Represent FP options in AST by special Expression node

[sepavloff]

Summary

The patch D76599 proposed a new statement node to represent pragmas that
modifies floating point environment. These nodes are used to implement
FP environment tracking and control in a function. Such node modify FP
environment in enclosing compound statement thus organizing FP
environment in hierarchical manner.

That solution however cannot be applied to initializers of global
variables and some other objects. They represent expressions outside
function bodies and thus cannot be embedded into compound statements.

Expression node introduced here (FPEnvironmentExpr) is to represent
FP environment in such cases. It contains a field of type FPOptions,
which specifies FP environment in which subexpression of
FPEnvironmentExpr should be executed. The patch implements FP
environment in the following cases:

• Initializers of global variables, like:
  
  float v1 = 3,1415926535;

• Inline initializers of fields:
  
  struct C1 { float f1 = 1,4142135623; };

• Arguments of base constructors in constructors:
  
  struct C3 : public C2 { C3(double x, double y) : C2(x + y) {} };

• Default function arguments:
  
  void func_01(float x = 1.1);

In contrast to the solution for compound statements in D76599, this
solution does not keep reference to the source code construct that set
the FP environment, namely the file scope pragma. It may cause problems
for AST consumers like source analyzers.

[rjmccall]

The goal here seems to be to avoid the need to store pragma state in operator expressions. As I mentioned in another review, I'm not sure how directly interesting that goal is if we can avoid memory overhead in the common case. Storing pragma state in operators certainly has a substantial complexity cost, but forcing every AST client to track the currently-active pragma state also has a cost.

[sepavloff]

The solution in D76384 (Move FPFeatures from BinaryOperator bitfields to Trailing storage) causes several concerns.

1. It requires substantial code changes. The patch in D76384 is already large and we need to do similar work for UnaryOperator, CallExpr, CXXOperatorCallExpr, CastExpr and probably some others. In contrast, using pragma nodes does not require changes to existing nodes.

2. This solution means some loss of source information. Pragma is not represented in AST and some source analysis tools probably may suffer from it.

3. In some cases pragma anyway must be present in AST. For instance, it is useful to have a pragma that sets rounding mode, without need of fesetround. Such pragma would make codegen to emit some code, it is reasonable to do that during treatment of corresponding statement node rather than of CompoundStmt.

4. Replication of FP environment into separate operation nodes actually change semantics. IEEE-754 considers FP environment as global state and this viewpoint is consistent with hardware viewpoint on many platforms. The replication make the environment a sum of operation properties. This change manifests itself in some cases. For instance, the following code:

	const float C1 = 3,1415926535;
	const float C2 = 1,4142135623;
	
	#pragma STDC FENV_ACCESS ON
	constexpr float func(float x, float y) {
	    return x + y;
	}
	
	#pragma STDC FENV_ROUND FE_DOWNWARD
	float V1 = func(C1, C2);
	
	#pragma STDC FENV_ROUND FE_UPWARD
	float V2 = func(C1, C2);

If FP environment is replicated into every operation in the body of func, the operations will get "round.dynamic" as rounding mode argument. Such nodes cannot be evaluated in compile time. But if FP environment is global state, constant evaluator could just set it before evaluation. Behavior of constexpr functions in this case produce the same results as for non-constexpr variants.

5. Rounding mode can be turned into local property, but exception status anyway would require global state in constant evaluator. A function like:

	constexpr float func(float x, float y) {
	    float z = x + y;
	    if (fetestexcept(FE_OVERFLOW))
	        z = 0;
	    return z;
	}

can be evaluated in compile time but exceptions raised by operations need to be kept in some global state. So maintaining this global state anyway required for constant evaluator, no matter if it contains rounding mode or not.

[rjmccall]

In D77545#1972344, @sepavloff wrote:

The solution in D76384 (Move FPFeatures from BinaryOperator bitfields to Trailing storage) causes several concerns.

1. It requires substantial code changes. The patch in D76384 is already large and we need to do similar work for UnaryOperator, CallExpr, CXXOperatorCallExpr, CastExpr and probably some others. In contrast, using pragma nodes does not require changes to existing nodes.

Pragma nodes don't require AST changes to existing nodes, but they require large changes to a number of clients, all of which will just do the wrong thing if they don't preserve and pass down the right information. It's extremely error-prone, and I don't see a way to make it not error-prone.

2. This solution means some loss of source information. Pragma is not represented in AST and some source analysis tools probably may suffer from it.

We can reflect the pragma in the AST even if it isn't necessary for correctness.

3. In some cases pragma anyway must be present in AST. For instance, it is useful to have a pragma that sets rounding mode, without need of fesetround. Such pragma would make codegen to emit some code, it is reasonable to do that during treatment of corresponding statement node rather than of CompoundStmt.

Since such a pragma would only affect the code in the function, it would not admit an implementation that just calls fesetround, because the original state would need to be restored on any function calls.

4. Replication of FP environment into separate operation nodes actually change semantics. IEEE-754 considers FP environment as global state and this viewpoint is consistent with hardware viewpoint on many platforms. The replication make the environment a sum of operation properties. This change manifests itself in some cases. For instance, the following code:

	const float C1 = 3,1415926535;
	const float C2 = 1,4142135623;
	
	#pragma STDC FENV_ACCESS ON
	constexpr float func(float x, float y) {
	    return x + y;
	}
	
	#pragma STDC FENV_ROUND FE_DOWNWARD
	float V1 = func(C1, C2);
	
	#pragma STDC FENV_ROUND FE_UPWARD
	float V2 = func(C1, C2);

If FP environment is replicated into every operation in the body of func, the operations will get "round.dynamic" as rounding mode argument. Such nodes cannot be evaluated in compile time. But if FP environment is global state, constant evaluator could just set it before evaluation. Behavior of constexpr functions in this case produce the same results as for non-constexpr variants.

C specifies that constant evaluation contexts do not honor FENV_ACCESS. I'm not sure it's specified anywhere for C++, but it presumably applies equally to at least explicit constexpr contexts.

5. Rounding mode can be turned into local property, but exception status anyway would require global state in constant evaluator. A function like:

	constexpr float func(float x, float y) {
	    float z = x + y;
	    if (fetestexcept(FE_OVERFLOW))
	        z = 0;
	    return z;
	}

can be evaluated in compile time but exceptions raised by operations need to be kept in some global state. So maintaining this global state anyway required for constant evaluator, no matter if it contains rounding mode or not.

The constant evaluator can certainly model state within its evaluation, but that state is local to an evaluation. You would not constant-evaluate one call that sets an FP exception and then expect a later constant-evaluation to be able to detect that.

The concern is that we don't want the constant evaluator to become sensitive to arbitrary mutable state in the larger compiler.

[sepavloff]

In D77545#1973169, @rjmccall wrote:

Pragma nodes don't require AST changes to existing nodes, but they require large changes to a number of clients,

If a client is unaware of peculiarities of floating point operations, it can safely ignore existence of FP environment. For example, ASTMatcher is such a client. No change are required in this case.

Some clients, like ASTDumper require modification to support new nodes. The changes in this case are not larger than typical change required to support a new AST node.

There are clients that can benefit from knowledge about FP environment, probably StaticAnalyzer is such. The relevant support requires almost the same efforts in any case.

Some clients, like Codegen and Constant Evaluator must take into account FP environment. They must be updated properly as now we have no such support. It is questionable which approach requires more efforts, I think both are similar in complexity.

The changes to clients in the case of 'global state' approach are not large than in the case of 'trailing objects'.

all of which will just do the wrong thing if they don't preserve and pass down the right information. It's extremely error-prone, and I don't see a way to make it not error-prone.

Actually support of FP environment is very similar to scope mechanism. It is changed *only* at compound statement entry or exit. We already have many RAII objects that facilitate this maintenance

C specifies that constant evaluation contexts do not honor FENV_ACCESS. I'm not sure it's specified anywhere for C++, but it presumably applies equally to at least explicit constexpr contexts.

They must honor FENV_ROUND:

n2454, F.8.2
During translation, constant rounding direction modes (7.6.2) are in effect where specified.

n2454, 7.6.2p2
The FENV_ROUND pragma provides a means to specify a constant rounding direction for floating point
operations for standard floating types within a translation unit or compound statement.

If initialization with call to constexpr function should be equivalent to similar constant expression, like in:

#pragma STDC FENV_ROUND <direction>
constexpr float add(float x, float y) { return x+y; }
float N1 = 2.22 + 3.33;
float N2 = add(2.22, 3.33);

compiler must evaluate constexpr function in the current FP environment.

5. Rounding mode can be turned into local property, but exception status anyway would require global state in constant evaluator. A function like:

	constexpr float func(float x, float y) {
	    float z = x + y;
	    if (fetestexcept(FE_OVERFLOW))
	        z = 0;
	    return z;
	}

