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