1 /* Machine mode definitions for GCC; included by rtl.h and tree.h. 2 Copyright (C) 1991-2021 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 HAVE_MACHINE_MODES 21 #define HAVE_MACHINE_MODES 22 23 typedef opt_mode<machine_mode> opt_machine_mode; 24 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]; 27 extern const unsigned char mode_inner[NUM_MACHINE_MODES]; 28 extern CONST_MODE_NUNITS poly_uint16_pod mode_nunits[NUM_MACHINE_MODES]; 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 }; 78 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 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]; 104 #define GET_MODE_CLASS(MODE) ((enum mode_class) mode_class[MODE]) 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 \ 111 || GET_MODE_CLASS (MODE) == MODE_VECTOR_BOOL \ 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. */ 127 #define VECTOR_MODE_P(MODE) \ 128 (GET_MODE_CLASS (MODE) == MODE_VECTOR_BOOL \ 129 || GET_MODE_CLASS (MODE) == MODE_VECTOR_INT \ 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 MODE is opaque. */ 229 #define OPAQUE_MODE_P(MODE) \ 230 (GET_MODE_CLASS (MODE) == MODE_OPAQUE) 231 232 /* Nonzero if CLASS modes can be widened. */ 233 #define CLASS_HAS_WIDER_MODES_P(CLASS) \ 234 (CLASS == MODE_INT \ 235 || CLASS == MODE_PARTIAL_INT \ 236 || CLASS == MODE_FLOAT \ 237 || CLASS == MODE_DECIMAL_FLOAT \ 238 || CLASS == MODE_COMPLEX_FLOAT \ 239 || CLASS == MODE_FRACT \ 240 || CLASS == MODE_UFRACT \ 241 || CLASS == MODE_ACCUM \ 242 || CLASS == MODE_UACCUM) 243 244 /* An optional T (i.e. a T or nothing), where T is some form of mode class. */ 245 template<typename T> 246 class opt_mode 247 { 248 public: 249 enum from_int { dummy = MAX_MACHINE_MODE }; 250 251 ALWAYS_INLINE CONSTEXPR opt_mode () : m_mode (E_VOIDmode) {} 252 ALWAYS_INLINE CONSTEXPR opt_mode (const T &m) : m_mode (m) {} 253 template<typename U> 254 ALWAYS_INLINE CONSTEXPR opt_mode (const U &m) : m_mode (T (m)) {} 255 ALWAYS_INLINE CONSTEXPR opt_mode (from_int m) : m_mode (machine_mode (m)) {} 256 257 machine_mode else_void () const; 258 machine_mode else_blk () const { return else_mode (BLKmode); } 259 machine_mode else_mode (machine_mode) const; 260 T require () const; 261 262 bool exists () const; 263 template<typename U> bool exists (U *) const; 264 265 bool operator== (const T &m) const { return m_mode == m; } 266 bool operator!= (const T &m) const { return m_mode != m; } 267 268 private: 269 machine_mode m_mode; 270 }; 271 272 /* If the object contains a T, return its enum value, otherwise return 273 E_VOIDmode. */ 274 275 template<typename T> 276 ALWAYS_INLINE machine_mode 277 opt_mode<T>::else_void () const 278 { 279 return m_mode; 280 } 281 282 /* If the T exists, return its enum value, otherwise return FALLBACK. */ 283 284 template<typename T> 285 inline machine_mode 286 opt_mode<T>::else_mode (machine_mode fallback) const 287 { 288 return m_mode == E_VOIDmode ? fallback : m_mode; 289 } 290 291 /* Assert that the object contains a T and return it. */ 292 293 template<typename T> 294 inline T 295 opt_mode<T>::require () const 296 { 297 gcc_checking_assert (m_mode != E_VOIDmode); 298 return typename mode_traits<T>::from_int (m_mode); 299 } 300 301 /* Return true if the object contains a T rather than nothing. */ 302 303 template<typename T> 304 ALWAYS_INLINE bool 305 opt_mode<T>::exists () const 306 { 307 return m_mode != E_VOIDmode; 308 } 309 310 /* Return true if the object contains a T, storing it in *MODE if so. */ 311 312 template<typename T> 313 template<typename U> 314 inline bool 315 opt_mode<T>::exists (U *mode) const 316 { 317 if (m_mode != E_VOIDmode) 318 { 319 *mode = T (typename mode_traits<T>::from_int (m_mode)); 320 return true; 321 } 322 return false; 323 } 324 325 /* A POD version of mode class T. */ 326 327 template<typename T> 328 struct pod_mode 329 { 330 typedef typename mode_traits<T>::from_int from_int; 331 typedef typename T::measurement_type measurement_type; 332 333 machine_mode m_mode; 334 ALWAYS_INLINE CONSTEXPR 335 operator machine_mode () const { return m_mode; } 336 337 ALWAYS_INLINE CONSTEXPR 338 operator T () const { return from_int (m_mode); } 339 340 ALWAYS_INLINE pod_mode &operator = (const T &m) { m_mode = m; return *this; } 341 }; 342 343 /* Return true if mode M has type T. */ 344 345 template<typename T> 346 inline bool 347 is_a (machine_mode m) 348 { 349 return T::includes_p (m); 350 } 351 352 template<typename T, typename U> 353 inline bool 354 is_a (const opt_mode<U> &m) 355 { 356 return T::includes_p (m.else_void ()); 357 } 358 359 /* Assert that mode M has type T, and return it in that form. */ 360 361 template<typename T> 362 inline T 363 as_a (machine_mode m) 364 { 365 gcc_checking_assert (T::includes_p (m)); 366 return typename mode_traits<T>::from_int (m); 367 } 368 369 template<typename T, typename U> 370 inline T 371 as_a (const opt_mode<U> &m) 372 { 373 return as_a <T> (m.else_void ()); 374 } 375 376 /* Convert M to an opt_mode<T>. */ 377 378 template<typename T> 379 inline opt_mode<T> 380 dyn_cast (machine_mode m) 381 { 382 if (T::includes_p (m)) 383 return T (typename mode_traits<T>::from_int (m)); 384 return opt_mode<T> (); 385 } 386 387 template<typename T, typename U> 388 inline opt_mode<T> 389 dyn_cast (const opt_mode<U> &m) 390 { 391 return dyn_cast <T> (m.else_void ()); 392 } 393 394 /* Return true if mode M has type T, storing it as a T in *RESULT 395 if so. */ 396 397 template<typename T, typename U> 398 inline bool 399 is_a (machine_mode m, U *result) 400 { 401 if (T::includes_p (m)) 402 { 403 *result = T (typename mode_traits<T>::from_int (m)); 404 return true; 405 } 406 return false; 407 } 408 409 /* Represents a machine mode that is known to be a SCALAR_INT_MODE_P. */ 410 class scalar_int_mode 411 { 412 public: 413 typedef mode_traits<scalar_int_mode>::from_int from_int; 414 typedef unsigned short measurement_type; 415 416 ALWAYS_INLINE scalar_int_mode () {} 417 418 ALWAYS_INLINE CONSTEXPR 419 scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {} 420 421 ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; } 422 423 static bool includes_p (machine_mode); 424 425 protected: 426 machine_mode m_mode; 427 }; 428 429 /* Return true if M is a scalar_int_mode. */ 430 431 inline bool 432 scalar_int_mode::includes_p (machine_mode m) 433 { 434 return SCALAR_INT_MODE_P (m); 435 } 436 437 /* Represents a machine mode that is known to be a SCALAR_FLOAT_MODE_P. */ 438 class scalar_float_mode 439 { 440 public: 441 typedef mode_traits<scalar_float_mode>::from_int from_int; 442 typedef unsigned short measurement_type; 443 444 ALWAYS_INLINE scalar_float_mode () {} 445 446 ALWAYS_INLINE CONSTEXPR 447 scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {} 448 449 ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; } 450 451 static bool includes_p (machine_mode); 452 453 protected: 454 machine_mode m_mode; 455 }; 456 457 /* Return true if M is a scalar_float_mode. */ 458 459 inline bool 460 scalar_float_mode::includes_p (machine_mode m) 461 { 462 return SCALAR_FLOAT_MODE_P (m); 463 } 464 465 /* Represents a machine mode that is known to be scalar. */ 466 class scalar_mode 467 { 468 public: 469 typedef mode_traits<scalar_mode>::from_int from_int; 470 typedef unsigned short measurement_type; 471 472 ALWAYS_INLINE scalar_mode () {} 473 474 ALWAYS_INLINE CONSTEXPR 475 scalar_mode (from_int m) : m_mode (machine_mode (m)) {} 476 477 ALWAYS_INLINE CONSTEXPR 478 scalar_mode (const scalar_int_mode &m) : m_mode (m) {} 479 480 ALWAYS_INLINE CONSTEXPR 481 scalar_mode (const scalar_float_mode &m) : m_mode (m) {} 482 483 ALWAYS_INLINE CONSTEXPR 484 scalar_mode (const scalar_int_mode_pod &m) : m_mode (m) {} 485 486 ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; } 487 488 static bool includes_p (machine_mode); 489 490 protected: 491 machine_mode m_mode; 492 }; 493 494 /* Return true if M represents some kind of scalar value. */ 495 496 inline bool 497 scalar_mode::includes_p (machine_mode m) 498 { 499 switch (GET_MODE_CLASS (m)) 500 { 501 case MODE_INT: 502 case MODE_PARTIAL_INT: 503 case MODE_FRACT: 504 case MODE_UFRACT: 505 case MODE_ACCUM: 506 case MODE_UACCUM: 507 case MODE_FLOAT: 508 case MODE_DECIMAL_FLOAT: 509 return true; 510 default: 511 return false; 512 } 513 } 514 515 /* Represents a machine mode that is known to be a COMPLEX_MODE_P. */ 516 class complex_mode 517 { 518 public: 519 typedef mode_traits<complex_mode>::from_int from_int; 520 typedef unsigned short measurement_type; 521 522 ALWAYS_INLINE complex_mode () {} 523 524 ALWAYS_INLINE CONSTEXPR 525 complex_mode (from_int m) : m_mode (machine_mode (m)) {} 526 527 ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; } 528 529 static bool includes_p (machine_mode); 530 531 protected: 532 machine_mode m_mode; 533 }; 534 535 /* Return true if M is a complex_mode. */ 536 537 inline bool 538 complex_mode::includes_p (machine_mode m) 539 { 540 return COMPLEX_MODE_P (m); 541 } 542 543 /* Return the base GET_MODE_SIZE value for MODE. */ 544 545 ALWAYS_INLINE poly_uint16 546 mode_to_bytes (machine_mode mode) 547 { 548 #if GCC_VERSION >= 4001 549 return (__builtin_constant_p (mode) 550 ? mode_size_inline (mode) : mode_size[mode]); 551 #else 552 return mode_size[mode]; 553 #endif 554 } 555 556 /* Return the base GET_MODE_BITSIZE value for MODE. */ 557 558 ALWAYS_INLINE poly_uint16 559 mode_to_bits (machine_mode mode) 560 { 561 return mode_to_bytes (mode) * BITS_PER_UNIT; 562 } 563 564 /* Return the base GET_MODE_PRECISION value for MODE. */ 565 566 ALWAYS_INLINE poly_uint16 567 mode_to_precision (machine_mode mode) 568 { 569 return mode_precision[mode]; 570 } 571 572 /* Return the base GET_MODE_INNER value for MODE. */ 573 574 ALWAYS_INLINE scalar_mode 575 mode_to_inner (machine_mode mode) 576 { 577 #if GCC_VERSION >= 4001 578 return scalar_mode::from_int (__builtin_constant_p (mode) 579 ? mode_inner_inline (mode) 580 : mode_inner[mode]); 581 #else 582 return scalar_mode::from_int (mode_inner[mode]); 583 #endif 584 } 585 586 /* Return the base GET_MODE_UNIT_SIZE value for MODE. */ 587 588 ALWAYS_INLINE unsigned char 589 mode_to_unit_size (machine_mode mode) 590 { 591 #if GCC_VERSION >= 4001 592 return (__builtin_constant_p (mode) 593 ? mode_unit_size_inline (mode) : mode_unit_size[mode]); 594 #else 595 return mode_unit_size[mode]; 596 #endif 597 } 598 599 /* Return the base GET_MODE_UNIT_PRECISION value for MODE. */ 600 601 ALWAYS_INLINE unsigned short 602 mode_to_unit_precision (machine_mode mode) 603 { 604 #if GCC_VERSION >= 4001 605 return (__builtin_constant_p (mode) 606 ? mode_unit_precision_inline (mode) : mode_unit_precision[mode]); 607 #else 608 return mode_unit_precision[mode]; 609 #endif 610 } 611 612 /* Return the base GET_MODE_NUNITS value for MODE. */ 613 614 ALWAYS_INLINE poly_uint16 615 mode_to_nunits (machine_mode mode) 616 { 617 #if GCC_VERSION >= 4001 618 return (__builtin_constant_p (mode) 619 ? mode_nunits_inline (mode) : mode_nunits[mode]); 620 #else 621 return mode_nunits[mode]; 622 #endif 623 } 624 625 /* Get the size in bytes of an object of mode MODE. */ 626 627 #if ONLY_FIXED_SIZE_MODES 628 #define GET_MODE_SIZE(MODE) ((unsigned short) mode_to_bytes (MODE).coeffs[0]) 629 #else 630 ALWAYS_INLINE poly_uint16 631 GET_MODE_SIZE (machine_mode mode) 632 { 633 return mode_to_bytes (mode); 634 } 635 636 template<typename T> 637 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type 638 GET_MODE_SIZE (const T &mode) 639 { 640 return mode_to_bytes (mode); 641 } 642 643 template<typename T> 644 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type 645 GET_MODE_SIZE (const T &mode) 646 { 647 return mode_to_bytes (mode).coeffs[0]; 648 } 649 #endif 650 651 /* Get the size in bits of an object of mode MODE. */ 652 653 #if ONLY_FIXED_SIZE_MODES 654 #define GET_MODE_BITSIZE(MODE) ((unsigned short) mode_to_bits (MODE).coeffs[0]) 655 #else 656 ALWAYS_INLINE poly_uint16 657 GET_MODE_BITSIZE (machine_mode mode) 658 { 659 return mode_to_bits (mode); 660 } 661 662 template<typename T> 663 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type 664 GET_MODE_BITSIZE (const T &mode) 665 { 666 return mode_to_bits (mode); 667 } 668 669 template<typename T> 670 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type 671 GET_MODE_BITSIZE (const T &mode) 672 { 673 return mode_to_bits (mode).coeffs[0]; 674 } 675 #endif 676 677 /* Get the number of value bits of an object of mode MODE. */ 678 679 #if ONLY_FIXED_SIZE_MODES 680 #define GET_MODE_PRECISION(MODE) \ 681 ((unsigned short) mode_to_precision (MODE).coeffs[0]) 682 #else 683 ALWAYS_INLINE poly_uint16 684 GET_MODE_PRECISION (machine_mode mode) 685 { 686 return mode_to_precision (mode); 687 } 688 689 template<typename T> 690 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type 691 GET_MODE_PRECISION (const T &mode) 692 { 693 return mode_to_precision (mode); 694 } 695 696 template<typename T> 697 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type 698 GET_MODE_PRECISION (const T &mode) 699 { 700 return mode_to_precision (mode).coeffs[0]; 701 } 702 #endif 703 704 /* Get the number of integral bits of an object of mode MODE. */ 705 extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES]; 706 #define GET_MODE_IBIT(MODE) mode_ibit[MODE] 707 708 /* Get the number of fractional bits of an object of mode MODE. */ 709 extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES]; 710 #define GET_MODE_FBIT(MODE) mode_fbit[MODE] 711 712 /* Get a bitmask containing 1 for all bits in a word 713 that fit within mode MODE. */ 714 715 extern CONST_MODE_MASK unsigned HOST_WIDE_INT 716 mode_mask_array[NUM_MACHINE_MODES]; 717 718 #define GET_MODE_MASK(MODE) mode_mask_array[MODE] 719 720 /* Return the mode of the basic parts of MODE. For vector modes this is the 721 mode of the vector elements. For complex modes it is the mode of the real 722 and imaginary parts. For other modes it is MODE itself. */ 723 724 #define GET_MODE_INNER(MODE) (mode_to_inner (MODE)) 725 726 /* Get the size in bytes or bits of the basic parts of an 727 object of mode MODE. */ 728 729 #define GET_MODE_UNIT_SIZE(MODE) mode_to_unit_size (MODE) 730 731 #define GET_MODE_UNIT_BITSIZE(MODE) \ 732 ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT)) 733 734 #define GET_MODE_UNIT_PRECISION(MODE) (mode_to_unit_precision (MODE)) 735 736 /* Get the number of units in an object of mode MODE. This is 2 for 737 complex modes and the number of elements for vector modes. */ 738 739 #if ONLY_FIXED_SIZE_MODES 740 #define GET_MODE_NUNITS(MODE) (mode_to_nunits (MODE).coeffs[0]) 741 #else 742 ALWAYS_INLINE poly_uint16 743 GET_MODE_NUNITS (machine_mode mode) 744 { 745 return mode_to_nunits (mode); 746 } 747 748 template<typename T> 749 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type 750 GET_MODE_NUNITS (const T &mode) 751 { 752 return mode_to_nunits (mode); 753 } 754 755 template<typename T> 756 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type 757 GET_MODE_NUNITS (const T &mode) 758 { 759 return mode_to_nunits (mode).coeffs[0]; 760 } 761 #endif 762 763 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI). */ 764 765 template<typename T> 766 ALWAYS_INLINE opt_mode<T> 767 GET_MODE_WIDER_MODE (const T &m) 768 { 769 return typename opt_mode<T>::from_int (mode_wider[m]); 770 } 771 772 /* For scalars, this is a mode with twice the precision. For vectors, 773 this is a mode with the same inner mode but with twice the elements. */ 774 775 template<typename T> 776 ALWAYS_INLINE opt_mode<T> 777 GET_MODE_2XWIDER_MODE (const T &m) 778 { 779 return typename opt_mode<T>::from_int (mode_2xwider[m]); 780 } 781 782 /* Get the complex mode from the component mode. */ 783 extern const unsigned char mode_complex[NUM_MACHINE_MODES]; 784 #define GET_MODE_COMPLEX_MODE(MODE) ((machine_mode) mode_complex[MODE]) 785 786 /* Represents a machine mode that must have a fixed size. The main 787 use of this class is to represent the modes of objects that always 788 have static storage duration, such as constant pool entries. 789 (No current target supports the concept of variable-size static data.) */ 790 class fixed_size_mode 791 { 792 public: 793 typedef mode_traits<fixed_size_mode>::from_int from_int; 794 typedef unsigned short measurement_type; 795 796 ALWAYS_INLINE fixed_size_mode () {} 797 798 ALWAYS_INLINE CONSTEXPR 799 fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {} 800 801 ALWAYS_INLINE CONSTEXPR 802 fixed_size_mode (const scalar_mode &m) : m_mode (m) {} 803 804 ALWAYS_INLINE CONSTEXPR 805 fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {} 806 807 ALWAYS_INLINE CONSTEXPR 808 fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {} 809 810 ALWAYS_INLINE CONSTEXPR 811 fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {} 812 813 ALWAYS_INLINE CONSTEXPR 814 fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {} 815 816 ALWAYS_INLINE CONSTEXPR 817 fixed_size_mode (const complex_mode &m) : m_mode (m) {} 818 819 ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; } 820 821 static bool includes_p (machine_mode); 822 823 protected: 824 machine_mode m_mode; 825 }; 826 827 /* Return true if MODE has a fixed size. */ 828 829 inline bool 830 fixed_size_mode::includes_p (machine_mode mode) 831 { 832 return mode_to_bytes (mode).is_constant (); 833 } 834 835 /* Wrapper for mode arguments to target macros, so that if a target 836 doesn't need polynomial-sized modes, its header file can continue 837 to treat everything as fixed_size_mode. This should go away once 838 macros are moved to target hooks. It shouldn't be used in other 839 contexts. */ 840 #if NUM_POLY_INT_COEFFS == 1 841 #define MACRO_MODE(MODE) (as_a <fixed_size_mode> (MODE)) 842 #else 843 #define MACRO_MODE(MODE) (MODE) 844 #endif 845 846 extern opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int); 847 848 /* Return the machine mode to use for a MODE_INT of SIZE bits, if one 849 exists. If LIMIT is nonzero, modes wider than MAX_FIXED_MODE_SIZE 850 will not be used. */ 851 852 inline opt_scalar_int_mode 853 int_mode_for_size (poly_uint64 size, int limit) 854 { 855 return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit)); 856 } 857 858 /* Return the machine mode to use for a MODE_FLOAT of SIZE bits, if one 859 exists. */ 860 861 inline opt_scalar_float_mode 862 float_mode_for_size (poly_uint64 size) 863 { 864 return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0)); 865 } 866 867 /* Likewise for MODE_DECIMAL_FLOAT. */ 868 869 inline opt_scalar_float_mode 870 decimal_float_mode_for_size (unsigned int size) 871 { 872 return dyn_cast <scalar_float_mode> 873 (mode_for_size (size, MODE_DECIMAL_FLOAT, 0)); 874 } 875 876 extern machine_mode smallest_mode_for_size (poly_uint64, enum mode_class); 877 878 /* Find the narrowest integer mode that contains at least SIZE bits. 879 Such a mode must exist. */ 880 881 inline scalar_int_mode 882 smallest_int_mode_for_size (poly_uint64 size) 883 { 884 return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT)); 885 } 886 887 extern opt_scalar_int_mode int_mode_for_mode (machine_mode); 888 extern opt_machine_mode bitwise_mode_for_mode (machine_mode); 889 extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64); 890 extern opt_machine_mode related_vector_mode (machine_mode, scalar_mode, 891 poly_uint64 = 0); 892 extern opt_machine_mode related_int_vector_mode (machine_mode); 893 894 /* A class for iterating through possible bitfield modes. */ 895 class bit_field_mode_iterator 896 { 897 public: 898 bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT, 899 poly_int64, poly_int64, 900 unsigned int, bool); 901 bool next_mode (scalar_int_mode *); 902 bool prefer_smaller_modes (); 903 904 private: 905 opt_scalar_int_mode m_mode; 906 /* We use signed values here because the bit position can be negative 907 for invalid input such as gcc.dg/pr48335-8.c. */ 908 HOST_WIDE_INT m_bitsize; 909 HOST_WIDE_INT m_bitpos; 910 poly_int64 m_bitregion_start; 911 poly_int64 m_bitregion_end; 912 unsigned int m_align; 913 bool m_volatilep; 914 int m_count; 915 }; 916 917 /* Find the best mode to use to access a bit field. */ 918 919 extern bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int, 920 unsigned HOST_WIDE_INT, bool, scalar_int_mode *); 921 922 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT. */ 923 924 extern CONST_MODE_BASE_ALIGN unsigned short mode_base_align[NUM_MACHINE_MODES]; 925 926 extern unsigned get_mode_alignment (machine_mode); 927 928 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE) 929 930 /* For each class, get the narrowest mode in that class. */ 931 932 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS]; 933 #define GET_CLASS_NARROWEST_MODE(CLASS) \ 934 ((machine_mode) class_narrowest_mode[CLASS]) 935 936 /* The narrowest full integer mode available on the target. */ 937 938 #define NARROWEST_INT_MODE \ 939 (scalar_int_mode \ 940 (scalar_int_mode::from_int (class_narrowest_mode[MODE_INT]))) 941 942 /* Return the narrowest mode in T's class. */ 943 944 template<typename T> 945 inline T 946 get_narrowest_mode (T mode) 947 { 948 return typename mode_traits<T>::from_int 949 (class_narrowest_mode[GET_MODE_CLASS (mode)]); 950 } 951 952 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD 953 and the mode whose class is Pmode and whose size is POINTER_SIZE. */ 954 955 extern scalar_int_mode byte_mode; 956 extern scalar_int_mode word_mode; 957 extern scalar_int_mode ptr_mode; 958 959 /* Target-dependent machine mode initialization - in insn-modes.c. */ 960 extern void init_adjust_machine_modes (void); 961 962 #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \ 963 (targetm.truly_noop_truncation (GET_MODE_PRECISION (MODE1), \ 964 GET_MODE_PRECISION (MODE2))) 965 966 /* Return true if MODE is a scalar integer mode that fits in a 967 HOST_WIDE_INT. */ 968 969 inline bool 970 HWI_COMPUTABLE_MODE_P (machine_mode mode) 971 { 972 machine_mode mme = mode; 973 return (SCALAR_INT_MODE_P (mme) 974 && mode_to_precision (mme).coeffs[0] <= HOST_BITS_PER_WIDE_INT); 975 } 976 977 inline bool 978 HWI_COMPUTABLE_MODE_P (scalar_int_mode mode) 979 { 980 return GET_MODE_PRECISION (mode) <= HOST_BITS_PER_WIDE_INT; 981 } 982 983 struct int_n_data_t { 984 /* These parts are initailized by genmodes output */ 985 unsigned int bitsize; 986 scalar_int_mode_pod m; 987 /* RID_* is RID_INTN_BASE + index into this array */ 988 }; 989 990 /* This is also in tree.h. genmodes.c guarantees the're sorted from 991 smallest bitsize to largest bitsize. */ 992 extern bool int_n_enabled_p[NUM_INT_N_ENTS]; 993 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS]; 994 995 /* Return true if MODE has class MODE_INT, storing it as a scalar_int_mode 996 in *INT_MODE if so. */ 997 998 template<typename T> 999 inline bool 1000 is_int_mode (machine_mode mode, T *int_mode) 1001 { 1002 if (GET_MODE_CLASS (mode) == MODE_INT) 1003 { 1004 *int_mode = scalar_int_mode (scalar_int_mode::from_int (mode)); 1005 return true; 1006 } 1007 return false; 1008 } 1009 1010 /* Return true if MODE has class MODE_FLOAT, storing it as a 1011 scalar_float_mode in *FLOAT_MODE if so. */ 1012 1013 template<typename T> 1014 inline bool 1015 is_float_mode (machine_mode mode, T *float_mode) 1016 { 1017 if (GET_MODE_CLASS (mode) == MODE_FLOAT) 1018 { 1019 *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode)); 1020 return true; 1021 } 1022 return false; 1023 } 1024 1025 /* Return true if MODE has class MODE_COMPLEX_INT, storing it as 1026 a complex_mode in *CMODE if so. */ 1027 1028 template<typename T> 1029 inline bool 1030 is_complex_int_mode (machine_mode mode, T *cmode) 1031 { 1032 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT) 1033 { 1034 *cmode = complex_mode (complex_mode::from_int (mode)); 1035 return true; 1036 } 1037 return false; 1038 } 1039 1040 /* Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as 1041 a complex_mode in *CMODE if so. */ 1042 1043 template<typename T> 1044 inline bool 1045 is_complex_float_mode (machine_mode mode, T *cmode) 1046 { 1047 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT) 1048 { 1049 *cmode = complex_mode (complex_mode::from_int (mode)); 1050 return true; 1051 } 1052 return false; 1053 } 1054 1055 /* Return true if MODE is a scalar integer mode with a precision 1056 smaller than LIMIT's precision. */ 1057 1058 inline bool 1059 is_narrower_int_mode (machine_mode mode, scalar_int_mode limit) 1060 { 1061 scalar_int_mode int_mode; 1062 return (is_a <scalar_int_mode> (mode, &int_mode) 1063 && GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit)); 1064 } 1065 1066 namespace mode_iterator 1067 { 1068 /* Start mode iterator *ITER at the first mode in class MCLASS, if any. */ 1069 1070 template<typename T> 1071 inline void 1072 start (opt_mode<T> *iter, enum mode_class mclass) 1073 { 1074 if (GET_CLASS_NARROWEST_MODE (mclass) == E_VOIDmode) 1075 *iter = opt_mode<T> (); 1076 else 1077 *iter = as_a<T> (GET_CLASS_NARROWEST_MODE (mclass)); 1078 } 1079 1080 inline void 1081 start (machine_mode *iter, enum mode_class mclass) 1082 { 1083 *iter = GET_CLASS_NARROWEST_MODE (mclass); 1084 } 1085 1086 /* Return true if mode iterator *ITER has not reached the end. */ 1087 1088 template<typename T> 1089 inline bool 1090 iterate_p (opt_mode<T> *iter) 1091 { 1092 return iter->exists (); 1093 } 1094 1095 inline bool 1096 iterate_p (machine_mode *iter) 1097 { 1098 return *iter != E_VOIDmode; 1099 } 1100 1101 /* Set mode iterator *ITER to the next widest mode in the same class, 1102 if any. */ 1103 1104 template<typename T> 1105 inline void 1106 get_wider (opt_mode<T> *iter) 1107 { 1108 *iter = GET_MODE_WIDER_MODE (iter->require ()); 1109 } 1110 1111 inline void 1112 get_wider (machine_mode *iter) 1113 { 1114 *iter = GET_MODE_WIDER_MODE (*iter).else_void (); 1115 } 1116 1117 /* Set mode iterator *ITER to the next widest mode in the same class. 1118 Such a mode is known to exist. */ 1119 1120 template<typename T> 1121 inline void 1122 get_known_wider (T *iter) 1123 { 1124 *iter = GET_MODE_WIDER_MODE (*iter).require (); 1125 } 1126 1127 /* Set mode iterator *ITER to the mode that is two times wider than the 1128 current one, if such a mode exists. */ 1129 1130 template<typename T> 1131 inline void 1132 get_2xwider (opt_mode<T> *iter) 1133 { 1134 *iter = GET_MODE_2XWIDER_MODE (iter->require ()); 1135 } 1136 1137 inline void 1138 get_2xwider (machine_mode *iter) 1139 { 1140 *iter = GET_MODE_2XWIDER_MODE (*iter).else_void (); 1141 } 1142 } 1143 1144 /* Make ITERATOR iterate over all the modes in mode class CLASS, 1145 from narrowest to widest. */ 1146 #define FOR_EACH_MODE_IN_CLASS(ITERATOR, CLASS) \ 1147 for (mode_iterator::start (&(ITERATOR), CLASS); \ 1148 mode_iterator::iterate_p (&(ITERATOR)); \ 1149 mode_iterator::get_wider (&(ITERATOR))) 1150 1151 /* Make ITERATOR iterate over all the modes in the range [START, END), 1152 in order of increasing width. */ 1153 #define FOR_EACH_MODE(ITERATOR, START, END) \ 1154 for ((ITERATOR) = (START); \ 1155 (ITERATOR) != (END); \ 1156 mode_iterator::get_known_wider (&(ITERATOR))) 1157 1158 /* Make ITERATOR iterate over START and all wider modes in the same 1159 class, in order of increasing width. */ 1160 #define FOR_EACH_MODE_FROM(ITERATOR, START) \ 1161 for ((ITERATOR) = (START); \ 1162 mode_iterator::iterate_p (&(ITERATOR)); \ 1163 mode_iterator::get_wider (&(ITERATOR))) 1164 1165 /* Make ITERATOR iterate over modes in the range [NARROWEST, END) 1166 in order of increasing width, where NARROWEST is the narrowest mode 1167 in END's class. */ 1168 #define FOR_EACH_MODE_UNTIL(ITERATOR, END) \ 1169 FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END) 1170 1171 /* Make ITERATOR iterate over modes in the same class as MODE, in order 1172 of increasing width. Start at the first mode wider than START, 1173 or don't iterate at all if there is no wider mode. */ 1174 #define FOR_EACH_WIDER_MODE(ITERATOR, START) \ 1175 for ((ITERATOR) = (START), mode_iterator::get_wider (&(ITERATOR)); \ 1176 mode_iterator::iterate_p (&(ITERATOR)); \ 1177 mode_iterator::get_wider (&(ITERATOR))) 1178 1179 /* Make ITERATOR iterate over modes in the same class as MODE, in order 1180 of increasing width, and with each mode being twice the width of the 1181 previous mode. Start at the mode that is two times wider than START, 1182 or don't iterate at all if there is no such mode. */ 1183 #define FOR_EACH_2XWIDER_MODE(ITERATOR, START) \ 1184 for ((ITERATOR) = (START), mode_iterator::get_2xwider (&(ITERATOR)); \ 1185 mode_iterator::iterate_p (&(ITERATOR)); \ 1186 mode_iterator::get_2xwider (&(ITERATOR))) 1187 1188 template<typename T> 1189 void 1190 gt_ggc_mx (pod_mode<T> *) 1191 { 1192 } 1193 1194 template<typename T> 1195 void 1196 gt_pch_nx (pod_mode<T> *) 1197 { 1198 } 1199 1200 template<typename T> 1201 void 1202 gt_pch_nx (pod_mode<T> *, void (*) (void *, void *), void *) 1203 { 1204 } 1205 1206 #endif /* not HAVE_MACHINE_MODES */ 1207