Represent FP options in AST by special Statement node

[sepavloff]

Summary

Now FPOption object is stored in the bits of Stmt class. The space
there is limited by 7 bits, which is by far not enough as FPOption
is supposed to grow incorporating other options related to floating
point operations. The problem was discussed in
http://lists.llvm.org/pipermail/cfe-dev/2020-March/064850.html. In
short, attempts to put FPOption as a field to relevant AST classes
result in substantial increase of AST size because such field would
consume memory even for nodes that do not deal with FP operations.

As a solution, a new statement node FloatingPragmaStmt has been
added. It represents a pragma that modifies floating point options.
This statement is placed at the beginning of corresponding
CompoundStmt. It provides persistency for the FP options and
allows to maintain actual FP state. Other nodes such as BinaryOperator
do not have to have a copy of FPOption, thus no unnecessary memory
consumption occurs.

If more than one pragma are specified in a compound statement, there
is a separate node for each. Each node keeps FP options accumulated
from all previous pragma nodes and from this one. Pragma specified
at file level results in pragma nodes implicitly inserted into every
function body affected by the pragma. In compilation option result
in non-default FP options, the synthesized pragma is inserted as well.

There are cases when an expression occurs outside compound statement.
These are global variable initializers, default arguments and some
other. This solution does not work for them, a special expression
node is required for them, it will be implemented later.

[sepavloff]

FPOptions is now stored in AST objects.

clang/include/clang-c/Index.h

enum CXCursorKind {
    * A declaration whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed declarations have the same operations as any other kind
    * of declaration; one can extract their location information,
    * spelling, find their definitions, etc. However, the specific kind
    * of the declaration is not reported.
    */
   CXCursor_UnexposedDecl                 = 1,
   /** A C or C++ struct. */
   CXCursor_StructDecl                    = 2,
   /** A C or C++ union. */
   CXCursor_UnionDecl                     = 3,
   /** A C++ class. */
   CXCursor_ClassDecl                     = 4,
   /** An enumeration. */
   CXCursor_EnumDecl                      = 5,
   /**
    * A field (in C) or non-static data member (in C++) in a
    * struct, union, or C++ class.
    */
   CXCursor_FieldDecl                     = 6,
   /** An enumerator constant. */
   CXCursor_EnumConstantDecl              = 7,
   /** A function. */
   CXCursor_FunctionDecl                  = 8,
   /** A variable. */
   CXCursor_VarDecl                       = 9,
   /** A function or method parameter. */
   CXCursor_ParmDecl                      = 10,
   /** An Objective-C \@interface. */
   CXCursor_ObjCInterfaceDecl             = 11,
   /** An Objective-C \@interface for a category. */
   CXCursor_ObjCCategoryDecl              = 12,
   /** An Objective-C \@protocol declaration. */
   CXCursor_ObjCProtocolDecl              = 13,
   /** An Objective-C \@property declaration. */
   CXCursor_ObjCPropertyDecl              = 14,
   /** An Objective-C instance variable. */
   CXCursor_ObjCIvarDecl                  = 15,
   /** An Objective-C instance method. */
   CXCursor_ObjCInstanceMethodDecl        = 16,
   /** An Objective-C class method. */
   CXCursor_ObjCClassMethodDecl           = 17,
   /** An Objective-C \@implementation. */
   CXCursor_ObjCImplementationDecl        = 18,
   /** An Objective-C \@implementation for a category. */
   CXCursor_ObjCCategoryImplDecl          = 19,
   /** A typedef. */
   CXCursor_TypedefDecl                   = 20,
   /** A C++ class method. */
   CXCursor_CXXMethod                     = 21,
   /** A C++ namespace. */
   CXCursor_Namespace                     = 22,
   /** A linkage specification, e.g. 'extern "C"'. */
   CXCursor_LinkageSpec                   = 23,
   /** A C++ constructor. */
   CXCursor_Constructor                   = 24,
   /** A C++ destructor. */
   CXCursor_Destructor                    = 25,
   /** A C++ conversion function. */
   CXCursor_ConversionFunction            = 26,
   /** A C++ template type parameter. */
   CXCursor_TemplateTypeParameter         = 27,
   /** A C++ non-type template parameter. */
   CXCursor_NonTypeTemplateParameter      = 28,
   /** A C++ template template parameter. */
   CXCursor_TemplateTemplateParameter     = 29,
   /** A C++ function template. */
   CXCursor_FunctionTemplate              = 30,
   /** A C++ class template. */
   CXCursor_ClassTemplate                 = 31,
   /** A C++ class template partial specialization. */
   CXCursor_ClassTemplatePartialSpecialization = 32,
   /** A C++ namespace alias declaration. */
   CXCursor_NamespaceAlias                = 33,
   /** A C++ using directive. */
   CXCursor_UsingDirective                = 34,
   /** A C++ using declaration. */
   CXCursor_UsingDeclaration              = 35,
   /** A C++ alias declaration */
   CXCursor_TypeAliasDecl                 = 36,
   /** An Objective-C \@synthesize definition. */
   CXCursor_ObjCSynthesizeDecl            = 37,
   /** An Objective-C \@dynamic definition. */
   CXCursor_ObjCDynamicDecl               = 38,
   /** An access specifier. */
   CXCursor_CXXAccessSpecifier            = 39,
 
   CXCursor_FirstDecl                     = CXCursor_UnexposedDecl,
   CXCursor_LastDecl                      = CXCursor_CXXAccessSpecifier,
 
   /* References */
   CXCursor_FirstRef                      = 40, /* Decl references */
   CXCursor_ObjCSuperClassRef             = 40,
   CXCursor_ObjCProtocolRef               = 41,
   CXCursor_ObjCClassRef                  = 42,
   /**
    * A reference to a type declaration.
    *
    * A type reference occurs anywhere where a type is named but not
    * declared. For example, given:
    *
    * \code
    * typedef unsigned size_type;
    * size_type size;
    * \endcode
    *
    * The typedef is a declaration of size_type (CXCursor_TypedefDecl),
    * while the type of the variable "size" is referenced. The cursor
    * referenced by the type of size is the typedef for size_type.
    */
   CXCursor_TypeRef                       = 43,
   CXCursor_CXXBaseSpecifier              = 44,
   /**
    * A reference to a class template, function template, template
    * template parameter, or class template partial specialization.
    */
   CXCursor_TemplateRef                   = 45,
   /**
    * A reference to a namespace or namespace alias.
    */
   CXCursor_NamespaceRef                  = 46,
   /**
    * A reference to a member of a struct, union, or class that occurs in
    * some non-expression context, e.g., a designated initializer.
    */
   CXCursor_MemberRef                     = 47,
   /**
    * A reference to a labeled statement.
    *
    * This cursor kind is used to describe the jump to "start_over" in the
    * goto statement in the following example:
    *
    * \code
    *   start_over:
    *     ++counter;
    *
    *     goto start_over;
    * \endcode
    *
    * A label reference cursor refers to a label statement.
    */
   CXCursor_LabelRef                      = 48,
 
   /**
    * A reference to a set of overloaded functions or function templates
    * that has not yet been resolved to a specific function or function template.
    *
    * An overloaded declaration reference cursor occurs in C++ templates where
    * a dependent name refers to a function. For example:
    *
enum CXCursorKind {
    * instantiation time, "swap" may also refer to other functions found via
    * argument-dependent lookup (e.g., the "swap" function at the end of the
    * example).
    *
    * The functions \c clang_getNumOverloadedDecls() and
    * \c clang_getOverloadedDecl() can be used to retrieve the definitions
    * referenced by this cursor.
    */
   CXCursor_OverloadedDeclRef             = 49,
 
   /**
    * A reference to a variable that occurs in some non-expression
    * context, e.g., a C++ lambda capture list.
    */
   CXCursor_VariableRef                   = 50,
 
   CXCursor_LastRef                       = CXCursor_VariableRef,
 
   /* Error conditions */
   CXCursor_FirstInvalid                  = 70,
   CXCursor_InvalidFile                   = 70,
   CXCursor_NoDeclFound                   = 71,
   CXCursor_NotImplemented                = 72,
   CXCursor_InvalidCode                   = 73,
   CXCursor_LastInvalid                   = CXCursor_InvalidCode,
 
   /* Expressions */
   CXCursor_FirstExpr                     = 100,
 
   /**
    * An expression whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed expressions have the same operations as any other kind
    * of expression; one can extract their location information,
    * spelling, children, etc. However, the specific kind of the
    * expression is not reported.
    */
   CXCursor_UnexposedExpr                 = 100,
 
   /**
    * An expression that refers to some value declaration, such
    * as a function, variable, or enumerator.
    */
   CXCursor_DeclRefExpr                   = 101,
 
