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