FloatingPointMode: Use -1 for "Dynamic"

[arsenm]

Summary

FLT_ROUNDS says -1 is used for "the default rounding direction is not
known". The previous 7 was taking away options in the
"implementation-defined behavior" range if you just wanted to extend
the enum.

AMDGPU has 2 separately controllable rounding modes that change
different fp types. I want to stick to the standard values in the case
the modes are the same, and use the extended range for cases where the
two are different. Dodging this gap in the enum value required
defining the AMDGPU target specific values in a weird way with strange
conversion code to handle it (see https://reviews.llvm.org/D153257).

[foad]

llvm/include/llvm/ADT/FloatingPointMode.h

39

Lost the ///< comment here.

41

Does ///< work before the field name?

[sepavloff]

Rounding mode is presented in FPOptions with 3 bits, so there is only 8 values available for particular modes. 5 of them, which are specified in IEEE-754, are listed in RoundingMode. Dynamic (which is -1 in 3-bit numbers) is not a real rounding mode, it represents rounding mode unknown at compiler time. RoundingMode::Invalid is not a mode at all, it is used to represent unspecified value at compile-time and can be eliminated by using things like std::optional. In 3 bits it would have the same value as Dynamic, but it is not a problem, because Invalid never appears in AST and IR.

Probably Dynamic is what you need. It prevents from constant folding and other transformations that rely on particular rounding mode and does not restrict actual rounding modes used in runtime. What prevents from using this mode for your case?

[arsenm]

In D156989#4558133, @sepavloff wrote:

Rounding mode is presented in FPOptions with 3 bits, so there is only 8 values available for particular modes. 5 of them, which are specified in IEEE-754, are listed in RoundingMode. Dynamic (which is -1 in 3-bit numbers) is not a real rounding mode,

But it is a spec'd value as -1 for FLT_ROUNDS

RoundingMode::Invalid is not a mode at all, it is used to represent unspecified value at compile-time and can be eliminated by using things like std::optional. In 3 bits it would have the same value as Dynamic, but it is not a problem, because Invalid never appears in AST and IR.

Right it's just filler here

Probably Dynamic is what you need. It prevents from constant folding and other transformations that rely on particular rounding mode and does not restrict actual rounding modes used in runtime. What prevents from using this mode for your case?

I can do better by reporting something meaningful, two different modes is not unknown. The enum here should just be exactly equal to the FLT_ROUNDS values and not pick a random other number, I just need the wrong value for Dynamic to get out of the way to avoid creating additional wrappers

[sepavloff]

In D156989#4558134, @arsenm wrote:

In D156989#4558133, @sepavloff wrote:

Rounding mode is presented in FPOptions with 3 bits, so there is only 8 values available for particular modes. 5 of them, which are specified in IEEE-754, are listed in RoundingMode. Dynamic (which is -1 in 3-bit numbers) is not a real rounding mode,

But it is a spec'd value as -1 for FLT_ROUNDS

It is no more than failure indicator for this function or macro. fegetround may use any negative value for this purpose. -1 does not represent any rounding mode, just like EOF does not represent any character in a stream.

Probably Dynamic is what you need. It prevents from constant folding and other transformations that rely on particular rounding mode and does not restrict actual rounding modes used in runtime. What prevents from using this mode for your case?

I can do better by reporting something meaningful, two different modes is not unknown. The enum here should just be exactly equal to the FLT_ROUNDS values and not pick a random other number, I just need the wrong value for Dynamic to get out of the way to avoid creating additional wrappers

Support of rounding mode in C standard is based on IEEE-754 model, where rounding mode is a global state and affects all FP operations. The case of two rounding modes does not fit this model. So in C/C++ you anyway need to invent special tools for setting this or that rounding mode or reading them. If static rounding mode is not needed, IEEE-754 rounding mode could be represented by Dynamic value.

In IR there are more possibilities to represent many rounding modes. Each constrained intrinsic call contains rounding mode and that mode may be different for different FP types. Actually this model can support the general case. For example, rounding mode for one type can be static but for the other type it can be dynamic. There must be intrinsic functions that set/get rounding mode for different types.

It looks like adding special bultin functions to get/set rounding mode for different types is enough to support rounding in AMDGPU. In any case IEEE-754 rounding mode should be honored, which means that fegetround and FLT_ROUNDS probably should return negative value, and fesetround probably should set all rounding modes. The difference between Dynamic and -1 does not matter because Dynamic can never be an argument of rounding mode type and Invalid (-1) is an error indicator and must not be treated as rounding mode.

[arsenm]

In D156989#4558486, @sepavloff wrote:

Support of rounding mode in C standard is based on IEEE-754 model, where rounding mode is a global state and affects all FP operations. The case of two rounding modes does not fit this model. So in C/C++ you anyway need to invent special tools for setting this or that rounding mode or reading them. If static rounding mode is not needed, IEEE-754 rounding mode could be represented by Dynamic value.

Correct, I'm not planning on creating special "standard looking" tools. I just want the value in the target defined range rather than a black box.

In IR there are more possibilities to represent many rounding modes. Each constrained intrinsic call contains rounding mode and that mode may be different for different FP types. Actually this model can support the general case. For example, rounding mode for one type can be static but for the other type it can be dynamic. There must be intrinsic functions that set/get rounding mode for different types.

The raw target intrinsic to read the mode register works. Once you're in the target range you know you have to do something with target operations

It looks like adding special bultin functions to get/set rounding mode for different types is enough to support rounding in AMDGPU. In any case IEEE-754 rounding mode should be honored, which means that fegetround and FLT_ROUNDS probably should return negative value, and fesetround probably should set all rounding modes. The difference between Dynamic and -1 does not matter because Dynamic can never be an argument of rounding mode type and Invalid (-1) is an error indicator and must not be treated as rounding mode.

My interpretation is fesetround of standard values would set all modes to be the same. Once you're outside of the range it would work correctly to consume the same target defined values. "Could not determine" is the same as dynamic, so this should just use the standard -1 value instead of 7 just to fit in a clang bitfield

[arsenm]

ping. This enum should just match FLT_ROUNDS and designing ABI around whatever this was doing doesn't really make sense

[sepavloff]

Dynamic cannot have value -1, its value must fits 3 bits. Some targets encode rounding mode in instructions, RISCV is an example. It allows five "real" rounding modes, enlisted now in RoundingMode to be specified in a special field or FP instruction. This field also can contain a distinct value that instructs the processor to take rounding mode from a special register. This is a "dynamic" rounding mode in contract to the "static" modes, specified by one of "real" values. When #pragma STC FENV_ACCESS ON is specified, FP operations must use the "dynamic" rounding mode, - they have Dynamic in FPOptions of their AST nodes.

clang/include/clang/Basic/FPOptions.def

 //===--- FPOptions.def - Floating Point Options database --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // This file defines the Floating Point language options. Users of this file
 //  must define the OPTION macro to make use of this information.
 #ifndef OPTION
 #  error Define the OPTION macro to handle floating point language options
 #endif
 
+#define SIMPLE_OPTION(name, type, width, previousName) \
+  OPTION(name, type, static_cast<type>, static_cast<type>, width, previousName)
+
 // OPTION(name, type, width, previousName)
-OPTION(FPContractMode, LangOptions::FPModeKind, 2, First)
-OPTION(RoundingMath, bool, 1, FPContractMode)
-OPTION(ConstRoundingMode, LangOptions::RoundingMode, 3, RoundingMath)
-OPTION(SpecifiedExceptionMode, LangOptions::FPExceptionModeKind, 2, ConstRoundingMode)
-OPTION(AllowFEnvAccess, bool, 1, SpecifiedExceptionMode)
-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)
-OPTION(Float16ExcessPrecision, LangOptions::ExcessPrecisionKind, 2, FPEvalMethod)
-OPTION(BFloat16ExcessPrecision, LangOptions::ExcessPrecisionKind, 2, FPEvalMethod)
+SIMPLE_OPTION(FPContractMode, LangOptions::FPModeKind, 2, First)
+SIMPLE_OPTION(RoundingMath, bool, 1, FPContractMode)
+OPTION(ConstRoundingMode, LangOptions::RoundingMode, llvm::encodeRoundingMode, llvm::decodeRoundingMode, 3, RoundingMath)
+SIMPLE_OPTION(SpecifiedExceptionMode, LangOptions::FPExceptionModeKind, 2, ConstRoundingMode)
+SIMPLE_OPTION(AllowFEnvAccess, bool, 1, SpecifiedExceptionMode)
+SIMPLE_OPTION(AllowFPReassociate, bool, 1, AllowFEnvAccess)
+SIMPLE_OPTION(NoHonorNaNs, bool, 1, AllowFPReassociate)
+SIMPLE_OPTION(NoHonorInfs, bool, 1, NoHonorNaNs)
+SIMPLE_OPTION(NoSignedZero, bool, 1, NoHonorInfs)
+SIMPLE_OPTION(AllowReciprocal, bool, 1, NoSignedZero)
+SIMPLE_OPTION(AllowApproxFunc, bool, 1, AllowReciprocal)
+SIMPLE_OPTION(FPEvalMethod, LangOptions::FPEvalMethodKind, 2, AllowApproxFunc)
+SIMPLE_OPTION(Float16ExcessPrecision, LangOptions::ExcessPrecisionKind, 2, FPEvalMethod)
+SIMPLE_OPTION(BFloat16ExcessPrecision, LangOptions::ExcessPrecisionKind, 2, FPEvalMethod)
+
+#undef SIMPLE_OPTION
 #undef OPTION

