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