Inform AST's UnaryOperator of FENV_ACCESS

[kpn]

Summary

The UnaryOperator needs to know about #pragma FENV_ACCESS to eventually properly emit the constrained math intrinsics. This diff just gets the information about the pragma into that part of the AST.

The visible behavior of clang is unaffected and so this cannot yet be tested.

[rsmith]

Maybe take this very slightly further so it becomes testable: change the expression evaluator (lib/AST/ExprConstant.cpp) so it treats floating-point operations as non-constant if they're potentially-overflowing.

You also need to update lib/Serialization/AST{Reader,Writer}Stmt.cpp to round-trip this information through AST files.

How do you intend for this to work in template instantiation? Do we record the pragmas in the AST (and likewise for the state on entry to each function) so that we can rebuild the FPOptions during instantiation, or should we be inheriting the FPOptions from the expression in the template onto the expression in the instantiation? In the latter case, it would make more sense to me to track FPOptions on the Scope rather than as a Sema member, so that the state is more-obviously unavailable during template instantiation.

include/clang/AST/Expr.h

1798–1800

Move this adjacent to the other bitfields so we don't spend 32 / 64 bits on it.

[kpn]

Address review comments.

Add a test case. The test depends on D53157, but it reads easily enough. Richard, does this work for you?

[lebedev.ri]

include/clang/AST/Expr.h

1791

Why as the first one, and not after CanOverflow ...

1808

.. then you should be able to init it in ctor initializer, not in the body.

[kpn]

I forgot to address the template question. I've spend the past 18 years doing SystemZ backend work on multiple {,JIT} compilers. I'm not really in a position to answer your question about how to handle getting these FP bits down into C++ templates. I hope that won't hold up getting FENV_ACCESS working for C compilations.

[kpn]

Address review comments.

[lebedev.ri]

I think you have uploaded the wrong patch here.

[kpn]

Upload the correct diff this time. Sorry about the confusion!

[rsmith]

In D52839#1262449, @kpn wrote:

I forgot to address the template question. I've spend the past 18 years doing SystemZ backend work on multiple {,JIT} compilers. I'm not really in a position to answer your question about how to handle getting these FP bits down into C++ templates. I hope that won't hold up getting FENV_ACCESS working for C compilations.

Actually, I think it should. If your approach doesn't extend to C++, then you have the wrong approach, and we should redesign it now rather than spend more time on it. (Also, we use TreeTransforms in C sometimes, too, so this actually isn't even a C++-specific design problem.)

I think there are two possible approaches to take here:

1. Treat the FP environment flags as a part of the global Sema state. Whenever Clang switches its current context, figure out the right FP environment for the new context, and switch the FP environment too. This'd necessitate storing the FP environment data on DeclContexts, which would likely otherwise be unnecessary.
2. Track the FP environment somewhere more transient, probably on the Scope object. When parsing an operator, store the environment on the expression, and when performing a TreeTransform, inherit the state onto the new node.

I think option 2 seems cleaner.

[kpn]

In D52839#1263794, @rsmith wrote:

2. Track the FP environment somewhere more transient, probably on the Scope object. When parsing an operator, store the environment on the expression, and when performing a TreeTransform, inherit the state onto the new node.

I think option 2 seems cleaner.

In D53157 it looks like an API where the IRBuilder has a constrained FP switch is preferred. This way calls to the IRBuilder can remain as one liners.

Going that route, would it make more sense to store the FP environment mode in some place like CompoundStmt so it gets set correctly when traversing the AST emitting IR? I'm not sure how TreeTransform would fit in here, though. The AST is supposed to be immutable once created, right? Can we set bits in a node after the node is created and before construction of the AST is completed?

Another wrinkle is that LLVM needs all FP in a function to be either constrained or non-constrained. This is to prevent code motion between the two modes. So clang would need to set the constrained mode someplace at function scope. I don't know the best place for that. And I'm not 100% sure that this requirement is set in stone yet. But where in the AST would be the proper place for that?

How does that change things?

[kpn]

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

include/clang/AST/Expr.h

 ///
 class UnaryOperator : public Expr {
 public:
   typedef UnaryOperatorKind Opcode;
 
 private:
   unsigned Opc : 5;
   unsigned CanOverflow : 1;
+  // This is only meaningful for operations on floating point types and 0
+  // otherwise.
+  unsigned FPFeatures : 3;
+
   SourceLocation Loc;
   Stmt *Val;
 public:
   UnaryOperator(Expr *input, Opcode opc, QualType type, ExprValueKind VK,
-                ExprObjectKind OK, SourceLocation l, bool CanOverflow)
+                ExprObjectKind OK, SourceLocation l, bool CanOverflow,
+                FPOptions FPFeatures)
       : Expr(UnaryOperatorClass, type, VK, OK,
              input->isTypeDependent() || type->isDependentType(),
              input->isValueDependent(),
              (input->isInstantiationDependent() ||
               type->isInstantiationDependentType()),
              input->containsUnexpandedParameterPack()),
-        Opc(opc), CanOverflow(CanOverflow), Loc(l), Val(input) {}
+        Opc(opc), CanOverflow(CanOverflow), 
+        FPFeatures(FPFeatures.getInt()),
+        Loc(l), Val(input) {}
 
   /// Build an empty unary operator.
   explicit UnaryOperator(EmptyShell Empty)
     : Expr(UnaryOperatorClass, Empty), Opc(UO_AddrOf) { }
 
   Opcode getOpcode() const { return static_cast<Opcode>(Opc); }
   void setOpcode(Opcode O) { Opc = O; }
 
