gccint: Storage Layout
1
1 18.5 Storage Layout
1 ===================
1
1 Note that the definitions of the macros in this table which are sizes or
1 alignments measured in bits do not need to be constant. They can be C
1 expressions that refer to static variables, such as the 'target_flags'.
1 ⇒Run-time Target.
1
1 -- Macro: BITS_BIG_ENDIAN
1 Define this macro to have the value 1 if the most significant bit
1 in a byte has the lowest number; otherwise define it to have the
1 value zero. This means that bit-field instructions count from the
1 most significant bit. If the machine has no bit-field
1 instructions, then this must still be defined, but it doesn't
1 matter which value it is defined to. This macro need not be a
1 constant.
1
1 This macro does not affect the way structure fields are packed into
1 bytes or words; that is controlled by 'BYTES_BIG_ENDIAN'.
1
1 -- Macro: BYTES_BIG_ENDIAN
1 Define this macro to have the value 1 if the most significant byte
1 in a word has the lowest number. This macro need not be a
1 constant.
1
1 -- Macro: WORDS_BIG_ENDIAN
1 Define this macro to have the value 1 if, in a multiword object,
1 the most significant word has the lowest number. This applies to
1 both memory locations and registers; see 'REG_WORDS_BIG_ENDIAN' if
1 the order of words in memory is not the same as the order in
1 registers. This macro need not be a constant.
1
1 -- Macro: REG_WORDS_BIG_ENDIAN
1 On some machines, the order of words in a multiword object differs
1 between registers in memory. In such a situation, define this
1 macro to describe the order of words in a register. The macro
1 'WORDS_BIG_ENDIAN' controls the order of words in memory.
1
1 -- Macro: FLOAT_WORDS_BIG_ENDIAN
1 Define this macro to have the value 1 if 'DFmode', 'XFmode' or
1 'TFmode' floating point numbers are stored in memory with the word
1 containing the sign bit at the lowest address; otherwise define it
1 to have the value 0. This macro need not be a constant.
1
1 You need not define this macro if the ordering is the same as for
1 multi-word integers.
1
1 -- Macro: BITS_PER_WORD
1 Number of bits in a word. If you do not define this macro, the
1 default is 'BITS_PER_UNIT * UNITS_PER_WORD'.
1
1 -- Macro: MAX_BITS_PER_WORD
1 Maximum number of bits in a word. If this is undefined, the
1 default is 'BITS_PER_WORD'. Otherwise, it is the constant value
1 that is the largest value that 'BITS_PER_WORD' can have at
1 run-time.
1
1 -- Macro: UNITS_PER_WORD
1 Number of storage units in a word; normally the size of a
1 general-purpose register, a power of two from 1 or 8.
1
1 -- Macro: MIN_UNITS_PER_WORD
1 Minimum number of units in a word. If this is undefined, the
1 default is 'UNITS_PER_WORD'. Otherwise, it is the constant value
1 that is the smallest value that 'UNITS_PER_WORD' can have at
1 run-time.
1
1 -- Macro: POINTER_SIZE
1 Width of a pointer, in bits. You must specify a value no wider
1 than the width of 'Pmode'. If it is not equal to the width of
1 'Pmode', you must define 'POINTERS_EXTEND_UNSIGNED'. If you do not
1 specify a value the default is 'BITS_PER_WORD'.
1
1 -- Macro: POINTERS_EXTEND_UNSIGNED
1 A C expression that determines how pointers should be extended from
1 'ptr_mode' to either 'Pmode' or 'word_mode'. It is greater than
1 zero if pointers should be zero-extended, zero if they should be
1 sign-extended, and negative if some other sort of conversion is
1 needed. In the last case, the extension is done by the target's
1 'ptr_extend' instruction.
1
1 You need not define this macro if the 'ptr_mode', 'Pmode' and
1 'word_mode' are all the same width.
1
1 -- Macro: PROMOTE_MODE (M, UNSIGNEDP, TYPE)
1 A macro to update M and UNSIGNEDP when an object whose type is TYPE
1 and which has the specified mode and signedness is to be stored in
1 a register. This macro is only called when TYPE is a scalar type.
1
1 On most RISC machines, which only have operations that operate on a
1 full register, define this macro to set M to 'word_mode' if M is an
1 integer mode narrower than 'BITS_PER_WORD'. In most cases, only
1 integer modes should be widened because wider-precision
1 floating-point operations are usually more expensive than their
1 narrower counterparts.
1
1 For most machines, the macro definition does not change UNSIGNEDP.
1 However, some machines, have instructions that preferentially
1 handle either signed or unsigned quantities of certain modes. For
1 example, on the DEC Alpha, 32-bit loads from memory and 32-bit add
1 instructions sign-extend the result to 64 bits. On such machines,
1 set UNSIGNEDP according to which kind of extension is more
1 efficient.
1
1 Do not define this macro if it would never modify M.
1
1 -- Target Hook: enum flt_eval_method TARGET_C_EXCESS_PRECISION (enum
1 excess_precision_type TYPE)
1 Return a value, with the same meaning as the C99 macro
1 'FLT_EVAL_METHOD' that describes which excess precision should be
1 applied. TYPE is either 'EXCESS_PRECISION_TYPE_IMPLICIT',
1 'EXCESS_PRECISION_TYPE_FAST', or 'EXCESS_PRECISION_TYPE_STANDARD'.
1 For 'EXCESS_PRECISION_TYPE_IMPLICIT', the target should return
1 which precision and range operations will be implictly evaluated in
1 regardless of the excess precision explicitly added. For
1 'EXCESS_PRECISION_TYPE_STANDARD' and 'EXCESS_PRECISION_TYPE_FAST',
1 the target should return the explicit excess precision that should
1 be added depending on the value set for
1 '-fexcess-precision=[standard|fast]'. Note that unpredictable
1 explicit excess precision does not make sense, so a target should
1 never return 'FLT_EVAL_METHOD_UNPREDICTABLE' when TYPE is
1 'EXCESS_PRECISION_TYPE_STANDARD' or 'EXCESS_PRECISION_TYPE_FAST'.
1
1 -- Target Hook: machine_mode TARGET_PROMOTE_FUNCTION_MODE (const_tree
1 TYPE, machine_mode MODE, int *PUNSIGNEDP, const_tree FUNTYPE,
1 int FOR_RETURN)
1 Like 'PROMOTE_MODE', but it is applied to outgoing function
1 arguments or function return values. The target hook should return
1 the new mode and possibly change '*PUNSIGNEDP' if the promotion
1 should change signedness. This function is called only for scalar
1 _or pointer_ types.
1
1 FOR_RETURN allows to distinguish the promotion of arguments and
1 return values. If it is '1', a return value is being promoted and
1 'TARGET_FUNCTION_VALUE' must perform the same promotions done here.
1 If it is '2', the returned mode should be that of the register in
1 which an incoming parameter is copied, or the outgoing result is
1 computed; then the hook should return the same mode as
1 'promote_mode', though the signedness may be different.
1
1 TYPE can be NULL when promoting function arguments of libcalls.
1
1 The default is to not promote arguments and return values. You can
1 also define the hook to
1 'default_promote_function_mode_always_promote' if you would like to
1 apply the same rules given by 'PROMOTE_MODE'.
1
1 -- Macro: PARM_BOUNDARY
1 Normal alignment required for function parameters on the stack, in
1 bits. All stack parameters receive at least this much alignment
1 regardless of data type. On most machines, this is the same as the
1 size of an integer.
1
1 -- Macro: STACK_BOUNDARY
1 Define this macro to the minimum alignment enforced by hardware for
1 the stack pointer on this machine. The definition is a C
1 expression for the desired alignment (measured in bits). This
1 value is used as a default if 'PREFERRED_STACK_BOUNDARY' is not
1 defined. On most machines, this should be the same as
1 'PARM_BOUNDARY'.
1
1 -- Macro: PREFERRED_STACK_BOUNDARY
1 Define this macro if you wish to preserve a certain alignment for
1 the stack pointer, greater than what the hardware enforces. The
1 definition is a C expression for the desired alignment (measured in
1 bits). This macro must evaluate to a value equal to or larger than
1 'STACK_BOUNDARY'.
1
1 -- Macro: INCOMING_STACK_BOUNDARY
1 Define this macro if the incoming stack boundary may be different
1 from 'PREFERRED_STACK_BOUNDARY'. This macro must evaluate to a
1 value equal to or larger than 'STACK_BOUNDARY'.
1
1 -- Macro: FUNCTION_BOUNDARY
1 Alignment required for a function entry point, in bits.
1
1 -- Macro: BIGGEST_ALIGNMENT
1 Biggest alignment that any data type can require on this machine,
1 in bits. Note that this is not the biggest alignment that is
1 supported, just the biggest alignment that, when violated, may
1 cause a fault.
1
1 -- Target Hook: HOST_WIDE_INT TARGET_ABSOLUTE_BIGGEST_ALIGNMENT
1 If defined, this target hook specifies the absolute biggest
1 alignment that a type or variable can have on this machine,
1 otherwise, 'BIGGEST_ALIGNMENT' is used.
1
1 -- Macro: MALLOC_ABI_ALIGNMENT
1 Alignment, in bits, a C conformant malloc implementation has to
1 provide. If not defined, the default value is 'BITS_PER_WORD'.
1
1 -- Macro: ATTRIBUTE_ALIGNED_VALUE
1 Alignment used by the '__attribute__ ((aligned))' construct. If
1 not defined, the default value is 'BIGGEST_ALIGNMENT'.
1
1 -- Macro: MINIMUM_ATOMIC_ALIGNMENT
1 If defined, the smallest alignment, in bits, that can be given to
1 an object that can be referenced in one operation, without
1 disturbing any nearby object. Normally, this is 'BITS_PER_UNIT',
1 but may be larger on machines that don't have byte or half-word
1 store operations.
1
1 -- Macro: BIGGEST_FIELD_ALIGNMENT
1 Biggest alignment that any structure or union field can require on
1 this machine, in bits. If defined, this overrides
1 'BIGGEST_ALIGNMENT' for structure and union fields only, unless the
1 field alignment has been set by the '__attribute__ ((aligned (N)))'
1 construct.
1
1 -- Macro: ADJUST_FIELD_ALIGN (FIELD, TYPE, COMPUTED)
1 An expression for the alignment of a structure field FIELD of type
1 TYPE if the alignment computed in the usual way (including applying
1 of 'BIGGEST_ALIGNMENT' and 'BIGGEST_FIELD_ALIGNMENT' to the
1 alignment) is COMPUTED. It overrides alignment only if the field
1 alignment has not been set by the '__attribute__ ((aligned (N)))'
1 construct. Note that FIELD may be 'NULL_TREE' in case we just
1 query for the minimum alignment of a field of type TYPE in
1 structure context.
1
1 -- Macro: MAX_STACK_ALIGNMENT
1 Biggest stack alignment guaranteed by the backend. Use this macro
1 to specify the maximum alignment of a variable on stack.
1
1 If not defined, the default value is 'STACK_BOUNDARY'.
1
1 -- Macro: MAX_OFILE_ALIGNMENT
1 Biggest alignment supported by the object file format of this
1 machine. Use this macro to limit the alignment which can be
1 specified using the '__attribute__ ((aligned (N)))' construct. If
1 not defined, the default value is 'BIGGEST_ALIGNMENT'.
1
1 On systems that use ELF, the default (in 'config/elfos.h') is the
1 largest supported 32-bit ELF section alignment representable on a
1 32-bit host e.g. '(((uint64_t) 1 << 28) * 8)'. On 32-bit ELF the
1 largest supported section alignment in bits is '(0x80000000 * 8)',
1 but this is not representable on 32-bit hosts.
1
1 -- Target Hook: HOST_WIDE_INT TARGET_STATIC_RTX_ALIGNMENT (machine_mode
1 MODE)
1 This hook returns the preferred alignment in bits for a
1 statically-allocated rtx, such as a constant pool entry. MODE is
1 the mode of the rtx. The default implementation returns
1 'GET_MODE_ALIGNMENT (MODE)'.
1
1 -- Macro: DATA_ALIGNMENT (TYPE, BASIC-ALIGN)
1 If defined, a C expression to compute the alignment for a variable
1 in the static store. TYPE is the data type, and BASIC-ALIGN is the
1 alignment that the object would ordinarily have. The value of this
1 macro is used instead of that alignment to align the object.
1
1 If this macro is not defined, then BASIC-ALIGN is used.
1
1 One use of this macro is to increase alignment of medium-size data
1 to make it all fit in fewer cache lines. Another is to cause
1 character arrays to be word-aligned so that 'strcpy' calls that
1 copy constants to character arrays can be done inline.
1
1 -- Macro: DATA_ABI_ALIGNMENT (TYPE, BASIC-ALIGN)
1 Similar to 'DATA_ALIGNMENT', but for the cases where the ABI
1 mandates some alignment increase, instead of optimization only
1 purposes. E.g. AMD x86-64 psABI says that variables with array
1 type larger than 15 bytes must be aligned to 16 byte boundaries.
1
1 If this macro is not defined, then BASIC-ALIGN is used.
1
1 -- Target Hook: HOST_WIDE_INT TARGET_CONSTANT_ALIGNMENT (const_tree
1 CONSTANT, HOST_WIDE_INT BASIC_ALIGN)
1 This hook returns the alignment in bits of a constant that is being
1 placed in memory. CONSTANT is the constant and BASIC_ALIGN is the
1 alignment that the object would ordinarily have.
1
1 The default definition just returns BASIC_ALIGN.
1
1 The typical use of this hook is to increase alignment for string
1 constants to be word aligned so that 'strcpy' calls that copy
1 constants can be done inline. The function
1 'constant_alignment_word_strings' provides such a definition.
1
1 -- Macro: LOCAL_ALIGNMENT (TYPE, BASIC-ALIGN)
1 If defined, a C expression to compute the alignment for a variable
1 in the local store. TYPE is the data type, and BASIC-ALIGN is the
1 alignment that the object would ordinarily have. The value of this
1 macro is used instead of that alignment to align the object.
1
1 If this macro is not defined, then BASIC-ALIGN is used.
1
1 One use of this macro is to increase alignment of medium-size data
1 to make it all fit in fewer cache lines.
1
1 If the value of this macro has a type, it should be an unsigned
1 type.
1
1 -- Target Hook: HOST_WIDE_INT TARGET_VECTOR_ALIGNMENT (const_tree TYPE)
1 This hook can be used to define the alignment for a vector of type
1 TYPE, in order to comply with a platform ABI. The default is to
1 require natural alignment for vector types. The alignment returned
1 by this hook must be a power-of-two multiple of the default
1 alignment of the vector element type.
1
1 -- Macro: STACK_SLOT_ALIGNMENT (TYPE, MODE, BASIC-ALIGN)
1 If defined, a C expression to compute the alignment for stack slot.
1 TYPE is the data type, MODE is the widest mode available, and
1 BASIC-ALIGN is the alignment that the slot would ordinarily have.
1 The value of this macro is used instead of that alignment to align
1 the slot.
1
1 If this macro is not defined, then BASIC-ALIGN is used when TYPE is
1 'NULL'. Otherwise, 'LOCAL_ALIGNMENT' will be used.
1
1 This macro is to set alignment of stack slot to the maximum
1 alignment of all possible modes which the slot may have.
1
1 If the value of this macro has a type, it should be an unsigned
1 type.
1
1 -- Macro: LOCAL_DECL_ALIGNMENT (DECL)
1 If defined, a C expression to compute the alignment for a local
1 variable DECL.
1
1 If this macro is not defined, then 'LOCAL_ALIGNMENT (TREE_TYPE
1 (DECL), DECL_ALIGN (DECL))' is used.
1
1 One use of this macro is to increase alignment of medium-size data
1 to make it all fit in fewer cache lines.
1
1 If the value of this macro has a type, it should be an unsigned
1 type.
1
1 -- Macro: MINIMUM_ALIGNMENT (EXP, MODE, ALIGN)
1 If defined, a C expression to compute the minimum required
1 alignment for dynamic stack realignment purposes for EXP (a type or
1 decl), MODE, assuming normal alignment ALIGN.
1
1 If this macro is not defined, then ALIGN will be used.
1
1 -- Macro: EMPTY_FIELD_BOUNDARY
1 Alignment in bits to be given to a structure bit-field that follows
1 an empty field such as 'int : 0;'.
1
1 If 'PCC_BITFIELD_TYPE_MATTERS' is true, it overrides this macro.
1
1 -- Macro: STRUCTURE_SIZE_BOUNDARY
1 Number of bits which any structure or union's size must be a
1 multiple of. Each structure or union's size is rounded up to a
1 multiple of this.
1
1 If you do not define this macro, the default is the same as
1 'BITS_PER_UNIT'.
1
1 -- Macro: STRICT_ALIGNMENT
1 Define this macro to be the value 1 if instructions will fail to
1 work if given data not on the nominal alignment. If instructions
1 will merely go slower in that case, define this macro as 0.
1
1 -- Macro: PCC_BITFIELD_TYPE_MATTERS
1 Define this if you wish to imitate the way many other C compilers
1 handle alignment of bit-fields and the structures that contain
1 them.
1
1 The behavior is that the type written for a named bit-field ('int',
1 'short', or other integer type) imposes an alignment for the entire
1 structure, as if the structure really did contain an ordinary field
1 of that type. In addition, the bit-field is placed within the
1 structure so that it would fit within such a field, not crossing a
1 boundary for it.
1
1 Thus, on most machines, a named bit-field whose type is written as
1 'int' would not cross a four-byte boundary, and would force
1 four-byte alignment for the whole structure. (The alignment used
1 may not be four bytes; it is controlled by the other alignment
1 parameters.)
1
1 An unnamed bit-field will not affect the alignment of the
1 containing structure.
1
1 If the macro is defined, its definition should be a C expression; a
1 nonzero value for the expression enables this behavior.
1
1 Note that if this macro is not defined, or its value is zero, some
1 bit-fields may cross more than one alignment boundary. The
1 compiler can support such references if there are 'insv', 'extv',
1 and 'extzv' insns that can directly reference memory.
1
1 The other known way of making bit-fields work is to define
1 'STRUCTURE_SIZE_BOUNDARY' as large as 'BIGGEST_ALIGNMENT'. Then
1 every structure can be accessed with fullwords.
1
1 Unless the machine has bit-field instructions or you define
1 'STRUCTURE_SIZE_BOUNDARY' that way, you must define
1 'PCC_BITFIELD_TYPE_MATTERS' to have a nonzero value.
1
1 If your aim is to make GCC use the same conventions for laying out
1 bit-fields as are used by another compiler, here is how to
1 investigate what the other compiler does. Compile and run this
1 program:
1
1 struct foo1
1 {
1 char x;
1 char :0;
1 char y;
1 };
1
1 struct foo2
1 {
1 char x;
1 int :0;
1 char y;
1 };
1
1 main ()
1 {
1 printf ("Size of foo1 is %d\n",
1 sizeof (struct foo1));
1 printf ("Size of foo2 is %d\n",
1 sizeof (struct foo2));
1 exit (0);
1 }
1
1 If this prints 2 and 5, then the compiler's behavior is what you
1 would get from 'PCC_BITFIELD_TYPE_MATTERS'.
1
1 -- Macro: BITFIELD_NBYTES_LIMITED
1 Like 'PCC_BITFIELD_TYPE_MATTERS' except that its effect is limited
1 to aligning a bit-field within the structure.
1
1 -- Target Hook: bool TARGET_ALIGN_ANON_BITFIELD (void)
1 When 'PCC_BITFIELD_TYPE_MATTERS' is true this hook will determine
1 whether unnamed bitfields affect the alignment of the containing
1 structure. The hook should return true if the structure should
1 inherit the alignment requirements of an unnamed bitfield's type.
1
1 -- Target Hook: bool TARGET_NARROW_VOLATILE_BITFIELD (void)
1 This target hook should return 'true' if accesses to volatile
1 bitfields should use the narrowest mode possible. It should return
1 'false' if these accesses should use the bitfield container type.
1
1 The default is 'false'.
1
1 -- Target Hook: bool TARGET_MEMBER_TYPE_FORCES_BLK (const_tree FIELD,
1 machine_mode MODE)
1 Return true if a structure, union or array containing FIELD should
1 be accessed using 'BLKMODE'.
1
1 If FIELD is the only field in the structure, MODE is its mode,
1 otherwise MODE is VOIDmode. MODE is provided in the case where
1 structures of one field would require the structure's mode to
1 retain the field's mode.
1
1 Normally, this is not needed.
1
1 -- Macro: ROUND_TYPE_ALIGN (TYPE, COMPUTED, SPECIFIED)
1 Define this macro as an expression for the alignment of a type
1 (given by TYPE as a tree node) if the alignment computed in the
1 usual way is COMPUTED and the alignment explicitly specified was
1 SPECIFIED.
1
1 The default is to use SPECIFIED if it is larger; otherwise, use the
1 smaller of COMPUTED and 'BIGGEST_ALIGNMENT'
1
1 -- Macro: MAX_FIXED_MODE_SIZE
1 An integer expression for the size in bits of the largest integer
1 machine mode that should actually be used. All integer machine
1 modes of this size or smaller can be used for structures and unions
1 with the appropriate sizes. If this macro is undefined,
1 'GET_MODE_BITSIZE (DImode)' is assumed.
1
1 -- Macro: STACK_SAVEAREA_MODE (SAVE_LEVEL)
1 If defined, an expression of type 'machine_mode' that specifies the
1 mode of the save area operand of a 'save_stack_LEVEL' named pattern
1 (⇒Standard Names). SAVE_LEVEL is one of 'SAVE_BLOCK',
1 'SAVE_FUNCTION', or 'SAVE_NONLOCAL' and selects which of the three
1 named patterns is having its mode specified.
1
1 You need not define this macro if it always returns 'Pmode'. You
1 would most commonly define this macro if the 'save_stack_LEVEL'
1 patterns need to support both a 32- and a 64-bit mode.
1
1 -- Macro: STACK_SIZE_MODE
1 If defined, an expression of type 'machine_mode' that specifies the
1 mode of the size increment operand of an 'allocate_stack' named
1 pattern (⇒Standard Names).
1
1 You need not define this macro if it always returns 'word_mode'.
1 You would most commonly define this macro if the 'allocate_stack'
1 pattern needs to support both a 32- and a 64-bit mode.
1
1 -- Target Hook: scalar_int_mode TARGET_LIBGCC_CMP_RETURN_MODE (void)
1 This target hook should return the mode to be used for the return
1 value of compare instructions expanded to libgcc calls. If not
1 defined 'word_mode' is returned which is the right choice for a
1 majority of targets.
1
1 -- Target Hook: scalar_int_mode TARGET_LIBGCC_SHIFT_COUNT_MODE (void)
1 This target hook should return the mode to be used for the shift
1 count operand of shift instructions expanded to libgcc calls. If
1 not defined 'word_mode' is returned which is the right choice for a
1 majority of targets.
1
1 -- Target Hook: scalar_int_mode TARGET_UNWIND_WORD_MODE (void)
1 Return machine mode to be used for '_Unwind_Word' type. The
1 default is to use 'word_mode'.
1
1 -- Target Hook: bool TARGET_MS_BITFIELD_LAYOUT_P (const_tree
1 RECORD_TYPE)
1 This target hook returns 'true' if bit-fields in the given
1 RECORD_TYPE are to be laid out following the rules of Microsoft
1 Visual C/C++, namely: (i) a bit-field won't share the same storage
1 unit with the previous bit-field if their underlying types have
1 different sizes, and the bit-field will be aligned to the highest
1 alignment of the underlying types of itself and of the previous
1 bit-field; (ii) a zero-sized bit-field will affect the alignment of
1 the whole enclosing structure, even if it is unnamed; except that
1 (iii) a zero-sized bit-field will be disregarded unless it follows
1 another bit-field of nonzero size. If this hook returns 'true',
1 other macros that control bit-field layout are ignored.
1
1 When a bit-field is inserted into a packed record, the whole size
1 of the underlying type is used by one or more same-size adjacent
1 bit-fields (that is, if its long:3, 32 bits is used in the record,
1 and any additional adjacent long bit-fields are packed into the
1 same chunk of 32 bits. However, if the size changes, a new field
1 of that size is allocated). In an unpacked record, this is the
1 same as using alignment, but not equivalent when packing.
1
1 If both MS bit-fields and '__attribute__((packed))' are used, the
1 latter will take precedence. If '__attribute__((packed))' is used
1 on a single field when MS bit-fields are in use, it will take
1 precedence for that field, but the alignment of the rest of the
1 structure may affect its placement.
1
1 -- Target Hook: bool TARGET_DECIMAL_FLOAT_SUPPORTED_P (void)
1 Returns true if the target supports decimal floating point.
1
1 -- Target Hook: bool TARGET_FIXED_POINT_SUPPORTED_P (void)
1 Returns true if the target supports fixed-point arithmetic.
1
1 -- Target Hook: void TARGET_EXPAND_TO_RTL_HOOK (void)
1 This hook is called just before expansion into rtl, allowing the
1 target to perform additional initializations or analysis before the
1 expansion. For example, the rs6000 port uses it to allocate a
1 scratch stack slot for use in copying SDmode values between memory
1 and floating point registers whenever the function being expanded
1 has any SDmode usage.
1
1 -- Target Hook: void TARGET_INSTANTIATE_DECLS (void)
1 This hook allows the backend to perform additional instantiations
1 on rtl that are not actually in any insns yet, but will be later.
1
1 -- Target Hook: const char * TARGET_MANGLE_TYPE (const_tree TYPE)
1 If your target defines any fundamental types, or any types your
1 target uses should be mangled differently from the default, define
1 this hook to return the appropriate encoding for these types as
1 part of a C++ mangled name. The TYPE argument is the tree
1 structure representing the type to be mangled. The hook may be
1 applied to trees which are not target-specific fundamental types;
1 it should return 'NULL' for all such types, as well as arguments it
1 does not recognize. If the return value is not 'NULL', it must
1 point to a statically-allocated string constant.
1
1 Target-specific fundamental types might be new fundamental types or
1 qualified versions of ordinary fundamental types. Encode new
1 fundamental types as 'u N NAME', where NAME is the name used for
1 the type in source code, and N is the length of NAME in decimal.
1 Encode qualified versions of ordinary types as 'U N NAME CODE',
1 where NAME is the name used for the type qualifier in source code,
1 N is the length of NAME as above, and CODE is the code used to
1 represent the unqualified version of this type. (See
1 'write_builtin_type' in 'cp/mangle.c' for the list of codes.) In
1 both cases the spaces are for clarity; do not include any spaces in
1 your string.
1
1 This hook is applied to types prior to typedef resolution. If the
1 mangled name for a particular type depends only on that type's main
1 variant, you can perform typedef resolution yourself using
1 'TYPE_MAIN_VARIANT' before mangling.
1
1 The default version of this hook always returns 'NULL', which is
1 appropriate for a target that does not define any new fundamental
1 types.
1