On 7/31/19 3:16 PM, Richard Earnshaw (lists) wrote:
>
>
> On 30/07/2019 21:51, Bernd Edlinger wrote:
>> +/* { dg-options "-marm -march=armv6 -mno-unaligned-access -mfloat-abi=soft
>> -mabi=aapcs -O3" } */
>
> This isn't going to work as-is, we test many combinations of the compiler,
> either with explicit dejagnu settings or with the compiler defaults and the
> dejagnu settings can't generally be overridden this way.
>
> For -marm you require an effective-target of arm_arm_ok. For ldrd, it should
> be enough to just require an effective-target of arm_ldrd_strd_ok, then you
> can .
>
> I don't think we really care about any ABIs other than aapcs, so I'd just
> leave that off. And as for setting the float-abi, I don't see anything in
> the tests that would require that, so that can probably be omitted as well.
>
> I think with all this, you can then write something like
>
> /* { dg-require-effective-target arm_arm_ok && arm_ldrd_strd_ok } */
> /* { dg-options "-marm -mno-unaligned-access -O3 } */
>
> But I haven't tested that, so you might need to fiddle with it a bit,
> especially the effective-target rule.
>
Okay, it seems we need two dg-require-effective-target rules for this to work,
as in the attached new version of the patch which I am currently boot-strapping.
Is it OK for trunk after successful boot-strap and reg-testing?
Thanks
Bernd.
2019-07-30 Bernd Edlinger <bernd.edlin...@hotmail.de>
PR middle-end/89544
* function.c (assign_param_data_one): Remove unused data members.
(assign_parm_find_stack_rtl): Use larger alignment when possible.
(assign_parm_adjust_stack_rtl): Revise STRICT_ALIGNMENT check.
(assign_parm_setup_reg): Handle misaligned stack arguments.
testsuite:
2019-07-30 Bernd Edlinger <bernd.edlin...@hotmail.de>
PR middle-end/89544
* gcc.target/arm/unaligned-argument-1.c: New test.
* gcc.target/arm/unaligned-argument-2.c: New test.
Index: gcc/function.c
===================================================================
--- gcc/function.c (revision 273767)
+++ gcc/function.c (working copy)
@@ -2274,8 +2274,6 @@ struct assign_parm_data_one
int partial;
BOOL_BITFIELD named_arg : 1;
BOOL_BITFIELD passed_pointer : 1;
- BOOL_BITFIELD on_stack : 1;
- BOOL_BITFIELD loaded_in_reg : 1;
};
/* A subroutine of assign_parms. Initialize ALL. */
@@ -2699,8 +2697,23 @@ assign_parm_find_stack_rtl (tree parm, struct assi
intentionally forcing upward padding. Otherwise we have to come
up with a guess at the alignment based on OFFSET_RTX. */
poly_int64 offset;
- if (data->locate.where_pad != PAD_DOWNWARD || data->entry_parm)
+ if (data->locate.where_pad == PAD_NONE || data->entry_parm)
align = boundary;
+ else if (data->locate.where_pad == PAD_UPWARD)
+ {
+ align = boundary;
+ /* If the argument offset is actually more aligned than the nominal
+ stack slot boundary, take advantage of that excess alignment.
+ Don't make any assumptions if STACK_POINTER_OFFSET is in use. */
+ if (poly_int_rtx_p (offset_rtx, &offset)
+ && STACK_POINTER_OFFSET == 0)
+ {
+ unsigned int offset_align = known_alignment (offset) * BITS_PER_UNIT;
+ if (offset_align == 0 || offset_align > STACK_BOUNDARY)
+ offset_align = STACK_BOUNDARY;
+ align = MAX (align, offset_align);
+ }
+ }
else if (poly_int_rtx_p (offset_rtx, &offset))
{
align = least_bit_hwi (boundary);
@@ -2813,8 +2826,9 @@ assign_parm_adjust_stack_rtl (struct assign_parm_d
ultimate type, don't use that slot after entry. We'll make another
stack slot, if we need one. */
if (stack_parm
- && ((STRICT_ALIGNMENT
- && GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm))
+ && ((GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm)
+ && targetm.slow_unaligned_access (data->nominal_mode,
+ MEM_ALIGN (stack_parm)))
|| (data->nominal_type
&& TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm)
&& MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY)))
@@ -3292,6 +3306,23 @@ assign_parm_setup_reg (struct assign_parm_data_all
did_conversion = true;
}
+ else if (MEM_P (data->entry_parm)
+ && GET_MODE_ALIGNMENT (promoted_nominal_mode)
+ > MEM_ALIGN (data->entry_parm)
+ && targetm.slow_unaligned_access (promoted_nominal_mode,
+ MEM_ALIGN (data->entry_parm)))
+ {
+ enum insn_code icode = optab_handler (movmisalign_optab,
+ promoted_nominal_mode);
+
+ if (icode != CODE_FOR_nothing)
+ emit_insn (GEN_FCN (icode) (parmreg, validated_mem));
+ else
+ rtl = parmreg = extract_bit_field (validated_mem,
+ GET_MODE_BITSIZE (promoted_nominal_mode), 0,
+ unsignedp, parmreg,
+ promoted_nominal_mode, VOIDmode, false, NULL);
+ }
else
emit_move_insn (parmreg, validated_mem);
Index: gcc/testsuite/gcc.target/arm/unaligned-argument-1.c
===================================================================
--- gcc/testsuite/gcc.target/arm/unaligned-argument-1.c (revision 0)
+++ gcc/testsuite/gcc.target/arm/unaligned-argument-1.c (working copy)
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_arm_ok } */
+/* { dg-require-effective-target arm_ldrd_strd_ok } */
+/* { dg-options "-marm -mno-unaligned-access -O3" } */
+
+struct s {
+ int a, b;
+} __attribute__((aligned(8)));
+
+struct s f0;
+
+void f(int a, int b, int c, int d, struct s f)
+{
+ f0 = f;
+}
+
+/* { dg-final { scan-assembler-times "ldrd" 1 } } */
+/* { dg-final { scan-assembler-times "strd" 1 } } */
+/* { dg-final { scan-assembler-times "stm" 0 } } */
Index: gcc/testsuite/gcc.target/arm/unaligned-argument-2.c
===================================================================
--- gcc/testsuite/gcc.target/arm/unaligned-argument-2.c (revision 0)
+++ gcc/testsuite/gcc.target/arm/unaligned-argument-2.c (working copy)
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_arm_ok } */
+/* { dg-require-effective-target arm_ldrd_strd_ok } */
+/* { dg-options "-marm -mno-unaligned-access -O3" } */
+
+struct s {
+ int a, b;
+} __attribute__((aligned(8)));
+
+struct s f0;
+
+void f(int a, int b, int c, int d, int e, struct s f)
+{
+ f0 = f;
+}
+
+/* { dg-final { scan-assembler-times "ldrd" 0 } } */
+/* { dg-final { scan-assembler-times "strd" 0 } } */
+/* { dg-final { scan-assembler-times "stm" 1 } } */
