don't use TYPE_ARG_TYPES in c-family/

don't use TYPE_ARG_TYPES in c-family/
	* c-common.c (check_main_parameter_types): Reindent.  Don't use
	TYPE_ARG_TYPES directly.
	(handle_nonnull_attribute): Likewise.
	(sync_resolve_params): Likewise.
	* c-format.c (handle_format_arg_attribute): Likewise.  Adjust call
	to check_format_string.
	(handle_format_attribute): Likewise.
	(check_format_string): Take a function type to examine instead of
	a type list.  Use a function_arg_iterator to step through argument
	types.

From-SVN: r173384

diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
index 8ad5f6e491bd822a8ac2d682bf04ca8d20018315..55c03b30ddfae1d71de1948bdb98b5f949a42e14 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,16 @@
+2011-05-04  Nathan Froyd  <froydnj@codesourcery.com>
+
+       * c-common.c (check_main_parameter_types): Reindent.  Don't use
+       TYPE_ARG_TYPES directly.
+       (handle_nonnull_attribute): Likewise.
+       (sync_resolve_params): Likewise.
+       * c-format.c (handle_format_arg_attribute): Likewise.  Adjust call
+       to check_format_string.
+       (handle_format_attribute): Likewise.
+       (check_format_string): Take a function type to examine instead of
+       a type list.  Use a function_arg_iterator to step through argument
+       types.
+
 2011-05-04  Richard Guenther  <rguenther@suse.de>
 
        * c-common.c (fix_string_type): Use size_int for index type bounds.

diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index aaaa21065306e0a139781984ab74bf58f908daa7..207f77be451d2041aeb7aad7501c54c2620fd5d0 100644 (file)
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -1663,51 +1663,52 @@ strict_aliasing_warning (tree otype, tree type, tree expr)
 void
 check_main_parameter_types (tree decl)
 {
-  tree args;
+  function_args_iterator iter;
+  tree type;
   int argct = 0;
 
-  for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
-      args = TREE_CHAIN (args))
-   {
-     tree type = args ? TREE_VALUE (args) : 0;
-
-     if (type == void_type_node || type == error_mark_node )
-       break;
-
-     ++argct;
-     switch (argct)
-       {
-       case 1:
-         if (TYPE_MAIN_VARIANT (type) != integer_type_node)
-           pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
-                   decl);
-         break;
-
-       case 2:
-         if (TREE_CODE (type) != POINTER_TYPE
-             || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
-             || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
-                 != char_type_node))
-           pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
-                   decl);
-         break;
-
-       case 3:
-         if (TREE_CODE (type) != POINTER_TYPE
-             || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
-             || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
-                 != char_type_node))
-          pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
-                   "%<char **%>", decl);
-         break;
-       }
-   }
+  FOREACH_FUNCTION_ARGS (TREE_TYPE (decl), type, iter)
+    {
+      /* XXX void_type_node belies the abstraction.  */
+      if (type == void_type_node || type == error_mark_node )
+       break;
+
+      ++argct;
+      switch (argct)
+       {
+       case 1:
+         if (TYPE_MAIN_VARIANT (type) != integer_type_node)
+           pedwarn (input_location, OPT_Wmain,
+                    "first argument of %q+D should be %<int%>", decl);
+         break;
+
+       case 2:
+         if (TREE_CODE (type) != POINTER_TYPE
+             || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
+             || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
+                 != char_type_node))
+           pedwarn (input_location, OPT_Wmain,
+                    "second argument of %q+D should be %<char **%>", decl);
+         break;
+
+       case 3:
+         if (TREE_CODE (type) != POINTER_TYPE
+             || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
+             || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
+                 != char_type_node))
+           pedwarn (input_location, OPT_Wmain,
+                    "third argument of %q+D should probably be "
+                    "%<char **%>", decl);
+         break;
+       }
+    }
 
   /* It is intentional that this message does not mention the third
     argument because it's only mentioned in an appendix of the
     standard.  */
   if (argct > 0 && (argct < 2 || argct > 3))
-    pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
+    pedwarn (input_location, OPT_Wmain,
+            "%q+D takes only zero or two arguments", decl);
 }
 
 /* True if pointers to distinct types T1 and T2 can be converted to
@@ -7395,7 +7396,6 @@ handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
      a pointer argument.  */
   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
     {
-      tree argument;
       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
 
       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
@@ -7406,18 +7406,21 @@ handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
          return NULL_TREE;
        }
 
-      argument = TYPE_ARG_TYPES (type);
-      if (argument)
+      if (prototype_p (type))
        {
-         for (ck_num = 1; ; ck_num++)
+         function_args_iterator iter;
+         tree argument;
+
+         function_args_iter_init (&iter, type);
+         for (ck_num = 1; ; ck_num++, function_args_iter_next (&iter))
            {
-             if (!argument || ck_num == arg_num)
+             argument = function_args_iter_cond (&iter);
+             if (argument == NULL_TREE || ck_num == arg_num)
                break;
-             argument = TREE_CHAIN (argument);
            }
 
          if (!argument
-             || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
+             || TREE_CODE (argument) == VOID_TYPE)
            {
              error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
                     (unsigned long) attr_arg_num, (unsigned long) arg_num);
@@ -7425,7 +7428,7 @@ handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
              return NULL_TREE;
            }
 
