OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

varasm.c (assemble_real): Use REAL_VALUE_TO_x and assemble_integer to emit floating point values.

Browse Source 
* varasm.c (assemble_real): Use REAL_VALUE_TO_x and assemble_integer
	to emit floating point values.
	(assemble_real_1): Remove.

	* 1750a/1750a.c (real_value_to_target_single): New.
	(real_value_to_target_double): New.
	* 1750a/1750a.h (TARGET_FLOAT_FORMAT): New.
	(REAL_VALUE_TO_TARGET_SINGLE): New.
	(REAL_VALUE_TO_TARGET_DOUBLE): New.
	* 1750a/1750a-protos.h: Update.

	* 1750a/1750a.h, a29k/a29k.h, alpha/alpha.h, alpha/unicosmk.h,
	alpha/vms.h, arc/arc.h, arm/aof.h, arm/aout.h, avr/avr.c,
	avr/avr.h, c4x/c4x.h, clipper/clix.h, convex/convex.h, cris/cris.h,
	d30v/d30v.h, dsp16xx/dsp16xx.c, dsp16xx/dsp16xx.h, elxsi/elxsi.h,
	fr30/fr30.h, h8300/h8300.h, i370/i370.h, i386/i386.h, i386/i386elf.h,
	i386/next.h, i386/ptx4-i.h, i386/sysv4.h, i860/fx2800.h, i860/i860.h,
	i860/paragon.h, i860/sysv4.h, i960/i960-protos.h, i960/i960.c,
	i960/i960.h, ia64/ia64.h, m32r/m32r.h, m68hc11/m68hc11.c,
	m68hc11/m68hc11.h, m68k/3b1.h, m68k/altos3068.h, m68k/crds.h,
	m68k/dpx2.h, m68k/hp320.h, m68k/m68k.h, m68k/mot3300.h, m68k/news.h,
	m68k/next.h, m68k/next21.h, m68k/sgs.h, m68k/sun2o4.h, m68k/sun3.h,
	m68k/tower-as.h, m88k/m88k.h, mcore/mcore.h, mips/mips-protos.h,
	mips/mips.c, mips/mips.h, mmix/mmix-protos.h, mmix/mmix.c,
	mmix/mmix.h, mn10200/mn10200.h, mn10300/mn10300.h, ns32k/encore.h,
	ns32k/ns32k.h, pa/long_double.h, pa/pa.h, pdp11/pdp11.h, pj/pj.h,
	romp/romp.c, romp/romp.h, rs6000/rs6000.h, s390/linux.h, sh/sh.h,
	sparc/sparc.h, stormy16/stormy16.h, v850/v850.h, vax/vax.h,
	vax/vaxv.h, we32k/we32k.h, doc/tm.texi: Remove ASM_OUTPUT_FLOAT,
	ASM_OUTPUT_DOUBLE, ASM_OUTPUT_LONG_DOUBLE, ASM_OUTPUT_BYTE_FLOAT,
	ASM_OUTPUT_SHORT_FLOAT, ASM_OUTPUT_THREE_QUARTER_FLOAT, and all
	associated support routines.

From-SVN: r48207
This commit is contained in:
Richard Henderson 2001-12-20 09:36:39 -08:00 committed by Richard Henderson
parent d1ee6d9bb7
commit 82af613ff3
83 changed files with 270 additions and 2039 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
gcc/ChangeLog
View File

@ -1,3 +1,38 @@
2001-12-20 Richard Henderson <rth@redhat.com>
* varasm.c (assemble_real): Use REAL_VALUE_TO_x and assemble_integer
to emit floating point values.
(assemble_real_1): Remove.
* 1750a/1750a.c (real_value_to_target_single): New.
(real_value_to_target_double): New.
* 1750a/1750a.h (TARGET_FLOAT_FORMAT): New.
(REAL_VALUE_TO_TARGET_SINGLE): New.
(REAL_VALUE_TO_TARGET_DOUBLE): New.
* 1750a/1750a-protos.h: Update.
* 1750a/1750a.h, a29k/a29k.h, alpha/alpha.h, alpha/unicosmk.h,
alpha/vms.h, arc/arc.h, arm/aof.h, arm/aout.h, avr/avr.c,
avr/avr.h, c4x/c4x.h, clipper/clix.h, convex/convex.h, cris/cris.h,
d30v/d30v.h, dsp16xx/dsp16xx.c, dsp16xx/dsp16xx.h, elxsi/elxsi.h,
fr30/fr30.h, h8300/h8300.h, i370/i370.h, i386/i386.h, i386/i386elf.h,
i386/next.h, i386/ptx4-i.h, i386/sysv4.h, i860/fx2800.h, i860/i860.h,
i860/paragon.h, i860/sysv4.h, i960/i960-protos.h, i960/i960.c,
i960/i960.h, ia64/ia64.h, m32r/m32r.h, m68hc11/m68hc11.c,
m68hc11/m68hc11.h, m68k/3b1.h, m68k/altos3068.h, m68k/crds.h,
m68k/dpx2.h, m68k/hp320.h, m68k/m68k.h, m68k/mot3300.h, m68k/news.h,
m68k/next.h, m68k/next21.h, m68k/sgs.h, m68k/sun2o4.h, m68k/sun3.h,
m68k/tower-as.h, m88k/m88k.h, mcore/mcore.h, mips/mips-protos.h,
mips/mips.c, mips/mips.h, mmix/mmix-protos.h, mmix/mmix.c,
mmix/mmix.h, mn10200/mn10200.h, mn10300/mn10300.h, ns32k/encore.h,
ns32k/ns32k.h, pa/long_double.h, pa/pa.h, pdp11/pdp11.h, pj/pj.h,
romp/romp.c, romp/romp.h, rs6000/rs6000.h, s390/linux.h, sh/sh.h,
sparc/sparc.h, stormy16/stormy16.h, v850/v850.h, vax/vax.h,
vax/vaxv.h, we32k/we32k.h, doc/tm.texi: Remove ASM_OUTPUT_FLOAT,
ASM_OUTPUT_DOUBLE, ASM_OUTPUT_LONG_DOUBLE, ASM_OUTPUT_BYTE_FLOAT,
ASM_OUTPUT_SHORT_FLOAT, ASM_OUTPUT_THREE_QUARTER_FLOAT, and all
associated support routines.
Thu Dec 20 16:58:46 CET 2001 Jan Hubicka <jh@suse.cz>
* cfgcleanup.c (flow_find_cross_jump): Avoid incrementing of ninsns

3
gcc/config/1750a/1750a-protos.h
View File

@ -43,3 +43,6 @@ extern const char *branch_or_jump PARAMS ((const char *, int));
extern int find_jmplbl PARAMS ((int));
extern int one_bit_set_p PARAMS ((int));
extern void check_section PARAMS ((enum section));
extern long real_value_to_target_single PARAMS((double));
extern void real_value_to_target_double PARAMS((double, long[]));

141
gcc/config/1750a/1750a.c
View File

