+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,
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,
* 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
* 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,
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,
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.
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>
\f
/* 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
#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
#undef ASM_OUTPUT_MAX_SKIP_ALIGN
#define ASM_OUTPUT_MAX_SKIP_ALIGN(STREAM,POWER,MAXSKIP)
\f
-/* 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
\f
/* 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
/* 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
/* 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
#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. */
#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. */
#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
\f
/* Target machine storage layout */
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))
/* Node: SDB and DWARF */
/* (no definitions) */
-/* Node: Cross-compilation */
-#define REAL_ARITHMETIC
-
-
/* Node: Misc */
/* FIXME: Check this one more time. */
/* 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) */
-
\f
/* Output of Uninitialized Variables. */
/* #define SDB_ALLOW_FORWARD_REFERENCES */
\f
-/* 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) */
-
\f
/* Miscellaneous Parameters. */
\f
/* 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.
*/
\f
/* 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. */
#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"
/* 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.
*/
#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. */
} \
} \
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
\f
/* 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
assemble_name (FILE, LABEL); \
fputc (')', FILE); \
} while (0)
-\f
-/* Cross Compilation and Floating Point. */
-
-/* Define to enable software floating point emulation. */
-#define REAL_ARITHMETIC
-
\f
/* Register Renaming Parameters. */
\f
/* 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
/* 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
#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)
/* 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
#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
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 ();
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))
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 ();
\f
/* 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.
#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__
#define DBX_DEBUGGING_INFO
-/* Allow folding division by zero. */
-#define REAL_INFINITY
-
/* Generate calls to memcpy, memcmp and memset. */
#define TARGET_MEM_FUNCTIONS
#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
/* 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) \
\f
/* 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 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 \
((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
+ (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
\f
/* 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
\f
/* 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
\f
/* 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
#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
#define STRICT_ALIGNMENT 0
-/* real arithmetic */
-
-#define REAL_ARITHMETIC
-
/* Define target floating point format. */
#undef TARGET_FLOAT_FORMAT
\f
/* 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. */
#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)
sprintf (LABEL, "*.L%s%ld", PREFIX, (long)(NUM))
\f
-/* 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)
#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)
\f
/* ??? 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
\f
/* 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
#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
\f
/* ??? 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
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) */
-
\f
/* Output of Uninitialized Variables. */
\f
/* 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
#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)
\f
/* 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. */
/* 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)
-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
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
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
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
@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.
}
}
-#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 ...)). */
mode);
#endif
}
-#endif /* ifndef REAL_ARITHMETIC */
/* Otherwise, we can't do this. */
return 0;
&& 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. */
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)
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.
+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.
{
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);
}
#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)
?
#endif
#if FFETARGET_okREAL1
-#ifdef REAL_ARITHMETIC
#ifdef FFETARGET_32bit_longs
typedef long int ffetargetReal1;
#define ffetargetReal1_f "l"
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
{
(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
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); \
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)); \
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)
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])); \
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); \
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), \
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); \
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); \
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); \
((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) \
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)
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) \
#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); \
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) \
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) \
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); \
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))
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)); \
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); \
*(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) \
(*(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)); \
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)
(*(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)); \
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) \
(*(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)); \
*(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)
#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)); \
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) \
(*(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)); \
*(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) \
(*(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)); \
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)); \
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); \
*(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) \
(*(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)); \
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)
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)); \
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); \
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)); \
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()
#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); \
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)); \
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)
}
else
{
-#ifdef REAL_ARITHMETIC
REAL_VALUE_TYPE r;
long l[2];
REAL_VALUE_FROM_CONST_DOUBLE (r, value);
*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 */
}
}
\f
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. */
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));
return overflow;
}
\f
-#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 */
-\f
/* Given T, an expression, return the negation of T. Allow for T to be
null, in which case return null. */
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,
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;
| 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);
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.
/* 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))
&& 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;
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
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. */
}
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)
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)
/* 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
+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
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
{
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;
}
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;
}
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));
}
}
-#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)
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. */
}
}
-#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
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
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");
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, ">");
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");
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;
/* 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
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
/* 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
#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)
#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. */
} \
} 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 */
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
PUT_REAL (einv, r);
return 1;
}
-#endif /* REAL_ARITHMETIC defined */
/* Used for debugging--print the value of R in human-readable format
on stderr. */
return (eisneg (ex));
}
-/* End of REAL_ARITHMETIC interface */
\f
/*
Extended precision IEEE binary floating point arithmetic routines
#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
#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;
#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;
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))
#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. */
#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 ))
/* 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
\f
/* Constant real values 0, 1, 2, and -1. */
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));
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;
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;
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;
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;
/* 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 \
+ (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
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));
\f
return x;
}
\f
-#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
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.
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))
{
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);
}
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)
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)
{
return 0;
}
-#endif
+
/* This was formerly used only for non-IEEE float.
eggert@twinsun.com says it is safe for IEEE also. */
else
}
}
\f
-#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
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))
{
}
#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. */
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
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
&& ! 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
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:
/* 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)
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)
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. */
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,
/* 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);
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;
}
{
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
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. */
projects / thirdparty / gcc.git / commitdiff
