1/* Definitions for simple data type for real numbers. 2 Copyright (C) 2002-2020 Free Software Foundation, Inc. 3 4This file is part of GCC. 5 6GCC is free software; you can redistribute it and/or modify it under 7the terms of the GNU General Public License as published by the Free 8Software Foundation; either version 3, or (at your option) any later 9version. 10 11GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12WARRANTY; without even the implied warranty of MERCHANTABILITY or 13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14for more details. 15 16You should have received a copy of the GNU General Public License 17along 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 36struct output_block; 37class lto_input_block; 38 39/* Structure for holding a simple real number. */ 40class sreal 41{ 42public: 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 (sig, exp); 50 } 51 52 void dump (FILE *) const; 53 int64_t to_int () const; 54 double to_double () const; 55 void stream_out (struct output_block *); 56 static sreal stream_in (class lto_input_block *); 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 { 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 } 77 } 78 79 bool operator== (const sreal &other) const 80 { 81 return m_exp == other.m_exp && m_sig == other.m_sig; 82 } 83 84 sreal operator- () const 85 { 86 sreal tmp = *this; 87 tmp.m_sig *= -1; 88 89 return tmp; 90 } 91 92 sreal shift (int s) const 93 { 94 /* Zero needs no shifting. */ 95 if (!m_sig) 96 return *this; 97 gcc_checking_assert (s <= SREAL_MAX_EXP); 98 gcc_checking_assert (s >= -SREAL_MAX_EXP); 99 100 /* Overflows/drop to 0 could be handled gracefully, but hopefully we do not 101 need to do so. */ 102 gcc_checking_assert (m_exp + s <= SREAL_MAX_EXP); 103 gcc_checking_assert (m_exp + s >= -SREAL_MAX_EXP); 104 105 sreal tmp = *this; 106 tmp.m_exp += s; 107 108 return tmp; 109 } 110 111 /* Global minimum sreal can hold. */ 112 inline static sreal min () 113 { 114 sreal min; 115 /* This never needs normalization. */ 116 min.m_sig = -SREAL_MAX_SIG; 117 min.m_exp = SREAL_MAX_EXP; 118 return min; 119 } 120 121 /* Global minimum sreal can hold. */ 122 inline static sreal max () 123 { 124 sreal max; 125 /* This never needs normalization. */ 126 max.m_sig = SREAL_MAX_SIG; 127 max.m_exp = SREAL_MAX_EXP; 128 return max; 129 } 130 131private: 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); 135 void shift_right (int amount); 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 139 int32_t m_sig; /* Significant. */ 140 signed int m_exp; /* Exponent. */ 141}; 142 143extern void debug (const sreal &ref); 144extern void debug (const sreal *ptr); 145 146inline sreal &operator+= (sreal &a, const sreal &b) 147{ 148 return a = a + b; 149} 150 151inline sreal &operator-= (sreal &a, const sreal &b) 152{ 153 return a = a - b; 154} 155 156inline sreal &operator/= (sreal &a, const sreal &b) 157{ 158 return a = a / b; 159} 160 161inline sreal &operator*= (sreal &a, const sreal &b) 162{ 163 return a = a * b; 164} 165 166inline bool operator!= (const sreal &a, const sreal &b) 167{ 168 return !(a == b); 169} 170 171inline bool operator> (const sreal &a, const sreal &b) 172{ 173 return !(a == b || a < b); 174} 175 176inline bool operator<= (const sreal &a, const sreal &b) 177{ 178 return a < b || a == b; 179} 180 181inline bool operator>= (const sreal &a, const sreal &b) 182{ 183 return a == b || a > b; 184} 185 186inline sreal operator<< (const sreal &a, int exp) 187{ 188 return a.shift (exp); 189} 190 191inline sreal operator>> (const sreal &a, int exp) 192{ 193 return a.shift (-exp); 194} 195 196/* Make significant to be >= SREAL_MIN_SIG. 197 198 Make this separate method so inliner can handle hot path better. */ 199 200inline void 201sreal::normalize_up (int64_t new_sig, signed int new_exp) 202{ 203 unsigned HOST_WIDE_INT sig = absu_hwi (new_sig); 204 int shift = SREAL_PART_BITS - 2 - floor_log2 (sig); 205 206 gcc_checking_assert (shift > 0); 207 sig <<= shift; 208 new_exp -= shift; 209 gcc_checking_assert (sig <= SREAL_MAX_SIG && sig >= SREAL_MIN_SIG); 210 211 /* Check underflow. */ 212 if (new_exp < -SREAL_MAX_EXP) 213 { 214 new_exp = -SREAL_MAX_EXP; 215 sig = 0; 216 } 217 m_exp = new_exp; 218 if (SREAL_SIGN (new_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 228inline void 229sreal::normalize_down (int64_t new_sig, signed int new_exp) 230{ 231 int last_bit; 232 unsigned HOST_WIDE_INT sig = absu_hwi (new_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 new_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 new_exp++; 247 } 248 249 /* Check overflow. */ 250 if (new_exp > SREAL_MAX_EXP) 251 { 252 new_exp = SREAL_MAX_EXP; 253 sig = SREAL_MAX_SIG; 254 } 255 m_exp = new_exp; 256 if (SREAL_SIGN (new_sig) == -1) 257 m_sig = -sig; 258 else 259 m_sig = sig; 260} 261 262/* Normalize *this; the hot path. */ 263 264inline void 265sreal::normalize (int64_t new_sig, signed int new_exp) 266{ 267 unsigned HOST_WIDE_INT sig = absu_hwi (new_sig); 268 269 if (sig == 0) 270 { 271 m_sig = 0; 272 m_exp = -SREAL_MAX_EXP; 273 } 274 else if (sig > SREAL_MAX_SIG) 275 normalize_down (new_sig, new_exp); 276 else if (sig < SREAL_MIN_SIG) 277 normalize_up (new_sig, new_exp); 278 else 279 { 280 m_sig = new_sig; 281 m_exp = new_exp; 282 } 283} 284 285#endif 286