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