[Clang][Preprocessor] Fix inconsistent `FLT_EVAL_METHOD` when compiling vs preprocessing

[egorzhdan]

Summary

When running clang -E -Ofast on macOS, the __FLT_EVAL_METHOD__ macro is 0, which causes the following typedef to be emitted into the preprocessed source: typedef float float_t.

However, when running clang -c -Ofast, __FLT_EVAL_METHOD__ is -1, and typedef long double float_t is emitted.

This causes build errors for certain projects, which are not reproducible when compiling from preprocessed source.

The issue is that __FLT_EVAL_METHOD__ is configured in Sema::Sema which is not executed when running in -E mode.

This change moves that logic into the preprocessor initialization method, which is invoked correctly in -E mode.

rdar://96134605
rdar://92748429

[egorzhdan]

Adjust commit message

[aaron.ballman]

Good catch! This LGTM.

[zahiraam]

Took the time to test the change on a few "crooked" tests I had used for the original patch. It works! LGTM.

clang/lib/Lex/Preprocessor.cpp

void Preprocessor::Initialize(const TargetInfo &Target,
   BuiltinInfo->InitializeTarget(Target, AuxTarget);
   HeaderInfo.setTarget(Target);
 
   // Populate the identifier table with info about keywords for the current language.
   Identifiers.AddKeywords(LangOpts);
 
   // Initialize the __FTL_EVAL_METHOD__ macro to the TargetInfo.
   setTUFPEvalMethod(getTargetInfo().getFPEvalMethod());
+
+  if (getLangOpts().getFPEvalMethod() == LangOptions::FEM_UnsetOnCommandLine)
+    // Use setting from TargetInfo.
+    setCurrentFPEvalMethod(SourceLocation(), Target.getFPEvalMethod());
+  else
+    // Set initial value of __FLT_EVAL_METHOD__ from the command line.
+    setCurrentFPEvalMethod(SourceLocation(), getLangOpts().getFPEvalMethod());
+  // When `-ffast-math` option is enabled, it triggers several driver math
+  // options to be enabled. Among those, only one the following two modes
+  // affect the eval-method:  reciprocal or reassociate.
+  if (getLangOpts().AllowFPReassoc || getLangOpts().AllowRecip)
+    setCurrentFPEvalMethod(SourceLocation(), LangOptions::FEM_Indeterminable);
 }
 
 void Preprocessor::InitializeForModelFile() {
   NumEnteredSourceFiles = 0;
 
   // Reset pragmas
   PragmaHandlersBackup = std::move(PragmaHandlers);
   PragmaHandlers = std::make_unique<PragmaNamespace>(StringRef());

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_UnsetOnCommandLine)
-    // Use setting from TargetInfo.
-    PP.setCurrentFPEvalMethod(SourceLocation(),
-                              ctxt.getTargetInfo().getFPEvalMethod());
-  else
-    // Set initial value of __FLT_EVAL_METHOD__ from the command line.
-    PP.setCurrentFPEvalMethod(SourceLocation(),
-                              getLangOpts().getFPEvalMethod());
+
   CurFPFeatures.setFPEvalMethod(PP.getCurrentFPEvalMethod());
-  // When `-ffast-math` option is enabled, it triggers several driver math
-  // options to be enabled. Among those, only one the following two modes
-  // affect the eval-method:  reciprocal or reassociate.
-  if (getLangOpts().AllowFPReassoc || getLangOpts().AllowRecip)
-    PP.setCurrentFPEvalMethod(SourceLocation(),
-                              LangOptions::FEM_Indeterminable);
 }
 
 // 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())

clang/test/Preprocessor/flt_eval_macro.cpp

 // RUN:   %s -o - | FileCheck %s  -strict-whitespace
 
 // RUN: %clang_cc1 -E -dM -triple=arm64_32-apple-ios  %s -o - \
 // RUN:   | FileCheck %s  -strict-whitespace
 
 // RUN: %clang_cc1 -E -dM -triple=arm64_32-apple-ios -target-feature -sse \
 // RUN:   %s -o - | FileCheck %s  -strict-whitespace
 
+// RUN: %clang_cc1 -E -dM -triple=x86_64-apple-macos13.0 -ffast-math \
+// RUN:   %s -o - | FileCheck %s -check-prefix=CHECK-MINUS-ONE -strict-whitespace
+
 // RUN: %clang_cc1 -E -dM -triple i386-pc-windows -target-cpu pentium4 %s -o - \
 // RUN:   | FileCheck %s  -strict-whitespace
 
 // RUN: %clang_cc1 -E -dM -triple i386-pc-windows -target-cpu pentium4 \
 // RUN:   -target-feature -sse %s -o - | FileCheck -check-prefix=EXT %s \
 // RUN:   -strict-whitespace
 
 #ifdef __FLT_EVAL_METHOD__
 #if __FLT_EVAL_METHOD__ == 3
 #define __GLIBC_FLT_EVAL_METHOD 2
 #else
 #define __GLIBC_FLT_EVAL_METHOD __FLT_EVAL_METHOD__
 #endif
 #elif defined __x86_64__
 #define __GLIBC_FLT_EVAL_METHOD 0
 #else
 #define __GLIBC_FLT_EVAL_METHOD 2
 #endif
 
-#if __GLIBC_FLT_EVAL_METHOD == 0 || __GLIBC_FLT_EVAL_METHOD == 16
+#if __GLIBC_FLT_EVAL_METHOD == -1
+#define Name "MinusOne"
+#elif __GLIBC_FLT_EVAL_METHOD == 0 || __GLIBC_FLT_EVAL_METHOD == 16
 #define Name "One"
 #elif __GLIBC_FLT_EVAL_METHOD == 1
 #define Name "Two"
 #elif __GLIBC_FLT_EVAL_METHOD == 2
 #define Name "Three"
 #elif __GLIBC_FLT_EVAL_METHOD == 32
 #define Name "Four"
 #elif __GLIBC_FLT_EVAL_METHOD == 33
 #define Name "Five"
 #elif __GLIBC_FLT_EVAL_METHOD == 64
 #define Name "Six"
 #elif __GLIBC_FLT_EVAL_METHOD == 65
 #define Name "Seven"
 #elif __GLIBC_FLT_EVAL_METHOD == 128
 #define Name "Eight"
 #elif __GLIBC_FLT_EVAL_METHOD == 129
 #define Name "Nine"
 #else
 #error "Unknown __GLIBC_FLT_EVAL_METHOD"
 #endif
 
 int foo() {
   // CHECK: #define Name "One"
+  // CHECK-MINUS-ONE: #define Name "MinusOne"
   // EXT: #define Name "Three"
   return Name;
 }
 
 #pragma fp eval_method(double)
 
 #if __FLT_EVAL_METHOD__ == 3
 #define Val "Unset"