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       cp_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 (d))
 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     int distance;
 476     tree path;
 477
 478     distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1,
 479                                   &path);
 480
 481     if (distance == -2)
 482       {
 483         cp_error ("dynamic_cast from `%T' to ambiguous base class `%T'",
 484                   TREE_TYPE (exprtype), TREE_TYPE (type));
 485         return error_mark_node;
 486       }
 487     if (distance == -3)
 488       {
 489         cp_error ("dynamic_cast from `%T' to private base class `%T'",
 490                   TREE_TYPE (exprtype), TREE_TYPE (type));
 491         return error_mark_node;
 492       }
 493
 494     if (distance >= 0)
 495       {
 496         expr = build_vbase_path (PLUS_EXPR, type, expr, path, 0);
 497         if (TREE_CODE (exprtype) == POINTER_TYPE)
 498           expr = non_lvalue (expr);
 499         return expr;
 500       }
 501   }
 502
 503   /* Otherwise *exprtype must be a polymorphic class (have a vtbl).  */
 504   if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
 505     {
 506       tree expr1;
 507       /* if TYPE is `void *', return pointer to complete object.  */
 508       if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
 509         {
 510           /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b.  */
 511           if (TREE_CODE (expr) == ADDR_EXPR
 512               && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
 513               && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
 514             return build1 (NOP_EXPR, type, expr);
 515
 516           /* Since expr is used twice below, save it.  */
 517           expr = save_expr (expr);
 518
 519           expr1 = build_headof (expr);
 520           if (TREE_TYPE (expr1) != type)
 521             expr1 = build1 (NOP_EXPR, type, expr1);
 522           return ifnonnull (expr, expr1);
 523         }
 524       else
 525         {
 526           tree retval;
 527           tree result, td2, td3, elems;
 528           tree static_type, target_type, boff;
 529
 530           /* If we got here, we can't convert statically.  Therefore,
 531              dynamic_cast<D&>(b) (b an object) cannot succeed.  */
 532           if (tc == REFERENCE_TYPE)
 533             {
 534               if (TREE_CODE (old_expr) == VAR_DECL
 535                   && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
 536                 {
 537                   tree expr = throw_bad_cast ();
 538                   cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
 539                               old_expr, type);
 540                   /* Bash it to the expected type.  */
 541                   TREE_TYPE (expr) = type;
 542                   return expr;
 543                 }
 544             }
 545           /* Ditto for dynamic_cast<D*>(&b).  */
 546           else if (TREE_CODE (expr) == ADDR_EXPR)
 547             {
 548               tree op = TREE_OPERAND (expr, 0);
 549               if (TREE_CODE (op) == VAR_DECL
 550                   && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
 551                 {
 552                   cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
 553                               op, type);
 554                   retval = build_int_2 (0, 0);
 555                   TREE_TYPE (retval) = type;
 556                   return retval;
 557                 }
 558             }
 559
 560           target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
 561           static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
 562           td2 = build_unary_op (ADDR_EXPR, get_tinfo_decl (target_type), 0);
 563           td3 = build_unary_op (ADDR_EXPR, get_tinfo_decl (static_type), 0);
 564
 565           /* Determine how T and V are related.  */
 566           boff = get_dynamic_cast_base_type (static_type, target_type);
 567
 568           /* Since expr is used twice below, save it.  */
 569           expr = save_expr (expr);
 570
 571           expr1 = expr;
 572           if (tc == REFERENCE_TYPE)
 573             expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
 574
 575           elems = tree_cons
 576             (NULL_TREE, expr1, tree_cons
 577              (NULL_TREE, td3, tree_cons
 578               (NULL_TREE, td2, tree_cons
 579                (NULL_TREE, boff, NULL_TREE))));
 580
 581           dcast_fn = dynamic_cast_node;
 582           if (!dcast_fn)
 583             {
 584               tree tmp;
 585               tree tinfo_ptr;
 586               tree ns = abi_node;
 587               const char *name;
 588
 589               push_nested_namespace (ns);
 590               tinfo_ptr = xref_tag (class_type_node,
 591                                     get_identifier ("__class_type_info"),
 592                                     1);
 593
 594               tinfo_ptr = build_pointer_type
 595                 (build_qualified_type
 596                  (tinfo_ptr, TYPE_QUAL_CONST));
 597               name = "__dynamic_cast";
 598               tmp = tree_cons
 599                 (NULL_TREE, const_ptr_type_node, tree_cons
 600                  (NULL_TREE, tinfo_ptr, tree_cons
 601                   (NULL_TREE, tinfo_ptr, tree_cons
 602                    (NULL_TREE, ptrdiff_type_node, void_list_node))));
 603               tmp = build_function_type (ptr_type_node, tmp);
 604               dcast_fn = build_library_fn_ptr (name, tmp);
 605               pop_nested_namespace (ns);
 606               dynamic_cast_node = dcast_fn;
 607             }
 608           result = build_call (dcast_fn, elems);
 609
 610           if (tc == REFERENCE_TYPE)
 611             {
 612               tree bad = throw_bad_cast ();
 613
 614               result = save_expr (result);
 615               return build (COND_EXPR, type, result, result, bad);
 616             }
 617
 618           /* Now back to the type we want from a void*.  */
 619           result = cp_convert (type, result);
 620           return ifnonnull (expr, result);
 621         }
 622     }
 623   else
 624     errstr = "source type is not polymorphic";
 625
 626  fail:
 627   cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)",
 628             expr, exprtype, type, errstr);
 629   return error_mark_node;
 630 }
 631
 632 tree
 633 build_dynamic_cast (type, expr)
 634      tree type, expr;
 635 {
 636   if (type == error_mark_node || expr == error_mark_node)
 637     return error_mark_node;
 638
 639   if (processing_template_decl)
 640     return build_min (DYNAMIC_CAST_EXPR, type, expr);
 641
 642   return convert_from_reference (build_dynamic_cast_1 (type, expr));
 643 }
 644 \f
 645 /* Return the runtime bit mask encoding the qualifiers of TYPE.  */
 646
 647 static int
 648 qualifier_flags (type)
 649      tree type;
 650 {
 651   int flags = 0;
 652   /* we want the qualifiers on this type, not any array core, it might have */
 653   int quals = TYPE_QUALS (type);
 654
 655   if (quals & TYPE_QUAL_CONST)
 656     flags |= 1;
 657   if (quals & TYPE_QUAL_VOLATILE)
 658     flags |= 2;
 659   if (quals & TYPE_QUAL_RESTRICT)
 660     flags |= 4;
 661   return flags;
 662 }
 663
 664 /* Return non-zero, if the pointer chain TYPE ends at an incomplete type, or
 665    contains a pointer to member of an incomplete class.  */
 666
 667 static int
 668 target_incomplete_p (type)
 669      tree type;
 670 {
 671   while (TREE_CODE (type) == POINTER_TYPE)
 672     if (TYPE_PTRMEM_P (type))
 673       {
 674         if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
 675           return 1;
 676         type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
 677       }
 678     else
 679       type = TREE_TYPE (type);
 680   if (!COMPLETE_OR_VOID_TYPE_P (type))
 681     return 1;
 682
 683   return 0;
 684 }
 685
 686 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
 687    is the vtable pointer and NTBS name.  The NTBS name is emitted as a
 688    comdat const char array, so it becomes a unique key for the type. Generate
 689    and emit that VAR_DECL here.  (We can't always emit the type_info itself
 690    as comdat, because of pointers to incomplete.) */
 691
 692 static tree
 693 tinfo_base_init (desc, target)
 694      tree desc;
 695      tree target;
 696 {
 697   tree init = NULL_TREE;
 698   tree name_decl;
 699
 700   {
 701     tree name_name;
 702
 703     /* Generate the NTBS array variable.  */
 704     tree name_type = build_cplus_array_type
 705                      (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
 706                      NULL_TREE);
 707     tree name_string = tinfo_name (target);
 708
 709     name_name = mangle_typeinfo_string_for_type (target);
 710     name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
 711
 712     DECL_ARTIFICIAL (name_decl) = 1;
 713     TREE_READONLY (name_decl) = 1;
 714     TREE_STATIC (name_decl) = 1;
 715     DECL_EXTERNAL (name_decl) = 0;
 716     TREE_PUBLIC (name_decl) = 1;
 717     comdat_linkage (name_decl);
 718     /* External name of the string containing the type's name has a
 719        special name.  */
 720     SET_DECL_ASSEMBLER_NAME (name_decl,
 721                              mangle_typeinfo_string_for_type (target));
 722     DECL_INITIAL (name_decl) = name_string;
 723     cp_finish_decl (name_decl, name_string, NULL_TREE, 0);
 724     pushdecl_top_level (name_decl);
 725   }
 726
 727   if (TINFO_VTABLE_DECL (desc))
 728     {
 729       tree vtbl_ptr = TINFO_VTABLE_DECL (desc);
 730       init = tree_cons (NULL_TREE, vtbl_ptr, init);
 731     }
 732
 733   init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
 734
 735   init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
 736   TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
 737   init = tree_cons (NULL_TREE, init, NULL_TREE);
 738
 739   return init;
 740 }
 741
 742 /* Return the CONSTRUCTOR expr for a type_info of TYPE. DESC provides the
 743    information about the particular type_info derivation, which adds no
 744    additional fields to the type_info base.  */
 745
 746 static tree
 747 generic_initializer (desc, target)
 748      tree desc;
 749      tree target;
 750 {
 751   tree init = tinfo_base_init (desc, target);
 752
 753   init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, init);
 754   TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
 755   return init;
 756 }
 757
 758 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
 759    DESC provides information about the particular type_info derivation,
 760    which adds target type and qualifier flags members to the type_info base.  */
 761
 762 static tree
 763 ptr_initializer (desc, target, non_public_ptr)
 764      tree desc;
 765      tree target;
 766      int *non_public_ptr;
 767 {
 768   tree init = tinfo_base_init (desc, target);
 769   tree to = TREE_TYPE (target);
 770   int flags = qualifier_flags (to);
 771   int incomplete = target_incomplete_p (to);
 772
 773   if (incomplete)
 774     {
 775       flags |= 8;
 776       *non_public_ptr = 1;
 777     }
 778   init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
 779   init = tree_cons (NULL_TREE,
 780                     build_unary_op (ADDR_EXPR,
 781                                     get_tinfo_decl (TYPE_MAIN_VARIANT (to)), 0),
 782                     init);
 783
 784   init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
 785   TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
 786   return init;
 787 }
 788
 789 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
 790    DESC provides information about the particular type_info derivation,
 791    which adds class, target type and qualifier flags members to the type_info
 792    base.  */
 793
 794 static tree
 795 ptm_initializer (desc, target, non_public_ptr)
 796      tree desc;
 797      tree target;
 798      int *non_public_ptr;
 799 {
 800   tree init = tinfo_base_init (desc, target);
 801   tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
 802   tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
 803   int flags = qualifier_flags (to);
 804   int incomplete = target_incomplete_p (to);
 805
 806   if (incomplete)
 807     {
 808       flags |= 0x8;
 809       *non_public_ptr = 1;
 810     }
 811   if (!COMPLETE_TYPE_P (klass))
 812     {
 813       flags |= 0x10;
 814       *non_public_ptr = 1;
 815     }
 816   init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
 817   init = tree_cons (NULL_TREE,
 818                     build_unary_op (ADDR_EXPR,
 819                                     get_tinfo_decl (TYPE_MAIN_VARIANT (to)), 0),
 820                     init);
 821   init = tree_cons (NULL_TREE,
 822                     build_unary_op (ADDR_EXPR, get_tinfo_decl (klass), 0),
 823                     init);
 824
 825   init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, nreverse (init));
 826   TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
 827   return init;
 828 }
 829
 830 /* Check base BINFO to set hint flags in *DATA, which is really an int.
 831    We use CLASSTYPE_MARKED to tag types we've found as non-virtual bases and
 832    CLASSTYPE_MARKED2 to tag those which are virtual bases. Remember it is
 833    possible for a type to be both a virtual and non-virtual base.  */
 834
 835 static tree
 836 dfs_class_hint_mark (binfo, data)
 837      tree binfo;
 838      void *data;
 839 {
 840   tree basetype = BINFO_TYPE (binfo);
 841   int *hint = (int *) data;
 842
 843   if (TREE_VIA_VIRTUAL (binfo))
 844     {
 845       if (CLASSTYPE_MARKED (basetype))
 846         *hint |= 1;
 847       if (CLASSTYPE_MARKED2 (basetype))
 848         *hint |= 2;
 849       SET_CLASSTYPE_MARKED2 (basetype);
 850     }
 851   else
 852     {
 853       if (CLASSTYPE_MARKED (basetype) || CLASSTYPE_MARKED2 (basetype))
 854         *hint |= 1;
 855       SET_CLASSTYPE_MARKED (basetype);
 856     }
 857   if (!TREE_VIA_PUBLIC (binfo) && TYPE_BINFO (basetype) != binfo)
 858     *hint |= 4;
 859   return NULL_TREE;
 860 };
 861
 862 /* Clear the base's dfs marks, after searching for duplicate bases. */
 863
 864 static tree
 865 dfs_class_hint_unmark (binfo, data)
 866      tree binfo;
 867      void *data ATTRIBUTE_UNUSED;
 868 {
 869   tree basetype = BINFO_TYPE (binfo);
 870
 871   CLEAR_CLASSTYPE_MARKED (basetype);
 872   CLEAR_CLASSTYPE_MARKED2 (basetype);
 873   return NULL_TREE;
 874 }
 875
 876 /* Determine the hint flags describing the features of a class's heirarchy.  */
 877
 878 static int
 879 class_hint_flags (type)
 880      tree type;
 881 {
 882   int hint_flags = 0;
 883   int i;
 884
 885   dfs_walk (TYPE_BINFO (type), dfs_class_hint_mark, NULL, &hint_flags);
 886   dfs_walk (TYPE_BINFO (type), dfs_class_hint_unmark, NULL, NULL);
 887
 888   for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); ++i)
 889     {
 890       tree base_binfo = BINFO_BASETYPE (TYPE_BINFO (type), i);
 891
 892       if (TREE_VIA_PUBLIC (base_binfo))
 893         hint_flags |= 0x8;
 894     }
 895   return hint_flags;
 896 }
 897
 898 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
 899    DESC provides information about the particular __class_type_info derivation,
 900    which adds hint flags and TRAIL initializers to the type_info base.  */
 901
 902 static tree
 903 class_initializer (desc, target, trail)
 904      tree desc;
 905      tree target;
 906      tree trail;
 907 {
 908   tree init = tinfo_base_init (desc, target);
 909
 910   TREE_CHAIN (init) = trail;
 911   init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, init);
 912   TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
 913   return init;
 914 }
 915
 916 /* Returns non-zero if the typeinfo for type should be placed in
 917    the runtime library.  */
 918
 919 static int
 920 typeinfo_in_lib_p (type)
 921      tree type;
 922 {
 923   /* The typeinfo objects for `T*' and `const T*' are in the runtime
 924      library for simple types T.  */
 925   if (TREE_CODE (type) == POINTER_TYPE
 926       && (CP_TYPE_QUALS (TREE_TYPE (type)) == TYPE_QUAL_CONST
 927           || CP_TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
 928     type = TREE_TYPE (type);
 929
 930   switch (TREE_CODE (type))
 931     {
 932     case INTEGER_TYPE:
 933     case BOOLEAN_TYPE:
 934     case CHAR_TYPE:
 935     case REAL_TYPE:
 936     case VOID_TYPE:
 937       return 1;
 938
 939     default:
 940       return 0;
 941     }
 942 }
 943
 944 /* Generate a pseudo_type_info VAR_DECL suitable for the supplied
 945    TARGET_TYPE and given the REAL_NAME. This is the structure expected by
 946    the runtime, and therefore has additional fields.  If we need not emit a
 947    definition (because the runtime must contain it), return NULL_TREE,
 948    otherwise return the VAR_DECL.  */
 949
 950 static tree
 951 synthesize_tinfo_var (target_type, real_name)
 952      tree target_type;
 953      tree real_name;
 954 {
 955   tree var_init = NULL_TREE;
 956   tree var_type = NULL_TREE;
 957   int non_public = 0;
 958
 959   switch (TREE_CODE (target_type))
 960     {
 961     case POINTER_TYPE:
 962       if (TYPE_PTRMEM_P (target_type))
 963         {
 964           var_type = ptm_desc_type_node;
 965           var_init = ptm_initializer (var_type, target_type, &non_public);
 966         }
 967       else
 968         {
 969           if (typeinfo_in_lib_p (target_type) && !doing_runtime)
 970             /* These are in the runtime.  */
 971             return NULL_TREE;
 972           var_type = ptr_desc_type_node;
 973           var_init = ptr_initializer (var_type, target_type, &non_public);
 974         }
 975       break;
 976     case ENUMERAL_TYPE:
 977       var_type = enum_desc_type_node;
 978       var_init = generic_initializer (var_type, target_type);
 979       break;
 980     case FUNCTION_TYPE:
 981       var_type = func_desc_type_node;
 982       var_init = generic_initializer (var_type, target_type);
 983       break;
 984     case ARRAY_TYPE:
 985       var_type = ary_desc_type_node;
 986       var_init = generic_initializer (var_type, target_type);
 987       break;
 988     case UNION_TYPE:
 989     case RECORD_TYPE:
 990       if (TYPE_PTRMEMFUNC_P (target_type))
 991         {
 992           var_type = ptm_desc_type_node;
 993           var_init = ptm_initializer (var_type, target_type, &non_public);
 994         }
 995       else if (!COMPLETE_TYPE_P (target_type))
 996         {
 997           /* Emit a non-public class_type_info.  */
 998           non_public = 1;
 999           var_type = class_desc_type_node;
1000           var_init = class_initializer (var_type, target_type, NULL_TREE);
1001         }
1002       else if (!CLASSTYPE_N_BASECLASSES (target_type))
1003         {
1004           var_type = class_desc_type_node;
1005           var_init = class_initializer (var_type, target_type, NULL_TREE);
1006         }
1007       else
1008         {
1009           /* if this has a single public non-virtual base, it's easier */
1010           tree binfo = TYPE_BINFO (target_type);
1011           int nbases = BINFO_N_BASETYPES (binfo);
1012           tree base_binfos = BINFO_BASETYPES (binfo);
1013           tree base_inits = NULL_TREE;
1014           int is_simple = nbases == 1;
1015           int ix;
1016
1017           /* Generate the base information initializer.  */
1018           for (ix = nbases; ix--;)
1019             {
1020               tree base_binfo = TREE_VEC_ELT (base_binfos, ix);
1021               tree base_init = NULL_TREE;
1022               int flags = 0;
1023               tree tinfo;
1024               tree offset;
1025
1026               if (TREE_PUBLIC (base_binfo))
1027                 flags |= 2;
1028               tinfo = get_tinfo_decl (BINFO_TYPE (base_binfo));
1029               tinfo = build_unary_op (ADDR_EXPR, tinfo, 0);
1030               if (TREE_VIA_VIRTUAL (base_binfo))
1031                 {
1032                    /* We store the vtable offset at which the virtual
1033                       base offset can be found.  */
1034                   offset = BINFO_VPTR_FIELD (binfo_for_vbase (BINFO_TYPE (base_binfo),
1035                                                               target_type));
1036                   offset = convert (sizetype, offset);
1037                   flags |= 1;
1038                 }
1039               else
1040                 offset = BINFO_OFFSET (base_binfo);
1041
1042               /* is it a single public inheritance? */
1043               if (is_simple && flags == 2 && integer_zerop (offset))
1044                 {
1045                   base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1046                   break;
1047                 }
1048               is_simple = 0;
1049
1050               /* combine offset and flags into one field */
1051               offset = cp_build_binary_op (LSHIFT_EXPR, offset,
1052                                            build_int_2 (8, 0));
1053               offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
1054                                            build_int_2 (flags, 0));
1055               base_init = tree_cons (NULL_TREE, offset, base_init);
1056               base_init = tree_cons (NULL_TREE, tinfo, base_init);
1057               base_init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_init);
1058               base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1059             }
1060
1061           if (is_simple)
1062             var_type = si_class_desc_type_node;
1063           else
1064             {
1065               int hint = class_hint_flags (target_type);
1066
1067               base_inits = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_inits);
1068               base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1069               /* Prepend the number of bases.  */
1070               base_inits = tree_cons (NULL_TREE,
1071                                       build_int_2 (nbases, 0), base_inits);
1072               /* Prepend the hint flags. */
1073               base_inits = tree_cons (NULL_TREE,
1074                                       build_int_2 (hint, 0), base_inits);
1075               var_type = get_vmi_pseudo_type_info (nbases);
1076             }
1077           var_init = class_initializer (var_type, target_type, base_inits);
1078         }
1079       break;
1080
1081     default:
1082       if (typeinfo_in_lib_p (target_type))
1083         {
1084           if (!doing_runtime)
1085             /* These are guaranteed to be in the runtime.  */
1086             return NULL_TREE;
1087           var_type = bltn_desc_type_node;
1088           var_init = generic_initializer (var_type, target_type);
1089           break;
1090         }
1091       my_friendly_abort (20000117);
1092     }
1093
1094   return create_real_tinfo_var (target_type,
1095                                 real_name, TINFO_PSEUDO_TYPE (var_type),
1096                                 var_init, non_public);
1097 }
1098
1099 /* Create the real typeinfo variable.  NON_PUBLIC indicates that we cannot
1100    make this variable public (comdat). */
1101
1102 static tree
1103 create_real_tinfo_var (target_type, name, type, init, non_public)
1104      tree target_type;
1105      tree name;
1106      tree type;
1107      tree init;
1108      int non_public;
1109 {
1110   static int count = 0;
1111   tree decl;
1112   tree hidden_name;
1113   char hidden[30];
1114
1115   /* We cannot give this the name NAME, as that already is globally
1116      bound to the tinfo_decl we originally created for this type in
1117      get_tinfo_decl. */
1118   sprintf (hidden, "__ti_%d", count++);
1119   hidden_name = get_identifier (hidden);
1120
1121   decl = build_lang_decl (VAR_DECL, hidden_name,
1122                           build_qualified_type (type, TYPE_QUAL_CONST));
1123   DECL_ARTIFICIAL (decl) = 1;
1124   TREE_READONLY (decl) = 1;
1125   TREE_STATIC (decl) = 1;
1126   DECL_EXTERNAL (decl) = 0;
1127
1128   if (!non_public)
1129     {
1130       TREE_PUBLIC (decl) = 1;
1131       if (flag_weak || !typeinfo_in_lib_p (target_type))
1132         comdat_linkage (decl);
1133     }
1134   SET_DECL_ASSEMBLER_NAME (decl, name);
1135   DECL_INITIAL (decl) = init;
1136   cp_finish_decl (decl, init, NULL_TREE, 0);
1137   pushdecl_top_level (decl);
1138   TREE_USED (decl) = 1;
1139   return decl;
1140 }
1141
1142 /* Generate the RECORD_TYPE containing the data layout of a type_info
1143    derivative as used by the runtime. This layout must be consistent with
1144    that defined in the runtime support. Also generate the VAR_DECL for the
1145    type's vtable. We explicitly manage the vtable member, and name it for
1146    real type as used in the runtime. The RECORD type has a different name,
1147    to avoid collisions.  Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1148    is the generated type and TINFO_VTABLE_DECL is the vtable decl.
1149
1150    REAL_NAME is the runtime's name of the type. Trailing arguments are
1151    additional FIELD_DECL's for the structure. The final argument must be
1152    NULL.  */
1153
1154 static tree
1155 create_pseudo_type_info VPARAMS((const char *real_name, int ident, ...))
1156 {
1157 #ifndef ANSI_PROTOTYPES
1158   char const *real_name;
1159   int ident;
1160 #endif
1161   va_list ap;
1162   tree real_type, pseudo_type;
1163   char *pseudo_name;
1164   tree vtable_decl;
1165   int ix;
1166   tree fields[10];
1167   tree field_decl;
1168   tree result;
1169
1170   VA_START (ap, ident);
1171 #ifndef ANSI_PROTOTYPES
1172   real_name = va_arg (ap, char const *);
1173   ident = va_arg (ap, int);
1174 #endif
1175
1176   /* Generate the pseudo type name. */
1177   pseudo_name = (char *)alloca (strlen (real_name) + 30);
1178   strcpy (pseudo_name, real_name);
1179   strcat (pseudo_name, "_pseudo");
1180   if (ident)
1181     sprintf (pseudo_name + strlen (pseudo_name), "%d", ident);
1182
1183   /* Get the vtable decl. */
1184   real_type = xref_tag (class_type_node, get_identifier (real_name), 1);
1185   vtable_decl = get_vtable_decl (real_type, /*complete=*/1);
1186   vtable_decl = build_unary_op (ADDR_EXPR, vtable_decl, 0);
1187
1188   /* We need to point into the middle of the vtable.  */
1189   vtable_decl = build (PLUS_EXPR,
1190                        TREE_TYPE (vtable_decl),
1191                        vtable_decl,
1192                        size_binop (MULT_EXPR,
1193                                    size_int (2),
1194                                    TYPE_SIZE_UNIT (vtable_entry_type)));
1195   TREE_CONSTANT (vtable_decl) = 1;
1196
1197   /* First field is the pseudo type_info base class. */
1198   fields[0] = build_decl (FIELD_DECL, NULL_TREE, ti_desc_type_node);
1199
1200   /* Now add the derived fields.  */
1201   for (ix = 0; (field_decl = va_arg (ap, tree));)
1202     fields[++ix] = field_decl;
1203
1204   /* Create the pseudo type. */
1205   pseudo_type = make_aggr_type (RECORD_TYPE);
1206   finish_builtin_type (pseudo_type, pseudo_name, fields, ix, ptr_type_node);
1207   TYPE_HAS_CONSTRUCTOR (pseudo_type) = 1;
1208   va_end (ap);
1209
1210   result = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE);
1211   TINFO_VTABLE_DECL (result) = vtable_decl;
1212   TINFO_PSEUDO_TYPE (result) = pseudo_type;
1213
1214   return result;
1215 }
1216
1217 /* Return a descriptor for a vmi type with NUM_BASES bases.  */
1218
1219 static tree
1220 get_vmi_pseudo_type_info (num_bases)
1221      int num_bases;
1222 {
1223   tree desc;
1224   tree array_domain, base_array;
1225
1226   if (TREE_VEC_LENGTH (vmi_class_desc_type_node) <= num_bases)
1227     {
1228       int ix;
1229       tree extend = make_tree_vec (num_bases + 5);
1230
1231       for (ix = TREE_VEC_LENGTH (vmi_class_desc_type_node); ix--;)
1232         TREE_VEC_ELT (extend, ix) = TREE_VEC_ELT (vmi_class_desc_type_node, ix);
1233       vmi_class_desc_type_node = extend;
1234     }
1235   desc = TREE_VEC_ELT (vmi_class_desc_type_node, num_bases);
1236
1237   if (desc)
1238     return desc;
1239
1240   /* Add number of bases and trailing array of base_class_type_info.  */
1241   array_domain = build_index_type (size_int (num_bases));
1242   base_array = build_array_type (base_desc_type_node, array_domain);
1243
1244   push_nested_namespace (abi_node);
1245
1246   desc = create_pseudo_type_info
1247             ("__vmi_class_type_info", num_bases,
1248              build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1249              build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1250              build_decl (FIELD_DECL, NULL_TREE, base_array),
1251              NULL);
1252
1253   pop_nested_namespace (abi_node);
1254
1255   TREE_VEC_ELT (vmi_class_desc_type_node, num_bases) = desc;
1256   return desc;
1257 }
1258
1259 /* Make sure the required builtin types exist for generating the type_info
1260    varable definitions.  */
1261
1262 static void
1263 create_tinfo_types ()
1264 {
1265   tree ptr_type_info;
1266
1267   if (bltn_desc_type_node)
1268     return;
1269   push_nested_namespace (abi_node);
1270
1271   ptr_type_info = build_pointer_type
1272                     (build_qualified_type
1273                       (type_info_type_node, TYPE_QUAL_CONST));
1274
1275   /* Create the internal type_info structure. This is used as a base for
1276      the other structures.  */
1277   {
1278     tree fields[2];
1279
1280     ti_desc_type_node = make_aggr_type (RECORD_TYPE);
1281     fields[0] = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1282     fields[1] = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1283     finish_builtin_type (ti_desc_type_node, "__type_info_pseudo",
1284                          fields, 1, ptr_type_node);
1285     TYPE_HAS_CONSTRUCTOR (ti_desc_type_node) = 1;
1286   }
1287
1288   /* Fundamental type_info */
1289   bltn_desc_type_node = create_pseudo_type_info
1290       ("__fundamental_type_info", 0,
1291        NULL);
1292
1293   /* Array, function and enum type_info. No additional fields. */
1294   ary_desc_type_node = create_pseudo_type_info
1295       ("__array_type_info", 0,
1296        NULL);
1297   func_desc_type_node = create_pseudo_type_info
1298        ("__function_type_info", 0,
1299         NULL);
1300   enum_desc_type_node = create_pseudo_type_info
1301        ("__enum_type_info", 0,
1302         NULL);
1303
1304   /* Class type_info. Add a flags field.  */
1305   class_desc_type_node = create_pseudo_type_info
1306         ("__class_type_info", 0,
1307          NULL);
1308
1309   /* Single public non-virtual base class. Add pointer to base class.
1310      This is really a descendant of __class_type_info.  */
1311   si_class_desc_type_node = create_pseudo_type_info
1312            ("__si_class_type_info", 0,
1313             build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1314             NULL);
1315
1316   /* Base class internal helper. Pointer to base type, offset to base,
1317      flags. */
1318   {
1319     tree fields[2];
1320
1321     fields[0] = build_decl (FIELD_DECL, NULL_TREE, ptr_type_info);
1322     fields[1] = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1323     base_desc_type_node = make_aggr_type (RECORD_TYPE);
1324     finish_builtin_type (base_desc_type_node, "__base_class_type_info_pseudo",
1325                          fields, 1, ptr_type_node);
1326     TYPE_HAS_CONSTRUCTOR (base_desc_type_node) = 1;
1327   }
1328
1329   /* General heirarchy is created as necessary in this vector. */
1330   vmi_class_desc_type_node = make_tree_vec (10);
1331
1332   /* Pointer type_info. Adds two fields, qualification mask
1333      and pointer to the pointed to type.  This is really a descendant of
1334      __pbase_type_info. */
1335   ptr_desc_type_node = create_pseudo_type_info
1336       ("__pointer_type_info", 0,
1337        build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1338        build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1339        NULL);
1340
1341   /* Pointer to member data type_info.  Add qualifications flags,
1342      pointer to the member's type info and pointer to the class.
1343      This is really a descendant of __pbase_type_info.  */
1344   ptm_desc_type_node = create_pseudo_type_info
1345        ("__pointer_to_member_type_info", 0,
1346         build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1347         build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1348         build_decl (FIELD_DECL, NULL_TREE, ptr_type_info),
1349         NULL);
1350
1351   pop_nested_namespace (abi_node);
1352 }
1353
1354 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1355    support.  Generating them here guarantees consistency with the other
1356    structures.  We use the following heuristic to determine when the runtime
1357    is being generated.  If std::__fundamental_type_info is defined, and its
1358    destructor is defined, then the runtime is being built.  */
1359
1360 void
1361 emit_support_tinfos ()
1362 {
1363   static tree *const fundamentals[] =
1364   {
1365     &void_type_node,
1366     &boolean_type_node,
1367     &wchar_type_node,
1368     &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1369     &short_integer_type_node, &short_unsigned_type_node,
1370     &integer_type_node, &unsigned_type_node,
1371     &long_integer_type_node, &long_unsigned_type_node,
1372     &long_long_integer_type_node, &long_long_unsigned_type_node,
1373     &float_type_node, &double_type_node, &long_double_type_node,
1374     0
1375   };
1376   int ix;
1377   tree bltn_type, dtor;
1378
1379   push_nested_namespace (abi_node);
1380   bltn_type = xref_tag (class_type_node,
1381                         get_identifier ("__fundamental_type_info"), 1);
1382   pop_nested_namespace (abi_node);
1383   if (!COMPLETE_TYPE_P (bltn_type))
1384     return;
1385   dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (bltn_type), 1);
1386   if (DECL_EXTERNAL (dtor))
1387     return;
1388   doing_runtime = 1;
1389   for (ix = 0; fundamentals[ix]; ix++)
1390     {
1391       tree bltn = *fundamentals[ix];
1392       tree bltn_ptr = build_pointer_type (bltn);
1393       tree bltn_const_ptr = build_pointer_type
1394               (build_qualified_type (bltn, TYPE_QUAL_CONST));
1395       tree tinfo;
1396
1397       tinfo = get_tinfo_decl (bltn);
1398       TREE_USED (tinfo) = 1;
1399       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1400
1401       tinfo = get_tinfo_decl (bltn_ptr);
1402       TREE_USED (tinfo) = 1;
1403       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1404
1405       tinfo = get_tinfo_decl (bltn_const_ptr);
1406       TREE_USED (tinfo) = 1;
1407       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1408     }
1409 }
1410
1411 /* Return non-zero, iff T is a type_info variable which has not had a
1412    definition emitted for it.  */
1413
1414 int
1415 tinfo_decl_p (t, data)
1416      tree t;
1417      void *data ATTRIBUTE_UNUSED;
1418 {
1419   return TREE_CODE (t) == VAR_DECL
1420          && IDENTIFIER_GLOBAL_VALUE (DECL_NAME (t)) == (t)
1421          && TREE_TYPE (t) == tinfo_decl_type
1422          && TREE_TYPE (DECL_NAME (t));
1423 }
1424
1425 /* Emit a suitable type_info definition for the type_info decl pointed to by
1426    DECL_PTR. We emit a completely new variable, of the correct type for the
1427    actual type this is describing. The DECL_ASSEMBLER_NAME of the generated
1428    definition is set to that of the supplied decl, so that they can be tied
1429    up. Mark the supplied decl as having been dealt with. Emitting one
1430    definition might cause other definitions to be required.
1431
1432    We need to do things this way, because we're trying to do something like
1433
1434       struct B : A {
1435         ...
1436       };
1437
1438       extern const A tinfo_var;
1439
1440       const B tinfo_var = {...};
1441
1442    which is not permitted. Also, we've not necessarily seen the definition of B.
1443    So we do something like the following,
1444
1445       extern const A tinfo_var;
1446
1447       struct pseudo_A {
1448         const void *vtable_ptr;
1449         const char *name;
1450       };
1451       struct pseudo_B {
1452         pseudo_A base;
1453         ...
1454       };
1455
1456       const pseudo_B proxy_tinfo_var attribute((assembler_name="tinfo_var")) =
1457       {
1458         {&B::vtable, "..."},
1459         ...
1460       };
1461
1462    pseudo_A and pseudo_B must be layout equivalent to the real definitions in
1463    the runtime.  */
1464
1465 int
1466 emit_tinfo_decl (decl_ptr, data)
1467      tree *decl_ptr;
1468      void *data ATTRIBUTE_UNUSED;
1469 {
1470   tree tinfo_decl = *decl_ptr;
1471   tree tinfo_type, decl;
1472
1473   my_friendly_assert (TREE_TYPE (tinfo_decl) == tinfo_decl_type, 20000121);
1474   tinfo_type = TREE_TYPE (DECL_NAME (tinfo_decl));
1475   my_friendly_assert (tinfo_type != NULL_TREE, 20000120);
1476
1477   if (!DECL_NEEDED_P (tinfo_decl))
1478     return 0;
1479   /* Say we've dealt with it.  */
1480   TREE_TYPE (DECL_NAME (tinfo_decl)) = NULL_TREE;
1481
1482   create_tinfo_types ();
1483   decl = synthesize_tinfo_var (tinfo_type, DECL_ASSEMBLER_NAME (tinfo_decl));
1484
1485   return decl != 0;
1486 }