On Fri, Sep 22, 2017 at 6:42 PM, Richard Sandiford
<richard.sandif...@linaro.org> wrote:
> Richard Biener <richard.guent...@gmail.com> writes:
>> On Thu, Sep 21, 2017 at 2:56 PM, Richard Sandiford
>> <richard.sandif...@linaro.org> wrote:
>>> Richard Biener <richard.guent...@gmail.com> writes:
>>>> On September 20, 2017 2:36:03 PM GMT+02:00, Richard Sandiford
>>>> <richard.sandif...@linaro.org> wrote:
>>>>>When forcing a constant of mode MODE into memory, force_const_mem
>>>>>asks the frontend to provide the type associated with that mode.
>>>>>In principle type_for_mode is allowed to return null, and although
>>>>>one use site correctly handled that, the other didn't.
>>>>>
>>>>>I think there's agreement that it's bogus to use type_for_mode for
>>>>>this kind of thing, since it forces frontends to handle types that
>>>>>don't exist in that language. See e.g. http://gcc.gnu.org/PR46805
>>>>>where the Go frontend was forced to handle vector types even though
>>>>>Go doesn't have vector types.
>>>>>
>>>>>Also, the frontends use code like:
>>>>>
>>>>> else if (VECTOR_MODE_P (mode))
>>>>> {
>>>>> machine_mode inner_mode = GET_MODE_INNER (mode);
>>>>> tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
>>>>> if (inner_type != NULL_TREE)
>>>>> return build_vector_type_for_mode (inner_type, mode);
>>>>> }
>>>>>
>>>>>and there's no guarantee that every vector mode M used by backend
>>>>>rtl has an associated vector type whose TYPE_MODE is M. I think
>>>>>really the type_for_mode hook should only return trees that _do_ have
>>>>>the requested TYPE_MODE, but PR46805 linked above shows that this is
>>>>>likely to have too many knock-on consequences. It doesn't make sense
>>>>>for force_const_mem to ask about vector modes that aren't valid for
>>>>>vector types, so this patch handles the condition there instead.
>>>>>
>>>>>This is needed for SVE multi-register modes, which are modelled as
>>>>>vector modes but are not usable as vector types.
>>>>>
>>>>>Tested on aarch64-linux-gnu, x86_64-linux-gnu and
>>>>>powerpc64le-linus-gnu.
>>>>>OK to install?
>>>>
>>>> I think we should get rid of the use entirely.
>>>
>>> I first read this as not using type_for_mode at all in force_const_mem,
>>> which sounded like a good thing :-)
>>
>> That's what I meant ;) A mode doesn't really have a type...
>>
>> I tried it overnight on the usual
>>> at-least-one-target-per-CPU set and diffing the before and after
>>> assembly for the testsuite. And it looks like i686 relies on this
>>> to get an alignment of 16 rather than 4 for XFmode constants:
>>> GET_MODE_ALIGNMENT (XFmode) == 32 (as requested by i386-modes.def),
>>> but i386's CONSTANT_ALIGNMENT increases it to 128 for static constants.
>>
>> Then the issue is that CONSTANT_ALIGNMENT takes a tree and not a mode...
>> even worse than type_for_mode is a use of make_tree! Incidentially
>> ix86_constant_alignment _does_ look at the mode in the end...
>
> OK, I guess this means another target hook conversion. The patch
> below converts CONSTANT_ALIGNMENT with its current interface.
> The definition:
>
> #define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> (TREE_CODE (EXP) == STRING_CST \
> && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
>
> was very common, so the patch adds a canned definition for that,
> called constant_alignment_word_strings. Some ports had a variation
> that used a port-local FASTEST_ALIGNMENT instead of BITS_PER_WORD;
> the patch uses constant_alignment_word_strings if FASTEST_ALIGNMENT
> was always BITS_PER_WORD and a port-local hook function otherwise.
>
> Tested on aarch64-linux-gnu, x86_64-linux-gnu and powerpc64le-linux-gnu.
> Also tested by comparing the testsuite assembly output on at least one
> target per CPU directory. I don't think this comes under Jeff's
> preapproval due to the constant_alignment_word_strings thing, so:
> OK to install?
Ok.
Thanks,
Richard.
> If so, then I'll follow up with a separate hook for rtl modes, which
> varasm, default_constant_alignment and constant_alignment_word_strings
> can all use.
>
> Thanks,
> Richard
>
>
> 2017-09-22 Richard Sandiford <richard.sandif...@linaro.org>
>
> gcc/
> * target.def (constant_alignment): New hook.
> * defaults.h (CONSTANT_ALIGNMENT): Delete.
> * doc/tm.texi.in (CONSTANT_ALIGNMENT): Replace with...
> (TARGET_CONSTANT_ALIGNMENT): ...this new hook.
> * doc/tm.texi: Regenerate.
> * targhooks.h (default_constant_alignment): Declare.
> (constant_alignment_word_strings): Likewise.
> * targhooks.c (default_constant_alignment): New function.
> (constant_alignment_word_strings): Likewise.
> * builtins.c (get_object_alignment_2): Use targetm.constant_alignment
> instead of CONSTANT_ALIGNMENT.
> * varasm.c (align_variable, get_variable_align, build_constant_desc)
> (force_const_mem): Likewise.
> * config/aarch64/aarch64.h (CONSTANT_ALIGNMENT): Delete.
> * config/aarch64/aarch64.c (aarch64_constant_alignment): New function.
> (aarch64_classify_address): Call it instead of CONSTANT_ALIGNMENT.
> (TARGET_CONSTANT_ALIGNMENT): Redefine.
> * config/alpha/alpha.h (CONSTANT_ALIGNMENT): Delete commented-out
> definition.
> * config/arc/arc.h (CONSTANT_ALIGNMENT): Delete.
> * config/arc/arc.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/arm/arm.h (CONSTANT_ALIGNMENT_FACTOR): Delete.
> (CONSTANT_ALIGNMENT): Likewise.
> * config/arm/arm.c (TARGET_CONSTANT_ALIGNMENT): Redefine.
> (arm_constant_alignment): New function.
> * config/bfin/bfin.h (CONSTANT_ALIGNMENT): Delete.
> * config/bfin/bfin.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/cr16/cr16.h (CONSTANT_ALIGNMENT): Delete.
> * config/cr16/cr16.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/cris/cris.h (CONSTANT_ALIGNMENT): Delete.
> * config/cris/cris.c (TARGET_CONSTANT_ALIGNMENT): Redefine.
> (cris_constant_alignment): New function.
> * config/epiphany/epiphany.h (CONSTANT_ALIGNMENT): Delete.
> * config/epiphany/epiphany.c (TARGET_CONSTANT_ALIGNMENT): Redefine.
> (epiphany_constant_alignment): New function.
> * config/fr30/fr30.h (CONSTANT_ALIGNMENT): Delete.
> * config/fr30/fr30.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/frv/frv.h (CONSTANT_ALIGNMENT): Delete.
> * config/frv/frv.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/ft32/ft32.h (CONSTANT_ALIGNMENT): Delete.
> * config/ft32/ft32.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/i386/i386.h (CONSTANT_ALIGNMENT): Delete.
> * config/i386/i386-protos.h (ix86_constant_alignment): Delete.
> * config/i386/i386.c (ix86_constant_alignment): Make static.
> Use the same interface as the target hook.
> (TARGET_CONSTANT_ALIGNMENT): Redefine.
> * config/ia64/ia64.h (CONSTANT_ALIGNMENT): Delete.
> * config/ia64/ia64.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/iq2000/iq2000.h (CONSTANT_ALIGNMENT): Delete.
> * config/iq2000/iq2000.c (iq2000_constant_alignment): New function.
> (TARGET_CONSTANT_ALIGNMENT): Redefine.
> * config/lm32/lm32.h (CONSTANT_ALIGNMENT): Delete.
> * config/lm32/lm32.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/m32r/m32r.h (CONSTANT_ALIGNMENT): Delete.
> * config/m32r/m32r.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/mcore/mcore.h (CONSTANT_ALIGNMENT): Delete.
> * config/mcore/mcore.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/microblaze/microblaze.h (CONSTANT_ALIGNMENT): Delete.
> * config/microblaze/microblaze.c (microblaze_constant_alignment):
> New function.
> (TARGET_CONSTANT_ALIGNMENT): Redefine.
> * config/mips/mips.h (CONSTANT_ALIGNMENT): Delete.
> * config/mips/mips.c (mips_constant_alignment): New function.
> (TARGET_CONSTANT_ALIGNMENT): Redefine.
> * config/mmix/mmix.h (CONSTANT_ALIGNMENT): Delete.
> * config/mmix/mmix-protos.h (mmix_constant_alignment): Delete.
> * config/mmix/mmix.c (TARGET_CONSTANT_ALIGNMENT): Redefine.
> (mmix_constant_alignment): Make static. Use the same interface
> as the target hook.
> * config/moxie/moxie.h (CONSTANT_ALIGNMENT): Delete.
> * config/moxie/moxie.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/nios2/nios2.h (CONSTANT_ALIGNMENT): Delete.
> * config/nios2/nios2.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/pa/pa.h (CONSTANT_ALIGNMENT): Delete.
> * config/pa/pa.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/powerpcspe/powerpcspe.h (CONSTANT_ALIGNMENT): Delete.
> * config/powerpcspe/powerpcspe.c (TARGET_CONSTANT_ALIGNMENT):
> Redefine.
> (rs6000_constant_alignment): New function.
> * config/riscv/riscv.h (CONSTANT_ALIGNMENT): Delete.
> * config/riscv/riscv.c (riscv_constant_alignment): New function.
> (TARGET_CONSTANT_ALIGNMENT): Redefine.
> * config/rs6000/rs6000.h (CONSTANT_ALIGNMENT): Delete.
> * config/rs6000/rs6000.c (TARGET_CONSTANT_ALIGNMENT): Redefine.
> (rs6000_constant_alignment): New function.
> * config/s390/s390.h (CONSTANT_ALIGNMENT): Delete.
> * config/s390/s390.c (s390_constant_alignment): New function.
> (TARGET_CONSTANT_ALIGNMENT): Redefine.
> * config/sh/sh.h (CONSTANT_ALIGNMENT): Delete.
> * config/sh/sh.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/sparc/sparc.h (CONSTANT_ALIGNMENT): Delete.
> * config/sparc/sparc.c (TARGET_CONSTANT_ALIGNMENT): Redefine.
> (sparc_constant_alignment): New function.
> * config/spu/spu.h (CONSTANT_ALIGNMENT): Delete.
> * config/spu/spu.c (spu_constant_alignment): New function.
> (TARGET_CONSTANT_ALIGNMENT): Redefine.
> * config/stormy16/stormy16.h (CONSTANT_ALIGNMENT): Delete.
> * config/stormy16/stormy16.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/tilegx/tilegx.h (CONSTANT_ALIGNMENT): Delete.
> * config/tilegx/tilegx.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/tilepro/tilepro.h (CONSTANT_ALIGNMENT): Delete.
> * config/tilepro/tilepro.c (TARGET_CONSTANT_ALIGNMENT): Redefine to
> constant_alignment_word_strings.
> * config/visium/visium.h (CONSTANT_ALIGNMENT): Delete.
> * config/visium/visium.c (TARGET_CONSTANT_ALIGNMENT): Redefine.
> (visium_constant_alignment): New function.
> * config/xtensa/xtensa.h (CONSTANT_ALIGNMENT): Delete.
> * config/xtensa/xtensa.c (TARGET_CONSTANT_ALIGNMENT): Redefine.
> (xtensa_constant_alignment): New function.
> * system.h (CONSTANT_ALIGNMENT): Poison.
>
> Index: gcc/target.def
> ===================================================================
> --- gcc/target.def 2017-09-22 17:31:56.428954480 +0100
> +++ gcc/target.def 2017-09-22 17:37:26.791614385 +0100
> @@ -3335,6 +3335,21 @@ HOOK_VECTOR_END (addr_space)
> #undef HOOK_PREFIX
> #define HOOK_PREFIX "TARGET_"
>
> +DEFHOOK
> +(constant_alignment,
> + "This hook returns the alignment in bits of a constant that is being\n\
> +placed in memory. @var{constant} is the constant and @var{basic_align}\n\
> +is the alignment that the object would ordinarily have.\n\
> +\n\
> +The default definition just returns @var{basic_align}.\n\
> +\n\
> +The typical use of this hook is to increase alignment for string\n\
> +constants to be word aligned so that @code{strcpy} calls that copy\n\
> +constants can be done inline. The function\n\
> +@code{constant_alignment_word_strings} provides such a definition.",
> + HOST_WIDE_INT, (const_tree constant, HOST_WIDE_INT basic_align),
> + default_constant_alignment)
> +
> /* True if MODE is valid for the target. By "valid", we mean able to
> be manipulated in non-trivial ways. In particular, this means all
> the arithmetic is supported. */
> Index: gcc/defaults.h
> ===================================================================
> --- gcc/defaults.h 2017-09-12 14:27:14.524325620 +0100
> +++ gcc/defaults.h 2017-09-22 17:37:26.788614385 +0100
> @@ -1265,10 +1265,6 @@ #define WORD_REGISTER_OPERATIONS 0
> #define LOAD_EXTEND_OP(M) UNKNOWN
> #endif
>
> -#ifndef CONSTANT_ALIGNMENT
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) ALIGN
> -#endif
> -
> #ifndef INITIAL_FRAME_ADDRESS_RTX
> #define INITIAL_FRAME_ADDRESS_RTX NULL
> #endif
> Index: gcc/doc/tm.texi.in
> ===================================================================
> --- gcc/doc/tm.texi.in 2017-09-22 17:31:36.934389276 +0100
> +++ gcc/doc/tm.texi.in 2017-09-22 17:37:26.790614385 +0100
> @@ -1050,19 +1050,7 @@ must be aligned to 16 byte boundaries.
> If this macro is not defined, then @var{basic-align} is used.
> @end defmac
>
> -@defmac CONSTANT_ALIGNMENT (@var{constant}, @var{basic-align})
> -If defined, a C expression to compute the alignment given to a constant
> -that is being placed in memory. @var{constant} is the constant and
> -@var{basic-align} is the alignment that the object would ordinarily
> -have. The value of this macro is used instead of that alignment to
> -align the object.
> -
> -The default definition just returns @var{basic-align}.
> -
> -The typical use of this macro is to increase alignment for string
> -constants to be word aligned so that @code{strcpy} calls that copy
> -constants can be done inline.
> -@end defmac
> +@hook TARGET_CONSTANT_ALIGNMENT
>
> @defmac LOCAL_ALIGNMENT (@var{type}, @var{basic-align})
> If defined, a C expression to compute the alignment for a variable in
> Index: gcc/doc/tm.texi
> ===================================================================
> --- gcc/doc/tm.texi 2017-09-22 17:31:56.428006577 +0100
> +++ gcc/doc/tm.texi 2017-09-22 17:37:26.789614385 +0100
> @@ -1102,19 +1102,18 @@ must be aligned to 16 byte boundaries.
> If this macro is not defined, then @var{basic-align} is used.
> @end defmac
>
> -@defmac CONSTANT_ALIGNMENT (@var{constant}, @var{basic-align})
> -If defined, a C expression to compute the alignment given to a constant
> -that is being placed in memory. @var{constant} is the constant and
> -@var{basic-align} is the alignment that the object would ordinarily
> -have. The value of this macro is used instead of that alignment to
> -align the object.
> +@deftypefn {Target Hook} HOST_WIDE_INT TARGET_CONSTANT_ALIGNMENT (const_tree
> @var{constant}, HOST_WIDE_INT @var{basic_align})
> +This hook returns the alignment in bits of a constant that is being
> +placed in memory. @var{constant} is the constant and @var{basic_align}
> +is the alignment that the object would ordinarily have.
>
> -The default definition just returns @var{basic-align}.
> +The default definition just returns @var{basic_align}.
>
> -The typical use of this macro is to increase alignment for string
> +The typical use of this hook is to increase alignment for string
> constants to be word aligned so that @code{strcpy} calls that copy
> -constants can be done inline.
> -@end defmac
> +constants can be done inline. The function
> +@code{constant_alignment_word_strings} provides such a definition.
> +@end deftypefn
>
> @defmac LOCAL_ALIGNMENT (@var{type}, @var{basic-align})
> If defined, a C expression to compute the alignment for a variable in
> Index: gcc/targhooks.h
> ===================================================================
> --- gcc/targhooks.h 2017-09-22 17:31:36.935337179 +0100
> +++ gcc/targhooks.h 2017-09-22 17:37:26.791614385 +0100
> @@ -93,6 +93,9 @@ extern int default_builtin_vectorization
>
> extern tree default_builtin_reciprocal (tree);
>
> +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);
> extern HOST_WIDE_INT default_vector_alignment (const_tree);
>
> extern HOST_WIDE_INT default_preferred_vector_alignment (const_tree);
> Index: gcc/targhooks.c
> ===================================================================
> --- gcc/targhooks.c 2017-09-22 17:31:36.935337179 +0100
> +++ gcc/targhooks.c 2017-09-22 17:37:26.791614385 +0100
> @@ -1165,6 +1165,25 @@ tree default_mangle_decl_assembler_name
> return id;
> }
>
> +/* The default implementation of TARGET_CONSTANT_ALIGNMENT. */
> +
> +HOST_WIDE_INT
> +default_constant_alignment (const_tree, HOST_WIDE_INT align)
> +{
> + return align;
> +}
> +
> +/* An implementation of TARGET_CONSTANT_ALIGNMENT that aligns strings
> + to at least BITS_PER_WORD but otherwise makes no changes. */
> +
> +HOST_WIDE_INT
> +constant_alignment_word_strings (const_tree exp, HOST_WIDE_INT align)
> +{
> + if (TREE_CODE (exp) == STRING_CST)
> + return MAX (align, BITS_PER_WORD);
> + return align;
> +}
> +
> /* Default to natural alignment for vector types. */
> HOST_WIDE_INT
> default_vector_alignment (const_tree type)
> Index: gcc/builtins.c
> ===================================================================
> --- gcc/builtins.c 2017-09-05 20:56:49.744887619 +0100
> +++ gcc/builtins.c 2017-09-22 17:37:26.746614388 +0100
> @@ -283,7 +283,7 @@ get_object_alignment_2 (tree exp, unsign
> exp = DECL_INITIAL (exp);
> align = TYPE_ALIGN (TREE_TYPE (exp));
> if (CONSTANT_CLASS_P (exp))
> - align = (unsigned) CONSTANT_ALIGNMENT (exp, align);
> + align = targetm.constant_alignment (exp, align);
>
> known_alignment = true;
> }
> @@ -359,7 +359,7 @@ get_object_alignment_2 (tree exp, unsign
> wrapped inside a CONST_DECL. */
> align = TYPE_ALIGN (TREE_TYPE (exp));
> if (CONSTANT_CLASS_P (exp))
> - align = (unsigned) CONSTANT_ALIGNMENT (exp, align);
> + align = targetm.constant_alignment (exp, align);
>
> known_alignment = true;
> }
> Index: gcc/varasm.c
> ===================================================================
> --- gcc/varasm.c 2017-09-21 22:34:52.782138953 +0100
> +++ gcc/varasm.c 2017-09-22 17:37:26.792614385 +0100
> @@ -1055,7 +1055,7 @@ align_variable (tree decl, bool dont_out
> && (in_lto_p || DECL_INITIAL (decl) != error_mark_node))
> {
> unsigned int const_align
> - = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
> + = targetm.constant_alignment (DECL_INITIAL (decl), align);
> /* Don't increase alignment too much for TLS variables - TLS
> space is too precious. */
> if (! DECL_THREAD_LOCAL_P (decl) || const_align <=
> BITS_PER_WORD)
> @@ -1106,8 +1106,8 @@ get_variable_align (tree decl)
> to mark offlined constructors. */
> && (in_lto_p || DECL_INITIAL (decl) != error_mark_node))
> {
> - unsigned int const_align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl),
> - align);
> + unsigned int const_align
> + = targetm.constant_alignment (DECL_INITIAL (decl), align);
> /* Don't increase alignment too much for TLS variables - TLS space
> is too precious. */
> if (! DECL_THREAD_LOCAL_P (decl) || const_align <= BITS_PER_WORD)
> @@ -3326,12 +3326,10 @@ build_constant_desc (tree exp)
> Instead we set the flag that will be recognized in make_decl_rtl. */
> DECL_IN_CONSTANT_POOL (decl) = 1;
> DECL_INITIAL (decl) = desc->value;
> - /* ??? CONSTANT_ALIGNMENT hasn't been updated for vector types on most
> - architectures so use DATA_ALIGNMENT as well, except for strings. */
> + /* ??? targetm.constant_alignment hasn't been updated for vector types on
> + most architectures so use DATA_ALIGNMENT as well, except for strings.
> */
> if (TREE_CODE (exp) == STRING_CST)
> - {
> - SET_DECL_ALIGN (decl, CONSTANT_ALIGNMENT (exp, DECL_ALIGN (decl)));
> - }
> + SET_DECL_ALIGN (decl, targetm.constant_alignment (exp, DECL_ALIGN
> (decl)));
> else
> align_variable (decl, 0);
>
> @@ -3790,7 +3788,7 @@ force_const_mem (machine_mode mode, rtx
>
> tree type = lang_hooks.types.type_for_mode (mode, 0);
> if (type != NULL_TREE)
> - align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
> + align = targetm.constant_alignment (make_tree (type, x), align);
>
> pool->offset += (align / BITS_PER_UNIT) - 1;
> pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
> Index: gcc/config/aarch64/aarch64.h
> ===================================================================
> --- gcc/config/aarch64/aarch64.h 2017-09-21 22:35:16.977238356 +0100
> +++ gcc/config/aarch64/aarch64.h 2017-09-22 17:37:26.747614388 +0100
> @@ -90,14 +90,6 @@ #define LONG_DOUBLE_TYPE_SIZE 128
> port. */
> #define TARGET_PTRMEMFUNC_VBIT_LOCATION ptrmemfunc_vbit_in_delta
>
> -/* Make strings word-aligned so that strcpy from constants will be
> - faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && !optimize_size \
> - && (ALIGN) < BITS_PER_WORD) \
> - ? BITS_PER_WORD : ALIGN)
> -
> /* Align definitions of arrays, unions and structures so that
> initializations and copies can be made more efficient. This is not
> ABI-changing, so it only affects places where we can see the
> Index: gcc/config/aarch64/aarch64.c
> ===================================================================
> --- gcc/config/aarch64/aarch64.c 2017-09-22 17:35:22.483794044 +0100
> +++ gcc/config/aarch64/aarch64.c 2017-09-22 17:37:26.747614388 +0100
> @@ -1142,6 +1142,17 @@ aarch64_hard_regno_caller_save_mode (uns
> return choose_hard_reg_mode (regno, nregs, false);
> }
>
> +/* Implement TARGET_CONSTANT_ALIGNMENT. Make strings word-aligned so
> + that strcpy from constants will be faster. */
> +
> +static HOST_WIDE_INT
> +aarch64_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + if (TREE_CODE (exp) == STRING_CST && !optimize_size)
> + return MAX (align, BITS_PER_WORD);
> + return align;
> +}
> +
> /* Return true if calls to DECL should be treated as
> long-calls (ie called via a register). */
> static bool
> @@ -4622,7 +4633,7 @@ aarch64_classify_address (struct aarch64
> {
> tree exp = SYMBOL_REF_DECL (sym);
> align = TYPE_ALIGN (TREE_TYPE (exp));
> - align = CONSTANT_ALIGNMENT (exp, align);
> + align = aarch64_constant_alignment (exp, align);
> }
> else if (SYMBOL_REF_DECL (sym))
> align = DECL_ALIGN (SYMBOL_REF_DECL (sym));
> @@ -15687,6 +15698,9 @@ #define TARGET_MODES_TIEABLE_P aarch64_m
> #define TARGET_HARD_REGNO_CALL_PART_CLOBBERED \
> aarch64_hard_regno_call_part_clobbered
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT aarch64_constant_alignment
> +
> #if CHECKING_P
> #undef TARGET_RUN_TARGET_SELFTESTS
> #define TARGET_RUN_TARGET_SELFTESTS selftest::aarch64_run_selftests
> Index: gcc/config/alpha/alpha.h
> ===================================================================
> --- gcc/config/alpha/alpha.h 2017-09-15 14:47:33.167333414 +0100
> +++ gcc/config/alpha/alpha.h 2017-09-22 17:37:26.748614388 +0100
> @@ -289,7 +289,6 @@ #define MINIMUM_ATOMIC_ALIGNMENT ((unsig
> /* ??? Only if block-move stuff knows about different source/destination
> alignment. */
> #if 0
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) MAX ((ALIGN), BITS_PER_WORD)
> #define DATA_ALIGNMENT(EXP, ALIGN) MAX ((ALIGN), BITS_PER_WORD)
> #endif
>
> Index: gcc/config/arc/arc.h
> ===================================================================
> --- gcc/config/arc/arc.h 2017-09-15 14:47:33.167333414 +0100
> +++ gcc/config/arc/arc.h 2017-09-22 17:37:26.749614388 +0100
> @@ -271,13 +271,6 @@ #define BIGGEST_ALIGNMENT 32
> /* The best alignment to use in cases where we have a choice. */
> #define FASTEST_ALIGNMENT 32
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < FASTEST_ALIGNMENT) \
> - ? FASTEST_ALIGNMENT : (ALIGN))
> -
> -
> /* Make arrays of chars word-aligned for the same reasons. */
> #define LOCAL_ALIGNMENT(TYPE, ALIGN) \
> (TREE_CODE (TYPE) == ARRAY_TYPE \
> Index: gcc/config/arc/arc.c
> ===================================================================
> --- gcc/config/arc/arc.c 2017-09-12 14:29:25.225531070 +0100
> +++ gcc/config/arc/arc.c 2017-09-22 17:37:26.749614388 +0100
> @@ -10657,6 +10657,9 @@ arc_use_anchors_for_symbol_p (const_rtx
> #undef TARGET_USE_ANCHORS_FOR_SYMBOL_P
> #define TARGET_USE_ANCHORS_FOR_SYMBOL_P arc_use_anchors_for_symbol_p
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-arc.h"
> Index: gcc/config/arm/arm.h
> ===================================================================
> --- gcc/config/arm/arm.h 2017-09-22 17:22:08.191305805 +0100
> +++ gcc/config/arm/arm.h 2017-09-22 17:37:26.752614387 +0100
> @@ -592,15 +592,6 @@ #define MALLOC_ABI_ALIGNMENT BIGGEST_AL
> #define BIGGEST_FIELD_ALIGNMENT 64
> #endif
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT_FACTOR (TARGET_THUMB || ! arm_tune_xscale ? 1 : 2)
> -
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && !optimize_size \
> - && (ALIGN) < BITS_PER_WORD * CONSTANT_ALIGNMENT_FACTOR) \
> - ? BITS_PER_WORD * CONSTANT_ALIGNMENT_FACTOR : (ALIGN))
> -
> /* Align definitions of arrays, unions and structures so that
> initializations and copies can be made more efficient. This is not
> ABI-changing, so it only affects places where we can see the
> Index: gcc/config/arm/arm.c
> ===================================================================
> --- gcc/config/arm/arm.c 2017-09-22 17:35:22.486794044 +0100
> +++ gcc/config/arm/arm.c 2017-09-22 17:37:26.751614388 +0100
> @@ -316,6 +316,7 @@ static opt_scalar_float_mode arm_floatn_
> static unsigned int arm_hard_regno_nregs (unsigned int, machine_mode);
> static bool arm_hard_regno_mode_ok (unsigned int, machine_mode);
> static bool arm_modes_tieable_p (machine_mode, machine_mode);
> +static HOST_WIDE_INT arm_constant_alignment (const_tree, HOST_WIDE_INT);
>
> /* Table of machine attributes. */
> static const struct attribute_spec arm_attribute_table[] =
> @@ -795,6 +796,9 @@ #define TARGET_MODES_TIEABLE_P arm_modes
>
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS arm_can_change_mode_class
> +
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT arm_constant_alignment
>
> /* Obstack for minipool constant handling. */
> static struct obstack minipool_obstack;
> @@ -31276,6 +31280,18 @@ arm_can_change_mode_class (machine_mode
> return true;
> }
>
> +/* Implement TARGET_CONSTANT_ALIGNMENT. Make strings word-aligned so
> + strcpy from constants will be faster. */
> +
> +static HOST_WIDE_INT
> +arm_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + unsigned int factor = (TARGET_THUMB || ! arm_tune_xscale ? 1 : 2);
> + if (TREE_CODE (exp) == STRING_CST && !optimize_size)
> + return MAX (align, BITS_PER_WORD * factor);
> + return align;
> +}
> +
> #if CHECKING_P
> namespace selftest {
>
> Index: gcc/config/bfin/bfin.h
> ===================================================================
> --- gcc/config/bfin/bfin.h 2017-09-15 14:47:33.168333307 +0100
> +++ gcc/config/bfin/bfin.h 2017-09-22 17:37:26.753614387 +0100
> @@ -321,11 +321,6 @@ #define ACCUMULATE_OUTGOING_ARGS 1
>
> #define LOCAL_ALIGNMENT(TYPE, ALIGN) bfin_local_alignment ((TYPE), (ALIGN))
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - (TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> #define TRAMPOLINE_SIZE (TARGET_FDPIC ? 30 : 18)
>
> /* Definitions for register eliminations.
> Index: gcc/config/bfin/bfin.c
> ===================================================================
> --- gcc/config/bfin/bfin.c 2017-09-12 14:29:25.228530938 +0100
> +++ gcc/config/bfin/bfin.c 2017-09-22 17:37:26.752614387 +0100
> @@ -5882,4 +5882,7 @@ #define TARGET_HARD_REGNO_MODE_OK bfin_h
> #undef TARGET_MODES_TIEABLE_P
> #define TARGET_MODES_TIEABLE_P bfin_modes_tieable_p
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
> Index: gcc/config/cr16/cr16.h
> ===================================================================
> --- gcc/config/cr16/cr16.h 2017-09-15 14:47:33.168333307 +0100
> +++ gcc/config/cr16/cr16.h 2017-09-22 17:37:26.753614387 +0100
> @@ -114,11 +114,6 @@ #define DATA_ALIGNMENT(TYPE, ALIGN)
> && ((ALIGN) < BITS_PER_WORD)) \
> ? (BITS_PER_WORD) : (ALIGN))
>
> -/* In CR16 strings are word-aligned; strcpy from constants will be faster.
> */
> -#define CONSTANT_ALIGNMENT(CONSTANT, ALIGN) \
> - (((TREE_CODE (CONSTANT) == STRING_CST) && ((ALIGN) < BITS_PER_WORD)) \
> - ? (BITS_PER_WORD) : (ALIGN))
> -
> #define STRICT_ALIGNMENT 0
>
> #define PCC_BITFIELD_TYPE_MATTERS 1
> Index: gcc/config/cr16/cr16.c
> ===================================================================
> --- gcc/config/cr16/cr16.c 2017-09-12 14:29:25.229530894 +0100
> +++ gcc/config/cr16/cr16.c 2017-09-22 17:37:26.753614387 +0100
> @@ -200,6 +200,9 @@ #define TARGET_REGISTER_MOVE_COST cr16_
> #undef TARGET_MEMORY_MOVE_COST
> #define TARGET_MEMORY_MOVE_COST cr16_memory_move_cost
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> /* Table of machine attributes. */
> static const struct attribute_spec cr16_attribute_table[] = {
> /* ISRs have special prologue and epilogue requirements. */
> Index: gcc/config/cris/cris.h
> ===================================================================
> --- gcc/config/cris/cris.h 2017-09-15 14:47:33.169333199 +0100
> +++ gcc/config/cris/cris.h 2017-09-22 17:37:26.754614387 +0100
> @@ -368,17 +368,6 @@ #define DATA_ALIGNMENT(TYPE, BASIC_ALIGN
> ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \
> : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN)
>
> -/* Note that CONSTANT_ALIGNMENT has the effect of making gcc believe that
> - ALL references to constant stuff (in code segment, like strings) has
> - this alignment. That is a rather rushed assumption. Luckily we do not
> - care about the "alignment" operand to builtin memcpy (only place where
> - it counts), so it doesn't affect any bad spots. */
> -#define CONSTANT_ALIGNMENT(CONSTANT, BASIC_ALIGN) \
> - (TARGET_CONST_ALIGN \
> - ? (TARGET_ALIGN_BY_32 \
> - ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \
> - : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN)
> -
> /* FIXME: Define LOCAL_ALIGNMENT for word and dword or arrays and
> structures (if -mstack-align=), and check that it is good. */
>
> Index: gcc/config/cris/cris.c
> ===================================================================
> --- gcc/config/cris/cris.c 2017-09-12 14:29:25.229530894 +0100
> +++ gcc/config/cris/cris.c 2017-09-22 17:37:26.754614387 +0100
> @@ -165,6 +165,7 @@ static bool cris_function_value_regno_p
> 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_constant_alignment (const_tree, HOST_WIDE_INT);
>
> /* This is the parsed result of the "-max-stack-stackframe=" option. If
> it (still) is zero, then there was no such option given. */
> @@ -287,6 +288,9 @@ #define TARGET_HARD_REGNO_NREGS cris_har
> #undef TARGET_HARD_REGNO_MODE_OK
> #define TARGET_HARD_REGNO_MODE_OK cris_hard_regno_mode_ok
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT cris_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> /* Helper for cris_load_multiple_op and cris_ret_movem_op. */
> @@ -4325,6 +4329,23 @@ cris_hard_regno_mode_ok (unsigned int re
> || (regno != CRIS_MOF_REGNUM && regno != CRIS_ACR_REGNUM)));
> }
>
> +/* 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
> + rushed assumption. Luckily we do not care about the "alignment"
> + operand to builtin memcpy (only place where it counts), so it doesn't
> + affect any bad spots. */
> +
> +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);
> +}
> +
> #if 0
> /* Various small functions to replace macros. Only called from a
> debugger. They might collide with gcc functions or system functions,
> Index: gcc/config/epiphany/epiphany.h
> ===================================================================
> --- gcc/config/epiphany/epiphany.h 2017-09-15 14:47:33.169333199 +0100
> +++ gcc/config/epiphany/epiphany.h 2017-09-22 17:37:26.754614387 +0100
> @@ -147,12 +147,6 @@ #define FASTEST_ALIGNMENT 64
>
> #define MALLOC_ABI_ALIGNMENT BIGGEST_ALIGNMENT
>
> -/* Make strings dword-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < FASTEST_ALIGNMENT) \
> - ? FASTEST_ALIGNMENT : (ALIGN))
> -
> /* Make arrays of chars dword-aligned for the same reasons.
> Also, align arrays of SImode items. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> Index: gcc/config/epiphany/epiphany.c
> ===================================================================
> --- gcc/config/epiphany/epiphany.c 2017-09-04 11:49:42.897500726 +0100
> +++ gcc/config/epiphany/epiphany.c 2017-09-22 17:37:26.754614387 +0100
> @@ -173,6 +173,9 @@ #define TARGET_ASM_ALIGNED_SI_OP "\t.wor
>
> #undef TARGET_HARD_REGNO_MODE_OK
> #define TARGET_HARD_REGNO_MODE_OK epiphany_hard_regno_mode_ok
> +
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT epiphany_constant_alignment
>
> bool
> epiphany_is_interrupt_p (tree decl)
> @@ -3014,4 +3017,15 @@ epiphany_start_function (FILE *file, con
> ASM_OUTPUT_FUNCTION_LABEL (file, name, decl);
> }
>
> +
> +/* Implement TARGET_CONSTANT_ALIGNMENT. */
> +
> +static HOST_WIDE_INT
> +epiphany_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + if (TREE_CODE (exp) == STRING_CST)
> + return MAX (align, FASTEST_ALIGNMENT);
> + return align;
> +}
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
> Index: gcc/config/fr30/fr30.h
> ===================================================================
> --- gcc/config/fr30/fr30.h 2017-09-15 14:47:33.169333199 +0100
> +++ gcc/config/fr30/fr30.h 2017-09-22 17:37:26.755614387 +0100
> @@ -88,10 +88,6 @@ #define DATA_ALIGNMENT(TYPE, ALIGN) \
> && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
> && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
>
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - (TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> #define STRICT_ALIGNMENT 1
>
> #define PCC_BITFIELD_TYPE_MATTERS 1
> Index: gcc/config/fr30/fr30.c
> ===================================================================
> --- gcc/config/fr30/fr30.c 2017-08-10 14:36:08.721447283 +0100
> +++ gcc/config/fr30/fr30.c 2017-09-22 17:37:26.754614387 +0100
> @@ -190,6 +190,9 @@ #define TARGET_ASM_TRAMPOLINE_TEMPLATE f
> #undef TARGET_TRAMPOLINE_INIT
> #define TARGET_TRAMPOLINE_INIT fr30_trampoline_init
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
>
> Index: gcc/config/frv/frv.h
> ===================================================================
> --- gcc/config/frv/frv.h 2017-09-15 14:47:33.169333199 +0100
> +++ gcc/config/frv/frv.h 2017-09-22 17:37:26.756614387 +0100
> @@ -351,20 +351,6 @@ #define DATA_ALIGNMENT(TYPE, ALIGN) \
> && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
> && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
>
> -/* If defined, a C expression to compute the alignment given to a constant
> that
> - is being placed in memory. CONSTANT is the constant and ALIGN is the
> - alignment that the object would ordinarily have. The value of this macro
> is
> - used instead of that alignment to align the object.
> -
> - If this macro is not defined, then ALIGN is used.
> -
> - The typical use of this macro is to increase alignment for string
> constants
> - to be word aligned so that `strcpy' calls that copy constants can be done
> - inline. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - (TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> /* Define this macro to be the value 1 if instructions will fail to work if
> given data not on the nominal alignment. If instructions will merely go
> slower in that case, define this macro as 0. */
> Index: gcc/config/frv/frv.c
> ===================================================================
> --- gcc/config/frv/frv.c 2017-09-12 14:29:25.231530806 +0100
> +++ gcc/config/frv/frv.c 2017-09-22 17:37:26.756614387 +0100
> @@ -523,6 +523,8 @@ #define TARGET_HARD_REGNO_NREGS frv_hard
> #define TARGET_HARD_REGNO_MODE_OK frv_hard_regno_mode_ok
> #undef TARGET_MODES_TIEABLE_P
> #define TARGET_MODES_TIEABLE_P frv_modes_tieable_p
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
>
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> Index: gcc/config/ft32/ft32.h
> ===================================================================
> --- gcc/config/ft32/ft32.h 2017-09-15 14:47:33.169333199 +0100
> +++ gcc/config/ft32/ft32.h 2017-09-22 17:37:26.756614387 +0100
> @@ -354,12 +354,6 @@ #define PCC_BITFIELD_TYPE_MATTERS
> is GET_MODE_SIZE(DImode). */
> #define MAX_FIXED_MODE_SIZE 32
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < FASTEST_ALIGNMENT) \
> - ? FASTEST_ALIGNMENT : (ALIGN))
> -
> /* Set this nonzero if move instructions will actually fail to work
> when given unaligned data. */
> #define STRICT_ALIGNMENT 1
> Index: gcc/config/ft32/ft32.c
> ===================================================================
> --- gcc/config/ft32/ft32.c 2017-08-30 12:18:46.608141057 +0100
> +++ gcc/config/ft32/ft32.c 2017-09-22 17:37:26.756614387 +0100
> @@ -940,6 +940,9 @@ ft32_elf_encode_section_info (tree decl,
> }
> }
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-ft32.h"
> Index: gcc/config/i386/i386.h
> ===================================================================
> --- gcc/config/i386/i386.h 2017-09-21 11:53:16.598005975 +0100
> +++ gcc/config/i386/i386.h 2017-09-22 17:37:26.761614387 +0100
> @@ -848,20 +848,6 @@ #define ADJUST_FIELD_ALIGN(FIELD, TYPE,
> x86_field_alignment ((TYPE), (COMPUTED))
> #endif
>
> -/* If defined, a C expression to compute the alignment given to a
> - constant that is being placed in memory. EXP is the constant
> - and ALIGN is the alignment that the object would ordinarily have.
> - The value of this macro is used instead of that alignment to align
> - the object.
> -
> - If this macro is not defined, then ALIGN is used.
> -
> - The typical use of this macro is to increase alignment for string
> - constants to be word aligned so that `strcpy' calls that copy
> - constants can be done inline. */
> -
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) ix86_constant_alignment ((EXP),
> (ALIGN))
> -
> /* If defined, a C expression to compute the alignment for a static
> variable. TYPE is the data type, and ALIGN is the alignment that
> the object would ordinarily have. The value of this macro is used
> Index: gcc/config/i386/i386-protos.h
> ===================================================================
> --- gcc/config/i386/i386-protos.h 2017-09-15 13:56:20.266148661 +0100
> +++ gcc/config/i386/i386-protos.h 2017-09-22 17:37:26.756614387 +0100
> @@ -209,7 +209,6 @@ extern unsigned int ix86_local_alignment
> unsigned int);
> extern unsigned int ix86_minimum_alignment (tree, machine_mode,
> unsigned int);
> -extern int ix86_constant_alignment (tree, int);
> extern tree ix86_handle_shared_attribute (tree *, tree, tree, int, bool *);
> extern tree ix86_handle_selectany_attribute (tree *, tree, tree, int, bool
> *);
> extern int x86_field_alignment (tree, int);
> Index: gcc/config/i386/i386.c
> ===================================================================
> --- gcc/config/i386/i386.c 2017-09-22 17:31:56.418527551 +0100
> +++ gcc/config/i386/i386.c 2017-09-22 17:37:26.760614387 +0100
> @@ -31555,14 +31555,10 @@ ix86_sched_init_global (FILE *, int, int
> }
>
>
> -/* Compute the alignment given to a constant that is being placed in memory.
> - EXP is the constant and ALIGN is the alignment that the object would
> - ordinarily have.
> - The value of this function is used instead of that alignment to align
> - the object. */
> +/* Implement TARGET_CONSTANT_ALIGNMENT. */
>
> -int
> -ix86_constant_alignment (tree exp, int align)
> +static HOST_WIDE_INT
> +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)
> @@ -53601,6 +53597,9 @@ #define TARGET_HARD_REGNO_CALL_PART_CLOB
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS ix86_can_change_mode_class
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT ix86_constant_alignment
> +
> #if CHECKING_P
> #undef TARGET_RUN_TARGET_SELFTESTS
> #define TARGET_RUN_TARGET_SELFTESTS selftest::ix86_run_selftests
> Index: gcc/config/ia64/ia64.h
> ===================================================================
> --- gcc/config/ia64/ia64.h 2017-09-15 14:47:33.170333092 +0100
> +++ gcc/config/ia64/ia64.h 2017-09-22 17:37:26.762614387 +0100
> @@ -185,15 +185,6 @@ #define DATA_ALIGNMENT(TYPE, ALIGN) \
> && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
> && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
>
> -/* If defined, a C expression to compute the alignment given to a constant
> that
> - is being placed in memory. CONSTANT is the constant and ALIGN is the
> - alignment that the object would ordinarily have. The value of this macro
> is
> - used instead of that alignment to align the object. */
> -
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - (TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> #define STRICT_ALIGNMENT 1
>
> /* Define this if you wish to imitate the way many other C compilers handle
> Index: gcc/config/ia64/ia64.c
> ===================================================================
> --- gcc/config/ia64/ia64.c 2017-09-22 17:31:56.419475454 +0100
> +++ gcc/config/ia64/ia64.c 2017-09-22 17:37:26.762614387 +0100
> @@ -672,6 +672,9 @@ #define TARGET_MODES_TIEABLE_P ia64_mode
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS ia64_can_change_mode_class
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> /* Returns TRUE iff the target attribute indicated by ATTR_ID takes a plain
> Index: gcc/config/iq2000/iq2000.h
> ===================================================================
> --- gcc/config/iq2000/iq2000.h 2017-09-15 14:47:33.170333092 +0100
> +++ gcc/config/iq2000/iq2000.h 2017-09-22 17:37:26.763614387 +0100
> @@ -96,10 +96,6 @@ #define DATA_ALIGNMENT(TYPE, ALIGN)
> || TREE_CODE (TYPE) == UNION_TYPE \
> || TREE_CODE (TYPE) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN))
>
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST || TREE_CODE (EXP) == CONSTRUCTOR) \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> #define EMPTY_FIELD_BOUNDARY 32
>
> #define STRUCTURE_SIZE_BOUNDARY 8
> Index: gcc/config/iq2000/iq2000.c
> ===================================================================
> --- gcc/config/iq2000/iq2000.c 2017-09-04 11:50:24.548966298 +0100
> +++ gcc/config/iq2000/iq2000.c 2017-09-22 17:37:26.762614387 +0100
> @@ -180,6 +180,7 @@ static void iq2000_print_operand_address
> static bool iq2000_print_operand_punct_valid_p (unsigned char code);
> static bool iq2000_hard_regno_mode_ok (unsigned int, machine_mode);
> static bool iq2000_modes_tieable_p (machine_mode, machine_mode);
> +static HOST_WIDE_INT iq2000_constant_alignment (const_tree, HOST_WIDE_INT);
>
> #undef TARGET_INIT_BUILTINS
> #define TARGET_INIT_BUILTINS iq2000_init_builtins
> @@ -264,6 +265,9 @@ #define TARGET_HARD_REGNO_MODE_OK iq2000
> #undef TARGET_MODES_TIEABLE_P
> #define TARGET_MODES_TIEABLE_P iq2000_modes_tieable_p
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT iq2000_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> /* Return nonzero if we split the address into high and low parts. */
> @@ -3532,4 +3536,14 @@ iq2000_modes_tieable_p (machine_mode mod
> || GET_MODE_CLASS (mode2) == MODE_COMPLEX_FLOAT));
> }
>
> +/* Implement TARGET_CONSTANT_ALIGNMENT. */
> +
> +static HOST_WIDE_INT
> +iq2000_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + if (TREE_CODE (exp) == STRING_CST || TREE_CODE (exp) == CONSTRUCTOR)
> + return MAX (align, BITS_PER_WORD);
> + return align;
> +}
> +
> #include "gt-iq2000.h"
> Index: gcc/config/lm32/lm32.h
> ===================================================================
> --- gcc/config/lm32/lm32.h 2017-09-15 14:47:33.171332984 +0100
> +++ gcc/config/lm32/lm32.h 2017-09-22 17:37:26.763614387 +0100
> @@ -99,11 +99,6 @@ #define STRICT_ALIGNMENT 1
>
> #define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - (TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> /* Make arrays and structures word-aligned to allow faster copying etc. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> ((((ALIGN) < BITS_PER_WORD) \
> Index: gcc/config/lm32/lm32.c
> ===================================================================
> --- gcc/config/lm32/lm32.c 2017-09-05 20:56:49.753937121 +0100
> +++ gcc/config/lm32/lm32.c 2017-09-22 17:37:26.763614387 +0100
> @@ -113,6 +113,9 @@ #define TARGET_HARD_REGNO_MODE_OK lm32_h
> #undef TARGET_MODES_TIEABLE_P
> #define TARGET_MODES_TIEABLE_P lm32_modes_tieable_p
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> /* Current frame information calculated by lm32_compute_frame_size. */
> Index: gcc/config/m32r/m32r.h
> ===================================================================
> --- gcc/config/m32r/m32r.h 2017-09-15 14:47:33.171332984 +0100
> +++ gcc/config/m32r/m32r.h 2017-09-22 17:37:26.766614387 +0100
> @@ -260,12 +260,6 @@ #define BIGGEST_ALIGNMENT 32
> /* The best alignment to use in cases where we have a choice. */
> #define FASTEST_ALIGNMENT 32
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < FASTEST_ALIGNMENT) \
> - ? FASTEST_ALIGNMENT : (ALIGN))
> -
> /* Make arrays of chars word-aligned for the same reasons. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> (TREE_CODE (TYPE) == ARRAY_TYPE \
> Index: gcc/config/m32r/m32r.c
> ===================================================================
> --- gcc/config/m32r/m32r.c 2017-09-04 11:50:08.518432217 +0100
> +++ gcc/config/m32r/m32r.c 2017-09-22 17:37:26.765614387 +0100
> @@ -217,6 +217,9 @@ #define TARGET_HARD_REGNO_MODE_OK m32r_h
> #undef TARGET_MODES_TIEABLE_P
> #define TARGET_MODES_TIEABLE_P m32r_modes_tieable_p
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> /* Called by m32r_option_override to initialize various things. */
> Index: gcc/config/mcore/mcore.h
> ===================================================================
> --- gcc/config/mcore/mcore.h 2017-09-15 14:47:33.171332984 +0100
> +++ gcc/config/mcore/mcore.h 2017-09-22 17:37:26.766614387 +0100
> @@ -148,12 +148,6 @@ #define PCC_BITFIELD_TYPE_MATTERS 1
> is GET_MODE_SIZE(DImode). */
> #define MAX_FIXED_MODE_SIZE 32
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < FASTEST_ALIGNMENT) \
> - ? FASTEST_ALIGNMENT : (ALIGN))
> -
> /* Make arrays of chars word-aligned for the same reasons. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> (TREE_CODE (TYPE) == ARRAY_TYPE \
> Index: gcc/config/mcore/mcore.c
> ===================================================================
> --- gcc/config/mcore/mcore.c 2017-09-04 11:50:08.519332606 +0100
> +++ gcc/config/mcore/mcore.c 2017-09-22 17:37:26.766614387 +0100
> @@ -248,6 +248,9 @@ #define TARGET_HARD_REGNO_MODE_OK mcore_
> #undef TARGET_MODES_TIEABLE_P
> #define TARGET_MODES_TIEABLE_P mcore_modes_tieable_p
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> /* Adjust the stack and return the number of bytes taken to do it. */
> Index: gcc/config/microblaze/microblaze.h
> ===================================================================
> --- gcc/config/microblaze/microblaze.h 2017-09-15 14:47:33.172332877 +0100
> +++ gcc/config/microblaze/microblaze.h 2017-09-22 17:37:26.767614387 +0100
> @@ -234,12 +234,6 @@ #define SIZE_TYPE "unsigned int"
> #undef PTRDIFF_TYPE
> #define PTRDIFF_TYPE "int"
>
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST || TREE_CODE (EXP) == CONSTRUCTOR) \
> - && (ALIGN) < BITS_PER_WORD \
> - ? BITS_PER_WORD \
> - : (ALIGN))
> -
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> ((((ALIGN) < BITS_PER_WORD) \
> && (TREE_CODE (TYPE) == ARRAY_TYPE \
> Index: gcc/config/microblaze/microblaze.c
> ===================================================================
> --- gcc/config/microblaze/microblaze.c 2017-09-05 20:56:49.754842071 +0100
> +++ gcc/config/microblaze/microblaze.c 2017-09-22 17:37:26.767614387 +0100
> @@ -3800,6 +3800,16 @@ microblaze_machine_dependent_reorg (void
> return;
> }
> }
> +
> +/* Implement TARGET_CONSTANT_ALIGNMENT. */
> +
> +static HOST_WIDE_INT
> +microblaze_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + if (TREE_CODE (exp) == STRING_CST || TREE_CODE (exp) == CONSTRUCTOR)
> + return MAX (align, BITS_PER_WORD);
> + return align;
> +}
>
> #undef TARGET_ENCODE_SECTION_INFO
> #define TARGET_ENCODE_SECTION_INFO microblaze_encode_section_info
> @@ -3904,6 +3914,9 @@ #define TARGET_HARD_REGNO_MODE_OK microb
> #undef TARGET_MODES_TIEABLE_P
> #define TARGET_MODES_TIEABLE_P microblaze_modes_tieable_p
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT microblaze_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-microblaze.h"
> Index: gcc/config/mips/mips.h
> ===================================================================
> --- gcc/config/mips/mips.h 2017-09-15 14:47:33.174332662 +0100
> +++ gcc/config/mips/mips.h 2017-09-22 17:37:26.769614386 +0100
> @@ -1636,22 +1636,6 @@ #define STRICT_ALIGNMENT 1
>
> #define PCC_BITFIELD_TYPE_MATTERS 1
>
> -/* If defined, a C expression to compute the alignment given to a
> - constant that is being placed in memory. CONSTANT is the constant
> - and ALIGN is the alignment that the object would ordinarily have.
> - The value of this macro is used instead of that alignment to align
> - the object.
> -
> - If this macro is not defined, then ALIGN is used.
> -
> - The typical use of this macro is to increase alignment for string
> - constants to be word aligned so that `strcpy' calls that copy
> - constants can be done inline. */
> -
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST || TREE_CODE (EXP) == CONSTRUCTOR) \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> /* If defined, a C expression to compute the alignment for a static
> variable. TYPE is the data type, and ALIGN is the alignment that
> the object would ordinarily have. The value of this macro is used
> Index: gcc/config/mips/mips.c
> ===================================================================
> --- gcc/config/mips/mips.c 2017-09-22 17:31:56.421371259 +0100
> +++ gcc/config/mips/mips.c 2017-09-22 17:37:26.769614386 +0100
> @@ -22336,6 +22336,16 @@ mips_truly_noop_truncation (unsigned int
> {
> return !TARGET_64BIT || inprec <= 32 || outprec > 32;
> }
> +
> +/* Implement TARGET_CONSTANT_ALIGNMENT. */
> +
> +static HOST_WIDE_INT
> +mips_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + if (TREE_CODE (exp) == STRING_CST || TREE_CODE (exp) == CONSTRUCTOR)
> + return MAX (align, BITS_PER_WORD);
> + return align;
> +}
>
> /* Initialize the GCC target structure. */
> #undef TARGET_ASM_ALIGNED_HI_OP
> @@ -22634,6 +22644,9 @@ #define TARGET_CAN_CHANGE_MODE_CLASS mip
> #undef TARGET_TRULY_NOOP_TRUNCATION
> #define TARGET_TRULY_NOOP_TRUNCATION mips_truly_noop_truncation
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT mips_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-mips.h"
> Index: gcc/config/mmix/mmix.h
> ===================================================================
> --- gcc/config/mmix/mmix.h 2017-09-15 14:47:33.174332662 +0100
> +++ gcc/config/mmix/mmix.h 2017-09-22 17:37:26.770614386 +0100
> @@ -167,9 +167,6 @@ #define MAX_OFILE_ALIGNMENT (32768 * 8)
> #define DATA_ABI_ALIGNMENT(TYPE, BASIC_ALIGN) \
> mmix_data_alignment (TYPE, BASIC_ALIGN)
>
> -#define CONSTANT_ALIGNMENT(CONSTANT, BASIC_ALIGN) \
> - mmix_constant_alignment (CONSTANT, BASIC_ALIGN)
> -
> #define LOCAL_ALIGNMENT(TYPE, BASIC_ALIGN) \
> mmix_local_alignment (TYPE, BASIC_ALIGN)
>
> Index: gcc/config/mmix/mmix-protos.h
> ===================================================================
> --- gcc/config/mmix/mmix-protos.h 2017-02-23 19:54:26.000000000 +0000
> +++ gcc/config/mmix/mmix-protos.h 2017-09-22 17:37:26.769614386 +0100
> @@ -47,7 +47,6 @@ extern unsigned mmix_dbx_register_number
> extern int mmix_use_simple_return (void);
> extern void mmix_make_decl_one_only (tree);
> extern int mmix_data_alignment (tree, int);
> -extern int mmix_constant_alignment (tree, int);
> extern unsigned mmix_local_alignment (tree, unsigned);
> extern void mmix_asm_output_pool_prologue (FILE *, const char *, tree, int);
> extern void mmix_asm_output_aligned_common (FILE *, const char *, int, int);
> Index: gcc/config/mmix/mmix.c
> ===================================================================
> --- gcc/config/mmix/mmix.c 2017-08-30 12:08:01.655417455 +0100
> +++ gcc/config/mmix/mmix.c 2017-09-22 17:37:26.770614386 +0100
> @@ -168,6 +168,7 @@ static void mmix_print_operand (FILE *,
> 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_constant_alignment (const_tree, HOST_WIDE_INT);
>
> /* Target structure macros. Listed by node. See `Using and Porting GCC'
> for a general description. */
> @@ -282,6 +283,9 @@ #define TARGET_TRAMPOLINE_INIT mmix_tram
> #undef TARGET_OPTION_OVERRIDE
> #define TARGET_OPTION_OVERRIDE mmix_option_override
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT mmix_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> /* Functions that are expansions for target macros.
> @@ -334,10 +338,10 @@ mmix_data_alignment (tree type ATTRIBUTE
> return basic_align;
> }
>
> -/* CONSTANT_ALIGNMENT. */
> +/* Implement tARGET_CONSTANT_ALIGNMENT. */
>
> -int
> -mmix_constant_alignment (tree constant ATTRIBUTE_UNUSED, int basic_align)
> +static HOST_WIDE_INT
> +mmix_constant_alignment (const_tree, HOST_WIDE_INT basic_align)
> {
> if (basic_align < 32)
> return 32;
> Index: gcc/config/moxie/moxie.h
> ===================================================================
> --- gcc/config/moxie/moxie.h 2017-09-15 14:47:33.175332555 +0100
> +++ gcc/config/moxie/moxie.h 2017-09-22 17:37:26.770614386 +0100
> @@ -317,12 +317,6 @@ #define PCC_BITFIELD_TYPE_MATTERS 1
> is GET_MODE_SIZE(DImode). */
> #define MAX_FIXED_MODE_SIZE 32
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < FASTEST_ALIGNMENT) \
> - ? FASTEST_ALIGNMENT : (ALIGN))
> -
> /* Make arrays of chars word-aligned for the same reasons. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> (TREE_CODE (TYPE) == ARRAY_TYPE \
> Index: gcc/config/moxie/moxie.c
> ===================================================================
> --- gcc/config/moxie/moxie.c 2017-08-10 14:36:08.735446777 +0100
> +++ gcc/config/moxie/moxie.c 2017-09-22 17:37:26.770614386 +0100
> @@ -667,6 +667,9 @@ #define TARGET_PRINT_OPERAND moxie_print
> #undef TARGET_PRINT_OPERAND_ADDRESS
> #define TARGET_PRINT_OPERAND_ADDRESS moxie_print_operand_address
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-moxie.h"
> Index: gcc/config/nios2/nios2.h
> ===================================================================
> --- gcc/config/nios2/nios2.h 2017-09-15 14:47:33.175332555 +0100
> +++ gcc/config/nios2/nios2.h 2017-09-22 17:37:26.771614386 +0100
> @@ -92,10 +92,6 @@ #define STACK_BOUNDARY 32
> #define PREFERRED_STACK_BOUNDARY 32
> #define MAX_FIXED_MODE_SIZE 64
>
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST) \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> #define LABEL_ALIGN(LABEL) nios2_label_align (LABEL)
>
> /* Layout of source language data types. */
> Index: gcc/config/nios2/nios2.c
> ===================================================================
> --- gcc/config/nios2/nios2.c 2017-09-04 11:50:24.551667467 +0100
> +++ gcc/config/nios2/nios2.c 2017-09-22 17:37:26.771614386 +0100
> @@ -5116,6 +5116,9 @@ #define TARGET_ASM_OUTPUT_MI_THUNK nios2
> #undef TARGET_MACHINE_DEPENDENT_REORG
> #define TARGET_MACHINE_DEPENDENT_REORG nios2_reorg
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-nios2.h"
> Index: gcc/config/pa/pa.h
> ===================================================================
> --- gcc/config/pa/pa.h 2017-09-15 14:47:33.176332447 +0100
> +++ gcc/config/pa/pa.h 2017-09-22 17:37:26.772614386 +0100
> @@ -309,11 +309,6 @@ #define BIGGEST_ALIGNMENT (2 * BITS_PER_
> atomic operations. */
> #define MALLOC_ABI_ALIGNMENT (TARGET_SOM ? 64 : 128)
>
> -/* Get around hp-ux assembler bug, and make strcpy of constants fast. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - (TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> /* Make arrays of chars word-aligned for the same reasons. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> (TREE_CODE (TYPE) == ARRAY_TYPE \
> Index: gcc/config/pa/pa.c
> ===================================================================
> --- gcc/config/pa/pa.c 2017-09-15 13:56:20.276148823 +0100
> +++ gcc/config/pa/pa.c 2017-09-22 17:37:26.772614386 +0100
> @@ -425,6 +425,9 @@ #define TARGET_MODES_TIEABLE_P pa_modes_
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS pa_can_change_mode_class
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> /* Parse the -mfixed-range= option string. */
> Index: gcc/config/powerpcspe/powerpcspe.h
> ===================================================================
> --- gcc/config/powerpcspe/powerpcspe.h 2017-09-15 14:47:33.176332447 +0100
> +++ gcc/config/powerpcspe/powerpcspe.h 2017-09-22 17:37:26.775614386 +0100
> @@ -978,14 +978,6 @@ enum data_align { align_abi, align_opt,
> #define LOCAL_ALIGNMENT(TYPE, ALIGN) \
> rs6000_data_alignment (TYPE, ALIGN, align_both)
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - (TREE_CODE (EXP) == STRING_CST \
> - && (STRICT_ALIGNMENT || !optimize_size) \
> - && (ALIGN) < BITS_PER_WORD \
> - ? BITS_PER_WORD \
> - : (ALIGN))
> -
> /* Make arrays of chars word-aligned for the same reasons. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> rs6000_data_alignment (TYPE, ALIGN, align_opt)
> Index: gcc/config/powerpcspe/powerpcspe.c
> ===================================================================
> --- gcc/config/powerpcspe/powerpcspe.c 2017-09-22 17:31:56.424214967 +0100
> +++ gcc/config/powerpcspe/powerpcspe.c 2017-09-22 17:37:26.775614386 +0100
> @@ -1984,6 +1984,9 @@ #define TARGET_SLOW_UNALIGNED_ACCESS rs6
>
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS rs6000_can_change_mode_class
> +
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT rs6000_constant_alignment
>
>
> /* Processor table. */
> @@ -43752,6 +43755,17 @@ rs6000_optab_supported_p (int op, machin
> return true;
> }
> }
> +
> +/* Implement TARGET_CONSTANT_ALIGNMENT. */
> +
> +static HOST_WIDE_INT
> +rs6000_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + if (TREE_CODE (exp) == STRING_CST
> + && (STRICT_ALIGNMENT || !optimize_size))
> + return MAX (align, BITS_PER_WORD);
> + return align;
> +}
>
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> Index: gcc/config/riscv/riscv.h
> ===================================================================
> --- gcc/config/riscv/riscv.h 2017-09-15 14:47:33.176332447 +0100
> +++ gcc/config/riscv/riscv.h 2017-09-22 17:37:26.776614386 +0100
> @@ -152,22 +152,6 @@ #define STRICT_ALIGNMENT TARGET_STRICT_A
>
> #define PCC_BITFIELD_TYPE_MATTERS 1
>
> -/* If defined, a C expression to compute the alignment given to a
> - constant that is being placed in memory. CONSTANT is the constant
> - and ALIGN is the alignment that the object would ordinarily have.
> - The value of this macro is used instead of that alignment to align
> - the object.
> -
> - If this macro is not defined, then ALIGN is used.
> -
> - The typical use of this macro is to increase alignment for string
> - constants to be word aligned so that `strcpy' calls that copy
> - constants can be done inline. */
> -
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST || TREE_CODE (EXP) == CONSTRUCTOR) \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> /* If defined, a C expression to compute the alignment for a static
> variable. TYPE is the data type, and ALIGN is the alignment that
> the object would ordinarily have. The value of this macro is used
> Index: gcc/config/riscv/riscv.c
> ===================================================================
> --- gcc/config/riscv/riscv.c 2017-09-15 13:56:20.282148920 +0100
> +++ gcc/config/riscv/riscv.c 2017-09-22 17:37:26.776614386 +0100
> @@ -3995,6 +3995,17 @@ riscv_can_change_mode_class (machine_mod
> return !reg_classes_intersect_p (FP_REGS, rclass);
> }
>
> +
> +/* Implement TARGET_CONSTANT_ALIGNMENT. */
> +
> +static HOST_WIDE_INT
> +riscv_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + if (TREE_CODE (exp) == STRING_CST || TREE_CODE (exp) == CONSTRUCTOR)
> + return MAX (align, BITS_PER_WORD);
> + return align;
> +}
> +
> /* Initialize the GCC target structure. */
> #undef TARGET_ASM_ALIGNED_HI_OP
> #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
> @@ -4142,6 +4153,9 @@ #define TARGET_SECONDARY_MEMORY_NEEDED r
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS riscv_can_change_mode_class
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT riscv_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-riscv.h"
> Index: gcc/config/rs6000/rs6000.h
> ===================================================================
> --- gcc/config/rs6000/rs6000.h 2017-09-15 14:47:33.177332340 +0100
> +++ gcc/config/rs6000/rs6000.h 2017-09-22 17:37:26.779614386 +0100
> @@ -950,14 +950,6 @@ enum data_align { align_abi, align_opt,
> #define LOCAL_ALIGNMENT(TYPE, ALIGN) \
> rs6000_data_alignment (TYPE, ALIGN, align_both)
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - (TREE_CODE (EXP) == STRING_CST \
> - && (STRICT_ALIGNMENT || !optimize_size) \
> - && (ALIGN) < BITS_PER_WORD \
> - ? BITS_PER_WORD \
> - : (ALIGN))
> -
> /* Make arrays of chars word-aligned for the same reasons. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> rs6000_data_alignment (TYPE, ALIGN, align_opt)
> Index: gcc/config/rs6000/rs6000.c
> ===================================================================
> --- gcc/config/rs6000/rs6000.c 2017-09-22 17:31:56.427058675 +0100
> +++ gcc/config/rs6000/rs6000.c 2017-09-22 17:37:26.779614386 +0100
> @@ -1974,6 +1974,9 @@ #define TARGET_SLOW_UNALIGNED_ACCESS rs6
>
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS rs6000_can_change_mode_class
> +
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT rs6000_constant_alignment
>
>
> /* Processor table. */
> @@ -39128,6 +39131,17 @@ rs6000_optab_supported_p (int op, machin
> return true;
> }
> }
> +
> +/* Implement TARGET_CONSTANT_ALIGNMENT. */
> +
> +static HOST_WIDE_INT
> +rs6000_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + if (TREE_CODE (exp) == STRING_CST
> + && (STRICT_ALIGNMENT || !optimize_size))
> + return MAX (align, BITS_PER_WORD);
> + return align;
> +}
>
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> Index: gcc/config/s390/s390.h
> ===================================================================
> --- gcc/config/s390/s390.h 2017-09-15 14:47:33.178332233 +0100
> +++ gcc/config/s390/s390.h 2017-09-22 17:37:26.781614386 +0100
> @@ -315,7 +315,6 @@ #define BIGGEST_ALIGNMENT 64
> #define EMPTY_FIELD_BOUNDARY 32
>
> /* Alignment on even addresses for LARL instruction. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) (ALIGN) < 16 ? 16 : (ALIGN)
> #define DATA_ABI_ALIGNMENT(TYPE, ALIGN) (ALIGN) < 16 ? 16 : (ALIGN)
>
> /* Alignment is not required by the hardware. */
> Index: gcc/config/s390/s390.c
> ===================================================================
> --- gcc/config/s390/s390.c 2017-09-21 11:53:16.508848803 +0100
> +++ gcc/config/s390/s390.c 2017-09-22 17:37:26.781614386 +0100
> @@ -15906,6 +15906,15 @@ s390_vector_alignment (const_tree type)
> return MIN (64, tree_to_shwi (TYPE_SIZE (type)));
> }
>
> +/* Implement TARGET_CONSTANT_ALIGNMENT. Alignment on even addresses for
> + LARL instruction. */
> +
> +static HOST_WIDE_INT
> +s390_constant_alignment (const_tree, HOST_WIDE_INT align)
> +{
> + return MAX (align, 16);
> +}
> +
> #ifdef HAVE_AS_MACHINE_MACHINEMODE
> /* Implement TARGET_ASM_FILE_START. */
> static void
> @@ -16325,6 +16334,9 @@ #define TARGET_OPTION_RESTORE s390_funct
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS s390_can_change_mode_class
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT s390_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-s390.h"
> Index: gcc/config/sh/sh.h
> ===================================================================
> --- gcc/config/sh/sh.h 2017-09-15 14:47:33.178332233 +0100
> +++ gcc/config/sh/sh.h 2017-09-22 17:37:26.782614386 +0100
> @@ -462,12 +462,6 @@ #define BIGGEST_ALIGNMENT (TARGET_ALIGN
> /* The best alignment to use in cases where we have a choice. */
> #define FASTEST_ALIGNMENT (32)
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < FASTEST_ALIGNMENT) \
> - ? FASTEST_ALIGNMENT : (ALIGN))
> -
> /* get_mode_alignment assumes complex values are always held in multiple
> registers, but that is not the case on the SH; CQImode and CHImode are
> held in a single integer register. */
> Index: gcc/config/sh/sh.c
> ===================================================================
> --- gcc/config/sh/sh.c 2017-09-15 13:56:20.288149017 +0100
> +++ gcc/config/sh/sh.c 2017-09-22 17:37:26.782614386 +0100
> @@ -657,6 +657,9 @@ #define TARGET_MODES_TIEABLE_P sh_modes_
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS sh_can_change_mode_class
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
>
> Index: gcc/config/sparc/sparc.h
> ===================================================================
> --- gcc/config/sparc/sparc.h 2017-09-15 14:47:33.178332233 +0100
> +++ gcc/config/sparc/sparc.h 2017-09-22 17:37:26.784614385 +0100
> @@ -579,12 +579,6 @@ #define MAX_FIXED_MODE_SIZE GET_MODE_BIT
> #define STACK_SAVEAREA_MODE(LEVEL) \
> ((LEVEL) == SAVE_NONLOCAL ? (TARGET_ARCH64 ? TImode : DImode) : Pmode)
>
> -/* Make strings word-aligned so strcpy from constants will be faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < FASTEST_ALIGNMENT) \
> - ? FASTEST_ALIGNMENT : (ALIGN))
> -
> /* Make arrays of chars word-aligned for the same reasons. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> (TREE_CODE (TYPE) == ARRAY_TYPE \
> Index: gcc/config/sparc/sparc.c
> ===================================================================
> --- gcc/config/sparc/sparc.c 2017-09-21 11:53:16.532263818 +0100
> +++ gcc/config/sparc/sparc.c 2017-09-22 17:37:26.784614385 +0100
> @@ -684,6 +684,7 @@ static bool sparc_hard_regno_mode_ok (un
> static bool sparc_modes_tieable_p (machine_mode, machine_mode);
> static bool sparc_can_change_mode_class (machine_mode, machine_mode,
> reg_class_t);
> +static HOST_WIDE_INT sparc_constant_alignment (const_tree, HOST_WIDE_INT);
>
> #ifdef SUBTARGET_ATTRIBUTE_TABLE
> /* Table of valid machine attributes. */
> @@ -925,6 +926,9 @@ #define TARGET_MODES_TIEABLE_P sparc_mod
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS sparc_can_change_mode_class
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT sparc_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> /* Return the memory reference contained in X if any, zero otherwise. */
> @@ -13429,4 +13433,14 @@ sparc_can_change_mode_class (machine_mod
> return true;
> }
>
> +/* Implement TARGET_CONSTANT_ALIGNMENT. */
> +
> +static HOST_WIDE_INT
> +sparc_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + if (TREE_CODE (exp) == STRING_CST)
> + return MAX (align, FASTEST_ALIGNMENT);
> + return align;
> +}
> +
> #include "gt-sparc.h"
> Index: gcc/config/spu/spu.h
> ===================================================================
> --- gcc/config/spu/spu.h 2017-09-15 15:37:22.133931616 +0100
> +++ gcc/config/spu/spu.h 2017-09-22 17:37:26.785614385 +0100
> @@ -96,7 +96,6 @@ #define MINIMUM_ATOMIC_ALIGNMENT 128
> on the stack. (Except a bug (?) allows some stack objects to be
> unaligned.) */
> #define DATA_ALIGNMENT(TYPE,ALIGN) ((ALIGN) > 128 ? (ALIGN) : 128)
> -#define CONSTANT_ALIGNMENT(TYPE,ALIGN) ((ALIGN) > 128 ? (ALIGN) : 128)
> #define LOCAL_ALIGNMENT(TYPE,ALIGN) ((ALIGN) > 128 ? (ALIGN) : 128)
>
> #define EMPTY_FIELD_BOUNDARY 32
> Index: gcc/config/spu/spu.c
> ===================================================================
> --- gcc/config/spu/spu.c 2017-09-21 22:36:18.178401236 +0100
> +++ gcc/config/spu/spu.c 2017-09-22 17:37:26.785614385 +0100
> @@ -4159,7 +4159,7 @@ spu_encode_section_info (tree decl, rtx
> which is both 16-byte aligned and padded to a 16-byte boundary. This
> would make it safe to store with a single instruction.
> We guarantee the alignment and padding for static objects by aligning
> - all of them to 16-bytes. (DATA_ALIGNMENT and CONSTANT_ALIGNMENT.)
> + all of them to 16-bytes. (DATA_ALIGNMENT and TARGET_CONSTANT_ALIGNMENT.)
> FIXME: We currently cannot guarantee this for objects on the stack
> because assign_parm_setup_stack calls assign_stack_local with the
> alignment of the parameter mode and in that case the alignment never
> @@ -7193,6 +7193,18 @@ spu_truly_noop_truncation (unsigned int
> {
> return inprec <= 32 && outprec <= inprec;
> }
> +
> +/* Implement TARGET_CONSTANT_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_constant_alignment (const_tree, HOST_WIDE_INT align)
> +{
> + return MAX (align, 128);
> +}
>
> /* Table of machine attributes. */
> static const struct attribute_spec spu_attribute_table[] =
> @@ -7433,6 +7445,9 @@ #define TARGET_CAN_CHANGE_MODE_CLASS spu
> #undef TARGET_TRULY_NOOP_TRUNCATION
> #define TARGET_TRULY_NOOP_TRUNCATION spu_truly_noop_truncation
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT spu_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-spu.h"
> Index: gcc/config/stormy16/stormy16.h
> ===================================================================
> --- gcc/config/stormy16/stormy16.h 2017-09-15 14:47:33.179332125 +0100
> +++ gcc/config/stormy16/stormy16.h 2017-09-22 17:37:26.785614385 +0100
> @@ -87,10 +87,6 @@ #define DATA_ALIGNMENT(TYPE, ALIGN) \
> && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
> && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
>
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - (TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
> -
> #define STRICT_ALIGNMENT 1
>
> #define PCC_BITFIELD_TYPE_MATTERS 1
> Index: gcc/config/stormy16/stormy16.c
> ===================================================================
> --- gcc/config/stormy16/stormy16.c 2017-09-04 11:50:08.540041564 +0100
> +++ gcc/config/stormy16/stormy16.c 2017-09-22 17:37:26.785614385 +0100
> @@ -2715,6 +2715,9 @@ #define TARGET_HARD_REGNO_MODE_OK xstorm
> #undef TARGET_MODES_TIEABLE_P
> #define TARGET_MODES_TIEABLE_P xstormy16_modes_tieable_p
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-stormy16.h"
> Index: gcc/config/tilegx/tilegx.h
> ===================================================================
> --- gcc/config/tilegx/tilegx.h 2017-09-15 14:47:33.180332018 +0100
> +++ gcc/config/tilegx/tilegx.h 2017-09-22 17:37:26.786614385 +0100
> @@ -94,13 +94,6 @@ #define FASTEST_ALIGNMENT 64
> #define BIGGEST_FIELD_ALIGNMENT 128
> #define WIDEST_HARDWARE_FP_SIZE 64
>
> -/* Make strings word-aligned so strcpy from constants will be
> - faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < FASTEST_ALIGNMENT) \
> - ? FASTEST_ALIGNMENT : (ALIGN))
> -
> /* Make arrays of chars word-aligned for the same reasons. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> (TREE_CODE (TYPE) == ARRAY_TYPE \
> Index: gcc/config/tilegx/tilegx.c
> ===================================================================
> --- gcc/config/tilegx/tilegx.c 2017-09-15 14:47:33.180332018 +0100
> +++ gcc/config/tilegx/tilegx.c 2017-09-22 17:37:26.786614385 +0100
> @@ -5734,6 +5734,9 @@ #define TARGET_CAN_USE_DOLOOP_P can_use_
> #undef TARGET_TRULY_NOOP_TRUNCATION
> #define TARGET_TRULY_NOOP_TRUNCATION tilegx_truly_noop_truncation
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-tilegx.h"
> Index: gcc/config/tilepro/tilepro.h
> ===================================================================
> --- gcc/config/tilepro/tilepro.h 2017-09-15 14:47:33.180332018 +0100
> +++ gcc/config/tilepro/tilepro.h 2017-09-22 17:37:26.787614385 +0100
> @@ -58,13 +58,6 @@ #define PCC_BITFIELD_TYPE_MATTERS 1
> #define FASTEST_ALIGNMENT 32
> #define BIGGEST_FIELD_ALIGNMENT 64
>
> -/* Make strings word-aligned so strcpy from constants will be
> - faster. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - ((TREE_CODE (EXP) == STRING_CST \
> - && (ALIGN) < FASTEST_ALIGNMENT) \
> - ? FASTEST_ALIGNMENT : (ALIGN))
> -
> /* Make arrays of chars word-aligned for the same reasons. */
> #define DATA_ALIGNMENT(TYPE, ALIGN) \
> (TREE_CODE (TYPE) == ARRAY_TYPE \
> Index: gcc/config/tilepro/tilepro.c
> ===================================================================
> --- gcc/config/tilepro/tilepro.c 2017-09-04 08:30:09.354408112 +0100
> +++ gcc/config/tilepro/tilepro.c 2017-09-22 17:37:26.786614385 +0100
> @@ -5091,6 +5091,9 @@ #define TARGET_ASM_FILE_END tilepro_file
> #undef TARGET_CAN_USE_DOLOOP_P
> #define TARGET_CAN_USE_DOLOOP_P can_use_doloop_if_innermost
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> #include "gt-tilepro.h"
> Index: gcc/config/visium/visium.h
> ===================================================================
> --- gcc/config/visium/visium.h 2017-09-15 14:47:33.181331910 +0100
> +++ gcc/config/visium/visium.h 2017-09-22 17:37:26.787614385 +0100
> @@ -236,16 +236,6 @@ #define BIGGEST_ALIGNMENT 32
> this macro is used instead of that alignment to align the object. */
> #define DATA_ALIGNMENT(TYPE,ALIGN) visium_data_alignment (TYPE, ALIGN)
>
> -/* `CONSTANT_ALIGNMENT (CONSTANT, BASIC-ALIGN)`
> -
> - If defined, a C expression to compute the alignment given to a
> - constant that is being placed in memory. CONSTANT is the constant
> - and BASIC-ALIGN is the alignment that the object would ordinarily
> - have. The value of this macro is used instead of that alignment to
> - align the object. */
> -#define CONSTANT_ALIGNMENT(EXP,ALIGN) \
> - visium_data_alignment (TREE_TYPE (EXP), ALIGN)
> -
> /* `LOCAL_ALIGNMENT (TYPE, BASIC-ALIGN)`
>
> If defined, a C expression to compute the alignment for a variable
> Index: gcc/config/visium/visium.c
> ===================================================================
> --- gcc/config/visium/visium.c 2017-09-15 13:56:20.293149098 +0100
> +++ gcc/config/visium/visium.c 2017-09-22 17:37:26.787614385 +0100
> @@ -237,6 +237,8 @@ static bool visium_modes_tieable_p (mach
> static bool visium_can_change_mode_class (machine_mode, machine_mode,
> reg_class_t);
>
> +static HOST_WIDE_INT visium_constant_alignment (const_tree, HOST_WIDE_INT);
> +
> /* Setup the global target hooks structure. */
>
> #undef TARGET_MAX_ANCHOR_OFFSET
> @@ -360,6 +362,9 @@ #define TARGET_MODES_TIEABLE_P visium_mo
> #undef TARGET_CAN_CHANGE_MODE_CLASS
> #define TARGET_CAN_CHANGE_MODE_CLASS visium_can_change_mode_class
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT visium_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
> namespace {
> @@ -834,6 +839,14 @@ visium_data_alignment (tree type, unsign
> return align;
> }
>
> +/* Implement TARGET_CONSTANT_ALIGNMENT. */
> +
> +static HOST_WIDE_INT
> +visium_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + return visium_data_alignment (TREE_TYPE (exp), align);
> +}
> +
> /* Helper function for HARD_REGNO_RENAME_OK (FROM, TO). Return non-zero if
> it is OK to rename a hard register FROM to another hard register TO. */
>
> Index: gcc/config/xtensa/xtensa.h
> ===================================================================
> --- gcc/config/xtensa/xtensa.h 2017-09-15 14:47:33.181331910 +0100
> +++ gcc/config/xtensa/xtensa.h 2017-09-22 17:37:26.788614385 +0100
> @@ -169,17 +169,6 @@ #define PROMOTE_MODE(MODE, UNSIGNEDP, TY
> bitfields and the structures that contain them. */
> #define PCC_BITFIELD_TYPE_MATTERS 1
>
> -/* Align string constants and constructors to at least a word boundary.
> - The typical use of this macro is to increase alignment for string
> - constants to be word aligned so that 'strcpy' calls that copy
> - constants can be done inline. */
> -#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
> - (!optimize_size && \
> - (TREE_CODE (EXP) == STRING_CST || TREE_CODE (EXP) == CONSTRUCTOR) \
> - && (ALIGN) < BITS_PER_WORD \
> - ? BITS_PER_WORD \
> - : (ALIGN))
> -
> /* Align arrays, unions and records to at least a word boundary.
> One use of this macro is to increase alignment of medium-size
> data to make it all fit in fewer cache lines. Another is to
> Index: gcc/config/xtensa/xtensa.c
> ===================================================================
> --- gcc/config/xtensa/xtensa.c 2017-09-12 14:29:25.261529490 +0100
> +++ gcc/config/xtensa/xtensa.c 2017-09-22 17:37:26.788614385 +0100
> @@ -181,6 +181,7 @@ static void xtensa_conditional_register_
> static unsigned int xtensa_hard_regno_nregs (unsigned int, machine_mode);
> static bool xtensa_hard_regno_mode_ok (unsigned int, machine_mode);
> static bool xtensa_modes_tieable_p (machine_mode, machine_mode);
> +static HOST_WIDE_INT xtensa_constant_alignment (const_tree, HOST_WIDE_INT);
>
>
>
> @@ -317,6 +318,9 @@ #define TARGET_HARD_REGNO_MODE_OK xtensa
> #undef TARGET_MODES_TIEABLE_P
> #define TARGET_MODES_TIEABLE_P xtensa_modes_tieable_p
>
> +#undef TARGET_CONSTANT_ALIGNMENT
> +#define TARGET_CONSTANT_ALIGNMENT xtensa_constant_alignment
> +
> struct gcc_target targetm = TARGET_INITIALIZER;
>
>
> @@ -4380,4 +4384,19 @@ enum reg_class xtensa_regno_to_class (in
> return regno_to_class[regno];
> }
>
> +/* Implement TARGET_CONSTANT_ALIGNMENT. Align string constants and
> + constructors to at least a word boundary. The typical use of this
> + macro is to increase alignment for string constants to be word
> + aligned so that 'strcpy' calls that copy constants can be done
> + inline. */
> +
> +static HOST_WIDE_INT
> +xtensa_constant_alignment (const_tree exp, HOST_WIDE_INT align)
> +{
> + if ((TREE_CODE (exp) == STRING_CST || TREE_CODE (exp) == CONSTRUCTOR)
> + && !optimize_size)
> + return MAX (align, BITS_PER_WORD);
> + return align;
> +}
> +
> #include "gt-xtensa.h"
> Index: gcc/system.h
> ===================================================================
> --- gcc/system.h 2017-09-15 15:37:22.136931501 +0100
> +++ gcc/system.h 2017-09-22 17:37:26.790614385 +0100
> @@ -915,7 +915,7 @@ #define realloc xrealloc
> MODES_TIEABLE_P FUNCTION_ARG_PADDING SLOW_UNALIGNED_ACCESS \
> HARD_REGNO_NREGS SECONDARY_MEMORY_NEEDED_MODE \
> SECONDARY_MEMORY_NEEDED CANNOT_CHANGE_MODE_CLASS \
> - TRULY_NOOP_TRUNCATION FUNCTION_ARG_OFFSET
> + TRULY_NOOP_TRUNCATION FUNCTION_ARG_OFFSET CONSTANT_ALIGNMENT
>
> /* Target macros only used for code built for the target, that have
> moved to libgcc-tm.h or have never been present elsewhere. */