   /**
    * An expression that refers to a member of a struct, union,
    * class, Objective-C class, etc.
    */
   CXCursor_MemberRefExpr                 = 102,
 
   /** An expression that calls a function. */
   CXCursor_CallExpr                      = 103,
 
   /** An expression that sends a message to an Objective-C
    object or class. */
   CXCursor_ObjCMessageExpr               = 104,
 
   /** An expression that represents a block literal. */
   CXCursor_BlockExpr                     = 105,
 
   /** An integer literal.
    */
   CXCursor_IntegerLiteral                = 106,
 
   /** A floating point number literal.
    */
   CXCursor_FloatingLiteral               = 107,
 
   /** An imaginary number literal.
    */
   CXCursor_ImaginaryLiteral              = 108,
 
   /** A string literal.
    */
   CXCursor_StringLiteral                 = 109,
 
   /** A character literal.
    */
   CXCursor_CharacterLiteral              = 110,
 
   /** A parenthesized expression, e.g. "(1)".
    *
    * This AST node is only formed if full location information is requested.
    */
   CXCursor_ParenExpr                     = 111,
 
   /** This represents the unary-expression's (except sizeof and
    * alignof).
    */
   CXCursor_UnaryOperator                 = 112,
 
   /** [C99 6.5.2.1] Array Subscripting.
    */
   CXCursor_ArraySubscriptExpr            = 113,
 
   /** A builtin binary operation expression such as "x + y" or
    * "x <= y".
    */
   CXCursor_BinaryOperator                = 114,
 
   /** Compound assignment such as "+=".
    */
   CXCursor_CompoundAssignOperator        = 115,
 
   /** The ?: ternary operator.
    */
   CXCursor_ConditionalOperator           = 116,
 
   /** An explicit cast in C (C99 6.5.4) or a C-style cast in C++
    * (C++ [expr.cast]), which uses the syntax (Type)expr.
    *
    * For example: (int)f.
    */
   CXCursor_CStyleCastExpr                = 117,
 
   /** [C99 6.5.2.5]
    */
   CXCursor_CompoundLiteralExpr           = 118,
 
   /** Describes an C or C++ initializer list.
    */
   CXCursor_InitListExpr                  = 119,
 
   /** The GNU address of label extension, representing &&label.
    */
   CXCursor_AddrLabelExpr                 = 120,
 
   /** This is the GNU Statement Expression extension: ({int X=4; X;})
    */
   CXCursor_StmtExpr                      = 121,
 
   /** Represents a C11 generic selection.
    */
   CXCursor_GenericSelectionExpr          = 122,
 
   /** Implements the GNU __null extension, which is a name for a null
    * pointer constant that has integral type (e.g., int or long) and is the same
    * size and alignment as a pointer.
    *
    * The __null extension is typically only used by system headers, which define
    * NULL as __null in C++ rather than using 0 (which is an integer that may not
    * match the size of a pointer).
    */
   CXCursor_GNUNullExpr                   = 123,
 
   /** C++'s static_cast<> expression.
    */
   CXCursor_CXXStaticCastExpr             = 124,
 
   /** C++'s dynamic_cast<> expression.
    */
   CXCursor_CXXDynamicCastExpr            = 125,
 
   /** C++'s reinterpret_cast<> expression.
    */
   CXCursor_CXXReinterpretCastExpr        = 126,
 
   /** C++'s const_cast<> expression.
    */
   CXCursor_CXXConstCastExpr              = 127,
 
   /** Represents an explicit C++ type conversion that uses "functional"
    * notion (C++ [expr.type.conv]).
    *
    * Example:
    * \code
    *   x = int(0.5);
    * \endcode
    */
   CXCursor_CXXFunctionalCastExpr         = 128,
 
   /** A C++ typeid expression (C++ [expr.typeid]).
    */
   CXCursor_CXXTypeidExpr                 = 129,
 
   /** [C++ 2.13.5] C++ Boolean Literal.
    */
   CXCursor_CXXBoolLiteralExpr            = 130,
 
   /** [C++0x 2.14.7] C++ Pointer Literal.
    */
   CXCursor_CXXNullPtrLiteralExpr         = 131,
 
   /** Represents the "this" expression in C++
    */
   CXCursor_CXXThisExpr                   = 132,
 
   /** [C++ 15] C++ Throw Expression.
    *
    * This handles 'throw' and 'throw' assignment-expression. When
    * assignment-expression isn't present, Op will be null.
    */
   CXCursor_CXXThrowExpr                  = 133,
 
   /** A new expression for memory allocation and constructor calls, e.g:
    * "new CXXNewExpr(foo)".
    */
   CXCursor_CXXNewExpr                    = 134,
 
   /** A delete expression for memory deallocation and destructor calls,
    * e.g. "delete[] pArray".
    */
   CXCursor_CXXDeleteExpr                 = 135,
 
   /** A unary expression. (noexcept, sizeof, or other traits)
    */
   CXCursor_UnaryExpr                     = 136,
 
   /** An Objective-C string literal i.e. @"foo".
    */
   CXCursor_ObjCStringLiteral             = 137,
 
   /** An Objective-C \@encode expression.
    */
   CXCursor_ObjCEncodeExpr                = 138,
 
   /** An Objective-C \@selector expression.
    */
   CXCursor_ObjCSelectorExpr              = 139,
 
   /** An Objective-C \@protocol expression.
    */
   CXCursor_ObjCProtocolExpr              = 140,
 
   /** An Objective-C "bridged" cast expression, which casts between
    * Objective-C pointers and C pointers, transferring ownership in the process.
    *
    * \code
    *   NSString *str = (__bridge_transfer NSString *)CFCreateString();
    * \endcode
    */
   CXCursor_ObjCBridgedCastExpr           = 141,
 
   /** Represents a C++0x pack expansion that produces a sequence of
    * expressions.
    *
    * A pack expansion expression contains a pattern (which itself is an
    * expression) followed by an ellipsis. For example:
    *
    * \code
    * template<typename F, typename ...Types>
    * void forward(F f, Types &&...args) {
    *  f(static_cast<Types&&>(args)...);
    * }
    * \endcode
    */
   CXCursor_PackExpansionExpr             = 142,
 
   /** Represents an expression that computes the length of a parameter
    * pack.
    *
    * \code
    * template<typename ...Types>
    * struct count {
    *   static const unsigned value = sizeof...(Types);
    * };
    * \endcode
    */
   CXCursor_SizeOfPackExpr                = 143,
 
   /* Represents a C++ lambda expression that produces a local function
    * object.
    *
    * \code
    * void abssort(float *x, unsigned N) {
    *   std::sort(x, x + N,
    *             [](float a, float b) {
    *               return std::abs(a) < std::abs(b);
    *             });
    * }
    * \endcode
    */
   CXCursor_LambdaExpr                    = 144,
 
   /** Objective-c Boolean Literal.
    */
   CXCursor_ObjCBoolLiteralExpr           = 145,
 
   /** Represents the "self" expression in an Objective-C method.
    */
   CXCursor_ObjCSelfExpr                  = 146,
 
   /** OpenMP 4.0 [2.4, Array Section].
    */
   CXCursor_OMPArraySectionExpr           = 147,
 
   /** Represents an @available(...) check.
    */
   CXCursor_ObjCAvailabilityCheckExpr     = 148,
 
   /**
    * Fixed point literal
    */
   CXCursor_FixedPointLiteral             = 149,
 
   CXCursor_LastExpr                      = CXCursor_FixedPointLiteral,
 
   /* Statements */
   CXCursor_FirstStmt                     = 200,
   /**
    * A statement whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed statements have the same operations as any other kind of
    * statement; one can extract their location information, spelling,
    * children, etc. However, the specific kind of the statement is not
    * reported.
    */
   CXCursor_UnexposedStmt                 = 200,
 
   /** A labelled statement in a function.
    *
    * This cursor kind is used to describe the "start_over:" label statement in
    * the following example:
    *
    * \code
    *   start_over:
    *     ++counter;
    * \endcode
    *
    */
   CXCursor_LabelStmt                     = 201,
 
   /** A group of statements like { stmt stmt }.
    *
    * This cursor kind is used to describe compound statements, e.g. function
    * bodies.
    */
   CXCursor_CompoundStmt                  = 202,
 
   /** A case statement.
    */
   CXCursor_CaseStmt                      = 203,
 
   /** A default statement.
    */
   CXCursor_DefaultStmt                   = 204,
 
   /** An if statement
    */
   CXCursor_IfStmt                        = 205,
 
   /** A switch statement.
    */
   CXCursor_SwitchStmt                    = 206,
 
   /** A while statement.
    */
   CXCursor_WhileStmt                     = 207,
 
