c-ada-spec.c (dump_ada_import): Use boolean and fix formatting.

	* c-ada-spec.c (dump_ada_import): Use boolean and fix formatting.
	(is_char_array): Fix formatting.
	(dump_template_types): Likewise.
	(dump_generic_ada_node): Rename into...
	(dump_ada_node): ...this.
	<POINTER_TYPE>: Remove superfluous space.  Use generic address for
	incomplete structures and not for empty structures.  Do not use it
	when forward declarations are needed.
	(dump_forward_type): New function.
	(dump_nested_types): Remove FORWARD parameter.  Do not consider
	TREE_VISITED and do not generate a forward declaration.  Only dump
	original nested types for nested declaration.
	(dump_nested_type) <POINTER_TYPE>: Call dump_forward_type.
	<ARRAY_TYPE>: Likewise if the component type is an anonymous pointer.
	<RECORD_TYPE>: Do not consider TREE_VISITED.
	(dump_ada_declaration): Use booleans and fix formatting throughout.
	<TYPE_DECL>: Skip incomplete structures and not empty structures.
	Call dump_forward_type instead of dump_nested_types for a typedef.
	Remove superfluous check and adjust call to dump_nested_types.
	<POINTER_TYPE>: Call dump_forward_type and fall through.
	(dump_ada_struct_decl): Rename into...
	(dump_ada_structure): ...this.  Do not special-case empty structures.

From-SVN: r258064

diff --git a/gcc/c-family/c-ada-spec.c b/gcc/c-family/c-ada-spec.c
index 69fd8d50157ad7b636cba1d0a0701b1c81002cf6..fbe654dc104c825bac9200d5d66290100d9ea85f 100644 (file)
--- a/gcc/c-family/c-ada-spec.c
+++ b/gcc/c-family/c-ada-spec.c
@@ -32,10 +32,9 @@ along with GCC; see the file COPYING3.  If not see
 #include "attribs.h"
 
 /* Local functions, macros and variables.  */
-static int  dump_generic_ada_node (pretty_printer *, tree, tree, int, bool,
-                                  bool);
+static int  dump_ada_node (pretty_printer *, tree, tree, int, bool, bool);
 static int  dump_ada_declaration (pretty_printer *, tree, tree, int);
-static void dump_ada_struct_decl (pretty_printer *, tree, tree, int, bool);
+static void dump_ada_structure (pretty_printer *, tree, tree, int, bool);
 static char *to_ada_name (const char *, unsigned int, bool *);
 
 #define INDENT(SPACE) \
@@ -1725,13 +1724,13 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func,
              pp_string (buffer, buf);
            }
 
-         dump_generic_ada_node (buffer, TREE_TYPE (arg), node, spc, 0, true);
+         dump_ada_node (buffer, TREE_TYPE (arg), node, spc, false, true);
        }
       else
        {
          sprintf (buf, "arg%d : ", num);
          pp_string (buffer, buf);
-         dump_generic_ada_node (buffer, TREE_VALUE (arg), node, spc, 0, true);
+         dump_ada_node (buffer, TREE_VALUE (arg), node, spc, false, true);
        }
 
       /* If the type is a pointer to a tagged type, we need to differentiate
@@ -1773,7 +1772,7 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func,
     {
       pp_string (buffer, " return ");
       tree type = is_constructor ? DECL_CONTEXT (func) : TREE_TYPE (node);
-      dump_generic_ada_node (buffer, type, type, spc, false, true);
+      dump_ada_node (buffer, type, type, spc, false, true);
     }
 }
 
@@ -1800,13 +1799,13 @@ dump_ada_array_domains (pretty_printer *buffer, tree node, int spc)
          first = 0;
 
          if (min)
-           dump_generic_ada_node (buffer, min, NULL_TREE, spc, 0, true);
+           dump_ada_node (buffer, min, NULL_TREE, spc, false, true);
          pp_string (buffer, " .. ");
 
          /* If the upper bound is zero, gcc may generate a NULL_TREE
             for TYPE_MAX_VALUE rather than an integer_cst.  */
          if (max)
