diff options
86 files changed, 423 insertions, 333 deletions
diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 026f862..ae7e21d 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -28406,6 +28406,18 @@ aarch64_bitint_type_info (int n, struct bitint_info *info) return true; } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return TFmode for + TI_LONG_DOUBLE_TYPE which is for long double type, go with the default + one for the others. */ + +static machine_mode +aarch64_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return TFmode; + return default_mode_for_floating_type (ti); +} + /* Implement TARGET_SCHED_CAN_SPECULATE_INSN. Return true if INSN can be scheduled for speculative execution. Reject the long-running division and square-root instructions. */ @@ -30533,6 +30545,9 @@ aarch64_run_selftests (void) #undef TARGET_C_BITINT_TYPE_INFO #define TARGET_C_BITINT_TYPE_INFO aarch64_bitint_type_info +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE aarch64_c_mode_for_floating_type + #undef TARGET_EXPAND_BUILTIN #define TARGET_EXPAND_BUILTIN aarch64_expand_builtin diff --git a/gcc/config/aarch64/aarch64.h b/gcc/config/aarch64/aarch64.h index 2b89f6f..fac1882 100644 --- a/gcc/config/aarch64/aarch64.h +++ b/gcc/config/aarch64/aarch64.h @@ -96,12 +96,6 @@ #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 - -#define DOUBLE_TYPE_SIZE 64 - -#define LONG_DOUBLE_TYPE_SIZE 128 - /* This value is the amount of bytes a caller is allowed to drop the stack before probing has to be done for stack clash protection. */ #define STACK_CLASH_CALLER_GUARD 1024 diff --git a/gcc/config/alpha/alpha.cc b/gcc/config/alpha/alpha.cc index 1126cea..a6fe95e 100644 --- a/gcc/config/alpha/alpha.cc +++ b/gcc/config/alpha/alpha.cc @@ -9916,7 +9916,19 @@ alpha_can_change_mode_class (machine_mode from, machine_mode to, return (GET_MODE_SIZE (from) == GET_MODE_SIZE (to) || !reg_classes_intersect_p (FLOAT_REGS, rclass)); } - + +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return TFmode or DFmode + for TI_LONG_DOUBLE_TYPE which is for long double type, go with the + default one for the others. */ + +static machine_mode +alpha_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return TARGET_LONG_DOUBLE_128 ? TFmode : DFmode; + return default_mode_for_floating_type (ti); +} + /* Initialize the GCC target structure. */ #if TARGET_ABI_OPEN_VMS # undef TARGET_ATTRIBUTE_TABLE @@ -10123,6 +10135,9 @@ alpha_can_change_mode_class (machine_mode from, machine_mode to, #undef TARGET_CAN_CHANGE_MODE_CLASS #define TARGET_CAN_CHANGE_MODE_CLASS alpha_can_change_mode_class +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE alpha_c_mode_for_floating_type + struct gcc_target targetm = TARGET_INITIALIZER; diff --git a/gcc/config/alpha/alpha.h b/gcc/config/alpha/alpha.h index 25ccfce..ee9e091 100644 --- a/gcc/config/alpha/alpha.h +++ b/gcc/config/alpha/alpha.h @@ -195,14 +195,6 @@ extern enum alpha_fp_trap_mode alpha_fptm; /* Define the size of `long long'. The default is the twice the word size. */ #define LONG_LONG_TYPE_SIZE 64 -/* The two floating-point formats we support are S-floating, which is - 4 bytes, and T-floating, which is 8 bytes. `float' is S and `double' - and `long double' are T. */ - -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64) - /* Work around target_flags dependency in ada/targtyps.cc. */ #define WIDEST_HARDWARE_FP_SIZE 64 diff --git a/gcc/config/arc/arc.h b/gcc/config/arc/arc.h index f3b43882..0a1ecb7 100644 --- a/gcc/config/arc/arc.h +++ b/gcc/config/arc/arc.h @@ -296,9 +296,6 @@ if (GET_MODE_CLASS (MODE) == MODE_INT \ #define INT_TYPE_SIZE 32 #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 /* Define this as 1 if `char' should by default be signed; else as 0. */ #define DEFAULT_SIGNED_CHAR 0 diff --git a/gcc/config/avr/avr.cc b/gcc/config/avr/avr.cc index 74924ab..61c325f 100644 --- a/gcc/config/avr/avr.cc +++ b/gcc/config/avr/avr.cc @@ -6930,6 +6930,20 @@ avr_canonicalize_comparison (int *icode, rtx *op0, rtx *op1, bool op0_fixed) } } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return SFmode or DFmode + for TI_{LONG_,}DOUBLE_TYPE which is for {long,} double type, go with + the default one for the others. */ + +static machine_mode +avr_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_DOUBLE_TYPE) + return avr_double == 32 ? SFmode : DFmode; + if (ti == TI_LONG_DOUBLE_TYPE) + return avr_long_double == 32 ? SFmode : DFmode; + return default_mode_for_floating_type (ti); +} + /* Output compare instruction @@ -16411,6 +16425,9 @@ avr_float_lib_compare_returns_bool (machine_mode mode, enum rtx_code) #undef TARGET_HAVE_SPECULATION_SAFE_VALUE #define TARGET_HAVE_SPECULATION_SAFE_VALUE speculation_safe_value_not_needed +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE avr_c_mode_for_floating_type + struct gcc_target targetm = TARGET_INITIALIZER; diff --git a/gcc/config/avr/avr.h b/gcc/config/avr/avr.h index 56211fa..4977e15 100644 --- a/gcc/config/avr/avr.h +++ b/gcc/config/avr/avr.h @@ -143,9 +143,6 @@ FIXME: DRIVER_SELF_SPECS has changed. #define SHORT_TYPE_SIZE (INT_TYPE_SIZE == 8 ? INT_TYPE_SIZE : 16) #define LONG_TYPE_SIZE (INT_TYPE_SIZE == 8 ? 16 : 32) #define LONG_LONG_TYPE_SIZE (INT_TYPE_SIZE == 8 ? 32 : 64) -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE (avr_double) -#define LONG_DOUBLE_TYPE_SIZE (avr_long_double) #define LONG_LONG_ACCUM_TYPE_SIZE 64 diff --git a/gcc/config/bfin/bfin.h b/gcc/config/bfin/bfin.h index e6ac8e3..e957c31 100644 --- a/gcc/config/bfin/bfin.h +++ b/gcc/config/bfin/bfin.h @@ -862,10 +862,10 @@ typedef struct { * really cause some alignment problem */ -#define UNITS_PER_FLOAT ((FLOAT_TYPE_SIZE + BITS_PER_UNIT - 1) / \ +#define UNITS_PER_FLOAT ((BFIN_FLOAT_TYPE_SIZE + BITS_PER_UNIT - 1) / \ BITS_PER_UNIT) -#define UNITS_PER_DOUBLE ((DOUBLE_TYPE_SIZE + BITS_PER_UNIT - 1) / \ +#define UNITS_PER_DOUBLE ((BFIN_DOUBLE_TYPE_SIZE + BITS_PER_UNIT - 1) / \ BITS_PER_UNIT) @@ -874,7 +874,8 @@ typedef struct { /* Define this as 1 if `char' should by default be signed; else as 0. */ #define DEFAULT_SIGNED_CHAR 1 -#define FLOAT_TYPE_SIZE BITS_PER_WORD +/* FLOAT_TYPE_SIZE get poisoned, so add BFIN_ prefix. */ +#define BFIN_FLOAT_TYPE_SIZE BITS_PER_WORD #define SHORT_TYPE_SIZE 16 #define CHAR_TYPE_SIZE 8 #define INT_TYPE_SIZE 32 @@ -890,8 +891,8 @@ typedef struct { * #define DOUBLES_ARE_FLOATS 1 */ -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 +/* DOUBLE_TYPE_SIZE get poisoned, so add BFIN_ prefix. */ +#define BFIN_DOUBLE_TYPE_SIZE 64 /* `PROMOTE_MODE (M, UNSIGNEDP, TYPE)' A macro to update M and UNSIGNEDP when an object whose type is diff --git a/gcc/config/bpf/bpf.h b/gcc/config/bpf/bpf.h index e163fbf..2298e5b 100644 --- a/gcc/config/bpf/bpf.h +++ b/gcc/config/bpf/bpf.h @@ -90,9 +90,6 @@ #define LONG_TYPE_SIZE 64 #define LONG_LONG_TYPE_SIZE 64 #define CHAR_TYPE_SIZE 8 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 #define INTPTR_TYPE "long int" #define UINTPTR_TYPE "long unsigned int" diff --git a/gcc/config/epiphany/epiphany.h b/gcc/config/epiphany/epiphany.h index 1df9eeec..aa4715b 100644 --- a/gcc/config/epiphany/epiphany.h +++ b/gcc/config/epiphany/epiphany.h @@ -188,9 +188,6 @@ along with GCC; see the file COPYING3. If not see #define INT_TYPE_SIZE 32 #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 /* Define this as 1 if `char' should by default be signed; else as 0. */ #define DEFAULT_SIGNED_CHAR 0 diff --git a/gcc/config/fr30/fr30.h b/gcc/config/fr30/fr30.h index 2a2674c..19020fb 100644 --- a/gcc/config/fr30/fr30.h +++ b/gcc/config/fr30/fr30.h @@ -99,9 +99,6 @@ along with GCC; see the file COPYING3. If not see #define INT_TYPE_SIZE 32 #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 #define DEFAULT_SIGNED_CHAR 1 diff --git a/gcc/config/frv/frv.h b/gcc/config/frv/frv.h index 60225ee..b16103a 100644 --- a/gcc/config/frv/frv.h +++ b/gcc/config/frv/frv.h @@ -366,9 +366,6 @@ #define INT_TYPE_SIZE 32 #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 /* An expression whose value is 1 or 0, according to whether the type `char' should be signed or unsigned by default. The user can always override this diff --git a/gcc/config/ft32/ft32.h b/gcc/config/ft32/ft32.h index 6d892a5..1803d5b 100644 --- a/gcc/config/ft32/ft32.h +++ b/gcc/config/ft32/ft32.h @@ -53,10 +53,6 @@ #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 - #define DEFAULT_SIGNED_CHAR 1 #undef SIZE_TYPE diff --git a/gcc/config/gcn/gcn.h b/gcc/config/gcn/gcn.h index afa6153..e3bfd29 100644 --- a/gcc/config/gcn/gcn.h +++ b/gcc/config/gcn/gcn.h @@ -111,9 +111,6 @@ #define INT_TYPE_SIZE 32 #define LONG_TYPE_SIZE 64 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 #define DEFAULT_SIGNED_CHAR 1 #define PCC_BITFIELD_TYPE_MATTERS 1 diff --git a/gcc/config/h8300/h8300.cc b/gcc/config/h8300/h8300.cc index 9ac6d52..7ab26f2 100644 --- a/gcc/config/h8300/h8300.cc +++ b/gcc/config/h8300/h8300.cc @@ -5601,6 +5601,18 @@ h8300_ok_for_sibcall_p (tree fndecl, tree) return 1; } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return SFmode or DFmode + for TI_{LONG_,}DOUBLE_TYPE which is for {long,} double type, go with + the default one for the others. */ + +static machine_mode +h8300_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_DOUBLE_TYPE || ti == TI_LONG_DOUBLE_TYPE) + return DOUBLE_TYPE_MODE; + return default_mode_for_floating_type (ti); +} + /* Return TRUE if OP is a PRE_INC or PRE_DEC instruction using REG, FALSE otherwise. */ @@ -5721,4 +5733,7 @@ pre_incdec_with_reg (rtx op, unsigned int reg) #undef TARGET_FUNCTION_OK_FOR_SIBCALL #define TARGET_FUNCTION_OK_FOR_SIBCALL h8300_ok_for_sibcall_p +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE h8300_c_mode_for_floating_type + struct gcc_target targetm = TARGET_INITIALIZER; diff --git a/gcc/config/h8300/h8300.h b/gcc/config/h8300/h8300.h index bb0bf74..d25689c 100644 --- a/gcc/config/h8300/h8300.h +++ b/gcc/config/h8300/h8300.h @@ -149,9 +149,7 @@ extern const char * const *h8_reg_names; #define INT_TYPE_SIZE (TARGET_INT32 ? 32 : 16) #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 32 -#define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE +#define DOUBLE_TYPE_MODE SFmode #define MAX_FIXED_MODE_SIZE 32 diff --git a/gcc/config/h8300/linux.h b/gcc/config/h8300/linux.h index 326c481..6e21db3 100644 --- a/gcc/config/h8300/linux.h +++ b/gcc/config/h8300/linux.h @@ -36,8 +36,8 @@ along with GCC; see the file COPYING3. If not see #define TARGET_DEFAULT (MASK_QUICKCALL | MASK_INT32 | MASK_H8300H) /* Width of a word, in units (bytes). */ -#undef DOUBLE_TYPE_SIZE -#define DOUBLE_TYPE_SIZE 64 +#undef DOUBLE_TYPE_MODE +#define DOUBLE_TYPE_MODE DFmode #undef DEFAULT_SIGNED_CHAR #define DEFAULT_SIGNED_CHAR 1 diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index d4ccc24..4185857 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -26109,6 +26109,19 @@ ix86_bitint_type_info (int n, struct bitint_info *info) return true; } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return DFmode, TFmode + or XFmode for TI_LONG_DOUBLE_TYPE which is for long double type, + based on long double bits, go with the default one for the others. */ + +static machine_mode +ix86_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return (TARGET_LONG_DOUBLE_64 ? DFmode + : (TARGET_LONG_DOUBLE_128 ? TFmode : XFmode)); + return default_mode_for_floating_type (ti); +} + /* Returns modified FUNCTION_TYPE for cdtor callabi. */ tree ix86_cxx_adjust_cdtor_callabi_fntype (tree fntype) @@ -26741,6 +26754,8 @@ static const scoped_attribute_specs *const ix86_attribute_table[] = #define TARGET_C_EXCESS_PRECISION ix86_get_excess_precision #undef TARGET_C_BITINT_TYPE_INFO #define TARGET_C_BITINT_TYPE_INFO ix86_bitint_type_info +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE ix86_c_mode_for_floating_type #undef TARGET_CXX_ADJUST_CDTOR_CALLABI_FNTYPE #define TARGET_CXX_ADJUST_CDTOR_CALLABI_FNTYPE ix86_cxx_adjust_cdtor_callabi_fntype #undef TARGET_PROMOTE_PROTOTYPES diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h index ff5ed32..a204c92 100644 --- a/gcc/config/i386/i386.h +++ b/gcc/config/i386/i386.h @@ -678,10 +678,6 @@ extern const char *host_detect_local_cpu (int argc, const char **argv); #define LONG_TYPE_SIZE (TARGET_X32 ? 32 : BITS_PER_WORD) #define POINTER_SIZE (TARGET_X32 ? 32 : BITS_PER_WORD) #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE \ - (TARGET_LONG_DOUBLE_64 ? 64 : (TARGET_LONG_DOUBLE_128 ? 128 : 80)) #define WIDEST_HARDWARE_FP_SIZE 80 diff --git a/gcc/config/ia64/ia64.cc b/gcc/config/ia64/ia64.cc index ac3d5607..cd6ed89 100644 --- a/gcc/config/ia64/ia64.cc +++ b/gcc/config/ia64/ia64.cc @@ -321,6 +321,7 @@ static const char *ia64_invalid_conversion (const_tree, const_tree); static const char *ia64_invalid_unary_op (int, const_tree); static const char *ia64_invalid_binary_op (int, const_tree, const_tree); static machine_mode ia64_c_mode_for_suffix (char); +static machine_mode ia64_c_mode_for_floating_type (enum tree_index); static void ia64_trampoline_init (rtx, tree, rtx); static void ia64_override_options_after_change (void); static bool ia64_member_type_forces_blk (const_tree, machine_mode); @@ -637,6 +638,9 @@ static const scoped_attribute_specs *const ia64_attribute_table[] = #undef TARGET_C_MODE_FOR_SUFFIX #define TARGET_C_MODE_FOR_SUFFIX ia64_c_mode_for_suffix +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE ia64_c_mode_for_floating_type + #undef TARGET_CAN_ELIMINATE #define TARGET_CAN_ELIMINATE ia64_can_eliminate @@ -11329,6 +11333,20 @@ ia64_c_mode_for_suffix (char suffix) return VOIDmode; } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return DFmode, XFmode + or TFmode for TI_LONG_DOUBLE_TYPE which is for long double type, + go with the default one for the others. */ + +static machine_mode +ia64_c_mode_for_floating_type (enum tree_index ti) +{ + /* long double is XFmode normally, and TFmode for HPUX. It should be + TFmode for VMS as well but we only support up to DFmode now. */ + if (ti == TI_LONG_DOUBLE_TYPE) + return TARGET_HPUX ? TFmode : (TARGET_ABI_OPEN_VMS ? DFmode : XFmode); + return default_mode_for_floating_type (ti); +} + static GTY(()) rtx ia64_dconst_0_5_rtx; rtx diff --git a/gcc/config/ia64/ia64.h b/gcc/config/ia64/ia64.h index b7f9d65..763b1c3 100644 --- a/gcc/config/ia64/ia64.h +++ b/gcc/config/ia64/ia64.h @@ -236,18 +236,6 @@ while (0) #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 - -#define DOUBLE_TYPE_SIZE 64 - -/* long double is XFmode normally, and TFmode for HPUX. It should be - TFmode for VMS as well but we only support up to DFmode now. */ -#define LONG_DOUBLE_TYPE_SIZE \ - (TARGET_HPUX ? 128 \ - : TARGET_ABI_OPEN_VMS ? 64 \ - : 80) - - #define DEFAULT_SIGNED_CHAR 1 /* A C expression for a string describing the name of the data type to use for diff --git a/gcc/config/iq2000/iq2000.h b/gcc/config/iq2000/iq2000.h index 88e87c6..c3562be 100644 --- a/gcc/config/iq2000/iq2000.h +++ b/gcc/config/iq2000/iq2000.h @@ -112,9 +112,6 @@ #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 #define CHAR_TYPE_SIZE BITS_PER_UNIT -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 #define DEFAULT_SIGNED_CHAR 1 #undef SIZE_TYPE diff --git a/gcc/config/lm32/lm32.h b/gcc/config/lm32/lm32.h index 1d2c8ad..e761e14 100644 --- a/gcc/config/lm32/lm32.h +++ b/gcc/config/lm32/lm32.h @@ -122,10 +122,6 @@ do { \ #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 - #define DEFAULT_SIGNED_CHAR 0 #define SIZE_TYPE "unsigned int" diff --git a/gcc/config/loongarch/loongarch.cc b/gcc/config/loongarch/loongarch.cc index 6ec3ee6..e2ff2af 100644 --- a/gcc/config/loongarch/loongarch.cc +++ b/gcc/config/loongarch/loongarch.cc @@ -10953,6 +10953,18 @@ loongarch_builtin_support_vector_misalignment (machine_mode mode, is_packed); } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return TFmode or DFmode + for TI_LONG_DOUBLE_TYPE which is for long double type, go with the + default one for the others. */ + +static machine_mode +loongarch_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return TARGET_64BIT ? TFmode : DFmode; + return default_mode_for_floating_type (ti); +} + static bool use_rsqrt_p (void) { @@ -11263,6 +11275,9 @@ loongarch_asm_code_end (void) #define TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT \ loongarch_builtin_support_vector_misalignment +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE loongarch_c_mode_for_floating_type + struct gcc_target targetm = TARGET_INITIALIZER; #include "gt-loongarch.h" diff --git a/gcc/config/loongarch/loongarch.h b/gcc/config/loongarch/loongarch.h index f7fe950..b9323ab 100644 --- a/gcc/config/loongarch/loongarch.h +++ b/gcc/config/loongarch/loongarch.h @@ -151,7 +151,7 @@ along with GCC; see the file COPYING3. If not see #define UNITS_PER_FPVALUE \ (TARGET_SOFT_FLOAT ? 0 \ : TARGET_SINGLE_FLOAT ? UNITS_PER_FP_REG \ - : LONG_DOUBLE_TYPE_SIZE / BITS_PER_UNIT) + : LA_LONG_DOUBLE_TYPE_SIZE / BITS_PER_UNIT) /* The number of bytes in a double. */ #define UNITS_PER_DOUBLE (TYPE_PRECISION (double_type_node) / BITS_PER_UNIT) @@ -162,9 +162,8 @@ along with GCC; see the file COPYING3. If not see #define LONG_TYPE_SIZE (TARGET_64BIT ? 64 : 32) #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE (TARGET_64BIT ? 128 : 64) +/* LONG_DOUBLE_TYPE_SIZE get poisoned, so add LA_ prefix. */ +#define LA_LONG_DOUBLE_TYPE_SIZE (TARGET_64BIT ? 128 : 64) /* Define the sizes of fixed-point types. */ #define SHORT_FRACT_TYPE_SIZE 8 @@ -179,7 +178,7 @@ along with GCC; see the file COPYING3. If not see /* long double is not a fixed mode, but the idea is that, if we support long double, we also want a 128-bit integer type. */ -#define MAX_FIXED_MODE_SIZE LONG_DOUBLE_TYPE_SIZE +#define MAX_FIXED_MODE_SIZE LA_LONG_DOUBLE_TYPE_SIZE /* Width in bits of a pointer. */ #ifndef POINTER_SIZE @@ -200,11 +199,11 @@ along with GCC; see the file COPYING3. If not see #define STRUCTURE_SIZE_BOUNDARY 8 /* There is no point aligning anything to a rounder boundary than - LONG_DOUBLE_TYPE_SIZE, unless under LSX/LASX the bigggest alignment is + LA_LONG_DOUBLE_TYPE_SIZE, unless under LSX/LASX the bigggest alignment is BITS_PER_LSX_REG/BITS_PER_LASX_REG/.. */ #define BIGGEST_ALIGNMENT \ (ISA_HAS_LASX? BITS_PER_LASX_REG \ - : (ISA_HAS_LSX ? BITS_PER_LSX_REG : LONG_DOUBLE_TYPE_SIZE)) + : (ISA_HAS_LSX ? BITS_PER_LSX_REG : LA_LONG_DOUBLE_TYPE_SIZE)) /* All accesses must be aligned. */ #define STRICT_ALIGNMENT (TARGET_STRICT_ALIGN) diff --git a/gcc/config/m32c/m32c.h b/gcc/config/m32c/m32c.h index 247b435..a956c50 100644 --- a/gcc/config/m32c/m32c.h +++ b/gcc/config/m32c/m32c.h @@ -180,10 +180,6 @@ machine_function; #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 - #define DEFAULT_SIGNED_CHAR 1 #undef PTRDIFF_TYPE diff --git a/gcc/config/m32r/m32r.h b/gcc/config/m32r/m32r.h index 4a400d1..7be8dfd 100644 --- a/gcc/config/m32r/m32r.h +++ b/gcc/config/m32r/m32r.h @@ -279,9 +279,6 @@ #define INT_TYPE_SIZE 32 #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 /* Define this as 1 if `char' should by default be signed; else as 0. */ #define DEFAULT_SIGNED_CHAR 1 diff --git a/gcc/config/m68k/m68k.cc b/gcc/config/m68k/m68k.cc index b1c9238..79ba4d5 100644 --- a/gcc/config/m68k/m68k.cc +++ b/gcc/config/m68k/m68k.cc @@ -198,6 +198,7 @@ static machine_mode m68k_promote_function_mode (const_tree, machine_mode, int *, const_tree, int); static void m68k_asm_final_postscan_insn (FILE *, rtx_insn *insn, rtx [], int); static HARD_REG_SET m68k_zero_call_used_regs (HARD_REG_SET); +static machine_mode m68k_c_mode_for_floating_type (enum tree_index); /* Initialize the GCC target structure. */ @@ -365,6 +366,9 @@ static HARD_REG_SET m68k_zero_call_used_regs (HARD_REG_SET); #undef TARGET_ZERO_CALL_USED_REGS #define TARGET_ZERO_CALL_USED_REGS m68k_zero_call_used_regs +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE m68k_c_mode_for_floating_type + TARGET_GNU_ATTRIBUTES (m68k_attribute_table, { /* { name, min_len, max_len, decl_req, type_req, fn_type_req, @@ -7212,4 +7216,16 @@ m68k_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs) return need_zeroed_hardregs; } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return XFmode or DFmode + for TI_LONG_DOUBLE_TYPE which is for long double type, go with the + default one for the others. */ + +static machine_mode +m68k_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return LONG_DOUBLE_TYPE_MODE; + return default_mode_for_floating_type (ti); +} + #include "gt-m68k.h" diff --git a/gcc/config/m68k/m68k.h b/gcc/config/m68k/m68k.h index 1aa89f1..0d57199 100644 --- a/gcc/config/m68k/m68k.h +++ b/gcc/config/m68k/m68k.h @@ -278,8 +278,8 @@ along with GCC; see the file COPYING3. If not see /* "long double" is the same as "double" on ColdFire and fido targets. */ -#define LONG_DOUBLE_TYPE_SIZE \ - ((TARGET_COLDFIRE || TARGET_FIDOA) ? 64 : 80) +#define LONG_DOUBLE_TYPE_MODE \ + ((TARGET_COLDFIRE || TARGET_FIDOA) ? DFmode : XFmode) #define BITS_BIG_ENDIAN 1 #define BYTES_BIG_ENDIAN 1 diff --git a/gcc/config/m68k/netbsd-elf.h b/gcc/config/m68k/netbsd-elf.h index 5239f09..6fc5ad1 100644 --- a/gcc/config/m68k/netbsd-elf.h +++ b/gcc/config/m68k/netbsd-elf.h @@ -36,8 +36,8 @@ along with GCC; see the file COPYING3. If not see while (0) /* Don't try using XFmode on the 68010. */ -#undef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE (TARGET_68020 ? 80 : 64) +#undef LONG_DOUBLE_TYPE_MODE +#define LONG_DOUBLE_TYPE_MODE (TARGET_68020 ? XFmode : DFmode) #undef SUBTARGET_EXTRA_SPECS #define SUBTARGET_EXTRA_SPECS \ diff --git a/gcc/config/microblaze/microblaze.h b/gcc/config/microblaze/microblaze.h index c88a87c..5d28abf 100644 --- a/gcc/config/microblaze/microblaze.h +++ b/gcc/config/microblaze/microblaze.h @@ -216,9 +216,6 @@ extern enum pipeline_type microblaze_pipe; #define SHORT_TYPE_SIZE 16 #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 #define POINTER_SIZE 32 #define PARM_BOUNDARY 32 #define FUNCTION_BOUNDARY 32 diff --git a/gcc/config/mips/mips.cc b/gcc/config/mips/mips.cc index 4892411..24addfa 100644 --- a/gcc/config/mips/mips.cc +++ b/gcc/config/mips/mips.cc @@ -23045,6 +23045,18 @@ mips_asm_file_end (void) file_end_indicate_exec_stack (); } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return TFmode or DFmode + for TI_LONG_DOUBLE_TYPE which is for long double type, go with the + default one for the others. */ + +static machine_mode +mips_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return MIPS_LONG_DOUBLE_TYPE_SIZE == 64 ? DFmode : TFmode; + return default_mode_for_floating_type (ti); +} + void mips_bit_clear_info (enum machine_mode mode, unsigned HOST_WIDE_INT m, int *start_pos, int *size) @@ -23413,6 +23425,8 @@ mips_bit_clear_p (enum machine_mode mode, unsigned HOST_WIDE_INT m) #undef TARGET_ASM_FILE_END #define TARGET_ASM_FILE_END mips_asm_file_end +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE mips_c_mode_for_floating_type struct gcc_target targetm = TARGET_INITIALIZER; diff --git a/gcc/config/mips/mips.h b/gcc/config/mips/mips.h index d18ca7d..84dd64d 100644 --- a/gcc/config/mips/mips.h +++ b/gcc/config/mips/mips.h @@ -1654,7 +1654,7 @@ FP_ASM_SPEC "\ #define UNITS_PER_FPVALUE \ (TARGET_SOFT_FLOAT_ABI ? 0 \ : TARGET_SINGLE_FLOAT ? UNITS_PER_FPREG \ - : LONG_DOUBLE_TYPE_SIZE / BITS_PER_UNIT) + : MIPS_LONG_DOUBLE_TYPE_SIZE / BITS_PER_UNIT) /* The number of bytes in a double. */ #define UNITS_PER_DOUBLE (TYPE_PRECISION (double_type_node) / BITS_PER_UNIT) @@ -1665,9 +1665,8 @@ FP_ASM_SPEC "\ #define LONG_TYPE_SIZE (TARGET_LONG64 ? 64 : 32) #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE (TARGET_NEWABI ? 128 : 64) +/* LONG_DOUBLE_TYPE_SIZE gets poisoned, so add MIPS_ prefix. */ +#define MIPS_LONG_DOUBLE_TYPE_SIZE (TARGET_NEWABI ? 128 : 64) /* Define the sizes of fixed-point types. */ #define SHORT_FRACT_TYPE_SIZE 8 @@ -1684,7 +1683,7 @@ FP_ASM_SPEC "\ /* long double is not a fixed mode, but the idea is that, if we support long double, we also want a 128-bit integer type. */ -#define MAX_FIXED_MODE_SIZE LONG_DOUBLE_TYPE_SIZE +#define MAX_FIXED_MODE_SIZE MIPS_LONG_DOUBLE_TYPE_SIZE /* Width in bits of a pointer. */ #ifndef POINTER_SIZE @@ -1705,10 +1704,10 @@ FP_ASM_SPEC "\ #define STRUCTURE_SIZE_BOUNDARY 8 /* There is no point aligning anything to a rounder boundary than - LONG_DOUBLE_TYPE_SIZE, unless under MSA the bigggest alignment is + MIPS_LONG_DOUBLE_TYPE_SIZE, unless under MSA the bigggest alignment is BITS_PER_MSA_REG. */ #define BIGGEST_ALIGNMENT \ - (ISA_HAS_MSA ? BITS_PER_MSA_REG : LONG_DOUBLE_TYPE_SIZE) + (ISA_HAS_MSA ? BITS_PER_MSA_REG : MIPS_LONG_DOUBLE_TYPE_SIZE) /* All accesses must be aligned. */ #define STRICT_ALIGNMENT (!ISA_HAS_UNALIGNED_ACCESS) diff --git a/gcc/config/mips/n32-elf.h b/gcc/config/mips/n32-elf.h index 94a90d8..01c8a85 100644 --- a/gcc/config/mips/n32-elf.h +++ b/gcc/config/mips/n32-elf.h @@ -26,5 +26,5 @@ along with GCC; see the file COPYING3. If not see #define NO_DOLLAR_IN_LABEL /* Force n32 to use 64-bit long doubles. */ -#undef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE 64 +#undef MIPS_LONG_DOUBLE_TYPE_SIZE +#define MIPS_LONG_DOUBLE_TYPE_SIZE 64 diff --git a/gcc/config/mmix/mmix.h b/gcc/config/mmix/mmix.h index c3c5a2a..e20bca1 100644 --- a/gcc/config/mmix/mmix.h +++ b/gcc/config/mmix/mmix.h @@ -195,10 +195,6 @@ struct GTY(()) machine_function #define SHORT_TYPE_SIZE 16 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 - #define DEFAULT_SIGNED_CHAR 1 diff --git a/gcc/config/moxie/moxie.h b/gcc/config/moxie/moxie.h index 066c256..4857c92 100644 --- a/gcc/config/moxie/moxie.h +++ b/gcc/config/moxie/moxie.h @@ -55,10 +55,6 @@ #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 - #define DEFAULT_SIGNED_CHAR 0 #undef SIZE_TYPE diff --git a/gcc/config/msp430/msp430.h b/gcc/config/msp430/msp430.h index 5c856ee..f20309c 100644 --- a/gcc/config/msp430/msp430.h +++ b/gcc/config/msp430/msp430.h @@ -178,10 +178,6 @@ extern const char *msp430_get_linker_devices_include_path (int, const char **); #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 /*DOUBLE_TYPE_SIZE*/ - #define DEFAULT_SIGNED_CHAR 0 #define STRICT_ALIGNMENT 1 diff --git a/gcc/config/nds32/nds32.h b/gcc/config/nds32/nds32.h index 03cf7a9..4c02302 100644 --- a/gcc/config/nds32/nds32.h +++ b/gcc/config/nds32/nds32.h @@ -1061,10 +1061,6 @@ enum nds32_builtins #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 - #define DEFAULT_SIGNED_CHAR 1 #define SIZE_TYPE "long unsigned int" diff --git a/gcc/config/nios2/nios2.h b/gcc/config/nios2/nios2.h index 767f56e..bad72671 100644 --- a/gcc/config/nios2/nios2.h +++ b/gcc/config/nios2/nios2.h @@ -100,9 +100,6 @@ #define SHORT_TYPE_SIZE 16 #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE #undef SIZE_TYPE #define SIZE_TYPE "unsigned int" diff --git a/gcc/config/nvptx/nvptx.h b/gcc/config/nvptx/nvptx.h index 74f4a68..68ab011 100644 --- a/gcc/config/nvptx/nvptx.h +++ b/gcc/config/nvptx/nvptx.h @@ -75,9 +75,6 @@ #define INT_TYPE_SIZE 32 #define LONG_TYPE_SIZE (TARGET_ABI64 ? 64 : 32) #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 #define TARGET_SUPPORTS_WIDE_INT 1 #undef SIZE_TYPE diff --git a/gcc/config/or1k/or1k.h b/gcc/config/or1k/or1k.h index 0ff73df..a55509f 100644 --- a/gcc/config/or1k/or1k.h +++ b/gcc/config/or1k/or1k.h @@ -67,9 +67,6 @@ #define SHORT_TYPE_SIZE 16 #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 #define WCHAR_TYPE_SIZE 32 #undef SIZE_TYPE diff --git a/gcc/config/pa/pa-64.h b/gcc/config/pa/pa-64.h index ea9d86e..b676468 100644 --- a/gcc/config/pa/pa-64.h +++ b/gcc/config/pa/pa-64.h @@ -58,12 +58,12 @@ along with GCC; see the file COPYING3. If not see #define LONG_TYPE_SIZE 64 #undef LONG_LONG_TYPE_SIZE #define LONG_LONG_TYPE_SIZE 64 -#undef FLOAT_TYPE_SIZE -#define FLOAT_TYPE_SIZE 32 -#undef DOUBLE_TYPE_SIZE -#define DOUBLE_TYPE_SIZE 64 -#undef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE 128 +#undef PA_FLOAT_TYPE_SIZE +#define PA_FLOAT_TYPE_SIZE 32 +#undef PA_DOUBLE_TYPE_SIZE +#define PA_DOUBLE_TYPE_SIZE 64 +#undef PA_LONG_DOUBLE_TYPE_SIZE +#define PA_LONG_DOUBLE_TYPE_SIZE 128 /* ?!? This needs to be made compile-time selectable. diff --git a/gcc/config/pa/pa-hpux.h b/gcc/config/pa/pa-hpux.h index a7421d6..accef44 100644 --- a/gcc/config/pa/pa-hpux.h +++ b/gcc/config/pa/pa-hpux.h @@ -34,7 +34,8 @@ along with GCC; see the file COPYING3. If not see #define SIZE_TYPE "unsigned int" #define PTRDIFF_TYPE "int" -#define LONG_DOUBLE_TYPE_SIZE 128 +#undef PA_LONG_DOUBLE_TYPE_SIZE +#define PA_LONG_DOUBLE_TYPE_SIZE 128 #define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) ((MODE) == TFmode) /* GCC always defines __STDC__. HP C++ compilers don't define it. This diff --git a/gcc/config/pa/pa.cc b/gcc/config/pa/pa.cc index a7af6b8..ab4bfc5 100644 --- a/gcc/config/pa/pa.cc +++ b/gcc/config/pa/pa.cc @@ -194,6 +194,7 @@ static rtx pa_internal_arg_pointer (void); static bool pa_can_eliminate (const int, const int); static void pa_conditional_register_usage (void); static machine_mode pa_c_mode_for_suffix (char); +static machine_mode pa_c_mode_for_floating_type (enum tree_index); static section *pa_function_section (tree, enum node_frequency, bool, bool); static bool pa_cannot_force_const_mem (machine_mode, rtx); static bool pa_legitimate_constant_p (machine_mode, rtx); @@ -398,6 +399,8 @@ static size_t n_deferred_plabels = 0; #define TARGET_CONDITIONAL_REGISTER_USAGE pa_conditional_register_usage #undef TARGET_C_MODE_FOR_SUFFIX #define TARGET_C_MODE_FOR_SUFFIX pa_c_mode_for_suffix +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE pa_c_mode_for_floating_type #undef TARGET_ASM_FUNCTION_SECTION #define TARGET_ASM_FUNCTION_SECTION pa_function_section @@ -6728,11 +6731,11 @@ pa_scalar_mode_supported_p (scalar_mode mode) return false; case MODE_FLOAT: - if (precision == FLOAT_TYPE_SIZE) + if (precision == PA_FLOAT_TYPE_SIZE) return true; - if (precision == DOUBLE_TYPE_SIZE) + if (precision == PA_DOUBLE_TYPE_SIZE) return true; - if (precision == LONG_DOUBLE_TYPE_SIZE) + if (precision == PA_LONG_DOUBLE_TYPE_SIZE) return true; return false; @@ -10808,6 +10811,18 @@ pa_c_mode_for_suffix (char suffix) return VOIDmode; } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return TFmode or DFmode + for TI_LONG_DOUBLE_TYPE which is for long double type, go with the + default one for the others. */ + +static machine_mode +pa_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return PA_LONG_DOUBLE_TYPE_SIZE == 64 ? DFmode : TFmode; + return default_mode_for_floating_type (ti); +} + /* Target hook for function_section. */ static section * diff --git a/gcc/config/pa/pa.h b/gcc/config/pa/pa.h index 127a0d1..7e45c35 100644 --- a/gcc/config/pa/pa.h +++ b/gcc/config/pa/pa.h @@ -1306,3 +1306,9 @@ do { \ /* An integer expression for the size in bits of the largest integer machine mode that should actually be used. We allow pairs of registers. */ #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (TARGET_64BIT ? TImode : DImode) + +/* Define these macros as default for all subtargets, add PA_ prefix + as {FLOAT,{,LONG_}DOUBLE}_TYPE_SIZE get poisoned. */ +#define PA_FLOAT_TYPE_SIZE BITS_PER_WORD +#define PA_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) +#define PA_LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) diff --git a/gcc/config/pdp11/pdp11.h b/gcc/config/pdp11/pdp11.h index 2446fea..6c8e045 100644 --- a/gcc/config/pdp11/pdp11.h +++ b/gcc/config/pdp11/pdp11.h @@ -71,17 +71,6 @@ along with GCC; see the file COPYING3. If not see #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -/* In earlier versions, FLOAT_TYPE_SIZE was selectable as 32 or 64, - but that conflicts with Fortran language rules. Since there is no - obvious reason why we should have that feature -- other targets - generally don't have float and double the same size -- I've removed - it. Note that it continues to be true (for now) that arithmetic is - always done with 64-bit values, i.e., the FPU is always in "double" - mode. */ -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 - /* machine types from ansi */ #define SIZE_TYPE "short unsigned int" /* definition of size_t */ #define WCHAR_TYPE "short int" /* or long int???? */ diff --git a/gcc/config/pru/pru.h b/gcc/config/pru/pru.h index 28aeb60..7aee286 100644 --- a/gcc/config/pru/pru.h +++ b/gcc/config/pru/pru.h @@ -107,9 +107,6 @@ #define SHORT_TYPE_SIZE 16 #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE #undef SIZE_TYPE #define SIZE_TYPE "unsigned int" diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index cca7ffd..9bba5da 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -11649,6 +11649,18 @@ riscv_expand_ussub (rtx dest, rtx x, rtx y) emit_move_insn (dest, gen_lowpart (mode, pmode_dest)); } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return TFmode for + TI_LONG_DOUBLE_TYPE which is for long double type, go with the + default one for the others. */ + +static machine_mode +riscv_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return TFmode; + return default_mode_for_floating_type (ti); +} + /* Initialize the GCC target structure. */ #undef TARGET_ASM_ALIGNED_HI_OP #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t" @@ -12004,6 +12016,9 @@ riscv_expand_ussub (rtx dest, rtx x, rtx y) #undef TARGET_GET_RAW_RESULT_MODE #define TARGET_GET_RAW_RESULT_MODE riscv_get_raw_result_mode +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE riscv_c_mode_for_floating_type + struct gcc_target targetm = TARGET_INITIALIZER; #include "gt-riscv.h" diff --git a/gcc/config/riscv/riscv.h b/gcc/config/riscv/riscv.h index 57910ee..6f04001 100644 --- a/gcc/config/riscv/riscv.h +++ b/gcc/config/riscv/riscv.h @@ -188,10 +188,6 @@ ASM_MISA_SPEC #define POINTER_SIZE (riscv_abi >= ABI_LP64 ? 64 : 32) #define LONG_TYPE_SIZE POINTER_SIZE -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 128 - /* Allocation boundary (in *bits*) for storing arguments in argument list. */ #define PARM_BOUNDARY BITS_PER_WORD diff --git a/gcc/config/rl78/rl78.cc b/gcc/config/rl78/rl78.cc index b4bb145..25f6606 100644 --- a/gcc/config/rl78/rl78.cc +++ b/gcc/config/rl78/rl78.cc @@ -4972,6 +4972,21 @@ rl78_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, reg_class_t rclass) return rclass; } +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE rl78_c_mode_for_floating_type + +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return SFmode for + TI_DOUBLE_TYPE which is for double type, go with the default + one for the others. */ + +static machine_mode +rl78_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_DOUBLE_TYPE) + return SFmode; + return default_mode_for_floating_type (ti); +} + /* The strub runtime uses asms, and physical register allocation won't deal with them, so disable it. */ diff --git a/gcc/config/rl78/rl78.h b/gcc/config/rl78/rl78.h index cfff98d..a960aee 100644 --- a/gcc/config/rl78/rl78.h +++ b/gcc/config/rl78/rl78.h @@ -113,10 +113,6 @@ #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 32 /*64*/ -#define LONG_DOUBLE_TYPE_SIZE 64 /*DOUBLE_TYPE_SIZE*/ - #define DEFAULT_SIGNED_CHAR 0 #define STRICT_ALIGNMENT 1 diff --git a/gcc/config/rs6000/rs6000.cc b/gcc/config/rs6000/rs6000.cc index ec31674..cd14e5a 100644 --- a/gcc/config/rs6000/rs6000.cc +++ b/gcc/config/rs6000/rs6000.cc @@ -1707,6 +1707,9 @@ static const scoped_attribute_specs *const rs6000_attribute_table[] = #undef TARGET_C_MODE_FOR_SUFFIX #define TARGET_C_MODE_FOR_SUFFIX rs6000_c_mode_for_suffix +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE rs6000_c_mode_for_floating_type + #undef TARGET_INVALID_BINARY_OP #define TARGET_INVALID_BINARY_OP rs6000_invalid_binary_op @@ -24373,6 +24376,19 @@ rs6000_c_mode_for_suffix (char suffix) return VOIDmode; } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return TFmode for + TI_LONG_DOUBLE_TYPE which is for long double type, go with the default + one for the others. */ + +static machine_mode +rs6000_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return rs6000_long_double_type_size == FLOAT_PRECISION_TFmode ? TFmode + : DFmode; + return default_mode_for_floating_type (ti); +} + /* Target hook for invalid_arg_for_unprototyped_fn. */ static const char * invalid_arg_for_unprototyped_fn (const_tree typelist, const_tree funcdecl, const_tree val) diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h index 2cde2e3..9211f91 100644 --- a/gcc/config/rs6000/rs6000.h +++ b/gcc/config/rs6000/rs6000.h @@ -693,20 +693,6 @@ extern unsigned char rs6000_recip_bits[]; words. */ #define LONG_LONG_TYPE_SIZE 64 -/* A C expression for the size in bits of the type `float' on the - target machine. If you don't define this, the default is one - word. */ -#define FLOAT_TYPE_SIZE 32 - -/* A C expression for the size in bits of the type `double' on the - target machine. If you don't define this, the default is two - words. */ -#define DOUBLE_TYPE_SIZE 64 - -/* A C expression for the size in bits of the type `long double' on the target - machine. If you don't define this, the default is two words. */ -#define LONG_DOUBLE_TYPE_SIZE rs6000_long_double_type_size - /* Work around rs6000_long_double_type_size dependency in ada/targtyps.cc. */ #define WIDEST_HARDWARE_FP_SIZE 64 diff --git a/gcc/config/rx/rx.cc b/gcc/config/rx/rx.cc index 9bf9d87..8048cc9 100644 --- a/gcc/config/rx/rx.cc +++ b/gcc/config/rx/rx.cc @@ -3648,6 +3648,18 @@ rx_modes_tieable_p (machine_mode mode1, machine_mode mode2) == (GET_MODE_CLASS (mode2) == MODE_FLOAT || GET_MODE_CLASS (mode2) == MODE_COMPLEX_FLOAT)); } + +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return SFmode or DFmode + for TI_{LONG_,}DOUBLE_TYPE which is for {long,} double type, go with + the default one for the others. */ + +static machine_mode +rx_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_DOUBLE_TYPE || ti == TI_LONG_DOUBLE_TYPE) + return TARGET_64BIT_DOUBLES ? DFmode : SFmode; + return default_mode_for_floating_type (ti); +} #undef TARGET_NARROW_VOLATILE_BITFIELD #define TARGET_NARROW_VOLATILE_BITFIELD rx_narrow_volatile_bitfield @@ -3807,6 +3819,9 @@ rx_modes_tieable_p (machine_mode mode1, machine_mode mode2) #undef TARGET_HAVE_SPECULATION_SAFE_VALUE #define TARGET_HAVE_SPECULATION_SAFE_VALUE speculation_safe_value_not_needed +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE rx_c_mode_for_floating_type + struct gcc_target targetm = TARGET_INITIALIZER; #include "gt-rx.h" diff --git a/gcc/config/rx/rx.h b/gcc/config/rx/rx.h index ff445df..15d6d25 100644 --- a/gcc/config/rx/rx.h +++ b/gcc/config/rx/rx.h @@ -132,10 +132,6 @@ #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE (TARGET_64BIT_DOUBLES ? 64 : 32) -#define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE - #define DEFAULT_SIGNED_CHAR 0 /* RX load/store instructions can handle unaligned addresses. */ diff --git a/gcc/config/s390/s390.cc b/gcc/config/s390/s390.cc index ec836ec..c65421d 100644 --- a/gcc/config/s390/s390.cc +++ b/gcc/config/s390/s390.cc @@ -18079,6 +18079,18 @@ s390_noce_conversion_profitable_p (rtx_insn *seq, struct noce_if_info *if_info) return default_noce_conversion_profitable_p (seq, if_info); } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return TFmode or DFmode + for TI_LONG_DOUBLE_TYPE which is for long double type, go with the + default one for the others. */ + +static machine_mode +s390_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return TARGET_LONG_DOUBLE_128 ? TFmode : DFmode; + return default_mode_for_floating_type (ti); +} + /* Initialize GCC target structure. */ #undef TARGET_ASM_ALIGNED_HI_OP @@ -18395,6 +18407,9 @@ s390_noce_conversion_profitable_p (rtx_insn *seq, struct noce_if_info *if_info) #undef TARGET_NOCE_CONVERSION_PROFITABLE_P #define TARGET_NOCE_CONVERSION_PROFITABLE_P s390_noce_conversion_profitable_p +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE s390_c_mode_for_floating_type + struct gcc_target targetm = TARGET_INITIALIZER; #include "gt-s390.h" diff --git a/gcc/config/s390/s390.h b/gcc/config/s390/s390.h index 0e6666a..4a4dde1 100644 --- a/gcc/config/s390/s390.h +++ b/gcc/config/s390/s390.h @@ -396,9 +396,6 @@ extern const char *s390_host_detect_local_cpu (int argc, const char **argv); #define INT_TYPE_SIZE 32 #define LONG_TYPE_SIZE (TARGET_64BIT ? 64 : 32) #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64) /* Work around target_flags dependency in ada/targtyps.cc. */ #define WIDEST_HARDWARE_FP_SIZE 64 diff --git a/gcc/config/sh/sh.cc b/gcc/config/sh/sh.cc index ef3c2e6..bc01742 100644 --- a/gcc/config/sh/sh.cc +++ b/gcc/config/sh/sh.cc @@ -328,6 +328,7 @@ static unsigned int sh_hard_regno_nregs (unsigned int, machine_mode); static bool sh_hard_regno_mode_ok (unsigned int, machine_mode); static bool sh_modes_tieable_p (machine_mode, machine_mode); static bool sh_can_change_mode_class (machine_mode, machine_mode, reg_class_t); +static machine_mode sh_c_mode_for_floating_type (enum tree_index); TARGET_GNU_ATTRIBUTES (sh_attribute_table, { @@ -664,6 +665,9 @@ TARGET_GNU_ATTRIBUTES (sh_attribute_table, #undef TARGET_HAVE_SPECULATION_SAFE_VALUE #define TARGET_HAVE_SPECULATION_SAFE_VALUE speculation_safe_value_not_needed +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE sh_c_mode_for_floating_type + struct gcc_target targetm = TARGET_INITIALIZER; @@ -10674,6 +10678,20 @@ sh_can_change_mode_class (machine_mode from, machine_mode to, return true; } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return SFmode or DFmode + for TI_DOUBLE_TYPE which is for double type, go with the default one + for the others. */ + +static machine_mode +sh_c_mode_for_floating_type (enum tree_index ti) +{ + /* Since the SH2e has only `float' support, it is desirable to make all + floating point types equivalent to `float'. */ + if (ti == TI_DOUBLE_TYPE) + return TARGET_FPU_SINGLE_ONLY ? SFmode : DFmode; + return default_mode_for_floating_type (ti); +} + /* Return true if registers in machine mode MODE will likely be allocated to registers in small register classes. */ bool diff --git a/gcc/config/sh/sh.h b/gcc/config/sh/sh.h index 7d3a3f0..53cad85 100644 --- a/gcc/config/sh/sh.h +++ b/gcc/config/sh/sh.h @@ -425,9 +425,6 @@ extern const sh_atomic_model& selected_atomic_model (void); /* Width in bits of a `long long'. */ #define LONG_LONG_TYPE_SIZE 64 -/* Width in bits of a `long double'. */ -#define LONG_DOUBLE_TYPE_SIZE 64 - /* Width of a word, in units (bytes). */ #define UNITS_PER_WORD (4) #define MIN_UNITS_PER_WORD 4 @@ -1433,13 +1430,6 @@ extern bool current_function_interrupt; Do not define this if the table should contain absolute addresses. */ #define CASE_VECTOR_PC_RELATIVE 1 -/* Define it here, so that it doesn't get bumped to 64-bits on SHmedia. */ -#define FLOAT_TYPE_SIZE 32 - -/* Since the SH2e has only `float' support, it is desirable to make all - floating point types equivalent to `float'. */ -#define DOUBLE_TYPE_SIZE (TARGET_FPU_SINGLE_ONLY ? 32 : 64) - /* 'char' is signed by default. */ #define DEFAULT_SIGNED_CHAR 1 diff --git a/gcc/config/sparc/freebsd.h b/gcc/config/sparc/freebsd.h index 3f00a08..5396b32 100644 --- a/gcc/config/sparc/freebsd.h +++ b/gcc/config/sparc/freebsd.h @@ -68,8 +68,8 @@ along with GCC; see the file COPYING3. If not see /* 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) +#undef SPARC_LONG_DOUBLE_TYPE_SIZE +#define SPARC_LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64) /* Definitions for 64-bit SPARC running systems with ELF. */ diff --git a/gcc/config/sparc/linux.h b/gcc/config/sparc/linux.h index 9646fa9c..8cc5389 100644 --- a/gcc/config/sparc/linux.h +++ b/gcc/config/sparc/linux.h @@ -115,7 +115,7 @@ do { \ /* 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) +#define SPARC_LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64) #undef DITF_CONVERSION_LIBFUNCS #define DITF_CONVERSION_LIBFUNCS 1 diff --git a/gcc/config/sparc/linux64.h b/gcc/config/sparc/linux64.h index 1e2e4ae..66426d8 100644 --- a/gcc/config/sparc/linux64.h +++ b/gcc/config/sparc/linux64.h @@ -61,8 +61,8 @@ along with GCC; see the file COPYING3. If not see /* 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) +#undef SPARC_LONG_DOUBLE_TYPE_SIZE +#define SPARC_LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64) #undef CPP_SUBTARGET_SPEC #define CPP_SUBTARGET_SPEC "\ diff --git a/gcc/config/sparc/netbsd-elf.h b/gcc/config/sparc/netbsd-elf.h index 2cf85dd..3bb05c5 100644 --- a/gcc/config/sparc/netbsd-elf.h +++ b/gcc/config/sparc/netbsd-elf.h @@ -160,8 +160,8 @@ along with GCC; see the file COPYING3. If not see #ifdef SPARC_BI_ARCH -#undef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64) +#undef SPARC_LONG_DOUBLE_TYPE_SIZE +#define SPARC_LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64) #undef CC1_SPEC #if DEFAULT_ARCH32_P @@ -181,8 +181,8 @@ along with GCC; see the file COPYING3. If not see #if TARGET_CPU_DEFAULT == TARGET_CPU_v9 \ || TARGET_CPU_DEFAULT == TARGET_CPU_ultrasparc -#undef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE 128 +#undef SPARC_LONG_DOUBLE_TYPE_SIZE +#define SPARC_LONG_DOUBLE_TYPE_SIZE 128 #undef CC1_SPEC #define CC1_SPEC CC1_SPEC64 @@ -193,8 +193,8 @@ along with GCC; see the file COPYING3. If not see /* A 32-bit only compiler. NetBSD don't support 128 bit `long double' for 32-bit code, unlike Solaris. */ -#undef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE 64 +#undef SPARC_LONG_DOUBLE_TYPE_SIZE +#define SPARC_LONG_DOUBLE_TYPE_SIZE 64 #undef CC1_SPEC #define CC1_SPEC CC1_SPEC32 diff --git a/gcc/config/sparc/openbsd64.h b/gcc/config/sparc/openbsd64.h index 9cd23f2..19cc20e 100644 --- a/gcc/config/sparc/openbsd64.h +++ b/gcc/config/sparc/openbsd64.h @@ -54,8 +54,8 @@ along with GCC; see the file COPYING3. If not see #undef WCHAR_TYPE_SIZE #define WCHAR_TYPE_SIZE 32 -#undef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE 128 +#undef SPARC_LONG_DOUBLE_TYPE_SIZE +#define SPARC_LONG_DOUBLE_TYPE_SIZE 128 #undef LINK_SPEC #define LINK_SPEC \ diff --git a/gcc/config/sparc/sol2.h b/gcc/config/sparc/sol2.h index 530e681..f0181d5 100644 --- a/gcc/config/sparc/sol2.h +++ b/gcc/config/sparc/sol2.h @@ -440,7 +440,7 @@ extern const char *host_detect_local_cpu (int argc, const char **argv); /* Define for support of TFmode long double. SPARC ABI says that long double is 4 words. */ -#define LONG_DOUBLE_TYPE_SIZE 128 +#define SPARC_LONG_DOUBLE_TYPE_SIZE 128 /* Solaris's _Qp_* library routine implementation clobbers the output memory before the inputs are fully consumed. */ diff --git a/gcc/config/sparc/sp-elf.h b/gcc/config/sparc/sp-elf.h index aa7982a..cc64d5d 100644 --- a/gcc/config/sparc/sp-elf.h +++ b/gcc/config/sparc/sp-elf.h @@ -63,5 +63,5 @@ along with GCC; see the file COPYING3. If not see #define WCHAR_TYPE_SIZE BITS_PER_WORD /* ??? until fixed. */ -#undef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE 64 +#undef SPARC_LONG_DOUBLE_TYPE_SIZE +#define SPARC_LONG_DOUBLE_TYPE_SIZE 64 diff --git a/gcc/config/sparc/sp64-elf.h b/gcc/config/sparc/sp64-elf.h index a9c53cb..6eb5b86 100644 --- a/gcc/config/sparc/sp64-elf.h +++ b/gcc/config/sparc/sp64-elf.h @@ -69,5 +69,5 @@ along with GCC; see the file COPYING3. If not see #undef WCHAR_TYPE_SIZE #define WCHAR_TYPE_SIZE 16 -#undef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE 128 +#undef SPARC_LONG_DOUBLE_TYPE_SIZE +#define SPARC_LONG_DOUBLE_TYPE_SIZE 128 diff --git a/gcc/config/sparc/sparc.cc b/gcc/config/sparc/sparc.cc index 8a5f76c..9282fb4 100644 --- a/gcc/config/sparc/sparc.cc +++ b/gcc/config/sparc/sparc.cc @@ -718,6 +718,7 @@ static bool sparc_vectorize_vec_perm_const (machine_mode, machine_mode, const vec_perm_indices &); static bool sparc_can_follow_jump (const rtx_insn *, const rtx_insn *); static HARD_REG_SET sparc_zero_call_used_regs (HARD_REG_SET); +static machine_mode sparc_c_mode_for_floating_type (enum tree_index); #ifdef SUBTARGET_ATTRIBUTE_TABLE /* Table of valid machine attributes. */ @@ -971,6 +972,9 @@ char sparc_hard_reg_printed[8]; #undef TARGET_ZERO_CALL_USED_REGS #define TARGET_ZERO_CALL_USED_REGS sparc_zero_call_used_regs +#undef TARGET_C_MODE_FOR_FLOATING_TYPE +#define TARGET_C_MODE_FOR_FLOATING_TYPE sparc_c_mode_for_floating_type + struct gcc_target targetm = TARGET_INITIALIZER; /* Return the memory reference contained in X if any, zero otherwise. */ @@ -9824,18 +9828,6 @@ sparc_assemble_integer (rtx x, unsigned int size, int aligned_p) #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) #endif -#ifndef FLOAT_TYPE_SIZE -#define FLOAT_TYPE_SIZE BITS_PER_WORD -#endif - -#ifndef DOUBLE_TYPE_SIZE -#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) -#endif - -#ifndef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) -#endif - unsigned long sparc_type_code (tree type) { @@ -9920,7 +9912,7 @@ sparc_type_code (tree type) /* Carefully distinguish all the standard types of C, without messing up if the language is not C. */ - if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE) + if (TYPE_PRECISION (type) == TYPE_PRECISION (float_type_node)) return (qualifiers | 6); else @@ -13984,4 +13976,15 @@ sparc_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs) return need_zeroed_hardregs; } +/* Implement TARGET_C_MODE_FOR_FLOATING_TYPE. Return TFmode or DFmode + for TI_LONG_DOUBLE_TYPE and the default for others. */ + +static machine_mode +sparc_c_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_LONG_DOUBLE_TYPE) + return SPARC_LONG_DOUBLE_TYPE_SIZE == 128 ? TFmode : DFmode; + return default_mode_for_floating_type (ti); +} + #include "gt-sparc.h" diff --git a/gcc/config/sparc/sparc.h b/gcc/config/sparc/sparc.h index 232ecb3..8612832 100644 --- a/gcc/config/sparc/sparc.h +++ b/gcc/config/sparc/sparc.h @@ -489,12 +489,11 @@ along with GCC; see the file COPYING3. If not see #define INT_TYPE_SIZE 32 #define LONG_TYPE_SIZE (TARGET_ARCH64 ? 64 : 32) #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -/* LONG_DOUBLE_TYPE_SIZE is defined per OS even though the - SPARC ABI says that it is 128-bit wide. */ -/* #define LONG_DOUBLE_TYPE_SIZE 128 */ +/* SPARC_LONG_DOUBLE_TYPE_SIZE is defined per OS even though the + SPARC ABI says that it is 128-bit wide. LONG_DOUBLE_TYPE_SIZE + get poisoned, so add SPARC_ prefix. */ +/* #define SPARC_LONG_DOUBLE_TYPE_SIZE 128 */ /* The widest floating-point format really supported by the hardware. */ #define WIDEST_HARDWARE_FP_SIZE 64 diff --git a/gcc/config/stormy16/stormy16.h b/gcc/config/stormy16/stormy16.h index 2503f23..3d5e21d 100644 --- a/gcc/config/stormy16/stormy16.h +++ b/gcc/config/stormy16/stormy16.h @@ -101,12 +101,6 @@ #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 - -#define DOUBLE_TYPE_SIZE 64 - -#define LONG_DOUBLE_TYPE_SIZE 64 - #define DEFAULT_SIGNED_CHAR 0 #define SIZE_TYPE "unsigned int" diff --git a/gcc/config/visium/visium.h b/gcc/config/visium/visium.h index 69e2552..afeb68f 100644 --- a/gcc/config/visium/visium.h +++ b/gcc/config/visium/visium.h @@ -330,33 +330,16 @@ it is rounded up to one unit.) */ #define CHAR_TYPE_SIZE 8 -/* `FLOAT_TYPE_SIZE' - - A C expression for the size in bits of the type `float' on the - target machine. If you don't define this, the default is one word. */ -#define FLOAT_TYPE_SIZE 32 - -/* `DOUBLE_TYPE_SIZE' - - A C expression for the size in bits of the type `double' on the - target machine. If you don't define this, the default is two - words. */ -#define DOUBLE_TYPE_SIZE 64 - -/* `LONG_DOUBLE_TYPE_SIZE' - - A C expression for the size in bits of the type `long double' on - the target machine. If you don't define this, the default is two - words. */ -#define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE - /* `WIDEST_HARDWARE_FP_SIZE' A C expression for the size in bits of the widest floating-point format supported by the hardware. If you define this macro, you - must specify a value less than or equal to the value of - `LONG_DOUBLE_TYPE_SIZE'. If you do not define this macro, the - value of `LONG_DOUBLE_TYPE_SIZE' is the default. */ + must specify a value less than or equal to mode precision of the + mode used for C type long double (from hook + targetm.c.mode_for_floating_type with tree_index + TI_LONG_DOUBLE_TYPE). If you do not define this macro, mode + precision of the mode used for C type long double is the + default. */ /* `DEFAULT_SIGNED_CHAR' diff --git a/gcc/config/xtensa/xtensa.h b/gcc/config/xtensa/xtensa.h index 094d922..8680234 100644 --- a/gcc/config/xtensa/xtensa.h +++ b/gcc/config/xtensa/xtensa.h @@ -120,9 +120,6 @@ along with GCC; see the file COPYING3. If not see #define SHORT_TYPE_SIZE 16 #define LONG_TYPE_SIZE 32 #define LONG_LONG_TYPE_SIZE 64 -#define FLOAT_TYPE_SIZE 32 -#define DOUBLE_TYPE_SIZE 64 -#define LONG_DOUBLE_TYPE_SIZE 64 /* Allocation boundary (in *bits*) for storing pointers in memory. */ #define POINTER_BOUNDARY 32 diff --git a/gcc/coretypes.h b/gcc/coretypes.h index 1ac6f0a..00c1c58 100644 --- a/gcc/coretypes.h +++ b/gcc/coretypes.h @@ -100,6 +100,7 @@ struct gimple; typedef gimple *gimple_seq; struct gimple_stmt_iterator; class code_helper; +enum tree_index : unsigned; /* Forward declare rtx_code, so that we can use it in target hooks without needing to pull in rtl.h. */ diff --git a/gcc/defaults.h b/gcc/defaults.h index 92f3e07..ac2d258 100644 --- a/gcc/defaults.h +++ b/gcc/defaults.h @@ -513,18 +513,6 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #define WCHAR_TYPE_SIZE INT_TYPE_SIZE #endif -#ifndef FLOAT_TYPE_SIZE -#define FLOAT_TYPE_SIZE BITS_PER_WORD -#endif - -#ifndef DOUBLE_TYPE_SIZE -#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) -#endif - -#ifndef LONG_DOUBLE_TYPE_SIZE -#define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) -#endif - #ifndef DECIMAL32_TYPE_SIZE #define DECIMAL32_TYPE_SIZE 32 #endif diff --git a/gcc/doc/rtl.texi b/gcc/doc/rtl.texi index 846a043..c1717ab 100644 --- a/gcc/doc/rtl.texi +++ b/gcc/doc/rtl.texi @@ -1326,7 +1326,7 @@ whose size is @code{BITS_PER_WORD}, @code{SImode} on 32-bit machines. The only modes which a machine description @i{must} support are @code{QImode}, and the modes corresponding to @code{BITS_PER_WORD}, -@code{FLOAT_TYPE_SIZE} and @code{DOUBLE_TYPE_SIZE}. +C type @code{float} and C type @code{double}. The compiler will attempt to use @code{DImode} for 8-byte structures and unions, but this can be prevented by overriding the definition of @code{MAX_FIXED_MODE_SIZE}. Alternatively, you can have the compiler diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index be5543b..24c92e2 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -1044,6 +1044,14 @@ are zero or sign extended depending on if it is @code{GET_MODE_ALIGNMENT (info->limb_mode)}. @end deftypefn +@deftypefn {Target Hook} machine_mode TARGET_C_MODE_FOR_FLOATING_TYPE (enum tree_index @var{ti}) +Return machine mode for a C floating point type which is indicated by + a given @code{enum tree_index} @var{ti}, @var{ti} should be + @code{TI_FLOAT_TYPE}, @code{TI_DOUBLE_TYPE} or @code{TI_LONG_DOUBLE_TYPE}. + The default implementation returns @code{SFmode} for @code{TI_FLOAT_TYPE}, + and @code{DFmode} for @code{TI_DOUBLE_TYPE} or @code{TI_LONG_DOUBLE_TYPE}. +@end deftypefn + @deftypefn {Target Hook} machine_mode TARGET_PROMOTE_FUNCTION_MODE (const_tree @var{type}, machine_mode @var{mode}, int *@var{punsignedp}, const_tree @var{funtype}, int @var{for_return}) Like @code{PROMOTE_MODE}, but it is applied to outgoing function arguments or function return values. The target hook should return the new mode @@ -1610,23 +1618,6 @@ C99 type @code{_Bool} on the target machine. If you don't define this, and you probably shouldn't, the default is @code{CHAR_TYPE_SIZE}. @end defmac -@defmac FLOAT_TYPE_SIZE -A C expression for the size in bits of the type @code{float} on the -target machine. If you don't define this, the default is one word. -@end defmac - -@defmac DOUBLE_TYPE_SIZE -A C expression for the size in bits of the type @code{double} on the -target machine. If you don't define this, the default is two -words. -@end defmac - -@defmac LONG_DOUBLE_TYPE_SIZE -A C expression for the size in bits of the type @code{long double} on -the target machine. If you don't define this, the default is two -words. -@end defmac - @defmac SHORT_FRACT_TYPE_SIZE A C expression for the size in bits of the type @code{short _Fract} on the target machine. If you don't define this, the default is @@ -1687,9 +1678,11 @@ the libgcc @file{config.host}. @defmac WIDEST_HARDWARE_FP_SIZE A C expression for the size in bits of the widest floating-point format supported by the hardware. If you define this macro, you must specify a -value less than or equal to the value of @code{LONG_DOUBLE_TYPE_SIZE}. -If you do not define this macro, the value of @code{LONG_DOUBLE_TYPE_SIZE} -is the default. +value less than or equal to mode precision of the mode used for C type +@code{long double} (from hook @code{targetm.c.mode_for_floating_type} +with argument @code{TI_LONG_DOUBLE_TYPE}). If you do not define this +macro, mode precision of the mode used for C type @code{long double} is +the default. @end defmac @defmac DEFAULT_SIGNED_CHAR diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index 87a7f89..24596eb 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -947,6 +947,8 @@ applied. @hook TARGET_C_BITINT_TYPE_INFO +@hook TARGET_C_MODE_FOR_FLOATING_TYPE + @hook TARGET_PROMOTE_FUNCTION_MODE @defmac PARM_BOUNDARY @@ -1351,23 +1353,6 @@ C99 type @code{_Bool} on the target machine. If you don't define this, and you probably shouldn't, the default is @code{CHAR_TYPE_SIZE}. @end defmac -@defmac FLOAT_TYPE_SIZE -A C expression for the size in bits of the type @code{float} on the -target machine. If you don't define this, the default is one word. -@end defmac - -@defmac DOUBLE_TYPE_SIZE -A C expression for the size in bits of the type @code{double} on the -target machine. If you don't define this, the default is two -words. -@end defmac - -@defmac LONG_DOUBLE_TYPE_SIZE -A C expression for the size in bits of the type @code{long double} on -the target machine. If you don't define this, the default is two -words. -@end defmac - @defmac SHORT_FRACT_TYPE_SIZE A C expression for the size in bits of the type @code{short _Fract} on the target machine. If you don't define this, the default is @@ -1428,9 +1413,11 @@ the libgcc @file{config.host}. @defmac WIDEST_HARDWARE_FP_SIZE A C expression for the size in bits of the widest floating-point format supported by the hardware. If you define this macro, you must specify a -value less than or equal to the value of @code{LONG_DOUBLE_TYPE_SIZE}. -If you do not define this macro, the value of @code{LONG_DOUBLE_TYPE_SIZE} -is the default. +value less than or equal to mode precision of the mode used for C type +@code{long double} (from hook @code{targetm.c.mode_for_floating_type} +with argument @code{TI_LONG_DOUBLE_TYPE}). If you do not define this +macro, mode precision of the mode used for C type @code{long double} is +the default. @end defmac @defmac DEFAULT_SIGNED_CHAR diff --git a/gcc/emit-rtl.cc b/gcc/emit-rtl.cc index 1856fa4..cb04aa1 100644 --- a/gcc/emit-rtl.cc +++ b/gcc/emit-rtl.cc @@ -6366,7 +6366,8 @@ init_emit_once (void) else const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE); - double_mode = float_mode_for_size (DOUBLE_TYPE_SIZE).require (); + mode = targetm.c.mode_for_floating_type (TI_DOUBLE_TYPE); + double_mode = as_a<scalar_float_mode> (mode); real_from_integer (&dconst0, double_mode, 0, SIGNED); real_from_integer (&dconst1, double_mode, 1, SIGNED); diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc index 8a1ec2d..5e9ef40 100644 --- a/gcc/jit/jit-recording.cc +++ b/gcc/jit/jit-recording.cc @@ -22,7 +22,7 @@ along with GCC; see the file COPYING3. If not see #define INCLUDE_SSTREAM #include "system.h" #include "coretypes.h" -#include "tm.h" +#include "target.h" #include "pretty-print.h" #include "toplev.h" @@ -2353,6 +2353,7 @@ size_t recording::memento_of_get_type::get_size () { int size; + machine_mode m; switch (m_kind) { case GCC_JIT_TYPE_VOID: @@ -2399,13 +2400,16 @@ recording::memento_of_get_type::get_size () size = 128; break; case GCC_JIT_TYPE_FLOAT: - size = FLOAT_TYPE_SIZE; + m = targetm.c.mode_for_floating_type (TI_FLOAT_TYPE); + size = GET_MODE_PRECISION (m).to_constant (); break; case GCC_JIT_TYPE_DOUBLE: - size = DOUBLE_TYPE_SIZE; + m = targetm.c.mode_for_floating_type (TI_DOUBLE_TYPE); + size = GET_MODE_PRECISION (m).to_constant (); break; case GCC_JIT_TYPE_LONG_DOUBLE: - size = LONG_DOUBLE_TYPE_SIZE; + m = targetm.c.mode_for_floating_type (TI_LONG_DOUBLE_TYPE); + size = GET_MODE_PRECISION (m).to_constant (); break; case GCC_JIT_TYPE_SIZE_T: size = MAX_BITS_PER_WORD; @@ -406,9 +406,10 @@ extern const struct real_format arm_bfloat_half_format; #define REAL_VALUE_MINUS_ZERO(x) real_isnegzero (&(x)) /* IN is a REAL_VALUE_TYPE. OUT is an array of longs. */ -#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) \ - real_to_target (OUT, &(IN), \ - float_mode_for_size (LONG_DOUBLE_TYPE_SIZE).require ()) +#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) \ + real_to_target (OUT, &(IN), \ + float_mode_for_size (TYPE_PRECISION \ + (long_double_type_node)).require ()) #define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \ real_to_target (OUT, &(IN), float_mode_for_size (64).require ()) diff --git a/gcc/system.h b/gcc/system.h index 1028dcb..cbb14fb 100644 --- a/gcc/system.h +++ b/gcc/system.h @@ -1000,7 +1000,8 @@ extern void fancy_abort (const char *, int, const char *) HARD_REGNO_NREGS SECONDARY_MEMORY_NEEDED_MODE \ SECONDARY_MEMORY_NEEDED CANNOT_CHANGE_MODE_CLASS \ TRULY_NOOP_TRUNCATION FUNCTION_ARG_OFFSET CONSTANT_ALIGNMENT \ - STARTING_FRAME_OFFSET + STARTING_FRAME_OFFSET FLOAT_TYPE_SIZE DOUBLE_TYPE_SIZE \ + LONG_DOUBLE_TYPE_SIZE /* Target macros only used for code built for the target, that have moved to libgcc-tm.h or have never been present elsewhere. */ diff --git a/gcc/target.def b/gcc/target.def index e5a9b52..e6f4df9 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -6389,6 +6389,15 @@ are zero or sign extended depending on if it is\n\ bool, (int n, struct bitint_info *info), default_bitint_type_info) +DEFHOOK +(mode_for_floating_type, +"Return machine mode for a C floating point type which is indicated by\n\ + a given @code{enum tree_index} @var{ti}, @var{ti} should be\n\ + @code{TI_FLOAT_TYPE}, @code{TI_DOUBLE_TYPE} or @code{TI_LONG_DOUBLE_TYPE}.\n\ + The default implementation returns @code{SFmode} for @code{TI_FLOAT_TYPE},\n\ + and @code{DFmode} for @code{TI_DOUBLE_TYPE} or @code{TI_LONG_DOUBLE_TYPE}.", + machine_mode, (enum tree_index ti), default_mode_for_floating_type) + HOOK_VECTOR_END (c) /* Functions specific to the C++ frontend. */ diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc index 4f53257..b10104c 100644 --- a/gcc/targhooks.cc +++ b/gcc/targhooks.cc @@ -298,6 +298,18 @@ default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED) return VOIDmode; } +/* Return machine mode for a floating type which is indicated + by the given enum tree_index. */ + +machine_mode +default_mode_for_floating_type (enum tree_index ti) +{ + if (ti == TI_FLOAT_TYPE) + return SFmode; + gcc_assert (ti == TI_DOUBLE_TYPE || ti == TI_LONG_DOUBLE_TYPE); + return DFmode; +} + /* The generic C++ ABI specifies this is a 64-bit value. */ tree default_cxx_guard_type (void) @@ -449,11 +461,11 @@ default_scalar_mode_supported_p (scalar_mode mode) return false; case MODE_FLOAT: - if (precision == FLOAT_TYPE_SIZE) + if (mode == targetm.c.mode_for_floating_type (TI_FLOAT_TYPE)) return true; - if (precision == DOUBLE_TYPE_SIZE) + if (mode == targetm.c.mode_for_floating_type (TI_DOUBLE_TYPE)) return true; - if (precision == LONG_DOUBLE_TYPE_SIZE) + if (mode == targetm.c.mode_for_floating_type (TI_LONG_DOUBLE_TYPE)) return true; return false; diff --git a/gcc/targhooks.h b/gcc/targhooks.h index f53913e..3cbca0f 100644 --- a/gcc/targhooks.h +++ b/gcc/targhooks.h @@ -290,6 +290,7 @@ extern unsigned int default_min_arithmetic_precision (void); extern enum flt_eval_method default_excess_precision (enum excess_precision_type ATTRIBUTE_UNUSED); extern bool default_bitint_type_info (int, struct bitint_info *); +extern machine_mode default_mode_for_floating_type (enum tree_index); extern HOST_WIDE_INT default_stack_clash_protection_alloca_probe_range (void); extern void default_select_early_remat_modes (sbitmap); extern tree default_preferred_else_value (unsigned, tree, unsigned, tree *); diff --git a/gcc/tree-core.h b/gcc/tree-core.h index bb5a130..27c569c 100644 --- a/gcc/tree-core.h +++ b/gcc/tree-core.h @@ -633,7 +633,7 @@ enum cv_qualifier { }; /* Standard named or nameless data types of the C compiler. */ -enum tree_index { +enum tree_index : unsigned { TI_ERROR_MARK, TI_INTQI_TYPE, TI_INTHI_TYPE, @@ -700,17 +700,18 @@ enum tree_index { TI_FLOAT64_TYPE, TI_FLOAT128_TYPE, TI_FLOATN_TYPE_LAST = TI_FLOAT128_TYPE, -#define NUM_FLOATN_TYPES (TI_FLOATN_TYPE_LAST - TI_FLOATN_TYPE_FIRST + 1) +#define NUM_FLOATN_TYPES ((int) (TI_FLOATN_TYPE_LAST \ + - TI_FLOATN_TYPE_FIRST + 1)) TI_FLOAT32X_TYPE, TI_FLOATNX_TYPE_FIRST = TI_FLOAT32X_TYPE, TI_FLOAT64X_TYPE, TI_FLOAT128X_TYPE, TI_FLOATNX_TYPE_LAST = TI_FLOAT128X_TYPE, TI_FLOATN_NX_TYPE_LAST = TI_FLOAT128X_TYPE, -#define NUM_FLOATNX_TYPES (TI_FLOATNX_TYPE_LAST - TI_FLOATNX_TYPE_FIRST + 1) -#define NUM_FLOATN_NX_TYPES (TI_FLOATN_NX_TYPE_LAST \ - - TI_FLOATN_NX_TYPE_FIRST \ - + 1) +#define NUM_FLOATNX_TYPES ((int) (TI_FLOATNX_TYPE_LAST \ + - TI_FLOATNX_TYPE_FIRST + 1)) +#define NUM_FLOATN_NX_TYPES ((int) (TI_FLOATN_NX_TYPE_LAST \ + - TI_FLOATN_NX_TYPE_FIRST + 1)) /* Type used by certain backends for __float128, which in C++ should be distinct type from _Float128 for backwards compatibility reasons. */ diff --git a/gcc/tree.cc b/gcc/tree.cc index 5a31fae..2d2d5b6 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -9602,15 +9602,27 @@ build_common_tree_nodes (bool signed_char) pointer_sized_int_node = build_nonstandard_integer_type (POINTER_SIZE, 1); float_type_node = make_node (REAL_TYPE); - TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE; + machine_mode float_type_mode + = targetm.c.mode_for_floating_type (TI_FLOAT_TYPE); + SET_TYPE_MODE (float_type_node, float_type_mode); + TYPE_PRECISION (float_type_node) + = GET_MODE_PRECISION (float_type_mode).to_constant (); layout_type (float_type_node); double_type_node = make_node (REAL_TYPE); - TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE; + machine_mode double_type_mode + = targetm.c.mode_for_floating_type (TI_DOUBLE_TYPE); + SET_TYPE_MODE (double_type_node, double_type_mode); + TYPE_PRECISION (double_type_node) + = GET_MODE_PRECISION (double_type_mode).to_constant (); layout_type (double_type_node); long_double_type_node = make_node (REAL_TYPE); - TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE; + machine_mode long_double_type_mode + = targetm.c.mode_for_floating_type (TI_LONG_DOUBLE_TYPE); + SET_TYPE_MODE (long_double_type_node, long_double_type_mode); + TYPE_PRECISION (long_double_type_node) + = GET_MODE_PRECISION (long_double_type_mode).to_constant (); layout_type (long_double_type_node); for (i = 0; i < NUM_FLOATN_NX_TYPES; i++) |