   /** A do statement.
    */
   CXCursor_DoStmt                        = 208,
 
   /** A for statement.
    */
   CXCursor_ForStmt                       = 209,
 
   /** A goto statement.
    */
   CXCursor_GotoStmt                      = 210,
 
   /** An indirect goto statement.
    */
   CXCursor_IndirectGotoStmt              = 211,
 
   /** A continue statement.
    */
   CXCursor_ContinueStmt                  = 212,
 
   /** A break statement.
    */
   CXCursor_BreakStmt                     = 213,
 
   /** A return statement.
    */
   CXCursor_ReturnStmt                    = 214,
 
   /** A GCC inline assembly statement extension.
    */
   CXCursor_GCCAsmStmt                    = 215,
   CXCursor_AsmStmt                       = CXCursor_GCCAsmStmt,
 
   /** Objective-C's overall \@try-\@catch-\@finally statement.
    */
   CXCursor_ObjCAtTryStmt                 = 216,
 
   /** Objective-C's \@catch statement.
    */
   CXCursor_ObjCAtCatchStmt               = 217,
 
   /** Objective-C's \@finally statement.
    */
   CXCursor_ObjCAtFinallyStmt             = 218,
 
   /** Objective-C's \@throw statement.
    */
   CXCursor_ObjCAtThrowStmt               = 219,
 
   /** Objective-C's \@synchronized statement.
    */
   CXCursor_ObjCAtSynchronizedStmt        = 220,
 
   /** Objective-C's autorelease pool statement.
    */
   CXCursor_ObjCAutoreleasePoolStmt       = 221,
 
   /** Objective-C's collection statement.
    */
   CXCursor_ObjCForCollectionStmt         = 222,
 
   /** C++'s catch statement.
    */
   CXCursor_CXXCatchStmt                  = 223,
 
   /** C++'s try statement.
    */
   CXCursor_CXXTryStmt                    = 224,
 
   /** C++'s for (* : *) statement.
    */
   CXCursor_CXXForRangeStmt               = 225,
 
   /** Windows Structured Exception Handling's try statement.
    */
   CXCursor_SEHTryStmt                    = 226,
 
   /** Windows Structured Exception Handling's except statement.
    */
   CXCursor_SEHExceptStmt                 = 227,
 
   /** Windows Structured Exception Handling's finally statement.
    */
   CXCursor_SEHFinallyStmt                = 228,
 
   /** A MS inline assembly statement extension.
    */
   CXCursor_MSAsmStmt                     = 229,
 
   /** The null statement ";": C99 6.8.3p3.
    *
    * This cursor kind is used to describe the null statement.
    */
   CXCursor_NullStmt                      = 230,
 
   /** Adaptor class for mixing declarations with statements and
    * expressions.
    */
   CXCursor_DeclStmt                      = 231,
 
   /** OpenMP parallel directive.
    */
   CXCursor_OMPParallelDirective          = 232,
 
   /** OpenMP SIMD directive.
    */
   CXCursor_OMPSimdDirective              = 233,
 
   /** OpenMP for directive.
    */
   CXCursor_OMPForDirective               = 234,
 
   /** OpenMP sections directive.
    */
   CXCursor_OMPSectionsDirective          = 235,
 
   /** OpenMP section directive.
    */
   CXCursor_OMPSectionDirective           = 236,
 
   /** OpenMP single directive.
    */
   CXCursor_OMPSingleDirective            = 237,
 
   /** OpenMP parallel for directive.
    */
   CXCursor_OMPParallelForDirective       = 238,
 
   /** OpenMP parallel sections directive.
    */
   CXCursor_OMPParallelSectionsDirective  = 239,
 
   /** OpenMP task directive.
    */
   CXCursor_OMPTaskDirective              = 240,
 
   /** OpenMP master directive.
    */
   CXCursor_OMPMasterDirective            = 241,
 
   /** OpenMP critical directive.
    */
   CXCursor_OMPCriticalDirective          = 242,
 
   /** OpenMP taskyield directive.
    */
   CXCursor_OMPTaskyieldDirective         = 243,
 
   /** OpenMP barrier directive.
    */
   CXCursor_OMPBarrierDirective           = 244,
 
   /** OpenMP taskwait directive.
    */
   CXCursor_OMPTaskwaitDirective          = 245,
 
   /** OpenMP flush directive.
    */
   CXCursor_OMPFlushDirective             = 246,
 
   /** Windows Structured Exception Handling's leave statement.
    */
   CXCursor_SEHLeaveStmt                  = 247,
 
   /** OpenMP ordered directive.
    */
   CXCursor_OMPOrderedDirective           = 248,
 
   /** OpenMP atomic directive.
    */
   CXCursor_OMPAtomicDirective            = 249,
 
   /** OpenMP for SIMD directive.
    */
   CXCursor_OMPForSimdDirective           = 250,
 
   /** OpenMP parallel for SIMD directive.
    */
   CXCursor_OMPParallelForSimdDirective   = 251,
 
   /** OpenMP target directive.
    */
   CXCursor_OMPTargetDirective            = 252,
 
   /** OpenMP teams directive.
    */
   CXCursor_OMPTeamsDirective             = 253,
 
   /** OpenMP taskgroup directive.
    */
   CXCursor_OMPTaskgroupDirective         = 254,
 
   /** OpenMP cancellation point directive.
    */
   CXCursor_OMPCancellationPointDirective = 255,
 
   /** OpenMP cancel directive.
    */
   CXCursor_OMPCancelDirective            = 256,
 
   /** OpenMP target data directive.
    */
   CXCursor_OMPTargetDataDirective        = 257,
 
   /** OpenMP taskloop directive.
    */
   CXCursor_OMPTaskLoopDirective          = 258,
 
   /** OpenMP taskloop simd directive.
    */
   CXCursor_OMPTaskLoopSimdDirective      = 259,
 
   /** OpenMP distribute directive.
    */
   CXCursor_OMPDistributeDirective        = 260,
 
   /** OpenMP target enter data directive.
    */
   CXCursor_OMPTargetEnterDataDirective   = 261,
 
   /** OpenMP target exit data directive.
    */
   CXCursor_OMPTargetExitDataDirective    = 262,
 
   /** OpenMP target parallel directive.
    */
   CXCursor_OMPTargetParallelDirective    = 263,
 
   /** OpenMP target parallel for directive.
    */
   CXCursor_OMPTargetParallelForDirective = 264,
 
   /** OpenMP target update directive.
    */
   CXCursor_OMPTargetUpdateDirective      = 265,
 
   /** OpenMP distribute parallel for directive.
    */
   CXCursor_OMPDistributeParallelForDirective = 266,
 
   /** OpenMP distribute parallel for simd directive.
    */
   CXCursor_OMPDistributeParallelForSimdDirective = 267,
enum CXCursorKind {
   CXCursor_OMPMasterTaskLoopDirective = 281,
 
   /** OpenMP parallel master taskloop directive.
    */
   CXCursor_OMPParallelMasterTaskLoopDirective = 282,
 
   /** OpenMP master taskloop simd directive.
    */
   CXCursor_OMPMasterTaskLoopSimdDirective      = 283,
 
   /** OpenMP parallel master taskloop simd directive.
    */
   CXCursor_OMPParallelMasterTaskLoopSimdDirective      = 284,
 
   /** OpenMP parallel master directive.
    */
   CXCursor_OMPParallelMasterDirective      = 285,
 
   /** OpenMP depobj directive.
    */
   CXCursor_OMPDepobjDirective             = 286,
 
   /** OpenMP scan directive.
    */
   CXCursor_OMPScanDirective               = 287,
 
-  CXCursor_LastStmt = CXCursor_OMPScanDirective,
+  /** Pragma changing floating point options.
+   */
+  CXcursor_FloatingPragmaStmt             = 288,
+
+  CXCursor_LastStmt = CXcursor_FloatingPragmaStmt,
 
   /**
    * Cursor that represents the translation unit itself.
    *
    * The translation unit cursor exists primarily to act as the root
    * cursor for traversing the contents of a translation unit.
    */
   CXCursor_TranslationUnit               = 300,
 
   /* Attributes */
   CXCursor_FirstAttr                     = 400,
   /**
    * An attribute whose specific kind is not exposed via this
    * interface.
    */
   CXCursor_UnexposedAttr                 = 400,
 
   CXCursor_IBActionAttr                  = 401,
   CXCursor_IBOutletAttr                  = 402,
   CXCursor_IBOutletCollectionAttr        = 403,
   CXCursor_CXXFinalAttr                  = 404,
   CXCursor_CXXOverrideAttr               = 405,
   CXCursor_AnnotateAttr                  = 406,
   CXCursor_AsmLabelAttr                  = 407,
enum CXCursorKind {
   CXCursor_FlagEnum                      = 437,
   CXCursor_ConvergentAttr                = 438,
   CXCursor_WarnUnusedAttr                = 439,
   CXCursor_WarnUnusedResultAttr          = 440,
   CXCursor_AlignedAttr                   = 441,
   CXCursor_LastAttr                      = CXCursor_AlignedAttr,
 
