c-aux-info.c revision 18334
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 7This file is part of GNU CC. 8 9GNU CC is free software; you can redistribute it and/or modify 10it under the terms of the GNU General Public License as published by 11the Free Software Foundation; either version 2, or (at your option) 12any later version. 13 14GNU CC is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along with GNU CC; see the file COPYING. If not, write to 21the Free Software Foundation, 59 Temple Place - Suite 330, 22Boston, 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 30extern char* xmalloc (); 31 32enum formals_style_enum { 33 ansi, 34 k_and_r_names, 35 k_and_r_decls 36}; 37typedef enum formals_style_enum formals_style; 38 39 40static char* data_type; 41 42static char * concat (); 43static char * concat3 (); 44static char * gen_formal_list_for_type (); 45static int deserves_ellipsis (); 46static char * gen_formal_list_for_func_def (); 47static char * gen_type (); 48static char * gen_decl (); 49void gen_aux_info_record (); 50 51/* Take two strings and mash them together into a newly allocated area. */ 52 53static char* 54concat (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 76static char* 77concat3 (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 116static char* 117affix_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 161static char* 162gen_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 245static int 246deserves_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 281static char* 282gen_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 356static char* 357gen_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 520static char* 521gen_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 (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 594extern 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 600void 601gen_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} 645