-         if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
+         if (TREE_CODE (argument) != POINTER_TYPE)
            {
              error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
                   (unsigned long) attr_arg_num, (unsigned long) arg_num);
@@ -8922,22 +8925,28 @@ sync_resolve_size (tree function, VEC(tree,gc) *params)
 static bool
 sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
 {
-  tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
+  function_args_iterator iter;
   tree ptype;
   unsigned int parmnum;
 
+  function_args_iter_init (&iter, TREE_TYPE (function));
   /* We've declared the implementation functions to use "volatile void *"
      as the pointer parameter, so we shouldn't get any complaints from the
      call to check_function_arguments what ever type the user used.  */
-  arg_types = TREE_CHAIN (arg_types);
+  function_args_iter_next (&iter);
   ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
 
   /* For the rest of the values, we need to cast these to FTYPE, so that we
      don't get warnings for passing pointer types, etc.  */
   parmnum = 0;
-  while (arg_types != void_list_node)
+  while (1)
     {
-      tree val;
+      tree val, arg_type;
+
+      arg_type = function_args_iter_cond (&iter);
+      /* XXX void_type_node belies the abstraction.  */
+      if (arg_type == void_type_node)
+       break;
 
       ++parmnum;
       if (VEC_length (tree, params) <= parmnum)
@@ -8951,10 +8960,10 @@ sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
         type.  This isn't portable across the C and C++ front ends atm.  */
       val = VEC_index (tree, params, parmnum);
       val = convert (ptype, val);
-      val = convert (TREE_VALUE (arg_types), val);
+      val = convert (arg_type, val);
       VEC_replace (tree, params, parmnum, val);
 
-      arg_types = TREE_CHAIN (arg_types);
+      function_args_iter_next (&iter);
     }
 
   /* The definition of these primitives is variadic, with the remaining

diff --git a/gcc/c-family/c-format.c b/gcc/c-family/c-format.c
index 0c5115a9360a1d045cd51ed54d6d256471f96154..66012c4a88eb60f8526448139f56e81c6cfbf628 100644 (file)
--- a/gcc/c-family/c-format.c
+++ b/gcc/c-family/c-format.c
@@ -120,7 +120,6 @@ handle_format_arg_attribute (tree *node, tree ARG_UNUSED (name),
   tree type = *node;
   tree format_num_expr = TREE_VALUE (args);
   unsigned HOST_WIDE_INT format_num = 0;
-  tree argument;
 
   if (!get_constant (format_num_expr, &format_num, 0))
     {
@@ -129,12 +128,11 @@ handle_format_arg_attribute (tree *node, tree ARG_UNUSED (name),
       return NULL_TREE;
     }
 
-  argument = TYPE_ARG_TYPES (type);
-  if (argument)
+  if (prototype_p (type))
     {
       /* The format arg can be any string reference valid for the language and
          target.  We cannot be more specific in this case.  */
-      if (!check_format_string (argument, format_num, flags, no_add_attrs, -1))
+      if (!check_format_string (type, format_num, flags, no_add_attrs, -1))
        return NULL_TREE;
     }
 
@@ -154,23 +152,24 @@ handle_format_arg_attribute (tree *node, tree ARG_UNUSED (name),
    error).  When we know the specific reference type expected, this is also 
    checked.  */
 static bool
-check_format_string (tree argument, unsigned HOST_WIDE_INT format_num,
+check_format_string (tree fntype, unsigned HOST_WIDE_INT format_num,
                     int flags, bool *no_add_attrs, int expected_format_type)
 {
   unsigned HOST_WIDE_INT i;
   bool is_objc_sref, is_target_sref, is_char_ref;
   tree ref;
   int fmt_flags;
+  function_args_iterator iter;
 
-  for (i = 1; i != format_num; i++)
+  i = 1;
+  FOREACH_FUNCTION_ARGS (fntype, ref, iter)
     {
-      if (argument == 0)
+      if (i == format_num)
        break;
-      argument = TREE_CHAIN (argument);
+      i++;
     }
 
-  if (!argument
-      || !(ref = TREE_VALUE (argument))
+  if (!ref
       || !valid_stringptr_type_p (ref))
     {
       if (!(flags & (int) ATTR_FLAG_BUILT_IN))
@@ -2957,7 +2956,6 @@ handle_format_attribute (tree *node, tree ARG_UNUSED (name), tree args,
 {
   tree type = *node;
   function_format_info info;
-  tree argument;
 
 #ifdef TARGET_FORMAT_TYPES
   /* If the target provides additional format types, we need to
@@ -2984,21 +2982,22 @@ handle_format_attribute (tree *node, tree ARG_UNUSED (name), tree args,
       return NULL_TREE;
     }
 
-  argument = TYPE_ARG_TYPES (type);
-  if (argument)
+  if (prototype_p (type))
     {
-      if (!check_format_string (argument, info.format_num, flags,
+      if (!check_format_string (type, info.format_num, flags,
                                no_add_attrs, info.format_type))
        return NULL_TREE;
 
       if (info.first_arg_num != 0)
        {
          unsigned HOST_WIDE_INT arg_num = 1;
+         function_args_iterator iter;
+         tree arg_type;
 
          /* Verify that first_arg_num points to the last arg,
             the ...  */
-         while (argument)
-           arg_num++, argument = TREE_CHAIN (argument);
+         FOREACH_FUNCTION_ARGS (type, arg_type, iter)
+           arg_num++;
 
          if (arg_num != info.first_arg_num)
            {