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. */
#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
#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
return (GET_MODE_SIZE (from) == GET_MODE_SIZE (to)
|| !reg_classes_intersect_p (FLOAT_REGS, rclass));
}
-\f
+
+/* 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
#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;
\f
/* 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
#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
}
}
+/* 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
#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;
\f
#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
* 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)
/* 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
* #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
#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"
#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
#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
#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
#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
#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
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. */
#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;
#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
#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
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)
#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
#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
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);
#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
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
#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
#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
#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"
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)
{
#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"
#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)
#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
/* 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
#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)
#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
#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
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);
\f
/* Initialize the GCC target structure. */
#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,
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"
/* "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
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 \
#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
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)
#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;
\f
#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)
#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
/* 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
#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)
#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
#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
#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
#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
#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"
#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"
#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
#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
#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.
#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
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);
#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
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;
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 *
/* 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)
#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???? */
#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"
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"
#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"
#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
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);
+}
+
\f
/* The strub runtime uses asms, and physical register allocation won't
deal with them, so disable it. */
#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
#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
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)
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
== (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);
+}
\f
#undef TARGET_NARROW_VOLATILE_BITFIELD
#define TARGET_NARROW_VOLATILE_BITFIELD rx_narrow_volatile_bitfield
#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"
#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. */
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
#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"
#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
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);
\f
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;
\f
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
/* 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
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
/* 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. */
\f
/* 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
/* 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 "\
#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
#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
/* 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
#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 \
/* 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. */
#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
#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
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);
\f
#ifdef SUBTARGET_ATTRIBUTE_TABLE
/* Table of valid machine attributes. */
#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. */
#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)
{
/* 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
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"
#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
#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"
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'
#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
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. */
#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
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
@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
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
@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
@hook TARGET_C_BITINT_TYPE_INFO
+@hook TARGET_C_MODE_FOR_FLOATING_TYPE
+
@hook TARGET_PROMOTE_FUNCTION_MODE
@defmac PARM_BOUNDARY
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
@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
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);
#define INCLUDE_SSTREAM
#include "system.h"
#include "coretypes.h"
-#include "tm.h"
+#include "target.h"
#include "pretty-print.h"
#include "toplev.h"
recording::memento_of_get_type::get_size ()
{
int size;
+ machine_mode m;
switch (m_kind)
{
case GCC_JIT_TYPE_VOID:
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;
#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 ())
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. */
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. */
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)
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;
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 *);
};
/* 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,
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. */
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++)
projects / thirdparty / gcc.git / commitdiff