can be evaluated in compile time but exceptions raised by operations need to be kept in some global state. So maintaining this global state anyway required for constant evaluator, no matter if it contains rounding mode or not.

The constant evaluator can certainly model state within its evaluation, but that state is local to an evaluation. You would not constant-evaluate one call that sets an FP exception and then expect a later constant-evaluation to be able to detect that.

The example with exception tracking was not good. I wanted only to demonstrate that constant evaluator inevitably should maintain global state if we want it to calculate exception state. It must be convenient, if an expression overflows, do one thing, if not do another. Using FP environment as a "hidden" argument to constexpr function is of course impossible.

The concern is that we don't want the constant evaluator to become sensitive to arbitrary mutable state in the larger compiler.

Not to arbitrary state, but to some part of FP state, namely FP control modes, which now is only rounding mode, set by pragma STDC FENV_ROUND.

[rjmccall]

! In D77545#1973765, @sepavloff wrote:

! In D77545#1973169, @rjmccall wrote:
all of which will just do the wrong thing if they don't preserve and pass down the right information. It's extremely error-prone, and I don't see a way to make it not error-prone.

Actually support of FP environment is very similar to scope mechanism. It is changed *only* at compound statement entry or exit. We already have many RAII objects that facilitate this maintenance

Okay, so you're proposing that we maintain global state in the ASTContext for what pragmas are in effect, managed by RAII objects, rather than passing the current pragma state in as an argument. I agree that this is relatively straightforward for clients to support if they're just performing a recursive walk. However, it is extremely susceptible to bugs where the current context is incorrectly applied to expressions written in a different context.

For example, in this code:

const float global = 2.22 + 3.33;

#pragma STDV FENV_ROUND <direction>
float getGlobal() { return global; }

The code-generation of getGlobal will attempt to constant-evaluate the initializer of global so that it can just return a constant instead of emitting a load from a global. It is important for correctness that this constant-evaluation occur in the default FP environment, not the active FP environment at the point of use. Presumably you are not proposing that global's initializer is a PragmaExpr, since it's in the default environment. Perhaps we can recognize by the *absence* of a PragmaExpr that it's meant to use the default environment? It's not clear at what level we would trigger this check, however. Is it now semantically important that we call a method like VarDecl::evaluateValue() rather than Expr::EvaluateAsFloat(...)? What happens with variables in local scope? A local variable could be from a scope outside the current pragma, so presumably we need to introduce PragmaExprs on the initializers of all variables within pragmas.

This sort of problem is why having the pragma state be an argument rather than global state is so much more attractive. And making it an argument is much more disruptive for clients, who must now do their own tracking, and recreate the state appropriately when calling outside the context.

Storing the pragma state in the expressions avoids these problems much more cleanly.

[sepavloff]

In D77545#1974509, @rjmccall wrote:

For example, in this code:

const float global = 2.22 + 3.33;

#pragma STDV FENV_ROUND <direction>
float getGlobal() { return global; }

The code-generation of getGlobal will attempt to constant-evaluate the initializer of global so that it can just return a constant instead of emitting a load from a global. It is important for correctness that this constant-evaluation occur in the default FP environment, not the active FP environment at the point of use. Presumably you are not proposing that global's initializer is a PragmaExpr, since it's in the default environment. Perhaps we can recognize by the *absence* of a PragmaExpr that it's meant to use the default environment? It's not clear at what level we would trigger this check, however. Is it now semantically important that we call a method like VarDecl::evaluateValue() rather than Expr::EvaluateAsFloat(...)? What happens with variables in local scope? A local variable could be from a scope outside the current pragma, so presumably we need to introduce PragmaExprs on the initializers of all variables within pragmas.

As you correctly noted, putting PragmaExpr around initializer expression even in default environment solves all these problems. This solution may be improved to put PragmaExpr only when the expression may be dependent on FP environment.

This sort of problem is why having the pragma state be an argument rather than global state is so much more attractive. And making it an argument is much more disruptive for clients, who must now do their own tracking, and recreate the state appropriately when calling outside the context.

Storing the pragma state in the expressions avoids these problems much more cleanly.

I see at least two issues with such solution:

1. There are cases when part of AST should be interpreted in other context than it was created. The example was presented earlier, this is constexpr function evaluation:

        #pragma STDC FENV_ACCESS ON
	constexpr float func(float x, float y) { return x + y;	}
	
	#pragma STDC FENV_ROUND FE_DOWNWARD
	float V1 = func(1.11, 2.22);
	
	#pragma STDC FENV_ROUND FE_UPWARD
	float V2 = func(1.11, 2.22);

If FP environment is encoded in AST nodes, then the body of func should use FE_DYNAMIC as rounding mode. During evaluation such nodes this value should be replaced by the rounding mode taken from current context. Constant evaluator anyway should use global state and RoundingMode::Dynamic must be interpreted specifically.

2. This solution requires huge changes to AST node implementation, as demonstrated by D76384. And what will we do with CallExpr and CastExpr, which already have TrailingObjects? How this solution can be extended? For instance, we may want to make ExprWithCleanups sensitive to FP environment so that it can restore previous state. We have to start with redesign of ExprWithCleanups so that it contains FPOptions. As this node already contains TrailingObjects it is not a trivial task. Any node that designates an operation that can depend on FP state should be reworked first.

In contrast, using special nodes to represent global state make this task transparently. No changes are required to existing AST nodes, only AST consumers that are aware of FP state need to be updated. This way looks more robust due to orthogonal and less invasive implementation.

[rjmccall]

In D77545#1977688, @sepavloff wrote:

In D77545#1974509, @rjmccall wrote:

For example, in this code:

const float global = 2.22 + 3.33;

#pragma STDV FENV_ROUND <direction>
float getGlobal() { return global; }

The code-generation of getGlobal will attempt to constant-evaluate the initializer of global so that it can just return a constant instead of emitting a load from a global. It is important for correctness that this constant-evaluation occur in the default FP environment, not the active FP environment at the point of use. Presumably you are not proposing that global's initializer is a PragmaExpr, since it's in the default environment. Perhaps we can recognize by the *absence* of a PragmaExpr that it's meant to use the default environment? It's not clear at what level we would trigger this check, however. Is it now semantically important that we call a method like VarDecl::evaluateValue() rather than Expr::EvaluateAsFloat(...)? What happens with variables in local scope? A local variable could be from a scope outside the current pragma, so presumably we need to introduce PragmaExprs on the initializers of all variables within pragmas.

As you correctly noted, putting PragmaExpr around initializer expression even in default environment solves all these problems. This solution may be improved to put PragmaExpr only when the expression may be dependent on FP environment.

As someone who's very familiar with how Clang and its various tools generally use the constant evaluator, I am telling you that reasoning by implication from the presence or absence of a direct PragmaExpr on an initializer is going to involve a lot of extremely subtle interactions and a very long tail of bugs. Since those bugs are going to be localized to this one extremely obscure feature, I do not think that is a good idea.

This sort of problem is why having the pragma state be an argument rather than global state is so much more attractive. And making it an argument is much more disruptive for clients, who must now do their own tracking, and recreate the state appropriately when calling outside the context.

Storing the pragma state in the expressions avoids these problems much more cleanly.

I see at least two issues with such solution:

1. There are cases when part of AST should be interpreted in other context than it was created. The example was presented earlier, this is constexpr function evaluation:

        #pragma STDC FENV_ACCESS ON
	constexpr float func(float x, float y) { return x + y;	}
	
	#pragma STDC FENV_ROUND FE_DOWNWARD
	float V1 = func(1.11, 2.22);
	
	#pragma STDC FENV_ROUND FE_UPWARD
	float V2 = func(1.11, 2.22);

If FP environment is encoded in AST nodes, then the body of func should use FE_DYNAMIC as rounding mode. During evaluation such nodes this value should be replaced by the rounding mode taken from current context. Constant evaluator anyway should use global state and RoundingMode::Dynamic must be interpreted specifically.

(1) It is not a good idea to use actual global state to model machine state within a constant evaluation because information is extremely prone to leaking in and out.
(2) We are specifically *required* by the standard to ignore FENV_ACCESS ON pragmas in mandatory constant evaluation.

2. This solution requires huge changes to AST node implementation, as demonstrated by D76384.

That patch has actually gotten much smaller.

And what will we do with CallExpr and CastExpr, which already have TrailingObjects?

It's actually quite easy to add more trailing fields to an AST node that already has them. Most of the boilerplate in D76384 is from switching new-expessions to calls to static factories, but you don't need to do that when a node is already using factories.

For instance, we may want to make ExprWithCleanups sensitive to FP environment so that it can restore previous state. We have to start with redesign of ExprWithCleanups so that it contains FPOptions. As this node already contains TrailingObjects it is not a trivial task.

