[FPEnv] Initialization of C++ globals not strictfp aware

[kpn]

Summary

The rules of the strictfp attribute say that if it is used inside a function then it must also be in the function definition. Initialization of C++ globals breaks that rule. This patch corrects the failing test but doesn't attempt to correct it on other ABIs.

Error spotted with use of D68233.

[rjmccall]

clang/lib/CodeGen/CodeGenFunction.h

4348

How is this set that we don't end up also setting it as a function attribute?

[kpn]

clang/lib/CodeGen/CodeGenFunction.h

4348

I admit I don't understand the question. Since the strictfp attribute is required on both definitions and calls then only one accessor function seems needed?

I don't get to spend as much time in clang proper as I might like.

[rjmccall]

clang/lib/CodeGen/CodeGenFunction.h

4348

There is some code that's setting IsFPConstrained on the builder in the first place when building the global initialization function. We should be making sure that we add the IR attribute to the function under the same conditions.

The main place that sets IsFPConstrained is in CGF::StartFunction where it detects that we're emitting a FunctionDecl and checks whether the FunctionDecl usesFPIntrin(). That place also immediately adds the IR attribute. But there's another place, in CGF::SetFPModel, that sets it based on the global exception and rounding-mode settings, and that place doesn't add the attribute.

Both of these places look buggy, though, because they're both setting setIsFPConstrained(condition), which means that the second one to get called will overwrite the first rather than supplementing it. We should unify these places so that StartFunction is responsible for deciding whether we're using strictfp and, if so, both configures the builder properly and adds the attribute.

clang/lib/CodeGen/CGDeclCXX.cpp

for (size_t i = 0; i < FileName.size(); ++i) {
     // to be the set of C preprocessing numbers.
     if (!isPreprocessingNumberBody(FileName[i]))
       FileName[i] = '_';
   }
 
   llvm::Function *Fn = CreateGlobalInitOrDestructFunction(
       FTy, llvm::Twine("_GLOBAL__sub_I_", FileName), FI);
 
-  CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn, CXXGlobalInits);
+  CodeGenFunction CGFn(*this);
+  CGFn.GenerateCXXGlobalInitFunc(Fn, CXXGlobalInits);
+  if (CGFn.isStrictFP())
+    if (!Fn->hasFnAttribute(llvm::Attribute::StrictFP))
+      Fn->addFnAttr(llvm::Attribute::StrictFP);
+
   AddGlobalCtor(Fn);
 
   // In OpenCL global init functions must be converted to kernels in order to
   // be able to launch them from the host.
   // FIXME: Some more work might be needed to handle destructors correctly.
   // Current initialization function makes use of function pointers callbacks.
   // We can't support function pointers especially between host and device.
   // However it seems global destruction has little meaning without any

clang/lib/CodeGen/CodeGenFunction.h

public:
   void SetFPAccuracy(llvm::Value *Val, float Accuracy);
 
   /// SetFPModel - Control floating point behavior via fp-model settings.
   void SetFPModel();
 
   /// Set the codegen fast-math flags.
   void SetFastMathFlags(FPOptions FPFeatures);
 
+  /// Query for the use of constrained floating point math
+  bool isStrictFP() { return Builder.getIsFPConstrained(); }
+
 private:
   llvm::MDNode *getRangeForLoadFromType(QualType Ty);
   void EmitReturnOfRValue(RValue RV, QualType Ty);
 
   void deferPlaceholderReplacement(llvm::Instruction *Old, llvm::Value *New);
 
   llvm::SmallVector<std::pair<llvm::Instruction *, llvm::Value *>, 4>
   DeferredReplacements;

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

 //CHECK-NOHONOR: call nnan ninf float @llvm.fmuladd{{.*}}
 #endif
 #if FAST
 //CHECK-FAST: fmul fast float
 //CHECK-FAST: fadd fast float
 #endif
 };
 OFF off;
+
+//CHECK-DEBSTRICT: define internal void @_GLOBAL__sub_I_fp_floatcontrol_stack.cpp() [[STRICTDEF:#[0-9]+]]
+//CHECK-DEBSTRICT: call void @__cxx_global_var_init() [[STRICTFPONLY:#[0-9]+]]
+//CHECK-DEBSTRICT: attributes [[STRICTDEF]] = { noinline{{.*}}strictfp{{.*}} }
+//CHECK-DEBSTRICT: attributes [[STRICTFPONLY]] = { strictfp }