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