GNU Info
(gcc-295.info)Instruction Output
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.
`FINAL_PRESCAN_LABEL'
If defined, `FINAL_PRESCAN_INSN' will be called on each
`CODE_LABEL'. In that case, OPVEC will be a null pointer and
NOPERANDS will be zero.
`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 constructs of the form
`{option0|option1|option2...}' 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 assembler 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.
automatically generated by info2www version 1.2.2.9