vect: Remove type from misalignment hook.

This patch removes the type argument from the vector_misalignment hook.
Ever since we switched from element to byte misalignment its
semantics haven't been particularly clear and nowadays it should be
redundant.

Also, in case of gather/scatter, the patch sets misalignment to the
misalignment of one unit of the vector mode so targets can
distinguish between element size alignment and element mode alignment.

is_packed is now always set, regardless of misalignment.

gcc/ChangeLog:

	* config/aarch64/aarch64.cc (aarch64_builtin_support_vector_misalignment):
	Remove type.
	* config/arm/arm.cc (arm_builtin_support_vector_misalignment):
	Ditto.
	* config/epiphany/epiphany.cc (epiphany_support_vector_misalignment):
	Ditto.
	* config/gcn/gcn.cc (gcn_vectorize_support_vector_misalignment):
	Ditto.
	* config/loongarch/loongarch.cc (loongarch_builtin_support_vector_misalignment):
	Ditto.
	* config/riscv/riscv.cc (riscv_support_vector_misalignment):
	Ditto.
	* config/rs6000/rs6000.cc (rs6000_builtin_support_vector_misalignment):
	Ditto.
	* config/s390/s390.cc (s390_support_vector_misalignment):
	Ditto.
	* doc/tm.texi: Adjust vector misalignment docs.
	* target.def: Ditto.
	* targhooks.cc (default_builtin_support_vector_misalignment):
	Remove type.
	* targhooks.h (default_builtin_support_vector_misalignment):
	Ditto.
	* tree-vect-data-refs.cc (vect_can_force_dr_alignment_p):
	Set misalignment for gather/scatter and remove type.
	(vect_supportable_dr_alignment): Ditto.

gcc/config/aarch64/aarch64.cc

@@ -355,7 +355,6 @@ static void aarch64_override_options_after_change (void);
 static bool aarch64_vector_mode_supported_p (machine_mode);
 static int aarch64_address_cost (rtx, machine_mode, addr_space_t, bool);
 static bool aarch64_builtin_support_vector_misalignment (machine_mode mode,
-							 const_tree type,
 							 int misalignment,
 							 bool is_packed,
 							 bool is_gather_scatter);
