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