Mercurial > hg > CbC > CbC_gcc
annotate gcc/c-aux-info.c @ 88:f214c1d5b862
merge 89
| author | Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Tue, 20 Dec 2011 18:53:46 +0900 |
| parents | f6334be47118 |
| children |
| rev | line source |
|---|---|
| 0 | 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, | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
5 1999, 2000, 2003, 2004, 2007, 2010 Free Software Foundation, Inc. |
| 0 | 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 | |
| 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 { | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
166 if (prototype_p (fntype)) |
| 0 | 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); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
227 if (stdarg_p (TREE_TYPE (fndecl))) |
| 0 | 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 } |