1/* RunTime Type Identification 2 Copyright (C) 1995-2022 Free Software Foundation, Inc. 3 Mostly written by Jason Merrill (jason@cygnus.com). 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 3, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21#include "config.h" 22#include "system.h" 23#include "coretypes.h" 24#include "target.h" 25#include "cp-tree.h" 26#include "memmodel.h" 27#include "tm_p.h" 28#include "stringpool.h" 29#include "intl.h" 30#include "stor-layout.h" 31#include "c-family/c-pragma.h" 32#include "gcc-rich-location.h" 33 34/* C++ returns type information to the user in struct type_info 35 objects. We also use type information to implement dynamic_cast and 36 exception handlers. Type information for a particular type is 37 indicated with an ABI defined structure derived from type_info. 38 This would all be very straight forward, but for the fact that the 39 runtime library provides the definitions of the type_info structure 40 and the ABI defined derived classes. We cannot build declarations 41 of them directly in the compiler, but we need to layout objects of 42 their type. Somewhere we have to lie. 43 44 We define layout compatible POD-structs with compiler-defined names 45 and generate the appropriate initializations for them (complete 46 with explicit mention of their vtable). When we have to provide a 47 type_info to the user we reinterpret_cast the internal compiler 48 type to type_info. A well formed program can only explicitly refer 49 to the type_infos of complete types (& cv void). However, we chain 50 pointer type_infos to the pointed-to-type, and that can be 51 incomplete. We only need the addresses of such incomplete 52 type_info objects for static initialization. 53 54 The type information VAR_DECL of a type is held on the 55 get_global_binding of the type's mangled name. That VAR_DECL 56 will be the internal type. It will usually have the correct 57 internal type reflecting the kind of type it represents (pointer, 58 array, function, class, inherited class, etc). When the type it 59 represents is incomplete, it will have the internal type 60 corresponding to type_info. That will only happen at the end of 61 translation, when we are emitting the type info objects. */ 62 63/* Auxiliary data we hold for each type_info derived object we need. */ 64struct GTY (()) tinfo_s { 65 tree type; /* The (const-qualified) RECORD_TYPE for this type_info object */ 66 67 tree vtable; /* The VAR_DECL of the vtable. Only filled at end of 68 translation. */ 69 70 tree name; /* IDENTIFIER_NODE for the ABI specified name of 71 the type_info derived type. */ 72}; 73 74 75enum tinfo_kind 76{ 77 TK_TYPE_INFO_TYPE, /* abi::__type_info_pseudo */ 78 TK_BASE_TYPE, /* abi::__base_class_type_info */ 79 TK_DERIVED_TYPES, /* Start of types derived from abi::__type_info */ 80 TK_BUILTIN_TYPE = TK_DERIVED_TYPES, /* abi::__fundamental_type_info */ 81 TK_ARRAY_TYPE, /* abi::__array_type_info */ 82 TK_FUNCTION_TYPE, /* abi::__function_type_info */ 83 TK_ENUMERAL_TYPE, /* abi::__enum_type_info */ 84 TK_POINTER_TYPE, /* abi::__pointer_type_info */ 85 TK_POINTER_MEMBER_TYPE, /* abi::__pointer_to_member_type_info */ 86 TK_CLASS_TYPE, /* abi::__class_type_info */ 87 TK_SI_CLASS_TYPE, /* abi::__si_class_type_info */ 88 TK_VMI_CLASS_TYPES, /* abi::__vmi_class_type_info<int> */ 89 TK_MAX 90}; 91 92/* Names of the tinfo types. Must be same order as TK enumeration 93 above. */ 94 95static const char *const tinfo_names[TK_MAX] = 96{ 97 "__type_info", 98 "__base_class_type_info", 99 "__fundamental_type_info", 100 "__array_type_info", 101 "__function_type_info", 102 "__enum_type_info", 103 "__pointer_type_info", 104 "__pointer_to_member_type_info", 105 "__class_type_info", 106 "__si_class_type_info", 107 "__vmi_class_type_info" 108}; 109 110/* Helper macro to get maximum scalar-width of pointer or of the 'long'-type. 111 This of interest for llp64 targets. */ 112#define LONGPTR_T \ 113 integer_types[(POINTER_SIZE <= TYPE_PRECISION (integer_types[itk_long]) \ 114 ? itk_long : itk_long_long)] 115 116/* A vector of all tinfo decls that haven't yet been emitted. */ 117vec<tree, va_gc> *unemitted_tinfo_decls; 118 119/* A vector of all type_info derived types we need. The first few are 120 fixed and created early. The remainder are for multiple inheritance 121 and are generated as needed. */ 122static GTY (()) vec<tinfo_s, va_gc> *tinfo_descs; 123 124static tree tinfo_name (tree, bool); 125static tree build_dynamic_cast_1 (location_t, tree, tree, tsubst_flags_t); 126static tree throw_bad_cast (void); 127static tree throw_bad_typeid (void); 128static bool typeid_ok_p (void); 129static int qualifier_flags (tree); 130static bool target_incomplete_p (tree); 131static tree tinfo_base_init (tinfo_s *, tree); 132static tree generic_initializer (tinfo_s *, tree); 133static tree ptr_initializer (tinfo_s *, tree); 134static tree ptm_initializer (tinfo_s *, tree); 135static tree class_initializer (tinfo_s *, tree, unsigned, ...); 136static tree get_pseudo_ti_init (tree, unsigned); 137static unsigned get_pseudo_ti_index (tree); 138static tinfo_s *get_tinfo_desc (unsigned); 139static void create_tinfo_types (void); 140static bool typeinfo_in_lib_p (tree); 141 142static int doing_runtime = 0; 143 144/* Create the internal versions of the ABI types. */ 145 146void 147init_rtti_processing (void) 148{ 149 vec_alloc (unemitted_tinfo_decls, 124); 150 151 create_tinfo_types (); 152} 153 154/* Given the expression EXP of type `class *', return the head of the 155 object pointed to by EXP with type cv void*, if the class has any 156 virtual functions (TYPE_POLYMORPHIC_P), else just return the 157 expression. */ 158 159tree 160build_headof (tree exp) 161{ 162 tree type = TREE_TYPE (exp); 163 tree offset; 164 tree index; 165 166 gcc_assert (TYPE_PTR_P (type)); 167 type = TREE_TYPE (type); 168 169 if (!TYPE_POLYMORPHIC_P (type)) 170 return exp; 171 172 /* We use this a couple of times below, protect it. */ 173 exp = save_expr (exp); 174 175 /* The offset-to-top field is at index -2 from the vptr. */ 176 index = build_int_cst (NULL_TREE, 177 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE); 178 179 offset = build_vtbl_ref (cp_build_fold_indirect_ref (exp), 180 index); 181 182 cp_build_qualified_type (ptr_type_node, 183 cp_type_quals (TREE_TYPE (exp))); 184 return fold_build_pointer_plus (exp, offset); 185} 186 187/* Get a bad_cast node for the program to throw... 188 189 See libstdc++/exception.cc for __throw_bad_cast */ 190 191static tree 192throw_bad_cast (void) 193{ 194 static tree fn; 195 if (!fn) 196 { 197 tree name = get_identifier ("__cxa_bad_cast"); 198 fn = get_global_binding (name); 199 if (!fn) 200 fn = push_throw_library_fn 201 (name, build_function_type_list (ptr_type_node, NULL_TREE)); 202 } 203 204 return build_cxx_call (fn, 0, NULL, tf_warning_or_error); 205} 206 207/* Return an expression for "__cxa_bad_typeid()". The expression 208 returned is an lvalue of type "const std::type_info". */ 209 210static tree 211throw_bad_typeid (void) 212{ 213 static tree fn; 214 if (!fn) 215 { 216 tree name = get_identifier ("__cxa_bad_typeid"); 217 fn = get_global_binding (name); 218 if (!fn) 219 { 220 tree t = build_reference_type (const_type_info_type_node); 221 t = build_function_type_list (t, NULL_TREE); 222 fn = push_throw_library_fn (name, t); 223 } 224 } 225 226 return build_cxx_call (fn, 0, NULL, tf_warning_or_error); 227} 228 229/* const type_info*. */ 230 231inline tree 232type_info_ptr_type () 233{ 234 return build_pointer_type (const_type_info_type_node); 235} 236 237/* Return a pointer to a type_info object describing TYPE, suitably 238 cast to the language defined type (for typeid) or void (for building 239 up the descriptors). */ 240 241static tree 242get_tinfo_ptr (tree type, bool voidp = false) 243{ 244 tree decl = get_tinfo_decl (type); 245 mark_used (decl); 246 247 tree ptype = voidp ? const_ptr_type_node : type_info_ptr_type (); 248 return build_nop (ptype, build_address (decl)); 249} 250static inline tree 251get_void_tinfo_ptr (tree type) 252{ 253 return get_tinfo_ptr (type, true); 254} 255 256/* Return an lvalue expression whose type is "const std::type_info" 257 and whose value indicates the type of the expression EXP. If EXP 258 is a reference to a polymorphic class, return the dynamic type; 259 otherwise return the static type of the expression. */ 260 261static tree 262get_tinfo_decl_dynamic (tree exp, tsubst_flags_t complain) 263{ 264 tree type; 265 tree t; 266 267 if (error_operand_p (exp)) 268 return error_mark_node; 269 270 exp = resolve_nondeduced_context (exp, complain); 271 272 /* Peel back references, so they match. */ 273 type = non_reference (unlowered_expr_type (exp)); 274 275 /* Peel off cv qualifiers. */ 276 type = cv_unqualified (type); 277 278 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */ 279 if (CLASS_TYPE_P (type) || type == unknown_type_node 280 || type == init_list_type_node) 281 type = complete_type_or_maybe_complain (type, exp, complain); 282 283 if (!type) 284 return error_mark_node; 285 286 /* If exp is a reference to polymorphic type, get the real type_info. */ 287 if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0)) 288 { 289 /* build reference to type_info from vtable. */ 290 tree index; 291 292 /* The RTTI information is at index -1. */ 293 index = build_int_cst (NULL_TREE, 294 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE); 295 t = build_vtbl_ref (exp, index); 296 t = convert (type_info_ptr_type (), t); 297 } 298 else 299 /* Otherwise return the type_info for the static type of the expr. */ 300 t = get_tinfo_ptr (type); 301 302 return cp_build_fold_indirect_ref (t); 303} 304 305static bool 306typeid_ok_p (void) 307{ 308 if (! flag_rtti) 309 { 310 error ("cannot use %<typeid%> with %<-fno-rtti%>"); 311 return false; 312 } 313 314 if (!const_type_info_type_node) 315 { 316 tree name = get_identifier ("type_info"); 317 tree decl = lookup_qualified_name (std_node, name); 318 if (TREE_CODE (decl) != TYPE_DECL) 319 { 320 gcc_rich_location richloc (input_location); 321 maybe_add_include_fixit (&richloc, "<typeinfo>", false); 322 error_at (&richloc, 323 "must %<#include <typeinfo>%> before using" 324 " %<typeid%>"); 325 326 return false; 327 } 328 const_type_info_type_node 329 = cp_build_qualified_type (TREE_TYPE (decl), TYPE_QUAL_CONST); 330 } 331 332 tree pseudo = TYPE_MAIN_VARIANT (get_tinfo_desc (TK_TYPE_INFO_TYPE)->type); 333 tree real = TYPE_MAIN_VARIANT (const_type_info_type_node); 334 335 /* Make sure abi::__type_info_pseudo has the same alias set 336 as std::type_info. */ 337 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo)) 338 TYPE_ALIAS_SET (pseudo) = get_alias_set (real); 339 else 340 gcc_assert (TYPE_ALIAS_SET (pseudo) == get_alias_set (real)); 341 342 return true; 343} 344 345/* Return an expression for "typeid(EXP)". The expression returned is 346 an lvalue of type "const std::type_info". */ 347 348tree 349build_typeid (tree exp, tsubst_flags_t complain) 350{ 351 tree cond = NULL_TREE, initial_expr = exp; 352 int nonnull = 0; 353 354 if (exp == error_mark_node || !typeid_ok_p ()) 355 return error_mark_node; 356 357 if (processing_template_decl) 358 return build_min (TYPEID_EXPR, const_type_info_type_node, exp); 359 360 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exp)) 361 && ! resolves_to_fixed_type_p (exp, &nonnull) 362 && ! nonnull) 363 { 364 /* So we need to look into the vtable of the type of exp. 365 Make sure it isn't a null lvalue. */ 366 exp = cp_build_addr_expr (exp, complain); 367 exp = save_expr (exp); 368 cond = cp_convert (boolean_type_node, exp, complain); 369 exp = cp_build_fold_indirect_ref (exp); 370 } 371 372 exp = get_tinfo_decl_dynamic (exp, complain); 373 374 if (exp == error_mark_node) 375 return error_mark_node; 376 377 if (cond) 378 { 379 tree bad = throw_bad_typeid (); 380 381 exp = build3 (COND_EXPR, TREE_TYPE (exp), cond, exp, bad); 382 } 383 else 384 mark_type_use (initial_expr); 385 386 return exp; 387} 388 389/* Generate the NTBS name of a type. If MARK_PRIVATE, put a '*' in front so that 390 comparisons will be done by pointer rather than string comparison. */ 391static tree 392tinfo_name (tree type, bool mark_private) 393{ 394 const char *name; 395 int length; 396 tree name_string; 397 398 name = mangle_type_string (type); 399 length = strlen (name); 400 401 if (mark_private) 402 { 403 /* Inject '*' at beginning of name to force pointer comparison. */ 404 char* buf = (char*) XALLOCAVEC (char, length + 2); 405 buf[0] = '*'; 406 memcpy (buf + 1, name, length + 1); 407 name_string = build_string (length + 2, buf); 408 } 409 else 410 name_string = build_string (length + 1, name); 411 412 return fix_string_type (name_string); 413} 414 415/* Return a VAR_DECL for the internal ABI defined type_info object for 416 TYPE. You must arrange that the decl is mark_used, if actually use 417 it --- decls in vtables are only used if the vtable is output. */ 418 419tree 420get_tinfo_decl (tree type) 421{ 422 if (variably_modified_type_p (type, /*fn=*/NULL_TREE)) 423 { 424 error ("cannot create type information for type %qT because " 425 "it involves types of variable size", 426 type); 427 return error_mark_node; 428 } 429 430 if (TREE_CODE (type) == METHOD_TYPE) 431 type = build_function_type (TREE_TYPE (type), 432 TREE_CHAIN (TYPE_ARG_TYPES (type))); 433 434 return get_tinfo_decl_direct (type, NULL, -1); 435} 436 437/* Get or create a tinfo VAR_DECL directly from the provided information. 438 The caller must have already checked it is valid to do so. */ 439 440tree 441get_tinfo_decl_direct (tree type, tree name, int pseudo_ix) 442{ 443 /* For a class type, the variable is cached in the type node 444 itself. */ 445 tree d = NULL_TREE; 446 447 gcc_checking_assert (TREE_CODE (type) != METHOD_TYPE); 448 449 if (CLASS_TYPE_P (type)) 450 d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)); 451 452 if (!name) 453 name = mangle_typeinfo_for_type (type); 454 455 if (!CLASS_TYPE_P (type) || TYPE_TRANSPARENT_AGGR (type)) 456 d = get_global_binding (name); 457 458 if (!d) 459 { 460 /* Create it. */ 461 if (pseudo_ix < 0) 462 pseudo_ix = get_pseudo_ti_index (type); 463 464 const tinfo_s *ti = get_tinfo_desc (pseudo_ix); 465 466 d = build_lang_decl (VAR_DECL, name, ti->type); 467 SET_DECL_ASSEMBLER_NAME (d, name); 468 /* Remember the type it is for. */ 469 TREE_TYPE (name) = type; 470 DECL_TINFO_P (d) = 1; 471 DECL_ARTIFICIAL (d) = 1; 472 DECL_IGNORED_P (d) = 1; 473 TREE_READONLY (d) = 1; 474 TREE_STATIC (d) = 1; 475 /* Tell equal_address_to that different tinfo decls never 476 overlap. */ 477 if (vec_safe_is_empty (unemitted_tinfo_decls)) 478 DECL_ATTRIBUTES (d) 479 = build_tree_list (get_identifier ("non overlapping"), 480 NULL_TREE); 481 else 482 DECL_ATTRIBUTES (d) 483 = DECL_ATTRIBUTES ((*unemitted_tinfo_decls)[0]); 484 485 /* Mark the variable as undefined -- but remember that we can 486 define it later if we need to do so. */ 487 DECL_EXTERNAL (d) = 1; 488 DECL_NOT_REALLY_EXTERN (d) = 1; 489 set_linkage_according_to_type (type, d); 490 491 d = pushdecl_top_level_and_finish (d, NULL_TREE); 492 if (CLASS_TYPE_P (type)) 493 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d; 494 495 /* Add decl to the global array of tinfo decls. */ 496 vec_safe_push (unemitted_tinfo_decls, d); 497 } 498 499 return d; 500} 501 502/* Return the type_info object for TYPE. */ 503 504tree 505get_typeid (tree type, tsubst_flags_t complain) 506{ 507 if (type == error_mark_node || !typeid_ok_p ()) 508 return error_mark_node; 509 510 if (processing_template_decl) 511 return build_min (TYPEID_EXPR, const_type_info_type_node, type); 512 513 /* If the type of the type-id is a reference type, the result of the 514 typeid expression refers to a type_info object representing the 515 referenced type. */ 516 type = non_reference (type); 517 518 /* This is not one of the uses of a qualified function type in 8.3.5. */ 519 if (TREE_CODE (type) == FUNCTION_TYPE 520 && (type_memfn_quals (type) != TYPE_UNQUALIFIED 521 || type_memfn_rqual (type) != REF_QUAL_NONE)) 522 { 523 if (complain & tf_error) 524 error ("%<typeid%> of qualified function type %qT", type); 525 return error_mark_node; 526 } 527 528 /* The top-level cv-qualifiers of the lvalue expression or the type-id 529 that is the operand of typeid are always ignored. */ 530 type = cv_unqualified (type); 531 532 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */ 533 if (CLASS_TYPE_P (type) || type == unknown_type_node 534 || type == init_list_type_node) 535 type = complete_type_or_maybe_complain (type, NULL_TREE, complain); 536 537 if (!type) 538 return error_mark_node; 539 540 return cp_build_fold_indirect_ref (get_tinfo_ptr (type)); 541} 542 543/* Check whether TEST is null before returning RESULT. If TEST is used in 544 RESULT, it must have previously had a save_expr applied to it. */ 545 546tree 547build_if_nonnull (tree test, tree result, tsubst_flags_t complain) 548{ 549 tree null_ptr = cp_convert (TREE_TYPE (test), nullptr_node, complain); 550 tree cond = build2 (NE_EXPR, boolean_type_node, test, null_ptr); 551 552 /* This is a compiler generated comparison, don't emit 553 e.g. -Wnonnull-compare warning for it. */ 554 suppress_warning (cond, OPT_Wnonnull); 555 556 null_ptr = cp_convert (TREE_TYPE (result), nullptr_node, complain); 557 cond = build3 (COND_EXPR, TREE_TYPE (result), cond, result, null_ptr); 558 559 /* Likewise, don't emit -Wnonnull for using the result to call 560 a member function. */ 561 suppress_warning (cond, OPT_Wnonnull); 562 return cond; 563} 564 565/* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working 566 paper. */ 567 568static tree 569build_dynamic_cast_1 (location_t loc, tree type, tree expr, 570 tsubst_flags_t complain) 571{ 572 enum tree_code tc = TREE_CODE (type); 573 tree exprtype; 574 tree dcast_fn; 575 tree old_expr = expr; 576 const char *errstr = NULL; 577 578 /* Save casted types in the function's used types hash table. */ 579 used_types_insert (type); 580 581 /* T shall be a pointer or reference to a complete class type, or 582 `pointer to cv void''. */ 583 switch (tc) 584 { 585 case POINTER_TYPE: 586 if (VOID_TYPE_P (TREE_TYPE (type))) 587 break; 588 /* Fall through. */ 589 case REFERENCE_TYPE: 590 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type))) 591 { 592 errstr = _("target is not pointer or reference to class"); 593 goto fail; 594 } 595 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type)))) 596 { 597 errstr = _("target is not pointer or reference to complete type"); 598 goto fail; 599 } 600 break; 601 602 default: 603 errstr = _("target is not pointer or reference"); 604 goto fail; 605 } 606 607 if (tc == POINTER_TYPE) 608 { 609 expr = decay_conversion (expr, complain); 610 exprtype = TREE_TYPE (expr); 611 612 /* If T is a pointer type, v shall be an rvalue of a pointer to 613 complete class type, and the result is an rvalue of type T. */ 614 615 expr = mark_rvalue_use (expr); 616 617 if (!TYPE_PTR_P (exprtype)) 618 { 619 errstr = _("source is not a pointer"); 620 goto fail; 621 } 622 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype))) 623 { 624 errstr = _("source is not a pointer to class"); 625 goto fail; 626 } 627 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype)))) 628 { 629 errstr = _("source is a pointer to incomplete type"); 630 goto fail; 631 } 632 } 633 else 634 { 635 expr = mark_lvalue_use (expr); 636 exprtype = TREE_TYPE (expr); 637 638 /* T is a reference type, v shall be an lvalue of a complete class 639 type, and the result is an lvalue of the type referred to by T. */ 640 if (! MAYBE_CLASS_TYPE_P (exprtype)) 641 { 642 errstr = _("source is not of class type"); 643 goto fail; 644 } 645 if (!COMPLETE_TYPE_P (complete_type (exprtype))) 646 { 647 errstr = _("source is of incomplete class type"); 648 goto fail; 649 } 650 651 exprtype = cp_build_reference_type (exprtype, !lvalue_p (expr)); 652 } 653 654 /* The dynamic_cast operator shall not cast away constness. */ 655 if (!at_least_as_qualified_p (TREE_TYPE (type), 656 TREE_TYPE (exprtype))) 657 { 658 errstr = _("conversion casts away constness"); 659 goto fail; 660 } 661 662 /* If *type is an unambiguous accessible base class of *exprtype, 663 convert statically. */ 664 { 665 tree binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type), 666 ba_check, NULL, complain); 667 if (binfo) 668 return build_static_cast (loc, type, expr, complain); 669 } 670 671 /* Apply trivial conversion T -> T& for dereferenced ptrs. */ 672 if (tc == REFERENCE_TYPE) 673 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT, 674 LOOKUP_NORMAL, NULL_TREE, complain); 675 676 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */ 677 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype))) 678 { 679 tree expr1; 680 /* if TYPE is `void *', return pointer to complete object. */ 681 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type))) 682 { 683 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */ 684 if (TREE_CODE (expr) == ADDR_EXPR 685 && VAR_P (TREE_OPERAND (expr, 0)) 686 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE) 687 return build1 (NOP_EXPR, type, expr); 688 689 /* Since expr is used twice below, save it. */ 690 expr = save_expr (expr); 691 692 expr1 = build_headof (expr); 693 if (TREE_TYPE (expr1) != type) 694 expr1 = build1 (NOP_EXPR, type, expr1); 695 return build_if_nonnull (expr, expr1, complain); 696 } 697 else 698 { 699 tree retval; 700 tree result, td2, td3; 701 tree elems[4]; 702 tree static_type, target_type, boff; 703 704 /* If we got here, we can't convert statically. Therefore, 705 dynamic_cast<D&>(b) (b an object) cannot succeed. */ 706 if (tc == REFERENCE_TYPE) 707 { 708 if (VAR_P (old_expr) 709 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE) 710 { 711 tree expr = throw_bad_cast (); 712 if (complain & tf_warning) 713 warning_at (loc, 0, 714 "%<dynamic_cast<%#T>(%#D)%> can never succeed", 715 type, old_expr); 716 /* Bash it to the expected type. */ 717 TREE_TYPE (expr) = type; 718 return expr; 719 } 720 } 721 /* Ditto for dynamic_cast<D*>(&b). */ 722 else if (TREE_CODE (expr) == ADDR_EXPR) 723 { 724 tree op = TREE_OPERAND (expr, 0); 725 if (VAR_P (op) 726 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE) 727 { 728 if (complain & tf_warning) 729 warning_at (loc, 0, 730 "%<dynamic_cast<%#T>(%#D)%> can never succeed", 731 type, op); 732 retval = build_int_cst (type, 0); 733 return retval; 734 } 735 } 736 737 /* Use of dynamic_cast when -fno-rtti is prohibited. */ 738 if (!flag_rtti) 739 { 740 if (complain & tf_error) 741 error_at (loc, 742 "%<dynamic_cast%> not permitted with %<-fno-rtti%>"); 743 return error_mark_node; 744 } 745 746 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 747 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype)); 748 td2 = get_tinfo_decl (target_type); 749 if (!mark_used (td2, complain) && !(complain & tf_error)) 750 return error_mark_node; 751 td2 = cp_build_addr_expr (td2, complain); 752 td3 = get_tinfo_decl (static_type); 753 if (!mark_used (td3, complain) && !(complain & tf_error)) 754 return error_mark_node; 755 td3 = cp_build_addr_expr (td3, complain); 756 757 /* Determine how T and V are related. */ 758 boff = dcast_base_hint (static_type, target_type); 759 760 /* Since expr is used twice below, save it. */ 761 expr = save_expr (expr); 762 763 expr1 = expr; 764 if (tc == REFERENCE_TYPE) 765 expr1 = cp_build_addr_expr (expr1, complain); 766 767 elems[0] = expr1; 768 elems[1] = td3; 769 elems[2] = td2; 770 elems[3] = boff; 771 772 dcast_fn = dynamic_cast_node; 773 if (!dcast_fn) 774 { 775 unsigned flags = push_abi_namespace (); 776 tree tinfo_ptr = xref_tag (class_type, 777 get_identifier ("__class_type_info")); 778 tinfo_ptr = cp_build_qualified_type (tinfo_ptr, TYPE_QUAL_CONST); 779 tinfo_ptr = build_pointer_type (tinfo_ptr); 780 781 const char *fn_name = "__dynamic_cast"; 782 /* void *() (void const *, __class_type_info const *, 783 __class_type_info const *, ptrdiff_t) */ 784 tree fn_type = (build_function_type_list 785 (ptr_type_node, const_ptr_type_node, 786 tinfo_ptr, tinfo_ptr, ptrdiff_type_node, 787 NULL_TREE)); 788 dcast_fn = (build_library_fn_ptr 789 (fn_name, fn_type, ECF_LEAF | ECF_PURE | ECF_NOTHROW)); 790 pop_abi_namespace (flags); 791 dynamic_cast_node = dcast_fn; 792 } 793 result = build_cxx_call (dcast_fn, 4, elems, complain); 794 SET_EXPR_LOCATION (result, loc); 795 796 if (tc == REFERENCE_TYPE) 797 { 798 tree bad = throw_bad_cast (); 799 tree neq; 800 801 result = save_expr (result); 802 neq = cp_truthvalue_conversion (result, complain); 803 return cp_convert (type, 804 build3 (COND_EXPR, TREE_TYPE (result), 805 neq, result, bad), complain); 806 } 807 808 /* Now back to the type we want from a void*. */ 809 result = cp_convert (type, result, complain); 810 return build_if_nonnull (expr, result, complain); 811 } 812 } 813 else 814 errstr = _("source type is not polymorphic"); 815 816 fail: 817 if (complain & tf_error) 818 error_at (loc, "cannot %<dynamic_cast%> %qE (of type %q#T) " 819 "to type %q#T (%s)", 820 old_expr, TREE_TYPE (old_expr), type, errstr); 821 return error_mark_node; 822} 823 824tree 825build_dynamic_cast (location_t loc, tree type, tree expr, 826 tsubst_flags_t complain) 827{ 828 tree r; 829 830 if (type == error_mark_node || expr == error_mark_node) 831 return error_mark_node; 832 833 if (processing_template_decl) 834 { 835 expr = build_min (DYNAMIC_CAST_EXPR, type, expr); 836 TREE_SIDE_EFFECTS (expr) = 1; 837 r = convert_from_reference (expr); 838 protected_set_expr_location (r, loc); 839 return r; 840 } 841 842 r = convert_from_reference (build_dynamic_cast_1 (loc, type, expr, 843 complain)); 844 if (r != error_mark_node) 845 maybe_warn_about_useless_cast (loc, type, expr, complain); 846 protected_set_expr_location (r, loc); 847 return r; 848} 849 850/* Return the runtime bit mask encoding the qualifiers of TYPE. */ 851 852static int 853qualifier_flags (tree type) 854{ 855 int flags = 0; 856 int quals = cp_type_quals (type); 857 858 if (quals & TYPE_QUAL_CONST) 859 flags |= 1; 860 if (quals & TYPE_QUAL_VOLATILE) 861 flags |= 2; 862 if (quals & TYPE_QUAL_RESTRICT) 863 flags |= 4; 864 return flags; 865} 866 867/* Return true, if the pointer chain TYPE ends at an incomplete type, or 868 contains a pointer to member of an incomplete class. */ 869 870static bool 871target_incomplete_p (tree type) 872{ 873 while (true) 874 if (TYPE_PTRDATAMEM_P (type)) 875 { 876 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type))) 877 return true; 878 type = TYPE_PTRMEM_POINTED_TO_TYPE (type); 879 } 880 else if (TYPE_PTR_P (type)) 881 type = TREE_TYPE (type); 882 else 883 return !COMPLETE_OR_VOID_TYPE_P (type); 884} 885 886/* Returns true if TYPE involves an incomplete class type; in that 887 case, typeinfo variables for TYPE should be emitted with internal 888 linkage. */ 889 890static bool 891involves_incomplete_p (tree type) 892{ 893 switch (TREE_CODE (type)) 894 { 895 case POINTER_TYPE: 896 return target_incomplete_p (TREE_TYPE (type)); 897 898 case OFFSET_TYPE: 899 ptrmem: 900 return 901 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type)) 902 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type))); 903 904 case RECORD_TYPE: 905 if (TYPE_PTRMEMFUNC_P (type)) 906 goto ptrmem; 907 /* Fall through. */ 908 case UNION_TYPE: 909 if (!COMPLETE_TYPE_P (type)) 910 return true; 911 /* Fall through. */ 912 default: 913 /* All other types do not involve incomplete class types. */ 914 return false; 915 } 916} 917 918/* Return a CONSTRUCTOR for the common part of the type_info objects. This 919 is the vtable pointer and NTBS name. The NTBS name is emitted as a 920 comdat const char array, so it becomes a unique key for the type. Generate 921 and emit that VAR_DECL here. (We can't always emit the type_info itself 922 as comdat, because of pointers to incomplete.) */ 923 924static tree 925tinfo_base_init (tinfo_s *ti, tree target) 926{ 927 tree init; 928 tree name_decl; 929 tree vtable_ptr; 930 vec<constructor_elt, va_gc> *v; 931 932 { 933 tree name_name, name_string; 934 935 /* Generate the NTBS array variable. */ 936 tree name_type = build_cplus_array_type 937 (cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST), 938 NULL_TREE); 939 940 /* Determine the name of the variable -- and remember with which 941 type it is associated. */ 942 name_name = mangle_typeinfo_string_for_type (target); 943 TREE_TYPE (name_name) = target; 944 945 name_decl = build_lang_decl (VAR_DECL, name_name, name_type); 946 SET_DECL_ASSEMBLER_NAME (name_decl, name_name); 947 DECL_ARTIFICIAL (name_decl) = 1; 948 DECL_IGNORED_P (name_decl) = 1; 949 TREE_READONLY (name_decl) = 1; 950 TREE_STATIC (name_decl) = 1; 951 DECL_EXTERNAL (name_decl) = 0; 952 DECL_TINFO_P (name_decl) = 1; 953 set_linkage_according_to_type (target, name_decl); 954 import_export_decl (name_decl); 955 name_string = tinfo_name (target, !TREE_PUBLIC (name_decl)); 956 DECL_INITIAL (name_decl) = name_string; 957 mark_used (name_decl); 958 pushdecl_top_level_and_finish (name_decl, name_string); 959 } 960 961 vtable_ptr = ti->vtable; 962 if (!vtable_ptr) 963 { 964 int flags = push_abi_namespace (); 965 tree real_type = xref_tag (class_type, ti->name); 966 tree real_decl = TYPE_NAME (real_type); 967 DECL_SOURCE_LOCATION (real_decl) = BUILTINS_LOCATION; 968 pop_abi_namespace (flags); 969 970 if (!COMPLETE_TYPE_P (real_type)) 971 { 972 /* We never saw a definition of this type, so we need to 973 tell the compiler that this is an exported class, as 974 indeed all of the __*_type_info classes are. */ 975 SET_CLASSTYPE_INTERFACE_KNOWN (real_type); 976 CLASSTYPE_INTERFACE_ONLY (real_type) = 1; 977 } 978 979 vtable_ptr = get_vtable_decl (real_type, /*complete=*/1); 980 vtable_ptr = cp_build_addr_expr (vtable_ptr, tf_warning_or_error); 981 982 /* We need to point into the middle of the vtable. */ 983 vtable_ptr = fold_build_pointer_plus 984 (vtable_ptr, 985 size_binop (MULT_EXPR, 986 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE), 987 TYPE_SIZE_UNIT (vtable_entry_type))); 988 989 ti->vtable = vtable_ptr; 990 } 991 992 vec_alloc (v, 2); 993 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, vtable_ptr); 994 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 995 decay_conversion (name_decl, tf_warning_or_error)); 996 997 init = build_constructor (init_list_type_node, v); 998 TREE_CONSTANT (init) = 1; 999 TREE_STATIC (init) = 1; 1000 1001 return init; 1002} 1003 1004/* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the 1005 information about the particular type_info derivation, which adds no 1006 additional fields to the type_info base. */ 1007 1008static tree 1009generic_initializer (tinfo_s *ti, tree target) 1010{ 1011 tree init = tinfo_base_init (ti, target); 1012 1013 init = build_constructor_single (init_list_type_node, NULL_TREE, init); 1014 TREE_CONSTANT (init) = 1; 1015 TREE_STATIC (init) = 1; 1016 return init; 1017} 1018 1019/* Return the CONSTRUCTOR expr for a type_info of pointer TYPE. 1020 TI provides information about the particular type_info derivation, 1021 which adds target type and qualifier flags members to the type_info base. */ 1022 1023static tree 1024ptr_initializer (tinfo_s *ti, tree target) 1025{ 1026 tree init = tinfo_base_init (ti, target); 1027 tree to = TREE_TYPE (target); 1028 int flags = qualifier_flags (to); 1029 bool incomplete = target_incomplete_p (to); 1030 vec<constructor_elt, va_gc> *v; 1031 vec_alloc (v, 3); 1032 1033 if (incomplete) 1034 flags |= 8; 1035 if (tx_safe_fn_type_p (to)) 1036 { 1037 flags |= 0x20; 1038 to = tx_unsafe_fn_variant (to); 1039 } 1040 if (flag_noexcept_type 1041 && FUNC_OR_METHOD_TYPE_P (to) 1042 && TYPE_NOTHROW_P (to)) 1043 { 1044 flags |= 0x40; 1045 to = build_exception_variant (to, NULL_TREE); 1046 } 1047 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init); 1048 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, flags)); 1049 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 1050 get_void_tinfo_ptr (TYPE_MAIN_VARIANT (to))); 1051 1052 init = build_constructor (init_list_type_node, v); 1053 TREE_CONSTANT (init) = 1; 1054 TREE_STATIC (init) = 1; 1055 return init; 1056} 1057 1058/* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE. 1059 TI provides information about the particular type_info derivation, 1060 which adds class, target type and qualifier flags members to the type_info 1061 base. */ 1062 1063static tree 1064ptm_initializer (tinfo_s *ti, tree target) 1065{ 1066 tree init = tinfo_base_init (ti, target); 1067 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target); 1068 tree klass = TYPE_PTRMEM_CLASS_TYPE (target); 1069 int flags = qualifier_flags (to); 1070 bool incomplete = target_incomplete_p (to); 1071 vec<constructor_elt, va_gc> *v; 1072 vec_alloc (v, 4); 1073 1074 if (incomplete) 1075 flags |= 0x8; 1076 if (!COMPLETE_TYPE_P (klass)) 1077 flags |= 0x10; 1078 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init); 1079 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, flags)); 1080 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 1081 get_void_tinfo_ptr (TYPE_MAIN_VARIANT (to))); 1082 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, get_void_tinfo_ptr (klass)); 1083 1084 init = build_constructor (init_list_type_node, v); 1085 TREE_CONSTANT (init) = 1; 1086 TREE_STATIC (init) = 1; 1087 return init; 1088} 1089 1090/* Return the CONSTRUCTOR expr for a type_info of class TYPE. 1091 TI provides information about the particular __class_type_info derivation, 1092 which adds hint flags and N extra initializers to the type_info base. */ 1093 1094static tree 1095class_initializer (tinfo_s *ti, tree target, unsigned n, ...) 1096{ 1097 tree init = tinfo_base_init (ti, target); 1098 va_list extra_inits; 1099 unsigned i; 1100 vec<constructor_elt, va_gc> *v; 1101 vec_alloc (v, n+1); 1102 1103 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init); 1104 va_start (extra_inits, n); 1105 for (i = 0; i < n; i++) 1106 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, va_arg (extra_inits, tree)); 1107 va_end (extra_inits); 1108 1109 init = build_constructor (init_list_type_node, v); 1110 TREE_CONSTANT (init) = 1; 1111 TREE_STATIC (init) = 1; 1112 return init; 1113} 1114 1115/* Returns true if the typeinfo for type should be placed in 1116 the runtime library. */ 1117 1118static bool 1119typeinfo_in_lib_p (tree type) 1120{ 1121 /* The typeinfo objects for `T*' and `const T*' are in the runtime 1122 library for simple types T. */ 1123 if (TYPE_PTR_P (type) 1124 && (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST 1125 || cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED)) 1126 type = TREE_TYPE (type); 1127 1128 switch (TREE_CODE (type)) 1129 { 1130 case INTEGER_TYPE: 1131 case BOOLEAN_TYPE: 1132 case REAL_TYPE: 1133 case VOID_TYPE: 1134 case NULLPTR_TYPE: 1135 return true; 1136 1137 case LANG_TYPE: 1138 /* fall through. */ 1139 1140 default: 1141 return false; 1142 } 1143} 1144 1145/* Generate the initializer for the type info describing TYPE. TK_INDEX is 1146 the index of the descriptor in the tinfo_desc vector. */ 1147 1148static tree 1149get_pseudo_ti_init (tree type, unsigned tk_index) 1150{ 1151 tinfo_s *ti = get_tinfo_desc (tk_index); 1152 1153 gcc_assert (at_eof); 1154 switch (tk_index) 1155 { 1156 case TK_POINTER_MEMBER_TYPE: 1157 return ptm_initializer (ti, type); 1158 1159 case TK_POINTER_TYPE: 1160 return ptr_initializer (ti, type); 1161 1162 case TK_BUILTIN_TYPE: 1163 case TK_ENUMERAL_TYPE: 1164 case TK_FUNCTION_TYPE: 1165 case TK_ARRAY_TYPE: 1166 return generic_initializer (ti, type); 1167 1168 case TK_CLASS_TYPE: 1169 return class_initializer (ti, type, 0); 1170 1171 case TK_SI_CLASS_TYPE: 1172 { 1173 tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), 0); 1174 tree tinfo = get_void_tinfo_ptr (BINFO_TYPE (base_binfo)); 1175 1176 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */ 1177 ti = &(*tinfo_descs)[tk_index]; 1178 return class_initializer (ti, type, 1, tinfo); 1179 } 1180 1181 default: 1182 { 1183 int hint = ((CLASSTYPE_REPEATED_BASE_P (type) << 0) 1184 | (CLASSTYPE_DIAMOND_SHAPED_P (type) << 1)); 1185 tree binfo = TYPE_BINFO (type); 1186 unsigned nbases = BINFO_N_BASE_BINFOS (binfo); 1187 vec<tree, va_gc> *base_accesses = BINFO_BASE_ACCESSES (binfo); 1188 tree offset_type = LONGPTR_T; 1189 vec<constructor_elt, va_gc> *init_vec = NULL; 1190 1191 gcc_assert (tk_index - TK_VMI_CLASS_TYPES + 1 == nbases); 1192 1193 vec_safe_grow (init_vec, nbases, true); 1194 /* Generate the base information initializer. */ 1195 for (unsigned ix = nbases; ix--;) 1196 { 1197 tree base_binfo = BINFO_BASE_BINFO (binfo, ix); 1198 int flags = 0; 1199 tree tinfo; 1200 tree offset; 1201 vec<constructor_elt, va_gc> *v; 1202 1203 if ((*base_accesses)[ix] == access_public_node) 1204 flags |= 2; 1205 tinfo = get_void_tinfo_ptr (BINFO_TYPE (base_binfo)); 1206 if (BINFO_VIRTUAL_P (base_binfo)) 1207 { 1208 /* We store the vtable offset at which the virtual 1209 base offset can be found. */ 1210 offset = BINFO_VPTR_FIELD (base_binfo); 1211 flags |= 1; 1212 } 1213 else 1214 offset = BINFO_OFFSET (base_binfo); 1215 1216 /* Combine offset and flags into one field. */ 1217 offset = fold_convert (offset_type, offset); 1218 offset = fold_build2_loc (input_location, 1219 LSHIFT_EXPR, offset_type, offset, 1220 build_int_cst (offset_type, 8)); 1221 offset = fold_build2_loc (input_location, 1222 BIT_IOR_EXPR, offset_type, offset, 1223 build_int_cst (offset_type, flags)); 1224 vec_alloc (v, 2); 1225 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, tinfo); 1226 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, offset); 1227 tree base_init = build_constructor (init_list_type_node, v); 1228 constructor_elt *e = &(*init_vec)[ix]; 1229 e->index = NULL_TREE; 1230 e->value = base_init; 1231 } 1232 tree base_inits = build_constructor (init_list_type_node, init_vec); 1233 1234 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */ 1235 ti = &(*tinfo_descs)[tk_index]; 1236 return class_initializer (ti, type, 3, 1237 build_int_cst (NULL_TREE, hint), 1238 build_int_cst (NULL_TREE, nbases), 1239 base_inits); 1240 } 1241 } 1242} 1243 1244/* Return the index of a pseudo type info type node used to describe 1245 TYPE. TYPE must be a complete type (or cv void), except at the end 1246 of the translation unit. */ 1247 1248static unsigned 1249get_pseudo_ti_index (tree type) 1250{ 1251 unsigned ix; 1252 1253 switch (TREE_CODE (type)) 1254 { 1255 case OFFSET_TYPE: 1256 ix = TK_POINTER_MEMBER_TYPE; 1257 break; 1258 1259 case POINTER_TYPE: 1260 ix = TK_POINTER_TYPE; 1261 break; 1262 1263 case ENUMERAL_TYPE: 1264 ix = TK_ENUMERAL_TYPE; 1265 break; 1266 1267 case FUNCTION_TYPE: 1268 ix = TK_FUNCTION_TYPE; 1269 break; 1270 1271 case ARRAY_TYPE: 1272 ix = TK_ARRAY_TYPE; 1273 break; 1274 1275 case UNION_TYPE: 1276 case RECORD_TYPE: 1277 if (TYPE_PTRMEMFUNC_P (type)) 1278 ix = TK_POINTER_MEMBER_TYPE; 1279 else if (!COMPLETE_TYPE_P (type)) 1280 { 1281 if (!at_eof) 1282 cxx_incomplete_type_error (NULL_TREE, type); 1283 ix = TK_CLASS_TYPE; 1284 } 1285 else if (!TYPE_BINFO (type) 1286 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type))) 1287 ix = TK_CLASS_TYPE; 1288 else 1289 { 1290 tree binfo = TYPE_BINFO (type); 1291 vec<tree, va_gc> *base_accesses = BINFO_BASE_ACCESSES (binfo); 1292 tree base_binfo = BINFO_BASE_BINFO (binfo, 0); 1293 int num_bases = BINFO_N_BASE_BINFOS (binfo); 1294 1295 if (num_bases == 1 1296 && (*base_accesses)[0] == access_public_node 1297 && !BINFO_VIRTUAL_P (base_binfo) 1298 && integer_zerop (BINFO_OFFSET (base_binfo))) 1299 /* single non-virtual public. */ 1300 ix = TK_SI_CLASS_TYPE; 1301 else 1302 ix = TK_VMI_CLASS_TYPES + num_bases - 1; 1303 } 1304 break; 1305 1306 default: 1307 ix = TK_BUILTIN_TYPE; 1308 break; 1309 } 1310 return ix; 1311} 1312 1313/* Return pointer to tinfo descriptor. Possibly creating the tinfo 1314 descriptor in the first place. */ 1315 1316static tinfo_s * 1317get_tinfo_desc (unsigned ix) 1318{ 1319 unsigned len = tinfo_descs->length (); 1320 1321 if (len <= ix) 1322 { 1323 /* too short, extend. */ 1324 len = ix + 1 - len; 1325 vec_safe_reserve (tinfo_descs, len); 1326 tinfo_s elt; 1327 elt.type = elt.vtable = elt.name = NULL_TREE; 1328 while (len--) 1329 tinfo_descs->quick_push (elt); 1330 } 1331 1332 tinfo_s *res = &(*tinfo_descs)[ix]; 1333 1334 if (res->type) 1335 return res; 1336 1337 /* Ok, we have to create it. This layout must be consistent with 1338 that defined in the runtime support. We explicitly manage the 1339 vtable member, and name it for real type as used in the runtime. 1340 The RECORD type has a different name, to avoid collisions. We 1341 have to delay generating the VAR_DECL of the vtable until the end 1342 of the translation, when we'll have seen the library definition, 1343 if there was one. */ 1344 1345 /* Fields to add, chained in reverse order. */ 1346 tree fields = NULL_TREE; 1347 1348 if (ix >= TK_DERIVED_TYPES) 1349 { 1350 /* First field is the pseudo type_info base class. */ 1351 tree fld_base = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 1352 get_tinfo_desc (TK_TYPE_INFO_TYPE)->type); 1353 1354 DECL_CHAIN (fld_base) = fields; 1355 fields = fld_base; 1356 } 1357 1358 switch (ix) 1359 { 1360 case TK_TYPE_INFO_TYPE: 1361 { 1362 tree fld_ptr = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1363 NULL_TREE, const_ptr_type_node); 1364 fields = fld_ptr; 1365 1366 tree fld_str = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1367 NULL_TREE, const_string_type_node); 1368 DECL_CHAIN (fld_str) = fields; 1369 fields = fld_str; 1370 break; 1371 } 1372 1373 case TK_BASE_TYPE: 1374 { 1375 /* Base class internal helper. Pointer to base type, offset to 1376 base, flags. */ 1377 tree fld_ptr = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1378 NULL_TREE, const_ptr_type_node); 1379 DECL_CHAIN (fld_ptr) = fields; 1380 fields = fld_ptr; 1381 1382 tree fld_flag = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1383 NULL_TREE, LONGPTR_T); 1384 DECL_CHAIN (fld_flag) = fields; 1385 fields = fld_flag; 1386 break; 1387 } 1388 1389 case TK_BUILTIN_TYPE: 1390 /* Fundamental type_info */ 1391 break; 1392 1393 case TK_ARRAY_TYPE: 1394 break; 1395 1396 case TK_FUNCTION_TYPE: 1397 break; 1398 1399 case TK_ENUMERAL_TYPE: 1400 break; 1401 1402 case TK_POINTER_TYPE: 1403 case TK_POINTER_MEMBER_TYPE: 1404 { 1405 /* Pointer type_info. Adds two fields, qualification mask and 1406 pointer to the pointed to type. This is really a 1407 descendant of __pbase_type_info. */ 1408 tree fld_mask = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1409 NULL_TREE, integer_type_node); 1410 DECL_CHAIN (fld_mask) = fields; 1411 fields = fld_mask; 1412 1413 tree fld_ptr = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1414 NULL_TREE, const_ptr_type_node); 1415 DECL_CHAIN (fld_ptr) = fields; 1416 fields = fld_ptr; 1417 1418 if (ix == TK_POINTER_MEMBER_TYPE) 1419 { 1420 /* Add a pointer to the class too. */ 1421 tree fld_cls = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1422 NULL_TREE, const_ptr_type_node); 1423 DECL_CHAIN (fld_cls) = fields; 1424 fields = fld_cls; 1425 } 1426 break; 1427 } 1428 1429 case TK_CLASS_TYPE: 1430 /* Class type_info. No additional fields. */ 1431 break; 1432 1433 case TK_SI_CLASS_TYPE: 1434 { 1435 /* Single public non-virtual base class. Add pointer to base 1436 class. This is really a descendant of 1437 __class_type_info. */ 1438 tree fld_ptr = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1439 NULL_TREE, const_ptr_type_node); 1440 DECL_CHAIN (fld_ptr) = fields; 1441 fields = fld_ptr; 1442 break; 1443 } 1444 1445 default: /* Multiple inheritance. */ 1446 { 1447 unsigned num_bases = ix - TK_VMI_CLASS_TYPES + 1; 1448 1449 tree fld_flg = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1450 NULL_TREE, integer_type_node); 1451 DECL_CHAIN (fld_flg) = fields; 1452 fields = fld_flg; 1453 1454 tree fld_cnt = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1455 NULL_TREE, integer_type_node); 1456 DECL_CHAIN (fld_cnt) = fields; 1457 fields = fld_cnt; 1458 1459 /* Create the array of __base_class_type_info entries. */ 1460 tree domain = build_index_type (size_int (num_bases - 1)); 1461 tree array = build_array_type (get_tinfo_desc (TK_BASE_TYPE)->type, 1462 domain); 1463 tree fld_ary = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1464 NULL_TREE, array); 1465 DECL_CHAIN (fld_ary) = fields; 1466 fields = fld_ary; 1467 break; 1468 } 1469 } 1470 1471 /* Generate the pseudo type name. */ 1472 const char *real_name = tinfo_names[ix < TK_VMI_CLASS_TYPES 1473 ? ix : unsigned (TK_VMI_CLASS_TYPES)]; 1474 size_t name_len = strlen (real_name); 1475 char *pseudo_name = (char *) alloca (name_len + 30); 1476 memcpy (pseudo_name, real_name, name_len); 1477 /* Those >= TK_VMI_CLASS_TYPES need a discriminator, may as well 1478 apply it to all. See get_peudo_tinfo_index where we make use of 1479 this. */ 1480 sprintf (pseudo_name + name_len, "_pseudo_%d", ix); 1481 1482 /* Create the pseudo type. */ 1483 tree pseudo_type = make_class_type (RECORD_TYPE); 1484 /* Pass the fields chained in reverse. */ 1485 finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE); 1486 CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type; 1487 DECL_CONTEXT (TYPE_NAME (pseudo_type)) = FROB_CONTEXT (global_namespace); 1488 DECL_TINFO_P (TYPE_NAME (pseudo_type)) = true; 1489 xref_basetypes (pseudo_type, /*bases=*/NULL_TREE); 1490 1491 res->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST); 1492 res->name = get_identifier (real_name); 1493 1494 /* Pretend this is public so determine_visibility doesn't give vtables 1495 internal linkage. */ 1496 TREE_PUBLIC (TYPE_MAIN_DECL (res->type)) = 1; 1497 1498 return res; 1499} 1500 1501/* Return an identifying index for the pseudo type_info TYPE. 1502 We wrote the index at the end of the name, so just scan it from 1503 there. This isn't critical, as it's only on the first use of this 1504 type during module stream out. */ 1505 1506unsigned 1507get_pseudo_tinfo_index (tree type) 1508{ 1509 tree name = DECL_NAME (TYPE_NAME (type)); 1510 unsigned ix = 0, scale = 1; 1511 size_t len = IDENTIFIER_LENGTH (name); 1512 const char *ptr = IDENTIFIER_POINTER (name) + len; 1513 1514 for (; *--ptr != '_'; scale *= 10) 1515 { 1516 len--; 1517 gcc_checking_assert (len && ISDIGIT (*ptr)); 1518 ix += (*ptr - '0') * scale; 1519 } 1520 1521 gcc_assert (len != IDENTIFIER_LENGTH (name)); 1522 return ix; 1523} 1524 1525tree 1526get_pseudo_tinfo_type (unsigned ix) 1527{ 1528 return get_tinfo_desc (ix)->type; 1529} 1530 1531/* We lazily create the type info types. */ 1532 1533static void 1534create_tinfo_types (void) 1535{ 1536 gcc_assert (!tinfo_descs); 1537 1538 vec_alloc (tinfo_descs, TK_MAX + 20); 1539} 1540 1541/* Helper for emit_support_tinfos. Emits the type_info descriptor of 1542 a single type. */ 1543 1544void 1545emit_support_tinfo_1 (tree bltn) 1546{ 1547 tree types[3]; 1548 1549 if (bltn == NULL_TREE) 1550 return; 1551 types[0] = bltn; 1552 types[1] = build_pointer_type (bltn); 1553 types[2] = build_pointer_type (cp_build_qualified_type (bltn, 1554 TYPE_QUAL_CONST)); 1555 1556 for (int i = 0; i < 3; ++i) 1557 { 1558 tree tinfo = get_tinfo_decl (types[i]); 1559 TREE_USED (tinfo) = 1; 1560 mark_needed (tinfo); 1561 /* The C++ ABI requires that these objects be COMDAT. But, 1562 On systems without weak symbols, initialized COMDAT 1563 objects are emitted with internal linkage. (See 1564 comdat_linkage for details.) Since we want these objects 1565 to have external linkage so that copies do not have to be 1566 emitted in code outside the runtime library, we make them 1567 non-COMDAT here. 1568 1569 It might also not be necessary to follow this detail of the 1570 ABI. */ 1571 if (!flag_weak || ! targetm.cxx.library_rtti_comdat ()) 1572 { 1573 gcc_assert (TREE_PUBLIC (tinfo) && !DECL_COMDAT (tinfo)); 1574 DECL_INTERFACE_KNOWN (tinfo) = 1; 1575 } 1576 } 1577} 1578 1579/* Emit the type_info descriptors which are guaranteed to be in the runtime 1580 support. Generating them here guarantees consistency with the other 1581 structures. We use the following heuristic to determine when the runtime 1582 is being generated. If std::__fundamental_type_info is defined, and its 1583 destructor is defined, then the runtime is being built. */ 1584 1585void 1586emit_support_tinfos (void) 1587{ 1588 /* Dummy static variable so we can put nullptr in the array; it will be 1589 set before we actually start to walk the array. */ 1590 static tree *const fundamentals[] = 1591 { 1592 &void_type_node, 1593 &boolean_type_node, 1594 &wchar_type_node, &char8_type_node, &char16_type_node, &char32_type_node, 1595 &char_type_node, &signed_char_type_node, &unsigned_char_type_node, 1596 &short_integer_type_node, &short_unsigned_type_node, 1597 &integer_type_node, &unsigned_type_node, 1598 &long_integer_type_node, &long_unsigned_type_node, 1599 &long_long_integer_type_node, &long_long_unsigned_type_node, 1600 &float_type_node, &double_type_node, &long_double_type_node, 1601 &dfloat32_type_node, &dfloat64_type_node, &dfloat128_type_node, 1602 &nullptr_type_node, 1603 0 1604 }; 1605 int ix; 1606 1607 /* Look for a defined class. */ 1608 tree bltn_type = lookup_qualified_name 1609 (abi_node, "__fundamental_type_info", LOOK_want::TYPE, false); 1610 if (TREE_CODE (bltn_type) != TYPE_DECL) 1611 return; 1612 1613 bltn_type = TREE_TYPE (bltn_type); 1614 if (!COMPLETE_TYPE_P (bltn_type)) 1615 return; 1616 tree dtor = CLASSTYPE_DESTRUCTOR (bltn_type); 1617 if (!dtor || DECL_EXTERNAL (dtor)) 1618 return; 1619 1620 /* All these are really builtins. So set the location. */ 1621 location_t saved_loc = input_location; 1622 input_location = BUILTINS_LOCATION; 1623 doing_runtime = 1; 1624 for (ix = 0; fundamentals[ix]; ix++) 1625 emit_support_tinfo_1 (*fundamentals[ix]); 1626 for (ix = 0; ix < NUM_INT_N_ENTS; ix ++) 1627 if (int_n_enabled_p[ix]) 1628 { 1629 emit_support_tinfo_1 (int_n_trees[ix].signed_type); 1630 emit_support_tinfo_1 (int_n_trees[ix].unsigned_type); 1631 } 1632 for (tree t = registered_builtin_types; t; t = TREE_CHAIN (t)) 1633 emit_support_tinfo_1 (TREE_VALUE (t)); 1634 /* For compatibility, emit DFP typeinfos even when DFP isn't enabled, 1635 because we've emitted that in the past. */ 1636 if (!targetm.decimal_float_supported_p ()) 1637 { 1638 gcc_assert (dfloat32_type_node == NULL_TREE 1639 && dfloat64_type_node == NULL_TREE 1640 && dfloat128_type_node == NULL_TREE); 1641 fallback_dfloat32_type = make_node (REAL_TYPE); 1642 fallback_dfloat64_type = make_node (REAL_TYPE); 1643 fallback_dfloat128_type = make_node (REAL_TYPE); 1644 emit_support_tinfo_1 (fallback_dfloat32_type); 1645 emit_support_tinfo_1 (fallback_dfloat64_type); 1646 emit_support_tinfo_1 (fallback_dfloat128_type); 1647 } 1648 input_location = saved_loc; 1649} 1650 1651/* Finish a type info decl. DECL_PTR is a pointer to an unemitted 1652 tinfo decl. Determine whether it needs emitting, and if so 1653 generate the initializer. */ 1654 1655bool 1656emit_tinfo_decl (tree decl) 1657{ 1658 gcc_assert (DECL_TINFO_P (decl)); 1659 1660 tree type = TREE_TYPE (DECL_NAME (decl)); 1661 if (typeinfo_in_lib_p (type)) 1662 { 1663 if (doing_runtime) 1664 DECL_EXTERNAL (decl) = 0; 1665 else 1666 { 1667 /* If we're not in the runtime, then DECL (which is already 1668 DECL_EXTERNAL) will not be defined here. */ 1669 DECL_INTERFACE_KNOWN (decl) = 1; 1670 return false; 1671 } 1672 } 1673 else if (involves_incomplete_p (type)) 1674 { 1675 if (!decl_needed_p (decl)) 1676 return false; 1677 /* If TYPE involves an incomplete class type, then the typeinfo 1678 object will be emitted with internal linkage. There is no 1679 way to know whether or not types are incomplete until the end 1680 of the compilation, so this determination must be deferred 1681 until this point. */ 1682 TREE_PUBLIC (decl) = 0; 1683 DECL_EXTERNAL (decl) = 0; 1684 DECL_INTERFACE_KNOWN (decl) = 1; 1685 } 1686 1687 import_export_decl (decl); 1688 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl)) 1689 { 1690 tree init; 1691 1692 DECL_EXTERNAL (decl) = 0; 1693 int pseudo_ix = get_pseudo_ti_index (type); 1694 const tinfo_s *ti = get_tinfo_desc (pseudo_ix); 1695 if (TREE_TYPE (decl) != ti->type) 1696 { 1697 /* If the class became complete since we first called get_tinfo_decl, 1698 its type_info descriptor may have switched from __class_type_info 1699 to e.g. __si_class_type_info. */ 1700 TREE_TYPE (decl) = ti->type; 1701 relayout_decl (decl); 1702 } 1703 init = get_pseudo_ti_init (type, pseudo_ix); 1704 DECL_INITIAL (decl) = init; 1705 mark_used (decl); 1706 cp_finish_decl (decl, init, false, NULL_TREE, 0); 1707 /* Avoid targets optionally bumping up the alignment to improve 1708 vector instruction accesses, tinfo are never accessed this way. */ 1709#ifdef DATA_ABI_ALIGNMENT 1710 SET_DECL_ALIGN (decl, DATA_ABI_ALIGNMENT (decl, TYPE_ALIGN (TREE_TYPE (decl)))); 1711 DECL_USER_ALIGN (decl) = true; 1712#endif 1713 return true; 1714 } 1715 else 1716 return false; 1717} 1718 1719#include "gt-cp-rtti.h" 1720