-           dump_generic_ada_node (buffer, max, NULL_TREE, spc, 0, true);
+           dump_ada_node (buffer, max, NULL_TREE, spc, false, true);
          else
            pp_string (buffer, "0");
        }
@@ -1855,8 +1854,9 @@ is_char_array (tree t)
     }
 
   tmp = TREE_TYPE (tmp);
-  return num_dim == 1 && TREE_CODE (tmp) == INTEGER_TYPE
-    && id_equal (DECL_NAME (TYPE_NAME (tmp)), "char");
+  return num_dim == 1
+        && TREE_CODE (tmp) == INTEGER_TYPE
+        && id_equal (DECL_NAME (TYPE_NAME (tmp)), "char");
 }
 
 /* Dump in BUFFER an array type T in Ada syntax.  Assume that the "type"
@@ -1894,7 +1894,7 @@ dump_ada_array_type (pretty_printer *buffer, tree t, tree parent, int spc)
        pp_string (buffer, "aliased ");
 
       if (TYPE_NAME (tmp) || !RECORD_OR_UNION_TYPE_P (tmp))
-       dump_generic_ada_node (buffer, tmp, TREE_TYPE (t), spc, false, true);
+       dump_ada_node (buffer, tmp, TREE_TYPE (t), spc, false, true);
       else
        dump_ada_double_name (buffer, parent, get_underlying_decl (tmp));
     }
@@ -1907,14 +1907,12 @@ dump_ada_array_type (pretty_printer *buffer, tree t, tree parent, int spc)
 static void
 dump_template_types (pretty_printer *buffer, tree types, int spc)
 {
-  size_t i;
-  size_t len = TREE_VEC_LENGTH (types);
-
-  for (i = 0; i < len; i++)
+  for (int i = 0; i < TREE_VEC_LENGTH (types); i++)
     {
       tree elem = TREE_VEC_ELT (types, i);
       pp_underscore (buffer);
-      if (!dump_generic_ada_node (buffer, elem, 0, spc, false, true))
+
+      if (!dump_ada_node (buffer, elem, NULL_TREE, spc, false, true))
        {
          pp_string (buffer, "unknown");
          pp_scalar (buffer, "%lu", (unsigned long) TREE_HASH (elem));
@@ -1967,7 +1965,7 @@ dump_ada_template (pretty_printer *buffer, tree t, int spc)
       INDENT (spc);
       pp_string (buffer, "package ");
       package_prefix = false;
-      dump_generic_ada_node (buffer, instance, t, spc, false, true);
+      dump_ada_node (buffer, instance, t, spc, false, true);
       dump_template_types (buffer, types, spc);
       pp_string (buffer, " is");
       spc += INDENT_INCR;
@@ -1975,7 +1973,7 @@ dump_ada_template (pretty_printer *buffer, tree t, int spc)
 
       TREE_VISITED (get_underlying_decl (instance)) = 1;
       pp_string (buffer, "type ");
-      dump_generic_ada_node (buffer, instance, t, spc, false, true);
+      dump_ada_node (buffer, instance, t, spc, false, true);
       package_prefix = true;
 
       if (is_tagged_type (instance))
@@ -1983,7 +1981,7 @@ dump_ada_template (pretty_printer *buffer, tree t, int spc)
       else
        pp_string (buffer, " is limited ");
 
-      dump_generic_ada_node (buffer, instance, t, spc, false, false);
+      dump_ada_node (buffer, instance, t, spc, false, false);
       pp_newline (buffer);
       spc -= INDENT_INCR;
       newline_and_indent (buffer, spc);
@@ -1992,7 +1990,7 @@ dump_ada_template (pretty_printer *buffer, tree t, int spc)
       newline_and_indent (buffer, spc);
       pp_string (buffer, "use ");
       package_prefix = false;
-      dump_generic_ada_node (buffer, instance, t, spc, false, true);
+      dump_ada_node (buffer, instance, t, spc, false, true);
       dump_template_types (buffer, types, spc);
       package_prefix = true;
       pp_semicolon (buffer);
@@ -2038,8 +2036,8 @@ static bool bitfield_used = false;
    we should only dump the name of NODE, instead of its full declaration.  */
 
 static int
-dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
-                      bool limited_access, bool name_only)
+dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
+              bool limited_access, bool name_only)
 {
   if (node == NULL_TREE)
     return 0;
@@ -2059,8 +2057,8 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
       return 0;
 
     case TREE_BINFO:
-      dump_generic_ada_node
-       (buffer, BINFO_TYPE (node), type, spc, limited_access, name_only);
+      dump_ada_node (buffer, BINFO_TYPE (node), type, spc, limited_access,
+                    name_only);
       return 0;
 
     case TREE_VEC:
@@ -2087,7 +2085,7 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
 
     case ENUMERAL_TYPE:
       if (name_only)
-       dump_generic_ada_node (buffer, TYPE_NAME (node), node, spc, 0, true);
+       dump_ada_node (buffer, TYPE_NAME (node), node, spc, false, true);
       else
        {
          tree value = TYPE_VALUES (node);
@@ -2115,9 +2113,9 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
              spc -= INDENT_INCR;
              newline_and_indent (buffer, spc);
              pp_string (buffer, "pragma Convention (C, ");
-             dump_generic_ada_node
-               (buffer, DECL_NAME (type) ? type : TYPE_NAME (node), type,
-                spc, 0, true);
+             dump_ada_node (buffer,
+                            DECL_NAME (type) ? type : TYPE_NAME (node),
+                            type, spc, false, true);
              pp_right_paren (buffer);
            }
          else
@@ -2135,16 +2133,16 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
                                          0, false);
                  pp_string (buffer, " : constant ");
 
-                 dump_generic_ada_node
-                   (buffer, DECL_NAME (type) ? type : TYPE_NAME (node), type,
-                    spc, 0, true);
+                 dump_ada_node (buffer,
+                                DECL_NAME (type) ? type : TYPE_NAME (node),
+                                type, spc, false, true);
 
                  pp_string (buffer, " := ");
-                 dump_generic_ada_node
-                   (buffer,
-                    TREE_CODE (TREE_VALUE (value)) == INTEGER_CST ?
-                      TREE_VALUE (value) : DECL_INITIAL (TREE_VALUE (value)),
-                    node, spc, false, true);
+                 dump_ada_node (buffer,
+                                TREE_CODE (TREE_VALUE (value)) == INTEGER_CST
+                                ? TREE_VALUE (value)
+                                : DECL_INITIAL (TREE_VALUE (value)),
+                                node, spc, false, true);
                }
            }
        }
@@ -2204,8 +2202,8 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
     case POINTER_TYPE:
     case REFERENCE_TYPE:
       if (name_only && TYPE_NAME (node))
-       dump_generic_ada_node
-         (buffer, TYPE_NAME (node), node, spc, limited_access, true);
+       dump_ada_node (buffer, TYPE_NAME (node), node, spc, limited_access,
+                      true);
 
       else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
        {
@@ -2224,7 +2222,7 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
              pp_semicolon (buffer);
              newline_and_indent (buffer, spc);
              pp_string (buffer, "pragma Convention (C, ");
-             dump_generic_ada_node (buffer, type, 0, spc, false, true);
+             dump_ada_node (buffer, type, NULL_TREE, spc, false, true);
              pp_right_paren (buffer);
            }
        }
@@ -2319,11 +2317,11 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
                    }
 
                  if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (node)) && type_name)
-                   dump_generic_ada_node (buffer, type_name, TREE_TYPE (node),
-                                          spc, is_access, true);
+                   dump_ada_node (buffer, type_name, TREE_TYPE (node), spc,
+                                  is_access, true);
                  else
-                   dump_generic_ada_node (buffer, TREE_TYPE (node),
-                                          TREE_TYPE (node), spc, 0, true);
+                   dump_ada_node (buffer, TREE_TYPE (node), TREE_TYPE (node),
+                                  spc, false, true);
                }
            }
        }
@@ -2331,8 +2329,8 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
 
     case ARRAY_TYPE:
       if (name_only)
