gcc/machmode.h

   1 /* Machine mode definitions for GCC; included by rtl.h and tree.h.
   2    Copyright (C) 1991-2015 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 /* Make an enum class that gives all the machine modes.  */
  24 #include "insn-modes.h"
  25
  26 /* Get the name of mode MODE as a string.  */
  27
  28 extern const char * const mode_name[NUM_MACHINE_MODES];
  29 #define GET_MODE_NAME(MODE)  mode_name[MODE]
  30
  31 /* Mode classes.  */
  32
  33 #include "mode-classes.def"
  34 #define DEF_MODE_CLASS(M) M
  35 enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
  36 #undef DEF_MODE_CLASS
  37 #undef MODE_CLASSES
  38
  39 /* Get the general kind of object that mode MODE represents
  40    (integer, floating, complex, etc.)  */
  41
  42 extern const unsigned char mode_class[NUM_MACHINE_MODES];
  43 #define GET_MODE_CLASS(MODE)  ((enum mode_class) mode_class[MODE])
  44
  45 /* Nonzero if MODE is an integral mode.  */
  46 #define INTEGRAL_MODE_P(MODE)                   \
  47   (GET_MODE_CLASS (MODE) == MODE_INT            \
  48    || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT \
  49    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT \
  50    || GET_MODE_CLASS (MODE) == MODE_VECTOR_INT)
  51
  52 /* Nonzero if MODE is a floating-point mode.  */
  53 #define FLOAT_MODE_P(MODE)              \
  54   (GET_MODE_CLASS (MODE) == MODE_FLOAT  \
  55    || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT \
  56    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
  57    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT)
  58
  59 /* Nonzero if MODE is a complex mode.  */
  60 #define COMPLEX_MODE_P(MODE)                    \
  61   (GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT    \
  62    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT)
  63
  64 /* Nonzero if MODE is a vector mode.  */
  65 #define VECTOR_MODE_P(MODE)                     \
  66   (GET_MODE_CLASS (MODE) == MODE_VECTOR_INT     \
  67    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT        \
  68    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT        \
  69    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT       \
  70    || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM        \
  71    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM)
  72
  73 /* Nonzero if MODE is a scalar integral mode.  */
  74 #define SCALAR_INT_MODE_P(MODE)                 \
  75   (GET_MODE_CLASS (MODE) == MODE_INT            \
  76    || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT)
  77
  78 /* Nonzero if MODE is a scalar floating point mode.  */
  79 #define SCALAR_FLOAT_MODE_P(MODE)               \
  80   (GET_MODE_CLASS (MODE) == MODE_FLOAT          \
  81    || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
  82
  83 /* Nonzero if MODE is a decimal floating point mode.  */
  84 #define DECIMAL_FLOAT_MODE_P(MODE)              \
  85   (GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
  86
  87 /* Nonzero if MODE is a scalar fract mode.  */
  88 #define SCALAR_FRACT_MODE_P(MODE)       \
  89   (GET_MODE_CLASS (MODE) == MODE_FRACT)
  90
  91 /* Nonzero if MODE is a scalar ufract mode.  */
  92 #define SCALAR_UFRACT_MODE_P(MODE)      \
  93   (GET_MODE_CLASS (MODE) == MODE_UFRACT)
  94
  95 /* Nonzero if MODE is a scalar fract or ufract mode.  */
  96 #define ALL_SCALAR_FRACT_MODE_P(MODE)   \
  97   (SCALAR_FRACT_MODE_P (MODE) || SCALAR_UFRACT_MODE_P (MODE))
  98
  99 /* Nonzero if MODE is a scalar accum mode.  */
 100 #define SCALAR_ACCUM_MODE_P(MODE)       \
 101   (GET_MODE_CLASS (MODE) == MODE_ACCUM)
 102
 103 /* Nonzero if MODE is a scalar uaccum mode.  */
 104 #define SCALAR_UACCUM_MODE_P(MODE)      \
 105   (GET_MODE_CLASS (MODE) == MODE_UACCUM)
 106
 107 /* Nonzero if MODE is a scalar accum or uaccum mode.  */
 108 #define ALL_SCALAR_ACCUM_MODE_P(MODE)   \
 109   (SCALAR_ACCUM_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
 110
 111 /* Nonzero if MODE is a scalar fract or accum mode.  */
 112 #define SIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)  \
 113   (SCALAR_FRACT_MODE_P (MODE) || SCALAR_ACCUM_MODE_P (MODE))
 114
 115 /* Nonzero if MODE is a scalar ufract or uaccum mode.  */
 116 #define UNSIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)        \
 117   (SCALAR_UFRACT_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
 118
 119 /* Nonzero if MODE is a scalar fract, ufract, accum or uaccum mode.  */
 120 #define ALL_SCALAR_FIXED_POINT_MODE_P(MODE)     \
 121   (SIGNED_SCALAR_FIXED_POINT_MODE_P (MODE)      \
 122    || UNSIGNED_SCALAR_FIXED_POINT_MODE_P (MODE))
 123
 124 /* Nonzero if MODE is a scalar/vector fract mode.  */
 125 #define FRACT_MODE_P(MODE)              \
 126   (GET_MODE_CLASS (MODE) == MODE_FRACT  \
 127    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT)
 128
 129 /* Nonzero if MODE is a scalar/vector ufract mode.  */
 130 #define UFRACT_MODE_P(MODE)             \
 131   (GET_MODE_CLASS (MODE) == MODE_UFRACT \
 132    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT)
 133
 134 /* Nonzero if MODE is a scalar/vector fract or ufract mode.  */
 135 #define ALL_FRACT_MODE_P(MODE)          \
 136   (FRACT_MODE_P (MODE) || UFRACT_MODE_P (MODE))
 137
 138 /* Nonzero if MODE is a scalar/vector accum mode.  */
 139 #define ACCUM_MODE_P(MODE)              \
 140   (GET_MODE_CLASS (MODE) == MODE_ACCUM  \
 141    || GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM)
 142
 143 /* Nonzero if MODE is a scalar/vector uaccum mode.  */
 144 #define UACCUM_MODE_P(MODE)             \
 145   (GET_MODE_CLASS (MODE) == MODE_UACCUM \
 146    || GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM)
 147
 148 /* Nonzero if MODE is a scalar/vector accum or uaccum mode.  */
 149 #define ALL_ACCUM_MODE_P(MODE)          \
 150   (ACCUM_MODE_P (MODE) || UACCUM_MODE_P (MODE))
 151
 152 /* Nonzero if MODE is a scalar/vector fract or accum mode.  */
 153 #define SIGNED_FIXED_POINT_MODE_P(MODE)         \
 154   (FRACT_MODE_P (MODE) || ACCUM_MODE_P (MODE))
 155
 156 /* Nonzero if MODE is a scalar/vector ufract or uaccum mode.  */
 157 #define UNSIGNED_FIXED_POINT_MODE_P(MODE)       \
 158   (UFRACT_MODE_P (MODE) || UACCUM_MODE_P (MODE))
 159
 160 /* Nonzero if MODE is a scalar/vector fract, ufract, accum or uaccum mode.  */
 161 #define ALL_FIXED_POINT_MODE_P(MODE)            \
 162   (SIGNED_FIXED_POINT_MODE_P (MODE)             \
 163    || UNSIGNED_FIXED_POINT_MODE_P (MODE))
 164
 165 /* Nonzero if CLASS modes can be widened.  */
 166 #define CLASS_HAS_WIDER_MODES_P(CLASS)         \
 167   (CLASS == MODE_INT                           \
 168    || CLASS == MODE_PARTIAL_INT                \
 169    || CLASS == MODE_FLOAT                      \
 170    || CLASS == MODE_DECIMAL_FLOAT              \
 171    || CLASS == MODE_COMPLEX_FLOAT              \
 172    || CLASS == MODE_FRACT                      \
 173    || CLASS == MODE_UFRACT                     \
 174    || CLASS == MODE_ACCUM                      \
 175    || CLASS == MODE_UACCUM)
 176
 177 #define POINTER_BOUNDS_MODE_P(MODE)      \
 178   (GET_MODE_CLASS (MODE) == MODE_POINTER_BOUNDS)
 179
 180 /* Get the size in bytes and bits of an object of mode MODE.  */
 181
 182 extern CONST_MODE_SIZE unsigned char mode_size[NUM_MACHINE_MODES];
 183 #if GCC_VERSION >= 4001
 184 #define GET_MODE_SIZE(MODE) \
 185   ((unsigned short) (__builtin_constant_p (MODE) \
 186                      ? mode_size_inline (MODE) : mode_size[MODE]))
 187 #else
 188 #define GET_MODE_SIZE(MODE)    ((unsigned short) mode_size[MODE])
 189 #endif
 190 #define GET_MODE_BITSIZE(MODE) \
 191   ((unsigned short) (GET_MODE_SIZE (MODE) * BITS_PER_UNIT))
 192
 193 /* Get the number of value bits of an object of mode MODE.  */
 194 extern const unsigned short mode_precision[NUM_MACHINE_MODES];
 195 #define GET_MODE_PRECISION(MODE)  mode_precision[MODE]
 196
 197 /* Get the number of integral bits of an object of mode MODE.  */
 198 extern CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES];
 199 #define GET_MODE_IBIT(MODE) mode_ibit[MODE]
 200
 201 /* Get the number of fractional bits of an object of mode MODE.  */
 202 extern CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES];
 203 #define GET_MODE_FBIT(MODE) mode_fbit[MODE]
 204
 205 /* Get a bitmask containing 1 for all bits in a word
 206    that fit within mode MODE.  */
 207
 208 extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES];
 209
 210 #define GET_MODE_MASK(MODE) mode_mask_array[MODE]
 211
 212 /* Return the mode of the basic parts of MODE.  For vector modes this is the
 213    mode of the vector elements.  For complex modes it is the mode of the real
 214    and imaginary parts.  For other modes it is MODE itself.  */
 215
 216 extern const unsigned char mode_inner[NUM_MACHINE_MODES];
 217 #if GCC_VERSION >= 4001
 218 #define GET_MODE_INNER(MODE) \
 219   ((machine_mode) (__builtin_constant_p (MODE) \
 220                         ? mode_inner_inline (MODE) : mode_inner[MODE]))
 221 #else
 222 #define GET_MODE_INNER(MODE) ((machine_mode) mode_inner[MODE])
 223 #endif
 224
 225 /* Get the size in bytes or bits of the basic parts of an
 226    object of mode MODE.  */
 227
 228 #define GET_MODE_UNIT_SIZE(MODE) GET_MODE_SIZE (GET_MODE_INNER (MODE))
 229
 230 #define GET_MODE_UNIT_BITSIZE(MODE) \
 231   ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))
 232
 233 #define GET_MODE_UNIT_PRECISION(MODE) GET_MODE_PRECISION (GET_MODE_INNER (MODE))
 234
 235 /* Get the number of units in the object.  */
 236
 237 extern const unsigned char mode_nunits[NUM_MACHINE_MODES];
 238 #if GCC_VERSION >= 4001
 239 #define GET_MODE_NUNITS(MODE) \
 240   ((unsigned char) (__builtin_constant_p (MODE) \
 241                     ? mode_nunits_inline (MODE) : mode_nunits[MODE]))
 242 #else
 243 #define GET_MODE_NUNITS(MODE)  mode_nunits[MODE]
 244 #endif
 245
 246 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI).  */
 247
 248 extern const unsigned char mode_wider[NUM_MACHINE_MODES];
 249 #define GET_MODE_WIDER_MODE(MODE) ((machine_mode) mode_wider[MODE])
 250
 251 /* For scalars, this is a mode with twice the precision.  For vectors,
 252    this is a mode with the same inner mode but with twice the elements.  */
 253 extern const unsigned char mode_2xwider[NUM_MACHINE_MODES];
 254 #define GET_MODE_2XWIDER_MODE(MODE) ((machine_mode) mode_2xwider[MODE])
 255
 256 /* Return the mode for data of a given size SIZE and mode class CLASS.
 257    If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
 258    The value is BLKmode if no other mode is found.  */
 259
 260 extern machine_mode mode_for_size (unsigned int, enum mode_class, int);
 261
 262 /* Similar, but find the smallest mode for a given width.  */
 263
 264 extern machine_mode smallest_mode_for_size (unsigned int,
 265                                                  enum mode_class);
 266
 267
 268 /* Return an integer mode of the exact same size as the input mode,
 269    or BLKmode on failure.  */
 270
 271 extern machine_mode int_mode_for_mode (machine_mode);
 272
 273 extern machine_mode bitwise_mode_for_mode (machine_mode);
 274
 275 /* Return a mode that is suitable for representing a vector,
 276    or BLKmode on failure.  */
 277
 278 extern machine_mode mode_for_vector (machine_mode, unsigned);
 279
 280 /* A class for iterating through possible bitfield modes.  */
 281 class bit_field_mode_iterator
 282 {
 283 public:
 284   bit_field_mode_iterator (HOST_WIDE_INT, HOST_WIDE_INT,
 285                            HOST_WIDE_INT, HOST_WIDE_INT,
 286                            unsigned int, bool);
 287   bool next_mode (machine_mode *);
 288   bool prefer_smaller_modes ();
 289
 290 private:
 291   machine_mode m_mode;
 292   /* We use signed values here because the bit position can be negative
 293      for invalid input such as gcc.dg/pr48335-8.c.  */
 294   HOST_WIDE_INT m_bitsize;
 295   HOST_WIDE_INT m_bitpos;
 296   HOST_WIDE_INT m_bitregion_start;
 297   HOST_WIDE_INT m_bitregion_end;
 298   unsigned int m_align;
 299   bool m_volatilep;
 300   int m_count;
 301 };
 302
 303 /* Find the best mode to use to access a bit field.  */
 304
 305 extern machine_mode get_best_mode (int, int,
 306                                         unsigned HOST_WIDE_INT,
 307                                         unsigned HOST_WIDE_INT,
 308                                         unsigned int,
 309                                         machine_mode, bool);
 310
 311 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.  */
 312
 313 extern CONST_MODE_BASE_ALIGN unsigned char mode_base_align[NUM_MACHINE_MODES];
 314
 315 extern unsigned get_mode_alignment (machine_mode);
 316
 317 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
 318
 319 /* For each class, get the narrowest mode in that class.  */
 320
 321 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
 322 #define GET_CLASS_NARROWEST_MODE(CLASS) \
 323   ((machine_mode) class_narrowest_mode[CLASS])
 324
 325 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
 326    and the mode whose class is Pmode and whose size is POINTER_SIZE.  */
 327
 328 extern machine_mode byte_mode;
 329 extern machine_mode word_mode;
 330 extern machine_mode ptr_mode;
 331
 332 /* Target-dependent machine mode initialization - in insn-modes.c.  */
 333 extern void init_adjust_machine_modes (void);
 334
 335 #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \
 336   TRULY_NOOP_TRUNCATION (GET_MODE_PRECISION (MODE1), \
 337                          GET_MODE_PRECISION (MODE2))
 338
 339 #define HWI_COMPUTABLE_MODE_P(MODE) \
 340   (SCALAR_INT_MODE_P (MODE) \
 341    && GET_MODE_PRECISION (MODE) <= HOST_BITS_PER_WIDE_INT)
 342
 343 typedef struct {
 344   /* These parts are initailized by genmodes output */
 345   unsigned int bitsize;
 346   machine_mode m;
 347   /* RID_* is RID_INTN_BASE + index into this array */
 348 } int_n_data_t;
 349
 350 /* This is also in tree.h.  genmodes.c guarantees the're sorted from
 351    smallest bitsize to largest bitsize. */
 352 extern bool int_n_enabled_p[NUM_INT_N_ENTS];
 353 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS];
 354
 355 #endif /* not HAVE_MACHINE_MODES */