   /* Preprocessing */
   CXCursor_PreprocessingDirective        = 500,
   CXCursor_MacroDefinition               = 501,
   CXCursor_MacroExpansion                = 502,
   CXCursor_MacroInstantiation            = CXCursor_MacroExpansion,
   CXCursor_InclusionDirective            = 503,
   CXCursor_FirstPreprocessing            = CXCursor_PreprocessingDirective,
   CXCursor_LastPreprocessing             = CXCursor_InclusionDirective,
 
   /* Extra Declarations */
   /**
    * A module import declaration.
    */
   CXCursor_ModuleImportDecl              = 600,
   CXCursor_TypeAliasTemplateDecl         = 601,
   /**
    * A static_assert or _Static_assert node
    */
   CXCursor_StaticAssert                  = 602,
   /**
    * a friend declaration.
    */
   CXCursor_FriendDecl                    = 603,
   CXCursor_FirstExtraDecl                = CXCursor_ModuleImportDecl,
   CXCursor_LastExtraDecl                 = CXCursor_FriendDecl,
 
   /**
    * A code completion overload candidate.
    */
   CXCursor_OverloadCandidate             = 700
 };
 
 /**
  * A cursor representing some element in the abstract syntax tree for
  * a translation unit.
  *
  * The cursor abstraction unifies the different kinds of entities in a
  * program--declaration, statements, expressions, references to declarations,

clang/include/clang/AST/Expr.h

public:
   void setFPFeatures(FPOptions F) {
     BinaryOperatorBits.FPFeatures = F.getInt();
   }
 
   FPOptions getFPFeatures() const {
     return FPOptions(BinaryOperatorBits.FPFeatures);
   }
 
-  // Get the FP contractability status of this operator. Only meaningful for
-  // operations on floating point types.
-  bool isFPContractableWithinStatement() const {
-    return getFPFeatures().allowFPContractWithinStatement();
-  }
-
   // Get the FENV_ACCESS status of this operator. Only meaningful for
   // operations on floating point types.
   bool isFEnvAccessOn() const { return getFPFeatures().allowFEnvAccess(); }
 
 protected:
   BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
                  ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc,
                  FPOptions FPFeatures, bool dead2)

clang/include/clang/AST/ExprCXX.h

public:
   // Set the FP contractability status of this operator. Only meaningful for
   // operations on floating point types.
   void setFPFeatures(FPOptions F) {
     CXXOperatorCallExprBits.FPFeatures = F.getInt();
   }
   FPOptions getFPFeatures() const {
     return FPOptions(CXXOperatorCallExprBits.FPFeatures);
   }
-
-  // Get the FP contractability status of this operator. Only meaningful for
-  // operations on floating point types.
-  bool isFPContractableWithinStatement() const {
-    return getFPFeatures().allowFPContractWithinStatement();
-  }
 };
 
 /// Represents a call to a member function that
 /// may be written either with member call syntax (e.g., "obj.func()"
 /// or "objptr->func()") or with normal function-call syntax
 /// ("func()") within a member function that ends up calling a member
 /// function. The callee in either case is a MemberExpr that contains
 /// both the object argument and the member function, while the

clang/include/clang/AST/RecursiveASTVisitor.h

DEF_TRAVERSE_STMT(UnresolvedMemberExpr, {
   }
 })
 
 DEF_TRAVERSE_STMT(SEHTryStmt, {})
 DEF_TRAVERSE_STMT(SEHExceptStmt, {})
 DEF_TRAVERSE_STMT(SEHFinallyStmt, {})
 DEF_TRAVERSE_STMT(SEHLeaveStmt, {})
 DEF_TRAVERSE_STMT(CapturedStmt, { TRY_TO(TraverseDecl(S->getCapturedDecl())); })
+DEF_TRAVERSE_STMT(FloatingPragmaStmt, {})
 
 DEF_TRAVERSE_STMT(CXXOperatorCallExpr, {})
 DEF_TRAVERSE_STMT(CXXRewrittenBinaryOperator, {
   if (!getDerived().shouldVisitImplicitCode()) {
     CXXRewrittenBinaryOperator::DecomposedForm Decomposed =
         S->getDecomposedForm();
     TRY_TO(TraverseStmt(const_cast<Expr*>(Decomposed.LHS)));
     TRY_TO(TraverseStmt(const_cast<Expr*>(Decomposed.RHS)));

clang/include/clang/AST/Stmt.h

 #ifndef LLVM_CLANG_AST_STMT_H
 #define LLVM_CLANG_AST_STMT_H
 
 #include "clang/AST/DeclGroup.h"
 #include "clang/AST/DependenceFlags.h"
 #include "clang/AST/StmtIterator.h"
 #include "clang/Basic/CapturedStmt.h"
 #include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/LangOptions.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
static bool classof(const Stmt *T) {
     return T->getStmtClass() == CapturedStmtClass;
   }
 
   child_range children();
 
   const_child_range children() const;
 };
 
+/// This represents a pragma that affects interpretations of the subsequent AST
+/// nodes that specify floating point operations.
+///
+/// An example of such pragma is 'pragma STDC FE_CONTRACT', which specifies
+/// whether operations may be contracted. It results in different code generated
+/// for some floating point operations. This and similar pragmas affect the AST
+/// nodes contained in the same compound statement where the pragma occurs.
+///
+/// Object of this class keeps the state of all properties, that can be modified
+/// using pragmas. If more than one of such pragma act in the same compound
+/// statement, each subsequent pragma keep options set by this and all preceding
+/// pragmas. If a pragma is specified at file level, each affected function will
+/// have synthesized pragma statement in its body. Similarly, if FP options
+/// differ from defaults because of compilation options, each function body
+/// receives such synthesized pragma statement.
+///
+class FloatingPragmaStmt : public Stmt {
+  friend class ASTReader;
+  friend class ASTStmtReader;
+
+public:
+
+  /// Enumerates possible pragma representations in source code.
+  enum PragmaKind {
+    /// This statement do not correspond to any pragma inside function
+    /// definition, it represents either pragmas at global level, or changes to
+    /// floating point environment made by compilation options.
+    Synthesized,
+    /// #pragma clang fp
+    PragmaClangFP,
+    /// #pragma STDC FP_CONTRACT
+    PragmaFPContract
+  };
+
+private:
+
+  PragmaKind Kind;
+  SourceLocation PragmaLoc;
+  FPOptions FPFeatures;
+
+public:
+
+  FloatingPragmaStmt(PragmaKind K, SourceLocation Loc, const FPOptions &FPO)
+      : Stmt(FloatingPragmaStmtClass), Kind(K), PragmaLoc(Loc), FPFeatures(FPO) {}
+
+  explicit FloatingPragmaStmt(EmptyShell E) : Stmt(FloatingPragmaStmtClass, E) {}
+
+  PragmaKind getKind() const { return Kind; }
+  void setKind(PragmaKind K) { Kind = K; }
+
+  SourceLocation getPragmaLoc() const { return PragmaLoc; }
+  void setPragmaLoc(SourceLocation L) { PragmaLoc = L; }
+
+  const FPOptions &getFPOptions() const { return FPFeatures; }
+  FPOptions &getFPOptions() { return FPFeatures; }
+
+  LangOptions::FPContractModeKind getContract() const {
+    return FPFeatures.getContract();
+  }
+  void setContract(LangOptions::FPContractModeKind X) {
+    FPFeatures.setContract(X);
+  }
+
+  SourceLocation getBeginLoc() const LLVM_READONLY { return PragmaLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY { return PragmaLoc; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == FloatingPragmaStmtClass;
+  }
+
+  static bool classof(FloatingPragmaStmt *) { return true; }
+
+  // Iterators
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+};
+
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_STMT_H

clang/include/clang/AST/TextNodeDumper.h

#include "clang/AST/AttrTextNodeDump.inc"
   void VisitPackTemplateArgument(const TemplateArgument &TA);
 
   void VisitIfStmt(const IfStmt *Node);
   void VisitSwitchStmt(const SwitchStmt *Node);
   void VisitWhileStmt(const WhileStmt *Node);
   void VisitLabelStmt(const LabelStmt *Node);
   void VisitGotoStmt(const GotoStmt *Node);
   void VisitCaseStmt(const CaseStmt *Node);
+  void VisitFloatingPragmaStmt(const FloatingPragmaStmt *Node);
   void VisitConstantExpr(const ConstantExpr *Node);
   void VisitCallExpr(const CallExpr *Node);
   void VisitCastExpr(const CastExpr *Node);
   void VisitImplicitCastExpr(const ImplicitCastExpr *Node);
   void VisitDeclRefExpr(const DeclRefExpr *Node);
   void VisitPredefinedExpr(const PredefinedExpr *Node);
   void VisitCharacterLiteral(const CharacterLiteral *Node);
   void VisitIntegerLiteral(const IntegerLiteral *Node);

clang/include/clang/Basic/LangOptions.h

#include "clang/Basic/LangOptions.def"
   bool assumeFunctionsAreConvergent() const {
     return ConvergentFunctions;
   }
 
   /// Return the OpenCL C or C++ version as a VersionTuple.
   VersionTuple getOpenCLVersionTuple() const;
 };
 
+/// 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 ContinueStmt : StmtNode<Stmt>;
 def BreakStmt : StmtNode<Stmt>;
 def ReturnStmt : StmtNode<Stmt>;
 def DeclStmt  : StmtNode<Stmt>;
 def SwitchCase : StmtNode<Stmt, 1>;
 def CaseStmt : StmtNode<SwitchCase>;
 def DefaultStmt : StmtNode<SwitchCase>;
 def CapturedStmt : StmtNode<Stmt>;
+def FloatingPragmaStmt : StmtNode<Stmt>;
 
 // Statements that might produce a value (for example, as the last non-null
 // statement in a GNU statement-expression).
 def ValueStmt : StmtNode<Stmt, 1>;
 def LabelStmt : StmtNode<ValueStmt>;
 def AttributedStmt : StmtNode<ValueStmt>;
 
 // Asm statements

clang/include/clang/Sema/Sema.h

StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
                             ArrayRef<StringRef> Constraints,
                             ArrayRef<StringRef> Clobbers,
                             ArrayRef<Expr*> Exprs,
                             SourceLocation EndLoc);
   LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
                                    SourceLocation Location,
                                    bool AlwaysCreate);
 
+  /// Statements created by floating point pragmas inside the current function.
+  /// The first element may be synthesized to represent file scope pragmas or
+  /// compilation options. The last element must be in sync with FPFeatures.
+  SmallVector<FloatingPragmaStmt *, 2> PragmaStatements;
+
+  void insertPragmaStatements(SmallVectorImpl<Stmt *> &Stmts);
+
+  StmtResult ActOnFloatingPragmaStmt(SourceLocation PragmaLoc,
+                                     FloatingPragmaStmt::PragmaKind K);
+  void ActOnFPContract(StmtResult S, LangOptions::FPContractModeKind X);
+
   VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,
                                   SourceLocation StartLoc,
                                   SourceLocation IdLoc, IdentifierInfo *Id,
                                   bool Invalid = false);
 
   Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D);
 
   StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen,

clang/include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
       STMT_CAPTURED,
 
       /// A GCC-style AsmStmt record.
       STMT_GCCASM,
 
       /// A MS-style AsmStmt record.
       STMT_MSASM,
 
+      /// A floating point option pragma.
+      STMT_FLOATING_PRAGMA,
+
       /// A constant expression context.
       EXPR_CONSTANT,
 
       /// A PredefinedExpr record.
       EXPR_PREDEFINED,
 
       /// A DeclRefExpr record.
       EXPR_DECL_REF,
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_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE,
       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,
 
       // 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/ExprConstant.cpp

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)
if (RetExpr &&
               ? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr)
               : Evaluate(Result.Value, Info, RetExpr)))
       return ESR_Failed;
     return Scope.destroy() ? ESR_Returned : ESR_Failed;
   }
 
   case Stmt::CompoundStmtClass: {
     BlockScopeRAII Scope(Info);
+    FPOptionsStateRAII SavedFPFeatures(Info);
 
     const CompoundStmt *CS = cast<CompoundStmt>(S);
     for (const auto *BI : CS->body()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, BI, Case);
       if (ESR == ESR_Succeeded)
         Case = nullptr;
       else if (ESR != ESR_CaseNotFound) {
         if (ESR != ESR_Failed && !Scope.destroy())
return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(),
                         Case);
 
   case Stmt::CaseStmtClass:
   case Stmt::DefaultStmtClass:
     return EvaluateStmt(Result, Info, cast<SwitchCase>(S)->getSubStmt(), Case);
   case Stmt::CXXTryStmtClass:
     // Evaluate try blocks by evaluating all sub statements.
     return EvaluateStmt(Result, Info, cast<CXXTryStmt>(S)->getTryBlock(), Case);
+
+  case Stmt::FloatingPragmaStmtClass:
+    Info.FPFeatures = cast<FloatingPragmaStmt>(S)->getFPOptions();
+    return ESR_Succeeded;
   }
 }
 
 /// CheckTrivialDefaultConstructor - Check whether a constructor is a trivial
 /// default constructor. If so, we'll fold it whether or not it's marked as
 /// constexpr. If it is marked as constexpr, we will never implicitly define it,
 /// so we need special handling.
 static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc,

clang/lib/AST/StmtPrinter.cpp

 
 void StmtPrinter::VisitOMPTargetTeamsDistributeSimdDirective(
     OMPTargetTeamsDistributeSimdDirective *Node) {
   Indent() << "#pragma omp target teams distribute simd";
   PrintOMPExecutableDirective(Node);
 }
 
 //===----------------------------------------------------------------------===//
+//  Miscellaneous directives printing methods
+//===----------------------------------------------------------------------===//
+
+void StmtPrinter::VisitFloatingPragmaStmt(FloatingPragmaStmt *Node) {
+  switch (Node->getKind()) {
+  case FloatingPragmaStmt::PragmaClangFP:
+  case FloatingPragmaStmt::Synthesized:
+    Indent() << "#pragma clang fp "
+             << spell(Node->getFPOptions().getContract(), false);
+    break;
+  case FloatingPragmaStmt::PragmaFPContract:
+    Indent() << "#pragma STDC FP_CONTRACT "
+             << spell(Node->getFPOptions().getContract(), true);
+    break;
+  default:
+    llvm_unreachable("Unexpected pragma kind");
+  }
+  if (Policy.IncludeNewlines)
+    OS << NL;
+}
+
+//===----------------------------------------------------------------------===//
 //  Expr printing methods.
 //===----------------------------------------------------------------------===//
 
 void StmtPrinter::VisitSourceLocExpr(SourceLocExpr *Node) {
   OS << Node->getBuiltinStr() << "()";
 }
 
 void StmtPrinter::VisitConstantExpr(ConstantExpr *Node) {

clang/lib/AST/StmtProfile.cpp

void StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) {
   VisitStmt(S);
 }
 
 void
 StmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) {
   VisitStmt(S);
 }
 
+void StmtProfiler::VisitFloatingPragmaStmt(const FloatingPragmaStmt *S) {
+  VisitStmt(S);
+}
+
 namespace {
 class OMPClauseProfiler : public ConstOMPClauseVisitor<OMPClauseProfiler> {
   StmtProfiler *Profiler;
   /// Process clauses with list of variables.
   template <typename T>
   void VisitOMPClauseList(T *Node);
 
 public:

clang/lib/AST/TextNodeDumper.cpp

void TextNodeDumper::VisitGotoStmt(const GotoStmt *Node) {
   dumpPointer(Node->getLabel());
 }
 
 void TextNodeDumper::VisitCaseStmt(const CaseStmt *Node) {
   if (Node->caseStmtIsGNURange())
     OS << " gnu_range";
 }
 
+void TextNodeDumper::VisitFloatingPragmaStmt(const FloatingPragmaStmt *Node) {
+  switch (Node->getKind()) {
+  case FloatingPragmaStmt::Synthesized:
+  case FloatingPragmaStmt::PragmaClangFP:
+    OS << " pragma clang fp "
+       << spell(Node->getFPOptions().getContract(), false);
+    break;
+  case FloatingPragmaStmt::PragmaFPContract:
+    OS << " pragma fp_contract "
+       << spell(Node->getFPOptions().getContract(), true);
+    break;
+  default:
+    break;
+  }
+}
+
 void TextNodeDumper::VisitConstantExpr(const ConstantExpr *Node) {
   if (Node->getResultAPValueKind() != APValue::None) {
     ColorScope Color(OS, ShowColors, ValueColor);
     OS << " ";
     Node->getAPValueResult().dump(OS);
   }
 }
 

clang/lib/Basic/LangOptions.cpp

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/CGExprScalar.cpp

static bool CanElideOverflowCheck(const ASTContext &Ctx, const BinOpInfo &Op) {
 
   // For unsigned multiplication the overflow check can be elided if either one
   // of the unpromoted types are less than half the size of the promoted type.
   unsigned PromotedSize = Ctx.getTypeSize(Op.E->getType());
   return (2 * Ctx.getTypeSize(LHSTy)) < PromotedSize ||
          (2 * Ctx.getTypeSize(RHSTy)) < PromotedSize;
 }
 
-/// Update the FastMathFlags of LLVM IR from the FPOptions in LangOptions.
-static void updateFastMathFlags(llvm::FastMathFlags &FMF,
-                                FPOptions FPFeatures) {
-  FMF.setAllowContract(FPFeatures.allowFPContractAcrossStatement());
-}
-
-/// Propagate fast-math flags from \p Op to the instruction in \p V.
-static Value *propagateFMFlags(Value *V, const BinOpInfo &Op) {
+/// Propagate fast-math flags from the current FPOtions to the instruction
+/// in \p V.
+static Value *propagateFMFlags(Value *V, CodeGenFunction &CGF) {
   if (auto *I = dyn_cast<llvm::Instruction>(V)) {
     llvm::FastMathFlags FMF = I->getFastMathFlags();
-    updateFastMathFlags(FMF, Op.FPFeatures);
+    FMF.setAllowContract(CGF.FPFeatures.allowFPContractAcrossStatement());
     I->setFastMathFlags(FMF);
   }
   return V;
 }
 
 class ScalarExprEmitter
   : public StmtVisitor<ScalarExprEmitter, Value*> {
   CodeGenFunction &CGF;
Value *EmitMul(const BinOpInfo &Ops) {
 
     if (Ops.Ty->isUnsignedIntegerType() &&
         CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
         !CanElideOverflowCheck(CGF.getContext(), Ops))
       return EmitOverflowCheckedBinOp(Ops);
 
     if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
       Value *V = Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
-      return propagateFMFlags(V, Ops);
+      return propagateFMFlags(V, CGF);
     }
     return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
   }
   /// Create a binary op that checks for overflow.
   /// Currently only supports +, - and *.
   Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops);
 
   // Check for undefined division and modulus behaviors.
static Value* tryEmitFMulAdd(const BinOpInfo &op,
                          const CodeGenFunction &CGF, CGBuilderTy &Builder,
                          bool isSub=false) {
 
   assert((op.Opcode == BO_Add || op.Opcode == BO_AddAssign ||
           op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) &&
          "Only fadd/fsub can be the root of an fmuladd.");
 
   // Check whether this op is marked as fusable.
-  if (!op.FPFeatures.allowFPContractWithinStatement())
+  if (!CGF.FPFeatures.allowFPContractWithinStatement())
     return nullptr;
 
   // We have a potentially fusable op. Look for a mul on one of the operands.
   // Also, make sure that the mul result isn't used directly. In that case,
   // there's no point creating a muladd operation.
   if (auto *LHSBinOp = dyn_cast<llvm::BinaryOperator>(op.LHS)) {
     if (LHSBinOp->getOpcode() == llvm::Instruction::FMul &&
         LHSBinOp->use_empty())
if (op.Ty->isUnsignedIntegerType() &&
     return EmitOverflowCheckedBinOp(op);
 
   if (op.LHS->getType()->isFPOrFPVectorTy()) {
     // Try to form an fmuladd.
     if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder))
       return FMulAdd;
 
     Value *V = Builder.CreateFAdd(op.LHS, op.RHS, "add");
-    return propagateFMFlags(V, op);
+    return propagateFMFlags(V, CGF);
   }
 
   if (op.isFixedPointBinOp())
     return EmitFixedPointBinOp(op);
 
   return Builder.CreateAdd(op.LHS, op.RHS, "add");
 }
 
if (op.Ty->isUnsignedIntegerType() &&
         !CanElideOverflowCheck(CGF.getContext(), op))
       return EmitOverflowCheckedBinOp(op);
 
     if (op.LHS->getType()->isFPOrFPVectorTy()) {
       // Try to form an fmuladd.
       if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder, true))
         return FMulAdd;
       Value *V = Builder.CreateFSub(op.LHS, op.RHS, "sub");
-      return propagateFMFlags(V, op);
+      return propagateFMFlags(V, CGF);
     }
 
     if (op.isFixedPointBinOp())
       return EmitFixedPointBinOp(op);
 
     return Builder.CreateSub(op.LHS, op.RHS, "sub");
   }
 

clang/lib/CodeGen/CGStmt.cpp

#include "clang/AST/StmtNodes.inc"
   case Stmt::CoreturnStmtClass:
     EmitCoreturnStmt(cast<CoreturnStmt>(*S));
     break;
   case Stmt::CapturedStmtClass: {
     const CapturedStmt *CS = cast<CapturedStmt>(S);
     EmitCapturedStmt(*CS, CS->getCapturedRegionKind());
     }
     break;
+  case Stmt::FloatingPragmaStmtClass:
+    EmitFloatingPragmaStmt(cast<FloatingPragmaStmt>(*S));
+    break;
   case Stmt::ObjCAtTryStmtClass:
     EmitObjCAtTryStmt(cast<ObjCAtTryStmt>(*S));
     break;
   case Stmt::ObjCAtCatchStmtClass:
     llvm_unreachable(
                     "@catch statements should be handled by EmitObjCAtTryStmt");
   case Stmt::ObjCAtFinallyStmtClass:
     llvm_unreachable(
                   "@finally statements should be handled by EmitObjCAtTryStmt");
   case Stmt::ObjCAtThrowStmtClass:
     EmitObjCAtThrowStmt(cast<ObjCAtThrowStmt>(*S));
     break;
   case Stmt::ObjCAtSynchronizedStmtClass:
     EmitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(*S));
     break;
   case Stmt::ObjCForCollectionStmtClass:
     EmitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(*S));
     break;
   case Stmt::ObjCAutoreleasePoolStmtClass:
     EmitObjCAutoreleasePoolStmt(cast<ObjCAutoreleasePoolStmt>(*S));
     break;
 
   case Stmt::CXXTryStmtClass:
     EmitCXXTryStmt(cast<CXXTryStmt>(*S));
     break;
   case Stmt::CXXForRangeStmtClass:
     EmitCXXForRangeStmt(cast<CXXForRangeStmt>(*S), Attrs);
     break;
   case Stmt::SEHTryStmtClass:
     EmitSEHTryStmt(cast<SEHTryStmt>(*S));
     break;

 CodeGenFunction::EmitCompoundStmtWithoutScope(const CompoundStmt &S,
                                               bool GetLast,
                                               AggValueSlot AggSlot) {
 
   const Stmt *ExprResult = S.getStmtExprResult();
   assert((!GetLast || (GetLast && ExprResult)) &&
          "If GetLast is true then the CompoundStmt must have a StmtExprResult");
 
+  FPOptions SaveFPFeatures = FPFeatures;
   Address RetAlloca = Address::invalid();
 
   for (auto *CurStmt : S.body()) {
     if (GetLast && ExprResult == CurStmt) {
       // We have to special case labels here.  They are statements, but when put
       // at the end of a statement expression, they yield the value of their
       // subexpression.  Handle this by walking through all labels we encounter,
       // emitting them before we evaluate the subexpr.
if (GetLast && ExprResult == CurStmt) {
         RetAlloca = CreateMemTemp(ExprTy);
         EmitAnyExprToMem(E, RetAlloca, Qualifiers(),
                          /*IsInit*/ false);
       }
     } else {
       EmitStmt(CurStmt);
     }
   }
