FENV_ACCESS support for libm-style constrained intrinsics

[kpn]

Summary

This builds on D49865 to get #pragma STDC FENV_ACCESS ON to and used by AST handling of function calls to math intrinsics. This now emits constrained math intrinsics instead of the regular variety for the ones currently implemented in llvm.

This should be good for C. More work is needed for C++.

[kpn]

Rebase.

Correct obvious error with powi. Fix test and test both C and (partial) C++.

Ping.

[kpn]

Update based on feedback to D52839: add missing AST (de)serialization support.

Ping.

[kpn]

I believe Serge Pavlov has demonstrated a better way to do this.

include/clang/AST/Expr.h

 /// a subclass for overloaded operator calls that use operator syntax, e.g.,
 /// "str1 + str2" to resolve to a function call.
 class CallExpr : public Expr {
   enum { FN=0, PREARGS_START=1 };
   Stmt **SubExprs;
   unsigned NumArgs;
   SourceLocation RParenLoc;
 
+  // This is only meaningful for operations on floating point types and 0
+  // otherwise.
+  unsigned FPFeatures : 3;
+
   void updateDependenciesFromArg(Expr *Arg);
 
 protected:
   // These versions of the constructor are for derived classes.
   CallExpr(const ASTContext &C, StmtClass SC, Expr *fn,
            ArrayRef<Expr *> preargs, ArrayRef<Expr *> args, QualType t,
-           ExprValueKind VK, SourceLocation rparenloc);
+           ExprValueKind VK, SourceLocation rparenloc, FPOptions FPFeatures);
   CallExpr(const ASTContext &C, StmtClass SC, Expr *fn, ArrayRef<Expr *> args,
-           QualType t, ExprValueKind VK, SourceLocation rparenloc);
+           QualType t, ExprValueKind VK, SourceLocation rparenloc, 
+           FPOptions FPFeatures);
   CallExpr(const ASTContext &C, StmtClass SC, unsigned NumPreArgs,
            EmptyShell Empty);
 
   Stmt *getPreArg(unsigned i) {
     assert(i < getNumPreArgs() && "Prearg access out of range!");
     return SubExprs[PREARGS_START+i];
   }
   const Stmt *getPreArg(unsigned i) const {
     assert(i < getNumPreArgs() && "Prearg access out of range!");
     return SubExprs[PREARGS_START+i];
   }
   void setPreArg(unsigned i, Stmt *PreArg) {
     assert(i < getNumPreArgs() && "Prearg access out of range!");
     SubExprs[PREARGS_START+i] = PreArg;
   }
 
   unsigned getNumPreArgs() const { return CallExprBits.NumPreArgs; }
 
 public:
   CallExpr(const ASTContext& C, Expr *fn, ArrayRef<Expr*> args, QualType t,
-           ExprValueKind VK, SourceLocation rparenloc);
+           ExprValueKind VK, SourceLocation rparenloc, FPOptions FPFeatures);
 
   /// Build an empty call expression.
   CallExpr(const ASTContext &C, StmtClass SC, EmptyShell Empty);
 
   const Expr *getCallee() const { return cast<Expr>(SubExprs[FN]); }
   Expr *getCallee() { return cast<Expr>(SubExprs[FN]); }
   void setCallee(Expr *F) { SubExprs[FN] = F; }
 
child_range children() {
     return child_range(&SubExprs[0],
                        &SubExprs[0]+NumArgs+getNumPreArgs()+PREARGS_START);
   }
 
   const_child_range children() const {
     return const_child_range(&SubExprs[0], &SubExprs[0] + NumArgs +
                                                getNumPreArgs() + PREARGS_START);
   }
