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