-       dump_generic_ada_node
-         (buffer, TYPE_NAME (node), node, spc, limited_access, true);
+       dump_ada_node (buffer, TYPE_NAME (node), node, spc, limited_access,
+                      true);
       else
        dump_ada_array_type (buffer, node, type, spc);
       break;
@@ -2342,8 +2340,8 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
       if (name_only)
        {
          if (TYPE_NAME (node))
-           dump_generic_ada_node
-             (buffer, TYPE_NAME (node), node, spc, limited_access, true);
+           dump_ada_node (buffer, TYPE_NAME (node), node, spc, limited_access,
+                          true);
          else
            {
              pp_string (buffer, "anon_");
@@ -2351,7 +2349,7 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
            }
        }
       else
-       dump_ada_struct_decl (buffer, node, type, spc, true);
+       dump_ada_structure (buffer, node, type, spc, true);
       break;
 
     case INTEGER_CST:
@@ -2442,8 +2440,7 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type, int spc,
          else if (has_nontrivial_methods (TREE_TYPE (node)))
            pp_string (buffer, "limited ");
 
-         dump_generic_ada_node
-           (buffer, TREE_TYPE (node), type, spc, false, false);
+         dump_ada_node (buffer, TREE_TYPE (node), type, spc, false, false);
        }
       break;
 
@@ -2529,7 +2526,7 @@ dump_forward_type (pretty_printer *buffer, tree type, tree t, int spc)
 
   /* Generate an incomplete type declaration.  */
   pp_string (buffer, "type ");
-  dump_generic_ada_node (buffer, decl, 0, spc, false, true);
+  dump_ada_node (buffer, decl, NULL_TREE, spc, false, true);
   pp_semicolon (buffer);
   newline_and_indent (buffer, spc);
 
@@ -2624,21 +2621,21 @@ dump_nested_type (pretty_printer *buffer, tree field, tree t, tree parent,
 
       if (TYPE_NAME (field_type))
        {
-         dump_generic_ada_node (buffer, field_type, 0, spc, false, true);
+         dump_ada_node (buffer, field_type, NULL_TREE, spc, false, true);
          if (TREE_CODE (field_type) == UNION_TYPE)
            pp_string (buffer, " (discr : unsigned := 0)");
          pp_string (buffer, " is ");
-         dump_ada_struct_decl (buffer, field_type, t, spc, false);
+         dump_ada_structure (buffer, field_type, t, spc, false);
 
          pp_string (buffer, "pragma Convention (C_Pass_By_Copy, ");
-         dump_generic_ada_node (buffer, field_type, 0, spc, false, true);
+         dump_ada_node (buffer, field_type, NULL_TREE, spc, false, true);
          pp_string (buffer, ");");
          newline_and_indent (buffer, spc);
 
          if (TREE_CODE (field_type) == UNION_TYPE)
            {
              pp_string (buffer, "pragma Unchecked_Union (");
-             dump_generic_ada_node (buffer, field_type, 0, spc, false, true);
+             dump_ada_node (buffer, field_type, NULL_TREE, spc, false, true);
              pp_string (buffer, ");");
            }
        }
@@ -2648,7 +2645,7 @@ dump_nested_type (pretty_printer *buffer, tree field, tree t, tree parent,
          if (TREE_CODE (field_type) == UNION_TYPE)
            pp_string (buffer, " (discr : unsigned := 0)");
          pp_string (buffer, " is ");
-         dump_ada_struct_decl (buffer, field_type, t, spc, false);
+         dump_ada_structure (buffer, field_type, t, spc, false);
 
          pp_string (buffer, "pragma Convention (C_Pass_By_Copy, ");
          dump_ada_double_name (buffer, parent, field);
@@ -2749,7 +2746,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
              if (RECORD_OR_UNION_TYPE_P (typ) && !COMPLETE_TYPE_P (typ))
                {
                  pp_string (buffer, "--  skipped incomplete struct ");
-                 dump_generic_ada_node (buffer, t, type, spc, false, true);
+                 dump_ada_node (buffer, t, type, spc, false, true);
                }
              else
                {
@@ -2757,9 +2754,9 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
                    dump_forward_type (buffer, stub, t, spc);
 
                  pp_string (buffer, "subtype ");
-                 dump_generic_ada_node (buffer, t, type, spc, false, true);
+                 dump_ada_node (buffer, t, type, spc, false, true);
                  pp_string (buffer, " is ");
-                 dump_generic_ada_node (buffer, typ, type, spc, false, true);
+                 dump_ada_node (buffer, typ, type, spc, false, true);
                  pp_string (buffer, ";  -- ");
                  dump_sloc (buffer, t);
                }
@@ -2792,7 +2789,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
            if (!COMPLETE_TYPE_P (TREE_TYPE (t)))
              {
                pp_string (buffer, "--  skipped incomplete struct ");
-               dump_generic_ada_node (buffer, t, type, spc, false, true);
+               dump_ada_node (buffer, t, type, spc, false, true);
                return 1;
              }
 
@@ -2801,7 +2798,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
                    || *IDENTIFIER_POINTER (decl_name) == '$'))
              {
                pp_string (buffer, "--  skipped anonymous struct ");
-               dump_generic_ada_node (buffer, t, type, spc, false, true);
+               dump_ada_node (buffer, t, type, spc, false, true);
                TREE_VISITED (t) = 1;
                return 1;
              }