+
+  // Set the FP contractability status of this operator. Only meaningful for
+  // operations on floating point types.
+  void setFPFeatures(FPOptions F) { FPFeatures = F.getInt(); }
+
+  FPOptions getFPFeatures() const { return FPOptions(FPFeatures); }
+
+  // Get the FENV_ACCESS status of this operator. Only meaningful for
+  // operations on floating point types.
+  bool isFEnvAccessOn() const {
+    return FPOptions(FPFeatures).allowFEnvAccess();
+  }
 };
 
 /// Extra data stored in some MemberExpr objects.
 struct MemberExprNameQualifier {
   /// The nested-name-specifier that qualifies the name, including
   /// source-location information.
   NestedNameSpecifierLoc QualifierLoc;
 

include/clang/AST/ExprCXX.h

 /// function templates that were found by name lookup at template
 /// definition time.
 class CXXOperatorCallExpr : public CallExpr {
   /// The overloaded operator.
   OverloadedOperatorKind Operator;
 
   SourceRange Range;
 
-  // Only meaningful for floating point types.
-  FPOptions FPFeatures;
-
   SourceRange getSourceRangeImpl() const LLVM_READONLY;
 
 public:
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
   CXXOperatorCallExpr(ASTContext& C, OverloadedOperatorKind Op, Expr *fn,
                       ArrayRef<Expr*> args, QualType t, ExprValueKind VK,
                       SourceLocation operatorloc, FPOptions FPFeatures)
-      : CallExpr(C, CXXOperatorCallExprClass, fn, args, t, VK, operatorloc),
-        Operator(Op), FPFeatures(FPFeatures) {
+      : CallExpr(C, CXXOperatorCallExprClass, fn, args, t, VK, operatorloc, 
+                 FPFeatures),
+        Operator(Op) {
     Range = getSourceRangeImpl();
   }
 
   explicit CXXOperatorCallExpr(ASTContext& C, EmptyShell Empty)
       : CallExpr(C, CXXOperatorCallExprClass, Empty) {}
 
   /// Returns the kind of overloaded operator that this
   /// expression refers to.
public:
   SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
   SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
   SourceRange getSourceRange() const { return Range; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CXXOperatorCallExprClass;
   }
 
-  // Set the FP contractability status of this operator. Only meaningful for
-  // operations on floating point types.
-  void setFPFeatures(FPOptions F) { FPFeatures = F; }
-
-  FPOptions getFPFeatures() const { return FPFeatures; }
-
   // Get the FP contractability status of this operator. Only meaningful for
   // operations on floating point types.
   bool isFPContractableWithinStatement() const {
-    return FPFeatures.allowFPContractWithinStatement();
+    return getFPFeatures().allowFPContractWithinStatement();
   }
 };
 
 /// Represents a call to a member function that
 /// may be written either with member call syntax (e.g., "obj.func()"
 /// or "objptr->func()") or with normal function-call syntax
 /// ("func()") within a member function that ends up calling a member
 /// function. The callee in either case is a MemberExpr that contains
 /// both the object argument and the member function, while the
 /// arguments are the arguments within the parentheses (not including
 /// the object argument).
 class CXXMemberCallExpr : public CallExpr {
 public:
   CXXMemberCallExpr(ASTContext &C, Expr *fn, ArrayRef<Expr*> args,
                     QualType t, ExprValueKind VK, SourceLocation RP)
-      : CallExpr(C, CXXMemberCallExprClass, fn, args, t, VK, RP) {}
+      : CallExpr(C, CXXMemberCallExprClass, fn, args, t, VK, RP, FPOptions(0)) 
+        {}
 
   CXXMemberCallExpr(ASTContext &C, EmptyShell Empty)
       : CallExpr(C, CXXMemberCallExprClass, Empty) {}
 
   /// Retrieves the implicit object argument for the member call.
   ///
   /// For example, in "x.f(5)", this returns the sub-expression "x".
   Expr *getImplicitObjectArgument() const;

 class CUDAKernelCallExpr : public CallExpr {
 private:
   enum { CONFIG, END_PREARG };
 
 public:
   CUDAKernelCallExpr(ASTContext &C, Expr *fn, CallExpr *Config,
                      ArrayRef<Expr*> args, QualType t, ExprValueKind VK,
                      SourceLocation RP)
-      : CallExpr(C, CUDAKernelCallExprClass, fn, Config, args, t, VK, RP) {}
+      : CallExpr(C, CUDAKernelCallExprClass, fn, Config, args, t, VK, RP, 
+                 FPOptions(0)) {}
 
   CUDAKernelCallExpr(ASTContext &C, EmptyShell Empty)
       : CallExpr(C, CUDAKernelCallExprClass, END_PREARG, Empty) {}
 
   const CallExpr *getConfig() const {
     return cast_or_null<CallExpr>(getPreArg(CONFIG));
   }
   CallExpr *getConfig() { return cast_or_null<CallExpr>(getPreArg(CONFIG)); }

 
 public:
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
   UserDefinedLiteral(const ASTContext &C, Expr *Fn, ArrayRef<Expr*> Args,
                      QualType T, ExprValueKind VK, SourceLocation LitEndLoc,
                      SourceLocation SuffixLoc)
-      : CallExpr(C, UserDefinedLiteralClass, Fn, Args, T, VK, LitEndLoc),
+      : CallExpr(C, UserDefinedLiteralClass, Fn, Args, T, VK, LitEndLoc,
+                 FPOptions(0)),
         UDSuffixLoc(SuffixLoc) {}
 
   explicit UserDefinedLiteral(const ASTContext &C, EmptyShell Empty)
       : CallExpr(C, UserDefinedLiteralClass, Empty) {}
 
   /// The kind of literal operator which is invoked.
   enum LiteralOperatorKind {
     /// Raw form: operator "" X (const char *)

lib/AST/ASTImporter.cpp

return new (Importer.getToContext()) CXXOperatorCallExpr(
           Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, T,
           OCE->getValueKind(), Importer.Import(OCE->getRParenLoc()),
           OCE->getFPFeatures());
   }
 
   return new (Importer.getToContext())
     CallExpr(Importer.getToContext(), ToCallee,
              llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
-             Importer.Import(E->getRParenLoc()));
+             Importer.Import(E->getRParenLoc()), E->getFPFeatures());
 }
 
 Optional<LambdaCapture>
 ASTNodeImporter::ImportLambdaCapture(const LambdaCapture &From) {
   VarDecl *Var = nullptr;
   if (From.capturesVariable()) {
     Var = cast_or_null<VarDecl>(Importer.Import(From.getCapturedVar()));
     if (!Var)

lib/AST/Expr.cpp

 
 
 //===----------------------------------------------------------------------===//
 // Postfix Operators.
 //===----------------------------------------------------------------------===//
 
 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, Expr *fn,
                    ArrayRef<Expr *> preargs, ArrayRef<Expr *> args, QualType t,
-                   ExprValueKind VK, SourceLocation rparenloc)
+                   ExprValueKind VK, SourceLocation rparenloc,
+                   FPOptions FPFeatures)
     : Expr(SC, t, VK, OK_Ordinary, fn->isTypeDependent(),
            fn->isValueDependent(), fn->isInstantiationDependent(),
            fn->containsUnexpandedParameterPack()),
-      NumArgs(args.size()) {
+      NumArgs(args.size()), FPFeatures(FPFeatures.getInt()) {
 
   unsigned NumPreArgs = preargs.size();
   SubExprs = new (C) Stmt *[args.size()+PREARGS_START+NumPreArgs];
   SubExprs[FN] = fn;
   for (unsigned i = 0; i != NumPreArgs; ++i) {
     updateDependenciesFromArg(preargs[i]);
     SubExprs[i+PREARGS_START] = preargs[i];
   }
   for (unsigned i = 0; i != args.size(); ++i) {
     updateDependenciesFromArg(args[i]);
     SubExprs[i+PREARGS_START+NumPreArgs] = args[i];
   }
 
   CallExprBits.NumPreArgs = NumPreArgs;
   RParenLoc = rparenloc;
 }
 
 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, Expr *fn,
                    ArrayRef<Expr *> args, QualType t, ExprValueKind VK,
-                   SourceLocation rparenloc)
-    : CallExpr(C, SC, fn, ArrayRef<Expr *>(), args, t, VK, rparenloc) {}
+                   SourceLocation rparenloc, FPOptions FPFeatures)
+    : CallExpr(C, SC, fn, ArrayRef<Expr *>(), args, t, VK, rparenloc, 
+               FPFeatures) {}
 
 CallExpr::CallExpr(const ASTContext &C, Expr *fn, ArrayRef<Expr *> args,
-                   QualType t, ExprValueKind VK, SourceLocation rparenloc)
-    : CallExpr(C, CallExprClass, fn, ArrayRef<Expr *>(), args, t, VK, rparenloc) {
-}
+                   QualType t, ExprValueKind VK, SourceLocation rparenloc,
+                   FPOptions FPFeatures)
+    : CallExpr(C, CallExprClass, fn, ArrayRef<Expr *>(), args, t, VK, 
+               rparenloc, FPFeatures) {}
 
 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, EmptyShell Empty)
     : CallExpr(C, SC, /*NumPreArgs=*/0, Empty) {}
 
 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, unsigned NumPreArgs,
                    EmptyShell Empty)
   : Expr(SC, Empty), SubExprs(nullptr), NumArgs(0) {
   // FIXME: Why do we allocate this?

lib/Analysis/BodyFarm.cpp

SubExpr = M.makeImplicitCast(Call, Ty, CK_FunctionToPointerDecay);
              && Call->getType()->isPointerType()
              && Call->getType()->getPointeeType()->isFunctionType()){
     SubExpr = Call;
   } else {
     llvm_unreachable("Unexpected state");
   }
 
   return new (C)
