From c6b19c5f7e30d3fe356989902a35bee01b8ea001 Mon Sep 17 00:00:00 2001 From: revitale Date: Tue, 15 Sep 2009 10:39:13 +0000 Subject: [PATCH] New function for checking misalignment git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@151715 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 17 +++++++++++++++++ gcc/config/rs6000/rs6000.c | 38 +++++++++++++++++++++++++++++++++++++- gcc/doc/tm.texi | 8 ++++++++ gcc/target-def.h | 6 +++++- gcc/target.h | 5 +++++ gcc/targhooks.c | 17 +++++++++++++++++ gcc/targhooks.h | 4 ++++ gcc/tree-vect-data-refs.c | 40 ++++++++++++++++++++++++++++++++-------- 8 files changed, 125 insertions(+), 10 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 1b36f26cabd..e64ec0fe967 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,20 @@ +2009-09-15 Revital Eres + + * doc/tm.texi (TARGET_SUPPORT_VECTOR_MISALIGNMENT): Document. + * targhooks.c (default_builtin_support_vector_misalignment): + New builtin function. + * targhooks.h (default_builtin_support_vector_misalignment): + Declare. + * target.h (builtin_support_vector_misalignment): + New field in struct gcc_target. + * tree-vect-data-refs.c (vect_supportable_dr_alignment): Call + new builtin function. + * target-def.h (TARGET_SUPPORT_VECTOR_MISALIGNMENT): + Define. + * config/rs6000/rs6000.c + (rs6000_builtin_support_vector_misalignment): New function. + (TARGET_SUPPORT_VECTOR_MISALIGNMENT): Define. + 2009-09-15 Jie Zhang * config/bfin/bfin.c (length_for_loop): Use NONDEBUG_INSN_P diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index f796c08d3c8..932a7e31d84 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -919,6 +919,10 @@ static tree rs6000_builtin_mul_widen_even (tree); static tree rs6000_builtin_mul_widen_odd (tree); static tree rs6000_builtin_conversion (unsigned int, tree); static tree rs6000_builtin_vec_perm (tree, tree *); +static bool rs6000_builtin_support_vector_misalignment (enum + machine_mode, + const_tree, + int, bool); static void def_builtin (int, const char *, tree, int); static bool rs6000_vector_alignment_reachable (const_tree, bool); @@ -1300,7 +1304,9 @@ static const struct attribute_spec rs6000_attribute_table[] = #define TARGET_VECTORIZE_BUILTIN_CONVERSION rs6000_builtin_conversion #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM #define TARGET_VECTORIZE_BUILTIN_VEC_PERM rs6000_builtin_vec_perm - +#undef TARGET_SUPPORT_VECTOR_MISALIGNMENT +#define TARGET_SUPPORT_VECTOR_MISALIGNMENT \ + rs6000_builtin_support_vector_misalignment #undef TARGET_VECTOR_ALIGNMENT_REACHABLE #define TARGET_VECTOR_ALIGNMENT_REACHABLE rs6000_vector_alignment_reachable @@ -2895,6 +2901,36 @@ rs6000_vector_alignment_reachable (const_tree type ATTRIBUTE_UNUSED, bool is_pac } } +/* Return true if the vector misalignment factor is supported by the + target. */ +bool +rs6000_builtin_support_vector_misalignment (enum machine_mode mode, + const_tree type, + int misalignment, + bool is_packed) +{ + if (TARGET_VSX) + { + /* Return if movmisalign pattern is not supported for this mode. */ + if (optab_handler (movmisalign_optab, mode)->insn_code == + CODE_FOR_nothing) + return false; + + if (misalignment == -1) + { + /* misalignment factor is unknown at compile time but we know + it's word aligned. */ + if (rs6000_vector_alignment_reachable (type, is_packed)) + return true; + return false; + } + /* VSX supports word-aligned vector. */ + if (misalignment % 4 == 0) + return true; + } + return false; +} + /* Implement targetm.vectorize.builtin_vec_perm. */ tree rs6000_builtin_vec_perm (tree type, tree *mask_element_type) diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index f236a7d1c1b..0139a8bfe6f 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -5679,6 +5679,14 @@ 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_SUPPORT_VECTOR_MISALIGNMENT (enum machine_mode @var{mode}, tree @var{type}, int @var{misalignment}, bool @var{is_packed}) +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 +the elements in the vectors should be of type @var{type}. @var{is_packed} +parameter is true if the memory access is defined in a packed struct. +@end deftypefn + @node Anchored Addresses @section Anchored Addresses @cindex anchored addresses diff --git a/gcc/target-def.h b/gcc/target-def.h index 286e1e68cd7..728e018f71d 100644 --- a/gcc/target-def.h +++ b/gcc/target-def.h @@ -388,6 +388,9 @@ #define TARGET_VECTOR_ALIGNMENT_REACHABLE \ default_builtin_vector_alignment_reachable #define TARGET_VECTORIZE_BUILTIN_VEC_PERM 0 +#define TARGET_SUPPORT_VECTOR_MISALIGNMENT \ + default_builtin_support_vector_misalignment + #define TARGET_VECTORIZE \ { \ @@ -398,7 +401,8 @@ TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD, \ TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST, \ TARGET_VECTOR_ALIGNMENT_REACHABLE, \ - TARGET_VECTORIZE_BUILTIN_VEC_PERM \ + TARGET_VECTORIZE_BUILTIN_VEC_PERM, \ + TARGET_SUPPORT_VECTOR_MISALIGNMENT \ } #define TARGET_DEFAULT_TARGET_FLAGS 0 diff --git a/gcc/target.h b/gcc/target.h index 7f7f177904f..c57b683a4fc 100644 --- a/gcc/target.h +++ b/gcc/target.h @@ -481,6 +481,11 @@ struct gcc_target /* Target builtin that implements vector permute. */ tree (* builtin_vec_perm) (tree, tree*); + /* Return true if the target supports misaligned store/load of a + specific factor denoted in the third parameter. The last parameter + is true if the access is defined in a packed struct. */ + bool (* builtin_support_vector_misalignment) (enum machine_mode, + const_tree, int, bool); } vectorize; /* The initial value of target_flags. */ diff --git a/gcc/targhooks.c b/gcc/targhooks.c index 7535bc10ab7..8480c0b833f 100644 --- a/gcc/targhooks.c +++ b/gcc/targhooks.c @@ -771,6 +771,23 @@ default_builtin_vector_alignment_reachable (const_tree type, bool is_packed) return true; } +/* By default, assume that a target supports any factor of misalignment + memory access if it supports movmisalign patten. + is_packed is true if the memory access is defined in a packed struct. */ +bool +default_builtin_support_vector_misalignment (enum machine_mode mode, + const_tree type + ATTRIBUTE_UNUSED, + int misalignment + ATTRIBUTE_UNUSED, + bool is_packed + ATTRIBUTE_UNUSED) +{ + if (optab_handler (movmisalign_optab, mode)->insn_code != CODE_FOR_nothing) + return true; + return false; +} + bool default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED) { diff --git a/gcc/targhooks.h b/gcc/targhooks.h index 4e5f631e76c..7a9355292ae 100644 --- a/gcc/targhooks.h +++ b/gcc/targhooks.h @@ -77,6 +77,10 @@ extern tree default_builtin_vectorized_conversion (unsigned int, tree); extern tree default_builtin_reciprocal (unsigned int, bool, bool); extern bool default_builtin_vector_alignment_reachable (const_tree, bool); +extern bool +default_builtin_support_vector_misalignment (enum machine_mode mode, + const_tree, + int, bool); /* These are here, and not in hooks.[ch], because not all users of hooks.h include tm.h, and thus we don't have CUMULATIVE_ARGS. */ diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index facde06969e..bc18f0272f8 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -3455,6 +3455,9 @@ vect_supportable_dr_alignment (struct data_reference *dr) if (DR_IS_READ (dr)) { + bool is_packed = false; + tree type = (TREE_TYPE (DR_REF (dr))); + if (optab_handler (vec_realign_load_optab, mode)->insn_code != CODE_FOR_nothing && (!targetm.vectorize.builtin_mask_for_load @@ -3468,18 +3471,39 @@ vect_supportable_dr_alignment (struct data_reference *dr) else return dr_explicit_realign_optimized; } - - if (optab_handler (movmisalign_optab, mode)->insn_code != - CODE_FOR_nothing) + if (!known_alignment_for_access_p (dr)) + { + tree ba = DR_BASE_OBJECT (dr); + + if (ba) + is_packed = contains_packed_reference (ba); + } + + if (targetm.vectorize. + builtin_support_vector_misalignment (mode, type, + DR_MISALIGNMENT (dr), is_packed)) /* Can't software pipeline the loads, but can at least do them. */ return dr_unaligned_supported; } - else - { - if (movmisalign_optab->handlers[mode].insn_code != CODE_FOR_nothing) - return dr_unaligned_supported; - } + else + { + bool is_packed = false; + tree type = (TREE_TYPE (DR_REF (dr))); + if (!known_alignment_for_access_p (dr)) + { + tree ba = DR_BASE_OBJECT (dr); + + if (ba) + is_packed = contains_packed_reference (ba); + } + + if (targetm.vectorize. + builtin_support_vector_misalignment (mode, type, + DR_MISALIGNMENT (dr), is_packed)) + return dr_unaligned_supported; + } + /* Unsupported. */ return dr_unaligned_unsupported; } -- 2.11.0