1/* Process declarations and variables for C++ compiler. 2 Copyright (C) 1988-2015 Free Software Foundation, Inc. 3 Contributed by Michael Tiemann (tiemann@cygnus.com) 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 3, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21 22/* Process declarations and symbol lookup for C++ front end. 23 Also constructs types; the standard scalar types at initialization, 24 and structure, union, array and enum types when they are declared. */ 25 26/* ??? not all decl nodes are given the most useful possible 27 line numbers. For example, the CONST_DECLs for enum values. */ 28 29#include "config.h" 30#include "system.h" 31#include "coretypes.h" 32#include "tm.h" 33#include "hash-set.h" 34#include "machmode.h" 35#include "vec.h" 36#include "double-int.h" 37#include "input.h" 38#include "alias.h" 39#include "symtab.h" 40#include "wide-int.h" 41#include "inchash.h" 42#include "tree.h" 43#include "tree-hasher.h" 44#include "stringpool.h" 45#include "stor-layout.h" 46#include "varasm.h" 47#include "attribs.h" 48#include "calls.h" 49#include "flags.h" 50#include "cp-tree.h" 51#include "tree-iterator.h" 52#include "tree-inline.h" 53#include "decl.h" 54#include "intl.h" 55#include "toplev.h" 56#include "hashtab.h" 57#include "tm_p.h" 58#include "target.h" 59#include "c-family/c-common.h" 60#include "c-family/c-objc.h" 61#include "c-family/c-pragma.h" 62#include "c-family/c-target.h" 63#include "c-family/c-ubsan.h" 64#include "diagnostic.h" 65#include "intl.h" 66#include "debug.h" 67#include "timevar.h" 68#include "splay-tree.h" 69#include "plugin.h" 70#include "hash-map.h" 71#include "is-a.h" 72#include "plugin-api.h" 73#include "hard-reg-set.h" 74#include "input.h" 75#include "function.h" 76#include "ipa-ref.h" 77#include "cgraph.h" 78#include "cilk.h" 79#include "wide-int.h" 80#include "builtins.h" 81 82/* Possible cases of bad specifiers type used by bad_specifiers. */ 83enum bad_spec_place { 84 BSP_VAR, /* variable */ 85 BSP_PARM, /* parameter */ 86 BSP_TYPE, /* type */ 87 BSP_FIELD /* field */ 88}; 89 90static tree grokparms (tree parmlist, tree *); 91static const char *redeclaration_error_message (tree, tree); 92 93static int decl_jump_unsafe (tree); 94static void require_complete_types_for_parms (tree); 95static int ambi_op_p (enum tree_code); 96static int unary_op_p (enum tree_code); 97static void push_local_name (tree); 98static tree grok_reference_init (tree, tree, tree, int); 99static tree grokvardecl (tree, tree, tree, const cp_decl_specifier_seq *, 100 int, int, int, tree); 101static int check_static_variable_definition (tree, tree); 102static void record_unknown_type (tree, const char *); 103static tree builtin_function_1 (tree, tree, bool); 104static int member_function_or_else (tree, tree, enum overload_flags); 105static void bad_specifiers (tree, enum bad_spec_place, int, int, int, int, 106 int); 107static void check_for_uninitialized_const_var (tree); 108static tree local_variable_p_walkfn (tree *, int *, void *); 109static tree record_builtin_java_type (const char *, int); 110static const char *tag_name (enum tag_types); 111static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool); 112static int walk_namespaces_r (tree, walk_namespaces_fn, void *); 113static void maybe_deduce_size_from_array_init (tree, tree); 114static void layout_var_decl (tree); 115static tree check_initializer (tree, tree, int, vec<tree, va_gc> **); 116static void make_rtl_for_nonlocal_decl (tree, tree, const char *); 117static void save_function_data (tree); 118static void copy_type_enum (tree , tree); 119static void check_function_type (tree, tree); 120static void finish_constructor_body (void); 121static void begin_destructor_body (void); 122static void finish_destructor_body (void); 123static void record_key_method_defined (tree); 124static tree create_array_type_for_decl (tree, tree, tree); 125static tree get_atexit_node (void); 126static tree get_dso_handle_node (void); 127static tree start_cleanup_fn (void); 128static void end_cleanup_fn (void); 129static tree cp_make_fname_decl (location_t, tree, int); 130static void initialize_predefined_identifiers (void); 131static tree check_special_function_return_type 132 (special_function_kind, tree, tree); 133static tree push_cp_library_fn (enum tree_code, tree, int); 134static tree build_cp_library_fn (tree, enum tree_code, tree, int); 135static void store_parm_decls (tree); 136static void initialize_local_var (tree, tree); 137static void expand_static_init (tree, tree); 138 139/* The following symbols are subsumed in the cp_global_trees array, and 140 listed here individually for documentation purposes. 141 142 C++ extensions 143 tree wchar_decl_node; 144 145 tree vtable_entry_type; 146 tree delta_type_node; 147 tree __t_desc_type_node; 148 149 tree class_type_node; 150 tree unknown_type_node; 151 152 Array type `vtable_entry_type[]' 153 154 tree vtbl_type_node; 155 tree vtbl_ptr_type_node; 156 157 Namespaces, 158 159 tree std_node; 160 tree abi_node; 161 162 A FUNCTION_DECL which can call `abort'. Not necessarily the 163 one that the user will declare, but sufficient to be called 164 by routines that want to abort the program. 165 166 tree abort_fndecl; 167 168 Used by RTTI 169 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type; 170 tree tinfo_var_id; */ 171 172tree cp_global_trees[CPTI_MAX]; 173 174/* Indicates that there is a type value in some namespace, although 175 that is not necessarily in scope at the moment. */ 176 177tree global_type_node; 178 179/* The node that holds the "name" of the global scope. */ 180tree global_scope_name; 181 182#define local_names cp_function_chain->x_local_names 183 184/* A list of objects which have constructors or destructors 185 which reside in the global scope. The decl is stored in 186 the TREE_VALUE slot and the initializer is stored 187 in the TREE_PURPOSE slot. */ 188tree static_aggregates; 189 190/* Like static_aggregates, but for thread_local variables. */ 191tree tls_aggregates; 192 193/* -- end of C++ */ 194 195/* A node for the integer constant 2. */ 196 197tree integer_two_node; 198 199/* Used only for jumps to as-yet undefined labels, since jumps to 200 defined labels can have their validity checked immediately. */ 201 202struct GTY((chain_next ("%h.next"))) named_label_use_entry { 203 struct named_label_use_entry *next; 204 /* The binding level to which this entry is *currently* attached. 205 This is initially the binding level in which the goto appeared, 206 but is modified as scopes are closed. */ 207 cp_binding_level *binding_level; 208 /* The head of the names list that was current when the goto appeared, 209 or the inner scope popped. These are the decls that will *not* be 210 skipped when jumping to the label. */ 211 tree names_in_scope; 212 /* The location of the goto, for error reporting. */ 213 location_t o_goto_locus; 214 /* True if an OpenMP structured block scope has been closed since 215 the goto appeared. This means that the branch from the label will 216 illegally exit an OpenMP scope. */ 217 bool in_omp_scope; 218}; 219 220/* A list of all LABEL_DECLs in the function that have names. Here so 221 we can clear out their names' definitions at the end of the 222 function, and so we can check the validity of jumps to these labels. */ 223 224struct GTY((for_user)) named_label_entry { 225 /* The decl itself. */ 226 tree label_decl; 227 228 /* The binding level to which the label is *currently* attached. 229 This is initially set to the binding level in which the label 230 is defined, but is modified as scopes are closed. */ 231 cp_binding_level *binding_level; 232 /* The head of the names list that was current when the label was 233 defined, or the inner scope popped. These are the decls that will 234 be skipped when jumping to the label. */ 235 tree names_in_scope; 236 /* A vector of all decls from all binding levels that would be 237 crossed by a backward branch to the label. */ 238 vec<tree, va_gc> *bad_decls; 239 240 /* A list of uses of the label, before the label is defined. */ 241 struct named_label_use_entry *uses; 242 243 /* The following bits are set after the label is defined, and are 244 updated as scopes are popped. They indicate that a backward jump 245 to the label will illegally enter a scope of the given flavor. */ 246 bool in_try_scope; 247 bool in_catch_scope; 248 bool in_omp_scope; 249}; 250 251#define named_labels cp_function_chain->x_named_labels 252 253/* The number of function bodies which we are currently processing. 254 (Zero if we are at namespace scope, one inside the body of a 255 function, two inside the body of a function in a local class, etc.) */ 256int function_depth; 257 258/* To avoid unwanted recursion, finish_function defers all mark_used calls 259 encountered during its execution until it finishes. */ 260bool defer_mark_used_calls; 261vec<tree, va_gc> *deferred_mark_used_calls; 262 263/* States indicating how grokdeclarator() should handle declspecs marked 264 with __attribute__((deprecated)). An object declared as 265 __attribute__((deprecated)) suppresses warnings of uses of other 266 deprecated items. */ 267enum deprecated_states deprecated_state = DEPRECATED_NORMAL; 268 269 270/* A list of VAR_DECLs whose type was incomplete at the time the 271 variable was declared. */ 272 273typedef struct GTY(()) incomplete_var_d { 274 tree decl; 275 tree incomplete_type; 276} incomplete_var; 277 278 279static GTY(()) vec<incomplete_var, va_gc> *incomplete_vars; 280 281/* Returns the kind of template specialization we are currently 282 processing, given that it's declaration contained N_CLASS_SCOPES 283 explicit scope qualifications. */ 284 285tmpl_spec_kind 286current_tmpl_spec_kind (int n_class_scopes) 287{ 288 int n_template_parm_scopes = 0; 289 int seen_specialization_p = 0; 290 int innermost_specialization_p = 0; 291 cp_binding_level *b; 292 293 /* Scan through the template parameter scopes. */ 294 for (b = current_binding_level; 295 b->kind == sk_template_parms; 296 b = b->level_chain) 297 { 298 /* If we see a specialization scope inside a parameter scope, 299 then something is wrong. That corresponds to a declaration 300 like: 301 302 template <class T> template <> ... 303 304 which is always invalid since [temp.expl.spec] forbids the 305 specialization of a class member template if the enclosing 306 class templates are not explicitly specialized as well. */ 307 if (b->explicit_spec_p) 308 { 309 if (n_template_parm_scopes == 0) 310 innermost_specialization_p = 1; 311 else 312 seen_specialization_p = 1; 313 } 314 else if (seen_specialization_p == 1) 315 return tsk_invalid_member_spec; 316 317 ++n_template_parm_scopes; 318 } 319 320 /* Handle explicit instantiations. */ 321 if (processing_explicit_instantiation) 322 { 323 if (n_template_parm_scopes != 0) 324 /* We've seen a template parameter list during an explicit 325 instantiation. For example: 326 327 template <class T> template void f(int); 328 329 This is erroneous. */ 330 return tsk_invalid_expl_inst; 331 else 332 return tsk_expl_inst; 333 } 334 335 if (n_template_parm_scopes < n_class_scopes) 336 /* We've not seen enough template headers to match all the 337 specialized classes present. For example: 338 339 template <class T> void R<T>::S<T>::f(int); 340 341 This is invalid; there needs to be one set of template 342 parameters for each class. */ 343 return tsk_insufficient_parms; 344 else if (n_template_parm_scopes == n_class_scopes) 345 /* We're processing a non-template declaration (even though it may 346 be a member of a template class.) For example: 347 348 template <class T> void S<T>::f(int); 349 350 The `class T' matches the `S<T>', leaving no template headers 351 corresponding to the `f'. */ 352 return tsk_none; 353 else if (n_template_parm_scopes > n_class_scopes + 1) 354 /* We've got too many template headers. For example: 355 356 template <> template <class T> void f (T); 357 358 There need to be more enclosing classes. */ 359 return tsk_excessive_parms; 360 else 361 /* This must be a template. It's of the form: 362 363 template <class T> template <class U> void S<T>::f(U); 364 365 This is a specialization if the innermost level was a 366 specialization; otherwise it's just a definition of the 367 template. */ 368 return innermost_specialization_p ? tsk_expl_spec : tsk_template; 369} 370 371/* Exit the current scope. */ 372 373void 374finish_scope (void) 375{ 376 poplevel (0, 0, 0); 377} 378 379/* When a label goes out of scope, check to see if that label was used 380 in a valid manner, and issue any appropriate warnings or errors. */ 381 382static void 383pop_label (tree label, tree old_value) 384{ 385 if (!processing_template_decl) 386 { 387 if (DECL_INITIAL (label) == NULL_TREE) 388 { 389 location_t location; 390 391 error ("label %q+D used but not defined", label); 392 location = input_location; 393 /* FIXME want (LOCATION_FILE (input_location), (line)0) */ 394 /* Avoid crashing later. */ 395 define_label (location, DECL_NAME (label)); 396 } 397 else 398 warn_for_unused_label (label); 399 } 400 401 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value); 402} 403 404/* At the end of a function, all labels declared within the function 405 go out of scope. BLOCK is the top-level block for the 406 function. */ 407 408int 409pop_labels_1 (named_label_entry **slot, tree block) 410{ 411 struct named_label_entry *ent = *slot; 412 413 pop_label (ent->label_decl, NULL_TREE); 414 415 /* Put the labels into the "variables" of the top-level block, 416 so debugger can see them. */ 417 DECL_CHAIN (ent->label_decl) = BLOCK_VARS (block); 418 BLOCK_VARS (block) = ent->label_decl; 419 420 named_labels->clear_slot (slot); 421 422 return 1; 423} 424 425static void 426pop_labels (tree block) 427{ 428 if (named_labels) 429 { 430 named_labels->traverse<tree, pop_labels_1> (block); 431 named_labels = NULL; 432 } 433} 434 435/* At the end of a block with local labels, restore the outer definition. */ 436 437static void 438pop_local_label (tree label, tree old_value) 439{ 440 struct named_label_entry dummy; 441 442 pop_label (label, old_value); 443 444 dummy.label_decl = label; 445 named_label_entry **slot = named_labels->find_slot (&dummy, NO_INSERT); 446 named_labels->clear_slot (slot); 447} 448 449/* The following two routines are used to interface to Objective-C++. 450 The binding level is purposely treated as an opaque type. */ 451 452void * 453objc_get_current_scope (void) 454{ 455 return current_binding_level; 456} 457 458/* The following routine is used by the NeXT-style SJLJ exceptions; 459 variables get marked 'volatile' so as to not be clobbered by 460 _setjmp()/_longjmp() calls. All variables in the current scope, 461 as well as parent scopes up to (but not including) ENCLOSING_BLK 462 shall be thusly marked. */ 463 464void 465objc_mark_locals_volatile (void *enclosing_blk) 466{ 467 cp_binding_level *scope; 468 469 for (scope = current_binding_level; 470 scope && scope != enclosing_blk; 471 scope = scope->level_chain) 472 { 473 tree decl; 474 475 for (decl = scope->names; decl; decl = TREE_CHAIN (decl)) 476 objc_volatilize_decl (decl); 477 478 /* Do not climb up past the current function. */ 479 if (scope->kind == sk_function_parms) 480 break; 481 } 482} 483 484/* Update data for defined and undefined labels when leaving a scope. */ 485 486int 487poplevel_named_label_1 (named_label_entry **slot, cp_binding_level *bl) 488{ 489 named_label_entry *ent = *slot; 490 cp_binding_level *obl = bl->level_chain; 491 492 if (ent->binding_level == bl) 493 { 494 tree decl; 495 496 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and 497 TREE_LISTs representing OVERLOADs, so be careful. */ 498 for (decl = ent->names_in_scope; decl; decl = (DECL_P (decl) 499 ? DECL_CHAIN (decl) 500 : TREE_CHAIN (decl))) 501 if (decl_jump_unsafe (decl)) 502 vec_safe_push (ent->bad_decls, decl); 503 504 ent->binding_level = obl; 505 ent->names_in_scope = obl->names; 506 switch (bl->kind) 507 { 508 case sk_try: 509 ent->in_try_scope = true; 510 break; 511 case sk_catch: 512 ent->in_catch_scope = true; 513 break; 514 case sk_omp: 515 ent->in_omp_scope = true; 516 break; 517 default: 518 break; 519 } 520 } 521 else if (ent->uses) 522 { 523 struct named_label_use_entry *use; 524 525 for (use = ent->uses; use ; use = use->next) 526 if (use->binding_level == bl) 527 { 528 use->binding_level = obl; 529 use->names_in_scope = obl->names; 530 if (bl->kind == sk_omp) 531 use->in_omp_scope = true; 532 } 533 } 534 535 return 1; 536} 537 538/* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings 539 when errors were reported, except for -Werror-unused-but-set-*. */ 540static int unused_but_set_errorcount; 541 542/* Exit a binding level. 543 Pop the level off, and restore the state of the identifier-decl mappings 544 that were in effect when this level was entered. 545 546 If KEEP == 1, this level had explicit declarations, so 547 and create a "block" (a BLOCK node) for the level 548 to record its declarations and subblocks for symbol table output. 549 550 If FUNCTIONBODY is nonzero, this level is the body of a function, 551 so create a block as if KEEP were set and also clear out all 552 label names. 553 554 If REVERSE is nonzero, reverse the order of decls before putting 555 them into the BLOCK. */ 556 557tree 558poplevel (int keep, int reverse, int functionbody) 559{ 560 tree link; 561 /* The chain of decls was accumulated in reverse order. 562 Put it into forward order, just for cleanliness. */ 563 tree decls; 564 tree subblocks; 565 tree block; 566 tree decl; 567 int leaving_for_scope; 568 scope_kind kind; 569 unsigned ix; 570 cp_label_binding *label_bind; 571 572 bool subtime = timevar_cond_start (TV_NAME_LOOKUP); 573 restart: 574 575 block = NULL_TREE; 576 577 gcc_assert (current_binding_level->kind != sk_class); 578 579 if (current_binding_level->kind == sk_cleanup) 580 functionbody = 0; 581 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0; 582 583 gcc_assert (!vec_safe_length (current_binding_level->class_shadowed)); 584 585 /* We used to use KEEP == 2 to indicate that the new block should go 586 at the beginning of the list of blocks at this binding level, 587 rather than the end. This hack is no longer used. */ 588 gcc_assert (keep == 0 || keep == 1); 589 590 if (current_binding_level->keep) 591 keep = 1; 592 593 /* Any uses of undefined labels, and any defined labels, now operate 594 under constraints of next binding contour. */ 595 if (cfun && !functionbody && named_labels) 596 named_labels->traverse<cp_binding_level *, poplevel_named_label_1> 597 (current_binding_level); 598 599 /* Get the decls in the order they were written. 600 Usually current_binding_level->names is in reverse order. 601 But parameter decls were previously put in forward order. */ 602 603 if (reverse) 604 current_binding_level->names 605 = decls = nreverse (current_binding_level->names); 606 else 607 decls = current_binding_level->names; 608 609 /* If there were any declarations or structure tags in that level, 610 or if this level is a function body, 611 create a BLOCK to record them for the life of this function. */ 612 block = NULL_TREE; 613 /* Avoid function body block if possible. */ 614 if (functionbody && subblocks && BLOCK_CHAIN (subblocks) == NULL_TREE) 615 keep = 0; 616 else if (keep == 1 || functionbody) 617 block = make_node (BLOCK); 618 if (block != NULL_TREE) 619 { 620 BLOCK_VARS (block) = decls; 621 BLOCK_SUBBLOCKS (block) = subblocks; 622 } 623 624 /* In each subblock, record that this is its superior. */ 625 if (keep >= 0) 626 for (link = subblocks; link; link = BLOCK_CHAIN (link)) 627 BLOCK_SUPERCONTEXT (link) = block; 628 629 /* We still support the old for-scope rules, whereby the variables 630 in a for-init statement were in scope after the for-statement 631 ended. We only use the new rules if flag_new_for_scope is 632 nonzero. */ 633 leaving_for_scope 634 = current_binding_level->kind == sk_for && flag_new_for_scope == 1; 635 636 /* Before we remove the declarations first check for unused variables. */ 637 if ((warn_unused_variable || warn_unused_but_set_variable) 638 && current_binding_level->kind != sk_template_parms 639 && !processing_template_decl) 640 for (tree d = getdecls (); d; d = TREE_CHAIN (d)) 641 { 642 /* There are cases where D itself is a TREE_LIST. See in 643 push_local_binding where the list of decls returned by 644 getdecls is built. */ 645 decl = TREE_CODE (d) == TREE_LIST ? TREE_VALUE (d) : d; 646 tree type = TREE_TYPE (decl); 647 if (VAR_P (decl) 648 && (! TREE_USED (decl) || !DECL_READ_P (decl)) 649 && ! DECL_IN_SYSTEM_HEADER (decl) 650 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl) 651 && type != error_mark_node 652 && (!CLASS_TYPE_P (type) 653 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) 654 || lookup_attribute ("warn_unused", 655 TYPE_ATTRIBUTES (TREE_TYPE (decl))))) 656 { 657 if (! TREE_USED (decl)) 658 warning (OPT_Wunused_variable, "unused variable %q+D", decl); 659 else if (DECL_CONTEXT (decl) == current_function_decl 660 // For -Wunused-but-set-variable leave references alone. 661 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE 662 && errorcount == unused_but_set_errorcount) 663 { 664 warning (OPT_Wunused_but_set_variable, 665 "variable %q+D set but not used", decl); 666 unused_but_set_errorcount = errorcount; 667 } 668 } 669 } 670 671 /* Remove declarations for all the DECLs in this level. */ 672 for (link = decls; link; link = TREE_CHAIN (link)) 673 { 674 if (leaving_for_scope && VAR_P (link) 675 /* It's hard to make this ARM compatibility hack play nicely with 676 lambdas, and it really isn't necessary in C++11 mode. */ 677 && cxx_dialect < cxx11 678 && DECL_NAME (link)) 679 { 680 tree name = DECL_NAME (link); 681 cxx_binding *ob; 682 tree ns_binding; 683 684 ob = outer_binding (name, 685 IDENTIFIER_BINDING (name), 686 /*class_p=*/true); 687 if (!ob) 688 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name); 689 else 690 ns_binding = NULL_TREE; 691 692 if (ob && ob->scope == current_binding_level->level_chain) 693 /* We have something like: 694 695 int i; 696 for (int i; ;); 697 698 and we are leaving the `for' scope. There's no reason to 699 keep the binding of the inner `i' in this case. */ 700 pop_binding (name, link); 701 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL)) 702 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL)) 703 /* Here, we have something like: 704 705 typedef int I; 706 707 void f () { 708 for (int I; ;); 709 } 710 711 We must pop the for-scope binding so we know what's a 712 type and what isn't. */ 713 pop_binding (name, link); 714 else 715 { 716 /* Mark this VAR_DECL as dead so that we can tell we left it 717 there only for backward compatibility. */ 718 DECL_DEAD_FOR_LOCAL (link) = 1; 719 720 /* Keep track of what should have happened when we 721 popped the binding. */ 722 if (ob && ob->value) 723 { 724 SET_DECL_SHADOWED_FOR_VAR (link, ob->value); 725 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1; 726 } 727 728 /* Add it to the list of dead variables in the next 729 outermost binding to that we can remove these when we 730 leave that binding. */ 731 vec_safe_push ( 732 current_binding_level->level_chain->dead_vars_from_for, 733 link); 734 735 /* Although we don't pop the cxx_binding, we do clear 736 its SCOPE since the scope is going away now. */ 737 IDENTIFIER_BINDING (name)->scope 738 = current_binding_level->level_chain; 739 } 740 } 741 else 742 { 743 tree name; 744 745 /* Remove the binding. */ 746 decl = link; 747 748 if (TREE_CODE (decl) == TREE_LIST) 749 decl = TREE_VALUE (decl); 750 name = decl; 751 752 if (TREE_CODE (name) == OVERLOAD) 753 name = OVL_FUNCTION (name); 754 755 gcc_assert (DECL_P (name)); 756 pop_binding (DECL_NAME (name), decl); 757 } 758 } 759 760 /* Remove declarations for any `for' variables from inner scopes 761 that we kept around. */ 762 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level->dead_vars_from_for, 763 ix, decl) 764 pop_binding (DECL_NAME (decl), decl); 765 766 /* Restore the IDENTIFIER_TYPE_VALUEs. */ 767 for (link = current_binding_level->type_shadowed; 768 link; link = TREE_CHAIN (link)) 769 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link)); 770 771 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */ 772 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level->shadowed_labels, 773 ix, label_bind) 774 pop_local_label (label_bind->label, label_bind->prev_value); 775 776 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs 777 list if a `using' declaration put them there. The debugging 778 back ends won't understand OVERLOAD, so we remove them here. 779 Because the BLOCK_VARS are (temporarily) shared with 780 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have 781 popped all the bindings. */ 782 if (block) 783 { 784 tree* d; 785 786 for (d = &BLOCK_VARS (block); *d; ) 787 { 788 if (TREE_CODE (*d) == TREE_LIST) 789 *d = TREE_CHAIN (*d); 790 else 791 d = &DECL_CHAIN (*d); 792 } 793 } 794 795 /* If the level being exited is the top level of a function, 796 check over all the labels. */ 797 if (functionbody) 798 { 799 if (block) 800 { 801 /* Since this is the top level block of a function, the vars are 802 the function's parameters. Don't leave them in the BLOCK 803 because they are found in the FUNCTION_DECL instead. */ 804 BLOCK_VARS (block) = 0; 805 pop_labels (block); 806 } 807 else 808 pop_labels (subblocks); 809 } 810 811 kind = current_binding_level->kind; 812 if (kind == sk_cleanup) 813 { 814 tree stmt; 815 816 /* If this is a temporary binding created for a cleanup, then we'll 817 have pushed a statement list level. Pop that, create a new 818 BIND_EXPR for the block, and insert it into the stream. */ 819 stmt = pop_stmt_list (current_binding_level->statement_list); 820 stmt = c_build_bind_expr (input_location, block, stmt); 821 add_stmt (stmt); 822 } 823 824 leave_scope (); 825 if (functionbody) 826 { 827 /* The current function is being defined, so its DECL_INITIAL 828 should be error_mark_node. */ 829 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node); 830 DECL_INITIAL (current_function_decl) = block ? block : subblocks; 831 if (subblocks) 832 { 833 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl)) 834 { 835 if (BLOCK_SUBBLOCKS (subblocks)) 836 BLOCK_OUTER_CURLY_BRACE_P (BLOCK_SUBBLOCKS (subblocks)) = 1; 837 } 838 else 839 BLOCK_OUTER_CURLY_BRACE_P (subblocks) = 1; 840 } 841 } 842 else if (block) 843 current_binding_level->blocks 844 = block_chainon (current_binding_level->blocks, block); 845 846 /* If we did not make a block for the level just exited, 847 any blocks made for inner levels 848 (since they cannot be recorded as subblocks in that level) 849 must be carried forward so they will later become subblocks 850 of something else. */ 851 else if (subblocks) 852 current_binding_level->blocks 853 = block_chainon (current_binding_level->blocks, subblocks); 854 855 /* Each and every BLOCK node created here in `poplevel' is important 856 (e.g. for proper debugging information) so if we created one 857 earlier, mark it as "used". */ 858 if (block) 859 TREE_USED (block) = 1; 860 861 /* All temporary bindings created for cleanups are popped silently. */ 862 if (kind == sk_cleanup) 863 goto restart; 864 865 timevar_cond_stop (TV_NAME_LOOKUP, subtime); 866 return block; 867} 868 869/* Walk all the namespaces contained NAMESPACE, including NAMESPACE 870 itself, calling F for each. The DATA is passed to F as well. */ 871 872static int 873walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data) 874{ 875 int result = 0; 876 tree current = NAMESPACE_LEVEL (name_space)->namespaces; 877 878 result |= (*f) (name_space, data); 879 880 for (; current; current = DECL_CHAIN (current)) 881 result |= walk_namespaces_r (current, f, data); 882 883 return result; 884} 885 886/* Walk all the namespaces, calling F for each. The DATA is passed to 887 F as well. */ 888 889int 890walk_namespaces (walk_namespaces_fn f, void* data) 891{ 892 return walk_namespaces_r (global_namespace, f, data); 893} 894 895/* Call wrapup_globals_declarations for the globals in NAMESPACE. If 896 DATA is non-NULL, this is the last time we will call 897 wrapup_global_declarations for this NAMESPACE. */ 898 899int 900wrapup_globals_for_namespace (tree name_space, void* data) 901{ 902 cp_binding_level *level = NAMESPACE_LEVEL (name_space); 903 vec<tree, va_gc> *statics = level->static_decls; 904 tree *vec = statics->address (); 905 int len = statics->length (); 906 int last_time = (data != 0); 907 908 if (last_time) 909 { 910 check_global_declarations (vec, len); 911 emit_debug_global_declarations (vec, len); 912 return 0; 913 } 914 915 /* Write out any globals that need to be output. */ 916 return wrapup_global_declarations (vec, len); 917} 918 919 920/* In C++, you don't have to write `struct S' to refer to `S'; you 921 can just use `S'. We accomplish this by creating a TYPE_DECL as 922 if the user had written `typedef struct S S'. Create and return 923 the TYPE_DECL for TYPE. */ 924 925tree 926create_implicit_typedef (tree name, tree type) 927{ 928 tree decl; 929 930 decl = build_decl (input_location, TYPE_DECL, name, type); 931 DECL_ARTIFICIAL (decl) = 1; 932 /* There are other implicit type declarations, like the one *within* 933 a class that allows you to write `S::S'. We must distinguish 934 amongst these. */ 935 SET_DECL_IMPLICIT_TYPEDEF_P (decl); 936 TYPE_NAME (type) = decl; 937 TYPE_STUB_DECL (type) = decl; 938 939 return decl; 940} 941 942/* Remember a local name for name-mangling purposes. */ 943 944static void 945push_local_name (tree decl) 946{ 947 size_t i, nelts; 948 tree t, name; 949 950 timevar_start (TV_NAME_LOOKUP); 951 952 name = DECL_NAME (decl); 953 954 nelts = vec_safe_length (local_names); 955 for (i = 0; i < nelts; i++) 956 { 957 t = (*local_names)[i]; 958 if (DECL_NAME (t) == name) 959 { 960 if (!DECL_LANG_SPECIFIC (decl)) 961 retrofit_lang_decl (decl); 962 DECL_LANG_SPECIFIC (decl)->u.base.u2sel = 1; 963 if (DECL_DISCRIMINATOR_SET_P (t)) 964 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1; 965 else 966 DECL_DISCRIMINATOR (decl) = 1; 967 968 (*local_names)[i] = decl; 969 timevar_stop (TV_NAME_LOOKUP); 970 return; 971 } 972 } 973 974 vec_safe_push (local_names, decl); 975 timevar_stop (TV_NAME_LOOKUP); 976} 977 978/* Subroutine of duplicate_decls: return truthvalue of whether 979 or not types of these decls match. 980 981 For C++, we must compare the parameter list so that `int' can match 982 `int&' in a parameter position, but `int&' is not confused with 983 `const int&'. */ 984 985int 986decls_match (tree newdecl, tree olddecl) 987{ 988 int types_match; 989 990 if (newdecl == olddecl) 991 return 1; 992 993 if (TREE_CODE (newdecl) != TREE_CODE (olddecl)) 994 /* If the two DECLs are not even the same kind of thing, we're not 995 interested in their types. */ 996 return 0; 997 998 gcc_assert (DECL_P (newdecl)); 999 1000 if (TREE_CODE (newdecl) == FUNCTION_DECL) 1001 { 1002 tree f1 = TREE_TYPE (newdecl); 1003 tree f2 = TREE_TYPE (olddecl); 1004 tree p1 = TYPE_ARG_TYPES (f1); 1005 tree p2 = TYPE_ARG_TYPES (f2); 1006 tree r2; 1007 1008 /* Specializations of different templates are different functions 1009 even if they have the same type. */ 1010 tree t1 = (DECL_USE_TEMPLATE (newdecl) 1011 ? DECL_TI_TEMPLATE (newdecl) 1012 : NULL_TREE); 1013 tree t2 = (DECL_USE_TEMPLATE (olddecl) 1014 ? DECL_TI_TEMPLATE (olddecl) 1015 : NULL_TREE); 1016 if (t1 != t2) 1017 return 0; 1018 1019 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl) 1020 && ! (DECL_EXTERN_C_P (newdecl) 1021 && DECL_EXTERN_C_P (olddecl))) 1022 return 0; 1023 1024 /* A new declaration doesn't match a built-in one unless it 1025 is also extern "C". */ 1026 if (DECL_IS_BUILTIN (olddecl) 1027 && DECL_EXTERN_C_P (olddecl) && !DECL_EXTERN_C_P (newdecl)) 1028 return 0; 1029 1030 if (TREE_CODE (f1) != TREE_CODE (f2)) 1031 return 0; 1032 1033 /* A declaration with deduced return type should use its pre-deduction 1034 type for declaration matching. */ 1035 r2 = fndecl_declared_return_type (olddecl); 1036 1037 if (same_type_p (TREE_TYPE (f1), r2)) 1038 { 1039 if (!prototype_p (f2) && DECL_EXTERN_C_P (olddecl) 1040 && (DECL_BUILT_IN (olddecl) 1041#ifndef NO_IMPLICIT_EXTERN_C 1042 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl)) 1043 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl)) 1044#endif 1045 )) 1046 { 1047 types_match = self_promoting_args_p (p1); 1048 if (p1 == void_list_node) 1049 TREE_TYPE (newdecl) = TREE_TYPE (olddecl); 1050 } 1051#ifndef NO_IMPLICIT_EXTERN_C 1052 else if (!prototype_p (f1) 1053 && (DECL_EXTERN_C_P (olddecl) 1054 && DECL_IN_SYSTEM_HEADER (olddecl) 1055 && !DECL_CLASS_SCOPE_P (olddecl)) 1056 && (DECL_EXTERN_C_P (newdecl) 1057 && DECL_IN_SYSTEM_HEADER (newdecl) 1058 && !DECL_CLASS_SCOPE_P (newdecl))) 1059 { 1060 types_match = self_promoting_args_p (p2); 1061 TREE_TYPE (newdecl) = TREE_TYPE (olddecl); 1062 } 1063#endif 1064 else 1065 types_match = 1066 compparms (p1, p2) 1067 && type_memfn_rqual (f1) == type_memfn_rqual (f2) 1068 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl)) == NULL_TREE 1069 || comp_type_attributes (TREE_TYPE (newdecl), 1070 TREE_TYPE (olddecl)) != 0); 1071 } 1072 else 1073 types_match = 0; 1074 1075 /* The decls dont match if they correspond to two different versions 1076 of the same function. Disallow extern "C" functions to be 1077 versions for now. */ 1078 if (types_match 1079 && !DECL_EXTERN_C_P (newdecl) 1080 && !DECL_EXTERN_C_P (olddecl) 1081 && targetm.target_option.function_versions (newdecl, olddecl)) 1082 { 1083 /* Mark functions as versions if necessary. Modify the mangled decl 1084 name if necessary. */ 1085 if (DECL_FUNCTION_VERSIONED (newdecl) 1086 && DECL_FUNCTION_VERSIONED (olddecl)) 1087 return 0; 1088 if (!DECL_FUNCTION_VERSIONED (newdecl)) 1089 { 1090 DECL_FUNCTION_VERSIONED (newdecl) = 1; 1091 if (DECL_ASSEMBLER_NAME_SET_P (newdecl)) 1092 mangle_decl (newdecl); 1093 } 1094 if (!DECL_FUNCTION_VERSIONED (olddecl)) 1095 { 1096 DECL_FUNCTION_VERSIONED (olddecl) = 1; 1097 if (DECL_ASSEMBLER_NAME_SET_P (olddecl)) 1098 mangle_decl (olddecl); 1099 } 1100 cgraph_node::record_function_versions (olddecl, newdecl); 1101 return 0; 1102 } 1103 } 1104 else if (TREE_CODE (newdecl) == TEMPLATE_DECL) 1105 { 1106 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) 1107 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))) 1108 return 0; 1109 1110 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl), 1111 DECL_TEMPLATE_PARMS (olddecl))) 1112 return 0; 1113 1114 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) 1115 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)), 1116 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))); 1117 else 1118 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl), 1119 DECL_TEMPLATE_RESULT (newdecl)); 1120 } 1121 else 1122 { 1123 /* Need to check scope for variable declaration (VAR_DECL). 1124 For typedef (TYPE_DECL), scope is ignored. */ 1125 if (VAR_P (newdecl) 1126 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl) 1127 /* [dcl.link] 1128 Two declarations for an object with C language linkage 1129 with the same name (ignoring the namespace that qualify 1130 it) that appear in different namespace scopes refer to 1131 the same object. */ 1132 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl))) 1133 return 0; 1134 1135 if (TREE_TYPE (newdecl) == error_mark_node) 1136 types_match = TREE_TYPE (olddecl) == error_mark_node; 1137 else if (TREE_TYPE (olddecl) == NULL_TREE) 1138 types_match = TREE_TYPE (newdecl) == NULL_TREE; 1139 else if (TREE_TYPE (newdecl) == NULL_TREE) 1140 types_match = 0; 1141 else 1142 types_match = comptypes (TREE_TYPE (newdecl), 1143 TREE_TYPE (olddecl), 1144 COMPARE_REDECLARATION); 1145 } 1146 1147 return types_match; 1148} 1149 1150/* If NEWDECL is `static' and an `extern' was seen previously, 1151 warn about it. OLDDECL is the previous declaration. 1152 1153 Note that this does not apply to the C++ case of declaring 1154 a variable `extern const' and then later `const'. 1155 1156 Don't complain about built-in functions, since they are beyond 1157 the user's control. */ 1158 1159void 1160warn_extern_redeclared_static (tree newdecl, tree olddecl) 1161{ 1162 if (TREE_CODE (newdecl) == TYPE_DECL 1163 || TREE_CODE (newdecl) == TEMPLATE_DECL 1164 || TREE_CODE (newdecl) == CONST_DECL 1165 || TREE_CODE (newdecl) == NAMESPACE_DECL) 1166 return; 1167 1168 /* Don't get confused by static member functions; that's a different 1169 use of `static'. */ 1170 if (TREE_CODE (newdecl) == FUNCTION_DECL 1171 && DECL_STATIC_FUNCTION_P (newdecl)) 1172 return; 1173 1174 /* If the old declaration was `static', or the new one isn't, then 1175 everything is OK. */ 1176 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl)) 1177 return; 1178 1179 /* It's OK to declare a builtin function as `static'. */ 1180 if (TREE_CODE (olddecl) == FUNCTION_DECL 1181 && DECL_ARTIFICIAL (olddecl)) 1182 return; 1183 1184 if (permerror (input_location, 1185 "%qD was declared %<extern%> and later %<static%>", newdecl)) 1186 inform (input_location, "previous declaration of %q+D", olddecl); 1187} 1188 1189/* NEW_DECL is a redeclaration of OLD_DECL; both are functions or 1190 function templates. If their exception specifications do not 1191 match, issue a diagnostic. */ 1192 1193static void 1194check_redeclaration_exception_specification (tree new_decl, 1195 tree old_decl) 1196{ 1197 tree new_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl)); 1198 tree old_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl)); 1199 1200 /* Two default specs are equivalent, don't force evaluation. */ 1201 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions) 1202 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions)) 1203 return; 1204 1205 maybe_instantiate_noexcept (new_decl); 1206 maybe_instantiate_noexcept (old_decl); 1207 new_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl)); 1208 old_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl)); 1209 1210 /* [except.spec] 1211 1212 If any declaration of a function has an exception-specification, 1213 all declarations, including the definition and an explicit 1214 specialization, of that function shall have an 1215 exception-specification with the same set of type-ids. */ 1216 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl)) 1217 && ! DECL_IS_BUILTIN (old_decl) 1218 && flag_exceptions 1219 && !comp_except_specs (new_exceptions, old_exceptions, ce_normal)) 1220 { 1221 error ("declaration of %qF has a different exception specifier", 1222 new_decl); 1223 error ("from previous declaration %q+F", old_decl); 1224 } 1225} 1226 1227/* Return true if OLD_DECL and NEW_DECL agree on constexprness. 1228 Otherwise issue diagnostics. */ 1229 1230static bool 1231validate_constexpr_redeclaration (tree old_decl, tree new_decl) 1232{ 1233 old_decl = STRIP_TEMPLATE (old_decl); 1234 new_decl = STRIP_TEMPLATE (new_decl); 1235 if (!VAR_OR_FUNCTION_DECL_P (old_decl) 1236 || !VAR_OR_FUNCTION_DECL_P (new_decl)) 1237 return true; 1238 if (DECL_DECLARED_CONSTEXPR_P (old_decl) 1239 == DECL_DECLARED_CONSTEXPR_P (new_decl)) 1240 return true; 1241 if (TREE_CODE (old_decl) == FUNCTION_DECL) 1242 { 1243 if (DECL_BUILT_IN (old_decl)) 1244 { 1245 /* Hide a built-in declaration. */ 1246 DECL_DECLARED_CONSTEXPR_P (old_decl) 1247 = DECL_DECLARED_CONSTEXPR_P (new_decl); 1248 return true; 1249 } 1250 /* 7.1.5 [dcl.constexpr] 1251 Note: An explicit specialization can differ from the template 1252 declaration with respect to the constexpr specifier. */ 1253 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl) 1254 && DECL_TEMPLATE_SPECIALIZATION (new_decl)) 1255 return true; 1256 1257 error ("redeclaration %qD differs in %<constexpr%>", new_decl); 1258 error ("from previous declaration %q+D", old_decl); 1259 return false; 1260 } 1261 return true; 1262} 1263 1264/* DECL is a redeclaration of a function or function template. If 1265 it does have default arguments issue a diagnostic. Note: this 1266 function is used to enforce the requirements in C++11 8.3.6 about 1267 no default arguments in redeclarations. */ 1268 1269static void 1270check_redeclaration_no_default_args (tree decl) 1271{ 1272 gcc_assert (DECL_DECLARES_FUNCTION_P (decl)); 1273 1274 for (tree t = FUNCTION_FIRST_USER_PARMTYPE (decl); 1275 t && t != void_list_node; t = TREE_CHAIN (t)) 1276 if (TREE_PURPOSE (t)) 1277 { 1278 permerror (input_location, 1279 "redeclaration of %q#D may not have default " 1280 "arguments", decl); 1281 return; 1282 } 1283} 1284 1285#define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \ 1286 && lookup_attribute ("gnu_inline", \ 1287 DECL_ATTRIBUTES (fn))) 1288 1289/* If NEWDECL is a redeclaration of OLDDECL, merge the declarations. 1290 If the redeclaration is invalid, a diagnostic is issued, and the 1291 error_mark_node is returned. Otherwise, OLDDECL is returned. 1292 1293 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is 1294 returned. 1295 1296 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */ 1297 1298tree 1299duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend) 1300{ 1301 unsigned olddecl_uid = DECL_UID (olddecl); 1302 int olddecl_friend = 0, types_match = 0, hidden_friend = 0; 1303 int new_defines_function = 0; 1304 tree new_template_info; 1305 1306 if (newdecl == olddecl) 1307 return olddecl; 1308 1309 types_match = decls_match (newdecl, olddecl); 1310 1311 /* If either the type of the new decl or the type of the old decl is an 1312 error_mark_node, then that implies that we have already issued an 1313 error (earlier) for some bogus type specification, and in that case, 1314 it is rather pointless to harass the user with yet more error message 1315 about the same declaration, so just pretend the types match here. */ 1316 if (TREE_TYPE (newdecl) == error_mark_node 1317 || TREE_TYPE (olddecl) == error_mark_node) 1318 return error_mark_node; 1319 1320 if (UDLIT_OPER_P (DECL_NAME (newdecl)) 1321 && UDLIT_OPER_P (DECL_NAME (olddecl))) 1322 { 1323 if (TREE_CODE (newdecl) == TEMPLATE_DECL 1324 && TREE_CODE (olddecl) != TEMPLATE_DECL 1325 && check_raw_literal_operator (olddecl)) 1326 error ("literal operator template %q+D conflicts with" 1327 " raw literal operator %qD", newdecl, olddecl); 1328 else if (TREE_CODE (newdecl) != TEMPLATE_DECL 1329 && TREE_CODE (olddecl) == TEMPLATE_DECL 1330 && check_raw_literal_operator (newdecl)) 1331 error ("raw literal operator %q+D conflicts with" 1332 " literal operator template %qD", newdecl, olddecl); 1333 } 1334 1335 if (DECL_P (olddecl) 1336 && TREE_CODE (newdecl) == FUNCTION_DECL 1337 && TREE_CODE (olddecl) == FUNCTION_DECL 1338 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl))) 1339 { 1340 if (DECL_DECLARED_INLINE_P (newdecl) 1341 && DECL_UNINLINABLE (newdecl) 1342 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))) 1343 /* Already warned elsewhere. */; 1344 else if (DECL_DECLARED_INLINE_P (olddecl) 1345 && DECL_UNINLINABLE (olddecl) 1346 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl))) 1347 /* Already warned. */; 1348 else if (DECL_DECLARED_INLINE_P (newdecl) 1349 && DECL_UNINLINABLE (olddecl) 1350 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl))) 1351 { 1352 if (warning (OPT_Wattributes, "function %q+D redeclared as inline", 1353 newdecl)) 1354 inform (DECL_SOURCE_LOCATION (olddecl), 1355 "previous declaration of %qD with attribute noinline", 1356 olddecl); 1357 } 1358 else if (DECL_DECLARED_INLINE_P (olddecl) 1359 && DECL_UNINLINABLE (newdecl) 1360 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl))) 1361 { 1362 if (warning (OPT_Wattributes, "function %q+D redeclared with " 1363 "attribute noinline", newdecl)) 1364 inform (DECL_SOURCE_LOCATION (olddecl), 1365 "previous declaration of %qD was inline", 1366 olddecl); 1367 } 1368 } 1369 1370 /* Check for redeclaration and other discrepancies. */ 1371 if (TREE_CODE (olddecl) == FUNCTION_DECL 1372 && DECL_ARTIFICIAL (olddecl)) 1373 { 1374 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl)); 1375 if (TREE_CODE (newdecl) != FUNCTION_DECL) 1376 { 1377 /* Avoid warnings redeclaring built-ins which have not been 1378 explicitly declared. */ 1379 if (DECL_ANTICIPATED (olddecl)) 1380 return NULL_TREE; 1381 1382 /* If you declare a built-in or predefined function name as static, 1383 the old definition is overridden, but optionally warn this was a 1384 bad choice of name. */ 1385 if (! TREE_PUBLIC (newdecl)) 1386 { 1387 warning (OPT_Wshadow, 1388 DECL_BUILT_IN (olddecl) 1389 ? G_("shadowing built-in function %q#D") 1390 : G_("shadowing library function %q#D"), olddecl); 1391 /* Discard the old built-in function. */ 1392 return NULL_TREE; 1393 } 1394 /* If the built-in is not ansi, then programs can override 1395 it even globally without an error. */ 1396 else if (! DECL_BUILT_IN (olddecl)) 1397 warning (0, "library function %q#D redeclared as non-function %q#D", 1398 olddecl, newdecl); 1399 else 1400 error ("declaration of %q#D conflicts with built-in " 1401 "declaration %q#D", newdecl, olddecl); 1402 return NULL_TREE; 1403 } 1404 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl)) 1405 { 1406 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl)); 1407 error_at (DECL_SOURCE_LOCATION (newdecl), 1408 "redeclaration of %<pragma omp declare reduction%>"); 1409 inform (DECL_SOURCE_LOCATION (olddecl), 1410 "previous %<pragma omp declare reduction%> declaration"); 1411 return error_mark_node; 1412 } 1413 else if (!types_match) 1414 { 1415 /* Avoid warnings redeclaring built-ins which have not been 1416 explicitly declared. */ 1417 if (DECL_ANTICIPATED (olddecl)) 1418 { 1419 /* Deal with fileptr_type_node. FILE type is not known 1420 at the time we create the builtins. */ 1421 tree t1, t2; 1422 1423 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)), 1424 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl)); 1425 t1 || t2; 1426 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)) 1427 if (!t1 || !t2) 1428 break; 1429 else if (TREE_VALUE (t2) == fileptr_type_node) 1430 { 1431 tree t = TREE_VALUE (t1); 1432 1433 if (TYPE_PTR_P (t) 1434 && TYPE_IDENTIFIER (TREE_TYPE (t)) 1435 == get_identifier ("FILE") 1436 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2))) 1437 { 1438 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl)); 1439 1440 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) 1441 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)); 1442 types_match = decls_match (newdecl, olddecl); 1443 if (types_match) 1444 return duplicate_decls (newdecl, olddecl, 1445 newdecl_is_friend); 1446 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs; 1447 } 1448 } 1449 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2))) 1450 break; 1451 } 1452 else if ((DECL_EXTERN_C_P (newdecl) 1453 && DECL_EXTERN_C_P (olddecl)) 1454 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), 1455 TYPE_ARG_TYPES (TREE_TYPE (olddecl)))) 1456 { 1457 /* A near match; override the builtin. */ 1458 1459 if (TREE_PUBLIC (newdecl)) 1460 warning (0, "new declaration %q#D ambiguates built-in " 1461 "declaration %q#D", newdecl, olddecl); 1462 else 1463 warning (OPT_Wshadow, 1464 DECL_BUILT_IN (olddecl) 1465 ? G_("shadowing built-in function %q#D") 1466 : G_("shadowing library function %q#D"), olddecl); 1467 } 1468 else 1469 /* Discard the old built-in function. */ 1470 return NULL_TREE; 1471 1472 /* Replace the old RTL to avoid problems with inlining. */ 1473 COPY_DECL_RTL (newdecl, olddecl); 1474 } 1475 /* Even if the types match, prefer the new declarations type for 1476 built-ins which have not been explicitly declared, for 1477 exception lists, etc... */ 1478 else if (DECL_IS_BUILTIN (olddecl)) 1479 { 1480 tree type = TREE_TYPE (newdecl); 1481 tree attribs = (*targetm.merge_type_attributes) 1482 (TREE_TYPE (olddecl), type); 1483 1484 type = cp_build_type_attribute_variant (type, attribs); 1485 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type; 1486 } 1487 1488 /* If a function is explicitly declared "throw ()", propagate that to 1489 the corresponding builtin. */ 1490 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL 1491 && DECL_ANTICIPATED (olddecl) 1492 && TREE_NOTHROW (newdecl) 1493 && !TREE_NOTHROW (olddecl)) 1494 { 1495 enum built_in_function fncode = DECL_FUNCTION_CODE (olddecl); 1496 tree tmpdecl = builtin_decl_explicit (fncode); 1497 if (tmpdecl && tmpdecl != olddecl && types_match) 1498 TREE_NOTHROW (tmpdecl) = 1; 1499 } 1500 1501 /* Whether or not the builtin can throw exceptions has no 1502 bearing on this declarator. */ 1503 TREE_NOTHROW (olddecl) = 0; 1504 1505 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl)) 1506 { 1507 /* If a builtin function is redeclared as `static', merge 1508 the declarations, but make the original one static. */ 1509 DECL_THIS_STATIC (olddecl) = 1; 1510 TREE_PUBLIC (olddecl) = 0; 1511 1512 /* Make the old declaration consistent with the new one so 1513 that all remnants of the builtin-ness of this function 1514 will be banished. */ 1515 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl)); 1516 COPY_DECL_RTL (newdecl, olddecl); 1517 } 1518 } 1519 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl)) 1520 { 1521 /* C++ Standard, 3.3, clause 4: 1522 "[Note: a namespace name or a class template name must be unique 1523 in its declarative region (7.3.2, clause 14). ]" */ 1524 if (TREE_CODE (olddecl) != NAMESPACE_DECL 1525 && TREE_CODE (newdecl) != NAMESPACE_DECL 1526 && (TREE_CODE (olddecl) != TEMPLATE_DECL 1527 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL) 1528 && (TREE_CODE (newdecl) != TEMPLATE_DECL 1529 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL)) 1530 { 1531 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl) 1532 && TREE_CODE (newdecl) != TYPE_DECL) 1533 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl) 1534 && TREE_CODE (olddecl) != TYPE_DECL)) 1535 { 1536 /* We do nothing special here, because C++ does such nasty 1537 things with TYPE_DECLs. Instead, just let the TYPE_DECL 1538 get shadowed, and know that if we need to find a TYPE_DECL 1539 for a given name, we can look in the IDENTIFIER_TYPE_VALUE 1540 slot of the identifier. */ 1541 return NULL_TREE; 1542 } 1543 1544 if ((TREE_CODE (newdecl) == FUNCTION_DECL 1545 && DECL_FUNCTION_TEMPLATE_P (olddecl)) 1546 || (TREE_CODE (olddecl) == FUNCTION_DECL 1547 && DECL_FUNCTION_TEMPLATE_P (newdecl))) 1548 return NULL_TREE; 1549 } 1550 1551 error ("%q#D redeclared as different kind of symbol", newdecl); 1552 if (TREE_CODE (olddecl) == TREE_LIST) 1553 olddecl = TREE_VALUE (olddecl); 1554 inform (DECL_SOURCE_LOCATION (olddecl), 1555 "previous declaration %q#D", olddecl); 1556 1557 return error_mark_node; 1558 } 1559 else if (!types_match) 1560 { 1561 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)) 1562 /* These are certainly not duplicate declarations; they're 1563 from different scopes. */ 1564 return NULL_TREE; 1565 1566 if (TREE_CODE (newdecl) == TEMPLATE_DECL) 1567 { 1568 /* The name of a class template may not be declared to refer to 1569 any other template, class, function, object, namespace, value, 1570 or type in the same scope. */ 1571 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL 1572 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) 1573 { 1574 error ("conflicting declaration of template %q#D", newdecl); 1575 inform (DECL_SOURCE_LOCATION (olddecl), 1576 "previous declaration %q#D", olddecl); 1577 return error_mark_node; 1578 } 1579 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL 1580 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL 1581 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))), 1582 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)))) 1583 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl), 1584 DECL_TEMPLATE_PARMS (olddecl)) 1585 /* Template functions can be disambiguated by 1586 return type. */ 1587 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)), 1588 TREE_TYPE (TREE_TYPE (olddecl)))) 1589 { 1590 error ("ambiguating new declaration %q#D", newdecl); 1591 inform (DECL_SOURCE_LOCATION (olddecl), 1592 "old declaration %q#D", olddecl); 1593 } 1594 return NULL_TREE; 1595 } 1596 if (TREE_CODE (newdecl) == FUNCTION_DECL) 1597 { 1598 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl)) 1599 { 1600 error ("conflicting declaration of C function %q#D", 1601 newdecl); 1602 inform (DECL_SOURCE_LOCATION (olddecl), 1603 "previous declaration %q#D", olddecl); 1604 return NULL_TREE; 1605 } 1606 /* For function versions, params and types match, but they 1607 are not ambiguous. */ 1608 else if ((!DECL_FUNCTION_VERSIONED (newdecl) 1609 && !DECL_FUNCTION_VERSIONED (olddecl)) 1610 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), 1611 TYPE_ARG_TYPES (TREE_TYPE (olddecl)))) 1612 { 1613 error ("ambiguating new declaration of %q#D", newdecl); 1614 inform (DECL_SOURCE_LOCATION (olddecl), 1615 "old declaration %q#D", olddecl); 1616 return error_mark_node; 1617 } 1618 else 1619 return NULL_TREE; 1620 } 1621 else 1622 { 1623 error ("conflicting declaration %q#D", newdecl); 1624 inform (DECL_SOURCE_LOCATION (olddecl), 1625 "previous declaration as %q#D", olddecl); 1626 return error_mark_node; 1627 } 1628 } 1629 else if (TREE_CODE (newdecl) == FUNCTION_DECL 1630 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl) 1631 && (!DECL_TEMPLATE_INFO (newdecl) 1632 || (DECL_TI_TEMPLATE (newdecl) 1633 != DECL_TI_TEMPLATE (olddecl)))) 1634 || (DECL_TEMPLATE_SPECIALIZATION (newdecl) 1635 && (!DECL_TEMPLATE_INFO (olddecl) 1636 || (DECL_TI_TEMPLATE (olddecl) 1637 != DECL_TI_TEMPLATE (newdecl)))))) 1638 /* It's OK to have a template specialization and a non-template 1639 with the same type, or to have specializations of two 1640 different templates with the same type. Note that if one is a 1641 specialization, and the other is an instantiation of the same 1642 template, that we do not exit at this point. That situation 1643 can occur if we instantiate a template class, and then 1644 specialize one of its methods. This situation is valid, but 1645 the declarations must be merged in the usual way. */ 1646 return NULL_TREE; 1647 else if (TREE_CODE (newdecl) == FUNCTION_DECL 1648 && ((DECL_TEMPLATE_INSTANTIATION (olddecl) 1649 && !DECL_USE_TEMPLATE (newdecl)) 1650 || (DECL_TEMPLATE_INSTANTIATION (newdecl) 1651 && !DECL_USE_TEMPLATE (olddecl)))) 1652 /* One of the declarations is a template instantiation, and the 1653 other is not a template at all. That's OK. */ 1654 return NULL_TREE; 1655 else if (TREE_CODE (newdecl) == NAMESPACE_DECL) 1656 { 1657 /* In [namespace.alias] we have: 1658 1659 In a declarative region, a namespace-alias-definition can be 1660 used to redefine a namespace-alias declared in that declarative 1661 region to refer only to the namespace to which it already 1662 refers. 1663 1664 Therefore, if we encounter a second alias directive for the same 1665 alias, we can just ignore the second directive. */ 1666 if (DECL_NAMESPACE_ALIAS (newdecl) 1667 && (DECL_NAMESPACE_ALIAS (newdecl) 1668 == DECL_NAMESPACE_ALIAS (olddecl))) 1669 return olddecl; 1670 /* [namespace.alias] 1671 1672 A namespace-name or namespace-alias shall not be declared as 1673 the name of any other entity in the same declarative region. 1674 A namespace-name defined at global scope shall not be 1675 declared as the name of any other entity in any global scope 1676 of the program. */ 1677 error ("conflicting declaration of namespace %qD", newdecl); 1678 inform (DECL_SOURCE_LOCATION (olddecl), 1679 "previous declaration of namespace %qD here", olddecl); 1680 return error_mark_node; 1681 } 1682 else 1683 { 1684 const char *errmsg = redeclaration_error_message (newdecl, olddecl); 1685 if (errmsg) 1686 { 1687 error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl); 1688 if (DECL_NAME (olddecl) != NULL_TREE) 1689 inform (input_location, 1690 (DECL_INITIAL (olddecl) && namespace_bindings_p ()) 1691 ? G_("%q+#D previously defined here") 1692 : G_("%q+#D previously declared here"), olddecl); 1693 return error_mark_node; 1694 } 1695 else if (TREE_CODE (olddecl) == FUNCTION_DECL 1696 && DECL_INITIAL (olddecl) != NULL_TREE 1697 && !prototype_p (TREE_TYPE (olddecl)) 1698 && prototype_p (TREE_TYPE (newdecl))) 1699 { 1700 /* Prototype decl follows defn w/o prototype. */ 1701 if (warning_at (DECL_SOURCE_LOCATION (newdecl), 0, 1702 "prototype specified for %q#D", newdecl)) 1703 inform (DECL_SOURCE_LOCATION (olddecl), 1704 "previous non-prototype definition here"); 1705 } 1706 else if (VAR_OR_FUNCTION_DECL_P (olddecl) 1707 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)) 1708 { 1709 /* [dcl.link] 1710 If two declarations of the same function or object 1711 specify different linkage-specifications ..., the program 1712 is ill-formed.... Except for functions with C++ linkage, 1713 a function declaration without a linkage specification 1714 shall not precede the first linkage specification for 1715 that function. A function can be declared without a 1716 linkage specification after an explicit linkage 1717 specification has been seen; the linkage explicitly 1718 specified in the earlier declaration is not affected by 1719 such a function declaration. 1720 1721 DR 563 raises the question why the restrictions on 1722 functions should not also apply to objects. Older 1723 versions of G++ silently ignore the linkage-specification 1724 for this example: 1725 1726 namespace N { 1727 extern int i; 1728 extern "C" int i; 1729 } 1730 1731 which is clearly wrong. Therefore, we now treat objects 1732 like functions. */ 1733 if (current_lang_depth () == 0) 1734 { 1735 /* There is no explicit linkage-specification, so we use 1736 the linkage from the previous declaration. */ 1737 if (!DECL_LANG_SPECIFIC (newdecl)) 1738 retrofit_lang_decl (newdecl); 1739 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl)); 1740 } 1741 else 1742 { 1743 error ("conflicting declaration of %q#D with %qL linkage", 1744 newdecl, DECL_LANGUAGE (newdecl)); 1745 inform (DECL_SOURCE_LOCATION (olddecl), 1746 "previous declaration with %qL linkage", 1747 DECL_LANGUAGE (olddecl)); 1748 } 1749 } 1750 1751 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl)) 1752 ; 1753 else if (TREE_CODE (olddecl) == FUNCTION_DECL) 1754 { 1755 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */ 1756 if (DECL_FUNCTION_MEMBER_P (olddecl) 1757 && (/* grokfndecl passes member function templates too 1758 as FUNCTION_DECLs. */ 1759 DECL_TEMPLATE_INFO (olddecl) 1760 /* C++11 8.3.6/6. 1761 Default arguments for a member function of a class 1762 template shall be specified on the initial declaration 1763 of the member function within the class template. */ 1764 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl)))) 1765 check_redeclaration_no_default_args (newdecl); 1766 else 1767 { 1768 tree t1 = FUNCTION_FIRST_USER_PARMTYPE (olddecl); 1769 tree t2 = FUNCTION_FIRST_USER_PARMTYPE (newdecl); 1770 int i = 1; 1771 1772 for (; t1 && t1 != void_list_node; 1773 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++) 1774 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2)) 1775 { 1776 if (1 == simple_cst_equal (TREE_PURPOSE (t1), 1777 TREE_PURPOSE (t2))) 1778 { 1779 if (permerror (input_location, 1780 "default argument given for parameter " 1781 "%d of %q#D", i, newdecl)) 1782 inform (DECL_SOURCE_LOCATION (olddecl), 1783 "previous specification in %q#D here", 1784 olddecl); 1785 } 1786 else 1787 { 1788 error ("default argument given for parameter %d " 1789 "of %q#D", i, newdecl); 1790 inform (DECL_SOURCE_LOCATION (olddecl), 1791 "previous specification in %q#D here", 1792 olddecl); 1793 } 1794 } 1795 } 1796 } 1797 } 1798 1799 /* Do not merge an implicit typedef with an explicit one. In: 1800 1801 class A; 1802 ... 1803 typedef class A A __attribute__ ((foo)); 1804 1805 the attribute should apply only to the typedef. */ 1806 if (TREE_CODE (olddecl) == TYPE_DECL 1807 && (DECL_IMPLICIT_TYPEDEF_P (olddecl) 1808 || DECL_IMPLICIT_TYPEDEF_P (newdecl))) 1809 return NULL_TREE; 1810 1811 /* If new decl is `static' and an `extern' was seen previously, 1812 warn about it. */ 1813 warn_extern_redeclared_static (newdecl, olddecl); 1814 1815 if (!validate_constexpr_redeclaration (olddecl, newdecl)) 1816 return error_mark_node; 1817 1818 /* We have committed to returning 1 at this point. */ 1819 if (TREE_CODE (newdecl) == FUNCTION_DECL) 1820 { 1821 /* Now that functions must hold information normally held 1822 by field decls, there is extra work to do so that 1823 declaration information does not get destroyed during 1824 definition. */ 1825 if (DECL_VINDEX (olddecl)) 1826 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl); 1827 if (DECL_CONTEXT (olddecl)) 1828 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl); 1829 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl); 1830 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl); 1831 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl); 1832 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl); 1833 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl); 1834 DECL_FINAL_P (newdecl) |= DECL_FINAL_P (olddecl); 1835 DECL_OVERRIDE_P (newdecl) |= DECL_OVERRIDE_P (olddecl); 1836 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl); 1837 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK) 1838 SET_OVERLOADED_OPERATOR_CODE 1839 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl)); 1840 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE; 1841 1842 /* Optionally warn about more than one declaration for the same 1843 name, but don't warn about a function declaration followed by a 1844 definition. */ 1845 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl) 1846 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE) 1847 /* Don't warn about extern decl followed by definition. */ 1848 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)) 1849 /* Don't warn about friends, let add_friend take care of it. */ 1850 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)) 1851 /* Don't warn about declaration followed by specialization. */ 1852 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl) 1853 || DECL_TEMPLATE_SPECIALIZATION (olddecl))) 1854 { 1855 if (warning (OPT_Wredundant_decls, 1856 "redundant redeclaration of %qD in same scope", 1857 newdecl)) 1858 inform (DECL_SOURCE_LOCATION (olddecl), 1859 "previous declaration of %qD", olddecl); 1860 } 1861 1862 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl) 1863 && DECL_TEMPLATE_SPECIALIZATION (newdecl))) 1864 { 1865 if (DECL_DELETED_FN (newdecl)) 1866 { 1867 error ("deleted definition of %qD", newdecl); 1868 inform (DECL_SOURCE_LOCATION (olddecl), 1869 "previous declaration of %qD", olddecl); 1870 } 1871 DECL_DELETED_FN (newdecl) |= DECL_DELETED_FN (olddecl); 1872 } 1873 } 1874 1875 /* Deal with C++: must preserve virtual function table size. */ 1876 if (TREE_CODE (olddecl) == TYPE_DECL) 1877 { 1878 tree newtype = TREE_TYPE (newdecl); 1879 tree oldtype = TREE_TYPE (olddecl); 1880 1881 if (newtype != error_mark_node && oldtype != error_mark_node 1882 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype)) 1883 CLASSTYPE_FRIEND_CLASSES (newtype) 1884 = CLASSTYPE_FRIEND_CLASSES (oldtype); 1885 1886 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl); 1887 } 1888 1889 /* Copy all the DECL_... slots specified in the new decl 1890 except for any that we copy here from the old type. */ 1891 DECL_ATTRIBUTES (newdecl) 1892 = (*targetm.merge_decl_attributes) (olddecl, newdecl); 1893 1894 if (DECL_DECLARES_FUNCTION_P (olddecl) && DECL_DECLARES_FUNCTION_P (newdecl)) 1895 { 1896 olddecl_friend = DECL_FRIEND_P (olddecl); 1897 hidden_friend = (DECL_ANTICIPATED (olddecl) 1898 && DECL_HIDDEN_FRIEND_P (olddecl) 1899 && newdecl_is_friend); 1900 if (!hidden_friend) 1901 { 1902 DECL_ANTICIPATED (olddecl) = 0; 1903 DECL_HIDDEN_FRIEND_P (olddecl) = 0; 1904 } 1905 } 1906 1907 if (TREE_CODE (newdecl) == TEMPLATE_DECL) 1908 { 1909 tree old_result; 1910 tree new_result; 1911 old_result = DECL_TEMPLATE_RESULT (olddecl); 1912 new_result = DECL_TEMPLATE_RESULT (newdecl); 1913 TREE_TYPE (olddecl) = TREE_TYPE (old_result); 1914 DECL_TEMPLATE_SPECIALIZATIONS (olddecl) 1915 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl), 1916 DECL_TEMPLATE_SPECIALIZATIONS (newdecl)); 1917 1918 DECL_ATTRIBUTES (old_result) 1919 = (*targetm.merge_decl_attributes) (old_result, new_result); 1920 1921 if (DECL_FUNCTION_TEMPLATE_P (newdecl)) 1922 { 1923 /* Per C++11 8.3.6/4, default arguments cannot be added in later 1924 declarations of a function template. */ 1925 if (DECL_SOURCE_LOCATION (newdecl) 1926 != DECL_SOURCE_LOCATION (olddecl)) 1927 check_redeclaration_no_default_args (newdecl); 1928 1929 check_default_args (newdecl); 1930 1931 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result) 1932 && DECL_INITIAL (new_result)) 1933 { 1934 if (DECL_INITIAL (old_result)) 1935 DECL_UNINLINABLE (old_result) = 1; 1936 else 1937 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result); 1938 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result); 1939 DECL_NOT_REALLY_EXTERN (old_result) 1940 = DECL_NOT_REALLY_EXTERN (new_result); 1941 DECL_INTERFACE_KNOWN (old_result) 1942 = DECL_INTERFACE_KNOWN (new_result); 1943 DECL_DECLARED_INLINE_P (old_result) 1944 = DECL_DECLARED_INLINE_P (new_result); 1945 DECL_DISREGARD_INLINE_LIMITS (old_result) 1946 |= DECL_DISREGARD_INLINE_LIMITS (new_result); 1947 1948 } 1949 else 1950 { 1951 DECL_DECLARED_INLINE_P (old_result) 1952 |= DECL_DECLARED_INLINE_P (new_result); 1953 DECL_DISREGARD_INLINE_LIMITS (old_result) 1954 |= DECL_DISREGARD_INLINE_LIMITS (new_result); 1955 check_redeclaration_exception_specification (newdecl, olddecl); 1956 } 1957 } 1958 1959 /* If the new declaration is a definition, update the file and 1960 line information on the declaration, and also make 1961 the old declaration the same definition. */ 1962 if (DECL_INITIAL (new_result) != NULL_TREE) 1963 { 1964 DECL_SOURCE_LOCATION (olddecl) 1965 = DECL_SOURCE_LOCATION (old_result) 1966 = DECL_SOURCE_LOCATION (newdecl); 1967 DECL_INITIAL (old_result) = DECL_INITIAL (new_result); 1968 if (DECL_FUNCTION_TEMPLATE_P (newdecl)) 1969 { 1970 tree parm; 1971 DECL_ARGUMENTS (old_result) 1972 = DECL_ARGUMENTS (new_result); 1973 for (parm = DECL_ARGUMENTS (old_result); parm; 1974 parm = DECL_CHAIN (parm)) 1975 DECL_CONTEXT (parm) = old_result; 1976 } 1977 } 1978 1979 return olddecl; 1980 } 1981 1982 if (types_match) 1983 { 1984 if (TREE_CODE (newdecl) == FUNCTION_DECL) 1985 check_redeclaration_exception_specification (newdecl, olddecl); 1986 1987 /* Automatically handles default parameters. */ 1988 tree oldtype = TREE_TYPE (olddecl); 1989 tree newtype; 1990 1991 /* For typedefs use the old type, as the new type's DECL_NAME points 1992 at newdecl, which will be ggc_freed. */ 1993 if (TREE_CODE (newdecl) == TYPE_DECL) 1994 { 1995 /* But NEWTYPE might have an attribute, honor that. */ 1996 tree tem = TREE_TYPE (newdecl); 1997 newtype = oldtype; 1998 1999 if (TYPE_USER_ALIGN (tem)) 2000 { 2001 if (TYPE_ALIGN (tem) > TYPE_ALIGN (newtype)) 2002 TYPE_ALIGN (newtype) = TYPE_ALIGN (tem); 2003 TYPE_USER_ALIGN (newtype) = true; 2004 } 2005 2006 /* And remove the new type from the variants list. */ 2007 if (TYPE_NAME (TREE_TYPE (newdecl)) == newdecl) 2008 { 2009 tree remove = TREE_TYPE (newdecl); 2010 for (tree t = TYPE_MAIN_VARIANT (remove); ; 2011 t = TYPE_NEXT_VARIANT (t)) 2012 if (TYPE_NEXT_VARIANT (t) == remove) 2013 { 2014 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (remove); 2015 break; 2016 } 2017 } 2018 } 2019 else 2020 /* Merge the data types specified in the two decls. */ 2021 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl)); 2022 2023 if (VAR_P (newdecl)) 2024 { 2025 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl); 2026 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl); 2027 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl) 2028 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl); 2029 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl) 2030 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl); 2031 2032 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */ 2033 if (DECL_LANG_SPECIFIC (olddecl) 2034 && CP_DECL_THREADPRIVATE_P (olddecl)) 2035 { 2036 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */ 2037 if (!DECL_LANG_SPECIFIC (newdecl)) 2038 retrofit_lang_decl (newdecl); 2039 2040 CP_DECL_THREADPRIVATE_P (newdecl) = 1; 2041 } 2042 } 2043 2044 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype; 2045 2046 if (TREE_CODE (newdecl) == FUNCTION_DECL) 2047 check_default_args (newdecl); 2048 2049 /* Lay the type out, unless already done. */ 2050 if (! same_type_p (newtype, oldtype) 2051 && TREE_TYPE (newdecl) != error_mark_node 2052 && !(processing_template_decl && uses_template_parms (newdecl))) 2053 layout_type (TREE_TYPE (newdecl)); 2054 2055 if ((VAR_P (newdecl) 2056 || TREE_CODE (newdecl) == PARM_DECL 2057 || TREE_CODE (newdecl) == RESULT_DECL 2058 || TREE_CODE (newdecl) == FIELD_DECL 2059 || TREE_CODE (newdecl) == TYPE_DECL) 2060 && !(processing_template_decl && uses_template_parms (newdecl))) 2061 layout_decl (newdecl, 0); 2062 2063 /* Merge the type qualifiers. */ 2064 if (TREE_READONLY (newdecl)) 2065 TREE_READONLY (olddecl) = 1; 2066 if (TREE_THIS_VOLATILE (newdecl)) 2067 TREE_THIS_VOLATILE (olddecl) = 1; 2068 if (TREE_NOTHROW (newdecl)) 2069 TREE_NOTHROW (olddecl) = 1; 2070 2071 /* Merge deprecatedness. */ 2072 if (TREE_DEPRECATED (newdecl)) 2073 TREE_DEPRECATED (olddecl) = 1; 2074 2075 /* Preserve function specific target and optimization options */ 2076 if (TREE_CODE (newdecl) == FUNCTION_DECL) 2077 { 2078 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl) 2079 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl)) 2080 DECL_FUNCTION_SPECIFIC_TARGET (newdecl) 2081 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl); 2082 2083 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl) 2084 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)) 2085 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl) 2086 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl); 2087 } 2088 2089 /* Merge the initialization information. */ 2090 if (DECL_INITIAL (newdecl) == NULL_TREE 2091 && DECL_INITIAL (olddecl) != NULL_TREE) 2092 { 2093 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl); 2094 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl); 2095 if (TREE_CODE (newdecl) == FUNCTION_DECL) 2096 { 2097 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl); 2098 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl); 2099 } 2100 } 2101 2102 if (TREE_CODE (newdecl) == FUNCTION_DECL) 2103 { 2104 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl) 2105 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl); 2106 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl); 2107 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl); 2108 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl); 2109 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl); 2110 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl); 2111 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl); 2112 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl); 2113 DECL_LOOPING_CONST_OR_PURE_P (newdecl) 2114 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl); 2115 /* Keep the old RTL. */ 2116 COPY_DECL_RTL (olddecl, newdecl); 2117 } 2118 else if (VAR_P (newdecl) 2119 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl))) 2120 { 2121 /* Keep the old RTL. We cannot keep the old RTL if the old 2122 declaration was for an incomplete object and the new 2123 declaration is not since many attributes of the RTL will 2124 change. */ 2125 COPY_DECL_RTL (olddecl, newdecl); 2126 } 2127 } 2128 /* If cannot merge, then use the new type and qualifiers, 2129 and don't preserve the old rtl. */ 2130 else 2131 { 2132 /* Clean out any memory we had of the old declaration. */ 2133 tree oldstatic = value_member (olddecl, static_aggregates); 2134 if (oldstatic) 2135 TREE_VALUE (oldstatic) = error_mark_node; 2136 2137 TREE_TYPE (olddecl) = TREE_TYPE (newdecl); 2138 TREE_READONLY (olddecl) = TREE_READONLY (newdecl); 2139 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl); 2140 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl); 2141 } 2142 2143 /* Merge the storage class information. */ 2144 merge_weak (newdecl, olddecl); 2145 2146 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl); 2147 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl); 2148 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl); 2149 if (! DECL_EXTERNAL (olddecl)) 2150 DECL_EXTERNAL (newdecl) = 0; 2151 2152 new_template_info = NULL_TREE; 2153 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl)) 2154 { 2155 bool new_redefines_gnu_inline = false; 2156 2157 if (new_defines_function 2158 && ((DECL_INTERFACE_KNOWN (olddecl) 2159 && TREE_CODE (olddecl) == FUNCTION_DECL) 2160 || (TREE_CODE (olddecl) == TEMPLATE_DECL 2161 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) 2162 == FUNCTION_DECL)))) 2163 { 2164 tree fn = olddecl; 2165 2166 if (TREE_CODE (fn) == TEMPLATE_DECL) 2167 fn = DECL_TEMPLATE_RESULT (olddecl); 2168 2169 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn); 2170 } 2171 2172 if (!new_redefines_gnu_inline) 2173 { 2174 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl); 2175 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl); 2176 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl); 2177 } 2178 DECL_TEMPLATE_INSTANTIATED (newdecl) 2179 |= DECL_TEMPLATE_INSTANTIATED (olddecl); 2180 DECL_ODR_USED (newdecl) |= DECL_ODR_USED (olddecl); 2181 2182 /* If the OLDDECL is an instantiation and/or specialization, 2183 then the NEWDECL must be too. But, it may not yet be marked 2184 as such if the caller has created NEWDECL, but has not yet 2185 figured out that it is a redeclaration. */ 2186 if (!DECL_USE_TEMPLATE (newdecl)) 2187 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl); 2188 2189 /* Don't really know how much of the language-specific 2190 values we should copy from old to new. */ 2191 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl); 2192 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl); 2193 DECL_INITIALIZED_IN_CLASS_P (newdecl) 2194 |= DECL_INITIALIZED_IN_CLASS_P (olddecl); 2195 2196 if (LANG_DECL_HAS_MIN (newdecl)) 2197 { 2198 DECL_LANG_SPECIFIC (newdecl)->u.min.u2 = 2199 DECL_LANG_SPECIFIC (olddecl)->u.min.u2; 2200 if (DECL_TEMPLATE_INFO (newdecl)) 2201 { 2202 new_template_info = DECL_TEMPLATE_INFO (newdecl); 2203 if (DECL_TEMPLATE_INSTANTIATION (olddecl) 2204 && DECL_TEMPLATE_SPECIALIZATION (newdecl)) 2205 /* Remember the presence of explicit specialization args. */ 2206 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl)) 2207 = TINFO_USED_TEMPLATE_ID (new_template_info); 2208 } 2209 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl); 2210 } 2211 /* Only functions have these fields. */ 2212 if (DECL_DECLARES_FUNCTION_P (newdecl)) 2213 { 2214 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl); 2215 DECL_BEFRIENDING_CLASSES (newdecl) 2216 = chainon (DECL_BEFRIENDING_CLASSES (newdecl), 2217 DECL_BEFRIENDING_CLASSES (olddecl)); 2218 /* DECL_THUNKS is only valid for virtual functions, 2219 otherwise it is a DECL_FRIEND_CONTEXT. */ 2220 if (DECL_VIRTUAL_P (newdecl)) 2221 SET_DECL_THUNKS (newdecl, DECL_THUNKS (olddecl)); 2222 } 2223 /* Only variables have this field. */ 2224 else if (VAR_P (newdecl) 2225 && VAR_HAD_UNKNOWN_BOUND (olddecl)) 2226 SET_VAR_HAD_UNKNOWN_BOUND (newdecl); 2227 } 2228 2229 if (TREE_CODE (newdecl) == FUNCTION_DECL) 2230 { 2231 tree parm; 2232 2233 /* Merge parameter attributes. */ 2234 tree oldarg, newarg; 2235 for (oldarg = DECL_ARGUMENTS(olddecl), 2236 newarg = DECL_ARGUMENTS(newdecl); 2237 oldarg && newarg; 2238 oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg)) { 2239 DECL_ATTRIBUTES (newarg) 2240 = (*targetm.merge_decl_attributes) (oldarg, newarg); 2241 DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg); 2242 } 2243 2244 if (DECL_TEMPLATE_INSTANTIATION (olddecl) 2245 && !DECL_TEMPLATE_INSTANTIATION (newdecl)) 2246 { 2247 /* If newdecl is not a specialization, then it is not a 2248 template-related function at all. And that means that we 2249 should have exited above, returning 0. */ 2250 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl)); 2251 2252 if (DECL_ODR_USED (olddecl)) 2253 /* From [temp.expl.spec]: 2254 2255 If a template, a member template or the member of a class 2256 template is explicitly specialized then that 2257 specialization shall be declared before the first use of 2258 that specialization that would cause an implicit 2259 instantiation to take place, in every translation unit in 2260 which such a use occurs. */ 2261 error ("explicit specialization of %qD after first use", 2262 olddecl); 2263 2264 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl); 2265 DECL_COMDAT (newdecl) = (TREE_PUBLIC (newdecl) 2266 && DECL_DECLARED_INLINE_P (newdecl)); 2267 2268 /* Don't propagate visibility from the template to the 2269 specialization here. We'll do that in determine_visibility if 2270 appropriate. */ 2271 DECL_VISIBILITY_SPECIFIED (olddecl) = 0; 2272 2273 /* [temp.expl.spec/14] We don't inline explicit specialization 2274 just because the primary template says so. */ 2275 2276 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with 2277 the always_inline attribute. */ 2278 if (DECL_DISREGARD_INLINE_LIMITS (olddecl) 2279 && !DECL_DISREGARD_INLINE_LIMITS (newdecl)) 2280 { 2281 if (DECL_DECLARED_INLINE_P (newdecl)) 2282 DECL_DISREGARD_INLINE_LIMITS (newdecl) = true; 2283 else 2284 DECL_ATTRIBUTES (newdecl) 2285 = remove_attribute ("always_inline", 2286 DECL_ATTRIBUTES (newdecl)); 2287 } 2288 } 2289 else if (new_defines_function && DECL_INITIAL (olddecl)) 2290 { 2291 /* Never inline re-defined extern inline functions. 2292 FIXME: this could be better handled by keeping both 2293 function as separate declarations. */ 2294 DECL_UNINLINABLE (newdecl) = 1; 2295 } 2296 else 2297 { 2298 if (DECL_PENDING_INLINE_INFO (newdecl) == 0) 2299 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl); 2300 2301 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl); 2302 2303 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl) 2304 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)); 2305 2306 DECL_DISREGARD_INLINE_LIMITS (newdecl) 2307 = DECL_DISREGARD_INLINE_LIMITS (olddecl) 2308 = (DECL_DISREGARD_INLINE_LIMITS (newdecl) 2309 || DECL_DISREGARD_INLINE_LIMITS (olddecl)); 2310 } 2311 2312 /* Preserve abstractness on cloned [cd]tors. */ 2313 DECL_ABSTRACT_P (newdecl) = DECL_ABSTRACT_P (olddecl); 2314 2315 /* Update newdecl's parms to point at olddecl. */ 2316 for (parm = DECL_ARGUMENTS (newdecl); parm; 2317 parm = DECL_CHAIN (parm)) 2318 DECL_CONTEXT (parm) = olddecl; 2319 2320 if (! types_match) 2321 { 2322 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl)); 2323 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl); 2324 COPY_DECL_RTL (newdecl, olddecl); 2325 } 2326 if (! types_match || new_defines_function) 2327 { 2328 /* These need to be copied so that the names are available. 2329 Note that if the types do match, we'll preserve inline 2330 info and other bits, but if not, we won't. */ 2331 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl); 2332 DECL_RESULT (olddecl) = DECL_RESULT (newdecl); 2333 } 2334 /* If redeclaring a builtin function, it stays built in 2335 if newdecl is a gnu_inline definition, or if newdecl is just 2336 a declaration. */ 2337 if (DECL_BUILT_IN (olddecl) 2338 && (new_defines_function ? GNU_INLINE_P (newdecl) : types_match)) 2339 { 2340 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl); 2341 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl); 2342 /* If we're keeping the built-in definition, keep the rtl, 2343 regardless of declaration matches. */ 2344 COPY_DECL_RTL (olddecl, newdecl); 2345 if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL) 2346 { 2347 enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl); 2348 switch (fncode) 2349 { 2350 /* If a compatible prototype of these builtin functions 2351 is seen, assume the runtime implements it with the 2352 expected semantics. */ 2353 case BUILT_IN_STPCPY: 2354 if (builtin_decl_explicit_p (fncode)) 2355 set_builtin_decl_implicit_p (fncode, true); 2356 break; 2357 default: 2358 if (builtin_decl_explicit_p (fncode)) 2359 set_builtin_decl_declared_p (fncode, true); 2360 break; 2361 } 2362 } 2363 } 2364 if (new_defines_function) 2365 /* If defining a function declared with other language 2366 linkage, use the previously declared language linkage. */ 2367 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl)); 2368 else if (types_match) 2369 { 2370 DECL_RESULT (newdecl) = DECL_RESULT (olddecl); 2371 /* Don't clear out the arguments if we're just redeclaring a 2372 function. */ 2373 if (DECL_ARGUMENTS (olddecl)) 2374 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl); 2375 } 2376 } 2377 else if (TREE_CODE (newdecl) == NAMESPACE_DECL) 2378 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl); 2379 2380 /* Now preserve various other info from the definition. */ 2381 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl); 2382 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl); 2383 DECL_COMMON (newdecl) = DECL_COMMON (olddecl); 2384 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl); 2385 2386 /* Warn about conflicting visibility specifications. */ 2387 if (DECL_VISIBILITY_SPECIFIED (olddecl) 2388 && DECL_VISIBILITY_SPECIFIED (newdecl) 2389 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl)) 2390 { 2391 if (warning_at (DECL_SOURCE_LOCATION (newdecl), OPT_Wattributes, 2392 "%qD: visibility attribute ignored because it " 2393 "conflicts with previous declaration", newdecl)) 2394 inform (DECL_SOURCE_LOCATION (olddecl), 2395 "previous declaration of %qD", olddecl); 2396 } 2397 /* Choose the declaration which specified visibility. */ 2398 if (DECL_VISIBILITY_SPECIFIED (olddecl)) 2399 { 2400 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl); 2401 DECL_VISIBILITY_SPECIFIED (newdecl) = 1; 2402 } 2403 /* Init priority used to be merged from newdecl to olddecl by the memcpy, 2404 so keep this behavior. */ 2405 if (VAR_P (newdecl) && DECL_HAS_INIT_PRIORITY_P (newdecl)) 2406 { 2407 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl)); 2408 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1; 2409 } 2410 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */ 2411 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl)) 2412 { 2413 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl); 2414 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl); 2415 } 2416 DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl); 2417 if (TREE_CODE (newdecl) == FIELD_DECL) 2418 DECL_PACKED (olddecl) = DECL_PACKED (newdecl); 2419 2420 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced 2421 with that from NEWDECL below. */ 2422 if (DECL_LANG_SPECIFIC (olddecl)) 2423 { 2424 gcc_assert (DECL_LANG_SPECIFIC (olddecl) 2425 != DECL_LANG_SPECIFIC (newdecl)); 2426 ggc_free (DECL_LANG_SPECIFIC (olddecl)); 2427 } 2428 2429 /* Merge the USED information. */ 2430 if (TREE_USED (olddecl)) 2431 TREE_USED (newdecl) = 1; 2432 else if (TREE_USED (newdecl)) 2433 TREE_USED (olddecl) = 1; 2434 if (VAR_P (newdecl)) 2435 { 2436 if (DECL_READ_P (olddecl)) 2437 DECL_READ_P (newdecl) = 1; 2438 else if (DECL_READ_P (newdecl)) 2439 DECL_READ_P (olddecl) = 1; 2440 } 2441 if (DECL_PRESERVE_P (olddecl)) 2442 DECL_PRESERVE_P (newdecl) = 1; 2443 else if (DECL_PRESERVE_P (newdecl)) 2444 DECL_PRESERVE_P (olddecl) = 1; 2445 2446 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied 2447 to olddecl and deleted. */ 2448 if (TREE_CODE (newdecl) == FUNCTION_DECL 2449 && DECL_FUNCTION_VERSIONED (olddecl)) 2450 { 2451 /* Set the flag for newdecl so that it gets copied to olddecl. */ 2452 DECL_FUNCTION_VERSIONED (newdecl) = 1; 2453 /* newdecl will be purged after copying to olddecl and is no longer 2454 a version. */ 2455 cgraph_node::delete_function_version (newdecl); 2456 } 2457 2458 if (TREE_CODE (newdecl) == FUNCTION_DECL) 2459 { 2460 int function_size; 2461 struct symtab_node *snode = symtab_node::get (olddecl); 2462 2463 function_size = sizeof (struct tree_decl_common); 2464 2465 memcpy ((char *) olddecl + sizeof (struct tree_common), 2466 (char *) newdecl + sizeof (struct tree_common), 2467 function_size - sizeof (struct tree_common)); 2468 2469 memcpy ((char *) olddecl + sizeof (struct tree_decl_common), 2470 (char *) newdecl + sizeof (struct tree_decl_common), 2471 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common)); 2472 2473 /* Preserve symtab node mapping. */ 2474 olddecl->decl_with_vis.symtab_node = snode; 2475 2476 if (new_template_info) 2477 /* If newdecl is a template instantiation, it is possible that 2478 the following sequence of events has occurred: 2479 2480 o A friend function was declared in a class template. The 2481 class template was instantiated. 2482 2483 o The instantiation of the friend declaration was 2484 recorded on the instantiation list, and is newdecl. 2485 2486 o Later, however, instantiate_class_template called pushdecl 2487 on the newdecl to perform name injection. But, pushdecl in 2488 turn called duplicate_decls when it discovered that another 2489 declaration of a global function with the same name already 2490 existed. 2491 2492 o Here, in duplicate_decls, we decided to clobber newdecl. 2493 2494 If we're going to do that, we'd better make sure that 2495 olddecl, and not newdecl, is on the list of 2496 instantiations so that if we try to do the instantiation 2497 again we won't get the clobbered declaration. */ 2498 reregister_specialization (newdecl, 2499 new_template_info, 2500 olddecl); 2501 } 2502 else 2503 { 2504 size_t size = tree_code_size (TREE_CODE (newdecl)); 2505 2506 memcpy ((char *) olddecl + sizeof (struct tree_common), 2507 (char *) newdecl + sizeof (struct tree_common), 2508 sizeof (struct tree_decl_common) - sizeof (struct tree_common)); 2509 switch (TREE_CODE (newdecl)) 2510 { 2511 case LABEL_DECL: 2512 case VAR_DECL: 2513 case RESULT_DECL: 2514 case PARM_DECL: 2515 case FIELD_DECL: 2516 case TYPE_DECL: 2517 case CONST_DECL: 2518 { 2519 struct symtab_node *snode = NULL; 2520 2521 if (TREE_CODE (newdecl) == VAR_DECL 2522 && (TREE_STATIC (olddecl) || TREE_PUBLIC (olddecl) || DECL_EXTERNAL (olddecl))) 2523 snode = symtab_node::get (olddecl); 2524 memcpy ((char *) olddecl + sizeof (struct tree_decl_common), 2525 (char *) newdecl + sizeof (struct tree_decl_common), 2526 size - sizeof (struct tree_decl_common) 2527 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *)); 2528 if (TREE_CODE (newdecl) == VAR_DECL) 2529 olddecl->decl_with_vis.symtab_node = snode; 2530 } 2531 break; 2532 default: 2533 memcpy ((char *) olddecl + sizeof (struct tree_decl_common), 2534 (char *) newdecl + sizeof (struct tree_decl_common), 2535 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common) 2536 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *)); 2537 break; 2538 } 2539 } 2540 2541 if (TREE_CODE (newdecl) == FUNCTION_DECL 2542 || TREE_CODE (newdecl) == VAR_DECL) 2543 { 2544 if (DECL_EXTERNAL (olddecl) 2545 || TREE_PUBLIC (olddecl) 2546 || TREE_STATIC (olddecl)) 2547 { 2548 /* Merge the section attribute. 2549 We want to issue an error if the sections conflict but that must be 2550 done later in decl_attributes since we are called before attributes 2551 are assigned. */ 2552 if (DECL_SECTION_NAME (newdecl) != NULL) 2553 set_decl_section_name (olddecl, DECL_SECTION_NAME (newdecl)); 2554 2555 if (DECL_ONE_ONLY (newdecl)) 2556 { 2557 struct symtab_node *oldsym, *newsym; 2558 if (TREE_CODE (olddecl) == FUNCTION_DECL) 2559 oldsym = cgraph_node::get_create (olddecl); 2560 else 2561 oldsym = varpool_node::get_create (olddecl); 2562 newsym = symtab_node::get (newdecl); 2563 oldsym->set_comdat_group (newsym->get_comdat_group ()); 2564 } 2565 } 2566 2567 if (TREE_CODE (newdecl) == VAR_DECL 2568 && DECL_THREAD_LOCAL_P (newdecl)) 2569 set_decl_tls_model (olddecl, DECL_TLS_MODEL (newdecl)); 2570 } 2571 2572 DECL_UID (olddecl) = olddecl_uid; 2573 if (olddecl_friend) 2574 DECL_FRIEND_P (olddecl) = 1; 2575 if (hidden_friend) 2576 { 2577 DECL_ANTICIPATED (olddecl) = 1; 2578 DECL_HIDDEN_FRIEND_P (olddecl) = 1; 2579 } 2580 2581 /* NEWDECL contains the merged attribute lists. 2582 Update OLDDECL to be the same. */ 2583 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl); 2584 2585 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl 2586 so that encode_section_info has a chance to look at the new decl 2587 flags and attributes. */ 2588 if (DECL_RTL_SET_P (olddecl) 2589 && (TREE_CODE (olddecl) == FUNCTION_DECL 2590 || (VAR_P (olddecl) 2591 && TREE_STATIC (olddecl)))) 2592 make_decl_rtl (olddecl); 2593 2594 /* The NEWDECL will no longer be needed. Because every out-of-class 2595 declaration of a member results in a call to duplicate_decls, 2596 freeing these nodes represents in a significant savings. 2597 2598 Before releasing the node, be sore to remove function from symbol 2599 table that might have been inserted there to record comdat group. 2600 Be sure to however do not free DECL_STRUCT_FUNCTION becuase this 2601 structure is shared in between newdecl and oldecl. */ 2602 if (TREE_CODE (newdecl) == FUNCTION_DECL) 2603 DECL_STRUCT_FUNCTION (newdecl) = NULL; 2604 if (TREE_CODE (newdecl) == FUNCTION_DECL 2605 || TREE_CODE (newdecl) == VAR_DECL) 2606 { 2607 struct symtab_node *snode = symtab_node::get (newdecl); 2608 if (snode) 2609 snode->remove (); 2610 } 2611 ggc_free (newdecl); 2612 2613 return olddecl; 2614} 2615 2616/* Return zero if the declaration NEWDECL is valid 2617 when the declaration OLDDECL (assumed to be for the same name) 2618 has already been seen. 2619 Otherwise return an error message format string with a %s 2620 where the identifier should go. */ 2621 2622static const char * 2623redeclaration_error_message (tree newdecl, tree olddecl) 2624{ 2625 if (TREE_CODE (newdecl) == TYPE_DECL) 2626 { 2627 /* Because C++ can put things into name space for free, 2628 constructs like "typedef struct foo { ... } foo" 2629 would look like an erroneous redeclaration. */ 2630 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl))) 2631 return NULL; 2632 else 2633 return G_("redefinition of %q#D"); 2634 } 2635 else if (TREE_CODE (newdecl) == FUNCTION_DECL) 2636 { 2637 /* If this is a pure function, its olddecl will actually be 2638 the original initialization to `0' (which we force to call 2639 abort()). Don't complain about redefinition in this case. */ 2640 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl) 2641 && DECL_INITIAL (olddecl) == NULL_TREE) 2642 return NULL; 2643 2644 /* If both functions come from different namespaces, this is not 2645 a redeclaration - this is a conflict with a used function. */ 2646 if (DECL_NAMESPACE_SCOPE_P (olddecl) 2647 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl) 2648 && ! decls_match (olddecl, newdecl)) 2649 return G_("%qD conflicts with used function"); 2650 2651 /* We'll complain about linkage mismatches in 2652 warn_extern_redeclared_static. */ 2653 2654 /* Defining the same name twice is no good. */ 2655 if (DECL_INITIAL (olddecl) != NULL_TREE 2656 && DECL_INITIAL (newdecl) != NULL_TREE) 2657 { 2658 if (DECL_NAME (olddecl) == NULL_TREE) 2659 return G_("%q#D not declared in class"); 2660 else if (!GNU_INLINE_P (olddecl) 2661 || GNU_INLINE_P (newdecl)) 2662 return G_("redefinition of %q#D"); 2663 } 2664 2665 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl)) 2666 { 2667 bool olda = GNU_INLINE_P (olddecl); 2668 bool newa = GNU_INLINE_P (newdecl); 2669 2670 if (olda != newa) 2671 { 2672 if (newa) 2673 return G_("%q+D redeclared inline with " 2674 "%<gnu_inline%> attribute"); 2675 else 2676 return G_("%q+D redeclared inline without " 2677 "%<gnu_inline%> attribute"); 2678 } 2679 } 2680 2681 check_abi_tag_redeclaration 2682 (olddecl, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl)), 2683 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl))); 2684 2685 return NULL; 2686 } 2687 else if (TREE_CODE (newdecl) == TEMPLATE_DECL) 2688 { 2689 tree nt, ot; 2690 2691 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL) 2692 { 2693 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl)) 2694 && COMPLETE_TYPE_P (TREE_TYPE (olddecl))) 2695 return G_("redefinition of %q#D"); 2696 return NULL; 2697 } 2698 2699 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL 2700 || (DECL_TEMPLATE_RESULT (newdecl) 2701 == DECL_TEMPLATE_RESULT (olddecl))) 2702 return NULL; 2703 2704 nt = DECL_TEMPLATE_RESULT (newdecl); 2705 if (DECL_TEMPLATE_INFO (nt)) 2706 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt)); 2707 ot = DECL_TEMPLATE_RESULT (olddecl); 2708 if (DECL_TEMPLATE_INFO (ot)) 2709 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot)); 2710 if (DECL_INITIAL (nt) && DECL_INITIAL (ot) 2711 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt))) 2712 return G_("redefinition of %q#D"); 2713 2714 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt)) 2715 { 2716 bool olda = GNU_INLINE_P (ot); 2717 bool newa = GNU_INLINE_P (nt); 2718 2719 if (olda != newa) 2720 { 2721 if (newa) 2722 return G_("%q+D redeclared inline with " 2723 "%<gnu_inline%> attribute"); 2724 else 2725 return G_("%q+D redeclared inline without " 2726 "%<gnu_inline%> attribute"); 2727 } 2728 } 2729 2730 /* Core issue #226 (C++0x): 2731 2732 If a friend function template declaration specifies a 2733 default template-argument, that declaration shall be a 2734 definition and shall be the only declaration of the 2735 function template in the translation unit. */ 2736 if ((cxx_dialect != cxx98) 2737 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot) 2738 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl), 2739 /*is_primary=*/true, 2740 /*is_partial=*/false, 2741 /*is_friend_decl=*/2)) 2742 return G_("redeclaration of friend %q#D " 2743 "may not have default template arguments"); 2744 2745 return NULL; 2746 } 2747 else if (VAR_P (newdecl) 2748 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl) 2749 && (! DECL_LANG_SPECIFIC (olddecl) 2750 || ! CP_DECL_THREADPRIVATE_P (olddecl) 2751 || DECL_THREAD_LOCAL_P (newdecl))) 2752 { 2753 /* Only variables can be thread-local, and all declarations must 2754 agree on this property. */ 2755 if (DECL_THREAD_LOCAL_P (newdecl)) 2756 return G_("thread-local declaration of %q#D follows " 2757 "non-thread-local declaration"); 2758 else 2759 return G_("non-thread-local declaration of %q#D follows " 2760 "thread-local declaration"); 2761 } 2762 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl)) 2763 { 2764 /* The objects have been declared at namespace scope. If either 2765 is a member of an anonymous union, then this is an invalid 2766 redeclaration. For example: 2767 2768 int i; 2769 union { int i; }; 2770 2771 is invalid. */ 2772 if ((VAR_P (newdecl) && DECL_ANON_UNION_VAR_P (newdecl)) 2773 || (VAR_P (olddecl) && DECL_ANON_UNION_VAR_P (olddecl))) 2774 return G_("redeclaration of %q#D"); 2775 /* If at least one declaration is a reference, there is no 2776 conflict. For example: 2777 2778 int i = 3; 2779 extern int i; 2780 2781 is valid. */ 2782 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl)) 2783 return NULL; 2784 /* Reject two definitions. */ 2785 return G_("redefinition of %q#D"); 2786 } 2787 else 2788 { 2789 /* Objects declared with block scope: */ 2790 /* Reject two definitions, and reject a definition 2791 together with an external reference. */ 2792 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl))) 2793 return G_("redeclaration of %q#D"); 2794 return NULL; 2795 } 2796} 2797 2798/* Hash and equality functions for the named_label table. */ 2799 2800hashval_t 2801named_label_hasher::hash (named_label_entry *ent) 2802{ 2803 return DECL_UID (ent->label_decl); 2804} 2805 2806bool 2807named_label_hasher::equal (named_label_entry *a, named_label_entry *b) 2808{ 2809 return a->label_decl == b->label_decl; 2810} 2811 2812/* Create a new label, named ID. */ 2813 2814static tree 2815make_label_decl (tree id, int local_p) 2816{ 2817 struct named_label_entry *ent; 2818 tree decl; 2819 2820 decl = build_decl (input_location, LABEL_DECL, id, void_type_node); 2821 2822 DECL_CONTEXT (decl) = current_function_decl; 2823 DECL_MODE (decl) = VOIDmode; 2824 C_DECLARED_LABEL_FLAG (decl) = local_p; 2825 2826 /* Say where one reference is to the label, for the sake of the 2827 error if it is not defined. */ 2828 DECL_SOURCE_LOCATION (decl) = input_location; 2829 2830 /* Record the fact that this identifier is bound to this label. */ 2831 SET_IDENTIFIER_LABEL_VALUE (id, decl); 2832 2833 /* Create the label htab for the function on demand. */ 2834 if (!named_labels) 2835 named_labels = hash_table<named_label_hasher>::create_ggc (13); 2836 2837 /* Record this label on the list of labels used in this function. 2838 We do this before calling make_label_decl so that we get the 2839 IDENTIFIER_LABEL_VALUE before the new label is declared. */ 2840 ent = ggc_cleared_alloc<named_label_entry> (); 2841 ent->label_decl = decl; 2842 2843 named_label_entry **slot = named_labels->find_slot (ent, INSERT); 2844 gcc_assert (*slot == NULL); 2845 *slot = ent; 2846 2847 return decl; 2848} 2849 2850/* Look for a label named ID in the current function. If one cannot 2851 be found, create one. (We keep track of used, but undefined, 2852 labels, and complain about them at the end of a function.) */ 2853 2854static tree 2855lookup_label_1 (tree id) 2856{ 2857 tree decl; 2858 2859 /* You can't use labels at global scope. */ 2860 if (current_function_decl == NULL_TREE) 2861 { 2862 error ("label %qE referenced outside of any function", id); 2863 return NULL_TREE; 2864 } 2865 2866 /* See if we've already got this label. */ 2867 decl = IDENTIFIER_LABEL_VALUE (id); 2868 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl) 2869 return decl; 2870 2871 decl = make_label_decl (id, /*local_p=*/0); 2872 return decl; 2873} 2874 2875/* Wrapper for lookup_label_1. */ 2876 2877tree 2878lookup_label (tree id) 2879{ 2880 tree ret; 2881 bool subtime = timevar_cond_start (TV_NAME_LOOKUP); 2882 ret = lookup_label_1 (id); 2883 timevar_cond_stop (TV_NAME_LOOKUP, subtime); 2884 return ret; 2885} 2886 2887/* Declare a local label named ID. */ 2888 2889tree 2890declare_local_label (tree id) 2891{ 2892 tree decl; 2893 cp_label_binding bind; 2894 2895 /* Add a new entry to the SHADOWED_LABELS list so that when we leave 2896 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */ 2897 bind.prev_value = IDENTIFIER_LABEL_VALUE (id); 2898 2899 decl = make_label_decl (id, /*local_p=*/1); 2900 bind.label = decl; 2901 vec_safe_push (current_binding_level->shadowed_labels, bind); 2902 2903 return decl; 2904} 2905 2906/* Returns nonzero if it is ill-formed to jump past the declaration of 2907 DECL. Returns 2 if it's also a real problem. */ 2908 2909static int 2910decl_jump_unsafe (tree decl) 2911{ 2912 /* [stmt.dcl]/3: A program that jumps from a point where a local variable 2913 with automatic storage duration is not in scope to a point where it is 2914 in scope is ill-formed unless the variable has scalar type, class type 2915 with a trivial default constructor and a trivial destructor, a 2916 cv-qualified version of one of these types, or an array of one of the 2917 preceding types and is declared without an initializer (8.5). */ 2918 tree type = TREE_TYPE (decl); 2919 2920 if (!VAR_P (decl) || TREE_STATIC (decl) 2921 || type == error_mark_node) 2922 return 0; 2923 2924 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl) 2925 || variably_modified_type_p (type, NULL_TREE)) 2926 return 2; 2927 2928 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) 2929 return 1; 2930 2931 return 0; 2932} 2933 2934/* A subroutine of check_previous_goto_1 and check_goto to identify a branch 2935 to the user. */ 2936 2937static bool 2938identify_goto (tree decl, location_t loc, const location_t *locus, 2939 diagnostic_t diag_kind) 2940{ 2941 bool complained 2942 = (decl ? emit_diagnostic (diag_kind, loc, 0, "jump to label %qD", decl) 2943 : emit_diagnostic (diag_kind, loc, 0, "jump to case label")); 2944 if (complained && locus) 2945 inform (*locus, " from here"); 2946 return complained; 2947} 2948 2949/* Check that a single previously seen jump to a newly defined label 2950 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for 2951 the jump context; NAMES are the names in scope in LEVEL at the jump 2952 context; LOCUS is the source position of the jump or 0. Returns 2953 true if all is well. */ 2954 2955static bool 2956check_previous_goto_1 (tree decl, cp_binding_level* level, tree names, 2957 bool exited_omp, const location_t *locus) 2958{ 2959 cp_binding_level *b; 2960 bool complained = false; 2961 int identified = 0; 2962 bool saw_eh = false, saw_omp = false; 2963 2964 if (exited_omp) 2965 { 2966 complained = identify_goto (decl, input_location, locus, DK_ERROR); 2967 if (complained) 2968 inform (input_location, " exits OpenMP structured block"); 2969 saw_omp = true; 2970 identified = 2; 2971 } 2972 2973 for (b = current_binding_level; b ; b = b->level_chain) 2974 { 2975 tree new_decls, old_decls = (b == level ? names : NULL_TREE); 2976 2977 for (new_decls = b->names; new_decls != old_decls; 2978 new_decls = (DECL_P (new_decls) ? DECL_CHAIN (new_decls) 2979 : TREE_CHAIN (new_decls))) 2980 { 2981 int problem = decl_jump_unsafe (new_decls); 2982 if (! problem) 2983 continue; 2984 2985 if (!identified) 2986 { 2987 complained = identify_goto (decl, input_location, locus, 2988 DK_PERMERROR); 2989 identified = 1; 2990 } 2991 if (complained) 2992 { 2993 if (problem > 1) 2994 inform (input_location, 2995 " crosses initialization of %q+#D", new_decls); 2996 else 2997 inform (input_location, " enters scope of %q+#D which has " 2998 "non-trivial destructor", new_decls); 2999 } 3000 } 3001 3002 if (b == level) 3003 break; 3004 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh) 3005 { 3006 if (identified < 2) 3007 { 3008 complained = identify_goto (decl, input_location, locus, 3009 DK_ERROR); 3010 identified = 2; 3011 } 3012 if (complained) 3013 { 3014 if (b->kind == sk_try) 3015 inform (input_location, " enters try block"); 3016 else 3017 inform (input_location, " enters catch block"); 3018 } 3019 saw_eh = true; 3020 } 3021 if (b->kind == sk_omp && !saw_omp) 3022 { 3023 if (identified < 2) 3024 { 3025 complained = identify_goto (decl, input_location, locus, 3026 DK_ERROR); 3027 identified = 2; 3028 } 3029 if (complained) 3030 inform (input_location, " enters OpenMP structured block"); 3031 saw_omp = true; 3032 } 3033 } 3034 3035 return !identified; 3036} 3037 3038static void 3039check_previous_goto (tree decl, struct named_label_use_entry *use) 3040{ 3041 check_previous_goto_1 (decl, use->binding_level, 3042 use->names_in_scope, use->in_omp_scope, 3043 &use->o_goto_locus); 3044} 3045 3046static bool 3047check_switch_goto (cp_binding_level* level) 3048{ 3049 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL); 3050} 3051 3052/* Check that a new jump to a label DECL is OK. Called by 3053 finish_goto_stmt. */ 3054 3055void 3056check_goto (tree decl) 3057{ 3058 struct named_label_entry *ent, dummy; 3059 bool saw_catch = false, complained = false; 3060 int identified = 0; 3061 tree bad; 3062 unsigned ix; 3063 3064 /* We can't know where a computed goto is jumping. 3065 So we assume that it's OK. */ 3066 if (TREE_CODE (decl) != LABEL_DECL) 3067 return; 3068 3069 /* We didn't record any information about this label when we created it, 3070 and there's not much point since it's trivial to analyze as a return. */ 3071 if (decl == cdtor_label) 3072 return; 3073 3074 dummy.label_decl = decl; 3075 ent = named_labels->find (&dummy); 3076 gcc_assert (ent != NULL); 3077 3078 /* If the label hasn't been defined yet, defer checking. */ 3079 if (! DECL_INITIAL (decl)) 3080 { 3081 struct named_label_use_entry *new_use; 3082 3083 /* Don't bother creating another use if the last goto had the 3084 same data, and will therefore create the same set of errors. */ 3085 if (ent->uses 3086 && ent->uses->names_in_scope == current_binding_level->names) 3087 return; 3088 3089 new_use = ggc_alloc<named_label_use_entry> (); 3090 new_use->binding_level = current_binding_level; 3091 new_use->names_in_scope = current_binding_level->names; 3092 new_use->o_goto_locus = input_location; 3093 new_use->in_omp_scope = false; 3094 3095 new_use->next = ent->uses; 3096 ent->uses = new_use; 3097 return; 3098 } 3099 3100 if (ent->in_try_scope || ent->in_catch_scope 3101 || ent->in_omp_scope || !vec_safe_is_empty (ent->bad_decls)) 3102 { 3103 diagnostic_t diag_kind = DK_PERMERROR; 3104 if (ent->in_try_scope || ent->in_catch_scope || ent->in_omp_scope) 3105 diag_kind = DK_ERROR; 3106 complained = identify_goto (decl, DECL_SOURCE_LOCATION (decl), 3107 &input_location, diag_kind); 3108 identified = 1 + (diag_kind == DK_ERROR); 3109 } 3110 3111 FOR_EACH_VEC_SAFE_ELT (ent->bad_decls, ix, bad) 3112 { 3113 int u = decl_jump_unsafe (bad); 3114 3115 if (u > 1 && DECL_ARTIFICIAL (bad)) 3116 { 3117 /* Can't skip init of __exception_info. */ 3118 if (identified == 1) 3119 { 3120 complained = identify_goto (decl, DECL_SOURCE_LOCATION (decl), 3121 &input_location, DK_ERROR); 3122 identified = 2; 3123 } 3124 if (complained) 3125 inform (DECL_SOURCE_LOCATION (bad), " enters catch block"); 3126 saw_catch = true; 3127 } 3128 else if (complained) 3129 { 3130 if (u > 1) 3131 inform (input_location, " skips initialization of %q+#D", bad); 3132 else 3133 inform (input_location, " enters scope of %q+#D which has " 3134 "non-trivial destructor", bad); 3135 } 3136 } 3137 3138 if (complained) 3139 { 3140 if (ent->in_try_scope) 3141 inform (input_location, " enters try block"); 3142 else if (ent->in_catch_scope && !saw_catch) 3143 inform (input_location, " enters catch block"); 3144 } 3145 3146 if (ent->in_omp_scope) 3147 { 3148 if (complained) 3149 inform (input_location, " enters OpenMP structured block"); 3150 } 3151 else if (flag_openmp) 3152 { 3153 cp_binding_level *b; 3154 for (b = current_binding_level; b ; b = b->level_chain) 3155 { 3156 if (b == ent->binding_level) 3157 break; 3158 if (b->kind == sk_omp) 3159 { 3160 if (identified < 2) 3161 { 3162 complained = identify_goto (decl, 3163 DECL_SOURCE_LOCATION (decl), 3164 &input_location, DK_ERROR); 3165 identified = 2; 3166 } 3167 if (complained) 3168 inform (input_location, " exits OpenMP structured block"); 3169 break; 3170 } 3171 } 3172 } 3173} 3174 3175/* Check that a return is ok wrt OpenMP structured blocks. 3176 Called by finish_return_stmt. Returns true if all is well. */ 3177 3178bool 3179check_omp_return (void) 3180{ 3181 cp_binding_level *b; 3182 for (b = current_binding_level; b ; b = b->level_chain) 3183 if (b->kind == sk_omp) 3184 { 3185 error ("invalid exit from OpenMP structured block"); 3186 return false; 3187 } 3188 else if (b->kind == sk_function_parms) 3189 break; 3190 return true; 3191} 3192 3193/* Define a label, specifying the location in the source file. 3194 Return the LABEL_DECL node for the label. */ 3195 3196static tree 3197define_label_1 (location_t location, tree name) 3198{ 3199 struct named_label_entry *ent, dummy; 3200 cp_binding_level *p; 3201 tree decl; 3202 3203 decl = lookup_label (name); 3204 3205 dummy.label_decl = decl; 3206 ent = named_labels->find (&dummy); 3207 gcc_assert (ent != NULL); 3208 3209 /* After labels, make any new cleanups in the function go into their 3210 own new (temporary) binding contour. */ 3211 for (p = current_binding_level; 3212 p->kind != sk_function_parms; 3213 p = p->level_chain) 3214 p->more_cleanups_ok = 0; 3215 3216 if (name == get_identifier ("wchar_t")) 3217 permerror (input_location, "label named wchar_t"); 3218 3219 if (DECL_INITIAL (decl) != NULL_TREE) 3220 { 3221 error ("duplicate label %qD", decl); 3222 return error_mark_node; 3223 } 3224 else 3225 { 3226 struct named_label_use_entry *use; 3227 3228 /* Mark label as having been defined. */ 3229 DECL_INITIAL (decl) = error_mark_node; 3230 /* Say where in the source. */ 3231 DECL_SOURCE_LOCATION (decl) = location; 3232 3233 ent->binding_level = current_binding_level; 3234 ent->names_in_scope = current_binding_level->names; 3235 3236 for (use = ent->uses; use ; use = use->next) 3237 check_previous_goto (decl, use); 3238 ent->uses = NULL; 3239 } 3240 3241 return decl; 3242} 3243 3244/* Wrapper for define_label_1. */ 3245 3246tree 3247define_label (location_t location, tree name) 3248{ 3249 tree ret; 3250 bool running = timevar_cond_start (TV_NAME_LOOKUP); 3251 ret = define_label_1 (location, name); 3252 timevar_cond_stop (TV_NAME_LOOKUP, running); 3253 return ret; 3254} 3255 3256 3257struct cp_switch 3258{ 3259 cp_binding_level *level; 3260 struct cp_switch *next; 3261 /* The SWITCH_STMT being built. */ 3262 tree switch_stmt; 3263 /* A splay-tree mapping the low element of a case range to the high 3264 element, or NULL_TREE if there is no high element. Used to 3265 determine whether or not a new case label duplicates an old case 3266 label. We need a tree, rather than simply a hash table, because 3267 of the GNU case range extension. */ 3268 splay_tree cases; 3269}; 3270 3271/* A stack of the currently active switch statements. The innermost 3272 switch statement is on the top of the stack. There is no need to 3273 mark the stack for garbage collection because it is only active 3274 during the processing of the body of a function, and we never 3275 collect at that point. */ 3276 3277static struct cp_switch *switch_stack; 3278 3279/* Called right after a switch-statement condition is parsed. 3280 SWITCH_STMT is the switch statement being parsed. */ 3281 3282void 3283push_switch (tree switch_stmt) 3284{ 3285 struct cp_switch *p = XNEW (struct cp_switch); 3286 p->level = current_binding_level; 3287 p->next = switch_stack; 3288 p->switch_stmt = switch_stmt; 3289 p->cases = splay_tree_new (case_compare, NULL, NULL); 3290 switch_stack = p; 3291} 3292 3293void 3294pop_switch (void) 3295{ 3296 struct cp_switch *cs = switch_stack; 3297 location_t switch_location; 3298 3299 /* Emit warnings as needed. */ 3300 switch_location = EXPR_LOC_OR_LOC (cs->switch_stmt, input_location); 3301 if (!processing_template_decl) 3302 c_do_switch_warnings (cs->cases, switch_location, 3303 SWITCH_STMT_TYPE (cs->switch_stmt), 3304 SWITCH_STMT_COND (cs->switch_stmt)); 3305 3306 splay_tree_delete (cs->cases); 3307 switch_stack = switch_stack->next; 3308 free (cs); 3309} 3310 3311/* Convert a case constant VALUE in a switch to the type TYPE of the switch 3312 condition. Note that if TYPE and VALUE are already integral we don't 3313 really do the conversion because the language-independent 3314 warning/optimization code will work better that way. */ 3315 3316static tree 3317case_conversion (tree type, tree value) 3318{ 3319 if (value == NULL_TREE) 3320 return value; 3321 3322 if (cxx_dialect >= cxx11 3323 && (SCOPED_ENUM_P (type) 3324 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value)))) 3325 { 3326 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type)) 3327 type = type_promotes_to (type); 3328 value = (perform_implicit_conversion_flags 3329 (type, value, tf_warning_or_error, 3330 LOOKUP_IMPLICIT | LOOKUP_NO_NON_INTEGRAL)); 3331 } 3332 return cxx_constant_value (value); 3333} 3334 3335/* Note that we've seen a definition of a case label, and complain if this 3336 is a bad place for one. */ 3337 3338tree 3339finish_case_label (location_t loc, tree low_value, tree high_value) 3340{ 3341 tree cond, r; 3342 cp_binding_level *p; 3343 tree type; 3344 3345 if (processing_template_decl) 3346 { 3347 tree label; 3348 3349 /* For templates, just add the case label; we'll do semantic 3350 analysis at instantiation-time. */ 3351 label = build_decl (loc, LABEL_DECL, NULL_TREE, NULL_TREE); 3352 return add_stmt (build_case_label (low_value, high_value, label)); 3353 } 3354 3355 /* Find the condition on which this switch statement depends. */ 3356 cond = SWITCH_STMT_COND (switch_stack->switch_stmt); 3357 if (cond && TREE_CODE (cond) == TREE_LIST) 3358 cond = TREE_VALUE (cond); 3359 3360 if (!check_switch_goto (switch_stack->level)) 3361 return error_mark_node; 3362 3363 type = SWITCH_STMT_TYPE (switch_stack->switch_stmt); 3364 3365 low_value = case_conversion (type, low_value); 3366 high_value = case_conversion (type, high_value); 3367 3368 r = c_add_case_label (loc, switch_stack->cases, cond, type, 3369 low_value, high_value); 3370 3371 /* After labels, make any new cleanups in the function go into their 3372 own new (temporary) binding contour. */ 3373 for (p = current_binding_level; 3374 p->kind != sk_function_parms; 3375 p = p->level_chain) 3376 p->more_cleanups_ok = 0; 3377 3378 return r; 3379} 3380 3381struct typename_info { 3382 tree scope; 3383 tree name; 3384 tree template_id; 3385 bool enum_p; 3386 bool class_p; 3387}; 3388 3389struct typename_hasher : ggc_hasher<tree> 3390{ 3391 typedef typename_info *compare_type; 3392 3393 /* Hash a TYPENAME_TYPE. */ 3394 3395 static hashval_t 3396 hash (tree t) 3397 { 3398 hashval_t hash; 3399 3400 hash = (htab_hash_pointer (TYPE_CONTEXT (t)) 3401 ^ htab_hash_pointer (TYPE_IDENTIFIER (t))); 3402 3403 return hash; 3404 } 3405 3406 /* Compare two TYPENAME_TYPEs. */ 3407 3408 static bool 3409 equal (tree t1, const typename_info *t2) 3410 { 3411 return (TYPE_IDENTIFIER (t1) == t2->name 3412 && TYPE_CONTEXT (t1) == t2->scope 3413 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id 3414 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p 3415 && TYPENAME_IS_CLASS_P (t1) == t2->class_p); 3416 } 3417}; 3418 3419/* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is 3420 the type of `T', NAME is the IDENTIFIER_NODE for `t'. 3421 3422 Returns the new TYPENAME_TYPE. */ 3423 3424static GTY (()) hash_table<typename_hasher> *typename_htab; 3425 3426static tree 3427build_typename_type (tree context, tree name, tree fullname, 3428 enum tag_types tag_type) 3429{ 3430 tree t; 3431 tree d; 3432 typename_info ti; 3433 tree *e; 3434 hashval_t hash; 3435 3436 if (typename_htab == NULL) 3437 typename_htab = hash_table<typename_hasher>::create_ggc (61); 3438 3439 ti.scope = FROB_CONTEXT (context); 3440 ti.name = name; 3441 ti.template_id = fullname; 3442 ti.enum_p = tag_type == enum_type; 3443 ti.class_p = (tag_type == class_type 3444 || tag_type == record_type 3445 || tag_type == union_type); 3446 hash = (htab_hash_pointer (ti.scope) 3447 ^ htab_hash_pointer (ti.name)); 3448 3449 /* See if we already have this type. */ 3450 e = typename_htab->find_slot_with_hash (&ti, hash, INSERT); 3451 if (*e) 3452 t = *e; 3453 else 3454 { 3455 /* Build the TYPENAME_TYPE. */ 3456 t = cxx_make_type (TYPENAME_TYPE); 3457 TYPE_CONTEXT (t) = ti.scope; 3458 TYPENAME_TYPE_FULLNAME (t) = ti.template_id; 3459 TYPENAME_IS_ENUM_P (t) = ti.enum_p; 3460 TYPENAME_IS_CLASS_P (t) = ti.class_p; 3461 3462 /* Build the corresponding TYPE_DECL. */ 3463 d = build_decl (input_location, TYPE_DECL, name, t); 3464 TYPE_NAME (TREE_TYPE (d)) = d; 3465 TYPE_STUB_DECL (TREE_TYPE (d)) = d; 3466 DECL_CONTEXT (d) = FROB_CONTEXT (context); 3467 DECL_ARTIFICIAL (d) = 1; 3468 3469 /* Store it in the hash table. */ 3470 *e = t; 3471 3472 /* TYPENAME_TYPEs must always be compared structurally, because 3473 they may or may not resolve down to another type depending on 3474 the currently open classes. */ 3475 SET_TYPE_STRUCTURAL_EQUALITY (t); 3476 } 3477 3478 return t; 3479} 3480 3481/* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag 3482 provided to name the type. Returns an appropriate type, unless an 3483 error occurs, in which case error_mark_node is returned. If we 3484 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we 3485 return that, rather than the _TYPE it corresponds to, in other 3486 cases we look through the type decl. If TF_ERROR is set, complain 3487 about errors, otherwise be quiet. */ 3488 3489tree 3490make_typename_type (tree context, tree name, enum tag_types tag_type, 3491 tsubst_flags_t complain) 3492{ 3493 tree fullname; 3494 tree t; 3495 bool want_template; 3496 3497 if (name == error_mark_node 3498 || context == NULL_TREE 3499 || context == error_mark_node) 3500 return error_mark_node; 3501 3502 if (TYPE_P (name)) 3503 { 3504 if (!(TYPE_LANG_SPECIFIC (name) 3505 && (CLASSTYPE_IS_TEMPLATE (name) 3506 || CLASSTYPE_USE_TEMPLATE (name)))) 3507 name = TYPE_IDENTIFIER (name); 3508 else 3509 /* Create a TEMPLATE_ID_EXPR for the type. */ 3510 name = build_nt (TEMPLATE_ID_EXPR, 3511 CLASSTYPE_TI_TEMPLATE (name), 3512 CLASSTYPE_TI_ARGS (name)); 3513 } 3514 else if (TREE_CODE (name) == TYPE_DECL) 3515 name = DECL_NAME (name); 3516 3517 fullname = name; 3518 3519 if (TREE_CODE (name) == TEMPLATE_ID_EXPR) 3520 { 3521 name = TREE_OPERAND (name, 0); 3522 if (DECL_TYPE_TEMPLATE_P (name)) 3523 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name); 3524 if (TREE_CODE (name) != IDENTIFIER_NODE) 3525 { 3526 if (complain & tf_error) 3527 error ("%qD is not a type", name); 3528 return error_mark_node; 3529 } 3530 } 3531 if (TREE_CODE (name) == TEMPLATE_DECL) 3532 { 3533 if (complain & tf_error) 3534 error ("%qD used without template parameters", name); 3535 return error_mark_node; 3536 } 3537 gcc_assert (identifier_p (name)); 3538 gcc_assert (TYPE_P (context)); 3539 3540 if (!MAYBE_CLASS_TYPE_P (context)) 3541 { 3542 if (complain & tf_error) 3543 error ("%q#T is not a class", context); 3544 return error_mark_node; 3545 } 3546 3547 /* When the CONTEXT is a dependent type, NAME could refer to a 3548 dependent base class of CONTEXT. But look inside it anyway 3549 if CONTEXT is a currently open scope, in case it refers to a 3550 member of the current instantiation or a non-dependent base; 3551 lookup will stop when we hit a dependent base. */ 3552 if (!dependent_scope_p (context)) 3553 /* We should only set WANT_TYPE when we're a nested typename type. 3554 Then we can give better diagnostics if we find a non-type. */ 3555 t = lookup_field (context, name, 2, /*want_type=*/true); 3556 else 3557 t = NULL_TREE; 3558 3559 if ((!t || TREE_CODE (t) == TREE_LIST) && dependent_type_p (context)) 3560 return build_typename_type (context, name, fullname, tag_type); 3561 3562 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR; 3563 3564 if (!t) 3565 { 3566 if (complain & tf_error) 3567 error (want_template ? G_("no class template named %q#T in %q#T") 3568 : G_("no type named %q#T in %q#T"), name, context); 3569 return error_mark_node; 3570 } 3571 3572 /* Pull out the template from an injected-class-name (or multiple). */ 3573 if (want_template) 3574 t = maybe_get_template_decl_from_type_decl (t); 3575 3576 if (TREE_CODE (t) == TREE_LIST) 3577 { 3578 if (complain & tf_error) 3579 { 3580 error ("lookup of %qT in %qT is ambiguous", name, context); 3581 print_candidates (t); 3582 } 3583 return error_mark_node; 3584 } 3585 3586 if (want_template && !DECL_TYPE_TEMPLATE_P (t)) 3587 { 3588 if (complain & tf_error) 3589 error ("%<typename %T::%D%> names %q#T, which is not a class template", 3590 context, name, t); 3591 return error_mark_node; 3592 } 3593 if (!want_template && TREE_CODE (t) != TYPE_DECL) 3594 { 3595 if (complain & tf_error) 3596 error ("%<typename %T::%D%> names %q#T, which is not a type", 3597 context, name, t); 3598 return error_mark_node; 3599 } 3600 3601 if (!perform_or_defer_access_check (TYPE_BINFO (context), t, t, complain)) 3602 return error_mark_node; 3603 3604 /* If we are currently parsing a template and if T is a typedef accessed 3605 through CONTEXT then we need to remember and check access of T at 3606 template instantiation time. */ 3607 add_typedef_to_current_template_for_access_check (t, context, input_location); 3608 3609 if (want_template) 3610 return lookup_template_class (t, TREE_OPERAND (fullname, 1), 3611 NULL_TREE, context, 3612 /*entering_scope=*/0, 3613 complain | tf_user); 3614 3615 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl)) 3616 t = TREE_TYPE (t); 3617 3618 maybe_record_typedef_use (t); 3619 3620 return t; 3621} 3622 3623/* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name 3624 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs, 3625 in which case error_mark_node is returned. 3626 3627 If PARM_LIST is non-NULL, also make sure that the template parameter 3628 list of TEMPLATE_DECL matches. 3629 3630 If COMPLAIN zero, don't complain about any errors that occur. */ 3631 3632tree 3633make_unbound_class_template (tree context, tree name, tree parm_list, 3634 tsubst_flags_t complain) 3635{ 3636 tree t; 3637 tree d; 3638 3639 if (TYPE_P (name)) 3640 name = TYPE_IDENTIFIER (name); 3641 else if (DECL_P (name)) 3642 name = DECL_NAME (name); 3643 gcc_assert (identifier_p (name)); 3644 3645 if (!dependent_type_p (context) 3646 || currently_open_class (context)) 3647 { 3648 tree tmpl = NULL_TREE; 3649 3650 if (MAYBE_CLASS_TYPE_P (context)) 3651 tmpl = lookup_field (context, name, 0, false); 3652 3653 if (tmpl && TREE_CODE (tmpl) == TYPE_DECL) 3654 tmpl = maybe_get_template_decl_from_type_decl (tmpl); 3655 3656 if (!tmpl || !DECL_TYPE_TEMPLATE_P (tmpl)) 3657 { 3658 if (complain & tf_error) 3659 error ("no class template named %q#T in %q#T", name, context); 3660 return error_mark_node; 3661 } 3662 3663 if (parm_list 3664 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list)) 3665 { 3666 if (complain & tf_error) 3667 { 3668 error ("template parameters do not match template %qD", tmpl); 3669 inform (DECL_SOURCE_LOCATION (tmpl), 3670 "%qD declared here", tmpl); 3671 } 3672 return error_mark_node; 3673 } 3674 3675 if (!perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl, 3676 complain)) 3677 return error_mark_node; 3678 3679 return tmpl; 3680 } 3681 3682 /* Build the UNBOUND_CLASS_TEMPLATE. */ 3683 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE); 3684 TYPE_CONTEXT (t) = FROB_CONTEXT (context); 3685 TREE_TYPE (t) = NULL_TREE; 3686 SET_TYPE_STRUCTURAL_EQUALITY (t); 3687 3688 /* Build the corresponding TEMPLATE_DECL. */ 3689 d = build_decl (input_location, TEMPLATE_DECL, name, t); 3690 TYPE_NAME (TREE_TYPE (d)) = d; 3691 TYPE_STUB_DECL (TREE_TYPE (d)) = d; 3692 DECL_CONTEXT (d) = FROB_CONTEXT (context); 3693 DECL_ARTIFICIAL (d) = 1; 3694 DECL_TEMPLATE_PARMS (d) = parm_list; 3695 3696 return t; 3697} 3698 3699 3700 3701/* Push the declarations of builtin types into the namespace. 3702 RID_INDEX is the index of the builtin type in the array 3703 RID_POINTERS. NAME is the name used when looking up the builtin 3704 type. TYPE is the _TYPE node for the builtin type. */ 3705 3706void 3707record_builtin_type (enum rid rid_index, 3708 const char* name, 3709 tree type) 3710{ 3711 tree rname = NULL_TREE, tname = NULL_TREE; 3712 tree tdecl = NULL_TREE; 3713 3714 if ((int) rid_index < (int) RID_MAX) 3715 rname = ridpointers[(int) rid_index]; 3716 if (name) 3717 tname = get_identifier (name); 3718 3719 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be 3720 eliminated. Built-in types should not be looked up name; their 3721 names are keywords that the parser can recognize. However, there 3722 is code in c-common.c that uses identifier_global_value to look 3723 up built-in types by name. */ 3724 if (tname) 3725 { 3726 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, tname, type); 3727 DECL_ARTIFICIAL (tdecl) = 1; 3728 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl); 3729 } 3730 if (rname) 3731 { 3732 if (!tdecl) 3733 { 3734 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, rname, type); 3735 DECL_ARTIFICIAL (tdecl) = 1; 3736 } 3737 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl); 3738 } 3739 3740 if (!TYPE_NAME (type)) 3741 TYPE_NAME (type) = tdecl; 3742 3743 if (tdecl) 3744 debug_hooks->type_decl (tdecl, 0); 3745} 3746 3747/* Record one of the standard Java types. 3748 * Declare it as having the given NAME. 3749 * If SIZE > 0, it is the size of one of the integral types; 3750 * otherwise it is the negative of the size of one of the other types. */ 3751 3752static tree 3753record_builtin_java_type (const char* name, int size) 3754{ 3755 tree type, decl; 3756 if (size > 0) 3757 { 3758 type = build_nonstandard_integer_type (size, 0); 3759 type = build_distinct_type_copy (type); 3760 } 3761 else if (size > -32) 3762 { 3763 tree stype; 3764 /* "__java_char" or ""__java_boolean". */ 3765 type = build_nonstandard_integer_type (-size, 1); 3766 type = build_distinct_type_copy (type); 3767 /* Get the signed type cached and attached to the unsigned type, 3768 so it doesn't get garbage-collected at "random" times, 3769 causing potential codegen differences out of different UIDs 3770 and different alias set numbers. */ 3771 stype = build_nonstandard_integer_type (-size, 0); 3772 stype = build_distinct_type_copy (stype); 3773 TREE_CHAIN (type) = stype; 3774 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/ 3775 } 3776 else 3777 { /* "__java_float" or ""__java_double". */ 3778 type = make_node (REAL_TYPE); 3779 TYPE_PRECISION (type) = - size; 3780 layout_type (type); 3781 } 3782 record_builtin_type (RID_MAX, name, type); 3783 decl = TYPE_NAME (type); 3784 3785 /* Suppress generate debug symbol entries for these types, 3786 since for normal C++ they are just clutter. 3787 However, push_lang_context undoes this if extern "Java" is seen. */ 3788 DECL_IGNORED_P (decl) = 1; 3789 3790 TYPE_FOR_JAVA (type) = 1; 3791 return type; 3792} 3793 3794/* Push a type into the namespace so that the back ends ignore it. */ 3795 3796static void 3797record_unknown_type (tree type, const char* name) 3798{ 3799 tree decl = pushdecl (build_decl (UNKNOWN_LOCATION, 3800 TYPE_DECL, get_identifier (name), type)); 3801 /* Make sure the "unknown type" typedecl gets ignored for debug info. */ 3802 DECL_IGNORED_P (decl) = 1; 3803 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1; 3804 TYPE_SIZE (type) = TYPE_SIZE (void_type_node); 3805 TYPE_ALIGN (type) = 1; 3806 TYPE_USER_ALIGN (type) = 0; 3807 SET_TYPE_MODE (type, TYPE_MODE (void_type_node)); 3808} 3809 3810/* A string for which we should create an IDENTIFIER_NODE at 3811 startup. */ 3812 3813typedef struct predefined_identifier 3814{ 3815 /* The name of the identifier. */ 3816 const char *const name; 3817 /* The place where the IDENTIFIER_NODE should be stored. */ 3818 tree *const node; 3819 /* Nonzero if this is the name of a constructor or destructor. */ 3820 const int ctor_or_dtor_p; 3821} predefined_identifier; 3822 3823/* Create all the predefined identifiers. */ 3824 3825static void 3826initialize_predefined_identifiers (void) 3827{ 3828 const predefined_identifier *pid; 3829 3830 /* A table of identifiers to create at startup. */ 3831 static const predefined_identifier predefined_identifiers[] = { 3832 { "C++", &lang_name_cplusplus, 0 }, 3833 { "C", &lang_name_c, 0 }, 3834 { "Java", &lang_name_java, 0 }, 3835 /* Some of these names have a trailing space so that it is 3836 impossible for them to conflict with names written by users. */ 3837 { "__ct ", &ctor_identifier, 1 }, 3838 { "__base_ctor ", &base_ctor_identifier, 1 }, 3839 { "__comp_ctor ", &complete_ctor_identifier, 1 }, 3840 { "__dt ", &dtor_identifier, 1 }, 3841 { "__comp_dtor ", &complete_dtor_identifier, 1 }, 3842 { "__base_dtor ", &base_dtor_identifier, 1 }, 3843 { "__deleting_dtor ", &deleting_dtor_identifier, 1 }, 3844 { IN_CHARGE_NAME, &in_charge_identifier, 0 }, 3845 { "nelts", &nelts_identifier, 0 }, 3846 { THIS_NAME, &this_identifier, 0 }, 3847 { VTABLE_DELTA_NAME, &delta_identifier, 0 }, 3848 { VTABLE_PFN_NAME, &pfn_identifier, 0 }, 3849 { "_vptr", &vptr_identifier, 0 }, 3850 { "__vtt_parm", &vtt_parm_identifier, 0 }, 3851 { "::", &global_scope_name, 0 }, 3852 { "std", &std_identifier, 0 }, 3853 { NULL, NULL, 0 } 3854 }; 3855 3856 for (pid = predefined_identifiers; pid->name; ++pid) 3857 { 3858 *pid->node = get_identifier (pid->name); 3859 if (pid->ctor_or_dtor_p) 3860 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1; 3861 } 3862} 3863 3864/* Create the predefined scalar types of C, 3865 and some nodes representing standard constants (0, 1, (void *)0). 3866 Initialize the global binding level. 3867 Make definitions for built-in primitive functions. */ 3868 3869void 3870cxx_init_decl_processing (void) 3871{ 3872 tree void_ftype; 3873 tree void_ftype_ptr; 3874 3875 /* Create all the identifiers we need. */ 3876 initialize_predefined_identifiers (); 3877 3878 /* Create the global variables. */ 3879 push_to_top_level (); 3880 3881 current_function_decl = NULL_TREE; 3882 current_binding_level = NULL; 3883 /* Enter the global namespace. */ 3884 gcc_assert (global_namespace == NULL_TREE); 3885 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name, 3886 void_type_node); 3887 DECL_CONTEXT (global_namespace) = build_translation_unit_decl (NULL_TREE); 3888 debug_hooks->register_main_translation_unit 3889 (DECL_CONTEXT (global_namespace)); 3890 TREE_PUBLIC (global_namespace) = 1; 3891 begin_scope (sk_namespace, global_namespace); 3892 3893 if (flag_visibility_ms_compat) 3894 default_visibility = VISIBILITY_HIDDEN; 3895 3896 /* Initially, C. */ 3897 current_lang_name = lang_name_c; 3898 3899 /* Create the `std' namespace. */ 3900 push_namespace (std_identifier); 3901 std_node = current_namespace; 3902 pop_namespace (); 3903 3904 c_common_nodes_and_builtins (); 3905 3906 java_byte_type_node = record_builtin_java_type ("__java_byte", 8); 3907 java_short_type_node = record_builtin_java_type ("__java_short", 16); 3908 java_int_type_node = record_builtin_java_type ("__java_int", 32); 3909 java_long_type_node = record_builtin_java_type ("__java_long", 64); 3910 java_float_type_node = record_builtin_java_type ("__java_float", -32); 3911 java_double_type_node = record_builtin_java_type ("__java_double", -64); 3912 java_char_type_node = record_builtin_java_type ("__java_char", -16); 3913 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1); 3914 3915 integer_two_node = build_int_cst (NULL_TREE, 2); 3916 3917 record_builtin_type (RID_BOOL, "bool", boolean_type_node); 3918 truthvalue_type_node = boolean_type_node; 3919 truthvalue_false_node = boolean_false_node; 3920 truthvalue_true_node = boolean_true_node; 3921 3922 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE); 3923 noexcept_true_spec = build_tree_list (boolean_true_node, NULL_TREE); 3924 noexcept_false_spec = build_tree_list (boolean_false_node, NULL_TREE); 3925 3926#if 0 3927 record_builtin_type (RID_MAX, NULL, string_type_node); 3928#endif 3929 3930 delta_type_node = ptrdiff_type_node; 3931 vtable_index_type = ptrdiff_type_node; 3932 3933 vtt_parm_type = build_pointer_type (const_ptr_type_node); 3934 void_ftype = build_function_type_list (void_type_node, NULL_TREE); 3935 void_ftype_ptr = build_function_type_list (void_type_node, 3936 ptr_type_node, NULL_TREE); 3937 void_ftype_ptr 3938 = build_exception_variant (void_ftype_ptr, empty_except_spec); 3939 3940 /* C++ extensions */ 3941 3942 unknown_type_node = make_node (LANG_TYPE); 3943 record_unknown_type (unknown_type_node, "unknown type"); 3944 3945 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */ 3946 TREE_TYPE (unknown_type_node) = unknown_type_node; 3947 3948 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same 3949 result. */ 3950 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node; 3951 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node; 3952 3953 init_list_type_node = make_node (LANG_TYPE); 3954 record_unknown_type (init_list_type_node, "init list"); 3955 3956 { 3957 /* Make sure we get a unique function type, so we can give 3958 its pointer type a name. (This wins for gdb.) */ 3959 tree vfunc_type = make_node (FUNCTION_TYPE); 3960 TREE_TYPE (vfunc_type) = integer_type_node; 3961 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE; 3962 layout_type (vfunc_type); 3963 3964 vtable_entry_type = build_pointer_type (vfunc_type); 3965 } 3966 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type); 3967 3968 vtbl_type_node 3969 = build_cplus_array_type (vtable_entry_type, NULL_TREE); 3970 layout_type (vtbl_type_node); 3971 vtbl_type_node = cp_build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST); 3972 record_builtin_type (RID_MAX, NULL, vtbl_type_node); 3973 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type); 3974 layout_type (vtbl_ptr_type_node); 3975 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node); 3976 3977 push_namespace (get_identifier ("__cxxabiv1")); 3978 abi_node = current_namespace; 3979 pop_namespace (); 3980 3981 global_type_node = make_node (LANG_TYPE); 3982 record_unknown_type (global_type_node, "global type"); 3983 3984 /* Now, C++. */ 3985 current_lang_name = lang_name_cplusplus; 3986 3987 { 3988 tree newattrs, extvisattr; 3989 tree newtype, deltype; 3990 tree ptr_ftype_sizetype; 3991 tree new_eh_spec; 3992 3993 ptr_ftype_sizetype 3994 = build_function_type_list (ptr_type_node, size_type_node, NULL_TREE); 3995 if (cxx_dialect == cxx98) 3996 { 3997 tree bad_alloc_id; 3998 tree bad_alloc_type_node; 3999 tree bad_alloc_decl; 4000 4001 push_namespace (std_identifier); 4002 bad_alloc_id = get_identifier ("bad_alloc"); 4003 bad_alloc_type_node = make_class_type (RECORD_TYPE); 4004 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace; 4005 bad_alloc_decl 4006 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node); 4007 DECL_CONTEXT (bad_alloc_decl) = current_namespace; 4008 pop_namespace (); 4009 4010 new_eh_spec 4011 = add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1); 4012 } 4013 else 4014 new_eh_spec = noexcept_false_spec; 4015 4016 /* Ensure attribs.c is initialized. */ 4017 init_attributes (); 4018 extvisattr = build_tree_list (get_identifier ("externally_visible"), 4019 NULL_TREE); 4020 newattrs = tree_cons (get_identifier ("alloc_size"), 4021 build_tree_list (NULL_TREE, integer_one_node), 4022 extvisattr); 4023 newtype = cp_build_type_attribute_variant (ptr_ftype_sizetype, newattrs); 4024 newtype = build_exception_variant (newtype, new_eh_spec); 4025 deltype = cp_build_type_attribute_variant (void_ftype_ptr, extvisattr); 4026 deltype = build_exception_variant (deltype, empty_except_spec); 4027 tree opnew = push_cp_library_fn (NEW_EXPR, newtype, 0); 4028 DECL_IS_MALLOC (opnew) = 1; 4029 DECL_IS_OPERATOR_NEW (opnew) = 1; 4030 opnew = push_cp_library_fn (VEC_NEW_EXPR, newtype, 0); 4031 DECL_IS_MALLOC (opnew) = 1; 4032 DECL_IS_OPERATOR_NEW (opnew) = 1; 4033 push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW); 4034 push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW); 4035 if (flag_sized_deallocation) 4036 { 4037 /* Also push the sized deallocation variants: 4038 void operator delete(void*, std::size_t) throw(); 4039 void operator delete[](void*, std::size_t) throw(); */ 4040 tree void_ftype_ptr_size 4041 = build_function_type_list (void_type_node, ptr_type_node, 4042 size_type_node, NULL_TREE); 4043 deltype = cp_build_type_attribute_variant (void_ftype_ptr_size, 4044 extvisattr); 4045 deltype = build_exception_variant (deltype, empty_except_spec); 4046 push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW); 4047 push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW); 4048 } 4049 4050 nullptr_type_node = make_node (NULLPTR_TYPE); 4051 TYPE_SIZE (nullptr_type_node) = bitsize_int (GET_MODE_BITSIZE (ptr_mode)); 4052 TYPE_SIZE_UNIT (nullptr_type_node) = size_int (GET_MODE_SIZE (ptr_mode)); 4053 TYPE_UNSIGNED (nullptr_type_node) = 1; 4054 TYPE_PRECISION (nullptr_type_node) = GET_MODE_BITSIZE (ptr_mode); 4055 if (abi_version_at_least (9)) 4056 TYPE_ALIGN (nullptr_type_node) = GET_MODE_ALIGNMENT (ptr_mode); 4057 SET_TYPE_MODE (nullptr_type_node, ptr_mode); 4058 record_builtin_type (RID_MAX, "decltype(nullptr)", nullptr_type_node); 4059 nullptr_node = build_int_cst (nullptr_type_node, 0); 4060 } 4061 4062 abort_fndecl 4063 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype, 4064 ECF_NORETURN | ECF_NOTHROW); 4065 4066 /* Perform other language dependent initializations. */ 4067 init_class_processing (); 4068 init_rtti_processing (); 4069 init_template_processing (); 4070 4071 if (flag_exceptions) 4072 init_exception_processing (); 4073 4074 if (! supports_one_only ()) 4075 flag_weak = 0; 4076 4077 make_fname_decl = cp_make_fname_decl; 4078 start_fname_decls (); 4079 4080 /* Show we use EH for cleanups. */ 4081 if (flag_exceptions) 4082 using_eh_for_cleanups (); 4083} 4084 4085/* Generate an initializer for a function naming variable from 4086 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is 4087 filled in with the type of the init. */ 4088 4089tree 4090cp_fname_init (const char* name, tree *type_p) 4091{ 4092 tree domain = NULL_TREE; 4093 tree type; 4094 tree init = NULL_TREE; 4095 size_t length = 0; 4096 4097 if (name) 4098 { 4099 length = strlen (name); 4100 domain = build_index_type (size_int (length)); 4101 init = build_string (length + 1, name); 4102 } 4103 4104 type = cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST); 4105 type = build_cplus_array_type (type, domain); 4106 4107 *type_p = type; 4108 4109 if (init) 4110 TREE_TYPE (init) = type; 4111 else 4112 init = error_mark_node; 4113 4114 return init; 4115} 4116 4117/* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give 4118 the decl, LOC is the location to give the decl, NAME is the 4119 initialization string and TYPE_DEP indicates whether NAME depended 4120 on the type of the function. We make use of that to detect 4121 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily 4122 at the point of first use, so we mustn't push the decl now. */ 4123 4124static tree 4125cp_make_fname_decl (location_t loc, tree id, int type_dep) 4126{ 4127 const char *const name = (type_dep && processing_template_decl 4128 ? NULL : fname_as_string (type_dep)); 4129 tree type; 4130 tree init = cp_fname_init (name, &type); 4131 tree decl = build_decl (loc, VAR_DECL, id, type); 4132 4133 if (name) 4134 free (CONST_CAST (char *, name)); 4135 4136 /* As we're using pushdecl_with_scope, we must set the context. */ 4137 DECL_CONTEXT (decl) = current_function_decl; 4138 4139 TREE_STATIC (decl) = 1; 4140 TREE_READONLY (decl) = 1; 4141 DECL_ARTIFICIAL (decl) = 1; 4142 4143 TREE_USED (decl) = 1; 4144 4145 if (current_function_decl) 4146 { 4147 cp_binding_level *b = current_binding_level; 4148 if (b->kind == sk_function_parms) 4149 return error_mark_node; 4150 while (b->level_chain->kind != sk_function_parms) 4151 b = b->level_chain; 4152 pushdecl_with_scope (decl, b, /*is_friend=*/false); 4153 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE, 4154 LOOKUP_ONLYCONVERTING); 4155 } 4156 else 4157 { 4158 DECL_THIS_STATIC (decl) = true; 4159 pushdecl_top_level_and_finish (decl, init); 4160 } 4161 4162 return decl; 4163} 4164 4165static tree 4166builtin_function_1 (tree decl, tree context, bool is_global) 4167{ 4168 tree id = DECL_NAME (decl); 4169 const char *name = IDENTIFIER_POINTER (id); 4170 4171 retrofit_lang_decl (decl); 4172 4173 DECL_ARTIFICIAL (decl) = 1; 4174 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK); 4175 SET_DECL_LANGUAGE (decl, lang_c); 4176 /* Runtime library routines are, by definition, available in an 4177 external shared object. */ 4178 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT; 4179 DECL_VISIBILITY_SPECIFIED (decl) = 1; 4180 4181 DECL_CONTEXT (decl) = context; 4182 4183 if (is_global) 4184 pushdecl_top_level (decl); 4185 else 4186 pushdecl (decl); 4187 4188 /* A function in the user's namespace should have an explicit 4189 declaration before it is used. Mark the built-in function as 4190 anticipated but not actually declared. */ 4191 if (name[0] != '_' || name[1] != '_') 4192 DECL_ANTICIPATED (decl) = 1; 4193 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0) 4194 { 4195 size_t len = strlen (name); 4196 4197 /* Treat __*_chk fortification functions as anticipated as well, 4198 unless they are __builtin_*. */ 4199 if (len > strlen ("___chk") 4200 && memcmp (name + len - strlen ("_chk"), 4201 "_chk", strlen ("_chk") + 1) == 0) 4202 DECL_ANTICIPATED (decl) = 1; 4203 } 4204 4205 return decl; 4206} 4207 4208tree 4209cxx_builtin_function (tree decl) 4210{ 4211 tree id = DECL_NAME (decl); 4212 const char *name = IDENTIFIER_POINTER (id); 4213 /* All builtins that don't begin with an '_' should additionally 4214 go in the 'std' namespace. */ 4215 if (name[0] != '_') 4216 { 4217 tree decl2 = copy_node(decl); 4218 push_namespace (std_identifier); 4219 builtin_function_1 (decl2, std_node, false); 4220 pop_namespace (); 4221 } 4222 4223 return builtin_function_1 (decl, NULL_TREE, false); 4224} 4225 4226/* Like cxx_builtin_function, but guarantee the function is added to the global 4227 scope. This is to allow function specific options to add new machine 4228 dependent builtins when the target ISA changes via attribute((target(...))) 4229 which saves space on program startup if the program does not use non-generic 4230 ISAs. */ 4231 4232tree 4233cxx_builtin_function_ext_scope (tree decl) 4234{ 4235 4236 tree id = DECL_NAME (decl); 4237 const char *name = IDENTIFIER_POINTER (id); 4238 /* All builtins that don't begin with an '_' should additionally 4239 go in the 'std' namespace. */ 4240 if (name[0] != '_') 4241 { 4242 tree decl2 = copy_node(decl); 4243 push_namespace (std_identifier); 4244 builtin_function_1 (decl2, std_node, true); 4245 pop_namespace (); 4246 } 4247 4248 return builtin_function_1 (decl, NULL_TREE, true); 4249} 4250 4251/* Generate a FUNCTION_DECL with the typical flags for a runtime library 4252 function. Not called directly. */ 4253 4254static tree 4255build_library_fn (tree name, enum tree_code operator_code, tree type, 4256 int ecf_flags) 4257{ 4258 tree fn = build_lang_decl (FUNCTION_DECL, name, type); 4259 DECL_EXTERNAL (fn) = 1; 4260 TREE_PUBLIC (fn) = 1; 4261 DECL_ARTIFICIAL (fn) = 1; 4262 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code); 4263 SET_DECL_LANGUAGE (fn, lang_c); 4264 /* Runtime library routines are, by definition, available in an 4265 external shared object. */ 4266 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT; 4267 DECL_VISIBILITY_SPECIFIED (fn) = 1; 4268 set_call_expr_flags (fn, ecf_flags); 4269 return fn; 4270} 4271 4272/* Returns the _DECL for a library function with C++ linkage. */ 4273 4274static tree 4275build_cp_library_fn (tree name, enum tree_code operator_code, tree type, 4276 int ecf_flags) 4277{ 4278 tree fn = build_library_fn (name, operator_code, type, ecf_flags); 4279 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace); 4280 SET_DECL_LANGUAGE (fn, lang_cplusplus); 4281 return fn; 4282} 4283 4284/* Like build_library_fn, but takes a C string instead of an 4285 IDENTIFIER_NODE. */ 4286 4287tree 4288build_library_fn_ptr (const char* name, tree type, int ecf_flags) 4289{ 4290 return build_library_fn (get_identifier (name), ERROR_MARK, type, ecf_flags); 4291} 4292 4293/* Like build_cp_library_fn, but takes a C string instead of an 4294 IDENTIFIER_NODE. */ 4295 4296tree 4297build_cp_library_fn_ptr (const char* name, tree type, int ecf_flags) 4298{ 4299 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type, 4300 ecf_flags); 4301} 4302 4303/* Like build_library_fn, but also pushes the function so that we will 4304 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function 4305 may throw exceptions listed in RAISES. */ 4306 4307tree 4308push_library_fn (tree name, tree type, tree raises, int ecf_flags) 4309{ 4310 tree fn; 4311 4312 if (raises) 4313 type = build_exception_variant (type, raises); 4314 4315 fn = build_library_fn (name, ERROR_MARK, type, ecf_flags); 4316 pushdecl_top_level (fn); 4317 return fn; 4318} 4319 4320/* Like build_cp_library_fn, but also pushes the function so that it 4321 will be found by normal lookup. */ 4322 4323static tree 4324push_cp_library_fn (enum tree_code operator_code, tree type, 4325 int ecf_flags) 4326{ 4327 tree fn = build_cp_library_fn (ansi_opname (operator_code), 4328 operator_code, 4329 type, ecf_flags); 4330 pushdecl (fn); 4331 if (flag_tm) 4332 apply_tm_attr (fn, get_identifier ("transaction_safe")); 4333 return fn; 4334} 4335 4336/* Like push_library_fn, but takes a TREE_LIST of parm types rather than 4337 a FUNCTION_TYPE. */ 4338 4339tree 4340push_void_library_fn (tree name, tree parmtypes, int ecf_flags) 4341{ 4342 tree type = build_function_type (void_type_node, parmtypes); 4343 return push_library_fn (name, type, NULL_TREE, ecf_flags); 4344} 4345 4346/* Like push_library_fn, but also note that this function throws 4347 and does not return. Used for __throw_foo and the like. */ 4348 4349tree 4350push_throw_library_fn (tree name, tree type) 4351{ 4352 tree fn = push_library_fn (name, type, NULL_TREE, ECF_NORETURN); 4353 return fn; 4354} 4355 4356/* When we call finish_struct for an anonymous union, we create 4357 default copy constructors and such. But, an anonymous union 4358 shouldn't have such things; this function undoes the damage to the 4359 anonymous union type T. 4360 4361 (The reason that we create the synthesized methods is that we don't 4362 distinguish `union { int i; }' from `typedef union { int i; } U'. 4363 The first is an anonymous union; the second is just an ordinary 4364 union type.) */ 4365 4366void 4367fixup_anonymous_aggr (tree t) 4368{ 4369 tree *q; 4370 4371 /* Wipe out memory of synthesized methods. */ 4372 TYPE_HAS_USER_CONSTRUCTOR (t) = 0; 4373 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0; 4374 TYPE_HAS_COPY_CTOR (t) = 0; 4375 TYPE_HAS_CONST_COPY_CTOR (t) = 0; 4376 TYPE_HAS_COPY_ASSIGN (t) = 0; 4377 TYPE_HAS_CONST_COPY_ASSIGN (t) = 0; 4378 4379 /* Splice the implicitly generated functions out of the TYPE_METHODS 4380 list. */ 4381 q = &TYPE_METHODS (t); 4382 while (*q) 4383 { 4384 if (DECL_ARTIFICIAL (*q)) 4385 *q = TREE_CHAIN (*q); 4386 else 4387 q = &DECL_CHAIN (*q); 4388 } 4389 4390 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */ 4391 if (TYPE_METHODS (t)) 4392 { 4393 tree decl = TYPE_MAIN_DECL (t); 4394 4395 if (TREE_CODE (t) != UNION_TYPE) 4396 error_at (DECL_SOURCE_LOCATION (decl), 4397 "an anonymous struct cannot have function members"); 4398 else 4399 error_at (DECL_SOURCE_LOCATION (decl), 4400 "an anonymous union cannot have function members"); 4401 } 4402 4403 /* Anonymous aggregates cannot have fields with ctors, dtors or complex 4404 assignment operators (because they cannot have these methods themselves). 4405 For anonymous unions this is already checked because they are not allowed 4406 in any union, otherwise we have to check it. */ 4407 if (TREE_CODE (t) != UNION_TYPE) 4408 { 4409 tree field, type; 4410 4411 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field)) 4412 if (TREE_CODE (field) == FIELD_DECL) 4413 { 4414 type = TREE_TYPE (field); 4415 if (CLASS_TYPE_P (type)) 4416 { 4417 if (TYPE_NEEDS_CONSTRUCTING (type)) 4418 error ("member %q+#D with constructor not allowed " 4419 "in anonymous aggregate", field); 4420 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) 4421 error ("member %q+#D with destructor not allowed " 4422 "in anonymous aggregate", field); 4423 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type)) 4424 error ("member %q+#D with copy assignment operator " 4425 "not allowed in anonymous aggregate", field); 4426 } 4427 } 4428 } 4429} 4430 4431/* Warn for an attribute located at LOCATION that appertains to the 4432 class type CLASS_TYPE that has not been properly placed after its 4433 class-key, in it class-specifier. */ 4434 4435void 4436warn_misplaced_attr_for_class_type (source_location location, 4437 tree class_type) 4438{ 4439 gcc_assert (OVERLOAD_TYPE_P (class_type)); 4440 4441 if (warning_at (location, OPT_Wattributes, 4442 "attribute ignored in declaration " 4443 "of %q#T", class_type)) 4444 inform (location, 4445 "attribute for %q#T must follow the %qs keyword", 4446 class_type, class_key_or_enum_as_string (class_type)); 4447} 4448 4449/* Make sure that a declaration with no declarator is well-formed, i.e. 4450 just declares a tagged type or anonymous union. 4451 4452 Returns the type declared; or NULL_TREE if none. */ 4453 4454tree 4455check_tag_decl (cp_decl_specifier_seq *declspecs, 4456 bool explicit_type_instantiation_p) 4457{ 4458 int saw_friend = decl_spec_seq_has_spec_p (declspecs, ds_friend); 4459 int saw_typedef = decl_spec_seq_has_spec_p (declspecs, ds_typedef); 4460 /* If a class, struct, or enum type is declared by the DECLSPECS 4461 (i.e, if a class-specifier, enum-specifier, or non-typename 4462 elaborated-type-specifier appears in the DECLSPECS), 4463 DECLARED_TYPE is set to the corresponding type. */ 4464 tree declared_type = NULL_TREE; 4465 bool error_p = false; 4466 4467 if (declspecs->multiple_types_p) 4468 error ("multiple types in one declaration"); 4469 else if (declspecs->redefined_builtin_type) 4470 { 4471 if (!in_system_header_at (input_location)) 4472 permerror (declspecs->locations[ds_redefined_builtin_type_spec], 4473 "redeclaration of C++ built-in type %qT", 4474 declspecs->redefined_builtin_type); 4475 return NULL_TREE; 4476 } 4477 4478 if (declspecs->type 4479 && TYPE_P (declspecs->type) 4480 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE 4481 && MAYBE_CLASS_TYPE_P (declspecs->type)) 4482 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE)) 4483 declared_type = declspecs->type; 4484 else if (declspecs->type == error_mark_node) 4485 error_p = true; 4486 if (declared_type == NULL_TREE && ! saw_friend && !error_p) 4487 permerror (input_location, "declaration does not declare anything"); 4488 else if (declared_type != NULL_TREE && type_uses_auto (declared_type)) 4489 { 4490 error ("%<auto%> can only be specified for variables " 4491 "or function declarations"); 4492 return error_mark_node; 4493 } 4494 /* Check for an anonymous union. */ 4495 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type)) 4496 && TYPE_ANONYMOUS_P (declared_type)) 4497 { 4498 /* 7/3 In a simple-declaration, the optional init-declarator-list 4499 can be omitted only when declaring a class (clause 9) or 4500 enumeration (7.2), that is, when the decl-specifier-seq contains 4501 either a class-specifier, an elaborated-type-specifier with 4502 a class-key (9.1), or an enum-specifier. In these cases and 4503 whenever a class-specifier or enum-specifier is present in the 4504 decl-specifier-seq, the identifiers in these specifiers are among 4505 the names being declared by the declaration (as class-name, 4506 enum-names, or enumerators, depending on the syntax). In such 4507 cases, and except for the declaration of an unnamed bit-field (9.6), 4508 the decl-specifier-seq shall introduce one or more names into the 4509 program, or shall redeclare a name introduced by a previous 4510 declaration. [Example: 4511 enum { }; // ill-formed 4512 typedef class { }; // ill-formed 4513 --end example] */ 4514 if (saw_typedef) 4515 { 4516 error ("missing type-name in typedef-declaration"); 4517 return NULL_TREE; 4518 } 4519 /* Anonymous unions are objects, so they can have specifiers. */; 4520 SET_ANON_AGGR_TYPE_P (declared_type); 4521 4522 if (TREE_CODE (declared_type) != UNION_TYPE 4523 && !in_system_header_at (input_location)) 4524 pedwarn (input_location, OPT_Wpedantic, "ISO C++ prohibits anonymous structs"); 4525 } 4526 4527 else 4528 { 4529 if (decl_spec_seq_has_spec_p (declspecs, ds_inline) 4530 || decl_spec_seq_has_spec_p (declspecs, ds_virtual)) 4531 error ("%qs can only be specified for functions", 4532 decl_spec_seq_has_spec_p (declspecs, ds_inline) 4533 ? "inline" : "virtual"); 4534 else if (saw_friend 4535 && (!current_class_type 4536 || current_scope () != current_class_type)) 4537 error ("%<friend%> can only be specified inside a class"); 4538 else if (decl_spec_seq_has_spec_p (declspecs, ds_explicit)) 4539 error ("%<explicit%> can only be specified for constructors"); 4540 else if (declspecs->storage_class) 4541 error ("a storage class can only be specified for objects " 4542 "and functions"); 4543 else if (decl_spec_seq_has_spec_p (declspecs, ds_const) 4544 || decl_spec_seq_has_spec_p (declspecs, ds_volatile) 4545 || decl_spec_seq_has_spec_p (declspecs, ds_restrict) 4546 || decl_spec_seq_has_spec_p (declspecs, ds_thread)) 4547 error ("qualifiers can only be specified for objects " 4548 "and functions"); 4549 else if (saw_typedef) 4550 warning (0, "%<typedef%> was ignored in this declaration"); 4551 else if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr)) 4552 error ("%<constexpr%> cannot be used for type declarations"); 4553 } 4554 4555 if (declspecs->attributes && warn_attributes && declared_type) 4556 { 4557 location_t loc; 4558 if (!CLASS_TYPE_P (declared_type) 4559 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type)) 4560 /* For a non-template class, use the name location. */ 4561 loc = location_of (declared_type); 4562 else 4563 /* For a template class (an explicit instantiation), use the 4564 current location. */ 4565 loc = input_location; 4566 4567 if (explicit_type_instantiation_p) 4568 /* [dcl.attr.grammar]/4: 4569 4570 No attribute-specifier-seq shall appertain to an explicit 4571 instantiation. */ 4572 { 4573 if (warning_at (loc, OPT_Wattributes, 4574 "attribute ignored in explicit instantiation %q#T", 4575 declared_type)) 4576 inform (loc, 4577 "no attribute can be applied to " 4578 "an explicit instantiation"); 4579 } 4580 else 4581 warn_misplaced_attr_for_class_type (loc, declared_type); 4582 } 4583 4584 return declared_type; 4585} 4586 4587/* Called when a declaration is seen that contains no names to declare. 4588 If its type is a reference to a structure, union or enum inherited 4589 from a containing scope, shadow that tag name for the current scope 4590 with a forward reference. 4591 If its type defines a new named structure or union 4592 or defines an enum, it is valid but we need not do anything here. 4593 Otherwise, it is an error. 4594 4595 C++: may have to grok the declspecs to learn about static, 4596 complain for anonymous unions. 4597 4598 Returns the TYPE declared -- or NULL_TREE if none. */ 4599 4600tree 4601shadow_tag (cp_decl_specifier_seq *declspecs) 4602{ 4603 tree t = check_tag_decl (declspecs, 4604 /*explicit_type_instantiation_p=*/false); 4605 4606 if (!t) 4607 return NULL_TREE; 4608 4609 if (maybe_process_partial_specialization (t) == error_mark_node) 4610 return NULL_TREE; 4611 4612 /* This is where the variables in an anonymous union are 4613 declared. An anonymous union declaration looks like: 4614 union { ... } ; 4615 because there is no declarator after the union, the parser 4616 sends that declaration here. */ 4617 if (ANON_AGGR_TYPE_P (t)) 4618 { 4619 fixup_anonymous_aggr (t); 4620 4621 if (TYPE_FIELDS (t)) 4622 { 4623 tree decl = grokdeclarator (/*declarator=*/NULL, 4624 declspecs, NORMAL, 0, NULL); 4625 finish_anon_union (decl); 4626 } 4627 } 4628 4629 return t; 4630} 4631 4632/* Decode a "typename", such as "int **", returning a ..._TYPE node. */ 4633 4634tree 4635groktypename (cp_decl_specifier_seq *type_specifiers, 4636 const cp_declarator *declarator, 4637 bool is_template_arg) 4638{ 4639 tree attrs; 4640 tree type; 4641 enum decl_context context 4642 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME; 4643 attrs = type_specifiers->attributes; 4644 type_specifiers->attributes = NULL_TREE; 4645 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs); 4646 if (attrs && type != error_mark_node) 4647 { 4648 if (CLASS_TYPE_P (type)) 4649 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT " 4650 "outside of definition", type); 4651 else if (MAYBE_CLASS_TYPE_P (type)) 4652 /* A template type parameter or other dependent type. */ 4653 warning (OPT_Wattributes, "ignoring attributes applied to dependent " 4654 "type %qT without an associated declaration", type); 4655 else 4656 cplus_decl_attributes (&type, attrs, 0); 4657 } 4658 return type; 4659} 4660 4661/* Process a DECLARATOR for a function-scope variable declaration, 4662 namespace-scope variable declaration, or function declaration. 4663 (Function definitions go through start_function; class member 4664 declarations appearing in the body of the class go through 4665 grokfield.) The DECL corresponding to the DECLARATOR is returned. 4666 If an error occurs, the error_mark_node is returned instead. 4667 4668 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is 4669 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED 4670 for an explicitly defaulted function, or SD_DELETED for an explicitly 4671 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable 4672 implicitly initialized via a default constructor. ATTRIBUTES and 4673 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration. 4674 4675 The scope represented by the context of the returned DECL is pushed 4676 (if it is not the global namespace) and is assigned to 4677 *PUSHED_SCOPE_P. The caller is then responsible for calling 4678 pop_scope on *PUSHED_SCOPE_P if it is set. */ 4679 4680tree 4681start_decl (const cp_declarator *declarator, 4682 cp_decl_specifier_seq *declspecs, 4683 int initialized, 4684 tree attributes, 4685 tree prefix_attributes, 4686 tree *pushed_scope_p) 4687{ 4688 tree decl; 4689 tree context; 4690 bool was_public; 4691 int flags; 4692 bool alias; 4693 4694 *pushed_scope_p = NULL_TREE; 4695 4696 /* An object declared as __attribute__((deprecated)) suppresses 4697 warnings of uses of other deprecated items. */ 4698 if (lookup_attribute ("deprecated", attributes)) 4699 deprecated_state = DEPRECATED_SUPPRESS; 4700 4701 attributes = chainon (attributes, prefix_attributes); 4702 4703 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized, 4704 &attributes); 4705 4706 deprecated_state = DEPRECATED_NORMAL; 4707 4708 if (decl == NULL_TREE || VOID_TYPE_P (decl) 4709 || decl == error_mark_node) 4710 return error_mark_node; 4711 4712 context = CP_DECL_CONTEXT (decl); 4713 if (context != global_namespace) 4714 *pushed_scope_p = push_scope (context); 4715 4716 /* Is it valid for this decl to have an initializer at all? 4717 If not, set INITIALIZED to zero, which will indirectly 4718 tell `cp_finish_decl' to ignore the initializer once it is parsed. */ 4719 if (initialized 4720 && TREE_CODE (decl) == TYPE_DECL) 4721 { 4722 error ("typedef %qD is initialized (use decltype instead)", decl); 4723 return error_mark_node; 4724 } 4725 4726 if (initialized) 4727 { 4728 if (! toplevel_bindings_p () 4729 && DECL_EXTERNAL (decl)) 4730 warning (0, "declaration of %q#D has %<extern%> and is initialized", 4731 decl); 4732 DECL_EXTERNAL (decl) = 0; 4733 if (toplevel_bindings_p ()) 4734 TREE_STATIC (decl) = 1; 4735 } 4736 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)) != 0; 4737 4738 if (alias && TREE_CODE (decl) == FUNCTION_DECL) 4739 record_key_method_defined (decl); 4740 4741 /* If this is a typedef that names the class for linkage purposes 4742 (7.1.3p8), apply any attributes directly to the type. */ 4743 if (TREE_CODE (decl) == TYPE_DECL 4744 && OVERLOAD_TYPE_P (TREE_TYPE (decl)) 4745 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)))) 4746 flags = ATTR_FLAG_TYPE_IN_PLACE; 4747 else 4748 flags = 0; 4749 4750 /* Set attributes here so if duplicate decl, will have proper attributes. */ 4751 cplus_decl_attributes (&decl, attributes, flags); 4752 4753 /* Dllimported symbols cannot be defined. Static data members (which 4754 can be initialized in-class and dllimported) go through grokfield, 4755 not here, so we don't need to exclude those decls when checking for 4756 a definition. */ 4757 if (initialized && DECL_DLLIMPORT_P (decl)) 4758 { 4759 error ("definition of %q#D is marked %<dllimport%>", decl); 4760 DECL_DLLIMPORT_P (decl) = 0; 4761 } 4762 4763 /* If #pragma weak was used, mark the decl weak now. */ 4764 if (!processing_template_decl) 4765 maybe_apply_pragma_weak (decl); 4766 4767 if (TREE_CODE (decl) == FUNCTION_DECL 4768 && DECL_DECLARED_INLINE_P (decl) 4769 && DECL_UNINLINABLE (decl) 4770 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl))) 4771 warning (0, "inline function %q+D given attribute noinline", decl); 4772 4773 if (TYPE_P (context) && COMPLETE_TYPE_P (complete_type (context))) 4774 { 4775 bool this_tmpl = (processing_template_decl 4776 > template_class_depth (context)); 4777 if (VAR_P (decl)) 4778 { 4779 tree field = lookup_field (context, DECL_NAME (decl), 0, false); 4780 if (field == NULL_TREE 4781 || !(VAR_P (field) || variable_template_p (field))) 4782 error ("%q+#D is not a static data member of %q#T", decl, context); 4783 else if (variable_template_p (field) && !this_tmpl) 4784 { 4785 if (DECL_LANG_SPECIFIC (decl) 4786 && DECL_TEMPLATE_SPECIALIZATION (decl)) 4787 /* OK, specialization was already checked. */; 4788 else 4789 { 4790 error_at (DECL_SOURCE_LOCATION (decl), 4791 "non-member-template declaration of %qD", decl); 4792 inform (DECL_SOURCE_LOCATION (field), "does not match " 4793 "member template declaration here"); 4794 return error_mark_node; 4795 } 4796 } 4797 else 4798 { 4799 if (variable_template_p (field)) 4800 field = DECL_TEMPLATE_RESULT (field); 4801 4802 if (DECL_CONTEXT (field) != context) 4803 { 4804 if (!same_type_p (DECL_CONTEXT (field), context)) 4805 permerror (input_location, "ISO C++ does not permit %<%T::%D%> " 4806 "to be defined as %<%T::%D%>", 4807 DECL_CONTEXT (field), DECL_NAME (decl), 4808 context, DECL_NAME (decl)); 4809 DECL_CONTEXT (decl) = DECL_CONTEXT (field); 4810 } 4811 /* Static data member are tricky; an in-class initialization 4812 still doesn't provide a definition, so the in-class 4813 declaration will have DECL_EXTERNAL set, but will have an 4814 initialization. Thus, duplicate_decls won't warn 4815 about this situation, and so we check here. */ 4816 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field)) 4817 error ("duplicate initialization of %qD", decl); 4818 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false)) 4819 decl = field; 4820 if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr) 4821 && !DECL_DECLARED_CONSTEXPR_P (field)) 4822 error ("%qD declared %<constexpr%> outside its class", field); 4823 } 4824 } 4825 else 4826 { 4827 tree field = check_classfn (context, decl, 4828 this_tmpl 4829 ? current_template_parms 4830 : NULL_TREE); 4831 if (field && field != error_mark_node 4832 && duplicate_decls (decl, field, 4833 /*newdecl_is_friend=*/false)) 4834 decl = field; 4835 } 4836 4837 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */ 4838 DECL_IN_AGGR_P (decl) = 0; 4839 /* Do not mark DECL as an explicit specialization if it was not 4840 already marked as an instantiation; a declaration should 4841 never be marked as a specialization unless we know what 4842 template is being specialized. */ 4843 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl)) 4844 { 4845 SET_DECL_TEMPLATE_SPECIALIZATION (decl); 4846 if (TREE_CODE (decl) == FUNCTION_DECL) 4847 DECL_COMDAT (decl) = (TREE_PUBLIC (decl) 4848 && DECL_DECLARED_INLINE_P (decl)); 4849 else 4850 DECL_COMDAT (decl) = false; 4851 4852 /* [temp.expl.spec] An explicit specialization of a static data 4853 member of a template is a definition if the declaration 4854 includes an initializer; otherwise, it is a declaration. 4855 4856 We check for processing_specialization so this only applies 4857 to the new specialization syntax. */ 4858 if (!initialized && processing_specialization) 4859 DECL_EXTERNAL (decl) = 1; 4860 } 4861 4862 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl) 4863 /* Aliases are definitions. */ 4864 && !alias) 4865 permerror (input_location, "declaration of %q#D outside of class is not definition", 4866 decl); 4867 } 4868 4869 was_public = TREE_PUBLIC (decl); 4870 4871 /* Enter this declaration into the symbol table. Don't push the plain 4872 VAR_DECL for a variable template. */ 4873 if (!template_parm_scope_p () 4874 || TREE_CODE (decl) != VAR_DECL) 4875 decl = maybe_push_decl (decl); 4876 4877 if (processing_template_decl) 4878 decl = push_template_decl (decl); 4879 if (decl == error_mark_node) 4880 return error_mark_node; 4881 4882 if (VAR_P (decl) 4883 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public 4884 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl)) 4885 { 4886 /* This is a const variable with implicit 'static'. Set 4887 DECL_THIS_STATIC so we can tell it from variables that are 4888 !TREE_PUBLIC because of the anonymous namespace. */ 4889 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl)) || errorcount); 4890 DECL_THIS_STATIC (decl) = 1; 4891 } 4892 4893 if (current_function_decl && VAR_P (decl) 4894 && DECL_DECLARED_CONSTEXPR_P (current_function_decl)) 4895 { 4896 bool ok = false; 4897 if (DECL_THREAD_LOCAL_P (decl)) 4898 error ("%qD declared %<thread_local%> in %<constexpr%> function", 4899 decl); 4900 else if (TREE_STATIC (decl)) 4901 error ("%qD declared %<static%> in %<constexpr%> function", decl); 4902 else 4903 ok = true; 4904 if (!ok) 4905 cp_function_chain->invalid_constexpr = true; 4906 } 4907 4908 if (!processing_template_decl && VAR_P (decl)) 4909 start_decl_1 (decl, initialized); 4910 4911 return decl; 4912} 4913 4914/* Process the declaration of a variable DECL. INITIALIZED is true 4915 iff DECL is explicitly initialized. (INITIALIZED is false if the 4916 variable is initialized via an implicitly-called constructor.) 4917 This function must be called for ordinary variables (including, for 4918 example, implicit instantiations of templates), but must not be 4919 called for template declarations. */ 4920 4921void 4922start_decl_1 (tree decl, bool initialized) 4923{ 4924 tree type; 4925 bool complete_p; 4926 bool aggregate_definition_p; 4927 4928 gcc_assert (!processing_template_decl); 4929 4930 if (error_operand_p (decl)) 4931 return; 4932 4933 gcc_assert (VAR_P (decl)); 4934 4935 type = TREE_TYPE (decl); 4936 complete_p = COMPLETE_TYPE_P (type); 4937 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl); 4938 4939 /* If an explicit initializer is present, or if this is a definition 4940 of an aggregate, then we need a complete type at this point. 4941 (Scalars are always complete types, so there is nothing to 4942 check.) This code just sets COMPLETE_P; errors (if necessary) 4943 are issued below. */ 4944 if ((initialized || aggregate_definition_p) 4945 && !complete_p 4946 && COMPLETE_TYPE_P (complete_type (type))) 4947 { 4948 complete_p = true; 4949 /* We will not yet have set TREE_READONLY on DECL if the type 4950 was "const", but incomplete, before this point. But, now, we 4951 have a complete type, so we can try again. */ 4952 cp_apply_type_quals_to_decl (cp_type_quals (type), decl); 4953 } 4954 4955 if (initialized) 4956 /* Is it valid for this decl to have an initializer at all? */ 4957 { 4958 /* Don't allow initializations for incomplete types except for 4959 arrays which might be completed by the initialization. */ 4960 if (complete_p) 4961 ; /* A complete type is ok. */ 4962 else if (type_uses_auto (type)) 4963 ; /* An auto type is ok. */ 4964 else if (TREE_CODE (type) != ARRAY_TYPE) 4965 { 4966 error ("variable %q#D has initializer but incomplete type", decl); 4967 type = TREE_TYPE (decl) = error_mark_node; 4968 } 4969 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type)))) 4970 { 4971 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)) 4972 error ("elements of array %q#D have incomplete type", decl); 4973 /* else we already gave an error in start_decl. */ 4974 } 4975 } 4976 else if (aggregate_definition_p && !complete_p) 4977 { 4978 if (type_uses_auto (type)) 4979 error ("declaration of %q#D has no initializer", decl); 4980 else 4981 error ("aggregate %q#D has incomplete type and cannot be defined", 4982 decl); 4983 /* Change the type so that assemble_variable will give 4984 DECL an rtl we can live with: (mem (const_int 0)). */ 4985 type = TREE_TYPE (decl) = error_mark_node; 4986 } 4987 4988 /* Create a new scope to hold this declaration if necessary. 4989 Whether or not a new scope is necessary cannot be determined 4990 until after the type has been completed; if the type is a 4991 specialization of a class template it is not until after 4992 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR 4993 will be set correctly. */ 4994 maybe_push_cleanup_level (type); 4995} 4996 4997/* Handle initialization of references. DECL, TYPE, and INIT have the 4998 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry, 4999 but will be set to a new CLEANUP_STMT if a temporary is created 5000 that must be destroyed subsequently. 5001 5002 Returns an initializer expression to use to initialize DECL, or 5003 NULL if the initialization can be performed statically. 5004 5005 Quotes on semantics can be found in ARM 8.4.3. */ 5006 5007static tree 5008grok_reference_init (tree decl, tree type, tree init, int flags) 5009{ 5010 if (init == NULL_TREE) 5011 { 5012 if ((DECL_LANG_SPECIFIC (decl) == 0 5013 || DECL_IN_AGGR_P (decl) == 0) 5014 && ! DECL_THIS_EXTERN (decl)) 5015 error ("%qD declared as reference but not initialized", decl); 5016 return NULL_TREE; 5017 } 5018 5019 if (TREE_CODE (init) == TREE_LIST) 5020 init = build_x_compound_expr_from_list (init, ELK_INIT, 5021 tf_warning_or_error); 5022 5023 tree ttype = TREE_TYPE (type); 5024 if (TREE_CODE (ttype) != ARRAY_TYPE 5025 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE) 5026 /* Note: default conversion is only called in very special cases. */ 5027 init = decay_conversion (init, tf_warning_or_error); 5028 5029 /* check_initializer handles this for non-reference variables, but for 5030 references we need to do it here or the initializer will get the 5031 incomplete array type and confuse later calls to 5032 cp_complete_array_type. */ 5033 if (TREE_CODE (ttype) == ARRAY_TYPE 5034 && TYPE_DOMAIN (ttype) == NULL_TREE 5035 && (BRACE_ENCLOSED_INITIALIZER_P (init) 5036 || TREE_CODE (init) == STRING_CST)) 5037 { 5038 cp_complete_array_type (&ttype, init, false); 5039 if (ttype != TREE_TYPE (type)) 5040 type = cp_build_reference_type (ttype, TYPE_REF_IS_RVALUE (type)); 5041 } 5042 5043 /* Convert INIT to the reference type TYPE. This may involve the 5044 creation of a temporary, whose lifetime must be the same as that 5045 of the reference. If so, a DECL_EXPR for the temporary will be 5046 added just after the DECL_EXPR for DECL. That's why we don't set 5047 DECL_INITIAL for local references (instead assigning to them 5048 explicitly); we need to allow the temporary to be initialized 5049 first. */ 5050 return initialize_reference (type, init, flags, 5051 tf_warning_or_error); 5052} 5053 5054/* Designated initializers in arrays are not supported in GNU C++. 5055 The parser cannot detect this error since it does not know whether 5056 a given brace-enclosed initializer is for a class type or for an 5057 array. This function checks that CE does not use a designated 5058 initializer. If it does, an error is issued. Returns true if CE 5059 is valid, i.e., does not have a designated initializer. */ 5060 5061static bool 5062check_array_designated_initializer (constructor_elt *ce, 5063 unsigned HOST_WIDE_INT index) 5064{ 5065 /* Designated initializers for array elements are not supported. */ 5066 if (ce->index) 5067 { 5068 /* The parser only allows identifiers as designated 5069 initializers. */ 5070 if (ce->index == error_mark_node) 5071 { 5072 error ("name used in a GNU-style designated " 5073 "initializer for an array"); 5074 return false; 5075 } 5076 else if (identifier_p (ce->index)) 5077 { 5078 error ("name %qD used in a GNU-style designated " 5079 "initializer for an array", ce->index); 5080 return false; 5081 } 5082 5083 tree ce_index = build_expr_type_conversion (WANT_INT | WANT_ENUM, 5084 ce->index, true); 5085 if (ce_index 5086 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index)) 5087 && (TREE_CODE (ce_index = maybe_constant_value (ce_index)) 5088 == INTEGER_CST)) 5089 { 5090 /* A C99 designator is OK if it matches the current index. */ 5091 if (wi::eq_p (ce_index, index)) 5092 return true; 5093 else 5094 sorry ("non-trivial designated initializers not supported"); 5095 } 5096 else 5097 error ("C99 designator %qE is not an integral constant-expression", 5098 ce->index); 5099 5100 return false; 5101 } 5102 5103 return true; 5104} 5105 5106/* When parsing `int a[] = {1, 2};' we don't know the size of the 5107 array until we finish parsing the initializer. If that's the 5108 situation we're in, update DECL accordingly. */ 5109 5110static void 5111maybe_deduce_size_from_array_init (tree decl, tree init) 5112{ 5113 tree type = TREE_TYPE (decl); 5114 5115 if (TREE_CODE (type) == ARRAY_TYPE 5116 && TYPE_DOMAIN (type) == NULL_TREE 5117 && TREE_CODE (decl) != TYPE_DECL) 5118 { 5119 /* do_default is really a C-ism to deal with tentative definitions. 5120 But let's leave it here to ease the eventual merge. */ 5121 int do_default = !DECL_EXTERNAL (decl); 5122 tree initializer = init ? init : DECL_INITIAL (decl); 5123 int failure = 0; 5124 5125 /* Check that there are no designated initializers in INIT, as 5126 those are not supported in GNU C++, and as the middle-end 5127 will crash if presented with a non-numeric designated 5128 initializer. */ 5129 if (initializer && BRACE_ENCLOSED_INITIALIZER_P (initializer)) 5130 { 5131 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initializer); 5132 constructor_elt *ce; 5133 HOST_WIDE_INT i; 5134 FOR_EACH_VEC_SAFE_ELT (v, i, ce) 5135 if (!check_array_designated_initializer (ce, i)) 5136 failure = 1; 5137 } 5138 5139 if (!failure) 5140 { 5141 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer, 5142 do_default); 5143 if (failure == 1) 5144 { 5145 error ("initializer fails to determine size of %qD", decl); 5146 } 5147 else if (failure == 2) 5148 { 5149 if (do_default) 5150 { 5151 error ("array size missing in %qD", decl); 5152 } 5153 /* If a `static' var's size isn't known, make it extern as 5154 well as static, so it does not get allocated. If it's not 5155 `static', then don't mark it extern; finish_incomplete_decl 5156 will give it a default size and it will get allocated. */ 5157 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl)) 5158 DECL_EXTERNAL (decl) = 1; 5159 } 5160 else if (failure == 3) 5161 { 5162 error ("zero-size array %qD", decl); 5163 } 5164 } 5165 5166 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl); 5167 5168 relayout_decl (decl); 5169 } 5170} 5171 5172/* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue 5173 any appropriate error messages regarding the layout. */ 5174 5175static void 5176layout_var_decl (tree decl) 5177{ 5178 tree type; 5179 5180 type = TREE_TYPE (decl); 5181 if (type == error_mark_node) 5182 return; 5183 5184 /* If we haven't already laid out this declaration, do so now. 5185 Note that we must not call complete type for an external object 5186 because it's type might involve templates that we are not 5187 supposed to instantiate yet. (And it's perfectly valid to say 5188 `extern X x' for some incomplete type `X'.) */ 5189 if (!DECL_EXTERNAL (decl)) 5190 complete_type (type); 5191 if (!DECL_SIZE (decl) 5192 && TREE_TYPE (decl) != error_mark_node 5193 && (COMPLETE_TYPE_P (type) 5194 || (TREE_CODE (type) == ARRAY_TYPE 5195 && !TYPE_DOMAIN (type) 5196 && COMPLETE_TYPE_P (TREE_TYPE (type))))) 5197 layout_decl (decl, 0); 5198 5199 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE) 5200 { 5201 /* An automatic variable with an incomplete type: that is an error. 5202 Don't talk about array types here, since we took care of that 5203 message in grokdeclarator. */ 5204 error ("storage size of %qD isn%'t known", decl); 5205 TREE_TYPE (decl) = error_mark_node; 5206 } 5207#if 0 5208 /* Keep this code around in case we later want to control debug info 5209 based on whether a type is "used". (jason 1999-11-11) */ 5210 5211 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype)) 5212 /* Let debugger know it should output info for this type. */ 5213 note_debug_info_needed (ttype); 5214 5215 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl)) 5216 note_debug_info_needed (DECL_CONTEXT (decl)); 5217#endif 5218 5219 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl)) 5220 && DECL_SIZE (decl) != NULL_TREE 5221 && ! TREE_CONSTANT (DECL_SIZE (decl))) 5222 { 5223 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST) 5224 constant_expression_warning (DECL_SIZE (decl)); 5225 else 5226 { 5227 error ("storage size of %qD isn%'t constant", decl); 5228 TREE_TYPE (decl) = error_mark_node; 5229 } 5230 } 5231} 5232 5233/* If a local static variable is declared in an inline function, or if 5234 we have a weak definition, we must endeavor to create only one 5235 instance of the variable at link-time. */ 5236 5237void 5238maybe_commonize_var (tree decl) 5239{ 5240 /* Static data in a function with comdat linkage also has comdat 5241 linkage. */ 5242 if (TREE_STATIC (decl) 5243 /* Don't mess with __FUNCTION__. */ 5244 && ! DECL_ARTIFICIAL (decl) 5245 && DECL_FUNCTION_SCOPE_P (decl) 5246 && vague_linkage_p (DECL_CONTEXT (decl))) 5247 { 5248 if (flag_weak) 5249 { 5250 /* With weak symbols, we simply make the variable COMDAT; 5251 that will cause copies in multiple translations units to 5252 be merged. */ 5253 comdat_linkage (decl); 5254 } 5255 else 5256 { 5257 if (DECL_INITIAL (decl) == NULL_TREE 5258 || DECL_INITIAL (decl) == error_mark_node) 5259 { 5260 /* Without weak symbols, we can use COMMON to merge 5261 uninitialized variables. */ 5262 TREE_PUBLIC (decl) = 1; 5263 DECL_COMMON (decl) = 1; 5264 } 5265 else 5266 { 5267 /* While for initialized variables, we must use internal 5268 linkage -- which means that multiple copies will not 5269 be merged. */ 5270 TREE_PUBLIC (decl) = 0; 5271 DECL_COMMON (decl) = 0; 5272 if (warning_at (DECL_SOURCE_LOCATION (decl), 0, 5273 "sorry: semantics of inline function static " 5274 "data %q#D are wrong (you%'ll wind up " 5275 "with multiple copies)", decl)) 5276 inform (DECL_SOURCE_LOCATION (decl), 5277 "you can work around this by removing the initializer"); 5278 } 5279 } 5280 } 5281} 5282 5283/* Issue an error message if DECL is an uninitialized const variable. */ 5284 5285static void 5286check_for_uninitialized_const_var (tree decl) 5287{ 5288 tree type = strip_array_types (TREE_TYPE (decl)); 5289 5290 /* ``Unless explicitly declared extern, a const object does not have 5291 external linkage and must be initialized. ($8.4; $12.1)'' ARM 5292 7.1.6 */ 5293 if (VAR_P (decl) 5294 && TREE_CODE (type) != REFERENCE_TYPE 5295 && (CP_TYPE_CONST_P (type) || var_in_constexpr_fn (decl)) 5296 && !DECL_INITIAL (decl)) 5297 { 5298 tree field = default_init_uninitialized_part (type); 5299 if (!field) 5300 return; 5301 5302 if (CP_TYPE_CONST_P (type)) 5303 permerror (DECL_SOURCE_LOCATION (decl), 5304 "uninitialized const %qD", decl); 5305 else 5306 { 5307 error_at (DECL_SOURCE_LOCATION (decl), 5308 "uninitialized variable %qD in %<constexpr%> function", 5309 decl); 5310 cp_function_chain->invalid_constexpr = true; 5311 } 5312 5313 if (CLASS_TYPE_P (type)) 5314 { 5315 tree defaulted_ctor; 5316 5317 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)), 5318 "%q#T has no user-provided default constructor", type); 5319 defaulted_ctor = in_class_defaulted_default_constructor (type); 5320 if (defaulted_ctor) 5321 inform (DECL_SOURCE_LOCATION (defaulted_ctor), 5322 "constructor is not user-provided because it is " 5323 "explicitly defaulted in the class body"); 5324 inform (0, "and the implicitly-defined constructor does not " 5325 "initialize %q+#D", field); 5326 } 5327 } 5328} 5329 5330/* Structure holding the current initializer being processed by reshape_init. 5331 CUR is a pointer to the current element being processed, END is a pointer 5332 after the last element present in the initializer. */ 5333typedef struct reshape_iterator_t 5334{ 5335 constructor_elt *cur; 5336 constructor_elt *end; 5337} reshape_iter; 5338 5339static tree reshape_init_r (tree, reshape_iter *, bool, tsubst_flags_t); 5340 5341/* FIELD is a FIELD_DECL or NULL. In the former case, the value 5342 returned is the next FIELD_DECL (possibly FIELD itself) that can be 5343 initialized. If there are no more such fields, the return value 5344 will be NULL. */ 5345 5346tree 5347next_initializable_field (tree field) 5348{ 5349 while (field 5350 && (TREE_CODE (field) != FIELD_DECL 5351 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field)) 5352 || DECL_ARTIFICIAL (field))) 5353 field = DECL_CHAIN (field); 5354 5355 return field; 5356} 5357 5358/* Subroutine of reshape_init_array and reshape_init_vector, which does 5359 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an 5360 INTEGER_CST representing the size of the array minus one (the maximum index), 5361 or NULL_TREE if the array was declared without specifying the size. D is 5362 the iterator within the constructor. */ 5363 5364static tree 5365reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d, 5366 tsubst_flags_t complain) 5367{ 5368 tree new_init; 5369 bool sized_array_p = (max_index && TREE_CONSTANT (max_index)); 5370 unsigned HOST_WIDE_INT max_index_cst = 0; 5371 unsigned HOST_WIDE_INT index; 5372 5373 /* The initializer for an array is always a CONSTRUCTOR. */ 5374 new_init = build_constructor (init_list_type_node, NULL); 5375 5376 if (sized_array_p) 5377 { 5378 /* Minus 1 is used for zero sized arrays. */ 5379 if (integer_all_onesp (max_index)) 5380 return new_init; 5381 5382 if (tree_fits_uhwi_p (max_index)) 5383 max_index_cst = tree_to_uhwi (max_index); 5384 /* sizetype is sign extended, not zero extended. */ 5385 else 5386 max_index_cst = tree_to_uhwi (fold_convert (size_type_node, max_index)); 5387 } 5388 5389 /* Loop until there are no more initializers. */ 5390 for (index = 0; 5391 d->cur != d->end && (!sized_array_p || index <= max_index_cst); 5392 ++index) 5393 { 5394 tree elt_init; 5395 constructor_elt *old_cur = d->cur; 5396 5397 check_array_designated_initializer (d->cur, index); 5398 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false, 5399 complain); 5400 if (elt_init == error_mark_node) 5401 return error_mark_node; 5402 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), 5403 size_int (index), elt_init); 5404 if (!TREE_CONSTANT (elt_init)) 5405 TREE_CONSTANT (new_init) = false; 5406 5407 /* This can happen with an invalid initializer (c++/54501). */ 5408 if (d->cur == old_cur && !sized_array_p) 5409 break; 5410 } 5411 5412 return new_init; 5413} 5414 5415/* Subroutine of reshape_init_r, processes the initializers for arrays. 5416 Parameters are the same of reshape_init_r. */ 5417 5418static tree 5419reshape_init_array (tree type, reshape_iter *d, tsubst_flags_t complain) 5420{ 5421 tree max_index = NULL_TREE; 5422 5423 gcc_assert (TREE_CODE (type) == ARRAY_TYPE); 5424 5425 if (TYPE_DOMAIN (type)) 5426 max_index = array_type_nelts (type); 5427 5428 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain); 5429} 5430 5431/* Subroutine of reshape_init_r, processes the initializers for vectors. 5432 Parameters are the same of reshape_init_r. */ 5433 5434static tree 5435reshape_init_vector (tree type, reshape_iter *d, tsubst_flags_t complain) 5436{ 5437 tree max_index = NULL_TREE; 5438 5439 gcc_assert (TREE_CODE (type) == VECTOR_TYPE); 5440 5441 if (COMPOUND_LITERAL_P (d->cur->value)) 5442 { 5443 tree value = d->cur->value; 5444 if (!same_type_p (TREE_TYPE (value), type)) 5445 { 5446 if (complain & tf_error) 5447 error ("invalid type %qT as initializer for a vector of type %qT", 5448 TREE_TYPE (d->cur->value), type); 5449 value = error_mark_node; 5450 } 5451 ++d->cur; 5452 return value; 5453 } 5454 5455 /* For a vector, we initialize it as an array of the appropriate size. */ 5456 if (TREE_CODE (type) == VECTOR_TYPE) 5457 max_index = size_int (TYPE_VECTOR_SUBPARTS (type) - 1); 5458 5459 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain); 5460} 5461 5462/* Subroutine of reshape_init_r, processes the initializers for classes 5463 or union. Parameters are the same of reshape_init_r. */ 5464 5465static tree 5466reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p, 5467 tsubst_flags_t complain) 5468{ 5469 tree field; 5470 tree new_init; 5471 5472 gcc_assert (CLASS_TYPE_P (type)); 5473 5474 /* The initializer for a class is always a CONSTRUCTOR. */ 5475 new_init = build_constructor (init_list_type_node, NULL); 5476 field = next_initializable_field (TYPE_FIELDS (type)); 5477 5478 if (!field) 5479 { 5480 /* [dcl.init.aggr] 5481 5482 An initializer for an aggregate member that is an 5483 empty class shall have the form of an empty 5484 initializer-list {}. */ 5485 if (!first_initializer_p) 5486 { 5487 if (complain & tf_error) 5488 error ("initializer for %qT must be brace-enclosed", type); 5489 return error_mark_node; 5490 } 5491 return new_init; 5492 } 5493 5494 /* Loop through the initializable fields, gathering initializers. */ 5495 while (d->cur != d->end) 5496 { 5497 tree field_init; 5498 constructor_elt *old_cur = d->cur; 5499 5500 /* Handle designated initializers, as an extension. */ 5501 if (d->cur->index) 5502 { 5503 if (d->cur->index == error_mark_node) 5504 return error_mark_node; 5505 5506 if (TREE_CODE (d->cur->index) == FIELD_DECL) 5507 /* We already reshaped this. */ 5508 gcc_assert (d->cur->index == field); 5509 else if (TREE_CODE (d->cur->index) == IDENTIFIER_NODE) 5510 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false); 5511 else 5512 { 5513 if (complain & tf_error) 5514 error ("%<[%E] =%> used in a GNU-style designated initializer" 5515 " for class %qT", d->cur->index, type); 5516 return error_mark_node; 5517 } 5518 5519 if (!field || TREE_CODE (field) != FIELD_DECL) 5520 { 5521 if (complain & tf_error) 5522 error ("%qT has no non-static data member named %qD", type, 5523 d->cur->index); 5524 return error_mark_node; 5525 } 5526 } 5527 5528 /* If we processed all the member of the class, we are done. */ 5529 if (!field) 5530 break; 5531 5532 field_init = reshape_init_r (TREE_TYPE (field), d, 5533 /*first_initializer_p=*/false, complain); 5534 if (field_init == error_mark_node) 5535 return error_mark_node; 5536 5537 if (d->cur == old_cur && d->cur->index) 5538 { 5539 /* This can happen with an invalid initializer for a flexible 5540 array member (c++/54441). */ 5541 if (complain & tf_error) 5542 error ("invalid initializer for %q#D", field); 5543 return error_mark_node; 5544 } 5545 5546 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init); 5547 5548 /* [dcl.init.aggr] 5549 5550 When a union is initialized with a brace-enclosed 5551 initializer, the braces shall only contain an 5552 initializer for the first member of the union. */ 5553 if (TREE_CODE (type) == UNION_TYPE) 5554 break; 5555 5556 field = next_initializable_field (DECL_CHAIN (field)); 5557 } 5558 5559 return new_init; 5560} 5561 5562/* Subroutine of reshape_init_r. We're in a context where C99 initializer 5563 designators are not valid; either complain or return true to indicate 5564 that reshape_init_r should return error_mark_node. */ 5565 5566static bool 5567has_designator_problem (reshape_iter *d, tsubst_flags_t complain) 5568{ 5569 if (d->cur->index) 5570 { 5571 if (complain & tf_error) 5572 error ("C99 designator %qE outside aggregate initializer", 5573 d->cur->index); 5574 else 5575 return true; 5576 } 5577 return false; 5578} 5579 5580/* Subroutine of reshape_init, which processes a single initializer (part of 5581 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the 5582 iterator within the CONSTRUCTOR which points to the initializer to process. 5583 FIRST_INITIALIZER_P is true if this is the first initializer of the 5584 outermost CONSTRUCTOR node. */ 5585 5586static tree 5587reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p, 5588 tsubst_flags_t complain) 5589{ 5590 tree init = d->cur->value; 5591 5592 if (error_operand_p (init)) 5593 return error_mark_node; 5594 5595 if (first_initializer_p && !CP_AGGREGATE_TYPE_P (type) 5596 && has_designator_problem (d, complain)) 5597 return error_mark_node; 5598 5599 if (TREE_CODE (type) == COMPLEX_TYPE) 5600 { 5601 /* A complex type can be initialized from one or two initializers, 5602 but braces are not elided. */ 5603 d->cur++; 5604 if (BRACE_ENCLOSED_INITIALIZER_P (init)) 5605 { 5606 if (CONSTRUCTOR_NELTS (init) > 2) 5607 { 5608 if (complain & tf_error) 5609 error ("too many initializers for %qT", type); 5610 else 5611 return error_mark_node; 5612 } 5613 } 5614 else if (first_initializer_p && d->cur != d->end) 5615 { 5616 vec<constructor_elt, va_gc> *v = 0; 5617 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init); 5618 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, d->cur->value); 5619 if (has_designator_problem (d, complain)) 5620 return error_mark_node; 5621 d->cur++; 5622 init = build_constructor (init_list_type_node, v); 5623 } 5624 return init; 5625 } 5626 5627 /* A non-aggregate type is always initialized with a single 5628 initializer. */ 5629 if (!CP_AGGREGATE_TYPE_P (type)) 5630 { 5631 /* It is invalid to initialize a non-aggregate type with a 5632 brace-enclosed initializer before C++0x. 5633 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because 5634 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is 5635 a CONSTRUCTOR (with a record type). */ 5636 if (TREE_CODE (init) == CONSTRUCTOR 5637 /* Don't complain about a capture-init. */ 5638 && !CONSTRUCTOR_IS_DIRECT_INIT (init) 5639 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */ 5640 { 5641 if (SCALAR_TYPE_P (type)) 5642 { 5643 if (cxx_dialect < cxx11 5644 /* Isn't value-initialization. */ 5645 || CONSTRUCTOR_NELTS (init) > 0) 5646 { 5647 if (complain & tf_error) 5648 error ("braces around scalar initializer for type %qT", 5649 type); 5650 init = error_mark_node; 5651 } 5652 } 5653 else 5654 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS); 5655 } 5656 5657 d->cur++; 5658 return init; 5659 } 5660 5661 /* "If T is a class type and the initializer list has a single element of 5662 type cv U, where U is T or a class derived from T, the object is 5663 initialized from that element." Even if T is an aggregate. */ 5664 if (cxx_dialect >= cxx11 && (CLASS_TYPE_P (type) || VECTOR_TYPE_P (type)) 5665 && first_initializer_p 5666 && d->end - d->cur == 1 5667 && reference_related_p (type, TREE_TYPE (init))) 5668 { 5669 d->cur++; 5670 return init; 5671 } 5672 5673 /* [dcl.init.aggr] 5674 5675 All implicit type conversions (clause _conv_) are considered when 5676 initializing the aggregate member with an initializer from an 5677 initializer-list. If the initializer can initialize a member, 5678 the member is initialized. Otherwise, if the member is itself a 5679 non-empty subaggregate, brace elision is assumed and the 5680 initializer is considered for the initialization of the first 5681 member of the subaggregate. */ 5682 if (TREE_CODE (init) != CONSTRUCTOR 5683 /* But don't try this for the first initializer, since that would be 5684 looking through the outermost braces; A a2 = { a1 }; is not a 5685 valid aggregate initialization. */ 5686 && !first_initializer_p 5687 && (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (init)) 5688 || can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL, 5689 complain))) 5690 { 5691 d->cur++; 5692 return init; 5693 } 5694 5695 /* [dcl.init.string] 5696 5697 A char array (whether plain char, signed char, or unsigned char) 5698 can be initialized by a string-literal (optionally enclosed in 5699 braces); a wchar_t array can be initialized by a wide 5700 string-literal (optionally enclosed in braces). */ 5701 if (TREE_CODE (type) == ARRAY_TYPE 5702 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))) 5703 { 5704 tree str_init = init; 5705 5706 /* Strip one level of braces if and only if they enclose a single 5707 element (as allowed by [dcl.init.string]). */ 5708 if (!first_initializer_p 5709 && TREE_CODE (str_init) == CONSTRUCTOR 5710 && vec_safe_length (CONSTRUCTOR_ELTS (str_init)) == 1) 5711 { 5712 str_init = (*CONSTRUCTOR_ELTS (str_init))[0].value; 5713 } 5714 5715 /* If it's a string literal, then it's the initializer for the array 5716 as a whole. Otherwise, continue with normal initialization for 5717 array types (one value per array element). */ 5718 if (TREE_CODE (str_init) == STRING_CST) 5719 { 5720 if (has_designator_problem (d, complain)) 5721 return error_mark_node; 5722 d->cur++; 5723 return str_init; 5724 } 5725 } 5726 5727 /* The following cases are about aggregates. If we are not within a full 5728 initializer already, and there is not a CONSTRUCTOR, it means that there 5729 is a missing set of braces (that is, we are processing the case for 5730 which reshape_init exists). */ 5731 if (!first_initializer_p) 5732 { 5733 if (TREE_CODE (init) == CONSTRUCTOR) 5734 { 5735 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init))) 5736 /* There is no need to reshape pointer-to-member function 5737 initializers, as they are always constructed correctly 5738 by the front end. */ 5739 ; 5740 else if (COMPOUND_LITERAL_P (init)) 5741 /* For a nested compound literal, there is no need to reshape since 5742 brace elision is not allowed. Even if we decided to allow it, 5743 we should add a call to reshape_init in finish_compound_literal, 5744 before calling digest_init, so changing this code would still 5745 not be necessary. */ 5746 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init)); 5747 else 5748 { 5749 ++d->cur; 5750 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init)); 5751 return reshape_init (type, init, complain); 5752 } 5753 } 5754 5755 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT", 5756 type); 5757 } 5758 5759 /* Dispatch to specialized routines. */ 5760 if (CLASS_TYPE_P (type)) 5761 return reshape_init_class (type, d, first_initializer_p, complain); 5762 else if (TREE_CODE (type) == ARRAY_TYPE) 5763 return reshape_init_array (type, d, complain); 5764 else if (TREE_CODE (type) == VECTOR_TYPE) 5765 return reshape_init_vector (type, d, complain); 5766 else 5767 gcc_unreachable(); 5768} 5769 5770/* Undo the brace-elision allowed by [dcl.init.aggr] in a 5771 brace-enclosed aggregate initializer. 5772 5773 INIT is the CONSTRUCTOR containing the list of initializers describing 5774 a brace-enclosed initializer for an entity of the indicated aggregate TYPE. 5775 It may not presently match the shape of the TYPE; for example: 5776 5777 struct S { int a; int b; }; 5778 struct S a[] = { 1, 2, 3, 4 }; 5779 5780 Here INIT will hold a vector of four elements, rather than a 5781 vector of two elements, each itself a vector of two elements. This 5782 routine transforms INIT from the former form into the latter. The 5783 revised CONSTRUCTOR node is returned. */ 5784 5785tree 5786reshape_init (tree type, tree init, tsubst_flags_t complain) 5787{ 5788 vec<constructor_elt, va_gc> *v; 5789 reshape_iter d; 5790 tree new_init; 5791 5792 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init)); 5793 5794 v = CONSTRUCTOR_ELTS (init); 5795 5796 /* An empty constructor does not need reshaping, and it is always a valid 5797 initializer. */ 5798 if (vec_safe_is_empty (v)) 5799 return init; 5800 5801 /* Recurse on this CONSTRUCTOR. */ 5802 d.cur = &(*v)[0]; 5803 d.end = d.cur + v->length (); 5804 5805 new_init = reshape_init_r (type, &d, true, complain); 5806 if (new_init == error_mark_node) 5807 return error_mark_node; 5808 5809 /* Make sure all the element of the constructor were used. Otherwise, 5810 issue an error about exceeding initializers. */ 5811 if (d.cur != d.end) 5812 { 5813 if (complain & tf_error) 5814 error ("too many initializers for %qT", type); 5815 else 5816 return error_mark_node; 5817 } 5818 5819 return new_init; 5820} 5821 5822/* Verify array initializer. Returns true if errors have been reported. */ 5823 5824bool 5825check_array_initializer (tree decl, tree type, tree init) 5826{ 5827 tree element_type = TREE_TYPE (type); 5828 5829 /* The array type itself need not be complete, because the 5830 initializer may tell us how many elements are in the array. 5831 But, the elements of the array must be complete. */ 5832 if (!COMPLETE_TYPE_P (complete_type (element_type))) 5833 { 5834 if (decl) 5835 error ("elements of array %q#D have incomplete type", decl); 5836 else 5837 error ("elements of array %q#T have incomplete type", type); 5838 return true; 5839 } 5840 /* A compound literal can't have variable size. */ 5841 if (init && !decl 5842 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type))) 5843 || !TREE_CONSTANT (TYPE_SIZE (element_type)))) 5844 { 5845 error ("variable-sized compound literal"); 5846 return true; 5847 } 5848 return false; 5849} 5850 5851/* Subroutine of check_initializer; args are passed down from that function. 5852 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */ 5853 5854static tree 5855build_aggr_init_full_exprs (tree decl, tree init, int flags) 5856 5857{ 5858 gcc_assert (stmts_are_full_exprs_p ()); 5859 return build_aggr_init (decl, init, flags, tf_warning_or_error); 5860} 5861 5862/* Verify INIT (the initializer for DECL), and record the 5863 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for 5864 grok_reference_init. 5865 5866 If the return value is non-NULL, it is an expression that must be 5867 evaluated dynamically to initialize DECL. */ 5868 5869static tree 5870check_initializer (tree decl, tree init, int flags, vec<tree, va_gc> **cleanups) 5871{ 5872 tree type = TREE_TYPE (decl); 5873 tree init_code = NULL; 5874 tree core_type; 5875 5876 /* Things that are going to be initialized need to have complete 5877 type. */ 5878 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl)); 5879 5880 if (DECL_HAS_VALUE_EXPR_P (decl)) 5881 { 5882 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder, 5883 it doesn't have storage to be initialized. */ 5884 gcc_assert (init == NULL_TREE); 5885 return NULL_TREE; 5886 } 5887 5888 if (type == error_mark_node) 5889 /* We will have already complained. */ 5890 return NULL_TREE; 5891 5892 if (TREE_CODE (type) == ARRAY_TYPE) 5893 { 5894 if (check_array_initializer (decl, type, init)) 5895 return NULL_TREE; 5896 } 5897 else if (!COMPLETE_TYPE_P (type)) 5898 { 5899 error ("%q#D has incomplete type", decl); 5900 TREE_TYPE (decl) = error_mark_node; 5901 return NULL_TREE; 5902 } 5903 else 5904 /* There is no way to make a variable-sized class type in GNU C++. */ 5905 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type))); 5906 5907 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)) 5908 { 5909 int init_len = vec_safe_length (CONSTRUCTOR_ELTS (init)); 5910 if (SCALAR_TYPE_P (type)) 5911 { 5912 if (init_len == 0) 5913 { 5914 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS); 5915 init = build_zero_init (type, NULL_TREE, false); 5916 } 5917 else if (init_len != 1 && TREE_CODE (type) != COMPLEX_TYPE) 5918 { 5919 error ("scalar object %qD requires one element in initializer", 5920 decl); 5921 TREE_TYPE (decl) = error_mark_node; 5922 return NULL_TREE; 5923 } 5924 } 5925 } 5926 5927 if (TREE_CODE (decl) == CONST_DECL) 5928 { 5929 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE); 5930 5931 DECL_INITIAL (decl) = init; 5932 5933 gcc_assert (init != NULL_TREE); 5934 init = NULL_TREE; 5935 } 5936 else if (!init && DECL_REALLY_EXTERN (decl)) 5937 ; 5938 else if (init || type_build_ctor_call (type) 5939 || TREE_CODE (type) == REFERENCE_TYPE) 5940 { 5941 if (TREE_CODE (type) == REFERENCE_TYPE) 5942 { 5943 init = grok_reference_init (decl, type, init, flags); 5944 flags |= LOOKUP_ALREADY_DIGESTED; 5945 } 5946 else if (!init) 5947 check_for_uninitialized_const_var (decl); 5948 /* Do not reshape constructors of vectors (they don't need to be 5949 reshaped. */ 5950 else if (BRACE_ENCLOSED_INITIALIZER_P (init)) 5951 { 5952 if (is_std_init_list (type)) 5953 { 5954 init = perform_implicit_conversion (type, init, 5955 tf_warning_or_error); 5956 flags |= LOOKUP_ALREADY_DIGESTED; 5957 } 5958 else if (TYPE_NON_AGGREGATE_CLASS (type)) 5959 { 5960 /* Don't reshape if the class has constructors. */ 5961 if (cxx_dialect == cxx98) 5962 error ("in C++98 %qD must be initialized by constructor, " 5963 "not by %<{...}%>", 5964 decl); 5965 } 5966 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_VECTOR_OPAQUE (type)) 5967 { 5968 error ("opaque vector types cannot be initialized"); 5969 init = error_mark_node; 5970 } 5971 else 5972 { 5973 init = reshape_init (type, init, tf_warning_or_error); 5974 flags |= LOOKUP_NO_NARROWING; 5975 } 5976 } 5977 else if (TREE_CODE (init) == TREE_LIST 5978 && TREE_TYPE (init) != unknown_type_node 5979 && !MAYBE_CLASS_TYPE_P (type)) 5980 { 5981 gcc_assert (TREE_CODE (decl) != RESULT_DECL); 5982 5983 /* We get here with code like `int a (2);' */ 5984 init = build_x_compound_expr_from_list (init, ELK_INIT, 5985 tf_warning_or_error); 5986 } 5987 5988 /* If DECL has an array type without a specific bound, deduce the 5989 array size from the initializer. */ 5990 maybe_deduce_size_from_array_init (decl, init); 5991 type = TREE_TYPE (decl); 5992 if (type == error_mark_node) 5993 return NULL_TREE; 5994 5995 if ((type_build_ctor_call (type) || CLASS_TYPE_P (type)) 5996 && !(flags & LOOKUP_ALREADY_DIGESTED) 5997 && !(init && BRACE_ENCLOSED_INITIALIZER_P (init) 5998 && CP_AGGREGATE_TYPE_P (type) 5999 && (CLASS_TYPE_P (type) 6000 || !TYPE_NEEDS_CONSTRUCTING (type) 6001 || type_has_extended_temps (type)))) 6002 { 6003 init_code = build_aggr_init_full_exprs (decl, init, flags); 6004 6005 /* A constructor call is a non-trivial initializer even if 6006 it isn't explicitly written. */ 6007 if (TREE_SIDE_EFFECTS (init_code)) 6008 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = true; 6009 6010 /* If this is a constexpr initializer, expand_default_init will 6011 have returned an INIT_EXPR rather than a CALL_EXPR. In that 6012 case, pull the initializer back out and pass it down into 6013 store_init_value. */ 6014 while (TREE_CODE (init_code) == EXPR_STMT 6015 || TREE_CODE (init_code) == CONVERT_EXPR) 6016 init_code = TREE_OPERAND (init_code, 0); 6017 if (TREE_CODE (init_code) == INIT_EXPR) 6018 { 6019 init = TREE_OPERAND (init_code, 1); 6020 init_code = NULL_TREE; 6021 /* Don't call digest_init; it's unnecessary and will complain 6022 about aggregate initialization of non-aggregate classes. */ 6023 flags |= LOOKUP_ALREADY_DIGESTED; 6024 } 6025 else if (DECL_DECLARED_CONSTEXPR_P (decl)) 6026 { 6027 /* Declared constexpr, but no suitable initializer; massage 6028 init appropriately so we can pass it into store_init_value 6029 for the error. */ 6030 if (CLASS_TYPE_P (type) 6031 && (!init || TREE_CODE (init) == TREE_LIST)) 6032 { 6033 init = build_functional_cast (type, init, tf_none); 6034 if (TREE_CODE (init) == TARGET_EXPR) 6035 TARGET_EXPR_DIRECT_INIT_P (init) = true; 6036 } 6037 init_code = NULL_TREE; 6038 } 6039 else 6040 init = NULL_TREE; 6041 } 6042 6043 if (init && TREE_CODE (init) != TREE_VEC) 6044 { 6045 /* In aggregate initialization of a variable, each element 6046 initialization is a full-expression because there is no 6047 enclosing expression. */ 6048 gcc_assert (stmts_are_full_exprs_p ()); 6049 6050 init_code = store_init_value (decl, init, cleanups, flags); 6051 6052 if (pedantic && TREE_CODE (type) == ARRAY_TYPE 6053 && DECL_INITIAL (decl) 6054 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST 6055 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl))) 6056 warning (0, "array %qD initialized by parenthesized string literal %qE", 6057 decl, DECL_INITIAL (decl)); 6058 init = NULL; 6059 } 6060 } 6061 else 6062 { 6063 if (CLASS_TYPE_P (core_type = strip_array_types (type)) 6064 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type) 6065 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))) 6066 diagnose_uninitialized_cst_or_ref_member (core_type, /*using_new=*/false, 6067 /*complain=*/true); 6068 6069 check_for_uninitialized_const_var (decl); 6070 } 6071 6072 if (init && init != error_mark_node) 6073 init_code = build2 (INIT_EXPR, type, decl, init); 6074 6075 if (init_code) 6076 { 6077 /* We might have set these in cp_finish_decl. */ 6078 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = false; 6079 TREE_CONSTANT (decl) = false; 6080 } 6081 6082 if (init_code && DECL_IN_AGGR_P (decl)) 6083 { 6084 static int explained = 0; 6085 6086 if (cxx_dialect < cxx11) 6087 error ("initializer invalid for static member with constructor"); 6088 else 6089 error ("non-constant in-class initialization invalid for static " 6090 "member %qD", decl); 6091 if (!explained) 6092 { 6093 inform (input_location, 6094 "(an out of class initialization is required)"); 6095 explained = 1; 6096 } 6097 return NULL_TREE; 6098 } 6099 6100 return init_code; 6101} 6102 6103/* If DECL is not a local variable, give it RTL. */ 6104 6105static void 6106make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec) 6107{ 6108 int toplev = toplevel_bindings_p (); 6109 int defer_p; 6110 6111 /* Set the DECL_ASSEMBLER_NAME for the object. */ 6112 if (asmspec) 6113 { 6114 /* The `register' keyword, when used together with an 6115 asm-specification, indicates that the variable should be 6116 placed in a particular register. */ 6117 if (VAR_P (decl) && DECL_REGISTER (decl)) 6118 { 6119 set_user_assembler_name (decl, asmspec); 6120 DECL_HARD_REGISTER (decl) = 1; 6121 } 6122 else 6123 { 6124 if (TREE_CODE (decl) == FUNCTION_DECL 6125 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL) 6126 set_builtin_user_assembler_name (decl, asmspec); 6127 set_user_assembler_name (decl, asmspec); 6128 } 6129 } 6130 6131 /* Handle non-variables up front. */ 6132 if (!VAR_P (decl)) 6133 { 6134 rest_of_decl_compilation (decl, toplev, at_eof); 6135 return; 6136 } 6137 6138 /* If we see a class member here, it should be a static data 6139 member. */ 6140 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl)) 6141 { 6142 gcc_assert (TREE_STATIC (decl)); 6143 /* An in-class declaration of a static data member should be 6144 external; it is only a declaration, and not a definition. */ 6145 if (init == NULL_TREE) 6146 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl)); 6147 } 6148 6149 /* We don't create any RTL for local variables. */ 6150 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl)) 6151 return; 6152 6153 /* We defer emission of local statics until the corresponding 6154 DECL_EXPR is expanded. But with constexpr its function might never 6155 be expanded, so go ahead and tell cgraph about the variable now. */ 6156 defer_p = ((DECL_FUNCTION_SCOPE_P (decl) 6157 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (decl))) 6158 || DECL_VIRTUAL_P (decl)); 6159 6160 /* Defer template instantiations. */ 6161 if (DECL_LANG_SPECIFIC (decl) 6162 && DECL_IMPLICIT_INSTANTIATION (decl)) 6163 defer_p = 1; 6164 6165 /* If we're not deferring, go ahead and assemble the variable. */ 6166 if (!defer_p) 6167 rest_of_decl_compilation (decl, toplev, at_eof); 6168} 6169 6170/* walk_tree helper for wrap_temporary_cleanups, below. */ 6171 6172static tree 6173wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data) 6174{ 6175 /* Stop at types or full-expression boundaries. */ 6176 if (TYPE_P (*stmt_p) 6177 || TREE_CODE (*stmt_p) == CLEANUP_POINT_EXPR) 6178 { 6179 *walk_subtrees = 0; 6180 return NULL_TREE; 6181 } 6182 6183 if (TREE_CODE (*stmt_p) == TARGET_EXPR) 6184 { 6185 tree guard = (tree)data; 6186 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p); 6187 6188 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard); 6189 /* Tell honor_protect_cleanup_actions to handle this as a separate 6190 cleanup. */ 6191 TRY_CATCH_IS_CLEANUP (tcleanup) = 1; 6192 6193 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup; 6194 } 6195 6196 return NULL_TREE; 6197} 6198 6199/* We're initializing a local variable which has a cleanup GUARD. If there 6200 are any temporaries used in the initializer INIT of this variable, we 6201 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the 6202 variable will be cleaned up properly if one of them throws. 6203 6204 Unfortunately, there's no way to express this properly in terms of 6205 nesting, as the regions for the temporaries overlap the region for the 6206 variable itself; if there are two temporaries, the variable needs to be 6207 the first thing destroyed if either of them throws. However, we only 6208 want to run the variable's cleanup if it actually got constructed. So 6209 we need to guard the temporary cleanups with the variable's cleanup if 6210 they are run on the normal path, but not if they are run on the 6211 exceptional path. We implement this by telling 6212 honor_protect_cleanup_actions to strip the variable cleanup from the 6213 exceptional path. */ 6214 6215static void 6216wrap_temporary_cleanups (tree init, tree guard) 6217{ 6218 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard); 6219} 6220 6221/* Generate code to initialize DECL (a local variable). */ 6222 6223static void 6224initialize_local_var (tree decl, tree init) 6225{ 6226 tree type = TREE_TYPE (decl); 6227 tree cleanup; 6228 int already_used; 6229 6230 gcc_assert (VAR_P (decl) 6231 || TREE_CODE (decl) == RESULT_DECL); 6232 gcc_assert (!TREE_STATIC (decl)); 6233 6234 if (DECL_SIZE (decl) == NULL_TREE) 6235 { 6236 /* If we used it already as memory, it must stay in memory. */ 6237 DECL_INITIAL (decl) = NULL_TREE; 6238 TREE_ADDRESSABLE (decl) = TREE_USED (decl); 6239 return; 6240 } 6241 6242 if (type == error_mark_node) 6243 return; 6244 6245 /* Compute and store the initial value. */ 6246 already_used = TREE_USED (decl) || TREE_USED (type); 6247 if (TREE_USED (type)) 6248 DECL_READ_P (decl) = 1; 6249 6250 /* Generate a cleanup, if necessary. */ 6251 cleanup = cxx_maybe_build_cleanup (decl, tf_warning_or_error); 6252 6253 /* Perform the initialization. */ 6254 if (init) 6255 { 6256 tree rinit = (TREE_CODE (init) == INIT_EXPR 6257 ? TREE_OPERAND (init, 1) : NULL_TREE); 6258 if (rinit && !TREE_SIDE_EFFECTS (rinit)) 6259 { 6260 /* Stick simple initializers in DECL_INITIAL so that 6261 -Wno-init-self works (c++/34772). */ 6262 gcc_assert (TREE_OPERAND (init, 0) == decl); 6263 DECL_INITIAL (decl) = rinit; 6264 6265 if (warn_init_self && TREE_CODE (type) == REFERENCE_TYPE) 6266 { 6267 STRIP_NOPS (rinit); 6268 if (rinit == decl) 6269 warning_at (DECL_SOURCE_LOCATION (decl), 6270 OPT_Winit_self, 6271 "reference %qD is initialized with itself", decl); 6272 } 6273 } 6274 else 6275 { 6276 int saved_stmts_are_full_exprs_p; 6277 6278 /* If we're only initializing a single object, guard the 6279 destructors of any temporaries used in its initializer with 6280 its destructor. This isn't right for arrays because each 6281 element initialization is a full-expression. */ 6282 if (cleanup && TREE_CODE (type) != ARRAY_TYPE) 6283 wrap_temporary_cleanups (init, cleanup); 6284 6285 gcc_assert (building_stmt_list_p ()); 6286 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p (); 6287 current_stmt_tree ()->stmts_are_full_exprs_p = 1; 6288 finish_expr_stmt (init); 6289 current_stmt_tree ()->stmts_are_full_exprs_p = 6290 saved_stmts_are_full_exprs_p; 6291 } 6292 } 6293 6294 /* Set this to 0 so we can tell whether an aggregate which was 6295 initialized was ever used. Don't do this if it has a 6296 destructor, so we don't complain about the 'resource 6297 allocation is initialization' idiom. Now set 6298 attribute((unused)) on types so decls of that type will be 6299 marked used. (see TREE_USED, above.) */ 6300 if (TYPE_NEEDS_CONSTRUCTING (type) 6301 && ! already_used 6302 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type) 6303 && DECL_NAME (decl)) 6304 TREE_USED (decl) = 0; 6305 else if (already_used) 6306 TREE_USED (decl) = 1; 6307 6308 if (cleanup) 6309 finish_decl_cleanup (decl, cleanup); 6310} 6311 6312/* DECL is a VAR_DECL for a compiler-generated variable with static 6313 storage duration (like a virtual table) whose initializer is a 6314 compile-time constant. Initialize the variable and provide it to the 6315 back end. */ 6316 6317void 6318initialize_artificial_var (tree decl, vec<constructor_elt, va_gc> *v) 6319{ 6320 tree init; 6321 gcc_assert (DECL_ARTIFICIAL (decl)); 6322 init = build_constructor (TREE_TYPE (decl), v); 6323 gcc_assert (TREE_CODE (init) == CONSTRUCTOR); 6324 DECL_INITIAL (decl) = init; 6325 DECL_INITIALIZED_P (decl) = 1; 6326 determine_visibility (decl); 6327 layout_var_decl (decl); 6328 maybe_commonize_var (decl); 6329 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL); 6330} 6331 6332/* INIT is the initializer for a variable, as represented by the 6333 parser. Returns true iff INIT is type-dependent. */ 6334 6335static bool 6336type_dependent_init_p (tree init) 6337{ 6338 if (TREE_CODE (init) == TREE_LIST) 6339 /* A parenthesized initializer, e.g.: int i (3, 2); ? */ 6340 return any_type_dependent_elements_p (init); 6341 else if (TREE_CODE (init) == CONSTRUCTOR) 6342 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */ 6343 { 6344 vec<constructor_elt, va_gc> *elts; 6345 size_t nelts; 6346 size_t i; 6347 6348 elts = CONSTRUCTOR_ELTS (init); 6349 nelts = vec_safe_length (elts); 6350 for (i = 0; i < nelts; ++i) 6351 if (type_dependent_init_p ((*elts)[i].value)) 6352 return true; 6353 } 6354 else 6355 /* It must be a simple expression, e.g., int i = 3; */ 6356 return type_dependent_expression_p (init); 6357 6358 return false; 6359} 6360 6361/* INIT is the initializer for a variable, as represented by the 6362 parser. Returns true iff INIT is value-dependent. */ 6363 6364static bool 6365value_dependent_init_p (tree init) 6366{ 6367 if (TREE_CODE (init) == TREE_LIST) 6368 /* A parenthesized initializer, e.g.: int i (3, 2); ? */ 6369 return any_value_dependent_elements_p (init); 6370 else if (TREE_CODE (init) == CONSTRUCTOR) 6371 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */ 6372 { 6373 vec<constructor_elt, va_gc> *elts; 6374 size_t nelts; 6375 size_t i; 6376 6377 elts = CONSTRUCTOR_ELTS (init); 6378 nelts = vec_safe_length (elts); 6379 for (i = 0; i < nelts; ++i) 6380 if (value_dependent_init_p ((*elts)[i].value)) 6381 return true; 6382 } 6383 else 6384 /* It must be a simple expression, e.g., int i = 3; */ 6385 return value_dependent_expression_p (init); 6386 6387 return false; 6388} 6389 6390/* Finish processing of a declaration; 6391 install its line number and initial value. 6392 If the length of an array type is not known before, 6393 it must be determined now, from the initial value, or it is an error. 6394 6395 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is 6396 true, then INIT is an integral constant expression. 6397 6398 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0 6399 if the (init) syntax was used. */ 6400 6401void 6402cp_finish_decl (tree decl, tree init, bool init_const_expr_p, 6403 tree asmspec_tree, int flags) 6404{ 6405 tree type; 6406 vec<tree, va_gc> *cleanups = NULL; 6407 const char *asmspec = NULL; 6408 int was_readonly = 0; 6409 bool var_definition_p = false; 6410 tree auto_node; 6411 6412 if (decl == error_mark_node) 6413 return; 6414 else if (! decl) 6415 { 6416 if (init) 6417 error ("assignment (not initialization) in declaration"); 6418 return; 6419 } 6420 6421 gcc_assert (TREE_CODE (decl) != RESULT_DECL); 6422 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */ 6423 gcc_assert (TREE_CODE (decl) != PARM_DECL); 6424 6425 type = TREE_TYPE (decl); 6426 if (type == error_mark_node) 6427 return; 6428 6429 /* If a name was specified, get the string. */ 6430 if (at_namespace_scope_p ()) 6431 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree); 6432 if (asmspec_tree && asmspec_tree != error_mark_node) 6433 asmspec = TREE_STRING_POINTER (asmspec_tree); 6434 6435 if (current_class_type 6436 && CP_DECL_CONTEXT (decl) == current_class_type 6437 && TYPE_BEING_DEFINED (current_class_type) 6438 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type) 6439 && (DECL_INITIAL (decl) || init)) 6440 DECL_INITIALIZED_IN_CLASS_P (decl) = 1; 6441 6442 if (TREE_CODE (decl) != FUNCTION_DECL 6443 && (auto_node = type_uses_auto (type))) 6444 { 6445 tree d_init; 6446 if (init == NULL_TREE) 6447 { 6448 if (DECL_LANG_SPECIFIC (decl) 6449 && DECL_TEMPLATE_INSTANTIATION (decl) 6450 && !DECL_TEMPLATE_INSTANTIATED (decl)) 6451 { 6452 /* init is null because we're deferring instantiating the 6453 initializer until we need it. Well, we need it now. */ 6454 instantiate_decl (decl, /*defer_ok*/true, /*expl*/false); 6455 return; 6456 } 6457 6458 error ("declaration of %q#D has no initializer", decl); 6459 TREE_TYPE (decl) = error_mark_node; 6460 return; 6461 } 6462 d_init = init; 6463 if (TREE_CODE (d_init) == TREE_LIST) 6464 d_init = build_x_compound_expr_from_list (d_init, ELK_INIT, 6465 tf_warning_or_error); 6466 d_init = resolve_nondeduced_context (d_init, tf_warning_or_error); 6467 type = TREE_TYPE (decl) = do_auto_deduction (type, d_init, 6468 auto_node); 6469 if (type == error_mark_node) 6470 return; 6471 cp_apply_type_quals_to_decl (cp_type_quals (type), decl); 6472 } 6473 6474 if (!ensure_literal_type_for_constexpr_object (decl)) 6475 DECL_DECLARED_CONSTEXPR_P (decl) = 0; 6476 6477 if (VAR_P (decl) 6478 && DECL_CLASS_SCOPE_P (decl) 6479 && DECL_INITIALIZED_IN_CLASS_P (decl)) 6480 check_static_variable_definition (decl, type); 6481 6482 if (init && TREE_CODE (decl) == FUNCTION_DECL) 6483 { 6484 tree clone; 6485 if (init == ridpointers[(int)RID_DELETE]) 6486 { 6487 /* FIXME check this is 1st decl. */ 6488 DECL_DELETED_FN (decl) = 1; 6489 DECL_DECLARED_INLINE_P (decl) = 1; 6490 DECL_INITIAL (decl) = error_mark_node; 6491 FOR_EACH_CLONE (clone, decl) 6492 { 6493 DECL_DELETED_FN (clone) = 1; 6494 DECL_DECLARED_INLINE_P (clone) = 1; 6495 DECL_INITIAL (clone) = error_mark_node; 6496 } 6497 init = NULL_TREE; 6498 } 6499 else if (init == ridpointers[(int)RID_DEFAULT]) 6500 { 6501 if (defaultable_fn_check (decl)) 6502 DECL_DEFAULTED_FN (decl) = 1; 6503 else 6504 DECL_INITIAL (decl) = NULL_TREE; 6505 } 6506 } 6507 6508 if (init && VAR_P (decl)) 6509 { 6510 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1; 6511 /* If DECL is a reference, then we want to know whether init is a 6512 reference constant; init_const_expr_p as passed tells us whether 6513 it's an rvalue constant. */ 6514 if (TREE_CODE (type) == REFERENCE_TYPE) 6515 init_const_expr_p = potential_constant_expression (init); 6516 if (init_const_expr_p) 6517 { 6518 /* Set these flags now for templates. We'll update the flags in 6519 store_init_value for instantiations. */ 6520 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1; 6521 if (decl_maybe_constant_var_p (decl)) 6522 TREE_CONSTANT (decl) = 1; 6523 } 6524 } 6525 6526 if (processing_template_decl) 6527 { 6528 bool type_dependent_p; 6529 6530 /* Add this declaration to the statement-tree. */ 6531 if (at_function_scope_p ()) 6532 add_decl_expr (decl); 6533 6534 type_dependent_p = dependent_type_p (type); 6535 6536 if (check_for_bare_parameter_packs (init)) 6537 { 6538 init = NULL_TREE; 6539 DECL_INITIAL (decl) = NULL_TREE; 6540 } 6541 6542 /* Generally, initializers in templates are expanded when the 6543 template is instantiated. But, if DECL is a variable constant 6544 then it can be used in future constant expressions, so its value 6545 must be available. */ 6546 6547 if (!VAR_P (decl) || dependent_type_p (type)) 6548 /* We can't do anything if the decl has dependent type. */; 6549 else if (init 6550 && init_const_expr_p 6551 && !type_dependent_p 6552 && TREE_CODE (type) != REFERENCE_TYPE 6553 && decl_maybe_constant_var_p (decl) 6554 && !type_dependent_init_p (init) 6555 && !value_dependent_init_p (init)) 6556 { 6557 /* This variable seems to be a non-dependent constant, so process 6558 its initializer. If check_initializer returns non-null the 6559 initialization wasn't constant after all. */ 6560 tree init_code; 6561 cleanups = make_tree_vector (); 6562 init_code = check_initializer (decl, init, flags, &cleanups); 6563 if (init_code == NULL_TREE) 6564 init = NULL_TREE; 6565 release_tree_vector (cleanups); 6566 } 6567 else if (!DECL_PRETTY_FUNCTION_P (decl)) 6568 { 6569 /* Deduce array size even if the initializer is dependent. */ 6570 maybe_deduce_size_from_array_init (decl, init); 6571 /* And complain about multiple initializers. */ 6572 if (init && TREE_CODE (init) == TREE_LIST && TREE_CHAIN (init) 6573 && !MAYBE_CLASS_TYPE_P (type)) 6574 init = build_x_compound_expr_from_list (init, ELK_INIT, 6575 tf_warning_or_error); 6576 } 6577 6578 if (init) 6579 DECL_INITIAL (decl) = init; 6580 return; 6581 } 6582 6583 /* Just store non-static data member initializers for later. */ 6584 if (init && TREE_CODE (decl) == FIELD_DECL) 6585 DECL_INITIAL (decl) = init; 6586 6587 /* Take care of TYPE_DECLs up front. */ 6588 if (TREE_CODE (decl) == TYPE_DECL) 6589 { 6590 if (type != error_mark_node 6591 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl)) 6592 { 6593 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type) 6594 warning (0, "shadowing previous type declaration of %q#D", decl); 6595 set_identifier_type_value (DECL_NAME (decl), decl); 6596 } 6597 6598 /* If we have installed this as the canonical typedef for this 6599 type, and that type has not been defined yet, delay emitting 6600 the debug information for it, as we will emit it later. */ 6601 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl 6602 && !COMPLETE_TYPE_P (TREE_TYPE (decl))) 6603 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1; 6604 6605 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 6606 at_eof); 6607 return; 6608 } 6609 6610 /* A reference will be modified here, as it is initialized. */ 6611 if (! DECL_EXTERNAL (decl) 6612 && TREE_READONLY (decl) 6613 && TREE_CODE (type) == REFERENCE_TYPE) 6614 { 6615 was_readonly = 1; 6616 TREE_READONLY (decl) = 0; 6617 } 6618 6619 if (VAR_P (decl)) 6620 { 6621 /* If this is a local variable that will need a mangled name, 6622 register it now. We must do this before processing the 6623 initializer for the variable, since the initialization might 6624 require a guard variable, and since the mangled name of the 6625 guard variable will depend on the mangled name of this 6626 variable. */ 6627 if (DECL_FUNCTION_SCOPE_P (decl) 6628 && TREE_STATIC (decl) 6629 && !DECL_ARTIFICIAL (decl)) 6630 { 6631 push_local_name (decl); 6632 if (DECL_CONSTRUCTOR_P (current_function_decl) 6633 || DECL_DESTRUCTOR_P (current_function_decl)) 6634 /* Normally local_decls is populated during GIMPLE lowering, 6635 but [cd]tors are never actually compiled directly. We need 6636 to put statics on the list so we can deal with the label 6637 address extension. FIXME. */ 6638 add_local_decl (cfun, decl); 6639 } 6640 6641 /* Convert the initializer to the type of DECL, if we have not 6642 already initialized DECL. */ 6643 if (!DECL_INITIALIZED_P (decl) 6644 /* If !DECL_EXTERNAL then DECL is being defined. In the 6645 case of a static data member initialized inside the 6646 class-specifier, there can be an initializer even if DECL 6647 is *not* defined. */ 6648 && (!DECL_EXTERNAL (decl) || init)) 6649 { 6650 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type)) 6651 { 6652 tree jclass 6653 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass")); 6654 /* Allow libjava/prims.cc define primitive classes. */ 6655 if (init != NULL_TREE 6656 || jclass == NULL_TREE 6657 || TREE_CODE (jclass) != TYPE_DECL 6658 || !POINTER_TYPE_P (TREE_TYPE (jclass)) 6659 || !same_type_ignoring_top_level_qualifiers_p 6660 (type, TREE_TYPE (TREE_TYPE (jclass)))) 6661 error ("Java object %qD not allocated with %<new%>", decl); 6662 init = NULL_TREE; 6663 } 6664 cleanups = make_tree_vector (); 6665 init = check_initializer (decl, init, flags, &cleanups); 6666 6667 /* Handle: 6668 6669 [dcl.init] 6670 6671 The memory occupied by any object of static storage 6672 duration is zero-initialized at program startup before 6673 any other initialization takes place. 6674 6675 We cannot create an appropriate initializer until after 6676 the type of DECL is finalized. If DECL_INITIAL is set, 6677 then the DECL is statically initialized, and any 6678 necessary zero-initialization has already been performed. */ 6679 if (TREE_STATIC (decl) && !DECL_INITIAL (decl)) 6680 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl), 6681 /*nelts=*/NULL_TREE, 6682 /*static_storage_p=*/true); 6683 /* Remember that the initialization for this variable has 6684 taken place. */ 6685 DECL_INITIALIZED_P (decl) = 1; 6686 /* This declaration is the definition of this variable, 6687 unless we are initializing a static data member within 6688 the class specifier. */ 6689 if (!DECL_EXTERNAL (decl)) 6690 var_definition_p = true; 6691 } 6692 /* If the variable has an array type, lay out the type, even if 6693 there is no initializer. It is valid to index through the 6694 array, and we must get TYPE_ALIGN set correctly on the array 6695 type. */ 6696 else if (TREE_CODE (type) == ARRAY_TYPE) 6697 layout_type (type); 6698 6699 if (TREE_STATIC (decl) 6700 && !at_function_scope_p () 6701 && current_function_decl == NULL) 6702 /* So decl is a global variable or a static member of a 6703 non local class. Record the types it uses 6704 so that we can decide later to emit debug info for them. */ 6705 record_types_used_by_current_var_decl (decl); 6706 } 6707 else if (TREE_CODE (decl) == FIELD_DECL 6708 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type)) 6709 error ("non-static data member %qD has Java class type", decl); 6710 6711 /* Add this declaration to the statement-tree. This needs to happen 6712 after the call to check_initializer so that the DECL_EXPR for a 6713 reference temp is added before the DECL_EXPR for the reference itself. */ 6714 if (DECL_FUNCTION_SCOPE_P (decl)) 6715 { 6716 /* If we're building a variable sized type, and we might be 6717 reachable other than via the top of the current binding 6718 level, then create a new BIND_EXPR so that we deallocate 6719 the object at the right time. */ 6720 if (VAR_P (decl) 6721 && DECL_SIZE (decl) 6722 && !TREE_CONSTANT (DECL_SIZE (decl)) 6723 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list)) 6724 { 6725 tree bind; 6726 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL); 6727 TREE_SIDE_EFFECTS (bind) = 1; 6728 add_stmt (bind); 6729 BIND_EXPR_BODY (bind) = push_stmt_list (); 6730 } 6731 add_decl_expr (decl); 6732 } 6733 6734 /* Let the middle end know about variables and functions -- but not 6735 static data members in uninstantiated class templates. */ 6736 if (VAR_OR_FUNCTION_DECL_P (decl)) 6737 { 6738 if (VAR_P (decl)) 6739 { 6740 layout_var_decl (decl); 6741 maybe_commonize_var (decl); 6742 } 6743 6744 /* This needs to happen after the linkage is set. */ 6745 determine_visibility (decl); 6746 6747 if (var_definition_p && TREE_STATIC (decl)) 6748 { 6749 /* If a TREE_READONLY variable needs initialization 6750 at runtime, it is no longer readonly and we need to 6751 avoid MEM_READONLY_P being set on RTL created for it. */ 6752 if (init) 6753 { 6754 if (TREE_READONLY (decl)) 6755 TREE_READONLY (decl) = 0; 6756 was_readonly = 0; 6757 } 6758 else if (was_readonly) 6759 TREE_READONLY (decl) = 1; 6760 6761 /* Likewise if it needs destruction. */ 6762 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) 6763 TREE_READONLY (decl) = 0; 6764 } 6765 6766 make_rtl_for_nonlocal_decl (decl, init, asmspec); 6767 6768 /* Check for abstractness of the type. Notice that there is no 6769 need to strip array types here since the check for those types 6770 is already done within create_array_type_for_decl. */ 6771 abstract_virtuals_error (decl, type); 6772 6773 if (TREE_TYPE (decl) == error_mark_node) 6774 /* No initialization required. */ 6775 ; 6776 else if (TREE_CODE (decl) == FUNCTION_DECL) 6777 { 6778 if (init) 6779 { 6780 if (init == ridpointers[(int)RID_DEFAULT]) 6781 { 6782 /* An out-of-class default definition is defined at 6783 the point where it is explicitly defaulted. */ 6784 if (DECL_DELETED_FN (decl)) 6785 maybe_explain_implicit_delete (decl); 6786 else if (DECL_INITIAL (decl) == error_mark_node) 6787 synthesize_method (decl); 6788 } 6789 else 6790 error ("function %q#D is initialized like a variable", decl); 6791 } 6792 /* else no initialization required. */ 6793 } 6794 else if (DECL_EXTERNAL (decl) 6795 && ! (DECL_LANG_SPECIFIC (decl) 6796 && DECL_NOT_REALLY_EXTERN (decl))) 6797 { 6798 if (init) 6799 DECL_INITIAL (decl) = init; 6800 } 6801 /* A variable definition. */ 6802 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl)) 6803 /* Initialize the local variable. */ 6804 initialize_local_var (decl, init); 6805 6806 /* If a variable is defined, and then a subsequent 6807 definition with external linkage is encountered, we will 6808 get here twice for the same variable. We want to avoid 6809 calling expand_static_init more than once. For variables 6810 that are not static data members, we can call 6811 expand_static_init only when we actually process the 6812 initializer. It is not legal to redeclare a static data 6813 member, so this issue does not arise in that case. */ 6814 else if (var_definition_p && TREE_STATIC (decl)) 6815 expand_static_init (decl, init); 6816 } 6817 6818 /* If a CLEANUP_STMT was created to destroy a temporary bound to a 6819 reference, insert it in the statement-tree now. */ 6820 if (cleanups) 6821 { 6822 unsigned i; tree t; 6823 FOR_EACH_VEC_ELT (*cleanups, i, t) 6824 push_cleanup (decl, t, false); 6825 release_tree_vector (cleanups); 6826 } 6827 6828 if (was_readonly) 6829 TREE_READONLY (decl) = 1; 6830 6831 invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl); 6832} 6833 6834/* Returns a declaration for a VAR_DECL as if: 6835 6836 extern "C" TYPE NAME; 6837 6838 had been seen. Used to create compiler-generated global 6839 variables. */ 6840 6841static tree 6842declare_global_var (tree name, tree type) 6843{ 6844 tree decl; 6845 6846 push_to_top_level (); 6847 decl = build_decl (input_location, VAR_DECL, name, type); 6848 TREE_PUBLIC (decl) = 1; 6849 DECL_EXTERNAL (decl) = 1; 6850 DECL_ARTIFICIAL (decl) = 1; 6851 /* If the user has explicitly declared this variable (perhaps 6852 because the code we are compiling is part of a low-level runtime 6853 library), then it is possible that our declaration will be merged 6854 with theirs by pushdecl. */ 6855 decl = pushdecl (decl); 6856 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0); 6857 pop_from_top_level (); 6858 6859 return decl; 6860} 6861 6862/* Returns the type for the argument to "__cxa_atexit" (or "atexit", 6863 if "__cxa_atexit" is not being used) corresponding to the function 6864 to be called when the program exits. */ 6865 6866static tree 6867get_atexit_fn_ptr_type (void) 6868{ 6869 tree fn_type; 6870 6871 if (!atexit_fn_ptr_type_node) 6872 { 6873 tree arg_type; 6874 if (flag_use_cxa_atexit 6875 && !targetm.cxx.use_atexit_for_cxa_atexit ()) 6876 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */ 6877 arg_type = ptr_type_node; 6878 else 6879 /* The parameter to "atexit" is "void (*)(void)". */ 6880 arg_type = NULL_TREE; 6881 6882 fn_type = build_function_type_list (void_type_node, 6883 arg_type, NULL_TREE); 6884 atexit_fn_ptr_type_node = build_pointer_type (fn_type); 6885 } 6886 6887 return atexit_fn_ptr_type_node; 6888} 6889 6890/* Returns a pointer to the `atexit' function. Note that if 6891 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new 6892 `__cxa_atexit' function specified in the IA64 C++ ABI. */ 6893 6894static tree 6895get_atexit_node (void) 6896{ 6897 tree atexit_fndecl; 6898 tree fn_type; 6899 tree fn_ptr_type; 6900 const char *name; 6901 bool use_aeabi_atexit; 6902 6903 if (atexit_node) 6904 return atexit_node; 6905 6906 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ()) 6907 { 6908 /* The declaration for `__cxa_atexit' is: 6909 6910 int __cxa_atexit (void (*)(void *), void *, void *) 6911 6912 We build up the argument types and then the function type 6913 itself. */ 6914 tree argtype0, argtype1, argtype2; 6915 6916 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit (); 6917 /* First, build the pointer-to-function type for the first 6918 argument. */ 6919 fn_ptr_type = get_atexit_fn_ptr_type (); 6920 /* Then, build the rest of the argument types. */ 6921 argtype2 = ptr_type_node; 6922 if (use_aeabi_atexit) 6923 { 6924 argtype1 = fn_ptr_type; 6925 argtype0 = ptr_type_node; 6926 } 6927 else 6928 { 6929 argtype1 = ptr_type_node; 6930 argtype0 = fn_ptr_type; 6931 } 6932 /* And the final __cxa_atexit type. */ 6933 fn_type = build_function_type_list (integer_type_node, 6934 argtype0, argtype1, argtype2, 6935 NULL_TREE); 6936 if (use_aeabi_atexit) 6937 name = "__aeabi_atexit"; 6938 else 6939 name = "__cxa_atexit"; 6940 } 6941 else 6942 { 6943 /* The declaration for `atexit' is: 6944 6945 int atexit (void (*)()); 6946 6947 We build up the argument types and then the function type 6948 itself. */ 6949 fn_ptr_type = get_atexit_fn_ptr_type (); 6950 /* Build the final atexit type. */ 6951 fn_type = build_function_type_list (integer_type_node, 6952 fn_ptr_type, NULL_TREE); 6953 name = "atexit"; 6954 } 6955 6956 /* Now, build the function declaration. */ 6957 push_lang_context (lang_name_c); 6958 atexit_fndecl = build_library_fn_ptr (name, fn_type, ECF_LEAF | ECF_NOTHROW); 6959 mark_used (atexit_fndecl); 6960 pop_lang_context (); 6961 atexit_node = decay_conversion (atexit_fndecl, tf_warning_or_error); 6962 6963 return atexit_node; 6964} 6965 6966/* Like get_atexit_node, but for thread-local cleanups. */ 6967 6968static tree 6969get_thread_atexit_node (void) 6970{ 6971 /* The declaration for `__cxa_thread_atexit' is: 6972 6973 int __cxa_thread_atexit (void (*)(void *), void *, void *) */ 6974 tree fn_type = build_function_type_list (integer_type_node, 6975 get_atexit_fn_ptr_type (), 6976 ptr_type_node, ptr_type_node, 6977 NULL_TREE); 6978 6979 /* Now, build the function declaration. */ 6980 tree atexit_fndecl = build_library_fn_ptr ("__cxa_thread_atexit", fn_type, 6981 ECF_LEAF | ECF_NOTHROW); 6982 return decay_conversion (atexit_fndecl, tf_warning_or_error); 6983} 6984 6985/* Returns the __dso_handle VAR_DECL. */ 6986 6987static tree 6988get_dso_handle_node (void) 6989{ 6990 if (dso_handle_node) 6991 return dso_handle_node; 6992 6993 /* Declare the variable. */ 6994 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"), 6995 ptr_type_node); 6996 6997#ifdef HAVE_GAS_HIDDEN 6998 if (dso_handle_node != error_mark_node) 6999 { 7000 DECL_VISIBILITY (dso_handle_node) = VISIBILITY_HIDDEN; 7001 DECL_VISIBILITY_SPECIFIED (dso_handle_node) = 1; 7002 } 7003#endif 7004 7005 return dso_handle_node; 7006} 7007 7008/* Begin a new function with internal linkage whose job will be simply 7009 to destroy some particular variable. */ 7010 7011static GTY(()) int start_cleanup_cnt; 7012 7013static tree 7014start_cleanup_fn (void) 7015{ 7016 char name[32]; 7017 tree fntype; 7018 tree fndecl; 7019 bool use_cxa_atexit = flag_use_cxa_atexit 7020 && !targetm.cxx.use_atexit_for_cxa_atexit (); 7021 7022 push_to_top_level (); 7023 7024 /* No need to mangle this. */ 7025 push_lang_context (lang_name_c); 7026 7027 /* Build the name of the function. */ 7028 sprintf (name, "__tcf_%d", start_cleanup_cnt++); 7029 /* Build the function declaration. */ 7030 fntype = TREE_TYPE (get_atexit_fn_ptr_type ()); 7031 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype); 7032 /* It's a function with internal linkage, generated by the 7033 compiler. */ 7034 TREE_PUBLIC (fndecl) = 0; 7035 DECL_ARTIFICIAL (fndecl) = 1; 7036 /* Make the function `inline' so that it is only emitted if it is 7037 actually needed. It is unlikely that it will be inlined, since 7038 it is only called via a function pointer, but we avoid unnecessary 7039 emissions this way. */ 7040 DECL_DECLARED_INLINE_P (fndecl) = 1; 7041 DECL_INTERFACE_KNOWN (fndecl) = 1; 7042 /* Build the parameter. */ 7043 if (use_cxa_atexit) 7044 { 7045 tree parmdecl; 7046 7047 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node); 7048 DECL_CONTEXT (parmdecl) = fndecl; 7049 TREE_USED (parmdecl) = 1; 7050 DECL_READ_P (parmdecl) = 1; 7051 DECL_ARGUMENTS (fndecl) = parmdecl; 7052 } 7053 7054 pushdecl (fndecl); 7055 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED); 7056 7057 pop_lang_context (); 7058 7059 return current_function_decl; 7060} 7061 7062/* Finish the cleanup function begun by start_cleanup_fn. */ 7063 7064static void 7065end_cleanup_fn (void) 7066{ 7067 expand_or_defer_fn (finish_function (0)); 7068 7069 pop_from_top_level (); 7070} 7071 7072/* Generate code to handle the destruction of DECL, an object with 7073 static storage duration. */ 7074 7075tree 7076register_dtor_fn (tree decl) 7077{ 7078 tree cleanup; 7079 tree addr; 7080 tree compound_stmt; 7081 tree fcall; 7082 tree type; 7083 bool ob_parm, dso_parm, use_dtor; 7084 tree arg0, arg1, arg2; 7085 tree atex_node; 7086 7087 type = TREE_TYPE (decl); 7088 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type)) 7089 return void_node; 7090 7091 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or 7092 "__aeabi_atexit"), and DECL is a class object, we can just pass the 7093 destructor to "__cxa_atexit"; we don't have to build a temporary 7094 function to do the cleanup. */ 7095 dso_parm = (flag_use_cxa_atexit 7096 && !targetm.cxx.use_atexit_for_cxa_atexit ()); 7097 ob_parm = (DECL_THREAD_LOCAL_P (decl) || dso_parm); 7098 use_dtor = ob_parm && CLASS_TYPE_P (type); 7099 if (use_dtor) 7100 { 7101 int idx; 7102 7103 /* Find the destructor. */ 7104 idx = lookup_fnfields_1 (type, complete_dtor_identifier); 7105 gcc_assert (idx >= 0); 7106 cleanup = (*CLASSTYPE_METHOD_VEC (type))[idx]; 7107 /* Make sure it is accessible. */ 7108 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup, 7109 tf_warning_or_error); 7110 } 7111 else 7112 { 7113 /* Call build_cleanup before we enter the anonymous function so 7114 that any access checks will be done relative to the current 7115 scope, rather than the scope of the anonymous function. */ 7116 build_cleanup (decl); 7117 7118 /* Now start the function. */ 7119 cleanup = start_cleanup_fn (); 7120 7121 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer 7122 to the original function, rather than the anonymous one. That 7123 will make the back end think that nested functions are in use, 7124 which causes confusion. */ 7125 push_deferring_access_checks (dk_no_check); 7126 fcall = build_cleanup (decl); 7127 pop_deferring_access_checks (); 7128 7129 /* Create the body of the anonymous function. */ 7130 compound_stmt = begin_compound_stmt (BCS_FN_BODY); 7131 finish_expr_stmt (fcall); 7132 finish_compound_stmt (compound_stmt); 7133 end_cleanup_fn (); 7134 } 7135 7136 /* Call atexit with the cleanup function. */ 7137 mark_used (cleanup); 7138 cleanup = build_address (cleanup); 7139 7140 if (DECL_THREAD_LOCAL_P (decl)) 7141 atex_node = get_thread_atexit_node (); 7142 else 7143 atex_node = get_atexit_node (); 7144 7145 if (use_dtor) 7146 { 7147 /* We must convert CLEANUP to the type that "__cxa_atexit" 7148 expects. */ 7149 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup); 7150 /* "__cxa_atexit" will pass the address of DECL to the 7151 cleanup function. */ 7152 mark_used (decl); 7153 addr = build_address (decl); 7154 /* The declared type of the parameter to "__cxa_atexit" is 7155 "void *". For plain "T*", we could just let the 7156 machinery in cp_build_function_call convert it -- but if the 7157 type is "cv-qualified T *", then we need to convert it 7158 before passing it in, to avoid spurious errors. */ 7159 addr = build_nop (ptr_type_node, addr); 7160 } 7161 else 7162 /* Since the cleanup functions we build ignore the address 7163 they're given, there's no reason to pass the actual address 7164 in, and, in general, it's cheaper to pass NULL than any 7165 other value. */ 7166 addr = null_pointer_node; 7167 7168 if (dso_parm) 7169 arg2 = cp_build_addr_expr (get_dso_handle_node (), 7170 tf_warning_or_error); 7171 else if (ob_parm) 7172 /* Just pass NULL to the dso handle parm if we don't actually 7173 have a DSO handle on this target. */ 7174 arg2 = null_pointer_node; 7175 else 7176 arg2 = NULL_TREE; 7177 7178 if (ob_parm) 7179 { 7180 if (!DECL_THREAD_LOCAL_P (decl) 7181 && targetm.cxx.use_aeabi_atexit ()) 7182 { 7183 arg1 = cleanup; 7184 arg0 = addr; 7185 } 7186 else 7187 { 7188 arg1 = addr; 7189 arg0 = cleanup; 7190 } 7191 } 7192 else 7193 { 7194 arg0 = cleanup; 7195 arg1 = NULL_TREE; 7196 } 7197 return cp_build_function_call_nary (atex_node, tf_warning_or_error, 7198 arg0, arg1, arg2, NULL_TREE); 7199} 7200 7201/* DECL is a VAR_DECL with static storage duration. INIT, if present, 7202 is its initializer. Generate code to handle the construction 7203 and destruction of DECL. */ 7204 7205static void 7206expand_static_init (tree decl, tree init) 7207{ 7208 gcc_assert (VAR_P (decl)); 7209 gcc_assert (TREE_STATIC (decl)); 7210 7211 /* Some variables require no dynamic initialization. */ 7212 if (!init 7213 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) 7214 { 7215 /* Make sure the destructor is callable. */ 7216 cxx_maybe_build_cleanup (decl, tf_warning_or_error); 7217 return; 7218 } 7219 7220 if (DECL_THREAD_LOCAL_P (decl) && DECL_GNU_TLS_P (decl) 7221 && !DECL_FUNCTION_SCOPE_P (decl)) 7222 { 7223 if (init) 7224 error ("non-local variable %qD declared %<__thread%> " 7225 "needs dynamic initialization", decl); 7226 else 7227 error ("non-local variable %qD declared %<__thread%> " 7228 "has a non-trivial destructor", decl); 7229 static bool informed; 7230 if (!informed) 7231 { 7232 inform (DECL_SOURCE_LOCATION (decl), 7233 "C++11 %<thread_local%> allows dynamic initialization " 7234 "and destruction"); 7235 informed = true; 7236 } 7237 return; 7238 } 7239 7240 if (DECL_FUNCTION_SCOPE_P (decl)) 7241 { 7242 /* Emit code to perform this initialization but once. */ 7243 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE; 7244 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE; 7245 tree guard, guard_addr; 7246 tree flag, begin; 7247 /* We don't need thread-safety code for thread-local vars. */ 7248 bool thread_guard = (flag_threadsafe_statics 7249 && !DECL_THREAD_LOCAL_P (decl)); 7250 7251 /* Emit code to perform this initialization but once. This code 7252 looks like: 7253 7254 static <type> guard; 7255 if (!guard.first_byte) { 7256 if (__cxa_guard_acquire (&guard)) { 7257 bool flag = false; 7258 try { 7259 // Do initialization. 7260 flag = true; __cxa_guard_release (&guard); 7261 // Register variable for destruction at end of program. 7262 } catch { 7263 if (!flag) __cxa_guard_abort (&guard); 7264 } 7265 } 7266 7267 Note that the `flag' variable is only set to 1 *after* the 7268 initialization is complete. This ensures that an exception, 7269 thrown during the construction, will cause the variable to 7270 reinitialized when we pass through this code again, as per: 7271 7272 [stmt.dcl] 7273 7274 If the initialization exits by throwing an exception, the 7275 initialization is not complete, so it will be tried again 7276 the next time control enters the declaration. 7277 7278 This process should be thread-safe, too; multiple threads 7279 should not be able to initialize the variable more than 7280 once. */ 7281 7282 /* Create the guard variable. */ 7283 guard = get_guard (decl); 7284 7285 /* This optimization isn't safe on targets with relaxed memory 7286 consistency. On such targets we force synchronization in 7287 __cxa_guard_acquire. */ 7288 if (!targetm.relaxed_ordering || !thread_guard) 7289 { 7290 /* Begin the conditional initialization. */ 7291 if_stmt = begin_if_stmt (); 7292 finish_if_stmt_cond (get_guard_cond (guard), if_stmt); 7293 then_clause = begin_compound_stmt (BCS_NO_SCOPE); 7294 } 7295 7296 if (thread_guard) 7297 { 7298 tree vfntype = NULL_TREE; 7299 tree acquire_name, release_name, abort_name; 7300 tree acquire_fn, release_fn, abort_fn; 7301 guard_addr = build_address (guard); 7302 7303 acquire_name = get_identifier ("__cxa_guard_acquire"); 7304 release_name = get_identifier ("__cxa_guard_release"); 7305 abort_name = get_identifier ("__cxa_guard_abort"); 7306 acquire_fn = identifier_global_value (acquire_name); 7307 release_fn = identifier_global_value (release_name); 7308 abort_fn = identifier_global_value (abort_name); 7309 if (!acquire_fn) 7310 acquire_fn = push_library_fn 7311 (acquire_name, build_function_type_list (integer_type_node, 7312 TREE_TYPE (guard_addr), 7313 NULL_TREE), 7314 NULL_TREE, ECF_NOTHROW | ECF_LEAF); 7315 if (!release_fn || !abort_fn) 7316 vfntype = build_function_type_list (void_type_node, 7317 TREE_TYPE (guard_addr), 7318 NULL_TREE); 7319 if (!release_fn) 7320 release_fn = push_library_fn (release_name, vfntype, NULL_TREE, 7321 ECF_NOTHROW | ECF_LEAF); 7322 if (!abort_fn) 7323 abort_fn = push_library_fn (abort_name, vfntype, NULL_TREE, 7324 ECF_NOTHROW | ECF_LEAF); 7325 7326 inner_if_stmt = begin_if_stmt (); 7327 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr), 7328 inner_if_stmt); 7329 7330 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE); 7331 begin = get_target_expr (boolean_false_node); 7332 flag = TARGET_EXPR_SLOT (begin); 7333 7334 TARGET_EXPR_CLEANUP (begin) 7335 = build3 (COND_EXPR, void_type_node, flag, 7336 void_node, 7337 build_call_n (abort_fn, 1, guard_addr)); 7338 CLEANUP_EH_ONLY (begin) = 1; 7339 7340 /* Do the initialization itself. */ 7341 init = add_stmt_to_compound (begin, init); 7342 init = add_stmt_to_compound 7343 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node)); 7344 init = add_stmt_to_compound 7345 (init, build_call_n (release_fn, 1, guard_addr)); 7346 } 7347 else 7348 init = add_stmt_to_compound (init, set_guard (guard)); 7349 7350 /* Use atexit to register a function for destroying this static 7351 variable. */ 7352 init = add_stmt_to_compound (init, register_dtor_fn (decl)); 7353 7354 finish_expr_stmt (init); 7355 7356 if (thread_guard) 7357 { 7358 finish_compound_stmt (inner_then_clause); 7359 finish_then_clause (inner_if_stmt); 7360 finish_if_stmt (inner_if_stmt); 7361 } 7362 7363 if (!targetm.relaxed_ordering || !thread_guard) 7364 { 7365 finish_compound_stmt (then_clause); 7366 finish_then_clause (if_stmt); 7367 finish_if_stmt (if_stmt); 7368 } 7369 } 7370 else if (DECL_THREAD_LOCAL_P (decl)) 7371 tls_aggregates = tree_cons (init, decl, tls_aggregates); 7372 else 7373 static_aggregates = tree_cons (init, decl, static_aggregates); 7374} 7375 7376 7377/* Make TYPE a complete type based on INITIAL_VALUE. 7378 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered, 7379 2 if there was no information (in which case assume 0 if DO_DEFAULT), 7380 3 if the initializer list is empty (in pedantic mode). */ 7381 7382int 7383cp_complete_array_type (tree *ptype, tree initial_value, bool do_default) 7384{ 7385 int failure; 7386 tree type, elt_type; 7387 7388 /* Don't get confused by a CONSTRUCTOR for some other type. */ 7389 if (initial_value && TREE_CODE (initial_value) == CONSTRUCTOR 7390 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value) 7391 && TREE_CODE (TREE_TYPE (initial_value)) != ARRAY_TYPE) 7392 return 1; 7393 7394 if (initial_value) 7395 { 7396 unsigned HOST_WIDE_INT i; 7397 tree value; 7398 7399 /* An array of character type can be initialized from a 7400 brace-enclosed string constant. 7401 7402 FIXME: this code is duplicated from reshape_init. Probably 7403 we should just call reshape_init here? */ 7404 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype))) 7405 && TREE_CODE (initial_value) == CONSTRUCTOR 7406 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value))) 7407 { 7408 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initial_value); 7409 tree value = (*v)[0].value; 7410 7411 if (TREE_CODE (value) == STRING_CST 7412 && v->length () == 1) 7413 initial_value = value; 7414 } 7415 7416 /* If any of the elements are parameter packs, we can't actually 7417 complete this type now because the array size is dependent. */ 7418 if (TREE_CODE (initial_value) == CONSTRUCTOR) 7419 { 7420 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value), 7421 i, value) 7422 { 7423 if (PACK_EXPANSION_P (value)) 7424 return 0; 7425 } 7426 } 7427 } 7428 7429 failure = complete_array_type (ptype, initial_value, do_default); 7430 7431 /* We can create the array before the element type is complete, which 7432 means that we didn't have these two bits set in the original type 7433 either. In completing the type, we are expected to propagate these 7434 bits. See also complete_type which does the same thing for arrays 7435 of fixed size. */ 7436 type = *ptype; 7437 if (TYPE_DOMAIN (type)) 7438 { 7439 elt_type = TREE_TYPE (type); 7440 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type); 7441 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) 7442 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type); 7443 } 7444 7445 return failure; 7446} 7447 7448/* As above, but either give an error or reject zero-size arrays, depending 7449 on COMPLAIN. */ 7450 7451int 7452cp_complete_array_type_or_error (tree *ptype, tree initial_value, 7453 bool do_default, tsubst_flags_t complain) 7454{ 7455 int failure; 7456 bool sfinae = !(complain & tf_error); 7457 /* In SFINAE context we can't be lenient about zero-size arrays. */ 7458 if (sfinae) 7459 ++pedantic; 7460 failure = cp_complete_array_type (ptype, initial_value, do_default); 7461 if (sfinae) 7462 --pedantic; 7463 if (failure) 7464 { 7465 if (sfinae) 7466 /* Not an error. */; 7467 else if (failure == 1) 7468 error ("initializer fails to determine size of %qT", *ptype); 7469 else if (failure == 2) 7470 { 7471 if (do_default) 7472 error ("array size missing in %qT", *ptype); 7473 } 7474 else if (failure == 3) 7475 error ("zero-size array %qT", *ptype); 7476 *ptype = error_mark_node; 7477 } 7478 return failure; 7479} 7480 7481/* Return zero if something is declared to be a member of type 7482 CTYPE when in the context of CUR_TYPE. STRING is the error 7483 message to print in that case. Otherwise, quietly return 1. */ 7484 7485static int 7486member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags) 7487{ 7488 if (ctype && ctype != cur_type) 7489 { 7490 if (flags == DTOR_FLAG) 7491 error ("destructor for alien class %qT cannot be a member", ctype); 7492 else 7493 error ("constructor for alien class %qT cannot be a member", ctype); 7494 return 0; 7495 } 7496 return 1; 7497} 7498 7499/* Subroutine of `grokdeclarator'. */ 7500 7501/* Generate errors possibly applicable for a given set of specifiers. 7502 This is for ARM $7.1.2. */ 7503 7504static void 7505bad_specifiers (tree object, 7506 enum bad_spec_place type, 7507 int virtualp, 7508 int quals, 7509 int inlinep, 7510 int friendp, 7511 int raises) 7512{ 7513 switch (type) 7514 { 7515 case BSP_VAR: 7516 if (virtualp) 7517 error ("%qD declared as a %<virtual%> variable", object); 7518 if (inlinep) 7519 error ("%qD declared as an %<inline%> variable", object); 7520 if (quals) 7521 error ("%<const%> and %<volatile%> function specifiers on " 7522 "%qD invalid in variable declaration", object); 7523 break; 7524 case BSP_PARM: 7525 if (virtualp) 7526 error ("%qD declared as a %<virtual%> parameter", object); 7527 if (inlinep) 7528 error ("%qD declared as an %<inline%> parameter", object); 7529 if (quals) 7530 error ("%<const%> and %<volatile%> function specifiers on " 7531 "%qD invalid in parameter declaration", object); 7532 break; 7533 case BSP_TYPE: 7534 if (virtualp) 7535 error ("%qD declared as a %<virtual%> type", object); 7536 if (inlinep) 7537 error ("%qD declared as an %<inline%> type", object); 7538 if (quals) 7539 error ("%<const%> and %<volatile%> function specifiers on " 7540 "%qD invalid in type declaration", object); 7541 break; 7542 case BSP_FIELD: 7543 if (virtualp) 7544 error ("%qD declared as a %<virtual%> field", object); 7545 if (inlinep) 7546 error ("%qD declared as an %<inline%> field", object); 7547 if (quals) 7548 error ("%<const%> and %<volatile%> function specifiers on " 7549 "%qD invalid in field declaration", object); 7550 break; 7551 default: 7552 gcc_unreachable(); 7553 } 7554 if (friendp) 7555 error ("%q+D declared as a friend", object); 7556 if (raises 7557 && (TREE_CODE (object) == TYPE_DECL 7558 || (!TYPE_PTRFN_P (TREE_TYPE (object)) 7559 && !TYPE_REFFN_P (TREE_TYPE (object)) 7560 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object))))) 7561 error ("%q+D declared with an exception specification", object); 7562} 7563 7564/* DECL is a member function or static data member and is presently 7565 being defined. Check that the definition is taking place in a 7566 valid namespace. */ 7567 7568static void 7569check_class_member_definition_namespace (tree decl) 7570{ 7571 /* These checks only apply to member functions and static data 7572 members. */ 7573 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl)); 7574 /* We check for problems with specializations in pt.c in 7575 check_specialization_namespace, where we can issue better 7576 diagnostics. */ 7577 if (processing_specialization) 7578 return; 7579 /* There are no restrictions on the placement of 7580 explicit instantiations. */ 7581 if (processing_explicit_instantiation) 7582 return; 7583 /* [class.mfct] 7584 7585 A member function definition that appears outside of the 7586 class definition shall appear in a namespace scope enclosing 7587 the class definition. 7588 7589 [class.static.data] 7590 7591 The definition for a static data member shall appear in a 7592 namespace scope enclosing the member's class definition. */ 7593 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl))) 7594 permerror (input_location, "definition of %qD is not in namespace enclosing %qT", 7595 decl, DECL_CONTEXT (decl)); 7596} 7597 7598/* Build a PARM_DECL for the "this" parameter. TYPE is the 7599 METHOD_TYPE for a non-static member function; QUALS are the 7600 cv-qualifiers that apply to the function. */ 7601 7602tree 7603build_this_parm (tree type, cp_cv_quals quals) 7604{ 7605 tree this_type; 7606 tree qual_type; 7607 tree parm; 7608 cp_cv_quals this_quals; 7609 7610 if (CLASS_TYPE_P (type)) 7611 { 7612 this_type 7613 = cp_build_qualified_type (type, quals & ~TYPE_QUAL_RESTRICT); 7614 this_type = build_pointer_type (this_type); 7615 } 7616 else 7617 this_type = type_of_this_parm (type); 7618 /* The `this' parameter is implicitly `const'; it cannot be 7619 assigned to. */ 7620 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST; 7621 qual_type = cp_build_qualified_type (this_type, this_quals); 7622 parm = build_artificial_parm (this_identifier, qual_type); 7623 cp_apply_type_quals_to_decl (this_quals, parm); 7624 return parm; 7625} 7626 7627/* DECL is a static member function. Complain if it was declared 7628 with function-cv-quals. */ 7629 7630static void 7631check_static_quals (tree decl, cp_cv_quals quals) 7632{ 7633 if (quals != TYPE_UNQUALIFIED) 7634 error ("static member function %q#D declared with type qualifiers", 7635 decl); 7636} 7637 7638/* Helper function. Replace the temporary this parameter injected 7639 during cp_finish_omp_declare_simd with the real this parameter. */ 7640 7641static tree 7642declare_simd_adjust_this (tree *tp, int *walk_subtrees, void *data) 7643{ 7644 tree this_parm = (tree) data; 7645 if (TREE_CODE (*tp) == PARM_DECL 7646 && DECL_NAME (*tp) == this_identifier 7647 && *tp != this_parm) 7648 *tp = this_parm; 7649 else if (TYPE_P (*tp)) 7650 *walk_subtrees = 0; 7651 return NULL_TREE; 7652} 7653 7654/* CTYPE is class type, or null if non-class. 7655 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE 7656 or METHOD_TYPE. 7657 DECLARATOR is the function's name. 7658 PARMS is a chain of PARM_DECLs for the function. 7659 VIRTUALP is truthvalue of whether the function is virtual or not. 7660 FLAGS are to be passed through to `grokclassfn'. 7661 QUALS are qualifiers indicating whether the function is `const' 7662 or `volatile'. 7663 RAISES is a list of exceptions that this function can raise. 7664 CHECK is 1 if we must find this method in CTYPE, 0 if we should 7665 not look, and -1 if we should not call `grokclassfn' at all. 7666 7667 SFK is the kind of special function (if any) for the new function. 7668 7669 Returns `NULL_TREE' if something goes wrong, after issuing 7670 applicable error messages. */ 7671 7672static tree 7673grokfndecl (tree ctype, 7674 tree type, 7675 tree declarator, 7676 tree parms, 7677 tree orig_declarator, 7678 int virtualp, 7679 enum overload_flags flags, 7680 cp_cv_quals quals, 7681 cp_ref_qualifier rqual, 7682 tree raises, 7683 int check, 7684 int friendp, 7685 int publicp, 7686 int inlinep, 7687 bool deletedp, 7688 special_function_kind sfk, 7689 bool funcdef_flag, 7690 int template_count, 7691 tree in_namespace, 7692 tree* attrlist, 7693 location_t location) 7694{ 7695 tree decl; 7696 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE; 7697 tree t; 7698 7699 if (rqual) 7700 type = build_ref_qualified_type (type, rqual); 7701 if (raises) 7702 type = build_exception_variant (type, raises); 7703 7704 decl = build_lang_decl (FUNCTION_DECL, declarator, type); 7705 7706 /* If we have an explicit location, use it, otherwise use whatever 7707 build_lang_decl used (probably input_location). */ 7708 if (location != UNKNOWN_LOCATION) 7709 DECL_SOURCE_LOCATION (decl) = location; 7710 7711 if (TREE_CODE (type) == METHOD_TYPE) 7712 { 7713 tree parm; 7714 parm = build_this_parm (type, quals); 7715 DECL_CHAIN (parm) = parms; 7716 parms = parm; 7717 } 7718 DECL_ARGUMENTS (decl) = parms; 7719 for (t = parms; t; t = DECL_CHAIN (t)) 7720 DECL_CONTEXT (t) = decl; 7721 /* Propagate volatile out from type to decl. */ 7722 if (TYPE_VOLATILE (type)) 7723 TREE_THIS_VOLATILE (decl) = 1; 7724 7725 /* Setup decl according to sfk. */ 7726 switch (sfk) 7727 { 7728 case sfk_constructor: 7729 case sfk_copy_constructor: 7730 case sfk_move_constructor: 7731 DECL_CONSTRUCTOR_P (decl) = 1; 7732 break; 7733 case sfk_destructor: 7734 DECL_DESTRUCTOR_P (decl) = 1; 7735 break; 7736 default: 7737 break; 7738 } 7739 7740 /* If pointers to member functions use the least significant bit to 7741 indicate whether a function is virtual, ensure a pointer 7742 to this function will have that bit clear. */ 7743 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn 7744 && TREE_CODE (type) == METHOD_TYPE 7745 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT) 7746 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT; 7747 7748 if (friendp 7749 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR) 7750 { 7751 if (funcdef_flag) 7752 error 7753 ("defining explicit specialization %qD in friend declaration", 7754 orig_declarator); 7755 else 7756 { 7757 tree fns = TREE_OPERAND (orig_declarator, 0); 7758 tree args = TREE_OPERAND (orig_declarator, 1); 7759 7760 if (PROCESSING_REAL_TEMPLATE_DECL_P ()) 7761 { 7762 /* Something like `template <class T> friend void f<T>()'. */ 7763 error ("invalid use of template-id %qD in declaration " 7764 "of primary template", 7765 orig_declarator); 7766 return NULL_TREE; 7767 } 7768 7769 7770 /* A friend declaration of the form friend void f<>(). Record 7771 the information in the TEMPLATE_ID_EXPR. */ 7772 SET_DECL_IMPLICIT_INSTANTIATION (decl); 7773 7774 gcc_assert (identifier_p (fns) || TREE_CODE (fns) == OVERLOAD); 7775 DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args); 7776 7777 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t)) 7778 if (TREE_PURPOSE (t) 7779 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG) 7780 { 7781 error ("default arguments are not allowed in declaration " 7782 "of friend template specialization %qD", 7783 decl); 7784 return NULL_TREE; 7785 } 7786 7787 if (inlinep & 1) 7788 error ("%<inline%> is not allowed in declaration of friend " 7789 "template specialization %qD", 7790 decl); 7791 if (inlinep & 2) 7792 error ("%<constexpr%> is not allowed in declaration of friend " 7793 "template specialization %qD", 7794 decl); 7795 if (inlinep) 7796 return NULL_TREE; 7797 } 7798 } 7799 7800 /* If this decl has namespace scope, set that up. */ 7801 if (in_namespace) 7802 set_decl_namespace (decl, in_namespace, friendp); 7803 else if (!ctype) 7804 DECL_CONTEXT (decl) = FROB_CONTEXT (current_decl_namespace ()); 7805 7806 /* `main' and builtins have implicit 'C' linkage. */ 7807 if ((MAIN_NAME_P (declarator) 7808 || (IDENTIFIER_LENGTH (declarator) > 10 7809 && IDENTIFIER_POINTER (declarator)[0] == '_' 7810 && IDENTIFIER_POINTER (declarator)[1] == '_' 7811 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0) 7812 || (targetcm.cxx_implicit_extern_c 7813 && targetcm.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator)))) 7814 && current_lang_name == lang_name_cplusplus 7815 && ctype == NULL_TREE 7816 && DECL_FILE_SCOPE_P (decl)) 7817 SET_DECL_LANGUAGE (decl, lang_c); 7818 7819 /* Should probably propagate const out from type to decl I bet (mrs). */ 7820 if (staticp) 7821 { 7822 DECL_STATIC_FUNCTION_P (decl) = 1; 7823 DECL_CONTEXT (decl) = ctype; 7824 } 7825 7826 if (deletedp) 7827 DECL_DELETED_FN (decl) = 1; 7828 7829 if (ctype) 7830 { 7831 DECL_CONTEXT (decl) = ctype; 7832 if (funcdef_flag) 7833 check_class_member_definition_namespace (decl); 7834 } 7835 7836 if (ctype == NULL_TREE && DECL_MAIN_P (decl)) 7837 { 7838 if (PROCESSING_REAL_TEMPLATE_DECL_P()) 7839 error ("cannot declare %<::main%> to be a template"); 7840 if (inlinep & 1) 7841 error ("cannot declare %<::main%> to be inline"); 7842 if (inlinep & 2) 7843 error ("cannot declare %<::main%> to be constexpr"); 7844 if (!publicp) 7845 error ("cannot declare %<::main%> to be static"); 7846 inlinep = 0; 7847 publicp = 1; 7848 } 7849 7850 /* Members of anonymous types and local classes have no linkage; make 7851 them internal. If a typedef is made later, this will be changed. */ 7852 if (ctype && (TYPE_ANONYMOUS_P (ctype) 7853 || decl_function_context (TYPE_MAIN_DECL (ctype)))) 7854 publicp = 0; 7855 7856 if (publicp && cxx_dialect == cxx98) 7857 { 7858 /* [basic.link]: A name with no linkage (notably, the name of a class 7859 or enumeration declared in a local scope) shall not be used to 7860 declare an entity with linkage. 7861 7862 DR 757 relaxes this restriction for C++0x. */ 7863 no_linkage_error (decl); 7864 } 7865 7866 TREE_PUBLIC (decl) = publicp; 7867 if (! publicp) 7868 { 7869 DECL_INTERFACE_KNOWN (decl) = 1; 7870 DECL_NOT_REALLY_EXTERN (decl) = 1; 7871 } 7872 7873 /* If the declaration was declared inline, mark it as such. */ 7874 if (inlinep) 7875 { 7876 DECL_DECLARED_INLINE_P (decl) = 1; 7877 if (publicp) 7878 DECL_COMDAT (decl) = 1; 7879 } 7880 if (inlinep & 2) 7881 DECL_DECLARED_CONSTEXPR_P (decl) = true; 7882 7883 DECL_EXTERNAL (decl) = 1; 7884 if (TREE_CODE (type) == FUNCTION_TYPE) 7885 { 7886 if (quals) 7887 { 7888 error (ctype 7889 ? G_("static member function %qD cannot have cv-qualifier") 7890 : G_("non-member function %qD cannot have cv-qualifier"), 7891 decl); 7892 quals = TYPE_UNQUALIFIED; 7893 } 7894 7895 if (rqual) 7896 { 7897 error (ctype 7898 ? G_("static member function %qD cannot have ref-qualifier") 7899 : G_("non-member function %qD cannot have ref-qualifier"), 7900 decl); 7901 rqual = REF_QUAL_NONE; 7902 } 7903 } 7904 7905 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)) 7906 && !grok_op_properties (decl, /*complain=*/true)) 7907 return NULL_TREE; 7908 else if (UDLIT_OPER_P (DECL_NAME (decl))) 7909 { 7910 bool long_long_unsigned_p; 7911 bool long_double_p; 7912 const char *suffix = NULL; 7913 /* [over.literal]/6: Literal operators shall not have C linkage. */ 7914 if (DECL_LANGUAGE (decl) == lang_c) 7915 { 7916 error ("literal operator with C linkage"); 7917 return NULL_TREE; 7918 } 7919 7920 if (DECL_NAMESPACE_SCOPE_P (decl)) 7921 { 7922 if (!check_literal_operator_args (decl, &long_long_unsigned_p, 7923 &long_double_p)) 7924 { 7925 error ("%qD has invalid argument list", decl); 7926 return NULL_TREE; 7927 } 7928 7929 suffix = UDLIT_OP_SUFFIX (DECL_NAME (decl)); 7930 if (long_long_unsigned_p) 7931 { 7932 if (cpp_interpret_int_suffix (parse_in, suffix, strlen (suffix))) 7933 warning (0, "integer suffix %<%s%>" 7934 " shadowed by implementation", suffix); 7935 } 7936 else if (long_double_p) 7937 { 7938 if (cpp_interpret_float_suffix (parse_in, suffix, strlen (suffix))) 7939 warning (0, "floating point suffix %<%s%>" 7940 " shadowed by implementation", suffix); 7941 } 7942 } 7943 else 7944 { 7945 error ("%qD must be a non-member function", decl); 7946 return NULL_TREE; 7947 } 7948 } 7949 7950 if (funcdef_flag) 7951 /* Make the init_value nonzero so pushdecl knows this is not 7952 tentative. error_mark_node is replaced later with the BLOCK. */ 7953 DECL_INITIAL (decl) = error_mark_node; 7954 7955 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl)) 7956 TREE_NOTHROW (decl) = 1; 7957 7958 if (flag_openmp || flag_openmp_simd || flag_cilkplus) 7959 { 7960 /* Adjust "omp declare simd" attributes. */ 7961 tree ods = lookup_attribute ("omp declare simd", *attrlist); 7962 if (ods) 7963 { 7964 tree attr; 7965 for (attr = ods; attr; 7966 attr = lookup_attribute ("omp declare simd", TREE_CHAIN (attr))) 7967 { 7968 if (TREE_CODE (type) == METHOD_TYPE) 7969 walk_tree (&TREE_VALUE (attr), declare_simd_adjust_this, 7970 DECL_ARGUMENTS (decl), NULL); 7971 if (TREE_VALUE (attr) != NULL_TREE) 7972 { 7973 tree cl = TREE_VALUE (TREE_VALUE (attr)); 7974 cl = c_omp_declare_simd_clauses_to_numbers 7975 (DECL_ARGUMENTS (decl), cl); 7976 if (cl) 7977 TREE_VALUE (TREE_VALUE (attr)) = cl; 7978 else 7979 TREE_VALUE (attr) = NULL_TREE; 7980 } 7981 } 7982 } 7983 } 7984 7985 /* Caller will do the rest of this. */ 7986 if (check < 0) 7987 return decl; 7988 7989 if (ctype != NULL_TREE) 7990 grokclassfn (ctype, decl, flags); 7991 7992 /* 12.4/3 */ 7993 if (cxx_dialect >= cxx11 7994 && DECL_DESTRUCTOR_P (decl) 7995 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl)) 7996 && !processing_template_decl) 7997 deduce_noexcept_on_destructor (decl); 7998 7999 decl = check_explicit_specialization (orig_declarator, decl, 8000 template_count, 8001 2 * funcdef_flag + 8002 4 * (friendp != 0)); 8003 if (decl == error_mark_node) 8004 return NULL_TREE; 8005 8006 if (DECL_STATIC_FUNCTION_P (decl)) 8007 check_static_quals (decl, quals); 8008 8009 if (attrlist) 8010 { 8011 cplus_decl_attributes (&decl, *attrlist, 0); 8012 *attrlist = NULL_TREE; 8013 } 8014 8015 /* Check main's type after attributes have been applied. */ 8016 if (ctype == NULL_TREE && DECL_MAIN_P (decl)) 8017 { 8018 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)), 8019 integer_type_node)) 8020 { 8021 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl)); 8022 tree newtype; 8023 error ("%<::main%> must return %<int%>"); 8024 newtype = build_function_type (integer_type_node, oldtypeargs); 8025 TREE_TYPE (decl) = newtype; 8026 } 8027 if (warn_main) 8028 check_main_parameter_types (decl); 8029 } 8030 8031 if (ctype != NULL_TREE 8032 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl)) 8033 && check) 8034 { 8035 tree old_decl = check_classfn (ctype, decl, 8036 (processing_template_decl 8037 > template_class_depth (ctype)) 8038 ? current_template_parms 8039 : NULL_TREE); 8040 8041 if (old_decl == error_mark_node) 8042 return NULL_TREE; 8043 8044 if (old_decl) 8045 { 8046 tree ok; 8047 tree pushed_scope; 8048 8049 if (TREE_CODE (old_decl) == TEMPLATE_DECL) 8050 /* Because grokfndecl is always supposed to return a 8051 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT 8052 here. We depend on our callers to figure out that its 8053 really a template that's being returned. */ 8054 old_decl = DECL_TEMPLATE_RESULT (old_decl); 8055 8056 if (DECL_STATIC_FUNCTION_P (old_decl) 8057 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) 8058 { 8059 /* Remove the `this' parm added by grokclassfn. */ 8060 revert_static_member_fn (decl); 8061 check_static_quals (decl, quals); 8062 } 8063 if (DECL_ARTIFICIAL (old_decl)) 8064 { 8065 error ("definition of implicitly-declared %qD", old_decl); 8066 return NULL_TREE; 8067 } 8068 else if (DECL_DEFAULTED_FN (old_decl)) 8069 { 8070 error ("definition of explicitly-defaulted %q+D", decl); 8071 error ("%q+#D explicitly defaulted here", old_decl); 8072 return NULL_TREE; 8073 } 8074 8075 /* Since we've smashed OLD_DECL to its 8076 DECL_TEMPLATE_RESULT, we must do the same to DECL. */ 8077 if (TREE_CODE (decl) == TEMPLATE_DECL) 8078 decl = DECL_TEMPLATE_RESULT (decl); 8079 8080 /* Attempt to merge the declarations. This can fail, in 8081 the case of some invalid specialization declarations. */ 8082 pushed_scope = push_scope (ctype); 8083 ok = duplicate_decls (decl, old_decl, friendp); 8084 if (pushed_scope) 8085 pop_scope (pushed_scope); 8086 if (!ok) 8087 { 8088 error ("no %q#D member function declared in class %qT", 8089 decl, ctype); 8090 return NULL_TREE; 8091 } 8092 if (ok == error_mark_node) 8093 return NULL_TREE; 8094 return old_decl; 8095 } 8096 } 8097 8098 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl)) 8099 return NULL_TREE; 8100 8101 if (ctype == NULL_TREE || check) 8102 return decl; 8103 8104 if (virtualp) 8105 DECL_VIRTUAL_P (decl) = 1; 8106 8107 return decl; 8108} 8109 8110/* decl is a FUNCTION_DECL. 8111 specifiers are the parsed virt-specifiers. 8112 8113 Set flags to reflect the virt-specifiers. 8114 8115 Returns decl. */ 8116 8117static tree 8118set_virt_specifiers (tree decl, cp_virt_specifiers specifiers) 8119{ 8120 if (decl == NULL_TREE) 8121 return decl; 8122 if (specifiers & VIRT_SPEC_OVERRIDE) 8123 DECL_OVERRIDE_P (decl) = 1; 8124 if (specifiers & VIRT_SPEC_FINAL) 8125 DECL_FINAL_P (decl) = 1; 8126 return decl; 8127} 8128 8129/* DECL is a VAR_DECL for a static data member. Set flags to reflect 8130 the linkage that DECL will receive in the object file. */ 8131 8132static void 8133set_linkage_for_static_data_member (tree decl) 8134{ 8135 /* A static data member always has static storage duration and 8136 external linkage. Note that static data members are forbidden in 8137 local classes -- the only situation in which a class has 8138 non-external linkage. */ 8139 TREE_PUBLIC (decl) = 1; 8140 TREE_STATIC (decl) = 1; 8141 /* For non-template classes, static data members are always put 8142 out in exactly those files where they are defined, just as 8143 with ordinary namespace-scope variables. */ 8144 if (!processing_template_decl) 8145 DECL_INTERFACE_KNOWN (decl) = 1; 8146} 8147 8148/* Create a VAR_DECL named NAME with the indicated TYPE. 8149 8150 If SCOPE is non-NULL, it is the class type or namespace containing 8151 the variable. If SCOPE is NULL, the variable should is created in 8152 the innermost enclosing scope. */ 8153 8154static tree 8155grokvardecl (tree type, 8156 tree name, 8157 tree orig_declarator, 8158 const cp_decl_specifier_seq *declspecs, 8159 int initialized, 8160 int constp, 8161 int template_count, 8162 tree scope) 8163{ 8164 tree decl; 8165 tree explicit_scope; 8166 8167 gcc_assert (!name || identifier_p (name)); 8168 8169 /* Compute the scope in which to place the variable, but remember 8170 whether or not that scope was explicitly specified by the user. */ 8171 explicit_scope = scope; 8172 if (!scope) 8173 { 8174 /* An explicit "extern" specifier indicates a namespace-scope 8175 variable. */ 8176 if (declspecs->storage_class == sc_extern) 8177 scope = current_decl_namespace (); 8178 else if (!at_function_scope_p ()) 8179 scope = current_scope (); 8180 } 8181 8182 if (scope 8183 && (/* If the variable is a namespace-scope variable declared in a 8184 template, we need DECL_LANG_SPECIFIC. */ 8185 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl) 8186 /* Similarly for namespace-scope variables with language linkage 8187 other than C++. */ 8188 || (TREE_CODE (scope) == NAMESPACE_DECL 8189 && current_lang_name != lang_name_cplusplus) 8190 /* Similarly for static data members. */ 8191 || TYPE_P (scope) 8192 /* Similarly for explicit specializations. */ 8193 || (orig_declarator 8194 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR))) 8195 decl = build_lang_decl (VAR_DECL, name, type); 8196 else 8197 decl = build_decl (input_location, VAR_DECL, name, type); 8198 8199 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL) 8200 set_decl_namespace (decl, explicit_scope, 0); 8201 else 8202 DECL_CONTEXT (decl) = FROB_CONTEXT (scope); 8203 8204 if (declspecs->storage_class == sc_extern) 8205 { 8206 DECL_THIS_EXTERN (decl) = 1; 8207 DECL_EXTERNAL (decl) = !initialized; 8208 } 8209 8210 if (DECL_CLASS_SCOPE_P (decl)) 8211 { 8212 set_linkage_for_static_data_member (decl); 8213 /* This function is only called with out-of-class definitions. */ 8214 DECL_EXTERNAL (decl) = 0; 8215 check_class_member_definition_namespace (decl); 8216 } 8217 /* At top level, either `static' or no s.c. makes a definition 8218 (perhaps tentative), and absence of `static' makes it public. */ 8219 else if (toplevel_bindings_p ()) 8220 { 8221 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static 8222 && (DECL_THIS_EXTERN (decl) || ! constp)); 8223 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl); 8224 } 8225 /* Not at top level, only `static' makes a static definition. */ 8226 else 8227 { 8228 TREE_STATIC (decl) = declspecs->storage_class == sc_static; 8229 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl); 8230 } 8231 8232 if (decl_spec_seq_has_spec_p (declspecs, ds_thread)) 8233 { 8234 if (DECL_EXTERNAL (decl) || TREE_STATIC (decl)) 8235 set_decl_tls_model (decl, decl_default_tls_model (decl)); 8236 if (declspecs->gnu_thread_keyword_p) 8237 DECL_GNU_TLS_P (decl) = true; 8238 } 8239 8240 /* If the type of the decl has no linkage, make sure that we'll 8241 notice that in mark_used. */ 8242 if (cxx_dialect > cxx98 8243 && decl_linkage (decl) != lk_none 8244 && DECL_LANG_SPECIFIC (decl) == NULL 8245 && !DECL_EXTERN_C_P (decl) 8246 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false)) 8247 retrofit_lang_decl (decl); 8248 8249 if (TREE_PUBLIC (decl)) 8250 { 8251 /* [basic.link]: A name with no linkage (notably, the name of a class 8252 or enumeration declared in a local scope) shall not be used to 8253 declare an entity with linkage. 8254 8255 DR 757 relaxes this restriction for C++0x. */ 8256 if (cxx_dialect < cxx11) 8257 no_linkage_error (decl); 8258 } 8259 else 8260 DECL_INTERFACE_KNOWN (decl) = 1; 8261 8262 // Handle explicit specializations and instantiations of variable templates. 8263 if (orig_declarator 8264 /* For GCC 5 fix 65646 this way. */ 8265 && current_tmpl_spec_kind (template_count) != tsk_none) 8266 decl = check_explicit_specialization (orig_declarator, decl, 8267 template_count, 0); 8268 8269 return decl != error_mark_node ? decl : NULL_TREE; 8270} 8271 8272/* Create and return a canonical pointer to member function type, for 8273 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */ 8274 8275tree 8276build_ptrmemfunc_type (tree type) 8277{ 8278 tree field, fields; 8279 tree t; 8280 8281 if (type == error_mark_node) 8282 return type; 8283 8284 /* Make sure that we always have the unqualified pointer-to-member 8285 type first. */ 8286 if (cp_cv_quals quals = cp_type_quals (type)) 8287 { 8288 tree unqual = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type)); 8289 return cp_build_qualified_type (unqual, quals); 8290 } 8291 8292 /* If a canonical type already exists for this type, use it. We use 8293 this method instead of type_hash_canon, because it only does a 8294 simple equality check on the list of field members. */ 8295 8296 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type))) 8297 return t; 8298 8299 t = make_node (RECORD_TYPE); 8300 8301 /* Let the front end know this is a pointer to member function. */ 8302 TYPE_PTRMEMFUNC_FLAG (t) = 1; 8303 8304 field = build_decl (input_location, FIELD_DECL, pfn_identifier, type); 8305 fields = field; 8306 8307 field = build_decl (input_location, FIELD_DECL, delta_identifier, 8308 delta_type_node); 8309 DECL_CHAIN (field) = fields; 8310 fields = field; 8311 8312 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node); 8313 8314 /* Zap out the name so that the back end will give us the debugging 8315 information for this anonymous RECORD_TYPE. */ 8316 TYPE_NAME (t) = NULL_TREE; 8317 8318 /* Cache this pointer-to-member type so that we can find it again 8319 later. */ 8320 TYPE_SET_PTRMEMFUNC_TYPE (type, t); 8321 8322 if (TYPE_STRUCTURAL_EQUALITY_P (type)) 8323 SET_TYPE_STRUCTURAL_EQUALITY (t); 8324 else if (TYPE_CANONICAL (type) != type) 8325 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type)); 8326 8327 return t; 8328} 8329 8330/* Create and return a pointer to data member type. */ 8331 8332tree 8333build_ptrmem_type (tree class_type, tree member_type) 8334{ 8335 if (TREE_CODE (member_type) == METHOD_TYPE) 8336 { 8337 cp_cv_quals quals = type_memfn_quals (member_type); 8338 cp_ref_qualifier rqual = type_memfn_rqual (member_type); 8339 member_type = build_memfn_type (member_type, class_type, quals, rqual); 8340 return build_ptrmemfunc_type (build_pointer_type (member_type)); 8341 } 8342 else 8343 { 8344 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE); 8345 return build_offset_type (class_type, member_type); 8346 } 8347} 8348 8349/* DECL is a VAR_DECL defined in-class, whose TYPE is also given. 8350 Check to see that the definition is valid. Issue appropriate error 8351 messages. Return 1 if the definition is particularly bad, or 0 8352 otherwise. */ 8353 8354static int 8355check_static_variable_definition (tree decl, tree type) 8356{ 8357 /* Can't check yet if we don't know the type. */ 8358 if (dependent_type_p (type)) 8359 return 0; 8360 /* If DECL is declared constexpr, we'll do the appropriate checks 8361 in check_initializer. */ 8362 if (DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl)) 8363 return 0; 8364 else if (cxx_dialect >= cxx11 && !INTEGRAL_OR_ENUMERATION_TYPE_P (type)) 8365 { 8366 if (!COMPLETE_TYPE_P (type)) 8367 error ("in-class initialization of static data member %q#D of " 8368 "incomplete type", decl); 8369 else if (literal_type_p (type)) 8370 permerror (input_location, 8371 "%<constexpr%> needed for in-class initialization of " 8372 "static data member %q#D of non-integral type", decl); 8373 else 8374 error ("in-class initialization of static data member %q#D of " 8375 "non-literal type", decl); 8376 return 1; 8377 } 8378 8379 /* Motion 10 at San Diego: If a static const integral data member is 8380 initialized with an integral constant expression, the initializer 8381 may appear either in the declaration (within the class), or in 8382 the definition, but not both. If it appears in the class, the 8383 member is a member constant. The file-scope definition is always 8384 required. */ 8385 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE) 8386 { 8387 error ("invalid in-class initialization of static data member " 8388 "of non-integral type %qT", 8389 type); 8390 return 1; 8391 } 8392 else if (!CP_TYPE_CONST_P (type)) 8393 error ("ISO C++ forbids in-class initialization of non-const " 8394 "static member %qD", 8395 decl); 8396 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type)) 8397 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids initialization of member constant " 8398 "%qD of non-integral type %qT", decl, type); 8399 8400 return 0; 8401} 8402 8403/* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any 8404 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those 8405 expressions out into temporary variables so that walk_tree doesn't 8406 step into them (c++/15764). */ 8407 8408static tree 8409stabilize_save_expr_r (tree *expr_p, int *walk_subtrees, void *data) 8410{ 8411 hash_set<tree> *pset = (hash_set<tree> *)data; 8412 tree expr = *expr_p; 8413 if (TREE_CODE (expr) == SAVE_EXPR) 8414 { 8415 tree op = TREE_OPERAND (expr, 0); 8416 cp_walk_tree (&op, stabilize_save_expr_r, data, pset); 8417 if (TREE_SIDE_EFFECTS (op)) 8418 TREE_OPERAND (expr, 0) = get_temp_regvar (TREE_TYPE (op), op); 8419 *walk_subtrees = 0; 8420 } 8421 else if (!EXPR_P (expr) || !TREE_SIDE_EFFECTS (expr)) 8422 *walk_subtrees = 0; 8423 return NULL; 8424} 8425 8426/* Entry point for the above. */ 8427 8428static void 8429stabilize_vla_size (tree size) 8430{ 8431 hash_set<tree> pset; 8432 /* Break out any function calls into temporary variables. */ 8433 cp_walk_tree (&size, stabilize_save_expr_r, &pset, &pset); 8434} 8435 8436/* Helper function for compute_array_index_type. Look for SIZEOF_EXPR 8437 not inside of SAVE_EXPR and fold them. */ 8438 8439static tree 8440fold_sizeof_expr_r (tree *expr_p, int *walk_subtrees, void *data) 8441{ 8442 tree expr = *expr_p; 8443 if (TREE_CODE (expr) == SAVE_EXPR || TYPE_P (expr)) 8444 *walk_subtrees = 0; 8445 else if (TREE_CODE (expr) == SIZEOF_EXPR) 8446 { 8447 *(bool *)data = true; 8448 if (SIZEOF_EXPR_TYPE_P (expr)) 8449 expr = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr, 0)), 8450 SIZEOF_EXPR, false); 8451 else if (TYPE_P (TREE_OPERAND (expr, 0))) 8452 expr = cxx_sizeof_or_alignof_type (TREE_OPERAND (expr, 0), SIZEOF_EXPR, 8453 false); 8454 else 8455 expr = cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr, 0), SIZEOF_EXPR, 8456 false); 8457 if (expr == error_mark_node) 8458 expr = size_one_node; 8459 *expr_p = expr; 8460 *walk_subtrees = 0; 8461 } 8462 return NULL; 8463} 8464 8465/* Given the SIZE (i.e., number of elements) in an array, compute an 8466 appropriate index type for the array. If non-NULL, NAME is the 8467 name of the thing being declared. */ 8468 8469tree 8470compute_array_index_type (tree name, tree size, tsubst_flags_t complain) 8471{ 8472 tree itype; 8473 tree osize = size; 8474 8475 if (error_operand_p (size)) 8476 return error_mark_node; 8477 8478 if (!type_dependent_expression_p (size)) 8479 { 8480 tree type = TREE_TYPE (size); 8481 8482 mark_rvalue_use (size); 8483 8484 if (cxx_dialect < cxx11 && TREE_CODE (size) == NOP_EXPR 8485 && TREE_SIDE_EFFECTS (size)) 8486 /* In C++98, we mark a non-constant array bound with a magic 8487 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */; 8488 else 8489 { 8490 size = instantiate_non_dependent_expr_sfinae (size, complain); 8491 8492 if (CLASS_TYPE_P (type) 8493 && CLASSTYPE_LITERAL_P (type)) 8494 { 8495 size = build_expr_type_conversion (WANT_INT, size, true); 8496 if (!size) 8497 { 8498 if (!(complain & tf_error)) 8499 return error_mark_node; 8500 if (name) 8501 error ("size of array %qD has non-integral type %qT", 8502 name, type); 8503 else 8504 error ("size of array has non-integral type %qT", type); 8505 size = integer_one_node; 8506 } 8507 if (size == error_mark_node) 8508 return error_mark_node; 8509 type = TREE_TYPE (size); 8510 } 8511 8512 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type)) 8513 size = maybe_constant_value (size); 8514 8515 if (!TREE_CONSTANT (size)) 8516 size = osize; 8517 } 8518 8519 if (error_operand_p (size)) 8520 return error_mark_node; 8521 8522 /* The array bound must be an integer type. */ 8523 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type)) 8524 { 8525 if (!(complain & tf_error)) 8526 return error_mark_node; 8527 if (name) 8528 error ("size of array %qD has non-integral type %qT", name, type); 8529 else 8530 error ("size of array has non-integral type %qT", type); 8531 size = integer_one_node; 8532 type = TREE_TYPE (size); 8533 } 8534 } 8535 8536 /* A type is dependent if it is...an array type constructed from any 8537 dependent type or whose size is specified by a constant expression 8538 that is value-dependent. */ 8539 /* We can only call value_dependent_expression_p on integral constant 8540 expressions; treat non-constant expressions as dependent, too. */ 8541 if (processing_template_decl 8542 && (type_dependent_expression_p (size) 8543 || !TREE_CONSTANT (size) || value_dependent_expression_p (size))) 8544 { 8545 /* We cannot do any checking for a SIZE that isn't known to be 8546 constant. Just build the index type and mark that it requires 8547 structural equality checks. */ 8548 itype = build_index_type (build_min (MINUS_EXPR, sizetype, 8549 size, size_one_node)); 8550 TYPE_DEPENDENT_P (itype) = 1; 8551 TYPE_DEPENDENT_P_VALID (itype) = 1; 8552 SET_TYPE_STRUCTURAL_EQUALITY (itype); 8553 return itype; 8554 } 8555 8556 /* Normally, the array-bound will be a constant. */ 8557 if (TREE_CODE (size) == INTEGER_CST) 8558 { 8559 /* Check to see if the array bound overflowed. Make that an 8560 error, no matter how generous we're being. */ 8561 constant_expression_error (size); 8562 8563 /* An array must have a positive number of elements. */ 8564 if (tree_int_cst_lt (size, integer_zero_node)) 8565 { 8566 if (!(complain & tf_error)) 8567 return error_mark_node; 8568 if (name) 8569 error ("size of array %qD is negative", name); 8570 else 8571 error ("size of array is negative"); 8572 size = integer_one_node; 8573 } 8574 /* As an extension we allow zero-sized arrays. */ 8575 else if (integer_zerop (size)) 8576 { 8577 if (!(complain & tf_error)) 8578 /* We must fail if performing argument deduction (as 8579 indicated by the state of complain), so that 8580 another substitution can be found. */ 8581 return error_mark_node; 8582 else if (in_system_header_at (input_location)) 8583 /* Allow them in system headers because glibc uses them. */; 8584 else if (name) 8585 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array %qD", name); 8586 else 8587 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array"); 8588 } 8589 } 8590 else if (TREE_CONSTANT (size) 8591 /* We don't allow VLAs at non-function scopes, or during 8592 tentative template substitution. */ 8593 || !at_function_scope_p () 8594 || !(complain & tf_error)) 8595 { 8596 if (!(complain & tf_error)) 8597 return error_mark_node; 8598 /* `(int) &fn' is not a valid array bound. */ 8599 if (name) 8600 error ("size of array %qD is not an integral constant-expression", 8601 name); 8602 else 8603 error ("size of array is not an integral constant-expression"); 8604 size = integer_one_node; 8605 } 8606 else if (pedantic && warn_vla != 0) 8607 { 8608 if (name) 8609 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name); 8610 else 8611 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array"); 8612 } 8613 else if (warn_vla > 0) 8614 { 8615 if (name) 8616 warning (OPT_Wvla, 8617 "variable length array %qD is used", name); 8618 else 8619 warning (OPT_Wvla, 8620 "variable length array is used"); 8621 } 8622 8623 if (processing_template_decl && !TREE_CONSTANT (size)) 8624 /* A variable sized array. */ 8625 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node); 8626 else 8627 { 8628 HOST_WIDE_INT saved_processing_template_decl; 8629 8630 /* Compute the index of the largest element in the array. It is 8631 one less than the number of elements in the array. We save 8632 and restore PROCESSING_TEMPLATE_DECL so that computations in 8633 cp_build_binary_op will be appropriately folded. */ 8634 saved_processing_template_decl = processing_template_decl; 8635 processing_template_decl = 0; 8636 itype = cp_build_binary_op (input_location, 8637 MINUS_EXPR, 8638 cp_convert (ssizetype, size, complain), 8639 cp_convert (ssizetype, integer_one_node, 8640 complain), 8641 complain); 8642 itype = fold (itype); 8643 processing_template_decl = saved_processing_template_decl; 8644 8645 if (!TREE_CONSTANT (itype)) 8646 { 8647 /* A variable sized array. */ 8648 itype = variable_size (itype); 8649 8650 if (TREE_CODE (itype) != SAVE_EXPR) 8651 { 8652 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise 8653 they might survive till gimplification. */ 8654 tree newitype = itype; 8655 bool found = false; 8656 cp_walk_tree_without_duplicates (&newitype, 8657 fold_sizeof_expr_r, &found); 8658 if (found) 8659 itype = variable_size (fold (newitype)); 8660 } 8661 8662 stabilize_vla_size (itype); 8663 8664 if (flag_sanitize & SANITIZE_VLA 8665 && do_ubsan_in_current_function ()) 8666 { 8667 /* We have to add 1 -- in the ubsan routine we generate 8668 LE_EXPR rather than LT_EXPR. */ 8669 tree t = fold_build2 (PLUS_EXPR, TREE_TYPE (itype), itype, 8670 build_one_cst (TREE_TYPE (itype))); 8671 t = ubsan_instrument_vla (input_location, t); 8672 finish_expr_stmt (t); 8673 } 8674 } 8675 /* Make sure that there was no overflow when creating to a signed 8676 index type. (For example, on a 32-bit machine, an array with 8677 size 2^32 - 1 is too big.) */ 8678 else if (TREE_CODE (itype) == INTEGER_CST 8679 && TREE_OVERFLOW (itype)) 8680 { 8681 if (!(complain & tf_error)) 8682 return error_mark_node; 8683 error ("overflow in array dimension"); 8684 TREE_OVERFLOW (itype) = 0; 8685 } 8686 } 8687 8688 /* Create and return the appropriate index type. */ 8689 itype = build_index_type (itype); 8690 8691 /* If the index type were dependent, we would have returned early, so 8692 remember that it isn't. */ 8693 TYPE_DEPENDENT_P (itype) = 0; 8694 TYPE_DEPENDENT_P_VALID (itype) = 1; 8695 return itype; 8696} 8697 8698/* Returns the scope (if any) in which the entity declared by 8699 DECLARATOR will be located. If the entity was declared with an 8700 unqualified name, NULL_TREE is returned. */ 8701 8702tree 8703get_scope_of_declarator (const cp_declarator *declarator) 8704{ 8705 while (declarator && declarator->kind != cdk_id) 8706 declarator = declarator->declarator; 8707 8708 /* If the declarator-id is a SCOPE_REF, the scope in which the 8709 declaration occurs is the first operand. */ 8710 if (declarator 8711 && declarator->u.id.qualifying_scope) 8712 return declarator->u.id.qualifying_scope; 8713 8714 /* Otherwise, the declarator is not a qualified name; the entity will 8715 be declared in the current scope. */ 8716 return NULL_TREE; 8717} 8718 8719/* Returns an ARRAY_TYPE for an array with SIZE elements of the 8720 indicated TYPE. If non-NULL, NAME is the NAME of the declaration 8721 with this type. */ 8722 8723static tree 8724create_array_type_for_decl (tree name, tree type, tree size) 8725{ 8726 tree itype = NULL_TREE; 8727 8728 /* If things have already gone awry, bail now. */ 8729 if (type == error_mark_node || size == error_mark_node) 8730 return error_mark_node; 8731 8732 /* 8.3.4/1: If the type of the identifier of D contains the auto 8733 type-specifier, the program is ill-formed. */ 8734 if (type_uses_auto (type)) 8735 { 8736 error ("%qD declared as array of %qT", name, type); 8737 return error_mark_node; 8738 } 8739 8740 /* If there are some types which cannot be array elements, 8741 issue an error-message and return. */ 8742 switch (TREE_CODE (type)) 8743 { 8744 case VOID_TYPE: 8745 if (name) 8746 error ("declaration of %qD as array of void", name); 8747 else 8748 error ("creating array of void"); 8749 return error_mark_node; 8750 8751 case FUNCTION_TYPE: 8752 if (name) 8753 error ("declaration of %qD as array of functions", name); 8754 else 8755 error ("creating array of functions"); 8756 return error_mark_node; 8757 8758 case REFERENCE_TYPE: 8759 if (name) 8760 error ("declaration of %qD as array of references", name); 8761 else 8762 error ("creating array of references"); 8763 return error_mark_node; 8764 8765 case METHOD_TYPE: 8766 if (name) 8767 error ("declaration of %qD as array of function members", name); 8768 else 8769 error ("creating array of function members"); 8770 return error_mark_node; 8771 8772 default: 8773 break; 8774 } 8775 8776 /* [dcl.array] 8777 8778 The constant expressions that specify the bounds of the arrays 8779 can be omitted only for the first member of the sequence. */ 8780 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)) 8781 { 8782 if (name) 8783 error ("declaration of %qD as multidimensional array must " 8784 "have bounds for all dimensions except the first", 8785 name); 8786 else 8787 error ("multidimensional array must have bounds for all " 8788 "dimensions except the first"); 8789 8790 return error_mark_node; 8791 } 8792 8793 /* Figure out the index type for the array. */ 8794 if (size) 8795 itype = compute_array_index_type (name, size, tf_warning_or_error); 8796 8797 /* [dcl.array] 8798 T is called the array element type; this type shall not be [...] an 8799 abstract class type. */ 8800 abstract_virtuals_error (name, type); 8801 8802 return build_cplus_array_type (type, itype); 8803} 8804 8805/* Check that it's OK to declare a function with the indicated TYPE. 8806 SFK indicates the kind of special function (if any) that this 8807 function is. OPTYPE is the type given in a conversion operator 8808 declaration, or the class type for a constructor/destructor. 8809 Returns the actual return type of the function; that 8810 may be different than TYPE if an error occurs, or for certain 8811 special functions. */ 8812 8813static tree 8814check_special_function_return_type (special_function_kind sfk, 8815 tree type, 8816 tree optype) 8817{ 8818 switch (sfk) 8819 { 8820 case sfk_constructor: 8821 if (type) 8822 error ("return type specification for constructor invalid"); 8823 8824 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype)) 8825 type = build_pointer_type (optype); 8826 else 8827 type = void_type_node; 8828 break; 8829 8830 case sfk_destructor: 8831 if (type) 8832 error ("return type specification for destructor invalid"); 8833 /* We can't use the proper return type here because we run into 8834 problems with ambiguous bases and covariant returns. 8835 Java classes are left unchanged because (void *) isn't a valid 8836 Java type, and we don't want to change the Java ABI. */ 8837 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype)) 8838 type = build_pointer_type (void_type_node); 8839 else 8840 type = void_type_node; 8841 break; 8842 8843 case sfk_conversion: 8844 if (type) 8845 error ("return type specified for %<operator %T%>", optype); 8846 type = optype; 8847 break; 8848 8849 default: 8850 gcc_unreachable (); 8851 } 8852 8853 return type; 8854} 8855 8856/* A variable or data member (whose unqualified name is IDENTIFIER) 8857 has been declared with the indicated TYPE. If the TYPE is not 8858 acceptable, issue an error message and return a type to use for 8859 error-recovery purposes. */ 8860 8861tree 8862check_var_type (tree identifier, tree type) 8863{ 8864 if (VOID_TYPE_P (type)) 8865 { 8866 if (!identifier) 8867 error ("unnamed variable or field declared void"); 8868 else if (identifier_p (identifier)) 8869 { 8870 gcc_assert (!IDENTIFIER_OPNAME_P (identifier)); 8871 error ("variable or field %qE declared void", identifier); 8872 } 8873 else 8874 error ("variable or field declared void"); 8875 type = error_mark_node; 8876 } 8877 8878 return type; 8879} 8880 8881/* Given declspecs and a declarator (abstract or otherwise), determine 8882 the name and type of the object declared and construct a DECL node 8883 for it. 8884 8885 DECLSPECS points to the representation of declaration-specifier 8886 sequence that precedes declarator. 8887 8888 DECL_CONTEXT says which syntactic context this declaration is in: 8889 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL. 8890 FUNCDEF for a function definition. Like NORMAL but a few different 8891 error messages in each case. Return value may be zero meaning 8892 this definition is too screwy to try to parse. 8893 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to 8894 handle member functions (which have FIELD context). 8895 Return value may be zero meaning this definition is too screwy to 8896 try to parse. 8897 PARM for a parameter declaration (either within a function prototype 8898 or before a function body). Make a PARM_DECL, or return void_type_node. 8899 TPARM for a template parameter declaration. 8900 CATCHPARM for a parameter declaration before a catch clause. 8901 TYPENAME if for a typename (in a cast or sizeof). 8902 Don't make a DECL node; just return the ..._TYPE node. 8903 FIELD for a struct or union field; make a FIELD_DECL. 8904 BITFIELD for a field with specified width. 8905 8906 INITIALIZED is as for start_decl. 8907 8908 ATTRLIST is a pointer to the list of attributes, which may be NULL 8909 if there are none; *ATTRLIST may be modified if attributes from inside 8910 the declarator should be applied to the declaration. 8911 8912 When this function is called, scoping variables (such as 8913 CURRENT_CLASS_TYPE) should reflect the scope in which the 8914 declaration occurs, not the scope in which the new declaration will 8915 be placed. For example, on: 8916 8917 void S::f() { ... } 8918 8919 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE 8920 should not be `S'. 8921 8922 Returns a DECL (if a declarator is present), a TYPE (if there is no 8923 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an 8924 error occurs. */ 8925 8926tree 8927grokdeclarator (const cp_declarator *declarator, 8928 cp_decl_specifier_seq *declspecs, 8929 enum decl_context decl_context, 8930 int initialized, 8931 tree* attrlist) 8932{ 8933 tree type = NULL_TREE; 8934 int longlong = 0; 8935 int explicit_intN = 0; 8936 int virtualp, explicitp, friendp, inlinep, staticp; 8937 int explicit_int = 0; 8938 int explicit_char = 0; 8939 int defaulted_int = 0; 8940 8941 tree typedef_decl = NULL_TREE; 8942 const char *name = NULL; 8943 tree typedef_type = NULL_TREE; 8944 /* True if this declarator is a function definition. */ 8945 bool funcdef_flag = false; 8946 cp_declarator_kind innermost_code = cdk_error; 8947 int bitfield = 0; 8948#if 0 8949 /* See the code below that used this. */ 8950 tree decl_attr = NULL_TREE; 8951#endif 8952 8953 /* Keep track of what sort of function is being processed 8954 so that we can warn about default return values, or explicit 8955 return values which do not match prescribed defaults. */ 8956 special_function_kind sfk = sfk_none; 8957 8958 tree dname = NULL_TREE; 8959 tree ctor_return_type = NULL_TREE; 8960 enum overload_flags flags = NO_SPECIAL; 8961 /* cv-qualifiers that apply to the declarator, for a declaration of 8962 a member function. */ 8963 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED; 8964 /* virt-specifiers that apply to the declarator, for a declaration of 8965 a member function. */ 8966 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED; 8967 /* ref-qualifier that applies to the declarator, for a declaration of 8968 a member function. */ 8969 cp_ref_qualifier rqual = REF_QUAL_NONE; 8970 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */ 8971 int type_quals; 8972 tree raises = NULL_TREE; 8973 int template_count = 0; 8974 tree returned_attrs = NULL_TREE; 8975 tree parms = NULL_TREE; 8976 const cp_declarator *id_declarator; 8977 /* The unqualified name of the declarator; either an 8978 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */ 8979 tree unqualified_id; 8980 /* The class type, if any, in which this entity is located, 8981 or NULL_TREE if none. Note that this value may be different from 8982 the current class type; for example if an attempt is made to declare 8983 "A::f" inside "B", this value will be "A". */ 8984 tree ctype = current_class_type; 8985 /* The NAMESPACE_DECL for the namespace in which this entity is 8986 located. If an unqualified name is used to declare the entity, 8987 this value will be NULL_TREE, even if the entity is located at 8988 namespace scope. */ 8989 tree in_namespace = NULL_TREE; 8990 cp_storage_class storage_class; 8991 bool unsigned_p, signed_p, short_p, long_p, thread_p; 8992 bool type_was_error_mark_node = false; 8993 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false; 8994 bool template_type_arg = false; 8995 bool template_parm_flag = false; 8996 bool typedef_p = decl_spec_seq_has_spec_p (declspecs, ds_typedef); 8997 bool constexpr_p = decl_spec_seq_has_spec_p (declspecs, ds_constexpr); 8998 bool late_return_type_p = false; 8999 bool array_parameter_p = false; 9000 source_location saved_loc = input_location; 9001 const char *errmsg; 9002 9003 signed_p = decl_spec_seq_has_spec_p (declspecs, ds_signed); 9004 unsigned_p = decl_spec_seq_has_spec_p (declspecs, ds_unsigned); 9005 short_p = decl_spec_seq_has_spec_p (declspecs, ds_short); 9006 long_p = decl_spec_seq_has_spec_p (declspecs, ds_long); 9007 longlong = decl_spec_seq_has_spec_p (declspecs, ds_long_long); 9008 explicit_intN = declspecs->explicit_intN_p; 9009 thread_p = decl_spec_seq_has_spec_p (declspecs, ds_thread); 9010 9011 if (decl_context == FUNCDEF) 9012 funcdef_flag = true, decl_context = NORMAL; 9013 else if (decl_context == MEMFUNCDEF) 9014 funcdef_flag = true, decl_context = FIELD; 9015 else if (decl_context == BITFIELD) 9016 bitfield = 1, decl_context = FIELD; 9017 else if (decl_context == TEMPLATE_TYPE_ARG) 9018 template_type_arg = true, decl_context = TYPENAME; 9019 else if (decl_context == TPARM) 9020 template_parm_flag = true, decl_context = PARM; 9021 9022 if (initialized > 1) 9023 funcdef_flag = true; 9024 9025 /* Look inside a declarator for the name being declared 9026 and get it as a string, for an error message. */ 9027 for (id_declarator = declarator; 9028 id_declarator; 9029 id_declarator = id_declarator->declarator) 9030 { 9031 if (id_declarator->kind != cdk_id) 9032 innermost_code = id_declarator->kind; 9033 9034 switch (id_declarator->kind) 9035 { 9036 case cdk_function: 9037 if (id_declarator->declarator 9038 && id_declarator->declarator->kind == cdk_id) 9039 { 9040 sfk = id_declarator->declarator->u.id.sfk; 9041 if (sfk == sfk_destructor) 9042 flags = DTOR_FLAG; 9043 } 9044 break; 9045 9046 case cdk_id: 9047 { 9048 tree qualifying_scope = id_declarator->u.id.qualifying_scope; 9049 tree decl = id_declarator->u.id.unqualified_name; 9050 if (!decl) 9051 break; 9052 if (qualifying_scope) 9053 { 9054 if (at_function_scope_p ()) 9055 { 9056 /* [dcl.meaning] 9057 9058 A declarator-id shall not be qualified except 9059 for ... 9060 9061 None of the cases are permitted in block 9062 scope. */ 9063 if (qualifying_scope == global_namespace) 9064 error ("invalid use of qualified-name %<::%D%>", 9065 decl); 9066 else if (TYPE_P (qualifying_scope)) 9067 error ("invalid use of qualified-name %<%T::%D%>", 9068 qualifying_scope, decl); 9069 else 9070 error ("invalid use of qualified-name %<%D::%D%>", 9071 qualifying_scope, decl); 9072 return error_mark_node; 9073 } 9074 else if (TYPE_P (qualifying_scope)) 9075 { 9076 ctype = qualifying_scope; 9077 if (!MAYBE_CLASS_TYPE_P (ctype)) 9078 { 9079 error ("%q#T is not a class or a namespace", ctype); 9080 ctype = NULL_TREE; 9081 } 9082 else if (innermost_code != cdk_function 9083 && current_class_type 9084 && !uniquely_derived_from_p (ctype, 9085 current_class_type)) 9086 { 9087 error ("invalid use of qualified-name %<%T::%D%>", 9088 qualifying_scope, decl); 9089 return error_mark_node; 9090 } 9091 } 9092 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL) 9093 in_namespace = qualifying_scope; 9094 } 9095 switch (TREE_CODE (decl)) 9096 { 9097 case BIT_NOT_EXPR: 9098 { 9099 tree type; 9100 9101 if (innermost_code != cdk_function) 9102 { 9103 error ("declaration of %qD as non-function", decl); 9104 return error_mark_node; 9105 } 9106 else if (!qualifying_scope 9107 && !(current_class_type && at_class_scope_p ())) 9108 { 9109 error ("declaration of %qD as non-member", decl); 9110 return error_mark_node; 9111 } 9112 9113 type = TREE_OPERAND (decl, 0); 9114 if (TYPE_P (type)) 9115 type = constructor_name (type); 9116 name = identifier_to_locale (IDENTIFIER_POINTER (type)); 9117 dname = decl; 9118 } 9119 break; 9120 9121 case TEMPLATE_ID_EXPR: 9122 { 9123 tree fns = TREE_OPERAND (decl, 0); 9124 9125 dname = fns; 9126 if (!identifier_p (dname)) 9127 { 9128 if (variable_template_p (dname)) 9129 dname = DECL_NAME (dname); 9130 else 9131 { 9132 gcc_assert (is_overloaded_fn (dname)); 9133 dname = DECL_NAME (get_first_fn (dname)); 9134 } 9135 } 9136 } 9137 /* Fall through. */ 9138 9139 case IDENTIFIER_NODE: 9140 if (identifier_p (decl)) 9141 dname = decl; 9142 9143 if (C_IS_RESERVED_WORD (dname)) 9144 { 9145 error ("declarator-id missing; using reserved word %qD", 9146 dname); 9147 name = identifier_to_locale (IDENTIFIER_POINTER (dname)); 9148 } 9149 else if (!IDENTIFIER_TYPENAME_P (dname)) 9150 name = identifier_to_locale (IDENTIFIER_POINTER (dname)); 9151 else 9152 { 9153 gcc_assert (flags == NO_SPECIAL); 9154 flags = TYPENAME_FLAG; 9155 ctor_return_type = TREE_TYPE (dname); 9156 sfk = sfk_conversion; 9157 if (is_typename_at_global_scope (dname)) 9158 name = identifier_to_locale (IDENTIFIER_POINTER (dname)); 9159 else 9160 name = "<invalid operator>"; 9161 } 9162 break; 9163 9164 default: 9165 gcc_unreachable (); 9166 } 9167 break; 9168 } 9169 9170 case cdk_array: 9171 case cdk_pointer: 9172 case cdk_reference: 9173 case cdk_ptrmem: 9174 break; 9175 9176 case cdk_error: 9177 return error_mark_node; 9178 9179 default: 9180 gcc_unreachable (); 9181 } 9182 if (id_declarator->kind == cdk_id) 9183 break; 9184 } 9185 9186 /* [dcl.fct.edf] 9187 9188 The declarator in a function-definition shall have the form 9189 D1 ( parameter-declaration-clause) ... */ 9190 if (funcdef_flag && innermost_code != cdk_function) 9191 { 9192 error ("function definition does not declare parameters"); 9193 return error_mark_node; 9194 } 9195 9196 if (flags == TYPENAME_FLAG 9197 && innermost_code != cdk_function 9198 && ! (ctype && !declspecs->any_specifiers_p)) 9199 { 9200 error ("declaration of %qD as non-function", dname); 9201 return error_mark_node; 9202 } 9203 9204 if (dname 9205 && identifier_p (dname) 9206 && UDLIT_OPER_P (dname) 9207 && innermost_code != cdk_function) 9208 { 9209 error ("declaration of %qD as non-function", dname); 9210 return error_mark_node; 9211 } 9212 9213 if (dname && IDENTIFIER_OPNAME_P (dname)) 9214 { 9215 if (typedef_p) 9216 { 9217 error ("declaration of %qD as %<typedef%>", dname); 9218 return error_mark_node; 9219 } 9220 else if (decl_context == PARM || decl_context == CATCHPARM) 9221 { 9222 error ("declaration of %qD as parameter", dname); 9223 return error_mark_node; 9224 } 9225 } 9226 9227 /* Anything declared one level down from the top level 9228 must be one of the parameters of a function 9229 (because the body is at least two levels down). */ 9230 9231 /* This heuristic cannot be applied to C++ nodes! Fixed, however, 9232 by not allowing C++ class definitions to specify their parameters 9233 with xdecls (must be spec.d in the parmlist). 9234 9235 Since we now wait to push a class scope until we are sure that 9236 we are in a legitimate method context, we must set oldcname 9237 explicitly (since current_class_name is not yet alive). 9238 9239 We also want to avoid calling this a PARM if it is in a namespace. */ 9240 9241 if (decl_context == NORMAL && !toplevel_bindings_p ()) 9242 { 9243 cp_binding_level *b = current_binding_level; 9244 current_binding_level = b->level_chain; 9245 if (current_binding_level != 0 && toplevel_bindings_p ()) 9246 decl_context = PARM; 9247 current_binding_level = b; 9248 } 9249 9250 if (name == NULL) 9251 name = decl_context == PARM ? "parameter" : "type name"; 9252 9253 if (constexpr_p && typedef_p) 9254 { 9255 error ("%<constexpr%> cannot appear in a typedef declaration"); 9256 return error_mark_node; 9257 } 9258 9259 /* If there were multiple types specified in the decl-specifier-seq, 9260 issue an error message. */ 9261 if (declspecs->multiple_types_p) 9262 { 9263 error ("two or more data types in declaration of %qs", name); 9264 return error_mark_node; 9265 } 9266 9267 if (declspecs->conflicting_specifiers_p) 9268 { 9269 error ("conflicting specifiers in declaration of %qs", name); 9270 return error_mark_node; 9271 } 9272 9273 /* Extract the basic type from the decl-specifier-seq. */ 9274 type = declspecs->type; 9275 if (type == error_mark_node) 9276 { 9277 type = NULL_TREE; 9278 type_was_error_mark_node = true; 9279 } 9280 /* If the entire declaration is itself tagged as deprecated then 9281 suppress reports of deprecated items. */ 9282 if (type && TREE_DEPRECATED (type) 9283 && deprecated_state != DEPRECATED_SUPPRESS) 9284 warn_deprecated_use (type, NULL_TREE); 9285 if (type && TREE_CODE (type) == TYPE_DECL) 9286 { 9287 typedef_decl = type; 9288 type = TREE_TYPE (typedef_decl); 9289 if (TREE_DEPRECATED (type) 9290 && DECL_ARTIFICIAL (typedef_decl) 9291 && deprecated_state != DEPRECATED_SUPPRESS) 9292 warn_deprecated_use (type, NULL_TREE); 9293 } 9294 /* No type at all: default to `int', and set DEFAULTED_INT 9295 because it was not a user-defined typedef. */ 9296 if (type == NULL_TREE) 9297 { 9298 if (signed_p || unsigned_p || long_p || short_p) 9299 { 9300 /* These imply 'int'. */ 9301 type = integer_type_node; 9302 defaulted_int = 1; 9303 } 9304 /* If we just have "complex", it is equivalent to "complex double". */ 9305 else if (!longlong && !explicit_intN 9306 && decl_spec_seq_has_spec_p (declspecs, ds_complex)) 9307 { 9308 type = double_type_node; 9309 pedwarn (declspecs->locations[ds_complex], OPT_Wpedantic, 9310 "ISO C++ does not support plain %<complex%> meaning " 9311 "%<double complex%>"); 9312 } 9313 } 9314 /* Gather flags. */ 9315 explicit_int = declspecs->explicit_int_p; 9316 explicit_char = declspecs->explicit_char_p; 9317 9318#if 0 9319 /* See the code below that used this. */ 9320 if (typedef_decl) 9321 decl_attr = DECL_ATTRIBUTES (typedef_decl); 9322#endif 9323 typedef_type = type; 9324 9325 9326 if (sfk != sfk_conversion) 9327 ctor_return_type = ctype; 9328 9329 if (sfk != sfk_none) 9330 type = check_special_function_return_type (sfk, type, 9331 ctor_return_type); 9332 else if (type == NULL_TREE) 9333 { 9334 int is_main; 9335 9336 explicit_int = -1; 9337 9338 /* We handle `main' specially here, because 'main () { }' is so 9339 common. With no options, it is allowed. With -Wreturn-type, 9340 it is a warning. It is only an error with -pedantic-errors. */ 9341 is_main = (funcdef_flag 9342 && dname && identifier_p (dname) 9343 && MAIN_NAME_P (dname) 9344 && ctype == NULL_TREE 9345 && in_namespace == NULL_TREE 9346 && current_namespace == global_namespace); 9347 9348 if (type_was_error_mark_node) 9349 /* We've already issued an error, don't complain more. */; 9350 else if (in_system_header_at (input_location) || flag_ms_extensions) 9351 /* Allow it, sigh. */; 9352 else if (! is_main) 9353 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name); 9354 else if (pedantic) 9355 pedwarn (input_location, OPT_Wpedantic, 9356 "ISO C++ forbids declaration of %qs with no type", name); 9357 else 9358 warning (OPT_Wreturn_type, 9359 "ISO C++ forbids declaration of %qs with no type", name); 9360 9361 type = integer_type_node; 9362 } 9363 9364 ctype = NULL_TREE; 9365 9366 if (explicit_intN) 9367 { 9368 if (! int_n_enabled_p[declspecs->int_n_idx]) 9369 { 9370 error ("%<__int%d%> is not supported by this target", 9371 int_n_data[declspecs->int_n_idx].bitsize); 9372 explicit_intN = false; 9373 } 9374 else if (pedantic && ! in_system_header_at (input_location)) 9375 pedwarn (input_location, OPT_Wpedantic, 9376 "ISO C++ does not support %<__int%d%> for %qs", 9377 int_n_data[declspecs->int_n_idx].bitsize, name); 9378 } 9379 9380 /* Now process the modifiers that were specified 9381 and check for invalid combinations. */ 9382 9383 /* Long double is a special combination. */ 9384 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node) 9385 { 9386 long_p = false; 9387 type = cp_build_qualified_type (long_double_type_node, 9388 cp_type_quals (type)); 9389 } 9390 9391 /* Check all other uses of type modifiers. */ 9392 9393 if (unsigned_p || signed_p || long_p || short_p) 9394 { 9395 int ok = 0; 9396 9397 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE) 9398 error ("%<signed%> or %<unsigned%> invalid for %qs", name); 9399 else if (signed_p && unsigned_p) 9400 error ("%<signed%> and %<unsigned%> specified together for %qs", name); 9401 else if (longlong && TREE_CODE (type) != INTEGER_TYPE) 9402 error ("%<long long%> invalid for %qs", name); 9403 else if (long_p && TREE_CODE (type) == REAL_TYPE) 9404 error ("%<long%> invalid for %qs", name); 9405 else if (short_p && TREE_CODE (type) == REAL_TYPE) 9406 error ("%<short%> invalid for %qs", name); 9407 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE) 9408 error ("%<long%> or %<short%> invalid for %qs", name); 9409 else if ((long_p || short_p || explicit_char || explicit_int) && explicit_intN) 9410 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name); 9411 else if ((long_p || short_p) && explicit_char) 9412 error ("%<long%> or %<short%> specified with char for %qs", name); 9413 else if (long_p && short_p) 9414 error ("%<long%> and %<short%> specified together for %qs", name); 9415 else if (type == char16_type_node || type == char32_type_node) 9416 { 9417 if (signed_p || unsigned_p) 9418 error ("%<signed%> or %<unsigned%> invalid for %qs", name); 9419 else if (short_p || long_p) 9420 error ("%<short%> or %<long%> invalid for %qs", name); 9421 } 9422 else 9423 { 9424 ok = 1; 9425 if (!explicit_int && !defaulted_int && !explicit_char && !explicit_intN && pedantic) 9426 { 9427 pedwarn (input_location, OPT_Wpedantic, 9428 "long, short, signed or unsigned used invalidly for %qs", 9429 name); 9430 if (flag_pedantic_errors) 9431 ok = 0; 9432 } 9433 } 9434 9435 /* Discard the type modifiers if they are invalid. */ 9436 if (! ok) 9437 { 9438 unsigned_p = false; 9439 signed_p = false; 9440 long_p = false; 9441 short_p = false; 9442 longlong = 0; 9443 } 9444 } 9445 9446 /* Decide whether an integer type is signed or not. 9447 Optionally treat bitfields as signed by default. */ 9448 if (unsigned_p 9449 /* [class.bit] 9450 9451 It is implementation-defined whether a plain (neither 9452 explicitly signed or unsigned) char, short, int, or long 9453 bit-field is signed or unsigned. 9454 9455 Naturally, we extend this to long long as well. Note that 9456 this does not include wchar_t. */ 9457 || (bitfield && !flag_signed_bitfields 9458 && !signed_p 9459 /* A typedef for plain `int' without `signed' can be 9460 controlled just like plain `int', but a typedef for 9461 `signed int' cannot be so controlled. */ 9462 && !(typedef_decl 9463 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)) 9464 && TREE_CODE (type) == INTEGER_TYPE 9465 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node))) 9466 { 9467 if (explicit_intN) 9468 type = int_n_trees[declspecs->int_n_idx].unsigned_type; 9469 else if (longlong) 9470 type = long_long_unsigned_type_node; 9471 else if (long_p) 9472 type = long_unsigned_type_node; 9473 else if (short_p) 9474 type = short_unsigned_type_node; 9475 else if (type == char_type_node) 9476 type = unsigned_char_type_node; 9477 else if (typedef_decl) 9478 type = unsigned_type_for (type); 9479 else 9480 type = unsigned_type_node; 9481 } 9482 else if (signed_p && type == char_type_node) 9483 type = signed_char_type_node; 9484 else if (explicit_intN) 9485 type = int_n_trees[declspecs->int_n_idx].signed_type; 9486 else if (longlong) 9487 type = long_long_integer_type_node; 9488 else if (long_p) 9489 type = long_integer_type_node; 9490 else if (short_p) 9491 type = short_integer_type_node; 9492 9493 if (decl_spec_seq_has_spec_p (declspecs, ds_complex)) 9494 { 9495 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE) 9496 error ("complex invalid for %qs", name); 9497 /* If a modifier is specified, the resulting complex is the complex 9498 form of TYPE. E.g, "complex short" is "complex short int". */ 9499 else if (type == integer_type_node) 9500 type = complex_integer_type_node; 9501 else if (type == float_type_node) 9502 type = complex_float_type_node; 9503 else if (type == double_type_node) 9504 type = complex_double_type_node; 9505 else if (type == long_double_type_node) 9506 type = complex_long_double_type_node; 9507 else 9508 type = build_complex_type (type); 9509 } 9510 9511 type_quals = TYPE_UNQUALIFIED; 9512 if (decl_spec_seq_has_spec_p (declspecs, ds_const)) 9513 type_quals |= TYPE_QUAL_CONST; 9514 if (decl_spec_seq_has_spec_p (declspecs, ds_volatile)) 9515 type_quals |= TYPE_QUAL_VOLATILE; 9516 if (decl_spec_seq_has_spec_p (declspecs, ds_restrict)) 9517 type_quals |= TYPE_QUAL_RESTRICT; 9518 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED) 9519 error ("qualifiers are not allowed on declaration of %<operator %T%>", 9520 ctor_return_type); 9521 9522 /* If we're using the injected-class-name to form a compound type or a 9523 declaration, replace it with the underlying class so we don't get 9524 redundant typedefs in the debug output. But if we are returning the 9525 type unchanged, leave it alone so that it's available to 9526 maybe_get_template_decl_from_type_decl. */ 9527 if (CLASS_TYPE_P (type) 9528 && DECL_SELF_REFERENCE_P (TYPE_NAME (type)) 9529 && type == TREE_TYPE (TYPE_NAME (type)) 9530 && (declarator || type_quals)) 9531 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type)); 9532 9533 type_quals |= cp_type_quals (type); 9534 type = cp_build_qualified_type_real 9535 (type, type_quals, ((((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)) 9536 || declspecs->decltype_p) 9537 ? tf_ignore_bad_quals : 0) | tf_warning_or_error)); 9538 /* We might have ignored or rejected some of the qualifiers. */ 9539 type_quals = cp_type_quals (type); 9540 9541 staticp = 0; 9542 inlinep = decl_spec_seq_has_spec_p (declspecs, ds_inline); 9543 virtualp = decl_spec_seq_has_spec_p (declspecs, ds_virtual); 9544 explicitp = decl_spec_seq_has_spec_p (declspecs, ds_explicit); 9545 9546 storage_class = declspecs->storage_class; 9547 if (storage_class == sc_static) 9548 staticp = 1 + (decl_context == FIELD); 9549 9550 if (virtualp && staticp == 2) 9551 { 9552 error ("member %qD cannot be declared both virtual and static", dname); 9553 storage_class = sc_none; 9554 staticp = 0; 9555 } 9556 friendp = decl_spec_seq_has_spec_p (declspecs, ds_friend); 9557 9558 /* Issue errors about use of storage classes for parameters. */ 9559 if (decl_context == PARM) 9560 { 9561 if (typedef_p) 9562 { 9563 error ("typedef declaration invalid in parameter declaration"); 9564 return error_mark_node; 9565 } 9566 else if (template_parm_flag && storage_class != sc_none) 9567 { 9568 error ("storage class specified for template parameter %qs", name); 9569 return error_mark_node; 9570 } 9571 else if (storage_class == sc_static 9572 || storage_class == sc_extern 9573 || thread_p) 9574 error ("storage class specifiers invalid in parameter declarations"); 9575 9576 /* Function parameters cannot be constexpr. If we saw one, moan 9577 and pretend it wasn't there. */ 9578 if (constexpr_p) 9579 { 9580 error ("a parameter cannot be declared %<constexpr%>"); 9581 constexpr_p = 0; 9582 } 9583 } 9584 9585 /* Give error if `virtual' is used outside of class declaration. */ 9586 if (virtualp 9587 && (current_class_name == NULL_TREE || decl_context != FIELD)) 9588 { 9589 error ("%<virtual%> outside class declaration"); 9590 virtualp = 0; 9591 } 9592 9593 /* Static anonymous unions are dealt with here. */ 9594 if (staticp && decl_context == TYPENAME 9595 && declspecs->type 9596 && ANON_AGGR_TYPE_P (declspecs->type)) 9597 decl_context = FIELD; 9598 9599 /* Warn about storage classes that are invalid for certain 9600 kinds of declarations (parameters, typenames, etc.). */ 9601 if (thread_p 9602 && ((storage_class 9603 && storage_class != sc_extern 9604 && storage_class != sc_static) 9605 || typedef_p)) 9606 { 9607 error ("multiple storage classes in declaration of %qs", name); 9608 thread_p = false; 9609 } 9610 if (decl_context != NORMAL 9611 && ((storage_class != sc_none 9612 && storage_class != sc_mutable) 9613 || thread_p)) 9614 { 9615 if ((decl_context == PARM || decl_context == CATCHPARM) 9616 && (storage_class == sc_register 9617 || storage_class == sc_auto)) 9618 ; 9619 else if (typedef_p) 9620 ; 9621 else if (decl_context == FIELD 9622 /* C++ allows static class elements. */ 9623 && storage_class == sc_static) 9624 /* C++ also allows inlines and signed and unsigned elements, 9625 but in those cases we don't come in here. */ 9626 ; 9627 else 9628 { 9629 if (decl_context == FIELD) 9630 error ("storage class specified for %qs", name); 9631 else 9632 { 9633 if (decl_context == PARM || decl_context == CATCHPARM) 9634 error ("storage class specified for parameter %qs", name); 9635 else 9636 error ("storage class specified for typename"); 9637 } 9638 if (storage_class == sc_register 9639 || storage_class == sc_auto 9640 || storage_class == sc_extern 9641 || thread_p) 9642 storage_class = sc_none; 9643 } 9644 } 9645 else if (storage_class == sc_extern && funcdef_flag 9646 && ! toplevel_bindings_p ()) 9647 error ("nested function %qs declared %<extern%>", name); 9648 else if (toplevel_bindings_p ()) 9649 { 9650 if (storage_class == sc_auto) 9651 error ("top-level declaration of %qs specifies %<auto%>", name); 9652 } 9653 else if (thread_p 9654 && storage_class != sc_extern 9655 && storage_class != sc_static) 9656 { 9657 if (declspecs->gnu_thread_keyword_p) 9658 pedwarn (input_location, 0, "function-scope %qs implicitly auto and " 9659 "declared %<__thread%>", name); 9660 9661 /* When thread_local is applied to a variable of block scope the 9662 storage-class-specifier static is implied if it does not appear 9663 explicitly. */ 9664 storage_class = declspecs->storage_class = sc_static; 9665 staticp = 1; 9666 } 9667 9668 if (storage_class && friendp) 9669 { 9670 error ("storage class specifiers invalid in friend function declarations"); 9671 storage_class = sc_none; 9672 staticp = 0; 9673 } 9674 9675 if (!id_declarator) 9676 unqualified_id = NULL_TREE; 9677 else 9678 { 9679 unqualified_id = id_declarator->u.id.unqualified_name; 9680 switch (TREE_CODE (unqualified_id)) 9681 { 9682 case BIT_NOT_EXPR: 9683 unqualified_id = TREE_OPERAND (unqualified_id, 0); 9684 if (TYPE_P (unqualified_id)) 9685 unqualified_id = constructor_name (unqualified_id); 9686 break; 9687 9688 case IDENTIFIER_NODE: 9689 case TEMPLATE_ID_EXPR: 9690 break; 9691 9692 default: 9693 gcc_unreachable (); 9694 } 9695 } 9696 9697 if (declspecs->std_attributes) 9698 { 9699 /* Apply the c++11 attributes to the type preceding them. */ 9700 input_location = declspecs->locations[ds_std_attribute]; 9701 decl_attributes (&type, declspecs->std_attributes, 0); 9702 input_location = saved_loc; 9703 } 9704 9705 /* Determine the type of the entity declared by recurring on the 9706 declarator. */ 9707 for (; declarator; declarator = declarator->declarator) 9708 { 9709 const cp_declarator *inner_declarator; 9710 tree attrs; 9711 9712 if (type == error_mark_node) 9713 return error_mark_node; 9714 9715 attrs = declarator->attributes; 9716 if (attrs) 9717 { 9718 int attr_flags; 9719 9720 attr_flags = 0; 9721 if (declarator == NULL || declarator->kind == cdk_id) 9722 attr_flags |= (int) ATTR_FLAG_DECL_NEXT; 9723 if (declarator->kind == cdk_function) 9724 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT; 9725 if (declarator->kind == cdk_array) 9726 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT; 9727 returned_attrs = decl_attributes (&type, 9728 chainon (returned_attrs, attrs), 9729 attr_flags); 9730 } 9731 9732 if (declarator->kind == cdk_id) 9733 break; 9734 9735 inner_declarator = declarator->declarator; 9736 9737 switch (declarator->kind) 9738 { 9739 case cdk_array: 9740 type = create_array_type_for_decl (dname, type, 9741 declarator->u.array.bounds); 9742 if (declarator->std_attributes) 9743 /* [dcl.array]/1: 9744 9745 The optional attribute-specifier-seq appertains to the 9746 array. */ 9747 returned_attrs = chainon (returned_attrs, 9748 declarator->std_attributes); 9749 break; 9750 9751 case cdk_function: 9752 { 9753 tree arg_types; 9754 int funcdecl_p; 9755 9756 /* Declaring a function type. 9757 Make sure we have a valid type for the function to return. */ 9758 9759 if (type_quals != TYPE_UNQUALIFIED) 9760 { 9761 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type)) 9762 warning (OPT_Wignored_qualifiers, 9763 "type qualifiers ignored on function return type"); 9764 /* We now know that the TYPE_QUALS don't apply to the 9765 decl, but to its return type. */ 9766 type_quals = TYPE_UNQUALIFIED; 9767 } 9768 errmsg = targetm.invalid_return_type (type); 9769 if (errmsg) 9770 { 9771 error (errmsg); 9772 type = integer_type_node; 9773 } 9774 9775 /* Error about some types functions can't return. */ 9776 9777 if (TREE_CODE (type) == FUNCTION_TYPE) 9778 { 9779 error ("%qs declared as function returning a function", name); 9780 return error_mark_node; 9781 } 9782 if (TREE_CODE (type) == ARRAY_TYPE) 9783 { 9784 error ("%qs declared as function returning an array", name); 9785 return error_mark_node; 9786 } 9787 9788 input_location = declspecs->locations[ds_type_spec]; 9789 abstract_virtuals_error (ACU_RETURN, type); 9790 input_location = saved_loc; 9791 9792 /* Pick up type qualifiers which should be applied to `this'. */ 9793 memfn_quals = declarator->u.function.qualifiers; 9794 /* Pick up virt-specifiers. */ 9795 virt_specifiers = declarator->u.function.virt_specifiers; 9796 /* And ref-qualifier, too */ 9797 rqual = declarator->u.function.ref_qualifier; 9798 /* Pick up the exception specifications. */ 9799 raises = declarator->u.function.exception_specification; 9800 /* If the exception-specification is ill-formed, let's pretend 9801 there wasn't one. */ 9802 if (raises == error_mark_node) 9803 raises = NULL_TREE; 9804 9805 /* Say it's a definition only for the CALL_EXPR 9806 closest to the identifier. */ 9807 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id; 9808 9809 /* Handle a late-specified return type. */ 9810 if (funcdecl_p) 9811 { 9812 if (type_uses_auto (type)) 9813 { 9814 if (!declarator->u.function.late_return_type) 9815 { 9816 if (current_class_type 9817 && LAMBDA_TYPE_P (current_class_type)) 9818 /* OK for C++11 lambdas. */; 9819 else if (cxx_dialect < cxx14) 9820 { 9821 error ("%qs function uses " 9822 "%<auto%> type specifier without trailing " 9823 "return type", name); 9824 inform (input_location, "deduced return type " 9825 "only available with -std=c++14 or " 9826 "-std=gnu++14"); 9827 } 9828 else if (virtualp) 9829 { 9830 error ("virtual function cannot " 9831 "have deduced return type"); 9832 virtualp = false; 9833 } 9834 } 9835 else if (!is_auto (type)) 9836 { 9837 error ("%qs function with trailing return type has" 9838 " %qT as its type rather than plain %<auto%>", 9839 name, type); 9840 return error_mark_node; 9841 } 9842 } 9843 else if (declarator->u.function.late_return_type) 9844 { 9845 if (cxx_dialect < cxx11) 9846 /* Not using maybe_warn_cpp0x because this should 9847 always be an error. */ 9848 error ("trailing return type only available with " 9849 "-std=c++11 or -std=gnu++11"); 9850 else 9851 error ("%qs function with trailing return type not " 9852 "declared with %<auto%> type specifier", name); 9853 return error_mark_node; 9854 } 9855 } 9856 type = splice_late_return_type 9857 (type, declarator->u.function.late_return_type); 9858 if (type == error_mark_node) 9859 return error_mark_node; 9860 9861 if (declarator->u.function.late_return_type) 9862 late_return_type_p = true; 9863 9864 if (ctype == NULL_TREE 9865 && decl_context == FIELD 9866 && funcdecl_p 9867 && friendp == 0) 9868 ctype = current_class_type; 9869 9870 if (ctype && (sfk == sfk_constructor 9871 || sfk == sfk_destructor)) 9872 { 9873 /* We are within a class's scope. If our declarator name 9874 is the same as the class name, and we are defining 9875 a function, then it is a constructor/destructor, and 9876 therefore returns a void type. */ 9877 9878 /* ISO C++ 12.4/2. A destructor may not be declared 9879 const or volatile. A destructor may not be static. 9880 A destructor may not be declared with ref-qualifier. 9881 9882 ISO C++ 12.1. A constructor may not be declared 9883 const or volatile. A constructor may not be 9884 virtual. A constructor may not be static. 9885 A constructor may not be declared with ref-qualifier. */ 9886 if (staticp == 2) 9887 error ((flags == DTOR_FLAG) 9888 ? G_("destructor cannot be static member function") 9889 : G_("constructor cannot be static member function")); 9890 if (memfn_quals) 9891 { 9892 error ((flags == DTOR_FLAG) 9893 ? G_("destructors may not be cv-qualified") 9894 : G_("constructors may not be cv-qualified")); 9895 memfn_quals = TYPE_UNQUALIFIED; 9896 } 9897 9898 if (rqual) 9899 { 9900 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER); 9901 error ((flags == DTOR_FLAG) 9902 ? "destructors may not be ref-qualified" 9903 : "constructors may not be ref-qualified"); 9904 rqual = REF_QUAL_NONE; 9905 } 9906 9907 if (decl_context == FIELD 9908 && !member_function_or_else (ctype, 9909 current_class_type, 9910 flags)) 9911 return error_mark_node; 9912 9913 if (flags != DTOR_FLAG) 9914 { 9915 /* It's a constructor. */ 9916 if (explicitp == 1) 9917 explicitp = 2; 9918 if (virtualp) 9919 { 9920 permerror (input_location, "constructors cannot be declared virtual"); 9921 virtualp = 0; 9922 } 9923 if (decl_context == FIELD 9924 && sfk != sfk_constructor) 9925 return error_mark_node; 9926 } 9927 if (decl_context == FIELD) 9928 staticp = 0; 9929 } 9930 else if (friendp) 9931 { 9932 if (virtualp) 9933 { 9934 /* Cannot be both friend and virtual. */ 9935 error ("virtual functions cannot be friends"); 9936 friendp = 0; 9937 } 9938 if (decl_context == NORMAL) 9939 error ("friend declaration not in class definition"); 9940 if (current_function_decl && funcdef_flag) 9941 error ("can%'t define friend function %qs in a local " 9942 "class definition", 9943 name); 9944 } 9945 else if (ctype && sfk == sfk_conversion) 9946 { 9947 if (explicitp == 1) 9948 { 9949 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION); 9950 explicitp = 2; 9951 } 9952 } 9953 9954 arg_types = grokparms (declarator->u.function.parameters, 9955 &parms); 9956 9957 if (inner_declarator 9958 && inner_declarator->kind == cdk_id 9959 && inner_declarator->u.id.sfk == sfk_destructor 9960 && arg_types != void_list_node) 9961 { 9962 error ("destructors may not have parameters"); 9963 arg_types = void_list_node; 9964 parms = NULL_TREE; 9965 } 9966 9967 type = build_function_type (type, arg_types); 9968 if (declarator->std_attributes) 9969 /* [dcl.fct]/2: 9970 9971 The optional attribute-specifier-seq appertains to 9972 the function type. */ 9973 decl_attributes (&type, declarator->std_attributes, 9974 0); 9975 } 9976 break; 9977 9978 case cdk_pointer: 9979 case cdk_reference: 9980 case cdk_ptrmem: 9981 /* Filter out pointers-to-references and references-to-references. 9982 We can get these if a TYPE_DECL is used. */ 9983 9984 if (TREE_CODE (type) == REFERENCE_TYPE) 9985 { 9986 if (declarator->kind != cdk_reference) 9987 { 9988 error ("cannot declare pointer to %q#T", type); 9989 type = TREE_TYPE (type); 9990 } 9991 9992 /* In C++0x, we allow reference to reference declarations 9993 that occur indirectly through typedefs [7.1.3/8 dcl.typedef] 9994 and template type arguments [14.3.1/4 temp.arg.type]. The 9995 check for direct reference to reference declarations, which 9996 are still forbidden, occurs below. Reasoning behind the change 9997 can be found in DR106, DR540, and the rvalue reference 9998 proposals. */ 9999 else if (cxx_dialect == cxx98) 10000 { 10001 error ("cannot declare reference to %q#T", type); 10002 type = TREE_TYPE (type); 10003 } 10004 } 10005 else if (VOID_TYPE_P (type)) 10006 { 10007 if (declarator->kind == cdk_reference) 10008 error ("cannot declare reference to %q#T", type); 10009 else if (declarator->kind == cdk_ptrmem) 10010 error ("cannot declare pointer to %q#T member", type); 10011 } 10012 10013 /* We now know that the TYPE_QUALS don't apply to the decl, 10014 but to the target of the pointer. */ 10015 type_quals = TYPE_UNQUALIFIED; 10016 10017 /* This code used to handle METHOD_TYPE, but I don't think it's 10018 possible to get it here anymore. */ 10019 gcc_assert (TREE_CODE (type) != METHOD_TYPE); 10020 if (declarator->kind == cdk_ptrmem 10021 && TREE_CODE (type) == FUNCTION_TYPE) 10022 { 10023 memfn_quals |= type_memfn_quals (type); 10024 type = build_memfn_type (type, 10025 declarator->u.pointer.class_type, 10026 memfn_quals, 10027 rqual); 10028 if (type == error_mark_node) 10029 return error_mark_node; 10030 10031 rqual = REF_QUAL_NONE; 10032 memfn_quals = TYPE_UNQUALIFIED; 10033 } 10034 10035 if (TREE_CODE (type) == FUNCTION_TYPE 10036 && (type_memfn_quals (type) != TYPE_UNQUALIFIED 10037 || type_memfn_rqual (type) != REF_QUAL_NONE)) 10038 error (declarator->kind == cdk_reference 10039 ? G_("cannot declare reference to qualified function type %qT") 10040 : G_("cannot declare pointer to qualified function type %qT"), 10041 type); 10042 10043 /* When the pointed-to type involves components of variable size, 10044 care must be taken to ensure that the size evaluation code is 10045 emitted early enough to dominate all the possible later uses 10046 and late enough for the variables on which it depends to have 10047 been assigned. 10048 10049 This is expected to happen automatically when the pointed-to 10050 type has a name/declaration of it's own, but special attention 10051 is required if the type is anonymous. 10052 10053 We handle the NORMAL and FIELD contexts here by inserting a 10054 dummy statement that just evaluates the size at a safe point 10055 and ensures it is not deferred until e.g. within a deeper 10056 conditional context (c++/43555). 10057 10058 We expect nothing to be needed here for PARM or TYPENAME. 10059 Evaluating the size at this point for TYPENAME would 10060 actually be incorrect, as we might be in the middle of an 10061 expression with side effects on the pointed-to type size 10062 "arguments" prior to the pointer declaration point and the 10063 size evaluation could end up prior to the side effects. */ 10064 10065 if (!TYPE_NAME (type) 10066 && (decl_context == NORMAL || decl_context == FIELD) 10067 && at_function_scope_p () 10068 && variably_modified_type_p (type, NULL_TREE)) 10069 /* Force evaluation of the SAVE_EXPR. */ 10070 finish_expr_stmt (TYPE_SIZE (type)); 10071 10072 if (declarator->kind == cdk_reference) 10073 { 10074 /* In C++0x, the type we are creating a reference to might be 10075 a typedef which is itself a reference type. In that case, 10076 we follow the reference collapsing rules in 10077 [7.1.3/8 dcl.typedef] to create the final reference type: 10078 10079 "If a typedef TD names a type that is a reference to a type 10080 T, an attempt to create the type 'lvalue reference to cv TD' 10081 creates the type 'lvalue reference to T,' while an attempt 10082 to create the type "rvalue reference to cv TD' creates the 10083 type TD." 10084 */ 10085 if (VOID_TYPE_P (type)) 10086 /* We already gave an error. */; 10087 else if (TREE_CODE (type) == REFERENCE_TYPE) 10088 { 10089 if (declarator->u.reference.rvalue_ref) 10090 /* Leave type alone. */; 10091 else 10092 type = cp_build_reference_type (TREE_TYPE (type), false); 10093 } 10094 else 10095 type = cp_build_reference_type 10096 (type, declarator->u.reference.rvalue_ref); 10097 10098 /* In C++0x, we need this check for direct reference to 10099 reference declarations, which are forbidden by 10100 [8.3.2/5 dcl.ref]. Reference to reference declarations 10101 are only allowed indirectly through typedefs and template 10102 type arguments. Example: 10103 10104 void foo(int & &); // invalid ref-to-ref decl 10105 10106 typedef int & int_ref; 10107 void foo(int_ref &); // valid ref-to-ref decl 10108 */ 10109 if (inner_declarator && inner_declarator->kind == cdk_reference) 10110 error ("cannot declare reference to %q#T, which is not " 10111 "a typedef or a template type argument", type); 10112 } 10113 else if (TREE_CODE (type) == METHOD_TYPE) 10114 type = build_ptrmemfunc_type (build_pointer_type (type)); 10115 else if (declarator->kind == cdk_ptrmem) 10116 { 10117 gcc_assert (TREE_CODE (declarator->u.pointer.class_type) 10118 != NAMESPACE_DECL); 10119 if (declarator->u.pointer.class_type == error_mark_node) 10120 /* We will already have complained. */ 10121 type = error_mark_node; 10122 else 10123 type = build_ptrmem_type (declarator->u.pointer.class_type, 10124 type); 10125 } 10126 else 10127 type = build_pointer_type (type); 10128 10129 /* Process a list of type modifier keywords (such as 10130 const or volatile) that were given inside the `*' or `&'. */ 10131 10132 if (declarator->u.pointer.qualifiers) 10133 { 10134 type 10135 = cp_build_qualified_type (type, 10136 declarator->u.pointer.qualifiers); 10137 type_quals = cp_type_quals (type); 10138 } 10139 10140 /* Apply C++11 attributes to the pointer, and not to the 10141 type pointed to. This is unlike what is done for GNU 10142 attributes above. It is to comply with [dcl.ptr]/1: 10143 10144 [the optional attribute-specifier-seq (7.6.1) appertains 10145 to the pointer and not to the object pointed to]. */ 10146 if (declarator->std_attributes) 10147 decl_attributes (&type, declarator->std_attributes, 10148 0); 10149 10150 ctype = NULL_TREE; 10151 break; 10152 10153 case cdk_error: 10154 break; 10155 10156 default: 10157 gcc_unreachable (); 10158 } 10159 } 10160 10161 /* A `constexpr' specifier used in an object declaration declares 10162 the object as `const'. */ 10163 if (constexpr_p && innermost_code != cdk_function) 10164 { 10165 /* DR1688 says that a `constexpr' specifier in combination with 10166 `volatile' is valid. */ 10167 10168 if (TREE_CODE (type) != REFERENCE_TYPE) 10169 { 10170 type_quals |= TYPE_QUAL_CONST; 10171 type = cp_build_qualified_type (type, type_quals); 10172 } 10173 } 10174 10175 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR 10176 && TREE_CODE (type) != FUNCTION_TYPE 10177 && TREE_CODE (type) != METHOD_TYPE 10178 && !variable_template_p (TREE_OPERAND (unqualified_id, 0))) 10179 { 10180 error ("template-id %qD used as a declarator", 10181 unqualified_id); 10182 unqualified_id = dname; 10183 } 10184 10185 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly 10186 qualified with a class-name, turn it into a METHOD_TYPE, unless 10187 we know that the function is static. We take advantage of this 10188 opportunity to do other processing that pertains to entities 10189 explicitly declared to be class members. Note that if DECLARATOR 10190 is non-NULL, we know it is a cdk_id declarator; otherwise, we 10191 would not have exited the loop above. */ 10192 if (declarator 10193 && declarator->u.id.qualifying_scope 10194 && MAYBE_CLASS_TYPE_P (declarator->u.id.qualifying_scope)) 10195 { 10196 ctype = declarator->u.id.qualifying_scope; 10197 ctype = TYPE_MAIN_VARIANT (ctype); 10198 template_count = num_template_headers_for_class (ctype); 10199 10200 if (ctype == current_class_type) 10201 { 10202 if (friendp) 10203 { 10204 permerror (input_location, "member functions are implicitly friends of their class"); 10205 friendp = 0; 10206 } 10207 else 10208 permerror (declarator->id_loc, 10209 "extra qualification %<%T::%> on member %qs", 10210 ctype, name); 10211 } 10212 else if (/* If the qualifying type is already complete, then we 10213 can skip the following checks. */ 10214 !COMPLETE_TYPE_P (ctype) 10215 && (/* If the function is being defined, then 10216 qualifying type must certainly be complete. */ 10217 funcdef_flag 10218 /* A friend declaration of "T::f" is OK, even if 10219 "T" is a template parameter. But, if this 10220 function is not a friend, the qualifying type 10221 must be a class. */ 10222 || (!friendp && !CLASS_TYPE_P (ctype)) 10223 /* For a declaration, the type need not be 10224 complete, if either it is dependent (since there 10225 is no meaningful definition of complete in that 10226 case) or the qualifying class is currently being 10227 defined. */ 10228 || !(dependent_type_p (ctype) 10229 || currently_open_class (ctype))) 10230 /* Check that the qualifying type is complete. */ 10231 && !complete_type_or_else (ctype, NULL_TREE)) 10232 return error_mark_node; 10233 else if (TREE_CODE (type) == FUNCTION_TYPE) 10234 { 10235 if (current_class_type 10236 && (!friendp || funcdef_flag)) 10237 { 10238 error (funcdef_flag 10239 ? G_("cannot define member function %<%T::%s%> " 10240 "within %<%T%>") 10241 : G_("cannot declare member function %<%T::%s%> " 10242 "within %<%T%>"), 10243 ctype, name, current_class_type); 10244 return error_mark_node; 10245 } 10246 } 10247 else if (typedef_p && current_class_type) 10248 { 10249 error ("cannot declare member %<%T::%s%> within %qT", 10250 ctype, name, current_class_type); 10251 return error_mark_node; 10252 } 10253 } 10254 10255 if (ctype == NULL_TREE && decl_context == FIELD && friendp == 0) 10256 ctype = current_class_type; 10257 10258 /* Now TYPE has the actual type. */ 10259 10260 if (returned_attrs) 10261 { 10262 if (attrlist) 10263 *attrlist = chainon (returned_attrs, *attrlist); 10264 else 10265 attrlist = &returned_attrs; 10266 } 10267 10268 if (declarator 10269 && declarator->kind == cdk_id 10270 && declarator->std_attributes) 10271 /* [dcl.meaning]/1: The optional attribute-specifier-seq following 10272 a declarator-id appertains to the entity that is declared. */ 10273 *attrlist = chainon (*attrlist, declarator->std_attributes); 10274 10275 /* Handle parameter packs. */ 10276 if (parameter_pack_p) 10277 { 10278 if (decl_context == PARM) 10279 /* Turn the type into a pack expansion.*/ 10280 type = make_pack_expansion (type); 10281 else 10282 error ("non-parameter %qs cannot be a parameter pack", name); 10283 } 10284 10285 /* Did array size calculations overflow or does the array cover more 10286 than half of the address-space? */ 10287 if (TREE_CODE (type) == ARRAY_TYPE 10288 && COMPLETE_TYPE_P (type) 10289 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST 10290 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type))) 10291 { 10292 error ("size of array %qs is too large", name); 10293 /* If we proceed with the array type as it is, we'll eventually 10294 crash in tree_to_[su]hwi(). */ 10295 type = error_mark_node; 10296 } 10297 10298 if ((decl_context == FIELD || decl_context == PARM) 10299 && !processing_template_decl 10300 && variably_modified_type_p (type, NULL_TREE)) 10301 { 10302 if (decl_context == FIELD) 10303 error ("data member may not have variably modified type %qT", type); 10304 else 10305 error ("parameter may not have variably modified type %qT", type); 10306 type = error_mark_node; 10307 } 10308 10309 if (explicitp == 1 || (explicitp && friendp)) 10310 { 10311 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only 10312 in the declaration of a constructor or conversion function within 10313 a class definition. */ 10314 if (!current_class_type) 10315 error ("%<explicit%> outside class declaration"); 10316 else if (friendp) 10317 error ("%<explicit%> in friend declaration"); 10318 else 10319 error ("only declarations of constructors and conversion operators " 10320 "can be %<explicit%>"); 10321 explicitp = 0; 10322 } 10323 10324 if (storage_class == sc_mutable) 10325 { 10326 if (decl_context != FIELD || friendp) 10327 { 10328 error ("non-member %qs cannot be declared %<mutable%>", name); 10329 storage_class = sc_none; 10330 } 10331 else if (decl_context == TYPENAME || typedef_p) 10332 { 10333 error ("non-object member %qs cannot be declared %<mutable%>", name); 10334 storage_class = sc_none; 10335 } 10336 else if (TREE_CODE (type) == FUNCTION_TYPE 10337 || TREE_CODE (type) == METHOD_TYPE) 10338 { 10339 error ("function %qs cannot be declared %<mutable%>", name); 10340 storage_class = sc_none; 10341 } 10342 else if (staticp) 10343 { 10344 error ("static %qs cannot be declared %<mutable%>", name); 10345 storage_class = sc_none; 10346 } 10347 else if (type_quals & TYPE_QUAL_CONST) 10348 { 10349 error ("const %qs cannot be declared %<mutable%>", name); 10350 storage_class = sc_none; 10351 } 10352 else if (TREE_CODE (type) == REFERENCE_TYPE) 10353 { 10354 permerror (input_location, "reference %qs cannot be declared " 10355 "%<mutable%>", name); 10356 storage_class = sc_none; 10357 } 10358 } 10359 10360 /* If this is declaring a typedef name, return a TYPE_DECL. */ 10361 if (typedef_p && decl_context != TYPENAME) 10362 { 10363 tree decl; 10364 10365 /* Note that the grammar rejects storage classes 10366 in typenames, fields or parameters. */ 10367 if (current_lang_name == lang_name_java) 10368 TYPE_FOR_JAVA (type) = 1; 10369 10370 /* This declaration: 10371 10372 typedef void f(int) const; 10373 10374 declares a function type which is not a member of any 10375 particular class, but which is cv-qualified; for 10376 example "f S::*" declares a pointer to a const-qualified 10377 member function of S. We record the cv-qualification in the 10378 function type. */ 10379 if ((rqual || memfn_quals) && TREE_CODE (type) == FUNCTION_TYPE) 10380 { 10381 type = apply_memfn_quals (type, memfn_quals, rqual); 10382 10383 /* We have now dealt with these qualifiers. */ 10384 memfn_quals = TYPE_UNQUALIFIED; 10385 rqual = REF_QUAL_NONE; 10386 } 10387 10388 if (type_uses_auto (type)) 10389 { 10390 error ("typedef declared %<auto%>"); 10391 type = error_mark_node; 10392 } 10393 10394 if (decl_context == FIELD) 10395 decl = build_lang_decl (TYPE_DECL, unqualified_id, type); 10396 else 10397 decl = build_decl (input_location, TYPE_DECL, unqualified_id, type); 10398 if (id_declarator && declarator->u.id.qualifying_scope) { 10399 error_at (DECL_SOURCE_LOCATION (decl), 10400 "typedef name may not be a nested-name-specifier"); 10401 TREE_TYPE (decl) = error_mark_node; 10402 } 10403 10404 if (decl_context != FIELD) 10405 { 10406 if (!current_function_decl) 10407 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); 10408 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl) 10409 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P 10410 (current_function_decl))) 10411 /* The TYPE_DECL is "abstract" because there will be 10412 clones of this constructor/destructor, and there will 10413 be copies of this TYPE_DECL generated in those 10414 clones. The decloning optimization (for space) may 10415 revert this subsequently if it determines that 10416 the clones should share a common implementation. */ 10417 DECL_ABSTRACT_P (decl) = true; 10418 } 10419 else if (current_class_type 10420 && constructor_name_p (unqualified_id, current_class_type)) 10421 permerror (input_location, "ISO C++ forbids nested type %qD with same name " 10422 "as enclosing class", 10423 unqualified_id); 10424 10425 /* If the user declares "typedef struct {...} foo" then the 10426 struct will have an anonymous name. Fill that name in now. 10427 Nothing can refer to it, so nothing needs know about the name 10428 change. */ 10429 if (type != error_mark_node 10430 && unqualified_id 10431 && TYPE_NAME (type) 10432 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 10433 && TYPE_ANONYMOUS_P (type) 10434 && declspecs->type_definition_p 10435 && attributes_naming_typedef_ok (*attrlist) 10436 && cp_type_quals (type) == TYPE_UNQUALIFIED) 10437 { 10438 tree t; 10439 10440 /* Replace the anonymous name with the real name everywhere. */ 10441 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 10442 { 10443 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))) 10444 /* We do not rename the debug info representing the 10445 anonymous tagged type because the standard says in 10446 [dcl.typedef] that the naming applies only for 10447 linkage purposes. */ 10448 /*debug_hooks->set_name (t, decl);*/ 10449 TYPE_NAME (t) = decl; 10450 } 10451 10452 if (TYPE_LANG_SPECIFIC (type)) 10453 TYPE_WAS_ANONYMOUS (type) = 1; 10454 10455 /* If this is a typedef within a template class, the nested 10456 type is a (non-primary) template. The name for the 10457 template needs updating as well. */ 10458 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type)) 10459 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)) 10460 = TYPE_IDENTIFIER (type); 10461 10462 /* Adjust linkage now that we aren't anonymous anymore. */ 10463 reset_type_linkage (type); 10464 10465 /* FIXME remangle member functions; member functions of a 10466 type with external linkage have external linkage. */ 10467 } 10468 10469 if (signed_p 10470 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))) 10471 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1; 10472 10473 bad_specifiers (decl, BSP_TYPE, virtualp, 10474 memfn_quals != TYPE_UNQUALIFIED, 10475 inlinep, friendp, raises != NULL_TREE); 10476 10477 if (decl_spec_seq_has_spec_p (declspecs, ds_alias)) 10478 /* Acknowledge that this was written: 10479 `using analias = atype;'. */ 10480 TYPE_DECL_ALIAS_P (decl) = 1; 10481 10482 return decl; 10483 } 10484 10485 /* Detect the case of an array type of unspecified size 10486 which came, as such, direct from a typedef name. 10487 We must copy the type, so that the array's domain can be 10488 individually set by the object's initializer. */ 10489 10490 if (type && typedef_type 10491 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type) 10492 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)) 10493 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE); 10494 10495 /* Detect where we're using a typedef of function type to declare a 10496 function. PARMS will not be set, so we must create it now. */ 10497 10498 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE) 10499 { 10500 tree decls = NULL_TREE; 10501 tree args; 10502 10503 for (args = TYPE_ARG_TYPES (type); 10504 args && args != void_list_node; 10505 args = TREE_CHAIN (args)) 10506 { 10507 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args)); 10508 10509 DECL_CHAIN (decl) = decls; 10510 decls = decl; 10511 } 10512 10513 parms = nreverse (decls); 10514 10515 if (decl_context != TYPENAME) 10516 { 10517 /* The qualifiers on the function type become the qualifiers on 10518 the non-static member function. */ 10519 memfn_quals |= type_memfn_quals (type); 10520 rqual = type_memfn_rqual (type); 10521 type_quals = TYPE_UNQUALIFIED; 10522 } 10523 } 10524 10525 /* If this is a type name (such as, in a cast or sizeof), 10526 compute the type and return it now. */ 10527 10528 if (decl_context == TYPENAME) 10529 { 10530 /* Note that the grammar rejects storage classes 10531 in typenames, fields or parameters. */ 10532 if (type_quals != TYPE_UNQUALIFIED) 10533 type_quals = TYPE_UNQUALIFIED; 10534 10535 /* Special case: "friend class foo" looks like a TYPENAME context. */ 10536 if (friendp) 10537 { 10538 if (type_quals != TYPE_UNQUALIFIED) 10539 { 10540 error ("type qualifiers specified for friend class declaration"); 10541 type_quals = TYPE_UNQUALIFIED; 10542 } 10543 if (inlinep) 10544 { 10545 error ("%<inline%> specified for friend class declaration"); 10546 inlinep = 0; 10547 } 10548 10549 if (!current_aggr) 10550 { 10551 /* Don't allow friend declaration without a class-key. */ 10552 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM) 10553 permerror (input_location, "template parameters cannot be friends"); 10554 else if (TREE_CODE (type) == TYPENAME_TYPE) 10555 permerror (input_location, "friend declaration requires class-key, " 10556 "i.e. %<friend class %T::%D%>", 10557 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type)); 10558 else 10559 permerror (input_location, "friend declaration requires class-key, " 10560 "i.e. %<friend %#T%>", 10561 type); 10562 } 10563 10564 /* Only try to do this stuff if we didn't already give up. */ 10565 if (type != integer_type_node) 10566 { 10567 /* A friendly class? */ 10568 if (current_class_type) 10569 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type), 10570 /*complain=*/true); 10571 else 10572 error ("trying to make class %qT a friend of global scope", 10573 type); 10574 10575 type = void_type_node; 10576 } 10577 } 10578 else if (memfn_quals || rqual) 10579 { 10580 if (ctype == NULL_TREE 10581 && TREE_CODE (type) == METHOD_TYPE) 10582 ctype = TYPE_METHOD_BASETYPE (type); 10583 10584 if (ctype) 10585 type = build_memfn_type (type, ctype, memfn_quals, rqual); 10586 /* Core issue #547: need to allow this in template type args. 10587 Allow it in general in C++11 for alias-declarations. */ 10588 else if ((template_type_arg || cxx_dialect >= cxx11) 10589 && TREE_CODE (type) == FUNCTION_TYPE) 10590 type = apply_memfn_quals (type, memfn_quals, rqual); 10591 else 10592 error ("invalid qualifiers on non-member function type"); 10593 } 10594 10595 return type; 10596 } 10597 else if (unqualified_id == NULL_TREE && decl_context != PARM 10598 && decl_context != CATCHPARM 10599 && TREE_CODE (type) != UNION_TYPE 10600 && ! bitfield) 10601 { 10602 error ("abstract declarator %qT used as declaration", type); 10603 return error_mark_node; 10604 } 10605 10606 /* Only functions may be declared using an operator-function-id. */ 10607 if (unqualified_id 10608 && IDENTIFIER_OPNAME_P (unqualified_id) 10609 && TREE_CODE (type) != FUNCTION_TYPE 10610 && TREE_CODE (type) != METHOD_TYPE) 10611 { 10612 error ("declaration of %qD as non-function", unqualified_id); 10613 return error_mark_node; 10614 } 10615 10616 /* We don't check parameter types here because we can emit a better 10617 error message later. */ 10618 if (decl_context != PARM) 10619 { 10620 type = check_var_type (unqualified_id, type); 10621 if (type == error_mark_node) 10622 return error_mark_node; 10623 } 10624 10625 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL 10626 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */ 10627 10628 if (decl_context == PARM || decl_context == CATCHPARM) 10629 { 10630 if (ctype || in_namespace) 10631 error ("cannot use %<::%> in parameter declaration"); 10632 10633 if (type_uses_auto (type)) 10634 { 10635 if (cxx_dialect >= cxx14) 10636 error ("%<auto%> parameter not permitted in this context"); 10637 else 10638 error ("parameter declared %<auto%>"); 10639 type = error_mark_node; 10640 } 10641 10642 /* A parameter declared as an array of T is really a pointer to T. 10643 One declared as a function is really a pointer to a function. 10644 One declared as a member is really a pointer to member. */ 10645 10646 if (TREE_CODE (type) == ARRAY_TYPE) 10647 { 10648 /* Transfer const-ness of array into that of type pointed to. */ 10649 type = build_pointer_type (TREE_TYPE (type)); 10650 type_quals = TYPE_UNQUALIFIED; 10651 array_parameter_p = true; 10652 } 10653 else if (TREE_CODE (type) == FUNCTION_TYPE) 10654 type = build_pointer_type (type); 10655 } 10656 10657 if (ctype && TREE_CODE (type) == FUNCTION_TYPE && staticp < 2 10658 && !NEW_DELETE_OPNAME_P (unqualified_id)) 10659 { 10660 cp_cv_quals real_quals = memfn_quals; 10661 if (cxx_dialect < cxx14 && constexpr_p 10662 && sfk != sfk_constructor && sfk != sfk_destructor) 10663 real_quals |= TYPE_QUAL_CONST; 10664 type = build_memfn_type (type, ctype, real_quals, rqual); 10665 } 10666 10667 { 10668 tree decl; 10669 10670 if (decl_context == PARM) 10671 { 10672 decl = cp_build_parm_decl (unqualified_id, type); 10673 DECL_ARRAY_PARAMETER_P (decl) = array_parameter_p; 10674 10675 bad_specifiers (decl, BSP_PARM, virtualp, 10676 memfn_quals != TYPE_UNQUALIFIED, 10677 inlinep, friendp, raises != NULL_TREE); 10678 } 10679 else if (decl_context == FIELD) 10680 { 10681 if (!staticp && !friendp && TREE_CODE (type) != METHOD_TYPE 10682 && type_uses_auto (type)) 10683 { 10684 error ("non-static data member declared %<auto%>"); 10685 type = error_mark_node; 10686 } 10687 10688 /* The C99 flexible array extension. */ 10689 if (!staticp && TREE_CODE (type) == ARRAY_TYPE 10690 && TYPE_DOMAIN (type) == NULL_TREE) 10691 { 10692 tree itype = compute_array_index_type (dname, integer_zero_node, 10693 tf_warning_or_error); 10694 type = build_cplus_array_type (TREE_TYPE (type), itype); 10695 } 10696 10697 if (type == error_mark_node) 10698 { 10699 /* Happens when declaring arrays of sizes which 10700 are error_mark_node, for example. */ 10701 decl = NULL_TREE; 10702 } 10703 else if (in_namespace && !friendp) 10704 { 10705 /* Something like struct S { int N::j; }; */ 10706 error ("invalid use of %<::%>"); 10707 return error_mark_node; 10708 } 10709 else if (TREE_CODE (type) == FUNCTION_TYPE 10710 || TREE_CODE (type) == METHOD_TYPE) 10711 { 10712 int publicp = 0; 10713 tree function_context; 10714 10715 if (friendp == 0) 10716 { 10717 /* This should never happen in pure C++ (the check 10718 could be an assert). It could happen in 10719 Objective-C++ if someone writes invalid code that 10720 uses a function declaration for an instance 10721 variable or property (instance variables and 10722 properties are parsed as FIELD_DECLs, but they are 10723 part of an Objective-C class, not a C++ class). 10724 That code is invalid and is caught by this 10725 check. */ 10726 if (!ctype) 10727 { 10728 error ("declaration of function %qD in invalid context", 10729 unqualified_id); 10730 return error_mark_node; 10731 } 10732 10733 /* ``A union may [ ... ] not [ have ] virtual functions.'' 10734 ARM 9.5 */ 10735 if (virtualp && TREE_CODE (ctype) == UNION_TYPE) 10736 { 10737 error ("function %qD declared virtual inside a union", 10738 unqualified_id); 10739 return error_mark_node; 10740 } 10741 10742 if (NEW_DELETE_OPNAME_P (unqualified_id)) 10743 { 10744 if (virtualp) 10745 { 10746 error ("%qD cannot be declared virtual, since it " 10747 "is always static", 10748 unqualified_id); 10749 virtualp = 0; 10750 } 10751 } 10752 } 10753 10754 /* Check that the name used for a destructor makes sense. */ 10755 if (sfk == sfk_destructor) 10756 { 10757 tree uqname = id_declarator->u.id.unqualified_name; 10758 10759 if (!ctype) 10760 { 10761 gcc_assert (friendp); 10762 error ("expected qualified name in friend declaration " 10763 "for destructor %qD", uqname); 10764 return error_mark_node; 10765 } 10766 10767 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0))) 10768 { 10769 error ("declaration of %qD as member of %qT", 10770 uqname, ctype); 10771 return error_mark_node; 10772 } 10773 if (constexpr_p) 10774 { 10775 error ("a destructor cannot be %<constexpr%>"); 10776 return error_mark_node; 10777 } 10778 } 10779 else if (sfk == sfk_constructor && friendp && !ctype) 10780 { 10781 error ("expected qualified name in friend declaration " 10782 "for constructor %qD", 10783 id_declarator->u.id.unqualified_name); 10784 return error_mark_node; 10785 } 10786 10787 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR) 10788 { 10789 tree tmpl = TREE_OPERAND (unqualified_id, 0); 10790 if (variable_template_p (tmpl)) 10791 { 10792 error ("specialization of variable template %qD " 10793 "declared as function", tmpl); 10794 inform (DECL_SOURCE_LOCATION (tmpl), 10795 "variable template declared here"); 10796 return error_mark_node; 10797 } 10798 } 10799 10800 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */ 10801 function_context = (ctype != NULL_TREE) ? 10802 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE; 10803 publicp = (! friendp || ! staticp) 10804 && function_context == NULL_TREE; 10805 10806 if (late_return_type_p) 10807 TYPE_HAS_LATE_RETURN_TYPE (type) = 1; 10808 10809 decl = grokfndecl (ctype, type, 10810 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR 10811 ? unqualified_id : dname, 10812 parms, 10813 unqualified_id, 10814 virtualp, flags, memfn_quals, rqual, raises, 10815 friendp ? -1 : 0, friendp, publicp, 10816 inlinep | (2 * constexpr_p), 10817 initialized == SD_DELETED, sfk, 10818 funcdef_flag, template_count, in_namespace, 10819 attrlist, declarator->id_loc); 10820 decl = set_virt_specifiers (decl, virt_specifiers); 10821 if (decl == NULL_TREE) 10822 return error_mark_node; 10823#if 0 10824 /* This clobbers the attrs stored in `decl' from `attrlist'. */ 10825 /* The decl and setting of decl_attr is also turned off. */ 10826 decl = build_decl_attribute_variant (decl, decl_attr); 10827#endif 10828 10829 /* [class.conv.ctor] 10830 10831 A constructor declared without the function-specifier 10832 explicit that can be called with a single parameter 10833 specifies a conversion from the type of its first 10834 parameter to the type of its class. Such a constructor 10835 is called a converting constructor. */ 10836 if (explicitp == 2) 10837 DECL_NONCONVERTING_P (decl) = 1; 10838 } 10839 else if (!staticp && !dependent_type_p (type) 10840 && !COMPLETE_TYPE_P (complete_type (type)) 10841 && (TREE_CODE (type) != ARRAY_TYPE 10842 || !COMPLETE_TYPE_P (TREE_TYPE (type)) 10843 || initialized == 0)) 10844 { 10845 if (unqualified_id) 10846 { 10847 error ("field %qD has incomplete type %qT", 10848 unqualified_id, type); 10849 cxx_incomplete_type_inform (strip_array_types (type)); 10850 } 10851 else 10852 error ("name %qT has incomplete type", type); 10853 10854 type = error_mark_node; 10855 decl = NULL_TREE; 10856 } 10857 else 10858 { 10859 if (friendp) 10860 { 10861 error ("%qE is neither function nor member function; " 10862 "cannot be declared friend", unqualified_id); 10863 friendp = 0; 10864 } 10865 decl = NULL_TREE; 10866 } 10867 10868 if (friendp) 10869 { 10870 /* Friends are treated specially. */ 10871 if (ctype == current_class_type) 10872 ; /* We already issued a permerror. */ 10873 else if (decl && DECL_NAME (decl)) 10874 { 10875 if (template_class_depth (current_class_type) == 0) 10876 { 10877 decl = check_explicit_specialization 10878 (unqualified_id, decl, template_count, 10879 2 * funcdef_flag + 4); 10880 if (decl == error_mark_node) 10881 return error_mark_node; 10882 } 10883 10884 decl = do_friend (ctype, unqualified_id, decl, 10885 *attrlist, flags, 10886 funcdef_flag); 10887 return decl; 10888 } 10889 else 10890 return error_mark_node; 10891 } 10892 10893 /* Structure field. It may not be a function, except for C++. */ 10894 10895 if (decl == NULL_TREE) 10896 { 10897 if (staticp) 10898 { 10899 /* C++ allows static class members. All other work 10900 for this is done by grokfield. */ 10901 decl = build_lang_decl_loc (declarator 10902 ? declarator->id_loc 10903 : input_location, 10904 VAR_DECL, unqualified_id, type); 10905 set_linkage_for_static_data_member (decl); 10906 /* Even if there is an in-class initialization, DECL 10907 is considered undefined until an out-of-class 10908 definition is provided. */ 10909 DECL_EXTERNAL (decl) = 1; 10910 10911 if (thread_p) 10912 { 10913 set_decl_tls_model (decl, decl_default_tls_model (decl)); 10914 if (declspecs->gnu_thread_keyword_p) 10915 DECL_GNU_TLS_P (decl) = true; 10916 } 10917 10918 if (constexpr_p && !initialized) 10919 { 10920 error ("constexpr static data member %qD must have an " 10921 "initializer", decl); 10922 constexpr_p = false; 10923 } 10924 } 10925 else 10926 { 10927 if (constexpr_p) 10928 { 10929 error ("non-static data member %qE declared %<constexpr%>", 10930 unqualified_id); 10931 constexpr_p = false; 10932 } 10933 decl = build_decl (input_location, 10934 FIELD_DECL, unqualified_id, type); 10935 DECL_NONADDRESSABLE_P (decl) = bitfield; 10936 if (bitfield && !unqualified_id) 10937 TREE_NO_WARNING (decl) = 1; 10938 10939 if (storage_class == sc_mutable) 10940 { 10941 DECL_MUTABLE_P (decl) = 1; 10942 storage_class = sc_none; 10943 } 10944 10945 if (initialized) 10946 { 10947 /* An attempt is being made to initialize a non-static 10948 member. This is new in C++11. */ 10949 maybe_warn_cpp0x (CPP0X_NSDMI); 10950 10951 /* If this has been parsed with static storage class, but 10952 errors forced staticp to be cleared, ensure NSDMI is 10953 not present. */ 10954 if (declspecs->storage_class == sc_static) 10955 DECL_INITIAL (decl) = error_mark_node; 10956 } 10957 } 10958 10959 bad_specifiers (decl, BSP_FIELD, virtualp, 10960 memfn_quals != TYPE_UNQUALIFIED, 10961 inlinep, friendp, raises != NULL_TREE); 10962 } 10963 } 10964 else if (TREE_CODE (type) == FUNCTION_TYPE 10965 || TREE_CODE (type) == METHOD_TYPE) 10966 { 10967 tree original_name; 10968 int publicp = 0; 10969 10970 if (!unqualified_id) 10971 return error_mark_node; 10972 10973 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR) 10974 original_name = dname; 10975 else 10976 original_name = unqualified_id; 10977 10978 if (storage_class == sc_auto) 10979 error ("storage class %<auto%> invalid for function %qs", name); 10980 else if (storage_class == sc_register) 10981 error ("storage class %<register%> invalid for function %qs", name); 10982 else if (thread_p) 10983 { 10984 if (declspecs->gnu_thread_keyword_p) 10985 error ("storage class %<__thread%> invalid for function %qs", 10986 name); 10987 else 10988 error ("storage class %<thread_local%> invalid for function %qs", 10989 name); 10990 } 10991 10992 if (virt_specifiers) 10993 error ("virt-specifiers in %qs not allowed outside a class definition", name); 10994 /* Function declaration not at top level. 10995 Storage classes other than `extern' are not allowed 10996 and `extern' makes no difference. */ 10997 if (! toplevel_bindings_p () 10998 && (storage_class == sc_static 10999 || decl_spec_seq_has_spec_p (declspecs, ds_inline)) 11000 && pedantic) 11001 { 11002 if (storage_class == sc_static) 11003 pedwarn (input_location, OPT_Wpedantic, 11004 "%<static%> specified invalid for function %qs " 11005 "declared out of global scope", name); 11006 else 11007 pedwarn (input_location, OPT_Wpedantic, 11008 "%<inline%> specifier invalid for function %qs " 11009 "declared out of global scope", name); 11010 } 11011 11012 if (ctype == NULL_TREE) 11013 { 11014 if (virtualp) 11015 { 11016 error ("virtual non-class function %qs", name); 11017 virtualp = 0; 11018 } 11019 else if (sfk == sfk_constructor 11020 || sfk == sfk_destructor) 11021 { 11022 error (funcdef_flag 11023 ? G_("%qs defined in a non-class scope") 11024 : G_("%qs declared in a non-class scope"), name); 11025 sfk = sfk_none; 11026 } 11027 } 11028 11029 /* Record whether the function is public. */ 11030 publicp = (ctype != NULL_TREE 11031 || storage_class != sc_static); 11032 11033 if (late_return_type_p) 11034 TYPE_HAS_LATE_RETURN_TYPE (type) = 1; 11035 11036 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id, 11037 virtualp, flags, memfn_quals, rqual, raises, 11038 1, friendp, 11039 publicp, inlinep | (2 * constexpr_p), 11040 initialized == SD_DELETED, sfk, 11041 funcdef_flag, 11042 template_count, in_namespace, attrlist, 11043 declarator->id_loc); 11044 if (decl == NULL_TREE) 11045 return error_mark_node; 11046 11047 if (staticp == 1) 11048 { 11049 int invalid_static = 0; 11050 11051 /* Don't allow a static member function in a class, and forbid 11052 declaring main to be static. */ 11053 if (TREE_CODE (type) == METHOD_TYPE) 11054 { 11055 permerror (input_location, "cannot declare member function %qD to have " 11056 "static linkage", decl); 11057 invalid_static = 1; 11058 } 11059 else if (current_function_decl) 11060 { 11061 /* FIXME need arm citation */ 11062 error ("cannot declare static function inside another function"); 11063 invalid_static = 1; 11064 } 11065 11066 if (invalid_static) 11067 { 11068 staticp = 0; 11069 storage_class = sc_none; 11070 } 11071 } 11072 } 11073 else 11074 { 11075 /* It's a variable. */ 11076 11077 /* An uninitialized decl with `extern' is a reference. */ 11078 decl = grokvardecl (type, dname, unqualified_id, 11079 declspecs, 11080 initialized, 11081 (type_quals & TYPE_QUAL_CONST) != 0, 11082 template_count, 11083 ctype ? ctype : in_namespace); 11084 if (decl == NULL_TREE) 11085 return error_mark_node; 11086 11087 bad_specifiers (decl, BSP_VAR, virtualp, 11088 memfn_quals != TYPE_UNQUALIFIED, 11089 inlinep, friendp, raises != NULL_TREE); 11090 11091 if (ctype) 11092 { 11093 DECL_CONTEXT (decl) = ctype; 11094 if (staticp == 1) 11095 { 11096 permerror (input_location, "%<static%> may not be used when defining " 11097 "(as opposed to declaring) a static data member"); 11098 staticp = 0; 11099 storage_class = sc_none; 11100 } 11101 if (storage_class == sc_register && TREE_STATIC (decl)) 11102 { 11103 error ("static member %qD declared %<register%>", decl); 11104 storage_class = sc_none; 11105 } 11106 if (storage_class == sc_extern && pedantic) 11107 { 11108 pedwarn (input_location, OPT_Wpedantic, 11109 "cannot explicitly declare member %q#D to have " 11110 "extern linkage", decl); 11111 storage_class = sc_none; 11112 } 11113 } 11114 else if (constexpr_p && DECL_EXTERNAL (decl)) 11115 { 11116 error ("declaration of constexpr variable %qD is not a definition", 11117 decl); 11118 constexpr_p = false; 11119 } 11120 } 11121 11122 if (storage_class == sc_extern && initialized && !funcdef_flag) 11123 { 11124 if (toplevel_bindings_p ()) 11125 { 11126 /* It's common practice (and completely valid) to have a const 11127 be initialized and declared extern. */ 11128 if (!(type_quals & TYPE_QUAL_CONST)) 11129 warning (0, "%qs initialized and declared %<extern%>", name); 11130 } 11131 else 11132 { 11133 error ("%qs has both %<extern%> and initializer", name); 11134 return error_mark_node; 11135 } 11136 } 11137 11138 /* Record `register' declaration for warnings on & 11139 and in case doing stupid register allocation. */ 11140 11141 if (storage_class == sc_register) 11142 DECL_REGISTER (decl) = 1; 11143 else if (storage_class == sc_extern) 11144 DECL_THIS_EXTERN (decl) = 1; 11145 else if (storage_class == sc_static) 11146 DECL_THIS_STATIC (decl) = 1; 11147 11148 /* Set constexpr flag on vars (functions got it in grokfndecl). */ 11149 if (constexpr_p && VAR_P (decl)) 11150 DECL_DECLARED_CONSTEXPR_P (decl) = true; 11151 11152 /* Record constancy and volatility on the DECL itself . There's 11153 no need to do this when processing a template; we'll do this 11154 for the instantiated declaration based on the type of DECL. */ 11155 if (!processing_template_decl) 11156 cp_apply_type_quals_to_decl (type_quals, decl); 11157 11158 return decl; 11159 } 11160} 11161 11162/* Subroutine of start_function. Ensure that each of the parameter 11163 types (as listed in PARMS) is complete, as is required for a 11164 function definition. */ 11165 11166static void 11167require_complete_types_for_parms (tree parms) 11168{ 11169 for (; parms; parms = DECL_CHAIN (parms)) 11170 { 11171 if (dependent_type_p (TREE_TYPE (parms))) 11172 continue; 11173 if (!VOID_TYPE_P (TREE_TYPE (parms)) 11174 && complete_type_or_else (TREE_TYPE (parms), parms)) 11175 { 11176 relayout_decl (parms); 11177 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms)); 11178 } 11179 else 11180 /* grokparms or complete_type_or_else will have already issued 11181 an error. */ 11182 TREE_TYPE (parms) = error_mark_node; 11183 } 11184} 11185 11186/* Returns nonzero if T is a local variable. */ 11187 11188int 11189local_variable_p (const_tree t) 11190{ 11191 if ((VAR_P (t) 11192 /* A VAR_DECL with a context that is a _TYPE is a static data 11193 member. */ 11194 && !TYPE_P (CP_DECL_CONTEXT (t)) 11195 /* Any other non-local variable must be at namespace scope. */ 11196 && !DECL_NAMESPACE_SCOPE_P (t)) 11197 || (TREE_CODE (t) == PARM_DECL)) 11198 return 1; 11199 11200 return 0; 11201} 11202 11203/* Like local_variable_p, but suitable for use as a tree-walking 11204 function. */ 11205 11206static tree 11207local_variable_p_walkfn (tree *tp, int *walk_subtrees, 11208 void * /*data*/) 11209{ 11210 if (local_variable_p (*tp) 11211 && (!DECL_ARTIFICIAL (*tp) || DECL_NAME (*tp) == this_identifier)) 11212 return *tp; 11213 else if (TYPE_P (*tp)) 11214 *walk_subtrees = 0; 11215 11216 return NULL_TREE; 11217} 11218 11219/* Check that ARG, which is a default-argument expression for a 11220 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if 11221 something goes wrong. DECL may also be a _TYPE node, rather than a 11222 DECL, if there is no DECL available. */ 11223 11224tree 11225check_default_argument (tree decl, tree arg, tsubst_flags_t complain) 11226{ 11227 tree var; 11228 tree decl_type; 11229 11230 if (TREE_CODE (arg) == DEFAULT_ARG) 11231 /* We get a DEFAULT_ARG when looking at an in-class declaration 11232 with a default argument. Ignore the argument for now; we'll 11233 deal with it after the class is complete. */ 11234 return arg; 11235 11236 if (TYPE_P (decl)) 11237 { 11238 decl_type = decl; 11239 decl = NULL_TREE; 11240 } 11241 else 11242 decl_type = TREE_TYPE (decl); 11243 11244 if (arg == error_mark_node 11245 || decl == error_mark_node 11246 || TREE_TYPE (arg) == error_mark_node 11247 || decl_type == error_mark_node) 11248 /* Something already went wrong. There's no need to check 11249 further. */ 11250 return error_mark_node; 11251 11252 /* [dcl.fct.default] 11253 11254 A default argument expression is implicitly converted to the 11255 parameter type. */ 11256 ++cp_unevaluated_operand; 11257 perform_implicit_conversion_flags (decl_type, arg, complain, 11258 LOOKUP_IMPLICIT); 11259 --cp_unevaluated_operand; 11260 11261 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at 11262 the call sites. */ 11263 if (TYPE_PTR_OR_PTRMEM_P (decl_type) 11264 && null_ptr_cst_p (arg)) 11265 return nullptr_node; 11266 11267 /* [dcl.fct.default] 11268 11269 Local variables shall not be used in default argument 11270 expressions. 11271 11272 The keyword `this' shall not be used in a default argument of a 11273 member function. */ 11274 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL); 11275 if (var) 11276 { 11277 if (complain & tf_warning_or_error) 11278 { 11279 if (DECL_NAME (var) == this_identifier) 11280 permerror (input_location, "default argument %qE uses %qD", 11281 arg, var); 11282 else 11283 error ("default argument %qE uses local variable %qD", arg, var); 11284 } 11285 return error_mark_node; 11286 } 11287 11288 /* All is well. */ 11289 return arg; 11290} 11291 11292/* Returns a deprecated type used within TYPE, or NULL_TREE if none. */ 11293 11294static tree 11295type_is_deprecated (tree type) 11296{ 11297 enum tree_code code; 11298 if (TREE_DEPRECATED (type)) 11299 return type; 11300 if (TYPE_NAME (type) 11301 && TREE_DEPRECATED (TYPE_NAME (type))) 11302 return type; 11303 11304 /* Do warn about using typedefs to a deprecated class. */ 11305 if (OVERLOAD_TYPE_P (type) && type != TYPE_MAIN_VARIANT (type)) 11306 return type_is_deprecated (TYPE_MAIN_VARIANT (type)); 11307 11308 code = TREE_CODE (type); 11309 11310 if (code == POINTER_TYPE || code == REFERENCE_TYPE 11311 || code == OFFSET_TYPE || code == FUNCTION_TYPE 11312 || code == METHOD_TYPE || code == ARRAY_TYPE) 11313 return type_is_deprecated (TREE_TYPE (type)); 11314 11315 if (TYPE_PTRMEMFUNC_P (type)) 11316 return type_is_deprecated 11317 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type)))); 11318 11319 return NULL_TREE; 11320} 11321 11322/* Decode the list of parameter types for a function type. 11323 Given the list of things declared inside the parens, 11324 return a list of types. 11325 11326 If this parameter does not end with an ellipsis, we append 11327 void_list_node. 11328 11329 *PARMS is set to the chain of PARM_DECLs created. */ 11330 11331static tree 11332grokparms (tree parmlist, tree *parms) 11333{ 11334 tree result = NULL_TREE; 11335 tree decls = NULL_TREE; 11336 tree parm; 11337 int any_error = 0; 11338 11339 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm)) 11340 { 11341 tree type = NULL_TREE; 11342 tree init = TREE_PURPOSE (parm); 11343 tree decl = TREE_VALUE (parm); 11344 const char *errmsg; 11345 11346 if (parm == void_list_node) 11347 break; 11348 11349 if (! decl || TREE_TYPE (decl) == error_mark_node) 11350 continue; 11351 11352 type = TREE_TYPE (decl); 11353 if (VOID_TYPE_P (type)) 11354 { 11355 if (same_type_p (type, void_type_node) 11356 && !init 11357 && !DECL_NAME (decl) && !result 11358 && TREE_CHAIN (parm) == void_list_node) 11359 /* DR 577: A parameter list consisting of a single 11360 unnamed parameter of non-dependent type 'void'. */ 11361 break; 11362 else if (cv_qualified_p (type)) 11363 error_at (DECL_SOURCE_LOCATION (decl), 11364 "invalid use of cv-qualified type %qT in " 11365 "parameter declaration", type); 11366 else 11367 error_at (DECL_SOURCE_LOCATION (decl), 11368 "invalid use of type %<void%> in parameter " 11369 "declaration"); 11370 /* It's not a good idea to actually create parameters of 11371 type `void'; other parts of the compiler assume that a 11372 void type terminates the parameter list. */ 11373 type = error_mark_node; 11374 TREE_TYPE (decl) = error_mark_node; 11375 } 11376 11377 if (type != error_mark_node 11378 && TYPE_FOR_JAVA (type) 11379 && MAYBE_CLASS_TYPE_P (type)) 11380 { 11381 error ("parameter %qD has Java class type", decl); 11382 type = error_mark_node; 11383 TREE_TYPE (decl) = error_mark_node; 11384 init = NULL_TREE; 11385 } 11386 11387 if (type != error_mark_node 11388 && (errmsg = targetm.invalid_parameter_type (type))) 11389 { 11390 error (errmsg); 11391 type = error_mark_node; 11392 TREE_TYPE (decl) = error_mark_node; 11393 } 11394 11395 if (type != error_mark_node) 11396 { 11397 if (deprecated_state != DEPRECATED_SUPPRESS) 11398 { 11399 tree deptype = type_is_deprecated (type); 11400 if (deptype) 11401 warn_deprecated_use (deptype, NULL_TREE); 11402 } 11403 11404 /* Top-level qualifiers on the parameters are 11405 ignored for function types. */ 11406 type = cp_build_qualified_type (type, 0); 11407 if (TREE_CODE (type) == METHOD_TYPE) 11408 { 11409 error ("parameter %qD invalidly declared method type", decl); 11410 type = build_pointer_type (type); 11411 TREE_TYPE (decl) = type; 11412 } 11413 else if (abstract_virtuals_error (decl, type)) 11414 any_error = 1; /* Seems like a good idea. */ 11415 else if (POINTER_TYPE_P (type)) 11416 { 11417 /* [dcl.fct]/6, parameter types cannot contain pointers 11418 (references) to arrays of unknown bound. */ 11419 tree t = TREE_TYPE (type); 11420 int ptr = TYPE_PTR_P (type); 11421 11422 while (1) 11423 { 11424 if (TYPE_PTR_P (t)) 11425 ptr = 1; 11426 else if (TREE_CODE (t) != ARRAY_TYPE) 11427 break; 11428 else if (!TYPE_DOMAIN (t)) 11429 break; 11430 t = TREE_TYPE (t); 11431 } 11432 if (TREE_CODE (t) == ARRAY_TYPE) 11433 error (ptr 11434 ? G_("parameter %qD includes pointer to array of " 11435 "unknown bound %qT") 11436 : G_("parameter %qD includes reference to array of " 11437 "unknown bound %qT"), 11438 decl, t); 11439 } 11440 11441 if (any_error) 11442 init = NULL_TREE; 11443 else if (init && !processing_template_decl) 11444 init = check_default_argument (decl, init, tf_warning_or_error); 11445 } 11446 11447 DECL_CHAIN (decl) = decls; 11448 decls = decl; 11449 result = tree_cons (init, type, result); 11450 } 11451 decls = nreverse (decls); 11452 result = nreverse (result); 11453 if (parm) 11454 result = chainon (result, void_list_node); 11455 *parms = decls; 11456 11457 return result; 11458} 11459 11460 11461/* D is a constructor or overloaded `operator='. 11462 11463 Let T be the class in which D is declared. Then, this function 11464 returns: 11465 11466 -1 if D's is an ill-formed constructor or copy assignment operator 11467 whose first parameter is of type `T'. 11468 0 if D is not a copy constructor or copy assignment 11469 operator. 11470 1 if D is a copy constructor or copy assignment operator whose 11471 first parameter is a reference to non-const qualified T. 11472 2 if D is a copy constructor or copy assignment operator whose 11473 first parameter is a reference to const qualified T. 11474 11475 This function can be used as a predicate. Positive values indicate 11476 a copy constructor and nonzero values indicate a copy assignment 11477 operator. */ 11478 11479int 11480copy_fn_p (const_tree d) 11481{ 11482 tree args; 11483 tree arg_type; 11484 int result = 1; 11485 11486 gcc_assert (DECL_FUNCTION_MEMBER_P (d)); 11487 11488 if (TREE_CODE (d) == TEMPLATE_DECL 11489 || (DECL_TEMPLATE_INFO (d) 11490 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d)))) 11491 /* Instantiations of template member functions are never copy 11492 functions. Note that member functions of templated classes are 11493 represented as template functions internally, and we must 11494 accept those as copy functions. */ 11495 return 0; 11496 11497 args = FUNCTION_FIRST_USER_PARMTYPE (d); 11498 if (!args) 11499 return 0; 11500 11501 arg_type = TREE_VALUE (args); 11502 if (arg_type == error_mark_node) 11503 return 0; 11504 11505 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d)) 11506 { 11507 /* Pass by value copy assignment operator. */ 11508 result = -1; 11509 } 11510 else if (TREE_CODE (arg_type) == REFERENCE_TYPE 11511 && !TYPE_REF_IS_RVALUE (arg_type) 11512 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d)) 11513 { 11514 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type))) 11515 result = 2; 11516 } 11517 else 11518 return 0; 11519 11520 args = TREE_CHAIN (args); 11521 11522 if (args && args != void_list_node && !TREE_PURPOSE (args)) 11523 /* There are more non-optional args. */ 11524 return 0; 11525 11526 return result; 11527} 11528 11529/* D is a constructor or overloaded `operator='. 11530 11531 Let T be the class in which D is declared. Then, this function 11532 returns true when D is a move constructor or move assignment 11533 operator, false otherwise. */ 11534 11535bool 11536move_fn_p (const_tree d) 11537{ 11538 gcc_assert (DECL_FUNCTION_MEMBER_P (d)); 11539 11540 if (cxx_dialect == cxx98) 11541 /* There are no move constructors if we are in C++98 mode. */ 11542 return false; 11543 11544 if (TREE_CODE (d) == TEMPLATE_DECL 11545 || (DECL_TEMPLATE_INFO (d) 11546 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d)))) 11547 /* Instantiations of template member functions are never move 11548 functions. Note that member functions of templated classes are 11549 represented as template functions internally, and we must 11550 accept those as move functions. */ 11551 return 0; 11552 11553 return move_signature_fn_p (d); 11554} 11555 11556/* D is a constructor or overloaded `operator='. 11557 11558 Then, this function returns true when D has the same signature as a move 11559 constructor or move assignment operator (because either it is such a 11560 ctor/op= or it is a template specialization with the same signature), 11561 false otherwise. */ 11562 11563bool 11564move_signature_fn_p (const_tree d) 11565{ 11566 tree args; 11567 tree arg_type; 11568 bool result = false; 11569 11570 args = FUNCTION_FIRST_USER_PARMTYPE (d); 11571 if (!args) 11572 return 0; 11573 11574 arg_type = TREE_VALUE (args); 11575 if (arg_type == error_mark_node) 11576 return 0; 11577 11578 if (TREE_CODE (arg_type) == REFERENCE_TYPE 11579 && TYPE_REF_IS_RVALUE (arg_type) 11580 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)), 11581 DECL_CONTEXT (d))) 11582 result = true; 11583 11584 args = TREE_CHAIN (args); 11585 11586 if (args && args != void_list_node && !TREE_PURPOSE (args)) 11587 /* There are more non-optional args. */ 11588 return false; 11589 11590 return result; 11591} 11592 11593/* Remember any special properties of member function DECL. */ 11594 11595void 11596grok_special_member_properties (tree decl) 11597{ 11598 tree class_type; 11599 11600 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 11601 return; 11602 11603 class_type = DECL_CONTEXT (decl); 11604 if (DECL_CONSTRUCTOR_P (decl)) 11605 { 11606 int ctor = copy_fn_p (decl); 11607 11608 if (!DECL_ARTIFICIAL (decl)) 11609 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1; 11610 11611 if (ctor > 0) 11612 { 11613 /* [class.copy] 11614 11615 A non-template constructor for class X is a copy 11616 constructor if its first parameter is of type X&, const 11617 X&, volatile X& or const volatile X&, and either there 11618 are no other parameters or else all other parameters have 11619 default arguments. */ 11620 TYPE_HAS_COPY_CTOR (class_type) = 1; 11621 if (user_provided_p (decl)) 11622 TYPE_HAS_COMPLEX_COPY_CTOR (class_type) = 1; 11623 if (ctor > 1) 11624 TYPE_HAS_CONST_COPY_CTOR (class_type) = 1; 11625 } 11626 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl))) 11627 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1; 11628 else if (move_fn_p (decl) && user_provided_p (decl)) 11629 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type) = 1; 11630 else if (is_list_ctor (decl)) 11631 TYPE_HAS_LIST_CTOR (class_type) = 1; 11632 11633 if (DECL_DECLARED_CONSTEXPR_P (decl) 11634 && !copy_fn_p (decl) && !move_fn_p (decl)) 11635 TYPE_HAS_CONSTEXPR_CTOR (class_type) = 1; 11636 } 11637 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR) 11638 { 11639 /* [class.copy] 11640 11641 A non-template assignment operator for class X is a copy 11642 assignment operator if its parameter is of type X, X&, const 11643 X&, volatile X& or const volatile X&. */ 11644 11645 int assop = copy_fn_p (decl); 11646 11647 if (assop) 11648 { 11649 TYPE_HAS_COPY_ASSIGN (class_type) = 1; 11650 if (user_provided_p (decl)) 11651 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type) = 1; 11652 if (assop != 1) 11653 TYPE_HAS_CONST_COPY_ASSIGN (class_type) = 1; 11654 } 11655 else if (move_fn_p (decl) && user_provided_p (decl)) 11656 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type) = 1; 11657 } 11658 /* Destructors are handled in check_methods. */ 11659} 11660 11661/* Check a constructor DECL has the correct form. Complains 11662 if the class has a constructor of the form X(X). */ 11663 11664int 11665grok_ctor_properties (const_tree ctype, const_tree decl) 11666{ 11667 int ctor_parm = copy_fn_p (decl); 11668 11669 if (ctor_parm < 0) 11670 { 11671 /* [class.copy] 11672 11673 A declaration of a constructor for a class X is ill-formed if 11674 its first parameter is of type (optionally cv-qualified) X 11675 and either there are no other parameters or else all other 11676 parameters have default arguments. 11677 11678 We *don't* complain about member template instantiations that 11679 have this form, though; they can occur as we try to decide 11680 what constructor to use during overload resolution. Since 11681 overload resolution will never prefer such a constructor to 11682 the non-template copy constructor (which is either explicitly 11683 or implicitly defined), there's no need to worry about their 11684 existence. Theoretically, they should never even be 11685 instantiated, but that's hard to forestall. */ 11686 error ("invalid constructor; you probably meant %<%T (const %T&)%>", 11687 ctype, ctype); 11688 return 0; 11689 } 11690 11691 return 1; 11692} 11693 11694/* An operator with this code is unary, but can also be binary. */ 11695 11696static int 11697ambi_op_p (enum tree_code code) 11698{ 11699 return (code == INDIRECT_REF 11700 || code == ADDR_EXPR 11701 || code == UNARY_PLUS_EXPR 11702 || code == NEGATE_EXPR 11703 || code == PREINCREMENT_EXPR 11704 || code == PREDECREMENT_EXPR); 11705} 11706 11707/* An operator with this name can only be unary. */ 11708 11709static int 11710unary_op_p (enum tree_code code) 11711{ 11712 return (code == TRUTH_NOT_EXPR 11713 || code == BIT_NOT_EXPR 11714 || code == COMPONENT_REF 11715 || code == TYPE_EXPR); 11716} 11717 11718/* DECL is a declaration for an overloaded operator. If COMPLAIN is true, 11719 errors are issued for invalid declarations. */ 11720 11721bool 11722grok_op_properties (tree decl, bool complain) 11723{ 11724 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl)); 11725 tree argtype; 11726 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE); 11727 tree name = DECL_NAME (decl); 11728 enum tree_code operator_code; 11729 int arity; 11730 bool ellipsis_p; 11731 tree class_type; 11732 11733 /* Count the number of arguments and check for ellipsis. */ 11734 for (argtype = argtypes, arity = 0; 11735 argtype && argtype != void_list_node; 11736 argtype = TREE_CHAIN (argtype)) 11737 ++arity; 11738 ellipsis_p = !argtype; 11739 11740 class_type = DECL_CONTEXT (decl); 11741 if (class_type && !CLASS_TYPE_P (class_type)) 11742 class_type = NULL_TREE; 11743 11744 if (DECL_CONV_FN_P (decl)) 11745 operator_code = TYPE_EXPR; 11746 else 11747 do 11748 { 11749#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \ 11750 if (ansi_opname (CODE) == name) \ 11751 { \ 11752 operator_code = (CODE); \ 11753 break; \ 11754 } \ 11755 else if (ansi_assopname (CODE) == name) \ 11756 { \ 11757 operator_code = (CODE); \ 11758 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \ 11759 break; \ 11760 } 11761 11762#include "operators.def" 11763#undef DEF_OPERATOR 11764 11765 gcc_unreachable (); 11766 } 11767 while (0); 11768 gcc_assert (operator_code != MAX_TREE_CODES); 11769 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code); 11770 11771 if (class_type) 11772 switch (operator_code) 11773 { 11774 case NEW_EXPR: 11775 TYPE_HAS_NEW_OPERATOR (class_type) = 1; 11776 break; 11777 11778 case DELETE_EXPR: 11779 TYPE_GETS_DELETE (class_type) |= 1; 11780 break; 11781 11782 case VEC_NEW_EXPR: 11783 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1; 11784 break; 11785 11786 case VEC_DELETE_EXPR: 11787 TYPE_GETS_DELETE (class_type) |= 2; 11788 break; 11789 11790 default: 11791 break; 11792 } 11793 11794 /* [basic.std.dynamic.allocation]/1: 11795 11796 A program is ill-formed if an allocation function is declared 11797 in a namespace scope other than global scope or declared static 11798 in global scope. 11799 11800 The same also holds true for deallocation functions. */ 11801 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR 11802 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR) 11803 { 11804 if (DECL_NAMESPACE_SCOPE_P (decl)) 11805 { 11806 if (CP_DECL_CONTEXT (decl) != global_namespace) 11807 { 11808 error ("%qD may not be declared within a namespace", decl); 11809 return false; 11810 } 11811 else if (!TREE_PUBLIC (decl)) 11812 { 11813 error ("%qD may not be declared as static", decl); 11814 return false; 11815 } 11816 if (!flag_sized_deallocation && warn_cxx14_compat) 11817 { 11818 tree parm = FUNCTION_ARG_CHAIN (decl); 11819 if (parm && same_type_p (TREE_VALUE (parm), size_type_node) 11820 && TREE_CHAIN (parm) == void_list_node) 11821 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc__14_compat, 11822 "%qD is a usual (non-placement) deallocation " 11823 "function in C++14 (or with -fsized-deallocation)", 11824 decl); 11825 } 11826 } 11827 } 11828 11829 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR) 11830 { 11831 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl)); 11832 DECL_IS_OPERATOR_NEW (decl) = 1; 11833 } 11834 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR) 11835 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl)); 11836 else 11837 { 11838 /* An operator function must either be a non-static member function 11839 or have at least one parameter of a class, a reference to a class, 11840 an enumeration, or a reference to an enumeration. 13.4.0.6 */ 11841 if (! methodp || DECL_STATIC_FUNCTION_P (decl)) 11842 { 11843 if (operator_code == TYPE_EXPR 11844 || operator_code == CALL_EXPR 11845 || operator_code == COMPONENT_REF 11846 || operator_code == ARRAY_REF 11847 || operator_code == NOP_EXPR) 11848 { 11849 error ("%qD must be a nonstatic member function", decl); 11850 return false; 11851 } 11852 else 11853 { 11854 tree p; 11855 11856 if (DECL_STATIC_FUNCTION_P (decl)) 11857 { 11858 error ("%qD must be either a non-static member " 11859 "function or a non-member function", decl); 11860 return false; 11861 } 11862 11863 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p)) 11864 { 11865 tree arg = non_reference (TREE_VALUE (p)); 11866 if (arg == error_mark_node) 11867 return false; 11868 11869 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used 11870 because these checks are performed even on 11871 template functions. */ 11872 if (MAYBE_CLASS_TYPE_P (arg) 11873 || TREE_CODE (arg) == ENUMERAL_TYPE) 11874 break; 11875 } 11876 11877 if (!p || p == void_list_node) 11878 { 11879 if (complain) 11880 error ("%qD must have an argument of class or " 11881 "enumerated type", decl); 11882 return false; 11883 } 11884 } 11885 } 11886 11887 /* There are no restrictions on the arguments to an overloaded 11888 "operator ()". */ 11889 if (operator_code == CALL_EXPR) 11890 return true; 11891 11892 /* Warn about conversion operators that will never be used. */ 11893 if (IDENTIFIER_TYPENAME_P (name) 11894 && ! DECL_TEMPLATE_INFO (decl) 11895 && warn_conversion 11896 /* Warn only declaring the function; there is no need to 11897 warn again about out-of-class definitions. */ 11898 && class_type == current_class_type) 11899 { 11900 tree t = TREE_TYPE (name); 11901 int ref = (TREE_CODE (t) == REFERENCE_TYPE); 11902 11903 if (ref) 11904 t = TYPE_MAIN_VARIANT (TREE_TYPE (t)); 11905 11906 if (VOID_TYPE_P (t)) 11907 warning (OPT_Wconversion, 11908 ref 11909 ? G_("conversion to a reference to void " 11910 "will never use a type conversion operator") 11911 : G_("conversion to void " 11912 "will never use a type conversion operator")); 11913 else if (class_type) 11914 { 11915 if (t == class_type) 11916 warning (OPT_Wconversion, 11917 ref 11918 ? G_("conversion to a reference to the same type " 11919 "will never use a type conversion operator") 11920 : G_("conversion to the same type " 11921 "will never use a type conversion operator")); 11922 /* Don't force t to be complete here. */ 11923 else if (MAYBE_CLASS_TYPE_P (t) 11924 && COMPLETE_TYPE_P (t) 11925 && DERIVED_FROM_P (t, class_type)) 11926 warning (OPT_Wconversion, 11927 ref 11928 ? G_("conversion to a reference to a base class " 11929 "will never use a type conversion operator") 11930 : G_("conversion to a base class " 11931 "will never use a type conversion operator")); 11932 } 11933 11934 } 11935 11936 if (operator_code == COND_EXPR) 11937 { 11938 /* 13.4.0.3 */ 11939 error ("ISO C++ prohibits overloading operator ?:"); 11940 return false; 11941 } 11942 else if (ellipsis_p) 11943 { 11944 error ("%qD must not have variable number of arguments", decl); 11945 return false; 11946 } 11947 else if (ambi_op_p (operator_code)) 11948 { 11949 if (arity == 1) 11950 /* We pick the one-argument operator codes by default, so 11951 we don't have to change anything. */ 11952 ; 11953 else if (arity == 2) 11954 { 11955 /* If we thought this was a unary operator, we now know 11956 it to be a binary operator. */ 11957 switch (operator_code) 11958 { 11959 case INDIRECT_REF: 11960 operator_code = MULT_EXPR; 11961 break; 11962 11963 case ADDR_EXPR: 11964 operator_code = BIT_AND_EXPR; 11965 break; 11966 11967 case UNARY_PLUS_EXPR: 11968 operator_code = PLUS_EXPR; 11969 break; 11970 11971 case NEGATE_EXPR: 11972 operator_code = MINUS_EXPR; 11973 break; 11974 11975 case PREINCREMENT_EXPR: 11976 operator_code = POSTINCREMENT_EXPR; 11977 break; 11978 11979 case PREDECREMENT_EXPR: 11980 operator_code = POSTDECREMENT_EXPR; 11981 break; 11982 11983 default: 11984 gcc_unreachable (); 11985 } 11986 11987 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code); 11988 11989 if ((operator_code == POSTINCREMENT_EXPR 11990 || operator_code == POSTDECREMENT_EXPR) 11991 && ! processing_template_decl 11992 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node)) 11993 { 11994 if (methodp) 11995 error ("postfix %qD must take %<int%> as its argument", 11996 decl); 11997 else 11998 error ("postfix %qD must take %<int%> as its second " 11999 "argument", decl); 12000 return false; 12001 } 12002 } 12003 else 12004 { 12005 if (methodp) 12006 error ("%qD must take either zero or one argument", decl); 12007 else 12008 error ("%qD must take either one or two arguments", decl); 12009 return false; 12010 } 12011 12012 /* More Effective C++ rule 6. */ 12013 if (warn_ecpp 12014 && (operator_code == POSTINCREMENT_EXPR 12015 || operator_code == POSTDECREMENT_EXPR 12016 || operator_code == PREINCREMENT_EXPR 12017 || operator_code == PREDECREMENT_EXPR)) 12018 { 12019 tree arg = TREE_VALUE (argtypes); 12020 tree ret = TREE_TYPE (TREE_TYPE (decl)); 12021 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE) 12022 arg = TREE_TYPE (arg); 12023 arg = TYPE_MAIN_VARIANT (arg); 12024 if (operator_code == PREINCREMENT_EXPR 12025 || operator_code == PREDECREMENT_EXPR) 12026 { 12027 if (TREE_CODE (ret) != REFERENCE_TYPE 12028 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)), 12029 arg)) 12030 warning (OPT_Weffc__, "prefix %qD should return %qT", decl, 12031 build_reference_type (arg)); 12032 } 12033 else 12034 { 12035 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg)) 12036 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg); 12037 } 12038 } 12039 } 12040 else if (unary_op_p (operator_code)) 12041 { 12042 if (arity != 1) 12043 { 12044 if (methodp) 12045 error ("%qD must take %<void%>", decl); 12046 else 12047 error ("%qD must take exactly one argument", decl); 12048 return false; 12049 } 12050 } 12051 else /* if (binary_op_p (operator_code)) */ 12052 { 12053 if (arity != 2) 12054 { 12055 if (methodp) 12056 error ("%qD must take exactly one argument", decl); 12057 else 12058 error ("%qD must take exactly two arguments", decl); 12059 return false; 12060 } 12061 12062 /* More Effective C++ rule 7. */ 12063 if (warn_ecpp 12064 && (operator_code == TRUTH_ANDIF_EXPR 12065 || operator_code == TRUTH_ORIF_EXPR 12066 || operator_code == COMPOUND_EXPR)) 12067 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments", 12068 decl); 12069 } 12070 12071 /* Effective C++ rule 23. */ 12072 if (warn_ecpp 12073 && arity == 2 12074 && !DECL_ASSIGNMENT_OPERATOR_P (decl) 12075 && (operator_code == PLUS_EXPR 12076 || operator_code == MINUS_EXPR 12077 || operator_code == TRUNC_DIV_EXPR 12078 || operator_code == MULT_EXPR 12079 || operator_code == TRUNC_MOD_EXPR) 12080 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE) 12081 warning (OPT_Weffc__, "%qD should return by value", decl); 12082 12083 /* [over.oper]/8 */ 12084 for (; argtypes && argtypes != void_list_node; 12085 argtypes = TREE_CHAIN (argtypes)) 12086 if (TREE_PURPOSE (argtypes)) 12087 { 12088 TREE_PURPOSE (argtypes) = NULL_TREE; 12089 if (operator_code == POSTINCREMENT_EXPR 12090 || operator_code == POSTDECREMENT_EXPR) 12091 { 12092 pedwarn (input_location, OPT_Wpedantic, "%qD cannot have default arguments", 12093 decl); 12094 } 12095 else 12096 { 12097 error ("%qD cannot have default arguments", decl); 12098 return false; 12099 } 12100 } 12101 } 12102 return true; 12103} 12104 12105/* Return a string giving the keyword associate with CODE. */ 12106 12107static const char * 12108tag_name (enum tag_types code) 12109{ 12110 switch (code) 12111 { 12112 case record_type: 12113 return "struct"; 12114 case class_type: 12115 return "class"; 12116 case union_type: 12117 return "union"; 12118 case enum_type: 12119 return "enum"; 12120 case typename_type: 12121 return "typename"; 12122 default: 12123 gcc_unreachable (); 12124 } 12125} 12126 12127/* Name lookup in an elaborated-type-specifier (after the keyword 12128 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the 12129 elaborated-type-specifier is invalid, issue a diagnostic and return 12130 error_mark_node; otherwise, return the *_TYPE to which it referred. 12131 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */ 12132 12133tree 12134check_elaborated_type_specifier (enum tag_types tag_code, 12135 tree decl, 12136 bool allow_template_p) 12137{ 12138 tree type; 12139 12140 /* In the case of: 12141 12142 struct S { struct S *p; }; 12143 12144 name lookup will find the TYPE_DECL for the implicit "S::S" 12145 typedef. Adjust for that here. */ 12146 if (DECL_SELF_REFERENCE_P (decl)) 12147 decl = TYPE_NAME (TREE_TYPE (decl)); 12148 12149 type = TREE_TYPE (decl); 12150 12151 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P 12152 is false for this case as well. */ 12153 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM) 12154 { 12155 error ("using template type parameter %qT after %qs", 12156 type, tag_name (tag_code)); 12157 return error_mark_node; 12158 } 12159 /* Accept template template parameters. */ 12160 else if (allow_template_p 12161 && (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM 12162 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)) 12163 ; 12164 /* [dcl.type.elab] 12165 12166 If the identifier resolves to a typedef-name or the 12167 simple-template-id resolves to an alias template 12168 specialization, the elaborated-type-specifier is ill-formed. 12169 12170 In other words, the only legitimate declaration to use in the 12171 elaborated type specifier is the implicit typedef created when 12172 the type is declared. */ 12173 else if (!DECL_IMPLICIT_TYPEDEF_P (decl) 12174 && !DECL_SELF_REFERENCE_P (decl) 12175 && tag_code != typename_type) 12176 { 12177 if (alias_template_specialization_p (type)) 12178 error ("using alias template specialization %qT after %qs", 12179 type, tag_name (tag_code)); 12180 else 12181 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code)); 12182 inform (DECL_SOURCE_LOCATION (decl), 12183 "%qD has a previous declaration here", decl); 12184 return error_mark_node; 12185 } 12186 else if (TREE_CODE (type) != RECORD_TYPE 12187 && TREE_CODE (type) != UNION_TYPE 12188 && tag_code != enum_type 12189 && tag_code != typename_type) 12190 { 12191 error ("%qT referred to as %qs", type, tag_name (tag_code)); 12192 inform (input_location, "%q+T has a previous declaration here", type); 12193 return error_mark_node; 12194 } 12195 else if (TREE_CODE (type) != ENUMERAL_TYPE 12196 && tag_code == enum_type) 12197 { 12198 error ("%qT referred to as enum", type); 12199 inform (input_location, "%q+T has a previous declaration here", type); 12200 return error_mark_node; 12201 } 12202 else if (!allow_template_p 12203 && TREE_CODE (type) == RECORD_TYPE 12204 && CLASSTYPE_IS_TEMPLATE (type)) 12205 { 12206 /* If a class template appears as elaborated type specifier 12207 without a template header such as: 12208 12209 template <class T> class C {}; 12210 void f(class C); // No template header here 12211 12212 then the required template argument is missing. */ 12213 error ("template argument required for %<%s %T%>", 12214 tag_name (tag_code), 12215 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))); 12216 return error_mark_node; 12217 } 12218 12219 return type; 12220} 12221 12222/* Lookup NAME in elaborate type specifier in scope according to 12223 SCOPE and issue diagnostics if necessary. 12224 Return *_TYPE node upon success, NULL_TREE when the NAME is not 12225 found, and ERROR_MARK_NODE for type error. */ 12226 12227static tree 12228lookup_and_check_tag (enum tag_types tag_code, tree name, 12229 tag_scope scope, bool template_header_p) 12230{ 12231 tree t; 12232 tree decl; 12233 if (scope == ts_global) 12234 { 12235 /* First try ordinary name lookup, ignoring hidden class name 12236 injected via friend declaration. */ 12237 decl = lookup_name_prefer_type (name, 2); 12238 decl = strip_using_decl (decl); 12239 /* If that fails, the name will be placed in the smallest 12240 non-class, non-function-prototype scope according to 3.3.1/5. 12241 We may already have a hidden name declared as friend in this 12242 scope. So lookup again but not ignoring hidden names. 12243 If we find one, that name will be made visible rather than 12244 creating a new tag. */ 12245 if (!decl) 12246 decl = lookup_type_scope (name, ts_within_enclosing_non_class); 12247 } 12248 else 12249 decl = lookup_type_scope (name, scope); 12250 12251 if (decl 12252 && (DECL_CLASS_TEMPLATE_P (decl) 12253 /* If scope is ts_current we're defining a class, so ignore a 12254 template template parameter. */ 12255 || (scope != ts_current 12256 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl)))) 12257 decl = DECL_TEMPLATE_RESULT (decl); 12258 12259 if (decl && TREE_CODE (decl) == TYPE_DECL) 12260 { 12261 /* Look for invalid nested type: 12262 class C { 12263 class C {}; 12264 }; */ 12265 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl)) 12266 { 12267 error ("%qD has the same name as the class in which it is " 12268 "declared", 12269 decl); 12270 return error_mark_node; 12271 } 12272 12273 /* Two cases we need to consider when deciding if a class 12274 template is allowed as an elaborated type specifier: 12275 1. It is a self reference to its own class. 12276 2. It comes with a template header. 12277 12278 For example: 12279 12280 template <class T> class C { 12281 class C *c1; // DECL_SELF_REFERENCE_P is true 12282 class D; 12283 }; 12284 template <class U> class C; // template_header_p is true 12285 template <class T> class C<T>::D { 12286 class C *c2; // DECL_SELF_REFERENCE_P is true 12287 }; */ 12288 12289 t = check_elaborated_type_specifier (tag_code, 12290 decl, 12291 template_header_p 12292 | DECL_SELF_REFERENCE_P (decl)); 12293 return t; 12294 } 12295 else if (decl && TREE_CODE (decl) == TREE_LIST) 12296 { 12297 error ("reference to %qD is ambiguous", name); 12298 print_candidates (decl); 12299 return error_mark_node; 12300 } 12301 else 12302 return NULL_TREE; 12303} 12304 12305/* Get the struct, enum or union (TAG_CODE says which) with tag NAME. 12306 Define the tag as a forward-reference if it is not defined. 12307 12308 If a declaration is given, process it here, and report an error if 12309 multiple declarations are not identical. 12310 12311 SCOPE is TS_CURRENT when this is also a definition. Only look in 12312 the current frame for the name (since C++ allows new names in any 12313 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend 12314 declaration. Only look beginning from the current scope outward up 12315 till the nearest non-class scope. Otherwise it is TS_GLOBAL. 12316 12317 TEMPLATE_HEADER_P is true when this declaration is preceded by 12318 a set of template parameters. */ 12319 12320static tree 12321xref_tag_1 (enum tag_types tag_code, tree name, 12322 tag_scope orig_scope, bool template_header_p) 12323{ 12324 enum tree_code code; 12325 tree t; 12326 tree context = NULL_TREE; 12327 tag_scope scope; 12328 12329 gcc_assert (identifier_p (name)); 12330 12331 switch (tag_code) 12332 { 12333 case record_type: 12334 case class_type: 12335 code = RECORD_TYPE; 12336 break; 12337 case union_type: 12338 code = UNION_TYPE; 12339 break; 12340 case enum_type: 12341 code = ENUMERAL_TYPE; 12342 break; 12343 default: 12344 gcc_unreachable (); 12345 } 12346 12347 if (orig_scope == ts_lambda) 12348 scope = ts_current; 12349 else 12350 scope = orig_scope; 12351 12352 /* In case of anonymous name, xref_tag is only called to 12353 make type node and push name. Name lookup is not required. */ 12354 if (ANON_AGGRNAME_P (name)) 12355 t = NULL_TREE; 12356 else 12357 t = lookup_and_check_tag (tag_code, name, 12358 scope, template_header_p); 12359 12360 if (t == error_mark_node) 12361 return error_mark_node; 12362 12363 if (scope != ts_current && t && current_class_type 12364 && template_class_depth (current_class_type) 12365 && template_header_p) 12366 { 12367 if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM) 12368 return t; 12369 12370 /* Since SCOPE is not TS_CURRENT, we are not looking at a 12371 definition of this tag. Since, in addition, we are currently 12372 processing a (member) template declaration of a template 12373 class, we must be very careful; consider: 12374 12375 template <class X> 12376 struct S1 12377 12378 template <class U> 12379 struct S2 12380 { template <class V> 12381 friend struct S1; }; 12382 12383 Here, the S2::S1 declaration should not be confused with the 12384 outer declaration. In particular, the inner version should 12385 have a template parameter of level 2, not level 1. This 12386 would be particularly important if the member declaration 12387 were instead: 12388 12389 template <class V = U> friend struct S1; 12390 12391 say, when we should tsubst into `U' when instantiating 12392 S2. On the other hand, when presented with: 12393 12394 template <class T> 12395 struct S1 { 12396 template <class U> 12397 struct S2 {}; 12398 template <class U> 12399 friend struct S2; 12400 }; 12401 12402 we must find the inner binding eventually. We 12403 accomplish this by making sure that the new type we 12404 create to represent this declaration has the right 12405 TYPE_CONTEXT. */ 12406 context = TYPE_CONTEXT (t); 12407 t = NULL_TREE; 12408 } 12409 12410 if (! t) 12411 { 12412 /* If no such tag is yet defined, create a forward-reference node 12413 and record it as the "definition". 12414 When a real declaration of this type is found, 12415 the forward-reference will be altered into a real type. */ 12416 if (code == ENUMERAL_TYPE) 12417 { 12418 error ("use of enum %q#D without previous declaration", name); 12419 return error_mark_node; 12420 } 12421 else 12422 { 12423 t = make_class_type (code); 12424 TYPE_CONTEXT (t) = context; 12425 if (orig_scope == ts_lambda) 12426 /* Remember that we're declaring a lambda to avoid bogus errors 12427 in push_template_decl. */ 12428 CLASSTYPE_LAMBDA_EXPR (t) = error_mark_node; 12429 t = pushtag (name, t, scope); 12430 } 12431 } 12432 else 12433 { 12434 if (template_header_p && MAYBE_CLASS_TYPE_P (t)) 12435 { 12436 if (!redeclare_class_template (t, current_template_parms)) 12437 return error_mark_node; 12438 } 12439 else if (!processing_template_decl 12440 && CLASS_TYPE_P (t) 12441 && CLASSTYPE_IS_TEMPLATE (t)) 12442 { 12443 error ("redeclaration of %qT as a non-template", t); 12444 error ("previous declaration %q+D", t); 12445 return error_mark_node; 12446 } 12447 12448 /* Make injected friend class visible. */ 12449 if (scope != ts_within_enclosing_non_class 12450 && hidden_name_p (TYPE_NAME (t))) 12451 { 12452 DECL_ANTICIPATED (TYPE_NAME (t)) = 0; 12453 DECL_FRIEND_P (TYPE_NAME (t)) = 0; 12454 12455 if (TYPE_TEMPLATE_INFO (t)) 12456 { 12457 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0; 12458 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0; 12459 } 12460 } 12461 } 12462 12463 return t; 12464} 12465 12466/* Wrapper for xref_tag_1. */ 12467 12468tree 12469xref_tag (enum tag_types tag_code, tree name, 12470 tag_scope scope, bool template_header_p) 12471{ 12472 tree ret; 12473 bool subtime; 12474 subtime = timevar_cond_start (TV_NAME_LOOKUP); 12475 ret = xref_tag_1 (tag_code, name, scope, template_header_p); 12476 timevar_cond_stop (TV_NAME_LOOKUP, subtime); 12477 return ret; 12478} 12479 12480 12481tree 12482xref_tag_from_type (tree old, tree id, tag_scope scope) 12483{ 12484 enum tag_types tag_kind; 12485 12486 if (TREE_CODE (old) == RECORD_TYPE) 12487 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type); 12488 else 12489 tag_kind = union_type; 12490 12491 if (id == NULL_TREE) 12492 id = TYPE_IDENTIFIER (old); 12493 12494 return xref_tag (tag_kind, id, scope, false); 12495} 12496 12497/* Create the binfo hierarchy for REF with (possibly NULL) base list 12498 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an 12499 access_* node, and the TREE_VALUE is the type of the base-class. 12500 Non-NULL TREE_TYPE indicates virtual inheritance. 12501 12502 Returns true if the binfo hierarchy was successfully created, 12503 false if an error was detected. */ 12504 12505bool 12506xref_basetypes (tree ref, tree base_list) 12507{ 12508 tree *basep; 12509 tree binfo, base_binfo; 12510 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */ 12511 unsigned max_bases = 0; /* Maximum direct bases. */ 12512 int i; 12513 tree default_access; 12514 tree igo_prev; /* Track Inheritance Graph Order. */ 12515 12516 if (ref == error_mark_node) 12517 return false; 12518 12519 /* The base of a derived class is private by default, all others are 12520 public. */ 12521 default_access = (TREE_CODE (ref) == RECORD_TYPE 12522 && CLASSTYPE_DECLARED_CLASS (ref) 12523 ? access_private_node : access_public_node); 12524 12525 /* First, make sure that any templates in base-classes are 12526 instantiated. This ensures that if we call ourselves recursively 12527 we do not get confused about which classes are marked and which 12528 are not. */ 12529 basep = &base_list; 12530 while (*basep) 12531 { 12532 tree basetype = TREE_VALUE (*basep); 12533 12534 /* The dependent_type_p call below should really be dependent_scope_p 12535 so that we give a hard error about using an incomplete type as a 12536 base, but we allow it with a pedwarn for backward 12537 compatibility. */ 12538 if (processing_template_decl 12539 && CLASS_TYPE_P (basetype) && TYPE_BEING_DEFINED (basetype)) 12540 cxx_incomplete_type_diagnostic (NULL_TREE, basetype, DK_PEDWARN); 12541 if (!dependent_type_p (basetype) 12542 && !complete_type_or_else (basetype, NULL)) 12543 /* An incomplete type. Remove it from the list. */ 12544 *basep = TREE_CHAIN (*basep); 12545 else 12546 { 12547 max_bases++; 12548 if (TREE_TYPE (*basep)) 12549 max_vbases++; 12550 if (CLASS_TYPE_P (basetype)) 12551 max_vbases += vec_safe_length (CLASSTYPE_VBASECLASSES (basetype)); 12552 basep = &TREE_CHAIN (*basep); 12553 } 12554 } 12555 12556 TYPE_MARKED_P (ref) = 1; 12557 12558 /* The binfo slot should be empty, unless this is an (ill-formed) 12559 redefinition. */ 12560 if (TYPE_BINFO (ref) && !TYPE_SIZE (ref)) 12561 { 12562 error ("redefinition of %q#T", ref); 12563 return false; 12564 } 12565 12566 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref); 12567 12568 binfo = make_tree_binfo (max_bases); 12569 12570 TYPE_BINFO (ref) = binfo; 12571 BINFO_OFFSET (binfo) = size_zero_node; 12572 BINFO_TYPE (binfo) = ref; 12573 12574 /* Apply base-class info set up to the variants of this type. */ 12575 fixup_type_variants (ref); 12576 12577 if (max_bases) 12578 { 12579 vec_alloc (BINFO_BASE_ACCESSES (binfo), max_bases); 12580 /* An aggregate cannot have baseclasses. */ 12581 CLASSTYPE_NON_AGGREGATE (ref) = 1; 12582 12583 if (TREE_CODE (ref) == UNION_TYPE) 12584 { 12585 error ("derived union %qT invalid", ref); 12586 return false; 12587 } 12588 } 12589 12590 if (max_bases > 1) 12591 { 12592 if (TYPE_FOR_JAVA (ref)) 12593 { 12594 error ("Java class %qT cannot have multiple bases", ref); 12595 return false; 12596 } 12597 } 12598 12599 if (max_vbases) 12600 { 12601 vec_alloc (CLASSTYPE_VBASECLASSES (ref), max_vbases); 12602 12603 if (TYPE_FOR_JAVA (ref)) 12604 { 12605 error ("Java class %qT cannot have virtual bases", ref); 12606 return false; 12607 } 12608 } 12609 12610 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list)) 12611 { 12612 tree access = TREE_PURPOSE (base_list); 12613 int via_virtual = TREE_TYPE (base_list) != NULL_TREE; 12614 tree basetype = TREE_VALUE (base_list); 12615 12616 if (access == access_default_node) 12617 access = default_access; 12618 12619 if (PACK_EXPANSION_P (basetype)) 12620 basetype = PACK_EXPANSION_PATTERN (basetype); 12621 if (TREE_CODE (basetype) == TYPE_DECL) 12622 basetype = TREE_TYPE (basetype); 12623 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE) 12624 { 12625 error ("base type %qT fails to be a struct or class type", 12626 basetype); 12627 return false; 12628 } 12629 12630 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0)) 12631 TYPE_FOR_JAVA (ref) = 1; 12632 12633 base_binfo = NULL_TREE; 12634 if (CLASS_TYPE_P (basetype) && !dependent_scope_p (basetype)) 12635 { 12636 base_binfo = TYPE_BINFO (basetype); 12637 /* The original basetype could have been a typedef'd type. */ 12638 basetype = BINFO_TYPE (base_binfo); 12639 12640 /* Inherit flags from the base. */ 12641 TYPE_HAS_NEW_OPERATOR (ref) 12642 |= TYPE_HAS_NEW_OPERATOR (basetype); 12643 TYPE_HAS_ARRAY_NEW_OPERATOR (ref) 12644 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype); 12645 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype); 12646 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype); 12647 CLASSTYPE_DIAMOND_SHAPED_P (ref) 12648 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype); 12649 CLASSTYPE_REPEATED_BASE_P (ref) 12650 |= CLASSTYPE_REPEATED_BASE_P (basetype); 12651 } 12652 12653 /* We must do this test after we've seen through a typedef 12654 type. */ 12655 if (TYPE_MARKED_P (basetype)) 12656 { 12657 if (basetype == ref) 12658 error ("recursive type %qT undefined", basetype); 12659 else 12660 error ("duplicate base type %qT invalid", basetype); 12661 return false; 12662 } 12663 12664 if (PACK_EXPANSION_P (TREE_VALUE (base_list))) 12665 /* Regenerate the pack expansion for the bases. */ 12666 basetype = make_pack_expansion (basetype); 12667 12668 TYPE_MARKED_P (basetype) = 1; 12669 12670 base_binfo = copy_binfo (base_binfo, basetype, ref, 12671 &igo_prev, via_virtual); 12672 if (!BINFO_INHERITANCE_CHAIN (base_binfo)) 12673 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo; 12674 12675 BINFO_BASE_APPEND (binfo, base_binfo); 12676 BINFO_BASE_ACCESS_APPEND (binfo, access); 12677 } 12678 12679 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref)) < max_vbases) 12680 /* If we didn't get max_vbases vbases, we must have shared at 12681 least one of them, and are therefore diamond shaped. */ 12682 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1; 12683 12684 /* Unmark all the types. */ 12685 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 12686 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0; 12687 TYPE_MARKED_P (ref) = 0; 12688 12689 /* Now see if we have a repeated base type. */ 12690 if (!CLASSTYPE_REPEATED_BASE_P (ref)) 12691 { 12692 for (base_binfo = binfo; base_binfo; 12693 base_binfo = TREE_CHAIN (base_binfo)) 12694 { 12695 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo))) 12696 { 12697 CLASSTYPE_REPEATED_BASE_P (ref) = 1; 12698 break; 12699 } 12700 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1; 12701 } 12702 for (base_binfo = binfo; base_binfo; 12703 base_binfo = TREE_CHAIN (base_binfo)) 12704 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo))) 12705 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0; 12706 else 12707 break; 12708 } 12709 12710 return true; 12711} 12712 12713 12714/* Copies the enum-related properties from type SRC to type DST. 12715 Used with the underlying type of an enum and the enum itself. */ 12716static void 12717copy_type_enum (tree dst, tree src) 12718{ 12719 tree t; 12720 for (t = dst; t; t = TYPE_NEXT_VARIANT (t)) 12721 { 12722 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (src); 12723 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (src); 12724 TYPE_SIZE (t) = TYPE_SIZE (src); 12725 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (src); 12726 SET_TYPE_MODE (dst, TYPE_MODE (src)); 12727 TYPE_PRECISION (t) = TYPE_PRECISION (src); 12728 TYPE_ALIGN (t) = TYPE_ALIGN (src); 12729 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (src); 12730 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (src); 12731 } 12732} 12733 12734/* Begin compiling the definition of an enumeration type. 12735 NAME is its name, 12736 12737 if ENUMTYPE is not NULL_TREE then the type has alredy been found. 12738 12739 UNDERLYING_TYPE is the type that will be used as the storage for 12740 the enumeration type. This should be NULL_TREE if no storage type 12741 was specified. 12742 12743 SCOPED_ENUM_P is true if this is a scoped enumeration type. 12744 12745 if IS_NEW is not NULL, gets TRUE iff a new type is created. 12746 12747 Returns the type object, as yet incomplete. 12748 Also records info about it so that build_enumerator 12749 may be used to declare the individual values as they are read. */ 12750 12751tree 12752start_enum (tree name, tree enumtype, tree underlying_type, 12753 bool scoped_enum_p, bool *is_new) 12754{ 12755 tree prevtype = NULL_TREE; 12756 gcc_assert (identifier_p (name)); 12757 12758 if (is_new) 12759 *is_new = false; 12760 /* [C++0x dcl.enum]p5: 12761 12762 If not explicitly specified, the underlying type of a scoped 12763 enumeration type is int. */ 12764 if (!underlying_type && scoped_enum_p) 12765 underlying_type = integer_type_node; 12766 12767 if (underlying_type) 12768 underlying_type = cv_unqualified (underlying_type); 12769 12770 /* If this is the real definition for a previous forward reference, 12771 fill in the contents in the same object that used to be the 12772 forward reference. */ 12773 if (!enumtype) 12774 enumtype = lookup_and_check_tag (enum_type, name, 12775 /*tag_scope=*/ts_current, 12776 /*template_header_p=*/false); 12777 12778 /* In case of a template_decl, the only check that should be deferred 12779 to instantiation time is the comparison of underlying types. */ 12780 if (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE) 12781 { 12782 if (scoped_enum_p != SCOPED_ENUM_P (enumtype)) 12783 { 12784 error_at (input_location, "scoped/unscoped mismatch " 12785 "in enum %q#T", enumtype); 12786 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)), 12787 "previous definition here"); 12788 enumtype = error_mark_node; 12789 } 12790 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) != !! underlying_type) 12791 { 12792 error_at (input_location, "underlying type mismatch " 12793 "in enum %q#T", enumtype); 12794 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)), 12795 "previous definition here"); 12796 enumtype = error_mark_node; 12797 } 12798 else if (underlying_type && ENUM_UNDERLYING_TYPE (enumtype) 12799 && !dependent_type_p (underlying_type) 12800 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype)) 12801 && !same_type_p (underlying_type, 12802 ENUM_UNDERLYING_TYPE (enumtype))) 12803 { 12804 error_at (input_location, "different underlying type " 12805 "in enum %q#T", enumtype); 12806 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)), 12807 "previous definition here"); 12808 underlying_type = NULL_TREE; 12809 } 12810 } 12811 12812 if (!enumtype || TREE_CODE (enumtype) != ENUMERAL_TYPE 12813 || processing_template_decl) 12814 { 12815 /* In case of error, make a dummy enum to allow parsing to 12816 continue. */ 12817 if (enumtype == error_mark_node) 12818 { 12819 name = make_anon_name (); 12820 enumtype = NULL_TREE; 12821 } 12822 12823 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition 12824 of an opaque enum, or an opaque enum of an already defined 12825 enumeration (C++0x only). 12826 In any other case, it'll be NULL_TREE. */ 12827 if (!enumtype) 12828 { 12829 if (is_new) 12830 *is_new = true; 12831 } 12832 prevtype = enumtype; 12833 12834 /* Do not push the decl more than once, unless we need to 12835 compare underlying types at instantiation time */ 12836 if (!enumtype 12837 || TREE_CODE (enumtype) != ENUMERAL_TYPE 12838 || (underlying_type 12839 && dependent_type_p (underlying_type)) 12840 || (ENUM_UNDERLYING_TYPE (enumtype) 12841 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype)))) 12842 { 12843 enumtype = cxx_make_type (ENUMERAL_TYPE); 12844 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current); 12845 } 12846 else 12847 enumtype = xref_tag (enum_type, name, /*tag_scope=*/ts_current, 12848 false); 12849 12850 if (enumtype == error_mark_node) 12851 return error_mark_node; 12852 12853 /* The enum is considered opaque until the opening '{' of the 12854 enumerator list. */ 12855 SET_OPAQUE_ENUM_P (enumtype, true); 12856 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) = !! underlying_type; 12857 } 12858 12859 SET_SCOPED_ENUM_P (enumtype, scoped_enum_p); 12860 12861 if (underlying_type) 12862 { 12863 if (CP_INTEGRAL_TYPE_P (underlying_type)) 12864 { 12865 copy_type_enum (enumtype, underlying_type); 12866 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type; 12867 } 12868 else if (dependent_type_p (underlying_type)) 12869 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type; 12870 else 12871 error ("underlying type %<%T%> of %<%T%> must be an integral type", 12872 underlying_type, enumtype); 12873 } 12874 12875 /* If into a template class, the returned enum is always the first 12876 declaration (opaque or not) seen. This way all the references to 12877 this type will be to the same declaration. The following ones are used 12878 only to check for definition errors. */ 12879 if (prevtype && processing_template_decl) 12880 return prevtype; 12881 else 12882 return enumtype; 12883} 12884 12885/* After processing and defining all the values of an enumeration type, 12886 install their decls in the enumeration type. 12887 ENUMTYPE is the type object. */ 12888 12889void 12890finish_enum_value_list (tree enumtype) 12891{ 12892 tree values; 12893 tree underlying_type; 12894 tree decl; 12895 tree value; 12896 tree minnode, maxnode; 12897 tree t; 12898 12899 bool fixed_underlying_type_p 12900 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE; 12901 12902 /* We built up the VALUES in reverse order. */ 12903 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype)); 12904 12905 /* For an enum defined in a template, just set the type of the values; 12906 all further processing is postponed until the template is 12907 instantiated. We need to set the type so that tsubst of a CONST_DECL 12908 works. */ 12909 if (processing_template_decl) 12910 { 12911 for (values = TYPE_VALUES (enumtype); 12912 values; 12913 values = TREE_CHAIN (values)) 12914 TREE_TYPE (TREE_VALUE (values)) = enumtype; 12915 return; 12916 } 12917 12918 /* Determine the minimum and maximum values of the enumerators. */ 12919 if (TYPE_VALUES (enumtype)) 12920 { 12921 minnode = maxnode = NULL_TREE; 12922 12923 for (values = TYPE_VALUES (enumtype); 12924 values; 12925 values = TREE_CHAIN (values)) 12926 { 12927 decl = TREE_VALUE (values); 12928 12929 /* [dcl.enum]: Following the closing brace of an enum-specifier, 12930 each enumerator has the type of its enumeration. Prior to the 12931 closing brace, the type of each enumerator is the type of its 12932 initializing value. */ 12933 TREE_TYPE (decl) = enumtype; 12934 12935 /* Update the minimum and maximum values, if appropriate. */ 12936 value = DECL_INITIAL (decl); 12937 if (value == error_mark_node) 12938 value = integer_zero_node; 12939 /* Figure out what the minimum and maximum values of the 12940 enumerators are. */ 12941 if (!minnode) 12942 minnode = maxnode = value; 12943 else if (tree_int_cst_lt (maxnode, value)) 12944 maxnode = value; 12945 else if (tree_int_cst_lt (value, minnode)) 12946 minnode = value; 12947 } 12948 } 12949 else 12950 /* [dcl.enum] 12951 12952 If the enumerator-list is empty, the underlying type is as if 12953 the enumeration had a single enumerator with value 0. */ 12954 minnode = maxnode = integer_zero_node; 12955 12956 if (!fixed_underlying_type_p) 12957 { 12958 /* Compute the number of bits require to represent all values of the 12959 enumeration. We must do this before the type of MINNODE and 12960 MAXNODE are transformed, since tree_int_cst_min_precision relies 12961 on the TREE_TYPE of the value it is passed. */ 12962 signop sgn = tree_int_cst_sgn (minnode) >= 0 ? UNSIGNED : SIGNED; 12963 int lowprec = tree_int_cst_min_precision (minnode, sgn); 12964 int highprec = tree_int_cst_min_precision (maxnode, sgn); 12965 int precision = MAX (lowprec, highprec); 12966 unsigned int itk; 12967 bool use_short_enum; 12968 12969 /* Determine the underlying type of the enumeration. 12970 12971 [dcl.enum] 12972 12973 The underlying type of an enumeration is an integral type that 12974 can represent all the enumerator values defined in the 12975 enumeration. It is implementation-defined which integral type is 12976 used as the underlying type for an enumeration except that the 12977 underlying type shall not be larger than int unless the value of 12978 an enumerator cannot fit in an int or unsigned int. 12979 12980 We use "int" or an "unsigned int" as the underlying type, even if 12981 a smaller integral type would work, unless the user has 12982 explicitly requested that we use the smallest possible type. The 12983 user can request that for all enumerations with a command line 12984 flag, or for just one enumeration with an attribute. */ 12985 12986 use_short_enum = flag_short_enums 12987 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype)); 12988 12989 for (itk = (use_short_enum ? itk_char : itk_int); 12990 itk != itk_none; 12991 itk++) 12992 { 12993 underlying_type = integer_types[itk]; 12994 if (underlying_type != NULL_TREE 12995 && TYPE_PRECISION (underlying_type) >= precision 12996 && TYPE_SIGN (underlying_type) == sgn) 12997 break; 12998 } 12999 if (itk == itk_none) 13000 { 13001 /* DR 377 13002 13003 IF no integral type can represent all the enumerator values, the 13004 enumeration is ill-formed. */ 13005 error ("no integral type can represent all of the enumerator values " 13006 "for %qT", enumtype); 13007 precision = TYPE_PRECISION (long_long_integer_type_node); 13008 underlying_type = integer_types[itk_unsigned_long_long]; 13009 } 13010 13011 /* [dcl.enum] 13012 13013 The value of sizeof() applied to an enumeration type, an object 13014 of an enumeration type, or an enumerator, is the value of sizeof() 13015 applied to the underlying type. */ 13016 copy_type_enum (enumtype, underlying_type); 13017 13018 /* Compute the minimum and maximum values for the type. 13019 13020 [dcl.enum] 13021 13022 For an enumeration where emin is the smallest enumerator and emax 13023 is the largest, the values of the enumeration are the values of the 13024 underlying type in the range bmin to bmax, where bmin and bmax are, 13025 respectively, the smallest and largest values of the smallest bit- 13026 field that can store emin and emax. */ 13027 13028 /* The middle-end currently assumes that types with TYPE_PRECISION 13029 narrower than their underlying type are suitably zero or sign 13030 extended to fill their mode. Similarly, it assumes that the front 13031 end assures that a value of a particular type must be within 13032 TYPE_MIN_VALUE and TYPE_MAX_VALUE. 13033 13034 We used to set these fields based on bmin and bmax, but that led 13035 to invalid assumptions like optimizing away bounds checking. So 13036 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and 13037 TYPE_MAX_VALUE to the values for the mode above and only restrict 13038 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */ 13039 ENUM_UNDERLYING_TYPE (enumtype) 13040 = build_distinct_type_copy (underlying_type); 13041 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype)) = precision; 13042 set_min_and_max_values_for_integral_type 13043 (ENUM_UNDERLYING_TYPE (enumtype), precision, sgn); 13044 13045 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */ 13046 if (flag_strict_enums) 13047 set_min_and_max_values_for_integral_type (enumtype, precision, sgn); 13048 } 13049 else 13050 underlying_type = ENUM_UNDERLYING_TYPE (enumtype); 13051 13052 /* Convert each of the enumerators to the type of the underlying 13053 type of the enumeration. */ 13054 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values)) 13055 { 13056 location_t saved_location; 13057 13058 decl = TREE_VALUE (values); 13059 saved_location = input_location; 13060 input_location = DECL_SOURCE_LOCATION (decl); 13061 if (fixed_underlying_type_p) 13062 /* If the enumeration type has a fixed underlying type, we 13063 already checked all of the enumerator values. */ 13064 value = DECL_INITIAL (decl); 13065 else 13066 value = perform_implicit_conversion (underlying_type, 13067 DECL_INITIAL (decl), 13068 tf_warning_or_error); 13069 input_location = saved_location; 13070 13071 /* Do not clobber shared ints. */ 13072 value = copy_node (value); 13073 13074 TREE_TYPE (value) = enumtype; 13075 DECL_INITIAL (decl) = value; 13076 } 13077 13078 /* Fix up all variant types of this enum type. */ 13079 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t)) 13080 TYPE_VALUES (t) = TYPE_VALUES (enumtype); 13081 13082 if (at_class_scope_p () 13083 && COMPLETE_TYPE_P (current_class_type) 13084 && UNSCOPED_ENUM_P (enumtype)) 13085 insert_late_enum_def_into_classtype_sorted_fields (enumtype, 13086 current_class_type); 13087 13088 /* Finish debugging output for this type. */ 13089 rest_of_type_compilation (enumtype, namespace_bindings_p ()); 13090} 13091 13092/* Finishes the enum type. This is called only the first time an 13093 enumeration is seen, be it opaque or odinary. 13094 ENUMTYPE is the type object. */ 13095 13096void 13097finish_enum (tree enumtype) 13098{ 13099 if (processing_template_decl) 13100 { 13101 if (at_function_scope_p ()) 13102 add_stmt (build_min (TAG_DEFN, enumtype)); 13103 return; 13104 } 13105 13106 /* If this is a forward declaration, there should not be any variants, 13107 though we can get a variant in the middle of an enum-specifier with 13108 wacky code like 'enum E { e = sizeof(const E*) };' */ 13109 gcc_assert (enumtype == TYPE_MAIN_VARIANT (enumtype) 13110 && (TYPE_VALUES (enumtype) 13111 || !TYPE_NEXT_VARIANT (enumtype))); 13112} 13113 13114/* Build and install a CONST_DECL for an enumeration constant of the 13115 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided. 13116 LOC is the location of NAME. 13117 Assignment of sequential values by default is handled here. */ 13118 13119void 13120build_enumerator (tree name, tree value, tree enumtype, location_t loc) 13121{ 13122 tree decl; 13123 tree context; 13124 tree type; 13125 13126 /* scalar_constant_value will pull out this expression, so make sure 13127 it's folded as appropriate. */ 13128 if (processing_template_decl) 13129 value = fold_non_dependent_expr (value); 13130 13131 /* If the VALUE was erroneous, pretend it wasn't there; that will 13132 result in the enum being assigned the next value in sequence. */ 13133 if (value == error_mark_node) 13134 value = NULL_TREE; 13135 13136 /* Remove no-op casts from the value. */ 13137 if (value) 13138 STRIP_TYPE_NOPS (value); 13139 13140 if (! processing_template_decl) 13141 { 13142 /* Validate and default VALUE. */ 13143 if (value != NULL_TREE) 13144 { 13145 if (!ENUM_UNDERLYING_TYPE (enumtype)) 13146 { 13147 tree tmp_value = build_expr_type_conversion (WANT_INT | WANT_ENUM, 13148 value, true); 13149 if (tmp_value) 13150 value = tmp_value; 13151 } 13152 else if (! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value))) 13153 value = perform_implicit_conversion_flags 13154 (ENUM_UNDERLYING_TYPE (enumtype), value, tf_warning_or_error, 13155 LOOKUP_IMPLICIT | LOOKUP_NO_NARROWING); 13156 13157 if (value == error_mark_node) 13158 value = NULL_TREE; 13159 13160 if (value != NULL_TREE) 13161 { 13162 value = cxx_constant_value (value); 13163 13164 if (TREE_CODE (value) != INTEGER_CST 13165 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value))) 13166 { 13167 error ("enumerator value for %qD is not an integer constant", 13168 name); 13169 value = NULL_TREE; 13170 } 13171 } 13172 } 13173 13174 /* Default based on previous value. */ 13175 if (value == NULL_TREE) 13176 { 13177 if (TYPE_VALUES (enumtype)) 13178 { 13179 tree prev_value; 13180 bool overflowed; 13181 13182 /* C++03 7.2/4: If no initializer is specified for the first 13183 enumerator, the type is an unspecified integral 13184 type. Otherwise the type is the same as the type of the 13185 initializing value of the preceding enumerator unless the 13186 incremented value is not representable in that type, in 13187 which case the type is an unspecified integral type 13188 sufficient to contain the incremented value. */ 13189 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype))); 13190 if (error_operand_p (prev_value)) 13191 value = error_mark_node; 13192 else 13193 { 13194 tree type = TREE_TYPE (prev_value); 13195 signop sgn = TYPE_SIGN (type); 13196 widest_int wi = wi::add (wi::to_widest (prev_value), 1, sgn, 13197 &overflowed); 13198 if (!overflowed) 13199 { 13200 bool pos = !wi::neg_p (wi, sgn); 13201 if (!wi::fits_to_tree_p (wi, type)) 13202 { 13203 unsigned int itk; 13204 for (itk = itk_int; itk != itk_none; itk++) 13205 { 13206 type = integer_types[itk]; 13207 if (type != NULL_TREE 13208 && (pos || !TYPE_UNSIGNED (type)) 13209 && wi::fits_to_tree_p (wi, type)) 13210 break; 13211 } 13212 if (type && cxx_dialect < cxx11 13213 && itk > itk_unsigned_long) 13214 pedwarn (input_location, OPT_Wlong_long, pos ? "\ 13215incremented enumerator value is too large for %<unsigned long%>" : "\ 13216incremented enumerator value is too large for %<long%>"); 13217 } 13218 if (type == NULL_TREE) 13219 overflowed = true; 13220 else 13221 value = wide_int_to_tree (type, wi); 13222 } 13223 13224 if (overflowed) 13225 { 13226 error ("overflow in enumeration values at %qD", name); 13227 value = error_mark_node; 13228 } 13229 } 13230 } 13231 else 13232 value = integer_zero_node; 13233 } 13234 13235 /* Remove no-op casts from the value. */ 13236 STRIP_TYPE_NOPS (value); 13237 13238 /* If the underlying type of the enum is fixed, check whether 13239 the enumerator values fits in the underlying type. If it 13240 does not fit, the program is ill-formed [C++0x dcl.enum]. */ 13241 if (ENUM_UNDERLYING_TYPE (enumtype) 13242 && value 13243 && TREE_CODE (value) == INTEGER_CST) 13244 { 13245 if (!int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype))) 13246 error ("enumerator value %E is outside the range of underlying " 13247 "type %<%T%>", value, ENUM_UNDERLYING_TYPE (enumtype)); 13248 13249 /* Convert the value to the appropriate type. */ 13250 value = convert (ENUM_UNDERLYING_TYPE (enumtype), value); 13251 } 13252 } 13253 13254 /* C++ associates enums with global, function, or class declarations. */ 13255 context = current_scope (); 13256 13257 /* Build the actual enumeration constant. Note that the enumeration 13258 constants have the underlying type of the enum (if it is fixed) 13259 or the type of their initializer (if the underlying type of the 13260 enum is not fixed): 13261 13262 [ C++0x dcl.enum ] 13263 13264 If the underlying type is fixed, the type of each enumerator 13265 prior to the closing brace is the underlying type; if the 13266 initializing value of an enumerator cannot be represented by 13267 the underlying type, the program is ill-formed. If the 13268 underlying type is not fixed, the type of each enumerator is 13269 the type of its initializing value. 13270 13271 If the underlying type is not fixed, it will be computed by 13272 finish_enum and we will reset the type of this enumerator. Of 13273 course, if we're processing a template, there may be no value. */ 13274 type = value ? TREE_TYPE (value) : NULL_TREE; 13275 13276 decl = build_decl (loc, CONST_DECL, name, type); 13277 13278 DECL_CONTEXT (decl) = enumtype; 13279 TREE_CONSTANT (decl) = 1; 13280 TREE_READONLY (decl) = 1; 13281 DECL_INITIAL (decl) = value; 13282 13283 if (context && context == current_class_type && !SCOPED_ENUM_P (enumtype)) 13284 /* In something like `struct S { enum E { i = 7 }; };' we put `i' 13285 on the TYPE_FIELDS list for `S'. (That's so that you can say 13286 things like `S::i' later.) */ 13287 finish_member_declaration (decl); 13288 else 13289 pushdecl (decl); 13290 13291 /* Add this enumeration constant to the list for this type. */ 13292 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype)); 13293} 13294 13295/* Look for an enumerator with the given NAME within the enumeration 13296 type ENUMTYPE. This routine is used primarily for qualified name 13297 lookup into an enumerator in C++0x, e.g., 13298 13299 enum class Color { Red, Green, Blue }; 13300 13301 Color color = Color::Red; 13302 13303 Returns the value corresponding to the enumerator, or 13304 NULL_TREE if no such enumerator was found. */ 13305tree 13306lookup_enumerator (tree enumtype, tree name) 13307{ 13308 tree e; 13309 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE); 13310 13311 e = purpose_member (name, TYPE_VALUES (enumtype)); 13312 return e? TREE_VALUE (e) : NULL_TREE; 13313} 13314 13315 13316/* We're defining DECL. Make sure that its type is OK. */ 13317 13318static void 13319check_function_type (tree decl, tree current_function_parms) 13320{ 13321 tree fntype = TREE_TYPE (decl); 13322 tree return_type = complete_type (TREE_TYPE (fntype)); 13323 13324 /* In a function definition, arg types must be complete. */ 13325 require_complete_types_for_parms (current_function_parms); 13326 13327 if (dependent_type_p (return_type) 13328 || type_uses_auto (return_type)) 13329 return; 13330 if (!COMPLETE_OR_VOID_TYPE_P (return_type) 13331 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type))) 13332 { 13333 tree args = TYPE_ARG_TYPES (fntype); 13334 13335 if (!COMPLETE_OR_VOID_TYPE_P (return_type)) 13336 error ("return type %q#T is incomplete", return_type); 13337 else 13338 error ("return type has Java class type %q#T", return_type); 13339 13340 /* Make it return void instead. */ 13341 if (TREE_CODE (fntype) == METHOD_TYPE) 13342 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)), 13343 void_type_node, 13344 TREE_CHAIN (args)); 13345 else 13346 fntype = build_function_type (void_type_node, args); 13347 fntype 13348 = build_exception_variant (fntype, 13349 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl))); 13350 fntype = (cp_build_type_attribute_variant 13351 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (decl)))); 13352 TREE_TYPE (decl) = fntype; 13353 } 13354 else 13355 abstract_virtuals_error (decl, TREE_TYPE (fntype)); 13356} 13357 13358/* Create the FUNCTION_DECL for a function definition. 13359 DECLSPECS and DECLARATOR are the parts of the declaration; 13360 they describe the function's name and the type it returns, 13361 but twisted together in a fashion that parallels the syntax of C. 13362 13363 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the 13364 DECLARATOR is really the DECL for the function we are about to 13365 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE 13366 indicating that the function is an inline defined in-class. 13367 13368 This function creates a binding context for the function body 13369 as well as setting up the FUNCTION_DECL in current_function_decl. 13370 13371 For C++, we must first check whether that datum makes any sense. 13372 For example, "class A local_a(1,2);" means that variable local_a 13373 is an aggregate of type A, which should have a constructor 13374 applied to it with the argument list [1, 2]. 13375 13376 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node, 13377 or may be a BLOCK if the function has been defined previously 13378 in this translation unit. On exit, DECL_INITIAL (decl1) will be 13379 error_mark_node if the function has never been defined, or 13380 a BLOCK if the function has been defined somewhere. */ 13381 13382bool 13383start_preparsed_function (tree decl1, tree attrs, int flags) 13384{ 13385 tree ctype = NULL_TREE; 13386 tree fntype; 13387 tree restype; 13388 int doing_friend = 0; 13389 cp_binding_level *bl; 13390 tree current_function_parms; 13391 struct c_fileinfo *finfo 13392 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1))); 13393 bool honor_interface; 13394 13395 /* Sanity check. */ 13396 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node))); 13397 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE); 13398 13399 fntype = TREE_TYPE (decl1); 13400 if (TREE_CODE (fntype) == METHOD_TYPE) 13401 ctype = TYPE_METHOD_BASETYPE (fntype); 13402 13403 /* ISO C++ 11.4/5. A friend function defined in a class is in 13404 the (lexical) scope of the class in which it is defined. */ 13405 if (!ctype && DECL_FRIEND_P (decl1)) 13406 { 13407 ctype = DECL_FRIEND_CONTEXT (decl1); 13408 13409 /* CTYPE could be null here if we're dealing with a template; 13410 for example, `inline friend float foo()' inside a template 13411 will have no CTYPE set. */ 13412 if (ctype && TREE_CODE (ctype) != RECORD_TYPE) 13413 ctype = NULL_TREE; 13414 else 13415 doing_friend = 1; 13416 } 13417 13418 if (DECL_DECLARED_INLINE_P (decl1) 13419 && lookup_attribute ("noinline", attrs)) 13420 warning (0, "inline function %q+D given attribute noinline", decl1); 13421 13422 /* Handle gnu_inline attribute. */ 13423 if (GNU_INLINE_P (decl1)) 13424 { 13425 DECL_EXTERNAL (decl1) = 1; 13426 DECL_NOT_REALLY_EXTERN (decl1) = 0; 13427 DECL_INTERFACE_KNOWN (decl1) = 1; 13428 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1; 13429 } 13430 13431 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1)) 13432 /* This is a constructor, we must ensure that any default args 13433 introduced by this definition are propagated to the clones 13434 now. The clones are used directly in overload resolution. */ 13435 adjust_clone_args (decl1); 13436 13437 /* Sometimes we don't notice that a function is a static member, and 13438 build a METHOD_TYPE for it. Fix that up now. */ 13439 gcc_assert (!(ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1) 13440 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)); 13441 13442 /* Set up current_class_type, and enter the scope of the class, if 13443 appropriate. */ 13444 if (ctype) 13445 push_nested_class (ctype); 13446 else if (DECL_STATIC_FUNCTION_P (decl1)) 13447 push_nested_class (DECL_CONTEXT (decl1)); 13448 13449 /* Now that we have entered the scope of the class, we must restore 13450 the bindings for any template parameters surrounding DECL1, if it 13451 is an inline member template. (Order is important; consider the 13452 case where a template parameter has the same name as a field of 13453 the class.) It is not until after this point that 13454 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */ 13455 if (flags & SF_INCLASS_INLINE) 13456 maybe_begin_member_template_processing (decl1); 13457 13458 /* Effective C++ rule 15. */ 13459 if (warn_ecpp 13460 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR 13461 && VOID_TYPE_P (TREE_TYPE (fntype))) 13462 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>"); 13463 13464 /* Make the init_value nonzero so pushdecl knows this is not tentative. 13465 error_mark_node is replaced below (in poplevel) with the BLOCK. */ 13466 if (!DECL_INITIAL (decl1)) 13467 DECL_INITIAL (decl1) = error_mark_node; 13468 13469 /* This function exists in static storage. 13470 (This does not mean `static' in the C sense!) */ 13471 TREE_STATIC (decl1) = 1; 13472 13473 /* We must call push_template_decl after current_class_type is set 13474 up. (If we are processing inline definitions after exiting a 13475 class scope, current_class_type will be NULL_TREE until set above 13476 by push_nested_class.) */ 13477 if (processing_template_decl) 13478 { 13479 tree newdecl1 = push_template_decl (decl1); 13480 if (newdecl1 == error_mark_node) 13481 { 13482 if (ctype || DECL_STATIC_FUNCTION_P (decl1)) 13483 pop_nested_class (); 13484 return false; 13485 } 13486 decl1 = newdecl1; 13487 } 13488 13489 /* We are now in the scope of the function being defined. */ 13490 current_function_decl = decl1; 13491 13492 /* Save the parm names or decls from this function's declarator 13493 where store_parm_decls will find them. */ 13494 current_function_parms = DECL_ARGUMENTS (decl1); 13495 13496 /* Make sure the parameter and return types are reasonable. When 13497 you declare a function, these types can be incomplete, but they 13498 must be complete when you define the function. */ 13499 check_function_type (decl1, current_function_parms); 13500 13501 /* Build the return declaration for the function. */ 13502 restype = TREE_TYPE (fntype); 13503 13504 if (DECL_RESULT (decl1) == NULL_TREE) 13505 { 13506 tree resdecl; 13507 13508 resdecl = build_decl (input_location, RESULT_DECL, 0, restype); 13509 DECL_ARTIFICIAL (resdecl) = 1; 13510 DECL_IGNORED_P (resdecl) = 1; 13511 DECL_RESULT (decl1) = resdecl; 13512 13513 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl); 13514 } 13515 13516 /* Let the user know we're compiling this function. */ 13517 announce_function (decl1); 13518 13519 /* Record the decl so that the function name is defined. 13520 If we already have a decl for this name, and it is a FUNCTION_DECL, 13521 use the old decl. */ 13522 if (!processing_template_decl && !(flags & SF_PRE_PARSED)) 13523 { 13524 /* A specialization is not used to guide overload resolution. */ 13525 if (!DECL_FUNCTION_MEMBER_P (decl1) 13526 && !(DECL_USE_TEMPLATE (decl1) && 13527 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1)))) 13528 { 13529 tree olddecl = pushdecl (decl1); 13530 13531 if (olddecl == error_mark_node) 13532 /* If something went wrong when registering the declaration, 13533 use DECL1; we have to have a FUNCTION_DECL to use when 13534 parsing the body of the function. */ 13535 ; 13536 else 13537 { 13538 /* Otherwise, OLDDECL is either a previous declaration 13539 of the same function or DECL1 itself. */ 13540 13541 if (warn_missing_declarations 13542 && olddecl == decl1 13543 && !DECL_MAIN_P (decl1) 13544 && TREE_PUBLIC (decl1) 13545 && !DECL_DECLARED_INLINE_P (decl1)) 13546 { 13547 tree context; 13548 13549 /* Check whether DECL1 is in an anonymous 13550 namespace. */ 13551 for (context = DECL_CONTEXT (decl1); 13552 context; 13553 context = DECL_CONTEXT (context)) 13554 { 13555 if (TREE_CODE (context) == NAMESPACE_DECL 13556 && DECL_NAME (context) == NULL_TREE) 13557 break; 13558 } 13559 13560 if (context == NULL) 13561 warning (OPT_Wmissing_declarations, 13562 "no previous declaration for %q+D", decl1); 13563 } 13564 13565 decl1 = olddecl; 13566 } 13567 } 13568 else 13569 { 13570 /* We need to set the DECL_CONTEXT. */ 13571 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1)) 13572 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1)); 13573 } 13574 fntype = TREE_TYPE (decl1); 13575 restype = TREE_TYPE (fntype); 13576 13577 /* If #pragma weak applies, mark the decl appropriately now. 13578 The pragma only applies to global functions. Because 13579 determining whether or not the #pragma applies involves 13580 computing the mangled name for the declaration, we cannot 13581 apply the pragma until after we have merged this declaration 13582 with any previous declarations; if the original declaration 13583 has a linkage specification, that specification applies to 13584 the definition as well, and may affect the mangled name. */ 13585 if (DECL_FILE_SCOPE_P (decl1)) 13586 maybe_apply_pragma_weak (decl1); 13587 } 13588 13589 /* Reset this in case the call to pushdecl changed it. */ 13590 current_function_decl = decl1; 13591 13592 gcc_assert (DECL_INITIAL (decl1)); 13593 13594 /* This function may already have been parsed, in which case just 13595 return; our caller will skip over the body without parsing. */ 13596 if (DECL_INITIAL (decl1) != error_mark_node) 13597 return true; 13598 13599 /* Initialize RTL machinery. We cannot do this until 13600 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this 13601 even when processing a template; this is how we get 13602 CFUN set up, and our per-function variables initialized. 13603 FIXME factor out the non-RTL stuff. */ 13604 bl = current_binding_level; 13605 allocate_struct_function (decl1, processing_template_decl); 13606 13607 /* Initialize the language data structures. Whenever we start 13608 a new function, we destroy temporaries in the usual way. */ 13609 cfun->language = ggc_cleared_alloc<language_function> (); 13610 current_stmt_tree ()->stmts_are_full_exprs_p = 1; 13611 current_binding_level = bl; 13612 13613 if (!processing_template_decl && type_uses_auto (restype)) 13614 { 13615 FNDECL_USED_AUTO (decl1) = true; 13616 current_function_auto_return_pattern = restype; 13617 } 13618 13619 /* Start the statement-tree, start the tree now. */ 13620 DECL_SAVED_TREE (decl1) = push_stmt_list (); 13621 13622 /* If we are (erroneously) defining a function that we have already 13623 defined before, wipe out what we knew before. */ 13624 if (!DECL_PENDING_INLINE_P (decl1)) 13625 DECL_SAVED_FUNCTION_DATA (decl1) = NULL; 13626 13627 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1)) 13628 { 13629 /* We know that this was set up by `grokclassfn'. We do not 13630 wait until `store_parm_decls', since evil parse errors may 13631 never get us to that point. Here we keep the consistency 13632 between `current_class_type' and `current_class_ptr'. */ 13633 tree t = DECL_ARGUMENTS (decl1); 13634 13635 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL); 13636 gcc_assert (TYPE_PTR_P (TREE_TYPE (t))); 13637 13638 cp_function_chain->x_current_class_ref 13639 = cp_build_indirect_ref (t, RO_NULL, tf_warning_or_error); 13640 /* Set this second to avoid shortcut in cp_build_indirect_ref. */ 13641 cp_function_chain->x_current_class_ptr = t; 13642 13643 /* Constructors and destructors need to know whether they're "in 13644 charge" of initializing virtual base classes. */ 13645 t = DECL_CHAIN (t); 13646 if (DECL_HAS_IN_CHARGE_PARM_P (decl1)) 13647 { 13648 current_in_charge_parm = t; 13649 t = DECL_CHAIN (t); 13650 } 13651 if (DECL_HAS_VTT_PARM_P (decl1)) 13652 { 13653 gcc_assert (DECL_NAME (t) == vtt_parm_identifier); 13654 current_vtt_parm = t; 13655 } 13656 } 13657 13658 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1) 13659 /* Implicitly-defined methods (like the 13660 destructor for a class in which no destructor 13661 is explicitly declared) must not be defined 13662 until their definition is needed. So, we 13663 ignore interface specifications for 13664 compiler-generated functions. */ 13665 && !DECL_ARTIFICIAL (decl1)); 13666 13667 if (processing_template_decl) 13668 /* Don't mess with interface flags. */; 13669 else if (DECL_INTERFACE_KNOWN (decl1)) 13670 { 13671 tree ctx = decl_function_context (decl1); 13672 13673 if (DECL_NOT_REALLY_EXTERN (decl1)) 13674 DECL_EXTERNAL (decl1) = 0; 13675 13676 if (ctx != NULL_TREE && vague_linkage_p (ctx)) 13677 /* This is a function in a local class in an extern inline 13678 or template function. */ 13679 comdat_linkage (decl1); 13680 } 13681 /* If this function belongs to an interface, it is public. 13682 If it belongs to someone else's interface, it is also external. 13683 This only affects inlines and template instantiations. */ 13684 else if (!finfo->interface_unknown && honor_interface) 13685 { 13686 if (DECL_DECLARED_INLINE_P (decl1) 13687 || DECL_TEMPLATE_INSTANTIATION (decl1)) 13688 { 13689 DECL_EXTERNAL (decl1) 13690 = (finfo->interface_only 13691 || (DECL_DECLARED_INLINE_P (decl1) 13692 && ! flag_implement_inlines 13693 && !DECL_VINDEX (decl1))); 13694 13695 /* For WIN32 we also want to put these in linkonce sections. */ 13696 maybe_make_one_only (decl1); 13697 } 13698 else 13699 DECL_EXTERNAL (decl1) = 0; 13700 DECL_INTERFACE_KNOWN (decl1) = 1; 13701 /* If this function is in an interface implemented in this file, 13702 make sure that the back end knows to emit this function 13703 here. */ 13704 if (!DECL_EXTERNAL (decl1)) 13705 mark_needed (decl1); 13706 } 13707 else if (finfo->interface_unknown && finfo->interface_only 13708 && honor_interface) 13709 { 13710 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma 13711 interface, we will have both finfo->interface_unknown and 13712 finfo->interface_only set. In that case, we don't want to 13713 use the normal heuristics because someone will supply a 13714 #pragma implementation elsewhere, and deducing it here would 13715 produce a conflict. */ 13716 comdat_linkage (decl1); 13717 DECL_EXTERNAL (decl1) = 0; 13718 DECL_INTERFACE_KNOWN (decl1) = 1; 13719 DECL_DEFER_OUTPUT (decl1) = 1; 13720 } 13721 else 13722 { 13723 /* This is a definition, not a reference. 13724 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */ 13725 if (!GNU_INLINE_P (decl1)) 13726 DECL_EXTERNAL (decl1) = 0; 13727 13728 if ((DECL_DECLARED_INLINE_P (decl1) 13729 || DECL_TEMPLATE_INSTANTIATION (decl1)) 13730 && ! DECL_INTERFACE_KNOWN (decl1)) 13731 DECL_DEFER_OUTPUT (decl1) = 1; 13732 else 13733 DECL_INTERFACE_KNOWN (decl1) = 1; 13734 } 13735 13736 /* Determine the ELF visibility attribute for the function. We must not 13737 do this before calling "pushdecl", as we must allow "duplicate_decls" 13738 to merge any attributes appropriately. We also need to wait until 13739 linkage is set. */ 13740 if (!DECL_CLONED_FUNCTION_P (decl1)) 13741 determine_visibility (decl1); 13742 13743 if (!processing_template_decl) 13744 maybe_instantiate_noexcept (decl1); 13745 13746 begin_scope (sk_function_parms, decl1); 13747 13748 ++function_depth; 13749 13750 if (DECL_DESTRUCTOR_P (decl1) 13751 || (DECL_CONSTRUCTOR_P (decl1) 13752 && targetm.cxx.cdtor_returns_this ())) 13753 { 13754 cdtor_label = create_artificial_label (input_location); 13755 } 13756 13757 start_fname_decls (); 13758 13759 store_parm_decls (current_function_parms); 13760 13761 return true; 13762} 13763 13764 13765/* Like start_preparsed_function, except that instead of a 13766 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR. 13767 13768 Returns true on success. If the DECLARATOR is not suitable 13769 for a function, we return false, which tells the parser to 13770 skip the entire function. */ 13771 13772bool 13773start_function (cp_decl_specifier_seq *declspecs, 13774 const cp_declarator *declarator, 13775 tree attrs) 13776{ 13777 tree decl1; 13778 13779 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs); 13780 if (decl1 == error_mark_node) 13781 return false; 13782 /* If the declarator is not suitable for a function definition, 13783 cause a syntax error. */ 13784 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) 13785 { 13786 error ("invalid function declaration"); 13787 return false; 13788 } 13789 13790 if (DECL_MAIN_P (decl1)) 13791 /* main must return int. grokfndecl should have corrected it 13792 (and issued a diagnostic) if the user got it wrong. */ 13793 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)), 13794 integer_type_node)); 13795 13796 return start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT); 13797} 13798 13799/* Returns true iff an EH_SPEC_BLOCK should be created in the body of 13800 FN. */ 13801 13802static bool 13803use_eh_spec_block (tree fn) 13804{ 13805 return (flag_exceptions && flag_enforce_eh_specs 13806 && !processing_template_decl 13807 && !type_throw_all_p (TREE_TYPE (fn)) 13808 /* We insert the EH_SPEC_BLOCK only in the original 13809 function; then, it is copied automatically to the 13810 clones. */ 13811 && !DECL_CLONED_FUNCTION_P (fn) 13812 /* Implicitly-generated constructors and destructors have 13813 exception specifications. However, those specifications 13814 are the union of the possible exceptions specified by the 13815 constructors/destructors for bases and members, so no 13816 unallowed exception will ever reach this function. By 13817 not creating the EH_SPEC_BLOCK we save a little memory, 13818 and we avoid spurious warnings about unreachable 13819 code. */ 13820 && !DECL_DEFAULTED_FN (fn)); 13821} 13822 13823/* Store the parameter declarations into the current function declaration. 13824 This is called after parsing the parameter declarations, before 13825 digesting the body of the function. 13826 13827 Also install to binding contour return value identifier, if any. */ 13828 13829static void 13830store_parm_decls (tree current_function_parms) 13831{ 13832 tree fndecl = current_function_decl; 13833 tree parm; 13834 13835 /* This is a chain of any other decls that came in among the parm 13836 declarations. If a parm is declared with enum {foo, bar} x; 13837 then CONST_DECLs for foo and bar are put here. */ 13838 tree nonparms = NULL_TREE; 13839 13840 if (current_function_parms) 13841 { 13842 /* This case is when the function was defined with an ANSI prototype. 13843 The parms already have decls, so we need not do anything here 13844 except record them as in effect 13845 and complain if any redundant old-style parm decls were written. */ 13846 13847 tree specparms = current_function_parms; 13848 tree next; 13849 13850 /* Must clear this because it might contain TYPE_DECLs declared 13851 at class level. */ 13852 current_binding_level->names = NULL; 13853 13854 /* If we're doing semantic analysis, then we'll call pushdecl 13855 for each of these. We must do them in reverse order so that 13856 they end in the correct forward order. */ 13857 specparms = nreverse (specparms); 13858 13859 for (parm = specparms; parm; parm = next) 13860 { 13861 next = DECL_CHAIN (parm); 13862 if (TREE_CODE (parm) == PARM_DECL) 13863 { 13864 if (DECL_NAME (parm) == NULL_TREE 13865 || !VOID_TYPE_P (parm)) 13866 pushdecl (parm); 13867 else 13868 error ("parameter %qD declared void", parm); 13869 } 13870 else 13871 { 13872 /* If we find an enum constant or a type tag, 13873 put it aside for the moment. */ 13874 TREE_CHAIN (parm) = NULL_TREE; 13875 nonparms = chainon (nonparms, parm); 13876 } 13877 } 13878 13879 /* Get the decls in their original chain order and record in the 13880 function. This is all and only the PARM_DECLs that were 13881 pushed into scope by the loop above. */ 13882 DECL_ARGUMENTS (fndecl) = getdecls (); 13883 } 13884 else 13885 DECL_ARGUMENTS (fndecl) = NULL_TREE; 13886 13887 /* Now store the final chain of decls for the arguments 13888 as the decl-chain of the current lexical scope. 13889 Put the enumerators in as well, at the front so that 13890 DECL_ARGUMENTS is not modified. */ 13891 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl)); 13892 13893 if (use_eh_spec_block (current_function_decl)) 13894 current_eh_spec_block = begin_eh_spec_block (); 13895} 13896 13897 13898/* We have finished doing semantic analysis on DECL, but have not yet 13899 generated RTL for its body. Save away our current state, so that 13900 when we want to generate RTL later we know what to do. */ 13901 13902static void 13903save_function_data (tree decl) 13904{ 13905 struct language_function *f; 13906 13907 /* Save the language-specific per-function data so that we can 13908 get it back when we really expand this function. */ 13909 gcc_assert (!DECL_PENDING_INLINE_P (decl)); 13910 13911 /* Make a copy. */ 13912 f = ggc_alloc<language_function> (); 13913 memcpy (f, cp_function_chain, sizeof (struct language_function)); 13914 DECL_SAVED_FUNCTION_DATA (decl) = f; 13915 13916 /* Clear out the bits we don't need. */ 13917 f->base.x_stmt_tree.x_cur_stmt_list = NULL; 13918 f->bindings = NULL; 13919 f->x_local_names = NULL; 13920 f->base.local_typedefs = NULL; 13921} 13922 13923 13924/* Set the return value of the constructor (if present). */ 13925 13926static void 13927finish_constructor_body (void) 13928{ 13929 tree val; 13930 tree exprstmt; 13931 13932 if (targetm.cxx.cdtor_returns_this () 13933 && (! TYPE_FOR_JAVA (current_class_type))) 13934 { 13935 /* Any return from a constructor will end up here. */ 13936 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label)); 13937 13938 val = DECL_ARGUMENTS (current_function_decl); 13939 val = build2 (MODIFY_EXPR, TREE_TYPE (val), 13940 DECL_RESULT (current_function_decl), val); 13941 /* Return the address of the object. */ 13942 exprstmt = build_stmt (input_location, RETURN_EXPR, val); 13943 add_stmt (exprstmt); 13944 } 13945} 13946 13947/* Do all the processing for the beginning of a destructor; set up the 13948 vtable pointers and cleanups for bases and members. */ 13949 13950static void 13951begin_destructor_body (void) 13952{ 13953 tree compound_stmt; 13954 13955 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already 13956 issued an error message. We still want to try to process the 13957 body of the function, but initialize_vtbl_ptrs will crash if 13958 TYPE_BINFO is NULL. */ 13959 if (COMPLETE_TYPE_P (current_class_type)) 13960 { 13961 compound_stmt = begin_compound_stmt (0); 13962 /* Make all virtual function table pointers in non-virtual base 13963 classes point to CURRENT_CLASS_TYPE's virtual function 13964 tables. */ 13965 initialize_vtbl_ptrs (current_class_ptr); 13966 finish_compound_stmt (compound_stmt); 13967 13968 if (flag_lifetime_dse 13969 /* Clobbering an empty base is harmful if it overlays real data. */ 13970 && !is_empty_class (current_class_type)) 13971 { 13972 /* Insert a cleanup to let the back end know that the object is dead 13973 when we exit the destructor, either normally or via exception. */ 13974 tree btype = CLASSTYPE_AS_BASE (current_class_type); 13975 tree clobber = build_constructor (btype, NULL); 13976 TREE_THIS_VOLATILE (clobber) = true; 13977 tree bref = build_nop (build_reference_type (btype), 13978 current_class_ptr); 13979 bref = convert_from_reference (bref); 13980 tree exprstmt = build2 (MODIFY_EXPR, btype, bref, clobber); 13981 finish_decl_cleanup (NULL_TREE, exprstmt); 13982 } 13983 13984 /* And insert cleanups for our bases and members so that they 13985 will be properly destroyed if we throw. */ 13986 push_base_cleanups (); 13987 } 13988} 13989 13990/* At the end of every destructor we generate code to delete the object if 13991 necessary. Do that now. */ 13992 13993static void 13994finish_destructor_body (void) 13995{ 13996 tree exprstmt; 13997 13998 /* Any return from a destructor will end up here; that way all base 13999 and member cleanups will be run when the function returns. */ 14000 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label)); 14001 14002 /* In a virtual destructor, we must call delete. */ 14003 if (DECL_VIRTUAL_P (current_function_decl)) 14004 { 14005 tree if_stmt; 14006 tree virtual_size = cxx_sizeof (current_class_type); 14007 14008 /* [class.dtor] 14009 14010 At the point of definition of a virtual destructor (including 14011 an implicit definition), non-placement operator delete shall 14012 be looked up in the scope of the destructor's class and if 14013 found shall be accessible and unambiguous. */ 14014 exprstmt = build_op_delete_call (DELETE_EXPR, current_class_ptr, 14015 virtual_size, 14016 /*global_p=*/false, 14017 /*placement=*/NULL_TREE, 14018 /*alloc_fn=*/NULL_TREE, 14019 tf_warning_or_error); 14020 14021 if_stmt = begin_if_stmt (); 14022 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node, 14023 current_in_charge_parm, 14024 integer_one_node), 14025 if_stmt); 14026 finish_expr_stmt (exprstmt); 14027 finish_then_clause (if_stmt); 14028 finish_if_stmt (if_stmt); 14029 } 14030 14031 if (targetm.cxx.cdtor_returns_this ()) 14032 { 14033 tree val; 14034 14035 val = DECL_ARGUMENTS (current_function_decl); 14036 val = build2 (MODIFY_EXPR, TREE_TYPE (val), 14037 DECL_RESULT (current_function_decl), val); 14038 /* Return the address of the object. */ 14039 exprstmt = build_stmt (input_location, RETURN_EXPR, val); 14040 add_stmt (exprstmt); 14041 } 14042} 14043 14044/* Do the necessary processing for the beginning of a function body, which 14045 in this case includes member-initializers, but not the catch clauses of 14046 a function-try-block. Currently, this means opening a binding level 14047 for the member-initializers (in a ctor), member cleanups (in a dtor), 14048 and capture proxies (in a lambda operator()). */ 14049 14050tree 14051begin_function_body (void) 14052{ 14053 tree stmt; 14054 14055 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl)) 14056 return NULL_TREE; 14057 14058 if (processing_template_decl) 14059 /* Do nothing now. */; 14060 else 14061 /* Always keep the BLOCK node associated with the outermost pair of 14062 curly braces of a function. These are needed for correct 14063 operation of dwarfout.c. */ 14064 keep_next_level (true); 14065 14066 stmt = begin_compound_stmt (BCS_FN_BODY); 14067 14068 if (processing_template_decl) 14069 /* Do nothing now. */; 14070 else if (DECL_DESTRUCTOR_P (current_function_decl)) 14071 begin_destructor_body (); 14072 14073 return stmt; 14074} 14075 14076/* Do the processing for the end of a function body. Currently, this means 14077 closing out the cleanups for fully-constructed bases and members, and in 14078 the case of the destructor, deleting the object if desired. Again, this 14079 is only meaningful for [cd]tors, since they are the only functions where 14080 there is a significant distinction between the main body and any 14081 function catch clauses. Handling, say, main() return semantics here 14082 would be wrong, as flowing off the end of a function catch clause for 14083 main() would also need to return 0. */ 14084 14085void 14086finish_function_body (tree compstmt) 14087{ 14088 if (compstmt == NULL_TREE) 14089 return; 14090 14091 /* Close the block. */ 14092 finish_compound_stmt (compstmt); 14093 14094 if (processing_template_decl) 14095 /* Do nothing now. */; 14096 else if (DECL_CONSTRUCTOR_P (current_function_decl)) 14097 finish_constructor_body (); 14098 else if (DECL_DESTRUCTOR_P (current_function_decl)) 14099 finish_destructor_body (); 14100} 14101 14102/* Given a function, returns the BLOCK corresponding to the outermost level 14103 of curly braces, skipping the artificial block created for constructor 14104 initializers. */ 14105 14106tree 14107outer_curly_brace_block (tree fndecl) 14108{ 14109 tree block = DECL_INITIAL (fndecl); 14110 if (BLOCK_OUTER_CURLY_BRACE_P (block)) 14111 return block; 14112 block = BLOCK_SUBBLOCKS (block); 14113 if (BLOCK_OUTER_CURLY_BRACE_P (block)) 14114 return block; 14115 block = BLOCK_SUBBLOCKS (block); 14116 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block)); 14117 return block; 14118} 14119 14120/* If FNDECL is a class's key method, add the class to the list of 14121 keyed classes that should be emitted. */ 14122 14123static void 14124record_key_method_defined (tree fndecl) 14125{ 14126 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl) 14127 && DECL_VIRTUAL_P (fndecl) 14128 && !processing_template_decl) 14129 { 14130 tree fnclass = DECL_CONTEXT (fndecl); 14131 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass)) 14132 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes); 14133 } 14134} 14135 14136/* Subroutine of finish_function. 14137 Save the body of constexpr functions for possible 14138 future compile time evaluation. */ 14139 14140static void 14141maybe_save_function_definition (tree fun) 14142{ 14143 if (!processing_template_decl 14144 && DECL_DECLARED_CONSTEXPR_P (fun) 14145 && !cp_function_chain->invalid_constexpr 14146 && !DECL_CLONED_FUNCTION_P (fun)) 14147 register_constexpr_fundef (fun, DECL_SAVED_TREE (fun)); 14148} 14149 14150/* Finish up a function declaration and compile that function 14151 all the way to assembler language output. The free the storage 14152 for the function definition. 14153 14154 FLAGS is a bitwise or of the following values: 14155 2 - INCLASS_INLINE 14156 We just finished processing the body of an in-class inline 14157 function definition. (This processing will have taken place 14158 after the class definition is complete.) */ 14159 14160tree 14161finish_function (int flags) 14162{ 14163 tree fndecl = current_function_decl; 14164 tree fntype, ctype = NULL_TREE; 14165 int inclass_inline = (flags & 2) != 0; 14166 14167 /* When we get some parse errors, we can end up without a 14168 current_function_decl, so cope. */ 14169 if (fndecl == NULL_TREE) 14170 return error_mark_node; 14171 14172 if (c_dialect_objc ()) 14173 objc_finish_function (); 14174 14175 gcc_assert (!defer_mark_used_calls); 14176 defer_mark_used_calls = true; 14177 14178 record_key_method_defined (fndecl); 14179 14180 fntype = TREE_TYPE (fndecl); 14181 14182 /* TREE_READONLY (fndecl) = 1; 14183 This caused &foo to be of type ptr-to-const-function 14184 which then got a warning when stored in a ptr-to-function variable. */ 14185 14186 gcc_assert (building_stmt_list_p ()); 14187 /* The current function is being defined, so its DECL_INITIAL should 14188 be set, and unless there's a multiple definition, it should be 14189 error_mark_node. */ 14190 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node); 14191 14192 /* For a cloned function, we've already got all the code we need; 14193 there's no need to add any extra bits. */ 14194 if (!DECL_CLONED_FUNCTION_P (fndecl)) 14195 { 14196 /* Make it so that `main' always returns 0 by default. */ 14197 if (DECL_MAIN_P (current_function_decl)) 14198 finish_return_stmt (integer_zero_node); 14199 14200 if (use_eh_spec_block (current_function_decl)) 14201 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS 14202 (TREE_TYPE (current_function_decl)), 14203 current_eh_spec_block); 14204 } 14205 14206 /* If we're saving up tree structure, tie off the function now. */ 14207 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl)); 14208 14209 if (fn_contains_cilk_spawn_p (cfun) && !processing_template_decl) 14210 cfun->cilk_frame_decl = insert_cilk_frame (fndecl); 14211 14212 finish_fname_decls (); 14213 14214 /* If this function can't throw any exceptions, remember that. */ 14215 if (!processing_template_decl 14216 && !cp_function_chain->can_throw 14217 && !flag_non_call_exceptions 14218 && !decl_replaceable_p (fndecl)) 14219 TREE_NOTHROW (fndecl) = 1; 14220 14221 /* This must come after expand_function_end because cleanups might 14222 have declarations (from inline functions) that need to go into 14223 this function's blocks. */ 14224 14225 /* If the current binding level isn't the outermost binding level 14226 for this function, either there is a bug, or we have experienced 14227 syntax errors and the statement tree is malformed. */ 14228 if (current_binding_level->kind != sk_function_parms) 14229 { 14230 /* Make sure we have already experienced errors. */ 14231 gcc_assert (errorcount); 14232 14233 /* Throw away the broken statement tree and extra binding 14234 levels. */ 14235 DECL_SAVED_TREE (fndecl) = alloc_stmt_list (); 14236 14237 while (current_binding_level->kind != sk_function_parms) 14238 { 14239 if (current_binding_level->kind == sk_class) 14240 pop_nested_class (); 14241 else 14242 poplevel (0, 0, 0); 14243 } 14244 } 14245 poplevel (1, 0, 1); 14246 14247 /* Statements should always be full-expressions at the outermost set 14248 of curly braces for a function. */ 14249 gcc_assert (stmts_are_full_exprs_p ()); 14250 14251 /* If there are no return statements in a function with auto return type, 14252 the return type is void. But if the declared type is something like 14253 auto*, this is an error. */ 14254 if (!processing_template_decl && FNDECL_USED_AUTO (fndecl) 14255 && TREE_TYPE (fntype) == current_function_auto_return_pattern) 14256 { 14257 if (!is_auto (current_function_auto_return_pattern) 14258 && !current_function_returns_value && !current_function_returns_null) 14259 { 14260 error ("no return statements in function returning %qT", 14261 current_function_auto_return_pattern); 14262 inform (input_location, "only plain %<auto%> return type can be " 14263 "deduced to %<void%>"); 14264 } 14265 apply_deduced_return_type (fndecl, void_type_node); 14266 fntype = TREE_TYPE (fndecl); 14267 } 14268 14269 /* Save constexpr function body before it gets munged by 14270 the NRV transformation. */ 14271 maybe_save_function_definition (fndecl); 14272 14273 /* Set up the named return value optimization, if we can. Candidate 14274 variables are selected in check_return_expr. */ 14275 if (current_function_return_value) 14276 { 14277 tree r = current_function_return_value; 14278 tree outer; 14279 14280 if (r != error_mark_node 14281 /* This is only worth doing for fns that return in memory--and 14282 simpler, since we don't have to worry about promoted modes. */ 14283 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl) 14284 /* Only allow this for variables declared in the outer scope of 14285 the function so we know that their lifetime always ends with a 14286 return; see g++.dg/opt/nrv6.C. We could be more flexible if 14287 we were to do this optimization in tree-ssa. */ 14288 && (outer = outer_curly_brace_block (fndecl)) 14289 && chain_member (r, BLOCK_VARS (outer))) 14290 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl)); 14291 14292 current_function_return_value = NULL_TREE; 14293 } 14294 14295 /* Remember that we were in class scope. */ 14296 if (current_class_name) 14297 ctype = current_class_type; 14298 14299 /* Must mark the RESULT_DECL as being in this function. */ 14300 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl; 14301 14302 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point 14303 to the FUNCTION_DECL node itself. */ 14304 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl; 14305 14306 /* Save away current state, if appropriate. */ 14307 if (!processing_template_decl) 14308 save_function_data (fndecl); 14309 14310 /* Complain if there's just no return statement. */ 14311 if (warn_return_type 14312 && !VOID_TYPE_P (TREE_TYPE (fntype)) 14313 && !dependent_type_p (TREE_TYPE (fntype)) 14314 && !current_function_returns_value && !current_function_returns_null 14315 /* Don't complain if we abort or throw. */ 14316 && !current_function_returns_abnormally 14317 /* Don't complain if there's an infinite loop. */ 14318 && !current_function_infinite_loop 14319 /* Don't complain if we are declared noreturn. */ 14320 && !TREE_THIS_VOLATILE (fndecl) 14321 && !DECL_NAME (DECL_RESULT (fndecl)) 14322 && !TREE_NO_WARNING (fndecl) 14323 /* Structor return values (if any) are set by the compiler. */ 14324 && !DECL_CONSTRUCTOR_P (fndecl) 14325 && !DECL_DESTRUCTOR_P (fndecl) 14326 && targetm.warn_func_return (fndecl)) 14327 { 14328 warning (OPT_Wreturn_type, 14329 "no return statement in function returning non-void"); 14330 TREE_NO_WARNING (fndecl) = 1; 14331 } 14332 14333 /* Store the end of the function, so that we get good line number 14334 info for the epilogue. */ 14335 cfun->function_end_locus = input_location; 14336 14337 /* Complain about parameters that are only set, but never otherwise used. */ 14338 if (warn_unused_but_set_parameter 14339 && !processing_template_decl 14340 && errorcount == unused_but_set_errorcount 14341 && !DECL_CLONED_FUNCTION_P (fndecl)) 14342 { 14343 tree decl; 14344 14345 for (decl = DECL_ARGUMENTS (fndecl); 14346 decl; 14347 decl = DECL_CHAIN (decl)) 14348 if (TREE_USED (decl) 14349 && TREE_CODE (decl) == PARM_DECL 14350 && !DECL_READ_P (decl) 14351 && DECL_NAME (decl) 14352 && !DECL_ARTIFICIAL (decl) 14353 && !TREE_NO_WARNING (decl) 14354 && !DECL_IN_SYSTEM_HEADER (decl) 14355 && TREE_TYPE (decl) != error_mark_node 14356 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE 14357 && (!CLASS_TYPE_P (TREE_TYPE (decl)) 14358 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))) 14359 warning (OPT_Wunused_but_set_parameter, 14360 "parameter %q+D set but not used", decl); 14361 unused_but_set_errorcount = errorcount; 14362 } 14363 14364 /* Complain about locally defined typedefs that are not used in this 14365 function. */ 14366 maybe_warn_unused_local_typedefs (); 14367 14368 /* Genericize before inlining. */ 14369 if (!processing_template_decl) 14370 { 14371 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl); 14372 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl); 14373 cp_genericize (fndecl); 14374 /* Clear out the bits we don't need. */ 14375 f->x_current_class_ptr = NULL; 14376 f->x_current_class_ref = NULL; 14377 f->x_eh_spec_block = NULL; 14378 f->x_in_charge_parm = NULL; 14379 f->x_vtt_parm = NULL; 14380 f->x_return_value = NULL; 14381 f->bindings = NULL; 14382 f->extern_decl_map = NULL; 14383 f->infinite_loops = NULL; 14384 } 14385 /* Clear out the bits we don't need. */ 14386 local_names = NULL; 14387 14388 /* We're leaving the context of this function, so zap cfun. It's still in 14389 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */ 14390 set_cfun (NULL); 14391 current_function_decl = NULL; 14392 14393 /* If this is an in-class inline definition, we may have to pop the 14394 bindings for the template parameters that we added in 14395 maybe_begin_member_template_processing when start_function was 14396 called. */ 14397 if (inclass_inline) 14398 maybe_end_member_template_processing (); 14399 14400 /* Leave the scope of the class. */ 14401 if (ctype) 14402 pop_nested_class (); 14403 14404 --function_depth; 14405 14406 /* Clean up. */ 14407 current_function_decl = NULL_TREE; 14408 14409 defer_mark_used_calls = false; 14410 if (deferred_mark_used_calls) 14411 { 14412 unsigned int i; 14413 tree decl; 14414 14415 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls, i, decl) 14416 mark_used (decl); 14417 vec_free (deferred_mark_used_calls); 14418 } 14419 14420 return fndecl; 14421} 14422 14423/* Create the FUNCTION_DECL for a function definition. 14424 DECLSPECS and DECLARATOR are the parts of the declaration; 14425 they describe the return type and the name of the function, 14426 but twisted together in a fashion that parallels the syntax of C. 14427 14428 This function creates a binding context for the function body 14429 as well as setting up the FUNCTION_DECL in current_function_decl. 14430 14431 Returns a FUNCTION_DECL on success. 14432 14433 If the DECLARATOR is not suitable for a function (it defines a datum 14434 instead), we return 0, which tells yyparse to report a parse error. 14435 14436 May return void_type_node indicating that this method is actually 14437 a friend. See grokfield for more details. 14438 14439 Came here with a `.pushlevel' . 14440 14441 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING 14442 CHANGES TO CODE IN `grokfield'. */ 14443 14444tree 14445grokmethod (cp_decl_specifier_seq *declspecs, 14446 const cp_declarator *declarator, tree attrlist) 14447{ 14448 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0, 14449 &attrlist); 14450 14451 if (fndecl == error_mark_node) 14452 return error_mark_node; 14453 14454 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL) 14455 { 14456 error ("invalid member function declaration"); 14457 return error_mark_node; 14458 } 14459 14460 if (attrlist) 14461 cplus_decl_attributes (&fndecl, attrlist, 0); 14462 14463 /* Pass friends other than inline friend functions back. */ 14464 if (fndecl == void_type_node) 14465 return fndecl; 14466 14467 if (DECL_IN_AGGR_P (fndecl)) 14468 { 14469 if (DECL_CLASS_SCOPE_P (fndecl)) 14470 error ("%qD is already defined in class %qT", fndecl, 14471 DECL_CONTEXT (fndecl)); 14472 return error_mark_node; 14473 } 14474 14475 check_template_shadow (fndecl); 14476 14477 DECL_COMDAT (fndecl) = 1; 14478 DECL_DECLARED_INLINE_P (fndecl) = 1; 14479 DECL_NO_INLINE_WARNING_P (fndecl) = 1; 14480 14481 /* We process method specializations in finish_struct_1. */ 14482 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl)) 14483 { 14484 fndecl = push_template_decl (fndecl); 14485 if (fndecl == error_mark_node) 14486 return fndecl; 14487 } 14488 14489 if (! DECL_FRIEND_P (fndecl)) 14490 { 14491 if (DECL_CHAIN (fndecl)) 14492 { 14493 fndecl = copy_node (fndecl); 14494 TREE_CHAIN (fndecl) = NULL_TREE; 14495 } 14496 } 14497 14498 cp_finish_decl (fndecl, NULL_TREE, false, NULL_TREE, 0); 14499 14500 DECL_IN_AGGR_P (fndecl) = 1; 14501 return fndecl; 14502} 14503 14504 14505/* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that 14506 we can lay it out later, when and if its type becomes complete. 14507 14508 Also handle constexpr variables where the initializer involves 14509 an unlowered PTRMEM_CST because the class isn't complete yet. */ 14510 14511void 14512maybe_register_incomplete_var (tree var) 14513{ 14514 gcc_assert (VAR_P (var)); 14515 14516 /* Keep track of variables with incomplete types. */ 14517 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node 14518 && DECL_EXTERNAL (var)) 14519 { 14520 tree inner_type = TREE_TYPE (var); 14521 14522 while (TREE_CODE (inner_type) == ARRAY_TYPE) 14523 inner_type = TREE_TYPE (inner_type); 14524 inner_type = TYPE_MAIN_VARIANT (inner_type); 14525 14526 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type)) 14527 /* RTTI TD entries are created while defining the type_info. */ 14528 || (TYPE_LANG_SPECIFIC (inner_type) 14529 && TYPE_BEING_DEFINED (inner_type))) 14530 { 14531 incomplete_var iv = {var, inner_type}; 14532 vec_safe_push (incomplete_vars, iv); 14533 } 14534 else if (!(DECL_LANG_SPECIFIC (var) && DECL_TEMPLATE_INFO (var)) 14535 && decl_constant_var_p (var) 14536 && (TYPE_PTRMEM_P (inner_type) || CLASS_TYPE_P (inner_type))) 14537 { 14538 /* When the outermost open class is complete we can resolve any 14539 pointers-to-members. */ 14540 tree context = outermost_open_class (); 14541 incomplete_var iv = {var, context}; 14542 vec_safe_push (incomplete_vars, iv); 14543 } 14544 } 14545} 14546 14547/* Called when a class type (given by TYPE) is defined. If there are 14548 any existing VAR_DECLs whose type has been completed by this 14549 declaration, update them now. */ 14550 14551void 14552complete_vars (tree type) 14553{ 14554 unsigned ix; 14555 incomplete_var *iv; 14556 14557 for (ix = 0; vec_safe_iterate (incomplete_vars, ix, &iv); ) 14558 { 14559 if (same_type_p (type, iv->incomplete_type)) 14560 { 14561 tree var = iv->decl; 14562 tree type = TREE_TYPE (var); 14563 14564 if (TYPE_MAIN_VARIANT (strip_array_types (type)) 14565 == iv->incomplete_type) 14566 { 14567 /* Complete the type of the variable. The VAR_DECL itself 14568 will be laid out in expand_expr. */ 14569 complete_type (type); 14570 cp_apply_type_quals_to_decl (cp_type_quals (type), var); 14571 } 14572 14573 if (DECL_INITIAL (var) 14574 && decl_constant_var_p (var)) 14575 DECL_INITIAL (var) = cplus_expand_constant (DECL_INITIAL (var)); 14576 14577 /* Remove this entry from the list. */ 14578 incomplete_vars->unordered_remove (ix); 14579 } 14580 else 14581 ix++; 14582 } 14583 14584 /* Check for pending declarations which may have abstract type. */ 14585 complete_type_check_abstract (type); 14586} 14587 14588/* If DECL is of a type which needs a cleanup, build and return an 14589 expression to perform that cleanup here. Return NULL_TREE if no 14590 cleanup need be done. DECL can also be a _REF when called from 14591 split_nonconstant_init_1. */ 14592 14593tree 14594cxx_maybe_build_cleanup (tree decl, tsubst_flags_t complain) 14595{ 14596 tree type; 14597 tree attr; 14598 tree cleanup; 14599 14600 /* Assume no cleanup is required. */ 14601 cleanup = NULL_TREE; 14602 14603 if (error_operand_p (decl)) 14604 return cleanup; 14605 14606 /* Handle "__attribute__((cleanup))". We run the cleanup function 14607 before the destructor since the destructor is what actually 14608 terminates the lifetime of the object. */ 14609 if (DECL_P (decl)) 14610 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl)); 14611 else 14612 attr = NULL_TREE; 14613 if (attr) 14614 { 14615 tree id; 14616 tree fn; 14617 tree arg; 14618 14619 /* Get the name specified by the user for the cleanup function. */ 14620 id = TREE_VALUE (TREE_VALUE (attr)); 14621 /* Look up the name to find the cleanup function to call. It is 14622 important to use lookup_name here because that is what is 14623 used in c-common.c:handle_cleanup_attribute when performing 14624 initial checks on the attribute. Note that those checks 14625 include ensuring that the function found is not an overloaded 14626 function, or an object with an overloaded call operator, 14627 etc.; we can rely on the fact that the function found is an 14628 ordinary FUNCTION_DECL. */ 14629 fn = lookup_name (id); 14630 arg = build_address (decl); 14631 if (!mark_used (decl, complain) && !(complain & tf_error)) 14632 return error_mark_node; 14633 cleanup = cp_build_function_call_nary (fn, complain, arg, NULL_TREE); 14634 if (cleanup == error_mark_node) 14635 return error_mark_node; 14636 } 14637 /* Handle ordinary C++ destructors. */ 14638 type = TREE_TYPE (decl); 14639 if (type_build_dtor_call (type)) 14640 { 14641 int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR; 14642 tree addr; 14643 tree call; 14644 14645 if (TREE_CODE (type) == ARRAY_TYPE) 14646 addr = decl; 14647 else 14648 addr = build_address (decl); 14649 14650 call = build_delete (TREE_TYPE (addr), addr, 14651 sfk_complete_destructor, flags, 0, complain); 14652 if (call == error_mark_node) 14653 cleanup = error_mark_node; 14654 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type)) 14655 /* Discard the call. */; 14656 else if (cleanup) 14657 cleanup = cp_build_compound_expr (cleanup, call, complain); 14658 else 14659 cleanup = call; 14660 } 14661 14662 /* build_delete sets the location of the destructor call to the 14663 current location, even though the destructor is going to be 14664 called later, at the end of the current scope. This can lead to 14665 a "jumpy" behaviour for users of debuggers when they step around 14666 the end of the block. So let's unset the location of the 14667 destructor call instead. */ 14668 if (cleanup != NULL && EXPR_P (cleanup)) 14669 SET_EXPR_LOCATION (cleanup, UNKNOWN_LOCATION); 14670 14671 if (cleanup 14672 && DECL_P (decl) 14673 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl))) 14674 /* Treat objects with destructors as used; the destructor may do 14675 something substantive. */ 14676 && !mark_used (decl, complain) && !(complain & tf_error)) 14677 return error_mark_node; 14678 14679 return cleanup; 14680} 14681 14682 14683/* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a 14684 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to 14685 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */ 14686 14687tree 14688static_fn_type (tree memfntype) 14689{ 14690 tree fntype; 14691 tree args; 14692 14693 if (TYPE_PTRMEMFUNC_P (memfntype)) 14694 memfntype = TYPE_PTRMEMFUNC_FN_TYPE (memfntype); 14695 if (POINTER_TYPE_P (memfntype) 14696 || TREE_CODE (memfntype) == FUNCTION_DECL) 14697 memfntype = TREE_TYPE (memfntype); 14698 if (TREE_CODE (memfntype) == FUNCTION_TYPE) 14699 return memfntype; 14700 gcc_assert (TREE_CODE (memfntype) == METHOD_TYPE); 14701 args = TYPE_ARG_TYPES (memfntype); 14702 cp_ref_qualifier rqual = type_memfn_rqual (memfntype); 14703 fntype = build_function_type (TREE_TYPE (memfntype), TREE_CHAIN (args)); 14704 fntype = apply_memfn_quals (fntype, type_memfn_quals (memfntype), rqual); 14705 fntype = (cp_build_type_attribute_variant 14706 (fntype, TYPE_ATTRIBUTES (memfntype))); 14707 fntype = (build_exception_variant 14708 (fntype, TYPE_RAISES_EXCEPTIONS (memfntype))); 14709 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype)) 14710 TYPE_HAS_LATE_RETURN_TYPE (fntype) = 1; 14711 return fntype; 14712} 14713 14714/* DECL was originally constructed as a non-static member function, 14715 but turned out to be static. Update it accordingly. */ 14716 14717void 14718revert_static_member_fn (tree decl) 14719{ 14720 tree stype = static_fn_type (decl); 14721 cp_cv_quals quals = type_memfn_quals (stype); 14722 cp_ref_qualifier rqual = type_memfn_rqual (stype); 14723 14724 if (quals != TYPE_UNQUALIFIED || rqual != REF_QUAL_NONE) 14725 stype = apply_memfn_quals (stype, TYPE_UNQUALIFIED, REF_QUAL_NONE); 14726 14727 TREE_TYPE (decl) = stype; 14728 14729 if (DECL_ARGUMENTS (decl)) 14730 DECL_ARGUMENTS (decl) = DECL_CHAIN (DECL_ARGUMENTS (decl)); 14731 DECL_STATIC_FUNCTION_P (decl) = 1; 14732} 14733 14734/* Return which tree structure is used by T, or TS_CP_GENERIC if T is 14735 one of the language-independent trees. */ 14736 14737enum cp_tree_node_structure_enum 14738cp_tree_node_structure (union lang_tree_node * t) 14739{ 14740 switch (TREE_CODE (&t->generic)) 14741 { 14742 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG; 14743 case DEFERRED_NOEXCEPT: return TS_CP_DEFERRED_NOEXCEPT; 14744 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER; 14745 case OVERLOAD: return TS_CP_OVERLOAD; 14746 case TEMPLATE_PARM_INDEX: return TS_CP_TPI; 14747 case PTRMEM_CST: return TS_CP_PTRMEM; 14748 case BASELINK: return TS_CP_BASELINK; 14749 case TEMPLATE_DECL: return TS_CP_TEMPLATE_DECL; 14750 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT; 14751 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT; 14752 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR; 14753 case LAMBDA_EXPR: return TS_CP_LAMBDA_EXPR; 14754 case TEMPLATE_INFO: return TS_CP_TEMPLATE_INFO; 14755 case USERDEF_LITERAL: return TS_CP_USERDEF_LITERAL; 14756 default: return TS_CP_GENERIC; 14757 } 14758} 14759 14760/* Build the void_list_node (void_type_node having been created). */ 14761tree 14762build_void_list_node (void) 14763{ 14764 tree t = build_tree_list (NULL_TREE, void_type_node); 14765 return t; 14766} 14767 14768bool 14769cp_missing_noreturn_ok_p (tree decl) 14770{ 14771 /* A missing noreturn is ok for the `main' function. */ 14772 return DECL_MAIN_P (decl); 14773} 14774 14775/* Return the decl used to identify the COMDAT group into which DECL should 14776 be placed. */ 14777 14778tree 14779cxx_comdat_group (tree decl) 14780{ 14781 /* Virtual tables, construction virtual tables, and virtual table 14782 tables all go in a single COMDAT group, named after the primary 14783 virtual table. */ 14784 if (VAR_P (decl) && DECL_VTABLE_OR_VTT_P (decl)) 14785 decl = CLASSTYPE_VTABLES (DECL_CONTEXT (decl)); 14786 /* For all other DECLs, the COMDAT group is the mangled name of the 14787 declaration itself. */ 14788 else 14789 { 14790 while (DECL_THUNK_P (decl)) 14791 { 14792 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk 14793 into the same section as the target function. In that case 14794 we must return target's name. */ 14795 tree target = THUNK_TARGET (decl); 14796 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target) 14797 && DECL_SECTION_NAME (target) != NULL 14798 && DECL_ONE_ONLY (target)) 14799 decl = target; 14800 else 14801 break; 14802 } 14803 } 14804 14805 return decl; 14806} 14807 14808/* Returns the return type for FN as written by the user, which may include 14809 a placeholder for a deduced return type. */ 14810 14811tree 14812fndecl_declared_return_type (tree fn) 14813{ 14814 fn = STRIP_TEMPLATE (fn); 14815 if (FNDECL_USED_AUTO (fn)) 14816 { 14817 struct language_function *f = NULL; 14818 if (DECL_STRUCT_FUNCTION (fn)) 14819 f = DECL_STRUCT_FUNCTION (fn)->language; 14820 if (f == NULL) 14821 f = DECL_SAVED_FUNCTION_DATA (fn); 14822 return f->x_auto_return_pattern; 14823 } 14824 return TREE_TYPE (TREE_TYPE (fn)); 14825} 14826 14827/* Returns true iff DECL was declared with an auto return type and it has 14828 not yet been deduced to a real type. */ 14829 14830bool 14831undeduced_auto_decl (tree decl) 14832{ 14833 if (cxx_dialect < cxx14) 14834 return false; 14835 return type_uses_auto (TREE_TYPE (decl)); 14836} 14837 14838/* Complain if DECL has an undeduced return type. */ 14839 14840void 14841require_deduced_type (tree decl) 14842{ 14843 if (undeduced_auto_decl (decl)) 14844 error ("use of %qD before deduction of %<auto%>", decl); 14845} 14846 14847#include "gt-cp-decl.h" 14848