gcc/cp/rtti.c

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