Add size of FP environment to DataLayout

[sepavloff]

Summary

Add size of FP environment to DataLayout

DataLayout specification is extended with a new item, which has the form
"fe:<size1>:<size2>". The argument <size1> specifies the size of floating
point control modes (such as rounding mode) and correspond to the size of
type femode_t used in C library. The optional argument <size2> represents
size of entire floating point environment and corresponds to the size of
fenv_t. It defaults to the same value as <size1>.

Saving/restoring the FP environment requries creation of a variable for
the FP state but the size of this variable depends on the used target. As
this operation occurs at IR level, the size of FP state must be provided
by a component intended to represent target properties in
target-independent pipeline.

[sepavloff]

Updated patch

• Removed alignment info. Alignment of stack must be enough.

[efriedma]

Do we really need this in the datalayout? I can imagine certain frontends might care, but I can't imagine optimizations inserting new save/restore operations.

As an example, inlining a function that requires default FP environment into a function where FP is non-standard requires saving the FP environment before entry into the inlined function and resoring it upon return.

Not sure what the inliner has to do with this; the required FP environment for each floating-point operation doesn't change if you inline a function.

[sepavloff]

In D71741#2091128, @efriedma wrote:

Do we really need this in the datalayout? I can imagine certain frontends might care, but I can't imagine optimizations inserting new save/restore operations.

There are at least two motivations of having FPEnv size in DataLayout:

• Implementation of a pragma that would set and restore runtime rounding mode, a sequence like this:

fegetenv(&saved_fpenv);
fesetroundinf(FE_DOWNWARD);
... Operations that require specific rounding mode ...
fesetenv(&saved_fpenv);

• Some IR transformation like inlining, various loop transformation and some others involve code motion. As a result the moved code may be put into surroundings where FP environment is different or unknown, or changing it is undesirable.

In these cases compiler may need to insert save/restore operations but the type of variable to store the environment is target-dependent.

[sepavloff]

The dependent revision D71742 is modified so that it does not require size of FP environment to be specified in DataLayout. Probably when implementing frontend part this information will become necessary.

[sepavloff]

Rebased patch. Added size of control modes.

[sepavloff]

Use more consistent name: s/getFPControlModesSize/getFPControlModeSize/

[sepavloff]

This is not required anymore, - intrinsics that operate FP environment must use correct types.

llvm/docs/LangRef.rst

``n<size1>:<size2>:<size3>...``
     bits. For example, it might contain ``n32`` for 32-bit PowerPC,
     ``n32:64`` for PowerPC 64, or ``n8:16:32:64`` for X86-64. Elements of
     this set are considered to support most general arithmetic operations
     efficiently.
 ``ni:<address space0>:<address space1>:<address space2>...``
     This specifies pointer types with the specified address spaces
     as :ref:`Non-Integral Pointer Type <nointptrtype>` s.  The ``0``
     address space cannot be specified as non-integral.
