gcc/cp/class.c

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