-      CallExpr(C, SubExpr, CallArgs, C.VoidTy, VK_RValue, SourceLocation());
+      CallExpr(C, SubExpr, CallArgs, C.VoidTy, VK_RValue, SourceLocation(),
+               FPOptions());
 }
 
 static CallExpr *create_call_once_lambda_call(ASTContext &C, ASTMaker M,
                                               const ParmVarDecl *Callback,
                                               CXXRecordDecl *CallbackDecl,
                                               ArrayRef<Expr *> CallArgs) {
   assert(CallbackDecl != nullptr);
   assert(CallbackDecl->isLambda());
static Stmt *create_dispatch_once(ASTContext &C, const FunctionDecl *D) {
 
   // (1) Create the call.
   CallExpr *CE = new (C) CallExpr(
       /*ASTContext=*/C,
       /*StmtClass=*/M.makeLvalueToRvalue(/*Expr=*/Block),
       /*args=*/None,
       /*QualType=*/C.VoidTy,
       /*ExprValueType=*/VK_RValue,
-      /*SourceLocation=*/SourceLocation());
+      /*SourceLocation=*/SourceLocation(),
+      /*FPOptions=*/FPOptions());
 
   // (2) Create the assignment to the predicate.
   Expr *DoneValue =
       new (C) UnaryOperator(M.makeIntegerLiteral(0, C.LongTy), UO_Not, C.LongTy,
                             VK_RValue, OK_Ordinary, SourceLocation(),
                             /*CanOverflow*/false);
 
   BinaryOperator *B =
static Stmt *create_dispatch_sync(ASTContext &C, const FunctionDecl *D) {
   // void dispatch_sync(dispatch_queue_t queue, void (^block)(void)) {
   //   block();
   // }
   //
   ASTMaker M(C);
   DeclRefExpr *DR = M.makeDeclRefExpr(PV);
   ImplicitCastExpr *ICE = M.makeLvalueToRvalue(DR, Ty);
   CallExpr *CE = new (C) CallExpr(C, ICE, None, C.VoidTy, VK_RValue,
-                                  SourceLocation());
+                                  SourceLocation(), FPOptions());
   return CE;
 }
 
 static Stmt *create_OSAtomicCompareAndSwap(ASTContext &C, const FunctionDecl *D)
 {
   // There are exactly 3 arguments.
   if (D->param_size() != 3)
     return nullptr;

lib/CodeGen/CGBuiltin.cpp

 #include "clang/Analysis/Analyses/OSLog.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/InlineAsm.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/TargetParser.h"
 #include <sstream>
 
 using namespace clang;
if (ReturnBool)
     return CGF.Builder.CreateZExt(CGF.Builder.CreateExtractValue(Pair, 1),
                                   CGF.ConvertType(E->getType()));
   else
     // Extract old value and emit it using the same type as compare value.
     return EmitFromInt(CGF, CGF.Builder.CreateExtractValue(Pair, 0), T,
                        ValueType);
 }
 
+static void getConstrainedMetadata(CodeGenFunction &CGF,
+                                   llvm::Value **RoundingV,
+                                   llvm::Value **ExceptV)
+{
+  if (RoundingV) {
+    auto *RoundingMD = MDString::get(CGF.getLLVMContext(),
+                                          "round.dynamic");
+    *RoundingV = MetadataAsValue::get(CGF.getLLVMContext(), RoundingMD);
+  }
+
+  if (ExceptV) {
+    auto *ExceptMD = MDString::get(CGF.getLLVMContext(),
+                                          "fpexcept.strict");
+    *ExceptV = MetadataAsValue::get(CGF.getLLVMContext(), ExceptMD);
+  }
+}
+
+// Emit a simple mangled intrinsic that has 1 argument and a return type
+// matching the argument type.
+// Include metadata needed since this is for a constrained FP intrinsic.
+static Value *emitUnaryConstrainedFPBuiltin(CodeGenFunction &CGF,
+                               const CallExpr *E,
+                               unsigned IntrinsicID) {
+  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
+  llvm::Value *Rounding;
+  llvm::Value *Except;
+
+  getConstrainedMetadata(CGF, &Rounding, &Except);
+
+  Value *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
+  return CGF.Builder.CreateCall(F, { Src0, Rounding, Except });
+}  
+
+// Emit an intrinsic that has 2 operands of the same type as its result.
+// Include metadata needed since this is for a constrained FP intrinsic.
+static Value *emitBinaryConstrainedFPBuiltin(CodeGenFunction &CGF,
+                                const CallExpr *E,
+                                unsigned IntrinsicID) {
+  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
+  llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
+  llvm::Value *Rounding;
+  llvm::Value *Except;
+
+  getConstrainedMetadata(CGF, &Rounding, &Except);
+
+  Value *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
+  return CGF.Builder.CreateCall(F, { Src0, Src1, Rounding, Except });
+}
+
+// Emit an intrinsic that has 3 operands of the same type as its result.
+// Include metadata needed since this is for a constrained FP intrinsic.
+static Value *emitTernaryConstrainedFPBuiltin(CodeGenFunction &CGF,
+                                 const CallExpr *E,
+                                 unsigned IntrinsicID) {
+  llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
+  llvm::Value *Src1 = CGF.EmitScalarExpr(E->getArg(1));
+  llvm::Value *Src2 = CGF.EmitScalarExpr(E->getArg(2));
+  llvm::Value *Rounding;
+  llvm::Value *Except;
+
+  getConstrainedMetadata(CGF, &Rounding, &Except);
+
+  Value *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
+  return CGF.Builder.CreateCall(F, { Src0, Src1, Src2, Rounding, Except });
+}
+
 // Emit a simple mangled intrinsic that has 1 argument and a return type
 // matching the argument type.
 static Value *emitUnaryBuiltin(CodeGenFunction &CGF,
                                const CallExpr *E,
                                unsigned IntrinsicID) {
   llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
 
   Value *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
case Builtin::BI__builtin_copysignf128:
       return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::copysign));
 
     case Builtin::BIcos:
     case Builtin::BIcosf:
     case Builtin::BIcosl:
     case Builtin::BI__builtin_cos:
     case Builtin::BI__builtin_cosf:
     case Builtin::BI__builtin_cosl:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitUnaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_cos));
+      else
         return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::cos));
 
     case Builtin::BIexp:
     case Builtin::BIexpf:
     case Builtin::BIexpl:
     case Builtin::BI__builtin_exp:
     case Builtin::BI__builtin_expf:
     case Builtin::BI__builtin_expl:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitUnaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_exp));
+      else
         return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::exp));
 
     case Builtin::BIexp2:
     case Builtin::BIexp2f:
     case Builtin::BIexp2l:
     case Builtin::BI__builtin_exp2:
     case Builtin::BI__builtin_exp2f:
     case Builtin::BI__builtin_exp2l:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitUnaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_exp2));
+      else
         return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::exp2));
 
     case Builtin::BIfabs:
     case Builtin::BIfabsf:
     case Builtin::BIfabsl:
     case Builtin::BI__builtin_fabs:
     case Builtin::BI__builtin_fabsf:
     case Builtin::BI__builtin_fabsl:
     case Builtin::BI__builtin_fabsf128:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::fabs));
 
     case Builtin::BIfloor:
     case Builtin::BIfloorf:
     case Builtin::BIfloorl:
     case Builtin::BI__builtin_floor:
     case Builtin::BI__builtin_floorf:
     case Builtin::BI__builtin_floorl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::floor));
 
     case Builtin::BIfma:
     case Builtin::BIfmaf:
     case Builtin::BIfmal:
     case Builtin::BI__builtin_fma:
     case Builtin::BI__builtin_fmaf:
     case Builtin::BI__builtin_fmal:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitTernaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_fma));
+      else
         return RValue::get(emitTernaryBuiltin(*this, E, Intrinsic::fma));
 
     case Builtin::BIfmax:
     case Builtin::BIfmaxf:
     case Builtin::BIfmaxl:
     case Builtin::BI__builtin_fmax:
     case Builtin::BI__builtin_fmaxf:
     case Builtin::BI__builtin_fmaxl:
       return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::maxnum));
if (FD->hasAttr<ConstAttr>()) {
     }
 
     case Builtin::BIlog:
     case Builtin::BIlogf:
     case Builtin::BIlogl:
     case Builtin::BI__builtin_log:
     case Builtin::BI__builtin_logf:
     case Builtin::BI__builtin_logl:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitUnaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_log));
+      else
         return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log));
 
     case Builtin::BIlog10:
     case Builtin::BIlog10f:
     case Builtin::BIlog10l:
     case Builtin::BI__builtin_log10:
     case Builtin::BI__builtin_log10f:
     case Builtin::BI__builtin_log10l:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitUnaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_log10));
