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