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