static bool classof(const Stmt *T) {
     return T->getStmtClass() == UnaryOperatorClass;
   }
 
   // Iterators
   child_range children() { return child_range(&Val, &Val+1); }
   const_child_range children() const {
     return const_child_range(&Val, &Val + 1);
   }
+
+  // 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();
+  }
 };
 
 /// Helper class for OffsetOfExpr.
 
 // __builtin_offsetof(type, identifier(.identifier|[expr])*)
 class OffsetOfNode {
 public:
   /// The kind of offsetof node we have.

lib/AST/ASTImporter.cpp

if (T.isNull())
     return nullptr;
 
   Expr *SubExpr = Importer.Import(E->getSubExpr());
   if (!SubExpr)
     return nullptr;
 
   return new (Importer.getToContext()) UnaryOperator(
       SubExpr, E->getOpcode(), T, E->getValueKind(), E->getObjectKind(),
-      Importer.Import(E->getOperatorLoc()), E->canOverflow());
+      Importer.Import(E->getOperatorLoc()), E->canOverflow(),
+      E->getFPFeatures());
 }
 
 Expr *
 ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
   QualType ResultType = Importer.Import(E->getType());
 
   if (E->isArgumentType()) {
     TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());

lib/Analysis/BodyFarm.cpp

DeclRefExpr *DR = DeclRefExpr::Create(
       C, NestedNameSpecifierLoc(), SourceLocation(), const_cast<VarDecl *>(D),
       RefersToEnclosingVariableOrCapture, SourceLocation(), Type, VK_LValue);
   return DR;
 }
 
 UnaryOperator *ASTMaker::makeDereference(const Expr *Arg, QualType Ty) {
   return new (C) UnaryOperator(const_cast<Expr*>(Arg), UO_Deref, Ty,
                                VK_LValue, OK_Ordinary, SourceLocation(),
-                              /*CanOverflow*/ false);
+                              /*CanOverflow*/ false, FPOptions());
 }
 
 ImplicitCastExpr *ASTMaker::makeLvalueToRvalue(const Expr *Arg, QualType Ty) {
   return makeImplicitCast(Arg, Ty, CK_LValueToRValue);
 }
 
 ImplicitCastExpr *
 ASTMaker::makeLvalueToRvalue(const VarDecl *Arg,
static Stmt *create_call_once(ASTContext &C, const FunctionDecl *D) {
   UnaryOperator *FlagCheck = new (C) UnaryOperator(
       /* input=*/
       M.makeImplicitCast(M.makeLvalueToRvalue(Deref, DerefType), DerefType,
                          CK_IntegralToBoolean),
       /* opc=*/ UO_LNot,
       /* QualType=*/ C.IntTy,
       /* ExprValueKind=*/ VK_RValue,
       /* ExprObjectKind=*/ OK_Ordinary, SourceLocation(),
-      /* CanOverflow*/ false);
+      /* CanOverflow*/ false,
+      FPOptions());
 
   // Create assignment.
   BinaryOperator *FlagAssignment = M.makeAssignment(
       Deref, M.makeIntegralCast(M.makeIntegerLiteral(1, C.IntTy), DerefType),
       DerefType);
 
   IfStmt *Out = new (C)
       IfStmt(C, SourceLocation(),
CallExpr *CE = new (C) CallExpr(
       /*QualType=*/C.VoidTy,
       /*ExprValueType=*/VK_RValue,
       /*SourceLocation=*/SourceLocation());
 
   // (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);
+                            /*CanOverflow*/false, FPOptions());
 
   BinaryOperator *B =
     M.makeAssignment(
        M.makeDereference(
           M.makeLvalueToRvalue(
             M.makeDeclRefExpr(Predicate), PredicateQPtrTy),
             PredicateTy),
        M.makeIntegralCast(DoneValue, PredicateTy),

lib/CodeGen/CGExprScalar.cpp

else {
         FS = &CGF.getTarget().getFloat128Format();
       else if (value->getType()->isHalfTy())
         FS = &CGF.getTarget().getHalfFormat();
       else
         FS = &CGF.getTarget().getLongDoubleFormat();
       F.convert(*FS, llvm::APFloat::rmTowardZero, &ignored);
       amt = llvm::ConstantFP::get(VMContext, F);
     }
+    if (E->isFEnvAccessOn())
+      value = Builder.CreateConstrainedFAdd(value, amt, isInc ? "inc" : "dec");
+    else
       value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
 
     if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
       if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
         value = Builder.CreateCall(
             CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16,
                                  CGF.CGM.FloatTy),
             value, "incdec.conv");
       } else {

lib/CodeGen/CGObjC.cpp

CodeGenFunction::GenerateObjCAtomicSetterCopyHelperFunction(
 
   CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
 
   StartFunction(FD, C.VoidTy, Fn, FI, args);
 
   DeclRefExpr DstExpr(&DstDecl, false, DestTy,
                       VK_RValue, SourceLocation());
   UnaryOperator DST(&DstExpr, UO_Deref, DestTy->getPointeeType(),
-                    VK_LValue, OK_Ordinary, SourceLocation(), false);
+                    VK_LValue, OK_Ordinary, SourceLocation(), false, 
+                    FPOptions());
 
   DeclRefExpr SrcExpr(&SrcDecl, false, SrcTy,
                       VK_RValue, SourceLocation());
   UnaryOperator SRC(&SrcExpr, UO_Deref, SrcTy->getPointeeType(),
-                    VK_LValue, OK_Ordinary, SourceLocation(), false);
+                    VK_LValue, OK_Ordinary, SourceLocation(), false,
+                    FPOptions());
 
   Expr *Args[2] = { &DST, &SRC };
   CallExpr *CalleeExp = cast<CallExpr>(PID->getSetterCXXAssignment());
   CXXOperatorCallExpr TheCall(C, OO_Equal, CalleeExp->getCallee(),
                               Args, DestTy->getPointeeType(),
                               VK_LValue, SourceLocation(), FPOptions());
 
   EmitStmt(&TheCall);