+      else
         return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log10));
 
     case Builtin::BIlog2:
     case Builtin::BIlog2f:
     case Builtin::BIlog2l:
     case Builtin::BI__builtin_log2:
     case Builtin::BI__builtin_log2f:
     case Builtin::BI__builtin_log2l:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitUnaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_log2));
+      else
         return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log2));
 
     case Builtin::BInearbyint:
     case Builtin::BInearbyintf:
     case Builtin::BInearbyintl:
     case Builtin::BI__builtin_nearbyint:
     case Builtin::BI__builtin_nearbyintf:
     case Builtin::BI__builtin_nearbyintl:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitUnaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_nearbyint));
+      else
         return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::nearbyint));
 
     case Builtin::BIpow:
     case Builtin::BIpowf:
     case Builtin::BIpowl:
     case Builtin::BI__builtin_pow:
     case Builtin::BI__builtin_powf:
     case Builtin::BI__builtin_powl:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitBinaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_pow));
+      else
         return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::pow));
 
     case Builtin::BIrint:
     case Builtin::BIrintf:
     case Builtin::BIrintl:
     case Builtin::BI__builtin_rint:
     case Builtin::BI__builtin_rintf:
     case Builtin::BI__builtin_rintl:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitUnaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_rint));
+      else
         return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::rint));
 
     case Builtin::BIround:
     case Builtin::BIroundf:
     case Builtin::BIroundl:
     case Builtin::BI__builtin_round:
     case Builtin::BI__builtin_roundf:
     case Builtin::BI__builtin_roundl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::round));
 
     case Builtin::BIsin:
     case Builtin::BIsinf:
     case Builtin::BIsinl:
     case Builtin::BI__builtin_sin:
     case Builtin::BI__builtin_sinf:
     case Builtin::BI__builtin_sinl:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitUnaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_sin));
+      else
         return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::sin));
 
     case Builtin::BIsqrt:
     case Builtin::BIsqrtf:
     case Builtin::BIsqrtl:
     case Builtin::BI__builtin_sqrt:
     case Builtin::BI__builtin_sqrtf:
     case Builtin::BI__builtin_sqrtl:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitUnaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_sqrt));
+      else
         return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::sqrt));
 
     case Builtin::BItrunc:
     case Builtin::BItruncf:
     case Builtin::BItruncl:
     case Builtin::BI__builtin_trunc:
     case Builtin::BI__builtin_truncf:
     case Builtin::BI__builtin_truncl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::trunc));
case Builtin::BI__builtin_unreachable: {
     // We do need to preserve an insertion point.
     EmitBlock(createBasicBlock("unreachable.cont"));
 
     return RValue::get(nullptr);
   }
 
   case Builtin::BI__builtin_powi:
   case Builtin::BI__builtin_powif:
-  case Builtin::BI__builtin_powil: {
-    Value *Base = EmitScalarExpr(E->getArg(0));
-    Value *Exponent = EmitScalarExpr(E->getArg(1));
-    llvm::Type *ArgType = Base->getType();
-    Value *F = CGM.getIntrinsic(Intrinsic::powi, ArgType);
-    return RValue::get(Builder.CreateCall(F, {Base, Exponent}));
-  }
+  case Builtin::BI__builtin_powil:
+      if (E->isFEnvAccessOn())
+        return RValue::get(emitBinaryConstrainedFPBuiltin(*this, E, 
+                           Intrinsic::experimental_constrained_powi));
+      else
+        return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::powi));
 
   case Builtin::BI__builtin_isgreater:
   case Builtin::BI__builtin_isgreaterequal:
   case Builtin::BI__builtin_isless:
   case Builtin::BI__builtin_islessequal:
   case Builtin::BI__builtin_islessgreater:
   case Builtin::BI__builtin_isunordered: {
     // Ordered comparisons: we know the arguments to these are matching scalar

lib/Frontend/Rewrite/RewriteModernObjC.cpp

RewriteModernObjC::SynthesizeCallToFunctionDecl(FunctionDecl *FD,
   ImplicitCastExpr *ICE =
     ImplicitCastExpr::Create(*Context, pToFunc, CK_FunctionToPointerDecay,
                              DRE, nullptr, VK_RValue);
 
   const FunctionType *FT = msgSendType->getAs<FunctionType>();
 
   CallExpr *Exp =  new (Context) CallExpr(*Context, ICE, Args,
                                           FT->getCallResultType(*Context),
-                                          VK_RValue, EndLoc);
+                                          VK_RValue, EndLoc, FPOptions());
   return Exp;
 }
 
 static bool scanForProtocolRefs(const char *startBuf, const char *endBuf,
                                 const char *&startRef, const char *&endRef) {
   while (startBuf < endBuf) {
     if (*startBuf == '<')
       startRef = startBuf; // mark the start.
Stmt *RewriteModernObjC::RewriteObjCBoxedExpr(ObjCBoxedExpr *Exp) {
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                   cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
 
   const FunctionType *FT = msgSendType->getAs<FunctionType>();
   CallExpr *CE = new (Context)
-      CallExpr(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, EndLoc);
+      CallExpr(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, EndLoc,
+               FPOptions());
   ReplaceStmt(Exp, CE);
   return CE;
 }
 
 Stmt *RewriteModernObjC::RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp) {
   // synthesize declaration of helper functions needed in this routine.
   if (!SelGetUidFunctionDecl)
     SynthSelGetUidFunctionDecl();
Stmt *RewriteModernObjC::RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp) {
   Expr *count = IntegerLiteral::Create(*Context,
                                        llvm::APInt(UnsignedIntSize, NumElements),
                                        Context->UnsignedIntTy, SourceLocation());
   InitExprs.push_back(count);
   for (unsigned i = 0; i < NumElements; i++)
     InitExprs.push_back(Exp->getElement(i));
   Expr *NSArrayCallExpr =
     new (Context) CallExpr(*Context, NSArrayDRE, InitExprs,
-                           NSArrayFType, VK_LValue, SourceLocation());
+                           NSArrayFType, VK_LValue, SourceLocation(),
+                           FPOptions());
 
   FieldDecl *ARRFD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
                                     SourceLocation(),
                                     &Context->Idents.get("arr"),
                                     Context->getPointerType(Context->VoidPtrTy),
                                     nullptr, /*BitWidth=*/nullptr,
                                     /*Mutable=*/true, ICIS_NoInit);
   MemberExpr *ArrayLiteralME = new (Context)
