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