1 /* Process declarations and variables for C++ compiler. 2 Copyright (C) 1988-2020 Free Software Foundation, Inc. 3 Hacked by Michael Tiemann (tiemann@cygnus.com) 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along 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 "memmodel.h" 33 #include "target.h" 34 #include "cp-tree.h" 35 #include "c-family/c-common.h" 36 #include "timevar.h" 37 #include "stringpool.h" 38 #include "cgraph.h" 39 #include "varasm.h" 40 #include "attribs.h" 41 #include "stor-layout.h" 42 #include "calls.h" 43 #include "decl.h" 44 #include "toplev.h" 45 #include "c-family/c-objc.h" 46 #include "c-family/c-pragma.h" 47 #include "dumpfile.h" 48 #include "intl.h" 49 #include "c-family/c-ada-spec.h" 50 #include "asan.h" 51 52 /* Id for dumping the raw trees. */ 53 int raw_dump_id; 54 55 extern cpp_reader *parse_in; 56 57 /* This structure contains information about the initializations 58 and/or destructions required for a particular priority level. */ 59 typedef struct priority_info_s { 60 /* Nonzero if there have been any initializations at this priority 61 throughout the translation unit. */ 62 int initializations_p; 63 /* Nonzero if there have been any destructions at this priority 64 throughout the translation unit. */ 65 int destructions_p; 66 } *priority_info; 67 68 static void mark_vtable_entries (tree); 69 static bool maybe_emit_vtables (tree); 70 static tree start_objects (int, int); 71 static void finish_objects (int, int, tree); 72 static tree start_static_storage_duration_function (unsigned); 73 static void finish_static_storage_duration_function (tree); 74 static priority_info get_priority_info (int); 75 static void do_static_initialization_or_destruction (tree, bool); 76 static void one_static_initialization_or_destruction (tree, tree, bool); 77 static void generate_ctor_or_dtor_function (bool, int, location_t *); 78 static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node, 79 void *); 80 static tree prune_vars_needing_no_initialization (tree *); 81 static void write_out_vars (tree); 82 static void import_export_class (tree); 83 static tree get_guard_bits (tree); 84 static void determine_visibility_from_class (tree, tree); 85 static bool determine_hidden_inline (tree); 86 static void maybe_instantiate_decl (tree); 87 88 /* A list of static class variables. This is needed, because a 89 static class variable can be declared inside the class without 90 an initializer, and then initialized, statically, outside the class. */ 91 static GTY(()) vec<tree, va_gc> *pending_statics; 92 93 /* A list of functions which were declared inline, but which we 94 may need to emit outline anyway. */ 95 static GTY(()) vec<tree, va_gc> *deferred_fns; 96 97 /* A list of decls that use types with no linkage, which we need to make 98 sure are defined. */ 99 static GTY(()) vec<tree, va_gc> *no_linkage_decls; 100 101 /* A vector of alternating decls and identifiers, where the latter 102 is to be an alias for the former if the former is defined. */ 103 static GTY(()) vec<tree, va_gc> *mangling_aliases; 104 105 /* hash traits for declarations. Hashes single decls via 106 DECL_ASSEMBLER_NAME_RAW. */ 107 108 struct mangled_decl_hash : ggc_remove <tree> 109 { 110 typedef tree value_type; /* A DECL. */ 111 typedef tree compare_type; /* An identifier. */ 112 113 static hashval_t hash (const value_type decl) 114 { 115 return IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME_RAW (decl)); 116 } 117 static bool equal (const value_type existing, compare_type candidate) 118 { 119 tree name = DECL_ASSEMBLER_NAME_RAW (existing); 120 return candidate == name; 121 } 122 123 static const bool empty_zero_p = true; 124 static inline void mark_empty (value_type &p) {p = NULL_TREE;} 125 static inline bool is_empty (value_type p) {return !p;} 126 127 static bool is_deleted (value_type e) 128 { 129 return e == reinterpret_cast <value_type> (1); 130 } 131 static void mark_deleted (value_type &e) 132 { 133 e = reinterpret_cast <value_type> (1); 134 } 135 }; 136 137 /* A hash table of decls keyed by mangled name. Used to figure out if 138 we need compatibility aliases. */ 139 static GTY(()) hash_table<mangled_decl_hash> *mangled_decls; 140 141 /* Nonzero if we're done parsing and into end-of-file activities. */ 142 143 int at_eof; 144 145 /* True if note_mangling_alias should enqueue mangling aliases for 146 later generation, rather than emitting them right away. */ 147 148 bool defer_mangling_aliases = true; 149 150 151 /* Return a member function type (a METHOD_TYPE), given FNTYPE (a 152 FUNCTION_TYPE), CTYPE (class type), and QUALS (the cv-qualifiers 153 that apply to the function). */ 154 155 tree 156 build_memfn_type (tree fntype, tree ctype, cp_cv_quals quals, 157 cp_ref_qualifier rqual) 158 { 159 if (fntype == error_mark_node || ctype == error_mark_node) 160 return error_mark_node; 161 162 gcc_assert (FUNC_OR_METHOD_TYPE_P (fntype)); 163 164 cp_cv_quals type_quals = quals & ~TYPE_QUAL_RESTRICT; 165 ctype = cp_build_qualified_type (ctype, type_quals); 166 167 tree newtype 168 = build_method_type_directly (ctype, TREE_TYPE (fntype), 169 (TREE_CODE (fntype) == METHOD_TYPE 170 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype)) 171 : TYPE_ARG_TYPES (fntype))); 172 if (tree attrs = TYPE_ATTRIBUTES (fntype)) 173 newtype = cp_build_type_attribute_variant (newtype, attrs); 174 newtype = build_cp_fntype_variant (newtype, rqual, 175 TYPE_RAISES_EXCEPTIONS (fntype), 176 TYPE_HAS_LATE_RETURN_TYPE (fntype)); 177 178 return newtype; 179 } 180 181 /* Return a variant of FNTYPE, a FUNCTION_TYPE or METHOD_TYPE, with its 182 return type changed to NEW_RET. */ 183 184 tree 185 change_return_type (tree new_ret, tree fntype) 186 { 187 if (new_ret == error_mark_node) 188 return fntype; 189 190 if (same_type_p (new_ret, TREE_TYPE (fntype))) 191 return fntype; 192 193 tree newtype; 194 tree args = TYPE_ARG_TYPES (fntype); 195 196 if (TREE_CODE (fntype) == FUNCTION_TYPE) 197 { 198 newtype = build_function_type (new_ret, args); 199 newtype = apply_memfn_quals (newtype, 200 type_memfn_quals (fntype)); 201 } 202 else 203 newtype = build_method_type_directly 204 (class_of_this_parm (fntype), new_ret, TREE_CHAIN (args)); 205 206 if (tree attrs = TYPE_ATTRIBUTES (fntype)) 207 newtype = cp_build_type_attribute_variant (newtype, attrs); 208 newtype = cxx_copy_lang_qualifiers (newtype, fntype); 209 210 return newtype; 211 } 212 213 /* Build a PARM_DECL of FN with NAME and TYPE, and set DECL_ARG_TYPE 214 appropriately. */ 215 216 tree 217 cp_build_parm_decl (tree fn, tree name, tree type) 218 { 219 tree parm = build_decl (input_location, 220 PARM_DECL, name, type); 221 DECL_CONTEXT (parm) = fn; 222 223 /* DECL_ARG_TYPE is only used by the back end and the back end never 224 sees templates. */ 225 if (!processing_template_decl) 226 DECL_ARG_TYPE (parm) = type_passed_as (type); 227 228 return parm; 229 } 230 231 /* Returns a PARM_DECL of FN for a parameter of the indicated TYPE, with the 232 indicated NAME. */ 233 234 tree 235 build_artificial_parm (tree fn, tree name, tree type) 236 { 237 tree parm = cp_build_parm_decl (fn, name, type); 238 DECL_ARTIFICIAL (parm) = 1; 239 /* All our artificial parms are implicitly `const'; they cannot be 240 assigned to. */ 241 TREE_READONLY (parm) = 1; 242 return parm; 243 } 244 245 /* Constructors for types with virtual baseclasses need an "in-charge" flag 246 saying whether this constructor is responsible for initialization of 247 virtual baseclasses or not. All destructors also need this "in-charge" 248 flag, which additionally determines whether or not the destructor should 249 free the memory for the object. 250 251 This function adds the "in-charge" flag to member function FN if 252 appropriate. It is called from grokclassfn and tsubst. 253 FN must be either a constructor or destructor. 254 255 The in-charge flag follows the 'this' parameter, and is followed by the 256 VTT parm (if any), then the user-written parms. */ 257 258 void 259 maybe_retrofit_in_chrg (tree fn) 260 { 261 tree basetype, arg_types, parms, parm, fntype; 262 263 /* If we've already add the in-charge parameter don't do it again. */ 264 if (DECL_HAS_IN_CHARGE_PARM_P (fn)) 265 return; 266 267 /* When processing templates we can't know, in general, whether or 268 not we're going to have virtual baseclasses. */ 269 if (processing_template_decl) 270 return; 271 272 /* We don't need an in-charge parameter for constructors that don't 273 have virtual bases. */ 274 if (DECL_CONSTRUCTOR_P (fn) 275 && !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn))) 276 return; 277 278 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn)); 279 basetype = TREE_TYPE (TREE_VALUE (arg_types)); 280 arg_types = TREE_CHAIN (arg_types); 281 282 parms = DECL_CHAIN (DECL_ARGUMENTS (fn)); 283 284 /* If this is a subobject constructor or destructor, our caller will 285 pass us a pointer to our VTT. */ 286 if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn))) 287 { 288 parm = build_artificial_parm (fn, vtt_parm_identifier, vtt_parm_type); 289 290 /* First add it to DECL_ARGUMENTS between 'this' and the real args... */ 291 DECL_CHAIN (parm) = parms; 292 parms = parm; 293 294 /* ...and then to TYPE_ARG_TYPES. */ 295 arg_types = hash_tree_chain (vtt_parm_type, arg_types); 296 297 DECL_HAS_VTT_PARM_P (fn) = 1; 298 } 299 300 /* Then add the in-charge parm (before the VTT parm). */ 301 parm = build_artificial_parm (fn, in_charge_identifier, integer_type_node); 302 DECL_CHAIN (parm) = parms; 303 parms = parm; 304 arg_types = hash_tree_chain (integer_type_node, arg_types); 305 306 /* Insert our new parameter(s) into the list. */ 307 DECL_CHAIN (DECL_ARGUMENTS (fn)) = parms; 308 309 /* And rebuild the function type. */ 310 fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)), 311 arg_types); 312 if (TYPE_ATTRIBUTES (TREE_TYPE (fn))) 313 fntype = (cp_build_type_attribute_variant 314 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (fn)))); 315 fntype = cxx_copy_lang_qualifiers (fntype, TREE_TYPE (fn)); 316 TREE_TYPE (fn) = fntype; 317 318 /* Now we've got the in-charge parameter. */ 319 DECL_HAS_IN_CHARGE_PARM_P (fn) = 1; 320 } 321 322 /* Classes overload their constituent function names automatically. 323 When a function name is declared in a record structure, 324 its name is changed to it overloaded name. Since names for 325 constructors and destructors can conflict, we place a leading 326 '$' for destructors. 327 328 CNAME is the name of the class we are grokking for. 329 330 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'. 331 332 FLAGS contains bits saying what's special about today's 333 arguments. DTOR_FLAG == DESTRUCTOR. 334 335 If FUNCTION is a destructor, then we must add the `auto-delete' field 336 as a second parameter. There is some hair associated with the fact 337 that we must "declare" this variable in the manner consistent with the 338 way the rest of the arguments were declared. 339 340 QUALS are the qualifiers for the this pointer. */ 341 342 void 343 grokclassfn (tree ctype, tree function, enum overload_flags flags) 344 { 345 tree fn_name = DECL_NAME (function); 346 347 /* Even within an `extern "C"' block, members get C++ linkage. See 348 [dcl.link] for details. */ 349 SET_DECL_LANGUAGE (function, lang_cplusplus); 350 351 if (fn_name == NULL_TREE) 352 { 353 error ("name missing for member function"); 354 fn_name = get_identifier ("<anonymous>"); 355 DECL_NAME (function) = fn_name; 356 } 357 358 DECL_CONTEXT (function) = ctype; 359 360 if (flags == DTOR_FLAG) 361 DECL_CXX_DESTRUCTOR_P (function) = 1; 362 363 if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function)) 364 maybe_retrofit_in_chrg (function); 365 } 366 367 /* Create an ARRAY_REF, checking for the user doing things backwards 368 along the way. DECLTYPE_P is for N3276, as in the parser. */ 369 370 tree 371 grok_array_decl (location_t loc, tree array_expr, tree index_exp, 372 bool decltype_p) 373 { 374 tree type; 375 tree expr; 376 tree orig_array_expr = array_expr; 377 tree orig_index_exp = index_exp; 378 tree overload = NULL_TREE; 379 380 if (error_operand_p (array_expr) || error_operand_p (index_exp)) 381 return error_mark_node; 382 383 if (processing_template_decl) 384 { 385 if (type_dependent_expression_p (array_expr) 386 || type_dependent_expression_p (index_exp)) 387 return build_min_nt_loc (loc, ARRAY_REF, array_expr, index_exp, 388 NULL_TREE, NULL_TREE); 389 array_expr = build_non_dependent_expr (array_expr); 390 index_exp = build_non_dependent_expr (index_exp); 391 } 392 393 type = TREE_TYPE (array_expr); 394 gcc_assert (type); 395 type = non_reference (type); 396 397 /* If they have an `operator[]', use that. */ 398 if (MAYBE_CLASS_TYPE_P (type) || MAYBE_CLASS_TYPE_P (TREE_TYPE (index_exp))) 399 { 400 tsubst_flags_t complain = tf_warning_or_error; 401 if (decltype_p) 402 complain |= tf_decltype; 403 expr = build_new_op (loc, ARRAY_REF, LOOKUP_NORMAL, array_expr, 404 index_exp, NULL_TREE, &overload, complain); 405 } 406 else 407 { 408 tree p1, p2, i1, i2; 409 bool swapped = false; 410 411 /* Otherwise, create an ARRAY_REF for a pointer or array type. 412 It is a little-known fact that, if `a' is an array and `i' is 413 an int, you can write `i[a]', which means the same thing as 414 `a[i]'. */ 415 if (TREE_CODE (type) == ARRAY_TYPE || VECTOR_TYPE_P (type)) 416 p1 = array_expr; 417 else 418 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false); 419 420 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE) 421 p2 = index_exp; 422 else 423 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false); 424 425 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, 426 false); 427 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, 428 false); 429 430 if ((p1 && i2) && (i1 && p2)) 431 error ("ambiguous conversion for array subscript"); 432 433 if (p1 && i2) 434 array_expr = p1, index_exp = i2; 435 else if (i1 && p2) 436 swapped = true, array_expr = p2, index_exp = i1; 437 else 438 { 439 error_at (loc, "invalid types %<%T[%T]%> for array subscript", 440 type, TREE_TYPE (index_exp)); 441 return error_mark_node; 442 } 443 444 if (array_expr == error_mark_node || index_exp == error_mark_node) 445 error ("ambiguous conversion for array subscript"); 446 447 if (TYPE_PTR_P (TREE_TYPE (array_expr))) 448 array_expr = mark_rvalue_use (array_expr); 449 else 450 array_expr = mark_lvalue_use_nonread (array_expr); 451 index_exp = mark_rvalue_use (index_exp); 452 if (swapped 453 && flag_strong_eval_order == 2 454 && (TREE_SIDE_EFFECTS (array_expr) || TREE_SIDE_EFFECTS (index_exp))) 455 expr = build_array_ref (input_location, index_exp, array_expr); 456 else 457 expr = build_array_ref (input_location, array_expr, index_exp); 458 } 459 if (processing_template_decl && expr != error_mark_node) 460 { 461 if (overload != NULL_TREE) 462 return (build_min_non_dep_op_overload 463 (ARRAY_REF, expr, overload, orig_array_expr, orig_index_exp)); 464 465 return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp, 466 NULL_TREE, NULL_TREE); 467 } 468 return expr; 469 } 470 471 /* Given the cast expression EXP, checking out its validity. Either return 472 an error_mark_node if there was an unavoidable error, return a cast to 473 void for trying to delete a pointer w/ the value 0, or return the 474 call to delete. If DOING_VEC is true, we handle things differently 475 for doing an array delete. 476 Implements ARM $5.3.4. This is called from the parser. */ 477 478 tree 479 delete_sanity (location_t loc, tree exp, tree size, bool doing_vec, 480 int use_global_delete, tsubst_flags_t complain) 481 { 482 tree t, type; 483 484 if (exp == error_mark_node) 485 return exp; 486 487 if (processing_template_decl) 488 { 489 t = build_min (DELETE_EXPR, void_type_node, exp, size); 490 DELETE_EXPR_USE_GLOBAL (t) = use_global_delete; 491 DELETE_EXPR_USE_VEC (t) = doing_vec; 492 TREE_SIDE_EFFECTS (t) = 1; 493 SET_EXPR_LOCATION (t, loc); 494 return t; 495 } 496 497 location_t exp_loc = cp_expr_loc_or_loc (exp, loc); 498 499 /* An array can't have been allocated by new, so complain. */ 500 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE 501 && (complain & tf_warning)) 502 warning_at (exp_loc, 0, "deleting array %q#E", exp); 503 504 t = build_expr_type_conversion (WANT_POINTER, exp, true); 505 506 if (t == NULL_TREE || t == error_mark_node) 507 { 508 if (complain & tf_error) 509 error_at (exp_loc, 510 "type %q#T argument given to %<delete%>, expected pointer", 511 TREE_TYPE (exp)); 512 return error_mark_node; 513 } 514 515 type = TREE_TYPE (t); 516 517 /* As of Valley Forge, you can delete a pointer to const. */ 518 519 /* You can't delete functions. */ 520 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) 521 { 522 if (complain & tf_error) 523 error_at (exp_loc, 524 "cannot delete a function. Only pointer-to-objects are " 525 "valid arguments to %<delete%>"); 526 return error_mark_node; 527 } 528 529 /* Deleting ptr to void is undefined behavior [expr.delete/3]. */ 530 if (VOID_TYPE_P (TREE_TYPE (type))) 531 { 532 if (complain & tf_warning) 533 warning_at (exp_loc, OPT_Wdelete_incomplete, 534 "deleting %qT is undefined", type); 535 doing_vec = 0; 536 } 537 538 /* Deleting a pointer with the value zero is valid and has no effect. */ 539 if (integer_zerop (t)) 540 return build1_loc (loc, NOP_EXPR, void_type_node, t); 541 542 if (doing_vec) 543 return build_vec_delete (loc, t, /*maxindex=*/NULL_TREE, 544 sfk_deleting_destructor, 545 use_global_delete, complain); 546 else 547 return build_delete (loc, type, t, sfk_deleting_destructor, 548 LOOKUP_NORMAL, use_global_delete, 549 complain); 550 } 551 552 /* Report an error if the indicated template declaration is not the 553 sort of thing that should be a member template. */ 554 555 void 556 check_member_template (tree tmpl) 557 { 558 tree decl; 559 560 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL); 561 decl = DECL_TEMPLATE_RESULT (tmpl); 562 563 if (TREE_CODE (decl) == FUNCTION_DECL 564 || DECL_ALIAS_TEMPLATE_P (tmpl) 565 || (TREE_CODE (decl) == TYPE_DECL 566 && MAYBE_CLASS_TYPE_P (TREE_TYPE (decl)))) 567 { 568 /* The parser rejects template declarations in local classes 569 (with the exception of generic lambdas). */ 570 gcc_assert (!current_function_decl || LAMBDA_FUNCTION_P (decl)); 571 /* The parser rejects any use of virtual in a function template. */ 572 gcc_assert (!(TREE_CODE (decl) == FUNCTION_DECL 573 && DECL_VIRTUAL_P (decl))); 574 575 /* The debug-information generating code doesn't know what to do 576 with member templates. */ 577 DECL_IGNORED_P (tmpl) = 1; 578 } 579 else if (variable_template_p (tmpl)) 580 /* OK */; 581 else 582 error ("template declaration of %q#D", decl); 583 } 584 585 /* Sanity check: report error if this function FUNCTION is not 586 really a member of the class (CTYPE) it is supposed to belong to. 587 TEMPLATE_PARMS is used to specify the template parameters of a member 588 template passed as FUNCTION_DECL. If the member template is passed as a 589 TEMPLATE_DECL, it can be NULL since the parameters can be extracted 590 from the declaration. If the function is not a function template, it 591 must be NULL. 592 It returns the original declaration for the function, NULL_TREE if 593 no declaration was found, error_mark_node if an error was emitted. */ 594 595 tree 596 check_classfn (tree ctype, tree function, tree template_parms) 597 { 598 if (DECL_USE_TEMPLATE (function) 599 && !(TREE_CODE (function) == TEMPLATE_DECL 600 && DECL_TEMPLATE_SPECIALIZATION (function)) 601 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function))) 602 /* Since this is a specialization of a member template, 603 we're not going to find the declaration in the class. 604 For example, in: 605 606 struct S { template <typename T> void f(T); }; 607 template <> void S::f(int); 608 609 we're not going to find `S::f(int)', but there's no 610 reason we should, either. We let our callers know we didn't 611 find the method, but we don't complain. */ 612 return NULL_TREE; 613 614 /* Basic sanity check: for a template function, the template parameters 615 either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */ 616 if (TREE_CODE (function) == TEMPLATE_DECL) 617 { 618 if (template_parms 619 && !comp_template_parms (template_parms, 620 DECL_TEMPLATE_PARMS (function))) 621 { 622 error ("template parameter lists provided don%'t match the " 623 "template parameters of %qD", function); 624 return error_mark_node; 625 } 626 template_parms = DECL_TEMPLATE_PARMS (function); 627 } 628 629 /* OK, is this a definition of a member template? */ 630 bool is_template = (template_parms != NULL_TREE); 631 632 /* [temp.mem] 633 634 A destructor shall not be a member template. */ 635 if (DECL_DESTRUCTOR_P (function) && is_template) 636 { 637 error ("destructor %qD declared as member template", function); 638 return error_mark_node; 639 } 640 641 /* We must enter the scope here, because conversion operators are 642 named by target type, and type equivalence relies on typenames 643 resolving within the scope of CTYPE. */ 644 tree pushed_scope = push_scope (ctype); 645 tree matched = NULL_TREE; 646 tree fns = get_class_binding (ctype, DECL_NAME (function)); 647 648 for (ovl_iterator iter (fns); !matched && iter; ++iter) 649 { 650 tree fndecl = *iter; 651 652 /* A member template definition only matches a member template 653 declaration. */ 654 if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL)) 655 continue; 656 657 if (!DECL_DECLARES_FUNCTION_P (fndecl)) 658 continue; 659 660 tree p1 = TYPE_ARG_TYPES (TREE_TYPE (function)); 661 tree p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); 662 663 /* We cannot simply call decls_match because this doesn't work 664 for static member functions that are pretending to be 665 methods, and because the name may have been changed by 666 asm("new_name"). */ 667 668 /* Get rid of the this parameter on functions that become 669 static. */ 670 if (DECL_STATIC_FUNCTION_P (fndecl) 671 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) 672 p1 = TREE_CHAIN (p1); 673 674 /* ref-qualifier or absence of same must match. */ 675 if (type_memfn_rqual (TREE_TYPE (function)) 676 != type_memfn_rqual (TREE_TYPE (fndecl))) 677 continue; 678 679 // Include constraints in the match. 680 tree c1 = get_constraints (function); 681 tree c2 = get_constraints (fndecl); 682 683 /* While finding a match, same types and params are not enough 684 if the function is versioned. Also check version ("target") 685 attributes. */ 686 if (same_type_p (TREE_TYPE (TREE_TYPE (function)), 687 TREE_TYPE (TREE_TYPE (fndecl))) 688 && compparms (p1, p2) 689 && !targetm.target_option.function_versions (function, fndecl) 690 && (!is_template 691 || comp_template_parms (template_parms, 692 DECL_TEMPLATE_PARMS (fndecl))) 693 && equivalent_constraints (c1, c2) 694 && (DECL_TEMPLATE_SPECIALIZATION (function) 695 == DECL_TEMPLATE_SPECIALIZATION (fndecl)) 696 && (!DECL_TEMPLATE_SPECIALIZATION (function) 697 || (DECL_TI_TEMPLATE (function) == DECL_TI_TEMPLATE (fndecl)))) 698 matched = fndecl; 699 } 700 701 if (!matched) 702 { 703 if (!COMPLETE_TYPE_P (ctype)) 704 cxx_incomplete_type_error (DECL_SOURCE_LOCATION (function), 705 function, ctype); 706 else 707 { 708 if (DECL_CONV_FN_P (function)) 709 fns = get_class_binding (ctype, conv_op_identifier); 710 711 error_at (DECL_SOURCE_LOCATION (function), 712 "no declaration matches %q#D", function); 713 if (fns) 714 print_candidates (fns); 715 else if (DECL_CONV_FN_P (function)) 716 inform (DECL_SOURCE_LOCATION (function), 717 "no conversion operators declared"); 718 else 719 inform (DECL_SOURCE_LOCATION (function), 720 "no functions named %qD", function); 721 inform (DECL_SOURCE_LOCATION (TYPE_NAME (ctype)), 722 "%#qT defined here", ctype); 723 } 724 matched = error_mark_node; 725 } 726 727 if (pushed_scope) 728 pop_scope (pushed_scope); 729 730 return matched; 731 } 732 733 /* DECL is a function with vague linkage. Remember it so that at the 734 end of the translation unit we can decide whether or not to emit 735 it. */ 736 737 void 738 note_vague_linkage_fn (tree decl) 739 { 740 if (processing_template_decl) 741 return; 742 743 DECL_DEFER_OUTPUT (decl) = 1; 744 vec_safe_push (deferred_fns, decl); 745 } 746 747 /* As above, but for variable template instantiations. */ 748 749 void 750 note_variable_template_instantiation (tree decl) 751 { 752 vec_safe_push (pending_statics, decl); 753 } 754 755 /* We have just processed the DECL, which is a static data member. 756 The other parameters are as for cp_finish_decl. */ 757 758 void 759 finish_static_data_member_decl (tree decl, 760 tree init, bool init_const_expr_p, 761 tree asmspec_tree, 762 int flags) 763 { 764 if (DECL_TEMPLATE_INSTANTIATED (decl)) 765 /* We already needed to instantiate this, so the processing in this 766 function is unnecessary/wrong. */ 767 return; 768 769 DECL_CONTEXT (decl) = current_class_type; 770 771 /* We cannot call pushdecl here, because that would fill in the 772 TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do 773 the right thing, namely, to put this decl out straight away. */ 774 775 if (! processing_template_decl) 776 vec_safe_push (pending_statics, decl); 777 778 if (LOCAL_CLASS_P (current_class_type) 779 /* We already complained about the template definition. */ 780 && !DECL_TEMPLATE_INSTANTIATION (decl)) 781 permerror (DECL_SOURCE_LOCATION (decl), 782 "local class %q#T shall not have static data member %q#D", 783 current_class_type, decl); 784 else 785 for (tree t = current_class_type; TYPE_P (t); 786 t = CP_TYPE_CONTEXT (t)) 787 if (TYPE_UNNAMED_P (t)) 788 { 789 auto_diagnostic_group d; 790 if (permerror (DECL_SOURCE_LOCATION (decl), 791 "static data member %qD in unnamed class", decl)) 792 inform (DECL_SOURCE_LOCATION (TYPE_NAME (t)), 793 "unnamed class defined here"); 794 break; 795 } 796 797 if (DECL_INLINE_VAR_P (decl) && !DECL_TEMPLATE_INSTANTIATION (decl)) 798 /* An inline variable is immediately defined, so don't set DECL_IN_AGGR_P. 799 Except that if decl is a template instantiation, it isn't defined until 800 instantiate_decl. */; 801 else 802 DECL_IN_AGGR_P (decl) = 1; 803 804 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 805 && TYPE_DOMAIN (TREE_TYPE (decl)) == NULL_TREE) 806 SET_VAR_HAD_UNKNOWN_BOUND (decl); 807 808 if (init) 809 { 810 /* Similarly to start_decl_1, we want to complete the type in order 811 to do the right thing in cp_apply_type_quals_to_decl, possibly 812 clear TYPE_QUAL_CONST (c++/65579). */ 813 tree type = TREE_TYPE (decl) = complete_type (TREE_TYPE (decl)); 814 cp_apply_type_quals_to_decl (cp_type_quals (type), decl); 815 } 816 817 cp_finish_decl (decl, init, init_const_expr_p, asmspec_tree, flags); 818 } 819 820 /* DECLARATOR and DECLSPECS correspond to a class member. The other 821 parameters are as for cp_finish_decl. Return the DECL for the 822 class member declared. */ 823 824 tree 825 grokfield (const cp_declarator *declarator, 826 cp_decl_specifier_seq *declspecs, 827 tree init, bool init_const_expr_p, 828 tree asmspec_tree, 829 tree attrlist) 830 { 831 tree value; 832 const char *asmspec = 0; 833 int flags; 834 835 if (init 836 && TREE_CODE (init) == TREE_LIST 837 && TREE_VALUE (init) == error_mark_node 838 && TREE_CHAIN (init) == NULL_TREE) 839 init = NULL_TREE; 840 841 value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist); 842 if (! value || value == error_mark_node) 843 /* friend or constructor went bad. */ 844 return error_mark_node; 845 if (TREE_TYPE (value) == error_mark_node) 846 return value; 847 848 if (TREE_CODE (value) == TYPE_DECL && init) 849 { 850 error_at (cp_expr_loc_or_loc (init, DECL_SOURCE_LOCATION (value)), 851 "typedef %qD is initialized (use %qs instead)", 852 value, "decltype"); 853 init = NULL_TREE; 854 } 855 856 /* Pass friendly classes back. */ 857 if (value == void_type_node) 858 return value; 859 860 if (DECL_NAME (value) 861 && TREE_CODE (DECL_NAME (value)) == TEMPLATE_ID_EXPR) 862 { 863 error_at (declarator->id_loc, 864 "explicit template argument list not allowed"); 865 return error_mark_node; 866 } 867 868 /* Stash away type declarations. */ 869 if (TREE_CODE (value) == TYPE_DECL) 870 { 871 DECL_NONLOCAL (value) = 1; 872 DECL_CONTEXT (value) = current_class_type; 873 874 if (attrlist) 875 { 876 int attrflags = 0; 877 878 /* If this is a typedef that names the class for linkage purposes 879 (7.1.3p8), apply any attributes directly to the type. */ 880 if (OVERLOAD_TYPE_P (TREE_TYPE (value)) 881 && value == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value)))) 882 attrflags = ATTR_FLAG_TYPE_IN_PLACE; 883 884 cplus_decl_attributes (&value, attrlist, attrflags); 885 } 886 887 if (decl_spec_seq_has_spec_p (declspecs, ds_typedef) 888 && TREE_TYPE (value) != error_mark_node 889 && TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))) != value) 890 set_underlying_type (value); 891 892 /* It's important that push_template_decl below follows 893 set_underlying_type above so that the created template 894 carries the properly set type of VALUE. */ 895 if (processing_template_decl) 896 value = push_template_decl (value); 897 898 record_locally_defined_typedef (value); 899 return value; 900 } 901 902 int friendp = decl_spec_seq_has_spec_p (declspecs, ds_friend); 903 904 if (!friendp && DECL_IN_AGGR_P (value)) 905 { 906 error ("%qD is already defined in %qT", value, DECL_CONTEXT (value)); 907 return void_type_node; 908 } 909 910 if (asmspec_tree && asmspec_tree != error_mark_node) 911 asmspec = TREE_STRING_POINTER (asmspec_tree); 912 913 if (init) 914 { 915 if (TREE_CODE (value) == FUNCTION_DECL) 916 { 917 if (init == ridpointers[(int)RID_DELETE]) 918 { 919 if (friendp && decl_defined_p (value)) 920 { 921 error ("redefinition of %q#D", value); 922 inform (DECL_SOURCE_LOCATION (value), 923 "%q#D previously defined here", value); 924 } 925 else 926 { 927 DECL_DELETED_FN (value) = 1; 928 DECL_DECLARED_INLINE_P (value) = 1; 929 DECL_INITIAL (value) = error_mark_node; 930 } 931 } 932 else if (init == ridpointers[(int)RID_DEFAULT]) 933 { 934 if (defaultable_fn_check (value)) 935 { 936 DECL_DEFAULTED_FN (value) = 1; 937 DECL_INITIALIZED_IN_CLASS_P (value) = 1; 938 DECL_DECLARED_INLINE_P (value) = 1; 939 } 940 } 941 else if (TREE_CODE (init) == DEFERRED_PARSE) 942 error ("invalid initializer for member function %qD", value); 943 else if (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE) 944 { 945 if (integer_zerop (init)) 946 DECL_PURE_VIRTUAL_P (value) = 1; 947 else if (error_operand_p (init)) 948 ; /* An error has already been reported. */ 949 else 950 error ("invalid initializer for member function %qD", 951 value); 952 } 953 else 954 { 955 gcc_assert (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE); 956 location_t iloc 957 = cp_expr_loc_or_loc (init, DECL_SOURCE_LOCATION (value)); 958 if (friendp) 959 error_at (iloc, "initializer specified for friend " 960 "function %qD", value); 961 else 962 error_at (iloc, "initializer specified for static " 963 "member function %qD", value); 964 } 965 } 966 else if (TREE_CODE (value) == FIELD_DECL) 967 /* C++11 NSDMI, keep going. */; 968 else if (!VAR_P (value)) 969 gcc_unreachable (); 970 } 971 972 /* Pass friend decls back. */ 973 if ((TREE_CODE (value) == FUNCTION_DECL 974 || TREE_CODE (value) == TEMPLATE_DECL) 975 && DECL_CONTEXT (value) != current_class_type) 976 return value; 977 978 /* Need to set this before push_template_decl. */ 979 if (VAR_P (value)) 980 DECL_CONTEXT (value) = current_class_type; 981 982 if (processing_template_decl && VAR_OR_FUNCTION_DECL_P (value)) 983 { 984 value = push_template_decl (value); 985 if (error_operand_p (value)) 986 return error_mark_node; 987 } 988 989 if (attrlist) 990 cplus_decl_attributes (&value, attrlist, 0); 991 992 if (init && DIRECT_LIST_INIT_P (init)) 993 flags = LOOKUP_NORMAL; 994 else 995 flags = LOOKUP_IMPLICIT; 996 997 if (decl_spec_seq_has_spec_p (declspecs, ds_constinit)) 998 flags |= LOOKUP_CONSTINIT; 999 1000 switch (TREE_CODE (value)) 1001 { 1002 case VAR_DECL: 1003 finish_static_data_member_decl (value, init, init_const_expr_p, 1004 asmspec_tree, flags); 1005 return value; 1006 1007 case FIELD_DECL: 1008 if (asmspec) 1009 error ("%<asm%> specifiers are not permitted on non-static data members"); 1010 if (DECL_INITIAL (value) == error_mark_node) 1011 init = error_mark_node; 1012 cp_finish_decl (value, init, /*init_const_expr_p=*/false, 1013 NULL_TREE, flags); 1014 DECL_IN_AGGR_P (value) = 1; 1015 return value; 1016 1017 case FUNCTION_DECL: 1018 if (asmspec) 1019 set_user_assembler_name (value, asmspec); 1020 1021 cp_finish_decl (value, 1022 /*init=*/NULL_TREE, 1023 /*init_const_expr_p=*/false, 1024 asmspec_tree, flags); 1025 1026 /* Pass friends back this way. */ 1027 if (DECL_FRIEND_P (value)) 1028 return void_type_node; 1029 1030 DECL_IN_AGGR_P (value) = 1; 1031 return value; 1032 1033 default: 1034 gcc_unreachable (); 1035 } 1036 return NULL_TREE; 1037 } 1038 1039 /* Like `grokfield', but for bitfields. 1040 WIDTH is the width of the bitfield, a constant expression. 1041 The other parameters are as for grokfield. */ 1042 1043 tree 1044 grokbitfield (const cp_declarator *declarator, 1045 cp_decl_specifier_seq *declspecs, tree width, tree init, 1046 tree attrlist) 1047 { 1048 tree value = grokdeclarator (declarator, declspecs, BITFIELD, 1049 init != NULL_TREE, &attrlist); 1050 1051 if (value == error_mark_node) 1052 return NULL_TREE; /* friends went bad. */ 1053 1054 tree type = TREE_TYPE (value); 1055 if (type == error_mark_node) 1056 return value; 1057 1058 /* Pass friendly classes back. */ 1059 if (VOID_TYPE_P (value)) 1060 return void_type_node; 1061 1062 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type) 1063 && (INDIRECT_TYPE_P (type) || !dependent_type_p (type))) 1064 { 1065 error_at (DECL_SOURCE_LOCATION (value), 1066 "bit-field %qD with non-integral type %qT", 1067 value, type); 1068 return error_mark_node; 1069 } 1070 1071 if (TREE_CODE (value) == TYPE_DECL) 1072 { 1073 error_at (DECL_SOURCE_LOCATION (value), 1074 "cannot declare %qD to be a bit-field type", value); 1075 return NULL_TREE; 1076 } 1077 1078 /* Usually, finish_struct_1 catches bitfields with invalid types. 1079 But, in the case of bitfields with function type, we confuse 1080 ourselves into thinking they are member functions, so we must 1081 check here. */ 1082 if (TREE_CODE (value) == FUNCTION_DECL) 1083 { 1084 error_at (DECL_SOURCE_LOCATION (value), 1085 "cannot declare bit-field %qD with function type", value); 1086 return NULL_TREE; 1087 } 1088 1089 if (TYPE_WARN_IF_NOT_ALIGN (type)) 1090 { 1091 error_at (DECL_SOURCE_LOCATION (value), "cannot declare bit-field " 1092 "%qD with %<warn_if_not_aligned%> type", value); 1093 return NULL_TREE; 1094 } 1095 1096 if (DECL_IN_AGGR_P (value)) 1097 { 1098 error ("%qD is already defined in the class %qT", value, 1099 DECL_CONTEXT (value)); 1100 return void_type_node; 1101 } 1102 1103 if (TREE_STATIC (value)) 1104 { 1105 error_at (DECL_SOURCE_LOCATION (value), 1106 "static member %qD cannot be a bit-field", value); 1107 return NULL_TREE; 1108 } 1109 1110 int flags = LOOKUP_IMPLICIT; 1111 if (init && DIRECT_LIST_INIT_P (init)) 1112 flags = LOOKUP_NORMAL; 1113 cp_finish_decl (value, init, false, NULL_TREE, flags); 1114 1115 if (width != error_mark_node) 1116 { 1117 /* The width must be an integer type. */ 1118 if (!type_dependent_expression_p (width) 1119 && !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (width))) 1120 error ("width of bit-field %qD has non-integral type %qT", value, 1121 TREE_TYPE (width)); 1122 else if (!check_for_bare_parameter_packs (width)) 1123 { 1124 /* Temporarily stash the width in DECL_BIT_FIELD_REPRESENTATIVE. 1125 check_bitfield_decl picks it from there later and sets DECL_SIZE 1126 accordingly. */ 1127 DECL_BIT_FIELD_REPRESENTATIVE (value) = width; 1128 SET_DECL_C_BIT_FIELD (value); 1129 } 1130 } 1131 1132 DECL_IN_AGGR_P (value) = 1; 1133 1134 if (attrlist) 1135 cplus_decl_attributes (&value, attrlist, /*flags=*/0); 1136 1137 return value; 1138 } 1139 1140 1141 /* Returns true iff ATTR is an attribute which needs to be applied at 1142 instantiation time rather than template definition time. */ 1143 1144 static bool 1145 is_late_template_attribute (tree attr, tree decl) 1146 { 1147 tree name = get_attribute_name (attr); 1148 tree args = TREE_VALUE (attr); 1149 const struct attribute_spec *spec = lookup_attribute_spec (name); 1150 tree arg; 1151 1152 if (!spec) 1153 /* Unknown attribute. */ 1154 return false; 1155 1156 /* Attribute weak handling wants to write out assembly right away. */ 1157 if (is_attribute_p ("weak", name)) 1158 return true; 1159 1160 /* Attributes used and unused are applied directly to typedefs for the 1161 benefit of maybe_warn_unused_local_typedefs. */ 1162 if (TREE_CODE (decl) == TYPE_DECL 1163 && (is_attribute_p ("unused", name) 1164 || is_attribute_p ("used", name))) 1165 return false; 1166 1167 /* Attribute tls_model wants to modify the symtab. */ 1168 if (is_attribute_p ("tls_model", name)) 1169 return true; 1170 1171 /* #pragma omp declare simd attribute needs to be always deferred. */ 1172 if (flag_openmp 1173 && is_attribute_p ("omp declare simd", name)) 1174 return true; 1175 1176 /* An attribute pack is clearly dependent. */ 1177 if (args && PACK_EXPANSION_P (args)) 1178 return true; 1179 1180 /* If any of the arguments are dependent expressions, we can't evaluate 1181 the attribute until instantiation time. */ 1182 for (arg = args; arg; arg = TREE_CHAIN (arg)) 1183 { 1184 tree t = TREE_VALUE (arg); 1185 1186 /* If the first attribute argument is an identifier, only consider 1187 second and following arguments. Attributes like mode, format, 1188 cleanup and several target specific attributes aren't late 1189 just because they have an IDENTIFIER_NODE as first argument. */ 1190 if (arg == args && attribute_takes_identifier_p (name) 1191 && identifier_p (t)) 1192 continue; 1193 1194 if (value_dependent_expression_p (t)) 1195 return true; 1196 } 1197 1198 if (TREE_CODE (decl) == TYPE_DECL 1199 || TYPE_P (decl) 1200 || spec->type_required) 1201 { 1202 tree type = TYPE_P (decl) ? decl : TREE_TYPE (decl); 1203 1204 /* We can't apply any attributes to a completely unknown type until 1205 instantiation time. */ 1206 enum tree_code code = TREE_CODE (type); 1207 if (code == TEMPLATE_TYPE_PARM 1208 || code == BOUND_TEMPLATE_TEMPLATE_PARM 1209 || code == TYPENAME_TYPE) 1210 return true; 1211 /* Also defer most attributes on dependent types. This is not 1212 necessary in all cases, but is the better default. */ 1213 else if (dependent_type_p (type) 1214 /* But some attributes specifically apply to templates. */ 1215 && !is_attribute_p ("abi_tag", name) 1216 && !is_attribute_p ("deprecated", name) 1217 && !is_attribute_p ("visibility", name)) 1218 return true; 1219 else 1220 return false; 1221 } 1222 else 1223 return false; 1224 } 1225 1226 /* ATTR_P is a list of attributes. Remove any attributes which need to be 1227 applied at instantiation time and return them. If IS_DEPENDENT is true, 1228 the declaration itself is dependent, so all attributes should be applied 1229 at instantiation time. */ 1230 1231 tree 1232 splice_template_attributes (tree *attr_p, tree decl) 1233 { 1234 tree *p = attr_p; 1235 tree late_attrs = NULL_TREE; 1236 tree *q = &late_attrs; 1237 1238 if (!p) 1239 return NULL_TREE; 1240 1241 for (; *p; ) 1242 { 1243 if (is_late_template_attribute (*p, decl)) 1244 { 1245 ATTR_IS_DEPENDENT (*p) = 1; 1246 *q = *p; 1247 *p = TREE_CHAIN (*p); 1248 q = &TREE_CHAIN (*q); 1249 *q = NULL_TREE; 1250 } 1251 else 1252 p = &TREE_CHAIN (*p); 1253 } 1254 1255 return late_attrs; 1256 } 1257 1258 /* Remove any late attributes from the list in ATTR_P and attach them to 1259 DECL_P. */ 1260 1261 static void 1262 save_template_attributes (tree *attr_p, tree *decl_p, int flags) 1263 { 1264 tree *q; 1265 1266 if (attr_p && *attr_p == error_mark_node) 1267 return; 1268 1269 tree late_attrs = splice_template_attributes (attr_p, *decl_p); 1270 if (!late_attrs) 1271 return; 1272 1273 if (DECL_P (*decl_p)) 1274 q = &DECL_ATTRIBUTES (*decl_p); 1275 else 1276 q = &TYPE_ATTRIBUTES (*decl_p); 1277 1278 tree old_attrs = *q; 1279 1280 /* Merge the late attributes at the beginning with the attribute 1281 list. */ 1282 late_attrs = merge_attributes (late_attrs, *q); 1283 if (*q != late_attrs 1284 && !DECL_P (*decl_p) 1285 && !(flags & ATTR_FLAG_TYPE_IN_PLACE)) 1286 { 1287 if (!dependent_type_p (*decl_p)) 1288 *decl_p = cp_build_type_attribute_variant (*decl_p, late_attrs); 1289 else 1290 { 1291 *decl_p = build_variant_type_copy (*decl_p); 1292 TYPE_ATTRIBUTES (*decl_p) = late_attrs; 1293 } 1294 } 1295 else 1296 *q = late_attrs; 1297 1298 if (!DECL_P (*decl_p) && *decl_p == TYPE_MAIN_VARIANT (*decl_p)) 1299 { 1300 /* We've added new attributes directly to the main variant, so 1301 now we need to update all of the other variants to include 1302 these new attributes. */ 1303 tree variant; 1304 for (variant = TYPE_NEXT_VARIANT (*decl_p); variant; 1305 variant = TYPE_NEXT_VARIANT (variant)) 1306 { 1307 gcc_assert (TYPE_ATTRIBUTES (variant) == old_attrs); 1308 TYPE_ATTRIBUTES (variant) = TYPE_ATTRIBUTES (*decl_p); 1309 } 1310 } 1311 } 1312 1313 /* True if ATTRS contains any dependent attributes that affect type 1314 identity. */ 1315 1316 bool 1317 any_dependent_type_attributes_p (tree attrs) 1318 { 1319 for (tree a = attrs; a; a = TREE_CHAIN (a)) 1320 if (ATTR_IS_DEPENDENT (a)) 1321 { 1322 const attribute_spec *as = lookup_attribute_spec (TREE_PURPOSE (a)); 1323 if (as && as->affects_type_identity) 1324 return true; 1325 } 1326 return false; 1327 } 1328 1329 /* Return true iff ATTRS are acceptable attributes to be applied in-place 1330 to a typedef which gives a previously unnamed class or enum a name for 1331 linkage purposes. */ 1332 1333 bool 1334 attributes_naming_typedef_ok (tree attrs) 1335 { 1336 for (; attrs; attrs = TREE_CHAIN (attrs)) 1337 { 1338 tree name = get_attribute_name (attrs); 1339 if (is_attribute_p ("vector_size", name)) 1340 return false; 1341 } 1342 return true; 1343 } 1344 1345 /* Like reconstruct_complex_type, but handle also template trees. */ 1346 1347 tree 1348 cp_reconstruct_complex_type (tree type, tree bottom) 1349 { 1350 tree inner, outer; 1351 1352 if (TYPE_PTR_P (type)) 1353 { 1354 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom); 1355 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type), 1356 TYPE_REF_CAN_ALIAS_ALL (type)); 1357 } 1358 else if (TYPE_REF_P (type)) 1359 { 1360 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom); 1361 outer = build_reference_type_for_mode (inner, TYPE_MODE (type), 1362 TYPE_REF_CAN_ALIAS_ALL (type)); 1363 } 1364 else if (TREE_CODE (type) == ARRAY_TYPE) 1365 { 1366 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom); 1367 outer = build_cplus_array_type (inner, TYPE_DOMAIN (type)); 1368 /* Don't call cp_build_qualified_type on ARRAY_TYPEs, the 1369 element type qualification will be handled by the recursive 1370 cp_reconstruct_complex_type call and cp_build_qualified_type 1371 for ARRAY_TYPEs changes the element type. */ 1372 return outer; 1373 } 1374 else if (TREE_CODE (type) == FUNCTION_TYPE) 1375 { 1376 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom); 1377 outer = build_function_type (inner, TYPE_ARG_TYPES (type)); 1378 outer = apply_memfn_quals (outer, type_memfn_quals (type)); 1379 } 1380 else if (TREE_CODE (type) == METHOD_TYPE) 1381 { 1382 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom); 1383 /* The build_method_type_directly() routine prepends 'this' to argument list, 1384 so we must compensate by getting rid of it. */ 1385 outer 1386 = build_method_type_directly 1387 (class_of_this_parm (type), inner, 1388 TREE_CHAIN (TYPE_ARG_TYPES (type))); 1389 } 1390 else if (TREE_CODE (type) == OFFSET_TYPE) 1391 { 1392 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom); 1393 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner); 1394 } 1395 else 1396 return bottom; 1397 1398 if (TYPE_ATTRIBUTES (type)) 1399 outer = cp_build_type_attribute_variant (outer, TYPE_ATTRIBUTES (type)); 1400 outer = cp_build_qualified_type (outer, cp_type_quals (type)); 1401 outer = cxx_copy_lang_qualifiers (outer, type); 1402 1403 return outer; 1404 } 1405 1406 /* Replaces any constexpr expression that may be into the attributes 1407 arguments with their reduced value. */ 1408 1409 void 1410 cp_check_const_attributes (tree attributes) 1411 { 1412 if (attributes == error_mark_node) 1413 return; 1414 1415 tree attr; 1416 for (attr = attributes; attr; attr = TREE_CHAIN (attr)) 1417 { 1418 tree arg; 1419 for (arg = TREE_VALUE (attr); arg && TREE_CODE (arg) == TREE_LIST; 1420 arg = TREE_CHAIN (arg)) 1421 { 1422 tree expr = TREE_VALUE (arg); 1423 if (EXPR_P (expr)) 1424 TREE_VALUE (arg) = fold_non_dependent_expr (expr); 1425 } 1426 } 1427 } 1428 1429 /* Return true if TYPE is an OpenMP mappable type. 1430 If NOTES is non-zero, emit a note message for each problem. */ 1431 static bool 1432 cp_omp_mappable_type_1 (tree type, bool notes) 1433 { 1434 bool result = true; 1435 1436 /* Mappable type has to be complete. */ 1437 if (type == error_mark_node || !COMPLETE_TYPE_P (type)) 1438 { 1439 if (notes && type != error_mark_node) 1440 { 1441 tree decl = TYPE_MAIN_DECL (type); 1442 inform ((decl ? DECL_SOURCE_LOCATION (decl) : input_location), 1443 "incomplete type %qT is not mappable", type); 1444 } 1445 result = false; 1446 } 1447 /* Arrays have mappable type if the elements have mappable type. */ 1448 while (TREE_CODE (type) == ARRAY_TYPE) 1449 type = TREE_TYPE (type); 1450 /* A mappable type cannot contain virtual members. */ 1451 if (CLASS_TYPE_P (type) && CLASSTYPE_VTABLES (type)) 1452 { 1453 if (notes) 1454 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)), 1455 "type %qT with virtual members is not mappable", type); 1456 result = false; 1457 } 1458 /* All data members must be non-static. */ 1459 if (CLASS_TYPE_P (type)) 1460 { 1461 tree field; 1462 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 1463 if (VAR_P (field)) 1464 { 1465 if (notes) 1466 inform (DECL_SOURCE_LOCATION (field), 1467 "static field %qD is not mappable", field); 1468 result = false; 1469 } 1470 /* All fields must have mappable types. */ 1471 else if (TREE_CODE (field) == FIELD_DECL 1472 && !cp_omp_mappable_type_1 (TREE_TYPE (field), notes)) 1473 result = false; 1474 } 1475 return result; 1476 } 1477 1478 /* Return true if TYPE is an OpenMP mappable type. */ 1479 bool 1480 cp_omp_mappable_type (tree type) 1481 { 1482 return cp_omp_mappable_type_1 (type, false); 1483 } 1484 1485 /* Return true if TYPE is an OpenMP mappable type. 1486 Emit an error messages if not. */ 1487 bool 1488 cp_omp_emit_unmappable_type_notes (tree type) 1489 { 1490 return cp_omp_mappable_type_1 (type, true); 1491 } 1492 1493 /* Return the last pushed declaration for the symbol DECL or NULL 1494 when no such declaration exists. */ 1495 1496 static tree 1497 find_last_decl (tree decl) 1498 { 1499 tree last_decl = NULL_TREE; 1500 1501 if (tree name = DECL_P (decl) ? DECL_NAME (decl) : NULL_TREE) 1502 { 1503 /* Look up the declaration in its scope. */ 1504 tree pushed_scope = NULL_TREE; 1505 if (tree ctype = DECL_CONTEXT (decl)) 1506 pushed_scope = push_scope (ctype); 1507 1508 last_decl = lookup_name (name); 1509 1510 if (pushed_scope) 1511 pop_scope (pushed_scope); 1512 1513 /* The declaration may be a member conversion operator 1514 or a bunch of overfloads (handle the latter below). */ 1515 if (last_decl && BASELINK_P (last_decl)) 1516 last_decl = BASELINK_FUNCTIONS (last_decl); 1517 } 1518 1519 if (!last_decl) 1520 return NULL_TREE; 1521 1522 if (DECL_P (last_decl) || TREE_CODE (last_decl) == OVERLOAD) 1523 { 1524 /* A set of overloads of the same function. */ 1525 for (lkp_iterator iter (last_decl); iter; ++iter) 1526 { 1527 if (TREE_CODE (*iter) == OVERLOAD) 1528 continue; 1529 1530 if (decls_match (decl, *iter, /*record_decls=*/false)) 1531 return *iter; 1532 } 1533 return NULL_TREE; 1534 } 1535 1536 return NULL_TREE; 1537 } 1538 1539 /* Like decl_attributes, but handle C++ complexity. */ 1540 1541 void 1542 cplus_decl_attributes (tree *decl, tree attributes, int flags) 1543 { 1544 if (*decl == NULL_TREE || *decl == void_type_node 1545 || *decl == error_mark_node) 1546 return; 1547 1548 /* Add implicit "omp declare target" attribute if requested. */ 1549 if (scope_chain->omp_declare_target_attribute 1550 && ((VAR_P (*decl) 1551 && (TREE_STATIC (*decl) || DECL_EXTERNAL (*decl))) 1552 || TREE_CODE (*decl) == FUNCTION_DECL)) 1553 { 1554 if (VAR_P (*decl) 1555 && DECL_CLASS_SCOPE_P (*decl)) 1556 error ("%q+D static data member inside of declare target directive", 1557 *decl); 1558 else if (VAR_P (*decl) 1559 && (processing_template_decl 1560 || !cp_omp_mappable_type (TREE_TYPE (*decl)))) 1561 attributes = tree_cons (get_identifier ("omp declare target implicit"), 1562 NULL_TREE, attributes); 1563 else 1564 { 1565 attributes = tree_cons (get_identifier ("omp declare target"), 1566 NULL_TREE, attributes); 1567 attributes = tree_cons (get_identifier ("omp declare target block"), 1568 NULL_TREE, attributes); 1569 } 1570 } 1571 1572 if (processing_template_decl) 1573 { 1574 if (check_for_bare_parameter_packs (attributes)) 1575 return; 1576 1577 save_template_attributes (&attributes, decl, flags); 1578 } 1579 1580 cp_check_const_attributes (attributes); 1581 1582 if (TREE_CODE (*decl) == TEMPLATE_DECL) 1583 decl = &DECL_TEMPLATE_RESULT (*decl); 1584 1585 if (TREE_TYPE (*decl) && TYPE_PTRMEMFUNC_P (TREE_TYPE (*decl))) 1586 { 1587 attributes 1588 = decl_attributes (decl, attributes, flags | ATTR_FLAG_FUNCTION_NEXT); 1589 decl_attributes (&TYPE_PTRMEMFUNC_FN_TYPE_RAW (TREE_TYPE (*decl)), 1590 attributes, flags); 1591 } 1592 else 1593 { 1594 tree last_decl = find_last_decl (*decl); 1595 decl_attributes (decl, attributes, flags, last_decl); 1596 } 1597 1598 if (TREE_CODE (*decl) == TYPE_DECL) 1599 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl)); 1600 1601 /* Propagate deprecation out to the template. */ 1602 if (TREE_DEPRECATED (*decl)) 1603 if (tree ti = get_template_info (*decl)) 1604 { 1605 tree tmpl = TI_TEMPLATE (ti); 1606 tree pattern = (TYPE_P (*decl) ? TREE_TYPE (tmpl) 1607 : DECL_TEMPLATE_RESULT (tmpl)); 1608 if (*decl == pattern) 1609 TREE_DEPRECATED (tmpl) = true; 1610 } 1611 } 1612 1613 /* Walks through the namespace- or function-scope anonymous union 1614 OBJECT, with the indicated TYPE, building appropriate VAR_DECLs. 1615 Returns one of the fields for use in the mangled name. */ 1616 1617 static tree 1618 build_anon_union_vars (tree type, tree object) 1619 { 1620 tree main_decl = NULL_TREE; 1621 tree field; 1622 1623 /* Rather than write the code to handle the non-union case, 1624 just give an error. */ 1625 if (TREE_CODE (type) != UNION_TYPE) 1626 { 1627 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)), 1628 "anonymous struct not inside named type"); 1629 return error_mark_node; 1630 } 1631 1632 for (field = TYPE_FIELDS (type); 1633 field != NULL_TREE; 1634 field = DECL_CHAIN (field)) 1635 { 1636 tree decl; 1637 tree ref; 1638 1639 if (DECL_ARTIFICIAL (field)) 1640 continue; 1641 if (TREE_CODE (field) != FIELD_DECL) 1642 { 1643 permerror (DECL_SOURCE_LOCATION (field), 1644 "%q#D invalid; an anonymous union can only " 1645 "have non-static data members", field); 1646 continue; 1647 } 1648 1649 if (TREE_PRIVATE (field)) 1650 permerror (DECL_SOURCE_LOCATION (field), 1651 "private member %q#D in anonymous union", field); 1652 else if (TREE_PROTECTED (field)) 1653 permerror (DECL_SOURCE_LOCATION (field), 1654 "protected member %q#D in anonymous union", field); 1655 1656 if (processing_template_decl) 1657 ref = build_min_nt_loc (UNKNOWN_LOCATION, COMPONENT_REF, object, 1658 DECL_NAME (field), NULL_TREE); 1659 else 1660 ref = build_class_member_access_expr (object, field, NULL_TREE, 1661 false, tf_warning_or_error); 1662 1663 if (DECL_NAME (field)) 1664 { 1665 tree base; 1666 1667 decl = build_decl (input_location, 1668 VAR_DECL, DECL_NAME (field), TREE_TYPE (field)); 1669 DECL_ANON_UNION_VAR_P (decl) = 1; 1670 DECL_ARTIFICIAL (decl) = 1; 1671 1672 base = get_base_address (object); 1673 TREE_PUBLIC (decl) = TREE_PUBLIC (base); 1674 TREE_STATIC (decl) = TREE_STATIC (base); 1675 DECL_EXTERNAL (decl) = DECL_EXTERNAL (base); 1676 1677 SET_DECL_VALUE_EXPR (decl, ref); 1678 DECL_HAS_VALUE_EXPR_P (decl) = 1; 1679 1680 decl = pushdecl (decl); 1681 } 1682 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field))) 1683 decl = build_anon_union_vars (TREE_TYPE (field), ref); 1684 else 1685 decl = 0; 1686 1687 if (main_decl == NULL_TREE) 1688 main_decl = decl; 1689 } 1690 1691 return main_decl; 1692 } 1693 1694 /* Finish off the processing of a UNION_TYPE structure. If the union is an 1695 anonymous union, then all members must be laid out together. PUBLIC_P 1696 is nonzero if this union is not declared static. */ 1697 1698 void 1699 finish_anon_union (tree anon_union_decl) 1700 { 1701 tree type; 1702 tree main_decl; 1703 bool public_p; 1704 1705 if (anon_union_decl == error_mark_node) 1706 return; 1707 1708 type = TREE_TYPE (anon_union_decl); 1709 public_p = TREE_PUBLIC (anon_union_decl); 1710 1711 /* The VAR_DECL's context is the same as the TYPE's context. */ 1712 DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type)); 1713 1714 if (TYPE_FIELDS (type) == NULL_TREE) 1715 return; 1716 1717 if (public_p) 1718 { 1719 error ("namespace-scope anonymous aggregates must be static"); 1720 return; 1721 } 1722 1723 main_decl = build_anon_union_vars (type, anon_union_decl); 1724 if (main_decl == error_mark_node) 1725 return; 1726 if (main_decl == NULL_TREE) 1727 { 1728 pedwarn (input_location, 0, "anonymous union with no members"); 1729 return; 1730 } 1731 1732 if (!processing_template_decl) 1733 { 1734 /* Use main_decl to set the mangled name. */ 1735 DECL_NAME (anon_union_decl) = DECL_NAME (main_decl); 1736 maybe_commonize_var (anon_union_decl); 1737 if (TREE_STATIC (anon_union_decl) || DECL_EXTERNAL (anon_union_decl)) 1738 { 1739 if (DECL_DISCRIMINATOR_P (anon_union_decl)) 1740 determine_local_discriminator (anon_union_decl); 1741 mangle_decl (anon_union_decl); 1742 } 1743 DECL_NAME (anon_union_decl) = NULL_TREE; 1744 } 1745 1746 pushdecl (anon_union_decl); 1747 cp_finish_decl (anon_union_decl, NULL_TREE, false, NULL_TREE, 0); 1748 } 1749 1750 /* Auxiliary functions to make type signatures for 1751 `operator new' and `operator delete' correspond to 1752 what compiler will be expecting. */ 1753 1754 tree 1755 coerce_new_type (tree type, location_t loc) 1756 { 1757 int e = 0; 1758 tree args = TYPE_ARG_TYPES (type); 1759 1760 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE); 1761 1762 if (!same_type_p (TREE_TYPE (type), ptr_type_node)) 1763 { 1764 e = 1; 1765 error_at (loc, "%<operator new%> must return type %qT", 1766 ptr_type_node); 1767 } 1768 1769 if (args && args != void_list_node) 1770 { 1771 if (TREE_PURPOSE (args)) 1772 { 1773 /* [basic.stc.dynamic.allocation] 1774 1775 The first parameter shall not have an associated default 1776 argument. */ 1777 error_at (loc, "the first parameter of %<operator new%> cannot " 1778 "have a default argument"); 1779 /* Throw away the default argument. */ 1780 TREE_PURPOSE (args) = NULL_TREE; 1781 } 1782 1783 if (!same_type_p (TREE_VALUE (args), size_type_node)) 1784 { 1785 e = 2; 1786 args = TREE_CHAIN (args); 1787 } 1788 } 1789 else 1790 e = 2; 1791 1792 if (e == 2) 1793 permerror (loc, "%<operator new%> takes type %<size_t%> (%qT) " 1794 "as first parameter", size_type_node); 1795 1796 switch (e) 1797 { 1798 case 2: 1799 args = tree_cons (NULL_TREE, size_type_node, args); 1800 /* Fall through. */ 1801 case 1: 1802 type = (cxx_copy_lang_qualifiers 1803 (build_function_type (ptr_type_node, args), 1804 type)); 1805 /* Fall through. */ 1806 default:; 1807 } 1808 return type; 1809 } 1810 1811 void 1812 coerce_delete_type (tree decl, location_t loc) 1813 { 1814 int e = 0; 1815 tree type = TREE_TYPE (decl); 1816 tree args = TYPE_ARG_TYPES (type); 1817 1818 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE); 1819 1820 if (!same_type_p (TREE_TYPE (type), void_type_node)) 1821 { 1822 e = 1; 1823 error_at (loc, "%<operator delete%> must return type %qT", 1824 void_type_node); 1825 } 1826 1827 tree ptrtype = ptr_type_node; 1828 if (destroying_delete_p (decl)) 1829 { 1830 if (DECL_CLASS_SCOPE_P (decl)) 1831 /* If the function is a destroying operator delete declared in class 1832 type C, the type of its first parameter shall be C*. */ 1833 ptrtype = build_pointer_type (DECL_CONTEXT (decl)); 1834 else 1835 /* A destroying operator delete shall be a class member function named 1836 operator delete. */ 1837 error_at (loc, 1838 "destroying %<operator delete%> must be a member function"); 1839 const ovl_op_info_t *op = IDENTIFIER_OVL_OP_INFO (DECL_NAME (decl)); 1840 if (op->flags & OVL_OP_FLAG_VEC) 1841 error_at (loc, "%<operator delete[]%> cannot be a destroying delete"); 1842 if (!usual_deallocation_fn_p (decl)) 1843 error_at (loc, "destroying %<operator delete%> must be a usual " 1844 "deallocation function"); 1845 } 1846 1847 if (!args || args == void_list_node 1848 || !same_type_p (TREE_VALUE (args), ptrtype)) 1849 { 1850 e = 2; 1851 if (args && args != void_list_node) 1852 args = TREE_CHAIN (args); 1853 error_at (loc, "%<operator delete%> takes type %qT as first parameter", 1854 ptrtype); 1855 } 1856 switch (e) 1857 { 1858 case 2: 1859 args = tree_cons (NULL_TREE, ptrtype, args); 1860 /* Fall through. */ 1861 case 1: 1862 type = (cxx_copy_lang_qualifiers 1863 (build_function_type (void_type_node, args), 1864 type)); 1865 /* Fall through. */ 1866 default:; 1867 } 1868 1869 TREE_TYPE (decl) = type; 1870 } 1871 1872 /* DECL is a VAR_DECL for a vtable: walk through the entries in the vtable 1873 and mark them as needed. */ 1874 1875 static void 1876 mark_vtable_entries (tree decl) 1877 { 1878 tree fnaddr; 1879 unsigned HOST_WIDE_INT idx; 1880 1881 /* It's OK for the vtable to refer to deprecated virtual functions. */ 1882 warning_sentinel w(warn_deprecated_decl); 1883 1884 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)), 1885 idx, fnaddr) 1886 { 1887 tree fn; 1888 1889 STRIP_NOPS (fnaddr); 1890 1891 if (TREE_CODE (fnaddr) != ADDR_EXPR 1892 && TREE_CODE (fnaddr) != FDESC_EXPR) 1893 /* This entry is an offset: a virtual base class offset, a 1894 virtual call offset, an RTTI offset, etc. */ 1895 continue; 1896 1897 fn = TREE_OPERAND (fnaddr, 0); 1898 TREE_ADDRESSABLE (fn) = 1; 1899 /* When we don't have vcall offsets, we output thunks whenever 1900 we output the vtables that contain them. With vcall offsets, 1901 we know all the thunks we'll need when we emit a virtual 1902 function, so we emit the thunks there instead. */ 1903 if (DECL_THUNK_P (fn)) 1904 use_thunk (fn, /*emit_p=*/0); 1905 /* Set the location, as marking the function could cause 1906 instantiation. We do not need to preserve the incoming 1907 location, as we're called from c_parse_final_cleanups, which 1908 takes care of that. */ 1909 input_location = DECL_SOURCE_LOCATION (fn); 1910 mark_used (fn); 1911 } 1912 } 1913 1914 /* Adjust the TLS model on variable DECL if need be, typically after 1915 the linkage of DECL has been modified. */ 1916 1917 static void 1918 adjust_var_decl_tls_model (tree decl) 1919 { 1920 if (CP_DECL_THREAD_LOCAL_P (decl) 1921 && !lookup_attribute ("tls_model", DECL_ATTRIBUTES (decl))) 1922 set_decl_tls_model (decl, decl_default_tls_model (decl)); 1923 } 1924 1925 /* Set DECL up to have the closest approximation of "initialized common" 1926 linkage available. */ 1927 1928 void 1929 comdat_linkage (tree decl) 1930 { 1931 if (flag_weak) 1932 make_decl_one_only (decl, cxx_comdat_group (decl)); 1933 else if (TREE_CODE (decl) == FUNCTION_DECL 1934 || (VAR_P (decl) && DECL_ARTIFICIAL (decl))) 1935 /* We can just emit function and compiler-generated variables 1936 statically; having multiple copies is (for the most part) only 1937 a waste of space. 1938 1939 There are two correctness issues, however: the address of a 1940 template instantiation with external linkage should be the 1941 same, independent of what translation unit asks for the 1942 address, and this will not hold when we emit multiple copies of 1943 the function. However, there's little else we can do. 1944 1945 Also, by default, the typeinfo implementation assumes that 1946 there will be only one copy of the string used as the name for 1947 each type. Therefore, if weak symbols are unavailable, the 1948 run-time library should perform a more conservative check; it 1949 should perform a string comparison, rather than an address 1950 comparison. */ 1951 TREE_PUBLIC (decl) = 0; 1952 else 1953 { 1954 /* Static data member template instantiations, however, cannot 1955 have multiple copies. */ 1956 if (DECL_INITIAL (decl) == 0 1957 || DECL_INITIAL (decl) == error_mark_node) 1958 DECL_COMMON (decl) = 1; 1959 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))) 1960 { 1961 DECL_COMMON (decl) = 1; 1962 DECL_INITIAL (decl) = error_mark_node; 1963 } 1964 else if (!DECL_EXPLICIT_INSTANTIATION (decl)) 1965 { 1966 /* We can't do anything useful; leave vars for explicit 1967 instantiation. */ 1968 DECL_EXTERNAL (decl) = 1; 1969 DECL_NOT_REALLY_EXTERN (decl) = 0; 1970 } 1971 } 1972 1973 if (TREE_PUBLIC (decl)) 1974 DECL_COMDAT (decl) = 1; 1975 1976 if (VAR_P (decl)) 1977 adjust_var_decl_tls_model (decl); 1978 } 1979 1980 /* For win32 we also want to put explicit instantiations in 1981 linkonce sections, so that they will be merged with implicit 1982 instantiations; otherwise we get duplicate symbol errors. 1983 For Darwin we do not want explicit instantiations to be 1984 linkonce. */ 1985 1986 void 1987 maybe_make_one_only (tree decl) 1988 { 1989 /* We used to say that this was not necessary on targets that support weak 1990 symbols, because the implicit instantiations will defer to the explicit 1991 one. However, that's not actually the case in SVR4; a strong definition 1992 after a weak one is an error. Also, not making explicit 1993 instantiations one_only means that we can end up with two copies of 1994 some template instantiations. */ 1995 if (! flag_weak) 1996 return; 1997 1998 /* We can't set DECL_COMDAT on functions, or cp_finish_file will think 1999 we can get away with not emitting them if they aren't used. We need 2000 to for variables so that cp_finish_decl will update their linkage, 2001 because their DECL_INITIAL may not have been set properly yet. */ 2002 2003 if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC 2004 || (! DECL_EXPLICIT_INSTANTIATION (decl) 2005 && ! DECL_TEMPLATE_SPECIALIZATION (decl))) 2006 { 2007 make_decl_one_only (decl, cxx_comdat_group (decl)); 2008 2009 if (VAR_P (decl)) 2010 { 2011 varpool_node *node = varpool_node::get_create (decl); 2012 DECL_COMDAT (decl) = 1; 2013 /* Mark it needed so we don't forget to emit it. */ 2014 node->forced_by_abi = true; 2015 TREE_USED (decl) = 1; 2016 2017 adjust_var_decl_tls_model (decl); 2018 } 2019 } 2020 } 2021 2022 /* Returns true iff DECL, a FUNCTION_DECL or VAR_DECL, has vague linkage. 2023 This predicate will give the right answer during parsing of the 2024 function, which other tests may not. */ 2025 2026 bool 2027 vague_linkage_p (tree decl) 2028 { 2029 if (!TREE_PUBLIC (decl)) 2030 { 2031 /* maybe_thunk_body clears TREE_PUBLIC and DECL_ABSTRACT_P on the 2032 maybe-in-charge 'tor variants; in that case we need to check one of 2033 the "clones" for the real linkage. But only in that case; before 2034 maybe_clone_body we haven't yet copied the linkage to the clones. */ 2035 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl) 2036 && !DECL_ABSTRACT_P (decl) 2037 && DECL_CHAIN (decl) 2038 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl))) 2039 return vague_linkage_p (DECL_CHAIN (decl)); 2040 2041 gcc_checking_assert (!DECL_COMDAT (decl)); 2042 return false; 2043 } 2044 /* Unfortunately, import_export_decl has not always been called 2045 before the function is processed, so we cannot simply check 2046 DECL_COMDAT. */ 2047 if (DECL_COMDAT (decl) 2048 || (TREE_CODE (decl) == FUNCTION_DECL 2049 && DECL_DECLARED_INLINE_P (decl)) 2050 || (DECL_LANG_SPECIFIC (decl) 2051 && DECL_TEMPLATE_INSTANTIATION (decl)) 2052 || (VAR_P (decl) && DECL_INLINE_VAR_P (decl))) 2053 return true; 2054 else if (DECL_FUNCTION_SCOPE_P (decl)) 2055 /* A local static in an inline effectively has vague linkage. */ 2056 return (TREE_STATIC (decl) 2057 && vague_linkage_p (DECL_CONTEXT (decl))); 2058 else 2059 return false; 2060 } 2061 2062 /* Determine whether or not we want to specifically import or export CTYPE, 2063 using various heuristics. */ 2064 2065 static void 2066 import_export_class (tree ctype) 2067 { 2068 /* -1 for imported, 1 for exported. */ 2069 int import_export = 0; 2070 2071 /* It only makes sense to call this function at EOF. The reason is 2072 that this function looks at whether or not the first non-inline 2073 non-abstract virtual member function has been defined in this 2074 translation unit. But, we can't possibly know that until we've 2075 seen the entire translation unit. */ 2076 gcc_assert (at_eof); 2077 2078 if (CLASSTYPE_INTERFACE_KNOWN (ctype)) 2079 return; 2080 2081 /* If MULTIPLE_SYMBOL_SPACES is set and we saw a #pragma interface, 2082 we will have CLASSTYPE_INTERFACE_ONLY set but not 2083 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this 2084 heuristic because someone will supply a #pragma implementation 2085 elsewhere, and deducing it here would produce a conflict. */ 2086 if (CLASSTYPE_INTERFACE_ONLY (ctype)) 2087 return; 2088 2089 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype))) 2090 import_export = -1; 2091 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype))) 2092 import_export = 1; 2093 else if (CLASSTYPE_IMPLICIT_INSTANTIATION (ctype) 2094 && !flag_implicit_templates) 2095 /* For a template class, without -fimplicit-templates, check the 2096 repository. If the virtual table is assigned to this 2097 translation unit, then export the class; otherwise, import 2098 it. */ 2099 import_export = -1; 2100 else if (TYPE_POLYMORPHIC_P (ctype)) 2101 { 2102 /* The ABI specifies that the virtual table and associated 2103 information are emitted with the key method, if any. */ 2104 tree method = CLASSTYPE_KEY_METHOD (ctype); 2105 /* If weak symbol support is not available, then we must be 2106 careful not to emit the vtable when the key function is 2107 inline. An inline function can be defined in multiple 2108 translation units. If we were to emit the vtable in each 2109 translation unit containing a definition, we would get 2110 multiple definition errors at link-time. */ 2111 if (method && (flag_weak || ! DECL_DECLARED_INLINE_P (method))) 2112 import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1); 2113 } 2114 2115 /* When MULTIPLE_SYMBOL_SPACES is set, we cannot count on seeing 2116 a definition anywhere else. */ 2117 if (MULTIPLE_SYMBOL_SPACES && import_export == -1) 2118 import_export = 0; 2119 2120 /* Allow back ends the chance to overrule the decision. */ 2121 if (targetm.cxx.import_export_class) 2122 import_export = targetm.cxx.import_export_class (ctype, import_export); 2123 2124 if (import_export) 2125 { 2126 SET_CLASSTYPE_INTERFACE_KNOWN (ctype); 2127 CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0); 2128 } 2129 } 2130 2131 /* Return true if VAR has already been provided to the back end; in that 2132 case VAR should not be modified further by the front end. */ 2133 static bool 2134 var_finalized_p (tree var) 2135 { 2136 return varpool_node::get_create (var)->definition; 2137 } 2138 2139 /* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason, 2140 must be emitted in this translation unit. Mark it as such. */ 2141 2142 void 2143 mark_needed (tree decl) 2144 { 2145 TREE_USED (decl) = 1; 2146 if (TREE_CODE (decl) == FUNCTION_DECL) 2147 { 2148 /* Extern inline functions don't become needed when referenced. 2149 If we know a method will be emitted in other TU and no new 2150 functions can be marked reachable, just use the external 2151 definition. */ 2152 struct cgraph_node *node = cgraph_node::get_create (decl); 2153 node->forced_by_abi = true; 2154 2155 /* #pragma interface can call mark_needed for 2156 maybe-in-charge 'tors; mark the clones as well. */ 2157 tree clone; 2158 FOR_EACH_CLONE (clone, decl) 2159 mark_needed (clone); 2160 } 2161 else if (VAR_P (decl)) 2162 { 2163 varpool_node *node = varpool_node::get_create (decl); 2164 /* C++ frontend use mark_decl_references to force COMDAT variables 2165 to be output that might appear dead otherwise. */ 2166 node->forced_by_abi = true; 2167 } 2168 } 2169 2170 /* DECL is either a FUNCTION_DECL or a VAR_DECL. This function 2171 returns true if a definition of this entity should be provided in 2172 this object file. Callers use this function to determine whether 2173 or not to let the back end know that a definition of DECL is 2174 available in this translation unit. */ 2175 2176 bool 2177 decl_needed_p (tree decl) 2178 { 2179 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl)); 2180 /* This function should only be called at the end of the translation 2181 unit. We cannot be sure of whether or not something will be 2182 COMDAT until that point. */ 2183 gcc_assert (at_eof); 2184 2185 /* All entities with external linkage that are not COMDAT/EXTERN should be 2186 emitted; they may be referred to from other object files. */ 2187 if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_REALLY_EXTERN (decl)) 2188 return true; 2189 /* Functions marked "dllexport" must be emitted so that they are 2190 visible to other DLLs. */ 2191 if (flag_keep_inline_dllexport 2192 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl))) 2193 return true; 2194 2195 /* When not optimizing, do not bother to produce definitions for extern 2196 symbols. */ 2197 if (DECL_REALLY_EXTERN (decl) 2198 && ((TREE_CODE (decl) != FUNCTION_DECL 2199 && !optimize) 2200 || (TREE_CODE (decl) == FUNCTION_DECL 2201 && !opt_for_fn (decl, optimize))) 2202 && !lookup_attribute ("always_inline", decl)) 2203 return false; 2204 2205 /* If this entity was used, let the back end see it; it will decide 2206 whether or not to emit it into the object file. */ 2207 if (TREE_USED (decl)) 2208 return true; 2209 2210 /* Virtual functions might be needed for devirtualization. */ 2211 if (flag_devirtualize 2212 && TREE_CODE (decl) == FUNCTION_DECL 2213 && DECL_VIRTUAL_P (decl)) 2214 return true; 2215 2216 /* Otherwise, DECL does not need to be emitted -- yet. A subsequent 2217 reference to DECL might cause it to be emitted later. */ 2218 return false; 2219 } 2220 2221 /* If necessary, write out the vtables for the dynamic class CTYPE. 2222 Returns true if any vtables were emitted. */ 2223 2224 static bool 2225 maybe_emit_vtables (tree ctype) 2226 { 2227 tree vtbl; 2228 tree primary_vtbl; 2229 int needed = 0; 2230 varpool_node *current = NULL, *last = NULL; 2231 2232 /* If the vtables for this class have already been emitted there is 2233 nothing more to do. */ 2234 primary_vtbl = CLASSTYPE_VTABLES (ctype); 2235 if (var_finalized_p (primary_vtbl)) 2236 return false; 2237 /* Ignore dummy vtables made by get_vtable_decl. */ 2238 if (TREE_TYPE (primary_vtbl) == void_type_node) 2239 return false; 2240 2241 /* On some targets, we cannot determine the key method until the end 2242 of the translation unit -- which is when this function is 2243 called. */ 2244 if (!targetm.cxx.key_method_may_be_inline ()) 2245 determine_key_method (ctype); 2246 2247 /* See if any of the vtables are needed. */ 2248 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl)) 2249 { 2250 import_export_decl (vtbl); 2251 if (DECL_NOT_REALLY_EXTERN (vtbl) && decl_needed_p (vtbl)) 2252 needed = 1; 2253 } 2254 if (!needed) 2255 { 2256 /* If the references to this class' vtables are optimized away, 2257 still emit the appropriate debugging information. See 2258 dfs_debug_mark. */ 2259 if (DECL_COMDAT (primary_vtbl) 2260 && CLASSTYPE_DEBUG_REQUESTED (ctype)) 2261 note_debug_info_needed (ctype); 2262 return false; 2263 } 2264 2265 /* The ABI requires that we emit all of the vtables if we emit any 2266 of them. */ 2267 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl)) 2268 { 2269 /* Mark entities references from the virtual table as used. */ 2270 mark_vtable_entries (vtbl); 2271 2272 if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0) 2273 { 2274 vec<tree, va_gc> *cleanups = NULL; 2275 tree expr = store_init_value (vtbl, DECL_INITIAL (vtbl), &cleanups, 2276 LOOKUP_NORMAL); 2277 2278 /* It had better be all done at compile-time. */ 2279 gcc_assert (!expr && !cleanups); 2280 } 2281 2282 /* Write it out. */ 2283 DECL_EXTERNAL (vtbl) = 0; 2284 rest_of_decl_compilation (vtbl, 1, 1); 2285 2286 /* Because we're only doing syntax-checking, we'll never end up 2287 actually marking the variable as written. */ 2288 if (flag_syntax_only) 2289 TREE_ASM_WRITTEN (vtbl) = 1; 2290 else if (DECL_ONE_ONLY (vtbl)) 2291 { 2292 current = varpool_node::get_create (vtbl); 2293 if (last) 2294 current->add_to_same_comdat_group (last); 2295 last = current; 2296 } 2297 } 2298 2299 /* For abstract classes, the destructor has been removed from the 2300 vtable (in class.c's build_vtbl_initializer). For a compiler- 2301 generated destructor, it hence might not have been generated in 2302 this translation unit - and with '#pragma interface' it might 2303 never get generated. */ 2304 if (CLASSTYPE_PURE_VIRTUALS (ctype) 2305 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) 2306 && !CLASSTYPE_LAZY_DESTRUCTOR (ctype) 2307 && DECL_DEFAULTED_IN_CLASS_P (CLASSTYPE_DESTRUCTOR (ctype))) 2308 note_vague_linkage_fn (CLASSTYPE_DESTRUCTOR (ctype)); 2309 2310 /* Since we're writing out the vtable here, also write the debug 2311 info. */ 2312 note_debug_info_needed (ctype); 2313 2314 return true; 2315 } 2316 2317 /* A special return value from type_visibility meaning internal 2318 linkage. */ 2319 2320 enum { VISIBILITY_ANON = VISIBILITY_INTERNAL+1 }; 2321 2322 static int expr_visibility (tree); 2323 static int type_visibility (tree); 2324 2325 /* walk_tree helper function for type_visibility. */ 2326 2327 static tree 2328 min_vis_r (tree *tp, int *walk_subtrees, void *data) 2329 { 2330 int *vis_p = (int *)data; 2331 if (! TYPE_P (*tp)) 2332 { 2333 *walk_subtrees = 0; 2334 } 2335 else if (OVERLOAD_TYPE_P (*tp) 2336 && !TREE_PUBLIC (TYPE_MAIN_DECL (*tp))) 2337 { 2338 *vis_p = VISIBILITY_ANON; 2339 return *tp; 2340 } 2341 else if (CLASS_TYPE_P (*tp) 2342 && CLASSTYPE_VISIBILITY (*tp) > *vis_p) 2343 *vis_p = CLASSTYPE_VISIBILITY (*tp); 2344 else if (TREE_CODE (*tp) == ARRAY_TYPE 2345 && uses_template_parms (TYPE_DOMAIN (*tp))) 2346 { 2347 int evis = expr_visibility (TYPE_MAX_VALUE (TYPE_DOMAIN (*tp))); 2348 if (evis > *vis_p) 2349 *vis_p = evis; 2350 } 2351 return NULL; 2352 } 2353 2354 /* walk_tree helper function for expr_visibility. */ 2355 2356 static tree 2357 min_vis_expr_r (tree *tp, int */*walk_subtrees*/, void *data) 2358 { 2359 int *vis_p = (int *)data; 2360 int tpvis = VISIBILITY_DEFAULT; 2361 2362 switch (TREE_CODE (*tp)) 2363 { 2364 case CAST_EXPR: 2365 case IMPLICIT_CONV_EXPR: 2366 case STATIC_CAST_EXPR: 2367 case REINTERPRET_CAST_EXPR: 2368 case CONST_CAST_EXPR: 2369 case DYNAMIC_CAST_EXPR: 2370 case NEW_EXPR: 2371 case CONSTRUCTOR: 2372 case LAMBDA_EXPR: 2373 tpvis = type_visibility (TREE_TYPE (*tp)); 2374 break; 2375 2376 case VAR_DECL: 2377 case FUNCTION_DECL: 2378 if (! TREE_PUBLIC (*tp)) 2379 tpvis = VISIBILITY_ANON; 2380 else 2381 tpvis = DECL_VISIBILITY (*tp); 2382 break; 2383 2384 default: 2385 break; 2386 } 2387 2388 if (tpvis > *vis_p) 2389 *vis_p = tpvis; 2390 2391 return NULL_TREE; 2392 } 2393 2394 /* Returns the visibility of TYPE, which is the minimum visibility of its 2395 component types. */ 2396 2397 static int 2398 type_visibility (tree type) 2399 { 2400 int vis = VISIBILITY_DEFAULT; 2401 cp_walk_tree_without_duplicates (&type, min_vis_r, &vis); 2402 return vis; 2403 } 2404 2405 /* Returns the visibility of an expression EXPR that appears in the signature 2406 of a function template, which is the minimum visibility of names that appear 2407 in its mangling. */ 2408 2409 static int 2410 expr_visibility (tree expr) 2411 { 2412 int vis = VISIBILITY_DEFAULT; 2413 cp_walk_tree_without_duplicates (&expr, min_vis_expr_r, &vis); 2414 return vis; 2415 } 2416 2417 /* Limit the visibility of DECL to VISIBILITY, if not explicitly 2418 specified (or if VISIBILITY is static). If TMPL is true, this 2419 constraint is for a template argument, and takes precedence 2420 over explicitly-specified visibility on the template. */ 2421 2422 static void 2423 constrain_visibility (tree decl, int visibility, bool tmpl) 2424 { 2425 if (visibility == VISIBILITY_ANON) 2426 { 2427 /* extern "C" declarations aren't affected by the anonymous 2428 namespace. */ 2429 if (!DECL_EXTERN_C_P (decl)) 2430 { 2431 TREE_PUBLIC (decl) = 0; 2432 DECL_WEAK (decl) = 0; 2433 DECL_COMMON (decl) = 0; 2434 DECL_COMDAT (decl) = false; 2435 if (VAR_OR_FUNCTION_DECL_P (decl)) 2436 { 2437 struct symtab_node *snode = symtab_node::get (decl); 2438 2439 if (snode) 2440 snode->set_comdat_group (NULL); 2441 } 2442 DECL_INTERFACE_KNOWN (decl) = 1; 2443 if (DECL_LANG_SPECIFIC (decl)) 2444 DECL_NOT_REALLY_EXTERN (decl) = 1; 2445 } 2446 } 2447 else if (visibility > DECL_VISIBILITY (decl) 2448 && (tmpl || !DECL_VISIBILITY_SPECIFIED (decl))) 2449 { 2450 DECL_VISIBILITY (decl) = (enum symbol_visibility) visibility; 2451 /* This visibility was not specified. */ 2452 DECL_VISIBILITY_SPECIFIED (decl) = false; 2453 } 2454 } 2455 2456 /* Constrain the visibility of DECL based on the visibility of its template 2457 arguments. */ 2458 2459 static void 2460 constrain_visibility_for_template (tree decl, tree targs) 2461 { 2462 /* If this is a template instantiation, check the innermost 2463 template args for visibility constraints. The outer template 2464 args are covered by the class check. */ 2465 tree args = INNERMOST_TEMPLATE_ARGS (targs); 2466 int i; 2467 for (i = TREE_VEC_LENGTH (args); i > 0; --i) 2468 { 2469 int vis = 0; 2470 2471 tree arg = TREE_VEC_ELT (args, i-1); 2472 if (TYPE_P (arg)) 2473 vis = type_visibility (arg); 2474 else 2475 vis = expr_visibility (arg); 2476 if (vis) 2477 constrain_visibility (decl, vis, true); 2478 } 2479 } 2480 2481 /* Like c_determine_visibility, but with additional C++-specific 2482 behavior. 2483 2484 Function-scope entities can rely on the function's visibility because 2485 it is set in start_preparsed_function. 2486 2487 Class-scope entities cannot rely on the class's visibility until the end 2488 of the enclosing class definition. 2489 2490 Note that because namespaces have multiple independent definitions, 2491 namespace visibility is handled elsewhere using the #pragma visibility 2492 machinery rather than by decorating the namespace declaration. 2493 2494 The goal is for constraints from the type to give a diagnostic, and 2495 other constraints to be applied silently. */ 2496 2497 void 2498 determine_visibility (tree decl) 2499 { 2500 /* Remember that all decls get VISIBILITY_DEFAULT when built. */ 2501 2502 /* Only relevant for names with external linkage. */ 2503 if (!TREE_PUBLIC (decl)) 2504 return; 2505 2506 /* Cloned constructors and destructors get the same visibility as 2507 the underlying function. That should be set up in 2508 maybe_clone_body. */ 2509 gcc_assert (!DECL_CLONED_FUNCTION_P (decl)); 2510 2511 bool orig_visibility_specified = DECL_VISIBILITY_SPECIFIED (decl); 2512 enum symbol_visibility orig_visibility = DECL_VISIBILITY (decl); 2513 2514 /* The decl may be a template instantiation, which could influence 2515 visibilty. */ 2516 tree template_decl = NULL_TREE; 2517 if (TREE_CODE (decl) == TYPE_DECL) 2518 { 2519 if (CLASS_TYPE_P (TREE_TYPE (decl))) 2520 { 2521 if (CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl))) 2522 template_decl = decl; 2523 } 2524 else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl))) 2525 template_decl = decl; 2526 } 2527 else if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl)) 2528 template_decl = decl; 2529 2530 if (TREE_CODE (decl) == TYPE_DECL 2531 && LAMBDA_TYPE_P (TREE_TYPE (decl)) 2532 && CLASSTYPE_LAMBDA_EXPR (TREE_TYPE (decl)) != error_mark_node) 2533 if (tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl))) 2534 { 2535 /* The lambda's visibility is limited by that of its extra 2536 scope. */ 2537 int vis = 0; 2538 if (TYPE_P (extra)) 2539 vis = type_visibility (extra); 2540 else 2541 vis = expr_visibility (extra); 2542 constrain_visibility (decl, vis, false); 2543 } 2544 2545 /* If DECL is a member of a class, visibility specifiers on the 2546 class can influence the visibility of the DECL. */ 2547 tree class_type = NULL_TREE; 2548 if (DECL_CLASS_SCOPE_P (decl)) 2549 class_type = DECL_CONTEXT (decl); 2550 else 2551 { 2552 /* Not a class member. */ 2553 2554 /* Virtual tables have DECL_CONTEXT set to their associated class, 2555 so they are automatically handled above. */ 2556 gcc_assert (!VAR_P (decl) 2557 || !DECL_VTABLE_OR_VTT_P (decl)); 2558 2559 if (DECL_FUNCTION_SCOPE_P (decl) && ! DECL_VISIBILITY_SPECIFIED (decl)) 2560 { 2561 /* Local statics and classes get the visibility of their 2562 containing function by default, except that 2563 -fvisibility-inlines-hidden doesn't affect them. */ 2564 tree fn = DECL_CONTEXT (decl); 2565 if (DECL_VISIBILITY_SPECIFIED (fn)) 2566 { 2567 DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn); 2568 DECL_VISIBILITY_SPECIFIED (decl) = 2569 DECL_VISIBILITY_SPECIFIED (fn); 2570 } 2571 else 2572 { 2573 if (DECL_CLASS_SCOPE_P (fn)) 2574 determine_visibility_from_class (decl, DECL_CONTEXT (fn)); 2575 else if (determine_hidden_inline (fn)) 2576 { 2577 DECL_VISIBILITY (decl) = default_visibility; 2578 DECL_VISIBILITY_SPECIFIED (decl) = 2579 visibility_options.inpragma; 2580 } 2581 else 2582 { 2583 DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn); 2584 DECL_VISIBILITY_SPECIFIED (decl) = 2585 DECL_VISIBILITY_SPECIFIED (fn); 2586 } 2587 } 2588 2589 /* Local classes in templates have CLASSTYPE_USE_TEMPLATE set, 2590 but have no TEMPLATE_INFO, so don't try to check it. */ 2591 template_decl = NULL_TREE; 2592 } 2593 else if (VAR_P (decl) && DECL_TINFO_P (decl) 2594 && flag_visibility_ms_compat) 2595 { 2596 /* Under -fvisibility-ms-compat, types are visible by default, 2597 even though their contents aren't. */ 2598 tree underlying_type = TREE_TYPE (DECL_NAME (decl)); 2599 int underlying_vis = type_visibility (underlying_type); 2600 if (underlying_vis == VISIBILITY_ANON 2601 || (CLASS_TYPE_P (underlying_type) 2602 && CLASSTYPE_VISIBILITY_SPECIFIED (underlying_type))) 2603 constrain_visibility (decl, underlying_vis, false); 2604 else 2605 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT; 2606 } 2607 else if (VAR_P (decl) && DECL_TINFO_P (decl)) 2608 { 2609 /* tinfo visibility is based on the type it's for. */ 2610 constrain_visibility 2611 (decl, type_visibility (TREE_TYPE (DECL_NAME (decl))), false); 2612 2613 /* Give the target a chance to override the visibility associated 2614 with DECL. */ 2615 if (TREE_PUBLIC (decl) 2616 && !DECL_REALLY_EXTERN (decl) 2617 && CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl))) 2618 && !CLASSTYPE_VISIBILITY_SPECIFIED (TREE_TYPE (DECL_NAME (decl)))) 2619 targetm.cxx.determine_class_data_visibility (decl); 2620 } 2621 else if (template_decl) 2622 /* Template instantiations and specializations get visibility based 2623 on their template unless they override it with an attribute. */; 2624 else if (! DECL_VISIBILITY_SPECIFIED (decl)) 2625 { 2626 if (determine_hidden_inline (decl)) 2627 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN; 2628 else 2629 { 2630 /* Set default visibility to whatever the user supplied with 2631 #pragma GCC visibility or a namespace visibility attribute. */ 2632 DECL_VISIBILITY (decl) = default_visibility; 2633 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma; 2634 } 2635 } 2636 } 2637 2638 if (template_decl) 2639 { 2640 /* If the specialization doesn't specify visibility, use the 2641 visibility from the template. */ 2642 tree tinfo = get_template_info (template_decl); 2643 tree args = TI_ARGS (tinfo); 2644 tree attribs = (TREE_CODE (decl) == TYPE_DECL 2645 ? TYPE_ATTRIBUTES (TREE_TYPE (decl)) 2646 : DECL_ATTRIBUTES (decl)); 2647 tree attr = lookup_attribute ("visibility", attribs); 2648 2649 if (args != error_mark_node) 2650 { 2651 tree pattern = DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo)); 2652 2653 if (!DECL_VISIBILITY_SPECIFIED (decl)) 2654 { 2655 if (!attr 2656 && determine_hidden_inline (decl)) 2657 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN; 2658 else 2659 { 2660 DECL_VISIBILITY (decl) = DECL_VISIBILITY (pattern); 2661 DECL_VISIBILITY_SPECIFIED (decl) 2662 = DECL_VISIBILITY_SPECIFIED (pattern); 2663 } 2664 } 2665 2666 if (args 2667 /* Template argument visibility outweighs #pragma or namespace 2668 visibility, but not an explicit attribute. */ 2669 && !attr) 2670 { 2671 int depth = TMPL_ARGS_DEPTH (args); 2672 if (DECL_VISIBILITY_SPECIFIED (decl)) 2673 { 2674 /* A class template member with explicit visibility 2675 overrides the class visibility, so we need to apply 2676 all the levels of template args directly. */ 2677 int i; 2678 for (i = 1; i <= depth; ++i) 2679 { 2680 tree lev = TMPL_ARGS_LEVEL (args, i); 2681 constrain_visibility_for_template (decl, lev); 2682 } 2683 } 2684 else if (PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))) 2685 /* Limit visibility based on its template arguments. */ 2686 constrain_visibility_for_template (decl, args); 2687 } 2688 } 2689 } 2690 2691 if (class_type) 2692 determine_visibility_from_class (decl, class_type); 2693 2694 if (decl_anon_ns_mem_p (decl)) 2695 /* Names in an anonymous namespace get internal linkage. 2696 This might change once we implement export. */ 2697 constrain_visibility (decl, VISIBILITY_ANON, false); 2698 else if (TREE_CODE (decl) != TYPE_DECL) 2699 { 2700 /* Propagate anonymity from type to decl. */ 2701 int tvis = type_visibility (TREE_TYPE (decl)); 2702 if (tvis == VISIBILITY_ANON 2703 || ! DECL_VISIBILITY_SPECIFIED (decl)) 2704 constrain_visibility (decl, tvis, false); 2705 } 2706 else if (no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/true)) 2707 /* DR 757: A type without linkage shall not be used as the type of a 2708 variable or function with linkage, unless 2709 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or 2710 o the variable or function is not used (3.2 [basic.def.odr]) or is 2711 defined in the same translation unit. 2712 2713 Since non-extern "C" decls need to be defined in the same 2714 translation unit, we can make the type internal. */ 2715 constrain_visibility (decl, VISIBILITY_ANON, false); 2716 2717 /* If visibility changed and DECL already has DECL_RTL, ensure 2718 symbol flags are updated. */ 2719 if ((DECL_VISIBILITY (decl) != orig_visibility 2720 || DECL_VISIBILITY_SPECIFIED (decl) != orig_visibility_specified) 2721 && ((VAR_P (decl) && TREE_STATIC (decl)) 2722 || TREE_CODE (decl) == FUNCTION_DECL) 2723 && DECL_RTL_SET_P (decl)) 2724 make_decl_rtl (decl); 2725 } 2726 2727 /* By default, static data members and function members receive 2728 the visibility of their containing class. */ 2729 2730 static void 2731 determine_visibility_from_class (tree decl, tree class_type) 2732 { 2733 if (DECL_VISIBILITY_SPECIFIED (decl)) 2734 return; 2735 2736 if (determine_hidden_inline (decl)) 2737 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN; 2738 else 2739 { 2740 /* Default to the class visibility. */ 2741 DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type); 2742 DECL_VISIBILITY_SPECIFIED (decl) 2743 = CLASSTYPE_VISIBILITY_SPECIFIED (class_type); 2744 } 2745 2746 /* Give the target a chance to override the visibility associated 2747 with DECL. */ 2748 if (VAR_P (decl) 2749 && TREE_PUBLIC (decl) 2750 && (DECL_TINFO_P (decl) || DECL_VTABLE_OR_VTT_P (decl)) 2751 && !DECL_REALLY_EXTERN (decl) 2752 && !CLASSTYPE_VISIBILITY_SPECIFIED (class_type)) 2753 targetm.cxx.determine_class_data_visibility (decl); 2754 } 2755 2756 /* Returns true iff DECL is an inline that should get hidden visibility 2757 because of -fvisibility-inlines-hidden. */ 2758 2759 static bool 2760 determine_hidden_inline (tree decl) 2761 { 2762 return (visibility_options.inlines_hidden 2763 /* Don't do this for inline templates; specializations might not be 2764 inline, and we don't want them to inherit the hidden 2765 visibility. We'll set it here for all inline instantiations. */ 2766 && !processing_template_decl 2767 && TREE_CODE (decl) == FUNCTION_DECL 2768 && DECL_DECLARED_INLINE_P (decl) 2769 && (! DECL_LANG_SPECIFIC (decl) 2770 || ! DECL_EXPLICIT_INSTANTIATION (decl))); 2771 } 2772 2773 /* Constrain the visibility of a class TYPE based on the visibility of its 2774 field types. Warn if any fields require lesser visibility. */ 2775 2776 void 2777 constrain_class_visibility (tree type) 2778 { 2779 tree binfo; 2780 tree t; 2781 int i; 2782 2783 int vis = type_visibility (type); 2784 2785 if (vis == VISIBILITY_ANON 2786 || DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type))) 2787 return; 2788 2789 /* Don't warn about visibility if the class has explicit visibility. */ 2790 if (CLASSTYPE_VISIBILITY_SPECIFIED (type)) 2791 vis = VISIBILITY_INTERNAL; 2792 2793 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t)) 2794 if (TREE_CODE (t) == FIELD_DECL && TREE_TYPE (t) != error_mark_node 2795 && !DECL_ARTIFICIAL (t)) 2796 { 2797 tree ftype = strip_pointer_or_array_types (TREE_TYPE (t)); 2798 int subvis = type_visibility (ftype); 2799 2800 if (subvis == VISIBILITY_ANON) 2801 { 2802 if (!in_main_input_context()) 2803 { 2804 tree nlt = no_linkage_check (ftype, /*relaxed_p=*/false); 2805 if (nlt) 2806 { 2807 if (same_type_p (TREE_TYPE (t), nlt)) 2808 warning (OPT_Wsubobject_linkage, "\ 2809 %qT has a field %qD whose type has no linkage", 2810 type, t); 2811 else 2812 warning (OPT_Wsubobject_linkage, "\ 2813 %qT has a field %qD whose type depends on the type %qT which has no linkage", 2814 type, t, nlt); 2815 } 2816 else 2817 warning (OPT_Wsubobject_linkage, "\ 2818 %qT has a field %qD whose type uses the anonymous namespace", 2819 type, t); 2820 } 2821 } 2822 else if (MAYBE_CLASS_TYPE_P (ftype) 2823 && vis < VISIBILITY_HIDDEN 2824 && subvis >= VISIBILITY_HIDDEN) 2825 warning (OPT_Wattributes, "\ 2826 %qT declared with greater visibility than the type of its field %qD", 2827 type, t); 2828 } 2829 2830 binfo = TYPE_BINFO (type); 2831 for (i = 0; BINFO_BASE_ITERATE (binfo, i, t); ++i) 2832 { 2833 int subvis = type_visibility (TREE_TYPE (t)); 2834 2835 if (subvis == VISIBILITY_ANON) 2836 { 2837 if (!in_main_input_context()) 2838 { 2839 tree nlt = no_linkage_check (TREE_TYPE (t), /*relaxed_p=*/false); 2840 if (nlt) 2841 { 2842 if (same_type_p (TREE_TYPE (t), nlt)) 2843 warning (OPT_Wsubobject_linkage, "\ 2844 %qT has a base %qT whose type has no linkage", 2845 type, TREE_TYPE (t)); 2846 else 2847 warning (OPT_Wsubobject_linkage, "\ 2848 %qT has a base %qT whose type depends on the type %qT which has no linkage", 2849 type, TREE_TYPE (t), nlt); 2850 } 2851 else 2852 warning (OPT_Wsubobject_linkage, "\ 2853 %qT has a base %qT whose type uses the anonymous namespace", 2854 type, TREE_TYPE (t)); 2855 } 2856 } 2857 else if (vis < VISIBILITY_HIDDEN 2858 && subvis >= VISIBILITY_HIDDEN) 2859 warning (OPT_Wattributes, "\ 2860 %qT declared with greater visibility than its base %qT", 2861 type, TREE_TYPE (t)); 2862 } 2863 } 2864 2865 /* Functions for adjusting the visibility of a tagged type and its nested 2866 types and declarations when it gets a name for linkage purposes from a 2867 typedef. */ 2868 2869 static void bt_reset_linkage_1 (binding_entry, void *); 2870 static void bt_reset_linkage_2 (binding_entry, void *); 2871 2872 /* First reset the visibility of all the types. */ 2873 2874 static void 2875 reset_type_linkage_1 (tree type) 2876 { 2877 set_linkage_according_to_type (type, TYPE_MAIN_DECL (type)); 2878 if (CLASS_TYPE_P (type)) 2879 binding_table_foreach (CLASSTYPE_NESTED_UTDS (type), 2880 bt_reset_linkage_1, NULL); 2881 } 2882 static void 2883 bt_reset_linkage_1 (binding_entry b, void */*data*/) 2884 { 2885 reset_type_linkage_1 (b->type); 2886 } 2887 2888 /* Then reset the visibility of any static data members or member 2889 functions that use those types. */ 2890 2891 static void 2892 reset_decl_linkage (tree decl) 2893 { 2894 if (TREE_PUBLIC (decl)) 2895 return; 2896 if (DECL_CLONED_FUNCTION_P (decl)) 2897 return; 2898 TREE_PUBLIC (decl) = true; 2899 DECL_INTERFACE_KNOWN (decl) = false; 2900 determine_visibility (decl); 2901 tentative_decl_linkage (decl); 2902 } 2903 2904 static void 2905 reset_type_linkage_2 (tree type) 2906 { 2907 if (CLASS_TYPE_P (type)) 2908 { 2909 if (tree vt = CLASSTYPE_VTABLES (type)) 2910 { 2911 tree name = mangle_vtbl_for_type (type); 2912 DECL_NAME (vt) = name; 2913 SET_DECL_ASSEMBLER_NAME (vt, name); 2914 reset_decl_linkage (vt); 2915 } 2916 if (tree ti = CLASSTYPE_TYPEINFO_VAR (type)) 2917 { 2918 tree name = mangle_typeinfo_for_type (type); 2919 DECL_NAME (ti) = name; 2920 SET_DECL_ASSEMBLER_NAME (ti, name); 2921 TREE_TYPE (name) = type; 2922 reset_decl_linkage (ti); 2923 } 2924 for (tree m = TYPE_FIELDS (type); m; m = DECL_CHAIN (m)) 2925 { 2926 tree mem = STRIP_TEMPLATE (m); 2927 if (TREE_CODE (mem) == VAR_DECL || TREE_CODE (mem) == FUNCTION_DECL) 2928 reset_decl_linkage (mem); 2929 } 2930 binding_table_foreach (CLASSTYPE_NESTED_UTDS (type), 2931 bt_reset_linkage_2, NULL); 2932 } 2933 } 2934 2935 static void 2936 bt_reset_linkage_2 (binding_entry b, void */*data*/) 2937 { 2938 reset_type_linkage_2 (b->type); 2939 } 2940 void 2941 reset_type_linkage (tree type) 2942 { 2943 reset_type_linkage_1 (type); 2944 reset_type_linkage_2 (type); 2945 } 2946 2947 /* Set up our initial idea of what the linkage of DECL should be. */ 2948 2949 void 2950 tentative_decl_linkage (tree decl) 2951 { 2952 if (DECL_INTERFACE_KNOWN (decl)) 2953 /* We've already made a decision as to how this function will 2954 be handled. */; 2955 else if (vague_linkage_p (decl)) 2956 { 2957 if (TREE_CODE (decl) == FUNCTION_DECL 2958 && decl_defined_p (decl)) 2959 { 2960 DECL_EXTERNAL (decl) = 1; 2961 DECL_NOT_REALLY_EXTERN (decl) = 1; 2962 note_vague_linkage_fn (decl); 2963 /* A non-template inline function with external linkage will 2964 always be COMDAT. As we must eventually determine the 2965 linkage of all functions, and as that causes writes to 2966 the data mapped in from the PCH file, it's advantageous 2967 to mark the functions at this point. */ 2968 if (DECL_DECLARED_INLINE_P (decl) 2969 && (!DECL_IMPLICIT_INSTANTIATION (decl) 2970 || DECL_DEFAULTED_FN (decl))) 2971 { 2972 /* This function must have external linkage, as 2973 otherwise DECL_INTERFACE_KNOWN would have been 2974 set. */ 2975 gcc_assert (TREE_PUBLIC (decl)); 2976 comdat_linkage (decl); 2977 DECL_INTERFACE_KNOWN (decl) = 1; 2978 } 2979 } 2980 else if (VAR_P (decl)) 2981 maybe_commonize_var (decl); 2982 } 2983 } 2984 2985 /* DECL is a FUNCTION_DECL or VAR_DECL. If the object file linkage 2986 for DECL has not already been determined, do so now by setting 2987 DECL_EXTERNAL, DECL_COMDAT and other related flags. Until this 2988 function is called entities with vague linkage whose definitions 2989 are available must have TREE_PUBLIC set. 2990 2991 If this function decides to place DECL in COMDAT, it will set 2992 appropriate flags -- but will not clear DECL_EXTERNAL. It is up to 2993 the caller to decide whether or not to clear DECL_EXTERNAL. Some 2994 callers defer that decision until it is clear that DECL is actually 2995 required. */ 2996 2997 void 2998 import_export_decl (tree decl) 2999 { 3000 bool comdat_p; 3001 bool import_p; 3002 tree class_type = NULL_TREE; 3003 3004 if (DECL_INTERFACE_KNOWN (decl)) 3005 return; 3006 3007 /* We cannot determine what linkage to give to an entity with vague 3008 linkage until the end of the file. For example, a virtual table 3009 for a class will be defined if and only if the key method is 3010 defined in this translation unit. */ 3011 gcc_assert (at_eof); 3012 /* Object file linkage for explicit instantiations is handled in 3013 mark_decl_instantiated. For static variables in functions with 3014 vague linkage, maybe_commonize_var is used. 3015 3016 Therefore, the only declarations that should be provided to this 3017 function are those with external linkage that are: 3018 3019 * implicit instantiations of function templates 3020 3021 * inline function 3022 3023 * implicit instantiations of static data members of class 3024 templates 3025 3026 * virtual tables 3027 3028 * typeinfo objects 3029 3030 Furthermore, all entities that reach this point must have a 3031 definition available in this translation unit. 3032 3033 The following assertions check these conditions. */ 3034 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl)); 3035 /* Any code that creates entities with TREE_PUBLIC cleared should 3036 also set DECL_INTERFACE_KNOWN. */ 3037 gcc_assert (TREE_PUBLIC (decl)); 3038 if (TREE_CODE (decl) == FUNCTION_DECL) 3039 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl) 3040 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl) 3041 || DECL_DECLARED_INLINE_P (decl)); 3042 else 3043 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl) 3044 || DECL_VTABLE_OR_VTT_P (decl) 3045 || DECL_TINFO_P (decl)); 3046 /* Check that a definition of DECL is available in this translation 3047 unit. */ 3048 gcc_assert (!DECL_REALLY_EXTERN (decl)); 3049 3050 /* Assume that DECL will not have COMDAT linkage. */ 3051 comdat_p = false; 3052 /* Assume that DECL will not be imported into this translation 3053 unit. */ 3054 import_p = false; 3055 3056 if (VAR_P (decl) && DECL_VTABLE_OR_VTT_P (decl)) 3057 { 3058 class_type = DECL_CONTEXT (decl); 3059 import_export_class (class_type); 3060 if (CLASSTYPE_INTERFACE_KNOWN (class_type) 3061 && CLASSTYPE_INTERFACE_ONLY (class_type)) 3062 import_p = true; 3063 else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC) 3064 && !CLASSTYPE_USE_TEMPLATE (class_type) 3065 && CLASSTYPE_KEY_METHOD (class_type) 3066 && !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type))) 3067 /* The ABI requires that all virtual tables be emitted with 3068 COMDAT linkage. However, on systems where COMDAT symbols 3069 don't show up in the table of contents for a static 3070 archive, or on systems without weak symbols (where we 3071 approximate COMDAT linkage by using internal linkage), the 3072 linker will report errors about undefined symbols because 3073 it will not see the virtual table definition. Therefore, 3074 in the case that we know that the virtual table will be 3075 emitted in only one translation unit, we make the virtual 3076 table an ordinary definition with external linkage. */ 3077 DECL_EXTERNAL (decl) = 0; 3078 else if (CLASSTYPE_INTERFACE_KNOWN (class_type)) 3079 { 3080 /* CLASS_TYPE is being exported from this translation unit, 3081 so DECL should be defined here. */ 3082 if (!flag_weak && CLASSTYPE_EXPLICIT_INSTANTIATION (class_type)) 3083 /* If a class is declared in a header with the "extern 3084 template" extension, then it will not be instantiated, 3085 even in translation units that would normally require 3086 it. Often such classes are explicitly instantiated in 3087 one translation unit. Therefore, the explicit 3088 instantiation must be made visible to other translation 3089 units. */ 3090 DECL_EXTERNAL (decl) = 0; 3091 else 3092 { 3093 /* The generic C++ ABI says that class data is always 3094 COMDAT, even if there is a key function. Some 3095 variants (e.g., the ARM EABI) says that class data 3096 only has COMDAT linkage if the class data might be 3097 emitted in more than one translation unit. When the 3098 key method can be inline and is inline, we still have 3099 to arrange for comdat even though 3100 class_data_always_comdat is false. */ 3101 if (!CLASSTYPE_KEY_METHOD (class_type) 3102 || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type)) 3103 || targetm.cxx.class_data_always_comdat ()) 3104 { 3105 /* The ABI requires COMDAT linkage. Normally, we 3106 only emit COMDAT things when they are needed; 3107 make sure that we realize that this entity is 3108 indeed needed. */ 3109 comdat_p = true; 3110 mark_needed (decl); 3111 } 3112 } 3113 } 3114 else if (!flag_implicit_templates 3115 && CLASSTYPE_IMPLICIT_INSTANTIATION (class_type)) 3116 import_p = true; 3117 else 3118 comdat_p = true; 3119 } 3120 else if (VAR_P (decl) && DECL_TINFO_P (decl)) 3121 { 3122 tree type = TREE_TYPE (DECL_NAME (decl)); 3123 if (CLASS_TYPE_P (type)) 3124 { 3125 class_type = type; 3126 import_export_class (type); 3127 if (CLASSTYPE_INTERFACE_KNOWN (type) 3128 && TYPE_POLYMORPHIC_P (type) 3129 && CLASSTYPE_INTERFACE_ONLY (type) 3130 /* If -fno-rtti was specified, then we cannot be sure 3131 that RTTI information will be emitted with the 3132 virtual table of the class, so we must emit it 3133 wherever it is used. */ 3134 && flag_rtti) 3135 import_p = true; 3136 else 3137 { 3138 if (CLASSTYPE_INTERFACE_KNOWN (type) 3139 && !CLASSTYPE_INTERFACE_ONLY (type)) 3140 { 3141 comdat_p = (targetm.cxx.class_data_always_comdat () 3142 || (CLASSTYPE_KEY_METHOD (type) 3143 && DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type)))); 3144 mark_needed (decl); 3145 if (!flag_weak) 3146 { 3147 comdat_p = false; 3148 DECL_EXTERNAL (decl) = 0; 3149 } 3150 } 3151 else 3152 comdat_p = true; 3153 } 3154 } 3155 else 3156 comdat_p = true; 3157 } 3158 else if (DECL_TEMPLOID_INSTANTIATION (decl)) 3159 { 3160 /* DECL is an implicit instantiation of a function or static 3161 data member. */ 3162 if (flag_implicit_templates 3163 || (flag_implicit_inline_templates 3164 && TREE_CODE (decl) == FUNCTION_DECL 3165 && DECL_DECLARED_INLINE_P (decl))) 3166 comdat_p = true; 3167 else 3168 /* If we are not implicitly generating templates, then mark 3169 this entity as undefined in this translation unit. */ 3170 import_p = true; 3171 } 3172 else if (DECL_FUNCTION_MEMBER_P (decl)) 3173 { 3174 if (!DECL_DECLARED_INLINE_P (decl)) 3175 { 3176 tree ctype = DECL_CONTEXT (decl); 3177 import_export_class (ctype); 3178 if (CLASSTYPE_INTERFACE_KNOWN (ctype)) 3179 { 3180 DECL_NOT_REALLY_EXTERN (decl) 3181 = ! (CLASSTYPE_INTERFACE_ONLY (ctype) 3182 || (DECL_DECLARED_INLINE_P (decl) 3183 && ! flag_implement_inlines 3184 && !DECL_VINDEX (decl))); 3185 3186 if (!DECL_NOT_REALLY_EXTERN (decl)) 3187 DECL_EXTERNAL (decl) = 1; 3188 3189 /* Always make artificials weak. */ 3190 if (DECL_ARTIFICIAL (decl) && flag_weak) 3191 comdat_p = true; 3192 else 3193 maybe_make_one_only (decl); 3194 } 3195 } 3196 else 3197 comdat_p = true; 3198 } 3199 else 3200 comdat_p = true; 3201 3202 if (import_p) 3203 { 3204 /* If we are importing DECL into this translation unit, mark is 3205 an undefined here. */ 3206 DECL_EXTERNAL (decl) = 1; 3207 DECL_NOT_REALLY_EXTERN (decl) = 0; 3208 } 3209 else if (comdat_p) 3210 { 3211 /* If we decided to put DECL in COMDAT, mark it accordingly at 3212 this point. */ 3213 comdat_linkage (decl); 3214 } 3215 3216 DECL_INTERFACE_KNOWN (decl) = 1; 3217 } 3218 3219 /* Return an expression that performs the destruction of DECL, which 3220 must be a VAR_DECL whose type has a non-trivial destructor, or is 3221 an array whose (innermost) elements have a non-trivial destructor. */ 3222 3223 tree 3224 build_cleanup (tree decl) 3225 { 3226 tree clean = cxx_maybe_build_cleanup (decl, tf_warning_or_error); 3227 gcc_assert (clean != NULL_TREE); 3228 return clean; 3229 } 3230 3231 /* GUARD is a helper variable for DECL; make them have the same linkage and 3232 visibility. */ 3233 3234 void 3235 copy_linkage (tree guard, tree decl) 3236 { 3237 TREE_PUBLIC (guard) = TREE_PUBLIC (decl); 3238 TREE_STATIC (guard) = TREE_STATIC (decl); 3239 DECL_COMMON (guard) = DECL_COMMON (decl); 3240 DECL_COMDAT (guard) = DECL_COMDAT (decl); 3241 if (TREE_STATIC (guard)) 3242 { 3243 CP_DECL_THREAD_LOCAL_P (guard) = CP_DECL_THREAD_LOCAL_P (decl); 3244 set_decl_tls_model (guard, DECL_TLS_MODEL (decl)); 3245 if (DECL_ONE_ONLY (decl)) 3246 make_decl_one_only (guard, cxx_comdat_group (guard)); 3247 if (TREE_PUBLIC (decl)) 3248 DECL_WEAK (guard) = DECL_WEAK (decl); 3249 /* Also check vague_linkage_p, as DECL_WEAK and DECL_ONE_ONLY might not 3250 be set until import_export_decl at EOF. */ 3251 if (vague_linkage_p (decl)) 3252 comdat_linkage (guard); 3253 DECL_VISIBILITY (guard) = DECL_VISIBILITY (decl); 3254 DECL_VISIBILITY_SPECIFIED (guard) = DECL_VISIBILITY_SPECIFIED (decl); 3255 } 3256 } 3257 3258 /* Returns the initialization guard variable for the variable DECL, 3259 which has static storage duration. */ 3260 3261 tree 3262 get_guard (tree decl) 3263 { 3264 tree sname; 3265 tree guard; 3266 3267 sname = mangle_guard_variable (decl); 3268 guard = get_global_binding (sname); 3269 if (! guard) 3270 { 3271 tree guard_type; 3272 3273 /* We use a type that is big enough to contain a mutex as well 3274 as an integer counter. */ 3275 guard_type = targetm.cxx.guard_type (); 3276 guard = build_decl (DECL_SOURCE_LOCATION (decl), 3277 VAR_DECL, sname, guard_type); 3278 3279 /* The guard should have the same linkage as what it guards. */ 3280 copy_linkage (guard, decl); 3281 3282 DECL_ARTIFICIAL (guard) = 1; 3283 DECL_IGNORED_P (guard) = 1; 3284 TREE_USED (guard) = 1; 3285 pushdecl_top_level_and_finish (guard, NULL_TREE); 3286 } 3287 return guard; 3288 } 3289 3290 /* Return an atomic load of src with the appropriate memory model. */ 3291 3292 static tree 3293 build_atomic_load_byte (tree src, HOST_WIDE_INT model) 3294 { 3295 tree ptr_type = build_pointer_type (char_type_node); 3296 tree mem_model = build_int_cst (integer_type_node, model); 3297 tree t, addr, val; 3298 unsigned int size; 3299 int fncode; 3300 3301 size = tree_to_uhwi (TYPE_SIZE_UNIT (char_type_node)); 3302 3303 fncode = BUILT_IN_ATOMIC_LOAD_N + exact_log2 (size) + 1; 3304 t = builtin_decl_implicit ((enum built_in_function) fncode); 3305 3306 addr = build1 (ADDR_EXPR, ptr_type, src); 3307 val = build_call_expr (t, 2, addr, mem_model); 3308 return val; 3309 } 3310 3311 /* Return those bits of the GUARD variable that should be set when the 3312 guarded entity is actually initialized. */ 3313 3314 static tree 3315 get_guard_bits (tree guard) 3316 { 3317 if (!targetm.cxx.guard_mask_bit ()) 3318 { 3319 /* We only set the first byte of the guard, in order to leave room 3320 for a mutex in the high-order bits. */ 3321 guard = build1 (ADDR_EXPR, 3322 build_pointer_type (TREE_TYPE (guard)), 3323 guard); 3324 guard = build1 (NOP_EXPR, 3325 build_pointer_type (char_type_node), 3326 guard); 3327 guard = build1 (INDIRECT_REF, char_type_node, guard); 3328 } 3329 3330 return guard; 3331 } 3332 3333 /* Return an expression which determines whether or not the GUARD 3334 variable has already been initialized. */ 3335 3336 tree 3337 get_guard_cond (tree guard, bool thread_safe) 3338 { 3339 tree guard_value; 3340 3341 if (!thread_safe) 3342 guard = get_guard_bits (guard); 3343 else 3344 guard = build_atomic_load_byte (guard, MEMMODEL_ACQUIRE); 3345 3346 /* Mask off all but the low bit. */ 3347 if (targetm.cxx.guard_mask_bit ()) 3348 { 3349 guard_value = integer_one_node; 3350 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard))) 3351 guard_value = fold_convert (TREE_TYPE (guard), guard_value); 3352 guard = cp_build_binary_op (input_location, 3353 BIT_AND_EXPR, guard, guard_value, 3354 tf_warning_or_error); 3355 } 3356 3357 guard_value = integer_zero_node; 3358 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard))) 3359 guard_value = fold_convert (TREE_TYPE (guard), guard_value); 3360 return cp_build_binary_op (input_location, 3361 EQ_EXPR, guard, guard_value, 3362 tf_warning_or_error); 3363 } 3364 3365 /* Return an expression which sets the GUARD variable, indicating that 3366 the variable being guarded has been initialized. */ 3367 3368 tree 3369 set_guard (tree guard) 3370 { 3371 tree guard_init; 3372 3373 /* Set the GUARD to one. */ 3374 guard = get_guard_bits (guard); 3375 guard_init = integer_one_node; 3376 if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard))) 3377 guard_init = fold_convert (TREE_TYPE (guard), guard_init); 3378 return cp_build_modify_expr (input_location, guard, NOP_EXPR, guard_init, 3379 tf_warning_or_error); 3380 } 3381 3382 /* Returns true iff we can tell that VAR does not have a dynamic 3383 initializer. */ 3384 3385 static bool 3386 var_defined_without_dynamic_init (tree var) 3387 { 3388 /* If it's defined in another TU, we can't tell. */ 3389 if (DECL_EXTERNAL (var)) 3390 return false; 3391 /* If it has a non-trivial destructor, registering the destructor 3392 counts as dynamic initialization. */ 3393 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (var))) 3394 return false; 3395 /* If it's in this TU, its initializer has been processed, unless 3396 it's a case of self-initialization, then DECL_INITIALIZED_P is 3397 false while the initializer is handled by finish_id_expression. */ 3398 if (!DECL_INITIALIZED_P (var)) 3399 return false; 3400 /* If it has no initializer or a constant one, it's not dynamic. */ 3401 return (!DECL_NONTRIVIALLY_INITIALIZED_P (var) 3402 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var)); 3403 } 3404 3405 /* Returns true iff VAR is a variable that needs uses to be 3406 wrapped for possible dynamic initialization. */ 3407 3408 bool 3409 var_needs_tls_wrapper (tree var) 3410 { 3411 return (!error_operand_p (var) 3412 && CP_DECL_THREAD_LOCAL_P (var) 3413 && !DECL_GNU_TLS_P (var) 3414 && !DECL_FUNCTION_SCOPE_P (var) 3415 && !var_defined_without_dynamic_init (var)); 3416 } 3417 3418 /* Get the FUNCTION_DECL for the shared TLS init function for this 3419 translation unit. */ 3420 3421 static tree 3422 get_local_tls_init_fn (location_t loc) 3423 { 3424 tree sname = get_identifier ("__tls_init"); 3425 tree fn = get_global_binding (sname); 3426 if (!fn) 3427 { 3428 fn = build_lang_decl_loc (loc, FUNCTION_DECL, sname, 3429 build_function_type (void_type_node, 3430 void_list_node)); 3431 SET_DECL_LANGUAGE (fn, lang_c); 3432 TREE_PUBLIC (fn) = false; 3433 DECL_ARTIFICIAL (fn) = true; 3434 mark_used (fn); 3435 set_global_binding (fn); 3436 } 3437 return fn; 3438 } 3439 3440 /* Get a FUNCTION_DECL for the init function for the thread_local 3441 variable VAR. The init function will be an alias to the function 3442 that initializes all the non-local TLS variables in the translation 3443 unit. The init function is only used by the wrapper function. */ 3444 3445 static tree 3446 get_tls_init_fn (tree var) 3447 { 3448 /* Only C++11 TLS vars need this init fn. */ 3449 if (!var_needs_tls_wrapper (var)) 3450 return NULL_TREE; 3451 3452 /* If -fno-extern-tls-init, assume that we don't need to call 3453 a tls init function for a variable defined in another TU. */ 3454 if (!flag_extern_tls_init && DECL_EXTERNAL (var)) 3455 return NULL_TREE; 3456 3457 /* If the variable is internal, or if we can't generate aliases, 3458 call the local init function directly. */ 3459 if (!TREE_PUBLIC (var) || !TARGET_SUPPORTS_ALIASES) 3460 return get_local_tls_init_fn (DECL_SOURCE_LOCATION (var)); 3461 3462 tree sname = mangle_tls_init_fn (var); 3463 tree fn = get_global_binding (sname); 3464 if (!fn) 3465 { 3466 fn = build_lang_decl (FUNCTION_DECL, sname, 3467 build_function_type (void_type_node, 3468 void_list_node)); 3469 SET_DECL_LANGUAGE (fn, lang_c); 3470 TREE_PUBLIC (fn) = TREE_PUBLIC (var); 3471 DECL_ARTIFICIAL (fn) = true; 3472 DECL_COMDAT (fn) = DECL_COMDAT (var); 3473 DECL_EXTERNAL (fn) = DECL_EXTERNAL (var); 3474 if (DECL_ONE_ONLY (var)) 3475 make_decl_one_only (fn, cxx_comdat_group (fn)); 3476 if (TREE_PUBLIC (var)) 3477 { 3478 tree obtype = strip_array_types (non_reference (TREE_TYPE (var))); 3479 /* If the variable is defined somewhere else and might have static 3480 initialization, make the init function a weak reference. */ 3481 if ((!TYPE_NEEDS_CONSTRUCTING (obtype) 3482 || TYPE_HAS_CONSTEXPR_CTOR (obtype) 3483 || TYPE_HAS_TRIVIAL_DFLT (obtype)) 3484 && TYPE_HAS_TRIVIAL_DESTRUCTOR (obtype) 3485 && DECL_EXTERNAL (var)) 3486 declare_weak (fn); 3487 else 3488 DECL_WEAK (fn) = DECL_WEAK (var); 3489 } 3490 DECL_VISIBILITY (fn) = DECL_VISIBILITY (var); 3491 DECL_VISIBILITY_SPECIFIED (fn) = DECL_VISIBILITY_SPECIFIED (var); 3492 DECL_DLLIMPORT_P (fn) = DECL_DLLIMPORT_P (var); 3493 DECL_IGNORED_P (fn) = 1; 3494 mark_used (fn); 3495 3496 DECL_BEFRIENDING_CLASSES (fn) = var; 3497 3498 set_global_binding (fn); 3499 } 3500 return fn; 3501 } 3502 3503 /* Get a FUNCTION_DECL for the init wrapper function for the thread_local 3504 variable VAR. The wrapper function calls the init function (if any) for 3505 VAR and then returns a reference to VAR. The wrapper function is used 3506 in place of VAR everywhere VAR is mentioned. */ 3507 3508 static tree 3509 get_tls_wrapper_fn (tree var) 3510 { 3511 /* Only C++11 TLS vars need this wrapper fn. */ 3512 if (!var_needs_tls_wrapper (var)) 3513 return NULL_TREE; 3514 3515 tree sname = mangle_tls_wrapper_fn (var); 3516 tree fn = get_global_binding (sname); 3517 if (!fn) 3518 { 3519 /* A named rvalue reference is an lvalue, so the wrapper should 3520 always return an lvalue reference. */ 3521 tree type = non_reference (TREE_TYPE (var)); 3522 type = build_reference_type (type); 3523 tree fntype = build_function_type (type, void_list_node); 3524 3525 fn = build_lang_decl_loc (DECL_SOURCE_LOCATION (var), 3526 FUNCTION_DECL, sname, fntype); 3527 SET_DECL_LANGUAGE (fn, lang_c); 3528 TREE_PUBLIC (fn) = TREE_PUBLIC (var); 3529 DECL_ARTIFICIAL (fn) = true; 3530 DECL_IGNORED_P (fn) = 1; 3531 /* The wrapper is inline and emitted everywhere var is used. */ 3532 DECL_DECLARED_INLINE_P (fn) = true; 3533 if (TREE_PUBLIC (var)) 3534 { 3535 comdat_linkage (fn); 3536 #ifdef HAVE_GAS_HIDDEN 3537 /* Make the wrapper bind locally; there's no reason to share 3538 the wrapper between multiple shared objects. */ 3539 DECL_VISIBILITY (fn) = VISIBILITY_INTERNAL; 3540 DECL_VISIBILITY_SPECIFIED (fn) = true; 3541 #endif 3542 } 3543 if (!TREE_PUBLIC (fn)) 3544 DECL_INTERFACE_KNOWN (fn) = true; 3545 mark_used (fn); 3546 note_vague_linkage_fn (fn); 3547 3548 #if 0 3549 /* We want CSE to commonize calls to the wrapper, but marking it as 3550 pure is unsafe since it has side-effects. I guess we need a new 3551 ECF flag even weaker than ECF_PURE. FIXME! */ 3552 DECL_PURE_P (fn) = true; 3553 #endif 3554 3555 DECL_BEFRIENDING_CLASSES (fn) = var; 3556 3557 set_global_binding (fn); 3558 } 3559 return fn; 3560 } 3561 3562 /* If EXPR is a thread_local variable that should be wrapped by init 3563 wrapper function, return a call to that function, otherwise return 3564 NULL. */ 3565 3566 tree 3567 maybe_get_tls_wrapper_call (tree expr) 3568 { 3569 if (VAR_P (expr) 3570 && !processing_template_decl 3571 && !cp_unevaluated_operand 3572 && CP_DECL_THREAD_LOCAL_P (expr)) 3573 if (tree wrap = get_tls_wrapper_fn (expr)) 3574 return build_cxx_call (wrap, 0, NULL, tf_warning_or_error); 3575 return NULL; 3576 } 3577 3578 /* At EOF, generate the definition for the TLS wrapper function FN: 3579 3580 T& var_wrapper() { 3581 if (init_fn) init_fn(); 3582 return var; 3583 } */ 3584 3585 static void 3586 generate_tls_wrapper (tree fn) 3587 { 3588 tree var = DECL_BEFRIENDING_CLASSES (fn); 3589 3590 start_preparsed_function (fn, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED); 3591 tree body = begin_function_body (); 3592 /* Only call the init fn if there might be one. */ 3593 if (tree init_fn = get_tls_init_fn (var)) 3594 { 3595 tree if_stmt = NULL_TREE; 3596 /* If init_fn is a weakref, make sure it exists before calling. */ 3597 if (lookup_attribute ("weak", DECL_ATTRIBUTES (init_fn))) 3598 { 3599 if_stmt = begin_if_stmt (); 3600 tree addr = cp_build_addr_expr (init_fn, tf_warning_or_error); 3601 tree cond = cp_build_binary_op (DECL_SOURCE_LOCATION (var), 3602 NE_EXPR, addr, nullptr_node, 3603 tf_warning_or_error); 3604 finish_if_stmt_cond (cond, if_stmt); 3605 } 3606 finish_expr_stmt (build_cxx_call 3607 (init_fn, 0, NULL, tf_warning_or_error)); 3608 if (if_stmt) 3609 { 3610 finish_then_clause (if_stmt); 3611 finish_if_stmt (if_stmt); 3612 } 3613 } 3614 else 3615 /* If there's no initialization, the wrapper is a constant function. */ 3616 TREE_READONLY (fn) = true; 3617 finish_return_stmt (convert_from_reference (var)); 3618 finish_function_body (body); 3619 expand_or_defer_fn (finish_function (/*inline_p=*/false)); 3620 } 3621 3622 /* Start the process of running a particular set of global constructors 3623 or destructors. Subroutine of do_[cd]tors. Also called from 3624 vtv_start_verification_constructor_init_function. */ 3625 3626 static tree 3627 start_objects (int method_type, int initp) 3628 { 3629 tree body; 3630 tree fndecl; 3631 char type[14]; 3632 3633 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */ 3634 3635 if (initp != DEFAULT_INIT_PRIORITY) 3636 { 3637 char joiner; 3638 3639 #ifdef JOINER 3640 joiner = JOINER; 3641 #else 3642 joiner = '_'; 3643 #endif 3644 3645 sprintf (type, "sub_%c%c%.5u", method_type, joiner, initp); 3646 } 3647 else 3648 sprintf (type, "sub_%c", method_type); 3649 3650 fndecl = build_lang_decl (FUNCTION_DECL, 3651 get_file_function_name (type), 3652 build_function_type_list (void_type_node, 3653 NULL_TREE)); 3654 start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED); 3655 3656 TREE_PUBLIC (current_function_decl) = 0; 3657 3658 /* Mark as artificial because it's not explicitly in the user's 3659 source code. */ 3660 DECL_ARTIFICIAL (current_function_decl) = 1; 3661 3662 /* Mark this declaration as used to avoid spurious warnings. */ 3663 TREE_USED (current_function_decl) = 1; 3664 3665 /* Mark this function as a global constructor or destructor. */ 3666 if (method_type == 'I') 3667 DECL_GLOBAL_CTOR_P (current_function_decl) = 1; 3668 else 3669 DECL_GLOBAL_DTOR_P (current_function_decl) = 1; 3670 3671 body = begin_compound_stmt (BCS_FN_BODY); 3672 3673 return body; 3674 } 3675 3676 /* Finish the process of running a particular set of global constructors 3677 or destructors. Subroutine of do_[cd]tors. */ 3678 3679 static void 3680 finish_objects (int method_type, int initp, tree body) 3681 { 3682 tree fn; 3683 3684 /* Finish up. */ 3685 finish_compound_stmt (body); 3686 fn = finish_function (/*inline_p=*/false); 3687 3688 if (method_type == 'I') 3689 { 3690 DECL_STATIC_CONSTRUCTOR (fn) = 1; 3691 decl_init_priority_insert (fn, initp); 3692 } 3693 else 3694 { 3695 DECL_STATIC_DESTRUCTOR (fn) = 1; 3696 decl_fini_priority_insert (fn, initp); 3697 } 3698 3699 expand_or_defer_fn (fn); 3700 } 3701 3702 /* The names of the parameters to the function created to handle 3703 initializations and destructions for objects with static storage 3704 duration. */ 3705 #define INITIALIZE_P_IDENTIFIER "__initialize_p" 3706 #define PRIORITY_IDENTIFIER "__priority" 3707 3708 /* The name of the function we create to handle initializations and 3709 destructions for objects with static storage duration. */ 3710 #define SSDF_IDENTIFIER "__static_initialization_and_destruction" 3711 3712 /* The declaration for the __INITIALIZE_P argument. */ 3713 static GTY(()) tree initialize_p_decl; 3714 3715 /* The declaration for the __PRIORITY argument. */ 3716 static GTY(()) tree priority_decl; 3717 3718 /* The declaration for the static storage duration function. */ 3719 static GTY(()) tree ssdf_decl; 3720 3721 /* All the static storage duration functions created in this 3722 translation unit. */ 3723 static GTY(()) vec<tree, va_gc> *ssdf_decls; 3724 3725 /* A map from priority levels to information about that priority 3726 level. There may be many such levels, so efficient lookup is 3727 important. */ 3728 static splay_tree priority_info_map; 3729 3730 /* Begins the generation of the function that will handle all 3731 initialization and destruction of objects with static storage 3732 duration. The function generated takes two parameters of type 3733 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is 3734 nonzero, it performs initializations. Otherwise, it performs 3735 destructions. It only performs those initializations or 3736 destructions with the indicated __PRIORITY. The generated function 3737 returns no value. 3738 3739 It is assumed that this function will only be called once per 3740 translation unit. */ 3741 3742 static tree 3743 start_static_storage_duration_function (unsigned count) 3744 { 3745 tree type; 3746 tree body; 3747 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32]; 3748 3749 /* Create the identifier for this function. It will be of the form 3750 SSDF_IDENTIFIER_<number>. */ 3751 sprintf (id, "%s_%u", SSDF_IDENTIFIER, count); 3752 3753 type = build_function_type_list (void_type_node, 3754 integer_type_node, integer_type_node, 3755 NULL_TREE); 3756 3757 /* Create the FUNCTION_DECL itself. */ 3758 ssdf_decl = build_lang_decl (FUNCTION_DECL, 3759 get_identifier (id), 3760 type); 3761 TREE_PUBLIC (ssdf_decl) = 0; 3762 DECL_ARTIFICIAL (ssdf_decl) = 1; 3763 3764 /* Put this function in the list of functions to be called from the 3765 static constructors and destructors. */ 3766 if (!ssdf_decls) 3767 { 3768 vec_alloc (ssdf_decls, 32); 3769 3770 /* Take this opportunity to initialize the map from priority 3771 numbers to information about that priority level. */ 3772 priority_info_map = splay_tree_new (splay_tree_compare_ints, 3773 /*delete_key_fn=*/0, 3774 /*delete_value_fn=*/ 3775 splay_tree_delete_pointers); 3776 3777 /* We always need to generate functions for the 3778 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk 3779 priorities later, we'll be sure to find the 3780 DEFAULT_INIT_PRIORITY. */ 3781 get_priority_info (DEFAULT_INIT_PRIORITY); 3782 } 3783 3784 vec_safe_push (ssdf_decls, ssdf_decl); 3785 3786 /* Create the argument list. */ 3787 initialize_p_decl = cp_build_parm_decl 3788 (ssdf_decl, get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node); 3789 TREE_USED (initialize_p_decl) = 1; 3790 priority_decl = cp_build_parm_decl 3791 (ssdf_decl, get_identifier (PRIORITY_IDENTIFIER), integer_type_node); 3792 TREE_USED (priority_decl) = 1; 3793 3794 DECL_CHAIN (initialize_p_decl) = priority_decl; 3795 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl; 3796 3797 /* Put the function in the global scope. */ 3798 pushdecl (ssdf_decl); 3799 3800 /* Start the function itself. This is equivalent to declaring the 3801 function as: 3802 3803 static void __ssdf (int __initialize_p, init __priority_p); 3804 3805 It is static because we only need to call this function from the 3806 various constructor and destructor functions for this module. */ 3807 start_preparsed_function (ssdf_decl, 3808 /*attrs=*/NULL_TREE, 3809 SF_PRE_PARSED); 3810 3811 /* Set up the scope of the outermost block in the function. */ 3812 body = begin_compound_stmt (BCS_FN_BODY); 3813 3814 return body; 3815 } 3816 3817 /* Finish the generation of the function which performs initialization 3818 and destruction of objects with static storage duration. After 3819 this point, no more such objects can be created. */ 3820 3821 static void 3822 finish_static_storage_duration_function (tree body) 3823 { 3824 /* Close out the function. */ 3825 finish_compound_stmt (body); 3826 expand_or_defer_fn (finish_function (/*inline_p=*/false)); 3827 } 3828 3829 /* Return the information about the indicated PRIORITY level. If no 3830 code to handle this level has yet been generated, generate the 3831 appropriate prologue. */ 3832 3833 static priority_info 3834 get_priority_info (int priority) 3835 { 3836 priority_info pi; 3837 splay_tree_node n; 3838 3839 n = splay_tree_lookup (priority_info_map, 3840 (splay_tree_key) priority); 3841 if (!n) 3842 { 3843 /* Create a new priority information structure, and insert it 3844 into the map. */ 3845 pi = XNEW (struct priority_info_s); 3846 pi->initializations_p = 0; 3847 pi->destructions_p = 0; 3848 splay_tree_insert (priority_info_map, 3849 (splay_tree_key) priority, 3850 (splay_tree_value) pi); 3851 } 3852 else 3853 pi = (priority_info) n->value; 3854 3855 return pi; 3856 } 3857 3858 /* The effective initialization priority of a DECL. */ 3859 3860 #define DECL_EFFECTIVE_INIT_PRIORITY(decl) \ 3861 ((!DECL_HAS_INIT_PRIORITY_P (decl) || DECL_INIT_PRIORITY (decl) == 0) \ 3862 ? DEFAULT_INIT_PRIORITY : DECL_INIT_PRIORITY (decl)) 3863 3864 /* Whether a DECL needs a guard to protect it against multiple 3865 initialization. */ 3866 3867 #define NEEDS_GUARD_P(decl) (TREE_PUBLIC (decl) && (DECL_COMMON (decl) \ 3868 || DECL_ONE_ONLY (decl) \ 3869 || DECL_WEAK (decl))) 3870 3871 /* Called from one_static_initialization_or_destruction(), 3872 via walk_tree. 3873 Walks the initializer list of a global variable and looks for 3874 temporary variables (DECL_NAME() == NULL and DECL_ARTIFICIAL != 0) 3875 and that have their DECL_CONTEXT() == NULL. 3876 For each such temporary variable, set their DECL_CONTEXT() to 3877 the current function. This is necessary because otherwise 3878 some optimizers (enabled by -O2 -fprofile-arcs) might crash 3879 when trying to refer to a temporary variable that does not have 3880 it's DECL_CONTECT() properly set. */ 3881 static tree 3882 fix_temporary_vars_context_r (tree *node, 3883 int * /*unused*/, 3884 void * /*unused1*/) 3885 { 3886 gcc_assert (current_function_decl); 3887 3888 if (TREE_CODE (*node) == BIND_EXPR) 3889 { 3890 tree var; 3891 3892 for (var = BIND_EXPR_VARS (*node); var; var = DECL_CHAIN (var)) 3893 if (VAR_P (var) 3894 && !DECL_NAME (var) 3895 && DECL_ARTIFICIAL (var) 3896 && !DECL_CONTEXT (var)) 3897 DECL_CONTEXT (var) = current_function_decl; 3898 } 3899 3900 return NULL_TREE; 3901 } 3902 3903 /* Set up to handle the initialization or destruction of DECL. If 3904 INITP is nonzero, we are initializing the variable. Otherwise, we 3905 are destroying it. */ 3906 3907 static void 3908 one_static_initialization_or_destruction (tree decl, tree init, bool initp) 3909 { 3910 tree guard_if_stmt = NULL_TREE; 3911 tree guard; 3912 3913 /* If we are supposed to destruct and there's a trivial destructor, 3914 nothing has to be done. */ 3915 if (!initp 3916 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) 3917 return; 3918 3919 /* Trick the compiler into thinking we are at the file and line 3920 where DECL was declared so that error-messages make sense, and so 3921 that the debugger will show somewhat sensible file and line 3922 information. */ 3923 input_location = DECL_SOURCE_LOCATION (decl); 3924 3925 /* Make sure temporary variables in the initialiser all have 3926 their DECL_CONTEXT() set to a value different from NULL_TREE. 3927 This can happen when global variables initializers are built. 3928 In that case, the DECL_CONTEXT() of the global variables _AND_ of all 3929 the temporary variables that might have been generated in the 3930 accompanying initializers is NULL_TREE, meaning the variables have been 3931 declared in the global namespace. 3932 What we want to do here is to fix that and make sure the DECL_CONTEXT() 3933 of the temporaries are set to the current function decl. */ 3934 cp_walk_tree_without_duplicates (&init, 3935 fix_temporary_vars_context_r, 3936 NULL); 3937 3938 /* Because of: 3939 3940 [class.access.spec] 3941 3942 Access control for implicit calls to the constructors, 3943 the conversion functions, or the destructor called to 3944 create and destroy a static data member is performed as 3945 if these calls appeared in the scope of the member's 3946 class. 3947 3948 we pretend we are in a static member function of the class of 3949 which the DECL is a member. */ 3950 if (member_p (decl)) 3951 { 3952 DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl); 3953 DECL_STATIC_FUNCTION_P (current_function_decl) = 1; 3954 } 3955 3956 /* Assume we don't need a guard. */ 3957 guard = NULL_TREE; 3958 /* We need a guard if this is an object with external linkage that 3959 might be initialized in more than one place. (For example, a 3960 static data member of a template, when the data member requires 3961 construction.) */ 3962 if (NEEDS_GUARD_P (decl)) 3963 { 3964 tree guard_cond; 3965 3966 guard = get_guard (decl); 3967 3968 /* When using __cxa_atexit, we just check the GUARD as we would 3969 for a local static. */ 3970 if (flag_use_cxa_atexit) 3971 { 3972 /* When using __cxa_atexit, we never try to destroy 3973 anything from a static destructor. */ 3974 gcc_assert (initp); 3975 guard_cond = get_guard_cond (guard, false); 3976 } 3977 /* If we don't have __cxa_atexit, then we will be running 3978 destructors from .fini sections, or their equivalents. So, 3979 we need to know how many times we've tried to initialize this 3980 object. We do initializations only if the GUARD is zero, 3981 i.e., if we are the first to initialize the variable. We do 3982 destructions only if the GUARD is one, i.e., if we are the 3983 last to destroy the variable. */ 3984 else if (initp) 3985 guard_cond 3986 = cp_build_binary_op (input_location, 3987 EQ_EXPR, 3988 cp_build_unary_op (PREINCREMENT_EXPR, 3989 guard, 3990 /*noconvert=*/true, 3991 tf_warning_or_error), 3992 integer_one_node, 3993 tf_warning_or_error); 3994 else 3995 guard_cond 3996 = cp_build_binary_op (input_location, 3997 EQ_EXPR, 3998 cp_build_unary_op (PREDECREMENT_EXPR, 3999 guard, 4000 /*noconvert=*/true, 4001 tf_warning_or_error), 4002 integer_zero_node, 4003 tf_warning_or_error); 4004 4005 guard_if_stmt = begin_if_stmt (); 4006 finish_if_stmt_cond (guard_cond, guard_if_stmt); 4007 } 4008 4009 4010 /* If we're using __cxa_atexit, we have not already set the GUARD, 4011 so we must do so now. */ 4012 if (guard && initp && flag_use_cxa_atexit) 4013 finish_expr_stmt (set_guard (guard)); 4014 4015 /* Perform the initialization or destruction. */ 4016 if (initp) 4017 { 4018 if (init) 4019 { 4020 finish_expr_stmt (init); 4021 if (sanitize_flags_p (SANITIZE_ADDRESS, decl)) 4022 { 4023 varpool_node *vnode = varpool_node::get (decl); 4024 if (vnode) 4025 vnode->dynamically_initialized = 1; 4026 } 4027 } 4028 4029 /* If we're using __cxa_atexit, register a function that calls the 4030 destructor for the object. */ 4031 if (flag_use_cxa_atexit) 4032 finish_expr_stmt (register_dtor_fn (decl)); 4033 } 4034 else 4035 finish_expr_stmt (build_cleanup (decl)); 4036 4037 /* Finish the guard if-stmt, if necessary. */ 4038 if (guard) 4039 { 4040 finish_then_clause (guard_if_stmt); 4041 finish_if_stmt (guard_if_stmt); 4042 } 4043 4044 /* Now that we're done with DECL we don't need to pretend to be a 4045 member of its class any longer. */ 4046 DECL_CONTEXT (current_function_decl) = NULL_TREE; 4047 DECL_STATIC_FUNCTION_P (current_function_decl) = 0; 4048 } 4049 4050 /* Generate code to do the initialization or destruction of the decls in VARS, 4051 a TREE_LIST of VAR_DECL with static storage duration. 4052 Whether initialization or destruction is performed is specified by INITP. */ 4053 4054 static void 4055 do_static_initialization_or_destruction (tree vars, bool initp) 4056 { 4057 tree node, init_if_stmt, cond; 4058 4059 /* Build the outer if-stmt to check for initialization or destruction. */ 4060 init_if_stmt = begin_if_stmt (); 4061 cond = initp ? integer_one_node : integer_zero_node; 4062 cond = cp_build_binary_op (input_location, 4063 EQ_EXPR, 4064 initialize_p_decl, 4065 cond, 4066 tf_warning_or_error); 4067 finish_if_stmt_cond (cond, init_if_stmt); 4068 4069 /* To make sure dynamic construction doesn't access globals from other 4070 compilation units where they might not be yet constructed, for 4071 -fsanitize=address insert __asan_before_dynamic_init call that 4072 prevents access to either all global variables that need construction 4073 in other compilation units, or at least those that haven't been 4074 initialized yet. Variables that need dynamic construction in 4075 the current compilation unit are kept accessible. */ 4076 if (initp && (flag_sanitize & SANITIZE_ADDRESS)) 4077 finish_expr_stmt (asan_dynamic_init_call (/*after_p=*/false)); 4078 4079 node = vars; 4080 do { 4081 tree decl = TREE_VALUE (node); 4082 tree priority_if_stmt; 4083 int priority; 4084 priority_info pi; 4085 4086 /* If we don't need a destructor, there's nothing to do. Avoid 4087 creating a possibly empty if-stmt. */ 4088 if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl))) 4089 { 4090 node = TREE_CHAIN (node); 4091 continue; 4092 } 4093 4094 /* Remember that we had an initialization or finalization at this 4095 priority. */ 4096 priority = DECL_EFFECTIVE_INIT_PRIORITY (decl); 4097 pi = get_priority_info (priority); 4098 if (initp) 4099 pi->initializations_p = 1; 4100 else 4101 pi->destructions_p = 1; 4102 4103 /* Conditionalize this initialization on being in the right priority 4104 and being initializing/finalizing appropriately. */ 4105 priority_if_stmt = begin_if_stmt (); 4106 cond = cp_build_binary_op (input_location, 4107 EQ_EXPR, 4108 priority_decl, 4109 build_int_cst (NULL_TREE, priority), 4110 tf_warning_or_error); 4111 finish_if_stmt_cond (cond, priority_if_stmt); 4112 4113 /* Process initializers with same priority. */ 4114 for (; node 4115 && DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority; 4116 node = TREE_CHAIN (node)) 4117 /* Do one initialization or destruction. */ 4118 one_static_initialization_or_destruction (TREE_VALUE (node), 4119 TREE_PURPOSE (node), initp); 4120 4121 /* Finish up the priority if-stmt body. */ 4122 finish_then_clause (priority_if_stmt); 4123 finish_if_stmt (priority_if_stmt); 4124 4125 } while (node); 4126 4127 /* Revert what __asan_before_dynamic_init did by calling 4128 __asan_after_dynamic_init. */ 4129 if (initp && (flag_sanitize & SANITIZE_ADDRESS)) 4130 finish_expr_stmt (asan_dynamic_init_call (/*after_p=*/true)); 4131 4132 /* Finish up the init/destruct if-stmt body. */ 4133 finish_then_clause (init_if_stmt); 4134 finish_if_stmt (init_if_stmt); 4135 } 4136 4137 /* VARS is a list of variables with static storage duration which may 4138 need initialization and/or finalization. Remove those variables 4139 that don't really need to be initialized or finalized, and return 4140 the resulting list. The order in which the variables appear in 4141 VARS is in reverse order of the order in which they should actually 4142 be initialized. The list we return is in the unreversed order; 4143 i.e., the first variable should be initialized first. */ 4144 4145 static tree 4146 prune_vars_needing_no_initialization (tree *vars) 4147 { 4148 tree *var = vars; 4149 tree result = NULL_TREE; 4150 4151 while (*var) 4152 { 4153 tree t = *var; 4154 tree decl = TREE_VALUE (t); 4155 tree init = TREE_PURPOSE (t); 4156 4157 /* Deal gracefully with error. */ 4158 if (error_operand_p (decl)) 4159 { 4160 var = &TREE_CHAIN (t); 4161 continue; 4162 } 4163 4164 /* The only things that can be initialized are variables. */ 4165 gcc_assert (VAR_P (decl)); 4166 4167 /* If this object is not defined, we don't need to do anything 4168 here. */ 4169 if (DECL_EXTERNAL (decl)) 4170 { 4171 var = &TREE_CHAIN (t); 4172 continue; 4173 } 4174 4175 /* Also, if the initializer already contains errors, we can bail 4176 out now. */ 4177 if (init && TREE_CODE (init) == TREE_LIST 4178 && value_member (error_mark_node, init)) 4179 { 4180 var = &TREE_CHAIN (t); 4181 continue; 4182 } 4183 4184 /* This variable is going to need initialization and/or 4185 finalization, so we add it to the list. */ 4186 *var = TREE_CHAIN (t); 4187 TREE_CHAIN (t) = result; 4188 result = t; 4189 } 4190 4191 return result; 4192 } 4193 4194 /* Make sure we have told the back end about all the variables in 4195 VARS. */ 4196 4197 static void 4198 write_out_vars (tree vars) 4199 { 4200 tree v; 4201 4202 for (v = vars; v; v = TREE_CHAIN (v)) 4203 { 4204 tree var = TREE_VALUE (v); 4205 if (!var_finalized_p (var)) 4206 { 4207 import_export_decl (var); 4208 rest_of_decl_compilation (var, 1, 1); 4209 } 4210 } 4211 } 4212 4213 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor 4214 (otherwise) that will initialize all global objects with static 4215 storage duration having the indicated PRIORITY. */ 4216 4217 static void 4218 generate_ctor_or_dtor_function (bool constructor_p, int priority, 4219 location_t *locus) 4220 { 4221 char function_key; 4222 tree fndecl; 4223 tree body; 4224 size_t i; 4225 4226 input_location = *locus; 4227 /* ??? */ 4228 /* Was: locus->line++; */ 4229 4230 /* We use `I' to indicate initialization and `D' to indicate 4231 destruction. */ 4232 function_key = constructor_p ? 'I' : 'D'; 4233 4234 /* We emit the function lazily, to avoid generating empty 4235 global constructors and destructors. */ 4236 body = NULL_TREE; 4237 4238 /* For Objective-C++, we may need to initialize metadata found in this module. 4239 This must be done _before_ any other static initializations. */ 4240 if (c_dialect_objc () && (priority == DEFAULT_INIT_PRIORITY) 4241 && constructor_p && objc_static_init_needed_p ()) 4242 { 4243 body = start_objects (function_key, priority); 4244 objc_generate_static_init_call (NULL_TREE); 4245 } 4246 4247 /* Call the static storage duration function with appropriate 4248 arguments. */ 4249 FOR_EACH_VEC_SAFE_ELT (ssdf_decls, i, fndecl) 4250 { 4251 /* Calls to pure or const functions will expand to nothing. */ 4252 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE))) 4253 { 4254 tree call; 4255 4256 if (! body) 4257 body = start_objects (function_key, priority); 4258 4259 call = cp_build_function_call_nary (fndecl, tf_warning_or_error, 4260 build_int_cst (NULL_TREE, 4261 constructor_p), 4262 build_int_cst (NULL_TREE, 4263 priority), 4264 NULL_TREE); 4265 finish_expr_stmt (call); 4266 } 4267 } 4268 4269 /* Close out the function. */ 4270 if (body) 4271 finish_objects (function_key, priority, body); 4272 } 4273 4274 /* Generate constructor and destructor functions for the priority 4275 indicated by N. */ 4276 4277 static int 4278 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data) 4279 { 4280 location_t *locus = (location_t *) data; 4281 int priority = (int) n->key; 4282 priority_info pi = (priority_info) n->value; 4283 4284 /* Generate the functions themselves, but only if they are really 4285 needed. */ 4286 if (pi->initializations_p) 4287 generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus); 4288 if (pi->destructions_p) 4289 generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus); 4290 4291 /* Keep iterating. */ 4292 return 0; 4293 } 4294 4295 /* Return C++ property of T, based on given operation OP. */ 4296 4297 static int 4298 cpp_check (tree t, cpp_operation op) 4299 { 4300 switch (op) 4301 { 4302 case HAS_DEPENDENT_TEMPLATE_ARGS: 4303 { 4304 tree ti = CLASSTYPE_TEMPLATE_INFO (t); 4305 if (!ti) 4306 return 0; 4307 ++processing_template_decl; 4308 const bool dep = any_dependent_template_arguments_p (TI_ARGS (ti)); 4309 --processing_template_decl; 4310 return dep; 4311 } 4312 case IS_ABSTRACT: 4313 return DECL_PURE_VIRTUAL_P (t); 4314 case IS_ASSIGNMENT_OPERATOR: 4315 return DECL_ASSIGNMENT_OPERATOR_P (t); 4316 case IS_CONSTRUCTOR: 4317 return DECL_CONSTRUCTOR_P (t); 4318 case IS_DESTRUCTOR: 4319 return DECL_DESTRUCTOR_P (t); 4320 case IS_COPY_CONSTRUCTOR: 4321 return DECL_COPY_CONSTRUCTOR_P (t); 4322 case IS_MOVE_CONSTRUCTOR: 4323 return DECL_MOVE_CONSTRUCTOR_P (t); 4324 case IS_TEMPLATE: 4325 return TREE_CODE (t) == TEMPLATE_DECL; 4326 case IS_TRIVIAL: 4327 return trivial_type_p (t); 4328 default: 4329 return 0; 4330 } 4331 } 4332 4333 /* Collect source file references recursively, starting from NAMESPC. */ 4334 4335 static void 4336 collect_source_refs (tree namespc) 4337 { 4338 /* Iterate over names in this name space. */ 4339 for (tree t = NAMESPACE_LEVEL (namespc)->names; t; t = TREE_CHAIN (t)) 4340 if (DECL_IS_BUILTIN (t)) 4341 ; 4342 else if (TREE_CODE (t) == NAMESPACE_DECL && !DECL_NAMESPACE_ALIAS (t)) 4343 collect_source_refs (t); 4344 else 4345 collect_source_ref (DECL_SOURCE_FILE (t)); 4346 } 4347 4348 /* Collect decls relevant to SOURCE_FILE from all namespaces recursively, 4349 starting from NAMESPC. */ 4350 4351 static void 4352 collect_ada_namespace (tree namespc, const char *source_file) 4353 { 4354 tree decl = NAMESPACE_LEVEL (namespc)->names; 4355 4356 /* Collect decls from this namespace. This will skip 4357 NAMESPACE_DECLs (both aliases and regular, it cannot tell). */ 4358 collect_ada_nodes (decl, source_file); 4359 4360 /* Now scan for namespace children, and dump them. */ 4361 for (; decl; decl = TREE_CHAIN (decl)) 4362 if (TREE_CODE (decl) == NAMESPACE_DECL && !DECL_NAMESPACE_ALIAS (decl)) 4363 collect_ada_namespace (decl, source_file); 4364 } 4365 4366 /* Returns true iff there is a definition available for variable or 4367 function DECL. */ 4368 4369 bool 4370 decl_defined_p (tree decl) 4371 { 4372 if (TREE_CODE (decl) == FUNCTION_DECL) 4373 return (DECL_INITIAL (decl) != NULL_TREE 4374 /* A pending instantiation of a friend temploid is defined. */ 4375 || (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl) 4376 && DECL_INITIAL (DECL_TEMPLATE_RESULT 4377 (DECL_TI_TEMPLATE (decl))))); 4378 else 4379 { 4380 gcc_assert (VAR_P (decl)); 4381 return !DECL_EXTERNAL (decl); 4382 } 4383 } 4384 4385 /* Nonzero for a VAR_DECL whose value can be used in a constant expression. 4386 4387 [expr.const] 4388 4389 An integral constant-expression can only involve ... const 4390 variables of integral or enumeration types initialized with 4391 constant expressions ... 4392 4393 C++0x also allows constexpr variables and temporaries initialized 4394 with constant expressions. We handle the former here, but the latter 4395 are just folded away in cxx_eval_constant_expression. 4396 4397 The standard does not require that the expression be non-volatile. 4398 G++ implements the proposed correction in DR 457. */ 4399 4400 bool 4401 decl_constant_var_p (tree decl) 4402 { 4403 if (!decl_maybe_constant_var_p (decl)) 4404 return false; 4405 4406 /* We don't know if a template static data member is initialized with 4407 a constant expression until we instantiate its initializer. Even 4408 in the case of a constexpr variable, we can't treat it as a 4409 constant until its initializer is complete in case it's used in 4410 its own initializer. */ 4411 maybe_instantiate_decl (decl); 4412 return DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl); 4413 } 4414 4415 /* Returns true if DECL could be a symbolic constant variable, depending on 4416 its initializer. */ 4417 4418 bool 4419 decl_maybe_constant_var_p (tree decl) 4420 { 4421 tree type = TREE_TYPE (decl); 4422 if (!VAR_P (decl)) 4423 return false; 4424 if (DECL_DECLARED_CONSTEXPR_P (decl) && !TREE_THIS_VOLATILE (decl)) 4425 return true; 4426 if (DECL_HAS_VALUE_EXPR_P (decl)) 4427 /* A proxy isn't constant. */ 4428 return false; 4429 if (TYPE_REF_P (type)) 4430 /* References can be constant. */; 4431 else if (CP_TYPE_CONST_NON_VOLATILE_P (type) 4432 && INTEGRAL_OR_ENUMERATION_TYPE_P (type)) 4433 /* And const integers. */; 4434 else 4435 return false; 4436 4437 if (DECL_INITIAL (decl) 4438 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)) 4439 /* We know the initializer, and it isn't constant. */ 4440 return false; 4441 else 4442 return true; 4443 } 4444 4445 /* Complain that DECL uses a type with no linkage. In C++98 mode this is 4446 called from grokfndecl and grokvardecl; in all modes it is called from 4447 cp_write_global_declarations. */ 4448 4449 void 4450 no_linkage_error (tree decl) 4451 { 4452 if (cxx_dialect >= cxx11 4453 && (decl_defined_p (decl) 4454 /* Treat templates which limit_bad_template_recursion decided 4455 not to instantiate as if they were defined. */ 4456 || (errorcount + sorrycount > 0 4457 && DECL_LANG_SPECIFIC (decl) 4458 && DECL_TEMPLATE_INFO (decl) 4459 && TREE_NO_WARNING (decl)))) 4460 /* In C++11 it's ok if the decl is defined. */ 4461 return; 4462 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false); 4463 if (t == NULL_TREE) 4464 /* The type that got us on no_linkage_decls must have gotten a name for 4465 linkage purposes. */; 4466 else if (CLASS_TYPE_P (t) && TYPE_BEING_DEFINED (t)) 4467 /* The type might end up having a typedef name for linkage purposes. */ 4468 vec_safe_push (no_linkage_decls, decl); 4469 else if (TYPE_UNNAMED_P (t)) 4470 { 4471 bool d = false; 4472 auto_diagnostic_group grp; 4473 if (cxx_dialect >= cxx11) 4474 d = permerror (DECL_SOURCE_LOCATION (decl), "%q#D, declared using " 4475 "unnamed type, is used but never defined", decl); 4476 else if (DECL_EXTERN_C_P (decl)) 4477 /* Allow this; it's pretty common in C. */; 4478 else if (VAR_P (decl)) 4479 /* DRs 132, 319 and 389 seem to indicate types with 4480 no linkage can only be used to declare extern "C" 4481 entities. Since it's not always an error in the 4482 ISO C++ 90 Standard, we only issue a warning. */ 4483 d = warning_at (DECL_SOURCE_LOCATION (decl), 0, "unnamed type " 4484 "with no linkage used to declare variable %q#D with " 4485 "linkage", decl); 4486 else 4487 d = permerror (DECL_SOURCE_LOCATION (decl), "unnamed type with no " 4488 "linkage used to declare function %q#D with linkage", 4489 decl); 4490 if (d && is_typedef_decl (TYPE_NAME (t))) 4491 inform (DECL_SOURCE_LOCATION (TYPE_NAME (t)), "%q#D does not refer " 4492 "to the unqualified type, so it is not used for linkage", 4493 TYPE_NAME (t)); 4494 } 4495 else if (cxx_dialect >= cxx11) 4496 { 4497 if (VAR_P (decl) || !DECL_PURE_VIRTUAL_P (decl)) 4498 permerror (DECL_SOURCE_LOCATION (decl), 4499 "%q#D, declared using local type " 4500 "%qT, is used but never defined", decl, t); 4501 } 4502 else if (VAR_P (decl)) 4503 warning_at (DECL_SOURCE_LOCATION (decl), 0, "type %qT with no linkage " 4504 "used to declare variable %q#D with linkage", t, decl); 4505 else 4506 permerror (DECL_SOURCE_LOCATION (decl), "type %qT with no linkage used " 4507 "to declare function %q#D with linkage", t, decl); 4508 } 4509 4510 /* Collect declarations from all namespaces relevant to SOURCE_FILE. */ 4511 4512 static void 4513 collect_all_refs (const char *source_file) 4514 { 4515 collect_ada_namespace (global_namespace, source_file); 4516 } 4517 4518 /* Clear DECL_EXTERNAL for NODE. */ 4519 4520 static bool 4521 clear_decl_external (struct cgraph_node *node, void * /*data*/) 4522 { 4523 DECL_EXTERNAL (node->decl) = 0; 4524 return false; 4525 } 4526 4527 /* Build up the function to run dynamic initializers for thread_local 4528 variables in this translation unit and alias the init functions for the 4529 individual variables to it. */ 4530 4531 static void 4532 handle_tls_init (void) 4533 { 4534 tree vars = prune_vars_needing_no_initialization (&tls_aggregates); 4535 if (vars == NULL_TREE) 4536 return; 4537 4538 location_t loc = DECL_SOURCE_LOCATION (TREE_VALUE (vars)); 4539 4540 write_out_vars (vars); 4541 4542 tree guard = build_decl (loc, VAR_DECL, get_identifier ("__tls_guard"), 4543 boolean_type_node); 4544 TREE_PUBLIC (guard) = false; 4545 TREE_STATIC (guard) = true; 4546 DECL_ARTIFICIAL (guard) = true; 4547 DECL_IGNORED_P (guard) = true; 4548 TREE_USED (guard) = true; 4549 CP_DECL_THREAD_LOCAL_P (guard) = true; 4550 set_decl_tls_model (guard, decl_default_tls_model (guard)); 4551 pushdecl_top_level_and_finish (guard, NULL_TREE); 4552 4553 tree fn = get_local_tls_init_fn (loc); 4554 start_preparsed_function (fn, NULL_TREE, SF_PRE_PARSED); 4555 tree body = begin_function_body (); 4556 tree if_stmt = begin_if_stmt (); 4557 tree cond = cp_build_unary_op (TRUTH_NOT_EXPR, guard, false, 4558 tf_warning_or_error); 4559 finish_if_stmt_cond (cond, if_stmt); 4560 finish_expr_stmt (cp_build_modify_expr (loc, guard, NOP_EXPR, 4561 boolean_true_node, 4562 tf_warning_or_error)); 4563 for (; vars; vars = TREE_CHAIN (vars)) 4564 { 4565 tree var = TREE_VALUE (vars); 4566 tree init = TREE_PURPOSE (vars); 4567 one_static_initialization_or_destruction (var, init, true); 4568 4569 /* Output init aliases even with -fno-extern-tls-init. */ 4570 if (TARGET_SUPPORTS_ALIASES && TREE_PUBLIC (var)) 4571 { 4572 tree single_init_fn = get_tls_init_fn (var); 4573 if (single_init_fn == NULL_TREE) 4574 continue; 4575 cgraph_node *alias 4576 = cgraph_node::get_create (fn)->create_same_body_alias 4577 (single_init_fn, fn); 4578 gcc_assert (alias != NULL); 4579 } 4580 } 4581 4582 finish_then_clause (if_stmt); 4583 finish_if_stmt (if_stmt); 4584 finish_function_body (body); 4585 expand_or_defer_fn (finish_function (/*inline_p=*/false)); 4586 } 4587 4588 /* We're at the end of compilation, so generate any mangling aliases that 4589 we've been saving up, if DECL is going to be output and ID2 isn't 4590 already taken by another declaration. */ 4591 4592 static void 4593 generate_mangling_alias (tree decl, tree id2) 4594 { 4595 struct cgraph_node *n = NULL; 4596 4597 if (TREE_CODE (decl) == FUNCTION_DECL) 4598 { 4599 n = cgraph_node::get (decl); 4600 if (!n) 4601 /* Don't create an alias to an unreferenced function. */ 4602 return; 4603 } 4604 4605 tree *slot 4606 = mangled_decls->find_slot_with_hash (id2, IDENTIFIER_HASH_VALUE (id2), 4607 INSERT); 4608 4609 /* If there's a declaration already using this mangled name, 4610 don't create a compatibility alias that conflicts. */ 4611 if (*slot) 4612 return; 4613 4614 tree alias = make_alias_for (decl, id2); 4615 *slot = alias; 4616 4617 DECL_IGNORED_P (alias) = 1; 4618 TREE_PUBLIC (alias) = TREE_PUBLIC (decl); 4619 DECL_VISIBILITY (alias) = DECL_VISIBILITY (decl); 4620 if (vague_linkage_p (decl)) 4621 DECL_WEAK (alias) = 1; 4622 4623 if (n) 4624 n->create_same_body_alias (alias, decl); 4625 else 4626 varpool_node::create_extra_name_alias (alias, decl); 4627 } 4628 4629 /* Note that we might want to emit an alias with the symbol ID2 for DECL at 4630 the end of translation, for compatibility across bugs in the mangling 4631 implementation. */ 4632 4633 void 4634 note_mangling_alias (tree decl, tree id2) 4635 { 4636 if (TARGET_SUPPORTS_ALIASES) 4637 { 4638 if (!defer_mangling_aliases) 4639 generate_mangling_alias (decl, id2); 4640 else 4641 { 4642 vec_safe_push (mangling_aliases, decl); 4643 vec_safe_push (mangling_aliases, id2); 4644 } 4645 } 4646 } 4647 4648 /* Emit all mangling aliases that were deferred up to this point. */ 4649 4650 void 4651 generate_mangling_aliases () 4652 { 4653 while (!vec_safe_is_empty (mangling_aliases)) 4654 { 4655 tree id2 = mangling_aliases->pop(); 4656 tree decl = mangling_aliases->pop(); 4657 generate_mangling_alias (decl, id2); 4658 } 4659 defer_mangling_aliases = false; 4660 } 4661 4662 /* Record a mangling of DECL, whose DECL_ASSEMBLER_NAME has just been 4663 set. NEED_WARNING is true if we must warn about collisions. We do 4664 this to spot changes in mangling that may require compatibility 4665 aliases. */ 4666 4667 void 4668 record_mangling (tree decl, bool need_warning) 4669 { 4670 if (!mangled_decls) 4671 mangled_decls = hash_table<mangled_decl_hash>::create_ggc (499); 4672 4673 gcc_checking_assert (DECL_ASSEMBLER_NAME_SET_P (decl)); 4674 tree id = DECL_ASSEMBLER_NAME_RAW (decl); 4675 tree *slot 4676 = mangled_decls->find_slot_with_hash (id, IDENTIFIER_HASH_VALUE (id), 4677 INSERT); 4678 4679 /* If this is already an alias, remove the alias, because the real 4680 decl takes precedence. */ 4681 if (*slot && DECL_ARTIFICIAL (*slot) && DECL_IGNORED_P (*slot)) 4682 if (symtab_node *n = symtab_node::get (*slot)) 4683 if (n->cpp_implicit_alias) 4684 { 4685 n->remove (); 4686 *slot = NULL_TREE; 4687 } 4688 4689 if (!*slot) 4690 *slot = decl; 4691 else if (need_warning) 4692 { 4693 error_at (DECL_SOURCE_LOCATION (decl), 4694 "mangling of %q#D as %qE conflicts with a previous mangle", 4695 decl, id); 4696 inform (DECL_SOURCE_LOCATION (*slot), 4697 "previous mangling %q#D", *slot); 4698 inform (DECL_SOURCE_LOCATION (decl), 4699 "a later %<-fabi-version=%> (or =0)" 4700 " avoids this error with a change in mangling"); 4701 *slot = decl; 4702 } 4703 } 4704 4705 /* The mangled name of DECL is being forcibly changed to NAME. Remove 4706 any existing knowledge of DECL's mangled name meaning DECL. */ 4707 4708 void 4709 overwrite_mangling (tree decl, tree name) 4710 { 4711 if (tree id = DECL_ASSEMBLER_NAME_RAW (decl)) 4712 if ((TREE_CODE (decl) == VAR_DECL 4713 || TREE_CODE (decl) == FUNCTION_DECL) 4714 && mangled_decls) 4715 if (tree *slot 4716 = mangled_decls->find_slot_with_hash (id, IDENTIFIER_HASH_VALUE (id), 4717 NO_INSERT)) 4718 if (*slot == decl) 4719 { 4720 mangled_decls->clear_slot (slot); 4721 4722 /* If this is an alias, remove it from the symbol table. */ 4723 if (DECL_ARTIFICIAL (decl) && DECL_IGNORED_P (decl)) 4724 if (symtab_node *n = symtab_node::get (decl)) 4725 if (n->cpp_implicit_alias) 4726 n->remove (); 4727 } 4728 4729 DECL_ASSEMBLER_NAME_RAW (decl) = name; 4730 } 4731 4732 /* The entire file is now complete. If requested, dump everything 4733 to a file. */ 4734 4735 static void 4736 dump_tu (void) 4737 { 4738 dump_flags_t flags; 4739 if (FILE *stream = dump_begin (raw_dump_id, &flags)) 4740 { 4741 dump_node (global_namespace, flags & ~TDF_SLIM, stream); 4742 dump_end (raw_dump_id, stream); 4743 } 4744 } 4745 4746 static location_t locus_at_end_of_parsing; 4747 4748 /* Check the deallocation functions for CODE to see if we want to warn that 4749 only one was defined. */ 4750 4751 static void 4752 maybe_warn_sized_delete (enum tree_code code) 4753 { 4754 tree sized = NULL_TREE; 4755 tree unsized = NULL_TREE; 4756 4757 for (ovl_iterator iter (get_global_binding (ovl_op_identifier (false, code))); 4758 iter; ++iter) 4759 { 4760 tree fn = *iter; 4761 /* We're only interested in usual deallocation functions. */ 4762 if (!usual_deallocation_fn_p (fn)) 4763 continue; 4764 if (FUNCTION_ARG_CHAIN (fn) == void_list_node) 4765 unsized = fn; 4766 else 4767 sized = fn; 4768 } 4769 if (DECL_INITIAL (unsized) && !DECL_INITIAL (sized)) 4770 warning_at (DECL_SOURCE_LOCATION (unsized), OPT_Wsized_deallocation, 4771 "the program should also define %qD", sized); 4772 else if (!DECL_INITIAL (unsized) && DECL_INITIAL (sized)) 4773 warning_at (DECL_SOURCE_LOCATION (sized), OPT_Wsized_deallocation, 4774 "the program should also define %qD", unsized); 4775 } 4776 4777 /* Check the global deallocation functions to see if we want to warn about 4778 defining unsized without sized (or vice versa). */ 4779 4780 static void 4781 maybe_warn_sized_delete () 4782 { 4783 if (!flag_sized_deallocation || !warn_sized_deallocation) 4784 return; 4785 maybe_warn_sized_delete (DELETE_EXPR); 4786 maybe_warn_sized_delete (VEC_DELETE_EXPR); 4787 } 4788 4789 /* Earlier we left PTRMEM_CST in variable initializers alone so that we could 4790 look them up when evaluating non-type template parameters. Now we need to 4791 lower them to something the back end can understand. */ 4792 4793 static void 4794 lower_var_init () 4795 { 4796 varpool_node *node; 4797 FOR_EACH_VARIABLE (node) 4798 { 4799 tree d = node->decl; 4800 if (tree init = DECL_INITIAL (d)) 4801 DECL_INITIAL (d) = cplus_expand_constant (init); 4802 } 4803 } 4804 4805 /* This routine is called at the end of compilation. 4806 Its job is to create all the code needed to initialize and 4807 destroy the global aggregates. We do the destruction 4808 first, since that way we only need to reverse the decls once. */ 4809 4810 void 4811 c_parse_final_cleanups (void) 4812 { 4813 tree vars; 4814 bool reconsider; 4815 size_t i; 4816 unsigned ssdf_count = 0; 4817 int retries = 0; 4818 tree decl; 4819 4820 locus_at_end_of_parsing = input_location; 4821 at_eof = 1; 4822 4823 /* Bad parse errors. Just forget about it. */ 4824 if (! global_bindings_p () || current_class_type 4825 || !vec_safe_is_empty (decl_namespace_list)) 4826 return; 4827 4828 /* This is the point to write out a PCH if we're doing that. 4829 In that case we do not want to do anything else. */ 4830 if (pch_file) 4831 { 4832 /* Mangle all symbols at PCH creation time. */ 4833 symtab_node *node; 4834 FOR_EACH_SYMBOL (node) 4835 if (! is_a <varpool_node *> (node) 4836 || ! DECL_HARD_REGISTER (node->decl)) 4837 DECL_ASSEMBLER_NAME (node->decl); 4838 c_common_write_pch (); 4839 dump_tu (); 4840 /* Ensure even the callers don't try to finalize the CU. */ 4841 flag_syntax_only = 1; 4842 return; 4843 } 4844 4845 timevar_stop (TV_PHASE_PARSING); 4846 timevar_start (TV_PHASE_DEFERRED); 4847 4848 symtab->process_same_body_aliases (); 4849 4850 /* Handle -fdump-ada-spec[-slim] */ 4851 if (flag_dump_ada_spec || flag_dump_ada_spec_slim) 4852 { 4853 collect_source_ref (main_input_filename); 4854 if (!flag_dump_ada_spec_slim) 4855 collect_source_refs (global_namespace); 4856 4857 dump_ada_specs (collect_all_refs, cpp_check); 4858 } 4859 4860 /* FIXME - huh? was input_line -= 1;*/ 4861 4862 /* We now have to write out all the stuff we put off writing out. 4863 These include: 4864 4865 o Template specializations that we have not yet instantiated, 4866 but which are needed. 4867 o Initialization and destruction for non-local objects with 4868 static storage duration. (Local objects with static storage 4869 duration are initialized when their scope is first entered, 4870 and are cleaned up via atexit.) 4871 o Virtual function tables. 4872 4873 All of these may cause others to be needed. For example, 4874 instantiating one function may cause another to be needed, and 4875 generating the initializer for an object may cause templates to be 4876 instantiated, etc., etc. */ 4877 4878 emit_support_tinfos (); 4879 4880 do 4881 { 4882 tree t; 4883 tree decl; 4884 4885 reconsider = false; 4886 4887 /* If there are templates that we've put off instantiating, do 4888 them now. */ 4889 instantiate_pending_templates (retries); 4890 ggc_collect (); 4891 4892 /* Write out virtual tables as required. Writing out the 4893 virtual table for a template class may cause the 4894 instantiation of members of that class. If we write out 4895 vtables then we remove the class from our list so we don't 4896 have to look at it again. */ 4897 for (i = keyed_classes->length (); 4898 keyed_classes->iterate (--i, &t);) 4899 if (maybe_emit_vtables (t)) 4900 { 4901 reconsider = true; 4902 keyed_classes->unordered_remove (i); 4903 } 4904 /* The input_location may have been changed during marking of 4905 vtable entries. */ 4906 input_location = locus_at_end_of_parsing; 4907 4908 /* Write out needed type info variables. We have to be careful 4909 looping through unemitted decls, because emit_tinfo_decl may 4910 cause other variables to be needed. New elements will be 4911 appended, and we remove from the vector those that actually 4912 get emitted. */ 4913 for (i = unemitted_tinfo_decls->length (); 4914 unemitted_tinfo_decls->iterate (--i, &t);) 4915 if (emit_tinfo_decl (t)) 4916 { 4917 reconsider = true; 4918 unemitted_tinfo_decls->unordered_remove (i); 4919 } 4920 4921 /* The list of objects with static storage duration is built up 4922 in reverse order. We clear STATIC_AGGREGATES so that any new 4923 aggregates added during the initialization of these will be 4924 initialized in the correct order when we next come around the 4925 loop. */ 4926 vars = prune_vars_needing_no_initialization (&static_aggregates); 4927 4928 if (vars) 4929 { 4930 /* We need to start a new initialization function each time 4931 through the loop. That's because we need to know which 4932 vtables have been referenced, and TREE_SYMBOL_REFERENCED 4933 isn't computed until a function is finished, and written 4934 out. That's a deficiency in the back end. When this is 4935 fixed, these initialization functions could all become 4936 inline, with resulting performance improvements. */ 4937 tree ssdf_body; 4938 4939 /* Make sure the back end knows about all the variables. */ 4940 write_out_vars (vars); 4941 4942 /* Set the line and file, so that it is obviously not from 4943 the source file. */ 4944 input_location = locus_at_end_of_parsing; 4945 ssdf_body = start_static_storage_duration_function (ssdf_count); 4946 4947 /* First generate code to do all the initializations. */ 4948 if (vars) 4949 do_static_initialization_or_destruction (vars, /*initp=*/true); 4950 4951 /* Then, generate code to do all the destructions. Do these 4952 in reverse order so that the most recently constructed 4953 variable is the first destroyed. If we're using 4954 __cxa_atexit, then we don't need to do this; functions 4955 were registered at initialization time to destroy the 4956 local statics. */ 4957 if (!flag_use_cxa_atexit && vars) 4958 { 4959 vars = nreverse (vars); 4960 do_static_initialization_or_destruction (vars, /*initp=*/false); 4961 } 4962 else 4963 vars = NULL_TREE; 4964 4965 /* Finish up the static storage duration function for this 4966 round. */ 4967 input_location = locus_at_end_of_parsing; 4968 finish_static_storage_duration_function (ssdf_body); 4969 4970 /* All those initializations and finalizations might cause 4971 us to need more inline functions, more template 4972 instantiations, etc. */ 4973 reconsider = true; 4974 ssdf_count++; 4975 /* ??? was: locus_at_end_of_parsing.line++; */ 4976 } 4977 4978 /* Now do the same for thread_local variables. */ 4979 handle_tls_init (); 4980 4981 /* Go through the set of inline functions whose bodies have not 4982 been emitted yet. If out-of-line copies of these functions 4983 are required, emit them. */ 4984 FOR_EACH_VEC_SAFE_ELT (deferred_fns, i, decl) 4985 { 4986 /* Does it need synthesizing? */ 4987 if (DECL_DEFAULTED_FN (decl) && ! DECL_INITIAL (decl) 4988 && (! DECL_REALLY_EXTERN (decl) || possibly_inlined_p (decl))) 4989 { 4990 /* Even though we're already at the top-level, we push 4991 there again. That way, when we pop back a few lines 4992 hence, all of our state is restored. Otherwise, 4993 finish_function doesn't clean things up, and we end 4994 up with CURRENT_FUNCTION_DECL set. */ 4995 push_to_top_level (); 4996 /* The decl's location will mark where it was first 4997 needed. Save that so synthesize method can indicate 4998 where it was needed from, in case of error */ 4999 input_location = DECL_SOURCE_LOCATION (decl); 5000 synthesize_method (decl); 5001 pop_from_top_level (); 5002 reconsider = true; 5003 } 5004 5005 if (!DECL_INITIAL (decl) && decl_tls_wrapper_p (decl)) 5006 generate_tls_wrapper (decl); 5007 5008 if (!DECL_SAVED_TREE (decl)) 5009 continue; 5010 5011 cgraph_node *node = cgraph_node::get_create (decl); 5012 5013 /* We lie to the back end, pretending that some functions 5014 are not defined when they really are. This keeps these 5015 functions from being put out unnecessarily. But, we must 5016 stop lying when the functions are referenced, or if they 5017 are not comdat since they need to be put out now. If 5018 DECL_INTERFACE_KNOWN, then we have already set 5019 DECL_EXTERNAL appropriately, so there's no need to check 5020 again, and we do not want to clear DECL_EXTERNAL if a 5021 previous call to import_export_decl set it. 5022 5023 This is done in a separate for cycle, because if some 5024 deferred function is contained in another deferred 5025 function later in deferred_fns varray, 5026 rest_of_compilation would skip this function and we 5027 really cannot expand the same function twice. */ 5028 import_export_decl (decl); 5029 if (DECL_NOT_REALLY_EXTERN (decl) 5030 && DECL_INITIAL (decl) 5031 && decl_needed_p (decl)) 5032 { 5033 if (node->cpp_implicit_alias) 5034 node = node->get_alias_target (); 5035 5036 node->call_for_symbol_thunks_and_aliases (clear_decl_external, 5037 NULL, true); 5038 /* If we mark !DECL_EXTERNAL one of the symbols in some comdat 5039 group, we need to mark all symbols in the same comdat group 5040 that way. */ 5041 if (node->same_comdat_group) 5042 for (cgraph_node *next 5043 = dyn_cast<cgraph_node *> (node->same_comdat_group); 5044 next != node; 5045 next = dyn_cast<cgraph_node *> (next->same_comdat_group)) 5046 next->call_for_symbol_thunks_and_aliases (clear_decl_external, 5047 NULL, true); 5048 } 5049 5050 /* If we're going to need to write this function out, and 5051 there's already a body for it, create RTL for it now. 5052 (There might be no body if this is a method we haven't 5053 gotten around to synthesizing yet.) */ 5054 if (!DECL_EXTERNAL (decl) 5055 && decl_needed_p (decl) 5056 && !TREE_ASM_WRITTEN (decl) 5057 && !DECL_IMMEDIATE_FUNCTION_P (decl) 5058 && !node->definition) 5059 { 5060 /* We will output the function; no longer consider it in this 5061 loop. */ 5062 DECL_DEFER_OUTPUT (decl) = 0; 5063 /* Generate RTL for this function now that we know we 5064 need it. */ 5065 expand_or_defer_fn (decl); 5066 reconsider = true; 5067 } 5068 } 5069 5070 if (wrapup_namespace_globals ()) 5071 reconsider = true; 5072 5073 /* Static data members are just like namespace-scope globals. */ 5074 FOR_EACH_VEC_SAFE_ELT (pending_statics, i, decl) 5075 { 5076 if (var_finalized_p (decl) || DECL_REALLY_EXTERN (decl) 5077 /* Don't write it out if we haven't seen a definition. */ 5078 || DECL_IN_AGGR_P (decl)) 5079 continue; 5080 import_export_decl (decl); 5081 /* If this static data member is needed, provide it to the 5082 back end. */ 5083 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl)) 5084 DECL_EXTERNAL (decl) = 0; 5085 } 5086 if (vec_safe_length (pending_statics) != 0 5087 && wrapup_global_declarations (pending_statics->address (), 5088 pending_statics->length ())) 5089 reconsider = true; 5090 5091 retries++; 5092 } 5093 while (reconsider); 5094 5095 lower_var_init (); 5096 5097 generate_mangling_aliases (); 5098 5099 /* All used inline functions must have a definition at this point. */ 5100 FOR_EACH_VEC_SAFE_ELT (deferred_fns, i, decl) 5101 { 5102 if (/* Check online inline functions that were actually used. */ 5103 DECL_ODR_USED (decl) && DECL_DECLARED_INLINE_P (decl) 5104 /* If the definition actually was available here, then the 5105 fact that the function was not defined merely represents 5106 that for some reason (use of a template repository, 5107 #pragma interface, etc.) we decided not to emit the 5108 definition here. */ 5109 && !DECL_INITIAL (decl) 5110 /* Don't complain if the template was defined. */ 5111 && !(DECL_TEMPLATE_INSTANTIATION (decl) 5112 && DECL_INITIAL (DECL_TEMPLATE_RESULT 5113 (template_for_substitution (decl)))) 5114 && warning_at (DECL_SOURCE_LOCATION (decl), 0, 5115 "inline function %qD used but never defined", decl)) 5116 /* Avoid a duplicate warning from check_global_declaration. */ 5117 TREE_NO_WARNING (decl) = 1; 5118 } 5119 5120 /* So must decls that use a type with no linkage. */ 5121 FOR_EACH_VEC_SAFE_ELT (no_linkage_decls, i, decl) 5122 no_linkage_error (decl); 5123 5124 maybe_warn_sized_delete (); 5125 5126 /* Then, do the Objective-C stuff. This is where all the 5127 Objective-C module stuff gets generated (symtab, 5128 class/protocol/selector lists etc). This must be done after C++ 5129 templates, destructors etc. so that selectors used in C++ 5130 templates are properly allocated. */ 5131 if (c_dialect_objc ()) 5132 objc_write_global_declarations (); 5133 5134 /* We give C linkage to static constructors and destructors. */ 5135 push_lang_context (lang_name_c); 5136 5137 /* Generate initialization and destruction functions for all 5138 priorities for which they are required. */ 5139 if (priority_info_map) 5140 splay_tree_foreach (priority_info_map, 5141 generate_ctor_and_dtor_functions_for_priority, 5142 /*data=*/&locus_at_end_of_parsing); 5143 else if (c_dialect_objc () && objc_static_init_needed_p ()) 5144 /* If this is obj-c++ and we need a static init, call 5145 generate_ctor_or_dtor_function. */ 5146 generate_ctor_or_dtor_function (/*constructor_p=*/true, 5147 DEFAULT_INIT_PRIORITY, 5148 &locus_at_end_of_parsing); 5149 5150 /* We're done with the splay-tree now. */ 5151 if (priority_info_map) 5152 splay_tree_delete (priority_info_map); 5153 5154 /* Generate any missing aliases. */ 5155 maybe_apply_pending_pragma_weaks (); 5156 5157 /* We're done with static constructors, so we can go back to "C++" 5158 linkage now. */ 5159 pop_lang_context (); 5160 5161 if (flag_vtable_verify) 5162 { 5163 vtv_recover_class_info (); 5164 vtv_compute_class_hierarchy_transitive_closure (); 5165 vtv_build_vtable_verify_fndecl (); 5166 } 5167 5168 perform_deferred_noexcept_checks (); 5169 5170 fini_constexpr (); 5171 5172 /* The entire file is now complete. If requested, dump everything 5173 to a file. */ 5174 dump_tu (); 5175 5176 if (flag_detailed_statistics) 5177 { 5178 dump_tree_statistics (); 5179 dump_time_statistics (); 5180 } 5181 5182 timevar_stop (TV_PHASE_DEFERRED); 5183 timevar_start (TV_PHASE_PARSING); 5184 5185 /* Indicate that we're done with front end processing. */ 5186 at_eof = 2; 5187 } 5188 5189 /* Perform any post compilation-proper cleanups for the C++ front-end. 5190 This should really go away. No front-end should need to do 5191 anything past the compilation process. */ 5192 5193 void 5194 cxx_post_compilation_parsing_cleanups (void) 5195 { 5196 timevar_start (TV_PHASE_LATE_PARSING_CLEANUPS); 5197 5198 if (flag_vtable_verify) 5199 { 5200 /* Generate the special constructor initialization function that 5201 calls __VLTRegisterPairs, and give it a very high 5202 initialization priority. This must be done after 5203 finalize_compilation_unit so that we have accurate 5204 information about which vtable will actually be emitted. */ 5205 vtv_generate_init_routine (); 5206 } 5207 5208 input_location = locus_at_end_of_parsing; 5209 5210 if (flag_checking) 5211 validate_conversion_obstack (); 5212 5213 timevar_stop (TV_PHASE_LATE_PARSING_CLEANUPS); 5214 } 5215 5216 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the 5217 function to call in parse-tree form; it has not yet been 5218 semantically analyzed. ARGS are the arguments to the function. 5219 They have already been semantically analyzed. This may change 5220 ARGS. */ 5221 5222 tree 5223 build_offset_ref_call_from_tree (tree fn, vec<tree, va_gc> **args, 5224 tsubst_flags_t complain) 5225 { 5226 tree orig_fn; 5227 vec<tree, va_gc> *orig_args = NULL; 5228 tree expr; 5229 tree object; 5230 5231 orig_fn = fn; 5232 object = TREE_OPERAND (fn, 0); 5233 5234 if (processing_template_decl) 5235 { 5236 gcc_assert (TREE_CODE (fn) == DOTSTAR_EXPR 5237 || TREE_CODE (fn) == MEMBER_REF); 5238 if (type_dependent_expression_p (fn) 5239 || any_type_dependent_arguments_p (*args)) 5240 return build_min_nt_call_vec (fn, *args); 5241 5242 orig_args = make_tree_vector_copy (*args); 5243 5244 /* Transform the arguments and add the implicit "this" 5245 parameter. That must be done before the FN is transformed 5246 because we depend on the form of FN. */ 5247 make_args_non_dependent (*args); 5248 object = build_non_dependent_expr (object); 5249 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE) 5250 { 5251 if (TREE_CODE (fn) == DOTSTAR_EXPR) 5252 object = cp_build_addr_expr (object, complain); 5253 vec_safe_insert (*args, 0, object); 5254 } 5255 /* Now that the arguments are done, transform FN. */ 5256 fn = build_non_dependent_expr (fn); 5257 } 5258 5259 /* A qualified name corresponding to a bound pointer-to-member is 5260 represented as an OFFSET_REF: 5261 5262 struct B { void g(); }; 5263 void (B::*p)(); 5264 void B::g() { (this->*p)(); } */ 5265 if (TREE_CODE (fn) == OFFSET_REF) 5266 { 5267 tree object_addr = cp_build_addr_expr (object, complain); 5268 fn = TREE_OPERAND (fn, 1); 5269 fn = get_member_function_from_ptrfunc (&object_addr, fn, 5270 complain); 5271 vec_safe_insert (*args, 0, object_addr); 5272 } 5273 5274 if (CLASS_TYPE_P (TREE_TYPE (fn))) 5275 expr = build_op_call (fn, args, complain); 5276 else 5277 expr = cp_build_function_call_vec (fn, args, complain); 5278 if (processing_template_decl && expr != error_mark_node) 5279 expr = build_min_non_dep_call_vec (expr, orig_fn, orig_args); 5280 5281 if (orig_args != NULL) 5282 release_tree_vector (orig_args); 5283 5284 return expr; 5285 } 5286 5287 5288 void 5289 check_default_args (tree x) 5290 { 5291 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x)); 5292 bool saw_def = false; 5293 bool noted_first_def = false; 5294 int idx_of_first_default_arg = 0; 5295 location_t loc_of_first_default_arg = UNKNOWN_LOCATION; 5296 int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE); 5297 tree fndecl = STRIP_TEMPLATE (x); 5298 auto_diagnostic_group d; 5299 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i) 5300 { 5301 if (TREE_PURPOSE (arg)) 5302 { 5303 if (!saw_def) 5304 { 5305 saw_def = true; 5306 idx_of_first_default_arg = i; 5307 location_t loc = get_fndecl_argument_location (fndecl, i); 5308 if (loc != DECL_SOURCE_LOCATION (x)) 5309 loc_of_first_default_arg = loc; 5310 } 5311 } 5312 else if (saw_def && !PACK_EXPANSION_P (TREE_VALUE (arg))) 5313 { 5314 error_at (get_fndecl_argument_location (fndecl, i), 5315 "default argument missing for parameter %P of %q#D", i, x); 5316 if (loc_of_first_default_arg != UNKNOWN_LOCATION 5317 && !noted_first_def) 5318 { 5319 inform (loc_of_first_default_arg, 5320 "...following parameter %P which has a default argument", 5321 idx_of_first_default_arg); 5322 noted_first_def = true; 5323 } 5324 TREE_PURPOSE (arg) = error_mark_node; 5325 } 5326 } 5327 } 5328 5329 /* Return true if function DECL can be inlined. This is used to force 5330 instantiation of methods that might be interesting for inlining. */ 5331 bool 5332 possibly_inlined_p (tree decl) 5333 { 5334 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); 5335 if (DECL_UNINLINABLE (decl)) 5336 return false; 5337 if (!optimize) 5338 return DECL_DECLARED_INLINE_P (decl); 5339 /* When optimizing, we might inline everything when flatten 5340 attribute or heuristics inlining for size or autoinlining 5341 is used. */ 5342 return true; 5343 } 5344 5345 /* Normally, we can wait until instantiation-time to synthesize DECL. 5346 However, if DECL is a static data member initialized with a constant 5347 or a constexpr function, we need it right now because a reference to 5348 such a data member or a call to such function is not value-dependent. 5349 For a function that uses auto in the return type, we need to instantiate 5350 it to find out its type. For OpenMP user defined reductions, we need 5351 them instantiated for reduction clauses which inline them by hand 5352 directly. */ 5353 5354 static void 5355 maybe_instantiate_decl (tree decl) 5356 { 5357 if (DECL_LANG_SPECIFIC (decl) 5358 && DECL_TEMPLATE_INFO (decl) 5359 && (decl_maybe_constant_var_p (decl) 5360 || (TREE_CODE (decl) == FUNCTION_DECL 5361 && DECL_OMP_DECLARE_REDUCTION_P (decl)) 5362 || undeduced_auto_decl (decl)) 5363 && !DECL_DECLARED_CONCEPT_P (decl) 5364 && !uses_template_parms (DECL_TI_ARGS (decl))) 5365 { 5366 /* Instantiating a function will result in garbage collection. We 5367 must treat this situation as if we were within the body of a 5368 function so as to avoid collecting live data only referenced from 5369 the stack (such as overload resolution candidates). */ 5370 ++function_depth; 5371 instantiate_decl (decl, /*defer_ok=*/false, 5372 /*expl_inst_class_mem_p=*/false); 5373 --function_depth; 5374 } 5375 } 5376 5377 /* Maybe warn if DECL is deprecated, subject to COMPLAIN. Returns whether or 5378 not a warning was emitted. */ 5379 5380 bool 5381 cp_warn_deprecated_use (tree decl, tsubst_flags_t complain) 5382 { 5383 if (!(complain & tf_warning) || !decl 5384 || deprecated_state == DEPRECATED_SUPPRESS) 5385 return false; 5386 5387 if (!TREE_DEPRECATED (decl)) 5388 { 5389 /* Perhaps this is a deprecated typedef. */ 5390 if (TYPE_P (decl) && TYPE_NAME (decl)) 5391 decl = TYPE_NAME (decl); 5392 5393 if (!TREE_DEPRECATED (decl)) 5394 return false; 5395 } 5396 5397 /* Don't warn within members of a deprecated type. */ 5398 if (TYPE_P (decl) 5399 && currently_open_class (decl)) 5400 return false; 5401 5402 bool warned = false; 5403 if (cxx_dialect >= cxx11 5404 && DECL_P (decl) 5405 && DECL_ARTIFICIAL (decl) 5406 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl) 5407 && copy_fn_p (decl)) 5408 { 5409 if (warn_deprecated_copy 5410 /* Don't warn about system library classes (c++/86342). */ 5411 && (!DECL_IN_SYSTEM_HEADER (decl) 5412 || global_dc->dc_warn_system_headers)) 5413 { 5414 auto_diagnostic_group d; 5415 tree ctx = DECL_CONTEXT (decl); 5416 tree other = classtype_has_depr_implicit_copy (ctx); 5417 int opt = (DECL_DESTRUCTOR_P (other) 5418 ? OPT_Wdeprecated_copy_dtor 5419 : OPT_Wdeprecated_copy); 5420 warned = warning (opt, "implicitly-declared %qD is deprecated", 5421 decl); 5422 if (warned) 5423 inform (DECL_SOURCE_LOCATION (other), 5424 "because %qT has user-provided %qD", 5425 ctx, other); 5426 } 5427 } 5428 else 5429 warned = warn_deprecated_use (decl, NULL_TREE); 5430 5431 return warned; 5432 } 5433 5434 /* Like above, but takes into account outer scopes. */ 5435 5436 void 5437 cp_warn_deprecated_use_scopes (tree scope) 5438 { 5439 while (scope 5440 && scope != error_mark_node 5441 && scope != global_namespace) 5442 { 5443 if ((TREE_CODE (scope) == NAMESPACE_DECL || OVERLOAD_TYPE_P (scope)) 5444 && cp_warn_deprecated_use (scope)) 5445 return; 5446 if (TYPE_P (scope)) 5447 scope = CP_TYPE_CONTEXT (scope); 5448 else 5449 scope = CP_DECL_CONTEXT (scope); 5450 } 5451 } 5452 5453 /* True if DECL or its enclosing scope have unbound template parameters. */ 5454 5455 bool 5456 decl_dependent_p (tree decl) 5457 { 5458 if (DECL_FUNCTION_SCOPE_P (decl) 5459 || TREE_CODE (decl) == CONST_DECL 5460 || TREE_CODE (decl) == USING_DECL 5461 || TREE_CODE (decl) == FIELD_DECL) 5462 decl = CP_DECL_CONTEXT (decl); 5463 if (tree tinfo = get_template_info (decl)) 5464 if (any_dependent_template_arguments_p (TI_ARGS (tinfo))) 5465 return true; 5466 if (LAMBDA_FUNCTION_P (decl) 5467 && dependent_type_p (DECL_CONTEXT (decl))) 5468 return true; 5469 return false; 5470 } 5471 5472 /* Mark DECL (either a _DECL or a BASELINK) as "used" in the program. 5473 If DECL is a specialization or implicitly declared class member, 5474 generate the actual definition. Return false if something goes 5475 wrong, true otherwise. */ 5476 5477 bool 5478 mark_used (tree decl, tsubst_flags_t complain) 5479 { 5480 /* If we're just testing conversions or resolving overloads, we 5481 don't want any permanent effects like forcing functions to be 5482 output or instantiating templates. */ 5483 if ((complain & tf_conv)) 5484 return true; 5485 5486 /* If DECL is a BASELINK for a single function, then treat it just 5487 like the DECL for the function. Otherwise, if the BASELINK is 5488 for an overloaded function, we don't know which function was 5489 actually used until after overload resolution. */ 5490 if (BASELINK_P (decl)) 5491 { 5492 decl = BASELINK_FUNCTIONS (decl); 5493 if (really_overloaded_fn (decl)) 5494 return true; 5495 decl = OVL_FIRST (decl); 5496 } 5497 5498 if (!DECL_P (decl)) 5499 return true; 5500 5501 /* Set TREE_USED for the benefit of -Wunused. */ 5502 TREE_USED (decl) = 1; 5503 /* And for structured bindings also the underlying decl. */ 5504 if (DECL_DECOMPOSITION_P (decl) && DECL_DECOMP_BASE (decl)) 5505 TREE_USED (DECL_DECOMP_BASE (decl)) = 1; 5506 5507 if (TREE_CODE (decl) == TEMPLATE_DECL) 5508 return true; 5509 5510 if (DECL_CLONED_FUNCTION_P (decl)) 5511 TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1; 5512 5513 /* Mark enumeration types as used. */ 5514 if (TREE_CODE (decl) == CONST_DECL) 5515 used_types_insert (DECL_CONTEXT (decl)); 5516 5517 if (TREE_CODE (decl) == FUNCTION_DECL 5518 && !DECL_DELETED_FN (decl) 5519 && !maybe_instantiate_noexcept (decl, complain)) 5520 return false; 5521 5522 if (TREE_CODE (decl) == FUNCTION_DECL 5523 && DECL_DELETED_FN (decl)) 5524 { 5525 if (DECL_ARTIFICIAL (decl) 5526 && DECL_CONV_FN_P (decl) 5527 && LAMBDA_TYPE_P (DECL_CONTEXT (decl))) 5528 /* We mark a lambda conversion op as deleted if we can't 5529 generate it properly; see maybe_add_lambda_conv_op. */ 5530 sorry ("converting lambda that uses %<...%> to function pointer"); 5531 else if (complain & tf_error) 5532 { 5533 error ("use of deleted function %qD", decl); 5534 if (!maybe_explain_implicit_delete (decl)) 5535 inform (DECL_SOURCE_LOCATION (decl), "declared here"); 5536 } 5537 return false; 5538 } 5539 5540 cp_warn_deprecated_use (decl, complain); 5541 5542 /* We can only check DECL_ODR_USED on variables or functions with 5543 DECL_LANG_SPECIFIC set, and these are also the only decls that we 5544 might need special handling for. */ 5545 if (!VAR_OR_FUNCTION_DECL_P (decl) 5546 || DECL_LANG_SPECIFIC (decl) == NULL 5547 || DECL_THUNK_P (decl)) 5548 { 5549 if (!decl_dependent_p (decl) 5550 && !require_deduced_type (decl, complain)) 5551 return false; 5552 return true; 5553 } 5554 5555 /* We only want to do this processing once. We don't need to keep trying 5556 to instantiate inline templates, because unit-at-a-time will make sure 5557 we get them compiled before functions that want to inline them. */ 5558 if (DECL_ODR_USED (decl)) 5559 return true; 5560 5561 if (flag_concepts && TREE_CODE (decl) == FUNCTION_DECL 5562 && !constraints_satisfied_p (decl)) 5563 { 5564 if (complain & tf_error) 5565 { 5566 auto_diagnostic_group d; 5567 error ("use of function %qD with unsatisfied constraints", 5568 decl); 5569 location_t loc = DECL_SOURCE_LOCATION (decl); 5570 inform (loc, "declared here"); 5571 diagnose_constraints (loc, decl, NULL_TREE); 5572 } 5573 return false; 5574 } 5575 5576 /* Normally, we can wait until instantiation-time to synthesize DECL. 5577 However, if DECL is a static data member initialized with a constant 5578 or a constexpr function, we need it right now because a reference to 5579 such a data member or a call to such function is not value-dependent. 5580 For a function that uses auto in the return type, we need to instantiate 5581 it to find out its type. For OpenMP user defined reductions, we need 5582 them instantiated for reduction clauses which inline them by hand 5583 directly. */ 5584 maybe_instantiate_decl (decl); 5585 5586 if (processing_template_decl || in_template_function ()) 5587 return true; 5588 5589 /* Check this too in case we're within instantiate_non_dependent_expr. */ 5590 if (DECL_TEMPLATE_INFO (decl) 5591 && uses_template_parms (DECL_TI_ARGS (decl))) 5592 return true; 5593 5594 if (!require_deduced_type (decl, complain)) 5595 return false; 5596 5597 if (builtin_pack_fn_p (decl)) 5598 { 5599 error ("use of built-in parameter pack %qD outside of a template", 5600 DECL_NAME (decl)); 5601 return false; 5602 } 5603 5604 /* If we don't need a value, then we don't need to synthesize DECL. */ 5605 if (cp_unevaluated_operand || in_discarded_stmt) 5606 return true; 5607 5608 DECL_ODR_USED (decl) = 1; 5609 if (DECL_CLONED_FUNCTION_P (decl)) 5610 DECL_ODR_USED (DECL_CLONED_FUNCTION (decl)) = 1; 5611 5612 /* DR 757: A type without linkage shall not be used as the type of a 5613 variable or function with linkage, unless 5614 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or 5615 o the variable or function is not used (3.2 [basic.def.odr]) or is 5616 defined in the same translation unit. */ 5617 if (cxx_dialect > cxx98 5618 && decl_linkage (decl) != lk_none 5619 && !DECL_EXTERN_C_P (decl) 5620 && !DECL_ARTIFICIAL (decl) 5621 && !decl_defined_p (decl) 5622 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false)) 5623 { 5624 if (is_local_extern (decl)) 5625 /* There's no way to define a local extern, and adding it to 5626 the vector interferes with GC, so give an error now. */ 5627 no_linkage_error (decl); 5628 else 5629 vec_safe_push (no_linkage_decls, decl); 5630 } 5631 5632 if (TREE_CODE (decl) == FUNCTION_DECL 5633 && DECL_DECLARED_INLINE_P (decl) 5634 && !DECL_INITIAL (decl) 5635 && !DECL_ARTIFICIAL (decl) 5636 && !DECL_PURE_VIRTUAL_P (decl)) 5637 /* Remember it, so we can check it was defined. */ 5638 note_vague_linkage_fn (decl); 5639 5640 /* Is it a synthesized method that needs to be synthesized? */ 5641 if (TREE_CODE (decl) == FUNCTION_DECL 5642 && DECL_DEFAULTED_FN (decl) 5643 /* A function defaulted outside the class is synthesized either by 5644 cp_finish_decl or instantiate_decl. */ 5645 && !DECL_DEFAULTED_OUTSIDE_CLASS_P (decl) 5646 && ! DECL_INITIAL (decl)) 5647 { 5648 /* Defer virtual destructors so that thunks get the right 5649 linkage. */ 5650 if (DECL_VIRTUAL_P (decl) && !at_eof) 5651 { 5652 note_vague_linkage_fn (decl); 5653 return true; 5654 } 5655 5656 /* Remember the current location for a function we will end up 5657 synthesizing. Then we can inform the user where it was 5658 required in the case of error. */ 5659 if (decl_remember_implicit_trigger_p (decl)) 5660 DECL_SOURCE_LOCATION (decl) = input_location; 5661 5662 /* Synthesizing an implicitly defined member function will result in 5663 garbage collection. We must treat this situation as if we were 5664 within the body of a function so as to avoid collecting live data 5665 on the stack (such as overload resolution candidates). 5666 5667 We could just let c_parse_final_cleanups handle synthesizing 5668 this function by adding it to deferred_fns, but doing 5669 it at the use site produces better error messages. */ 5670 ++function_depth; 5671 synthesize_method (decl); 5672 --function_depth; 5673 /* If this is a synthesized method we don't need to 5674 do the instantiation test below. */ 5675 } 5676 else if (VAR_OR_FUNCTION_DECL_P (decl) 5677 && DECL_TEMPLATE_INFO (decl) 5678 && !DECL_DECLARED_CONCEPT_P (decl) 5679 && (!DECL_EXPLICIT_INSTANTIATION (decl) 5680 || always_instantiate_p (decl))) 5681 /* If this is a function or variable that is an instance of some 5682 template, we now know that we will need to actually do the 5683 instantiation. We check that DECL is not an explicit 5684 instantiation because that is not checked in instantiate_decl. 5685 5686 We put off instantiating functions in order to improve compile 5687 times. Maintaining a stack of active functions is expensive, 5688 and the inliner knows to instantiate any functions it might 5689 need. Therefore, we always try to defer instantiation. */ 5690 { 5691 ++function_depth; 5692 instantiate_decl (decl, /*defer_ok=*/true, 5693 /*expl_inst_class_mem_p=*/false); 5694 --function_depth; 5695 } 5696 5697 return true; 5698 } 5699 5700 bool 5701 mark_used (tree decl) 5702 { 5703 return mark_used (decl, tf_warning_or_error); 5704 } 5705 5706 tree 5707 vtv_start_verification_constructor_init_function (void) 5708 { 5709 return start_objects ('I', MAX_RESERVED_INIT_PRIORITY - 1); 5710 } 5711 5712 tree 5713 vtv_finish_verification_constructor_init_function (tree function_body) 5714 { 5715 tree fn; 5716 5717 finish_compound_stmt (function_body); 5718 fn = finish_function (/*inline_p=*/false); 5719 DECL_STATIC_CONSTRUCTOR (fn) = 1; 5720 decl_init_priority_insert (fn, MAX_RESERVED_INIT_PRIORITY - 1); 5721 5722 return fn; 5723 } 5724 5725 #include "gt-cp-decl2.h" 5726