procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

emit-rtl.c, [...]: Remove all #ifndef REAL_ARITHMETIC blocks...

Browse source 
* emit-rtl.c, final.c, fold-const.c, gengenrtl.c, optabs.c,
	print-tree.c, real.c, real.h, recog.c, rtl.c, simplify-rtx.c,
	tree.c, config/m68k/m68k.c, f/com.c, f/target.h, java/expr.c,
	java/jcf-parse.c, java/lex.c:
	Remove all #ifndef REAL_ARITHMETIC blocks, make all #ifdef
	REAL_ARITHMETIC blocks unconditional.  Delete some further
	#ifdef blocks predicated on REAL_ARITHMETIC.
	* flags.h, toplev.c: Delete remaining references to
	flag_pretend_float.

	* doc/invoke.texi: Remove documentation of -fpretend-float.
	* doc/tm.texi: Describe the various REAL_* macros as provided by
	real.h, not by the target configuration files.

	* config/alpha/alpha.h, config/alpha/unicosmk.h, config/arm/arm.h,
	config/avr/avr.h, config/c4x/c4x.h, config/convex/convex.h,
	config/cris/cris.h, config/d30v/d30v.h, config/dsp16xx/dsp16xx.h,
	config/h8300/h8300.h, config/i370/i370.h, config/i386/i386.h,
	config/i386/osf1elf.h, config/i960/i960.h, config/ia64/ia64.h,
	config/m32r/m32r.h, config/m68hc11/m68hc11.h, config/m68k/dpx2.h,
	config/m68k/linux-aout.h, config/m68k/linux.h, config/m68k/m68k.h,
	config/m68k/sun3.h, config/m68k/vxm68k.h, config/mcore/mcore.h,
	config/mips/mips.h, config/mmix/mmix.h, config/mn10200/mn10200.h,
	config/mn10300/mn10300.h, config/pa/pa.h, config/pj/pj.h,
	config/rs6000/rs6000.h, config/s390/s390.h, config/sh/sh.h,
	config/sparc/freebsd.h, config/sparc/linux.h, config/sparc/linux64.h,
	config/sparc/sol2.h, config/sparc/sparc.h, config/sparc/vxsim.h,
	config/stormy16/stormy16.h, config/v850/v850.h, config/vax/vax.h,
	config/xtensa/xtensa.h:
	Do not define, undefine, or mention in comments any of
	REAL_ARITHMETIC, REAL_VALUE_ATOF, REAL_VALUE_HTOF,
	REAL_VALUE_ISNAN, REAL_VALUE_ISINF,
	REAL_VALUE_TO_TARGET_SINGLE, REAL_VALUE_TO_TARGET_DOUBLE,
	REAL_VALUE_TO_TARGET_LONG_DOUBLE, REAL_VALUE_TO_DECIMAL,
	REAL_VALUE_TYPE, REAL_VALUES_EQUAL, REAL_VALUES_LESS,
	REAL_VALUE_LDEXP, REAL_VALUE_FIX, REAL_VALUE_UNSIGNED_FIX,
	REAL_VALUE_RNDZINT, REAL_VALUE_UNSIGNED_RNDZINT,
	REAL_INFINITY, REAL_VALUE_NEGATE, REAL_VALUE_TRUNCATE,
	REAL_VALUE_TO_INT, or REAL_VALUE_FROM_INT.

From-SVN: r50263
This commit is contained in:
Zack Weinberg 2002-03-03 21:10:09 +00:00
parent e98f0f5c13
commit ba31d94ee6
72 changed files with 124 additions and 2037 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

57
gcc/ChangeLog
View file

@ -1,3 +1,44 @@
2002-03-03 Zack Weinberg <zack@codesourcery.com>
* emit-rtl.c, final.c, fold-const.c, gengenrtl.c, optabs.c,
print-tree.c, real.c, real.h, recog.c, rtl.c, simplify-rtx.c,
tree.c, config/m68k/m68k.c:
Remove all #ifndef REAL_ARITHMETIC blocks, make all #ifdef
REAL_ARITHMETIC blocks unconditional. Delete some further
#ifdef blocks predicated on REAL_ARITHMETIC.
* flags.h, toplev.c: Delete remaining references to
flag_pretend_float.
* doc/invoke.texi: Remove documentation of -fpretend-float.
* doc/tm.texi: Describe the various REAL_* macros as provided by
real.h, not by the target configuration files.
* config/alpha/alpha.h, config/alpha/unicosmk.h, config/arm/arm.h,
config/avr/avr.h, config/c4x/c4x.h, config/convex/convex.h,
config/cris/cris.h, config/d30v/d30v.h, config/dsp16xx/dsp16xx.h,
config/h8300/h8300.h, config/i370/i370.h, config/i386/i386.h,
config/i386/osf1elf.h, config/i960/i960.h, config/ia64/ia64.h,
config/m32r/m32r.h, config/m68hc11/m68hc11.h, config/m68k/dpx2.h,
config/m68k/linux-aout.h, config/m68k/linux.h, config/m68k/m68k.h,
config/m68k/sun3.h, config/m68k/vxm68k.h, config/mcore/mcore.h,
config/mips/mips.h, config/mmix/mmix.h, config/mn10200/mn10200.h,
config/mn10300/mn10300.h, config/pa/pa.h, config/pj/pj.h,
config/rs6000/rs6000.h, config/s390/s390.h, config/sh/sh.h,
config/sparc/freebsd.h, config/sparc/linux.h, config/sparc/linux64.h,
config/sparc/sol2.h, config/sparc/sparc.h, config/sparc/vxsim.h,
config/stormy16/stormy16.h, config/v850/v850.h, config/vax/vax.h,
config/xtensa/xtensa.h:
Do not define, undefine, or mention in comments any of
REAL_ARITHMETIC, REAL_VALUE_ATOF, REAL_VALUE_HTOF,
REAL_VALUE_ISNAN, REAL_VALUE_ISINF,
REAL_VALUE_TO_TARGET_SINGLE, REAL_VALUE_TO_TARGET_DOUBLE,
REAL_VALUE_TO_TARGET_LONG_DOUBLE, REAL_VALUE_TO_DECIMAL,
REAL_VALUE_TYPE, REAL_VALUES_EQUAL, REAL_VALUES_LESS,
REAL_VALUE_LDEXP, REAL_VALUE_FIX, REAL_VALUE_UNSIGNED_FIX,
REAL_VALUE_RNDZINT, REAL_VALUE_UNSIGNED_RNDZINT,
REAL_INFINITY, REAL_VALUE_NEGATE, REAL_VALUE_TRUNCATE,
REAL_VALUE_TO_INT, or REAL_VALUE_FROM_INT.
2002-03-03 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* 1750a.h, a29k.h, alpha.h, arc.h, arm.h, avr.h, c4x.h, clipper.h,
@ -8,7 +49,7 @@
stormy16.h, v850.h, vax.h, we32k.h, xtensa.h (BITS_PER_WORD):
Delete.
* defaults.h (BITS_PER_WORD): Define.
* doc/tm.texi (BITS_PER_WORD): Document default value.
* doc/tm.texi (BITS_PER_WORD): Document default value.
* 1750a.h, avr.h, convex.h, d30v.h, dsp16xx.h, fr30.h, ia64.h,
m68hc11.h, m88k.h, mips.h, pdp11.h, rs6000.h, sparc.c,
@ -32,7 +73,7 @@
* ggc-page.c (NUM_EXTRA_ORDERS): Likewise.
* lcm.c (N_ENTITIES): Likewise.
* stor-layout.c (set_sizetype): Likewise.
2002-03-03 Richard Henderson <rth@redhat.com>
* toplev.c (rest_of_decl_compilation): Do not invoke make_decl_rtl
@ -74,7 +115,7 @@
* config/darwin-protos.h, config/darwin.c, config/darwin.h,
config/a29k/a29k.h, config/alpha/alpha-protos.h, config/alpha/alpha.c,
config/alpha/alpha.h, config/arc/arc.h, config/arm/arm-protos.h,
config/alpha/alpha.h, config/arc/arc.h, config/arm/arm-protos.h,
config/arm/arm.h, config/arm/pe.c, config/arm/pe.h,
config/avr/avr-protos.h, config/avr/avr.c, config/avr/avr.h,
config/c4x/c4x-protos.h, config/c4x/c4x.c, config/c4x/c4x.h,
@ -84,12 +125,12 @@
config/i386/osfrose.h, config/i386/win32.h, config/i386/winnt.c,
config/ia64/ia64-protos.h, config/ia64/ia64.c, config/ia64/ia64.h,
config/m32r/m32r-protos.h, config/m32r/m32r.c, config/m32r/m32r.h,
config/m68hc11/m68hc11-protos.h, config/m68hc11/m68hc11.c,
config/m68hc11/m68hc11.h, config/m88k/m88k.h,
config/m68hc11/m68hc11-protos.h, config/m68hc11/m68hc11.c,
config/m68hc11/m68hc11.h, config/m88k/m88k.h,
config/mcore/mcore-protos.h, config/mcore/mcore.c,
config/mcore/mcore.h, config/mips/mips.h, config/ns32k/ns32k.h,
config/pa/pa.h, config/romp/romp.h, config/rs6000/linux64.h,
config/rs6000/rs6000-protos.h, config/rs6000/rs6000.c,
config/rs6000/rs6000-protos.h, config/rs6000/rs6000.c,
config/rs6000/sysv4.h, config/rs6000/xcoff.h, config/s390/s390.h,
config/sh/sh.h, config/sparc/sparc.h,
config/stormy16/stormy16-protos.h, config/stormy16/stormy16.c,
@ -97,7 +138,7 @@
config/xtensa/xtensa.h, doc/tm.texi: ENCODE_SECTION_INFO now takes
FIRST argument. As needed, examine it and do nothing.
* config/darwin.h, config/alpha/alpha.h, config/arm/pe.h,
* config/darwin.h, config/alpha/alpha.h, config/arm/pe.h,
config/i386/cygwin.h, config/ia64/ia64.h, config/m68hc11/m68hc11.h,
config/mcore/mcore.h: Remove REDO_SECTION_INFO_P.
@ -380,7 +421,7 @@ objc:
2002-02-27 Andrew MacLeod <amacleod@redhat.com>
* dwarf2out.c (stack_adjust_offset): Add support for POST_INC,
* dwarf2out.c (stack_adjust_offset): Add support for POST_INC,
POST_DEC, and POST_MODIFY.
2002-02-27 Zack Weinberg <zack@codesourcery.com>

3
gcc/config/alpha/alpha.h
View file

@ -409,9 +409,6 @@ extern const char *alpha_mlat_string; /* For -mmemory-latency= */
/* target machine storage layout */
/* Define to enable software floating point emulation. */
#define REAL_ARITHMETIC
/* Define the size of `int'. The default is the same as the word size. */
#define INT_TYPE_SIZE 32

15
gcc/config/alpha/unicosmk.h
View file

@ -35,13 +35,6 @@ Boston, MA 02111-1307, USA. */
#undef CPP_PREDEFINES
#define CPP_PREDEFINES "-D__unix=1 -D_UNICOS=205 -D_CRAY=1 -D_CRAYT3E=1 -D_CRAYMPP=1 -D_CRAYIEEE=1 -D_ADDR64=1 -D_LD64=1 -D__UNICOSMK__ -D__INT_MAX__=9223372036854775807 -D__SHRT_MAX__=2147483647"
/* Disable software floating point emulation because it requires a 16-bit
type which we do not have. */
#ifndef __GNUC__
#undef REAL_ARITHMETIC
#endif
#define SHORT_TYPE_SIZE 32
#undef INT_TYPE_SIZE
@ -568,14 +561,6 @@ ssib_section () \
#undef ASM_OUTPUT_MAX_SKIP_ALIGN
#define ASM_OUTPUT_MAX_SKIP_ALIGN(STREAM,POWER,MAXSKIP)
/* We have to define these because we do not use the floating-point
emulation. Unfortunately, atof does not accept hex literals. */
#ifndef REAL_ARITHMETIC
#define REAL_VALUE_ATOF(x,s) atof(x)
#define REAL_VALUE_HTOF(x,s) atof(x)
#endif
#undef NM_FLAGS
#undef OBJECT_FORMAT_COFF

4
gcc/config/arc/arc.h
View file

