[clang] Add support for option -ffp-eval-method and extend #pragma float_control similarly

[mibintc]

Summary

The Intel compiler supports the option "-fp-model=(source|double|extended)" which causes the compiler to use a wider type for intermediate floating point calculations. Also supported is a way to embed this effect in the source program with #pragma float_control(source|double|extended). This patch proposes to extend pragma float_control syntax, and also to support a new floating point option via "-ffp-eval-method=(source|double|extended)"

Note that the C floating point working group has proposed nearly identical pragma semantics in http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1974.pdf like this
#pragma STDC FENV_FLT_EVAL_METHOD width
I would like to add support for this also, but it's not in this patch. In the WG14 document, the standard widths are 0,1,2 representing source, double and extended precision. Negative values of width are reserved for the implementation.

The ICL option with description of semantics is at this url, https://software.intel.com/content/www/us/en/develop/documentation/cpp-compiler-developer-guide-and-reference/top/compiler-reference/compiler-options/compiler-option-details/floating-point-options/fp-model-fp.html
Quoting that here for easy reference "source
Rounds intermediate results to source-defined precision.
double
Rounds intermediate results to 53-bit (double) precision.
extended
Rounds intermediate results to 64-bit (extended) precision."

[mibintc]

clang/lib/Sema/SemaAttr.cpp

489

@rjmccall I would like to push a new value for FLT_EVAL_METHOD at the start of the scope of this pragma, then pop that value of the macro to restore the previous setting when the scope is exited, should I do that in ParsePragma? Can I do that by injecting "pragma push_macro(...)" into the token stream, do you have other suggestion or is there something similar in clang that I can study how to do this?

[mibintc]

@rjmccall Hoping you can take a look at this patch

[mibintc]

I found a way to get the macro FLT_EVAL_METHOD set properly, so this patch is ready for your review, thanks!

[aaron.ballman]

One question that came up in off-line discussions with @mibintc is whether the evaluation method should have an impact on constant folding or not. My intuition is that it should impact constant folding because it would be pretty strange for the evaluation at runtime to produce different results, but I don't have anything concrete to back my intuition up with.

clang/docs/UsersManual.rst

1530

clang/include/clang/Basic/LangOptions.h

244

FYI: it may be somewhat confusing that we have an enumerator with default in the name but that enumerator isn't the default.

clang/lib/Frontend/CompilerInvocation.cpp

4250

May want to update the comment above for why we're turning the option off here.

clang/lib/Lex/PPMacroExpansion.cpp

1716

It looks like some unrelated formatting changes snuck in.

[mibintc]

clang/include/clang/Basic/LangOptions.h

244

That's true. I had a heck of a time getting the initialization of the lang option setting correct: the setting should come from the TargetInfo if command line options don't override. That seems simple enough but there's somethng really odd about initialization. Adding the "default target" enumeral allowed me to get it initialized the way I wanted.

[mibintc]

clang/docs/LanguageExtensions.rst

3581

I'd like to add Intel ICL compatible syntax, but 'off' doesn't make too much sense to me. In the Intel compiler using'off' requires both ffp-exception-behavior to be ignore, and FENV_ACCESS to be off. If that's true then setting float_control(source|double|extended, off) is allowable and the semantics of float evaluation method set to a 4th level "float eval fast" which is loosely described in the commentary as "don't care". Ideally "float eval fast" would deliver the same results, in this context, as Microsoft's fp:fast command line option. I could make "off" an illegal setting, or warn that it's ignored. @andrew.w.kaylor do you have any input here?

[jansvoboda11]

clang/lib/Frontend/CompilerInvocation.cpp

3954

Can you please use the marshalling infrastructure for this? https://clang.llvm.org/docs/InternalsManual.html#adding-new-command-line-option (MarshallingInfoEnum)

[mibintc]

I rebased the patch and responded to review comments from @aaron.ballman and @jansvoboda11

[mibintc]

clang/include/clang/Basic/LangOptions.h

244

I redid the comments to eliminate the confusion

clang/lib/Sema/SemaAttr.cpp

489

Nevermind, I found a way to set the macro.

[aaron.ballman]

clang/docs/LanguageExtensions.rst

3586

clang/docs/UsersManual.rst

1528

clang/include/clang/Basic/LangOptions.h

236

clang/include/clang/Lex/Preprocessor.h

181

Otherwise, when LexExpandSpecialBuiltins is false, I think this winds up being an uninitialized pointer value.

clang/lib/Driver/ToolChains/Clang.cpp

2827

clang/lib/Lex/PPMacroExpansion.cpp

1743

Unrelated formatting change?

clang/lib/Sema/Sema.cpp

239

I don't think this cast is needed, is it? (It might make sense for the getFloatEvalMethod() return type to be int rather than unisnged though, given that we support negative values for implementation-defined semantics?)

243

Heh, so we have:

setCurrentFltEvalMethod
getFloatEvalMethod
getFPEvalMethod

I think we should pick a consistent spelling for float evaluation method and go with it. I don't know that work needs to happen as part of this patch (it can be a follow-up), but I think it'd help with readability.

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

240

Can we also get some tests that show how this behaves with the less common floating-point types like float16, bfloat16, float128, half?

[mibintc]

Respond to @aaron.ballman 's review

[mibintc]

clang/include/clang/Lex/Preprocessor.h

181

thanks for catching this!

clang/lib/Lex/PPMacroExpansion.cpp

1716

clang-format really wants to fix this file

clang/lib/Sema/Sema.cpp

239

You are so right. i changed the type and modified the identifier like you suggested to make things more easily understandable

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

240

I added tests fp16 and float128. I don't know if the other type names are supported in Intel, _Float16 isn't supported. I didn't see a typename half nor bfloat16 being used in any of the CodeGen tests, is this sufficient? if the predicate IsFloatingType is true and if the expression comes into UsualUnaryConversions then this new code should take effect

clang/test/Preprocessor/predefined-flteval-macro.c

1 ↗