+``fe:<size1>:<size2>``
+    This specifies the size of floating point environment. The first element,
+    <size1>, specifies the size required to store control modes. It corresponds
+    to the size of ``femode_t` used in C library. The second element, <size2>,
+    specifies the the size, required to store full floating point environment,
+    it corresponds to the size of ``fenv_t`` used in C library. If <size2> is
+    omitted, it is assumed to be the same as <size1>.
 
 On every specification that takes a ``<abi>:<pref>``, specifying the
 ``<pref>`` alignment is optional. If omitted, the preceding ``:``
 should be omitted too and ``<pref>`` will be equal to ``<abi>``.
 
 When constructing the data layout for a given target, LLVM starts with a
 default set of specifications which are then (possibly) overridden by
 the specifications in the ``datalayout`` keyword. The default

llvm/include/llvm/IR/DataLayout.h

 private:
   /// Defaults to false.
   bool BigEndian;
 
   unsigned AllocaAddrSpace;
   MaybeAlign StackNaturalAlign;
   unsigned ProgramAddrSpace;
   unsigned DefaultGlobalsAddrSpace;
+  unsigned FPControlModeSize;
+  unsigned FPEnvironmentSize;
 
   MaybeAlign FunctionPtrAlign;
   FunctionPtrAlignType TheFunctionPtrAlignType;
 
   enum ManglingModeT {
     MM_None,
     MM_ELF,
     MM_MachO,
DataLayout &operator=(const DataLayout &DL) {
     StringRepresentation = DL.StringRepresentation;
     BigEndian = DL.isBigEndian();
     AllocaAddrSpace = DL.AllocaAddrSpace;
     StackNaturalAlign = DL.StackNaturalAlign;
     FunctionPtrAlign = DL.FunctionPtrAlign;
     TheFunctionPtrAlignType = DL.TheFunctionPtrAlignType;
     ProgramAddrSpace = DL.ProgramAddrSpace;
     DefaultGlobalsAddrSpace = DL.DefaultGlobalsAddrSpace;
+    FPControlModeSize = DL.FPControlModeSize;
+    FPEnvironmentSize = DL.FPEnvironmentSize;
     ManglingMode = DL.ManglingMode;
     LegalIntWidths = DL.LegalIntWidths;
     Alignments = DL.Alignments;
     Pointers = DL.Pointers;
     NonIntegralAddressSpaces = DL.NonIntegralAddressSpaces;
     return *this;
   }
 
FunctionPtrAlignType getFunctionPtrAlignType() const {
     return TheFunctionPtrAlignType;
   }
 
   unsigned getProgramAddressSpace() const { return ProgramAddrSpace; }
   unsigned getDefaultGlobalsAddressSpace() const {
     return DefaultGlobalsAddrSpace;
   }
 
+  unsigned getFPControlModeSize() const { return FPControlModeSize; }
+  unsigned getFPEnvironmentSize() const { return FPEnvironmentSize; }
+
   bool hasMicrosoftFastStdCallMangling() const {
     return ManglingMode == MM_WinCOFFX86;
   }
 
   /// Returns true if symbols with leading question marks should not receive IR
   /// mangling. True for Windows mangling modes.
   bool doNotMangleLeadingQuestionMark() const {
     return ManglingMode == MM_WinCOFF || ManglingMode == MM_WinCOFFX86;

llvm/lib/IR/DataLayout.cpp

void DataLayout::reset(StringRef Desc) {
   clear();
 
   LayoutMap = nullptr;
   BigEndian = false;
   AllocaAddrSpace = 0;
   StackNaturalAlign.reset();
   ProgramAddrSpace = 0;
   DefaultGlobalsAddrSpace = 0;
+  FPControlModeSize = 0;
+  FPEnvironmentSize = 0;
   FunctionPtrAlign.reset();
   TheFunctionPtrAlignType = FunctionPtrAlignType::Independent;
   ManglingMode = MM_None;
   NonIntegralAddressSpaces.clear();
 
   // Default alignments
   for (const LayoutAlignElem &E : DefaultAlignments) {
     if (Error Err = setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign,
if (Tok == "ni") {
         if (AS == 0)
           return reportError("Address space 0 can never be non-integral");
         NonIntegralAddressSpaces.push_back(AS);
       } while (!Rest.empty());
 
       continue;
     }
 
+    if (Tok == "fe") {
+      if (Rest.empty())
+        report_fatal_error("Missing size specification for FP environment in "
+                           "datalayout string");
+      if (Error Err = split(Rest, ':', Split))
+        return Err;
+      Rest = Split.second;
+      if (Error Err = getInt(Split.first, FPControlModeSize))
+        return Err;
+      if (!Rest.empty()) {
+        if (Error Err = split(Rest, ':', Split))
+          return Err;
+        Rest = Split.second;
+        if (Error Err = getInt(Split.first, FPEnvironmentSize))
+          return Err;
+      } else {
+        FPEnvironmentSize = FPControlModeSize;
+      }
+      if (!Rest.empty())
+        report_fatal_error("Extra item in FP environment specification");
+      continue;
+    }
+
     char Specifier = Tok.front();
     Tok = Tok.substr(1);
 
     switch (Specifier) {
     case 's':
       // Deprecated, but ignoring here to preserve loading older textual llvm
       // ASM file
       break;

 void DataLayout::init(const Module *M) { *this = M->getDataLayout(); }
 
 bool DataLayout::operator==(const DataLayout &Other) const {
   bool Ret = BigEndian == Other.BigEndian &&
              AllocaAddrSpace == Other.AllocaAddrSpace &&
              StackNaturalAlign == Other.StackNaturalAlign &&
              ProgramAddrSpace == Other.ProgramAddrSpace &&
              DefaultGlobalsAddrSpace == Other.DefaultGlobalsAddrSpace &&
+             FPControlModeSize == Other.FPControlModeSize &&
+             FPEnvironmentSize == Other.FPEnvironmentSize &&
              FunctionPtrAlign == Other.FunctionPtrAlign &&
              TheFunctionPtrAlignType == Other.TheFunctionPtrAlignType &&
              ManglingMode == Other.ManglingMode &&
              LegalIntWidths == Other.LegalIntWidths &&
              Alignments == Other.Alignments && Pointers == Other.Pointers;
   // Note: getStringRepresentation() might differs, it is not canonicalized
   return Ret;
 }

llvm/unittests/IR/DataLayoutTest.cpp

auto *DefaultGlobal2 = new GlobalVariable(
       *M, Int32, false, GlobalValue::ExternalLinkage, nullptr);
   EXPECT_EQ(DefaultGlobal2->getAddressSpace(), 200u);
   auto *ExplicitGlobal2 = new GlobalVariable(
       *M, Int32, false, GlobalValue::ExternalLinkage, nullptr, "", nullptr,
       GlobalValue::NotThreadLocal, 123);
   EXPECT_EQ(ExplicitGlobal2->getAddressSpace(), 123u);
 }
 
+TEST(DataLayoutTest, FPEnvironmentProperties) {
+  EXPECT_EQ(0U, DataLayout("").getFPControlModeSize());
+  EXPECT_EQ(0U, DataLayout("").getFPEnvironmentSize());
+  EXPECT_EQ(0U, DataLayout("fe:0").getFPControlModeSize());
+  EXPECT_EQ(0U, DataLayout("fe:0").getFPEnvironmentSize());
+  EXPECT_EQ(32U, DataLayout("fe:32").getFPControlModeSize());
+  EXPECT_EQ(32U, DataLayout("fe:32").getFPEnvironmentSize());
+  EXPECT_EQ(32U, DataLayout("fe:32:64").getFPControlModeSize());
+  EXPECT_EQ(64U, DataLayout("fe:32:64").getFPEnvironmentSize());
+}
+
 } // anonymous namespace