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