================
@@ -717,6 +717,336 @@ static inline Floating abs(InterpState &S, const Floating
&In) {
return Output;
}
+static bool interp__builtin_ceil(InterpState &S, CodePtr OpPC,
+ const InterpFrame *Frame, const CallExpr
*Call,
+ unsigned BuiltinOp) {
+ const Floating &Val = S.Stk.pop<Floating>();
+ Floating Result = S.allocFloat(Val.getSemantics());
+ APFloat F = Val.getAPFloat();
+
+ llvm::RoundingMode RM;
+ switch (BuiltinOp) {
+ case Builtin::BI__builtin_ceil:
+ case Builtin::BI__builtin_ceilf:
+ case Builtin::BI__builtin_ceill:
+ case Builtin::BI__builtin_ceilf16:
+ case Builtin::BI__builtin_ceilf128:
+ RM = llvm::RoundingMode::TowardPositive;
+ break;
+ case Builtin::BI__builtin_floor:
+ case Builtin::BI__builtin_floorf:
+ case Builtin::BI__builtin_floorl:
+ case Builtin::BI__builtin_floorf16:
+ case Builtin::BI__builtin_floorf128:
+ RM = llvm::RoundingMode::TowardNegative;
+ break;
+ case Builtin::BI__builtin_trunc:
+ case Builtin::BI__builtin_truncf:
+ case Builtin::BI__builtin_truncl:
+ case Builtin::BI__builtin_truncf16:
+ case Builtin::BI__builtin_truncf128:
+ RM = llvm::RoundingMode::TowardZero;
+ break;
+ default:
+ llvm_unreachable("invalid builtin ID");
+ }
+
+ F.roundToIntegral(RM);
+ Result.copy(F);
+ S.Stk.push<Floating>(Result);
+ return true;
+}
+
+static bool interp__builtin_fdim(InterpState &S, CodePtr OpPC,
+ const InterpFrame *Frame,
+ const CallExpr *Call) {
+ const Floating &RHS = S.Stk.pop<Floating>();
+ const Floating &LHS = S.Stk.pop<Floating>();
+ APFloat L = LHS.getAPFloat();
+ APFloat R = RHS.getAPFloat();
+ APFloat Result(L.getSemantics());
+
+ if (L.compare(R) == APFloat::cmpGreaterThan) {
+ L.subtract(R, APFloat::rmNearestTiesToEven);
+ Result = L;
+ } else if (L.isNaN() || R.isNaN()) {
+ L.add(R, APFloat::rmNearestTiesToEven);
+ Result = L;
+ } else {
+ Result = APFloat::getZero(L.getSemantics());
+ }
+
+ Floating F = S.allocFloat(Result.getSemantics());
+ F.copy(Result);
+ S.Stk.push<Floating>(F);
+ return true;
+}
+
+static bool interp__builtin_fma(InterpState &S, CodePtr OpPC,
+ const InterpFrame *Frame,
+ const CallExpr *Call) {
+ const Floating &Z = S.Stk.pop<Floating>();
+ const Floating &Y = S.Stk.pop<Floating>();
+ const Floating &X = S.Stk.pop<Floating>();
+ APFloat Result = X.getAPFloat();
+
+ llvm::RoundingMode RM =
+ getRoundingMode(Call->getFPFeaturesInEffect(S.getLangOpts()));
+
+ Result.fusedMultiplyAdd(Y.getAPFloat(), Z.getAPFloat(), RM);
+ Floating F = S.allocFloat(Result.getSemantics());
+ F.copy(Result);
+ S.Stk.push<Floating>(F);
+ return true;
+}
+
+static bool interp__builtin_frexp(InterpState &S, CodePtr OpPC,
+ const InterpFrame *Frame,
+ const CallExpr *Call) {
+ const Pointer &Ptr = S.Stk.pop<Pointer>();
+ const Floating &Val = S.Stk.pop<Floating>();
+
+ int Exp = 0;
+ llvm::RoundingMode RM =
+ getRoundingMode(Call->getFPFeaturesInEffect(S.getLangOpts()));
+
+ APFloat F = frexp(Val.getAPFloat(), Exp, RM);
+
+ if (Ptr.isDummy())
+ return false;
+
+ QualType ExpType = Call->getArg(1)->getType()->getPointeeType();
+ PrimType ExpT = *S.getContext().classify(ExpType);
+ assignIntegral(S, Ptr, ExpT, APSInt::get(Exp));
+ Ptr.initialize();
+
+ Floating Result = S.allocFloat(F.getSemantics());
+ Result.copy(F);
+ S.Stk.push<Floating>(Result);
+ return true;
+}
+
+static bool interp__builtin_modf(InterpState &S, CodePtr OpPC,
+ const InterpFrame *Frame,
+ const CallExpr *Call) {
+ const Pointer &Ptr = S.Stk.pop<Pointer>();
+ const Floating &Val = S.Stk.pop<Floating>();
+ const APFloat &F = Val.getAPFloat();
+
+ APFloat Integral = F;
+ Integral.roundToIntegral(APFloat::rmTowardZero);
+
+ if (Ptr.isDummy())
+ return false;
+
+ Ptr.deref<Floating>().copy(Integral);
+ Ptr.initialize();
+
+ if (F.isInfinity()) {
+ Floating Fraction = S.allocFloat(F.getSemantics());
+ Fraction.copy(APFloat::getZero(F.getSemantics(), F.isNegative()));
+ S.Stk.push<Floating>(Fraction);
+ return true;
+ }
+
+ APFloat Fraction = F;
+ Fraction.subtract(Integral, APFloat::rmNearestTiesToEven);
+
+ Floating Result = S.allocFloat(Fraction.getSemantics());
+ Result.copy(Fraction);
+ S.Stk.push<Floating>(Result);
+ return true;
+}
+
+static bool interp__builtin_fmod(InterpState &S, CodePtr OpPC,
+ const InterpFrame *Frame, const CallExpr
*Call,
+ unsigned BuiltinOp) {
+ const Floating &RHS = S.Stk.pop<Floating>();
+ const Floating &LHS = S.Stk.pop<Floating>();
+ const APFloat &L = LHS.getAPFloat();
+ const APFloat &R = RHS.getAPFloat();
+ APFloat ResF = L;
+
+ if (BuiltinOp == Builtin::BI__builtin_remainder ||
+ BuiltinOp == Builtin::BI__builtin_remainderf ||
+ BuiltinOp == Builtin::BI__builtin_remainderl ||
+ BuiltinOp == Builtin::BI__builtin_remainderf128)
+ ResF.remainder(R);
+ else
+ ResF.mod(R);
+
+ Floating F = S.allocFloat(ResF.getSemantics());
+ F.copy(ResF);
+ S.Stk.push<Floating>(F);
+ return true;
+}
+
+static bool interp__builtin_nextafter(InterpState &S, CodePtr OpPC,
+ const InterpFrame *Frame,
+ const CallExpr *Call) {
+ const Floating &RHS = S.Stk.pop<Floating>();
+ const Floating &LHS = S.Stk.pop<Floating>();
+ const APFloat &L = LHS.getAPFloat();
+ const APFloat &R = RHS.getAPFloat();
+
+ if (L.isNaN()) {
+ S.Stk.push<Floating>(LHS);
+ return true;
+ }
+
+ if (R.isNaN()) {
----------------
Serosh-commits wrote:
i think this is needed for nexttoward(x, y) because y is a long double so if y
is NaN, we must convert it to the type of x before returning just to be
consistent
https://github.com/llvm/llvm-project/pull/194327
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