CodeGenFunction::GenerateObjCAtomicGetterCopyHelperFunction(
   CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
 
   StartFunction(FD, C.VoidTy, Fn, FI, args);
 
   DeclRefExpr SrcExpr(&SrcDecl, false, SrcTy,
                       VK_RValue, SourceLocation());
 
   UnaryOperator SRC(&SrcExpr, UO_Deref, SrcTy->getPointeeType(),
-                    VK_LValue, OK_Ordinary, SourceLocation(), false);
+                    VK_LValue, OK_Ordinary, SourceLocation(), false,
+                    FPOptions());
 
   CXXConstructExpr *CXXConstExpr =
     cast<CXXConstructExpr>(PID->getGetterCXXConstructor());
 
   SmallVector<Expr*, 4> ConstructorArgs;
   ConstructorArgs.push_back(&SRC);
   ConstructorArgs.append(std::next(CXXConstExpr->arg_begin()),
                          CXXConstExpr->arg_end());

lib/CodeGen/CGStmtOpenMP.cpp

auto &&CodeGen = [&S, CapturedStmt, CS,
     CodeGenFunction::OpaqueValueMapping OpaqueIV(CGF, &IVRefExpr, IV);
     OpaqueValueExpr UBRefExpr(S.getBeginLoc(), KmpInt32Ty, VK_LValue);
     CodeGenFunction::OpaqueValueMapping OpaqueUB(CGF, &UBRefExpr, UB);
     // Generate condition for loop.
     BinaryOperator Cond(&IVRefExpr, &UBRefExpr, BO_LE, C.BoolTy, VK_RValue,
                         OK_Ordinary, S.getBeginLoc(), FPOptions());
     // Increment for loop counter.
     UnaryOperator Inc(&IVRefExpr, UO_PreInc, KmpInt32Ty, VK_RValue, OK_Ordinary,
-                      S.getBeginLoc(), true);
+                      S.getBeginLoc(), true, FPOptions());
     auto &&BodyGen = [CapturedStmt, CS, &S, &IV](CodeGenFunction &CGF) {
       // Iterate through all sections and emit a switch construct:
       // switch (IV) {
       //   case 0:
       //     <SectionStmt[0]>;
       //     break;
       // ...
       //   case <NumSection> - 1:

lib/Frontend/Rewrite/RewriteModernObjC.cpp

Stmt *RewriteModernObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
   VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
                                    SourceLocation(), &Context->Idents.get(S),
                                    strType, nullptr, SC_Static);
   DeclRefExpr *DRE = new (Context) DeclRefExpr(NewVD, false, strType, VK_LValue,
                                                SourceLocation());
   Expr *Unop = new (Context) UnaryOperator(DRE, UO_AddrOf,
                                  Context->getPointerType(DRE->getType()),
                                            VK_RValue, OK_Ordinary,
-                                           SourceLocation(), false);
+                                           SourceLocation(), false,
+                                           FPOptions());
   // cast to NSConstantString *
   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
                                             CK_CPointerToObjCPointerCast, Unop);
   ReplaceStmt(Exp, cast);
   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
   return cast;
 }
 
if (LangOpts.MicrosoftExt) {
       // 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()),
                                              VK_RValue, OK_Ordinary,
-                                             SourceLocation(), false);
+                                             SourceLocation(), false,
+                                             FPOptions());
       SuperRep = NoTypeInfoCStyleCastExpr(Context,
                                           Context->getPointerType(superType),
                                           CK_BitCast, SuperRep);
     } else {
       // (struct __rw_objc_super) { <exprs from above> }
       InitListExpr *ILE =
         new (Context) InitListExpr(*Context, SourceLocation(), InitExprs,
                                    SourceLocation());
       TypeSourceInfo *superTInfo
         = Context->getTrivialTypeSourceInfo(superType);
       SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superTInfo,
                                                    superType, VK_LValue,
                                                    ILE, false);
       // struct __rw_objc_super *
       SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
                                Context->getPointerType(SuperRep->getType()),
                                              VK_RValue, OK_Ordinary,
