OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [c-decl.c] - Blame information for rev 280

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.