From f073de07ad00d4be604bdbaeab14786850932601 Mon Sep 17 00:00:00 2001 From: Richard Sandiford Date: Thu, 26 Oct 2017 11:28:25 +0000 Subject: [PATCH] This patch adds a new hook that gives the preferred alignment for a static rtx... TARGET_STATIC_RTX_ALIGNMENT This patch adds a new hook that gives the preferred alignment for a static rtx, so that we don't need to query the front end in force_const_mem. 2017-10-26 Richard Sandiford gcc/ * target.def (static_rtx_alignment): New hook. * targhooks.h (default_static_rtx_alignment): Declare. * targhooks.c (default_static_rtx_alignment): New function. * doc/tm.texi.in (TARGET_STATIC_RTX_ALIGNMENT): New hook. * doc/tm.texi: Regenerate. * varasm.c (force_const_mem): Use targetm.static_rtx_alignment instead of targetm.constant_alignment. Remove call to set_mem_attributes. * config/cris/cris.c (TARGET_STATIC_RTX_ALIGNMENT): Redefine. (cris_preferred_mininum_alignment): New function, split out from... (cris_constant_alignment): ...here. (cris_static_rtx_alignment): New function. * config/i386/i386.c (ix86_static_rtx_alignment): New function, split out from... (ix86_constant_alignment): ...here. (TARGET_STATIC_RTX_ALIGNMENT): Redefine. * config/mmix/mmix.c (TARGET_STATIC_RTX_ALIGNMENT): Redefine. (mmix_static_rtx_alignment): New function. * config/spu/spu.c (spu_static_rtx_alignment): New function. (TARGET_STATIC_RTX_ALIGNMENT): Redefine. From-SVN: r254102 --- gcc/ChangeLog | 23 +++++++++++++++++++++++ gcc/config/cris/cris.c | 29 ++++++++++++++++++++++++----- gcc/config/i386/i386.c | 21 +++++++++++++++++---- gcc/config/mmix/mmix.c | 11 +++++++++++ gcc/config/spu/spu.c | 14 ++++++++++++++ gcc/doc/tm.texi | 7 +++++++ gcc/doc/tm.texi.in | 2 ++ gcc/target.def | 9 +++++++++ gcc/targhooks.c | 8 ++++++++ gcc/targhooks.h | 1 + gcc/varasm.c | 8 ++------ 11 files changed, 118 insertions(+), 15 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index ad54a57e1c0..3033a7f789d 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,26 @@ +2017-10-26 Richard Sandiford + + * target.def (static_rtx_alignment): New hook. + * targhooks.h (default_static_rtx_alignment): Declare. + * targhooks.c (default_static_rtx_alignment): New function. + * doc/tm.texi.in (TARGET_STATIC_RTX_ALIGNMENT): New hook. + * doc/tm.texi: Regenerate. + * varasm.c (force_const_mem): Use targetm.static_rtx_alignment + instead of targetm.constant_alignment. Remove call to + set_mem_attributes. + * config/cris/cris.c (TARGET_STATIC_RTX_ALIGNMENT): Redefine. + (cris_preferred_mininum_alignment): New function, split out from... + (cris_constant_alignment): ...here. + (cris_static_rtx_alignment): New function. + * config/i386/i386.c (ix86_static_rtx_alignment): New function, + split out from... + (ix86_constant_alignment): ...here. + (TARGET_STATIC_RTX_ALIGNMENT): Redefine. + * config/mmix/mmix.c (TARGET_STATIC_RTX_ALIGNMENT): Redefine. + (mmix_static_rtx_alignment): New function. + * config/spu/spu.c (spu_static_rtx_alignment): New function. + (TARGET_STATIC_RTX_ALIGNMENT): Redefine. + 2017-10-26 Tamar Christina PR target/81800 diff --git a/gcc/config/cris/cris.c b/gcc/config/cris/cris.c index fe80a27b2d6..8fa234f7ff0 100644 --- a/gcc/config/cris/cris.c +++ b/gcc/config/cris/cris.c @@ -165,6 +165,7 @@ static bool cris_function_value_regno_p (const unsigned int); static void cris_file_end (void); static unsigned int cris_hard_regno_nregs (unsigned int, machine_mode); static bool cris_hard_regno_mode_ok (unsigned int, machine_mode); +static HOST_WIDE_INT cris_static_rtx_alignment (machine_mode); static HOST_WIDE_INT cris_constant_alignment (const_tree, HOST_WIDE_INT); /* This is the parsed result of the "-max-stack-stackframe=" option. If @@ -288,6 +289,8 @@ int cris_cpu_version = CRIS_DEFAULT_CPU_VERSION; #undef TARGET_HARD_REGNO_MODE_OK #define TARGET_HARD_REGNO_MODE_OK cris_hard_regno_mode_ok +#undef TARGET_STATIC_RTX_ALIGNMENT +#define TARGET_STATIC_RTX_ALIGNMENT cris_static_rtx_alignment #undef TARGET_CONSTANT_ALIGNMENT #define TARGET_CONSTANT_ALIGNMENT cris_constant_alignment @@ -4329,6 +4332,26 @@ cris_hard_regno_mode_ok (unsigned int regno, machine_mode mode) || (regno != CRIS_MOF_REGNUM && regno != CRIS_ACR_REGNUM))); } +/* Return the preferred minimum alignment for a static object. */ + +static HOST_WIDE_INT +cris_preferred_mininum_alignment (void) +{ + if (!TARGET_CONST_ALIGN) + return 8; + if (TARGET_ALIGN_BY_32) + return 32; + return 16; +} + +/* Implement TARGET_STATIC_RTX_ALIGNMENT. */ + +static HOST_WIDE_INT +cris_static_rtx_alignment (machine_mode mode) +{ + return MAX (cris_preferred_mininum_alignment (), GET_MODE_ALIGNMENT (mode)); +} + /* Implement TARGET_CONSTANT_ALIGNMENT. Note that this hook has the effect of making gcc believe that ALL references to constant stuff (in code segment, like strings) have this alignment. That is a rather @@ -4339,11 +4362,7 @@ cris_hard_regno_mode_ok (unsigned int regno, machine_mode mode) static HOST_WIDE_INT cris_constant_alignment (const_tree, HOST_WIDE_INT basic_align) { - if (!TARGET_CONST_ALIGN) - return basic_align; - if (TARGET_ALIGN_BY_32) - return MAX (basic_align, 32); - return MAX (basic_align, 16); + return MAX (cris_preferred_mininum_alignment (), basic_align); } #if 0 diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c index 56486e049c7..1facf121987 100644 --- a/gcc/config/i386/i386.c +++ b/gcc/config/i386/i386.c @@ -28741,6 +28741,18 @@ ix86_sched_init_global (FILE *, int, int) } +/* Implement TARGET_STATIC_RTX_ALIGNMENT. */ + +static HOST_WIDE_INT +ix86_static_rtx_alignment (machine_mode mode) +{ + if (mode == DFmode) + return 64; + if (ALIGN_MODE_128 (mode)) + return MAX (128, GET_MODE_ALIGNMENT (mode)); + return GET_MODE_ALIGNMENT (mode); +} + /* Implement TARGET_CONSTANT_ALIGNMENT. */ static HOST_WIDE_INT @@ -28749,10 +28761,9 @@ ix86_constant_alignment (const_tree exp, HOST_WIDE_INT align) if (TREE_CODE (exp) == REAL_CST || TREE_CODE (exp) == VECTOR_CST || TREE_CODE (exp) == INTEGER_CST) { - if (TYPE_MODE (TREE_TYPE (exp)) == DFmode && align < 64) - return 64; - else if (ALIGN_MODE_128 (TYPE_MODE (TREE_TYPE (exp))) && align < 128) - return 128; + machine_mode mode = TYPE_MODE (TREE_TYPE (exp)); + HOST_WIDE_INT mode_align = ix86_static_rtx_alignment (mode); + return MAX (mode_align, align); } else if (!optimize_size && TREE_CODE (exp) == STRING_CST && TREE_STRING_LENGTH (exp) >= 31 && align < BITS_PER_WORD) @@ -50295,6 +50306,8 @@ ix86_run_selftests (void) #undef TARGET_CAN_CHANGE_MODE_CLASS #define TARGET_CAN_CHANGE_MODE_CLASS ix86_can_change_mode_class +#undef TARGET_STATIC_RTX_ALIGNMENT +#define TARGET_STATIC_RTX_ALIGNMENT ix86_static_rtx_alignment #undef TARGET_CONSTANT_ALIGNMENT #define TARGET_CONSTANT_ALIGNMENT ix86_constant_alignment diff --git a/gcc/config/mmix/mmix.c b/gcc/config/mmix/mmix.c index e9115941e1e..4a73162c18c 100644 --- a/gcc/config/mmix/mmix.c +++ b/gcc/config/mmix/mmix.c @@ -168,6 +168,7 @@ static void mmix_print_operand (FILE *, rtx, int); static void mmix_print_operand_address (FILE *, machine_mode, rtx); static bool mmix_print_operand_punct_valid_p (unsigned char); static void mmix_conditional_register_usage (void); +static HOST_WIDE_INT mmix_static_rtx_alignment (machine_mode); static HOST_WIDE_INT mmix_constant_alignment (const_tree, HOST_WIDE_INT); static HOST_WIDE_INT mmix_starting_frame_offset (void); @@ -284,6 +285,8 @@ static HOST_WIDE_INT mmix_starting_frame_offset (void); #undef TARGET_OPTION_OVERRIDE #define TARGET_OPTION_OVERRIDE mmix_option_override +#undef TARGET_STATIC_RTX_ALIGNMENT +#define TARGET_STATIC_RTX_ALIGNMENT mmix_static_rtx_alignment #undef TARGET_CONSTANT_ALIGNMENT #define TARGET_CONSTANT_ALIGNMENT mmix_constant_alignment @@ -342,6 +345,14 @@ mmix_data_alignment (tree type ATTRIBUTE_UNUSED, int basic_align) return basic_align; } +/* Implement TARGET_STATIC_RTX_ALIGNMENT. */ + +static HOST_WIDE_INT +mmix_static_rtx_alignment (machine_mode mode) +{ + return MAX (GET_MODE_ALIGNMENT (mode), 32); +} + /* Implement tARGET_CONSTANT_ALIGNMENT. */ static HOST_WIDE_INT diff --git a/gcc/config/spu/spu.c b/gcc/config/spu/spu.c index eda7fcaaeb9..bf21cca5157 100644 --- a/gcc/config/spu/spu.c +++ b/gcc/config/spu/spu.c @@ -7196,6 +7196,18 @@ spu_truly_noop_truncation (unsigned int outprec, unsigned int inprec) return inprec <= 32 && outprec <= inprec; } +/* Implement TARGET_STATIC_RTX_ALIGNMENT. + + Make all static objects 16-byte aligned. This allows us to assume + they are also padded to 16 bytes, which means we can use a single + load or store instruction to access them. */ + +static HOST_WIDE_INT +spu_static_rtx_alignment (machine_mode mode) +{ + return MAX (GET_MODE_ALIGNMENT (mode), 128); +} + /* Implement TARGET_CONSTANT_ALIGNMENT. Make all static objects 16-byte aligned. This allows us to assume @@ -7447,6 +7459,8 @@ static const struct attribute_spec spu_attribute_table[] = #undef TARGET_TRULY_NOOP_TRUNCATION #define TARGET_TRULY_NOOP_TRUNCATION spu_truly_noop_truncation +#undef TARGET_STATIC_RTX_ALIGNMENT +#define TARGET_STATIC_RTX_ALIGNMENT spu_static_rtx_alignment #undef TARGET_CONSTANT_ALIGNMENT #define TARGET_CONSTANT_ALIGNMENT spu_constant_alignment diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 8484c1d3602..c02f4d35116 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -1078,6 +1078,13 @@ On 32-bit ELF the largest supported section alignment in bits is @samp{(0x80000000 * 8)}, but this is not representable on 32-bit hosts. @end defmac +@deftypefn {Target Hook} HOST_WIDE_INT TARGET_STATIC_RTX_ALIGNMENT (machine_mode @var{mode}) +This hook returns the preferred alignment in bits for a +statically-allocated rtx, such as a constant pool entry. @var{mode} +is the mode of the rtx. The default implementation returns +@samp{GET_MODE_ALIGNMENT (@var{mode})}. +@end deftypefn + @defmac DATA_ALIGNMENT (@var{type}, @var{basic-align}) If defined, a C expression to compute the alignment for a variable in the static store. @var{type} is the data type, and @var{basic-align} is diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index 015f59eac2e..37308e1e551 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -1026,6 +1026,8 @@ On 32-bit ELF the largest supported section alignment in bits is @samp{(0x80000000 * 8)}, but this is not representable on 32-bit hosts. @end defmac +@hook TARGET_STATIC_RTX_ALIGNMENT + @defmac DATA_ALIGNMENT (@var{type}, @var{basic-align}) If defined, a C expression to compute the alignment for a variable in the static store. @var{type} is the data type, and @var{basic-align} is diff --git a/gcc/target.def b/gcc/target.def index 435849c3d35..6a1cd31f2ac 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -3335,6 +3335,15 @@ HOOK_VECTOR_END (addr_space) #undef HOOK_PREFIX #define HOOK_PREFIX "TARGET_" +DEFHOOK +(static_rtx_alignment, + "This hook returns the preferred alignment in bits for a\n\ +statically-allocated rtx, such as a constant pool entry. @var{mode}\n\ +is the mode of the rtx. The default implementation returns\n\ +@samp{GET_MODE_ALIGNMENT (@var{mode})}.", + HOST_WIDE_INT, (machine_mode mode), + default_static_rtx_alignment) + DEFHOOK (constant_alignment, "This hook returns the alignment in bits of a constant that is being\n\ diff --git a/gcc/targhooks.c b/gcc/targhooks.c index 41cab3825df..92ecc90d4d4 100644 --- a/gcc/targhooks.c +++ b/gcc/targhooks.c @@ -1173,6 +1173,14 @@ tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED, return id; } +/* The default implementation of TARGET_STATIC_RTX_ALIGNMENT. */ + +HOST_WIDE_INT +default_static_rtx_alignment (machine_mode mode) +{ + return GET_MODE_ALIGNMENT (mode); +} + /* The default implementation of TARGET_CONSTANT_ALIGNMENT. */ HOST_WIDE_INT diff --git a/gcc/targhooks.h b/gcc/targhooks.h index 1510bb97a9c..f60bca257f7 100644 --- a/gcc/targhooks.h +++ b/gcc/targhooks.h @@ -94,6 +94,7 @@ extern int default_builtin_vectorization_cost (enum vect_cost_for_stmt, tree, in extern tree default_builtin_reciprocal (tree); +extern HOST_WIDE_INT default_static_rtx_alignment (machine_mode); extern HOST_WIDE_INT default_constant_alignment (const_tree, HOST_WIDE_INT); extern HOST_WIDE_INT constant_alignment_word_strings (const_tree, HOST_WIDE_INT); diff --git a/gcc/varasm.c b/gcc/varasm.c index d324ca034fb..a139151b2e1 100644 --- a/gcc/varasm.c +++ b/gcc/varasm.c @@ -3783,11 +3783,8 @@ force_const_mem (machine_mode mode, rtx x) *slot = desc; /* Align the location counter as required by EXP's data type. */ - align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode); - - tree type = lang_hooks.types.type_for_mode (mode, 0); - if (type != NULL_TREE) - align = targetm.constant_alignment (make_tree (type, x), align); + machine_mode align_mode = (mode == VOIDmode ? word_mode : mode); + align = targetm.static_rtx_alignment (align_mode); pool->offset += (align / BITS_PER_UNIT) - 1; pool->offset &= ~ ((align / BITS_PER_UNIT) - 1); @@ -3829,7 +3826,6 @@ force_const_mem (machine_mode mode, rtx x) /* Construct the MEM. */ desc->mem = def = gen_const_mem (mode, symbol); - set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1); set_mem_align (def, align); /* If we're dropping a label to the constant pool, make sure we