| Message ID | 87shfhzgwc.fsf@linaro.org |
|---|---|
| State | New |
| Headers | show |
| Series | Don't query the frontend for unsupported types | expand |
On September 20, 2017 2:36:03 PM GMT+02:00, Richard Sandiford <richard.sandiford@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. Richard. >Richard > > >2017-09-20 Richard Sandiford <richard.sandiford@linaro.org> > Alan Hayward <alan.hayward@arm.com> > David Sherwood <david.sherwood@arm.com> > >gcc/ > * varasm.c (force_const_mem): Don't ask the front end about > vector modes that are not supported as vector types by the target. > >Index: gcc/varasm.c >=================================================================== >--- gcc/varasm.c 2017-09-12 14:28:56.402824780 +0100 >+++ gcc/varasm.c 2017-09-20 13:33:15.942547232 +0100 >@@ -3785,10 +3785,17 @@ force_const_mem (machine_mode mode, rtx > desc = ggc_alloc<constant_descriptor_rtx> (); > *slot = desc; > >+ tree type = NULL_TREE; >+ if (mode != VOIDmode >+ /* Don't ask the frontend about vector modes if there cannot be >a >+ VECTOR_TYPE whose TYPE_MODE is MODE. */ >+ && (!VECTOR_MODE_P (mode) >+ || targetm.vector_mode_supported_p (mode))) >+ type = lang_hooks.types.type_for_mode (mode, 0); >+ > /* 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 = CONSTANT_ALIGNMENT (make_tree (type, x), align); > >@@ -3832,7 +3839,8 @@ force_const_mem (machine_mode mode, rtx > > /* Construct the MEM. */ > desc->mem = def = gen_const_mem (mode, symbol); >- set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), >1); >+ if (type) >+ set_mem_attributes (def, type, 1); > set_mem_align (def, align); > > /* If we're dropping a label to the constant pool, make sure we
Richard Biener <richard.guenther@gmail.com> writes: > On September 20, 2017 2:36:03 PM GMT+02:00, Richard Sandiford > <richard.sandiford@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 :-) 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. But now I wonder if you meant we should just get rid of: set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1); and keep the other call to type_for_mode, as below. Thanks, Richard 2017-09-21 Richard Sandiford <richard.sandiford@linaro.org> Alan Hayward <alan.hayward@arm.com> David Sherwood <david.sherwood@arm.com> gcc/ * varasm.c (force_const_mem): Don't ask the front end about vector modes that are not supported as vector types by the target. Remove call to set_mem_attributes. Index: gcc/varasm.c =================================================================== --- gcc/varasm.c 2017-09-21 11:17:14.726201207 +0100 +++ gcc/varasm.c 2017-09-21 13:54:22.209159021 +0100 @@ -3785,10 +3785,17 @@ force_const_mem (machine_mode mode, rtx desc = ggc_alloc<constant_descriptor_rtx> (); *slot = desc; + tree type = NULL_TREE; + if (mode != VOIDmode + /* Don't ask the frontend about vector modes if there cannot be a + VECTOR_TYPE whose TYPE_MODE is MODE. */ + && (!VECTOR_MODE_P (mode) + || targetm.vector_mode_supported_p (mode))) + type = lang_hooks.types.type_for_mode (mode, 0); + /* 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 = CONSTANT_ALIGNMENT (make_tree (type, x), align); @@ -3832,7 +3839,6 @@ force_const_mem (machine_mode mode, rtx /* 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
On Thu, Sep 21, 2017 at 2:56 PM, Richard Sandiford <richard.sandiford@linaro.org> wrote: > Richard Biener <richard.guenther@gmail.com> writes: >> On September 20, 2017 2:36:03 PM GMT+02:00, Richard Sandiford >> <richard.sandiford@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... > But now I wonder if you meant we should just get rid of: > > set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1); > > and keep the other call to type_for_mode, as below. Well, that one is easy to remove indeed. I think assigning an alias-set based on the mode of a constant is bogus anyway. Richard. > Thanks, > Richard > > > 2017-09-21 Richard Sandiford <richard.sandiford@linaro.org> > Alan Hayward <alan.hayward@arm.com> > David Sherwood <david.sherwood@arm.com> > > gcc/ > * varasm.c (force_const_mem): Don't ask the front end about > vector modes that are not supported as vector types by the target. > Remove call to set_mem_attributes. > > Index: gcc/varasm.c > =================================================================== > --- gcc/varasm.c 2017-09-21 11:17:14.726201207 +0100 > +++ gcc/varasm.c 2017-09-21 13:54:22.209159021 +0100 > @@ -3785,10 +3785,17 @@ force_const_mem (machine_mode mode, rtx > desc = ggc_alloc<constant_descriptor_rtx> (); > *slot = desc; > > + tree type = NULL_TREE; > + if (mode != VOIDmode > + /* Don't ask the frontend about vector modes if there cannot be a > + VECTOR_TYPE whose TYPE_MODE is MODE. */ > + && (!VECTOR_MODE_P (mode) > + || targetm.vector_mode_supported_p (mode))) > + type = lang_hooks.types.type_for_mode (mode, 0); > + > /* 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 = CONSTANT_ALIGNMENT (make_tree (type, x), align); > > @@ -3832,7 +3839,6 @@ force_const_mem (machine_mode mode, rtx > > /* 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
Richard Biener <richard.guenther@gmail.com> writes: > On Thu, Sep 21, 2017 at 2:56 PM, Richard Sandiford > <richard.sandiford@linaro.org> wrote: >> Richard Biener <richard.guenther@gmail.com> writes: >>> On September 20, 2017 2:36:03 PM GMT+02:00, Richard Sandiford >>> <richard.sandiford@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? 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.sandiford@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. */
On Fri, Sep 22, 2017 at 6:42 PM, Richard Sandiford <richard.sandiford@linaro.org> wrote: > Richard Biener <richard.guenther@gmail.com> writes: >> On Thu, Sep 21, 2017 at 2:56 PM, Richard Sandiford >> <richard.sandiford@linaro.org> wrote: >>> Richard Biener <richard.guenther@gmail.com> writes: >>>> On September 20, 2017 2:36:03 PM GMT+02:00, Richard Sandiford >>>> <richard.sandiford@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.sandiford@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. */
Richard Biener <richard.guenther@gmail.com> writes: > On Fri, Sep 22, 2017 at 6:42 PM, Richard Sandiford > <richard.sandiford@linaro.org> wrote: >> Richard Biener <richard.guenther@gmail.com> writes: >>> On Thu, Sep 21, 2017 at 2:56 PM, Richard Sandiford >>> <richard.sandiford@linaro.org> wrote: >>>> Richard Biener <richard.guenther@gmail.com> writes: >>>>> On September 20, 2017 2:36:03 PM GMT+02:00, Richard Sandiford >>>>> <richard.sandiford@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. A bit later than intended, but here's the follow-on to add the new rtx hook. 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. OK to install? Richard 2017-10-01 Richard Sandiford <richard.sandiford@linaro.org> 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. Index: gcc/target.def =================================================================== --- gcc/target.def 2017-09-25 17:04:16.792359030 +0100 +++ gcc/target.def 2017-10-01 17:14:18.480815538 +0100 @@ -3336,6 +3336,15 @@ HOOK_VECTOR_END (addr_space) #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\ placed in memory. @var{constant} is the constant and @var{basic_align}\n\ Index: gcc/targhooks.h =================================================================== --- gcc/targhooks.h 2017-09-25 17:04:16.793358890 +0100 +++ gcc/targhooks.h 2017-10-01 17:14:18.481821912 +0100 @@ -93,6 +93,7 @@ extern int default_builtin_vectorization 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); Index: gcc/targhooks.c =================================================================== --- gcc/targhooks.c 2017-09-25 17:04:16.793358890 +0100 +++ gcc/targhooks.c 2017-10-01 17:14:18.481821912 +0100 @@ -1165,6 +1165,14 @@ tree default_mangle_decl_assembler_name 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 Index: gcc/doc/tm.texi.in =================================================================== --- gcc/doc/tm.texi.in 2017-09-25 17:04:16.792359030 +0100 +++ gcc/doc/tm.texi.in 2017-10-01 17:14:18.480815538 +0100 @@ -1026,6 +1026,8 @@ On 32-bit ELF the largest supported sect @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 Index: gcc/doc/tm.texi =================================================================== --- gcc/doc/tm.texi 2017-09-25 17:04:16.791359170 +0100 +++ gcc/doc/tm.texi 2017-10-01 17:14:18.479809163 +0100 @@ -1078,6 +1078,13 @@ On 32-bit ELF the largest supported sect @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 Index: gcc/varasm.c =================================================================== --- gcc/varasm.c 2017-09-25 17:04:16.793358890 +0100 +++ gcc/varasm.c 2017-10-01 17:14:18.481821912 +0100 @@ -3784,11 +3784,8 @@ force_const_mem (machine_mode mode, rtx *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); @@ -3830,7 +3827,6 @@ force_const_mem (machine_mode mode, rtx /* 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 Index: gcc/config/cris/cris.c =================================================================== --- gcc/config/cris/cris.c 2017-09-25 17:04:16.762363228 +0100 +++ gcc/config/cris/cris.c 2017-10-01 17:14:18.472764540 +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_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 @@ #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_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 re || (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 re 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 Index: gcc/config/i386/i386.c =================================================================== --- gcc/config/i386/i386.c 2017-09-25 17:04:16.768362388 +0100 +++ gcc/config/i386/i386.c 2017-10-01 17:14:18.477796414 +0100 @@ -31563,6 +31563,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 @@ -31571,10 +31583,9 @@ ix86_constant_alignment (const_tree exp, 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) @@ -53605,6 +53616,8 @@ #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_STATIC_RTX_ALIGNMENT +#define TARGET_STATIC_RTX_ALIGNMENT ix86_static_rtx_alignment #undef TARGET_CONSTANT_ALIGNMENT #define TARGET_CONSTANT_ALIGNMENT ix86_constant_alignment Index: gcc/config/mmix/mmix.c =================================================================== --- gcc/config/mmix/mmix.c 2017-09-25 17:04:16.774361549 +0100 +++ gcc/config/mmix/mmix.c 2017-10-01 17:14:18.477796414 +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_static_rtx_alignment (machine_mode); static HOST_WIDE_INT mmix_constant_alignment (const_tree, HOST_WIDE_INT); /* Target structure macros. Listed by node. See `Using and Porting GCC' @@ -283,6 +284,8 @@ #define TARGET_TRAMPOLINE_INIT mmix_tram #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 @@ -338,6 +341,14 @@ mmix_data_alignment (tree type ATTRIBUTE 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 Index: gcc/config/spu/spu.c =================================================================== --- gcc/config/spu/spu.c 2017-09-25 17:04:16.787359730 +0100 +++ gcc/config/spu/spu.c 2017-10-01 17:14:18.478802788 +0100 @@ -7194,6 +7194,18 @@ spu_truly_noop_truncation (unsigned int 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 @@ -7445,6 +7457,8 @@ #define TARGET_CAN_CHANGE_MODE_CLASS spu #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
Ping. Richard Sandiford <richard.sandiford@linaro.org> writes: > Richard Biener <richard.guenther@gmail.com> writes: >> On Fri, Sep 22, 2017 at 6:42 PM, Richard Sandiford >> <richard.sandiford@linaro.org> wrote: >>> Richard Biener <richard.guenther@gmail.com> writes: >>>> On Thu, Sep 21, 2017 at 2:56 PM, Richard Sandiford >>>> <richard.sandiford@linaro.org> wrote: >>>>> Richard Biener <richard.guenther@gmail.com> writes: >>>>>> On September 20, 2017 2:36:03 PM GMT+02:00, Richard Sandiford >>>>>> <richard.sandiford@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. A bit later than intended, but here's the follow-on to add > the new rtx hook. > > 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. OK to install? > > Richard > > > 2017-10-01 Richard Sandiford <richard.sandiford@linaro.org> > > 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. > > Index: gcc/target.def > =================================================================== > --- gcc/target.def 2017-09-25 17:04:16.792359030 +0100 > +++ gcc/target.def 2017-10-01 17:14:18.480815538 +0100 > @@ -3336,6 +3336,15 @@ HOOK_VECTOR_END (addr_space) > #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\ > placed in memory. @var{constant} is the constant and @var{basic_align}\n\ > Index: gcc/targhooks.h > =================================================================== > --- gcc/targhooks.h 2017-09-25 17:04:16.793358890 +0100 > +++ gcc/targhooks.h 2017-10-01 17:14:18.481821912 +0100 > @@ -93,6 +93,7 @@ extern int default_builtin_vectorization > > 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); > Index: gcc/targhooks.c > =================================================================== > --- gcc/targhooks.c 2017-09-25 17:04:16.793358890 +0100 > +++ gcc/targhooks.c 2017-10-01 17:14:18.481821912 +0100 > @@ -1165,6 +1165,14 @@ tree default_mangle_decl_assembler_name > 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 > Index: gcc/doc/tm.texi.in > =================================================================== > --- gcc/doc/tm.texi.in 2017-09-25 17:04:16.792359030 +0100 > +++ gcc/doc/tm.texi.in 2017-10-01 17:14:18.480815538 +0100 > @@ -1026,6 +1026,8 @@ On 32-bit ELF the largest supported sect > @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 > Index: gcc/doc/tm.texi > =================================================================== > --- gcc/doc/tm.texi 2017-09-25 17:04:16.791359170 +0100 > +++ gcc/doc/tm.texi 2017-10-01 17:14:18.479809163 +0100 > @@ -1078,6 +1078,13 @@ On 32-bit ELF the largest supported sect > @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 > Index: gcc/varasm.c > =================================================================== > --- gcc/varasm.c 2017-09-25 17:04:16.793358890 +0100 > +++ gcc/varasm.c 2017-10-01 17:14:18.481821912 +0100 > @@ -3784,11 +3784,8 @@ force_const_mem (machine_mode mode, rtx > *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); > @@ -3830,7 +3827,6 @@ force_const_mem (machine_mode mode, rtx > > /* 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 > Index: gcc/config/cris/cris.c > =================================================================== > --- gcc/config/cris/cris.c 2017-09-25 17:04:16.762363228 +0100 > +++ gcc/config/cris/cris.c 2017-10-01 17:14:18.472764540 +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_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 @@ #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_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 re > || (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 re > 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 > Index: gcc/config/i386/i386.c > =================================================================== > --- gcc/config/i386/i386.c 2017-09-25 17:04:16.768362388 +0100 > +++ gcc/config/i386/i386.c 2017-10-01 17:14:18.477796414 +0100 > @@ -31563,6 +31563,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 > @@ -31571,10 +31583,9 @@ ix86_constant_alignment (const_tree exp, > 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) > @@ -53605,6 +53616,8 @@ #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_STATIC_RTX_ALIGNMENT > +#define TARGET_STATIC_RTX_ALIGNMENT ix86_static_rtx_alignment > #undef TARGET_CONSTANT_ALIGNMENT > #define TARGET_CONSTANT_ALIGNMENT ix86_constant_alignment > > Index: gcc/config/mmix/mmix.c > =================================================================== > --- gcc/config/mmix/mmix.c 2017-09-25 17:04:16.774361549 +0100 > +++ gcc/config/mmix/mmix.c 2017-10-01 17:14:18.477796414 +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_static_rtx_alignment (machine_mode); > static HOST_WIDE_INT mmix_constant_alignment (const_tree, HOST_WIDE_INT); > > /* Target structure macros. Listed by node. See `Using and Porting GCC' > @@ -283,6 +284,8 @@ #define TARGET_TRAMPOLINE_INIT mmix_tram > #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 > > @@ -338,6 +341,14 @@ mmix_data_alignment (tree type ATTRIBUTE > 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 > Index: gcc/config/spu/spu.c > =================================================================== > --- gcc/config/spu/spu.c 2017-09-25 17:04:16.787359730 +0100 > +++ gcc/config/spu/spu.c 2017-10-01 17:14:18.478802788 +0100 > @@ -7194,6 +7194,18 @@ spu_truly_noop_truncation (unsigned int > 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 > @@ -7445,6 +7457,8 @@ #define TARGET_CAN_CHANGE_MODE_CLASS spu > #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 >
On Sun, Oct 1, 2017 at 6:17 PM, Richard Sandiford <richard.sandiford@linaro.org> wrote: > Richard Biener <richard.guenther@gmail.com> writes: >> On Fri, Sep 22, 2017 at 6:42 PM, Richard Sandiford >> <richard.sandiford@linaro.org> wrote: >>> Richard Biener <richard.guenther@gmail.com> writes: >>>> On Thu, Sep 21, 2017 at 2:56 PM, Richard Sandiford >>>> <richard.sandiford@linaro.org> wrote: >>>>> Richard Biener <richard.guenther@gmail.com> writes: >>>>>> On September 20, 2017 2:36:03 PM GMT+02:00, Richard Sandiford >>>>>> <richard.sandiford@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. A bit later than intended, but here's the follow-on to add > the new rtx hook. > > 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. OK to install? Ok, sorry for the delay. Richard. > Richard > > > 2017-10-01 Richard Sandiford <richard.sandiford@linaro.org> > > 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. > > Index: gcc/target.def > =================================================================== > --- gcc/target.def 2017-09-25 17:04:16.792359030 +0100 > +++ gcc/target.def 2017-10-01 17:14:18.480815538 +0100 > @@ -3336,6 +3336,15 @@ HOOK_VECTOR_END (addr_space) > #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\ > placed in memory. @var{constant} is the constant and @var{basic_align}\n\ > Index: gcc/targhooks.h > =================================================================== > --- gcc/targhooks.h 2017-09-25 17:04:16.793358890 +0100 > +++ gcc/targhooks.h 2017-10-01 17:14:18.481821912 +0100 > @@ -93,6 +93,7 @@ extern int default_builtin_vectorization > > 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); > Index: gcc/targhooks.c > =================================================================== > --- gcc/targhooks.c 2017-09-25 17:04:16.793358890 +0100 > +++ gcc/targhooks.c 2017-10-01 17:14:18.481821912 +0100 > @@ -1165,6 +1165,14 @@ tree default_mangle_decl_assembler_name > 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 > Index: gcc/doc/tm.texi.in > =================================================================== > --- gcc/doc/tm.texi.in 2017-09-25 17:04:16.792359030 +0100 > +++ gcc/doc/tm.texi.in 2017-10-01 17:14:18.480815538 +0100 > @@ -1026,6 +1026,8 @@ On 32-bit ELF the largest supported sect > @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 > Index: gcc/doc/tm.texi > =================================================================== > --- gcc/doc/tm.texi 2017-09-25 17:04:16.791359170 +0100 > +++ gcc/doc/tm.texi 2017-10-01 17:14:18.479809163 +0100 > @@ -1078,6 +1078,13 @@ On 32-bit ELF the largest supported sect > @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 > Index: gcc/varasm.c > =================================================================== > --- gcc/varasm.c 2017-09-25 17:04:16.793358890 +0100 > +++ gcc/varasm.c 2017-10-01 17:14:18.481821912 +0100 > @@ -3784,11 +3784,8 @@ force_const_mem (machine_mode mode, rtx > *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); > @@ -3830,7 +3827,6 @@ force_const_mem (machine_mode mode, rtx > > /* 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 > Index: gcc/config/cris/cris.c > =================================================================== > --- gcc/config/cris/cris.c 2017-09-25 17:04:16.762363228 +0100 > +++ gcc/config/cris/cris.c 2017-10-01 17:14:18.472764540 +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_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 @@ #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_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 re > || (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 re > 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 > Index: gcc/config/i386/i386.c > =================================================================== > --- gcc/config/i386/i386.c 2017-09-25 17:04:16.768362388 +0100 > +++ gcc/config/i386/i386.c 2017-10-01 17:14:18.477796414 +0100 > @@ -31563,6 +31563,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 > @@ -31571,10 +31583,9 @@ ix86_constant_alignment (const_tree exp, > 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) > @@ -53605,6 +53616,8 @@ #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_STATIC_RTX_ALIGNMENT > +#define TARGET_STATIC_RTX_ALIGNMENT ix86_static_rtx_alignment > #undef TARGET_CONSTANT_ALIGNMENT > #define TARGET_CONSTANT_ALIGNMENT ix86_constant_alignment > > Index: gcc/config/mmix/mmix.c > =================================================================== > --- gcc/config/mmix/mmix.c 2017-09-25 17:04:16.774361549 +0100 > +++ gcc/config/mmix/mmix.c 2017-10-01 17:14:18.477796414 +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_static_rtx_alignment (machine_mode); > static HOST_WIDE_INT mmix_constant_alignment (const_tree, HOST_WIDE_INT); > > /* Target structure macros. Listed by node. See `Using and Porting GCC' > @@ -283,6 +284,8 @@ #define TARGET_TRAMPOLINE_INIT mmix_tram > #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 > > @@ -338,6 +341,14 @@ mmix_data_alignment (tree type ATTRIBUTE > 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 > Index: gcc/config/spu/spu.c > =================================================================== > --- gcc/config/spu/spu.c 2017-09-25 17:04:16.787359730 +0100 > +++ gcc/config/spu/spu.c 2017-10-01 17:14:18.478802788 +0100 > @@ -7194,6 +7194,18 @@ spu_truly_noop_truncation (unsigned int > 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 > @@ -7445,6 +7457,8 @@ #define TARGET_CAN_CHANGE_MODE_CLASS spu > #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 >
Index: gcc/varasm.c =================================================================== --- gcc/varasm.c 2017-09-12 14:28:56.402824780 +0100 +++ gcc/varasm.c 2017-09-20 13:33:15.942547232 +0100 @@ -3785,10 +3785,17 @@ force_const_mem (machine_mode mode, rtx desc = ggc_alloc<constant_descriptor_rtx> (); *slot = desc; + tree type = NULL_TREE; + if (mode != VOIDmode + /* Don't ask the frontend about vector modes if there cannot be a + VECTOR_TYPE whose TYPE_MODE is MODE. */ + && (!VECTOR_MODE_P (mode) + || targetm.vector_mode_supported_p (mode))) + type = lang_hooks.types.type_for_mode (mode, 0); + /* 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 = CONSTANT_ALIGNMENT (make_tree (type, x), align); @@ -3832,7 +3839,8 @@ force_const_mem (machine_mode mode, rtx /* Construct the MEM. */ desc->mem = def = gen_const_mem (mode, symbol); - set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1); + if (type) + set_mem_attributes (def, type, 1); set_mem_align (def, align); /* If we're dropping a label to the constant pool, make sure we
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? Richard 2017-09-20 Richard Sandiford <richard.sandiford@linaro.org> Alan Hayward <alan.hayward@arm.com> David Sherwood <david.sherwood@arm.com> gcc/ * varasm.c (force_const_mem): Don't ask the front end about vector modes that are not supported as vector types by the target.