@ -870,4 +870,145 @@ which_bit (x)
return b;
}
/* Convert a REAL_VALUE_TYPE to the target float format:
MSB LSB MSB LSB
------------------------------------------------------
|S| Mantissa | Exponent |
------------------------------------------------------
0 1 23 24 31
*/
long
real_value_to_target_single(in)
REAL_VALUE_TYPE in;
{
union {
double d;
struct {
#if HOST_WORDS_BIG_ENDIAN
unsigned int negative:1;
unsigned int exponent:11;
unsigned int mantissa0:20;
unsigned int mantissa1:32;
#else
unsigned int mantissa1:32;
unsigned int mantissa0:20;
unsigned int exponent:11;
unsigned int negative:1;
#endif
} s;
} ieee;
unsigned int mant;
int exp;
if (HOST_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
abort ();
ieee.d = in;
/* Don't bother with NaN, Inf, 0 special cases, since they'll be handled
by the over/underflow code below. */
exp = ieee.s.exponent - 0x3ff;
mant = 1 << 23 | ieee.s.mantissa0 << 3 | ieee.s.mantissa1 >> 29;
/* The sign is actually part of the mantessa. Since we're comming from
IEEE we know that either bit 23 is set or we have a zero. */
if (! ieee.s.negative)
{
mant >>= 1;
exp += 1;
}
/* Check for overflow. Crop to FLT_MAX. */
if (exp > 127)
{
exp = 127;
mant = (ieee.s.negative ? 0xffffff : 0x7fffff);
}
/* Underflow to zero. */
else if (exp < -128)
{
exp = 0;
mant = 0;
}
return mant << 8 | (exp & 0xff);
}
/* Convert a REAL_VALUE_TYPE to the target 1750a extended float format:
----------------------------------------------------
| | Mantissa | | Mantissa |
|S| MS |Exponent| LS |
----------------------------------------------------
0 1 23 24 31 32 47
*/
void
real_value_to_target_double(in, out)
REAL_VALUE_TYPE in;
long out[];
{
union {
double d;
struct {
#if HOST_WORDS_BIG_ENDIAN
unsigned int negative:1;
unsigned int exponent:11;
unsigned int mantissa0:20;
unsigned int mantissa1:32;
#else
unsigned int mantissa1:32;
unsigned int mantissa0:20;
unsigned int exponent:11;
unsigned int negative:1;
#endif
} s;
} ieee;
unsigned int mant_h24, mant_l16;
int exp;
if (HOST_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
abort ();
ieee.d = in;
/* Don't bother with NaN, Inf, 0 special cases, since they'll be handled
by the over/underflow code below. */
exp = ieee.s.exponent - 0x3ff;
mant_h24 = 1 << 23 | ieee.s.mantissa0 << 3 | ieee.s.mantissa1 >> 29;
mant_l16 = (ieee.s.mantissa1 >> 13) & 0xffff;
/* The sign is actually part of the mantessa. Since we're comming from
IEEE we know that either bit 23 is set or we have a zero. */
if (! ieee.s.negative)
{
mant_l16 = mant_l16 >> 1 | (mant_h24 & 1) << 15;
mant_h24 >>= 1;
exp += 1;
}
/* Check for overflow. Crop to DBL_MAX. */
if (exp > 127)
{
exp = 127;
mant_h24 = (ieee.s.negative ? 0xffffff : 0x7fffff);
mant_l16 = 0xffff;
}
/* Underflow to zero. */
else if (exp < -128)
{
exp = 0;
mant_h24 = 0;
mant_l16 = 0;
}
out[0] = mant_h24 << 8 | (exp & 0xff);
out[1] = mant_l16;
}

39
gcc/config/1750a/1750a.h
View File

@ -111,9 +111,8 @@ extern const char *const sectname[4];
/* Type to use for `size_t'. If undefined, uses `long unsigned int'. */
#define SIZE_TYPE "int"
/* 1750a preliminary
#define TARGET_FLOAT_FORMAT UNKNOWN_FLOAT_FORMAT
*/
/* 1750a preliminary. Ought to properly define the format in real.c. */
#define TARGET_FLOAT_FORMAT UNKNOWN_FLOAT_FORMAT
/* Allocation boundary (in *bits*) for storing pointers in memory. */
#define POINTER_BOUNDARY 16
@ -1069,32 +1068,6 @@ enum reg_class { NO_REGS, R2, R0_1, INDEX_REGS, BASE_REGS, ALL_REGS, LIM_REG_CLA
#define JUMP_TABLES_IN_TEXT_SECTION 1
/* This is how to output an assembler line defining a 1750A `float'
constant. */
#define ASM_OUTPUT_SHORT_FLOAT(FILE,VALUE) \
do { \
if (label_pending) { \
label_pending = 0; \
sprintf (datalbl[datalbl_ndx].value, "%f", (double) VALUE); \
} \
datalbl[datalbl_ndx].size += 2; \
fprintf (FILE, "\tdataf\t%f\n",VALUE); \
} while(0)
/* This is how to output an assembler line defining a 1750A `double'
constant. */
#define ASM_OUTPUT_THREE_QUARTER_FLOAT(FILE,VALUE) \
do { \
if (label_pending) { \
label_pending = 0; \
sprintf (datalbl[datalbl_ndx].value, "%f", VALUE); \
} \
datalbl[datalbl_ndx].size += 3; \
fprintf(FILE,"\tdataef\t%f\n",VALUE); \
} while (0)
/* This is how to output an assembler line defining a string constant. */
#define ASM_OUTPUT_ASCII(FILE, PTR, LEN) do { \
@ -1190,7 +1163,13 @@ enum reg_class { NO_REGS, R2, R0_1, INDEX_REGS, BASE_REGS, ALL_REGS, LIM_REG_CLA
'Q': print a 1750 Base-Register-with-offset instruction's operands
*/
/* 1750A: see file aux-output.c */
#define PRINT_OPERAND(FILE, X, CODE) print_operand(FILE,X,CODE)
#define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address(FILE,ADDR)
/* Convert a REAL_VALUE_TYPE to the target 1750a float format. */
#define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \
((OUT) = real_value_to_target_single(IN))
/* Convert a REAL_VALUE_TYPE to the target 1750a extended float format. */
#define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \
real_value_to_target_double((IN), (OUT))

10
gcc/config/a29k/a29k.h
View File

@ -1460,16 +1460,6 @@ extern int a29k_debug_reg_map[];
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, "*%s%d", PREFIX, NUM)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
fprintf (FILE, "\t.double %.20e\n", (VALUE))
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
fprintf (FILE, "\t.float %.20e\n", (VALUE))
/* This is how to output an insn to push a register on the stack.
It need not be very fast code. */

31
gcc/config/alpha/alpha.h
View File

@ -1947,37 +1947,6 @@ do { \
#define CHECK_FLOAT_VALUE(MODE, D, OVERFLOW) \
((OVERFLOW) = check_float_value (MODE, &D, OVERFLOW))
/* This is how to output an assembler line defining a `long double'
constant. */
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { \
long t[4]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE ((VALUE), t); \
fprintf (FILE, "\t.quad 0x%lx%08lx,0x%lx%08lx\n", \
t[1] & 0xffffffff, t[0] & 0xffffffff, \
t[3] & 0xffffffff, t[2] & 0xffffffff); \
} while (0)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { \
long t[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
fprintf (FILE, "\t.quad 0x%lx%08lx\n", \
t[1] & 0xffffffff, t[0] & 0xffffffff); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { \
long t; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
fprintf (FILE, "\t.long 0x%lx\n", t & 0xffffffff); \
} while (0)
/* We use the default ASCII-output routine, except that we don't write more
than 50 characters since the assembler doesn't support very long lines. */

45
gcc/config/alpha/unicosmk.h
View File

@ -413,51 +413,6 @@ ssib_section () \
#define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,TABLEINSN) \
ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM)
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#ifdef REAL_ARITHMETIC
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long t[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
fprintf (FILE, "\t.quad ^X%lx%08lx\n", \
t[0] & 0xffffffff, t[1] & 0xffffffff); \
} while (0)
#else
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long t[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
fprintf (FILE, "\t.quad ^X%lx\n", t[0]); \
} while(0)
#endif
/* This is how to output an assembler line defining a `long double'
constant. `long double' and `double' are the same on the Cray T3E. */
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
ASM_OUTPUT_DOUBLE (FILE,VALUE)
/* This is how to output an assembler line defining a `float' constant.
??? Somehow, REAL_VALUE_TO_TARGET_SINGLE gets confused and returns the
value in the upper bits of the int. */
#undef ASM_OUTPUT_FLOAT
#ifdef REAL_ARITHMETIC
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long t; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
fprintf (FILE, "\t.long ^X%lx\n", t & 0xffffffff);\
} while (0)
#else
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long t; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
fprintf (FILE, "\t.long ^X%lx\n", (t >> 32) & 0xffffffff);\
} while(0)
#endif
/* CAM has some restrictions with respect to string literals. It won't
accept lines with more that 256 characters which means that we have
to split long strings. Moreover, it only accepts escape sequences of

19
gcc/config/alpha/vms.h
View File

@ -253,25 +253,6 @@ typedef struct {int num_args; enum avms_arg_type atypes[6];} avms_arg_info;
ASM_OUTPUT_SOURCE_FILENAME (FILE, main_input_filename); \
}
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
{ \
if (REAL_VALUE_ISINF (VALUE) \
|| REAL_VALUE_ISNAN (VALUE) \
|| REAL_VALUE_MINUS_ZERO (VALUE)) \
{ \
long t; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
fprintf (FILE, "\t.long 0x%lx\n", t & 0xffffffff); \
} \
else \
{ \
char str[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
fprintf (FILE, "\t.%c_floating %s\n", (TARGET_FLOAT_VAX)?'f':'s', str); \
} \
}
#define LINK_SECTION_ASM_OP "\t.link"
#define READONLY_SECTION_ASM_OP "\t.rdata"
#define LITERALS_SECTION_ASM_OP "\t.literals"

22
gcc/config/arc/arc.h
View File

@ -1238,28 +1238,6 @@ do { \
no longer contain unusual constructs. */
#define ASM_APP_OFF ""
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
{ \
long t; \
char str[30]; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
fprintf (FILE, "\t.word\t0x%lx %s %s\n", \
t, ASM_COMMENT_START, str); \
}
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
{ \
long t[2]; \
char str[30]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
fprintf (FILE, "\t.word\t0x%lx %s %s\n\t.word\t0x%lx\n", \
t[0], ASM_COMMENT_START, str, t[1]); \
}
/* This is how to output the definition of a user-level label named NAME,
such as the label on a static function or variable NAME. */
#define ASM_OUTPUT_LABEL(FILE, NAME) \

23
gcc/config/arm/aof.h
View File

@ -183,29 +183,6 @@ do \
#define ASM_APP_OFF ""
#define ASM_OUTPUT_LONG_DOUBLE(STREAM,VALUE) \
ASM_OUTPUT_DOUBLE((STREAM),(VALUE))
#define ASM_OUTPUT_DOUBLE(STREAM,VALUE) \
do { \
char dstr[30]; \
long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), l); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.14g", dstr); \
fprintf ((STREAM), "\tDCD &%lx, &%lx\t%s double %s\n", \
l[0], l[1], ASM_COMMENT_START, dstr); \
} while (0)
#define ASM_OUTPUT_FLOAT(STREAM,VALUE) \
do { \
char dstr[30]; \
long l; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), l); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.7g", dstr); \
fprintf ((STREAM), "\tDCD &%lx\t%s double %s\n", \
l, ASM_COMMENT_START, dstr); \
} while (0)
#define ASM_OUTPUT_ASCII(STREAM,PTR,LEN) \
{ \
int i; \

42
gcc/config/arm/aout.h
View File

@ -184,48 +184,6 @@ Boston, MA 02111-1307, USA. */
#define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL) \
asm_fprintf (STREAM, "\tb\t%LL%d\n", VALUE)
/* Output various types of constants. For real numbers we output hex, with
a comment containing the "human" value, this allows us to pass NaN's which
the riscix assembler doesn't understand (it also makes cross-assembling
less likely to fail). */
#define ASM_OUTPUT_LONG_DOUBLE(STREAM, VALUE) \
do \
{ \
char dstr[30]; \
long l[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr); \
asm_fprintf (STREAM, \
"\t.long 0x%lx,0x%lx,0x%lx\t%@ long double %s\n", \
l[0], l[1], l[2], dstr); \
} \
while (0)
#define ASM_OUTPUT_DOUBLE(STREAM, VALUE) \
do \
{ \
char dstr[30]; \
long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
REAL_VALUE_TO_DECIMAL (VALUE, "%.14g", dstr); \
asm_fprintf (STREAM, "\t.long 0x%lx, 0x%lx\t%@ double %s\n", l[0],\
l[1], dstr); \
} \
while (0)
#define ASM_OUTPUT_FLOAT(STREAM, VALUE) \
do \
{ \
char dstr[30]; \
long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
REAL_VALUE_TO_DECIMAL (VALUE, "%.7g", dstr); \
asm_fprintf (STREAM, "\t.word 0x%lx\t%@ float %s\n", l, \
dstr); \
} \
while (0)
#undef ASM_OUTPUT_ASCII
#define ASM_OUTPUT_ASCII(STREAM, PTR, LEN) \
output_ascii_pseudo_op (STREAM, (const unsigned char *)(PTR), LEN)

16
gcc/config/avr/avr.c
View File

@ -4485,22 +4485,6 @@ avr_assemble_integer (x, size, aligned_p)
return default_assemble_integer (x, size, aligned_p);
}
/* Output real N to file FILE */
void
asm_output_float (file, n)
FILE *file;
REAL_VALUE_TYPE n;
{
long val;
char dstr[100];
REAL_VALUE_TO_TARGET_SINGLE (n, val);
REAL_VALUE_TO_DECIMAL (n, "%g", dstr);
fprintf (file, "\t.long 0x%08lx\t/* %s */\n", val, dstr);
}
/* Sets section name for declaration DECL */
void

16
gcc/config/avr/avr.h
View File

@ -2009,22 +2009,6 @@ progmem_section (void) \
Objective C program. */
#define ASM_OUTPUT_DOUBLE(STREAM, VALUE) fprintf (STREAM, "no double float %.20e\n", VALUE)
#define ASM_OUTPUT_FLOAT(STREAM, VALUE) asm_output_float (STREAM, VALUE)
/* `ASM_OUTPUT_LONG_DOUBLE (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. */
#define ASM_OUTPUT_ASCII(FILE, P, SIZE) gas_output_ascii (FILE,P,SIZE)
/* `ASM_OUTPUT_ASCII (STREAM, PTR, LEN)'
output_ascii (FILE, P, SIZE)

37
gcc/config/c4x/c4x.h
View File

@ -1851,43 +1851,6 @@ const_section () \
#define ASM_APP_ON ""
#define ASM_APP_OFF ""
/* Output float/double constants QFmode. */
#define ASM_OUTPUT_BYTE_FLOAT(FILE, VALUE) \
do { \
long l; \
char str[30]; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
REAL_VALUE_TO_DECIMAL (VALUE, "%20lf", str); \
if (sizeof (int) == sizeof (long)) \
fprintf (FILE, "\t.word\t0%08xh\t; %s\n", (int) l, str);\
else \
fprintf (FILE, "\t.word\t0%08lxh\t; %s\n", l, str);\
} while (0);
/* Output long double constants HFmode.
The first word contains the exponent and first part of the mantissa
in the same manner as QFmode. The second word contains the full
mantissa. We should ensure that the two words are allocated within
the same page for the large memory model since we only output a single
LDP instruction. FIXME. The simplest solution probably is to output
a LDP for each load. */
#define ASM_OUTPUT_SHORT_FLOAT(FILE, VALUE) \
do { \
long l[2]; \
char str[30]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
REAL_VALUE_TO_DECIMAL (VALUE, "%20lf", str); \
l[1] = (l[0] << 8) | ((l[1] >> 24) & 0xff); \
if (sizeof (int) == sizeof (long)) \
fprintf (FILE, "\t.word\t0%08xh\t; %s\n\t.word\t0%08xh\n", \
(int) l[0], str, (int) l[1]); \
else \
fprintf (FILE, "\t.word\t0%08lxh\t; %s\n\t.word\t0%08lxh\n", \
l[0], str, l[1]); \
} while (0);
#define ASM_OUTPUT_ASCII(FILE, PTR, LEN) c4x_output_ascii (FILE, PTR, LEN)
/* Output and Generation of Labels. */

16
gcc/config/clipper/clix.h
View File

@ -46,22 +46,6 @@ do { \
fputs ("\n", (FILE)); \
} while (0)
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
{ \
union { int i[2]; double d; } _d_; \
_d_.d = VALUE; \
fprintf (FILE, "\t.long 0x%08x,0x%08x\n", _d_.i[0],_d_.i[1]); \
}
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
{ \
union { int i; float f; } _f_; \
_f_.f = VALUE; \
fprintf (FILE, "\t.long 0x%08x\n", _f_.i); \
}
/* This is how to output an assembler line
that says to advance the location counter
to a multiple of 2**LOG bytes. */

10
gcc/config/convex/convex.h
View File

@ -1257,16 +1257,6 @@ enum reg_class {
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, "*%s%d", PREFIX, NUM)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
outfloat (FILE, VALUE, "%.17e", "\tds.d ", "\n")
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
outfloat (FILE, VALUE, "%.9e", "\tds.s ", "\n")
/* This is how to output a string */
#define ASM_OUTPUT_ASCII(FILE,STR,SIZE) do { \

30
gcc/config/cris/cris.h
View File

@ -1507,36 +1507,6 @@ struct cum_args {int regs;};
/* Node: Data Output */
/* We must use REAL_VALUE_TO_TARGET_SINGLE and
REAL_VALUE_TO_TARGET_LONG_DOUBLE. It seems real.h cannot support when
target-double is target-single is 32bit-single. */
#define ASM_OUTPUT_LONG_DOUBLE(FILE, VALUE) \
do \
{ \
long l[2]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \
fprintf (FILE, "\t.dword 0x%lx\n", l[0]); \
fprintf (FILE, "\t.dword 0x%lx\n", l[1]); \
} \
while (0)
/* FIXME: The manual says "array of long:s", but
REAL_VALUE_TO_TARGET_SINGLE actually writes a long. */
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
do \
{ \
long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
fprintf (FILE, "\t.dword 0x%lx\n", l); \
} \
while (0)
/* This is what is used by gcc for 64-bit floats,
not the "long double" one. */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
ASM_OUTPUT_LONG_DOUBLE (FILE, VALUE)
#define IS_ASM_LOGICAL_LINE_SEPARATOR(C) (C) == '@'
/* Node: Uninitialized Data */

49
gcc/config/d30v/d30v.h
View File

@ -3729,55 +3729,6 @@ extern const char *d30v_branch_cost_string;
/* Output of Data. */
/* 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. */
/* #define ASM_OUTPUT_LONG_DOUBLE(STREAM, VALUE) */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
{ \
if (REAL_VALUE_ISINF (VALUE) \
|| REAL_VALUE_ISNAN (VALUE) \
|| REAL_VALUE_MINUS_ZERO (VALUE)) \
{ \
long t[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
fprintf (FILE, "\t.long 0x%lx\n\t.long 0x%lx\n", \
t[0] & 0xffffffff, t[1] & 0xffffffff); \
} \
else \
{ \
char str[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20e", str); \
fprintf (FILE, "\t.double 0d%s\n", str); \
} \
}
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
{ \
if (REAL_VALUE_ISINF (VALUE) \
|| REAL_VALUE_ISNAN (VALUE) \
|| REAL_VALUE_MINUS_ZERO (VALUE)) \
{ \
long t; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
fprintf (FILE, "\t.long 0x%lx\n", t & 0xffffffff); \
} \
else \
{ \
char str[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
fprintf (FILE, "\t.float 0d%s\n", str); \
} \
}
/* #define ASM_OUTPUT_THREE_QUARTER_FLOAT(STREAM, VALUE) */
/* #define ASM_OUTPUT_SHORT_FLOAT(STREAM, VALUE) */
/* #define ASM_OUTPUT_BYTE_FLOAT(STREAM, VALUE) */
/* 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'.

24
gcc/config/dsp16xx/dsp16xx.c
View File

@ -2264,30 +2264,6 @@ asm_output_local(file, name, size, rounded)
fprintf (file, "int\n");
}
void
asm_output_float (file, fp_const)
FILE *file;
double fp_const;
{
#if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
REAL_VALUE_TYPE d = fp_const;
long value;
REAL_VALUE_TO_TARGET_SINGLE (d, value);
fputs ("\tint ", file);
#ifdef WORDS_BIG_ENDIAN
fprintf (file, "0x%-4.4lx, 0x%-4.4lx", (value >> 16) & 0xffff,
value & 0xffff);
#else
fprintf (file, "0x%-4.4lx, 0x%-4.4lx", value & 0xffff,
(value >> 16) & 0xffff);
#endif
fputs ("\n", file);
#else
fatal_error ("inline float constants not supported on this host");
#endif
}
int
dsp16xx_address_cost (addr)
rtx addr;

10
gcc/config/dsp16xx/dsp16xx.h
View File

@ -1638,16 +1638,6 @@ const_section () \
/* OUTPUT OF DATA */
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) asm_output_float (FILE,VALUE)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) asm_output_float (FILE, VALUE)
/* This is how to output an assembler line defining a 'float' constant of
size HFmode. */
#define ASM_OUTPUT_SHORT_FLOAT(FILE,VALUE) asm_output_float (FILE, VALUE)
/* This is how we output a 'c' character string. For the 16xx
assembler we have to do it one letter at a time */

15
gcc/config/elxsi/elxsi.h
View File

@ -732,21 +732,6 @@ enum reg_class { NO_REGS, GENERAL_REGS, ALL_REGS, LIM_REG_CLASSES };
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, ".%s%d", PREFIX, NUM)
/* This is how to output an assembler line defining a `double' constant.
It is .dfloat or .gfloat, depending. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
{ union {double d; int i[2]; } tem; \
tem.d = (VALUE); \
fprintf (FILE, "\t.data\t%d{32}, %d{32}\n", tem.i[0], tem.i[1]); }
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
{ union {float f; int i; } tem; \
tem.f = (VALUE); \
fprintf (FILE, "\t.data %d{32}\n", tem.i); }
/* This is how to output an insn to push a register on the stack.
It need not be very fast code. */

32
gcc/config/fr30/fr30.h
View File

@ -1412,38 +1412,6 @@ do \
for ordinary compiler output. */
#define ASM_APP_OFF "#NO_APP\n"
/*}}}*/
/*{{{ Output of Data. */
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
do \
{ \
long t; \
char str[30]; \
\
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
\
fprintf (FILE, "\t.word\t0x%lx %s %s\n", \
t, ASM_COMMENT_START, str); \
} \
while (0)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
do \
{ \
long t[2]; \
char str[30]; \
\
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
\
fprintf (FILE, "\t.word\t0x%lx %s %s\n\t.word\t0x%lx\n", \
t[0], ASM_COMMENT_START, str, t[1]); \
} \
while (0)
/*}}}*/
/*{{{ Output and Generation of Labels. */

22
gcc/config/h8300/h8300.h
View File

@ -1248,28 +1248,6 @@ readonly_data () \
#define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \
sprintf (LABEL, "*.%s%d", PREFIX, NUM)
/* This is how to output an assembler line defining a `double' constant.
It is .dfloat or .gfloat, depending. */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
do \
{ \
char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.double %s\n", dstr); \
} \
while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
do \
{ \
char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.float %s\n", dstr); \
} \
while (0)
/* This is how to output an insn to push a register on the stack.
It need not be very fast code. */

26
gcc/config/i370/i370.h
View File

@ -1183,14 +1183,6 @@ enum reg_class
fprintf (FILE, "\tL\t%s,%d(13)\n\tLA\t13,4(13)\n", \
reg_names[REGNO], STACK_POINTER_OFFSET)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
fprintf (FILE, "\tDC\tD'%.18G'\n", (VALUE))
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
fprintf (FILE, "\tDC\tE'%.9G'\n", (VALUE))
/* This outputs a text string. The string are chopped up to fit into
an 80 byte record. Also, control and special characters, interpreted
by the IBM assembler, are output numerically. */
@ -1866,24 +1858,6 @@ abort(); \
#define ASM_DOUBLE "\t.double"
/* Argument to the flt pt. macros is a REAL_VALUE_TYPE which
may or may not be a float/double, depending on whther we
are running in cross-compiler mode. */
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE, RVAL) { \
char buf[50]; \
REAL_VALUE_TO_DECIMAL (RVAL, HOST_WIDE_INT_PRINT_DOUBLE_HEX, buf); \
fprintf (FILE, "\tDC\tD'%s'\n", buf); \
}
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE, RVAL) { \
char buf[50]; \
REAL_VALUE_TO_DECIMAL (RVAL, HOST_WIDE_INT_PRINT_DEC, buf); \
fprintf (FILE, "\tDC\tE'%s'\n", buf); \
}
/* This is how to output the definition of a user-level label named NAME,
such as the label on a static function or variable NAME. */
#define ASM_OUTPUT_LABEL(FILE,NAME) \

28
gcc/config/i386/i386.h
View File

@ -2876,34 +2876,6 @@ extern int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER];
#define ASM_OUTPUT_LABEL(FILE,NAME) \
(assemble_name (FILE, NAME), fputs (":\n", FILE))
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
fprintf (FILE, "%s0x%lx,0x%lx\n", ASM_LONG, l[0], l[1]); \
} while (0)
/* This is how to output a `long double' extended real constant. */
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long l[4]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \
if (TARGET_128BIT_LONG_DOUBLE) \
fprintf (FILE, "%s0x%lx,0x%lx,0x%lx,0x0\n", ASM_LONG, l[0], l[1], l[2]); \
else \
fprintf (FILE, "%s0x%lx,0x%lx,0x%lx\n", ASM_LONG, l[0], l[1], l[2]); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
fprintf ((FILE), "%s0x%lx\n", ASM_LONG, l); \
} while (0)
/* Store in OUTPUT a string (made with alloca) containing
an assembler-name for a local static variable named NAME.
LABELNO is an integer which is different for each call. */