-                                             SourceLocation(), false);
+                                             SourceLocation(), false,
+                                             FPOptions());
     }
     MsgExprs.push_back(SuperRep);
     break;
   }
 
   case ObjCMessageExpr::Class: {
     SmallVector<Expr*, 8> ClsExprs;
     ObjCInterfaceDecl *Class
if (LangOpts.MicrosoftExt) {
       // 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()),
                                VK_RValue, OK_Ordinary,
-                               SourceLocation(), false);
+                               SourceLocation(), false, FPOptions());
       SuperRep = NoTypeInfoCStyleCastExpr(Context,
                                Context->getPointerType(superType),
                                CK_BitCast, SuperRep);
     } else {
       // (struct __rw_objc_super) { <exprs from above> }
       InitListExpr *ILE =
         new (Context) InitListExpr(*Context, SourceLocation(), InitExprs,
                                    SourceLocation());

 //
 Stmt *RewriteModernObjC::RewriteLocalVariableExternalStorage(DeclRefExpr *DRE) {
   ValueDecl *VD = DRE->getDecl();
   if (VarDecl *Var = dyn_cast<VarDecl>(VD))
     if (!ImportedLocalExternalDecls.count(Var))
       return DRE;
   Expr *Exp = new (Context) UnaryOperator(DRE, UO_Deref, DRE->getType(),
                                           VK_LValue, OK_Ordinary,
-                                          DRE->getLocation(), false);
+                                          DRE->getLocation(), false,
+                                          FPOptions());
   // Need parens to enforce precedence.
   ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(),
                                           Exp);
   ReplaceStmt(DRE, PE);
   return PE;
 }
 
 void RewriteModernObjC::RewriteCastExpr(CStyleCastExpr *CE) {
Stmt *RewriteModernObjC::SynthBlockInitExpr(BlockExpr *Exp,
   UnaryOperator *DescRefExpr =
     new (Context) UnaryOperator(new (Context) DeclRefExpr(NewVD, false,
                                                           Context->VoidPtrTy,
                                                           VK_LValue,
                                                           SourceLocation()),
                                 UO_AddrOf,
                                 Context->getPointerType(Context->VoidPtrTy),
                                 VK_RValue, OK_Ordinary,
-                                SourceLocation(), false);
+                                SourceLocation(), false, FPOptions());
   InitExprs.push_back(DescRefExpr);
 
   // Add initializers for any closure decl refs.
   if (BlockDeclRefs.size()) {
     Expr *Exp;
     // Output all "by copy" declarations.
     for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(),
          E = BlockByCopyDecls.end(); I != E; ++I) {
       if (isObjCType((*I)->getType())) {
         // FIXME: Conform to ABI ([[obj retain] autorelease]).
         FD = SynthBlockInitFunctionDecl((*I)->getName());
         Exp = new (Context) DeclRefExpr(FD, false, FD->getType(),
                                         VK_LValue, SourceLocation());
         if (HasLocalVariableExternalStorage(*I)) {
           QualType QT = (*I)->getType();
           QT = Context->getPointerType(QT);
           Exp = new (Context) UnaryOperator(Exp, UO_AddrOf, QT, VK_RValue,
                                             OK_Ordinary, SourceLocation(),
-                                            false);
+                                            false, FPOptions());
         }
       } else if (isTopLevelBlockPointerType((*I)->getType())) {
         FD = SynthBlockInitFunctionDecl((*I)->getName());
         Arg = new (Context) DeclRefExpr(FD, false, FD->getType(),
                                         VK_LValue, SourceLocation());
         Exp = NoTypeInfoCStyleCastExpr(Context, Context->VoidPtrTy,
                                        CK_BitCast, Arg);
       } else {
         FD = SynthBlockInitFunctionDecl((*I)->getName());
         Exp = new (Context) DeclRefExpr(FD, false, FD->getType(),
                                         VK_LValue, SourceLocation());
         if (HasLocalVariableExternalStorage(*I)) {
           QualType QT = (*I)->getType();
           QT = Context->getPointerType(QT);
           Exp = new (Context) UnaryOperator(Exp, UO_AddrOf, QT, VK_RValue,
                                             OK_Ordinary, SourceLocation(),
-                                            false);
+                                            false, FPOptions());
         }
 
       }
       InitExprs.push_back(Exp);
     }
     // Output all "by ref" declarations.
     for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
          E = BlockByRefDecls.end(); I != E; ++I) {
for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
           }
         }
       // captured nested byref variable has its address passed. Do not take
       // its address again.
       if (!isNestedCapturedVar)
           Exp = new (Context) UnaryOperator(Exp, UO_AddrOf,
                                      Context->getPointerType(Exp->getType()),
                                      VK_RValue, OK_Ordinary, SourceLocation(),
-                                     false);
+                                     false, FPOptions());
       Exp = NoTypeInfoCStyleCastExpr(Context, castT, CK_BitCast, Exp);
       InitExprs.push_back(Exp);
     }
   }
   if (ImportedBlockDecls.size()) {
     // generate BLOCK_HAS_COPY_DISPOSE(have helper funcs) | BLOCK_HAS_DESCRIPTOR
     int flag = (BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR);
     unsigned IntSize =
if (GlobalBlockExpr) {
     assert (!GlobalConstructionExp &&
             "SynthBlockInitExpr - GlobalConstructionExp must be null");
     GlobalConstructionExp = NewRep;
     NewRep = DRE;
   }
 
   NewRep = new (Context) UnaryOperator(NewRep, UO_AddrOf,
                              Context->getPointerType(NewRep->getType()),
-                             VK_RValue, OK_Ordinary, SourceLocation(), false);
+                             VK_RValue, OK_Ordinary, SourceLocation(), false,
+                             FPOptions());
   NewRep = NoTypeInfoCStyleCastExpr(Context, FType, CK_BitCast,
                                     NewRep);
   // Put Paren around the call.
   NewRep = new (Context) ParenExpr(SourceLocation(), SourceLocation(),
                                    NewRep);
 
   BlockDeclRefs.clear();
   BlockByRefDecls.clear();
