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