fold-const.c (build_zero_vector): Use build_vector_from_val.

	* fold-const.c (build_zero_vector): Use build_vector_from_val.
	* tree-vect-loop.c (get_initial_def_for_induction): Likewise.
	(get_initial_def_for_reduction): Likewise.
	* tree-vect-slp.c (vect_get_constant_vectors): Likewise.
	* tree-vect-stmts.c (vect_get_vec_def_for_operand): Likewise.
	* tree.c (build_one_cst): Likewise.
	(build_vector_from_val): Use types_compatible_p for assert.

From-SVN: r166102

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 2d6360984a3960679def2acefbd4417812e933a2..660e3392703664c8a3cac25bb544be920970eb65 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,13 @@
+2010-10-30  Nathan Froyd  <froydnj@codesourcery.com>
+
+       * fold-const.c (build_zero_vector): Use build_vector_from_val.
+       * tree-vect-loop.c (get_initial_def_for_induction): Likewise.
+       (get_initial_def_for_reduction): Likewise.
+       * tree-vect-slp.c (vect_get_constant_vectors): Likewise.
+       * tree-vect-stmts.c (vect_get_vec_def_for_operand): Likewise.
+       * tree.c (build_one_cst): Likewise.
+       (build_vector_from_val): Use types_compatible_p for assert.
+
 2010-10-30  Nathan Froyd  <froydnj@codesourcery.com>
 
        * emit-rtl.c (mark_used_flags): New function.

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index decb0fba8f51858d7ae71765988fb2199dd39a01..4599a69d50cadbf17b845804fddfd1d3af9e9c79 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -1796,16 +1796,10 @@ fold_convert_const (enum tree_code code, tree type, tree arg1)
 static tree
 build_zero_vector (tree type)
 {
-  tree elem, list;
-  int i, units;
-
-  elem = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
-  units = TYPE_VECTOR_SUBPARTS (type);
+  tree t;
 
-  list = NULL_TREE;
-  for (i = 0; i < units; i++)
-    list = tree_cons (NULL_TREE, elem, list);
-  return build_vector (type, list);
+  t = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
+  return build_vector_from_val (type, t);
 }
 
 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR.  */

diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c
index 4b1bd44305408ea4c7cbbdfbcb987db0f594aff4..c213673e20bf5a298fa8327d2614d0be2c6d5dd8 100644 (file)
--- a/gcc/tree-vect-loop.c
+++ b/gcc/tree-vect-loop.c
@@ -2725,13 +2725,11 @@ get_initial_def_for_induction (gimple iv_phi)
                              expr, step_expr);
     }
 
-  t = NULL_TREE;
-  for (i = 0; i < nunits; i++)
-    t = tree_cons (NULL_TREE, unshare_expr (new_name), t);
+  t = unshare_expr (new_name);
   gcc_assert (CONSTANT_CLASS_P (new_name));
   stepvectype = get_vectype_for_scalar_type (TREE_TYPE (new_name));
   gcc_assert (stepvectype);
-  vec = build_vector (stepvectype, t);
+  vec = build_vector_from_val (stepvectype, t);
   vec_step = vect_init_vector (iv_phi, vec, stepvectype, NULL);
 
 
@@ -2785,11 +2783,9 @@ get_initial_def_for_induction (gimple iv_phi)
       expr = build_int_cst (TREE_TYPE (step_expr), nunits);
       new_name = fold_build2 (MULT_EXPR, TREE_TYPE (step_expr),
                              expr, step_expr);
-      t = NULL_TREE;
-      for (i = 0; i < nunits; i++)
-       t = tree_cons (NULL_TREE, unshare_expr (new_name), t);
+      t = unshare_expr (new_name);
       gcc_assert (CONSTANT_CLASS_P (new_name));
-      vec = build_vector (stepvectype, t);
+      vec = build_vector_from_val (stepvectype, t);
       vec_step = vect_init_vector (iv_phi, vec, stepvectype, NULL);
 
       vec_def = induc_def;
@@ -3021,14 +3017,7 @@ get_initial_def_for_reduction (gimple stmt, tree init_val,
             break;
           }
 
-        for (i = nunits - 1; i >= 0; --i)
-          t = tree_cons (NULL_TREE, init_value, t);
-
-        if (TREE_CONSTANT (init_val))
-          init_def = build_vector (vectype, t);
-        else
-          init_def = build_constructor_from_list (vectype, t);
-
+       init_def = build_vector_from_val (vectype, init_value);
         break;
 
       default:

diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c
index 7a69db05ebb43834069bacd1ef0280625652ffa7..fdaaff2865b5da4b7b5895fadd22517f4932aea7 100644 (file)
--- a/gcc/tree-vect-slp.c
+++ b/gcc/tree-vect-slp.c
@@ -1986,12 +1986,7 @@ vect_get_constant_vectors (tree op, slp_tree slp_node,
       if (neutral_op)
         {
           if (!neutral_vec)
-            {
-              t = NULL;
-              for (i = 0; i < (unsigned) nunits; i++)
-                 t = tree_cons (NULL_TREE, neutral_op, t);
-              neutral_vec = build_vector (vector_type, t);
-            }
+           neutral_vec = build_vector_from_val (vector_type, neutral_op);
 
           VEC_quick_push (tree, *vec_oprnds, neutral_vec);
         }

diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c
index 01fd5cfd14a2eff55b6c706a395ab5a484dc4a9d..6f4f56861d0b8c9dd08af36c276a98510ec55460 100644 (file)
--- a/gcc/tree-vect-stmts.c
+++ b/gcc/tree-vect-stmts.c
@@ -987,9 +987,7 @@ vect_get_vec_def_for_operand (tree op, gimple stmt, tree *scalar_def)
   loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo);
   tree vec_inv;
   tree vec_cst;
-  tree t = NULL_TREE;
   tree def;
-  int i;
   enum vect_def_type dt;
   bool is_simple_use;
   tree vector_type;
@@ -1033,11 +1031,7 @@ vect_get_vec_def_for_operand (tree op, gimple stmt, tree *scalar_def)
         if (vect_print_dump_info (REPORT_DETAILS))
           fprintf (vect_dump, "Create vector_cst. nunits = %d", nunits);
 
-        for (i = nunits - 1; i >= 0; --i)
-          {
-            t = tree_cons (NULL_TREE, op, t);
-          }
-        vec_cst = build_vector (vector_type, t);
+        vec_cst = build_vector_from_val (vector_type, op);
         return vect_init_vector (stmt, vec_cst, vector_type, NULL);
       }
 
@@ -1055,13 +1049,7 @@ vect_get_vec_def_for_operand (tree op, gimple stmt, tree *scalar_def)
         if (vect_print_dump_info (REPORT_DETAILS))
           fprintf (vect_dump, "Create vector_inv.");
 
-        for (i = nunits - 1; i >= 0; --i)
-          {
-            t = tree_cons (NULL_TREE, def, t);
-          }
-
-       /* FIXME: use build_constructor directly.  */
-        vec_inv = build_constructor_from_list (vector_type, t);
+        vec_inv = build_vector_from_val (vector_type, def);
         return vect_init_vector (stmt, vec_inv, vector_type, NULL);
       }
 

diff --git a/gcc/tree.c b/gcc/tree.c
index 4eb13c124c1c8b804168e9912fa5e6f795fde9ba..4de73ee4d2c75c3eb55c7f850cdb08603fcef71f 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -1376,7 +1376,8 @@ build_vector_from_val (tree vectype, tree sc)
   if (sc == error_mark_node)
     return sc;
 
-  gcc_assert (TREE_TYPE (sc) == TREE_TYPE (vectype));
+  gcc_assert (lang_hooks.types_compatible_p (TREE_TYPE (sc),
+                                            TREE_TYPE (vectype)));
 
   v = VEC_alloc (constructor_elt, gc, nunits);
   for (i = 0; i < nunits; ++i)
@@ -1590,17 +1591,9 @@ build_one_cst (tree type)
 
     case VECTOR_TYPE:
       {
-       tree scalar, cst;
-       int i;
-
-       scalar = build_one_cst (TREE_TYPE (type));
-
-       /* Create 'vect_cst_ = {cst,cst,...,cst}'  */
-       cst = NULL_TREE;
-       for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
-         cst = tree_cons (NULL_TREE, scalar, cst);
+       tree scalar = build_one_cst (TREE_TYPE (type));
 
-       return build_vector (type, cst);
+       return build_vector_from_val (type, scalar);
       }
 
     case COMPLEX_TYPE: