gcc/c-decl.c

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