Using and Porting GNU CC

16.16.2: Output of Data

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.

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.

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.