--- gcc/gcc.info-23 2018/04/24 18:18:07 1.1.1.2 +++ gcc/gcc.info-23 2018/04/24 18:24:25 1.1.1.3 @@ -3,11 +3,11 @@ file gcc.texi. This file documents the use and the internals of the GNU compiler. - Published by the Free Software Foundation 675 Massachusetts Avenue -Cambridge, MA 02139 USA + Published by the Free Software Foundation 59 Temple Place - Suite 330 +Boston, MA 02111-1307 USA - Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation, -Inc. + Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995 Free Software +Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are @@ -30,540 +30,1117 @@ translations approved by the Free Softwa original English.  -File: gcc.info, Node: Misc, Prev: Cross-compilation, Up: Target Macros +File: gcc.info, Node: Uninitialized Data, Next: Label Output, Prev: Data Output, Up: Assembler Format -Miscellaneous Parameters -======================== +Output of Uninitialized Variables +--------------------------------- - Here are several miscellaneous parameters. + Each of the macros in this section is used to do the whole job of +outputting a single uninitialized variable. -`PREDICATE_CODES' - Define this if you have defined special-purpose predicates in the - file `MACHINE.c'. This macro is called within an initializer of an - array of structures. The first field in the structure is the name - of a predicate and the second field is an array of rtl codes. For - each predicate, list all rtl codes that can be in expressions - matched by the predicate. The list should have a trailing comma. - Here is an example of two entries in the list for a typical RISC - machine: - - #define PREDICATE_CODES \ - {"gen_reg_rtx_operand", {SUBREG, REG}}, \ - {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}}, - - Defining this macro does not affect the generated code (however, - incorrect definitions that omit an rtl code that may be matched by - the predicate can cause the compiler to malfunction). Instead, it - allows the table built by `genrecog' to be more compact and - efficient, thus speeding up the compiler. The most important - predicates to include in the list specified by this macro are - thoses used in the most insn patterns. - -`CASE_VECTOR_MODE' - An alias for a machine mode name. This is the machine mode that - elements of a jump-table should have. - -`CASE_VECTOR_PC_RELATIVE' - Define this macro if jump-tables should contain relative addresses. - -`CASE_DROPS_THROUGH' - Define this if control falls through a `case' insn when the index - value is out of range. This means the specified default-label is - actually ignored by the `case' insn proper. - -`CASE_VALUES_THRESHOLD' - Define this to be the smallest number of different values for - which it is best to use a jump-table instead of a tree of - conditional branches. The default is four for machines with a - `casesi' instruction and five otherwise. This is best for most - machines. - -`WORD_REGISTER_OPERATIONS' - Define this macro if operations between registers with integral - mode smaller than a word are always performed on the entire - register. Most RISC machines have this property and most CISC - machines do not. - -`LOAD_EXTEND_OP (MODE)' - Define this macro to be a C expression indicating when insns that - read memory in MODE, an integral mode narrower than a word, set the - bits outside of MODE to be either the sign-extension or the - zero-extension of the data read. Return `SIGN_EXTEND' for values - of MODE for which the insn sign-extends, `ZERO_EXTEND' for which - it zero-extends, and `NIL' for other modes. - - This macro is not called with MODE non-integral or with a width - greater than or equal to `BITS_PER_WORD', so you may return any - value in this case. Do not define this macro if it would always - return `NIL'. On machines where this macro is defined, you will - normally define it as the constant `SIGN_EXTEND' or `ZERO_EXTEND'. - -`IMPLICIT_FIX_EXPR' - An alias for a tree code that should be used by default for - conversion of floating point values to fixed point. Normally, - `FIX_ROUND_EXPR' is used. - -`FIXUNS_TRUNC_LIKE_FIX_TRUNC' - Define this macro if the same instructions that convert a floating - point number to a signed fixed point number also convert validly - to an unsigned one. - -`EASY_DIV_EXPR' - An alias for a tree code that is the easiest kind of division to - compile code for in the general case. It may be `TRUNC_DIV_EXPR', - `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four - division operators differ in how they round the result to an - integer. `EASY_DIV_EXPR' is used when it is permissible to use - any of those kinds of division and the choice should be made on - the basis of efficiency. - -`MOVE_MAX' - The maximum number of bytes that a single instruction can move - quickly from memory to memory. - -`MAX_MOVE_MAX' - The maximum number of bytes that a single instruction can move - quickly from memory to memory. If this is undefined, the default - is `MOVE_MAX'. Otherwise, it is the constant value that is the - largest value that `MOVE_MAX' can have at run-time. - -`SHIFT_COUNT_TRUNCATED' - A C expression that is nonzero if on this machine the number of - bits actually used for the count of a shift operation is equal to - the number of bits needed to represent the size of the object - being shifted. When this macro is non-zero, the compiler will - assume that it is safe to omit a sign-extend, zero-extend, and - certain bitwise `and' instructions that truncates the count of a - shift operation. On machines that have instructions that act on - bitfields at variable positions, which may include `bit test' - instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables - deletion of truncations of the values that serve as arguments to - bitfield instructions. - - If both types of instructions truncate the count (for shifts) and - position (for bitfield operations), or if no variable-position - bitfield instructions exist, you should define this macro. - - However, on some machines, such as the 80386 and the 680x0, - truncation only applies to shift operations and not the (real or - pretended) bitfield operations. Define `SHIFT_COUNT_TRUNCATED' to - be zero on such machines. Instead, add patterns to the `md' file - that include the implied truncation of the shift instructions. - - You need not define this macro if it would always have the value - of zero. - -`TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)' - A C expression which is nonzero if on this machine it is safe to - "convert" an integer of INPREC bits to one of OUTPREC bits (where - OUTPREC is smaller than INPREC) by merely operating on it as if it - had only OUTPREC bits. - - On many machines, this expression can be 1. - - When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for - modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result. - If this is the case, making `TRULY_NOOP_TRUNCATION' return 0 in - such cases may improve things. - -`STORE_FLAG_VALUE' - A C expression describing the value returned by a comparison - operator with an integral mode and stored by a store-flag - instruction (`sCOND') when the condition is true. This - description must apply to *all* the `sCOND' patterns and all the - comparison operators whose results have a `MODE_INT' mode. - - A value of 1 or -1 means that the instruction implementing the - comparison operator returns exactly 1 or -1 when the comparison is - true and 0 when the comparison is false. Otherwise, the value - indicates which bits of the result are guaranteed to be 1 when the - comparison is true. This value is interpreted in the mode of the - comparison operation, which is given by the mode of the first - operand in the `sCOND' pattern. Either the low bit or the sign - bit of `STORE_FLAG_VALUE' be on. Presently, only those bits are - used by the compiler. - - If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will - generate code that depends only on the specified bits. It can also - replace comparison operators with equivalent operations if they - cause the required bits to be set, even if the remaining bits are - undefined. For example, on a machine whose comparison operators - return an `SImode' value and where `STORE_FLAG_VALUE' is defined as - `0x80000000', saying that just the sign bit is relevant, the - expression - - (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0)) - - can be converted to - - (ashift:SI X (const_int N)) - - where N is the appropriate shift count to move the bit being - tested into the sign bit. - - There is no way to describe a machine that always sets the - low-order bit for a true value, but does not guarantee the value - of any other bits, but we do not know of any machine that has such - an instruction. If you are trying to port GNU CC to such a - machine, include an instruction to perform a logical-and of the - result with 1 in the pattern for the comparison operators and let - us know (*note How to Report Bugs: Bug Reporting.). - - Often, a machine will have multiple instructions that obtain a - value from a comparison (or the condition codes). Here are rules - to guide the choice of value for `STORE_FLAG_VALUE', and hence the - instructions to be used: - - * Use the shortest sequence that yields a valid definition for - `STORE_FLAG_VALUE'. It is more efficient for the compiler to - "normalize" the value (convert it to, e.g., 1 or 0) than for - the comparison operators to do so because there may be - opportunities to combine the normalization with other - operations. - - * For equal-length sequences, use a value of 1 or -1, with -1 - being slightly preferred on machines with expensive jumps and - 1 preferred on other machines. - - * As a second choice, choose a value of `0x80000001' if - instructions exist that set both the sign and low-order bits - but do not define the others. - - * Otherwise, use a value of `0x80000000'. - - Many machines can produce both the value chosen for - `STORE_FLAG_VALUE' and its negation in the same number of - instructions. On those machines, you should also define a pattern - for those cases, e.g., one matching - - (set A (neg:M (ne:M B C))) - - Some machines can also perform `and' or `plus' operations on - condition code values with less instructions than the corresponding - `sCOND' insn followed by `and' or `plus'. On those machines, - define the appropriate patterns. Use the names `incscc' and - `decscc', respectively, for the the patterns which perform `plus' - or `minus' operations on condition code values. See `rs6000.md' - for some examples. The GNU Superoptizer can be used to find such - instruction sequences on other machines. - - You need not define `STORE_FLAG_VALUE' if the machine has no - store-flag instructions. - -`FLOAT_STORE_FLAG_VALUE' - A C expression that gives a non-zero floating point value that is - returned when comparison operators with floating-point results are - true. Define this macro on machine that have comparison - operations that return floating-point values. If there are no - such operations, do not define this macro. - -`Pmode' - An alias for the machine mode for pointers. Normally the - definition can be - - #define Pmode SImode - -`FUNCTION_MODE' - An alias for the machine mode used for memory references to - functions being called, in `call' RTL expressions. On most - machines this should be `QImode'. - -`INTEGRATE_THRESHOLD (DECL)' - A C expression for the maximum number of instructions above which - the function DECL should not be inlined. DECL is a - `FUNCTION_DECL' node. - - The default definition of this macro is 64 plus 8 times the number - of arguments that the function accepts. Some people think a larger - threshold should be used on RISC machines. - -`SCCS_DIRECTIVE' - Define this if the preprocessor should ignore `#sccs' directives - and print no error message. - -`NO_IMPLICIT_EXTERN_C' - Define this macro if the system header files support C++ as well - as C. This macro inhibits the usual method of using system header - files in C++, which is to pretend that the file's contents are - enclosed in `extern "C" {...}'. - -`HANDLE_PRAGMA (STREAM)' - Define this macro if you want to implement any pragmas. If - defined, it should be a C statement to be executed when `#pragma' - is seen. The argument STREAM is the stdio input stream from which - the source text can be read. - - It is generally a bad idea to implement new uses of `#pragma'. The - only reason to define this macro is for compatibility with other - compilers that do support `#pragma' for the sake of any user - programs which already use it. - -`VALID_MACHINE_ATTRIBUTE (TYPE, ATTRIBUTES, IDENTIFIER)' - Define this macro if you want to support machine specific - attributes for types. If defined, it should be a C statement - whose value is nonzero if IDENTIFIER is an attribute that is valid - for TYPE. The attributes in ATTRIBUTES have previously been - assigned to TYPE. - -`COMP_TYPE_ATTRIBUTES (TYPE1, TYPE2)' - Define this macro if type attributes must be checked for - compatibility. If defined, it should be a C statement that - returns zero if the attributes on TYPE1 and TYPE2 are - incompatible, one if they are compatible, and two if they are - nearly compatible (which causes a warning to be generated). - -`SET_DEFAULT_TYPE_ATTRIBUTES (TYPE)' - Define this macro if you want to give the newly defined TYPE some - default attributes. - -`DOLLARS_IN_IDENTIFIERS' - Define this macro to control use of the character `$' in identifier - names. The value should be 0, 1, or 2. 0 means `$' is not allowed - by default; 1 means it is allowed by default if `-traditional' is - used; 2 means it is allowed by default provided `-ansi' is not - used. 1 is the default; there is no need to define this macro in - that case. - -`NO_DOLLAR_IN_LABEL' - Define this macro if the assembler does not accept the character - `$' in label names. By default constructors and destructors in - G++ have `$' in the identifiers. If this macro is defined, `.' is - used instead. - -`NO_DOT_IN_LABEL' - Define this macro if the assembler does not accept the character - `.' in label names. By default constructors and destructors in G++ - have names that use `.'. If this macro is defined, these names - are rewritten to avoid `.'. - -`DEFAULT_MAIN_RETURN' - Define this macro if the target system expects every program's - `main' function to return a standard "success" value by default - (if no other value is explicitly returned). - - The definition should be a C statement (sans semicolon) to - generate the appropriate rtl instructions. It is used only when - compiling the end of `main'. - -`HAVE_ATEXIT' - Define this if the target system supports the function `atexit' - from the ANSI C standard. If this is not defined, and - `INIT_SECTION_ASM_OP' is not defined, a default `exit' function - will be provided to support C++. - -`EXIT_BODY' - Define this if your `exit' function needs to do something besides - calling an external function `_cleanup' before terminating with - `_exit'. The `EXIT_BODY' macro is only needed if netiher - `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined. - -`INSN_SETS_ARE_DELAYED (INSN)' - Define this macro as a C expression that is nonzero if it is safe - for the delay slot scheduler to place instructions in the delay - slot of INSN, even if they appear to use a resource set or - clobbered in INSN. INSN is always a `jump_insn' or an `insn'; GNU - CC knows that every `call_insn' has this behavior. On machines - where some `insn' or `jump_insn' is really a function call and - hence has this behavior, you should define this macro. - - You need not define this macro if it would always return zero. - -`INSN_REFERENCES_ARE_DELAYED (INSN)' - Define this macro as a C expression that is nonzero if it is safe - for the delay slot scheduler to place instructions in the delay - slot of INSN, even if they appear to set or clobber a resource - referenced in INSN. INSN is always a `jump_insn' or an `insn'. - On machines where some `insn' or `jump_insn' is really a function - call and its operands are registers whose use is actually in the - subroutine it calls, you should define this macro. Doing so - allows the delay slot scheduler to move instructions which copy - arguments into the argument registers into the delay slot of INSN. - - You need not define this macro if it would always return zero. - -`MACHINE_DEPENDENT_REORG (INSN)' - In rare cases, correct code generation requires extra machine - dependent processing between the second jump optimization pass and - delayed branch scheduling. On those machines, define this macro - as a C statement to act on the code starting at INSN. - - -File: gcc.info, Node: Config, Next: Index, Prev: Target Macros, Up: Top - -The Configuration File -********************** - - The configuration file `xm-MACHINE.h' contains macro definitions -that describe the machine and system on which the compiler is running, -unlike the definitions in `MACHINE.h', which describe the machine for -which the compiler is producing output. Most of the values in -`xm-MACHINE.h' are actually the same on all machines that GNU CC runs -on, so large parts of all configuration files are identical. But there -are some macros that vary: - -`USG' - Define this macro if the host system is System V. - -`VMS' - Define this macro if the host system is VMS. - -`FAILURE_EXIT_CODE' - A C expression for the status code to be returned when the compiler - exits after serious errors. - -`SUCCESS_EXIT_CODE' - A C expression for the status code to be returned when the compiler - exits without serious errors. - -`HOST_WORDS_BIG_ENDIAN' - Defined if the host machine stores words of multi-word values in - big-endian order. (GNU CC does not depend on the host byte - ordering within a word.) - -`HOST_FLOAT_WORDS_BIG_ENDIAN' - Define this macro to be 1 if the host machine stores `DFmode', - `XFmode' or `TFmode' floating point numbers in memory with the - word containing the sign bit at the lowest address; otherwise, - define it to be zero. - - This macro need not be defined if the ordering is the same as for - multi-word integers. - -`HOST_FLOAT_FORMAT' - A numeric code distinguishing the floating point format for the - host machine. See `TARGET_FLOAT_FORMAT' in *Note Storage Layout:: - for the alternatives and default. - -`HOST_BITS_PER_CHAR' - A C expression for the number of bits in `char' on the host - machine. - -`HOST_BITS_PER_SHORT' - A C expression for the number of bits in `short' on the host - machine. - -`HOST_BITS_PER_INT' - A C expression for the number of bits in `int' on the host machine. - -`HOST_BITS_PER_LONG' - A C expression for the number of bits in `long' on the host - machine. - -`ONLY_INT_FIELDS' - Define this macro to indicate that the host compiler only supports - `int' bit fields, rather than other integral types, including - `enum', as do most C compilers. - -`EXECUTABLE_SUFFIX' - Define this macro if the host system uses a naming convention for - executable files that involves a common suffix (such as, in some - systems, `.exe') that must be mentioned explicitly when you run - the program. - -`OBSTACK_CHUNK_SIZE' - A C expression for the size of ordinary obstack chunks. If you - don't define this, a usually-reasonable default is used. - -`OBSTACK_CHUNK_ALLOC' - The function used to allocate obstack chunks. If you don't define - this, `xmalloc' is used. - -`OBSTACK_CHUNK_FREE' - The function used to free obstack chunks. If you don't define - this, `free' is used. - -`USE_C_ALLOCA' - Define this macro to indicate that the compiler is running with the - `alloca' implemented in C. This version of `alloca' can be found - in the file `alloca.c'; to use it, you must also alter the - `Makefile' variable `ALLOCA'. (This is done automatically for the - systems on which we know it is needed.) - - If you do define this macro, you should probably do it as follows: - - #ifndef __GNUC__ - #define USE_C_ALLOCA - #else - #define alloca __builtin_alloca - #endif - - so that when the compiler is compiled with GNU CC it uses the more - efficient built-in `alloca' function. - -`FUNCTION_CONVERSION_BUG' - Define this macro to indicate that the host compiler does not - properly handle converting a function value to a - pointer-to-function when it is used in an expression. - -`HAVE_VPRINTF' - Define this if the library function `vprintf' is available on your - system. - -`MULTIBYTE_CHARS' - Define this macro to enable support for multibyte characters in the - input to GNU CC. This requires that the host system support the - ANSI C library functions for converting multibyte characters to - wide characters. - -`HAVE_PUTENV' - Define this if the library function `putenv' is available on your - system. - -`NO_SYS_SIGLIST' - Define this if your system *does not* provide the variable - `sys_siglist'. - -`DONT_DECLARE_SYS_SIGLIST' - Define this if your system has the variable `sys_siglist', and - there is already a declaration of it in the system header files. - -`USE_PROTOTYPES' - Define this to be 1 if you know that the host compiler supports - prototypes, even if it doesn't define __STDC__, or define it to be - 0 if you do not want any prototypes used in compiling GNU CC. If - `USE_PROTOTYPES' is not defined, it will be determined - automatically whether your compiler supports prototypes by - checking if `__STDC__' is defined. - -`NO_MD_PROTOTYPES' - Define this if you wish suppression of prototypes generated from - the machine description file, but to use other prototypes within - GNU CC. If `USE_PROTOTYPES' is defined to be 0, or the host - compiler does not support prototypes, this macro has no effect. - -`MD_CALL_PROTOTYPES' - Define this if you wish to generate prototypes for the `gen_call' - or `gen_call_value' functions generated from the machine - description file. If `USE_PROTOTYPES' is defined to be 0, or the - host compiler does not support prototypes, or `NO_MD_PROTOTYPES' - is defined, this macro has no effect. As soon as all of the - machine descriptions are modified to have the appropriate number - of arguments, this macro will be removed. - - Some systems do provide this variable, but with a different name - such as `_sys_siglist'. On these systems, you can define - `sys_siglist' as a macro which expands into the name actually - provided. - -`NO_STAB_H' - Define this if your system does not have the include file - `stab.h'. If `USG' is defined, `NO_STAB_H' is assumed. - -`PATH_SEPARATOR' - Define this macro to be a C character constant representing the - character used to separate components in paths. The default value - is. the colon character - -`DIR_SEPARATOR' - If your system uses some character other than slash to separate - directory names within a file specification, define this macro to - be a C character constant specifying that character. When GNU CC - displays file names, the character you specify will be used. GNU - CC will test for both slash and the character you specify when - parsing filenames. - - In addition, configuration files for system V define `bcopy', -`bzero' and `bcmp' as aliases. Some files define `alloca' as a macro -when compiled with GNU CC, in order to take advantage of the benefit of -GNU CC's built-in `alloca'. +`ASM_OUTPUT_COMMON (STREAM, NAME, SIZE, ROUNDED)' + A C statement (sans semicolon) to output to the stdio stream + STREAM the assembler definition of a common-label named NAME whose + size is SIZE bytes. The variable ROUNDED is the size rounded up + to whatever alignment the caller wants. + + Use the expression `assemble_name (STREAM, NAME)' to output the + name itself; before and after that, output the additional + assembler syntax for defining the name, and a newline. + + This macro controls how the assembler definitions of uninitialized + global variables are output. + +`ASM_OUTPUT_ALIGNED_COMMON (STREAM, NAME, SIZE, ALIGNMENT)' + Like `ASM_OUTPUT_COMMON' except takes the required alignment as a + separate, explicit argument. If you define this macro, it is used + in place of `ASM_OUTPUT_COMMON', and gives you more flexibility in + handling the required alignment of the variable. The alignment is + specified as the number of bits. + +`ASM_OUTPUT_SHARED_COMMON (STREAM, NAME, SIZE, ROUNDED)' + If defined, it is similar to `ASM_OUTPUT_COMMON', except that it + is used when NAME is shared. If not defined, `ASM_OUTPUT_COMMON' + will be used. + +`ASM_OUTPUT_LOCAL (STREAM, NAME, SIZE, ROUNDED)' + A C statement (sans semicolon) to output to the stdio stream + STREAM the assembler definition of a local-common-label named NAME + whose size is SIZE bytes. The variable ROUNDED is the size + rounded up to whatever alignment the caller wants. + + Use the expression `assemble_name (STREAM, NAME)' to output the + name itself; before and after that, output the additional + assembler syntax for defining the name, and a newline. + + This macro controls how the assembler definitions of uninitialized + static variables are output. + +`ASM_OUTPUT_ALIGNED_LOCAL (STREAM, NAME, SIZE, ALIGNMENT)' + Like `ASM_OUTPUT_LOCAL' except takes the required alignment as a + separate, explicit argument. If you define this macro, it is used + in place of `ASM_OUTPUT_LOCAL', and gives you more flexibility in + handling the required alignment of the variable. The alignment is + specified as the number of bits. + +`ASM_OUTPUT_SHARED_LOCAL (STREAM, NAME, SIZE, ROUNDED)' + If defined, it is similar to `ASM_OUTPUT_LOCAL', except that it is + used when NAME is shared. If not defined, `ASM_OUTPUT_LOCAL' will + be used. + + +File: gcc.info, Node: Label Output, Next: Initialization, Prev: Uninitialized Data, Up: Assembler Format + +Output and Generation of Labels +------------------------------- + + This is about outputting labels. + +`ASM_OUTPUT_LABEL (STREAM, NAME)' + A C statement (sans semicolon) to output to the stdio stream + STREAM the assembler definition of a label named NAME. Use the + expression `assemble_name (STREAM, NAME)' to output the name + itself; before and after that, output the additional assembler + syntax for defining the name, and a newline. + +`ASM_DECLARE_FUNCTION_NAME (STREAM, NAME, DECL)' + A C statement (sans semicolon) to output to the stdio stream + STREAM any text necessary for declaring the name NAME of a + function which is being defined. This macro is responsible for + outputting the label definition (perhaps using + `ASM_OUTPUT_LABEL'). The argument DECL is the `FUNCTION_DECL' + tree node representing the function. + + If this macro is not defined, then the function name is defined in + the usual manner as a label (by means of `ASM_OUTPUT_LABEL'). + +`ASM_DECLARE_FUNCTION_SIZE (STREAM, NAME, DECL)' + A C statement (sans semicolon) to output to the stdio stream + STREAM any text necessary for declaring the size of a function + which is being defined. The argument NAME is the name of the + function. The argument DECL is the `FUNCTION_DECL' tree node + representing the function. + + If this macro is not defined, then the function size is not + defined. + +`ASM_DECLARE_OBJECT_NAME (STREAM, NAME, DECL)' + A C statement (sans semicolon) to output to the stdio stream + STREAM any text necessary for declaring the name NAME of an + initialized variable which is being defined. This macro must + output the label definition (perhaps using `ASM_OUTPUT_LABEL'). + The argument DECL is the `VAR_DECL' tree node representing the + variable. + + If this macro is not defined, then the variable name is defined in + the usual manner as a label (by means of `ASM_OUTPUT_LABEL'). + +`ASM_FINISH_DECLARE_OBJECT (STREAM, DECL, TOPLEVEL, ATEND)' + A C statement (sans semicolon) to finish up declaring a variable + name once the compiler has processed its initializer fully and + thus has had a chance to determine the size of an array when + controlled by an initializer. This is used on systems where it's + necessary to declare something about the size of the object. + + If you don't define this macro, that is equivalent to defining it + to do nothing. + +`ASM_GLOBALIZE_LABEL (STREAM, NAME)' + A C statement (sans semicolon) to output to the stdio stream + STREAM some commands that will make the label NAME global; that + is, available for reference from other files. Use the expression + `assemble_name (STREAM, NAME)' to output the name itself; before + and after that, output the additional assembler syntax for making + that name global, and a newline. + +`ASM_WEAKEN_LABEL' + A C statement (sans semicolon) to output to the stdio stream + STREAM some commands that will make the label NAME weak; that is, + available for reference from other files but only used if no other + definition is available. Use the expression `assemble_name + (STREAM, NAME)' to output the name itself; before and after that, + output the additional assembler syntax for making that name weak, + and a newline. + + If you don't define this macro, GNU CC will not support weak + symbols and you should not define the `SUPPORTS_WEAK' macro. + +`SUPPORTS_WEAK' + A C expression which evaluates to true if the target supports weak + symbols. + + If you don't define this macro, `defaults.h' provides a default + definition. If `ASM_WEAKEN_LABEL' is defined, the default + definition is `1'; otherwise, it is `0'. Define this macro if you + want to control weak symbol support with a compiler flag such as + `-melf'. + +`ASM_OUTPUT_EXTERNAL (STREAM, DECL, NAME)' + A C statement (sans semicolon) to output to the stdio stream + STREAM any text necessary for declaring the name of an external + symbol named NAME which is referenced in this compilation but not + defined. The value of DECL is the tree node for the declaration. + + This macro need not be defined if it does not need to output + anything. The GNU assembler and most Unix assemblers don't + require anything. + +`ASM_OUTPUT_EXTERNAL_LIBCALL (STREAM, SYMREF)' + A C statement (sans semicolon) to output on STREAM an assembler + pseudo-op to declare a library function name external. The name + of the library function is given by SYMREF, which has type `rtx' + and is a `symbol_ref'. + + This macro need not be defined if it does not need to output + anything. The GNU assembler and most Unix assemblers don't + require anything. + +`ASM_OUTPUT_LABELREF (STREAM, NAME)' + A C statement (sans semicolon) to output to the stdio stream + STREAM a reference in assembler syntax to a label named NAME. + This should add `_' to the front of the name, if that is customary + on your operating system, as it is in most Berkeley Unix systems. + This macro is used in `assemble_name'. + +`ASM_OUTPUT_INTERNAL_LABEL (STREAM, PREFIX, NUM)' + A C statement to output to the stdio stream STREAM a label whose + name is made from the string PREFIX and the number NUM. + + It is absolutely essential that these labels be distinct from the + labels used for user-level functions and variables. Otherwise, + certain programs will have name conflicts with internal labels. + + It is desirable to exclude internal labels from the symbol table + of the object file. Most assemblers have a naming convention for + labels that should be excluded; on many systems, the letter `L' at + the beginning of a label has this effect. You should find out what + convention your system uses, and follow it. + + The usual definition of this macro is as follows: + + fprintf (STREAM, "L%s%d:\n", PREFIX, NUM) + +`ASM_GENERATE_INTERNAL_LABEL (STRING, PREFIX, NUM)' + A C statement to store into the string STRING a label whose name + is made from the string PREFIX and the number NUM. + + This string, when output subsequently by `assemble_name', should + produce the output that `ASM_OUTPUT_INTERNAL_LABEL' would produce + with the same PREFIX and NUM. + + If the string begins with `*', then `assemble_name' will output + the rest of the string unchanged. It is often convenient for + `ASM_GENERATE_INTERNAL_LABEL' to use `*' in this way. If the + string doesn't start with `*', then `ASM_OUTPUT_LABELREF' gets to + output the string, and may change it. (Of course, + `ASM_OUTPUT_LABELREF' is also part of your machine description, so + you should know what it does on your machine.) + +`ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)' + A C expression to assign to OUTVAR (which is a variable of type + `char *') a newly allocated string made from the string NAME and + the number NUMBER, with some suitable punctuation added. Use + `alloca' to get space for the string. + + The string will be used as an argument to `ASM_OUTPUT_LABELREF' to + produce an assembler label for an internal static variable whose + name is NAME. Therefore, the string must be such as to result in + valid assembler code. The argument NUMBER is different each time + this macro is executed; it prevents conflicts between + similarly-named internal static variables in different scopes. + + Ideally this string should not be a valid C identifier, to prevent + any conflict with the user's own symbols. Most assemblers allow + periods or percent signs in assembler symbols; putting at least + one of these between the name and the number will suffice. + +`ASM_OUTPUT_DEF (STREAM, NAME, VALUE)' + A C statement to output to the stdio stream STREAM assembler code + which defines (equates) the symbol NAME to have the value VALUE. + + If SET_ASM_OP is defined, a default definition is provided which is + correct for most systems. + +`OBJC_GEN_METHOD_LABEL (BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME)' + Define this macro to override the default assembler names used for + Objective C methods. + + The default name is a unique method number followed by the name of + the class (e.g. `_1_Foo'). For methods in categories, the name of + the category is also included in the assembler name (e.g. + `_1_Foo_Bar'). + + These names are safe on most systems, but make debugging difficult + since the method's selector is not present in the name. + Therefore, particular systems define other ways of computing names. + + BUF is an expression of type `char *' which gives you a buffer in + which to store the name; its length is as long as CLASS_NAME, + CAT_NAME and SEL_NAME put together, plus 50 characters extra. + + The argument IS_INST specifies whether the method is an instance + method or a class method; CLASS_NAME is the name of the class; + CAT_NAME is the name of the category (or NULL if the method is not + in a category); and SEL_NAME is the name of the selector. + + On systems where the assembler can handle quoted names, you can + use this macro to provide more human-readable names. + + +File: gcc.info, Node: Initialization, Next: Macros for Initialization, Prev: Label Output, Up: Assembler Format + +How Initialization Functions Are Handled +---------------------------------------- + + The compiled code for certain languages includes "constructors" +(also called "initialization routines")--functions to initialize data +in the program when the program is started. These functions need to be +called before the program is "started"--that is to say, before `main' +is called. + + Compiling some languages generates "destructors" (also called +"termination routines") that should be called when the program +terminates. + + To make the initialization and termination functions work, the +compiler must output something in the assembler code to cause those +functions to be called at the appropriate time. When you port the +compiler to a new system, you need to specify how to do this. + + There are two major ways that GCC currently supports the execution of +initialization and termination functions. Each way has two variants. +Much of the structure is common to all four variations. + + The linker must build two lists of these functions--a list of +initialization functions, called `__CTOR_LIST__', and a list of +termination functions, called `__DTOR_LIST__'. + + Each list always begins with an ignored function pointer (which may +hold 0, -1, or a count of the function pointers after it, depending on +the environment). This is followed by a series of zero or more function +pointers to constructors (or destructors), followed by a function +pointer containing zero. + + Depending on the operating system and its executable file format, +either `crtstuff.c' or `libgcc2.c' traverses these lists at startup +time and exit time. Constructors are called in reverse order of the +list; destructors in forward order. + + The best way to handle static constructors works only for object file +formats which provide arbitrarily-named sections. A section is set +aside for a list of constructors, and another for a list of destructors. +Traditionally these are called `.ctors' and `.dtors'. Each object file +that defines an initialization function also puts a word in the +constructor section to point to that function. The linker accumulates +all these words into one contiguous `.ctors' section. Termination +functions are handled similarly. + + To use this method, you need appropriate definitions of the macros +`ASM_OUTPUT_CONSTRUCTOR' and `ASM_OUTPUT_DESTRUCTOR'. Usually you can +get them by including `svr4.h'. + + When arbitrary sections are available, there are two variants, +depending upon how the code in `crtstuff.c' is called. On systems that +support an "init" section which is executed at program startup, parts +of `crtstuff.c' are compiled into that section. The program is linked +by the `gcc' driver like this: + + ld -o OUTPUT_FILE crtbegin.o ... crtend.o -lgcc + + The head of a function (`__do_global_ctors') appears in the init +section of `crtbegin.o'; the remainder of the function appears in the +init section of `crtend.o'. The linker will pull these two parts of +the section together, making a whole function. If any of the user's +object files linked into the middle of it contribute code, then that +code will be executed as part of the body of `__do_global_ctors'. + + To use this variant, you must define the `INIT_SECTION_ASM_OP' macro +properly. + + If no init section is available, do not define +`INIT_SECTION_ASM_OP'. Then `__do_global_ctors' is built into the text +section like all other functions, and resides in `libgcc.a'. When GCC +compiles any function called `main', it inserts a procedure call to +`__main' as the first executable code after the function prologue. The +`__main' function, also defined in `libgcc2.c', simply calls +`__do_global_ctors'. + + In file formats that don't support arbitrary sections, there are +again two variants. In the simplest variant, the GNU linker (GNU `ld') +and an `a.out' format must be used. In this case, +`ASM_OUTPUT_CONSTRUCTOR' is defined to produce a `.stabs' entry of type +`N_SETT', referencing the name `__CTOR_LIST__', and with the address of +the void function containing the initialization code as its value. The +GNU linker recognizes this as a request to add the value to a "set"; +the values are accumulated, and are eventually placed in the executable +as a vector in the format described above, with a leading (ignored) +count and a trailing zero element. `ASM_OUTPUT_DESTRUCTOR' is handled +similarly. Since no init section is available, the absence of +`INIT_SECTION_ASM_OP' causes the compilation of `main' to call `__main' +as above, starting the initialization process. + + The last variant uses neither arbitrary sections nor the GNU linker. +This is preferable when you want to do dynamic linking and when using +file formats which the GNU linker does not support, such as `ECOFF'. In +this case, `ASM_OUTPUT_CONSTRUCTOR' does not produce an `N_SETT' +symbol; initialization and termination functions are recognized simply +by their names. This requires an extra program in the linkage step, +called `collect2'. This program pretends to be the linker, for use +with GNU CC; it does its job by running the ordinary linker, but also +arranges to include the vectors of initialization and termination +functions. These functions are called via `__main' as described above. + + Choosing among these configuration options has been simplified by a +set of operating-system-dependent files in the `config' subdirectory. +These files define all of the relevant parameters. Usually it is +sufficient to include one into your specific machine-dependent +configuration file. These files are: + +`aoutos.h' + For operating systems using the `a.out' format. + +`next.h' + For operating systems using the `MachO' format. + +`svr3.h' + For System V Release 3 and similar systems using `COFF' format. + +`svr4.h' + For System V Release 4 and similar systems using `ELF' format. + +`vms.h' + For the VMS operating system. + + The following section describes the specific macros that control and +customize the handling of initialization and termination functions. + + +File: gcc.info, Node: Macros for Initialization, Next: Instruction Output, Prev: Initialization, Up: Assembler Format + +Macros Controlling Initialization Routines +------------------------------------------ + + Here are the macros that control how the compiler handles +initialization and termination functions: + +`INIT_SECTION_ASM_OP' + If defined, a C string constant for the assembler operation to + identify the following data as initialization code. If not + defined, GNU CC will assume such a section does not exist. When + you are using special sections for initialization and termination + functions, this macro also controls how `crtstuff.c' and + `libgcc2.c' arrange to run the initialization functions. + +`HAS_INIT_SECTION' + If defined, `main' will not call `__main' as described above. + This macro should be defined for systems that control the contents + of the init section on a symbol-by-symbol basis, such as OSF/1, + and should not be defined explicitly for systems that support + `INIT_SECTION_ASM_OP'. + +`LD_INIT_SWITCH' + If defined, a C string constant for a switch that tells the linker + that the following symbol is an initialization routine. + +`LD_FINI_SWITCH' + If defined, a C string constant for a switch that tells the linker + that the following symbol is a finalization routine. + +`INVOKE__main' + If defined, `main' will call `__main' despite the presence of + `INIT_SECTION_ASM_OP'. This macro should be defined for systems + where the init section is not actually run automatically, but is + still useful for collecting the lists of constructors and + destructors. + +`ASM_OUTPUT_CONSTRUCTOR (STREAM, NAME)' + Define this macro as a C statement to output on the stream STREAM + the assembler code to arrange to call the function named NAME at + initialization time. + + Assume that NAME is the name of a C function generated + automatically by the compiler. This function takes no arguments. + Use the function `assemble_name' to output the name NAME; this + performs any system-specific syntactic transformations such as + adding an underscore. + + If you don't define this macro, nothing special is output to + arrange to call the function. This is correct when the function + will be called in some other manner--for example, by means of the + `collect2' program, which looks through the symbol table to find + these functions by their names. + +`ASM_OUTPUT_DESTRUCTOR (STREAM, NAME)' + This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination + functions rather than initialization functions. + + If your system uses `collect2' as the means of processing +constructors, then that program normally uses `nm' to scan an object +file for constructor functions to be called. On certain kinds of +systems, you can define these macros to make `collect2' work faster +(and, in some cases, make it work at all): + +`OBJECT_FORMAT_COFF' + Define this macro if the system uses COFF (Common Object File + Format) object files, so that `collect2' can assume this format + and scan object files directly for dynamic constructor/destructor + functions. + +`OBJECT_FORMAT_ROSE' + Define this macro if the system uses ROSE format object files, so + that `collect2' can assume this format and scan object files + directly for dynamic constructor/destructor functions. + + These macros are effective only in a native compiler; `collect2' as + part of a cross compiler always uses `nm' for the target machine. + +`REAL_NM_FILE_NAME' + Define this macro as a C string constant containing the file name + to use to execute `nm'. The default is to search the path + normally for `nm'. + + If your system supports shared libraries and has a program to list + the dynamic dependencies of a given library or executable, you can + define these macros to enable support for running initialization + and termination functions in shared libraries: + +`LDD_SUFFIX' + Define this macro to a C string constant containing the name of the + program which lists dynamic dependencies, like `"ldd"' under SunOS + 4. + +`PARSE_LDD_OUTPUT (PTR)' + Define this macro to be C code that extracts filenames from the + output of the program denoted by `LDD_SUFFIX'. PTR is a variable + of type `char *' that points to the beginning of a line of output + from `LDD_SUFFIX'. If the line lists a dynamic dependency, the + code must advance PTR to the beginning of the filename on that + line. Otherwise, it must set PTR to `NULL'. + + +File: gcc.info, Node: Instruction Output, Next: Dispatch Tables, Prev: Macros for Initialization, Up: Assembler Format + +Output of Assembler Instructions +-------------------------------- + + This describes assembler instruction output. + +`REGISTER_NAMES' + A C initializer containing the assembler's names for the machine + registers, each one as a C string constant. This is what + translates register numbers in the compiler into assembler + language. + +`ADDITIONAL_REGISTER_NAMES' + If defined, a C initializer for an array of structures containing + a name and a register number. This macro defines additional names + for hard registers, thus allowing the `asm' option in declarations + to refer to registers using alternate names. + +`ASM_OUTPUT_OPCODE (STREAM, PTR)' + Define this macro if you are using an unusual assembler that + requires different names for the machine instructions. + + The definition is a C statement or statements which output an + assembler instruction opcode to the stdio stream STREAM. The + macro-operand PTR is a variable of type `char *' which points to + the opcode name in its "internal" form--the form that is written + in the machine description. The definition should output the + opcode name to STREAM, performing any translation you desire, and + increment the variable PTR to point at the end of the opcode so + that it will not be output twice. + + In fact, your macro definition may process less than the entire + opcode name, or more than the opcode name; but if you want to + process text that includes `%'-sequences to substitute operands, + you must take care of the substitution yourself. Just be sure to + increment PTR over whatever text should not be output normally. + + If you need to look at the operand values, they can be found as the + elements of `recog_operand'. + + If the macro definition does nothing, the instruction is output in + the usual way. + +`FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)' + If defined, a C statement to be executed just prior to the output + of assembler code for INSN, to modify the extracted operands so + they will be output differently. + + Here the argument OPVEC is the vector containing the operands + extracted from INSN, and NOPERANDS is the number of elements of + the vector which contain meaningful data for this insn. The + contents of this vector are what will be used to convert the insn + template into assembler code, so you can change the assembler + output by changing the contents of the vector. + + This macro is useful when various assembler syntaxes share a single + file of instruction patterns; by defining this macro differently, + you can cause a large class of instructions to be output + differently (such as with rearranged operands). Naturally, + variations in assembler syntax affecting individual insn patterns + ought to be handled by writing conditional output routines in + those patterns. + + If this macro is not defined, it is equivalent to a null statement. + +`PRINT_OPERAND (STREAM, X, CODE)' + A C compound statement to output to stdio stream STREAM the + assembler syntax for an instruction operand X. X is an RTL + expression. + + CODE is a value that can be used to specify one of several ways of + printing the operand. It is used when identical operands must be + printed differently depending on the context. CODE comes from the + `%' specification that was used to request printing of the + operand. If the specification was just `%DIGIT' then CODE is 0; + if the specification was `%LTR DIGIT' then CODE is the ASCII code + for LTR. + + If X is a register, this macro should print the register's name. + The names can be found in an array `reg_names' whose type is `char + *[]'. `reg_names' is initialized from `REGISTER_NAMES'. + + When the machine description has a specification `%PUNCT' (a `%' + followed by a punctuation character), this macro is called with a + null pointer for X and the punctuation character for CODE. + +`PRINT_OPERAND_PUNCT_VALID_P (CODE)' + A C expression which evaluates to true if CODE is a valid + punctuation character for use in the `PRINT_OPERAND' macro. If + `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no + punctuation characters (except for the standard one, `%') are used + in this way. + +`PRINT_OPERAND_ADDRESS (STREAM, X)' + A C compound statement to output to stdio stream STREAM the + assembler syntax for an instruction operand that is a memory + reference whose address is X. X is an RTL expression. + + On some machines, the syntax for a symbolic address depends on the + section that the address refers to. On these machines, define the + macro `ENCODE_SECTION_INFO' to store the information into the + `symbol_ref', and then check for it here. *Note Assembler + Format::. + +`DBR_OUTPUT_SEQEND(FILE)' + A C statement, to be executed after all slot-filler instructions + have been output. If necessary, call `dbr_sequence_length' to + determine the number of slots filled in a sequence (zero if not + currently outputting a sequence), to decide how many no-ops to + output, or whatever. + + Don't define this macro if it has nothing to do, but it is helpful + in reading assembly output if the extent of the delay sequence is + made explicit (e.g. with white space). + + Note that output routines for instructions with delay slots must be + prepared to deal with not being output as part of a sequence (i.e. + when the scheduling pass is not run, or when no slot fillers could + be found.) The variable `final_sequence' is null when not + processing a sequence, otherwise it contains the `sequence' rtx + being output. + +`REGISTER_PREFIX' +`LOCAL_LABEL_PREFIX' +`USER_LABEL_PREFIX' +`IMMEDIATE_PREFIX' + If defined, C string expressions to be used for the `%R', `%L', + `%U', and `%I' options of `asm_fprintf' (see `final.c'). These + are useful when a single `md' file must support multiple assembler + formats. In that case, the various `tm.h' files can define these + macros differently. + +`ASSEMBLER_DIALECT' + If your target supports multiple dialects of assembler language + (such as different opcodes), define this macro as a C expression + that gives the numeric index of the assembler language dialect to + use, with zero as the first variant. + + If this macro is defined, you may use + `{option0|option1|option2...}' constructs in the output templates + of patterns (*note Output Template::.) or in the first argument of + `asm_fprintf'. This construct outputs `option0', `option1' or + `option2', etc., if the value of `ASSEMBLER_DIALECT' is zero, one + or two, etc. Any special characters within these strings retain + their usual meaning. + + If you do not define this macro, the characters `{', `|' and `}' + do not have any special meaning when used in templates or operands + to `asm_fprintf'. + + Define the macros `REGISTER_PREFIX', `LOCAL_LABEL_PREFIX', + `USER_LABEL_PREFIX' and `IMMEDIATE_PREFIX' if you can express the + variations in assemble language syntax with that mechanism. Define + `ASSEMBLER_DIALECT' and use the `{option0|option1}' syntax if the + syntax variant are larger and involve such things as different + opcodes or operand order. + +`ASM_OUTPUT_REG_PUSH (STREAM, REGNO)' + A C expression to output to STREAM some assembler code which will + push hard register number REGNO onto the stack. The code need not + be optimal, since this macro is used only when profiling. + +`ASM_OUTPUT_REG_POP (STREAM, REGNO)' + A C expression to output to STREAM some assembler code which will + pop hard register number REGNO off of the stack. The code need + not be optimal, since this macro is used only when profiling. + + +File: gcc.info, Node: Dispatch Tables, Next: Alignment Output, Prev: Instruction Output, Up: Assembler Format + +Output of Dispatch Tables +------------------------- + + This concerns dispatch tables. + +`ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)' + This macro should be provided on machines where the addresses in a + dispatch table are relative to the table's own address. + + The definition should be a C statement to output to the stdio + stream STREAM an assembler pseudo-instruction to generate a + difference between two labels. VALUE and REL are the numbers of + two internal labels. The definitions of these labels are output + using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the + same way here. For example, + + fprintf (STREAM, "\t.word L%d-L%d\n", + VALUE, REL) + +`ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)' + This macro should be provided on machines where the addresses in a + dispatch table are absolute. + + The definition should be a C statement to output to the stdio + stream STREAM an assembler pseudo-instruction to generate a + reference to a label. VALUE is the number of an internal label + whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. For + example, + + fprintf (STREAM, "\t.word L%d\n", VALUE) + +`ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)' + Define this if the label before a jump-table needs to be output + specially. The first three arguments are the same as for + `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table + which follows (a `jump_insn' containing an `addr_vec' or + `addr_diff_vec'). + + This feature is used on system V to output a `swbeg' statement for + the table. + + If this macro is not defined, these labels are output with + `ASM_OUTPUT_INTERNAL_LABEL'. + +`ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)' + Define this if something special must be output at the end of a + jump-table. The definition should be a C statement to be executed + after the assembler code for the table is written. It should write + the appropriate code to stdio stream STREAM. The argument TABLE + is the jump-table insn, and NUM is the label-number of the + preceding label. + + If this macro is not defined, nothing special is output at the end + of the jump-table. + + +File: gcc.info, Node: Alignment Output, Prev: Dispatch Tables, Up: Assembler Format + +Assembler Commands for Alignment +-------------------------------- + + This describes commands for alignment. + +`ASM_OUTPUT_ALIGN_CODE (FILE)' + A C expression to output text to align the location counter in the + way that is desirable at a point in the code that is reached only + by jumping. + + This macro need not be defined if you don't want any special + alignment to be done at such a time. Most machine descriptions do + not currently define the macro. + +`ASM_OUTPUT_LOOP_ALIGN (FILE)' + A C expression to output text to align the location counter in the + way that is desirable at the beginning of a loop. + + This macro need not be defined if you don't want any special + alignment to be done at such a time. Most machine descriptions do + not currently define the macro. + +`ASM_OUTPUT_SKIP (STREAM, NBYTES)' + A C statement to output to the stdio stream STREAM an assembler + instruction to advance the location counter by NBYTES bytes. + Those bytes should be zero when loaded. NBYTES will be a C + expression of type `int'. + +`ASM_NO_SKIP_IN_TEXT' + Define this macro if `ASM_OUTPUT_SKIP' should not be used in the + text section because it fails put zeros in the bytes that are + skipped. This is true on many Unix systems, where the pseudo-op + to skip bytes produces no-op instructions rather than zeros when + used in the text section. + +`ASM_OUTPUT_ALIGN (STREAM, POWER)' + A C statement to output to the stdio stream STREAM an assembler + command to advance the location counter to a multiple of 2 to the + POWER bytes. POWER will be a C expression of type `int'. + + +File: gcc.info, Node: Debugging Info, Next: Cross-compilation, Prev: Assembler Format, Up: Target Macros + +Controlling Debugging Information Format +======================================== + + This describes how to specify debugging information. + +* Menu: + +* All Debuggers:: Macros that affect all debugging formats uniformly. +* DBX Options:: Macros enabling specific options in DBX format. +* DBX Hooks:: Hook macros for varying DBX format. +* File Names and DBX:: Macros controlling output of file names in DBX format. +* SDB and DWARF:: Macros for SDB (COFF) and DWARF formats. + + +File: gcc.info, Node: All Debuggers, Next: DBX Options, Up: Debugging Info + +Macros Affecting All Debugging Formats +-------------------------------------- + + These macros affect all debugging formats. + +`DBX_REGISTER_NUMBER (REGNO)' + A C expression that returns the DBX register number for the + compiler register number REGNO. In simple cases, the value of this + expression may be REGNO itself. But sometimes there are some + registers that the compiler knows about and DBX does not, or vice + versa. In such cases, some register may need to have one number in + the compiler and another for DBX. + + If two registers have consecutive numbers inside GNU CC, and they + can be used as a pair to hold a multiword value, then they *must* + have consecutive numbers after renumbering with + `DBX_REGISTER_NUMBER'. Otherwise, debuggers will be unable to + access such a pair, because they expect register pairs to be + consecutive in their own numbering scheme. + + If you find yourself defining `DBX_REGISTER_NUMBER' in way that + does not preserve register pairs, then what you must do instead is + redefine the actual register numbering scheme. + +`DEBUGGER_AUTO_OFFSET (X)' + A C expression that returns the integer offset value for an + automatic variable having address X (an RTL expression). The + default computation assumes that X is based on the frame-pointer + and gives the offset from the frame-pointer. This is required for + targets that produce debugging output for DBX or COFF-style + debugging output for SDB and allow the frame-pointer to be + eliminated when the `-g' options is used. + +`DEBUGGER_ARG_OFFSET (OFFSET, X)' + A C expression that returns the integer offset value for an + argument having address X (an RTL expression). The nominal offset + is OFFSET. + +`PREFERRED_DEBUGGING_TYPE' + A C expression that returns the type of debugging output GNU CC + produces when the user specifies `-g' or `-ggdb'. Define this if + you have arranged for GNU CC to support more than one format of + debugging output. Currently, the allowable values are `DBX_DEBUG', + `SDB_DEBUG', `DWARF_DEBUG', and `XCOFF_DEBUG'. + + The value of this macro only affects the default debugging output; + the user can always get a specific type of output by using + `-gstabs', `-gcoff', `-gdwarf', or `-gxcoff'. + + +File: gcc.info, Node: DBX Options, Next: DBX Hooks, Prev: All Debuggers, Up: Debugging Info + +Specific Options for DBX Output +------------------------------- + + These are specific options for DBX output. + +`DBX_DEBUGGING_INFO' + Define this macro if GNU CC should produce debugging output for DBX + in response to the `-g' option. + +`XCOFF_DEBUGGING_INFO' + Define this macro if GNU CC should produce XCOFF format debugging + output in response to the `-g' option. This is a variant of DBX + format. + +`DEFAULT_GDB_EXTENSIONS' + Define this macro to control whether GNU CC should by default + generate GDB's extended version of DBX debugging information + (assuming DBX-format debugging information is enabled at all). If + you don't define the macro, the default is 1: always generate the + extended information if there is any occasion to. + +`DEBUG_SYMS_TEXT' + Define this macro if all `.stabs' commands should be output while + in the text section. + +`ASM_STABS_OP' + A C string constant naming the assembler pseudo op to use instead + of `.stabs' to define an ordinary debugging symbol. If you don't + define this macro, `.stabs' is used. This macro applies only to + DBX debugging information format. + +`ASM_STABD_OP' + A C string constant naming the assembler pseudo op to use instead + of `.stabd' to define a debugging symbol whose value is the current + location. If you don't define this macro, `.stabd' is used. This + macro applies only to DBX debugging information format. + +`ASM_STABN_OP' + A C string constant naming the assembler pseudo op to use instead + of `.stabn' to define a debugging symbol with no name. If you + don't define this macro, `.stabn' is used. This macro applies + only to DBX debugging information format. + +`DBX_NO_XREFS' + Define this macro if DBX on your system does not support the + construct `xsTAGNAME'. On some systems, this construct is used to + describe a forward reference to a structure named TAGNAME. On + other systems, this construct is not supported at all. + +`DBX_CONTIN_LENGTH' + A symbol name in DBX-format debugging information is normally + continued (split into two separate `.stabs' directives) when it + exceeds a certain length (by default, 80 characters). On some + operating systems, DBX requires this splitting; on others, + splitting must not be done. You can inhibit splitting by defining + this macro with the value zero. You can override the default + splitting-length by defining this macro as an expression for the + length you desire. + +`DBX_CONTIN_CHAR' + Normally continuation is indicated by adding a `\' character to + the end of a `.stabs' string when a continuation follows. To use + a different character instead, define this macro as a character + constant for the character you want to use. Do not define this + macro if backslash is correct for your system. + +`DBX_STATIC_STAB_DATA_SECTION' + Define this macro if it is necessary to go to the data section + before outputting the `.stabs' pseudo-op for a non-global static + variable. + +`DBX_TYPE_DECL_STABS_CODE' + The value to use in the "code" field of the `.stabs' directive for + a typedef. The default is `N_LSYM'. + +`DBX_STATIC_CONST_VAR_CODE' + The value to use in the "code" field of the `.stabs' directive for + a static variable located in the text section. DBX format does not + provide any "right" way to do this. The default is `N_FUN'. + +`DBX_REGPARM_STABS_CODE' + The value to use in the "code" field of the `.stabs' directive for + a parameter passed in registers. DBX format does not provide any + "right" way to do this. The default is `N_RSYM'. + +`DBX_REGPARM_STABS_LETTER' + The letter to use in DBX symbol data to identify a symbol as a + parameter passed in registers. DBX format does not customarily + provide any way to do this. The default is `'P''. + +`DBX_MEMPARM_STABS_LETTER' + The letter to use in DBX symbol data to identify a symbol as a + stack parameter. The default is `'p''. + +`DBX_FUNCTION_FIRST' + Define this macro if the DBX information for a function and its + arguments should precede the assembler code for the function. + Normally, in DBX format, the debugging information entirely + follows the assembler code. + +`DBX_LBRAC_FIRST' + Define this macro if the `N_LBRAC' symbol for a block should + precede the debugging information for variables and functions + defined in that block. Normally, in DBX format, the `N_LBRAC' + symbol comes first. + +`DBX_BLOCKS_FUNCTION_RELATIVE' + Define this macro if the value of a symbol describing the scope of + a block (`N_LBRAC' or `N_RBRAC') should be relative to the start + of the enclosing function. Normally, GNU C uses an absolute + address. + + +File: gcc.info, Node: DBX Hooks, Next: File Names and DBX, Prev: DBX Options, Up: Debugging Info + +Open-Ended Hooks for DBX Format +------------------------------- + + These are hooks for DBX format. + +`DBX_OUTPUT_LBRAC (STREAM, NAME)' + Define this macro to say how to output to STREAM the debugging + information for the start of a scope level for variable names. The + argument NAME is the name of an assembler symbol (for use with + `assemble_name') whose value is the address where the scope begins. + +`DBX_OUTPUT_RBRAC (STREAM, NAME)' + Like `DBX_OUTPUT_LBRAC', but for the end of a scope level. + +`DBX_OUTPUT_ENUM (STREAM, TYPE)' + Define this macro if the target machine requires special handling + to output an enumeration type. The definition should be a C + statement (sans semicolon) to output the appropriate information + to STREAM for the type TYPE. + +`DBX_OUTPUT_FUNCTION_END (STREAM, FUNCTION)' + Define this macro if the target machine requires special output at + the end of the debugging information for a function. The + definition should be a C statement (sans semicolon) to output the + appropriate information to STREAM. FUNCTION is the + `FUNCTION_DECL' node for the function. + +`DBX_OUTPUT_STANDARD_TYPES (SYMS)' + Define this macro if you need to control the order of output of the + standard data types at the beginning of compilation. The argument + SYMS is a `tree' which is a chain of all the predefined global + symbols, including names of data types. + + Normally, DBX output starts with definitions of the types for + integers and characters, followed by all the other predefined + types of the particular language in no particular order. + + On some machines, it is necessary to output different particular + types first. To do this, define `DBX_OUTPUT_STANDARD_TYPES' to + output those symbols in the necessary order. Any predefined types + that you don't explicitly output will be output afterward in no + particular order. + + Be careful not to define this macro so that it works only for C. + There are no global variables to access most of the built-in + types, because another language may have another set of types. + The way to output a particular type is to look through SYMS to see + if you can find it. Here is an example: + + { + tree decl; + for (decl = syms; decl; decl = TREE_CHAIN (decl)) + if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), + "long int")) + dbxout_symbol (decl); + ... + } + + This does nothing if the expected type does not exist. + + See the function `init_decl_processing' in `c-decl.c' to find the + names to use for all the built-in C types. + + Here is another way of finding a particular type: + + { + tree decl; + for (decl = syms; decl; decl = TREE_CHAIN (decl)) + if (TREE_CODE (decl) == TYPE_DECL + && (TREE_CODE (TREE_TYPE (decl)) + == INTEGER_CST) + && TYPE_PRECISION (TREE_TYPE (decl)) == 16 + && TYPE_UNSIGNED (TREE_TYPE (decl))) + /* This must be `unsigned short'. */ + dbxout_symbol (decl); + ... + } + + +File: gcc.info, Node: File Names and DBX, Next: SDB and DWARF, Prev: DBX Hooks, Up: Debugging Info + +File Names in DBX Format +------------------------ + + This describes file names in DBX format. + +`DBX_WORKING_DIRECTORY' + Define this if DBX wants to have the current directory recorded in + each object file. + + Note that the working directory is always recorded if GDB + extensions are enabled. + +`DBX_OUTPUT_MAIN_SOURCE_FILENAME (STREAM, NAME)' + A C statement to output DBX debugging information to the stdio + stream STREAM which indicates that file NAME is the main source + file--the file specified as the input file for compilation. This + macro is called only once, at the beginning of compilation. + + This macro need not be defined if the standard form of output for + DBX debugging information is appropriate. + +`DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (STREAM, NAME)' + A C statement to output DBX debugging information to the stdio + stream STREAM which indicates that the current directory during + compilation is named NAME. + + This macro need not be defined if the standard form of output for + DBX debugging information is appropriate. + +`DBX_OUTPUT_MAIN_SOURCE_FILE_END (STREAM, NAME)' + A C statement to output DBX debugging information at the end of + compilation of the main source file NAME. + + If you don't define this macro, nothing special is output at the + end of compilation, which is correct for most machines. + +`DBX_OUTPUT_SOURCE_FILENAME (STREAM, NAME)' + A C statement to output DBX debugging information to the stdio + stream STREAM which indicates that file NAME is the current source + file. This output is generated each time input shifts to a + different source file as a result of `#include', the end of an + included file, or a `#line' command. + + This macro need not be defined if the standard form of output for + DBX debugging information is appropriate. + + +File: gcc.info, Node: SDB and DWARF, Prev: File Names and DBX, Up: Debugging Info + +Macros for SDB and DWARF Output +------------------------------- + + Here are macros for SDB and DWARF output. + +`SDB_DEBUGGING_INFO' + Define this macro if GNU CC should produce COFF-style debugging + output for SDB in response to the `-g' option. + +`DWARF_DEBUGGING_INFO' + Define this macro if GNU CC should produce dwarf format debugging + output in response to the `-g' option. + +`PUT_SDB_...' + Define these macros to override the assembler syntax for the + special SDB assembler directives. See `sdbout.c' for a list of + these macros and their arguments. If the standard syntax is used, + you need not define them yourself. + +`SDB_DELIM' + Some assemblers do not support a semicolon as a delimiter, even + between SDB assembler directives. In that case, define this macro + to be the delimiter to use (usually `\n'). It is not necessary to + define a new set of `PUT_SDB_OP' macros if this is the only change + required. + +`SDB_GENERATE_FAKE' + Define this macro to override the usual method of constructing a + dummy name for anonymous structure and union types. See + `sdbout.c' for more information. + +`SDB_ALLOW_UNKNOWN_REFERENCES' + Define this macro to allow references to unknown structure, union, + or enumeration tags to be emitted. Standard COFF does not allow + handling of unknown references, MIPS ECOFF has support for it. + +`SDB_ALLOW_FORWARD_REFERENCES' + Define this macro to allow references to structure, union, or + enumeration tags that have not yet been seen to be handled. Some + assemblers choke if forward tags are used, while some require it.