55
gcc/config/i386/i386elf.h
View File

@ -54,61 +54,6 @@ Boston, MA 02111-1307, USA. */
%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}}}\
crtbegin.o%s"
/* This is how to output assembly code to define a `float' constant.
We always have to use a .long pseudo-op to do this because the native
SVR4 ELF assembler is buggy and it generates incorrect values when we
try to use the .float pseudo-op instead. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long value; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), value); \
if (sizeof (int) == sizeof (long)) \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value); \
else \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value); \
} while (0)
/* This is how to output assembly code to define a `double' constant.
We always have to use a pair of .long pseudo-ops to do this because
the native SVR4 ELF assembler is buggy and it generates incorrect
values when we try to use the the .double pseudo-op instead. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long value[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), value); \
if (sizeof (int) == sizeof (long)) \
{ \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[0]); \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[1]); \
} \
else \
{ \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[0]); \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[1]); \
} \
} while (0)
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long value[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE ((VALUE), value); \
if (sizeof (int) == sizeof (long)) \
{ \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[0]); \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[1]); \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[2]); \
} \
else \
{ \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[0]); \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[1]); \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[2]); \
} \
} while (0)
#undef DBX_REGISTER_NUMBER
#define DBX_REGISTER_NUMBER(n) \
(TARGET_64BIT ? dbx64_register_map[n] : svr4_dbx_register_map[n])

44
gcc/config/i386/next.h
View File

@ -42,50 +42,6 @@ Boston, MA 02111-1307, USA. */
((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode \
? FIRST_FLOAT_REG : 0)
#ifdef REAL_VALUE_TO_TARGET_LONG_DOUBLE
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { \
long hex[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, hex); \
if (sizeof (int) == sizeof (long)) \
fprintf (FILE, "\t.long 0x%x\n\t.long 0x%x\n\t.long 0x%x\n", \
(int) hex[0], (int) hex[1], (int) hex[2]); \
else \
fprintf (FILE, "\t.long 0x%lx\n\t.long 0x%lx\n\t.long 0x%lx\n", \
hex[0], hex[1], hex[2]); \
} while (0)
#endif
#ifdef REAL_VALUE_TO_TARGET_DOUBLE
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { \
long hex[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, hex); \
if (sizeof (int) == sizeof (long)) \
fprintf (FILE, "\t.long 0x%x\n\t.long 0x%x\n", \
(int) hex[0], (int) hex[1]); \
else \
fprintf (FILE, "\t.long 0x%lx\n\t.long 0x%lx\n", hex[0], hex[1]); \
} while (0)
#endif
/* This is how to output an assembler line defining a `float' constant. */
#ifdef REAL_VALUE_TO_TARGET_SINGLE
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { \
long hex; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, hex); \
if (sizeof (int) == sizeof (long)) \
fprintf (FILE, "\t.long 0x%x\n", (int) hex); \
else \
fprintf (FILE, "\t.long 0x%lx\n", hex); \
} while (0)
#endif
/* 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

55
gcc/config/i386/ptx4-i.h
View File

@ -40,61 +40,6 @@ Boston, MA 02111-1307, USA. */
#define CPP_PREDEFINES \
"-Dunix -D_SEQUENT_ -Asystem=unix -Asystem=ptx4"
/* This is how to output assembly code to define a `float' constant.
We always have to use a .long pseudo-op to do this because the native
SVR4 ELF assembler is buggy and it generates incorrect values when we
try to use the .float pseudo-op instead. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long value; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), value); \
if (sizeof (int) == sizeof (long)) \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value); \
else \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value); \
} while (0)
/* This is how to output assembly code to define a `double' constant.
We always have to use a pair of .long pseudo-ops to do this because
the native SVR4 ELF assembler is buggy and it generates incorrect
values when we try to use the .double pseudo-op instead. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long value[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), value); \
if (sizeof (int) == sizeof (long)) \
{ \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[0]); \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[1]); \
} \
else \
{ \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[0]); \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[1]); \
} \
} while (0)
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long value[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE ((VALUE), value); \
if (sizeof (int) == sizeof (long)) \
{ \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[0]); \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[1]); \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[2]); \
} \
else \
{ \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[0]); \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[1]); \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[2]); \
} \
} while (0)
#undef DBX_REGISTER_NUMBER
#define DBX_REGISTER_NUMBER(n) svr4_dbx_register_map[n]

55
gcc/config/i386/sysv4.h
View File

@ -38,61 +38,6 @@ Boston, MA 02111-1307, USA. */
#define CPP_PREDEFINES \
"-Dunix -D__svr4__ -Asystem=unix -Asystem=svr4"
/* This is how to output assembly code to define a `float' constant.
We always have to use a .long pseudo-op to do this because the native
SVR4 ELF assembler is buggy and it generates incorrect values when we
try to use the .float pseudo-op instead. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long value; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), value); \
if (sizeof (int) == sizeof (long)) \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value); \
else \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value); \
} while (0)
/* This is how to output assembly code to define a `double' constant.
We always have to use a pair of .long pseudo-ops to do this because
the native SVR4 ELF assembler is buggy and it generates incorrect
values when we try to use the .double pseudo-op instead. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long value[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), value); \
if (sizeof (int) == sizeof (long)) \
{ \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[0]); \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[1]); \
} \
else \
{ \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[0]); \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[1]); \
} \
} while (0)
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long value[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE ((VALUE), value); \
if (sizeof (int) == sizeof (long)) \
{ \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[0]); \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[1]); \
fprintf((FILE), "%s0x%x\n", ASM_LONG, (int) value[2]); \
} \
else \
{ \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[0]); \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[1]); \
fprintf((FILE), "%s0x%lx\n", ASM_LONG, value[2]); \
} \
} while (0)
/* Output at beginning of assembler file. */
/* The .file command should always begin the output. */

