OSDN Git Service

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