[thirdparty/gcc.git] / gcc / machmode.def

/* This file contains the definitions and documentation for the
   machine modes used in the GNU compiler.
   Copyright (C) 1987, 1992, 1994, 1997, 1998, 2000, 2003, 2004, 2005,
   2007, 2010, 2011  Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */


/* This file defines all the MACHINE MODES used by GCC.

   A machine mode specifies a size and format of data
   at the machine level.

   Each RTL expression has a machine mode.

   At the syntax tree level, each ..._TYPE and each ..._DECL node
   has a machine mode which describes data of that type or the
   data of the variable declared.  */

/* This file is included by the genmodes program.  Its text is the
   body of a function.  Do not rely on this, it will change in the
   future.

   The following statements can be used in this file -- all have
   the form of a C macro call.  In their arguments:

   A CLASS argument must be one of the constants defined in
   mode-classes.def, less the leading MODE_ prefix; some statements
   that take CLASS arguments have restrictions on which classes are
   acceptable.  For instance, INT.

   A MODE argument must be the printable name of a machine mode,
   without quotation marks or trailing "mode".  For instance, SI.

   A PRECISION, BYTESIZE, or COUNT argument must be a positive integer
   constant.

   A FORMAT argument must be one of the real_mode_format structures
   declared in real.h, or else a literal 0.  Do not put a leading &
   on the argument.

   An EXPR argument must be a syntactically valid C expression.
   If an EXPR contains commas, you may need to write an extra pair of
   parentheses around it, so it appears to be a single argument to the
   statement.

   This file defines only those modes which are of use on almost all
   machines.  Other modes can be defined in the target-specific
   mode definition file, config/ARCH/ARCH-modes.def.

   Order matters in this file in so far as statements which refer to
   other modes must appear after the modes they refer to.  However,
   statements which do not refer to other modes may appear in any
   order.

     RANDOM_MODE (MODE);
        declares MODE to be of class RANDOM.

     CC_MODE (MODE);
        declares MODE to be of class CC.

     INT_MODE (MODE, BYTESIZE);
        declares MODE to be of class INT and BYTESIZE bytes wide.
	All of the bits of its representation are significant.

     FRACTIONAL_INT_MODE (MODE, PRECISION, BYTESIZE);
        declares MODE to be of class INT, BYTESIZE bytes wide in
	storage, but with only PRECISION significant bits.

     FLOAT_MODE (MODE, BYTESIZE, FORMAT);
        declares MODE to be of class FLOAT and BYTESIZE bytes wide,
	using floating point format FORMAT.
	All of the bits of its representation are significant.

     FRACTIONAL_FLOAT_MODE (MODE, PRECISION, BYTESIZE, FORMAT);
        declares MODE to be of class FLOAT, BYTESIZE bytes wide in
	storage, but with only PRECISION significant bits, using
	floating point format FORMAT.

     DECIMAL_FLOAT_MODE (MODE, BYTESIZE, FORMAT);
	declares MODE to be of class DECIMAL_FLOAT and BYTESIZE bytes
	wide.  All of the bits of its representation are significant.

     FRACTIONAL_DECIMAL_FLOAT_MODE (MODE, BYTESIZE, FORMAT);
	declares MODE to be of class DECIMAL_FLOAT and BYTESIZE bytes
	wide.  All of the bits of its representation are significant.

     FRACT_MODE (MODE, BYTESIZE, FBIT);
	declares MODE to be of class FRACT and BYTESIZE bytes wide
	with FBIT fractional bits.  There may be padding bits.

     UFRACT_MODE (MODE, BYTESIZE, FBIT);
	declares MODE to be of class UFRACT and BYTESIZE bytes wide
	with FBIT fractional bits.  There may be padding bits.

     ACCUM_MODE (MODE, BYTESIZE, IBIT, FBIT);
	declares MODE to be of class ACCUM and BYTESIZE bytes wide
	with IBIT integral bits and FBIT fractional bits.
	There may be padding bits.

     UACCUM_MODE (MODE, BYTESIZE, IBIT, FBIT);
	declares MODE to be of class UACCUM and BYTESIZE bytes wide
	with IBIT integral bits and FBIT fractional bits.
	There may be padding bits.

     RESET_FLOAT_FORMAT (MODE, FORMAT);
	changes the format of MODE, which must be class FLOAT,
	to FORMAT.  Use in an ARCH-modes.def to reset the format
	of one of the float modes defined in this file.

     PARTIAL_INT_MODE (MODE);
        declares a mode of class PARTIAL_INT with the same size as
	MODE (which must be an INT mode).  The name of the new mode
	is made by prefixing a P to the name MODE.  This statement
	may grow a PRECISION argument in the future.

     VECTOR_MODE (CLASS, MODE, COUNT);
        Declare a vector mode whose component mode is MODE (of class
	CLASS) with COUNT components.  CLASS must be INT or FLOAT.
	The name of the vector mode takes the form VnX where n is
	COUNT in decimal and X is MODE.

     VECTOR_MODES (CLASS, WIDTH);
        For all modes presently declared in class CLASS, construct
	corresponding vector modes having width WIDTH.  Modes whose
	byte sizes do not evenly divide WIDTH are ignored, as are
	modes that would produce vector modes with only one component,
	and modes smaller than one byte (if CLASS is INT) or smaller
	than two bytes (if CLASS is FLOAT).  CLASS must be INT or
	FLOAT.  The names follow the same rule as VECTOR_MODE uses.

     COMPLEX_MODES (CLASS);
        For all modes presently declared in class CLASS, construct
	corresponding complex modes.  Modes smaller than one byte
	are ignored.  For FLOAT modes, the names are derived by
	replacing the 'F' in the mode name with a 'C'.  (It is an
	error if there is no 'F'.  For INT modes, the names are
	derived by prefixing a C to the name.

     ADJUST_BYTESIZE (MODE, EXPR);
     ADJUST_ALIGNMENT (MODE, EXPR);
     ADJUST_FLOAT_FORMAT (MODE, EXPR);
     ADJUST_IBIT (MODE, EXPR);
     ADJUST_FBIT (MODE, EXPR);
	Arrange for the byte size, alignment, floating point format, ibit,
	or fbit of MODE to be adjustable at run time.  EXPR will be executed
	once after processing all command line options, and should
	evaluate to the desired byte size, alignment, format, ibit or fbit.

	Unlike a FORMAT argument, if you are adjusting a float format
	you must put an & in front of the name of each format structure.

   Note: If a mode is ever made which is more than 255 bytes wide,
   machmode.h and genmodes.c will have to be changed to allocate
   more space for the mode_size and mode_alignment arrays.  */