@@ -24564,7 +24563,7 @@ aarch64_simd_vector_alignment_reachable (const_tree type, bool is_packed)
    target.  */
 static bool
 aarch64_builtin_support_vector_misalignment (machine_mode mode,
-					     const_tree type, int misalignment,
+					     int misalignment,
 					     bool is_packed,
 					     bool is_gather_scatter)
 {
@@ -24581,7 +24580,7 @@ aarch64_builtin_support_vector_misalignment (machine_mode mode,
       if (misalignment == -1)
 	return false;
     }
-  return default_builtin_support_vector_misalignment (mode, type, misalignment,
+  return default_builtin_support_vector_misalignment (mode, misalignment,
 						      is_packed,
 						      is_gather_scatter);
 }

gcc/config/arm/arm.cc

@@ -287,7 +287,6 @@ static bool arm_class_likely_spilled_p (reg_class_t);
 static HOST_WIDE_INT arm_vector_alignment (const_tree type);
 static bool arm_vector_alignment_reachable (const_tree type, bool is_packed);
 static bool arm_builtin_support_vector_misalignment (machine_mode mode,
-						     const_tree type,
 						     int misalignment,
 						     bool is_packed,
 						     bool is_gather_scatter);
@@ -30662,7 +30661,7 @@ arm_vector_alignment_reachable (const_tree type, bool is_packed)
 
 static bool
 arm_builtin_support_vector_misalignment (machine_mode mode,
-					 const_tree type, int misalignment,
+					 int misalignment,
 					 bool is_packed,
 					 bool is_gather_scatter)
 {
@@ -30688,7 +30687,7 @@ arm_builtin_support_vector_misalignment (machine_mode mode,
       return ((misalignment % align) == 0);
     }
 
-  return default_builtin_support_vector_misalignment (mode, type, misalignment,
+  return default_builtin_support_vector_misalignment (mode, misalignment,
 						      is_packed,
 						      is_gather_scatter);
 }

gcc/config/epiphany/epiphany.cc

@@ -2815,15 +2815,15 @@ epiphany_vector_alignment_reachable (const_tree type, bool is_packed)
 }
 
 static bool
-epiphany_support_vector_misalignment (machine_mode mode, const_tree type,
+epiphany_support_vector_misalignment (machine_mode mode, int misalignment,
-				      int misalignment, bool is_packed,
+				      bool is_packed,
 				      bool is_gather_scatter)
 {
   if (is_gather_scatter)
     return true;
   if (GET_MODE_SIZE (mode) == 8 && misalignment % 4 == 0)
     return true;
-  return default_builtin_support_vector_misalignment (mode, type, misalignment,
+  return default_builtin_support_vector_misalignment (mode, misalignment,
 						      is_packed,
 						      is_gather_scatter);
 }

gcc/config/gcn/gcn.cc

@@ -5368,14 +5368,13 @@ gcn_preferred_vector_alignment (const_tree type)
 
 static bool
 gcn_vectorize_support_vector_misalignment (machine_mode ARG_UNUSED (mode),
-					   const_tree ARG_UNUSED (type),
 					   int ARG_UNUSED (misalignment),
 					   bool is_packed,
 					   bool ARG_UNUSED (is_gather_scatter))
 {
   /* All Flat and Global load instructions support arbitrary alignment, so
      the types and such are irrelevant (Buffer instructions are not used).  */
- 
+
   /* Disallow packed accesses because expand attempts to take scalar subregs of
      vector registers, which is nonsense.
      Testcase: gfortran.dg/recursive_alloc_comp_4.f08   */

gcc/config/loongarch/loongarch.cc

@@ -11058,7 +11058,6 @@ void loongarch_emit_swdivsf (rtx res, rtx a, rtx b, machine_mode mode)
 
 static bool
 loongarch_builtin_support_vector_misalignment (machine_mode mode,
-					       const_tree type,
 					       int misalignment,
 					       bool is_packed,
 					       bool is_gather_scatter)
@@ -11072,7 +11071,7 @@ loongarch_builtin_support_vector_misalignment (machine_mode mode,
       if (misalignment == -1)
 	return false;
     }
-  return default_builtin_support_vector_misalignment (mode, type, misalignment,
+  return default_builtin_support_vector_misalignment (mode, misalignment,
 						      is_packed,
 						      is_gather_scatter);
 }

gcc/config/riscv/riscv.cc

@@ -12659,12 +12659,11 @@ riscv_estimated_poly_value (poly_int64 val,
 /* Return true if the vector misalignment factor is supported by the
    target.  */
 bool
-riscv_support_vector_misalignment (machine_mode mode, const_tree type,
+riscv_support_vector_misalignment (machine_mode mode, int misalignment,
-				   int misalignment, bool is_packed,
+				   bool is_packed, bool is_gather_scatter)
-				   bool is_gather_scatter)
 {
   /* IS_PACKED is true if the corresponding scalar element is not naturally
-     aligned.  If the misalignment is unknown and the the access is packed
+     aligned.  If the misalignment is unknown and the access is packed
      we defer to the default hook which will check if movmisalign is present.
      Movmisalign, in turn, depends on TARGET_VECTOR_MISALIGN_SUPPORTED.  */
   if (misalignment == DR_MISALIGNMENT_UNKNOWN)
@@ -12676,12 +12675,12 @@ riscv_support_vector_misalignment (machine_mode mode, const_tree type,
     {
       /* If we know that misalignment is a multiple of the element size, we're
 	 good.  */
-      if (misalignment % TYPE_ALIGN_UNIT (type) == 0)
+      if (misalignment % (GET_MODE_UNIT_SIZE (mode)) == 0)
 	return true;
     }
 
   /* Otherwise fall back to movmisalign again.  */
-  return default_builtin_support_vector_misalignment (mode, type, misalignment,
+  return default_builtin_support_vector_misalignment (mode, misalignment,
 						      is_packed,
 						      is_gather_scatter);
 }

gcc/config/rs6000/rs6000.cc

@@ -4947,7 +4947,6 @@ rs6000_vector_alignment_reachable (const_tree type ATTRIBUTE_UNUSED, bool is_pac
    target.  */
 static bool
 rs6000_builtin_support_vector_misalignment (machine_mode mode,
-					    const_tree type,
 					    int misalignment,
 					    bool is_packed,
 					    bool is_gather_scatter)
@@ -4973,13 +4972,13 @@ rs6000_builtin_support_vector_misalignment (machine_mode mode,
 	{
 	  /* Misalignment factor is unknown at compile time but we know
 	     it's word aligned.  */
-	  if (rs6000_vector_alignment_reachable (type, is_packed))
+	  if (rs6000_vector_alignment_reachable (NULL_TREE, is_packed))
-            {
+	    {
-              int element_size = TREE_INT_CST_LOW (TYPE_SIZE (type));
+	      int element_size = GET_MODE_UNIT_BITSIZE (mode);
 
-              if (element_size == 64 || element_size == 32)
+	      if (element_size == 64 || element_size == 32)
-               return true;
+		return true;
-            }
+	    }
 
 	  return false;
 	}

gcc/config/s390/s390.cc

@@ -17503,7 +17503,6 @@ s390_preferred_simd_mode (scalar_mode mode)
 /* Our hardware does not require vectors to be strictly aligned.  */
 static bool
 s390_support_vector_misalignment (machine_mode mode ATTRIBUTE_UNUSED,
-				  const_tree type ATTRIBUTE_UNUSED,
 				  int misalignment ATTRIBUTE_UNUSED,
 				  bool is_packed ATTRIBUTE_UNUSED,
 				  bool is_gather_scatter ATTRIBUTE_UNUSED)
@@ -17511,7 +17510,7 @@ s390_support_vector_misalignment (machine_mode mode ATTRIBUTE_UNUSED,
   if (TARGET_VX)
     return true;
 
-  return default_builtin_support_vector_misalignment (mode, type, misalignment,
+  return default_builtin_support_vector_misalignment (mode, misalignment,
 						      is_packed,
 						      is_gather_scatter);
 }

gcc/doc/tm.texi

@@ -6397,14 +6397,14 @@ return type of the vectorized function shall be of vector type
 @var{vec_type_out} and the argument types should be @var{vec_type_in}.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT (machine_mode @var{mode}, const_tree @var{type}, int @var{misalignment}, bool @var{is_packed}, bool @var{is_gather_scatter})
+@deftypefn {Target Hook} bool TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT (machine_mode @var{mode}, int @var{misalignment}, bool @var{is_packed}, bool @var{is_gather_scatter})
 This hook should return true if the target supports misaligned vector
 store/load of a specific factor denoted in the @var{misalignment}
-parameter.  The vector store/load should be of machine mode @var{mode} and
+parameter.  The vector store/load should be of machine mode @var{mode}.
-the elements in the vectors should be of type @var{type}.  The
+The @var{is_packed} parameter is true if the original memory access is
-@var{is_packed} parameter is true if the misalignment is unknown and the
+not naturally aligned.  @var{is_gather_scatter} is true if the
-memory access is defined in a packed struct.  @var{is_gather_scatter} is true
+load/store is a gather or scatter.  In that case misalignment
-if the load/store is a gather or scatter.
+denotes the misalignment of @var{mode}'s element mode.
 @end deftypefn
 
 @deftypefn {Target Hook} machine_mode TARGET_VECTORIZE_PREFERRED_SIMD_MODE (scalar_mode @var{mode})

gcc/target.def

@@ -1925,13 +1925,13 @@ DEFHOOK
 (support_vector_misalignment,
  "This hook should return true if the target supports misaligned vector\n\
 store/load of a specific factor denoted in the @var{misalignment}\n\
-parameter.  The vector store/load should be of machine mode @var{mode} and\n\
+parameter.  The vector store/load should be of machine mode @var{mode}.\n\
-the elements in the vectors should be of type @var{type}.  The\n\
+The @var{is_packed} parameter is true if the original memory access is\n\
-@var{is_packed} parameter is true if the misalignment is unknown and the\n\
+not naturally aligned.  @var{is_gather_scatter} is true if the\n\
-memory access is defined in a packed struct.  @var{is_gather_scatter} is true\n\
+load/store is a gather or scatter.  In that case misalignment\n\
-if the load/store is a gather or scatter.",
+denotes the misalignment of @var{mode}'s element mode.",
  bool,
- (machine_mode mode, const_tree type, int misalignment, bool is_packed,
+ (machine_mode mode, int misalignment, bool is_packed,
   bool is_gather_scatter),
  default_builtin_support_vector_misalignment)
 

gcc/targhooks.cc

@@ -1551,8 +1551,6 @@ default_builtin_vector_alignment_reachable (const_tree /*type*/, bool is_packed)
    is_packed is true if the memory access is defined in a packed struct.  */
 bool
 default_builtin_support_vector_misalignment (machine_mode mode,
-					     const_tree type
-					     ATTRIBUTE_UNUSED,
 					     int misalignment
 					     ATTRIBUTE_UNUSED,
 					     bool is_packed

gcc/targhooks.h

@@ -113,7 +113,6 @@ extern poly_uint64 default_preferred_vector_alignment (const_tree);
 extern bool default_builtin_vector_alignment_reachable (const_tree, bool);
 extern bool
 default_builtin_support_vector_misalignment (machine_mode mode,
-					     const_tree,
 					     int, bool, bool);
 extern machine_mode default_preferred_simd_mode (scalar_mode mode);
 extern machine_mode default_split_reduction (machine_mode);

gcc/tree-vect-data-refs.cc

@@ -6522,7 +6522,8 @@ vect_can_force_dr_alignment_p (const_tree decl, poly_uint64 alignment)
    alignment.
    If CHECK_ALIGNED_ACCESSES is TRUE, check if the access is supported even
    it is aligned, i.e., check if it is possible to vectorize it with different
-   alignment.  If GS_INFO is passed we are dealing with a gather/scatter.  */
+   alignment.  If IS_GATHER_SCATTER is true we are dealing with a
+   gather/scatter.  */
 
 enum dr_alignment_support
 vect_supportable_dr_alignment (vec_info *vinfo, dr_vec_info *dr_info,
@@ -6636,11 +6637,13 @@ vect_supportable_dr_alignment (vec_info *vinfo, dr_vec_info *dr_info,
 	}
     }
 
-  bool is_packed = false;
+  bool is_packed = not_size_aligned (DR_REF (dr));
-  tree type = TREE_TYPE (DR_REF (dr));
+  if (misalignment == DR_MISALIGNMENT_UNKNOWN
-  if (misalignment == DR_MISALIGNMENT_UNKNOWN)
+      && is_gather_scatter)
-    is_packed = not_size_aligned (DR_REF (dr));
+    misalignment = (get_object_alignment (DR_REF (dr))
-  if (targetm.vectorize.support_vector_misalignment (mode, type, misalignment,
+		    % (GET_MODE_BITSIZE (GET_MODE_INNER (mode))))
+      / BITS_PER_UNIT;
+  if (targetm.vectorize.support_vector_misalignment (mode, misalignment,
 						     is_packed,
 						     is_gather_scatter))
     return dr_unaligned_supported;