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:<size>:<align>``
+    This specifies the size and alignment of memory required to store floating
+    point environment. If this specifier is absent or ``<size>`` is zero, it is
+    assumed that the environment size is equal to one stack word, which is
+    evaluated from the stack alignment. If ``<align>`` is omitted, the
+    alignment is assumed to be the same as natural alignment of the stack.
 
 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

public:
   };
 private:
   /// Defaults to false.
   bool BigEndian;
 
   unsigned AllocaAddrSpace;
   MaybeAlign StackNaturalAlign;
   unsigned ProgramAddrSpace;
+  unsigned FPEnvironmentSize;
+  MaybeAlign FPEnvironmentAlign;
 
   MaybeAlign FunctionPtrAlign;
   FunctionPtrAlignType TheFunctionPtrAlignType;
 
   enum ManglingModeT {
     MM_None,
     MM_ELF,
     MM_MachO,
DataLayout &operator=(const DataLayout &DL) {
     clear();
     StringRepresentation = DL.StringRepresentation;
     BigEndian = DL.isBigEndian();
     AllocaAddrSpace = DL.AllocaAddrSpace;
     StackNaturalAlign = DL.StackNaturalAlign;
     FunctionPtrAlign = DL.FunctionPtrAlign;
     TheFunctionPtrAlignType = DL.TheFunctionPtrAlignType;
     ProgramAddrSpace = DL.ProgramAddrSpace;
+    FPEnvironmentAlign = DL.FPEnvironmentAlign;
+    FPEnvironmentSize = DL.FPEnvironmentSize;
     ManglingMode = DL.ManglingMode;
     LegalIntWidths = DL.LegalIntWidths;
     Alignments = DL.Alignments;
     Pointers = DL.Pointers;
     NonIntegralAddressSpaces = DL.NonIntegralAddressSpaces;
     return *this;
   }
 
public:
   /// Return the type of function pointer alignment.
   /// \see getFunctionPtrAlign
   FunctionPtrAlignType getFunctionPtrAlignType() const {
     return TheFunctionPtrAlignType;
   }
 
   unsigned getProgramAddressSpace() const { return ProgramAddrSpace; }
 
+  unsigned getFPEnvironmentSize() const { return FPEnvironmentSize; }
+  MaybeAlign getFPEnvironmentAlign() const { return FPEnvironmentAlign; }
+
   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;
+  FPEnvironmentSize = 0;
   FunctionPtrAlign.reset();
   TheFunctionPtrAlignType = FunctionPtrAlignType::Independent;
   ManglingMode = MM_None;
   NonIntegralAddressSpaces.clear();
 
   // Default alignments
   for (const LayoutAlignElem &E : DefaultAlignments) {
     setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign, E.PrefAlign,
if (Tok == "ni") {
         if (AS == 0)
           report_fatal_error("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");
+      Split = split(Rest, ':');
+      Rest = Split.second;
+      FPEnvironmentSize = inBytes(getInt(Split.first));
+      if (!Rest.empty()) {
+        unsigned Alignment = inBytes(getInt(Rest));
+        if (Alignment != 0 && !llvm::isPowerOf2_64(Alignment))
+          report_fatal_error("Alignment is neither 0 nor a power of 2");
+        FPEnvironmentAlign = MaybeAlign(Alignment);
+      }
+      continue;
+    }
+
     char Specifier = Tok.front();
     Tok = Tok.substr(1);
 
     switch (Specifier) {
     case 's':
       // Ignored for backward compatibility.
       // FIXME: remove this on LLVM 4.0.
       break;

llvm/unittests/IR/DataLayoutTest.cpp

TEST(DataLayoutTest, ValueOrABITypeAlignment) {
   LLVMContext Context;
   Type *const FourByteAlignType = Type::getInt32Ty(Context);
   EXPECT_EQ(Align(16),
             DL.getValueOrABITypeAlignment(MaybeAlign(16), FourByteAlignType));
   EXPECT_EQ(Align(4),
             DL.getValueOrABITypeAlignment(MaybeAlign(), FourByteAlignType));
 }
 
+TEST(DataLayoutTest, FPEnvironmentProperties) {
+  EXPECT_EQ(0, DataLayout("").getFPEnvironmentSize());
+  EXPECT_EQ(0, DataLayout("fe:0").getFPEnvironmentSize());
+  EXPECT_EQ(4, DataLayout("fe:32").getFPEnvironmentSize());
+  EXPECT_EQ(MaybeAlign(), DataLayout("fe:32").getFPEnvironmentAlign());
+  EXPECT_EQ(MaybeAlign(0), DataLayout("fe:32:0").getFPEnvironmentAlign());
+  EXPECT_EQ(MaybeAlign(4), DataLayout("fe:32:32").getFPEnvironmentAlign());
+}
+
 }  // anonymous namespace