OSDN Git Service

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