@@ -2816,7 +2813,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
                  {
                    is_class = true;
                    pp_string (buffer, "package Class_");
-                   dump_generic_ada_node (buffer, t, type, spc, false, true);
+                   dump_ada_node (buffer, t, type, spc, false, true);
                    pp_string (buffer, " is");
                    spc += INDENT_INCR;
                    newline_and_indent (buffer, spc);
@@ -2840,7 +2837,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
 
          case FUNCTION_TYPE:
            pp_string (buffer, "--  skipped function type ");
-           dump_generic_ada_node (buffer, t, type, spc, false, true);
+           dump_ada_node (buffer, t, type, spc, false, true);
            return 1;
 
          case ENUMERAL_TYPE:
@@ -2873,15 +2870,14 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
        INDENT (spc);
 
       /* Print variable's name.  */
-      dump_generic_ada_node (buffer, t, type, spc, false, true);
+      dump_ada_node (buffer, t, type, spc, false, true);
 
       if (TREE_CODE (t) == TYPE_DECL)
        {
          pp_string (buffer, " is ");
 
          if (orig && TYPE_NAME (orig))
-           dump_generic_ada_node
-             (buffer, TYPE_NAME (orig), type, spc, false, true);
+           dump_ada_node (buffer, TYPE_NAME (orig), type, spc, false, true);
          else
            dump_ada_array_type (buffer, t, type, spc);
        }
@@ -2898,7 +2894,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
            pp_string (buffer, "aliased ");
 
          if (tmp)
-           dump_generic_ada_node (buffer, tmp, type, spc, false, true);
+           dump_ada_node (buffer, tmp, type, spc, false, true);
          else if (type)
            dump_ada_double_name (buffer, type, t);
          else
@@ -3022,7 +3018,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
        INDENT (spc);
 
       /* Anonymous structs/unions.  */
-      dump_generic_ada_node (buffer, TREE_TYPE (t), t, spc, false, true);
+      dump_ada_node (buffer, TREE_TYPE (t), t, spc, false, true);
 
       if (TREE_CODE (TREE_TYPE (t)) == UNION_TYPE)
        pp_string (buffer, " (discr : unsigned := 0)");
@@ -3068,9 +3064,9 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
          dump_sloc (buffer, t);
          newline_and_indent (buffer, spc);
          pp_string (buffer, "pragma Import (CPP, ");
-         dump_generic_ada_node
-           (buffer, TYPE_NAME (TREE_TYPE (t)), type, spc, false, true);
-         pp_right_paren (buffer);
+         dump_ada_node (buffer, TYPE_NAME (TREE_TYPE (t)), type, spc, false,
+                        true);
+         pp_right_paren (buffer);
 
          dump_ada_methods (buffer, TREE_TYPE (t), spc);
        }