(On Diff #343666)

Since FLT_EVAL_METHOD is no longer a typical predefined macro, I removed all the tests from clang/test/Preprocessor/init.c (see above) and created this to test all the combinations

[aaron.ballman]

I think the changes look good to me, but I'm not a floating-point expert either.

Adding @hubert.reinterpretcast for his floating-point expertise.

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

240

I think this is fine (I picked the floating point names from Types.h when looking to see what other floating-point types exist) -- thanks for adding the new tests!

[mibintc]

I've rebased and applied clang-format. I'd like to push this, looking for your +1, thank you!

[aaron.ballman]

In D93769#2887857, @mibintc wrote:

I've rebased and applied clang-format. I'd like to push this, looking for your +1, thank you!

I've marked with my LGTM, but I'd still really appreciate a double-check from someone with more experience in floating-point before we land.

[MaskRay]

This breaks clang/test/Index/preamble-reparse-changed-module.m

http://45.33.8.238/linux/51638/step_7.txt

[MaskRay]

clang/test/Preprocessor/predefined-flteval-macro.c

332 ↗

(On Diff #360247)

So many clang invocations slow down testsuite execution.

Can some RUN lines be removed if their coverage value is low ?

[mibintc]

In D93769#2891545, @MaskRay wrote:

This breaks clang/test/Index/preamble-reparse-changed-module.m

http://45.33.8.238/linux/51638/step_7.txt

I saw this fail on console when i do "ninja check-clang" but when I run each step in this test separately there is no failure
the return code is 0
I don't understand what the failure is, how can I discover the problem? Thank you. I can revert the patch

[MaskRay]

In D93769#2891549, @mibintc wrote:

In D93769#2891545, @MaskRay wrote:

This breaks clang/test/Index/preamble-reparse-changed-module.m

http://45.33.8.238/linux/51638/step_7.txt

I saw this fail on console when i do "ninja check-clang" but when I run each step in this test separately there is no failure
the return code is 0
I don't understand what the failure is, how can I discover the problem? Thank you. I can revert the patch

Seems like a libclang crash (an assert failure) if you enable LLVM_ENABLE_ASSERTIONS=on.

You can reproduce with check-clang-index

[mibintc]

clang/test/Preprocessor/predefined-flteval-macro.c

332 ↗

(On Diff #360247)

OK. I was trying to demonstrate that my changes hadn't modified the macro settings across all

[mibintc]

In D93769#2891552, @MaskRay wrote:

In D93769#2891549, @mibintc wrote:

In D93769#2891545, @MaskRay wrote:

This breaks clang/test/Index/preamble-reparse-changed-module.m

Seems like a libclang crash (an assert failure) if you enable LLVM_ENABLE_ASSERTIONS=on.

You can reproduce with check-clang-index

Thanks for this, I'm building with assertions on now. This patch doesn't expand FLT_EVAL_METHOD in -E mode, I'm guessing that's why it fails. It can't expand the macro during -E because the context showing the value of the macro setting is only available in Sema. I haven't yet studied the test but do you know have an idea how I might be able to solve the problem?

[mibintc]

@MaskRay I experience that the failing test clang/test/Index/preamble-reparse-changed-module.m is non-deterministic and currently I cannot reproduce the fail. I added details in D95159. Are you able to reproduce if you clean your build area? Do you have a suggestion for how I can solve this problem? Thanks a lot

[zahiraam]

This comment was removed by zahiraam.

[matthewtff]

This CL breaks -E flow. I've created a repro: https://pastebin.com/fFuUdsfp
If you build it on linux with ToT clang like this: clang++ -target i386-unknown-linux-gnu repro.cc -o repro.bin
and then run the binary you'll get output "Hello, One". But if you make a roundtrip via preprocessing:
clang++ -target i386-unknown-linux-gnu -E repro.cc > repro_pp.cc
clang++ -target i386-unknown-linux-gnu repro_pp.cc -o repro_pp.bin
And then run ./repro_pp.bin, you'll get output "Hello, Three". So now the binary differs.

If you revert this CL, then both ways of compiling would give the same binary, that would output "Hello, One".

[zahiraam]

In D93769#2970097, @matthewtff wrote:

This CL breaks -E flow. I've created a repro: https://pastebin.com/fFuUdsfp
If you build it on linux with ToT clang like this: clang++ -target i386-unknown-linux-gnu repro.cc -o repro.bin
and then run the binary you'll get output "Hello, One". But if you make a roundtrip via preprocessing:
clang++ -target i386-unknown-linux-gnu -E repro.cc > repro_pp.cc
clang++ -target i386-unknown-linux-gnu repro_pp.cc -o repro_pp.bin
And then run ./repro_pp.bin, you'll get output "Hello, Three". So now the binary differs.

If you revert this CL, then both ways of compiling would give the same binary, that would output "Hello, One".

I do see a previous comment from Melanie mentioning this issue:
"Thanks for this, I'm building with assertions on now. This patch doesn't expand FLT_EVAL_METHOD in -E mode, I'm guessing that's why it fails. It can't expand the macro during -E because the context showing the value of the macro setting is only available in Sema. I haven't yet studied the test but do you know have an idea how I might be able to solve the problem?"
It looks like Melanie asked the questions but it wasn't resolved.

[matthewtff]

It looks like Melanie asked the questions but it wasn't resolved.

Can this CL be reverted and relanded later with a fix? This breakage is crucial for a lot of remote/distributed compilation systems.

[erichkeane]

In D93769#2972151, @matthewtff wrote:

It looks like Melanie asked the questions but it wasn't resolved.

Can this CL be reverted and relanded later with a fix? This breakage is crucial for a lot of remote/distributed compilation systems.

Did someone perhaps fix this in trunk? I don't see it on godbolt: https://godbolt.org/z/r76rx5Evd

See the preprocessed version ends up being:

int main() {

std::cout << "Hello, " "One" << std::endl;

}

[aaron.ballman]

In D93769#2972151, @matthewtff wrote:

It looks like Melanie asked the questions but it wasn't resolved.

Can this CL be reverted and relanded later with a fix? This breakage is crucial for a lot of remote/distributed compilation systems.

I think that's reasonable, as Melanie recently retired from Intel and so it may take a bit to get the correct fix. Someone should double-check that this patch did *not* make it to the Clang 13 branch, too. By my understanding the branch was at 1:45am Jul 28 and this patch landed at 10:51am Jul 28 and so we should be good, but best to double-check.

[erichkeane]

In D93769#2972203, @erichkeane wrote:

In D93769#2972151, @matthewtff wrote:

It looks like Melanie asked the questions but it wasn't resolved.

Can this CL be reverted and relanded later with a fix? This breakage is crucial for a lot of remote/distributed compilation systems.

Did someone perhaps fix this in trunk? I don't see it on godbolt: https://godbolt.org/z/r76rx5Evd

See the preprocessed version ends up being:

int main() {

std::cout << "Hello, " "One" << std::endl;

}

Ah, nvm, I see what I did wrong. The test requires 32 bit to fail, since there is an #elif branch of the #ifdef __FLT_EVAL_METHOD__. Disregard.

[matthewtff]

Did someone perhaps fix this in trunk? I don't see it on godbolt: https://godbolt.org/z/r76rx5Evd

You've missed the -target argument. It still reproduces with correct arguments: https://godbolt.org/z/1ozhjYvhf

clang/docs/LanguageExtensions.rst

 compound statement (excluding comments). When used within a compound statement,
 the pragma is active within the scope of the compound statement.  This pragma
 is modeled after a Microsoft pragma with the same spelling and syntax.  For
 pragmas specified at file or namespace scope, or within a language linkage
 specification, a stack is supported so that the ``pragma float_control``
 settings can be pushed or popped.
 
 When ``pragma float_control(precise, on)`` is enabled, the section of code
-governed by the pragma uses precise floating point semantics, effectively
+governed by the pragma uses precise floating-point semantics, effectively
 ``-ffast-math`` is disabled and ``-ffp-contract=on``
 (fused multiply add) is enabled.
 
 When ``pragma float_control(except, on)`` is enabled, the section of code governed
 by the pragma behaves as though the command-line option
 ``-ffp-exception-behavior=strict`` is enabled,
 when ``pragma float_control(precise, off)`` is enabled, the section of code
 governed by the pragma behaves as though the command-line option
 ``-ffp-exception-behavior=ignore`` is enabled.
 
+When ``pragma float_control(source, on)`` is enabled, the section of code governed
+by the pragma behaves as though the command-line option
+``-ffp-eval-method=source`` is enabled. Note: The default
+floating-point evaluation method is target-specific, typically ``source``.
+
+When ``pragma float_control(double, on)`` is enabled, the section of code governed
+by the pragma behaves as though the command-line option
+``-ffp-eval-method=double`` is enabled.
+
+When ``pragma float_control(extended, on)`` is enabled, the section of code governed
+by the pragma behaves as though the command-line option
+``-ffp-eval-method=extended`` is enabled.
+
+When ``pragma float_control(source, off)`` or
+``pragma float_control(double, off)`` or
+``pragma float_control(extended, off)`` is enabled,
+the section of code governed
+by the pragma behaves as though the command-line option
+``-ffp-eval-method=source`` is enabled, returning floating-point evaluation
+method to the default setting.
+
 The full syntax this pragma supports is
-``float_control(except|precise, on|off [, push])`` and
+``float_control(except|precise|source|double|extended, on|off [, push])`` and
 ``float_control(push|pop)``.
 The ``push`` and ``pop`` forms, including using ``push`` as the optional
 third argument, can only occur at file scope.
 
 .. code-block:: c++
 
   for(...) {
     // This block will be compiled with -fno-fast-math and -ffp-contract=on

clang/docs/UsersManual.rst

.. option:: -ffp-exception-behavior=<value>
 
    Valid values are: ``ignore``, ``maytrap``, and ``strict``.
    The default value is ``ignore``.  Details:
 
    * ``ignore`` The compiler assumes that the exception status flags will not be read and that floating point exceptions will be masked.
    * ``maytrap`` The compiler avoids transformations that may raise exceptions that would not have been raised by the original code. Constant folding performed by the compiler is exempt from this option.
    * ``strict`` The compiler ensures that all transformations strictly preserve the floating point exception semantics of the original code.
 
+.. option:: -ffp-eval-method=<value>
+
+   Specify the floating-point evaluation method.
+
+   Valid values are: ``source``, ``double``, and ``extended``.
+   The default value is target-specific, typically ``source``.  Details:
+
+   * ``source`` The compiler uses the floating-point type declared in the source program as the evaluation method.
+   * ``double`` The compiler uses ``double`` as the floating-point evaluation method for all float expressions of type that is narrower than ``double``.
+   * ``extended`` The compiler uses ``long double`` as the floating-point evaluation method for all float expressions of type that is narrower than ``long double``.
+
 .. option:: -f[no-]protect-parens:
 
    This option pertains to floating-point types, complex types with
    floating-point components, and vectors of these types. Some arithmetic
    expression transformations that are mathematically correct and permissible
    according to the C and C++ language standards may be incorrect when dealing
    with floating-point types, such as reassociation and distribution. Further,
    the optimizer may ignore parentheses when computing arithmetic expressions

clang/include/clang/Basic/FPOptions.def

 OPTION(FPExceptionMode, LangOptions::FPExceptionModeKind, 2, RoundingMode)
 OPTION(AllowFEnvAccess, bool, 1, FPExceptionMode)
 OPTION(AllowFPReassociate, bool, 1, AllowFEnvAccess)
 OPTION(NoHonorNaNs, bool, 1, AllowFPReassociate)
 OPTION(NoHonorInfs, bool, 1, NoHonorNaNs)
 OPTION(NoSignedZero, bool, 1, NoHonorInfs)
 OPTION(AllowReciprocal, bool, 1, NoSignedZero)
 OPTION(AllowApproxFunc, bool, 1, AllowReciprocal)
+OPTION(FPEvalMethod, LangOptions::FPEvalMethodKind, 2, AllowApproxFunc)
 #undef OPTION

clang/include/clang/Basic/LangOptions.h

enum FPExceptionModeKind {
     FPE_MayTrap,
     /// Strictly preserve the floating-point exception semantics.
     FPE_Strict
   };
 
   /// Possible exception handling behavior.
   enum class ExceptionHandlingKind { None, SjLj, WinEH, DwarfCFI, Wasm };
 
+  /// Possible float expression evaluation method choices.
+  enum FPEvalMethodKind {
+    /// Use the declared type for fp arithmetic.
+    FEM_Source,
+    /// Use the type double for fp arithmetic.
+    FEM_Double,
+    /// Use extended type for fp arithmetic.
+    FEM_Extended,
+    /// Use the default float eval method specified by Target:
+    //  most targets are defined with evaluation method FEM_Source.
+    FEM_TargetDefault
+  };
+
   enum class LaxVectorConversionKind {
     /// Permit no implicit vector bitcasts.
     None,
     /// Permit vector bitcasts between integer vectors with different numbers
     /// of elements but the same total bit-width.
     Integer,
     /// Permit vector bitcasts between all vectors with the same total
     /// bit-width.
explicit FPOptions(const LangOptions &LO) {
     if (getFPContractMode() == LangOptions::FPM_On &&
         getRoundingMode() == llvm::RoundingMode::Dynamic &&
         getFPExceptionMode() == LangOptions::FPE_Strict)
       // If the FP settings are set to the "strict" model, then
       // FENV access is set to true. (ffp-model=strict)
       setAllowFEnvAccess(true);
     else
       setAllowFEnvAccess(LangOptions::FPM_Off);
+    setFPEvalMethod(LO.getFPEvalMethod());
   }
 
   bool allowFPContractWithinStatement() const {
     return getFPContractMode() == LangOptions::FPM_On;
   }
   void setAllowFPContractWithinStatement() {
     setFPContractMode(LangOptions::FPM_On);
   }

clang/include/clang/Basic/LangOptions.def

 BENIGN_LANGOPT(CLNoSignedZero , 1, 0, "Permit Floating Point optimization without regard to signed zeros")
 COMPATIBLE_LANGOPT(CLUnsafeMath , 1, 0, "Unsafe Floating Point Math")
 COMPATIBLE_LANGOPT(CLFiniteMathOnly , 1, 0, "__FINITE_MATH_ONLY__ predefined macro")
 /// FP_CONTRACT mode (on/off/fast).
 BENIGN_ENUM_LANGOPT(DefaultFPContractMode, FPModeKind, 2, FPM_Off, "FP contraction type")
 COMPATIBLE_LANGOPT(ExpStrictFP, 1, false, "Enable experimental strict floating point")
 BENIGN_ENUM_LANGOPT(FPRoundingMode, RoundingMode, 3, RoundingMode::NearestTiesToEven, "FP Rounding Mode type")
 BENIGN_ENUM_LANGOPT(FPExceptionMode, FPExceptionModeKind, 2, FPE_Ignore, "FP Exception Behavior Mode type")
+BENIGN_ENUM_LANGOPT(FPEvalMethod, FPEvalMethodKind, 2, FEM_TargetDefault, "FP type used for floating point arithmetic")
 LANGOPT(NoBitFieldTypeAlign , 1, 0, "bit-field type alignment")
 LANGOPT(HexagonQdsp6Compat , 1, 0, "hexagon-qdsp6 backward compatibility")
 LANGOPT(ObjCAutoRefCount , 1, 0, "Objective-C automated reference counting")
 LANGOPT(ObjCWeakRuntime     , 1, 0, "__weak support in the ARC runtime")
 LANGOPT(ObjCWeak            , 1, 0, "Objective-C __weak in ARC and MRC files")
 LANGOPT(ObjCSubscriptingLegacyRuntime         , 1, 0, "Subscripting support in legacy ObjectiveC runtime")
 BENIGN_LANGOPT(CompatibilityQualifiedIdBlockParamTypeChecking, 1, 0,
                "compatibility mode for type checking block parameters "

clang/include/clang/Basic/PragmaKinds.h

 
 enum PragmaFloatControlKind {
   PFC_Unknown,
   PFC_Precise,   // #pragma float_control(precise, [,on])
   PFC_NoPrecise, // #pragma float_control(precise, off)
   PFC_Except,    // #pragma float_control(except [,on])
   PFC_NoExcept,  // #pragma float_control(except, off)
   PFC_Push,      // #pragma float_control(push)
-  PFC_Pop        // #pragma float_control(pop)
+  PFC_Pop,       // #pragma float_control(pop)
+  PFC_Source,    // #pragma float_control(source, {on|off} [,push])
+  PFC_Double,    // #pragma float_control(double, {on|off} [,push])
+  PFC_Extended,  // #pragma float_control(extended, {on|off} [,push])
 };
 }
 
 #endif

clang/include/clang/Basic/TargetInfo.h

public:
   virtual const char *getFloat128Mangling() const { return "g"; }
 
   /// Return the mangled code of bfloat.
   virtual const char *getBFloat16Mangling() const {
     llvm_unreachable("bfloat not implemented on this target");
   }
 
   /// Return the value for the C99 FLT_EVAL_METHOD macro.
-  virtual unsigned getFloatEvalMethod() const { return 0; }
+  //  Note: implementation defined values may be negative.
+  virtual int getFPEvalMethod() const { return 0; }
 
   // getLargeArrayMinWidth/Align - Return the minimum array size that is
   // 'large' and its alignment.
   unsigned getLargeArrayMinWidth() const { return LargeArrayMinWidth; }
   unsigned getLargeArrayAlign() const { return LargeArrayAlign; }
 
   /// Return the maximum width lock-free atomic operation which will
   /// ever be supported for the given target

clang/include/clang/Driver/Options.td

 def : Flag<["-"], "fno-expensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
 def fextdirs_EQ : Joined<["-"], "fextdirs=">, Group<f_Group>;
 def : Flag<["-"], "fdefer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fno-defer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fextended-identifiers">, Group<clang_ignored_f_Group>;
 def : Flag<["-"], "fno-extended-identifiers">, Group<f_Group>, Flags<[Unsupported]>;
 def fhosted : Flag<["-"], "fhosted">, Group<f_Group>;
 def fdenormal_fp_math_EQ : Joined<["-"], "fdenormal-fp-math=">, Group<f_Group>, Flags<[CC1Option]>;
+def ffp_eval_method_EQ : Joined<["-"], "ffp-eval-method=">, Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Specifies the evaluation method to use for floating-point arithmetic.">,
+  Values<"source,double,extended">, NormalizedValuesScope<"LangOptions">,
+  NormalizedValues<["FEM_Source", "FEM_Double", "FEM_Extended"]>,
+  MarshallingInfoEnum<LangOpts<"FPEvalMethod">, "FEM_TargetDefault">;
 def ffp_model_EQ : Joined<["-"], "ffp-model=">, Group<f_Group>, Flags<[NoXarchOption]>,
   HelpText<"Controls the semantics of floating-point calculations.">;
 def ffp_exception_behavior_EQ : Joined<["-"], "ffp-exception-behavior=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Specifies the exception behavior of floating-point operations.">,
   Values<"ignore,maytrap,strict">, NormalizedValuesScope<"LangOptions">,
   NormalizedValues<["FPE_Ignore", "FPE_MayTrap", "FPE_Strict"]>,
   MarshallingInfoEnum<LangOpts<"FPExceptionMode">, "FPE_Ignore">;
 defm fast_math : BoolFOption<"fast-math",

clang/include/clang/Lex/Preprocessor.h

class Preprocessor {
   IdentifierInfo *Ident__MODULE__;                 // __MODULE__
   IdentifierInfo *Ident__has_cpp_attribute;        // __has_cpp_attribute
   IdentifierInfo *Ident__has_c_attribute;          // __has_c_attribute
   IdentifierInfo *Ident__has_declspec;             // __has_declspec_attribute
   IdentifierInfo *Ident__is_target_arch;           // __is_target_arch
   IdentifierInfo *Ident__is_target_vendor;         // __is_target_vendor
   IdentifierInfo *Ident__is_target_os;             // __is_target_os
   IdentifierInfo *Ident__is_target_environment;    // __is_target_environment
+  IdentifierInfo *Ident__FLT_EVAL_METHOD__ = nullptr; // __FLT_EVAL_METHOD__
 
   // Weak, only valid (and set) while InMacroArgs is true.
   Token* ArgMacro;
 
   SourceLocation DATELoc, TIMELoc;
 
+  // Corresponding to __FLT_EVAL_METHOD__. Initialized from TargetInfo
+  // or the command line. Implementation-defined values can be negative.
+  int CurrentFPEvalMethod = 0;
+
   // Next __COUNTER__ value, starts at 0.
   unsigned CounterValue = 0;
 
   enum {
     /// Maximum depth of \#includes.
     MaxAllowedIncludeStackDepth = 200
   };
 
public:
 
   /// Returns true if the preprocessor has seen a use of
   /// __DATE__ or __TIME__ in the file so far.
   bool SawDateOrTime() const {
     return DATELoc != SourceLocation() || TIMELoc != SourceLocation();
   }
   unsigned getCounterValue() const { return CounterValue; }
   void setCounterValue(unsigned V) { CounterValue = V; }
+  int getCurrentFPEvalMethod() const { return CurrentFPEvalMethod; }
+  void setCurrentFPEvalMethod(int V) { CurrentFPEvalMethod = V; }
 
   /// Retrieves the module that we're currently building, if any.
   Module *getCurrentModule();
 
   /// Allocate a new MacroInfo object with the provided SourceLocation.
   MacroInfo *AllocateMacroInfo(SourceLocation L);
 
   /// Turn the specified lexer token into a fully checked and spelled

clang/include/clang/Lex/PreprocessorOptions.h

public:
   /// Disables #includes of other files and if there are unresolved identifiers
   /// in preprocessor directive conditions it causes all blocks to be parsed so
   /// that the client can get the maximum amount of information from the parser.
   bool SingleFileParseMode = false;
 
   /// When enabled, the preprocessor will construct editor placeholder tokens.
   bool LexEditorPlaceholders = true;
 
+  /// When enabled, the preprocessor will expand special builtin macros.
+  bool LexExpandSpecialBuiltins = true;
+
   /// True if the SourceManager should report the original file name for
   /// contents of files that were remapped to other files. Defaults to true.
   bool RemappedFilesKeepOriginalName = true;
 
   /// The set of file remappings, which take existing files on
   /// the system (the first part of each pair) and gives them the
   /// contents of other files on the system (the second part of each
   /// pair).
public:
   void resetNonModularOptions() {
     Includes.clear();
     MacroIncludes.clear();
     ChainedIncludes.clear();
     DumpDeserializedPCHDecls = false;
     ImplicitPCHInclude.clear();
     SingleFileParseMode = false;
     LexEditorPlaceholders = true;
+    LexExpandSpecialBuiltins = true;
     RetainRemappedFileBuffers = true;
     PrecompiledPreambleBytes.first = 0;
     PrecompiledPreambleBytes.second = false;
     RetainExcludedConditionalBlocks = false;
   }
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_

clang/include/clang/Sema/Sema.h

   /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
   /// should not be used elsewhere.
   void EmitCurrentDiagnostic(unsigned DiagID);
 
   /// Records and restores the CurFPFeatures state on entry/exit of compound
   /// statements.
   class FPFeaturesStateRAII {
   public:
-    FPFeaturesStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.CurFPFeatures) {
-      OldOverrides = S.FpPragmaStack.CurrentValue;
-    }
-    ~FPFeaturesStateRAII() {
-      S.CurFPFeatures = OldFPFeaturesState;
-      S.FpPragmaStack.CurrentValue = OldOverrides;
-    }
+    FPFeaturesStateRAII(Sema &S);
+    ~FPFeaturesStateRAII();
     FPOptionsOverride getOverrides() { return OldOverrides; }
 
   private:
     Sema& S;
     FPOptions OldFPFeaturesState;
     FPOptionsOverride OldOverrides;
+    int OldEvalMethod;
   };
 
   void addImplicitTypedef(StringRef Name, QualType T);
 
   bool WarnedStackExhausted = false;
 
   /// Increment when we find a reference; decrement when we find an ignored
   /// assignment.  Ultimately the value is 0 if every reference is an ignored

clang/lib/Basic/Targets/OSTargets.h

if (this->PointerWidth == 64) {
       this->WCharType = this->UnsignedInt;
     } else {
       this->WCharType = this->UnsignedShort;
     }
     this->UseZeroLengthBitfieldAlignment = true;
   }
 
   // AIX sets FLT_EVAL_METHOD to be 1.
-  unsigned getFloatEvalMethod() const override { return 1; }
+  int getFPEvalMethod() const override { return 1; }
   bool hasInt128Type() const override { return false; }
 
   bool defaultsToAIXPowerAlignment() const override { return true; }
 };
 
 // z/OS target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY ZOSTargetInfo : public OSTargetInfo<Target> {

clang/lib/Basic/Targets/X86.h

X86TargetInfo(const llvm::Triple &Triple, const TargetOptions &)
     if (IsWinCOFF)
       MaxVectorAlign = MaxTLSAlign = 8192u * getCharWidth();
   }
 
   const char *getLongDoubleMangling() const override {
     return LongDoubleFormat == &llvm::APFloat::IEEEquad() ? "g" : "e";
   }
 
-  unsigned getFloatEvalMethod() const override {
+  int getFPEvalMethod() const override {
     // X87 evaluates with 80 bits "long double" precision.
     return SSELevel == NoSSE ? 2 : 0;
   }
 
   ArrayRef<const char *> getGCCRegNames() const override;
 
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
     return None;

 };
 
 class LLVM_LIBRARY_VISIBILITY NetBSDI386TargetInfo
     : public NetBSDTargetInfo<X86_32TargetInfo> {
 public:
   NetBSDI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : NetBSDTargetInfo<X86_32TargetInfo>(Triple, Opts) {}
 
-  unsigned getFloatEvalMethod() const override {
+  int getFPEvalMethod() const override {
     unsigned Major, Minor, Micro;
     getTriple().getOSVersion(Major, Minor, Micro);
     // New NetBSD uses the default rounding mode.
     if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0)
-      return X86_32TargetInfo::getFloatEvalMethod();
+      return X86_32TargetInfo::getFPEvalMethod();
     // NetBSD before 6.99.26 defaults to "double" rounding.
     return 1;
   }
 };
 
 class LLVM_LIBRARY_VISIBILITY OpenBSDI386TargetInfo
     : public OpenBSDTargetInfo<X86_32TargetInfo> {
 public:

clang/lib/Driver/ToolChains/Clang.cpp

static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
   bool TrappingMathPresent = false; // Is trapping-math in args, and not
                                     // overriden by ffp-exception-behavior?
   bool RoundingFPMath = false;
   bool RoundingMathPresent = false; // Is rounding-math in args?
   // -ffp-model values: strict, fast, precise
   StringRef FPModel = "";
   // -ffp-exception-behavior options: strict, maytrap, ignore
   StringRef FPExceptionBehavior = "";
+  // -ffp-eval-method options: double, extended, source
+  StringRef FPEvalMethod = "";
   const llvm::DenormalMode DefaultDenormalFPMath =
       TC.getDefaultDenormalModeForType(Args, JA);
   const llvm::DenormalMode DefaultDenormalFP32Math =
       TC.getDefaultDenormalModeForType(Args, JA, &llvm::APFloat::IEEEsingle());
 
   llvm::DenormalMode DenormalFPMath = DefaultDenormalFPMath;
   llvm::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math;
   StringRef FPContract = "on";
case options::OPT_ffp_exception_behavior_EQ: {
         FPExceptionBehavior = Val;
         TrappingMath = TrappingMathPresent = true;
       } else
         D.Diag(diag::err_drv_unsupported_option_argument)
             << A->getOption().getName() << Val;
       break;
     }
 
+    // Validate and pass through -ffp-eval-method option.
+    case options::OPT_ffp_eval_method_EQ: {
+      StringRef Val = A->getValue();
+      if (Val.equals("double") || Val.equals("extended") ||
+          Val.equals("source"))
+        FPEvalMethod = Val;
+      else
+        D.Diag(diag::err_drv_unsupported_option_argument)
+            << A->getOption().getName() << Val;
+      break;
+    }
+
     case options::OPT_ffinite_math_only:
       HonorINFs = false;
       HonorNaNs = false;
       break;
     case options::OPT_fno_finite_math_only:
       HonorINFs = true;
       HonorNaNs = true;
       break;
static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
 
   if (RoundingFPMath && RoundingMathPresent)
     CmdArgs.push_back(Args.MakeArgString("-frounding-math"));
 
   if (!FPExceptionBehavior.empty())
     CmdArgs.push_back(Args.MakeArgString("-ffp-exception-behavior=" +
                       FPExceptionBehavior));
 
+  if (!FPEvalMethod.empty())
+    CmdArgs.push_back(Args.MakeArgString("-ffp-eval-method=" + FPEvalMethod));
+
   ParseMRecip(D, Args, CmdArgs);
 
   // -ffast-math enables the __FAST_MATH__ preprocessor macro, but check for the
   // individual features enabled by -ffast-math instead of the option itself as
   // that's consistent with gcc's behaviour.
   if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath &&
       ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
     CmdArgs.push_back("-ffast-math");

clang/lib/Frontend/CompilerInvocation.cpp

#undef LANG_OPTION_WITH_MARSHALLING
   std::vector<std::string> systemIgnorelists =
       Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
   Opts.NoSanitizeFiles.insert(Opts.NoSanitizeFiles.end(),
                               systemIgnorelists.begin(),
                               systemIgnorelists.end());
 
   if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
     Opts.setClangABICompat(LangOptions::ClangABI::Latest);
 
     StringRef Ver = A->getValue();
     std::pair<StringRef, StringRef> VerParts = Ver.split('.');
     unsigned Major, Minor = 0;
 
     // Check the version number is valid: either 3.x (0 <= x <= 9) or
     // y or y.0 (4 <= y <= current version).
     if (!VerParts.first.startswith("0") &&
         !VerParts.first.getAsInteger(10, Major) &&
for (const auto *A : Args.filtered(OPT_remap_file)) {
     }
 
     Opts.addRemappedFile(Split.first, Split.second);
   }
 
   // Always avoid lexing editor placeholders when we're just running the
   // preprocessor as we never want to emit the
   // "editor placeholder in source file" error in PP only mode.
-  if (isStrictlyPreprocessorAction(Action))
+  // Certain predefined macros which depend upon semantic processing,
+  // for example __FLT_EVAL_METHOD__, are not expanded in PP mode, they
+  // appear in the preprocessed output as an unexpanded macro name.
+  if (isStrictlyPreprocessorAction(Action)) {
     Opts.LexEditorPlaceholders = false;
+    Opts.LexExpandSpecialBuiltins = false;
+  }
 
   return Diags.getNumErrors() == NumErrorsBefore;
 }
 
 static void GeneratePreprocessorOutputArgs(
     const PreprocessorOutputOptions &Opts, SmallVectorImpl<const char *> &Args,
     CompilerInvocation::StringAllocator SA, frontend::ActionKind Action) {
   const PreprocessorOutputOptions &PreprocessorOutputOpts = Opts;

clang/lib/Frontend/InitPreprocessor.cpp

if (unsigned PICLevel = LangOpts.PICLevel) {
     Builder.defineMacro("__pic__", Twine(PICLevel));
     if (LangOpts.PIE) {
       Builder.defineMacro("__PIE__", Twine(PICLevel));
       Builder.defineMacro("__pie__", Twine(PICLevel));
     }
   }
 
   // Macros to control C99 numerics and <float.h>
-  Builder.defineMacro("__FLT_EVAL_METHOD__", Twine(TI.getFloatEvalMethod()));
+  // Note: __FLT_EVAL_METHOD__ is not defined here since it is a special
+  // builtin macro, its value may fluctuate during compilation.
   Builder.defineMacro("__FLT_RADIX__", "2");
   Builder.defineMacro("__DECIMAL_DIG__", "__LDBL_DECIMAL_DIG__");
 
   if (LangOpts.getStackProtector() == LangOptions::SSPOn)
     Builder.defineMacro("__SSP__");
   else if (LangOpts.getStackProtector() == LangOptions::SSPStrong)
     Builder.defineMacro("__SSP_STRONG__", "2");
   else if (LangOpts.getStackProtector() == LangOptions::SSPReq)

clang/lib/Lex/PPMacroExpansion.cpp

 /// identifier table.
 void Preprocessor::RegisterBuiltinMacros() {
   Ident__LINE__ = RegisterBuiltinMacro(*this, "__LINE__");
   Ident__FILE__ = RegisterBuiltinMacro(*this, "__FILE__");
   Ident__DATE__ = RegisterBuiltinMacro(*this, "__DATE__");
   Ident__TIME__ = RegisterBuiltinMacro(*this, "__TIME__");
   Ident__COUNTER__ = RegisterBuiltinMacro(*this, "__COUNTER__");
   Ident_Pragma  = RegisterBuiltinMacro(*this, "_Pragma");
+  if (PPOpts->LexExpandSpecialBuiltins)
+    // Suppress macro expansion if compiler stops before semantic analysis,
+    // the macro identifier will appear in the preprocessed output.
+    Ident__FLT_EVAL_METHOD__ =
+        RegisterBuiltinMacro(*this, "__FLT_EVAL_METHOD__");
 
   // C++ Standing Document Extensions.
   if (getLangOpts().CPlusPlus)
     Ident__has_cpp_attribute =
         RegisterBuiltinMacro(*this, "__has_cpp_attribute");
   else
     Ident__has_cpp_attribute = nullptr;
 
if (CurFile) {
       struct tm *TM = localtime(&TT);
       Result = asctime(TM);
     } else {
       Result = "??? ??? ?? ??:??:?? ????\n";
     }
     // Surround the string with " and strip the trailing newline.
     OS << '"' << StringRef(Result).drop_back() << '"';
     Tok.setKind(tok::string_literal);
+  } else if (II == Ident__FLT_EVAL_METHOD__) {
+    // __FLT_EVAL_METHOD__ expands to a simple numeric value.
+    OS << getCurrentFPEvalMethod();
+    Tok.setKind(tok::numeric_constant);
   } else if (II == Ident__COUNTER__) {
     // __COUNTER__ expands to a simple numeric value.
     OS << CounterValue++;
     Tok.setKind(tok::numeric_constant);
   } else if (II == Ident__has_feature) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [this](Token &Tok, bool &HasLexedNextToken) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
           const LangOptions &LangOpts = getLangOpts();
           return LangOpts.DeclSpecKeyword &&
                  hasAttribute(AttrSyntax::Declspec, nullptr, II,
                               getTargetInfo(), LangOpts);
         }
 
         return false;
       });