9
gcc/config/i860/fx2800.h
View File

@ -266,15 +266,6 @@ Boston, MA 02111-1307, USA. */
#undef ASM_COMMENT_START
#define ASM_COMMENT_START "//"
/* Use definitions of ASM_OUTPUT_{DOUBLE,FLOAT} as given in i860.h */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
fprintf(FILE, "\t.double %.20e\n", (VALUE))
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
fprintf(FILE, "\t.float %.12e\n", (VALUE))
#undef ASM_FILE_START
#define ASM_FILE_START(FILE)
#undef ASM_OUTPUT_FUNCTION_PREFIX

10
gcc/config/i860/i860.h
View File

@ -1072,16 +1072,6 @@ do { ASM_OUTPUT_ALIGN ((FILE), 2); \
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, "*.%s%d", PREFIX, NUM)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
fprintf (FILE, "\t.double %.20e\n", (VALUE))
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
fprintf (FILE, "\t.float %.12e\n", (VALUE))
/* This is how to output code to push a register on the stack.
It need not be very fast code. */

35
gcc/config/i860/paragon.h
View File

@ -81,41 +81,6 @@ Boston, MA 02111-1307, USA. */
#define ASM_OUTPUT_IDENT(FILE, NAME) \
fprintf (FILE, "//\t.ident \"%s\"\n", NAME);
/*
* the assembler doesn't grok .double INF and the like
* but does understand .long with hex numbers, so special
* case the "symbolic" IEEE numbers.
*/
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
{ \
if (REAL_VALUE_ISINF (VALUE) \
|| REAL_VALUE_ISNAN (VALUE) \
|| REAL_VALUE_MINUS_ZERO (VALUE)) \
{ \
long t[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
fprintf (FILE, "\t.long 0x%lx\n\t.long 0x%lx\n", t[0], t[1]); \
} \
else \
fprintf (FILE, "\t.double %.20e\n", VALUE); \
}
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
{ \
if (REAL_VALUE_ISINF (VALUE) \
|| REAL_VALUE_ISNAN (VALUE) \
|| REAL_VALUE_MINUS_ZERO (VALUE)) \
{ \
long t; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
fprintf (FILE, "\t.long 0x%lx\n", t); \
} \
else \
fprintf (FILE, "\t.float %.12e\n", VALUE); \
}
#undef ASM_OUTPUT_ASCII
#define ASM_OUTPUT_ASCII(FILE, STR, LENGTH) \
do \

49
gcc/config/i860/sysv4.h
View File

@ -59,55 +59,6 @@ Boston, MA 02111-1307, USA. */
fprintf (FILE, "]@%s", PART_CODE); \
} while (0)
/* If the host and target formats match, output the floats as hex. */
#if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
#if defined (HOST_WORDS_BIG_ENDIAN) == WORDS_BIG_ENDIAN
/* This is how to output an assembler line defining a `double' constant.
Note that the native i860/svr4 ELF assembler can't properly handle
infinity. It generates an incorrect (non-infinity) value when given
`.double 99e9999' and it doesn't grok `inf' at all. It also mishandles
NaNs and -0.0. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
{ \
if (REAL_VALUE_ISINF (VALUE) \
|| REAL_VALUE_ISNAN (VALUE) \
|| REAL_VALUE_MINUS_ZERO (VALUE)) \
{ \
long t[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
fprintf (FILE, "\t.word 0x%lx\n\t.word 0x%lx\n", t[0], t[1]); \
} \
else \
fprintf (FILE, "\t.double %.20e\n", VALUE); \
}
/* This is how to output an assembler line defining a `float' constant.
Note that the native i860/svr4 ELF assembler can't properly handle
infinity. It actually generates an assembly time error when given
`.float 99e9999' and it doesn't grok `inf' at all. It also mishandles
NaNs and -0.0. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
{ \
if (REAL_VALUE_ISINF (VALUE) \
|| REAL_VALUE_ISNAN (VALUE) \
|| REAL_VALUE_MINUS_ZERO (VALUE)) \
{ \
long t; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
fprintf (FILE, "\t.word 0x%lx\n", t); \
} \
else \
fprintf (FILE, "\t.float %.12e\n", VALUE); \
}
#endif /* word order matches */
#endif /* HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT */
#undef ASM_FILE_START
#define ASM_FILE_START(FILE) \
do { output_file_directive (FILE, main_input_filename); \

6
gcc/config/i960/i960-protos.h
View File

@ -88,12 +88,6 @@ extern int i960_final_reg_parm_stack_space PARAMS ((int, tree));
extern int i960_reg_parm_stack_space PARAMS ((tree));
#endif /* TREE_CODE */
#ifdef REAL_VALUE_TYPE
extern void i960_output_long_double PARAMS ((FILE *, REAL_VALUE_TYPE));
extern void i960_output_double PARAMS ((FILE *, REAL_VALUE_TYPE));
extern void i960_output_float PARAMS ((FILE *, REAL_VALUE_TYPE));
#endif /* REAL_VALUE_TYPE */
extern int process_pragma PARAMS ((int(*)(void), void(*)(int), const char *));
extern int i960_object_bytes_bitalign PARAMS ((int));
extern void i960_initialize PARAMS ((void));

48
gcc/config/i960/i960.c
View File

@ -2447,54 +2447,6 @@ i960_function_arg (cum, mode, type, named)
return ret;
}
/* Floating-point support. */
void
i960_output_long_double (file, value)
FILE *file;
REAL_VALUE_TYPE value;
{
long value_long[3];
char dstr[30];
REAL_VALUE_TO_TARGET_LONG_DOUBLE (value, value_long);
REAL_VALUE_TO_DECIMAL (value, "%.20g", dstr);
fprintf (file,
"\t.word\t0x%08lx\t\t# %s\n\t.word\t0x%08lx\n\t.word\t0x%08lx\n",
value_long[0], dstr, value_long[1], value_long[2]);
fprintf (file, "\t.word\t0x0\n");
}
void
i960_output_double (file, value)
FILE *file;
REAL_VALUE_TYPE value;
{
long value_long[2];
char dstr[30];
REAL_VALUE_TO_TARGET_DOUBLE (value, value_long);
REAL_VALUE_TO_DECIMAL (value, "%.20g", dstr);
fprintf (file, "\t.word\t0x%08lx\t\t# %s\n\t.word\t0x%08lx\n",
value_long[0], dstr, value_long[1]);
}
void
i960_output_float (file, value)
FILE *file;
REAL_VALUE_TYPE value;
{
long value_long;
char dstr[30];
REAL_VALUE_TO_TARGET_SINGLE (value, value_long);
REAL_VALUE_TO_DECIMAL (value, "%.12g", dstr);
fprintf (file, "\t.word\t0x%08lx\t\t# %s (float)\n", value_long, dstr);
}
/* Return the number of bits that an object of size N bytes is aligned to. */
int

13
gcc/config/i960/i960.h
View File

@ -1388,19 +1388,6 @@ extern struct rtx_def *i960_compare_op0, *i960_compare_op1;
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, "*%s%d", PREFIX, NUM)
/* This is how to output an assembler line defining a `long double'
constant. */
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) i960_output_long_double(FILE, VALUE)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) i960_output_double(FILE, VALUE)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) i960_output_float(FILE, VALUE)
#define ASM_OUTPUT_REG_PUSH(FILE,REGNO) \
fprintf (FILE, "\tst\t%s,(sp)\n\taddo\t4,sp,sp\n", reg_names[REGNO])

31
gcc/config/ia64/ia64.h
View File

