sdcc/support/cpp/gcc/machmode.h

   1 /* Machine mode definitions for GCC; included by rtl.h and tree.h.
   2    Copyright (C) 1991-2022 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 // sdcpp extern CONST_MODE_SIZE poly_uint16_pod mode_size[NUM_MACHINE_MODES];
  26 // sdcpp extern CONST_MODE_PRECISION poly_uint16_pod mode_precision[NUM_MACHINE_MODES];
  27 extern const unsigned char mode_inner[NUM_MACHINE_MODES];
  28 // sdcpp extern CONST_MODE_NUNITS poly_uint16_pod mode_nunits[NUM_MACHINE_MODES];
  29 // sdcpp extern CONST_MODE_UNIT_SIZE unsigned char mode_unit_size[NUM_MACHINE_MODES];
  30 // sdcpp extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES];
  31 // sdcpp extern const unsigned char mode_wider[NUM_MACHINE_MODES];
  32 // sdcpp 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 #if 0 // sdcpp
 546 ALWAYS_INLINE poly_uint16
 547 mode_to_bytes (machine_mode mode)
 548 {
 549 #if GCC_VERSION >= 4001
 550   return (__builtin_constant_p (mode)
 551           ? mode_size_inline (mode) : mode_size[mode]);
 552 #else
 553   return mode_size[mode];
 554 #endif
 555 }
 556
 557 /* Return the base GET_MODE_BITSIZE value for MODE.  */
 558
 559 ALWAYS_INLINE poly_uint16
 560 mode_to_bits (machine_mode mode)
 561 {
 562   return mode_to_bytes (mode) * BITS_PER_UNIT;
 563 }
 564
 565 /* Return the base GET_MODE_PRECISION value for MODE.  */
 566
 567 ALWAYS_INLINE poly_uint16
 568 mode_to_precision (machine_mode mode)
 569 {
 570   return mode_precision[mode];
 571 }
 572
 573 /* Return the base GET_MODE_INNER value for MODE.  */
 574 #endif // sdcpp
 575
 576 ALWAYS_INLINE scalar_mode
 577 mode_to_inner (machine_mode mode)
 578 {
 579 #if GCC_VERSION >= 4001
 580   return scalar_mode::from_int (__builtin_constant_p (mode)
 581                                 ? mode_inner_inline (mode)
 582                                 : mode_inner[mode]);
 583 #else
 584   return scalar_mode::from_int (mode_inner[mode]);
 585 #endif
 586 }
 587
 588 #if 0 // sdcpp
 589
 590 /* Return the base GET_MODE_UNIT_SIZE value for MODE.  */
 591
 592 ALWAYS_INLINE unsigned char
 593 mode_to_unit_size (machine_mode mode)
 594 {
 595 #if GCC_VERSION >= 4001
 596   return (__builtin_constant_p (mode)
 597           ? mode_unit_size_inline (mode) : mode_unit_size[mode]);
 598 #else
 599   return mode_unit_size[mode];
 600 #endif
 601 }
 602
 603 /* Return the base GET_MODE_UNIT_PRECISION value for MODE.  */
 604
 605 ALWAYS_INLINE unsigned short
 606 mode_to_unit_precision (machine_mode mode)
 607 {
 608 #if GCC_VERSION >= 4001
 609   return (__builtin_constant_p (mode)
 610           ? mode_unit_precision_inline (mode) : mode_unit_precision[mode]);
 611 #else
 612   return mode_unit_precision[mode];
 613 #endif
 614 }
 615
 616 /* Return the base GET_MODE_NUNITS value for MODE.  */
 617
 618 ALWAYS_INLINE poly_uint16
 619 mode_to_nunits (machine_mode mode)
 620 {
 621 #if GCC_VERSION >= 4001
 622   return (__builtin_constant_p (mode)
 623           ? mode_nunits_inline (mode) : mode_nunits[mode]);
 624 #else
 625   return mode_nunits[mode];
 626 #endif
 627 }
 628
 629 /* Get the size in bytes of an object of mode MODE.  */
 630
 631 #if ONLY_FIXED_SIZE_MODES
 632 #define GET_MODE_SIZE(MODE) ((unsigned short) mode_to_bytes (MODE).coeffs[0])
 633 #else
 634 ALWAYS_INLINE poly_uint16
 635 GET_MODE_SIZE (machine_mode mode)
 636 {
 637   return mode_to_bytes (mode);
 638 }
 639
 640 template<typename T>
 641 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 642 GET_MODE_SIZE (const T &mode)
 643 {
 644   return mode_to_bytes (mode);
 645 }
 646
 647 template<typename T>
 648 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 649 GET_MODE_SIZE (const T &mode)
 650 {
 651   return mode_to_bytes (mode).coeffs[0];
 652 }
 653 #endif
 654 #endif // sdcpp
 655
 656 /* Get the size in bits of an object of mode MODE.  */
 657
 658 #if 0 // sdcpp
 659 #if ONLY_FIXED_SIZE_MODES
 660 #define GET_MODE_BITSIZE(MODE) ((unsigned short) mode_to_bits (MODE).coeffs[0])
 661 #else
 662 ALWAYS_INLINE poly_uint16
 663 GET_MODE_BITSIZE (machine_mode mode)
 664 {
 665   return mode_to_bits (mode);
 666 }
 667
 668 template<typename T>
 669 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 670 GET_MODE_BITSIZE (const T &mode)
 671 {
 672   return mode_to_bits (mode);
 673 }
 674
 675 template<typename T>
 676 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 677 GET_MODE_BITSIZE (const T &mode)
 678 {
 679   return mode_to_bits (mode).coeffs[0];
 680 }
 681 #endif
 682
 683 /* Get the number of value bits of an object of mode MODE.  */
 684
 685 #if ONLY_FIXED_SIZE_MODES
 686 #define GET_MODE_PRECISION(MODE) \
 687   ((unsigned short) mode_to_precision (MODE).coeffs[0])
 688 #else
 689 ALWAYS_INLINE poly_uint16
 690 GET_MODE_PRECISION (machine_mode mode)
 691 {
 692   return mode_to_precision (mode);
 693 }
 694
 695 template<typename T>
 696 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 697 GET_MODE_PRECISION (const T &mode)
 698 {
 699   return mode_to_precision (mode);
 700 }
 701
 702 template<typename T>
 703 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 704 GET_MODE_PRECISION (const T &mode)
 705 {
 706   return mode_to_precision (mode).coeffs[0];
 707 }
 708 #endif
 709
 710 /* Get the number of integral bits of an object of mode MODE.  */
 711 extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES];
 712 #define GET_MODE_IBIT(MODE) mode_ibit[MODE]
 713
 714 /* Get the number of fractional bits of an object of mode MODE.  */
 715 extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES];
 716 #define GET_MODE_FBIT(MODE) mode_fbit[MODE]
 717
 718 /* Get a bitmask containing 1 for all bits in a word
 719    that fit within mode MODE.  */
 720
 721 extern CONST_MODE_MASK unsigned HOST_WIDE_INT
 722   mode_mask_array[NUM_MACHINE_MODES];
 723
 724 #define GET_MODE_MASK(MODE) mode_mask_array[MODE]
 725
 726 /* Return the mode of the basic parts of MODE.  For vector modes this is the
 727    mode of the vector elements.  For complex modes it is the mode of the real
 728    and imaginary parts.  For other modes it is MODE itself.  */
 729 #endif // sdcpp
 730
 731 #define GET_MODE_INNER(MODE) (mode_to_inner (MODE))
 732
 733 #if 0 // sdcpp
 734
 735 /* Get the size in bytes or bits of the basic parts of an
 736    object of mode MODE.  */
 737
 738 #define GET_MODE_UNIT_SIZE(MODE) mode_to_unit_size (MODE)
 739
 740 #define GET_MODE_UNIT_BITSIZE(MODE) \
 741   ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))
 742
 743 #define GET_MODE_UNIT_PRECISION(MODE) (mode_to_unit_precision (MODE))
 744
 745 /* Get the number of units in an object of mode MODE.  This is 2 for
 746    complex modes and the number of elements for vector modes.  */
 747
 748 #if ONLY_FIXED_SIZE_MODES
 749 #define GET_MODE_NUNITS(MODE) (mode_to_nunits (MODE).coeffs[0])
 750 #else
 751 ALWAYS_INLINE poly_uint16
 752 GET_MODE_NUNITS (machine_mode mode)
 753 {
 754   return mode_to_nunits (mode);
 755 }
 756
 757 template<typename T>
 758 ALWAYS_INLINE typename if_poly<typename T::measurement_type>::type
 759 GET_MODE_NUNITS (const T &mode)
 760 {
 761   return mode_to_nunits (mode);
 762 }
 763
 764 template<typename T>
 765 ALWAYS_INLINE typename if_nonpoly<typename T::measurement_type>::type
 766 GET_MODE_NUNITS (const T &mode)
 767 {
 768   return mode_to_nunits (mode).coeffs[0];
 769 }
 770 #endif
 771
 772 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI).  */
 773
 774 template<typename T>
 775 ALWAYS_INLINE opt_mode<T>
 776 GET_MODE_WIDER_MODE (const T &m)
 777 {
 778   return typename opt_mode<T>::from_int (mode_wider[m]);
 779 }
 780
 781 /* For scalars, this is a mode with twice the precision.  For vectors,
 782    this is a mode with the same inner mode but with twice the elements.  */
 783
 784 template<typename T>
 785 ALWAYS_INLINE opt_mode<T>
 786 GET_MODE_2XWIDER_MODE (const T &m)
 787 {
 788   return typename opt_mode<T>::from_int (mode_2xwider[m]);
 789 }
 790
 791 /* Get the complex mode from the component mode.  */
 792 extern const unsigned char mode_complex[NUM_MACHINE_MODES];
 793 #define GET_MODE_COMPLEX_MODE(MODE) ((machine_mode) mode_complex[MODE])
 794
 795 /* Represents a machine mode that must have a fixed size.  The main
 796    use of this class is to represent the modes of objects that always
 797    have static storage duration, such as constant pool entries.
 798    (No current target supports the concept of variable-size static data.)  */
 799 class fixed_size_mode
 800 {
 801 public:
 802   typedef mode_traits<fixed_size_mode>::from_int from_int;
 803   typedef unsigned short measurement_type;
 804
 805   ALWAYS_INLINE fixed_size_mode () {}
 806
 807   ALWAYS_INLINE CONSTEXPR
 808   fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {}
 809
 810   ALWAYS_INLINE CONSTEXPR
 811   fixed_size_mode (const scalar_mode &m) : m_mode (m) {}
 812
 813   ALWAYS_INLINE CONSTEXPR
 814   fixed_size_mode (const scalar_int_mode &m) : m_mode (m) {}
 815
 816   ALWAYS_INLINE CONSTEXPR
 817   fixed_size_mode (const scalar_float_mode &m) : m_mode (m) {}
 818
 819   ALWAYS_INLINE CONSTEXPR
 820   fixed_size_mode (const scalar_mode_pod &m) : m_mode (m) {}
 821
 822   ALWAYS_INLINE CONSTEXPR
 823   fixed_size_mode (const scalar_int_mode_pod &m) : m_mode (m) {}
 824
 825   ALWAYS_INLINE CONSTEXPR
 826   fixed_size_mode (const complex_mode &m) : m_mode (m) {}
 827
 828   ALWAYS_INLINE CONSTEXPR operator machine_mode () const { return m_mode; }
 829
 830   static bool includes_p (machine_mode);
 831
 832 protected:
 833   machine_mode m_mode;
 834 };
 835
 836 /* Return true if MODE has a fixed size.  */
 837
 838 inline bool
 839 fixed_size_mode::includes_p (machine_mode mode)
 840 {
 841   return mode_to_bytes (mode).is_constant ();
 842 }
 843
 844 /* Wrapper for mode arguments to target macros, so that if a target
 845    doesn't need polynomial-sized modes, its header file can continue
 846    to treat everything as fixed_size_mode.  This should go away once
 847    macros are moved to target hooks.  It shouldn't be used in other
 848    contexts.  */
 849 #if NUM_POLY_INT_COEFFS == 1
 850 #define MACRO_MODE(MODE) (as_a <fixed_size_mode> (MODE))
 851 #else
 852 #define MACRO_MODE(MODE) (MODE)
 853 #endif
 854
 855 extern opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int);
 856
 857 /* Return the machine mode to use for a MODE_INT of SIZE bits, if one
 858    exists.  If LIMIT is nonzero, modes wider than MAX_FIXED_MODE_SIZE
 859    will not be used.  */
 860
 861 inline opt_scalar_int_mode
 862 int_mode_for_size (poly_uint64 size, int limit)
 863 {
 864   return dyn_cast <scalar_int_mode> (mode_for_size (size, MODE_INT, limit));
 865 }
 866
 867 /* Return the machine mode to use for a MODE_FLOAT of SIZE bits, if one
 868    exists.  */
 869
 870 inline opt_scalar_float_mode
 871 float_mode_for_size (poly_uint64 size)
 872 {
 873   return dyn_cast <scalar_float_mode> (mode_for_size (size, MODE_FLOAT, 0));
 874 }
 875
 876 /* Likewise for MODE_DECIMAL_FLOAT.  */
 877
 878 inline opt_scalar_float_mode
 879 decimal_float_mode_for_size (unsigned int size)
 880 {
 881   return dyn_cast <scalar_float_mode>
 882     (mode_for_size (size, MODE_DECIMAL_FLOAT, 0));
 883 }
 884
 885 extern machine_mode smallest_mode_for_size (poly_uint64, enum mode_class);
 886
 887 /* Find the narrowest integer mode that contains at least SIZE bits.
 888    Such a mode must exist.  */
 889
 890 inline scalar_int_mode
 891 smallest_int_mode_for_size (poly_uint64 size)
 892 {
 893   return as_a <scalar_int_mode> (smallest_mode_for_size (size, MODE_INT));
 894 }
 895
 896 extern opt_scalar_int_mode int_mode_for_mode (machine_mode);
 897 extern opt_machine_mode bitwise_mode_for_mode (machine_mode);
 898 extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64);
 899 extern opt_machine_mode related_vector_mode (machine_mode, scalar_mode,
 900                                              poly_uint64 = 0);
 901 extern opt_machine_mode related_int_vector_mode (machine_mode);
 902
 903 /* A class for iterating through possible bitfield modes.  */
 904 class bit_field_mode_iterator
 905 {
 906 public:
 907   bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT,
 908                            poly_int64, poly_int64,
 909                            unsigned int, bool);
 910   bool next_mode (scalar_int_mode *);
 911   bool prefer_smaller_modes ();
 912
 913 private:
 914   opt_scalar_int_mode m_mode;
 915   /* We use signed values here because the bit position can be negative
 916      for invalid input such as gcc.dg/pr48335-8.c.  */
 917   HOST_WIDE_INT m_bitsize;
 918   HOST_WIDE_INT m_bitpos;
 919   poly_int64 m_bitregion_start;
 920   poly_int64 m_bitregion_end;
 921   unsigned int m_align;
 922   bool m_volatilep;
 923   int m_count;
 924 };
 925
 926 /* Find the best mode to use to access a bit field.  */
 927
 928 extern bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int,
 929                            unsigned HOST_WIDE_INT, bool, scalar_int_mode *);
 930
 931 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.  */
 932
 933 extern CONST_MODE_BASE_ALIGN unsigned short mode_base_align[NUM_MACHINE_MODES];
 934
 935 extern unsigned get_mode_alignment (machine_mode);
 936
 937 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
 938
 939 /* For each class, get the narrowest mode in that class.  */
 940
 941 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
 942 #define GET_CLASS_NARROWEST_MODE(CLASS) \
 943   ((machine_mode) class_narrowest_mode[CLASS])
 944
 945 /* The narrowest full integer mode available on the target.  */
 946
 947 #define NARROWEST_INT_MODE \
 948   (scalar_int_mode \
 949    (scalar_int_mode::from_int (class_narrowest_mode[MODE_INT])))
 950
 951 /* Return the narrowest mode in T's class.  */
 952
 953 template<typename T>
 954 inline T
 955 get_narrowest_mode (T mode)
 956 {
 957   return typename mode_traits<T>::from_int
 958     (class_narrowest_mode[GET_MODE_CLASS (mode)]);
 959 }
 960
 961 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
 962    and the mode whose class is Pmode and whose size is POINTER_SIZE.  */
 963
 964 extern scalar_int_mode byte_mode;
 965 extern scalar_int_mode word_mode;
 966 extern scalar_int_mode ptr_mode;
 967
 968 /* Target-dependent machine mode initialization - in insn-modes.cc.  */
 969 extern void init_adjust_machine_modes (void);
 970
 971 #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \
 972   (targetm.truly_noop_truncation (GET_MODE_PRECISION (MODE1), \
 973                                   GET_MODE_PRECISION (MODE2)))
 974
 975 /* Return true if MODE is a scalar integer mode that fits in a
 976    HOST_WIDE_INT.  */
 977
 978 inline bool
 979 HWI_COMPUTABLE_MODE_P (machine_mode mode)
 980 {
 981   machine_mode mme = mode;
 982   return (SCALAR_INT_MODE_P (mme)
 983           && mode_to_precision (mme).coeffs[0] <= HOST_BITS_PER_WIDE_INT);
 984 }
 985
 986 inline bool
 987 HWI_COMPUTABLE_MODE_P (scalar_int_mode mode)
 988 {
 989   return GET_MODE_PRECISION (mode) <= HOST_BITS_PER_WIDE_INT;
 990 }
 991
 992 struct int_n_data_t {
 993   /* These parts are initailized by genmodes output */
 994   unsigned int bitsize;
 995   scalar_int_mode_pod m;
 996   /* RID_* is RID_INTN_BASE + index into this array */
 997 };
 998
 999 /* This is also in tree.h.  genmodes.cc guarantees the're sorted from
1000    smallest bitsize to largest bitsize. */
1001 extern bool int_n_enabled_p[NUM_INT_N_ENTS];
1002 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS];
1003
1004 /* Return true if MODE has class MODE_INT, storing it as a scalar_int_mode
1005    in *INT_MODE if so.  */
1006
1007 template<typename T>
1008 inline bool
1009 is_int_mode (machine_mode mode, T *int_mode)
1010 {
1011   if (GET_MODE_CLASS (mode) == MODE_INT)
1012     {
1013       *int_mode = scalar_int_mode (scalar_int_mode::from_int (mode));
1014       return true;
1015     }
1016   return false;
1017 }
1018
1019 /* Return true if MODE has class MODE_FLOAT, storing it as a
1020    scalar_float_mode in *FLOAT_MODE if so.  */
1021
1022 template<typename T>
1023 inline bool
1024 is_float_mode (machine_mode mode, T *float_mode)
1025 {
1026   if (GET_MODE_CLASS (mode) == MODE_FLOAT)
1027     {
1028       *float_mode = scalar_float_mode (scalar_float_mode::from_int (mode));
1029       return true;
1030     }
1031   return false;
1032 }
1033
1034 /* Return true if MODE has class MODE_COMPLEX_INT, storing it as
1035    a complex_mode in *CMODE if so.  */
1036
1037 template<typename T>
1038 inline bool
1039 is_complex_int_mode (machine_mode mode, T *cmode)
1040 {
1041   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
1042     {
1043       *cmode = complex_mode (complex_mode::from_int (mode));
1044       return true;
1045     }
1046   return false;
1047 }
1048
1049 /* Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as
1050    a complex_mode in *CMODE if so.  */
1051
1052 template<typename T>
1053 inline bool
1054 is_complex_float_mode (machine_mode mode, T *cmode)
1055 {
1056   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
1057     {
1058       *cmode = complex_mode (complex_mode::from_int (mode));
1059       return true;
1060     }
1061   return false;
1062 }
1063
1064 /* Return true if MODE is a scalar integer mode with a precision
1065    smaller than LIMIT's precision.  */
1066
1067 inline bool
1068 is_narrower_int_mode (machine_mode mode, scalar_int_mode limit)
1069 {
1070   scalar_int_mode int_mode;
1071   return (is_a <scalar_int_mode> (mode, &int_mode)
1072           && GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (limit));
1073 }
1074
1075 namespace mode_iterator
1076 {
1077   /* Start mode iterator *ITER at the first mode in class MCLASS, if any.  */
1078
1079   template<typename T>
1080   inline void
1081   start (opt_mode<T> *iter, enum mode_class mclass)
1082   {
1083     if (GET_CLASS_NARROWEST_MODE (mclass) == E_VOIDmode)
1084       *iter = opt_mode<T> ();
1085     else
1086       *iter = as_a<T> (GET_CLASS_NARROWEST_MODE (mclass));
1087   }
1088
1089   inline void
1090   start (machine_mode *iter, enum mode_class mclass)
1091   {
1092     *iter = GET_CLASS_NARROWEST_MODE (mclass);
1093   }
1094
1095   /* Return true if mode iterator *ITER has not reached the end.  */
1096
1097   template<typename T>
1098   inline bool
1099   iterate_p (opt_mode<T> *iter)
1100   {
1101     return iter->exists ();
1102   }
1103
1104   inline bool
1105   iterate_p (machine_mode *iter)
1106   {
1107     return *iter != E_VOIDmode;
1108   }
1109
1110   /* Set mode iterator *ITER to the next widest mode in the same class,
1111      if any.  */
1112
1113   template<typename T>
1114   inline void
1115   get_wider (opt_mode<T> *iter)
1116   {
1117     *iter = GET_MODE_WIDER_MODE (iter->require ());
1118   }
1119
1120   inline void
1121   get_wider (machine_mode *iter)
1122   {
1123     *iter = GET_MODE_WIDER_MODE (*iter).else_void ();
1124   }
1125
1126   /* Set mode iterator *ITER to the next widest mode in the same class.
1127      Such a mode is known to exist.  */
1128
1129   template<typename T>
1130   inline void
1131   get_known_wider (T *iter)
1132   {
1133     *iter = GET_MODE_WIDER_MODE (*iter).require ();
1134   }
1135
1136   /* Set mode iterator *ITER to the mode that is two times wider than the
1137      current one, if such a mode exists.  */
1138
1139   template<typename T>
1140   inline void
1141   get_2xwider (opt_mode<T> *iter)
1142   {
1143     *iter = GET_MODE_2XWIDER_MODE (iter->require ());
1144   }
1145
1146   inline void
1147   get_2xwider (machine_mode *iter)
1148   {
1149     *iter = GET_MODE_2XWIDER_MODE (*iter).else_void ();
1150   }
1151 }
1152
1153 /* Make ITERATOR iterate over all the modes in mode class CLASS,
1154    from narrowest to widest.  */
1155 #define FOR_EACH_MODE_IN_CLASS(ITERATOR, CLASS)  \
1156   for (mode_iterator::start (&(ITERATOR), CLASS); \
1157        mode_iterator::iterate_p (&(ITERATOR)); \
1158        mode_iterator::get_wider (&(ITERATOR)))
1159
1160 /* Make ITERATOR iterate over all the modes in the range [START, END),
1161    in order of increasing width.  */
1162 #define FOR_EACH_MODE(ITERATOR, START, END) \
1163   for ((ITERATOR) = (START); \
1164        (ITERATOR) != (END); \
1165        mode_iterator::get_known_wider (&(ITERATOR)))
1166
1167 /* Make ITERATOR iterate over START and all wider modes in the same
1168    class, in order of increasing width.  */
1169 #define FOR_EACH_MODE_FROM(ITERATOR, START) \
1170   for ((ITERATOR) = (START); \
1171        mode_iterator::iterate_p (&(ITERATOR)); \
1172        mode_iterator::get_wider (&(ITERATOR)))
1173
1174 /* Make ITERATOR iterate over modes in the range [NARROWEST, END)
1175    in order of increasing width, where NARROWEST is the narrowest mode
1176    in END's class.  */
1177 #define FOR_EACH_MODE_UNTIL(ITERATOR, END) \
1178   FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END)
1179
1180 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1181    of increasing width.  Start at the first mode wider than START,
1182    or don't iterate at all if there is no wider mode.  */
1183 #define FOR_EACH_WIDER_MODE(ITERATOR, START) \
1184   for ((ITERATOR) = (START), mode_iterator::get_wider (&(ITERATOR)); \
1185        mode_iterator::iterate_p (&(ITERATOR)); \
1186        mode_iterator::get_wider (&(ITERATOR)))
1187
1188 /* Make ITERATOR iterate over modes in the same class as MODE, in order
1189    of increasing width, and with each mode being twice the width of the
1190    previous mode.  Start at the mode that is two times wider than START,
1191    or don't iterate at all if there is no such mode.  */
1192 #define FOR_EACH_2XWIDER_MODE(ITERATOR, START) \
1193   for ((ITERATOR) = (START), mode_iterator::get_2xwider (&(ITERATOR)); \
1194        mode_iterator::iterate_p (&(ITERATOR)); \
1195        mode_iterator::get_2xwider (&(ITERATOR)))
1196
1197 template<typename T>
1198 void
1199 gt_ggc_mx (pod_mode<T> *)
1200 {
1201 }
1202
1203 template<typename T>
1204 void
1205 gt_pch_nx (pod_mode<T> *)
1206 {
1207 }
1208
1209 template<typename T>
1210 void
1211 gt_pch_nx (pod_mode<T> *, gt_pointer_operator, void *)
1212 {
1213 }
1214
1215 #endif // sdcpp
1216
1217 #endif /* not HAVE_MACHINE_MODES */