-  } else if (II == Ident__has_cpp_attribute ||
-             II == Ident__has_c_attribute) {
+  } else if (II == Ident__has_cpp_attribute || II == Ident__has_c_attribute) {
     bool IsCXX = II == Ident__has_cpp_attribute;
     EvaluateFeatureLikeBuiltinMacro(
         OS, Tok, II, *this, [&](Token &Tok, bool &HasLexedNextToken) -> int {
           IdentifierInfo *ScopeII = nullptr;
           IdentifierInfo *II = ExpectFeatureIdentifierInfo(
               Tok, *this, diag::err_feature_check_malformed);
           if (!II)
             return false;
EvaluateFeatureLikeBuiltinMacro(
                                              diag::err_feature_check_malformed);
           }
 
           AttrSyntax Syntax = IsCXX ? AttrSyntax::CXX : AttrSyntax::C;
           return II ? hasAttribute(Syntax, ScopeII, II, getTargetInfo(),
                                    getLangOpts())
                     : 0;
         });
-  } else if (II == Ident__has_include ||
-             II == Ident__has_include_next) {
+  } else if (II == Ident__has_include || II == Ident__has_include_next) {
     // The argument to these two builtins should be a parenthesized
     // file name string literal using angle brackets (<>) or
     // double-quotes ("").
     bool Value;
     if (II == Ident__has_include)
       Value = EvaluateHasInclude(Tok, II, *this);
     else
       Value = EvaluateHasIncludeNext(Tok, II, *this);

clang/lib/Parse/ParsePragma.cpp

void PragmaFloatControlHandler::HandlePragma(Preprocessor &PP,
   PP.Lex(Tok);
   if (Tok.isNot(tok::l_paren)) {
     PP.Diag(FloatControlLoc, diag::err_expected) << tok::l_paren;
     return;
   }
 
   // Read the identifier.
   PP.Lex(Tok);
+  PragmaFloatControlKind Kind;
+  if (Tok.is(tok::kw_double)) {
+    Kind = PFC_Double;
+  } else {
     if (Tok.isNot(tok::identifier)) {
       PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
       return;
     }
 
     // Verify that this is one of the float control options.
     IdentifierInfo *II = Tok.getIdentifierInfo();
-  PragmaFloatControlKind Kind =
-      llvm::StringSwitch<PragmaFloatControlKind>(II->getName())
+    Kind = llvm::StringSwitch<PragmaFloatControlKind>(II->getName())
                .Case("precise", PFC_Precise)
                .Case("except", PFC_Except)
                .Case("push", PFC_Push)
                .Case("pop", PFC_Pop)
+               .Case("source", PFC_Source)
+               .Case("extended", PFC_Extended)
                .Default(PFC_Unknown);
-  PP.Lex(Tok); // the identifier
+  }
+  PP.Lex(Tok); // the first pragma token
   if (Kind == PFC_Unknown) {
     PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
     return;
   } else if (Kind == PFC_Push || Kind == PFC_Pop) {
     if (Tok.isNot(tok::r_paren)) {
       PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
       return;
     }
else if (Tok.isNot(tok::comma)) {
         PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
         return;
       }
       StringRef PushOnOff = Tok.getIdentifierInfo()->getName();
       if (PushOnOff == "on")
         // Kind is set correctly
         ;
       else if (PushOnOff == "off") {
-        if (Kind == PFC_Precise)
+        switch (Kind) {
+        default:
+          break;
+        case PFC_Precise:
           Kind = PFC_NoPrecise;
-        if (Kind == PFC_Except)
+          break;
+        case PFC_Except:
           Kind = PFC_NoExcept;
+          break;
+        case PFC_Double:
+        case PFC_Extended:
+          // Reset eval mode to 'source'
+          Kind = PFC_Source;
+          break;
+        }
       } else if (PushOnOff == "push") {
         Action = Sema::PSK_Push_Set;
       } else {
         PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);
         return;
       }
       PP.Lex(Tok); // the identifier
       if (Tok.is(tok::comma)) {

clang/lib/Sema/Sema.cpp

Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
   // Initialization of data sharing attributes stack for OpenMP
   InitDataSharingAttributesStack();
 
   std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
       std::make_unique<sema::SemaPPCallbacks>();
   SemaPPCallbackHandler = Callbacks.get();
   PP.addPPCallbacks(std::move(Callbacks));
   SemaPPCallbackHandler->set(*this);
+  if (getLangOpts().getFPEvalMethod() == LangOptions::FEM_TargetDefault)
+    // Use setting from TargetInfo.
+    PP.setCurrentFPEvalMethod(ctxt.getTargetInfo().getFPEvalMethod());
+  else
+    // Set initial value of __FLT_EVAL_METHOD__ from the command line.
+    PP.setCurrentFPEvalMethod(getLangOpts().getFPEvalMethod());
 }
 
 // Anchor Sema's type info to this TU.
 void Sema::anchor() {}
 
 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
   DeclarationName DN = &Context.Idents.get(Name);
   if (IdResolver.begin(DN) == IdResolver.end())
     PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);
CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
 
   return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
 }
 
 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
 Sema::getMismatchingDeleteExpressions() const {
   return DeleteExprs;
 }
