/*}}}*/ \f
/*{{{ Driver configuration. */
-/* A C expression which determines whether the option `-CHAR' takes arguments.
- The value should be the number of arguments that option takes-zero, for many
- options.
-
- By default, this macro is defined to handle the standard options properly.
- You need not define it unless you wish to add additional options which take
- arguments.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
#undef SWITCH_TAKES_ARG
-/* A C expression which determines whether the option `-NAME' takes arguments.
- The value should be the number of arguments that option takes-zero, for many
- options. This macro rather than `SWITCH_TAKES_ARG' is used for
- multi-character option names.
-
- By default, this macro is defined as `DEFAULT_WORD_SWITCH_TAKES_ARG', which
- handles the standard options properly. You need not define
- `WORD_SWITCH_TAKES_ARG' unless you wish to add additional options which take
- arguments. Any redefinition should call `DEFAULT_WORD_SWITCH_TAKES_ARG' and
- then check for additional options.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
#undef WORD_SWITCH_TAKES_ARG
/*}}}*/ \f
#define TARGET_VERSION fprintf (stderr, " (fr30)");
-/* Define this macro if debugging can be performed even without a frame
- pointer. If this macro is defined, GNU CC will turn on the
- `-fomit-frame-pointer' option whenever `-O' is specified. */
#define CAN_DEBUG_WITHOUT_FP
#undef STARTFILE_SPEC
/*}}}*/ \f
/*{{{ Storage Layout. */
-/* Define this macro to have the value 1 if the most significant bit in a byte
- has the lowest number; otherwise define it to have the value zero. This
- means that bit-field instructions count from the most significant bit. If
- the machine has no bit-field instructions, then this must still be defined,
- but it doesn't matter which value it is defined to. This macro need not be
- a constant.
-
- This macro does not affect the way structure fields are packed into bytes or
- words; that is controlled by `BYTES_BIG_ENDIAN'. */
#define BITS_BIG_ENDIAN 1
-/* Define this macro to have the value 1 if the most significant byte in a word
- has the lowest number. This macro need not be a constant. */
#define BYTES_BIG_ENDIAN 1
-/* Define this macro to have the value 1 if, in a multiword object, the most
- significant word has the lowest number. This applies to both memory
- locations and registers; GNU CC fundamentally assumes that the order of
- words in memory is the same as the order in registers. This macro need not
- be a constant. */
#define WORDS_BIG_ENDIAN 1
-/* Define this macro to be the number of bits in an addressable storage unit
- (byte); normally 8. */
#define BITS_PER_UNIT 8
-/* Number of bits in a word; normally 32. */
#define BITS_PER_WORD 32
-/* Number of storage units in a word; normally 4. */
#define UNITS_PER_WORD 4
-/* Width of a pointer, in bits. You must specify a value no wider than the
- width of `Pmode'. If it is not equal to the width of `Pmode', you must
- define `POINTERS_EXTEND_UNSIGNED'. */
#define POINTER_SIZE 32
-/* A macro to update MODE and UNSIGNEDP when an object whose type is TYPE and
- which has the specified mode and signedness is to be stored in a register.
- This macro is only called when TYPE is a scalar type.
-
- On most RISC machines, which only have operations that operate on a full
- register, define this macro to set M to `word_mode' if M is an integer mode
- narrower than `BITS_PER_WORD'. In most cases, only integer modes should be
- widened because wider-precision floating-point operations are usually more
- expensive than their narrower counterparts.
-
- For most machines, the macro definition does not change UNSIGNEDP. However,
- some machines, have instructions that preferentially handle either signed or
- unsigned quantities of certain modes. For example, on the DEC Alpha, 32-bit
- loads from memory and 32-bit add instructions sign-extend the result to 64
- bits. On such machines, set UNSIGNEDP according to which kind of extension
- is more efficient.
-
- Do not define this macro if it would never modify MODE. */
#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \
do \
{ \
} \
while (0)
-/* Normal alignment required for function parameters on the stack, in bits.
- All stack parameters receive at least this much alignment regardless of data
- type. On most machines, this is the same as the size of an integer. */
#define PARM_BOUNDARY 32
-/* Define this macro if you wish to preserve a certain alignment for the stack
- pointer. The definition is a C expression for the desired alignment
- (measured in bits).
-
- If `PUSH_ROUNDING' is not defined, the stack will always be aligned to the
- specified boundary. If `PUSH_ROUNDING' is defined and specifies a less
- strict alignment than `STACK_BOUNDARY', the stack may be momentarily
- unaligned while pushing arguments. */
#define STACK_BOUNDARY 32
-/* Alignment required for a function entry point, in bits. */
#define FUNCTION_BOUNDARY 32
-/* Biggest alignment that any data type can require on this machine,
- in bits. */
#define BIGGEST_ALIGNMENT 32
-/* If defined, a C expression to compute the alignment for a static variable.
- TYPE is the data type, and ALIGN is the alignment that the object
- would ordinarily have. The value of this macro is used instead of that
- alignment to align the object.
-
- If this macro is not defined, then ALIGN is used.
-
- One use of this macro is to increase alignment of medium-size data to make
- it all fit in fewer cache lines. Another is to cause character arrays to be
- word-aligned so that `strcpy' calls that copy constants to character arrays
- can be done inline. */
#define DATA_ALIGNMENT(TYPE, ALIGN) \
(TREE_CODE (TYPE) == ARRAY_TYPE \
&& TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
&& (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
-/* If defined, a C expression to compute the alignment given to a constant that
- is being placed in memory. CONSTANT is the constant and ALIGN is the
- alignment that the object would ordinarily have. The value of this macro is
- used instead of that alignment to align the object.
-
- If this macro is not defined, then ALIGN is used.
-
- The typical use of this macro is to increase alignment for string constants
- to be word aligned so that `strcpy' calls that copy constants can be done
- inline. */
#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
(TREE_CODE (EXP) == STRING_CST \
&& (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
-/* Define this macro to be the value 1 if instructions will fail to work if
- given data not on the nominal alignment. If instructions will merely go
- slower in that case, define this macro as 0. */
#define STRICT_ALIGNMENT 1
-/* Define this if you wish to imitate the way many other C compilers handle
- alignment of bitfields and the structures that contain them.
-
- The behavior is that the type written for a bitfield (`int', `short', or
- other integer type) imposes an alignment for the entire structure, as if the
- structure really did contain an ordinary field of that type. In addition,
- the bitfield is placed within the structure so that it would fit within such
- a field, not crossing a boundary for it.
-
- Thus, on most machines, a bitfield whose type is written as `int' would not
- cross a four-byte boundary, and would force four-byte alignment for the
- whole structure. (The alignment used may not be four bytes; it is
- controlled by the other alignment parameters.)
-
- If the macro is defined, its definition should be a C expression; a nonzero
- value for the expression enables this behavior.
-
- Note that if this macro is not defined, or its value is zero, some bitfields
- may cross more than one alignment boundary. The compiler can support such
- references if there are `insv', `extv', and `extzv' insns that can directly
- reference memory.
-
- The other known way of making bitfields work is to define
- `STRUCTURE_SIZE_BOUNDARY' as large as `BIGGEST_ALIGNMENT'. Then every
- structure can be accessed with fullwords.
-
- Unless the machine has bitfield instructions or you define
- `STRUCTURE_SIZE_BOUNDARY' that way, you must define
- `PCC_BITFIELD_TYPE_MATTERS' to have a nonzero value.
-
- If your aim is to make GNU CC use the same conventions for laying out
- bitfields as are used by another compiler, here is how to investigate what
- the other compiler does. Compile and run this program:
-
- struct foo1
- {
- char x;
- char :0;
- char y;
- };
-
- struct foo2
- {
- char x;
- int :0;
- char y;
- };
-
- main ()
- {
- printf ("Size of foo1 is %d\n",
- sizeof (struct foo1));
- printf ("Size of foo2 is %d\n",
- sizeof (struct foo2));
- exit (0);
- }
-
- If this prints 2 and 5, then the compiler's behavior is what you would get
- from `PCC_BITFIELD_TYPE_MATTERS'.
-
- Defined in svr4.h. */
+/* Defined in svr4.h. */
#define PCC_BITFIELD_TYPE_MATTERS 1
-/* A code distinguishing the floating point format of the target machine.
- There are three defined values:
-
- IEEE_FLOAT_FORMAT'
- This code indicates IEEE floating point. It is the default;
- there is no need to define this macro when the format is IEEE.
-
- VAX_FLOAT_FORMAT'
- This code indicates the peculiar format used on the VAX.
-
- UNKNOWN_FLOAT_FORMAT'
- This code indicates any other format.
-
- The value of this macro is compared with `HOST_FLOAT_FORMAT'
- to determine whether the target machine has the same format as
- the host machine. If any other formats are actually in use on supported
- machines, new codes should be defined for them.
-
- The ordering of the component words of floating point values stored in
- memory is controlled by `FLOAT_WORDS_BIG_ENDIAN' for the target machine and
- `HOST_FLOAT_WORDS_BIG_ENDIAN' for the host. */
#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
/*}}}*/ \f
#define DOUBLE_TYPE_SIZE 64
#define LONG_DOUBLE_TYPE_SIZE 64
-/* An expression whose value is 1 or 0, according to whether the type `char'
- should be signed or unsigned by default. The user can always override this
- default with the options `-fsigned-char' and `-funsigned-char'. */
#define DEFAULT_SIGNED_CHAR 1
/*}}}*/ \f
git://gcc.gnu.org / gcc.git / blobdiff