if (BaseExpr->getType()->isObjCObjectPointerType()) {
       castExpr = NoTypeInfoCStyleCastExpr(Context,
                                           castT,
                                           CK_BitCast,
                                           PE);
 
 
       Expr *Exp = new (Context) UnaryOperator(castExpr, UO_Deref, IvarT,
                                               VK_LValue, OK_Ordinary,
-                                              SourceLocation(), false);
+                                              SourceLocation(), false, 
+                                              FPOptions());
       PE = new (Context) ParenExpr(OldRange.getBegin(),
                                    OldRange.getEnd(),
                                    Exp);
 
       if (D->isBitField()) {
         FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
                                           SourceLocation(),
                                           &Context->Idents.get(D->getNameAsString()),

lib/Frontend/Rewrite/RewriteObjC.cpp

Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
   VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
                                    SourceLocation(), &Context->Idents.get(S),
                                    strType, nullptr, SC_Static);
   DeclRefExpr *DRE = new (Context) DeclRefExpr(NewVD, false, strType, VK_LValue,
                                                SourceLocation());
   Expr *Unop = new (Context) UnaryOperator(DRE, UO_AddrOf,
                                  Context->getPointerType(DRE->getType()),
                                            VK_RValue, OK_Ordinary,
-                                           SourceLocation(), false);
+                                           SourceLocation(), false, 
+                                           FPOptions());
   // cast to NSConstantString *
   CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
                                             CK_CPointerToObjCPointerCast, Unop);
   ReplaceStmt(Exp, cast);
   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
   return cast;
 }
 
if (LangOpts.MicrosoftExt) {
       // 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()),
                                              VK_RValue, OK_Ordinary,
-                                             SourceLocation(), false);
+                                             SourceLocation(), false,
+                                             FPOptions());
       SuperRep = NoTypeInfoCStyleCastExpr(Context,
                                           Context->getPointerType(superType),
                                           CK_BitCast, SuperRep);
     } else {
       // (struct objc_super) { <exprs from above> }
       InitListExpr *ILE =
         new (Context) InitListExpr(*Context, SourceLocation(), InitExprs,
                                    SourceLocation());
       TypeSourceInfo *superTInfo
         = Context->getTrivialTypeSourceInfo(superType);
       SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superTInfo,
                                                    superType, VK_LValue,
                                                    ILE, false);
       // struct objc_super *
       SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
                                Context->getPointerType(SuperRep->getType()),
                                              VK_RValue, OK_Ordinary,