+
+Sema::FPFeaturesStateRAII::FPFeaturesStateRAII(Sema &S)
+    : S(S), OldFPFeaturesState(S.CurFPFeatures),
+      OldOverrides(S.FpPragmaStack.CurrentValue),
+      OldEvalMethod(S.PP.getCurrentFPEvalMethod()) {}
+
+Sema::FPFeaturesStateRAII::~FPFeaturesStateRAII() {
+  S.CurFPFeatures = OldFPFeaturesState;
+  S.FpPragmaStack.CurrentValue = OldOverrides;
+  S.PP.setCurrentFPEvalMethod(OldEvalMethod);
+}

clang/lib/Sema/SemaAttr.cpp

if ((Action == PSK_Push_Set || Action == PSK_Push || Action == PSK_Pop) &&
     // Push and pop can only occur at file or namespace scope, or within a
     // language linkage declaration.
     Diag(Loc, diag::err_pragma_fc_pp_scope);
     return;
   }
   switch (Value) {
   default:
     llvm_unreachable("invalid pragma float_control kind");
+  case PFC_Source:
+    PP.setCurrentFPEvalMethod(LangOptions::FEM_Source);
+    NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Source);
+    FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures);
+    break;
+  case PFC_Double:
+    PP.setCurrentFPEvalMethod(LangOptions::FEM_Double);
+    NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Double);
+    FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures);
+    break;
+  case PFC_Extended:
+    PP.setCurrentFPEvalMethod(LangOptions::FEM_Extended);
+    NewFPFeatures.setFPEvalMethodOverride(LangOptions::FEM_Extended);
+    FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures);
+    break;
   case PFC_Precise:
     NewFPFeatures.setFPPreciseEnabled(true);
     FpPragmaStack.Act(Loc, Action, StringRef(), NewFPFeatures);
     break;
   case PFC_NoPrecise:
     if (CurFPFeatures.getFPExceptionMode() == LangOptions::FPE_Strict)
       Diag(Loc, diag::err_pragma_fc_noprecise_requires_noexcept);
     else if (CurFPFeatures.getAllowFEnvAccess())

clang/lib/Sema/SemaExpr.cpp

ExprResult Sema::UsualUnaryConversions(Expr *E) {
   ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
   if (Res.isInvalid())
     return ExprError();
   E = Res.get();
 
   QualType Ty = E->getType();
   assert(!Ty.isNull() && "UsualUnaryConversions - missing type");
 
+  LangOptions::FPEvalMethodKind EvalMethod = CurFPFeatures.getFPEvalMethod();
+  if (EvalMethod != LangOptions::FEM_Source && Ty->isFloatingType()) {
+    switch (EvalMethod) {
+    default:
+      llvm_unreachable("Unrecognized float evaluation method");
+      break;
+    case LangOptions::FEM_TargetDefault:
+      // Float evaluation method not defined, use FEM_Source.
+      break;
+    case LangOptions::FEM_Double:
+      if (Context.getFloatingTypeOrder(Context.DoubleTy, Ty) > 0)
+        // Widen the expression to double.
+        return Ty->isComplexType()
+                   ? ImpCastExprToType(E,
+                                       Context.getComplexType(Context.DoubleTy),
+                                       CK_FloatingComplexCast)
+                   : ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast);
+      break;
+    case LangOptions::FEM_Extended:
+      if (Context.getFloatingTypeOrder(Context.LongDoubleTy, Ty) > 0)
+        // Widen the expression to long double.
+        return Ty->isComplexType()
+                   ? ImpCastExprToType(
+                         E, Context.getComplexType(Context.LongDoubleTy),
+                         CK_FloatingComplexCast)
+                   : ImpCastExprToType(E, Context.LongDoubleTy,
+                                       CK_FloatingCast);
+      break;
+    }
+  }
+
   // Half FP have to be promoted to float unless it is natively supported
   if (Ty->isHalfType() && !getLangOpts().NativeHalfType)
     return ImpCastExprToType(Res.get(), Context.FloatTy, CK_FloatingCast);
 
   // Try to perform integral promotions if the object has a theoretically
   // promotable type.
   if (Ty->isIntegralOrUnscopedEnumerationType()) {
     // C99 6.3.1.1p2:

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

 // RUN: %clang_cc1 -fexperimental-strict-floating-point -DEXCEPT=1 -fcxx-exceptions -triple x86_64-linux-gnu -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-NS %s
-// RUN: %clang_cc1 -fexperimental-strict-floating-point -triple x86_64-linux-gnu -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -fexperimental-strict-floating-point -triple x86_64-linux-gnu -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK-DEFAULT
 // RUN: %clang_cc1 -fexperimental-strict-floating-point -DFENV_ON=1 -triple x86_64-linux-gnu -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-FENV %s
-// RUN: %clang_cc1 -fexperimental-strict-floating-point -triple %itanium_abi_triple -O3 -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-O3 %s
+// RUN: %clang_cc1 -fexperimental-strict-floating-point -DNF128 -triple %itanium_abi_triple -O3 -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-O3 %s
+// RUN: %clang_cc1 -fexperimental-strict-floating-point -triple x86_64-linux-gnu -emit-llvm -o - %s -ffp-eval-method=source | FileCheck %s -check-prefix=CHECK-SOURCE
+// RUN: %clang_cc1 -fexperimental-strict-floating-point -triple x86_64-linux-gnu -emit-llvm -o - %s -ffp-eval-method=double | FileCheck %s -check-prefix=CHECK-DOUBLE
+// RUN: %clang_cc1 -fexperimental-strict-floating-point -triple x86_64-linux-gnu -emit-llvm -o - %s -ffp-eval-method=extended -mlong-double-80 | FileCheck %s -check-prefix=CHECK-EXTENDED
+// RUN: %clang_cc1 -fexperimental-strict-floating-point -triple i386-linux-gnu -emit-llvm -o - %s -ffp-eval-method=source | FileCheck %s -check-prefix=CHECK-SOURCE
+// RUN: %clang_cc1 -fexperimental-strict-floating-point -triple i386-linux-gnu -emit-llvm -o - %s -ffp-eval-method=double | FileCheck %s -check-prefix=CHECK-DOUBLE
+// RUN: %clang_cc1 -fexperimental-strict-floating-point -triple i386-linux-gnu -emit-llvm -o - %s -ffp-eval-method=extended -mlong-double-80 | FileCheck %s -check-prefix=CHECK-EXTENDED
+// RUN: %clang_cc1 -triple powerpc-unknown-aix -DNF128 -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK-AIX
 
 // Verify float_control(precise, off) enables fast math flags on fp operations.
 float fp_precise_1(float a, float b, float c) {
 // CHECK-O3: _Z12fp_precise_1fff
 // CHECK-O3: %[[M:.+]] = fmul fast float{{.*}}
 // CHECK-O3: fadd fast float %[[M]], %c
 #pragma float_control(precise, off)
   return a * b + c;

 #pragma float_control( except, on)
             return a * b;
 //CHECK: llvm.experimental.constrained.fmul{{.*}}fpexcept.strict
         } // end of lambda expression
   (1.0f,2.0f);
   result = x + t;
   return result;
 }
+
+float mySub(float x, float y) {
+  // CHECK: define {{.*}}float {{.*}}mySub{{.*}}
+  // CHECK-NS: fsub float
+  // CHECK-SOURCE: fsub float
+  // CHECK-DOUBLE: fpext float
+  // CHECK-DOUBLE: fpext float
+  // CHECK-DOUBLE: fsub double
+  // CHECK-DOUBLE: fptrunc double {{.*}} to float
+  // CHECK-EXTENDED: fpext float
+  // CHECK-EXTENDED: fpext float
+  // CHECK-EXTENDED: fsub double
+  // CHECK-EXTENDED: fptrunc double {{.*}} to float
+  return x - y;
+}
+
+float mySubSource(float x, float y) {
+// CHECK: define {{.*}}float {{.*}}mySubSource{{.*}}
+#pragma float_control(source)
+  return x - y;
+  // CHECK: fsub float
+}
+
+float mySubExtended(float x, float y) {
+// CHECK: define {{.*}}float {{.*}}mySubExtended{{.*}}
+#pragma float_control(extended)
+  return x - y;
+  // CHECK: fpext float
+  // CHECK: fpext float
+  // CHECK: fsub x86_fp80
+  // CHECK: fptrunc x86_fp80 {{.*}} to float
+}
+
+float mySubDouble(float x, float y) {
+// CHECK: define {{.*}}float {{.*}}mySubDouble{{.*}}
+#pragma float_control(double)
+  return x - y;
+  // CHECK: fpext float
+  // CHECK: fpext float
+  // CHECK: fsub double
+  // CHECK: fptrunc double {{.*}} to float
+}
+
+#ifndef NF128
+__float128 mySub128(__float128 x, __float128 y) {
+  // CHECK: define {{.*}}mySub128{{.*}}
+  // Expect no fpext since fp128 is already widest
+  // CHECK: load fp128
+  // CHECK-NEXT: load fp128
+  // CHECK-NEXT: fsub fp128
+  // CHECK-NEXT: ret fp128
+  return x - y;
+}
+#endif
+
+void mySubfp16(__fp16 *res, __fp16 *x, __fp16 *y) {
+  // CHECK: define {{.*}}mySubfp16{{.*}}
+  *res = *x - *y;
+  // CHECK: load half
+  // CHECK-NEXT: load half
+  // CHECK-NEXT: fpext half{{.*}}
+  // CHECK-NEXT: load half
+  // CHECK-NEXT: load half
+  // CHECK-NS: fpext half{{.*}} to float
+  // CHECK-DEFAULT: fpext half{{.*}} to float
+  // CHECK-DOUBLE: fpext half{{.*}} to double
+  // CHECK-EXTENDED: fpext half{{.*}} to x86_fp80
+  // CHECK-NEXT: fsub
+  // CHECK-NEXT: fptrunc {{.*}}to half
+  // CHECK-NS: fptrunc float {{.*}} to half
+  // CHECK-DOUBLE: fptrunc double {{.*}} to half
+  // CHECK-EXTENDED: fptrunc x86_fp80 {{.*}} to half
+}
+
+int getFEM() {
+  // CHECK: define {{.*}}getFEM{{.*}}
+  return __FLT_EVAL_METHOD__;
+  // CHECK-NS: ret {{.*}} 0
+  // CHECK-AIX: ret {{.*}} 1
+  // CHECK-SOURCE: ret {{.*}} 0
+  // CHECK-DOUBLE: ret {{.*}} 1
+  // CHECK-EXTENDED: ret {{.*}} 2
+}