+  FPFeatures = SaveFPFeatures;
 
   return RetAlloca;
 }
 
 void CodeGenFunction::SimplifyForwardingBlocks(llvm::BasicBlock *BB) {
   llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
 
   // If there is a cleanup stack, then we it isn't worth trying to
if ((i < ResultTypeRequiresCast.size()) && ResultTypeRequiresCast[i]) {
         return;
       }
       Dest = MakeAddrLValue(A, Ty);
     }
     EmitStoreThroughLValue(RValue::get(Tmp), Dest);
   }
 }
 
+void CodeGenFunction::EmitFloatingPragmaStmt(const FloatingPragmaStmt& S) {
+  FPFeatures = S.getFPOptions();
+}
+
 LValue CodeGenFunction::InitCapturedStruct(const CapturedStmt &S) {
   const RecordDecl *RD = S.getCapturedRecordDecl();
   QualType RecordTy = getContext().getRecordType(RD);
 
   // Initialize the captured struct.
   LValue SlotLV =
     MakeAddrLValue(CreateMemTemp(RecordTy, "agg.captured"), RecordTy);
 

clang/lib/CodeGen/CodeGenFunction.h

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;

   void EmitDeclStmt(const DeclStmt &S);
   void EmitBreakStmt(const BreakStmt &S);
   void EmitContinueStmt(const ContinueStmt &S);
   void EmitSwitchStmt(const SwitchStmt &S);
   void EmitDefaultStmt(const DefaultStmt &S);
   void EmitCaseStmt(const CaseStmt &S);
   void EmitCaseStmtRange(const CaseStmt &S);
   void EmitAsmStmt(const AsmStmt &S);
+  void EmitFloatingPragmaStmt(const FloatingPragmaStmt &S);
 
   void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S);
   void EmitObjCAtTryStmt(const ObjCAtTryStmt &S);
   void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S);
   void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S);
   void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S);
 
   void EmitCoroutineBody(const CoroutineBodyStmt &S);