@ -168,10 +168,6 @@ do { \
/* Target machine storage layout. */
/* Define to use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields. */
#define BITS_BIG_ENDIAN 1

8
gcc/config/arm/arm.h
View file

@ -647,8 +647,6 @@ extern int arm_is_6_or_7;
/* This is required to ensure that push insns always push a word. */
#define PROMOTE_FUNCTION_ARGS
/* Define for XFmode extended real floating point support.
This will automatically cause REAL_ARITHMETIC to be defined. */
/* For the ARM:
I think I have added all the code to make this work. Unfortunately,
early releases of the floating point emulation code on RISCiX used a
@ -663,12 +661,6 @@ extern int arm_is_6_or_7;
/* Disable XFmode patterns in md file */
#define ENABLE_XF_PATTERNS 0
/* Define if you don't want extended real, but do want to use the
software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
/* See comment above */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields. */
#define BITS_BIG_ENDIAN 0

4
gcc/config/avr/avr.h
View file

@ -2915,10 +2915,6 @@ extern struct rtx_def *ldi_reg_rtx;
#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
/* Define to use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
#define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
/* Get the standard ELF stabs definitions. */

5
gcc/config/c4x/c4x.h
View file

@ -360,11 +360,6 @@ extern const char *c4x_rpts_cycles_string, *c4x_cpu_version_string;
#define BITS_PER_HIGH 16
#define BITS_PER_LO_SUM 16
/* Use the internal floating point stuff in the compiler and not the
host floating point stuff. */
#define REAL_ARITHMETIC
/* Define register numbers. */
/* Extended-precision registers. */

15
gcc/config/convex/convex.h
View file

@ -409,18 +409,6 @@ extern int target_flags;
#define LINK_LIBGCC_SPECIAL_1
/* Since IEEE support was added to gcc, most things seem to like it
better if we disable exceptions and check afterward for infinity. */
#if __convex__
#if _IEEE_FLOAT_
#define REAL_VALUE_ISNAN(x) 0
#define REAL_VALUE_ISINF(x) ((*(short *) &(x) & 0x7ff0) == 0x7ff0)
#else
#define REAL_VALUE_ISNAN(x) 0
#define REAL_VALUE_ISINF(x) ((*(short *) &(x) & 0xfff0) == 0x8000)
#endif
#endif
/* Target machine storage layout */
@ -1089,9 +1077,6 @@ enum reg_class {
Follow the host format. */
#define TARGET_FLOAT_FORMAT HOST_FLOAT_FORMAT
/* But must prevent real.c from constructing VAX dfloats */
#define REAL_VALUE_ATOF(X,S) atof (X)
/* Check a `double' value for validity for a particular machine mode. */
#define CHECK_FLOAT_VALUE(MODE, D, OVERFLOW) \
(OVERFLOW = check_float_value (MODE, &D, OVERFLOW))

4
gcc/config/cris/cris.h
View file

@ -1746,10 +1746,6 @@ call_ ## FUNC (void) \
/* Node: SDB and DWARF */
/* (no definitions) */
/* Node: Cross-compilation */
#define REAL_ARITHMETIC
/* Node: Misc */
/* FIXME: Check this one more time. */

159
gcc/config/d30v/d30v.h
View file

@ -3000,27 +3000,6 @@ extern const char *d30v_branch_cost_string;
/* These macros are provided by `real.h' for writing the definitions of
`ASM_OUTPUT_DOUBLE' and the like: */
/* 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. */
/* #define REAL_VALUE_TO_TARGET_SINGLE(X, L) */
/* #define REAL_VALUE_TO_TARGET_DOUBLE(X, L) */
/* #define REAL_VALUE_TO_TARGET_LONG_DOUBLE(X, L) */
/* 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. */
/* #define REAL_VALUE_TO_DECIMAL(X, FORMAT, STRING) */
/* Output of Uninitialized Variables. */
@ -4139,144 +4118,6 @@ fprintf (STREAM, "\t.word .L%d\n", VALUE)
/* #define SDB_ALLOW_FORWARD_REFERENCES */
/* Cross Compilation and Floating Point. */
/* While all modern machines use 2's complement representation for integers,
there are a variety of representations for floating point numbers. This
means that in a cross-compiler the representation of floating point numbers
in the compiled program may be different from that used in the machine doing
the compilation.
Because different representation systems may offer different amounts of
range and precision, the cross compiler cannot safely use the host machine's
floating point arithmetic. Therefore, floating point constants must be
represented in the target machine's format. This means that the cross
compiler cannot use `atof' to parse a floating point constant; it must have
its own special routine to use instead. Also, constant folding must emulate
the target machine's arithmetic (or must not be done at all).
The macros in the following table should be defined only if you are cross
compiling between different floating point formats.
Otherwise, don't define them. Then default definitions will be set up which
use `double' as the data type, `==' to test for equality, etc.
You don't need to worry about how many times you use an operand of any of
these macros. The compiler never uses operands which have side effects. */
/* A macro for the C data type to be used to hold a floating point value in the
target machine's format. Typically this would be a `struct' containing an
array of `int'. */
/* #define REAL_VALUE_TYPE */
/* A macro for a C expression which compares for equality the two values, X and
Y, both of type `REAL_VALUE_TYPE'. */
/* #define REAL_VALUES_EQUAL(X, Y) */
/* A macro for a C expression which tests whether X is less than Y, both values
being of type `REAL_VALUE_TYPE' and interpreted as floating point numbers in
the target machine's representation. */
/* #define REAL_VALUES_LESS(X, Y) */
/* A macro for a C expression which performs the standard library function
`ldexp', but using the target machine's floating point representation. Both
X and the value of the expression have type `REAL_VALUE_TYPE'. The second
argument, SCALE, is an integer. */
/* #define REAL_VALUE_LDEXP(X, SCALE) */
/* A macro whose definition is a C expression to convert the target-machine
floating point value X to a signed integer. X has type `REAL_VALUE_TYPE'. */
/* #define REAL_VALUE_FIX(X) */
/* A macro whose definition is a C expression to convert the target-machine
floating point value X to an unsigned integer. X has type
`REAL_VALUE_TYPE'. */
/* #define REAL_VALUE_UNSIGNED_FIX(X) */
/* A macro whose definition is a C expression to round the target-machine
floating point value X towards zero to an integer value (but still as a
floating point number). X has type `REAL_VALUE_TYPE', and so does the
value. */
/* #define REAL_VALUE_RNDZINT(X) */
/* A macro whose definition is a C expression to round the target-machine
floating point value X towards zero to an unsigned integer value (but still
represented as a floating point number). X has type `REAL_VALUE_TYPE', and
so does the value. */
/* #define REAL_VALUE_UNSIGNED_RNDZINT(X) */
/* A macro for a C expression which converts STRING, an expression of type
`char *', into a floating point number in the target machine's
representation for mode MODE. The value has type `REAL_VALUE_TYPE'. */
/* #define REAL_VALUE_ATOF(STRING, MODE) */
/* Define this macro if infinity is a possible floating point value, and
therefore division by 0 is legitimate. */
/* #define REAL_INFINITY */
/* A macro for a C expression which determines whether X, a floating point
value, is infinity. The value has type `int'. By default, this is defined
to call `isinf'. */
/* #define REAL_VALUE_ISINF(X) */
/* A macro for a C expression which determines whether X, a floating point
value, is a "nan" (not-a-number). The value has type `int'. By default,
this is defined to call `isnan'. */
/* #define REAL_VALUE_ISNAN(X) */
/* Define the following additional macros if you want to make floating point
constant folding work while cross compiling. If you don't define them,
cross compilation is still possible, but constant folding will not happen
for floating point values. */
/* A macro for a C statement which calculates an arithmetic operation of the
two floating point values X and Y, both of type `REAL_VALUE_TYPE' in the
target machine's representation, to produce a result of the same type and
representation which is stored in OUTPUT (which will be a variable).
The operation to be performed is specified by CODE, a tree code which will
always be one of the following: `PLUS_EXPR', `MINUS_EXPR', `MULT_EXPR',
`RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'.
The expansion of this macro is responsible for checking for overflow. If
overflow happens, the macro expansion should execute the statement `return
0;', which indicates the inability to perform the arithmetic operation
requested. */
/* #define REAL_ARITHMETIC(OUTPUT, CODE, X, Y) */
/* The real.h file actually defines REAL_ARITHMETIC appropriately if it was
defined at all before entering into the code, by using #undef first. */
#define REAL_ARITHMETIC
/* A macro for a C expression which returns the negative of the floating point
value X. Both X and the value of the expression have type `REAL_VALUE_TYPE'
and are in the target machine's floating point representation.
There is no way for this macro to report overflow, since overflow can't
happen in the negation operation. */
/* #define REAL_VALUE_NEGATE(X) */
/* A macro for a C expression which converts the floating point value X to mode
MODE.
Both X and the value of the expression are in the target machine's floating
point representation and have type `REAL_VALUE_TYPE'. However, the value
should have an appropriate bit pattern to be output properly as a floating
constant whose precision accords with mode MODE.
There is no way for this macro to report overflow. */
/* #define REAL_VALUE_TRUNCATE(MODE, X) */
/* A macro for a C expression which converts a floating point value X into a
double-precision integer which is then stored into LOW and HIGH, two
variables of type INT. */
/* #define REAL_VALUE_TO_INT(LOW, HIGH, X) */
/* A macro for a C expression which converts a double-precision integer found
in LOW and HIGH, two variables of type INT, into a floating point value
which is then stored into X. */
/* #define REAL_VALUE_FROM_INT(X, LOW, HIGH) */
/* Miscellaneous Parameters. */

5
gcc/config/dsp16xx/dsp16xx.h
View file

@ -294,11 +294,6 @@ extern int target_flags;
/* STORAGE LAYOUT */
/* Define if you don't want extended real, but do want to use the
software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields.
*/

4
gcc/config/h8300/h8300.h
View file

@ -180,10 +180,6 @@ extern int target_flags;
/* Target machine storage layout */
/* Define to use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields.
This is not true on the H8/300. */

8
gcc/config/i370/linux.h
View file

@ -28,14 +28,6 @@ Boston, MA 02111-1307, USA. */
#define TARGET_ELF_ABI
#define LINUX_DEFAULT_ELF
/* hack alert define to get dbx/gdb/dwarf to compile */
/* problem is that host float format is not target float format. */
/* define REAL_ARITHMETIC for software emulation of float to
* int conversion. This seems to have somethings to do with
* cross-compiling ... */
#define REAL_ARITHMETIC
/* Include system common definitions */
/* TODO: convert include to ${tm_file} list in config.gcc. */
#include "i370/i370.h"

7
gcc/config/i386/i386.h
View file

@ -669,8 +669,6 @@ extern int ix86_arch;
/* target machine storage layout */
/* Define for XFmode or TFmode extended real floating point support.
This will automatically cause REAL_ARITHMETIC to be defined.
The XFmode is specified by i386 ABI, while TFmode may be faster
due to alignment and simplifications in the address calculations.
*/
@ -702,11 +700,6 @@ extern int ix86_arch;
#define MAX_LONG_TYPE_SIZE 32
#endif
/* Define if you don't want extended real, but do want to use the
software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
/* #define REAL_ARITHMETIC */
/* Define this if most significant byte of a word is the lowest numbered. */
/* That is true on the 80386. */

6
gcc/config/i386/osf1elf.h
View file

@ -205,9 +205,3 @@ do \
} \
} \
while (0)
#if defined (CROSS_COMPILE) && defined (HOST_BITS_PER_INT) && defined (HOST_BITS_PER_LONG) && defined (HOST_BITS_PER_LONGLONG)
#if (HOST_BITS_PER_INT==32) && (HOST_BITS_PER_LONG==64) && (HOST_BITS_PER_LONGLONG==64)
#define REAL_ARITHMETIC
#endif
#endif

4
gcc/config/i960/i960.h
View file

@ -380,10 +380,6 @@ extern int target_flags;
/* Target machine storage layout. */
/* Define for cross-compilation from a host with a different float format
or endianness, as well as to support 80 bit long doubles on the i960. */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields. */
#define BITS_BIG_ENDIAN 0

6
gcc/config/ia64/ia64.h
View file

@ -2276,12 +2276,6 @@ do { \
assemble_name (FILE, LABEL); \
fputc (')', FILE); \
} while (0)
/* Cross Compilation and Floating Point. */
/* Define to enable software floating point emulation. */
#define REAL_ARITHMETIC
/* Register Renaming Parameters. */

4
gcc/config/m32r/m32r.h
View file

@ -421,10 +421,6 @@ extern enum m32r_sdata m32r_sdata;
/* Target machine storage layout. */
/* Define to use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields. */
#define BITS_BIG_ENDIAN 1

5
gcc/config/m68hc11/m68hc11.h
View file

@ -244,11 +244,6 @@ extern const struct processor_costs *m68hc11_cost;
/* Width of a word, in units (bytes). */
#define UNITS_PER_WORD 2
/* Define if you don't want extended real, but do want to use the
software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
/* Width in bits of a pointer. See also the macro `Pmode' defined below. */
#define POINTER_SIZE 16

5
gcc/config/m68k/dpx2.h
View file

@ -113,11 +113,6 @@ Boston, MA 02111-1307, USA. */
#undef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE 64
/* Define if you don't want extended real, but do want to use the
software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
#undef ASM_OUTPUT_SOURCE_FILENAME
#define ASM_OUTPUT_SOURCE_FILENAME(FILE, NA) \
do { fprintf ((FILE), "\t.file\t'%s'\n", (NA)); } while (0)

3
gcc/config/m68k/linux-aout.h
View file

@ -73,6 +73,3 @@ Boston, MA 02111-1307, USA. */
/* Don't default to pcc-struct-return, because gcc is the only compiler. */
#undef PCC_STATIC_STRUCT_RETURN
#define DEFAULT_PCC_STRUCT_RETURN 0
/* Allow folding division by zero. */
#define REAL_INFINITY

3
gcc/config/m68k/linux.h
View file

@ -247,9 +247,6 @@ Boston, MA 02111-1307, USA. */
#define DBX_CONTIN_LENGTH 0
/* Allow folding division by zero. */
#define REAL_INFINITY
/* 1 if N is a possible register number for a function value. For
m68k/SVR4 allow d0, a0, or fp0 as return registers, for integral,
pointer, or floating types, respectively. Reject fp0 if not using

21
gcc/config/m68k/m68k.c
View file

@ -3112,13 +3112,6 @@ standard_68881_constant_p (x)
if (TARGET_68040 || TARGET_68060)
return 0;
#ifndef REAL_ARITHMETIC
#if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
if (! flag_pretend_float)
return 0;
#endif
#endif
if (! inited_68881_table)
init_68881_table ();
@ -3153,13 +3146,6 @@ floating_exact_log2 (x)
REAL_VALUE_TYPE r, r1;
int i;
#ifndef REAL_ARITHMETIC
#if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
if (! flag_pretend_float)
return 0;
#endif
#endif
REAL_VALUE_FROM_CONST_DOUBLE (r, x);
if (REAL_VALUES_LESS (r, dconst0))
@ -3305,13 +3291,6 @@ standard_sun_fpa_constant_p (x)
REAL_VALUE_TYPE r;
int i;
#ifndef REAL_ARITHMETIC
#if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
if (! flag_pretend_float)
return 0;
#endif
#endif
if (! inited_FPA_table)
init_FPA_table ();

8
gcc/config/m68k/m68k.h
View file

@ -294,15 +294,9 @@ extern int target_flags;
/* target machine storage layout */
/* Define for XFmode extended real floating point support.
This will automatically cause REAL_ARITHMETIC to be defined. */
/* Define for XFmode extended real floating point support. */
#define LONG_DOUBLE_TYPE_SIZE 96
/* Define if you don't want extended real, but do want to use the
software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
/* #define REAL_ARITHMETIC */
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields.
This is true for 68020 insns such as bfins and bfexts.

4
gcc/config/m68k/netbsd-elf.h
View file

@ -34,10 +34,6 @@ Boston, MA 02111-1307, USA. */
#if TARGET_DEFAULT == 0
#undef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE 64
/* Use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
#endif
#ifdef __mc68010__

3
gcc/config/m68k/sun3.h
View file

@ -163,9 +163,6 @@ Boston, MA 02111-1307, USA. */
#define DBX_DEBUGGING_INFO
/* Allow folding division by zero. */
#define REAL_INFINITY
/* Generate calls to memcpy, memcmp and memset. */
#define TARGET_MEM_FUNCTIONS

3
gcc/config/m68k/vxm68k.h
View file

@ -94,9 +94,6 @@ Unrecognized value in TARGET_CPU_DEFAULT.
#define STRUCTURE_SIZE_BOUNDARY 16
/* Allow folding division by zero. */
#define REAL_INFINITY
/* GCC is the primary compiler for VxWorks, so we don't need this. */
#undef PCC_STATIC_STRUCT_RETURN

4
gcc/config/mcore/mcore.h
View file

@ -214,10 +214,6 @@ extern const char * mcore_stack_increment_string;
/* Target machine storage Layout. */
/* Define to use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \
if (GET_MODE_CLASS (MODE) == MODE_INT \
&& GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \

4
gcc/config/mips/mips.h
View file

@ -1546,10 +1546,6 @@ do { \
/* Target machine storage layout */
/* Define in order to support both big and little endian float formats
in the same gcc binary. */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields.
*/

11
gcc/config/mmix/mmix.h
View file

@ -1154,17 +1154,6 @@ const_section () \
#define DWARF2_DEBUGGING_INFO
#define DWARF2_ASM_LINE_DEBUG_INFO 1
/* Node: Cross-compilation */
/* FIXME: I don't know whether it is best to tweak emit-rtl.c to handle
the case where sizeof (float) == word_size / 2 on the target, or to fix
real.h to define REAL_ARITHMETIC in that case. Anyway, it should be
documented that a target can define this to force emulation. Note that
we don't check #ifdef CROSS_COMPILE here; not even if mmix gets
self-hosted must we do that. Case gcc.c-torture/compile/930611-1.c. */
#define REAL_ARITHMETIC
/* Node: Misc */
#define PREDICATE_CODES \

4
gcc/config/mn10200/mn10200.h
View file

@ -915,10 +915,6 @@ struct cum_arg { int nbytes; };
((GET_CODE (X) == PLUS ? OFFSET : 0) \
+ (frame_pointer_needed ? 0 : -total_frame_size ()))
/* Define to use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
/* Specify the machine mode that this machine uses
for the index in the tablejump instruction. */
#define CASE_VECTOR_MODE Pmode

4
gcc/config/mn10300/mn10300.h
View file

@ -1013,10 +1013,6 @@ struct cum_arg {int nbytes; };
+ (frame_pointer_needed \
? 0 : -initial_offset (ARG_POINTER_REGNUM, STACK_POINTER_REGNUM)))
/* Define to use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
/* Specify the machine mode that this machine uses
for the index in the tablejump instruction. */
#define CASE_VECTOR_MODE Pmode

4
gcc/config/pa/pa.h
View file

@ -362,10 +362,6 @@ extern int target_flags;
/* target machine storage layout */
/* Define for cross-compilation from a host with a different float format
or endianness (e.g. VAX, x86). */
#define REAL_ARITHMETIC
/* Define this macro if it is advisable to hold scalars in registers
in a wider mode than that declared by the program. In such cases,
the value is constrained to be within the bounds of the declared

4
gcc/config/pj/pj.h
View file

@ -110,10 +110,6 @@ extern int target_flags;
/* Target machine storage layout. */
/* Define to use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields. */
#define BITS_BIG_ENDIAN 0

3
gcc/config/rs6000/rs6000.h
View file