This representation does not model these things as explicit FP environment state changes that would need to be undone on an exception. But also, adding more trailing objects to a node is not a significant burden.

[sepavloff]

FPOptions is now stored in AST objects.

clang/include/clang/AST/EvaluatedExprVisitor.h

 //===--- EvaluatedExprVisitor.h - Evaluated expression visitor --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
void VisitLambdaExpr(PTR(LambdaExpr) LE) {
     // Only visit the capture initializers, and not the body.
     for (LambdaExpr::const_capture_init_iterator I = LE->capture_init_begin(),
                                                  E = LE->capture_init_end();
          I != E; ++I)
       if (*I)
         this->Visit(*I);
   }
 
+  void VisitFPEnvironmentExpr(PTR(FPEnvironmentExpr) E) {
+    this->Visit(E->getSubExpr());
+  }
+
   /// The basis case walks all of the children of the statement or
   /// expression, assuming they are all potentially evaluated.
   void VisitStmt(PTR(Stmt) S) {
     for (auto *SubStmt : S->children())
       if (SubStmt)
         this->Visit(SubStmt);
   }
 

clang/include/clang/AST/Expr.h

 //===--- Expr.h - Classes for representing expressions ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
private:
 
   SourceLocation BeginLoc, EndLoc;
   unsigned NumExprs;
   friend TrailingObjects;
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
 
+class FPEnvironmentExpr : public Expr {
+  friend class ASTStmtReader;
+  friend class ASTStmtWriter;
+
+  /// Expression that is calculated in floating point environment specified by
+  /// this node.
+  Stmt *SubExpr;
+
+  /// FP Environment in which the contained expression is evaluated.
+  FPOptions FPFeatures;
+
+public:
+  FPEnvironmentExpr(EmptyShell Empty) : Expr(FPEnvironmentExprClass, Empty) {}
+  FPEnvironmentExpr(Expr *E, const FPOptions &F)
+    : Expr(FPEnvironmentExprClass, E->getType(), E->getValueKind(),
+           E->getObjectKind()), SubExpr(E), FPFeatures(F) {}
+
+  const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
+  Expr *getSubExpr() { return cast<Expr>(SubExpr); }
+
+  const FPOptions &getFPOptions() const { return FPFeatures; }
+  FPOptions &getFPOptions() { return FPFeatures; }
+
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    return SubExpr->getBeginLoc();
+  }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return SubExpr->getEndLoc();
+  }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == FPEnvironmentExprClass;
+  }
+  static bool classof(const FPEnvironmentExpr *T) { return true; }
+
+  // Iterators
+  child_range children() {
+    return child_range(&SubExpr, &SubExpr + 1);
+  }
+  const_child_range children() const {
+    return const_child_range(&SubExpr, &SubExpr + 1);
+  }
+};
+
 } // end namespace clang
 
 #endif // LLVM_CLANG_AST_EXPR_H

clang/include/clang/AST/RecursiveASTVisitor.h

 //===--- RecursiveASTVisitor.h - Recursive AST Visitor ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 DEF_TRAVERSE_STMT(CXXNoexceptExpr, {})
 DEF_TRAVERSE_STMT(PackExpansionExpr, {})
 DEF_TRAVERSE_STMT(SizeOfPackExpr, {})
 DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmPackExpr, {})
 DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmExpr, {})
 DEF_TRAVERSE_STMT(FunctionParmPackExpr, {})
 DEF_TRAVERSE_STMT(CXXFoldExpr, {})
 DEF_TRAVERSE_STMT(AtomicExpr, {})
+DEF_TRAVERSE_STMT(FPEnvironmentExpr, {})
 
 DEF_TRAVERSE_STMT(MaterializeTemporaryExpr, {
   if (S->getLifetimeExtendedTemporaryDecl()) {
     TRY_TO(TraverseLifetimeExtendedTemporaryDecl(
         S->getLifetimeExtendedTemporaryDecl()));
     ShouldVisitChildren = false;
   }
 })

clang/include/clang/AST/TextNodeDumper.h

 //===--- TextNodeDumper.h - Printing of AST nodes -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
   void dumpLocation(SourceLocation Loc);
   void dumpSourceRange(SourceRange R);
   void dumpBareType(QualType T, bool Desugar = true);
   void dumpType(QualType T);
   void dumpBareDeclRef(const Decl *D);
   void dumpName(const NamedDecl *ND);
   void dumpAccessSpecifier(AccessSpecifier AS);
   void dumpCleanupObject(const ExprWithCleanups::CleanupObject &C);
+  void dumpFPOptions(const FPOptions &FPO);
 
   void dumpDeclRef(const Decl *D, StringRef Label = {});
 
   void visitTextComment(const comments::TextComment *C,
                         const comments::FullComment *);
   void visitInlineCommandComment(const comments::InlineCommandComment *C,
                                  const comments::FullComment *);
   void visitHTMLStartTagComment(const comments::HTMLStartTagComment *C,
#include "clang/AST/AttrTextNodeDump.inc"
   void VisitObjCBoxedExpr(const ObjCBoxedExpr *Node);
   void VisitObjCSelectorExpr(const ObjCSelectorExpr *Node);
   void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node);
   void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node);
   void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node);
   void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node);
   void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node);
   void VisitOMPIteratorExpr(const OMPIteratorExpr *Node);
+  void VisitFPEnvironmentExpr(const FPEnvironmentExpr *Node);
 
   void VisitRValueReferenceType(const ReferenceType *T);
   void VisitArrayType(const ArrayType *T);
   void VisitConstantArrayType(const ConstantArrayType *T);
   void VisitVariableArrayType(const VariableArrayType *T);
   void VisitDependentSizedArrayType(const DependentSizedArrayType *T);
   void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T);
   void VisitVectorType(const VectorType *T);

clang/include/clang/Basic/LangOptions.h

 //===- LangOptions.h - C Language Family Language Options -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
#include "clang/Basic/LangOptions.def"
   }
 
   /// Check if leaf functions are also signed.
   bool isSignReturnAddressScopeAll() const {
     return getSignReturnAddressScope() == SignReturnAddressScopeKind::All;
   }
 };
 
+/// Returns text representation for the given contract mode value.
+/// If \a ShortMode is true, only corresponding switch value ("ON", "OFF" or
+/// "FAST") is returned, otherwise the output string looks like "contract(on)".
+///
+StringRef spell(LangOptions::FPContractModeKind X, bool ShortForm);
+
 /// Floating point control options
 class FPOptions {
 public:
   FPOptions() : fp_contract(LangOptions::FPC_Off),
                 fenv_access(LangOptions::FEA_Off),
                 rounding(LangOptions::FPR_ToNearest),
                 exceptions(LangOptions::FPE_Ignore)
         {}
public:
   }
 
   void setAllowFPContractAcrossStatement() {
     fp_contract = LangOptions::FPC_Fast;
   }
 
   void setDisallowFPContract() { fp_contract = LangOptions::FPC_Off; }
 
+  LangOptions::FPContractModeKind getContract() const {
+    return static_cast<LangOptions::FPContractModeKind>(fp_contract);
+  }
+
+  void setContract(LangOptions::FPContractModeKind X) { fp_contract = X; }
+
   bool allowFEnvAccess() const {
     return fenv_access == LangOptions::FEA_On;
   }
 
   void setAllowFEnvAccess() {
     fenv_access = LangOptions::FEA_On;
   }
 
public:
   }
 
   bool isFPConstrained() const {
     return getRoundingMode() != LangOptions::FPR_ToNearest ||
            getExceptionMode() != LangOptions::FPE_Ignore ||
            allowFEnvAccess();
   }
 
+  bool isDefault() const { return *this == FPOptions(); }
+
   /// Used to serialize this.
   unsigned getInt() const {
     return fp_contract | (fenv_access << 2) | (rounding << 3)
         | (exceptions << 6);
   }
 
+  bool operator == (const FPOptions &O) const {
+    return fp_contract == O.fp_contract &&
+           fenv_access == O.fenv_access &&
+           rounding == O.rounding &&
+           exceptions == O.exceptions;
+  }
+
+  bool operator != (const FPOptions &O) const { return !operator==(O); }
+
 private:
   /// Adjust BinaryOperatorBitfields::FPFeatures and
   /// CXXOperatorCallExprBitfields::FPFeatures to match the total bit-field size
   /// of these fields.
   unsigned fp_contract : 2;
   unsigned fenv_access : 1;
   unsigned rounding : 3;
   unsigned exceptions : 2;