/* VOIDmode is used when no mode needs to be specified,
   as for example on CONST_INT RTL expressions.  */
RANDOM_MODE (VOID);

/* BLKmode is used for structures, arrays, etc.
   that fit no more specific mode.  */
RANDOM_MODE (BLK);

/* Single bit mode used for booleans.  */
FRACTIONAL_INT_MODE (BI, 1, 1);

/* Basic integer modes.  We go up to TI in generic code (128 bits).
   The name OI is reserved for a 256-bit type (needed by some back ends).
   FIXME TI shouldn't be generically available either.  */
INT_MODE (QI, 1);
INT_MODE (HI, 2);
INT_MODE (SI, 4);
INT_MODE (DI, 8);
INT_MODE (TI, 16);

/* No partial integer modes are defined by default.  */

/* Basic floating point modes.  SF and DF are the only modes provided
   by default.  The names QF, HF, XF, and TF are reserved for targets
   that need 1-word, 2-word, 80-bit, or 128-bit float types respectively.

   These are the IEEE mappings.  They can be overridden with
   RESET_FLOAT_FORMAT or at runtime (in TARGET_OPTION_OVERRIDE).  */

FLOAT_MODE (SF, 4, ieee_single_format);
FLOAT_MODE (DF, 8, ieee_double_format);

/* Basic CC modes.
   FIXME define this only for targets that need it.  */
CC_MODE (CC);

/* Fixed-point modes.  */
FRACT_MODE (QQ, 1, 7); /* s.7 */
FRACT_MODE (HQ, 2, 15); /* s.15 */
FRACT_MODE (SQ, 4, 31); /* s.31 */
FRACT_MODE (DQ, 8, 63); /* s.63 */
FRACT_MODE (TQ, 16, 127); /* s.127 */

UFRACT_MODE (UQQ, 1, 8); /* .8 */
UFRACT_MODE (UHQ, 2, 16); /* .16 */
UFRACT_MODE (USQ, 4, 32); /* .32 */
UFRACT_MODE (UDQ, 8, 64); /* .64 */
UFRACT_MODE (UTQ, 16, 128); /* .128 */

ACCUM_MODE (HA, 2, 8, 7); /* s8.7 */
ACCUM_MODE (SA, 4, 16, 15); /* s16.15 */
ACCUM_MODE (DA, 8, 32, 31); /* s32.31 */
ACCUM_MODE (TA, 16, 64, 63); /* s64.63 */

UACCUM_MODE (UHA, 2, 8, 8); /* 8.8 */
UACCUM_MODE (USA, 4, 16, 16); /* 16.16 */
UACCUM_MODE (UDA, 8, 32, 32); /* 32.32 */
UACCUM_MODE (UTA, 16, 64, 64); /* 64.64 */

/* Allow the target to specify additional modes of various kinds.  */
#if HAVE_EXTRA_MODES
# include EXTRA_MODES_FILE
#endif

/* Complex modes.  */
COMPLEX_MODES (INT);
COMPLEX_MODES (FLOAT);

