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/// \file
10/// Utilities for dealing with flags related to floating point properties and
11/// mode controls.
12///
13//===----------------------------------------------------------------------===/
14
15#ifndef LLVM_ADT_FLOATINGPOINTMODE_H
16#define LLVM_ADT_FLOATINGPOINTMODE_H
17
18#include "llvm/ADT/BitmaskEnum.h"
19#include "llvm/ADT/StringSwitch.h"
20#include "llvm/Support/raw_ostream.h"
21
22namespace llvm {
23
24/// Rounding mode.
25///
26/// Enumerates supported rounding modes, as well as some special values. The set
27/// of the modes must agree with IEEE-754, 4.3.1 and 4.3.2. The constants
28/// assigned to the IEEE rounding modes must agree with the values used by
29/// FLT_ROUNDS (C11, 5.2.4.2.2p8).
30///
31/// This value is packed into bitfield in some cases, including \c FPOptions, so
32/// the rounding mode values and the special value \c Dynamic must fit into the
33/// the bit field (now - 3 bits). The value \c Invalid is used only in values
34/// returned by intrinsics to indicate errors, it should never be stored as
35/// rounding mode value, so it does not need to fit the bit fields.
36///
37enum class RoundingMode : int8_t {
38 // Rounding mode defined in IEEE-754.
39 TowardZero = 0, ///< roundTowardZero.
40 NearestTiesToEven = 1, ///< roundTiesToEven.
41 TowardPositive = 2, ///< roundTowardPositive.
42 TowardNegative = 3, ///< roundTowardNegative.
43 NearestTiesToAway = 4, ///< roundTiesToAway.
44
45 // Special values.
46 Dynamic = 7, ///< Denotes mode unknown at compile time.
47 Invalid = -1 ///< Denotes invalid value.
48};
49
50/// Returns text representation of the given rounding mode.
51inline StringRef spell(RoundingMode RM) {
52 switch (RM) {
53 case RoundingMode::TowardZero: return "towardzero";
54 case RoundingMode::NearestTiesToEven: return "tonearest";
55 case RoundingMode::TowardPositive: return "upward";
56 case RoundingMode::TowardNegative: return "downward";
57 case RoundingMode::NearestTiesToAway: return "tonearestaway";
58 case RoundingMode::Dynamic: return "dynamic";
59 default: return "invalid";
60 }
61}
62
63inline raw_ostream &operator << (raw_ostream &OS, RoundingMode RM) {
64 OS << spell(RM);
65 return OS;
66}
67
68/// Represent subnormal handling kind for floating point instruction inputs and
69/// outputs.
70struct DenormalMode {
71 /// Represent handled modes for denormal (aka subnormal) modes in the floating
72 /// point environment.
73 enum DenormalModeKind : int8_t {
74 Invalid = -1,
75
76 /// IEEE-754 denormal numbers preserved.
77 IEEE,
78
79 /// The sign of a flushed-to-zero number is preserved in the sign of 0
80 PreserveSign,
81
82 /// Denormals are flushed to positive zero.
83 PositiveZero,
84
85 /// Denormals have unknown treatment.
86 Dynamic
87 };
88
89 /// Denormal flushing mode for floating point instruction results in the
90 /// default floating point environment.
91 DenormalModeKind Output = DenormalModeKind::Invalid;
92
93 /// Denormal treatment kind for floating point instruction inputs in the
94 /// default floating-point environment. If this is not DenormalModeKind::IEEE,
95 /// floating-point instructions implicitly treat the input value as 0.
96 DenormalModeKind Input = DenormalModeKind::Invalid;
97
98 constexpr DenormalMode() = default;
99 constexpr DenormalMode(const DenormalMode &) = default;
100 constexpr DenormalMode(DenormalModeKind Out, DenormalModeKind In) :
101 Output(Out), Input(In) {}
102
103 DenormalMode &operator=(const DenormalMode &) = default;
104
105 static constexpr DenormalMode getInvalid() {
106 return DenormalMode(DenormalModeKind::Invalid, DenormalModeKind::Invalid);
107 }
108
109 /// Return the assumed default mode for a function without denormal-fp-math.
110 static constexpr DenormalMode getDefault() {
111 return getIEEE();
112 }
113
114 static constexpr DenormalMode getIEEE() {
115 return DenormalMode(DenormalModeKind::IEEE, DenormalModeKind::IEEE);
116 }
117
118 static constexpr DenormalMode getPreserveSign() {
119 return DenormalMode(DenormalModeKind::PreserveSign,
120 DenormalModeKind::PreserveSign);
121 }
122
123 static constexpr DenormalMode getPositiveZero() {
124 return DenormalMode(DenormalModeKind::PositiveZero,
125 DenormalModeKind::PositiveZero);
126 }
127
128 static constexpr DenormalMode getDynamic() {
129 return DenormalMode(DenormalModeKind::Dynamic, DenormalModeKind::Dynamic);
130 }
131
132 bool operator==(DenormalMode Other) const {
133 return Output == Other.Output && Input == Other.Input;
134 }
135
136 bool operator!=(DenormalMode Other) const {
137 return !(*this == Other);
138 }
139
140 bool isSimple() const {
141 return Input == Output;
142 }
143
144 bool isValid() const {
145 return Output != DenormalModeKind::Invalid &&
146 Input != DenormalModeKind::Invalid;
147 }
148
149 /// Return true if input denormals must be implicitly treated as 0.
150 constexpr bool inputsAreZero() const {
151 return Input == DenormalModeKind::PreserveSign ||
152 Input == DenormalModeKind::PositiveZero;
153 }
154
155 /// Return true if output denormals should be flushed to 0.
156 constexpr bool outputsAreZero() const {
157 return Output == DenormalModeKind::PreserveSign ||
158 Output == DenormalModeKind::PositiveZero;
159 }
160
161 /// Get the effective denormal mode if the mode if this caller calls into a
162 /// function with \p Callee. This promotes dynamic modes to the mode of the
163 /// caller.
164 DenormalMode mergeCalleeMode(DenormalMode Callee) const {
165 DenormalMode MergedMode = Callee;
166 if (Callee.Input == DenormalMode::Dynamic)
167 MergedMode.Input = Input;
168 if (Callee.Output == DenormalMode::Dynamic)
169 MergedMode.Output = Output;
170 return MergedMode;
171 }
172
173 inline void print(raw_ostream &OS) const;
174
175 inline std::string str() const {
176 std::string storage;
177 raw_string_ostream OS(storage);
178 print(OS);
179 return OS.str();
180 }
181};
182
183inline raw_ostream& operator<<(raw_ostream &OS, DenormalMode Mode) {
184 Mode.print(OS);
185 return OS;
186}
187
188/// Parse the expected names from the denormal-fp-math attribute.
189inline DenormalMode::DenormalModeKind
190parseDenormalFPAttributeComponent(StringRef Str) {
191 // Assume ieee on unspecified attribute.
192 return StringSwitch<DenormalMode::DenormalModeKind>(Str)
193 .Cases(S0: "", S1: "ieee", Value: DenormalMode::IEEE)
194 .Case(S: "preserve-sign", Value: DenormalMode::PreserveSign)
195 .Case(S: "positive-zero", Value: DenormalMode::PositiveZero)
196 .Case(S: "dynamic", Value: DenormalMode::Dynamic)
197 .Default(Value: DenormalMode::Invalid);
198}
199
200/// Return the name used for the denormal handling mode used by the
201/// expected names from the denormal-fp-math attribute.
202inline StringRef denormalModeKindName(DenormalMode::DenormalModeKind Mode) {
203 switch (Mode) {
204 case DenormalMode::IEEE:
205 return "ieee";
206 case DenormalMode::PreserveSign:
207 return "preserve-sign";
208 case DenormalMode::PositiveZero:
209 return "positive-zero";
210 case DenormalMode::Dynamic:
211 return "dynamic";
212 default:
213 return "";
214 }
215}
216
217/// Returns the denormal mode to use for inputs and outputs.
218inline DenormalMode parseDenormalFPAttribute(StringRef Str) {
219 StringRef OutputStr, InputStr;
220 std::tie(args&: OutputStr, args&: InputStr) = Str.split(Separator: ',');
221
222 DenormalMode Mode;
223 Mode.Output = parseDenormalFPAttributeComponent(Str: OutputStr);
224
225 // Maintain compatibility with old form of the attribute which only specified
226 // one component.
227 Mode.Input = InputStr.empty() ? Mode.Output :
228 parseDenormalFPAttributeComponent(Str: InputStr);
229
230 return Mode;
231}
232
233void DenormalMode::print(raw_ostream &OS) const {
234 OS << denormalModeKindName(Mode: Output) << ',' << denormalModeKindName(Mode: Input);
235}
236
237/// Floating-point class tests, supported by 'is_fpclass' intrinsic. Actual
238/// test may be an OR combination of basic tests.
239enum FPClassTest : unsigned {
240 fcNone = 0,
241
242 fcSNan = 0x0001,
243 fcQNan = 0x0002,
244 fcNegInf = 0x0004,
245 fcNegNormal = 0x0008,
246 fcNegSubnormal = 0x0010,
247 fcNegZero = 0x0020,
248 fcPosZero = 0x0040,
249 fcPosSubnormal = 0x0080,
250 fcPosNormal = 0x0100,
251 fcPosInf = 0x0200,
252
253 fcNan = fcSNan | fcQNan,
254 fcInf = fcPosInf | fcNegInf,
255 fcNormal = fcPosNormal | fcNegNormal,
256 fcSubnormal = fcPosSubnormal | fcNegSubnormal,
257 fcZero = fcPosZero | fcNegZero,
258 fcPosFinite = fcPosNormal | fcPosSubnormal | fcPosZero,
259 fcNegFinite = fcNegNormal | fcNegSubnormal | fcNegZero,
260 fcFinite = fcPosFinite | fcNegFinite,
261 fcPositive = fcPosFinite | fcPosInf,
262 fcNegative = fcNegFinite | fcNegInf,
263
264 fcAllFlags = fcNan | fcInf | fcFinite,
265};
266
267LLVM_DECLARE_ENUM_AS_BITMASK(FPClassTest, /* LargestValue */ fcPosInf);
268
269/// Return the test mask which returns true if the value's sign bit is flipped.
270FPClassTest fneg(FPClassTest Mask);
271
272/// Return the test mask which returns true after fabs is applied to the value.
273FPClassTest inverse_fabs(FPClassTest Mask);
274
275/// Return the test mask which returns true if the value could have the same set
276/// of classes, but with a different sign.
277FPClassTest unknown_sign(FPClassTest Mask);
278
279/// Write a human readable form of \p Mask to \p OS
280raw_ostream &operator<<(raw_ostream &OS, FPClassTest Mask);
281
282} // namespace llvm
283
284#endif // LLVM_ADT_FLOATINGPOINTMODE_H
285

source code of llvm/include/llvm/ADT/FloatingPointMode.h