]>
Commit | Line | Data |
---|---|---|
8201d1f6 | 1 | /* Definitions for simple data type for real numbers. |
fbd26352 | 2 | Copyright (C) 2002-2019 Free Software Foundation, Inc. |
e9d7220b | 3 | |
4 | This file is part of GCC. | |
5 | ||
6 | GCC is free software; you can redistribute it and/or modify it under | |
7 | the terms of the GNU General Public License as published by the Free | |
8c4c00c1 | 8 | Software Foundation; either version 3, or (at your option) any later |
e9d7220b | 9 | version. |
10 | ||
11 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
12 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
13 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
14 | for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
8c4c00c1 | 17 | along with GCC; see the file COPYING3. If not see |
18 | <http://www.gnu.org/licenses/>. */ | |
e9d7220b | 19 | |
20 | #ifndef GCC_SREAL_H | |
21 | #define GCC_SREAL_H | |
22 | ||
e8a89d32 | 23 | #define SREAL_PART_BITS 31 |
e9d7220b | 24 | |
8201d1f6 | 25 | #define UINT64_BITS 64 |
26 | ||
b0410238 | 27 | #define SREAL_MIN_SIG ((int64_t) 1 << (SREAL_PART_BITS - 2)) |
28 | #define SREAL_MAX_SIG (((int64_t) 1 << (SREAL_PART_BITS - 1)) - 1) | |
e9d7220b | 29 | #define SREAL_MAX_EXP (INT_MAX / 4) |
30 | ||
e9d7220b | 31 | #define SREAL_BITS SREAL_PART_BITS |
e9d7220b | 32 | |
8d022ef4 | 33 | #define SREAL_SIGN(v) (v < 0 ? -1: 1) |
34 | #define SREAL_ABS(v) (v < 0 ? -v: v) | |
35 | ||
50b1eab3 | 36 | struct output_block; |
2e966e2a | 37 | class lto_input_block; |
50b1eab3 | 38 | |
e9d7220b | 39 | /* Structure for holding a simple real number. */ |
23a92fc7 | 40 | class sreal |
e9d7220b | 41 | { |
23a92fc7 | 42 | public: |
43 | /* Construct an uninitialized sreal. */ | |
b0410238 | 44 | sreal () : m_sig (-1), m_exp (-1) {} |
23a92fc7 | 45 | |
46 | /* Construct a sreal. */ | |
6784be9e | 47 | sreal (int64_t sig, int exp = 0) |
8201d1f6 | 48 | { |
6784be9e | 49 | normalize (sig, exp); |
8201d1f6 | 50 | } |
23a92fc7 | 51 | |
52 | void dump (FILE *) const; | |
53 | int64_t to_int () const; | |
eb9db6ce | 54 | double to_double () const; |
50b1eab3 | 55 | void stream_out (struct output_block *); |
2e966e2a | 56 | static sreal stream_in (class lto_input_block *); |
23a92fc7 | 57 | sreal operator+ (const sreal &other) const; |
58 | sreal operator- (const sreal &other) const; | |
59 | sreal operator* (const sreal &other) const; | |
60 | sreal operator/ (const sreal &other) const; | |
61 | ||
62 | bool operator< (const sreal &other) const | |
63 | { | |
b0410238 | 64 | if (m_exp == other.m_exp) |
65 | return m_sig < other.m_sig; | |
66 | else | |
67 | { | |
68 | bool negative = m_sig < 0; | |
69 | bool other_negative = other.m_sig < 0; | |
70 | ||
71 | if (negative != other_negative) | |
72 | return negative > other_negative; | |
73 | ||
74 | bool r = m_exp < other.m_exp; | |
75 | return negative ? !r : r; | |
76 | } | |
23a92fc7 | 77 | } |
78 | ||
79 | bool operator== (const sreal &other) const | |
80 | { | |
b0410238 | 81 | return m_exp == other.m_exp && m_sig == other.m_sig; |
8201d1f6 | 82 | } |
83 | ||
84 | sreal operator- () const | |
85 | { | |
8201d1f6 | 86 | sreal tmp = *this; |
b0410238 | 87 | tmp.m_sig *= -1; |
8201d1f6 | 88 | |
89 | return tmp; | |
90 | } | |
91 | ||
e90b28a5 | 92 | sreal shift (int s) const |
8201d1f6 | 93 | { |
eb9db6ce | 94 | /* Zero needs no shifting. */ |
95 | if (!m_sig) | |
96 | return *this; | |
09196675 | 97 | gcc_checking_assert (s <= SREAL_MAX_EXP); |
98 | gcc_checking_assert (s >= -SREAL_MAX_EXP); | |
e90b28a5 | 99 | |
eb9db6ce | 100 | /* Overflows/drop to 0 could be handled gracefully, but hopefully we do not |
101 | need to do so. */ | |
e90b28a5 | 102 | gcc_checking_assert (m_exp + s <= SREAL_MAX_EXP); |
103 | gcc_checking_assert (m_exp + s >= -SREAL_MAX_EXP); | |
104 | ||
8201d1f6 | 105 | sreal tmp = *this; |
e90b28a5 | 106 | tmp.m_exp += s; |
8201d1f6 | 107 | |
108 | return tmp; | |
109 | } | |
110 | ||
111 | /* Global minimum sreal can hold. */ | |
112 | inline static sreal min () | |
113 | { | |
ce7bcd95 | 114 | sreal min; |
115 | /* This never needs normalization. */ | |
116 | min.m_sig = -SREAL_MAX_SIG; | |
117 | min.m_exp = SREAL_MAX_EXP; | |
8201d1f6 | 118 | return min; |
119 | } | |
120 | ||
121 | /* Global minimum sreal can hold. */ | |
122 | inline static sreal max () | |
123 | { | |
ce7bcd95 | 124 | sreal max; |
125 | /* This never needs normalization. */ | |
126 | max.m_sig = SREAL_MAX_SIG; | |
127 | max.m_exp = SREAL_MAX_EXP; | |
8201d1f6 | 128 | return max; |
23a92fc7 | 129 | } |
130 | ||
131 | private: | |
6784be9e | 132 | inline void normalize (int64_t new_sig, signed int new_exp); |
133 | inline void normalize_up (int64_t new_sig, signed int new_exp); | |
134 | inline void normalize_down (int64_t new_sig, signed int new_exp); | |
23a92fc7 | 135 | void shift_right (int amount); |
8201d1f6 | 136 | static sreal signedless_plus (const sreal &a, const sreal &b, bool negative); |
137 | static sreal signedless_minus (const sreal &a, const sreal &b, bool negative); | |
138 | ||
e8a89d32 | 139 | int32_t m_sig; /* Significant. */ |
23a92fc7 | 140 | signed int m_exp; /* Exponent. */ |
b3e7c666 | 141 | }; |
e9d7220b | 142 | |
b0410238 | 143 | extern void debug (const sreal &ref); |
144 | extern void debug (const sreal *ptr); | |
23a92fc7 | 145 | |
146 | inline sreal &operator+= (sreal &a, const sreal &b) | |
147 | { | |
148 | return a = a + b; | |
149 | } | |
150 | ||
151 | inline sreal &operator-= (sreal &a, const sreal &b) | |
152 | { | |
8201d1f6 | 153 | return a = a - b; |
23a92fc7 | 154 | } |
155 | ||
156 | inline sreal &operator/= (sreal &a, const sreal &b) | |
157 | { | |
8201d1f6 | 158 | return a = a / b; |
23a92fc7 | 159 | } |
160 | ||
161 | inline sreal &operator*= (sreal &a, const sreal &b) | |
162 | { | |
163 | return a = a * b; | |
164 | } | |
165 | ||
166 | inline bool operator!= (const sreal &a, const sreal &b) | |
167 | { | |
168 | return !(a == b); | |
169 | } | |
170 | ||
171 | inline bool operator> (const sreal &a, const sreal &b) | |
172 | { | |
173 | return !(a == b || a < b); | |
174 | } | |
175 | ||
176 | inline bool operator<= (const sreal &a, const sreal &b) | |
177 | { | |
178 | return a < b || a == b; | |
179 | } | |
180 | ||
181 | inline bool operator>= (const sreal &a, const sreal &b) | |
182 | { | |
183 | return a == b || a > b; | |
184 | } | |
e9d7220b | 185 | |
8201d1f6 | 186 | inline sreal operator<< (const sreal &a, int exp) |
187 | { | |
188 | return a.shift (exp); | |
189 | } | |
190 | ||
191 | inline sreal operator>> (const sreal &a, int exp) | |
192 | { | |
193 | return a.shift (-exp); | |
194 | } | |
195 | ||
53164e87 | 196 | /* Make significant to be >= SREAL_MIN_SIG. |
197 | ||
198 | Make this separate method so inliner can handle hot path better. */ | |
199 | ||
200 | inline void | |
6784be9e | 201 | sreal::normalize_up (int64_t new_sig, signed int new_exp) |
53164e87 | 202 | { |
6784be9e | 203 | unsigned HOST_WIDE_INT sig = absu_hwi (new_sig); |
53164e87 | 204 | int shift = SREAL_PART_BITS - 2 - floor_log2 (sig); |
205 | ||
206 | gcc_checking_assert (shift > 0); | |
207 | sig <<= shift; | |
6784be9e | 208 | new_exp -= shift; |
53164e87 | 209 | gcc_checking_assert (sig <= SREAL_MAX_SIG && sig >= SREAL_MIN_SIG); |
210 | ||
211 | /* Check underflow. */ | |
6784be9e | 212 | if (new_exp < -SREAL_MAX_EXP) |
53164e87 | 213 | { |
6784be9e | 214 | new_exp = -SREAL_MAX_EXP; |
53164e87 | 215 | sig = 0; |
216 | } | |
6784be9e | 217 | m_exp = new_exp; |
218 | if (SREAL_SIGN (new_sig) == -1) | |
53164e87 | 219 | m_sig = -sig; |
220 | else | |
221 | m_sig = sig; | |
222 | } | |
223 | ||
224 | /* Make significant to be <= SREAL_MAX_SIG. | |
225 | ||
226 | Make this separate method so inliner can handle hot path better. */ | |
227 | ||
228 | inline void | |
6784be9e | 229 | sreal::normalize_down (int64_t new_sig, signed int new_exp) |
53164e87 | 230 | { |
53164e87 | 231 | int last_bit; |
6784be9e | 232 | unsigned HOST_WIDE_INT sig = absu_hwi (new_sig); |
53164e87 | 233 | int shift = floor_log2 (sig) - SREAL_PART_BITS + 2; |
234 | ||
235 | gcc_checking_assert (shift > 0); | |
236 | last_bit = (sig >> (shift-1)) & 1; | |
237 | sig >>= shift; | |
6784be9e | 238 | new_exp += shift; |
53164e87 | 239 | gcc_checking_assert (sig <= SREAL_MAX_SIG && sig >= SREAL_MIN_SIG); |
240 | ||
241 | /* Round the number. */ | |
242 | sig += last_bit; | |
243 | if (sig > SREAL_MAX_SIG) | |
244 | { | |
245 | sig >>= 1; | |
6784be9e | 246 | new_exp++; |
53164e87 | 247 | } |
248 | ||
249 | /* Check overflow. */ | |
6784be9e | 250 | if (new_exp > SREAL_MAX_EXP) |
53164e87 | 251 | { |
6784be9e | 252 | new_exp = SREAL_MAX_EXP; |
53164e87 | 253 | sig = SREAL_MAX_SIG; |
254 | } | |
6784be9e | 255 | m_exp = new_exp; |
256 | if (SREAL_SIGN (new_sig) == -1) | |
53164e87 | 257 | m_sig = -sig; |
258 | else | |
259 | m_sig = sig; | |
260 | } | |
261 | ||
262 | /* Normalize *this; the hot path. */ | |
263 | ||
264 | inline void | |
6784be9e | 265 | sreal::normalize (int64_t new_sig, signed int new_exp) |
53164e87 | 266 | { |
6784be9e | 267 | unsigned HOST_WIDE_INT sig = absu_hwi (new_sig); |
53164e87 | 268 | |
269 | if (sig == 0) | |
6784be9e | 270 | { |
271 | m_sig = 0; | |
272 | m_exp = -SREAL_MAX_EXP; | |
273 | } | |
53164e87 | 274 | else if (sig > SREAL_MAX_SIG) |
6784be9e | 275 | normalize_down (new_sig, new_exp); |
53164e87 | 276 | else if (sig < SREAL_MIN_SIG) |
6784be9e | 277 | normalize_up (new_sig, new_exp); |
278 | else | |
279 | { | |
280 | m_sig = new_sig; | |
281 | m_exp = new_exp; | |
282 | } | |
53164e87 | 283 | } |
284 | ||
e9d7220b | 285 | #endif |