Stmt *RewriteModernObjC::RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp) {
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                   cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
 
   const FunctionType *FT = msgSendType->getAs<FunctionType>();
   CallExpr *CE = new (Context)
-      CallExpr(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, EndLoc);
+      CallExpr(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, EndLoc,
+               FPOptions());
   ReplaceStmt(Exp, CE);
   return CE;
 }
 
 Stmt *RewriteModernObjC::RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp) {
   // synthesize declaration of helper functions needed in this routine.
   if (!SelGetUidFunctionDecl)
     SynthSelGetUidFunctionDecl();
for (unsigned i = 0; i < NumElements; i++) {
     ObjCDictionaryElement Element = Exp->getKeyValueElement(i);
     KeyExprs.push_back(Element.Key);
     ValueExprs.push_back(Element.Value);
   }
 
   // (const id [])objects
   Expr *NSValueCallExpr =
     new (Context) CallExpr(*Context, NSDictDRE, ValueExprs,
-                           NSDictFType, VK_LValue, SourceLocation());
+                           NSDictFType, VK_LValue, SourceLocation(), 
+                           FPOptions());
 
   FieldDecl *ARRFD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
                                        SourceLocation(),
                                        &Context->Idents.get("arr"),
                                        Context->getPointerType(Context->VoidPtrTy),
                                        nullptr, /*BitWidth=*/nullptr,
                                        /*Mutable=*/true, ICIS_NoInit);
   MemberExpr *DictLiteralValueME = new (Context)
       MemberExpr(NSValueCallExpr, false, SourceLocation(), ARRFD,
                  SourceLocation(), ARRFD->getType(), VK_LValue, OK_Ordinary);
   QualType ConstIdT = Context->getObjCIdType().withConst();
   CStyleCastExpr * DictValueObjects =
     NoTypeInfoCStyleCastExpr(Context,
                              Context->getPointerType(ConstIdT),
                              CK_BitCast,
                              DictLiteralValueME);
   // (const id <NSCopying> [])keys
   Expr *NSKeyCallExpr =
     new (Context) CallExpr(*Context, NSDictDRE, KeyExprs,
-                           NSDictFType, VK_LValue, SourceLocation());
+                           NSDictFType, VK_LValue, SourceLocation(),
+                           FPOptions());
 
   MemberExpr *DictLiteralKeyME = new (Context)
       MemberExpr(NSKeyCallExpr, false, SourceLocation(), ARRFD,
                  SourceLocation(), ARRFD->getType(), VK_LValue, OK_Ordinary);
 
   CStyleCastExpr * DictKeyObjects =
     NoTypeInfoCStyleCastExpr(Context,
                              Context->getPointerType(ConstIdT),
Stmt *RewriteModernObjC::RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp) {
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                   cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
 
   const FunctionType *FT = msgSendType->getAs<FunctionType>();
   CallExpr *CE = new (Context)
-      CallExpr(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, EndLoc);
+      CallExpr(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, EndLoc,
+               FPOptions());
   ReplaceStmt(Exp, CE);
   return CE;
 }
 
 // struct __rw_objc_super {
 //   struct objc_object *object; struct objc_object *superClass;
 // };
 QualType RewriteModernObjC::getSuperStructType() {
Expr *RewriteModernObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
   // AST for __Stretn(receiver, args).s;
   IdentifierInfo *ID = &Context->Idents.get(name);
   FunctionDecl *FD = FunctionDecl::Create(*Context, TUDecl, SourceLocation(),
                                           SourceLocation(), ID, castType,
                                           nullptr, SC_Extern, false, false);
   DeclRefExpr *DRE = new (Context) DeclRefExpr(FD, false, castType, VK_RValue,
                                                SourceLocation());
   CallExpr *STCE = new (Context) CallExpr(*Context, DRE, MsgExprs,
-                                          castType, VK_LValue, SourceLocation());
+                                          castType, VK_LValue, 
+                                          SourceLocation(), FPOptions());
 
   FieldDecl *FieldD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
                                     SourceLocation(),
                                     &Context->Idents.get("s"),
                                     returnType, nullptr,
                                     /*BitWidth=*/nullptr,
                                     /*Mutable=*/true, ICIS_NoInit);
   MemberExpr *ME = new (Context)
