gcc/: Rename array_type_nelts => array_type_nelts_minus_one

The old name was misleading.

While at it, also rename some temporary variables that are used with
this function, for consistency.

Link: <https://inbox.sourceware.org/gcc-patches/9fffd80-dca-2c7e-14b-6c9b509a7215@redhat.com/T/#m2f661c67c8f7b2c405c8c7fc3152dd85dc729120>

gcc/ChangeLog:

	* tree.cc (array_type_nelts, array_type_nelts_minus_one)
	* tree.h (array_type_nelts, array_type_nelts_minus_one)
	* expr.cc (count_type_elements)
	* config/aarch64/aarch64.cc
	(pure_scalable_type_info::analyze_array)
	* config/i386/i386.cc (ix86_canonical_va_list_type):
	Rename array_type_nelts => array_type_nelts_minus_one
	The old name was misleading.

gcc/c/ChangeLog:

	* c-decl.cc (one_element_array_type_p, get_parm_array_spec)
	* c-fold.cc (c_fold_array_ref):
	Rename array_type_nelts => array_type_nelts_minus_one

gcc/cp/ChangeLog:

	* decl.cc (reshape_init_array)
	* init.cc
	(build_zero_init_1)
	(build_value_init_noctor)
	(build_vec_init)
	(build_delete)
	* lambda.cc (add_capture)
	* tree.cc (array_type_nelts_top):
	Rename array_type_nelts => array_type_nelts_minus_one

gcc/fortran/ChangeLog:

	* trans-array.cc (structure_alloc_comps)
	* trans-openmp.cc
	(gfc_walk_alloc_comps)
	(gfc_omp_clause_linear_ctor):
	Rename array_type_nelts => array_type_nelts_minus_one

gcc/rust/ChangeLog:

	* backend/rust-tree.cc (array_type_nelts_top):
	Rename array_type_nelts => array_type_nelts_minus_one

Suggested-by: Richard Biener <richard.guenther@gmail.com>
Signed-off-by: Alejandro Colomar <alx@kernel.org>

diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
index 1827bbf06465db62d9f4af66fa2be13bb3bfa6c9..491c24b9fe7ee577565fb4fb74c74461669b6cd8 100644 (file)
--- a/gcc/c/c-decl.cc
+++ b/gcc/c/c-decl.cc
@@ -5367,7 +5367,7 @@ one_element_array_type_p (const_tree type)
 {
   if (TREE_CODE (type) != ARRAY_TYPE)
     return false;
-  return integer_zerop (array_type_nelts (type));
+  return integer_zerop (array_type_nelts_minus_one (type));
 }
 
 /* Determine whether TYPE is a zero-length array type "[0]".  */
@@ -6315,15 +6315,15 @@ get_parm_array_spec (const struct c_parm *parm, tree attrs)
          for (tree type = parm->specs->type; TREE_CODE (type) == ARRAY_TYPE;
               type = TREE_TYPE (type))
            {
-             tree nelts = array_type_nelts (type);
-             if (error_operand_p (nelts))
+             tree nelts_minus_one = array_type_nelts_minus_one (type);
+             if (error_operand_p (nelts_minus_one))
                return attrs;
-             if (TREE_CODE (nelts) != INTEGER_CST)
+             if (TREE_CODE (nelts_minus_one) != INTEGER_CST)
                {
                  /* Each variable VLA bound is represented by the dollar
                     sign.  */
                  spec += "$";
-                 tpbnds = tree_cons (NULL_TREE, nelts, tpbnds);
+                 tpbnds = tree_cons (NULL_TREE, nelts_minus_one, tpbnds);
                }
            }
          tpbnds = nreverse (tpbnds);

