gcc/cp/rtti.c

   1 /* RunTime Type Identification
   2    Copyright (C) 1995, 96-97, 1998, 1999 Free Software Foundation, Inc.
   3    Mostly written by Jason Merrill (jason@cygnus.com).
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "tree.h"
  26 #include "cp-tree.h"
  27 #include "flags.h"
  28 #include "output.h"
  29 #include "assert.h"
  30 #include "toplev.h"
  31
  32 #ifndef INT_TYPE_SIZE
  33 #define INT_TYPE_SIZE BITS_PER_WORD
  34 #endif
  35
  36 extern struct obstack permanent_obstack;
  37
  38 static tree call_void_fn PROTO((const char *));
  39 static tree build_headof_sub PROTO((tree));
  40 static tree build_headof PROTO((tree));
  41 static tree get_tinfo_var PROTO((tree));
  42 static tree ifnonnull PROTO((tree, tree));
  43 static tree build_dynamic_cast_1 PROTO((tree, tree));
  44 static void expand_si_desc PROTO((tree, tree));
  45 static void expand_class_desc PROTO((tree, tree));
  46 static void expand_attr_desc PROTO((tree, tree));
  47 static void expand_ptr_desc PROTO((tree, tree));
  48 static void expand_generic_desc PROTO((tree, tree, const char *));
  49 static tree throw_bad_cast PROTO((void));
  50 static tree throw_bad_typeid PROTO((void));
  51 \f
  52 void
  53 init_rtti_processing ()
  54 {
  55   if (flag_honor_std)
  56     push_namespace (get_identifier ("std"));
  57   type_info_type_node = xref_tag
  58     (class_type_node, get_identifier ("type_info"), 1);
  59   if (flag_honor_std)
  60     pop_namespace ();
  61   tinfo_fn_id = get_identifier ("__tf");
  62   tinfo_fn_type = build_function_type
  63     (build_reference_type (build_qualified_type (type_info_type_node,
  64                                                  TYPE_QUAL_CONST)),
  65      void_list_node);
  66 }
  67
  68 /* Given a pointer to an object with at least one virtual table
  69    pointer somewhere, return a pointer to a possible sub-object that
  70    has a virtual table pointer in it that is the vtable parent for
  71    that sub-object.  */
  72
  73 static tree
  74 build_headof_sub (exp)
  75      tree exp;
  76 {
  77   tree type = TREE_TYPE (TREE_TYPE (exp));
  78   tree basetype = CLASSTYPE_RTTI (type);
  79   tree binfo = get_binfo (basetype, type, 0);
  80
  81   exp = convert_pointer_to_real (binfo, exp);
  82   return exp;
  83 }
  84
  85 /* Given the expression EXP of type `class *', return the head of the
  86    object pointed to by EXP with type cv void*, if the class has any
  87    virtual functions (TYPE_VIRTUAL_P), else just return the
  88    expression.  */
  89
  90 static tree
  91 build_headof (exp)
  92      tree exp;
  93 {
  94   tree type = TREE_TYPE (exp);
  95   tree aref;
  96   tree offset;
  97
  98   if (TREE_CODE (type) != POINTER_TYPE)
  99     {
 100       error ("`headof' applied to non-pointer type");
 101       return error_mark_node;
 102     }
 103   type = TREE_TYPE (type);
 104
 105   if (!TYPE_VIRTUAL_P (type))
 106     return exp;
 107   if (CLASSTYPE_COM_INTERFACE (type))
 108     {
 109       cp_error ("RTTI not supported for COM interface type `%T'", type);
 110       return error_mark_node;
 111     }
 112
 113   /* If we don't have rtti stuff, get to a sub-object that does.  */
 114   if (!CLASSTYPE_VFIELDS (TREE_TYPE (TREE_TYPE (exp))))
 115     exp = build_headof_sub (exp);
 116
 117   /* We use this a couple of times below, protect it.  */
 118   exp = save_expr (exp);
 119
 120   aref = build_vtbl_ref (build_indirect_ref (exp, NULL_PTR), integer_zero_node);
 121
 122   if (flag_vtable_thunks)
 123     offset = aref;
 124   else
 125     offset = build_component_ref (aref, delta_identifier, NULL_TREE, 0);
 126
 127   type = build_qualified_type (ptr_type_node,
 128                                CP_TYPE_QUALS (TREE_TYPE (exp)));
 129   return build (PLUS_EXPR, type, exp,
 130                 cp_convert (ptrdiff_type_node, offset));
 131 }
 132
 133 /* Build a call to a generic entry point taking and returning void.  */
 134
 135 static tree
 136 call_void_fn (name)
 137      const char *name;
 138 {
 139   tree d = get_identifier (name);
 140   tree type;
 141
 142   if (IDENTIFIER_GLOBAL_VALUE (d))
 143     d = IDENTIFIER_GLOBAL_VALUE (d);
 144   else
 145     {
 146       push_obstacks (&permanent_obstack, &permanent_obstack);
 147
 148       type = build_function_type (void_type_node, void_list_node);
 149       d = build_lang_decl (FUNCTION_DECL, d, type);
 150       DECL_EXTERNAL (d) = 1;
 151       TREE_PUBLIC (d) = 1;
 152       DECL_ARTIFICIAL (d) = 1;
 153       pushdecl_top_level (d);
 154       make_function_rtl (d);
 155       pop_obstacks ();
 156     }
 157
 158   mark_used (d);
 159   return build_call (d, void_type_node, NULL_TREE);
 160 }
 161
 162 /* Get a bad_cast node for the program to throw...
 163
 164    See libstdc++/exception.cc for __throw_bad_cast */
 165
 166 static tree
 167 throw_bad_cast ()
 168 {
 169   return call_void_fn ("__throw_bad_cast");
 170 }
 171
 172 static tree
 173 throw_bad_typeid ()
 174 {
 175   return call_void_fn ("__throw_bad_typeid");
 176 }
 177 \f
 178 /* Return the type_info function associated with the expression EXP.  If
 179    EXP is a reference to a polymorphic class, return the dynamic type;
 180    otherwise return the static type of the expression.  */
 181
 182 tree
 183 get_tinfo_fn_dynamic (exp)
 184      tree exp;
 185 {
 186   tree type;
 187
 188   if (exp == error_mark_node)
 189     return error_mark_node;
 190
 191   if (type_unknown_p (exp))
 192     {
 193       error ("typeid of overloaded function");
 194       return error_mark_node;
 195     }
 196
 197   type = TREE_TYPE (exp);
 198
 199   /* peel back references, so they match.  */
 200   if (TREE_CODE (type) == REFERENCE_TYPE)
 201     type = TREE_TYPE (type);
 202
 203   /* Peel off cv qualifiers.  */
 204   type = TYPE_MAIN_VARIANT (type);
 205
 206   if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
 207     {
 208       cp_error ("taking typeid of incomplete type `%T'", type);
 209       return error_mark_node;
 210     }
 211
 212   /* If exp is a reference to polymorphic type, get the real type_info.  */
 213   if (TYPE_VIRTUAL_P (type) && ! resolves_to_fixed_type_p (exp, 0))
 214     {
 215       /* build reference to type_info from vtable.  */
 216       tree t;
 217
 218       if (! flag_rtti)
 219         error ("taking dynamic typeid of object with -fno-rtti");
 220       if (CLASSTYPE_COM_INTERFACE (type))
 221         {
 222           cp_error ("RTTI not supported for COM interface type `%T'", type);
 223           return error_mark_node;
 224         }
 225
 226       /* If we don't have rtti stuff, get to a sub-object that does.  */
 227       if (! CLASSTYPE_VFIELDS (type))
 228         {
 229           exp = build_unary_op (ADDR_EXPR, exp, 0);
 230           exp = build_headof_sub (exp);
 231           exp = build_indirect_ref (exp, NULL_PTR);
 232         }
 233
 234       if (flag_vtable_thunks)
 235         t = build_vfn_ref ((tree *) 0, exp, integer_one_node);
 236       else
 237         t = build_vfn_ref ((tree *) 0, exp, integer_zero_node);
 238       TREE_TYPE (t) = build_pointer_type (tinfo_fn_type);
 239       return t;
 240     }
 241
 242   /* otherwise return the type_info for the static type of the expr.  */
 243   return get_tinfo_fn (TYPE_MAIN_VARIANT (type));
 244 }
 245
 246 tree
 247 build_typeid (exp)
 248      tree exp;
 249 {
 250   exp = get_tinfo_fn_dynamic (exp);
 251   exp = build_call (exp, TREE_TYPE (tinfo_fn_type), NULL_TREE);
 252   return convert_from_reference (exp);
 253 }
 254
 255 tree
 256 build_x_typeid (exp)
 257      tree exp;
 258 {
 259   tree cond = NULL_TREE;
 260   tree type;
 261   int nonnull;
 262
 263   if (! flag_rtti)
 264     {
 265       error ("cannot use typeid with -fno-rtti");
 266       return error_mark_node;
 267     }
 268
 269   if (TYPE_SIZE (type_info_type_node) == NULL_TREE)
 270     {
 271       error ("must #include <typeinfo> before using typeid");
 272       return error_mark_node;
 273     }
 274
 275   if (processing_template_decl)
 276     return build_min_nt (TYPEID_EXPR, exp);
 277
 278   if (TREE_CODE (exp) == INDIRECT_REF
 279       && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
 280       && TYPE_VIRTUAL_P (TREE_TYPE (exp))
 281       && ! resolves_to_fixed_type_p (exp, &nonnull)
 282       && ! nonnull)
 283     {
 284       exp = stabilize_reference (exp);
 285       cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
 286     }
 287
 288   exp = get_tinfo_fn_dynamic (exp);
 289
 290   if (exp == error_mark_node)
 291     return error_mark_node;
 292
 293   type = TREE_TYPE (tinfo_fn_type);
 294   exp = build_call (exp, type, NULL_TREE);
 295
 296   if (cond)
 297     {
 298       tree bad = throw_bad_typeid ();
 299
 300       bad = build_compound_expr
 301         (tree_cons (NULL_TREE, bad, build_expr_list
 302                     (NULL_TREE, cp_convert (type, integer_zero_node))));
 303       exp = build (COND_EXPR, type, cond, exp, bad);
 304     }
 305
 306   return convert_from_reference (exp);
 307 }
 308
 309 static tree
 310 get_tinfo_var (type)
 311      tree type;
 312 {
 313   tree tname = build_overload_with_type (get_identifier ("__ti"), type);
 314   tree tdecl, arrtype;
 315   int size;
 316
 317   if (IDENTIFIER_GLOBAL_VALUE (tname))
 318     return IDENTIFIER_GLOBAL_VALUE (tname);
 319
 320   /* Figure out how much space we need to allocate for the type_info object.
 321      If our struct layout or the type_info classes are changed, this will
 322      need to be modified.  */
 323   if (TYPE_QUALS (type) != TYPE_UNQUALIFIED)
 324     size = 3 * POINTER_SIZE + INT_TYPE_SIZE;
 325   else if (TREE_CODE (type) == POINTER_TYPE
 326            && ! (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE
 327                  || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE))
 328     size = 3 * POINTER_SIZE;
 329   else if (IS_AGGR_TYPE (type))
 330     {
 331       if (CLASSTYPE_N_BASECLASSES (type) == 0)
 332         size = 2 * POINTER_SIZE;
 333       else if (! TYPE_USES_COMPLEX_INHERITANCE (type)
 334                && (TREE_VIA_PUBLIC
 335                    (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0))))
 336         size = 3 * POINTER_SIZE;
 337       else
 338         size = 3 * POINTER_SIZE + TYPE_PRECISION (sizetype);
 339     }
 340   else
 341     size = 2 * POINTER_SIZE;
 342
 343   push_obstacks (&permanent_obstack, &permanent_obstack);
 344
 345   /* The type for a character array of the appropriate size.  */
 346   arrtype = build_cplus_array_type
 347     (unsigned_char_type_node,
 348      build_index_type (size_int (size / BITS_PER_UNIT - 1)));
 349
 350   tdecl = build_decl (VAR_DECL, tname, arrtype);
 351   TREE_PUBLIC (tdecl) = 1;
 352   DECL_EXTERNAL (tdecl) = 1;
 353   DECL_ARTIFICIAL (tdecl) = 1;
 354   push_to_top_level ();
 355   pushdecl (tdecl);
 356   cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0);
 357   pop_from_top_level ();
 358
 359   pop_obstacks ();
 360
 361   return tdecl;
 362 }
 363
 364 tree
 365 get_tinfo_fn (type)
 366      tree type;
 367 {
 368   tree name;
 369   tree d;
 370
 371   if (TREE_CODE (type) == OFFSET_TYPE)
 372     type = TREE_TYPE (type);
 373   if (TREE_CODE (type) == METHOD_TYPE)
 374     type = build_function_type (TREE_TYPE (type),
 375                                 TREE_CHAIN (TYPE_ARG_TYPES (type)));
 376
 377   name = build_overload_with_type (tinfo_fn_id, type);
 378
 379   if (IDENTIFIER_GLOBAL_VALUE (name))
 380     return IDENTIFIER_GLOBAL_VALUE (name);
 381
 382   push_obstacks (&permanent_obstack, &permanent_obstack);
 383
 384   d = build_lang_decl (FUNCTION_DECL, name, tinfo_fn_type);
 385   DECL_EXTERNAL (d) = 1;
 386   TREE_PUBLIC (d) = 1;
 387   DECL_ARTIFICIAL (d) = 1;
 388   DECL_NOT_REALLY_EXTERN (d) = 1;
 389   SET_DECL_TINFO_FN_P (d);
 390   TREE_TYPE (name) = type;
 391
 392   pushdecl_top_level (d);
 393   make_function_rtl (d);
 394   mark_used (d);
 395   mark_inline_for_output (d);
 396   pop_obstacks ();
 397
 398   return d;
 399 }
 400
 401 tree
 402 get_typeid_1 (type)
 403      tree type;
 404 {
 405   tree t;
 406
 407   t = build_call
 408     (get_tinfo_fn (type), TREE_TYPE (tinfo_fn_type), NULL_TREE);
 409   return convert_from_reference (t);
 410 }
 411
 412 /* Return the type_info object for TYPE, creating it if necessary.  */
 413
 414 tree
 415 get_typeid (type)
 416      tree type;
 417 {
 418   if (type == error_mark_node)
 419     return error_mark_node;
 420
 421   if (TYPE_SIZE (type_info_type_node) == NULL_TREE)
 422     {
 423       error ("must #include <typeinfo> before using typeid");
 424       return error_mark_node;
 425     }
 426
 427   if (processing_template_decl)
 428     return build_min_nt (TYPEID_EXPR, type);
 429
 430   /* If the type of the type-id is a reference type, the result of the
 431      typeid expression refers to a type_info object representing the
 432      referenced type.  */
 433   if (TREE_CODE (type) == REFERENCE_TYPE)
 434     type = TREE_TYPE (type);
 435
 436   /* The top-level cv-qualifiers of the lvalue expression or the type-id
 437      that is the operand of typeid are always ignored.  */
 438   type = TYPE_MAIN_VARIANT (type);
 439
 440   if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
 441     {
 442       cp_error ("taking typeid of incomplete type `%T'", type);
 443       return error_mark_node;
 444     }
 445
 446   return get_typeid_1 (type);
 447 }
 448
 449 /* Check whether TEST is null before returning RESULT.  If TEST is used in
 450    RESULT, it must have previously had a save_expr applied to it.  */
 451
 452 static tree
 453 ifnonnull (test, result)
 454      tree test, result;
 455 {
 456   return build (COND_EXPR, TREE_TYPE (result),
 457                 build (EQ_EXPR, boolean_type_node, test, integer_zero_node),
 458                 cp_convert (TREE_TYPE (result), integer_zero_node),
 459                 result);
 460 }
 461
 462 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
 463    paper.  */
 464
 465 static tree
 466 build_dynamic_cast_1 (type, expr)
 467      tree type, expr;
 468 {
 469   enum tree_code tc = TREE_CODE (type);
 470   tree exprtype;
 471   enum tree_code ec;
 472   tree dcast_fn;
 473   tree old_expr = expr;
 474
 475   if (TREE_CODE (expr) == OFFSET_REF)
 476     expr = resolve_offset_ref (expr);
 477
 478   exprtype = TREE_TYPE (expr);
 479   assert (exprtype != NULL_TREE);
 480   ec = TREE_CODE (exprtype);
 481
 482   switch (tc)
 483     {
 484     case POINTER_TYPE:
 485       if (ec == REFERENCE_TYPE)
 486         {
 487           expr = convert_from_reference (expr);
 488           exprtype = TREE_TYPE (expr);
 489           ec = TREE_CODE (exprtype);
 490         }
 491       if (ec != POINTER_TYPE)
 492         goto fail;
 493       if (TREE_CODE (TREE_TYPE (exprtype)) != RECORD_TYPE)
 494         goto fail;
 495       if (TYPE_SIZE (complete_type (TREE_TYPE (exprtype))) == NULL_TREE)
 496         goto fail;
 497       if (!at_least_as_qualified_p (TREE_TYPE (type),
 498                                     TREE_TYPE (exprtype)))
 499         goto fail;
 500       if (TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
 501         break;
 502       /* else fall through */
 503     case REFERENCE_TYPE:
 504       if (TREE_CODE (TREE_TYPE (type)) != RECORD_TYPE)
 505         goto fail;
 506       if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
 507         goto fail;
 508       break;
 509       /* else fall through */
 510     default:
 511       goto fail;
 512     }
 513
 514   /* Apply trivial conversion T -> T& for dereferenced ptrs.  */
 515   if (ec == RECORD_TYPE)
 516     {
 517       exprtype = build_reference_type (exprtype);
 518       expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
 519                                    LOOKUP_NORMAL, NULL_TREE);
 520       ec = REFERENCE_TYPE;
 521     }
 522
 523   if (tc == REFERENCE_TYPE)
 524     {
 525       if (ec != REFERENCE_TYPE)
 526         goto fail;
 527       if (TREE_CODE (TREE_TYPE (exprtype)) != RECORD_TYPE)
 528         goto fail;
 529       if (TYPE_SIZE (complete_type (TREE_TYPE (exprtype))) == NULL_TREE)
 530         goto fail;
 531       if (!at_least_as_qualified_p (TREE_TYPE (type),
 532                                     TREE_TYPE (exprtype)))
 533         goto fail;
 534     }
 535
 536   /* If *type is an unambiguous accessible base class of *exprtype,
 537      convert statically.  */
 538   {
 539     int distance;
 540     tree path;
 541
 542     distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1,
 543                                   &path);
 544
 545     if (distance == -2)
 546       {
 547         cp_error ("dynamic_cast from `%T' to ambiguous base class `%T'",
 548                   TREE_TYPE (exprtype), TREE_TYPE (type));
 549         return error_mark_node;
 550       }
 551     if (distance == -3)
 552       {
 553         cp_error ("dynamic_cast from `%T' to private base class `%T'",
 554                   TREE_TYPE (exprtype), TREE_TYPE (type));
 555         return error_mark_node;
 556       }
 557
 558     if (distance >= 0)
 559       return build_vbase_path (PLUS_EXPR, type, expr, path, 0);
 560   }
 561
 562   /* Otherwise *exprtype must be a polymorphic class (have a vtbl).  */
 563   if (TYPE_VIRTUAL_P (TREE_TYPE (exprtype)))
 564     {
 565       tree expr1;
 566       /* if TYPE is `void *', return pointer to complete object.  */
 567       if (tc == POINTER_TYPE
 568           && TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
 569         {
 570           /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b.  */
 571           if (TREE_CODE (expr) == ADDR_EXPR
 572               && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
 573               && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
 574             return build1 (NOP_EXPR, type, expr);
 575
 576           /* Since expr is used twice below, save it.  */
 577           expr = save_expr (expr);
 578
 579           expr1 = build_headof (expr);
 580           if (TREE_TYPE (expr1) != type)
 581             expr1 = build1 (NOP_EXPR, type, expr1);
 582           return ifnonnull (expr, expr1);
 583         }
 584       else
 585         {
 586           tree retval;
 587           tree result, td1, td2, td3, elems, expr2;
 588           tree static_type, target_type, boff;
 589
 590           /* If we got here, we can't convert statically.  Therefore,
 591              dynamic_cast<D&>(b) (b an object) cannot succeed.  */
 592           if (ec == REFERENCE_TYPE)
 593             {
 594               if (TREE_CODE (old_expr) == VAR_DECL
 595                   && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
 596                 {
 597                   cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
 598                               old_expr, type);
 599                   return throw_bad_cast ();
 600                 }
 601             }
 602           /* Ditto for dynamic_cast<D*>(&b).  */
 603           else if (TREE_CODE (expr) == ADDR_EXPR)
 604             {
 605               tree op = TREE_OPERAND (expr, 0);
 606               if (TREE_CODE (op) == VAR_DECL
 607                   && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
 608                 {
 609                   cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
 610                               op, type);
 611                   retval = build_int_2 (0, 0);
 612                   TREE_TYPE (retval) = type;
 613                   return retval;
 614                 }
 615             }
 616
 617           /* Since expr is used twice below, save it.  */
 618           expr = save_expr (expr);
 619
 620           expr1 = expr;
 621           if (tc == REFERENCE_TYPE)
 622             expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
 623
 624           /* Build run-time conversion.  */
 625           expr2 = build_headof (expr1);
 626
 627           if (ec == POINTER_TYPE)
 628             td1 = get_tinfo_fn_dynamic (build_indirect_ref (expr, NULL_PTR));
 629           else
 630             td1 = get_tinfo_fn_dynamic (expr);
 631           td1 = decay_conversion (td1);
 632
 633           target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
 634           static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
 635           td2 = decay_conversion (get_tinfo_fn (target_type));
 636           td3 = decay_conversion (get_tinfo_fn (static_type));
 637
 638           /* Determine how T and V are related.  */
 639           boff = get_dynamic_cast_base_type (static_type, target_type);
 640
 641           elems = tree_cons
 642             (NULL_TREE, td1, tree_cons
 643              (NULL_TREE, td2, tree_cons
 644               (NULL_TREE, boff, tree_cons
 645                (NULL_TREE, expr2, tree_cons
 646                 (NULL_TREE, td3, tree_cons
 647                  (NULL_TREE, expr1, NULL_TREE))))));
 648
 649           dcast_fn = get_identifier ("__dynamic_cast_2");
 650           if (IDENTIFIER_GLOBAL_VALUE (dcast_fn))
 651             dcast_fn = IDENTIFIER_GLOBAL_VALUE (dcast_fn);
 652           else
 653             {
 654               tree tmp;
 655
 656               push_obstacks (&permanent_obstack, &permanent_obstack);
 657               tmp = tree_cons
 658                 (NULL_TREE, TREE_TYPE (td1), tree_cons
 659                  (NULL_TREE, TREE_TYPE (td1), tree_cons
 660                   (NULL_TREE, integer_type_node, tree_cons
 661                    (NULL_TREE, ptr_type_node, tree_cons
 662                     (NULL_TREE, TREE_TYPE (td1), tree_cons
 663                      (NULL_TREE, ptr_type_node, void_list_node))))));
 664               tmp = build_function_type (ptr_type_node, tmp);
 665               dcast_fn = build_lang_decl (FUNCTION_DECL, dcast_fn, tmp);
 666               DECL_EXTERNAL (dcast_fn) = 1;
 667               TREE_PUBLIC (dcast_fn) = 1;
 668               DECL_ARTIFICIAL (dcast_fn) = 1;
 669               pushdecl_top_level (dcast_fn);
 670               make_function_rtl (dcast_fn);
 671               pop_obstacks ();
 672             }
 673
 674           mark_used (dcast_fn);
 675           result = build_call
 676             (dcast_fn, TREE_TYPE (TREE_TYPE (dcast_fn)), elems);
 677
 678           if (tc == REFERENCE_TYPE)
 679             {
 680               expr1 = throw_bad_cast ();
 681               expr1 = build_compound_expr
 682                 (tree_cons (NULL_TREE, expr1,
 683                             build_expr_list (NULL_TREE, cp_convert (type, integer_zero_node))));
 684               TREE_TYPE (expr1) = type;
 685               result = save_expr (result);
 686               return build (COND_EXPR, type, result, result, expr1);
 687             }
 688
 689           /* Now back to the type we want from a void*.  */
 690           result = cp_convert (type, result);
 691           return ifnonnull (expr, result);
 692         }
 693     }
 694
 695   cp_error ("dynamic_cast from non-polymorphic type `%#T'", exprtype);
 696   return error_mark_node;
 697
 698  fail:
 699   cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T'",
 700             expr, exprtype, type);
 701   return error_mark_node;
 702 }
 703
 704 tree
 705 build_dynamic_cast (type, expr)
 706      tree type, expr;
 707 {
 708   if (type == error_mark_node || expr == error_mark_node)
 709     return error_mark_node;
 710
 711   if (processing_template_decl)
 712     return build_min (DYNAMIC_CAST_EXPR, type, expr);
 713
 714   return convert_from_reference (build_dynamic_cast_1 (type, expr));
 715 }
 716 \f
 717 /* Build and initialize various sorts of descriptors.  Every descriptor
 718    node has a name associated with it (the name created by mangling).
 719    For this reason, we use the identifier as our access to the __*_desc
 720    nodes, instead of sticking them directly in the types.  Otherwise we
 721    would burden all built-in types (and pointer types) with slots that
 722    we don't necessarily want to use.
 723
 724    For each descriptor we build, we build a variable that contains
 725    the descriptor's information.  When we need this info at runtime,
 726    all we need is access to these variables.
 727
 728    Note: these constructors always return the address of the descriptor
 729    info, since that is simplest for their mutual interaction.  */
 730
 731 /* Build an initializer for a __si_type_info node.  */
 732
 733 static void
 734 expand_si_desc (tdecl, type)
 735      tree tdecl;
 736      tree type;
 737 {
 738   tree t, elems, fn;
 739   const char *name = build_overload_name (type, 1, 1);
 740   tree name_string = combine_strings (build_string (strlen (name)+1, name));
 741
 742   type = BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0));
 743   finish_expr_stmt (get_typeid_1 (type));
 744   t = decay_conversion (get_tinfo_var (type));
 745   elems = tree_cons
 746     (NULL_TREE, decay_conversion (tdecl), tree_cons
 747      (NULL_TREE, decay_conversion (name_string), tree_cons
 748       (NULL_TREE, t, NULL_TREE)));
 749
 750   fn = get_identifier ("__rtti_si");
 751   if (IDENTIFIER_GLOBAL_VALUE (fn))
 752     fn = IDENTIFIER_GLOBAL_VALUE (fn);
 753   else
 754     {
 755       tree tmp;
 756       push_obstacks (&permanent_obstack, &permanent_obstack);
 757       tmp = tree_cons
 758         (NULL_TREE, ptr_type_node, tree_cons
 759          (NULL_TREE, const_string_type_node, tree_cons
 760           (NULL_TREE, build_pointer_type (type_info_type_node),
 761            void_list_node)));
 762       tmp = build_function_type (void_type_node, tmp);
 763
 764       fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
 765       DECL_EXTERNAL (fn) = 1;
 766       TREE_PUBLIC (fn) = 1;
 767       DECL_ARTIFICIAL (fn) = 1;
 768       pushdecl_top_level (fn);
 769       make_function_rtl (fn);
 770       pop_obstacks ();
 771     }
 772
 773   mark_used (fn);
 774   fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
 775   finish_expr_stmt (fn);
 776 }
 777
 778 /* Build an initializer for a __class_type_info node.  */
 779
 780 static void
 781 expand_class_desc (tdecl, type)
 782      tree tdecl;
 783      tree type;
 784 {
 785   tree name_string;
 786   tree fn, tmp;
 787   const char *name;
 788
 789   int i = CLASSTYPE_N_BASECLASSES (type);
 790   int base_cnt = 0;
 791   tree binfos = TYPE_BINFO_BASETYPES (type);
 792 #if 0
 793   /* See code below that used these.  */
 794   tree vb = CLASSTYPE_VBASECLASSES (type);
 795   int n_base = i;
 796 #endif
 797   tree base, elems, access, offset, isvir;
 798   tree elt, elts = NULL_TREE;
 799   static tree base_info_type_node;
 800
 801   if (base_info_type_node == NULL_TREE)
 802     {
 803       tree fields [4];
 804
 805       /* A reasonably close approximation of __class_type_info::base_info */
 806
 807       push_obstacks (&permanent_obstack, &permanent_obstack);
 808       base_info_type_node = make_lang_type (RECORD_TYPE);
 809
 810       /* Actually const __user_type_info * */
 811       fields [0] = build_lang_decl
 812         (FIELD_DECL, NULL_TREE,
 813          build_pointer_type (build_qualified_type
 814                              (type_info_type_node,
 815                               TYPE_QUAL_CONST)));
 816       fields [1] = build_lang_decl
 817         (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
 818       DECL_BIT_FIELD (fields[1]) = 1;
 819       DECL_FIELD_SIZE (fields[1]) = 29;
 820
 821       fields [2] = build_lang_decl
 822         (FIELD_DECL, NULL_TREE, boolean_type_node);
 823       DECL_BIT_FIELD (fields[2]) = 1;
 824       DECL_FIELD_SIZE (fields[2]) = 1;
 825
 826       /* Actually enum access */
 827       fields [3] = build_lang_decl
 828         (FIELD_DECL, NULL_TREE, integer_type_node);
 829       DECL_BIT_FIELD (fields[3]) = 1;
 830       DECL_FIELD_SIZE (fields[3]) = 2;
 831
 832       finish_builtin_type (base_info_type_node, "__base_info", fields,
 833                            3, ptr_type_node);
 834       pop_obstacks ();
 835     }
 836
 837   while (--i >= 0)
 838     {
 839       tree binfo = TREE_VEC_ELT (binfos, i);
 840
 841       finish_expr_stmt (get_typeid_1 (BINFO_TYPE (binfo)));
 842       base = decay_conversion (get_tinfo_var (BINFO_TYPE (binfo)));
 843
 844       if (TREE_VIA_VIRTUAL (binfo))
 845         {
 846           tree t = BINFO_TYPE (binfo);
 847           const char *name;
 848           tree field;
 849
 850           FORMAT_VBASE_NAME (name, t);
 851           field = lookup_field (type, get_identifier (name), 0, 0);
 852           offset = size_binop (FLOOR_DIV_EXPR,
 853                 DECL_FIELD_BITPOS (field), size_int (BITS_PER_UNIT));
 854           offset = convert (sizetype, offset);
 855         }
 856       else
 857         offset = BINFO_OFFSET (binfo);
 858
 859       if (TREE_VIA_PUBLIC (binfo))
 860         access = access_public_node;
 861       else if (TREE_VIA_PROTECTED (binfo))
 862         access = access_protected_node;
 863       else
 864         access = access_private_node;
 865       if (TREE_VIA_VIRTUAL (binfo))
 866         isvir = boolean_true_node;
 867       else
 868         isvir = boolean_false_node;
 869
 870       elt = build
 871         (CONSTRUCTOR, base_info_type_node, NULL_TREE, tree_cons
 872          (NULL_TREE, base, tree_cons
 873           (NULL_TREE, offset, tree_cons
 874            (NULL_TREE, isvir, tree_cons
 875             (NULL_TREE, access, NULL_TREE)))));
 876       TREE_HAS_CONSTRUCTOR (elt) = TREE_CONSTANT (elt) = TREE_STATIC (elt) = 1;
 877       elts = tree_cons (NULL_TREE, elt, elts);
 878       base_cnt++;
 879     }
 880 #if 0
 881   i = n_base;
 882   while (vb)
 883     {
 884       tree b;
 885       access = access_public_node;
 886       while (--i >= 0)
 887         {
 888           b = TREE_VEC_ELT (binfos, i);
 889           if (BINFO_TYPE (vb) == BINFO_TYPE (b) && TREE_VIA_VIRTUAL (b))
 890             {
 891               if (TREE_VIA_PUBLIC (b))
 892                 access = access_public_node;
 893               else if (TREE_VIA_PROTECTED (b))
 894                 access = access_protected_node;
 895               else
 896                 access = access_private_node;
 897               break;
 898             }
 899         }
 900       base = build_t_desc (BINFO_TYPE (vb), 1);
 901       offset = BINFO_OFFSET (vb);
 902       isvir = build_int_2 (1, 0);
 903
 904       base_list = tree_cons (NULL_TREE, base, base_list);
 905       isvir_list = tree_cons (NULL_TREE, isvir, isvir_list);
 906       acc_list = tree_cons (NULL_TREE, access, acc_list);
 907       off_list = tree_cons (NULL_TREE, offset, off_list);
 908
 909       base_cnt++;
 910       vb = TREE_CHAIN (vb);
 911     }
 912 #endif
 913
 914   name = build_overload_name (type, 1, 1);
 915   name_string = combine_strings (build_string (strlen (name)+1, name));
 916
 917   {
 918     tree arrtype = build_array_type (base_info_type_node, NULL_TREE);
 919     elts = build (CONSTRUCTOR, arrtype, NULL_TREE, elts);
 920     TREE_HAS_CONSTRUCTOR (elts) = TREE_CONSTANT (elts)
 921       = TREE_STATIC (elts) = 1;
 922     complete_array_type (arrtype, elts, 1);
 923   }
 924
 925   elems = tree_cons
 926     (NULL_TREE, decay_conversion (tdecl), tree_cons
 927      (NULL_TREE, decay_conversion (name_string), tree_cons
 928       (NULL_TREE, decay_conversion (elts), tree_cons
 929        (NULL_TREE, cp_convert (sizetype, build_int_2 (base_cnt, 0)),
 930         NULL_TREE))));
 931
 932   fn = get_identifier ("__rtti_class");
 933   if (IDENTIFIER_GLOBAL_VALUE (fn))
 934     fn = IDENTIFIER_GLOBAL_VALUE (fn);
 935   else
 936     {
 937       push_obstacks (&permanent_obstack, &permanent_obstack);
 938       tmp = tree_cons
 939         (NULL_TREE, ptr_type_node, tree_cons
 940          (NULL_TREE, const_string_type_node, tree_cons
 941           (NULL_TREE, build_pointer_type (base_info_type_node), tree_cons
 942            (NULL_TREE, sizetype, void_list_node))));
 943       tmp = build_function_type (void_type_node, tmp);
 944
 945       fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
 946       DECL_EXTERNAL (fn) = 1;
 947       TREE_PUBLIC (fn) = 1;
 948       DECL_ARTIFICIAL (fn) = 1;
 949       pushdecl_top_level (fn);
 950       make_function_rtl (fn);
 951       pop_obstacks ();
 952     }
 953
 954   mark_used (fn);
 955   fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
 956   finish_expr_stmt (fn);
 957 }
 958
 959 /* Build an initializer for a __pointer_type_info node.  */
 960
 961 static void
 962 expand_ptr_desc (tdecl, type)
 963      tree tdecl;
 964      tree type;
 965 {
 966   tree t, elems, fn;
 967   const char *name = build_overload_name (type, 1, 1);
 968   tree name_string = combine_strings (build_string (strlen (name)+1, name));
 969
 970   type = TREE_TYPE (type);
 971   finish_expr_stmt (get_typeid_1 (type));
 972   t = decay_conversion (get_tinfo_var (type));
 973   elems = tree_cons
 974     (NULL_TREE, decay_conversion (tdecl), tree_cons
 975      (NULL_TREE, decay_conversion (name_string), tree_cons
 976       (NULL_TREE, t, NULL_TREE)));
 977
 978   fn = get_identifier ("__rtti_ptr");
 979   if (IDENTIFIER_GLOBAL_VALUE (fn))
 980     fn = IDENTIFIER_GLOBAL_VALUE (fn);
 981   else
 982     {
 983       tree tmp;
 984       push_obstacks (&permanent_obstack, &permanent_obstack);
 985       tmp = tree_cons
 986         (NULL_TREE, ptr_type_node, tree_cons
 987          (NULL_TREE, const_string_type_node, tree_cons
 988           (NULL_TREE, build_pointer_type (type_info_type_node),
 989            void_list_node)));
 990       tmp = build_function_type (void_type_node, tmp);
 991
 992       fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
 993       DECL_EXTERNAL (fn) = 1;
 994       TREE_PUBLIC (fn) = 1;
 995       DECL_ARTIFICIAL (fn) = 1;
 996       pushdecl_top_level (fn);
 997       make_function_rtl (fn);
 998       pop_obstacks ();
 999     }
1000
1001   mark_used (fn);
1002   fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
1003   finish_expr_stmt (fn);
1004 }
1005
1006 /* Build an initializer for a __attr_type_info node.  */
1007
1008 static void
1009 expand_attr_desc (tdecl, type)
1010      tree tdecl;
1011      tree type;
1012 {
1013   tree elems, t, fn;
1014   const char *name = build_overload_name (type, 1, 1);
1015   tree name_string = combine_strings (build_string (strlen (name)+1, name));
1016   tree attrval = build_int_2 (TYPE_QUALS (type), 0);
1017
1018   finish_expr_stmt (get_typeid_1 (TYPE_MAIN_VARIANT (type)));
1019   t = decay_conversion (get_tinfo_var (TYPE_MAIN_VARIANT (type)));
1020   elems = tree_cons
1021     (NULL_TREE, decay_conversion (tdecl), tree_cons
1022      (NULL_TREE, decay_conversion (name_string), tree_cons
1023       (NULL_TREE, attrval, tree_cons (NULL_TREE, t, NULL_TREE))));
1024
1025   fn = get_identifier ("__rtti_attr");
1026   if (IDENTIFIER_GLOBAL_VALUE (fn))
1027     fn = IDENTIFIER_GLOBAL_VALUE (fn);
1028   else
1029     {
1030       tree tmp;
1031       push_obstacks (&permanent_obstack, &permanent_obstack);
1032       tmp = tree_cons
1033         (NULL_TREE, ptr_type_node, tree_cons
1034          (NULL_TREE, const_string_type_node, tree_cons
1035           (NULL_TREE, integer_type_node, tree_cons
1036            (NULL_TREE, build_pointer_type (type_info_type_node),
1037             void_list_node))));
1038       tmp = build_function_type (void_type_node, tmp);
1039
1040       fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
1041       DECL_EXTERNAL (fn) = 1;
1042       TREE_PUBLIC (fn) = 1;
1043       DECL_ARTIFICIAL (fn) = 1;
1044       pushdecl_top_level (fn);
1045       make_function_rtl (fn);
1046       pop_obstacks ();
1047     }
1048
1049   mark_used (fn);
1050   fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
1051   finish_expr_stmt (fn);
1052 }
1053
1054 /* Build an initializer for a type_info node that just has a name.  */
1055
1056 static void
1057 expand_generic_desc (tdecl, type, fnname)
1058      tree tdecl;
1059      tree type;
1060      const char *fnname;
1061 {
1062   const char *name = build_overload_name (type, 1, 1);
1063   tree name_string = combine_strings (build_string (strlen (name)+1, name));
1064   tree elems = tree_cons
1065     (NULL_TREE, decay_conversion (tdecl), tree_cons
1066      (NULL_TREE, decay_conversion (name_string), NULL_TREE));
1067
1068   tree fn = get_identifier (fnname);
1069   if (IDENTIFIER_GLOBAL_VALUE (fn))
1070     fn = IDENTIFIER_GLOBAL_VALUE (fn);
1071   else
1072     {
1073       tree tmp;
1074       push_obstacks (&permanent_obstack, &permanent_obstack);
1075       tmp = tree_cons
1076         (NULL_TREE, ptr_type_node, tree_cons
1077          (NULL_TREE, const_string_type_node, void_list_node));
1078       tmp = build_function_type (void_type_node, tmp);
1079
1080       fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
1081       DECL_EXTERNAL (fn) = 1;
1082       TREE_PUBLIC (fn) = 1;
1083       DECL_ARTIFICIAL (fn) = 1;
1084       pushdecl_top_level (fn);
1085       make_function_rtl (fn);
1086       pop_obstacks ();
1087     }
1088
1089   mark_used (fn);
1090   fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
1091   finish_expr_stmt (fn);
1092 }
1093
1094 /* Generate the code for a type_info initialization function.
1095    Note that we take advantage of the passage
1096
1097    5.2.7  Type identification                               [expr.typeid]
1098
1099    Whether or not the destructor is called for the type_info object at the
1100    end of the program is unspecified.
1101
1102    and don't bother to arrange for these objects to be destroyed.  It
1103    doesn't matter, anyway, since the destructors don't do anything.
1104
1105    This must only be called from toplevel (i.e. from finish_file)!  */
1106
1107 void
1108 synthesize_tinfo_fn (fndecl)
1109      tree fndecl;
1110 {
1111   tree type = TREE_TYPE (DECL_NAME (fndecl));
1112   tree tmp, addr, tdecl;
1113   tree compound_stmt;
1114   tree if_stmt;
1115   tree then_clause;
1116
1117   if (at_eof)
1118     {
1119       import_export_decl (fndecl);
1120       if (DECL_REALLY_EXTERN (fndecl))
1121         return;
1122     }
1123
1124   /* Declare the static typeinfo variable.  */
1125   tdecl = get_tinfo_var (type);
1126   DECL_EXTERNAL (tdecl) = 0;
1127   TREE_STATIC (tdecl) = 1;
1128   DECL_COMMON (tdecl) = 1;
1129   TREE_USED (tdecl) = 1;
1130   DECL_ALIGN (tdecl) = TYPE_ALIGN (ptr_type_node);
1131   cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0);
1132
1133   /* Begin processing the function.  */
1134   start_function (NULL_TREE, fndecl, NULL_TREE,
1135                   SF_DEFAULT | SF_PRE_PARSED);
1136   DECL_DEFER_OUTPUT (fndecl) = 1;
1137   store_parm_decls ();
1138   clear_last_expr ();
1139
1140   /* Begin the body of the function.  */
1141   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
1142
1143   /* For convenience, we save away the address of the static
1144      variable.  */
1145   addr = decay_conversion (tdecl);
1146
1147   /* If the first word of the array (the vtable) is non-zero, we've already
1148      initialized the object, so don't do it again.  */
1149   if_stmt = begin_if_stmt ();
1150   tmp = cp_convert (build_pointer_type (ptr_type_node), addr);
1151   tmp = build_indirect_ref (tmp, 0);
1152   tmp = build_binary_op (EQ_EXPR, tmp, integer_zero_node);
1153   finish_if_stmt_cond (tmp, if_stmt);
1154   then_clause = begin_compound_stmt (/*has_no_scope=*/0);
1155
1156   if (TREE_CODE (type) == FUNCTION_TYPE)
1157     expand_generic_desc (tdecl, type, "__rtti_func");
1158   else if (TREE_CODE (type) == ARRAY_TYPE)
1159     expand_generic_desc (tdecl, type, "__rtti_array");
1160   else if (TYPE_QUALS (type) != TYPE_UNQUALIFIED)
1161     expand_attr_desc (tdecl, type);
1162   else if (TREE_CODE (type) == POINTER_TYPE)
1163     {
1164       if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE)
1165         expand_generic_desc (tdecl, type, "__rtti_ptmd");
1166       else if (TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
1167         expand_generic_desc (tdecl, type, "__rtti_ptmf");
1168       else
1169         expand_ptr_desc (tdecl, type);
1170     }
1171   else if (TYPE_PTRMEMFUNC_P (type))
1172     expand_generic_desc (tdecl, type, "__rtti_ptmf");
1173   else if (IS_AGGR_TYPE (type))
1174     {
1175       if (CLASSTYPE_N_BASECLASSES (type) == 0)
1176         expand_generic_desc (tdecl, type, "__rtti_user");
1177       else if (! TYPE_USES_COMPLEX_INHERITANCE (type)
1178                && (TREE_VIA_PUBLIC
1179                    (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0))))
1180         expand_si_desc (tdecl, type);
1181       else
1182         expand_class_desc (tdecl, type);
1183     }
1184   else if (TREE_CODE (type) == ENUMERAL_TYPE)
1185     expand_generic_desc (tdecl, type, "__rtti_user");
1186   else
1187     my_friendly_abort (252);
1188
1189   finish_compound_stmt (/*has_no_scope=*/0, then_clause);
1190   finish_then_clause (if_stmt);
1191   finish_if_stmt ();
1192
1193   /* OK, now return the type_info object.  */
1194   tmp = cp_convert (build_pointer_type (type_info_type_node), addr);
1195   tmp = build_indirect_ref (tmp, 0);
1196   finish_return_stmt (tmp);
1197   /* Finish the function body.  */
1198   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
1199   expand_body (finish_function (lineno, 0));
1200 }