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