clang/lib/Parse/ParsePragma.cpp

void Parser::HandlePragmaFPContract() {
   case tok::OOS_OFF:
     FPC = LangOptions::FPC_Off;
     break;
   case tok::OOS_DEFAULT:
     FPC = getLangOpts().getDefaultFPContractMode();
     break;
   }
 
-  Actions.ActOnPragmaFPContract(FPC);
+  StmtResult S = Actions.ActOnFloatingPragmaStmt(
+      Tok.getLocation(), FloatingPragmaStmt::PragmaFPContract);
+  Actions.ActOnFPContract(S, FPC);
+
   ConsumeAnnotationToken();
 }
 
 void Parser::HandlePragmaFEnvAccess() {
   assert(Tok.is(tok::annot_pragma_fenv_access));
   tok::OnOffSwitch OOS =
     static_cast<tok::OnOffSwitch>(
     reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
void Parser::HandlePragmaFP() {
   case TokFPAnnotValue::Fast:
     FPC = LangOptions::FPC_Fast;
     break;
   case TokFPAnnotValue::Off:
     FPC = LangOptions::FPC_Off;
     break;
   }
 
-  Actions.ActOnPragmaFPContract(FPC);
+  StmtResult S = Actions.ActOnFloatingPragmaStmt(
+      Tok.getLocation(), FloatingPragmaStmt::PragmaClangFP);
+  Actions.ActOnFPContract(S, FPC);
   ConsumeAnnotationToken();
 }
 
 /// Parses loop or unroll pragma hint value and fills in Info.
 static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName,
                                Token Option, bool ValueInParens,
                                PragmaLoopHintInfo &Info) {
   SmallVector<Token, 1> ValueList;

clang/lib/Parse/ParseStmt.cpp

StmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr) {
 
   Sema::CompoundScopeRAII CompoundScope(Actions, isStmtExpr);
 
   // Parse any pragmas at the beginning of the compound statement.
   ParseCompoundStatementLeadingPragmas();
 
   StmtVector Stmts;
 
+  // If parsing leading pragmas created statements, put them into the body.
+  Actions.insertPragmaStatements(Stmts);
+
   // "__label__ X, Y, Z;" is the GNU "Local Label" extension.  These are
   // only allowed at the start of a compound stmt regardless of the language.
   while (Tok.is(tok::kw___label__)) {
     SourceLocation LabelLoc = ConsumeToken();
 
     SmallVector<Decl *, 8> DeclsInGroup;
     while (1) {
       if (Tok.isNot(tok::identifier)) {

clang/lib/Sema/SemaDecl.cpp

if (C.capturesVariable()) {
                              I->getType());
     }
     ++I;
   }
 }
 
 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D,
                                     SkipBodyInfo *SkipBody) {
+  PragmaStatements.clear();
+
   if (!D) {
     // Parsing the function declaration failed in some way. Push on a fake scope
     // anyway so we can try to parse the function body.
     PushFunctionScope();
     PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
     return D;
   }
 
Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D,
   // We want to attach documentation to original Decl (which might be
   // a function template).
   ActOnDocumentableDecl(D);
   if (getCurLexicalContext()->isObjCContainer() &&
       getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
       getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation)
     Diag(FD->getLocation(), diag::warn_function_def_in_objc_container);
 
+  // If compilation options or file scope pragmas modified floating point state,
+  // create pragma statement to represent this state.
+  if (!FPFeatures.isDefault())
+    PragmaStatements.push_back(new (Context) FloatingPragmaStmt(
+        FloatingPragmaStmt::Synthesized, SourceLocation(), FPFeatures));
+
   return D;
 }
 
 /// Given the set of return statements within a function body,
 /// compute the variables that are subject to the named return value
 /// optimization.
 ///
 /// Each of the variables that is subject to the named return value