@ -1913,37 +1913,6 @@ do { \
/* Output of Data. */
/* A C statement to output to the stdio stream STREAM an assembler instruction
to assemble a floating-point constant of `TFmode', `DFmode', `SFmode',
respectively, whose value is VALUE. */
/* ??? Must reverse the word order for big-endian code? */
#define ASM_OUTPUT_LONG_DOUBLE(FILE, VALUE) \
do { \
long t[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, t); \
fprintf (FILE, "\tdata4 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx\n", \
t[0] & 0xffffffff, t[1] & 0xffffffff, t[2] & 0xffffffff, 0L);\
} while (0)
/* ??? Must reverse the word order for big-endian code? */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { \
long t[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, t); \
fprintf (FILE, "\tdata8 0x%08lx%08lx\n", \
t[1] & 0xffffffff, t[0] & 0xffffffff); \
} while (0)
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { \
long t; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, t); \
fprintf (FILE, "\tdata4 0x%lx\n", t & 0xffffffff); \
} while (0)
/* This is how to output an assembler line defining a `char' constant
to an xdata segment. */

26
gcc/config/m32r/m32r.h
View File

@ -1719,32 +1719,6 @@ do { \
no longer contain unusual constructs. */
#define ASM_APP_OFF ""
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
do \
{ \
long t; \
char str[30]; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
fprintf (FILE, "\t.word\t0x%lx %s %s\n", \
t, ASM_COMMENT_START, str); \
} \
while (0)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
do \
{ \
long t[2]; \
char str[30]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
fprintf (FILE, "\t.word\t0x%lx %s %s\n\t.word\t0x%lx\n", \
t[0], ASM_COMMENT_START, str, t[1]); \
} \
while (0)
/* This is how to output the definition of a user-level label named NAME,
such as the label on a static function or variable NAME. */
/* On the M32R we need to ensure the next instruction starts on a 32 bit

19
gcc/config/m68hc11/m68hc11.c
View File

@ -2209,20 +2209,21 @@ print_operand (file, op, letter)
else if (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == SFmode)
{
REAL_VALUE_TYPE r;
long l;
REAL_VALUE_FROM_CONST_DOUBLE (r, op);
ASM_OUTPUT_FLOAT_OPERAND (letter, file, r);
REAL_VALUE_TO_TARGET_SINGLE (r, l);
asm_fprintf (file, "%I0x%lx", l);
}
else if (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == XFmode)
else if (GET_CODE (op) == CONST_DOUBLE
&& (GET_MODE (op) == DFmode || GET_MODE (op) == XFmode))
{
REAL_VALUE_TYPE r;
char dstr[30];
REAL_VALUE_FROM_CONST_DOUBLE (r, op);
ASM_OUTPUT_LONG_DOUBLE_OPERAND (file, r);
}
else if (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == DFmode)
{
REAL_VALUE_TYPE r;
REAL_VALUE_FROM_CONST_DOUBLE (r, op);
ASM_OUTPUT_DOUBLE_OPERAND (file, r);
REAL_VALUE_TO_DECIMAL (r, "%.20g", dstr);
asm_fprintf (file, "%I0r%s", dstr);
}
else
{

49
gcc/config/m68hc11/m68hc11.h
View File

@ -1569,28 +1569,6 @@ do { \
/* Output #ident as a .ident. */
/* This is how to output a `long double' extended real constant. */
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
ASM_OUTPUT_DOUBLE(FILE,VALUE)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
fprintf (FILE, "\t%s\t0x%lx,0x%lx\n", \
integer_asm_op (4, TRUE), l[0], l[1]); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
assemble_aligned_integer (4, GEN_INT (l)); \
} while (0)
/* This is how to output the definition of a user-level label named NAME,
such as the label on a static function or variable NAME. */
@ -1629,33 +1607,6 @@ do { long l; \
"*_.frame", "*_.tmp", "*_.z", "*_.xy", "*fake clobber", \
SOFT_REG_NAMES, "*sframe", "*ap"}
/* Output a float value (represented as a C double) as an immediate operand.
This macro is a 68k-specific macro. */
#define ASM_OUTPUT_FLOAT_OPERAND(CODE,FILE,VALUE) \
do { \
long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
asm_fprintf ((FILE), "%I0x%lx", l); \
} while (0)
/* Output a double value (represented as a C double) as an immediate operand.
This macro is a 68k-specific macro. */
#define ASM_OUTPUT_DOUBLE_OPERAND(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr); \
asm_fprintf (FILE, "%I0r%s", dstr); \
} while (0)
/* Note, long double immediate operands are not actually
generated by m68k.md. */
#define ASM_OUTPUT_LONG_DOUBLE_OPERAND(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr); \
asm_fprintf (FILE, "%I0r%s", dstr); \
} while (0)
/* Print an instruction operand X on file FILE. CODE is the code from the
%-spec for printing this operand. If `%z3' was used to print operand
3, then CODE is 'z'. */

25
gcc/config/m68k/3b1.h
View File

@ -101,8 +101,6 @@ output_file_directive ((FILE), main_input_filename)
#undef TARGET_VERSION
#undef ASM_FORMAT_PRIVATE_NAME
#undef ASM_OUTPUT_DOUBLE
#undef ASM_OUTPUT_FLOAT
#undef ASM_OUTPUT_ALIGN
#undef ASM_OUTPUT_SOURCE_FILENAME
#undef ASM_OUTPUT_SOURCE_LINE
@ -127,29 +125,6 @@ output_file_directive ((FILE), main_input_filename)
( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 12), \
sprintf ((OUTPUT), "%s_%%%d", (NAME), (LABELNO)))
/* The unixpc doesn't know about double's and float's */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
fprintf (FILE, "\tlong 0x%lx,0x%lx\n", l[0], l[1]); \
} while (0)
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long l[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \
fprintf (FILE, "\tlong 0x%lx,0x%lx,0x%lx\n", l[0], l[1], l[2]); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
fprintf ((FILE), "\tlong 0x%lx\n", l); \
} while (0)
#define ASM_OUTPUT_ALIGN(FILE,LOG) \
do { \
if ((LOG) == 1) \

18
gcc/config/m68k/altos3068.h
View File

@ -78,24 +78,6 @@ Boston, MA 02111-1307, USA. */
#define USE_GAS
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20e", dstr); \
fprintf (FILE, "\t.double 0r%s\n", dstr); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20e", dstr); \
fprintf (FILE, "\t.single 0r%s\n", dstr); \
} while (0)
#undef ASM_OUTPUT_FLOAT_OPERAND
#define ASM_OUTPUT_FLOAT_OPERAND(CODE,FILE,VALUE) \
do { \

9
gcc/config/m68k/crds.h
View File

@ -155,15 +155,6 @@ Boston, MA 02111-1307, USA. */
#undef IMMEDIATE_PREFIX
#define IMMEDIATE_PREFIX "$"
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
fprintf (FILE, "\t.long 0x%lx, 0x%lx\n", l[0], l[1]); \
} while (0)
/*unos has no .skip :-( */
#undef ASM_OUTPUT_SKIP
#define ASM_OUTPUT_SKIP(FILE,SIZE) \

37
gcc/config/m68k/dpx2.h
View File

@ -269,43 +269,6 @@ Boston, MA 02111-1307, USA. */
} \
}
/* This is how to output a `long double' extended real constant. */
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long l[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \
if (sizeof (int) == sizeof (long)) \
fprintf (FILE, "\tdc.l $%x,$%x,$%x\n", (int)l[0], (int)l[1], (int)l[2]); \
else \
fprintf (FILE, "\tdc.l $%lx,$%lx,$%lx\n", l[0], l[1], l[2]); \
} while (0)
#undef ASM_OUTPUT_DOUBLE
#if 0
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr); \
fprintf (FILE, "\tdc.d %s\n", dstr); \
} while (0)
#endif
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
fprintf (FILE, "\tdc.l $%lx,$%lx\n", l[0], l[1]); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
if (sizeof (int) == sizeof (long)) \
fprintf (FILE, "\tdc.l $%x\n", (int) l); \
else \
fprintf (FILE, "\tdc.l $%lx\n", l); \
} while (0)
/* This is how to output an element of a case-vector that is absolute.
(The 68000 does not use such vectors,
but we must define this macro anyway.) */

21
gcc/config/m68k/hp320.h
View File

@ -165,8 +165,6 @@ Boston, MA 02111-1307, USA. */
#undef TEXT_SECTION_ASM_OP
#undef DATA_SECTION_ASM_OP
#undef READONLY_DATA_SECTION
#undef ASM_OUTPUT_DOUBLE
#undef ASM_OUTPUT_FLOAT
#undef ASM_OUTPUT_ADDR_VEC_ELT
#undef ASM_OUTPUT_ADDR_DIFF_ELT
#undef ASM_OUTPUT_ALIGN
@ -266,25 +264,6 @@ do{ if (PREFIX[0] == 'L' && PREFIX[1] == 'I') \
fprintf (FILE, "%s%d:\n", PREFIX, NUM); \
} while(0)
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr); \
fprintf (FILE, "\tdouble 0f%s\n", dstr); \
} while (0)
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.9g", dstr); \
fprintf (FILE, "\tfloat 0f%s\n", dstr); \
} while (0)
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long l[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \
fprintf (FILE, "\tlong 0x%lx,0x%lx,0x%lx\n", l[0], l[1], l[2]); \
} while (0)
#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
fprintf (FILE, "\tlong L%d\n", VALUE)

24
gcc/config/m68k/m68k.h
View File

@ -1802,30 +1802,6 @@ __transfer_from_trampoline () \
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, "*%s%s%ld", LOCAL_LABEL_PREFIX, PREFIX, (long)(NUM))
/* This is how to output a `long double' extended real constant. */
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long l[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \
fprintf (FILE, "\t.long 0x%lx,0x%lx,0x%lx\n", l[0], l[1], l[2]); \
} while (0)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr); \
fprintf (FILE, "\t.double 0r%s\n", dstr); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
fprintf (FILE, "\t.long 0x%lx\n", l); \
} while (0)
/* This is how to output an insn to push a register on the stack.
It need not be very fast code. */

28
gcc/config/m68k/mot3300.h
View File

@ -296,34 +296,6 @@ Boston, MA 02111-1307, USA. */
#define INT_OP_GROUP INT_OP_NO_DOT
#endif
/* The sysV68 as doesn't know about double's and float's. */
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
fprintf ((FILE), "%s0x%lx,0x%lx\n", \
integer_asm_op (4, TRUE), l[0], l[1]); \
} while (0)
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long l[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \
fprintf (FILE, "%s 0x%lx,0x%lx,0x%lx\n", \
integer_asm_op (4, TRUE), l[0], l[1], l[2]); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
assemble_aligned_integer (4, GEN_INT (l)); \
} while (0)
/* This is how to output an assembler line
that says to advance the location counter
to a multiple of 2**LOG bytes. */

7
gcc/config/m68k/news.h
View File

@ -102,7 +102,6 @@ Boston, MA 02111-1307, USA. */
#undef REGISTER_NAMES
#undef ASM_OUTPUT_REG_PUSH
#undef ASM_OUTPUT_REG_POP
#undef ASM_OUTPUT_DOUBLE
#undef ASM_OUTPUT_SKIP
#undef ASM_FORMAT_PRIVATE_NAME
#endif
@ -160,12 +159,6 @@ Boston, MA 02111-1307, USA. */
#define ASM_OUTPUT_REG_POP(FILE,REGNO) \
fprintf (FILE, "\tmove.l (sp)+,%s\n", reg_names[REGNO])
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.double 0d%s\n", dstr); \
} while (0)
#define ASM_OUTPUT_SKIP(FILE,SIZE) \
fprintf (FILE, "\t.space %u\n", (SIZE))

53
gcc/config/m68k/next.h
View File