clang/include/clang/Basic/StmtNodes.td

 def NoInitExpr : StmtNode<Expr>;
 def ArrayInitLoopExpr : StmtNode<Expr>;
 def ArrayInitIndexExpr : StmtNode<Expr>;
 def ParenListExpr : StmtNode<Expr>;
 def VAArgExpr : StmtNode<Expr>;
 def GenericSelectionExpr : StmtNode<Expr>;
 def PseudoObjectExpr : StmtNode<Expr>;
 def SourceLocExpr : StmtNode<Expr>;
+def FPEnvironmentExpr : StmtNode<Expr>;
 
 // Wrapper expressions
 def FullExpr : StmtNode<Expr, 1>;
 def ConstantExpr : StmtNode<FullExpr>;
 
 // Atomic expressions
 def AtomicExpr : StmtNode<Expr>;
 

clang/include/clang/Sema/Sema.h

 //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
                                        UnqualifiedId &SecondTypeName);
 
   ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
                                        SourceLocation OpLoc,
                                        tok::TokenKind OpKind,
                                        SourceLocation TildeLoc,
                                        const DeclSpec& DS);
 
+  ExprResult BuildFPEnvironmentExpr(Expr *S, const FPOptions &FPO);
+
   /// MaybeCreateExprWithCleanups - If the current full-expression
   /// requires any cleanups, surround it with a ExprWithCleanups node.
   /// Otherwise, just returns the passed-in expression.
   Expr *MaybeCreateExprWithCleanups(Expr *SubExpr);
   Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt);
   ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr);
 
   MaterializeTemporaryExpr *

clang/include/clang/Serialization/ASTBitCodes.h

 //===- ASTBitCodes.h - Enum values for the PCH bitcode format ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
enum StmtCode {
       EXPR_PSEUDO_OBJECT,
 
       /// An AtomicExpr record.
       EXPR_ATOMIC,
 
       /// A RecoveryExpr record.
       EXPR_RECOVERY,
 
+      /// An FPEnvironmentExpr,
+      EXPR_FP_ENVIRONMENT,
+
       // Objective-C
 
       /// An ObjCStringLiteral record.
       EXPR_OBJC_STRING_LITERAL,
 
       EXPR_OBJC_BOXED_EXPRESSION,
       EXPR_OBJC_ARRAY_LITERAL,
       EXPR_OBJC_DICTIONARY_LITERAL,
enum StmtCode {
       EXPR_USER_DEFINED_LITERAL,
 
       /// A CXXStdInitializerListExpr record.
       EXPR_CXX_STD_INITIALIZER_LIST,
 
       /// A CXXBoolLiteralExpr record.
       EXPR_CXX_BOOL_LITERAL,
 
       EXPR_CXX_NULL_PTR_LITERAL,  // CXXNullPtrLiteralExpr
       EXPR_CXX_TYPEID_EXPR,       // CXXTypeidExpr (of expr).
       EXPR_CXX_TYPEID_TYPE,       // CXXTypeidExpr (of type).
       EXPR_CXX_THIS,              // CXXThisExpr
       EXPR_CXX_THROW,             // CXXThrowExpr
       EXPR_CXX_DEFAULT_ARG,       // CXXDefaultArgExpr
       EXPR_CXX_DEFAULT_INIT,      // CXXDefaultInitExpr
       EXPR_CXX_BIND_TEMPORARY,    // CXXBindTemporaryExpr
 
       EXPR_CXX_SCALAR_VALUE_INIT, // CXXScalarValueInitExpr
       EXPR_CXX_NEW,               // CXXNewExpr
       EXPR_CXX_DELETE,            // CXXDeleteExpr
       EXPR_CXX_PSEUDO_DESTRUCTOR, // CXXPseudoDestructorExpr
 
       EXPR_EXPR_WITH_CLEANUPS,    // ExprWithCleanups
 
       EXPR_CXX_DEPENDENT_SCOPE_MEMBER,   // CXXDependentScopeMemberExpr
       EXPR_CXX_DEPENDENT_SCOPE_DECL_REF, // DependentScopeDeclRefExpr
       EXPR_CXX_UNRESOLVED_CONSTRUCT,     // CXXUnresolvedConstructExpr
       EXPR_CXX_UNRESOLVED_MEMBER,        // UnresolvedMemberExpr
       EXPR_CXX_UNRESOLVED_LOOKUP,        // UnresolvedLookupExpr
 
       EXPR_CXX_EXPRESSION_TRAIT,  // ExpressionTraitExpr
       EXPR_CXX_NOEXCEPT,          // CXXNoexceptExpr
 
       EXPR_OPAQUE_VALUE,          // OpaqueValueExpr
       EXPR_BINARY_CONDITIONAL_OPERATOR,  // BinaryConditionalOperator
       EXPR_TYPE_TRAIT,            // TypeTraitExpr
       EXPR_ARRAY_TYPE_TRAIT,      // ArrayTypeTraitIntExpr
 
       EXPR_PACK_EXPANSION,        // PackExpansionExpr
       EXPR_SIZEOF_PACK,           // SizeOfPackExpr
       EXPR_SUBST_NON_TYPE_TEMPLATE_PARM, // SubstNonTypeTemplateParmExpr
       EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK,// SubstNonTypeTemplateParmPackExpr
       EXPR_FUNCTION_PARM_PACK,    // FunctionParmPackExpr
       EXPR_MATERIALIZE_TEMPORARY, // MaterializeTemporaryExpr
       EXPR_CXX_FOLD,              // CXXFoldExpr
       EXPR_CONCEPT_SPECIALIZATION,// ConceptSpecializationExpr
       EXPR_REQUIRES,              // RequiresExpr
 
       // CUDA
       EXPR_CUDA_KERNEL_CALL,       // CUDAKernelCallExpr
 
       // OpenCL
       EXPR_ASTYPE,                 // AsTypeExpr
 
       // Microsoft
       EXPR_CXX_PROPERTY_REF_EXPR, // MSPropertyRefExpr
       EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR, // MSPropertySubscriptExpr
       EXPR_CXX_UUIDOF_EXPR,       // CXXUuidofExpr (of expr).
       EXPR_CXX_UUIDOF_TYPE,       // CXXUuidofExpr (of type).
       STMT_SEH_LEAVE,             // SEHLeaveStmt
       STMT_SEH_EXCEPT,            // SEHExceptStmt
       STMT_SEH_FINALLY,           // SEHFinallyStmt
       STMT_SEH_TRY,               // SEHTryStmt
 
       // OpenMP directives
       STMT_OMP_PARALLEL_DIRECTIVE,
enum StmtCode {
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
       EXPR_OMP_ARRAY_SECTION,
       EXPR_OMP_ARRAY_SHAPING,
       EXPR_OMP_ITERATOR,
 
       // ARC
       EXPR_OBJC_BRIDGED_CAST,     // ObjCBridgedCastExpr
 
       STMT_MS_DEPENDENT_EXISTS,   // MSDependentExistsStmt
       EXPR_LAMBDA,                // LambdaExpr
       STMT_COROUTINE_BODY,
       STMT_CORETURN,
       EXPR_COAWAIT,
       EXPR_COYIELD,
       EXPR_DEPENDENT_COAWAIT,
     };
 

clang/lib/AST/Expr.cpp

 //===--- Expr.cpp - Expression AST Node Implementation --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case SubstNonTypeTemplateParmExprClass:
     return cast<SubstNonTypeTemplateParmExpr>(this)->getReplacement()
       ->isConstantInitializer(Ctx, false, Culprit);
   case CXXDefaultArgExprClass:
     return cast<CXXDefaultArgExpr>(this)->getExpr()
       ->isConstantInitializer(Ctx, false, Culprit);
   case CXXDefaultInitExprClass:
     return cast<CXXDefaultInitExpr>(this)->getExpr()
       ->isConstantInitializer(Ctx, false, Culprit);
+  case FPEnvironmentExprClass:
+    return cast<FPEnvironmentExpr>(this)->getSubExpr()
+      ->isConstantInitializer(Ctx, IsForRef, Culprit);
   }
   // Allow certain forms of UB in constant initializers: signed integer
   // overflow and floating-point division by zero. We'll give a warning on
   // these, but they're common enough that we have to accept them.
   if (isEvaluatable(Ctx, SE_AllowUndefinedBehavior))
     return true;
   if (Culprit)
     *Culprit = this;
bool Expr::HasSideEffects(const ASTContext &Ctx,
   case CXXPseudoDestructorExprClass:
   case CXXRewrittenBinaryOperatorClass:
   case CXXStdInitializerListExprClass:
   case SubstNonTypeTemplateParmExprClass:
   case MaterializeTemporaryExprClass:
   case ShuffleVectorExprClass:
   case ConvertVectorExprClass:
   case AsTypeExprClass:
+  case FPEnvironmentExprClass:
     // These have a side-effect if any subexpression does.
     break;
 
   case UnaryOperatorClass:
     if (cast<UnaryOperator>(this)->isIncrementDecrementOp())
       return true;
     break;
 

clang/lib/AST/ExprClassification.cpp

 //===- ExprClassification.cpp - Expression AST Node Implementation --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (E->isRValue())
       return ClassifyExprValueKind(Lang, E, E->getValueKind());
     assert(cast<InitListExpr>(E)->getNumInits() == 1 &&
            "Only 1-element init lists can be glvalues.");
     return ClassifyInternal(Ctx, cast<InitListExpr>(E)->getInit(0));
 
   case Expr::CoawaitExprClass:
   case Expr::CoyieldExprClass:
     return ClassifyInternal(Ctx, cast<CoroutineSuspendExpr>(E)->getResumeExpr());
+
+  case Expr::FPEnvironmentExprClass:
+    return ClassifyInternal(Ctx, cast<FPEnvironmentExpr>(E)->getSubExpr());
   }
 
