![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c-decl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to c-decl.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Process declarations and variables for C compiler.
2: Copyright (C) 1988, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: /* Process declarations and symbol lookup for C front end.
22: Also constructs types; the standard scalar types at initialization,
23: and structure, union, array and enum types when they are declared. */
24:
25: /* ??? not all decl nodes are given the most useful possible
26: line numbers. For example, the CONST_DECLs for enum values. */
27:
28: #include "config.h"
29: #include "tree.h"
30: #include "flags.h"
31: #include "c-tree.h"
32: #include "c-lex.h"
33: #include <stdio.h>
34:
35: /* In grokdeclarator, distinguish syntactic contexts of declarators. */
36: enum decl_context
37: { NORMAL, /* Ordinary declaration */
38: FUNCDEF, /* Function definition */
39: PARM, /* Declaration of parm before function body */
40: FIELD, /* Declaration inside struct or union */
41: BITFIELD, /* Likewise but with specified width */
42: TYPENAME}; /* Typename (inside cast or sizeof) */
43:
44: #undef NULL
45: #define NULL 0
46:
47: #ifndef CHAR_TYPE_SIZE
48: #define CHAR_TYPE_SIZE BITS_PER_UNIT
49: #endif
50:
51: #ifndef SHORT_TYPE_SIZE
52: #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
53: #endif
54:
55: #ifndef INT_TYPE_SIZE
56: #define INT_TYPE_SIZE BITS_PER_WORD
57: #endif
58:
59: #ifndef LONG_TYPE_SIZE
60: #define LONG_TYPE_SIZE BITS_PER_WORD
61: #endif
62:
63: #ifndef LONG_LONG_TYPE_SIZE
64: #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
65: #endif
66:
67: #ifndef WCHAR_UNSIGNED
68: #define WCHAR_UNSIGNED 0
69: #endif
70:
71: #ifndef FLOAT_TYPE_SIZE
72: #define FLOAT_TYPE_SIZE BITS_PER_WORD
73: #endif
74:
75: #ifndef DOUBLE_TYPE_SIZE
76: #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
77: #endif
78:
79: #ifndef LONG_DOUBLE_TYPE_SIZE
80: #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
81: #endif
82:
83: /* We let tm.h override the types used here, to handle trivial differences
84: such as the choice of unsigned int or long unsigned int for size_t.
85: When machines start needing nontrivial differences in the size type,
86: it would be best to do something here to figure out automatically
87: from other information what type to use. */
88:
89: #ifndef SIZE_TYPE
90: #define SIZE_TYPE "long unsigned int"
91: #endif
92:
93: #ifndef PTRDIFF_TYPE
94: #define PTRDIFF_TYPE "long int"
95: #endif
96:
97: #ifndef WCHAR_TYPE
98: #define WCHAR_TYPE "int"
99: #endif
100:
101: /* a node which has tree code ERROR_MARK, and whose type is itself.
102: All erroneous expressions are replaced with this node. All functions
103: that accept nodes as arguments should avoid generating error messages
104: if this node is one of the arguments, since it is undesirable to get
105: multiple error messages from one error in the input. */
106:
107: tree error_mark_node;
108:
109: /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
110:
111: tree short_integer_type_node;
112: tree integer_type_node;
113: tree long_integer_type_node;
114: tree long_long_integer_type_node;
115:
116: tree short_unsigned_type_node;
117: tree unsigned_type_node;
118: tree long_unsigned_type_node;
119: tree long_long_unsigned_type_node;
120:
121: tree ptrdiff_type_node;
122:
123: tree unsigned_char_type_node;
124: tree signed_char_type_node;
125: tree char_type_node;
126: tree wchar_type_node;
127: tree signed_wchar_type_node;
128: tree unsigned_wchar_type_node;
129:
130: tree float_type_node;
131: tree double_type_node;
132: tree long_double_type_node;
133:
134: /* a VOID_TYPE node. */
135:
136: tree void_type_node;
137:
138: /* Nodes for types `void *' and `const void *'. */
139:
140: tree ptr_type_node, const_ptr_type_node;
141:
142: /* Nodes for types `char *' and `const char *'. */
143:
144: tree string_type_node, const_string_type_node;
145:
146: /* Type `char[256]' or something like it.
147: Used when an array of char is needed and the size is irrelevant. */
148:
149: tree char_array_type_node;
150:
151: /* Type `int[256]' or something like it.
152: Used when an array of int needed and the size is irrelevant. */
153:
154: tree int_array_type_node;
155:
156: /* Type `wchar_t[256]' or something like it.
157: Used when a wide string literal is created. */
158:
159: tree wchar_array_type_node;
160:
161: /* type `int ()' -- used for implicit declaration of functions. */
162:
163: tree default_function_type;
164:
165: /* function types `double (double)' and `double (double, double)', etc. */
166:
167: tree double_ftype_double, double_ftype_double_double;
168: tree int_ftype_int, long_ftype_long;
169:
170: /* Function type `void (void *, void *, int)' and similar ones */
171:
172: tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int, void_ftype_ptr_int_int;
173:
174: /* Function type `char *(char *, char *)' and similar ones */
175: tree string_ftype_ptr_ptr, int_ftype_string_string;
176:
177: /* Function type `size_t (const char *)' */
178: tree sizet_ftype_string;
179:
180: /* Function type `int (const void *, const void *, size_t)' */
181: tree int_ftype_cptr_cptr_sizet;
182:
183: /* Two expressions that are constants with value zero.
184: The first is of type `int', the second of type `void *'. */
185:
186: tree integer_zero_node;
187: tree null_pointer_node;
188:
189: /* A node for the integer constant 1. */
190:
191: tree integer_one_node;
192:
193: /* Nonzero if we have seen an invalid cross reference
194: to a struct, union, or enum, but not yet printed the message. */
195:
196: tree pending_invalid_xref;
197: /* File and line to appear in the eventual error message. */
198: char *pending_invalid_xref_file;
199: int pending_invalid_xref_line;
200:
201: /* While defining an enum type, this is 1 plus the last enumerator
202: constant value. */
203:
204: static tree enum_next_value;
205:
206: /* Parsing a function declarator leaves a list of parameter names
207: or a chain or parameter decls here. */
208:
209: static tree last_function_parms;
210:
211: /* Parsing a function declarator leaves here a chain of structure
212: and enum types declared in the parmlist. */
213:
214: static tree last_function_parm_tags;
215:
216: /* After parsing the declarator that starts a function definition,
217: `start_function' puts here the list of parameter names or chain of decls.
218: `store_parm_decls' finds it here. */
219:
220: static tree current_function_parms;
221:
222: /* Similar, for last_function_parm_tags. */
223: static tree current_function_parm_tags;
224:
225: /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
226: that have names. Here so we can clear out their names' definitions
227: at the end of the function. */
228:
229: tree named_labels;
230:
231: /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
232:
233: static tree shadowed_labels;
234:
235: /* Nonzero when store_parm_decls is called indicates a varargs function.
236: Value not meaningful after store_parm_decls. */
237:
238: static int c_function_varargs;
239:
240: /* The FUNCTION_DECL for the function currently being compiled,
241: or 0 if between functions. */
242: tree current_function_decl;
243:
244: /* Set to 0 at beginning of a function definition, set to 1 if
245: a return statement that specifies a return value is seen. */
246:
247: int current_function_returns_value;
248:
249: /* Set to 0 at beginning of a function definition, set to 1 if
250: a return statement with no argument is seen. */
251:
252: int current_function_returns_null;
253:
254: /* Set to nonzero by `grokdeclarator' for a function
255: whose return type is defaulted, if warnings for this are desired. */
256:
257: static int warn_about_return_type;
258:
259: /* Nonzero when starting a function delcared `extern inline'. */
260:
261: static int current_extern_inline;
262:
263: /* For each binding contour we allocate a binding_level structure
264: * which records the names defined in that contour.
265: * Contours include:
266: * 0) the global one
267: * 1) one for each function definition,
268: * where internal declarations of the parameters appear.
269: * 2) one for each compound statement,
270: * to record its declarations.
271: *
272: * The current meaning of a name can be found by searching the levels from
273: * the current one out to the global one.
274: */
275:
276: /* Note that the information in the `names' component of the global contour
277: is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
278:
279: struct binding_level
280: {
281: /* A chain of _DECL nodes for all variables, constants, functions,
282: and typedef types. These are in the reverse of the order supplied.
283: */
284: tree names;
285:
286: /* A list of structure, union and enum definitions,
287: * for looking up tag names.
288: * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
289: * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
290: * or ENUMERAL_TYPE node.
291: */
292: tree tags;
293:
294: /* For each level, a list of shadowed outer-level local definitions
295: to be restored when this level is popped.
296: Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
297: whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
298: tree shadowed;
299:
300: /* For each level (except not the global one),
301: a chain of BLOCK nodes for all the levels
302: that were entered and exited one level down. */
303: tree blocks;
304:
305: /* The binding level which this one is contained in (inherits from). */
306: struct binding_level *level_chain;
307:
308: /* Nonzero for the level that holds the parameters of a function. */
309: /* 2 for a definition, 1 for a declaration. */
310: char parm_flag;
311:
312: /* Nonzero if this level "doesn't exist" for tags. */
313: char tag_transparent;
314:
315: /* Nonzero if sublevels of this level "don't exist" for tags.
316: This is set in the parm level of a function definition
317: while reading the function body, so that the outermost block
318: of the function body will be tag-transparent. */
319: char subblocks_tag_transparent;
320:
321: /* Nonzero means make a BLOCK for this level regardless of all else. */
322: char keep;
323:
324: /* Nonzero means make a BLOCK if this level has any subblocks. */
325: char keep_if_subblocks;
326:
327: /* Number of decls in `names' that have incomplete
328: structure or union types. */
329: int n_incomplete;
330:
331: /* A list of decls giving the (reversed) specified order of parms,
332: not including any forward-decls in the parmlist.
333: This is so we can put the parms in proper order for assign_parms. */
334: tree parm_order;
335: };
336:
337: #define NULL_BINDING_LEVEL (struct binding_level *) NULL
338:
339: /* The binding level currently in effect. */
340:
341: static struct binding_level *current_binding_level;
342:
343: /* A chain of binding_level structures awaiting reuse. */
344:
345: static struct binding_level *free_binding_level;
346:
347: /* The outermost binding level, for names of file scope.
348: This is created when the compiler is started and exists
349: through the entire run. */
350:
351: static struct binding_level *global_binding_level;
352:
353: /* Binding level structures are initialized by copying this one. */
354:
355: static struct binding_level clear_binding_level
356: = {NULL, NULL, NULL, NULL, NULL, 0, 0, 0};
357:
358: /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
359:
360: static int keep_next_level_flag;
361:
362: /* Nonzero means make a BLOCK for the next level pushed
363: if it has subblocks. */
364:
365: static int keep_next_if_subblocks;
366:
367: /* The chain of outer levels of label scopes.
368: This uses the same data structure used for binding levels,
369: but it works differently: each link in the chain records
370: saved values of named_labels and shadowed_labels for
371: a label binding level outside the current one. */
372:
373: static struct binding_level *label_level_chain;
374:
375: /* Forward declarations. */
376:
377: static tree grokparms (), grokdeclarator ();
378: tree pushdecl ();
379: static tree builtin_function ();
380:
381: static tree lookup_tag ();
382: static tree lookup_tag_reverse ();
383: static tree lookup_name_current_level ();
384: static char *redeclaration_error_message ();
385: static void layout_array_type ();
386:
387: /* C-specific option variables. */
388:
389: /* Nonzero means allow type mismatches in conditional expressions;
390: just make their values `void'. */
391:
392: int flag_cond_mismatch;
393:
394: /* Nonzero means give `double' the same size as `float'. */
395:
396: int flag_short_double;
397:
398: /* Nonzero means don't recognize the keyword `asm'. */
399:
400: int flag_no_asm;
401:
402: /* Nonzero means don't recognize the non-ANSI builtin functions. */
403:
404: int flag_no_builtin;
405:
406: /* Nonzero means do some things the same way PCC does. */
407:
408: int flag_traditional;
409:
410: /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
411:
412: int flag_signed_bitfields = 1;
413:
414: /* Nonzero means handle `#ident' directives. 0 means ignore them. */
415:
416: int flag_no_ident = 0;
417:
418: /* Nonzero means warn about implicit declarations. */
419:
420: int warn_implicit;
421:
422: /* Nonzero means give string constants the type `const char *'
423: to get extra warnings from them. These warnings will be too numerous
424: to be useful, except in thoroughly ANSIfied programs. */
425:
426: int warn_write_strings;
427:
428: /* Nonzero means warn about pointer casts that can drop a type qualifier
429: from the pointer target type. */
430:
431: int warn_cast_qual;
432:
433: /* Warn about traditional constructs whose meanings changed in ANSI C. */
434:
435: int warn_traditional;
436:
437: /* Nonzero means warn about sizeof(function) or addition/subtraction
438: of function pointers. */
439:
440: int warn_pointer_arith;
441:
442: /* Nonzero means warn for non-prototype function decls
443: or non-prototyped defs without previous prototype. */
444:
445: int warn_strict_prototypes;
446:
447: /* Nonzero means warn for any global function def
448: without separate previous prototype decl. */
449:
450: int warn_missing_prototypes;
451:
452: /* Nonzero means warn about multiple (redundant) decls for the same single
453: variable or function. */
454:
455: int warn_redundant_decls = 0;
456:
457: /* Nonzero means warn about extern declarations of objects not at
458: file-scope level and about *all* declarations of functions (whether
459: extern or static) not at file-scope level. Note that we exclude
460: implicit function declarations. To get warnings about those, use
461: -Wimplicit. */
462:
463: int warn_nested_externs = 0;
464:
465: /* Warn about *printf or *scanf format/argument anomalies. */
466:
467: int warn_format;
468:
469: /* Warn about a subscript that has type char. */
470:
471: int warn_char_subscripts = 0;
472:
473: /* Warn if a type conversion is done that might have confusing results. */
474:
475: int warn_conversion;
476:
477: /* Warn if adding () is suggested. */
478:
479: int warn_parentheses = 1;
480:
481: /* Nonzero means `$' can be in an identifier.
482: See cccp.c for reasons why this breaks some obscure ANSI C programs. */
483:
484: #ifndef DOLLARS_IN_IDENTIFIERS
485: #define DOLLARS_IN_IDENTIFIERS 1
486: #endif
487: int dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 1;
488:
489: char *language_string = "GNU C";
490:
491: /* Decode the string P as a language-specific option for C.
492: Return 1 if it is recognized (and handle it);
493: return 0 if not recognized. */
494:
495: int
496: c_decode_option (p)
497: char *p;
498: {
499: if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
500: {
501: flag_traditional = 1;
502: flag_writable_strings = 1;
503: #if DOLLARS_IN_IDENTIFIERS > 0
504: dollars_in_ident = 1;
505: #endif
506: }
507: else if (!strcmp (p, "-fnotraditional"))
508: ;
509: else if (!strcmp (p, "-fsigned-char"))
510: flag_signed_char = 1;
511: else if (!strcmp (p, "-funsigned-char"))
512: flag_signed_char = 0;
513: else if (!strcmp (p, "-fno-signed-char"))
514: flag_signed_char = 0;
515: else if (!strcmp (p, "-fno-unsigned-char"))
516: flag_signed_char = 1;
517: else if (!strcmp (p, "-fsigned-bitfields"))
518: flag_signed_bitfields = 1;
519: else if (!strcmp (p, "-funsigned-bitfields"))
520: flag_signed_bitfields = 0;
521: else if (!strcmp (p, "-fno-signed-bitfields"))
522: flag_signed_bitfields = 0;
523: else if (!strcmp (p, "-fno-unsigned-bitfields"))
524: flag_signed_bitfields = 1;
525: else if (!strcmp (p, "-fshort-enums"))
526: flag_short_enums = 1;
527: else if (!strcmp (p, "-fno-short-enums"))
528: flag_short_enums = 0;
529: else if (!strcmp (p, "-fcond-mismatch"))
530: flag_cond_mismatch = 1;
531: else if (!strcmp (p, "-fno-cond-mismatch"))
532: flag_cond_mismatch = 0;
533: else if (!strcmp (p, "-fshort-double"))
534: flag_short_double = 1;
535: else if (!strcmp (p, "-fno-short-double"))
536: flag_short_double = 0;
537: else if (!strcmp (p, "-fasm"))
538: flag_no_asm = 0;
539: else if (!strcmp (p, "-fno-asm"))
540: flag_no_asm = 1;
541: else if (!strcmp (p, "-fbuiltin"))
542: flag_no_builtin = 0;
543: else if (!strcmp (p, "-fno-builtin"))
544: flag_no_builtin = 1;
545: else if (!strcmp (p, "-fno-ident"))
546: flag_no_ident = 1;
547: else if (!strcmp (p, "-fident"))
548: flag_no_ident = 0;
549: else if (!strcmp (p, "-ansi"))
550: flag_no_asm = 1, flag_no_builtin = 1, dollars_in_ident = 0;
551: else if (!strcmp (p, "-Wimplicit"))
552: warn_implicit = 1;
553: else if (!strcmp (p, "-Wno-implicit"))
554: warn_implicit = 0;
555: else if (!strcmp (p, "-Wwrite-strings"))
556: warn_write_strings = 1;
557: else if (!strcmp (p, "-Wno-write-strings"))
558: warn_write_strings = 0;
559: else if (!strcmp (p, "-Wcast-qual"))
560: warn_cast_qual = 1;
561: else if (!strcmp (p, "-Wno-cast-qual"))
562: warn_cast_qual = 0;
563: else if (!strcmp (p, "-Wpointer-arith"))
564: warn_pointer_arith = 1;
565: else if (!strcmp (p, "-Wno-pointer-arith"))
566: warn_pointer_arith = 0;
567: else if (!strcmp (p, "-Wstrict-prototypes"))
568: warn_strict_prototypes = 1;
569: else if (!strcmp (p, "-Wno-strict-prototypes"))
570: warn_strict_prototypes = 0;
571: else if (!strcmp (p, "-Wmissing-prototypes"))
572: warn_missing_prototypes = 1;
573: else if (!strcmp (p, "-Wno-missing-prototypes"))
574: warn_missing_prototypes = 0;
575: else if (!strcmp (p, "-Wredundant-decls"))
576: warn_redundant_decls = 1;
577: else if (!strcmp (p, "-Wnoredundant-decls"))
578: warn_redundant_decls = 0;
579: else if (!strcmp (p, "-Wnested-externs"))
580: warn_nested_externs = 1;
581: else if (!strcmp (p, "-Wno-nested-externs"))
582: warn_nested_externs = 0;
583: else if (!strcmp (p, "-Wtraditional"))
584: warn_traditional = 1;
585: else if (!strcmp (p, "-Wno-traditional"))
586: warn_traditional = 0;
587: else if (!strcmp (p, "-Wformat"))
588: warn_format = 1;
589: else if (!strcmp (p, "-Wno-format"))
590: warn_format = 0;
591: else if (!strcmp (p, "-Wchar-subscripts"))
592: warn_char_subscripts = 1;
593: else if (!strcmp (p, "-Wno-char-subscripts"))
594: warn_char_subscripts = 0;
595: else if (!strcmp (p, "-Wconversion"))
596: warn_conversion = 1;
597: else if (!strcmp (p, "-Wno-conversion"))
598: warn_conversion = 0;
599: else if (!strcmp (p, "-Wparentheses"))
600: warn_parentheses = 1;
601: else if (!strcmp (p, "-Wno-parentheses"))
602: warn_parentheses = 0;
603: else if (!strcmp (p, "-Wcomment"))
604: ; /* cpp handles this one. */
605: else if (!strcmp (p, "-Wno-comment"))
606: ; /* cpp handles this one. */
607: else if (!strcmp (p, "-Wcomments"))
608: ; /* cpp handles this one. */
609: else if (!strcmp (p, "-Wno-comments"))
610: ; /* cpp handles this one. */
611: else if (!strcmp (p, "-Wtrigraphs"))
612: ; /* cpp handles this one. */
613: else if (!strcmp (p, "-Wno-trigraphs"))
614: ; /* cpp handles this one. */
615: else if (!strcmp (p, "-Wall"))
616: {
617: extra_warnings = 1;
618: warn_uninitialized = 1;
619: warn_implicit = 1;
620: warn_return_type = 1;
621: warn_unused = 1;
622: warn_switch = 1;
623: warn_format = 1;
624: warn_char_subscripts = 1;
625: }
626: else
627: return 0;
628:
629: return 1;
630: }
631:
632: /* Hooks for print_node. */
633:
634: void
635: print_lang_decl ()
636: {
637: }
638:
639: void
640: print_lang_type ()
641: {
642: }
643:
644: void
645: print_lang_identifier (file, node, indent)
646: FILE *file;
647: tree node;
648: int indent;
649: {
650: print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
651: print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
652: print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
653: print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
654: print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
655: }
656:
657: /* Create a new `struct binding_level'. */
658:
659: static
660: struct binding_level *
661: make_binding_level ()
662: {
663: /* NOSTRICT */
664: return (struct binding_level *) xmalloc (sizeof (struct binding_level));
665: }
666:
667: /* Nonzero if we are currently in the global binding level. */
668:
669: int
670: global_bindings_p ()
671: {
672: return current_binding_level == global_binding_level;
673: }
674:
675: void
676: keep_next_level ()
677: {
678: keep_next_level_flag = 1;
679: }
680:
681: /* Nonzero if the current level needs to have a BLOCK made. */
682:
683: int
684: kept_level_p ()
685: {
686: return ((current_binding_level->keep_if_subblocks
687: && current_binding_level->blocks != 0)
688: || current_binding_level->keep
689: || current_binding_level->names != 0
690: || (current_binding_level->tags != 0
691: && !current_binding_level->tag_transparent));
692: }
693:
694: /* Identify this binding level as a level of parameters.
695: DEFINITION_FLAG is 1 for a definition, 0 for a declaration. */
696:
697: void
698: declare_parm_level (definition_flag)
699: int definition_flag;
700: {
701: current_binding_level->parm_flag = 1 + definition_flag;
702: }
703:
704: /* Nonzero if currently making parm declarations. */
705:
706: int
707: in_parm_level_p ()
708: {
709: return current_binding_level->parm_flag;
710: }
711:
712: /* Enter a new binding level.
713: If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
714: not for that of tags. */
715:
716: void
717: pushlevel (tag_transparent)
718: int tag_transparent;
719: {
720: register struct binding_level *newlevel = NULL_BINDING_LEVEL;
721:
722: /* If this is the top level of a function,
723: just make sure that NAMED_LABELS is 0. */
724:
725: if (current_binding_level == global_binding_level)
726: {
727: named_labels = 0;
728: }
729:
730: /* Reuse or create a struct for this binding level. */
731:
732: if (free_binding_level)
733: {
734: newlevel = free_binding_level;
735: free_binding_level = free_binding_level->level_chain;
736: }
737: else
738: {
739: newlevel = make_binding_level ();
740: }
741:
742: /* Add this level to the front of the chain (stack) of levels that
743: are active. */
744:
745: *newlevel = clear_binding_level;
746: newlevel->tag_transparent
747: = (tag_transparent
748: || (current_binding_level
749: ? current_binding_level->subblocks_tag_transparent
750: : 0));
751: newlevel->level_chain = current_binding_level;
752: current_binding_level = newlevel;
753: newlevel->keep = keep_next_level_flag;
754: keep_next_level_flag = 0;
755: newlevel->keep_if_subblocks = keep_next_if_subblocks;
756: keep_next_if_subblocks = 0;
757: }
758:
759: /* Exit a binding level.
760: Pop the level off, and restore the state of the identifier-decl mappings
761: that were in effect when this level was entered.
762:
763: If KEEP is nonzero, this level had explicit declarations, so
764: and create a "block" (a BLOCK node) for the level
765: to record its declarations and subblocks for symbol table output.
766:
767: If FUNCTIONBODY is nonzero, this level is the body of a function,
768: so create a block as if KEEP were set and also clear out all
769: label names.
770:
771: If REVERSE is nonzero, reverse the order of decls before putting
772: them into the BLOCK. */
773:
774: tree
775: poplevel (keep, reverse, functionbody)
776: int keep;
777: int reverse;
778: int functionbody;
779: {
780: register tree link;
781: /* The chain of decls was accumulated in reverse order.
782: Put it into forward order, just for cleanliness. */
783: tree decls;
784: tree tags = current_binding_level->tags;
785: tree subblocks = current_binding_level->blocks;
786: tree block = 0;
787: tree decl;
788:
789: keep |= current_binding_level->keep;
790:
791: /* This warning is turned off because it causes warnings for
792: declarations like `extern struct foo *x'. */
793: #if 0
794: /* Warn about incomplete structure types in this level. */
795: for (link = tags; link; link = TREE_CHAIN (link))
796: if (TYPE_SIZE (TREE_VALUE (link)) == 0)
797: {
798: tree type = TREE_VALUE (link);
799: char *errmsg;
800: switch (TREE_CODE (type))
801: {
802: case RECORD_TYPE:
803: errmsg = "`struct %s' incomplete in scope ending here";
804: break;
805: case UNION_TYPE:
806: errmsg = "`union %s' incomplete in scope ending here";
807: break;
808: case ENUMERAL_TYPE:
809: errmsg = "`enum %s' incomplete in scope ending here";
810: break;
811: }
812: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
813: error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
814: else
815: /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
816: error (errmsg, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
817: }
818: #endif /* 0 */
819:
820: /* Get the decls in the order they were written.
821: Usually current_binding_level->names is in reverse order.
822: But parameter decls were previously put in forward order. */
823:
824: if (reverse)
825: current_binding_level->names
826: = decls = nreverse (current_binding_level->names);
827: else
828: decls = current_binding_level->names;
829:
830: /* Output any nested inline functions within this block
831: if they weren't already output. */
832:
833: for (decl = decls; decl; decl = TREE_CHAIN (decl))
834: if (TREE_CODE (decl) == FUNCTION_DECL
835: && ! TREE_ASM_WRITTEN (decl)
836: && DECL_INITIAL (decl) != 0
837: && TREE_ADDRESSABLE (decl))
838: output_inline_function (decl);
839:
840: /* If there were any declarations or structure tags in that level,
841: or if this level is a function body,
842: create a BLOCK to record them for the life of this function. */
843:
844: if (keep || functionbody
845: || (current_binding_level->keep_if_subblocks && subblocks != 0))
846: block = build_block (keep ? decls : 0, keep ? tags : 0,
847: subblocks, 0, 0);
848:
849: /* In each subblock, record that this is its superior. */
850:
851: for (link = subblocks; link; link = TREE_CHAIN (link))
852: BLOCK_SUPERCONTEXT (link) = block;
853:
854: /* Clear out the meanings of the local variables of this level. */
855:
856: for (link = decls; link; link = TREE_CHAIN (link))
857: {
858: if (DECL_NAME (link) != 0)
859: {
860: /* If the ident. was used or addressed via a local extern decl,
861: don't forget that fact. */
862: if (TREE_EXTERNAL (link))
863: {
864: if (TREE_USED (link))
865: TREE_USED (DECL_NAME (link)) = 1;
866: if (TREE_ADDRESSABLE (link))
867: TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
868: }
869: IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
870: }
871: }
872:
873: /* Restore all name-meanings of the outer levels
874: that were shadowed by this level. */
875:
876: for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
877: IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
878:
879: /* If the level being exited is the top level of a function,
880: check over all the labels, and clear out the current
881: (function local) meanings of their names. */
882:
883: if (functionbody)
884: {
885: /* If this is the top level block of a function,
886: the vars are the function's parameters.
887: Don't leave them in the BLOCK because they are
888: found in the FUNCTION_DECL instead. */
889:
890: BLOCK_VARS (block) = 0;
891:
892: /* Clear out the definitions of all label names,
893: since their scopes end here,
894: and add them to BLOCK_VARS. */
895:
896: for (link = named_labels; link; link = TREE_CHAIN (link))
897: {
898: register tree label = TREE_VALUE (link);
899:
900: if (DECL_INITIAL (label) == 0)
901: {
902: error_with_decl (label, "label `%s' used but not defined");
903: /* Avoid crashing later. */
904: define_label (input_filename, lineno,
905: DECL_NAME (label));
906: }
907: else if (warn_unused && !TREE_USED (label))
908: warning_with_decl (label, "label `%s' defined but not used");
909: IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
910:
911: /* Put the labels into the "variables" of the
912: top-level block, so debugger can see them. */
913: TREE_CHAIN (label) = BLOCK_VARS (block);
914: BLOCK_VARS (block) = label;
915: }
916: }
917:
918: /* Pop the current level, and free the structure for reuse. */
919:
920: {
921: register struct binding_level *level = current_binding_level;
922: current_binding_level = current_binding_level->level_chain;
923:
924: level->level_chain = free_binding_level;
925: free_binding_level = level;
926: }
927:
928: /* Dispose of the block that we just made inside some higher level. */
929: if (functionbody)
930: DECL_INITIAL (current_function_decl) = block;
931: else if (block)
932: current_binding_level->blocks
933: = chainon (current_binding_level->blocks, block);
934: /* If we did not make a block for the level just exited,
935: any blocks made for inner levels
936: (since they cannot be recorded as subblocks in that level)
937: must be carried forward so they will later become subblocks
938: of something else. */
939: else if (subblocks)
940: current_binding_level->blocks
941: = chainon (current_binding_level->blocks, subblocks);
942:
943: /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
944: binding contour so that they point to the appropriate construct, i.e.
945: either to the current FUNCTION_DECL node, or else to the BLOCK node
946: we just constructed.
947:
948: Note that for tagged types whose scope is just the formal parameter
949: list for some function type specification, we can't properly set
950: their TYPE_CONTEXTs here, because we don't have a pointer to the
951: appropriate FUNCTION_TYPE node readily available to us. For those
952: cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
953: in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
954: node which will represent the "scope" for these "parameter list local"
955: tagged types.
956: */
957:
958: if (functionbody)
959: for (link = tags; link; link = TREE_CHAIN (link))
960: TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
961: else if (block)
962: for (link = tags; link; link = TREE_CHAIN (link))
963: TYPE_CONTEXT (TREE_VALUE (link)) = block;
964:
965: if (block)
966: TREE_USED (block) = 1;
967: return block;
968: }
969:
970: void
971: push_label_level ()
972: {
973: register struct binding_level *newlevel;
974:
975: /* Reuse or create a struct for this binding level. */
976:
977: if (free_binding_level)
978: {
979: newlevel = free_binding_level;
980: free_binding_level = free_binding_level->level_chain;
981: }
982: else
983: {
984: newlevel = make_binding_level ();
985: }
986:
987: /* Add this level to the front of the chain (stack) of label levels. */
988:
989: newlevel->level_chain = label_level_chain;
990: label_level_chain = newlevel;
991:
992: newlevel->names = named_labels;
993: newlevel->shadowed = shadowed_labels;
994: named_labels = 0;
995: shadowed_labels = 0;
996: }
997:
998: void
999: pop_label_level ()
1000: {
1001: register struct binding_level *level = label_level_chain;
1002: tree link, prev;
1003:
1004: /* Clear out the definitions of the declared labels in this level.
1005: Leave in the list any ordinary, non-declared labels. */
1006: for (link = named_labels, prev = 0; link;)
1007: {
1008: if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
1009: {
1010: if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
1011: {
1012: error_with_decl ("label `%s' used but not defined",
1013: TREE_VALUE (link));
1014: /* Avoid crashing later. */
1015: define_label (input_filename, lineno,
1016: DECL_NAME (TREE_VALUE (link)));
1017: }
1018: else if (warn_unused && !TREE_USED (TREE_VALUE (link)))
1019: warning_with_decl (TREE_VALUE (link),
1020: "label `%s' defined but not used");
1021: IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
1022:
1023: /* Delete this element from the list. */
1024: link = TREE_CHAIN (link);
1025: if (prev)
1026: TREE_CHAIN (prev) = link;
1027: else
1028: named_labels = link;
1029: }
1030: else
1031: {
1032: prev = link;
1033: link = TREE_CHAIN (link);
1034: }
1035: }
1036:
1037: /* Bring back all the labels that were shadowed. */
1038: for (link = shadowed_labels; link; link = TREE_CHAIN (link))
1039: if (DECL_NAME (TREE_VALUE (link)) != 0)
1040: IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
1041: = TREE_VALUE (link);
1042:
1043: named_labels = chainon (named_labels, level->names);
1044: shadowed_labels = level->shadowed;
1045:
1046: /* Pop the current level, and free the structure for reuse. */
1047: label_level_chain = label_level_chain->level_chain;
1048: level->level_chain = free_binding_level;
1049: free_binding_level = level;
1050: }
1051:
1052: /* Push a definition or a declaration of struct, union or enum tag "name".
1053: "type" should be the type node.
1054: We assume that the tag "name" is not already defined.
1055:
1056: Note that the definition may really be just a forward reference.
1057: In that case, the TYPE_SIZE will be zero. */
1058:
1059: void
1060: pushtag (name, type)
1061: tree name, type;
1062: {
1063: register struct binding_level *b;
1064:
1065: /* Find the proper binding level for this type tag. */
1066:
1067: for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
1068: continue;
1069:
1070: if (name)
1071: {
1072: /* Record the identifier as the type's name if it has none. */
1073:
1074: if (TYPE_NAME (type) == 0)
1075: TYPE_NAME (type) = name;
1076:
1077: if (b == global_binding_level)
1078: b->tags = perm_tree_cons (name, type, b->tags);
1079: else
1080: b->tags = saveable_tree_cons (name, type, b->tags);
1081: }
1082:
1083: /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
1084: tagged type we just added to the current binding level. This fake
1085: NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
1086: to output a a representation of a tagged type, and it also gives
1087: us a convenient place to record the "scope start" address for the
1088: tagged type. */
1089:
1090: TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL, type));
1091: }
1092:
1093: /* Handle when a new declaration NEWDECL
1094: has the same name as an old one OLDDECL
1095: in the same binding contour.
1096: Prints an error message if appropriate.
1097:
1098: If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
1099: Otherwise, return 0. */
1100:
1101: static int
1102: duplicate_decls (newdecl, olddecl)
1103: register tree newdecl, olddecl;
1104: {
1105: int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1106: int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1107: && DECL_INITIAL (newdecl) != 0);
1108:
1109: if (TREE_CODE (TREE_TYPE (newdecl)) == ERROR_MARK
1110: || TREE_CODE (TREE_TYPE (olddecl)) == ERROR_MARK)
1111: types_match = 0;
1112:
1113: /* New decl is completely inconsistent with the old one =>
1114: tell caller to replace the old one.
1115: This is always an error except in the case of shadowing a builtin. */
1116: if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1117: {
1118: if (TREE_CODE (olddecl) == FUNCTION_DECL
1119: && DECL_BUILT_IN (olddecl))
1120: {
1121: /* If you declare a built-in function name as static, the
1122: built-in definition is overridden,
1123: but optionally warn this was a bad choice of name. */
1124: if (!TREE_PUBLIC (newdecl))
1125: {
1126: if (warn_shadow)
1127: warning_with_decl (newdecl, "shadowing built-in function `%s'");
1128: }
1129: /* Likewise, if the built-in is not ansi, then programs can
1130: overide it even globally without an error. */
1131: else if (DECL_BUILT_IN_NONANSI (olddecl))
1132: warning_with_decl (newdecl,
1133: "built-in function `%s' declared as non-function");
1134: else
1135: error_with_decl (newdecl,
1136: "built-in function `%s' declared as non-function");
1137: }
1138: else if (TREE_CODE (olddecl) == FUNCTION_DECL
1139: && DECL_BUILT_IN_NONANSI (olddecl))
1140: {
1141: /* If overriding decl is static,
1142: optionally warn this was a bad choice of name. */
1143: if (!TREE_PUBLIC (newdecl))
1144: {
1145: if (warn_shadow)
1146: warning_with_decl (newdecl, "shadowing library function `%s'");
1147: }
1148: /* Otherwise, always warn. */
1149: else
1150: warning_with_decl (newdecl,
1151: "library function `%s' declared as non-function");
1152: }
1153: else
1154: {
1155: error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
1156: error_with_decl (olddecl, "previous declaration of `%s'");
1157: }
1158:
1159: return 0;
1160: }
1161:
1162: /* For real parm decl following a forward decl,
1163: return 1 so old decl will be reused. */
1164: if (types_match && TREE_CODE (newdecl) == PARM_DECL
1165: && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
1166: return 1;
1167:
1168: /* The new declaration is the same kind of object as the old one.
1169: The declarations may partially match. Print warnings if they don't
1170: match enough. Ultimately, copy most of the information from the new
1171: decl to the old one, and keep using the old one. */
1172:
1173: if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
1174: && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (newdecl)) == olddecl
1175: && DECL_INITIAL (olddecl) == 0)
1176: /* If -traditional, avoid error for redeclaring fcn
1177: after implicit decl. */
1178: ;
1179: else if (TREE_CODE (olddecl) == FUNCTION_DECL
1180: && DECL_BUILT_IN (olddecl))
1181: {
1182: if (!TREE_PUBLIC (newdecl))
1183: {
1184: /* If you declare a built-in function name as static, the
1185: built-in definition is overridden,
1186: but optionally warn this was a bad choice of name. */
1187: if (warn_shadow)
1188: warning_with_decl (newdecl, "shadowing built-in function `%s'");
1189: /* Discard the old built-in function. */
1190: return 0;
1191: }
1192: else if (!types_match)
1193: warning_with_decl (newdecl, "conflicting types for built-in function `%s'");
1194: }
1195: else if (TREE_CODE (olddecl) == FUNCTION_DECL
1196: && DECL_BUILT_IN_NONANSI (olddecl))
1197: {
1198: if (!TREE_PUBLIC (newdecl))
1199: {
1200: /* If you declare a built-in function name as static, the
1201: built-in definition is overridden,
1202: but optionally warn this was a bad choice of name. */
1203: if (warn_shadow)
1204: warning_with_decl (newdecl, "shadowing library function `%s'");
1205: /* Discard the old built-in function. */
1206: return 0;
1207: }
1208: else if (!types_match)
1209: warning_with_decl (newdecl, "conflicting types for library function `%s'");
1210: }
1211: else if (!types_match
1212: /* Permit char *foo (int, ...); followed by char *foo ();
1213: if not pedantic. */
1214: && ! (TREE_CODE (olddecl) == FUNCTION_DECL
1215: && ! pedantic
1216: /* Return types must still match. */
1217: && comptypes (TREE_TYPE (TREE_TYPE (olddecl)),
1218: TREE_TYPE (TREE_TYPE (newdecl)))
1219: && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) == 0))
1220: {
1221: error_with_decl (newdecl, "conflicting types for `%s'");
1222: /* Check for function type mismatch
1223: involving an empty arglist vs a nonempty one. */
1224: if (TREE_CODE (olddecl) == FUNCTION_DECL
1225: && comptypes (TREE_TYPE (TREE_TYPE (olddecl)),
1226: TREE_TYPE (TREE_TYPE (newdecl)))
1227: && ((TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == 0
1228: && DECL_INITIAL (olddecl) == 0)
1229: ||
1230: (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) == 0
1231: && DECL_INITIAL (newdecl) == 0)))
1232: {
1233: /* Classify the problem further. */
1234: register tree t = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1235: if (t == 0)
1236: t = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1237: for (; t; t = TREE_CHAIN (t))
1238: {
1239: register tree type = TREE_VALUE (t);
1240:
1241: if (TREE_CHAIN (t) == 0 && type != void_type_node)
1242: {
1243: error ("A parameter list with an ellipsis can't match");
1244: error ("an empty parameter name list declaration.");
1245: break;
1246: }
1247:
1248: if (type == float_type_node
1249: || (TREE_CODE (type) == INTEGER_TYPE
1250: && (TYPE_PRECISION (type)
1251: < TYPE_PRECISION (integer_type_node))))
1252: {
1253: error ("An argument type that has a default promotion");
1254: error ("can't match an empty parameter name list declaration.");
1255: break;
1256: }
1257: }
1258: }
1259: error_with_decl (olddecl, "previous declaration of `%s'");
1260: }
1261: else
1262: {
1263: char *errmsg = redeclaration_error_message (newdecl, olddecl);
1264: if (errmsg)
1265: {
1266: error_with_decl (newdecl, errmsg);
1267: error_with_decl (olddecl,
1268: "`%s' previously declared here");
1269: }
1270: else if (TREE_CODE (olddecl) == FUNCTION_DECL
1271: && DECL_INITIAL (olddecl) != 0
1272: && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == 0
1273: && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0)
1274: {
1275: register tree type, parm;
1276: register int nargs;
1277: /* Prototype decl follows defn w/o prototype. */
1278:
1279: for (parm = TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (olddecl)),
1280: type = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1281: nargs = 1;
1282: (TREE_VALUE (parm) != void_type_node
1283: || TREE_VALUE (type) != void_type_node);
1284: parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
1285: {
1286: if (TREE_VALUE (parm) == void_type_node
1287: || TREE_VALUE (type) == void_type_node)
1288: {
1289: errmsg = "prototype for `%s' follows and number of arguments";
1290: break;
1291: }
1292: /* Type for passing arg must be consistent
1293: with that declared for the arg. */
1294: if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type))
1295: /* If -traditional, allow `unsigned int' instead of `int'
1296: in the prototype. */
1297: && (! (flag_traditional
1298: && TREE_VALUE (parm) == integer_type_node
1299: && TREE_VALUE (type) == unsigned_type_node)))
1300: {
1301: errmsg = "prototype for `%s' follows and argument %d";
1302: break;
1303: }
1304: }
1305: if (errmsg)
1306: {
1307: error_with_decl (newdecl, errmsg, nargs);
1308: error_with_decl (olddecl,
1309: "doesn't match non-prototype definition here");
1310: }
1311: else
1312: {
1313: warning_with_decl (newdecl, "prototype for `%s' follows");
1314: warning_with_decl (olddecl, "non-prototype definition here");
1315: }
1316: }
1317: /* Warn if function is now inline
1318: but was previously declared not inline and has been called. */
1319: else
1320: {
1321: if (TREE_CODE (olddecl) == FUNCTION_DECL
1322: && ! TREE_INLINE (olddecl) && TREE_INLINE (newdecl)
1323: && TREE_USED (olddecl))
1324: warning_with_decl (newdecl,
1325: "`%s' declared inline after being called");
1326: if (TREE_CODE (olddecl) == FUNCTION_DECL
1327: && TREE_INLINE (olddecl) != TREE_INLINE (newdecl))
1328: warning_with_decl (newdecl,
1329: "`%s' declarations disagree about `inline'");
1330: /* It is nice to warn when a function is declared
1331: global first and then static. */
1332: if (TREE_CODE (olddecl) == FUNCTION_DECL
1333: && TREE_PUBLIC (olddecl)
1334: && !TREE_PUBLIC (newdecl))
1335: warning_with_decl (newdecl, "static declaration for `%s' follows non-static");
1336:
1337: /* These bits are logically part of the type. */
1338: if (pedantic
1339: && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
1340: || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
1341: pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
1342: }
1343: }
1344:
1345: /* Copy all the DECL_... slots specified in the new decl
1346: except for any that we copy here from the old type. */
1347:
1348: if (types_match)
1349: {
1350: tree oldtype = TREE_TYPE (olddecl);
1351: /* Merge the data types specified in the two decls. */
1352: if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
1353: TREE_TYPE (newdecl)
1354: = TREE_TYPE (olddecl)
1355: = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1356:
1357: /* Lay the type out, unless already done. */
1358: if (oldtype != TREE_TYPE (newdecl))
1359: {
1360: if (TREE_TYPE (newdecl) != error_mark_node)
1361: layout_type (TREE_TYPE (newdecl));
1362: if (TREE_CODE (newdecl) != FUNCTION_DECL
1363: && TREE_CODE (newdecl) != TYPE_DECL
1364: && TREE_CODE (newdecl) != CONST_DECL)
1365: layout_decl (newdecl, 0);
1366: }
1367: else
1368: {
1369: /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1370: DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1371: if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1372: DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1373: }
1374:
1375: /* Merge the type qualifiers. */
1376: if (DECL_BUILT_IN_NONANSI (olddecl) && TREE_THIS_VOLATILE (olddecl)
1377: && !TREE_THIS_VOLATILE (newdecl))
1378: TREE_THIS_VOLATILE (olddecl) = 0;
1379: if (TREE_READONLY (newdecl))
1380: TREE_READONLY (olddecl) = 1;
1381: if (TREE_THIS_VOLATILE (newdecl))
1382: TREE_THIS_VOLATILE (olddecl) = 1;
1383:
1384: /* Keep source location of definition rather than declaration. */
1385: if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
1386: {
1387: DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
1388: DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
1389: }
1390:
1391: /* Merge the initialization information. */
1392: if (DECL_INITIAL (newdecl) == 0)
1393: DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1394: /* Keep the old rtl since we can safely use it. */
1395: DECL_RTL (newdecl) = DECL_RTL (olddecl);
1396: }
1397: /* If cannot merge, then use the new type and qualifiers,
1398: and don't preserve the old rtl. */
1399: else
1400: {
1401: TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1402: TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1403: TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1404: TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1405: }
1406:
1407: /* Merge the storage class information. */
1408: /* For functions, static overrides non-static. */
1409: if (TREE_CODE (newdecl) == FUNCTION_DECL)
1410: {
1411: TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1412: /* This is since we don't automatically
1413: copy the attributes of NEWDECL into OLDDECL. */
1414: TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1415: /* If this clears `static', clear it in the identifier too. */
1416: if (! TREE_PUBLIC (olddecl))
1417: TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1418: }
1419: if (TREE_EXTERNAL (newdecl))
1420: {
1421: TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1422: TREE_EXTERNAL (newdecl) = TREE_EXTERNAL (olddecl);
1423: /* An extern decl does not override previous storage class. */
1424: TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1425: }
1426: else
1427: {
1428: TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1429: TREE_EXTERNAL (olddecl) = 0;
1430: TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1431: }
1432: /* If either decl says `inline', this fn is inline,
1433: unless its definition was passed already. */
1434: if (TREE_INLINE (newdecl) && DECL_INITIAL (olddecl) == 0)
1435: TREE_INLINE (olddecl) = 1;
1436:
1437: /* Get rid of any built-in function if new arg types don't match it
1438: or if we have a function definition. */
1439: if (TREE_CODE (newdecl) == FUNCTION_DECL
1440: && DECL_BUILT_IN (olddecl)
1441: && (!types_match || new_is_definition))
1442: {
1443: TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1444: DECL_BUILT_IN (olddecl) = 0;
1445: }
1446:
1447: /* If redeclaring a builtin function, and not a definition,
1448: it stays built in.
1449: Also preserve various other info from the definition. */
1450: if (TREE_CODE (newdecl) == FUNCTION_DECL && !new_is_definition)
1451: {
1452: if (DECL_BUILT_IN (olddecl))
1453: {
1454: DECL_BUILT_IN (newdecl) = 1;
1455: DECL_SET_FUNCTION_CODE (newdecl, DECL_FUNCTION_CODE (olddecl));
1456: }
1457: else
1458: DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
1459:
1460: DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1461: DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1462: DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
1463: DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1464: }
1465:
1466: bcopy ((char *) newdecl + sizeof (struct tree_common),
1467: (char *) olddecl + sizeof (struct tree_common),
1468: sizeof (struct tree_decl) - sizeof (struct tree_common));
1469:
1470: return 1;
1471: }
1472:
1473: /* Record a decl-node X as belonging to the current lexical scope.
1474: Check for errors (such as an incompatible declaration for the same
1475: name already seen in the same scope).
1476:
1477: Returns either X or an old decl for the same name.
1478: If an old decl is returned, it may have been smashed
1479: to agree with what X says. */
1480:
1481: tree
1482: pushdecl (x)
1483: tree x;
1484: {
1485: register tree t;
1486: register tree name = DECL_NAME (x);
1487: register struct binding_level *b = current_binding_level;
1488:
1489: DECL_CONTEXT (x) = current_function_decl;
1490: /* A local declaration for a function doesn't constitute nesting. */
1491: if (TREE_CODE (x) == FUNCTION_DECL && DECL_INITIAL (x) == 0)
1492: DECL_CONTEXT (x) = 0;
1493:
1494: if (warn_nested_externs && TREE_EXTERNAL (x) && b != global_binding_level
1495: && x != IDENTIFIER_IMPLICIT_DECL (name))
1496: warning ("nested extern declaration of `%s'", IDENTIFIER_POINTER (name));
1497:
1498: if (name)
1499: {
1500: char *file;
1501: int line;
1502:
1503: t = lookup_name_current_level (name);
1504: if (t != 0 && t == error_mark_node)
1505: /* error_mark_node is 0 for a while during initialization! */
1506: {
1507: t = 0;
1508: error_with_decl (x, "`%s' used prior to declaration");
1509: }
1510:
1511: if (t != 0)
1512: {
1513: file = DECL_SOURCE_FILE (t);
1514: line = DECL_SOURCE_LINE (t);
1515: }
1516:
1517: if (t != 0 && duplicate_decls (x, t))
1518: {
1519: if (TREE_CODE (t) == PARM_DECL)
1520: {
1521: /* Don't allow more than one "real" duplicate
1522: of a forward parm decl. */
1523: TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
1524: return t;
1525: }
1526: /* If this decl is `static' and an implicit decl was seen previously,
1527: warn. But don't complain if -traditional,
1528: since traditional compilers don't complain. */
1529: if (!flag_traditional && TREE_PUBLIC (name)
1530: && ! TREE_PUBLIC (x) && ! TREE_EXTERNAL (x)
1531: /* We used to warn also for explicit extern followed by static,
1532: but sometimes you need to do it that way. */
1533: && IDENTIFIER_IMPLICIT_DECL (name) != 0)
1534: {
1535: pedwarn ("`%s' was declared implicitly `extern' and later `static'",
1536: IDENTIFIER_POINTER (name));
1537: pedwarn_with_file_and_line (file, line,
1538: "previous declaration of `%s'",
1539: IDENTIFIER_POINTER (name));
1540: }
1541: if (warn_redundant_decls && line != 0)
1542: {
1543: warning ("redundant redeclaration of `%s' in same scope",
1544: IDENTIFIER_POINTER (name));
1545: warning_with_file_and_line (file, line,
1546: "previous declaration of `%s'",
1547: IDENTIFIER_POINTER (name));
1548: }
1549: return t;
1550: }
1551:
1552: /* If declaring a type as a typedef, and the type has no known
1553: typedef name, install this TYPE_DECL as its typedef name. If
1554: generating prototypes, *don't* assign the current name to the
1555: existing type node, but rather give the name its own associated
1556: type node. This new type node is created as a type variant of
1557: the existing type node, but it is essentially identical to the
1558: existing one. Obviously, we don't generate these type variants
1559: if the node that we are working on is a standard type and it has
1560: not yet been assigned a name. In that case we must allow the
1561: standard type to given its standard name (by the compiler).
1562: Since all standard types are effectively declared at line zero
1563: in the source file, we can easily check to see if we are working
1564: on a standard type by checking the current value of lineno. */
1565:
1566: if (TREE_CODE (x) == TYPE_DECL)
1567: {
1568: if (DECL_SOURCE_LINE (x) == 0 || !flag_gen_aux_info)
1569: {
1570: if (TYPE_NAME (TREE_TYPE (x)) == 0)
1571: TYPE_NAME (TREE_TYPE (x)) = x;
1572: }
1573: else
1574: {
1575: tree tt = TREE_TYPE (x);
1576:
1577: tt = c_build_type_variant (tt,
1578: TYPE_READONLY (tt), TYPE_VOLATILE (tt));
1579: TYPE_NAME (tt) = x;
1580: TREE_TYPE (x) = tt;
1581: }
1582: }
1583:
1584: /* Multiple external decls of the same identifier ought to match. */
1585:
1586: if (TREE_EXTERNAL (x) && IDENTIFIER_GLOBAL_VALUE (name) != 0
1587: && (TREE_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
1588: || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name)))
1589: /* We get warnings about inline functions where they are defined.
1590: Avoid duplicate warnings where they are used. */
1591: && !TREE_INLINE (x))
1592: {
1593: if (! comptypes (TREE_TYPE (x),
1594: TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
1595: {
1596: pedwarn_with_decl (x,
1597: "type mismatch with previous external decl");
1598: pedwarn_with_decl (IDENTIFIER_GLOBAL_VALUE (name),
1599: "previous external decl of `%s'");
1600: }
1601: }
1602:
1603: /* If a function has had an implicit declaration, and then is defined,
1604: make sure they are compatible. */
1605:
1606: if (IDENTIFIER_IMPLICIT_DECL (name) != 0
1607: && IDENTIFIER_GLOBAL_VALUE (name) == 0
1608: && TREE_CODE (x) == FUNCTION_DECL
1609: && ! comptypes (TREE_TYPE (x),
1610: TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
1611: {
1612: warning_with_decl (x, "type mismatch with previous implicit declaration");
1613: warning_with_decl (x, "previous implicit declaration of `%s'");
1614: }
1615:
1616: /* In PCC-compatibility mode, extern decls of vars with no current decl
1617: take effect at top level no matter where they are. */
1618: if (flag_traditional && TREE_EXTERNAL (x)
1619: && lookup_name (name) == 0)
1620: {
1621: tree type = TREE_TYPE (x);
1622:
1623: /* But don't do this if the type contains temporary nodes. */
1624: while (type)
1625: {
1626: if (type == error_mark_node)
1627: break;
1628: if (! TREE_PERMANENT (type))
1629: {
1630: warning_with_decl (x, "type of external `%s' is not global");
1631: /* By exiting the loop early, we leave TYPE nonzero,
1632: and thus prevent globalization of the decl. */
1633: break;
1634: }
1635: else if (TREE_CODE (type) == FUNCTION_TYPE
1636: && TYPE_ARG_TYPES (type) != 0)
1637: /* The types might not be truly local,
1638: but the list of arg types certainly is temporary.
1639: Since prototypes are nontraditional,
1640: ok not to do the traditional thing. */
1641: break;
1642: type = TREE_TYPE (type);
1643: }
1644:
1645: if (type == 0)
1646: b = global_binding_level;
1647: }
1648:
1649: /* This name is new in its binding level.
1650: Install the new declaration and return it. */
1651: if (b == global_binding_level)
1652: {
1653: /* Install a global value. */
1654:
1655: /* If the first global decl has external linkage,
1656: warn if we later see static one. */
1657: if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
1658: TREE_PUBLIC (name) = 1;
1659:
1660: IDENTIFIER_GLOBAL_VALUE (name) = x;
1661:
1662: /* Don't forget if the function was used via an implicit decl. */
1663: if (IDENTIFIER_IMPLICIT_DECL (name)
1664: && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
1665: TREE_USED (x) = 1, TREE_USED (name) = 1;
1666:
1667: /* Don't forget if its address was taken in that way. */
1668: if (IDENTIFIER_IMPLICIT_DECL (name)
1669: && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
1670: TREE_ADDRESSABLE (x) = 1;
1671:
1672: /* Warn about mismatches against previous implicit decl. */
1673: if (IDENTIFIER_IMPLICIT_DECL (name) != 0
1674: /* If this real decl matches the implicit, don't complain. */
1675: && ! (TREE_CODE (x) == FUNCTION_DECL
1676: && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
1677: pedwarn ("`%s' was previously implicitly declared to return `int'",
1678: IDENTIFIER_POINTER (name));
1679:
1680: /* If this decl is `static' and an `extern' was seen previously,
1681: that is erroneous. */
1682: if (TREE_PUBLIC (name)
1683: && ! TREE_PUBLIC (x) && ! TREE_EXTERNAL (x))
1684: {
1685: if (IDENTIFIER_IMPLICIT_DECL (name))
1686: pedwarn ("`%s' was declared implicitly `extern' and later `static'",
1687: IDENTIFIER_POINTER (name));
1688: else
1689: pedwarn ("`%s' was declared `extern' and later `static'",
1690: IDENTIFIER_POINTER (name));
1691: }
1692: }
1693: else
1694: {
1695: /* Here to install a non-global value. */
1696: tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1697: tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
1698: IDENTIFIER_LOCAL_VALUE (name) = x;
1699:
1700: /* If this is an extern function declaration, see if we
1701: have a global definition for the function. */
1702: if (oldlocal == 0
1703: && TREE_EXTERNAL (x) && !TREE_INLINE (x)
1704: && oldglobal != 0
1705: && TREE_CODE (x) == FUNCTION_DECL
1706: && TREE_CODE (oldglobal) == FUNCTION_DECL)
1707: {
1708: /* We have one. Their types must agree. */
1709: if (! comptypes (TREE_TYPE (x),
1710: TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
1711: pedwarn_with_decl (x, "local declaration of `%s' doesn't match global one");
1712: /* If the global one is inline, make the local one inline. */
1713: else if (TREE_INLINE (oldglobal)
1714: || DECL_BUILT_IN (oldglobal)
1715: || (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
1716: && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0))
1717: IDENTIFIER_LOCAL_VALUE (name) = oldglobal;
1718: }
1719:
1720: #if 0 /* This case is probably sometimes the right thing to do. */
1721: /* If we have a local external declaration,
1722: then any file-scope declaration should not
1723: have been static. */
1724: if (oldlocal == 0 && oldglobal != 0
1725: && !TREE_PUBLIC (oldglobal)
1726: && TREE_EXTERNAL (x) && TREE_PUBLIC (x))
1727: warning ("`%s' locally external but globally static",
1728: IDENTIFIER_POINTER (name));
1729: #endif
1730:
1731: /* If we have a local external declaration,
1732: and no file-scope declaration has yet been seen,
1733: then if we later have a file-scope decl it must not be static. */
1734: if (oldlocal == 0
1735: && oldglobal == 0
1736: && TREE_EXTERNAL (x)
1737: && TREE_PUBLIC (x))
1738: {
1739: TREE_PUBLIC (name) = 1;
1740: }
1741:
1742: /* Warn if shadowing an argument at the top level of the body. */
1743: if (oldlocal != 0 && !TREE_EXTERNAL (x)
1744: /* This warning doesn't apply to the parms of a nested fcn. */
1745: && ! current_binding_level->parm_flag
1746: /* Check that this is one level down from the parms. */
1747: && current_binding_level->level_chain->parm_flag
1748: /* Check that the decl being shadowed
1749: comes from the parm level, one level up. */
1750: && chain_member (oldlocal, current_binding_level->level_chain->names))
1751: {
1752: if (TREE_CODE (oldlocal) == PARM_DECL)
1753: pedwarn ("declaration of `%s' shadows a parameter",
1754: IDENTIFIER_POINTER (name));
1755: else
1756: pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
1757: IDENTIFIER_POINTER (name));
1758: }
1759:
1760: /* Maybe warn if shadowing something else. */
1761: else if (warn_shadow && !TREE_EXTERNAL (x)
1762: /* No shadow warnings for vars made for inlining. */
1763: && ! DECL_FROM_INLINE (x))
1764: {
1765: char *warnstring = 0;
1766:
1767: if (TREE_CODE (x) == PARM_DECL
1768: && current_binding_level->parm_flag == 1)
1769: /* Don't warn about the parm names in a declaration. */
1770: ;
1771: else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
1772: warnstring = "declaration of `%s' shadows a parameter";
1773: else if (oldlocal != 0)
1774: warnstring = "declaration of `%s' shadows previous local";
1775: else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
1776: && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
1777: warnstring = "declaration of `%s' shadows global declaration";
1778:
1779: if (warnstring)
1780: warning (warnstring, IDENTIFIER_POINTER (name));
1781: }
1782:
1783: /* If storing a local value, there may already be one (inherited).
1784: If so, record it for restoration when this binding level ends. */
1785: if (oldlocal != 0)
1786: b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1787: }
1788:
1789: /* Keep count of variables in this level with incomplete type. */
1790: if (TYPE_SIZE (TREE_TYPE (x)) == 0)
1791: ++b->n_incomplete;
1792: }
1793:
1794: /* Put decls on list in reverse order.
1795: We will reverse them later if necessary. */
1796: TREE_CHAIN (x) = b->names;
1797: b->names = x;
1798:
1799: return x;
1800: }
1801:
1802: /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
1803:
1804: tree
1805: pushdecl_top_level (x)
1806: tree x;
1807: {
1808: register tree t;
1809: register struct binding_level *b = current_binding_level;
1810:
1811: current_binding_level = global_binding_level;
1812: t = pushdecl (x);
1813: current_binding_level = b;
1814: return t;
1815: }
1816:
1817: /* Generate an implicit declaration for identifier FUNCTIONID
1818: as a function of type int (). Print a warning if appropriate. */
1819:
1820: tree
1821: implicitly_declare (functionid)
1822: tree functionid;
1823: {
1824: register tree decl;
1825: int traditional_warning = 0;
1826: /* Only one "implicit declaration" warning per identifier. */
1827: int implicit_warning;
1828:
1829: /* Save the decl permanently so we can warn if definition follows. */
1830: push_obstacks_nochange ();
1831: end_temporary_allocation ();
1832:
1833: /* We used to reuse an old implicit decl here,
1834: but this loses with inline functions because it can clobber
1835: the saved decl chains. */
1836: /* if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
1837: decl = IDENTIFIER_IMPLICIT_DECL (functionid);
1838: else */
1839: decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
1840:
1841: /* Warn of implicit decl following explicit local extern decl.
1842: This is probably a program designed for traditional C. */
1843: if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
1844: traditional_warning = 1;
1845:
1846: /* Warn once of an implicit declaration. */
1847: implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
1848:
1849: TREE_EXTERNAL (decl) = 1;
1850: TREE_PUBLIC (decl) = 1;
1851:
1852: /* Record that we have an implicit decl and this is it. */
1853: IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
1854:
1855: /* ANSI standard says implicit declarations are in the innermost block.
1856: So we record the decl in the standard fashion.
1857: If flag_traditional is set, pushdecl does it top-level. */
1858: pushdecl (decl);
1859:
1860: /* This is a no-op in c-lang.c or something real in objc-actions.c. */
1861: maybe_objc_check_decl (decl);
1862:
1863: rest_of_decl_compilation (decl, 0, 0, 0);
1864:
1865: if (warn_implicit && implicit_warning)
1866: warning ("implicit declaration of function `%s'",
1867: IDENTIFIER_POINTER (functionid));
1868: else if (warn_traditional && traditional_warning)
1869: warning ("function `%s' was previously declared within a block",
1870: IDENTIFIER_POINTER (functionid));
1871:
1872: /* Write a record describing this implicit function declaration to the
1873: prototypes file (if requested). */
1874:
1875: gen_aux_info_record (decl, 0, 1, 0);
1876:
1877: pop_obstacks ();
1878:
1879: return decl;
1880: }
1881:
1882: /* Return zero if the declaration NEWDECL is valid
1883: when the declaration OLDDECL (assumed to be for the same name)
1884: has already been seen.
1885: Otherwise return an error message format string with a %s
1886: where the identifier should go. */
1887:
1888: static char *
1889: redeclaration_error_message (newdecl, olddecl)
1890: tree newdecl, olddecl;
1891: {
1892: if (TREE_CODE (newdecl) == TYPE_DECL)
1893: {
1894: if (flag_traditional && TREE_TYPE (newdecl) == TREE_TYPE (olddecl))
1895: return 0;
1896: return "redefinition of `%s'";
1897: }
1898: else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1899: {
1900: /* Declarations of functions can insist on internal linkage
1901: but they can't be inconsistent with internal linkage,
1902: so there can be no error on that account.
1903: However defining the same name twice is no good. */
1904: if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
1905: /* However, defining once as extern inline and a second
1906: time in another way is ok. */
1907: && !(TREE_INLINE (olddecl) && TREE_EXTERNAL (olddecl)
1908: && !(TREE_INLINE (newdecl) && TREE_EXTERNAL (newdecl))))
1909: return "redefinition of `%s'";
1910: return 0;
1911: }
1912: else if (current_binding_level == global_binding_level)
1913: {
1914: /* Objects declared at top level: */
1915: /* If at least one is a reference, it's ok. */
1916: if (TREE_EXTERNAL (newdecl) || TREE_EXTERNAL (olddecl))
1917: return 0;
1918: /* Reject two definitions. */
1919: if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
1920: return "redefinition of `%s'";
1921: /* Now we have two tentative defs, or one tentative and one real def. */
1922: /* Insist that the linkage match. */
1923: if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
1924: return "conflicting declarations of `%s'";
1925: return 0;
1926: }
1927: else if (current_binding_level->parm_flag
1928: && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
1929: return 0;
1930: else
1931: {
1932: /* Objects declared with block scope: */
1933: /* Reject two definitions, and reject a definition
1934: together with an external reference. */
1935: if (!(TREE_EXTERNAL (newdecl) && TREE_EXTERNAL (olddecl)))
1936: return "redeclaration of `%s'";
1937: return 0;
1938: }
1939: }
1940:
1941: /* Get the LABEL_DECL corresponding to identifier ID as a label.
1942: Create one if none exists so far for the current function.
1943: This function is called for both label definitions and label references. */
1944:
1945: tree
1946: lookup_label (id)
1947: tree id;
1948: {
1949: register tree decl = IDENTIFIER_LABEL_VALUE (id);
1950:
1951: /* Use a label already defined or ref'd with this name. */
1952: if (decl != 0)
1953: {
1954: /* But not if it is inherited and wasn't declared to be inheritable. */
1955: if (DECL_CONTEXT (decl) != current_function_decl
1956: && ! C_DECLARED_LABEL_FLAG (decl))
1957: return shadow_label (id);
1958: return decl;
1959: }
1960:
1961: decl = build_decl (LABEL_DECL, id, void_type_node);
1962:
1963: /* A label not explicitly declared must be local to where it's ref'd. */
1964: DECL_CONTEXT (decl) = current_function_decl;
1965:
1966: DECL_MODE (decl) = VOIDmode;
1967:
1968: /* Say where one reference is to the label,
1969: for the sake of the error if it is not defined. */
1970: DECL_SOURCE_LINE (decl) = lineno;
1971: DECL_SOURCE_FILE (decl) = input_filename;
1972:
1973: IDENTIFIER_LABEL_VALUE (id) = decl;
1974:
1975: named_labels = tree_cons (NULL_TREE, decl, named_labels);
1976:
1977: return decl;
1978: }
1979:
1980: /* Make a label named NAME in the current function,
1981: shadowing silently any that may be inherited from containing functions
1982: or containing scopes.
1983:
1984: Note that valid use, if the label being shadowed
1985: comes from another scope in the same function,
1986: requires calling declare_nonlocal_label right away. */
1987:
1988: tree
1989: shadow_label (name)
1990: tree name;
1991: {
1992: register tree decl = IDENTIFIER_LABEL_VALUE (name);
1993:
1994: if (decl != 0)
1995: {
1996: shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
1997: IDENTIFIER_LABEL_VALUE (name) = decl = 0;
1998: }
1999:
2000: return lookup_label (name);
2001: }
2002:
2003: /* Define a label, specifying the location in the source file.
2004: Return the LABEL_DECL node for the label, if the definition is valid.
2005: Otherwise return 0. */
2006:
2007: tree
2008: define_label (filename, line, name)
2009: char *filename;
2010: int line;
2011: tree name;
2012: {
2013: tree decl = lookup_label (name);
2014:
2015: /* If label with this name is known from an outer context, shadow it. */
2016: if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
2017: {
2018: shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
2019: IDENTIFIER_LABEL_VALUE (name) = 0;
2020: decl = lookup_label (name);
2021: }
2022:
2023: if (DECL_INITIAL (decl) != 0)
2024: {
2025: error_with_decl (decl, "duplicate label `%s'");
2026: return 0;
2027: }
2028: else
2029: {
2030: /* Mark label as having been defined. */
2031: DECL_INITIAL (decl) = error_mark_node;
2032: /* Say where in the source. */
2033: DECL_SOURCE_FILE (decl) = filename;
2034: DECL_SOURCE_LINE (decl) = line;
2035: return decl;
2036: }
2037: }
2038:
2039: /* Return the list of declarations of the current level.
2040: Note that this list is in reverse order unless/until
2041: you nreverse it; and when you do nreverse it, you must
2042: store the result back using `storedecls' or you will lose. */
2043:
2044: tree
2045: getdecls ()
2046: {
2047: return current_binding_level->names;
2048: }
2049:
2050: /* Return the list of type-tags (for structs, etc) of the current level. */
2051:
2052: tree
2053: gettags ()
2054: {
2055: return current_binding_level->tags;
2056: }
2057:
2058: /* Store the list of declarations of the current level.
2059: This is done for the parameter declarations of a function being defined,
2060: after they are modified in the light of any missing parameters. */
2061:
2062: static void
2063: storedecls (decls)
2064: tree decls;
2065: {
2066: current_binding_level->names = decls;
2067: }
2068:
2069: /* Similarly, store the list of tags of the current level. */
2070:
2071: static void
2072: storetags (tags)
2073: tree tags;
2074: {
2075: current_binding_level->tags = tags;
2076: }
2077:
2078: /* Given NAME, an IDENTIFIER_NODE,
2079: return the structure (or union or enum) definition for that name.
2080: Searches binding levels from BINDING_LEVEL up to the global level.
2081: If THISLEVEL_ONLY is nonzero, searches only the specified context
2082: (but skips any tag-transparent contexts to find one that is
2083: meaningful for tags).
2084: CODE says which kind of type the caller wants;
2085: it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2086: If the wrong kind of type is found, an error is reported. */
2087:
2088: static tree
2089: lookup_tag (code, name, binding_level, thislevel_only)
2090: enum tree_code code;
2091: struct binding_level *binding_level;
2092: tree name;
2093: int thislevel_only;
2094: {
2095: register struct binding_level *level;
2096:
2097: for (level = binding_level; level; level = level->level_chain)
2098: {
2099: register tree tail;
2100: for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2101: {
2102: if (TREE_PURPOSE (tail) == name)
2103: {
2104: if (TREE_CODE (TREE_VALUE (tail)) != code)
2105: {
2106: /* Definition isn't the kind we were looking for. */
2107: pending_invalid_xref = name;
2108: pending_invalid_xref_file = input_filename;
2109: pending_invalid_xref_line = lineno;
2110: }
2111: return TREE_VALUE (tail);
2112: }
2113: }
2114: if (thislevel_only && ! level->tag_transparent)
2115: return NULL_TREE;
2116: }
2117: return NULL_TREE;
2118: }
2119:
2120: /* Print an error message now
2121: for a recent invalid struct, union or enum cross reference.
2122: We don't print them immediately because they are not invalid
2123: when used in the `struct foo;' construct for shadowing. */
2124:
2125: void
2126: pending_xref_error ()
2127: {
2128: if (pending_invalid_xref != 0)
2129: error_with_file_and_line (pending_invalid_xref_file,
2130: pending_invalid_xref_line,
2131: "`%s' defined as wrong kind of tag",
2132: IDENTIFIER_POINTER (pending_invalid_xref));
2133: pending_invalid_xref = 0;
2134: }
2135:
2136: /* Given a type, find the tag that was defined for it and return the tag name.
2137: Otherwise return 0. */
2138:
2139: static tree
2140: lookup_tag_reverse (type)
2141: tree type;
2142: {
2143: register struct binding_level *level;
2144:
2145: for (level = current_binding_level; level; level = level->level_chain)
2146: {
2147: register tree tail;
2148: for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
2149: {
2150: if (TREE_VALUE (tail) == type)
2151: return TREE_PURPOSE (tail);
2152: }
2153: }
2154: return NULL_TREE;
2155: }
2156:
2157: /* Look up NAME in the current binding level and its superiors
2158: in the namespace of variables, functions and typedefs.
2159: Return a ..._DECL node of some kind representing its definition,
2160: or return 0 if it is undefined. */
2161:
2162: tree
2163: lookup_name (name)
2164: tree name;
2165: {
2166: register tree val;
2167: if (current_binding_level != global_binding_level
2168: && IDENTIFIER_LOCAL_VALUE (name))
2169: val = IDENTIFIER_LOCAL_VALUE (name);
2170: else
2171: val = IDENTIFIER_GLOBAL_VALUE (name);
2172: return val;
2173: }
2174:
2175: /* Similar to `lookup_name' but look only at current binding level. */
2176:
2177: static tree
2178: lookup_name_current_level (name)
2179: tree name;
2180: {
2181: register tree t;
2182:
2183: if (current_binding_level == global_binding_level)
2184: return IDENTIFIER_GLOBAL_VALUE (name);
2185:
2186: if (IDENTIFIER_LOCAL_VALUE (name) == 0)
2187: return 0;
2188:
2189: for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
2190: if (DECL_NAME (t) == name)
2191: break;
2192:
2193: return t;
2194: }
2195:
2196: /* Create the predefined scalar types of C,
2197: and some nodes representing standard constants (0, 1, (void *)0).
2198: Initialize the global binding level.
2199: Make definitions for built-in primitive functions. */
2200:
2201: void
2202: init_decl_processing ()
2203: {
2204: register tree endlink;
2205: /* Either char* or void*. */
2206: tree traditional_ptr_type_node;
2207: /* Data type of memcpy. */
2208: tree memcpy_ftype;
2209: int wchar_type_size;
2210: tree temp;
2211:
2212: current_function_decl = NULL;
2213: named_labels = NULL;
2214: current_binding_level = NULL_BINDING_LEVEL;
2215: free_binding_level = NULL_BINDING_LEVEL;
2216: pushlevel (0); /* make the binding_level structure for global names */
2217: global_binding_level = current_binding_level;
2218:
2219: /* Define `int' and `char' first so that dbx will output them first. */
2220:
2221: integer_type_node = make_signed_type (INT_TYPE_SIZE);
2222: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_INT],
2223: integer_type_node));
2224:
2225: /* Define `char', which is like either `signed char' or `unsigned char'
2226: but not the same as either. */
2227:
2228: char_type_node =
2229: (flag_signed_char
2230: ? make_signed_type (CHAR_TYPE_SIZE)
2231: : make_unsigned_type (CHAR_TYPE_SIZE));
2232: pushdecl (build_decl (TYPE_DECL, get_identifier ("char"),
2233: char_type_node));
2234:
2235: long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
2236: pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"),
2237: long_integer_type_node));
2238:
2239: unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
2240: pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
2241: unsigned_type_node));
2242:
2243: long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
2244: pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"),
2245: long_unsigned_type_node));
2246:
2247: /* `unsigned long' is the standard type for sizeof.
2248: Traditionally, use a signed type.
2249: Note that stddef.h uses `unsigned long',
2250: and this must agree, even of long and int are the same size. */
2251: if (flag_traditional)
2252: sizetype = long_integer_type_node;
2253: else
2254: sizetype
2255: = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
2256:
2257: ptrdiff_type_node
2258: = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
2259:
2260: TREE_TYPE (TYPE_SIZE (integer_type_node)) = sizetype;
2261: TREE_TYPE (TYPE_SIZE (char_type_node)) = sizetype;
2262: TREE_TYPE (TYPE_SIZE (unsigned_type_node)) = sizetype;
2263: TREE_TYPE (TYPE_SIZE (long_unsigned_type_node)) = sizetype;
2264: TREE_TYPE (TYPE_SIZE (long_integer_type_node)) = sizetype;
2265:
2266: error_mark_node = make_node (ERROR_MARK);
2267: TREE_TYPE (error_mark_node) = error_mark_node;
2268:
2269: short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
2270: pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"),
2271: short_integer_type_node));
2272:
2273: long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
2274: pushdecl (build_decl (TYPE_DECL, get_identifier ("long long int"),
2275: long_long_integer_type_node));
2276:
2277: short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
2278: pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"),
2279: short_unsigned_type_node));
2280:
2281: long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
2282: pushdecl (build_decl (TYPE_DECL, get_identifier ("long long unsigned int"),
2283: long_long_unsigned_type_node));
2284:
2285: /* Define both `signed char' and `unsigned char'. */
2286: signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
2287: pushdecl (build_decl (TYPE_DECL, get_identifier ("signed char"),
2288: signed_char_type_node));
2289:
2290: unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
2291: pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"),
2292: unsigned_char_type_node));
2293:
2294: float_type_node = make_node (REAL_TYPE);
2295: TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
2296: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_FLOAT],
2297: float_type_node));
2298: layout_type (float_type_node);
2299:
2300: double_type_node = make_node (REAL_TYPE);
2301: if (flag_short_double)
2302: TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
2303: else
2304: TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
2305: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_DOUBLE],
2306: double_type_node));
2307: layout_type (double_type_node);
2308:
2309: long_double_type_node = make_node (REAL_TYPE);
2310: TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
2311: pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"),
2312: long_double_type_node));
2313: layout_type (long_double_type_node);
2314:
2315: wchar_type_node
2316: = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
2317: wchar_type_size = TYPE_PRECISION (wchar_type_node);
2318: signed_wchar_type_node = type_for_size (wchar_type_size, 0);
2319: unsigned_wchar_type_node = type_for_size (wchar_type_size, 1);
2320:
2321: integer_zero_node = build_int_2 (0, 0);
2322: TREE_TYPE (integer_zero_node) = integer_type_node;
2323: integer_one_node = build_int_2 (1, 0);
2324: TREE_TYPE (integer_one_node) = integer_type_node;
2325:
2326: size_zero_node = build_int_2 (0, 0);
2327: TREE_TYPE (size_zero_node) = sizetype;
2328: size_one_node = build_int_2 (1, 0);
2329: TREE_TYPE (size_one_node) = sizetype;
2330:
2331: void_type_node = make_node (VOID_TYPE);
2332: pushdecl (build_decl (TYPE_DECL,
2333: ridpointers[(int) RID_VOID], void_type_node));
2334: layout_type (void_type_node); /* Uses integer_zero_node */
2335: /* We are not going to have real types in C with less than byte alignment,
2336: so we might as well not have any types that claim to have it. */
2337: TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
2338:
2339: null_pointer_node = build_int_2 (0, 0);
2340: TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
2341: layout_type (TREE_TYPE (null_pointer_node));
2342:
2343: string_type_node = build_pointer_type (char_type_node);
2344: const_string_type_node
2345: = build_pointer_type (build_type_variant (char_type_node, 1, 0));
2346:
2347: /* make a type for arrays of 256 characters.
2348: 256 is picked randomly because we have a type for integers from 0 to 255.
2349: With luck nothing will ever really depend on the length of this
2350: array type. */
2351: char_array_type_node
2352: = build_array_type (char_type_node, unsigned_char_type_node);
2353: /* Likewise for arrays of ints. */
2354: int_array_type_node
2355: = build_array_type (integer_type_node, unsigned_char_type_node);
2356: /* This is for wide string constants. */
2357: wchar_array_type_node
2358: = build_array_type (wchar_type_node, unsigned_char_type_node);
2359:
2360: default_function_type
2361: = build_function_type (integer_type_node, NULL_TREE);
2362:
2363: ptr_type_node = build_pointer_type (void_type_node);
2364: const_ptr_type_node
2365: = build_pointer_type (build_type_variant (void_type_node, 1, 0));
2366:
2367: endlink = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
2368:
2369: double_ftype_double
2370: = build_function_type (double_type_node,
2371: tree_cons (NULL_TREE, double_type_node, endlink));
2372:
2373: double_ftype_double_double
2374: = build_function_type (double_type_node,
2375: tree_cons (NULL_TREE, double_type_node,
2376: tree_cons (NULL_TREE,
2377: double_type_node, endlink)));
2378:
2379: int_ftype_int
2380: = build_function_type (integer_type_node,
2381: tree_cons (NULL_TREE, integer_type_node, endlink));
2382:
2383: long_ftype_long
2384: = build_function_type (long_integer_type_node,
2385: tree_cons (NULL_TREE,
2386: long_integer_type_node, endlink));
2387:
2388: void_ftype_ptr_ptr_int
2389: = build_function_type (void_type_node,
2390: tree_cons (NULL_TREE, ptr_type_node,
2391: tree_cons (NULL_TREE, ptr_type_node,
2392: tree_cons (NULL_TREE,
2393: integer_type_node,
2394: endlink))));
2395:
2396: int_ftype_cptr_cptr_sizet
2397: = build_function_type (integer_type_node,
2398: tree_cons (NULL_TREE, const_ptr_type_node,
2399: tree_cons (NULL_TREE, const_ptr_type_node,
2400: tree_cons (NULL_TREE,
2401: sizetype,
2402: endlink))));
2403:
2404: void_ftype_ptr_int_int
2405: = build_function_type (void_type_node,
2406: tree_cons (NULL_TREE, ptr_type_node,
2407: tree_cons (NULL_TREE, integer_type_node,
2408: tree_cons (NULL_TREE,
2409: integer_type_node,
2410: endlink))));
2411:
2412: string_ftype_ptr_ptr /* strcpy prototype */
2413: = build_function_type (string_type_node,
2414: tree_cons (NULL_TREE, string_type_node,
2415: tree_cons (NULL_TREE,
2416: const_string_type_node,
2417: endlink)));
2418:
2419: int_ftype_string_string /* strcmp prototype */
2420: = build_function_type (integer_type_node,
2421: tree_cons (NULL_TREE, const_string_type_node,
2422: tree_cons (NULL_TREE,
2423: const_string_type_node,
2424: endlink)));
2425:
2426: sizet_ftype_string /* strlen prototype */
2427: = build_function_type (sizetype,
2428: tree_cons (NULL_TREE, const_string_type_node,
2429: endlink));
2430:
2431: traditional_ptr_type_node
2432: = (flag_traditional ? string_type_node : ptr_type_node);
2433:
2434: memcpy_ftype /* memcpy prototype */
2435: = build_function_type (traditional_ptr_type_node,
2436: tree_cons (NULL_TREE, ptr_type_node,
2437: tree_cons (NULL_TREE, const_ptr_type_node,
2438: tree_cons (NULL_TREE,
2439: sizetype,
2440: endlink))));
2441:
2442: /* ``integer_tpe_node'' mispelling corrected: North-Keys 30 Mar 91 */
2443: builtin_function ("__builtin_constant_p",
2444: build_function_type (integer_type_node, endlink),
2445: BUILT_IN_CONSTANT_P, 0);
2446:
2447: builtin_function ("__builtin_return_address",
2448: build_function_type (integer_type_node,
2449: tree_cons (NULL_TREE,
2450: unsigned_type_node,
2451: endlink)),
2452: BUILT_IN_RETURN_ADDRESS, 0);
2453:
2454: builtin_function ("__builtin_frame_address",
2455: build_function_type (integer_type_node,
2456: tree_cons (NULL_TREE,
2457: unsigned_type_node,
2458: endlink)),
2459: BUILT_IN_FRAME_ADDRESS, 0);
2460:
2461: builtin_function ("__builtin_alloca",
2462: build_function_type (ptr_type_node,
2463: tree_cons (NULL_TREE,
2464: sizetype,
2465: endlink)),
2466: BUILT_IN_ALLOCA, "alloca");
2467: if (! flag_no_builtin)
2468: {
2469: tree exit_type;
2470: temp = builtin_function ("alloca",
2471: build_function_type (ptr_type_node,
2472: tree_cons (NULL_TREE,
2473: sizetype,
2474: endlink)),
2475: BUILT_IN_ALLOCA, 0);
2476: /* Suppress error if redefined as a non-function. */
2477: DECL_BUILT_IN_NONANSI (temp) = 1;
2478: /* Declare these functions volatile
2479: to avoid spurious "control drops through" warnings. */
2480: /* Don't specify the argument types, to avoid errors
2481: from certain code which isn't valid in ANSI but which exists. */
2482: temp = builtin_function ("abort",
2483: build_function_type (void_type_node, 0),
2484: NOT_BUILT_IN, 0);
2485: TREE_THIS_VOLATILE (temp) = 1;
2486: TREE_SIDE_EFFECTS (temp) = 1;
2487: /* Suppress error if redefined as a non-function. */
2488: DECL_BUILT_IN_NONANSI (temp) = 1;
2489: exit_type = build_function_type (void_type_node, 0);
2490: temp = builtin_function ("exit", exit_type, NOT_BUILT_IN, 0);
2491: TREE_THIS_VOLATILE (temp) = 1;
2492: TREE_SIDE_EFFECTS (temp) = 1;
2493: /* Suppress error if redefined as a non-function. */
2494: DECL_BUILT_IN_NONANSI (temp) = 1;
2495: temp = builtin_function ("_exit", exit_type, NOT_BUILT_IN, 0);
2496: TREE_THIS_VOLATILE (temp) = 1;
2497: TREE_SIDE_EFFECTS (temp) = 1;
2498: /* Suppress error if redefined as a non-function. */
2499: DECL_BUILT_IN_NONANSI (temp) = 1;
2500: }
2501:
2502: builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, 0);
2503: builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS, 0);
2504: builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS, 0);
2505: builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, 0);
2506: builtin_function ("__builtin_saveregs", default_function_type,
2507: BUILT_IN_SAVEREGS, 0);
2508: /* EXPAND_BUILTIN_VARARGS is obsolete. */
2509: #if 0
2510: builtin_function ("__builtin_varargs",
2511: build_function_type (ptr_type_node,
2512: tree_cons (NULL_TREE,
2513: integer_type_node,
2514: endlink)),
2515: BUILT_IN_VARARGS, 0);
2516: #endif
2517: builtin_function ("__builtin_classify_type", default_function_type,
2518: BUILT_IN_CLASSIFY_TYPE, 0);
2519: builtin_function ("__builtin_next_arg",
2520: build_function_type (ptr_type_node, endlink),
2521: BUILT_IN_NEXT_ARG, 0);
2522: builtin_function ("__builtin_args_info",
2523: build_function_type (integer_type_node,
2524: tree_cons (NULL_TREE,
2525: integer_type_node,
2526: endlink)),
2527: BUILT_IN_ARGS_INFO, 0);
2528:
2529: /* Currently under experimentation. */
2530: builtin_function ("__builtin_memcpy", memcpy_ftype,
2531: BUILT_IN_MEMCPY, "memcpy");
2532: builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
2533: BUILT_IN_MEMCMP, "memcmp");
2534: builtin_function ("__builtin_strcmp", int_ftype_string_string,
2535: BUILT_IN_STRCMP, "strcmp");
2536: builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
2537: BUILT_IN_STRCPY, "strcpy");
2538: builtin_function ("__builtin_strlen", sizet_ftype_string,
2539: BUILT_IN_STRLEN, "strlen");
2540: /* In an ANSI C program, it is okay to supply built-in meanings
2541: for these functions, since applications cannot validly use them
2542: with any other meaning.
2543: However, a traditional C program can do so. */
2544: if (!flag_traditional)
2545: {
2546: builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, 0);
2547: builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, 0);
2548: builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, 0);
2549: builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, 0);
2550: builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP, 0);
2551: builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP, 0);
2552: builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY, 0);
2553: builtin_function ("strlen", sizet_ftype_string, BUILT_IN_STRLEN, 0);
2554: }
2555:
2556: #if 0
2557: /* Support for these has not been written in either expand_builtin
2558: or build_function_call. */
2559: builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, 0);
2560: builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, 0);
2561: builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR, 0);
2562: builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL, 0);
2563: builtin_function ("__builtin_fmod", double_ftype_double_double, BUILT_IN_FMOD, 0);
2564: builtin_function ("__builtin_frem", double_ftype_double_double, BUILT_IN_FREM, 0);
2565: builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int, BUILT_IN_MEMSET, 0);
2566: builtin_function ("__builtin_fsqrt", double_ftype_double, BUILT_IN_FSQRT, 0);
2567: builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP, 0);
2568: builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN, 0);
2569: #endif
2570:
2571: start_identifier_warnings ();
2572:
2573: init_format_info_table ();
2574: }
2575:
2576: /* Return a definition for a builtin function named NAME and whose data type
2577: is TYPE. TYPE should be a function type with argument types.
2578: FUNCTION_CODE tells later passes how to compile calls to this function.
2579: See tree.h for its possible values.
2580:
2581: If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
2582: the name to be called if we can't opencode the function. */
2583:
2584: static tree
2585: builtin_function (name, type, function_code, library_name)
2586: char *name;
2587: tree type;
2588: enum built_in_function function_code;
2589: char *library_name;
2590: {
2591: tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
2592: TREE_EXTERNAL (decl) = 1;
2593: TREE_PUBLIC (decl) = 1;
2594: if (library_name)
2595: DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
2596: make_decl_rtl (decl, 0, 1);
2597: pushdecl (decl);
2598: if (function_code != NOT_BUILT_IN)
2599: {
2600: DECL_BUILT_IN (decl) = 1;
2601: DECL_SET_FUNCTION_CODE (decl, function_code);
2602: }
2603:
2604: return decl;
2605: }
2606:
2607: /* Called when a declaration is seen that contains no names to declare.
2608: If its type is a reference to a structure, union or enum inherited
2609: from a containing scope, shadow that tag name for the current scope
2610: with a forward reference.
2611: If its type defines a new named structure or union
2612: or defines an enum, it is valid but we need not do anything here.
2613: Otherwise, it is an error. */
2614:
2615: void
2616: shadow_tag (declspecs)
2617: tree declspecs;
2618: {
2619: int found_tag = 0;
2620: int warned = 0;
2621: register tree link;
2622:
2623: pending_invalid_xref = 0;
2624:
2625: for (link = declspecs; link; link = TREE_CHAIN (link))
2626: {
2627: register tree value = TREE_VALUE (link);
2628: register enum tree_code code = TREE_CODE (value);
2629:
2630: if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
2631: /* Used to test also that TYPE_SIZE (value) != 0.
2632: That caused warning for `struct foo;' at top level in the file. */
2633: {
2634: register tree name = lookup_tag_reverse (value);
2635: register tree t;
2636:
2637: found_tag++;
2638:
2639: if (name == 0)
2640: {
2641: if (code != ENUMERAL_TYPE) /* Empty unnamed enum OK */
2642: {
2643: pedwarn ("unnamed struct/union that defines no instances");
2644: warned = 1;
2645: }
2646: }
2647: else
2648: {
2649: t = lookup_tag (code, name, current_binding_level, 1);
2650:
2651: if (t == 0)
2652: {
2653: t = make_node (code);
2654: pushtag (name, t);
2655: }
2656: }
2657: }
2658: else
2659: {
2660: if (!warned)
2661: warning ("useless keyword or type name in empty declaration");
2662: warned = 1;
2663: }
2664: }
2665:
2666: if (!warned)
2667: {
2668: if (found_tag > 1)
2669: error ("two types specified in one empty declaration");
2670: if (found_tag == 0)
2671: pedwarn ("empty declaration");
2672: }
2673: }
2674:
2675: /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
2676:
2677: tree
2678: groktypename (typename)
2679: tree typename;
2680: {
2681: if (TREE_CODE (typename) != TREE_LIST)
2682: return typename;
2683: return grokdeclarator (TREE_VALUE (typename),
2684: TREE_PURPOSE (typename),
2685: TYPENAME, 0);
2686: }
2687:
2688: /* Return a PARM_DECL node for a given pair of specs and declarator. */
2689:
2690: tree
2691: groktypename_in_parm_context (typename)
2692: tree typename;
2693: {
2694: if (TREE_CODE (typename) != TREE_LIST)
2695: return typename;
2696: return grokdeclarator (TREE_VALUE (typename),
2697: TREE_PURPOSE (typename),
2698: PARM, 0);
2699: }
2700:
2701: /* Decode a declarator in an ordinary declaration or data definition.
2702: This is called as soon as the type information and variable name
2703: have been parsed, before parsing the initializer if any.
2704: Here we create the ..._DECL node, fill in its type,
2705: and put it on the list of decls for the current context.
2706: The ..._DECL node is returned as the value.
2707:
2708: Exception: for arrays where the length is not specified,
2709: the type is left null, to be filled in by `finish_decl'.
2710:
2711: Function definitions do not come here; they go to start_function
2712: instead. However, external and forward declarations of functions
2713: do go through here. Structure field declarations are done by
2714: grokfield and not through here. */
2715:
2716: /* Set this to zero to debug not using the temporary obstack
2717: to parse initializers. */
2718: int debug_temp_inits = 1;
2719:
2720: tree
2721: start_decl (declarator, declspecs, initialized)
2722: tree declspecs, declarator;
2723: int initialized;
2724: {
2725: register tree decl = grokdeclarator (declarator, declspecs,
2726: NORMAL, initialized);
2727: register tree tem;
2728: int init_written = initialized;
2729:
2730: /* The corresponding pop_obstacks is in finish_decl. */
2731: push_obstacks_nochange ();
2732:
2733: if (initialized)
2734: /* Is it valid for this decl to have an initializer at all?
2735: If not, set INITIALIZED to zero, which will indirectly
2736: tell `finish_decl' to ignore the initializer once it is parsed. */
2737: switch (TREE_CODE (decl))
2738: {
2739: case TYPE_DECL:
2740: /* typedef foo = bar means give foo the same type as bar.
2741: We haven't parsed bar yet, so `finish_decl' will fix that up.
2742: Any other case of an initialization in a TYPE_DECL is an error. */
2743: if (pedantic || list_length (declspecs) > 1)
2744: {
2745: error ("typedef `%s' is initialized",
2746: IDENTIFIER_POINTER (DECL_NAME (decl)));
2747: initialized = 0;
2748: }
2749: break;
2750:
2751: case FUNCTION_DECL:
2752: error ("function `%s' is initialized like a variable",
2753: IDENTIFIER_POINTER (DECL_NAME (decl)));
2754: initialized = 0;
2755: break;
2756:
2757: case PARM_DECL:
2758: /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
2759: error ("parameter `%s' is initialized",
2760: IDENTIFIER_POINTER (DECL_NAME (decl)));
2761: initialized = 0;
2762: break;
2763:
2764: default:
2765: /* Don't allow initializations for incomplete types
2766: except for arrays which might be completed by the initialization. */
2767: if (TYPE_SIZE (TREE_TYPE (decl)) != 0)
2768: {
2769: /* A complete type is ok if size is fixed. */
2770:
2771: if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
2772: || C_DECL_VARIABLE_SIZE (decl))
2773: {
2774: error ("variable-sized object may not be initialized");
2775: initialized = 0;
2776: }
2777: }
2778: else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
2779: {
2780: error ("variable `%s' has initializer but incomplete type",
2781: IDENTIFIER_POINTER (DECL_NAME (decl)));
2782: initialized = 0;
2783: }
2784: else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0)
2785: {
2786: error ("elements of array `%s' have incomplete type",
2787: IDENTIFIER_POINTER (DECL_NAME (decl)));
2788: initialized = 0;
2789: }
2790: }
2791:
2792: if (initialized)
2793: {
2794: #if 0 /* Seems redundant with grokdeclarator. */
2795: if (current_binding_level != global_binding_level
2796: && TREE_EXTERNAL (decl)
2797: && TREE_CODE (decl) != FUNCTION_DECL)
2798: warning ("declaration of `%s' has `extern' and is initialized",
2799: IDENTIFIER_POINTER (DECL_NAME (decl)));
2800: #endif
2801: TREE_EXTERNAL (decl) = 0;
2802: if (current_binding_level == global_binding_level)
2803: TREE_STATIC (decl) = 1;
2804:
2805: /* Tell `pushdecl' this is an initialized decl
2806: even though we don't yet have the initializer expression.
2807: Also tell `finish_decl' it may store the real initializer. */
2808: DECL_INITIAL (decl) = error_mark_node;
2809: }
2810:
2811: /* If this is a function declaration, write a record describing it to the
2812: prototypes file (if requested). */
2813:
2814: if (TREE_CODE (decl) == FUNCTION_DECL)
2815: gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
2816:
2817: /* Add this decl to the current binding level.
2818: TEM may equal DECL or it may be a previous decl of the same name. */
2819: tem = pushdecl (decl);
2820:
2821: /* For a local variable, define the RTL now. */
2822: if (current_binding_level != global_binding_level
2823: /* But not if this is a duplicate decl
2824: and we preserved the rtl from the previous one
2825: (which may or may not happen). */
2826: && DECL_RTL (tem) == 0)
2827: {
2828: if (TYPE_SIZE (TREE_TYPE (tem)) != 0)
2829: expand_decl (tem);
2830: else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
2831: && DECL_INITIAL (tem) != 0)
2832: expand_decl (tem);
2833: }
2834:
2835: if (init_written)
2836: {
2837: /* When parsing and digesting the initializer,
2838: use temporary storage. Do this even if we will ignore the value. */
2839: if (current_binding_level == global_binding_level && debug_temp_inits)
2840: temporary_allocation ();
2841: }
2842:
2843: return tem;
2844: }
2845:
2846: /* Finish processing of a declaration;
2847: install its initial value.
2848: If the length of an array type is not known before,
2849: it must be determined now, from the initial value, or it is an error. */
2850:
2851: void
2852: finish_decl (decl, init, asmspec_tree)
2853: tree decl, init;
2854: tree asmspec_tree;
2855: {
2856: register tree type = TREE_TYPE (decl);
2857: int was_incomplete = (DECL_SIZE (decl) == 0);
2858: int temporary = allocation_temporary_p ();
2859: char *asmspec = 0;
2860:
2861: if (asmspec_tree)
2862: asmspec = TREE_STRING_POINTER (asmspec_tree);
2863:
2864: /* If `start_decl' didn't like having an initialization, ignore it now. */
2865:
2866: if (init != 0 && DECL_INITIAL (decl) == 0)
2867: init = 0;
2868: /* Don't crash if parm is initialized. */
2869: if (TREE_CODE (decl) == PARM_DECL)
2870: init = 0;
2871:
2872: if (init)
2873: {
2874: if (TREE_CODE (decl) != TYPE_DECL)
2875: store_init_value (decl, init);
2876: else
2877: {
2878: /* typedef foo = bar; store the type of bar as the type of foo. */
2879: TREE_TYPE (decl) = TREE_TYPE (init);
2880: DECL_INITIAL (decl) = init = 0;
2881: }
2882: }
2883:
2884: /* For top-level declaration, the initial value was read in
2885: the temporary obstack. MAXINDEX, rtl, etc. to be made below
2886: must go in the permanent obstack; but don't discard the
2887: temporary data yet. */
2888:
2889: if (current_binding_level == global_binding_level && temporary)
2890: end_temporary_allocation ();
2891:
2892: /* Deduce size of array from initialization, if not already known */
2893:
2894: if (TREE_CODE (type) == ARRAY_TYPE
2895: && TYPE_DOMAIN (type) == 0
2896: && TREE_CODE (decl) != TYPE_DECL)
2897: {
2898: int do_default
2899: = (TREE_STATIC (decl)
2900: /* Even if pedantic, an external linkage array
2901: may have incomplete type at first. */
2902: ? pedantic && !TREE_PUBLIC (decl)
2903: : !TREE_EXTERNAL (decl));
2904: int failure
2905: = complete_array_type (type, DECL_INITIAL (decl), do_default);
2906:
2907: /* Get the completed type made by complete_array_type. */
2908: type = TREE_TYPE (decl);
2909:
2910: if (failure == 1)
2911: error_with_decl (decl, "initializer fails to determine size of `%s'");
2912:
2913: if (failure == 2)
2914: {
2915: if (do_default)
2916: error_with_decl (decl, "array size missing in `%s'");
2917: else if (!pedantic && TREE_STATIC (decl))
2918: TREE_EXTERNAL (decl) = 1;
2919: }
2920:
2921: if (pedantic && TYPE_DOMAIN (type) != 0
2922: && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
2923: integer_zero_node))
2924: error_with_decl (decl, "zero-size array `%s'");
2925:
2926: layout_decl (decl, 0);
2927: }
2928:
2929: if (TREE_CODE (decl) == VAR_DECL)
2930: {
2931: if (TREE_STATIC (decl) && DECL_SIZE (decl) == 0)
2932: {
2933: /* A static variable with an incomplete type:
2934: that is an error if it is initialized or `static'.
2935: Otherwise, let it through, but if it is not `extern'
2936: then it may cause an error message later. */
2937: if (! (TREE_PUBLIC (decl) && DECL_INITIAL (decl) == 0))
2938: error_with_decl (decl, "storage size of `%s' isn't known");
2939: }
2940: else if (!TREE_EXTERNAL (decl) && DECL_SIZE (decl) == 0)
2941: {
2942: /* An automatic variable with an incomplete type:
2943: that is an error. */
2944: error_with_decl (decl, "storage size of `%s' isn't known");
2945: TREE_TYPE (decl) = error_mark_node;
2946: }
2947:
2948: if ((TREE_EXTERNAL (decl) || TREE_STATIC (decl))
2949: && DECL_SIZE (decl) != 0
2950: && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
2951: error_with_decl (decl, "storage size of `%s' isn't constant");
2952: }
2953:
2954: /* Output the assembler code and/or RTL code for variables and functions,
2955: unless the type is an undefined structure or union.
2956: If not, it will get done when the type is completed. */
2957:
2958: if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
2959: {
2960: if (flag_traditional && allocation_temporary_p ())
2961: {
2962: push_obstacks_nochange ();
2963: end_temporary_allocation ();
2964: /* This is a no-op in c-lang.c or something real in objc-actions.c. */
2965: maybe_objc_check_decl (decl);
2966: rest_of_decl_compilation (decl, asmspec,
2967: current_binding_level == global_binding_level,
2968: 0);
2969: pop_obstacks ();
2970: }
2971: else
2972: {
2973: /* This is a no-op in c-lang.c or something real in objc-actions.c. */
2974: maybe_objc_check_decl (decl);
2975: rest_of_decl_compilation (decl, asmspec,
2976: current_binding_level == global_binding_level,
2977: 0);
2978: }
2979: if (current_binding_level != global_binding_level)
2980: {
2981: /* Recompute the RTL of a local array now
2982: if it used to be an incomplete type. */
2983: if (was_incomplete
2984: && ! TREE_STATIC (decl) && ! TREE_EXTERNAL (decl))
2985: {
2986: /* If we used it already as memory, it must stay in memory. */
2987: TREE_ADDRESSABLE (decl) = TREE_USED (decl);
2988: /* If it's still incomplete now, no init will save it. */
2989: if (DECL_SIZE (decl) == 0)
2990: DECL_INITIAL (decl) = 0;
2991: expand_decl (decl);
2992: }
2993: /* Compute and store the initial value. */
2994: expand_decl_init (decl);
2995: }
2996: }
2997:
2998: if (TREE_CODE (decl) == TYPE_DECL)
2999: {
3000: /* This is a no-op in c-lang.c or something real in objc-actions.c. */
3001: maybe_objc_check_decl (decl);
3002: rest_of_decl_compilation (decl, 0,
3003: current_binding_level == global_binding_level,
3004: 0);
3005: }
3006:
3007: if (temporary && TREE_PERMANENT (decl))
3008: {
3009: /* We need to remember that this array HAD an initialization,
3010: but discard the actual temporary nodes,
3011: since we can't have a permanent node keep pointing to them. */
3012: if (DECL_INITIAL (decl) != 0)
3013: DECL_INITIAL (decl) = error_mark_node;
3014: }
3015:
3016: /* Resume permanent allocation, if not within a function. */
3017: /* The corresponding push_obstacks_nochange is in start_decl,
3018: and in push_parm_decl and in grokfield. */
3019: pop_obstacks ();
3020: if (current_binding_level == global_binding_level && temporary)
3021: /* Actually free the temporary space that we no longer need. */
3022: permanent_allocation ();
3023:
3024: /* At the end of a declaration, throw away any variable type sizes
3025: of types defined inside that declaration. There is no use
3026: computing them in the following function definition. */
3027: if (current_binding_level == global_binding_level)
3028: get_pending_sizes ();
3029: }
3030:
3031: /* If DECL has a cleanup, build and return that cleanup here.
3032: This is a callback called by expand_expr. */
3033:
3034: tree
3035: maybe_build_cleanup (decl)
3036: tree decl;
3037: {
3038: /* There are no cleanups in C. */
3039: return NULL_TREE;
3040: }
3041:
3042: /* Given a parsed parameter declaration,
3043: decode it into a PARM_DECL and push that on the current binding level.
3044: Also, for the sake of forward parm decls,
3045: record the given order of parms in `parm_order'. */
3046:
3047: void
3048: push_parm_decl (parm)
3049: tree parm;
3050: {
3051: tree decl;
3052:
3053: /* The corresponding pop_obstacks is in finish_decl. */
3054: push_obstacks_nochange ();
3055:
3056: decl = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm), PARM, 0);
3057: decl = pushdecl (decl);
3058:
3059: current_binding_level->parm_order
3060: = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
3061:
3062: /* Add this decl to the current binding level. */
3063: finish_decl (decl, NULL_TREE, NULL_TREE);
3064: }
3065:
3066: /* Clear the given order of parms in `parm_order'.
3067: Used at start of parm list,
3068: and also at semicolon terminating forward decls. */
3069:
3070: void
3071: clear_parm_order ()
3072: {
3073: current_binding_level->parm_order = NULL_TREE;
3074: }
3075:
3076: /* Make TYPE a complete type based on INITIAL_VALUE.
3077: Return 0 if successful, 1 if INITIAL_VALUE can't be decyphered,
3078: 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
3079:
3080: int
3081: complete_array_type (type, initial_value, do_default)
3082: tree type;
3083: tree initial_value;
3084: int do_default;
3085: {
3086: register tree maxindex = NULL_TREE;
3087: int value = 0;
3088:
3089: if (initial_value)
3090: {
3091: /* Note MAXINDEX is really the maximum index,
3092: one less than the size. */
3093: if (TREE_CODE (initial_value) == STRING_CST)
3094: {
3095: int eltsize
3096: = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
3097: maxindex = build_int_2 (TREE_STRING_LENGTH (initial_value) / eltsize - 1, 0);
3098: }
3099: else if (TREE_CODE (initial_value) == CONSTRUCTOR)
3100: {
3101: register int nelts
3102: = list_length (CONSTRUCTOR_ELTS (initial_value));
3103: maxindex = build_int_2 (nelts - 1, 0);
3104: }
3105: else
3106: {
3107: /* Make an error message unless that happened already. */
3108: if (initial_value != error_mark_node)
3109: value = 1;
3110:
3111: /* Prevent further error messages. */
3112: maxindex = build_int_2 (1, 0);
3113: }
3114: }
3115:
3116: if (!maxindex)
3117: {
3118: if (do_default)
3119: maxindex = build_int_2 (1, 0);
3120: value = 2;
3121: }
3122:
3123: if (maxindex)
3124: {
3125: TYPE_DOMAIN (type) = build_index_type (maxindex);
3126: if (!TREE_TYPE (maxindex))
3127: TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
3128: }
3129:
3130: /* Lay out the type now that we can get the real answer. */
3131:
3132: layout_type (type);
3133:
3134: return value;
3135: }
3136:
3137: /* Given declspecs and a declarator,
3138: determine the name and type of the object declared
3139: and construct a ..._DECL node for it.
3140: (In one case we can return a ..._TYPE node instead.
3141: For invalid input we sometimes return 0.)
3142:
3143: DECLSPECS is a chain of tree_list nodes whose value fields
3144: are the storage classes and type specifiers.
3145:
3146: DECL_CONTEXT says which syntactic context this declaration is in:
3147: NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3148: FUNCDEF for a function definition. Like NORMAL but a few different
3149: error messages in each case. Return value may be zero meaning
3150: this definition is too screwy to try to parse.
3151: PARM for a parameter declaration (either within a function prototype
3152: or before a function body). Make a PARM_DECL, or return void_type_node.
3153: TYPENAME if for a typename (in a cast or sizeof).
3154: Don't make a DECL node; just return the ..._TYPE node.
3155: FIELD for a struct or union field; make a FIELD_DECL.
3156: BITFIELD for a field with specified width.
3157: INITIALIZED is 1 if the decl has an initializer.
3158:
3159: In the TYPENAME case, DECLARATOR is really an absolute declarator.
3160: It may also be so in the PARM case, for a prototype where the
3161: argument type is specified but not the name.
3162:
3163: This function is where the complicated C meanings of `static'
3164: and `extern' are intrepreted. */
3165:
3166: static tree
3167: grokdeclarator (declarator, declspecs, decl_context, initialized)
3168: tree declspecs;
3169: tree declarator;
3170: enum decl_context decl_context;
3171: int initialized;
3172: {
3173: int specbits = 0;
3174: tree spec;
3175: tree type = NULL_TREE;
3176: int longlong = 0;
3177: int constp;
3178: int volatilep;
3179: int inlinep;
3180: int explicit_int = 0;
3181: int explicit_char = 0;
3182: tree typedef_decl = 0;
3183: char *name;
3184: tree typedef_type = 0;
3185: int funcdef_flag = 0;
3186: enum tree_code innermost_code = ERROR_MARK;
3187: int bitfield = 0;
3188: int variable_size = 0;
3189:
3190: if (decl_context == BITFIELD)
3191: bitfield = 1, decl_context = FIELD;
3192:
3193: if (decl_context == FUNCDEF)
3194: funcdef_flag = 1, decl_context = NORMAL;
3195:
3196: push_obstacks_nochange ();
3197:
3198: if (flag_traditional && allocation_temporary_p ())
3199: end_temporary_allocation ();
3200:
3201: /* Look inside a declarator for the name being declared
3202: and get it as a string, for an error message. */
3203: {
3204: register tree decl = declarator;
3205: name = 0;
3206:
3207: while (decl)
3208: switch (TREE_CODE (decl))
3209: {
3210: case ARRAY_REF:
3211: case INDIRECT_REF:
3212: case CALL_EXPR:
3213: innermost_code = TREE_CODE (decl);
3214: decl = TREE_OPERAND (decl, 0);
3215: break;
3216:
3217: case IDENTIFIER_NODE:
3218: name = IDENTIFIER_POINTER (decl);
3219: decl = 0;
3220: break;
3221:
3222: default:
3223: abort ();
3224: }
3225: if (name == 0)
3226: name = "type name";
3227: }
3228:
3229: /* A function definition's declarator must have the form of
3230: a function declarator. */
3231:
3232: if (funcdef_flag && innermost_code != CALL_EXPR)
3233: return 0;
3234:
3235: /* Anything declared one level down from the top level
3236: must be one of the parameters of a function
3237: (because the body is at least two levels down). */
3238:
3239: /* If this looks like a function definition, make it one,
3240: even if it occurs where parms are expected.
3241: Then store_parm_decls will reject it and not use it as a parm. */
3242: if (decl_context == NORMAL && !funcdef_flag
3243: && current_binding_level->level_chain == global_binding_level)
3244: decl_context = PARM;
3245:
3246: /* Look through the decl specs and record which ones appear.
3247: Some typespecs are defined as built-in typenames.
3248: Others, the ones that are modifiers of other types,
3249: are represented by bits in SPECBITS: set the bits for
3250: the modifiers that appear. Storage class keywords are also in SPECBITS.
3251:
3252: If there is a typedef name or a type, store the type in TYPE.
3253: This includes builtin typedefs such as `int'.
3254:
3255: Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
3256: and did not come from a user typedef.
3257:
3258: Set LONGLONG if `long' is mentioned twice. */
3259:
3260: for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
3261: {
3262: register int i;
3263: register tree id = TREE_VALUE (spec);
3264:
3265: if (id == ridpointers[(int) RID_INT])
3266: explicit_int = 1;
3267: if (id == ridpointers[(int) RID_CHAR])
3268: explicit_char = 1;
3269:
3270: if (TREE_CODE (id) == IDENTIFIER_NODE)
3271: for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
3272: {
3273: if (ridpointers[i] == id)
3274: {
3275: if (i == (int) RID_LONG && specbits & (1<<i))
3276: {
3277: if (pedantic)
3278: pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
3279: else if (longlong)
3280: warning ("`long long long' is too long for GCC");
3281: else
3282: longlong = 1;
3283: }
3284: else if (specbits & (1 << i))
3285: warning ("duplicate `%s'", IDENTIFIER_POINTER (id));
3286: specbits |= 1 << i;
3287: goto found;
3288: }
3289: }
3290: if (type)
3291: error ("two or more data types in declaration of `%s'", name);
3292: /* Actual typedefs come to us as TYPE_DECL nodes. */
3293: else if (TREE_CODE (id) == TYPE_DECL)
3294: {
3295: type = TREE_TYPE (id);
3296: typedef_decl = id;
3297: }
3298: /* Built-in types come as identifiers. */
3299: else if (TREE_CODE (id) == IDENTIFIER_NODE)
3300: {
3301: register tree t = lookup_name (id);
3302: if (TREE_TYPE (t) == error_mark_node)
3303: ;
3304: else if (!t || TREE_CODE (t) != TYPE_DECL)
3305: error ("`%s' fails to be a typedef or built in type",
3306: IDENTIFIER_POINTER (id));
3307: else
3308: {
3309: type = TREE_TYPE (t);
3310: typedef_decl = t;
3311: }
3312: }
3313: else if (TREE_CODE (id) != ERROR_MARK)
3314: type = id;
3315:
3316: found: {}
3317: }
3318:
3319: typedef_type = type;
3320: if (type)
3321: variable_size = C_TYPE_VARIABLE_SIZE (type);
3322:
3323: /* No type at all: default to `int', and set EXPLICIT_INT
3324: because it was not a user-defined typedef. */
3325:
3326: if (type == 0)
3327: {
3328: if (funcdef_flag && warn_return_type
3329: && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3330: | (1 << (int) RID_SIGNED) | (1 << (int) RID_UNSIGNED))))
3331: warn_about_return_type = 1;
3332: explicit_int = 1;
3333: type = integer_type_node;
3334: }
3335:
3336: /* Now process the modifiers that were specified
3337: and check for invalid combinations. */
3338:
3339: /* Long double is a special combination. */
3340:
3341: if ((specbits & 1 << (int) RID_LONG) && type == double_type_node)
3342: {
3343: specbits &= ~ (1 << (int) RID_LONG);
3344: type = long_double_type_node;
3345: }
3346:
3347: /* Check all other uses of type modifiers. */
3348:
3349: if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3350: | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
3351: {
3352: int ok = 0;
3353:
3354: if (TREE_CODE (type) != INTEGER_TYPE)
3355: error ("long, short, signed or unsigned invalid for `%s'", name);
3356: else if ((specbits & 1 << (int) RID_LONG)
3357: && (specbits & 1 << (int) RID_SHORT))
3358: error ("long and short specified together for `%s'", name);
3359: else if (((specbits & 1 << (int) RID_LONG)
3360: || (specbits & 1 << (int) RID_SHORT))
3361: && explicit_char)
3362: error ("long or short specified with char for `%s'", name);
3363: else if (((specbits & 1 << (int) RID_LONG)
3364: || (specbits & 1 << (int) RID_SHORT))
3365: && TREE_CODE (type) == REAL_TYPE)
3366: error ("long or short specified with floating type for `%s'", name);
3367: else if ((specbits & 1 << (int) RID_SIGNED)
3368: && (specbits & 1 << (int) RID_UNSIGNED))
3369: error ("signed and unsigned given together for `%s'", name);
3370: else
3371: {
3372: ok = 1;
3373: if (!explicit_int && !explicit_char && pedantic)
3374: {
3375: pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
3376: name);
3377: if (flag_pedantic_errors)
3378: ok = 0;
3379: }
3380: }
3381:
3382: /* Discard the type modifiers if they are invalid. */
3383: if (! ok)
3384: {
3385: specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
3386: | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
3387: longlong = 0;
3388: }
3389: }
3390:
3391: /* Decide whether an integer type is signed or not.
3392: Optionally treat bitfields as signed by default. */
3393: if (specbits & 1 << (int) RID_UNSIGNED
3394: /* Traditionally, all bitfields are unsigned. */
3395: || (bitfield && flag_traditional)
3396: || (bitfield && ! flag_signed_bitfields
3397: && (explicit_int || explicit_char
3398: /* A typedef for plain `int' without `signed'
3399: can be controlled just like plain `int'. */
3400: || ! (typedef_decl != 0
3401: && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
3402: && TREE_CODE (type) != ENUMERAL_TYPE
3403: && !(specbits & 1 << (int) RID_SIGNED)))
3404: {
3405: if (longlong)
3406: type = long_long_unsigned_type_node;
3407: else if (specbits & 1 << (int) RID_LONG)
3408: type = long_unsigned_type_node;
3409: else if (specbits & 1 << (int) RID_SHORT)
3410: type = short_unsigned_type_node;
3411: else if (type == char_type_node)
3412: type = unsigned_char_type_node;
3413: else if (typedef_decl)
3414: type = unsigned_type (type);
3415: else
3416: type = unsigned_type_node;
3417: }
3418: else if ((specbits & 1 << (int) RID_SIGNED)
3419: && type == char_type_node)
3420: type = signed_char_type_node;
3421: else if (longlong)
3422: type = long_long_integer_type_node;
3423: else if (specbits & 1 << (int) RID_LONG)
3424: type = long_integer_type_node;
3425: else if (specbits & 1 << (int) RID_SHORT)
3426: type = short_integer_type_node;
3427:
3428: /* Set CONSTP if this declaration is `const', whether by
3429: explicit specification or via a typedef.
3430: Likewise for VOLATILEP. */
3431:
3432: constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
3433: volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
3434: inlinep = !! (specbits & (1 << (int) RID_INLINE));
3435: if (constp > 1)
3436: warning ("duplicate `const'");
3437: if (volatilep > 1)
3438: warning ("duplicate `volatile'");
3439: if (! flag_gen_aux_info && (TYPE_READONLY (type) || TYPE_VOLATILE (type)))
3440: type = TYPE_MAIN_VARIANT (type);
3441:
3442: /* Warn if two storage classes are given. Default to `auto'. */
3443:
3444: {
3445: int nclasses = 0;
3446:
3447: if (specbits & 1 << (int) RID_AUTO) nclasses++;
3448: if (specbits & 1 << (int) RID_STATIC) nclasses++;
3449: if (specbits & 1 << (int) RID_EXTERN) nclasses++;
3450: if (specbits & 1 << (int) RID_REGISTER) nclasses++;
3451: if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
3452:
3453: /* Warn about storage classes that are invalid for certain
3454: kinds of declarations (parameters, typenames, etc.). */
3455:
3456: if (nclasses > 1)
3457: error ("multiple storage classes in declaration of `%s'", name);
3458: else if (funcdef_flag
3459: && (specbits
3460: & ((1 << (int) RID_REGISTER)
3461: | (1 << (int) RID_AUTO)
3462: | (1 << (int) RID_TYPEDEF))))
3463: {
3464: if (specbits & 1 << (int) RID_AUTO
3465: && (pedantic || current_binding_level == global_binding_level))
3466: pedwarn ("function definition declared `auto'");
3467: if (specbits & 1 << (int) RID_REGISTER)
3468: error ("function definition declared `register'");
3469: if (specbits & 1 << (int) RID_TYPEDEF)
3470: error ("function definition declared `typedef'");
3471: specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3472: | (1 << (int) RID_AUTO));
3473: }
3474: else if (decl_context != NORMAL && nclasses > 0)
3475: {
3476: if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
3477: ;
3478: else
3479: {
3480: error ((decl_context == FIELD
3481: ? "storage class specified for structure field `%s'"
3482: : (decl_context == PARM
3483: ? "storage class specified for parameter `%s'"
3484: : "storage class specified for typename")),
3485: name);
3486: specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
3487: | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
3488: | (1 << (int) RID_EXTERN));
3489: }
3490: }
3491: else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
3492: {
3493: /* `extern' with initialization is invalid if not at top level. */
3494: if (current_binding_level == global_binding_level)
3495: warning ("`%s' initialized and declared `extern'", name);
3496: else
3497: error ("`%s' has both `extern' and initializer", name);
3498: }
3499: else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
3500: && current_binding_level != global_binding_level)
3501: error ("nested function `%s' declared `extern'", name);
3502: else if (current_binding_level == global_binding_level
3503: && specbits & (1 << (int) RID_AUTO))
3504: error ("top-level declaration of `%s' specifies `auto'", name);
3505: }
3506:
3507: /* Now figure out the structure of the declarator proper.
3508: Descend through it, creating more complex types, until we reach
3509: the declared identifier (or NULL_TREE, in an absolute declarator). */
3510:
3511: while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
3512: {
3513: if (type == error_mark_node)
3514: {
3515: declarator = TREE_OPERAND (declarator, 0);
3516: continue;
3517: }
3518:
3519: /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
3520: an INDIRECT_REF (for *...),
3521: a CALL_EXPR (for ...(...)),
3522: an identifier (for the name being declared)
3523: or a null pointer (for the place in an absolute declarator
3524: where the name was omitted).
3525: For the last two cases, we have just exited the loop.
3526:
3527: At this point, TYPE is the type of elements of an array,
3528: or for a function to return, or for a pointer to point to.
3529: After this sequence of ifs, TYPE is the type of the
3530: array or function or pointer, and DECLARATOR has had its
3531: outermost layer removed. */
3532:
3533: if (TREE_CODE (declarator) == ARRAY_REF)
3534: {
3535: register tree itype = NULL_TREE;
3536: register tree size = TREE_OPERAND (declarator, 1);
3537:
3538: declarator = TREE_OPERAND (declarator, 0);
3539:
3540: /* Check for some types that there cannot be arrays of. */
3541:
3542: if (type == void_type_node)
3543: {
3544: error ("declaration of `%s' as array of voids", name);
3545: type = error_mark_node;
3546: }
3547:
3548: if (TREE_CODE (type) == FUNCTION_TYPE)
3549: {
3550: error ("declaration of `%s' as array of functions", name);
3551: type = error_mark_node;
3552: }
3553:
3554: if (size == error_mark_node)
3555: type = error_mark_node;
3556:
3557: if (type == error_mark_node)
3558: continue;
3559:
3560: /* If size was specified, set ITYPE to a range-type for that size.
3561: Otherwise, ITYPE remains null. finish_decl may figure it out
3562: from an initial value. */
3563:
3564: if (size)
3565: {
3566: /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3567: while (TREE_CODE (size) == NON_LVALUE_EXPR)
3568: size = TREE_OPERAND (size, 0);
3569:
3570: if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
3571: && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
3572: {
3573: error ("size of array `%s' has non-integer type", name);
3574: size = integer_one_node;
3575: }
3576: if (pedantic && integer_zerop (size))
3577: pedwarn ("ANSI C forbids zero-size array `%s'", name);
3578: if (TREE_CODE (size) == INTEGER_CST)
3579: {
3580: if (INT_CST_LT (size, integer_zero_node))
3581: {
3582: error ("size of array `%s' is negative", name);
3583: size = integer_one_node;
3584: }
3585: itype = build_index_type (build_int_2 (TREE_INT_CST_LOW (size) - 1, 0));
3586: }
3587: else
3588: {
3589: if (pedantic)
3590: pedwarn ("ANSI C forbids variable-size array `%s'", name);
3591: itype = build_binary_op (MINUS_EXPR, size, integer_one_node,
3592: 1);
3593: /* Make sure the array size remains visibly nonconstant
3594: even if it is (eg) a const variable with known value. */
3595: variable_size = 1;
3596: itype = build_index_type (save_expr (itype));
3597: }
3598: }
3599:
3600: #if 0 /* This had bad results for pointers to arrays, as in
3601: union incomplete (*foo)[4]; */
3602: /* Complain about arrays of incomplete types, except in typedefs. */
3603:
3604: if (TYPE_SIZE (type) == 0
3605: /* Avoid multiple warnings for nested array types. */
3606: && TREE_CODE (type) != ARRAY_TYPE
3607: && !(specbits & (1 << (int) RID_TYPEDEF))
3608: && !C_TYPE_BEING_DEFINED (type))
3609: warning ("array type has incomplete element type");
3610: #endif
3611:
3612: /* Build the array type itself.
3613: Merge any constancy or volatility into the target type. */
3614:
3615: #if 0 /* We shouldn't have a function type here at all!
3616: Functions aren't allowed as array elements. */
3617: if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
3618: && (constp || volatilep))
3619: pedwarn ("ANSI C forbids const or volatile function types");
3620: #endif
3621: if (constp || volatilep)
3622: type = c_build_type_variant (type, constp, volatilep);
3623:
3624: #if 0 /* don't clear these; leave them set so that the array type
3625: or the variable is itself const or volatile. */
3626: constp = 0;
3627: volatilep = 0;
3628: #endif
3629:
3630: type = build_array_type (type, itype);
3631: if (variable_size)
3632: C_TYPE_VARIABLE_SIZE (type) = 1;
3633: }
3634: else if (TREE_CODE (declarator) == CALL_EXPR)
3635: {
3636: tree arg_types;
3637:
3638: /* Declaring a function type.
3639: Make sure we have a valid type for the function to return. */
3640: if (type == error_mark_node)
3641: continue;
3642:
3643: variable_size = 0;
3644:
3645: /* Warn about some types functions can't return. */
3646:
3647: if (TREE_CODE (type) == FUNCTION_TYPE)
3648: {
3649: error ("`%s' declared as function returning a function", name);
3650: type = integer_type_node;
3651: }
3652: if (TREE_CODE (type) == ARRAY_TYPE)
3653: {
3654: error ("`%s' declared as function returning an array", name);
3655: type = integer_type_node;
3656: }
3657:
3658: #ifndef TRADITIONAL_RETURN_FLOAT
3659: /* Traditionally, declaring return type float means double. */
3660:
3661: if (flag_traditional && type == float_type_node)
3662: type = double_type_node;
3663: #endif /* TRADITIONAL_RETURN_FLOAT */
3664:
3665: /* Construct the function type and go to the next
3666: inner layer of declarator. */
3667:
3668: arg_types = grokparms (TREE_OPERAND (declarator, 1),
3669: funcdef_flag
3670: /* Say it's a definition
3671: only for the CALL_EXPR
3672: closest to the identifier. */
3673: && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
3674: #if 0 /* This seems to be false. We turn off temporary allocation
3675: above in this function if -traditional.
3676: And this code caused inconsistent results with prototypes:
3677: callers would ignore them, and pass arguments wrong. */
3678:
3679: /* Omit the arg types if -traditional, since the arg types
3680: and the list links might not be permanent. */
3681: type = build_function_type (type, flag_traditional ? 0 : arg_types);
3682: #endif
3683: type = build_function_type (type, arg_types);
3684: declarator = TREE_OPERAND (declarator, 0);
3685:
3686: /* Set the TYPE_CONTEXTs for each tagged type which is local to
3687: the formal parameter list of this FUNCTION_TYPE to point to
3688: the FUNCTION_TYPE node itself. */
3689:
3690: {
3691: register tree link;
3692:
3693: for (link = current_function_parm_tags;
3694: link;
3695: link = TREE_CHAIN (link))
3696: TYPE_CONTEXT (TREE_VALUE (link)) = type;
3697: }
3698: }
3699: else if (TREE_CODE (declarator) == INDIRECT_REF)
3700: {
3701: /* Merge any constancy or volatility into the target type
3702: for the pointer. */
3703:
3704: if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
3705: && (constp || volatilep))
3706: pedwarn ("ANSI C forbids const or volatile function types");
3707: if (constp || volatilep)
3708: type = c_build_type_variant (type, constp, volatilep);
3709: constp = 0;
3710: volatilep = 0;
3711: variable_size = 0;
3712:
3713: type = build_pointer_type (type);
3714:
3715: /* Process a list of type modifier keywords
3716: (such as const or volatile) that were given inside the `*'. */
3717:
3718: if (TREE_TYPE (declarator))
3719: {
3720: register tree typemodlist;
3721: int erred = 0;
3722: for (typemodlist = TREE_TYPE (declarator); typemodlist;
3723: typemodlist = TREE_CHAIN (typemodlist))
3724: {
3725: if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
3726: constp++;
3727: else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
3728: volatilep++;
3729: else if (!erred)
3730: {
3731: erred = 1;
3732: error ("invalid type modifier within pointer declarator");
3733: }
3734: }
3735: if (constp > 1)
3736: warning ("duplicate `const'");
3737: if (volatilep > 1)
3738: warning ("duplicate `volatile'");
3739: }
3740:
3741: declarator = TREE_OPERAND (declarator, 0);
3742: }
3743: else
3744: abort ();
3745:
3746: }
3747:
3748: /* Now TYPE has the actual type. */
3749:
3750: /* If this is declaring a typedef name, return a TYPE_DECL. */
3751:
3752: if (specbits & (1 << (int) RID_TYPEDEF))
3753: {
3754: tree decl;
3755: /* Note that the grammar rejects storage classes
3756: in typenames, fields or parameters */
3757: if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
3758: && (constp || volatilep))
3759: pedwarn ("ANSI C forbids const or volatile function types");
3760: if (constp || volatilep)
3761: type = c_build_type_variant (type, constp, volatilep);
3762: pop_obstacks ();
3763: decl = build_decl (TYPE_DECL, declarator, type);
3764: if ((specbits & (1 << (int) RID_SIGNED))
3765: || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
3766: C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
3767: return decl;
3768: }
3769:
3770: /* Detect the case of an array type of unspecified size
3771: which came, as such, direct from a typedef name.
3772: We must copy the type, so that each identifier gets
3773: a distinct type, so that each identifier's size can be
3774: controlled separately by its own initializer. */
3775:
3776: if (type != 0 && typedef_type != 0
3777: && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)
3778: && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0)
3779: {
3780: type = build_array_type (TREE_TYPE (type), 0);
3781: if (variable_size)
3782: C_TYPE_VARIABLE_SIZE (type) = 1;
3783: }
3784:
3785: /* If this is a type name (such as, in a cast or sizeof),
3786: compute the type and return it now. */
3787:
3788: if (decl_context == TYPENAME)
3789: {
3790: /* Note that the grammar rejects storage classes
3791: in typenames, fields or parameters */
3792: if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
3793: && (constp || volatilep))
3794: pedwarn ("ANSI C forbids const or volatile function types");
3795: if (constp || volatilep)
3796: type = c_build_type_variant (type, constp, volatilep);
3797: pop_obstacks ();
3798: return type;
3799: }
3800:
3801: /* `void' at top level (not within pointer)
3802: is allowed only in typedefs or type names.
3803: We don't complain about parms either, but that is because
3804: a better error message can be made later. */
3805:
3806: if (type == void_type_node && decl_context != PARM)
3807: {
3808: error ("variable or field `%s' declared void",
3809: IDENTIFIER_POINTER (declarator));
3810: type = integer_type_node;
3811: }
3812:
3813: /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
3814: or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
3815:
3816: {
3817: register tree decl;
3818:
3819: if (decl_context == PARM)
3820: {
3821: tree type_as_written = type;
3822:
3823: /* A parameter declared as an array of T is really a pointer to T.
3824: One declared as a function is really a pointer to a function. */
3825:
3826: if (TREE_CODE (type) == ARRAY_TYPE)
3827: {
3828: /* Transfer const-ness of array into that of type pointed to. */
3829: type = build_pointer_type
3830: (c_build_type_variant (TREE_TYPE (type), constp, volatilep));
3831: volatilep = constp = 0;
3832: variable_size = 0;
3833: }
3834: else if (TREE_CODE (type) == FUNCTION_TYPE)
3835: {
3836: if (pedantic && (constp || volatilep))
3837: pedwarn ("ANSI C forbids const or volatile function types");
3838: type = build_pointer_type (c_build_type_variant (type, constp, volatilep));
3839: volatilep = constp = 0;
3840: }
3841:
3842: if (initialized)
3843: error ("parameter `%s' is initialized", name);
3844:
3845: decl = build_decl (PARM_DECL, declarator, type);
3846: if (variable_size)
3847: C_DECL_VARIABLE_SIZE (decl) = 1;
3848:
3849: /* Compute the type actually passed in the parmlist,
3850: for the case where there is no prototype.
3851: (For example, shorts and chars are passed as ints.)
3852: When there is a prototype, this is overridden later. */
3853:
3854: DECL_ARG_TYPE (decl) = type;
3855: if (type == float_type_node)
3856: DECL_ARG_TYPE (decl) = double_type_node;
3857: else if (TREE_CODE (type) == INTEGER_TYPE
3858: && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
3859: DECL_ARG_TYPE (decl) = integer_type_node;
3860:
3861: DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
3862: }
3863: else if (decl_context == FIELD)
3864: {
3865: /* Structure field. It may not be a function. */
3866:
3867: if (TREE_CODE (type) == FUNCTION_TYPE)
3868: {
3869: error ("field `%s' declared as a function",
3870: IDENTIFIER_POINTER (declarator));
3871: type = build_pointer_type (type);
3872: }
3873: else if (TREE_CODE (type) != ERROR_MARK && TYPE_SIZE (type) == 0)
3874: {
3875: error ("field `%s' has incomplete type",
3876: IDENTIFIER_POINTER (declarator));
3877: type = error_mark_node;
3878: }
3879: /* Move type qualifiers down to element of an array. */
3880: if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
3881: {
3882: type = build_array_type (c_build_type_variant (TREE_TYPE (type),
3883: constp, volatilep),
3884: TYPE_DOMAIN (type));
3885: #if 0 /* Leave the field const or volatile as well. */
3886: constp = volatilep = 0;
3887: #endif
3888: }
3889: decl = build_decl (FIELD_DECL, declarator, type);
3890: if (variable_size)
3891: C_DECL_VARIABLE_SIZE (decl) = 1;
3892: }
3893: else if (TREE_CODE (type) == FUNCTION_TYPE)
3894: {
3895: if (specbits & (1 << (int) RID_AUTO)
3896: && (pedantic || current_binding_level == global_binding_level))
3897: pedwarn ("invalid storage class for function `%s'",
3898: IDENTIFIER_POINTER (declarator));
3899: if (specbits & (1 << (int) RID_REGISTER))
3900: error ("invalid storage class for function `%s'",
3901: IDENTIFIER_POINTER (declarator));
3902: /* Function declaration not at top level.
3903: Storage classes other than `extern' are not allowed
3904: and `extern' makes no difference. */
3905: if (current_binding_level != global_binding_level
3906: && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
3907: && pedantic)
3908: pedwarn ("invalid storage class for function `%s'",
3909: IDENTIFIER_POINTER (declarator));
3910: decl = build_decl (FUNCTION_DECL, declarator, type);
3911:
3912: if (pedantic && (constp || volatilep))
3913: pedwarn ("ANSI C forbids const or volatile functions");
3914:
3915: /* Every function declaration is "external"
3916: except for those which are inside a function body
3917: in which `auto' is used.
3918: That is a case not specified by ANSI C,
3919: and we use it for forward declarations for nested functions. */
3920: if (!(specbits & (1 << (int) RID_AUTO))
3921: || current_binding_level == global_binding_level)
3922: TREE_EXTERNAL (decl) = 1;
3923: /* Record absence of global scope for `static' or `auto'. */
3924: TREE_PUBLIC (decl)
3925: = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
3926: /* Record presence of `inline', if it is reasonable. */
3927: if (inlinep)
3928: {
3929: tree last = tree_last (TYPE_ARG_TYPES (type));
3930:
3931: if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
3932: warning ("cannot inline function `main'");
3933: else if (last && TREE_VALUE (last) != void_type_node)
3934: warning ("inline declaration ignored for function with `...'");
3935: else
3936: /* Assume that otherwise the function can be inlined. */
3937: TREE_INLINE (decl) = 1;
3938:
3939: if (specbits & (1 << (int) RID_EXTERN))
3940: current_extern_inline = 1;
3941: }
3942: }
3943: else
3944: {
3945: /* It's a variable. */
3946:
3947: /* Move type qualifiers down to element of an array. */
3948: if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
3949: {
3950: type = build_array_type (c_build_type_variant (TREE_TYPE (type),
3951: constp, volatilep),
3952: TYPE_DOMAIN (type));
3953: #if 0 /* Leave the variable const or volatile as well. */
3954: constp = volatilep = 0;
3955: #endif
3956: }
3957:
3958: decl = build_decl (VAR_DECL, declarator, type);
3959: if (variable_size)
3960: C_DECL_VARIABLE_SIZE (decl) = 1;
3961:
3962: if (inlinep)
3963: pedwarn_with_decl (decl, "variable `%s' declared `inline'");
3964:
3965: /* An uninitialized decl with `extern' is a reference. */
3966: TREE_EXTERNAL (decl)
3967: = !initialized && (specbits & (1 << (int) RID_EXTERN));
3968: /* At top level, either `static' or no s.c. makes a definition
3969: (perhaps tentative), and absence of `static' makes it public. */
3970: if (current_binding_level == global_binding_level)
3971: {
3972: TREE_PUBLIC (decl) = !(specbits & (1 << (int) RID_STATIC));
3973: TREE_STATIC (decl) = ! TREE_EXTERNAL (decl);
3974: }
3975: /* Not at top level, only `static' makes a static definition. */
3976: else
3977: {
3978: TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
3979: TREE_PUBLIC (decl) = TREE_EXTERNAL (decl);
3980: }
3981: }
3982:
3983: /* Record `register' declaration for warnings on &
3984: and in case doing stupid register allocation. */
3985:
3986: if (specbits & (1 << (int) RID_REGISTER))
3987: TREE_REGDECL (decl) = 1;
3988:
3989: /* Record constancy and volatility. */
3990:
3991: if (constp)
3992: TREE_READONLY (decl) = 1;
3993: if (volatilep)
3994: {
3995: TREE_SIDE_EFFECTS (decl) = 1;
3996: TREE_THIS_VOLATILE (decl) = 1;
3997: }
3998: /* If a type has volatile components, it should be stored in memory.
3999: Otherwise, the fact that those components are volatile
4000: will be ignored, and would even crash the compiler. */
4001: if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
4002: mark_addressable (decl);
4003:
4004: pop_obstacks ();
4005:
4006: return decl;
4007: }
4008: }
4009:
4010: /* Make a variant type in the proper way for C, propagating qualifiers
4011: down to the element type of an array. */
4012:
4013: tree
4014: c_build_type_variant (type, constp, volatilep)
4015: tree type;
4016: int constp, volatilep;
4017: {
4018: if (TREE_CODE (type) == ARRAY_TYPE)
4019: type = build_array_type (c_build_type_variant (TREE_TYPE (type),
4020: constp, volatilep),
4021: TYPE_DOMAIN (type));
4022: return build_type_variant (type, constp, volatilep);
4023: }
4024:
4025: /* Decode the parameter-list info for a function type or function definition.
4026: The argument is the value returned by `get_parm_info' (or made in parse.y
4027: if there is an identifier list instead of a parameter decl list).
4028: These two functions are separate because when a function returns
4029: or receives functions then each is called multiple times but the order
4030: of calls is different. The last call to `grokparms' is always the one
4031: that contains the formal parameter names of a function definition.
4032:
4033: Store in `last_function_parms' a chain of the decls of parms.
4034: Also store in `last_function_parm_tags' a chain of the struct, union,
4035: and enum tags declared among the parms.
4036:
4037: Return a list of arg types to use in the FUNCTION_TYPE for this function.
4038:
4039: FUNCDEF_FLAG is nonzero for a function definition, 0 for
4040: a mere declaration. A nonempty identifier-list gets an error message
4041: when FUNCDEF_FLAG is zero. */
4042:
4043: static tree
4044: grokparms (parms_info, funcdef_flag)
4045: tree parms_info;
4046: int funcdef_flag;
4047: {
4048: tree first_parm = TREE_CHAIN (parms_info);
4049:
4050: last_function_parms = TREE_PURPOSE (parms_info);
4051: last_function_parm_tags = TREE_VALUE (parms_info);
4052:
4053: if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag)
4054: warning ("function declaration isn't a prototype");
4055:
4056: if (first_parm != 0
4057: && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
4058: {
4059: if (! funcdef_flag)
4060: pedwarn ("parameter names (without types) in function declaration");
4061:
4062: last_function_parms = first_parm;
4063: return 0;
4064: }
4065: else
4066: {
4067: tree parm;
4068: tree typelt;
4069: /* We no longer test FUNCDEF_FLAG.
4070: If the arg types are incomplete in a declaration,
4071: they must include undefined tags.
4072: These tags can never be defined in the scope of the declaration,
4073: so the types can never be completed,
4074: and no call can be compiled successfully. */
4075: #if 0
4076: /* In a fcn definition, arg types must be complete. */
4077: if (funcdef_flag)
4078: #endif
4079: for (parm = last_function_parms, typelt = first_parm;
4080: parm;
4081: parm = TREE_CHAIN (parm))
4082: /* Skip over any enumeration constants declared here. */
4083: if (TREE_CODE (parm) == PARM_DECL)
4084: {
4085: /* Barf if the parameter itself has an incomplete type. */
4086: tree type = TREE_VALUE (typelt);
4087: if (TYPE_SIZE (type) == 0)
4088: {
4089: if (funcdef_flag && DECL_NAME (parm) != 0)
4090: error ("parameter `%s' has incomplete type",
4091: IDENTIFIER_POINTER (DECL_NAME (parm)));
4092: else
4093: warning ("parameter has incomplete type");
4094: if (funcdef_flag)
4095: {
4096: TREE_VALUE (typelt) = error_mark_node;
4097: TREE_TYPE (parm) = error_mark_node;
4098: }
4099: }
4100: #if 0 /* This has been replaced by parm_tags_warning
4101: which uses a more accurate criterion for what to warn about. */
4102: else
4103: {
4104: /* Now warn if is a pointer to an incomplete type. */
4105: while (TREE_CODE (type) == POINTER_TYPE
4106: || TREE_CODE (type) == REFERENCE_TYPE)
4107: type = TREE_TYPE (type);
4108: type = TYPE_MAIN_VARIANT (type);
4109: if (TYPE_SIZE (type) == 0)
4110: {
4111: if (DECL_NAME (parm) != 0)
4112: warning ("parameter `%s' points to incomplete type",
4113: IDENTIFIER_POINTER (DECL_NAME (parm)));
4114: else
4115: warning ("parameter points to incomplete type");
4116: }
4117: }
4118: #endif
4119: typelt = TREE_CHAIN (typelt);
4120: }
4121:
4122: return first_parm;
4123: }
4124: }
4125:
4126:
4127: /* Return a tree_list node with info on a parameter list just parsed.
4128: The TREE_PURPOSE is a chain of decls of those parms.
4129: The TREE_VALUE is a list of structure, union and enum tags defined.
4130: The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
4131: This tree_list node is later fed to `grokparms'.
4132:
4133: VOID_AT_END nonzero means append `void' to the end of the type-list.
4134: Zero means the parmlist ended with an ellipsis so don't append `void'. */
4135:
4136: tree
4137: get_parm_info (void_at_end)
4138: int void_at_end;
4139: {
4140: register tree decl, t;
4141: register tree types = 0;
4142: int erred = 0;
4143: tree tags = gettags ();
4144: tree parms = getdecls ();
4145: tree new_parms = 0;
4146: tree order = current_binding_level->parm_order;
4147:
4148: /* Just `void' (and no ellipsis) is special. There are really no parms. */
4149: if (void_at_end && parms != 0
4150: && TREE_CHAIN (parms) == 0
4151: && TREE_TYPE (parms) == void_type_node
4152: && DECL_NAME (parms) == 0)
4153: {
4154: parms = NULL_TREE;
4155: storedecls (NULL_TREE);
4156: return saveable_tree_cons (NULL_TREE, NULL_TREE,
4157: saveable_tree_cons (NULL_TREE, void_type_node, NULL_TREE));
4158: }
4159:
4160: /* Extract enumerator values and other non-parms declared with the parms. */
4161: for (decl = parms; decl; )
4162: {
4163: tree next = TREE_CHAIN (decl);
4164:
4165: if (TREE_CODE (decl) != PARM_DECL)
4166: {
4167: TREE_CHAIN (decl) = new_parms;
4168: new_parms = decl;
4169: }
4170: decl = next;
4171: }
4172:
4173: /* Put the parm decls back in the order they were in in the parm list. */
4174: for (t = order; t; t = TREE_CHAIN (t))
4175: {
4176: if (TREE_CHAIN (t))
4177: TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
4178: else
4179: TREE_CHAIN (TREE_VALUE (t)) = 0;
4180: }
4181:
4182: new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
4183: new_parms);
4184:
4185: /* Store the parmlist in the binding level since the old one
4186: is no longer a valid list. (We have changed the chain pointers.) */
4187: storedecls (new_parms);
4188:
4189: for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
4190: /* There may also be declarations for enumerators if an enumeration
4191: type is declared among the parms. Ignore them here. */
4192: if (TREE_CODE (decl) == PARM_DECL)
4193: {
4194: /* Since there is a prototype,
4195: args are passed in their declared types. */
4196: tree type = TREE_TYPE (decl);
4197: DECL_ARG_TYPE (decl) = type;
4198: #ifdef PROMOTE_PROTOTYPES
4199: if (TREE_CODE (type) == INTEGER_TYPE
4200: && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
4201: DECL_ARG_TYPE (decl) = integer_type_node;
4202: #endif
4203:
4204: types = saveable_tree_cons (NULL_TREE, TREE_TYPE (decl), types);
4205: if (TREE_VALUE (types) == void_type_node && ! erred
4206: && DECL_NAME (decl) == 0)
4207: {
4208: error ("`void' in parameter list must be the entire list");
4209: erred = 1;
4210: }
4211: }
4212:
4213: if (void_at_end)
4214: return saveable_tree_cons (new_parms, tags,
4215: nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
4216:
4217: return saveable_tree_cons (new_parms, tags, nreverse (types));
4218: }
4219:
4220: /* At end of parameter list, warn about any struct, union or enum tags
4221: defined within. Do so because these types cannot ever become complete. */
4222:
4223: void
4224: parmlist_tags_warning ()
4225: {
4226: tree elt;
4227: static int already;
4228:
4229: for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
4230: {
4231: enum tree_code code = TREE_CODE (TREE_VALUE (elt));
4232: warning ("`%s %s' declared inside parameter list",
4233: (code == RECORD_TYPE ? "struct"
4234: : code == UNION_TYPE ? "union"
4235: : "enum"),
4236: IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
4237: if (! already)
4238: {
4239: warning ("its scope is only this definition or declaration,");
4240: warning ("which is probably not what you want.");
4241: already = 1;
4242: }
4243: }
4244: }
4245:
4246: /* Get the struct, enum or union (CODE says which) with tag NAME.
4247: Define the tag as a forward-reference if it is not defined. */
4248:
4249: tree
4250: xref_tag (code, name)
4251: enum tree_code code;
4252: tree name;
4253: {
4254: int temporary = allocation_temporary_p ();
4255:
4256: /* If a cross reference is requested, look up the type
4257: already defined for this tag and return it. */
4258:
4259: register tree ref = lookup_tag (code, name, current_binding_level, 0);
4260: /* Even if this is the wrong type of tag, return what we found.
4261: There will be an error message anyway, from pending_xref_error.
4262: If we create an empty xref just for an invalid use of the type,
4263: the main result is to create lots of superflous error messages. */
4264: if (ref)
4265: return ref;
4266:
4267: push_obstacks_nochange ();
4268:
4269: if (current_binding_level == global_binding_level && temporary)
4270: end_temporary_allocation ();
4271:
4272: /* If no such tag is yet defined, create a forward-reference node
4273: and record it as the "definition".
4274: When a real declaration of this type is found,
4275: the forward-reference will be altered into a real type. */
4276:
4277: ref = make_node (code);
4278: if (code == ENUMERAL_TYPE)
4279: {
4280: /* (In ANSI, Enums can be referred to only if already defined.) */
4281: if (pedantic)
4282: pedwarn ("ANSI C forbids forward references to `enum' types");
4283: /* Give the type a default layout like unsigned int
4284: to avoid crashing if it does not get defined. */
4285: TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
4286: TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
4287: TREE_UNSIGNED (ref) = 1;
4288: TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
4289: TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
4290: TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
4291: }
4292:
4293: pushtag (name, ref);
4294:
4295: pop_obstacks ();
4296:
4297: return ref;
4298: }
4299:
4300: /* Make sure that the tag NAME is defined *in the current binding level*
4301: at least as a forward reference.
4302: CODE says which kind of tag NAME ought to be. */
4303:
4304: tree
4305: start_struct (code, name)
4306: enum tree_code code;
4307: tree name;
4308: {
4309: /* If there is already a tag defined at this binding level
4310: (as a forward reference), just return it. */
4311:
4312: register tree ref = 0;
4313:
4314: if (name != 0)
4315: ref = lookup_tag (code, name, current_binding_level, 1);
4316: if (ref && TREE_CODE (ref) == code)
4317: {
4318: C_TYPE_BEING_DEFINED (ref) = 1;
4319: if (TYPE_FIELDS (ref))
4320: error ((code == UNION_TYPE ? "redefinition of `union %s'"
4321: : "redefinition of `struct %s'"),
4322: IDENTIFIER_POINTER (name));
4323:
4324: return ref;
4325: }
4326:
4327: /* Otherwise create a forward-reference just so the tag is in scope. */
4328:
4329: ref = make_node (code);
4330: pushtag (name, ref);
4331: C_TYPE_BEING_DEFINED (ref) = 1;
4332: return ref;
4333: }
4334:
4335: /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
4336: of a structure component, returning a FIELD_DECL node.
4337: WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
4338:
4339: This is done during the parsing of the struct declaration.
4340: The FIELD_DECL nodes are chained together and the lot of them
4341: are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
4342:
4343: tree
4344: grokfield (filename, line, declarator, declspecs, width)
4345: char *filename;
4346: int line;
4347: tree declarator, declspecs, width;
4348: {
4349: tree value;
4350:
4351: /* The corresponding pop_obstacks is in finish_decl. */
4352: push_obstacks_nochange ();
4353:
4354: value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
4355:
4356: finish_decl (value, NULL, NULL);
4357: DECL_INITIAL (value) = width;
4358:
4359: return value;
4360: }
4361:
4362: /* Function to help qsort sort FIELD_DECLs by name order. */
4363:
4364: static int
4365: field_decl_cmp (x, y)
4366: tree *x, *y;
4367: {
4368: return (long)DECL_NAME (*x) - (long)DECL_NAME (*y);
4369: }
4370:
4371: /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
4372: FIELDLIST is a chain of FIELD_DECL nodes for the fields. */
4373:
4374: tree
4375: finish_struct (t, fieldlist)
4376: register tree t, fieldlist;
4377: {
4378: register tree x;
4379: int old_momentary;
4380: int toplevel = global_binding_level == current_binding_level;
4381:
4382: /* If this type was previously laid out as a forward reference,
4383: make sure we lay it out again. */
4384:
4385: TYPE_SIZE (t) = 0;
4386:
4387: /* Nameless union parm types are useful as GCC extension. */
4388: if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
4389: /* Otherwise, warn about any struct or union def. in parmlist. */
4390: if (in_parm_level_p ())
4391: {
4392: if (pedantic)
4393: pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
4394: : "structure defined inside parms"));
4395: else
4396: warning ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
4397: : "structure defined inside parms"));
4398: }
4399:
4400: old_momentary = suspend_momentary ();
4401:
4402: if (fieldlist == 0 && pedantic)
4403: pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union has no members"
4404: : "structure has no members"));
4405:
4406: /* Install struct as DECL_CONTEXT of each field decl.
4407: Also process specified field sizes.
4408: Set DECL_FRAME_SIZE to the specified size, or 0 if none specified.
4409: The specified size is found in the DECL_INITIAL.
4410: Store 0 there, except for ": 0" fields (so we can find them
4411: and delete them, below). */
4412:
4413: for (x = fieldlist; x; x = TREE_CHAIN (x))
4414: {
4415: DECL_CONTEXT (x) = t;
4416: DECL_FRAME_SIZE (x) = 0;
4417:
4418: /* If any field is const, the structure type is pseudo-const. */
4419: if (TREE_READONLY (x))
4420: C_TYPE_FIELDS_READONLY (t) = 1;
4421: else
4422: {
4423: /* A field that is pseudo-const makes the structure likewise. */
4424: tree t1 = TREE_TYPE (x);
4425: while (TREE_CODE (t1) == ARRAY_TYPE)
4426: t1 = TREE_TYPE (t1);
4427: if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
4428: && C_TYPE_FIELDS_READONLY (t1))
4429: C_TYPE_FIELDS_READONLY (t) = 1;
4430: }
4431:
4432: /* Any field that is volatile means variables of this type must be
4433: treated in some ways as volatile. */
4434: if (TREE_THIS_VOLATILE (x))
4435: C_TYPE_FIELDS_VOLATILE (t) = 1;
4436:
4437: /* Any field of nominal variable size implies structure is too. */
4438: if (C_DECL_VARIABLE_SIZE (x))
4439: C_TYPE_VARIABLE_SIZE (t) = 1;
4440:
4441: /* Detect invalid bit-field size. */
4442: while (DECL_INITIAL (x)
4443: && TREE_CODE (DECL_INITIAL (x)) == NON_LVALUE_EXPR)
4444: DECL_INITIAL (x) = TREE_OPERAND (DECL_INITIAL (x), 0);
4445: if (DECL_INITIAL (x) && TREE_CODE (DECL_INITIAL (x)) != INTEGER_CST)
4446: {
4447: error_with_decl (x, "bit-field `%s' width not an integer constant");
4448: DECL_INITIAL (x) = NULL;
4449: }
4450:
4451: /* Detect invalid bit-field type. */
4452: if (DECL_INITIAL (x)
4453: && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
4454: && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
4455: {
4456: error_with_decl (x, "bit-field `%s' has invalid type");
4457: DECL_INITIAL (x) = NULL;
4458: }
4459: if (DECL_INITIAL (x) && pedantic
4460: && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
4461: && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node)
4462: pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C");
4463:
4464: /* Detect and ignore out of range field width. */
4465: if (DECL_INITIAL (x))
4466: {
4467: register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
4468:
4469: if (width < 0)
4470: {
4471: DECL_INITIAL (x) = NULL;
4472: error_with_decl (x, "negative width in bit-field `%s'");
4473: }
4474: else if (width == 0 && DECL_NAME (x) != 0)
4475: {
4476: error_with_decl (x, "zero width for bit-field `%s'");
4477: DECL_INITIAL (x) = NULL;
4478: }
4479: else if (width > TYPE_PRECISION (TREE_TYPE (x)))
4480: {
4481: DECL_INITIAL (x) = NULL;
4482: pedwarn_with_decl (x, "width of `%s' exceeds its type");
4483: }
4484: }
4485:
4486: /* Process valid field width. */
4487: if (DECL_INITIAL (x))
4488: {
4489: register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
4490:
4491: DECL_FRAME_SIZE (x) = width;
4492: DECL_BIT_FIELD (x) = 1;
4493: DECL_INITIAL (x) = NULL;
4494:
4495: if (width == 0)
4496: {
4497: /* field size 0 => force desired amount of alignment. */
4498: #ifdef EMPTY_FIELD_BOUNDARY
4499: DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
4500: #endif
4501: #ifdef PCC_BITFIELD_TYPE_MATTERS
4502: DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
4503: TYPE_ALIGN (TREE_TYPE (x)));
4504: #endif
4505: }
4506: }
4507: else
4508: /* Non-bit-fields are aligned for their type. */
4509: DECL_ALIGN (x) = MAX (DECL_ALIGN (x), TYPE_ALIGN (TREE_TYPE (x)));
4510: }
4511:
4512: /* Now DECL_INITIAL is null on all members. */
4513:
4514: /* Delete all duplicate fields from the fieldlist */
4515: for (x = fieldlist; x && TREE_CHAIN (x);)
4516: /* Anonymous fields aren't duplicates. */
4517: if (DECL_NAME (TREE_CHAIN (x)) == 0)
4518: x = TREE_CHAIN (x);
4519: else
4520: {
4521: register tree y = fieldlist;
4522:
4523: while (1)
4524: {
4525: if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
4526: break;
4527: if (y == x)
4528: break;
4529: y = TREE_CHAIN (y);
4530: }
4531: if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
4532: {
4533: error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
4534: TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
4535: }
4536: else x = TREE_CHAIN (x);
4537: }
4538:
4539: /* Now we have the nearly final fieldlist. Record it,
4540: then lay out the structure or union (including the fields). */
4541:
4542: TYPE_FIELDS (t) = fieldlist;
4543:
4544: layout_type (t);
4545:
4546: /* Delete all zero-width bit-fields from the front of the fieldlist */
4547: while (fieldlist
4548: && DECL_INITIAL (fieldlist))
4549: fieldlist = TREE_CHAIN (fieldlist);
4550: /* Delete all such members from the rest of the fieldlist */
4551: for (x = fieldlist; x;)
4552: {
4553: if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x)))
4554: TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
4555: else x = TREE_CHAIN (x);
4556: }
4557:
4558: /* Now we have the truly final field list.
4559: Store it in this type and in the variants. */
4560:
4561: TYPE_FIELDS (t) = fieldlist;
4562:
4563: /* If there are lots of fields, sort so we can look through them fast.
4564: We arbitrarily consider 16 or more elts to be "a lot". */
4565: {
4566: int len = 0;
4567:
4568: for (x = fieldlist; x; x = TREE_CHAIN (x))
4569: {
4570: if (len > 15)
4571: break;
4572: len += 1;
4573: }
4574: if (len > 15)
4575: {
4576: tree *field_array;
4577: char *space;
4578:
4579: len += list_length (x);
4580: /* Use the same allocation policy here that make_node uses, to
4581: ensure that this lives as long as the rest of the struct decl.
4582: All decls in an inline function need to be saved. */
4583: if (allocation_temporary_p ())
4584: space = savealloc (sizeof (struct lang_type) + len * sizeof (tree));
4585: else
4586: space = oballoc (sizeof (struct lang_type) + len * sizeof (tree));
4587:
4588: TYPE_LANG_SPECIFIC (t) = (struct lang_type *) space;
4589: TYPE_LANG_SPECIFIC (t)->len = len;
4590:
4591: field_array = &TYPE_LANG_SPECIFIC (t)->elts[0];
4592: len = 0;
4593: for (x = fieldlist; x; x = TREE_CHAIN (x))
4594: field_array[len++] = x;
4595:
4596: qsort (field_array, len, sizeof (tree), field_decl_cmp);
4597: }
4598: }
4599:
4600: for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
4601: {
4602: TYPE_FIELDS (x) = TYPE_FIELDS (t);
4603: TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
4604: TYPE_ALIGN (x) = TYPE_ALIGN (t);
4605: }
4606:
4607: /* Promote each bit-field's type to int if it is narrower than that. */
4608: for (x = fieldlist; x; x = TREE_CHAIN (x))
4609: if (DECL_BIT_FIELD (x)
4610: && TREE_CODE (TREE_TYPE (x)) == INTEGER_TYPE
4611: && (TREE_INT_CST_LOW (DECL_SIZE (x))
4612: < TYPE_PRECISION (integer_type_node)))
4613: TREE_TYPE (x) = integer_type_node;
4614:
4615: /* If this structure or union completes the type of any previous
4616: variable declaration, lay it out and output its rtl. */
4617:
4618: if (current_binding_level->n_incomplete != 0)
4619: {
4620: tree decl;
4621: for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
4622: {
4623: if (TREE_TYPE (decl) == t
4624: && TREE_CODE (decl) != TYPE_DECL)
4625: {
4626: layout_decl (decl, 0);
4627: /* This is a no-op in c-lang.c or something real in objc-actions.c. */
4628: maybe_objc_check_decl (decl);
4629: rest_of_decl_compilation (decl, 0, toplevel, 0);
4630: if (! toplevel)
4631: expand_decl (decl);
4632: --current_binding_level->n_incomplete;
4633: }
4634: else if (TYPE_SIZE (TREE_TYPE (decl)) == 0
4635: && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
4636: {
4637: tree element = TREE_TYPE (decl);
4638: while (TREE_CODE (element) == ARRAY_TYPE)
4639: element = TREE_TYPE (element);
4640: if (element == t)
4641: layout_array_type (TREE_TYPE (decl));
4642: }
4643: }
4644: }
4645:
4646: resume_momentary (old_momentary);
4647:
4648: /* Finish debugging output for this type. */
4649: rest_of_type_compilation (t, toplevel);
4650:
4651: return t;
4652: }
4653:
4654: /* Lay out the type T, and its element type, and so on. */
4655:
4656: static void
4657: layout_array_type (t)
4658: tree t;
4659: {
4660: if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
4661: layout_array_type (TREE_TYPE (t));
4662: layout_type (t);
4663: }
4664:
4665: /* Begin compiling the definition of an enumeration type.
4666: NAME is its name (or null if anonymous).
4667: Returns the type object, as yet incomplete.
4668: Also records info about it so that build_enumerator
4669: may be used to declare the individual values as they are read. */
4670:
4671: tree
4672: start_enum (name)
4673: tree name;
4674: {
4675: register tree enumtype = 0;
4676:
4677: /* If this is the real definition for a previous forward reference,
4678: fill in the contents in the same object that used to be the
4679: forward reference. */
4680:
4681: if (name != 0)
4682: enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
4683:
4684: if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
4685: {
4686: enumtype = make_node (ENUMERAL_TYPE);
4687: pushtag (name, enumtype);
4688: }
4689:
4690: C_TYPE_BEING_DEFINED (enumtype) = 1;
4691:
4692: if (TYPE_VALUES (enumtype) != 0)
4693: {
4694: /* This enum is a named one that has been declared already. */
4695: error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
4696:
4697: /* Completely replace its old definition.
4698: The old enumerators remain defined, however. */
4699: TYPE_VALUES (enumtype) = 0;
4700: }
4701:
4702: enum_next_value = integer_zero_node;
4703:
4704: return enumtype;
4705: }
4706:
4707: /* After processing and defining all the values of an enumeration type,
4708: install their decls in the enumeration type and finish it off.
4709: ENUMTYPE is the type object and VALUES a list of decl-value pairs.
4710: Returns ENUMTYPE. */
4711:
4712: tree
4713: finish_enum (enumtype, values)
4714: register tree enumtype, values;
4715: {
4716: register tree pair;
4717: tree minnode = 0, maxnode = 0;
4718: register long maxvalue = 0;
4719: register long minvalue = 0;
4720: register int i;
4721: unsigned precision = 0;
4722: int toplevel = global_binding_level == current_binding_level;
4723:
4724: if (in_parm_level_p ())
4725: warning ("enum defined inside parms");
4726:
4727: /* Calculate the maximum value of any enumerator in this type. */
4728:
4729: for (pair = values; pair; pair = TREE_CHAIN (pair))
4730: {
4731: tree value = TREE_VALUE (pair);
4732: if (pair == values)
4733: minnode = maxnode = TREE_VALUE (pair);
4734: else
4735: {
4736: if (tree_int_cst_lt (maxnode, value))
4737: maxnode = value;
4738: if (tree_int_cst_lt (value, minnode))
4739: minnode = value;
4740: }
4741: }
4742:
4743: TYPE_MIN_VALUE (enumtype) = minnode;
4744: TYPE_MAX_VALUE (enumtype) = maxnode;
4745:
4746: /* Determine the precision this type needs. */
4747:
4748: if (TREE_INT_CST_HIGH (minnode) >= 0
4749: ? tree_int_cst_lt (TYPE_MAX_VALUE (unsigned_type_node), maxnode)
4750: : (tree_int_cst_lt (minnode, TYPE_MIN_VALUE (integer_type_node))
4751: || tree_int_cst_lt (TYPE_MAX_VALUE (integer_type_node), maxnode)))
4752: precision = TYPE_PRECISION (long_long_integer_type_node);
4753: else
4754: {
4755: int maxvalue = TREE_INT_CST_LOW (maxnode);
4756: int minvalue = TREE_INT_CST_LOW (minnode);
4757:
4758: if (maxvalue > 0)
4759: precision = floor_log2 (maxvalue) + 1;
4760: if (minvalue < 0)
4761: {
4762: /* Compute number of bits to represent magnitude of a negative value.
4763: Add one to MINVALUE since range of negative numbers
4764: includes the power of two. */
4765: unsigned negprecision = floor_log2 (-minvalue - 1) + 1;
4766: if (negprecision > precision)
4767: precision = negprecision;
4768: precision += 1; /* room for sign bit */
4769: }
4770:
4771: if (!precision)
4772: precision = 1;
4773: }
4774:
4775: if (flag_short_enums || precision > TYPE_PRECISION (integer_type_node))
4776: /* Use the width of the narrowest normal C type which is wide enough. */
4777: TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size (precision, 1));
4778: else
4779: TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
4780:
4781: TYPE_SIZE (enumtype) = 0;
4782: layout_type (enumtype);
4783:
4784: /* An enum can have some negative values; then it is signed. */
4785: TREE_UNSIGNED (enumtype) = ! tree_int_cst_lt (minnode, integer_zero_node);
4786:
4787: /* If the enumerators might not fit in an int, change their type now. */
4788: /* It seems more useful in the debugger to leave these as int
4789: unless the enumerator is wider than int. */
4790: if (TYPE_PRECISION (enumtype) <= TYPE_PRECISION (integer_type_node))
4791: for (pair = values; pair; pair = TREE_CHAIN (pair))
4792: {
4793: TREE_TYPE (TREE_PURPOSE (pair)) = enumtype;
4794: DECL_SIZE (TREE_PURPOSE (pair)) = TYPE_SIZE (enumtype);
4795: DECL_ALIGN (TREE_PURPOSE (pair)) = TYPE_ALIGN (enumtype);
4796: }
4797:
4798: /* Replace the decl nodes in VALUES with their names. */
4799: for (pair = values; pair; pair = TREE_CHAIN (pair))
4800: TREE_PURPOSE (pair) = DECL_NAME (TREE_PURPOSE (pair));
4801:
4802: TYPE_VALUES (enumtype) = values;
4803:
4804: /* Finish debugging output for this type. */
4805: rest_of_type_compilation (enumtype, toplevel);
4806:
4807: return enumtype;
4808: }
4809:
4810: /* Build and install a CONST_DECL for one value of the
4811: current enumeration type (one that was begun with start_enum).
4812: Return a tree-list containing the CONST_DECL and its value.
4813: Assignment of sequential values by default is handled here. */
4814:
4815: tree
4816: build_enumerator (name, value)
4817: tree name, value;
4818: {
4819: register tree decl;
4820:
4821: /* Validate and default VALUE. */
4822:
4823: /* Remove no-op casts from the value. */
4824: while (value != 0
4825: && (TREE_CODE (value) == NOP_EXPR
4826: || TREE_CODE (value) == NON_LVALUE_EXPR))
4827: value = TREE_OPERAND (value, 0);
4828:
4829: if (value != 0 && TREE_CODE (value) != INTEGER_CST)
4830: {
4831: error ("enumerator value for `%s' not integer constant",
4832: IDENTIFIER_POINTER (name));
4833: value = 0;
4834: }
4835:
4836: /* Default based on previous value. */
4837: /* It should no longer be possible to have NON_LVALUE_EXPR
4838: in the default. */
4839: if (value == 0)
4840: value = enum_next_value;
4841:
4842: if (pedantic && ! int_fits_type_p (value, integer_type_node))
4843: {
4844: pedwarn ("ANSI C restricts enumerator values to range of `int'");
4845: value = integer_zero_node;
4846: }
4847:
4848: /* Set basis for default for next value. */
4849: enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
4850:
4851: /* Now create a declaration for the enum value name. */
4852:
4853: decl = build_decl (CONST_DECL, name, integer_type_node);
4854: DECL_INITIAL (decl) = value;
4855: TREE_TYPE (value) = integer_type_node;
4856: pushdecl (decl);
4857:
4858: return saveable_tree_cons (decl, value, NULL);
4859: }
4860:
4861: /* Create the FUNCTION_DECL for a function definition.
4862: DECLSPECS and DECLARATOR are the parts of the declaration;
4863: they describe the function's name and the type it returns,
4864: but twisted together in a fashion that parallels the syntax of C.
4865:
4866: This function creates a binding context for the function body
4867: as well as setting up the FUNCTION_DECL in current_function_decl.
4868:
4869: Returns 1 on success. If the DECLARATOR is not suitable for a function
4870: (it defines a datum instead), we return 0, which tells
4871: yyparse to report a parse error.
4872:
4873: NESTED is nonzero for a function nested within another function. */
4874:
4875: int
4876: start_function (declspecs, declarator, nested)
4877: tree declarator, declspecs;
4878: int nested;
4879: {
4880: tree decl1, old_decl;
4881: tree restype;
4882:
4883: current_function_returns_value = 0; /* Assume, until we see it does. */
4884: current_function_returns_null = 0;
4885: warn_about_return_type = 0;
4886: current_extern_inline = 0;
4887: c_function_varargs = 0;
4888: named_labels = 0;
4889: shadowed_labels = 0;
4890:
4891: decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
4892:
4893: /* If the declarator is not suitable for a function definition,
4894: cause a syntax error. */
4895: if (decl1 == 0)
4896: return 0;
4897:
4898: announce_function (decl1);
4899:
4900: if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
4901: {
4902: error ("return-type is an incomplete type");
4903: /* Make it return void instead. */
4904: TREE_TYPE (decl1)
4905: = build_function_type (void_type_node,
4906: TYPE_ARG_TYPES (TREE_TYPE (decl1)));
4907: }
4908:
4909: if (warn_about_return_type)
4910: warning ("return-type defaults to `int'");
4911:
4912: /* Save the parm names or decls from this function's declarator
4913: where store_parm_decls will find them. */
4914: current_function_parms = last_function_parms;
4915: current_function_parm_tags = last_function_parm_tags;
4916:
4917: /* Make the init_value nonzero so pushdecl knows this is not tentative.
4918: error_mark_node is replaced below (in poplevel) with the BLOCK. */
4919: DECL_INITIAL (decl1) = error_mark_node;
4920:
4921: /* If this definition isn't a prototype and we had a prototype declaration
4922: before, copy the arg type info from that prototype.
4923: But not if what we had before was a builtin function. */
4924: old_decl = lookup_name_current_level (DECL_NAME (decl1));
4925: if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
4926: && !DECL_BUILT_IN (old_decl)
4927: && TREE_TYPE (TREE_TYPE (decl1)) == TREE_TYPE (TREE_TYPE (old_decl))
4928: && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
4929: TREE_TYPE (decl1) = TREE_TYPE (old_decl);
4930:
4931: /* Optionally warn of old-fashioned def with no previous prototype. */
4932: if (warn_strict_prototypes
4933: && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
4934: && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
4935: warning ("function declaration isn't a prototype");
4936: /* Optionally warn of any global def with no previous prototype. */
4937: else if (warn_missing_prototypes
4938: && TREE_PUBLIC (decl1)
4939: && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
4940: warning_with_decl (decl1, "no previous prototype for `%s'");
4941: /* Optionally warn of any def with no previous prototype
4942: if the function has already been used. */
4943: else if (warn_missing_prototypes
4944: && old_decl != 0 && TREE_USED (old_decl)
4945: && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
4946: warning_with_decl (decl1, "`%s' was used with no prototype before its definition");
4947:
4948: /* This is a definition, not a reference.
4949: So normally clear TREE_EXTERNAL.
4950: However, `extern inline' acts like a declaration
4951: except for defining how to inline. So set TREE_EXTERNAL in that case. */
4952: TREE_EXTERNAL (decl1) = current_extern_inline;
4953:
4954: /* This function exists in static storage.
4955: (This does not mean `static' in the C sense!) */
4956: TREE_STATIC (decl1) = 1;
4957:
4958: /* A nested function is not global. */
4959: if (current_function_decl != 0)
4960: TREE_PUBLIC (decl1) = 0;
4961:
4962: /* Record the decl so that the function name is defined.
4963: If we already have a decl for this name, and it is a FUNCTION_DECL,
4964: use the old decl. */
4965:
4966: current_function_decl = pushdecl (decl1);
4967:
4968: pushlevel (0);
4969: declare_parm_level (1);
4970: current_binding_level->subblocks_tag_transparent = 1;
4971:
4972: make_function_rtl (current_function_decl);
4973:
4974: restype = TREE_TYPE (TREE_TYPE (current_function_decl));
4975: /* Promote the value to int before returning it. */
4976: if (TREE_CODE (restype) == INTEGER_TYPE
4977: && TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
4978: restype = integer_type_node;
4979: DECL_RESULT (current_function_decl) = build_decl (RESULT_DECL, 0, restype);
4980:
4981: if (!nested)
4982: /* Allocate further tree nodes temporarily during compilation
4983: of this function only. */
4984: temporary_allocation ();
4985:
4986: /* If this fcn was already referenced via a block-scope `extern' decl
4987: (or an implicit decl), propagate certain information about the usage. */
4988: if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
4989: TREE_ADDRESSABLE (current_function_decl) = 1;
4990:
4991: return 1;
4992: }
4993:
4994: /* Record that this function is going to be a varargs function.
4995: This is called before store_parm_decls, which is too early
4996: to call mark_varargs directly. */
4997:
4998: void
4999: c_mark_varargs ()
5000: {
5001: c_function_varargs = 1;
5002: }
5003:
5004: /* Store the parameter declarations into the current function declaration.
5005: This is called after parsing the parameter declarations, before
5006: digesting the body of the function.
5007:
5008: For an old-style definition, modify the function's type
5009: to specify at least the number of arguments. */
5010:
5011: void
5012: store_parm_decls ()
5013: {
5014: register tree fndecl = current_function_decl;
5015: register tree parm;
5016:
5017: /* This is either a chain of PARM_DECLs (if a prototype was used)
5018: or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */
5019: tree specparms = current_function_parms;
5020:
5021: /* This is a list of types declared among parms in a prototype. */
5022: tree parmtags = current_function_parm_tags;
5023:
5024: /* This is a chain of PARM_DECLs from old-style parm declarations. */
5025: register tree parmdecls = getdecls ();
5026:
5027: /* This is a chain of any other decls that came in among the parm
5028: declarations. If a parm is declared with enum {foo, bar} x;
5029: then CONST_DECLs for foo and bar are put here. */
5030: tree nonparms = 0;
5031:
5032: /* Nonzero if this definition is written with a prototype. */
5033: int prototype = 0;
5034:
5035: if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
5036: {
5037: /* This case is when the function was defined with an ANSI prototype.
5038: The parms already have decls, so we need not do anything here
5039: except record them as in effect
5040: and complain if any redundant old-style parm decls were written. */
5041:
5042: register tree next;
5043: tree others = 0;
5044:
5045: prototype = 1;
5046:
5047: if (parmdecls != 0)
5048: error_with_decl (fndecl,
5049: "parm types given both in parmlist and separately");
5050:
5051: specparms = nreverse (specparms);
5052: for (parm = specparms; parm; parm = next)
5053: {
5054: next = TREE_CHAIN (parm);
5055: if (TREE_CODE (parm) == PARM_DECL)
5056: {
5057: if (DECL_NAME (parm) == 0)
5058: error_with_decl (parm, "parameter name omitted");
5059: else if (TREE_TYPE (parm) == void_type_node)
5060: error_with_decl (parm, "parameter `%s' declared void");
5061: pushdecl (parm);
5062: }
5063: else
5064: {
5065: /* If we find an enum constant or a type tag,
5066: put it aside for the moment. */
5067: TREE_CHAIN (parm) = 0;
5068: others = chainon (others, parm);
5069: }
5070: }
5071:
5072: /* Get the decls in their original chain order
5073: and record in the function. */
5074: DECL_ARGUMENTS (fndecl) = getdecls ();
5075:
5076: #if 0
5077: /* If this function takes a variable number of arguments,
5078: add a phony parameter to the end of the parm list,
5079: to represent the position of the first unnamed argument. */
5080: if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
5081: != void_type_node)
5082: {
5083: tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
5084: /* Let's hope the address of the unnamed parm
5085: won't depend on its type. */
5086: TREE_TYPE (dummy) = integer_type_node;
5087: DECL_ARG_TYPE (dummy) = integer_type_node;
5088: DECL_ARGUMENTS (fndecl)
5089: = chainon (DECL_ARGUMENTS (fndecl), dummy);
5090: }
5091: #endif
5092:
5093: /* Now pushdecl the enum constants. */
5094: for (parm = others; parm; parm = next)
5095: {
5096: next = TREE_CHAIN (parm);
5097: if (DECL_NAME (parm) == 0)
5098: ;
5099: else if (TREE_TYPE (parm) == void_type_node)
5100: ;
5101: else if (TREE_CODE (parm) != PARM_DECL)
5102: pushdecl (parm);
5103: }
5104:
5105: storetags (chainon (parmtags, gettags ()));
5106: }
5107: else
5108: {
5109: /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
5110: each with a parm name as the TREE_VALUE.
5111:
5112: PARMDECLS is a chain of declarations for parameters.
5113: Warning! It can also contain CONST_DECLs which are not parameters
5114: but are names of enumerators of any enum types
5115: declared among the parameters.
5116:
5117: First match each formal parameter name with its declaration.
5118: Associate decls with the names and store the decls
5119: into the TREE_PURPOSE slots. */
5120:
5121: for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
5122: DECL_RESULT (parm) = 0;
5123:
5124: for (parm = specparms; parm; parm = TREE_CHAIN (parm))
5125: {
5126: register tree tail, found = NULL;
5127:
5128: if (TREE_VALUE (parm) == 0)
5129: {
5130: error_with_decl (fndecl, "parameter name missing from parameter list");
5131: TREE_PURPOSE (parm) = 0;
5132: continue;
5133: }
5134:
5135: /* See if any of the parmdecls specifies this parm by name.
5136: Ignore any enumerator decls. */
5137: for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
5138: if (DECL_NAME (tail) == TREE_VALUE (parm)
5139: && TREE_CODE (tail) == PARM_DECL)
5140: {
5141: found = tail;
5142: break;
5143: }
5144:
5145: /* If declaration already marked, we have a duplicate name.
5146: Complain, and don't use this decl twice. */
5147: if (found && DECL_RESULT (found) != 0)
5148: {
5149: error_with_decl (found, "multiple parameters named `%s'");
5150: found = 0;
5151: }
5152:
5153: /* If the declaration says "void", complain and ignore it. */
5154: if (found && TREE_TYPE (found) == void_type_node)
5155: {
5156: error_with_decl (found, "parameter `%s' declared void");
5157: TREE_TYPE (found) = integer_type_node;
5158: DECL_ARG_TYPE (found) = integer_type_node;
5159: layout_decl (found, 0);
5160: }
5161:
5162: /* Traditionally, a parm declared float is actually a double. */
5163: if (found && flag_traditional
5164: && TREE_TYPE (found) == float_type_node)
5165: TREE_TYPE (found) = double_type_node;
5166:
5167: /* If no declaration found, default to int. */
5168: if (!found)
5169: {
5170: found = build_decl (PARM_DECL, TREE_VALUE (parm),
5171: integer_type_node);
5172: DECL_ARG_TYPE (found) = TREE_TYPE (found);
5173: DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
5174: DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
5175: if (extra_warnings)
5176: warning_with_decl (found, "type of `%s' defaults to `int'");
5177: pushdecl (found);
5178: }
5179:
5180: TREE_PURPOSE (parm) = found;
5181:
5182: /* Mark this decl as "already found" -- see test, above.
5183: It is safe to use DECL_RESULT for this
5184: since it is not used in PARM_DECLs or CONST_DECLs. */
5185: DECL_RESULT (found) = error_mark_node;
5186: }
5187:
5188: /* Put anything which is on the parmdecls chain and which is
5189: not a PARM_DECL onto the list NONPARMS. (The types of
5190: non-parm things which might appear on the list include
5191: enumerators and NULL-named TYPE_DECL nodes.) Complain about
5192: any actual PARM_DECLs not matched with any names. */
5193:
5194: nonparms = 0;
5195: for (parm = parmdecls; parm; )
5196: {
5197: tree next = TREE_CHAIN (parm);
5198: TREE_CHAIN (parm) = 0;
5199:
5200: if (TREE_CODE (parm) != PARM_DECL)
5201: nonparms = chainon (nonparms, parm);
5202: else
5203: {
5204: /* Complain about args with incomplete types. */
5205: if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
5206: {
5207: error_with_decl (parm, "parameter `%s' has incomplete type");
5208: TREE_TYPE (parm) = error_mark_node;
5209: }
5210:
5211: if (DECL_RESULT (parm) == 0)
5212: {
5213: error_with_decl (parm,
5214: "declaration for parameter `%s' but no such parameter");
5215: /* Pretend the parameter was not missing.
5216: This gets us to a standard state and minimizes
5217: further error messages. */
5218: specparms
5219: = chainon (specparms,
5220: tree_cons (parm, NULL_TREE, NULL_TREE));
5221: }
5222: }
5223:
5224: parm = next;
5225: }
5226:
5227: /* Chain the declarations together in the order of the list of names. */
5228: /* Store that chain in the function decl, replacing the list of names. */
5229: parm = specparms;
5230: DECL_ARGUMENTS (fndecl) = 0;
5231: {
5232: register tree last;
5233: for (last = 0; parm; parm = TREE_CHAIN (parm))
5234: if (TREE_PURPOSE (parm))
5235: {
5236: if (last == 0)
5237: DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
5238: else
5239: TREE_CHAIN (last) = TREE_PURPOSE (parm);
5240: last = TREE_PURPOSE (parm);
5241: TREE_CHAIN (last) = 0;
5242: }
5243: }
5244:
5245: /* If there was a previous prototype,
5246: set the DECL_ARG_TYPE of each argument according to
5247: the type previously specified, and report any mismatches. */
5248:
5249: if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
5250: {
5251: register tree type;
5252: for (parm = DECL_ARGUMENTS (fndecl),
5253: type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
5254: parm || (type && TREE_VALUE (type) != void_type_node);
5255: parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
5256: {
5257: if (parm == 0 || type == 0
5258: || TREE_VALUE (type) == void_type_node)
5259: {
5260: error ("number of arguments doesn't match prototype");
5261: break;
5262: }
5263: /* Type for passing arg must be consistent
5264: with that declared for the arg. */
5265: if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type))
5266: /* If -traditional, allow `unsigned int' instead of `int'
5267: in the prototype. */
5268: && (! (flag_traditional
5269: && DECL_ARG_TYPE (parm) == integer_type_node
5270: && TREE_VALUE (type) == unsigned_type_node)))
5271: {
5272: error ("argument `%s' doesn't match function prototype",
5273: IDENTIFIER_POINTER (DECL_NAME (parm)));
5274: if (DECL_ARG_TYPE (parm) == integer_type_node
5275: && TREE_VALUE (type) == TREE_TYPE (parm))
5276: {
5277: error ("a formal parameter type that promotes to `int'");
5278: error ("can match only `int' in the prototype");
5279: }
5280: if (DECL_ARG_TYPE (parm) == double_type_node
5281: && TREE_VALUE (type) == TREE_TYPE (parm))
5282: {
5283: error ("a formal parameter type that promotes to `double'");
5284: error ("can match only `double' in the prototype");
5285: }
5286: }
5287: }
5288: TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
5289: }
5290:
5291: /* Otherwise, create a prototype that would match. */
5292:
5293: else
5294: {
5295: register tree actual, type;
5296: register tree last = 0;
5297:
5298: for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
5299: {
5300: type = perm_tree_cons (NULL, DECL_ARG_TYPE (parm), NULL);
5301: if (last)
5302: TREE_CHAIN (last) = type;
5303: else
5304: actual = type;
5305: last = type;
5306: }
5307: type = perm_tree_cons (NULL, void_type_node, NULL);
5308: if (last)
5309: TREE_CHAIN (last) = type;
5310: else
5311: actual = type;
5312:
5313: TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
5314: }
5315:
5316: /* Now store the final chain of decls for the arguments
5317: as the decl-chain of the current lexical scope.
5318: Put the enumerators in as well, at the front so that
5319: DECL_ARGUMENTS is not modified. */
5320:
5321: storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
5322: }
5323:
5324: /* Make sure the binding level for the top of the function body
5325: gets a BLOCK if there are any in the function.
5326: Otherwise, the dbx output is wrong. */
5327:
5328: keep_next_if_subblocks = 1;
5329:
5330: /* ??? This might be an improvement,
5331: but needs to be thought about some more. */
5332: #if 0
5333: keep_next_level_flag = 1;
5334: #endif
5335:
5336: /* Write a record describing this function definition to the prototypes
5337: file (if requested). */
5338:
5339: gen_aux_info_record (fndecl, 1, 0, prototype);
5340:
5341: /* Initialize the RTL code for the function. */
5342:
5343: init_function_start (fndecl, input_filename, lineno);
5344:
5345: /* If this is a varargs function, inform function.c. */
5346:
5347: if (c_function_varargs)
5348: mark_varargs ();
5349:
5350: /* Set up parameters and prepare for return, for the function. */
5351:
5352: expand_function_start (fndecl, 0);
5353:
5354: /* If this function is `main', emit a call to `__main'
5355: to run global initializers, etc. */
5356: if (DECL_NAME (fndecl)
5357: && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
5358: && DECL_CONTEXT (fndecl) == NULL_TREE)
5359: expand_main_function ();
5360: }
5361:
5362: /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
5363: each with a parm name as the TREE_VALUE. A null pointer as TREE_VALUE
5364: stands for an ellipsis in the identifier list.
5365:
5366: PARMLIST is the data returned by get_parm_info for the
5367: parmlist that follows the semicolon.
5368:
5369: We return a value of the same sort that get_parm_info returns,
5370: except that it describes the combination of identifiers and parmlist. */
5371:
5372: tree
5373: combine_parm_decls (specparms, parmlist, void_at_end)
5374: tree specparms, parmlist;
5375: int void_at_end;
5376: {
5377: register tree fndecl = current_function_decl;
5378: register tree parm;
5379:
5380: tree parmdecls = TREE_PURPOSE (parmlist);
5381:
5382: /* This is a chain of any other decls that came in among the parm
5383: declarations. They were separated already by get_parm_info,
5384: so we just need to keep them separate. */
5385: tree nonparms = TREE_VALUE (parmlist);
5386:
5387: tree types = 0;
5388:
5389: for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
5390: DECL_RESULT (parm) = 0;
5391:
5392: for (parm = specparms; parm; parm = TREE_CHAIN (parm))
5393: {
5394: register tree tail, found = NULL;
5395:
5396: /* See if any of the parmdecls specifies this parm by name. */
5397: for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
5398: if (DECL_NAME (tail) == TREE_VALUE (parm))
5399: {
5400: found = tail;
5401: break;
5402: }
5403:
5404: /* If declaration already marked, we have a duplicate name.
5405: Complain, and don't use this decl twice. */
5406: if (found && DECL_RESULT (found) != 0)
5407: {
5408: error_with_decl (found, "multiple parameters named `%s'");
5409: found = 0;
5410: }
5411:
5412: /* If the declaration says "void", complain and ignore it. */
5413: if (found && TREE_TYPE (found) == void_type_node)
5414: {
5415: error_with_decl (found, "parameter `%s' declared void");
5416: TREE_TYPE (found) = integer_type_node;
5417: DECL_ARG_TYPE (found) = integer_type_node;
5418: layout_decl (found, 0);
5419: }
5420:
5421: /* Traditionally, a parm declared float is actually a double. */
5422: if (found && flag_traditional
5423: && TREE_TYPE (found) == float_type_node)
5424: TREE_TYPE (found) = double_type_node;
5425:
5426: /* If no declaration found, default to int. */
5427: if (!found)
5428: {
5429: found = build_decl (PARM_DECL, TREE_VALUE (parm),
5430: integer_type_node);
5431: DECL_ARG_TYPE (found) = TREE_TYPE (found);
5432: DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
5433: DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
5434: error (found, "type of parameter `%s' is not declared");
5435: pushdecl (found);
5436: }
5437:
5438: TREE_PURPOSE (parm) = found;
5439:
5440: /* Mark this decl as "already found" -- see test, above.
5441: It is safe to use DECL_RESULT for this
5442: since it is not used in PARM_DECLs or CONST_DECLs. */
5443: DECL_RESULT (found) = error_mark_node;
5444: }
5445:
5446: /* Complain about any actual PARM_DECLs not matched with any names. */
5447:
5448: for (parm = parmdecls; parm; )
5449: {
5450: tree next = TREE_CHAIN (parm);
5451: TREE_CHAIN (parm) = 0;
5452:
5453: /* Complain about args with incomplete types. */
5454: if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
5455: {
5456: error_with_decl (parm, "parameter `%s' has incomplete type");
5457: TREE_TYPE (parm) = error_mark_node;
5458: }
5459:
5460: if (DECL_RESULT (parm) == 0)
5461: {
5462: error_with_decl (parm,
5463: "declaration for parameter `%s' but no such parameter");
5464: /* Pretend the parameter was not missing.
5465: This gets us to a standard state and minimizes
5466: further error messages. */
5467: specparms
5468: = chainon (specparms,
5469: tree_cons (parm, NULL_TREE, NULL_TREE));
5470: }
5471:
5472: parm = next;
5473: }
5474:
5475: /* Chain the declarations together in the order of the list of names.
5476: At the same time, build up a list of their types, in reverse order. */
5477:
5478: parm = specparms;
5479: parmdecls = 0;
5480: {
5481: register tree last;
5482: for (last = 0; parm; parm = TREE_CHAIN (parm))
5483: if (TREE_PURPOSE (parm))
5484: {
5485: if (last == 0)
5486: parmdecls = TREE_PURPOSE (parm);
5487: else
5488: TREE_CHAIN (last) = TREE_PURPOSE (parm);
5489: last = TREE_PURPOSE (parm);
5490: TREE_CHAIN (last) = 0;
5491:
5492: types = saveable_tree_cons (NULL_TREE, TREE_TYPE (parm), types);
5493: }
5494: }
5495:
5496: if (void_at_end)
5497: return saveable_tree_cons (parmdecls, nonparms,
5498: nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
5499:
5500: return saveable_tree_cons (parmdecls, nonparms, nreverse (types));
5501: }
5502:
5503: /* Finish up a function declaration and compile that function
5504: all the way to assembler language output. The free the storage
5505: for the function definition.
5506:
5507: This is called after parsing the body of the function definition.
5508:
5509: NESTED is nonzero if the function being finished is nested in another. */
5510:
5511: void
5512: finish_function (nested)
5513: int nested;
5514: {
5515: register tree fndecl = current_function_decl;
5516:
5517: /* TREE_READONLY (fndecl) = 1;
5518: This caused &foo to be of type ptr-to-const-function
5519: which then got a warning when stored in a ptr-to-function variable. */
5520:
5521: poplevel (1, 0, 1);
5522:
5523: /* Must mark the RESULT_DECL as being in this function. */
5524:
5525: DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
5526:
5527: /* Obey `register' declarations if `setjmp' is called in this fn. */
5528: if (flag_traditional && current_function_calls_setjmp)
5529: {
5530: setjmp_protect (DECL_INITIAL (fndecl));
5531: setjmp_protect_args ();
5532: }
5533:
5534: #ifdef DEFAULT_MAIN_RETURN
5535: if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main"))
5536: {
5537: /* Make it so that `main' always returns success by default. */
5538: DEFAULT_MAIN_RETURN;
5539: }
5540: #endif
5541:
5542: /* Generate rtl for function exit. */
5543: expand_function_end (input_filename, lineno);
5544:
5545: /* So we can tell if jump_optimize sets it to 1. */
5546: can_reach_end = 0;
5547:
5548: /* Run the optimizers and output the assembler code for this function. */
5549: rest_of_compilation (fndecl);
5550:
5551: current_function_returns_null |= can_reach_end;
5552:
5553: if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
5554: warning ("`volatile' function does return");
5555: else if (warn_return_type && current_function_returns_null
5556: && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) != void_type_node)
5557: /* If this function returns non-void and control can drop through,
5558: complain. */
5559: warning ("control reaches end of non-void function");
5560: /* With just -W, complain only if function returns both with
5561: and without a value. */
5562: else if (extra_warnings
5563: && current_function_returns_value && current_function_returns_null)
5564: warning ("this function may return with or without a value");
5565:
5566: /* Free all the tree nodes making up this function. */
5567: /* Switch back to allocating nodes permanently
5568: until we start another function. */
5569: if (! nested)
5570: permanent_allocation ();
5571:
5572: if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested)
5573: {
5574: /* Stop pointing to the local nodes about to be freed. */
5575: /* But DECL_INITIAL must remain nonzero so we know this
5576: was an actual function definition. */
5577: /* For a nested function, this is done in pop_c_function_context. */
5578: DECL_INITIAL (fndecl) = error_mark_node;
5579: DECL_ARGUMENTS (fndecl) = 0;
5580: }
5581:
5582: if (! nested)
5583: {
5584: /* Let the error reporting routines know that we're outside a
5585: function. For a nested function, this value is used in
5586: pop_c_function_context and then reset via pop_function_context. */
5587: current_function_decl = NULL;
5588: }
5589: }
5590:
5591: /* Save and restore the variables in this file and elsewhere
5592: that keep track of the progress of compilation of the current function.
5593: Used for nested functions. */
5594:
5595: struct c_function
5596: {
5597: struct c_function *next;
5598: tree enum_next_value;
5599: tree named_labels;
5600: tree shadowed_labels;
5601: int returns_value;
5602: int returns_null;
5603: int warn_about_return_type;
5604: int extern_inline;
5605: struct binding_level *binding_level;
5606: };
5607:
5608: struct c_function *c_function_chain;
5609:
5610: /* Save and reinitialize the variables
5611: used during compilation of a C function. */
5612:
5613: void
5614: push_c_function_context ()
5615: {
5616: struct c_function *p
5617: = (struct c_function *) xmalloc (sizeof (struct c_function));
5618:
5619: push_function_context ();
5620:
5621: p->next = c_function_chain;
5622: c_function_chain = p;
5623:
5624: p->enum_next_value = enum_next_value;
5625: p->named_labels = named_labels;
5626: p->shadowed_labels = shadowed_labels;
5627: p->returns_value = current_function_returns_value;
5628: p->returns_null = current_function_returns_null;
5629: p->warn_about_return_type = warn_about_return_type;
5630: p->extern_inline = current_extern_inline;
5631: p->binding_level = current_binding_level;
5632: }
5633:
5634: /* Restore the variables used during compilation of a C function. */
5635:
5636: void
5637: pop_c_function_context ()
5638: {
5639: struct c_function *p = c_function_chain;
5640: tree link;
5641:
5642: /* Bring back all the labels that were shadowed. */
5643: for (link = shadowed_labels; link; link = TREE_CHAIN (link))
5644: if (DECL_NAME (TREE_VALUE (link)) != 0)
5645: IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
5646: = TREE_VALUE (link);
5647:
5648: if (DECL_SAVED_INSNS (current_function_decl) == 0)
5649: {
5650: /* Stop pointing to the local nodes about to be freed. */
5651: /* But DECL_INITIAL must remain nonzero so we know this
5652: was an actual function definition. */
5653: DECL_INITIAL (current_function_decl) = error_mark_node;
5654: DECL_ARGUMENTS (current_function_decl) = 0;
5655: }
5656:
5657: pop_function_context ();
5658:
5659: c_function_chain = p->next;
5660:
5661: enum_next_value = p->enum_next_value;
5662: named_labels = p->named_labels;
5663: shadowed_labels = p->shadowed_labels;
5664: current_function_returns_value = p->returns_value;
5665: current_function_returns_null = p->returns_null;
5666: warn_about_return_type = p->warn_about_return_type;
5667: current_extern_inline = p->extern_inline;
5668: current_binding_level = p->binding_level;
5669:
5670: free (p);
5671: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.