PREV UP NEXT Using and Porting GNU CC

16.3: Storage Layout

Note that the definitions of the macros in this table which are sizes or alignments measured in bits do not need to be constant. They can be C expressions that refer to static variables, such as the target_flags. See Run-time Target.

BITS_BIG_ENDIAN
Define this macro to be the value 1 if the most significant bit in a byte has the lowest number; otherwise define it to be 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 does not affect the way structure fields are packed into bytes or words; that is controlled by BYTES_BIG_ENDIAN.

BYTES_BIG_ENDIAN
Define this macro to be 1 if the most significant byte in a word has the lowest number.
WORDS_BIG_ENDIAN
Define this macro to be 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.
FLOAT_WORDS_BIG_ENDIAN
Define this macro to be 1 if DFmode, XFmode or TFmode floating point numbers are stored in memory with the word containing the sign bit at the lowest address; otherwise define it to be 0.

You need not define this macro if the ordering is the same as for multi-word integers.

BITS_PER_UNIT
Define this macro to be the number of bits in an addressable storage unit (byte); normally 8.
BITS_PER_WORD
Number of bits in a word; normally 32.
MAX_BITS_PER_WORD
Maximum number of bits in a word. If this is undefined, the default is BITS_PER_WORD. Otherwise, it is the constant value that is the largest value that BITS_PER_WORD can have at run-time.
UNITS_PER_WORD
Number of storage units in a word; normally 4.
MAX_UNITS_PER_WORD
Maximum number of units in a word. If this is undefined, the default is UNITS_PER_WORD. Otherwise, it is the constant value that is the largest value that UNITS_PER_WORD can have at run-time.
POINTER_SIZE
Width of a pointer, in bits.
PROMOTE_MODE (m, unsignedp, type)
A macro to update m 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 m.

PROMOTE_FUNCTION_ARGS
Define this macro if the promotion described by PROMOTE_MODE should also be done for outgoing function arguments.
PROMOTE_FUNCTION_RETURN
Define this macro if the promotion described by PROMOTE_MODE should also be done for the return value of functions.

If this macro is defined, FUNCTION_VALUE must perform the same promotions done by PROMOTE_MODE.

PROMOTE_FOR_CALL_ONLY
Define this macro if the promotion described by PROMOTE_MODE should only be performed for outgoing function arguments or function return values, as specified by PROMOTE_FUNCTION_ARGS and PROMOTE_FUNCTION_RETURN, respectively.
PARM_BOUNDARY
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.
STACK_BOUNDARY
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.

FUNCTION_BOUNDARY
Alignment required for a function entry point, in bits.
BIGGEST_ALIGNMENT
Biggest alignment that any data type can require on this machine, in bits.
BIGGEST_FIELD_ALIGNMENT
Biggest alignment that any structure field can require on this machine, in bits. If defined, this overrides BIGGEST_ALIGNMENT for structure fields only.
MAX_OFILE_ALIGNMENT
Biggest alignment supported by the object file format of this machine. Use this macro to limit the alignment which can be specified using the __attribute__ ((aligned (n))) construct. If not defined, the default value is BIGGEST_ALIGNMENT.
DATA_ALIGNMENT (type, basic-align)
If defined, a C expression to compute the alignment for a static variable. type is the data type, and basic-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 basic-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.

CONSTANT_ALIGNMENT (constant, basic-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 basic-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 basic-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.

EMPTY_FIELD_BOUNDARY
Alignment in bits to be given to a structure bit field that follows an empty field such as int : 0;.

Note that PCC_BITFIELD_TYPE_MATTERS also affects the alignment that results from an empty field.

STRUCTURE_SIZE_BOUNDARY
Number of bits which any structure or union's size must be a multiple of. Each structure or union's size is rounded up to a multiple of this.

If you do not define this macro, the default is the same as BITS_PER_UNIT.

STRICT_ALIGNMENT
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.
PCC_BITFIELD_TYPE_MATTERS
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.

BITFIELD_NBYTES_LIMITED
Like PCC_BITFIELD_TYPE_MATTERS except that its effect is limited to aligning a bitfield within the structure.
ROUND_TYPE_SIZE (struct, size, align)
Define this macro as an expression for the overall size of a structure (given by struct as a tree node) when the size computed from the fields is size and the alignment is align.

The default is to round size up to a multiple of align.

ROUND_TYPE_ALIGN (struct, computed, specified)
Define this macro as an expression for the alignment of a structure (given by struct as a tree node) if the alignment computed in the usual way is computed and the alignment explicitly specified was specified.

The default is to use specified if it is larger; otherwise, use the smaller of computed and BIGGEST_ALIGNMENT

MAX_FIXED_MODE_SIZE
An integer expression for the size in bits of the largest integer machine mode that should actually be used. All integer machine modes of this size or smaller can be used for structures and unions with the appropriate sizes. If this macro is undefined, GET_MODE_BITSIZE (DImode) is assumed.
CHECK_FLOAT_VALUE (mode, value, overflow)
A C statement to validate the value value (of type double) for mode mode. This means that you check whether value fits within the possible range of values for mode mode on this target machine. The mode mode is always a mode of class MODE_FLOAT. overflow is nonzero if the value is already known to be out of range.

If value is not valid or if overflow is nonzero, you should set overflow to 1 and then assign some valid value to value. Allowing an invalid value to go through the compiler can produce incorrect assembler code which may even cause Unix assemblers to crash.

This macro need not be defined if there is no work for it to do.

TARGET_FLOAT_FORMAT
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 (see Config) 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.