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