-                                             SourceLocation(), false);
+                                             SourceLocation(), false,
+                                             FPOptions());
     }
     MsgExprs.push_back(SuperRep);
     break;
   }
 
   case ObjCMessageExpr::Class: {
     SmallVector<Expr*, 8> ClsExprs;
     ObjCInterfaceDecl *Class
if (LangOpts.MicrosoftExt) {
       // 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()),
                                VK_RValue, OK_Ordinary,
-                               SourceLocation(), false);
+                               SourceLocation(), false, FPOptions());
       SuperRep = NoTypeInfoCStyleCastExpr(Context,
                                Context->getPointerType(superType),
                                CK_BitCast, SuperRep);
     } else {
       // (struct objc_super) { <exprs from above> }
       InitListExpr *ILE =
         new (Context) InitListExpr(*Context, SourceLocation(), InitExprs,
                                    SourceLocation());
Stmt *RewriteObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
   IdentifierInfo *ID = &Context->Idents.get(Name);
   VarDecl *VD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
                                 SourceLocation(), ID, getProtocolType(),
                                 nullptr, SC_Extern);
   DeclRefExpr *DRE = new (Context) DeclRefExpr(VD, false, getProtocolType(),
                                                VK_LValue, SourceLocation());
   Expr *DerefExpr = new (Context) UnaryOperator(DRE, UO_AddrOf,
                              Context->getPointerType(DRE->getType()),
-                             VK_RValue, OK_Ordinary, SourceLocation(), false);
+                             VK_RValue, OK_Ordinary, SourceLocation(), false,
+                             FPOptions());
   CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, DerefExpr->getType(),
                                                 CK_BitCast,
                                                 DerefExpr);
   ReplaceStmt(Exp, castExpr);
   ProtocolExprDecls.insert(Exp->getProtocol()->getCanonicalDecl());
   // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
   return castExpr;
 }

 //
 Stmt *RewriteObjC::RewriteLocalVariableExternalStorage(DeclRefExpr *DRE) {
   ValueDecl *VD = DRE->getDecl();
   if (VarDecl *Var = dyn_cast<VarDecl>(VD))
     if (!ImportedLocalExternalDecls.count(Var))
       return DRE;
   Expr *Exp = new (Context) UnaryOperator(DRE, UO_Deref, DRE->getType(),
                                           VK_LValue, OK_Ordinary,
-                                          DRE->getLocation(), false);
+                                          DRE->getLocation(), false, 
+                                          FPOptions());
   // Need parens to enforce precedence.
   ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(),
                                           Exp);
   ReplaceStmt(DRE, PE);
   return PE;
 }
 
 void RewriteObjC::RewriteCastExpr(CStyleCastExpr *CE) {
int countOfInnerDecls = 0;
   UnaryOperator *DescRefExpr =
     new (Context) UnaryOperator(new (Context) DeclRefExpr(NewVD, false,
                                                           Context->VoidPtrTy,
                                                           VK_LValue,
                                                           SourceLocation()),
                                 UO_AddrOf,
                                 Context->getPointerType(Context->VoidPtrTy),
                                 VK_RValue, OK_Ordinary,
-                                SourceLocation(), false);
+                                SourceLocation(), false, FPOptions());
   InitExprs.push_back(DescRefExpr);
 
   // Add initializers for any closure decl refs.
   if (BlockDeclRefs.size()) {
     Expr *Exp;
     // Output all "by copy" declarations.
     for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(),
          E = BlockByCopyDecls.end(); I != E; ++I) {
       if (isObjCType((*I)->getType())) {
         // FIXME: Conform to ABI ([[obj retain] autorelease]).
         FD = SynthBlockInitFunctionDecl((*I)->getName());
         Exp = new (Context) DeclRefExpr(FD, false, FD->getType(), VK_LValue,
                                         SourceLocation());
         if (HasLocalVariableExternalStorage(*I)) {
           QualType QT = (*I)->getType();
           QT = Context->getPointerType(QT);
           Exp = new (Context) UnaryOperator(Exp, UO_AddrOf, QT, VK_RValue,
                                             OK_Ordinary, SourceLocation(),
-                                            false);
+                                            false, FPOptions());
         }
       } else if (isTopLevelBlockPointerType((*I)->getType())) {
         FD = SynthBlockInitFunctionDecl((*I)->getName());
         Arg = new (Context) DeclRefExpr(FD, false, FD->getType(), VK_LValue,
                                         SourceLocation());
         Exp = NoTypeInfoCStyleCastExpr(Context, Context->VoidPtrTy,
                                        CK_BitCast, Arg);
       } else {
         FD = SynthBlockInitFunctionDecl((*I)->getName());
         Exp = new (Context) DeclRefExpr(FD, false, FD->getType(), VK_LValue,
                                         SourceLocation());
         if (HasLocalVariableExternalStorage(*I)) {
           QualType QT = (*I)->getType();
           QT = Context->getPointerType(QT);
           Exp = new (Context) UnaryOperator(Exp, UO_AddrOf, QT, VK_RValue,
                                             OK_Ordinary, SourceLocation(),
-                                            false);
+                                            false, FPOptions());
         }
       }
       InitExprs.push_back(Exp);
     }
     // Output all "by ref" declarations.
     for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
          E = BlockByRefDecls.end(); I != E; ++I) {
       ValueDecl *ND = (*I);
for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
             break;
           }
         }
       // captured nested byref variable has its address passed. Do not take
       // its address again.
       if (!isNestedCapturedVar)
         Exp = new (Context) UnaryOperator(
             Exp, UO_AddrOf, Context->getPointerType(Exp->getType()), VK_RValue,
-            OK_Ordinary, SourceLocation(), false);
+            OK_Ordinary, SourceLocation(), false, FPOptions());
       Exp = NoTypeInfoCStyleCastExpr(Context, castT, CK_BitCast, Exp);
       InitExprs.push_back(Exp);
     }
   }
   if (ImportedBlockDecls.size()) {
     // generate BLOCK_HAS_COPY_DISPOSE(have helper funcs) | BLOCK_HAS_DESCRIPTOR
     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());
   NewRep = new (Context) UnaryOperator(NewRep, UO_AddrOf,
                              Context->getPointerType(NewRep->getType()),
-                             VK_RValue, OK_Ordinary, SourceLocation(), false);
+                             VK_RValue, OK_Ordinary, SourceLocation(), false,
+                             FPOptions());
   NewRep = NoTypeInfoCStyleCastExpr(Context, FType, CK_BitCast,
                                     NewRep);
   BlockDeclRefs.clear();
   BlockByRefDecls.clear();
   BlockByRefDeclsPtrSet.clear();
   BlockByCopyDecls.clear();
   BlockByCopyDeclsPtrSet.clear();
   ImportedBlockDecls.clear();

lib/Sema/SemaDeclCXX.cpp

llvm::APInt Size(S.Context.getTypeSize(SizeType),
                    S.Context.getTypeSizeInChars(T).getQuantity());
 
   // Take the address of the field references for "from" and "to". We
   // directly construct UnaryOperators here because semantic analysis
   // does not permit us to take the address of an xvalue.
   Expr *From = FromB.build(S, Loc);
   From = new (S.Context) UnaryOperator(From, UO_AddrOf,
                          S.Context.getPointerType(From->getType()),
-                         VK_RValue, OK_Ordinary, Loc, false);
+                         VK_RValue, OK_Ordinary, Loc, false, FPOptions());
   Expr *To = ToB.build(S, Loc);
   To = new (S.Context) UnaryOperator(To, UO_AddrOf,
                        S.Context.getPointerType(To->getType()),
-                       VK_RValue, OK_Ordinary, Loc, false);
+                       VK_RValue, OK_Ordinary, Loc, false, FPOptions());
 
   const Type *E = T->getBaseElementTypeUnsafe();
   bool NeedsCollectableMemCpy =
     E->isRecordType() && E->getAs<RecordType>()->getDecl()->hasObjectMember();
 
   // Create a reference to the __builtin_objc_memmove_collectable function
   StringRef MemCpyName = NeedsCollectableMemCpy ?
     "__builtin_objc_memmove_collectable" :