@ -39,59 +39,6 @@ Boston, MA 02111-1307, USA. */
(Why isn't this in m68k.h?) */
#define STRUCTURE_SIZE_BOUNDARY 16
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#ifdef REAL_VALUE_TO_TARGET_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { \
long hex[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, hex); \
fprintf (FILE, "\t.long 0x%lx\n\t.long 0x%lx\n", hex[0], hex[1]); \
} while (0)
#else
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { if (REAL_VALUE_ISINF (VALUE)) \
{ \
if (REAL_VALUE_NEGATIVE (VALUE)) \
fprintf (FILE, "\t.double 0r-99e999\n"); \
else \
fprintf (FILE, "\t.double 0r99e999\n"); \
} \
else \
{ char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.double 0r%s\n", dstr); \
} \
} while (0)
#endif
/* This is how to output an assembler line defining a `float' constant. */
#undef ASM_OUTPUT_FLOAT
#ifdef REAL_VALUE_TO_TARGET_SINGLE
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { \
long hex; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, hex); \
fprintf (FILE, "\t.long 0x%lx\n", hex); \
} while (0)
#else
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { if (REAL_VALUE_ISINF (VALUE)) \
{ \
if (REAL_VALUE_NEGATIVE (VALUE)) \
fprintf (FILE, "\t.single 0r-99e999\n"); \
else \
fprintf (FILE, "\t.single 0r99e999\n"); \
} \
else \
{ char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.single 0r%s\n", dstr); \
} \
} while (0)
#endif
#undef ASM_OUTPUT_FLOAT_OPERAND
#ifdef REAL_VALUE_TO_TARGET_SINGLE

33
gcc/config/m68k/next21.h
View File

@ -27,39 +27,6 @@ Boston, MA 02111-1307, USA. */
/* for #include <mach.h> in libgcc2.c */
#define NeXTStep21
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { if (REAL_VALUE_ISINF (VALUE)) \
{ \
if (REAL_VALUE_NEGATIVE (VALUE)) \
fprintf (FILE, "#0r-99e999"); \
else \
fprintf (FILE, "#0r99e999"); \
} \
else \
{ char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.double 0r%s\n", dstr); \
} \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { if (REAL_VALUE_ISINF (VALUE)) \
{ \
if (REAL_VALUE_NEGATIVE (VALUE)) \
fprintf (FILE, "\t.single 0r-99e999\n"); \
else \
fprintf (FILE, "\t.single 0r99e999\n"); \
} \
else \
{ char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.single 0r%s\n", dstr); \
} \
} while (0)
/* called from m68k.c line 1881 */
#undef ASM_OUTPUT_FLOAT_OPERAND
#define ASM_OUTPUT_FLOAT_OPERAND(CODE,FILE,VALUE) \

30
gcc/config/m68k/sgs.h
View File

@ -99,36 +99,6 @@ Boston, MA 02111-1307, USA. */
#endif /* defined SUPPORT_SUN_FPA */
/* This is how to output an assembler line defining an `int' constant. */
/* The SGS assembler doesn't understand ".word". */
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long l[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \
fprintf ((FILE), "%s0x%lx,0x%lx,0x%lx\n", \
integer_asm_op (4, TRUE), l[0], l[1], l[2]); \
} while (0)
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
fprintf ((FILE), "%s0x%lx,0x%lx\n", \
integer_asm_op (4, TRUE), l[0], l[1]); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
assemble_aligned_integer (4, GEN_INT (l)); \
} while (0)
/* This is how to output an assembler line that says to advance the
location counter to a multiple of 2**LOG bytes. */

42
gcc/config/m68k/sun2o4.h
View File

@ -96,48 +96,6 @@ Boston, MA 02111-1307, USA. */
#define LINK_SPEC \
"%{!nostdlib:%{!r*:%{!e*:-e start}}} -dc -dp %{static:-Bstatic}"
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { if (REAL_VALUE_ISINF (VALUE)) \
{ \
if (REAL_VALUE_NEGATIVE (VALUE)) \
fprintf (FILE, "\t.double 0r-99e999\n"); \
else \
fprintf (FILE, "\t.double 0r99e999\n"); \
} \
else if (REAL_VALUE_MINUS_ZERO (VALUE)) \
{ \
fprintf (FILE, "\t.long 0x80000000,0\n"); \
} \
else \
{ char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.double 0r%s\n", dstr); \
} \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { if (REAL_VALUE_ISINF (VALUE)) \
{ \
if (REAL_VALUE_NEGATIVE (VALUE)) \
fprintf (FILE, "\t.single 0r-99e999\n"); \
else \
fprintf (FILE, "\t.single 0r99e999\n"); \
} \
else if (REAL_VALUE_MINUS_ZERO (VALUE)) \
{ \
fprintf (FILE, "\t.long 0x80000000\n"); \
} \
else \
{ char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.single 0r%s\n", dstr); \
} \
} while (0)
#undef ASM_OUTPUT_FLOAT_OPERAND
#define ASM_OUTPUT_FLOAT_OPERAND(CODE,FILE,VALUE) \
do { \

48
gcc/config/m68k/sun3.h
View File

@ -183,54 +183,6 @@ Boston, MA 02111-1307, USA. */
#define FUNCTION_VALUE(VALTYPE,FUNC) FUNCTION_VALUEX (TYPE_MODE (VALTYPE))
#endif /* 0 */
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
{ \
if (REAL_VALUE_ISINF (VALUE)) \
{ \
if (REAL_VALUE_NEGATIVE (VALUE)) \
fprintf (FILE, "\t.double 0r-99e999\n"); \
else \
fprintf (FILE, "\t.double 0r99e999\n"); \
} \
else if (REAL_VALUE_ISNAN (VALUE)) \
{ long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), l); \
fprintf (FILE, "\t.long 0x%lx\n\t.long 0x%lx\n", l[0], l[1]); \
} \
else \
{ char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.17g", dstr); \
fprintf (FILE, "\t.double 0r%s\n", dstr); \
} \
}
/* This is how to output an assembler line defining a `float' constant. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
{ \
if (REAL_VALUE_ISINF (VALUE)) \
{ \
if (REAL_VALUE_NEGATIVE (VALUE)) \
fprintf (FILE, "\t.single 0r-99e999\n"); \
else \
fprintf (FILE, "\t.single 0r99e999\n"); \
} \
else if (REAL_VALUE_ISNAN (VALUE)) \
{ long l; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), l); \
fprintf (FILE, "\t.long 0x%lx\n", l); \
} \
else \
{ char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.9g", dstr); \
fprintf (FILE, "\t.single 0r%s\n", dstr); \
} \
}
/* This is how to output an assembler lines defining floating operands.
There's no way to output a NaN's fraction, so we lose it. */

21
gcc/config/m68k/tower-as.h
View File

@ -258,27 +258,6 @@ Boston, MA 02111-1307, USA. */
fprintf (FILE, "\tswbeg &%d\n%s%%%d:\n", \
XVECLEN (PATTERN (TABLE), 1), (PREFIX), (NUM)); \
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
fprintf (FILE, "\tlong 0x%lx,0x%lx\n", l[0], l[1]); \
} while (0)
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long l[3]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \
fprintf (FILE, "\tlong 0x%lx,0x%lx,0x%lx\n", l[0], l[1], l[2]); \
} while (0)
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
fprintf ((FILE), "\tlong 0x%lx\n", l); \
} while (0)
#undef ASM_OUTPUT_ADDR_VEC_ELT
#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
fprintf (FILE, "\tlong L%%%d\n", (VALUE))

55
gcc/config/m88k/m88k.h
View File

@ -1988,61 +1988,6 @@ do { \
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, TARGET_SVR4 ? "*.%s%ld" : "*@%s%ld", PREFIX, (long)(NUM))
/* Internal macro to get a single precision floating point value into
an int, so we can print its value in hex. */
#define FLOAT_TO_INT_INTERNAL( FVALUE, IVALUE ) \
{ union { \
REAL_VALUE_TYPE d; \
struct { \
unsigned sign : 1; \
unsigned exponent1 : 1; \
unsigned exponent2 : 3; \
unsigned exponent3 : 7; \
unsigned mantissa1 : 20; \
unsigned mantissa2 : 3; \
unsigned mantissa3 : 29; \
} s; \
} _u; \
\
union { \
int i; \
struct { \
unsigned sign : 1; \
unsigned exponent1 : 1; \
unsigned exponent3 : 7; \
unsigned mantissa1 : 20; \
unsigned mantissa2 : 3; \
} s; \
} _u2; \
\
_u.d = REAL_VALUE_TRUNCATE (SFmode, FVALUE); \
_u2.s.sign = _u.s.sign; \
_u2.s.exponent1 = _u.s.exponent1; \
_u2.s.exponent3 = _u.s.exponent3; \
_u2.s.mantissa1 = _u.s.mantissa1; \
_u2.s.mantissa2 = _u.s.mantissa2; \
IVALUE = _u2.i; \
}
/* This is how to output an assembler line defining a `double' constant.
Use "word" pseudos to avoid printing NaNs, infinity, etc. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { \
union { REAL_VALUE_TYPE d; long l[2]; } x; \
x.d = (VALUE); \
fprintf (FILE, "%s0x%.8lx, 0x%.8lx\n", \
integer_asm_op (4, TRUE), \
(long) x.l[0], (long) x.l[1]); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { \
int i; \
FLOAT_TO_INT_INTERNAL (VALUE, i); \
assemble_aligned_integer (4, GEN_INT (i)); \
} while (0)
/* The single-byte pseudo-op is the default. Override svr[34].h. */
#undef ASM_OUTPUT_ASCII
#define ASM_OUTPUT_ASCII(FILE, P, SIZE) \

21
gcc/config/mcore/mcore.h
View File

@ -1245,27 +1245,6 @@ extern long mcore_current_compilation_timestamp;
/* Output various types of constants. */
/* This is how to output an assembler line defining a `double'. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do \
{ \
char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.double %s\n", dstr); \
} \
while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do \
{ \
char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.float %s\n", dstr); \
} \
while (0)
/* This is how to output an assembler line
that says to advance the location counter by SIZE bytes. */
#undef ASM_OUTPUT_SKIP

4
gcc/config/mips/mips-protos.h
View File

@ -40,10 +40,6 @@ extern void mips_declare_object PARAMS ((FILE *, const char *,
const char *, int));
extern void mips_expand_epilogue PARAMS ((void));
extern void mips_expand_prologue PARAMS ((void));
#ifdef REAL_VALUE_TYPE
extern void mips_output_double PARAMS ((FILE *, REAL_VALUE_TYPE));
extern void mips_output_float PARAMS ((FILE *, REAL_VALUE_TYPE));
#endif /* REAL_VALUE_TYPE */
extern void mips_output_filename PARAMS ((FILE *, const char *));
extern void mips_output_lineno PARAMS ((FILE *, int));
extern void mips_output_ascii PARAMS ((FILE *, const char *,

37
gcc/config/mips/mips.c
View File

@ -6289,43 +6289,6 @@ mips_declare_object (stream, name, init_string, final_string, size)
}
}
/* Output a double precision value to the assembler. If both the
host and target are IEEE, emit the values in hex. */
void
mips_output_double (stream, value)
FILE *stream;
REAL_VALUE_TYPE value;
{
#ifdef REAL_VALUE_TO_TARGET_DOUBLE
long value_long[2];
REAL_VALUE_TO_TARGET_DOUBLE (value, value_long);
fprintf (stream, "\t.word\t0x%08lx\t\t# %.20g\n\t.word\t0x%08lx\n",
value_long[0], value, value_long[1]);
#else
fprintf (stream, "\t.double\t%.20g\n", value);
#endif
}
/* Output a single precision value to the assembler. If both the
host and target are IEEE, emit the values in hex. */
void
mips_output_float (stream, value)
FILE *stream;
REAL_VALUE_TYPE value;
{
#ifdef REAL_VALUE_TO_TARGET_SINGLE
long value_long;
REAL_VALUE_TO_TARGET_SINGLE (value, value_long);
fprintf (stream, "\t.word\t0x%08lx\t\t# %.12g (float)\n", value_long, value);
#else
fprintf (stream, "\t.float\t%.12g\n", value);
#endif
}
/* Return the bytes needed to compute the frame pointer from the current
stack pointer.

12
gcc/config/mips/mips.h
View File

@ -4384,18 +4384,6 @@ do { \
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf ((LABEL), "*%s%s%ld", (LOCAL_LABEL_PREFIX), (PREFIX), (long)(NUM))
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(STREAM,VALUE) \
mips_output_double (STREAM, VALUE)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(STREAM,VALUE) \
mips_output_float (STREAM, VALUE)
/* This is how to output an element of a case-vector that is absolute. */
#define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \

6
gcc/config/mmix/mmix-protos.h
View File

@ -131,12 +131,6 @@ extern rtx mmix_gen_compare_reg PARAMS ((enum rtx_code, rtx, rtx));
extern int mmix_asm_preferred_eh_data_format PARAMS ((int, int));
extern void mmix_setup_frame_addresses PARAMS ((void));
/* Need real.h */
#ifdef GCC_REAL_H
extern void mmix_asm_output_double PARAMS ((FILE *, REAL_VALUE_TYPE *));
extern void mmix_asm_output_float PARAMS ((FILE *, REAL_VALUE_TYPE *));
#endif /* GCC_REAL_H */
/*
* Local variables:
* eval: (c-set-style "gnu")

33
gcc/config/mmix/mmix.c
View File

@ -1890,39 +1890,6 @@ mmix_asm_output_source_line (stream, lineno)
fprintf (stream, "\n");
}
/* ASM_OUTPUT_DOUBLE. */
void
mmix_asm_output_double (stream, valuep)
FILE * stream;
REAL_VALUE_TYPE * valuep;
{
unsigned long bits[2];
HOST_WIDEST_INT value;
REAL_VALUE_TO_TARGET_DOUBLE (*valuep, (long *) bits);
value
= (((HOST_WIDEST_INT) bits[0]) << 32) | (HOST_WIDEST_INT) bits[1];
mmix_output_octa (stream, value, 1);
}
/* ASM_OUTPUT_FLOAT. */
void
mmix_asm_output_float (stream, valuep)
FILE * stream;
REAL_VALUE_TYPE * valuep;
{
unsigned long bits;
REAL_VALUE_TO_TARGET_SINGLE (*valuep, bits);
fprintf (stream, "\tTETRA #%lx\n",
(unsigned long) (bits
& (((unsigned HOST_WIDEST_INT) (1 << 31) - 1) * 2
+ 1)));
}
/* Target hook for assembling integer objects. Use mmix_print_operand
for WYDE and TETRA. Use mmix_output_octa to output 8-byte
CONST_DOUBLEs. */

7
gcc/config/mmix/mmix.h
View File

@ -966,16 +966,9 @@ const_section () \
/* Node: Data Output */
#define ASM_OUTPUT_DOUBLE(STREAM, VALUE) \
mmix_asm_output_double (STREAM, &VALUE)
#define ASM_OUTPUT_FLOAT(STREAM, VALUE) \
mmix_asm_output_float (STREAM, &VALUE)
#define ASM_OUTPUT_ASCII(STREAM, PTR, LEN) \
mmix_asm_output_ascii (STREAM, PTR, LEN)
/* Node: Uninitialized Data */
#define ASM_OUTPUT_ALIGNED_COMMON(ST, N, S, A) \

17
gcc/config/mn10200/mn10200.h
View File

@ -817,23 +817,6 @@ struct cum_arg { int nbytes; };
#define ASM_APP_OFF "#NO_APP\n"
/* This is how to output an assembler line defining a `double' constant.
It is .dfloat or .gfloat, depending. */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.double %s\n", dstr); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.float %s\n", dstr); \
} while (0)
/* This says how to output the assembler to define a global
uninitialized but not common symbol.
Try to use asm_output_bss to implement this macro. */

17
gcc/config/mn10300/mn10300.h
View File

@ -901,23 +901,6 @@ struct cum_arg {int nbytes; };
#define ASM_APP_OFF "#NO_APP\n"
/* This is how to output an assembler line defining a `double' constant.
It is .dfloat or .gfloat, depending. */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.double %s\n", dstr); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.float %s\n", dstr); \
} while (0)
/* This says how to output the assembler to define a global
uninitialized but not common symbol.
Try to use asm_output_bss to implement this macro. */

4
gcc/config/ns32k/encore.h
View File

@ -39,7 +39,6 @@ Boston, MA 02111-1307, USA. */
#undef ASM_OUTPUT_ADDR_DIFF_ELT
#undef ASM_OUTPUT_ALIGN
#undef ASM_OUTPUT_ASCII
#undef ASM_OUTPUT_DOUBLE
#undef ASM_OUTPUT_INTERNAL_LABEL
#undef ASM_OUTPUT_LOCAL
#undef CPP_PREDEFINES
@ -105,9 +104,6 @@ do { \
} while (0)
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
fprintf (FILE, "\t.long 0f%.20e\n", (VALUE))
#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \
( fputs ("\t.bss ", (FILE)), \
assemble_name ((FILE), (NAME)), \

12
gcc/config/ns32k/ns32k.h
View File

@ -1283,18 +1283,6 @@ while (0)
/* Output of Data */
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
fprintf (FILE, "\t.double 0d%.20e\n", (VALUE))
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
fprintf (FILE, "\t.float 0f%.20e\n", (VALUE))
/* This is how to output an assembler line defining an `int' constant. */
/* This is how to output an assembler line defining an external/static
address which is not in tree format (for collect.c). */

11
gcc/config/pa/long_double.h
View File

@ -20,17 +20,6 @@ Boston, MA 02111-1307, USA. */
#define LONG_DOUBLE_TYPE_SIZE 128
#undef ASM_OUTPUT_LONG_DOUBLE
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
do { long value[4]; \
REAL_VALUE_TO_TARGET_LONG_DOUBLE ((VALUE), value); \
fprintf((FILE), "%s\t0x%lx\n", "\t.word", value[0]); \
fprintf((FILE), "%s\t0x%lx\n", "\t.word", value[1]); \
fprintf((FILE), "%s\t0x%lx\n", "\t.word", value[2]); \
fprintf((FILE), "%s\t0x%lx\n", "\t.word", value[3]); \
} while (0)
/* Define library calls for quad FP operations. These are all part of the
PA32 and PA64 ABIs. */
#define ADDTF3_LIBCALL "_U_Qfadd"

16
gcc/config/pa/pa.h
View File

@ -1735,22 +1735,6 @@ while (0)
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, "*%c$%s%04ld", (PREFIX)[0], (PREFIX) + 1, (long)(NUM))
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { long l[2]; \
REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l); \
fprintf (FILE, "\t.word 0x%lx\n\t.word 0x%lx\n", l[0], l[1]); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { long l; \
REAL_VALUE_TO_TARGET_SINGLE (VALUE, l); \
fprintf (FILE, "\t.word 0x%lx\n", l); \
} while (0)
#define ASM_GLOBALIZE_LABEL(FILE, NAME) \
do { \
/* We only handle DATA objects here, functions are globalized in \

10
gcc/config/pdp11/pdp11.h
View File

@ -1089,16 +1089,6 @@ fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n") \
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, "*%s_%d", PREFIX, NUM)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
fprintf (FILE, "\tdouble %.20e\n", (VALUE))
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
fprintf (FILE, "\tfloat %.12e\n", (VALUE))
#define ASM_OUTPUT_ASCII(FILE, P, SIZE) \
output_ascii (FILE, P, SIZE)

16
gcc/config/pj/pj.h
View File

@ -1184,22 +1184,6 @@ do { fputs (current_function_varargs || current_function_stdarg \
/* Output various types of constants. */
/* This is how to output an assembler line defining a `double'. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf ((FILE), "\t.double %s\n", dstr); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf ((FILE), "\t.float %s\n", dstr); \
} while (0)
/* This is how to output an assembler line
that says to advance the location counter by SIZE bytes. */

6
gcc/config/romp/romp.c
View File

@ -1965,10 +1965,8 @@ output_fpops (file)
union real_extract u;
memcpy (&u, &CONST_DOUBLE_LOW (immed[i]), sizeof u);
if (GET_MODE (immed[i]) == DFmode)
ASM_OUTPUT_DOUBLE (file, u.d);
else
ASM_OUTPUT_FLOAT (file, u.d);
assemble_real (u.d, GET_MODE (immed[i]),
GET_MODE_ALIGNMENT (GET_MODE (immed[i])));
}
else
abort ();

20
gcc/config/romp/romp.h
View File

@ -1384,26 +1384,6 @@ struct rt_cargs {int gregs, fregs; };
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, "*%s%d", PREFIX, NUM)
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
fprintf (FILE, "\t.double 0d%.20e\n", (VALUE))
/* This is how to output an assembler line defining a `float' constant.
WARNING: Believe it or not, the ROMP assembler has a bug in its
handling of single-precision floating-point values making it impossible
to output such values in the expected way. Therefore, it must be output
in hex. THIS WILL NOT WORK IF CROSS-COMPILING FROM A MACHINE THAT DOES
NOT USE IEEE-FORMAT FLOATING-POINT, but there is nothing that can be done
about it short of fixing the assembler. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { union { int i; float f; } u_i_f; \
u_i_f.f = (VALUE); \
fprintf (FILE, "\t.long 0x%x\n", u_i_f.i);\
} while (0)
/* This is how to output code to push a register on the stack.
It need not be very fast code. */

19
gcc/config/rs6000/rs6000.h
View File

