1 //===- llvm/Support/FloatingPointMode.h -------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Utilities for dealing with flags related to floating point mode controls. 10 // 11 //===----------------------------------------------------------------------===/ 12 13 #ifndef LLVM_ADT_FLOATINGPOINTMODE_H 14 #define LLVM_ADT_FLOATINGPOINTMODE_H 15 16 #include "llvm/ADT/StringSwitch.h" 17 #include "llvm/Support/raw_ostream.h" 18 19 namespace llvm { 20 21 /// Rounding mode. 22 /// 23 /// Enumerates supported rounding modes, as well as some special values. The set 24 /// of the modes must agree with IEEE-754, 4.3.1 and 4.3.2. The constants 25 /// assigned to the IEEE rounding modes must agree with the values used by 26 /// FLT_ROUNDS (C11, 5.2.4.2.2p8). 27 /// 28 /// This value is packed into bitfield in some cases, including \c FPOptions, so 29 /// the rounding mode values and the special value \c Dynamic must fit into the 30 /// the bit field (now - 3 bits). The value \c Invalid is used only in values 31 /// returned by intrinsics to indicate errors, it should never be stored as 32 /// rounding mode value, so it does not need to fit the bit fields. 33 /// 34 enum class RoundingMode : int8_t { 35 // Rounding mode defined in IEEE-754. 36 TowardZero = 0, ///< roundTowardZero. 37 NearestTiesToEven = 1, ///< roundTiesToEven. 38 TowardPositive = 2, ///< roundTowardPositive. 39 TowardNegative = 3, ///< roundTowardNegative. 40 NearestTiesToAway = 4, ///< roundTiesToAway. 41 42 // Special values. 43 Dynamic = 7, ///< Denotes mode unknown at compile time. 44 Invalid = -1 ///< Denotes invalid value. 45 }; 46 47 /// Returns text representation of the given rounding mode. 48 inline StringRef spell(RoundingMode RM) { 49 switch (RM) { 50 case RoundingMode::TowardZero: return "towardzero"; 51 case RoundingMode::NearestTiesToEven: return "tonearest"; 52 case RoundingMode::TowardPositive: return "upward"; 53 case RoundingMode::TowardNegative: return "downward"; 54 case RoundingMode::NearestTiesToAway: return "tonearestaway"; 55 case RoundingMode::Dynamic: return "dynamic"; 56 default: return "invalid"; 57 } 58 } 59 60 inline raw_ostream &operator << (raw_ostream &OS, RoundingMode RM) { 61 OS << spell(RM); 62 return OS; 63 } 64 65 /// Represent subnormal handling kind for floating point instruction inputs and 66 /// outputs. 67 struct DenormalMode { 68 /// Represent handled modes for denormal (aka subnormal) modes in the floating 69 /// point environment. 70 enum DenormalModeKind : int8_t { 71 Invalid = -1, 72 73 /// IEEE-754 denormal numbers preserved. 74 IEEE, 75 76 /// The sign of a flushed-to-zero number is preserved in the sign of 0 77 PreserveSign, 78 79 /// Denormals are flushed to positive zero. 80 PositiveZero 81 }; 82 83 /// Denormal flushing mode for floating point instruction results in the 84 /// default floating point environment. 85 DenormalModeKind Output = DenormalModeKind::Invalid; 86 87 /// Denormal treatment kind for floating point instruction inputs in the 88 /// default floating-point environment. If this is not DenormalModeKind::IEEE, 89 /// floating-point instructions implicitly treat the input value as 0. 90 DenormalModeKind Input = DenormalModeKind::Invalid; 91 92 constexpr DenormalMode() = default; 93 constexpr DenormalMode(DenormalModeKind Out, DenormalModeKind In) : 94 Output(Out), Input(In) {} 95 96 97 static constexpr DenormalMode getInvalid() { 98 return DenormalMode(DenormalModeKind::Invalid, DenormalModeKind::Invalid); 99 } 100 101 static constexpr DenormalMode getIEEE() { 102 return DenormalMode(DenormalModeKind::IEEE, DenormalModeKind::IEEE); 103 } 104 105 static constexpr DenormalMode getPreserveSign() { 106 return DenormalMode(DenormalModeKind::PreserveSign, 107 DenormalModeKind::PreserveSign); 108 } 109 110 static constexpr DenormalMode getPositiveZero() { 111 return DenormalMode(DenormalModeKind::PositiveZero, 112 DenormalModeKind::PositiveZero); 113 } 114 115 bool operator==(DenormalMode Other) const { 116 return Output == Other.Output && Input == Other.Input; 117 } 118 119 bool operator!=(DenormalMode Other) const { 120 return !(*this == Other); 121 } 122 123 bool isSimple() const { 124 return Input == Output; 125 } 126 127 bool isValid() const { 128 return Output != DenormalModeKind::Invalid && 129 Input != DenormalModeKind::Invalid; 130 } 131 132 inline void print(raw_ostream &OS) const; 133 134 inline std::string str() const { 135 std::string storage; 136 raw_string_ostream OS(storage); 137 print(OS); 138 return OS.str(); 139 } 140 }; 141 142 inline raw_ostream& operator<<(raw_ostream &OS, DenormalMode Mode) { 143 Mode.print(OS); 144 return OS; 145 } 146 147 /// Parse the expected names from the denormal-fp-math attribute. 148 inline DenormalMode::DenormalModeKind 149 parseDenormalFPAttributeComponent(StringRef Str) { 150 // Assume ieee on unspecified attribute. 151 return StringSwitch<DenormalMode::DenormalModeKind>(Str) 152 .Cases("", "ieee", DenormalMode::IEEE) 153 .Case("preserve-sign", DenormalMode::PreserveSign) 154 .Case("positive-zero", DenormalMode::PositiveZero) 155 .Default(DenormalMode::Invalid); 156 } 157 158 /// Return the name used for the denormal handling mode used by the the 159 /// expected names from the denormal-fp-math attribute. 160 inline StringRef denormalModeKindName(DenormalMode::DenormalModeKind Mode) { 161 switch (Mode) { 162 case DenormalMode::IEEE: 163 return "ieee"; 164 case DenormalMode::PreserveSign: 165 return "preserve-sign"; 166 case DenormalMode::PositiveZero: 167 return "positive-zero"; 168 default: 169 return ""; 170 } 171 } 172 173 /// Returns the denormal mode to use for inputs and outputs. 174 inline DenormalMode parseDenormalFPAttribute(StringRef Str) { 175 StringRef OutputStr, InputStr; 176 std::tie(OutputStr, InputStr) = Str.split(','); 177 178 DenormalMode Mode; 179 Mode.Output = parseDenormalFPAttributeComponent(OutputStr); 180 181 // Maintain compatability with old form of the attribute which only specified 182 // one component. 183 Mode.Input = InputStr.empty() ? Mode.Output : 184 parseDenormalFPAttributeComponent(InputStr); 185 186 return Mode; 187 } 188 189 void DenormalMode::print(raw_ostream &OS) const { 190 OS << denormalModeKindName(Output) << ',' << denormalModeKindName(Input); 191 } 192 193 } 194 195 #endif // LLVM_ADT_FLOATINGPOINTMODE_H 196