clang/lib/Sema/SemaDeclCXX.cpp

case Stmt::CXXCatchStmtClass:
     // Do not bother checking the language mode (already covered by the
     // try block check).
     if (!CheckConstexprFunctionStmt(SemaRef, Dcl,
                                     cast<CXXCatchStmt>(S)->getHandlerBlock(),
                                     ReturnStmts, Cxx1yLoc, Cxx2aLoc, Kind))
       return false;
     return true;
 
+  case Stmt::FloatingPragmaStmtClass:
+    return true;
+
   default:
     if (!isa<Expr>(S))
       break;
 
     // C++1y allows expression-statements.
     if (!Cxx1yLoc.isValid())
       Cxx1yLoc = S->getBeginLoc();
     return true;

clang/lib/Sema/SemaExceptionSpec.cpp

for (unsigned I = TS->getNumCatchStmts(); I != 0; --I) {
       if (Catch->hasEllipsis())
         return CT;
     }
 
     // Didn't find an @catch(...). Exceptions from the @try body can escape.
     return mergeCanThrow(CT, canThrow(TS->getTryBody()));
   }
 
+  case Stmt::FloatingPragmaStmtClass:
+    return CT_Cannot;
+
   case Stmt::NoStmtClass:
     llvm_unreachable("Invalid class for statement");
   }
   llvm_unreachable("Bogus StmtClass");
 }
 
 } // end namespace clang

clang/lib/Sema/SemaStmt.cpp

CapturedStmt *Res = CapturedStmt::Create(
       getASTContext(), S, static_cast<CapturedRegionKind>(RSI->CapRegionKind),
       Captures, CaptureInits, CD, RD);
 
   CD->setBody(Res->getCapturedStmt());
   RD->completeDefinition();
 
   return Res;
 }
+
+void Sema::insertPragmaStatements(SmallVectorImpl<Stmt*> &Stmts) {
+  if (!PragmaStatements.empty()) {
+    Stmts.insert(Stmts.begin(), PragmaStatements.begin(),
+                 PragmaStatements.end());
+  }
+  PragmaStatements.clear();
+}
+
+StmtResult Sema::ActOnFloatingPragmaStmt(SourceLocation PragmaLoc,
+                                         FloatingPragmaStmt::PragmaKind K) {
+  if (getCurScope()->getFnParent()) {
+    auto S = new (Context) FloatingPragmaStmt(K, PragmaLoc, FPFeatures);
+    PragmaStatements.push_back(S);
+    return S;
+  }
+  return StmtEmpty();
+}
+
+void Sema::ActOnFPContract(StmtResult S, LangOptions::FPContractModeKind X) {
+  if (S.isUsable())
+    cast<FloatingPragmaStmt>(S.get())->setContract(X);
+  FPFeatures.setContract(X);
+}

clang/lib/Sema/TreeTransform.h

 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) {
   return S;
 }
 
+template<typename Derived>
+StmtResult
+TreeTransform<Derived>::TransformFloatingPragmaStmt(FloatingPragmaStmt *S) {
+  return S;
+}
+
 //===----------------------------------------------------------------------===//
 // OpenMP directive transformation
 //===----------------------------------------------------------------------===//
 template <typename Derived>
 StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
     OMPExecutableDirective *D) {
 
   // Transform the clauses

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
   E->setExprOperand(Record.readSubExpr());
 }
 
 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
   VisitStmt(S);
   S->setLeaveLoc(readSourceLocation());
 }
 
+void ASTStmtReader::VisitFloatingPragmaStmt(FloatingPragmaStmt *S) {
+  VisitStmt(S);
+  S->setKind(static_cast<FloatingPragmaStmt::PragmaKind>(Record.readInt()));
+  S->getFPOptions() = FPOptions(Record.readInt());
+  S->setPragmaLoc(readSourceLocation());
+}
+
 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
   VisitStmt(S);
   S->Loc = readSourceLocation();
   S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
   S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
case EXPR_DEPENDENT_COAWAIT:
       break;
 
     case EXPR_CONCEPT_SPECIALIZATION: {
       unsigned numTemplateArgs = Record[ASTStmtReader::NumExprFields];
       S = ConceptSpecializationExpr::Create(Context, Empty, numTemplateArgs);
       break;
     }
 
-    case EXPR_REQUIRES:
+    case EXPR_REQUIRES: {
       unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields];
       unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1];
       S = RequiresExpr::Create(Context, Empty, numLocalParameters,
                                numRequirement);
       break;
     }
 