case ObjCMessageExpr::SuperClass: {
     if (LangOpts.MicrosoftExt) {
       SynthSuperConstructorFunctionDecl();
       // Simulate a constructor call...
       DeclRefExpr *DRE = new (Context) DeclRefExpr(SuperConstructorFunctionDecl,
                                                    false, superType, VK_LValue,
                                                    SourceLocation());
       SuperRep = new (Context) CallExpr(*Context, DRE, InitExprs,
                                         superType, VK_LValue,
-                                        SourceLocation());
+                                        SourceLocation(), FPOptions());
       // The code for super is a little tricky to prevent collision with
       // the structure definition in the header. The rewriter has it's own
       // internal definition (__rw_objc_super) that is uses. This is why
       // we need the cast below. For example:
       // (struct __rw_objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
       //
       SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
                                Context->getPointerType(SuperRep->getType()),
case ObjCMessageExpr::SuperInstance:{
 
     if (LangOpts.MicrosoftExt) {
       SynthSuperConstructorFunctionDecl();
       // Simulate a constructor call...
       DeclRefExpr *DRE = new (Context) DeclRefExpr(SuperConstructorFunctionDecl,
                                                    false, superType, VK_LValue,
                                                    SourceLocation());
       SuperRep = new (Context) CallExpr(*Context, DRE, InitExprs,
-                                        superType, VK_LValue, SourceLocation());
+                                        superType, VK_LValue, SourceLocation(),
+                                        FPOptions());
       // The code for super is a little tricky to prevent collision with
       // the structure definition in the header. The rewriter has it's own
       // internal definition (__rw_objc_super) that is uses. This is why
       // we need the cast below. For example:
       // (struct __rw_objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
       //
       SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
                                Context->getPointerType(SuperRep->getType()),
Stmt *RewriteModernObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                   cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
 
   const FunctionType *FT = msgSendType->getAs<FunctionType>();
   CallExpr *CE = new (Context)
-      CallExpr(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, EndLoc);
+      CallExpr(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, EndLoc,
+               FPOptions());
   Stmt *ReplacingStmt = CE;
   if (MsgSendStretFlavor) {
     // We have the method which returns a struct/union. Must also generate
     // call to objc_msgSend_stret and hang both varieties on a conditional
     // expression which dictate which one to envoke depending on size of
     // method's return type.
 
     Expr *STCE = SynthMsgSendStretCallExpr(MsgSendStretFlavor,
Stmt *RewriteModernObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
   BlkExprs.push_back(BlkCast);
   // Add the user arguments.
   for (CallExpr::arg_iterator I = Exp->arg_begin(),
        E = Exp->arg_end(); I != E; ++I) {
     BlkExprs.push_back(*I);
   }
   CallExpr *CE = new (Context) CallExpr(*Context, PE, BlkExprs,
                                         Exp->getType(), VK_RValue,
-                                        SourceLocation());
+                                        SourceLocation(), FPOptions());
   return CE;
 }
 
 // We need to return the rewritten expression to handle cases where the
 // DeclRefExpr is embedded in another expression being rewritten.
 // For example:
 //
 // int main() {
if (ImportedBlockDecls.size()) {
     int flag = (BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR);
     unsigned IntSize =
       static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
     Expr *FlagExp = IntegerLiteral::Create(*Context, llvm::APInt(IntSize, flag),
                                            Context->IntTy, SourceLocation());
     InitExprs.push_back(FlagExp);
   }
   NewRep = new (Context) CallExpr(*Context, DRE, InitExprs,
-                                  FType, VK_LValue, SourceLocation());
+                                  FType, VK_LValue, SourceLocation(), 
+                                  FPOptions());
 
   if (GlobalBlockExpr) {
     assert (!GlobalConstructionExp &&
             "SynthBlockInitExpr - GlobalConstructionExp must be null");
     GlobalConstructionExp = NewRep;
     NewRep = DRE;
   }
 

lib/Frontend/Rewrite/RewriteObjC.cpp

RewriteObjC::SynthesizeCallToFunctionDecl(FunctionDecl *FD,
   ImplicitCastExpr *ICE =
     ImplicitCastExpr::Create(*Context, pToFunc, CK_FunctionToPointerDecay,
                              DRE, nullptr, VK_RValue);
 
   const FunctionType *FT = msgSendType->getAs<FunctionType>();
 
   CallExpr *Exp = new (Context) CallExpr(*Context, ICE, Args,
                                          FT->getCallResultType(*Context),
-                                         VK_RValue, EndLoc);
+                                         VK_RValue, EndLoc, FPOptions());
   return Exp;
 }
 
 static bool scanForProtocolRefs(const char *startBuf, const char *endBuf,
                                 const char *&startRef, const char *&endRef) {
   while (startBuf < endBuf) {
     if (*startBuf == '<')
       startRef = startBuf; // mark the start.
CallExpr *RewriteObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                             cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), cast);
 
   const FunctionType *FT = msgSendType->getAs<FunctionType>();
   CallExpr *STCE = new (Context) CallExpr(
-      *Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, SourceLocation());
+      *Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, SourceLocation(),
+      FPOptions());
   return STCE;
 }
 
 Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
                                     SourceLocation StartLoc,
                                     SourceLocation EndLoc) {
   if (!SelGetUidFunctionDecl)
     SynthSelGetUidFunctionDecl();
case ObjCMessageExpr::SuperClass: {
     if (LangOpts.MicrosoftExt) {
       SynthSuperConstructorFunctionDecl();
       // Simulate a constructor call...
       DeclRefExpr *DRE = new (Context) DeclRefExpr(SuperConstructorFunctionDecl,
                                                    false, superType, VK_LValue,
                                                    SourceLocation());
       SuperRep = new (Context) CallExpr(*Context, DRE, InitExprs,
                                         superType, VK_LValue,
-                                        SourceLocation());
+                                        SourceLocation(), FPOptions());
       // The code for super is a little tricky to prevent collision with
       // the structure definition in the header. The rewriter has it's own
       // internal definition (__rw_objc_super) that is uses. This is why
       // we need the cast below. For example:
       // (struct objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
       //
       SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
                                Context->getPointerType(SuperRep->getType()),
case ObjCMessageExpr::SuperInstance:{
 
     if (LangOpts.MicrosoftExt) {
       SynthSuperConstructorFunctionDecl();
       // Simulate a constructor call...
       DeclRefExpr *DRE = new (Context) DeclRefExpr(SuperConstructorFunctionDecl,
                                                    false, superType, VK_LValue,
                                                    SourceLocation());
       SuperRep = new (Context) CallExpr(*Context, DRE, InitExprs,
-                                        superType, VK_LValue, SourceLocation());
+                                        superType, VK_LValue, SourceLocation(),
+                                        FPOptions());
       // The code for super is a little tricky to prevent collision with
       // the structure definition in the header. The rewriter has it's own
       // internal definition (__rw_objc_super) that is uses. This is why
       // we need the cast below. For example:
       // (struct objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
       //
       SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
                                Context->getPointerType(SuperRep->getType()),
Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
   cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                   cast);
 
   // Don't forget the parens to enforce the proper binding.
   ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
 
   const FunctionType *FT = msgSendType->getAs<FunctionType>();
   CallExpr *CE = new (Context)
-      CallExpr(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, EndLoc);
+      CallExpr(*Context, PE, MsgExprs, FT->getReturnType(), VK_RValue, EndLoc,
+               FPOptions());
   Stmt *ReplacingStmt = CE;
   if (MsgSendStretFlavor) {
     // We have the method which returns a struct/union. Must also generate
     // call to objc_msgSend_stret and hang both varieties on a conditional
     // expression which dictate which one to envoke depending on size of
     // method's return type.
 
     CallExpr *STCE = SynthMsgSendStretCallExpr(MsgSendStretFlavor,
Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
   BlkExprs.push_back(BlkCast);
   // Add the user arguments.
   for (CallExpr::arg_iterator I = Exp->arg_begin(),
        E = Exp->arg_end(); I != E; ++I) {
     BlkExprs.push_back(*I);
   }
   CallExpr *CE = new (Context) CallExpr(*Context, PE, BlkExprs,
                                         Exp->getType(), VK_RValue,
-                                        SourceLocation());
+                                        SourceLocation(), FPOptions());
   return CE;
 }
 
 // We need to return the rewritten expression to handle cases where the
 // BlockDeclRefExpr is embedded in another expression being rewritten.
 // For example:
 //
 // int main() {
if (ImportedBlockDecls.size()) {
     int flag = (BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR);
     unsigned IntSize =
       static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
     Expr *FlagExp = IntegerLiteral::Create(*Context, llvm::APInt(IntSize, flag),
                                            Context->IntTy, SourceLocation());
     InitExprs.push_back(FlagExp);
   }
   NewRep = new (Context) CallExpr(*Context, DRE, InitExprs,
-                                  FType, VK_LValue, SourceLocation());
+                                  FType, VK_LValue, SourceLocation(),
+                                  FPOptions());
   NewRep = new (Context) UnaryOperator(NewRep, UO_AddrOf,
                              Context->getPointerType(NewRep->getType()),
                              VK_RValue, OK_Ordinary, SourceLocation(), false);
   NewRep = NoTypeInfoCStyleCastExpr(Context, FType, CK_BitCast,
                                     NewRep);
   BlockDeclRefs.clear();
   BlockByRefDecls.clear();
   BlockByRefDeclsPtrSet.clear();

lib/Sema/SemaExpr.cpp

if (isa<CXXPseudoDestructorExpr>(Fn)) {
         // Pseudo-destructor calls should not have any arguments.
         Diag(Fn->getBeginLoc(), diag::err_pseudo_dtor_call_with_args)
             << FixItHint::CreateRemoval(
                    SourceRange(ArgExprs.front()->getBeginLoc(),
                                ArgExprs.back()->getEndLoc()));
       }
 
       return new (Context)
-          CallExpr(Context, Fn, None, Context.VoidTy, VK_RValue, RParenLoc);
+          CallExpr(Context, Fn, None, Context.VoidTy, VK_RValue, RParenLoc,
+                   FPFeatures);
     }
     if (Fn->getType() == Context.PseudoObjectTy) {
       ExprResult result = CheckPlaceholderExpr(Fn);
       if (result.isInvalid()) return ExprError();
       Fn = result.get();
     }
 
     // Determine whether this is a dependent call inside a C++ template,
     // in which case we won't do any semantic analysis now.
     if (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs)) {
       if (ExecConfig) {
         return new (Context) CUDAKernelCallExpr(
             Context, Fn, cast<CallExpr>(ExecConfig), ArgExprs,
             Context.DependentTy, VK_RValue, RParenLoc);
       } else {
 
         tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(
             *this, dyn_cast<UnresolvedMemberExpr>(Fn->IgnoreParens()),
             Fn->getBeginLoc());
 
         return new (Context) CallExpr(
-            Context, Fn, ArgExprs, Context.DependentTy, VK_RValue, RParenLoc);
+            Context, Fn, ArgExprs, Context.DependentTy, VK_RValue, RParenLoc,
+            FPFeatures);
       }
     }
 
     // Determine whether this is a call to an object (C++ [over.call.object]).
     if (Fn->getType()->isRecordType())
       return BuildCallToObjectOfClassType(Scope, Fn, LParenLoc, ArgExprs,
                                           RParenLoc);
 
ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
   // Check for overloaded calls.  This can happen even in C due to extensions.
   if (Fn->getType() == Context.OverloadTy) {
     OverloadExpr::FindResult find = OverloadExpr::find(Fn);
 
     // We aren't supposed to apply this logic if there's an '&' involved.
     if (!find.HasFormOfMemberPointer) {
       if (Expr::hasAnyTypeDependentArguments(ArgExprs))
         return new (Context) CallExpr(
-            Context, Fn, ArgExprs, Context.DependentTy, VK_RValue, RParenLoc);
+            Context, Fn, ArgExprs, Context.DependentTy, VK_RValue, RParenLoc,
+            FPFeatures);
       OverloadExpr *ovl = find.Expression;
       if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(ovl))
         return BuildOverloadedCallExpr(
             Scope, Fn, ULE, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
             /*AllowTypoCorrection=*/true, find.IsAddressOfOperand);
       return BuildCallToMemberFunction(Scope, Fn, LParenLoc, ArgExprs,
                                        RParenLoc);
     }
Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
   CallExpr *TheCall;
   if (Config)
     TheCall = new (Context) CUDAKernelCallExpr(Context, Fn,
                                                cast<CallExpr>(Config), Args,
                                                Context.BoolTy, VK_RValue,
                                                RParenLoc);
   else
     TheCall = new (Context) CallExpr(Context, Fn, Args, Context.BoolTy,
-                                     VK_RValue, RParenLoc);
+                                     VK_RValue, RParenLoc, FPFeatures);
 
   if (!getLangOpts().CPlusPlus) {
     // C cannot always handle TypoExpr nodes in builtin calls and direct
     // function calls as their argument checking don't necessarily handle
     // dependent types properly, so make sure any TypoExprs have been
     // dealt with.
     ExprResult Result = CorrectDelayedTyposInExpr(TheCall);
     if (!Result.isUsable()) return ExprError();
case BuiltinType::BuiltinFn: {
     // Accept __noop without parens by implicitly converting it to a call expr.
     auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts());
     if (DRE) {
       auto *FD = cast<FunctionDecl>(DRE->getDecl());
       if (FD->getBuiltinID() == Builtin::BI__noop) {
         E = ImpCastExprToType(E, Context.getPointerType(FD->getType()),
                               CK_BuiltinFnToFnPtr).get();
         return new (Context) CallExpr(Context, E, None, Context.IntTy,
-                                      VK_RValue, SourceLocation());
+                                      VK_RValue, SourceLocation(), FPFeatures);
       }
     }
 
     Diag(E->getBeginLoc(), diag::err_builtin_fn_use);
     return ExprError();
   }
 
   // Expressions of unknown type.

