* hsa-gen.c (hsa_op_immed::hsa_op_immed Use CONSTRUCTOR_NELTS (...)

	instead of vec_safe_length (CONSTRUCTOR_ELTS (...)).
	(gen_hsa_ctor_assignment): Likewise.
	* print-tree.c (print_node): Likewise.
	* tree-dump.c (dequeue_and_dump): Likewise.
	* tree-sra.c (sra_modify_constructor_assign): Likewise.
	* expr.c (store_constructor): Likewise.
	* fold-const.c (operand_equal_p): Likewise.
	* tree-pretty-print.c (dump_generic_node): Likewise.
	* hsa-brig.c (hsa_op_immed::emit_to_buffer): Likewise.
	* ipa-icf-gimple.c (func_checker::compare_operand): Likewise.
cp/
	* typeck2.c (process_init_constructor_record): Use
	CONSTRUCTOR_NELTS (...) instead of
	vec_safe_length (CONSTRUCTOR_ELTS (...)).
	* decl.c (reshape_init_r): Likewise.
	(check_initializer): Likewise.
ada/
	* gcc-interface/decl.c (gnat_to_gnu_entity): Use
	CONSTRUCTOR_NELTS (...) instead of
	vec_safe_length (CONSTRUCTOR_ELTS (...)).

From-SVN: r240390

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 313e390b4c3c7267458629a6ebc204a04180813d..453413be33833662961e78bbf3bbafdc53262a59 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,17 @@
+2016-09-23  Jakub Jelinek  <jakub@redhat.com>
+
+       * hsa-gen.c (hsa_op_immed::hsa_op_immed Use CONSTRUCTOR_NELTS (...)
+       instead of vec_safe_length (CONSTRUCTOR_ELTS (...)).
+       (gen_hsa_ctor_assignment): Likewise.
+       * print-tree.c (print_node): Likewise.
+       * tree-dump.c (dequeue_and_dump): Likewise.
+       * tree-sra.c (sra_modify_constructor_assign): Likewise.
+       * expr.c (store_constructor): Likewise.
+       * fold-const.c (operand_equal_p): Likewise.
+       * tree-pretty-print.c (dump_generic_node): Likewise.
+       * hsa-brig.c (hsa_op_immed::emit_to_buffer): Likewise.
+       * ipa-icf-gimple.c (func_checker::compare_operand): Likewise.
+
 2016-09-23  Richard Biener  <rguenther@suse.de>
 
        * hooks.h (hook_uint_uintp_false): Declare.

diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 54cd2dc6ddad51eb62e054107484bb0f3b2830ba..9dc0d97b865224d77e8ae25d8c37d9b18f17f665 100644 (file)
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,9 @@
+2016-09-23  Jakub Jelinek  <jakub@redhat.com>
+
+       * gcc-interface/decl.c (gnat_to_gnu_entity): Use
+       CONSTRUCTOR_NELTS (...) instead of
+       vec_safe_length (CONSTRUCTOR_ELTS (...)).
+
 2016-07-14  Eric Botcazou  <ebotcazou@adacore.com>
 
        * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Access_Type>: Also use

diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c
index 3f468b6f5e80f903db9b99bdf9006a7b050c314d..f820f8452bfefa3a44e46370becf86929e2fea68 100644 (file)
--- a/gcc/ada/gcc-interface/decl.c
+++ b/gcc/ada/gcc-interface/decl.c
@@ -1339,7 +1339,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition)
                      = TREE_TYPE (DECL_CHAIN (TYPE_FIELDS (gnu_alloc_type)));
 
                    if (TREE_CODE (gnu_expr) == CONSTRUCTOR
-                       && vec_safe_length (CONSTRUCTOR_ELTS (gnu_expr)) == 1)
+                       && CONSTRUCTOR_NELTS (gnu_expr) == 1)
                      gnu_expr = NULL_TREE;
                    else
                      gnu_expr

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 3a4d1f45f8cf5f749b44f9e4bf7151a5ed9f0ce3..ae5934301c9fc3b98d881aee49c7789ef3be0b45 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,11 @@
+2016-09-23  Jakub Jelinek  <jakub@redhat.com>
+
+       * typeck2.c (process_init_constructor_record): Use
+       CONSTRUCTOR_NELTS (...) instead of
+       vec_safe_length (CONSTRUCTOR_ELTS (...)).
+       * decl.c (reshape_init_r): Likewise.
+       (check_initializer): Likewise.
+
 2016-09-22  Paolo Carlini  <paolo.carlini@oracle.com>
 
        PR c++/71979

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 921f8d5ffb5cfd3ddff2d425e3726e4379213981..24f71ce4f7236fcc14030e87e2034a94f4bc0448 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -5933,7 +5933,7 @@ reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
         element (as allowed by [dcl.init.string]).  */
       if (!first_initializer_p
          && TREE_CODE (str_init) == CONSTRUCTOR
-         && vec_safe_length (CONSTRUCTOR_ELTS (str_init)) == 1)
+         && CONSTRUCTOR_NELTS (str_init) == 1)
        {
          str_init = (*CONSTRUCTOR_ELTS (str_init))[0].value;
        }