   llvm_unreachable("unhandled expression kind in classification");
 }
 
 /// ClassifyDecl - Return the classification of an expression referencing the
 /// given declaration.
 static Cl::Kinds ClassifyDecl(ASTContext &Ctx, const Decl *D) {

clang/lib/AST/ExprConstant.cpp

 //===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
namespace {
   /// indicates whether the subexpression is "evaluated" or not according to C
   /// rules.  For example, the RHS of (0 && foo()) is not evaluated.  We can
   /// evaluate the expression regardless of what the RHS is, but C only allows
   /// certain things in certain situations.
   class EvalInfo : public interp::State {
   public:
     ASTContext &Ctx;
 
+    /// Keeps floating point options used in evaluation.
+    FPOptions FPFeatures;
+
     /// EvalStatus - Contains information about the evaluation.
     Expr::EvalStatus &EvalStatus;
 
     /// CurrentCall - The top of the constexpr call stack.
     CallStackFrame *CurrentCall;
 
     /// CallStackDepth - The number of calls in the call stack right now.
     unsigned CallStackDepth;
static bool cleanup(EvalInfo &Info, bool RunDestructors,
             std::remove_if(NewEnd, Info.CleanupStack.end(),
                            [](Cleanup &C) { return !C.isLifetimeExtended(); });
       Info.CleanupStack.erase(NewEnd, Info.CleanupStack.end());
       return Success;
     }
   };
   typedef ScopeRAII<false> BlockScopeRAII;
   typedef ScopeRAII<true> FullExpressionRAII;
+
+  class FPOptionsStateRAII {
+    EvalInfo &Info;
+    FPOptions SavedState;
+
+  public:
+    explicit FPOptionsStateRAII(EvalInfo &Info)
+        : Info(Info), SavedState(Info.FPFeatures) {
+    }
+
+    ~FPOptionsStateRAII() { Info.FPFeatures = SavedState; }
+  };
 }
 
 bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E,
                                          CheckSubobjectKind CSK) {
   if (Invalid)
     return false;
   if (isOnePastTheEnd()) {
     Info.CCEDiag(E, diag::note_constexpr_past_end_subobject)
for (CompoundStmt::const_body_iterator BI = CS->body_begin(),
                       diag::note_constexpr_stmt_expr_unsupported);
         return false;
       }
     }
 
     llvm_unreachable("Return from function from the loop above.");
   }
 
+  bool VisitFPEnvironmentExpr(const FPEnvironmentExpr *E) {
+    FPOptionsStateRAII SavedFPFeatures(Info);
+    Info.FPFeatures = E->getFPOptions();
+    return StmtVisitorTy::Visit(E->getSubExpr());
+  }
+
   /// Visit a value which is evaluated, but whose value is ignored.
   void VisitIgnoredValue(const Expr *E) {
     EvaluateIgnoredValue(Info, E);
   }
 
   /// Potentially visit a MemberExpr's base expression.
   void VisitIgnoredBaseExpression(const Expr *E) {
     // While MSVC doesn't evaluate the base expression, it does diagnose the
#include "clang/AST/StmtNodes.inc"
   case Expr::ChooseExprClass: {
     return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(), Ctx);
   }
   case Expr::BuiltinBitCastExprClass: {
     if (!checkBitCastConstexprEligibility(nullptr, Ctx, cast<CastExpr>(E)))
       return ICEDiag(IK_NotICE, E->getBeginLoc());
     return CheckICE(cast<CastExpr>(E)->getSubExpr(), Ctx);
   }
+  case Expr::FPEnvironmentExprClass:
+    return CheckICE(cast<FPEnvironmentExpr>(E)->getSubExpr(), Ctx);
   }
 
   llvm_unreachable("Invalid StmtClass!");
 }
 
 /// Evaluate an expression as a C++11 integral constant expression.
 static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx,
                                                     const Expr *E,

clang/lib/AST/ItaniumMangle.cpp

 //===--- ItaniumMangle.cpp - Itanium C++ Name Mangling ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case Expr::DependentCoawaitExprClass:
     mangleExpression(cast<DependentCoawaitExpr>(E)->getOperand());
     break;
 
   case Expr::CoyieldExprClass:
     // FIXME: Propose a non-vendor mangling.
     Out << "v18co_yield";
     mangleExpression(cast<CoawaitExpr>(E)->getOperand());
     break;
+
+  case Expr::FPEnvironmentExprClass:
+    mangleExpression(cast<FPEnvironmentExpr>(E)->getSubExpr());
+    break;
   }
 }
 
 /// Mangle an expression which refers to a parameter variable.
 ///
 /// <expression>     ::= <function-param>
 /// <function-param> ::= fp <top-level CV-qualifiers> _      # L == 0, I == 0
 /// <function-param> ::= fp <top-level CV-qualifiers>

clang/lib/AST/StmtPrinter.cpp

 //===- StmtPrinter.cpp - Printing implementation for Stmt ASTs ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {
   OS << "__builtin_astype(";
   PrintExpr(Node->getSrcExpr());
   OS << ", ";
   Node->getType().print(OS, Policy);
   OS << ")";
 }
 
+void StmtPrinter::VisitFPEnvironmentExpr(FPEnvironmentExpr *Node) {
+  PrintExpr(Node->getSubExpr());
+}
+
 //===----------------------------------------------------------------------===//
 // Stmt method implementations
 //===----------------------------------------------------------------------===//
 
 void Stmt::dumpPretty(const ASTContext &Context) const {
   printPretty(llvm::errs(), nullptr, PrintingPolicy(Context.getLangOpts()));
 }
 

clang/lib/AST/StmtProfile.cpp

 //===---- StmtProfile.cpp - Profile implementation for Stmt ASTs ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 }
 
 void StmtProfiler::VisitSourceLocExpr(const SourceLocExpr *E) {
   VisitExpr(E);
 }
 
 void StmtProfiler::VisitRecoveryExpr(const RecoveryExpr *E) { VisitExpr(E); }
 
+void StmtProfiler::VisitFPEnvironmentExpr(const FPEnvironmentExpr *E) {
+  VisitExpr(E);
+}
+
 void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
   VisitExpr(E);
 }
 

clang/lib/AST/TextNodeDumper.cpp

 //===--- TextNodeDumper.cpp - Printing of AST nodes -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
AddChild([=] {
         OS << CLE->getStmtClassName();
       }
       dumpPointer(CLE);
     });
   else
     llvm_unreachable("unexpected cleanup type");
 }
 
+void TextNodeDumper::dumpFPOptions(const FPOptions& FPO) {
+  OS << spell(FPO.getContract(), false);
+}
+
 void TextNodeDumper::dumpDeclRef(const Decl *D, StringRef Label) {
   if (!D)
     return;
 
   AddChild([=] {
     if (!Label.empty())
       OS << Label << ' ';
     dumpBareDeclRef(D);
for (unsigned I = 0, E = Node->numOfIterators(); I < E; ++I) {
     Visit(Range.End);
     if (Range.Step) {
       OS << " step ";
       Visit(Range.Step);
     }
   }
 }
 
+void TextNodeDumper::VisitFPEnvironmentExpr(const FPEnvironmentExpr *Node) {
+  OS << " ";
+  dumpFPOptions(Node->getFPOptions());
+}
+
 void TextNodeDumper::VisitRValueReferenceType(const ReferenceType *T) {
   if (T->isSpelledAsLValue())
     OS << " written as lvalue reference";
 }
 
 void TextNodeDumper::VisitArrayType(const ArrayType *T) {
   switch (T->getSizeModifier()) {
   case ArrayType::Normal:

clang/lib/Basic/LangOptions.cpp

 //===- LangOptions.cpp - C Language Family Language Options ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (FuncName.equals(NoBuiltinFuncs[i]))
       return true;
   return false;
 }
 
 VersionTuple LangOptions::getOpenCLVersionTuple() const {
   const int Ver = OpenCLCPlusPlus ? OpenCLCPlusPlusVersion : OpenCLVersion;
   return VersionTuple(Ver / 100, (Ver % 100) / 10);
 }
+
+StringRef clang::spell(LangOptions::FPContractModeKind X, bool ShortForm) {
+  switch (X) {
+  case LangOptions::FPC_Off:
+    return ShortForm ? "OFF" : "contract(off)";
+  case LangOptions::FPC_On:
+    return ShortForm ? "ON" : "contract(on)";
+  case LangOptions::FPC_Fast:
+    return ShortForm ? "FAST" : "contract(fast)";
+  }
+  llvm_unreachable("Unexpected value");
+}

clang/lib/CodeGen/CGExprAgg.cpp

 //===--- CGExprAgg.cpp - Emit LLVM Code from Aggregate Expressions --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
   void EmitInitializationToLValue(Expr *E, LValue Address);
   void EmitNullInitializationToLValue(LValue Address);
   //  case Expr::ChooseExprClass:
   void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
   void VisitAtomicExpr(AtomicExpr *E) {
     RValue Res = CGF.EmitAtomicExpr(E);
     EmitFinalDestCopy(E->getType(), Res);
   }
+  void VisitFPEnvironmentExpr(FPEnvironmentExpr* E) {
+    FPOptions SavedFPFeatures = CGF.FPFeatures;
+    return Visit(E->getSubExpr());
+    CGF.FPFeatures = SavedFPFeatures;
+  }
 };
 }  // end anonymous namespace.
 
 //===----------------------------------------------------------------------===//
 //                                Utilities
 //===----------------------------------------------------------------------===//
 
 /// EmitAggLoadOfLValue - Given an expression with aggregate type that

clang/lib/CodeGen/CGExprConstant.cpp

 //===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E, QualType T) {
     Str.resize(CAT->getSize().getZExtValue(), '\0');
     return llvm::ConstantDataArray::getString(VMContext, Str, false);
   }
 
   llvm::Constant *VisitUnaryExtension(const UnaryOperator *E, QualType T) {
     return Visit(E->getSubExpr(), T);
   }
 
+  llvm::Constant *VisitFPEnvironmentExpr(FPEnvironmentExpr *E, QualType T) {
+    FPOptions SavedFPFeatures = Emitter.FPFeatures;
+    Emitter.FPFeatures = E->getFPOptions();
+    llvm::Constant *Result = Visit(E->getSubExpr(), T);
+    Emitter.FPFeatures = SavedFPFeatures;
+    return Result;
+  }
+
   // Utility methods
   llvm::Type *ConvertType(QualType T) {
     return CGM.getTypes().ConvertType(T);
   }
 };
 
 }  // end anonymous namespace.
 

clang/lib/CodeGen/CGExprScalar.cpp

 //===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
#undef VISITCOMP
   Value *VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
     return CGF.EmitObjCArrayLiteral(E);
   }
   Value *VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
     return CGF.EmitObjCDictionaryLiteral(E);
   }
   Value *VisitAsTypeExpr(AsTypeExpr *CE);
   Value *VisitAtomicExpr(AtomicExpr *AE);
+  Value *VisitFPEnvironmentExpr(FPEnvironmentExpr *E);
 };
 }  // end anonymous namespace.
 
 //===----------------------------------------------------------------------===//
 //                                Utilities
 //===----------------------------------------------------------------------===//
 
 /// EmitConversionToBool - Convert the specified expression value to a
Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
 
   return Val;
 }
 
 Value *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *block) {
   return CGF.EmitBlockLiteral(block);
 }
 
+Value *ScalarExprEmitter::VisitFPEnvironmentExpr(FPEnvironmentExpr *E) {
+  FPOptions SavedFPFeatures = CGF.FPFeatures;
+  return Visit(E->getSubExpr());
+  CGF.FPFeatures = SavedFPFeatures;
+}
+
 // Convert a vec3 to vec4, or vice versa.
 static Value *ConvertVec3AndVec4(CGBuilderTy &Builder, CodeGenFunction &CGF,
                                  Value *Src, unsigned NumElementsDst) {
   llvm::Value *UnV = llvm::UndefValue::get(Src->getType());
   SmallVector<llvm::Constant*, 4> Args;
   Args.push_back(Builder.getInt32(0));
   Args.push_back(Builder.getInt32(1));
   Args.push_back(Builder.getInt32(2));

clang/lib/CodeGen/CGOpenCLRuntime.cpp

 //===----- CGOpenCLRuntime.cpp - Interface to OpenCL Runtimes -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 // reassigned.
 static const BlockExpr *getBlockExpr(const Expr *E) {
   const Expr *Prev = nullptr; // to make sure we do not stuck in infinite loop.
   while(!isa<BlockExpr>(E) && E != Prev) {
     Prev = E;
     E = E->IgnoreCasts();
     if (auto DR = dyn_cast<DeclRefExpr>(E)) {
       E = cast<VarDecl>(DR->getDecl())->getInit();
+      if (auto FPE = dyn_cast<FPEnvironmentExpr>(E))
+        E = FPE->getSubExpr();
     }
   }
   return cast<BlockExpr>(E);
 }
 
 /// Record emitted llvm invoke function and llvm block literal for the
 /// corresponding block expression.
 void CGOpenCLRuntime::recordBlockInfo(const BlockExpr *E,

clang/lib/CodeGen/CodeGenFunction.h

 //===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
       }
 
       ~InlinedRegionBodyRAII() { CGF.AllocaInsertPt = OldAllocaIP; }
     };
   };
 
   CodeGenModule &CGM;  // Per-module state.
   const TargetInfo &Target;
+  FPOptions FPFeatures;
 
   typedef std::pair<llvm::Value *, llvm::Value *> ComplexPairTy;
   LoopInfoStack LoopStack;
   CGBuilderTy Builder;
 
   // Stores variables for which we can't generate correct lifetime markers
   // because of jumps.
   VarBypassDetector Bypasses;

