cp/
[official-gcc.git] / gcc / sreal.h
blobfcb0322295d410ee9bba9a24d8a74fecc4eae7e7
1 /* Definitions for simple data type for real numbers.
2 Copyright (C) 2002-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
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.
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.
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/>. */
20 #ifndef GCC_SREAL_H
21 #define GCC_SREAL_H
23 /* SREAL_PART_BITS has to be an even number. */
24 #define SREAL_PART_BITS 32
26 #define UINT64_BITS 64
28 #define SREAL_MIN_SIG ((int64_t) 1 << (SREAL_PART_BITS - 2))
29 #define SREAL_MAX_SIG (((int64_t) 1 << (SREAL_PART_BITS - 1)) - 1)
30 #define SREAL_MAX_EXP (INT_MAX / 4)
32 #define SREAL_BITS SREAL_PART_BITS
34 /* Structure for holding a simple real number. */
35 class sreal
37 public:
38 /* Construct an uninitialized sreal. */
39 sreal () : m_sig (-1), m_exp (-1) {}
41 /* Construct a sreal. */
42 sreal (int64_t sig, int exp = 0) : m_sig (sig), m_exp (exp)
44 normalize ();
47 void dump (FILE *) const;
48 int64_t to_int () const;
49 double to_double () const;
50 sreal operator+ (const sreal &other) const;
51 sreal operator- (const sreal &other) const;
52 sreal operator* (const sreal &other) const;
53 sreal operator/ (const sreal &other) const;
55 bool operator< (const sreal &other) const
57 if (m_exp == other.m_exp)
58 return m_sig < other.m_sig;
59 else
61 bool negative = m_sig < 0;
62 bool other_negative = other.m_sig < 0;
64 if (negative != other_negative)
65 return negative > other_negative;
67 bool r = m_exp < other.m_exp;
68 return negative ? !r : r;
72 bool operator== (const sreal &other) const
74 return m_exp == other.m_exp && m_sig == other.m_sig;
77 sreal operator- () const
79 sreal tmp = *this;
80 tmp.m_sig *= -1;
82 return tmp;
85 sreal shift (int s) const
87 /* Zero needs no shifting. */
88 if (!m_sig)
89 return *this;
90 gcc_checking_assert (s <= SREAL_MAX_EXP);
91 gcc_checking_assert (s >= -SREAL_MAX_EXP);
93 /* Overflows/drop to 0 could be handled gracefully, but hopefully we do not
94 need to do so. */
95 gcc_checking_assert (m_exp + s <= SREAL_MAX_EXP);
96 gcc_checking_assert (m_exp + s >= -SREAL_MAX_EXP);
98 sreal tmp = *this;
99 tmp.m_exp += s;
101 return tmp;
104 /* Global minimum sreal can hold. */
105 inline static sreal min ()
107 static sreal min = sreal (-SREAL_MAX_SIG, SREAL_MAX_EXP);
108 return min;
111 /* Global minimum sreal can hold. */
112 inline static sreal max ()
114 static sreal max = sreal (SREAL_MAX_SIG, SREAL_MAX_EXP);
115 return max;
118 private:
119 inline void normalize ();
120 inline void normalize_up ();
121 inline void normalize_down ();
122 void shift_right (int amount);
123 static sreal signedless_plus (const sreal &a, const sreal &b, bool negative);
124 static sreal signedless_minus (const sreal &a, const sreal &b, bool negative);
126 int64_t m_sig; /* Significant. */
127 signed int m_exp; /* Exponent. */
130 extern void debug (const sreal &ref);
131 extern void debug (const sreal *ptr);
133 inline sreal &operator+= (sreal &a, const sreal &b)
135 return a = a + b;
138 inline sreal &operator-= (sreal &a, const sreal &b)
140 return a = a - b;
143 inline sreal &operator/= (sreal &a, const sreal &b)
145 return a = a / b;
148 inline sreal &operator*= (sreal &a, const sreal &b)
150 return a = a * b;
153 inline bool operator!= (const sreal &a, const sreal &b)
155 return !(a == b);
158 inline bool operator> (const sreal &a, const sreal &b)
160 return !(a == b || a < b);
163 inline bool operator<= (const sreal &a, const sreal &b)
165 return a < b || a == b;
168 inline bool operator>= (const sreal &a, const sreal &b)
170 return a == b || a > b;
173 inline sreal operator<< (const sreal &a, int exp)
175 return a.shift (exp);
178 inline sreal operator>> (const sreal &a, int exp)
180 return a.shift (-exp);
183 /* Make significant to be >= SREAL_MIN_SIG.
185 Make this separate method so inliner can handle hot path better. */
187 inline void
188 sreal::normalize_up ()
190 int64_t s = m_sig < 0 ? -1 : 1;
191 unsigned HOST_WIDE_INT sig = absu_hwi (m_sig);
192 int shift = SREAL_PART_BITS - 2 - floor_log2 (sig);
194 gcc_checking_assert (shift > 0);
195 sig <<= shift;
196 m_exp -= shift;
197 gcc_checking_assert (sig <= SREAL_MAX_SIG && sig >= SREAL_MIN_SIG);
199 /* Check underflow. */
200 if (m_exp < -SREAL_MAX_EXP)
202 m_exp = -SREAL_MAX_EXP;
203 sig = 0;
205 if (s == -1)
206 m_sig = -sig;
207 else
208 m_sig = sig;
211 /* Make significant to be <= SREAL_MAX_SIG.
213 Make this separate method so inliner can handle hot path better. */
215 inline void
216 sreal::normalize_down ()
218 int64_t s = m_sig < 0 ? -1 : 1;
219 int last_bit;
220 unsigned HOST_WIDE_INT sig = absu_hwi (m_sig);
221 int shift = floor_log2 (sig) - SREAL_PART_BITS + 2;
223 gcc_checking_assert (shift > 0);
224 last_bit = (sig >> (shift-1)) & 1;
225 sig >>= shift;
226 m_exp += shift;
227 gcc_checking_assert (sig <= SREAL_MAX_SIG && sig >= SREAL_MIN_SIG);
229 /* Round the number. */
230 sig += last_bit;
231 if (sig > SREAL_MAX_SIG)
233 sig >>= 1;
234 m_exp++;
237 /* Check overflow. */
238 if (m_exp > SREAL_MAX_EXP)
240 m_exp = SREAL_MAX_EXP;
241 sig = SREAL_MAX_SIG;
243 if (s == -1)
244 m_sig = -sig;
245 else
246 m_sig = sig;
249 /* Normalize *this; the hot path. */
251 inline void
252 sreal::normalize ()
254 unsigned HOST_WIDE_INT sig = absu_hwi (m_sig);
256 if (sig == 0)
257 m_exp = -SREAL_MAX_EXP;
258 else if (sig > SREAL_MAX_SIG)
259 normalize_down ();
260 else if (sig < SREAL_MIN_SIG)
261 normalize_up ();
264 #endif