1128 lines
50 KiB
Plaintext
1128 lines
50 KiB
Plaintext
This is Info file gcc.info, produced by Makeinfo-1.47 from the input
|
||
file gcc.texi.
|
||
|
||
This file documents the use and the internals of the GNU compiler.
|
||
|
||
Copyright (C) 1988, 1989, 1992 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
|
||
preserved on all copies.
|
||
|
||
Permission is granted to copy and distribute modified versions of
|
||
this manual under the conditions for verbatim copying, provided also
|
||
that the sections entitled "GNU General Public License" and "Boycott"
|
||
are included exactly as in the original, and provided that the entire
|
||
resulting derived work is distributed under the terms of a permission
|
||
notice identical to this one.
|
||
|
||
Permission is granted to copy and distribute translations of this
|
||
manual into another language, under the above conditions for modified
|
||
versions, except that the sections entitled "GNU General Public
|
||
License" and "Boycott", and this permission notice, may be included in
|
||
translations approved by the Free Software Foundation instead of in the
|
||
original English.
|
||
|
||
|
||
File: gcc.info, Node: Costs, Next: Sections, Prev: Condition Code, Up: Target Macros
|
||
|
||
Describing Relative Costs of Operations
|
||
=======================================
|
||
|
||
These macros let you describe the relative speed of various
|
||
operations on the target machine.
|
||
|
||
`CONST_COSTS (X, CODE, OUTER_CODE)'
|
||
A part of a C `switch' statement that describes the relative costs
|
||
of constant RTL expressions. It must contain `case' labels for
|
||
expression codes `const_int', `const', `symbol_ref', `label_ref'
|
||
and `const_double'. Each case must ultimately reach a `return'
|
||
statement to return the relative cost of the use of that kind of
|
||
constant value in an expression. The cost may depend on the
|
||
precise value of the constant, which is available for examination
|
||
in X, and the rtx code of the expression in which it is contained,
|
||
found in OUTER_CODE.
|
||
|
||
CODE is the expression code--redundant, since it can be obtained
|
||
with `GET_CODE (X)'.
|
||
|
||
`RTX_COSTS (X, CODE, OUTER_CODE)'
|
||
Like `CONST_COSTS' but applies to nonconstant RTL expressions.
|
||
This can be used, for example, to indicate how costly a multiply
|
||
instruction is. In writing this macro, you can use the construct
|
||
`COSTS_N_INSNS (N)' to specify a cost equal to N fast
|
||
instructions. OUTER_CODE is the code of the expression in which X
|
||
is contained.
|
||
|
||
This macro is optional; do not define it if the default cost
|
||
assumptions are adequate for the target machine.
|
||
|
||
`ADDRESS_COST (ADDRESS)'
|
||
An expression giving the cost of an addressing mode that contains
|
||
ADDRESS. If not defined, the cost is computed from the ADDRESS
|
||
expression and the `CONST_COSTS' values.
|
||
|
||
For most CISC machines, the default cost is a good approximation
|
||
of the true cost of the addressing mode. However, on RISC
|
||
machines, all instructions normally have the same length and
|
||
execution time. Hence all addresses will have equal costs.
|
||
|
||
In cases where more than one form of an address is known, the form
|
||
with the lowest cost will be used. If multiple forms have the
|
||
same, lowest, cost, the one that is the most complex will be used.
|
||
|
||
For example, suppose an address that is equal to the sum of a
|
||
register and a constant is used twice in the same basic block.
|
||
When this macro is not defined, the address will be computed in a
|
||
register and memory references will be indirect through that
|
||
register. On machines where the cost of the addressing mode
|
||
containing the sum is no higher than that of a simple indirect
|
||
reference, this will produce an additional instruction and
|
||
possibly require an additional register. Proper specification of
|
||
this macro eliminates this overhead for such machines.
|
||
|
||
Similar use of this macro is made in strength reduction of loops.
|
||
|
||
ADDRESS need not be valid as an address. In such a case, the cost
|
||
is not relevant and can be any value; invalid addresses need not be
|
||
assigned a different cost.
|
||
|
||
On machines where an address involving more than one register is as
|
||
cheap as an address computation involving only one register,
|
||
defining `ADDRESS_COST' to reflect this can cause two registers to
|
||
be live over a region of code where only one would have been if
|
||
`ADDRESS_COST' were not defined in that manner. This effect should
|
||
be considered in the definition of this macro. Equivalent costs
|
||
should probably only be given to addresses with different numbers
|
||
of registers on machines with lots of registers.
|
||
|
||
This macro will normally either not be defined or be defined as a
|
||
constant.
|
||
|
||
`REGISTER_MOVE_COST (FROM, TO)'
|
||
A C expression for the cost of moving data from a register in class
|
||
FROM to one in class TO. The classes are expressed using the
|
||
enumeration values such as `GENERAL_REGS'. A value of 2 is the
|
||
default; other values are interpreted relative to that.
|
||
|
||
It is not required that the cost always equal 2 when FROM is the
|
||
same as TO; on some machines it is expensive to move between
|
||
registers if they are not general registers.
|
||
|
||
If reload sees an insn consisting of a single `set' between two
|
||
hard registers, and if `REGISTER_MOVE_COST' applied to their
|
||
classes returns a value of 2, reload does not check to ensure that
|
||
the constraints of the insn are met. Setting a cost of other than
|
||
2 will allow reload to verify that the constraints are met. You
|
||
should do this if the `movM' pattern's constraints do not allow
|
||
such copying.
|
||
|
||
`MEMORY_MOVE_COST (M)'
|
||
A C expression for the cost of moving data of mode M between a
|
||
register and memory. A value of 2 is the default; this cost is
|
||
relative to those in `REGISTER_MOVE_COST'.
|
||
|
||
If moving between registers and memory is more expensive than
|
||
between two registers, you should define this macro to express the
|
||
relative cost.
|
||
|
||
`BRANCH_COST'
|
||
A C expression for the cost of a branch instruction. A value of 1
|
||
is the default; other values are interpreted relative to that.
|
||
|
||
Here are additional macros which do not specify precise relative
|
||
costs, but only that certain actions are more expensive than GNU CC
|
||
would ordinarily expect.
|
||
|
||
`SLOW_BYTE_ACCESS'
|
||
Define this macro as a C expression which is nonzero if accessing
|
||
less than a word of memory (i.e. a `char' or a `short') is no
|
||
faster than accessing a word of memory, i.e., if such access
|
||
require more than one instruction or if there is no difference in
|
||
cost between byte and (aligned) word loads.
|
||
|
||
When this macro is not defined, the compiler will access a field by
|
||
finding the smallest containing object; when it is defined, a
|
||
fullword load will be used if alignment permits. Unless bytes
|
||
accesses are faster than word accesses, using word accesses is
|
||
preferable since it may eliminate subsequent memory access if
|
||
subsequent accesses occur to other fields in the same word of the
|
||
structure, but to different bytes.
|
||
|
||
`SLOW_ZERO_EXTEND'
|
||
Define this macro if zero-extension (of a `char' or `short' to an
|
||
`int') can be done faster if the destination is a register that is
|
||
known to be zero.
|
||
|
||
If you define this macro, you must have instruction patterns that
|
||
recognize RTL structures like this:
|
||
|
||
(set (strict_low_part (subreg:QI (reg:SI ...) 0)) ...)
|
||
|
||
and likewise for `HImode'.
|
||
|
||
`SLOW_UNALIGNED_ACCESS'
|
||
Define this macro to be the value 1 if unaligned accesses have a
|
||
cost many times greater than aligned accesses, for example if they
|
||
are emulated in a trap handler.
|
||
|
||
When this macro is non-zero, the compiler will act as if
|
||
`STRICT_ALIGNMENT' were non-zero when generating code for block
|
||
moves. This can cause significantly more instructions to be
|
||
produced. Therefore, do not set this macro non-zero if unaligned
|
||
accesses only add a cycle or two to the time for a memory access.
|
||
|
||
If the value of this macro is always zero, it need not be defined.
|
||
|
||
`DONT_REDUCE_ADDR'
|
||
Define this macro to inhibit strength reduction of memory
|
||
addresses. (On some machines, such strength reduction seems to do
|
||
harm rather than good.)
|
||
|
||
`MOVE_RATIO'
|
||
The number of scalar move insns which should be generated instead
|
||
of a string move insn or a library call. Increasing the value
|
||
will always make code faster, but eventually incurs high cost in
|
||
increased code size.
|
||
|
||
If you don't define this, a reasonable default is used.
|
||
|
||
`NO_FUNCTION_CSE'
|
||
Define this macro if it is as good or better to call a constant
|
||
function address than to call an address kept in a register.
|
||
|
||
`NO_RECURSIVE_FUNCTION_CSE'
|
||
Define this macro if it is as good or better for a function to call
|
||
itself with an explicit address than to call an address kept in a
|
||
register.
|
||
|
||
|
||
File: gcc.info, Node: Sections, Next: PIC, Prev: Costs, Up: Target Macros
|
||
|
||
Dividing the Output into Sections (Texts, Data, ...)
|
||
====================================================
|
||
|
||
An object file is divided into sections containing different types of
|
||
data. In the most common case, there are three sections: the "text
|
||
section", which holds instructions and read-only data; the "data
|
||
section", which holds initialized writable data; and the "bss section",
|
||
which holds uninitialized data. Some systems have other kinds of
|
||
sections.
|
||
|
||
The compiler must tell the assembler when to switch sections. These
|
||
macros control what commands to output to tell the assembler this. You
|
||
can also define additional sections.
|
||
|
||
`TEXT_SECTION_ASM_OP'
|
||
A C string constant for the assembler operation that should precede
|
||
instructions and read-only data. Normally `".text"' is right.
|
||
|
||
`DATA_SECTION_ASM_OP'
|
||
A C string constant for the assembler operation to identify the
|
||
following data as writable initialized data. Normally `".data"'
|
||
is right.
|
||
|
||
`SHARED_SECTION_ASM_OP'
|
||
If defined, a C string constant for the assembler operation to
|
||
identify the following data as shared data. If not defined,
|
||
`DATA_SECTION_ASM_OP' will be used.
|
||
|
||
`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.
|
||
|
||
`EXTRA_SECTIONS'
|
||
A list of names for sections other than the standard two, which are
|
||
`in_text' and `in_data'. You need not define this macro on a
|
||
system with no other sections (that GCC needs to use).
|
||
|
||
`EXTRA_SECTION_FUNCTIONS'
|
||
One or more functions to be defined in `varasm.c'. These
|
||
functions should do jobs analogous to those of `text_section' and
|
||
`data_section', for your additional sections. Do not define this
|
||
macro if you do not define `EXTRA_SECTIONS'.
|
||
|
||
`READONLY_DATA_SECTION'
|
||
On most machines, read-only variables, constants, and jump tables
|
||
are placed in the text section. If this is not the case on your
|
||
machine, this macro should be defined to be the name of a function
|
||
(either `data_section' or a function defined in `EXTRA_SECTIONS')
|
||
that switches to the section to be used for read-only items.
|
||
|
||
If these items should be placed in the text section, this macro
|
||
should not be defined.
|
||
|
||
`SELECT_SECTION (EXP, RELOC)'
|
||
A C statement or statements to switch to the appropriate section
|
||
for output of EXP. You can assume that EXP is either a `VAR_DECL'
|
||
node or a constant of some sort. RELOC indicates whether the
|
||
initial value of EXP requires link-time relocations. Select the
|
||
section by calling `text_section' or one of the alternatives for
|
||
other sections.
|
||
|
||
Do not define this macro if you put all read-only variables and
|
||
constants in the read-only data section (usually the text section).
|
||
|
||
`SELECT_RTX_SECTION (MODE, RTX)'
|
||
A C statement or statements to switch to the appropriate section
|
||
for output of RTX in mode MODE. You can assume that RTX is some
|
||
kind of constant in RTL. The argument MODE is redundant except in
|
||
the case of a `const_int' rtx. Select the section by calling
|
||
`text_section' or one of the alternatives for other sections.
|
||
|
||
Do not define this macro if you put all constants in the read-only
|
||
data section.
|
||
|
||
`JUMP_TABLES_IN_TEXT_SECTION'
|
||
Define this macro if jump tables (for `tablejump' insns) should be
|
||
output in the text section, along with the assembler instructions.
|
||
Otherwise, the readonly data section is used.
|
||
|
||
This macro is irrelevant if there is no separate readonly data
|
||
section.
|
||
|
||
`ENCODE_SECTION_INFO (DECL)'
|
||
Define this macro if references to a symbol must be treated
|
||
differently depending on something about the variable or function
|
||
named by the symbol (such as what section it is in).
|
||
|
||
The macro definition, if any, is executed immediately after the
|
||
rtl for DECL has been created and stored in `DECL_RTL (DECL)'. The
|
||
value of the rtl will be a `mem' whose address is a `symbol_ref'.
|
||
|
||
The usual thing for this macro to do is to record a flag in the
|
||
`symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified
|
||
name string in the `symbol_ref' (if one bit is not enough
|
||
information).
|
||
|
||
|
||
File: gcc.info, Node: PIC, Next: Assembler Format, Prev: Sections, Up: Target Macros
|
||
|
||
Position Independent Code
|
||
=========================
|
||
|
||
This section describes macros that help implement generation of
|
||
position independent code. Simply defining these macros is not enough
|
||
to generate valid PIC; you must also add support to the macros
|
||
`GO_IF_LEGITIMATE_ADDRESS' and `LEGITIMIZE_ADDRESS', and
|
||
`PRINT_OPERAND_ADDRESS' as well. You must modify the definition of
|
||
`movsi' to do something appropriate when the source operand contains a
|
||
symbolic address. You may also need to alter the handling of switch
|
||
statements so that they use relative addresses.
|
||
|
||
`PIC_OFFSET_TABLE_REGNUM'
|
||
The register number of the register used to address a table of
|
||
static data addresses in memory. In some cases this register is
|
||
defined by a processor's "application binary interface" (ABI).
|
||
When this macro is defined, RTL is generated for this register
|
||
once, as with the stack pointer and frame pointer registers. If
|
||
this macro is not defined, it is up to the machine-dependent files
|
||
to allocate such a register (if necessary).
|
||
|
||
`FINALIZE_PIC'
|
||
By generating position-independent code, when two different
|
||
programs (A and B) share a common library (libC.a), the text of
|
||
the library can be shared whether or not the library is linked at
|
||
the same address for both programs. In some of these
|
||
environments, position-independent code requires not only the use
|
||
of different addressing modes, but also special code to enable the
|
||
use of these addressing modes.
|
||
|
||
The `FINALIZE_PIC' macro serves as a hook to emit these special
|
||
codes once the function is being compiled into assembly code, but
|
||
not before. (It is not done before, because in the case of
|
||
compiling an inline function, it would lead to multiple PIC
|
||
prologues being included in functions which used inline functions
|
||
and were compiled to assembly language.)
|
||
|
||
|
||
File: gcc.info, Node: Assembler Format, Next: Debugging Info, Prev: PIC, Up: Target Macros
|
||
|
||
Defining the Output Assembler Language
|
||
======================================
|
||
|
||
This section describes macros whose principal purpose is to describe
|
||
how to write instructions in assembler language--rather than what the
|
||
instructions do.
|
||
|
||
* Menu:
|
||
|
||
* File Framework:: Structural information for the assembler file.
|
||
* Data Output:: Output of constants (numbers, strings, addresses).
|
||
* Uninitialized Data:: Output of uninitialized variables.
|
||
* Label Output:: Output and generation of labels.
|
||
* Constructor Output:: Output of initialization and termination routines.
|
||
* Instruction Output:: Output of actual instructions.
|
||
* Dispatch Tables:: Output of jump tables.
|
||
* Alignment Output:: Pseudo ops for alignment and skipping data.
|
||
|
||
|
||
File: gcc.info, Node: File Framework, Next: Data Output, Up: Assembler Format
|
||
|
||
The Overall Framework of an Assembler File
|
||
------------------------------------------
|
||
|
||
`ASM_FILE_START (STREAM)'
|
||
A C expression which outputs to the stdio stream STREAM some
|
||
appropriate text to go at the start of an assembler file.
|
||
|
||
Normally this macro is defined to output a line containing
|
||
`#NO_APP', which is a comment that has no effect on most
|
||
assemblers but tells the GNU assembler that it can save time by not
|
||
checking for certain assembler constructs.
|
||
|
||
On systems that use SDB, it is necessary to output certain
|
||
commands; see `attasm.h'.
|
||
|
||
`ASM_FILE_END (STREAM)'
|
||
A C expression which outputs to the stdio stream STREAM some
|
||
appropriate text to go at the end of an assembler file.
|
||
|
||
If this macro is not defined, the default is to output nothing
|
||
special at the end of the file. Most systems don't require any
|
||
definition.
|
||
|
||
On systems that use SDB, it is necessary to output certain
|
||
commands; see `attasm.h'.
|
||
|
||
`ASM_IDENTIFY_GCC (FILE)'
|
||
A C statement to output assembler commands which will identify the
|
||
object file as having been compiled with GNU CC (or another GNU
|
||
compiler).
|
||
|
||
If you don't define this macro, the string `gcc_compiled.:' is
|
||
output. This string is calculated to define a symbol which, on
|
||
BSD systems, will never be defined for any other reason. GDB
|
||
checks for the presence of this symbol when reading the symbol
|
||
table of an executable.
|
||
|
||
On non-BSD systems, you must arrange communication with GDB in
|
||
some other fashion. If GDB is not used on your system, you can
|
||
define this macro with an empty body.
|
||
|
||
`ASM_COMMENT_START'
|
||
A C string constant describing how to begin a comment in the target
|
||
assembler language. The compiler assumes that the comment will
|
||
end at the end of the line.
|
||
|
||
`ASM_APP_ON'
|
||
A C string constant for text to be output before each `asm'
|
||
statement or group of consecutive ones. Normally this is
|
||
`"#APP"', which is a comment that has no effect on most assemblers
|
||
but tells the GNU assembler that it must check the lines that
|
||
follow for all valid assembler constructs.
|
||
|
||
`ASM_APP_OFF'
|
||
A C string constant for text to be output after each `asm'
|
||
statement or group of consecutive ones. Normally this is
|
||
`"#NO_APP"', which tells the GNU assembler to resume making the
|
||
time-saving assumptions that are valid for ordinary compiler
|
||
output.
|
||
|
||
`ASM_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
|
||
A C statement to output COFF information or DWARF debugging
|
||
information which indicates that filename NAME is the current
|
||
source file to the stdio stream STREAM.
|
||
|
||
This macro need not be defined if the standard form of output for
|
||
the file format in use is appropriate.
|
||
|
||
`ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)'
|
||
A C statement to output DBX or SDB debugging information before
|
||
code for line number LINE of the current source file to the stdio
|
||
stream STREAM.
|
||
|
||
This macro need not be defined if the standard form of debugging
|
||
information for the debugger in use is appropriate.
|
||
|
||
`ASM_OUTPUT_IDENT (STREAM, STRING)'
|
||
A C statement to output something to the assembler file to handle a
|
||
`#ident' directive containing the text STRING. If this macro is
|
||
not defined, nothing is output for a `#ident' directive.
|
||
|
||
`OBJC_PROLOGUE'
|
||
A C statement to output any assembler statements which are
|
||
required to precede any Objective C object definitions or message
|
||
sending. The statement is executed only when compiling an
|
||
Objective C program.
|
||
|
||
|
||
File: gcc.info, Node: Data Output, Next: Uninitialized Data, Prev: File Framework, Up: Assembler Format
|
||
|
||
Output of Data
|
||
--------------
|
||
|
||
`ASM_OUTPUT_LONG_DOUBLE (STREAM, VALUE)'
|
||
`ASM_OUTPUT_DOUBLE (STREAM, VALUE)'
|
||
`ASM_OUTPUT_FLOAT (STREAM, VALUE)'
|
||
A C statement to output to the stdio stream STREAM an assembler
|
||
instruction to assemble a floating-point constant of `TFmode',
|
||
`DFmode' or `SFmode', respectively, whose value is VALUE. VALUE
|
||
will be a C expression of type `REAL_VALUE__TYPE', usually
|
||
`double'.
|
||
|
||
`ASM_OUTPUT_QUADRUPLE_INT (STREAM, EXP)'
|
||
`ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)'
|
||
`ASM_OUTPUT_INT (STREAM, EXP)'
|
||
`ASM_OUTPUT_SHORT (STREAM, EXP)'
|
||
`ASM_OUTPUT_CHAR (STREAM, EXP)'
|
||
A C statement to output to the stdio stream STREAM an assembler
|
||
instruction to assemble an integer of 16, 8, 4, 2 or 1 bytes,
|
||
respectively, whose value is VALUE. The argument EXP will be an
|
||
RTL expression which represents a constant value. Use
|
||
`output_addr_const (STREAM, EXP)' to output this value as an
|
||
assembler expression.
|
||
|
||
For sizes larger than `UNITS_PER_WORD', if the action of a macro
|
||
would be identical to repeatedly calling the macro corresponding to
|
||
a size of `UNITS_PER_WORD', once for each word, you need not define
|
||
the macro.
|
||
|
||
`ASM_OUTPUT_BYTE (STREAM, VALUE)'
|
||
A C statement to output to the stdio stream STREAM an assembler
|
||
instruction to assemble a single byte containing the number VALUE.
|
||
|
||
`ASM_BYTE_OP'
|
||
A C string constant giving the pseudo-op to use for a sequence of
|
||
single-byte constants. If this macro is not defined, the default
|
||
is `"byte"'.
|
||
|
||
`ASM_OUTPUT_ASCII (STREAM, PTR, LEN)'
|
||
A C statement to output to the stdio stream STREAM an assembler
|
||
instruction to assemble a string constant containing the LEN bytes
|
||
at PTR. PTR will be a C expression of type `char *' and LEN a C
|
||
expression of type `int'.
|
||
|
||
If the assembler has a `.ascii' pseudo-op as found in the Berkeley
|
||
Unix assembler, do not define the macro `ASM_OUTPUT_ASCII'.
|
||
|
||
`ASM_OUTPUT_POOL_PROLOGUE (FILE FUNNAME FUNDECL SIZE)'
|
||
A C statement to output assembler commands to define the start of
|
||
the constant pool for a function. FUNNAME is a string giving the
|
||
name of the function. Should the return type of the function be
|
||
required, it can be obtained via FUNDECL. SIZE is the size, in
|
||
bytes, of the constant pool that will be written immediately after
|
||
this call.
|
||
|
||
If no constant-pool prefix is required, the usual case, this macro
|
||
need not be defined.
|
||
|
||
`ASM_OUTPUT_SPECIAL_POOL_ENTRY (FILE, X, MODE, ALIGN, LABELNO, JUMPTO)'
|
||
A C statement (with or without semicolon) to output a constant in
|
||
the constant pool, if it needs special treatment. (This macro
|
||
need not do anything for RTL expressions that can be output
|
||
normally.)
|
||
|
||
The argument FILE is the standard I/O stream to output the
|
||
assembler code on. X is the RTL expression for the constant to
|
||
output, and MODE is the machine mode (in case X is a `const_int').
|
||
ALIGN is the required alignment for the value X; you should
|
||
output an assembler directive to force this much alignment.
|
||
|
||
The argument LABELNO is a number to use in an internal label for
|
||
the address of this pool entry. The definition of this macro is
|
||
responsible for outputting the label definition at the proper
|
||
place. Here is how to do this:
|
||
|
||
ASM_OUTPUT_INTERNAL_LABEL (FILE, "LC", LABELNO);
|
||
|
||
When you output a pool entry specially, you should end with a
|
||
`goto' to the label JUMPTO. This will prevent the same pool entry
|
||
from being output a second time in the usual manner.
|
||
|
||
You need not define this macro if it would do nothing.
|
||
|
||
`ASM_OPEN_PAREN'
|
||
`ASM_CLOSE_PAREN'
|
||
These macros are defined as C string constant, describing the
|
||
syntax in the assembler for grouping arithmetic expressions. The
|
||
following definitions are correct for most assemblers:
|
||
|
||
#define ASM_OPEN_PAREN "("
|
||
#define ASM_CLOSE_PAREN ")"
|
||
|
||
|
||
File: gcc.info, Node: Uninitialized Data, Next: Label Output, Prev: Data Output, Up: Assembler Format
|
||
|
||
Output of Uninitialized Variables
|
||
---------------------------------
|
||
|
||
Each of the macros in this section is used to do the whole job of
|
||
outputting a single uninitialized variable.
|
||
|
||
`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.
|
||
|
||
`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.
|
||
|
||
`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: Constructor Output, Prev: Uninitialized Data, Up: Assembler Format
|
||
|
||
Output and Generation of 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_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_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_LABELREF_AS_INT (FILE, LABEL)'
|
||
Define this macro for systems that use the program `collect2'. The
|
||
definition should be a C statement to output a word containing a
|
||
reference to the label LABEL.
|
||
|
||
`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 same 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.
|
||
|
||
This string will be used as the 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.
|
||
|
||
`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: Constructor Output, Next: Instruction Output, Prev: Label Output, Up: Assembler Format
|
||
|
||
Output of Initialization Routines
|
||
---------------------------------
|
||
|
||
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 what assembler code is
|
||
needed to do this.
|
||
|
||
Here are the two macros you should define if necessary:
|
||
|
||
`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
|
||
`collect' program, which looks through the symbol table to find
|
||
these functions by their names. If you want to use `collect',
|
||
then you need to arrange for it to be built and installed and used
|
||
on your system.
|
||
|
||
`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'.
|
||
|
||
`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'.
|
||
|
||
|
||
File: gcc.info, Node: Instruction Output, Next: Dispatch Tables, Prev: Constructor Output, Up: Assembler Format
|
||
|
||
Output of Assembler Instructions
|
||
--------------------------------
|
||
|
||
`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.
|
||
|
||
`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
|
||
-------------------------
|
||
|
||
`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
|
||
--------------------------------
|
||
|
||
`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
|
||
========================================
|
||
|
||
* 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
|
||
--------------------------------------
|
||
|
||
`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.
|
||
|
||
|