diff --git a/gcc/c/c-fold.cc b/gcc/c/c-fold.cc
index 57b67c74bd8e8831ec0064c85dc2faf98f0f6c17..9ea174f79c49bf947c8b7b0034ac3278d1dccf5c 100644 (file)
--- a/gcc/c/c-fold.cc
+++ b/gcc/c/c-fold.cc
@@ -73,11 +73,12 @@ c_fold_array_ref (tree type, tree ary, tree index)
   unsigned elem_nchars = (TYPE_PRECISION (elem_type)
                          / TYPE_PRECISION (char_type_node));
   unsigned len = (unsigned) TREE_STRING_LENGTH (ary) / elem_nchars;
-  tree nelts = array_type_nelts (TREE_TYPE (ary));
+  tree nelts_minus_one = array_type_nelts_minus_one (TREE_TYPE (ary));
   bool dummy1 = true, dummy2 = true;
-  nelts = c_fully_fold_internal (nelts, true, &dummy1, &dummy2, false, false);
+  nelts_minus_one = c_fully_fold_internal (nelts_minus_one, true, &dummy1,
+                                          &dummy2, false, false);
   unsigned HOST_WIDE_INT i = tree_to_uhwi (index);
-  if (!tree_int_cst_le (index, nelts)
+  if (!tree_int_cst_le (index, nelts_minus_one)
       || i >= len
       || i + elem_nchars > len)
     return NULL_TREE;

diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc
index 3ab550acc7cdb7c0c4bfb148e643891f701b776e..0dbc2aaa99ff0b0602c12e44546c7616bae68c73 100644 (file)
--- a/gcc/config/aarch64/aarch64.cc
+++ b/gcc/config/aarch64/aarch64.cc
@@ -1081,7 +1081,7 @@ pure_scalable_type_info::analyze_array (const_tree type)
 
   /* An array of unknown, flexible or variable length will be passed and
      returned by reference whatever we do.  */
-  tree nelts_minus_one = array_type_nelts (type);
+  tree nelts_minus_one = array_type_nelts_minus_one (type);
   if (!tree_fits_uhwi_p (nelts_minus_one))
     return DOESNT_MATTER;
 

diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc
index 68d038da3f909b673a1871906a44fa65a6fef64b..9e5a6c0ffefdcfcc9343dfba6676afdcddd99d01 100644 (file)
--- a/gcc/config/i386/i386.cc
+++ b/gcc/config/i386/i386.cc
@@ -24629,7 +24629,7 @@ ix86_canonical_va_list_type (tree type)
        return ms_va_list_type_node;
 
       if ((TREE_CODE (type) == ARRAY_TYPE
-          && integer_zerop (array_type_nelts (type)))
+          && integer_zerop (array_type_nelts_minus_one (type)))
          || POINTER_TYPE_P (type))
        {
          tree elem_type = TREE_TYPE (type);

diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 0c5b5c06a12e73e149d0a5446336d12e05687172..7281818be8fd47979f6bc71dc1f284299f926e83 100644 (file)
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -6956,7 +6956,7 @@ reshape_init_array (tree type, reshape_iter *d, tree first_initializer_p,
   gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
 
   if (TYPE_DOMAIN (type))
-    max_index = array_type_nelts (type);
+    max_index = array_type_nelts_minus_one (type);
 
   return reshape_init_array_1 (TREE_TYPE (type), max_index, d,
                               first_initializer_p, complain);

diff --git a/gcc/cp/init.cc b/gcc/cp/init.cc
index f785015e47744b38b197cf521025b5d25c8f7de1..10b83efa85061e312948acf1db564005c56c9f7c 100644 (file)
--- a/gcc/cp/init.cc
+++ b/gcc/cp/init.cc
@@ -263,7 +263,7 @@ build_zero_init_1 (tree type, tree nelts, bool static_storage_p,
       else if (TYPE_DOMAIN (type) == NULL_TREE)
        return NULL_TREE;
       else
-       max_index = array_type_nelts (type);
+       max_index = array_type_nelts_minus_one (type);
 
       /* If we have an error_mark here, we should just return error mark
         as we don't know the size of the array yet.  */
@@ -474,7 +474,7 @@ build_value_init_noctor (tree type, tsubst_flags_t complain)
       vec<constructor_elt, va_gc> *v = NULL;
 
       /* Iterate over the array elements, building initializations.  */
-      tree max_index = array_type_nelts (type);
+      tree max_index = array_type_nelts_minus_one (type);
 
       /* If we have an error_mark here, we should just return error mark
         as we don't know the size of the array yet.  */
@@ -4526,7 +4526,7 @@ build_vec_init (tree base, tree maxindex, tree init,
                    : location_of (base));
 
   if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
-    maxindex = array_type_nelts (atype);
+    maxindex = array_type_nelts_minus_one (atype);
 
   if (maxindex == NULL_TREE || maxindex == error_mark_node)
     return error_mark_node;
@@ -5191,7 +5191,7 @@ build_delete (location_t loc, tree otype, tree addr,
            error_at (loc, "unknown array size in delete");
          return error_mark_node;
        }
-      return build_vec_delete (loc, addr, array_type_nelts (type),
+      return build_vec_delete (loc, addr, array_type_nelts_minus_one (type),
                               auto_delete, use_global_delete, complain);
     }
 

diff --git a/gcc/cp/lambda.cc b/gcc/cp/lambda.cc
index e17c00217b2e45ec06f022e6b37ca4cd20b981ab..d51b513f0fae8823e038b0254657ec858185fdbd 100644 (file)
--- a/gcc/cp/lambda.cc
+++ b/gcc/cp/lambda.cc
@@ -556,7 +556,8 @@ add_capture (tree lambda, tree id, tree orig_init, bool by_reference_p,
                                     integer_zero_node, tf_warning_or_error);
       initializer = build_constructor_va (init_list_type_node, 2,
                                          NULL_TREE, build_address (elt),
-                                         NULL_TREE, array_type_nelts (type));
+                                         NULL_TREE,
+                                         array_type_nelts_minus_one (type));
       type = vla_capture_type (type);
     }
   else if (!dependent_type_p (type)

diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
index 0a7a56cc6e2eb4eb3cee6f7b8c5b16f942b90840..3cac8ac4df1b6bb159324c887a612fbd6a065784 100644 (file)
--- a/gcc/cp/tree.cc
+++ b/gcc/cp/tree.cc
@@ -3085,7 +3085,7 @@ array_type_nelts_top (tree type)
 {
   return fold_build2_loc (input_location,
                      PLUS_EXPR, sizetype,
-                     array_type_nelts (type),
+                     array_type_nelts_minus_one (type),
                      size_one_node);
 }
 

diff --git a/gcc/expr.cc b/gcc/expr.cc
index b7a04f76fbf6687949f3f0c0c0e9ac3f0b1b9e23..87f9e002c07c59cb114eedcf0a331133927aed3b 100644 (file)
--- a/gcc/expr.cc
+++ b/gcc/expr.cc
@@ -6991,14 +6991,14 @@ count_type_elements (const_tree type, bool for_ctor_p)
     {
     case ARRAY_TYPE:
       {
-       tree nelts;
+       tree nelts_minus_one;
 
-       nelts = array_type_nelts (type);
-       if (nelts && tree_fits_uhwi_p (nelts))
+       nelts_minus_one = array_type_nelts_minus_one (type);
+       if (nelts_minus_one && tree_fits_uhwi_p (nelts_minus_one))
          {
            unsigned HOST_WIDE_INT n;
 
-           n = tree_to_uhwi (nelts) + 1;
+           n = tree_to_uhwi (nelts_minus_one) + 1;
            if (n == 0 || for_ctor_p)
              return n;
            else

diff --git a/gcc/fortran/trans-array.cc b/gcc/fortran/trans-array.cc
index 0b8ef0b5e018f943e0bb8af81814d08f6e08c32d..160a543bda27eebeeaac1e6b89c4822c6c4244fd 100644 (file)
--- a/gcc/fortran/trans-array.cc
+++ b/gcc/fortran/trans-array.cc
@@ -9695,7 +9695,7 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, tree dest,
       else
        {
          /*  Otherwise use the TYPE_DOMAIN information.  */
-         tmp = array_type_nelts (decl_type);
+         tmp = array_type_nelts_minus_one (decl_type);
          tmp = fold_convert (gfc_array_index_type, tmp);
        }
 

diff --git a/gcc/fortran/trans-openmp.cc b/gcc/fortran/trans-openmp.cc
index d3783f56a6937ec28b976fa8f3eee4f93487d79f..f4c93148400d8ed4d39c394c4c36323024b13d95 100644 (file)
--- a/gcc/fortran/trans-openmp.cc
+++ b/gcc/fortran/trans-openmp.cc
@@ -582,7 +582,7 @@ gfc_walk_alloc_comps (tree decl, tree dest, tree var,
              tem = size_binop (MINUS_EXPR, tem, size_one_node);
            }
          else
-           tem = array_type_nelts (type);
+           tem = array_type_nelts_minus_one (type);
          tem = fold_convert (gfc_array_index_type, tem);
        }
 
@@ -1309,7 +1309,7 @@ gfc_omp_clause_linear_ctor (tree clause, tree dest, tree src, tree add)
          nelems = size_binop (MINUS_EXPR, nelems, size_one_node);
        }
       else
-       nelems = array_type_nelts (type);
+       nelems = array_type_nelts_minus_one (type);
       nelems = fold_convert (gfc_array_index_type, nelems);
 
       gfc_omp_linear_clause_add_loop (&block, dest, src, add, nelems);

diff --git a/gcc/rust/backend/rust-tree.cc b/gcc/rust/backend/rust-tree.cc
index cdb79095da88208002b821c3a560745e8bf85897..8d32e5203aea014666b4ffa2662b1e1653ac392d 100644 (file)
--- a/gcc/rust/backend/rust-tree.cc
+++ b/gcc/rust/backend/rust-tree.cc
@@ -869,7 +869,7 @@ tree
 array_type_nelts_top (tree type)
 {
   return fold_build2_loc (input_location, PLUS_EXPR, sizetype,
-                         array_type_nelts (type), size_one_node);
+                         array_type_nelts_minus_one (type), size_one_node);
 }
 
 // forked from gcc/cp/tree.cc builtin_valid_in_constant_expr_p

diff --git a/gcc/tree.cc b/gcc/tree.cc
index 392c3dc879e7b77466f7b8fa2613bac27001f63e..94c6d086bd73a81e93897351791f526a30b9ce96 100644 (file)
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -3701,7 +3701,7 @@ int_byte_position (const_tree field)
    ARRAY_TYPE) minus one.  This counts only elements of the top array.  */
 
 tree
-array_type_nelts (const_tree type)
+array_type_nelts_minus_one (const_tree type)
 {
   tree index_type, min, max;
 
@@ -14800,7 +14800,7 @@ is_empty_type (const_tree type)
       return true;
     }
   else if (TREE_CODE (type) == ARRAY_TYPE)
-    return (integer_minus_onep (array_type_nelts (type))
+    return (integer_minus_onep (array_type_nelts_minus_one (type))
            || TYPE_DOMAIN (type) == NULL_TREE
            || is_empty_type (TREE_TYPE (type)));
   return false;

diff --git a/gcc/tree.h b/gcc/tree.h
index d324a3f42a67a61bc3dffa0c1371f717f0763c49..c996821c95340e53e8de4c573364ad24f53865b8 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -4929,7 +4929,7 @@ extern tree build_method_type_directly (tree, tree, tree);
 extern tree build_method_type (tree, tree);
 extern tree build_offset_type (tree, tree);
 extern tree build_complex_type (tree, bool named = false);
-extern tree array_type_nelts (const_tree);
+extern tree array_type_nelts_minus_one (const_tree);
 
 extern tree value_member (tree, tree);
 extern tree purpose_member (const_tree, tree);