clang/lib/CodeGen/ConstantEmitter.h

 //===--- ConstantEmitter.h - IR constant emission ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 
 namespace clang {
 namespace CodeGen {
 
 class ConstantEmitter {
 public:
   CodeGenModule &CGM;
   CodeGenFunction *const CGF;
+  FPOptions FPFeatures;
 
 private:
   bool Abstract = false;
 
   /// Whether non-abstract components of the emitter have been initialized.
   bool InitializedNonAbstract = false;
 
   /// Whether the emitter has been finalized.
private:
   /// Used for generating appropriate placeholders.
   LangAS DestAddressSpace;
 
   llvm::SmallVector<std::pair<llvm::Constant *, llvm::GlobalVariable*>, 4>
     PlaceholderAddresses;
 
 public:
   ConstantEmitter(CodeGenModule &CGM, CodeGenFunction *CGF = nullptr)
-    : CGM(CGM), CGF(CGF) {}
+    : CGM(CGM), CGF(CGF) {
+    if (CGF)
+      FPFeatures = CGF->FPFeatures;
+  }
 
   /// Initialize this emission in the context of the given function.
   /// Use this if the expression might contain contextual references like
   /// block addresses or PredefinedExprs.
   ConstantEmitter(CodeGenFunction &CGF)
-    : CGM(CGF.CGM), CGF(&CGF) {}
+    : CGM(CGF.CGM), CGF(&CGF), FPFeatures(CGF.FPFeatures) {}
 
   ConstantEmitter(const ConstantEmitter &other) = delete;
   ConstantEmitter &operator=(const ConstantEmitter &other) = delete;
 
   ~ConstantEmitter();
 
   /// Is the current emission context abstract?
   bool isAbstract() const {

clang/lib/Sema/SemaCUDA.cpp

 //===--- SemaCUDA.cpp - Semantic Analysis for CUDA constructs -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
bool Sema::isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD) {
 
   // Its class has no virtual functions and no virtual base classes.
   if (CD->getParent()->isDynamicClass())
     return false;
 
   // The only form of initializer allowed is an empty constructor.
   // This will recursively check all base classes and member initializers
   if (!llvm::all_of(CD->inits(), [&](const CXXCtorInitializer *CI) {
-        if (const CXXConstructExpr *CE =
-                dyn_cast<CXXConstructExpr>(CI->getInit()))
+        const Expr *Init = CI->getInit();
+        if (auto FPE = dyn_cast<FPEnvironmentExpr>(Init))
+          Init = FPE->getSubExpr();
+        if (auto CE = dyn_cast<CXXConstructExpr>(Init))
           return isEmptyCudaConstructor(Loc, CE->getConstructor());
         return false;
       }))
     return false;
 
   return true;
 }
 
bool Sema::isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *DD) {
 
   return true;
 }
 
 void Sema::checkAllowedCUDAInitializer(VarDecl *VD) {
   if (VD->isInvalidDecl() || !VD->hasInit() || !VD->hasGlobalStorage())
     return;
   const Expr *Init = VD->getInit();
+  if (auto FPE = dyn_cast<FPEnvironmentExpr>(Init))
+    Init = FPE->getSubExpr();
   if (VD->hasAttr<CUDADeviceAttr>() || VD->hasAttr<CUDAConstantAttr>() ||
       VD->hasAttr<CUDASharedAttr>()) {
     if (LangOpts.GPUAllowDeviceInit)
       return;
     assert(!VD->isStaticLocal() || VD->hasAttr<CUDASharedAttr>());
     bool AllowedInit = false;
     if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(Init))
       AllowedInit =
           isEmptyCudaConstructor(VD->getLocation(), CE->getConstructor());
     // We'll allow constant initializers even if it's a non-empty
     // constructor according to CUDA rules. This deviates from NVCC,
     // but allows us to handle things like constexpr constructors.
     if (!AllowedInit &&
         (VD->hasAttr<CUDADeviceAttr>() || VD->hasAttr<CUDAConstantAttr>()))
-      AllowedInit = VD->getInit()->isConstantInitializer(
+      AllowedInit = Init->isConstantInitializer(
           Context, VD->getType()->isReferenceType());
 
     // Also make sure that destructor, if there is one, is empty.
     if (AllowedInit)
       if (CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl())
         AllowedInit =
             isEmptyCudaDestructor(VD->getLocation(), RD->getDestructor());
 

clang/lib/Sema/SemaDecl.cpp

 //===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
ExprResult Result =
       ActOnFinishFullExpr(Init, VDecl->getLocation(),
                           /*DiscardedValue*/ false, VDecl->isConstexpr());
   if (Result.isInvalid()) {
     VDecl->setInvalidDecl();
     return;
   }
   Init = Result.get();
 
+  // If the current set of floating point options is not default, wrap the
+  // initializer in a special node that keeps the options.
+  if (VDecl->isFileVarDecl() && !FPFeatures.isDefault()) {
+    ExprResult NewInit = BuildFPEnvironmentExpr(Init, FPFeatures);
+    assert(NewInit.isUsable());
+    Init = NewInit.get();
+  }
+
   // Attach the initializer to the decl.
   VDecl->setInit(Init);
 
   if (VDecl->isLocalVarDecl()) {
     // Don't check the initializer if the declaration is malformed.
     if (VDecl->isInvalidDecl()) {
       // do nothing
 

clang/lib/Sema/SemaDeclCXX.cpp

 //===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
   ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
   if (Result.isInvalid())
     return true;
   Arg = Result.getAs<Expr>();
 
   CheckCompletedExpr(Arg, EqualLoc);
   Arg = MaybeCreateExprWithCleanups(Arg);
 
+  // If the current set of floating point options is not default, wrap the
+  // default argument in a special node that keeps the options.
+  if (!FPFeatures.isDefault())
+    Arg = BuildFPEnvironmentExpr(Arg, FPFeatures).get();
+
   // Okay: add the default argument to the parameter
   Param->setDefaultArg(Arg);
 
   // We have already instantiated this parameter; provide each of the
   // instantiations with the uninstantiated default argument.
   UnparsedDefaultArgInstantiationsMap::iterator InstPos
     = UnparsedDefaultArgInstantiations.find(Param);
   if (InstPos != UnparsedDefaultArgInstantiations.end()) {
if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent()) {
     InitializationSequence Seq(*this, Entity, Kind, InitExpr);
     Init = Seq.Perform(*this, Entity, Kind, InitExpr);
     if (Init.isInvalid()) {
       FD->setInvalidDecl();
       return;
     }
   }
 
+  // If the current set of floating point options is not default, wrap the
+  // initializer in a special node that keeps the options.
+  if (Init.isUsable() && !FPFeatures.isDefault())
+    Init = BuildFPEnvironmentExpr(Init.get(), FPFeatures);
+
   // C++11 [class.base.init]p7:
   //   The initialization of each base and member constitutes a
   //   full-expression.
   Init = ActOnFinishFullExpr(Init.get(), InitLoc, /*DiscardedValue*/ false);
   if (Init.isInvalid()) {
     FD->setInvalidDecl();
     return;
   }
Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
   // C++11 [class.base.init]p7:
   //   The initialization of each base and member constitutes a
   //   full-expression.
   BaseInit = ActOnFinishFullExpr(BaseInit.get(), InitRange.getBegin(),
                                  /*DiscardedValue*/ false);
   if (BaseInit.isInvalid())
     return true;
 
+  // If the current set of floating point options is not default, wrap the
+  // initializer in a special node that keeps the options.
+  if (BaseInit.isUsable() && !FPFeatures.isDefault())
+    BaseInit = BuildFPEnvironmentExpr(BaseInit.get(), FPFeatures);
+
   // If we are in a dependent context, template instantiation will
   // perform this type-checking again. Just save the arguments that we
   // received in a ParenListExpr.
   // FIXME: This isn't quite ideal, since our ASTs don't capture all
   // of the information that we have about the base
   // initializer. However, deconstructing the ASTs is a dicey process,
   // and this approach is far more likely to get the corner cases right.
   if (CurContext->isDependentContext())

clang/lib/Sema/SemaExceptionSpec.cpp

 //===--- SemaExceptionSpec.cpp - C++ Exception Specifications ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
CanThrowResult Sema::canThrow(const Stmt *S) {
   case Expr::ObjCIsaExprClass:
   case Expr::ObjCIvarRefExprClass:
   case Expr::ParenExprClass:
   case Expr::ParenListExprClass:
   case Expr::ShuffleVectorExprClass:
   case Expr::StmtExprClass:
   case Expr::ConvertVectorExprClass:
   case Expr::VAArgExprClass:
+  case Expr::FPEnvironmentExprClass:
     return canSubStmtsThrow(*this, S);
 
   case Expr::CompoundLiteralExprClass:
   case Expr::CXXConstCastExprClass:
   case Expr::CXXReinterpretCastExprClass:
   case Expr::BuiltinBitCastExprClass:
       // FIXME: Properly determine whether a variably-modified type can throw.
     if (cast<Expr>(S)->getType()->isVariablyModifiedType())

clang/lib/Sema/SemaExpr.cpp

 //===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
ExprResult Sema::CreateRecoveryExpr(SourceLocation Begin, SourceLocation End,
   if (!Context.getLangOpts().RecoveryAST)
     return ExprError();
 
   if (isSFINAEContext())
     return ExprError();
 
   return RecoveryExpr::Create(Context, Begin, End, SubExprs);
 }
+
+ExprResult Sema::BuildFPEnvironmentExpr(Expr *E, const FPOptions &FPO) {
+  return new (Context) FPEnvironmentExpr(E, FPO);
+}

clang/lib/Sema/SemaInit.cpp

 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case SK_OCLSamplerInit: {
             break;
           }
           // Case 1a
           // For function call with a file-scope sampler variable as argument,
           // get the integer literal.
           // Do not diagnose if the file-scope variable does not have initializer
           // since this has already been diagnosed when parsing the variable
           // declaration.
-          if (!Var->getInit() || !isa<ImplicitCastExpr>(Var->getInit()))
+          const Expr *VarInit = Var->getInit();
+          if (VarInit)
+            if (auto FPE = dyn_cast<FPEnvironmentExpr>(VarInit))
+              VarInit = FPE->getSubExpr();
+          if (!VarInit || !isa<ImplicitCastExpr>(VarInit))
             break;
-          Init = cast<ImplicitCastExpr>(const_cast<Expr*>(
-            Var->getInit()))->getSubExpr();
+          Init =
+              cast<ImplicitCastExpr>(const_cast<Expr *>(VarInit))->getSubExpr();
           SourceType = Init->getType();
         }
       } else {
         // Case 2
         // Check initializer is 32 bit integer constant.
         // If the initializer is taken from global variable, do not diagnose since
         // this has already been done when parsing the variable declaration.
         if (!Init->isConstantInitializer(S.Context, false))

clang/lib/Sema/TreeTransform.h

 //===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //===----------------------------------------------------------------------===//
 //
 //  This file implements a semantic tree transformation that takes a given
return getSema().BuildAtomicExpr(Range, Range, RParenLoc, SubExprs, Op,
                                      Sema::AtomicArgumentOrder::AST);
   }
 
   ExprResult RebuildRecoveryExpr(SourceLocation BeginLoc, SourceLocation EndLoc,
                                  ArrayRef<Expr *> SubExprs) {
     return getSema().CreateRecoveryExpr(BeginLoc, EndLoc, SubExprs);
   }
 
+  ExprResult RebuildFPEnvironmentExpr(Expr *SubExpr, const FPOptions &FPO) {
+    return getSema().BuildFPEnvironmentExpr(SubExpr, FPO);
+  }
+
 private:
   TypeLoc TransformTypeInObjectScope(TypeLoc TL,
                                      QualType ObjectType,
                                      NamedDecl *FirstQualifierInScope,
                                      CXXScopeSpec &SS);
 
   TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
                                              QualType ObjectType,
for (Expr *C : E->subExpressions()) {
     Changed |= NewC.get() != C;
   }
   if (!getDerived().AlwaysRebuild() && !Changed)
     return E;
   return getDerived().RebuildRecoveryExpr(E->getBeginLoc(), E->getEndLoc(),
                                           Children);
 }
 
-template<typename Derived>
+template <typename Derived>
+ExprResult TreeTransform<Derived>::TransformFPEnvironmentExpr(
+                                                         FPEnvironmentExpr *E) {
+  ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
+  if (Result.isInvalid())
+    return ExprError();
+  return getDerived().RebuildFPEnvironmentExpr(Result.get(), E->getFPOptions());
+}
+
+template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
   // Rebuild the syntactic form.  The original syntactic form has
   // opaque-value expressions in it, so strip those away and rebuild
   // the result.  This is a really awful way of doing this, but the
   // better solution (rebuilding the semantic expressions and
   // rebinding OVEs as necessary) doesn't work; we'd need
   // TreeTransform to not strip away implicit conversions.

clang/lib/Serialization/ASTReaderStmt.cpp

 //===- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
   E->Op = AtomicExpr::AtomicOp(Record.readInt());
   E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
   for (unsigned I = 0; I != E->NumSubExprs; ++I)
     E->SubExprs[I] = Record.readSubExpr();
   E->BuiltinLoc = readSourceLocation();
   E->RParenLoc = readSourceLocation();
 }
 
+void ASTStmtReader::VisitFPEnvironmentExpr(FPEnvironmentExpr *E) {
+  VisitExpr(E);
+  E->getFPOptions() = FPOptions(Record.readInt());
+  Expr *SubExpr = Record.readSubExpr();
+  E->SubExpr = SubExpr;
+}
+
 //===----------------------------------------------------------------------===//
 // Objective-C Expressions and Statements
 
 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
   VisitExpr(E);
   E->setString(cast<StringLiteral>(Record.readSubStmt()));
   E->setAtLoc(readSourceLocation());
 }
case EXPR_BLOCK:
       break;
 
     case EXPR_GENERIC_SELECTION:
       S = GenericSelectionExpr::CreateEmpty(
           Context,
           /*NumAssocs=*/Record[ASTStmtReader::NumExprFields]);
       break;
 
+    case EXPR_FP_ENVIRONMENT:
+      S = new (Context) FPEnvironmentExpr(Empty);
+      break;
+
     case EXPR_OBJC_STRING_LITERAL:
       S = new (Context) ObjCStringLiteral(Empty);
       break;
 
     case EXPR_OBJC_BOXED_EXPRESSION:
       S = new (Context) ObjCBoxedExpr(Empty);
       break;
 

clang/lib/Serialization/ASTWriterStmt.cpp

 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
   Record.push_back(E->getOp());
   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
     Record.AddStmt(E->getSubExprs()[I]);
   Record.AddSourceLocation(E->getBuiltinLoc());
   Record.AddSourceLocation(E->getRParenLoc());
   Code = serialization::EXPR_ATOMIC;
 }
 
+void ASTStmtWriter::VisitFPEnvironmentExpr(FPEnvironmentExpr *E) {
+  VisitExpr(E);
+  Record.push_back(E->getFPOptions().getInt());
+  Record.AddStmt(E->getSubExpr());
+  Code = serialization::EXPR_FP_ENVIRONMENT;
+}
+
 //===----------------------------------------------------------------------===//
 // Objective-C Expressions and Statements.
 //===----------------------------------------------------------------------===//
 
 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
   VisitExpr(E);
   Record.AddStmt(E->getString());
   Record.AddSourceLocation(E->getAtLoc());

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

 //===- ExprEngine.cpp - Path-Sensitive Expression-Level Dataflow ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
switch (S->getStmtClass()) {
     case Stmt::ConvertVectorExprClass:
     case Stmt::VAArgExprClass:
     case Stmt::CUDAKernelCallExprClass:
     case Stmt::OpaqueValueExprClass:
     case Stmt::AsTypeExprClass:
     case Stmt::ConceptSpecializationExprClass:
     case Stmt::CXXRewrittenBinaryOperatorClass:
     case Stmt::RequiresExprClass:
+    case Stmt::FPEnvironmentExprClass:
       // Fall through.
 
     // Cases we intentionally don't evaluate, since they don't need
     // to be explicitly evaluated.
     case Stmt::PredefinedExprClass:
     case Stmt::AddrLabelExprClass:
     case Stmt::AttributedStmtClass:
     case Stmt::IntegerLiteralClass:

clang/test/AST/ast-dump-pragma.cpp

+// RUN: %clang_cc1 -ast-dump %s | FileCheck --check-prefixes=CHECK,NOOPT %s
+
+#pragma STDC FP_CONTRACT ON
+
+float var_01 = 1.1;
+
+// CHECK: VarDecl {{.*}} var_01
+// CHECK-NEXT: FPEnvironmentExpr {{.*}} contract(on)
+// CHECK-NEXT: ImplicitCastExpr
+// CHECK-NEXT: FloatingLiteral
+
+struct C1 {
+  float f1 = 1.1;
+};
+
+// CHECK: CXXRecordDecl {{.*}} struct C1
+// CHECK: FieldDecl {{.*}} f1
+// CHECK-NEXT: FPEnvironmentExpr {{.*}} contract(on)
+// CHECK-NEXT: ImplicitCastExpr
+// CHECK-NEXT: FloatingLiteral
+
+struct C2 {
+  C2(float);
+};
+
+struct C3 : public C2 {
+  C3(double x) : C2(x) {}
+};
+
+// CHECK: CXXRecordDecl {{.*}} struct C3
+// CHECK: CXXConstructorDecl {{.*}} C3 'void (double)'
+// CHECK: CXXCtorInitializer 'C2'
+// CHECK-NEXT: FPEnvironmentExpr {{.*}} contract(on)
+// CHECK-NEXT: CXXConstructExpr {{.*}} 'C2' 'void (float)'
+// CHECK-NEXT: ImplicitCastExpr
+// CHECK-NEXT: ImplicitCastExpr
+// CHECK-NEXT: DeclRefExpr {{.*}} 'x'
+
+void func_01(float x = 1.1);
+
+// CHECK: FunctionDecl {{.*}} func_01
+// CHECK-NEXT: ParmVarDecl
+// CHECK: FPEnvironmentExpr {{.*}} contract(on)
+// CHECK: ImplicitCastExpr
+// CHECK: FloatingLiteral

clang/test/CodeGen/fp-contract-pragma.cpp

 // RUN: %clang_cc1 -O3 -triple %itanium_abi_triple -emit-llvm -o - %s | FileCheck %s
 
 // Is FP_CONTRACT honored in a simple case?
 float fp_contract_1(float a, float b, float c) {
 // CHECK: _Z13fp_contract_1fff
 // CHECK: tail call float @llvm.fmuladd
   #pragma STDC FP_CONTRACT ON
   return a * b + c;

 
 float fp_contract_9(float a, float b, float c) {
 // CHECK: _Z13fp_contract_9fff
 // CHECK: fneg float %a
 // CHECK: tail call float @llvm.fmuladd
   #pragma STDC FP_CONTRACT ON
   return c - a * b;
 }
+
+
+#pragma STDC FP_CONTRACT ON
+struct C1 {
+  C1(float);
+};
+struct C2 : public C1 {
+  C2(float a, float b, float c);
+};
+C2::C2(float a, float b, float c) : C1(a*b+c) {}
+// CHECK: _ZN2C2C2Efff
+// CHECK: call float @llvm.fmuladd.f32

clang/tools/libclang/CXCursor.cpp

 //===- CXCursor.cpp - Routines for manipulating CXCursors -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
   case Stmt::SourceLocExprClass:
   case Stmt::ConvertVectorExprClass:
   case Stmt::VAArgExprClass:
   case Stmt::ObjCArrayLiteralClass:
   case Stmt::ObjCDictionaryLiteralClass:
   case Stmt::ObjCBoxedExprClass:
   case Stmt::ObjCSubscriptRefExprClass:
   case Stmt::RecoveryExprClass:
+  case Stmt::FPEnvironmentExprClass:
     K = CXCursor_UnexposedExpr;
     break;
 
   case Stmt::OpaqueValueExprClass:
     if (Expr *Src = cast<OpaqueValueExpr>(S)->getSourceExpr())
       return MakeCXCursor(Src, Parent, TU, RegionOfInterest);
     K = CXCursor_UnexposedExpr;
     break;