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