gcc/cp/rtti.c

   1 /* RunTime Type Identification
   2    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Mostly written by Jason Merrill (jason@cygnus.com).
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "tree.h"
  27 #include "cp-tree.h"
  28 #include "flags.h"
  29 #include "output.h"
  30 #include "assert.h"
  31 #include "toplev.h"
  32
  33 #ifndef INT_TYPE_SIZE
  34 #define INT_TYPE_SIZE BITS_PER_WORD
  35 #endif
  36
  37 /* Accessors for the type_info objects. We need to remember several things
  38    about each of the type_info types. The global tree nodes such as
  39    bltn_desc_type_node are TREE_LISTs, and these macros are used to access
  40    the required information. */
  41 /* The RECORD_TYPE of a type_info derived class. */
  42 #define TINFO_PSEUDO_TYPE(NODE) TREE_TYPE (NODE)
  43 /* The VAR_DECL of the vtable for the type_info derived class. */
  44 #define TINFO_VTABLE_DECL(NODE) TREE_VALUE (NODE)
  45
  46 extern struct obstack permanent_obstack;
  47
  48 static tree build_headof_sub PARAMS((tree));
  49 static tree build_headof PARAMS((tree));
  50 static tree get_tinfo_var PARAMS((tree));
  51 static tree ifnonnull PARAMS((tree, tree));
  52 static tree tinfo_name PARAMS((tree));
  53 static tree get_base_offset PARAMS((tree, tree));
  54 static tree build_dynamic_cast_1 PARAMS((tree, tree));
  55 static void expand_si_desc PARAMS((tree, tree));
  56 static void expand_class_desc PARAMS((tree, tree));
  57 static void expand_attr_desc PARAMS((tree, tree));
  58 static void expand_ptr_desc PARAMS((tree, tree));
  59 static void expand_generic_desc PARAMS((tree, tree, const char *));
  60 static tree throw_bad_cast PARAMS((void));
  61 static tree throw_bad_typeid PARAMS((void));
  62 static tree get_tinfo_decl_dynamic PARAMS((tree));
  63 static tree tinfo_from_decl PARAMS((tree));
  64 static int qualifier_flags PARAMS((tree));
  65 static int target_incomplete_p PARAMS((tree));
  66 static tree tinfo_base_init PARAMS((tree, tree));
  67 static tree generic_initializer PARAMS((tree, tree));
  68 static tree ptr_initializer PARAMS((tree, tree, int *));
  69 static tree ptm_initializer PARAMS((tree, tree, int *));
  70 static tree dfs_class_hint_mark PARAMS ((tree, void *));
  71 static tree dfs_class_hint_unmark PARAMS ((tree, void *));
  72 static int class_hint_flags PARAMS((tree));
  73 static tree class_initializer PARAMS((tree, tree, tree));
  74 static tree synthesize_tinfo_var PARAMS((tree, tree));
  75 static tree create_real_tinfo_var PARAMS((tree, tree, tree, int));
  76 static tree create_pseudo_type_info PARAMS((const char *, int, ...));
  77 static tree get_vmi_pseudo_type_info PARAMS((int));
  78 static void create_tinfo_types PARAMS((void));
  79
  80 static int doing_runtime = 0;
  81 \f
  82 void
  83 init_rtti_processing ()
  84 {
  85   if (flag_honor_std)
  86     push_namespace (get_identifier ("std"));
  87   type_info_type_node = xref_tag
  88     (class_type_node, get_identifier ("type_info"), 1);
  89   if (flag_honor_std)
  90     pop_namespace ();
  91   if (!new_abi_rtti_p ())
  92     {
  93       tinfo_decl_id = get_identifier ("__tf");
  94       tinfo_decl_type = build_function_type
  95         (build_reference_type
  96           (build_qualified_type
  97             (type_info_type_node, TYPE_QUAL_CONST)),
  98          void_list_node);
  99       tinfo_var_id = get_identifier ("__ti");
 100     }
 101   else
 102     {
 103       /* FIXME: These identifier prefixes are not set in stone yet.  */
 104       tinfo_decl_id = get_identifier ("__ti");
 105       tinfo_var_id = get_identifier ("__tn");
 106       tinfo_decl_type = build_qualified_type
 107                           (type_info_type_node, TYPE_QUAL_CONST);
 108     }
 109 }
 110
 111 /* Given a pointer to an object with at least one virtual table
 112    pointer somewhere, return a pointer to a possible sub-object that
 113    has a virtual table pointer in it that is the vtable parent for
 114    that sub-object.  */
 115
 116 static tree
 117 build_headof_sub (exp)
 118      tree exp;
 119 {
 120   tree type = TREE_TYPE (TREE_TYPE (exp));
 121   tree basetype = CLASSTYPE_RTTI (type);
 122   tree binfo = get_binfo (basetype, type, 0);
 123
 124   exp = convert_pointer_to_real (binfo, exp);
 125   return exp;
 126 }
 127
 128 /* Given the expression EXP of type `class *', return the head of the
 129    object pointed to by EXP with type cv void*, if the class has any
 130    virtual functions (TYPE_POLYMORPHIC_P), else just return the
 131    expression.  */
 132
 133 static tree
 134 build_headof (exp)
 135      tree exp;
 136 {
 137   tree type = TREE_TYPE (exp);
 138   tree aref;
 139   tree offset;
 140   tree index;
 141
 142   my_friendly_assert (TREE_CODE (type) == POINTER_TYPE, 20000112);
 143   type = TREE_TYPE (type);
 144
 145   if (!TYPE_POLYMORPHIC_P (type))
 146     return exp;
 147   if (CLASSTYPE_COM_INTERFACE (type))
 148     {
 149       cp_error ("RTTI not supported for COM interface type `%T'", type);
 150       return error_mark_node;
 151     }
 152
 153   /* If we don't have rtti stuff, get to a sub-object that does.  */
 154   if (!CLASSTYPE_VFIELDS (TREE_TYPE (TREE_TYPE (exp))))
 155     exp = build_headof_sub (exp);
 156
 157   /* We use this a couple of times below, protect it.  */
 158   exp = save_expr (exp);
 159
 160   /* Under the new ABI, the offset-to-top field is at index -2 from
 161      the vptr.  */
 162   if (new_abi_rtti_p ())
 163     index = build_int_2 (-2, -1);
 164   /* But under the old ABI, it is at offset zero.  */
 165   else
 166     index = integer_zero_node;
 167
 168   aref = build_vtbl_ref (build_indirect_ref (exp, NULL_PTR), index);
 169
 170   if (flag_vtable_thunks)
 171     offset = aref;
 172   else
 173     offset = build_component_ref (aref, delta_identifier, NULL_TREE, 0);
 174
 175   type = build_qualified_type (ptr_type_node,
 176                                CP_TYPE_QUALS (TREE_TYPE (exp)));
 177   return build (PLUS_EXPR, type, exp,
 178                 cp_convert (ptrdiff_type_node, offset));
 179 }
 180
 181 /* Get a bad_cast node for the program to throw...
 182
 183    See libstdc++/exception.cc for __throw_bad_cast */
 184
 185 static tree
 186 throw_bad_cast ()
 187 {
 188   tree fn = get_identifier ("__throw_bad_cast");
 189   if (IDENTIFIER_GLOBAL_VALUE (fn))
 190     fn = IDENTIFIER_GLOBAL_VALUE (fn);
 191   else
 192     fn = push_throw_library_fn (fn, build_function_type (ptr_type_node,
 193                                                          void_list_node));
 194
 195   return build_call (fn, NULL_TREE);
 196 }
 197
 198 static tree
 199 throw_bad_typeid ()
 200 {
 201   tree fn = get_identifier ("__throw_bad_typeid");
 202   if (IDENTIFIER_GLOBAL_VALUE (fn))
 203     fn = IDENTIFIER_GLOBAL_VALUE (fn);
 204   else
 205     {
 206       tree t = build_qualified_type (type_info_type_node, TYPE_QUAL_CONST);
 207       t = build_function_type (build_reference_type (t), void_list_node);
 208       fn = push_throw_library_fn (fn, t);
 209     }
 210
 211   return build_call (fn, NULL_TREE);
 212 }
 213 \f
 214 /* Return a pointer to type_info function associated with the expression EXP.
 215    If EXP is a reference to a polymorphic class, return the dynamic type;
 216    otherwise return the static type of the expression.  */
 217
 218 static tree
 219 get_tinfo_decl_dynamic (exp)
 220      tree exp;
 221 {
 222   tree type;
 223
 224   if (exp == error_mark_node)
 225     return error_mark_node;
 226
 227   type = TREE_TYPE (exp);
 228
 229   /* peel back references, so they match.  */
 230   if (TREE_CODE (type) == REFERENCE_TYPE)
 231     type = TREE_TYPE (type);
 232
 233   /* Peel off cv qualifiers.  */
 234   type = TYPE_MAIN_VARIANT (type);
 235
 236   if (!VOID_TYPE_P (type))
 237     type = complete_type_or_else (type, exp);
 238
 239   if (!type)
 240     return error_mark_node;
 241
 242   /* If exp is a reference to polymorphic type, get the real type_info.  */
 243   if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))
 244     {
 245       /* build reference to type_info from vtable.  */
 246       tree t;
 247       tree index;
 248
 249       if (! flag_rtti)
 250         error ("taking dynamic typeid of object with -fno-rtti");
 251       if (CLASSTYPE_COM_INTERFACE (type))
 252         {
 253           cp_error ("RTTI not supported for COM interface type `%T'", type);
 254           return error_mark_node;
 255         }
 256
 257       /* If we don't have rtti stuff, get to a sub-object that does.  */
 258       if (! CLASSTYPE_VFIELDS (type))
 259         {
 260           exp = build_unary_op (ADDR_EXPR, exp, 0);
 261           exp = build_headof_sub (exp);
 262           exp = build_indirect_ref (exp, NULL_PTR);
 263         }
 264
 265       /* The RTTI information is always in the vtable, but it's at
 266          different indices depending on the ABI.  */
 267       if (new_abi_rtti_p ())
 268         index = minus_one_node;
 269       else if (flag_vtable_thunks)
 270         index = integer_one_node;
 271       else
 272         index = integer_zero_node;
 273       t = build_vfn_ref ((tree *) 0, exp, index);
 274       TREE_TYPE (t) = build_pointer_type (tinfo_decl_type);
 275       return t;
 276     }
 277
 278   /* otherwise return the type_info for the static type of the expr.  */
 279   exp = get_tinfo_decl (TYPE_MAIN_VARIANT (type));
 280   return build_unary_op (ADDR_EXPR, exp, 0);
 281 }
 282
 283 tree
 284 build_typeid (exp)
 285      tree exp;
 286 {
 287   tree cond = NULL_TREE;
 288   int nonnull = 0;
 289
 290   if (! flag_rtti)
 291     {
 292       error ("cannot use typeid with -fno-rtti");
 293       return error_mark_node;
 294     }
 295
 296   if (!COMPLETE_TYPE_P (type_info_type_node))
 297     {
 298       error ("must #include <typeinfo> before using typeid");
 299       return error_mark_node;
 300     }
 301
 302   if (processing_template_decl)
 303     return build_min_nt (TYPEID_EXPR, exp);
 304
 305   if (TREE_CODE (exp) == INDIRECT_REF
 306       && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
 307       && TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
 308       && ! resolves_to_fixed_type_p (exp, &nonnull)
 309       && ! nonnull)
 310     {
 311       exp = stabilize_reference (exp);
 312       cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
 313     }
 314
 315   exp = get_tinfo_decl_dynamic (exp);
 316
 317   if (exp == error_mark_node)
 318     return error_mark_node;
 319
 320   exp = tinfo_from_decl (exp);
 321
 322   if (cond)
 323     {
 324       tree bad = throw_bad_typeid ();
 325
 326       exp = build (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);
 327     }
 328
 329   return convert_from_reference (exp);
 330 }
 331
 332 static tree
 333 get_tinfo_var (type)
 334      tree type;
 335 {
 336   tree tname = build_overload_with_type (tinfo_var_id, type);
 337   tree arrtype;
 338   int size;
 339
 340   my_friendly_assert (!new_abi_rtti_p (), 20000118);
 341   if (IDENTIFIER_GLOBAL_VALUE (tname))
 342     return IDENTIFIER_GLOBAL_VALUE (tname);
 343
 344   /* Figure out how much space we need to allocate for the type_info object.
 345      If our struct layout or the type_info classes are changed, this will
 346      need to be modified.  */
 347   if (TYPE_QUALS (type) != TYPE_UNQUALIFIED)
 348     size = 3 * POINTER_SIZE + INT_TYPE_SIZE;
 349   else if (TREE_CODE (type) == POINTER_TYPE
 350            && ! (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE
 351                  || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE))
 352     size = 3 * POINTER_SIZE;
 353   else if (IS_AGGR_TYPE (type))
 354     {
 355       if (CLASSTYPE_N_BASECLASSES (type) == 0)
 356         size = 2 * POINTER_SIZE;
 357       else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
 358                && (TREE_VIA_PUBLIC
 359                    (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0))))
 360         size = 3 * POINTER_SIZE;
 361       else
 362         size = 3 * POINTER_SIZE + TYPE_PRECISION (sizetype);
 363     }
 364   else
 365     size = 2 * POINTER_SIZE;
 366
 367   /* The type for a character array of the appropriate size.  */
 368   arrtype = build_cplus_array_type
 369     (unsigned_char_type_node,
 370      build_index_type (size_int (size / BITS_PER_UNIT - 1)));
 371
 372   return declare_global_var (tname, arrtype);
 373 }
 374
 375 /* Generate the NTBS name of a type.  */
 376 static tree
 377 tinfo_name (type)
 378      tree type;
 379 {
 380   const char *name;
 381   tree name_string;
 382
 383   if (flag_new_abi)
 384     name = mangle_type_string (type);
 385   else
 386     name = build_overload_name (type, 1, 1);
 387   name_string = combine_strings (build_string (strlen (name) + 1, name));
 388   return name_string;
 389 }
 390
 391 /* Returns a decl for a function or variable which can be used to obtain a
 392    type_info object for TYPE.  The old-abi uses functions, the new-abi
 393    uses the type_info object directly.  You can take the address of the
 394    returned decl, to save the decl.  To use the decl call
 395    tinfo_from_decl.  You must arrange that the decl is mark_used, if
 396    actually use it --- decls in vtables are only used if the vtable is
 397    output.  */
 398
 399 tree
 400 get_tinfo_decl (type)
 401      tree type;
 402 {
 403   tree name;
 404   tree d;
 405
 406   if (TREE_CODE (type) == OFFSET_TYPE)
 407     type = TREE_TYPE (type);
 408   if (TREE_CODE (type) == METHOD_TYPE)
 409     type = build_function_type (TREE_TYPE (type),
 410                                 TREE_CHAIN (TYPE_ARG_TYPES (type)));
 411
 412   if (flag_new_abi)
 413     name = mangle_typeinfo_for_type (type);
 414   else
 415     name = build_overload_with_type (tinfo_decl_id, type);
 416
 417   d = IDENTIFIER_GLOBAL_VALUE (name);
 418   if (d)
 419     /* OK */;
 420   else if (!new_abi_rtti_p ())
 421     {
 422       /* The tinfo decl is a function returning a reference to the
 423          type_info object.  */
 424       d = push_library_fn (name, tinfo_decl_type);
 425       DECL_NOT_REALLY_EXTERN (d) = 1;
 426       SET_DECL_TINFO_FN_P (d);
 427       TREE_TYPE (name) = type;
 428       defer_fn (d);
 429     }
 430   else
 431     {
 432       /* The tinfo decl is the type_info object itself.  We make all
 433          tinfo objects look as type_info, even though they will end up
 434          being a subclass of that when emitted.  This means the we'll
 435          erroneously think we know the dynamic type -- be careful in the
 436          runtime.  */
 437       d = build_lang_decl (VAR_DECL, name, tinfo_decl_type);
 438
 439       DECL_ARTIFICIAL (d) = 1;
 440       DECL_ALIGN (d) = TYPE_ALIGN (ptr_type_node);
 441       DECL_USER_ALIGN (d) = 0;
 442       TREE_READONLY (d) = 1;
 443       TREE_STATIC (d) = 1;
 444       DECL_EXTERNAL (d) = 1;
 445       TREE_PUBLIC (d) = 1;
 446       comdat_linkage (d);
 447       DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
 448       cp_finish_decl (d, NULL_TREE, NULL_TREE, 0);
 449
 450       pushdecl_top_level (d);
 451       /* Remember the type it is for.  */
 452       TREE_TYPE (name) = type;
 453       TREE_USED (name) = 1;
 454     }
 455   return d;
 456 }
 457
 458 /* Given an expr produced by get_tinfo_decl, return an expr which
 459    produces a reference to the type_info object.  */
 460
 461 static tree
 462 tinfo_from_decl (expr)
 463      tree expr;
 464 {
 465   tree t;
 466
 467   if (!new_abi_rtti_p ())
 468     t = build_call (expr, NULL_TREE);
 469   else if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
 470     t = build_indirect_ref (expr, NULL);
 471   else
 472     t = expr;
 473
 474   return t;
 475 }
 476
 477 tree
 478 get_typeid_1 (type)
 479      tree type;
 480 {
 481   tree t;
 482
 483   t = get_tinfo_decl (type);
 484   t = tinfo_from_decl (t);
 485   return convert_from_reference (t);
 486 }
 487
 488 /* Return the type_info object for TYPE.  */
 489
 490 tree
 491 get_typeid (type)
 492      tree type;
 493 {
 494   if (type == error_mark_node)
 495     return error_mark_node;
 496
 497   if (!COMPLETE_TYPE_P (type_info_type_node))
 498     {
 499       error ("must #include <typeinfo> before using typeid");
 500       return error_mark_node;
 501     }
 502
 503   if (processing_template_decl)
 504     return build_min_nt (TYPEID_EXPR, type);
 505
 506   /* If the type of the type-id is a reference type, the result of the
 507      typeid expression refers to a type_info object representing the
 508      referenced type.  */
 509   if (TREE_CODE (type) == REFERENCE_TYPE)
 510     type = TREE_TYPE (type);
 511
 512   /* The top-level cv-qualifiers of the lvalue expression or the type-id
 513      that is the operand of typeid are always ignored.  */
 514   type = TYPE_MAIN_VARIANT (type);
 515
 516   if (!VOID_TYPE_P (type))
 517     type = complete_type_or_else (type, NULL_TREE);
 518
 519   if (!type)
 520     return error_mark_node;
 521
 522   return get_typeid_1 (type);
 523 }
 524
 525 /* Check whether TEST is null before returning RESULT.  If TEST is used in
 526    RESULT, it must have previously had a save_expr applied to it.  */
 527
 528 static tree
 529 ifnonnull (test, result)
 530      tree test, result;
 531 {
 532   return build (COND_EXPR, TREE_TYPE (result),
 533                 build (EQ_EXPR, boolean_type_node, test, integer_zero_node),
 534                 cp_convert (TREE_TYPE (result), integer_zero_node),
 535                 result);
 536 }
 537
 538 /* Generate the constant expression describing where direct base BINFO
 539    appears within the PARENT. How to interpret this expression depends on
 540    details of the ABI, which the runtime must be aware of.  */
 541
 542 static tree
 543 get_base_offset (binfo, parent)
 544      tree binfo;
 545      tree parent;
 546 {
 547   if (! TREE_VIA_VIRTUAL (binfo))
 548     return BINFO_OFFSET (binfo);
 549   else if (! vbase_offsets_in_vtable_p ())
 550     {
 551       const char *name;
 552       tree result;
 553       tree field;
 554
 555       FORMAT_VBASE_NAME (name, BINFO_TYPE (binfo));
 556       field = lookup_field (parent, get_identifier (name), 0, 0);
 557       result = byte_position (field);
 558
 559       if (DECL_CONTEXT (field) != parent)
 560         {
 561           /* The vbase pointer might be in a non-virtual base of PARENT.
 562            * Adjust for the offset of that base in PARENT.  */
 563           tree path;
 564
 565           get_base_distance (DECL_CONTEXT (field), parent, -1, &path);
 566           result = build (PLUS_EXPR, TREE_TYPE (result),
 567                           result, BINFO_OFFSET (path));
 568           result = fold (result);
 569         }
 570       return result;
 571     }
 572   else
 573     /* Under the new ABI, we store the vtable offset at which
 574        the virtual base offset can be found.  */
 575     return convert (sizetype,
 576                     BINFO_VPTR_FIELD (binfo_for_vbase (BINFO_TYPE (binfo),
 577                                                        parent)));
 578
 579 }
 580
 581 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
 582    paper.  */
 583
 584 static tree
 585 build_dynamic_cast_1 (type, expr)
 586      tree type, expr;
 587 {
 588   enum tree_code tc = TREE_CODE (type);
 589   tree exprtype = TREE_TYPE (expr);
 590   tree dcast_fn;
 591   tree old_expr = expr;
 592   const char *errstr = NULL;
 593
 594   /* T shall be a pointer or reference to a complete class type, or
 595      `pointer to cv void''.  */
 596   switch (tc)
 597     {
 598     case POINTER_TYPE:
 599       if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
 600         break;
 601     case REFERENCE_TYPE:
 602       if (! IS_AGGR_TYPE (TREE_TYPE (type)))
 603         {
 604           errstr = "target is not pointer or reference to class";
 605           goto fail;
 606         }
 607       if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
 608         {
 609           errstr = "target is not pointer or reference to complete type";
 610           goto fail;
 611         }
 612       break;
 613
 614     default:
 615       errstr = "target is not pointer or reference";
 616       goto fail;
 617     }
 618
 619   if (TREE_CODE (expr) == OFFSET_REF)
 620     {
 621       expr = resolve_offset_ref (expr);
 622       exprtype = TREE_TYPE (expr);
 623     }
 624
 625   if (tc == POINTER_TYPE)
 626     expr = convert_from_reference (expr);
 627   else if (TREE_CODE (exprtype) != REFERENCE_TYPE)
 628     {
 629       /* Apply trivial conversion T -> T& for dereferenced ptrs.  */
 630       exprtype = build_reference_type (exprtype);
 631       expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
 632                                    LOOKUP_NORMAL, NULL_TREE);
 633     }
 634
 635   exprtype = TREE_TYPE (expr);
 636
 637   if (tc == POINTER_TYPE)
 638     {
 639       /* If T is a pointer type, v shall be an rvalue of a pointer to
 640          complete class type, and the result is an rvalue of type T.  */
 641
 642       if (TREE_CODE (exprtype) != POINTER_TYPE)
 643         {
 644           errstr = "source is not a pointer";
 645           goto fail;
 646         }
 647       if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
 648         {
 649           errstr = "source is not a pointer to class";
 650           goto fail;
 651         }
 652       if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
 653         {
 654           errstr = "source is a pointer to incomplete type";
 655           goto fail;
 656         }
 657     }
 658   else
 659     {
 660       /* T is a reference type, v shall be an lvalue of a complete class
 661          type, and the result is an lvalue of the type referred to by T.  */
 662
 663       if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
 664         {
 665           errstr = "source is not of class type";
 666           goto fail;
 667         }
 668       if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
 669         {
 670           errstr = "source is of incomplete class type";
 671           goto fail;
 672         }
 673
 674     }
 675
 676   /* The dynamic_cast operator shall not cast away constness.  */
 677   if (!at_least_as_qualified_p (TREE_TYPE (type),
 678                                 TREE_TYPE (exprtype)))
 679     {
 680       errstr = "conversion casts away constness";
 681       goto fail;
 682     }
 683
 684   /* If *type is an unambiguous accessible base class of *exprtype,
 685      convert statically.  */
 686   {
 687     int distance;
 688     tree path;
 689
 690     distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1,
 691                                   &path);
 692
 693     if (distance == -2)
 694       {
 695         cp_error ("dynamic_cast from `%T' to ambiguous base class `%T'",
 696                   TREE_TYPE (exprtype), TREE_TYPE (type));
 697         return error_mark_node;
 698       }
 699     if (distance == -3)
 700       {
 701         cp_error ("dynamic_cast from `%T' to private base class `%T'",
 702                   TREE_TYPE (exprtype), TREE_TYPE (type));
 703         return error_mark_node;
 704       }
 705
 706     if (distance >= 0)
 707       {
 708         expr = build_vbase_path (PLUS_EXPR, type, expr, path, 0);
 709         if (TREE_CODE (exprtype) == POINTER_TYPE)
 710           expr = non_lvalue (expr);
 711         return expr;
 712       }
 713   }
 714
 715   /* Otherwise *exprtype must be a polymorphic class (have a vtbl).  */
 716   if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
 717     {
 718       tree expr1;
 719       /* if TYPE is `void *', return pointer to complete object.  */
 720       if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
 721         {
 722           /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b.  */
 723           if (TREE_CODE (expr) == ADDR_EXPR
 724               && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
 725               && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
 726             return build1 (NOP_EXPR, type, expr);
 727
 728           /* Since expr is used twice below, save it.  */
 729           expr = save_expr (expr);
 730
 731           expr1 = build_headof (expr);
 732           if (TREE_TYPE (expr1) != type)
 733             expr1 = build1 (NOP_EXPR, type, expr1);
 734           return ifnonnull (expr, expr1);
 735         }
 736       else
 737         {
 738           tree retval;
 739           tree result, td2, td3, elems;
 740           tree static_type, target_type, boff;
 741
 742           /* If we got here, we can't convert statically.  Therefore,
 743              dynamic_cast<D&>(b) (b an object) cannot succeed.  */
 744           if (tc == REFERENCE_TYPE)
 745             {
 746               if (TREE_CODE (old_expr) == VAR_DECL
 747                   && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
 748                 {
 749                   tree expr = throw_bad_cast ();
 750                   cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
 751                               old_expr, type);
 752                   /* Bash it to the expected type.  */
 753                   TREE_TYPE (expr) = type;
 754                   return expr;
 755                 }
 756             }
 757           /* Ditto for dynamic_cast<D*>(&b).  */
 758           else if (TREE_CODE (expr) == ADDR_EXPR)
 759             {
 760               tree op = TREE_OPERAND (expr, 0);
 761               if (TREE_CODE (op) == VAR_DECL
 762                   && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
 763                 {
 764                   cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
 765                               op, type);
 766                   retval = build_int_2 (0, 0);
 767                   TREE_TYPE (retval) = type;
 768                   return retval;
 769                 }
 770             }
 771
 772           target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
 773           static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
 774           td2 = build_unary_op (ADDR_EXPR, get_tinfo_decl (target_type), 0);
 775           td3 = build_unary_op (ADDR_EXPR, get_tinfo_decl (static_type), 0);
 776
 777           /* Determine how T and V are related.  */
 778           boff = get_dynamic_cast_base_type (static_type, target_type);
 779
 780           /* Since expr is used twice below, save it.  */
 781           expr = save_expr (expr);
 782
 783           expr1 = expr;
 784           if (tc == REFERENCE_TYPE)
 785             expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
 786
 787           if (!new_abi_rtti_p ())
 788             {
 789               tree expr2 = build_headof (expr1);
 790               tree td1 = expr;
 791
 792               if (tc == POINTER_TYPE)
 793                 td1 = build_indirect_ref (td1, NULL_PTR);
 794               td1 = get_tinfo_decl_dynamic (td1);
 795
 796               elems = tree_cons
 797                 (NULL_TREE, td1, tree_cons
 798                   (NULL_TREE, td2, tree_cons
 799                     (NULL_TREE, boff, tree_cons
 800                       (NULL_TREE, expr2, tree_cons
 801                         (NULL_TREE, td3, tree_cons
 802                           (NULL_TREE, expr1, NULL_TREE))))));
 803             }
 804           else
 805             elems = tree_cons
 806               (NULL_TREE, expr1, tree_cons
 807                 (NULL_TREE, td3, tree_cons
 808                   (NULL_TREE, td2, tree_cons
 809                     (NULL_TREE, boff, NULL_TREE))));
 810
 811           dcast_fn = dynamic_cast_node;
 812           if (!dcast_fn)
 813             {
 814               tree tmp;
 815               tree tinfo_ptr;
 816               tree ns = new_abi_rtti_p () ? abi_node : global_namespace;
 817               const char *name;
 818
 819               push_nested_namespace (ns);
 820               if (!new_abi_rtti_p ())
 821                 {
 822                   tinfo_ptr = build_pointer_type (tinfo_decl_type);
 823                   name = "__dynamic_cast_2";
 824                   tmp = tree_cons
 825                     (NULL_TREE, tinfo_ptr, tree_cons
 826                       (NULL_TREE, tinfo_ptr, tree_cons
 827                         (NULL_TREE, integer_type_node, tree_cons
 828                           (NULL_TREE, ptr_type_node, tree_cons
 829                             (NULL_TREE, tinfo_ptr, tree_cons
 830                               (NULL_TREE, ptr_type_node, void_list_node))))));
 831                 }
 832               else
 833                 {
 834                   tinfo_ptr = xref_tag (class_type_node,
 835                                         get_identifier ("__class_type_info"),
 836                                         1);
 837
 838                   tinfo_ptr = build_pointer_type
 839                                 (build_qualified_type
 840                                   (tinfo_ptr, TYPE_QUAL_CONST));
 841                   name = "__dynamic_cast";
 842                   tmp = tree_cons
 843                     (NULL_TREE, const_ptr_type_node, tree_cons
 844                       (NULL_TREE, tinfo_ptr, tree_cons
 845                         (NULL_TREE, tinfo_ptr, tree_cons
 846                           (NULL_TREE, ptrdiff_type_node, void_list_node))));
 847                 }
 848               tmp = build_function_type (ptr_type_node, tmp);
 849               dcast_fn = build_library_fn_ptr (name, tmp);
 850               pop_nested_namespace (ns);
 851               dynamic_cast_node = dcast_fn;
 852             }
 853           result = build_call (dcast_fn, elems);
 854
 855           if (tc == REFERENCE_TYPE)
 856             {
 857               tree bad = throw_bad_cast ();
 858
 859               result = save_expr (result);
 860               return build (COND_EXPR, type, result, result, bad);
 861             }
 862
 863           /* Now back to the type we want from a void*.  */
 864           result = cp_convert (type, result);
 865           return ifnonnull (expr, result);
 866         }
 867     }
 868   else
 869     errstr = "source type is not polymorphic";
 870
 871  fail:
 872   cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)",
 873             expr, exprtype, type, errstr);
 874   return error_mark_node;
 875 }
 876
 877 tree
 878 build_dynamic_cast (type, expr)
 879      tree type, expr;
 880 {
 881   if (type == error_mark_node || expr == error_mark_node)
 882     return error_mark_node;
 883
 884   if (processing_template_decl)
 885     return build_min (DYNAMIC_CAST_EXPR, type, expr);
 886
 887   return convert_from_reference (build_dynamic_cast_1 (type, expr));
 888 }
 889 \f
 890 /* Build and initialize various sorts of descriptors.  Every descriptor
 891    node has a name associated with it (the name created by mangling).
 892    For this reason, we use the identifier as our access to the __*_desc
 893    nodes, instead of sticking them directly in the types.  Otherwise we
 894    would burden all built-in types (and pointer types) with slots that
 895    we don't necessarily want to use.
 896
 897    For each descriptor we build, we build a variable that contains
 898    the descriptor's information.  When we need this info at runtime,
 899    all we need is access to these variables.
 900
 901    Note: these constructors always return the address of the descriptor
 902    info, since that is simplest for their mutual interaction.  */
 903
 904 /* Build an initializer for a __si_type_info node.  */
 905
 906 static void
 907 expand_si_desc (tdecl, type)
 908      tree tdecl;
 909      tree type;
 910 {
 911   tree t, elems, fn;
 912   tree name_string = tinfo_name (type);
 913
 914   type = BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0));
 915   finish_expr_stmt (get_typeid_1 (type));
 916   t = decay_conversion (get_tinfo_var (type));
 917   elems = tree_cons
 918     (NULL_TREE, decay_conversion (tdecl), tree_cons
 919      (NULL_TREE, decay_conversion (name_string), tree_cons
 920       (NULL_TREE, t, NULL_TREE)));
 921
 922   fn = get_identifier ("__rtti_si");
 923   if (IDENTIFIER_GLOBAL_VALUE (fn))
 924     fn = IDENTIFIER_GLOBAL_VALUE (fn);
 925   else
 926     {
 927       tree tmp;
 928       tmp = tree_cons
 929         (NULL_TREE, ptr_type_node, tree_cons
 930          (NULL_TREE, const_string_type_node, tree_cons
 931           (NULL_TREE, build_pointer_type (type_info_type_node),
 932            void_list_node)));
 933       fn = push_void_library_fn (fn, tmp);
 934     }
 935
 936   fn = build_call (fn, elems);
 937   finish_expr_stmt (fn);
 938 }
 939
 940 /* Build an initializer for a __class_type_info node.  */
 941
 942 static void
 943 expand_class_desc (tdecl, type)
 944      tree tdecl;
 945      tree type;
 946 {
 947   tree name_string;
 948   tree fn, tmp;
 949
 950   int i = CLASSTYPE_N_BASECLASSES (type);
 951   int base_cnt = 0;
 952   tree binfos = TYPE_BINFO_BASETYPES (type);
 953   tree base, elems, access, offset, isvir;
 954   tree elt, elts = NULL_TREE;
 955
 956   if (base_desc_type_node == NULL_TREE)
 957     {
 958       tree fields [4];
 959
 960       /* A reasonably close approximation of __class_type_info::base_info */
 961
 962       base_desc_type_node = make_aggr_type (RECORD_TYPE);
 963
 964       /* Actually const __user_type_info * */
 965       fields [0] = build_decl
 966         (FIELD_DECL, NULL_TREE,
 967          build_pointer_type (build_qualified_type
 968                              (type_info_type_node,
 969                               TYPE_QUAL_CONST)));
 970       fields [1] = build_decl
 971         (FIELD_DECL, NULL_TREE,
 972          flag_new_abi ? intSI_type_node : unsigned_intSI_type_node);
 973       DECL_BIT_FIELD (fields[1]) = 1;
 974       DECL_SIZE (fields[1]) = bitsize_int (29);
 975
 976       fields [2] = build_decl (FIELD_DECL, NULL_TREE, boolean_type_node);
 977       DECL_BIT_FIELD (fields[2]) = 1;
 978       DECL_SIZE (fields[2]) = bitsize_one_node;
 979
 980       /* Actually enum access */
 981       fields [3] = build_decl (FIELD_DECL, NULL_TREE, integer_type_node);
 982       DECL_BIT_FIELD (fields[3]) = 1;
 983       DECL_SIZE (fields[3]) = bitsize_int (2);
 984
 985       finish_builtin_type (base_desc_type_node, "__base_info", fields,
 986                            3, ptr_type_node);
 987     }
 988
 989   while (--i >= 0)
 990     {
 991       tree binfo = TREE_VEC_ELT (binfos, i);
 992
 993       finish_expr_stmt (get_typeid_1 (BINFO_TYPE (binfo)));
 994       base = decay_conversion (get_tinfo_var (BINFO_TYPE (binfo)));
 995       offset = get_base_offset (binfo, type);
 996
 997       if (TREE_VIA_PUBLIC (binfo))
 998         access = access_public_node;
 999       else if (TREE_VIA_PROTECTED (binfo))
1000         access = access_protected_node;
1001       else
1002         access = access_private_node;
1003       if (TREE_VIA_VIRTUAL (binfo))
1004         isvir = boolean_true_node;
1005       else
1006         isvir = boolean_false_node;
1007
1008       elt = build
1009         (CONSTRUCTOR, base_desc_type_node, NULL_TREE, tree_cons
1010          (NULL_TREE, base, tree_cons
1011           (NULL_TREE, offset, tree_cons
1012            (NULL_TREE, isvir, tree_cons
1013             (NULL_TREE, access, NULL_TREE)))));
1014       TREE_HAS_CONSTRUCTOR (elt) = TREE_CONSTANT (elt) = TREE_STATIC (elt) = 1;
1015       elts = tree_cons (NULL_TREE, elt, elts);
1016       base_cnt++;
1017     }
1018
1019   name_string = tinfo_name (type);
1020
1021   {
1022     tree arrtype = build_array_type (base_desc_type_node, NULL_TREE);
1023     elts = build (CONSTRUCTOR, arrtype, NULL_TREE, elts);
1024     TREE_HAS_CONSTRUCTOR (elts) = TREE_CONSTANT (elts)
1025       = TREE_STATIC (elts) = 1;
1026     complete_array_type (arrtype, elts, 1);
1027   }
1028
1029   elems = tree_cons
1030     (NULL_TREE, decay_conversion (tdecl), tree_cons
1031      (NULL_TREE, decay_conversion (name_string), tree_cons
1032       (NULL_TREE, decay_conversion (elts), tree_cons
1033        (NULL_TREE, cp_convert (sizetype, build_int_2 (base_cnt, 0)),
1034         NULL_TREE))));
1035
1036   fn = get_identifier ("__rtti_class");
1037   if (IDENTIFIER_GLOBAL_VALUE (fn))
1038     fn = IDENTIFIER_GLOBAL_VALUE (fn);
1039   else
1040     {
1041       tmp = tree_cons
1042         (NULL_TREE, ptr_type_node, tree_cons
1043          (NULL_TREE, const_string_type_node, tree_cons
1044           (NULL_TREE, build_pointer_type (base_desc_type_node), tree_cons
1045            (NULL_TREE, sizetype, void_list_node))));
1046
1047       fn = push_void_library_fn (fn, tmp);
1048     }
1049
1050   fn = build_call (fn, elems);
1051   finish_expr_stmt (fn);
1052 }
1053
1054 /* Build an initializer for a __pointer_type_info node.  */
1055
1056 static void
1057 expand_ptr_desc (tdecl, type)
1058      tree tdecl;
1059      tree type;
1060 {
1061   tree t, elems, fn;
1062   tree name_string = tinfo_name (type);
1063
1064   type = TREE_TYPE (type);
1065   finish_expr_stmt (get_typeid_1 (type));
1066   t = decay_conversion (get_tinfo_var (type));
1067   elems = tree_cons
1068     (NULL_TREE, decay_conversion (tdecl), tree_cons
1069      (NULL_TREE, decay_conversion (name_string), tree_cons
1070       (NULL_TREE, t, NULL_TREE)));
1071
1072   fn = get_identifier ("__rtti_ptr");
1073   if (IDENTIFIER_GLOBAL_VALUE (fn))
1074     fn = IDENTIFIER_GLOBAL_VALUE (fn);
1075   else
1076     {
1077       tree tmp;
1078       tmp = tree_cons
1079         (NULL_TREE, ptr_type_node, tree_cons
1080          (NULL_TREE, const_string_type_node, tree_cons
1081           (NULL_TREE, build_pointer_type (type_info_type_node),
1082            void_list_node)));
1083       fn = push_void_library_fn (fn, tmp);
1084     }
1085
1086   fn = build_call (fn, elems);
1087   finish_expr_stmt (fn);
1088 }
1089
1090 /* Build an initializer for a __attr_type_info node.  */
1091
1092 static void
1093 expand_attr_desc (tdecl, type)
1094      tree tdecl;
1095      tree type;
1096 {
1097   tree elems, t, fn;
1098   tree name_string = tinfo_name (type);
1099   tree attrval = build_int_2 (TYPE_QUALS (type), 0);
1100
1101   finish_expr_stmt (get_typeid_1 (TYPE_MAIN_VARIANT (type)));
1102   t = decay_conversion (get_tinfo_var (TYPE_MAIN_VARIANT (type)));
1103   elems = tree_cons
1104     (NULL_TREE, decay_conversion (tdecl), tree_cons
1105      (NULL_TREE, decay_conversion (name_string), tree_cons
1106       (NULL_TREE, attrval, tree_cons (NULL_TREE, t, NULL_TREE))));
1107
1108   fn = get_identifier ("__rtti_attr");
1109   if (IDENTIFIER_GLOBAL_VALUE (fn))
1110     fn = IDENTIFIER_GLOBAL_VALUE (fn);
1111   else
1112     {
1113       tree tmp;
1114       tmp = tree_cons
1115         (NULL_TREE, ptr_type_node, tree_cons
1116          (NULL_TREE, const_string_type_node, tree_cons
1117           (NULL_TREE, integer_type_node, tree_cons
1118            (NULL_TREE, build_pointer_type (type_info_type_node),
1119             void_list_node))));
1120       fn = push_void_library_fn (fn, tmp);
1121     }
1122
1123   fn = build_call (fn, elems);
1124   finish_expr_stmt (fn);
1125 }
1126
1127 /* Build an initializer for a type_info node that just has a name.  */
1128
1129 static void
1130 expand_generic_desc (tdecl, type, fnname)
1131      tree tdecl;
1132      tree type;
1133      const char *fnname;
1134 {
1135   tree name_string = tinfo_name (type);
1136   tree elems = tree_cons
1137     (NULL_TREE, decay_conversion (tdecl), tree_cons
1138      (NULL_TREE, decay_conversion (name_string), NULL_TREE));
1139
1140   tree fn = get_identifier (fnname);
1141   if (IDENTIFIER_GLOBAL_VALUE (fn))
1142     fn = IDENTIFIER_GLOBAL_VALUE (fn);
1143   else
1144     {
1145       tree tmp;
1146       tmp = tree_cons
1147         (NULL_TREE, ptr_type_node, tree_cons
1148          (NULL_TREE, const_string_type_node, void_list_node));
1149       fn = push_void_library_fn (fn, tmp);
1150     }
1151
1152   fn = build_call (fn, elems);
1153   finish_expr_stmt (fn);
1154 }
1155
1156 /* Generate the code for a type_info initialization function.
1157    Note that we take advantage of the passage
1158
1159    5.2.7  Type identification                               [expr.typeid]
1160
1161    Whether or not the destructor is called for the type_info object at the
1162    end of the program is unspecified.
1163
1164    and don't bother to arrange for these objects to be destroyed.  It
1165    doesn't matter, anyway, since the destructors don't do anything.
1166
1167    This must only be called from toplevel (i.e. from finish_file)!  */
1168
1169 void
1170 synthesize_tinfo_fn (fndecl)
1171      tree fndecl;
1172 {
1173   tree type = TREE_TYPE (DECL_NAME (fndecl));
1174   tree tmp, addr, tdecl;
1175   tree compound_stmt;
1176   tree if_stmt;
1177   tree then_clause;
1178
1179   my_friendly_assert (!new_abi_rtti_p (), 20000118);
1180   if (at_eof)
1181     {
1182       import_export_decl (fndecl);
1183       if (DECL_REALLY_EXTERN (fndecl))
1184         return;
1185     }
1186
1187   /* Declare the static typeinfo variable.  */
1188   tdecl = get_tinfo_var (type);
1189   DECL_EXTERNAL (tdecl) = 0;
1190   TREE_STATIC (tdecl) = 1;
1191   DECL_COMMON (tdecl) = 1;
1192   TREE_USED (tdecl) = 1;
1193   DECL_ALIGN (tdecl) = TYPE_ALIGN (ptr_type_node);
1194   DECL_USER_ALIGN (tdecl) = 0;
1195   cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0);
1196
1197   /* Begin processing the function.  */
1198   start_function (NULL_TREE, fndecl, NULL_TREE,
1199                   SF_DEFAULT | SF_PRE_PARSED);
1200   DECL_DEFER_OUTPUT (fndecl) = 1;
1201   store_parm_decls ();
1202   clear_last_expr ();
1203
1204   /* Begin the body of the function.  */
1205   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
1206
1207   /* For convenience, we save away the address of the static
1208      variable.  */
1209   addr = decay_conversion (tdecl);
1210
1211   /* If the first word of the array (the vtable) is non-zero, we've already
1212      initialized the object, so don't do it again.  */
1213   if_stmt = begin_if_stmt ();
1214   tmp = cp_convert (build_pointer_type (ptr_type_node), addr);
1215   tmp = build_indirect_ref (tmp, 0);
1216   tmp = cp_build_binary_op (EQ_EXPR, tmp, integer_zero_node);
1217   finish_if_stmt_cond (tmp, if_stmt);
1218   then_clause = begin_compound_stmt (/*has_no_scope=*/0);
1219
1220   if (TREE_CODE (type) == FUNCTION_TYPE)
1221     expand_generic_desc (tdecl, type, "__rtti_func");
1222   else if (TREE_CODE (type) == ARRAY_TYPE)
1223     expand_generic_desc (tdecl, type, "__rtti_array");
1224   else if (TYPE_QUALS (type) != TYPE_UNQUALIFIED)
1225     expand_attr_desc (tdecl, type);
1226   else if (TREE_CODE (type) == POINTER_TYPE)
1227     {
1228       if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE)
1229         expand_generic_desc (tdecl, type, "__rtti_ptmd");
1230       else if (TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
1231         expand_generic_desc (tdecl, type, "__rtti_ptmf");
1232       else
1233         expand_ptr_desc (tdecl, type);
1234     }
1235   else if (TYPE_PTRMEMFUNC_P (type))
1236     expand_generic_desc (tdecl, type, "__rtti_ptmf");
1237   else if (IS_AGGR_TYPE (type))
1238     {
1239       if (CLASSTYPE_N_BASECLASSES (type) == 0)
1240         expand_generic_desc (tdecl, type, "__rtti_user");
1241       else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)
1242                && (TREE_VIA_PUBLIC
1243                    (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0))))
1244         expand_si_desc (tdecl, type);
1245       else
1246         expand_class_desc (tdecl, type);
1247     }
1248   else if (TREE_CODE (type) == ENUMERAL_TYPE)
1249     expand_generic_desc (tdecl, type, "__rtti_user");
1250   else
1251     my_friendly_abort (252);
1252
1253   finish_compound_stmt (/*has_no_scope=*/0, then_clause);
1254   finish_then_clause (if_stmt);
1255   finish_if_stmt ();
1256
1257   /* OK, now return the type_info object.  */
1258   tmp = cp_convert (build_pointer_type (type_info_type_node), addr);
1259   tmp = build_indirect_ref (tmp, 0);
1260   finish_return_stmt (tmp);
1261   /* Finish the function body.  */
1262   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
1263   expand_body (finish_function (0));
1264 }
1265
1266 /* Return the runtime bit mask encoding the qualifiers of TYPE.  */
1267
1268 static int
1269 qualifier_flags (type)
1270      tree type;
1271 {
1272   int flags = 0;
1273   /* we want the qualifiers on this type, not any array core, it might have */
1274   int quals = TYPE_QUALS (type);
1275
1276   if (quals & TYPE_QUAL_CONST)
1277     flags |= 1;
1278   if (quals & TYPE_QUAL_VOLATILE)
1279     flags |= 2;
1280   if (quals & TYPE_QUAL_RESTRICT)
1281     flags |= 4;
1282   return flags;
1283 }
1284
1285 /* Return non-zero, if the pointer chain TYPE ends at an incomplete type, or
1286    contains a pointer to member of an incomplete class.  */
1287
1288 static int
1289 target_incomplete_p (type)
1290      tree type;
1291 {
1292   while (TREE_CODE (type) == POINTER_TYPE)
1293     if (TYPE_PTRMEM_P (type))
1294       {
1295         if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
1296           return 1;
1297         type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
1298       }
1299     else
1300       type = TREE_TYPE (type);
1301   if (!COMPLETE_OR_VOID_TYPE_P (type))
1302     return 1;
1303
1304   return 0;
1305 }
1306
1307 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
1308    is the vtable pointer and NTBS name.  The NTBS name is emitted as a
1309    comdat const char array, so it becomes a unique key for the type. Generate
1310    and emit that VAR_DECL here.  (We can't always emit the type_info itself
1311    as comdat, because of pointers to incomplete.) */
1312
1313 static tree
1314 tinfo_base_init (desc, target)
1315      tree desc;
1316      tree target;
1317 {
1318   tree init = NULL_TREE;
1319   tree name_decl;
1320
1321   {
1322     tree name_name;
1323
1324     /* Generate the NTBS array variable.  */
1325     tree name_type = build_cplus_array_type
1326                      (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
1327                      NULL_TREE);
1328     tree name_string = tinfo_name (target);
1329
1330     if (flag_new_abi)
1331       name_name = mangle_typeinfo_for_type (target);
1332     else
1333       name_name = build_overload_with_type (tinfo_var_id, target);
1334     name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
1335
1336     DECL_ARTIFICIAL (name_decl) = 1;
1337     TREE_READONLY (name_decl) = 1;
1338     TREE_STATIC (name_decl) = 1;
1339     DECL_EXTERNAL (name_decl) = 0;
1340     TREE_PUBLIC (name_decl) = 1;
1341     comdat_linkage (name_decl);
1342     if (flag_new_abi)
1343       /* The new ABI specifies the external name of the string
1344          containing the type's name.  */
1345       DECL_ASSEMBLER_NAME (name_decl)
1346         = mangle_typeinfo_string_for_type (target);
1347     else
1348       DECL_ASSEMBLER_NAME (name_decl) = DECL_NAME (name_decl);
1349     DECL_INITIAL (name_decl) = name_string;
1350     cp_finish_decl (name_decl, name_string, NULL_TREE, 0);
1351   }
1352
1353   if (TINFO_VTABLE_DECL (desc))
1354     {
1355       tree vtbl_ptr = TINFO_VTABLE_DECL (desc);
1356       init = tree_cons (NULL_TREE, vtbl_ptr, init);
1357     }
1358
1359   init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
1360
1361   init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
1362   TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
1363   init = tree_cons (NULL_TREE, init, NULL_TREE);
1364
1365   return init;
1366 }
1367
1368 /* Return the CONSTRUCTOR expr for a type_info of TYPE. DESC provides the
1369    information about the particular type_info derivation, which adds no
1370    additional fields to the type_info base.  */
1371
1372 static tree
1373 generic_initializer (desc, target)
1374      tree desc;
1375      tree target;
1376 {
1377   tree init = tinfo_base_init (desc, target);
1378
1379   init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, init);
1380   TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
1381   return init;
1382 }
1383
1384 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
1385    DESC provides information about the particular type_info derivation,
1386    which adds target type and qualifier flags members to the type_info base.  */
1387
1388 static tree
1389 ptr_initializer (desc, target, non_public_ptr)
1390      tree desc;
1391      tree target;
1392      int *non_public_ptr;
1393 {
1394   tree init = tinfo_base_init (desc, target);
1395   tree to = TREE_TYPE (target);
1396   int flags = qualifier_flags (to);
1397   int incomplete = target_incomplete_p (to);
1398
1399   if (incomplete)
1400     {
1401       flags |= 8;
1402       *non_public_ptr = 1;
1403     }
1404   init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
1405   init = tree_cons (NULL_TREE,
1406                     build_unary_op (ADDR_EXPR,
1407                                     get_tinfo_decl (TYPE_MAIN_VARIANT (to)), 0),
1408                     init);
1409
1410   init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
1411   TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
1412   return init;
1413 }
1414
1415 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
1416    DESC provides information about the particular type_info derivation,
1417    which adds class, target type and qualifier flags members to the type_info
1418    base.  */
1419
1420 static tree
1421 ptm_initializer (desc, target, non_public_ptr)
1422      tree desc;
1423      tree target;
1424      int *non_public_ptr;
1425 {
1426   tree init = tinfo_base_init (desc, target);
1427   tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
1428   tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
1429   int flags = qualifier_flags (to);
1430   int incomplete = target_incomplete_p (to);
1431
1432   if (incomplete)
1433     {
1434       flags |= 0x8;
1435       *non_public_ptr = 1;
1436     }
1437   if (!COMPLETE_TYPE_P (klass))
1438     {
1439       flags |= 0x10;
1440       *non_public_ptr = 1;
1441     }
1442   init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
1443   init = tree_cons (NULL_TREE,
1444                     build_unary_op (ADDR_EXPR,
1445                                     get_tinfo_decl (TYPE_MAIN_VARIANT (to)), 0),
1446                     init);
1447   init = tree_cons (NULL_TREE,
1448                     build_unary_op (ADDR_EXPR, get_tinfo_decl (klass), 0),
1449                     init);
1450
1451   init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
1452   TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
1453   return init;
1454 }
1455
1456 /* Check base BINFO to set hint flags in *DATA, which is really an int.
1457    We use CLASSTYPE_MARKED to tag types we've found as non-virtual bases and
1458    CLASSTYPE_MARKED2 to tag those which are virtual bases. Remember it is
1459    possible for a type to be both a virtual and non-virtual base.  */
1460
1461 static tree
1462 dfs_class_hint_mark (binfo, data)
1463      tree binfo;
1464      void *data;
1465 {
1466   tree basetype = BINFO_TYPE (binfo);
1467   int *hint = (int *) data;
1468
1469   if (TREE_VIA_VIRTUAL (binfo))
1470     {
1471       if (CLASSTYPE_MARKED (basetype))
1472         *hint |= 1;
1473       if (CLASSTYPE_MARKED2 (basetype))
1474         *hint |= 2;
1475       SET_CLASSTYPE_MARKED2 (basetype);
1476     }
1477   else
1478     {
1479       if (CLASSTYPE_MARKED (basetype) || CLASSTYPE_MARKED2 (basetype))
1480         *hint |= 1;
1481       SET_CLASSTYPE_MARKED (basetype);
1482     }
1483   if (!TREE_VIA_PUBLIC (binfo) && TYPE_BINFO (basetype) != binfo)
1484     *hint |= 4;
1485   return NULL_TREE;
1486 };
1487
1488 /* Clear the base's dfs marks, after searching for duplicate bases. */
1489
1490 static tree
1491 dfs_class_hint_unmark (binfo, data)
1492      tree binfo;
1493      void *data ATTRIBUTE_UNUSED;
1494 {
1495   tree basetype = BINFO_TYPE (binfo);
1496
1497   CLEAR_CLASSTYPE_MARKED (basetype);
1498   CLEAR_CLASSTYPE_MARKED2 (basetype);
1499   return NULL_TREE;
1500 }
1501
1502 /* Determine the hint flags describing the features of a class's heirarchy.  */
1503
1504 static int
1505 class_hint_flags (type)
1506      tree type;
1507 {
1508   int hint_flags = 0;
1509   int i;
1510
1511   dfs_walk (TYPE_BINFO (type), dfs_class_hint_mark, NULL, &hint_flags);
1512   dfs_walk (TYPE_BINFO (type), dfs_class_hint_unmark, NULL, NULL);
1513
1514   for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); ++i)
1515     {
1516       tree base_binfo = BINFO_BASETYPE (TYPE_BINFO (type), i);
1517
1518       if (TREE_VIA_PUBLIC (base_binfo))
1519         hint_flags |= 0x8;
1520     }
1521   return hint_flags;
1522 }
1523
1524 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1525    DESC provides information about the particular __class_type_info derivation,
1526    which adds hint flags and TRAIL initializers to the type_info base.  */
1527
1528 static tree
1529 class_initializer (desc, target, trail)
1530      tree desc;
1531      tree target;
1532      tree trail;
1533 {
1534   tree init = tinfo_base_init (desc, target);
1535
1536   TREE_CHAIN (init) = trail;
1537   init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, init);
1538   TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
1539   return init;
1540 }
1541
1542 /* Generate a pseudo_type_info VAR_DECL suitable for the supplied
1543    TARGET_TYPE and given the REAL_NAME. This is the structure expected by
1544    the runtime, and therefore has additional fields.  If we need not emit a
1545    definition (because the runtime must contain it), return NULL_TREE,
1546    otherwise return the VAR_DECL.  */
1547
1548 static tree
1549 synthesize_tinfo_var (target_type, real_name)
1550      tree target_type;
1551      tree real_name;
1552 {
1553   tree var_init = NULL_TREE;
1554   tree var_type = NULL_TREE;
1555   int non_public = 0;
1556
1557   my_friendly_assert (new_abi_rtti_p (), 20000118);
1558
1559   switch (TREE_CODE (target_type))
1560     {
1561     case POINTER_TYPE:
1562       if (TYPE_PTRMEM_P (target_type))
1563         {
1564           var_type = ptm_desc_type_node;
1565           var_init = ptm_initializer (var_type, target_type, &non_public);
1566         }
1567       else
1568         {
1569           int code = TREE_CODE (TREE_TYPE (target_type));
1570
1571           if ((CP_TYPE_QUALS (TREE_TYPE (target_type)) | TYPE_QUAL_CONST)
1572               == TYPE_QUAL_CONST
1573               && (code == INTEGER_TYPE || code == BOOLEAN_TYPE
1574                   || code == CHAR_TYPE || code == REAL_TYPE
1575                   || code == VOID_TYPE)
1576               && !doing_runtime)
1577             /* These are in the runtime.  */
1578             return NULL_TREE;
1579           var_type = ptr_desc_type_node;
1580           var_init = ptr_initializer (var_type, target_type, &non_public);
1581         }
1582       break;
1583     case ENUMERAL_TYPE:
1584       var_type = enum_desc_type_node;
1585       var_init = generic_initializer (var_type, target_type);
1586       break;
1587     case FUNCTION_TYPE:
1588       var_type = func_desc_type_node;
1589       var_init = generic_initializer (var_type, target_type);
1590       break;
1591     case ARRAY_TYPE:
1592       var_type = ary_desc_type_node;
1593       var_init = generic_initializer (var_type, target_type);
1594       break;
1595     case UNION_TYPE:
1596     case RECORD_TYPE:
1597       if (TYPE_PTRMEMFUNC_P (target_type))
1598         {
1599           var_type = ptm_desc_type_node;
1600           var_init = ptm_initializer (var_type, target_type, &non_public);
1601         }
1602       else if (!COMPLETE_TYPE_P (target_type))
1603         {
1604           /* Emit a non-public class_type_info.  */
1605           non_public = 1;
1606           var_type = class_desc_type_node;
1607           var_init = class_initializer (var_type, target_type, NULL_TREE);
1608         }
1609       else if (!CLASSTYPE_N_BASECLASSES (target_type))
1610         {
1611           var_type = class_desc_type_node;
1612           var_init = class_initializer (var_type, target_type, NULL_TREE);
1613         }
1614       else
1615         {
1616           /* if this has a single public non-virtual base, it's easier */
1617           tree binfo = TYPE_BINFO (target_type);
1618           int nbases = BINFO_N_BASETYPES (binfo);
1619           tree base_binfos = BINFO_BASETYPES (binfo);
1620           tree base_inits = NULL_TREE;
1621           int is_simple = nbases == 1;
1622           int ix;
1623
1624           /* Generate the base information initializer.  */
1625           for (ix = nbases; ix--;)
1626             {
1627               tree base_binfo = TREE_VEC_ELT (base_binfos, ix);
1628               tree base_init = NULL_TREE;
1629               int flags = 0;
1630               tree tinfo;
1631               tree offset;
1632
1633               if (TREE_VIA_VIRTUAL (base_binfo))
1634                 flags |= 1;
1635               if (TREE_PUBLIC (base_binfo))
1636                 flags |= 2;
1637               tinfo = get_tinfo_decl (BINFO_TYPE (base_binfo));
1638               tinfo = build_unary_op (ADDR_EXPR, tinfo, 0);
1639               offset = get_base_offset (base_binfo, target_type);
1640
1641               /* is it a single public inheritance? */
1642               if (is_simple && flags == 2 && integer_zerop (offset))
1643                 {
1644                   base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1645                   break;
1646                 }
1647               is_simple = 0;
1648
1649               /* combine offset and flags into one field */
1650               offset = cp_build_binary_op (LSHIFT_EXPR, offset,
1651                                            build_int_2 (8, 0));
1652               offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
1653                                            build_int_2 (flags, 0));
1654               base_init = tree_cons (NULL_TREE, offset, base_init);
1655               base_init = tree_cons (NULL_TREE, tinfo, base_init);
1656               base_init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_init);
1657               base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1658             }
1659
1660           if (is_simple)
1661             var_type = si_class_desc_type_node;
1662           else
1663             {
1664               int hint = class_hint_flags (target_type);
1665
1666               base_inits = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_inits);
1667               base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1668               /* Prepend the number of bases.  */
1669               base_inits = tree_cons (NULL_TREE,
1670                                       build_int_2 (nbases, 0), base_inits);
1671               /* Prepend the hint flags. */
1672               base_inits = tree_cons (NULL_TREE,
1673                                       build_int_2 (hint, 0), base_inits);
1674               var_type = get_vmi_pseudo_type_info (nbases);
1675             }
1676           var_init = class_initializer (var_type, target_type, base_inits);
1677         }
1678       break;
1679     case INTEGER_TYPE:
1680     case BOOLEAN_TYPE:
1681     case CHAR_TYPE:
1682     case REAL_TYPE:
1683     case VOID_TYPE:
1684       if (!doing_runtime)
1685         /* These are guaranteed to be in the runtime.  */
1686         return NULL_TREE;
1687       var_type = bltn_desc_type_node;
1688       var_init = generic_initializer (var_type, target_type);
1689       break;
1690     default:
1691       my_friendly_abort (20000117);
1692     }
1693
1694
1695   return create_real_tinfo_var (real_name, TINFO_PSEUDO_TYPE (var_type),
1696                                 var_init, non_public);
1697 }
1698
1699 /* Create the real typeinfo variable.  NON_PUBLIC indicates that we cannot
1700    make this variable public (comdat). */
1701
1702 static tree
1703 create_real_tinfo_var (name, type, init, non_public)
1704      tree name;
1705      tree type;
1706      tree init;
1707      int non_public;
1708 {
1709   static int count = 0;
1710   tree decl;
1711   tree hidden_name;
1712   char hidden[30];
1713
1714   sprintf (hidden, "%.*s_%d",
1715            IDENTIFIER_LENGTH (tinfo_decl_id), IDENTIFIER_POINTER (tinfo_decl_id),
1716            count++);
1717   hidden_name = get_identifier (hidden);
1718
1719   decl = build_lang_decl (VAR_DECL, hidden_name,
1720                           build_qualified_type (type, TYPE_QUAL_CONST));
1721   DECL_ARTIFICIAL (decl) = 1;
1722   TREE_READONLY (decl) = 1;
1723   TREE_STATIC (decl) = 1;
1724   DECL_EXTERNAL (decl) = 0;
1725
1726   if (!non_public)
1727     {
1728       TREE_PUBLIC (decl) = 1;
1729       comdat_linkage (decl);
1730     }
1731   DECL_ASSEMBLER_NAME (decl) = name;
1732   DECL_INITIAL (decl) = init;
1733   cp_finish_decl (decl, init, NULL_TREE, 0);
1734   pushdecl_top_level (decl);
1735   TREE_USED (decl) = 1;
1736   return decl;
1737 }
1738
1739 /* Generate the RECORD_TYPE containing the data layout of a type_info
1740    derivative as used by the runtime. This layout must be consistent with
1741    that defined in the runtime support. Also generate the VAR_DECL for the
1742    type's vtable. We explicitly manage the vtable member, and name it for
1743    real type as used in the runtime. The RECORD type has a different name,
1744    to avoid collisions.  Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1745    is the generated type and TINFO_VTABLE_DECL is the vtable decl.
1746
1747    REAL_NAME is the runtime's name of the type. Trailing arguments are
1748    additional FIELD_DECL's for the structure. The final argument must be
1749    NULL.  */
1750
1751 static tree
1752 create_pseudo_type_info VPARAMS((const char *real_name, int ident, ...))
1753 {
1754 #ifndef ANSI_PROTOTYPES
1755   char const *real_name;
1756   int ident;
1757 #endif
1758   va_list ap;
1759   tree real_type, pseudo_type;
1760   char *pseudo_name;
1761   tree vtable_decl;
1762   int ix;
1763   tree fields[10];
1764   tree field_decl;
1765   tree result;
1766
1767   VA_START (ap, ident);
1768 #ifndef ANSI_PROTOTYPES
1769   real_name = va_arg (ap, char const *);
1770   ident = va_arg (app, int);
1771 #endif
1772
1773   /* Generate the pseudo type name. */
1774   pseudo_name = (char *)alloca (strlen (real_name) + 30);
1775   strcpy (pseudo_name, real_name);
1776   strcat (pseudo_name, "_pseudo");
1777   if (ident)
1778     sprintf (pseudo_name + strlen (pseudo_name), "%d", ident);
1779
1780   /* Get the vtable decl. */
1781   real_type = xref_tag (class_type_node, get_identifier (real_name), 1);
1782   vtable_decl = get_vtable_decl (real_type, /*complete=*/1);
1783   vtable_decl = build_unary_op (ADDR_EXPR, vtable_decl, 0);
1784
1785   /* Under the new ABI, we need to point into the middle of the
1786      vtable.  */
1787   if (flag_new_abi)
1788     {
1789       vtable_decl = build (PLUS_EXPR,
1790                            TREE_TYPE (vtable_decl),
1791                            vtable_decl,
1792                            size_binop (MULT_EXPR,
1793                                        size_int (2),
1794                                        TYPE_SIZE_UNIT (vtable_entry_type)));
1795       TREE_CONSTANT (vtable_decl) = 1;
1796     }
1797
1798   /* First field is the pseudo type_info base class. */
1799   fields[0] = build_decl (FIELD_DECL, NULL_TREE, ti_desc_type_node);
1800
1801   /* Now add the derived fields.  */
1802   for (ix = 0; (field_decl = va_arg (ap, tree));)
1803     fields[++ix] = field_decl;
1804
1805   /* Create the pseudo type. */
1806   pseudo_type = make_aggr_type (RECORD_TYPE);
1807   finish_builtin_type (pseudo_type, pseudo_name, fields, ix, ptr_type_node);
1808   TYPE_HAS_CONSTRUCTOR (pseudo_type) = 1;
1809   va_end (ap);
1810
1811   result = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE);
1812   TINFO_VTABLE_DECL (result) = vtable_decl;
1813   TINFO_PSEUDO_TYPE (result) = pseudo_type;
1814
1815   return result;
1816 }
1817
1818 /* Return a descriptor for a vmi type with NUM_BASES bases.  */
1819
1820 static tree
1821 get_vmi_pseudo_type_info (num_bases)
1822      int num_bases;
1823 {
1824   tree desc;
1825   tree array_domain, base_array;
1826
1827   if (TREE_VEC_LENGTH (vmi_class_desc_type_node) <= num_bases)
1828     {
1829       int ix;
1830       tree extend = make_tree_vec (num_bases + 5);
1831
1832       for (ix = TREE_VEC_LENGTH (vmi_class_desc_type_node); ix--;)
1833         TREE_VEC_ELT (extend, ix) = TREE_VEC_ELT (vmi_class_desc_type_node, ix);
1834       vmi_class_desc_type_node = extend;
1835     }
1836   desc = TREE_VEC_ELT (vmi_class_desc_type_node, num_bases);
1837
1838   if (desc)
1839     return desc;
1840
1841   /* Add number of bases and trailing array of base_class_type_info.  */
1842   array_domain = build_index_type (build_int_2 (num_bases, 0));
1843   base_array = build_array_type (base_desc_type_node, array_domain);
1844
1845   push_nested_namespace (abi_node);
1846
1847   desc = create_pseudo_type_info
1848             ("__vmi_class_type_info", num_bases,
1849              build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1850              build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1851              build_decl (FIELD_DECL, NULL_TREE, base_array),
1852              NULL);
1853
1854   pop_nested_namespace (abi_node);
1855
1856   TREE_VEC_ELT (vmi_class_desc_type_node, num_bases) = desc;
1857   return desc;
1858 }
1859
1860 /* Make sure the required builtin types exist for generating the type_info
1861    varable definitions.  */
1862
1863 static void
1864 create_tinfo_types ()
1865 {
1866   tree ptr_type_info;
1867
1868   if (bltn_desc_type_node)
1869     return;
1870   push_nested_namespace (abi_node);
1871
1872   ptr_type_info = build_pointer_type
1873                     (build_qualified_type
1874                       (type_info_type_node, TYPE_QUAL_CONST));
1875
1876   /* Create the internal type_info structure. This is used as a base for
1877      the other structures.  */
1878   {
1879     tree fields[2];
1880
1881     ti_desc_type_node = make_aggr_type (RECORD_TYPE);
1882     fields[0] = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1883     fields[1] = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1884     finish_builtin_type (ti_desc_type_node, "__type_info_pseudo",
1885                          fields, 1, ptr_type_node);
1886     TYPE_HAS_CONSTRUCTOR (ti_desc_type_node) = 1;
1887   }
1888
1889   /* Fundamental type_info */
1890   bltn_desc_type_node = create_pseudo_type_info
1891       ("__fundamental_type_info", 0,
1892        NULL);
1893
1894   /* Array, function and enum type_info. No additional fields. */
1895   ary_desc_type_node = create_pseudo_type_info
1896       ("__array_type_info", 0,
1897        NULL);
1898   func_desc_type_node = create_pseudo_type_info
1899        ("__function_type_info", 0,
1900         NULL);
1901   enum_desc_type_node = create_pseudo_type_info
1902        ("__enum_type_info", 0,
1903         NULL);
1904
1905   /* Class type_info. Add a flags field.  */
1906   class_desc_type_node = create_pseudo_type_info
1907         ("__class_type_info", 0,
1908          NULL);
1909
1910   /* Single public non-virtual base class. Add pointer to base class.
1911      This is really a descendant of __class_type_info.  */
1912   si_class_desc_type_node = create_pseudo_type_info
1913            ("__si_class_type_info", 0,
1914             build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1915             NULL);
1916
1917   /* Base class internal helper. Pointer to base type, offset to base,
1918      flags. */
1919   {
1920     tree fields[2];
1921
1922     fields[0] = build_decl (FIELD_DECL, NULL_TREE, ptr_type_info);
1923     fields[1] = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1924     base_desc_type_node = make_aggr_type (RECORD_TYPE);
1925     finish_builtin_type (base_desc_type_node, "__base_class_type_info_pseudo",
1926                          fields, 1, ptr_type_node);
1927     TYPE_HAS_CONSTRUCTOR (base_desc_type_node) = 1;
1928   }
1929
1930   /* General heirarchy is created as necessary in this vector. */
1931   vmi_class_desc_type_node = make_tree_vec (10);
1932
1933   /* Pointer type_info. Adds two fields, qualification mask
1934      and pointer to the pointed to type.  This is really a descendant of
1935      __pbase_type_info. */
1936   ptr_desc_type_node = create_pseudo_type_info
1937       ("__pointer_type_info", 0,
1938        build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1939        build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1940        NULL);
1941
1942   /* Pointer to member data type_info.  Add qualifications flags,
1943      pointer to the member's type info and pointer to the class.
1944      This is really a descendant of __pbase_type_info.  */
1945   ptm_desc_type_node = create_pseudo_type_info
1946        ("__pointer_to_member_type_info", 0,
1947         build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1948         build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1949         build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1950         NULL);
1951
1952   pop_nested_namespace (abi_node);
1953 }
1954
1955 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1956    support.  Generating them here guarantees consistency with the other
1957    structures.  We use the following heuristic to determine when the runtime
1958    is being generated.  If std::__fundamental_type_info is defined, and it's
1959    destructor is defined, then the runtime is being built.  */
1960
1961 void
1962 emit_support_tinfos ()
1963 {
1964   static tree *const fundamentals[] =
1965   {
1966     &void_type_node,
1967     &boolean_type_node,
1968     &wchar_type_node,
1969     &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1970     &short_integer_type_node, &short_unsigned_type_node,
1971     &integer_type_node, &unsigned_type_node,
1972     &long_integer_type_node, &long_unsigned_type_node,
1973     &long_long_integer_type_node, &long_long_unsigned_type_node,
1974     &float_type_node, &double_type_node, &long_double_type_node,
1975     0
1976   };
1977   int ix;
1978   tree bltn_type, dtor;
1979
1980   push_nested_namespace (abi_node);
1981   bltn_type = xref_tag (class_type_node,
1982                         get_identifier ("__fundamental_type_info"), 1);
1983   pop_nested_namespace (abi_node);
1984   if (!COMPLETE_TYPE_P (bltn_type))
1985     return;
1986   dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (bltn_type), 1);
1987   if (DECL_EXTERNAL (dtor))
1988     return;
1989   doing_runtime = 1;
1990   for (ix = 0; fundamentals[ix]; ix++)
1991     {
1992       tree bltn = *fundamentals[ix];
1993       tree bltn_ptr = build_pointer_type (bltn);
1994       tree bltn_const_ptr = build_pointer_type
1995               (build_qualified_type (bltn, TYPE_QUAL_CONST));
1996       tree tinfo;
1997
1998       tinfo = get_tinfo_decl (bltn);
1999       TREE_USED (tinfo) = 1;
2000       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
2001
2002       tinfo = get_tinfo_decl (bltn_ptr);
2003       TREE_USED (tinfo) = 1;
2004       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
2005
2006       tinfo = get_tinfo_decl (bltn_const_ptr);
2007       TREE_USED (tinfo) = 1;
2008       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
2009     }
2010 }
2011
2012 /* Return non-zero, iff T is a type_info variable which has not had a
2013    definition emitted for it.  */
2014
2015 int
2016 tinfo_decl_p (t, data)
2017      tree t;
2018      void *data ATTRIBUTE_UNUSED;
2019 {
2020   return TREE_CODE (t) == VAR_DECL
2021          && IDENTIFIER_GLOBAL_VALUE (DECL_NAME (t)) == (t)
2022          && TREE_TYPE (t) == tinfo_decl_type
2023          && TREE_TYPE (DECL_NAME (t));
2024 }
2025
2026 /* Emit a suitable type_info definition for the type_info decl pointed to by
2027    DECL_PTR. We emit a completely new variable, of the correct type for the
2028    actual type this is describing. The DECL_ASSEMBLER_NAME of the generated
2029    definition is set to that of the supplied decl, so that they can be tied
2030    up. Mark the supplied decl as having been dealt with. Emitting one
2031    definition might cause other definitions to be required.
2032
2033    We need to do things this way, because we're trying to do something like
2034
2035       struct B : A {
2036         ...
2037       };
2038
2039       extern const A tinfo_var;
2040
2041       const B tinfo_var = {...};
2042
2043    which is not permitted. Also, we've not necessarily seen the definition of B.
2044    So we do something like the following,
2045
2046       extern const A tinfo_var;
2047
2048       struct pseudo_A {
2049         const void *vtable_ptr;
2050         const char *name;
2051       };
2052       struct pseudo_B {
2053         pseudo_A base;
2054         ...
2055       };
2056
2057       const pseudo_B proxy_tinfo_var attribute((assembler_name="tinfo_var")) =
2058       {
2059         {&B::vtable, "..."},
2060         ...
2061       };
2062
2063    pseudo_A and pseudo_B must be layout equivalent to the real definitions in
2064    the runtime.  */
2065
2066 int
2067 emit_tinfo_decl (decl_ptr, data)
2068      tree *decl_ptr;
2069      void *data ATTRIBUTE_UNUSED;
2070 {
2071   tree tinfo_decl = *decl_ptr;
2072   tree tinfo_type, decl;
2073
2074   my_friendly_assert (TREE_TYPE (tinfo_decl) == tinfo_decl_type, 20000121);
2075   tinfo_type = TREE_TYPE (DECL_NAME (tinfo_decl));
2076   my_friendly_assert (tinfo_type != NULL_TREE, 20000120);
2077
2078   if (!DECL_NEEDED_P (tinfo_decl))
2079     return 0;
2080   /* Say we've dealt with it.  */
2081   TREE_TYPE (DECL_NAME (tinfo_decl)) = NULL_TREE;
2082
2083   create_tinfo_types ();
2084   decl = synthesize_tinfo_var (tinfo_type, DECL_ASSEMBLER_NAME (tinfo_decl));
2085
2086   return decl != 0;
2087 }