1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 /* Process declarations and symbol lookup for C front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
25
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
28
29 #include "config.h"
30 #include "system.h"
31 #include "coretypes.h"
32 #include "input.h"
33 #include "tm.h"
34 #include "intl.h"
35 #include "tree.h"
36 #include "tree-inline.h"
37 #include "rtl.h"
38 #include "flags.h"
39 #include "function.h"
40 #include "output.h"
41 #include "expr.h"
42 #include "c-tree.h"
43 #include "toplev.h"
44 #include "ggc.h"
45 #include "tm_p.h"
46 #include "cpplib.h"
47 #include "target.h"
48 #include "debug.h"
49 #include "opts.h"
50 #include "timevar.h"
51 #include "c-common.h"
52 #include "c-pragma.h"
53 #include "langhooks.h"
54 #include "tree-mudflap.h"
55 #include "tree-gimple.h"
56 #include "diagnostic.h"
57 #include "tree-dump.h"
58 #include "cgraph.h"
59 #include "hashtab.h"
60 #include "libfuncs.h"
61 #include "except.h"
62 #include "langhooks-def.h"
63 #include "pointer-set.h"
64
65 /* In grokdeclarator, distinguish syntactic contexts of declarators. */
66 enum decl_context
67 { NORMAL, /* Ordinary declaration */
68 FUNCDEF, /* Function definition */
69 PARM, /* Declaration of parm before function body */
70 FIELD, /* Declaration inside struct or union */
71 TYPENAME}; /* Typename (inside cast or sizeof) */
72
73
74 /* Nonzero if we have seen an invalid cross reference
75 to a struct, union, or enum, but not yet printed the message. */
76 tree pending_invalid_xref;
77
78 /* File and line to appear in the eventual error message. */
79 location_t pending_invalid_xref_location;
80
81 /* True means we've initialized exception handling. */
82 bool c_eh_initialized_p;
83
84 /* While defining an enum type, this is 1 plus the last enumerator
85 constant value. Note that will do not have to save this or `enum_overflow'
86 around nested function definition since such a definition could only
87 occur in an enum value expression and we don't use these variables in
88 that case. */
89
90 static tree enum_next_value;
91
92 /* Nonzero means that there was overflow computing enum_next_value. */
93
94 static int enum_overflow;
95
96 /* The file and line that the prototype came from if this is an
97 old-style definition; used for diagnostics in
98 store_parm_decls_oldstyle. */
99
100 static location_t current_function_prototype_locus;
101
102 /* Whether this prototype was built-in. */
103
104 static bool current_function_prototype_built_in;
105
106 /* The argument type information of this prototype. */
107
108 static tree current_function_prototype_arg_types;
109
110 /* The argument information structure for the function currently being
111 defined. */
112
113 static struct c_arg_info *current_function_arg_info;
114
115 /* The obstack on which parser and related data structures, which are
116 not live beyond their top-level declaration or definition, are
117 allocated. */
118 struct obstack parser_obstack;
119
120 /* The current statement tree. */
121
122 static GTY(()) struct stmt_tree_s c_stmt_tree;
123
124 /* State saving variables. */
125 tree c_break_label;
126 tree c_cont_label;
127
128 /* Linked list of TRANSLATION_UNIT_DECLS for the translation units
129 included in this invocation. Note that the current translation
130 unit is not included in this list. */
131
132 static GTY(()) tree all_translation_units;
133
134 /* A list of decls to be made automatically visible in each file scope. */
135 static GTY(()) tree visible_builtins;
136
137 /* Set to 0 at beginning of a function definition, set to 1 if
138 a return statement that specifies a return value is seen. */
139
140 int current_function_returns_value;
141
142 /* Set to 0 at beginning of a function definition, set to 1 if
143 a return statement with no argument is seen. */
144
145 int current_function_returns_null;
146
147 /* Set to 0 at beginning of a function definition, set to 1 if
148 a call to a noreturn function is seen. */
149
150 int current_function_returns_abnormally;
151
152 /* Set to nonzero by `grokdeclarator' for a function
153 whose return type is defaulted, if warnings for this are desired. */
154
155 static int warn_about_return_type;
156
157 /* Nonzero when starting a function declared `extern inline'. */
158
159 static int current_extern_inline;
160
161 /* Nonzero when the current toplevel function contains a declaration
162 of a nested function which is never defined. */
163
164 static bool undef_nested_function;
165
166 /* True means global_bindings_p should return false even if the scope stack
167 says we are in file scope. */
168 bool c_override_global_bindings_to_false;
169
170
171 /* Each c_binding structure describes one binding of an identifier to
172 a decl. All the decls in a scope - irrespective of namespace - are
173 chained together by the ->prev field, which (as the name implies)
174 runs in reverse order. All the decls in a given namespace bound to
175 a given identifier are chained by the ->shadowed field, which runs
176 from inner to outer scopes.
177
178 The ->decl field usually points to a DECL node, but there are two
179 exceptions. In the namespace of type tags, the bound entity is a
180 RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE node. If an undeclared
181 identifier is encountered, it is bound to error_mark_node to
182 suppress further errors about that identifier in the current
183 function.
184
185 The ->type field stores the type of the declaration in this scope;
186 if NULL, the type is the type of the ->decl field. This is only of
187 relevance for objects with external or internal linkage which may
188 be redeclared in inner scopes, forming composite types that only
189 persist for the duration of those scopes. In the external scope,
190 this stores the composite of all the types declared for this
191 object, visible or not. The ->inner_comp field (used only at file
192 scope) stores whether an incomplete array type at file scope was
193 completed at an inner scope to an array size other than 1.
194
195 The depth field is copied from the scope structure that holds this
196 decl. It is used to preserve the proper ordering of the ->shadowed
197 field (see bind()) and also for a handful of special-case checks.
198 Finally, the invisible bit is true for a decl which should be
199 ignored for purposes of normal name lookup, and the nested bit is
200 true for a decl that's been bound a second time in an inner scope;
201 in all such cases, the binding in the outer scope will have its
202 invisible bit true. */
203
204 struct c_binding GTY((chain_next ("%h.prev")))
205 {
206 tree decl; /* the decl bound */
207 tree type; /* the type in this scope */
208 tree id; /* the identifier it's bound to */
209 struct c_binding *prev; /* the previous decl in this scope */
210 struct c_binding *shadowed; /* the innermost decl shadowed by this one */
211 unsigned int depth : 28; /* depth of this scope */
212 BOOL_BITFIELD invisible : 1; /* normal lookup should ignore this binding */
213 BOOL_BITFIELD nested : 1; /* do not set DECL_CONTEXT when popping */
214 BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
215 /* one free bit */
216 };
217 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
218 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
219 #define B_IN_FILE_SCOPE(b) ((b)->depth == 1 /*file_scope->depth*/)
220 #define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
221
222 #define I_SYMBOL_BINDING(node) \
223 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
224 #define I_SYMBOL_DECL(node) \
225 (I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
226
227 #define I_TAG_BINDING(node) \
228 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
229 #define I_TAG_DECL(node) \
230 (I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
231
232 #define I_LABEL_BINDING(node) \
233 (((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
234 #define I_LABEL_DECL(node) \
235 (I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
236
237 /* Each C symbol points to three linked lists of c_binding structures.
238 These describe the values of the identifier in the three different
239 namespaces defined by the language. */
240
241 struct lang_identifier GTY(())
242 {
243 struct c_common_identifier common_id;
244 struct c_binding *symbol_binding; /* vars, funcs, constants, typedefs */
245 struct c_binding *tag_binding; /* struct/union/enum tags */
246 struct c_binding *label_binding; /* labels */
247 };
248
249 /* Validate c-lang.c's assumptions. */
250 extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
251 [(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1];
252
253 /* The resulting tree type. */
254
255 union lang_tree_node
256 GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
257 chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : (union lang_tree_node *) TREE_CHAIN (&%h.generic)")))
258 {
259 union tree_node GTY ((tag ("0"),
260 desc ("tree_node_structure (&%h)")))
261 generic;
262 struct lang_identifier GTY ((tag ("1"))) identifier;
263 };
264
265 /* Each c_scope structure describes the complete contents of one
266 scope. Four scopes are distinguished specially: the innermost or
267 current scope, the innermost function scope, the file scope (always
268 the second to outermost) and the outermost or external scope.
269
270 Most declarations are recorded in the current scope.
271
272 All normal label declarations are recorded in the innermost
273 function scope, as are bindings of undeclared identifiers to
274 error_mark_node. (GCC permits nested functions as an extension,
275 hence the 'innermost' qualifier.) Explicitly declared labels
276 (using the __label__ extension) appear in the current scope.
277
278 Being in the file scope (current_scope == file_scope) causes
279 special behavior in several places below. Also, under some
280 conditions the Objective-C front end records declarations in the
281 file scope even though that isn't the current scope.
282
283 All declarations with external linkage are recorded in the external
284 scope, even if they aren't visible there; this models the fact that
285 such declarations are visible to the entire program, and (with a
286 bit of cleverness, see pushdecl) allows diagnosis of some violations
287 of C99 6.2.2p7 and 6.2.7p2:
288
289 If, within the same translation unit, the same identifier appears
290 with both internal and external linkage, the behavior is
291 undefined.
292
293 All declarations that refer to the same object or function shall
294 have compatible type; otherwise, the behavior is undefined.
295
296 Initially only the built-in declarations, which describe compiler
297 intrinsic functions plus a subset of the standard library, are in
298 this scope.
299
300 The order of the blocks list matters, and it is frequently appended
301 to. To avoid having to walk all the way to the end of the list on
302 each insertion, or reverse the list later, we maintain a pointer to
303 the last list entry. (FIXME: It should be feasible to use a reversed
304 list here.)
305
306 The bindings list is strictly in reverse order of declarations;
307 pop_scope relies on this. */
308
309
310 struct c_scope GTY((chain_next ("%h.outer")))
311 {
312 /* The scope containing this one. */
313 struct c_scope *outer;
314
315 /* The next outermost function scope. */
316 struct c_scope *outer_function;
317
318 /* All bindings in this scope. */
319 struct c_binding *bindings;
320
321 /* For each scope (except the global one), a chain of BLOCK nodes
322 for all the scopes that were entered and exited one level down. */
323 tree blocks;
324 tree blocks_last;
325
326 /* The depth of this scope. Used to keep the ->shadowed chain of
327 bindings sorted innermost to outermost. */
328 unsigned int depth : 28;
329
330 /* True if we are currently filling this scope with parameter
331 declarations. */
332 BOOL_BITFIELD parm_flag : 1;
333
334 /* True if we already complained about forward parameter decls
335 in this scope. This prevents double warnings on
336 foo (int a; int b; ...) */
337 BOOL_BITFIELD warned_forward_parm_decls : 1;
338
339 /* True if this is the outermost block scope of a function body.
340 This scope contains the parameters, the local variables declared
341 in the outermost block, and all the labels (except those in
342 nested functions, or declared at block scope with __label__). */
343 BOOL_BITFIELD function_body : 1;
344
345 /* True means make a BLOCK for this scope no matter what. */
346 BOOL_BITFIELD keep : 1;
347 };
348
349 /* The scope currently in effect. */
350
351 static GTY(()) struct c_scope *current_scope;
352
353 /* The innermost function scope. Ordinary (not explicitly declared)
354 labels, bindings to error_mark_node, and the lazily-created
355 bindings of __func__ and its friends get this scope. */
356
357 static GTY(()) struct c_scope *current_function_scope;
358
359 /* The C file scope. This is reset for each input translation unit. */
360
361 static GTY(()) struct c_scope *file_scope;
362
363 /* The outermost scope. This is used for all declarations with
364 external linkage, and only these, hence the name. */
365
366 static GTY(()) struct c_scope *external_scope;
367
368 /* A chain of c_scope structures awaiting reuse. */
369
370 static GTY((deletable)) struct c_scope *scope_freelist;
371
372 /* A chain of c_binding structures awaiting reuse. */
373
374 static GTY((deletable)) struct c_binding *binding_freelist;
375
376 /* Append VAR to LIST in scope SCOPE. */
377 #define SCOPE_LIST_APPEND(scope, list, decl) do { \
378 struct c_scope *s_ = (scope); \
379 tree d_ = (decl); \
380 if (s_->list##_last) \
381 TREE_CHAIN (s_->list##_last) = d_; \
382 else \
383 s_->list = d_; \
384 s_->list##_last = d_; \
385 } while (0)
386
387 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE. */
388 #define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do { \
389 struct c_scope *t_ = (tscope); \
390 struct c_scope *f_ = (fscope); \
391 if (t_->to##_last) \
392 TREE_CHAIN (t_->to##_last) = f_->from; \
393 else \
394 t_->to = f_->from; \
395 t_->to##_last = f_->from##_last; \
396 } while (0)
397
398 /* True means unconditionally make a BLOCK for the next scope pushed. */
399
400 static bool keep_next_level_flag;
401
402 /* True means the next call to push_scope will be the outermost scope
403 of a function body, so do not push a new scope, merely cease
404 expecting parameter decls. */
405
406 static bool next_is_function_body;
407
408 /* Functions called automatically at the beginning and end of execution. */
409
410 static GTY(()) tree static_ctors;
411 static GTY(()) tree static_dtors;
412
413 /* Forward declarations. */
414 static tree lookup_name_in_scope (tree, struct c_scope *);
415 static tree c_make_fname_decl (tree, int);
416 static tree grokdeclarator (const struct c_declarator *,
417 struct c_declspecs *,
418 enum decl_context, bool, tree *);
419 static tree grokparms (struct c_arg_info *, bool);
420 static void layout_array_type (tree);
421
422 /* T is a statement. Add it to the statement-tree. This is the
423 C/ObjC version--C++ has a slightly different version of this
424 function. */
425
426 tree
add_stmt(tree t)427 add_stmt (tree t)
428 {
429 enum tree_code code = TREE_CODE (t);
430
431 if (EXPR_P (t) && code != LABEL_EXPR)
432 {
433 if (!EXPR_HAS_LOCATION (t))
434 SET_EXPR_LOCATION (t, input_location);
435 }
436
437 if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
438 STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
439
440 /* Add T to the statement-tree. Non-side-effect statements need to be
441 recorded during statement expressions. */
442 append_to_statement_list_force (t, &cur_stmt_list);
443
444 return t;
445 }
446
447 /* States indicating how grokdeclarator() should handle declspecs marked
448 with __attribute__((deprecated)). An object declared as
449 __attribute__((deprecated)) suppresses warnings of uses of other
450 deprecated items. */
451
452 enum deprecated_states {
453 DEPRECATED_NORMAL,
454 DEPRECATED_SUPPRESS
455 };
456
457 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
458
459 void
c_print_identifier(FILE * file,tree node,int indent)460 c_print_identifier (FILE *file, tree node, int indent)
461 {
462 print_node (file, "symbol", I_SYMBOL_DECL (node), indent + 4);
463 print_node (file, "tag", I_TAG_DECL (node), indent + 4);
464 print_node (file, "label", I_LABEL_DECL (node), indent + 4);
465 if (C_IS_RESERVED_WORD (node))
466 {
467 tree rid = ridpointers[C_RID_CODE (node)];
468 indent_to (file, indent + 4);
469 fprintf (file, "rid %p \"%s\"",
470 (void *) rid, IDENTIFIER_POINTER (rid));
471 }
472 }
473
474 /* Establish a binding between NAME, an IDENTIFIER_NODE, and DECL,
475 which may be any of several kinds of DECL or TYPE or error_mark_node,
476 in the scope SCOPE. */
477 static void
bind(tree name,tree decl,struct c_scope * scope,bool invisible,bool nested)478 bind (tree name, tree decl, struct c_scope *scope, bool invisible, bool nested)
479 {
480 struct c_binding *b, **here;
481
482 if (binding_freelist)
483 {
484 b = binding_freelist;
485 binding_freelist = b->prev;
486 }
487 else
488 b = GGC_NEW (struct c_binding);
489
490 b->shadowed = 0;
491 b->decl = decl;
492 b->id = name;
493 b->depth = scope->depth;
494 b->invisible = invisible;
495 b->nested = nested;
496 b->inner_comp = 0;
497
498 b->type = 0;
499
500 b->prev = scope->bindings;
501 scope->bindings = b;
502
503 if (!name)
504 return;
505
506 switch (TREE_CODE (decl))
507 {
508 case LABEL_DECL: here = &I_LABEL_BINDING (name); break;
509 case ENUMERAL_TYPE:
510 case UNION_TYPE:
511 case RECORD_TYPE: here = &I_TAG_BINDING (name); break;
512 case VAR_DECL:
513 case FUNCTION_DECL:
514 case TYPE_DECL:
515 case CONST_DECL:
516 case PARM_DECL:
517 case ERROR_MARK: here = &I_SYMBOL_BINDING (name); break;
518
519 default:
520 gcc_unreachable ();
521 }
522
523 /* Locate the appropriate place in the chain of shadowed decls
524 to insert this binding. Normally, scope == current_scope and
525 this does nothing. */
526 while (*here && (*here)->depth > scope->depth)
527 here = &(*here)->shadowed;
528
529 b->shadowed = *here;
530 *here = b;
531 }
532
533 /* Clear the binding structure B, stick it on the binding_freelist,
534 and return the former value of b->prev. This is used by pop_scope
535 and get_parm_info to iterate destructively over all the bindings
536 from a given scope. */
537 static struct c_binding *
free_binding_and_advance(struct c_binding * b)538 free_binding_and_advance (struct c_binding *b)
539 {
540 struct c_binding *prev = b->prev;
541
542 memset (b, 0, sizeof (struct c_binding));
543 b->prev = binding_freelist;
544 binding_freelist = b;
545
546 return prev;
547 }
548
549
550 /* Hook called at end of compilation to assume 1 elt
551 for a file-scope tentative array defn that wasn't complete before. */
552
553 void
c_finish_incomplete_decl(tree decl)554 c_finish_incomplete_decl (tree decl)
555 {
556 if (TREE_CODE (decl) == VAR_DECL)
557 {
558 tree type = TREE_TYPE (decl);
559 if (type != error_mark_node
560 && TREE_CODE (type) == ARRAY_TYPE
561 && !DECL_EXTERNAL (decl)
562 && TYPE_DOMAIN (type) == 0)
563 {
564 warning (0, "array %q+D assumed to have one element", decl);
565
566 complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
567
568 layout_decl (decl, 0);
569 }
570 }
571 }
572
573 /* The Objective-C front-end often needs to determine the current scope. */
574
575 void *
objc_get_current_scope(void)576 objc_get_current_scope (void)
577 {
578 return current_scope;
579 }
580
581 /* The following function is used only by Objective-C. It needs to live here
582 because it accesses the innards of c_scope. */
583
584 void
objc_mark_locals_volatile(void * enclosing_blk)585 objc_mark_locals_volatile (void *enclosing_blk)
586 {
587 struct c_scope *scope;
588 struct c_binding *b;
589
590 for (scope = current_scope;
591 scope && scope != enclosing_blk;
592 scope = scope->outer)
593 {
594 for (b = scope->bindings; b; b = b->prev)
595 objc_volatilize_decl (b->decl);
596
597 /* Do not climb up past the current function. */
598 if (scope->function_body)
599 break;
600 }
601 }
602
603 /* Nonzero if we are currently in file scope. */
604
605 int
global_bindings_p(void)606 global_bindings_p (void)
607 {
608 return current_scope == file_scope && !c_override_global_bindings_to_false;
609 }
610
611 void
keep_next_level(void)612 keep_next_level (void)
613 {
614 keep_next_level_flag = true;
615 }
616
617 /* Identify this scope as currently being filled with parameters. */
618
619 void
declare_parm_level(void)620 declare_parm_level (void)
621 {
622 current_scope->parm_flag = true;
623 }
624
625 void
push_scope(void)626 push_scope (void)
627 {
628 if (next_is_function_body)
629 {
630 /* This is the transition from the parameters to the top level
631 of the function body. These are the same scope
632 (C99 6.2.1p4,6) so we do not push another scope structure.
633 next_is_function_body is set only by store_parm_decls, which
634 in turn is called when and only when we are about to
635 encounter the opening curly brace for the function body.
636
637 The outermost block of a function always gets a BLOCK node,
638 because the debugging output routines expect that each
639 function has at least one BLOCK. */
640 current_scope->parm_flag = false;
641 current_scope->function_body = true;
642 current_scope->keep = true;
643 current_scope->outer_function = current_function_scope;
644 current_function_scope = current_scope;
645
646 keep_next_level_flag = false;
647 next_is_function_body = false;
648 }
649 else
650 {
651 struct c_scope *scope;
652 if (scope_freelist)
653 {
654 scope = scope_freelist;
655 scope_freelist = scope->outer;
656 }
657 else
658 scope = GGC_CNEW (struct c_scope);
659
660 scope->keep = keep_next_level_flag;
661 scope->outer = current_scope;
662 scope->depth = current_scope ? (current_scope->depth + 1) : 0;
663
664 /* Check for scope depth overflow. Unlikely (2^28 == 268,435,456) but
665 possible. */
666 if (current_scope && scope->depth == 0)
667 {
668 scope->depth--;
669 sorry ("GCC supports only %u nested scopes", scope->depth);
670 }
671
672 current_scope = scope;
673 keep_next_level_flag = false;
674 }
675 }
676
677 /* Set the TYPE_CONTEXT of all of TYPE's variants to CONTEXT. */
678
679 static void
set_type_context(tree type,tree context)680 set_type_context (tree type, tree context)
681 {
682 for (type = TYPE_MAIN_VARIANT (type); type;
683 type = TYPE_NEXT_VARIANT (type))
684 TYPE_CONTEXT (type) = context;
685 }
686
687 /* Exit a scope. Restore the state of the identifier-decl mappings
688 that were in effect when this scope was entered. Return a BLOCK
689 node containing all the DECLs in this scope that are of interest
690 to debug info generation. */
691
692 tree
pop_scope(void)693 pop_scope (void)
694 {
695 struct c_scope *scope = current_scope;
696 tree block, context, p;
697 struct c_binding *b;
698
699 bool functionbody = scope->function_body;
700 bool keep = functionbody || scope->keep || scope->bindings;
701
702 c_end_vm_scope (scope->depth);
703
704 /* If appropriate, create a BLOCK to record the decls for the life
705 of this function. */
706 block = 0;
707 if (keep)
708 {
709 block = make_node (BLOCK);
710 BLOCK_SUBBLOCKS (block) = scope->blocks;
711 TREE_USED (block) = 1;
712
713 /* In each subblock, record that this is its superior. */
714 for (p = scope->blocks; p; p = TREE_CHAIN (p))
715 BLOCK_SUPERCONTEXT (p) = block;
716
717 BLOCK_VARS (block) = 0;
718 }
719
720 /* The TYPE_CONTEXTs for all of the tagged types belonging to this
721 scope must be set so that they point to the appropriate
722 construct, i.e. either to the current FUNCTION_DECL node, or
723 else to the BLOCK node we just constructed.
724
725 Note that for tagged types whose scope is just the formal
726 parameter list for some function type specification, we can't
727 properly set their TYPE_CONTEXTs here, because we don't have a
728 pointer to the appropriate FUNCTION_TYPE node readily available
729 to us. For those cases, the TYPE_CONTEXTs of the relevant tagged
730 type nodes get set in `grokdeclarator' as soon as we have created
731 the FUNCTION_TYPE node which will represent the "scope" for these
732 "parameter list local" tagged types. */
733 if (scope->function_body)
734 context = current_function_decl;
735 else if (scope == file_scope)
736 {
737 tree file_decl = build_decl (TRANSLATION_UNIT_DECL, 0, 0);
738 TREE_CHAIN (file_decl) = all_translation_units;
739 all_translation_units = file_decl;
740 context = file_decl;
741 }
742 else
743 context = block;
744
745 /* Clear all bindings in this scope. */
746 for (b = scope->bindings; b; b = free_binding_and_advance (b))
747 {
748 p = b->decl;
749 switch (TREE_CODE (p))
750 {
751 case LABEL_DECL:
752 /* Warnings for unused labels, errors for undefined labels. */
753 if (TREE_USED (p) && !DECL_INITIAL (p))
754 {
755 error ("label %q+D used but not defined", p);
756 DECL_INITIAL (p) = error_mark_node;
757 }
758 else if (!TREE_USED (p) && warn_unused_label)
759 {
760 if (DECL_INITIAL (p))
761 warning (0, "label %q+D defined but not used", p);
762 else
763 warning (0, "label %q+D declared but not defined", p);
764 }
765 /* Labels go in BLOCK_VARS. */
766 TREE_CHAIN (p) = BLOCK_VARS (block);
767 BLOCK_VARS (block) = p;
768 gcc_assert (I_LABEL_BINDING (b->id) == b);
769 I_LABEL_BINDING (b->id) = b->shadowed;
770 break;
771
772 case ENUMERAL_TYPE:
773 case UNION_TYPE:
774 case RECORD_TYPE:
775 set_type_context (p, context);
776
777 /* Types may not have tag-names, in which case the type
778 appears in the bindings list with b->id NULL. */
779 if (b->id)
780 {
781 gcc_assert (I_TAG_BINDING (b->id) == b);
782 I_TAG_BINDING (b->id) = b->shadowed;
783 }
784 break;
785
786 case FUNCTION_DECL:
787 /* Propagate TREE_ADDRESSABLE from nested functions to their
788 containing functions. */
789 if (!TREE_ASM_WRITTEN (p)
790 && DECL_INITIAL (p) != 0
791 && TREE_ADDRESSABLE (p)
792 && DECL_ABSTRACT_ORIGIN (p) != 0
793 && DECL_ABSTRACT_ORIGIN (p) != p)
794 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (p)) = 1;
795 if (!DECL_EXTERNAL (p)
796 && DECL_INITIAL (p) == 0)
797 {
798 error ("nested function %q+D declared but never defined", p);
799 undef_nested_function = true;
800 }
801 goto common_symbol;
802
803 case VAR_DECL:
804 /* Warnings for unused variables. */
805 if (!TREE_USED (p)
806 && !TREE_NO_WARNING (p)
807 && !DECL_IN_SYSTEM_HEADER (p)
808 && DECL_NAME (p)
809 && !DECL_ARTIFICIAL (p)
810 && scope != file_scope
811 && scope != external_scope)
812 warning (OPT_Wunused_variable, "unused variable %q+D", p);
813
814 if (b->inner_comp)
815 {
816 error ("type of array %q+D completed incompatibly with"
817 " implicit initialization", p);
818 }
819
820 /* Fall through. */
821 case TYPE_DECL:
822 case CONST_DECL:
823 common_symbol:
824 /* All of these go in BLOCK_VARS, but only if this is the
825 binding in the home scope. */
826 if (!b->nested)
827 {
828 TREE_CHAIN (p) = BLOCK_VARS (block);
829 BLOCK_VARS (block) = p;
830 }
831 /* If this is the file scope, and we are processing more
832 than one translation unit in this compilation, set
833 DECL_CONTEXT of each decl to the TRANSLATION_UNIT_DECL.
834 This makes same_translation_unit_p work, and causes
835 static declarations to be given disambiguating suffixes. */
836 if (scope == file_scope && num_in_fnames > 1)
837 {
838 DECL_CONTEXT (p) = context;
839 if (TREE_CODE (p) == TYPE_DECL)
840 set_type_context (TREE_TYPE (p), context);
841 }
842
843 /* Fall through. */
844 /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
845 already been put there by store_parm_decls. Unused-
846 parameter warnings are handled by function.c.
847 error_mark_node obviously does not go in BLOCK_VARS and
848 does not get unused-variable warnings. */
849 case PARM_DECL:
850 case ERROR_MARK:
851 /* It is possible for a decl not to have a name. We get
852 here with b->id NULL in this case. */
853 if (b->id)
854 {
855 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
856 I_SYMBOL_BINDING (b->id) = b->shadowed;
857 if (b->shadowed && b->shadowed->type)
858 TREE_TYPE (b->shadowed->decl) = b->shadowed->type;
859 }
860 break;
861
862 default:
863 gcc_unreachable ();
864 }
865 }
866
867
868 /* Dispose of the block that we just made inside some higher level. */
869 if ((scope->function_body || scope == file_scope) && context)
870 {
871 DECL_INITIAL (context) = block;
872 BLOCK_SUPERCONTEXT (block) = context;
873 }
874 else if (scope->outer)
875 {
876 if (block)
877 SCOPE_LIST_APPEND (scope->outer, blocks, block);
878 /* If we did not make a block for the scope just exited, any
879 blocks made for inner scopes must be carried forward so they
880 will later become subblocks of something else. */
881 else if (scope->blocks)
882 SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
883 }
884
885 /* Pop the current scope, and free the structure for reuse. */
886 current_scope = scope->outer;
887 if (scope->function_body)
888 current_function_scope = scope->outer_function;
889
890 memset (scope, 0, sizeof (struct c_scope));
891 scope->outer = scope_freelist;
892 scope_freelist = scope;
893
894 return block;
895 }
896
897 void
push_file_scope(void)898 push_file_scope (void)
899 {
900 tree decl;
901
902 if (file_scope)
903 return;
904
905 push_scope ();
906 file_scope = current_scope;
907
908 start_fname_decls ();
909
910 for (decl = visible_builtins; decl; decl = TREE_CHAIN (decl))
911 bind (DECL_NAME (decl), decl, file_scope,
912 /*invisible=*/false, /*nested=*/true);
913 }
914
915 void
pop_file_scope(void)916 pop_file_scope (void)
917 {
918 /* In case there were missing closebraces, get us back to the global
919 binding level. */
920 while (current_scope != file_scope)
921 pop_scope ();
922
923 /* __FUNCTION__ is defined at file scope (""). This
924 call may not be necessary as my tests indicate it
925 still works without it. */
926 finish_fname_decls ();
927
928 /* This is the point to write out a PCH if we're doing that.
929 In that case we do not want to do anything else. */
930 if (pch_file)
931 {
932 c_common_write_pch ();
933 return;
934 }
935
936 /* Pop off the file scope and close this translation unit. */
937 pop_scope ();
938 file_scope = 0;
939
940 maybe_apply_pending_pragma_weaks ();
941 cgraph_finalize_compilation_unit ();
942 }
943
944 /* Insert BLOCK at the end of the list of subblocks of the current
945 scope. This is used when a BIND_EXPR is expanded, to handle the
946 BLOCK node inside the BIND_EXPR. */
947
948 void
insert_block(tree block)949 insert_block (tree block)
950 {
951 TREE_USED (block) = 1;
952 SCOPE_LIST_APPEND (current_scope, blocks, block);
953 }
954
955 /* Push a definition or a declaration of struct, union or enum tag "name".
956 "type" should be the type node.
957 We assume that the tag "name" is not already defined.
958
959 Note that the definition may really be just a forward reference.
960 In that case, the TYPE_SIZE will be zero. */
961
962 static void
pushtag(tree name,tree type)963 pushtag (tree name, tree type)
964 {
965 /* Record the identifier as the type's name if it has none. */
966 if (name && !TYPE_NAME (type))
967 TYPE_NAME (type) = name;
968 bind (name, type, current_scope, /*invisible=*/false, /*nested=*/false);
969
970 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
971 tagged type we just added to the current scope. This fake
972 NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
973 to output a representation of a tagged type, and it also gives
974 us a convenient place to record the "scope start" address for the
975 tagged type. */
976
977 TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
978
979 /* An approximation for now, so we can tell this is a function-scope tag.
980 This will be updated in pop_scope. */
981 TYPE_CONTEXT (type) = DECL_CONTEXT (TYPE_STUB_DECL (type));
982 }
983
984 /* Subroutine of compare_decls. Allow harmless mismatches in return
985 and argument types provided that the type modes match. This function
986 return a unified type given a suitable match, and 0 otherwise. */
987
988 static tree
match_builtin_function_types(tree newtype,tree oldtype)989 match_builtin_function_types (tree newtype, tree oldtype)
990 {
991 tree newrettype, oldrettype;
992 tree newargs, oldargs;
993 tree trytype, tryargs;
994
995 /* Accept the return type of the new declaration if same modes. */
996 oldrettype = TREE_TYPE (oldtype);
997 newrettype = TREE_TYPE (newtype);
998
999 if (TYPE_MODE (oldrettype) != TYPE_MODE (newrettype))
1000 return 0;
1001
1002 oldargs = TYPE_ARG_TYPES (oldtype);
1003 newargs = TYPE_ARG_TYPES (newtype);
1004 tryargs = newargs;
1005
1006 while (oldargs || newargs)
1007 {
1008 if (!oldargs
1009 || !newargs
1010 || !TREE_VALUE (oldargs)
1011 || !TREE_VALUE (newargs)
1012 || TYPE_MODE (TREE_VALUE (oldargs))
1013 != TYPE_MODE (TREE_VALUE (newargs)))
1014 return 0;
1015
1016 oldargs = TREE_CHAIN (oldargs);
1017 newargs = TREE_CHAIN (newargs);
1018 }
1019
1020 trytype = build_function_type (newrettype, tryargs);
1021 return build_type_attribute_variant (trytype, TYPE_ATTRIBUTES (oldtype));
1022 }
1023
1024 /* Subroutine of diagnose_mismatched_decls. Check for function type
1025 mismatch involving an empty arglist vs a nonempty one and give clearer
1026 diagnostics. */
1027 static void
diagnose_arglist_conflict(tree newdecl,tree olddecl,tree newtype,tree oldtype)1028 diagnose_arglist_conflict (tree newdecl, tree olddecl,
1029 tree newtype, tree oldtype)
1030 {
1031 tree t;
1032
1033 if (TREE_CODE (olddecl) != FUNCTION_DECL
1034 || !comptypes (TREE_TYPE (oldtype), TREE_TYPE (newtype))
1035 || !((TYPE_ARG_TYPES (oldtype) == 0 && DECL_INITIAL (olddecl) == 0)
1036 ||
1037 (TYPE_ARG_TYPES (newtype) == 0 && DECL_INITIAL (newdecl) == 0)))
1038 return;
1039
1040 t = TYPE_ARG_TYPES (oldtype);
1041 if (t == 0)
1042 t = TYPE_ARG_TYPES (newtype);
1043 for (; t; t = TREE_CHAIN (t))
1044 {
1045 tree type = TREE_VALUE (t);
1046
1047 if (TREE_CHAIN (t) == 0
1048 && TYPE_MAIN_VARIANT (type) != void_type_node)
1049 {
1050 inform ("a parameter list with an ellipsis can%'t match "
1051 "an empty parameter name list declaration");
1052 break;
1053 }
1054
1055 if (c_type_promotes_to (type) != type)
1056 {
1057 inform ("an argument type that has a default promotion can%'t match "
1058 "an empty parameter name list declaration");
1059 break;
1060 }
1061 }
1062 }
1063
1064 /* Another subroutine of diagnose_mismatched_decls. OLDDECL is an
1065 old-style function definition, NEWDECL is a prototype declaration.
1066 Diagnose inconsistencies in the argument list. Returns TRUE if
1067 the prototype is compatible, FALSE if not. */
1068 static bool
validate_proto_after_old_defn(tree newdecl,tree newtype,tree oldtype)1069 validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
1070 {
1071 tree newargs, oldargs;
1072 int i;
1073
1074 #define END_OF_ARGLIST(t) ((t) == void_type_node)
1075
1076 oldargs = TYPE_ACTUAL_ARG_TYPES (oldtype);
1077 newargs = TYPE_ARG_TYPES (newtype);
1078 i = 1;
1079
1080 for (;;)
1081 {
1082 tree oldargtype = TYPE_MAIN_VARIANT (TREE_VALUE (oldargs));
1083 tree newargtype = TYPE_MAIN_VARIANT (TREE_VALUE (newargs));
1084
1085 if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
1086 break;
1087
1088 /* Reaching the end of just one list means the two decls don't
1089 agree on the number of arguments. */
1090 if (END_OF_ARGLIST (oldargtype))
1091 {
1092 error ("prototype for %q+D declares more arguments "
1093 "than previous old-style definition", newdecl);
1094 return false;
1095 }
1096 else if (END_OF_ARGLIST (newargtype))
1097 {
1098 error ("prototype for %q+D declares fewer arguments "
1099 "than previous old-style definition", newdecl);
1100 return false;
1101 }
1102
1103 /* Type for passing arg must be consistent with that declared
1104 for the arg. */
1105 else if (!comptypes (oldargtype, newargtype))
1106 {
1107 error ("prototype for %q+D declares argument %d"
1108 " with incompatible type",
1109 newdecl, i);
1110 return false;
1111 }
1112
1113 oldargs = TREE_CHAIN (oldargs);
1114 newargs = TREE_CHAIN (newargs);
1115 i++;
1116 }
1117
1118 /* If we get here, no errors were found, but do issue a warning
1119 for this poor-style construct. */
1120 warning (0, "prototype for %q+D follows non-prototype definition",
1121 newdecl);
1122 return true;
1123 #undef END_OF_ARGLIST
1124 }
1125
1126 /* Subroutine of diagnose_mismatched_decls. Report the location of DECL,
1127 first in a pair of mismatched declarations, using the diagnostic
1128 function DIAG. */
1129 static void
1130 locate_old_decl (tree decl, void (*diag)(const char *, ...) ATTRIBUTE_GCC_CDIAG(1,2))
1131 {
1132 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1133 ;
1134 else if (DECL_INITIAL (decl))
1135 diag (G_("previous definition of %q+D was here"), decl);
1136 else if (C_DECL_IMPLICIT (decl))
1137 diag (G_("previous implicit declaration of %q+D was here"), decl);
1138 else
1139 diag (G_("previous declaration of %q+D was here"), decl);
1140 }
1141
1142 /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
1143 Returns true if the caller should proceed to merge the two, false
1144 if OLDDECL should simply be discarded. As a side effect, issues
1145 all necessary diagnostics for invalid or poor-style combinations.
1146 If it returns true, writes the types of NEWDECL and OLDDECL to
1147 *NEWTYPEP and *OLDTYPEP - these may have been adjusted from
1148 TREE_TYPE (NEWDECL, OLDDECL) respectively. */
1149
1150 static bool
diagnose_mismatched_decls(tree newdecl,tree olddecl,tree * newtypep,tree * oldtypep)1151 diagnose_mismatched_decls (tree newdecl, tree olddecl,
1152 tree *newtypep, tree *oldtypep)
1153 {
1154 tree newtype, oldtype;
1155 bool pedwarned = false;
1156 bool warned = false;
1157 bool retval = true;
1158
1159 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL) \
1160 && DECL_EXTERNAL (DECL))
1161
1162 /* If we have error_mark_node for either decl or type, just discard
1163 the previous decl - we're in an error cascade already. */
1164 if (olddecl == error_mark_node || newdecl == error_mark_node)
1165 return false;
1166 *oldtypep = oldtype = TREE_TYPE (olddecl);
1167 *newtypep = newtype = TREE_TYPE (newdecl);
1168 if (oldtype == error_mark_node || newtype == error_mark_node)
1169 return false;
1170
1171 /* Two different categories of symbol altogether. This is an error
1172 unless OLDDECL is a builtin. OLDDECL will be discarded in any case. */
1173 if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1174 {
1175 if (!(TREE_CODE (olddecl) == FUNCTION_DECL
1176 && DECL_BUILT_IN (olddecl)
1177 && !C_DECL_DECLARED_BUILTIN (olddecl)))
1178 {
1179 error ("%q+D redeclared as different kind of symbol", newdecl);
1180 locate_old_decl (olddecl, error);
1181 }
1182 else if (TREE_PUBLIC (newdecl))
1183 warning (0, "built-in function %q+D declared as non-function",
1184 newdecl);
1185 else
1186 warning (OPT_Wshadow, "declaration of %q+D shadows "
1187 "a built-in function", newdecl);
1188 return false;
1189 }
1190
1191 /* Enumerators have no linkage, so may only be declared once in a
1192 given scope. */
1193 if (TREE_CODE (olddecl) == CONST_DECL)
1194 {
1195 error ("redeclaration of enumerator %q+D", newdecl);
1196 locate_old_decl (olddecl, error);
1197 return false;
1198 }
1199
1200 if (!comptypes (oldtype, newtype))
1201 {
1202 if (TREE_CODE (olddecl) == FUNCTION_DECL
1203 && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
1204 {
1205 /* Accept harmless mismatch in function types.
1206 This is for the ffs and fprintf builtins. */
1207 tree trytype = match_builtin_function_types (newtype, oldtype);
1208
1209 if (trytype && comptypes (newtype, trytype))
1210 *oldtypep = oldtype = trytype;
1211 else
1212 {
1213 /* If types don't match for a built-in, throw away the
1214 built-in. No point in calling locate_old_decl here, it
1215 won't print anything. */
1216 warning (0, "conflicting types for built-in function %q+D",
1217 newdecl);
1218 return false;
1219 }
1220 }
1221 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1222 && DECL_IS_BUILTIN (olddecl))
1223 {
1224 /* A conflicting function declaration for a predeclared
1225 function that isn't actually built in. Objective C uses
1226 these. The new declaration silently overrides everything
1227 but the volatility (i.e. noreturn) indication. See also
1228 below. FIXME: Make Objective C use normal builtins. */
1229 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1230 return false;
1231 }
1232 /* Permit void foo (...) to match int foo (...) if the latter is
1233 the definition and implicit int was used. See
1234 c-torture/compile/920625-2.c. */
1235 else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
1236 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
1237 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
1238 && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
1239 {
1240 pedwarn ("conflicting types for %q+D", newdecl);
1241 /* Make sure we keep void as the return type. */
1242 TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
1243 C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
1244 pedwarned = true;
1245 }
1246 /* Permit void foo (...) to match an earlier call to foo (...) with
1247 no declared type (thus, implicitly int). */
1248 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1249 && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
1250 && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
1251 && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
1252 {
1253 pedwarn ("conflicting types for %q+D", newdecl);
1254 /* Make sure we keep void as the return type. */
1255 TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
1256 pedwarned = true;
1257 }
1258 else
1259 {
1260 if (TYPE_QUALS (newtype) != TYPE_QUALS (oldtype))
1261 error ("conflicting type qualifiers for %q+D", newdecl);
1262 else
1263 error ("conflicting types for %q+D", newdecl);
1264 diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
1265 locate_old_decl (olddecl, error);
1266 return false;
1267 }
1268 }
1269
1270 /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
1271 but silently ignore the redeclaration if either is in a system
1272 header. (Conflicting redeclarations were handled above.) */
1273 if (TREE_CODE (newdecl) == TYPE_DECL)
1274 {
1275 if (DECL_IN_SYSTEM_HEADER (newdecl) || DECL_IN_SYSTEM_HEADER (olddecl))
1276 return true; /* Allow OLDDECL to continue in use. */
1277
1278 error ("redefinition of typedef %q+D", newdecl);
1279 locate_old_decl (olddecl, error);
1280 return false;
1281 }
1282
1283 /* Function declarations can either be 'static' or 'extern' (no
1284 qualifier is equivalent to 'extern' - C99 6.2.2p5) and therefore
1285 can never conflict with each other on account of linkage (6.2.2p4).
1286 Multiple definitions are not allowed (6.9p3,5) but GCC permits
1287 two definitions if one is 'extern inline' and one is not. The non-
1288 extern-inline definition supersedes the extern-inline definition. */
1289
1290 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1291 {
1292 /* If you declare a built-in function name as static, or
1293 define the built-in with an old-style definition (so we
1294 can't validate the argument list) the built-in definition is
1295 overridden, but optionally warn this was a bad choice of name. */
1296 if (DECL_BUILT_IN (olddecl)
1297 && !C_DECL_DECLARED_BUILTIN (olddecl)
1298 && (!TREE_PUBLIC (newdecl)
1299 || (DECL_INITIAL (newdecl)
1300 && !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
1301 {
1302 warning (OPT_Wshadow, "declaration of %q+D shadows "
1303 "a built-in function", newdecl);
1304 /* Discard the old built-in function. */
1305 return false;
1306 }
1307
1308 if (DECL_INITIAL (newdecl))
1309 {
1310 if (DECL_INITIAL (olddecl))
1311 {
1312 /* If both decls are in the same TU and the new declaration
1313 isn't overriding an extern inline reject the new decl.
1314 When we handle c99 style inline rules we'll want to reject
1315 the following:
1316
1317 DECL_EXTERN_INLINE (olddecl)
1318 && !DECL_EXTERN_INLINE (newdecl)
1319
1320 if they're in the same translation unit. Until we implement
1321 the full semantics we accept the construct. */
1322 if (!(DECL_EXTERN_INLINE (olddecl)
1323 && !DECL_EXTERN_INLINE (newdecl))
1324 && same_translation_unit_p (newdecl, olddecl))
1325 {
1326 error ("redefinition of %q+D", newdecl);
1327 locate_old_decl (olddecl, error);
1328 return false;
1329 }
1330 }
1331 }
1332 /* If we have a prototype after an old-style function definition,
1333 the argument types must be checked specially. */
1334 else if (DECL_INITIAL (olddecl)
1335 && !TYPE_ARG_TYPES (oldtype) && TYPE_ARG_TYPES (newtype)
1336 && TYPE_ACTUAL_ARG_TYPES (oldtype)
1337 && !validate_proto_after_old_defn (newdecl, newtype, oldtype))
1338 {
1339 locate_old_decl (olddecl, error);
1340 return false;
1341 }
1342 /* A non-static declaration (even an "extern") followed by a
1343 static declaration is undefined behavior per C99 6.2.2p3-5,7.
1344 The same is true for a static forward declaration at block
1345 scope followed by a non-static declaration/definition at file
1346 scope. Static followed by non-static at the same scope is
1347 not undefined behavior, and is the most convenient way to get
1348 some effects (see e.g. what unwind-dw2-fde-glibc.c does to
1349 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
1350 we do diagnose it if -Wtraditional. */
1351 if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
1352 {
1353 /* Two exceptions to the rule. If olddecl is an extern
1354 inline, or a predeclared function that isn't actually
1355 built in, newdecl silently overrides olddecl. The latter
1356 occur only in Objective C; see also above. (FIXME: Make
1357 Objective C use normal builtins.) */
1358 if (!DECL_IS_BUILTIN (olddecl)
1359 && !DECL_EXTERN_INLINE (olddecl))
1360 {
1361 error ("static declaration of %q+D follows "
1362 "non-static declaration", newdecl);
1363 locate_old_decl (olddecl, error);
1364 }
1365 return false;
1366 }
1367 else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
1368 {
1369 if (DECL_CONTEXT (olddecl))
1370 {
1371 error ("non-static declaration of %q+D follows "
1372 "static declaration", newdecl);
1373 locate_old_decl (olddecl, error);
1374 return false;
1375 }
1376 else if (warn_traditional)
1377 {
1378 warning (OPT_Wtraditional, "non-static declaration of %q+D "
1379 "follows static declaration", newdecl);
1380 warned = true;
1381 }
1382 }
1383 }
1384 else if (TREE_CODE (newdecl) == VAR_DECL)
1385 {
1386 /* Only variables can be thread-local, and all declarations must
1387 agree on this property. */
1388 if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
1389 {
1390 if (DECL_THREAD_LOCAL_P (newdecl))
1391 error ("thread-local declaration of %q+D follows "
1392 "non-thread-local declaration", newdecl);
1393 else
1394 error ("non-thread-local declaration of %q+D follows "
1395 "thread-local declaration", newdecl);
1396
1397 locate_old_decl (olddecl, error);
1398 return false;
1399 }
1400
1401 /* Multiple initialized definitions are not allowed (6.9p3,5). */
1402 if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
1403 {
1404 error ("redefinition of %q+D", newdecl);
1405 locate_old_decl (olddecl, error);
1406 return false;
1407 }
1408
1409 /* Objects declared at file scope: if the first declaration had
1410 external linkage (even if it was an external reference) the
1411 second must have external linkage as well, or the behavior is
1412 undefined. If the first declaration had internal linkage, then
1413 the second must too, or else be an external reference (in which
1414 case the composite declaration still has internal linkage).
1415 As for function declarations, we warn about the static-then-
1416 extern case only for -Wtraditional. See generally 6.2.2p3-5,7. */
1417 if (DECL_FILE_SCOPE_P (newdecl)
1418 && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
1419 {
1420 if (DECL_EXTERNAL (newdecl))
1421 {
1422 if (!DECL_FILE_SCOPE_P (olddecl))
1423 {
1424 error ("extern declaration of %q+D follows "
1425 "declaration with no linkage", newdecl);
1426 locate_old_decl (olddecl, error);
1427 return false;
1428 }
1429 else if (warn_traditional)
1430 {
1431 warning (OPT_Wtraditional, "non-static declaration of %q+D "
1432 "follows static declaration", newdecl);
1433 warned = true;
1434 }
1435 }
1436 else
1437 {
1438 if (TREE_PUBLIC (newdecl))
1439 error ("non-static declaration of %q+D follows "
1440 "static declaration", newdecl);
1441 else
1442 error ("static declaration of %q+D follows "
1443 "non-static declaration", newdecl);
1444
1445 locate_old_decl (olddecl, error);
1446 return false;
1447 }
1448 }
1449 /* Two objects with the same name declared at the same block
1450 scope must both be external references (6.7p3). */
1451 else if (!DECL_FILE_SCOPE_P (newdecl))
1452 {
1453 if (DECL_EXTERNAL (newdecl))
1454 {
1455 /* Extern with initializer at block scope, which will
1456 already have received an error. */
1457 }
1458 else if (DECL_EXTERNAL (olddecl))
1459 {
1460 error ("declaration of %q+D with no linkage follows "
1461 "extern declaration", newdecl);
1462 locate_old_decl (olddecl, error);
1463 }
1464 else
1465 {
1466 error ("redeclaration of %q+D with no linkage", newdecl);
1467 locate_old_decl (olddecl, error);
1468 }
1469
1470 return false;
1471 }
1472 }
1473
1474 /* warnings */
1475 /* All decls must agree on a visibility. */
1476 if (CODE_CONTAINS_STRUCT (TREE_CODE (newdecl), TS_DECL_WITH_VIS)
1477 && DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
1478 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1479 {
1480 warning (0, "redeclaration of %q+D with different visibility "
1481 "(old visibility preserved)", newdecl);
1482 warned = true;
1483 }
1484
1485 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1486 {
1487 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
1488 if (DECL_DECLARED_INLINE_P (newdecl)
1489 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1490 {
1491 warning (OPT_Wattributes, "inline declaration of %qD follows "
1492 "declaration with attribute noinline", newdecl);
1493 warned = true;
1494 }
1495 else if (DECL_DECLARED_INLINE_P (olddecl)
1496 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1497 {
1498 warning (OPT_Wattributes, "declaration of %q+D with attribute "
1499 "noinline follows inline declaration ", newdecl);
1500 warned = true;
1501 }
1502
1503 /* Inline declaration after use or definition.
1504 ??? Should we still warn about this now we have unit-at-a-time
1505 mode and can get it right?
1506 Definitely don't complain if the decls are in different translation
1507 units. */
1508 if (DECL_DECLARED_INLINE_P (newdecl) && !DECL_DECLARED_INLINE_P (olddecl)
1509 && same_translation_unit_p (olddecl, newdecl))
1510 {
1511 if (TREE_USED (olddecl))
1512 {
1513 warning (0, "%q+D declared inline after being called", olddecl);
1514 warned = true;
1515 }
1516 else if (DECL_INITIAL (olddecl))
1517 {
1518 warning (0, "%q+D declared inline after its definition", olddecl);
1519 warned = true;
1520 }
1521 }
1522 }
1523 else /* PARM_DECL, VAR_DECL */
1524 {
1525 /* Redeclaration of a parameter is a constraint violation (this is
1526 not explicitly stated, but follows from C99 6.7p3 [no more than
1527 one declaration of the same identifier with no linkage in the
1528 same scope, except type tags] and 6.2.2p6 [parameters have no
1529 linkage]). We must check for a forward parameter declaration,
1530 indicated by TREE_ASM_WRITTEN on the old declaration - this is
1531 an extension, the mandatory diagnostic for which is handled by
1532 mark_forward_parm_decls. */
1533
1534 if (TREE_CODE (newdecl) == PARM_DECL
1535 && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
1536 {
1537 error ("redefinition of parameter %q+D", newdecl);
1538 locate_old_decl (olddecl, error);
1539 return false;
1540 }
1541 }
1542
1543 /* Optional warning for completely redundant decls. */
1544 if (!warned && !pedwarned
1545 && warn_redundant_decls
1546 /* Don't warn about a function declaration followed by a
1547 definition. */
1548 && !(TREE_CODE (newdecl) == FUNCTION_DECL
1549 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
1550 /* Don't warn about redundant redeclarations of builtins. */
1551 && !(TREE_CODE (newdecl) == FUNCTION_DECL
1552 && !DECL_BUILT_IN (newdecl)
1553 && DECL_BUILT_IN (olddecl)
1554 && !C_DECL_DECLARED_BUILTIN (olddecl))
1555 /* Don't warn about an extern followed by a definition. */
1556 && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
1557 /* Don't warn about forward parameter decls. */
1558 && !(TREE_CODE (newdecl) == PARM_DECL
1559 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
1560 /* Don't warn about a variable definition following a declaration. */
1561 && !(TREE_CODE (newdecl) == VAR_DECL
1562 && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
1563 {
1564 warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
1565 newdecl);
1566 warned = true;
1567 }
1568
1569 /* Report location of previous decl/defn in a consistent manner. */
1570 if (warned || pedwarned)
1571 locate_old_decl (olddecl, pedwarned ? pedwarn : warning0);
1572
1573 #undef DECL_EXTERN_INLINE
1574
1575 return retval;
1576 }
1577
1578 /* Subroutine of duplicate_decls. NEWDECL has been found to be
1579 consistent with OLDDECL, but carries new information. Merge the
1580 new information into OLDDECL. This function issues no
1581 diagnostics. */
1582
1583 static void
merge_decls(tree newdecl,tree olddecl,tree newtype,tree oldtype)1584 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
1585 {
1586 int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
1587 && DECL_INITIAL (newdecl) != 0);
1588 int new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
1589 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0);
1590 int old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
1591 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0);
1592
1593 /* For real parm decl following a forward decl, rechain the old decl
1594 in its new location and clear TREE_ASM_WRITTEN (it's not a
1595 forward decl anymore). */
1596 if (TREE_CODE (newdecl) == PARM_DECL
1597 && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
1598 {
1599 struct c_binding *b, **here;
1600
1601 for (here = ¤t_scope->bindings; *here; here = &(*here)->prev)
1602 if ((*here)->decl == olddecl)
1603 goto found;
1604 gcc_unreachable ();
1605
1606 found:
1607 b = *here;
1608 *here = b->prev;
1609 b->prev = current_scope->bindings;
1610 current_scope->bindings = b;
1611
1612 TREE_ASM_WRITTEN (olddecl) = 0;
1613 }
1614
1615 DECL_ATTRIBUTES (newdecl)
1616 = targetm.merge_decl_attributes (olddecl, newdecl);
1617
1618 /* Merge the data types specified in the two decls. */
1619 TREE_TYPE (newdecl)
1620 = TREE_TYPE (olddecl)
1621 = composite_type (newtype, oldtype);
1622
1623 /* Lay the type out, unless already done. */
1624 if (!comptypes (oldtype, TREE_TYPE (newdecl)))
1625 {
1626 if (TREE_TYPE (newdecl) != error_mark_node)
1627 layout_type (TREE_TYPE (newdecl));
1628 if (TREE_CODE (newdecl) != FUNCTION_DECL
1629 && TREE_CODE (newdecl) != TYPE_DECL
1630 && TREE_CODE (newdecl) != CONST_DECL)
1631 layout_decl (newdecl, 0);
1632 }
1633 else
1634 {
1635 /* Since the type is OLDDECL's, make OLDDECL's size go with. */
1636 DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
1637 DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
1638 DECL_MODE (newdecl) = DECL_MODE (olddecl);
1639 if (TREE_CODE (olddecl) != FUNCTION_DECL)
1640 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
1641 {
1642 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
1643 DECL_USER_ALIGN (newdecl) |= DECL_ALIGN (olddecl);
1644 }
1645 }
1646
1647
1648 /* Merge the type qualifiers. */
1649 if (TREE_READONLY (newdecl))
1650 TREE_READONLY (olddecl) = 1;
1651
1652 if (TREE_THIS_VOLATILE (newdecl))
1653 {
1654 TREE_THIS_VOLATILE (olddecl) = 1;
1655 if (TREE_CODE (newdecl) == VAR_DECL)
1656 make_var_volatile (newdecl);
1657 }
1658
1659 /* Merge deprecatedness. */
1660 if (TREE_DEPRECATED (newdecl))
1661 TREE_DEPRECATED (olddecl) = 1;
1662
1663 /* Keep source location of definition rather than declaration and of
1664 prototype rather than non-prototype unless that prototype is
1665 built-in. */
1666 if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
1667 || (old_is_prototype && !new_is_prototype
1668 && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
1669 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1670
1671 /* Merge the initialization information. */
1672 if (DECL_INITIAL (newdecl) == 0)
1673 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1674
1675 if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
1676 {
1677 /* Merge the unused-warning information. */
1678 if (DECL_IN_SYSTEM_HEADER (olddecl))
1679 DECL_IN_SYSTEM_HEADER (newdecl) = 1;
1680 else if (DECL_IN_SYSTEM_HEADER (newdecl))
1681 DECL_IN_SYSTEM_HEADER (olddecl) = 1;
1682
1683 /* Merge the section attribute.
1684 We want to issue an error if the sections conflict but that must be
1685 done later in decl_attributes since we are called before attributes
1686 are assigned. */
1687 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1688 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1689
1690 /* Copy the assembler name.
1691 Currently, it can only be defined in the prototype. */
1692 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1693
1694 /* Use visibility of whichever declaration had it specified */
1695 if (DECL_VISIBILITY_SPECIFIED (olddecl))
1696 {
1697 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1698 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1699 }
1700
1701 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1702 {
1703 DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
1704 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1705 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1706 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1707 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1708 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1709 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1710 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1711 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1712 DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
1713 }
1714
1715 /* Merge the storage class information. */
1716 merge_weak (newdecl, olddecl);
1717
1718 /* For functions, static overrides non-static. */
1719 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1720 {
1721 TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
1722 /* This is since we don't automatically
1723 copy the attributes of NEWDECL into OLDDECL. */
1724 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1725 /* If this clears `static', clear it in the identifier too. */
1726 if (!TREE_PUBLIC (olddecl))
1727 TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
1728 }
1729 }
1730
1731 if (DECL_EXTERNAL (newdecl))
1732 {
1733 TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
1734 DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
1735
1736 /* An extern decl does not override previous storage class. */
1737 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1738 if (!DECL_EXTERNAL (newdecl))
1739 {
1740 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1741 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1742 }
1743 }
1744 else
1745 {
1746 TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
1747 TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
1748 }
1749
1750 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1751 {
1752 /* If we're redefining a function previously defined as extern
1753 inline, make sure we emit debug info for the inline before we
1754 throw it away, in case it was inlined into a function that hasn't
1755 been written out yet. */
1756 if (new_is_definition && DECL_INITIAL (olddecl))
1757 {
1758 if (TREE_USED (olddecl)
1759 /* In unit-at-a-time mode we never inline re-defined extern
1760 inline functions. */
1761 && !flag_unit_at_a_time
1762 && cgraph_function_possibly_inlined_p (olddecl))
1763 (*debug_hooks->outlining_inline_function) (olddecl);
1764
1765 /* The new defn must not be inline. */
1766 DECL_INLINE (newdecl) = 0;
1767 DECL_UNINLINABLE (newdecl) = 1;
1768 }
1769 else
1770 {
1771 /* If either decl says `inline', this fn is inline,
1772 unless its definition was passed already. */
1773 if (DECL_DECLARED_INLINE_P (newdecl)
1774 || DECL_DECLARED_INLINE_P (olddecl))
1775 DECL_DECLARED_INLINE_P (newdecl) = 1;
1776
1777 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1778 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1779 }
1780
1781 if (DECL_BUILT_IN (olddecl))
1782 {
1783 /* If redeclaring a builtin function, it stays built in.
1784 But it gets tagged as having been declared. */
1785 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1786 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1787 C_DECL_DECLARED_BUILTIN (newdecl) = 1;
1788 if (new_is_prototype)
1789 C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
1790 else
1791 C_DECL_BUILTIN_PROTOTYPE (newdecl)
1792 = C_DECL_BUILTIN_PROTOTYPE (olddecl);
1793 }
1794
1795 /* Also preserve various other info from the definition. */
1796 if (!new_is_definition)
1797 {
1798 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1799 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1800 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1801 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1802 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1803
1804 /* Set DECL_INLINE on the declaration if we've got a body
1805 from which to instantiate. */
1806 if (DECL_INLINE (olddecl) && !DECL_UNINLINABLE (newdecl))
1807 {
1808 DECL_INLINE (newdecl) = 1;
1809 DECL_ABSTRACT_ORIGIN (newdecl)
1810 = DECL_ABSTRACT_ORIGIN (olddecl);
1811 }
1812 }
1813 else
1814 {
1815 /* If a previous declaration said inline, mark the
1816 definition as inlinable. */
1817 if (DECL_DECLARED_INLINE_P (newdecl)
1818 && !DECL_UNINLINABLE (newdecl))
1819 DECL_INLINE (newdecl) = 1;
1820 }
1821 }
1822
1823 /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
1824 But preserve OLDDECL's DECL_UID and DECL_CONTEXT. */
1825 {
1826 unsigned olddecl_uid = DECL_UID (olddecl);
1827 tree olddecl_context = DECL_CONTEXT (olddecl);
1828
1829 memcpy ((char *) olddecl + sizeof (struct tree_common),
1830 (char *) newdecl + sizeof (struct tree_common),
1831 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
1832 switch (TREE_CODE (olddecl))
1833 {
1834 case FIELD_DECL:
1835 case VAR_DECL:
1836 case PARM_DECL:
1837 case LABEL_DECL:
1838 case RESULT_DECL:
1839 case CONST_DECL:
1840 case TYPE_DECL:
1841 case FUNCTION_DECL:
1842 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1843 (char *) newdecl + sizeof (struct tree_decl_common),
1844 tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
1845 break;
1846
1847 default:
1848
1849 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1850 (char *) newdecl + sizeof (struct tree_decl_common),
1851 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
1852 }
1853 DECL_UID (olddecl) = olddecl_uid;
1854 DECL_CONTEXT (olddecl) = olddecl_context;
1855 }
1856
1857 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1858 so that encode_section_info has a chance to look at the new decl
1859 flags and attributes. */
1860 if (DECL_RTL_SET_P (olddecl)
1861 && (TREE_CODE (olddecl) == FUNCTION_DECL
1862 || (TREE_CODE (olddecl) == VAR_DECL
1863 && TREE_STATIC (olddecl))))
1864 make_decl_rtl (olddecl);
1865 }
1866
1867 /* Handle when a new declaration NEWDECL has the same name as an old
1868 one OLDDECL in the same binding contour. Prints an error message
1869 if appropriate.
1870
1871 If safely possible, alter OLDDECL to look like NEWDECL, and return
1872 true. Otherwise, return false. */
1873
1874 static bool
duplicate_decls(tree newdecl,tree olddecl)1875 duplicate_decls (tree newdecl, tree olddecl)
1876 {
1877 tree newtype = NULL, oldtype = NULL;
1878
1879 if (!diagnose_mismatched_decls (newdecl, olddecl, &newtype, &oldtype))
1880 {
1881 /* Avoid `unused variable' and other warnings warnings for OLDDECL. */
1882 TREE_NO_WARNING (olddecl) = 1;
1883 return false;
1884 }
1885
1886 merge_decls (newdecl, olddecl, newtype, oldtype);
1887 return true;
1888 }
1889
1890
1891 /* Check whether decl-node NEW_DECL shadows an existing declaration. */
1892 static void
warn_if_shadowing(tree new_decl)1893 warn_if_shadowing (tree new_decl)
1894 {
1895 struct c_binding *b;
1896
1897 /* Shadow warnings wanted? */
1898 if (!warn_shadow
1899 /* No shadow warnings for internally generated vars. */
1900 || DECL_IS_BUILTIN (new_decl)
1901 /* No shadow warnings for vars made for inlining. */
1902 || DECL_FROM_INLINE (new_decl))
1903 return;
1904
1905 /* Is anything being shadowed? Invisible decls do not count. */
1906 for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
1907 if (b->decl && b->decl != new_decl && !b->invisible)
1908 {
1909 tree old_decl = b->decl;
1910
1911 if (old_decl == error_mark_node)
1912 {
1913 warning (OPT_Wshadow, "declaration of %q+D shadows previous "
1914 "non-variable", new_decl);
1915 break;
1916 }
1917 else if (TREE_CODE (old_decl) == PARM_DECL)
1918 warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
1919 new_decl);
1920 else if (DECL_FILE_SCOPE_P (old_decl))
1921 warning (OPT_Wshadow, "declaration of %q+D shadows a global "
1922 "declaration", new_decl);
1923 else if (TREE_CODE (old_decl) == FUNCTION_DECL
1924 && DECL_BUILT_IN (old_decl))
1925 {
1926 warning (OPT_Wshadow, "declaration of %q+D shadows "
1927 "a built-in function", new_decl);
1928 break;
1929 }
1930 else
1931 warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
1932 new_decl);
1933
1934 warning (OPT_Wshadow, "%Jshadowed declaration is here", old_decl);
1935
1936 break;
1937 }
1938 }
1939
1940
1941 /* Subroutine of pushdecl.
1942
1943 X is a TYPE_DECL for a typedef statement. Create a brand new
1944 ..._TYPE node (which will be just a variant of the existing
1945 ..._TYPE node with identical properties) and then install X
1946 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
1947
1948 The whole point here is to end up with a situation where each
1949 and every ..._TYPE node the compiler creates will be uniquely
1950 associated with AT MOST one node representing a typedef name.
1951 This way, even though the compiler substitutes corresponding
1952 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
1953 early on, later parts of the compiler can always do the reverse
1954 translation and get back the corresponding typedef name. For
1955 example, given:
1956
1957 typedef struct S MY_TYPE;
1958 MY_TYPE object;
1959
1960 Later parts of the compiler might only know that `object' was of
1961 type `struct S' if it were not for code just below. With this
1962 code however, later parts of the compiler see something like:
1963
1964 struct S' == struct S
1965 typedef struct S' MY_TYPE;
1966 struct S' object;
1967
1968 And they can then deduce (from the node for type struct S') that
1969 the original object declaration was:
1970
1971 MY_TYPE object;
1972
1973 Being able to do this is important for proper support of protoize,
1974 and also for generating precise symbolic debugging information
1975 which takes full account of the programmer's (typedef) vocabulary.
1976
1977 Obviously, we don't want to generate a duplicate ..._TYPE node if
1978 the TYPE_DECL node that we are now processing really represents a
1979 standard built-in type.
1980
1981 Since all standard types are effectively declared at line zero
1982 in the source file, we can easily check to see if we are working
1983 on a standard type by checking the current value of lineno. */
1984
1985 static void
clone_underlying_type(tree x)1986 clone_underlying_type (tree x)
1987 {
1988 if (DECL_IS_BUILTIN (x))
1989 {
1990 if (TYPE_NAME (TREE_TYPE (x)) == 0)
1991 TYPE_NAME (TREE_TYPE (x)) = x;
1992 }
1993 else if (TREE_TYPE (x) != error_mark_node
1994 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
1995 {
1996 tree tt = TREE_TYPE (x);
1997 DECL_ORIGINAL_TYPE (x) = tt;
1998 tt = build_variant_type_copy (tt);
1999 TYPE_NAME (tt) = x;
2000 TREE_USED (tt) = TREE_USED (x);
2001 TREE_TYPE (x) = tt;
2002 }
2003 }
2004
2005 /* Record a decl-node X as belonging to the current lexical scope.
2006 Check for errors (such as an incompatible declaration for the same
2007 name already seen in the same scope).
2008
2009 Returns either X or an old decl for the same name.
2010 If an old decl is returned, it may have been smashed
2011 to agree with what X says. */
2012
2013 tree
pushdecl(tree x)2014 pushdecl (tree x)
2015 {
2016 tree name = DECL_NAME (x);
2017 struct c_scope *scope = current_scope;
2018 struct c_binding *b;
2019 bool nested = false;
2020
2021 /* Functions need the lang_decl data. */
2022 if (TREE_CODE (x) == FUNCTION_DECL && !DECL_LANG_SPECIFIC (x))
2023 DECL_LANG_SPECIFIC (x) = GGC_CNEW (struct lang_decl);
2024
2025 /* Must set DECL_CONTEXT for everything not at file scope or
2026 DECL_FILE_SCOPE_P won't work. Local externs don't count
2027 unless they have initializers (which generate code). */
2028 if (current_function_decl
2029 && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
2030 || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
2031 DECL_CONTEXT (x) = current_function_decl;
2032
2033 /* If this is of variably modified type, prevent jumping into its
2034 scope. */
2035 if ((TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == TYPE_DECL)
2036 && variably_modified_type_p (TREE_TYPE (x), NULL_TREE))
2037 c_begin_vm_scope (scope->depth);
2038
2039 /* Anonymous decls are just inserted in the scope. */
2040 if (!name)
2041 {
2042 bind (name, x, scope, /*invisible=*/false, /*nested=*/false);
2043 return x;
2044 }
2045
2046 /* First, see if there is another declaration with the same name in
2047 the current scope. If there is, duplicate_decls may do all the
2048 work for us. If duplicate_decls returns false, that indicates
2049 two incompatible decls in the same scope; we are to silently
2050 replace the old one (duplicate_decls has issued all appropriate
2051 diagnostics). In particular, we should not consider possible
2052 duplicates in the external scope, or shadowing. */
2053 b = I_SYMBOL_BINDING (name);
2054 if (b && B_IN_SCOPE (b, scope))
2055 {
2056 struct c_binding *b_ext, *b_use;
2057 tree type = TREE_TYPE (x);
2058 tree visdecl = b->decl;
2059 tree vistype = TREE_TYPE (visdecl);
2060 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
2061 && COMPLETE_TYPE_P (TREE_TYPE (x)))
2062 b->inner_comp = false;
2063 b_use = b;
2064 b_ext = b;
2065 /* If this is an external linkage declaration, we should check
2066 for compatibility with the type in the external scope before
2067 setting the type at this scope based on the visible
2068 information only. */
2069 if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
2070 {
2071 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
2072 b_ext = b_ext->shadowed;
2073 if (b_ext)
2074 {
2075 b_use = b_ext;
2076 if (b_use->type)
2077 TREE_TYPE (b_use->decl) = b_use->type;
2078 }
2079 }
2080 if (duplicate_decls (x, b_use->decl))
2081 {
2082 if (b_use != b)
2083 {
2084 /* Save the updated type in the external scope and
2085 restore the proper type for this scope. */
2086 tree thistype;
2087 if (comptypes (vistype, type))
2088 thistype = composite_type (vistype, type);
2089 else
2090 thistype = TREE_TYPE (b_use->decl);
2091 b_use->type = TREE_TYPE (b_use->decl);
2092 if (TREE_CODE (b_use->decl) == FUNCTION_DECL
2093 && DECL_BUILT_IN (b_use->decl))
2094 thistype
2095 = build_type_attribute_variant (thistype,
2096 TYPE_ATTRIBUTES
2097 (b_use->type));
2098 TREE_TYPE (b_use->decl) = thistype;
2099 }
2100 return b_use->decl;
2101 }
2102 else
2103 goto skip_external_and_shadow_checks;
2104 }
2105
2106 /* All declarations with external linkage, and all external
2107 references, go in the external scope, no matter what scope is
2108 current. However, the binding in that scope is ignored for
2109 purposes of normal name lookup. A separate binding structure is
2110 created in the requested scope; this governs the normal
2111 visibility of the symbol.
2112
2113 The binding in the externals scope is used exclusively for
2114 detecting duplicate declarations of the same object, no matter
2115 what scope they are in; this is what we do here. (C99 6.2.7p2:
2116 All declarations that refer to the same object or function shall
2117 have compatible type; otherwise, the behavior is undefined.) */
2118 if (DECL_EXTERNAL (x) || scope == file_scope)
2119 {
2120 tree type = TREE_TYPE (x);
2121 tree vistype = 0;
2122 tree visdecl = 0;
2123 bool type_saved = false;
2124 if (b && !B_IN_EXTERNAL_SCOPE (b)
2125 && (TREE_CODE (b->decl) == FUNCTION_DECL
2126 || TREE_CODE (b->decl) == VAR_DECL)
2127 && DECL_FILE_SCOPE_P (b->decl))
2128 {
2129 visdecl = b->decl;
2130 vistype = TREE_TYPE (visdecl);
2131 }
2132 if (scope != file_scope
2133 && !DECL_IN_SYSTEM_HEADER (x))
2134 warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
2135
2136 while (b && !B_IN_EXTERNAL_SCOPE (b))
2137 {
2138 /* If this decl might be modified, save its type. This is
2139 done here rather than when the decl is first bound
2140 because the type may change after first binding, through
2141 being completed or through attributes being added. If we
2142 encounter multiple such decls, only the first should have
2143 its type saved; the others will already have had their
2144 proper types saved and the types will not have changed as
2145 their scopes will not have been re-entered. */
2146 if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
2147 {
2148 b->type = TREE_TYPE (b->decl);
2149 type_saved = true;
2150 }
2151 if (B_IN_FILE_SCOPE (b)
2152 && TREE_CODE (b->decl) == VAR_DECL
2153 && TREE_STATIC (b->decl)
2154 && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
2155 && !TYPE_DOMAIN (TREE_TYPE (b->decl))
2156 && TREE_CODE (type) == ARRAY_TYPE
2157 && TYPE_DOMAIN (type)
2158 && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
2159 && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
2160 {
2161 /* Array type completed in inner scope, which should be
2162 diagnosed if the completion does not have size 1 and
2163 it does not get completed in the file scope. */
2164 b->inner_comp = true;
2165 }
2166 b = b->shadowed;
2167 }
2168
2169 /* If a matching external declaration has been found, set its
2170 type to the composite of all the types of that declaration.
2171 After the consistency checks, it will be reset to the
2172 composite of the visible types only. */
2173 if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2174 && b->type)
2175 TREE_TYPE (b->decl) = b->type;
2176
2177 /* The point of the same_translation_unit_p check here is,
2178 we want to detect a duplicate decl for a construct like
2179 foo() { extern bar(); } ... static bar(); but not if
2180 they are in different translation units. In any case,
2181 the static does not go in the externals scope. */
2182 if (b
2183 && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
2184 && duplicate_decls (x, b->decl))
2185 {
2186 tree thistype;
2187 if (vistype)
2188 {
2189 if (comptypes (vistype, type))
2190 thistype = composite_type (vistype, type);
2191 else
2192 thistype = TREE_TYPE (b->decl);
2193 }
2194 else
2195 thistype = type;
2196 b->type = TREE_TYPE (b->decl);
2197 if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
2198 thistype
2199 = build_type_attribute_variant (thistype,
2200 TYPE_ATTRIBUTES (b->type));
2201 TREE_TYPE (b->decl) = thistype;
2202 bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true);
2203 return b->decl;
2204 }
2205 else if (TREE_PUBLIC (x))
2206 {
2207 if (visdecl && !b && duplicate_decls (x, visdecl))
2208 {
2209 /* An external declaration at block scope referring to a
2210 visible entity with internal linkage. The composite
2211 type will already be correct for this scope, so we
2212 just need to fall through to make the declaration in
2213 this scope. */
2214 nested = true;
2215 x = visdecl;
2216 }
2217 else
2218 {
2219 bind (name, x, external_scope, /*invisible=*/true,
2220 /*nested=*/false);
2221 nested = true;
2222 }
2223 }
2224 }
2225
2226 if (TREE_CODE (x) != PARM_DECL)
2227 warn_if_shadowing (x);
2228
2229 skip_external_and_shadow_checks:
2230 if (TREE_CODE (x) == TYPE_DECL)
2231 clone_underlying_type (x);
2232
2233 bind (name, x, scope, /*invisible=*/false, nested);
2234
2235 /* If x's type is incomplete because it's based on a
2236 structure or union which has not yet been fully declared,
2237 attach it to that structure or union type, so we can go
2238 back and complete the variable declaration later, if the
2239 structure or union gets fully declared.
2240
2241 If the input is erroneous, we can have error_mark in the type
2242 slot (e.g. "f(void a, ...)") - that doesn't count as an
2243 incomplete type. */
2244 if (TREE_TYPE (x) != error_mark_node
2245 && !COMPLETE_TYPE_P (TREE_TYPE (x)))
2246 {
2247 tree element = TREE_TYPE (x);
2248
2249 while (TREE_CODE (element) == ARRAY_TYPE)
2250 element = TREE_TYPE (element);
2251 element = TYPE_MAIN_VARIANT (element);
2252
2253 if ((TREE_CODE (element) == RECORD_TYPE
2254 || TREE_CODE (element) == UNION_TYPE)
2255 && (TREE_CODE (x) != TYPE_DECL
2256 || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
2257 && !COMPLETE_TYPE_P (element))
2258 C_TYPE_INCOMPLETE_VARS (element)
2259 = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
2260 }
2261 return x;
2262 }
2263
2264 /* Record X as belonging to file scope.
2265 This is used only internally by the Objective-C front end,
2266 and is limited to its needs. duplicate_decls is not called;
2267 if there is any preexisting decl for this identifier, it is an ICE. */
2268
2269 tree
pushdecl_top_level(tree x)2270 pushdecl_top_level (tree x)
2271 {
2272 tree name;
2273 bool nested = false;
2274 gcc_assert (TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == CONST_DECL);
2275
2276 name = DECL_NAME (x);
2277
2278 gcc_assert (TREE_CODE (x) == CONST_DECL || !I_SYMBOL_BINDING (name));
2279
2280 if (TREE_PUBLIC (x))
2281 {
2282 bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false);
2283 nested = true;
2284 }
2285 if (file_scope)
2286 bind (name, x, file_scope, /*invisible=*/false, nested);
2287
2288 return x;
2289 }
2290
2291 static void
implicit_decl_warning(tree id,tree olddecl)2292 implicit_decl_warning (tree id, tree olddecl)
2293 {
2294 void (*diag) (const char *, ...) ATTRIBUTE_GCC_CDIAG(1,2);
2295 switch (mesg_implicit_function_declaration)
2296 {
2297 case 0: return;
2298 case 1: diag = warning0; break;
2299 case 2: diag = error; break;
2300 default: gcc_unreachable ();
2301 }
2302
2303 diag (G_("implicit declaration of function %qE"), id);
2304 if (olddecl)
2305 locate_old_decl (olddecl, diag);
2306 }
2307
2308 /* Generate an implicit declaration for identifier FUNCTIONID as a
2309 function of type int (). */
2310
2311 tree
implicitly_declare(tree functionid)2312 implicitly_declare (tree functionid)
2313 {
2314 struct c_binding *b;
2315 tree decl = 0;
2316 tree asmspec_tree;
2317
2318 for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
2319 {
2320 if (B_IN_SCOPE (b, external_scope))
2321 {
2322 decl = b->decl;
2323 break;
2324 }
2325 }
2326
2327 if (decl)
2328 {
2329 if (decl == error_mark_node)
2330 return decl;
2331
2332 /* FIXME: Objective-C has weird not-really-builtin functions
2333 which are supposed to be visible automatically. They wind up
2334 in the external scope because they're pushed before the file
2335 scope gets created. Catch this here and rebind them into the
2336 file scope. */
2337 if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
2338 {
2339 bind (functionid, decl, file_scope,
2340 /*invisible=*/false, /*nested=*/true);
2341 return decl;
2342 }
2343 else
2344 {
2345 tree newtype = default_function_type;
2346 if (b->type)
2347 TREE_TYPE (decl) = b->type;
2348 /* Implicit declaration of a function already declared
2349 (somehow) in a different scope, or as a built-in.
2350 If this is the first time this has happened, warn;
2351 then recycle the old declaration but with the new type. */
2352 if (!C_DECL_IMPLICIT (decl))
2353 {
2354 implicit_decl_warning (functionid, decl);
2355 C_DECL_IMPLICIT (decl) = 1;
2356 }
2357 if (DECL_BUILT_IN (decl))
2358 {
2359 newtype = build_type_attribute_variant (newtype,
2360 TYPE_ATTRIBUTES
2361 (TREE_TYPE (decl)));
2362 if (!comptypes (newtype, TREE_TYPE (decl)))
2363 {
2364 warning (0, "incompatible implicit declaration of built-in"
2365 " function %qD", decl);
2366 newtype = TREE_TYPE (decl);
2367 }
2368 }
2369 else
2370 {
2371 if (!comptypes (newtype, TREE_TYPE (decl)))
2372 {
2373 error ("incompatible implicit declaration of function %qD",
2374 decl);
2375 locate_old_decl (decl, error);
2376 }
2377 }
2378 b->type = TREE_TYPE (decl);
2379 TREE_TYPE (decl) = newtype;
2380 bind (functionid, decl, current_scope,
2381 /*invisible=*/false, /*nested=*/true);
2382 return decl;
2383 }
2384 }
2385
2386 /* Not seen before. */
2387 decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
2388 DECL_EXTERNAL (decl) = 1;
2389 TREE_PUBLIC (decl) = 1;
2390 C_DECL_IMPLICIT (decl) = 1;
2391 implicit_decl_warning (functionid, 0);
2392 asmspec_tree = maybe_apply_renaming_pragma (decl, /*asmname=*/NULL);
2393 if (asmspec_tree)
2394 set_user_assembler_name (decl, TREE_STRING_POINTER (asmspec_tree));
2395
2396 /* C89 says implicit declarations are in the innermost block.
2397 So we record the decl in the standard fashion. */
2398 decl = pushdecl (decl);
2399
2400 /* No need to call objc_check_decl here - it's a function type. */
2401 rest_of_decl_compilation (decl, 0, 0);
2402
2403 /* Write a record describing this implicit function declaration
2404 to the prototypes file (if requested). */
2405 gen_aux_info_record (decl, 0, 1, 0);
2406
2407 /* Possibly apply some default attributes to this implicit declaration. */
2408 decl_attributes (&decl, NULL_TREE, 0);
2409
2410 return decl;
2411 }
2412
2413 /* Issue an error message for a reference to an undeclared variable
2414 ID, including a reference to a builtin outside of function-call
2415 context. Establish a binding of the identifier to error_mark_node
2416 in an appropriate scope, which will suppress further errors for the
2417 same identifier. The error message should be given location LOC. */
2418 void
undeclared_variable(tree id,location_t loc)2419 undeclared_variable (tree id, location_t loc)
2420 {
2421 struct c_scope *scope;
2422
2423 if (current_function_decl == 0)
2424 {
2425 error ("%H%qE undeclared here (not in a function)", &loc, id);
2426 scope = current_scope;
2427 }
2428 else
2429 {
2430 error ("%H%qE undeclared (first use in this function)", &loc, id);
2431
2432 /* If we are parsing old-style parameter decls, current_function_decl
2433 will be nonnull but current_function_scope will be null. */
2434 scope = current_function_scope ? current_function_scope : current_scope;
2435 }
2436 bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false);
2437 }
2438
2439 /* Subroutine of lookup_label, declare_label, define_label: construct a
2440 LABEL_DECL with all the proper frills. */
2441
2442 static tree
make_label(tree name,location_t location)2443 make_label (tree name, location_t location)
2444 {
2445 tree label = build_decl (LABEL_DECL, name, void_type_node);
2446
2447 DECL_CONTEXT (label) = current_function_decl;
2448 DECL_MODE (label) = VOIDmode;
2449 DECL_SOURCE_LOCATION (label) = location;
2450
2451 return label;
2452 }
2453
2454 /* Get the LABEL_DECL corresponding to identifier NAME as a label.
2455 Create one if none exists so far for the current function.
2456 This is called when a label is used in a goto expression or
2457 has its address taken. */
2458
2459 tree
lookup_label(tree name)2460 lookup_label (tree name)
2461 {
2462 tree label;
2463
2464 if (current_function_decl == 0)
2465 {
2466 error ("label %qE referenced outside of any function", name);
2467 return 0;
2468 }
2469
2470 /* Use a label already defined or ref'd with this name, but not if
2471 it is inherited from a containing function and wasn't declared
2472 using __label__. */
2473 label = I_LABEL_DECL (name);
2474 if (label && (DECL_CONTEXT (label) == current_function_decl
2475 || C_DECLARED_LABEL_FLAG (label)))
2476 {
2477 /* If the label has only been declared, update its apparent
2478 location to point here, for better diagnostics if it
2479 turns out not to have been defined. */
2480 if (!TREE_USED (label))
2481 DECL_SOURCE_LOCATION (label) = input_location;
2482 return label;
2483 }
2484
2485 /* No label binding for that identifier; make one. */
2486 label = make_label (name, input_location);
2487
2488 /* Ordinary labels go in the current function scope. */
2489 bind (name, label, current_function_scope,
2490 /*invisible=*/false, /*nested=*/false);
2491 return label;
2492 }
2493
2494 /* Make a label named NAME in the current function, shadowing silently
2495 any that may be inherited from containing functions or containing
2496 scopes. This is called for __label__ declarations. */
2497
2498 tree
declare_label(tree name)2499 declare_label (tree name)
2500 {
2501 struct c_binding *b = I_LABEL_BINDING (name);
2502 tree label;
2503
2504 /* Check to make sure that the label hasn't already been declared
2505 at this scope */
2506 if (b && B_IN_CURRENT_SCOPE (b))
2507 {
2508 error ("duplicate label declaration %qE", name);
2509 locate_old_decl (b->decl, error);
2510
2511 /* Just use the previous declaration. */
2512 return b->decl;
2513 }
2514
2515 label = make_label (name, input_location);
2516 C_DECLARED_LABEL_FLAG (label) = 1;
2517
2518 /* Declared labels go in the current scope. */
2519 bind (name, label, current_scope,
2520 /*invisible=*/false, /*nested=*/false);
2521 return label;
2522 }
2523
2524 /* Define a label, specifying the location in the source file.
2525 Return the LABEL_DECL node for the label, if the definition is valid.
2526 Otherwise return 0. */
2527
2528 tree
define_label(location_t location,tree name)2529 define_label (location_t location, tree name)
2530 {
2531 /* Find any preexisting label with this name. It is an error
2532 if that label has already been defined in this function, or
2533 if there is a containing function with a declared label with
2534 the same name. */
2535 tree label = I_LABEL_DECL (name);
2536 struct c_label_list *nlist_se, *nlist_vm;
2537
2538 if (label
2539 && ((DECL_CONTEXT (label) == current_function_decl
2540 && DECL_INITIAL (label) != 0)
2541 || (DECL_CONTEXT (label) != current_function_decl
2542 && C_DECLARED_LABEL_FLAG (label))))
2543 {
2544 error ("%Hduplicate label %qD", &location, label);
2545 locate_old_decl (label, error);
2546 return 0;
2547 }
2548 else if (label && DECL_CONTEXT (label) == current_function_decl)
2549 {
2550 /* The label has been used or declared already in this function,
2551 but not defined. Update its location to point to this
2552 definition. */
2553 if (C_DECL_UNDEFINABLE_STMT_EXPR (label))
2554 error ("%Jjump into statement expression", label);
2555 if (C_DECL_UNDEFINABLE_VM (label))
2556 error ("%Jjump into scope of identifier with variably modified type",
2557 label);
2558 DECL_SOURCE_LOCATION (label) = location;
2559 }
2560 else
2561 {
2562 /* No label binding for that identifier; make one. */
2563 label = make_label (name, location);
2564
2565 /* Ordinary labels go in the current function scope. */
2566 bind (name, label, current_function_scope,
2567 /*invisible=*/false, /*nested=*/false);
2568 }
2569
2570 if (!in_system_header && lookup_name (name))
2571 warning (OPT_Wtraditional, "%Htraditional C lacks a separate namespace "
2572 "for labels, identifier %qE conflicts", &location, name);
2573
2574 nlist_se = XOBNEW (&parser_obstack, struct c_label_list);
2575 nlist_se->next = label_context_stack_se->labels_def;
2576 nlist_se->label = label;
2577 label_context_stack_se->labels_def = nlist_se;
2578
2579 nlist_vm = XOBNEW (&parser_obstack, struct c_label_list);
2580 nlist_vm->next = label_context_stack_vm->labels_def;
2581 nlist_vm->label = label;
2582 label_context_stack_vm->labels_def = nlist_vm;
2583
2584 /* Mark label as having been defined. */
2585 DECL_INITIAL (label) = error_mark_node;
2586 return label;
2587 }
2588
2589 /* Given NAME, an IDENTIFIER_NODE,
2590 return the structure (or union or enum) definition for that name.
2591 If THISLEVEL_ONLY is nonzero, searches only the current_scope.
2592 CODE says which kind of type the caller wants;
2593 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2594 If the wrong kind of type is found, an error is reported. */
2595
2596 static tree
lookup_tag(enum tree_code code,tree name,int thislevel_only)2597 lookup_tag (enum tree_code code, tree name, int thislevel_only)
2598 {
2599 struct c_binding *b = I_TAG_BINDING (name);
2600 int thislevel = 0;
2601
2602 if (!b || !b->decl)
2603 return 0;
2604
2605 /* We only care about whether it's in this level if
2606 thislevel_only was set or it might be a type clash. */
2607 if (thislevel_only || TREE_CODE (b->decl) != code)
2608 {
2609 /* For our purposes, a tag in the external scope is the same as
2610 a tag in the file scope. (Primarily relevant to Objective-C
2611 and its builtin structure tags, which get pushed before the
2612 file scope is created.) */
2613 if (B_IN_CURRENT_SCOPE (b)
2614 || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
2615 thislevel = 1;
2616 }
2617
2618 if (thislevel_only && !thislevel)
2619 return 0;
2620
2621 if (TREE_CODE (b->decl) != code)
2622 {
2623 /* Definition isn't the kind we were looking for. */
2624 pending_invalid_xref = name;
2625 pending_invalid_xref_location = input_location;
2626
2627 /* If in the same binding level as a declaration as a tag
2628 of a different type, this must not be allowed to
2629 shadow that tag, so give the error immediately.
2630 (For example, "struct foo; union foo;" is invalid.) */
2631 if (thislevel)
2632 pending_xref_error ();
2633 }
2634 return b->decl;
2635 }
2636
2637 /* Print an error message now
2638 for a recent invalid struct, union or enum cross reference.
2639 We don't print them immediately because they are not invalid
2640 when used in the `struct foo;' construct for shadowing. */
2641
2642 void
pending_xref_error(void)2643 pending_xref_error (void)
2644 {
2645 if (pending_invalid_xref != 0)
2646 error ("%H%qE defined as wrong kind of tag",
2647 &pending_invalid_xref_location, pending_invalid_xref);
2648 pending_invalid_xref = 0;
2649 }
2650
2651
2652 /* Look up NAME in the current scope and its superiors
2653 in the namespace of variables, functions and typedefs.
2654 Return a ..._DECL node of some kind representing its definition,
2655 or return 0 if it is undefined. */
2656
2657 tree
lookup_name(tree name)2658 lookup_name (tree name)
2659 {
2660 struct c_binding *b = I_SYMBOL_BINDING (name);
2661 if (b && !b->invisible)
2662 return b->decl;
2663 return 0;
2664 }
2665
2666 /* Similar to `lookup_name' but look only at the indicated scope. */
2667
2668 static tree
lookup_name_in_scope(tree name,struct c_scope * scope)2669 lookup_name_in_scope (tree name, struct c_scope *scope)
2670 {
2671 struct c_binding *b;
2672
2673 for (b = I_SYMBOL_BINDING (name); b; b = b->shadowed)
2674 if (B_IN_SCOPE (b, scope))
2675 return b->decl;
2676 return 0;
2677 }
2678
2679 /* Create the predefined scalar types of C,
2680 and some nodes representing standard constants (0, 1, (void *) 0).
2681 Initialize the global scope.
2682 Make definitions for built-in primitive functions. */
2683
2684 void
c_init_decl_processing(void)2685 c_init_decl_processing (void)
2686 {
2687 location_t save_loc = input_location;
2688
2689 /* Initialize reserved words for parser. */
2690 c_parse_init ();
2691
2692 current_function_decl = 0;
2693
2694 gcc_obstack_init (&parser_obstack);
2695
2696 /* Make the externals scope. */
2697 push_scope ();
2698 external_scope = current_scope;
2699
2700 /* Declarations from c_common_nodes_and_builtins must not be associated
2701 with this input file, lest we get differences between using and not
2702 using preprocessed headers. */
2703 #ifdef USE_MAPPED_LOCATION
2704 input_location = BUILTINS_LOCATION;
2705 #else
2706 input_location.file = "<built-in>";
2707 input_location.line = 0;
2708 #endif
2709
2710 build_common_tree_nodes (flag_signed_char, false);
2711
2712 c_common_nodes_and_builtins ();
2713
2714 /* In C, comparisons and TRUTH_* expressions have type int. */
2715 truthvalue_type_node = integer_type_node;
2716 truthvalue_true_node = integer_one_node;
2717 truthvalue_false_node = integer_zero_node;
2718
2719 /* Even in C99, which has a real boolean type. */
2720 pushdecl (build_decl (TYPE_DECL, get_identifier ("_Bool"),
2721 boolean_type_node));
2722
2723 input_location = save_loc;
2724
2725 pedantic_lvalues = pedantic;
2726
2727 make_fname_decl = c_make_fname_decl;
2728 start_fname_decls ();
2729 }
2730
2731 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
2732 decl, NAME is the initialization string and TYPE_DEP indicates whether
2733 NAME depended on the type of the function. As we don't yet implement
2734 delayed emission of static data, we mark the decl as emitted
2735 so it is not placed in the output. Anything using it must therefore pull
2736 out the STRING_CST initializer directly. FIXME. */
2737
2738 static tree
c_make_fname_decl(tree id,int type_dep)2739 c_make_fname_decl (tree id, int type_dep)
2740 {
2741 const char *name = fname_as_string (type_dep);
2742 tree decl, type, init;
2743 size_t length = strlen (name);
2744
2745 type = build_array_type (char_type_node,
2746 build_index_type (size_int (length)));
2747 type = c_build_qualified_type (type, TYPE_QUAL_CONST);
2748
2749 decl = build_decl (VAR_DECL, id, type);
2750
2751 TREE_STATIC (decl) = 1;
2752 TREE_READONLY (decl) = 1;
2753 DECL_ARTIFICIAL (decl) = 1;
2754
2755 init = build_string (length + 1, name);
2756 free ((char *) name);
2757 TREE_TYPE (init) = type;
2758 DECL_INITIAL (decl) = init;
2759
2760 TREE_USED (decl) = 1;
2761
2762 if (current_function_decl)
2763 {
2764 DECL_CONTEXT (decl) = current_function_decl;
2765 bind (id, decl, current_function_scope,
2766 /*invisible=*/false, /*nested=*/false);
2767 }
2768
2769 finish_decl (decl, init, NULL_TREE);
2770
2771 return decl;
2772 }
2773
2774 /* Return a definition for a builtin function named NAME and whose data type
2775 is TYPE. TYPE should be a function type with argument types.
2776 FUNCTION_CODE tells later passes how to compile calls to this function.
2777 See tree.h for its possible values.
2778
2779 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
2780 the name to be called if we can't opencode the function. If
2781 ATTRS is nonzero, use that for the function's attribute list. */
2782
2783 tree
builtin_function(const char * name,tree type,int function_code,enum built_in_class cl,const char * library_name,tree attrs)2784 builtin_function (const char *name, tree type, int function_code,
2785 enum built_in_class cl, const char *library_name,
2786 tree attrs)
2787 {
2788 tree id = get_identifier (name);
2789 tree decl = build_decl (FUNCTION_DECL, id, type);
2790 TREE_PUBLIC (decl) = 1;
2791 DECL_EXTERNAL (decl) = 1;
2792 DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
2793 DECL_BUILT_IN_CLASS (decl) = cl;
2794 DECL_FUNCTION_CODE (decl) = function_code;
2795 C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0);
2796 if (library_name)
2797 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
2798
2799 /* Should never be called on a symbol with a preexisting meaning. */
2800 gcc_assert (!I_SYMBOL_BINDING (id));
2801
2802 bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false);
2803
2804 /* Builtins in the implementation namespace are made visible without
2805 needing to be explicitly declared. See push_file_scope. */
2806 if (name[0] == '_' && (name[1] == '_' || ISUPPER (name[1])))
2807 {
2808 TREE_CHAIN (decl) = visible_builtins;
2809 visible_builtins = decl;
2810 }
2811
2812 /* Possibly apply some default attributes to this built-in function. */
2813 if (attrs)
2814 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
2815 else
2816 decl_attributes (&decl, NULL_TREE, 0);
2817
2818 return decl;
2819 }
2820
2821 /* Apply default attributes to a function, if a system function with default
2822 attributes. */
2823
2824 void
c_insert_default_attributes(tree decl)2825 c_insert_default_attributes (tree decl)
2826 {
2827 if (!TREE_PUBLIC (decl))
2828 return;
2829 c_common_insert_default_attributes (decl);
2830 }
2831
2832 /* Called when a declaration is seen that contains no names to declare.
2833 If its type is a reference to a structure, union or enum inherited
2834 from a containing scope, shadow that tag name for the current scope
2835 with a forward reference.
2836 If its type defines a new named structure or union
2837 or defines an enum, it is valid but we need not do anything here.
2838 Otherwise, it is an error. */
2839
2840 void
shadow_tag(const struct c_declspecs * declspecs)2841 shadow_tag (const struct c_declspecs *declspecs)
2842 {
2843 shadow_tag_warned (declspecs, 0);
2844 }
2845
2846 /* WARNED is 1 if we have done a pedwarn, 2 if we have done a warning,
2847 but no pedwarn. */
2848 void
shadow_tag_warned(const struct c_declspecs * declspecs,int warned)2849 shadow_tag_warned (const struct c_declspecs *declspecs, int warned)
2850 {
2851 bool found_tag = false;
2852
2853 if (declspecs->type && !declspecs->default_int_p && !declspecs->typedef_p)
2854 {
2855 tree value = declspecs->type;
2856 enum tree_code code = TREE_CODE (value);
2857
2858 if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
2859 /* Used to test also that TYPE_SIZE (value) != 0.
2860 That caused warning for `struct foo;' at top level in the file. */
2861 {
2862 tree name = TYPE_NAME (value);
2863 tree t;
2864
2865 found_tag = true;
2866
2867 if (name == 0)
2868 {
2869 if (warned != 1 && code != ENUMERAL_TYPE)
2870 /* Empty unnamed enum OK */
2871 {
2872 pedwarn ("unnamed struct/union that defines no instances");
2873 warned = 1;
2874 }
2875 }
2876 else if (!declspecs->tag_defined_p
2877 && declspecs->storage_class != csc_none)
2878 {
2879 if (warned != 1)
2880 pedwarn ("empty declaration with storage class specifier "
2881 "does not redeclare tag");
2882 warned = 1;
2883 pending_xref_error ();
2884 }
2885 else if (!declspecs->tag_defined_p
2886 && (declspecs->const_p
2887 || declspecs->volatile_p
2888 || declspecs->restrict_p))
2889 {
2890 if (warned != 1)
2891 pedwarn ("empty declaration with type qualifier "
2892 "does not redeclare tag");
2893 warned = 1;
2894 pending_xref_error ();
2895 }
2896 else
2897 {
2898 pending_invalid_xref = 0;
2899 t = lookup_tag (code, name, 1);
2900
2901 if (t == 0)
2902 {
2903 t = make_node (code);
2904 pushtag (name, t);
2905 }
2906 }
2907 }
2908 else
2909 {
2910 if (warned != 1 && !in_system_header)
2911 {
2912 pedwarn ("useless type name in empty declaration");
2913 warned = 1;
2914 }
2915 }
2916 }
2917 else if (warned != 1 && !in_system_header && declspecs->typedef_p)
2918 {
2919 pedwarn ("useless type name in empty declaration");
2920 warned = 1;
2921 }
2922
2923 pending_invalid_xref = 0;
2924
2925 if (declspecs->inline_p)
2926 {
2927 error ("%<inline%> in empty declaration");
2928 warned = 1;
2929 }
2930
2931 if (current_scope == file_scope && declspecs->storage_class == csc_auto)
2932 {
2933 error ("%<auto%> in file-scope empty declaration");
2934 warned = 1;
2935 }
2936
2937 if (current_scope == file_scope && declspecs->storage_class == csc_register)
2938 {
2939 error ("%<register%> in file-scope empty declaration");
2940 warned = 1;
2941 }
2942
2943 if (!warned && !in_system_header && declspecs->storage_class != csc_none)
2944 {
2945 warning (0, "useless storage class specifier in empty declaration");
2946 warned = 2;
2947 }
2948
2949 if (!warned && !in_system_header && declspecs->thread_p)
2950 {
2951 warning (0, "useless %<__thread%> in empty declaration");
2952 warned = 2;
2953 }
2954
2955 if (!warned && !in_system_header && (declspecs->const_p
2956 || declspecs->volatile_p
2957 || declspecs->restrict_p))
2958 {
2959 warning (0, "useless type qualifier in empty declaration");
2960 warned = 2;
2961 }
2962
2963 if (warned != 1)
2964 {
2965 if (!found_tag)
2966 pedwarn ("empty declaration");
2967 }
2968 }
2969
2970
2971 /* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
2972 bits. SPECS represents declaration specifiers that the grammar
2973 only permits to contain type qualifiers and attributes. */
2974
2975 int
quals_from_declspecs(const struct c_declspecs * specs)2976 quals_from_declspecs (const struct c_declspecs *specs)
2977 {
2978 int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
2979 | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
2980 | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0));
2981 gcc_assert (!specs->type
2982 && !specs->decl_attr
2983 && specs->typespec_word == cts_none
2984 && specs->storage_class == csc_none
2985 && !specs->typedef_p
2986 && !specs->explicit_signed_p
2987 && !specs->deprecated_p
2988 && !specs->long_p
2989 && !specs->long_long_p
2990 && !specs->short_p
2991 && !specs->signed_p
2992 && !specs->unsigned_p
2993 && !specs->complex_p
2994 && !specs->inline_p
2995 && !specs->thread_p);
2996 return quals;
2997 }
2998
2999 /* Construct an array declarator. EXPR is the expression inside [], or
3000 NULL_TREE. QUALS are the type qualifiers inside the [] (to be applied
3001 to the pointer to which a parameter array is converted). STATIC_P is
3002 true if "static" is inside the [], false otherwise. VLA_UNSPEC_P
3003 is true if the array is [*], a VLA of unspecified length which is
3004 nevertheless a complete type (not currently implemented by GCC),
3005 false otherwise. The field for the contained declarator is left to be
3006 filled in by set_array_declarator_inner. */
3007
3008 struct c_declarator *
build_array_declarator(tree expr,struct c_declspecs * quals,bool static_p,bool vla_unspec_p)3009 build_array_declarator (tree expr, struct c_declspecs *quals, bool static_p,
3010 bool vla_unspec_p)
3011 {
3012 struct c_declarator *declarator = XOBNEW (&parser_obstack,
3013 struct c_declarator);
3014 declarator->kind = cdk_array;
3015 declarator->declarator = 0;
3016 declarator->u.array.dimen = expr;
3017 if (quals)
3018 {
3019 declarator->u.array.attrs = quals->attrs;
3020 declarator->u.array.quals = quals_from_declspecs (quals);
3021 }
3022 else
3023 {
3024 declarator->u.array.attrs = NULL_TREE;
3025 declarator->u.array.quals = 0;
3026 }
3027 declarator->u.array.static_p = static_p;
3028 declarator->u.array.vla_unspec_p = vla_unspec_p;
3029 if (pedantic && !flag_isoc99)
3030 {
3031 if (static_p || quals != NULL)
3032 pedwarn ("ISO C90 does not support %<static%> or type "
3033 "qualifiers in parameter array declarators");
3034 if (vla_unspec_p)
3035 pedwarn ("ISO C90 does not support %<[*]%> array declarators");
3036 }
3037 if (vla_unspec_p)
3038 warning (0, "GCC does not yet properly implement %<[*]%> array declarators");
3039 return declarator;
3040 }
3041
3042 /* Set the contained declarator of an array declarator. DECL is the
3043 declarator, as constructed by build_array_declarator; INNER is what
3044 appears on the left of the []. ABSTRACT_P is true if it is an
3045 abstract declarator, false otherwise; this is used to reject static
3046 and type qualifiers in abstract declarators, where they are not in
3047 the C99 grammar (subject to possible change in DR#289). */
3048
3049 struct c_declarator *
set_array_declarator_inner(struct c_declarator * decl,struct c_declarator * inner,bool abstract_p)3050 set_array_declarator_inner (struct c_declarator *decl,
3051 struct c_declarator *inner, bool abstract_p)
3052 {
3053 decl->declarator = inner;
3054 if (abstract_p && (decl->u.array.quals != TYPE_UNQUALIFIED
3055 || decl->u.array.attrs != NULL_TREE
3056 || decl->u.array.static_p))
3057 error ("static or type qualifiers in abstract declarator");
3058 return decl;
3059 }
3060
3061 /* INIT is a constructor that forms DECL's initializer. If the final
3062 element initializes a flexible array field, add the size of that
3063 initializer to DECL's size. */
3064
3065 static void
add_flexible_array_elts_to_size(tree decl,tree init)3066 add_flexible_array_elts_to_size (tree decl, tree init)
3067 {
3068 unsigned int size;
3069 tree elt, type;
3070
3071 size = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
3072 if (size == 0)
3073 return;
3074
3075 elt = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), size - 1)->value;
3076 type = TREE_TYPE (elt);
3077 if (TREE_CODE (type) == ARRAY_TYPE
3078 && TYPE_SIZE (type) == NULL_TREE
3079 && TYPE_DOMAIN (type) != NULL_TREE
3080 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE)
3081 {
3082 complete_array_type (&type, elt, false);
3083 DECL_SIZE (decl)
3084 = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
3085 DECL_SIZE_UNIT (decl)
3086 = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
3087 }
3088 }
3089
3090 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3091
3092 tree
groktypename(struct c_type_name * type_name)3093 groktypename (struct c_type_name *type_name)
3094 {
3095 tree type;
3096 tree attrs = type_name->specs->attrs;
3097
3098 type_name->specs->attrs = NULL_TREE;
3099
3100 type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
3101 false, NULL);
3102
3103 /* Apply attributes. */
3104 decl_attributes (&type, attrs, 0);
3105
3106 return type;
3107 }
3108
3109 /* Decode a declarator in an ordinary declaration or data definition.
3110 This is called as soon as the type information and variable name
3111 have been parsed, before parsing the initializer if any.
3112 Here we create the ..._DECL node, fill in its type,
3113 and put it on the list of decls for the current context.
3114 The ..._DECL node is returned as the value.
3115
3116 Exception: for arrays where the length is not specified,
3117 the type is left null, to be filled in by `finish_decl'.
3118
3119 Function definitions do not come here; they go to start_function
3120 instead. However, external and forward declarations of functions
3121 do go through here. Structure field declarations are done by
3122 grokfield and not through here. */
3123
3124 tree
start_decl(struct c_declarator * declarator,struct c_declspecs * declspecs,bool initialized,tree attributes)3125 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
3126 bool initialized, tree attributes)
3127 {
3128 tree decl;
3129 tree tem;
3130
3131 /* An object declared as __attribute__((deprecated)) suppresses
3132 warnings of uses of other deprecated items. */
3133 if (lookup_attribute ("deprecated", attributes))
3134 deprecated_state = DEPRECATED_SUPPRESS;
3135
3136 decl = grokdeclarator (declarator, declspecs,
3137 NORMAL, initialized, NULL);
3138 if (!decl)
3139 return 0;
3140
3141 deprecated_state = DEPRECATED_NORMAL;
3142
3143 if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
3144 && MAIN_NAME_P (DECL_NAME (decl)))
3145 warning (OPT_Wmain, "%q+D is usually a function", decl);
3146
3147 if (initialized)
3148 /* Is it valid for this decl to have an initializer at all?
3149 If not, set INITIALIZED to zero, which will indirectly
3150 tell 'finish_decl' to ignore the initializer once it is parsed. */
3151 switch (TREE_CODE (decl))
3152 {
3153 case TYPE_DECL:
3154 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3155 initialized = 0;
3156 break;
3157
3158 case FUNCTION_DECL:
3159 error ("function %qD is initialized like a variable", decl);
3160 initialized = 0;
3161 break;
3162
3163 case PARM_DECL:
3164 /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
3165 error ("parameter %qD is initialized", decl);
3166 initialized = 0;
3167 break;
3168
3169 default:
3170 /* Don't allow initializations for incomplete types except for
3171 arrays which might be completed by the initialization. */
3172
3173 /* This can happen if the array size is an undefined macro.
3174 We already gave a warning, so we don't need another one. */
3175 if (TREE_TYPE (decl) == error_mark_node)
3176 initialized = 0;
3177 else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
3178 {
3179 /* A complete type is ok if size is fixed. */
3180
3181 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
3182 || C_DECL_VARIABLE_SIZE (decl))
3183 {
3184 error ("variable-sized object may not be initialized");
3185 initialized = 0;
3186 }
3187 }
3188 else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
3189 {
3190 error ("variable %qD has initializer but incomplete type", decl);
3191 initialized = 0;
3192 }
3193 else if (C_DECL_VARIABLE_SIZE (decl))
3194 {
3195 /* Although C99 is unclear about whether incomplete arrays
3196 of VLAs themselves count as VLAs, it does not make
3197 sense to permit them to be initialized given that
3198 ordinary VLAs may not be initialized. */
3199 error ("variable-sized object may not be initialized");
3200 initialized = 0;
3201 }
3202 }
3203
3204 if (initialized)
3205 {
3206 if (current_scope == file_scope)
3207 TREE_STATIC (decl) = 1;
3208
3209 /* Tell 'pushdecl' this is an initialized decl
3210 even though we don't yet have the initializer expression.
3211 Also tell 'finish_decl' it may store the real initializer. */
3212 DECL_INITIAL (decl) = error_mark_node;
3213 }
3214
3215 /* If this is a function declaration, write a record describing it to the
3216 prototypes file (if requested). */
3217
3218 if (TREE_CODE (decl) == FUNCTION_DECL)
3219 gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
3220
3221 /* ANSI specifies that a tentative definition which is not merged with
3222 a non-tentative definition behaves exactly like a definition with an
3223 initializer equal to zero. (Section 3.7.2)
3224
3225 -fno-common gives strict ANSI behavior, though this tends to break
3226 a large body of code that grew up without this rule.
3227
3228 Thread-local variables are never common, since there's no entrenched
3229 body of code to break, and it allows more efficient variable references
3230 in the presence of dynamic linking. */
3231
3232 if (TREE_CODE (decl) == VAR_DECL
3233 && !initialized
3234 && TREE_PUBLIC (decl)
3235 && !DECL_THREAD_LOCAL_P (decl)
3236 && !flag_no_common)
3237 DECL_COMMON (decl) = 1;
3238
3239 /* Set attributes here so if duplicate decl, will have proper attributes. */
3240 decl_attributes (&decl, attributes, 0);
3241
3242 if (TREE_CODE (decl) == FUNCTION_DECL
3243 && targetm.calls.promote_prototypes (TREE_TYPE (decl)))
3244 {
3245 struct c_declarator *ce = declarator;
3246
3247 if (ce->kind == cdk_pointer)
3248 ce = declarator->declarator;
3249 if (ce->kind == cdk_function)
3250 {
3251 tree args = ce->u.arg_info->parms;
3252 for (; args; args = TREE_CHAIN (args))
3253 {
3254 tree type = TREE_TYPE (args);
3255 if (type && INTEGRAL_TYPE_P (type)
3256 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
3257 DECL_ARG_TYPE (args) = integer_type_node;
3258 }
3259 }
3260 }
3261
3262 if (TREE_CODE (decl) == FUNCTION_DECL
3263 && DECL_DECLARED_INLINE_P (decl)
3264 && DECL_UNINLINABLE (decl)
3265 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3266 warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
3267 decl);
3268
3269 /* Add this decl to the current scope.
3270 TEM may equal DECL or it may be a previous decl of the same name. */
3271 tem = pushdecl (decl);
3272
3273 if (initialized && DECL_EXTERNAL (tem))
3274 {
3275 DECL_EXTERNAL (tem) = 0;
3276 TREE_STATIC (tem) = 1;
3277 }
3278
3279 return tem;
3280 }
3281
3282 /* Finish processing of a declaration;
3283 install its initial value.
3284 If the length of an array type is not known before,
3285 it must be determined now, from the initial value, or it is an error. */
3286
3287 void
finish_decl(tree decl,tree init,tree asmspec_tree)3288 finish_decl (tree decl, tree init, tree asmspec_tree)
3289 {
3290 tree type = TREE_TYPE (decl);
3291 int was_incomplete = (DECL_SIZE (decl) == 0);
3292 const char *asmspec = 0;
3293
3294 /* If a name was specified, get the string. */
3295 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
3296 && DECL_FILE_SCOPE_P (decl))
3297 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
3298 if (asmspec_tree)
3299 asmspec = TREE_STRING_POINTER (asmspec_tree);
3300
3301 /* If `start_decl' didn't like having an initialization, ignore it now. */
3302 if (init != 0 && DECL_INITIAL (decl) == 0)
3303 init = 0;
3304
3305 /* Don't crash if parm is initialized. */
3306 if (TREE_CODE (decl) == PARM_DECL)
3307 init = 0;
3308
3309 if (init)
3310 store_init_value (decl, init);
3311
3312 if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
3313 || TREE_CODE (decl) == FUNCTION_DECL
3314 || TREE_CODE (decl) == FIELD_DECL))
3315 objc_check_decl (decl);
3316
3317 /* Deduce size of array from initialization, if not already known. */
3318 if (TREE_CODE (type) == ARRAY_TYPE
3319 && TYPE_DOMAIN (type) == 0
3320 && TREE_CODE (decl) != TYPE_DECL)
3321 {
3322 bool do_default
3323 = (TREE_STATIC (decl)
3324 /* Even if pedantic, an external linkage array
3325 may have incomplete type at first. */
3326 ? pedantic && !TREE_PUBLIC (decl)
3327 : !DECL_EXTERNAL (decl));
3328 int failure
3329 = complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
3330 do_default);
3331
3332 /* Get the completed type made by complete_array_type. */
3333 type = TREE_TYPE (decl);
3334
3335 switch (failure)
3336 {
3337 case 1:
3338 error ("initializer fails to determine size of %q+D", decl);
3339 break;
3340
3341 case 2:
3342 if (do_default)
3343 error ("array size missing in %q+D", decl);
3344 /* If a `static' var's size isn't known,
3345 make it extern as well as static, so it does not get
3346 allocated.
3347 If it is not `static', then do not mark extern;
3348 finish_incomplete_decl will give it a default size
3349 and it will get allocated. */
3350 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
3351 DECL_EXTERNAL (decl) = 1;
3352 break;
3353
3354 case 3:
3355 error ("zero or negative size array %q+D", decl);
3356 break;
3357
3358 case 0:
3359 /* For global variables, update the copy of the type that
3360 exists in the binding. */
3361 if (TREE_PUBLIC (decl))
3362 {
3363 struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
3364 while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
3365 b_ext = b_ext->shadowed;
3366 if (b_ext)
3367 {
3368 if (b_ext->type)
3369 b_ext->type = composite_type (b_ext->type, type);
3370 else
3371 b_ext->type = type;
3372 }
3373 }
3374 break;
3375
3376 default:
3377 gcc_unreachable ();
3378 }
3379
3380 if (DECL_INITIAL (decl))
3381 TREE_TYPE (DECL_INITIAL (decl)) = type;
3382
3383 layout_decl (decl, 0);
3384 }
3385
3386 if (TREE_CODE (decl) == VAR_DECL)
3387 {
3388 if (init && TREE_CODE (init) == CONSTRUCTOR)
3389 add_flexible_array_elts_to_size (decl, init);
3390
3391 if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
3392 && COMPLETE_TYPE_P (TREE_TYPE (decl)))
3393 layout_decl (decl, 0);
3394
3395 if (DECL_SIZE (decl) == 0
3396 /* Don't give an error if we already gave one earlier. */
3397 && TREE_TYPE (decl) != error_mark_node
3398 && (TREE_STATIC (decl)
3399 /* A static variable with an incomplete type
3400 is an error if it is initialized.
3401 Also if it is not file scope.
3402 Otherwise, let it through, but if it is not `extern'
3403 then it may cause an error message later. */
3404 ? (DECL_INITIAL (decl) != 0
3405 || !DECL_FILE_SCOPE_P (decl))
3406 /* An automatic variable with an incomplete type
3407 is an error. */
3408 : !DECL_EXTERNAL (decl)))
3409 {
3410 error ("storage size of %q+D isn%'t known", decl);
3411 TREE_TYPE (decl) = error_mark_node;
3412 }
3413
3414 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3415 && DECL_SIZE (decl) != 0)
3416 {
3417 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3418 constant_expression_warning (DECL_SIZE (decl));
3419 else
3420 error ("storage size of %q+D isn%'t constant", decl);
3421 }
3422
3423 if (TREE_USED (type))
3424 TREE_USED (decl) = 1;
3425 }
3426
3427 /* If this is a function and an assembler name is specified, reset DECL_RTL
3428 so we can give it its new name. Also, update built_in_decls if it
3429 was a normal built-in. */
3430 if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
3431 {
3432 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
3433 set_builtin_user_assembler_name (decl, asmspec);
3434 set_user_assembler_name (decl, asmspec);
3435 }
3436
3437 /* If #pragma weak was used, mark the decl weak now. */
3438 maybe_apply_pragma_weak (decl);
3439
3440 /* If this is a variable definition, determine its ELF visibility. */
3441 if (TREE_CODE (decl) == VAR_DECL
3442 && TREE_STATIC (decl)
3443 && !DECL_EXTERNAL (decl))
3444 c_determine_visibility (decl);
3445
3446 /* Output the assembler code and/or RTL code for variables and functions,
3447 unless the type is an undefined structure or union.
3448 If not, it will get done when the type is completed. */
3449
3450 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3451 {
3452 /* This is a no-op in c-lang.c or something real in objc-act.c. */
3453 if (c_dialect_objc ())
3454 objc_check_decl (decl);
3455
3456 if (asmspec)
3457 {
3458 /* If this is not a static variable, issue a warning.
3459 It doesn't make any sense to give an ASMSPEC for an
3460 ordinary, non-register local variable. Historically,
3461 GCC has accepted -- but ignored -- the ASMSPEC in
3462 this case. */
3463 if (!DECL_FILE_SCOPE_P (decl)
3464 && TREE_CODE (decl) == VAR_DECL
3465 && !C_DECL_REGISTER (decl)
3466 && !TREE_STATIC (decl))
3467 warning (0, "ignoring asm-specifier for non-static local "
3468 "variable %q+D", decl);
3469 else
3470 set_user_assembler_name (decl, asmspec);
3471 }
3472
3473 if (DECL_FILE_SCOPE_P (decl))
3474 {
3475 if (DECL_INITIAL (decl) == NULL_TREE
3476 || DECL_INITIAL (decl) == error_mark_node)
3477 /* Don't output anything
3478 when a tentative file-scope definition is seen.
3479 But at end of compilation, do output code for them. */
3480 DECL_DEFER_OUTPUT (decl) = 1;
3481 rest_of_decl_compilation (decl, true, 0);
3482 }
3483 else
3484 {
3485 /* In conjunction with an ASMSPEC, the `register'
3486 keyword indicates that we should place the variable
3487 in a particular register. */
3488 if (asmspec && C_DECL_REGISTER (decl))
3489 {
3490 DECL_HARD_REGISTER (decl) = 1;
3491 /* This cannot be done for a structure with volatile
3492 fields, on which DECL_REGISTER will have been
3493 reset. */
3494 if (!DECL_REGISTER (decl))
3495 error ("cannot put object with volatile field into register");
3496 }
3497
3498 if (TREE_CODE (decl) != FUNCTION_DECL)
3499 {
3500 /* If we're building a variable sized type, and we might be
3501 reachable other than via the top of the current binding
3502 level, then create a new BIND_EXPR so that we deallocate
3503 the object at the right time. */
3504 /* Note that DECL_SIZE can be null due to errors. */
3505 if (DECL_SIZE (decl)
3506 && !TREE_CONSTANT (DECL_SIZE (decl))
3507 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
3508 {
3509 tree bind;
3510 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
3511 TREE_SIDE_EFFECTS (bind) = 1;
3512 add_stmt (bind);
3513 BIND_EXPR_BODY (bind) = push_stmt_list ();
3514 }
3515 add_stmt (build_stmt (DECL_EXPR, decl));
3516 }
3517 }
3518
3519
3520 if (!DECL_FILE_SCOPE_P (decl))
3521 {
3522 /* Recompute the RTL of a local array now
3523 if it used to be an incomplete type. */
3524 if (was_incomplete
3525 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
3526 {
3527 /* If we used it already as memory, it must stay in memory. */
3528 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
3529 /* If it's still incomplete now, no init will save it. */
3530 if (DECL_SIZE (decl) == 0)
3531 DECL_INITIAL (decl) = 0;
3532 }
3533 }
3534 }
3535
3536 /* If this was marked 'used', be sure it will be output. */
3537 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
3538 mark_decl_referenced (decl);
3539
3540 if (TREE_CODE (decl) == TYPE_DECL)
3541 {
3542 if (!DECL_FILE_SCOPE_P (decl)
3543 && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
3544 add_stmt (build_stmt (DECL_EXPR, decl));
3545
3546 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
3547 }
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_scope == file_scope)
3553 get_pending_sizes ();
3554
3555 /* Install a cleanup (aka destructor) if one was given. */
3556 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
3557 {
3558 tree attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
3559 if (attr)
3560 {
3561 tree cleanup_id = TREE_VALUE (TREE_VALUE (attr));
3562 tree cleanup_decl = lookup_name (cleanup_id);
3563 tree cleanup;
3564
3565 /* Build "cleanup(&decl)" for the destructor. */
3566 cleanup = build_unary_op (ADDR_EXPR, decl, 0);
3567 cleanup = build_tree_list (NULL_TREE, cleanup);
3568 cleanup = build_function_call (cleanup_decl, cleanup);
3569
3570 /* Don't warn about decl unused; the cleanup uses it. */
3571 TREE_USED (decl) = 1;
3572 TREE_USED (cleanup_decl) = 1;
3573
3574 /* Initialize EH, if we've been told to do so. */
3575 if (flag_exceptions && !c_eh_initialized_p)
3576 {
3577 c_eh_initialized_p = true;
3578 eh_personality_libfunc
3579 = init_one_libfunc (USING_SJLJ_EXCEPTIONS
3580 ? "__gcc_personality_sj0"
3581 : "__gcc_personality_v0");
3582 default_init_unwind_resume_libfunc ();
3583 using_eh_for_cleanups ();
3584 }
3585
3586 push_cleanup (decl, cleanup, false);
3587 }
3588 }
3589 }
3590
3591 /* Given a parsed parameter declaration, decode it into a PARM_DECL. */
3592
3593 tree
grokparm(const struct c_parm * parm)3594 grokparm (const struct c_parm *parm)
3595 {
3596 tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
3597 NULL);
3598
3599 decl_attributes (&decl, parm->attrs, 0);
3600
3601 return decl;
3602 }
3603
3604 /* Given a parsed parameter declaration, decode it into a PARM_DECL
3605 and push that on the current scope. */
3606
3607 void
push_parm_decl(const struct c_parm * parm)3608 push_parm_decl (const struct c_parm *parm)
3609 {
3610 tree decl;
3611 /* begin-TIGCC-local (regparms): explicit register specification for parameters */
3612 tree asmspec;
3613
3614 asmspec = parm->asmspec;
3615 /* end-TIGCC-local (regparms) */
3616 decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL);
3617 decl_attributes (&decl, parm->attrs, 0);
3618
3619 /* begin-TIGCC-local (regparms): explicit register specification for parameters */
3620 if (asmspec)
3621 #ifdef EXPLICIT_REGPARM
3622 {
3623 const char *regname=TREE_STRING_POINTER(asmspec);
3624 int regnum;
3625 if ((regnum=decode_reg_name(regname))>=0)
3626 {
3627 tree type=TREE_TYPE(decl);
3628 if (HARD_REGNO_MODE_OK(regnum, TYPE_MODE(type)))
3629 {
3630 tree t, attrs;
3631 /* push_obstacks_nochange();
3632 end_temporary_allocation(); */
3633 /* Build tree for __attribute__ ((asm(regnum))). */
3634 #if 0
3635 /* This doesn't work well because of a bug in
3636 attribute_list_contained(), which passes list of arguments to
3637 simple_cst_equal() instead of passing every argument
3638 separately. */
3639 attrs=tree_cons(get_identifier("asm"), tree_cons(NULL_TREE,
3640 build_int_cstu(NULL_TREE, regnum), NULL_TREE), NULL_TREE);
3641 #else
3642 attrs=tree_cons(get_identifier("asm"),
3643 build_int_cstu(NULL_TREE, regnum), NULL_TREE);
3644 #endif
3645 #if 0
3646 /* build_type_attribute_variant() would seem to be more
3647 appropriate here. However, that function does not support
3648 attributes for parameters properly. It modifies
3649 TYPE_MAIN_VARIANT of a new type. As a result, comptypes()
3650 thinks that types of parameters in prototype and definition
3651 are different and issues error messages. See also comment
3652 below. */
3653 type=build_type_attribute_variant(type, attrs);
3654 #else
3655 /* First check whether such a type already exists - if yes, use
3656 that one. This is very important, since otherwise
3657 common_type() would think that it sees two different
3658 types and would try to merge them - this could result in
3659 warning messages. */
3660 for (t=TYPE_MAIN_VARIANT(type); t; t=TYPE_NEXT_VARIANT(t))
3661 if (comptypes(t, type)==1
3662 && attribute_list_equal(TYPE_ATTRIBUTES(t), attrs))
3663 break;
3664 if (t)
3665 type=t;
3666 else
3667 {
3668 /* Create a new variant, with differing attributes.
3669 (Hack! Type with differing attributes should no longer be
3670 a variant of its main type. See comment above for
3671 explanation why this was necessary). */
3672 type=build_variant_type_copy(type);
3673 TYPE_ATTRIBUTES(type)=attrs;
3674 }
3675 #endif
3676 TREE_TYPE(decl)=type;
3677 /* pop_obstacks(); */
3678 }
3679 else
3680 error("%Jregister number for `%s' isn't suitable for the data type",
3681 decl);
3682 }
3683 else
3684 error("invalid register name `%s'", regname);
3685 }
3686 #else /* !EXPLICIT_REGPARM */
3687 error("explicit register specification for parameters is not supported for this target");
3688 #endif
3689 /* end-TIGCC-local (regparms) */
3690
3691 decl = pushdecl (decl);
3692
3693 finish_decl (decl, NULL_TREE, NULL_TREE);
3694 }
3695
3696 /* Mark all the parameter declarations to date as forward decls.
3697 Also diagnose use of this extension. */
3698
3699 void
mark_forward_parm_decls(void)3700 mark_forward_parm_decls (void)
3701 {
3702 struct c_binding *b;
3703
3704 if (pedantic && !current_scope->warned_forward_parm_decls)
3705 {
3706 pedwarn ("ISO C forbids forward parameter declarations");
3707 current_scope->warned_forward_parm_decls = true;
3708 }
3709
3710 for (b = current_scope->bindings; b; b = b->prev)
3711 if (TREE_CODE (b->decl) == PARM_DECL)
3712 TREE_ASM_WRITTEN (b->decl) = 1;
3713 }
3714
3715 /* Build a COMPOUND_LITERAL_EXPR. TYPE is the type given in the compound
3716 literal, which may be an incomplete array type completed by the
3717 initializer; INIT is a CONSTRUCTOR that initializes the compound
3718 literal. */
3719
3720 tree
build_compound_literal(tree type,tree init)3721 build_compound_literal (tree type, tree init)
3722 {
3723 /* We do not use start_decl here because we have a type, not a declarator;
3724 and do not use finish_decl because the decl should be stored inside
3725 the COMPOUND_LITERAL_EXPR rather than added elsewhere as a DECL_EXPR. */
3726 tree decl;
3727 tree complit;
3728 tree stmt;
3729
3730 if (type == error_mark_node)
3731 return error_mark_node;
3732
3733 decl = build_decl (VAR_DECL, NULL_TREE, type);
3734 DECL_EXTERNAL (decl) = 0;
3735 TREE_PUBLIC (decl) = 0;
3736 TREE_STATIC (decl) = (current_scope == file_scope);
3737 DECL_CONTEXT (decl) = current_function_decl;
3738 TREE_USED (decl) = 1;
3739 TREE_TYPE (decl) = type;
3740 /* (TIGCC 20050206) If -fglobal-compound-literals (on by default) is given,
3741 for constant constructors, the compound literal is written out as if it was
3742 const, which gets GCC to output it as a global, avoiding the copy. */
3743 TREE_READONLY (decl) = TYPE_READONLY (type)
3744 || (flag_global_compound_literals && TREE_CONSTANT (init));
3745 store_init_value (decl, init);
3746
3747 if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
3748 {
3749 int failure = complete_array_type (&TREE_TYPE (decl),
3750 DECL_INITIAL (decl), true);
3751 gcc_assert (!failure);
3752
3753 type = TREE_TYPE (decl);
3754 TREE_TYPE (DECL_INITIAL (decl)) = type;
3755 }
3756
3757 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3758 return error_mark_node;
3759
3760 stmt = build_stmt (DECL_EXPR, decl);
3761 complit = build1 (COMPOUND_LITERAL_EXPR, type, stmt);
3762 TREE_SIDE_EFFECTS (complit) = 1;
3763
3764 layout_decl (decl, 0);
3765
3766 if (TREE_STATIC (decl))
3767 {
3768 /* This decl needs a name for the assembler output. */
3769 set_compound_literal_name (decl);
3770 DECL_DEFER_OUTPUT (decl) = 1;
3771 DECL_COMDAT (decl) = 1;
3772 DECL_ARTIFICIAL (decl) = 1;
3773 DECL_IGNORED_P (decl) = 1;
3774 pushdecl (decl);
3775 rest_of_decl_compilation (decl, 1, 0);
3776 }
3777
3778 return complit;
3779 }
3780
3781 /* Determine whether TYPE is a structure with a flexible array member,
3782 or a union containing such a structure (possibly recursively). */
3783
3784 static bool
flexible_array_type_p(tree type)3785 flexible_array_type_p (tree type)
3786 {
3787 tree x;
3788 switch (TREE_CODE (type))
3789 {
3790 case RECORD_TYPE:
3791 x = TYPE_FIELDS (type);
3792 if (x == NULL_TREE)
3793 return false;
3794 while (TREE_CHAIN (x) != NULL_TREE)
3795 x = TREE_CHAIN (x);
3796 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
3797 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3798 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
3799 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
3800 return true;
3801 return false;
3802 case UNION_TYPE:
3803 for (x = TYPE_FIELDS (type); x != NULL_TREE; x = TREE_CHAIN (x))
3804 {
3805 if (flexible_array_type_p (TREE_TYPE (x)))
3806 return true;
3807 }
3808 return false;
3809 default:
3810 return false;
3811 }
3812 }
3813
3814 /* Performs sanity checks on the TYPE and WIDTH of the bit-field NAME,
3815 replacing with appropriate values if they are invalid. */
3816 static void
check_bitfield_type_and_width(tree * type,tree * width,const char * orig_name)3817 check_bitfield_type_and_width (tree *type, tree *width, const char *orig_name)
3818 {
3819 tree type_mv;
3820 unsigned int max_width;
3821 unsigned HOST_WIDE_INT w;
3822 const char *name = orig_name ? orig_name: _("<anonymous>");
3823
3824 /* Detect and ignore out of range field width and process valid
3825 field widths. */
3826 if (!INTEGRAL_TYPE_P (TREE_TYPE (*width))
3827 || TREE_CODE (*width) != INTEGER_CST)
3828 {
3829 error ("bit-field %qs width not an integer constant", name);
3830 *width = integer_one_node;
3831 }
3832 else
3833 {
3834 constant_expression_warning (*width);
3835 if (tree_int_cst_sgn (*width) < 0)
3836 {
3837 error ("negative width in bit-field %qs", name);
3838 *width = integer_one_node;
3839 }
3840 else if (integer_zerop (*width) && orig_name)
3841 {
3842 error ("zero width for bit-field %qs", name);
3843 *width = integer_one_node;
3844 }
3845 }
3846
3847 /* Detect invalid bit-field type. */
3848 if (TREE_CODE (*type) != INTEGER_TYPE
3849 && TREE_CODE (*type) != BOOLEAN_TYPE
3850 && TREE_CODE (*type) != ENUMERAL_TYPE)
3851 {
3852 error ("bit-field %qs has invalid type", name);
3853 *type = unsigned_type_node;
3854 }
3855
3856 type_mv = TYPE_MAIN_VARIANT (*type);
3857 if (pedantic
3858 && !in_system_header
3859 && type_mv != integer_type_node
3860 && type_mv != unsigned_type_node
3861 && type_mv != boolean_type_node)
3862 pedwarn ("type of bit-field %qs is a GCC extension", name);
3863
3864 if (type_mv == boolean_type_node)
3865 max_width = CHAR_TYPE_SIZE;
3866 else
3867 max_width = TYPE_PRECISION (*type);
3868
3869 if (0 < compare_tree_int (*width, max_width))
3870 {
3871 error ("width of %qs exceeds its type", name);
3872 w = max_width;
3873 *width = build_int_cst (NULL_TREE, w);
3874 }
3875 else
3876 w = tree_low_cst (*width, 1);
3877
3878 if (TREE_CODE (*type) == ENUMERAL_TYPE)
3879 {
3880 struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
3881 if (!lt
3882 || w < min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
3883 || w < min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
3884 warning (0, "%qs is narrower than values of its type", name);
3885 }
3886 }
3887
3888 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3889 static tree
c_build_bitfield_integer_type(unsigned HOST_WIDE_INT width,int unsignedp)3890 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3891 {
3892 /* Extended integer types of the same width as a standard type have
3893 lesser rank, so those of the same width as int promote to int or
3894 unsigned int and are valid for printf formats expecting int or
3895 unsigned int. To avoid such special cases, avoid creating
3896 extended integer types for bit-fields if a standard integer type
3897 is available. */
3898 if (width == TYPE_PRECISION (integer_type_node))
3899 return unsignedp ? unsigned_type_node : integer_type_node;
3900 if (width == TYPE_PRECISION (signed_char_type_node))
3901 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3902 if (width == TYPE_PRECISION (short_integer_type_node))
3903 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3904 if (width == TYPE_PRECISION (long_integer_type_node))
3905 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3906 if (width == TYPE_PRECISION (long_long_integer_type_node))
3907 return (unsignedp ? long_long_unsigned_type_node
3908 : long_long_integer_type_node);
3909 return build_nonstandard_integer_type (width, unsignedp);
3910 }
3911
3912 /* Given declspecs and a declarator,
3913 determine the name and type of the object declared
3914 and construct a ..._DECL node for it.
3915 (In one case we can return a ..._TYPE node instead.
3916 For invalid input we sometimes return 0.)
3917
3918 DECLSPECS is a c_declspecs structure for the declaration specifiers.
3919
3920 DECL_CONTEXT says which syntactic context this declaration is in:
3921 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
3922 FUNCDEF for a function definition. Like NORMAL but a few different
3923 error messages in each case. Return value may be zero meaning
3924 this definition is too screwy to try to parse.
3925 PARM for a parameter declaration (either within a function prototype
3926 or before a function body). Make a PARM_DECL, or return void_type_node.
3927 TYPENAME if for a typename (in a cast or sizeof).
3928 Don't make a DECL node; just return the ..._TYPE node.
3929 FIELD for a struct or union field; make a FIELD_DECL.
3930 INITIALIZED is true if the decl has an initializer.
3931 WIDTH is non-NULL for bit-fields, and is a pointer to an INTEGER_CST node
3932 representing the width of the bit-field.
3933
3934 In the TYPENAME case, DECLARATOR is really an absolute declarator.
3935 It may also be so in the PARM case, for a prototype where the
3936 argument type is specified but not the name.
3937
3938 This function is where the complicated C meanings of `static'
3939 and `extern' are interpreted. */
3940
3941 static tree
grokdeclarator(const struct c_declarator * declarator,struct c_declspecs * declspecs,enum decl_context decl_context,bool initialized,tree * width)3942 grokdeclarator (const struct c_declarator *declarator,
3943 struct c_declspecs *declspecs,
3944 enum decl_context decl_context, bool initialized, tree *width)
3945 {
3946 tree type = declspecs->type;
3947 bool threadp = declspecs->thread_p;
3948 enum c_storage_class storage_class = declspecs->storage_class;
3949 int constp;
3950 int restrictp;
3951 int volatilep;
3952 int type_quals = TYPE_UNQUALIFIED;
3953 const char *name, *orig_name;
3954 tree typedef_type = 0;
3955 int funcdef_flag = 0;
3956 bool funcdef_syntax = false;
3957 int size_varies = 0;
3958 tree decl_attr = declspecs->decl_attr;
3959 int array_ptr_quals = TYPE_UNQUALIFIED;
3960 tree array_ptr_attrs = NULL_TREE;
3961 int array_parm_static = 0;
3962 tree returned_attrs = NULL_TREE;
3963 bool bitfield = width != NULL;
3964 tree element_type;
3965 struct c_arg_info *arg_info = 0;
3966
3967 if (decl_context == FUNCDEF)
3968 funcdef_flag = 1, decl_context = NORMAL;
3969
3970 /* Look inside a declarator for the name being declared
3971 and get it as a string, for an error message. */
3972 {
3973 const struct c_declarator *decl = declarator;
3974 name = 0;
3975
3976 while (decl)
3977 switch (decl->kind)
3978 {
3979 case cdk_function:
3980 case cdk_array:
3981 case cdk_pointer:
3982 funcdef_syntax = (decl->kind == cdk_function);
3983 decl = decl->declarator;
3984 break;
3985
3986 case cdk_attrs:
3987 decl = decl->declarator;
3988 break;
3989
3990 case cdk_id:
3991 if (decl->u.id)
3992 name = IDENTIFIER_POINTER (decl->u.id);
3993 decl = 0;
3994 break;
3995
3996 default:
3997 gcc_unreachable ();
3998 }
3999 orig_name = name;
4000 if (name == 0)
4001 name = "type name";
4002 }
4003
4004 /* A function definition's declarator must have the form of
4005 a function declarator. */
4006
4007 if (funcdef_flag && !funcdef_syntax)
4008 return 0;
4009
4010 /* If this looks like a function definition, make it one,
4011 even if it occurs where parms are expected.
4012 Then store_parm_decls will reject it and not use it as a parm. */
4013 if (decl_context == NORMAL && !funcdef_flag && current_scope->parm_flag)
4014 decl_context = PARM;
4015
4016 if (declspecs->deprecated_p && deprecated_state != DEPRECATED_SUPPRESS)
4017 warn_deprecated_use (declspecs->type);
4018
4019 if ((decl_context == NORMAL || decl_context == FIELD)
4020 && current_scope == file_scope
4021 && variably_modified_type_p (type, NULL_TREE))
4022 {
4023 error ("variably modified %qs at file scope", name);
4024 type = integer_type_node;
4025 }
4026
4027 typedef_type = type;
4028 size_varies = C_TYPE_VARIABLE_SIZE (type);
4029
4030 /* Diagnose defaulting to "int". */
4031
4032 if (declspecs->default_int_p && !in_system_header)
4033 {
4034 /* Issue a warning if this is an ISO C 99 program or if
4035 -Wreturn-type and this is a function, or if -Wimplicit;
4036 prefer the former warning since it is more explicit. */
4037 if ((warn_implicit_int || warn_return_type || flag_isoc99)
4038 && funcdef_flag)
4039 warn_about_return_type = 1;
4040 else if (warn_implicit_int || flag_isoc99)
4041 pedwarn_c99 ("type defaults to %<int%> in declaration of %qs", name);
4042 }
4043
4044 /* Adjust the type if a bit-field is being declared,
4045 -funsigned-bitfields applied and the type is not explicitly
4046 "signed". */
4047 if (bitfield && !flag_signed_bitfields && !declspecs->explicit_signed_p
4048 && TREE_CODE (type) == INTEGER_TYPE)
4049 type = c_common_unsigned_type (type);
4050
4051 /* Figure out the type qualifiers for the declaration. There are
4052 two ways a declaration can become qualified. One is something
4053 like `const int i' where the `const' is explicit. Another is
4054 something like `typedef const int CI; CI i' where the type of the
4055 declaration contains the `const'. A third possibility is that
4056 there is a type qualifier on the element type of a typedefed
4057 array type, in which case we should extract that qualifier so
4058 that c_apply_type_quals_to_decls receives the full list of
4059 qualifiers to work with (C90 is not entirely clear about whether
4060 duplicate qualifiers should be diagnosed in this case, but it
4061 seems most appropriate to do so). */
4062 element_type = strip_array_types (type);
4063 constp = declspecs->const_p + TYPE_READONLY (element_type);
4064 restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
4065 volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
4066 if (pedantic && !flag_isoc99)
4067 {
4068 if (constp > 1)
4069 pedwarn ("duplicate %<const%>");
4070 if (restrictp > 1)
4071 pedwarn ("duplicate %<restrict%>");
4072 if (volatilep > 1)
4073 pedwarn ("duplicate %<volatile%>");
4074 }
4075 if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
4076 type = TYPE_MAIN_VARIANT (type);
4077 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
4078 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
4079 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
4080
4081 /* Warn about storage classes that are invalid for certain
4082 kinds of declarations (parameters, typenames, etc.). */
4083
4084 if (funcdef_flag
4085 && (threadp
4086 || storage_class == csc_auto
4087 || storage_class == csc_register
4088 || storage_class == csc_typedef))
4089 {
4090 if (storage_class == csc_auto
4091 && (pedantic || current_scope == file_scope))
4092 pedwarn ("function definition declared %<auto%>");
4093 if (storage_class == csc_register)
4094 error ("function definition declared %<register%>");
4095 if (storage_class == csc_typedef)
4096 error ("function definition declared %<typedef%>");
4097 if (threadp)
4098 error ("function definition declared %<__thread%>");
4099 threadp = false;
4100 if (storage_class == csc_auto
4101 || storage_class == csc_register
4102 || storage_class == csc_typedef)
4103 storage_class = csc_none;
4104 }
4105 else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
4106 {
4107 if (decl_context == PARM && storage_class == csc_register)
4108 ;
4109 else
4110 {
4111 switch (decl_context)
4112 {
4113 case FIELD:
4114 error ("storage class specified for structure field %qs",
4115 name);
4116 break;
4117 case PARM:
4118 error ("storage class specified for parameter %qs", name);
4119 break;
4120 default:
4121 error ("storage class specified for typename");
4122 break;
4123 }
4124 storage_class = csc_none;
4125 threadp = false;
4126 }
4127 }
4128 else if (storage_class == csc_extern
4129 && initialized
4130 && !funcdef_flag)
4131 {
4132 /* 'extern' with initialization is invalid if not at file scope. */
4133 if (current_scope == file_scope)
4134 warning (0, "%qs initialized and declared %<extern%>", name);
4135 else
4136 error ("%qs has both %<extern%> and initializer", name);
4137 }
4138 else if (current_scope == file_scope)
4139 {
4140 if (storage_class == csc_auto)
4141 error ("file-scope declaration of %qs specifies %<auto%>", name);
4142 if (pedantic && storage_class == csc_register)
4143 pedwarn ("file-scope declaration of %qs specifies %<register%>", name);
4144 }
4145 else
4146 {
4147 if (storage_class == csc_extern && funcdef_flag)
4148 error ("nested function %qs declared %<extern%>", name);
4149 else if (threadp && storage_class == csc_none)
4150 {
4151 error ("function-scope %qs implicitly auto and declared "
4152 "%<__thread%>",
4153 name);
4154 threadp = false;
4155 }
4156 }
4157
4158 /* Now figure out the structure of the declarator proper.
4159 Descend through it, creating more complex types, until we reach
4160 the declared identifier (or NULL_TREE, in an absolute declarator).
4161 At each stage we maintain an unqualified version of the type
4162 together with any qualifiers that should be applied to it with
4163 c_build_qualified_type; this way, array types including
4164 multidimensional array types are first built up in unqualified
4165 form and then the qualified form is created with
4166 TYPE_MAIN_VARIANT pointing to the unqualified form. */
4167
4168 while (declarator && declarator->kind != cdk_id)
4169 {
4170 if (type == error_mark_node)
4171 {
4172 declarator = declarator->declarator;
4173 continue;
4174 }
4175
4176 /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
4177 a cdk_pointer (for *...),
4178 a cdk_function (for ...(...)),
4179 a cdk_attrs (for nested attributes),
4180 or a cdk_id (for the name being declared
4181 or the place in an absolute declarator
4182 where the name was omitted).
4183 For the last case, we have just exited the loop.
4184
4185 At this point, TYPE is the type of elements of an array,
4186 or for a function to return, or for a pointer to point to.
4187 After this sequence of ifs, TYPE is the type of the
4188 array or function or pointer, and DECLARATOR has had its
4189 outermost layer removed. */
4190
4191 if (array_ptr_quals != TYPE_UNQUALIFIED
4192 || array_ptr_attrs != NULL_TREE
4193 || array_parm_static)
4194 {
4195 /* Only the innermost declarator (making a parameter be of
4196 array type which is converted to pointer type)
4197 may have static or type qualifiers. */
4198 error ("static or type qualifiers in non-parameter array declarator");
4199 array_ptr_quals = TYPE_UNQUALIFIED;
4200 array_ptr_attrs = NULL_TREE;
4201 array_parm_static = 0;
4202 }
4203
4204 switch (declarator->kind)
4205 {
4206 case cdk_attrs:
4207 {
4208 /* A declarator with embedded attributes. */
4209 tree attrs = declarator->u.attrs;
4210 const struct c_declarator *inner_decl;
4211 int attr_flags = 0;
4212 declarator = declarator->declarator;
4213 inner_decl = declarator;
4214 while (inner_decl->kind == cdk_attrs)
4215 inner_decl = inner_decl->declarator;
4216 if (inner_decl->kind == cdk_id)
4217 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
4218 else if (inner_decl->kind == cdk_function)
4219 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
4220 else if (inner_decl->kind == cdk_array)
4221 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
4222 returned_attrs = decl_attributes (&type,
4223 chainon (returned_attrs, attrs),
4224 attr_flags);
4225 break;
4226 }
4227 case cdk_array:
4228 {
4229 tree itype = NULL_TREE;
4230 tree size = declarator->u.array.dimen;
4231 /* The index is a signed object `sizetype' bits wide. */
4232 tree index_type = c_common_signed_type (sizetype);
4233
4234 array_ptr_quals = declarator->u.array.quals;
4235 array_ptr_attrs = declarator->u.array.attrs;
4236 array_parm_static = declarator->u.array.static_p;
4237
4238 declarator = declarator->declarator;
4239
4240 /* Check for some types that there cannot be arrays of. */
4241
4242 if (VOID_TYPE_P (type))
4243 {
4244 error ("declaration of %qs as array of voids", name);
4245 type = error_mark_node;
4246 }
4247
4248 if (TREE_CODE (type) == FUNCTION_TYPE)
4249 {
4250 error ("declaration of %qs as array of functions", name);
4251 type = error_mark_node;
4252 }
4253
4254 if (pedantic && !in_system_header && flexible_array_type_p (type))
4255 pedwarn ("invalid use of structure with flexible array member");
4256
4257 if (size == error_mark_node)
4258 type = error_mark_node;
4259
4260 if (type == error_mark_node)
4261 continue;
4262
4263 /* If size was specified, set ITYPE to a range-type for
4264 that size. Otherwise, ITYPE remains null. finish_decl
4265 may figure it out from an initial value. */
4266
4267 if (size)
4268 {
4269 /* Strip NON_LVALUE_EXPRs since we aren't using as an
4270 lvalue. */
4271 STRIP_TYPE_NOPS (size);
4272
4273 if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
4274 {
4275 error ("size of array %qs has non-integer type", name);
4276 size = integer_one_node;
4277 }
4278
4279 if (pedantic && integer_zerop (size))
4280 pedwarn ("ISO C forbids zero-size array %qs", name);
4281
4282 if (TREE_CODE (size) == INTEGER_CST)
4283 {
4284 constant_expression_warning (size);
4285 if (tree_int_cst_sgn (size) < 0)
4286 {
4287 error ("size of array %qs is negative", name);
4288 size = integer_one_node;
4289 }
4290 }
4291 else if ((decl_context == NORMAL || decl_context == FIELD)
4292 && current_scope == file_scope)
4293 {
4294 error ("variably modified %qs at file scope", name);
4295 size = integer_one_node;
4296 }
4297 else
4298 {
4299 /* Make sure the array size remains visibly
4300 nonconstant even if it is (eg) a const variable
4301 with known value. */
4302 size_varies = 1;
4303
4304 if (!flag_isoc99 && pedantic)
4305 {
4306 if (TREE_CONSTANT (size))
4307 pedwarn ("ISO C90 forbids array %qs whose size "
4308 "can%'t be evaluated",
4309 name);
4310 else
4311 pedwarn ("ISO C90 forbids variable-size array %qs",
4312 name);
4313 }
4314 }
4315
4316 if (integer_zerop (size))
4317 {
4318 /* A zero-length array cannot be represented with
4319 an unsigned index type, which is what we'll
4320 get with build_index_type. Create an
4321 open-ended range instead. */
4322 itype = build_range_type (sizetype, size, NULL_TREE);
4323 }
4324 else
4325 {
4326 /* Arrange for the SAVE_EXPR on the inside of the
4327 MINUS_EXPR, which allows the -1 to get folded
4328 with the +1 that happens when building TYPE_SIZE. */
4329 if (size_varies)
4330 size = variable_size (size);
4331
4332 /* Compute the maximum valid index, that is, size
4333 - 1. Do the calculation in index_type, so that
4334 if it is a variable the computations will be
4335 done in the proper mode. */
4336 itype = fold_build2 (MINUS_EXPR, index_type,
4337 convert (index_type, size),
4338 convert (index_type,
4339 size_one_node));
4340
4341 /* If that overflowed, the array is too big. ???
4342 While a size of INT_MAX+1 technically shouldn't
4343 cause an overflow (because we subtract 1), the
4344 overflow is recorded during the conversion to
4345 index_type, before the subtraction. Handling
4346 this case seems like an unnecessary
4347 complication. */
4348 if (TREE_CODE (itype) == INTEGER_CST
4349 && TREE_OVERFLOW (itype))
4350 {
4351 error ("size of array %qs is too large", name);
4352 type = error_mark_node;
4353 continue;
4354 }
4355
4356 itype = build_index_type (itype);
4357 }
4358 }
4359 else if (decl_context == FIELD)
4360 {
4361 if (pedantic && !flag_isoc99 && !in_system_header)
4362 pedwarn ("ISO C90 does not support flexible array members");
4363
4364 /* ISO C99 Flexible array members are effectively
4365 identical to GCC's zero-length array extension. */
4366 itype = build_range_type (sizetype, size_zero_node, NULL_TREE);
4367 }
4368
4369 /* Complain about arrays of incomplete types. */
4370 if (!COMPLETE_TYPE_P (type))
4371 {
4372 error ("array type has incomplete element type");
4373 type = error_mark_node;
4374 }
4375 else
4376 type = build_array_type (type, itype);
4377
4378 if (type != error_mark_node)
4379 {
4380 if (size_varies)
4381 {
4382 if (size && TREE_CODE (size) == INTEGER_CST)
4383 type
4384 = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
4385 C_TYPE_VARIABLE_SIZE (type) = 1;
4386 }
4387
4388 /* The GCC extension for zero-length arrays differs from
4389 ISO flexible array members in that sizeof yields
4390 zero. */
4391 if (size && integer_zerop (size))
4392 {
4393 TYPE_SIZE (type) = bitsize_zero_node;
4394 TYPE_SIZE_UNIT (type) = size_zero_node;
4395 }
4396 }
4397
4398 if (decl_context != PARM
4399 && (array_ptr_quals != TYPE_UNQUALIFIED
4400 || array_ptr_attrs != NULL_TREE
4401 || array_parm_static))
4402 {
4403 error ("static or type qualifiers in non-parameter array declarator");
4404 array_ptr_quals = TYPE_UNQUALIFIED;
4405 array_ptr_attrs = NULL_TREE;
4406 array_parm_static = 0;
4407 }
4408 break;
4409 }
4410 case cdk_function:
4411 {
4412 /* Say it's a definition only for the declarator closest
4413 to the identifier, apart possibly from some
4414 attributes. */
4415 bool really_funcdef = false;
4416 tree arg_types;
4417 if (funcdef_flag)
4418 {
4419 const struct c_declarator *t = declarator->declarator;
4420 while (t->kind == cdk_attrs)
4421 t = t->declarator;
4422 really_funcdef = (t->kind == cdk_id);
4423 }
4424
4425 /* Declaring a function type. Make sure we have a valid
4426 type for the function to return. */
4427 if (type == error_mark_node)
4428 continue;
4429
4430 size_varies = 0;
4431
4432 /* Warn about some types functions can't return. */
4433 if (TREE_CODE (type) == FUNCTION_TYPE)
4434 {
4435 error ("%qs declared as function returning a function", name);
4436 type = integer_type_node;
4437 }
4438 if (TREE_CODE (type) == ARRAY_TYPE)
4439 {
4440 error ("%qs declared as function returning an array", name);
4441 type = integer_type_node;
4442 }
4443
4444 /* Construct the function type and go to the next
4445 inner layer of declarator. */
4446 arg_info = declarator->u.arg_info;
4447 arg_types = grokparms (arg_info, really_funcdef);
4448
4449 /* Type qualifiers before the return type of the function
4450 qualify the return type, not the function type. */
4451 if (type_quals)
4452 {
4453 /* Type qualifiers on a function return type are
4454 normally permitted by the standard but have no
4455 effect, so give a warning at -Wreturn-type.
4456 Qualifiers on a void return type are banned on
4457 function definitions in ISO C; GCC used to used
4458 them for noreturn functions. */
4459 if (VOID_TYPE_P (type) && really_funcdef)
4460 pedwarn ("function definition has qualified void return type");
4461 else
4462 warning (OPT_Wreturn_type,
4463 "type qualifiers ignored on function return type");
4464
4465 type = c_build_qualified_type (type, type_quals);
4466 }
4467 type_quals = TYPE_UNQUALIFIED;
4468
4469 type = build_function_type (type, arg_types);
4470 declarator = declarator->declarator;
4471
4472 /* Set the TYPE_CONTEXTs for each tagged type which is local to
4473 the formal parameter list of this FUNCTION_TYPE to point to
4474 the FUNCTION_TYPE node itself. */
4475 {
4476 tree link;
4477
4478 for (link = arg_info->tags;
4479 link;
4480 link = TREE_CHAIN (link))
4481 TYPE_CONTEXT (TREE_VALUE (link)) = type;
4482 }
4483 break;
4484 }
4485 case cdk_pointer:
4486 {
4487 /* Merge any constancy or volatility into the target type
4488 for the pointer. */
4489
4490 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4491 && type_quals)
4492 pedwarn ("ISO C forbids qualified function types");
4493 if (type_quals)
4494 type = c_build_qualified_type (type, type_quals);
4495 size_varies = 0;
4496
4497 type = build_pointer_type (type);
4498
4499 /* Process type qualifiers (such as const or volatile)
4500 that were given inside the `*'. */
4501 type_quals = declarator->u.pointer_quals;
4502
4503 declarator = declarator->declarator;
4504 break;
4505 }
4506 default:
4507 gcc_unreachable ();
4508 }
4509 }
4510
4511 /* Now TYPE has the actual type, apart from any qualifiers in
4512 TYPE_QUALS. */
4513
4514 /* Check the type and width of a bit-field. */
4515 if (bitfield)
4516 check_bitfield_type_and_width (&type, width, orig_name);
4517
4518 /* Did array size calculations overflow? */
4519
4520 if (TREE_CODE (type) == ARRAY_TYPE
4521 && COMPLETE_TYPE_P (type)
4522 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
4523 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
4524 {
4525 error ("size of array %qs is too large", name);
4526 /* If we proceed with the array type as it is, we'll eventually
4527 crash in tree_low_cst(). */
4528 type = error_mark_node;
4529 }
4530
4531 /* If this is declaring a typedef name, return a TYPE_DECL. */
4532
4533 if (storage_class == csc_typedef)
4534 {
4535 tree decl;
4536 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4537 && type_quals)
4538 pedwarn ("ISO C forbids qualified function types");
4539 if (type_quals)
4540 type = c_build_qualified_type (type, type_quals);
4541 decl = build_decl (TYPE_DECL, declarator->u.id, type);
4542 if (declspecs->explicit_signed_p)
4543 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
4544 decl_attributes (&decl, returned_attrs, 0);
4545 if (declspecs->inline_p)
4546 pedwarn ("typedef %q+D declared %<inline%>", decl);
4547 return decl;
4548 }
4549
4550 /* Detect the case of an array type of unspecified size
4551 which came, as such, direct from a typedef name.
4552 We must copy the type, so that each identifier gets
4553 a distinct type, so that each identifier's size can be
4554 controlled separately by its own initializer. */
4555
4556 if (type != 0 && typedef_type != 0
4557 && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
4558 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
4559 {
4560 type = build_array_type (TREE_TYPE (type), 0);
4561 if (size_varies)
4562 C_TYPE_VARIABLE_SIZE (type) = 1;
4563 }
4564
4565 /* If this is a type name (such as, in a cast or sizeof),
4566 compute the type and return it now. */
4567
4568 if (decl_context == TYPENAME)
4569 {
4570 /* Note that the grammar rejects storage classes in typenames
4571 and fields. */
4572 gcc_assert (storage_class == csc_none && !threadp
4573 && !declspecs->inline_p);
4574 if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
4575 && type_quals)
4576 pedwarn ("ISO C forbids const or volatile function types");
4577 if (type_quals)
4578 type = c_build_qualified_type (type, type_quals);
4579 decl_attributes (&type, returned_attrs, 0);
4580 return type;
4581 }
4582
4583 /* Aside from typedefs and type names (handle above),
4584 `void' at top level (not within pointer)
4585 is allowed only in public variables.
4586 We don't complain about parms either, but that is because
4587 a better error message can be made later. */
4588
4589 if (VOID_TYPE_P (type) && decl_context != PARM
4590 && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
4591 && (storage_class == csc_extern
4592 || (current_scope == file_scope
4593 && !(storage_class == csc_static
4594 || storage_class == csc_register)))))
4595 {
4596 error ("variable or field %qs declared void", name);
4597 type = integer_type_node;
4598 }
4599
4600 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
4601 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
4602
4603 {
4604 tree decl;
4605
4606 if (decl_context == PARM)
4607 {
4608 tree type_as_written;
4609 tree promoted_type;
4610
4611 /* A parameter declared as an array of T is really a pointer to T.
4612 One declared as a function is really a pointer to a function. */
4613
4614 if (TREE_CODE (type) == ARRAY_TYPE)
4615 {
4616 /* Transfer const-ness of array into that of type pointed to. */
4617 type = TREE_TYPE (type);
4618 if (type_quals)
4619 type = c_build_qualified_type (type, type_quals);
4620 type = build_pointer_type (type);
4621 type_quals = array_ptr_quals;
4622
4623 /* We don't yet implement attributes in this context. */
4624 if (array_ptr_attrs != NULL_TREE)
4625 warning (OPT_Wattributes,
4626 "attributes in parameter array declarator ignored");
4627
4628 size_varies = 0;
4629 }
4630 else if (TREE_CODE (type) == FUNCTION_TYPE)
4631 {
4632 if (pedantic && type_quals)
4633 pedwarn ("ISO C forbids qualified function types");
4634 if (type_quals)
4635 type = c_build_qualified_type (type, type_quals);
4636 type = build_pointer_type (type);
4637 type_quals = TYPE_UNQUALIFIED;
4638 }
4639 else if (type_quals)
4640 type = c_build_qualified_type (type, type_quals);
4641
4642 type_as_written = type;
4643
4644 decl = build_decl (PARM_DECL, declarator->u.id, type);
4645 if (size_varies)
4646 C_DECL_VARIABLE_SIZE (decl) = 1;
4647
4648 /* Compute the type actually passed in the parmlist,
4649 for the case where there is no prototype.
4650 (For example, shorts and chars are passed as ints.)
4651 When there is a prototype, this is overridden later. */
4652
4653 if (type == error_mark_node)
4654 promoted_type = type;
4655 else
4656 promoted_type = c_type_promotes_to (type);
4657
4658 DECL_ARG_TYPE (decl) = promoted_type;
4659 if (declspecs->inline_p)
4660 pedwarn ("parameter %q+D declared %<inline%>", decl);
4661 }
4662 else if (decl_context == FIELD)
4663 {
4664 /* Note that the grammar rejects storage classes in typenames
4665 and fields. */
4666 gcc_assert (storage_class == csc_none && !threadp
4667 && !declspecs->inline_p);
4668
4669 /* Structure field. It may not be a function. */
4670
4671 if (TREE_CODE (type) == FUNCTION_TYPE)
4672 {
4673 error ("field %qs declared as a function", name);
4674 type = build_pointer_type (type);
4675 }
4676 else if (TREE_CODE (type) != ERROR_MARK
4677 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
4678 {
4679 error ("field %qs has incomplete type", name);
4680 type = error_mark_node;
4681 }
4682 type = c_build_qualified_type (type, type_quals);
4683 decl = build_decl (FIELD_DECL, declarator->u.id, type);
4684 DECL_NONADDRESSABLE_P (decl) = bitfield;
4685
4686 if (size_varies)
4687 C_DECL_VARIABLE_SIZE (decl) = 1;
4688 }
4689 else if (TREE_CODE (type) == FUNCTION_TYPE)
4690 {
4691 if (storage_class == csc_register || threadp)
4692 {
4693 error ("invalid storage class for function %qs", name);
4694 }
4695 else if (current_scope != file_scope)
4696 {
4697 /* Function declaration not at file scope. Storage
4698 classes other than `extern' are not allowed, C99
4699 6.7.1p5, and `extern' makes no difference. However,
4700 GCC allows 'auto', perhaps with 'inline', to support
4701 nested functions. */
4702 if (storage_class == csc_auto)
4703 {
4704 if (pedantic)
4705 pedwarn ("invalid storage class for function %qs", name);
4706 }
4707 else if (storage_class == csc_static)
4708 {
4709 error ("invalid storage class for function %qs", name);
4710 if (funcdef_flag)
4711 storage_class = declspecs->storage_class = csc_none;
4712 else
4713 return 0;
4714 }
4715 }
4716
4717 decl = build_decl (FUNCTION_DECL, declarator->u.id, type);
4718 decl = build_decl_attribute_variant (decl, decl_attr);
4719
4720 DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
4721
4722 if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
4723 pedwarn ("ISO C forbids qualified function types");
4724
4725 /* GNU C interprets a volatile-qualified function type to indicate
4726 that the function does not return. */
4727 if ((type_quals & TYPE_QUAL_VOLATILE)
4728 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
4729 warning (0, "%<noreturn%> function returns non-void value");
4730
4731 /* Every function declaration is an external reference
4732 (DECL_EXTERNAL) except for those which are not at file
4733 scope and are explicitly declared "auto". This is
4734 forbidden by standard C (C99 6.7.1p5) and is interpreted by
4735 GCC to signify a forward declaration of a nested function. */
4736 if (storage_class == csc_auto && current_scope != file_scope)
4737 DECL_EXTERNAL (decl) = 0;
4738 else
4739 DECL_EXTERNAL (decl) = 1;
4740
4741 /* Record absence of global scope for `static' or `auto'. */
4742 TREE_PUBLIC (decl)
4743 = !(storage_class == csc_static || storage_class == csc_auto);
4744
4745 /* For a function definition, record the argument information
4746 block where store_parm_decls will look for it. */
4747 if (funcdef_flag)
4748 current_function_arg_info = arg_info;
4749
4750 if (declspecs->default_int_p)
4751 C_FUNCTION_IMPLICIT_INT (decl) = 1;
4752
4753 /* Record presence of `inline', if it is reasonable. */
4754 if (flag_hosted && MAIN_NAME_P (declarator->u.id))
4755 {
4756 if (declspecs->inline_p)
4757 pedwarn ("cannot inline function %<main%>");
4758 }
4759 else if (declspecs->inline_p)
4760 {
4761 /* Record that the function is declared `inline'. */
4762 DECL_DECLARED_INLINE_P (decl) = 1;
4763
4764 /* Do not mark bare declarations as DECL_INLINE. Doing so
4765 in the presence of multiple declarations can result in
4766 the abstract origin pointing between the declarations,
4767 which will confuse dwarf2out. */
4768 if (initialized)
4769 {
4770 DECL_INLINE (decl) = 1;
4771 if (storage_class == csc_extern)
4772 current_extern_inline = 1;
4773 }
4774 }
4775 /* If -finline-functions, assume it can be inlined. This does
4776 two things: let the function be deferred until it is actually
4777 needed, and let dwarf2 know that the function is inlinable. */
4778 else if (flag_inline_trees == 2 && initialized)
4779 DECL_INLINE (decl) = 1;
4780 }
4781 else
4782 {
4783 /* It's a variable. */
4784 /* An uninitialized decl with `extern' is a reference. */
4785 int extern_ref = !initialized && storage_class == csc_extern;
4786
4787 type = c_build_qualified_type (type, type_quals);
4788
4789 /* C99 6.2.2p7: It is invalid (compile-time undefined
4790 behavior) to create an 'extern' declaration for a
4791 variable if there is a global declaration that is
4792 'static' and the global declaration is not visible.
4793 (If the static declaration _is_ currently visible,
4794 the 'extern' declaration is taken to refer to that decl.) */
4795 if (extern_ref && current_scope != file_scope)
4796 {
4797 tree global_decl = identifier_global_value (declarator->u.id);
4798 tree visible_decl = lookup_name (declarator->u.id);
4799
4800 if (global_decl
4801 && global_decl != visible_decl
4802 && TREE_CODE (global_decl) == VAR_DECL
4803 && !TREE_PUBLIC (global_decl))
4804 error ("variable previously declared %<static%> redeclared "
4805 "%<extern%>");
4806 }
4807
4808 decl = build_decl (VAR_DECL, declarator->u.id, type);
4809 DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
4810 if (size_varies)
4811 C_DECL_VARIABLE_SIZE (decl) = 1;
4812
4813 if (declspecs->inline_p)
4814 pedwarn ("variable %q+D declared %<inline%>", decl);
4815
4816 /* At file scope, an initialized extern declaration may follow
4817 a static declaration. In that case, DECL_EXTERNAL will be
4818 reset later in start_decl. */
4819 DECL_EXTERNAL (decl) = (storage_class == csc_extern);
4820
4821 /* At file scope, the presence of a `static' or `register' storage
4822 class specifier, or the absence of all storage class specifiers
4823 makes this declaration a definition (perhaps tentative). Also,
4824 the absence of `static' makes it public. */
4825 if (current_scope == file_scope)
4826 {
4827 TREE_PUBLIC (decl) = storage_class != csc_static;
4828 TREE_STATIC (decl) = !extern_ref;
4829 }
4830 /* Not at file scope, only `static' makes a static definition. */
4831 else
4832 {
4833 TREE_STATIC (decl) = (storage_class == csc_static);
4834 TREE_PUBLIC (decl) = extern_ref;
4835 }
4836
4837 if (threadp)
4838 {
4839 if (targetm.have_tls)
4840 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
4841 else
4842 /* A mere warning is sure to result in improper semantics
4843 at runtime. Don't bother to allow this to compile. */
4844 error ("thread-local storage not supported for this target");
4845 }
4846 }
4847
4848 /* Record `register' declaration for warnings on &
4849 and in case doing stupid register allocation. */
4850
4851 if (storage_class == csc_register)
4852 {
4853 C_DECL_REGISTER (decl) = 1;
4854 DECL_REGISTER (decl) = 1;
4855 }
4856
4857 /* Record constancy and volatility. */
4858 c_apply_type_quals_to_decl (type_quals, decl);
4859
4860 /* If a type has volatile components, it should be stored in memory.
4861 Otherwise, the fact that those components are volatile
4862 will be ignored, and would even crash the compiler.
4863 Of course, this only makes sense on VAR,PARM, and RESULT decl's. */
4864 if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
4865 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
4866 || TREE_CODE (decl) == RESULT_DECL))
4867 {
4868 /* It is not an error for a structure with volatile fields to
4869 be declared register, but reset DECL_REGISTER since it
4870 cannot actually go in a register. */
4871 int was_reg = C_DECL_REGISTER (decl);
4872 C_DECL_REGISTER (decl) = 0;
4873 DECL_REGISTER (decl) = 0;
4874 c_mark_addressable (decl);
4875 C_DECL_REGISTER (decl) = was_reg;
4876 }
4877
4878 /* This is the earliest point at which we might know the assembler
4879 name of a variable. Thus, if it's known before this, die horribly. */
4880 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
4881
4882 decl_attributes (&decl, returned_attrs, 0);
4883
4884 return decl;
4885 }
4886 }
4887
4888 /* Decode the parameter-list info for a function type or function definition.
4889 The argument is the value returned by `get_parm_info' (or made in parse.y
4890 if there is an identifier list instead of a parameter decl list).
4891 These two functions are separate because when a function returns
4892 or receives functions then each is called multiple times but the order
4893 of calls is different. The last call to `grokparms' is always the one
4894 that contains the formal parameter names of a function definition.
4895
4896 Return a list of arg types to use in the FUNCTION_TYPE for this function.
4897
4898 FUNCDEF_FLAG is true for a function definition, false for
4899 a mere declaration. A nonempty identifier-list gets an error message
4900 when FUNCDEF_FLAG is false. */
4901
4902 static tree
grokparms(struct c_arg_info * arg_info,bool funcdef_flag)4903 grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
4904 {
4905 tree arg_types = arg_info->types;
4906
4907 if (arg_types == 0 && !funcdef_flag && !in_system_header)
4908 warning (OPT_Wstrict_prototypes,
4909 "function declaration isn%'t a prototype");
4910
4911 if (arg_types == error_mark_node)
4912 return 0; /* don't set TYPE_ARG_TYPES in this case */
4913
4914 else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
4915 {
4916 if (!funcdef_flag)
4917 pedwarn ("parameter names (without types) in function declaration");
4918
4919 arg_info->parms = arg_info->types;
4920 arg_info->types = 0;
4921 return 0;
4922 }
4923 else
4924 {
4925 tree parm, type, typelt;
4926 unsigned int parmno;
4927
4928 /* If there is a parameter of incomplete type in a definition,
4929 this is an error. In a declaration this is valid, and a
4930 struct or union type may be completed later, before any calls
4931 or definition of the function. In the case where the tag was
4932 first declared within the parameter list, a warning has
4933 already been given. If a parameter has void type, then
4934 however the function cannot be defined or called, so
4935 warn. */
4936
4937 for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
4938 parm;
4939 parm = TREE_CHAIN (parm), typelt = TREE_CHAIN (typelt), parmno++)
4940 {
4941 type = TREE_VALUE (typelt);
4942 if (type == error_mark_node)
4943 continue;
4944
4945 if (!COMPLETE_TYPE_P (type))
4946 {
4947 if (funcdef_flag)
4948 {
4949 if (DECL_NAME (parm))
4950 error ("parameter %u (%q+D) has incomplete type",
4951 parmno, parm);
4952 else
4953 error ("%Jparameter %u has incomplete type",
4954 parm, parmno);
4955
4956 TREE_VALUE (typelt) = error_mark_node;
4957 TREE_TYPE (parm) = error_mark_node;
4958 }
4959 else if (VOID_TYPE_P (type))
4960 {
4961 if (DECL_NAME (parm))
4962 warning (0, "parameter %u (%q+D) has void type",
4963 parmno, parm);
4964 else
4965 warning (0, "%Jparameter %u has void type",
4966 parm, parmno);
4967 }
4968 }
4969
4970 if (DECL_NAME (parm) && TREE_USED (parm))
4971 warn_if_shadowing (parm);
4972 }
4973 return arg_types;
4974 }
4975 }
4976
4977 /* Take apart the current scope and return a c_arg_info structure with
4978 info on a parameter list just parsed.
4979
4980 This structure is later fed to 'grokparms' and 'store_parm_decls'.
4981
4982 ELLIPSIS being true means the argument list ended in '...' so don't
4983 append a sentinel (void_list_node) to the end of the type-list. */
4984
4985 struct c_arg_info *
get_parm_info(bool ellipsis)4986 get_parm_info (bool ellipsis)
4987 {
4988 struct c_binding *b = current_scope->bindings;
4989 struct c_arg_info *arg_info = XOBNEW (&parser_obstack,
4990 struct c_arg_info);
4991 tree parms = 0;
4992 tree tags = 0;
4993 tree types = 0;
4994 tree others = 0;
4995
4996 static bool explained_incomplete_types = false;
4997 bool gave_void_only_once_err = false;
4998
4999 arg_info->parms = 0;
5000 arg_info->tags = 0;
5001 arg_info->types = 0;
5002 arg_info->others = 0;
5003
5004 /* The bindings in this scope must not get put into a block.
5005 We will take care of deleting the binding nodes. */
5006 current_scope->bindings = 0;
5007
5008 /* This function is only called if there was *something* on the
5009 parameter list. */
5010 gcc_assert (b);
5011
5012 /* A parameter list consisting solely of 'void' indicates that the
5013 function takes no arguments. But if the 'void' is qualified
5014 (by 'const' or 'volatile'), or has a storage class specifier
5015 ('register'), then the behavior is undefined; issue an error.
5016 Typedefs for 'void' are OK (see DR#157). */
5017 if (b->prev == 0 /* one binding */
5018 && TREE_CODE (b->decl) == PARM_DECL /* which is a parameter */
5019 && !DECL_NAME (b->decl) /* anonymous */
5020 && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
5021 {
5022 if (TREE_THIS_VOLATILE (b->decl)
5023 || TREE_READONLY (b->decl)
5024 || C_DECL_REGISTER (b->decl))
5025 error ("%<void%> as only parameter may not be qualified");
5026
5027 /* There cannot be an ellipsis. */
5028 if (ellipsis)
5029 error ("%<void%> must be the only parameter");
5030
5031 arg_info->types = void_list_node;
5032 return arg_info;
5033 }
5034
5035 if (!ellipsis)
5036 types = void_list_node;
5037
5038 /* Break up the bindings list into parms, tags, types, and others;
5039 apply sanity checks; purge the name-to-decl bindings. */
5040 while (b)
5041 {
5042 tree decl = b->decl;
5043 tree type = TREE_TYPE (decl);
5044 const char *keyword;
5045
5046 switch (TREE_CODE (decl))
5047 {
5048 case PARM_DECL:
5049 if (b->id)
5050 {
5051 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
5052 I_SYMBOL_BINDING (b->id) = b->shadowed;
5053 }
5054
5055 /* Check for forward decls that never got their actual decl. */
5056 if (TREE_ASM_WRITTEN (decl))
5057 error ("parameter %q+D has just a forward declaration", decl);
5058 /* Check for (..., void, ...) and issue an error. */
5059 else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
5060 {
5061 if (!gave_void_only_once_err)
5062 {
5063 error ("%<void%> must be the only parameter");
5064 gave_void_only_once_err = true;
5065 }
5066 }
5067 else
5068 {
5069 /* Valid parameter, add it to the list. */
5070 TREE_CHAIN (decl) = parms;
5071 parms = decl;
5072
5073 /* Since there is a prototype, args are passed in their
5074 declared types. The back end may override this later. */
5075 DECL_ARG_TYPE (decl) = type;
5076 types = tree_cons (0, type, types);
5077 }
5078 break;
5079
5080 case ENUMERAL_TYPE: keyword = "enum"; goto tag;
5081 case UNION_TYPE: keyword = "union"; goto tag;
5082 case RECORD_TYPE: keyword = "struct"; goto tag;
5083 tag:
5084 /* Types may not have tag-names, in which case the type
5085 appears in the bindings list with b->id NULL. */
5086 if (b->id)
5087 {
5088 gcc_assert (I_TAG_BINDING (b->id) == b);
5089 I_TAG_BINDING (b->id) = b->shadowed;
5090 }
5091
5092 /* Warn about any struct, union or enum tags defined in a
5093 parameter list. The scope of such types is limited to
5094 the parameter list, which is rarely if ever desirable
5095 (it's impossible to call such a function with type-
5096 correct arguments). An anonymous union parm type is
5097 meaningful as a GNU extension, so don't warn for that. */
5098 if (TREE_CODE (decl) != UNION_TYPE || b->id != 0)
5099 {
5100 if (b->id)
5101 /* The %s will be one of 'struct', 'union', or 'enum'. */
5102 warning (0, "%<%s %E%> declared inside parameter list",
5103 keyword, b->id);
5104 else
5105 /* The %s will be one of 'struct', 'union', or 'enum'. */
5106 warning (0, "anonymous %s declared inside parameter list",
5107 keyword);
5108
5109 if (!explained_incomplete_types)
5110 {
5111 warning (0, "its scope is only this definition or declaration,"
5112 " which is probably not what you want");
5113 explained_incomplete_types = true;
5114 }
5115 }
5116
5117 tags = tree_cons (b->id, decl, tags);
5118 break;
5119
5120 case CONST_DECL:
5121 case TYPE_DECL:
5122 case FUNCTION_DECL:
5123 /* CONST_DECLs appear here when we have an embedded enum,
5124 and TYPE_DECLs appear here when we have an embedded struct
5125 or union. No warnings for this - we already warned about the
5126 type itself. FUNCTION_DECLs appear when there is an implicit
5127 function declaration in the parameter list. */
5128
5129 TREE_CHAIN (decl) = others;
5130 others = decl;
5131 /* fall through */
5132
5133 case ERROR_MARK:
5134 /* error_mark_node appears here when we have an undeclared
5135 variable. Just throw it away. */
5136 if (b->id)
5137 {
5138 gcc_assert (I_SYMBOL_BINDING (b->id) == b);
5139 I_SYMBOL_BINDING (b->id) = b->shadowed;
5140 }
5141 break;
5142
5143 /* Other things that might be encountered. */
5144 case LABEL_DECL:
5145 case VAR_DECL:
5146 default:
5147 gcc_unreachable ();
5148 }
5149
5150 b = free_binding_and_advance (b);
5151 }
5152
5153 arg_info->parms = parms;
5154 arg_info->tags = tags;
5155 arg_info->types = types;
5156 arg_info->others = others;
5157 return arg_info;
5158 }
5159
5160 /* Get the struct, enum or union (CODE says which) with tag NAME.
5161 Define the tag as a forward-reference if it is not defined.
5162 Return a c_typespec structure for the type specifier. */
5163
5164 struct c_typespec
parser_xref_tag(enum tree_code code,tree name)5165 parser_xref_tag (enum tree_code code, tree name)
5166 {
5167 struct c_typespec ret;
5168 /* If a cross reference is requested, look up the type
5169 already defined for this tag and return it. */
5170
5171 tree ref = lookup_tag (code, name, 0);
5172 /* If this is the right type of tag, return what we found.
5173 (This reference will be shadowed by shadow_tag later if appropriate.)
5174 If this is the wrong type of tag, do not return it. If it was the
5175 wrong type in the same scope, we will have had an error
5176 message already; if in a different scope and declaring
5177 a name, pending_xref_error will give an error message; but if in a
5178 different scope and not declaring a name, this tag should
5179 shadow the previous declaration of a different type of tag, and
5180 this would not work properly if we return the reference found.
5181 (For example, with "struct foo" in an outer scope, "union foo;"
5182 must shadow that tag with a new one of union type.) */
5183 ret.kind = (ref ? ctsk_tagref : ctsk_tagfirstref);
5184 if (ref && TREE_CODE (ref) == code)
5185 {
5186 ret.spec = ref;
5187 return ret;
5188 }
5189
5190 /* If no such tag is yet defined, create a forward-reference node
5191 and record it as the "definition".
5192 When a real declaration of this type is found,
5193 the forward-reference will be altered into a real type. */
5194
5195 ref = make_node (code);
5196 if (code == ENUMERAL_TYPE)
5197 {
5198 /* Give the type a default layout like unsigned int
5199 to avoid crashing if it does not get defined. */
5200 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
5201 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
5202 TYPE_USER_ALIGN (ref) = 0;
5203 TYPE_UNSIGNED (ref) = 1;
5204 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
5205 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
5206 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
5207 }
5208
5209 pushtag (name, ref);
5210
5211 ret.spec = ref;
5212 return ret;
5213 }
5214
5215 /* Get the struct, enum or union (CODE says which) with tag NAME.
5216 Define the tag as a forward-reference if it is not defined.
5217 Return a tree for the type. */
5218
5219 tree
xref_tag(enum tree_code code,tree name)5220 xref_tag (enum tree_code code, tree name)
5221 {
5222 return parser_xref_tag (code, name).spec;
5223 }
5224
5225 /* Make sure that the tag NAME is defined *in the current scope*
5226 at least as a forward reference.
5227 CODE says which kind of tag NAME ought to be. */
5228
5229 tree
start_struct(enum tree_code code,tree name)5230 start_struct (enum tree_code code, tree name)
5231 {
5232 /* If there is already a tag defined at this scope
5233 (as a forward reference), just return it. */
5234
5235 tree ref = 0;
5236
5237 if (name != 0)
5238 ref = lookup_tag (code, name, 1);
5239 if (ref && TREE_CODE (ref) == code)
5240 {
5241 if (TYPE_SIZE (ref))
5242 {
5243 if (code == UNION_TYPE)
5244 error ("redefinition of %<union %E%>", name);
5245 else
5246 error ("redefinition of %<struct %E%>", name);
5247 }
5248 else if (C_TYPE_BEING_DEFINED (ref))
5249 {
5250 if (code == UNION_TYPE)
5251 error ("nested redefinition of %<union %E%>", name);
5252 else
5253 error ("nested redefinition of %<struct %E%>", name);
5254 }
5255 }
5256 else
5257 {
5258 /* Otherwise create a forward-reference just so the tag is in scope. */
5259
5260 ref = make_node (code);
5261 pushtag (name, ref);
5262 }
5263
5264 C_TYPE_BEING_DEFINED (ref) = 1;
5265 TYPE_PACKED (ref) = flag_pack_struct;
5266 return ref;
5267 }
5268
5269 /* Process the specs, declarator and width (NULL if omitted)
5270 of a structure component, returning a FIELD_DECL node.
5271 WIDTH is non-NULL for bit-fields only, and is an INTEGER_CST node.
5272
5273 This is done during the parsing of the struct declaration.
5274 The FIELD_DECL nodes are chained together and the lot of them
5275 are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
5276
5277 tree
grokfield(struct c_declarator * declarator,struct c_declspecs * declspecs,tree width)5278 grokfield (struct c_declarator *declarator, struct c_declspecs *declspecs,
5279 tree width)
5280 {
5281 tree value;
5282
5283 if (declarator->kind == cdk_id && declarator->u.id == NULL_TREE
5284 && width == NULL_TREE)
5285 {
5286 /* This is an unnamed decl.
5287
5288 If we have something of the form "union { list } ;" then this
5289 is the anonymous union extension. Similarly for struct.
5290
5291 If this is something of the form "struct foo;", then
5292 If MS extensions are enabled, this is handled as an
5293 anonymous struct.
5294 Otherwise this is a forward declaration of a structure tag.
5295
5296 If this is something of the form "foo;" and foo is a TYPE_DECL, then
5297 If MS extensions are enabled and foo names a structure, then
5298 again this is an anonymous struct.
5299 Otherwise this is an error.
5300
5301 Oh what a horrid tangled web we weave. I wonder if MS consciously
5302 took this from Plan 9 or if it was an accident of implementation
5303 that took root before someone noticed the bug... */
5304
5305 tree type = declspecs->type;
5306 bool type_ok = (TREE_CODE (type) == RECORD_TYPE
5307 || TREE_CODE (type) == UNION_TYPE);
5308 bool ok = false;
5309
5310 if (type_ok
5311 && (flag_ms_extensions || !declspecs->typedef_p))
5312 {
5313 if (flag_ms_extensions)
5314 ok = true;
5315 else if (flag_iso)
5316 ok = false;
5317 else if (TYPE_NAME (type) == NULL)
5318 ok = true;
5319 else
5320 ok = false;
5321 }
5322 if (!ok)
5323 {
5324 pedwarn ("declaration does not declare anything");
5325 return NULL_TREE;
5326 }
5327 if (pedantic)
5328 pedwarn ("ISO C doesn%'t support unnamed structs/unions");
5329 }
5330
5331 value = grokdeclarator (declarator, declspecs, FIELD, false,
5332 width ? &width : NULL);
5333
5334 finish_decl (value, NULL_TREE, NULL_TREE);
5335 DECL_INITIAL (value) = width;
5336
5337 return value;
5338 }
5339
5340 /* Generate an error for any duplicate field names in FIELDLIST. Munge
5341 the list such that this does not present a problem later. */
5342
5343 static void
detect_field_duplicates(tree fieldlist)5344 detect_field_duplicates (tree fieldlist)
5345 {
5346 tree x, y;
5347 int timeout = 10;
5348
5349 /* First, see if there are more than "a few" fields.
5350 This is trivially true if there are zero or one fields. */
5351 if (!fieldlist)
5352 return;
5353 x = TREE_CHAIN (fieldlist);
5354 if (!x)
5355 return;
5356 do {
5357 timeout--;
5358 x = TREE_CHAIN (x);
5359 } while (timeout > 0 && x);
5360
5361 /* If there were "few" fields, avoid the overhead of allocating
5362 a hash table. Instead just do the nested traversal thing. */
5363 if (timeout > 0)
5364 {
5365 for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
5366 if (DECL_NAME (x))
5367 {
5368 for (y = fieldlist; y != x; y = TREE_CHAIN (y))
5369 if (DECL_NAME (y) == DECL_NAME (x))
5370 {
5371 error ("duplicate member %q+D", x);
5372 DECL_NAME (x) = NULL_TREE;
5373 }
5374 }
5375 }
5376 else
5377 {
5378 htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
5379 void **slot;
5380
5381 for (x = fieldlist; x ; x = TREE_CHAIN (x))
5382 if ((y = DECL_NAME (x)) != 0)
5383 {
5384 slot = htab_find_slot (htab, y, INSERT);
5385 if (*slot)
5386 {
5387 error ("duplicate member %q+D", x);
5388 DECL_NAME (x) = NULL_TREE;
5389 }
5390 *slot = y;
5391 }
5392
5393 htab_delete (htab);
5394 }
5395 }
5396
5397 /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
5398 FIELDLIST is a chain of FIELD_DECL nodes for the fields.
5399 ATTRIBUTES are attributes to be applied to the structure. */
5400
5401 tree
finish_struct(tree t,tree fieldlist,tree attributes)5402 finish_struct (tree t, tree fieldlist, tree attributes)
5403 {
5404 tree x;
5405 bool toplevel = file_scope == current_scope;
5406 int saw_named_field;
5407
5408 /* If this type was previously laid out as a forward reference,
5409 make sure we lay it out again. */
5410
5411 TYPE_SIZE (t) = 0;
5412
5413 decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5414
5415 if (pedantic)
5416 {
5417 for (x = fieldlist; x; x = TREE_CHAIN (x))
5418 if (DECL_NAME (x) != 0)
5419 break;
5420
5421 if (x == 0)
5422 {
5423 if (TREE_CODE (t) == UNION_TYPE)
5424 {
5425 if (fieldlist)
5426 pedwarn ("union has no named members");
5427 else
5428 pedwarn ("union has no members");
5429 }
5430 else
5431 {
5432 if (fieldlist)
5433 pedwarn ("struct has no named members");
5434 else
5435 pedwarn ("struct has no members");
5436 }
5437 }
5438 }
5439
5440 /* Install struct as DECL_CONTEXT of each field decl.
5441 Also process specified field sizes, found in the DECL_INITIAL,
5442 storing 0 there after the type has been changed to precision equal
5443 to its width, rather than the precision of the specified standard
5444 type. (Correct layout requires the original type to have been preserved
5445 until now.) */
5446
5447 saw_named_field = 0;
5448 for (x = fieldlist; x; x = TREE_CHAIN (x))
5449 {
5450 if (TREE_TYPE (x) == error_mark_node)
5451 continue;
5452
5453 DECL_CONTEXT (x) = t;
5454
5455 if (TYPE_PACKED (t) && TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
5456 DECL_PACKED (x) = 1;
5457
5458 /* If any field is const, the structure type is pseudo-const. */
5459 if (TREE_READONLY (x))
5460 C_TYPE_FIELDS_READONLY (t) = 1;
5461 else
5462 {
5463 /* A field that is pseudo-const makes the structure likewise. */
5464 tree t1 = TREE_TYPE (x);
5465 while (TREE_CODE (t1) == ARRAY_TYPE)
5466 t1 = TREE_TYPE (t1);
5467 if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
5468 && C_TYPE_FIELDS_READONLY (t1))
5469 C_TYPE_FIELDS_READONLY (t) = 1;
5470 }
5471
5472 /* Any field that is volatile means variables of this type must be
5473 treated in some ways as volatile. */
5474 if (TREE_THIS_VOLATILE (x))
5475 C_TYPE_FIELDS_VOLATILE (t) = 1;
5476
5477 /* Any field of nominal variable size implies structure is too. */
5478 if (C_DECL_VARIABLE_SIZE (x))
5479 C_TYPE_VARIABLE_SIZE (t) = 1;
5480
5481 if (DECL_INITIAL (x))
5482 {
5483 unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
5484 DECL_SIZE (x) = bitsize_int (width);
5485 DECL_BIT_FIELD (x) = 1;
5486 SET_DECL_C_BIT_FIELD (x);
5487 }
5488
5489 /* Detect flexible array member in an invalid context. */
5490 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
5491 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
5492 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
5493 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
5494 {
5495 if (TREE_CODE (t) == UNION_TYPE)
5496 {
5497 error ("%Jflexible array member in union", x);
5498 TREE_TYPE (x) = error_mark_node;
5499 }
5500 else if (TREE_CHAIN (x) != NULL_TREE)
5501 {
5502 error ("%Jflexible array member not at end of struct", x);
5503 TREE_TYPE (x) = error_mark_node;
5504 }
5505 else if (!saw_named_field)
5506 {
5507 error ("%Jflexible array member in otherwise empty struct", x);
5508 TREE_TYPE (x) = error_mark_node;
5509 }
5510 }
5511
5512 if (pedantic && !in_system_header && TREE_CODE (t) == RECORD_TYPE
5513 && flexible_array_type_p (TREE_TYPE (x)))
5514 pedwarn ("%Jinvalid use of structure with flexible array member", x);
5515
5516 if (DECL_NAME (x))
5517 saw_named_field = 1;
5518 }
5519
5520 detect_field_duplicates (fieldlist);
5521
5522 /* Now we have the nearly final fieldlist. Record it,
5523 then lay out the structure or union (including the fields). */
5524
5525 TYPE_FIELDS (t) = fieldlist;
5526
5527 layout_type (t);
5528
5529 /* Give bit-fields their proper types. */
5530 {
5531 tree *fieldlistp = &fieldlist;
5532 while (*fieldlistp)
5533 if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
5534 && TREE_TYPE (*fieldlistp) != error_mark_node)
5535 {
5536 unsigned HOST_WIDE_INT width
5537 = tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
5538 tree type = TREE_TYPE (*fieldlistp);
5539 if (width != TYPE_PRECISION (type))
5540 {
5541 TREE_TYPE (*fieldlistp)
5542 = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
5543 DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
5544 }
5545 DECL_INITIAL (*fieldlistp) = 0;
5546 }
5547 else
5548 fieldlistp = &TREE_CHAIN (*fieldlistp);
5549 }
5550
5551 /* Now we have the truly final field list.
5552 Store it in this type and in the variants. */
5553
5554 TYPE_FIELDS (t) = fieldlist;
5555
5556 /* If there are lots of fields, sort so we can look through them fast.
5557 We arbitrarily consider 16 or more elts to be "a lot". */
5558
5559 {
5560 int len = 0;
5561
5562 for (x = fieldlist; x; x = TREE_CHAIN (x))
5563 {
5564 if (len > 15 || DECL_NAME (x) == NULL)
5565 break;
5566 len += 1;
5567 }
5568
5569 if (len > 15)
5570 {
5571 tree *field_array;
5572 struct lang_type *space;
5573 struct sorted_fields_type *space2;
5574
5575 len += list_length (x);
5576
5577 /* Use the same allocation policy here that make_node uses, to
5578 ensure that this lives as long as the rest of the struct decl.
5579 All decls in an inline function need to be saved. */
5580
5581 space = GGC_CNEW (struct lang_type);
5582 space2 = GGC_NEWVAR (struct sorted_fields_type,
5583 sizeof (struct sorted_fields_type) + len * sizeof (tree));
5584
5585 len = 0;
5586 space->s = space2;
5587 field_array = &space2->elts[0];
5588 for (x = fieldlist; x; x = TREE_CHAIN (x))
5589 {
5590 field_array[len++] = x;
5591
5592 /* If there is anonymous struct or union, break out of the loop. */
5593 if (DECL_NAME (x) == NULL)
5594 break;
5595 }
5596 /* Found no anonymous struct/union. Add the TYPE_LANG_SPECIFIC. */
5597 if (x == NULL)
5598 {
5599 TYPE_LANG_SPECIFIC (t) = space;
5600 TYPE_LANG_SPECIFIC (t)->s->len = len;
5601 field_array = TYPE_LANG_SPECIFIC (t)->s->elts;
5602 qsort (field_array, len, sizeof (tree), field_decl_cmp);
5603 }
5604 }
5605 }
5606
5607 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
5608 {
5609 TYPE_FIELDS (x) = TYPE_FIELDS (t);
5610 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
5611 TYPE_ALIGN (x) = TYPE_ALIGN (t);
5612 TYPE_USER_ALIGN (x) = TYPE_USER_ALIGN (t);
5613 C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
5614 C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
5615 C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
5616 }
5617
5618 /* If this was supposed to be a transparent union, but we can't
5619 make it one, warn and turn off the flag. */
5620 if (TREE_CODE (t) == UNION_TYPE
5621 && TYPE_TRANSPARENT_UNION (t)
5622 && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))))
5623 {
5624 TYPE_TRANSPARENT_UNION (t) = 0;
5625 warning (0, "union cannot be made transparent");
5626 }
5627
5628 /* If this structure or union completes the type of any previous
5629 variable declaration, lay it out and output its rtl. */
5630 for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
5631 x;
5632 x = TREE_CHAIN (x))
5633 {
5634 tree decl = TREE_VALUE (x);
5635 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
5636 layout_array_type (TREE_TYPE (decl));
5637 if (TREE_CODE (decl) != TYPE_DECL)
5638 {
5639 layout_decl (decl, 0);
5640 if (c_dialect_objc ())
5641 objc_check_decl (decl);
5642 rest_of_decl_compilation (decl, toplevel, 0);
5643 if (!toplevel)
5644 expand_decl (decl);
5645 }
5646 }
5647 C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
5648
5649 /* Finish debugging output for this type. */
5650 rest_of_type_compilation (t, toplevel);
5651
5652 /* If we're inside a function proper, i.e. not file-scope and not still
5653 parsing parameters, then arrange for the size of a variable sized type
5654 to be bound now. */
5655 if (cur_stmt_list && variably_modified_type_p (t, NULL))
5656 add_stmt (build_stmt (DECL_EXPR, build_decl (TYPE_DECL, NULL, t)));
5657
5658 return t;
5659 }
5660
5661 /* Lay out the type T, and its element type, and so on. */
5662
5663 static void
layout_array_type(tree t)5664 layout_array_type (tree t)
5665 {
5666 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
5667 layout_array_type (TREE_TYPE (t));
5668 layout_type (t);
5669 }
5670
5671 /* Begin compiling the definition of an enumeration type.
5672 NAME is its name (or null if anonymous).
5673 Returns the type object, as yet incomplete.
5674 Also records info about it so that build_enumerator
5675 may be used to declare the individual values as they are read. */
5676
5677 tree
start_enum(tree name)5678 start_enum (tree name)
5679 {
5680 tree enumtype = 0;
5681
5682 /* If this is the real definition for a previous forward reference,
5683 fill in the contents in the same object that used to be the
5684 forward reference. */
5685
5686 if (name != 0)
5687 enumtype = lookup_tag (ENUMERAL_TYPE, name, 1);
5688
5689 if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
5690 {
5691 enumtype = make_node (ENUMERAL_TYPE);
5692 pushtag (name, enumtype);
5693 }
5694
5695 if (C_TYPE_BEING_DEFINED (enumtype))
5696 error ("nested redefinition of %<enum %E%>", name);
5697
5698 C_TYPE_BEING_DEFINED (enumtype) = 1;
5699
5700 if (TYPE_VALUES (enumtype) != 0)
5701 {
5702 /* This enum is a named one that has been declared already. */
5703 error ("redeclaration of %<enum %E%>", name);
5704
5705 /* Completely replace its old definition.
5706 The old enumerators remain defined, however. */
5707 TYPE_VALUES (enumtype) = 0;
5708 }
5709
5710 enum_next_value = integer_zero_node;
5711 enum_overflow = 0;
5712
5713 if (flag_short_enums)
5714 TYPE_PACKED (enumtype) = 1;
5715
5716 return enumtype;
5717 }
5718
5719 /* After processing and defining all the values of an enumeration type,
5720 install their decls in the enumeration type and finish it off.
5721 ENUMTYPE is the type object, VALUES a list of decl-value pairs,
5722 and ATTRIBUTES are the specified attributes.
5723 Returns ENUMTYPE. */
5724
5725 tree
finish_enum(tree enumtype,tree values,tree attributes)5726 finish_enum (tree enumtype, tree values, tree attributes)
5727 {
5728 tree pair, tem;
5729 tree minnode = 0, maxnode = 0;
5730 int precision, unsign;
5731 bool toplevel = (file_scope == current_scope);
5732 struct lang_type *lt;
5733
5734 decl_attributes (&enumtype, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5735
5736 /* Calculate the maximum value of any enumerator in this type. */
5737
5738 if (values == error_mark_node)
5739 minnode = maxnode = integer_zero_node;
5740 else
5741 {
5742 minnode = maxnode = TREE_VALUE (values);
5743 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
5744 {
5745 tree value = TREE_VALUE (pair);
5746 if (tree_int_cst_lt (maxnode, value))
5747 maxnode = value;
5748 if (tree_int_cst_lt (value, minnode))
5749 minnode = value;
5750 }
5751 }
5752
5753 /* Construct the final type of this enumeration. It is the same
5754 as one of the integral types - the narrowest one that fits, except
5755 that normally we only go as narrow as int - and signed iff any of
5756 the values are negative. */
5757 unsign = (tree_int_cst_sgn (minnode) >= 0);
5758 precision = MAX (min_precision (minnode, unsign),
5759 min_precision (maxnode, unsign));
5760
5761 if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
5762 {
5763 tem = c_common_type_for_size (precision, unsign);
5764 if (tem == NULL)
5765 {
5766 warning (0, "enumeration values exceed range of largest integer");
5767 tem = long_long_integer_type_node;
5768 }
5769 }
5770 else
5771 tem = unsign ? unsigned_type_node : integer_type_node;
5772
5773 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (tem);
5774 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (tem);
5775 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (tem);
5776 TYPE_SIZE (enumtype) = 0;
5777
5778 /* If the precision of the type was specific with an attribute and it
5779 was too small, give an error. Otherwise, use it. */
5780 if (TYPE_PRECISION (enumtype))
5781 {
5782 if (precision > TYPE_PRECISION (enumtype))
5783 error ("specified mode too small for enumeral values");
5784 }
5785 else
5786 TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
5787
5788 layout_type (enumtype);
5789
5790 if (values != error_mark_node)
5791 {
5792 /* Change the type of the enumerators to be the enum type. We
5793 need to do this irrespective of the size of the enum, for
5794 proper type checking. Replace the DECL_INITIALs of the
5795 enumerators, and the value slots of the list, with copies
5796 that have the enum type; they cannot be modified in place
5797 because they may be shared (e.g. integer_zero_node) Finally,
5798 change the purpose slots to point to the names of the decls. */
5799 for (pair = values; pair; pair = TREE_CHAIN (pair))
5800 {
5801 tree enu = TREE_PURPOSE (pair);
5802 tree ini = DECL_INITIAL (enu);
5803
5804 TREE_TYPE (enu) = enumtype;
5805
5806 /* The ISO C Standard mandates enumerators to have type int,
5807 even though the underlying type of an enum type is
5808 unspecified. Here we convert any enumerators that fit in
5809 an int to type int, to avoid promotions to unsigned types
5810 when comparing integers with enumerators that fit in the
5811 int range. When -pedantic is given, build_enumerator()
5812 would have already taken care of those that don't fit. */
5813 if (int_fits_type_p (ini, integer_type_node))
5814 tem = integer_type_node;
5815 else
5816 tem = enumtype;
5817 ini = convert (tem, ini);
5818
5819 DECL_INITIAL (enu) = ini;
5820 TREE_PURPOSE (pair) = DECL_NAME (enu);
5821 TREE_VALUE (pair) = ini;
5822 }
5823
5824 TYPE_VALUES (enumtype) = values;
5825 }
5826
5827 /* Record the min/max values so that we can warn about bit-field
5828 enumerations that are too small for the values. */
5829 lt = GGC_CNEW (struct lang_type);
5830 lt->enum_min = minnode;
5831 lt->enum_max = maxnode;
5832 TYPE_LANG_SPECIFIC (enumtype) = lt;
5833
5834 /* Fix up all variant types of this enum type. */
5835 for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
5836 {
5837 if (tem == enumtype)
5838 continue;
5839 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
5840 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
5841 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
5842 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
5843 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
5844 TYPE_MODE (tem) = TYPE_MODE (enumtype);
5845 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
5846 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
5847 TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
5848 TYPE_UNSIGNED (tem) = TYPE_UNSIGNED (enumtype);
5849 TYPE_LANG_SPECIFIC (tem) = TYPE_LANG_SPECIFIC (enumtype);
5850 }
5851
5852 /* Finish debugging output for this type. */
5853 rest_of_type_compilation (enumtype, toplevel);
5854
5855 return enumtype;
5856 }
5857
5858 /* Build and install a CONST_DECL for one value of the
5859 current enumeration type (one that was begun with start_enum).
5860 Return a tree-list containing the CONST_DECL and its value.
5861 Assignment of sequential values by default is handled here. */
5862
5863 tree
build_enumerator(tree name,tree value)5864 build_enumerator (tree name, tree value)
5865 {
5866 tree decl, type;
5867
5868 /* Validate and default VALUE. */
5869
5870 if (value != 0)
5871 {
5872 /* Don't issue more errors for error_mark_node (i.e. an
5873 undeclared identifier) - just ignore the value expression. */
5874 if (value == error_mark_node)
5875 value = 0;
5876 else if (!INTEGRAL_TYPE_P (TREE_TYPE (value))
5877 || TREE_CODE (value) != INTEGER_CST)
5878 {
5879 error ("enumerator value for %qE is not an integer constant", name);
5880 value = 0;
5881 }
5882 else
5883 {
5884 value = default_conversion (value);
5885 constant_expression_warning (value);
5886 }
5887 }
5888
5889 /* Default based on previous value. */
5890 /* It should no longer be possible to have NON_LVALUE_EXPR
5891 in the default. */
5892 if (value == 0)
5893 {
5894 value = enum_next_value;
5895 if (enum_overflow)
5896 error ("overflow in enumeration values");
5897 }
5898
5899 if (pedantic && !int_fits_type_p (value, integer_type_node))
5900 {
5901 pedwarn ("ISO C restricts enumerator values to range of %<int%>");
5902 /* XXX This causes -pedantic to change the meaning of the program.
5903 Remove? -zw 2004-03-15 */
5904 value = convert (integer_type_node, value);
5905 }
5906
5907 /* Set basis for default for next value. */
5908 enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
5909 enum_overflow = tree_int_cst_lt (enum_next_value, value);
5910
5911 /* Now create a declaration for the enum value name. */
5912
5913 type = TREE_TYPE (value);
5914 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
5915 TYPE_PRECISION (integer_type_node)),
5916 (TYPE_PRECISION (type)
5917 >= TYPE_PRECISION (integer_type_node)
5918 && TYPE_UNSIGNED (type)));
5919
5920 decl = build_decl (CONST_DECL, name, type);
5921 DECL_INITIAL (decl) = convert (type, value);
5922 pushdecl (decl);
5923
5924 return tree_cons (decl, value, NULL_TREE);
5925 }
5926
5927
5928 /* Create the FUNCTION_DECL for a function definition.
5929 DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
5930 the declaration; they describe the function's name and the type it returns,
5931 but twisted together in a fashion that parallels the syntax of C.
5932
5933 This function creates a binding context for the function body
5934 as well as setting up the FUNCTION_DECL in current_function_decl.
5935
5936 Returns 1 on success. If the DECLARATOR is not suitable for a function
5937 (it defines a datum instead), we return 0, which tells
5938 yyparse to report a parse error. */
5939
5940 int
start_function(struct c_declspecs * declspecs,struct c_declarator * declarator,tree attributes)5941 start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
5942 tree attributes)
5943 {
5944 tree decl1, old_decl;
5945 tree restype, resdecl;
5946 struct c_label_context_se *nstack_se;
5947 struct c_label_context_vm *nstack_vm;
5948
5949 current_function_returns_value = 0; /* Assume, until we see it does. */
5950 current_function_returns_null = 0;
5951 current_function_returns_abnormally = 0;
5952 warn_about_return_type = 0;
5953 current_extern_inline = 0;
5954 c_switch_stack = NULL;
5955
5956 nstack_se = XOBNEW (&parser_obstack, struct c_label_context_se);
5957 nstack_se->labels_def = NULL;
5958 nstack_se->labels_used = NULL;
5959 nstack_se->next = label_context_stack_se;
5960 label_context_stack_se = nstack_se;
5961
5962 nstack_vm = XOBNEW (&parser_obstack, struct c_label_context_vm);
5963 nstack_vm->labels_def = NULL;
5964 nstack_vm->labels_used = NULL;
5965 nstack_vm->scope = 0;
5966 nstack_vm->next = label_context_stack_vm;
5967 label_context_stack_vm = nstack_vm;
5968
5969 /* Indicate no valid break/continue context by setting these variables
5970 to some non-null, non-label value. We'll notice and emit the proper
5971 error message in c_finish_bc_stmt. */
5972 c_break_label = c_cont_label = size_zero_node;
5973
5974 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, true, NULL);
5975
5976 /* If the declarator is not suitable for a function definition,
5977 cause a syntax error. */
5978 if (decl1 == 0)
5979 {
5980 label_context_stack_se = label_context_stack_se->next;
5981 label_context_stack_vm = label_context_stack_vm->next;
5982 return 0;
5983 }
5984
5985 decl_attributes (&decl1, attributes, 0);
5986
5987 if (DECL_DECLARED_INLINE_P (decl1)
5988 && DECL_UNINLINABLE (decl1)
5989 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
5990 warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
5991 decl1);
5992
5993 announce_function (decl1);
5994
5995 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl1))))
5996 {
5997 error ("return type is an incomplete type");
5998 /* Make it return void instead. */
5999 TREE_TYPE (decl1)
6000 = build_function_type (void_type_node,
6001 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
6002 }
6003
6004 if (warn_about_return_type)
6005 pedwarn_c99 ("return type defaults to %<int%>");
6006
6007 /* Make the init_value nonzero so pushdecl knows this is not tentative.
6008 error_mark_node is replaced below (in pop_scope) with the BLOCK. */
6009 DECL_INITIAL (decl1) = error_mark_node;
6010
6011 /* If this definition isn't a prototype and we had a prototype declaration
6012 before, copy the arg type info from that prototype. */
6013 old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope);
6014 current_function_prototype_locus = UNKNOWN_LOCATION;
6015 current_function_prototype_built_in = false;
6016 current_function_prototype_arg_types = NULL_TREE;
6017 if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
6018 {
6019 if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
6020 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
6021 TREE_TYPE (TREE_TYPE (old_decl))))
6022 {
6023 TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
6024 TREE_TYPE (decl1));
6025 current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
6026 current_function_prototype_built_in
6027 = C_DECL_BUILTIN_PROTOTYPE (old_decl);
6028 current_function_prototype_arg_types
6029 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
6030 }
6031 if (TREE_PUBLIC (decl1))
6032 {
6033 /* If there is an external prototype declaration of this
6034 function, record its location but do not copy information
6035 to this decl. This may be an invisible declaration
6036 (built-in or in a scope which has finished) or simply
6037 have more refined argument types than any declaration
6038 found above. */
6039 struct c_binding *b;
6040 for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
6041 if (B_IN_SCOPE (b, external_scope))
6042 break;
6043 if (b)
6044 {
6045 tree ext_decl, ext_type;
6046 ext_decl = b->decl;
6047 ext_type = b->type ? b->type : TREE_TYPE (ext_decl);
6048 if (TREE_CODE (ext_type) == FUNCTION_TYPE
6049 && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
6050 TREE_TYPE (ext_type)))
6051 {
6052 current_function_prototype_locus
6053 = DECL_SOURCE_LOCATION (ext_decl);
6054 current_function_prototype_built_in
6055 = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
6056 current_function_prototype_arg_types
6057 = TYPE_ARG_TYPES (ext_type);
6058 }
6059 }
6060 }
6061 }
6062
6063 /* Optionally warn of old-fashioned def with no previous prototype. */
6064 if (warn_strict_prototypes
6065 && old_decl != error_mark_node
6066 && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
6067 && C_DECL_ISNT_PROTOTYPE (old_decl))
6068 warning (OPT_Wstrict_prototypes,
6069 "function declaration isn%'t a prototype");
6070 /* Optionally warn of any global def with no previous prototype. */
6071 else if (warn_missing_prototypes
6072 && old_decl != error_mark_node
6073 && TREE_PUBLIC (decl1)
6074 && !MAIN_NAME_P (DECL_NAME (decl1))
6075 && C_DECL_ISNT_PROTOTYPE (old_decl))
6076 warning (OPT_Wmissing_prototypes, "no previous prototype for %q+D", decl1);
6077 /* Optionally warn of any def with no previous prototype
6078 if the function has already been used. */
6079 else if (warn_missing_prototypes
6080 && old_decl != 0
6081 && old_decl != error_mark_node
6082 && TREE_USED (old_decl)
6083 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
6084 warning (OPT_Wmissing_prototypes,
6085 "%q+D was used with no prototype before its definition", decl1);
6086 /* Optionally warn of any global def with no previous declaration. */
6087 else if (warn_missing_declarations
6088 && TREE_PUBLIC (decl1)
6089 && old_decl == 0
6090 && !MAIN_NAME_P (DECL_NAME (decl1)))
6091 warning (OPT_Wmissing_declarations, "no previous declaration for %q+D",
6092 decl1);
6093 /* Optionally warn of any def with no previous declaration
6094 if the function has already been used. */
6095 else if (warn_missing_declarations
6096 && old_decl != 0
6097 && old_decl != error_mark_node
6098 && TREE_USED (old_decl)
6099 && C_DECL_IMPLICIT (old_decl))
6100 warning (OPT_Wmissing_declarations,
6101 "%q+D was used with no declaration before its definition", decl1);
6102
6103 /* This is a definition, not a reference.
6104 So normally clear DECL_EXTERNAL.
6105 However, `extern inline' acts like a declaration
6106 except for defining how to inline. So set DECL_EXTERNAL in that case. */
6107 DECL_EXTERNAL (decl1) = current_extern_inline;
6108
6109 /* This function exists in static storage.
6110 (This does not mean `static' in the C sense!) */
6111 TREE_STATIC (decl1) = 1;
6112
6113 /* A nested function is not global. */
6114 if (current_function_decl != 0)
6115 TREE_PUBLIC (decl1) = 0;
6116
6117 /* This is the earliest point at which we might know the assembler
6118 name of the function. Thus, if it's set before this, die horribly. */
6119 gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl1));
6120
6121 /* If #pragma weak was used, mark the decl weak now. */
6122 if (current_scope == file_scope)
6123 maybe_apply_pragma_weak (decl1);
6124
6125 /* Warn for unlikely, improbable, or stupid declarations of `main'. */
6126 if (warn_main > 0 && MAIN_NAME_P (DECL_NAME (decl1)))
6127 {
6128 tree args;
6129 int argct = 0;
6130
6131 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
6132 != integer_type_node)
6133 pedwarn ("return type of %q+D is not %<int%>", decl1);
6134
6135 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
6136 args = TREE_CHAIN (args))
6137 {
6138 tree type = args ? TREE_VALUE (args) : 0;
6139
6140 if (type == void_type_node)
6141 break;
6142
6143 ++argct;
6144 switch (argct)
6145 {
6146 case 1:
6147 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
6148 pedwarn ("first argument of %q+D should be %<int%>", decl1);
6149 break;
6150
6151 case 2:
6152 if (TREE_CODE (type) != POINTER_TYPE
6153 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6154 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6155 != char_type_node))
6156 pedwarn ("second argument of %q+D should be %<char **%>",
6157 decl1);
6158 break;
6159
6160 case 3:
6161 if (TREE_CODE (type) != POINTER_TYPE
6162 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
6163 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
6164 != char_type_node))
6165 pedwarn ("third argument of %q+D should probably be "
6166 "%<char **%>", decl1);
6167 break;
6168 }
6169 }
6170
6171 /* It is intentional that this message does not mention the third
6172 argument because it's only mentioned in an appendix of the
6173 standard. */
6174 if (argct > 0 && (argct < 2 || argct > 3))
6175 pedwarn ("%q+D takes only zero or two arguments", decl1);
6176
6177 if (!TREE_PUBLIC (decl1))
6178 pedwarn ("%q+D is normally a non-static function", decl1);
6179 }
6180
6181 /* Record the decl so that the function name is defined.
6182 If we already have a decl for this name, and it is a FUNCTION_DECL,
6183 use the old decl. */
6184
6185 current_function_decl = pushdecl (decl1);
6186
6187 push_scope ();
6188 declare_parm_level ();
6189
6190 restype = TREE_TYPE (TREE_TYPE (current_function_decl));
6191 /* Promote the value to int before returning it. */
6192 if (c_promoting_integer_type_p (restype))
6193 {
6194 /* It retains unsignedness if not really getting wider. */
6195 if (TYPE_UNSIGNED (restype)
6196 && (TYPE_PRECISION (restype)
6197 == TYPE_PRECISION (integer_type_node)))
6198 restype = unsigned_type_node;
6199 else
6200 restype = integer_type_node;
6201 }
6202
6203 resdecl = build_decl (RESULT_DECL, NULL_TREE, restype);
6204 DECL_ARTIFICIAL (resdecl) = 1;
6205 DECL_IGNORED_P (resdecl) = 1;
6206 DECL_RESULT (current_function_decl) = resdecl;
6207
6208 start_fname_decls ();
6209
6210 return 1;
6211 }
6212
6213 /* Subroutine of store_parm_decls which handles new-style function
6214 definitions (prototype format). The parms already have decls, so we
6215 need only record them as in effect and complain if any redundant
6216 old-style parm decls were written. */
6217 static void
store_parm_decls_newstyle(tree fndecl,const struct c_arg_info * arg_info)6218 store_parm_decls_newstyle (tree fndecl, const struct c_arg_info *arg_info)
6219 {
6220 tree decl;
6221
6222 if (current_scope->bindings)
6223 {
6224 error ("%Jold-style parameter declarations in prototyped "
6225 "function definition", fndecl);
6226
6227 /* Get rid of the old-style declarations. */
6228 pop_scope ();
6229 push_scope ();
6230 }
6231 /* Don't issue this warning for nested functions, and don't issue this
6232 warning if we got here because ARG_INFO_TYPES was error_mark_node
6233 (this happens when a function definition has just an ellipsis in
6234 its parameter list). */
6235 else if (!in_system_header && !current_function_scope
6236 && arg_info->types != error_mark_node)
6237 warning (OPT_Wtraditional,
6238 "%Jtraditional C rejects ISO C style function definitions",
6239 fndecl);
6240
6241 /* Now make all the parameter declarations visible in the function body.
6242 We can bypass most of the grunt work of pushdecl. */
6243 for (decl = arg_info->parms; decl; decl = TREE_CHAIN (decl))
6244 {
6245 DECL_CONTEXT (decl) = current_function_decl;
6246 if (DECL_NAME (decl))
6247 {
6248 bind (DECL_NAME (decl), decl, current_scope,
6249 /*invisible=*/false, /*nested=*/false);
6250 if (!TREE_USED (decl))
6251 warn_if_shadowing (decl);
6252 }
6253 else
6254 error ("%Jparameter name omitted", decl);
6255 }
6256
6257 /* Record the parameter list in the function declaration. */
6258 DECL_ARGUMENTS (fndecl) = arg_info->parms;
6259
6260 /* Now make all the ancillary declarations visible, likewise. */
6261 for (decl = arg_info->others; decl; decl = TREE_CHAIN (decl))
6262 {
6263 DECL_CONTEXT (decl) = current_function_decl;
6264 if (DECL_NAME (decl))
6265 bind (DECL_NAME (decl), decl, current_scope,
6266 /*invisible=*/false, /*nested=*/false);
6267 }
6268
6269 /* And all the tag declarations. */
6270 for (decl = arg_info->tags; decl; decl = TREE_CHAIN (decl))
6271 if (TREE_PURPOSE (decl))
6272 bind (TREE_PURPOSE (decl), TREE_VALUE (decl), current_scope,
6273 /*invisible=*/false, /*nested=*/false);
6274 }
6275
6276 /* Subroutine of store_parm_decls which handles old-style function
6277 definitions (separate parameter list and declarations). */
6278
6279 static void
store_parm_decls_oldstyle(tree fndecl,const struct c_arg_info * arg_info)6280 store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
6281 {
6282 struct c_binding *b;
6283 tree parm, decl, last;
6284 tree parmids = arg_info->parms;
6285 struct pointer_set_t *seen_args = pointer_set_create ();
6286
6287 if (!in_system_header)
6288 warning (OPT_Wold_style_definition, "%Jold-style function definition",
6289 fndecl);
6290
6291 /* Match each formal parameter name with its declaration. Save each
6292 decl in the appropriate TREE_PURPOSE slot of the parmids chain. */
6293 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
6294 {
6295 if (TREE_VALUE (parm) == 0)
6296 {
6297 error ("%Jparameter name missing from parameter list", fndecl);
6298 TREE_PURPOSE (parm) = 0;
6299 continue;
6300 }
6301
6302 b = I_SYMBOL_BINDING (TREE_VALUE (parm));
6303 if (b && B_IN_CURRENT_SCOPE (b))
6304 {
6305 decl = b->decl;
6306 /* If we got something other than a PARM_DECL it is an error. */
6307 if (TREE_CODE (decl) != PARM_DECL)
6308 error ("%q+D declared as a non-parameter", decl);
6309 /* If the declaration is already marked, we have a duplicate
6310 name. Complain and ignore the duplicate. */
6311 else if (pointer_set_contains (seen_args, decl))
6312 {
6313 error ("multiple parameters named %q+D", decl);
6314 TREE_PURPOSE (parm) = 0;
6315 continue;
6316 }
6317 /* If the declaration says "void", complain and turn it into
6318 an int. */
6319 else if (VOID_TYPE_P (TREE_TYPE (decl)))
6320 {
6321 error ("parameter %q+D declared with void type", decl);
6322 TREE_TYPE (decl) = integer_type_node;
6323 DECL_ARG_TYPE (decl) = integer_type_node;
6324 layout_decl (decl, 0);
6325 }
6326 warn_if_shadowing (decl);
6327 }
6328 /* If no declaration found, default to int. */
6329 else
6330 {
6331 decl = build_decl (PARM_DECL, TREE_VALUE (parm), integer_type_node);
6332 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
6333 DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (fndecl);
6334 pushdecl (decl);
6335 warn_if_shadowing (decl);
6336
6337 if (flag_isoc99)
6338 pedwarn ("type of %q+D defaults to %<int%>", decl);
6339 else if (extra_warnings)
6340 warning (OPT_Wextra, "type of %q+D defaults to %<int%>", decl);
6341 }
6342
6343 TREE_PURPOSE (parm) = decl;
6344 pointer_set_insert (seen_args, decl);
6345 }
6346
6347 /* Now examine the parms chain for incomplete declarations
6348 and declarations with no corresponding names. */
6349
6350 for (b = current_scope->bindings; b; b = b->prev)
6351 {
6352 parm = b->decl;
6353 if (TREE_CODE (parm) != PARM_DECL)
6354 continue;
6355
6356 if (TREE_TYPE (parm) != error_mark_node
6357 && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
6358 {
6359 error ("parameter %q+D has incomplete type", parm);
6360 TREE_TYPE (parm) = error_mark_node;
6361 }
6362
6363 if (!pointer_set_contains (seen_args, parm))
6364 {
6365 error ("declaration for parameter %q+D but no such parameter", parm);
6366
6367 /* Pretend the parameter was not missing.
6368 This gets us to a standard state and minimizes
6369 further error messages. */
6370 parmids = chainon (parmids, tree_cons (parm, 0, 0));
6371 }
6372 }
6373
6374 /* Chain the declarations together in the order of the list of
6375 names. Store that chain in the function decl, replacing the
6376 list of names. Update the current scope to match. */
6377 DECL_ARGUMENTS (fndecl) = 0;
6378
6379 for (parm = parmids; parm; parm = TREE_CHAIN (parm))
6380 if (TREE_PURPOSE (parm))
6381 break;
6382 if (parm && TREE_PURPOSE (parm))
6383 {
6384 last = TREE_PURPOSE (parm);
6385 DECL_ARGUMENTS (fndecl) = last;
6386
6387 for (parm = TREE_CHAIN (parm); parm; parm = TREE_CHAIN (parm))
6388 if (TREE_PURPOSE (parm))
6389 {
6390 TREE_CHAIN (last) = TREE_PURPOSE (parm);
6391 last = TREE_PURPOSE (parm);
6392 }
6393 TREE_CHAIN (last) = 0;
6394 }
6395
6396 pointer_set_destroy (seen_args);
6397
6398 /* If there was a previous prototype,
6399 set the DECL_ARG_TYPE of each argument according to
6400 the type previously specified, and report any mismatches. */
6401
6402 if (current_function_prototype_arg_types)
6403 {
6404 tree type;
6405 for (parm = DECL_ARGUMENTS (fndecl),
6406 type = current_function_prototype_arg_types;
6407 parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
6408 != void_type_node));
6409 parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
6410 {
6411 if (parm == 0 || type == 0
6412 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
6413 {
6414 if (current_function_prototype_built_in)
6415 warning (0, "number of arguments doesn%'t match "
6416 "built-in prototype");
6417 else
6418 {
6419 error ("number of arguments doesn%'t match prototype");
6420 error ("%Hprototype declaration",
6421 ¤t_function_prototype_locus);
6422 }
6423 break;
6424 }
6425 /* Type for passing arg must be consistent with that
6426 declared for the arg. ISO C says we take the unqualified
6427 type for parameters declared with qualified type. */
6428 if (!comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
6429 TYPE_MAIN_VARIANT (TREE_VALUE (type))))
6430 {
6431 if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
6432 == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
6433 {
6434 /* Adjust argument to match prototype. E.g. a previous
6435 `int foo(float);' prototype causes
6436 `int foo(x) float x; {...}' to be treated like
6437 `int foo(float x) {...}'. This is particularly
6438 useful for argument types like uid_t. */
6439 DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
6440
6441 if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl))
6442 && INTEGRAL_TYPE_P (TREE_TYPE (parm))
6443 && TYPE_PRECISION (TREE_TYPE (parm))
6444 < TYPE_PRECISION (integer_type_node))
6445 DECL_ARG_TYPE (parm) = integer_type_node;
6446
6447 if (pedantic)
6448 {
6449 /* ??? Is it possible to get here with a
6450 built-in prototype or will it always have
6451 been diagnosed as conflicting with an
6452 old-style definition and discarded? */
6453 if (current_function_prototype_built_in)
6454 warning (0, "promoted argument %qD "
6455 "doesn%'t match built-in prototype", parm);
6456 else
6457 {
6458 pedwarn ("promoted argument %qD "
6459 "doesn%'t match prototype", parm);
6460 pedwarn ("%Hprototype declaration",
6461 ¤t_function_prototype_locus);
6462 }
6463 }
6464 }
6465 else
6466 {
6467 if (current_function_prototype_built_in)
6468 warning (0, "argument %qD doesn%'t match "
6469 "built-in prototype", parm);
6470 else
6471 {
6472 error ("argument %qD doesn%'t match prototype", parm);
6473 error ("%Hprototype declaration",
6474 ¤t_function_prototype_locus);
6475 }
6476 }
6477 }
6478 }
6479 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
6480 }
6481
6482 /* Otherwise, create a prototype that would match. */
6483
6484 else
6485 {
6486 tree actual = 0, last = 0, type;
6487
6488 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
6489 {
6490 type = tree_cons (NULL_TREE, DECL_ARG_TYPE (parm), NULL_TREE);
6491 if (last)
6492 TREE_CHAIN (last) = type;
6493 else
6494 actual = type;
6495 last = type;
6496 }
6497 type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
6498 if (last)
6499 TREE_CHAIN (last) = type;
6500 else
6501 actual = type;
6502
6503 /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
6504 of the type of this function, but we need to avoid having this
6505 affect the types of other similarly-typed functions, so we must
6506 first force the generation of an identical (but separate) type
6507 node for the relevant function type. The new node we create
6508 will be a variant of the main variant of the original function
6509 type. */
6510
6511 TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
6512
6513 TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
6514 }
6515 }
6516
6517 /* Store parameter declarations passed in ARG_INFO into the current
6518 function declaration. */
6519
6520 void
store_parm_decls_from(struct c_arg_info * arg_info)6521 store_parm_decls_from (struct c_arg_info *arg_info)
6522 {
6523 current_function_arg_info = arg_info;
6524 store_parm_decls ();
6525 }
6526
6527 /* Store the parameter declarations into the current function declaration.
6528 This is called after parsing the parameter declarations, before
6529 digesting the body of the function.
6530
6531 For an old-style definition, construct a prototype out of the old-style
6532 parameter declarations and inject it into the function's type. */
6533
6534 void
store_parm_decls(void)6535 store_parm_decls (void)
6536 {
6537 tree fndecl = current_function_decl;
6538 bool proto;
6539
6540 /* The argument information block for FNDECL. */
6541 struct c_arg_info *arg_info = current_function_arg_info;
6542 current_function_arg_info = 0;
6543
6544 /* True if this definition is written with a prototype. Note:
6545 despite C99 6.7.5.3p14, we can *not* treat an empty argument
6546 list in a function definition as equivalent to (void) -- an
6547 empty argument list specifies the function has no parameters,
6548 but only (void) sets up a prototype for future calls. */
6549 proto = arg_info->types != 0;
6550
6551 if (proto)
6552 store_parm_decls_newstyle (fndecl, arg_info);
6553 else
6554 store_parm_decls_oldstyle (fndecl, arg_info);
6555
6556 /* The next call to push_scope will be a function body. */
6557
6558 next_is_function_body = true;
6559
6560 /* Write a record describing this function definition to the prototypes
6561 file (if requested). */
6562
6563 gen_aux_info_record (fndecl, 1, 0, proto);
6564
6565 /* Initialize the RTL code for the function. */
6566 allocate_struct_function (fndecl);
6567
6568 /* Begin the statement tree for this function. */
6569 DECL_SAVED_TREE (fndecl) = push_stmt_list ();
6570
6571 /* ??? Insert the contents of the pending sizes list into the function
6572 to be evaluated. The only reason left to have this is
6573 void foo(int n, int array[n++])
6574 because we throw away the array type in favor of a pointer type, and
6575 thus won't naturally see the SAVE_EXPR containing the increment. All
6576 other pending sizes would be handled by gimplify_parameters. */
6577 {
6578 tree t;
6579 for (t = nreverse (get_pending_sizes ()); t ; t = TREE_CHAIN (t))
6580 add_stmt (TREE_VALUE (t));
6581 }
6582
6583 /* Even though we're inside a function body, we still don't want to
6584 call expand_expr to calculate the size of a variable-sized array.
6585 We haven't necessarily assigned RTL to all variables yet, so it's
6586 not safe to try to expand expressions involving them. */
6587 cfun->x_dont_save_pending_sizes_p = 1;
6588 }
6589
6590 /* Handle attribute((warn_unused_result)) on FNDECL and all its nested
6591 functions. */
6592
6593 static void
c_warn_unused_result_recursively(tree fndecl)6594 c_warn_unused_result_recursively (tree fndecl)
6595 {
6596 struct cgraph_node *cgn;
6597
6598 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
6599 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
6600
6601 /* Finalize all nested functions now. */
6602 cgn = cgraph_node (fndecl);
6603 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
6604 c_warn_unused_result_recursively (cgn->decl);
6605 }
6606
6607 /* Finish up a function declaration and compile that function
6608 all the way to assembler language output. The free the storage
6609 for the function definition.
6610
6611 This is called after parsing the body of the function definition. */
6612
6613 void
finish_function(void)6614 finish_function (void)
6615 {
6616 tree fndecl = current_function_decl;
6617
6618 label_context_stack_se = label_context_stack_se->next;
6619 label_context_stack_vm = label_context_stack_vm->next;
6620
6621 if (TREE_CODE (fndecl) == FUNCTION_DECL
6622 && targetm.calls.promote_prototypes (TREE_TYPE (fndecl)))
6623 {
6624 tree args = DECL_ARGUMENTS (fndecl);
6625 for (; args; args = TREE_CHAIN (args))
6626 {
6627 tree type = TREE_TYPE (args);
6628 if (INTEGRAL_TYPE_P (type)
6629 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
6630 DECL_ARG_TYPE (args) = integer_type_node;
6631 }
6632 }
6633
6634 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node)
6635 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
6636
6637 /* Must mark the RESULT_DECL as being in this function. */
6638
6639 if (DECL_RESULT (fndecl) && DECL_RESULT (fndecl) != error_mark_node)
6640 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
6641
6642 if (MAIN_NAME_P (DECL_NAME (fndecl)) && flag_hosted)
6643 {
6644 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
6645 != integer_type_node)
6646 {
6647 /* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
6648 If warn_main is -1 (-Wno-main) we don't want to be warned. */
6649 if (!warn_main)
6650 pedwarn ("return type of %q+D is not %<int%>", fndecl);
6651 }
6652 else
6653 {
6654 if (flag_isoc99)
6655 {
6656 tree stmt = c_finish_return (integer_zero_node);
6657 #ifdef USE_MAPPED_LOCATION
6658 /* Hack. We don't want the middle-end to warn that this return
6659 is unreachable, so we mark its location as special. Using
6660 UNKNOWN_LOCATION has the problem that it gets clobbered in
6661 annotate_one_with_locus. A cleaner solution might be to
6662 ensure ! should_carry_locus_p (stmt), but that needs a flag.
6663 */
6664 SET_EXPR_LOCATION (stmt, BUILTINS_LOCATION);
6665 #else
6666 /* Hack. We don't want the middle-end to warn that this
6667 return is unreachable, so put the statement on the
6668 special line 0. */
6669 annotate_with_file_line (stmt, input_filename, 0);
6670 #endif
6671 }
6672 }
6673 }
6674
6675 /* Tie off the statement tree for this function. */
6676 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
6677
6678 finish_fname_decls ();
6679
6680 /* Complain if there's just no return statement. */
6681 if (warn_return_type
6682 && TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
6683 && !current_function_returns_value && !current_function_returns_null
6684 /* Don't complain if we are no-return. */
6685 && !current_function_returns_abnormally
6686 /* Don't warn for main(). */
6687 && !MAIN_NAME_P (DECL_NAME (fndecl))
6688 /* Or if they didn't actually specify a return type. */
6689 && !C_FUNCTION_IMPLICIT_INT (fndecl)
6690 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
6691 inline function, as we might never be compiled separately. */
6692 && DECL_INLINE (fndecl))
6693 {
6694 warning (OPT_Wreturn_type,
6695 "no return statement in function returning non-void");
6696 TREE_NO_WARNING (fndecl) = 1;
6697 }
6698
6699 /* With just -Wextra, complain only if function returns both with
6700 and without a value. */
6701 if (extra_warnings
6702 && current_function_returns_value
6703 && current_function_returns_null)
6704 warning (OPT_Wextra, "this function may return with or without a value");
6705
6706 /* Store the end of the function, so that we get good line number
6707 info for the epilogue. */
6708 cfun->function_end_locus = input_location;
6709
6710 /* If we don't have ctors/dtors sections, and this is a static
6711 constructor or destructor, it must be recorded now. */
6712 if (DECL_STATIC_CONSTRUCTOR (fndecl)
6713 && !targetm.have_ctors_dtors)
6714 static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
6715 if (DECL_STATIC_DESTRUCTOR (fndecl)
6716 && !targetm.have_ctors_dtors)
6717 static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
6718
6719 /* Finalize the ELF visibility for the function. */
6720 c_determine_visibility (fndecl);
6721
6722 /* Genericize before inlining. Delay genericizing nested functions
6723 until their parent function is genericized. Since finalizing
6724 requires GENERIC, delay that as well. */
6725
6726 if (DECL_INITIAL (fndecl) && DECL_INITIAL (fndecl) != error_mark_node
6727 && !undef_nested_function)
6728 {
6729 if (!decl_function_context (fndecl))
6730 {
6731 c_genericize (fndecl);
6732 c_warn_unused_result_recursively (fndecl);
6733
6734 /* ??? Objc emits functions after finalizing the compilation unit.
6735 This should be cleaned up later and this conditional removed. */
6736 if (cgraph_global_info_ready)
6737 {
6738 c_expand_body (fndecl);
6739 return;
6740 }
6741
6742 cgraph_finalize_function (fndecl, false);
6743 }
6744 else
6745 {
6746 /* Register this function with cgraph just far enough to get it
6747 added to our parent's nested function list. Handy, since the
6748 C front end doesn't have such a list. */
6749 (void) cgraph_node (fndecl);
6750 }
6751 }
6752
6753 if (!decl_function_context (fndecl))
6754 undef_nested_function = false;
6755
6756 /* We're leaving the context of this function, so zap cfun.
6757 It's still in DECL_STRUCT_FUNCTION, and we'll restore it in
6758 tree_rest_of_compilation. */
6759 cfun = NULL;
6760 current_function_decl = NULL;
6761 }
6762
6763 /* Generate the RTL for the body of FNDECL. */
6764
6765 void
c_expand_body(tree fndecl)6766 c_expand_body (tree fndecl)
6767 {
6768
6769 if (!DECL_INITIAL (fndecl)
6770 || DECL_INITIAL (fndecl) == error_mark_node)
6771 return;
6772
6773 tree_rest_of_compilation (fndecl);
6774
6775 if (DECL_STATIC_CONSTRUCTOR (fndecl)
6776 && targetm.have_ctors_dtors)
6777 targetm.asm_out.constructor (XEXP (DECL_RTL (fndecl), 0),
6778 DEFAULT_INIT_PRIORITY);
6779 if (DECL_STATIC_DESTRUCTOR (fndecl)
6780 && targetm.have_ctors_dtors)
6781 targetm.asm_out.destructor (XEXP (DECL_RTL (fndecl), 0),
6782 DEFAULT_INIT_PRIORITY);
6783 }
6784
6785 /* Check the declarations given in a for-loop for satisfying the C99
6786 constraints. */
6787 void
check_for_loop_decls(void)6788 check_for_loop_decls (void)
6789 {
6790 struct c_binding *b;
6791
6792 if (!flag_isoc99)
6793 {
6794 /* If we get here, declarations have been used in a for loop without
6795 the C99 for loop scope. This doesn't make much sense, so don't
6796 allow it. */
6797 error ("%<for%> loop initial declaration used outside C99 mode");
6798 return;
6799 }
6800 /* C99 subclause 6.8.5 paragraph 3:
6801
6802 [#3] The declaration part of a for statement shall only
6803 declare identifiers for objects having storage class auto or
6804 register.
6805
6806 It isn't clear whether, in this sentence, "identifiers" binds to
6807 "shall only declare" or to "objects" - that is, whether all identifiers
6808 declared must be identifiers for objects, or whether the restriction
6809 only applies to those that are. (A question on this in comp.std.c
6810 in November 2000 received no answer.) We implement the strictest
6811 interpretation, to avoid creating an extension which later causes
6812 problems. */
6813
6814 for (b = current_scope->bindings; b; b = b->prev)
6815 {
6816 tree id = b->id;
6817 tree decl = b->decl;
6818
6819 if (!id)
6820 continue;
6821
6822 switch (TREE_CODE (decl))
6823 {
6824 case VAR_DECL:
6825 if (TREE_STATIC (decl))
6826 error ("declaration of static variable %q+D in %<for%> loop "
6827 "initial declaration", decl);
6828 else if (DECL_EXTERNAL (decl))
6829 error ("declaration of %<extern%> variable %q+D in %<for%> loop "
6830 "initial declaration", decl);
6831 break;
6832
6833 case RECORD_TYPE:
6834 error ("%<struct %E%> declared in %<for%> loop initial declaration",
6835 id);
6836 break;
6837 case UNION_TYPE:
6838 error ("%<union %E%> declared in %<for%> loop initial declaration",
6839 id);
6840 break;
6841 case ENUMERAL_TYPE:
6842 error ("%<enum %E%> declared in %<for%> loop initial declaration",
6843 id);
6844 break;
6845 default:
6846 error ("declaration of non-variable %q+D in %<for%> loop "
6847 "initial declaration", decl);
6848 }
6849 }
6850 }
6851
6852 /* Save and reinitialize the variables
6853 used during compilation of a C function. */
6854
6855 void
c_push_function_context(struct function * f)6856 c_push_function_context (struct function *f)
6857 {
6858 struct language_function *p;
6859 p = GGC_NEW (struct language_function);
6860 f->language = p;
6861
6862 p->base.x_stmt_tree = c_stmt_tree;
6863 p->x_break_label = c_break_label;
6864 p->x_cont_label = c_cont_label;
6865 p->x_switch_stack = c_switch_stack;
6866 p->arg_info = current_function_arg_info;
6867 p->returns_value = current_function_returns_value;
6868 p->returns_null = current_function_returns_null;
6869 p->returns_abnormally = current_function_returns_abnormally;
6870 p->warn_about_return_type = warn_about_return_type;
6871 p->extern_inline = current_extern_inline;
6872 }
6873
6874 /* Restore the variables used during compilation of a C function. */
6875
6876 void
c_pop_function_context(struct function * f)6877 c_pop_function_context (struct function *f)
6878 {
6879 struct language_function *p = f->language;
6880
6881 if (DECL_STRUCT_FUNCTION (current_function_decl) == 0
6882 && DECL_SAVED_TREE (current_function_decl) == NULL_TREE)
6883 {
6884 /* Stop pointing to the local nodes about to be freed. */
6885 /* But DECL_INITIAL must remain nonzero so we know this
6886 was an actual function definition. */
6887 DECL_INITIAL (current_function_decl) = error_mark_node;
6888 DECL_ARGUMENTS (current_function_decl) = 0;
6889 }
6890
6891 c_stmt_tree = p->base.x_stmt_tree;
6892 c_break_label = p->x_break_label;
6893 c_cont_label = p->x_cont_label;
6894 c_switch_stack = p->x_switch_stack;
6895 current_function_arg_info = p->arg_info;
6896 current_function_returns_value = p->returns_value;
6897 current_function_returns_null = p->returns_null;
6898 current_function_returns_abnormally = p->returns_abnormally;
6899 warn_about_return_type = p->warn_about_return_type;
6900 current_extern_inline = p->extern_inline;
6901
6902 f->language = NULL;
6903 }
6904
6905 /* Copy the DECL_LANG_SPECIFIC data associated with DECL. */
6906
6907 void
c_dup_lang_specific_decl(tree decl)6908 c_dup_lang_specific_decl (tree decl)
6909 {
6910 struct lang_decl *ld;
6911
6912 if (!DECL_LANG_SPECIFIC (decl))
6913 return;
6914
6915 ld = GGC_NEW (struct lang_decl);
6916 memcpy (ld, DECL_LANG_SPECIFIC (decl), sizeof (struct lang_decl));
6917 DECL_LANG_SPECIFIC (decl) = ld;
6918 }
6919
6920 /* The functions below are required for functionality of doing
6921 function at once processing in the C front end. Currently these
6922 functions are not called from anywhere in the C front end, but as
6923 these changes continue, that will change. */
6924
6925 /* Returns the stmt_tree (if any) to which statements are currently
6926 being added. If there is no active statement-tree, NULL is
6927 returned. */
6928
6929 stmt_tree
current_stmt_tree(void)6930 current_stmt_tree (void)
6931 {
6932 return &c_stmt_tree;
6933 }
6934
6935 /* Nonzero if TYPE is an anonymous union or struct type. Always 0 in
6936 C. */
6937
6938 int
anon_aggr_type_p(tree ARG_UNUSED (node))6939 anon_aggr_type_p (tree ARG_UNUSED (node))
6940 {
6941 return 0;
6942 }
6943
6944 /* Return the global value of T as a symbol. */
6945
6946 tree
identifier_global_value(tree t)6947 identifier_global_value (tree t)
6948 {
6949 struct c_binding *b;
6950
6951 for (b = I_SYMBOL_BINDING (t); b; b = b->shadowed)
6952 if (B_IN_FILE_SCOPE (b) || B_IN_EXTERNAL_SCOPE (b))
6953 return b->decl;
6954
6955 return 0;
6956 }
6957
6958 /* Record a builtin type for C. If NAME is non-NULL, it is the name used;
6959 otherwise the name is found in ridpointers from RID_INDEX. */
6960
6961 void
record_builtin_type(enum rid rid_index,const char * name,tree type)6962 record_builtin_type (enum rid rid_index, const char *name, tree type)
6963 {
6964 tree id, decl;
6965 if (name == 0)
6966 id = ridpointers[(int) rid_index];
6967 else
6968 id = get_identifier (name);
6969 decl = build_decl (TYPE_DECL, id, type);
6970 pushdecl (decl);
6971 if (debug_hooks->type_decl)
6972 debug_hooks->type_decl (decl, false);
6973 }
6974
6975 /* Build the void_list_node (void_type_node having been created). */
6976 tree
build_void_list_node(void)6977 build_void_list_node (void)
6978 {
6979 tree t = build_tree_list (NULL_TREE, void_type_node);
6980 return t;
6981 }
6982
6983 /* Return a c_parm structure with the given SPECS, ATTRS and DECLARATOR. */
6984
6985 struct c_parm *
build_c_parm(struct c_declspecs * specs,tree attrs,struct c_declarator * declarator,tree asmspec)6986 build_c_parm (struct c_declspecs *specs, tree attrs,
6987 struct c_declarator *declarator, tree asmspec)
6988 {
6989 struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
6990 ret->specs = specs;
6991 ret->attrs = attrs;
6992 ret->declarator = declarator;
6993 ret->asmspec = asmspec; /* (TIGCC 20050203) */
6994 return ret;
6995 }
6996
6997 /* Return a declarator with nested attributes. TARGET is the inner
6998 declarator to which these attributes apply. ATTRS are the
6999 attributes. */
7000
7001 struct c_declarator *
build_attrs_declarator(tree attrs,struct c_declarator * target)7002 build_attrs_declarator (tree attrs, struct c_declarator *target)
7003 {
7004 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7005 ret->kind = cdk_attrs;
7006 ret->declarator = target;
7007 ret->u.attrs = attrs;
7008 return ret;
7009 }
7010
7011 /* Return a declarator for a function with arguments specified by ARGS
7012 and return type specified by TARGET. */
7013
7014 struct c_declarator *
build_function_declarator(struct c_arg_info * args,struct c_declarator * target)7015 build_function_declarator (struct c_arg_info *args,
7016 struct c_declarator *target)
7017 {
7018 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7019 ret->kind = cdk_function;
7020 ret->declarator = target;
7021 ret->u.arg_info = args;
7022 return ret;
7023 }
7024
7025 /* Return a declarator for the identifier IDENT (which may be
7026 NULL_TREE for an abstract declarator). */
7027
7028 struct c_declarator *
build_id_declarator(tree ident)7029 build_id_declarator (tree ident)
7030 {
7031 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7032 ret->kind = cdk_id;
7033 ret->declarator = 0;
7034 ret->u.id = ident;
7035 /* Default value - may get reset to a more precise location. */
7036 ret->id_loc = input_location;
7037 return ret;
7038 }
7039
7040 /* Return something to represent absolute declarators containing a *.
7041 TARGET is the absolute declarator that the * contains.
7042 TYPE_QUALS_ATTRS is a structure for type qualifiers and attributes
7043 to apply to the pointer type. */
7044
7045 struct c_declarator *
make_pointer_declarator(struct c_declspecs * type_quals_attrs,struct c_declarator * target)7046 make_pointer_declarator (struct c_declspecs *type_quals_attrs,
7047 struct c_declarator *target)
7048 {
7049 tree attrs;
7050 int quals = 0;
7051 struct c_declarator *itarget = target;
7052 struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
7053 if (type_quals_attrs)
7054 {
7055 attrs = type_quals_attrs->attrs;
7056 quals = quals_from_declspecs (type_quals_attrs);
7057 if (attrs != NULL_TREE)
7058 itarget = build_attrs_declarator (attrs, target);
7059 }
7060 ret->kind = cdk_pointer;
7061 ret->declarator = itarget;
7062 ret->u.pointer_quals = quals;
7063 return ret;
7064 }
7065
7066 /* Return a pointer to a structure for an empty list of declaration
7067 specifiers. */
7068
7069 struct c_declspecs *
build_null_declspecs(void)7070 build_null_declspecs (void)
7071 {
7072 struct c_declspecs *ret = XOBNEW (&parser_obstack, struct c_declspecs);
7073 ret->type = 0;
7074 ret->decl_attr = 0;
7075 ret->attrs = 0;
7076 ret->typespec_word = cts_none;
7077 ret->storage_class = csc_none;
7078 ret->declspecs_seen_p = false;
7079 ret->type_seen_p = false;
7080 ret->non_sc_seen_p = false;
7081 ret->typedef_p = false;
7082 ret->tag_defined_p = false;
7083 ret->explicit_signed_p = false;
7084 ret->deprecated_p = false;
7085 ret->default_int_p = false;
7086 ret->long_p = false;
7087 ret->long_long_p = false;
7088 ret->short_p = false;
7089 ret->signed_p = false;
7090 ret->unsigned_p = false;
7091 ret->complex_p = false;
7092 ret->inline_p = false;
7093 ret->thread_p = false;
7094 ret->const_p = false;
7095 ret->volatile_p = false;
7096 ret->restrict_p = false;
7097 return ret;
7098 }
7099
7100 /* Add the type qualifier QUAL to the declaration specifiers SPECS,
7101 returning SPECS. */
7102
7103 struct c_declspecs *
declspecs_add_qual(struct c_declspecs * specs,tree qual)7104 declspecs_add_qual (struct c_declspecs *specs, tree qual)
7105 {
7106 enum rid i;
7107 bool dupe = false;
7108 specs->non_sc_seen_p = true;
7109 specs->declspecs_seen_p = true;
7110 gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
7111 && C_IS_RESERVED_WORD (qual));
7112 i = C_RID_CODE (qual);
7113 switch (i)
7114 {
7115 case RID_CONST:
7116 dupe = specs->const_p;
7117 specs->const_p = true;
7118 break;
7119 case RID_VOLATILE:
7120 dupe = specs->volatile_p;
7121 specs->volatile_p = true;
7122 break;
7123 case RID_RESTRICT:
7124 dupe = specs->restrict_p;
7125 specs->restrict_p = true;
7126 break;
7127 default:
7128 gcc_unreachable ();
7129 }
7130 if (dupe && pedantic && !flag_isoc99)
7131 pedwarn ("duplicate %qE", qual);
7132 return specs;
7133 }
7134
7135 /* Add the type specifier TYPE to the declaration specifiers SPECS,
7136 returning SPECS. */
7137
7138 struct c_declspecs *
declspecs_add_type(struct c_declspecs * specs,struct c_typespec spec)7139 declspecs_add_type (struct c_declspecs *specs, struct c_typespec spec)
7140 {
7141 tree type = spec.spec;
7142 specs->non_sc_seen_p = true;
7143 specs->declspecs_seen_p = true;
7144 specs->type_seen_p = true;
7145 if (TREE_DEPRECATED (type))
7146 specs->deprecated_p = true;
7147
7148 /* Handle type specifier keywords. */
7149 if (TREE_CODE (type) == IDENTIFIER_NODE && C_IS_RESERVED_WORD (type))
7150 {
7151 enum rid i = C_RID_CODE (type);
7152 if (specs->type)
7153 {
7154 error ("two or more data types in declaration specifiers");
7155 return specs;
7156 }
7157 if ((int) i <= (int) RID_LAST_MODIFIER)
7158 {
7159 /* "long", "short", "signed", "unsigned" or "_Complex". */
7160 bool dupe = false;
7161 switch (i)
7162 {
7163 case RID_LONG:
7164 if (specs->long_long_p)
7165 {
7166 error ("%<long long long%> is too long for GCC");
7167 break;
7168 }
7169 if (specs->long_p)
7170 {
7171 if (specs->typespec_word == cts_double)
7172 {
7173 error ("both %<long long%> and %<double%> in "
7174 "declaration specifiers");
7175 break;
7176 }
7177 if (pedantic && !flag_isoc99 && !in_system_header
7178 && warn_long_long)
7179 pedwarn ("ISO C90 does not support %<long long%>");
7180 specs->long_long_p = 1;
7181 break;
7182 }
7183 if (specs->short_p)
7184 error ("both %<long%> and %<short%> in "
7185 "declaration specifiers");
7186 else if (specs->typespec_word == cts_void)
7187 error ("both %<long%> and %<void%> in "
7188 "declaration specifiers");
7189 else if (specs->typespec_word == cts_bool)
7190 error ("both %<long%> and %<_Bool%> in "
7191 "declaration specifiers");
7192 else if (specs->typespec_word == cts_char)
7193 error ("both %<long%> and %<char%> in "
7194 "declaration specifiers");
7195 else if (specs->typespec_word == cts_float)
7196 error ("both %<long%> and %<float%> in "
7197 "declaration specifiers");
7198 else
7199 specs->long_p = true;
7200 break;
7201 case RID_SHORT:
7202 dupe = specs->short_p;
7203 if (specs->long_p)
7204 error ("both %<long%> and %<short%> in "
7205 "declaration specifiers");
7206 else if (specs->typespec_word == cts_void)
7207 error ("both %<short%> and %<void%> in "
7208 "declaration specifiers");
7209 else if (specs->typespec_word == cts_bool)
7210 error ("both %<short%> and %<_Bool%> in "
7211 "declaration specifiers");
7212 else if (specs->typespec_word == cts_char)
7213 error ("both %<short%> and %<char%> in "
7214 "declaration specifiers");
7215 else if (specs->typespec_word == cts_float)
7216 error ("both %<short%> and %<float%> in "
7217 "declaration specifiers");
7218 else if (specs->typespec_word == cts_double)
7219 error ("both %<short%> and %<double%> in "
7220 "declaration specifiers");
7221 else
7222 specs->short_p = true;
7223 break;
7224 case RID_SIGNED:
7225 dupe = specs->signed_p;
7226 if (specs->unsigned_p)
7227 error ("both %<signed%> and %<unsigned%> in "
7228 "declaration specifiers");
7229 else if (specs->typespec_word == cts_void)
7230 error ("both %<signed%> and %<void%> in "
7231 "declaration specifiers");
7232 else if (specs->typespec_word == cts_bool)
7233 error ("both %<signed%> and %<_Bool%> in "
7234 "declaration specifiers");
7235 else if (specs->typespec_word == cts_float)
7236 error ("both %<signed%> and %<float%> in "
7237 "declaration specifiers");
7238 else if (specs->typespec_word == cts_double)
7239 error ("both %<signed%> and %<double%> in "
7240 "declaration specifiers");
7241 else
7242 specs->signed_p = true;
7243 break;
7244 case RID_UNSIGNED:
7245 dupe = specs->unsigned_p;
7246 if (specs->signed_p)
7247 error ("both %<signed%> and %<unsigned%> in "
7248 "declaration specifiers");
7249 else if (specs->typespec_word == cts_void)
7250 error ("both %<unsigned%> and %<void%> in "
7251 "declaration specifiers");
7252 else if (specs->typespec_word == cts_bool)
7253 error ("both %<unsigned%> and %<_Bool%> in "
7254 "declaration specifiers");
7255 else if (specs->typespec_word == cts_float)
7256 error ("both %<unsigned%> and %<float%> in "
7257 "declaration specifiers");
7258 else if (specs->typespec_word == cts_double)
7259 error ("both %<unsigned%> and %<double%> in "
7260 "declaration specifiers");
7261 else
7262 specs->unsigned_p = true;
7263 break;
7264 case RID_COMPLEX:
7265 dupe = specs->complex_p;
7266 if (pedantic && !flag_isoc99 && !in_system_header)
7267 pedwarn ("ISO C90 does not support complex types");
7268 if (specs->typespec_word == cts_void)
7269 error ("both %<complex%> and %<void%> in "
7270 "declaration specifiers");
7271 else if (specs->typespec_word == cts_bool)
7272 error ("both %<complex%> and %<_Bool%> in "
7273 "declaration specifiers");
7274 else
7275 specs->complex_p = true;
7276 break;
7277 default:
7278 gcc_unreachable ();
7279 }
7280
7281 if (dupe)
7282 error ("duplicate %qE", type);
7283
7284 return specs;
7285 }
7286 else
7287 {
7288 /* "void", "_Bool", "char", "int", "float" or "double". */
7289 if (specs->typespec_word != cts_none)
7290 {
7291 error ("two or more data types in declaration specifiers");
7292 return specs;
7293 }
7294 switch (i)
7295 {
7296 case RID_VOID:
7297 if (specs->long_p)
7298 error ("both %<long%> and %<void%> in "
7299 "declaration specifiers");
7300 else if (specs->short_p)
7301 error ("both %<short%> and %<void%> in "
7302 "declaration specifiers");
7303 else if (specs->signed_p)
7304 error ("both %<signed%> and %<void%> in "
7305 "declaration specifiers");
7306 else if (specs->unsigned_p)
7307 error ("both %<unsigned%> and %<void%> in "
7308 "declaration specifiers");
7309 else if (specs->complex_p)
7310 error ("both %<complex%> and %<void%> in "
7311 "declaration specifiers");
7312 else
7313 specs->typespec_word = cts_void;
7314 return specs;
7315 case RID_BOOL:
7316 if (specs->long_p)
7317 error ("both %<long%> and %<_Bool%> in "
7318 "declaration specifiers");
7319 else if (specs->short_p)
7320 error ("both %<short%> and %<_Bool%> in "
7321 "declaration specifiers");
7322 else if (specs->signed_p)
7323 error ("both %<signed%> and %<_Bool%> in "
7324 "declaration specifiers");
7325 else if (specs->unsigned_p)
7326 error ("both %<unsigned%> and %<_Bool%> in "
7327 "declaration specifiers");
7328 else if (specs->complex_p)
7329 error ("both %<complex%> and %<_Bool%> in "
7330 "declaration specifiers");
7331 else
7332 specs->typespec_word = cts_bool;
7333 return specs;
7334 case RID_CHAR:
7335 if (specs->long_p)
7336 error ("both %<long%> and %<char%> in "
7337 "declaration specifiers");
7338 else if (specs->short_p)
7339 error ("both %<short%> and %<char%> in "
7340 "declaration specifiers");
7341 else
7342 specs->typespec_word = cts_char;
7343 return specs;
7344 case RID_INT:
7345 specs->typespec_word = cts_int;
7346 return specs;
7347 case RID_FLOAT:
7348 if (specs->long_p)
7349 error ("both %<long%> and %<float%> in "
7350 "declaration specifiers");
7351 else if (specs->short_p)
7352 error ("both %<short%> and %<float%> in "
7353 "declaration specifiers");
7354 else if (specs->signed_p)
7355 error ("both %<signed%> and %<float%> in "
7356 "declaration specifiers");
7357 else if (specs->unsigned_p)
7358 error ("both %<unsigned%> and %<float%> in "
7359 "declaration specifiers");
7360 else
7361 specs->typespec_word = cts_float;
7362 return specs;
7363 case RID_DOUBLE:
7364 if (specs->long_long_p)
7365 error ("both %<long long%> and %<double%> in "
7366 "declaration specifiers");
7367 else if (specs->short_p)
7368 error ("both %<short%> and %<double%> in "
7369 "declaration specifiers");
7370 else if (specs->signed_p)
7371 error ("both %<signed%> and %<double%> in "
7372 "declaration specifiers");
7373 else if (specs->unsigned_p)
7374 error ("both %<unsigned%> and %<double%> in "
7375 "declaration specifiers");
7376 else
7377 specs->typespec_word = cts_double;
7378 return specs;
7379 default:
7380 /* ObjC reserved word "id", handled below. */
7381 break;
7382 }
7383 }
7384 }
7385
7386 /* Now we have a typedef (a TYPE_DECL node), an identifier (some
7387 form of ObjC type, cases such as "int" and "long" being handled
7388 above), a TYPE (struct, union, enum and typeof specifiers) or an
7389 ERROR_MARK. In none of these cases may there have previously
7390 been any type specifiers. */
7391 if (specs->type || specs->typespec_word != cts_none
7392 || specs->long_p || specs->short_p || specs->signed_p
7393 || specs->unsigned_p || specs->complex_p)
7394 error ("two or more data types in declaration specifiers");
7395 else if (TREE_CODE (type) == TYPE_DECL)
7396 {
7397 if (TREE_TYPE (type) == error_mark_node)
7398 ; /* Allow the type to default to int to avoid cascading errors. */
7399 else
7400 {
7401 specs->type = TREE_TYPE (type);
7402 specs->decl_attr = DECL_ATTRIBUTES (type);
7403 specs->typedef_p = true;
7404 specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
7405 }
7406 }
7407 else if (TREE_CODE (type) == IDENTIFIER_NODE)
7408 {
7409 tree t = lookup_name (type);
7410 if (!t || TREE_CODE (t) != TYPE_DECL)
7411 error ("%qE fails to be a typedef or built in type", type);
7412 else if (TREE_TYPE (t) == error_mark_node)
7413 ;
7414 else
7415 specs->type = TREE_TYPE (t);
7416 }
7417 else if (TREE_CODE (type) != ERROR_MARK)
7418 {
7419 if (spec.kind == ctsk_tagdef || spec.kind == ctsk_tagfirstref)
7420 specs->tag_defined_p = true;
7421 if (spec.kind == ctsk_typeof)
7422 specs->typedef_p = true;
7423 specs->type = type;
7424 }
7425
7426 return specs;
7427 }
7428
7429 /* Add the storage class specifier or function specifier SCSPEC to the
7430 declaration specifiers SPECS, returning SPECS. */
7431
7432 struct c_declspecs *
declspecs_add_scspec(struct c_declspecs * specs,tree scspec)7433 declspecs_add_scspec (struct c_declspecs *specs, tree scspec)
7434 {
7435 enum rid i;
7436 enum c_storage_class n = csc_none;
7437 bool dupe = false;
7438 specs->declspecs_seen_p = true;
7439 gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
7440 && C_IS_RESERVED_WORD (scspec));
7441 i = C_RID_CODE (scspec);
7442 if (extra_warnings && specs->non_sc_seen_p)
7443 warning (OPT_Wextra, "%qE is not at beginning of declaration", scspec);
7444 switch (i)
7445 {
7446 case RID_INLINE:
7447 /* C99 permits duplicate inline. Although of doubtful utility,
7448 it seems simplest to permit it in gnu89 mode as well, as
7449 there is also little utility in maintaining this as a
7450 difference between gnu89 and C99 inline. */
7451 dupe = false;
7452 specs->inline_p = true;
7453 break;
7454 case RID_THREAD:
7455 dupe = specs->thread_p;
7456 if (specs->storage_class == csc_auto)
7457 error ("%<__thread%> used with %<auto%>");
7458 else if (specs->storage_class == csc_register)
7459 error ("%<__thread%> used with %<register%>");
7460 else if (specs->storage_class == csc_typedef)
7461 error ("%<__thread%> used with %<typedef%>");
7462 else
7463 specs->thread_p = true;
7464 break;
7465 case RID_AUTO:
7466 n = csc_auto;
7467 break;
7468 case RID_EXTERN:
7469 n = csc_extern;
7470 /* Diagnose "__thread extern". */
7471 if (specs->thread_p)
7472 error ("%<__thread%> before %<extern%>");
7473 break;
7474 case RID_REGISTER:
7475 n = csc_register;
7476 break;
7477 case RID_STATIC:
7478 n = csc_static;
7479 /* Diagnose "__thread static". */
7480 if (specs->thread_p)
7481 error ("%<__thread%> before %<static%>");
7482 break;
7483 case RID_TYPEDEF:
7484 n = csc_typedef;
7485 break;
7486 default:
7487 gcc_unreachable ();
7488 }
7489 if (n != csc_none && n == specs->storage_class)
7490 dupe = true;
7491 if (dupe)
7492 error ("duplicate %qE", scspec);
7493 if (n != csc_none)
7494 {
7495 if (specs->storage_class != csc_none && n != specs->storage_class)
7496 {
7497 error ("multiple storage classes in declaration specifiers");
7498 }
7499 else
7500 {
7501 specs->storage_class = n;
7502 if (n != csc_extern && n != csc_static && specs->thread_p)
7503 {
7504 error ("%<__thread%> used with %qE", scspec);
7505 specs->thread_p = false;
7506 }
7507 }
7508 }
7509 return specs;
7510 }
7511
7512 /* Add the attributes ATTRS to the declaration specifiers SPECS,
7513 returning SPECS. */
7514
7515 struct c_declspecs *
declspecs_add_attrs(struct c_declspecs * specs,tree attrs)7516 declspecs_add_attrs (struct c_declspecs *specs, tree attrs)
7517 {
7518 specs->attrs = chainon (attrs, specs->attrs);
7519 specs->declspecs_seen_p = true;
7520 return specs;
7521 }
7522
7523 /* Combine "long", "short", "signed", "unsigned" and "_Complex" type
7524 specifiers with any other type specifier to determine the resulting
7525 type. This is where ISO C checks on complex types are made, since
7526 "_Complex long" is a prefix of the valid ISO C type "_Complex long
7527 double". */
7528
7529 struct c_declspecs *
finish_declspecs(struct c_declspecs * specs)7530 finish_declspecs (struct c_declspecs *specs)
7531 {
7532 /* If a type was specified as a whole, we have no modifiers and are
7533 done. */
7534 if (specs->type != NULL_TREE)
7535 {
7536 gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
7537 && !specs->signed_p && !specs->unsigned_p
7538 && !specs->complex_p);
7539 return specs;
7540 }
7541
7542 /* If none of "void", "_Bool", "char", "int", "float" or "double"
7543 has been specified, treat it as "int" unless "_Complex" is
7544 present and there are no other specifiers. If we just have
7545 "_Complex", it is equivalent to "_Complex double", but e.g.
7546 "_Complex short" is equivalent to "_Complex short int". */
7547 if (specs->typespec_word == cts_none)
7548 {
7549 if (specs->long_p || specs->short_p
7550 || specs->signed_p || specs->unsigned_p)
7551 {
7552 specs->typespec_word = cts_int;
7553 }
7554 else if (specs->complex_p)
7555 {
7556 specs->typespec_word = cts_double;
7557 if (pedantic)
7558 pedwarn ("ISO C does not support plain %<complex%> meaning "
7559 "%<double complex%>");
7560 }
7561 else
7562 {
7563 specs->typespec_word = cts_int;
7564 specs->default_int_p = true;
7565 /* We don't diagnose this here because grokdeclarator will
7566 give more specific diagnostics according to whether it is
7567 a function definition. */
7568 }
7569 }
7570
7571 /* If "signed" was specified, record this to distinguish "int" and
7572 "signed int" in the case of a bit-field with
7573 -funsigned-bitfields. */
7574 specs->explicit_signed_p = specs->signed_p;
7575
7576 /* Now compute the actual type. */
7577 switch (specs->typespec_word)
7578 {
7579 case cts_void:
7580 gcc_assert (!specs->long_p && !specs->short_p
7581 && !specs->signed_p && !specs->unsigned_p
7582 && !specs->complex_p);
7583 specs->type = void_type_node;
7584 break;
7585 case cts_bool:
7586 gcc_assert (!specs->long_p && !specs->short_p
7587 && !specs->signed_p && !specs->unsigned_p
7588 && !specs->complex_p);
7589 specs->type = boolean_type_node;
7590 break;
7591 case cts_char:
7592 gcc_assert (!specs->long_p && !specs->short_p);
7593 gcc_assert (!(specs->signed_p && specs->unsigned_p));
7594 if (specs->signed_p)
7595 specs->type = signed_char_type_node;
7596 else if (specs->unsigned_p)
7597 specs->type = unsigned_char_type_node;
7598 else
7599 specs->type = char_type_node;
7600 if (specs->complex_p)
7601 {
7602 if (pedantic)
7603 pedwarn ("ISO C does not support complex integer types");
7604 specs->type = build_complex_type (specs->type);
7605 }
7606 break;
7607 case cts_int:
7608 gcc_assert (!(specs->long_p && specs->short_p));
7609 gcc_assert (!(specs->signed_p && specs->unsigned_p));
7610 if (specs->long_long_p)
7611 specs->type = (specs->unsigned_p
7612 ? long_long_unsigned_type_node
7613 : long_long_integer_type_node);
7614 else if (specs->long_p)
7615 specs->type = (specs->unsigned_p
7616 ? long_unsigned_type_node
7617 : long_integer_type_node);
7618 else if (specs->short_p)
7619 specs->type = (specs->unsigned_p
7620 ? short_unsigned_type_node
7621 : short_integer_type_node);
7622 else
7623 specs->type = (specs->unsigned_p
7624 ? unsigned_type_node
7625 : integer_type_node);
7626 if (specs->complex_p)
7627 {
7628 if (pedantic)
7629 pedwarn ("ISO C does not support complex integer types");
7630 specs->type = build_complex_type (specs->type);
7631 }
7632 break;
7633 case cts_float:
7634 gcc_assert (!specs->long_p && !specs->short_p
7635 && !specs->signed_p && !specs->unsigned_p);
7636 specs->type = (specs->complex_p
7637 ? complex_float_type_node
7638 : float_type_node);
7639 break;
7640 case cts_double:
7641 gcc_assert (!specs->long_long_p && !specs->short_p
7642 && !specs->signed_p && !specs->unsigned_p);
7643 if (specs->long_p)
7644 {
7645 specs->type = (specs->complex_p
7646 ? complex_long_double_type_node
7647 : long_double_type_node);
7648 }
7649 else
7650 {
7651 specs->type = (specs->complex_p
7652 ? complex_double_type_node
7653 : double_type_node);
7654 }
7655 break;
7656 default:
7657 gcc_unreachable ();
7658 }
7659
7660 return specs;
7661 }
7662
7663 /* Synthesize a function which calls all the global ctors or global
7664 dtors in this file. This is only used for targets which do not
7665 support .ctors/.dtors sections. FIXME: Migrate into cgraph. */
7666 static void
build_cdtor(int method_type,tree cdtors)7667 build_cdtor (int method_type, tree cdtors)
7668 {
7669 tree body = 0;
7670
7671 if (!cdtors)
7672 return;
7673
7674 for (; cdtors; cdtors = TREE_CHAIN (cdtors))
7675 append_to_statement_list (build_function_call (TREE_VALUE (cdtors), 0),
7676 &body);
7677
7678 cgraph_build_static_cdtor (method_type, body, DEFAULT_INIT_PRIORITY);
7679 }
7680
7681 /* A subroutine of c_write_global_declarations. Perform final processing
7682 on one file scope's declarations (or the external scope's declarations),
7683 GLOBALS. */
7684
7685 static void
c_write_global_declarations_1(tree globals)7686 c_write_global_declarations_1 (tree globals)
7687 {
7688 tree decl;
7689 bool reconsider;
7690
7691 /* Process the decls in the order they were written. */
7692 for (decl = globals; decl; decl = TREE_CHAIN (decl))
7693 {
7694 /* Check for used but undefined static functions using the C
7695 standard's definition of "used", and set TREE_NO_WARNING so
7696 that check_global_declarations doesn't repeat the check. */
7697 if (TREE_CODE (decl) == FUNCTION_DECL
7698 && DECL_INITIAL (decl) == 0
7699 && DECL_EXTERNAL (decl)
7700 && !TREE_PUBLIC (decl)
7701 && C_DECL_USED (decl))
7702 {
7703 pedwarn ("%q+F used but never defined", decl);
7704 TREE_NO_WARNING (decl) = 1;
7705 }
7706
7707 wrapup_global_declaration_1 (decl);
7708 }
7709
7710 do
7711 {
7712 reconsider = false;
7713 for (decl = globals; decl; decl = TREE_CHAIN (decl))
7714 reconsider |= wrapup_global_declaration_2 (decl);
7715 }
7716 while (reconsider);
7717
7718 for (decl = globals; decl; decl = TREE_CHAIN (decl))
7719 check_global_declaration_1 (decl);
7720 }
7721
7722 /* A subroutine of c_write_global_declarations Emit debug information for each
7723 of the declarations in GLOBALS. */
7724
7725 static void
c_write_global_declarations_2(tree globals)7726 c_write_global_declarations_2 (tree globals)
7727 {
7728 tree decl;
7729
7730 for (decl = globals; decl ; decl = TREE_CHAIN (decl))
7731 debug_hooks->global_decl (decl);
7732 }
7733
7734 /* Preserve the external declarations scope across a garbage collect. */
7735 static GTY(()) tree ext_block;
7736
7737 void
c_write_global_declarations(void)7738 c_write_global_declarations (void)
7739 {
7740 tree t;
7741
7742 /* We don't want to do this if generating a PCH. */
7743 if (pch_file)
7744 return;
7745
7746 /* Don't waste time on further processing if -fsyntax-only or we've
7747 encountered errors. */
7748 if (flag_syntax_only || errorcount || sorrycount || cpp_errors (parse_in))
7749 return;
7750
7751 /* Close the external scope. */
7752 ext_block = pop_scope ();
7753 external_scope = 0;
7754 gcc_assert (!current_scope);
7755
7756 if (ext_block)
7757 {
7758 tree tmp = BLOCK_VARS (ext_block);
7759 int flags;
7760 FILE * stream = dump_begin (TDI_tu, &flags);
7761 if (stream && tmp)
7762 {
7763 dump_node (tmp, flags & ~TDF_SLIM, stream);
7764 dump_end (TDI_tu, stream);
7765 }
7766 }
7767
7768 /* Process all file scopes in this compilation, and the external_scope,
7769 through wrapup_global_declarations and check_global_declarations. */
7770 for (t = all_translation_units; t; t = TREE_CHAIN (t))
7771 c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
7772 c_write_global_declarations_1 (BLOCK_VARS (ext_block));
7773
7774 /* Generate functions to call static constructors and destructors
7775 for targets that do not support .ctors/.dtors sections. These
7776 functions have magic names which are detected by collect2. */
7777 build_cdtor ('I', static_ctors); static_ctors = 0;
7778 build_cdtor ('D', static_dtors); static_dtors = 0;
7779
7780 /* We're done parsing; proceed to optimize and emit assembly.
7781 FIXME: shouldn't be the front end's responsibility to call this. */
7782 cgraph_optimize ();
7783
7784 /* After cgraph has had a chance to emit everything that's going to
7785 be emitted, output debug information for globals. */
7786 if (errorcount == 0 && sorrycount == 0)
7787 {
7788 timevar_push (TV_SYMOUT);
7789 for (t = all_translation_units; t; t = TREE_CHAIN (t))
7790 c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
7791 c_write_global_declarations_2 (BLOCK_VARS (ext_block));
7792 timevar_pop (TV_SYMOUT);
7793 }
7794
7795 ext_block = NULL;
7796 }
7797
7798 #include "gt-c-decl.h"
7799