= new (S.Context) BinaryOperator(IterationVarRefRVal.build(S, Loc),
                                      BO_NE, S.Context.BoolTy,
                                      VK_RValue, OK_Ordinary, Loc, FPOptions());
 
   // Create the pre-increment of the iteration variable. We can determine
   // whether the increment will overflow based on the value of the array
   // bound.
   Expr *Increment = new (S.Context)
       UnaryOperator(IterationVarRef.build(S, Loc), UO_PreInc, SizeType,
-                    VK_LValue, OK_Ordinary, Loc, Upper.isMaxValue());
+                    VK_LValue, OK_Ordinary, Loc, Upper.isMaxValue(), 
+                    FPOptions());
 
   // Construct the loop that copies all elements of this array.
   return S.ActOnForStmt(
       Loc, Loc, InitStmt,
       S.ActOnCondition(nullptr, Loc, Comparison, Sema::ConditionKind::Boolean),
       S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());
 }
 

lib/Sema/SemaExpr.cpp

ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
   // Check for array bounds violations in the operand of the UnaryOperator,
   // except for the '*' and '&' operators that have to be handled specially
   // by CheckArrayAccess (as there are special cases like &array[arraysize]
   // that are explicitly defined as valid by the standard).
   if (Opc != UO_AddrOf && Opc != UO_Deref)
     CheckArrayAccess(Input.get());
 
   auto *UO = new (Context)
-      UnaryOperator(Input.get(), Opc, resultType, VK, OK, OpLoc, CanOverflow);
+      UnaryOperator(Input.get(), Opc, resultType, VK, OK, OpLoc, CanOverflow,
+                    FPFeatures);
   // Convert the result back to a half vector.
   if (ConvertHalfVec)
     return convertVector(UO, Context.HalfTy, *this);
   return UO;
 }
 
 /// Determine whether the given expression is a qualified member
 /// access expression, of a form that could be turned into a pointer to member

lib/Sema/SemaExprObjC.cpp

Expr *Sema::stripARCUnbridgedCast(Expr *e) {
   if (ParenExpr *pe = dyn_cast<ParenExpr>(e)) {
     Expr *sub = stripARCUnbridgedCast(pe->getSubExpr());
     return new (Context) ParenExpr(pe->getLParen(), pe->getRParen(), sub);
   } else if (UnaryOperator *uo = dyn_cast<UnaryOperator>(e)) {
     assert(uo->getOpcode() == UO_Extension);
     Expr *sub = stripARCUnbridgedCast(uo->getSubExpr());
     return new (Context)
         UnaryOperator(sub, UO_Extension, sub->getType(), sub->getValueKind(),
-                      sub->getObjectKind(), uo->getOperatorLoc(), false);
+                      sub->getObjectKind(), uo->getOperatorLoc(), false,
+                      FPFeatures);
   } else if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
     assert(!gse->isResultDependent());
 
     unsigned n = gse->getNumAssocs();
     SmallVector<Expr*, 4> subExprs(n);
     SmallVector<TypeSourceInfo*, 4> subTypes(n);
     for (unsigned i = 0; i != n; ++i) {
       subTypes[i] = gse->getAssocTypeSourceInfo(i);

lib/Sema/SemaOverload.cpp

if (Opc == UO_PostInc || Opc == UO_PostDec) {
     NumArgs = 2;
   }
 
   ArrayRef<Expr *> ArgsArray(Args, NumArgs);
 
   if (Input->isTypeDependent()) {
     if (Fns.empty())
       return new (Context) UnaryOperator(Input, Opc, Context.DependentTy,
-                                         VK_RValue, OK_Ordinary, OpLoc, false);
+                                         VK_RValue, OK_Ordinary, OpLoc, false,
+                                         FPFeatures);
 
     CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
     UnresolvedLookupExpr *Fn
       = UnresolvedLookupExpr::Create(Context, NamingClass,
                                      NestedNameSpecifierLoc(), OpNameInfo,
                                      /*ADL*/ true, IsOverloaded(Fns),
                                      Fns.begin(), Fns.end());
     return new (Context)
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
         QualType MemPtrType
           = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
         // Under the MS ABI, lock down the inheritance model now.
         if (Context.getTargetInfo().getCXXABI().isMicrosoft())
           (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
 
         return new (Context) UnaryOperator(SubExpr, UO_AddrOf, MemPtrType,
                                            VK_RValue, OK_Ordinary,
-                                           UnOp->getOperatorLoc(), false);
+                                           UnOp->getOperatorLoc(), false,
+                                           FPFeatures);
       }
     }
     Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
                                                    Found, Fn);
     if (SubExpr == UnOp->getSubExpr())
       return UnOp;
 
     return new (Context) UnaryOperator(SubExpr, UO_AddrOf,
                                      Context.getPointerType(SubExpr->getType()),
                                        VK_RValue, OK_Ordinary,
-                                       UnOp->getOperatorLoc(), false);
+                                       UnOp->getOperatorLoc(), false,
+                                       FPFeatures);
   }
 
   // C++ [except.spec]p17:
   //   An exception-specification is considered to be needed when:
   //   - in an expression the function is the unique lookup result or the
   //     selected member of a set of overloaded functions
   if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
     ResolveExceptionSpec(E->getExprLoc(), FPT);

lib/Sema/SemaPseudoObject.cpp

