OSDN Git Service

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