expr.c (expand_assignment): Handle misaligned DECLs.

2019-09-28  Bernd Edlinger  <bernd.edlinger@hotmail.de>
	    Richard Biener  <rguenther@suse.de>

	* expr.c (expand_assignment): Handle misaligned DECLs.
	(expand_expr_real_1): Handle FUNCTION_DECL as unaligned.
	* function.c (assign_parm_adjust_stack_rtl): Check movmisalign optab
	too.
	(assign_parm_setup_stack): Allocate properly aligned stack slots.
	* varasm.c (build_constant_desc): Align constants of misaligned types.
	* config/arm/predicates.md (aligned_operand): New predicate.
	* config/arm/arm.md (movdi, movsi, movhi, movhf, movsf, movdf): Use
	aligned_operand to check restrictions on memory addresses.
	* config/arm/neon.md (movti, mov<VSTRUCT>, mov<VH>): Likewise.
	* config/arm/vec-common.md (mov<VALL>): Likewise.

Co-Authored-By: Richard Biener <rguenther@suse.de>
From-SVN: r274986

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 1ee26fcf8bf2e81cfb40093e566dbca8c272df72..b9b9da98491e1c148e140b1053a2adf91417a448 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,18 @@
+2019-09-28  Bernd Edlinger  <bernd.edlinger@hotmail.de>
+           Richard Biener  <rguenther@suse.de>
+
+       * expr.c (expand_assignment): Handle misaligned DECLs.
+       (expand_expr_real_1): Handle FUNCTION_DECL as unaligned.
+       * function.c (assign_parm_adjust_stack_rtl): Check movmisalign optab
+       too.
+       (assign_parm_setup_stack): Allocate properly aligned stack slots.
+       * varasm.c (build_constant_desc): Align constants of misaligned types.
+       * config/arm/predicates.md (aligned_operand): New predicate.
+       * config/arm/arm.md (movdi, movsi, movhi, movhf, movsf, movdf): Use
+       aligned_operand to check restrictions on memory addresses.
+       * config/arm/neon.md (movti, mov<VSTRUCT>, mov<VH>): Likewise.
+       * config/arm/vec-common.md (mov<VALL>): Likewise.
+
 2019-08-28  Jakub Jelinek  <jakub@redhat.com>
 
        PR libgomp/91530

diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md
index f138d31f01293162fe0713b6bead45d1b7ab0e67..0be7a018eedeea048523f622f99bdd765b8d86ec 100644 (file)
--- a/gcc/config/arm/arm.md
+++ b/gcc/config/arm/arm.md
@@ -5231,6 +5231,8 @@
        (match_operand:DI 1 "general_operand"))]
   "TARGET_EITHER"
   "
+  gcc_checking_assert (aligned_operand (operands[0], DImode));
+  gcc_checking_assert (aligned_operand (operands[1], DImode));
   if (can_create_pseudo_p ())
     {
       if (!REG_P (operands[0]))
@@ -5407,6 +5409,8 @@
   {
   rtx base, offset, tmp;
 
+  gcc_checking_assert (aligned_operand (operands[0], SImode));
+  gcc_checking_assert (aligned_operand (operands[1], SImode));
   if (TARGET_32BIT || TARGET_HAVE_MOVT)
     {
       /* Everything except mem = const or mem = mem can be done easily.  */
@@ -5896,6 +5900,8 @@
        (match_operand:HI 1 "general_operand"))]
   "TARGET_EITHER"
   "
+  gcc_checking_assert (aligned_operand (operands[0], HImode));
+  gcc_checking_assert (aligned_operand (operands[1], HImode));
   if (TARGET_ARM)
     {
       if (can_create_pseudo_p ())
@@ -6305,6 +6311,8 @@
        (match_operand:HF 1 "general_operand"))]
   "TARGET_EITHER"
   "
+  gcc_checking_assert (aligned_operand (operands[0], HFmode));
+  gcc_checking_assert (aligned_operand (operands[1], HFmode));
   if (TARGET_32BIT)
     {
       if (MEM_P (operands[0]))
@@ -6369,6 +6377,8 @@
        (match_operand:SF 1 "general_operand"))]
   "TARGET_EITHER"
   "