@ -2669,25 +2669,6 @@ extern char rs6000_reg_names[][8]; /* register names (0 vs. %r0). */
the loader. This depends on the AIX version. */
#define RS6000_CALL_GLUE "cror 31,31,31"
/* This is how to output an assembler line defining a `double' constant. */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
{ \
long t[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
fprintf (FILE, "\t.long 0x%lx\n\t.long 0x%lx\n", \
t[0] & 0xffffffff, t[1] & 0xffffffff); \
}
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
{ \
long t; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
fprintf (FILE, "\t.long 0x%lx\n", t & 0xffffffff); \
}
/* This is how to output an element of a case-vector that is relative. */
#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \

24
gcc/config/s390/linux.h
View File

@ -93,30 +93,6 @@ Boston, MA 02111-1307, USA. */
#define ASM_OUTPUT_LABEL(FILE, NAME) \
(assemble_name (FILE, NAME), fputs (":\n", FILE))
/* This is how to output an assembler line defining a `double' constant. */
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
{ \
long t[2]; \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
fprintf (FILE, "\t.long 0x%lx\n\t.long 0x%lx\n", \
t[0] & 0xffffffff, t[1] & 0xffffffff); \
}
/* This is how to output an assembler line defining a `float' constant. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
{ \
long t; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
fprintf (FILE, "\t.long 0x%lx\n", t & 0xffffffff); \
}
/* Store in OUTPUT a string (made with alloca) containing
an assembler-name for a local static variable named NAME.
LABELNO is an integer which is different for each call. */

15
gcc/config/sh/sh.h
View File

@ -2072,21 +2072,6 @@ extern char fp_reg_names[][5];
/* Output various types of constants. */
/* This is how to output an assembler line defining a `double'. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf ((FILE), "\t.double %s\n", dstr); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf ((FILE), "\t.float %s\n", dstr); \
} while (0)
/* Loop alignment is now done in machine_dependent_reorg, so that
branch shortening can know about it. */

50
gcc/config/sparc/sparc.h
View File

@ -2717,56 +2717,6 @@ do { \
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf ((LABEL), "*%s%ld", (PREFIX), (long)(NUM))
/* This is how to output an assembler line defining a `float' constant.
We always have to use a .long pseudo-op to do this because the native
SVR4 ELF assembler is buggy and it generates incorrect values when we
try to use the .float pseudo-op instead. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
{ \
long t; \
char str[30]; \
REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
fprintf (FILE, "\t%s\t0x%lx %s ~%s\n", \
integer_asm_op (4, TRUE), t, \
ASM_COMMENT_START, str); \
} \
/* This is how to output an assembler line defining a `double' constant.
We always have to use a .long pseudo-op to do this because the native
SVR4 ELF assembler is buggy and it generates incorrect values when we
try to use the .float pseudo-op instead. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
{ \
long t[2]; \
char str[30]; \
const char *long_op = integer_asm_op (4, TRUE); \
REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
fprintf (FILE, "\t%s\t0x%lx %s ~%s\n", long_op, t[0], \
ASM_COMMENT_START, str); \
fprintf (FILE, "\t%s\t0x%lx\n", long_op, t[1]); \
}
/* This is how to output an assembler line defining a `long double'
constant. */
#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \
{ \
long t[4]; \
char str[30]; \
const char *long_op = integer_asm_op (4, TRUE); \
REAL_VALUE_TO_TARGET_LONG_DOUBLE ((VALUE), t); \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str); \
fprintf (FILE, "\t%s\t0x%lx %s ~%s\n", long_op, t[0], \
ASM_COMMENT_START, str); \
fprintf (FILE, "\t%s\t0x%lx\n", long_op, t[1]); \
fprintf (FILE, "\t%s\t0x%lx\n", long_op, t[2]); \
fprintf (FILE, "\t%s\t0x%lx\n", long_op, t[3]); \
}
/* This is how we hook in and defer the case-vector until the end of
the function. */
#define ASM_OUTPUT_ADDR_VEC(LAB,VEC) \

25
gcc/config/stormy16/stormy16.h
View File

@ -3546,31 +3546,6 @@ do { \
/* Output of Data. */
/* 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. */
/* This is how to output an assembler line defining a `double'. */
#define ASM_OUTPUT_DOUBLE(STREAM,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf ((STREAM), "\t.double %s\n", dstr); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(STREAM,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf ((STREAM), "\t.float %s\n", dstr); \
} while (0)
/* #define ASM_OUTPUT_LONG_DOUBLE(STREAM, VALUE) */
/* #define ASM_OUTPUT_THREE_QUARTER_FLOAT(STREAM, VALUE) */
/* #define ASM_OUTPUT_SHORT_FLOAT(STREAM, VALUE) */
/* #define ASM_OUTPUT_BYTE_FLOAT(STREAM, VALUE) */
/* 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'.

17
gcc/config/v850/v850.h
View File

@ -1258,23 +1258,6 @@ do { \
else \
goto FAIL;
/* This is how to output an assembler line defining a `double' constant.
It is .double or .float, depending. */
#define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.double %s\n", dstr); \
} while (0)
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE, VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
fprintf (FILE, "\t.float %s\n", dstr); \
} while (0)
/* This says how to output the assembler to define a global
uninitialized but not common symbol. */

17
gcc/config/vax/vax.h
View File

@ -1106,23 +1106,6 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
sprintf (LABEL, "*%s%d", PREFIX, NUM)
/* This is how to output an assembler line defining a `double' constant.
It is .dfloat or .gfloat, depending. */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20e", dstr); \
fprintf (FILE, "\t.%cfloat 0%c%s\n", ASM_DOUBLE_CHAR, \
ASM_DOUBLE_CHAR, dstr); \
} while (0);
/* This is how to output an assembler line defining a `float' constant. */
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20e", dstr); \
fprintf (FILE, "\t.float 0f%s\n", dstr); } while (0);
/* This is how to output an insn to push a register on the stack.
It need not be very fast code. */

7
gcc/config/vax/vaxv.h
View File

@ -61,10 +61,3 @@ do { \
} \
fputs ("\n", (FILE)); \
} while (0)
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { char dstr[30]; \
REAL_VALUE_TO_DECIMAL (VALUE, "%.20e", dstr); \
fprintf (FILE, "\t.double 0d%s\n", dstr); \
} while (0)

31
gcc/config/we32k/we32k.h
View File

@ -755,37 +755,6 @@ enum reg_class { NO_REGS, GENERAL_REGS,
ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM); \
} while (0)
/* This is how to output an assembler line defining a `double' constant. */
/* This is how to output an assembler line defining a `float' constant. */
/* AT&T's assembler can't handle floating constants written as floating.
However, when cross-compiling, always use that in case format differs. */
#ifdef CROSS_COMPILE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
fprintf (FILE, "\t.double 0r%.20g\n", (VALUE))
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
fprintf (FILE, "\t.float 0r%.10g\n", (VALUE))
#else
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { union { double d; long l[2];} tem; \
tem.d = (VALUE); \
fprintf (FILE, "\t.word 0x%lx, 0x%lx\n", tem.l[0], tem.l[1]);\
} while (0)
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { union { float f; long l;} tem; \
tem.f = (VALUE); \
fprintf (FILE, "\t.word 0x%lx\n", tem.l); \
} while (0)
#endif /* not CROSS_COMPILE */
#define ASM_OUTPUT_ASCII(FILE,PTR,LEN) \
do { \
const unsigned char *s; \

17
gcc/doc/tm.texi
View File

@ -5852,23 +5852,6 @@ when the relevant string is @code{NULL}.
@end deftypefn
@table @code
@findex ASM_OUTPUT_LONG_DOUBLE
@findex ASM_OUTPUT_DOUBLE
@findex ASM_OUTPUT_FLOAT
@item ASM_OUTPUT_LONG_DOUBLE (@var{stream}, @var{value})
@itemx ASM_OUTPUT_DOUBLE (@var{stream}, @var{value})
@itemx ASM_OUTPUT_FLOAT (@var{stream}, @var{value})
@itemx ASM_OUTPUT_THREE_QUARTER_FLOAT (@var{stream}, @var{value})
@itemx ASM_OUTPUT_SHORT_FLOAT (@var{stream}, @var{value})
@itemx ASM_OUTPUT_BYTE_FLOAT (@var{stream}, @var{value})
A C statement to output to the stdio stream @var{stream} an assembler
instruction to assemble a floating-point constant of @code{TFmode},
@code{DFmode}, @code{SFmode}, @code{TQFmode}, @code{HFmode}, or
@code{QFmode}, respectively, whose value is @var{value}. @var{value}
will be a C expression of type @code{REAL_VALUE_TYPE}. Macros such as
@code{REAL_VALUE_TO_TARGET_DOUBLE} are useful for writing these
definitions.
@findex OUTPUT_ADDR_CONST_EXTRA
@item OUTPUT_ADDR_CONST_EXTRA (@var{stream}, @var{x}, @var{fail})
A C statement to recognize @var{rtx} patterns that

142
gcc/varasm.c
View File

@ -140,7 +140,6 @@ static HOST_WIDE_INT const_alias_set;
static const char *strip_reg_name PARAMS ((const char *));
static int contains_pointers_p PARAMS ((tree));
static void assemble_real_1 PARAMS ((PTR));
static void decode_addr_const PARAMS ((tree, struct addr_const *));
static int const_hash PARAMS ((tree));
static int compare_constant PARAMS ((tree,
@ -2038,86 +2037,85 @@ assemble_integer (x, size, align, force)
return false;
}
/* Assemble the floating-point constant D into an object of size MODE. */
struct assemble_real_args
{
REAL_VALUE_TYPE *d;
enum machine_mode mode;
};
static void
assemble_real_1 (p)
PTR p;
{
struct assemble_real_args *args = (struct assemble_real_args *) p;
REAL_VALUE_TYPE *d = args->d;
enum machine_mode mode = args->mode;
switch (mode)
{
#ifdef ASM_OUTPUT_BYTE_FLOAT
case QFmode:
ASM_OUTPUT_BYTE_FLOAT (asm_out_file, *d);
break;
#endif
#ifdef ASM_OUTPUT_SHORT_FLOAT
case HFmode:
ASM_OUTPUT_SHORT_FLOAT (asm_out_file, *d);
break;
#endif
#ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
case TQFmode:
ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file, *d);
break;
#endif
#ifdef ASM_OUTPUT_FLOAT
case SFmode:
ASM_OUTPUT_FLOAT (asm_out_file, *d);
break;
#endif
#ifdef ASM_OUTPUT_DOUBLE
case DFmode:
ASM_OUTPUT_DOUBLE (asm_out_file, *d);
break;
#endif
#ifdef ASM_OUTPUT_LONG_DOUBLE
case XFmode:
case TFmode:
ASM_OUTPUT_LONG_DOUBLE (asm_out_file, *d);
break;
#endif
default:
abort ();
}
}
void
assemble_real (d, mode, align)
REAL_VALUE_TYPE d;
enum machine_mode mode;
unsigned int align;
{
struct assemble_real_args args;
args.d = &d;
args.mode = mode;
long data[4];
long l;
unsigned int nalign = min_align (align, 32);
/* We cannot emit unaligned floating point constants. This is slightly
complicated in that we don't know what "unaligned" means exactly. */
#ifdef BIGGEST_FIELD_ALIGNMENT
if (align >= BIGGEST_FIELD_ALIGNMENT)
;
else
#endif
if (align < GET_MODE_ALIGNMENT (mode))
abort ();
switch (BITS_PER_UNIT)
{
case 8:
switch (mode)
{
case SFmode:
REAL_VALUE_TO_TARGET_SINGLE (d, l);
assemble_integer (GEN_INT (l), 4, align, 1);
break;
case DFmode:
REAL_VALUE_TO_TARGET_DOUBLE (d, data);
assemble_integer (GEN_INT (data[0]), 4, align, 1);
assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
break;
case XFmode:
REAL_VALUE_TO_TARGET_LONG_DOUBLE (d, data);
assemble_integer (GEN_INT (data[0]), 4, align, 1);
assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
assemble_integer (GEN_INT (data[2]), 4, nalign, 1);
break;
case TFmode:
REAL_VALUE_TO_TARGET_LONG_DOUBLE (d, data);
assemble_integer (GEN_INT (data[0]), 4, align, 1);
assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
assemble_integer (GEN_INT (data[2]), 4, nalign, 1);
assemble_integer (GEN_INT (data[3]), 4, nalign, 1);
break;
default:
abort ();
}
break;
if (do_float_handler (assemble_real_1, (PTR) &args))
return;
case 16:
switch (mode)
{
case HFmode:
REAL_VALUE_TO_TARGET_SINGLE (d, l);
assemble_integer (GEN_INT (l), 2, align, 1);
break;
case TQFmode:
REAL_VALUE_TO_TARGET_DOUBLE (d, data);
assemble_integer (GEN_INT (data[0]), 2, align, 1);
assemble_integer (GEN_INT (data[1]), 1, nalign, 1);
break;
default:
abort ();
}
break;
internal_error ("floating point trap outputting a constant");
case 32:
switch (mode)
{
case QFmode:
REAL_VALUE_TO_TARGET_SINGLE (d, l);
assemble_integer (GEN_INT (l), 1, align, 1);
break;
case HFmode:
REAL_VALUE_TO_TARGET_DOUBLE (d, data);
assemble_integer (GEN_INT (data[0]), 1, align, 1);
assemble_integer (GEN_INT (data[1]), 1, nalign, 1);
break;
default:
abort ();
}
break;
default:
abort ();
}
}
/* Here we combine duplicate floating constants to make