Mercurial > hg > CbC > CbC_gcc
annotate gcc/machmode.h @ 145:1830386684a0
gcc-9.2.0
| author | anatofuz |
|---|---|
| date | Thu, 13 Feb 2020 11:34:05 +0900 |
| parents | 84e7813d76e9 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Machine mode definitions for GCC; included by rtl.h and tree.h. |
| 145 | 2 Copyright (C) 1991-2020 Free Software Foundation, Inc. |
| 0 | 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 HAVE_MACHINE_MODES | |
| 21 #define HAVE_MACHINE_MODES | |
| 22 | |
| 111 | 23 typedef opt_mode<machine_mode> opt_machine_mode; |
| 24 | |
| 131 | 25 extern CONST_MODE_SIZE poly_uint16_pod mode_size[NUM_MACHINE_MODES]; |
| 26 extern CONST_MODE_PRECISION poly_uint16_pod mode_precision[NUM_MACHINE_MODES]; | |
| 111 | 27 extern const unsigned char mode_inner[NUM_MACHINE_MODES]; |
| 131 | 28 extern CONST_MODE_NUNITS poly_uint16_pod mode_nunits[NUM_MACHINE_MODES]; |
| 111 | 29 extern CONST_MODE_UNIT_SIZE unsigned char mode_unit_size[NUM_MACHINE_MODES]; |
| 30 extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES]; | |
| 31 extern const unsigned char mode_wider[NUM_MACHINE_MODES]; | |
| 32 extern const unsigned char mode_2xwider[NUM_MACHINE_MODES]; | |
| 33 | |
| 34 template<typename T> | |
| 35 struct mode_traits | |
| 36 { | |
| 37 /* For use by the machmode support code only. | |
| 38 | |
| 39 There are cases in which the machmode support code needs to forcibly | |
| 40 convert a machine_mode to a specific mode class T, and in which the | |
| 41 context guarantees that this is valid without the need for an assert. | |
| 42 This can be done using: | |
| 43 | |
| 44 return typename mode_traits<T>::from_int (mode); | |
| 45 | |
| 46 when returning a T and: | |
| 47 | |
| 48 res = T (typename mode_traits<T>::from_int (mode)); | |
| 49 | |
| 50 when assigning to a value RES that must be assignment-compatible | |
| 51 with (but possibly not the same as) T. */ | |
| 52 #ifdef USE_ENUM_MODES | |
| 53 /* Allow direct conversion of enums to specific mode classes only | |
| 54 when USE_ENUM_MODES is defined. This is only intended for use | |
| 55 by gencondmd, so that it can tell more easily when .md conditions | |
| 56 are always false. */ | |
| 57 typedef machine_mode from_int; | |
| 58 #else | |
| 59 /* Here we use an enum type distinct from machine_mode but with the | |
| 60 same range as machine_mode. T should have a constructor that | |
| 61 accepts this enum type; it should not have a constructor that | |
| 62 accepts machine_mode. | |
| 63 | |
| 64 We use this somewhat indirect approach to avoid too many constructor | |
| 65 calls when the compiler is built with -O0. For example, even in | |
| 66 unoptimized code, the return statement above would construct the | |
| 67 returned T directly from the numerical value of MODE. */ | |
| 68 enum from_int { dummy = MAX_MACHINE_MODE }; | |
| 69 #endif | |
| 70 }; | |
| 71 | |
| 72 template<> | |
| 73 struct mode_traits<machine_mode> | |
| 74 { | |
| 75 /* machine_mode itself needs no conversion. */ | |
| 76 typedef machine_mode from_int; | |
| 77 }; | |
| 0 | 78 |
| 131 | 79 /* Always treat machine modes as fixed-size while compiling code specific |
| 80 to targets that have no variable-size modes. */ | |
| 81 #if defined (IN_TARGET_CODE) && NUM_POLY_INT_COEFFS == 1 | |
| 82 #define ONLY_FIXED_SIZE_MODES 1 | |
| 83 #else | |
| 84 #define ONLY_FIXED_SIZE_MODES 0 | |
| 85 #endif | |
| 86 | |
| 0 | 87 /* Get the name of mode MODE as a string. */ |
| 88 | |
| 89 extern const char * const mode_name[NUM_MACHINE_MODES]; | |
| 90 #define GET_MODE_NAME(MODE) mode_name[MODE] | |
| 91 | |
| 92 /* Mode classes. */ | |
| 93 | |
| 94 #include "mode-classes.def" | |
| 95 #define DEF_MODE_CLASS(M) M | |
| 96 enum mode_class { MODE_CLASSES, MAX_MODE_CLASS }; | |
| 97 #undef DEF_MODE_CLASS | |
| 98 #undef MODE_CLASSES | |
| 99 | |
| 100 /* Get the general kind of object that mode MODE represents | |
| 101 (integer, floating, complex, etc.) */ | |
| 102 | |
| 103 extern const unsigned char mode_class[NUM_MACHINE_MODES]; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
104 #define GET_MODE_CLASS(MODE) ((enum mode_class) mode_class[MODE]) |
| 0 | 105 |
| 106 /* Nonzero if MODE is an integral mode. */ | |
| 107 #define INTEGRAL_MODE_P(MODE) \ | |
| 108 (GET_MODE_CLASS (MODE) == MODE_INT \ | |
| 109 || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT \ | |
| 110 || GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT \ | |
| 131 | 111 || GET_MODE_CLASS (MODE) == MODE_VECTOR_BOOL \ |
| 0 | 112 || GET_MODE_CLASS (MODE) == MODE_VECTOR_INT) |
| 113 | |
| 114 /* Nonzero if MODE is a floating-point mode. */ | |
| 115 #define FLOAT_MODE_P(MODE) \ | |
| 116 (GET_MODE_CLASS (MODE) == MODE_FLOAT \ | |
| 117 || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT \ | |
| 118 || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \ | |
| 119 || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT) | |
| 120 | |
| 121 /* Nonzero if MODE is a complex mode. */ | |
| 122 #define COMPLEX_MODE_P(MODE) \ | |
| 123 (GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT \ | |
| 124 || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT) | |
| 125 | |
| 126 /* Nonzero if MODE is a vector mode. */ | |
| 131 | 127 #define VECTOR_MODE_P(MODE) \ |
| 128 (GET_MODE_CLASS (MODE) == MODE_VECTOR_BOOL \ | |
| 129 || GET_MODE_CLASS (MODE) == MODE_VECTOR_INT \ | |
| 0 | 130 || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT \ |
| 131 || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT \ | |
| 132 || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT \ | |
| 133 || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM \ | |
| 134 || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM) | |
| 135 | |
| 136 /* Nonzero if MODE is a scalar integral mode. */ | |
| 137 #define SCALAR_INT_MODE_P(MODE) \ | |
| 138 (GET_MODE_CLASS (MODE) == MODE_INT \ | |
| 139 || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT) | |
| 140 | |
| 141 /* Nonzero if MODE is a scalar floating point mode. */ | |
| 142 #define SCALAR_FLOAT_MODE_P(MODE) \ | |
| 143 (GET_MODE_CLASS (MODE) == MODE_FLOAT \ | |
| 144 || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT) | |
| 145 | |
| 146 /* Nonzero if MODE is a decimal floating point mode. */ | |
| 147 #define DECIMAL_FLOAT_MODE_P(MODE) \ | |
| 148 (GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT) | |
| 149 | |
| 150 /* Nonzero if MODE is a scalar fract mode. */ | |
| 151 #define SCALAR_FRACT_MODE_P(MODE) \ | |
| 152 (GET_MODE_CLASS (MODE) == MODE_FRACT) | |
| 153 | |
| 154 /* Nonzero if MODE is a scalar ufract mode. */ | |
| 155 #define SCALAR_UFRACT_MODE_P(MODE) \ | |
| 156 (GET_MODE_CLASS (MODE) == MODE_UFRACT) | |
| 157 | |
| 158 /* Nonzero if MODE is a scalar fract or ufract mode. */ | |
| 159 #define ALL_SCALAR_FRACT_MODE_P(MODE) \ | |
| 160 (SCALAR_FRACT_MODE_P (MODE) || SCALAR_UFRACT_MODE_P (MODE)) | |
| 161 | |
| 162 /* Nonzero if MODE is a scalar accum mode. */ | |
| 163 #define SCALAR_ACCUM_MODE_P(MODE) \ | |
| 164 (GET_MODE_CLASS (MODE) == MODE_ACCUM) | |
| 165 | |
| 166 /* Nonzero if MODE is a scalar uaccum mode. */ | |
| 167 #define SCALAR_UACCUM_MODE_P(MODE) \ | |
| 168 (GET_MODE_CLASS (MODE) == MODE_UACCUM) | |
| 169 | |
| 170 /* Nonzero if MODE is a scalar accum or uaccum mode. */ | |
| 171 #define ALL_SCALAR_ACCUM_MODE_P(MODE) \ | |
| 172 (SCALAR_ACCUM_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE)) | |
| 173 | |
| 174 /* Nonzero if MODE is a scalar fract or accum mode. */ | |
| 175 #define SIGNED_SCALAR_FIXED_POINT_MODE_P(MODE) \ | |
| 176 (SCALAR_FRACT_MODE_P (MODE) || SCALAR_ACCUM_MODE_P (MODE)) | |
| 177 | |
| 178 /* Nonzero if MODE is a scalar ufract or uaccum mode. */ | |
| 179 #define UNSIGNED_SCALAR_FIXED_POINT_MODE_P(MODE) \ | |
| 180 (SCALAR_UFRACT_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE)) | |
| 181 | |
| 182 /* Nonzero if MODE is a scalar fract, ufract, accum or uaccum mode. */ | |
| 183 #define ALL_SCALAR_FIXED_POINT_MODE_P(MODE) \ | |
| 184 (SIGNED_SCALAR_FIXED_POINT_MODE_P (MODE) \ | |
| 185 || UNSIGNED_SCALAR_FIXED_POINT_MODE_P (MODE)) | |
| 186 | |
| 187 /* Nonzero if MODE is a scalar/vector fract mode. */ | |
| 188 #define FRACT_MODE_P(MODE) \ | |
| 189 (GET_MODE_CLASS (MODE) == MODE_FRACT \ | |
| 190 || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT) | |
| 191 | |
| 192 /* Nonzero if MODE is a scalar/vector ufract mode. */ | |
| 193 #define UFRACT_MODE_P(MODE) \ | |
| 194 (GET_MODE_CLASS (MODE) == MODE_UFRACT \ | |
| 195 || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT) | |
| 196 | |
| 197 /* Nonzero if MODE is a scalar/vector fract or ufract mode. */ | |
| 198 #define ALL_FRACT_MODE_P(MODE) \ | |
| 199 (FRACT_MODE_P (MODE) || UFRACT_MODE_P (MODE)) | |
| 200 | |
| 201 /* Nonzero if MODE is a scalar/vector accum mode. */ | |
| 202 #define ACCUM_MODE_P(MODE) \ | |
| 203 (GET_MODE_CLASS (MODE) == MODE_ACCUM \ | |
| 204 || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM) | |
| 205 | |
| 206 /* Nonzero if MODE is a scalar/vector uaccum mode. */ | |
| 207 #define UACCUM_MODE_P(MODE) \ | |
| 208 (GET_MODE_CLASS (MODE) == MODE_UACCUM \ | |
| 209 || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM) | |
| 210 | |
| 211 /* Nonzero if MODE is a scalar/vector accum or uaccum mode. */ | |
| 212 #define ALL_ACCUM_MODE_P(MODE) \ | |
| 213 (ACCUM_MODE_P (MODE) || UACCUM_MODE_P (MODE)) | |
| 214 | |
| 215 /* Nonzero if MODE is a scalar/vector fract or accum mode. */ | |
| 216 #define SIGNED_FIXED_POINT_MODE_P(MODE) \ | |
| 217 (FRACT_MODE_P (MODE) || ACCUM_MODE_P (MODE)) | |
| 218 | |
| 219 /* Nonzero if MODE is a scalar/vector ufract or uaccum mode. */ | |
| 220 #define UNSIGNED_FIXED_POINT_MODE_P(MODE) \ | |
| 221 (UFRACT_MODE_P (MODE) || UACCUM_MODE_P (MODE)) | |
| 222 | |
| 223 /* Nonzero if MODE is a scalar/vector fract, ufract, accum or uaccum mode. */ | |
| 224 #define ALL_FIXED_POINT_MODE_P(MODE) \ | |
| 225 (SIGNED_FIXED_POINT_MODE_P (MODE) \ | |
| 226 || UNSIGNED_FIXED_POINT_MODE_P (MODE)) | |
| 227 | |
| 228 /* Nonzero if CLASS modes can be widened. */ | |
| 229 #define CLASS_HAS_WIDER_MODES_P(CLASS) \ | |
| 230 (CLASS == MODE_INT \ | |
| 111 | 231 || CLASS == MODE_PARTIAL_INT \ |
| 0 | 232 || CLASS == MODE_FLOAT \ |
| 233 || CLASS == MODE_DECIMAL_FLOAT \ | |
| 234 || CLASS == MODE_COMPLEX_FLOAT \ | |
| 235 || CLASS == MODE_FRACT \ | |
| 236 || CLASS == MODE_UFRACT \ | |
| 237 || CLASS == MODE_ACCUM \ | |
| 238 || CLASS == MODE_UACCUM) | |
| 239 | |
| 111 | 240 /* An optional T (i.e. a T or nothing), where T is some form of mode class. */ |
| 241 template<typename T> | |
| 242 class opt_mode | |
| 243 { | |
| 244 public: | |
| 245 enum from_int { dummy = MAX_MACHINE_MODE }; | |
| 246 | |
| 145 | 247 ALWAYS_INLINE CONSTEXPR opt_mode () : m_mode (E_VOIDmode) {} |
| 248 ALWAYS_INLINE CONSTEXPR opt_mode (const T &m) : m_mode (m) {} | |
| 111 | 249 template<typename U> |
| 145 | 250 ALWAYS_INLINE CONSTEXPR opt_mode (const U &m) : m_mode (T (m)) {} |
| 251 ALWAYS_INLINE CONSTEXPR opt_mode (from_int m) : m_mode (machine_mode (m)) {} | |
| 111 | 252 |
| 253 machine_mode else_void () const; | |
| 145 | 254 machine_mode else_blk () const { return else_mode (BLKmode); } |
| 255 machine_mode else_mode (machine_mode) const; | |
| 111 | 256 T require () const; |
| 257 | |
| 258 bool exists () const; | |
| 259 template<typename U> bool exists (U *) const; | |
| 260 | |
| 145 | 261 bool operator== (const T &m) const { return m_mode == m; } |
| 262 bool operator!= (const T &m) const { return m_mode != m; } | |
| 263 | |
| 111 | 264 private: |
| 265 machine_mode m_mode; | |
| 266 }; | |
| 267 | |
| 268 /* If the object contains a T, return its enum value, otherwise return | |
| 269 E_VOIDmode. */ | |
| 270 | |
| 271 template<typename T> | |
| 272 ALWAYS_INLINE machine_mode | |
| 273 opt_mode<T>::else_void () const | |
| 274 { | |
| 275 return m_mode; | |
| 276 } | |
| 277 | |
| 145 | 278 /* If the T exists, return its enum value, otherwise return FALLBACK. */ |
| 111 | 279 |
| 280 template<typename T> | |
| 281 inline machine_mode | |
| 145 | 282 opt_mode<T>::else_mode (machine_mode fallback) const |
| 111 | 283 { |
| 145 | 284 return m_mode == E_VOIDmode ? fallback : m_mode; |
| 111 | 285 } |
| 286 | |
| 287 /* Assert that the object contains a T and return it. */ | |
| 288 | |
| 289 template<typename T> | |
| 290 inline T | |
| 291 opt_mode<T>::require () const | |
| 292 { | |
| 293 gcc_checking_assert (m_mode != E_VOIDmode); | |
| 294 return typename mode_traits<T>::from_int (m_mode); | |
| 295 } | |
| 296 | |
| 297 /* Return true if the object contains a T rather than nothing. */ | |
| 298 | |
| 299 template<typename T> | |
| 300 ALWAYS_INLINE bool | |
| 301 opt_mode<T>::exists () const | |
| 302 { | |
| 303 return m_mode != E_VOIDmode; | |
| 304 } | |
| 305 | |
| 306 /* Return true if the object contains a T, storing it in *MODE if so. */ | |
| 307 | |
| 308 template<typename T> | |
| 309 template<typename U> | |
| 310 inline bool | |
| 311 opt_mode<T>::exists (U *mode) const | |
| 312 { | |
| 313 if (m_mode != E_VOIDmode) | |
| 314 { | |
| 315 *mode = T (typename mode_traits<T>::from_int (m_mode)); | |
| 316 return true; | |
| 317 } | |
| 318 return false; | |
| 319 } | |
| 320 | |
| 321 /* A POD version of mode class T. */ | |
| 322 | |
| 323 template<typename T> | |
| 324 struct pod_mode | |
| 325 { | |
| 326 typedef typename mode_traits<T>::from_int from_int; | |
| 131 | 327 typedef typename T::measurement_type measurement_type; |
| 111 | 328 |
| 329 machine_mode m_mode; | |
| 145 | 330 ALWAYS_INLINE CONSTEXPR |
| 331 operator machine_mode () const { return m_mode; } | |
| 332 | |
| 333 ALWAYS_INLINE CONSTEXPR | |
| 334 operator T () const { return from_int (m_mode); } | |
| 335 | |
| 111 | 336 ALWAYS_INLINE pod_mode &operator = (const T &m) { m_mode = m; return *this; } |
| 337 }; | |
| 338 | |
| 339 /* Return true if mode M has type T. */ | |
| 340 | |
| 341 template<typename T> | |
| 342 inline bool | |
| 343 is_a (machine_mode m) | |
| 344 { | |
| 345 return T::includes_p (m); | |
| 346 } | |
| 347 | |
| 348 template<typename T, typename U> | |
| 349 inline bool | |
| 350 is_a (const opt_mode<U> &m) | |
| 351 { | |
| 352 return T::includes_p (m.else_void ()); | |
| 353 } | |
| 354 | |
| 355 /* Assert that mode M has type T, and return it in that form. */ | |
| 356 | |
| 357 template<typename T> | |
| 358 inline T | |
| 359 as_a (machine_mode m) | |
| 360 { | |
| 361 gcc_checking_assert (T::includes_p (m)); | |
| 362 return typename mode_traits<T>::from_int (m); | |
| 363 } | |
| 364 | |
| 365 template<typename T, typename U> | |
| 366 inline T | |
| 367 as_a (const opt_mode<U> &m) | |
| 368 { | |
| 369 return as_a <T> (m.else_void ()); | |
| 370 } | |
| 371 | |
| 372 /* Convert M to an opt_mode<T>. */ | |
| 373 | |
| 374 template<typename T> | |
| 375 inline opt_mode<T> | |
| 376 dyn_cast (machine_mode m) | |
| 377 { | |
| 378 if (T::includes_p (m)) | |
| 379 return T (typename mode_traits<T>::from_int (m)); | |
| 380 return opt_mode<T> (); | |
| 381 } | |
| 382 | |
| 383 template<typename T, typename U> | |
| 384 inline opt_mode<T> | |
| 385 dyn_cast (const opt_mode<U> &m) | |
| 386 { | |
| 387 return dyn_cast <T> (m.else_void ()); | |
| 388 } | |
| 389 | |
| 390 /* Return true if mode M has type T, storing it as a T in *RESULT | |
| 391 if so. */ | |
| 392 | |
| 393 template<typename T, typename U> | |
| 394 inline bool | |
| 395 is_a (machine_mode m, U *result) | |
| 396 { | |
| 397 if (T::includes_p (m)) | |
| 398 { | |
| 399 *result = T (typename mode_traits<T>::from_int (m)); | |
| 400 return true; | |
| 401 } | |
| 402 return false; | |
| 403 } | |
| 404 | |
| 405 /* Represents a machine mode that is known to be a SCALAR_INT_MODE_P. */ | |
| 406 class scalar_int_mode | |
| 407 { | |
| 408 public: | |
| 409 typedef mode_traits<scalar_int_mode>::from_int from_int; | |
| 131 | 410 typedef unsigned short measurement_type; |
| 111 | 411 |
| 412 ALWAYS_INLINE scalar_int_mode () {} | |
| 145 | 413 |
| 414 ALWAYS_INLINE CONSTEXPR | |
| 415 scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {} | |
| 416 | |
| 417 ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; } | |
| 111 | 418 |
| 419 static bool includes_p (machine_mode); | |
| 420 | |
| 421 protected: | |
| 422 machine_mode m_mode; | |
| 423 }; | |
| 424 | |
| 425 /* Return true if M is a scalar_int_mode. */ | |
| 0 | 426 |
| 111 | 427 inline bool |
| 428 scalar_int_mode::includes_p (machine_mode m) | |
| 429 { | |
| 430 return SCALAR_INT_MODE_P (m); | |
| 431 } | |
| 432 | |
| 433 /* Represents a machine mode that is known to be a SCALAR_FLOAT_MODE_P. */ | |
| 434 class scalar_float_mode | |
| 435 { | |
| 436 public: | |
| 437 typedef mode_traits<scalar_float_mode>::from_int from_int; | |
| 131 | 438 typedef unsigned short measurement_type; |
| 111 | 439 |
| 440 ALWAYS_INLINE scalar_float_mode () {} | |
| 145 | 441 |
| 442 ALWAYS_INLINE CONSTEXPR | |
| 443 scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {} | |
| 444 | |
| 445 ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; } | |
| 111 | 446 |
| 447 static bool includes_p (machine_mode); | |
| 448 | |
| 449 protected: | |
| 450 machine_mode m_mode; | |
| 451 }; | |
| 452 | |
| 453 /* Return true if M is a scalar_float_mode. */ | |
| 454 | |
| 455 inline bool | |
| 456 scalar_float_mode::includes_p (machine_mode m) | |
| 457 { | |
| 458 return SCALAR_FLOAT_MODE_P (m); | |
| 459 } | |
| 460 | |
| 461 /* Represents a machine mode that is known to be scalar. */ | |
| 462 class scalar_mode | |
| 463 { | |
| 464 public: | |
| 465 typedef mode_traits<scalar_mode>::from_int from_int; | |
| 131 | 466 typedef unsigned short measurement_type; |
| 111 | 467 |
| 468 ALWAYS_INLINE scalar_mode () {} | |
| 145 | 469 |
| 470 ALWAYS_INLINE CONSTEXPR | |
| 471 scalar_mode (from_int m) : m_mode (machine_mode (m)) {} | |
| 472 | |
| 473 ALWAYS_INLINE CONSTEXPR | |
| 474 scalar_mode (const scalar_int_mode &m) : m_mode (m) {} | |
| 475 | |
| 476 ALWAYS_INLINE CONSTEXPR | |
| 477 scalar_mode (const scalar_float_mode &m) : m_mode (m) {} | |
| 478 | |
| 479 ALWAYS_INLINE CONSTEXPR | |
| 480 scalar_mode (const scalar_int_mode_pod &m) : m_mode (m) {} | |
| 481 | |
| 482 ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; } | |
| 111 | 483 |
| 484 static bool includes_p (machine_mode); | |
| 485 | |
| 486 protected: | |
| 487 machine_mode m_mode; | |
| 488 }; | |
| 489 | |
| 490 /* Return true if M represents some kind of scalar value. */ | |
| 491 | |
| 492 inline bool | |
| 493 scalar_mode::includes_p (machine_mode m) | |
| 494 { | |
| 495 switch (GET_MODE_CLASS (m)) | |
| 496 { | |
| 497 case MODE_INT: | |
| 498 case MODE_PARTIAL_INT: | |
| 499 case MODE_FRACT: | |
| 500 case MODE_UFRACT: | |
| 501 case MODE_ACCUM: | |
| 502 case MODE_UACCUM: | |
| 503 case MODE_FLOAT: | |
| 504 case MODE_DECIMAL_FLOAT: | |
| 505 return true; | |
| 506 default: | |
| 507 return false; | |
| 508 } | |
| 509 } | |
| 510 | |
| 511 /* Represents a machine mode that is known to be a COMPLEX_MODE_P. */ | |
| 512 class complex_mode | |
| 513 { | |
| 514 public: | |
| 515 typedef mode_traits<complex_mode>::from_int from_int; | |
| 131 | 516 typedef unsigned short measurement_type; |
| 111 | 517 |
| 518 ALWAYS_INLINE complex_mode () {} | |
| 145 | 519 |
| 520 ALWAYS_INLINE CONSTEXPR | |
| 521 complex_mode (from_int m) : m_mode (machine_mode (m)) {} | |
| 522 | |
| 523 ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; } | |
| 111 | 524 |
| 525 static bool includes_p (machine_mode); | |
| 526 | |
| 527 protected: | |
| 528 machine_mode m_mode; | |
| 529 }; | |
| 530 | |
| 531 /* Return true if M is a complex_mode. */ | |
| 532 | |
| 533 inline bool | |
| 534 complex_mode::includes_p (machine_mode m) | |
| 535 { | |
| 536 return COMPLEX_MODE_P (m); | |
| 537 } | |
| 538 | |
| 539 /* Return the base GET_MODE_SIZE value for MODE. */ | |
| 540 | |
| 131 | 541 ALWAYS_INLINE poly_uint16 |
| 111 | 542 mode_to_bytes (machine_mode mode) |
| 543 { | |
| 544 #if GCC_VERSION >= 4001 | |
| 545 return (__builtin_constant_p (mode) | |
| 546 ? mode_size_inline (mode) : mode_size[mode]); | |
| 547 #else | |
| 548 return mode_size[mode]; | |
| 549 #endif | |
| 550 } | |
| 551 | |
| 552 /* Return the base GET_MODE_BITSIZE value for MODE. */ | |
| 553 | |
| 131 | 554 ALWAYS_INLINE poly_uint16 |
| 111 | 555 mode_to_bits (machine_mode mode) |
| 556 { | |
| 557 return mode_to_bytes (mode) * BITS_PER_UNIT; | |
| 558 } | |
| 559 | |
| 560 /* Return the base GET_MODE_PRECISION value for MODE. */ | |
| 561 | |
| 131 | 562 ALWAYS_INLINE poly_uint16 |
| 111 | 563 mode_to_precision (machine_mode mode) |
| 564 { | |
| 565 return mode_precision[mode]; | |
| 566 } | |
| 567 | |
| 568 /* Return the base GET_MODE_INNER value for MODE. */ | |
| 569 | |
| 570 ALWAYS_INLINE scalar_mode | |
| 571 mode_to_inner (machine_mode mode) | |
| 572 { | |
| 573 #if GCC_VERSION >= 4001 | |
| 574 return scalar_mode::from_int (__builtin_constant_p (mode) | |
| 575 ? mode_inner_inline (mode) | |
| 576 : mode_inner[mode]); | |
| 577 #else | |
| 578 return scalar_mode::from_int (mode_inner[mode]); | |
| 579 #endif | |
| 580 } | |
| 581 | |
| 582 /* Return the base GET_MODE_UNIT_SIZE value for MODE. */ | |
| 583 | |
| 584 ALWAYS_INLINE unsigned char | |
| 585 mode_to_unit_size (machine_mode mode) | |
| 586 { | |
| 587 #if GCC_VERSION >= 4001 | |
| 588 return (__builtin_constant_p (mode) | |
| 589 ? mode_unit_size_inline (mode) : mode_unit_size[mode]); | |
| 590 #else | |
| 591 return mode_unit_size[mode]; | |
| 592 #endif | |
| 593 } | |
| 594 | |
| 595 /* Return the base GET_MODE_UNIT_PRECISION value for MODE. */ | |
| 596 | |
| 597 ALWAYS_INLINE unsigned short | |
| 598 mode_to_unit_precision (machine_mode mode) | |
| 599 { | |
| 600 #if GCC_VERSION >= 4001 | |
| 601 return (__builtin_constant_p (mode) | |
| 602 ? mode_unit_precision_inline (mode) : mode_unit_precision[mode]); | |
| 603 #else | |
| 604 return mode_unit_precision[mode]; | |
| 605 #endif | |
| 606 } | |
| 607 | |
| 608 /* Return the base GET_MODE_NUNITS value for MODE. */ | |
| 609 | |
| 131 | 610 ALWAYS_INLINE poly_uint16 |
| 111 | 611 mode_to_nunits (machine_mode mode) |
| 612 { | |
| 613 #if GCC_VERSION >= 4001 | |
| 614 return (__builtin_constant_p (mode) | |
| 615 ? mode_nunits_inline (mode) : mode_nunits[mode]); | |
| 616 #else | |
| 617 return mode_nunits[mode]; | |
| 618 #endif | |
| 619 } | |
| 620 | |
| 621 /* Get the size in bytes of an object of mode MODE. */ | |
| 622 | |
| 131 | 623 #if ONLY_FIXED_SIZE_MODES |
| 624 #define GET_MODE_SIZE(MODE) ((unsigned short) mode_to_bytes (MODE).coeffs[0]) | |
| 625 #else | |
| 626 ALWAYS_INLINE poly_uint16 | |
| 627 GET_MODE_SIZE (machine_mode mode) | |
| 628 { | |
| 629 return mode_to_bytes (mode); | |
| 630 } | |
| 631 | |
| 632 template<typename T> | |
| 633 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type | |
| 634 GET_MODE_SIZE (const T &mode) | |
| 635 { | |
| 636 return mode_to_bytes (mode); | |
| 637 } | |
| 638 | |
| 639 template<typename T> | |
| 640 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type | |
| 641 GET_MODE_SIZE (const T &mode) | |
| 642 { | |
| 643 return mode_to_bytes (mode).coeffs[0]; | |
| 644 } | |
| 645 #endif | |
| 111 | 646 |
| 647 /* Get the size in bits of an object of mode MODE. */ | |
| 648 | |
| 131 | 649 #if ONLY_FIXED_SIZE_MODES |
| 650 #define GET_MODE_BITSIZE(MODE) ((unsigned short) mode_to_bits (MODE).coeffs[0]) | |
| 651 #else | |
| 652 ALWAYS_INLINE poly_uint16 | |
| 653 GET_MODE_BITSIZE (machine_mode mode) | |
| 654 { | |
| 655 return mode_to_bits (mode); | |
| 656 } | |
| 657 | |
| 658 template<typename T> | |
| 659 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type | |
| 660 GET_MODE_BITSIZE (const T &mode) | |
| 661 { | |
| 662 return mode_to_bits (mode); | |
| 663 } | |
| 664 | |
| 665 template<typename T> | |
| 666 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type | |
| 667 GET_MODE_BITSIZE (const T &mode) | |
| 668 { | |
| 669 return mode_to_bits (mode).coeffs[0]; | |
| 670 } | |
| 671 #endif | |
| 0 | 672 |
| 673 /* Get the number of value bits of an object of mode MODE. */ | |
| 111 | 674 |
| 131 | 675 #if ONLY_FIXED_SIZE_MODES |
| 676 #define GET_MODE_PRECISION(MODE) \ | |
| 677 ((unsigned short) mode_to_precision (MODE).coeffs[0]) | |
| 678 #else | |
| 679 ALWAYS_INLINE poly_uint16 | |
| 680 GET_MODE_PRECISION (machine_mode mode) | |
| 681 { | |
| 682 return mode_to_precision (mode); | |
| 683 } | |
| 684 | |
| 685 template<typename T> | |
| 686 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type | |
| 687 GET_MODE_PRECISION (const T &mode) | |
| 688 { | |
| 689 return mode_to_precision (mode); | |
| 690 } | |
| 691 | |
| 692 template<typename T> | |
| 693 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type | |
| 694 GET_MODE_PRECISION (const T &mode) | |
| 695 { | |
| 696 return mode_to_precision (mode).coeffs[0]; | |
| 697 } | |
| 698 #endif | |
| 0 | 699 |
| 700 /* Get the number of integral bits of an object of mode MODE. */ | |
| 701 extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES]; | |
| 702 #define GET_MODE_IBIT(MODE) mode_ibit[MODE] | |
| 703 | |
| 704 /* Get the number of fractional bits of an object of mode MODE. */ | |
| 705 extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES]; | |
| 706 #define GET_MODE_FBIT(MODE) mode_fbit[MODE] | |
| 707 | |
| 708 /* Get a bitmask containing 1 for all bits in a word | |
| 709 that fit within mode MODE. */ | |
| 710 | |
| 711 extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES]; | |
| 712 | |
| 713 #define GET_MODE_MASK(MODE) mode_mask_array[MODE] | |
| 714 | |
| 111 | 715 /* Return the mode of the basic parts of MODE. For vector modes this is the |
| 716 mode of the vector elements. For complex modes it is the mode of the real | |
| 717 and imaginary parts. For other modes it is MODE itself. */ | |
| 0 | 718 |
| 111 | 719 #define GET_MODE_INNER(MODE) (mode_to_inner (MODE)) |
| 0 | 720 |
| 111 | 721 /* Get the size in bytes or bits of the basic parts of an |
| 722 object of mode MODE. */ | |
| 0 | 723 |
| 111 | 724 #define GET_MODE_UNIT_SIZE(MODE) mode_to_unit_size (MODE) |
| 725 | |
| 726 #define GET_MODE_UNIT_BITSIZE(MODE) \ | |
| 727 ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT)) | |
| 0 | 728 |
| 111 | 729 #define GET_MODE_UNIT_PRECISION(MODE) (mode_to_unit_precision (MODE)) |
| 0 | 730 |
| 111 | 731 /* Get the number of units in an object of mode MODE. This is 2 for |
| 732 complex modes and the number of elements for vector modes. */ | |
| 733 | |
| 131 | 734 #if ONLY_FIXED_SIZE_MODES |
| 735 #define GET_MODE_NUNITS(MODE) (mode_to_nunits (MODE).coeffs[0]) | |
| 736 #else | |
| 737 ALWAYS_INLINE poly_uint16 | |
| 738 GET_MODE_NUNITS (machine_mode mode) | |
| 739 { | |
| 740 return mode_to_nunits (mode); | |
| 741 } | |
| 742 | |
| 743 template<typename T> | |
| 744 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type | |
| 745 GET_MODE_NUNITS (const T &mode) | |
| 746 { | |
| 747 return mode_to_nunits (mode); | |
| 748 } | |
| 749 | |
| 750 template<typename T> | |
| 751 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type | |
| 752 GET_MODE_NUNITS (const T &mode) | |
| 753 { | |
| 754 return mode_to_nunits (mode).coeffs[0]; | |
| 755 } | |
| 756 #endif | |
| 0 | 757 |
| 758 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI). */ | |
| 759 | |
| 111 | 760 template<typename T> |
| 761 ALWAYS_INLINE opt_mode<T> | |
| 762 GET_MODE_WIDER_MODE (const T &m) | |
| 763 { | |
| 764 return typename opt_mode<T>::from_int (mode_wider[m]); | |
| 765 } | |
| 766 | |
| 767 /* For scalars, this is a mode with twice the precision. For vectors, | |
| 768 this is a mode with the same inner mode but with twice the elements. */ | |
| 0 | 769 |
| 111 | 770 template<typename T> |
| 771 ALWAYS_INLINE opt_mode<T> | |
| 772 GET_MODE_2XWIDER_MODE (const T &m) | |
| 773 { | |
| 774 return typename opt_mode<T>::from_int (mode_2xwider[m]); | |
| 775 } | |
| 776 | |
| 777 /* Get the complex mode from the component mode. */ | |
| 778 extern const unsigned char mode_complex[NUM_MACHINE_MODES]; | |
| 779 #define GET_MODE_COMPLEX_MODE(MODE) ((machine_mode) mode_complex[MODE]) | |
| 780 | |
| 131 | 781 /* Represents a machine mode that must have a fixed size. The main |
| 782 use of this class is to represent the modes of objects that always | |
| 783 have static storage duration, such as constant pool entries. | |
| 784 (No current target supports the concept of variable-size static data.) */ | |
| 785 class fixed_size_mode | |
| 786 { | |
| 787 public: | |
| 788 typedef mode_traits<fixed_size_mode>::from_int from_int; | |
| 789 typedef unsigned short measurement_type; | |
| 790 | |
| 791 ALWAYS_INLINE fixed_size_mode () {} | |
| 145 | 792 |
| 793 ALWAYS_INLINE CONSTEXPR | |
| 794 fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {} | |
| 795 | |
| 796 ALWAYS_INLINE CONSTEXPR | |
| 797 fixed_size_mode (const scalar_mode &m) : m_mode (m) {} | |
| 798 | |
| 799 ALWAYS_INLINE CONSTEXPR | |
| 800 fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {} | |
| 801 | |
| 802 ALWAYS_INLINE CONSTEXPR | |
| 803 fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {} | |
| 804 | |
| 805 ALWAYS_INLINE CONSTEXPR | |
| 806 fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {} | |
| 807 | |
| 808 ALWAYS_INLINE CONSTEXPR | |
| 809 fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {} | |
| 810 | |
| 811 ALWAYS_INLINE CONSTEXPR | |
| 812 fixed_size_mode (const complex_mode &m) : m_mode (m) {} | |
| 813 | |
| 814 ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; } | |
| 131 | 815 |
| 816 static bool includes_p (machine_mode); | |
| 817 | |
| 818 protected: | |
| 819 machine_mode m_mode; | |
| 820 }; | |
| 821 | |
| 822 /* Return true if MODE has a fixed size. */ | |
| 823 | |
| 824 inline bool | |
| 825 fixed_size_mode::includes_p (machine_mode mode) | |
| 826 { | |
| 827 return mode_to_bytes (mode).is_constant (); | |
| 828 } | |
| 829 | |
| 830 /* Wrapper for mode arguments to target macros, so that if a target | |
| 831 doesn't need polynomial-sized modes, its header file can continue | |
| 832 to treat everything as fixed_size_mode. This should go away once | |
| 833 macros are moved to target hooks. It shouldn't be used in other | |
| 834 contexts. */ | |
| 835 #if NUM_POLY_INT_COEFFS == 1 | |
| 836 #define MACRO_MODE(MODE) (as_a <fixed_size_mode> (MODE)) | |
| 837 #else | |
| 838 #define MACRO_MODE(MODE) (MODE) | |
| 839 #endif | |
| 840 | |
| 841 extern opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int); | |
| 0 | 842 |
| 111 | 843 /* Return the machine mode to use for a MODE_INT of SIZE bits, if one |
| 844 exists. If LIMIT is nonzero, modes wider than MAX_FIXED_MODE_SIZE | |
| 845 will not be used. */ | |
| 846 | |
| 847 inline opt_scalar_int_mode | |
| 131 | 848 int_mode_for_size (poly_uint64 size, int limit) |
| 111 | 849 { |
| 850 return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit)); | |
| 851 } | |
| 852 | |
| 853 /* Return the machine mode to use for a MODE_FLOAT of SIZE bits, if one | |
| 854 exists. */ | |
| 0 | 855 |
| 111 | 856 inline opt_scalar_float_mode |
| 131 | 857 float_mode_for_size (poly_uint64 size) |
| 111 | 858 { |
| 859 return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0)); | |
| 860 } | |
| 0 | 861 |
| 111 | 862 /* Likewise for MODE_DECIMAL_FLOAT. */ |
| 863 | |
| 864 inline opt_scalar_float_mode | |
| 865 decimal_float_mode_for_size (unsigned int size) | |
| 866 { | |
| 867 return dyn_cast <scalar_float_mode> | |
| 868 (mode_for_size (size, MODE_DECIMAL_FLOAT, 0)); | |
| 869 } | |
| 0 | 870 |
| 131 | 871 extern machine_mode smallest_mode_for_size (poly_uint64, enum mode_class); |
| 111 | 872 |
| 873 /* Find the narrowest integer mode that contains at least SIZE bits. | |
| 874 Such a mode must exist. */ | |
| 875 | |
| 876 inline scalar_int_mode | |
| 131 | 877 smallest_int_mode_for_size (poly_uint64 size) |
| 111 | 878 { |
| 879 return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT)); | |
| 880 } | |
| 0 | 881 |
| 111 | 882 extern opt_scalar_int_mode int_mode_for_mode (machine_mode); |
| 883 extern opt_machine_mode bitwise_mode_for_mode (machine_mode); | |
| 131 | 884 extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64); |
| 145 | 885 extern opt_machine_mode related_vector_mode (machine_mode, scalar_mode, |
| 886 poly_uint64 = 0); | |
| 887 extern opt_machine_mode related_int_vector_mode (machine_mode); | |
| 0 | 888 |
| 111 | 889 /* A class for iterating through possible bitfield modes. */ |
| 890 class bit_field_mode_iterator | |
| 891 { | |
| 892 public: | |
| 893 bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT, | |
| 131 | 894 poly_int64, poly_int64, |
| 111 | 895 unsigned int, bool); |
| 896 bool next_mode (scalar_int_mode *); | |
| 897 bool prefer_smaller_modes (); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
898 |
| 111 | 899 private: |
| 900 opt_scalar_int_mode m_mode; | |
| 901 /* We use signed values here because the bit position can be negative | |
| 902 for invalid input such as gcc.dg/pr48335-8.c. */ | |
| 903 HOST_WIDE_INT m_bitsize; | |
| 904 HOST_WIDE_INT m_bitpos; | |
| 131 | 905 poly_int64 m_bitregion_start; |
| 906 poly_int64 m_bitregion_end; | |
| 111 | 907 unsigned int m_align; |
| 908 bool m_volatilep; | |
| 909 int m_count; | |
| 910 }; | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
911 |
| 0 | 912 /* Find the best mode to use to access a bit field. */ |
| 913 | |
| 131 | 914 extern bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int, |
| 111 | 915 unsigned HOST_WIDE_INT, bool, scalar_int_mode *); |
| 0 | 916 |
| 917 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT. */ | |
| 918 | |
| 111 | 919 extern CONST_MODE_BASE_ALIGN unsigned short mode_base_align[NUM_MACHINE_MODES]; |
| 0 | 920 |
| 111 | 921 extern unsigned get_mode_alignment (machine_mode); |
| 0 | 922 |
| 923 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE) | |
| 924 | |
| 925 /* For each class, get the narrowest mode in that class. */ | |
| 926 | |
| 927 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS]; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
928 #define GET_CLASS_NARROWEST_MODE(CLASS) \ |
| 111 | 929 ((machine_mode) class_narrowest_mode[CLASS]) |
| 930 | |
| 931 /* The narrowest full integer mode available on the target. */ | |
| 932 | |
| 933 #define NARROWEST_INT_MODE \ | |
| 934 (scalar_int_mode \ | |
| 935 (scalar_int_mode::from_int (class_narrowest_mode[MODE_INT]))) | |
| 936 | |
| 937 /* Return the narrowest mode in T's class. */ | |
| 938 | |
| 939 template<typename T> | |
| 940 inline T | |
| 941 get_narrowest_mode (T mode) | |
| 942 { | |
| 943 return typename mode_traits<T>::from_int | |
| 944 (class_narrowest_mode[GET_MODE_CLASS (mode)]); | |
| 945 } | |
| 0 | 946 |
| 947 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD | |
| 948 and the mode whose class is Pmode and whose size is POINTER_SIZE. */ | |
| 949 | |
| 111 | 950 extern scalar_int_mode byte_mode; |
| 951 extern scalar_int_mode word_mode; | |
| 952 extern scalar_int_mode ptr_mode; | |
| 0 | 953 |
| 954 /* Target-dependent machine mode initialization - in insn-modes.c. */ | |
| 955 extern void init_adjust_machine_modes (void); | |
| 956 | |
| 111 | 957 #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \ |
| 958 (targetm.truly_noop_truncation (GET_MODE_PRECISION (MODE1), \ | |
| 959 GET_MODE_PRECISION (MODE2))) | |
| 960 | |
| 131 | 961 /* Return true if MODE is a scalar integer mode that fits in a |
| 962 HOST_WIDE_INT. */ | |
| 963 | |
| 964 inline bool | |
| 965 HWI_COMPUTABLE_MODE_P (machine_mode mode) | |
| 966 { | |
| 967 machine_mode mme = mode; | |
| 968 return (SCALAR_INT_MODE_P (mme) | |
| 969 && mode_to_precision (mme).coeffs[0] <= HOST_BITS_PER_WIDE_INT); | |
| 970 } | |
| 971 | |
| 972 inline bool | |
| 973 HWI_COMPUTABLE_MODE_P (scalar_int_mode mode) | |
| 974 { | |
| 975 return GET_MODE_PRECISION (mode) <= HOST_BITS_PER_WIDE_INT; | |
| 976 } | |
| 111 | 977 |
| 978 struct int_n_data_t { | |
| 979 /* These parts are initailized by genmodes output */ | |
| 980 unsigned int bitsize; | |
| 981 scalar_int_mode_pod m; | |
| 982 /* RID_* is RID_INTN_BASE + index into this array */ | |
| 983 }; | |
| 984 | |
| 985 /* This is also in tree.h. genmodes.c guarantees the're sorted from | |
| 986 smallest bitsize to largest bitsize. */ | |
| 987 extern bool int_n_enabled_p[NUM_INT_N_ENTS]; | |
| 988 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS]; | |
| 989 | |
| 990 /* Return true if MODE has class MODE_INT, storing it as a scalar_int_mode | |
| 991 in *INT_MODE if so. */ | |
| 992 | |
| 993 template<typename T> | |
| 994 inline bool | |
| 995 is_int_mode (machine_mode mode, T *int_mode) | |
| 996 { | |
| 997 if (GET_MODE_CLASS (mode) == MODE_INT) | |
| 998 { | |
| 999 *int_mode = scalar_int_mode (scalar_int_mode::from_int (mode)); | |
| 1000 return true; | |
| 1001 } | |
| 1002 return false; | |
| 1003 } | |
| 1004 | |
| 1005 /* Return true if MODE has class MODE_FLOAT, storing it as a | |
| 1006 scalar_float_mode in *FLOAT_MODE if so. */ | |
| 1007 | |
| 1008 template<typename T> | |
| 1009 inline bool | |
| 1010 is_float_mode (machine_mode mode, T *float_mode) | |
| 1011 { | |
| 1012 if (GET_MODE_CLASS (mode) == MODE_FLOAT) | |
| 1013 { | |
| 1014 *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode)); | |
| 1015 return true; | |
| 1016 } | |
| 1017 return false; | |
| 1018 } | |
| 1019 | |
| 1020 /* Return true if MODE has class MODE_COMPLEX_INT, storing it as | |
| 1021 a complex_mode in *CMODE if so. */ | |
| 1022 | |
| 1023 template<typename T> | |
| 1024 inline bool | |
| 1025 is_complex_int_mode (machine_mode mode, T *cmode) | |
| 1026 { | |
| 1027 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT) | |
| 1028 { | |
| 1029 *cmode = complex_mode (complex_mode::from_int (mode)); | |
| 1030 return true; | |
| 1031 } | |
| 1032 return false; | |
| 1033 } | |
| 1034 | |
| 1035 /* Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as | |
| 1036 a complex_mode in *CMODE if so. */ | |
| 1037 | |
| 1038 template<typename T> | |
| 1039 inline bool | |
| 1040 is_complex_float_mode (machine_mode mode, T *cmode) | |
| 1041 { | |
| 1042 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT) | |
| 1043 { | |
| 1044 *cmode = complex_mode (complex_mode::from_int (mode)); | |
| 1045 return true; | |
| 1046 } | |
| 1047 return false; | |
| 1048 } | |
| 1049 | |
| 131 | 1050 /* Return true if MODE is a scalar integer mode with a precision |
| 1051 smaller than LIMIT's precision. */ | |
| 1052 | |
| 1053 inline bool | |
| 1054 is_narrower_int_mode (machine_mode mode, scalar_int_mode limit) | |
| 1055 { | |
| 1056 scalar_int_mode int_mode; | |
| 1057 return (is_a <scalar_int_mode> (mode, &int_mode) | |
| 1058 && GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit)); | |
| 1059 } | |
| 1060 | |
| 111 | 1061 namespace mode_iterator |
| 1062 { | |
| 1063 /* Start mode iterator *ITER at the first mode in class MCLASS, if any. */ | |
| 1064 | |
| 1065 template<typename T> | |
| 1066 inline void | |
| 1067 start (opt_mode<T> *iter, enum mode_class mclass) | |
| 1068 { | |
| 1069 if (GET_CLASS_NARROWEST_MODE (mclass) == E_VOIDmode) | |
| 1070 *iter = opt_mode<T> (); | |
| 1071 else | |
| 1072 *iter = as_a<T> (GET_CLASS_NARROWEST_MODE (mclass)); | |
| 1073 } | |
| 1074 | |
| 1075 inline void | |
| 1076 start (machine_mode *iter, enum mode_class mclass) | |
| 1077 { | |
| 1078 *iter = GET_CLASS_NARROWEST_MODE (mclass); | |
| 1079 } | |
| 1080 | |
| 1081 /* Return true if mode iterator *ITER has not reached the end. */ | |
| 1082 | |
| 1083 template<typename T> | |
| 1084 inline bool | |
| 1085 iterate_p (opt_mode<T> *iter) | |
| 1086 { | |
| 1087 return iter->exists (); | |
| 1088 } | |
| 1089 | |
| 1090 inline bool | |
| 1091 iterate_p (machine_mode *iter) | |
| 1092 { | |
| 1093 return *iter != E_VOIDmode; | |
| 1094 } | |
| 1095 | |
| 1096 /* Set mode iterator *ITER to the next widest mode in the same class, | |
| 1097 if any. */ | |
| 1098 | |
| 1099 template<typename T> | |
| 1100 inline void | |
| 1101 get_wider (opt_mode<T> *iter) | |
| 1102 { | |
| 1103 *iter = GET_MODE_WIDER_MODE (iter->require ()); | |
| 1104 } | |
| 1105 | |
| 1106 inline void | |
| 1107 get_wider (machine_mode *iter) | |
| 1108 { | |
| 1109 *iter = GET_MODE_WIDER_MODE (*iter).else_void (); | |
| 1110 } | |
| 1111 | |
| 1112 /* Set mode iterator *ITER to the next widest mode in the same class. | |
| 1113 Such a mode is known to exist. */ | |
| 1114 | |
| 1115 template<typename T> | |
| 1116 inline void | |
| 1117 get_known_wider (T *iter) | |
| 1118 { | |
| 1119 *iter = GET_MODE_WIDER_MODE (*iter).require (); | |
| 1120 } | |
| 1121 | |
| 1122 /* Set mode iterator *ITER to the mode that is two times wider than the | |
| 1123 current one, if such a mode exists. */ | |
| 1124 | |
| 1125 template<typename T> | |
| 1126 inline void | |
| 1127 get_2xwider (opt_mode<T> *iter) | |
| 1128 { | |
| 1129 *iter = GET_MODE_2XWIDER_MODE (iter->require ()); | |
| 1130 } | |
| 1131 | |
| 1132 inline void | |
| 1133 get_2xwider (machine_mode *iter) | |
| 1134 { | |
| 1135 *iter = GET_MODE_2XWIDER_MODE (*iter).else_void (); | |
| 1136 } | |
| 1137 } | |
| 1138 | |
| 1139 /* Make ITERATOR iterate over all the modes in mode class CLASS, | |
| 1140 from narrowest to widest. */ | |
| 1141 #define FOR_EACH_MODE_IN_CLASS(ITERATOR, CLASS) \ | |
| 1142 for (mode_iterator::start (&(ITERATOR), CLASS); \ | |
| 1143 mode_iterator::iterate_p (&(ITERATOR)); \ | |
| 1144 mode_iterator::get_wider (&(ITERATOR))) | |
| 1145 | |
| 1146 /* Make ITERATOR iterate over all the modes in the range [START, END), | |
| 1147 in order of increasing width. */ | |
| 1148 #define FOR_EACH_MODE(ITERATOR, START, END) \ | |
| 1149 for ((ITERATOR) = (START); \ | |
| 1150 (ITERATOR) != (END); \ | |
| 1151 mode_iterator::get_known_wider (&(ITERATOR))) | |
| 1152 | |
| 1153 /* Make ITERATOR iterate over START and all wider modes in the same | |
| 1154 class, in order of increasing width. */ | |
| 1155 #define FOR_EACH_MODE_FROM(ITERATOR, START) \ | |
| 1156 for ((ITERATOR) = (START); \ | |
| 1157 mode_iterator::iterate_p (&(ITERATOR)); \ | |
| 1158 mode_iterator::get_wider (&(ITERATOR))) | |
| 1159 | |
| 1160 /* Make ITERATOR iterate over modes in the range [NARROWEST, END) | |
| 1161 in order of increasing width, where NARROWEST is the narrowest mode | |
| 1162 in END's class. */ | |
| 1163 #define FOR_EACH_MODE_UNTIL(ITERATOR, END) \ | |
| 1164 FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END) | |
| 1165 | |
| 1166 /* Make ITERATOR iterate over modes in the same class as MODE, in order | |
| 1167 of increasing width. Start at the first mode wider than START, | |
| 1168 or don't iterate at all if there is no wider mode. */ | |
| 1169 #define FOR_EACH_WIDER_MODE(ITERATOR, START) \ | |
| 1170 for ((ITERATOR) = (START), mode_iterator::get_wider (&(ITERATOR)); \ | |
| 1171 mode_iterator::iterate_p (&(ITERATOR)); \ | |
| 1172 mode_iterator::get_wider (&(ITERATOR))) | |
| 1173 | |
| 1174 /* Make ITERATOR iterate over modes in the same class as MODE, in order | |
| 1175 of increasing width, and with each mode being twice the width of the | |
| 1176 previous mode. Start at the mode that is two times wider than START, | |
| 1177 or don't iterate at all if there is no such mode. */ | |
| 1178 #define FOR_EACH_2XWIDER_MODE(ITERATOR, START) \ | |
| 1179 for ((ITERATOR) = (START), mode_iterator::get_2xwider (&(ITERATOR)); \ | |
| 1180 mode_iterator::iterate_p (&(ITERATOR)); \ | |
| 1181 mode_iterator::get_2xwider (&(ITERATOR))) | |
| 1182 | |
| 1183 template<typename T> | |
| 1184 void | |
| 1185 gt_ggc_mx (pod_mode<T> *) | |
| 1186 { | |
| 1187 } | |
| 1188 | |
| 1189 template<typename T> | |
| 1190 void | |
| 1191 gt_pch_nx (pod_mode<T> *) | |
| 1192 { | |
| 1193 } | |
| 1194 | |
| 1195 template<typename T> | |
| 1196 void | |
| 1197 gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *) | |
| 1198 { | |
| 1199 } | |
| 1200 | |
| 0 | 1201 #endif /* not HAVE_MACHINE_MODES */ |