+    case STMT_FLOATING_PRAGMA:
+      S = new (Context) FloatingPragmaStmt(Empty);
+      break;
+    }
+
     // We hit a STMT_STOP, so we're done with this expression.
     if (Finished)
       break;
 
     ++NumStatementsRead;
 
     if (S && !IsStmtReference) {
       Reader.Visit(S);

clang/lib/Serialization/ASTWriter.cpp

#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   RECORD(STMT_GOTO);
   RECORD(STMT_INDIRECT_GOTO);
   RECORD(STMT_CONTINUE);
   RECORD(STMT_BREAK);
   RECORD(STMT_RETURN);
   RECORD(STMT_DECL);
   RECORD(STMT_GCCASM);
   RECORD(STMT_MSASM);
+  RECORD(STMT_FLOATING_PRAGMA);
   RECORD(EXPR_PREDEFINED);
   RECORD(EXPR_DECL_REF);
   RECORD(EXPR_INTEGER_LITERAL);
   RECORD(EXPR_FLOATING_LITERAL);
   RECORD(EXPR_IMAGINARY_LITERAL);
   RECORD(EXPR_STRING_LITERAL);
   RECORD(EXPR_CHARACTER_LITERAL);
   RECORD(EXPR_PAREN);

clang/lib/Serialization/ASTWriterStmt.cpp

 }
 
 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
   VisitStmt(S);
   Record.AddSourceLocation(S->getLeaveLoc());
   Code = serialization::STMT_SEH_LEAVE;
 }
 
+void ASTStmtWriter::VisitFloatingPragmaStmt(FloatingPragmaStmt *S) {
+  VisitStmt(S);
+  Record.writeEnum(S->getKind());
+  Record.push_back(S->getFPOptions().getInt());
+  Record.AddSourceLocation(S->getPragmaLoc());
+  Code = serialization::STMT_FLOATING_PRAGMA;
+}
+
 //===----------------------------------------------------------------------===//
 // OpenMP Directives.
 //===----------------------------------------------------------------------===//
 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
   Record.AddSourceLocation(E->getBeginLoc());
   Record.AddSourceLocation(E->getEndLoc());
   for (unsigned i = 0; i < E->getNumClauses(); ++i) {
     Record.writeOMPClause(E->getClause(i));

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::RequiresExprClass:
       // 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::FloatingPragmaStmtClass:
     case Stmt::IntegerLiteralClass:
     case Stmt::FixedPointLiteralClass:
     case Stmt::CharacterLiteralClass:
     case Stmt::CXXScalarValueInitExprClass:
     case Stmt::CXXBoolLiteralExprClass:
     case Stmt::ObjCBoolLiteralExprClass:
     case Stmt::ObjCAvailabilityCheckExprClass:
     case Stmt::FloatingLiteralClass:

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

+// RUN: %clang_cc1 -ast-dump %s | FileCheck --check-prefixes=CHECK,NOOPT %s
+// RUN: %clang_cc1 -ffp-contract=on -ast-dump %s | FileCheck --check-prefix=FPCONTRACT %s
+
+
+float func_00(float x, float y, float z) {
+  return x + y * z;
+}
+// NOOPT-LABEL: FunctionDecl {{.*}} func_00
+// NOOPT:       CompoundStmt
+// NOOPT-NEXT:  ReturnStmt
+
+// FPCONTRACT-LABEL: FunctionDecl {{.*}} func_00
+// FPCONTRACT:       CompoundStmt
+// FPCONTRACT-NEXT:  FloatingPragmaStmt {{.*}} pragma clang fp contract(on)
+// FPCONTRACT-NEXT:  ReturnStmt
+
+
+float func_01(float x, float y, float z) {
+  #pragma clang fp contract(on)
+  return x + y * z;
+}
+// CHECK-LABEL: FunctionDecl {{.*}} func_01
+// CHECK:       CompoundStmt
+// CHECK-NEXT:  FloatingPragmaStmt {{.*}} pragma clang fp contract(on)
+// CHECK-NEXT:  ReturnStmt
+
+
+float func_03(float x, float y, float z) {
+  #pragma STDC FP_CONTRACT ON
+  return x + y * z;
+}
+// CHECK-LABEL: FunctionDecl {{.*}} func_03
+// CHECK:       CompoundStmt
+// CHECK-NEXT:  FloatingPragmaStmt {{.*}} pragma fp_contract ON
+// CHECK-NEXT:  ReturnStmt
+
+
+float func_05(float x, float y, float z) {
+  #pragma clang fp contract(on)
+  #pragma clang fp contract(off)
+  #pragma clang fp contract(fast)
+  return x + y * z;
+}
+// CHECK-LABEL: FunctionDecl {{.*}} func_05
+// CHECK:       CompoundStmt
+// CHECK-NEXT:  FloatingPragmaStmt {{.*}} pragma clang fp contract(on)
+// CHECK-NEXT:  FloatingPragmaStmt {{.*}} pragma clang fp contract(off)
+// CHECK-NEXT:  FloatingPragmaStmt {{.*}} pragma clang fp contract(fast)
+// CHECK-NEXT:  ReturnStmt
+
+
+constexpr float func_06(float x, float y, float z) {
+  #pragma clang fp contract(on)
+  return x + y * z;
+}
+// CHECK-LABEL: FunctionDecl {{.*}} func_06
+// CHECK:       CompoundStmt
+// CHECK-NEXT:  FloatingPragmaStmt {{.*}} pragma clang fp contract(on)
+// CHECK-NEXT:  ReturnStmt
+
+
+#pragma clang fp contract(on)
+
+
+float func_07(float x, float y, float z) {
+  return x + y * z;
+}
+// CHECK-LABEL: FunctionDecl {{.*}} func_07
+// CHECK:       CompoundStmt
+// CHECK-NEXT:  FloatingPragmaStmt {{.*}} pragma clang fp contract(on)
+// CHECK-NEXT:  ReturnStmt
+
+
+float func_08(float x, float y, float z) {
+  #pragma clang fp contract(off)
+  return x + y * z;
+}
+// CHECK-LABEL: FunctionDecl {{.*}} func_08
+// CHECK:       CompoundStmt
+// CHECK-NEXT:  FloatingPragmaStmt {{.*}} pragma clang fp contract(on)
+// CHECK-NEXT:  FloatingPragmaStmt {{.*}} pragma clang fp contract(off)
+// CHECK-NEXT:  ReturnStmt

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

 
 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;
 }
+
+float fp_contract_10(float a, float x, float y, float z) {
+// CHECK-LABEL: _Z14fp_contract_10ffff
+// CHECK:       call float @llvm.fmuladd.f32
+// CHECK:       fmul float
+// CHECK:       fadd float
+// CHECK:       fadd float
+// CHECK:       call float @llvm.fmuladd.f32
+  #pragma STDC FP_CONTRACT ON
+  float r = x + y * z;
+  {
+    #pragma STDC FP_CONTRACT OFF
+    r += a + x * y;
+  }
+  r += z + x * a;
+  return r;
+}

clang/test/Coverage/c-language-features.inc

struct {
     unsigned char aa;
     unsigned char bb;
   };
 };
 
 void f11() {
   struct s12 var = { .aa = 33 };
 }
+
+float pragma_01(float x, float y, float z) {
+  #pragma clang fp contract(on)
+  #pragma STDC FP_CONTRACT OFF
+  return x + y * z;
+}

clang/tools/libclang/CIndex.cpp

CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
   case CXCursor_ConvergentAttr:
       return cxstring::createRef("attribute(convergent)");
   case CXCursor_WarnUnusedAttr:
       return cxstring::createRef("attribute(warn_unused)");
   case CXCursor_WarnUnusedResultAttr:
       return cxstring::createRef("attribute(warn_unused_result)");
   case CXCursor_AlignedAttr:
       return cxstring::createRef("attribute(aligned)");
+  case CXcursor_FloatingPragmaStmt:
+      return cxstring::createRef("FloatingPragma");
   }
 
   llvm_unreachable("Unhandled CXCursorKind");
 }
 
 struct GetCursorData {
   SourceLocation TokenBeginLoc;
   bool PointsAtMacroArgExpansion;

clang/tools/libclang/CXCursor.cpp

CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
   case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective;
     break;
   case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeSimdDirective;
     break;
   case Stmt::BuiltinBitCastExprClass:
     K = CXCursor_BuiltinBitCastExpr;
+    break;
+  case Stmt::FloatingPragmaStmtClass:
+    K = CXcursor_FloatingPragmaStmt;
+    break;
   }
 
   CXCursor C = { K, 0, { Parent, S, TU } };
   return C;
 }
 
 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super, 
                                                SourceLocation Loc,