Branch data Line data Source code
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-2024 Free Software Foundation, Inc.
5 : : Contributed by Ron Guilmette (rfg@segfault.us.com).
6 : :
7 : : This file is part of GCC.
8 : :
9 : : GCC is free software; you can redistribute it and/or modify it under
10 : : the terms of the GNU General Public License as published by the Free
11 : : Software Foundation; either version 3, or (at your option) any later
12 : : version.
13 : :
14 : : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 : : WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 : : for more details.
18 : :
19 : : You should have received a copy of the GNU General Public License
20 : : along 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 : :
29 : : enum formals_style {
30 : : ansi,
31 : : k_and_r_names,
32 : : k_and_r_decls
33 : : };
34 : :
35 : :
36 : : static const char *data_type;
37 : :
38 : : static char *affix_data_type (const char *) ATTRIBUTE_MALLOC;
39 : : static const char *gen_formal_list_for_type (tree, formals_style);
40 : : static const char *gen_formal_list_for_func_def (tree, formals_style);
41 : : static const char *gen_type (const char *, tree, formals_style);
42 : : static 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 : :
58 : : static char *
59 : 0 : affix_data_type (const char *param)
60 : : {
61 : 0 : char *const type_or_decl = ASTRDUP (param);
62 : 0 : char *p = type_or_decl;
63 : 0 : char *qualifiers_then_data_type;
64 : 0 : char saved;
65 : :
66 : : /* Skip as many leading const's or volatile's as there are. */
67 : :
68 : 0 : for (;;)
69 : : {
70 : 0 : if (startswith (p, "volatile "))
71 : : {
72 : 0 : p += 9;
73 : 0 : continue;
74 : : }
75 : 0 : if (startswith (p, "const "))
76 : : {
77 : 0 : p += 6;
78 : 0 : continue;
79 : : }
80 : 0 : 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 : 0 : if (p == type_or_decl)
87 : 0 : return concat (data_type, " ", type_or_decl, NULL);
88 : :
89 : 0 : saved = *p;
90 : 0 : *p = '\0';
91 : 0 : qualifiers_then_data_type = concat (type_or_decl, data_type, NULL);
92 : 0 : *p = saved;
93 : 0 : return reconcat (qualifiers_then_data_type,
94 : 0 : 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 : :
104 : : static const char *
105 : 0 : gen_formal_list_for_type (tree fntype, formals_style style)
106 : : {
107 : 0 : const char *formal_list = "";
108 : 0 : tree formal_type;
109 : :
110 : 0 : if (style != ansi)
111 : : return "()";
112 : :
113 : 0 : formal_type = TYPE_ARG_TYPES (fntype);
114 : 0 : while (formal_type && TREE_VALUE (formal_type) != void_type_node)
115 : : {
116 : 0 : const char *this_type;
117 : :
118 : 0 : if (*formal_list)
119 : 0 : formal_list = concat (formal_list, ", ", NULL);
120 : :
121 : 0 : this_type = gen_type ("", TREE_VALUE (formal_type), ansi);
122 : 0 : formal_list
123 : 0 : = ((strlen (this_type))
124 : 0 : ? concat (formal_list, affix_data_type (this_type), NULL)
125 : 0 : : concat (formal_list, data_type, NULL));
126 : :
127 : 0 : 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 : 0 : if (!*formal_list)
161 : : {
162 : 0 : if (prototype_p (fntype))
163 : : /* assert (TREE_VALUE (TYPE_ARG_TYPES (fntype)) == void_type_node); */
164 : : formal_list = "void";
165 : : else
166 : 0 : 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 : 0 : if (!formal_type)
174 : 0 : formal_list = concat (formal_list, ", ...", NULL);
175 : : }
176 : :
177 : 0 : 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 : :
199 : : static const char *
200 : 0 : gen_formal_list_for_func_def (tree fndecl, formals_style style)
201 : : {
202 : 0 : const char *formal_list = "";
203 : 0 : tree formal_decl;
204 : :
205 : 0 : formal_decl = DECL_ARGUMENTS (fndecl);
206 : 0 : while (formal_decl)
207 : : {
208 : 0 : const char *this_formal;
209 : :
210 : 0 : if (*formal_list && ((style == ansi) || (style == k_and_r_names)))
211 : 0 : formal_list = concat (formal_list, ", ", NULL);
212 : 0 : this_formal = gen_decl (formal_decl, 0, style);
213 : 0 : if (style == k_and_r_decls)
214 : 0 : formal_list = concat (formal_list, this_formal, "; ", NULL);
215 : : else
216 : 0 : formal_list = concat (formal_list, this_formal, NULL);
217 : 0 : formal_decl = TREE_CHAIN (formal_decl);
218 : : }
219 : 0 : if (style == ansi)
220 : : {
221 : 0 : if (!DECL_ARGUMENTS (fndecl))
222 : 0 : formal_list = concat (formal_list, "void", NULL);
223 : 0 : if (stdarg_p (TREE_TYPE (fndecl)))
224 : 0 : formal_list = concat (formal_list, ", ...", NULL);
225 : : }
226 : 0 : if ((style == ansi) || (style == k_and_r_names))
227 : 0 : formal_list = concat (" (", formal_list, ")", NULL);
228 : 0 : 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 : :
272 : : static const char *
273 : 0 : gen_type (const char *ret_val, tree t, formals_style style)
274 : : {
275 : 0 : tree chain_p;
276 : :
277 : : /* If there is a typedef name for this type, use it. */
278 : 0 : if (TYPE_NAME (t) && TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
279 : 0 : data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
280 : : else
281 : : {
282 : 0 : switch (TREE_CODE (t))
283 : : {
284 : 0 : case POINTER_TYPE:
285 : 0 : if (TYPE_ATOMIC (t))
286 : 0 : ret_val = concat ("_Atomic ", ret_val, NULL);
287 : 0 : if (TYPE_READONLY (t))
288 : 0 : ret_val = concat ("const ", ret_val, NULL);
289 : 0 : if (TYPE_VOLATILE (t))
290 : 0 : ret_val = concat ("volatile ", ret_val, NULL);
291 : :
292 : 0 : ret_val = concat ("*", ret_val, NULL);
293 : :
294 : 0 : if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
295 : 0 : ret_val = concat ("(", ret_val, ")", NULL);
296 : :
297 : 0 : ret_val = gen_type (ret_val, TREE_TYPE (t), style);
298 : :
299 : 0 : return ret_val;
300 : :
301 : 0 : case ARRAY_TYPE:
302 : 0 : if (!COMPLETE_TYPE_P (t) || TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
303 : 0 : ret_val = gen_type (concat (ret_val, "[]", NULL),
304 : 0 : TREE_TYPE (t), style);
305 : 0 : else if (int_size_in_bytes (t) == 0)
306 : 0 : ret_val = gen_type (concat (ret_val, "[0]", NULL),
307 : 0 : TREE_TYPE (t), style);
308 : : else
309 : : {
310 : 0 : char buff[23];
311 : 0 : sprintf (buff, "[" HOST_WIDE_INT_PRINT_DEC"]",
312 : 0 : int_size_in_bytes (t)
313 : 0 : / int_size_in_bytes (TREE_TYPE (t)));
314 : 0 : ret_val = gen_type (concat (ret_val, buff, NULL),
315 : 0 : TREE_TYPE (t), style);
316 : : }
317 : : break;
318 : :
319 : 0 : case FUNCTION_TYPE:
320 : 0 : ret_val = gen_type (concat (ret_val,
321 : : gen_formal_list_for_type (t, style),
322 : : NULL),
323 : 0 : TREE_TYPE (t), style);
324 : 0 : break;
325 : :
326 : 0 : case IDENTIFIER_NODE:
327 : 0 : data_type = IDENTIFIER_POINTER (t);
328 : 0 : 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 : 0 : case RECORD_TYPE:
342 : 0 : if (TYPE_NAME (t))
343 : 0 : data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
344 : : else
345 : : {
346 : 0 : data_type = "";
347 : 0 : chain_p = TYPE_FIELDS (t);
348 : 0 : while (chain_p)
349 : : {
350 : 0 : data_type = concat (data_type, gen_decl (chain_p, 0, ansi),
351 : : NULL);
352 : 0 : chain_p = TREE_CHAIN (chain_p);
353 : 0 : data_type = concat (data_type, "; ", NULL);
354 : : }
355 : 0 : data_type = concat ("{ ", data_type, "}", NULL);
356 : : }
357 : 0 : data_type = concat ("struct ", data_type, NULL);
358 : 0 : break;
359 : :
360 : 0 : case UNION_TYPE:
361 : 0 : if (TYPE_NAME (t))
362 : 0 : data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
363 : : else
364 : : {
365 : 0 : data_type = "";
366 : 0 : chain_p = TYPE_FIELDS (t);
367 : 0 : while (chain_p)
368 : : {
369 : 0 : data_type = concat (data_type, gen_decl (chain_p, 0, ansi),
370 : : NULL);
371 : 0 : chain_p = TREE_CHAIN (chain_p);
372 : 0 : data_type = concat (data_type, "; ", NULL);
373 : : }
374 : 0 : data_type = concat ("{ ", data_type, "}", NULL);
375 : : }
376 : 0 : data_type = concat ("union ", data_type, NULL);
377 : 0 : break;
378 : :
379 : 0 : case ENUMERAL_TYPE:
380 : 0 : if (TYPE_NAME (t))
381 : 0 : data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
382 : : else
383 : : {
384 : 0 : data_type = "";
385 : 0 : chain_p = TYPE_VALUES (t);
386 : 0 : while (chain_p)
387 : : {
388 : 0 : data_type = concat (data_type,
389 : 0 : IDENTIFIER_POINTER (TREE_PURPOSE (chain_p)), NULL);
390 : 0 : chain_p = TREE_CHAIN (chain_p);
391 : 0 : if (chain_p)
392 : 0 : data_type = concat (data_type, ", ", NULL);
393 : : }
394 : 0 : data_type = concat ("{ ", data_type, " }", NULL);
395 : : }
396 : 0 : data_type = concat ("enum ", data_type, NULL);
397 : 0 : break;
398 : :
399 : 0 : case TYPE_DECL:
400 : 0 : data_type = IDENTIFIER_POINTER (DECL_NAME (t));
401 : 0 : break;
402 : :
403 : 0 : case INTEGER_TYPE:
404 : 0 : case FIXED_POINT_TYPE:
405 : 0 : 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 : 0 : if (TYPE_UNSIGNED (t) && TYPE_QUALS (t))
409 : 0 : data_type = concat ("unsigned ", data_type, NULL);
410 : : break;
411 : :
412 : 0 : case BITINT_TYPE:
413 : 0 : {
414 : 0 : char buf[sizeof ("2147483647")];
415 : 0 : sprintf (buf, "%d", TYPE_PRECISION (t));
416 : 0 : if (TYPE_UNSIGNED (t))
417 : 0 : data_type = concat ("unsigned _BitInt(", buf, ")", NULL);
418 : : else
419 : 0 : data_type = concat ("_BitInt(", buf, ")", NULL);
420 : 0 : break;
421 : : }
422 : :
423 : 0 : case OPAQUE_TYPE:
424 : 0 : case REAL_TYPE:
425 : 0 : data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
426 : 0 : break;
427 : :
428 : 0 : case VOID_TYPE:
429 : 0 : data_type = "void";
430 : 0 : break;
431 : :
432 : 0 : case ERROR_MARK:
433 : 0 : data_type = "[ERROR]";
434 : 0 : break;
435 : :
436 : 0 : default:
437 : 0 : gcc_unreachable ();
438 : : }
439 : : }
440 : 0 : if (TYPE_ATOMIC (t))
441 : 0 : ret_val = concat ("_Atomic ", ret_val, NULL);
442 : 0 : if (TYPE_READONLY (t))
443 : 0 : ret_val = concat ("const ", ret_val, NULL);
444 : 0 : if (TYPE_VOLATILE (t))
445 : 0 : ret_val = concat ("volatile ", ret_val, NULL);
446 : 0 : if (TYPE_RESTRICT (t))
447 : 0 : ret_val = concat ("restrict ", ret_val, NULL);
448 : : return ret_val;
449 : : }
450 : :
451 : : /* Generate a string (source) representation of an entire entity declaration
452 : : (using some particular style for function types).
453 : :
454 : : The given entity may be either a variable or a function.
455 : :
456 : : If the "is_func_definition" parameter is nonzero, assume that the thing
457 : : we are generating a declaration for is a FUNCTION_DECL node which is
458 : : associated with a function definition. In this case, we can assume that
459 : : an attached list of DECL nodes for function formal arguments is present. */
460 : :
461 : : static const char *
462 : 0 : gen_decl (tree decl, int is_func_definition, formals_style style)
463 : : {
464 : 0 : const char *ret_val;
465 : :
466 : 0 : if (DECL_NAME (decl))
467 : 0 : ret_val = IDENTIFIER_POINTER (DECL_NAME (decl));
468 : : else
469 : : ret_val = "";
470 : :
471 : : /* If we are just generating a list of names of formal parameters, we can
472 : : simply return the formal parameter name (with no typing information
473 : : attached to it) now. */
474 : :
475 : 0 : if (style == k_and_r_names)
476 : : return ret_val;
477 : :
478 : : /* Note that for the declaration of some entity (either a function or a
479 : : data object, like for instance a parameter) if the entity itself was
480 : : declared as either const or volatile, then const and volatile properties
481 : : are associated with just the declaration of the entity, and *not* with
482 : : the `type' of the entity. Thus, for such declared entities, we have to
483 : : generate the qualifiers here. */
484 : :
485 : 0 : if (TREE_THIS_VOLATILE (decl))
486 : 0 : ret_val = concat ("volatile ", ret_val, NULL);
487 : 0 : if (TREE_READONLY (decl))
488 : 0 : ret_val = concat ("const ", ret_val, NULL);
489 : :
490 : 0 : data_type = "";
491 : :
492 : : /* For FUNCTION_DECL nodes, there are two possible cases here. First, if
493 : : this FUNCTION_DECL node was generated from a function "definition", then
494 : : we will have a list of DECL_NODE's, one for each of the function's formal
495 : : parameters. In this case, we can print out not only the types of each
496 : : formal, but also each formal's name. In the second case, this
497 : : FUNCTION_DECL node came from an actual function declaration (and *not*
498 : : a definition). In this case, we do nothing here because the formal
499 : : argument type-list will be output later, when the "type" of the function
500 : : is added to the string we are building. Note that the ANSI-style formal
501 : : parameter list is considered to be a (suffix) part of the "type" of the
502 : : function. */
503 : :
504 : 0 : if (TREE_CODE (decl) == FUNCTION_DECL && is_func_definition)
505 : : {
506 : 0 : ret_val = concat (ret_val, gen_formal_list_for_func_def (decl, ansi),
507 : : NULL);
508 : :
509 : : /* Since we have already added in the formals list stuff, here we don't
510 : : add the whole "type" of the function we are considering (which
511 : : would include its parameter-list info), rather, we only add in
512 : : the "type" of the "type" of the function, which is really just
513 : : the return-type of the function (and does not include the parameter
514 : : list info). */
515 : :
516 : 0 : ret_val = gen_type (ret_val, TREE_TYPE (TREE_TYPE (decl)), style);
517 : : }
518 : : else
519 : 0 : ret_val = gen_type (ret_val, TREE_TYPE (decl), style);
520 : :
521 : 0 : ret_val = affix_data_type (ret_val);
522 : :
523 : 0 : if (TREE_CODE (decl) != FUNCTION_DECL && C_DECL_REGISTER (decl))
524 : 0 : ret_val = concat ("register ", ret_val, NULL);
525 : 0 : if (TREE_PUBLIC (decl))
526 : 0 : ret_val = concat ("extern ", ret_val, NULL);
527 : 0 : if (TREE_CODE (decl) == FUNCTION_DECL && !TREE_PUBLIC (decl))
528 : 0 : ret_val = concat ("static ", ret_val, NULL);
529 : :
530 : : return ret_val;
531 : : }
532 : :
533 : : extern FILE *aux_info_file;
534 : :
535 : : /* Generate and write a new line of info to the aux-info (.X) file. This
536 : : routine is called once for each function declaration, and once for each
537 : : function definition (even the implicit ones). */
538 : :
539 : : void
540 : 44181257 : gen_aux_info_record (tree fndecl, int is_definition, int is_implicit,
541 : : int is_prototyped)
542 : : {
543 : 44181257 : if (flag_gen_aux_info)
544 : : {
545 : 0 : static int compiled_from_record = 0;
546 : 0 : expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (fndecl));
547 : :
548 : : /* Each output .X file must have a header line. Write one now if we
549 : : have not yet done so. */
550 : :
551 : 0 : if (!compiled_from_record++)
552 : : {
553 : : /* The first line tells which directory file names are relative to.
554 : : Currently, -aux-info works only for files in the working
555 : : directory, so just use a `.' as a placeholder for now. */
556 : 0 : fprintf (aux_info_file, "/* compiled from: . */\n");
557 : : }
558 : :
559 : : /* Write the actual line of auxiliary info. */
560 : :
561 : 0 : fprintf (aux_info_file, "/* %s:%d:%c%c */ %s;",
562 : : xloc.file, xloc.line,
563 : 0 : (is_implicit) ? 'I' : (is_prototyped) ? 'N' : 'O',
564 : : (is_definition) ? 'F' : 'C',
565 : : gen_decl (fndecl, is_definition, ansi));
566 : :
567 : : /* If this is an explicit function declaration, we need to also write
568 : : out an old-style (i.e. K&R) function header, just in case the user
569 : : wants to run unprotoize. */
570 : :
571 : 0 : if (is_definition)
572 : : {
573 : 0 : fprintf (aux_info_file, " /*%s %s*/",
574 : : gen_formal_list_for_func_def (fndecl, k_and_r_names),
575 : : gen_formal_list_for_func_def (fndecl, k_and_r_decls));
576 : : }
577 : :
578 : 0 : fprintf (aux_info_file, "\n");
579 : : }
580 : 44181257 : }
|
