diff options
Diffstat (limited to 'toolchain-layer/recipes-devtools/gcc/gcc-4.6/linaro/gcc-4.6-linaro-r106842.patch')
| -rw-r--r-- | toolchain-layer/recipes-devtools/gcc/gcc-4.6/linaro/gcc-4.6-linaro-r106842.patch | 375 |
1 files changed, 375 insertions, 0 deletions
diff --git a/toolchain-layer/recipes-devtools/gcc/gcc-4.6/linaro/gcc-4.6-linaro-r106842.patch b/toolchain-layer/recipes-devtools/gcc/gcc-4.6/linaro/gcc-4.6-linaro-r106842.patch new file mode 100644 index 0000000000..2cf2741ba6 --- /dev/null +++ b/toolchain-layer/recipes-devtools/gcc/gcc-4.6/linaro/gcc-4.6-linaro-r106842.patch @@ -0,0 +1,375 @@ +2011-11-22 Ira Rosen <ira.rosen@linaro.org> + + Backport from mainline: + + 2011-10-06 Jakub Jelinek <jakub@redhat.com> + + gcc/ + PR tree-optimization/50596 + * tree-vectorizer.h (vect_is_simple_cond): New prototype. + (NUM_PATTERNS): Change to 6. + * tree-vect-patterns.c (vect_recog_mixed_size_cond_pattern): New + function. + (vect_vect_recog_func_ptrs): Add vect_recog_mixed_size_cond_pattern. + (vect_mark_pattern_stmts): Don't create stmt_vinfo for def_stmt + if it already has one, and don't set STMT_VINFO_VECTYPE in it + if it is already set. + * tree-vect-stmts.c (vect_mark_stmts_to_be_vectorized): Handle + COND_EXPR in pattern stmts. + (vect_is_simple_cond): No longer static. + + gcc/testsuite: + PR tree-optimization/50596 + * gcc.dg/vect/vect-cond-8.c: New test. + + 2011-10-07 Jakub Jelinek <jakub@redhat.com> + + gcc/ + PR tree-optimization/50650 + * tree-vect-patterns.c (vect_recog_mixed_size_cond_pattern): Don't + call vect_is_simple_cond here, instead fail if cond_expr isn't + COMPARISON_CLASS_P or if get_vectype_for_scalar_type returns NULL + for cond_expr's first operand. + * tree-vect-stmts.c (vect_is_simple_cond): Static again. + * tree-vectorizer.h (vect_is_simple_cond): Remove prototype. + + + gcc/ + * tree-vect-patterns.c (vect_recog_mixed_size_cond_pattern): Reduce + it to integral types only. + + gcc/testsuite/ + * gcc.dg/vect/pr30858.c: Expect the error message twice for targets + with multiple vector sizes. + * gcc.dg/vect/vect-cond-8.c: Rename to... + * gcc.dg/vect/vect-cond-8a.c: ... this and change the type from float + to int. + * lib/target-supports.exp (check_effective_target_vect_condition): + Return true for NEON. + +=== modified file 'gcc/testsuite/gcc.dg/vect/pr30858.c' +Index: gcc-4_6-branch/gcc/testsuite/gcc.dg/vect/pr30858.c +=================================================================== +--- gcc-4_6-branch.orig/gcc/testsuite/gcc.dg/vect/pr30858.c 2012-01-04 15:33:52.000000000 -0800 ++++ gcc-4_6-branch/gcc/testsuite/gcc.dg/vect/pr30858.c 2012-03-05 16:23:47.748983031 -0800 +@@ -11,5 +11,6 @@ + } + + /* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" } } */ +-/* { dg-final { scan-tree-dump-times "Unknown def-use cycle pattern." 1 "vect" } } */ ++/* { dg-final { scan-tree-dump-times "Unknown def-use cycle pattern." 1 "vect" { xfail vect_multiple_sizes } } } */ ++/* { dg-final { scan-tree-dump-times "Unknown def-use cycle pattern." 2 "vect" { target vect_multiple_sizes } } } */ + /* { dg-final { cleanup-tree-dump "vect" } } */ +Index: gcc-4_6-branch/gcc/testsuite/gcc.dg/vect/vect-cond-8a.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ gcc-4_6-branch/gcc/testsuite/gcc.dg/vect/vect-cond-8a.c 2012-03-05 16:23:47.748983031 -0800 +@@ -0,0 +1,75 @@ ++/* { dg-require-effective-target vect_condition } */ ++ ++#include "tree-vect.h" ++ ++#define N 1024 ++int a[N], b[N], c[N]; ++char d[N], e[N], f[N]; ++unsigned char k[N]; ++ ++__attribute__((noinline, noclone)) void ++f1 (void) ++{ ++ int i; ++ for (i = 0; i < N; ++i) ++ k[i] = a[i] < b[i] ? 17 : 0; ++} ++ ++__attribute__((noinline, noclone)) void ++f2 (void) ++{ ++ int i; ++ for (i = 0; i < N; ++i) ++ k[i] = a[i] < b[i] ? 0 : 24; ++} ++ ++__attribute__((noinline, noclone)) void ++f3 (void) ++{ ++ int i; ++ for (i = 0; i < N; ++i) ++ k[i] = a[i] < b[i] ? 51 : 12; ++} ++ ++int ++main () ++{ ++ int i; ++ ++ check_vect (); ++ ++ for (i = 0; i < N; i++) ++ { ++ switch (i % 9) ++ { ++ case 0: asm (""); a[i] = - i - 1; b[i] = i + 1; break; ++ case 1: a[i] = 0; b[i] = 0; break; ++ case 2: a[i] = i + 1; b[i] = - i - 1; break; ++ case 3: a[i] = i; b[i] = i + 7; break; ++ case 4: a[i] = i; b[i] = i; break; ++ case 5: a[i] = i + 16; b[i] = i + 3; break; ++ case 6: a[i] = - i - 5; b[i] = - i; break; ++ case 7: a[i] = - i; b[i] = - i; break; ++ case 8: a[i] = - i; b[i] = - i - 7; break; ++ } ++ d[i] = i; ++ e[i] = 2 * i; ++ } ++ f1 (); ++ for (i = 0; i < N; i++) ++ if (k[i] != ((i % 3) == 0 ? 17 : 0)) ++ abort (); ++ f2 (); ++ for (i = 0; i < N; i++) ++ if (k[i] != ((i % 3) == 0 ? 0 : 24)) ++ abort (); ++ f3 (); ++ for (i = 0; i < N; i++) ++ if (k[i] != ((i % 3) == 0 ? 51 : 12)) ++ abort (); ++ ++ return 0; ++} ++ ++/* { dg-final { scan-tree-dump-times "note: vectorized 1 loops" 3 "vect" } } */ ++/* { dg-final { cleanup-tree-dump "vect" } } */ +Index: gcc-4_6-branch/gcc/tree-vect-patterns.c +=================================================================== +--- gcc-4_6-branch.orig/gcc/tree-vect-patterns.c 2012-03-05 16:23:10.000000000 -0800 ++++ gcc-4_6-branch/gcc/tree-vect-patterns.c 2012-03-05 16:23:47.748983031 -0800 +@@ -50,13 +50,16 @@ + tree *); + static gimple vect_recog_widen_shift_pattern (VEC (gimple, heap) **, + tree *, tree *); ++static gimple vect_recog_mixed_size_cond_pattern (VEC (gimple, heap) **, ++ tree *, tree *); + static vect_recog_func_ptr vect_vect_recog_func_ptrs[NUM_PATTERNS] = { + vect_recog_widen_mult_pattern, + vect_recog_widen_sum_pattern, + vect_recog_dot_prod_pattern, + vect_recog_pow_pattern, + vect_recog_over_widening_pattern, +- vect_recog_widen_shift_pattern}; ++ vect_recog_widen_shift_pattern, ++ vect_recog_mixed_size_cond_pattern}; + + + /* Function widened_name_p +@@ -1441,6 +1444,118 @@ + return pattern_stmt; + } + ++/* Function vect_recog_mixed_size_cond_pattern ++ ++ Try to find the following pattern: ++ ++ type x_t, y_t; ++ TYPE a_T, b_T, c_T; ++ loop: ++ S1 a_T = x_t CMP y_t ? b_T : c_T; ++ ++ where type 'TYPE' is an integral type which has different size ++ from 'type'. b_T and c_T are constants and if 'TYPE' is wider ++ than 'type', the constants need to fit into an integer type ++ with the same width as 'type'. ++ ++ Input: ++ ++ * LAST_STMT: A stmt from which the pattern search begins. ++ ++ Output: ++ ++ * TYPE_IN: The type of the input arguments to the pattern. ++ ++ * TYPE_OUT: The type of the output of this pattern. ++ ++ * Return value: A new stmt that will be used to replace the pattern. ++ Additionally a def_stmt is added. ++ ++ a_it = x_t CMP y_t ? b_it : c_it; ++ a_T = (TYPE) a_it; */ ++ ++static gimple ++vect_recog_mixed_size_cond_pattern (VEC (gimple, heap) **stmts, tree *type_in, ++ tree *type_out) ++{ ++ gimple last_stmt = VEC_index (gimple, *stmts, 0); ++ tree cond_expr, then_clause, else_clause; ++ stmt_vec_info stmt_vinfo = vinfo_for_stmt (last_stmt), def_stmt_info; ++ tree type, vectype, comp_vectype, comp_type, op, tmp; ++ enum machine_mode cmpmode; ++ gimple pattern_stmt, def_stmt; ++ loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo); ++ ++ if (!is_gimple_assign (last_stmt) ++ || gimple_assign_rhs_code (last_stmt) != COND_EXPR ++ || STMT_VINFO_DEF_TYPE (stmt_vinfo) != vect_internal_def) ++ return NULL; ++ ++ op = gimple_assign_rhs1 (last_stmt); ++ cond_expr = TREE_OPERAND (op, 0); ++ then_clause = TREE_OPERAND (op, 1); ++ else_clause = TREE_OPERAND (op, 2); ++ ++ if (TREE_CODE (then_clause) != INTEGER_CST ++ || TREE_CODE (else_clause) != INTEGER_CST) ++ return NULL; ++ ++ if (!COMPARISON_CLASS_P (cond_expr)) ++ return NULL; ++ ++ type = gimple_expr_type (last_stmt); ++ comp_type = TREE_TYPE (TREE_OPERAND (cond_expr, 0)); ++ if (!INTEGRAL_TYPE_P (comp_type) ++ || !INTEGRAL_TYPE_P (type)) ++ return NULL; ++ ++ comp_vectype = get_vectype_for_scalar_type (comp_type); ++ if (comp_vectype == NULL_TREE) ++ return NULL; ++ ++ cmpmode = GET_MODE_INNER (TYPE_MODE (comp_vectype)); ++ ++ if (GET_MODE_BITSIZE (TYPE_MODE (type)) == GET_MODE_BITSIZE (cmpmode)) ++ return NULL; ++ ++ vectype = get_vectype_for_scalar_type (type); ++ if (vectype == NULL_TREE) ++ return NULL; ++ ++ if (types_compatible_p (vectype, comp_vectype)) ++ return NULL; ++ ++ if (!expand_vec_cond_expr_p (comp_vectype, TYPE_MODE (comp_vectype))) ++ return NULL; ++ ++ if (GET_MODE_BITSIZE (TYPE_MODE (type)) > GET_MODE_BITSIZE (cmpmode)) ++ { ++ if (!int_fits_type_p (then_clause, comp_type) ++ || !int_fits_type_p (else_clause, comp_type)) ++ return NULL; ++ } ++ ++ tmp = build3 (COND_EXPR, comp_type, unshare_expr (cond_expr), ++ fold_convert (comp_type, then_clause), ++ fold_convert (comp_type, else_clause)); ++ def_stmt = gimple_build_assign (vect_recog_temp_ssa_var (comp_type, NULL), tmp); ++ ++ pattern_stmt ++ = gimple_build_assign_with_ops (NOP_EXPR, ++ vect_recog_temp_ssa_var (type, NULL), ++ gimple_assign_lhs (def_stmt), NULL_TREE); ++ ++ STMT_VINFO_PATTERN_DEF_STMT (stmt_vinfo) = def_stmt; ++ def_stmt_info = new_stmt_vec_info (def_stmt, loop_vinfo, NULL); ++ set_vinfo_for_stmt (def_stmt, def_stmt_info); ++ STMT_VINFO_VECTYPE (def_stmt_info) = comp_vectype; ++ *type_in = vectype; ++ *type_out = vectype; ++ ++ return pattern_stmt; ++} ++ ++ + /* Mark statements that are involved in a pattern. */ + + static inline void +@@ -1468,14 +1583,18 @@ + if (STMT_VINFO_PATTERN_DEF_STMT (pattern_stmt_info)) + { + def_stmt = STMT_VINFO_PATTERN_DEF_STMT (pattern_stmt_info); +- set_vinfo_for_stmt (def_stmt, +- new_stmt_vec_info (def_stmt, loop_vinfo, NULL)); +- gimple_set_bb (def_stmt, gimple_bb (orig_stmt)); + def_stmt_info = vinfo_for_stmt (def_stmt); ++ if (def_stmt_info == NULL) ++ { ++ def_stmt_info = new_stmt_vec_info (def_stmt, loop_vinfo, NULL); ++ set_vinfo_for_stmt (def_stmt, def_stmt_info); ++ } ++ gimple_set_bb (def_stmt, gimple_bb (orig_stmt)); + STMT_VINFO_RELATED_STMT (def_stmt_info) = orig_stmt; + STMT_VINFO_DEF_TYPE (def_stmt_info) + = STMT_VINFO_DEF_TYPE (orig_stmt_info); +- STMT_VINFO_VECTYPE (def_stmt_info) = pattern_vectype; ++ if (STMT_VINFO_VECTYPE (def_stmt_info) == NULL_TREE) ++ STMT_VINFO_VECTYPE (def_stmt_info) = pattern_vectype; + } + } + +Index: gcc-4_6-branch/gcc/tree-vect-stmts.c +=================================================================== +--- gcc-4_6-branch.orig/gcc/tree-vect-stmts.c 2012-03-05 16:23:11.000000000 -0800 ++++ gcc-4_6-branch/gcc/tree-vect-stmts.c 2012-03-05 16:23:47.748983031 -0800 +@@ -655,20 +655,40 @@ + tree rhs = gimple_assign_rhs1 (stmt); + unsigned int op_num; + tree op; ++ enum tree_code rhs_code; + switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))) + { + case GIMPLE_SINGLE_RHS: +- op_num = TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt)); +- for (i = 0; i < op_num; i++) +- { +- op = TREE_OPERAND (rhs, i); +- if (!process_use (stmt, op, loop_vinfo, live_p, relevant, +- &worklist)) +- { +- VEC_free (gimple, heap, worklist); +- return false; +- } +- } ++ op = gimple_assign_rhs1 (stmt); ++ rhs_code = gimple_assign_rhs_code (stmt); ++ i = 0; ++ if (rhs_code == COND_EXPR ++ && COMPARISON_CLASS_P (TREE_OPERAND (op, 0))) ++ { ++ op = TREE_OPERAND (op, 0); ++ if (!process_use (stmt, TREE_OPERAND (op, 0), ++ loop_vinfo, ++ live_p, relevant, &worklist) ++ || !process_use (stmt, TREE_OPERAND (op, 1), ++ loop_vinfo, ++ live_p, relevant, &worklist)) ++ { ++ VEC_free (gimple, heap, worklist); ++ return false; ++ } ++ i = 1; ++ } ++ op_num = TREE_OPERAND_LENGTH (gimple_assign_rhs1 (stmt)); ++ for (i; i < op_num; i++) ++ { ++ op = TREE_OPERAND (rhs, i); ++ if (!process_use (stmt, op, loop_vinfo, live_p, relevant, ++ &worklist)) ++ { ++ VEC_free (gimple, heap, worklist); ++ return false; ++ } ++ } + break; + + case GIMPLE_BINARY_RHS: +Index: gcc-4_6-branch/gcc/tree-vectorizer.h +=================================================================== +--- gcc-4_6-branch.orig/gcc/tree-vectorizer.h 2012-03-05 16:23:11.000000000 -0800 ++++ gcc-4_6-branch/gcc/tree-vectorizer.h 2012-03-05 16:23:47.748983031 -0800 +@@ -917,7 +917,7 @@ + Additional pattern recognition functions can (and will) be added + in the future. */ + typedef gimple (* vect_recog_func_ptr) (VEC (gimple, heap) **, tree *, tree *); +-#define NUM_PATTERNS 6 ++#define NUM_PATTERNS 7 + void vect_pattern_recog (loop_vec_info); + + /* In tree-vectorizer.c. */ |