/* Decimal floating point modes.  */
DECIMAL_FLOAT_MODE (SD, 4, decimal_single_format);
DECIMAL_FLOAT_MODE (DD, 8, decimal_double_format);
DECIMAL_FLOAT_MODE (TD, 16, decimal_quad_format);

/* The symbol Pmode stands for one of the above machine modes (usually SImode).
   The tm.h file specifies which one.  It is not a distinct mode.  */

/*
Local variables:
mode:c
version-control: t
End:
*/
Commit	Line	Data
34af06d1	1	/* This file contains the definitions and documentation for the
3398e91d	2	machine modes used in the GNU compiler.
8c4c00c1	3	Copyright (C) 1987, 1992, 1994, 1997, 1998, 2000, 2003, 2004, 2005,
71e45bc2	4	2007, 2010, 2011 Free Software Foundation, Inc.
34af06d1	5
f12b58b3	6	This file is part of GCC.
34af06d1	7
f12b58b3	8	GCC is free software; you can redistribute it and/or modify it under
f12b58b3	9	the terms of the GNU General Public License as published by the Free
8c4c00c1	10	Software Foundation; either version 3, or (at your option) any later
f12b58b3	11	version.
34af06d1	12
f12b58b3	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.
34af06d1	17
34af06d1	18	You should have received a copy of the GNU General Public License
8c4c00c1	19	along with GCC; see the file COPYING3. If not see
8c4c00c1	20	<http://www.gnu.org/licenses/>. */
34af06d1	21
34af06d1	22
f12b58b3	23	/* This file defines all the MACHINE MODES used by GCC.
34af06d1	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
47a2c1d4	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
06b27565	43	that take CLASS arguments have restrictions on which classes are
47a2c1d4	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
7c0390e7	49	A PRECISION, BYTESIZE, or COUNT argument must be a positive integer
47a2c1d4	50	constant.
47a2c1d4	51
15460c97	52	A FORMAT argument must be one of the real_mode_format structures
f58875bf	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.
15460c97	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
47a2c1d4	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
7c0390e7	80	FRACTIONAL_INT_MODE (MODE, PRECISION, BYTESIZE);
47a2c1d4	81	declares MODE to be of class INT, BYTESIZE bytes wide in
7c0390e7	82	storage, but with only PRECISION significant bits.
47a2c1d4	83
15460c97	84	FLOAT_MODE (MODE, BYTESIZE, FORMAT);
	85	declares MODE to be of class FLOAT and BYTESIZE bytes wide,
	86	using floating point format FORMAT.
47a2c1d4	87	All of the bits of its representation are significant.
47a2c1d4	88
7c0390e7	89	FRACTIONAL_FLOAT_MODE (MODE, PRECISION, BYTESIZE, FORMAT);
47a2c1d4	90	declares MODE to be of class FLOAT, BYTESIZE bytes wide in
7c0390e7	91	storage, but with only PRECISION significant bits, using
15460c97	92	floating point format FORMAT.
15460c97	93
7f24e187	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
c559c639	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
7f24e187	115	UACCUM_MODE (MODE, BYTESIZE, IBIT, FBIT);
c559c639	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
15460c97	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.
47a2c1d4	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
7c0390e7	129	may grow a PRECISION argument in the future.
47a2c1d4	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
f58875bf	154	ADJUST_BYTESIZE (MODE, EXPR);
	155	ADJUST_ALIGNMENT (MODE, EXPR);
	156	ADJUST_FLOAT_FORMAT (MODE, EXPR);
c559c639	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
f58875bf	161	once after processing all command line options, and should
c559c639	162	evaluate to the desired byte size, alignment, format, ibit or fbit.
f58875bf	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
47a2c1d4	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. */
34af06d1	170
	171	/* VOIDmode is used when no mode needs to be specified,
	172	as for example on CONST_INT RTL expressions. */
47a2c1d4	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);
3573fd04	181
15460c97	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. */
47a2c1d4	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);
15460c97	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
4c834714	198	RESET_FLOAT_FORMAT or at runtime (in TARGET_OPTION_OVERRIDE). */
15460c97	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. */
47a2c1d4	205	CC_MODE (CC);
47a2c1d4	206
c559c639	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
47a2c1d4	230	/* Allow the target to specify additional modes of various kinds. */
47a2c1d4	231	#if HAVE_EXTRA_MODES
47a2c1d4	232	# include EXTRA_MODES_FILE
47a2c1d4	233	#endif
34af06d1	234
a4531b55	235	/* Complex modes. */
47a2c1d4	236	COMPLEX_MODES (INT);
47a2c1d4	237	COMPLEX_MODES (FLOAT);
a4531b55	238
3c28f41a	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
34af06d1	244	/* The symbol Pmode stands for one of the above machine modes (usually SImode).
47a2c1d4	245	The tm.h file specifies which one. It is not a distinct mode. */
34af06d1	246
	247	/*
	248	Local variables:
	249	mode:c
	250	version-control: t
	251	End:
	252	*/