@@ -3078,7 +3074,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
        {
          if (is_abstract_record)
            pp_string (buffer, "abstract ");
-         dump_generic_ada_node (buffer, t, t, spc, false, false);
+         dump_ada_node (buffer, t, t, spc, false, false);
        }
     }
   else
@@ -3090,7 +3086,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
        check_name (buffer, t);
 
       /* Print variable/type's name.  */
-      dump_generic_ada_node (buffer, t, t, spc, false, true);
+      dump_ada_node (buffer, t, t, spc, false, true);
 
       if (TREE_CODE (t) == TYPE_DECL)
        {
@@ -3101,7 +3097,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
 
          pp_string (buffer, " is ");
 
-         dump_generic_ada_node (buffer, orig, t, spc, false, is_subtype);
+         dump_ada_node (buffer, orig, t, spc, false, is_subtype);
        }
       else
        {
@@ -3118,8 +3114,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
                pp_string (buffer, "constant ");
 
              if (TYPE_NAME (TREE_TYPE (t)))
-               dump_generic_ada_node
-                 (buffer, TREE_TYPE (t), t, spc, false, true);
+               dump_ada_node (buffer, TREE_TYPE (t), t, spc, false, true);
              else if (type)
                dump_ada_double_name (buffer, type, t);
            }
@@ -3133,8 +3128,8 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
              if (TREE_READONLY (t) && TREE_CODE (t) != FIELD_DECL)
                pp_string (buffer, "constant ");
 
-             dump_generic_ada_node
-               (buffer, TREE_TYPE (t), TREE_TYPE (t), spc, false, true);
+             dump_ada_node (buffer, TREE_TYPE (t), TREE_TYPE (t), spc, false,
+                            true);
            }
        }
     }
@@ -3146,7 +3141,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
       pp_string (buffer, "end;");
       newline_and_indent (buffer, spc);
       pp_string (buffer, "use Class_");
-      dump_generic_ada_node (buffer, t, type, spc, false, true);
+      dump_ada_node (buffer, t, type, spc, false, true);
       pp_semicolon (buffer);
       pp_newline (buffer);
 
@@ -3173,8 +3168,8 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
    true, also print the pragma Convention for NODE.  */
 
 static void
-dump_ada_struct_decl (pretty_printer *buffer, tree node, tree type, int spc,
-                      bool display_convention)
+dump_ada_structure (pretty_printer *buffer, tree node, tree type, int spc,
+                   bool display_convention)
 {
   tree tmp;
   const bool is_union = (TREE_CODE (node) == UNION_TYPE);
@@ -3288,7 +3283,7 @@ dump_ada_struct_decl (pretty_printer *buffer, tree node, tree type, int spc,
     pp_string (buffer, "pragma Convention (C, ");
 
   package_prefix = false;
-  dump_generic_ada_node (buffer, TREE_TYPE (type), type, spc, false, true);
+  dump_ada_node (buffer, TREE_TYPE (type), type, spc, false, true);
   package_prefix = true;
   pp_right_paren (buffer);
 
@@ -3298,7 +3293,7 @@ dump_ada_struct_decl (pretty_printer *buffer, tree node, tree type, int spc,
       newline_and_indent (buffer, spc);
       pp_string (buffer, "pragma Unchecked_Union (");
 
-      dump_generic_ada_node (buffer, TREE_TYPE (type), type, spc, false, true);
+      dump_ada_node (buffer, TREE_TYPE (type), type, spc, false, true);
       pp_right_paren (buffer);
     }
 
@@ -3307,8 +3302,7 @@ dump_ada_struct_decl (pretty_printer *buffer, tree node, tree type, int spc,
       pp_semicolon (buffer);
       newline_and_indent (buffer, spc);
       pp_string (buffer, "pragma Pack (");
-      dump_generic_ada_node
-       (buffer, TREE_TYPE (type), type, spc, false, true);
+      dump_ada_node (buffer, TREE_TYPE (type), type, spc, false, true);
       pp_right_paren (buffer);
       bitfield_used = false;
     }