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