lib/Sema/SemaOpenMP.cpp

if (DeclareReductionRef.isUsable()) {
       FunctionProtoType::ExtProtoInfo EPI;
       QualType Params[] = {PtrRedTy, PtrRedTy};
       QualType FnTy = Context.getFunctionType(Context.VoidTy, Params, EPI);
       auto *OVE = new (Context) OpaqueValueExpr(
           ELoc, Context.getPointerType(FnTy), VK_RValue, OK_Ordinary,
           S.DefaultLvalueConversion(DeclareReductionRef.get()).get());
       Expr *Args[] = {LHS.get(), RHS.get()};
       ReductionOp = new (Context)
-          CallExpr(Context, OVE, Args, Context.VoidTy, VK_RValue, ELoc);
+          CallExpr(Context, OVE, Args, Context.VoidTy, VK_RValue, ELoc, 
+                   S.FPFeatures);
     } else {
       ReductionOp = S.BuildBinOp(
           Stack->getCurScope(), ReductionId.getBeginLoc(), BOK, LHSDRE, RHSDRE);
       if (ReductionOp.isUsable()) {
         if (BOK != BO_LT && BOK != BO_GT) {
           ReductionOp =
               S.BuildBinOp(Stack->getCurScope(), ReductionId.getBeginLoc(),
                            BO_Assign, LHSDRE, ReductionOp.get());

lib/Sema/SemaOverload.cpp

Sema::AddConversionCandidate(CXXConversionDecl *Conversion,
 
   ExprValueKind VK = Expr::getValueKindForType(ConversionType);
 
   // Note that it is safe to allocate CallExpr on the stack here because
   // there are 0 arguments (i.e., nothing is allocated using ASTContext's
   // allocator).
   QualType CallResultType = ConversionType.getNonLValueExprType(Context);
   CallExpr Call(Context, &ConversionFn, None, CallResultType, VK,
-                From->getBeginLoc());
+                From->getBeginLoc(), FPFeatures);
   ImplicitConversionSequence ICS =
     TryCopyInitialization(*this, &Call, ToType,
                           /*SuppressUserConversions=*/true,
                           /*InOverloadResolution=*/false,
                           /*AllowObjCWritebackConversion=*/false);
 
   switch (ICS.getKind()) {
   case ImplicitConversionSequence::StandardConversion:
if (getLangOpts().MSVCCompat &&
     if (CandidateSet->empty() ||
         CandidateSet->BestViableFunction(*this, Fn->getBeginLoc(), Best) ==
             OR_No_Viable_Function) {
       // In Microsoft mode, if we are inside a template class member function then
       // create a type dependent CallExpr. The goal is to postpone name lookup
       // to instantiation time to be able to search into type dependent base
       // classes.
       CallExpr *CE = new (Context) CallExpr(
-          Context, Fn, Args, Context.DependentTy, VK_RValue, RParenLoc);
+          Context, Fn, Args, Context.DependentTy, VK_RValue, RParenLoc,
+          FPFeatures);
       CE->setTypeDependent(true);
       CE->setValueDependent(true);
       CE->setInstantiationDependent(true);
       *Result = CE;
       return true;
     }
   }
 
if (BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
     if (CheckOtherCall(call, proto))
       return ExprError();
 
     return MaybeBindToTemporary(call);
   }
 
   if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
     return new (Context)
-        CallExpr(Context, MemExprE, Args, Context.VoidTy, VK_RValue, RParenLoc);
+        CallExpr(Context, MemExprE, Args, Context.VoidTy, VK_RValue, RParenLoc,
+                 FPFeatures);
 
   UnbridgedCastsSet UnbridgedCasts;
   if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
     return ExprError();
 
   MemberExpr *MemExpr;
   CXXMethodDecl *Method = nullptr;
   DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_public);

lib/Sema/TreeTransform.h

Expr *Callee = new (SemaRef.Context) DeclRefExpr(Builtin, false,
                                                   VK_RValue, BuiltinLoc);
     QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
     Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy,
                                        CK_BuiltinFnToFnPtr).get();
 
     // Build the CallExpr
     ExprResult TheCall = new (SemaRef.Context) CallExpr(
         SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
-        Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc);
+        Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc,
+        SemaRef.FPFeatures);
 
     // Type-check the __builtin_shufflevector expression.
     return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get()));
   }
 
   /// Build a new convert vector expression.
   ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc,
                                       Expr *SrcExpr, TypeSourceInfo *DstTInfo,

lib/Serialization/ASTReaderStmt.cpp

 
 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
   E->setNumArgs(Record.getContext(), Record.readInt());
   E->setRParenLoc(ReadSourceLocation());
   E->setCallee(Record.readSubExpr());
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
     E->setArg(I, Record.readSubExpr());
+  FPOptions FPFeatures(Record.readInt());
+  E->setFPFeatures(FPFeatures);
 }
 
 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
   VisitCallExpr(E);
 }
 
 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
   // Don't call VisitExpr, this is fully initialized at creation.

lib/Serialization/ASTWriterStmt.cpp

 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumArgs());
   Record.AddSourceLocation(E->getRParenLoc());
   Record.AddStmt(E->getCallee());
   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
        Arg != ArgEnd; ++Arg)
     Record.AddStmt(*Arg);
