contrib/gcc/cp/rtti.c

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