clang/test/Preprocessor/init-aarch64.c

 // AARCH64-NEXT: #define __FLT16_MAX__ 6.5504e+4F16
 // AARCH64-NEXT: #define __FLT16_MIN_10_EXP__ (-4)
 // AARCH64-NEXT: #define __FLT16_MIN_EXP__ (-13)
 // AARCH64-NEXT: #define __FLT16_MIN__ 6.103515625e-5F16
 // AARCH64-NEXT: #define __FLT_DECIMAL_DIG__ 9
 // AARCH64-NEXT: #define __FLT_DENORM_MIN__ 1.40129846e-45F
 // AARCH64-NEXT: #define __FLT_DIG__ 6
 // AARCH64-NEXT: #define __FLT_EPSILON__ 1.19209290e-7F
-// AARCH64-NEXT: #define __FLT_EVAL_METHOD__ 0
 // AARCH64-NEXT: #define __FLT_HAS_DENORM__ 1
 // AARCH64-NEXT: #define __FLT_HAS_INFINITY__ 1
 // AARCH64-NEXT: #define __FLT_HAS_QUIET_NAN__ 1
 // AARCH64-NEXT: #define __FLT_MANT_DIG__ 24
 // AARCH64-NEXT: #define __FLT_MAX_10_EXP__ 38
 // AARCH64-NEXT: #define __FLT_MAX_EXP__ 128
 // AARCH64-NEXT: #define __FLT_MAX__ 3.40282347e+38F
 // AARCH64-NEXT: #define __FLT_MIN_10_EXP__ (-37)

 // AARCH64-DARWIN: #define __DBL_MAX__ 1.7976931348623157e+308
 // AARCH64-DARWIN: #define __DBL_MIN_10_EXP__ (-307)
 // AARCH64-DARWIN: #define __DBL_MIN_EXP__ (-1021)
 // AARCH64-DARWIN: #define __DBL_MIN__ 2.2250738585072014e-308
 // AARCH64-DARWIN: #define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // AARCH64-DARWIN: #define __FLT_DENORM_MIN__ 1.40129846e-45F
 // AARCH64-DARWIN: #define __FLT_DIG__ 6
 // AARCH64-DARWIN: #define __FLT_EPSILON__ 1.19209290e-7F
-// AARCH64-DARWIN: #define __FLT_EVAL_METHOD__ 0
 // AARCH64-DARWIN: #define __FLT_HAS_DENORM__ 1
 // AARCH64-DARWIN: #define __FLT_HAS_INFINITY__ 1
 // AARCH64-DARWIN: #define __FLT_HAS_QUIET_NAN__ 1
 // AARCH64-DARWIN: #define __FLT_MANT_DIG__ 24
 // AARCH64-DARWIN: #define __FLT_MAX_10_EXP__ 38
 // AARCH64-DARWIN: #define __FLT_MAX_EXP__ 128
 // AARCH64-DARWIN: #define __FLT_MAX__ 3.40282347e+38F
 // AARCH64-DARWIN: #define __FLT_MIN_10_EXP__ (-37)

 // AARCH64-MSVC: #define __DBL_MIN_EXP__ (-1021)
 // AARCH64-MSVC: #define __DBL_MIN__ 2.2250738585072014e-308
 // AARCH64-MSVC: #define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // AARCH64-MSVC: #define __FINITE_MATH_ONLY__ 0
 // AARCH64-MSVC: #define __FLT_DECIMAL_DIG__ 9
 // AARCH64-MSVC: #define __FLT_DENORM_MIN__ 1.40129846e-45F
 // AARCH64-MSVC: #define __FLT_DIG__ 6
 // AARCH64-MSVC: #define __FLT_EPSILON__ 1.19209290e-7F
-// AARCH64-MSVC: #define __FLT_EVAL_METHOD__ 0
 // AARCH64-MSVC: #define __FLT_HAS_DENORM__ 1
 // AARCH64-MSVC: #define __FLT_HAS_INFINITY__ 1
 // AARCH64-MSVC: #define __FLT_HAS_QUIET_NAN__ 1
 // AARCH64-MSVC: #define __FLT_MANT_DIG__ 24
 // AARCH64-MSVC: #define __FLT_MAX_10_EXP__ 38
 // AARCH64-MSVC: #define __FLT_MAX_EXP__ 128
 // AARCH64-MSVC: #define __FLT_MAX__ 3.40282347e+38F
 // AARCH64-MSVC: #define __FLT_MIN_10_EXP__ (-37)

clang/test/Preprocessor/init-arm.c

 // ARM:#define __DBL_MAX__ 1.7976931348623157e+308
 // ARM:#define __DBL_MIN_10_EXP__ (-307)
 // ARM:#define __DBL_MIN_EXP__ (-1021)
 // ARM:#define __DBL_MIN__ 2.2250738585072014e-308
 // ARM:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // ARM:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // ARM:#define __FLT_DIG__ 6
 // ARM:#define __FLT_EPSILON__ 1.19209290e-7F
-// ARM:#define __FLT_EVAL_METHOD__ 0
 // ARM:#define __FLT_HAS_DENORM__ 1
 // ARM:#define __FLT_HAS_INFINITY__ 1
 // ARM:#define __FLT_HAS_QUIET_NAN__ 1
 // ARM:#define __FLT_MANT_DIG__ 24
 // ARM:#define __FLT_MAX_10_EXP__ 38
 // ARM:#define __FLT_MAX_EXP__ 128
 // ARM:#define __FLT_MAX__ 3.40282347e+38F
 // ARM:#define __FLT_MIN_10_EXP__ (-37)

 // ARM-BE:#define __DBL_MAX__ 1.7976931348623157e+308
 // ARM-BE:#define __DBL_MIN_10_EXP__ (-307)
 // ARM-BE:#define __DBL_MIN_EXP__ (-1021)
 // ARM-BE:#define __DBL_MIN__ 2.2250738585072014e-308
 // ARM-BE:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // ARM-BE:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // ARM-BE:#define __FLT_DIG__ 6
 // ARM-BE:#define __FLT_EPSILON__ 1.19209290e-7F
-// ARM-BE:#define __FLT_EVAL_METHOD__ 0
 // ARM-BE:#define __FLT_HAS_DENORM__ 1
 // ARM-BE:#define __FLT_HAS_INFINITY__ 1
 // ARM-BE:#define __FLT_HAS_QUIET_NAN__ 1
 // ARM-BE:#define __FLT_MANT_DIG__ 24
 // ARM-BE:#define __FLT_MAX_10_EXP__ 38
 // ARM-BE:#define __FLT_MAX_EXP__ 128
 // ARM-BE:#define __FLT_MAX__ 3.40282347e+38F
 // ARM-BE:#define __FLT_MIN_10_EXP__ (-37)

 // ARMEABISOFTFP:#define __DBL_MAX__ 1.7976931348623157e+308
 // ARMEABISOFTFP:#define __DBL_MIN_10_EXP__ (-307)
 // ARMEABISOFTFP:#define __DBL_MIN_EXP__ (-1021)
 // ARMEABISOFTFP:#define __DBL_MIN__ 2.2250738585072014e-308
 // ARMEABISOFTFP:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // ARMEABISOFTFP:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // ARMEABISOFTFP:#define __FLT_DIG__ 6
 // ARMEABISOFTFP:#define __FLT_EPSILON__ 1.19209290e-7F
-// ARMEABISOFTFP:#define __FLT_EVAL_METHOD__ 0
 // ARMEABISOFTFP:#define __FLT_HAS_DENORM__ 1
 // ARMEABISOFTFP:#define __FLT_HAS_INFINITY__ 1
 // ARMEABISOFTFP:#define __FLT_HAS_QUIET_NAN__ 1
 // ARMEABISOFTFP:#define __FLT_MANT_DIG__ 24
 // ARMEABISOFTFP:#define __FLT_MAX_10_EXP__ 38
 // ARMEABISOFTFP:#define __FLT_MAX_EXP__ 128
 // ARMEABISOFTFP:#define __FLT_MAX__ 3.40282347e+38F
 // ARMEABISOFTFP:#define __FLT_MIN_10_EXP__ (-37)

 // ARMEABIHARDFP:#define __DBL_MAX__ 1.7976931348623157e+308
 // ARMEABIHARDFP:#define __DBL_MIN_10_EXP__ (-307)
 // ARMEABIHARDFP:#define __DBL_MIN_EXP__ (-1021)
 // ARMEABIHARDFP:#define __DBL_MIN__ 2.2250738585072014e-308
 // ARMEABIHARDFP:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // ARMEABIHARDFP:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // ARMEABIHARDFP:#define __FLT_DIG__ 6
 // ARMEABIHARDFP:#define __FLT_EPSILON__ 1.19209290e-7F
-// ARMEABIHARDFP:#define __FLT_EVAL_METHOD__ 0
 // ARMEABIHARDFP:#define __FLT_HAS_DENORM__ 1
 // ARMEABIHARDFP:#define __FLT_HAS_INFINITY__ 1
 // ARMEABIHARDFP:#define __FLT_HAS_QUIET_NAN__ 1
 // ARMEABIHARDFP:#define __FLT_MANT_DIG__ 24
 // ARMEABIHARDFP:#define __FLT_MAX_10_EXP__ 38
 // ARMEABIHARDFP:#define __FLT_MAX_EXP__ 128
 // ARMEABIHARDFP:#define __FLT_MAX__ 3.40282347e+38F
 // ARMEABIHARDFP:#define __FLT_MIN_10_EXP__ (-37)

 // ARM-NETBSD:#define __DBL_MAX__ 1.7976931348623157e+308
 // ARM-NETBSD:#define __DBL_MIN_10_EXP__ (-307)
 // ARM-NETBSD:#define __DBL_MIN_EXP__ (-1021)
 // ARM-NETBSD:#define __DBL_MIN__ 2.2250738585072014e-308
 // ARM-NETBSD:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // ARM-NETBSD:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // ARM-NETBSD:#define __FLT_DIG__ 6
 // ARM-NETBSD:#define __FLT_EPSILON__ 1.19209290e-7F
-// ARM-NETBSD:#define __FLT_EVAL_METHOD__ 0
 // ARM-NETBSD:#define __FLT_HAS_DENORM__ 1
 // ARM-NETBSD:#define __FLT_HAS_INFINITY__ 1
 // ARM-NETBSD:#define __FLT_HAS_QUIET_NAN__ 1
 // ARM-NETBSD:#define __FLT_MANT_DIG__ 24
 // ARM-NETBSD:#define __FLT_MAX_10_EXP__ 38
 // ARM-NETBSD:#define __FLT_MAX_EXP__ 128
 // ARM-NETBSD:#define __FLT_MAX__ 3.40282347e+38F
 // ARM-NETBSD:#define __FLT_MIN_10_EXP__ (-37)

clang/test/Preprocessor/init-mips.c

 // MIPS32BE:#define __DBL_MAX__ 1.7976931348623157e+308
 // MIPS32BE:#define __DBL_MIN_10_EXP__ (-307)
 // MIPS32BE:#define __DBL_MIN_EXP__ (-1021)
 // MIPS32BE:#define __DBL_MIN__ 2.2250738585072014e-308
 // MIPS32BE:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // MIPS32BE:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // MIPS32BE:#define __FLT_DIG__ 6
 // MIPS32BE:#define __FLT_EPSILON__ 1.19209290e-7F
-// MIPS32BE:#define __FLT_EVAL_METHOD__ 0
 // MIPS32BE:#define __FLT_HAS_DENORM__ 1
 // MIPS32BE:#define __FLT_HAS_INFINITY__ 1
 // MIPS32BE:#define __FLT_HAS_QUIET_NAN__ 1
 // MIPS32BE:#define __FLT_MANT_DIG__ 24
 // MIPS32BE:#define __FLT_MAX_10_EXP__ 38
 // MIPS32BE:#define __FLT_MAX_EXP__ 128
 // MIPS32BE:#define __FLT_MAX__ 3.40282347e+38F
 // MIPS32BE:#define __FLT_MIN_10_EXP__ (-37)

 // MIPS32EL:#define __DBL_MAX__ 1.7976931348623157e+308
 // MIPS32EL:#define __DBL_MIN_10_EXP__ (-307)
 // MIPS32EL:#define __DBL_MIN_EXP__ (-1021)
 // MIPS32EL:#define __DBL_MIN__ 2.2250738585072014e-308
 // MIPS32EL:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // MIPS32EL:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // MIPS32EL:#define __FLT_DIG__ 6
 // MIPS32EL:#define __FLT_EPSILON__ 1.19209290e-7F
