Branch data Line data Source code
1 : : /* Definitions for simple data type for real numbers.
2 : : Copyright (C) 2002-2025 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 : 1670985744 : sreal () : m_sig (-1), m_exp (-1) {}
45 : :
46 : : /* Construct a sreal. */
47 : 3148430808 : sreal (int64_t sig, int exp = 0)
48 : 3148430808 : {
49 : 2698460915 : normalize (sig, exp);
50 : 2034624 : }
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 : 590939205 : bool operator< (const sreal &other) const
64 : : {
65 : 590939205 : if (m_exp == other.m_exp)
66 : 34586684 : return m_sig < other.m_sig;
67 : : else
68 : : {
69 : 556352521 : bool negative = m_sig < 0;
70 : 556352521 : bool other_negative = other.m_sig < 0;
71 : :
72 : 556352521 : if (negative != other_negative)
73 : 38950006 : return negative > other_negative;
74 : :
75 : 517402515 : bool r = m_exp < other.m_exp;
76 : 517402515 : return negative ? !r : r;
77 : : }
78 : : }
79 : :
80 : 1072717848 : bool operator== (const sreal &other) const
81 : : {
82 : 255034795 : return m_exp == other.m_exp && m_sig == other.m_sig;
83 : : }
84 : :
85 : 10331592 : sreal operator- () const
86 : : {
87 : 10331592 : sreal tmp = *this;
88 : 10331592 : tmp.m_sig *= -1;
89 : :
90 : 10331592 : return tmp;
91 : : }
92 : :
93 : 61567536 : sreal shift (int s) const
94 : : {
95 : : /* Zero needs no shifting. */
96 : 61567536 : if (!m_sig)
97 : 5805919 : return *this;
98 : 55761617 : gcc_checking_assert (s <= SREAL_MAX_EXP);
99 : 55761617 : 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 : 55761617 : gcc_checking_assert (m_exp + s <= SREAL_MAX_EXP);
104 : 55761617 : gcc_checking_assert (m_exp + s >= -SREAL_MAX_EXP);
105 : :
106 : 55761617 : sreal tmp = *this;
107 : 55761617 : tmp.m_exp += s;
108 : :
109 : 55761617 : return tmp;
110 : : }
111 : :
112 : : /* Global minimum sreal can hold. */
113 : 1235549 : inline static sreal min ()
114 : : {
115 : 1235549 : sreal min;
116 : : /* This never needs normalization. */
117 : 1235549 : min.m_sig = -SREAL_MAX_SIG;
118 : 1235549 : min.m_exp = SREAL_MAX_EXP;
119 : 1235549 : return min;
120 : : }
121 : :
122 : : /* Global minimum sreal can hold. */
123 : 3020791 : inline static sreal max ()
124 : : {
125 : 3020791 : sreal max;
126 : : /* This never needs normalization. */
127 : 3020791 : max.m_sig = SREAL_MAX_SIG;
128 : 3020791 : max.m_exp = SREAL_MAX_EXP;
129 : 508079 : 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 : 651096043 : inline sreal &operator+= (sreal &a, const sreal &b)
148 : : {
149 : 649611440 : return a = a + b;
150 : : }
151 : :
152 : 448491 : inline sreal &operator-= (sreal &a, const sreal &b)
153 : : {
154 : 448491 : return a = a - b;
155 : : }
156 : :
157 : 459077 : inline sreal &operator/= (sreal &a, const sreal &b)
158 : : {
159 : 459077 : return a = a / b;
160 : : }
161 : :
162 : 18372436 : inline sreal &operator*= (sreal &a, const sreal &b)
163 : : {
164 : 18372436 : return a = a * b;
165 : : }
166 : :
167 : 67311036 : inline bool operator!= (const sreal &a, const sreal &b)
168 : : {
169 : 117666847 : return !(a == b);
170 : : }
171 : :
172 : 434357765 : inline bool operator> (const sreal &a, const sreal &b)
173 : : {
174 : 448262323 : return !(a == b || a < b);
175 : : }
176 : :
177 : 12507061 : inline bool operator<= (const sreal &a, const sreal &b)
178 : : {
179 : 12507061 : return a < b || a == b;
180 : : }
181 : :
182 : 482219416 : inline bool operator>= (const sreal &a, const sreal &b)
183 : : {
184 : 484079361 : return a == b || a > b;
185 : : }
186 : :
187 : 3013224 : inline sreal operator<< (const sreal &a, int exp)
188 : : {
189 : 3013224 : return a.shift (exp);
190 : : }
191 : :
192 : 48651410 : inline sreal operator>> (const sreal &a, int exp)
193 : : {
194 : 48651410 : return a.shift (-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 : 1156131080 : sreal::normalize_up (int64_t new_sig, signed int new_exp)
203 : : {
204 : 1156131080 : unsigned HOST_WIDE_INT sig = absu_hwi (new_sig);
205 : 1156131080 : int shift = SREAL_PART_BITS - 2 - floor_log2 (sig);
206 : :
207 : 1156131080 : gcc_checking_assert (shift > 0);
208 : 1156131080 : sig <<= shift;
209 : 1156131080 : new_exp -= shift;
210 : 1156131080 : gcc_checking_assert (sig <= SREAL_MAX_SIG && sig >= SREAL_MIN_SIG);
211 : :
212 : : /* Check underflow. */
213 : 1156131080 : if (new_exp < -SREAL_MAX_EXP)
214 : : {
215 : 0 : new_exp = -SREAL_MAX_EXP;
216 : 0 : sig = 0;
217 : : }
218 : 1156131080 : m_exp = new_exp;
219 : 1156131080 : if (SREAL_SIGN (new_sig) == -1)
220 : 44785313 : m_sig = -sig;
221 : : else
222 : 1111345767 : m_sig = sig;
223 : 1156131080 : }
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 : 960043971 : sreal::normalize_down (int64_t new_sig, signed int new_exp)
231 : : {
232 : 960043971 : int last_bit;
233 : 960043971 : unsigned HOST_WIDE_INT sig = absu_hwi (new_sig);
234 : 960043971 : int shift = floor_log2 (sig) - SREAL_PART_BITS + 2;
235 : :
236 : 960043971 : gcc_checking_assert (shift > 0);
237 : 960043971 : last_bit = (sig >> (shift-1)) & 1;
238 : 960043971 : sig >>= shift;
239 : 960043971 : new_exp += shift;
240 : 960043971 : gcc_checking_assert (sig <= SREAL_MAX_SIG && sig >= SREAL_MIN_SIG);
241 : :
242 : : /* Round the number. */
243 : 960043971 : sig += last_bit;
244 : 960043971 : if (sig > SREAL_MAX_SIG)
245 : : {
246 : 3802608 : sig >>= 1;
247 : 3802608 : new_exp++;
248 : : }
249 : :
250 : : /* Check overflow. */
251 : 960043971 : if (new_exp > SREAL_MAX_EXP)
252 : : {
253 : 0 : new_exp = SREAL_MAX_EXP;
254 : 0 : sig = SREAL_MAX_SIG;
255 : : }
256 : 960043971 : m_exp = new_exp;
257 : 960043971 : if (SREAL_SIGN (new_sig) == -1)
258 : 16711632 : m_sig = -sig;
259 : : else
260 : 943332339 : m_sig = sig;
261 : 960043971 : }
262 : :
263 : : /* Normalize *this; the hot path. */
264 : :
265 : : inline void
266 : 3640174572 : sreal::normalize (int64_t new_sig, signed int new_exp)
267 : : {
268 : 3640174572 : unsigned HOST_WIDE_INT sig = absu_hwi (new_sig);
269 : :
270 : 3640174572 : if (sig == 0)
271 : : {
272 : 1119074997 : m_sig = 0;
273 : 1119074997 : m_exp = -SREAL_MAX_EXP;
274 : : }
275 : 2521099575 : else if (sig > SREAL_MAX_SIG)
276 : 960043971 : normalize_down (new_sig, new_exp);
277 : 1561055604 : else if (sig < SREAL_MIN_SIG)
278 : 1156131080 : normalize_up (new_sig, new_exp);
279 : : else
280 : : {
281 : 404924524 : m_sig = new_sig;
282 : 404924524 : m_exp = new_exp;
283 : : }
284 : 3640174572 : }
285 : :
286 : : #endif
|
