1 /* Definitions for simple data type for real numbers. 2 Copyright (C) 2002-2018 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 /* SREAL_PART_BITS has to be an even number. */ 24 #define SREAL_PART_BITS 32 25 26 #define UINT64_BITS 64 27 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) 31 32 #define SREAL_BITS SREAL_PART_BITS 33 34 #define SREAL_SIGN(v) (v < 0 ? -1: 1) 35 #define SREAL_ABS(v) (v < 0 ? -v: v) 36 37 struct output_block; 38 struct lto_input_block; 39 40 /* Structure for holding a simple real number. */ 41 class sreal 42 { 43 public: 44 /* Construct an uninitialized sreal. */ 45 sreal () : m_sig (-1), m_exp (-1) {} 46 47 /* Construct a sreal. */ 48 sreal (int64_t sig, int exp = 0) : m_sig (sig), m_exp (exp) 49 { 50 normalize (); 51 } 52 53 void dump (FILE *) const; 54 int64_t to_int () const; 55 double to_double () const; 56 void stream_out (struct output_block *); 57 static sreal stream_in (struct 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 (); 134 inline void normalize_up (); 135 inline void normalize_down (); 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 int64_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 (exp); 190 } 191 192 inline sreal operator>> (const sreal &a, int exp) 193 { 194 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 sreal::normalize_up () 203 { 204 unsigned HOST_WIDE_INT sig = absu_hwi (m_sig); 205 int shift = SREAL_PART_BITS - 2 - floor_log2 (sig); 206 207 gcc_checking_assert (shift > 0); 208 sig <<= shift; 209 m_exp -= shift; 210 gcc_checking_assert (sig <= SREAL_MAX_SIG && sig >= SREAL_MIN_SIG); 211 212 /* Check underflow. */ 213 if (m_exp < -SREAL_MAX_EXP) 214 { 215 m_exp = -SREAL_MAX_EXP; 216 sig = 0; 217 } 218 if (SREAL_SIGN (m_sig) == -1) 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 229 sreal::normalize_down () 230 { 231 int last_bit; 232 unsigned HOST_WIDE_INT sig = absu_hwi (m_sig); 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; 238 m_exp += shift; 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; 246 m_exp++; 247 } 248 249 /* Check overflow. */ 250 if (m_exp > SREAL_MAX_EXP) 251 { 252 m_exp = SREAL_MAX_EXP; 253 sig = SREAL_MAX_SIG; 254 } 255 if (SREAL_SIGN (m_sig) == -1) 256 m_sig = -sig; 257 else 258 m_sig = sig; 259 } 260 261 /* Normalize *this; the hot path. */ 262 263 inline void 264 sreal::normalize () 265 { 266 unsigned HOST_WIDE_INT sig = absu_hwi (m_sig); 267 268 if (sig == 0) 269 m_exp = -SREAL_MAX_EXP; 270 else if (sig > SREAL_MAX_SIG) 271 normalize_down (); 272 else if (sig < SREAL_MIN_SIG) 273 normalize_up (); 274 } 275 276 #endif 277