gcc/machmode.def

   1 /* This file contains the definitions and documentation for the
   2    machine modes used in the GNU compiler.
   3    Copyright (C) 1987-2023 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21
  22 /* This file defines all the MACHINE MODES used by GCC.
  23
  24    A machine mode specifies a size and format of data
  25    at the machine level.
  26
  27    Each RTL expression has a machine mode.
  28
  29    At the syntax tree level, each ..._TYPE and each ..._DECL node
  30    has a machine mode which describes data of that type or the
  31    data of the variable declared.  */
  32
  33 /* This file is included by the genmodes program.  Its text is the
  34    body of a function.  Do not rely on this, it will change in the
  35    future.
  36
  37    The following statements can be used in this file -- all have
  38    the form of a C macro call.  In their arguments:
  39
  40    A CLASS argument must be one of the constants defined in
  41    mode-classes.def, less the leading MODE_ prefix; some statements
  42    that take CLASS arguments have restrictions on which classes are
  43    acceptable.  For instance, INT.
  44
  45    A MODE argument must be the printable name of a machine mode,
  46    without quotation marks or trailing "mode".  For instance, SI.
  47
  48    A PRECISION, BYTESIZE, or COUNT argument must be a positive integer
  49    constant.
  50
  51    A FORMAT argument must be one of the real_mode_format structures
  52    declared in real.h, or else a literal 0.  Do not put a leading &
  53    on the argument.
  54
  55    An EXPR argument must be a syntactically valid C expression.
  56    If an EXPR contains commas, you may need to write an extra pair of
  57    parentheses around it, so it appears to be a single argument to the
  58    statement.
  59
  60    This file defines only those modes which are of use on almost all
  61    machines.  Other modes can be defined in the target-specific
  62    mode definition file, config/ARCH/ARCH-modes.def.
  63
  64    Order matters in this file in so far as statements which refer to
  65    other modes must appear after the modes they refer to.  However,
  66    statements which do not refer to other modes may appear in any
  67    order.
  68
  69      RANDOM_MODE (MODE);
  70         declares MODE to be of class RANDOM.
  71
  72      CC_MODE (MODE);
  73         declares MODE to be of class CC.
  74
  75      INT_MODE (MODE, BYTESIZE);
  76         declares MODE to be of class INT and BYTESIZE bytes wide.
  77         All of the bits of its representation are significant.
  78
  79      FRACTIONAL_INT_MODE (MODE, PRECISION, BYTESIZE);
  80         declares MODE to be of class INT, BYTESIZE bytes wide in
  81         storage, but with only PRECISION significant bits.
  82
  83      FLOAT_MODE (MODE, BYTESIZE, FORMAT);
  84         declares MODE to be of class FLOAT and BYTESIZE bytes wide,
  85         using floating point format FORMAT.
  86         All of the bits of its representation are significant.
  87
  88      FRACTIONAL_FLOAT_MODE (MODE, PRECISION, BYTESIZE, FORMAT);
  89         declares MODE to be of class FLOAT, BYTESIZE bytes wide in
  90         storage, but with only PRECISION significant bits, using
  91         floating point format FORMAT.
  92
  93      DECIMAL_FLOAT_MODE (MODE, BYTESIZE, FORMAT);
  94         declares MODE to be of class DECIMAL_FLOAT and BYTESIZE bytes
  95         wide.  All of the bits of its representation are significant.
  96
  97      FRACTIONAL_DECIMAL_FLOAT_MODE (MODE, BYTESIZE, FORMAT);
  98         declares MODE to be of class DECIMAL_FLOAT and BYTESIZE bytes
  99         wide.  All of the bits of its representation are significant.
 100
 101      FRACT_MODE (MODE, BYTESIZE, FBIT);
 102         declares MODE to be of class FRACT and BYTESIZE bytes wide
 103         with FBIT fractional bits.  There may be padding bits.
 104
 105      UFRACT_MODE (MODE, BYTESIZE, FBIT);
 106         declares MODE to be of class UFRACT and BYTESIZE bytes wide
 107         with FBIT fractional bits.  There may be padding bits.
 108
 109      ACCUM_MODE (MODE, BYTESIZE, IBIT, FBIT);
 110         declares MODE to be of class ACCUM and BYTESIZE bytes wide
 111         with IBIT integral bits and FBIT fractional bits.
 112         There may be padding bits.
 113
 114      UACCUM_MODE (MODE, BYTESIZE, IBIT, FBIT);
 115         declares MODE to be of class UACCUM and BYTESIZE bytes wide
 116         with IBIT integral bits and FBIT fractional bits.
 117         There may be padding bits.
 118
 119      RESET_FLOAT_FORMAT (MODE, FORMAT);
 120         changes the format of MODE, which must be class FLOAT,
 121         to FORMAT.  Use in an ARCH-modes.def to reset the format
 122         of one of the float modes defined in this file.
 123
 124      PARTIAL_INT_MODE (MODE, PRECISION, NAME);
 125         declares a mode of class PARTIAL_INT with the same size as
 126         MODE (which must be an INT mode) and precision PREC.
 127         Optionally, NAME is the new name of the mode.  NAME is the
 128         name of the mode.
 129
 130      VECTOR_MODE (CLASS, MODE, COUNT);
 131         Declare a vector mode whose component mode is MODE (of class
 132         CLASS) with COUNT components.  CLASS must be INT or FLOAT.
 133         The name of the vector mode takes the form VnX where n is
 134         COUNT in decimal and X is MODE.
 135
 136      VECTOR_MODES (CLASS, WIDTH);
 137         For all modes presently declared in class CLASS, construct
 138         corresponding vector modes having width WIDTH.  Modes whose
 139         byte sizes do not evenly divide WIDTH are ignored, as are
 140         modes that would produce vector modes with only one component,
 141         and modes smaller than one byte (if CLASS is INT) or smaller
 142         than two bytes (if CLASS is FLOAT).  CLASS must be INT or
 143         FLOAT.  The names follow the same rule as VECTOR_MODE uses.
 144
 145      VECTOR_MODES_WITH_PREFIX (PREFIX, CLASS, WIDTH, ORDER);
 146         Like VECTOR_MODES, but start the mode names with PREFIX instead
 147         of the usual "V".  ORDER is the top-level sorting order of the
 148         mode, with smaller numbers indicating a higher priority.
 149
 150      VECTOR_BOOL_MODE (NAME, COUNT, COMPONENT, BYTESIZE)
 151         Create a vector mode called NAME that contains COUNT boolean
 152         elements and occupies BYTESIZE bytes in total.  Each boolean
 153         element is of COMPONENT type and occupies (COUNT * BITS_PER_UNIT) /
 154         BYTESIZE bits, with the element at index 0 occupying the lsb of the
 155         first byte in memory.  Only the lowest bit of each element is
 156         significant.
 157
 158      OPAQUE_MODE (NAME, BYTESIZE)
 159         Create an opaque mode called NAME that is BYTESIZE bytes wide.
 160
 161      COMPLEX_MODES (CLASS);
 162         For all modes presently declared in class CLASS, construct
 163         corresponding complex modes.  Modes smaller than one byte
 164         are ignored.  For FLOAT modes, the names are derived by
 165         replacing the 'F' in the mode name with a 'C'.  (It is an
 166         error if there is no 'F'.  For INT modes, the names are
 167         derived by prefixing a C to the name.
 168
 169      ADJUST_BYTESIZE (MODE, EXPR);
 170      ADJUST_ALIGNMENT (MODE, EXPR);
 171      ADJUST_FLOAT_FORMAT (MODE, EXPR);
 172      ADJUST_IBIT (MODE, EXPR);
 173      ADJUST_FBIT (MODE, EXPR);
 174         Arrange for the byte size, alignment, floating point format, ibit,
 175         or fbit of MODE to be adjustable at run time.  EXPR will be executed
 176         once after processing all command line options, and should
 177         evaluate to the desired byte size, alignment, format, ibit or fbit.
 178
 179         Unlike a FORMAT argument, if you are adjusting a float format
 180         you must put an & in front of the name of each format structure.
 181
 182      ADJUST_NUNITS (MODE, EXPR);
 183         Like the above, but set the number of nunits of MODE to EXPR.
 184         This changes the size and precision of the mode in proportion
 185         to the change in the number of units; for example, doubling
 186         the number of units doubles the size and precision as well.
 187
 188    Note: If a mode is ever made which is more than 255 bytes wide,
 189    machmode.h and genmodes.cc will have to be changed to allocate
 190    more space for the mode_size and mode_alignment arrays.  */
 191
 192 /* VOIDmode is used when no mode needs to be specified,
 193    as for example on CONST_INT RTL expressions.  */
 194 RANDOM_MODE (VOID);
 195
 196 /* BLKmode is used for structures, arrays, etc.
 197    that fit no more specific mode.  */
 198 RANDOM_MODE (BLK);
 199
 200 /* Single bit mode used for booleans.  */
 201 BOOL_MODE (BI, 1, 1);
 202
 203 /* Basic integer modes.  We go up to TI in generic code (128 bits).
 204    TImode is needed here because the some front ends now genericly
 205    support __int128.  If the front ends decide to generically support
 206    larger types, then corresponding modes must be added here.  The
 207    name OI is reserved for a 256-bit type (needed by some back ends).
 208     */
 209 INT_MODE (QI, 1);
 210 INT_MODE (HI, 2);
 211 INT_MODE (SI, 4);
 212 INT_MODE (DI, 8);
 213 INT_MODE (TI, 16);
 214
 215 /* No partial integer modes are defined by default.  */
 216
 217 /* The target normally defines any target-specific __intN types and
 218    their modes, but __int128 for TImode is fairly common so define it
 219    here.  The type will not be created unless the target supports
 220    TImode.  */
 221
 222 INT_N (TI, 128);
 223
 224 /* Basic floating point modes.  SF and DF are the only modes provided
 225    by default.  The names QF, HF, XF, and TF are reserved for targets
 226    that need 1-word, 2-word, 80-bit, or 128-bit float types respectively.
 227
 228    These are the IEEE mappings.  They can be overridden with
 229    RESET_FLOAT_FORMAT or at runtime (in TARGET_OPTION_OVERRIDE).  */
 230
 231 FLOAT_MODE (SF, 4, ieee_single_format);
 232 FLOAT_MODE (DF, 8, ieee_double_format);
 233
 234 /* Basic CC modes.
 235    FIXME define this only for targets that need it.  */
 236 CC_MODE (CC);
 237
 238 /* Fixed-point modes.  */
 239 FRACT_MODE (QQ, 1, 7); /* s.7 */
 240 FRACT_MODE (HQ, 2, 15); /* s.15 */
 241 FRACT_MODE (SQ, 4, 31); /* s.31 */
 242 FRACT_MODE (DQ, 8, 63); /* s.63 */
 243 FRACT_MODE (TQ, 16, 127); /* s.127 */
 244
 245 UFRACT_MODE (UQQ, 1, 8); /* .8 */
 246 UFRACT_MODE (UHQ, 2, 16); /* .16 */
 247 UFRACT_MODE (USQ, 4, 32); /* .32 */
 248 UFRACT_MODE (UDQ, 8, 64); /* .64 */
 249 UFRACT_MODE (UTQ, 16, 128); /* .128 */
 250
 251 ACCUM_MODE (HA, 2, 8, 7); /* s8.7 */
 252 ACCUM_MODE (SA, 4, 16, 15); /* s16.15 */
 253 ACCUM_MODE (DA, 8, 32, 31); /* s32.31 */
 254 ACCUM_MODE (TA, 16, 64, 63); /* s64.63 */
 255
 256 UACCUM_MODE (UHA, 2, 8, 8); /* 8.8 */
 257 UACCUM_MODE (USA, 4, 16, 16); /* 16.16 */
 258 UACCUM_MODE (UDA, 8, 32, 32); /* 32.32 */
 259 UACCUM_MODE (UTA, 16, 64, 64); /* 64.64 */
 260
 261 /* Allow the target to specify additional modes of various kinds.  */
 262 #if HAVE_EXTRA_MODES
 263 # include EXTRA_MODES_FILE
 264 #endif
 265
 266 /* Complex modes.  */
 267 COMPLEX_MODES (INT);
 268 COMPLEX_MODES (PARTIAL_INT);
 269 COMPLEX_MODES (FLOAT);
 270
 271 /* Decimal floating point modes.  */
 272 DECIMAL_FLOAT_MODE (SD, 4, decimal_single_format);
 273 DECIMAL_FLOAT_MODE (DD, 8, decimal_double_format);
 274 DECIMAL_FLOAT_MODE (TD, 16, decimal_quad_format);
 275
 276 /* The symbol Pmode stands for one of the above machine modes (usually SImode).
 277    The tm.h file specifies which one.  It is not a distinct mode.  */
 278
 279 /*
 280 Local variables:
 281 mode:c
 282 version-control: t
 283 End:
 284 */