GNU Info
(gcc-295.info)Data Output
Output of Data
--------------
This describes data output.
`ASM_OUTPUT_LONG_DOUBLE (STREAM, VALUE)'
`ASM_OUTPUT_DOUBLE (STREAM, VALUE)'
`ASM_OUTPUT_FLOAT (STREAM, VALUE)'
`ASM_OUTPUT_THREE_QUARTER_FLOAT (STREAM, VALUE)'
`ASM_OUTPUT_SHORT_FLOAT (STREAM, VALUE)'
`ASM_OUTPUT_BYTE_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', `SFmode', `TQFmode', `HFmode', or `QFmode',
respectively, whose value is VALUE. VALUE will be a C expression
of type `REAL_VALUE_TYPE'. Macros such as
`REAL_VALUE_TO_TARGET_DOUBLE' are useful for writing these
definitions.
`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'.
`CONSTANT_POOL_BEFORE_FUNCTION'
You may define this macro as a C expression. You should define the
expression to have a non-zero value if GNU CC should output the
constant pool for a function before the code for the function, or
a zero value if GNU CC should output the constant pool after the
function. If you do not define this macro, the usual case, GNU CC
will output the constant pool before the function.
`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.
`CONSTANT_AFTER_FUNCTION_P (EXP)'
Define this macro as a C expression which is nonzero if the
constant EXP, of type `tree', should be output after the code for a
function. The compiler will normally output all constants before
the function; you need not define this macro if this is OK.
`ASM_OUTPUT_POOL_EPILOGUE (FILE FUNNAME FUNDECL SIZE)'
A C statement to output assembler commands to at the end 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, you can obtain it via FUNDECL. SIZE is the size, in
bytes, of the constant pool that GNU CC wrote immediately before
this call.
If no constant-pool epilogue is required, the usual case, you need
not define this macro.
`IS_ASM_LOGICAL_LINE_SEPARATOR (C)'
Define this macro as a C expression which is nonzero if C is used
as a logical line separator by the assembler.
If you do not define this macro, the default is that only the
character `;' is treated as a logical line separator.
`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 ")"
These macros are provided by `real.h' for writing the definitions of
`ASM_OUTPUT_DOUBLE' and the like:
`REAL_VALUE_TO_TARGET_SINGLE (X, L)'
`REAL_VALUE_TO_TARGET_DOUBLE (X, L)'
`REAL_VALUE_TO_TARGET_LONG_DOUBLE (X, L)'
These translate X, of type `REAL_VALUE_TYPE', to the target's
floating point representation, and store its bit pattern in the
array of `long int' whose address is L. The number of elements in
the output array is determined by the size of the desired target
floating point data type: 32 bits of it go in each `long int' array
element. Each array element holds 32 bits of the result, even if
`long int' is wider than 32 bits on the host machine.
The array element values are designed so that you can print them
out using `fprintf' in the order they should appear in the target
machine's memory.
`REAL_VALUE_TO_DECIMAL (X, FORMAT, STRING)'
This macro converts X, of type `REAL_VALUE_TYPE', to a decimal
number and stores it as a string into STRING. You must pass, as
STRING, the address of a long enough block of space to hold the
result.
The argument FORMAT is a `printf'-specification that serves as a
suggestion for how to format the output string.
automatically generated by info2www version 1.2.2.9