+  Record.push_back(E->getFPFeatures().getInt());
   Code = serialization::EXPR_CALL;
 }
 
 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
   // Don't call VisitExpr, we'll write everything here.
 
   Record.push_back(E->hasQualifier());
   if (E->hasQualifier())

test/CodeGen/fenv-access-pragma.c

+// RUN: %clang_cc1 -O3 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
+
+// Is FENV_ACCESS honored in a simple case?
+float fenv_access_1(float a) {
+// CHECK: fenv_access_1
+// CHECK: call double @llvm.experimental.constrained.cos.f64
+#pragma STDC FENV_ACCESS ON
+  return __builtin_cos(a);
+}
+
+// Is FENV_ACCESS state cleared on exiting compound statements?
+float fenv_access_2(float a) {
+  // CHECK: fenv_access_2
+  // CHECK: call double @llvm.cos.f64
+  {
+#pragma STDC FENV_ACCESS ON
+  }
+  return __builtin_cos(a);
+}
+
+// Check file-scoped FENV_ACCESS
+#pragma STDC FENV_ACCESS ON
+float fenv_access_3(float a) {
+  // CHECK: fenv_access_3
+  // CHECK: call double @llvm.experimental.constrained.cos.f64
+  return __builtin_cos(a);
+}
+
+#pragma STDC FENV_ACCESS OFF
+float fenv_access_4(float a) {
+  // CHECK: fenv_access_4
+  // CHECK: call double @llvm.cos.f64
+  return __builtin_cos(a);
+}
+

test/CodeGen/fenv-access-pragma.cpp

+// RUN: %clang_cc1 -O3 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
+
+// Is FENV_ACCESS honored in a simple case?
+float fenv_access_1(float a) {
+// CHECK: _Z13fenv_access_1f
+// CHECK: call double @llvm.experimental.constrained.cos.f64
+#pragma STDC FENV_ACCESS ON
+  return __builtin_cos(a);
+}
+
+// Is FENV_ACCESS state cleared on exiting compound statements?
+float fenv_access_2(float a) {
+  // CHECK: _Z13fenv_access_2f
+  // CHECK: call double @llvm.cos.f64
+  {
+#pragma STDC FENV_ACCESS ON
+  }
+  return __builtin_cos(a);
+}
+
+// Does FENV_ACCESS survive template instantiation?
+template <typename T>
+T template_bcos(T a) {
+#pragma STDC FENV_ACCESS ON
+  return __builtin_cos(a);
+}
+
+float fenv_access_3(float a) {
+  // CHECK: _Z13fenv_access_3f
+  // FIXME: This should be call double @llvm.experimental.constrained.cos.f64
+  // FIXME: Templates are known incomplete with FP_CONTRACT and FENV_ACCESS.
+  // CHECK: call double @llvm.cos.f64
+  return template_bcos<float>(a);
+}
+
+template <typename T>
+class fenv_access_4 {
+  float method(float a) {
+#pragma STDC FENV_ACCESS ON
+    return __builtin_cos(a);
+  }
+};
+
+template class fenv_access_4<int>;
+// CHECK: _ZN13fenv_access_4IiE6methodEf
+// FIXME: This should be call double @llvm.experimental.constrained.cos.f64
+// CHECK: call double @llvm.cos.f64
+
+// Check file-scoped FENV_ACCESS
+#pragma STDC FENV_ACCESS ON
+float fenv_access_5(float a) {
+  // CHECK: _Z13fenv_access_5f
+  // CHECK: call double @llvm.experimental.constrained.cos.f64
+  return __builtin_cos(a);
+}
+
+#pragma STDC FENV_ACCESS OFF
+float fenv_access_6(float a) {
+  // CHECK: _Z13fenv_access_6f
+  // CHECK: call double @llvm.cos.f64
+  return __builtin_cos(a);
+}
+

test/CodeGen/fenv-math-builtins.c

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -w -S -o - -emit-llvm              %s | FileCheck %s 
+
+// Test codegen of math builtins when using FENV_ACCESS ON.
+// Derived from math-builtins.c and keeps calls in the same order.
+#pragma STDC FENV_ACCESS ON
+
+void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) {
+  __builtin_pow(f,f);        __builtin_powf(f,f);       __builtin_powl(f,f);
+
+// CHECK: declare double @llvm.experimental.constrained.pow.f64(double, double, metadata, metadata) [[MATH_INTRINSIC:#[0-9]+]]
+// CHECK: declare float @llvm.experimental.constrained.pow.f32(float, float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.pow.f80(x86_fp80, x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+  __builtin_powi(f,f);        __builtin_powif(f,f);       __builtin_powil(f,f);
+
+// CHECK: declare double @llvm.experimental.constrained.powi.f64(double, i32, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.powi.f32(float, i32, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.powi.f80(x86_fp80, i32, metadata, metadata) [[MATH_INTRINSIC]]
+
+  /* math */
+  __builtin_cos(f);        __builtin_cosf(f);       __builtin_cosl(f); 
+// CHECK: declare double @llvm.experimental.constrained.cos.f64(double, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.cos.f32(float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.cos.f80(x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+  __builtin_exp(f);        __builtin_expf(f);       __builtin_expl(f);
+// CHECK: declare double @llvm.experimental.constrained.exp.f64(double, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.exp.f32(float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.exp.f80(x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+  __builtin_exp2(f);       __builtin_exp2f(f);      __builtin_exp2l(f); 
+
+// CHECK: declare double @llvm.experimental.constrained.exp2.f64(double, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.exp2.f32(float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.exp2.f80(x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+  __builtin_fma(f,f,f);        __builtin_fmaf(f,f,f);       __builtin_fmal(f,f,f);
+
+// CHECK: declare double @llvm.experimental.constrained.fma.f64(double, double, double, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.fma.f32(float, float, float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.fma.f80(x86_fp80, x86_fp80, x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+  __builtin_log(f);        __builtin_logf(f);       __builtin_logl(f);
+
+// CHECK: declare double @llvm.experimental.constrained.log.f64(double, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.log.f32(float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.log.f80(x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+  __builtin_log10(f);      __builtin_log10f(f);     __builtin_log10l(f);
+
+// CHECK: declare double @llvm.experimental.constrained.log10.f64(double, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.log10.f32(float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.log10.f80(x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+  __builtin_nearbyint(f);  __builtin_nearbyintf(f); __builtin_nearbyintl(f);
+
+// CHECK: declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.nearbyint.f80(x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+  __builtin_nextafter(f,f);  __builtin_nextafterf(f,f); __builtin_nextafterl(f,f);
+
+  __builtin_rint(f);       __builtin_rintf(f);      __builtin_rintl(f);
+
+// CHECK: declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.rint.f80(x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+  __builtin_sin(f);        __builtin_sinf(f);       __builtin_sinl(f);
+
+// CHECK: declare double @llvm.experimental.constrained.sin.f64(double, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.sin.f32(float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.sin.f80(x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+  __builtin_sqrt(f);       __builtin_sqrtf(f);      __builtin_sqrtl(f); 
+
+// CHECK: declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare float @llvm.experimental.constrained.sqrt.f32(float, metadata, metadata) [[MATH_INTRINSIC]]
+// CHECK: declare x86_fp80 @llvm.experimental.constrained.sqrt.f80(x86_fp80, metadata, metadata) [[MATH_INTRINSIC]]
+
+}
+
+// CHECK: attributes [[MATH_INTRINSIC]] = { {{.*}}inaccessiblememonly nounwind{{.*}} }
+