gcc/cp/class.c

   1 /* Functions related to building classes and their related objects.
   2    Copyright (C) 1987, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
   3    Contributed by Michael Tiemann (tiemann@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 /* High-level class interface.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "tree.h"
  28 #include "cp-tree.h"
  29 #include "flags.h"
  30 #include "rtl.h"
  31 #include "output.h"
  32 #include "toplev.h"
  33
  34 #include "obstack.h"
  35 #define obstack_chunk_alloc xmalloc
  36 #define obstack_chunk_free free
  37
  38 extern struct obstack permanent_obstack;
  39
  40 /* This is how we tell when two virtual member functions are really the
  41    same.  */
  42 #define SAME_FN(FN1DECL, FN2DECL) (DECL_ASSEMBLER_NAME (FN1DECL) == DECL_ASSEMBLER_NAME (FN2DECL))
  43
  44 extern void set_class_shadows PROTO ((tree));
  45
  46 /* Way of stacking class types.  */
  47 static tree *current_class_base, *current_class_stack;
  48 static int current_class_stacksize;
  49 int current_class_depth;
  50
  51 struct class_level
  52 {
  53   /* The previous class level.  */
  54   struct class_level *level_chain;
  55
  56   /* The class instance variable, as a PARM_DECL.  */
  57   tree decl;
  58   /* The class instance variable, as an object.  */
  59   tree object;
  60   /* The virtual function table pointer
  61      for the class instance variable.  */
  62   tree vtable_decl;
  63
  64   /* Name of the current class.  */
  65   tree name;
  66   /* Type of the current class.  */
  67   tree type;
  68
  69   /* Flags for this class level.  */
  70   int this_is_variable;
  71   int memoized_lookups;
  72   int save_memoized;
  73   int unused;
  74 };
  75
  76 /* The current_class_ptr is the pointer to the current class.
  77    current_class_ref is the actual current class.  */
  78 tree current_class_ptr, current_class_ref;
  79
  80 /* The following two can be derived from the previous one */
  81 tree current_class_name;        /* IDENTIFIER_NODE: name of current class */
  82 tree current_class_type;        /* _TYPE: the type of the current class */
  83 tree previous_class_type;       /* _TYPE: the previous type that was a class */
  84 tree previous_class_values;             /* TREE_LIST: copy of the class_shadowed list
  85                                    when leaving an outermost class scope.  */
  86
  87 struct base_info;
  88
  89 static tree get_vfield_name PROTO((tree));
  90 static void finish_struct_anon PROTO((tree));
  91 static tree build_vbase_pointer PROTO((tree, tree));
  92 static int complete_type_p PROTO((tree));
  93 static tree build_vtable_entry PROTO((tree, tree));
  94 static tree get_vtable_name PROTO((tree));
  95 static tree get_derived_offset PROTO((tree, tree));
  96 static tree get_basefndecls PROTO((tree, tree));
  97 static void set_rtti_entry PROTO((tree, tree, tree));
  98 static tree build_vtable PROTO((tree, tree));
  99 static void prepare_fresh_vtable PROTO((tree, tree));
 100 static void fixup_vtable_deltas1 PROTO((tree, tree));
 101 static void fixup_vtable_deltas PROTO((tree, int, tree));
 102 static void grow_method PROTO((tree, tree *));
 103 static void finish_vtbls PROTO((tree, int, tree));
 104 static void modify_vtable_entry PROTO((tree, tree, tree));
 105 static tree get_vtable_entry_n PROTO((tree, unsigned HOST_WIDE_INT));
 106 static void add_virtual_function PROTO((tree *, tree *, int *, tree, tree));
 107 static tree delete_duplicate_fields_1 PROTO((tree, tree));
 108 static void delete_duplicate_fields PROTO((tree));
 109 static void finish_struct_bits PROTO((tree, int));
 110 static int alter_access PROTO((tree, tree, tree, tree));
 111 static void handle_using_decl PROTO((tree, tree, tree, tree));
 112 static int overrides PROTO((tree, tree));
 113 static int strictly_overrides PROTO((tree, tree));
 114 static void merge_overrides PROTO((tree, tree, int, tree));
 115 static void override_one_vtable PROTO((tree, tree, tree));
 116 static void mark_overriders PROTO((tree, tree));
 117 static void check_for_override PROTO((tree, tree));
 118 static tree maybe_fixup_vptrs PROTO((tree, tree, tree));
 119 static tree get_class_offset_1 PROTO((tree, tree, tree, tree, tree));
 120 static tree get_class_offset PROTO((tree, tree, tree, tree));
 121 static void modify_one_vtable PROTO((tree, tree, tree, tree));
 122 static void modify_all_vtables PROTO((tree, tree, tree));
 123 static void modify_all_direct_vtables PROTO((tree, int, tree, tree,
 124                                              tree));
 125 static void modify_all_indirect_vtables PROTO((tree, int, int, tree,
 126                                                tree, tree));
 127 static void build_class_init_list PROTO((tree));
 128 static int finish_base_struct PROTO((tree, struct base_info *));
 129
 130 /* Way of stacking language names.  */
 131 tree *current_lang_base, *current_lang_stack;
 132 int current_lang_stacksize;
 133
 134 /* Names of languages we recognize.  */
 135 tree lang_name_c, lang_name_cplusplus, lang_name_java;
 136 tree current_lang_name;
 137
 138 /* When layout out an aggregate type, the size of the
 139    basetypes (virtual and non-virtual) is passed to layout_record
 140    via this node.  */
 141 static tree base_layout_decl;
 142
 143 /* Constants used for access control.  */
 144 tree access_default_node; /* 0 */
 145 tree access_public_node; /* 1 */
 146 tree access_protected_node; /* 2 */
 147 tree access_private_node; /* 3 */
 148 tree access_default_virtual_node; /* 4 */
 149 tree access_public_virtual_node; /* 5 */
 150 tree access_protected_virtual_node; /* 6 */
 151 tree access_private_virtual_node; /* 7 */
 152
 153 /* Variables shared between class.c and call.c.  */
 154
 155 #ifdef GATHER_STATISTICS
 156 int n_vtables = 0;
 157 int n_vtable_entries = 0;
 158 int n_vtable_searches = 0;
 159 int n_vtable_elems = 0;
 160 int n_convert_harshness = 0;
 161 int n_compute_conversion_costs = 0;
 162 int n_build_method_call = 0;
 163 int n_inner_fields_searched = 0;
 164 #endif
 165
 166 /* Virtual baseclass things.  */
 167
 168 static tree
 169 build_vbase_pointer (exp, type)
 170      tree exp, type;
 171 {
 172   char *name;
 173
 174   name = (char *) alloca (TYPE_NAME_LENGTH (type) + sizeof (VBASE_NAME) + 1);
 175   sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (type));
 176   return build_component_ref (exp, get_identifier (name), NULL_TREE, 0);
 177 }
 178
 179 /* Is the type of the EXPR, the complete type of the object?
 180    If we are going to be wrong, we must be conservative, and return 0.  */
 181
 182 static int
 183 complete_type_p (expr)
 184      tree expr;
 185 {
 186   tree type = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
 187   while (1)
 188     {
 189       switch (TREE_CODE (expr))
 190         {
 191         case SAVE_EXPR:
 192         case INDIRECT_REF:
 193         case ADDR_EXPR:
 194         case NOP_EXPR:
 195         case CONVERT_EXPR:
 196           expr = TREE_OPERAND (expr, 0);
 197           continue;
 198
 199         case CALL_EXPR:
 200           if (! TREE_HAS_CONSTRUCTOR (expr))
 201             break;
 202           /* fall through...  */
 203         case VAR_DECL:
 204         case FIELD_DECL:
 205           if (TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
 206               && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (expr)))
 207               && TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type)
 208             return 1;
 209           /* fall through...  */
 210         case TARGET_EXPR:
 211         case PARM_DECL:
 212           if (IS_AGGR_TYPE (TREE_TYPE (expr))
 213               && TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type)
 214             return 1;
 215           /* fall through...  */
 216         case PLUS_EXPR:
 217         default:
 218           break;
 219         }
 220       break;
 221     }
 222   return 0;
 223 }
 224
 225 /* Build multi-level access to EXPR using hierarchy path PATH.
 226    CODE is PLUS_EXPR if we are going with the grain,
 227    and MINUS_EXPR if we are not (in which case, we cannot traverse
 228    virtual baseclass links).
 229
 230    TYPE is the type we want this path to have on exit.
 231
 232    ALIAS_THIS is non-zero if EXPR in an expression involving `this'.  */
 233
 234 tree
 235 build_vbase_path (code, type, expr, path, alias_this)
 236      enum tree_code code;
 237      tree type, expr, path;
 238      int alias_this;
 239 {
 240   register int changed = 0;
 241   tree last = NULL_TREE, last_virtual = NULL_TREE;
 242   int nonnull = 0;
 243   int fixed_type_p;
 244   tree null_expr = 0, nonnull_expr;
 245   tree basetype;
 246   tree offset = integer_zero_node;
 247
 248   if (BINFO_INHERITANCE_CHAIN (path) == NULL_TREE)
 249     return build1 (NOP_EXPR, type, expr);
 250
 251   if (nonnull == 0 && (alias_this && flag_this_is_variable <= 0))
 252     nonnull = 1;
 253
 254 #if 0
 255   /* We need additional logic to convert back to the unconverted type
 256      (the static type of the complete object), and then convert back
 257      to the type we want.  Until that is done, or until we can
 258      recognize when that is, we cannot do the short cut logic. (mrs) */
 259   fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
 260 #else
 261   /* Do this, until we can undo any previous conversions.  See net35.C
 262      for a testcase.  */
 263   fixed_type_p = complete_type_p (expr);
 264 #endif
 265
 266   if (!fixed_type_p && TREE_SIDE_EFFECTS (expr))
 267     expr = save_expr (expr);
 268   nonnull_expr = expr;
 269
 270   if (BINFO_INHERITANCE_CHAIN (path))
 271     {
 272       tree reverse_path = NULL_TREE;
 273
 274       push_expression_obstack ();
 275       while (path)
 276         {
 277           tree r = copy_node (path);
 278           BINFO_INHERITANCE_CHAIN (r) = reverse_path;
 279           reverse_path = r;
 280           path = BINFO_INHERITANCE_CHAIN (path);
 281         }
 282       path = reverse_path;
 283       pop_obstacks ();
 284     }
 285
 286   basetype = BINFO_TYPE (path);
 287
 288   while (path)
 289     {
 290       if (TREE_VIA_VIRTUAL (path))
 291         {
 292           last_virtual = BINFO_TYPE (path);
 293           if (code == PLUS_EXPR)
 294             {
 295               changed = ! fixed_type_p;
 296
 297               if (changed)
 298                 {
 299                   tree ind;
 300
 301                   /* We already check for ambiguous things in the caller, just
 302                      find a path.  */
 303                   if (last)
 304                     {
 305                       tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (nonnull_expr))), 0);
 306                       nonnull_expr = convert_pointer_to_real (binfo, nonnull_expr);
 307                     }
 308                   ind = build_indirect_ref (nonnull_expr, NULL_PTR);
 309                   nonnull_expr = build_vbase_pointer (ind, last_virtual);
 310                   if (nonnull == 0
 311                       && (TREE_CODE (type) == POINTER_TYPE
 312                           || !flag_assume_nonnull_objects)
 313                       && null_expr == NULL_TREE)
 314                     {
 315                       null_expr = build1 (NOP_EXPR, build_pointer_type (last_virtual), integer_zero_node);
 316                       expr = build (COND_EXPR, build_pointer_type (last_virtual),
 317                                     build (EQ_EXPR, boolean_type_node, expr,
 318                                            integer_zero_node),
 319                                     null_expr, nonnull_expr);
 320                     }
 321                 }
 322               /* else we'll figure out the offset below.  */
 323
 324               /* Happens in the case of parse errors.  */
 325               if (nonnull_expr == error_mark_node)
 326                 return error_mark_node;
 327             }
 328           else
 329             {
 330               cp_error ("cannot cast up from virtual baseclass `%T'",
 331                           last_virtual);
 332               return error_mark_node;
 333             }
 334         }
 335       last = path;
 336       path = BINFO_INHERITANCE_CHAIN (path);
 337     }
 338   /* LAST is now the last basetype assoc on the path.  */
 339
 340   /* A pointer to a virtual base member of a non-null object
 341      is non-null.  Therefore, we only need to test for zeroness once.
 342      Make EXPR the canonical expression to deal with here.  */
 343   if (null_expr)
 344     {
 345       TREE_OPERAND (expr, 2) = nonnull_expr;
 346       TREE_TYPE (expr) = TREE_TYPE (TREE_OPERAND (expr, 1))
 347         = TREE_TYPE (nonnull_expr);
 348     }
 349   else
 350     expr = nonnull_expr;
 351
 352   /* If we go through any virtual base pointers, make sure that
 353      casts to BASETYPE from the last virtual base class use
 354      the right value for BASETYPE.  */
 355   if (changed)
 356     {
 357       tree intype = TREE_TYPE (TREE_TYPE (expr));
 358       if (TYPE_MAIN_VARIANT (intype) != BINFO_TYPE (last))
 359         {
 360           tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (intype), 0);
 361           offset = BINFO_OFFSET (binfo);
 362         }
 363     }
 364   else
 365     {
 366       if (last_virtual)
 367         {
 368           offset = BINFO_OFFSET (binfo_member (last_virtual,
 369                                                CLASSTYPE_VBASECLASSES (basetype)));
 370           offset = size_binop (PLUS_EXPR, offset, BINFO_OFFSET (last));
 371         }
 372       else
 373         offset = BINFO_OFFSET (last);
 374     }
 375
 376   if (TREE_INT_CST_LOW (offset))
 377     {
 378       /* Bash types to make the backend happy.  */
 379       offset = cp_convert (type, offset);
 380 #if 0
 381       /* This shouldn't be necessary.  (mrs) */
 382       expr = build1 (NOP_EXPR, type, expr);
 383 #endif
 384
 385       /* For multiple inheritance: if `this' can be set by any
 386          function, then it could be 0 on entry to any function.
 387          Preserve such zeroness here.  Otherwise, only in the
 388          case of constructors need we worry, and in those cases,
 389          it will be zero, or initialized to some valid value to
 390          which we may add.  */
 391       if (nonnull == 0)
 392         {
 393           if (null_expr)
 394             TREE_TYPE (null_expr) = type;
 395           else
 396             null_expr = build1 (NOP_EXPR, type, integer_zero_node);
 397           if (TREE_SIDE_EFFECTS (expr))
 398             expr = save_expr (expr);
 399
 400           return build (COND_EXPR, type,
 401                         build (EQ_EXPR, boolean_type_node, expr, integer_zero_node),
 402                         null_expr,
 403                         build (code, type, expr, offset));
 404         }
 405       else return build (code, type, expr, offset);
 406     }
 407
 408   /* Cannot change the TREE_TYPE of a NOP_EXPR here, since it may
 409      be used multiple times in initialization of multiple inheritance.  */
 410   if (null_expr)
 411     {
 412       TREE_TYPE (expr) = type;
 413       return expr;
 414     }
 415   else
 416     return build1 (NOP_EXPR, type, expr);
 417 }
 418
 419 /* Virtual function things.  */
 420
 421 /* Build an entry in the virtual function table.
 422    DELTA is the offset for the `this' pointer.
 423    PFN is an ADDR_EXPR containing a pointer to the virtual function.
 424    Note that the index (DELTA2) in the virtual function table
 425    is always 0.  */
 426
 427 static tree
 428 build_vtable_entry (delta, pfn)
 429      tree delta, pfn;
 430 {
 431   if (flag_vtable_thunks)
 432     {
 433       HOST_WIDE_INT idelta = TREE_INT_CST_LOW (delta);
 434       if (idelta && ! DECL_ABSTRACT_VIRTUAL_P (TREE_OPERAND (pfn, 0)))
 435         {
 436           pfn = build1 (ADDR_EXPR, vtable_entry_type,
 437                         make_thunk (pfn, idelta));
 438           TREE_READONLY (pfn) = 1;
 439           TREE_CONSTANT (pfn) = 1;
 440         }
 441 #ifdef GATHER_STATISTICS
 442       n_vtable_entries += 1;
 443 #endif
 444       return pfn;
 445     }
 446   else
 447     {
 448       extern int flag_huge_objects;
 449       tree elems = expr_tree_cons (NULL_TREE, delta,
 450                               expr_tree_cons (NULL_TREE, integer_zero_node,
 451                                          build_expr_list (NULL_TREE, pfn)));
 452       tree entry = build (CONSTRUCTOR, vtable_entry_type, NULL_TREE, elems);
 453
 454       /* DELTA used to be constructed by `size_int' and/or size_binop,
 455          which caused overflow problems when it was negative.  That should
 456          be fixed now.  */
 457
 458       if (! int_fits_type_p (delta, delta_type_node))
 459         {
 460           if (flag_huge_objects)
 461             sorry ("object size exceeds built-in limit for virtual function table implementation");
 462           else
 463             sorry ("object size exceeds normal limit for virtual function table implementation, recompile all source and use -fhuge-objects");
 464         }
 465
 466       TREE_CONSTANT (entry) = 1;
 467       TREE_STATIC (entry) = 1;
 468       TREE_READONLY (entry) = 1;
 469
 470 #ifdef GATHER_STATISTICS
 471       n_vtable_entries += 1;
 472 #endif
 473
 474       return entry;
 475     }
 476 }
 477
 478 /* Given an object INSTANCE, return an expression which yields the
 479    virtual function vtable element corresponding to INDEX.  There are
 480    many special cases for INSTANCE which we take care of here, mainly
 481    to avoid creating extra tree nodes when we don't have to.  */
 482
 483 tree
 484 build_vtbl_ref (instance, idx)
 485      tree instance, idx;
 486 {
 487   tree vtbl, aref;
 488   tree basetype = TREE_TYPE (instance);
 489
 490   if (TREE_CODE (basetype) == REFERENCE_TYPE)
 491     basetype = TREE_TYPE (basetype);
 492
 493   if (instance == current_class_ref)
 494     vtbl = build_indirect_ref (build_vfield_ref (instance, basetype),
 495                                NULL_PTR);
 496   else
 497     {
 498       if (optimize)
 499         {
 500           /* Try to figure out what a reference refers to, and
 501              access its virtual function table directly.  */
 502           tree ref = NULL_TREE;
 503
 504           if (TREE_CODE (instance) == INDIRECT_REF
 505               && TREE_CODE (TREE_TYPE (TREE_OPERAND (instance, 0))) == REFERENCE_TYPE)
 506             ref = TREE_OPERAND (instance, 0);
 507           else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
 508             ref = instance;
 509
 510           if (ref && TREE_CODE (ref) == VAR_DECL
 511               && DECL_INITIAL (ref))
 512             {
 513               tree init = DECL_INITIAL (ref);
 514
 515               while (TREE_CODE (init) == NOP_EXPR
 516                      || TREE_CODE (init) == NON_LVALUE_EXPR)
 517                 init = TREE_OPERAND (init, 0);
 518               if (TREE_CODE (init) == ADDR_EXPR)
 519                 {
 520                   init = TREE_OPERAND (init, 0);
 521                   if (IS_AGGR_TYPE (TREE_TYPE (init))
 522                       && (TREE_CODE (init) == PARM_DECL
 523                           || TREE_CODE (init) == VAR_DECL))
 524                     instance = init;
 525                 }
 526             }
 527         }
 528
 529       if (IS_AGGR_TYPE (TREE_TYPE (instance))
 530           && (TREE_CODE (instance) == RESULT_DECL
 531               || TREE_CODE (instance) == PARM_DECL
 532               || TREE_CODE (instance) == VAR_DECL))
 533         vtbl = TYPE_BINFO_VTABLE (basetype);
 534       else
 535         vtbl = build_indirect_ref (build_vfield_ref (instance, basetype),
 536                                    NULL_PTR);
 537     }
 538   assemble_external (vtbl);
 539   aref = build_array_ref (vtbl, idx);
 540
 541   return aref;
 542 }
 543
 544 /* Given an object INSTANCE, return an expression which yields the
 545    virtual function corresponding to INDEX.  There are many special
 546    cases for INSTANCE which we take care of here, mainly to avoid
 547    creating extra tree nodes when we don't have to.  */
 548
 549 tree
 550 build_vfn_ref (ptr_to_instptr, instance, idx)
 551      tree *ptr_to_instptr, instance;
 552      tree idx;
 553 {
 554   tree aref = build_vtbl_ref (instance, idx);
 555
 556   /* When using thunks, there is no extra delta, and we get the pfn
 557      directly.  */
 558   if (flag_vtable_thunks)
 559     return aref;
 560
 561   if (ptr_to_instptr)
 562     {
 563       /* Save the intermediate result in a SAVE_EXPR so we don't have to
 564          compute each component of the virtual function pointer twice.  */
 565       if (TREE_CODE (aref) == INDIRECT_REF)
 566         TREE_OPERAND (aref, 0) = save_expr (TREE_OPERAND (aref, 0));
 567
 568       *ptr_to_instptr
 569         = build (PLUS_EXPR, TREE_TYPE (*ptr_to_instptr),
 570                  *ptr_to_instptr,
 571                  cp_convert (ptrdiff_type_node,
 572                              build_component_ref (aref, delta_identifier, NULL_TREE, 0)));
 573     }
 574
 575   return build_component_ref (aref, pfn_identifier, NULL_TREE, 0);
 576 }
 577
 578 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
 579    for the given TYPE.  */
 580
 581 static tree
 582 get_vtable_name (type)
 583      tree type;
 584 {
 585   tree type_id = build_typename_overload (type);
 586   char *buf = (char *) alloca (strlen (VTABLE_NAME_FORMAT)
 587                                + IDENTIFIER_LENGTH (type_id) + 2);
 588   char *ptr = IDENTIFIER_POINTER (type_id);
 589   int i;
 590   for (i = 0; ptr[i] == OPERATOR_TYPENAME_FORMAT[i]; i++) ;
 591 #if 0
 592   /* We don't take off the numbers; prepare_fresh_vtable uses the
 593      DECL_ASSEMBLER_NAME for the type, which includes the number
 594      in `3foo'.  If we were to pull them off here, we'd end up with
 595      something like `_vt.foo.3bar', instead of a uniform definition.  */
 596   while (ptr[i] >= '0' && ptr[i] <= '9')
 597     i += 1;
 598 #endif
 599   sprintf (buf, VTABLE_NAME_FORMAT, ptr+i);
 600   return get_identifier (buf);
 601 }
 602
 603 /* Return the offset to the main vtable for a given base BINFO.  */
 604
 605 tree
 606 get_vfield_offset (binfo)
 607      tree binfo;
 608 {
 609   tree tmp
 610     = size_binop (FLOOR_DIV_EXPR,
 611                   DECL_FIELD_BITPOS (CLASSTYPE_VFIELD (BINFO_TYPE (binfo))),
 612                   size_int (BITS_PER_UNIT));
 613   tmp = convert (sizetype, tmp);
 614   return size_binop (PLUS_EXPR, tmp, BINFO_OFFSET (binfo));
 615 }
 616
 617 /* Get the offset to the start of the original binfo that we derived
 618    this binfo from.  If we find TYPE first, return the offset only
 619    that far.  The shortened search is useful because the this pointer
 620    on method calling is expected to point to a DECL_CONTEXT (fndecl)
 621    object, and not a baseclass of it.  */
 622
 623 static tree
 624 get_derived_offset (binfo, type)
 625      tree binfo, type;
 626 {
 627   tree offset1 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo)));
 628   tree offset2;
 629   int i;
 630   while (BINFO_BASETYPES (binfo)
 631          && (i=CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo))) != -1)
 632     {
 633       tree binfos = BINFO_BASETYPES (binfo);
 634       if (BINFO_TYPE (binfo) == type)
 635         break;
 636       binfo = TREE_VEC_ELT (binfos, i);
 637     }
 638   offset2 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo)));
 639   return size_binop (MINUS_EXPR, offset1, offset2);
 640 }
 641
 642 /* Update the rtti info for this class.  */
 643
 644 static void
 645 set_rtti_entry (virtuals, offset, type)
 646      tree virtuals, offset, type;
 647 {
 648   tree vfn;
 649
 650   if (flag_rtti)
 651     vfn = build1 (ADDR_EXPR, vfunc_ptr_type_node, get_tinfo_fn (type));
 652   else
 653     vfn = build1 (NOP_EXPR, vfunc_ptr_type_node, size_zero_node);
 654   TREE_CONSTANT (vfn) = 1;
 655
 656   if (! flag_vtable_thunks)
 657     TREE_VALUE (virtuals) = build_vtable_entry (offset, vfn);
 658   else
 659     {
 660       tree voff = build1 (NOP_EXPR, vfunc_ptr_type_node, offset);
 661       TREE_CONSTANT (voff) = 1;
 662
 663       TREE_VALUE (virtuals) = build_vtable_entry (integer_zero_node, voff);
 664
 665       /* The second slot is for the tdesc pointer when thunks are used.  */
 666       TREE_VALUE (TREE_CHAIN (virtuals))
 667         = build_vtable_entry (integer_zero_node, vfn);
 668     }
 669 }
 670
 671 /* Build a virtual function for type TYPE.
 672    If BINFO is non-NULL, build the vtable starting with the initial
 673    approximation that it is the same as the one which is the head of
 674    the association list.  */
 675
 676 static tree
 677 build_vtable (binfo, type)
 678      tree binfo, type;
 679 {
 680   tree name = get_vtable_name (type);
 681   tree virtuals, decl;
 682
 683   if (binfo)
 684     {
 685       tree offset;
 686
 687       virtuals = copy_list (BINFO_VIRTUALS (binfo));
 688       decl = build_decl (VAR_DECL, name, TREE_TYPE (BINFO_VTABLE (binfo)));
 689
 690       /* Now do rtti stuff.  */
 691       offset = get_derived_offset (TYPE_BINFO (type), NULL_TREE);
 692       offset = ssize_binop (MINUS_EXPR, integer_zero_node, offset);
 693       set_rtti_entry (virtuals, offset, type);
 694     }
 695   else
 696     {
 697       virtuals = NULL_TREE;
 698       decl = build_decl (VAR_DECL, name, void_type_node);
 699     }
 700
 701 #ifdef GATHER_STATISTICS
 702   n_vtables += 1;
 703   n_vtable_elems += list_length (virtuals);
 704 #endif
 705
 706   /* Set TREE_PUBLIC and TREE_EXTERN as appropriate.  */
 707   import_export_vtable (decl, type, 0);
 708
 709   decl = pushdecl_top_level (decl);
 710   SET_IDENTIFIER_GLOBAL_VALUE (name, decl);
 711   /* Initialize the association list for this type, based
 712      on our first approximation.  */
 713   TYPE_BINFO_VTABLE (type) = decl;
 714   TYPE_BINFO_VIRTUALS (type) = virtuals;
 715
 716   DECL_ARTIFICIAL (decl) = 1;
 717   TREE_STATIC (decl) = 1;
 718 #ifndef WRITABLE_VTABLES
 719   /* Make them READONLY by default. (mrs) */
 720   TREE_READONLY (decl) = 1;
 721 #endif
 722   /* At one time the vtable info was grabbed 2 words at a time.  This
 723      fails on sparc unless you have 8-byte alignment.  (tiemann) */
 724   DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
 725                            DECL_ALIGN (decl));
 726
 727   /* Why is this conditional? (mrs) */
 728   if (binfo && write_virtuals >= 0)
 729     DECL_VIRTUAL_P (decl) = 1;
 730   DECL_CONTEXT (decl) = type;
 731
 732   binfo = TYPE_BINFO (type);
 733   SET_BINFO_NEW_VTABLE_MARKED (binfo);
 734   return decl;
 735 }
 736
 737 extern tree signed_size_zero_node;
 738
 739 /* Give TYPE a new virtual function table which is initialized
 740    with a skeleton-copy of its original initialization.  The only
 741    entry that changes is the `delta' entry, so we can really
 742    share a lot of structure.
 743
 744    FOR_TYPE is the derived type which caused this table to
 745    be needed.
 746
 747    BINFO is the type association which provided TYPE for FOR_TYPE.
 748
 749    The order in which vtables are built (by calling this function) for
 750    an object must remain the same, otherwise a binary incompatibility
 751    can result.  */
 752
 753 static void
 754 prepare_fresh_vtable (binfo, for_type)
 755      tree binfo, for_type;
 756 {
 757   tree basetype;
 758   tree orig_decl = BINFO_VTABLE (binfo);
 759   tree name;
 760   tree new_decl;
 761   tree offset;
 762   tree path = binfo;
 763   char *buf, *buf2;
 764   char joiner = '_';
 765   int i;
 766
 767 #ifdef JOINER
 768   joiner = JOINER;
 769 #endif
 770
 771   basetype = TYPE_MAIN_VARIANT (BINFO_TYPE (binfo));
 772
 773   buf2 = TYPE_ASSEMBLER_NAME_STRING (basetype);
 774   i = TYPE_ASSEMBLER_NAME_LENGTH (basetype) + 1;
 775
 776   /* We know that the vtable that we are going to create doesn't exist
 777      yet in the global namespace, and when we finish, it will be
 778      pushed into the global namespace.  In complex MI hierarchies, we
 779      have to loop while the name we are thinking of adding is globally
 780      defined, adding more name components to the vtable name as we
 781      loop, until the name is unique.  This is because in complex MI
 782      cases, we might have the same base more than once.  This means
 783      that the order in which this function is called for vtables must
 784      remain the same, otherwise binary compatibility can be
 785      compromised.  */
 786
 787   while (1)
 788     {
 789       char *buf1 = (char *) alloca (TYPE_ASSEMBLER_NAME_LENGTH (for_type)
 790                                     + 1 + i);
 791       char *new_buf2;
 792
 793       sprintf (buf1, "%s%c%s", TYPE_ASSEMBLER_NAME_STRING (for_type), joiner,
 794                buf2);
 795       buf = (char *) alloca (strlen (VTABLE_NAME_FORMAT) + strlen (buf1) + 1);
 796       sprintf (buf, VTABLE_NAME_FORMAT, buf1);
 797       name = get_identifier (buf);
 798
 799       /* If this name doesn't clash, then we can use it, otherwise
 800          we add more to the name until it is unique.  */
 801
 802       if (! IDENTIFIER_GLOBAL_VALUE (name))
 803         break;
 804
 805       /* Set values for next loop through, if the name isn't unique.  */
 806
 807       path = BINFO_INHERITANCE_CHAIN (path);
 808
 809       /* We better not run out of stuff to make it unique.  */
 810       my_friendly_assert (path != NULL_TREE, 368);
 811
 812       basetype = TYPE_MAIN_VARIANT (BINFO_TYPE (path));
 813
 814       if (for_type == basetype)
 815         {
 816           /* If we run out of basetypes in the path, we have already
 817              found created a vtable with that name before, we now
 818              resort to tacking on _%d to distinguish them.  */
 819           int j = 2;
 820           i = TYPE_ASSEMBLER_NAME_LENGTH (basetype) + 1 + i + 1 + 3;
 821           buf1 = (char *) alloca (i);
 822           do {
 823             sprintf (buf1, "%s%c%s%c%d",
 824                      TYPE_ASSEMBLER_NAME_STRING (basetype), joiner,
 825                      buf2, joiner, j);
 826             buf = (char *) alloca (strlen (VTABLE_NAME_FORMAT)
 827                                    + strlen (buf1) + 1);
 828             sprintf (buf, VTABLE_NAME_FORMAT, buf1);
 829             name = get_identifier (buf);
 830
 831             /* If this name doesn't clash, then we can use it,
 832                otherwise we add something different to the name until
 833                it is unique.  */
 834           } while (++j <= 999 && IDENTIFIER_GLOBAL_VALUE (name));
 835
 836           /* Hey, they really like MI don't they?  Increase the 3
 837              above to 6, and the 999 to 999999.  :-)  */
 838           my_friendly_assert (j <= 999, 369);
 839
 840           break;
 841         }
 842
 843       i = TYPE_ASSEMBLER_NAME_LENGTH (basetype) + 1 + i;
 844       new_buf2 = (char *) alloca (i);
 845       sprintf (new_buf2, "%s%c%s",
 846                TYPE_ASSEMBLER_NAME_STRING (basetype), joiner, buf2);
 847       buf2 = new_buf2;
 848     }
 849
 850   new_decl = build_decl (VAR_DECL, name, TREE_TYPE (orig_decl));
 851   /* Remember which class this vtable is really for.  */
 852   DECL_CONTEXT (new_decl) = for_type;
 853
 854   DECL_ARTIFICIAL (new_decl) = 1;
 855   TREE_STATIC (new_decl) = 1;
 856   BINFO_VTABLE (binfo) = pushdecl_top_level (new_decl);
 857   DECL_VIRTUAL_P (new_decl) = 1;
 858 #ifndef WRITABLE_VTABLES
 859   /* Make them READONLY by default. (mrs) */
 860   TREE_READONLY (new_decl) = 1;
 861 #endif
 862   DECL_ALIGN (new_decl) = DECL_ALIGN (orig_decl);
 863
 864   /* Make fresh virtual list, so we can smash it later.  */
 865   BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
 866
 867   if (TREE_VIA_VIRTUAL (binfo))
 868     {
 869       tree binfo1 = binfo_member (BINFO_TYPE (binfo),
 870                                   CLASSTYPE_VBASECLASSES (for_type));
 871
 872       /* XXX - This should never happen, if it does, the caller should
 873          ensure that the binfo is from for_type's binfos, not from any
 874          base type's.  We can remove all this code after a while.  */
 875       if (binfo1 != binfo)
 876         warning ("internal inconsistency: binfo offset error for rtti");
 877
 878       offset = BINFO_OFFSET (binfo1);
 879     }
 880   else
 881     offset = BINFO_OFFSET (binfo);
 882
 883   set_rtti_entry (BINFO_VIRTUALS (binfo),
 884                   ssize_binop (MINUS_EXPR, integer_zero_node, offset),
 885                   for_type);
 886
 887 #ifdef GATHER_STATISTICS
 888   n_vtables += 1;
 889   n_vtable_elems += list_length (BINFO_VIRTUALS (binfo));
 890 #endif
 891
 892   /* Set TREE_PUBLIC and TREE_EXTERN as appropriate.  */
 893   import_export_vtable (new_decl, for_type, 0);
 894
 895   if (TREE_VIA_VIRTUAL (binfo))
 896     my_friendly_assert (binfo == binfo_member (BINFO_TYPE (binfo),
 897                                    CLASSTYPE_VBASECLASSES (current_class_type)),
 898                         170);
 899   SET_BINFO_NEW_VTABLE_MARKED (binfo);
 900 }
 901
 902 #if 0
 903 /* Access the virtual function table entry that logically
 904    contains BASE_FNDECL.  VIRTUALS is the virtual function table's
 905    initializer.  We can run off the end, when dealing with virtual
 906    destructors in MI situations, return NULL_TREE in that case.  */
 907
 908 static tree
 909 get_vtable_entry (virtuals, base_fndecl)
 910      tree virtuals, base_fndecl;
 911 {
 912   unsigned HOST_WIDE_INT n = (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
 913            ? (TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl))
 914               & (((unsigned HOST_WIDE_INT)1<<(BITS_PER_WORD-1))-1))
 915            : TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl)));
 916
 917 #ifdef GATHER_STATISTICS
 918   n_vtable_searches += n;
 919 #endif
 920
 921   while (n > 0 && virtuals)
 922     {
 923       --n;
 924       virtuals = TREE_CHAIN (virtuals);
 925     }
 926   return virtuals;
 927 }
 928 #endif
 929
 930 /* Put new entry ENTRY into virtual function table initializer
 931    VIRTUALS.
 932
 933    Also update DECL_VINDEX (FNDECL).  */
 934
 935 static void
 936 modify_vtable_entry (old_entry_in_list, new_entry, fndecl)
 937      tree old_entry_in_list, new_entry, fndecl;
 938 {
 939   tree base_fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (old_entry_in_list)), 0);
 940
 941 #ifdef NOTQUITE
 942   cp_warning ("replaced %D with %D", DECL_ASSEMBLER_NAME (base_fndecl),
 943               DECL_ASSEMBLER_NAME (fndecl));
 944 #endif
 945   TREE_VALUE (old_entry_in_list) = new_entry;
 946
 947   /* Now assign virtual dispatch information, if unset.  */
 948   /* We can dispatch this, through any overridden base function.  */
 949   if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
 950     {
 951       DECL_VINDEX (fndecl) = DECL_VINDEX (base_fndecl);
 952       DECL_CONTEXT (fndecl) = DECL_CONTEXT (base_fndecl);
 953     }
 954 }
 955
 956 /* Access the virtual function table entry N.  VIRTUALS is the virtual
 957    function table's initializer.  */
 958
 959 static tree
 960 get_vtable_entry_n (virtuals, n)
 961      tree virtuals;
 962      unsigned HOST_WIDE_INT n;
 963 {
 964   while (n > 0)
 965     {
 966       --n;
 967       virtuals = TREE_CHAIN (virtuals);
 968     }
 969   return virtuals;
 970 }
 971
 972 /* Add a virtual function to all the appropriate vtables for the class
 973    T.  DECL_VINDEX(X) should be error_mark_node, if we want to
 974    allocate a new slot in our table.  If it is error_mark_node, we
 975    know that no other function from another vtable is overridden by X.
 976    HAS_VIRTUAL keeps track of how many virtuals there are in our main
 977    vtable for the type, and we build upon the PENDING_VIRTUALS list
 978    and return it.  */
 979
 980 static void
 981 add_virtual_function (pv, phv, has_virtual, fndecl, t)
 982      tree *pv, *phv;
 983      int *has_virtual;
 984      tree fndecl;
 985      tree t; /* Structure type.  */
 986 {
 987   tree pending_virtuals = *pv;
 988   tree pending_hard_virtuals = *phv;
 989
 990   /* FUNCTION_TYPEs and OFFSET_TYPEs no longer freely
 991      convert to void *.  Make such a conversion here.  */
 992   tree vfn = build1 (ADDR_EXPR, vfunc_ptr_type_node, fndecl);
 993   TREE_CONSTANT (vfn) = 1;
 994
 995 #ifndef DUMB_USER
 996   if (current_class_type == 0)
 997     cp_warning ("internal problem, current_class_type is zero when adding `%D', please report",
 998                 fndecl);
 999   if (current_class_type && t != current_class_type)
1000     cp_warning ("internal problem, current_class_type differs when adding `%D', please report",
1001                 fndecl);
1002 #endif
1003
1004   /* If the virtual function is a redefinition of a prior one,
1005      figure out in which base class the new definition goes,
1006      and if necessary, make a fresh virtual function table
1007      to hold that entry.  */
1008   if (DECL_VINDEX (fndecl) == error_mark_node)
1009     {
1010       tree entry;
1011
1012       /* We remember that this was the base sub-object for rtti.  */
1013       CLASSTYPE_RTTI (t) = t;
1014
1015       /* If we are using thunks, use two slots at the front, one
1016          for the offset pointer, one for the tdesc pointer.  */
1017       if (*has_virtual == 0 && flag_vtable_thunks)
1018         {
1019           *has_virtual = 1;
1020         }
1021
1022       /* Build a new INT_CST for this DECL_VINDEX.  */
1023       {
1024         static tree index_table[256];
1025         tree idx;
1026         /* We skip a slot for the offset/tdesc entry.  */
1027         int i = ++(*has_virtual);
1028
1029         if (i >= 256 || index_table[i] == 0)
1030           {
1031             idx = build_int_2 (i, 0);
1032             if (i < 256)
1033               index_table[i] = idx;
1034           }
1035         else
1036           idx = index_table[i];
1037
1038         /* Now assign virtual dispatch information.  */
1039         DECL_VINDEX (fndecl) = idx;
1040         DECL_CONTEXT (fndecl) = t;
1041       }
1042       entry = build_vtable_entry (integer_zero_node, vfn);
1043       pending_virtuals = tree_cons (DECL_VINDEX (fndecl), entry, pending_virtuals);
1044     }
1045   /* Might already be INTEGER_CST if declared twice in class.  We will
1046      give error later or we've already given it.  */
1047   else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
1048     {
1049       /* Need an entry in some other virtual function table.
1050          Deal with this after we have laid out our virtual base classes.  */
1051       pending_hard_virtuals = temp_tree_cons (fndecl, vfn, pending_hard_virtuals);
1052     }
1053   *pv = pending_virtuals;
1054   *phv = pending_hard_virtuals;
1055 }
1056 \f
1057 /* Obstack on which to build the vector of class methods.  */
1058 struct obstack class_obstack;
1059 extern struct obstack *current_obstack;
1060
1061 /* Add method METHOD to class TYPE.  This is used when a method
1062    has been defined which did not initially appear in the class definition,
1063    and helps cut down on spurious error messages.
1064
1065    FIELDS is the entry in the METHOD_VEC vector entry of the class type where
1066    the method should be added.  */
1067
1068 void
1069 add_method (type, fields, method)
1070      tree type, *fields, method;
1071 {
1072   push_obstacks (&permanent_obstack, &permanent_obstack);
1073
1074   if (fields && *fields)
1075       *fields = build_overload (method, *fields);
1076   else if (CLASSTYPE_METHOD_VEC (type) == 0)
1077     {
1078       tree method_vec = make_node (TREE_VEC);
1079       if (TYPE_IDENTIFIER (type) == DECL_NAME (method))
1080         {
1081           /* ??? Is it possible for there to have been enough room in the
1082              current chunk for the tree_vec structure but not a tree_vec
1083              plus a tree*?  Will this work in that case?  */
1084           obstack_free (current_obstack, method_vec);
1085           obstack_blank (current_obstack, sizeof (struct tree_vec) + sizeof (tree *));
1086           if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (method)))
1087             TREE_VEC_ELT (method_vec, 1) = method;
1088           else
1089             TREE_VEC_ELT (method_vec, 0) = method;
1090           TREE_VEC_LENGTH (method_vec) = 2;
1091         }
1092       else
1093         {
1094           /* ??? Is it possible for there to have been enough room in the
1095              current chunk for the tree_vec structure but not a tree_vec
1096              plus a tree*?  Will this work in that case?  */
1097           obstack_free (current_obstack, method_vec);
1098           obstack_blank (current_obstack, sizeof (struct tree_vec) + 2*sizeof (tree *));
1099           TREE_VEC_ELT (method_vec, 2) = method;
1100           TREE_VEC_LENGTH (method_vec) = 3;
1101           obstack_finish (current_obstack);
1102         }
1103       CLASSTYPE_METHOD_VEC (type) = method_vec;
1104     }
1105   else
1106     {
1107       tree method_vec = CLASSTYPE_METHOD_VEC (type);
1108       int len = TREE_VEC_LENGTH (method_vec);
1109
1110       /* Adding a new ctor or dtor.  This is easy because our
1111          METHOD_VEC always has a slot for such entries.  */
1112       if (TYPE_IDENTIFIER (type) == DECL_NAME (method))
1113         {
1114           int idx = !!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (method));
1115           /* TREE_VEC_ELT (method_vec, idx) = method; */
1116           if (method != TREE_VEC_ELT (method_vec, idx))
1117             TREE_VEC_ELT (method_vec, idx) =
1118               build_overload (method, TREE_VEC_ELT (method_vec, idx));
1119         }
1120       else
1121         {
1122           /* This is trickier.  We try to extend the TREE_VEC in-place,
1123              but if that does not work, we copy all its data to a new
1124              TREE_VEC that's large enough.  */
1125           struct obstack *ob = &class_obstack;
1126           tree *end = (tree *)obstack_next_free (ob);
1127
1128           if (end != TREE_VEC_END (method_vec))
1129             {
1130               ob = current_obstack;
1131               TREE_VEC_LENGTH (method_vec) += 1;
1132               TREE_VEC_ELT (method_vec, len) = NULL_TREE;
1133               method_vec = copy_node (method_vec);
1134               TREE_VEC_LENGTH (method_vec) -= 1;
1135             }
1136           else
1137             {
1138               tree tmp_vec = (tree) obstack_base (ob);
1139               if (obstack_room (ob) < sizeof (tree))
1140                 {
1141                   obstack_blank (ob, sizeof (struct tree_common)
1142                                  + tree_code_length[(int) TREE_VEC]
1143                                    * sizeof (char *)
1144                                  + len * sizeof (tree));
1145                   tmp_vec = (tree) obstack_base (ob);
1146                   bcopy ((char *) method_vec, (char *) tmp_vec,
1147                          (sizeof (struct tree_common)
1148                           + tree_code_length[(int) TREE_VEC] * sizeof (char *)
1149                           + (len-1) * sizeof (tree)));
1150                   method_vec = tmp_vec;
1151                 }
1152               else
1153                 obstack_blank (ob, sizeof (tree));
1154             }
1155
1156           obstack_finish (ob);
1157           TREE_VEC_ELT (method_vec, len) = method;
1158           TREE_VEC_LENGTH (method_vec) = len + 1;
1159           CLASSTYPE_METHOD_VEC (type) = method_vec;
1160
1161           if (TYPE_BINFO_BASETYPES (type) && CLASSTYPE_BASELINK_VEC (type))
1162             {
1163               /* ??? May be better to know whether these can be extended?  */
1164               tree baselink_vec = CLASSTYPE_BASELINK_VEC (type);
1165
1166               TREE_VEC_LENGTH (baselink_vec) += 1;
1167               CLASSTYPE_BASELINK_VEC (type) = copy_node (baselink_vec);
1168               TREE_VEC_LENGTH (baselink_vec) -= 1;
1169
1170               TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), len) = 0;
1171             }
1172         }
1173     }
1174   DECL_CONTEXT (method) = type;
1175   DECL_CLASS_CONTEXT (method) = type;
1176
1177   pop_obstacks ();
1178 }
1179
1180 /* Subroutines of finish_struct.  */
1181
1182 /* Look through the list of fields for this struct, deleting
1183    duplicates as we go.  This must be recursive to handle
1184    anonymous unions.
1185
1186    FIELD is the field which may not appear anywhere in FIELDS.
1187    FIELD_PTR, if non-null, is the starting point at which
1188    chained deletions may take place.
1189    The value returned is the first acceptable entry found
1190    in FIELDS.
1191
1192    Note that anonymous fields which are not of UNION_TYPE are
1193    not duplicates, they are just anonymous fields.  This happens
1194    when we have unnamed bitfields, for example.  */
1195
1196 static tree
1197 delete_duplicate_fields_1 (field, fields)
1198      tree field, fields;
1199 {
1200   tree x;
1201   tree prev = 0;
1202   if (DECL_NAME (field) == 0)
1203     {
1204       if (TREE_CODE (TREE_TYPE (field)) != UNION_TYPE)
1205         return fields;
1206
1207       for (x = TYPE_FIELDS (TREE_TYPE (field)); x; x = TREE_CHAIN (x))
1208         fields = delete_duplicate_fields_1 (x, fields);
1209       return fields;
1210     }
1211   else
1212     {
1213       for (x = fields; x; prev = x, x = TREE_CHAIN (x))
1214         {
1215           if (DECL_NAME (x) == 0)
1216             {
1217               if (TREE_CODE (TREE_TYPE (x)) != UNION_TYPE)
1218                 continue;
1219               TYPE_FIELDS (TREE_TYPE (x))
1220                 = delete_duplicate_fields_1 (field, TYPE_FIELDS (TREE_TYPE (x)));
1221               if (TYPE_FIELDS (TREE_TYPE (x)) == 0)
1222                 {
1223                   if (prev == 0)
1224                     fields = TREE_CHAIN (fields);
1225                   else
1226                     TREE_CHAIN (prev) = TREE_CHAIN (x);
1227                 }
1228             }
1229           else
1230             {
1231               if (DECL_NAME (field) == DECL_NAME (x))
1232                 {
1233                   if (TREE_CODE (field) == CONST_DECL
1234                       && TREE_CODE (x) == CONST_DECL)
1235                     cp_error_at ("duplicate enum value `%D'", x);
1236                   else if (TREE_CODE (field) == CONST_DECL
1237                            || TREE_CODE (x) == CONST_DECL)
1238                     cp_error_at ("duplicate field `%D' (as enum and non-enum)",
1239                                 x);
1240                   else if (DECL_DECLARES_TYPE_P (field)
1241                            && DECL_DECLARES_TYPE_P (x))
1242                     {
1243                       if (comptypes (TREE_TYPE (field), TREE_TYPE (x), 1))
1244                         continue;
1245                       cp_error_at ("duplicate nested type `%D'", x);
1246                     }
1247                   else if (DECL_DECLARES_TYPE_P (field)
1248                            || DECL_DECLARES_TYPE_P (x))
1249                     {
1250                       /* Hide tag decls.  */
1251                       if ((TREE_CODE (field) == TYPE_DECL
1252                            && DECL_ARTIFICIAL (field))
1253                           || (TREE_CODE (x) == TYPE_DECL
1254                               && DECL_ARTIFICIAL (x)))
1255                         continue;
1256                       cp_error_at ("duplicate field `%D' (as type and non-type)",
1257                                    x);
1258                     }
1259                   else
1260                     cp_error_at ("duplicate member `%D'", x);
1261                   if (prev == 0)
1262                     fields = TREE_CHAIN (fields);
1263                   else
1264                     TREE_CHAIN (prev) = TREE_CHAIN (x);
1265                 }
1266             }
1267         }
1268     }
1269   return fields;
1270 }
1271
1272 static void
1273 delete_duplicate_fields (fields)
1274      tree fields;
1275 {
1276   tree x;
1277   for (x = fields; x && TREE_CHAIN (x); x = TREE_CHAIN (x))
1278     TREE_CHAIN (x) = delete_duplicate_fields_1 (x, TREE_CHAIN (x));
1279 }
1280
1281 /* Change the access of FDECL to ACCESS in T.  The access to FDECL is
1282    along the path given by BINFO.  Return 1 if change was legit,
1283    otherwise return 0.  */
1284
1285 static int
1286 alter_access (t, binfo, fdecl, access)
1287      tree t;
1288      tree binfo;
1289      tree fdecl;
1290      tree access;
1291 {
1292   tree elem = purpose_member (t, DECL_ACCESS (fdecl));
1293   if (elem)
1294     {
1295       if (TREE_VALUE (elem) != access)
1296         {
1297           if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
1298             cp_error_at ("conflicting access specifications for method `%D', ignored", TREE_TYPE (fdecl));
1299           else
1300             error ("conflicting access specifications for field `%s', ignored",
1301                    IDENTIFIER_POINTER (DECL_NAME (fdecl)));
1302         }
1303       else
1304         {
1305           /* They're changing the access to the same thing they changed
1306              it to before.  That's OK.  */
1307           ;
1308         }
1309     }
1310   else
1311     {
1312       enforce_access (binfo, fdecl);
1313
1314       DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
1315       return 1;
1316     }
1317   return 0;
1318 }
1319
1320 /* Process the USING_DECL, which is a member of T.  The METHOD_VEC, if
1321    non-NULL, is the methods of T.  The FIELDS are the fields of T.
1322    Returns 1 if the USING_DECL was valid, 0 otherwise.  */
1323
1324 void
1325 handle_using_decl (using_decl, t, method_vec, fields)
1326      tree using_decl;
1327      tree t;
1328      tree method_vec;
1329      tree fields;
1330 {
1331   tree ctype = DECL_INITIAL (using_decl);
1332   tree name = DECL_NAME (using_decl);
1333   tree access
1334     = TREE_PRIVATE (using_decl) ? access_private_node
1335     : TREE_PROTECTED (using_decl) ? access_protected_node
1336     : access_public_node;
1337   tree fdecl, binfo;
1338   tree flist = NULL_TREE;
1339   tree tmp;
1340   int i;
1341   int n_methods;
1342
1343   binfo = binfo_or_else (ctype, t);
1344   if (! binfo)
1345     return;
1346
1347   if (name == constructor_name (ctype)
1348       || name == constructor_name_full (ctype))
1349     cp_error_at ("using-declaration for constructor", using_decl);
1350
1351   fdecl = lookup_member (binfo, name, 0, 0);
1352
1353   if (!fdecl)
1354     {
1355       cp_error_at ("no members matching `%D' in `%#T'", using_decl, ctype);
1356       return;
1357     }
1358
1359   /* Functions are represented as TREE_LIST, with the purpose
1360      being the type and the value the functions. Other members
1361      come as themselves. */
1362   if (TREE_CODE (fdecl) == TREE_LIST)
1363     /* Ignore base type this came from. */
1364     fdecl = TREE_VALUE (fdecl);
1365
1366   if (TREE_CODE (fdecl) == OVERLOAD)
1367     {
1368       /* We later iterate over all functions. */
1369       flist = fdecl;
1370       fdecl = OVL_FUNCTION (flist);
1371     }
1372
1373   name = DECL_NAME (fdecl);
1374   n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
1375   for (i = 2; i < n_methods; i++)
1376     if (DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (method_vec, i)))
1377         == name)
1378       {
1379         cp_error ("cannot adjust access to `%#D' in `%#T'", fdecl, t);
1380         cp_error_at ("  because of local method `%#D' with same name",
1381                      OVL_CURRENT (TREE_VEC_ELT (method_vec, i)));
1382         return;
1383       }
1384
1385   for (tmp = fields; tmp; tmp = TREE_CHAIN (tmp))
1386     if (DECL_NAME (tmp) == name)
1387       {
1388         cp_error ("cannot adjust access to `%#D' in `%#T'", fdecl, t);
1389         cp_error_at ("  because of local field `%#D' with same name", tmp);
1390         return;
1391       }
1392
1393   /* Make type T see field decl FDECL with access ACCESS.*/
1394   if (flist)
1395     {
1396       while (flist)
1397         {
1398           if (alter_access (t, binfo, OVL_FUNCTION (flist),
1399                             access) == 0)
1400             return;
1401           flist = OVL_CHAIN (flist);
1402         }
1403     }
1404   else
1405     alter_access (t, binfo, fdecl, access);
1406 }
1407
1408 /* If FOR_TYPE needs to reinitialize virtual function table pointers
1409    for TYPE's sub-objects, add such reinitializations to BASE_INIT_LIST.
1410    Returns BASE_INIT_LIST appropriately modified.  */
1411
1412 static tree
1413 maybe_fixup_vptrs (for_type, binfo, base_init_list)
1414      tree for_type, binfo, base_init_list;
1415 {
1416   /* Now reinitialize any slots that don't fall under our virtual
1417      function table pointer.  */
1418   tree vfields = CLASSTYPE_VFIELDS (BINFO_TYPE (binfo));
1419   while (vfields)
1420     {
1421       tree basetype = VF_NORMAL_VALUE (vfields)
1422         ? TYPE_MAIN_VARIANT (VF_NORMAL_VALUE (vfields))
1423           : VF_BASETYPE_VALUE (vfields);
1424
1425       tree base_binfo = get_binfo (basetype, for_type, 0);
1426       /* Punt until this is implemented.  */
1427       if (1 /* BINFO_MODIFIED (base_binfo) */)
1428         {
1429           tree base_offset = get_vfield_offset (base_binfo);
1430           if (! tree_int_cst_equal (base_offset, get_vfield_offset (TYPE_BINFO (for_type)))
1431               && ! tree_int_cst_equal (base_offset, get_vfield_offset (binfo)))
1432             base_init_list = tree_cons (error_mark_node, base_binfo,
1433                                         base_init_list);
1434         }
1435       vfields = TREE_CHAIN (vfields);
1436     }
1437   return base_init_list;
1438 }
1439
1440 /* If TYPE does not have a constructor, then the compiler must
1441    manually deal with all of the initialization this type requires.
1442
1443    If a base initializer exists only to fill in the virtual function
1444    table pointer, then we mark that fact with the TREE_VIRTUAL bit.
1445    This way, we avoid multiple initializations of the same field by
1446    each virtual function table up the class hierarchy.
1447
1448    Virtual base class pointers are not initialized here.  They are
1449    initialized only at the "top level" of object creation.  If we
1450    initialized them here, we would have to skip a lot of work.  */
1451
1452 static void
1453 build_class_init_list (type)
1454      tree type;
1455 {
1456   tree base_init_list = NULL_TREE;
1457   tree member_init_list = NULL_TREE;
1458
1459   /* Since we build member_init_list and base_init_list using
1460      tree_cons, backwards fields the all through work.  */
1461   tree x;
1462   tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
1463   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1464
1465   for (x = TYPE_FIELDS (type); x; x = TREE_CHAIN (x))
1466     {
1467       if (TREE_CODE (x) != FIELD_DECL)
1468         continue;
1469
1470       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (x))
1471           || DECL_INITIAL (x) != NULL_TREE)
1472         member_init_list = tree_cons (x, type, member_init_list);
1473     }
1474   member_init_list = nreverse (member_init_list);
1475
1476   /* We will end up doing this last.  Need special marker
1477      to avoid infinite regress.  */
1478   if (TYPE_VIRTUAL_P (type))
1479     {
1480       base_init_list = build_tree_list (error_mark_node, TYPE_BINFO (type));
1481       if (CLASSTYPE_NEEDS_VIRTUAL_REINIT (type) == 0)
1482         TREE_VALUE (base_init_list) = NULL_TREE;
1483       TREE_ADDRESSABLE (base_init_list) = 1;
1484     }
1485
1486   /* Each base class which needs to have initialization
1487      of some kind gets to make such requests known here.  */
1488   for (i = n_baseclasses-1; i >= 0; i--)
1489     {
1490       tree base_binfo = TREE_VEC_ELT (binfos, i);
1491       tree blist;
1492
1493       /* Don't initialize virtual baseclasses this way.  */
1494       if (TREE_VIA_VIRTUAL (base_binfo))
1495         continue;
1496
1497       if (TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (base_binfo)))
1498         {
1499           /* ...and the last shall come first...  */
1500           base_init_list = maybe_fixup_vptrs (type, base_binfo, base_init_list);
1501           base_init_list = tree_cons (NULL_TREE, base_binfo, base_init_list);
1502           continue;
1503         }
1504
1505       if ((blist = CLASSTYPE_BASE_INIT_LIST (BINFO_TYPE (base_binfo))) == NULL_TREE)
1506         /* Nothing to initialize.  */
1507         continue;
1508
1509       /* ...ditto...  */
1510       base_init_list = maybe_fixup_vptrs (type, base_binfo, base_init_list);
1511
1512       /* This is normally true for single inheritance.
1513          The win is we can shrink the chain of initializations
1514          to be done by only converting to the actual type
1515          we are interested in.  */
1516       if (TREE_VALUE (blist)
1517           && TREE_CODE (TREE_VALUE (blist)) == TREE_VEC
1518           && tree_int_cst_equal (BINFO_OFFSET (base_binfo),
1519                                  BINFO_OFFSET (TREE_VALUE (blist))))
1520         {
1521           if (base_init_list)
1522             {
1523               /* Does it do more than just fill in a
1524                  virtual function table pointer?  */
1525               if (! TREE_ADDRESSABLE (blist))
1526                 base_init_list = build_tree_list (blist, base_init_list);
1527               /* Can we get by just with the virtual function table
1528                  pointer that it fills in?  */
1529               else if (TREE_ADDRESSABLE (base_init_list)
1530                        && TREE_VALUE (base_init_list) == 0)
1531                 base_init_list = blist;
1532               /* Maybe, but it is not obvious as the previous case.  */
1533               else if (! CLASSTYPE_NEEDS_VIRTUAL_REINIT (type))
1534                 {
1535                   tree last = tree_last (base_init_list);
1536                   while (TREE_VALUE (last)
1537                          && TREE_CODE (TREE_VALUE (last)) == TREE_LIST)
1538                     last = tree_last (TREE_VALUE (last));
1539                   if (TREE_VALUE (last) == 0)
1540                     base_init_list = build_tree_list (blist, base_init_list);
1541                 }
1542             }
1543           else
1544             base_init_list = blist;
1545         }
1546       else
1547         {
1548           /* The function expand_aggr_init knows how to do the
1549              initialization of `basetype' without getting
1550              an explicit `blist'.  */
1551           if (base_init_list)
1552             base_init_list = tree_cons (NULL_TREE, base_binfo, base_init_list);
1553           else
1554             base_init_list = CLASSTYPE_BINFO_AS_LIST (BINFO_TYPE (base_binfo));
1555         }
1556     }
1557
1558   if (base_init_list)
1559     {
1560       if (member_init_list)
1561         CLASSTYPE_BASE_INIT_LIST (type) =
1562           build_tree_list (base_init_list, member_init_list);
1563       else
1564         CLASSTYPE_BASE_INIT_LIST (type) = base_init_list;
1565     }
1566   else if (member_init_list)
1567     CLASSTYPE_BASE_INIT_LIST (type) = member_init_list;
1568 }
1569 \f
1570 struct base_info
1571 {
1572   int has_virtual;
1573   int max_has_virtual;
1574   int n_ancestors;
1575   tree vfield;
1576   tree vfields;
1577   tree rtti;
1578   char cant_have_default_ctor;
1579   char cant_have_const_ctor;
1580   char no_const_asn_ref;
1581 };
1582
1583 /* Record information about type T derived from its base classes.
1584    Store most of that information in T itself, and place the
1585    remaining information in the struct BASE_INFO.
1586
1587    Propagate basetype offsets throughout the lattice.  Note that the
1588    lattice topped by T is really a pair: it's a DAG that gives the
1589    structure of the derivation hierarchy, and it's a list of the
1590    virtual baseclasses that appear anywhere in the DAG.  When a vbase
1591    type appears in the DAG, it's offset is 0, and it's children start
1592    their offsets from that point.  When a vbase type appears in the list,
1593    its offset is the offset it has in the hierarchy, and its children's
1594    offsets include that offset in theirs.
1595
1596    Returns the index of the first base class to have virtual functions,
1597    or -1 if no such base class.  */
1598
1599 static int
1600 finish_base_struct (t, b)
1601      tree t;
1602      struct base_info *b;
1603 {
1604   tree binfos = TYPE_BINFO_BASETYPES (t);
1605   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1606   int first_vfn_base_index = -1;
1607   bzero ((char *) b, sizeof (struct base_info));
1608
1609   for (i = 0; i < n_baseclasses; i++)
1610     {
1611       tree base_binfo = TREE_VEC_ELT (binfos, i);
1612       tree basetype = BINFO_TYPE (base_binfo);
1613
1614       /* Effective C++ rule 14.  We only need to check TYPE_VIRTUAL_P
1615          here because the case of virtual functions but non-virtual
1616          dtor is handled in finish_struct_1.  */
1617       if (warn_ecpp && ! TYPE_VIRTUAL_P (basetype)
1618           && TYPE_HAS_DESTRUCTOR (basetype))
1619         cp_warning ("base class `%#T' has a non-virtual destructor", basetype);
1620
1621       /* If the type of basetype is incomplete, then
1622          we already complained about that fact
1623          (and we should have fixed it up as well).  */
1624       if (TYPE_SIZE (basetype) == 0)
1625         {
1626           int j;
1627           /* The base type is of incomplete type.  It is
1628              probably best to pretend that it does not
1629              exist.  */
1630           if (i == n_baseclasses-1)
1631             TREE_VEC_ELT (binfos, i) = NULL_TREE;
1632           TREE_VEC_LENGTH (binfos) -= 1;
1633           n_baseclasses -= 1;
1634           for (j = i; j+1 < n_baseclasses; j++)
1635             TREE_VEC_ELT (binfos, j) = TREE_VEC_ELT (binfos, j+1);
1636         }
1637
1638       if (! TYPE_HAS_CONST_INIT_REF (basetype))
1639         b->cant_have_const_ctor = 1;
1640
1641       if (TYPE_HAS_CONSTRUCTOR (basetype)
1642           && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))
1643         {
1644           b->cant_have_default_ctor = 1;
1645           if (! TYPE_HAS_CONSTRUCTOR (t))
1646             {
1647               cp_pedwarn ("base `%T' with only non-default constructor",
1648                           basetype);
1649               cp_pedwarn ("in class without a constructor");
1650             }
1651         }
1652
1653       if (TYPE_HAS_ASSIGN_REF (basetype)
1654           && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
1655         b->no_const_asn_ref = 1;
1656
1657       b->n_ancestors += CLASSTYPE_N_SUPERCLASSES (basetype);
1658       TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1659       TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (basetype);
1660       TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
1661       TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);
1662
1663       TYPE_OVERLOADS_CALL_EXPR (t) |= TYPE_OVERLOADS_CALL_EXPR (basetype);
1664       TYPE_OVERLOADS_ARRAY_REF (t) |= TYPE_OVERLOADS_ARRAY_REF (basetype);
1665       TYPE_OVERLOADS_ARROW (t) |= TYPE_OVERLOADS_ARROW (basetype);
1666
1667       if (! TREE_VIA_VIRTUAL (base_binfo))
1668         CLASSTYPE_N_SUPERCLASSES (t) += 1;
1669
1670       if (TYPE_VIRTUAL_P (basetype))
1671         {
1672           /* Ensure that this is set from at least a virtual base
1673              class.  */
1674           if (b->rtti == NULL_TREE)
1675             b->rtti = CLASSTYPE_RTTI (basetype);
1676
1677           /* Don't borrow virtuals from virtual baseclasses.  */
1678           if (TREE_VIA_VIRTUAL (base_binfo))
1679             continue;
1680
1681           if (first_vfn_base_index < 0)
1682             {
1683               tree vfields;
1684               first_vfn_base_index = i;
1685
1686               /* Update these two, now that we know what vtable we are
1687                  going to extend.  This is so that we can add virtual
1688                  functions, and override them properly.  */
1689               TYPE_BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (basetype);
1690               TYPE_BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (basetype);
1691               b->has_virtual = CLASSTYPE_VSIZE (basetype);
1692               b->vfield = CLASSTYPE_VFIELD (basetype);
1693               b->vfields = copy_list (CLASSTYPE_VFIELDS (basetype));
1694               vfields = b->vfields;
1695               while (vfields)
1696                 {
1697                   if (VF_BINFO_VALUE (vfields) == NULL_TREE
1698                       || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1699                     {
1700                       tree value = VF_BASETYPE_VALUE (vfields);
1701                       if (DECL_NAME (CLASSTYPE_VFIELD (value))
1702                           == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1703                         VF_NORMAL_VALUE (b->vfields) = basetype;
1704                       else
1705                         VF_NORMAL_VALUE (b->vfields) = VF_NORMAL_VALUE (vfields);
1706                     }
1707                   vfields = TREE_CHAIN (vfields);
1708                 }
1709               CLASSTYPE_VFIELD (t) = b->vfield;
1710             }
1711           else
1712             {
1713               /* Only add unique vfields, and flatten them out as we go.  */
1714               tree vfields = CLASSTYPE_VFIELDS (basetype);
1715               while (vfields)
1716                 {
1717                   if (VF_BINFO_VALUE (vfields) == NULL_TREE
1718                       || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1719                     {
1720                       tree value = VF_BASETYPE_VALUE (vfields);
1721                       b->vfields = tree_cons (base_binfo, value, b->vfields);
1722                       if (DECL_NAME (CLASSTYPE_VFIELD (value))
1723                           == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1724                         VF_NORMAL_VALUE (b->vfields) = basetype;
1725                       else
1726                         VF_NORMAL_VALUE (b->vfields) = VF_NORMAL_VALUE (vfields);
1727                     }
1728                   vfields = TREE_CHAIN (vfields);
1729                 }
1730
1731               if (b->has_virtual == 0)
1732                 {
1733                   first_vfn_base_index = i;
1734
1735                   /* Update these two, now that we know what vtable we are
1736                      going to extend.  This is so that we can add virtual
1737                      functions, and override them properly.  */
1738                   TYPE_BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (basetype);
1739                   TYPE_BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (basetype);
1740                   b->has_virtual = CLASSTYPE_VSIZE (basetype);
1741                   b->vfield = CLASSTYPE_VFIELD (basetype);
1742                   CLASSTYPE_VFIELD (t) = b->vfield;
1743                   /* When we install the first one, set the VF_NORMAL_VALUE
1744                      to be the current class, as this it is the most derived
1745                      class.  Hopefully, this is not set to something else
1746                      later.  (mrs) */
1747                   vfields = b->vfields;
1748                   while (vfields)
1749                     {
1750                       if (DECL_NAME (CLASSTYPE_VFIELD (t))
1751                           == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1752                         {
1753                           VF_NORMAL_VALUE (vfields) = t;
1754                           /* There should only be one of them!  And it should
1755                              always be found, if we get into here.  (mrs)  */
1756                           break;
1757                         }
1758                       vfields = TREE_CHAIN (vfields);
1759                     }
1760                 }
1761             }
1762         }
1763     }
1764
1765   /* This comment said "Must come after offsets are fixed for all bases."
1766      Well, now this happens before the offsets are fixed, but it seems to
1767      work fine.  Guess we'll see...  */
1768   for (i = 0; i < n_baseclasses; i++)
1769     {
1770       tree base_binfo = TREE_VEC_ELT (binfos, i);
1771       tree basetype = BINFO_TYPE (base_binfo);
1772
1773       if (get_base_distance (basetype, t, 0, (tree*)0) == -2)
1774         {
1775           cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
1776                       basetype, t);
1777         }
1778     }
1779   {
1780     tree v = get_vbase_types (t);
1781
1782     for (; v; v = TREE_CHAIN (v))
1783       {
1784         tree basetype = BINFO_TYPE (v);
1785         if (get_base_distance (basetype, t, 0, (tree*)0) == -2)
1786           {
1787             if (extra_warnings)
1788               cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
1789                           basetype, t);
1790           }
1791       }
1792   }
1793
1794   {
1795     tree vfields;
1796     /* Find the base class with the largest number of virtual functions.  */
1797     for (vfields = b->vfields; vfields; vfields = TREE_CHAIN (vfields))
1798       {
1799         if (CLASSTYPE_VSIZE (VF_BASETYPE_VALUE (vfields)) > b->max_has_virtual)
1800           b->max_has_virtual = CLASSTYPE_VSIZE (VF_BASETYPE_VALUE (vfields));
1801         if (VF_DERIVED_VALUE (vfields)
1802             && CLASSTYPE_VSIZE (VF_DERIVED_VALUE (vfields)) > b->max_has_virtual)
1803           b->max_has_virtual = CLASSTYPE_VSIZE (VF_DERIVED_VALUE (vfields));
1804       }
1805   }
1806
1807   if (b->vfield == 0)
1808     /* If all virtual functions come only from virtual baseclasses.  */
1809     return -1;
1810
1811   /* Update the rtti base if we have a non-virtual base class version
1812      of it.  */
1813   b->rtti = CLASSTYPE_RTTI (BINFO_TYPE (TREE_VEC_ELT (binfos, first_vfn_base_index)));
1814
1815   return first_vfn_base_index;
1816 }
1817 \f
1818 /* Set memoizing fields and bits of T (and its variants) for later use.
1819    MAX_HAS_VIRTUAL is the largest size of any T's virtual function tables.  */
1820
1821 static void
1822 finish_struct_bits (t, max_has_virtual)
1823      tree t;
1824      int max_has_virtual;
1825 {
1826   int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1827
1828   /* Fix up variants (if any).  */
1829   tree variants = TYPE_NEXT_VARIANT (t);
1830   while (variants)
1831     {
1832       /* These fields are in the _TYPE part of the node, not in
1833          the TYPE_LANG_SPECIFIC component, so they are not shared.  */
1834       TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t);
1835       TYPE_HAS_DESTRUCTOR (variants) = TYPE_HAS_DESTRUCTOR (t);
1836       TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1837       TYPE_NEEDS_DESTRUCTOR (variants) = TYPE_NEEDS_DESTRUCTOR (t);
1838
1839       TYPE_USES_COMPLEX_INHERITANCE (variants) = TYPE_USES_COMPLEX_INHERITANCE (t);
1840       TYPE_VIRTUAL_P (variants) = TYPE_VIRTUAL_P (t);
1841       TYPE_USES_VIRTUAL_BASECLASSES (variants) = TYPE_USES_VIRTUAL_BASECLASSES (t);
1842       /* Copy whatever these are holding today.  */
1843       TYPE_MIN_VALUE (variants) = TYPE_MIN_VALUE (t);
1844       TYPE_MAX_VALUE (variants) = TYPE_MAX_VALUE (t);
1845       TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1846       TYPE_SIZE (variants) = TYPE_SIZE (t);
1847       variants = TYPE_NEXT_VARIANT (variants);
1848     }
1849
1850   if (n_baseclasses && max_has_virtual)
1851     {
1852       /* Done by `finish_struct' for classes without baseclasses.  */
1853       int might_have_abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (t) != 0;
1854       tree binfos = TYPE_BINFO_BASETYPES (t);
1855       for (i = n_baseclasses-1; i >= 0; i--)
1856         {
1857           might_have_abstract_virtuals
1858             |= (CLASSTYPE_ABSTRACT_VIRTUALS (BINFO_TYPE (TREE_VEC_ELT (binfos, i))) != 0);
1859           if (might_have_abstract_virtuals)
1860             break;
1861         }
1862       if (might_have_abstract_virtuals)
1863         {
1864           /* We use error_mark_node from override_one_vtable to signal
1865              an artificial abstract.  */
1866           if (CLASSTYPE_ABSTRACT_VIRTUALS (t) == error_mark_node)
1867             CLASSTYPE_ABSTRACT_VIRTUALS (t) = NULL_TREE;
1868           CLASSTYPE_ABSTRACT_VIRTUALS (t) = get_abstract_virtuals (t);
1869         }
1870     }
1871
1872   if (n_baseclasses)
1873     {
1874       /* Notice whether this class has type conversion functions defined.  */
1875       tree binfo = TYPE_BINFO (t);
1876       tree binfos = BINFO_BASETYPES (binfo);
1877       tree basetype;
1878
1879       for (i = n_baseclasses-1; i >= 0; i--)
1880         {
1881           basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
1882
1883           TYPE_HAS_CONVERSION (t) |= TYPE_HAS_CONVERSION (basetype);
1884           if (CLASSTYPE_MAX_DEPTH (basetype) >= CLASSTYPE_MAX_DEPTH (t))
1885             CLASSTYPE_MAX_DEPTH (t) = CLASSTYPE_MAX_DEPTH (basetype) + 1;
1886         }
1887     }
1888
1889   /* If this type has a copy constructor, force its mode to be BLKmode, and
1890      force its TREE_ADDRESSABLE bit to be nonzero.  This will cause it to
1891      be passed by invisible reference and prevent it from being returned in
1892      a register.
1893
1894      Also do this if the class has BLKmode but can still be returned in
1895      registers, since function_cannot_inline_p won't let us inline
1896      functions returning such a type.  This affects the HP-PA.  */
1897   if (! TYPE_HAS_TRIVIAL_INIT_REF (t)
1898       || (TYPE_MODE (t) == BLKmode && ! aggregate_value_p (t)
1899           && CLASSTYPE_NON_AGGREGATE (t)))
1900     {
1901       tree variants;
1902       DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
1903       for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1904         {
1905           TYPE_MODE (variants) = BLKmode;
1906           TREE_ADDRESSABLE (variants) = 1;
1907         }
1908     }
1909 }
1910
1911 /* Add FNDECL to the method_vec growing on the class_obstack.  Used by
1912    finish_struct_methods.  Note, FNDECL cannot be a constructor or
1913    destructor, those cases are handled by the caller.  */
1914
1915 static void
1916 grow_method (fndecl, method_vec_ptr)
1917      tree fndecl;
1918      tree *method_vec_ptr;
1919 {
1920   tree method_vec = (tree)obstack_base (&class_obstack);
1921
1922   /* Start off past the constructors and destructor.  */
1923   tree *testp = &TREE_VEC_ELT (method_vec, 2);
1924
1925   while (testp < (tree *) obstack_next_free (&class_obstack)
1926          && (*testp == NULL_TREE || DECL_NAME (OVL_CURRENT (*testp)) != DECL_NAME (fndecl)))
1927     testp++;
1928
1929   if (testp < (tree *) obstack_next_free (&class_obstack))
1930     *testp = build_overload (fndecl, *testp);
1931   else
1932     {
1933       obstack_ptr_grow (&class_obstack, fndecl);
1934       *method_vec_ptr = (tree)obstack_base (&class_obstack);
1935     }
1936 }
1937
1938 /* Warn about duplicate methods in fn_fields.  Also compact method
1939    lists so that lookup can be made faster.
1940
1941    Algorithm: Outer loop builds lists by method name.  Inner loop
1942    checks for redundant method names within a list.
1943
1944    Data Structure: List of method lists.  The outer list is a
1945    TREE_LIST, whose TREE_PURPOSE field is the field name and the
1946    TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs.  TREE_CHAIN
1947    links the entire list of methods for TYPE_METHODS.  Friends are
1948    chained in the same way as member functions (? TREE_CHAIN or
1949    DECL_CHAIN), but they live in the TREE_TYPE field of the outer
1950    list.  That allows them to be quickly deleted, and requires no
1951    extra storage.
1952
1953    If there are any constructors/destructors, they are moved to the
1954    front of the list.  This makes pushclass more efficient.
1955
1956    We also link each field which has shares a name with its baseclass
1957    to the head of the list of fields for that base class.  This allows
1958    us to reduce search time in places like `build_method_call' to
1959    consider only reasonably likely functions.  */
1960
1961 tree
1962 finish_struct_methods (t, fn_fields, nonprivate_method)
1963      tree t;
1964      tree fn_fields;
1965      int nonprivate_method;
1966 {
1967   tree method_vec;
1968   tree save_fn_fields = fn_fields;
1969   tree ctor_name = constructor_name (t);
1970   int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1971
1972   /* Now prepare to gather fn_fields into vector.  */
1973   struct obstack *ambient_obstack = current_obstack;
1974   current_obstack = &class_obstack;
1975   method_vec = make_tree_vec (2);
1976   current_obstack = ambient_obstack;
1977
1978   /* Now make this a live vector.  */
1979   obstack_free (&class_obstack, method_vec);
1980
1981   /* Save room for constructors and destructors.  */
1982   obstack_blank (&class_obstack, sizeof (struct tree_vec) + sizeof (struct tree *));
1983
1984   /* First fill in entry 0 with the constructors, entry 1 with destructors,
1985      and the next few with type conversion operators (if any).  */
1986
1987   for (; fn_fields; fn_fields = TREE_CHAIN (fn_fields))
1988     {
1989       tree fn_name = DECL_NAME (fn_fields);
1990
1991       /* Clear out this flag.
1992
1993          @@ Doug may figure out how to break
1994          @@ this with nested classes and friends.  */
1995       DECL_IN_AGGR_P (fn_fields) = 0;
1996
1997       /* Note here that a copy ctor is private, so we don't dare generate
1998          a default copy constructor for a class that has a member
1999          of this type without making sure they have access to it.  */
2000       if (fn_name == ctor_name)
2001         {
2002           tree parmtypes = FUNCTION_ARG_CHAIN (fn_fields);
2003           tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
2004
2005           if (TREE_CODE (parmtype) == REFERENCE_TYPE
2006               && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == t)
2007             {
2008               if (TREE_CHAIN (parmtypes) == NULL_TREE
2009                   || TREE_CHAIN (parmtypes) == void_list_node
2010                   || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
2011                 {
2012                   if (TREE_PROTECTED (fn_fields))
2013                     TYPE_HAS_NONPUBLIC_CTOR (t) = 1;
2014                   else if (TREE_PRIVATE (fn_fields))
2015                     TYPE_HAS_NONPUBLIC_CTOR (t) = 2;
2016                 }
2017             }
2018           if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fn_fields)))
2019             {
2020               /* Destructors go in slot 1.  */
2021               TREE_VEC_ELT (method_vec, 1) =
2022                 build_overload (fn_fields, TREE_VEC_ELT (method_vec, 1));
2023             }
2024           else
2025             {
2026               /* Constructors go in slot 0.  */
2027               TREE_VEC_ELT (method_vec, 0) =
2028                 build_overload (fn_fields, TREE_VEC_ELT (method_vec, 0));
2029             }
2030         }
2031       else if (IDENTIFIER_TYPENAME_P (fn_name))
2032         grow_method (fn_fields, &method_vec);
2033     }
2034
2035   fn_fields = save_fn_fields;
2036   for (; fn_fields; fn_fields = TREE_CHAIN (fn_fields))
2037     {
2038       tree fn_name = DECL_NAME (fn_fields);
2039
2040       if (fn_name == ctor_name || IDENTIFIER_TYPENAME_P (fn_name))
2041         continue;
2042
2043       if (fn_name == ansi_opname[(int) MODIFY_EXPR])
2044         {
2045           tree parmtype = TREE_VALUE (FUNCTION_ARG_CHAIN (fn_fields));
2046
2047           if (copy_assignment_arg_p (parmtype, DECL_VIRTUAL_P (fn_fields)))
2048             {
2049               if (TREE_PROTECTED (fn_fields))
2050                 TYPE_HAS_NONPUBLIC_ASSIGN_REF (t) = 1;
2051               else if (TREE_PRIVATE (fn_fields))
2052                 TYPE_HAS_NONPUBLIC_ASSIGN_REF (t) = 2;
2053             }
2054         }
2055
2056       grow_method (fn_fields, &method_vec);
2057     }
2058
2059   TREE_VEC_LENGTH (method_vec) = (tree *)obstack_next_free (&class_obstack)
2060     - (&TREE_VEC_ELT (method_vec, 0));
2061   obstack_finish (&class_obstack);
2062   CLASSTYPE_METHOD_VEC (t) = method_vec;
2063
2064   if (nonprivate_method == 0
2065       && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
2066       && DECL_FRIENDLIST (TYPE_MAIN_DECL (t)) == NULL_TREE)
2067     {
2068       tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
2069       for (i = 0; i < n_baseclasses; i++)
2070         if (TREE_VIA_PUBLIC (TREE_VEC_ELT (binfos, i))
2071             || TREE_VIA_PROTECTED (TREE_VEC_ELT (binfos, i)))
2072           {
2073             nonprivate_method = 1;
2074             break;
2075           }
2076       if (nonprivate_method == 0
2077           && warn_ctor_dtor_privacy)
2078         cp_warning ("all member functions in class `%T' are private", t);
2079     }
2080
2081   /* Warn if all destructors are private (in which case this class is
2082      effectively unusable.  */
2083   if (TYPE_HAS_DESTRUCTOR (t))
2084     {
2085       tree dtor = TREE_VEC_ELT (method_vec, 1);
2086
2087       /* Wild parse errors can cause this to happen.  */
2088       if (dtor == NULL_TREE)
2089         TYPE_HAS_DESTRUCTOR (t) = 0;
2090       else if (TREE_PRIVATE (dtor)
2091                && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
2092                && DECL_FRIENDLIST (TYPE_MAIN_DECL (t)) == NULL_TREE
2093                && warn_ctor_dtor_privacy)
2094         cp_warning ("`%#T' only defines a private destructor and has no friends",
2095                     t);
2096     }
2097
2098   /* Now for each member function (except for constructors and
2099      destructors), compute where member functions of the same
2100      name reside in base classes.  */
2101   if (n_baseclasses != 0
2102       && TREE_VEC_LENGTH (method_vec) > 2)
2103     {
2104       int len = TREE_VEC_LENGTH (method_vec);
2105       tree baselink_vec = make_tree_vec (len);
2106       int any_links = 0;
2107       tree baselink_binfo = build_tree_list (NULL_TREE, TYPE_BINFO (t));
2108
2109       for (i = 2; i < len; i++)
2110         {
2111           TREE_VEC_ELT (baselink_vec, i)
2112             = get_baselinks (baselink_binfo, t,
2113                              DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (method_vec, i))));
2114           if (TREE_VEC_ELT (baselink_vec, i) != 0)
2115             any_links = 1;
2116         }
2117       if (any_links != 0)
2118         CLASSTYPE_BASELINK_VEC (t) = baselink_vec;
2119       else
2120         obstack_free (current_obstack, baselink_vec);
2121     }
2122
2123   return method_vec;
2124 }
2125
2126 /* Emit error when a duplicate definition of a type is seen.  Patch up.  */
2127
2128 void
2129 duplicate_tag_error (t)
2130      tree t;
2131 {
2132   cp_error ("redefinition of `%#T'", t);
2133   cp_error_at ("previous definition here", t);
2134
2135   /* Pretend we haven't defined this type.  */
2136
2137   /* All of the component_decl's were TREE_CHAINed together in the parser.
2138      finish_struct_methods walks these chains and assembles all methods with
2139      the same base name into DECL_CHAINs. Now we don't need the parser chains
2140      anymore, so we unravel them.  */
2141
2142   /* This used to be in finish_struct, but it turns out that the
2143      TREE_CHAIN is used by dbxout_type_methods and perhaps some other
2144      things...  */
2145   if (CLASSTYPE_METHOD_VEC (t))
2146     {
2147       tree method_vec = CLASSTYPE_METHOD_VEC (t);
2148       int i, len  = TREE_VEC_LENGTH (method_vec);
2149       for (i = 0; i < len; i++)
2150         {
2151           tree unchain = TREE_VEC_ELT (method_vec, i);
2152           while (unchain != NULL_TREE)
2153             {
2154               TREE_CHAIN (OVL_CURRENT (unchain)) = NULL_TREE;
2155               unchain = OVL_NEXT (unchain);
2156             }
2157         }
2158     }
2159
2160   if (TYPE_LANG_SPECIFIC (t))
2161     {
2162       tree as_list = CLASSTYPE_AS_LIST (t);
2163       tree binfo = TYPE_BINFO (t);
2164       tree binfo_as_list = CLASSTYPE_BINFO_AS_LIST (t);
2165       int interface_only = CLASSTYPE_INTERFACE_ONLY (t);
2166       int interface_unknown = CLASSTYPE_INTERFACE_UNKNOWN (t);
2167
2168       bzero ((char *) TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type));
2169       BINFO_BASETYPES(binfo) = NULL_TREE;
2170
2171       CLASSTYPE_AS_LIST (t) = as_list;
2172       TYPE_BINFO (t) = binfo;
2173       CLASSTYPE_BINFO_AS_LIST (t) = binfo_as_list;
2174       CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
2175       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
2176       TYPE_REDEFINED (t) = 1;
2177     }
2178   TYPE_SIZE (t) = NULL_TREE;
2179   TYPE_MODE (t) = VOIDmode;
2180   TYPE_FIELDS (t) = NULL_TREE;
2181   TYPE_METHODS (t) = NULL_TREE;
2182   TYPE_VFIELD (t) = NULL_TREE;
2183   TYPE_CONTEXT (t) = NULL_TREE;
2184 }
2185
2186 /* finish up all new vtables.  */
2187
2188 static void
2189 finish_vtbls (binfo, do_self, t)
2190      tree binfo;
2191      int do_self;
2192      tree t;
2193 {
2194   tree binfos = BINFO_BASETYPES (binfo);
2195   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2196
2197   /* Should we use something besides CLASSTYPE_VFIELDS? */
2198   if (do_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2199     {
2200       if (BINFO_NEW_VTABLE_MARKED (binfo))
2201         {
2202           tree decl, context;
2203
2204           decl = BINFO_VTABLE (binfo);
2205           context = DECL_CONTEXT (decl);
2206           DECL_CONTEXT (decl) = 0;
2207           if (write_virtuals >= 0
2208               && DECL_INITIAL (decl) != BINFO_VIRTUALS (binfo))
2209             DECL_INITIAL (decl) = build_nt (CONSTRUCTOR, NULL_TREE,
2210                                             BINFO_VIRTUALS (binfo));
2211           cp_finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0, 0);
2212           DECL_CONTEXT (decl) = context;
2213         }
2214       CLEAR_BINFO_NEW_VTABLE_MARKED (binfo);
2215     }
2216
2217   for (i = 0; i < n_baselinks; i++)
2218     {
2219       tree base_binfo = TREE_VEC_ELT (binfos, i);
2220       int is_not_base_vtable
2221         = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2222       if (TREE_VIA_VIRTUAL (base_binfo))
2223         {
2224           base_binfo = binfo_member (BINFO_TYPE (base_binfo), CLASSTYPE_VBASECLASSES (t));
2225         }
2226       finish_vtbls (base_binfo, is_not_base_vtable, t);
2227     }
2228 }
2229
2230 /* True if we should override the given BASE_FNDECL with the given
2231    FNDECL.  */
2232
2233 static int
2234 overrides (fndecl, base_fndecl)
2235      tree fndecl, base_fndecl;
2236 {
2237   /* Destructors have special names.  */
2238   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (base_fndecl))
2239       && DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
2240     return 1;
2241   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (base_fndecl))
2242       || DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
2243     return 0;
2244   if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl))
2245     {
2246       tree types, base_types;
2247 #if 0
2248       retypes = TREE_TYPE (TREE_TYPE (fndecl));
2249       base_retypes = TREE_TYPE (TREE_TYPE (base_fndecl));
2250 #endif
2251       types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2252       base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
2253       if ((TYPE_READONLY (TREE_TYPE (TREE_VALUE (base_types)))
2254            == TYPE_READONLY (TREE_TYPE (TREE_VALUE (types))))
2255           && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types), 3))
2256         return 1;
2257     }
2258   return 0;
2259 }
2260
2261 static tree
2262 get_class_offset_1 (parent, binfo, context, t, fndecl)
2263      tree parent, binfo, context, t, fndecl;
2264 {
2265   tree binfos = BINFO_BASETYPES (binfo);
2266   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2267   tree rval = NULL_TREE;
2268
2269   if (binfo == parent)
2270     return error_mark_node;
2271
2272   for (i = 0; i < n_baselinks; i++)
2273     {
2274       tree base_binfo = TREE_VEC_ELT (binfos, i);
2275       tree nrval;
2276
2277       if (TREE_VIA_VIRTUAL (base_binfo))
2278         base_binfo = binfo_member (BINFO_TYPE (base_binfo),
2279                                    CLASSTYPE_VBASECLASSES (t));
2280       nrval = get_class_offset_1 (parent, base_binfo, context, t, fndecl);
2281       /* See if we have a new value */
2282       if (nrval && (nrval != error_mark_node || rval==0))
2283         {
2284           /* Only compare if we have two offsets */
2285           if (rval && rval != error_mark_node
2286               && ! tree_int_cst_equal (nrval, rval))
2287             {
2288               /* Only give error if the two offsets are different */
2289               error ("every virtual function must have a unique final overrider");
2290               cp_error ("  found two (or more) `%T' class subobjects in `%T'", context, t);
2291               cp_error ("  with virtual `%D' from virtual base class", fndecl);
2292               return rval;
2293             }
2294           rval = nrval;
2295         }
2296
2297       if (rval && BINFO_TYPE (binfo) == context)
2298         {
2299           my_friendly_assert (rval == error_mark_node
2300                               || tree_int_cst_equal (rval, BINFO_OFFSET (binfo)), 999);
2301           rval = BINFO_OFFSET (binfo);
2302         }
2303     }
2304   return rval;
2305 }
2306
2307 /* Get the offset to the CONTEXT subobject that is related to the
2308    given BINFO.  */
2309
2310 static tree
2311 get_class_offset (context, t, binfo, fndecl)
2312      tree context, t, binfo, fndecl;
2313 {
2314   tree first_binfo = binfo;
2315   tree offset;
2316   int i;
2317
2318   if (context == t)
2319     return integer_zero_node;
2320
2321   if (BINFO_TYPE (binfo) == context)
2322     return BINFO_OFFSET (binfo);
2323
2324   /* Check less derived binfos first.  */
2325   while (BINFO_BASETYPES (binfo)
2326          && (i=CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo))) != -1)
2327     {
2328       tree binfos = BINFO_BASETYPES (binfo);
2329       binfo = TREE_VEC_ELT (binfos, i);
2330       if (BINFO_TYPE (binfo) == context)
2331         return BINFO_OFFSET (binfo);
2332     }
2333
2334   /* Ok, not found in the less derived binfos, now check the more
2335      derived binfos.  */
2336   offset = get_class_offset_1 (first_binfo, TYPE_BINFO (t), context, t, fndecl);
2337   if (offset==0 || TREE_CODE (offset) != INTEGER_CST)
2338     my_friendly_abort (999);    /* we have to find it.  */
2339   return offset;
2340 }
2341
2342 /* Skip RTTI information at the front of the virtual list.  */
2343
2344 unsigned HOST_WIDE_INT
2345 skip_rtti_stuff (virtuals)
2346      tree *virtuals;
2347 {
2348   int n;
2349
2350   n = 0;
2351   if (*virtuals)
2352     {
2353       /* We always reserve a slot for the offset/tdesc entry.  */
2354       ++n;
2355       *virtuals = TREE_CHAIN (*virtuals);
2356     }
2357   if (flag_vtable_thunks && *virtuals)
2358     {
2359       /* The second slot is reserved for the tdesc pointer when thunks
2360          are used.  */
2361       ++n;
2362       *virtuals = TREE_CHAIN (*virtuals);
2363     }
2364   return n;
2365 }
2366
2367 static void
2368 modify_one_vtable (binfo, t, fndecl, pfn)
2369      tree binfo, t, fndecl, pfn;
2370 {
2371   tree virtuals = BINFO_VIRTUALS (binfo);
2372   unsigned HOST_WIDE_INT n;
2373
2374   /* update rtti entry */
2375   if (flag_rtti)
2376     {
2377       if (binfo == TYPE_BINFO (t))
2378         {
2379           if (! BINFO_NEW_VTABLE_MARKED (binfo))
2380             build_vtable (TYPE_BINFO (DECL_CONTEXT (CLASSTYPE_VFIELD (t))), t);
2381         }
2382       else
2383         {
2384           if (! BINFO_NEW_VTABLE_MARKED (binfo))
2385             prepare_fresh_vtable (binfo, t);
2386         }
2387     }
2388   if (fndecl == NULL_TREE)
2389     return;
2390
2391   n = skip_rtti_stuff (&virtuals);
2392
2393   while (virtuals)
2394     {
2395       tree current_fndecl = TREE_VALUE (virtuals);
2396       current_fndecl = FNADDR_FROM_VTABLE_ENTRY (current_fndecl);
2397       current_fndecl = TREE_OPERAND (current_fndecl, 0);
2398       if (current_fndecl && overrides (fndecl, current_fndecl))
2399         {
2400           tree base_offset, offset;
2401           tree context = DECL_CLASS_CONTEXT (fndecl);
2402           tree vfield = CLASSTYPE_VFIELD (t);
2403           tree this_offset;
2404
2405           offset = get_class_offset (context, t, binfo, fndecl);
2406
2407           /* Find the right offset for the this pointer based on the
2408              base class we just found.  We have to take into
2409              consideration the virtual base class pointers that we
2410              stick in before the virtual function table pointer.
2411
2412              Also, we want just the delta between the most base class
2413              that we derived this vfield from and us.  */
2414           base_offset = size_binop (PLUS_EXPR,
2415                                     get_derived_offset (binfo, DECL_CONTEXT (current_fndecl)),
2416                                     BINFO_OFFSET (binfo));
2417           this_offset = ssize_binop (MINUS_EXPR, offset, base_offset);
2418
2419           /* Make sure we can modify the derived association with immunity.  */
2420           if (TREE_USED (binfo))
2421             my_friendly_assert (0, 999);
2422
2423           if (binfo == TYPE_BINFO (t))
2424             {
2425               /* In this case, it is *type*'s vtable we are modifying.
2426                  We start with the approximation that it's vtable is that
2427                  of the immediate base class.  */
2428               if (! BINFO_NEW_VTABLE_MARKED (binfo))
2429                 build_vtable (TYPE_BINFO (DECL_CONTEXT (vfield)), t);
2430             }
2431           else
2432             {
2433               /* This is our very own copy of `basetype' to play with.
2434                  Later, we will fill in all the virtual functions
2435                  that override the virtual functions in these base classes
2436                  which are not defined by the current type.  */
2437               if (! BINFO_NEW_VTABLE_MARKED (binfo))
2438                 prepare_fresh_vtable (binfo, t);
2439             }
2440
2441 #ifdef NOTQUITE
2442           cp_warning ("in %D", DECL_NAME (BINFO_VTABLE (binfo)));
2443 #endif
2444           modify_vtable_entry (get_vtable_entry_n (BINFO_VIRTUALS (binfo), n),
2445                                build_vtable_entry (this_offset, pfn),
2446                                fndecl);
2447         }
2448       ++n;
2449       virtuals = TREE_CHAIN (virtuals);
2450     }
2451 }
2452
2453 /* These are the ones that are not through virtual base classes.  */
2454
2455 static void
2456 modify_all_direct_vtables (binfo, do_self, t, fndecl, pfn)
2457      tree binfo;
2458      int do_self;
2459      tree t, fndecl, pfn;
2460 {
2461   tree binfos = BINFO_BASETYPES (binfo);
2462   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2463
2464   /* Should we use something besides CLASSTYPE_VFIELDS? */
2465   if (do_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2466     {
2467       modify_one_vtable (binfo, t, fndecl, pfn);
2468     }
2469
2470   for (i = 0; i < n_baselinks; i++)
2471     {
2472       tree base_binfo = TREE_VEC_ELT (binfos, i);
2473       int is_not_base_vtable
2474         = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2475       if (! TREE_VIA_VIRTUAL (base_binfo))
2476         modify_all_direct_vtables (base_binfo, is_not_base_vtable, t, fndecl, pfn);
2477     }
2478 }
2479
2480 /* Fixup all the delta entries in this one vtable that need updating.  */
2481
2482 static void
2483 fixup_vtable_deltas1 (binfo, t)
2484      tree binfo, t;
2485 {
2486   tree virtuals = BINFO_VIRTUALS (binfo);
2487   unsigned HOST_WIDE_INT n;
2488
2489   n = skip_rtti_stuff (&virtuals);
2490
2491   while (virtuals)
2492     {
2493       tree fndecl = TREE_VALUE (virtuals);
2494       tree pfn = FNADDR_FROM_VTABLE_ENTRY (fndecl);
2495       tree delta = DELTA_FROM_VTABLE_ENTRY (fndecl);
2496       fndecl = TREE_OPERAND (pfn, 0);
2497       if (fndecl)
2498         {
2499           tree base_offset, offset;
2500           tree context = DECL_CLASS_CONTEXT (fndecl);
2501           tree vfield = CLASSTYPE_VFIELD (t);
2502           tree this_offset;
2503
2504           offset = get_class_offset (context, t, binfo, fndecl);
2505
2506           /* Find the right offset for the this pointer based on the
2507              base class we just found.  We have to take into
2508              consideration the virtual base class pointers that we
2509              stick in before the virtual function table pointer.
2510
2511              Also, we want just the delta between the most base class
2512              that we derived this vfield from and us.  */
2513           base_offset = size_binop (PLUS_EXPR,
2514                                     get_derived_offset (binfo,
2515                                                         DECL_CONTEXT (fndecl)),
2516                                     BINFO_OFFSET (binfo));
2517           this_offset = ssize_binop (MINUS_EXPR, offset, base_offset);
2518
2519           if (! tree_int_cst_equal (this_offset, delta))
2520             {
2521               /* Make sure we can modify the derived association with immunity.  */
2522               if (TREE_USED (binfo))
2523                 my_friendly_assert (0, 999);
2524
2525               if (binfo == TYPE_BINFO (t))
2526                 {
2527                   /* In this case, it is *type*'s vtable we are modifying.
2528                      We start with the approximation that it's vtable is that
2529                      of the immediate base class.  */
2530                   if (! BINFO_NEW_VTABLE_MARKED (binfo))
2531                     build_vtable (TYPE_BINFO (DECL_CONTEXT (vfield)), t);
2532                 }
2533               else
2534                 {
2535                   /* This is our very own copy of `basetype' to play with.
2536                      Later, we will fill in all the virtual functions
2537                      that override the virtual functions in these base classes
2538                      which are not defined by the current type.  */
2539                   if (! BINFO_NEW_VTABLE_MARKED (binfo))
2540                     prepare_fresh_vtable (binfo, t);
2541                 }
2542
2543               modify_vtable_entry (get_vtable_entry_n (BINFO_VIRTUALS (binfo), n),
2544                                    build_vtable_entry (this_offset, pfn),
2545                                    fndecl);
2546             }
2547         }
2548       ++n;
2549       virtuals = TREE_CHAIN (virtuals);
2550     }
2551 }
2552
2553 /* Fixup all the delta entries in all the direct vtables that need updating.
2554    This happens when we have non-overridden virtual functions from a
2555    virtual base class, that are at a different offset, in the new
2556    hierarchy, because the layout of the virtual bases has changed.  */
2557
2558 static void
2559 fixup_vtable_deltas (binfo, init_self, t)
2560      tree binfo;
2561      int init_self;
2562      tree t;
2563 {
2564   tree binfos = BINFO_BASETYPES (binfo);
2565   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2566
2567   for (i = 0; i < n_baselinks; i++)
2568     {
2569       tree base_binfo = TREE_VEC_ELT (binfos, i);
2570       int is_not_base_vtable
2571         = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2572       if (! TREE_VIA_VIRTUAL (base_binfo))
2573         fixup_vtable_deltas (base_binfo, is_not_base_vtable, t);
2574     }
2575   /* Should we use something besides CLASSTYPE_VFIELDS? */
2576   if (init_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2577     {
2578       fixup_vtable_deltas1 (binfo, t);
2579     }
2580 }
2581
2582 /* These are the ones that are through virtual base classes.  */
2583
2584 static void
2585 modify_all_indirect_vtables (binfo, do_self, via_virtual, t, fndecl, pfn)
2586      tree binfo;
2587      int do_self, via_virtual;
2588      tree t, fndecl, pfn;
2589 {
2590   tree binfos = BINFO_BASETYPES (binfo);
2591   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2592
2593   /* Should we use something besides CLASSTYPE_VFIELDS? */
2594   if (do_self && via_virtual && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2595     {
2596       modify_one_vtable (binfo, t, fndecl, pfn);
2597     }
2598
2599   for (i = 0; i < n_baselinks; i++)
2600     {
2601       tree base_binfo = TREE_VEC_ELT (binfos, i);
2602       int is_not_base_vtable
2603         = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2604       if (TREE_VIA_VIRTUAL (base_binfo))
2605         {
2606           via_virtual = 1;
2607           base_binfo = binfo_member (BINFO_TYPE (base_binfo), CLASSTYPE_VBASECLASSES (t));
2608         }
2609       modify_all_indirect_vtables (base_binfo, is_not_base_vtable, via_virtual, t, fndecl, pfn);
2610     }
2611 }
2612
2613 static void
2614 modify_all_vtables (t, fndecl, vfn)
2615      tree t, fndecl, vfn;
2616 {
2617   /* Do these first, so that we will make use of any non-virtual class's
2618      vtable, over a virtual classes vtable.  */
2619   modify_all_direct_vtables (TYPE_BINFO (t), 1, t, fndecl, vfn);
2620   if (TYPE_USES_VIRTUAL_BASECLASSES (t))
2621     modify_all_indirect_vtables (TYPE_BINFO (t), 1, 0, t, fndecl, vfn);
2622 }
2623
2624 /* Here, we already know that they match in every respect.
2625    All we have to check is where they had their declarations.  */
2626
2627 static int
2628 strictly_overrides (fndecl1, fndecl2)
2629      tree fndecl1, fndecl2;
2630 {
2631   int distance = get_base_distance (DECL_CLASS_CONTEXT (fndecl2),
2632                                     DECL_CLASS_CONTEXT (fndecl1),
2633                                     0, (tree *)0);
2634   if (distance == -2 || distance > 0)
2635     return 1;
2636   return 0;
2637 }
2638
2639 /* Merge overrides for one vtable.
2640    If we want to merge in same function, we are fine.
2641    else
2642      if one has a DECL_CLASS_CONTEXT that is a parent of the
2643        other, than choose the more derived one
2644      else
2645        potentially ill-formed (see 10.3 [class.virtual])
2646        we have to check later to see if there was an
2647        override in this class.  If there was ok, if not
2648        then it is ill-formed.  (mrs)
2649
2650    We take special care to reuse a vtable, if we can.  */
2651
2652 static void
2653 override_one_vtable (binfo, old, t)
2654      tree binfo, old, t;
2655 {
2656   tree virtuals = BINFO_VIRTUALS (binfo);
2657   tree old_virtuals = BINFO_VIRTUALS (old);
2658   enum { REUSE_NEW, REUSE_OLD, UNDECIDED, NEITHER } choose = UNDECIDED;
2659
2660   /* If we have already committed to modifying it, then don't try and
2661      reuse another vtable.  */
2662   if (BINFO_NEW_VTABLE_MARKED (binfo))
2663     choose = NEITHER;
2664
2665   skip_rtti_stuff (&virtuals);
2666   skip_rtti_stuff (&old_virtuals);
2667
2668   while (virtuals)
2669     {
2670       tree fndecl = TREE_VALUE (virtuals);
2671       tree old_fndecl = TREE_VALUE (old_virtuals);
2672       fndecl = FNADDR_FROM_VTABLE_ENTRY (fndecl);
2673       old_fndecl = FNADDR_FROM_VTABLE_ENTRY (old_fndecl);
2674       fndecl = TREE_OPERAND (fndecl, 0);
2675       old_fndecl = TREE_OPERAND (old_fndecl, 0);
2676       /* First check to see if they are the same.  */
2677       if (DECL_ASSEMBLER_NAME (fndecl) == DECL_ASSEMBLER_NAME (old_fndecl))
2678         {
2679           /* No need to do anything.  */
2680         }
2681       else if (strictly_overrides (fndecl, old_fndecl))
2682         {
2683           if (choose == UNDECIDED)
2684             choose = REUSE_NEW;
2685           else if (choose == REUSE_OLD)
2686             {
2687               choose = NEITHER;
2688               if (! BINFO_NEW_VTABLE_MARKED (binfo))
2689                 {
2690                   prepare_fresh_vtable (binfo, t);
2691                   override_one_vtable (binfo, old, t);
2692                   return;
2693                 }
2694             }
2695         }
2696       else if (strictly_overrides (old_fndecl, fndecl))
2697         {
2698           if (choose == UNDECIDED)
2699             choose = REUSE_OLD;
2700           else if (choose == REUSE_NEW)
2701             {
2702               choose = NEITHER;
2703               if (! BINFO_NEW_VTABLE_MARKED (binfo))
2704                 {
2705                   prepare_fresh_vtable (binfo, t);
2706                   override_one_vtable (binfo, old, t);
2707                   return;
2708                 }
2709               TREE_VALUE (virtuals) = TREE_VALUE (old_virtuals);
2710             }
2711           else if (choose == NEITHER)
2712             {
2713               TREE_VALUE (virtuals) = TREE_VALUE (old_virtuals);
2714             }
2715         }
2716       else
2717         {
2718           choose = NEITHER;
2719           if (! BINFO_NEW_VTABLE_MARKED (binfo))
2720             {
2721               prepare_fresh_vtable (binfo, t);
2722               override_one_vtable (binfo, old, t);
2723               return;
2724             }
2725           {
2726             /* This MUST be overridden, or the class is ill-formed.  */
2727             /* For now, we just make it abstract.  */
2728             tree fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
2729             tree vfn;
2730
2731             fndecl = copy_node (fndecl);
2732             copy_lang_decl (fndecl);
2733             DECL_ABSTRACT_VIRTUAL_P (fndecl) = 1;
2734             DECL_NEEDS_FINAL_OVERRIDER_P (fndecl) = 1;
2735             /* Make sure we search for it later.  */
2736             if (! CLASSTYPE_ABSTRACT_VIRTUALS (t))
2737               CLASSTYPE_ABSTRACT_VIRTUALS (t) = error_mark_node;
2738
2739             vfn = build1 (ADDR_EXPR, vfunc_ptr_type_node, fndecl);
2740             TREE_CONSTANT (vfn) = 1;
2741
2742             /* We can use integer_zero_node, as we will core dump
2743                if this is used anyway.  */
2744             TREE_VALUE (virtuals) = build_vtable_entry (integer_zero_node, vfn);
2745           }
2746         }
2747       virtuals = TREE_CHAIN (virtuals);
2748       old_virtuals = TREE_CHAIN (old_virtuals);
2749     }
2750
2751   /* Let's reuse the old vtable.  */
2752   if (choose == REUSE_OLD)
2753     {
2754       BINFO_VTABLE (binfo) = BINFO_VTABLE (old);
2755       BINFO_VIRTUALS (binfo) = BINFO_VIRTUALS (old);
2756     }
2757 }
2758
2759 /* Merge in overrides for virtual bases.
2760    BINFO is the hierarchy we want to modify, and OLD has the potential
2761    overrides.  */
2762
2763 static void
2764 merge_overrides (binfo, old, do_self, t)
2765      tree binfo, old;
2766      int do_self;
2767      tree t;
2768 {
2769   tree binfos = BINFO_BASETYPES (binfo);
2770   tree old_binfos = BINFO_BASETYPES (old);
2771   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2772
2773   /* Should we use something besides CLASSTYPE_VFIELDS? */
2774   if (do_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2775     {
2776       override_one_vtable (binfo, old, t);
2777     }
2778
2779   for (i = 0; i < n_baselinks; i++)
2780     {
2781       tree base_binfo = TREE_VEC_ELT (binfos, i);
2782       tree old_base_binfo = TREE_VEC_ELT (old_binfos, i);
2783       int is_not_base_vtable
2784         = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2785       if (! TREE_VIA_VIRTUAL (base_binfo))
2786         merge_overrides (base_binfo, old_base_binfo, is_not_base_vtable, t);
2787     }
2788 }
2789
2790 /* Get the base virtual function declarations in T that are either
2791    overridden or hidden by FNDECL as a list.  We set TREE_PURPOSE with
2792    the overrider/hider.  */
2793
2794 static tree
2795 get_basefndecls (fndecl, t)
2796      tree fndecl, t;
2797 {
2798   tree methods = TYPE_METHODS (t);
2799   tree base_fndecls = NULL_TREE;
2800   tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
2801   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2802
2803   while (methods)
2804     {
2805       if (TREE_CODE (methods) == FUNCTION_DECL
2806           && DECL_VINDEX (methods) != NULL_TREE
2807           && DECL_NAME (fndecl) == DECL_NAME (methods))
2808         base_fndecls = temp_tree_cons (fndecl, methods, base_fndecls);
2809
2810       methods = TREE_CHAIN (methods);
2811     }
2812
2813   if (base_fndecls)
2814     return base_fndecls;
2815
2816   for (i = 0; i < n_baseclasses; i++)
2817     {
2818       tree base_binfo = TREE_VEC_ELT (binfos, i);
2819       tree basetype = BINFO_TYPE (base_binfo);
2820
2821       base_fndecls = chainon (get_basefndecls (fndecl, basetype),
2822                               base_fndecls);
2823     }
2824
2825   return base_fndecls;
2826 }
2827
2828 /* Mark the functions that have been hidden with their overriders.
2829    Since we start out with all functions already marked with a hider,
2830    no need to mark functions that are just hidden.  */
2831
2832 static void
2833 mark_overriders (fndecl, base_fndecls)
2834      tree fndecl, base_fndecls;
2835 {
2836   while (base_fndecls)
2837     {
2838       if (overrides (TREE_VALUE (base_fndecls), fndecl))
2839         TREE_PURPOSE (base_fndecls) = fndecl;
2840
2841       base_fndecls = TREE_CHAIN (base_fndecls);
2842     }
2843 }
2844
2845 /* If this declaration supersedes the declaration of
2846    a method declared virtual in the base class, then
2847    mark this field as being virtual as well.  */
2848
2849 static void
2850 check_for_override (decl, ctype)
2851      tree decl, ctype;
2852 {
2853   tree binfos = BINFO_BASETYPES (TYPE_BINFO (ctype));
2854   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2855   int virtualp = DECL_VIRTUAL_P (decl);
2856
2857   for (i = 0; i < n_baselinks; i++)
2858     {
2859       tree base_binfo = TREE_VEC_ELT (binfos, i);
2860       if (TYPE_VIRTUAL_P (BINFO_TYPE (base_binfo))
2861           || flag_all_virtual == 1)
2862         {
2863           tree tmp = get_matching_virtual
2864             (base_binfo, decl,
2865              DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)));
2866           if (tmp)
2867             {
2868               /* If this function overrides some virtual in some base
2869                  class, then the function itself is also necessarily
2870                  virtual, even if the user didn't explicitly say so.  */
2871               DECL_VIRTUAL_P (decl) = 1;
2872
2873               /* The TMP we really want is the one from the deepest
2874                  baseclass on this path, taking care not to
2875                  duplicate if we have already found it (via another
2876                  path to its virtual baseclass.  */
2877               if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
2878                 {
2879                   cp_error_at ("method `%D' may not be declared static",
2880                                decl);
2881                   cp_error_at ("(since `%D' declared virtual in base class.)",
2882                                tmp);
2883                   break;
2884                 }
2885               virtualp = 1;
2886
2887 #if 0 /* The signature of an overriding function is not changed.  */
2888               {
2889                 /* The argument types may have changed...  */
2890                 tree type = TREE_TYPE (decl);
2891                 tree argtypes = TYPE_ARG_TYPES (type);
2892                 tree base_variant = TREE_TYPE (TREE_VALUE (argtypes));
2893                 tree raises = TYPE_RAISES_EXCEPTIONS (type);
2894
2895                 argtypes = commonparms (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (tmp))),
2896                                         TREE_CHAIN (argtypes));
2897                 /* But the return type has not.  */
2898                 type = build_cplus_method_type (base_variant, TREE_TYPE (type), argtypes);
2899                 if (raises)
2900                   type = build_exception_variant (type, raises);
2901                 TREE_TYPE (decl) = type;
2902               }
2903 #endif
2904               DECL_VINDEX (decl)
2905                 = tree_cons (NULL_TREE, tmp, DECL_VINDEX (decl));
2906               break;
2907             }
2908         }
2909     }
2910   if (virtualp)
2911     {
2912       if (DECL_VINDEX (decl) == NULL_TREE)
2913         DECL_VINDEX (decl) = error_mark_node;
2914       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2915     }
2916 }
2917
2918 /* Warn about hidden virtual functions that are not overridden in t.
2919    We know that constructors and destructors don't apply.  */
2920
2921 void
2922 warn_hidden (t)
2923      tree t;
2924 {
2925   tree method_vec = CLASSTYPE_METHOD_VEC (t);
2926   int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
2927   int i;
2928
2929   /* We go through each separately named virtual function.  */
2930   for (i = 2; i < n_methods; ++i)
2931     {
2932       tree fndecl = TREE_VEC_ELT (method_vec, i);
2933
2934       tree base_fndecls = NULL_TREE;
2935       tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
2936       int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2937
2938       if (DECL_VINDEX (fndecl) == NULL_TREE)
2939         continue;
2940
2941       /* First we get a list of all possible functions that might be
2942          hidden from each base class.  */
2943       for (i = 0; i < n_baseclasses; i++)
2944         {
2945           tree base_binfo = TREE_VEC_ELT (binfos, i);
2946           tree basetype = BINFO_TYPE (base_binfo);
2947
2948           base_fndecls = chainon (get_basefndecls (fndecl, basetype),
2949                                   base_fndecls);
2950         }
2951
2952       if (TREE_CHAIN (fndecl)
2953           && DECL_NAME (TREE_CHAIN (fndecl)) == DECL_NAME (fndecl))
2954           fndecl = TREE_CHAIN (fndecl);
2955         else
2956           fndecl = NULL_TREE;
2957
2958       /* ...then mark up all the base functions with overriders, preferring
2959          overriders to hiders.  */
2960       if (base_fndecls)
2961         while (fndecl)
2962           {
2963             mark_overriders (fndecl, base_fndecls);
2964
2965             if (TREE_CHAIN (fndecl)
2966                 && DECL_NAME (TREE_CHAIN (fndecl)) == DECL_NAME (fndecl))
2967               fndecl = TREE_CHAIN (fndecl);
2968             else
2969               fndecl = NULL_TREE;
2970           }
2971
2972       /* Now give a warning for all base functions without overriders,
2973          as they are hidden.  */
2974       while (base_fndecls)
2975         {
2976           if (! overrides (TREE_VALUE (base_fndecls),
2977                            TREE_PURPOSE (base_fndecls)))
2978             {
2979               /* Here we know it is a hider, and no overrider exists.  */
2980               cp_warning_at ("`%D' was hidden", TREE_VALUE (base_fndecls));
2981               cp_warning_at ("  by `%D'", TREE_PURPOSE (base_fndecls));
2982             }
2983
2984           base_fndecls = TREE_CHAIN (base_fndecls);
2985         }
2986     }
2987 }
2988
2989 /* Check for things that are invalid.  There are probably plenty of other
2990    things we should check for also.  */
2991
2992 static void
2993 finish_struct_anon (t)
2994      tree t;
2995 {
2996   tree field;
2997   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2998     {
2999       if (TREE_STATIC (field))
3000         continue;
3001       if (TREE_CODE (field) != FIELD_DECL)
3002         continue;
3003
3004       if (DECL_NAME (field) == NULL_TREE
3005           && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
3006         {
3007           tree* uelt = &TYPE_FIELDS (TREE_TYPE (field));
3008           for (; *uelt; uelt = &TREE_CHAIN (*uelt))
3009             {
3010               if (TREE_CODE (*uelt) != FIELD_DECL)
3011                 continue;
3012
3013               if (TREE_PRIVATE (*uelt))
3014                 cp_pedwarn_at ("private member `%#D' in anonymous union",
3015                                *uelt);
3016               else if (TREE_PROTECTED (*uelt))
3017                 cp_pedwarn_at ("protected member `%#D' in anonymous union",
3018                                *uelt);
3019
3020               TREE_PRIVATE (*uelt) = TREE_PRIVATE (field);
3021               TREE_PROTECTED (*uelt) = TREE_PROTECTED (field);
3022             }
3023         }
3024     }
3025 }
3026
3027 extern int interface_only, interface_unknown;
3028
3029 /* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
3030    (or C++ class declaration).
3031
3032    For C++, we must handle the building of derived classes.
3033    Also, C++ allows static class members.  The way that this is
3034    handled is to keep the field name where it is (as the DECL_NAME
3035    of the field), and place the overloaded decl in the DECL_FIELD_BITPOS
3036    of the field.  layout_record and layout_union will know about this.
3037
3038    More C++ hair: inline functions have text in their
3039    DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
3040    meaningful tree structure.  After the struct has been laid out, set
3041    things up so that this can happen.
3042
3043    And still more: virtual functions.  In the case of single inheritance,
3044    when a new virtual function is seen which redefines a virtual function
3045    from the base class, the new virtual function is placed into
3046    the virtual function table at exactly the same address that
3047    it had in the base class.  When this is extended to multiple
3048    inheritance, the same thing happens, except that multiple virtual
3049    function tables must be maintained.  The first virtual function
3050    table is treated in exactly the same way as in the case of single
3051    inheritance.  Additional virtual function tables have different
3052    DELTAs, which tell how to adjust `this' to point to the right thing.
3053
3054    LIST_OF_FIELDLISTS is just that.  The elements of the list are
3055    TREE_LIST elements, whose TREE_PURPOSE field tells what access
3056    the list has, and the TREE_VALUE slot gives the actual fields.
3057
3058    ATTRIBUTES is the set of decl attributes to be applied, if any.
3059
3060    If flag_all_virtual == 1, then we lay all functions into
3061    the virtual function table, as though they were declared
3062    virtual.  Constructors do not lay down in the virtual function table.
3063
3064    If flag_all_virtual == 2, then we lay all functions into
3065    the virtual function table, such that virtual functions
3066    occupy a space by themselves, and then all functions
3067    of the class occupy a space by themselves.  This is illustrated
3068    in the following diagram:
3069
3070    class A; class B : A;
3071
3072         Class A's vtbl:                 Class B's vtbl:
3073     --------------------------------------------------------------------
3074    | A's virtual functions|             | B's virtual functions         |
3075    |                      |             | (may inherit some from A).    |
3076     --------------------------------------------------------------------
3077    | All of A's functions |             | All of A's functions          |
3078    | (such as a->A::f).   |             | (such as b->A::f)             |
3079     --------------------------------------------------------------------
3080                                         | B's new virtual functions     |
3081                                         | (not defined in A.)           |
3082                                          -------------------------------
3083                                         | All of B's functions          |
3084                                         | (such as b->B::f)             |
3085                                          -------------------------------
3086
3087    this allows the program to make references to any function, virtual
3088    or otherwise in a type-consistent manner.  */
3089
3090 tree
3091 finish_struct_1 (t, warn_anon)
3092      tree t;
3093      int warn_anon;
3094 {
3095   int old;
3096   tree name = TYPE_IDENTIFIER (t);
3097   enum tree_code code = TREE_CODE (t);
3098   tree fields = TYPE_FIELDS (t);
3099   tree fn_fields = TYPE_METHODS (t);
3100   tree x, last_x, method_vec;
3101   int all_virtual;
3102   int has_virtual;
3103   int max_has_virtual;
3104   tree pending_virtuals = NULL_TREE;
3105   tree pending_hard_virtuals = NULL_TREE;
3106   tree abstract_virtuals = NULL_TREE;
3107   tree vfield;
3108   tree vfields;
3109   int cant_have_default_ctor;
3110   int cant_have_const_ctor;
3111   int no_const_asn_ref;
3112
3113   /* The index of the first base class which has virtual
3114      functions.  Only applied to non-virtual baseclasses.  */
3115   int first_vfn_base_index;
3116
3117   int n_baseclasses;
3118   int any_default_members = 0;
3119   int const_sans_init = 0;
3120   int ref_sans_init = 0;
3121   int nonprivate_method = 0;
3122   tree access_decls = NULL_TREE;
3123   int aggregate = 1;
3124   int empty = 1;
3125   int has_pointers = 0;
3126
3127   if (warn_anon && code != UNION_TYPE && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
3128     pedwarn ("anonymous class type not used to declare any objects");
3129
3130   if (TYPE_SIZE (t))
3131     {
3132       if (IS_AGGR_TYPE (t))
3133         cp_error ("redefinition of `%#T'", t);
3134       else
3135         my_friendly_abort (172);
3136       popclass (0);
3137       return t;
3138     }
3139
3140   GNU_xref_decl (current_function_decl, t);
3141
3142   /* If this type was previously laid out as a forward reference,
3143      make sure we lay it out again.  */
3144
3145   TYPE_SIZE (t) = NULL_TREE;
3146   CLASSTYPE_GOT_SEMICOLON (t) = 0;
3147
3148 #if 0
3149   /* This is in general too late to do this.  I moved the main case up to
3150      left_curly, what else needs to move?  */
3151   if (! IS_SIGNATURE (t))
3152     {
3153       my_friendly_assert (CLASSTYPE_INTERFACE_ONLY (t) == interface_only, 999);
3154       my_friendly_assert (CLASSTYPE_INTERFACE_KNOWN (t) == ! interface_unknown, 999);
3155     }
3156 #endif
3157
3158   old = suspend_momentary ();
3159
3160   /* Install struct as DECL_FIELD_CONTEXT of each field decl.
3161      Also process specified field sizes.
3162      Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
3163      The specified size is found in the DECL_INITIAL.
3164      Store 0 there, except for ": 0" fields (so we can find them
3165      and delete them, below).  */
3166
3167   if (TYPE_BINFO_BASETYPES (t))
3168     n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (t));
3169   else
3170     n_baseclasses = 0;
3171
3172   if (n_baseclasses > 0)
3173     {
3174       struct base_info base_info;
3175
3176       first_vfn_base_index = finish_base_struct (t, &base_info);
3177       /* Remember where we got our vfield from.  */
3178       CLASSTYPE_VFIELD_PARENT (t) = first_vfn_base_index;
3179       has_virtual = base_info.has_virtual;
3180       max_has_virtual = base_info.max_has_virtual;
3181       CLASSTYPE_N_SUPERCLASSES (t) += base_info.n_ancestors;
3182       vfield = base_info.vfield;
3183       vfields = base_info.vfields;
3184       CLASSTYPE_RTTI (t) = base_info.rtti;
3185       cant_have_default_ctor = base_info.cant_have_default_ctor;
3186       cant_have_const_ctor = base_info.cant_have_const_ctor;
3187       no_const_asn_ref = base_info.no_const_asn_ref;
3188       aggregate = 0;
3189     }
3190   else
3191     {
3192       first_vfn_base_index = -1;
3193       has_virtual = 0;
3194       max_has_virtual = has_virtual;
3195       vfield = NULL_TREE;
3196       vfields = NULL_TREE;
3197       CLASSTYPE_RTTI (t) = NULL_TREE;
3198       cant_have_default_ctor = 0;
3199       cant_have_const_ctor = 0;
3200       no_const_asn_ref = 0;
3201     }
3202
3203 #if 0
3204   /* Both of these should be done before now.  */
3205   if (write_virtuals == 3 && CLASSTYPE_INTERFACE_KNOWN (t)
3206       && ! IS_SIGNATURE (t))
3207     {
3208       my_friendly_assert (CLASSTYPE_INTERFACE_ONLY (t) == interface_only, 999);
3209       my_friendly_assert (CLASSTYPE_VTABLE_NEEDS_WRITING (t) == ! interface_only, 999);
3210     }
3211 #endif
3212
3213   /* The three of these are approximations which may later be
3214      modified.  Needed at this point to make add_virtual_function
3215      and modify_vtable_entries work.  */
3216   CLASSTYPE_VFIELDS (t) = vfields;
3217   CLASSTYPE_VFIELD (t) = vfield;
3218
3219   if (IS_SIGNATURE (t))
3220     all_virtual = 0;
3221   else if (flag_all_virtual == 1)
3222     all_virtual = 1;
3223   else
3224     all_virtual = 0;
3225
3226   for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
3227     {
3228       GNU_xref_member (current_class_name, x);
3229
3230       nonprivate_method |= ! TREE_PRIVATE (x);
3231
3232       /* If this was an evil function, don't keep it in class.  */
3233       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
3234         continue;
3235
3236       DECL_CLASS_CONTEXT (x) = t;
3237
3238       /* Do both of these, even though they're in the same union;
3239          if the insn `r' member and the size `i' member are
3240          different sizes, as on the alpha, the larger of the two
3241          will end up with garbage in it.  */
3242       DECL_SAVED_INSNS (x) = NULL_RTX;
3243       DECL_FIELD_SIZE (x) = 0;
3244
3245       check_for_override (x, t);
3246       if (DECL_ABSTRACT_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3247         cp_error_at ("initializer specified for non-virtual method `%D'", x);
3248
3249       /* The name of the field is the original field name
3250          Save this in auxiliary field for later overloading.  */
3251       if (DECL_VINDEX (x)
3252           || (all_virtual == 1 && ! DECL_CONSTRUCTOR_P (x)))
3253         {
3254           add_virtual_function (&pending_virtuals, &pending_hard_virtuals,
3255                                 &has_virtual, x, t);
3256           if (DECL_ABSTRACT_VIRTUAL_P (x))
3257             abstract_virtuals = tree_cons (NULL_TREE, x, abstract_virtuals);
3258 #if 0
3259           /* XXX Why did I comment this out?  (jason) */
3260           else
3261             TREE_USED (x) = 1;
3262 #endif
3263         }
3264     }
3265
3266   if (n_baseclasses)
3267     fields = chainon (build_vbase_pointer_fields (t), fields);
3268
3269   last_x = NULL_TREE;
3270   for (x = fields; x; x = TREE_CHAIN (x))
3271     {
3272       GNU_xref_member (current_class_name, x);
3273
3274       if (TREE_CODE (x) == FIELD_DECL)
3275         {
3276           DECL_PACKED (x) |= TYPE_PACKED (t);
3277           empty = 0;
3278         }
3279
3280       if (TREE_CODE (x) == USING_DECL)
3281         {
3282           /* Save access declarations for later.  */
3283           if (last_x)
3284             TREE_CHAIN (last_x) = TREE_CHAIN (x);
3285           else
3286             fields = TREE_CHAIN (x);
3287
3288           access_decls = scratch_tree_cons (NULL_TREE, x, access_decls);
3289           continue;
3290         }
3291
3292       last_x = x;
3293
3294       if (TREE_CODE (x) == TYPE_DECL
3295           || TREE_CODE (x) == TEMPLATE_DECL)
3296         continue;
3297
3298       /* If we've gotten this far, it's a data member, possibly static,
3299          or an enumerator.  */
3300
3301       DECL_FIELD_CONTEXT (x) = t;
3302
3303       /* ``A local class cannot have static data members.'' ARM 9.4 */
3304       if (current_function_decl && TREE_STATIC (x))
3305         cp_error_at ("field `%D' in local class cannot be static", x);
3306
3307       /* Perform error checking that did not get done in
3308          grokdeclarator.  */
3309       if (TREE_CODE (TREE_TYPE (x)) == FUNCTION_TYPE)
3310         {
3311           cp_error_at ("field `%D' invalidly declared function type",
3312                        x);
3313           TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
3314         }
3315       else if (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE)
3316         {
3317           cp_error_at ("field `%D' invalidly declared method type", x);
3318           TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
3319         }
3320       else if (TREE_CODE (TREE_TYPE (x)) == OFFSET_TYPE)
3321         {
3322           cp_error_at ("field `%D' invalidly declared offset type", x);
3323           TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
3324         }
3325
3326 #if 0
3327       if (DECL_NAME (x) == constructor_name (t))
3328         cant_have_default_ctor = 1;
3329 #endif
3330
3331       if (TREE_TYPE (x) == error_mark_node)
3332         continue;
3333
3334       DECL_SAVED_INSNS (x) = NULL_RTX;
3335       DECL_FIELD_SIZE (x) = 0;
3336
3337       /* When this goes into scope, it will be a non-local reference.  */
3338       DECL_NONLOCAL (x) = 1;
3339
3340       if (TREE_CODE (x) == CONST_DECL)
3341         continue;
3342
3343       if (TREE_CODE (x) == VAR_DECL)
3344         {
3345           if (TREE_CODE (t) == UNION_TYPE)
3346             /* Unions cannot have static members.  */
3347             cp_error_at ("field `%D' declared static in union", x);
3348
3349           continue;
3350         }
3351
3352       /* Now it can only be a FIELD_DECL.  */
3353
3354       if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3355         aggregate = 0;
3356
3357       /* If this is of reference type, check if it needs an init.
3358          Also do a little ANSI jig if necessary.  */
3359       if (TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE)
3360         {
3361           if (DECL_INITIAL (x) == NULL_TREE)
3362             ref_sans_init = 1;
3363
3364           /* ARM $12.6.2: [A member initializer list] (or, for an
3365              aggregate, initialization by a brace-enclosed list) is the
3366              only way to initialize nonstatic const and reference
3367              members.  */
3368           cant_have_default_ctor = 1;
3369           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3370
3371           if (! TYPE_HAS_CONSTRUCTOR (t) && extra_warnings)
3372             {
3373               if (DECL_NAME (x))
3374                 cp_warning_at ("non-static reference `%#D' in class without a constructor", x);
3375               else
3376                 cp_warning_at ("non-static reference in class without a constructor", x);
3377             }
3378         }
3379
3380       if (TREE_CODE (TREE_TYPE (x)) == POINTER_TYPE)
3381         has_pointers = 1;
3382
3383       /* If any field is const, the structure type is pseudo-const.  */
3384       if (TREE_READONLY (x))
3385         {
3386           C_TYPE_FIELDS_READONLY (t) = 1;
3387           if (DECL_INITIAL (x) == NULL_TREE)
3388             const_sans_init = 1;
3389
3390           /* ARM $12.6.2: [A member initializer list] (or, for an
3391              aggregate, initialization by a brace-enclosed list) is the
3392              only way to initialize nonstatic const and reference
3393              members.  */
3394           cant_have_default_ctor = 1;
3395           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3396
3397           if (! TYPE_HAS_CONSTRUCTOR (t) && !IS_SIGNATURE (t)
3398               && extra_warnings)
3399             {
3400               if (DECL_NAME (x))
3401                 cp_warning_at ("non-static const member `%#D' in class without a constructor", x);
3402               else
3403                 cp_warning_at ("non-static const member in class without a constructor", x);
3404             }
3405         }
3406       else
3407         {
3408           /* A field that is pseudo-const makes the structure
3409              likewise.  */
3410           tree t1 = TREE_TYPE (x);
3411           while (TREE_CODE (t1) == ARRAY_TYPE)
3412             t1 = TREE_TYPE (t1);
3413           if (IS_AGGR_TYPE (t1))
3414             {
3415               if (C_TYPE_FIELDS_READONLY (t1))
3416                 C_TYPE_FIELDS_READONLY (t) = 1;
3417               if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (t1))
3418                 const_sans_init = 1;
3419             }
3420         }
3421
3422       /* We set DECL_BIT_FIELD tentatively in grokbitfield.
3423          If the type and width are valid, we'll keep it set.
3424          Otherwise, the flag is cleared.  */
3425       if (DECL_BIT_FIELD (x))
3426         {
3427           DECL_BIT_FIELD (x) = 0;
3428           /* Invalid bit-field size done by grokfield.  */
3429           /* Detect invalid bit-field type.  */
3430           if (DECL_INITIAL (x)
3431               && ! INTEGRAL_TYPE_P (TREE_TYPE (x)))
3432             {
3433               cp_error_at ("bit-field `%#D' with non-integral type", x);
3434               DECL_INITIAL (x) = NULL;
3435             }
3436
3437           /* Detect and ignore out of range field width.  */
3438           if (DECL_INITIAL (x))
3439             {
3440               tree w = DECL_INITIAL (x);
3441               register int width = 0;
3442
3443               /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs.  */
3444               STRIP_NOPS (w);
3445
3446               /* detect invalid field size.  */
3447               if (TREE_CODE (w) == CONST_DECL)
3448                 w = DECL_INITIAL (w);
3449               else if (TREE_READONLY_DECL_P (w))
3450                 w = decl_constant_value (w);
3451
3452               if (TREE_CODE (w) != INTEGER_CST)
3453                 {
3454                   cp_error_at ("bit-field `%D' width not an integer constant",
3455                                x);
3456                   DECL_INITIAL (x) = NULL_TREE;
3457                 }
3458               else if (width = TREE_INT_CST_LOW (w),
3459                        width < 0)
3460                 {
3461                   DECL_INITIAL (x) = NULL;
3462                   cp_error_at ("negative width in bit-field `%D'", x);
3463                 }
3464               else if (width == 0 && DECL_NAME (x) != 0)
3465                 {
3466                   DECL_INITIAL (x) = NULL;
3467                   cp_error_at ("zero width for bit-field `%D'", x);
3468                 }
3469               else if (width
3470                        > TYPE_PRECISION (long_long_unsigned_type_node))
3471                 {
3472                   /* The backend will dump if you try to use something
3473                      too big; avoid that.  */
3474                   DECL_INITIAL (x) = NULL;
3475                   sorry ("bit-fields larger than %d bits",
3476                          TYPE_PRECISION (long_long_unsigned_type_node));
3477                   cp_error_at ("  in declaration of `%D'", x);
3478                 }
3479               else if (width > TYPE_PRECISION (TREE_TYPE (x))
3480                        && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE
3481                        && TREE_CODE (TREE_TYPE (x)) != BOOLEAN_TYPE)
3482                 {
3483                   cp_warning_at ("width of `%D' exceeds its type", x);
3484                 }
3485               else if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
3486                        && ((min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
3487                                            TREE_UNSIGNED (TREE_TYPE (x))) > width)
3488                            || (min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
3489                                               TREE_UNSIGNED (TREE_TYPE (x))) > width)))
3490                 {
3491                   cp_warning_at ("`%D' is too small to hold all values of `%#T'",
3492                                  x, TREE_TYPE (x));
3493                 }
3494
3495               if (DECL_INITIAL (x) == NULL_TREE)
3496                 ;
3497               else if (width == 0)
3498                 {
3499 #ifdef EMPTY_FIELD_BOUNDARY
3500                   DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
3501 #endif
3502 #ifdef PCC_BITFIELD_TYPE_MATTERS
3503                   DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
3504                                         TYPE_ALIGN (TREE_TYPE (x)));
3505 #endif
3506                 }
3507               else
3508                 {
3509                   DECL_INITIAL (x) = NULL_TREE;
3510                   DECL_FIELD_SIZE (x) = width;
3511                   DECL_BIT_FIELD (x) = 1;
3512                 }
3513             }
3514           else
3515             /* Non-bit-fields are aligned for their type.  */
3516             DECL_ALIGN (x) = MAX (DECL_ALIGN (x), TYPE_ALIGN (TREE_TYPE (x)));
3517         }
3518       else
3519         {
3520           tree type = TREE_TYPE (x);
3521
3522           while (TREE_CODE (type) == ARRAY_TYPE)
3523             type = TREE_TYPE (type);
3524
3525           if (TYPE_LANG_SPECIFIC (type) && ! ANON_UNION_P (x)
3526               && ! TYPE_PTRMEMFUNC_P (type))
3527             {
3528               /* Never let anything with uninheritable virtuals
3529                  make it through without complaint.  */
3530               if (CLASSTYPE_ABSTRACT_VIRTUALS (type))
3531                 abstract_virtuals_error (x, type);
3532
3533               /* Don't let signatures make it through either.  */
3534               if (IS_SIGNATURE (type))
3535                 signature_error (x, type);
3536
3537               if (code == UNION_TYPE)
3538                 {
3539                   char *fie = NULL;
3540                   if (TYPE_NEEDS_CONSTRUCTING (type))
3541                     fie = "constructor";
3542                   else if (TYPE_NEEDS_DESTRUCTOR (type))
3543                     fie = "destructor";
3544                   else if (TYPE_HAS_REAL_ASSIGNMENT (type))
3545                     fie = "assignment operator";
3546                   if (fie)
3547                     cp_error_at ("member `%#D' with %s not allowed in union", x,
3548                                  fie);
3549                 }
3550               else
3551                 {
3552                   TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
3553                   TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (type);
3554                   TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
3555                   TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
3556                 }
3557
3558               if (!TYPE_HAS_CONST_INIT_REF (type))
3559                 cant_have_const_ctor = 1;
3560
3561               if (!TYPE_HAS_CONST_ASSIGN_REF (type))
3562                 no_const_asn_ref = 1;
3563
3564               if (TYPE_HAS_CONSTRUCTOR (type)
3565                   && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
3566                 {
3567                   cant_have_default_ctor = 1;
3568 #if 0
3569                   /* This is wrong for aggregates.  */
3570                   if (! TYPE_HAS_CONSTRUCTOR (t))
3571                     {
3572                       if (DECL_NAME (x))
3573                         cp_pedwarn_at ("member `%#D' with only non-default constructor", x);
3574                       else
3575                         cp_pedwarn_at ("member with only non-default constructor", x);
3576                       cp_pedwarn_at ("in class without a constructor",
3577                                      x);
3578                     }
3579 #endif
3580                 }
3581             }
3582           if (DECL_INITIAL (x) != NULL_TREE)
3583             {
3584               /* `build_class_init_list' does not recognize
3585                  non-FIELD_DECLs.  */
3586               if (code == UNION_TYPE && any_default_members != 0)
3587                 cp_error_at ("multiple fields in union `%T' initialized");
3588               any_default_members = 1;
3589             }
3590         }
3591     }
3592
3593   /* If this type has any constant members which did not come
3594      with their own initialization, mark that fact here.  It is
3595      not an error here, since such types can be saved either by their
3596      constructors, or by fortuitous initialization.  */
3597   CLASSTYPE_READONLY_FIELDS_NEED_INIT (t) = const_sans_init;
3598   CLASSTYPE_REF_FIELDS_NEED_INIT (t) = ref_sans_init;
3599   CLASSTYPE_ABSTRACT_VIRTUALS (t) = abstract_virtuals;
3600
3601   /* Synthesize any needed methods.  Note that methods will be synthesized
3602      for anonymous unions; grok_x_components undoes that.  */
3603
3604   if (! fn_fields)
3605     nonprivate_method = 1;
3606
3607   if (TYPE_NEEDS_DESTRUCTOR (t) && !TYPE_HAS_DESTRUCTOR (t)
3608       && !IS_SIGNATURE (t))
3609     {
3610       /* Here we must cons up a destructor on the fly.  */
3611       tree dtor = cons_up_default_function (t, name, 0);
3612       check_for_override (dtor, t);
3613
3614       /* If we couldn't make it work, then pretend we didn't need it.  */
3615       if (dtor == void_type_node)
3616         TYPE_NEEDS_DESTRUCTOR (t) = 0;
3617       else
3618         {
3619           /* Link dtor onto end of fn_fields.  */
3620
3621           TREE_CHAIN (dtor) = fn_fields;
3622           fn_fields = dtor;
3623
3624           if (DECL_VINDEX (dtor))
3625             add_virtual_function (&pending_virtuals, &pending_hard_virtuals,
3626                                   &has_virtual, dtor, t);
3627           nonprivate_method = 1;
3628         }
3629     }
3630
3631   /* Effective C++ rule 11.  */
3632   if (has_pointers && warn_ecpp && TYPE_HAS_CONSTRUCTOR (t)
3633       && ! (TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
3634     {
3635       cp_warning ("`%#T' has pointer data members", t);
3636
3637       if (! TYPE_HAS_INIT_REF (t))
3638         {
3639           cp_warning ("  but does not override `%T(const %T&)'", t, t);
3640           if (! TYPE_HAS_ASSIGN_REF (t))
3641             cp_warning ("  or `operator=(const %T&)'", t);
3642         }
3643       else if (! TYPE_HAS_ASSIGN_REF (t))
3644         cp_warning ("  but does not override `operator=(const %T&)'", t);
3645     }
3646
3647   TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t);
3648
3649   TYPE_HAS_COMPLEX_INIT_REF (t)
3650     |= (TYPE_HAS_INIT_REF (t) || TYPE_USES_VIRTUAL_BASECLASSES (t)
3651         || has_virtual || any_default_members);
3652   TYPE_NEEDS_CONSTRUCTING (t)
3653     |= (TYPE_HAS_CONSTRUCTOR (t) || TYPE_USES_VIRTUAL_BASECLASSES (t)
3654         || has_virtual || any_default_members);
3655   if (! IS_SIGNATURE (t))
3656     CLASSTYPE_NON_AGGREGATE (t)
3657       = ! aggregate || has_virtual || TYPE_HAS_CONSTRUCTOR (t);
3658
3659   /* ARM $12.1: A default constructor will be generated for a class X
3660      only if no constructor has been declared for class X.  So we
3661      check TYPE_HAS_CONSTRUCTOR also, to make sure we don't generate
3662      one if they declared a constructor in this class.  */
3663   if (! TYPE_HAS_CONSTRUCTOR (t) && ! cant_have_default_ctor
3664       && ! IS_SIGNATURE (t))
3665     {
3666       tree default_fn = cons_up_default_function (t, name, 2);
3667       TREE_CHAIN (default_fn) = fn_fields;
3668       fn_fields = default_fn;
3669     }
3670
3671   /* Create default copy constructor, if needed.  */
3672   if (! TYPE_HAS_INIT_REF (t) && ! IS_SIGNATURE (t) && ! TYPE_FOR_JAVA (t))
3673     {
3674       /* ARM 12.18: You get either X(X&) or X(const X&), but
3675          not both.  --Chip  */
3676       tree default_fn = cons_up_default_function (t, name,
3677                                                   3 + cant_have_const_ctor);
3678       TREE_CHAIN (default_fn) = fn_fields;
3679       fn_fields = default_fn;
3680     }
3681
3682   TYPE_HAS_REAL_ASSIGNMENT (t) |= TYPE_HAS_ASSIGNMENT (t);
3683   TYPE_HAS_REAL_ASSIGN_REF (t) |= TYPE_HAS_ASSIGN_REF (t);
3684   TYPE_HAS_COMPLEX_ASSIGN_REF (t)
3685     |= TYPE_HAS_ASSIGN_REF (t) || TYPE_USES_VIRTUAL_BASECLASSES (t);
3686
3687   if (! TYPE_HAS_ASSIGN_REF (t) && ! IS_SIGNATURE (t) && ! TYPE_FOR_JAVA (t))
3688     {
3689       tree default_fn = cons_up_default_function (t, name,
3690                                                   5 + no_const_asn_ref);
3691       TREE_CHAIN (default_fn) = fn_fields;
3692       fn_fields = default_fn;
3693     }
3694
3695   if (fn_fields)
3696     {
3697       TYPE_METHODS (t) = fn_fields;
3698       method_vec = finish_struct_methods (t, fn_fields, nonprivate_method);
3699
3700       if (TYPE_HAS_CONSTRUCTOR (t)
3701           && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
3702           && DECL_FRIENDLIST (TYPE_MAIN_DECL (t)) == NULL_TREE)
3703         {
3704           int nonprivate_ctor = 0;
3705           tree ctor;
3706
3707           for (ctor = TREE_VEC_ELT (method_vec, 0);
3708                ctor;
3709                ctor = OVL_NEXT (ctor))
3710             if (! TREE_PRIVATE (OVL_CURRENT (ctor)))
3711               {
3712                 nonprivate_ctor = 1;
3713                 break;
3714               }
3715
3716           if (nonprivate_ctor == 0 && warn_ctor_dtor_privacy)
3717             cp_warning ("`%#T' only defines private constructors and has no friends",
3718                         t);
3719         }
3720     }
3721   else
3722     {
3723       method_vec = 0;
3724
3725       /* Just in case these got accidentally
3726          filled in by syntax errors.  */
3727       TYPE_HAS_CONSTRUCTOR (t) = 0;
3728       TYPE_HAS_DESTRUCTOR (t) = 0;
3729     }
3730
3731   for (access_decls = nreverse (access_decls); access_decls;
3732        access_decls = TREE_CHAIN (access_decls))
3733     handle_using_decl (TREE_VALUE (access_decls), t, method_vec, fields);
3734
3735   if (vfield == NULL_TREE && has_virtual)
3736     {
3737       /* We build this decl with ptr_type_node, and
3738          change the type when we know what it should be.  */
3739       vfield = build_lang_field_decl (FIELD_DECL, get_vfield_name (t),
3740                                       ptr_type_node);
3741       /* If you change any of the below, take a look at all the
3742          other VFIELD_BASEs and VTABLE_BASEs in the code, and change
3743          them too.  */
3744       DECL_ASSEMBLER_NAME (vfield) = get_identifier (VFIELD_BASE);
3745       CLASSTYPE_VFIELD (t) = vfield;
3746       DECL_VIRTUAL_P (vfield) = 1;
3747       DECL_ARTIFICIAL (vfield) = 1;
3748       DECL_FIELD_CONTEXT (vfield) = t;
3749       DECL_CLASS_CONTEXT (vfield) = t;
3750       DECL_FCONTEXT (vfield) = t;
3751       DECL_SAVED_INSNS (vfield) = NULL_RTX;
3752       DECL_FIELD_SIZE (vfield) = 0;
3753       DECL_ALIGN (vfield) = TYPE_ALIGN (ptr_type_node);
3754 #if 0
3755       /* This is more efficient, but breaks binary compatibility, turn
3756          it on sometime when we don't care.  If we turn it on, we also
3757          have to enable the code in dfs_init_vbase_pointers.  */
3758       /* vfield is always first entry in structure.  */
3759       TREE_CHAIN (vfield) = fields;
3760       fields = vfield;
3761 #else
3762       if (last_x)
3763         {
3764           my_friendly_assert (TREE_CHAIN (last_x) == NULL_TREE, 175);
3765           TREE_CHAIN (last_x) = vfield;
3766           last_x = vfield;
3767         }
3768       else
3769         fields = vfield;
3770 #endif
3771       empty = 0;
3772       vfields = chainon (vfields, CLASSTYPE_AS_LIST (t));
3773     }
3774
3775   /* Now DECL_INITIAL is null on all members except for zero-width bit-fields.
3776      And they have already done their work.
3777
3778      C++: maybe we will support default field initialization some day...  */
3779
3780   /* Delete all zero-width bit-fields from the front of the fieldlist */
3781   while (fields && DECL_BIT_FIELD (fields)
3782          && DECL_INITIAL (fields))
3783     fields = TREE_CHAIN (fields);
3784   /* Delete all such fields from the rest of the fields.  */
3785   for (x = fields; x;)
3786     {
3787       if (TREE_CHAIN (x) && DECL_BIT_FIELD (TREE_CHAIN (x))
3788           && DECL_INITIAL (TREE_CHAIN (x)))
3789         TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
3790       else
3791         x = TREE_CHAIN (x);
3792     }
3793   /* Delete all duplicate fields from the fields */
3794   delete_duplicate_fields (fields);
3795
3796   /* Catch function/field name conflict.  We don't need to do this for a
3797      signature, since it can only contain the fields constructed in
3798      append_signature_fields.  */
3799   if (! IS_SIGNATURE (t))
3800     {
3801       int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
3802       for (x = fields; x; x = TREE_CHAIN (x))
3803         {
3804           tree name = DECL_NAME (x);
3805           int i = 2;
3806
3807           if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
3808             continue;
3809
3810           for (; i < n_methods; ++i)
3811             if (DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (method_vec, i)))
3812                 == name)
3813               {
3814                 cp_error_at ("data member `%#D' conflicts with", x);
3815                 cp_error_at ("function member `%#D'",
3816                              OVL_CURRENT (TREE_VEC_ELT (method_vec, i)));
3817                 break;
3818               }
3819         }
3820     }
3821
3822   /* Now we have the final fieldlist for the data fields.  Record it,
3823      then lay out the structure or union (including the fields).  */
3824
3825   TYPE_FIELDS (t) = fields;
3826
3827   if (n_baseclasses)
3828     {
3829       last_x = build_base_fields (t);
3830
3831       /* If all our bases are empty, we can be empty too.  */
3832       for (x = last_x; empty && x; x = TREE_CHAIN (x))
3833         if (DECL_SIZE (x) != integer_zero_node)
3834           empty = 0;
3835     }
3836   if (empty)
3837     {
3838       /* C++: do not let empty structures exist.  */
3839       tree decl = build_lang_field_decl
3840         (FIELD_DECL, NULL_TREE, char_type_node);
3841       TREE_CHAIN (decl) = fields;
3842       TYPE_FIELDS (t) = decl;
3843     }
3844   if (n_baseclasses)
3845     TYPE_FIELDS (t) = chainon (last_x, TYPE_FIELDS (t));
3846
3847   layout_type (t);
3848
3849   /* Remember the size and alignment of the class before adding
3850      the virtual bases.  */
3851   if (empty && flag_new_abi)
3852     CLASSTYPE_SIZE (t) = integer_zero_node;
3853   else if (flag_new_abi && TYPE_HAS_COMPLEX_INIT_REF (t)
3854            && TYPE_HAS_COMPLEX_ASSIGN_REF (t))
3855     CLASSTYPE_SIZE (t) = TYPE_BINFO_SIZE (t);
3856   else
3857     CLASSTYPE_SIZE (t) = TYPE_SIZE (t);
3858   CLASSTYPE_ALIGN (t) = TYPE_ALIGN (t);
3859
3860   finish_struct_anon (t);
3861
3862   /* Set the TYPE_DECL for this type to contain the right
3863      value for DECL_OFFSET, so that we can use it as part
3864      of a COMPONENT_REF for multiple inheritance.  */
3865
3866   layout_decl (TYPE_MAIN_DECL (t), 0);
3867
3868   /* Now fix up any virtual base class types that we left lying
3869      around.  We must get these done before we try to lay out the
3870      virtual function table.  */
3871   pending_hard_virtuals = nreverse (pending_hard_virtuals);
3872
3873   if (n_baseclasses)
3874     /* layout_basetypes will remove the base subobject fields.  */
3875     max_has_virtual = layout_basetypes (t, max_has_virtual);
3876   else if (empty)
3877     TYPE_FIELDS (t) = fields;
3878
3879   if (TYPE_USES_VIRTUAL_BASECLASSES (t))
3880     {
3881       tree vbases;
3882
3883       vbases = CLASSTYPE_VBASECLASSES (t);
3884       CLASSTYPE_N_VBASECLASSES (t) = list_length (vbases);
3885
3886       {
3887         /* Now fixup overrides of all functions in vtables from all
3888            direct or indirect virtual base classes.  */
3889         tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
3890         int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
3891
3892         for (i = 0; i < n_baseclasses; i++)
3893           {
3894             tree base_binfo = TREE_VEC_ELT (binfos, i);
3895             tree basetype = BINFO_TYPE (base_binfo);
3896             tree vbases;
3897
3898             vbases = CLASSTYPE_VBASECLASSES (basetype);
3899             while (vbases)
3900               {
3901                 merge_overrides (binfo_member (BINFO_TYPE (vbases),
3902                                                CLASSTYPE_VBASECLASSES (t)),
3903                                  vbases, 1, t);
3904                 vbases = TREE_CHAIN (vbases);
3905               }
3906           }
3907         }
3908     }
3909
3910   /* Set up the DECL_FIELD_BITPOS of the vfield if we need to, as we
3911      might need to know it for setting up the offsets in the vtable
3912      (or in thunks) below.  */
3913   if (vfield != NULL_TREE
3914       && DECL_FIELD_CONTEXT (vfield) != t)
3915     {
3916       tree binfo = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
3917       tree offset = BINFO_OFFSET (binfo);
3918
3919       vfield = copy_node (vfield);
3920       copy_lang_decl (vfield);
3921
3922       if (! integer_zerop (offset))
3923         offset = size_binop (MULT_EXPR, offset, size_int (BITS_PER_UNIT));
3924       DECL_FIELD_CONTEXT (vfield) = t;
3925       DECL_CLASS_CONTEXT (vfield) = t;
3926       DECL_FIELD_BITPOS (vfield)
3927         = size_binop (PLUS_EXPR, offset, DECL_FIELD_BITPOS (vfield));
3928       CLASSTYPE_VFIELD (t) = vfield;
3929     }
3930
3931 #ifdef NOTQUITE
3932   cp_warning ("Doing hard virtuals for %T...", t);
3933 #endif
3934
3935   if (has_virtual > max_has_virtual)
3936     max_has_virtual = has_virtual;
3937   if (max_has_virtual > 0)
3938     TYPE_VIRTUAL_P (t) = 1;
3939
3940   if (flag_rtti && TYPE_VIRTUAL_P (t) && !pending_hard_virtuals)
3941     modify_all_vtables (t, NULL_TREE, NULL_TREE);
3942
3943   while (pending_hard_virtuals)
3944     {
3945       modify_all_vtables (t,
3946                           TREE_PURPOSE (pending_hard_virtuals),
3947                           TREE_VALUE (pending_hard_virtuals));
3948       pending_hard_virtuals = TREE_CHAIN (pending_hard_virtuals);
3949     }
3950
3951   if (TYPE_USES_VIRTUAL_BASECLASSES (t))
3952     {
3953       tree vbases;
3954       /* Now fixup any virtual function entries from virtual bases
3955          that have different deltas.  This has to come after we do the
3956          pending hard virtuals, as we might have a function that comes
3957          from multiple virtual base instances that is only overridden
3958          by a hard virtual above.  */
3959       vbases = CLASSTYPE_VBASECLASSES (t);
3960       while (vbases)
3961         {
3962           /* We might be able to shorten the amount of work we do by
3963              only doing this for vtables that come from virtual bases
3964              that have differing offsets, but don't want to miss any
3965              entries.  */
3966           fixup_vtable_deltas (vbases, 1, t);
3967           vbases = TREE_CHAIN (vbases);
3968         }
3969     }
3970
3971   /* Under our model of GC, every C++ class gets its own virtual
3972      function table, at least virtually.  */
3973   if (pending_virtuals)
3974     {
3975       pending_virtuals = nreverse (pending_virtuals);
3976       /* We must enter these virtuals into the table.  */
3977       if (first_vfn_base_index < 0)
3978         {
3979           /* The second slot is for the tdesc pointer when thunks are used.  */
3980           if (flag_vtable_thunks)
3981             pending_virtuals = tree_cons (NULL_TREE, NULL_TREE, pending_virtuals);
3982
3983           /* The first slot is for the rtti offset.  */
3984           pending_virtuals = tree_cons (NULL_TREE, NULL_TREE, pending_virtuals);
3985
3986           set_rtti_entry (pending_virtuals, integer_zero_node, t);
3987           build_vtable (NULL_TREE, t);
3988         }
3989       else
3990         {
3991           /* Here we know enough to change the type of our virtual
3992              function table, but we will wait until later this function.  */
3993
3994           if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
3995             build_vtable (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), first_vfn_base_index), t);
3996         }
3997
3998       /* If this type has basetypes with constructors, then those
3999          constructors might clobber the virtual function table.  But
4000          they don't if the derived class shares the exact vtable of the base
4001          class.  */
4002
4003       CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
4004     }
4005   else if (first_vfn_base_index >= 0)
4006     {
4007       tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), first_vfn_base_index);
4008       /* This class contributes nothing new to the virtual function
4009          table.  However, it may have declared functions which
4010          went into the virtual function table "inherited" from the
4011          base class.  If so, we grab a copy of those updated functions,
4012          and pretend they are ours.  */
4013
4014       /* See if we should steal the virtual info from base class.  */
4015       if (TYPE_BINFO_VTABLE (t) == NULL_TREE)
4016         TYPE_BINFO_VTABLE (t) = BINFO_VTABLE (binfo);
4017       if (TYPE_BINFO_VIRTUALS (t) == NULL_TREE)
4018         TYPE_BINFO_VIRTUALS (t) = BINFO_VIRTUALS (binfo);
4019       if (TYPE_BINFO_VTABLE (t) != BINFO_VTABLE (binfo))
4020         CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
4021     }
4022
4023   if (max_has_virtual || first_vfn_base_index >= 0)
4024     {
4025       CLASSTYPE_VSIZE (t) = has_virtual;
4026       if (first_vfn_base_index >= 0)
4027         {
4028           if (pending_virtuals)
4029             TYPE_BINFO_VIRTUALS (t) = chainon (TYPE_BINFO_VIRTUALS (t),
4030                                                 pending_virtuals);
4031         }
4032       else if (has_virtual)
4033         {
4034           TYPE_BINFO_VIRTUALS (t) = pending_virtuals;
4035           if (write_virtuals >= 0)
4036             DECL_VIRTUAL_P (TYPE_BINFO_VTABLE (t)) = 1;
4037         }
4038     }
4039
4040   /* Now lay out the virtual function table.  */
4041   if (has_virtual)
4042     {
4043       tree atype, itype;
4044
4045       if (TREE_TYPE (vfield) == ptr_type_node)
4046         {
4047           /* We must create a pointer to this table because
4048              the one inherited from base class does not exist.
4049              We will fill in the type when we know what it
4050              should really be.  Use `size_int' so values are memoized
4051              in common cases.  */
4052           itype = build_index_type (size_int (has_virtual));
4053           atype = build_array_type (vtable_entry_type, itype);
4054           layout_type (atype);
4055           TREE_TYPE (vfield) = build_pointer_type (atype);
4056         }
4057       else
4058         {
4059           atype = TREE_TYPE (TREE_TYPE (vfield));
4060
4061           if (has_virtual != TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (atype))))
4062             {
4063               /* We must extend (or create) the boundaries on this array,
4064                  because we picked up virtual functions from multiple
4065                  base classes.  */
4066               itype = build_index_type (size_int (has_virtual));
4067               atype = build_array_type (vtable_entry_type, itype);
4068               layout_type (atype);
4069               vfield = copy_node (vfield);
4070               TREE_TYPE (vfield) = build_pointer_type (atype);
4071             }
4072         }
4073
4074       CLASSTYPE_VFIELD (t) = vfield;
4075       if (TREE_TYPE (TYPE_BINFO_VTABLE (t)) != atype)
4076         {
4077           TREE_TYPE (TYPE_BINFO_VTABLE (t)) = atype;
4078           DECL_SIZE (TYPE_BINFO_VTABLE (t)) = 0;
4079           layout_decl (TYPE_BINFO_VTABLE (t), 0);
4080           /* At one time the vtable info was grabbed 2 words at a time.  This
4081              fails on sparc unless you have 8-byte alignment.  (tiemann) */
4082           DECL_ALIGN (TYPE_BINFO_VTABLE (t))
4083             = MAX (TYPE_ALIGN (double_type_node),
4084                    DECL_ALIGN (TYPE_BINFO_VTABLE (t)));
4085         }
4086     }
4087   else if (first_vfn_base_index >= 0)
4088     CLASSTYPE_VFIELD (t) = vfield;
4089   CLASSTYPE_VFIELDS (t) = vfields;
4090
4091   finish_struct_bits (t, max_has_virtual);
4092
4093   /* Complete the rtl for any static member objects of the type we're
4094      working on.  */
4095   for (x = fields; x; x = TREE_CHAIN (x))
4096     {
4097       if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
4098           && TREE_TYPE (x) == t)
4099         {
4100           DECL_MODE (x) = TYPE_MODE (t);
4101           make_decl_rtl (x, NULL, 0);
4102         }
4103     }
4104
4105   if (TYPE_HAS_CONSTRUCTOR (t))
4106     {
4107       tree vfields = CLASSTYPE_VFIELDS (t);
4108
4109       while (vfields)
4110         {
4111           /* Mark the fact that constructor for T
4112              could affect anybody inheriting from T
4113              who wants to initialize vtables for VFIELDS's type.  */
4114           if (VF_DERIVED_VALUE (vfields))
4115             TREE_ADDRESSABLE (vfields) = 1;
4116           vfields = TREE_CHAIN (vfields);
4117         }
4118       if (any_default_members != 0)
4119         build_class_init_list (t);
4120     }
4121   else if (TYPE_NEEDS_CONSTRUCTING (t))
4122     build_class_init_list (t);
4123
4124   /* Write out inline function definitions.  */
4125   do_inline_function_hair (t, CLASSTYPE_INLINE_FRIENDS (t));
4126   CLASSTYPE_INLINE_FRIENDS (t) = 0;
4127
4128   if (CLASSTYPE_VSIZE (t) != 0)
4129     {
4130 #if 0
4131       /* This is now done above.  */
4132       if (DECL_FIELD_CONTEXT (vfield) != t)
4133         {
4134           tree binfo = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
4135           tree offset = BINFO_OFFSET (binfo);
4136
4137           vfield = copy_node (vfield);
4138           copy_lang_decl (vfield);
4139
4140           if (! integer_zerop (offset))
4141             offset = size_binop (MULT_EXPR, offset, size_int (BITS_PER_UNIT));
4142           DECL_FIELD_CONTEXT (vfield) = t;
4143           DECL_CLASS_CONTEXT (vfield) = t;
4144           DECL_FIELD_BITPOS (vfield)
4145             = size_binop (PLUS_EXPR, offset, DECL_FIELD_BITPOS (vfield));
4146           CLASSTYPE_VFIELD (t) = vfield;
4147         }
4148 #endif
4149
4150       /* In addition to this one, all the other vfields should be listed.  */
4151       /* Before that can be done, we have to have FIELD_DECLs for them, and
4152          a place to find them.  */
4153       TYPE_NONCOPIED_PARTS (t) = build_tree_list (default_conversion (TYPE_BINFO_VTABLE (t)), vfield);
4154
4155       if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (t)
4156           && DECL_VINDEX (TREE_VEC_ELT (method_vec, 1)) == NULL_TREE)
4157         cp_warning ("`%#T' has virtual functions but non-virtual destructor",
4158                     t);
4159     }
4160
4161   /* Make the rtl for any new vtables we have created, and unmark
4162      the base types we marked.  */
4163   finish_vtbls (TYPE_BINFO (t), 1, t);
4164   hack_incomplete_structures (t);
4165
4166 #if 0
4167   if (TYPE_NAME (t) && TYPE_IDENTIFIER (t))
4168     undo_template_name_overload (TYPE_IDENTIFIER (t), 1);
4169 #endif
4170
4171   resume_momentary (old);
4172
4173   if (warn_overloaded_virtual)
4174     warn_hidden (t);
4175
4176 #if 0
4177   /* This has to be done after we have sorted out what to do with
4178      the enclosing type.  */
4179   if (write_symbols != DWARF_DEBUG)
4180     {
4181       /* Be smarter about nested classes here.  If a type is nested,
4182          only output it if we would output the enclosing type.  */
4183       if (DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (t)))
4184         DECL_IGNORED_P (TYPE_MAIN_DECL (t)) = TREE_ASM_WRITTEN (TYPE_MAIN_DECL (t));
4185     }
4186 #endif
4187
4188   if (write_symbols != DWARF_DEBUG && write_symbols != DWARF2_DEBUG)
4189     {
4190       /* If the type has methods, we want to think about cutting down
4191          the amount of symbol table stuff we output.  The value stored in
4192          the TYPE_DECL's DECL_IGNORED_P slot is a first approximation.
4193          For example, if a member function is seen and we decide to
4194          write out that member function, then we can change the value
4195          of the DECL_IGNORED_P slot, and the type will be output when
4196          that member function's debug info is written out.
4197
4198          We can't do this with DWARF, which does not support name
4199          references between translation units.  */
4200       if (CLASSTYPE_METHOD_VEC (t))
4201         {
4202           extern tree pending_vtables;
4203
4204           /* Don't output full info about any type
4205              which does not have its implementation defined here.  */
4206           if (TYPE_VIRTUAL_P (t) && write_virtuals == 2)
4207             TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t))
4208               = (value_member (TYPE_IDENTIFIER (t), pending_vtables) == 0);
4209           else if (CLASSTYPE_INTERFACE_ONLY (t))
4210             TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
4211 #if 0
4212           /* XXX do something about this.  */
4213           else if (CLASSTYPE_INTERFACE_UNKNOWN (t))
4214             /* Only a first approximation!  */
4215             TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
4216 #endif
4217         }
4218       else if (CLASSTYPE_INTERFACE_ONLY (t))
4219         TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t)) = 1;
4220     }
4221
4222   /* Finish debugging output for this type.  */
4223   rest_of_type_compilation (t, toplevel_bindings_p ());
4224
4225   return t;
4226 }
4227
4228 tree
4229 finish_struct (t, list_of_fieldlists, attributes, warn_anon)
4230      tree t, list_of_fieldlists, attributes;
4231      int warn_anon;
4232 {
4233   tree fields = NULL_TREE;
4234   tree *tail = &TYPE_METHODS (t);
4235   tree specializations = NULL_TREE;
4236   tree *specialization_tail = &specializations;
4237   tree name = TYPE_NAME (t);
4238   tree x, last_x = NULL_TREE;
4239   tree access;
4240   tree dummy = NULL_TREE;
4241   tree next_x = NULL_TREE;
4242
4243   if (TREE_CODE (name) == TYPE_DECL)
4244     {
4245       extern int lineno;
4246
4247       DECL_SOURCE_FILE (name) = input_filename;
4248       /* For TYPE_DECL that are not typedefs (those marked with a line
4249          number of zero, we don't want to mark them as real typedefs.
4250          If this fails one needs to make sure real typedefs have a
4251          previous line number, even if it is wrong, that way the below
4252          will fill in the right line number.  (mrs) */
4253       if (DECL_SOURCE_LINE (name))
4254         DECL_SOURCE_LINE (name) = lineno;
4255       CLASSTYPE_SOURCE_LINE (t) = lineno;
4256       name = DECL_NAME (name);
4257     }
4258
4259   /* Append the fields we need for constructing signature tables.  */
4260   if (IS_SIGNATURE (t))
4261     append_signature_fields (list_of_fieldlists);
4262
4263   /* Move our self-reference declaration to the end of the field list so
4264      any real field with the same name takes precedence.  */
4265   if (list_of_fieldlists
4266       && TREE_VALUE (list_of_fieldlists)
4267       && DECL_ARTIFICIAL (TREE_VALUE (list_of_fieldlists)))
4268     {
4269       dummy = TREE_VALUE (list_of_fieldlists);
4270       list_of_fieldlists = TREE_CHAIN (list_of_fieldlists);
4271     }
4272
4273   if (last_x && list_of_fieldlists)
4274     TREE_CHAIN (last_x) = TREE_VALUE (list_of_fieldlists);
4275
4276   while (list_of_fieldlists)
4277     {
4278       access = TREE_PURPOSE (list_of_fieldlists);
4279
4280       /* For signatures, we made all methods `public' in the parser and
4281          reported an error if a access specifier was used.  */
4282       if (access == access_default_node)
4283         {
4284           if (CLASSTYPE_DECLARED_CLASS (t) == 0)
4285             access = access_public_node;
4286           else
4287             access = access_private_node;
4288         }
4289
4290       for (x = TREE_VALUE (list_of_fieldlists); x; x = next_x)
4291         {
4292           next_x = TREE_CHAIN (x);
4293
4294           TREE_PRIVATE (x) = access == access_private_node;
4295           TREE_PROTECTED (x) = access == access_protected_node;
4296
4297           if (TREE_CODE (x) == TEMPLATE_DECL)
4298             {
4299               TREE_PRIVATE (DECL_RESULT (x)) = TREE_PRIVATE (x);
4300               TREE_PROTECTED (DECL_RESULT (x)) = TREE_PROTECTED (x);
4301             }
4302
4303           /* Check for inconsistent use of this name in the class body.
4304              Enums, types and static vars have already been checked.  */
4305           if (TREE_CODE (x) != TYPE_DECL && TREE_CODE (x) != USING_DECL
4306               && ! (TREE_CODE (x) == TEMPLATE_DECL
4307                     && TREE_CODE (DECL_RESULT (x)) == TYPE_DECL)
4308               && TREE_CODE (x) != CONST_DECL && TREE_CODE (x) != VAR_DECL)
4309             {
4310               tree name = DECL_NAME (x);
4311               tree icv;
4312
4313               /* Don't get confused by access decls.  */
4314               if (name && TREE_CODE (name) == IDENTIFIER_NODE)
4315                 icv = IDENTIFIER_CLASS_VALUE (name);
4316               else
4317                 icv = NULL_TREE;
4318
4319               if (icv
4320                   /* Don't complain about constructors.  */
4321                   && name != constructor_name (current_class_type)
4322                   /* Or inherited names.  */
4323                   && id_in_current_class (name)
4324                   /* Or shadowed tags.  */
4325                   && !(TREE_CODE (icv) == TYPE_DECL
4326                        && DECL_CONTEXT (icv) == t))
4327                 {
4328                   cp_error_at ("declaration of identifier `%D' as `%+#D'",
4329                                name, x);
4330                   cp_error_at ("conflicts with other use in class as `%#D'",
4331                                icv);
4332                 }
4333             }
4334
4335           if (TREE_CODE (x) == FUNCTION_DECL
4336               || DECL_FUNCTION_TEMPLATE_P (x))
4337             {
4338               DECL_CLASS_CONTEXT (x) = t;
4339
4340               if (last_x)
4341                 TREE_CHAIN (last_x) = next_x;
4342
4343               if (DECL_TEMPLATE_SPECIALIZATION (x))
4344                 /* We don't enter the specialization into the class
4345                    method vector since specializations don't affect
4346                    overloading.  Instead we keep track of the
4347                    specializations, and process them after the method
4348                    vector is complete.  */
4349                 {
4350                   *specialization_tail = x;
4351                   specialization_tail = &TREE_CHAIN (x);
4352                   TREE_CHAIN (x) = NULL_TREE;
4353                   continue;
4354                 }
4355
4356               /* Link x onto end of TYPE_METHODS.  */
4357               *tail = x;
4358               tail = &TREE_CHAIN (x);
4359               continue;
4360             }
4361
4362           if (TREE_CODE (x) != TYPE_DECL)
4363             DECL_FIELD_CONTEXT (x) = t;
4364
4365           if (! fields)
4366             fields = x;
4367           last_x = x;
4368         }
4369       list_of_fieldlists = TREE_CHAIN (list_of_fieldlists);
4370       /* link the tail while we have it! */
4371       if (last_x)
4372         {
4373           TREE_CHAIN (last_x) = NULL_TREE;
4374
4375           if (list_of_fieldlists
4376               && TREE_VALUE (list_of_fieldlists)
4377               && TREE_CODE (TREE_VALUE (list_of_fieldlists)) != FUNCTION_DECL)
4378             TREE_CHAIN (last_x) = TREE_VALUE (list_of_fieldlists);
4379         }
4380     }
4381
4382   /* Now add the tags, if any, to the list of TYPE_DECLs
4383      defined for this type.  */
4384   if (CLASSTYPE_TAGS (t) || dummy)
4385     {
4386       /* The list of tags was built up in pushtag in reverse order; we need
4387          to fix that so that enumerators will be processed in forward order
4388          in template instantiation.  */
4389       CLASSTYPE_TAGS (t) = x = nreverse (CLASSTYPE_TAGS (t));
4390       while (x)
4391         {
4392           tree tag_type = TREE_VALUE (x);
4393           tree tag = TYPE_MAIN_DECL (TREE_VALUE (x));
4394
4395           if (IS_AGGR_TYPE_CODE (TREE_CODE (tag_type))
4396               && CLASSTYPE_IS_TEMPLATE (tag_type))
4397             tag = CLASSTYPE_TI_TEMPLATE (tag_type);
4398
4399           TREE_NONLOCAL_FLAG (tag_type) = 0;
4400           x = TREE_CHAIN (x);
4401           last_x = chainon (last_x, tag);
4402         }
4403       if (dummy)
4404         last_x = chainon (last_x, dummy);
4405       if (fields == NULL_TREE)
4406         fields = last_x;
4407       CLASSTYPE_LOCAL_TYPEDECLS (t) = 1;
4408     }
4409
4410   *tail = NULL_TREE;
4411   TYPE_FIELDS (t) = fields;
4412
4413   cplus_decl_attributes (t, attributes, NULL_TREE);
4414
4415   if (processing_template_decl)
4416     {
4417       tree d = getdecls ();
4418       for (; d; d = TREE_CHAIN (d))
4419         {
4420           /* If this is the decl for the class or one of the template
4421              parms, we've seen all the injected decls.  */
4422           if ((TREE_CODE (d) == TYPE_DECL
4423                && (TREE_TYPE (d) == t
4424                    || TREE_CODE (TREE_TYPE (d)) == TEMPLATE_TYPE_PARM
4425                    || TREE_CODE (TREE_TYPE (d)) == TEMPLATE_TEMPLATE_PARM))
4426               || TREE_CODE (d) == CONST_DECL)
4427             break;
4428           /* Don't inject cache decls.  */
4429           else if (IDENTIFIER_TEMPLATE (DECL_NAME (d)))
4430             continue;
4431           DECL_TEMPLATE_INJECT (CLASSTYPE_TI_TEMPLATE (t))
4432             = tree_cons (NULL_TREE, d,
4433                          DECL_TEMPLATE_INJECT (CLASSTYPE_TI_TEMPLATE (t)));
4434         }
4435       CLASSTYPE_METHOD_VEC (t)
4436         = finish_struct_methods (t, TYPE_METHODS (t), 1);
4437       TYPE_SIZE (t) = integer_zero_node;
4438     }
4439   else
4440     t = finish_struct_1 (t, warn_anon);
4441
4442   TYPE_BEING_DEFINED (t) = 0;
4443
4444   /* Now, figure out which member templates we're specializing.  */
4445   for (x = specializations; x != NULL_TREE; x = TREE_CHAIN (x))
4446     {
4447       tree spec_args;
4448       tree fn;
4449       int pending_specialization;
4450
4451       if (uses_template_parms (t))
4452         /* If t is a template class, and x is a specialization, then x
4453            is itself really a template.  Due to the vagaries of the
4454            parser, however, we will have a handle to a function
4455            declaration, rather than the template declaration, at this
4456            point.  */
4457         {
4458           my_friendly_assert (DECL_TEMPLATE_INFO (x) != NULL_TREE, 0);
4459           my_friendly_assert (DECL_TI_TEMPLATE (x) != NULL_TREE, 0);
4460           fn = DECL_TI_TEMPLATE (x);
4461         }
4462       else
4463         fn = x;
4464
4465       /* We want the specialization arguments, which will be the
4466          innermost ones.  */
4467       if (DECL_TI_ARGS (fn) && TREE_CODE (DECL_TI_ARGS (fn)) == TREE_VEC)
4468         spec_args
4469           = TREE_VEC_ELT (DECL_TI_ARGS (fn), 0);
4470       else
4471         spec_args = DECL_TI_ARGS (fn);
4472
4473       pending_specialization
4474         = TI_PENDING_SPECIALIZATION_FLAG (DECL_TEMPLATE_INFO (fn));
4475       check_explicit_specialization
4476         (lookup_template_function (DECL_NAME (fn), spec_args),
4477          fn, 0, 1 | (8 * pending_specialization));
4478       TI_PENDING_SPECIALIZATION_FLAG (DECL_TEMPLATE_INFO (fn)) = 0;
4479
4480       /* Now, the assembler name will be correct for fn, so we
4481          make its RTL.  */
4482       DECL_RTL (fn) = 0;
4483       make_decl_rtl (fn, NULL_PTR, 1);
4484
4485       if (x != fn)
4486         {
4487           DECL_RTL (x) = 0;
4488           make_decl_rtl (x, NULL_PTR, 1);
4489         }
4490     }
4491
4492   if (current_class_type)
4493     popclass (0);
4494   else
4495     error ("trying to finish struct, but kicked out due to previous parse errors.");
4496
4497   return t;
4498 }
4499 \f
4500 /* Return non-zero if the effective type of INSTANCE is static.
4501    Used to determine whether the virtual function table is needed
4502    or not.
4503
4504    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
4505    of our knowledge of its type.  */
4506
4507 int
4508 resolves_to_fixed_type_p (instance, nonnull)
4509      tree instance;
4510      int *nonnull;
4511 {
4512   switch (TREE_CODE (instance))
4513     {
4514     case INDIRECT_REF:
4515       /* Check that we are not going through a cast of some sort.  */
4516       if (TREE_TYPE (instance)
4517           == TREE_TYPE (TREE_TYPE (TREE_OPERAND (instance, 0))))
4518         instance = TREE_OPERAND (instance, 0);
4519       /* fall through...  */
4520     case CALL_EXPR:
4521       /* This is a call to a constructor, hence it's never zero.  */
4522       if (TREE_HAS_CONSTRUCTOR (instance))
4523         {
4524           if (nonnull)
4525             *nonnull = 1;
4526           return 1;
4527         }
4528       return 0;
4529
4530     case SAVE_EXPR:
4531       /* This is a call to a constructor, hence it's never zero.  */
4532       if (TREE_HAS_CONSTRUCTOR (instance))
4533         {
4534           if (nonnull)
4535             *nonnull = 1;
4536           return 1;
4537         }
4538       return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
4539
4540     case RTL_EXPR:
4541       return 0;
4542
4543     case PLUS_EXPR:
4544     case MINUS_EXPR:
4545       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
4546         /* Propagate nonnull.  */
4547         resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
4548       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
4549         return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
4550       return 0;
4551
4552     case NOP_EXPR:
4553     case CONVERT_EXPR:
4554       return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
4555
4556     case ADDR_EXPR:
4557       if (nonnull)
4558         *nonnull = 1;
4559       return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
4560
4561     case COMPONENT_REF:
4562       return resolves_to_fixed_type_p (TREE_OPERAND (instance, 1), nonnull);
4563
4564     case VAR_DECL:
4565     case FIELD_DECL:
4566       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
4567           && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
4568         {
4569           if (nonnull)
4570             *nonnull = 1;
4571           return 1;
4572         }
4573       /* fall through...  */
4574     case TARGET_EXPR:
4575     case PARM_DECL:
4576       if (IS_AGGR_TYPE (TREE_TYPE (instance)))
4577         {
4578           if (nonnull)
4579             *nonnull = 1;
4580           return 1;
4581         }
4582       else if (nonnull)
4583         {
4584           if (instance == current_class_ptr
4585               && flag_this_is_variable <= 0)
4586             {
4587               /* Some people still use `this = 0' inside destructors.  */
4588               *nonnull = ! DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (current_function_decl));
4589               /* In a constructor, we know our type.  */
4590               if (flag_this_is_variable < 0)
4591                 return 1;
4592             }
4593           else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
4594             /* Reference variables should be references to objects.  */
4595             *nonnull = 1;
4596         }
4597       return 0;
4598
4599     default:
4600       return 0;
4601     }
4602 }
4603 \f
4604 void
4605 init_class_processing ()
4606 {
4607   current_class_depth = 0;
4608   current_class_stacksize = 10;
4609   current_class_base = (tree *)xmalloc(current_class_stacksize * sizeof (tree));
4610   current_class_stack = current_class_base;
4611
4612   current_lang_stacksize = 10;
4613   current_lang_base = (tree *)xmalloc(current_lang_stacksize * sizeof (tree));
4614   current_lang_stack = current_lang_base;
4615
4616   access_default_node = build_int_2 (0, 0);
4617   access_public_node = build_int_2 (1, 0);
4618   access_protected_node = build_int_2 (2, 0);
4619   access_private_node = build_int_2 (3, 0);
4620   access_default_virtual_node = build_int_2 (4, 0);
4621   access_public_virtual_node = build_int_2 (5, 0);
4622   access_protected_virtual_node = build_int_2 (6, 0);
4623   access_private_virtual_node = build_int_2 (7, 0);
4624
4625   /* Keep these values lying around.  */
4626   base_layout_decl = build_lang_field_decl (FIELD_DECL, NULL_TREE, error_mark_node);
4627   TREE_TYPE (base_layout_decl) = make_node (RECORD_TYPE);
4628
4629   gcc_obstack_init (&class_obstack);
4630 }
4631
4632 /* Set current scope to NAME. CODE tells us if this is a
4633    STRUCT, UNION, or ENUM environment.
4634
4635    NAME may end up being NULL_TREE if this is an anonymous or
4636    late-bound struct (as in "struct { ... } foo;")  */
4637
4638 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE to
4639    appropriate values, found by looking up the type definition of
4640    NAME (as a CODE).
4641
4642    If MODIFY is 1, we set IDENTIFIER_CLASS_VALUE's of names
4643    which can be seen locally to the class.  They are shadowed by
4644    any subsequent local declaration (including parameter names).
4645
4646    If MODIFY is 2, we set IDENTIFIER_CLASS_VALUE's of names
4647    which have static meaning (i.e., static members, static
4648    member functions, enum declarations, etc).
4649
4650    If MODIFY is 3, we set IDENTIFIER_CLASS_VALUE of names
4651    which can be seen locally to the class (as in 1), but
4652    know that we are doing this for declaration purposes
4653    (i.e. friend foo::bar (int)).
4654
4655    So that we may avoid calls to lookup_name, we cache the _TYPE
4656    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
4657
4658    For multiple inheritance, we perform a two-pass depth-first search
4659    of the type lattice.  The first pass performs a pre-order search,
4660    marking types after the type has had its fields installed in
4661    the appropriate IDENTIFIER_CLASS_VALUE slot.  The second pass merely
4662    unmarks the marked types.  If a field or member function name
4663    appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
4664    that name becomes `error_mark_node'.  */
4665
4666 void
4667 pushclass (type, modify)
4668      tree type;
4669      int modify;
4670 {
4671   type = TYPE_MAIN_VARIANT (type);
4672   push_memoized_context (type, modify);
4673
4674   current_class_depth++;
4675   *current_class_stack++ = current_class_name;
4676   *current_class_stack++ = current_class_type;
4677   if (current_class_stack >= current_class_base + current_class_stacksize)
4678     {
4679       current_class_base
4680         = (tree *)xrealloc (current_class_base,
4681                             sizeof (tree) * (current_class_stacksize + 10));
4682       current_class_stack = current_class_base + current_class_stacksize;
4683       current_class_stacksize += 10;
4684     }
4685
4686   current_class_name = TYPE_NAME (type);
4687   if (TREE_CODE (current_class_name) == TYPE_DECL)
4688     current_class_name = DECL_NAME (current_class_name);
4689   current_class_type = type;
4690
4691   if (previous_class_type != NULL_TREE
4692       && (type != previous_class_type || TYPE_SIZE (previous_class_type) == NULL_TREE)
4693       && current_class_depth == 1)
4694     {
4695       /* Forcibly remove any old class remnants.  */
4696       popclass (-1);
4697       previous_class_type = NULL_TREE;
4698     }
4699
4700   pushlevel_class ();
4701
4702 #if 0
4703   if (CLASSTYPE_TEMPLATE_INFO (type))
4704     overload_template_name (type);
4705 #endif
4706
4707   if (modify)
4708     {
4709       tree tags;
4710       tree this_fndecl = current_function_decl;
4711
4712       if (current_function_decl
4713           && DECL_CONTEXT (current_function_decl)
4714           && TREE_CODE (DECL_CONTEXT (current_function_decl)) == FUNCTION_DECL)
4715         current_function_decl = DECL_CONTEXT (current_function_decl);
4716       else
4717         current_function_decl = NULL_TREE;
4718
4719       if (type != previous_class_type || current_class_depth > 1)
4720         {
4721 #ifdef MI_MATRIX
4722           build_mi_matrix (type);
4723           push_class_decls (type);
4724           free_mi_matrix ();
4725 #else
4726           push_class_decls (type);
4727 #endif
4728         }
4729       else
4730         {
4731           tree item;
4732
4733           /* Hooray, we successfully cached; let's just install the
4734              cached class_shadowed list, and walk through it to get the
4735              IDENTIFIER_TYPE_VALUEs correct.  */
4736           set_class_shadows (previous_class_values);
4737           for (item = previous_class_values; item; item = TREE_CHAIN (item))
4738             {
4739               tree id = TREE_PURPOSE (item);
4740               tree decl = IDENTIFIER_CLASS_VALUE (id);
4741
4742               if (TREE_CODE (decl) == TYPE_DECL)
4743                 set_identifier_type_value (id, TREE_TYPE (decl));
4744             }
4745           unuse_fields (type);
4746         }
4747
4748       for (tags = CLASSTYPE_TAGS (type); tags; tags = TREE_CHAIN (tags))
4749         {
4750           tree tag_type = TREE_VALUE (tags);
4751
4752           TREE_NONLOCAL_FLAG (tag_type) = 1;
4753           if (! TREE_PURPOSE (tags))
4754             continue;
4755           if (! (IS_AGGR_TYPE_CODE (TREE_CODE (tag_type))
4756                  && CLASSTYPE_IS_TEMPLATE (tag_type)))
4757             pushtag (TREE_PURPOSE (tags), tag_type, 0);
4758           else
4759             pushdecl_class_level (CLASSTYPE_TI_TEMPLATE (tag_type));
4760         }
4761
4762       current_function_decl = this_fndecl;
4763     }
4764 }
4765
4766 /* Get out of the current class scope. If we were in a class scope
4767    previously, that is the one popped to.  The flag MODIFY tells whether
4768    the current scope declarations needs to be modified as a result of
4769    popping to the previous scope.  0 is used for class definitions.  */
4770
4771 void
4772 popclass (modify)
4773      int modify;
4774 {
4775   if (modify < 0)
4776     {
4777       /* Back this old class out completely.  */
4778       tree tags = CLASSTYPE_TAGS (previous_class_type);
4779       tree t;
4780
4781       /* This code can be seen as a cache miss.  When we've cached a
4782          class' scope's bindings and we can't use them, we need to reset
4783          them.  This is it!  */
4784       for (t = previous_class_values; t; t = TREE_CHAIN (t))
4785         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
4786       while (tags)
4787         {
4788           TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 0;
4789           tags = TREE_CHAIN (tags);
4790         }
4791       goto ret;
4792     }
4793
4794   if (modify)
4795     {
4796       /* Just remove from this class what didn't make
4797          it into IDENTIFIER_CLASS_VALUE.  */
4798       tree tags = CLASSTYPE_TAGS (current_class_type);
4799
4800       while (tags)
4801         {
4802           TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 0;
4803           tags = TREE_CHAIN (tags);
4804         }
4805     }
4806
4807   /* Force clearing of IDENTIFIER_CLASS_VALUEs after a class definition,
4808      since not all class decls make it there currently.  */
4809   poplevel_class (! modify);
4810
4811   /* Since poplevel_class does the popping of class decls nowadays,
4812      this really only frees the obstack used for these decls.
4813      That's why it had to be moved down here.  */
4814   if (modify)
4815     pop_class_decls ();
4816
4817   current_class_depth--;
4818   current_class_type = *--current_class_stack;
4819   current_class_name = *--current_class_stack;
4820
4821   pop_memoized_context (modify);
4822
4823  ret:
4824   ;
4825 }
4826
4827 /* Returns 1 if current_class_type is either T or a nested type of T.  */
4828
4829 int
4830 currently_open_class (t)
4831      tree t;
4832 {
4833   int i;
4834   if (t == current_class_type)
4835     return 1;
4836   for (i = 0; i < current_class_depth; ++i)
4837     if (current_class_stack [-i*2 - 1] == t)
4838       return 1;
4839   return 0;
4840 }
4841
4842 /* When entering a class scope, all enclosing class scopes' names with
4843    static meaning (static variables, static functions, types and enumerators)
4844    have to be visible.  This recursive function calls pushclass for all
4845    enclosing class contexts until global or a local scope is reached.
4846    TYPE is the enclosed class and MODIFY is equivalent with the pushclass
4847    formal of the same name.  */
4848
4849 void
4850 push_nested_class (type, modify)
4851      tree type;
4852      int modify;
4853 {
4854   tree context;
4855
4856   if (type == NULL_TREE || type == error_mark_node || ! IS_AGGR_TYPE (type)
4857       || TREE_CODE (type) == TEMPLATE_TYPE_PARM
4858       || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
4859     return;
4860
4861   context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
4862
4863   if (context && TREE_CODE (context) == RECORD_TYPE)
4864     push_nested_class (context, 2);
4865   pushclass (type, modify);
4866 }
4867
4868 /* Undoes a push_nested_class call.  MODIFY is passed on to popclass.  */
4869
4870 void
4871 pop_nested_class (modify)
4872      int modify;
4873 {
4874   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
4875
4876   popclass (modify);
4877   if (context && TREE_CODE (context) == RECORD_TYPE)
4878     pop_nested_class (modify);
4879 }
4880
4881 /* Set global variables CURRENT_LANG_NAME to appropriate value
4882    so that behavior of name-mangling machinery is correct.  */
4883
4884 void
4885 push_lang_context (name)
4886      tree name;
4887 {
4888   *current_lang_stack++ = current_lang_name;
4889   if (current_lang_stack >= current_lang_base + current_lang_stacksize)
4890     {
4891       current_lang_base
4892         = (tree *)xrealloc (current_lang_base,
4893                             sizeof (tree) * (current_lang_stacksize + 10));
4894       current_lang_stack = current_lang_base + current_lang_stacksize;
4895       current_lang_stacksize += 10;
4896     }
4897
4898   if (name == lang_name_cplusplus || name == lang_name_java)
4899     {
4900       strict_prototype = strict_prototypes_lang_cplusplus;
4901       current_lang_name = name;
4902     }
4903   else if (name == lang_name_c)
4904     {
4905       strict_prototype = strict_prototypes_lang_c;
4906       current_lang_name = name;
4907     }
4908   else
4909     error ("language string `\"%s\"' not recognized", IDENTIFIER_POINTER (name));
4910 }
4911
4912 /* Get out of the current language scope.  */
4913
4914 void
4915 pop_lang_context ()
4916 {
4917   current_lang_name = *--current_lang_stack;
4918   if (current_lang_name == lang_name_cplusplus
4919       || current_lang_name == lang_name_java)
4920     strict_prototype = strict_prototypes_lang_cplusplus;
4921   else if (current_lang_name == lang_name_c)
4922     strict_prototype = strict_prototypes_lang_c;
4923 }
4924 \f
4925 /* Type instantiation routines.  */
4926
4927 static tree
4928 validate_lhs (lhstype, complain)
4929      tree lhstype;
4930      int complain;
4931 {
4932   if (TYPE_PTRMEMFUNC_P (lhstype))
4933     lhstype = TYPE_PTRMEMFUNC_FN_TYPE (lhstype);
4934
4935   if (TREE_CODE (lhstype) == POINTER_TYPE)
4936     {
4937       if (TREE_CODE (TREE_TYPE (lhstype)) == FUNCTION_TYPE
4938           || TREE_CODE (TREE_TYPE (lhstype)) == METHOD_TYPE)
4939         lhstype = TREE_TYPE (lhstype);
4940       else
4941         {
4942           if (complain)
4943             error ("invalid type combination for overload");
4944           return error_mark_node;
4945         }
4946     }
4947   return lhstype;
4948 }
4949
4950 /* This function will instantiate the type of the expression given in
4951    RHS to match the type of LHSTYPE.  If errors exist, then return
4952    error_mark_node.  If only complain is COMPLAIN is set.  If we are
4953    not complaining, never modify rhs, as overload resolution wants to
4954    try many possible instantiations, in hopes that at least one will
4955    work.
4956
4957    This function is used in build_modify_expr, convert_arguments,
4958    build_c_cast, and compute_conversion_costs.  */
4959
4960 tree
4961 instantiate_type (lhstype, rhs, complain)
4962      tree lhstype, rhs;
4963      int complain;
4964 {
4965   tree explicit_targs = NULL_TREE;
4966   int template_only = 0;
4967
4968   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
4969     {
4970       if (complain)
4971         error ("not enough type information");
4972       return error_mark_node;
4973     }
4974
4975   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
4976     {
4977       if (comptypes (lhstype, TREE_TYPE (rhs), 1))
4978         return rhs;
4979       if (complain)
4980         cp_error ("argument of type `%T' does not match `%T'",
4981                   TREE_TYPE (rhs), lhstype);
4982       return error_mark_node;
4983     }
4984
4985   /* We don't overwrite rhs if it is an overloaded function.
4986      Copying it would destroy the tree link.  */
4987   if (TREE_CODE (rhs) != OVERLOAD)
4988     rhs = copy_node (rhs);
4989
4990   /* This should really only be used when attempting to distinguish
4991      what sort of a pointer to function we have.  For now, any
4992      arithmetic operation which is not supported on pointers
4993      is rejected as an error.  */
4994
4995   switch (TREE_CODE (rhs))
4996     {
4997     case TYPE_EXPR:
4998     case CONVERT_EXPR:
4999     case SAVE_EXPR:
5000     case CONSTRUCTOR:
5001     case BUFFER_REF:
5002       my_friendly_abort (177);
5003       return error_mark_node;
5004
5005     case INDIRECT_REF:
5006     case ARRAY_REF:
5007       {
5008         tree new_rhs;
5009
5010         new_rhs = instantiate_type (build_pointer_type (lhstype),
5011                                     TREE_OPERAND (rhs, 0), complain);
5012         if (new_rhs == error_mark_node)
5013           return error_mark_node;
5014
5015         TREE_TYPE (rhs) = lhstype;
5016         TREE_OPERAND (rhs, 0) = new_rhs;
5017         return rhs;
5018       }
5019
5020     case NOP_EXPR:
5021       rhs = copy_node (TREE_OPERAND (rhs, 0));
5022       TREE_TYPE (rhs) = unknown_type_node;
5023       return instantiate_type (lhstype, rhs, complain);
5024
5025     case COMPONENT_REF:
5026       {
5027         tree field = TREE_OPERAND (rhs, 1);
5028         if (TREE_CODE (field) == TREE_LIST)
5029           {
5030             tree function = instantiate_type (lhstype, field, complain);
5031             if (function == error_mark_node)
5032               return error_mark_node;
5033             my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 185);
5034             if (DECL_VINDEX (function))
5035               {
5036                 tree base = TREE_OPERAND (rhs, 0);
5037                 tree base_ptr = build_unary_op (ADDR_EXPR, base, 0);
5038                 if (base_ptr == error_mark_node)
5039                   return error_mark_node;
5040                 base_ptr = convert_pointer_to (DECL_CONTEXT (function), base_ptr);
5041                 if (base_ptr == error_mark_node)
5042                   return error_mark_node;
5043                 return build_vfn_ref (&base_ptr, base, DECL_VINDEX (function));
5044               }
5045             mark_used (function);
5046             return function;
5047           }
5048
5049         /* I could not trigger this code. MvL */
5050         my_friendly_abort (980326);
5051 #if 0
5052         my_friendly_assert (TREE_CODE (field) == FIELD_DECL, 178);
5053         my_friendly_assert (!(TREE_CODE (TREE_TYPE (field)) == FUNCTION_TYPE
5054                               || TREE_CODE (TREE_TYPE (field)) == METHOD_TYPE),
5055                             179);
5056
5057         TREE_TYPE (rhs) = lhstype;
5058         /* First look for an exact match  */
5059
5060         while (field && TREE_TYPE (field) != lhstype)
5061           field = DECL_CHAIN (field);
5062         if (field)
5063           {
5064             TREE_OPERAND (rhs, 1) = field;
5065             mark_used (field);
5066             return rhs;
5067           }
5068
5069         /* No exact match found, look for a compatible function.  */
5070         field = TREE_OPERAND (rhs, 1);
5071         while (field && ! comptypes (lhstype, TREE_TYPE (field), 0))
5072           field = DECL_CHAIN (field);
5073         if (field)
5074           {
5075             TREE_OPERAND (rhs, 1) = field;
5076             field = DECL_CHAIN (field);
5077             while (field && ! comptypes (lhstype, TREE_TYPE (field), 0))
5078               field = DECL_CHAIN (field);
5079             if (field)
5080               {
5081                 if (complain)
5082                   error ("ambiguous overload for COMPONENT_REF requested");
5083                 return error_mark_node;
5084               }
5085           }
5086         else
5087           {
5088             if (complain)
5089               error ("no appropriate overload exists for COMPONENT_REF");
5090             return error_mark_node;
5091           }
5092 #endif
5093         return rhs;
5094       }
5095
5096     case OFFSET_REF:
5097       /* This can happen if we are forming a pointer-to-member for a
5098          member template.  */
5099       rhs = TREE_OPERAND (rhs, 1);
5100       my_friendly_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR, 0);
5101
5102       /* Fall through.  */
5103
5104     case TEMPLATE_ID_EXPR:
5105       {
5106         explicit_targs = TREE_OPERAND (rhs, 1);
5107         template_only = 1;
5108         rhs = TREE_OPERAND (rhs, 0);
5109       }
5110       /* fall through */
5111       my_friendly_assert (TREE_CODE (rhs) == OVERLOAD, 980401);
5112
5113     case OVERLOAD:
5114       {
5115         tree elem, elems;
5116
5117         /* Check that the LHSTYPE and the RHS are reasonable.  */
5118         lhstype = validate_lhs (lhstype, complain);
5119         if (lhstype == error_mark_node)
5120           return lhstype;
5121
5122         if (TREE_CODE (lhstype) != FUNCTION_TYPE
5123             && TREE_CODE (lhstype) != METHOD_TYPE)
5124           {
5125             if (complain)
5126               cp_error("cannot resolve overloaded function `%D' "
5127                        "based on non-function type",
5128                        DECL_NAME (OVL_FUNCTION (rhs)));
5129             return error_mark_node;
5130           }
5131
5132         /* Look for an exact match, by searching through the
5133            overloaded functions.  */
5134         if (template_only)
5135           /* If we're processing a template-id, only a template
5136              function can match, so we don't look through the
5137              overloaded functions.  */
5138           ;
5139         else for (elems = rhs; elems; elems = OVL_CHAIN (elems))
5140           {
5141             elem = OVL_FUNCTION (elems);
5142             if (comptypes (lhstype, TREE_TYPE (elem), 1))
5143               {
5144                 mark_used (elem);
5145                 return elem;
5146               }
5147           }
5148
5149         /* No overloaded function was an exact match.  See if we can
5150            instantiate some template to match.  */
5151         {
5152           tree save_elem = 0;
5153           elems = rhs;
5154           if (TREE_CODE (elems) == TREE_LIST)
5155             elems = TREE_VALUE (rhs);
5156           for (; elems; elems = OVL_NEXT (elems))
5157             if (TREE_CODE (elem = OVL_CURRENT (elems)) == TEMPLATE_DECL)
5158               {
5159                 int n = DECL_NTPARMS (elem);
5160                 tree t = make_scratch_vec (n);
5161                 int i;
5162                 i = type_unification
5163                   (DECL_INNERMOST_TEMPLATE_PARMS (elem), t,
5164                    TYPE_ARG_TYPES (TREE_TYPE (elem)),
5165                    TYPE_ARG_TYPES (lhstype), explicit_targs, DEDUCE_EXACT, 1);
5166                 if (i == 0)
5167                   {
5168                     if (save_elem)
5169                       {
5170                         cp_error ("ambiguous template instantiation converting to `%#T'", lhstype);
5171                         return error_mark_node;
5172                       }
5173                     save_elem = instantiate_template (elem, t);
5174                     /* Check the return type.  */
5175                     if (! comptypes (TREE_TYPE (lhstype),
5176                                      TREE_TYPE (TREE_TYPE (save_elem)), 1))
5177                       save_elem = 0;
5178                   }
5179               }
5180           if (save_elem)
5181             {
5182               mark_used (save_elem);
5183               return save_elem;
5184             }
5185         }
5186
5187         /* There's no exact match, and no templates can be
5188            instantiated to match.  The last thing we try is to see if
5189            some ordinary overloaded function is close enough.  If
5190            we're only looking for template functions, we don't do
5191            this.  */
5192         if (!template_only)
5193           {
5194             for (elems = rhs; elems; elems = OVL_NEXT (elems))
5195               {
5196                 elem = OVL_CURRENT (elems);
5197                 if (comp_target_types (lhstype, TREE_TYPE (elem), 1) > 0)
5198                   break;
5199               }
5200             if (elems)
5201               {
5202                 tree save_elem = elem;
5203                 for (elems = OVL_CHAIN (elems); elems;
5204                      elems = OVL_CHAIN (elems))
5205                   {
5206                     elem = OVL_FUNCTION (elems);
5207                     if (comp_target_types (lhstype, TREE_TYPE (elem), 0) > 0)
5208                       break;
5209                   }
5210                 if (elems)
5211                   {
5212                     if (complain)
5213                       {
5214                         cp_error
5215                           ("cannot resolve overload to target type `%#T'",
5216                            lhstype);
5217                         cp_error_at ("  ambiguity between `%#D'", save_elem);
5218                         cp_error_at ("  and `%#D', at least", elem);
5219                       }
5220                     return error_mark_node;
5221                   }
5222                 mark_used (save_elem);
5223                 return save_elem;
5224               }
5225           }
5226
5227         /* We failed to find a match.  */
5228         if (complain)
5229           {
5230             cp_error ("cannot resolve overload to target type `%#T'", lhstype);
5231             cp_error
5232               ("  because no suitable overload of function `%D' exists",
5233                DECL_NAME (OVL_FUNCTION (rhs)));
5234           }
5235         return error_mark_node;
5236       }
5237
5238     case TREE_LIST:
5239       {
5240         tree elem, baselink, name = NULL_TREE;
5241
5242         if (TREE_PURPOSE (rhs) == error_mark_node)
5243           {
5244             /* Make sure we don't drop the non-local flag, as the old code
5245                would rely on it. */
5246             int nl = TREE_NONLOCAL_FLAG (rhs);
5247             /* We don't need the type of this node. */
5248             rhs = TREE_VALUE (rhs);
5249             my_friendly_assert (TREE_NONLOCAL_FLAG (rhs) == nl, 980331);
5250           }
5251
5252         /* Now we should have a baselink. */
5253         my_friendly_assert (TREE_CODE (TREE_PURPOSE (rhs)) == TREE_VEC,
5254                             980331);
5255         /* First look for an exact match.  Search member functions.
5256            May have to undo what `default_conversion' might do to
5257            lhstype.  */
5258
5259         lhstype = validate_lhs (lhstype, complain);
5260         if (lhstype == error_mark_node)
5261           return lhstype;
5262
5263         my_friendly_assert (TREE_CHAIN (rhs) == NULL_TREE, 181);
5264         my_friendly_assert (TREE_CODE (TREE_VALUE (rhs)) == FUNCTION_DECL
5265                             || TREE_CODE (TREE_VALUE (rhs)) == OVERLOAD,
5266                             182);
5267
5268         for (baselink = rhs; baselink;
5269              baselink = next_baselink (baselink))
5270           {
5271             elem = TREE_VALUE (baselink);
5272             while (elem)
5273               if (comptypes (lhstype, TREE_TYPE (OVL_CURRENT (elem)), 1))
5274                 {
5275                   mark_used (OVL_CURRENT (elem));
5276                   return OVL_CURRENT (elem);
5277                 }
5278               else
5279                 elem = OVL_NEXT (elem);
5280           }
5281
5282         /* No exact match found, look for a compatible method.  */
5283         for (baselink = rhs; baselink;
5284              baselink = next_baselink (baselink))
5285           {
5286             elem = TREE_VALUE (baselink);
5287             for (; elem; elem = OVL_NEXT (elem))
5288               if (comp_target_types (lhstype,
5289                                      TREE_TYPE (OVL_CURRENT (elem)), 1) > 0)
5290                 break;
5291             if (elem)
5292               {
5293                 tree save_elem = OVL_CURRENT (elem);
5294                 for (elem = OVL_NEXT (elem); elem; elem = OVL_NEXT (elem))
5295                   if (comp_target_types (lhstype,
5296                                          TREE_TYPE (OVL_CURRENT (elem)), 0) > 0)
5297                     break;
5298                 if (elem)
5299                   {
5300                     if (complain)
5301                       error ("ambiguous overload for overloaded method requested");
5302                     return error_mark_node;
5303                   }
5304                 mark_used (save_elem);
5305                 return save_elem;
5306               }
5307             name = rhs;
5308             while (TREE_CODE (name) == TREE_LIST)
5309               name = TREE_VALUE (name);
5310             name = DECL_NAME (OVL_CURRENT (name));
5311 #if 0
5312             if (TREE_CODE (lhstype) == FUNCTION_TYPE && globals < 0)
5313               {
5314                 /* Try to instantiate from non-member functions.  */
5315                 rhs = lookup_name_nonclass (name);
5316                 if (rhs && TREE_CODE (rhs) == TREE_LIST)
5317                   {
5318                     /* This code seems to be missing a `return'.  */
5319                     my_friendly_abort (4);
5320                     instantiate_type (lhstype, rhs, complain);
5321                   }
5322               }
5323 #endif
5324           }
5325         if (complain)
5326           cp_error ("no compatible member functions named `%D'", name);
5327         return error_mark_node;
5328       }
5329
5330     case CALL_EXPR:
5331       /* This is too hard for now.  */
5332       my_friendly_abort (183);
5333       return error_mark_node;
5334
5335     case PLUS_EXPR:
5336     case MINUS_EXPR:
5337     case COMPOUND_EXPR:
5338       TREE_OPERAND (rhs, 0)
5339         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
5340       if (TREE_OPERAND (rhs, 0) == error_mark_node)
5341         return error_mark_node;
5342       TREE_OPERAND (rhs, 1)
5343         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
5344       if (TREE_OPERAND (rhs, 1) == error_mark_node)
5345         return error_mark_node;
5346
5347       TREE_TYPE (rhs) = lhstype;
5348       return rhs;
5349
5350     case MULT_EXPR:
5351     case TRUNC_DIV_EXPR:
5352     case FLOOR_DIV_EXPR:
5353     case CEIL_DIV_EXPR:
5354     case ROUND_DIV_EXPR:
5355     case RDIV_EXPR:
5356     case TRUNC_MOD_EXPR:
5357     case FLOOR_MOD_EXPR:
5358     case CEIL_MOD_EXPR:
5359     case ROUND_MOD_EXPR:
5360     case FIX_ROUND_EXPR:
5361     case FIX_FLOOR_EXPR:
5362     case FIX_CEIL_EXPR:
5363     case FIX_TRUNC_EXPR:
5364     case FLOAT_EXPR:
5365     case NEGATE_EXPR:
5366     case ABS_EXPR:
5367     case MAX_EXPR:
5368     case MIN_EXPR:
5369     case FFS_EXPR:
5370
5371     case BIT_AND_EXPR:
5372     case BIT_IOR_EXPR:
5373     case BIT_XOR_EXPR:
5374     case LSHIFT_EXPR:
5375     case RSHIFT_EXPR:
5376     case LROTATE_EXPR:
5377     case RROTATE_EXPR:
5378
5379     case PREINCREMENT_EXPR:
5380     case PREDECREMENT_EXPR:
5381     case POSTINCREMENT_EXPR:
5382     case POSTDECREMENT_EXPR:
5383       if (complain)
5384         error ("invalid operation on uninstantiated type");
5385       return error_mark_node;
5386
5387     case TRUTH_AND_EXPR:
5388     case TRUTH_OR_EXPR:
5389     case TRUTH_XOR_EXPR:
5390     case LT_EXPR:
5391     case LE_EXPR:
5392     case GT_EXPR:
5393     case GE_EXPR:
5394     case EQ_EXPR:
5395     case NE_EXPR:
5396     case TRUTH_ANDIF_EXPR:
5397     case TRUTH_ORIF_EXPR:
5398     case TRUTH_NOT_EXPR:
5399       if (complain)
5400         error ("not enough type information");
5401       return error_mark_node;
5402
5403     case COND_EXPR:
5404       if (type_unknown_p (TREE_OPERAND (rhs, 0)))
5405         {
5406           if (complain)
5407             error ("not enough type information");
5408           return error_mark_node;
5409         }
5410       TREE_OPERAND (rhs, 1)
5411         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
5412       if (TREE_OPERAND (rhs, 1) == error_mark_node)
5413         return error_mark_node;
5414       TREE_OPERAND (rhs, 2)
5415         = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), complain);
5416       if (TREE_OPERAND (rhs, 2) == error_mark_node)
5417         return error_mark_node;
5418
5419       TREE_TYPE (rhs) = lhstype;
5420       return rhs;
5421
5422     case MODIFY_EXPR:
5423       TREE_OPERAND (rhs, 1)
5424         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
5425       if (TREE_OPERAND (rhs, 1) == error_mark_node)
5426         return error_mark_node;
5427
5428       TREE_TYPE (rhs) = lhstype;
5429       return rhs;
5430
5431     case ADDR_EXPR:
5432       if (TYPE_PTRMEMFUNC_P (lhstype))
5433         lhstype = TYPE_PTRMEMFUNC_FN_TYPE (lhstype);
5434       else if (TREE_CODE (lhstype) != POINTER_TYPE)
5435         {
5436           if (complain)
5437             error ("type for resolving address of overloaded function must be pointer type");
5438           return error_mark_node;
5439         }
5440       {
5441         tree fn = instantiate_type (TREE_TYPE (lhstype), TREE_OPERAND (rhs, 0), complain);
5442         if (fn == error_mark_node)
5443           return error_mark_node;
5444         mark_addressable (fn);
5445         TREE_TYPE (rhs) = lhstype;
5446         TREE_OPERAND (rhs, 0) = fn;
5447         TREE_CONSTANT (rhs) = staticp (fn);
5448         if (TREE_CODE (lhstype) == POINTER_TYPE
5449             && TREE_CODE (TREE_TYPE (lhstype)) == METHOD_TYPE)
5450           {
5451             build_ptrmemfunc_type (lhstype);
5452             rhs = build_ptrmemfunc (lhstype, rhs, 0);
5453           }
5454       }
5455       return rhs;
5456
5457     case ENTRY_VALUE_EXPR:
5458       my_friendly_abort (184);
5459       return error_mark_node;
5460
5461     case ERROR_MARK:
5462       return error_mark_node;
5463
5464     default:
5465       my_friendly_abort (185);
5466       return error_mark_node;
5467     }
5468 }
5469 \f
5470 /* Return the name of the virtual function pointer field
5471    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
5472    this may have to look back through base types to find the
5473    ultimate field name.  (For single inheritance, these could
5474    all be the same name.  Who knows for multiple inheritance).  */
5475
5476 static tree
5477 get_vfield_name (type)
5478      tree type;
5479 {
5480   tree binfo = TYPE_BINFO (type);
5481   char *buf;
5482
5483   while (BINFO_BASETYPES (binfo)
5484          && TYPE_VIRTUAL_P (BINFO_TYPE (BINFO_BASETYPE (binfo, 0)))
5485          && ! TREE_VIA_VIRTUAL (BINFO_BASETYPE (binfo, 0)))
5486     binfo = BINFO_BASETYPE (binfo, 0);
5487
5488   type = BINFO_TYPE (binfo);
5489   buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
5490                          + TYPE_NAME_LENGTH (type) + 2);
5491   sprintf (buf, VFIELD_NAME_FORMAT, TYPE_NAME_STRING (type));
5492   return get_identifier (buf);
5493 }
5494
5495 void
5496 print_class_statistics ()
5497 {
5498 #ifdef GATHER_STATISTICS
5499   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
5500   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
5501   fprintf (stderr, "build_method_call = %d (inner = %d)\n",
5502            n_build_method_call, n_inner_fields_searched);
5503   if (n_vtables)
5504     {
5505       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
5506                n_vtables, n_vtable_searches);
5507       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
5508                n_vtable_entries, n_vtable_elems);
5509     }
5510 #endif
5511 }
5512
5513 /* Push an obstack which is sufficiently long-lived to hold such class
5514    decls that may be cached in the previous_class_values list.  For now, let's
5515    use the permanent obstack, later we may create a dedicated obstack just
5516    for this purpose.  The effect is undone by pop_obstacks.  */
5517
5518 void
5519 maybe_push_cache_obstack ()
5520 {
5521   push_obstacks_nochange ();
5522   if (current_class_depth == 1)
5523     current_obstack = &permanent_obstack;
5524 }
5525
5526 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
5527    according to [class]:
5528                                           The class-name is also inserted
5529    into  the scope of the class itself.  For purposes of access checking,
5530    the inserted class name is treated as if it were a public member name.  */
5531
5532 tree
5533 build_self_reference ()
5534 {
5535   tree name = constructor_name (current_class_type);
5536   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
5537   DECL_NONLOCAL (value) = 1;
5538   DECL_CONTEXT (value) = current_class_type;
5539   DECL_CLASS_CONTEXT (value) = current_class_type;
5540   CLASSTYPE_LOCAL_TYPEDECLS (current_class_type) = 1;
5541   DECL_ARTIFICIAL (value) = 1;
5542
5543   pushdecl_class_level (value);
5544   return value;
5545 }
5546
5547 /* Returns 1 if TYPE contains only padding bytes.  */
5548
5549 int
5550 is_empty_class (type)
5551      tree type;
5552 {
5553   tree t;
5554
5555   if (type == error_mark_node)
5556     return 0;
5557
5558   if (! IS_AGGR_TYPE (type))
5559     return 0;
5560
5561   if (flag_new_abi)
5562     return CLASSTYPE_SIZE (type) == integer_zero_node;
5563
5564   if (TYPE_BINFO_BASETYPES (type))
5565     return 0;
5566   t = TYPE_FIELDS (type);
5567   while (t && TREE_CODE (t) != FIELD_DECL)
5568     t = TREE_CHAIN (t);
5569   return (t == NULL_TREE);
5570 }