From: Richard Biener Date: Wed, 25 Jan 2017 12:30:41 +0000 (+0000) Subject: re PR target/69264 (ICE building spidermonkey -mcpu=970 -maltivec -O3: rs6000_builtin... X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=c287389223fd552ef5b5d126f0b38d3a61337477;p=gcc.git re PR target/69264 (ICE building spidermonkey -mcpu=970 -maltivec -O3: rs6000_builtin_vectorization_cost, at config/rs6000/rs6000.c:4350) 2017-01-25 Richard Biener PR tree-optimization/69264 * target.def (vector_alignment_reachable): Improve documentation. * doc/tm.texi: Regenerate. * targhooks.c (default_builtin_vector_alignment_reachable): Simplify and add a comment. * tree-vect-data-refs.c (vect_supportable_dr_alignment): Revert earlier changes with respect to TYPE_USER_ALIGN. (vector_alignment_reachable_p): Likewise. Improve dumping. * g++.dg/torture/pr69264.C: New testcase. From-SVN: r244897 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 6bd1c69982f..7e0b4c66650 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,14 @@ +2017-01-25 Richard Biener + + PR tree-optimization/69264 + * target.def (vector_alignment_reachable): Improve documentation. + * doc/tm.texi: Regenerate. + * targhooks.c (default_builtin_vector_alignment_reachable): Simplify + and add a comment. + * tree-vect-data-refs.c (vect_supportable_dr_alignment): Revert + earlier changes with respect to TYPE_USER_ALIGN. + (vector_alignment_reachable_p): Likewise. Improve dumping. + 2016-01-25 Kyrylo Tkachov PR target/79145 diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 4b62e05f4c4..909589c373b 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -5745,7 +5745,7 @@ misalignment value (@var{misalign}). @end deftypefn @deftypefn {Target Hook} bool TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE (const_tree @var{type}, bool @var{is_packed}) -Return true if vector alignment is reachable (by peeling N iterations) for the given type. +Return true if vector alignment is reachable (by peeling N iterations) for the given scalar type @var{type}. @var{is_packed} is false if the scalar access using @var{type} is known to be naturally aligned. @end deftypefn @deftypefn {Target Hook} bool TARGET_VECTORIZE_VEC_PERM_CONST_OK (machine_mode, const unsigned char *@var{sel}) diff --git a/gcc/target.def b/gcc/target.def index 04433901903..7308da16cdb 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -1801,10 +1801,10 @@ misalignment value (@var{misalign}).", default_builtin_vectorization_cost) /* Return true if vector alignment is reachable (by peeling N - iterations) for the given type. */ + iterations) for the given scalar type. */ DEFHOOK (vector_alignment_reachable, - "Return true if vector alignment is reachable (by peeling N iterations) for the given type.", + "Return true if vector alignment is reachable (by peeling N iterations) for the given scalar type @var{type}. @var{is_packed} is false if the scalar access using @var{type} is known to be naturally aligned.", bool, (const_tree type, bool is_packed), default_builtin_vector_alignment_reachable) diff --git a/gcc/targhooks.c b/gcc/targhooks.c index 2f2abd331d4..1cdec068ed8 100644 --- a/gcc/targhooks.c +++ b/gcc/targhooks.c @@ -1127,20 +1127,12 @@ default_vector_alignment (const_tree type) return align; } +/* By default assume vectors of element TYPE require a multiple of the natural + alignment of TYPE. TYPE is naturally aligned if IS_PACKED is false. */ bool -default_builtin_vector_alignment_reachable (const_tree type, bool is_packed) +default_builtin_vector_alignment_reachable (const_tree /*type*/, bool is_packed) { - if (is_packed) - return false; - - /* Assuming that types whose size is > pointer-size are not guaranteed to be - naturally aligned. */ - if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0) - return false; - - /* Assuming that types whose size is <= pointer-size - are naturally aligned. */ - return true; + return ! is_packed; } /* By default, assume that a target supports any factor of misalignment diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 9eb748f9fde..43e18fea091 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2017-01-25 Richard Biener + + PR tree-optimization/69264 + * g++.dg/torture/pr69264.C: New testcase. + 2016-01-25 Kyrylo Tkachov PR target/79145 diff --git a/gcc/testsuite/g++.dg/torture/pr69264.C b/gcc/testsuite/g++.dg/torture/pr69264.C new file mode 100644 index 00000000000..43753806758 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr69264.C @@ -0,0 +1,81 @@ +// { dg-do compile } +// { dg-additional-options "-mcpu=970 -maltivec" { target powerpc*-*-* } } + +typedef union { + long int asBits; +} jsval_layout; +static jsval_layout STRING_TO_JSVAL_IMPL() {} + +typedef __attribute__ ((aligned(sizeof (long int)))) long int jsval; +class Value { +public: + void setString() { + data = STRING_TO_JSVAL_IMPL(); + } + jsval_layout data; +} __attribute__ ((aligned(8))); + +static Value StringValue() +{ + Value v; + v.setString(); + return v; +} + +static const jsval & Jsvalify(const Value & v) +{ + return (const jsval &)v; +} + +static Value *Valueify(jsval *v) +{ + return (Value *) v; +} + +struct JSObject { + void getQNameLocalName(); +}; +static Value IdToValue(int id) +{ + if (id) + return StringValue(); +} + +static jsval IdToJsval(int id) +{ + return Jsvalify(IdToValue(id)); +} + +class AutoGCRooter; +struct JSContext { + AutoGCRooter *autoGCRooters; +}; +class AutoGCRooter { +public: + AutoGCRooter(JSContext *cx) {} +}; +class AutoArrayRooter:AutoGCRooter { +public: + AutoArrayRooter(JSContext *cx, Value *vec):AutoGCRooter(cx) + { + array = vec; + cx->autoGCRooters = this; + } + Value *array; +}; + +static void PutProperty(JSContext *cx, int id, jsval *vp) +{ + JSObject *nameobj; + jsval roots[3]; + roots[1] = IdToJsval(id); + roots[2] = *vp; + AutoArrayRooter tvr(cx, Valueify(roots)); + nameobj->getQNameLocalName(); +} + +void xml_defineProperty(JSContext *cx, int id, const Value *v) +{ + jsval tmp = Jsvalify(*v); + PutProperty(cx, id, &tmp); +} diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index c1fbbc958e0..33a32b818e9 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -1098,12 +1098,9 @@ vector_alignment_reachable_p (struct data_reference *dr) bool is_packed = not_size_aligned (DR_REF (dr)); if (dump_enabled_p ()) dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "Unknown misalignment, is_packed = %d\n",is_packed); - if ((TYPE_USER_ALIGN (type) && !is_packed) - || targetm.vectorize.vector_alignment_reachable (type, is_packed)) - return true; - else - return false; + "Unknown misalignment, %snaturally aligned\n", + is_packed ? "not " : ""); + return targetm.vectorize.vector_alignment_reachable (type, is_packed); } return true; @@ -6153,10 +6150,8 @@ vect_supportable_dr_alignment (struct data_reference *dr, if (!known_alignment_for_access_p (dr)) is_packed = not_size_aligned (DR_REF (dr)); - if ((TYPE_USER_ALIGN (type) && !is_packed) - || targetm.vectorize. - support_vector_misalignment (mode, type, - DR_MISALIGNMENT (dr), is_packed)) + if (targetm.vectorize.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; } @@ -6168,10 +6163,8 @@ vect_supportable_dr_alignment (struct data_reference *dr, if (!known_alignment_for_access_p (dr)) is_packed = not_size_aligned (DR_REF (dr)); - if ((TYPE_USER_ALIGN (type) && !is_packed) - || targetm.vectorize. - support_vector_misalignment (mode, type, - DR_MISALIGNMENT (dr), is_packed)) + if (targetm.vectorize.support_vector_misalignment + (mode, type, DR_MISALIGNMENT (dr), is_packed)) return dr_unaligned_supported; }