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