-// MIPS32EL:#define __FLT_EVAL_METHOD__ 0
 // MIPS32EL:#define __FLT_HAS_DENORM__ 1
 // MIPS32EL:#define __FLT_HAS_INFINITY__ 1
 // MIPS32EL:#define __FLT_HAS_QUIET_NAN__ 1
 // MIPS32EL:#define __FLT_MANT_DIG__ 24
 // MIPS32EL:#define __FLT_MAX_10_EXP__ 38
 // MIPS32EL:#define __FLT_MAX_EXP__ 128
 // MIPS32EL:#define __FLT_MAX__ 3.40282347e+38F
 // MIPS32EL:#define __FLT_MIN_10_EXP__ (-37)

 // MIPSN32BE: #define __DBL_MIN_10_EXP__ (-307)
 // MIPSN32BE: #define __DBL_MIN_EXP__ (-1021)
 // MIPSN32BE: #define __DBL_MIN__ 2.2250738585072014e-308
 // MIPSN32BE: #define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // MIPSN32BE: #define __FINITE_MATH_ONLY__ 0
 // MIPSN32BE: #define __FLT_DENORM_MIN__ 1.40129846e-45F
 // MIPSN32BE: #define __FLT_DIG__ 6
 // MIPSN32BE: #define __FLT_EPSILON__ 1.19209290e-7F
-// MIPSN32BE: #define __FLT_EVAL_METHOD__ 0
 // MIPSN32BE: #define __FLT_HAS_DENORM__ 1
 // MIPSN32BE: #define __FLT_HAS_INFINITY__ 1
 // MIPSN32BE: #define __FLT_HAS_QUIET_NAN__ 1
 // MIPSN32BE: #define __FLT_MANT_DIG__ 24
 // MIPSN32BE: #define __FLT_MAX_10_EXP__ 38
 // MIPSN32BE: #define __FLT_MAX_EXP__ 128
 // MIPSN32BE: #define __FLT_MAX__ 3.40282347e+38F
 // MIPSN32BE: #define __FLT_MIN_10_EXP__ (-37)

 // MIPSN32EL: #define __DBL_MIN_10_EXP__ (-307)
 // MIPSN32EL: #define __DBL_MIN_EXP__ (-1021)
 // MIPSN32EL: #define __DBL_MIN__ 2.2250738585072014e-308
 // MIPSN32EL: #define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // MIPSN32EL: #define __FINITE_MATH_ONLY__ 0
 // MIPSN32EL: #define __FLT_DENORM_MIN__ 1.40129846e-45F
 // MIPSN32EL: #define __FLT_DIG__ 6
 // MIPSN32EL: #define __FLT_EPSILON__ 1.19209290e-7F
-// MIPSN32EL: #define __FLT_EVAL_METHOD__ 0
 // MIPSN32EL: #define __FLT_HAS_DENORM__ 1
 // MIPSN32EL: #define __FLT_HAS_INFINITY__ 1
 // MIPSN32EL: #define __FLT_HAS_QUIET_NAN__ 1
 // MIPSN32EL: #define __FLT_MANT_DIG__ 24
 // MIPSN32EL: #define __FLT_MAX_10_EXP__ 38
 // MIPSN32EL: #define __FLT_MAX_EXP__ 128
 // MIPSN32EL: #define __FLT_MAX__ 3.40282347e+38F
 // MIPSN32EL: #define __FLT_MIN_10_EXP__ (-37)

 // MIPS64BE:#define __DBL_MAX__ 1.7976931348623157e+308
 // MIPS64BE:#define __DBL_MIN_10_EXP__ (-307)
 // MIPS64BE:#define __DBL_MIN_EXP__ (-1021)
 // MIPS64BE:#define __DBL_MIN__ 2.2250738585072014e-308
 // MIPS64BE:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // MIPS64BE:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // MIPS64BE:#define __FLT_DIG__ 6
 // MIPS64BE:#define __FLT_EPSILON__ 1.19209290e-7F
-// MIPS64BE:#define __FLT_EVAL_METHOD__ 0
 // MIPS64BE:#define __FLT_HAS_DENORM__ 1
 // MIPS64BE:#define __FLT_HAS_INFINITY__ 1
 // MIPS64BE:#define __FLT_HAS_QUIET_NAN__ 1
 // MIPS64BE:#define __FLT_MANT_DIG__ 24
 // MIPS64BE:#define __FLT_MAX_10_EXP__ 38
 // MIPS64BE:#define __FLT_MAX_EXP__ 128
 // MIPS64BE:#define __FLT_MAX__ 3.40282347e+38F
 // MIPS64BE:#define __FLT_MIN_10_EXP__ (-37)

 // MIPS64EL:#define __DBL_MAX__ 1.7976931348623157e+308
 // MIPS64EL:#define __DBL_MIN_10_EXP__ (-307)
 // MIPS64EL:#define __DBL_MIN_EXP__ (-1021)
 // MIPS64EL:#define __DBL_MIN__ 2.2250738585072014e-308
 // MIPS64EL:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // MIPS64EL:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // MIPS64EL:#define __FLT_DIG__ 6
 // MIPS64EL:#define __FLT_EPSILON__ 1.19209290e-7F
-// MIPS64EL:#define __FLT_EVAL_METHOD__ 0
 // MIPS64EL:#define __FLT_HAS_DENORM__ 1
 // MIPS64EL:#define __FLT_HAS_INFINITY__ 1
 // MIPS64EL:#define __FLT_HAS_QUIET_NAN__ 1
 // MIPS64EL:#define __FLT_MANT_DIG__ 24
 // MIPS64EL:#define __FLT_MAX_10_EXP__ 38
 // MIPS64EL:#define __FLT_MAX_EXP__ 128
 // MIPS64EL:#define __FLT_MAX__ 3.40282347e+38F
 // MIPS64EL:#define __FLT_MIN_10_EXP__ (-37)

clang/test/Preprocessor/init-ppc.c

 // PPC603E:#define __DBL_MAX__ 1.7976931348623157e+308
 // PPC603E:#define __DBL_MIN_10_EXP__ (-307)
 // PPC603E:#define __DBL_MIN_EXP__ (-1021)
 // PPC603E:#define __DBL_MIN__ 2.2250738585072014e-308
 // PPC603E:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // PPC603E:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // PPC603E:#define __FLT_DIG__ 6
 // PPC603E:#define __FLT_EPSILON__ 1.19209290e-7F
-// PPC603E:#define __FLT_EVAL_METHOD__ 0
 // PPC603E:#define __FLT_HAS_DENORM__ 1
 // PPC603E:#define __FLT_HAS_INFINITY__ 1
 // PPC603E:#define __FLT_HAS_QUIET_NAN__ 1
 // PPC603E:#define __FLT_MANT_DIG__ 24
 // PPC603E:#define __FLT_MAX_10_EXP__ 38
 // PPC603E:#define __FLT_MAX_EXP__ 128
 // PPC603E:#define __FLT_MAX__ 3.40282347e+38F
 // PPC603E:#define __FLT_MIN_10_EXP__ (-37)

 // PPC:#define __DBL_MAX__ 1.7976931348623157e+308
 // PPC:#define __DBL_MIN_10_EXP__ (-307)
 // PPC:#define __DBL_MIN_EXP__ (-1021)
 // PPC:#define __DBL_MIN__ 2.2250738585072014e-308
 // PPC:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // PPC:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // PPC:#define __FLT_DIG__ 6
 // PPC:#define __FLT_EPSILON__ 1.19209290e-7F
-// PPC:#define __FLT_EVAL_METHOD__ 0
 // PPC:#define __FLT_HAS_DENORM__ 1
 // PPC:#define __FLT_HAS_INFINITY__ 1
 // PPC:#define __FLT_HAS_QUIET_NAN__ 1
 // PPC:#define __FLT_MANT_DIG__ 24
 // PPC:#define __FLT_MAX_10_EXP__ 38
 // PPC:#define __FLT_MAX_EXP__ 128
 // PPC:#define __FLT_MAX__ 3.40282347e+38F
 // PPC:#define __FLT_MIN_10_EXP__ (-37)

 // PPC-AIX:#define __DBL_MAX__ 1.7976931348623157e+308
 // PPC-AIX:#define __DBL_MIN_10_EXP__ (-307)
 // PPC-AIX:#define __DBL_MIN_EXP__ (-1021)
 // PPC-AIX:#define __DBL_MIN__ 2.2250738585072014e-308
 // PPC-AIX:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // PPC-AIX:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // PPC-AIX:#define __FLT_DIG__ 6
 // PPC-AIX:#define __FLT_EPSILON__ 1.19209290e-7F
-// PPC-AIX:#define __FLT_EVAL_METHOD__ 1
 // PPC-AIX:#define __FLT_HAS_DENORM__ 1
 // PPC-AIX:#define __FLT_HAS_INFINITY__ 1
 // PPC-AIX:#define __FLT_HAS_QUIET_NAN__ 1
 // PPC-AIX:#define __FLT_MANT_DIG__ 24
 // PPC-AIX:#define __FLT_MAX_10_EXP__ 38
 // PPC-AIX:#define __FLT_MAX_EXP__ 128
 // PPC-AIX:#define __FLT_MAX__ 3.40282347e+38F
 // PPC-AIX:#define __FLT_MIN_10_EXP__ (-37)

 // PPC-LINUX:#define __DBL_MAX__ 1.7976931348623157e+308
 // PPC-LINUX:#define __DBL_MIN_10_EXP__ (-307)
 // PPC-LINUX:#define __DBL_MIN_EXP__ (-1021)
 // PPC-LINUX:#define __DBL_MIN__ 2.2250738585072014e-308
 // PPC-LINUX:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // PPC-LINUX:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // PPC-LINUX:#define __FLT_DIG__ 6
 // PPC-LINUX:#define __FLT_EPSILON__ 1.19209290e-7F
-// PPC-LINUX:#define __FLT_EVAL_METHOD__ 0
 // PPC-LINUX:#define __FLT_HAS_DENORM__ 1
 // PPC-LINUX:#define __FLT_HAS_INFINITY__ 1
 // PPC-LINUX:#define __FLT_HAS_QUIET_NAN__ 1
 // PPC-LINUX:#define __FLT_MANT_DIG__ 24
 // PPC-LINUX:#define __FLT_MAX_10_EXP__ 38
 // PPC-LINUX:#define __FLT_MAX_EXP__ 128
 // PPC-LINUX:#define __FLT_MAX__ 3.40282347e+38F
 // PPC-LINUX:#define __FLT_MIN_10_EXP__ (-37)

 // PPC-DARWIN:#define __DBL_MAX__ 1.7976931348623157e+308
 // PPC-DARWIN:#define __DBL_MIN_10_EXP__ (-307)
 // PPC-DARWIN:#define __DBL_MIN_EXP__ (-1021)
 // PPC-DARWIN:#define __DBL_MIN__ 2.2250738585072014e-308
 // PPC-DARWIN:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // PPC-DARWIN:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // PPC-DARWIN:#define __FLT_DIG__ 6
 // PPC-DARWIN:#define __FLT_EPSILON__ 1.19209290e-7F
-// PPC-DARWIN:#define __FLT_EVAL_METHOD__ 0
 // PPC-DARWIN:#define __FLT_HAS_DENORM__ 1
 // PPC-DARWIN:#define __FLT_HAS_INFINITY__ 1
 // PPC-DARWIN:#define __FLT_HAS_QUIET_NAN__ 1
 // PPC-DARWIN:#define __FLT_MANT_DIG__ 24
 // PPC-DARWIN:#define __FLT_MAX_10_EXP__ 38
 // PPC-DARWIN:#define __FLT_MAX_EXP__ 128
 // PPC-DARWIN:#define __FLT_MAX__ 3.40282347e+38F
 // PPC-DARWIN:#define __FLT_MIN_10_EXP__ (-37)

clang/test/Preprocessor/init-ppc64.c

 // PPC64:#define __DBL_MAX__ 1.7976931348623157e+308
 // PPC64:#define __DBL_MIN_10_EXP__ (-307)
 // PPC64:#define __DBL_MIN_EXP__ (-1021)
 // PPC64:#define __DBL_MIN__ 2.2250738585072014e-308
 // PPC64:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // PPC64:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // PPC64:#define __FLT_DIG__ 6
 // PPC64:#define __FLT_EPSILON__ 1.19209290e-7F
-// PPC64:#define __FLT_EVAL_METHOD__ 0
 // PPC64:#define __FLT_HAS_DENORM__ 1
 // PPC64:#define __FLT_HAS_INFINITY__ 1
 // PPC64:#define __FLT_HAS_QUIET_NAN__ 1
 // PPC64:#define __FLT_MANT_DIG__ 24
 // PPC64:#define __FLT_MAX_10_EXP__ 38
 // PPC64:#define __FLT_MAX_EXP__ 128
 // PPC64:#define __FLT_MAX__ 3.40282347e+38F
 // PPC64:#define __FLT_MIN_10_EXP__ (-37)

 // PPC64LE:#define __DBL_MAX__ 1.7976931348623157e+308
 // PPC64LE:#define __DBL_MIN_10_EXP__ (-307)
 // PPC64LE:#define __DBL_MIN_EXP__ (-1021)
 // PPC64LE:#define __DBL_MIN__ 2.2250738585072014e-308
 // PPC64LE:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // PPC64LE:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // PPC64LE:#define __FLT_DIG__ 6
 // PPC64LE:#define __FLT_EPSILON__ 1.19209290e-7F
-// PPC64LE:#define __FLT_EVAL_METHOD__ 0
 // PPC64LE:#define __FLT_HAS_DENORM__ 1
 // PPC64LE:#define __FLT_HAS_INFINITY__ 1
 // PPC64LE:#define __FLT_HAS_QUIET_NAN__ 1
 // PPC64LE:#define __FLT_MANT_DIG__ 24
 // PPC64LE:#define __FLT_MAX_10_EXP__ 38
 // PPC64LE:#define __FLT_MAX_EXP__ 128
 // PPC64LE:#define __FLT_MAX__ 3.40282347e+38F
 // PPC64LE:#define __FLT_MIN_10_EXP__ (-37)

 // PPC64-AIX:#define __DBL_MAX__ 1.7976931348623157e+308
 // PPC64-AIX:#define __DBL_MIN_10_EXP__ (-307)
 // PPC64-AIX:#define __DBL_MIN_EXP__ (-1021)
 // PPC64-AIX:#define __DBL_MIN__ 2.2250738585072014e-308
 // PPC64-AIX:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // PPC64-AIX:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // PPC64-AIX:#define __FLT_DIG__ 6
 // PPC64-AIX:#define __FLT_EPSILON__ 1.19209290e-7F