clang/include/clang/Basic/LangOptions.h

public:
 
   using RoundingMode = llvm::RoundingMode;
 
   static constexpr unsigned StorageBitSize = 8 * sizeof(storage_type);
 
   // Define a fake option named "First" so that we have a PREVIOUS even for the
   // real first option.
   static constexpr storage_type FirstShift = 0, FirstWidth = 0;
-#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
+#define OPTION(NAME, ENCODE, DECODE, TYPE, WIDTH, PREVIOUS)                    \
   static constexpr storage_type NAME##Shift =                                  \
       PREVIOUS##Shift + PREVIOUS##Width;                                       \
   static constexpr storage_type NAME##Width = WIDTH;                           \
   static constexpr storage_type NAME##Mask = ((1 << NAME##Width) - 1)          \
                                              << NAME##Shift;
 #include "clang/Basic/FPOptions.def"
 
   static constexpr storage_type TotalWidth = 0
-#define OPTION(NAME, TYPE, WIDTH, PREVIOUS) +WIDTH
+#define OPTION(NAME, ENCODE, DECODE, TYPE, WIDTH, PREVIOUS) +WIDTH
 #include "clang/Basic/FPOptions.def"
       ;
   static_assert(TotalWidth <= StorageBitSize, "Too short type for FPOptions");
 
 private:
   storage_type Value;
 
   FPOptionsOverride getChangesSlow(const FPOptions &Base) const;