Expr *rebuild(Expr *e) {
       if (UnaryOperator *uop = dyn_cast<UnaryOperator>(e)) {
         assert(uop->getOpcode() == UO_Extension);
         e = rebuild(uop->getSubExpr());
         return new (S.Context) UnaryOperator(e, uop->getOpcode(),
                                              uop->getType(),
                                              uop->getValueKind(),
                                              uop->getObjectKind(),
                                              uop->getOperatorLoc(),
-                                             uop->canOverflow());
+                                             uop->canOverflow(),
+                                             FPOptions());
       }
 
       if (GenericSelectionExpr *gse = dyn_cast<GenericSelectionExpr>(e)) {
         assert(!gse->isResultDependent());
         unsigned resultIndex = gse->getResultIndex();
         unsigned numAssocs = gse->getNumAssocs();
 
         SmallVector<Expr*, 8> assocs(numAssocs);
if (UnaryOperator::isPrefix(opcode) && !captureSetValueAsResult() &&
       (result.get()->isTypeDependent() || CanCaptureValue(result.get())))
     setResultToLastSemantic();
 
   UnaryOperator *syntactic = new (S.Context) UnaryOperator(
       syntacticOp, opcode, resultType, VK_LValue, OK_Ordinary, opcLoc,
       !resultType->isDependentType()
           ? S.Context.getTypeSize(resultType) >=
                 S.Context.getTypeSize(S.Context.IntTy)
-          : false);
+          : false, FPOptions());
   return complete(syntactic);
 }
 
 
 //===----------------------------------------------------------------------===//
 //  Objective-C @property and implicit property references
 //===----------------------------------------------------------------------===//
 

 }
 
 /// Check an increment or decrement of a pseudo-object expression.
 ExprResult Sema::checkPseudoObjectIncDec(Scope *Sc, SourceLocation opcLoc,
                                          UnaryOperatorKind opcode, Expr *op) {
   // Do nothing if the operand is dependent.
   if (op->isTypeDependent())
     return new (Context) UnaryOperator(op, opcode, Context.DependentTy,
-                                       VK_RValue, OK_Ordinary, opcLoc, false);
+                                       VK_RValue, OK_Ordinary, opcLoc, false,
+                                       FPOptions());
 
   assert(UnaryOperator::isIncrementDecrementOp(opcode));
   Expr *opaqueRef = op->IgnoreParens();
   if (ObjCPropertyRefExpr *refExpr
         = dyn_cast<ObjCPropertyRefExpr>(opaqueRef)) {
     ObjCPropertyOpBuilder builder(*this, refExpr, false);
     return builder.buildIncDecOperation(Sc, opcLoc, opcode, op);
   } else if (isa<ObjCSubscriptRefExpr>(opaqueRef)) {

 /// capable of rebuilding a tree without stripping implicit
 /// operations.
 Expr *Sema::recreateSyntacticForm(PseudoObjectExpr *E) {
   Expr *syntax = E->getSyntacticForm();
   if (UnaryOperator *uop = dyn_cast<UnaryOperator>(syntax)) {
     Expr *op = stripOpaqueValuesFromPseudoObjectRef(*this, uop->getSubExpr());
     return new (Context) UnaryOperator(
         op, uop->getOpcode(), uop->getType(), uop->getValueKind(),
-        uop->getObjectKind(), uop->getOperatorLoc(), uop->canOverflow());
+        uop->getObjectKind(), uop->getOperatorLoc(), uop->canOverflow(),
+        FPOptions());
   } else if (CompoundAssignOperator *cop
                = dyn_cast<CompoundAssignOperator>(syntax)) {
     Expr *lhs = stripOpaqueValuesFromPseudoObjectRef(*this, cop->getLHS());
     Expr *rhs = cast<OpaqueValueExpr>(cop->getRHS())->getSourceExpr();
     return new (Context) CompoundAssignOperator(lhs, rhs, cop->getOpcode(),
                                                 cop->getType(),
                                                 cop->getValueKind(),
                                                 cop->getObjectKind(),

lib/Serialization/ASTReaderStmt.cpp

 }
 
 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
   VisitExpr(E);
   E->setSubExpr(Record.readSubExpr());
   E->setOpcode((UnaryOperator::Opcode)Record.readInt());
   E->setOperatorLoc(ReadSourceLocation());
   E->setCanOverflow(Record.readInt());
+  FPOptions FPFeatures(Record.readInt());
+  E->setFPFeatures(FPFeatures);
 }
 
 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
   VisitExpr(E);
   assert(E->getNumComponents() == Record.peekInt());
   Record.skipInts(1);
   assert(E->getNumExpressions() == Record.peekInt());
   Record.skipInts(1);

lib/Serialization/ASTWriterStmt.cpp

 }
 
 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
   VisitExpr(E);
   Record.AddStmt(E->getSubExpr());
   Record.push_back(E->getOpcode()); // FIXME: stable encoding
   Record.AddSourceLocation(E->getOperatorLoc());
   Record.push_back(E->canOverflow());
+  Record.push_back(E->getFPFeatures().getInt());
   Code = serialization::EXPR_UNARY_OPERATOR;
 }
 
 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumComponents());
   Record.push_back(E->getNumExpressions());
   Record.AddSourceLocation(E->getOperatorLoc());

test/CodeGen/unary-con-fadd.c

+// RUN: %clang_cc1 -emit-llvm -o - %s | FileCheck %s
+
+#pragma STDC FENV_ACCESS ON
+
+// Is FENV_ACCESS honored in a simple case?
+double test_1(double x) {
+// CHECK: test_1
+// CHECK: call double @llvm.experimental.constrained.fadd.f64
+  x++;
+  return x;
+}