V10/cmd/gcc/internals-7
File: internals, Node: Assembler Format, Prev: Condition Code, Up: Machine Macros
Output of Assembler Code
========================
`ASM_SPEC'
A C string constant that tells the GNU CC driver program options to
pass to the assembler. It can also specify how to translate options
you give to GNU CC into options for GNU CC to pass to the assembler.
See the file `tm-sun3.h' for an example of this.
Do not define this macro if it does not need to do anything.
`LINK_SPEC'
A C string constant that tells the GNU CC driver program options to
pass to the linker. It can also specify how to translate options you
give to GNU CC into options for GNU CC to pass to the linker.
Do not define this macro if it does not need to do anything.
`ASM_FILE_START'
A C string constant for text to be output at the start of each
assembler output file. Normally this is `"#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.
`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.
`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.
`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.
`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.
`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.
`ASM_OUTPUT_LABEL (FILE, NAME)'
A C statement (sans semicolon) to output to the stdio stream FILE the
assembler definition of a label named NAME. Use the expression
`assemble_name (FILE, 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 (FILE, NAME)'
A C statement (sans semicolon) to output to the stdio stream FILE any
text necessary for declaring the name of a function which is being
defined. This macro is responsible for outputting the label
definition (perhaps using `ASM_OUTPUT_LABEL').
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_GLOBALIZE_LABEL (FILE, NAME)'
A C statement (sans semicolon) to output to the stdio stream FILE some
commands that will make the label NAME global; that is, available for
reference from other files. Use the expression `assemble_name (FILE,
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 (FILE, NAME)'
A C statement (sans semicolon) to output to the stdio stream FILE any
text necessary for declaring the name of an external symbol which is
referenced in this compilation but not defined.
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 (FILE, NAME)'
A C statement to output to the stdio stream FILE a reference in
assembler syntax to a label named NAME. The character `_' should be
added 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 (FILE, PREFIX, NUM)'
A C statement to output to the stdio stream FILE a label whose name is
made from the string PREFIX and the number NUM. These labels are used
for internal purposes, and there is no reason for them to appear in
the symbol table of the object file. On many systems, the letter `L'
at the beginning of a label has this effect. The usual definition of
this macro is as follows:
fprintf (FILE, "L%s%d:\n", PREFIX, NUM)
`ASM_OUTPUT_CASE_LABEL (FILE, 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_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.
`ASM_OUTPUT_ADDR_DIFF_ELT (FILE, 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
FILE 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 (FILE, "\t.word L%d-L%d\n",
VALUE, REL)
`ASM_OUTPUT_ADDR_VEC_ELT (FILE, 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
FILE 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 (FILE, "\t.word L%d\n", VALUE)
`ASM_OUTPUT_DOUBLE (FILE, VALUE)'
A C statement to output to the stdio stream FILE an assembler
instruction to assemble a `double' constant whose value is VALUE.
VALUE will be a C expression of type `double'.
`ASM_OUTPUT_FLOAT (FILE, VALUE)'
A C statement to output to the stdio stream FILE an assembler
instruction to assemble a `float' constant whose value is VALUE.
VALUE will be a C expression of type `float'.
`ASM_OUTPUT_INT (FILE, EXP)'
`ASM_OUTPUT_SHORT (FILE, EXP)'
`ASM_OUTPUT_CHAR (FILE, EXP)'
A C statement to output to the stdio stream FILE an assembler
instruction to assemble a `int', `short' or `char' constant whose
value is VALUE. The argument EXP will be an RTL expression which
represents a constant value. Use `output_addr_const (EXP)' to output
this value as an assembler expression.
`ASM_OUTPUT_BYTE (FILE, VALUE)'
A C statement to output to the stdio stream FILE an assembler
instruction to assemble a single byte containing the number VALUE.
`ASM_OUTPUT_ASCII (FILE, PTR, LEN)'
A C statement to output to the stdio stream FILE 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_SKIP (FILE, NBYTES)'
A C statement to output to the stdio stream FILE an assembler
instruction to advance the location counter by NBYTES bytes. NBYTES
will be a C expression of type `int'.
`ASM_OUTPUT_ALIGN (FILE, POWER)'
A C statement to output to the stdio stream FILE an assembler
instruction to advance the location counter to a multiple of 2 to the
POWER bytes. POWER will be a C expression of type `int'.
`ASM_OUTPUT_COMMON (FILE, NAME, SIZE)'
A C statement (sans semicolon) to output to the stdio stream FILE the
assembler definition of a common-label named NAME whose size is SIZE
bytes. Use the expression `assemble_name (FILE, 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_LOCAL (FILE, NAME, SIZE)'
A C statement (sans semicolon) to output to the stdio stream FILE the
assembler definition of a local-common-label named NAME whose size is
SIZE bytes. Use the expression `assemble_name (FILE, 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.
`TARGET_BELL'
A C constant expression for the integer value for escape sequence `\a'.
`TARGET_BS'
`TARGET_TAB'
`TARGET_NEWLINE'
C constant expressions for the integer values for escape sequences
`\b', `\t' and `\n'.
`TARGET_VT'
`TARGET_FF'
`TARGET_CR'
C constant expressions for the integer values for escape sequences
`\v', `\f' and `\r'.
`ASM_OUTPUT_OPCODE (FILE, 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 FILE. 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
FILE, 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 the macro definition does nothing, the instruction is output in the
usual way.
`PRINT_OPERAND (FILE, X, CODE)'
A C compound statement to output to stdio stream FILE 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_ADDRESS (FILE, X)'
A C compound statement to output to stdio stream FILE the assembler
syntax for an instruction operand that is a memory reference whose
address is X. X is an RTL expression.
`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: internals, Node: Config, Prev: Machine Macros, Up: Top
The Configuration File
**********************
The configuration file `config-MACHINE.h' contains macro definitions that
describe the machine and system on which the compiler is running. Most of
the values in it are actually the same on all machines that GNU CC runs on,
so most all configuration files are identical. But there are some macros
that vary:
`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.
Tag Table:
Node: Top1084
Node: Copying2276
Node: Contributors9633
Node: Options11165
Node: Installation36068
Node: VMS Install42638
Node: Trouble44602
Node: Incompatibilities44958
Node: Extensions49707
Node: Statement Exprs51271
Node: Naming Types52721
Node: Typeof53804
Node: Lvalues55502
Node: Conditionals57396
Node: Zero-Length58315
Node: Variable-Length58987
Node: Subscripting61129
Node: Pointer Arith61610
Node: Initializers62102
Node: Constructors62518
Node: Dollar Signs64001
Node: Alignment64297
Node: Inline65610
Node: Extended Asm67488
Node: Asm Labels72522
Node: Bugs73789
Node: Bug Criteria74501
Node: Bug Reporting77281
Node: Portability83698
Node: Interface85455
Node: Passes88262
Node: RTL100724
Node: RTL Objects102547
Node: Accessors105457
Node: Flags108739
Node: Macnusual 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 FILE. 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
FILE, 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 the macro definition does nothing, the instruction is output in the
usual way.
`PRINT_OPERAND (FILE, X, CODE)'
A C compound statement to output to stdio stream FILE the assembler
syntax for an i