gcc/c-aux-info.c

   1 /* Generate information regarding function declarations and definitions based
   2    on information stored in GCC's tree structure.  This code implements the
   3    -aux-info option.
   4    Copyright (C) 1989, 91, 94, 95, 97, 1998 Free Software Foundation, Inc.
   5    Contributed by Ron Guilmette (rfg@segfault.us.com).
   6
   7 This file is part of GNU CC.
   8
   9 GNU CC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GNU CC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU CC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.  */
  23
  24 #include "config.h"
  25 #include <stdio.h>
  26 #ifdef HAVE_STRING_H
  27 # include <string.h>
  28 #else
  29 # ifdef HAVE_STRINGS_H
  30 #  include <strings.h>
  31 #endif
  32 #endif
  33 #include "flags.h"
  34 #include "tree.h"
  35 #include "c-tree.h"
  36
  37 extern char *xmalloc ();
  38
  39 enum formals_style_enum {
  40   ansi,
  41   k_and_r_names,
  42   k_and_r_decls
  43 };
  44 typedef enum formals_style_enum formals_style;
  45
  46
  47 static char *data_type;
  48
  49 static char *concat                     PROTO((char *, char *));
  50 static char *concat3                    PROTO((char *, char *, char *));
  51 static char *affix_data_type            PROTO((char *));
  52 static char *gen_formal_list_for_type   PROTO((tree, formals_style));
  53 static int   deserves_ellipsis          PROTO((tree));
  54 static char *gen_formal_list_for_func_def PROTO((tree, formals_style));
  55 static char *gen_type                   PROTO((char *, tree, formals_style));
  56 static char *gen_decl                   PROTO((tree, int, formals_style));
  57 \f
  58 /*  Take two strings and mash them together into a newly allocated area.  */
  59
  60 static char *
  61 concat (s1, s2)
  62      char *s1;
  63      char *s2;
  64 {
  65   int size1, size2;
  66   char *ret_val;
  67
  68   if (!s1)
  69     s1 = "";
  70   if (!s2)
  71     s2 = "";
  72
  73   size1 = strlen (s1);
  74   size2 = strlen (s2);
  75   ret_val = xmalloc (size1 + size2 + 1);
  76   strcpy (ret_val, s1);
  77   strcpy (&ret_val[size1], s2);
  78   return ret_val;
  79 }
  80
  81 /*  Take three strings and mash them together into a newly allocated area.  */
  82
  83 static char *
  84 concat3 (s1, s2, s3)
  85      char *s1;
  86      char *s2;
  87      char *s3;
  88 {
  89   int size1, size2, size3;
  90   char *ret_val;
  91
  92   if (!s1)
  93     s1 = "";
  94   if (!s2)
  95     s2 = "";
  96   if (!s3)
  97     s3 = "";
  98
  99   size1 = strlen (s1);
 100   size2 = strlen (s2);
 101   size3 = strlen (s3);
 102   ret_val = xmalloc (size1 + size2 + size3 + 1);
 103   strcpy (ret_val, s1);
 104   strcpy (&ret_val[size1], s2);
 105   strcpy (&ret_val[size1+size2], s3);
 106   return ret_val;
 107 }
 108
 109 /* Given a string representing an entire type or an entire declaration
 110    which only lacks the actual "data-type" specifier (at its left end),
 111    affix the data-type specifier to the left end of the given type
 112    specification or object declaration.
 113
 114    Because of C language weirdness, the data-type specifier (which normally
 115    goes in at the very left end) may have to be slipped in just to the
 116    right of any leading "const" or "volatile" qualifiers (there may be more
 117    than one).  Actually this may not be strictly necessary because it seems
 118    that GCC (at least) accepts `<data-type> const foo;' and treats it the
 119    same as `const <data-type> foo;' but people are accustomed to seeing
 120    `const char *foo;' and *not* `char const *foo;' so we try to create types
 121    that look as expected.  */
 122
 123 static char *
 124 affix_data_type (type_or_decl)
 125      char *type_or_decl;
 126 {
 127   char *p = type_or_decl;
 128   char *qualifiers_then_data_type;
 129   char saved;
 130
 131   /* Skip as many leading const's or volatile's as there are.  */
 132
 133   for (;;)
 134     {
 135       if (!strncmp (p, "volatile ", 9))
 136         {
 137           p += 9;
 138           continue;
 139         }
 140       if (!strncmp (p, "const ", 6))
 141         {
 142           p += 6;
 143           continue;
 144         }
 145       break;
 146     }
 147
 148   /* p now points to the place where we can insert the data type.  We have to
 149      add a blank after the data-type of course.  */
 150
 151   if (p == type_or_decl)
 152     return concat3 (data_type, " ", type_or_decl);
 153
 154   saved = *p;
 155   *p = '\0';
 156   qualifiers_then_data_type = concat (type_or_decl, data_type);
 157   *p = saved;
 158   return concat3 (qualifiers_then_data_type, " ", p);
 159 }
 160
 161 /* Given a tree node which represents some "function type", generate the
 162    source code version of a formal parameter list (of some given style) for
 163    this function type.  Return the whole formal parameter list (including
 164    a pair of surrounding parens) as a string.   Note that if the style
 165    we are currently aiming for is non-ansi, then we just return a pair
 166    of empty parens here.  */
 167
 168 static char *
 169 gen_formal_list_for_type (fntype, style)
 170      tree fntype;
 171      formals_style style;
 172 {
 173   char *formal_list = "";
 174   tree formal_type;
 175
 176   if (style != ansi)
 177     return "()";
 178
 179   formal_type = TYPE_ARG_TYPES (fntype);
 180   while (formal_type && TREE_VALUE (formal_type) != void_type_node)
 181     {
 182       char *this_type;
 183
 184       if (*formal_list)
 185         formal_list = concat (formal_list, ", ");
 186
 187       this_type = gen_type ("", TREE_VALUE (formal_type), ansi);
 188       formal_list
 189         = ((strlen (this_type))
 190            ? concat (formal_list, affix_data_type (this_type))
 191            : concat (formal_list, data_type));
 192
 193       formal_type = TREE_CHAIN (formal_type);
 194     }
 195
 196   /* If we got to here, then we are trying to generate an ANSI style formal
 197      parameters list.
 198
 199      New style prototyped ANSI formal parameter lists should in theory always
 200      contain some stuff between the opening and closing parens, even if it is
 201      only "void".
 202
 203      The brutal truth though is that there is lots of old K&R code out there
 204      which contains declarations of "pointer-to-function" parameters and
 205      these almost never have fully specified formal parameter lists associated
 206      with them.  That is, the pointer-to-function parameters are declared
 207      with just empty parameter lists.
 208
 209      In cases such as these, protoize should really insert *something* into
 210      the vacant parameter lists, but what?  It has no basis on which to insert
 211      anything in particular.
 212
 213      Here, we make life easy for protoize by trying to distinguish between
 214      K&R empty parameter lists and new-style prototyped parameter lists
 215      that actually contain "void".  In the latter case we (obviously) want
 216      to output the "void" verbatim, and that what we do.  In the former case,
 217      we do our best to give protoize something nice to insert.
 218
 219      This "something nice" should be something that is still valid (when
 220      re-compiled) but something that can clearly indicate to the user that
 221      more typing information (for the parameter list) should be added (by
 222      hand) at some convenient moment.
 223
 224      The string chosen here is a comment with question marks in it.  */
 225
 226   if (!*formal_list)
 227     {
 228       if (TYPE_ARG_TYPES (fntype))
 229         /* assert (TREE_VALUE (TYPE_ARG_TYPES (fntype)) == void_type_node);  */
 230         formal_list = "void";
 231       else
 232         formal_list = "/* ??? */";
 233     }
 234   else
 235     {
 236       /* If there were at least some parameters, and if the formals-types-list
 237          petered out to a NULL (i.e. without being terminated by a
 238          void_type_node) then we need to tack on an ellipsis.  */
 239       if (!formal_type)
 240         formal_list = concat (formal_list, ", ...");
 241     }
 242
 243   return concat3 (" (", formal_list, ")");
 244 }
 245
 246 /* For the generation of an ANSI prototype for a function definition, we have
 247    to look at the formal parameter list of the function's own "type" to
 248    determine if the function's formal parameter list should end with an
 249    ellipsis.  Given a tree node, the following function will return non-zero
 250    if the "function type" parameter list should end with an ellipsis.  */
 251
 252 static int
 253 deserves_ellipsis (fntype)
 254      tree fntype;
 255 {
 256   tree formal_type;
 257
 258   formal_type = TYPE_ARG_TYPES (fntype);
 259   while (formal_type && TREE_VALUE (formal_type) != void_type_node)
 260     formal_type = TREE_CHAIN (formal_type);
 261
 262   /* If there were at least some parameters, and if the formals-types-list
 263      petered out to a NULL (i.e. without being terminated by a void_type_node)
 264      then we need to tack on an ellipsis.  */
 265
 266   return (!formal_type && TYPE_ARG_TYPES (fntype));
 267 }
 268
 269 /* Generate a parameter list for a function definition (in some given style).
 270
 271    Note that this routine has to be separate (and different) from the code that
 272    generates the prototype parameter lists for function declarations, because
 273    in the case of a function declaration, all we have to go on is a tree node
 274    representing the function's own "function type".  This can tell us the types
 275    of all of the formal parameters for the function, but it cannot tell us the
 276    actual *names* of each of the formal parameters.  We need to output those
 277    parameter names for each function definition.
 278
 279    This routine gets a pointer to a tree node which represents the actual
 280    declaration of the given function, and this DECL node has a list of formal
 281    parameter (variable) declarations attached to it.  These formal parameter
 282    (variable) declaration nodes give us the actual names of the formal
 283    parameters for the given function definition.
 284
 285    This routine returns a string which is the source form for the entire
 286    function formal parameter list.  */
 287
 288 static char *
 289 gen_formal_list_for_func_def (fndecl, style)
 290      tree fndecl;
 291      formals_style style;
 292 {
 293   char *formal_list = "";
 294   tree formal_decl;
 295
 296   formal_decl = DECL_ARGUMENTS (fndecl);
 297   while (formal_decl)
 298     {
 299       char *this_formal;
 300
 301       if (*formal_list && ((style == ansi) || (style == k_and_r_names)))
 302         formal_list = concat (formal_list, ", ");
 303       this_formal = gen_decl (formal_decl, 0, style);
 304       if (style == k_and_r_decls)
 305         formal_list = concat3 (formal_list, this_formal, "; ");
 306       else
 307         formal_list = concat (formal_list, this_formal);
 308       formal_decl = TREE_CHAIN (formal_decl);
 309     }
 310   if (style == ansi)
 311     {
 312       if (!DECL_ARGUMENTS (fndecl))
 313         formal_list = concat (formal_list, "void");
 314       if (deserves_ellipsis (TREE_TYPE (fndecl)))
 315         formal_list = concat (formal_list, ", ...");
 316     }
 317   if ((style == ansi) || (style == k_and_r_names))
 318     formal_list = concat3 (" (", formal_list, ")");
 319   return formal_list;
 320 }
 321
 322 /* Generate a string which is the source code form for a given type (t).  This
 323    routine is ugly and complex because the C syntax for declarations is ugly
 324    and complex.  This routine is straightforward so long as *no* pointer types,
 325    array types, or function types are involved.
 326
 327    In the simple cases, this routine will return the (string) value which was
 328    passed in as the "ret_val" argument.  Usually, this starts out either as an
 329    empty string, or as the name of the declared item (i.e. the formal function
 330    parameter variable).
 331
 332    This routine will also return with the global variable "data_type" set to
 333    some string value which is the "basic" data-type of the given complete type.
 334    This "data_type" string can be concatenated onto the front of the returned
 335    string after this routine returns to its caller.
 336
 337    In complicated cases involving pointer types, array types, or function
 338    types, the C declaration syntax requires an "inside out" approach, i.e. if
 339    you have a type which is a "pointer-to-function" type, you need to handle
 340    the "pointer" part first, but it also has to be "innermost" (relative to
 341    the declaration stuff for the "function" type).  Thus, is this case, you
 342    must prepend a "(*" and append a ")" to the name of the item (i.e. formal
 343    variable).  Then you must append and prepend the other info for the
 344    "function type" part of the overall type.
 345
 346    To handle the "innermost precedence" rules of complicated C declarators, we
 347    do the following (in this routine).  The input parameter called "ret_val"
 348    is treated as a "seed".  Each time gen_type is called (perhaps recursively)
 349    some additional strings may be appended or prepended (or both) to the "seed"
 350    string.  If yet another (lower) level of the GCC tree exists for the given
 351    type (as in the case of a pointer type, an array type, or a function type)
 352    then the (wrapped) seed is passed to a (recursive) invocation of gen_type()
 353    this recursive invocation may again "wrap" the (new) seed with yet more
 354    declarator stuff, by appending, prepending (or both).  By the time the
 355    recursion bottoms out, the "seed value" at that point will have a value
 356    which is (almost) the complete source version of the declarator (except
 357    for the data_type info).  Thus, this deepest "seed" value is simply passed
 358    back up through all of the recursive calls until it is given (as the return
 359    value) to the initial caller of the gen_type() routine.  All that remains
 360    to do at this point is for the initial caller to prepend the "data_type"
 361    string onto the returned "seed".  */
 362
 363 static char *
 364 gen_type (ret_val, t, style)
 365      char *ret_val;
 366      tree t;
 367      formals_style style;
 368 {
 369   tree chain_p;
 370
 371   if (TYPE_NAME (t) && DECL_NAME (TYPE_NAME (t)))
 372     data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
 373   else
 374     {
 375       switch (TREE_CODE (t))
 376         {
 377         case POINTER_TYPE:
 378           if (TYPE_READONLY (t))
 379             ret_val = concat ("const ", ret_val);
 380           if (TYPE_VOLATILE (t))
 381             ret_val = concat ("volatile ", ret_val);
 382
 383           ret_val = concat ("*", ret_val);
 384
 385           if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
 386             ret_val = concat3 ("(", ret_val, ")");
 387
 388           ret_val = gen_type (ret_val, TREE_TYPE (t), style);
 389
 390           return ret_val;
 391
 392         case ARRAY_TYPE:
 393           if (TYPE_SIZE (t) == 0 || TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
 394             ret_val = gen_type (concat (ret_val, "[]"), TREE_TYPE (t), style);
 395           else if (int_size_in_bytes (t) == 0)
 396             ret_val = gen_type (concat (ret_val, "[0]"), TREE_TYPE (t), style);
 397           else
 398             {
 399               int size = (int_size_in_bytes (t) / int_size_in_bytes (TREE_TYPE (t)));
 400               char buff[10];
 401               sprintf (buff, "[%d]", size);
 402               ret_val = gen_type (concat (ret_val, buff),
 403                                   TREE_TYPE (t), style);
 404             }
 405           break;
 406
 407         case FUNCTION_TYPE:
 408           ret_val = gen_type (concat (ret_val, gen_formal_list_for_type (t, style)), TREE_TYPE (t), style);
 409           break;
 410
 411         case IDENTIFIER_NODE:
 412           data_type = IDENTIFIER_POINTER (t);
 413           break;
 414
 415         /* The following three cases are complicated by the fact that a
 416            user may do something really stupid, like creating a brand new
 417            "anonymous" type specification in a formal argument list (or as
 418            part of a function return type specification).  For example:
 419
 420                 int f (enum { red, green, blue } color);
 421
 422            In such cases, we have no name that we can put into the prototype
 423            to represent the (anonymous) type.  Thus, we have to generate the
 424            whole darn type specification.  Yuck!  */
 425
 426         case RECORD_TYPE:
 427           if (TYPE_NAME (t))
 428             data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
 429           else
 430             {
 431               data_type = "";
 432               chain_p = TYPE_FIELDS (t);
 433               while (chain_p)
 434                 {
 435                   data_type = concat (data_type, gen_decl (chain_p, 0, ansi));
 436                   chain_p = TREE_CHAIN (chain_p);
 437                   data_type = concat (data_type, "; ");
 438                 }
 439               data_type = concat3 ("{ ", data_type, "}");
 440             }
 441           data_type = concat ("struct ", data_type);
 442           break;
 443
 444         case UNION_TYPE:
 445           if (TYPE_NAME (t))
 446             data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
 447           else
 448             {
 449               data_type = "";
 450               chain_p = TYPE_FIELDS (t);
 451               while (chain_p)
 452                 {
 453                   data_type = concat (data_type, gen_decl (chain_p, 0, ansi));
 454                   chain_p = TREE_CHAIN (chain_p);
 455                   data_type = concat (data_type, "; ");
 456                 }
 457               data_type = concat3 ("{ ", data_type, "}");
 458             }
 459           data_type = concat ("union ", data_type);
 460           break;
 461
 462         case ENUMERAL_TYPE:
 463           if (TYPE_NAME (t))
 464             data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
 465           else
 466             {
 467               data_type = "";
 468               chain_p = TYPE_VALUES (t);
 469               while (chain_p)
 470                 {
 471                   data_type = concat (data_type,
 472                         IDENTIFIER_POINTER (TREE_PURPOSE (chain_p)));
 473                   chain_p = TREE_CHAIN (chain_p);
 474                   if (chain_p)
 475                     data_type = concat (data_type, ", ");
 476                 }
 477               data_type = concat3 ("{ ", data_type, " }");
 478             }
 479           data_type = concat ("enum ", data_type);
 480           break;
 481
 482         case TYPE_DECL:
 483           data_type = IDENTIFIER_POINTER (DECL_NAME (t));
 484           break;
 485
 486         case INTEGER_TYPE:
 487           data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
 488           /* Normally, `unsigned' is part of the deal.  Not so if it comes
 489              with `const' or `volatile'.  */
 490           if (TREE_UNSIGNED (t) && (TYPE_READONLY (t) || TYPE_VOLATILE (t)))
 491             data_type = concat ("unsigned ", data_type);
 492           break;
 493
 494         case REAL_TYPE:
 495           data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
 496           break;
 497
 498         case VOID_TYPE:
 499           data_type = "void";
 500           break;
 501
 502         case ERROR_MARK:
 503           data_type = "[ERROR]";
 504           break;
 505
 506         default:
 507           abort ();
 508         }
 509     }
 510   if (TYPE_READONLY (t))
 511     ret_val = concat ("const ", ret_val);
 512   if (TYPE_VOLATILE (t))
 513     ret_val = concat ("volatile ", ret_val);
 514   return ret_val;
 515 }
 516
 517 /* Generate a string (source) representation of an entire entity declaration
 518    (using some particular style for function types).
 519
 520    The given entity may be either a variable or a function.
 521
 522    If the "is_func_definition" parameter is non-zero, assume that the thing
 523    we are generating a declaration for is a FUNCTION_DECL node which is
 524    associated with a function definition.  In this case, we can assume that
 525    an attached list of DECL nodes for function formal arguments is present.  */
 526
 527 static char *
 528 gen_decl (decl, is_func_definition, style)
 529      tree decl;
 530      int is_func_definition;
 531      formals_style style;
 532 {
 533   char *ret_val;
 534
 535   if (DECL_NAME (decl))
 536     ret_val = IDENTIFIER_POINTER (DECL_NAME (decl));
 537   else
 538     ret_val = "";
 539
 540   /* If we are just generating a list of names of formal parameters, we can
 541      simply return the formal parameter name (with no typing information
 542      attached to it) now.  */
 543
 544   if (style == k_and_r_names)
 545     return ret_val;
 546
 547   /* Note that for the declaration of some entity (either a function or a
 548      data object, like for instance a parameter) if the entity itself was
 549      declared as either const or volatile, then const and volatile properties
 550      are associated with just the declaration of the entity, and *not* with
 551      the `type' of the entity.  Thus, for such declared entities, we have to
 552      generate the qualifiers here.  */
 553
 554   if (TREE_THIS_VOLATILE (decl))
 555     ret_val = concat ("volatile ", ret_val);
 556   if (TREE_READONLY (decl))
 557     ret_val = concat ("const ", ret_val);
 558
 559   data_type = "";
 560
 561   /* For FUNCTION_DECL nodes, there are two possible cases here.  First, if
 562      this FUNCTION_DECL node was generated from a function "definition", then
 563      we will have a list of DECL_NODE's, one for each of the function's formal
 564      parameters.  In this case, we can print out not only the types of each
 565      formal, but also each formal's name.  In the second case, this
 566      FUNCTION_DECL node came from an actual function declaration (and *not*
 567      a definition).  In this case, we do nothing here because the formal
 568      argument type-list will be output later, when the "type" of the function
 569      is added to the string we are building.  Note that the ANSI-style formal
 570      parameter list is considered to be a (suffix) part of the "type" of the
 571      function.  */
 572
 573   if (TREE_CODE (decl) == FUNCTION_DECL && is_func_definition)
 574     {
 575       ret_val = concat (ret_val, gen_formal_list_for_func_def (decl, ansi));
 576
 577       /* Since we have already added in the formals list stuff, here we don't
 578          add the whole "type" of the function we are considering (which
 579          would include its parameter-list info), rather, we only add in
 580          the "type" of the "type" of the function, which is really just
 581          the return-type of the function (and does not include the parameter
 582          list info).  */
 583
 584       ret_val = gen_type (ret_val, TREE_TYPE (TREE_TYPE (decl)), style);
 585     }
 586   else
 587     ret_val = gen_type (ret_val, TREE_TYPE (decl), style);
 588
 589   ret_val = affix_data_type (ret_val);
 590
 591   if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
 592     ret_val = concat ("register ", ret_val);
 593   if (TREE_PUBLIC (decl))
 594     ret_val = concat ("extern ", ret_val);
 595   if (TREE_CODE (decl) == FUNCTION_DECL && !TREE_PUBLIC (decl))
 596     ret_val = concat ("static ", ret_val);
 597
 598   return ret_val;
 599 }
 600
 601 extern FILE *aux_info_file;
 602
 603 /* Generate and write a new line of info to the aux-info (.X) file.  This
 604    routine is called once for each function declaration, and once for each
 605    function definition (even the implicit ones).  */
 606
 607 void
 608 gen_aux_info_record (fndecl, is_definition, is_implicit, is_prototyped)
 609      tree fndecl;
 610      int is_definition;
 611      int is_implicit;
 612      int is_prototyped;
 613 {
 614   if (flag_gen_aux_info)
 615     {
 616       static int compiled_from_record = 0;
 617
 618       /* Each output .X file must have a header line.  Write one now if we
 619          have not yet done so.  */
 620
 621       if (! compiled_from_record++)
 622         {
 623           /* The first line tells which directory file names are relative to.
 624              Currently, -aux-info works only for files in the working
 625              directory, so just use a `.' as a placeholder for now.  */
 626           fprintf (aux_info_file, "/* compiled from: . */\n");
 627         }
 628
 629       /* Write the actual line of auxiliary info.  */
 630
 631       fprintf (aux_info_file, "/* %s:%d:%c%c */ %s;",
 632                DECL_SOURCE_FILE (fndecl),
 633                DECL_SOURCE_LINE (fndecl),
 634                (is_implicit) ? 'I' : (is_prototyped) ? 'N' : 'O',
 635                (is_definition) ? 'F' : 'C',
 636                gen_decl (fndecl, is_definition, ansi));
 637
 638       /* If this is an explicit function declaration, we need to also write
 639          out an old-style (i.e. K&R) function header, just in case the user
 640          wants to run unprotoize.  */
 641
 642       if (is_definition)
 643         {
 644           fprintf (aux_info_file, " /*%s %s*/",
 645                    gen_formal_list_for_func_def (fndecl, k_and_r_names),
 646                    gen_formal_list_for_func_def (fndecl, k_and_r_decls));
 647         }
 648
 649       fprintf (aux_info_file, "\n");
 650     }
 651 }