static FPOptions getFromOpaqueInt(storage_type Value) {
     Opts.Value = Value;
     return Opts;
   }
 
   /// Return difference with the given option set.
   FPOptionsOverride getChangesFrom(const FPOptions &Base) const;
 
   // We can define most of the accessors automatically:
-#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
+#define OPTION(NAME, TYPE, ENCODE, DECODE, WIDTH, PREVIOUS)                    \
   TYPE get##NAME() const {                                                     \
-    return static_cast<TYPE>((Value & NAME##Mask) >> NAME##Shift);             \
+    return DECODE((Value & NAME##Mask) >> NAME##Shift);                        \
   }                                                                            \
   void set##NAME(TYPE value) {                                                 \
-    Value = (Value & ~NAME##Mask) | (storage_type(value) << NAME##Shift);      \
+    Value =                                                                    \
+        (Value & ~NAME##Mask) | (storage_type(ENCODE(value)) << NAME##Shift);  \
   }
 #include "clang/Basic/FPOptions.def"
   LLVM_DUMP_METHOD void dump();
 };
 
 /// Represents difference between two FPOptions values.
 ///
 /// The effect of language constructs changing the set of floating point options
FPOptions applyOverrides(const LangOptions &LO) {
     return applyOverrides(FPOptions(LO));
   }
 
   bool operator==(FPOptionsOverride other) const {
     return Options == other.Options && OverrideMask == other.OverrideMask;
   }
   bool operator!=(FPOptionsOverride other) const { return !(*this == other); }
 
-#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
+#define OPTION(NAME, TYPE, ENCODE, DECODE, WIDTH, PREVIOUS)                    \
   bool has##NAME##Override() const {                                           \
     return OverrideMask & FPOptions::NAME##Mask;                               \
   }                                                                            \
   TYPE get##NAME##Override() const {                                           \
     assert(has##NAME##Override());                                             \
     return Options.get##NAME();                                                \
   }                                                                            \
   void clear##NAME##Override() {                                               \

clang/lib/AST/JSONNodeDumper.cpp

 
 void JSONNodeDumper::visitVerbatimLineComment(
     const comments::VerbatimLineComment *C, const comments::FullComment *) {
   JOS.attribute("text", C->getText());
 }
 
 llvm::json::Object JSONNodeDumper::createFPOptions(FPOptionsOverride FPO) {
   llvm::json::Object Ret;
-#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
+#define OPTION(NAME, TYPE, ENCODE, DECODE, WIDTH, PREVIOUS)                    \
   if (FPO.has##NAME##Override())                                               \
     Ret.try_emplace(#NAME, static_cast<unsigned>(FPO.get##NAME##Override()));
 #include "clang/Basic/FPOptions.def"
   return Ret;
 }
 
 void JSONNodeDumper::VisitCompoundStmt(const CompoundStmt *S) {
   VisitStmt(S);
   if (S->hasStoredFPFeatures())
     JOS.attribute("fpoptions", createFPOptions(S->getStoredFPFeatures()));
 }

clang/lib/AST/TextNodeDumper.cpp

const char *TextNodeDumper::getCommandName(unsigned CommandID) {
   const comments::CommandInfo *Info =
       comments::CommandTraits::getBuiltinCommandInfo(CommandID);
   if (Info)
     return Info->Name;
   return "<not a builtin command>";
 }
 
 void TextNodeDumper::printFPOptions(FPOptionsOverride FPO) {
-#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
+#define OPTION(NAME, TYPE, ENCODE, DECODE, WIDTH, PREVIOUS)                    \
   if (FPO.has##NAME##Override())                                               \
     OS << " " #NAME "=" << FPO.get##NAME##Override();
 #include "clang/Basic/FPOptions.def"
 }
 
 void TextNodeDumper::visitTextComment(const comments::TextComment *C,
                                       const comments::FullComment *) {
   OS << " Text=\"" << C->getText() << "\"";

clang/lib/Basic/LangOptions.cpp

 
 FPOptions FPOptions::defaultWithoutTrailingStorage(const LangOptions &LO) {
   FPOptions result(LO);
   return result;
 }
 
 FPOptionsOverride FPOptions::getChangesSlow(const FPOptions &Base) const {
   FPOptions::storage_type OverrideMask = 0;
-#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
+#define OPTION(NAME, TYPE, ENCODE, DECODE, WIDTH, PREVIOUS)                    \
   if (get##NAME() != Base.get##NAME())                                         \
     OverrideMask |= NAME##Mask;
 #include "clang/Basic/FPOptions.def"
   return FPOptionsOverride(*this, OverrideMask);
 }
 
 LLVM_DUMP_METHOD void FPOptions::dump() {
-#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
+#define OPTION(NAME, TYPE, ENCODE, DECODE, WIDTH, PREVIOUS)                    \
   llvm::errs() << "\n " #NAME " " << get##NAME();
 #include "clang/Basic/FPOptions.def"
   llvm::errs() << "\n";
 }
 
 LLVM_DUMP_METHOD void FPOptionsOverride::dump() {
-#define OPTION(NAME, TYPE, WIDTH, PREVIOUS)                                    \
+#define OPTION(NAME, TYPE, ENCODE, DECODE, WIDTH, PREVIOUS)                    \
   if (has##NAME##Override())                                                   \
     llvm::errs() << "\n " #NAME " Override is " << get##NAME##Override();
 #include "clang/Basic/FPOptions.def"
   llvm::errs() << "\n";
 }

llvm/include/llvm/ADT/FloatingPointMode.h

 ///
 /// This value is packed into bitfield in some cases, including \c FPOptions, so
 /// the rounding mode values and the special value \c Dynamic must fit into the
 /// the bit field (now - 3 bits). The value \c Invalid is used only in values
 /// returned by intrinsics to indicate errors, it should never be stored as
 /// rounding mode value, so it does not need to fit the bit fields.
 ///
 enum class RoundingMode : int8_t {
+  // Special values.
+  Invalid = -2, ///< Denotes invalid value.
+  Dynamic = -1, ///< Denotes mode unknown at compile time.
+
   // Rounding mode defined in IEEE-754.
   TowardZero        = 0,    ///< roundTowardZero.
   NearestTiesToEven = 1,    ///< roundTiesToEven.
   TowardPositive    = 2,    ///< roundTowardPositive.
   TowardNegative    = 3,    ///< roundTowardNegative.
-  NearestTiesToAway = 4,    ///< roundTiesToAway.
-
-  // Special values.
-  Dynamic = 7,    ///< Denotes mode unknown at compile time.
-  Invalid = -1    ///< Denotes invalid value.
+  NearestTiesToAway = 4     ///< roundTiesToAway.
 };
 
+/// Encode a RoundingMode value into a form suitable for a bitfield.
+constexpr int8_t encodeRoundingMode(RoundingMode RM) {
+  return static_cast<int8_t>(RM) + 1;
+}
+
+/// Decode a RoundingMode value from a form suitable for a bitfield.
+constexpr RoundingMode decodeRoundingMode(int8_t Val) {
+  return static_cast<RoundingMode>(Val - 1);
+}
+
 /// Returns text representation of the given rounding mode.
 inline StringRef spell(RoundingMode RM) {
   switch (RM) {
   case RoundingMode::TowardZero: return "towardzero";
   case RoundingMode::NearestTiesToEven: return "tonearest";
   case RoundingMode::TowardPositive: return "upward";
   case RoundingMode::TowardNegative: return "downward";
   case RoundingMode::NearestTiesToAway: return "tonearestaway";