-// PPC64-AIX:#define __FLT_EVAL_METHOD__ 1
 // PPC64-AIX:#define __FLT_HAS_DENORM__ 1
 // PPC64-AIX:#define __FLT_HAS_INFINITY__ 1
 // PPC64-AIX:#define __FLT_HAS_QUIET_NAN__ 1
 // PPC64-AIX:#define __FLT_MANT_DIG__ 24
 // PPC64-AIX:#define __FLT_MAX_10_EXP__ 38
 // PPC64-AIX:#define __FLT_MAX_EXP__ 128
 // PPC64-AIX:#define __FLT_MAX__ 3.40282347e+38F
 // PPC64-AIX:#define __FLT_MIN_10_EXP__ (-37)

 // PPC64-LINUX:#define __DBL_MAX__ 1.7976931348623157e+308
 // PPC64-LINUX:#define __DBL_MIN_10_EXP__ (-307)
 // PPC64-LINUX:#define __DBL_MIN_EXP__ (-1021)
 // PPC64-LINUX:#define __DBL_MIN__ 2.2250738585072014e-308
 // PPC64-LINUX:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // PPC64-LINUX:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // PPC64-LINUX:#define __FLT_DIG__ 6
 // PPC64-LINUX:#define __FLT_EPSILON__ 1.19209290e-7F
-// PPC64-LINUX:#define __FLT_EVAL_METHOD__ 0
 // PPC64-LINUX:#define __FLT_HAS_DENORM__ 1
 // PPC64-LINUX:#define __FLT_HAS_INFINITY__ 1
 // PPC64-LINUX:#define __FLT_HAS_QUIET_NAN__ 1
 // PPC64-LINUX:#define __FLT_MANT_DIG__ 24
 // PPC64-LINUX:#define __FLT_MAX_10_EXP__ 38
 // PPC64-LINUX:#define __FLT_MAX_EXP__ 128
 // PPC64-LINUX:#define __FLT_MAX__ 3.40282347e+38F
 // PPC64-LINUX:#define __FLT_MIN_10_EXP__ (-37)

clang/test/Preprocessor/init-s390x.c

 // S390X:#define __DBL_MAX__ 1.7976931348623157e+308
 // S390X:#define __DBL_MIN_10_EXP__ (-307)
 // S390X:#define __DBL_MIN_EXP__ (-1021)
 // S390X:#define __DBL_MIN__ 2.2250738585072014e-308
 // S390X:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // S390X:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // S390X:#define __FLT_DIG__ 6
 // S390X:#define __FLT_EPSILON__ 1.19209290e-7F
-// S390X:#define __FLT_EVAL_METHOD__ 0
 // S390X:#define __FLT_HAS_DENORM__ 1
 // S390X:#define __FLT_HAS_INFINITY__ 1
 // S390X:#define __FLT_HAS_QUIET_NAN__ 1
 // S390X:#define __FLT_MANT_DIG__ 24
 // S390X:#define __FLT_MAX_10_EXP__ 38
 // S390X:#define __FLT_MAX_EXP__ 128
 // S390X:#define __FLT_MAX__ 3.40282347e+38F
 // S390X:#define __FLT_MIN_10_EXP__ (-37)

clang/test/Preprocessor/init-v7k-compat.c

 // CHECK: #define __DBL_MAX__ 1.7976931348623157e+308
 // CHECK: #define __DBL_MIN_10_EXP__ (-307)
 // CHECK: #define __DBL_MIN_EXP__ (-1021)
 // CHECK: #define __DBL_MIN__ 2.2250738585072014e-308
 // CHECK: #define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // CHECK: #define __FLT_DENORM_MIN__ 1.40129846e-45F
 // CHECK: #define __FLT_DIG__ 6
 // CHECK: #define __FLT_EPSILON__ 1.19209290e-7F
-// CHECK: #define __FLT_EVAL_METHOD__ 0
 // CHECK: #define __FLT_HAS_DENORM__ 1
 // CHECK: #define __FLT_HAS_INFINITY__ 1
 // CHECK: #define __FLT_HAS_QUIET_NAN__ 1
 // CHECK: #define __FLT_MANT_DIG__ 24
 // CHECK: #define __FLT_MAX_10_EXP__ 38
 // CHECK: #define __FLT_MAX_EXP__ 128
 // CHECK: #define __FLT_MAX__ 3.40282347e+38F
 // CHECK: #define __FLT_MIN_10_EXP__ (-37)

clang/test/Preprocessor/init-x86.c

 // I386:#define __DBL_MAX__ 1.7976931348623157e+308
 // I386:#define __DBL_MIN_10_EXP__ (-307)
 // I386:#define __DBL_MIN_EXP__ (-1021)
 // I386:#define __DBL_MIN__ 2.2250738585072014e-308
 // I386:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // I386:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // I386:#define __FLT_DIG__ 6
 // I386:#define __FLT_EPSILON__ 1.19209290e-7F
-// I386:#define __FLT_EVAL_METHOD__ 2
 // I386:#define __FLT_HAS_DENORM__ 1
 // I386:#define __FLT_HAS_INFINITY__ 1
 // I386:#define __FLT_HAS_QUIET_NAN__ 1
 // I386:#define __FLT_MANT_DIG__ 24
 // I386:#define __FLT_MAX_10_EXP__ 38
 // I386:#define __FLT_MAX_EXP__ 128
 // I386:#define __FLT_MAX__ 3.40282347e+38F
 // I386:#define __FLT_MIN_10_EXP__ (-37)

 // I386-LINUX:#define __DBL_MAX__ 1.7976931348623157e+308
 // I386-LINUX:#define __DBL_MIN_10_EXP__ (-307)
 // I386-LINUX:#define __DBL_MIN_EXP__ (-1021)
 // I386-LINUX:#define __DBL_MIN__ 2.2250738585072014e-308
 // I386-LINUX:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // I386-LINUX:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // I386-LINUX:#define __FLT_DIG__ 6
 // I386-LINUX:#define __FLT_EPSILON__ 1.19209290e-7F
-// I386-LINUX:#define __FLT_EVAL_METHOD__ 0
 // I386-LINUX:#define __FLT_HAS_DENORM__ 1
 // I386-LINUX:#define __FLT_HAS_INFINITY__ 1
 // I386-LINUX:#define __FLT_HAS_QUIET_NAN__ 1
 // I386-LINUX:#define __FLT_MANT_DIG__ 24
 // I386-LINUX:#define __FLT_MAX_10_EXP__ 38
 // I386-LINUX:#define __FLT_MAX_EXP__ 128
 // I386-LINUX:#define __FLT_MAX__ 3.40282347e+38F
 // I386-LINUX:#define __FLT_MIN_10_EXP__ (-37)

 // I386-NETBSD:#define __DBL_MAX__ 1.7976931348623157e+308
 // I386-NETBSD:#define __DBL_MIN_10_EXP__ (-307)
 // I386-NETBSD:#define __DBL_MIN_EXP__ (-1021)
 // I386-NETBSD:#define __DBL_MIN__ 2.2250738585072014e-308
 // I386-NETBSD:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // I386-NETBSD:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // I386-NETBSD:#define __FLT_DIG__ 6
 // I386-NETBSD:#define __FLT_EPSILON__ 1.19209290e-7F
-// I386-NETBSD:#define __FLT_EVAL_METHOD__ 2
 // I386-NETBSD:#define __FLT_HAS_DENORM__ 1
 // I386-NETBSD:#define __FLT_HAS_INFINITY__ 1
 // I386-NETBSD:#define __FLT_HAS_QUIET_NAN__ 1
 // I386-NETBSD:#define __FLT_MANT_DIG__ 24
 // I386-NETBSD:#define __FLT_MAX_10_EXP__ 38
 // I386-NETBSD:#define __FLT_MAX_EXP__ 128
 // I386-NETBSD:#define __FLT_MAX__ 3.40282347e+38F
 // I386-NETBSD:#define __FLT_MIN_10_EXP__ (-37)

 // I386-NETBSD:#define __WCHAR_TYPE__ int
 // I386-NETBSD:#define __WCHAR_WIDTH__ 32
 // I386-NETBSD:#define __WINT_TYPE__ int
 // I386-NETBSD:#define __WINT_WIDTH__ 32
 // I386-NETBSD:#define __i386 1
 // I386-NETBSD:#define __i386__ 1
 // I386-NETBSD:#define i386 1
 
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=i386-netbsd -target-feature +sse2 < /dev/null | FileCheck -match-full-lines -check-prefix I386-NETBSD-SSE %s
-// I386-NETBSD-SSE:#define __FLT_EVAL_METHOD__ 0
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=i386-netbsd6  < /dev/null | FileCheck -match-full-lines -check-prefix I386-NETBSD6 %s
-// I386-NETBSD6:#define __FLT_EVAL_METHOD__ 1
-// RUN: %clang_cc1 -E -dM -ffreestanding -triple=i386-netbsd6 -target-feature +sse2 < /dev/null | FileCheck -match-full-lines -check-prefix I386-NETBSD6-SSE %s
-// I386-NETBSD6-SSE:#define __FLT_EVAL_METHOD__ 1
 
 // RUN: %clang_cc1 -E -dM -triple=i686-pc-mingw32 < /dev/null | FileCheck -match-full-lines -check-prefix I386-DECLSPEC %s
 // RUN: %clang_cc1 -E -dM -fms-extensions -triple=i686-pc-mingw32 < /dev/null | FileCheck -match-full-lines -check-prefix I386-DECLSPEC %s
 // RUN: %clang_cc1 -E -dM -triple=i686-unknown-cygwin < /dev/null | FileCheck -match-full-lines -check-prefix I386-DECLSPEC %s
 // RUN: %clang_cc1 -E -dM -fms-extensions -triple=i686-unknown-cygwin < /dev/null | FileCheck -match-full-lines -check-prefix I386-DECLSPEC %s
 // I386-DECLSPEC: #define __declspec{{.*}}
 
 //

 // X86_64:#define __DBL_MAX__ 1.7976931348623157e+308
 // X86_64:#define __DBL_MIN_10_EXP__ (-307)
 // X86_64:#define __DBL_MIN_EXP__ (-1021)
 // X86_64:#define __DBL_MIN__ 2.2250738585072014e-308
 // X86_64:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // X86_64:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // X86_64:#define __FLT_DIG__ 6
 // X86_64:#define __FLT_EPSILON__ 1.19209290e-7F
-// X86_64:#define __FLT_EVAL_METHOD__ 0
 // X86_64:#define __FLT_HAS_DENORM__ 1
 // X86_64:#define __FLT_HAS_INFINITY__ 1
 // X86_64:#define __FLT_HAS_QUIET_NAN__ 1
 // X86_64:#define __FLT_MANT_DIG__ 24
 // X86_64:#define __FLT_MAX_10_EXP__ 38
 // X86_64:#define __FLT_MAX_EXP__ 128
 // X86_64:#define __FLT_MAX__ 3.40282347e+38F
 // X86_64:#define __FLT_MIN_10_EXP__ (-37)

 // X32:#define __DBL_MAX__ 1.7976931348623157e+308
 // X32:#define __DBL_MIN_10_EXP__ (-307)
 // X32:#define __DBL_MIN_EXP__ (-1021)
 // X32:#define __DBL_MIN__ 2.2250738585072014e-308
 // X32:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // X32:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // X32:#define __FLT_DIG__ 6
 // X32:#define __FLT_EPSILON__ 1.19209290e-7F
-// X32:#define __FLT_EVAL_METHOD__ 0
 // X32:#define __FLT_HAS_DENORM__ 1
 // X32:#define __FLT_HAS_INFINITY__ 1
 // X32:#define __FLT_HAS_QUIET_NAN__ 1
 // X32:#define __FLT_MANT_DIG__ 24
 // X32:#define __FLT_MAX_10_EXP__ 38
 // X32:#define __FLT_MAX_EXP__ 128
 // X32:#define __FLT_MAX__ 3.40282347e+38F
 // X32:#define __FLT_MIN_10_EXP__ (-37)

 // X86_64-CLOUDABI:#define __DBL_MIN__ 2.2250738585072014e-308
 // X86_64-CLOUDABI:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // X86_64-CLOUDABI:#define __ELF__ 1
 // X86_64-CLOUDABI:#define __FINITE_MATH_ONLY__ 0
 // X86_64-CLOUDABI:#define __FLT_DECIMAL_DIG__ 9
 // X86_64-CLOUDABI:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // X86_64-CLOUDABI:#define __FLT_DIG__ 6
 // X86_64-CLOUDABI:#define __FLT_EPSILON__ 1.19209290e-7F
-// X86_64-CLOUDABI:#define __FLT_EVAL_METHOD__ 0
 // X86_64-CLOUDABI:#define __FLT_HAS_DENORM__ 1
 // X86_64-CLOUDABI:#define __FLT_HAS_INFINITY__ 1
 // X86_64-CLOUDABI:#define __FLT_HAS_QUIET_NAN__ 1
 // X86_64-CLOUDABI:#define __FLT_MANT_DIG__ 24
 // X86_64-CLOUDABI:#define __FLT_MAX_10_EXP__ 38
 // X86_64-CLOUDABI:#define __FLT_MAX_EXP__ 128
 // X86_64-CLOUDABI:#define __FLT_MAX__ 3.40282347e+38F
 // X86_64-CLOUDABI:#define __FLT_MIN_10_EXP__ (-37)

 // X86_64-LINUX:#define __DBL_MAX__ 1.7976931348623157e+308
 // X86_64-LINUX:#define __DBL_MIN_10_EXP__ (-307)
 // X86_64-LINUX:#define __DBL_MIN_EXP__ (-1021)
 // X86_64-LINUX:#define __DBL_MIN__ 2.2250738585072014e-308
 // X86_64-LINUX:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // X86_64-LINUX:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // X86_64-LINUX:#define __FLT_DIG__ 6
 // X86_64-LINUX:#define __FLT_EPSILON__ 1.19209290e-7F