@@ -6136,7 +6136,7 @@ check_initializer (tree decl, tree init, int flags, vec<tree, va_gc> **cleanups)
 
   if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
     {
-      int init_len = vec_safe_length (CONSTRUCTOR_ELTS (init));
+      int init_len = CONSTRUCTOR_NELTS (init);
       if (SCALAR_TYPE_P (type))
        {
          if (init_len == 0)

diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index b9dc56d01c385295147961aa6a5b49bb9a09066d..6e226856edcbc4021ab370a7d14bdd93343dadef 100644 (file)
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -1379,7 +1379,7 @@ process_init_constructor_record (tree type, tree init,
       if (type == error_mark_node)
        return PICFLAG_ERRONEOUS;
 
-      if (idx < vec_safe_length (CONSTRUCTOR_ELTS (init)))
+      if (idx < CONSTRUCTOR_NELTS (init))
        {
          constructor_elt *ce = &(*CONSTRUCTOR_ELTS (init))[idx];
          if (ce->index)
@@ -1476,7 +1476,7 @@ process_init_constructor_record (tree type, tree init,
       CONSTRUCTOR_APPEND_ELT (v, field, next);
     }
 
-  if (idx < vec_safe_length (CONSTRUCTOR_ELTS (init)))
+  if (idx < CONSTRUCTOR_NELTS (init))
     {
       if (complain & tf_error)
        error ("too many initializers for %qT", type);

diff --git a/gcc/expr.c b/gcc/expr.c
index 2e97030c5b884b046fa6d2867f5c63680f32af85..d15e98bdfe8a90a0d3022fd8478498fb3d9e6ffb 100644 (file)
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -6187,8 +6187,7 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size,
           register whose mode size isn't equal to SIZE since
           clear_storage can't handle this case.  */
        else if (size > 0
-                && (((int)vec_safe_length (CONSTRUCTOR_ELTS (exp))
-                     != fields_length (type))
+                && (((int) CONSTRUCTOR_NELTS (exp) != fields_length (type))
                     || mostly_zeros_p (exp))
                 && (!REG_P (target)
                     || ((HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target))

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index e040b2a279b206b23c1dcfd5bd7f68d26df91324..a6b7ec7dfeced0a019ce2b7d4c2ee6abde25e84b 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -2954,8 +2954,7 @@ operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
       case CONSTRUCTOR:
        /* In GIMPLE empty constructors are allowed in initializers of
           aggregates.  */
-       return (!vec_safe_length (CONSTRUCTOR_ELTS (arg0))
-               && !vec_safe_length (CONSTRUCTOR_ELTS (arg1)));
+       return !CONSTRUCTOR_NELTS (arg0) && !CONSTRUCTOR_NELTS (arg1);
       default:
        break;
       }

diff --git a/gcc/hsa-brig.c b/gcc/hsa-brig.c
index 9c74b9aa0713d9ffd7dfb678c6ec2adff9fdd36f..4dc568c54e45b4e84b63949199a1549202f73bc9 100644 (file)
--- a/gcc/hsa-brig.c
+++ b/gcc/hsa-brig.c
@@ -985,7 +985,7 @@ hsa_op_immed::emit_to_buffer (unsigned *brig_repr_size)
        }
       else if (TREE_CODE (m_tree_value) == CONSTRUCTOR)
        {
-         unsigned len = vec_safe_length (CONSTRUCTOR_ELTS (m_tree_value));
+         unsigned len = CONSTRUCTOR_NELTS (m_tree_value);
          for (unsigned i = 0; i < len; i++)
            {
              tree v = CONSTRUCTOR_ELT (m_tree_value, i)->value;

diff --git a/gcc/hsa-gen.c b/gcc/hsa-gen.c
index 4d1b2767441cfea3a947dad21baa2ca5062a357c..2c8ec1d95057745e69d31823095f9441c1feef55 100644 (file)
--- a/gcc/hsa-gen.c
+++ b/gcc/hsa-gen.c
@@ -1100,8 +1100,7 @@ hsa_op_immed::hsa_op_immed (tree tree_val, bool min32int)
 
   /* Verify that all elements of a constructor are constants.  */
   if (TREE_CODE (m_tree_value) == CONSTRUCTOR)
-    for (unsigned i = 0;
-        i < vec_safe_length (CONSTRUCTOR_ELTS (m_tree_value)); i++)
+    for (unsigned i = 0; i < CONSTRUCTOR_NELTS (m_tree_value); i++)
       {
        tree v = CONSTRUCTOR_ELT (m_tree_value, i)->value;
        if (!CONSTANT_CLASS_P (v))
@@ -2845,7 +2844,7 @@ void
 gen_hsa_ctor_assignment (hsa_op_address *addr_lhs, tree rhs, hsa_bb *hbb,
                         BrigAlignment8_t align)
 {
-  if (vec_safe_length (CONSTRUCTOR_ELTS (rhs)))
+  if (CONSTRUCTOR_NELTS (rhs))
     {
       HSA_SORRY_AT (EXPR_LOCATION (rhs),
                    "support for HSA does not implement load from constructor");

diff --git a/gcc/ipa-icf-gimple.c b/gcc/ipa-icf-gimple.c
index 9e3c862339b4b1b14fcf72838fa1bf416f1b194e..683df31577902c89b9d23ecb30a868c243f2d413 100644 (file)
--- a/gcc/ipa-icf-gimple.c
+++ b/gcc/ipa-icf-gimple.c
@@ -406,8 +406,8 @@ func_checker::compare_operand (tree t1, tree t2)
     {
     case CONSTRUCTOR:
       {
-       unsigned length1 = vec_safe_length (CONSTRUCTOR_ELTS (t1));
-       unsigned length2 = vec_safe_length (CONSTRUCTOR_ELTS (t2));
+       unsigned length1 = CONSTRUCTOR_NELTS (t1);
+       unsigned length2 = CONSTRUCTOR_NELTS (t2);
 
        if (length1 != length2)
          return return_false ();

diff --git a/gcc/print-tree.c b/gcc/print-tree.c
index 60957f9525974be74ef8f1b7cdabe50a0718ad2a..8c63cb8ee23b5f4cf8d26b4fdc5fb170785f2605 100644 (file)
--- a/gcc/print-tree.c
+++ b/gcc/print-tree.c
@@ -841,7 +841,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
          {
            unsigned HOST_WIDE_INT cnt;
            tree index, value;
-           len = vec_safe_length (CONSTRUCTOR_ELTS (node));
+           len = CONSTRUCTOR_NELTS (node);
            fprintf (file, " lngt %d", len);
            FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node),
                                      cnt, index, value)

diff --git a/gcc/tree-dump.c b/gcc/tree-dump.c
index 05228a0afe1ce728f73a1d1182e767711c973d06..ed60e6d3cd58d5ee1640919596bb926506363867 100644 (file)
--- a/gcc/tree-dump.c
+++ b/gcc/tree-dump.c
@@ -646,7 +646,7 @@ dequeue_and_dump (dump_info_p di)
       {
        unsigned HOST_WIDE_INT cnt;
        tree index, value;
-       dump_int (di, "lngt", vec_safe_length (CONSTRUCTOR_ELTS (t)));
+       dump_int (di, "lngt", CONSTRUCTOR_NELTS (t));
        FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
          {
            dump_child ("idx", index);

diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index 0915fd4243e578ff179f36929c516302132f174d..3449f266beade197419bbf5d98666a4e77cbe9c8 100644 (file)
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -1983,7 +1983,7 @@ dump_generic_node (pretty_printer *pp, tree node, int spc, int flags,
                dump_decl_name (pp, val, flags);
            else
                dump_generic_node (pp, val, spc, flags, false);
-           if (ix != vec_safe_length (CONSTRUCTOR_ELTS (node)) - 1)
+           if (ix != CONSTRUCTOR_NELTS (node) - 1)
              {
                pp_comma (pp);
                pp_space (pp);

diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index 4a2ff0d174c200715b031e6117b403b56c272f65..5565743af0a31f6219203e71261a6cb6ed7db984 100644 (file)
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -3224,7 +3224,7 @@ sra_modify_constructor_assign (gimple *stmt, gimple_stmt_iterator *gsi)
        return SRA_AM_MODIFIED;
     }
 
-  if (vec_safe_length (CONSTRUCTOR_ELTS (gimple_assign_rhs1 (stmt))) > 0)
+  if (CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt)) > 0)
     {
       /* I have never seen this code path trigger but if it can happen the
         following should handle it gracefully.  */