+  gcc_checking_assert (aligned_operand (operands[0], SFmode));
+  gcc_checking_assert (aligned_operand (operands[1], SFmode));
   if (TARGET_32BIT)
     {
       if (MEM_P (operands[0]))
@@ -6464,6 +6474,8 @@
        (match_operand:DF 1 "general_operand"))]
   "TARGET_EITHER"
   "
+  gcc_checking_assert (aligned_operand (operands[0], DFmode));
+  gcc_checking_assert (aligned_operand (operands[1], DFmode));
   if (TARGET_32BIT)
     {
       if (MEM_P (operands[0]))

diff --git a/gcc/config/arm/neon.md b/gcc/config/arm/neon.md
index 0c1ee746b6ada4f83040cd1717f17bef03dc2264..a5aa8d68e62159396f879d54128a364a2261e937 100644 (file)
--- a/gcc/config/arm/neon.md
+++ b/gcc/config/arm/neon.md
@@ -127,6 +127,8 @@
        (match_operand:TI 1 "general_operand"))]
   "TARGET_NEON"
 {
+  gcc_checking_assert (aligned_operand (operands[0], TImode));
+  gcc_checking_assert (aligned_operand (operands[1], TImode));
   if (can_create_pseudo_p ())
     {
       if (!REG_P (operands[0]))
@@ -139,6 +141,8 @@
        (match_operand:VSTRUCT 1 "general_operand"))]
   "TARGET_NEON"
 {
+  gcc_checking_assert (aligned_operand (operands[0], <MODE>mode));
+  gcc_checking_assert (aligned_operand (operands[1], <MODE>mode));
   if (can_create_pseudo_p ())
     {
       if (!REG_P (operands[0]))
@@ -151,6 +155,8 @@
        (match_operand:VH 1 "s_register_operand"))]
   "TARGET_NEON"
 {
+  gcc_checking_assert (aligned_operand (operands[0], <MODE>mode));
+  gcc_checking_assert (aligned_operand (operands[1], <MODE>mode));
   if (can_create_pseudo_p ())
     {
       if (!REG_P (operands[0]))

diff --git a/gcc/config/arm/predicates.md b/gcc/config/arm/predicates.md
index 59dc2e89534a8b85df1197bd7211af43c56fb18c..983faac8a72ef75e80cc34031c07c6435902c36f 100644 (file)
--- a/gcc/config/arm/predicates.md
+++ b/gcc/config/arm/predicates.md
@@ -697,3 +697,7 @@
   (ior (and (match_code "symbol_ref")
            (match_test "!arm_is_long_call_p (SYMBOL_REF_DECL (op))"))
        (match_operand 0 "s_register_operand")))
+
+(define_special_predicate "aligned_operand"
+  (ior (not (match_code "mem"))
+       (match_test "MEM_ALIGN (op) >= GET_MODE_ALIGNMENT (mode)")))

diff --git a/gcc/config/arm/vec-common.md b/gcc/config/arm/vec-common.md
index 99a430e32e6c6efa681c8c57b6c9934bc0ce78df..33ff5627284d7cc898074b562179938982ecc420 100644 (file)
--- a/gcc/config/arm/vec-common.md
+++ b/gcc/config/arm/vec-common.md
@@ -26,6 +26,8 @@
   "TARGET_NEON
    || (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (<MODE>mode))"
 {
+  gcc_checking_assert (aligned_operand (operands[0], <MODE>mode));
+  gcc_checking_assert (aligned_operand (operands[1], <MODE>mode));
   if (can_create_pseudo_p ())
     {
       if (!REG_P (operands[0]))

diff --git a/gcc/expr.c b/gcc/expr.c
index 5ca0e20f14ae174b0bf112673f3e653b77c961c9..022b571fb79a905d4992d23b9a107c0f47c4c806 100644 (file)
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -5001,9 +5001,10 @@ expand_assignment (tree to, tree from, bool nontemporal)
   /* Handle misaligned stores.  */
   mode = TYPE_MODE (TREE_TYPE (to));
   if ((TREE_CODE (to) == MEM_REF
-       || TREE_CODE (to) == TARGET_MEM_REF)
+       || TREE_CODE (to) == TARGET_MEM_REF
+       || DECL_P (to))
       && mode != BLKmode
-      && !mem_ref_refers_to_non_mem_p (to)
+      && (DECL_P (to) || !mem_ref_refers_to_non_mem_p (to))
       && ((align = get_object_alignment (to))
          < GET_MODE_ALIGNMENT (mode))
       && (((icode = optab_handler (movmisalign_optab, mode))
@@ -10795,6 +10796,14 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
            MEM_VOLATILE_P (op0) = 1;
          }
 
+       if (MEM_P (op0) && TREE_CODE (tem) == FUNCTION_DECL)
+         {
+           if (op0 == orig_op0)
+             op0 = copy_rtx (op0);
+
+           set_mem_align (op0, BITS_PER_UNIT);
+         }
+
        /* In cases where an aligned union has an unaligned object
           as a field, we might be extracting a BLKmode value from
           an integer-mode (e.g., SImode) object.  Handle this case

diff --git a/gcc/function.c b/gcc/function.c
index 05241a36161b7d45760e4f9e9d822905f2b5e3f2..751d2de3bfd8ed81b6a1679338e5fe670c37d577 100644 (file)
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -2807,8 +2807,10 @@ assign_parm_adjust_stack_rtl (struct assign_parm_data_one *data)
      stack slot, if we need one.  */
   if (stack_parm
       && ((GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm)
-          && targetm.slow_unaligned_access (data->nominal_mode,
-                                            MEM_ALIGN (stack_parm)))
+          && ((optab_handler (movmisalign_optab, data->nominal_mode)
+               != CODE_FOR_nothing)
+              || 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)))
@@ -3461,11 +3463,20 @@ assign_parm_setup_stack (struct assign_parm_data_all *all, tree parm,
          int align = STACK_SLOT_ALIGNMENT (data->arg.type,
                                            GET_MODE (data->entry_parm),
                                            TYPE_ALIGN (data->arg.type));
+         if (align < (int)GET_MODE_ALIGNMENT (GET_MODE (data->entry_parm))
+             && ((optab_handler (movmisalign_optab,
+                                 GET_MODE (data->entry_parm))
+                  != CODE_FOR_nothing)
+                 || targetm.slow_unaligned_access (GET_MODE (data->entry_parm),
+                                                   align)))
+           align = GET_MODE_ALIGNMENT (GET_MODE (data->entry_parm));
          data->stack_parm
            = assign_stack_local (GET_MODE (data->entry_parm),
                                  GET_MODE_SIZE (GET_MODE (data->entry_parm)),
                                  align);
+         align = MEM_ALIGN (data->stack_parm);
          set_mem_attributes (data->stack_parm, parm, 1);
+         set_mem_align (data->stack_parm, align);
        }
 
       dest = validize_mem (copy_rtx (data->stack_parm));

diff --git a/gcc/varasm.c b/gcc/varasm.c
index ae25f4d9c1672e6e9f215e693290d139b0ab634d..a7c22523f9faf12c96b917b37b34777ca750cb02 100644 (file)
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -47,6 +47,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "stmt.h"
 #include "expr.h"
 #include "expmed.h"
+#include "optabs.h"
 #include "output.h"
 #include "langhooks.h"
 #include "debug.h"
@@ -3386,7 +3387,15 @@ build_constant_desc (tree exp)
   if (TREE_CODE (exp) == STRING_CST)
     SET_DECL_ALIGN (decl, targetm.constant_alignment (exp, DECL_ALIGN (decl)));
   else
-    align_variable (decl, 0);
+    {
+      align_variable (decl, 0);
+      if (DECL_ALIGN (decl) < GET_MODE_ALIGNMENT (DECL_MODE (decl))
+         && ((optab_handler (movmisalign_optab, DECL_MODE (decl))
+              != CODE_FOR_nothing)
+             || targetm.slow_unaligned_access (DECL_MODE (decl),
+                                               DECL_ALIGN (decl))))
+       SET_DECL_ALIGN (decl, GET_MODE_ALIGNMENT (DECL_MODE (decl)));
+    }
 
   /* Now construct the SYMBOL_REF and the MEM.  */
   if (use_object_blocks_p ())