-// X86_64-LINUX:#define __FLT_EVAL_METHOD__ 0
 // X86_64-LINUX:#define __FLT_HAS_DENORM__ 1
 // X86_64-LINUX:#define __FLT_HAS_INFINITY__ 1
 // X86_64-LINUX:#define __FLT_HAS_QUIET_NAN__ 1
 // X86_64-LINUX:#define __FLT_MANT_DIG__ 24
 // X86_64-LINUX:#define __FLT_MAX_10_EXP__ 38
 // X86_64-LINUX:#define __FLT_MAX_EXP__ 128
 // X86_64-LINUX:#define __FLT_MAX__ 3.40282347e+38F
 // X86_64-LINUX:#define __FLT_MIN_10_EXP__ (-37)

 // X86_64-NETBSD:#define __DBL_MAX__ 1.7976931348623157e+308
 // X86_64-NETBSD:#define __DBL_MIN_10_EXP__ (-307)
 // X86_64-NETBSD:#define __DBL_MIN_EXP__ (-1021)
 // X86_64-NETBSD:#define __DBL_MIN__ 2.2250738585072014e-308
 // X86_64-NETBSD:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // X86_64-NETBSD:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // X86_64-NETBSD:#define __FLT_DIG__ 6
 // X86_64-NETBSD:#define __FLT_EPSILON__ 1.19209290e-7F
-// X86_64-NETBSD:#define __FLT_EVAL_METHOD__ 0
 // X86_64-NETBSD:#define __FLT_HAS_DENORM__ 1
 // X86_64-NETBSD:#define __FLT_HAS_INFINITY__ 1
 // X86_64-NETBSD:#define __FLT_HAS_QUIET_NAN__ 1
 // X86_64-NETBSD:#define __FLT_MANT_DIG__ 24
 // X86_64-NETBSD:#define __FLT_MAX_10_EXP__ 38
 // X86_64-NETBSD:#define __FLT_MAX_EXP__ 128
 // X86_64-NETBSD:#define __FLT_MAX__ 3.40282347e+38F
 // X86_64-NETBSD:#define __FLT_MIN_10_EXP__ (-37)

clang/test/Preprocessor/init.c

 // MSP430:#define __DBL_MAX__ 1.7976931348623157e+308
 // MSP430:#define __DBL_MIN_10_EXP__ (-307)
 // MSP430:#define __DBL_MIN_EXP__ (-1021)
 // MSP430:#define __DBL_MIN__ 2.2250738585072014e-308
 // MSP430:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // MSP430:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // MSP430:#define __FLT_DIG__ 6
 // MSP430:#define __FLT_EPSILON__ 1.19209290e-7F
-// MSP430:#define __FLT_EVAL_METHOD__ 0
 // MSP430:#define __FLT_HAS_DENORM__ 1
 // MSP430:#define __FLT_HAS_INFINITY__ 1
 // MSP430:#define __FLT_HAS_QUIET_NAN__ 1
 // MSP430:#define __FLT_MANT_DIG__ 24
 // MSP430:#define __FLT_MAX_10_EXP__ 38
 // MSP430:#define __FLT_MAX_EXP__ 128
 // MSP430:#define __FLT_MAX__ 3.40282347e+38F
 // MSP430:#define __FLT_MIN_10_EXP__ (-37)

 // NVPTX32:#define __DBL_MIN_10_EXP__ (-307)
 // NVPTX32:#define __DBL_MIN_EXP__ (-1021)
 // NVPTX32:#define __DBL_MIN__ 2.2250738585072014e-308
 // NVPTX32:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // NVPTX32:#define __FINITE_MATH_ONLY__ 0
 // NVPTX32:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // NVPTX32:#define __FLT_DIG__ 6
 // NVPTX32:#define __FLT_EPSILON__ 1.19209290e-7F
-// NVPTX32:#define __FLT_EVAL_METHOD__ 0
 // NVPTX32:#define __FLT_HAS_DENORM__ 1
 // NVPTX32:#define __FLT_HAS_INFINITY__ 1
 // NVPTX32:#define __FLT_HAS_QUIET_NAN__ 1
 // NVPTX32:#define __FLT_MANT_DIG__ 24
 // NVPTX32:#define __FLT_MAX_10_EXP__ 38
 // NVPTX32:#define __FLT_MAX_EXP__ 128
 // NVPTX32:#define __FLT_MAX__ 3.40282347e+38F
 // NVPTX32:#define __FLT_MIN_10_EXP__ (-37)

 // NVPTX64:#define __DBL_MIN_10_EXP__ (-307)
 // NVPTX64:#define __DBL_MIN_EXP__ (-1021)
 // NVPTX64:#define __DBL_MIN__ 2.2250738585072014e-308
 // NVPTX64:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // NVPTX64:#define __FINITE_MATH_ONLY__ 0
 // NVPTX64:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // NVPTX64:#define __FLT_DIG__ 6
 // NVPTX64:#define __FLT_EPSILON__ 1.19209290e-7F
-// NVPTX64:#define __FLT_EVAL_METHOD__ 0
 // NVPTX64:#define __FLT_HAS_DENORM__ 1
 // NVPTX64:#define __FLT_HAS_INFINITY__ 1
 // NVPTX64:#define __FLT_HAS_QUIET_NAN__ 1
 // NVPTX64:#define __FLT_MANT_DIG__ 24
 // NVPTX64:#define __FLT_MAX_10_EXP__ 38
 // NVPTX64:#define __FLT_MAX_EXP__ 128
 // NVPTX64:#define __FLT_MAX__ 3.40282347e+38F
 // NVPTX64:#define __FLT_MIN_10_EXP__ (-37)

 // SPARC:#define __DBL_MAX__ 1.7976931348623157e+308
 // SPARC:#define __DBL_MIN_10_EXP__ (-307)
 // SPARC:#define __DBL_MIN_EXP__ (-1021)
 // SPARC:#define __DBL_MIN__ 2.2250738585072014e-308
 // SPARC:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // SPARC:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // SPARC:#define __FLT_DIG__ 6
 // SPARC:#define __FLT_EPSILON__ 1.19209290e-7F
-// SPARC:#define __FLT_EVAL_METHOD__ 0
 // SPARC:#define __FLT_HAS_DENORM__ 1
 // SPARC:#define __FLT_HAS_INFINITY__ 1
 // SPARC:#define __FLT_HAS_QUIET_NAN__ 1
 // SPARC:#define __FLT_MANT_DIG__ 24
 // SPARC:#define __FLT_MAX_10_EXP__ 38
 // SPARC:#define __FLT_MAX_EXP__ 128
 // SPARC:#define __FLT_MAX__ 3.40282347e+38F
 // SPARC:#define __FLT_MIN_10_EXP__ (-37)

 // TCE:#define __DBL_MAX__ 3.40282347e+38
 // TCE:#define __DBL_MIN_10_EXP__ (-37)
 // TCE:#define __DBL_MIN_EXP__ (-125)
 // TCE:#define __DBL_MIN__ 1.17549435e-38
 // TCE:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // TCE:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // TCE:#define __FLT_DIG__ 6
 // TCE:#define __FLT_EPSILON__ 1.19209290e-7F
-// TCE:#define __FLT_EVAL_METHOD__ 0
 // TCE:#define __FLT_HAS_DENORM__ 1
 // TCE:#define __FLT_HAS_INFINITY__ 1
 // TCE:#define __FLT_HAS_QUIET_NAN__ 1
 // TCE:#define __FLT_MANT_DIG__ 24
 // TCE:#define __FLT_MAX_10_EXP__ 38
 // TCE:#define __FLT_MAX_EXP__ 128
 // TCE:#define __FLT_MAX__ 3.40282347e+38F
 // TCE:#define __FLT_MIN_10_EXP__ (-37)

 // PS4:#define __DBL_MIN_10_EXP__ (-307)
 // PS4:#define __DBL_MIN_EXP__ (-1021)
 // PS4:#define __DBL_MIN__ 2.2250738585072014e-308
 // PS4:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // PS4:#define __ELF__ 1
 // PS4:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // PS4:#define __FLT_DIG__ 6
 // PS4:#define __FLT_EPSILON__ 1.19209290e-7F
-// PS4:#define __FLT_EVAL_METHOD__ 0
 // PS4:#define __FLT_HAS_DENORM__ 1
 // PS4:#define __FLT_HAS_INFINITY__ 1
 // PS4:#define __FLT_HAS_QUIET_NAN__ 1
 // PS4:#define __FLT_MANT_DIG__ 24
 // PS4:#define __FLT_MAX_10_EXP__ 38
 // PS4:#define __FLT_MAX_EXP__ 128
 // PS4:#define __FLT_MAX__ 3.40282347e+38F
 // PS4:#define __FLT_MIN_10_EXP__ (-37)

 // WEBASSEMBLY-NOT:#define __FLT16_MAX__
 // WEBASSEMBLY-NOT:#define __FLT16_MIN_10_EXP__
 // WEBASSEMBLY-NOT:#define __FLT16_MIN_EXP__
 // WEBASSEMBLY-NOT:#define __FLT16_MIN__
 // WEBASSEMBLY-NEXT:#define __FLT_DECIMAL_DIG__ 9
 // WEBASSEMBLY-NEXT:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // WEBASSEMBLY-NEXT:#define __FLT_DIG__ 6
 // WEBASSEMBLY-NEXT:#define __FLT_EPSILON__ 1.19209290e-7F
-// WEBASSEMBLY-NEXT:#define __FLT_EVAL_METHOD__ 0
 // WEBASSEMBLY-NEXT:#define __FLT_HAS_DENORM__ 1
 // WEBASSEMBLY-NEXT:#define __FLT_HAS_INFINITY__ 1
 // WEBASSEMBLY-NEXT:#define __FLT_HAS_QUIET_NAN__ 1
 // WEBASSEMBLY-NEXT:#define __FLT_MANT_DIG__ 24
 // WEBASSEMBLY-NEXT:#define __FLT_MAX_10_EXP__ 38
 // WEBASSEMBLY-NEXT:#define __FLT_MAX_EXP__ 128
 // WEBASSEMBLY-NEXT:#define __FLT_MAX__ 3.40282347e+38F
 // WEBASSEMBLY-NEXT:#define __FLT_MIN_10_EXP__ (-37)

 // AVR:#define __DBL_MIN_10_EXP__ (-37)
 // AVR:#define __DBL_MIN_EXP__ (-125)
 // AVR:#define __DBL_MIN__ 1.17549435e-38
 // AVR:#define __FINITE_MATH_ONLY__ 0
 // AVR:#define __FLT_DECIMAL_DIG__ 9
 // AVR:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // AVR:#define __FLT_DIG__ 6
 // AVR:#define __FLT_EPSILON__ 1.19209290e-7F
-// AVR:#define __FLT_EVAL_METHOD__ 0
 // AVR:#define __FLT_HAS_DENORM__ 1
 // AVR:#define __FLT_HAS_INFINITY__ 1
 // AVR:#define __FLT_HAS_QUIET_NAN__ 1
 // AVR:#define __FLT_MANT_DIG__ 24
 // AVR:#define __FLT_MAX_10_EXP__ 38
 // AVR:#define __FLT_MAX_EXP__ 128
 // AVR:#define __FLT_MAX__ 3.40282347e+38F
 // AVR:#define __FLT_MIN_10_EXP__ (-37)

 // RISCV32: #define __DBL_MIN__ 2.2250738585072014e-308
 // RISCV32: #define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // RISCV32: #define __ELF__ 1
 // RISCV32: #define __FINITE_MATH_ONLY__ 0
 // RISCV32: #define __FLT_DECIMAL_DIG__ 9
 // RISCV32: #define __FLT_DENORM_MIN__ 1.40129846e-45F
 // RISCV32: #define __FLT_DIG__ 6
 // RISCV32: #define __FLT_EPSILON__ 1.19209290e-7F
-// RISCV32: #define __FLT_EVAL_METHOD__ 0
 // RISCV32: #define __FLT_HAS_DENORM__ 1
 // RISCV32: #define __FLT_HAS_INFINITY__ 1
 // RISCV32: #define __FLT_HAS_QUIET_NAN__ 1
 // RISCV32: #define __FLT_MANT_DIG__ 24
 // RISCV32: #define __FLT_MAX_10_EXP__ 38
 // RISCV32: #define __FLT_MAX_EXP__ 128
 // RISCV32: #define __FLT_MAX__ 3.40282347e+38F
 // RISCV32: #define __FLT_MIN_10_EXP__ (-37)

 // RISCV64: #define __DBL_MIN__ 2.2250738585072014e-308
 // RISCV64: #define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
 // RISCV64: #define __ELF__ 1
 // RISCV64: #define __FINITE_MATH_ONLY__ 0
 // RISCV64: #define __FLT_DECIMAL_DIG__ 9
 // RISCV64: #define __FLT_DENORM_MIN__ 1.40129846e-45F
 // RISCV64: #define __FLT_DIG__ 6
 // RISCV64: #define __FLT_EPSILON__ 1.19209290e-7F
-// RISCV64: #define __FLT_EVAL_METHOD__ 0
 // RISCV64: #define __FLT_HAS_DENORM__ 1
 // RISCV64: #define __FLT_HAS_INFINITY__ 1
 // RISCV64: #define __FLT_HAS_QUIET_NAN__ 1
 // RISCV64: #define __FLT_MANT_DIG__ 24
 // RISCV64: #define __FLT_MAX_10_EXP__ 38
 // RISCV64: #define __FLT_MAX_EXP__ 128
 // RISCV64: #define __FLT_MAX__ 3.40282347e+38F
 // RISCV64: #define __FLT_MIN_10_EXP__ (-37)