@ -483,9 +483,6 @@ extern int rs6000_altivec_abi;
/* target machine storage layout */
/* Define to support cross compilation to an RS6000 target. */
#define REAL_ARITHMETIC
/* Define this macro if it is advisable to hold scalars in registers
in a wider mode than that declared by the program. In such cases,
the value is constrained to be within the bounds of the declared

6
gcc/config/s390/s390.h
View file

@ -78,7 +78,7 @@ extern int target_flags;
#define OVERRIDE_OPTIONS override_options ()
/* Defines for REAL_ARITHMETIC. */
/* Defines for real.c. */
#define IEEE_FLOAT 1
#define TARGET_IBM_FLOAT 0
#define TARGET_IEEE_FLOAT 1
@ -201,10 +201,6 @@ if (INTEGRAL_MODE_P (MODE) && \
#define STRICT_ALIGNMENT 0
/* real arithmetic */
#define REAL_ARITHMETIC
/* Define target floating point format. */
#undef TARGET_FLOAT_FORMAT

4
gcc/config/sh/sh.h
View file

@ -406,10 +406,6 @@ do { \
/* Target machine storage layout. */
/* Define to use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields. */

2
gcc/config/sparc/freebsd.h
View file

@ -56,7 +56,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#undef WCHAR_TYPE_SIZE
#define WCHAR_TYPE_SIZE 32
/* Define for support of TFmode long double and REAL_ARITHMETIC.
/* Define for support of TFmode long double.
Sparc ABI says that long double is 4 words. */
#undef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64)

2
gcc/config/sparc/linux.h
View file

@ -228,7 +228,7 @@ do { \
sprintf (LABEL, "*.L%s%ld", PREFIX, (long)(NUM))
/* Define for support of TFmode long double and REAL_ARITHMETIC.
/* Define for support of TFmode long double.
Sparc ABI says that long double is 4 words. */
#define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64)

2
gcc/config/sparc/linux64.h
View file

@ -146,7 +146,7 @@ Boston, MA 02111-1307, USA. */
#undef MAX_WCHAR_TYPE_SIZE
/* Define for support of TFmode long double and REAL_ARITHMETIC.
/* Define for support of TFmode long double.
Sparc ABI says that long double is 4 words. */
#undef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64)

2
gcc/config/sparc/sol2.h
View file

@ -196,7 +196,7 @@ Boston, MA 02111-1307, USA. */
/* ??? This does not work in SunOS 4.x, so it is not enabled in sparc.h.
Instead, it is enabled here, because it does work under Solaris. */
/* Define for support of TFmode long double and REAL_ARITHMETIC.
/* Define for support of TFmode long double.
Sparc ABI says that long double is 4 words. */
#define LONG_DOUBLE_TYPE_SIZE 128

6
gcc/config/sparc/sparc.h
View file

@ -687,10 +687,6 @@ extern struct sparc_cpu_select sparc_select[];
/* target machine storage layout */
/* Define for cross-compilation to a sparc target with no TFmode from a host
with a different float format (e.g. VAX). */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields. */
#define BITS_BIG_ENDIAN 1
@ -732,7 +728,7 @@ extern struct sparc_cpu_select sparc_select[];
#if 0
/* ??? This does not work in SunOS 4.x, so it is not enabled here.
Instead, it is enabled in sol2.h, because it does work under Solaris. */
/* Define for support of TFmode long double and REAL_ARITHMETIC.
/* Define for support of TFmode long double.
Sparc ABI says that long double is 4 words. */
#define LONG_DOUBLE_TYPE_SIZE 128
#endif

2
gcc/config/sparc/vxsim.h
View file

@ -128,6 +128,6 @@ do { \
/* ??? This does not work in SunOS 4.x, so it is not enabled in sparc.h.
Instead, it is enabled here, because it does work under Solaris. */
/* Define for support of TFmode long double and REAL_ARITHMETIC.
/* Define for support of TFmode long double.
Sparc ABI says that long double is 4 words. */
#define LONG_DOUBLE_TYPE_SIZE 64

28
gcc/config/stormy16/stormy16.h
View file

@ -2808,30 +2808,6 @@ do { \
is treated as a logical line separator. */
#define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == '|')
/* These macros are provided by `real.h' for writing the definitions of
`ASM_OUTPUT_DOUBLE' and the like: */
/* 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. */
/* #define REAL_VALUE_TO_TARGET_SINGLE(X, L) */
/* #define REAL_VALUE_TO_TARGET_DOUBLE(X, L) */
/* #define REAL_VALUE_TO_TARGET_LONG_DOUBLE(X, L) */
/* 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. */
/* #define REAL_VALUE_TO_DECIMAL(X, FORMAT, STRING) */
/* Output of Uninitialized Variables. */
@ -3859,10 +3835,6 @@ do { \
/* Miscellaneous Parameters. */
/* Define REAL_ARITHMETIC to use a software emulator for the target floating
point mode. Otherwise the host floating point mode is used. */
#define REAL_ARITHMETIC
/* Define this if you have defined special-purpose predicates in the file
`MACHINE.c'. This macro is called within an initializer of an array of
structures. The first field in the structure is the name of a predicate and

4
gcc/config/v850/v850.h
View file

@ -1360,10 +1360,6 @@ do { \
#undef PREFERRED_DEBUGGING_TYPE
#define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
/* Define to use software floating point emulator for REAL_ARITHMETIC and
decimal <-> binary conversion. */
#define REAL_ARITHMETIC
/* Specify the machine mode that this machine uses
for the index in the tablejump instruction. */
#define CASE_VECTOR_MODE (TARGET_BIG_SWITCH ? SImode : HImode)

2
gcc/config/vax/vax.h
View file

@ -89,8 +89,6 @@ extern int target_flags;
/* Target machine storage layout */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields.
This is not true on the VAX. */

4
gcc/config/xtensa/xtensa.h
View file

@ -221,10 +221,6 @@ extern unsigned xtensa_current_frame_size;
/* Target machine storage layout */
/* Define in order to support both big and little endian float formats
in the same gcc binary. */
#define REAL_ARITHMETIC
/* Define this if most significant bit is lowest numbered
in instructions that operate on numbered bit-fields. */
#define BITS_BIG_ENDIAN (TARGET_BIG_ENDIAN != 0)

10
gcc/doc/invoke.texi
View file

@ -247,7 +247,7 @@ in the following sections.
-fdump-class-hierarchy@r{[}-@var{n}@r{]} @gol
-fdump-tree-original@r{[}-@var{n}@r{]} -fdump-tree-optimized@r{[}-@var{n}@r{]} @gol
-fdump-tree-inlined@r{[}-@var{n}@r{]} @gol
-fmem-report -fpretend-float @gol
-fmem-report @gol
-fprofile-arcs -ftest-coverage -ftime-report @gol
-g -g@var{level} -gcoff -gdwarf -gdwarf-1 -gdwarf-1+ -gdwarf-2 @gol
-ggdb -gstabs -gstabs+ -gvms -gxcoff -gxcoff+ @gol
@ -3042,14 +3042,6 @@ Dump after all tree based optimization, to @file{@var{file}.optimized}.
Dump after function inlining, to @file{@var{file}.inlined}.
@end table
@item -fpretend-float
@opindex fpretend-float
When running a cross-compiler, pretend that the target machine uses the
same floating point format as the host machine. This causes incorrect
output of the actual floating constants, but the actual instruction
sequence will probably be the same as GCC would make when running on
the target machine.
@item -save-temps
@opindex save-temps
Store the usual ``temporary'' intermediate files permanently; place them

23
gcc/doc/tm.texi
View file

@ -7678,14 +7678,10 @@ it must have its own special routine to use instead. Also, constant
folding must emulate the target machine's arithmetic (or must not be done
at all).
The macros in the following table should be defined only if you are cross
compiling between different floating point formats.
Otherwise, don't define them. Then default definitions will be set up which
use @code{double} as the data type, @code{==} to test for equality, etc.
You don't need to worry about how many times you use an operand of any
of these macros. The compiler never uses operands which have side effects.
The macros in the following table are provided by @file{real.h} for the
compiler to use. All parts of the compiler which generate or optimize
floating-point calculations must use these macros. They may evaluate
their operands more than once, so operands must not have side effects.
@table @code
@findex REAL_VALUE_TYPE
@ -7766,15 +7762,7 @@ By default, this is defined to call @code{isinf}.
A macro for a C expression which determines whether @var{x}, a floating
point value, is a ``nan'' (not-a-number). The value has type
@code{int}. By default, this is defined to call @code{isnan}.
@end table
@cindex constant folding and floating point
Define the following additional macros if you want to make floating
point constant folding work while cross compiling. If you don't
define them, cross compilation is still possible, but constant folding
will not happen for floating point values.
@table @code
@findex REAL_ARITHMETIC
@item REAL_ARITHMETIC (@var{output}, @var{code}, @var{x}, @var{y})
A macro for a C statement which calculates an arithmetic operation of
@ -7789,8 +7777,7 @@ which will always be one of the following: @code{PLUS_EXPR},
@code{MAX_EXPR}, @code{MIN_EXPR}.
@cindex overflow while constant folding
The expansion of this macro is responsible for checking for overflow.
If overflow happens, the macro expansion should execute the statement
If overflow happens, the macro expansion executes the statement
@code{return 0;}, which indicates the inability to perform the
arithmetic operation requested.

147
gcc/emit-rtl.c
View file

@ -887,94 +887,7 @@ gen_lowpart_common (mode, x)
}
}
#ifndef REAL_ARITHMETIC
/* If X is an integral constant but we want it in floating-point, it
must be the case that we have a union of an integer and a floating-point
value. If the machine-parameters allow it, simulate that union here
and return the result. The two-word and single-word cases are
different. */
else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_MODE_SIZE (mode) == UNITS_PER_WORD
&& GET_CODE (x) == CONST_INT
&& sizeof (float) * HOST_BITS_PER_CHAR == HOST_BITS_PER_WIDE_INT)
{
union {HOST_WIDE_INT i; float d; } u;
u.i = INTVAL (x);
return CONST_DOUBLE_FROM_REAL_VALUE (u.d, mode);
}
else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
&& (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)
&& GET_MODE (x) == VOIDmode
&& (sizeof (double) * HOST_BITS_PER_CHAR
== 2 * HOST_BITS_PER_WIDE_INT))
{
union {HOST_WIDE_INT i[2]; double d; } u;
HOST_WIDE_INT low, high;
if (GET_CODE (x) == CONST_INT)
low = INTVAL (x), high = low >> (HOST_BITS_PER_WIDE_INT -1);
else
low = CONST_DOUBLE_LOW (x), high = CONST_DOUBLE_HIGH (x);
#ifdef HOST_WORDS_BIG_ENDIAN
u.i[0] = high, u.i[1] = low;
#else
u.i[0] = low, u.i[1] = high;
#endif
return CONST_DOUBLE_FROM_REAL_VALUE (u.d, mode);
}
/* Similarly, if this is converting a floating-point value into a
single-word integer. Only do this is the host and target parameters are
compatible. */
else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& (GET_MODE_CLASS (mode) == MODE_INT
|| GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
&& GET_CODE (x) == CONST_DOUBLE
&& GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT
&& GET_MODE_BITSIZE (mode) == BITS_PER_WORD)
return constant_subword (x, (offset / UNITS_PER_WORD), GET_MODE (x));
/* Similarly, if this is converting a floating-point value into a
two-word integer, we can do this one word at a time and make an
integer. Only do this is the host and target parameters are
compatible. */
else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& (GET_MODE_CLASS (mode) == MODE_INT
|| GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
&& GET_CODE (x) == CONST_DOUBLE
&& GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT
&& GET_MODE_BITSIZE (mode) == 2 * BITS_PER_WORD)
{
rtx lowpart, highpart;
lowpart = constant_subword (x,
(offset / UNITS_PER_WORD) + WORDS_BIG_ENDIAN,
GET_MODE (x));
highpart = constant_subword (x,
(offset / UNITS_PER_WORD) + (! WORDS_BIG_ENDIAN),
GET_MODE (x));
if (lowpart && GET_CODE (lowpart) == CONST_INT
&& highpart && GET_CODE (highpart) == CONST_INT)
return immed_double_const (INTVAL (lowpart), INTVAL (highpart), mode);
}
#else /* ifndef REAL_ARITHMETIC */
/* When we have a FP emulator, we can handle all conversions between
/* The floating-point emulator can handle all conversions between
FP and integer operands. This simplifies reload because it
doesn't have to deal with constructs like (subreg:DI
(const_double:SF ...)) or (subreg:DF (const_int ...)). */
@ -1076,7 +989,6 @@ gen_lowpart_common (mode, x)
mode);
#endif
}
#endif /* ifndef REAL_ARITHMETIC */
/* Otherwise, we can't do this. */
return 0;
@ -1310,7 +1222,6 @@ constant_subword (op, offset, mode)
&& GET_MODE_SIZE (mode) == UNITS_PER_WORD)
return op;
#ifdef REAL_ARITHMETIC
/* The output is some bits, the width of the target machine's word.
A wider-word host can surely hold them in a CONST_INT. A narrower-word
host can't. */
@ -1389,32 +1300,10 @@ constant_subword (op, offset, mode)
else
abort ();
}
#else /* no REAL_ARITHMETIC */
if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
&& GET_CODE (op) == CONST_DOUBLE)
{
/* The constant is stored in the host's word-ordering,
but we want to access it in the target's word-ordering. Some
compilers don't like a conditional inside macro args, so we have two
copies of the return. */
#ifdef HOST_WORDS_BIG_ENDIAN
return GEN_INT (offset == WORDS_BIG_ENDIAN
? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op));
#else
return GEN_INT (offset != WORDS_BIG_ENDIAN
? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op));
#endif
}
#endif /* no REAL_ARITHMETIC */
/* Single word float is a little harder, since single- and double-word
values often do not have the same high-order bits. We have already
verified that we want the only defined word of the single-word value. */
#ifdef REAL_ARITHMETIC
if (GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_MODE_BITSIZE (mode) == 32
&& GET_CODE (op) == CONST_DOUBLE)
@ -1438,40 +1327,6 @@ constant_subword (op, offset, mode)
return GEN_INT (val);
}
#else
if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& sizeof (float) * 8 == HOST_BITS_PER_WIDE_INT
&& GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_MODE_SIZE (mode) == UNITS_PER_WORD
&& GET_CODE (op) == CONST_DOUBLE)
{
double d;
union {float f; HOST_WIDE_INT i; } u;
REAL_VALUE_FROM_CONST_DOUBLE (d, op);
u.f = d;
return GEN_INT (u.i);
}
if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
&& HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
|| flag_pretend_float)
&& sizeof (double) * 8 == HOST_BITS_PER_WIDE_INT
&& GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_MODE_SIZE (mode) == UNITS_PER_WORD
&& GET_CODE (op) == CONST_DOUBLE)
{
double d;
union {double d; HOST_WIDE_INT i; } u;
REAL_VALUE_FROM_CONST_DOUBLE (d, op);
u.d = d;
return GEN_INT (u.i);
}
#endif /* no REAL_ARITHMETIC */
/* The only remaining cases that we can handle are integers.
Convert to proper endianness now since these cases need it.

6
gcc/f/ChangeLog
View file

@ -1,3 +1,9 @@
2002-03-03 Zack Weinberg <zack@codesourcery.com>
* com.c, target.h: Remove all #ifndef REAL_ARITHMETIC
blocks, make all #ifdef REAL_ARITHMETIC blocks unconditional.
Delete some further #ifdef blocks predicated on REAL_ARITHMETIC.
Thu Feb 28 07:53:46 2002 Neil Booth <neil@daikokuya.demon.co.uk>
* com.c (copy_lang_decl): Delete.

4
gcc/f/com.c
View file

@ -11799,11 +11799,7 @@ ffecom_init_0 ()
{
REAL_VALUE_TYPE point_5;
#ifdef REAL_ARITHMETIC
REAL_ARITHMETIC (point_5, RDIV_EXPR, dconst1, dconst2);
#else
point_5 = .5;
#endif
ffecom_float_half_ = build_real (float_type_node, point_5);
ffecom_double_half_ = build_real (double_type_node, point_5);
}

290
gcc/f/target.h
View file

@ -38,16 +38,6 @@ the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#endif
#endif
/* For now, g77 requires the ability to determine the exact bit pattern
of a float on the target machine. (Hopefully this will be changed
soon). Make sure we can do this. */
#if !defined (REAL_ARITHMETIC) \
&& ((TARGET_FLOAT_FORMAT != HOST_FLOAT_FORMAT) \
|| (FLOAT_WORDS_BIG_ENDIAN != HOST_FLOAT_WORDS_BIG_ENDIAN))
#error "g77 requires ability to access exact FP representation of target machine"
#endif
/* Simple definitions and enumerations. */
#define FFETARGET_charactersizeNONE (-1)
@ -333,7 +323,6 @@ typedef ? ffetargetLogical8;
?
#endif
#if FFETARGET_okREAL1
#ifdef REAL_ARITHMETIC
#ifdef FFETARGET_32bit_longs
typedef long int ffetargetReal1;
#define ffetargetReal1_f "l"
@ -351,13 +340,8 @@ typedef int ffetargetReal1;
REAL_VALUE_TO_TARGET_SINGLE ((in), _tmp); \
(out) = (ffetargetReal1) _tmp; })
#endif
#else /* REAL_ARITHMETIC */
typedef float ffetargetReal1;
#define ffetargetReal1_f ""
#endif /* REAL_ARITHMETIC */
#endif
#if FFETARGET_okREAL2
#ifdef REAL_ARITHMETIC
#ifdef FFETARGET_32bit_longs
typedef struct
{
@ -387,63 +371,29 @@ ffetargetReal2;
(out)[0] = (int) (_tmp[0]); \
(out)[1] = (int) (_tmp[1]); })
#endif
#else
typedef double ffetargetReal2;
#define ffetargetReal2_f ""
#endif
#endif
#if FFETARGET_okREAL3
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal3[?];
#else
typedef ? ffetargetReal3;
#define ffetargetReal3_f
#endif
?
#endif
#if FFETARGET_okREAL4
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal4[?];
#else
typedef ? ffetargetReal4;
#define ffetargetReal4_f
#endif
?
#endif
#if FFETARGET_okREAL5
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal5[?];
#else
typedef ? ffetargetReal5;
#define ffetargetReal5_f
#endif
?
#endif
#if FFETARGET_okREAL6
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal6[?];
#else
typedef ? ffetargetReal6;
#define ffetargetReal6_f
#endif
?
#endif
#if FFETARGET_okREAL7
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal7[?];
#else
typedef ? ffetargetReal7;
#define ffetargetReal7_f
#endif
?
#endif
#if FFETARGET_okREAL8
#ifdef REAL_ARITHMETIC
typedef long ffetargetReal8[?];
#else
typedef ? ffetargetReal8;
#define ffetargetReal8_f
#endif
?
#endif
#if FFETARGET_okCOMPLEX1
@ -864,7 +814,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0), \
((kt == 1) ? SFmode : DFmode))
#ifdef REAL_ARITHMETIC
#define ffetarget_add_complex1(res,l,r) \
({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
@ -887,19 +836,10 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
FFEBAD; })
#else
#define ffetarget_add_complex1(res,l,r) \
((res)->real = (l).real + (r).real, \
(res)->imaginary = (l).imaginary + (r).imaginary, FFEBAD)
#define ffetarget_add_complex2(res,l,r) \
((res)->real = (l).real + (r).real, \
(res)->imaginary = (l).imaginary + (r).imaginary, FFEBAD)
#endif
#define ffetarget_add_integer1(res,l,r) (*(res) = (l) + (r), FFEBAD)
#define ffetarget_add_integer2(res,l,r) (*(res) = (l) + (r), FFEBAD)
#define ffetarget_add_integer3(res,l,r) (*(res) = (l) + (r), FFEBAD)
#define ffetarget_add_integer4(res,l,r) (*(res) = (l) + (r), FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_add_real1(res,l,r) \
({ REAL_VALUE_TYPE lr, rr, resr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -914,10 +854,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
FFEBAD; })
#else
#define ffetarget_add_real1(res,l,r) (*(res) = (l) + (r), FFEBAD)
#define ffetarget_add_real2(res,l,r) (*(res) = (l) + (r), FFEBAD)
#endif
#define ffetarget_aggregate_ptr_memcpy(dbt,dkt,sbt,skt) \
((ffetargetCopyfunc) ffetarget_memcpy_)
#define ffetarget_and_integer1(res,l,r) (*(res) = (l) & (r), FFEBAD)
@ -961,7 +897,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
#define ffetarget_convert_complex1_typeless(res,l) \
ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex1_complex2(res,l) \
({ REAL_VALUE_TYPE lr, li; \
lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
@ -969,11 +904,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_cvt_rv_to_r1_ (lr, (res)->real); \
ffetarget_cvt_rv_to_r1_ (li, (res)->imaginary), \
FFEBAD; })
#else
#define ffetarget_convert_complex1_complex2(res,l) \
((res)->real = (l).real, (res)->imaginary = (l).imaginary, FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex1_integer(res,l) \
({ REAL_VALUE_TYPE resi, resr; \
ffetargetInteger1 lf = (l); \
@ -982,19 +912,10 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \
ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \
FFEBAD; })
#else
#define ffetarget_convert_complex1_integer(res,l) \
((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#endif
#define ffetarget_convert_complex1_integer1 ffetarget_convert_complex1_integer
#define ffetarget_convert_complex1_integer2 ffetarget_convert_complex1_integer
#define ffetarget_convert_complex1_integer3 ffetarget_convert_complex1_integer
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex1_integer4(res,l) FFEBAD_NOCANDO
#else
#define ffetarget_convert_complex1_integer4 ffetarget_convert_complex1_integer
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex1_real1(res,l) \
((res)->real = (l), \
ffetarget_cvt_rv_to_r1_ (dconst0, (res)->imaginary), \
@ -1005,19 +926,12 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_cvt_rv_to_r1_ (lr, (res)->real); \
ffetarget_cvt_rv_to_r1_ (dconst0, (res)->imaginary), \
FFEBAD; })
#else
#define ffetarget_convert_complex1_real1(res,l) \
((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#define ffetarget_convert_complex1_real2(res,l) \
((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#endif
#define ffetarget_convert_complex2_character1(res,l) \
ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
#define ffetarget_convert_complex2_hollerith(res,l) \
ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
#define ffetarget_convert_complex2_typeless(res,l) \
ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex2_complex1(res,l) \
({ REAL_VALUE_TYPE lr, li; \
lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
@ -1025,11 +939,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_cvt_rv_to_r2_ (lr, &((res)->real.v[0])); \
ffetarget_cvt_rv_to_r2_ (li, &((res)->imaginary.v[0])), \
FFEBAD; })
#else
#define ffetarget_convert_complex2_complex1(res,l) \
((res)->real = (l).real, (res)->imaginary = (l).imaginary, FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex2_integer(res,l) \
({ REAL_VALUE_TYPE resi, resr; \
ffetargetInteger1 lf = (l); \
@ -1038,19 +947,10 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
FFEBAD; })
#else
#define ffetarget_convert_complex2_integer(res,l) \
((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#endif
#define ffetarget_convert_complex2_integer1 ffetarget_convert_complex2_integer
#define ffetarget_convert_complex2_integer2 ffetarget_convert_complex2_integer
#define ffetarget_convert_complex2_integer3 ffetarget_convert_complex2_integer
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex2_integer4(res,l) FFEBAD_NOCANDO
#else
#define ffetarget_convert_complex2_integer4 ffetarget_convert_complex2_integer
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_complex2_real1(res,l) \
({ REAL_VALUE_TYPE lr; \
lr = ffetarget_cvt_r1_to_rv_ (l); \
@ -1061,12 +961,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
((res)->real = (l), \
ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->imaginary.v[0])), \
FFEBAD)
#else
#define ffetarget_convert_complex2_real1(res,l) \
((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#define ffetarget_convert_complex2_real2(res,l) \
((res)->real = (l), (res)->imaginary = 0, FFEBAD)
#endif
#define ffetarget_convert_integer2_character1(res,l) \
ffetarget_convert_integer1_character1(res,l)
#define ffetarget_convert_integer2_complex1(res,l) \
@ -1119,15 +1013,8 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_convert_integer1_typeless(res,l)
#define ffetarget_convert_integer4_character1(res,l) \
ffetarget_convert_integer1_character1(res,l)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_integer4_complex1(res,l) FFEBAD_NOCANDO
#define ffetarget_convert_integer4_complex2(res,l) FFEBAD_NOCANDO
#else
#define ffetarget_convert_integer4_complex1(res,l) \
ffetarget_convert_integer1_complex1(res,l)
#define ffetarget_convert_integer4_complex2(res,l) \
ffetarget_convert_integer1_complex2(res,l)
#endif
#define ffetarget_convert_integer4_hollerith(res,l) \
ffetarget_convert_integer1_hollerith(res,l)
#define ffetarget_convert_integer4_integer1(res,l) (*(res) = (l), FFEBAD)
@ -1141,15 +1028,8 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_convert_integer1_logical1(res,l)
#define ffetarget_convert_integer4_logical4(res,l) \
ffetarget_convert_integer1_logical1(res,l)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_integer4_real1(res,l) FFEBAD_NOCANDO
#define ffetarget_convert_integer4_real2(res,l) FFEBAD_NOCANDO
#else
#define ffetarget_convert_integer4_real1(res,l) \
ffetarget_convert_integer1_real1(res,l)
#define ffetarget_convert_integer4_real2(res,l) \
ffetarget_convert_integer1_real2(res,l)
#endif
#define ffetarget_convert_integer4_typeless(res,l) \
ffetarget_convert_integer1_typeless(res,l)
#define ffetarget_convert_logical1_character1(res,l) \
@ -1217,7 +1097,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
#define ffetarget_convert_integer1_logical2(res,l) (*(res) = (l), FFEBAD)
#define ffetarget_convert_integer1_logical3(res,l) (*(res) = (l), FFEBAD)
#define ffetarget_convert_integer1_logical4(res,l) (*(res) = (l), FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_integer1_real1(res,l) \
({ REAL_VALUE_TYPE lr; \
lr = ffetarget_cvt_r1_to_rv_ (l); \
@ -1242,12 +1121,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
*(res) = ffetarget_long_val_; \
FFEBAD; })
#else
#define ffetarget_convert_integer1_real1(res,l) (*(res) = (l), FFEBAD)
#define ffetarget_convert_integer1_real2(res,l) (*(res) = (l), FFEBAD)
#define ffetarget_convert_integer1_complex1(res,l) (*(res) = (l).real, FFEBAD)
#define ffetarget_convert_integer1_complex2(res,l) (*(res) = (l).real, FFEBAD)
#endif
#define ffetarget_convert_real1_character1(res,l) \
ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
#define ffetarget_convert_real1_hollerith(res,l) \
@ -1256,36 +1129,23 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_convert_real1_integer1(res,l)
#define ffetarget_convert_real1_integer3(res,l) \
ffetarget_convert_real1_integer1(res,l)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_real1_integer4(res,l) FFEBAD_NOCANDO
#else
#define ffetarget_convert_real1_integer4(res,l) \
ffetarget_convert_real1_integer1(res,l)
#endif
#define ffetarget_convert_real1_typeless(res,l) \
ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
#define ffetarget_convert_real1_complex1(res,l) (*(res) = (l).real, FFEBAD)
#define ffetarget_convert_real1_complex2(res,l) \
ffetarget_convert_real1_real2 ((res), (l).real)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_real1_integer1(res,l) \
({ REAL_VALUE_TYPE resr; \
ffetargetInteger1 lf = (l); \
FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 1); \
ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
FFEBAD; })
#else
#define ffetarget_convert_real1_integer1(res,l) (*(res) = (l), FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_real1_real2(res,l) \
({ REAL_VALUE_TYPE lr; \
lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
ffetarget_cvt_rv_to_r1_ (lr, *(res)); \
FFEBAD; })
#else
#define ffetarget_convert_real1_real2(res,l) (*(res) = (l), FFEBAD)
#endif
#define ffetarget_convert_real2_character1(res,l) \
ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
#define ffetarget_convert_real2_hollerith(res,l) \
@ -1294,18 +1154,12 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_convert_real2_integer1(res,l)
#define ffetarget_convert_real2_integer3(res,l) \
ffetarget_convert_real2_integer1(res,l)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_real2_integer4(res,l) FFEBAD_NOCANDO
#else
#define ffetarget_convert_real2_integer4(res,l) \
ffetarget_convert_real2_integer1(res,l)
#endif
#define ffetarget_convert_real2_typeless(res,l) \
ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
#define ffetarget_convert_real2_complex1(res,l) \
ffetarget_convert_real2_real1 ((res), (l).real)
#define ffetarget_convert_real2_complex2(res,l) (*(res) = (l).real, FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_real2_integer(res,l) \
({ REAL_VALUE_TYPE resr; \
ffetargetInteger1 lf = (l); \
@ -1313,18 +1167,11 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
FFEBAD; })
#define ffetarget_convert_real2_integer1 ffetarget_convert_real2_integer
#else
#define ffetarget_convert_real2_integer1(res,l) (*(res) = (l), FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_convert_real2_real1(res,l) \
({ REAL_VALUE_TYPE lr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
ffetarget_cvt_rv_to_r2_ (lr, &((res)->v[0])); \
FFEBAD; })
#else
#define ffetarget_convert_real2_real1(res,l) (*(res) = (l), FFEBAD)
#endif
#define ffetarget_divide_integer1(res,l,r) \
(((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO) \
: (*(res) = (l) / (r), FFEBAD))
@ -1334,7 +1181,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_divide_integer1(res,l,r)
#define ffetarget_divide_integer4(res,l,r) \
ffetarget_divide_integer1(res,l,r)
#ifdef REAL_ARITHMETIC
#define ffetarget_divide_real1(res,l,r) \
({ REAL_VALUE_TYPE lr, rr, resr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1361,15 +1207,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
FFEBAD; \
}); \
})
#else
#define ffetarget_divide_real1(res,l,r) \
(((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO) \
: (*(res) = (l) / (r), FFEBAD))
#define ffetarget_divide_real2(res,l,r) \
(((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO) \
: (*(res) = (l) / (r), FFEBAD))
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_eq_complex1(res,l,r) \
({ REAL_VALUE_TYPE lr, li, rr, ri; \
lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
@ -1388,14 +1225,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
*(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
? TRUE : FALSE; \
FFEBAD; })
#else
#define ffetarget_eq_complex1(res,l,r) \
(*(res) = (((l).real == (r).real) && ((l).imaginary == (r).imaginary)) \
? TRUE : FALSE, FFEBAD)
#define ffetarget_eq_complex2(res,l,r) \
(*(res) = (((l).real == (r).real) && ((l).imaginary == (r).imaginary)) \
? TRUE : FALSE, FFEBAD)
#endif
#define ffetarget_eq_integer1(res,l,r) \
(*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_eq_integer2(res,l,r) \
@ -1404,7 +1233,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
(*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_eq_integer4(res,l,r) \
(*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_eq_real1(res,l,r) \
({ REAL_VALUE_TYPE lr, rr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1417,12 +1245,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
*(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \
FFEBAD; })
#else
#define ffetarget_eq_real1(res,l,r) \
(*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_eq_real2(res,l,r) \
(*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
#endif
#define ffetarget_eqv_integer1(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
#define ffetarget_eqv_integer2(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
#define ffetarget_eqv_integer3(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
@ -1439,7 +1261,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
(*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_ge_integer4(res,l,r) \
(*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_ge_real1(res,l,r) \
({ REAL_VALUE_TYPE lr, rr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1452,12 +1273,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
*(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \
FFEBAD; })
#else
#define ffetarget_ge_real1(res,l,r) \
(*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_ge_real2(res,l,r) \
(*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
#endif
#define ffetarget_gt_integer1(res,l,r) \
(*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_gt_integer2(res,l,r) \
@ -1466,7 +1281,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
(*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_gt_integer4(res,l,r) \
(*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_gt_real1(res,l,r) \
({ REAL_VALUE_TYPE lr, rr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1481,12 +1295,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
*(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
? FALSE : TRUE; \
FFEBAD; })
#else
#define ffetarget_gt_real1(res,l,r) \
(*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_gt_real2(res,l,r) \
(*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
#endif
#define ffetarget_hexxmil(v,t) ffetarget_typeless_hex (v, t)
#define ffetarget_hexxvxt(v,t) ffetarget_typeless_hex (v, t)
#define ffetarget_hexzmil(v,t) ffetarget_typeless_hex (v, t)
@ -1503,7 +1311,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
#define ffetarget_integerdefault_is_magical(i) \
(((unsigned int) i) == FFETARGET_integerBIG_MAGICAL)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_iszero_real1(l) \
({ REAL_VALUE_TYPE lr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1514,10 +1321,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
REAL_VALUES_EQUAL (lr, dconst0); \
})
#else
#define ffetarget_iszero_real1(l) ((l) == 0.)
#define ffetarget_iszero_real2(l) ((l) == 0.)
#endif
#define ffetarget_iszero_typeless(l) ((l) == 0)
#define ffetarget_logical1(v,truth) (*(v) = truth ? 1 : 0)
#define ffetarget_le_integer1(res,l,r) \
@ -1528,7 +1331,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
(*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_le_integer4(res,l,r) \
(*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_le_real1(res,l,r) \
({ REAL_VALUE_TYPE lr, rr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1543,12 +1345,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
*(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
? TRUE : FALSE; \
FFEBAD; })
#else
#define ffetarget_le_real1(res,l,r) \
(*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_le_real2(res,l,r) \
(*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
#endif
#define ffetarget_lt_integer1(res,l,r) \
(*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_lt_integer2(res,l,r) \
@ -1557,7 +1353,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
(*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_lt_integer4(res,l,r) \
(*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_lt_real1(res,l,r) \
({ REAL_VALUE_TYPE lr, rr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1570,28 +1365,16 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
*(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \
FFEBAD; })
#else
#define ffetarget_lt_real1(res,l,r) \
(*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_lt_real2(res,l,r) \
(*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
#endif
#define ffetarget_length_character1(c) ((c).length)
#define ffetarget_length_characterdefault ffetarget_length_character1
#ifdef REAL_ARITHMETIC
#define ffetarget_make_real1(res,lr) \
ffetarget_cvt_rv_to_r1_ ((lr), *(res))
#define ffetarget_make_real2(res,lr) \
ffetarget_cvt_rv_to_r2_ ((lr), &((res)->v[0]))
#else
#define ffetarget_make_real1(res,lr) (*(res) = (lr))
#define ffetarget_make_real2(res,lr) (*(res) = (lr))
#endif
#define ffetarget_multiply_integer1(res,l,r) (*(res) = (l) * (r), FFEBAD)
#define ffetarget_multiply_integer2(res,l,r) (*(res) = (l) * (r), FFEBAD)
#define ffetarget_multiply_integer3(res,l,r) (*(res) = (l) * (r), FFEBAD)
#define ffetarget_multiply_integer4(res,l,r) (*(res) = (l) * (r), FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_multiply_real1(res,l,r) \
({ REAL_VALUE_TYPE lr, rr, resr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1606,11 +1389,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \
ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
FFEBAD; })
#else
#define ffetarget_multiply_real1(res,l,r) (*(res) = (l) * (r), FFEBAD)
#define ffetarget_multiply_real2(res,l,r) (*(res) = (l) * (r), FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_ne_complex1(res,l,r) \
({ REAL_VALUE_TYPE lr, li, rr, ri; \
lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
@ -1629,14 +1407,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
*(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
? FALSE : TRUE; \
FFEBAD; })
#else
#define ffetarget_ne_complex1(res,l,r) \
(*(res) = (((l).real != (r).real) || ((l).imaginary != (r).imaginary)) \
? TRUE : FALSE, FFEBAD)
#define ffetarget_ne_complex2(res,l,r) \
(*(res) = (((l).real != (r).real) || ((l).imaginary != (r).imaginary)) \
? TRUE : FALSE, FFEBAD)
#endif
#define ffetarget_ne_integer1(res,l,r) \
(*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_ne_integer2(res,l,r) \
@ -1645,7 +1415,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
(*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_ne_integer4(res,l,r) \
(*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_ne_real1(res,l,r) \
({ REAL_VALUE_TYPE lr, rr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1658,12 +1427,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
*(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \
FFEBAD; })
#else
#define ffetarget_ne_real1(res,l,r) \
(*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
#define ffetarget_ne_real2(res,l,r) \
(*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
#endif
#define ffetarget_neqv_integer1(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
#define ffetarget_neqv_integer2(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
#define ffetarget_neqv_integer3(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
@ -1719,7 +1482,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
fprintf ((f), "%" ffetargetLogical4_f "d", (v))
#define ffetarget_print_octalmil(f,v) ffetarget_print_octal(f,v)
#define ffetarget_print_octalvxt(f,v) ffetarget_print_octal(f,v)
#ifdef REAL_ARITHMETIC
#define ffetarget_print_real1(f,l) \
({ REAL_VALUE_TYPE lr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1732,38 +1494,16 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
REAL_VALUE_TO_DECIMAL (lr, bad_fmt_val??, ffetarget_string_); \
fputs (ffetarget_string_, (f)); \
})
#else
#define ffetarget_print_real1(f,v) \
fprintf ((f), "%" ffetargetReal1_f "g", (v))
#define ffetarget_print_real2(f,v) \
fprintf ((f), "%" ffetargetReal2_f "g", (v))
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_real1_one(res) ffetarget_cvt_rv_to_r1_ (dconst1, *(res))
#define ffetarget_real2_one(res) ffetarget_cvt_rv_to_r2_ (dconst1, &((res)->v[0]))
#else
#define ffetarget_real1_one(res) (*(res) = (float) 1.)
#define ffetarget_real2_one(res) (*(res) = 1.)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_real1_two(res) ffetarget_cvt_rv_to_r1_ (dconst2, *(res))
#define ffetarget_real2_two(res) ffetarget_cvt_rv_to_r2_ (dconst2, &((res)->v[0]))
#else
#define ffetarget_real1_two(res) (*(res) = (float) 2.)
#define ffetarget_real2_two(res) (*(res) = 2.)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_real1_zero(res) ffetarget_cvt_rv_to_r1_ (dconst0, *(res))
#define ffetarget_real2_zero(res) ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->v[0]))
#else
#define ffetarget_real1_zero(res) (*(res) = (float) 0.)
#define ffetarget_real2_zero(res) (*(res) = 0.)
#endif
#define ffetarget_size_typeless_binary(t) ((ffetarget_num_digits_(t) + 7) / 8)
#define ffetarget_size_typeless_octal(t) \
((ffetarget_num_digits_(t) * 3 + 7) / 8)
#define ffetarget_size_typeless_hex(t) ((ffetarget_num_digits_(t) + 1) / 2)
#ifdef REAL_ARITHMETIC
#define ffetarget_subtract_complex1(res,l,r) \
({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
@ -1786,19 +1526,10 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
FFEBAD; })
#else
#define ffetarget_subtract_complex1(res,l,r) \
((res)->real = (l).real - (r).real, \
(res)->imaginary = (l).imaginary - (r).imaginary, FFEBAD)
#define ffetarget_subtract_complex2(res,l,r) \
((res)->real = (l).real - (r).real, \
(res)->imaginary = (l).imaginary - (r).imaginary, FFEBAD)
#endif
#define ffetarget_subtract_integer1(res,l,r) (*(res) = (l) - (r), FFEBAD)
#define ffetarget_subtract_integer2(res,l,r) (*(res) = (l) - (r), FFEBAD)
#define ffetarget_subtract_integer3(res,l,r) (*(res) = (l) - (r), FFEBAD)
#define ffetarget_subtract_integer4(res,l,r) (*(res) = (l) - (r), FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_subtract_real1(res,l,r) \
({ REAL_VALUE_TYPE lr, rr, resr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1813,10 +1544,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
FFEBAD; })
#else
#define ffetarget_subtract_real1(res,l,r) (*(res) = (l) - (r), FFEBAD)
#define ffetarget_subtract_real2(res,l,r) (*(res) = (l) - (r), FFEBAD)
#endif
#define ffetarget_terminate_0()
#define ffetarget_terminate_1()
#define ffetarget_terminate_2()
@ -1824,7 +1551,6 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
#define ffetarget_terminate_4()
#define ffetarget_text_character1(c) ((c).text)
#define ffetarget_text_characterdefault ffetarget_text_character1
#ifdef REAL_ARITHMETIC
#define ffetarget_uminus_complex1(res,l) \
({ REAL_VALUE_TYPE lr, li, resr, resi; \
lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
@ -1843,17 +1569,10 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
FFEBAD; })
#else
#define ffetarget_uminus_complex1(res,l) \
((res)->real = -(l).real, (res)->imaginary = -(l).imaginary, FFEBAD)
#define ffetarget_uminus_complex2(res,l) \
((res)->real = -(l).real, (res)->imaginary = -(l).imaginary, FFEBAD)
#endif
#define ffetarget_uminus_integer1(res,l) (*(res) = -(l), FFEBAD)
#define ffetarget_uminus_integer2(res,l) (*(res) = -(l), FFEBAD)
#define ffetarget_uminus_integer3(res,l) (*(res) = -(l), FFEBAD)
#define ffetarget_uminus_integer4(res,l) (*(res) = -(l), FFEBAD)
#ifdef REAL_ARITHMETIC
#define ffetarget_uminus_real1(res,l) \
({ REAL_VALUE_TYPE lr, resr; \
lr = ffetarget_cvt_r1_to_rv_ ((l)); \
@ -1866,17 +1585,8 @@ void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
resr = REAL_VALUE_NEGATE (lr); \
ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
FFEBAD; })
#else
#define ffetarget_uminus_real1(res,l) (*(res) = -(l), FFEBAD)
#define ffetarget_uminus_real2(res,l) (*(res) = -(l), FFEBAD)
#endif
#ifdef REAL_ARITHMETIC
#define ffetarget_value_real1(lr) ffetarget_cvt_r1_to_rv_ ((lr))
#define ffetarget_value_real2(lr) ffetarget_cvt_r2_to_rv_ (&((lr).v[0]))
#else
#define ffetarget_value_real1
#define ffetarget_value_real2
#endif
#define ffetarget_xor_integer1(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
#define ffetarget_xor_integer2(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
#define ffetarget_xor_integer3(res,l,r) (*(res) = (l) ^ (r), FFEBAD)

25
gcc/final.c
View file

@ -3771,7 +3771,6 @@ split_double (value, first, second)
}
else
{
#ifdef REAL_ARITHMETIC
REAL_VALUE_TYPE r;
long l[2];
REAL_VALUE_FROM_CONST_DOUBLE (r, value);
@ -3800,30 +3799,6 @@ split_double (value, first, second)
*first = GEN_INT ((HOST_WIDE_INT) l[0]);
*second = GEN_INT ((HOST_WIDE_INT) l[1]);
#else
if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
|| HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
&& ! flag_pretend_float)
abort ();
if (
#ifdef HOST_WORDS_BIG_ENDIAN
WORDS_BIG_ENDIAN
#else
! WORDS_BIG_ENDIAN
#endif
)
{
/* Host and target agree => no need to swap. */
*first = GEN_INT (CONST_DOUBLE_LOW (value));
*second = GEN_INT (CONST_DOUBLE_HIGH (value));
}
else
{
*second = GEN_INT (CONST_DOUBLE_LOW (value));
*first = GEN_INT (CONST_DOUBLE_HIGH (value));
}
#endif /* no REAL_ARITHMETIC */
}
}

6
gcc/flags.h
View file

@ -434,12 +434,6 @@ extern int flag_delayed_branch;
extern int flag_dump_unnumbered;
/* Nonzero means pretend it is OK to examine bits of target floats,
even if that isn't true. The resulting code will have incorrect constants,
but the same series of instructions that the native compiler would make. */
extern int flag_pretend_float;
/* Nonzero means change certain warnings into errors.
Usually these are warnings about failure to conform to some standard. */

595
gcc/fold-const.c
View file

@ -59,9 +59,6 @@ static void encode PARAMS ((HOST_WIDE_INT *,
static void decode PARAMS ((HOST_WIDE_INT *,
unsigned HOST_WIDE_INT *,
HOST_WIDE_INT *));
#ifndef REAL_ARITHMETIC
static void exact_real_inverse_1 PARAMS ((PTR));
#endif
static tree negate_expr PARAMS ((tree));
static tree split_tree PARAMS ((tree, enum tree_code, tree *, tree *,
int));
@ -834,512 +831,6 @@ div_and_round_double (code, uns,
return overflow;
}
#ifndef REAL_ARITHMETIC
/* Effectively truncate a real value to represent the nearest possible value
in a narrower mode. The result is actually represented in the same data
type as the argument, but its value is usually different.
A trap may occur during the FP operations and it is the responsibility
of the calling function to have a handler established. */
REAL_VALUE_TYPE
real_value_truncate (mode, arg)
enum machine_mode mode;
REAL_VALUE_TYPE arg;
{
return REAL_VALUE_TRUNCATE (mode, arg);
}
#if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
/* Check for infinity in an IEEE double precision number. */
int
target_isinf (x)
REAL_VALUE_TYPE x;
{
/* The IEEE 64-bit double format. */
union {
REAL_VALUE_TYPE d;
struct {
unsigned sign : 1;
unsigned exponent : 11;
unsigned mantissa1 : 20;
unsigned mantissa2 : 32;
} little_endian;
struct {
unsigned mantissa2 : 32;
unsigned mantissa1 : 20;
unsigned exponent : 11;
unsigned sign : 1;
} big_endian;
} u;
u.d = dconstm1;
if (u.big_endian.sign == 1)
{
u.d = x;
return (u.big_endian.exponent == 2047
&& u.big_endian.mantissa1 == 0
&& u.big_endian.mantissa2 == 0);
}
else
{
u.d = x;
return (u.little_endian.exponent == 2047
&& u.little_endian.mantissa1 == 0
&& u.little_endian.mantissa2 == 0);
}
}
/* Check whether an IEEE double precision number is a NaN. */
int
target_isnan (x)
REAL_VALUE_TYPE x;
{
/* The IEEE 64-bit double format. */
union {
REAL_VALUE_TYPE d;
struct {
unsigned sign : 1;
unsigned exponent : 11;
unsigned mantissa1 : 20;
unsigned mantissa2 : 32;
} little_endian;
struct {
unsigned mantissa2 : 32;
unsigned mantissa1 : 20;
unsigned exponent : 11;
unsigned sign : 1;
} big_endian;
} u;
u.d = dconstm1;
if (u.big_endian.sign == 1)
{
u.d = x;
return (u.big_endian.exponent == 2047
&& (u.big_endian.mantissa1 != 0
|| u.big_endian.mantissa2 != 0));
}
else
{
u.d = x;
return (u.little_endian.exponent == 2047
&& (u.little_endian.mantissa1 != 0
|| u.little_endian.mantissa2 != 0));
}
}
/* Check for a negative IEEE double precision number. */
int
target_negative (x)
REAL_VALUE_TYPE x;
{
/* The IEEE 64-bit double format. */
union {
REAL_VALUE_TYPE d;
struct {
unsigned sign : 1;
unsigned exponent : 11;
unsigned mantissa1 : 20;
unsigned mantissa2 : 32;
} little_endian;
struct {
unsigned mantissa2 : 32;
unsigned mantissa1 : 20;
unsigned exponent : 11;
unsigned sign : 1;
} big_endian;
} u;
u.d = dconstm1;
if (u.big_endian.sign == 1)
{
u.d = x;
return u.big_endian.sign;
}
else
{
u.d = x;
return u.little_endian.sign;
}
}
#else /* Target not IEEE */
/* Let's assume other float formats don't have infinity.
(This can be overridden by redefining REAL_VALUE_ISINF.) */
int
target_isinf (x)
REAL_VALUE_TYPE x ATTRIBUTE_UNUSED;
{
return 0;
}
/* Let's assume other float formats don't have NaNs.
(This can be overridden by redefining REAL_VALUE_ISNAN.) */
int
target_isnan (x)
REAL_VALUE_TYPE x ATTRIBUTE_UNUSED;
{
return 0;
}
/* Let's assume other float formats don't have minus zero.
(This can be overridden by redefining REAL_VALUE_NEGATIVE.) */
int
target_negative (x)
REAL_VALUE_TYPE x;
{
return x < 0;
}
#endif /* Target not IEEE */
/* Try to change R into its exact multiplicative inverse in machine mode
MODE. Return nonzero function value if successful. */
struct exact_real_inverse_args
{
REAL_VALUE_TYPE *r;
enum machine_mode mode;
int success;
};
static void
exact_real_inverse_1 (p)
PTR p;
{
struct exact_real_inverse_args *args =
(struct exact_real_inverse_args *) p;
enum machine_mode mode = args->mode;
REAL_VALUE_TYPE *r = args->r;
union
{
double d;
unsigned short i[4];
}
x, t, y;
#ifdef CHECK_FLOAT_VALUE
int i;
#endif
/* Set array index to the less significant bits in the unions, depending
on the endian-ness of the host doubles. */
#if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT \
|| HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
# define K 2
#else
# define K (2 * HOST_FLOAT_WORDS_BIG_ENDIAN)
#endif
/* Domain check the argument. */
x.d = *r;
if (x.d == 0.0)
goto fail;
#ifdef REAL_INFINITY
if (REAL_VALUE_ISINF (x.d) || REAL_VALUE_ISNAN (x.d))
goto fail;
#endif
/* Compute the reciprocal and check for numerical exactness.
It is unnecessary to check all the significand bits to determine
whether X is a power of 2. If X is not, then it is impossible for
the bottom half significand of both X and 1/X to be all zero bits.
Hence we ignore the data structure of the top half and examine only
the low order bits of the two significands. */
t.d = 1.0 / x.d;
if (x.i[K] != 0 || x.i[K + 1] != 0 || t.i[K] != 0 || t.i[K + 1] != 0)
goto fail;
/* Truncate to the required mode and range-check the result. */
y.d = REAL_VALUE_TRUNCATE (mode, t.d);
#ifdef CHECK_FLOAT_VALUE
i = 0;
if (CHECK_FLOAT_VALUE (mode, y.d, i))
goto fail;
#endif
/* Fail if truncation changed the value. */
if (y.d != t.d || y.d == 0.0)
goto fail;
#ifdef REAL_INFINITY
if (REAL_VALUE_ISINF (y.d) || REAL_VALUE_ISNAN (y.d))
goto fail;
#endif
/* Output the reciprocal and return success flag. */
*r = y.d;
args->success = 1;
return;
fail:
args->success = 0;
return;
#undef K
}
int
exact_real_inverse (mode, r)
enum machine_mode mode;
REAL_VALUE_TYPE *r;
{
struct exact_real_inverse_args args;
/* Disable if insufficient information on the data structure. */
#if HOST_FLOAT_FORMAT == UNKNOWN_FLOAT_FORMAT
return 0;
#endif
/* Usually disable if bounds checks are not reliable. */
if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT) && !flag_pretend_float)
return 0;
args.mode = mode;
args.r = r;
if (do_float_handler (exact_real_inverse_1, (PTR) &args))
return args.success;
return 0;
}
/* Convert C99 hexadecimal floating point string constant S. Return
real value type in mode MODE. This function uses the host computer's
floating point arithmetic when there is no REAL_ARITHMETIC. */
REAL_VALUE_TYPE
real_hex_to_f (s, mode)
const char *s;
enum machine_mode mode;
{
REAL_VALUE_TYPE ip;
const char *p = s;
unsigned HOST_WIDE_INT low, high;
int shcount, nrmcount, k;
int sign, expsign, isfloat;
int lost = 0;/* Nonzero low order bits shifted out and discarded. */
int frexpon = 0; /* Bits after the decimal point. */
int expon = 0; /* Value of exponent. */
int decpt = 0; /* How many decimal points. */
int gotp = 0; /* How many P's. */
char c;
isfloat = 0;
expsign = 1;
ip = 0.0;
while (*p == ' ' || *p == '\t')
++p;
/* Sign, if any, comes first. */
sign = 1;
if (*p == '-')
{
sign = -1;
++p;
}
/* The string is supposed to start with 0x or 0X . */
if (*p == '0')
{
++p;
if (*p == 'x' || *p == 'X')
++p;
else
abort ();
}
else
abort ();
while (*p == '0')
++p;
high = 0;
low = 0;
shcount = 0;
while ((c = *p) != '\0')
{
if (ISXDIGIT (c))
{
k = hex_value (c & CHARMASK);
if ((high & 0xf0000000) == 0)
{
high = (high << 4) + ((low >> 28) & 15);
low = (low << 4) + k;
shcount += 4;
if (decpt)
frexpon += 4;
}
else
{
/* Record nonzero lost bits. */
lost |= k;
if (! decpt)
frexpon -= 4;
}
++p;
}
else if (c == '.')
{
++decpt;
++p;
}
else if (c == 'p' || c == 'P')
{
++gotp;
++p;
/* Sign of exponent. */
if (*p == '-')
{
expsign = -1;
++p;
}
/* Value of exponent.
The exponent field is a decimal integer. */
while (ISDIGIT (*p))
{
k = (*p++ & CHARMASK) - '0';
expon = 10 * expon + k;
}
expon *= expsign;
/* F suffix is ambiguous in the significand part
so it must appear after the decimal exponent field. */
if (*p == 'f' || *p == 'F')
{
isfloat = 1;
++p;
break;
}
}
else if (c == 'l' || c == 'L')
{
++p;
break;
}
else
break;
}
/* Abort if last character read was not legitimate. */
c = *p;
if ((c != '\0' && c != ' ' && c != '\n' && c != '\r') || (decpt > 1))
abort ();
/* There must be either one decimal point or one p. */
if (decpt == 0 && gotp == 0)
abort ();
shcount -= 4;
if (high == 0 && low == 0)
return dconst0;
/* Normalize. */
nrmcount = 0;
if (high == 0)
{
high = low;
low = 0;
nrmcount += 32;
}
/* Leave a high guard bit for carry-out. */
if ((high & 0x80000000) != 0)
{
lost |= low & 1;
low = (low >> 1) | (high << 31);
high = high >> 1;
nrmcount -= 1;
}
if ((high & 0xffff8000) == 0)
{
high = (high << 16) + ((low >> 16) & 0xffff);
low = low << 16;
nrmcount += 16;
}
while ((high & 0xc0000000) == 0)
{
high = (high << 1) + ((low >> 31) & 1);
low = low << 1;
nrmcount += 1;
}
if (isfloat || GET_MODE_SIZE (mode) == UNITS_PER_WORD)
{
/* Keep 24 bits precision, bits 0x7fffff80.
Rounding bit is 0x40. */
lost = lost | low | (high & 0x3f);
low = 0;
if (high & 0x40)
{
if ((high & 0x80) || lost)
high += 0x40;
}
high &= 0xffffff80;
}
else
{
/* We need real.c to do long double formats, so here default
to double precision. */
#if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
/* IEEE double.
Keep 53 bits precision, bits 0x7fffffff fffffc00.
Rounding bit is low word 0x200. */
lost = lost | (low & 0x1ff);
if (low & 0x200)
{
if ((low & 0x400) || lost)
{
low = (low + 0x200) & 0xfffffc00;
if (low == 0)
high += 1;
}
}
low &= 0xfffffc00;
#else
/* Assume it's a VAX with 56-bit significand,
bits 0x7fffffff ffffff80. */
lost = lost | (low & 0x7f);
if (low & 0x40)
{
if ((low & 0x80) || lost)
{
low = (low + 0x40) & 0xffffff80;
if (low == 0)
high += 1;
}
}
low &= 0xffffff80;
#endif
}
ip = (double) high;
ip = REAL_VALUE_LDEXP (ip, 32) + (double) low;
/* Apply shifts and exponent value as power of 2. */
ip = REAL_VALUE_LDEXP (ip, expon - (nrmcount + frexpon));
if (sign < 0)
ip = -ip;
return ip;
}
#endif /* no REAL_ARITHMETIC */
/* Given T, an expression, return the negation of T. Allow for T to be
null, in which case return null. */
@ -1725,44 +1216,7 @@ const_binop_1 (data)
struct cb_args *args = (struct cb_args *) data;
REAL_VALUE_TYPE value;
#ifdef REAL_ARITHMETIC
REAL_ARITHMETIC (value, args->code, args->d1, args->d2);
#else
switch (args->code)
{
case PLUS_EXPR:
value = args->d1 + args->d2;
break;
case MINUS_EXPR:
value = args->d1 - args->d2;
break;
case MULT_EXPR:
value = args->d1 * args->d2;
break;
case RDIV_EXPR:
#ifndef REAL_INFINITY
if (args->d2 == 0)
abort ();
#endif
value = args->d1 / args->d2;
break;
case MIN_EXPR:
value = MIN (args->d1, args->d2);
break;
case MAX_EXPR:
value = MAX (args->d1, args->d2);
break;
default:
abort ();
}
#endif /* no REAL_ARITHMETIC */
args->t
= build_real (args->type,
@ -1787,7 +1241,6 @@ const_binop (code, arg1, arg2, notrunc)
if (TREE_CODE (arg1) == INTEGER_CST)
return int_const_binop (code, arg1, arg2, notrunc);
#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
if (TREE_CODE (arg1) == REAL_CST)
{
REAL_VALUE_TYPE d1;
@ -1831,7 +1284,6 @@ const_binop (code, arg1, arg2, notrunc)
| TREE_CONSTANT_OVERFLOW (arg2);
return t;
}
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
if (TREE_CODE (arg1) == COMPLEX_CST)
{
tree type = TREE_TYPE (arg1);
@ -2145,7 +1597,6 @@ fold_convert (t, arg1)
TREE_CONSTANT_OVERFLOW (t)
= TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
}
#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
else if (TREE_CODE (arg1) == REAL_CST)
{
/* Don't initialize these, use assignments.
@ -2166,15 +1617,9 @@ fold_convert (t, arg1)
/* See if X will be in range after truncation towards 0.
To compensate for truncation, move the bounds away from 0,
but reject if X exactly equals the adjusted bounds. */
#ifdef REAL_ARITHMETIC
REAL_ARITHMETIC (l, MINUS_EXPR, l, dconst1);
if (!no_upper_bound)
REAL_ARITHMETIC (u, PLUS_EXPR, u, dconst1);
#else
l--;
if (!no_upper_bound)
u++;
#endif
/* If X is a NaN, use zero instead and show we have an overflow.
Otherwise, range check. */
if (REAL_VALUE_ISNAN (x))
@ -2184,50 +1629,23 @@ fold_convert (t, arg1)
&& REAL_VALUES_LESS (x, u)))
overflow = 1;
#ifndef REAL_ARITHMETIC
{
HOST_WIDE_INT low, high;
HOST_WIDE_INT half_word
= (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2);
if (x < 0)
x = -x;
high = (HOST_WIDE_INT) (x / half_word / half_word);
x -= (REAL_VALUE_TYPE) high * half_word * half_word;
if (x >= (REAL_VALUE_TYPE) half_word * half_word / 2)
{
low = x - (REAL_VALUE_TYPE) half_word * half_word / 2;
low |= (HOST_WIDE_INT) -1 << (HOST_BITS_PER_WIDE_INT - 1);
}
else
low = (HOST_WIDE_INT) x;
if (TREE_REAL_CST (arg1) < 0)
neg_double (low, high, &low, &high);
t = build_int_2 (low, high);
}
#else
{
HOST_WIDE_INT low, high;
REAL_VALUE_TO_INT (&low, &high, x);
t = build_int_2 (low, high);
}
#endif
TREE_TYPE (t) = type;
TREE_OVERFLOW (t)
= TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
TREE_CONSTANT_OVERFLOW (t)
= TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
}
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
TREE_TYPE (t) = type;
}
else if (TREE_CODE (type) == REAL_TYPE)
{
#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
if (TREE_CODE (arg1) == INTEGER_CST)
return build_real_from_int_cst (type, arg1);
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
if (TREE_CODE (arg1) == REAL_CST)
{
struct fc_args args;
@ -5008,9 +4426,7 @@ fold (expr)
subop = arg0;
if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
&& TREE_CODE (subop) != REAL_CST
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
)
/* Note that TREE_CONSTANT isn't enough:
static var addresses are constant but we can't
@ -5045,10 +4461,7 @@ fold (expr)
subop = op;
if (TREE_CODE (subop) != INTEGER_CST
#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
&& TREE_CODE (subop) != REAL_CST
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
)
&& TREE_CODE (subop) != REAL_CST)
/* Note that TREE_CONSTANT isn't enough:
static var addresses are constant but we can't
do arithmetic on them. */
@ -5704,10 +5117,6 @@ fold (expr)
}
binary:
#if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
if (TREE_CODE (arg1) == REAL_CST)
return t;
#endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
if (wins)
t1 = const_binop (code, arg0, arg1, 0);
if (t1 != NULL_TREE)
@ -5948,12 +5357,10 @@ fold (expr)
case RDIV_EXPR:
/* In most cases, do nothing with a divide by zero. */
#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
#ifndef REAL_INFINITY
if (TREE_CODE (arg1) == REAL_CST && real_zerop (arg1))
return t;
#endif
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
/* (-A) / (-B) -> A / B */
if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)

22
gcc/gengenrtl.c
View file

@ -31,30 +31,28 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
/* Calculate the format for CONST_DOUBLE. This depends on the relative
widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
We need to go out to e0wwwww, since REAL_ARITHMETIC assumes 16-bits
per element in REAL_VALUE_TYPE.
We need to go out to e0wwwww, since real.c assumes 16 bits per element
in REAL_VALUE_TYPE.
This is duplicated in rtl.c.
A number of places assume that there are always at least two 'w'
slots in a CONST_DOUBLE, so we provide them even if one would suffice. */
#ifdef REAL_ARITHMETIC
# if MAX_LONG_DOUBLE_TYPE_SIZE == 96
# define REAL_WIDTH \
#if MAX_LONG_DOUBLE_TYPE_SIZE == 96
# define REAL_WIDTH \
(11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
#else
# if MAX_LONG_DOUBLE_TYPE_SIZE == 128
# define REAL_WIDTH \
(19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
# else
# if MAX_LONG_DOUBLE_TYPE_SIZE == 128
# if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
# define REAL_WIDTH \
(19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
# else
# if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
# define REAL_WIDTH \
(7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
# endif
# endif
# endif
#endif /* REAL_ARITHMETIC */
#endif
#ifndef REAL_WIDTH
# if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE

7
gcc/java/ChangeLog
View file

@ -1,3 +1,10 @@
2002-03-03 Zack Weinberg <zack@codesourcery.com>
* java/expr.c, java/jcf-parse.c, java/lex.c:
Remove all #ifndef REAL_ARITHMETIC blocks, make all #ifdef
REAL_ARITHMETIC blocks unconditional. Delete some further
#ifdef blocks predicated on REAL_ARITHMETIC.
2002-03-03 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* class.c (init_class_processing): Use ARRAY_SIZE in lieu of

4
gcc/java/expr.c
View file

@ -1099,11 +1099,7 @@ expand_java_pushc (ival, type)
else if (type == float_type_node || type == double_type_node)
{
REAL_VALUE_TYPE x;
#ifdef REAL_ARITHMETIC
REAL_VALUE_FROM_INT (x, ival, 0, TYPE_MODE (type));
#else
x = ival;
#endif
value = build_real (type, x);
}
else

15
gcc/java/jcf-parse.c
View file

@ -306,13 +306,7 @@ get_constant (jcf, index)
{
jint num = JPOOL_INT(jcf, index);
REAL_VALUE_TYPE d;
#ifdef REAL_ARITHMETIC
d = REAL_VALUE_FROM_TARGET_SINGLE (num);
#else
union { float f; jint i; } u;
u.i = num;
d = u.f;
#endif
value = build_real (float_type_node, d);
break;
}
@ -343,16 +337,7 @@ get_constant (jcf, index)
num[0] = lo;
num[1] = hi;
}
#ifdef REAL_ARITHMETIC
d = REAL_VALUE_FROM_TARGET_DOUBLE (num);
#else
{
union { double d; jint i[2]; } u;
u.i[0] = (jint) num[0];
u.i[1] = (jint) num[1];
d = u.d;
}
#endif
value = build_real (double_type_node, d);
break;
}

4
gcc/java/lex.c
View file

@ -840,11 +840,7 @@ struct jpa_args
int number_beginning;
};
#ifdef REAL_ARITHMETIC
#define IS_ZERO(X) (ereal_cmp (X, dconst0) == 0)
#else
#define IS_ZERO(X) ((X) == 0)
#endif
static void java_perform_atof PARAMS ((PTR));

5
gcc/optabs.c
View file

@ -4120,8 +4120,6 @@ expand_float (to, from, unsignedp)
}
}
#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
/* Unsigned integer, and no way to convert directly.
Convert as signed, then conditionally adjust the result. */
if (unsignedp)
@ -4236,7 +4234,6 @@ expand_float (to, from, unsignedp)
emit_label (label);
goto done;
}
#endif
/* No hardware instruction available; call a library routine to convert from
SImode, DImode, or TImode into SFmode, DFmode, XFmode, or TFmode. */
@ -4387,7 +4384,6 @@ expand_fix (to, from, unsignedp)
}
}
#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
/* For an unsigned conversion, there is one more way to do it.
If we have a signed conversion, we generate code that compares
the real value to the largest representable positive number. If if
@ -4467,7 +4463,6 @@ expand_fix (to, from, unsignedp)
return;
}
#endif
/* We can't do it with an insn, so use a library call. But first ensure
that the mode of TO is at least as wide as SImode, since those are the

22
gcc/print-tree.c
View file

@ -124,7 +124,6 @@ print_node_brief (file, prefix, node, indent)
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
#if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
d = TREE_REAL_CST (node);
if (REAL_VALUE_ISINF (d))
fprintf (file, " Inf");
@ -137,16 +136,6 @@ print_node_brief (file, prefix, node, indent)
REAL_VALUE_TO_DECIMAL (d, "%e", string);
fprintf (file, " %s", string);
}
#else
{
int i;
unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
fprintf (file, " 0x");
for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
fprintf (file, "%02x", *p++);
fprintf (file, "");
}
#endif
}
fprintf (file, ">");
@ -681,7 +670,6 @@ print_node (file, prefix, node, indent)
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
#if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
d = TREE_REAL_CST (node);
if (REAL_VALUE_ISINF (d))
fprintf (file, " Inf");
@ -694,16 +682,6 @@ print_node (file, prefix, node, indent)
REAL_VALUE_TO_DECIMAL (d, "%e", string);
fprintf (file, " %s", string);
}
#else
{
int i;
unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
fprintf (file, " 0x");
for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
fprintf (file, "%02x", *p++);
fprintf (file, "");
}
#endif
}
break;

60
gcc/real.c
View file

@ -30,19 +30,12 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
/* To enable support of XFmode extended real floating point, define
LONG_DOUBLE_TYPE_SIZE 96 in the tm.h file (m68k.h or i386.h).
To support cross compilation between IEEE, VAX and IBM floating
point formats, define REAL_ARITHMETIC in the tm.h file.
In either case the machine files (tm.h) must not contain any code
Machine files (tm.h etc) must not contain any code
that tries to use host floating point arithmetic to convert
REAL_VALUE_TYPEs from `double' to `float', pass them to fprintf,
etc. In cross-compile situations a REAL_VALUE_TYPE may not
be intelligible to the host computer's native arithmetic.
The emulator defaults to the host's floating point format so that
its decimal conversion functions can be used if desired (see
real.h).
The first part of this file interfaces gcc to a floating point
arithmetic suite that was not written with gcc in mind. Avoid
changing the low-level arithmetic routines unless you have suitable
@ -88,10 +81,7 @@ netlib.att.com: netlib/cephes. */
If LONG_DOUBLE_TYPE_SIZE = 64 (the default, unless tm.h defines it)
then `long double' and `double' are both implemented, but they
both mean DFmode. In this case, the software floating-point
support available here is activated by writing
#define REAL_ARITHMETIC
in tm.h.
both mean DFmode.
The case LONG_DOUBLE_TYPE_SIZE = 128 activates TFmode support
and may deactivate XFmode since `long double' is used to refer
@ -113,10 +103,6 @@ netlib.att.com: netlib/cephes. */
/* The following converts gcc macros into the ones used by this file. */
/* REAL_ARITHMETIC defined means that macros in real.h are
defined to call emulator functions. */
#ifdef REAL_ARITHMETIC
#if TARGET_FLOAT_FORMAT == VAX_FLOAT_FORMAT
/* PDP-11, Pro350, VAX: */
#define DEC 1
@ -142,33 +128,6 @@ unknown arithmetic type
#define REAL_WORDS_BIG_ENDIAN FLOAT_WORDS_BIG_ENDIAN
#else
/* REAL_ARITHMETIC not defined means that the *host's* data
structure will be used. It may differ by endian-ness from the
target machine's structure and will get its ends swapped
accordingly (but not here). Probably only the decimal <-> binary
functions in this file will actually be used in this case. */
#if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT
#define DEC 1
#else /* it's not VAX */
#if HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
/* IBM System/370 style */
#define IBM 1
#else /* it's also not an IBM */
#if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
#define IEEE
#else /* it's not IEEE either */
unknown arithmetic type
#define UNK 1
#endif /* not IEEE */
#endif /* not IBM */
#endif /* not VAX */
#define REAL_WORDS_BIG_ENDIAN HOST_FLOAT_WORDS_BIG_ENDIAN
#endif /* REAL_ARITHMETIC not defined */
/* Define INFINITY for support of infinity.
Define NANS for support of Not-a-Number's (NaN's). */
#if !defined(DEC) && !defined(IBM) && !defined(C4X)
@ -290,7 +249,6 @@ typedef unsigned int UHItype __attribute__ ((mode (HI)));
#define NE 6
#define MAXDECEXP 4932
#define MINDECEXP -4956
#ifdef REAL_ARITHMETIC
/* Emulator uses target format internally
but host stores it in host endian-ness. */
@ -324,13 +282,6 @@ do { \
} \
} while (0)
#else /* not REAL_ARITHMETIC */
/* emulator uses host format */
#define GET_REAL(r,e) e53toe ((const UEMUSHORT *) (r), (e))
#define PUT_REAL(e,r) etoe53 ((e), (UEMUSHORT *) (r))
#endif /* not REAL_ARITHMETIC */
#endif /* not TFmode */
#endif /* not XFmode */
@ -1048,11 +999,6 @@ ereal_ldexp (x, n)
return (r);
}
/* These routines are conditionally compiled because functions
of the same names may be defined in fold-const.c. */
#ifdef REAL_ARITHMETIC
/* Check for infinity in a REAL_VALUE_TYPE. */
int
@ -1226,7 +1172,6 @@ exact_real_inverse (mode, r)
PUT_REAL (einv, r);
return 1;
}
#endif /* REAL_ARITHMETIC defined */
/* Used for debugging--print the value of R in human-readable format
on stderr. */
@ -1361,7 +1306,6 @@ ereal_isneg (x)
return (eisneg (ex));
}
/* End of REAL_ARITHMETIC interface */
/*
Extended precision IEEE binary floating point arithmetic routines

245
gcc/real.h
View file

@ -65,10 +65,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#endif
#endif
/* Defining REAL_ARITHMETIC invokes a floating point emulator
that can produce a target machine format differing by more
than just endian-ness from the host's format. The emulator
is also used to support extended real XFmode. */
#ifndef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE 64
#endif
@ -80,19 +76,13 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#ifndef MAX_LONG_DOUBLE_TYPE_SIZE
#define MAX_LONG_DOUBLE_TYPE_SIZE LONG_DOUBLE_TYPE_SIZE
#endif
#if (MAX_LONG_DOUBLE_TYPE_SIZE == 96) || (MAX_LONG_DOUBLE_TYPE_SIZE == 128)
#ifndef REAL_ARITHMETIC
#define REAL_ARITHMETIC
#endif
#endif
#ifdef REAL_ARITHMETIC
/* **** Start of software floating point emulator interface macros **** */
/* Support 80-bit extended real XFmode if LONG_DOUBLE_TYPE_SIZE
has been defined to be 96 in the tm.h machine file. */
#if (MAX_LONG_DOUBLE_TYPE_SIZE == 96)
#define REAL_IS_NOT_DOUBLE
#define REAL_ARITHMETIC
typedef struct {
HOST_WIDE_INT r[(11 + sizeof (HOST_WIDE_INT))/(sizeof (HOST_WIDE_INT))];
} realvaluetype;
@ -103,7 +93,6 @@ typedef struct {
#if (MAX_LONG_DOUBLE_TYPE_SIZE == 128)
#define REAL_IS_NOT_DOUBLE
#define REAL_ARITHMETIC
typedef struct {
HOST_WIDE_INT r[(19 + sizeof (HOST_WIDE_INT))/(sizeof (HOST_WIDE_INT))];
} realvaluetype;
@ -130,13 +119,6 @@ typedef struct {
extern unsigned int significand_size PARAMS ((enum machine_mode));
/* If emulation has been enabled by defining REAL_ARITHMETIC or by
setting LONG_DOUBLE_TYPE_SIZE to 96 or 128, then define macros so that
they invoke emulator functions. This will succeed only if the machine
files have been updated to use these macros in place of any
references to host machine `double' or `float' types. */
#ifdef REAL_ARITHMETIC
#undef REAL_ARITHMETIC
#define REAL_ARITHMETIC(value, code, d1, d2) \
earith (&(value), (code), &(d1), &(d2))
@ -176,10 +158,21 @@ extern REAL_VALUE_TYPE ereal_from_double PARAMS ((HOST_WIDE_INT *));
#define REAL_VALUES_LESS(x, y) (ereal_cmp ((x), (y)) == -1)
#define REAL_VALUE_LDEXP(x, n) ereal_ldexp (x, n)
/* Compare two floating-point objects for bitwise identity.
This is not the same as comparing for equality on IEEE hosts:
-0.0 equals 0.0 but they are not identical, and conversely
two NaNs might be identical but they cannot be equal. */
#define REAL_VALUES_IDENTICAL(x, y) \
(!memcmp ((char *) &(x), (char *) &(y), sizeof (REAL_VALUE_TYPE)))
/* These return REAL_VALUE_TYPE: */
#define REAL_VALUE_RNDZINT(x) (etrunci (x))
#define REAL_VALUE_UNSIGNED_RNDZINT(x) (etruncui (x))
/* Truncate the floating-point value X to mode MODE. */
#define REAL_VALUE_TRUNCATE(mode, x) real_value_truncate (mode, x)
extern REAL_VALUE_TYPE real_value_truncate PARAMS ((enum machine_mode,
REAL_VALUE_TYPE));
/* These return HOST_WIDE_INT: */
/* Convert a floating-point value to integer, rounding toward zero. */
@ -195,6 +188,16 @@ extern REAL_VALUE_TYPE ereal_from_double PARAMS ((HOST_WIDE_INT *));
#define REAL_VALUE_NEGATE ereal_negate
/* Determine whether a floating-point value X is infinite. */
#define REAL_VALUE_ISINF(x) (target_isinf (x))
/* Determine whether a floating-point value X is a NaN. */
#define REAL_VALUE_ISNAN(x) (target_isnan (x))
/* Determine whether a floating-point value X is negative. */
#define REAL_VALUE_NEGATIVE(x) (target_negative (x))
/* Determine whether a floating-point value X is minus zero. */
#define REAL_VALUE_MINUS_ZERO(x) \
((ereal_cmp (x, dconst0) == 0) && (ereal_isneg (x) != 0 ))
@ -234,203 +237,7 @@ extern REAL_VALUE_TYPE ereal_from_double PARAMS ((HOST_WIDE_INT *));
/* Conversions to decimal ASCII string. */
#define REAL_VALUE_TO_DECIMAL(r, fmt, s) (ereal_to_decimal (r, s))
#endif /* REAL_ARITHMETIC defined */
/* **** End of software floating point emulator interface macros **** */
#else /* No XFmode or TFmode and REAL_ARITHMETIC not defined */
/* old interface */
#ifdef REAL_ARITHMETIC
/* Defining REAL_IS_NOT_DOUBLE breaks certain initializations
when REAL_ARITHMETIC etc. are not defined. */
/* Now see if the host and target machines use the same format.
If not, define REAL_IS_NOT_DOUBLE (even if we end up representing
reals as doubles because we have no better way in this cross compiler.)
This turns off various optimizations that can happen when we know the
compiler's float format matches the target's float format.
*/
#if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
#define REAL_IS_NOT_DOUBLE
#ifndef REAL_VALUE_TYPE
typedef struct {
HOST_WIDE_INT r[sizeof (double)/sizeof (HOST_WIDE_INT)];
} realvaluetype;
#define REAL_VALUE_TYPE realvaluetype
#endif /* no REAL_VALUE_TYPE */
#endif /* formats differ */
#endif /* 0 */
#endif /* emulator not used */
/* If we are not cross-compiling, use a `double' to represent the
floating-point value. Otherwise, use some other type
(probably a struct containing an array of longs). */
#ifndef REAL_VALUE_TYPE
#define REAL_VALUE_TYPE double
#else
#define REAL_IS_NOT_DOUBLE
#endif
#if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
/* Convert a type `double' value in host format first to a type `float'
value in host format and then to a single type `long' value which
is the bitwise equivalent of the `float' value. */
#ifndef REAL_VALUE_TO_TARGET_SINGLE
#define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \
do { \
union { \
float f; \
HOST_WIDE_INT l; \
} u; \
if (sizeof(HOST_WIDE_INT) < sizeof(float)) \
abort (); \
u.l = 0; \
u.f = (IN); \
(OUT) = u.l; \
} while (0)
#endif
/* Convert a type `double' value in host format to a pair of type `long'
values which is its bitwise equivalent, but put the two words into
proper word order for the target. */
#ifndef REAL_VALUE_TO_TARGET_DOUBLE
#define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \
do { \
union { \
REAL_VALUE_TYPE f; \
HOST_WIDE_INT l[2]; \
} u; \
if (sizeof(HOST_WIDE_INT) * 2 < sizeof(REAL_VALUE_TYPE)) \
abort (); \
u.l[0] = u.l[1] = 0; \
u.f = (IN); \
if (HOST_FLOAT_WORDS_BIG_ENDIAN == FLOAT_WORDS_BIG_ENDIAN) \
(OUT)[0] = u.l[0], (OUT)[1] = u.l[1]; \
else \
(OUT)[1] = u.l[0], (OUT)[0] = u.l[1]; \
} while (0)
#endif
#endif /* HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT */
/* In this configuration, double and long double are the same. */
#ifndef REAL_VALUE_TO_TARGET_LONG_DOUBLE
#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(a, b) REAL_VALUE_TO_TARGET_DOUBLE (a, b)
#endif
/* Compare two floating-point objects for bitwise identity.
This is not the same as comparing for equality on IEEE hosts:
-0.0 equals 0.0 but they are not identical, and conversely
two NaNs might be identical but they cannot be equal. */
#define REAL_VALUES_IDENTICAL(x, y) \
(!memcmp ((char *) &(x), (char *) &(y), sizeof (REAL_VALUE_TYPE)))
/* Compare two floating-point values for equality. */
#ifndef REAL_VALUES_EQUAL
#define REAL_VALUES_EQUAL(x, y) ((x) == (y))
#endif
/* Compare two floating-point values for less than. */
#ifndef REAL_VALUES_LESS
#define REAL_VALUES_LESS(x, y) ((x) < (y))
#endif
/* Truncate toward zero to an integer floating-point value. */
#ifndef REAL_VALUE_RNDZINT
#define REAL_VALUE_RNDZINT(x) ((double) ((int) (x)))
#endif
/* Truncate toward zero to an unsigned integer floating-point value. */
#ifndef REAL_VALUE_UNSIGNED_RNDZINT
#define REAL_VALUE_UNSIGNED_RNDZINT(x) ((double) ((unsigned int) (x)))
#endif
/* Convert a floating-point value to integer, rounding toward zero. */
#ifndef REAL_VALUE_FIX
#define REAL_VALUE_FIX(x) ((int) (x))
#endif
/* Convert a floating-point value to unsigned integer, rounding
toward zero. */
#ifndef REAL_VALUE_UNSIGNED_FIX
#define REAL_VALUE_UNSIGNED_FIX(x) ((unsigned int) (x))
#endif
/* Scale X by Y powers of 2. */
#ifndef REAL_VALUE_LDEXP
#define REAL_VALUE_LDEXP(x, y) ldexp (x, y)
extern double ldexp PARAMS ((double, int));
#endif
/* Convert the string X to a floating-point value. */
#ifndef REAL_VALUE_ATOF
#if 1
/* Use real.c to convert decimal numbers to binary, ... */
#define REAL_VALUE_ATOF(x, s) ereal_atof (x, s)
/* Could use ereal_atof here for hexadecimal floats too, but real_hex_to_f
is OK and it uses faster native fp arithmetic. */
/* #define REAL_VALUE_HTOF(x, s) ereal_atof (x, s) */
#else
/* ... or, if you like the host computer's atof, go ahead and use it: */
#define REAL_VALUE_ATOF(x, s) atof (x)
#if defined (MIPSEL) || defined (MIPSEB)
/* MIPS compiler can't handle parens around the function name.
This problem *does not* appear to be connected with any
macro definition for atof. It does not seem there is one. */
extern double atof ();
#else
extern double (atof) ();
#endif
#endif
#endif
/* Hexadecimal floating constant input for use with host computer's
fp arithmetic. */
#ifndef REAL_VALUE_HTOF
extern REAL_VALUE_TYPE real_hex_to_f PARAMS ((const char *,
enum machine_mode));
#define REAL_VALUE_HTOF(s,m) real_hex_to_f(s,m)
#endif
/* Negate the floating-point value X. */
#ifndef REAL_VALUE_NEGATE
#define REAL_VALUE_NEGATE(x) (- (x))
#endif
/* Truncate the floating-point value X to mode MODE. This is correct only
for the most common case where the host and target have objects of the same
size and where `float' is SFmode. */
/* Don't use REAL_VALUE_TRUNCATE directly--always call real_value_truncate. */
extern REAL_VALUE_TYPE real_value_truncate PARAMS ((enum machine_mode,
REAL_VALUE_TYPE));
#ifndef REAL_VALUE_TRUNCATE
#define REAL_VALUE_TRUNCATE(mode, x) \
(GET_MODE_BITSIZE (mode) == sizeof (float) * HOST_BITS_PER_CHAR \
? (float) (x) : (x))
#endif
/* Determine whether a floating-point value X is infinite. */
#ifndef REAL_VALUE_ISINF
#define REAL_VALUE_ISINF(x) (target_isinf (x))
#endif
/* Determine whether a floating-point value X is a NaN. */
#ifndef REAL_VALUE_ISNAN
#define REAL_VALUE_ISNAN(x) (target_isnan (x))
#endif
/* Determine whether a floating-point value X is negative. */
#ifndef REAL_VALUE_NEGATIVE
#define REAL_VALUE_NEGATIVE(x) (target_negative (x))
#endif
/* Determine whether a floating-point value X is minus 0. */
#ifndef REAL_VALUE_MINUS_ZERO
#define REAL_VALUE_MINUS_ZERO(x) ((x) == 0 && REAL_VALUE_NEGATIVE (x))
#endif
/* Constant real values 0, 1, 2, and -1. */
@ -466,14 +273,6 @@ do { union real_extract u; \
extern struct rtx_def *immed_real_const_1 PARAMS ((REAL_VALUE_TYPE,
enum machine_mode));
/* Convert a floating point value `r', that can be interpreted
as a host machine float or double, to a decimal ASCII string `s'
using printf format string `fmt'. */
#ifndef REAL_VALUE_TO_DECIMAL
#define REAL_VALUE_TO_DECIMAL(r, fmt, s) (sprintf (s, fmt, r))
#endif
/* Replace R by 1/R in the given machine mode, if the result is exact. */
extern int exact_real_inverse PARAMS ((enum machine_mode, REAL_VALUE_TYPE *));
extern int target_isnan PARAMS ((REAL_VALUE_TYPE));

22
gcc/recog.c
View file

@ -1716,16 +1716,6 @@ asm_operand_ok (op, constraint)
break;
case 'E':
#ifndef REAL_ARITHMETIC
/* Match any floating double constant, but only if
we can examine the bits of it reliably. */
if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
|| HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
&& GET_MODE (op) != VOIDmode && ! flag_pretend_float)
break;
#endif
/* FALLTHRU */
case 'F':
if (GET_CODE (op) == CONST_DOUBLE)
return 1;
@ -2492,18 +2482,6 @@ constrain_operands (strict)
break;
case 'E':
#ifndef REAL_ARITHMETIC
/* Match any CONST_DOUBLE, but only if
we can examine the bits of it reliably. */
if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
|| HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
&& GET_MODE (op) != VOIDmode && ! flag_pretend_float)
break;
#endif
if (GET_CODE (op) == CONST_DOUBLE)
win = 1;
break;
case 'F':
if (GET_CODE (op) == CONST_DOUBLE)
win = 1;

12
gcc/regclass.c
View file

@ -1635,18 +1635,6 @@ record_reg_classes (n_alts, n_ops, ops, modes,
break;
case 'E':
#ifndef REAL_ARITHMETIC
/* Match any floating double constant, but only if
we can examine the bits of it reliably. */
if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
|| HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
&& GET_MODE (op) != VOIDmode && ! flag_pretend_float)
break;
#endif
if (GET_CODE (op) == CONST_DOUBLE)
win = 1;
break;
case 'F':
if (GET_CODE (op) == CONST_DOUBLE)
win = 1;

12
gcc/reload.c
View file

@ -3121,18 +3121,6 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
break;
case 'E':
#ifndef REAL_ARITHMETIC
/* Match any floating double constant, but only if
we can examine the bits of it reliably. */
if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
|| HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
&& GET_MODE (operand) != VOIDmode && ! flag_pretend_float)
break;
#endif
if (GET_CODE (operand) == CONST_DOUBLE)
win = 1;
break;
case 'F':
if (GET_CODE (operand) == CONST_DOUBLE)
win = 1;

24
gcc/rtl.c
View file

@ -30,30 +30,28 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
/* Calculate the format for CONST_DOUBLE. This depends on the relative
widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
We need to go out to 0wwwww, since REAL_ARITHMETIC assumes 16-bits
per element in REAL_VALUE_TYPE.
We need to go out to 0wwwww, since real.c assumes 16 bits per element
in REAL_VALUE_TYPE.
This is duplicated in gengenrtl.c.
A number of places assume that there are always at least two 'w'
slots in a CONST_DOUBLE, so we provide them even if one would suffice. */
#ifdef REAL_ARITHMETIC
# if MAX_LONG_DOUBLE_TYPE_SIZE == 96
# define REAL_WIDTH \
#if MAX_LONG_DOUBLE_TYPE_SIZE == 96
# define REAL_WIDTH \
(11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
# else
# if MAX_LONG_DOUBLE_TYPE_SIZE == 128
# define REAL_WIDTH \
#else
# if MAX_LONG_DOUBLE_TYPE_SIZE == 128
# define REAL_WIDTH \
(19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
# else
# if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
# define REAL_WIDTH \
# else
# if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
# define REAL_WIDTH \
(7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
# endif
# endif
# endif
#endif /* REAL_ARITHMETIC */
#endif
#ifndef REAL_WIDTH
# if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE

80
gcc/simplify-rtx.c
View file

@ -102,10 +102,8 @@ static rtx simplify_plus_minus PARAMS ((enum rtx_code,
enum machine_mode, rtx,
rtx, int));
static void check_fold_consts PARAMS ((PTR));
#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
static void simplify_unary_real PARAMS ((PTR));
static void simplify_binary_real PARAMS ((PTR));
#endif
static void simplify_binary_is2orm1 PARAMS ((PTR));
@ -339,7 +337,6 @@ simplify_replace_rtx (x, old, new)
return x;
}
#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
/* Subroutine of simplify_unary_operation, called via do_float_handler.
Handles simplification of unary ops on floating point values. */
struct simplify_unary_real_args
@ -398,7 +395,6 @@ simplify_unary_real (p)
args->result = CONST_DOUBLE_FROM_REAL_VALUE (d, args->mode);
}
}
#endif
/* Try to simplify a unary operation CODE whose output mode is to be
MODE with input operand OP whose mode was originally OP_MODE.
@ -417,8 +413,6 @@ simplify_unary_operation (code, mode, op, op_mode)
check the wrong mode (input vs. output) for a conversion operation,
such as FIX. At some point, this should be simplified. */
#if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
if (code == FLOAT && GET_MODE (trueop) == VOIDmode
&& (GET_CODE (trueop) == CONST_DOUBLE || GET_CODE (trueop) == CONST_INT))
{
@ -430,25 +424,7 @@ simplify_unary_operation (code, mode, op, op_mode)
else
lv = CONST_DOUBLE_LOW (trueop), hv = CONST_DOUBLE_HIGH (trueop);
#ifdef REAL_ARITHMETIC
REAL_VALUE_FROM_INT (d, lv, hv, mode);
#else
if (hv < 0)
{
d = (double) (~ hv);
d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d += (double) (unsigned HOST_WIDE_INT) (~ lv);
d = (- d - 1.0);
}
else
{
d = (double) hv;
d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d += (double) (unsigned HOST_WIDE_INT) lv;
}
#endif /* REAL_ARITHMETIC */
d = real_value_truncate (mode, d);
return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
}
@ -476,19 +452,10 @@ simplify_unary_operation (code, mode, op, op_mode)
else
hv = 0, lv &= GET_MODE_MASK (op_mode);
#ifdef REAL_ARITHMETIC
REAL_VALUE_FROM_UNSIGNED_INT (d, lv, hv, mode);
#else
d = (double) (unsigned HOST_WIDE_INT) hv;
d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d += (double) (unsigned HOST_WIDE_INT) lv;
#endif /* REAL_ARITHMETIC */
d = real_value_truncate (mode, d);
return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
}
#endif
if (GET_CODE (trueop) == CONST_INT
&& width <= HOST_BITS_PER_WIDE_INT && width > 0)
@ -664,7 +631,6 @@ simplify_unary_operation (code, mode, op, op_mode)
return immed_double_const (lv, hv, mode);
}
#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
else if (GET_CODE (trueop) == CONST_DOUBLE
&& GET_MODE_CLASS (mode) == MODE_FLOAT)
{
@ -696,7 +662,7 @@ simplify_unary_operation (code, mode, op, op_mode)
return 0;
}
#endif
/* This was formerly used only for non-IEEE float.
eggert@twinsun.com says it is safe for IEEE also. */
else
@ -770,7 +736,6 @@ simplify_unary_operation (code, mode, op, op_mode)
}
}
#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
/* Subroutine of simplify_binary_operation, called via do_float_handler.
Handles simplification of binary ops on floating point values. */
struct simplify_binary_real_args
@ -794,7 +759,6 @@ simplify_binary_real (p)
f0 = real_value_truncate (args->mode, f0);
f1 = real_value_truncate (args->mode, f1);
#ifdef REAL_ARITHMETIC
#ifndef REAL_INFINITY
if (args->code == DIV && REAL_VALUES_EQUAL (f1, dconst0))
{
@ -803,40 +767,10 @@ simplify_binary_real (p)
}
#endif
REAL_ARITHMETIC (value, rtx_to_tree_code (args->code), f0, f1);
#else
switch (args->code)
{
case PLUS:
value = f0 + f1;
break;
case MINUS:
value = f0 - f1;
break;
case MULT:
value = f0 * f1;
break;
case DIV:
#ifndef REAL_INFINITY
if (f1 == 0)
return 0;
#endif
value = f0 / f1;
break;
case SMIN:
value = MIN (f0, f1);
break;
case SMAX:
value = MAX (f0, f1);
break;
default:
abort ();
}
#endif
value = real_value_truncate (args->mode, value);
args->result = CONST_DOUBLE_FROM_REAL_VALUE (value, args->mode);
}
#endif
/* Another subroutine called via do_float_handler. This one tests
the floating point value given against 2. and -1. */
@ -894,7 +828,6 @@ simplify_binary_operation (code, mode, op0, op1)
tem = trueop0, trueop0 = trueop1, trueop1 = tem;
}
#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
if (GET_MODE_CLASS (mode) == MODE_FLOAT
&& GET_CODE (trueop0) == CONST_DOUBLE
&& GET_CODE (trueop1) == CONST_DOUBLE
@ -910,7 +843,6 @@ simplify_binary_operation (code, mode, op0, op1)
return args.result;
return 0;
}
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
/* We can fold some multi-word operations. */
if (GET_MODE_CLASS (mode) == MODE_INT
@ -1432,7 +1364,6 @@ simplify_binary_operation (code, mode, op0, op1)
&& ! side_effects_p (op1))
return op0;
#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
/* Change division by a constant into multiplication. Only do
this with -funsafe-math-optimizations. */
else if (GET_CODE (trueop1) == CONST_DOUBLE
@ -1445,18 +1376,11 @@ simplify_binary_operation (code, mode, op0, op1)
if (! REAL_VALUES_EQUAL (d, dconst0))
{
#if defined (REAL_ARITHMETIC)
REAL_ARITHMETIC (d, rtx_to_tree_code (DIV), dconst1, d);
return gen_rtx_MULT (mode, op0,
CONST_DOUBLE_FROM_REAL_VALUE (d, mode));
#else
return
gen_rtx_MULT (mode, op0,
CONST_DOUBLE_FROM_REAL_VALUE (1./d, mode));
#endif
}
}
#endif
break;
case UMOD:
@ -2102,7 +2026,6 @@ simplify_relational_operation (code, mode, op0, op1)
/* If the operands are floating-point constants, see if we can fold
the result. */
#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
else if (GET_CODE (trueop0) == CONST_DOUBLE
&& GET_CODE (trueop1) == CONST_DOUBLE
&& GET_MODE_CLASS (GET_MODE (trueop0)) == MODE_FLOAT)
@ -2145,7 +2068,6 @@ simplify_relational_operation (code, mode, op0, op1)
op0lt = op0ltu = args.op0lt;
op1lt = op1ltu = args.op1lt;
}
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
/* Otherwise, see if the operands are both integers. */
else if ((GET_MODE_CLASS (mode) == MODE_INT || mode == VOIDmode)

8
gcc/toplev.c
View file

@ -726,12 +726,6 @@ int flag_asynchronous_unwind_tables = 0;
int flag_no_common;
/* Nonzero means pretend it is OK to examine bits of target floats,
even if that isn't true. The resulting code will have incorrect constants,
but the same series of instructions that the native compiler would make. */
int flag_pretend_float;
/* Nonzero means change certain warnings into errors.
Usually these are warnings about failure to conform to some standard. */
@ -1055,8 +1049,6 @@ static const lang_independent_options f_options[] =
N_("Run the loop optimizer twice") },
{"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1,
N_("Delete useless null pointer checks") },
{"pretend-float", &flag_pretend_float, 1,
N_("Pretend that host and target use the same FP format") },
{"schedule-insns", &flag_schedule_insns, 1,
N_("Reschedule instructions before register allocation") },
{"schedule-insns2", &flag_schedule_insns_after_reload, 1,

38
gcc/tree.c
View file

@ -613,15 +613,12 @@ build_real (type, d)
/* Return a new REAL_CST node whose type is TYPE
and whose value is the integer value of the INTEGER_CST node I. */
#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
REAL_VALUE_TYPE
real_value_from_int_cst (type, i)
tree type ATTRIBUTE_UNUSED, i;
{
REAL_VALUE_TYPE d;
#ifdef REAL_ARITHMETIC
/* Clear all bits of the real value type so that we can later do
bitwise comparisons to see if two values are the same. */
memset ((char *) &d, 0, sizeof d);
@ -632,33 +629,6 @@ real_value_from_int_cst (type, i)
else
REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i),
TREE_INT_CST_HIGH (i), TYPE_MODE (type));
#else /* not REAL_ARITHMETIC */
/* Some 386 compilers mishandle unsigned int to float conversions,
so introduce a temporary variable E to avoid those bugs. */
if (TREE_INT_CST_HIGH (i) < 0 && ! TREE_UNSIGNED (TREE_TYPE (i)))
{
REAL_VALUE_TYPE e;
d = (double) (~TREE_INT_CST_HIGH (i));
e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d *= e;
e = (double) (~TREE_INT_CST_LOW (i));
d += e;
d = (- d - 1.0);
}
else
{
REAL_VALUE_TYPE e;
d = (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (i);
e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
* (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
d *= e;
e = (double) TREE_INT_CST_LOW (i);
d += e;
}
#endif /* not REAL_ARITHMETIC */
return d;
}
@ -680,13 +650,7 @@ build_real_from_int_cst_1 (data)
{
struct brfic_args *args = (struct brfic_args *) data;
#ifdef REAL_ARITHMETIC
args->d = real_value_from_int_cst (args->type, args->i);
#else
args->d
= REAL_VALUE_TRUNCATE (TYPE_MODE (args->type),
real_value_from_int_cst (args->type, args->i));
#endif
}
/* Given a tree representing an integer constant I, return a tree
@ -732,8 +696,6 @@ build_real_from_int_cst (type, i)
return v;
}
#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
/* Return a newly constructed STRING_CST node whose value is
the LEN characters at STR.
The TREE_TYPE is not initialized. */