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));
 111 static int overrides PROTO((tree, tree));
 112 static int strictly_overrides PROTO((tree, tree));
 113 static void merge_overrides PROTO((tree, tree, int, tree));
 114 static void override_one_vtable PROTO((tree, tree, tree));
 115 static void mark_overriders PROTO((tree, tree));
 116 static void check_for_override PROTO((tree, tree));
 117 static tree maybe_fixup_vptrs PROTO((tree, tree, tree));
 118 static tree get_class_offset_1 PROTO((tree, tree, tree, tree, tree));
 119 static tree get_class_offset PROTO((tree, tree, tree, tree));
 120 static void modify_one_vtable PROTO((tree, tree, tree, tree));
 121 static void modify_all_vtables PROTO((tree, tree, tree));
 122 static void modify_all_direct_vtables PROTO((tree, int, tree, tree,
 123                                              tree));
 124 static void modify_all_indirect_vtables PROTO((tree, int, int, tree,
 125                                                tree, tree));
 126 static void build_class_init_list PROTO((tree));
 127 static int finish_base_struct PROTO((tree, struct base_info *));
 128
 129 /* Way of stacking language names.  */
 130 tree *current_lang_base, *current_lang_stack;
 131 int current_lang_stacksize;
 132
 133 /* Names of languages we recognize.  */
 134 tree lang_name_c, lang_name_cplusplus, lang_name_java;
 135 tree current_lang_name;
 136
 137 /* When layout out an aggregate type, the size of the
 138    basetypes (virtual and non-virtual) is passed to layout_record
 139    via this node.  */
 140 static tree base_layout_decl;
 141
 142 /* Constants used for access control.  */
 143 tree access_default_node; /* 0 */
 144 tree access_public_node; /* 1 */
 145 tree access_protected_node; /* 2 */
 146 tree access_private_node; /* 3 */
 147 tree access_default_virtual_node; /* 4 */
 148 tree access_public_virtual_node; /* 5 */
 149 tree access_protected_virtual_node; /* 6 */
 150 tree access_private_virtual_node; /* 7 */
 151
 152 /* Variables shared between class.c and call.c.  */
 153
 154 #ifdef GATHER_STATISTICS
 155 int n_vtables = 0;
 156 int n_vtable_entries = 0;
 157 int n_vtable_searches = 0;
 158 int n_vtable_elems = 0;
 159 int n_convert_harshness = 0;
 160 int n_compute_conversion_costs = 0;
 161 int n_build_method_call = 0;
 162 int n_inner_fields_searched = 0;
 163 #endif
 164
 165 /* Virtual baseclass things.  */
 166
 167 static tree
 168 build_vbase_pointer (exp, type)
 169      tree exp, type;
 170 {
 171   char *name;
 172
 173   name = (char *) alloca (TYPE_NAME_LENGTH (type) + sizeof (VBASE_NAME) + 1);
 174   sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (type));
 175   return build_component_ref (exp, get_identifier (name), NULL_TREE, 0);
 176 }
 177
 178 /* Is the type of the EXPR, the complete type of the object?
 179    If we are going to be wrong, we must be conservative, and return 0.  */
 180
 181 static int
 182 complete_type_p (expr)
 183      tree expr;
 184 {
 185   tree type = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
 186   while (1)
 187     {
 188       switch (TREE_CODE (expr))
 189         {
 190         case SAVE_EXPR:
 191         case INDIRECT_REF:
 192         case ADDR_EXPR:
 193         case NOP_EXPR:
 194         case CONVERT_EXPR:
 195           expr = TREE_OPERAND (expr, 0);
 196           continue;
 197
 198         case CALL_EXPR:
 199           if (! TREE_HAS_CONSTRUCTOR (expr))
 200             break;
 201           /* fall through...  */
 202         case VAR_DECL:
 203         case FIELD_DECL:
 204           if (TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
 205               && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (expr)))
 206               && TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type)
 207             return 1;
 208           /* fall through...  */
 209         case TARGET_EXPR:
 210         case PARM_DECL:
 211           if (IS_AGGR_TYPE (TREE_TYPE (expr))
 212               && TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type)
 213             return 1;
 214           /* fall through...  */
 215         case PLUS_EXPR:
 216         default:
 217           break;
 218         }
 219       break;
 220     }
 221   return 0;
 222 }
 223
 224 /* Build multi-level access to EXPR using hierarchy path PATH.
 225    CODE is PLUS_EXPR if we are going with the grain,
 226    and MINUS_EXPR if we are not (in which case, we cannot traverse
 227    virtual baseclass links).
 228
 229    TYPE is the type we want this path to have on exit.
 230
 231    ALIAS_THIS is non-zero if EXPR in an expression involving `this'.  */
 232
 233 tree
 234 build_vbase_path (code, type, expr, path, alias_this)
 235      enum tree_code code;
 236      tree type, expr, path;
 237      int alias_this;
 238 {
 239   register int changed = 0;
 240   tree last = NULL_TREE, last_virtual = NULL_TREE;
 241   int nonnull = 0;
 242   int fixed_type_p;
 243   tree null_expr = 0, nonnull_expr;
 244   tree basetype;
 245   tree offset = integer_zero_node;
 246
 247   if (BINFO_INHERITANCE_CHAIN (path) == NULL_TREE)
 248     return build1 (NOP_EXPR, type, expr);
 249
 250   if (nonnull == 0 && (alias_this && flag_this_is_variable <= 0))
 251     nonnull = 1;
 252
 253 #if 0
 254   /* We need additional logic to convert back to the unconverted type
 255      (the static type of the complete object), and then convert back
 256      to the type we want.  Until that is done, or until we can
 257      recognize when that is, we cannot do the short cut logic. (mrs) */
 258   fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
 259 #else
 260   /* Do this, until we can undo any previous conversions.  See net35.C
 261      for a testcase.  */
 262   fixed_type_p = complete_type_p (expr);
 263 #endif
 264
 265   if (!fixed_type_p && TREE_SIDE_EFFECTS (expr))
 266     expr = save_expr (expr);
 267   nonnull_expr = expr;
 268
 269   if (BINFO_INHERITANCE_CHAIN (path))
 270     {
 271       tree reverse_path = NULL_TREE;
 272
 273       push_expression_obstack ();
 274       while (path)
 275         {
 276           tree r = copy_node (path);
 277           BINFO_INHERITANCE_CHAIN (r) = reverse_path;
 278           reverse_path = r;
 279           path = BINFO_INHERITANCE_CHAIN (path);
 280         }
 281       path = reverse_path;
 282       pop_obstacks ();
 283     }
 284
 285   basetype = BINFO_TYPE (path);
 286
 287   while (path)
 288     {
 289       if (TREE_VIA_VIRTUAL (path))
 290         {
 291           last_virtual = BINFO_TYPE (path);
 292           if (code == PLUS_EXPR)
 293             {
 294               changed = ! fixed_type_p;
 295
 296               if (changed)
 297                 {
 298                   tree ind;
 299
 300                   /* We already check for ambiguous things in the caller, just
 301                      find a path.  */
 302                   if (last)
 303                     {
 304                       tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (nonnull_expr))), 0);
 305                       nonnull_expr = convert_pointer_to_real (binfo, nonnull_expr);
 306                     }
 307                   ind = build_indirect_ref (nonnull_expr, NULL_PTR);
 308                   nonnull_expr = build_vbase_pointer (ind, last_virtual);
 309                   if (nonnull == 0
 310                       && (TREE_CODE (type) == POINTER_TYPE
 311                           || !flag_assume_nonnull_objects)
 312                       && null_expr == NULL_TREE)
 313                     {
 314                       null_expr = build1 (NOP_EXPR, build_pointer_type (last_virtual), integer_zero_node);
 315                       expr = build (COND_EXPR, build_pointer_type (last_virtual),
 316                                     build (EQ_EXPR, boolean_type_node, expr,
 317                                            integer_zero_node),
 318                                     null_expr, nonnull_expr);
 319                     }
 320                 }
 321               /* else we'll figure out the offset below.  */
 322
 323               /* Happens in the case of parse errors.  */
 324               if (nonnull_expr == error_mark_node)
 325                 return error_mark_node;
 326             }
 327           else
 328             {
 329               cp_error ("cannot cast up from virtual baseclass `%T'",
 330                           last_virtual);
 331               return error_mark_node;
 332             }
 333         }
 334       last = path;
 335       path = BINFO_INHERITANCE_CHAIN (path);
 336     }
 337   /* LAST is now the last basetype assoc on the path.  */
 338
 339   /* A pointer to a virtual base member of a non-null object
 340      is non-null.  Therefore, we only need to test for zeroness once.
 341      Make EXPR the canonical expression to deal with here.  */
 342   if (null_expr)
 343     {
 344       TREE_OPERAND (expr, 2) = nonnull_expr;
 345       TREE_TYPE (expr) = TREE_TYPE (TREE_OPERAND (expr, 1))
 346         = TREE_TYPE (nonnull_expr);
 347     }
 348   else
 349     expr = nonnull_expr;
 350
 351   /* If we go through any virtual base pointers, make sure that
 352      casts to BASETYPE from the last virtual base class use
 353      the right value for BASETYPE.  */
 354   if (changed)
 355     {
 356       tree intype = TREE_TYPE (TREE_TYPE (expr));
 357       if (TYPE_MAIN_VARIANT (intype) != BINFO_TYPE (last))
 358         {
 359           tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (intype), 0);
 360           offset = BINFO_OFFSET (binfo);
 361         }
 362     }
 363   else
 364     {
 365       if (last_virtual)
 366         {
 367           offset = BINFO_OFFSET (binfo_member (last_virtual,
 368                                                CLASSTYPE_VBASECLASSES (basetype)));
 369           offset = size_binop (PLUS_EXPR, offset, BINFO_OFFSET (last));
 370         }
 371       else
 372         offset = BINFO_OFFSET (last);
 373     }
 374
 375   if (TREE_INT_CST_LOW (offset))
 376     {
 377       /* Bash types to make the backend happy.  */
 378       offset = cp_convert (type, offset);
 379 #if 0
 380       /* This shouldn't be necessary.  (mrs) */
 381       expr = build1 (NOP_EXPR, type, expr);
 382 #endif
 383
 384       /* For multiple inheritance: if `this' can be set by any
 385          function, then it could be 0 on entry to any function.
 386          Preserve such zeroness here.  Otherwise, only in the
 387          case of constructors need we worry, and in those cases,
 388          it will be zero, or initialized to some valid value to
 389          which we may add.  */
 390       if (nonnull == 0)
 391         {
 392           if (null_expr)
 393             TREE_TYPE (null_expr) = type;
 394           else
 395             null_expr = build1 (NOP_EXPR, type, integer_zero_node);
 396           if (TREE_SIDE_EFFECTS (expr))
 397             expr = save_expr (expr);
 398
 399           return build (COND_EXPR, type,
 400                         build (EQ_EXPR, boolean_type_node, expr, integer_zero_node),
 401                         null_expr,
 402                         build (code, type, expr, offset));
 403         }
 404       else return build (code, type, expr, offset);
 405     }
 406
 407   /* Cannot change the TREE_TYPE of a NOP_EXPR here, since it may
 408      be used multiple times in initialization of multiple inheritance.  */
 409   if (null_expr)
 410     {
 411       TREE_TYPE (expr) = type;
 412       return expr;
 413     }
 414   else
 415     return build1 (NOP_EXPR, type, expr);
 416 }
 417
 418 /* Virtual function things.  */
 419
 420 /* Build an entry in the virtual function table.
 421    DELTA is the offset for the `this' pointer.
 422    PFN is an ADDR_EXPR containing a pointer to the virtual function.
 423    Note that the index (DELTA2) in the virtual function table
 424    is always 0.  */
 425
 426 static tree
 427 build_vtable_entry (delta, pfn)
 428      tree delta, pfn;
 429 {
 430   if (flag_vtable_thunks)
 431     {
 432       HOST_WIDE_INT idelta = TREE_INT_CST_LOW (delta);
 433       if (idelta && ! DECL_ABSTRACT_VIRTUAL_P (TREE_OPERAND (pfn, 0)))
 434         {
 435           pfn = build1 (ADDR_EXPR, vtable_entry_type,
 436                         make_thunk (pfn, idelta));
 437           TREE_READONLY (pfn) = 1;
 438           TREE_CONSTANT (pfn) = 1;
 439         }
 440 #ifdef GATHER_STATISTICS
 441       n_vtable_entries += 1;
 442 #endif
 443       return pfn;
 444     }
 445   else
 446     {
 447       extern int flag_huge_objects;
 448       tree elems = expr_tree_cons (NULL_TREE, delta,
 449                               expr_tree_cons (NULL_TREE, integer_zero_node,
 450                                          build_expr_list (NULL_TREE, pfn)));
 451       tree entry = build (CONSTRUCTOR, vtable_entry_type, NULL_TREE, elems);
 452
 453       /* DELTA used to be constructed by `size_int' and/or size_binop,
 454          which caused overflow problems when it was negative.  That should
 455          be fixed now.  */
 456
 457       if (! int_fits_type_p (delta, delta_type_node))
 458         {
 459           if (flag_huge_objects)
 460             sorry ("object size exceeds built-in limit for virtual function table implementation");
 461           else
 462             sorry ("object size exceeds normal limit for virtual function table implementation, recompile all source and use -fhuge-objects");
 463         }
 464
 465       TREE_CONSTANT (entry) = 1;
 466       TREE_STATIC (entry) = 1;
 467       TREE_READONLY (entry) = 1;
 468
 469 #ifdef GATHER_STATISTICS
 470       n_vtable_entries += 1;
 471 #endif
 472
 473       return entry;
 474     }
 475 }
 476
 477 /* Given an object INSTANCE, return an expression which yields the
 478    virtual function vtable element corresponding to INDEX.  There are
 479    many special cases for INSTANCE which we take care of here, mainly
 480    to avoid creating extra tree nodes when we don't have to.  */
 481
 482 tree
 483 build_vtbl_ref (instance, idx)
 484      tree instance, idx;
 485 {
 486   tree vtbl, aref;
 487   tree basetype = TREE_TYPE (instance);
 488
 489   if (TREE_CODE (basetype) == REFERENCE_TYPE)
 490     basetype = TREE_TYPE (basetype);
 491
 492   if (instance == current_class_ref)
 493     vtbl = build_indirect_ref (build_vfield_ref (instance, basetype),
 494                                NULL_PTR);
 495   else
 496     {
 497       if (optimize)
 498         {
 499           /* Try to figure out what a reference refers to, and
 500              access its virtual function table directly.  */
 501           tree ref = NULL_TREE;
 502
 503           if (TREE_CODE (instance) == INDIRECT_REF
 504               && TREE_CODE (TREE_TYPE (TREE_OPERAND (instance, 0))) == REFERENCE_TYPE)
 505             ref = TREE_OPERAND (instance, 0);
 506           else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
 507             ref = instance;
 508
 509           if (ref && TREE_CODE (ref) == VAR_DECL
 510               && DECL_INITIAL (ref))
 511             {
 512               tree init = DECL_INITIAL (ref);
 513
 514               while (TREE_CODE (init) == NOP_EXPR
 515                      || TREE_CODE (init) == NON_LVALUE_EXPR)
 516                 init = TREE_OPERAND (init, 0);
 517               if (TREE_CODE (init) == ADDR_EXPR)
 518                 {
 519                   init = TREE_OPERAND (init, 0);
 520                   if (IS_AGGR_TYPE (TREE_TYPE (init))
 521                       && (TREE_CODE (init) == PARM_DECL
 522                           || TREE_CODE (init) == VAR_DECL))
 523                     instance = init;
 524                 }
 525             }
 526         }
 527
 528       if (IS_AGGR_TYPE (TREE_TYPE (instance))
 529           && (TREE_CODE (instance) == RESULT_DECL
 530               || TREE_CODE (instance) == PARM_DECL
 531               || TREE_CODE (instance) == VAR_DECL))
 532         vtbl = TYPE_BINFO_VTABLE (basetype);
 533       else
 534         vtbl = build_indirect_ref (build_vfield_ref (instance, basetype),
 535                                    NULL_PTR);
 536     }
 537   assemble_external (vtbl);
 538   aref = build_array_ref (vtbl, idx);
 539
 540   return aref;
 541 }
 542
 543 /* Given an object INSTANCE, return an expression which yields the
 544    virtual function corresponding to INDEX.  There are many special
 545    cases for INSTANCE which we take care of here, mainly to avoid
 546    creating extra tree nodes when we don't have to.  */
 547
 548 tree
 549 build_vfn_ref (ptr_to_instptr, instance, idx)
 550      tree *ptr_to_instptr, instance;
 551      tree idx;
 552 {
 553   tree aref = build_vtbl_ref (instance, idx);
 554
 555   /* When using thunks, there is no extra delta, and we get the pfn
 556      directly.  */
 557   if (flag_vtable_thunks)
 558     return aref;
 559
 560   if (ptr_to_instptr)
 561     {
 562       /* Save the intermediate result in a SAVE_EXPR so we don't have to
 563          compute each component of the virtual function pointer twice.  */
 564       if (TREE_CODE (aref) == INDIRECT_REF)
 565         TREE_OPERAND (aref, 0) = save_expr (TREE_OPERAND (aref, 0));
 566
 567       *ptr_to_instptr
 568         = build (PLUS_EXPR, TREE_TYPE (*ptr_to_instptr),
 569                  *ptr_to_instptr,
 570                  cp_convert (ptrdiff_type_node,
 571                              build_component_ref (aref, delta_identifier, NULL_TREE, 0)));
 572     }
 573
 574   return build_component_ref (aref, pfn_identifier, NULL_TREE, 0);
 575 }
 576
 577 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
 578    for the given TYPE.  */
 579
 580 static tree
 581 get_vtable_name (type)
 582      tree type;
 583 {
 584   tree type_id = build_typename_overload (type);
 585   char *buf = (char *) alloca (strlen (VTABLE_NAME_FORMAT)
 586                                + IDENTIFIER_LENGTH (type_id) + 2);
 587   char *ptr = IDENTIFIER_POINTER (type_id);
 588   int i;
 589   for (i = 0; ptr[i] == OPERATOR_TYPENAME_FORMAT[i]; i++) ;
 590 #if 0
 591   /* We don't take off the numbers; prepare_fresh_vtable uses the
 592      DECL_ASSEMBLER_NAME for the type, which includes the number
 593      in `3foo'.  If we were to pull them off here, we'd end up with
 594      something like `_vt.foo.3bar', instead of a uniform definition.  */
 595   while (ptr[i] >= '0' && ptr[i] <= '9')
 596     i += 1;
 597 #endif
 598   sprintf (buf, VTABLE_NAME_FORMAT, ptr+i);
 599   return get_identifier (buf);
 600 }
 601
 602 /* Return the offset to the main vtable for a given base BINFO.  */
 603
 604 tree
 605 get_vfield_offset (binfo)
 606      tree binfo;
 607 {
 608   tree tmp
 609     = size_binop (FLOOR_DIV_EXPR,
 610                   DECL_FIELD_BITPOS (CLASSTYPE_VFIELD (BINFO_TYPE (binfo))),
 611                   size_int (BITS_PER_UNIT));
 612   tmp = convert (sizetype, tmp);
 613   return size_binop (PLUS_EXPR, tmp, BINFO_OFFSET (binfo));
 614 }
 615
 616 /* Get the offset to the start of the original binfo that we derived
 617    this binfo from.  If we find TYPE first, return the offset only
 618    that far.  The shortened search is useful because the this pointer
 619    on method calling is expected to point to a DECL_CONTEXT (fndecl)
 620    object, and not a baseclass of it.  */
 621
 622 static tree
 623 get_derived_offset (binfo, type)
 624      tree binfo, type;
 625 {
 626   tree offset1 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo)));
 627   tree offset2;
 628   int i;
 629   while (BINFO_BASETYPES (binfo)
 630          && (i=CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo))) != -1)
 631     {
 632       tree binfos = BINFO_BASETYPES (binfo);
 633       if (BINFO_TYPE (binfo) == type)
 634         break;
 635       binfo = TREE_VEC_ELT (binfos, i);
 636     }
 637   offset2 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo)));
 638   return size_binop (MINUS_EXPR, offset1, offset2);
 639 }
 640
 641 /* Update the rtti info for this class.  */
 642
 643 static void
 644 set_rtti_entry (virtuals, offset, type)
 645      tree virtuals, offset, type;
 646 {
 647   tree vfn;
 648
 649   if (flag_rtti)
 650     vfn = build1 (ADDR_EXPR, vfunc_ptr_type_node, get_tinfo_fn (type));
 651   else
 652     vfn = build1 (NOP_EXPR, vfunc_ptr_type_node, size_zero_node);
 653   TREE_CONSTANT (vfn) = 1;
 654
 655   if (! flag_vtable_thunks)
 656     TREE_VALUE (virtuals) = build_vtable_entry (offset, vfn);
 657   else
 658     {
 659       tree voff = build1 (NOP_EXPR, vfunc_ptr_type_node, offset);
 660       TREE_CONSTANT (voff) = 1;
 661
 662       TREE_VALUE (virtuals) = build_vtable_entry (integer_zero_node, voff);
 663
 664       /* The second slot is for the tdesc pointer when thunks are used.  */
 665       TREE_VALUE (TREE_CHAIN (virtuals))
 666         = build_vtable_entry (integer_zero_node, vfn);
 667     }
 668 }
 669
 670 /* Build a virtual function for type TYPE.
 671    If BINFO is non-NULL, build the vtable starting with the initial
 672    approximation that it is the same as the one which is the head of
 673    the association list.  */
 674
 675 static tree
 676 build_vtable (binfo, type)
 677      tree binfo, type;
 678 {
 679   tree name = get_vtable_name (type);
 680   tree virtuals, decl;
 681
 682   if (binfo)
 683     {
 684       tree offset;
 685
 686       virtuals = copy_list (BINFO_VIRTUALS (binfo));
 687       decl = build_decl (VAR_DECL, name, TREE_TYPE (BINFO_VTABLE (binfo)));
 688
 689       /* Now do rtti stuff.  */
 690       offset = get_derived_offset (TYPE_BINFO (type), NULL_TREE);
 691       offset = ssize_binop (MINUS_EXPR, integer_zero_node, offset);
 692       set_rtti_entry (virtuals, offset, type);
 693     }
 694   else
 695     {
 696       virtuals = NULL_TREE;
 697       decl = build_decl (VAR_DECL, name, void_type_node);
 698     }
 699
 700 #ifdef GATHER_STATISTICS
 701   n_vtables += 1;
 702   n_vtable_elems += list_length (virtuals);
 703 #endif
 704
 705   /* Set TREE_PUBLIC and TREE_EXTERN as appropriate.  */
 706   import_export_vtable (decl, type, 0);
 707
 708   decl = pushdecl_top_level (decl);
 709   SET_IDENTIFIER_GLOBAL_VALUE (name, decl);
 710   /* Initialize the association list for this type, based
 711      on our first approximation.  */
 712   TYPE_BINFO_VTABLE (type) = decl;
 713   TYPE_BINFO_VIRTUALS (type) = virtuals;
 714
 715   DECL_ARTIFICIAL (decl) = 1;
 716   TREE_STATIC (decl) = 1;
 717 #ifndef WRITABLE_VTABLES
 718   /* Make them READONLY by default. (mrs) */
 719   TREE_READONLY (decl) = 1;
 720 #endif
 721   /* At one time the vtable info was grabbed 2 words at a time.  This
 722      fails on sparc unless you have 8-byte alignment.  (tiemann) */
 723   DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
 724                            DECL_ALIGN (decl));
 725
 726   /* Why is this conditional? (mrs) */
 727   if (binfo && write_virtuals >= 0)
 728     DECL_VIRTUAL_P (decl) = 1;
 729   DECL_CONTEXT (decl) = type;
 730
 731   binfo = TYPE_BINFO (type);
 732   SET_BINFO_NEW_VTABLE_MARKED (binfo);
 733   return decl;
 734 }
 735
 736 extern tree signed_size_zero_node;
 737
 738 /* Give TYPE a new virtual function table which is initialized
 739    with a skeleton-copy of its original initialization.  The only
 740    entry that changes is the `delta' entry, so we can really
 741    share a lot of structure.
 742
 743    FOR_TYPE is the derived type which caused this table to
 744    be needed.
 745
 746    BINFO is the type association which provided TYPE for FOR_TYPE.
 747
 748    The order in which vtables are built (by calling this function) for
 749    an object must remain the same, otherwise a binary incompatibility
 750    can result.  */
 751
 752 static void
 753 prepare_fresh_vtable (binfo, for_type)
 754      tree binfo, for_type;
 755 {
 756   tree basetype;
 757   tree orig_decl = BINFO_VTABLE (binfo);
 758   tree name;
 759   tree new_decl;
 760   tree offset;
 761   tree path = binfo;
 762   char *buf, *buf2;
 763   char joiner = '_';
 764   int i;
 765
 766 #ifdef JOINER
 767   joiner = JOINER;
 768 #endif
 769
 770   basetype = TYPE_MAIN_VARIANT (BINFO_TYPE (binfo));
 771
 772   buf2 = TYPE_ASSEMBLER_NAME_STRING (basetype);
 773   i = TYPE_ASSEMBLER_NAME_LENGTH (basetype) + 1;
 774
 775   /* We know that the vtable that we are going to create doesn't exist
 776      yet in the global namespace, and when we finish, it will be
 777      pushed into the global namespace.  In complex MI hierarchies, we
 778      have to loop while the name we are thinking of adding is globally
 779      defined, adding more name components to the vtable name as we
 780      loop, until the name is unique.  This is because in complex MI
 781      cases, we might have the same base more than once.  This means
 782      that the order in which this function is called for vtables must
 783      remain the same, otherwise binary compatibility can be
 784      compromised.  */
 785
 786   while (1)
 787     {
 788       char *buf1 = (char *) alloca (TYPE_ASSEMBLER_NAME_LENGTH (for_type)
 789                                     + 1 + i);
 790       char *new_buf2;
 791
 792       sprintf (buf1, "%s%c%s", TYPE_ASSEMBLER_NAME_STRING (for_type), joiner,
 793                buf2);
 794       buf = (char *) alloca (strlen (VTABLE_NAME_FORMAT) + strlen (buf1) + 1);
 795       sprintf (buf, VTABLE_NAME_FORMAT, buf1);
 796       name = get_identifier (buf);
 797
 798       /* If this name doesn't clash, then we can use it, otherwise
 799          we add more to the name until it is unique.  */
 800
 801       if (! IDENTIFIER_GLOBAL_VALUE (name))
 802         break;
 803
 804       /* Set values for next loop through, if the name isn't unique.  */
 805
 806       path = BINFO_INHERITANCE_CHAIN (path);
 807
 808       /* We better not run out of stuff to make it unique.  */
 809       my_friendly_assert (path != NULL_TREE, 368);
 810
 811       basetype = TYPE_MAIN_VARIANT (BINFO_TYPE (path));
 812
 813       if (for_type == basetype)
 814         {
 815           /* If we run out of basetypes in the path, we have already
 816              found created a vtable with that name before, we now
 817              resort to tacking on _%d to distinguish them.  */
 818           int j = 2;
 819           i = TYPE_ASSEMBLER_NAME_LENGTH (basetype) + 1 + i + 1 + 3;
 820           buf1 = (char *) alloca (i);
 821           do {
 822             sprintf (buf1, "%s%c%s%c%d",
 823                      TYPE_ASSEMBLER_NAME_STRING (basetype), joiner,
 824                      buf2, joiner, j);
 825             buf = (char *) alloca (strlen (VTABLE_NAME_FORMAT)
 826                                    + strlen (buf1) + 1);
 827             sprintf (buf, VTABLE_NAME_FORMAT, buf1);
 828             name = get_identifier (buf);
 829
 830             /* If this name doesn't clash, then we can use it,
 831                otherwise we add something different to the name until
 832                it is unique.  */
 833           } while (++j <= 999 && IDENTIFIER_GLOBAL_VALUE (name));
 834
 835           /* Hey, they really like MI don't they?  Increase the 3
 836              above to 6, and the 999 to 999999.  :-)  */
 837           my_friendly_assert (j <= 999, 369);
 838
 839           break;
 840         }
 841
 842       i = TYPE_ASSEMBLER_NAME_LENGTH (basetype) + 1 + i;
 843       new_buf2 = (char *) alloca (i);
 844       sprintf (new_buf2, "%s%c%s",
 845                TYPE_ASSEMBLER_NAME_STRING (basetype), joiner, buf2);
 846       buf2 = new_buf2;
 847     }
 848
 849   new_decl = build_decl (VAR_DECL, name, TREE_TYPE (orig_decl));
 850   /* Remember which class this vtable is really for.  */
 851   DECL_CONTEXT (new_decl) = for_type;
 852
 853   DECL_ARTIFICIAL (new_decl) = 1;
 854   TREE_STATIC (new_decl) = 1;
 855   BINFO_VTABLE (binfo) = pushdecl_top_level (new_decl);
 856   DECL_VIRTUAL_P (new_decl) = 1;
 857 #ifndef WRITABLE_VTABLES
 858   /* Make them READONLY by default. (mrs) */
 859   TREE_READONLY (new_decl) = 1;
 860 #endif
 861   DECL_ALIGN (new_decl) = DECL_ALIGN (orig_decl);
 862
 863   /* Make fresh virtual list, so we can smash it later.  */
 864   BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
 865
 866   if (TREE_VIA_VIRTUAL (binfo))
 867     {
 868       tree binfo1 = binfo_member (BINFO_TYPE (binfo),
 869                                   CLASSTYPE_VBASECLASSES (for_type));
 870
 871       /* XXX - This should never happen, if it does, the caller should
 872          ensure that the binfo is from for_type's binfos, not from any
 873          base type's.  We can remove all this code after a while.  */
 874       if (binfo1 != binfo)
 875         warning ("internal inconsistency: binfo offset error for rtti");
 876
 877       offset = BINFO_OFFSET (binfo1);
 878     }
 879   else
 880     offset = BINFO_OFFSET (binfo);
 881
 882   set_rtti_entry (BINFO_VIRTUALS (binfo),
 883                   ssize_binop (MINUS_EXPR, integer_zero_node, offset),
 884                   for_type);
 885
 886 #ifdef GATHER_STATISTICS
 887   n_vtables += 1;
 888   n_vtable_elems += list_length (BINFO_VIRTUALS (binfo));
 889 #endif
 890
 891   /* Set TREE_PUBLIC and TREE_EXTERN as appropriate.  */
 892   import_export_vtable (new_decl, for_type, 0);
 893
 894   if (TREE_VIA_VIRTUAL (binfo))
 895     my_friendly_assert (binfo == binfo_member (BINFO_TYPE (binfo),
 896                                    CLASSTYPE_VBASECLASSES (current_class_type)),
 897                         170);
 898   SET_BINFO_NEW_VTABLE_MARKED (binfo);
 899 }
 900
 901 #if 0
 902 /* Access the virtual function table entry that logically
 903    contains BASE_FNDECL.  VIRTUALS is the virtual function table's
 904    initializer.  We can run off the end, when dealing with virtual
 905    destructors in MI situations, return NULL_TREE in that case.  */
 906
 907 static tree
 908 get_vtable_entry (virtuals, base_fndecl)
 909      tree virtuals, base_fndecl;
 910 {
 911   unsigned HOST_WIDE_INT n = (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
 912            ? (TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl))
 913               & (((unsigned HOST_WIDE_INT)1<<(BITS_PER_WORD-1))-1))
 914            : TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl)));
 915
 916 #ifdef GATHER_STATISTICS
 917   n_vtable_searches += n;
 918 #endif
 919
 920   while (n > 0 && virtuals)
 921     {
 922       --n;
 923       virtuals = TREE_CHAIN (virtuals);
 924     }
 925   return virtuals;
 926 }
 927 #endif
 928
 929 /* Put new entry ENTRY into virtual function table initializer
 930    VIRTUALS.
 931
 932    Also update DECL_VINDEX (FNDECL).  */
 933
 934 static void
 935 modify_vtable_entry (old_entry_in_list, new_entry, fndecl)
 936      tree old_entry_in_list, new_entry, fndecl;
 937 {
 938   tree base_fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (old_entry_in_list)), 0);
 939
 940 #ifdef NOTQUITE
 941   cp_warning ("replaced %D with %D", DECL_ASSEMBLER_NAME (base_fndecl),
 942               DECL_ASSEMBLER_NAME (fndecl));
 943 #endif
 944   TREE_VALUE (old_entry_in_list) = new_entry;
 945
 946   /* Now assign virtual dispatch information, if unset.  */
 947   /* We can dispatch this, through any overridden base function.  */
 948   if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
 949     {
 950       DECL_VINDEX (fndecl) = DECL_VINDEX (base_fndecl);
 951       DECL_CONTEXT (fndecl) = DECL_CONTEXT (base_fndecl);
 952     }
 953 }
 954
 955 /* Access the virtual function table entry N.  VIRTUALS is the virtual
 956    function table's initializer.  */
 957
 958 static tree
 959 get_vtable_entry_n (virtuals, n)
 960      tree virtuals;
 961      unsigned HOST_WIDE_INT n;
 962 {
 963   while (n > 0)
 964     {
 965       --n;
 966       virtuals = TREE_CHAIN (virtuals);
 967     }
 968   return virtuals;
 969 }
 970
 971 /* Add a virtual function to all the appropriate vtables for the class
 972    T.  DECL_VINDEX(X) should be error_mark_node, if we want to
 973    allocate a new slot in our table.  If it is error_mark_node, we
 974    know that no other function from another vtable is overridden by X.
 975    HAS_VIRTUAL keeps track of how many virtuals there are in our main
 976    vtable for the type, and we build upon the PENDING_VIRTUALS list
 977    and return it.  */
 978
 979 static void
 980 add_virtual_function (pv, phv, has_virtual, fndecl, t)
 981      tree *pv, *phv;
 982      int *has_virtual;
 983      tree fndecl;
 984      tree t; /* Structure type.  */
 985 {
 986   tree pending_virtuals = *pv;
 987   tree pending_hard_virtuals = *phv;
 988
 989   /* FUNCTION_TYPEs and OFFSET_TYPEs no longer freely
 990      convert to void *.  Make such a conversion here.  */
 991   tree vfn = build1 (ADDR_EXPR, vfunc_ptr_type_node, fndecl);
 992   TREE_CONSTANT (vfn) = 1;
 993
 994 #ifndef DUMB_USER
 995   if (current_class_type == 0)
 996     cp_warning ("internal problem, current_class_type is zero when adding `%D', please report",
 997                 fndecl);
 998   if (current_class_type && t != current_class_type)
 999     cp_warning ("internal problem, current_class_type differs when adding `%D', please report",
1000                 fndecl);
1001 #endif
1002
1003   /* If the virtual function is a redefinition of a prior one,
1004      figure out in which base class the new definition goes,
1005      and if necessary, make a fresh virtual function table
1006      to hold that entry.  */
1007   if (DECL_VINDEX (fndecl) == error_mark_node)
1008     {
1009       tree entry;
1010
1011       /* We remember that this was the base sub-object for rtti.  */
1012       CLASSTYPE_RTTI (t) = t;
1013
1014       /* If we are using thunks, use two slots at the front, one
1015          for the offset pointer, one for the tdesc pointer.  */
1016       if (*has_virtual == 0 && flag_vtable_thunks)
1017         {
1018           *has_virtual = 1;
1019         }
1020
1021       /* Build a new INT_CST for this DECL_VINDEX.  */
1022       {
1023         static tree index_table[256];
1024         tree idx;
1025         /* We skip a slot for the offset/tdesc entry.  */
1026         int i = ++(*has_virtual);
1027
1028         if (i >= 256 || index_table[i] == 0)
1029           {
1030             idx = build_int_2 (i, 0);
1031             if (i < 256)
1032               index_table[i] = idx;
1033           }
1034         else
1035           idx = index_table[i];
1036
1037         /* Now assign virtual dispatch information.  */
1038         DECL_VINDEX (fndecl) = idx;
1039         DECL_CONTEXT (fndecl) = t;
1040       }
1041       entry = build_vtable_entry (integer_zero_node, vfn);
1042       pending_virtuals = tree_cons (DECL_VINDEX (fndecl), entry, pending_virtuals);
1043     }
1044   /* Might already be INTEGER_CST if declared twice in class.  We will
1045      give error later or we've already given it.  */
1046   else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
1047     {
1048       /* Need an entry in some other virtual function table.
1049          Deal with this after we have laid out our virtual base classes.  */
1050       pending_hard_virtuals = temp_tree_cons (fndecl, vfn, pending_hard_virtuals);
1051     }
1052   *pv = pending_virtuals;
1053   *phv = pending_hard_virtuals;
1054 }
1055 \f
1056 /* Obstack on which to build the vector of class methods.  */
1057 struct obstack class_obstack;
1058 extern struct obstack *current_obstack;
1059
1060 /* Add method METHOD to class TYPE.  This is used when a method
1061    has been defined which did not initially appear in the class definition,
1062    and helps cut down on spurious error messages.
1063
1064    FIELDS is the entry in the METHOD_VEC vector entry of the class type where
1065    the method should be added.  */
1066
1067 void
1068 add_method (type, fields, method)
1069      tree type, *fields, method;
1070 {
1071   push_obstacks (&permanent_obstack, &permanent_obstack);
1072
1073   if (fields && *fields)
1074       *fields = build_overload (method, *fields);
1075   else if (CLASSTYPE_METHOD_VEC (type) == 0)
1076     {
1077       tree method_vec = make_node (TREE_VEC);
1078       if (TYPE_IDENTIFIER (type) == DECL_NAME (method))
1079         {
1080           /* ??? Is it possible for there to have been enough room in the
1081              current chunk for the tree_vec structure but not a tree_vec
1082              plus a tree*?  Will this work in that case?  */
1083           obstack_free (current_obstack, method_vec);
1084           obstack_blank (current_obstack, sizeof (struct tree_vec) + sizeof (tree *));
1085           if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (method)))
1086             TREE_VEC_ELT (method_vec, 1) = method;
1087           else
1088             TREE_VEC_ELT (method_vec, 0) = method;
1089           TREE_VEC_LENGTH (method_vec) = 2;
1090         }
1091       else
1092         {
1093           /* ??? Is it possible for there to have been enough room in the
1094              current chunk for the tree_vec structure but not a tree_vec
1095              plus a tree*?  Will this work in that case?  */
1096           obstack_free (current_obstack, method_vec);
1097           obstack_blank (current_obstack, sizeof (struct tree_vec) + 2*sizeof (tree *));
1098           TREE_VEC_ELT (method_vec, 2) = method;
1099           TREE_VEC_LENGTH (method_vec) = 3;
1100           obstack_finish (current_obstack);
1101         }
1102       CLASSTYPE_METHOD_VEC (type) = method_vec;
1103     }
1104   else
1105     {
1106       tree method_vec = CLASSTYPE_METHOD_VEC (type);
1107       int len = TREE_VEC_LENGTH (method_vec);
1108
1109       /* Adding a new ctor or dtor.  This is easy because our
1110          METHOD_VEC always has a slot for such entries.  */
1111       if (TYPE_IDENTIFIER (type) == DECL_NAME (method))
1112         {
1113           int idx = !!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (method));
1114           /* TREE_VEC_ELT (method_vec, idx) = method; */
1115           if (method != TREE_VEC_ELT (method_vec, idx))
1116             TREE_VEC_ELT (method_vec, idx) =
1117               build_overload (method, TREE_VEC_ELT (method_vec, idx));
1118         }
1119       else
1120         {
1121           /* This is trickier.  We try to extend the TREE_VEC in-place,
1122              but if that does not work, we copy all its data to a new
1123              TREE_VEC that's large enough.  */
1124           struct obstack *ob = &class_obstack;
1125           tree *end = (tree *)obstack_next_free (ob);
1126
1127           if (end != TREE_VEC_END (method_vec))
1128             {
1129               ob = current_obstack;
1130               TREE_VEC_LENGTH (method_vec) += 1;
1131               TREE_VEC_ELT (method_vec, len) = NULL_TREE;
1132               method_vec = copy_node (method_vec);
1133               TREE_VEC_LENGTH (method_vec) -= 1;
1134             }
1135           else
1136             {
1137               tree tmp_vec = (tree) obstack_base (ob);
1138               if (obstack_room (ob) < sizeof (tree))
1139                 {
1140                   obstack_blank (ob, sizeof (struct tree_common)
1141                                  + tree_code_length[(int) TREE_VEC]
1142                                    * sizeof (char *)
1143                                  + len * sizeof (tree));
1144                   tmp_vec = (tree) obstack_base (ob);
1145                   bcopy ((char *) method_vec, (char *) tmp_vec,
1146                          (sizeof (struct tree_common)
1147                           + tree_code_length[(int) TREE_VEC] * sizeof (char *)
1148                           + (len-1) * sizeof (tree)));
1149                   method_vec = tmp_vec;
1150                 }
1151               else
1152                 obstack_blank (ob, sizeof (tree));
1153             }
1154
1155           obstack_finish (ob);
1156           TREE_VEC_ELT (method_vec, len) = method;
1157           TREE_VEC_LENGTH (method_vec) = len + 1;
1158           CLASSTYPE_METHOD_VEC (type) = method_vec;
1159
1160           if (TYPE_BINFO_BASETYPES (type) && CLASSTYPE_BASELINK_VEC (type))
1161             {
1162               /* ??? May be better to know whether these can be extended?  */
1163               tree baselink_vec = CLASSTYPE_BASELINK_VEC (type);
1164
1165               TREE_VEC_LENGTH (baselink_vec) += 1;
1166               CLASSTYPE_BASELINK_VEC (type) = copy_node (baselink_vec);
1167               TREE_VEC_LENGTH (baselink_vec) -= 1;
1168
1169               TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), len) = 0;
1170             }
1171         }
1172     }
1173   DECL_CONTEXT (method) = type;
1174   DECL_CLASS_CONTEXT (method) = type;
1175
1176   pop_obstacks ();
1177 }
1178
1179 /* Subroutines of finish_struct.  */
1180
1181 /* Look through the list of fields for this struct, deleting
1182    duplicates as we go.  This must be recursive to handle
1183    anonymous unions.
1184
1185    FIELD is the field which may not appear anywhere in FIELDS.
1186    FIELD_PTR, if non-null, is the starting point at which
1187    chained deletions may take place.
1188    The value returned is the first acceptable entry found
1189    in FIELDS.
1190
1191    Note that anonymous fields which are not of UNION_TYPE are
1192    not duplicates, they are just anonymous fields.  This happens
1193    when we have unnamed bitfields, for example.  */
1194
1195 static tree
1196 delete_duplicate_fields_1 (field, fields)
1197      tree field, fields;
1198 {
1199   tree x;
1200   tree prev = 0;
1201   if (DECL_NAME (field) == 0)
1202     {
1203       if (TREE_CODE (TREE_TYPE (field)) != UNION_TYPE)
1204         return fields;
1205
1206       for (x = TYPE_FIELDS (TREE_TYPE (field)); x; x = TREE_CHAIN (x))
1207         fields = delete_duplicate_fields_1 (x, fields);
1208       return fields;
1209     }
1210   else
1211     {
1212       for (x = fields; x; prev = x, x = TREE_CHAIN (x))
1213         {
1214           if (DECL_NAME (x) == 0)
1215             {
1216               if (TREE_CODE (TREE_TYPE (x)) != UNION_TYPE)
1217                 continue;
1218               TYPE_FIELDS (TREE_TYPE (x))
1219                 = delete_duplicate_fields_1 (field, TYPE_FIELDS (TREE_TYPE (x)));
1220               if (TYPE_FIELDS (TREE_TYPE (x)) == 0)
1221                 {
1222                   if (prev == 0)
1223                     fields = TREE_CHAIN (fields);
1224                   else
1225                     TREE_CHAIN (prev) = TREE_CHAIN (x);
1226                 }
1227             }
1228           else
1229             {
1230               if (DECL_NAME (field) == DECL_NAME (x))
1231                 {
1232                   if (TREE_CODE (field) == CONST_DECL
1233                       && TREE_CODE (x) == CONST_DECL)
1234                     cp_error_at ("duplicate enum value `%D'", x);
1235                   else if (TREE_CODE (field) == CONST_DECL
1236                            || TREE_CODE (x) == CONST_DECL)
1237                     cp_error_at ("duplicate field `%D' (as enum and non-enum)",
1238                                 x);
1239                   else if (DECL_DECLARES_TYPE_P (field)
1240                            && DECL_DECLARES_TYPE_P (x))
1241                     {
1242                       if (comptypes (TREE_TYPE (field), TREE_TYPE (x), 1))
1243                         continue;
1244                       cp_error_at ("duplicate nested type `%D'", x);
1245                     }
1246                   else if (DECL_DECLARES_TYPE_P (field)
1247                            || DECL_DECLARES_TYPE_P (x))
1248                     {
1249                       /* Hide tag decls.  */
1250                       if ((TREE_CODE (field) == TYPE_DECL
1251                            && DECL_ARTIFICIAL (field))
1252                           || (TREE_CODE (x) == TYPE_DECL
1253                               && DECL_ARTIFICIAL (x)))
1254                         continue;
1255                       cp_error_at ("duplicate field `%D' (as type and non-type)",
1256                                    x);
1257                     }
1258                   else
1259                     cp_error_at ("duplicate member `%D'", x);
1260                   if (prev == 0)
1261                     fields = TREE_CHAIN (fields);
1262                   else
1263                     TREE_CHAIN (prev) = TREE_CHAIN (x);
1264                 }
1265             }
1266         }
1267     }
1268   return fields;
1269 }
1270
1271 static void
1272 delete_duplicate_fields (fields)
1273      tree fields;
1274 {
1275   tree x;
1276   for (x = fields; x && TREE_CHAIN (x); x = TREE_CHAIN (x))
1277     TREE_CHAIN (x) = delete_duplicate_fields_1 (x, TREE_CHAIN (x));
1278 }
1279
1280 /* Change the access of FDECL to ACCESS in T.
1281    Return 1 if change was legit, otherwise return 0.  */
1282
1283 static int
1284 alter_access (t, fdecl, access)
1285      tree t;
1286      tree fdecl;
1287      tree access;
1288 {
1289   tree elem = purpose_member (t, DECL_ACCESS (fdecl));
1290   if (elem)
1291     {
1292       if (TREE_VALUE (elem) != access)
1293         {
1294           if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
1295             cp_error_at ("conflicting access specifications for method `%D', ignored", TREE_TYPE (fdecl));
1296           else
1297             error ("conflicting access specifications for field `%s', ignored",
1298                    IDENTIFIER_POINTER (DECL_NAME (fdecl)));
1299         }
1300       else
1301         {
1302           /* They're changing the access to the same thing they changed
1303              it to before.  That's OK.  */
1304           ;
1305         }
1306     }
1307   else
1308     {
1309       enforce_access (TYPE_BINFO (t), fdecl);
1310
1311       DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
1312       return 1;
1313     }
1314   return 0;
1315 }
1316
1317 /* If FOR_TYPE needs to reinitialize virtual function table pointers
1318    for TYPE's sub-objects, add such reinitializations to BASE_INIT_LIST.
1319    Returns BASE_INIT_LIST appropriately modified.  */
1320
1321 static tree
1322 maybe_fixup_vptrs (for_type, binfo, base_init_list)
1323      tree for_type, binfo, base_init_list;
1324 {
1325   /* Now reinitialize any slots that don't fall under our virtual
1326      function table pointer.  */
1327   tree vfields = CLASSTYPE_VFIELDS (BINFO_TYPE (binfo));
1328   while (vfields)
1329     {
1330       tree basetype = VF_NORMAL_VALUE (vfields)
1331         ? TYPE_MAIN_VARIANT (VF_NORMAL_VALUE (vfields))
1332           : VF_BASETYPE_VALUE (vfields);
1333
1334       tree base_binfo = get_binfo (basetype, for_type, 0);
1335       /* Punt until this is implemented.  */
1336       if (1 /* BINFO_MODIFIED (base_binfo) */)
1337         {
1338           tree base_offset = get_vfield_offset (base_binfo);
1339           if (! tree_int_cst_equal (base_offset, get_vfield_offset (TYPE_BINFO (for_type)))
1340               && ! tree_int_cst_equal (base_offset, get_vfield_offset (binfo)))
1341             base_init_list = tree_cons (error_mark_node, base_binfo,
1342                                         base_init_list);
1343         }
1344       vfields = TREE_CHAIN (vfields);
1345     }
1346   return base_init_list;
1347 }
1348
1349 /* If TYPE does not have a constructor, then the compiler must
1350    manually deal with all of the initialization this type requires.
1351
1352    If a base initializer exists only to fill in the virtual function
1353    table pointer, then we mark that fact with the TREE_VIRTUAL bit.
1354    This way, we avoid multiple initializations of the same field by
1355    each virtual function table up the class hierarchy.
1356
1357    Virtual base class pointers are not initialized here.  They are
1358    initialized only at the "top level" of object creation.  If we
1359    initialized them here, we would have to skip a lot of work.  */
1360
1361 static void
1362 build_class_init_list (type)
1363      tree type;
1364 {
1365   tree base_init_list = NULL_TREE;
1366   tree member_init_list = NULL_TREE;
1367
1368   /* Since we build member_init_list and base_init_list using
1369      tree_cons, backwards fields the all through work.  */
1370   tree x;
1371   tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
1372   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1373
1374   for (x = TYPE_FIELDS (type); x; x = TREE_CHAIN (x))
1375     {
1376       if (TREE_CODE (x) != FIELD_DECL)
1377         continue;
1378
1379       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (x))
1380           || DECL_INITIAL (x) != NULL_TREE)
1381         member_init_list = tree_cons (x, type, member_init_list);
1382     }
1383   member_init_list = nreverse (member_init_list);
1384
1385   /* We will end up doing this last.  Need special marker
1386      to avoid infinite regress.  */
1387   if (TYPE_VIRTUAL_P (type))
1388     {
1389       base_init_list = build_tree_list (error_mark_node, TYPE_BINFO (type));
1390       if (CLASSTYPE_NEEDS_VIRTUAL_REINIT (type) == 0)
1391         TREE_VALUE (base_init_list) = NULL_TREE;
1392       TREE_ADDRESSABLE (base_init_list) = 1;
1393     }
1394
1395   /* Each base class which needs to have initialization
1396      of some kind gets to make such requests known here.  */
1397   for (i = n_baseclasses-1; i >= 0; i--)
1398     {
1399       tree base_binfo = TREE_VEC_ELT (binfos, i);
1400       tree blist;
1401
1402       /* Don't initialize virtual baseclasses this way.  */
1403       if (TREE_VIA_VIRTUAL (base_binfo))
1404         continue;
1405
1406       if (TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (base_binfo)))
1407         {
1408           /* ...and the last shall come first...  */
1409           base_init_list = maybe_fixup_vptrs (type, base_binfo, base_init_list);
1410           base_init_list = tree_cons (NULL_TREE, base_binfo, base_init_list);
1411           continue;
1412         }
1413
1414       if ((blist = CLASSTYPE_BASE_INIT_LIST (BINFO_TYPE (base_binfo))) == NULL_TREE)
1415         /* Nothing to initialize.  */
1416         continue;
1417
1418       /* ...ditto...  */
1419       base_init_list = maybe_fixup_vptrs (type, base_binfo, base_init_list);
1420
1421       /* This is normally true for single inheritance.
1422          The win is we can shrink the chain of initializations
1423          to be done by only converting to the actual type
1424          we are interested in.  */
1425       if (TREE_VALUE (blist)
1426           && TREE_CODE (TREE_VALUE (blist)) == TREE_VEC
1427           && tree_int_cst_equal (BINFO_OFFSET (base_binfo),
1428                                  BINFO_OFFSET (TREE_VALUE (blist))))
1429         {
1430           if (base_init_list)
1431             {
1432               /* Does it do more than just fill in a
1433                  virtual function table pointer?  */
1434               if (! TREE_ADDRESSABLE (blist))
1435                 base_init_list = build_tree_list (blist, base_init_list);
1436               /* Can we get by just with the virtual function table
1437                  pointer that it fills in?  */
1438               else if (TREE_ADDRESSABLE (base_init_list)
1439                        && TREE_VALUE (base_init_list) == 0)
1440                 base_init_list = blist;
1441               /* Maybe, but it is not obvious as the previous case.  */
1442               else if (! CLASSTYPE_NEEDS_VIRTUAL_REINIT (type))
1443                 {
1444                   tree last = tree_last (base_init_list);
1445                   while (TREE_VALUE (last)
1446                          && TREE_CODE (TREE_VALUE (last)) == TREE_LIST)
1447                     last = tree_last (TREE_VALUE (last));
1448                   if (TREE_VALUE (last) == 0)
1449                     base_init_list = build_tree_list (blist, base_init_list);
1450                 }
1451             }
1452           else
1453             base_init_list = blist;
1454         }
1455       else
1456         {
1457           /* The function expand_aggr_init knows how to do the
1458              initialization of `basetype' without getting
1459              an explicit `blist'.  */
1460           if (base_init_list)
1461             base_init_list = tree_cons (NULL_TREE, base_binfo, base_init_list);
1462           else
1463             base_init_list = CLASSTYPE_BINFO_AS_LIST (BINFO_TYPE (base_binfo));
1464         }
1465     }
1466
1467   if (base_init_list)
1468     {
1469       if (member_init_list)
1470         CLASSTYPE_BASE_INIT_LIST (type) =
1471           build_tree_list (base_init_list, member_init_list);
1472       else
1473         CLASSTYPE_BASE_INIT_LIST (type) = base_init_list;
1474     }
1475   else if (member_init_list)
1476     CLASSTYPE_BASE_INIT_LIST (type) = member_init_list;
1477 }
1478 \f
1479 struct base_info
1480 {
1481   int has_virtual;
1482   int max_has_virtual;
1483   int n_ancestors;
1484   tree vfield;
1485   tree vfields;
1486   tree rtti;
1487   char cant_have_default_ctor;
1488   char cant_have_const_ctor;
1489   char no_const_asn_ref;
1490 };
1491
1492 /* Record information about type T derived from its base classes.
1493    Store most of that information in T itself, and place the
1494    remaining information in the struct BASE_INFO.
1495
1496    Propagate basetype offsets throughout the lattice.  Note that the
1497    lattice topped by T is really a pair: it's a DAG that gives the
1498    structure of the derivation hierarchy, and it's a list of the
1499    virtual baseclasses that appear anywhere in the DAG.  When a vbase
1500    type appears in the DAG, it's offset is 0, and it's children start
1501    their offsets from that point.  When a vbase type appears in the list,
1502    its offset is the offset it has in the hierarchy, and its children's
1503    offsets include that offset in theirs.
1504
1505    Returns the index of the first base class to have virtual functions,
1506    or -1 if no such base class.  */
1507
1508 static int
1509 finish_base_struct (t, b)
1510      tree t;
1511      struct base_info *b;
1512 {
1513   tree binfos = TYPE_BINFO_BASETYPES (t);
1514   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1515   int first_vfn_base_index = -1;
1516   bzero ((char *) b, sizeof (struct base_info));
1517
1518   for (i = 0; i < n_baseclasses; i++)
1519     {
1520       tree base_binfo = TREE_VEC_ELT (binfos, i);
1521       tree basetype = BINFO_TYPE (base_binfo);
1522
1523       /* Effective C++ rule 14.  We only need to check TYPE_VIRTUAL_P
1524          here because the case of virtual functions but non-virtual
1525          dtor is handled in finish_struct_1.  */
1526       if (warn_ecpp && ! TYPE_VIRTUAL_P (basetype)
1527           && TYPE_HAS_DESTRUCTOR (basetype))
1528         cp_warning ("base class `%#T' has a non-virtual destructor", basetype);
1529
1530       /* If the type of basetype is incomplete, then
1531          we already complained about that fact
1532          (and we should have fixed it up as well).  */
1533       if (TYPE_SIZE (basetype) == 0)
1534         {
1535           int j;
1536           /* The base type is of incomplete type.  It is
1537              probably best to pretend that it does not
1538              exist.  */
1539           if (i == n_baseclasses-1)
1540             TREE_VEC_ELT (binfos, i) = NULL_TREE;
1541           TREE_VEC_LENGTH (binfos) -= 1;
1542           n_baseclasses -= 1;
1543           for (j = i; j+1 < n_baseclasses; j++)
1544             TREE_VEC_ELT (binfos, j) = TREE_VEC_ELT (binfos, j+1);
1545         }
1546
1547       if (! TYPE_HAS_CONST_INIT_REF (basetype))
1548         b->cant_have_const_ctor = 1;
1549
1550       if (TYPE_HAS_CONSTRUCTOR (basetype)
1551           && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))
1552         {
1553           b->cant_have_default_ctor = 1;
1554           if (! TYPE_HAS_CONSTRUCTOR (t))
1555             {
1556               cp_pedwarn ("base `%T' with only non-default constructor",
1557                           basetype);
1558               cp_pedwarn ("in class without a constructor");
1559             }
1560         }
1561
1562       if (TYPE_HAS_ASSIGN_REF (basetype)
1563           && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
1564         b->no_const_asn_ref = 1;
1565
1566       b->n_ancestors += CLASSTYPE_N_SUPERCLASSES (basetype);
1567       TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1568       TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (basetype);
1569       TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
1570       TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);
1571
1572       TYPE_OVERLOADS_CALL_EXPR (t) |= TYPE_OVERLOADS_CALL_EXPR (basetype);
1573       TYPE_OVERLOADS_ARRAY_REF (t) |= TYPE_OVERLOADS_ARRAY_REF (basetype);
1574       TYPE_OVERLOADS_ARROW (t) |= TYPE_OVERLOADS_ARROW (basetype);
1575
1576       if (! TREE_VIA_VIRTUAL (base_binfo))
1577         CLASSTYPE_N_SUPERCLASSES (t) += 1;
1578
1579       if (TYPE_VIRTUAL_P (basetype))
1580         {
1581           /* Ensure that this is set from at least a virtual base
1582              class.  */
1583           if (b->rtti == NULL_TREE)
1584             b->rtti = CLASSTYPE_RTTI (basetype);
1585
1586           /* Don't borrow virtuals from virtual baseclasses.  */
1587           if (TREE_VIA_VIRTUAL (base_binfo))
1588             continue;
1589
1590           if (first_vfn_base_index < 0)
1591             {
1592               tree vfields;
1593               first_vfn_base_index = i;
1594
1595               /* Update these two, now that we know what vtable we are
1596                  going to extend.  This is so that we can add virtual
1597                  functions, and override them properly.  */
1598               TYPE_BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (basetype);
1599               TYPE_BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (basetype);
1600               b->has_virtual = CLASSTYPE_VSIZE (basetype);
1601               b->vfield = CLASSTYPE_VFIELD (basetype);
1602               b->vfields = copy_list (CLASSTYPE_VFIELDS (basetype));
1603               vfields = b->vfields;
1604               while (vfields)
1605                 {
1606                   if (VF_BINFO_VALUE (vfields) == NULL_TREE
1607                       || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1608                     {
1609                       tree value = VF_BASETYPE_VALUE (vfields);
1610                       if (DECL_NAME (CLASSTYPE_VFIELD (value))
1611                           == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1612                         VF_NORMAL_VALUE (b->vfields) = basetype;
1613                       else
1614                         VF_NORMAL_VALUE (b->vfields) = VF_NORMAL_VALUE (vfields);
1615                     }
1616                   vfields = TREE_CHAIN (vfields);
1617                 }
1618               CLASSTYPE_VFIELD (t) = b->vfield;
1619             }
1620           else
1621             {
1622               /* Only add unique vfields, and flatten them out as we go.  */
1623               tree vfields = CLASSTYPE_VFIELDS (basetype);
1624               while (vfields)
1625                 {
1626                   if (VF_BINFO_VALUE (vfields) == NULL_TREE
1627                       || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1628                     {
1629                       tree value = VF_BASETYPE_VALUE (vfields);
1630                       b->vfields = tree_cons (base_binfo, value, b->vfields);
1631                       if (DECL_NAME (CLASSTYPE_VFIELD (value))
1632                           == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1633                         VF_NORMAL_VALUE (b->vfields) = basetype;
1634                       else
1635                         VF_NORMAL_VALUE (b->vfields) = VF_NORMAL_VALUE (vfields);
1636                     }
1637                   vfields = TREE_CHAIN (vfields);
1638                 }
1639
1640               if (b->has_virtual == 0)
1641                 {
1642                   first_vfn_base_index = i;
1643
1644                   /* Update these two, now that we know what vtable we are
1645                      going to extend.  This is so that we can add virtual
1646                      functions, and override them properly.  */
1647                   TYPE_BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (basetype);
1648                   TYPE_BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (basetype);
1649                   b->has_virtual = CLASSTYPE_VSIZE (basetype);
1650                   b->vfield = CLASSTYPE_VFIELD (basetype);
1651                   CLASSTYPE_VFIELD (t) = b->vfield;
1652                   /* When we install the first one, set the VF_NORMAL_VALUE
1653                      to be the current class, as this it is the most derived
1654                      class.  Hopefully, this is not set to something else
1655                      later.  (mrs) */
1656                   vfields = b->vfields;
1657                   while (vfields)
1658                     {
1659                       if (DECL_NAME (CLASSTYPE_VFIELD (t))
1660                           == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1661                         {
1662                           VF_NORMAL_VALUE (vfields) = t;
1663                           /* There should only be one of them!  And it should
1664                              always be found, if we get into here.  (mrs)  */
1665                           break;
1666                         }
1667                       vfields = TREE_CHAIN (vfields);
1668                     }
1669                 }
1670             }
1671         }
1672     }
1673
1674   /* This comment said "Must come after offsets are fixed for all bases."
1675      Well, now this happens before the offsets are fixed, but it seems to
1676      work fine.  Guess we'll see...  */
1677   for (i = 0; i < n_baseclasses; i++)
1678     {
1679       tree base_binfo = TREE_VEC_ELT (binfos, i);
1680       tree basetype = BINFO_TYPE (base_binfo);
1681
1682       if (get_base_distance (basetype, t, 0, (tree*)0) == -2)
1683         {
1684           cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
1685                       basetype, t);
1686         }
1687     }
1688   {
1689     tree v = get_vbase_types (t);
1690
1691     for (; v; v = TREE_CHAIN (v))
1692       {
1693         tree basetype = BINFO_TYPE (v);
1694         if (get_base_distance (basetype, t, 0, (tree*)0) == -2)
1695           {
1696             if (extra_warnings)
1697               cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
1698                           basetype, t);
1699           }
1700       }
1701   }
1702
1703   {
1704     tree vfields;
1705     /* Find the base class with the largest number of virtual functions.  */
1706     for (vfields = b->vfields; vfields; vfields = TREE_CHAIN (vfields))
1707       {
1708         if (CLASSTYPE_VSIZE (VF_BASETYPE_VALUE (vfields)) > b->max_has_virtual)
1709           b->max_has_virtual = CLASSTYPE_VSIZE (VF_BASETYPE_VALUE (vfields));
1710         if (VF_DERIVED_VALUE (vfields)
1711             && CLASSTYPE_VSIZE (VF_DERIVED_VALUE (vfields)) > b->max_has_virtual)
1712           b->max_has_virtual = CLASSTYPE_VSIZE (VF_DERIVED_VALUE (vfields));
1713       }
1714   }
1715
1716   if (b->vfield == 0)
1717     /* If all virtual functions come only from virtual baseclasses.  */
1718     return -1;
1719
1720   /* Update the rtti base if we have a non-virtual base class version
1721      of it.  */
1722   b->rtti = CLASSTYPE_RTTI (BINFO_TYPE (TREE_VEC_ELT (binfos, first_vfn_base_index)));
1723
1724   return first_vfn_base_index;
1725 }
1726 \f
1727 /* Set memoizing fields and bits of T (and its variants) for later use.
1728    MAX_HAS_VIRTUAL is the largest size of any T's virtual function tables.  */
1729
1730 static void
1731 finish_struct_bits (t, max_has_virtual)
1732      tree t;
1733      int max_has_virtual;
1734 {
1735   int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1736
1737   /* Fix up variants (if any).  */
1738   tree variants = TYPE_NEXT_VARIANT (t);
1739   while (variants)
1740     {
1741       /* These fields are in the _TYPE part of the node, not in
1742          the TYPE_LANG_SPECIFIC component, so they are not shared.  */
1743       TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t);
1744       TYPE_HAS_DESTRUCTOR (variants) = TYPE_HAS_DESTRUCTOR (t);
1745       TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1746       TYPE_NEEDS_DESTRUCTOR (variants) = TYPE_NEEDS_DESTRUCTOR (t);
1747
1748       TYPE_USES_COMPLEX_INHERITANCE (variants) = TYPE_USES_COMPLEX_INHERITANCE (t);
1749       TYPE_VIRTUAL_P (variants) = TYPE_VIRTUAL_P (t);
1750       TYPE_USES_VIRTUAL_BASECLASSES (variants) = TYPE_USES_VIRTUAL_BASECLASSES (t);
1751       /* Copy whatever these are holding today.  */
1752       TYPE_MIN_VALUE (variants) = TYPE_MIN_VALUE (t);
1753       TYPE_MAX_VALUE (variants) = TYPE_MAX_VALUE (t);
1754       TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1755       TYPE_SIZE (variants) = TYPE_SIZE (t);
1756       variants = TYPE_NEXT_VARIANT (variants);
1757     }
1758
1759   if (n_baseclasses && max_has_virtual)
1760     {
1761       /* Done by `finish_struct' for classes without baseclasses.  */
1762       int might_have_abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (t) != 0;
1763       tree binfos = TYPE_BINFO_BASETYPES (t);
1764       for (i = n_baseclasses-1; i >= 0; i--)
1765         {
1766           might_have_abstract_virtuals
1767             |= (CLASSTYPE_ABSTRACT_VIRTUALS (BINFO_TYPE (TREE_VEC_ELT (binfos, i))) != 0);
1768           if (might_have_abstract_virtuals)
1769             break;
1770         }
1771       if (might_have_abstract_virtuals)
1772         {
1773           /* We use error_mark_node from override_one_vtable to signal
1774              an artificial abstract.  */
1775           if (CLASSTYPE_ABSTRACT_VIRTUALS (t) == error_mark_node)
1776             CLASSTYPE_ABSTRACT_VIRTUALS (t) = NULL_TREE;
1777           CLASSTYPE_ABSTRACT_VIRTUALS (t) = get_abstract_virtuals (t);
1778         }
1779     }
1780
1781   if (n_baseclasses)
1782     {
1783       /* Notice whether this class has type conversion functions defined.  */
1784       tree binfo = TYPE_BINFO (t);
1785       tree binfos = BINFO_BASETYPES (binfo);
1786       tree basetype;
1787
1788       for (i = n_baseclasses-1; i >= 0; i--)
1789         {
1790           basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
1791
1792           TYPE_HAS_CONVERSION (t) |= TYPE_HAS_CONVERSION (basetype);
1793           if (CLASSTYPE_MAX_DEPTH (basetype) >= CLASSTYPE_MAX_DEPTH (t))
1794             CLASSTYPE_MAX_DEPTH (t) = CLASSTYPE_MAX_DEPTH (basetype) + 1;
1795         }
1796     }
1797
1798   /* If this type has a copy constructor, force its mode to be BLKmode, and
1799      force its TREE_ADDRESSABLE bit to be nonzero.  This will cause it to
1800      be passed by invisible reference and prevent it from being returned in
1801      a register.
1802
1803      Also do this if the class has BLKmode but can still be returned in
1804      registers, since function_cannot_inline_p won't let us inline
1805      functions returning such a type.  This affects the HP-PA.  */
1806   if (! TYPE_HAS_TRIVIAL_INIT_REF (t)
1807       || (TYPE_MODE (t) == BLKmode && ! aggregate_value_p (t)
1808           && CLASSTYPE_NON_AGGREGATE (t)))
1809     {
1810       tree variants;
1811       DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
1812       for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1813         {
1814           TYPE_MODE (variants) = BLKmode;
1815           TREE_ADDRESSABLE (variants) = 1;
1816         }
1817     }
1818 }
1819
1820 /* Add FNDECL to the method_vec growing on the class_obstack.  Used by
1821    finish_struct_methods.  Note, FNDECL cannot be a constructor or
1822    destructor, those cases are handled by the caller.  */
1823
1824 static void
1825 grow_method (fndecl, method_vec_ptr)
1826      tree fndecl;
1827      tree *method_vec_ptr;
1828 {
1829   tree method_vec = (tree)obstack_base (&class_obstack);
1830
1831   /* Start off past the constructors and destructor.  */
1832   tree *testp = &TREE_VEC_ELT (method_vec, 2);
1833
1834   while (testp < (tree *) obstack_next_free (&class_obstack)
1835          && (*testp == NULL_TREE || DECL_NAME (OVL_CURRENT (*testp)) != DECL_NAME (fndecl)))
1836     testp++;
1837
1838   if (testp < (tree *) obstack_next_free (&class_obstack))
1839     *testp = build_overload (fndecl, *testp);
1840   else
1841     {
1842       obstack_ptr_grow (&class_obstack, fndecl);
1843       *method_vec_ptr = (tree)obstack_base (&class_obstack);
1844     }
1845 }
1846
1847 /* Warn about duplicate methods in fn_fields.  Also compact method
1848    lists so that lookup can be made faster.
1849
1850    Algorithm: Outer loop builds lists by method name.  Inner loop
1851    checks for redundant method names within a list.
1852
1853    Data Structure: List of method lists.  The outer list is a
1854    TREE_LIST, whose TREE_PURPOSE field is the field name and the
1855    TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs.  TREE_CHAIN
1856    links the entire list of methods for TYPE_METHODS.  Friends are
1857    chained in the same way as member functions (? TREE_CHAIN or
1858    DECL_CHAIN), but they live in the TREE_TYPE field of the outer
1859    list.  That allows them to be quickly deleted, and requires no
1860    extra storage.
1861
1862    If there are any constructors/destructors, they are moved to the
1863    front of the list.  This makes pushclass more efficient.
1864
1865    We also link each field which has shares a name with its baseclass
1866    to the head of the list of fields for that base class.  This allows
1867    us to reduce search time in places like `build_method_call' to
1868    consider only reasonably likely functions.  */
1869
1870 tree
1871 finish_struct_methods (t, fn_fields, nonprivate_method)
1872      tree t;
1873      tree fn_fields;
1874      int nonprivate_method;
1875 {
1876   tree method_vec;
1877   tree save_fn_fields = fn_fields;
1878   tree ctor_name = constructor_name (t);
1879   int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1880
1881   /* Now prepare to gather fn_fields into vector.  */
1882   struct obstack *ambient_obstack = current_obstack;
1883   current_obstack = &class_obstack;
1884   method_vec = make_tree_vec (2);
1885   current_obstack = ambient_obstack;
1886
1887   /* Now make this a live vector.  */
1888   obstack_free (&class_obstack, method_vec);
1889
1890   /* Save room for constructors and destructors.  */
1891   obstack_blank (&class_obstack, sizeof (struct tree_vec) + sizeof (struct tree *));
1892
1893   /* First fill in entry 0 with the constructors, entry 1 with destructors,
1894      and the next few with type conversion operators (if any).  */
1895
1896   for (; fn_fields; fn_fields = TREE_CHAIN (fn_fields))
1897     {
1898       tree fn_name = DECL_NAME (fn_fields);
1899
1900       /* Clear out this flag.
1901
1902          @@ Doug may figure out how to break
1903          @@ this with nested classes and friends.  */
1904       DECL_IN_AGGR_P (fn_fields) = 0;
1905
1906       /* Note here that a copy ctor is private, so we don't dare generate
1907          a default copy constructor for a class that has a member
1908          of this type without making sure they have access to it.  */
1909       if (fn_name == ctor_name)
1910         {
1911           tree parmtypes = FUNCTION_ARG_CHAIN (fn_fields);
1912           tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
1913
1914           if (TREE_CODE (parmtype) == REFERENCE_TYPE
1915               && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == t)
1916             {
1917               if (TREE_CHAIN (parmtypes) == NULL_TREE
1918                   || TREE_CHAIN (parmtypes) == void_list_node
1919                   || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
1920                 {
1921                   if (TREE_PROTECTED (fn_fields))
1922                     TYPE_HAS_NONPUBLIC_CTOR (t) = 1;
1923                   else if (TREE_PRIVATE (fn_fields))
1924                     TYPE_HAS_NONPUBLIC_CTOR (t) = 2;
1925                 }
1926             }
1927           if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fn_fields)))
1928             {
1929               /* Destructors go in slot 1.  */
1930               TREE_VEC_ELT (method_vec, 1) =
1931                 build_overload (fn_fields, TREE_VEC_ELT (method_vec, 1));
1932             }
1933           else
1934             {
1935               /* Constructors go in slot 0.  */
1936               TREE_VEC_ELT (method_vec, 0) =
1937                 build_overload (fn_fields, TREE_VEC_ELT (method_vec, 0));
1938             }
1939         }
1940       else if (IDENTIFIER_TYPENAME_P (fn_name))
1941         grow_method (fn_fields, &method_vec);
1942     }
1943
1944   fn_fields = save_fn_fields;
1945   for (; fn_fields; fn_fields = TREE_CHAIN (fn_fields))
1946     {
1947       tree fn_name = DECL_NAME (fn_fields);
1948
1949       if (fn_name == ctor_name || IDENTIFIER_TYPENAME_P (fn_name))
1950         continue;
1951
1952       if (fn_name == ansi_opname[(int) MODIFY_EXPR])
1953         {
1954           tree parmtype = TREE_VALUE (FUNCTION_ARG_CHAIN (fn_fields));
1955
1956           if (copy_assignment_arg_p (parmtype, DECL_VIRTUAL_P (fn_fields)))
1957             {
1958               if (TREE_PROTECTED (fn_fields))
1959                 TYPE_HAS_NONPUBLIC_ASSIGN_REF (t) = 1;
1960               else if (TREE_PRIVATE (fn_fields))
1961                 TYPE_HAS_NONPUBLIC_ASSIGN_REF (t) = 2;
1962             }
1963         }
1964
1965       grow_method (fn_fields, &method_vec);
1966     }
1967
1968   TREE_VEC_LENGTH (method_vec) = (tree *)obstack_next_free (&class_obstack)
1969     - (&TREE_VEC_ELT (method_vec, 0));
1970   obstack_finish (&class_obstack);
1971   CLASSTYPE_METHOD_VEC (t) = method_vec;
1972
1973   if (nonprivate_method == 0
1974       && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
1975       && DECL_FRIENDLIST (TYPE_MAIN_DECL (t)) == NULL_TREE)
1976     {
1977       tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
1978       for (i = 0; i < n_baseclasses; i++)
1979         if (TREE_VIA_PUBLIC (TREE_VEC_ELT (binfos, i))
1980             || TREE_VIA_PROTECTED (TREE_VEC_ELT (binfos, i)))
1981           {
1982             nonprivate_method = 1;
1983             break;
1984           }
1985       if (nonprivate_method == 0
1986           && warn_ctor_dtor_privacy)
1987         cp_warning ("all member functions in class `%T' are private", t);
1988     }
1989
1990   /* Warn if all destructors are private (in which case this class is
1991      effectively unusable.  */
1992   if (TYPE_HAS_DESTRUCTOR (t))
1993     {
1994       tree dtor = TREE_VEC_ELT (method_vec, 1);
1995
1996       /* Wild parse errors can cause this to happen.  */
1997       if (dtor == NULL_TREE)
1998         TYPE_HAS_DESTRUCTOR (t) = 0;
1999       else if (TREE_PRIVATE (dtor)
2000                && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
2001                && DECL_FRIENDLIST (TYPE_MAIN_DECL (t)) == NULL_TREE
2002                && warn_ctor_dtor_privacy)
2003         cp_warning ("`%#T' only defines a private destructor and has no friends",
2004                     t);
2005     }
2006
2007   /* Now for each member function (except for constructors and
2008      destructors), compute where member functions of the same
2009      name reside in base classes.  */
2010   if (n_baseclasses != 0
2011       && TREE_VEC_LENGTH (method_vec) > 2)
2012     {
2013       int len = TREE_VEC_LENGTH (method_vec);
2014       tree baselink_vec = make_tree_vec (len);
2015       int any_links = 0;
2016       tree baselink_binfo = build_tree_list (NULL_TREE, TYPE_BINFO (t));
2017
2018       for (i = 2; i < len; i++)
2019         {
2020           TREE_VEC_ELT (baselink_vec, i)
2021             = get_baselinks (baselink_binfo, t,
2022                              DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (method_vec, i))));
2023           if (TREE_VEC_ELT (baselink_vec, i) != 0)
2024             any_links = 1;
2025         }
2026       if (any_links != 0)
2027         CLASSTYPE_BASELINK_VEC (t) = baselink_vec;
2028       else
2029         obstack_free (current_obstack, baselink_vec);
2030     }
2031
2032   return method_vec;
2033 }
2034
2035 /* Emit error when a duplicate definition of a type is seen.  Patch up.  */
2036
2037 void
2038 duplicate_tag_error (t)
2039      tree t;
2040 {
2041   cp_error ("redefinition of `%#T'", t);
2042   cp_error_at ("previous definition here", t);
2043
2044   /* Pretend we haven't defined this type.  */
2045
2046   /* All of the component_decl's were TREE_CHAINed together in the parser.
2047      finish_struct_methods walks these chains and assembles all methods with
2048      the same base name into DECL_CHAINs. Now we don't need the parser chains
2049      anymore, so we unravel them.  */
2050
2051   /* This used to be in finish_struct, but it turns out that the
2052      TREE_CHAIN is used by dbxout_type_methods and perhaps some other
2053      things...  */
2054   if (CLASSTYPE_METHOD_VEC (t))
2055     {
2056       tree method_vec = CLASSTYPE_METHOD_VEC (t);
2057       int i, len  = TREE_VEC_LENGTH (method_vec);
2058       for (i = 0; i < len; i++)
2059         {
2060           tree unchain = TREE_VEC_ELT (method_vec, i);
2061           while (unchain != NULL_TREE)
2062             {
2063               TREE_CHAIN (OVL_CURRENT (unchain)) = NULL_TREE;
2064               unchain = OVL_NEXT (unchain);
2065             }
2066         }
2067     }
2068
2069   if (TYPE_LANG_SPECIFIC (t))
2070     {
2071       tree as_list = CLASSTYPE_AS_LIST (t);
2072       tree binfo = TYPE_BINFO (t);
2073       tree binfo_as_list = CLASSTYPE_BINFO_AS_LIST (t);
2074       int interface_only = CLASSTYPE_INTERFACE_ONLY (t);
2075       int interface_unknown = CLASSTYPE_INTERFACE_UNKNOWN (t);
2076
2077       bzero ((char *) TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type));
2078       BINFO_BASETYPES(binfo) = NULL_TREE;
2079
2080       CLASSTYPE_AS_LIST (t) = as_list;
2081       TYPE_BINFO (t) = binfo;
2082       CLASSTYPE_BINFO_AS_LIST (t) = binfo_as_list;
2083       CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
2084       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
2085       TYPE_REDEFINED (t) = 1;
2086     }
2087   TYPE_SIZE (t) = NULL_TREE;
2088   TYPE_MODE (t) = VOIDmode;
2089   TYPE_FIELDS (t) = NULL_TREE;
2090   TYPE_METHODS (t) = NULL_TREE;
2091   TYPE_VFIELD (t) = NULL_TREE;
2092   TYPE_CONTEXT (t) = NULL_TREE;
2093 }
2094
2095 /* finish up all new vtables.  */
2096
2097 static void
2098 finish_vtbls (binfo, do_self, t)
2099      tree binfo;
2100      int do_self;
2101      tree t;
2102 {
2103   tree binfos = BINFO_BASETYPES (binfo);
2104   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2105
2106   /* Should we use something besides CLASSTYPE_VFIELDS? */
2107   if (do_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2108     {
2109       if (BINFO_NEW_VTABLE_MARKED (binfo))
2110         {
2111           tree decl, context;
2112
2113           decl = BINFO_VTABLE (binfo);
2114           context = DECL_CONTEXT (decl);
2115           DECL_CONTEXT (decl) = 0;
2116           if (write_virtuals >= 0
2117               && DECL_INITIAL (decl) != BINFO_VIRTUALS (binfo))
2118             DECL_INITIAL (decl) = build_nt (CONSTRUCTOR, NULL_TREE,
2119                                             BINFO_VIRTUALS (binfo));
2120           cp_finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0, 0);
2121           DECL_CONTEXT (decl) = context;
2122         }
2123       CLEAR_BINFO_NEW_VTABLE_MARKED (binfo);
2124     }
2125
2126   for (i = 0; i < n_baselinks; i++)
2127     {
2128       tree base_binfo = TREE_VEC_ELT (binfos, i);
2129       int is_not_base_vtable
2130         = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2131       if (TREE_VIA_VIRTUAL (base_binfo))
2132         {
2133           base_binfo = binfo_member (BINFO_TYPE (base_binfo), CLASSTYPE_VBASECLASSES (t));
2134         }
2135       finish_vtbls (base_binfo, is_not_base_vtable, t);
2136     }
2137 }
2138
2139 /* True if we should override the given BASE_FNDECL with the given
2140    FNDECL.  */
2141
2142 static int
2143 overrides (fndecl, base_fndecl)
2144      tree fndecl, base_fndecl;
2145 {
2146   /* Destructors have special names.  */
2147   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (base_fndecl))
2148       && DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
2149     return 1;
2150   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (base_fndecl))
2151       || DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
2152     return 0;
2153   if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl))
2154     {
2155       tree types, base_types;
2156 #if 0
2157       retypes = TREE_TYPE (TREE_TYPE (fndecl));
2158       base_retypes = TREE_TYPE (TREE_TYPE (base_fndecl));
2159 #endif
2160       types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2161       base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
2162       if ((TYPE_READONLY (TREE_TYPE (TREE_VALUE (base_types)))
2163            == TYPE_READONLY (TREE_TYPE (TREE_VALUE (types))))
2164           && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types), 3))
2165         return 1;
2166     }
2167   return 0;
2168 }
2169
2170 static tree
2171 get_class_offset_1 (parent, binfo, context, t, fndecl)
2172      tree parent, binfo, context, t, fndecl;
2173 {
2174   tree binfos = BINFO_BASETYPES (binfo);
2175   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2176   tree rval = NULL_TREE;
2177
2178   if (binfo == parent)
2179     return error_mark_node;
2180
2181   for (i = 0; i < n_baselinks; i++)
2182     {
2183       tree base_binfo = TREE_VEC_ELT (binfos, i);
2184       tree nrval;
2185
2186       if (TREE_VIA_VIRTUAL (base_binfo))
2187         base_binfo = binfo_member (BINFO_TYPE (base_binfo),
2188                                    CLASSTYPE_VBASECLASSES (t));
2189       nrval = get_class_offset_1 (parent, base_binfo, context, t, fndecl);
2190       /* See if we have a new value */
2191       if (nrval && (nrval != error_mark_node || rval==0))
2192         {
2193           /* Only compare if we have two offsets */
2194           if (rval && rval != error_mark_node
2195               && ! tree_int_cst_equal (nrval, rval))
2196             {
2197               /* Only give error if the two offsets are different */
2198               error ("every virtual function must have a unique final overrider");
2199               cp_error ("  found two (or more) `%T' class subobjects in `%T'", context, t);
2200               cp_error ("  with virtual `%D' from virtual base class", fndecl);
2201               return rval;
2202             }
2203           rval = nrval;
2204         }
2205
2206       if (rval && BINFO_TYPE (binfo) == context)
2207         {
2208           my_friendly_assert (rval == error_mark_node
2209                               || tree_int_cst_equal (rval, BINFO_OFFSET (binfo)), 999);
2210           rval = BINFO_OFFSET (binfo);
2211         }
2212     }
2213   return rval;
2214 }
2215
2216 /* Get the offset to the CONTEXT subobject that is related to the
2217    given BINFO.  */
2218
2219 static tree
2220 get_class_offset (context, t, binfo, fndecl)
2221      tree context, t, binfo, fndecl;
2222 {
2223   tree first_binfo = binfo;
2224   tree offset;
2225   int i;
2226
2227   if (context == t)
2228     return integer_zero_node;
2229
2230   if (BINFO_TYPE (binfo) == context)
2231     return BINFO_OFFSET (binfo);
2232
2233   /* Check less derived binfos first.  */
2234   while (BINFO_BASETYPES (binfo)
2235          && (i=CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo))) != -1)
2236     {
2237       tree binfos = BINFO_BASETYPES (binfo);
2238       binfo = TREE_VEC_ELT (binfos, i);
2239       if (BINFO_TYPE (binfo) == context)
2240         return BINFO_OFFSET (binfo);
2241     }
2242
2243   /* Ok, not found in the less derived binfos, now check the more
2244      derived binfos.  */
2245   offset = get_class_offset_1 (first_binfo, TYPE_BINFO (t), context, t, fndecl);
2246   if (offset==0 || TREE_CODE (offset) != INTEGER_CST)
2247     my_friendly_abort (999);    /* we have to find it.  */
2248   return offset;
2249 }
2250
2251 /* Skip RTTI information at the front of the virtual list.  */
2252
2253 unsigned HOST_WIDE_INT
2254 skip_rtti_stuff (virtuals)
2255      tree *virtuals;
2256 {
2257   int n;
2258
2259   n = 0;
2260   if (*virtuals)
2261     {
2262       /* We always reserve a slot for the offset/tdesc entry.  */
2263       ++n;
2264       *virtuals = TREE_CHAIN (*virtuals);
2265     }
2266   if (flag_vtable_thunks && *virtuals)
2267     {
2268       /* The second slot is reserved for the tdesc pointer when thunks
2269          are used.  */
2270       ++n;
2271       *virtuals = TREE_CHAIN (*virtuals);
2272     }
2273   return n;
2274 }
2275
2276 static void
2277 modify_one_vtable (binfo, t, fndecl, pfn)
2278      tree binfo, t, fndecl, pfn;
2279 {
2280   tree virtuals = BINFO_VIRTUALS (binfo);
2281   unsigned HOST_WIDE_INT n;
2282
2283   /* update rtti entry */
2284   if (flag_rtti)
2285     {
2286       if (binfo == TYPE_BINFO (t))
2287         {
2288           if (! BINFO_NEW_VTABLE_MARKED (binfo))
2289             build_vtable (TYPE_BINFO (DECL_CONTEXT (CLASSTYPE_VFIELD (t))), t);
2290         }
2291       else
2292         {
2293           if (! BINFO_NEW_VTABLE_MARKED (binfo))
2294             prepare_fresh_vtable (binfo, t);
2295         }
2296     }
2297   if (fndecl == NULL_TREE)
2298     return;
2299
2300   n = skip_rtti_stuff (&virtuals);
2301
2302   while (virtuals)
2303     {
2304       tree current_fndecl = TREE_VALUE (virtuals);
2305       current_fndecl = FNADDR_FROM_VTABLE_ENTRY (current_fndecl);
2306       current_fndecl = TREE_OPERAND (current_fndecl, 0);
2307       if (current_fndecl && overrides (fndecl, current_fndecl))
2308         {
2309           tree base_offset, offset;
2310           tree context = DECL_CLASS_CONTEXT (fndecl);
2311           tree vfield = CLASSTYPE_VFIELD (t);
2312           tree this_offset;
2313
2314           offset = get_class_offset (context, t, binfo, fndecl);
2315
2316           /* Find the right offset for the this pointer based on the
2317              base class we just found.  We have to take into
2318              consideration the virtual base class pointers that we
2319              stick in before the virtual function table pointer.
2320
2321              Also, we want just the delta between the most base class
2322              that we derived this vfield from and us.  */
2323           base_offset = size_binop (PLUS_EXPR,
2324                                     get_derived_offset (binfo, DECL_CONTEXT (current_fndecl)),
2325                                     BINFO_OFFSET (binfo));
2326           this_offset = ssize_binop (MINUS_EXPR, offset, base_offset);
2327
2328           /* Make sure we can modify the derived association with immunity.  */
2329           if (TREE_USED (binfo))
2330             my_friendly_assert (0, 999);
2331
2332           if (binfo == TYPE_BINFO (t))
2333             {
2334               /* In this case, it is *type*'s vtable we are modifying.
2335                  We start with the approximation that it's vtable is that
2336                  of the immediate base class.  */
2337               if (! BINFO_NEW_VTABLE_MARKED (binfo))
2338                 build_vtable (TYPE_BINFO (DECL_CONTEXT (vfield)), t);
2339             }
2340           else
2341             {
2342               /* This is our very own copy of `basetype' to play with.
2343                  Later, we will fill in all the virtual functions
2344                  that override the virtual functions in these base classes
2345                  which are not defined by the current type.  */
2346               if (! BINFO_NEW_VTABLE_MARKED (binfo))
2347                 prepare_fresh_vtable (binfo, t);
2348             }
2349
2350 #ifdef NOTQUITE
2351           cp_warning ("in %D", DECL_NAME (BINFO_VTABLE (binfo)));
2352 #endif
2353           modify_vtable_entry (get_vtable_entry_n (BINFO_VIRTUALS (binfo), n),
2354                                build_vtable_entry (this_offset, pfn),
2355                                fndecl);
2356         }
2357       ++n;
2358       virtuals = TREE_CHAIN (virtuals);
2359     }
2360 }
2361
2362 /* These are the ones that are not through virtual base classes.  */
2363
2364 static void
2365 modify_all_direct_vtables (binfo, do_self, t, fndecl, pfn)
2366      tree binfo;
2367      int do_self;
2368      tree t, fndecl, pfn;
2369 {
2370   tree binfos = BINFO_BASETYPES (binfo);
2371   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2372
2373   /* Should we use something besides CLASSTYPE_VFIELDS? */
2374   if (do_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2375     {
2376       modify_one_vtable (binfo, t, fndecl, pfn);
2377     }
2378
2379   for (i = 0; i < n_baselinks; i++)
2380     {
2381       tree base_binfo = TREE_VEC_ELT (binfos, i);
2382       int is_not_base_vtable
2383         = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2384       if (! TREE_VIA_VIRTUAL (base_binfo))
2385         modify_all_direct_vtables (base_binfo, is_not_base_vtable, t, fndecl, pfn);
2386     }
2387 }
2388
2389 /* Fixup all the delta entries in this one vtable that need updating.  */
2390
2391 static void
2392 fixup_vtable_deltas1 (binfo, t)
2393      tree binfo, t;
2394 {
2395   tree virtuals = BINFO_VIRTUALS (binfo);
2396   unsigned HOST_WIDE_INT n;
2397
2398   n = skip_rtti_stuff (&virtuals);
2399
2400   while (virtuals)
2401     {
2402       tree fndecl = TREE_VALUE (virtuals);
2403       tree pfn = FNADDR_FROM_VTABLE_ENTRY (fndecl);
2404       tree delta = DELTA_FROM_VTABLE_ENTRY (fndecl);
2405       fndecl = TREE_OPERAND (pfn, 0);
2406       if (fndecl)
2407         {
2408           tree base_offset, offset;
2409           tree context = DECL_CLASS_CONTEXT (fndecl);
2410           tree vfield = CLASSTYPE_VFIELD (t);
2411           tree this_offset;
2412
2413           offset = get_class_offset (context, t, binfo, fndecl);
2414
2415           /* Find the right offset for the this pointer based on the
2416              base class we just found.  We have to take into
2417              consideration the virtual base class pointers that we
2418              stick in before the virtual function table pointer.
2419
2420              Also, we want just the delta between the most base class
2421              that we derived this vfield from and us.  */
2422           base_offset = size_binop (PLUS_EXPR,
2423                                     get_derived_offset (binfo,
2424                                                         DECL_CONTEXT (fndecl)),
2425                                     BINFO_OFFSET (binfo));
2426           this_offset = ssize_binop (MINUS_EXPR, offset, base_offset);
2427
2428           if (! tree_int_cst_equal (this_offset, delta))
2429             {
2430               /* Make sure we can modify the derived association with immunity.  */
2431               if (TREE_USED (binfo))
2432                 my_friendly_assert (0, 999);
2433
2434               if (binfo == TYPE_BINFO (t))
2435                 {
2436                   /* In this case, it is *type*'s vtable we are modifying.
2437                      We start with the approximation that it's vtable is that
2438                      of the immediate base class.  */
2439                   if (! BINFO_NEW_VTABLE_MARKED (binfo))
2440                     build_vtable (TYPE_BINFO (DECL_CONTEXT (vfield)), t);
2441                 }
2442               else
2443                 {
2444                   /* This is our very own copy of `basetype' to play with.
2445                      Later, we will fill in all the virtual functions
2446                      that override the virtual functions in these base classes
2447                      which are not defined by the current type.  */
2448                   if (! BINFO_NEW_VTABLE_MARKED (binfo))
2449                     prepare_fresh_vtable (binfo, t);
2450                 }
2451
2452               modify_vtable_entry (get_vtable_entry_n (BINFO_VIRTUALS (binfo), n),
2453                                    build_vtable_entry (this_offset, pfn),
2454                                    fndecl);
2455             }
2456         }
2457       ++n;
2458       virtuals = TREE_CHAIN (virtuals);
2459     }
2460 }
2461
2462 /* Fixup all the delta entries in all the direct vtables that need updating.
2463    This happens when we have non-overridden virtual functions from a
2464    virtual base class, that are at a different offset, in the new
2465    hierarchy, because the layout of the virtual bases has changed.  */
2466
2467 static void
2468 fixup_vtable_deltas (binfo, init_self, t)
2469      tree binfo;
2470      int init_self;
2471      tree t;
2472 {
2473   tree binfos = BINFO_BASETYPES (binfo);
2474   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2475
2476   for (i = 0; i < n_baselinks; i++)
2477     {
2478       tree base_binfo = TREE_VEC_ELT (binfos, i);
2479       int is_not_base_vtable
2480         = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2481       if (! TREE_VIA_VIRTUAL (base_binfo))
2482         fixup_vtable_deltas (base_binfo, is_not_base_vtable, t);
2483     }
2484   /* Should we use something besides CLASSTYPE_VFIELDS? */
2485   if (init_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2486     {
2487       fixup_vtable_deltas1 (binfo, t);
2488     }
2489 }
2490
2491 /* These are the ones that are through virtual base classes.  */
2492
2493 static void
2494 modify_all_indirect_vtables (binfo, do_self, via_virtual, t, fndecl, pfn)
2495      tree binfo;
2496      int do_self, via_virtual;
2497      tree t, fndecl, pfn;
2498 {
2499   tree binfos = BINFO_BASETYPES (binfo);
2500   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2501
2502   /* Should we use something besides CLASSTYPE_VFIELDS? */
2503   if (do_self && via_virtual && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2504     {
2505       modify_one_vtable (binfo, t, fndecl, pfn);
2506     }
2507
2508   for (i = 0; i < n_baselinks; i++)
2509     {
2510       tree base_binfo = TREE_VEC_ELT (binfos, i);
2511       int is_not_base_vtable
2512         = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2513       if (TREE_VIA_VIRTUAL (base_binfo))
2514         {
2515           via_virtual = 1;
2516           base_binfo = binfo_member (BINFO_TYPE (base_binfo), CLASSTYPE_VBASECLASSES (t));
2517         }
2518       modify_all_indirect_vtables (base_binfo, is_not_base_vtable, via_virtual, t, fndecl, pfn);
2519     }
2520 }
2521
2522 static void
2523 modify_all_vtables (t, fndecl, vfn)
2524      tree t, fndecl, vfn;
2525 {
2526   /* Do these first, so that we will make use of any non-virtual class's
2527      vtable, over a virtual classes vtable.  */
2528   modify_all_direct_vtables (TYPE_BINFO (t), 1, t, fndecl, vfn);
2529   if (TYPE_USES_VIRTUAL_BASECLASSES (t))
2530     modify_all_indirect_vtables (TYPE_BINFO (t), 1, 0, t, fndecl, vfn);
2531 }
2532
2533 /* Here, we already know that they match in every respect.
2534    All we have to check is where they had their declarations.  */
2535
2536 static int
2537 strictly_overrides (fndecl1, fndecl2)
2538      tree fndecl1, fndecl2;
2539 {
2540   int distance = get_base_distance (DECL_CLASS_CONTEXT (fndecl2),
2541                                     DECL_CLASS_CONTEXT (fndecl1),
2542                                     0, (tree *)0);
2543   if (distance == -2 || distance > 0)
2544     return 1;
2545   return 0;
2546 }
2547
2548 /* Merge overrides for one vtable.
2549    If we want to merge in same function, we are fine.
2550    else
2551      if one has a DECL_CLASS_CONTEXT that is a parent of the
2552        other, than choose the more derived one
2553      else
2554        potentially ill-formed (see 10.3 [class.virtual])
2555        we have to check later to see if there was an
2556        override in this class.  If there was ok, if not
2557        then it is ill-formed.  (mrs)
2558
2559    We take special care to reuse a vtable, if we can.  */
2560
2561 static void
2562 override_one_vtable (binfo, old, t)
2563      tree binfo, old, t;
2564 {
2565   tree virtuals = BINFO_VIRTUALS (binfo);
2566   tree old_virtuals = BINFO_VIRTUALS (old);
2567   enum { REUSE_NEW, REUSE_OLD, UNDECIDED, NEITHER } choose = UNDECIDED;
2568
2569   /* If we have already committed to modifying it, then don't try and
2570      reuse another vtable.  */
2571   if (BINFO_NEW_VTABLE_MARKED (binfo))
2572     choose = NEITHER;
2573
2574   skip_rtti_stuff (&virtuals);
2575   skip_rtti_stuff (&old_virtuals);
2576
2577   while (virtuals)
2578     {
2579       tree fndecl = TREE_VALUE (virtuals);
2580       tree old_fndecl = TREE_VALUE (old_virtuals);
2581       fndecl = FNADDR_FROM_VTABLE_ENTRY (fndecl);
2582       old_fndecl = FNADDR_FROM_VTABLE_ENTRY (old_fndecl);
2583       fndecl = TREE_OPERAND (fndecl, 0);
2584       old_fndecl = TREE_OPERAND (old_fndecl, 0);
2585       /* First check to see if they are the same.  */
2586       if (DECL_ASSEMBLER_NAME (fndecl) == DECL_ASSEMBLER_NAME (old_fndecl))
2587         {
2588           /* No need to do anything.  */
2589         }
2590       else if (strictly_overrides (fndecl, old_fndecl))
2591         {
2592           if (choose == UNDECIDED)
2593             choose = REUSE_NEW;
2594           else if (choose == REUSE_OLD)
2595             {
2596               choose = NEITHER;
2597               if (! BINFO_NEW_VTABLE_MARKED (binfo))
2598                 {
2599                   prepare_fresh_vtable (binfo, t);
2600                   override_one_vtable (binfo, old, t);
2601                   return;
2602                 }
2603             }
2604         }
2605       else if (strictly_overrides (old_fndecl, fndecl))
2606         {
2607           if (choose == UNDECIDED)
2608             choose = REUSE_OLD;
2609           else if (choose == REUSE_NEW)
2610             {
2611               choose = NEITHER;
2612               if (! BINFO_NEW_VTABLE_MARKED (binfo))
2613                 {
2614                   prepare_fresh_vtable (binfo, t);
2615                   override_one_vtable (binfo, old, t);
2616                   return;
2617                 }
2618               TREE_VALUE (virtuals) = TREE_VALUE (old_virtuals);
2619             }
2620           else if (choose == NEITHER)
2621             {
2622               TREE_VALUE (virtuals) = TREE_VALUE (old_virtuals);
2623             }
2624         }
2625       else
2626         {
2627           choose = NEITHER;
2628           if (! BINFO_NEW_VTABLE_MARKED (binfo))
2629             {
2630               prepare_fresh_vtable (binfo, t);
2631               override_one_vtable (binfo, old, t);
2632               return;
2633             }
2634           {
2635             /* This MUST be overridden, or the class is ill-formed.  */
2636             /* For now, we just make it abstract.  */
2637             tree fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
2638             tree vfn;
2639
2640             fndecl = copy_node (fndecl);
2641             copy_lang_decl (fndecl);
2642             DECL_ABSTRACT_VIRTUAL_P (fndecl) = 1;
2643             DECL_NEEDS_FINAL_OVERRIDER_P (fndecl) = 1;
2644             /* Make sure we search for it later.  */
2645             if (! CLASSTYPE_ABSTRACT_VIRTUALS (t))
2646               CLASSTYPE_ABSTRACT_VIRTUALS (t) = error_mark_node;
2647
2648             vfn = build1 (ADDR_EXPR, vfunc_ptr_type_node, fndecl);
2649             TREE_CONSTANT (vfn) = 1;
2650
2651             /* We can use integer_zero_node, as we will core dump
2652                if this is used anyway.  */
2653             TREE_VALUE (virtuals) = build_vtable_entry (integer_zero_node, vfn);
2654           }
2655         }
2656       virtuals = TREE_CHAIN (virtuals);
2657       old_virtuals = TREE_CHAIN (old_virtuals);
2658     }
2659
2660   /* Let's reuse the old vtable.  */
2661   if (choose == REUSE_OLD)
2662     {
2663       BINFO_VTABLE (binfo) = BINFO_VTABLE (old);
2664       BINFO_VIRTUALS (binfo) = BINFO_VIRTUALS (old);
2665     }
2666 }
2667
2668 /* Merge in overrides for virtual bases.
2669    BINFO is the hierarchy we want to modify, and OLD has the potential
2670    overrides.  */
2671
2672 static void
2673 merge_overrides (binfo, old, do_self, t)
2674      tree binfo, old;
2675      int do_self;
2676      tree t;
2677 {
2678   tree binfos = BINFO_BASETYPES (binfo);
2679   tree old_binfos = BINFO_BASETYPES (old);
2680   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2681
2682   /* Should we use something besides CLASSTYPE_VFIELDS? */
2683   if (do_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2684     {
2685       override_one_vtable (binfo, old, t);
2686     }
2687
2688   for (i = 0; i < n_baselinks; i++)
2689     {
2690       tree base_binfo = TREE_VEC_ELT (binfos, i);
2691       tree old_base_binfo = TREE_VEC_ELT (old_binfos, i);
2692       int is_not_base_vtable
2693         = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2694       if (! TREE_VIA_VIRTUAL (base_binfo))
2695         merge_overrides (base_binfo, old_base_binfo, is_not_base_vtable, t);
2696     }
2697 }
2698
2699 /* Get the base virtual function declarations in T that are either
2700    overridden or hidden by FNDECL as a list.  We set TREE_PURPOSE with
2701    the overrider/hider.  */
2702
2703 static tree
2704 get_basefndecls (fndecl, t)
2705      tree fndecl, t;
2706 {
2707   tree methods = TYPE_METHODS (t);
2708   tree base_fndecls = NULL_TREE;
2709   tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
2710   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2711
2712   while (methods)
2713     {
2714       if (TREE_CODE (methods) == FUNCTION_DECL
2715           && DECL_VINDEX (methods) != NULL_TREE
2716           && DECL_NAME (fndecl) == DECL_NAME (methods))
2717         base_fndecls = temp_tree_cons (fndecl, methods, base_fndecls);
2718
2719       methods = TREE_CHAIN (methods);
2720     }
2721
2722   if (base_fndecls)
2723     return base_fndecls;
2724
2725   for (i = 0; i < n_baseclasses; i++)
2726     {
2727       tree base_binfo = TREE_VEC_ELT (binfos, i);
2728       tree basetype = BINFO_TYPE (base_binfo);
2729
2730       base_fndecls = chainon (get_basefndecls (fndecl, basetype),
2731                               base_fndecls);
2732     }
2733
2734   return base_fndecls;
2735 }
2736
2737 /* Mark the functions that have been hidden with their overriders.
2738    Since we start out with all functions already marked with a hider,
2739    no need to mark functions that are just hidden.  */
2740
2741 static void
2742 mark_overriders (fndecl, base_fndecls)
2743      tree fndecl, base_fndecls;
2744 {
2745   while (base_fndecls)
2746     {
2747       if (overrides (TREE_VALUE (base_fndecls), fndecl))
2748         TREE_PURPOSE (base_fndecls) = fndecl;
2749
2750       base_fndecls = TREE_CHAIN (base_fndecls);
2751     }
2752 }
2753
2754 /* If this declaration supersedes the declaration of
2755    a method declared virtual in the base class, then
2756    mark this field as being virtual as well.  */
2757
2758 static void
2759 check_for_override (decl, ctype)
2760      tree decl, ctype;
2761 {
2762   tree binfos = BINFO_BASETYPES (TYPE_BINFO (ctype));
2763   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2764   int virtualp = DECL_VIRTUAL_P (decl);
2765
2766   for (i = 0; i < n_baselinks; i++)
2767     {
2768       tree base_binfo = TREE_VEC_ELT (binfos, i);
2769       if (TYPE_VIRTUAL_P (BINFO_TYPE (base_binfo))
2770           || flag_all_virtual == 1)
2771         {
2772           tree tmp = get_matching_virtual
2773             (base_binfo, decl,
2774              DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)));
2775           if (tmp)
2776             {
2777               /* If this function overrides some virtual in some base
2778                  class, then the function itself is also necessarily
2779                  virtual, even if the user didn't explicitly say so.  */
2780               DECL_VIRTUAL_P (decl) = 1;
2781
2782               /* The TMP we really want is the one from the deepest
2783                  baseclass on this path, taking care not to
2784                  duplicate if we have already found it (via another
2785                  path to its virtual baseclass.  */
2786               if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
2787                 {
2788                   cp_error_at ("method `%D' may not be declared static",
2789                                decl);
2790                   cp_error_at ("(since `%D' declared virtual in base class.)",
2791                                tmp);
2792                   break;
2793                 }
2794               virtualp = 1;
2795
2796 #if 0 /* The signature of an overriding function is not changed.  */
2797               {
2798                 /* The argument types may have changed...  */
2799                 tree type = TREE_TYPE (decl);
2800                 tree argtypes = TYPE_ARG_TYPES (type);
2801                 tree base_variant = TREE_TYPE (TREE_VALUE (argtypes));
2802                 tree raises = TYPE_RAISES_EXCEPTIONS (type);
2803
2804                 argtypes = commonparms (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (tmp))),
2805                                         TREE_CHAIN (argtypes));
2806                 /* But the return type has not.  */
2807                 type = build_cplus_method_type (base_variant, TREE_TYPE (type), argtypes);
2808                 if (raises)
2809                   type = build_exception_variant (type, raises);
2810                 TREE_TYPE (decl) = type;
2811               }
2812 #endif
2813               DECL_VINDEX (decl)
2814                 = tree_cons (NULL_TREE, tmp, DECL_VINDEX (decl));
2815               break;
2816             }
2817         }
2818     }
2819   if (virtualp)
2820     {
2821       if (DECL_VINDEX (decl) == NULL_TREE)
2822         DECL_VINDEX (decl) = error_mark_node;
2823       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2824     }
2825 }
2826
2827 /* Warn about hidden virtual functions that are not overridden in t.
2828    We know that constructors and destructors don't apply.  */
2829
2830 void
2831 warn_hidden (t)
2832      tree t;
2833 {
2834   tree method_vec = CLASSTYPE_METHOD_VEC (t);
2835   int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
2836   int i;
2837
2838   /* We go through each separately named virtual function.  */
2839   for (i = 2; i < n_methods; ++i)
2840     {
2841       tree fndecl = TREE_VEC_ELT (method_vec, i);
2842
2843       tree base_fndecls = NULL_TREE;
2844       tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
2845       int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2846
2847       if (DECL_VINDEX (fndecl) == NULL_TREE)
2848         continue;
2849
2850       /* First we get a list of all possible functions that might be
2851          hidden from each base class.  */
2852       for (i = 0; i < n_baseclasses; i++)
2853         {
2854           tree base_binfo = TREE_VEC_ELT (binfos, i);
2855           tree basetype = BINFO_TYPE (base_binfo);
2856
2857           base_fndecls = chainon (get_basefndecls (fndecl, basetype),
2858                                   base_fndecls);
2859         }
2860
2861       if (TREE_CHAIN (fndecl)
2862           && DECL_NAME (TREE_CHAIN (fndecl)) == DECL_NAME (fndecl))
2863           fndecl = TREE_CHAIN (fndecl);
2864         else
2865           fndecl = NULL_TREE;
2866
2867       /* ...then mark up all the base functions with overriders, preferring
2868          overriders to hiders.  */
2869       if (base_fndecls)
2870         while (fndecl)
2871           {
2872             mark_overriders (fndecl, base_fndecls);
2873
2874             if (TREE_CHAIN (fndecl)
2875                 && DECL_NAME (TREE_CHAIN (fndecl)) == DECL_NAME (fndecl))
2876               fndecl = TREE_CHAIN (fndecl);
2877             else
2878               fndecl = NULL_TREE;
2879           }
2880
2881       /* Now give a warning for all base functions without overriders,
2882          as they are hidden.  */
2883       while (base_fndecls)
2884         {
2885           if (! overrides (TREE_VALUE (base_fndecls),
2886                            TREE_PURPOSE (base_fndecls)))
2887             {
2888               /* Here we know it is a hider, and no overrider exists.  */
2889               cp_warning_at ("`%D' was hidden", TREE_VALUE (base_fndecls));
2890               cp_warning_at ("  by `%D'", TREE_PURPOSE (base_fndecls));
2891             }
2892
2893           base_fndecls = TREE_CHAIN (base_fndecls);
2894         }
2895     }
2896 }
2897
2898 /* Check for things that are invalid.  There are probably plenty of other
2899    things we should check for also.  */
2900
2901 static void
2902 finish_struct_anon (t)
2903      tree t;
2904 {
2905   tree field;
2906   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2907     {
2908       if (TREE_STATIC (field))
2909         continue;
2910       if (TREE_CODE (field) != FIELD_DECL)
2911         continue;
2912
2913       if (DECL_NAME (field) == NULL_TREE
2914           && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
2915         {
2916           tree* uelt = &TYPE_FIELDS (TREE_TYPE (field));
2917           for (; *uelt; uelt = &TREE_CHAIN (*uelt))
2918             {
2919               if (TREE_CODE (*uelt) != FIELD_DECL)
2920                 continue;
2921
2922               if (TREE_PRIVATE (*uelt))
2923                 cp_pedwarn_at ("private member `%#D' in anonymous union",
2924                                *uelt);
2925               else if (TREE_PROTECTED (*uelt))
2926                 cp_pedwarn_at ("protected member `%#D' in anonymous union",
2927                                *uelt);
2928
2929               TREE_PRIVATE (*uelt) = TREE_PRIVATE (field);
2930               TREE_PROTECTED (*uelt) = TREE_PROTECTED (field);
2931             }
2932         }
2933     }
2934 }
2935
2936 extern int interface_only, interface_unknown;
2937
2938 /* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
2939    (or C++ class declaration).
2940
2941    For C++, we must handle the building of derived classes.
2942    Also, C++ allows static class members.  The way that this is
2943    handled is to keep the field name where it is (as the DECL_NAME
2944    of the field), and place the overloaded decl in the DECL_FIELD_BITPOS
2945    of the field.  layout_record and layout_union will know about this.
2946
2947    More C++ hair: inline functions have text in their
2948    DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
2949    meaningful tree structure.  After the struct has been laid out, set
2950    things up so that this can happen.
2951
2952    And still more: virtual functions.  In the case of single inheritance,
2953    when a new virtual function is seen which redefines a virtual function
2954    from the base class, the new virtual function is placed into
2955    the virtual function table at exactly the same address that
2956    it had in the base class.  When this is extended to multiple
2957    inheritance, the same thing happens, except that multiple virtual
2958    function tables must be maintained.  The first virtual function
2959    table is treated in exactly the same way as in the case of single
2960    inheritance.  Additional virtual function tables have different
2961    DELTAs, which tell how to adjust `this' to point to the right thing.
2962
2963    LIST_OF_FIELDLISTS is just that.  The elements of the list are
2964    TREE_LIST elements, whose TREE_PURPOSE field tells what access
2965    the list has, and the TREE_VALUE slot gives the actual fields.
2966
2967    ATTRIBUTES is the set of decl attributes to be applied, if any.
2968
2969    If flag_all_virtual == 1, then we lay all functions into
2970    the virtual function table, as though they were declared
2971    virtual.  Constructors do not lay down in the virtual function table.
2972
2973    If flag_all_virtual == 2, then we lay all functions into
2974    the virtual function table, such that virtual functions
2975    occupy a space by themselves, and then all functions
2976    of the class occupy a space by themselves.  This is illustrated
2977    in the following diagram:
2978
2979    class A; class B : A;
2980
2981         Class A's vtbl:                 Class B's vtbl:
2982     --------------------------------------------------------------------
2983    | A's virtual functions|             | B's virtual functions         |
2984    |                      |             | (may inherit some from A).    |
2985     --------------------------------------------------------------------
2986    | All of A's functions |             | All of A's functions          |
2987    | (such as a->A::f).   |             | (such as b->A::f)             |
2988     --------------------------------------------------------------------
2989                                         | B's new virtual functions     |
2990                                         | (not defined in A.)           |
2991                                          -------------------------------
2992                                         | All of B's functions          |
2993                                         | (such as b->B::f)             |
2994                                          -------------------------------
2995
2996    this allows the program to make references to any function, virtual
2997    or otherwise in a type-consistent manner.  */
2998
2999 tree
3000 finish_struct_1 (t, warn_anon)
3001      tree t;
3002      int warn_anon;
3003 {
3004   int old;
3005   tree name = TYPE_IDENTIFIER (t);
3006   enum tree_code code = TREE_CODE (t);
3007   tree fields = TYPE_FIELDS (t);
3008   tree fn_fields = TYPE_METHODS (t);
3009   tree x, last_x, method_vec;
3010   int all_virtual;
3011   int has_virtual;
3012   int max_has_virtual;
3013   tree pending_virtuals = NULL_TREE;
3014   tree pending_hard_virtuals = NULL_TREE;
3015   tree abstract_virtuals = NULL_TREE;
3016   tree vfield;
3017   tree vfields;
3018   int cant_have_default_ctor;
3019   int cant_have_const_ctor;
3020   int no_const_asn_ref;
3021
3022   /* The index of the first base class which has virtual
3023      functions.  Only applied to non-virtual baseclasses.  */
3024   int first_vfn_base_index;
3025
3026   int n_baseclasses;
3027   int any_default_members = 0;
3028   int const_sans_init = 0;
3029   int ref_sans_init = 0;
3030   int nonprivate_method = 0;
3031   tree access_decls = NULL_TREE;
3032   int aggregate = 1;
3033   int empty = 1;
3034   int has_pointers = 0;
3035
3036   if (warn_anon && code != UNION_TYPE && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
3037     pedwarn ("anonymous class type not used to declare any objects");
3038
3039   if (TYPE_SIZE (t))
3040     {
3041       if (IS_AGGR_TYPE (t))
3042         cp_error ("redefinition of `%#T'", t);
3043       else
3044         my_friendly_abort (172);
3045       popclass (0);
3046       return t;
3047     }
3048
3049   GNU_xref_decl (current_function_decl, t);
3050
3051   /* If this type was previously laid out as a forward reference,
3052      make sure we lay it out again.  */
3053
3054   TYPE_SIZE (t) = NULL_TREE;
3055   CLASSTYPE_GOT_SEMICOLON (t) = 0;
3056
3057 #if 0
3058   /* This is in general too late to do this.  I moved the main case up to
3059      left_curly, what else needs to move?  */
3060   if (! IS_SIGNATURE (t))
3061     {
3062       my_friendly_assert (CLASSTYPE_INTERFACE_ONLY (t) == interface_only, 999);
3063       my_friendly_assert (CLASSTYPE_INTERFACE_KNOWN (t) == ! interface_unknown, 999);
3064     }
3065 #endif
3066
3067   old = suspend_momentary ();
3068
3069   /* Install struct as DECL_FIELD_CONTEXT of each field decl.
3070      Also process specified field sizes.
3071      Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
3072      The specified size is found in the DECL_INITIAL.
3073      Store 0 there, except for ": 0" fields (so we can find them
3074      and delete them, below).  */
3075
3076   if (TYPE_BINFO_BASETYPES (t))
3077     n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (t));
3078   else
3079     n_baseclasses = 0;
3080
3081   if (n_baseclasses > 0)
3082     {
3083       struct base_info base_info;
3084
3085       first_vfn_base_index = finish_base_struct (t, &base_info);
3086       /* Remember where we got our vfield from.  */
3087       CLASSTYPE_VFIELD_PARENT (t) = first_vfn_base_index;
3088       has_virtual = base_info.has_virtual;
3089       max_has_virtual = base_info.max_has_virtual;
3090       CLASSTYPE_N_SUPERCLASSES (t) += base_info.n_ancestors;
3091       vfield = base_info.vfield;
3092       vfields = base_info.vfields;
3093       CLASSTYPE_RTTI (t) = base_info.rtti;
3094       cant_have_default_ctor = base_info.cant_have_default_ctor;
3095       cant_have_const_ctor = base_info.cant_have_const_ctor;
3096       no_const_asn_ref = base_info.no_const_asn_ref;
3097       aggregate = 0;
3098     }
3099   else
3100     {
3101       first_vfn_base_index = -1;
3102       has_virtual = 0;
3103       max_has_virtual = has_virtual;
3104       vfield = NULL_TREE;
3105       vfields = NULL_TREE;
3106       CLASSTYPE_RTTI (t) = NULL_TREE;
3107       cant_have_default_ctor = 0;
3108       cant_have_const_ctor = 0;
3109       no_const_asn_ref = 0;
3110     }
3111
3112 #if 0
3113   /* Both of these should be done before now.  */
3114   if (write_virtuals == 3 && CLASSTYPE_INTERFACE_KNOWN (t)
3115       && ! IS_SIGNATURE (t))
3116     {
3117       my_friendly_assert (CLASSTYPE_INTERFACE_ONLY (t) == interface_only, 999);
3118       my_friendly_assert (CLASSTYPE_VTABLE_NEEDS_WRITING (t) == ! interface_only, 999);
3119     }
3120 #endif
3121
3122   /* The three of these are approximations which may later be
3123      modified.  Needed at this point to make add_virtual_function
3124      and modify_vtable_entries work.  */
3125   CLASSTYPE_VFIELDS (t) = vfields;
3126   CLASSTYPE_VFIELD (t) = vfield;
3127
3128   if (IS_SIGNATURE (t))
3129     all_virtual = 0;
3130   else if (flag_all_virtual == 1)
3131     all_virtual = 1;
3132   else
3133     all_virtual = 0;
3134
3135   for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
3136     {
3137       GNU_xref_member (current_class_name, x);
3138
3139       nonprivate_method |= ! TREE_PRIVATE (x);
3140
3141       /* If this was an evil function, don't keep it in class.  */
3142       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
3143         continue;
3144
3145       DECL_CLASS_CONTEXT (x) = t;
3146
3147       /* Do both of these, even though they're in the same union;
3148          if the insn `r' member and the size `i' member are
3149          different sizes, as on the alpha, the larger of the two
3150          will end up with garbage in it.  */
3151       DECL_SAVED_INSNS (x) = NULL_RTX;
3152       DECL_FIELD_SIZE (x) = 0;
3153
3154       check_for_override (x, t);
3155       if (DECL_ABSTRACT_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3156         cp_error_at ("initializer specified for non-virtual method `%D'", x);
3157
3158       /* The name of the field is the original field name
3159          Save this in auxiliary field for later overloading.  */
3160       if (DECL_VINDEX (x)
3161           || (all_virtual == 1 && ! DECL_CONSTRUCTOR_P (x)))
3162         {
3163           add_virtual_function (&pending_virtuals, &pending_hard_virtuals,
3164                                 &has_virtual, x, t);
3165           if (DECL_ABSTRACT_VIRTUAL_P (x))
3166             abstract_virtuals = tree_cons (NULL_TREE, x, abstract_virtuals);
3167 #if 0
3168           /* XXX Why did I comment this out?  (jason) */
3169           else
3170             TREE_USED (x) = 1;
3171 #endif
3172         }
3173     }
3174
3175   if (n_baseclasses)
3176     fields = chainon (build_vbase_pointer_fields (t), fields);
3177
3178   last_x = NULL_TREE;
3179   for (x = fields; x; x = TREE_CHAIN (x))
3180     {
3181       GNU_xref_member (current_class_name, x);
3182
3183       if (TREE_CODE (x) == FIELD_DECL)
3184         {
3185           DECL_PACKED (x) |= TYPE_PACKED (t);
3186           empty = 0;
3187         }
3188
3189       /* Handle access declarations.  */
3190       if (TREE_CODE (x) == USING_DECL)
3191         {
3192           tree ctype = DECL_INITIAL (x);
3193           tree sname = DECL_NAME (x);
3194           tree access
3195             = TREE_PRIVATE (x) ? access_private_node
3196                                : TREE_PROTECTED (x) ? access_protected_node
3197                                                     : access_public_node;
3198           tree fdecl, binfo;
3199
3200           if (last_x)
3201             TREE_CHAIN (last_x) = TREE_CHAIN (x);
3202           else
3203             fields = TREE_CHAIN (x);
3204
3205           binfo = binfo_or_else (ctype, t);
3206           if (! binfo)
3207             continue;
3208
3209           if (sname == constructor_name (ctype)
3210               || sname == constructor_name_full (ctype))
3211             cp_error_at ("using-declaration for constructor", x);
3212
3213           fdecl = lookup_field (binfo, sname, 0, 0);
3214           if (! fdecl)
3215             fdecl = lookup_fnfields (binfo, sname, 0);
3216
3217           if (fdecl)
3218             access_decls = scratch_tree_cons (access, fdecl, access_decls);
3219           else
3220             cp_error_at ("no members matching `%D' in `%#T'", x, ctype);
3221           continue;
3222         }
3223
3224       last_x = x;
3225
3226       if (TREE_CODE (x) == TYPE_DECL
3227           || TREE_CODE (x) == TEMPLATE_DECL)
3228         continue;
3229
3230       /* If we've gotten this far, it's a data member, possibly static,
3231          or an enumerator.  */
3232
3233       DECL_FIELD_CONTEXT (x) = t;
3234
3235       /* ``A local class cannot have static data members.'' ARM 9.4 */
3236       if (current_function_decl && TREE_STATIC (x))
3237         cp_error_at ("field `%D' in local class cannot be static", x);
3238
3239       /* Perform error checking that did not get done in
3240          grokdeclarator.  */
3241       if (TREE_CODE (TREE_TYPE (x)) == FUNCTION_TYPE)
3242         {
3243           cp_error_at ("field `%D' invalidly declared function type",
3244                        x);
3245           TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
3246         }
3247       else if (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE)
3248         {
3249           cp_error_at ("field `%D' invalidly declared method type", x);
3250           TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
3251         }
3252       else if (TREE_CODE (TREE_TYPE (x)) == OFFSET_TYPE)
3253         {
3254           cp_error_at ("field `%D' invalidly declared offset type", x);
3255           TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
3256         }
3257
3258 #if 0
3259       if (DECL_NAME (x) == constructor_name (t))
3260         cant_have_default_ctor = 1;
3261 #endif
3262
3263       if (TREE_TYPE (x) == error_mark_node)
3264         continue;
3265
3266       DECL_SAVED_INSNS (x) = NULL_RTX;
3267       DECL_FIELD_SIZE (x) = 0;
3268
3269       /* When this goes into scope, it will be a non-local reference.  */
3270       DECL_NONLOCAL (x) = 1;
3271
3272       if (TREE_CODE (x) == CONST_DECL)
3273         continue;
3274
3275       if (TREE_CODE (x) == VAR_DECL)
3276         {
3277           if (TREE_CODE (t) == UNION_TYPE)
3278             /* Unions cannot have static members.  */
3279             cp_error_at ("field `%D' declared static in union", x);
3280
3281           continue;
3282         }
3283
3284       /* Now it can only be a FIELD_DECL.  */
3285
3286       if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3287         aggregate = 0;
3288
3289       /* If this is of reference type, check if it needs an init.
3290          Also do a little ANSI jig if necessary.  */
3291       if (TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE)
3292         {
3293           if (DECL_INITIAL (x) == NULL_TREE)
3294             ref_sans_init = 1;
3295
3296           /* ARM $12.6.2: [A member initializer list] (or, for an
3297              aggregate, initialization by a brace-enclosed list) is the
3298              only way to initialize nonstatic const and reference
3299              members.  */
3300           cant_have_default_ctor = 1;
3301           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3302
3303           if (! TYPE_HAS_CONSTRUCTOR (t) && extra_warnings)
3304             {
3305               if (DECL_NAME (x))
3306                 cp_warning_at ("non-static reference `%#D' in class without a constructor", x);
3307               else
3308                 cp_warning_at ("non-static reference in class without a constructor", x);
3309             }
3310         }
3311
3312       if (TREE_CODE (TREE_TYPE (x)) == POINTER_TYPE)
3313         has_pointers = 1;
3314
3315       /* If any field is const, the structure type is pseudo-const.  */
3316       if (TREE_READONLY (x))
3317         {
3318           C_TYPE_FIELDS_READONLY (t) = 1;
3319           if (DECL_INITIAL (x) == NULL_TREE)
3320             const_sans_init = 1;
3321
3322           /* ARM $12.6.2: [A member initializer list] (or, for an
3323              aggregate, initialization by a brace-enclosed list) is the
3324              only way to initialize nonstatic const and reference
3325              members.  */
3326           cant_have_default_ctor = 1;
3327           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3328
3329           if (! TYPE_HAS_CONSTRUCTOR (t) && !IS_SIGNATURE (t)
3330               && extra_warnings)
3331             {
3332               if (DECL_NAME (x))
3333                 cp_warning_at ("non-static const member `%#D' in class without a constructor", x);
3334               else
3335                 cp_warning_at ("non-static const member in class without a constructor", x);
3336             }
3337         }
3338       else
3339         {
3340           /* A field that is pseudo-const makes the structure
3341              likewise.  */
3342           tree t1 = TREE_TYPE (x);
3343           while (TREE_CODE (t1) == ARRAY_TYPE)
3344             t1 = TREE_TYPE (t1);
3345           if (IS_AGGR_TYPE (t1))
3346             {
3347               if (C_TYPE_FIELDS_READONLY (t1))
3348                 C_TYPE_FIELDS_READONLY (t) = 1;
3349               if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (t1))
3350                 const_sans_init = 1;
3351             }
3352         }
3353
3354       /* We set DECL_BIT_FIELD tentatively in grokbitfield.
3355          If the type and width are valid, we'll keep it set.
3356          Otherwise, the flag is cleared.  */
3357       if (DECL_BIT_FIELD (x))
3358         {
3359           DECL_BIT_FIELD (x) = 0;
3360           /* Invalid bit-field size done by grokfield.  */
3361           /* Detect invalid bit-field type.  */
3362           if (DECL_INITIAL (x)
3363               && ! INTEGRAL_TYPE_P (TREE_TYPE (x)))
3364             {
3365               cp_error_at ("bit-field `%#D' with non-integral type", x);
3366               DECL_INITIAL (x) = NULL;
3367             }
3368
3369           /* Detect and ignore out of range field width.  */
3370           if (DECL_INITIAL (x))
3371             {
3372               tree w = DECL_INITIAL (x);
3373               register int width = 0;
3374
3375               /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs.  */
3376               STRIP_NOPS (w);
3377
3378               /* detect invalid field size.  */
3379               if (TREE_CODE (w) == CONST_DECL)
3380                 w = DECL_INITIAL (w);
3381               else if (TREE_READONLY_DECL_P (w))
3382                 w = decl_constant_value (w);
3383
3384               if (TREE_CODE (w) != INTEGER_CST)
3385                 {
3386                   cp_error_at ("bit-field `%D' width not an integer constant",
3387                                x);
3388                   DECL_INITIAL (x) = NULL_TREE;
3389                 }
3390               else if (width = TREE_INT_CST_LOW (w),
3391                        width < 0)
3392                 {
3393                   DECL_INITIAL (x) = NULL;
3394                   cp_error_at ("negative width in bit-field `%D'", x);
3395                 }
3396               else if (width == 0 && DECL_NAME (x) != 0)
3397                 {
3398                   DECL_INITIAL (x) = NULL;
3399                   cp_error_at ("zero width for bit-field `%D'", x);
3400                 }
3401               else if (width
3402                        > TYPE_PRECISION (long_long_unsigned_type_node))
3403                 {
3404                   /* The backend will dump if you try to use something
3405                      too big; avoid that.  */
3406                   DECL_INITIAL (x) = NULL;
3407                   sorry ("bit-fields larger than %d bits",
3408                          TYPE_PRECISION (long_long_unsigned_type_node));
3409                   cp_error_at ("  in declaration of `%D'", x);
3410                 }
3411               else if (width > TYPE_PRECISION (TREE_TYPE (x))
3412                        && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE
3413                        && TREE_CODE (TREE_TYPE (x)) != BOOLEAN_TYPE)
3414                 {
3415                   cp_warning_at ("width of `%D' exceeds its type", x);
3416                 }
3417               else if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
3418                        && ((min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
3419                                            TREE_UNSIGNED (TREE_TYPE (x))) > width)
3420                            || (min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
3421                                               TREE_UNSIGNED (TREE_TYPE (x))) > width)))
3422                 {
3423                   cp_warning_at ("`%D' is too small to hold all values of `%#T'",
3424                                  x, TREE_TYPE (x));
3425                 }
3426
3427               if (DECL_INITIAL (x) == NULL_TREE)
3428                 ;
3429               else if (width == 0)
3430                 {
3431 #ifdef EMPTY_FIELD_BOUNDARY
3432                   DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
3433 #endif
3434 #ifdef PCC_BITFIELD_TYPE_MATTERS
3435                   DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
3436                                         TYPE_ALIGN (TREE_TYPE (x)));
3437 #endif
3438                 }
3439               else
3440                 {
3441                   DECL_INITIAL (x) = NULL_TREE;
3442                   DECL_FIELD_SIZE (x) = width;
3443                   DECL_BIT_FIELD (x) = 1;
3444                 }
3445             }
3446           else
3447             /* Non-bit-fields are aligned for their type.  */
3448             DECL_ALIGN (x) = MAX (DECL_ALIGN (x), TYPE_ALIGN (TREE_TYPE (x)));
3449         }
3450       else
3451         {
3452           tree type = TREE_TYPE (x);
3453
3454           while (TREE_CODE (type) == ARRAY_TYPE)
3455             type = TREE_TYPE (type);
3456
3457           if (TYPE_LANG_SPECIFIC (type) && ! ANON_UNION_P (x)
3458               && ! TYPE_PTRMEMFUNC_P (type))
3459             {
3460               /* Never let anything with uninheritable virtuals
3461                  make it through without complaint.  */
3462               if (CLASSTYPE_ABSTRACT_VIRTUALS (type))
3463                 abstract_virtuals_error (x, type);
3464
3465               /* Don't let signatures make it through either.  */
3466               if (IS_SIGNATURE (type))
3467                 signature_error (x, type);
3468
3469               if (code == UNION_TYPE)
3470                 {
3471                   char *fie = NULL;
3472                   if (TYPE_NEEDS_CONSTRUCTING (type))
3473                     fie = "constructor";
3474                   else if (TYPE_NEEDS_DESTRUCTOR (type))
3475                     fie = "destructor";
3476                   else if (TYPE_HAS_REAL_ASSIGNMENT (type))
3477                     fie = "assignment operator";
3478                   if (fie)
3479                     cp_error_at ("member `%#D' with %s not allowed in union", x,
3480                                  fie);
3481                 }
3482               else
3483                 {
3484                   TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
3485                   TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (type);
3486                   TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
3487                   TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
3488                 }
3489
3490               if (!TYPE_HAS_CONST_INIT_REF (type))
3491                 cant_have_const_ctor = 1;
3492
3493               if (!TYPE_HAS_CONST_ASSIGN_REF (type))
3494                 no_const_asn_ref = 1;
3495
3496               if (TYPE_HAS_CONSTRUCTOR (type)
3497                   && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
3498                 {
3499                   cant_have_default_ctor = 1;
3500 #if 0
3501                   /* This is wrong for aggregates.  */
3502                   if (! TYPE_HAS_CONSTRUCTOR (t))
3503                     {
3504                       if (DECL_NAME (x))
3505                         cp_pedwarn_at ("member `%#D' with only non-default constructor", x);
3506                       else
3507                         cp_pedwarn_at ("member with only non-default constructor", x);
3508                       cp_pedwarn_at ("in class without a constructor",
3509                                      x);
3510                     }
3511 #endif
3512                 }
3513             }
3514           if (DECL_INITIAL (x) != NULL_TREE)
3515             {
3516               /* `build_class_init_list' does not recognize
3517                  non-FIELD_DECLs.  */
3518               if (code == UNION_TYPE && any_default_members != 0)
3519                 cp_error_at ("multiple fields in union `%T' initialized");
3520               any_default_members = 1;
3521             }
3522         }
3523     }
3524
3525   /* If this type has any constant members which did not come
3526      with their own initialization, mark that fact here.  It is
3527      not an error here, since such types can be saved either by their
3528      constructors, or by fortuitous initialization.  */
3529   CLASSTYPE_READONLY_FIELDS_NEED_INIT (t) = const_sans_init;
3530   CLASSTYPE_REF_FIELDS_NEED_INIT (t) = ref_sans_init;
3531   CLASSTYPE_ABSTRACT_VIRTUALS (t) = abstract_virtuals;
3532
3533   /* Synthesize any needed methods.  Note that methods will be synthesized
3534      for anonymous unions; grok_x_components undoes that.  */
3535
3536   if (! fn_fields)
3537     nonprivate_method = 1;
3538
3539   if (TYPE_NEEDS_DESTRUCTOR (t) && !TYPE_HAS_DESTRUCTOR (t)
3540       && !IS_SIGNATURE (t))
3541     {
3542       /* Here we must cons up a destructor on the fly.  */
3543       tree dtor = cons_up_default_function (t, name, 0);
3544       check_for_override (dtor, t);
3545
3546       /* If we couldn't make it work, then pretend we didn't need it.  */
3547       if (dtor == void_type_node)
3548         TYPE_NEEDS_DESTRUCTOR (t) = 0;
3549       else
3550         {
3551           /* Link dtor onto end of fn_fields.  */
3552
3553           TREE_CHAIN (dtor) = fn_fields;
3554           fn_fields = dtor;
3555
3556           if (DECL_VINDEX (dtor))
3557             add_virtual_function (&pending_virtuals, &pending_hard_virtuals,
3558                                   &has_virtual, dtor, t);
3559           nonprivate_method = 1;
3560         }
3561     }
3562
3563   /* Effective C++ rule 11.  */
3564   if (has_pointers && warn_ecpp && TYPE_HAS_CONSTRUCTOR (t)
3565       && ! (TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
3566     {
3567       cp_warning ("`%#T' has pointer data members", t);
3568
3569       if (! TYPE_HAS_INIT_REF (t))
3570         {
3571           cp_warning ("  but does not override `%T(const %T&)'", t, t);
3572           if (! TYPE_HAS_ASSIGN_REF (t))
3573             cp_warning ("  or `operator=(const %T&)'", t);
3574         }
3575       else if (! TYPE_HAS_ASSIGN_REF (t))
3576         cp_warning ("  but does not override `operator=(const %T&)'", t);
3577     }
3578
3579   TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t);
3580
3581   TYPE_HAS_COMPLEX_INIT_REF (t)
3582     |= (TYPE_HAS_INIT_REF (t) || TYPE_USES_VIRTUAL_BASECLASSES (t)
3583         || has_virtual || any_default_members);
3584   TYPE_NEEDS_CONSTRUCTING (t)
3585     |= (TYPE_HAS_CONSTRUCTOR (t) || TYPE_USES_VIRTUAL_BASECLASSES (t)
3586         || has_virtual || any_default_members);
3587   if (! IS_SIGNATURE (t))
3588     CLASSTYPE_NON_AGGREGATE (t)
3589       = ! aggregate || has_virtual || TYPE_HAS_CONSTRUCTOR (t);
3590
3591   /* ARM $12.1: A default constructor will be generated for a class X
3592      only if no constructor has been declared for class X.  So we
3593      check TYPE_HAS_CONSTRUCTOR also, to make sure we don't generate
3594      one if they declared a constructor in this class.  */
3595   if (! TYPE_HAS_CONSTRUCTOR (t) && ! cant_have_default_ctor
3596       && ! IS_SIGNATURE (t))
3597     {
3598       tree default_fn = cons_up_default_function (t, name, 2);
3599       TREE_CHAIN (default_fn) = fn_fields;
3600       fn_fields = default_fn;
3601     }
3602
3603   /* Create default copy constructor, if needed.  */
3604   if (! TYPE_HAS_INIT_REF (t) && ! IS_SIGNATURE (t) && ! TYPE_FOR_JAVA (t))
3605     {
3606       /* ARM 12.18: You get either X(X&) or X(const X&), but
3607          not both.  --Chip  */
3608       tree default_fn = cons_up_default_function (t, name,
3609                                                   3 + cant_have_const_ctor);
3610       TREE_CHAIN (default_fn) = fn_fields;
3611       fn_fields = default_fn;
3612     }
3613
3614   TYPE_HAS_REAL_ASSIGNMENT (t) |= TYPE_HAS_ASSIGNMENT (t);
3615   TYPE_HAS_REAL_ASSIGN_REF (t) |= TYPE_HAS_ASSIGN_REF (t);
3616   TYPE_HAS_COMPLEX_ASSIGN_REF (t)
3617     |= TYPE_HAS_ASSIGN_REF (t) || TYPE_USES_VIRTUAL_BASECLASSES (t);
3618
3619   if (! TYPE_HAS_ASSIGN_REF (t) && ! IS_SIGNATURE (t) && ! TYPE_FOR_JAVA (t))
3620     {
3621       tree default_fn = cons_up_default_function (t, name,
3622                                                   5 + no_const_asn_ref);
3623       TREE_CHAIN (default_fn) = fn_fields;
3624       fn_fields = default_fn;
3625     }
3626
3627   if (fn_fields)
3628     {
3629       TYPE_METHODS (t) = fn_fields;
3630       method_vec = finish_struct_methods (t, fn_fields, nonprivate_method);
3631
3632       if (TYPE_HAS_CONSTRUCTOR (t)
3633           && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
3634           && DECL_FRIENDLIST (TYPE_MAIN_DECL (t)) == NULL_TREE)
3635         {
3636           int nonprivate_ctor = 0;
3637           tree ctor;
3638
3639           for (ctor = TREE_VEC_ELT (method_vec, 0);
3640                ctor;
3641                ctor = OVL_NEXT (ctor))
3642             if (! TREE_PRIVATE (OVL_CURRENT (ctor)))
3643               {
3644                 nonprivate_ctor = 1;
3645                 break;
3646               }
3647
3648           if (nonprivate_ctor == 0 && warn_ctor_dtor_privacy)
3649             cp_warning ("`%#T' only defines private constructors and has no friends",
3650                         t);
3651         }
3652     }
3653   else
3654     {
3655       method_vec = 0;
3656
3657       /* Just in case these got accidentally
3658          filled in by syntax errors.  */
3659       TYPE_HAS_CONSTRUCTOR (t) = 0;
3660       TYPE_HAS_DESTRUCTOR (t) = 0;
3661     }
3662
3663   {
3664     int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
3665
3666     for (access_decls = nreverse (access_decls); access_decls;
3667          access_decls = TREE_CHAIN (access_decls))
3668       {
3669         tree fdecl = TREE_VALUE (access_decls);
3670         tree flist = NULL_TREE;
3671         tree name;
3672         tree access = TREE_PURPOSE (access_decls);
3673         int i = 2;
3674         tree tmp;
3675
3676         /* Functions are represented as TREE_LIST, with the purpose
3677            being the type and the value the functions. Other members
3678            come as themselves. */
3679         if (TREE_CODE (fdecl) == TREE_LIST)
3680           {
3681             /* Ignore base type this came from. */
3682             fdecl = TREE_VALUE (fdecl);
3683           }
3684         if (TREE_CODE (fdecl) == OVERLOAD)
3685           {
3686             /* We later iterate over all functions. */
3687             flist = fdecl;
3688             fdecl = OVL_FUNCTION (flist);
3689           }
3690
3691         name = DECL_NAME (fdecl);
3692
3693         for (; i < n_methods; i++)
3694           if (DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (method_vec, i)))
3695                 == name)
3696             {
3697               cp_error ("cannot adjust access to `%#D' in `%#T'", fdecl, t);
3698               cp_error_at ("  because of local method `%#D' with same name",
3699                            OVL_CURRENT (TREE_VEC_ELT (method_vec, i)));
3700               fdecl = NULL_TREE;
3701               break;
3702             }
3703
3704         if (! fdecl)
3705           continue;
3706
3707         for (tmp = fields; tmp; tmp = TREE_CHAIN (tmp))
3708           if (DECL_NAME (tmp) == name)
3709             {
3710               cp_error ("cannot adjust access to `%#D' in `%#T'", fdecl, t);
3711               cp_error_at ("  because of local field `%#D' with same name", tmp);
3712               fdecl = NULL_TREE;
3713               break;
3714             }
3715
3716         if (!fdecl)
3717           continue;
3718
3719         /* Make type T see field decl FDECL with access ACCESS.*/
3720         if (flist)
3721           {
3722             while (flist)
3723               {
3724                 if (alter_access (t, OVL_FUNCTION (flist), access) == 0)
3725                   break;
3726                 flist = OVL_CHAIN (flist);
3727               }
3728           }
3729         else
3730           alter_access (t, fdecl, access);
3731       }
3732
3733   }
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
4967   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
4968     {
4969       if (complain)
4970         error ("not enough type information");
4971       return error_mark_node;
4972     }
4973
4974   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
4975     {
4976       if (comptypes (lhstype, TREE_TYPE (rhs), 1))
4977         return rhs;
4978       if (complain)
4979         cp_error ("argument of type `%T' does not match `%T'",
4980                   TREE_TYPE (rhs), lhstype);
4981       return error_mark_node;
4982     }
4983
4984   /* We don't overwrite rhs if it is an overloaded function.
4985      Copying it would destroy the tree link.  */
4986   if (TREE_CODE (rhs) != OVERLOAD)
4987     rhs = copy_node (rhs);
4988
4989   /* This should really only be used when attempting to distinguish
4990      what sort of a pointer to function we have.  For now, any
4991      arithmetic operation which is not supported on pointers
4992      is rejected as an error.  */
4993
4994   switch (TREE_CODE (rhs))
4995     {
4996     case TYPE_EXPR:
4997     case CONVERT_EXPR:
4998     case SAVE_EXPR:
4999     case CONSTRUCTOR:
5000     case BUFFER_REF:
5001       my_friendly_abort (177);
5002       return error_mark_node;
5003
5004     case INDIRECT_REF:
5005     case ARRAY_REF:
5006       {
5007         tree new_rhs;
5008
5009         new_rhs = instantiate_type (build_pointer_type (lhstype),
5010                                     TREE_OPERAND (rhs, 0), complain);
5011         if (new_rhs == error_mark_node)
5012           return error_mark_node;
5013
5014         TREE_TYPE (rhs) = lhstype;
5015         TREE_OPERAND (rhs, 0) = new_rhs;
5016         return rhs;
5017       }
5018
5019     case NOP_EXPR:
5020       rhs = copy_node (TREE_OPERAND (rhs, 0));
5021       TREE_TYPE (rhs) = unknown_type_node;
5022       return instantiate_type (lhstype, rhs, complain);
5023
5024     case COMPONENT_REF:
5025       {
5026         tree field = TREE_OPERAND (rhs, 1);
5027         if (TREE_CODE (field) == TREE_LIST)
5028           {
5029             tree function = instantiate_type (lhstype, field, complain);
5030             if (function == error_mark_node)
5031               return error_mark_node;
5032             my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 185);
5033             if (DECL_VINDEX (function))
5034               {
5035                 tree base = TREE_OPERAND (rhs, 0);
5036                 tree base_ptr = build_unary_op (ADDR_EXPR, base, 0);
5037                 if (base_ptr == error_mark_node)
5038                   return error_mark_node;
5039                 base_ptr = convert_pointer_to (DECL_CONTEXT (function), base_ptr);
5040                 if (base_ptr == error_mark_node)
5041                   return error_mark_node;
5042                 return build_vfn_ref (&base_ptr, base, DECL_VINDEX (function));
5043               }
5044             mark_used (function);
5045             return function;
5046           }
5047
5048         /* I could not trigger this code. MvL */
5049         my_friendly_abort (980326);
5050 #if 0
5051         my_friendly_assert (TREE_CODE (field) == FIELD_DECL, 178);
5052         my_friendly_assert (!(TREE_CODE (TREE_TYPE (field)) == FUNCTION_TYPE
5053                               || TREE_CODE (TREE_TYPE (field)) == METHOD_TYPE),
5054                             179);
5055
5056         TREE_TYPE (rhs) = lhstype;
5057         /* First look for an exact match  */
5058
5059         while (field && TREE_TYPE (field) != lhstype)
5060           field = DECL_CHAIN (field);
5061         if (field)
5062           {
5063             TREE_OPERAND (rhs, 1) = field;
5064             mark_used (field);
5065             return rhs;
5066           }
5067
5068         /* No exact match found, look for a compatible function.  */
5069         field = TREE_OPERAND (rhs, 1);
5070         while (field && ! comptypes (lhstype, TREE_TYPE (field), 0))
5071           field = DECL_CHAIN (field);
5072         if (field)
5073           {
5074             TREE_OPERAND (rhs, 1) = field;
5075             field = DECL_CHAIN (field);
5076             while (field && ! comptypes (lhstype, TREE_TYPE (field), 0))
5077               field = DECL_CHAIN (field);
5078             if (field)
5079               {
5080                 if (complain)
5081                   error ("ambiguous overload for COMPONENT_REF requested");
5082                 return error_mark_node;
5083               }
5084           }
5085         else
5086           {
5087             if (complain)
5088               error ("no appropriate overload exists for COMPONENT_REF");
5089             return error_mark_node;
5090           }
5091 #endif
5092         return rhs;
5093       }
5094
5095     case SCOPE_REF:
5096       {
5097         /* This can happen if we are forming a pointer-to-member for a
5098            member template.  */
5099         tree template_id_expr = TREE_OPERAND (rhs, 1);
5100         tree name;
5101         my_friendly_assert (TREE_CODE (template_id_expr) == TEMPLATE_ID_EXPR,
5102                             0);
5103         explicit_targs = TREE_OPERAND (template_id_expr, 1);
5104         name = TREE_OPERAND (template_id_expr, 0);
5105         my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
5106         rhs = lookup_fnfields (TYPE_BINFO (TREE_OPERAND (rhs, 0)), name, 1);
5107         goto overload;
5108       }
5109
5110     case TEMPLATE_ID_EXPR:
5111       {
5112         explicit_targs = TREE_OPERAND (rhs, 1);
5113         rhs = TREE_OPERAND (rhs, 0);
5114       }
5115       /* fall through */
5116       my_friendly_assert (TREE_CODE (rhs) == OVERLOAD, 980401);
5117
5118     case OVERLOAD:
5119     overload:
5120       {
5121         tree elem, elems;
5122
5123         /* First look for an exact match.  Search overloaded
5124            functions.  May have to undo what `default_conversion'
5125            might do to lhstype.  */
5126
5127         lhstype = validate_lhs (lhstype, complain);
5128         if (lhstype == error_mark_node)
5129           return lhstype;
5130
5131         if (TREE_CODE (lhstype) != FUNCTION_TYPE
5132             && TREE_CODE (lhstype) != METHOD_TYPE)
5133           {
5134             rhs = DECL_NAME (OVL_FUNCTION (rhs));
5135             if (complain)
5136               cp_error("cannot resolve overloaded function `%D' "
5137                        "based on non-function type", rhs);
5138             return error_mark_node;
5139           }
5140
5141         elems = rhs;
5142         /* If there are explicit_targs, only a template function
5143            can match.  */
5144         if (explicit_targs == NULL_TREE)
5145           while (elems)
5146             {
5147               elem = OVL_FUNCTION (elems);
5148               if (! comptypes (lhstype, TREE_TYPE (elem), 1))
5149                 elems = OVL_CHAIN (elems);
5150               else
5151                 {
5152                   mark_used (elem);
5153                   return elem;
5154                 }
5155             }
5156
5157         /* No exact match found, look for a compatible template.  */
5158         {
5159           tree save_elem = 0;
5160           elems = rhs;
5161           if (TREE_CODE (elems) == TREE_LIST)
5162             elems = TREE_VALUE (rhs);
5163           for (; elems; elems = OVL_NEXT (elems))
5164             if (TREE_CODE (elem = OVL_CURRENT (elems)) == TEMPLATE_DECL)
5165               {
5166                 int n = DECL_NTPARMS (elem);
5167                 tree t = make_scratch_vec (n);
5168                 int i;
5169                 i = type_unification
5170                   (DECL_INNERMOST_TEMPLATE_PARMS (elem), t,
5171                    TYPE_ARG_TYPES (TREE_TYPE (elem)),
5172                    TYPE_ARG_TYPES (lhstype), explicit_targs, DEDUCE_EXACT, 1);
5173                 if (i == 0)
5174                   {
5175                     if (save_elem)
5176                       {
5177                         cp_error ("ambiguous template instantiation converting to `%#T'", lhstype);
5178                         return error_mark_node;
5179                       }
5180                     save_elem = instantiate_template (elem, t);
5181                     /* Check the return type.  */
5182                     if (! comptypes (TREE_TYPE (lhstype),
5183                                      TREE_TYPE (TREE_TYPE (save_elem)), 1))
5184                       save_elem = 0;
5185                   }
5186               }
5187           if (save_elem)
5188             {
5189               mark_used (save_elem);
5190               return save_elem;
5191             }
5192         }
5193
5194         /* If there are explicit_targs, only a template function
5195            can match.  */
5196         if (explicit_targs == NULL_TREE)
5197           {
5198             /* No match found, look for a compatible function.  */
5199             tree elems = rhs;
5200             elems = rhs;
5201             for (; elems; elems = OVL_NEXT (elems))
5202               {
5203                 elem = OVL_CURRENT (elems);
5204                 if (comp_target_types (lhstype, TREE_TYPE (elem), 1) > 0)
5205                   break;
5206               }
5207             if (elems)
5208               {
5209                 tree save_elem = elem;
5210                 for (elems = OVL_CHAIN (elems); elems;
5211                      elems = OVL_CHAIN (elems))
5212                   {
5213                     elem = OVL_FUNCTION (elems);
5214                     if (comp_target_types (lhstype, TREE_TYPE (elem), 0) > 0)
5215                       break;
5216                   }
5217                 if (elems)
5218                   {
5219                     if (complain)
5220                       {
5221                         cp_error
5222                           ("cannot resolve overload to target type `%#T'",
5223                            lhstype);
5224                         cp_error_at ("  ambiguity between `%#D'", save_elem);
5225                         cp_error_at ("  and `%#D', at least", elem);
5226                       }
5227                     return error_mark_node;
5228                   }
5229                 mark_used (save_elem);
5230                 return save_elem;
5231               }
5232           }
5233         if (complain)
5234           {
5235             cp_error ("cannot resolve overload to target type `%#T'", lhstype);
5236             cp_error
5237               ("  because no suitable overload of function `%D' exists",
5238                DECL_NAME (OVL_FUNCTION (rhs)));
5239           }
5240         return error_mark_node;
5241       }
5242
5243     case TREE_LIST:
5244       {
5245         tree elem, baselink, name = NULL_TREE;
5246
5247         if (TREE_PURPOSE (rhs) == error_mark_node)
5248           {
5249             /* Make sure we don't drop the non-local flag, as the old code
5250                would rely on it. */
5251             int nl = TREE_NONLOCAL_FLAG (rhs);
5252             /* We don't need the type of this node. */
5253             rhs = TREE_VALUE (rhs);
5254             my_friendly_assert (TREE_NONLOCAL_FLAG (rhs) == nl, 980331);
5255           }
5256
5257         /* Now we should have a baselink. */
5258         my_friendly_assert (TREE_CODE (TREE_PURPOSE (rhs)) == TREE_VEC,
5259                             980331);
5260         /* First look for an exact match.  Search member functions.
5261            May have to undo what `default_conversion' might do to
5262            lhstype.  */
5263
5264         lhstype = validate_lhs (lhstype, complain);
5265         if (lhstype == error_mark_node)
5266           return lhstype;
5267
5268         my_friendly_assert (TREE_CHAIN (rhs) == NULL_TREE, 181);
5269         my_friendly_assert (TREE_CODE (TREE_VALUE (rhs)) == FUNCTION_DECL
5270                             || TREE_CODE (TREE_VALUE (rhs)) == OVERLOAD,
5271                             182);
5272
5273         for (baselink = rhs; baselink;
5274              baselink = next_baselink (baselink))
5275           {
5276             elem = TREE_VALUE (baselink);
5277             while (elem)
5278               if (comptypes (lhstype, TREE_TYPE (OVL_CURRENT (elem)), 1))
5279                 {
5280                   mark_used (OVL_CURRENT (elem));
5281                   return OVL_CURRENT (elem);
5282                 }
5283               else
5284                 elem = OVL_NEXT (elem);
5285           }
5286
5287         /* No exact match found, look for a compatible method.  */
5288         for (baselink = rhs; baselink;
5289              baselink = next_baselink (baselink))
5290           {
5291             elem = TREE_VALUE (baselink);
5292             for (; elem; elem = OVL_NEXT (elem))
5293               if (comp_target_types (lhstype,
5294                                      TREE_TYPE (OVL_CURRENT (elem)), 1) > 0)
5295                 break;
5296             if (elem)
5297               {
5298                 tree save_elem = OVL_CURRENT (elem);
5299                 for (elem = OVL_NEXT (elem); elem; elem = OVL_NEXT (elem))
5300                   if (comp_target_types (lhstype,
5301                                          TREE_TYPE (OVL_CURRENT (elem)), 0) > 0)
5302                     break;
5303                 if (elem)
5304                   {
5305                     if (complain)
5306                       error ("ambiguous overload for overloaded method requested");
5307                     return error_mark_node;
5308                   }
5309                 mark_used (save_elem);
5310                 return save_elem;
5311               }
5312             name = rhs;
5313             while (TREE_CODE (name) == TREE_LIST)
5314               name = TREE_VALUE (name);
5315             name = DECL_NAME (OVL_CURRENT (name));
5316 #if 0
5317             if (TREE_CODE (lhstype) == FUNCTION_TYPE && globals < 0)
5318               {
5319                 /* Try to instantiate from non-member functions.  */
5320                 rhs = lookup_name_nonclass (name);
5321                 if (rhs && TREE_CODE (rhs) == TREE_LIST)
5322                   {
5323                     /* This code seems to be missing a `return'.  */
5324                     my_friendly_abort (4);
5325                     instantiate_type (lhstype, rhs, complain);
5326                   }
5327               }
5328 #endif
5329           }
5330         if (complain)
5331           cp_error ("no compatible member functions named `%D'", name);
5332         return error_mark_node;
5333       }
5334
5335     case CALL_EXPR:
5336       /* This is too hard for now.  */
5337       my_friendly_abort (183);
5338       return error_mark_node;
5339
5340     case PLUS_EXPR:
5341     case MINUS_EXPR:
5342     case COMPOUND_EXPR:
5343       TREE_OPERAND (rhs, 0)
5344         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
5345       if (TREE_OPERAND (rhs, 0) == error_mark_node)
5346         return error_mark_node;
5347       TREE_OPERAND (rhs, 1)
5348         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
5349       if (TREE_OPERAND (rhs, 1) == error_mark_node)
5350         return error_mark_node;
5351
5352       TREE_TYPE (rhs) = lhstype;
5353       return rhs;
5354
5355     case MULT_EXPR:
5356     case TRUNC_DIV_EXPR:
5357     case FLOOR_DIV_EXPR:
5358     case CEIL_DIV_EXPR:
5359     case ROUND_DIV_EXPR:
5360     case RDIV_EXPR:
5361     case TRUNC_MOD_EXPR:
5362     case FLOOR_MOD_EXPR:
5363     case CEIL_MOD_EXPR:
5364     case ROUND_MOD_EXPR:
5365     case FIX_ROUND_EXPR:
5366     case FIX_FLOOR_EXPR:
5367     case FIX_CEIL_EXPR:
5368     case FIX_TRUNC_EXPR:
5369     case FLOAT_EXPR:
5370     case NEGATE_EXPR:
5371     case ABS_EXPR:
5372     case MAX_EXPR:
5373     case MIN_EXPR:
5374     case FFS_EXPR:
5375
5376     case BIT_AND_EXPR:
5377     case BIT_IOR_EXPR:
5378     case BIT_XOR_EXPR:
5379     case LSHIFT_EXPR:
5380     case RSHIFT_EXPR:
5381     case LROTATE_EXPR:
5382     case RROTATE_EXPR:
5383
5384     case PREINCREMENT_EXPR:
5385     case PREDECREMENT_EXPR:
5386     case POSTINCREMENT_EXPR:
5387     case POSTDECREMENT_EXPR:
5388       if (complain)
5389         error ("invalid operation on uninstantiated type");
5390       return error_mark_node;
5391
5392     case TRUTH_AND_EXPR:
5393     case TRUTH_OR_EXPR:
5394     case TRUTH_XOR_EXPR:
5395     case LT_EXPR:
5396     case LE_EXPR:
5397     case GT_EXPR:
5398     case GE_EXPR:
5399     case EQ_EXPR:
5400     case NE_EXPR:
5401     case TRUTH_ANDIF_EXPR:
5402     case TRUTH_ORIF_EXPR:
5403     case TRUTH_NOT_EXPR:
5404       if (complain)
5405         error ("not enough type information");
5406       return error_mark_node;
5407
5408     case COND_EXPR:
5409       if (type_unknown_p (TREE_OPERAND (rhs, 0)))
5410         {
5411           if (complain)
5412             error ("not enough type information");
5413           return error_mark_node;
5414         }
5415       TREE_OPERAND (rhs, 1)
5416         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
5417       if (TREE_OPERAND (rhs, 1) == error_mark_node)
5418         return error_mark_node;
5419       TREE_OPERAND (rhs, 2)
5420         = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), complain);
5421       if (TREE_OPERAND (rhs, 2) == error_mark_node)
5422         return error_mark_node;
5423
5424       TREE_TYPE (rhs) = lhstype;
5425       return rhs;
5426
5427     case MODIFY_EXPR:
5428       TREE_OPERAND (rhs, 1)
5429         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
5430       if (TREE_OPERAND (rhs, 1) == error_mark_node)
5431         return error_mark_node;
5432
5433       TREE_TYPE (rhs) = lhstype;
5434       return rhs;
5435
5436     case ADDR_EXPR:
5437       if (TYPE_PTRMEMFUNC_P (lhstype))
5438         lhstype = TYPE_PTRMEMFUNC_FN_TYPE (lhstype);
5439       else if (TREE_CODE (lhstype) != POINTER_TYPE)
5440         {
5441           if (complain)
5442             error ("type for resolving address of overloaded function must be pointer type");
5443           return error_mark_node;
5444         }
5445       {
5446         tree fn = instantiate_type (TREE_TYPE (lhstype), TREE_OPERAND (rhs, 0), complain);
5447         if (fn == error_mark_node)
5448           return error_mark_node;
5449         mark_addressable (fn);
5450         TREE_TYPE (rhs) = lhstype;
5451         TREE_OPERAND (rhs, 0) = fn;
5452         TREE_CONSTANT (rhs) = staticp (fn);
5453         if (TREE_CODE (lhstype) == POINTER_TYPE
5454             && TREE_CODE (TREE_TYPE (lhstype)) == METHOD_TYPE)
5455           {
5456             build_ptrmemfunc_type (lhstype);
5457             rhs = build_ptrmemfunc (lhstype, rhs, 0);
5458           }
5459       }
5460       return rhs;
5461
5462     case ENTRY_VALUE_EXPR:
5463       my_friendly_abort (184);
5464       return error_mark_node;
5465
5466     case ERROR_MARK:
5467       return error_mark_node;
5468
5469     default:
5470       my_friendly_abort (185);
5471       return error_mark_node;
5472     }
5473 }
5474 \f
5475 /* Return the name of the virtual function pointer field
5476    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
5477    this may have to look back through base types to find the
5478    ultimate field name.  (For single inheritance, these could
5479    all be the same name.  Who knows for multiple inheritance).  */
5480
5481 static tree
5482 get_vfield_name (type)
5483      tree type;
5484 {
5485   tree binfo = TYPE_BINFO (type);
5486   char *buf;
5487
5488   while (BINFO_BASETYPES (binfo)
5489          && TYPE_VIRTUAL_P (BINFO_TYPE (BINFO_BASETYPE (binfo, 0)))
5490          && ! TREE_VIA_VIRTUAL (BINFO_BASETYPE (binfo, 0)))
5491     binfo = BINFO_BASETYPE (binfo, 0);
5492
5493   type = BINFO_TYPE (binfo);
5494   buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
5495                          + TYPE_NAME_LENGTH (type) + 2);
5496   sprintf (buf, VFIELD_NAME_FORMAT, TYPE_NAME_STRING (type));
5497   return get_identifier (buf);
5498 }
5499
5500 void
5501 print_class_statistics ()
5502 {
5503 #ifdef GATHER_STATISTICS
5504   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
5505   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
5506   fprintf (stderr, "build_method_call = %d (inner = %d)\n",
5507            n_build_method_call, n_inner_fields_searched);
5508   if (n_vtables)
5509     {
5510       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
5511                n_vtables, n_vtable_searches);
5512       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
5513                n_vtable_entries, n_vtable_elems);
5514     }
5515 #endif
5516 }
5517
5518 /* Push an obstack which is sufficiently long-lived to hold such class
5519    decls that may be cached in the previous_class_values list.  For now, let's
5520    use the permanent obstack, later we may create a dedicated obstack just
5521    for this purpose.  The effect is undone by pop_obstacks.  */
5522
5523 void
5524 maybe_push_cache_obstack ()
5525 {
5526   push_obstacks_nochange ();
5527   if (current_class_depth == 1)
5528     current_obstack = &permanent_obstack;
5529 }
5530
5531 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
5532    according to [class]:
5533                                           The class-name is also inserted
5534    into  the scope of the class itself.  For purposes of access checking,
5535    the inserted class name is treated as if it were a public member name.  */
5536
5537 tree
5538 build_self_reference ()
5539 {
5540   tree name = constructor_name (current_class_type);
5541   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
5542   DECL_NONLOCAL (value) = 1;
5543   DECL_CONTEXT (value) = current_class_type;
5544   DECL_CLASS_CONTEXT (value) = current_class_type;
5545   CLASSTYPE_LOCAL_TYPEDECLS (current_class_type) = 1;
5546   DECL_ARTIFICIAL (value) = 1;
5547
5548   pushdecl_class_level (value);
5549   return value;
5550 }
5551
5552 /* Returns 1 if TYPE contains only padding bytes.  */
5553
5554 int
5555 is_empty_class (type)
5556      tree type;
5557 {
5558   tree t;
5559
5560   if (type == error_mark_node)
5561     return 0;
5562
5563   if (! IS_AGGR_TYPE (type))
5564     return 0;
5565
5566   if (flag_new_abi)
5567     return CLASSTYPE_SIZE (type) == integer_zero_node;
5568
5569   if (TYPE_BINFO_BASETYPES (type))
5570     return 0;
5571   t = TYPE_FIELDS (type);
5572   while (t && TREE_CODE (t) != FIELD_DECL)
5573     t = TREE_CHAIN (t);
5574   return (t == NULL_TREE);
5575 }