gcc/java/class.c

   1 /* Functions related to building classes and their related objects.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC 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 GCC 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 GCC; 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 Java and all Java-based marks are trademarks or registered trademarks
  23 of Sun Microsystems, Inc. in the United States and other countries.
  24 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  25
  26 /* Written by Per Bothner <bothner@cygnus.com> */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tm.h"
  32 #include "tree.h"
  33 #include "rtl.h"
  34 #include "flags.h"
  35 #include "java-tree.h"
  36 #include "jcf.h"
  37 #include "obstack.h"
  38 #include "toplev.h"
  39 #include "output.h"
  40 #include "parse.h"
  41 #include "function.h"
  42 #include "ggc.h"
  43 #include "stdio.h"
  44 #include "target.h"
  45
  46 /* DOS brain-damage */
  47 #ifndef O_BINARY
  48 #define O_BINARY 0 /* MS-DOS brain-damage */
  49 #endif
  50
  51 static tree make_method_value (tree);
  52 static tree build_java_method_type (tree, tree, int);
  53 static int32 hashUtf8String (const char *, int);
  54 static tree make_field_value (tree);
  55 static tree get_dispatch_vector (tree);
  56 static tree get_dispatch_table (tree, tree);
  57 static int supers_all_compiled (tree type);
  58 static void add_interface_do (tree, tree, int);
  59 static tree maybe_layout_super_class (tree, tree);
  60 static int assume_compiled (const char *);
  61 static tree build_method_symbols_entry (tree);
  62
  63 static GTY(()) rtx registerClass_libfunc;
  64
  65 struct obstack temporary_obstack;
  66
  67 /* The compiler generates different code depending on whether or not
  68    it can assume certain classes have been compiled down to native
  69    code or not.  The compiler options -fassume-compiled= and
  70    -fno-assume-compiled= are used to create a tree of
  71    assume_compiled_node objects.  This tree is queried to determine if
  72    a class is assume to be compiled or not.  Each node in the tree
  73    represents either a package or a specific class.  */
  74
  75 typedef struct assume_compiled_node_struct
  76 {
  77   /* The class or package name.  */
  78   const char *ident;
  79
  80   /* Nonzero if this represents an exclusion.  */
  81   int excludep;
  82
  83   /* Pointers to other nodes in the tree.  */
  84   struct assume_compiled_node_struct *parent;
  85   struct assume_compiled_node_struct *sibling;
  86   struct assume_compiled_node_struct *child;
  87 } assume_compiled_node;
  88
  89 static assume_compiled_node *find_assume_compiled_node (assume_compiled_node *,
  90                                                         const char *);
  91
  92 /* This is the root of the include/exclude tree.  */
  93
  94 static assume_compiled_node *assume_compiled_tree;
  95
  96 static GTY(()) tree class_roots[5];
  97 #define registered_class class_roots[0]
  98 #define fields_ident class_roots[1]  /* get_identifier ("fields") */
  99 #define info_ident class_roots[2]  /* get_identifier ("info") */
 100 #define class_list class_roots[3]
 101 #define class_dtable_decl class_roots[4]
 102
 103 /* Return the node that most closely represents the class whose name
 104    is IDENT.  Start the search from NODE.  Return NULL if an
 105    appropriate node does not exist.  */
 106
 107 static assume_compiled_node *
 108 find_assume_compiled_node (assume_compiled_node *node, const char *ident)
 109 {
 110   while (node)
 111     {
 112       size_t node_ident_length = strlen (node->ident);
 113
 114       /* node_ident_length is zero at the root of the tree.  If the
 115          identifiers are the same length, then we have matching
 116          classes.  Otherwise check if we've matched an enclosing
 117          package name.  */
 118
 119       if (node_ident_length == 0
 120           || (strncmp (ident, node->ident, node_ident_length) == 0
 121               && (strlen (ident) == node_ident_length
 122                   || ident[node_ident_length] == '.')))
 123         {
 124           /* We've found a match, however, there might be a more
 125              specific match.  */
 126
 127           assume_compiled_node *found = find_assume_compiled_node (node->child,
 128                                                                    ident);
 129           if (found)
 130             return found;
 131           else
 132             return node;
 133         }
 134
 135       /* No match yet.  Continue through the sibling list.  */
 136       node = node->sibling;
 137     }
 138
 139   /* No match at all in this tree.  */
 140   return NULL;
 141 }
 142
 143 /* Add a new IDENT to the include/exclude tree.  It's an exclusion
 144    if EXCLUDEP is nonzero.  */
 145
 146 void
 147 add_assume_compiled (const char *ident, int excludep)
 148 {
 149   int len;
 150   assume_compiled_node *parent;
 151   assume_compiled_node *node = xmalloc (sizeof (assume_compiled_node));
 152
 153   node->ident = xstrdup (ident);
 154   node->excludep = excludep;
 155   node->child = NULL;
 156
 157   /* Create the root of the tree if it doesn't exist yet.  */
 158
 159   if (NULL == assume_compiled_tree)
 160     {
 161       assume_compiled_tree = xmalloc (sizeof (assume_compiled_node));
 162       assume_compiled_tree->ident = "";
 163       assume_compiled_tree->excludep = 0;
 164       assume_compiled_tree->sibling = NULL;
 165       assume_compiled_tree->child = NULL;
 166       assume_compiled_tree->parent = NULL;
 167     }
 168
 169   /* Calling the function with the empty string means we're setting
 170      excludep for the root of the hierarchy.  */
 171
 172   if (0 == ident[0])
 173     {
 174       assume_compiled_tree->excludep = excludep;
 175       return;
 176     }
 177
 178   /* Find the parent node for this new node.  PARENT will either be a
 179      class or a package name.  Adjust PARENT accordingly.  */
 180
 181   parent = find_assume_compiled_node (assume_compiled_tree, ident);
 182   len = strlen (parent->ident);
 183   if (parent->ident[len] && parent->ident[len] != '.')
 184     parent = parent->parent;
 185
 186   /* Insert NODE into the tree.  */
 187
 188   node->parent = parent;
 189   node->sibling = parent->child;
 190   parent->child = node;
 191 }
 192
 193 /* Returns nonzero if IDENT is the name of a class that the compiler
 194    should assume has been compiled to object code.  */
 195
 196 static int
 197 assume_compiled (const char *ident)
 198 {
 199   assume_compiled_node *i;
 200   int result;
 201
 202   if (NULL == assume_compiled_tree)
 203     return 1;
 204
 205   i = find_assume_compiled_node (assume_compiled_tree,
 206                                  ident);
 207
 208   result = ! i->excludep;
 209
 210   return (result);
 211 }
 212
 213 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
 214    except that characters matching OLD_CHAR are substituted by NEW_CHAR.
 215    Also, PREFIX is prepended, and SUFFIX is appended. */
 216
 217 tree
 218 ident_subst (const char* old_name,
 219              int old_length,
 220              const char *prefix,
 221              int old_char,
 222              int new_char,
 223              const char *suffix)
 224 {
 225   int prefix_len = strlen (prefix);
 226   int suffix_len = strlen (suffix);
 227   int i = prefix_len + old_length + suffix_len + 1;
 228 #ifdef __GNUC__
 229   char buffer[i];
 230 #else
 231   char *buffer = alloca (i);
 232 #endif
 233   strcpy (buffer, prefix);
 234   for (i = 0; i < old_length; i++)
 235     {
 236       char ch = old_name[i];
 237       if (ch == old_char)
 238         ch = new_char;
 239       buffer[prefix_len + i] = ch;
 240     }
 241   strcpy (buffer + prefix_len + old_length, suffix);
 242   return get_identifier (buffer);
 243 }
 244
 245 /* Return an IDENTIFIER_NODE the same as OLD_ID,
 246    except that characters matching OLD_CHAR are substituted by NEW_CHAR.
 247    Also, PREFIX is prepended, and SUFFIX is appended. */
 248
 249 tree
 250 identifier_subst (const tree old_id,
 251                   const char *prefix,
 252                   int old_char,
 253                   int new_char,
 254                   const char *suffix)
 255 {
 256   return ident_subst (IDENTIFIER_POINTER (old_id), IDENTIFIER_LENGTH (old_id),
 257                       prefix, old_char, new_char, suffix);
 258 }
 259
 260 /* Generate a valid C identifier from the name of the class TYPE,
 261    prefixed by PREFIX. */
 262
 263 tree
 264 mangled_classname (const char *prefix, tree type)
 265 {
 266   tree ident = TYPE_NAME (type);
 267   if (TREE_CODE (ident) != IDENTIFIER_NODE)
 268     ident = DECL_NAME (ident);
 269   return identifier_subst (ident, prefix, '.', '_', "");
 270 }
 271
 272 tree
 273 make_class (void)
 274 {
 275   tree type;
 276   type = make_node (RECORD_TYPE);
 277   TYPE_BINFO (type) = make_tree_vec (BINFO_ELTS);
 278   MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
 279
 280   return type;
 281 }
 282
 283 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
 284    and where each of the constituents is separated by '/',
 285    return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
 286
 287 tree
 288 unmangle_classname (const char *name, int name_length)
 289 {
 290   tree to_return = ident_subst (name, name_length, "", '/', '.', "");
 291   /* It's not sufficient to compare to_return and get_identifier
 292      (name) to determine whether to_return is qualified. There are
 293      cases in signature analysis where name will be stripped of a
 294      trailing ';'. */
 295   name = IDENTIFIER_POINTER (to_return);
 296   while (*name)
 297     if (*name++ == '.')
 298       {
 299         QUALIFIED_P (to_return) = 1;
 300         break;
 301       }
 302
 303   return to_return;
 304 }
 305
 306 tree
 307 push_class (tree class_type, tree class_name)
 308 {
 309   tree decl, signature;
 310   location_t saved_loc = input_location;
 311   tree source_name = identifier_subst (class_name, "", '.', '/', ".java");
 312   CLASS_P (class_type) = 1;
 313   input_filename = IDENTIFIER_POINTER (source_name);
 314   input_line = 0;
 315   decl = build_decl (TYPE_DECL, class_name, class_type);
 316
 317   /* dbxout needs a DECL_SIZE if in gstabs mode */
 318   DECL_SIZE (decl) = integer_zero_node;
 319
 320   input_location = saved_loc;
 321   signature = identifier_subst (class_name, "L", '.', '/', ";");
 322   IDENTIFIER_SIGNATURE_TYPE (signature) = build_pointer_type (class_type);
 323
 324   /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
 325      both a typedef and in the struct name-space.  We may want to re-visit
 326      this later, but for now it reduces the changes needed for gdb. */
 327   DECL_ARTIFICIAL (decl) = 1;
 328
 329   pushdecl_top_level (decl);
 330
 331   return decl;
 332 }
 333
 334 /* Finds the (global) class named NAME.  Creates the class if not found.
 335    Also creates associated TYPE_DECL.
 336    Does not check if the class actually exists, load the class,
 337    fill in field or methods, or do layout_type. */
 338
 339 tree
 340 lookup_class (tree name)
 341 {
 342   tree decl = IDENTIFIER_CLASS_VALUE (name);
 343   if (decl == NULL_TREE)
 344     decl = push_class (make_class (), name);
 345   return TREE_TYPE (decl);
 346 }
 347
 348 void
 349 set_super_info (int access_flags, tree this_class,
 350                 tree super_class, int interfaces_count)
 351 {
 352   int total_supers = interfaces_count;
 353   tree class_decl = TYPE_NAME (this_class);
 354   if (super_class)
 355     total_supers++;
 356
 357   TYPE_BINFO_BASETYPES (this_class) = make_tree_vec (total_supers);
 358   if (super_class)
 359     {
 360       tree super_binfo = make_tree_vec (BINFO_ELTS);
 361       BINFO_TYPE (super_binfo) = super_class;
 362       BINFO_OFFSET (super_binfo) = integer_zero_node;
 363       TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (this_class)), 0)
 364         = super_binfo;
 365       CLASS_HAS_SUPER (this_class) = 1;
 366     }
 367
 368   set_class_decl_access_flags (access_flags, class_decl);
 369 }
 370
 371 void
 372 set_class_decl_access_flags (int access_flags, tree class_decl)
 373 {
 374   if (access_flags & ACC_PUBLIC)    CLASS_PUBLIC (class_decl) = 1;
 375   if (access_flags & ACC_FINAL)     CLASS_FINAL (class_decl) = 1;
 376   if (access_flags & ACC_SUPER)     CLASS_SUPER (class_decl) = 1;
 377   if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
 378   if (access_flags & ACC_ABSTRACT)  CLASS_ABSTRACT (class_decl) = 1;
 379   if (access_flags & ACC_STATIC)    CLASS_STATIC (class_decl) = 1;
 380   if (access_flags & ACC_PRIVATE)   CLASS_PRIVATE (class_decl) = 1;
 381   if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
 382   if (access_flags & ACC_STRICT)    CLASS_STRICTFP (class_decl) = 1;
 383 }
 384
 385 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
 386    direct sub-classes of Object are 1, and so on. */
 387
 388 int
 389 class_depth (tree clas)
 390 {
 391   int depth = 0;
 392   if (! CLASS_LOADED_P (clas))
 393     load_class (clas, 1);
 394   if (TYPE_SIZE (clas) == error_mark_node)
 395     return -1;
 396   while (clas != object_type_node)
 397     {
 398       depth++;
 399       clas = TYPE_BINFO_BASETYPE (clas, 0);
 400     }
 401   return depth;
 402 }
 403
 404 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
 405
 406 int
 407 interface_of_p (tree type1, tree type2)
 408 {
 409   int n, i;
 410   tree basetype_vec;
 411
 412   if (!(basetype_vec = TYPE_BINFO_BASETYPES (type2)))
 413     return 0;
 414   n = TREE_VEC_LENGTH (basetype_vec);
 415   for (i = 0; i < n; i++)
 416     {
 417       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
 418       if (vec_elt && BINFO_TYPE (vec_elt) == type1)
 419         return 1;
 420     }
 421   for (i = 0; i < n; i++)
 422     {
 423       tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
 424       if (vec_elt && BINFO_TYPE (vec_elt)
 425           && interface_of_p (type1, BINFO_TYPE (vec_elt)))
 426         return 1;
 427     }
 428   return 0;
 429 }
 430
 431 /* Return true iff TYPE1 inherits from TYPE2. */
 432
 433 int
 434 inherits_from_p (tree type1, tree type2)
 435 {
 436   while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
 437     {
 438       if (type1 == type2)
 439         return 1;
 440       type1 = CLASSTYPE_SUPER (type1);
 441     }
 442   return 0;
 443 }
 444
 445 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
 446
 447 int
 448 enclosing_context_p (tree type1, tree type2)
 449 {
 450   if (!INNER_CLASS_TYPE_P (type2))
 451     return 0;
 452
 453   for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
 454        type2;
 455        type2 = (INNER_CLASS_TYPE_P (type2) ?
 456                 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
 457     {
 458       if (type2 == type1)
 459         return 1;
 460     }
 461
 462   return 0;
 463 }
 464
 465 /* Return 1 iff there exists a common enclosing context between TYPE1
 466    and TYPE2.  */
 467
 468 int common_enclosing_context_p (tree type1, tree type2)
 469 {
 470   if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
 471     return 0;
 472
 473   for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1;
 474        type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
 475                 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
 476     {
 477       tree current;
 478       for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
 479            current = (PURE_INNER_CLASS_TYPE_P (current) ?
 480                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
 481                       NULL_TREE))
 482         if (type1 == current)
 483           return 1;
 484     }
 485   return 0;
 486 }
 487
 488 static void
 489 add_interface_do (tree basetype_vec, tree interface_class, int i)
 490 {
 491   tree interface_binfo = make_tree_vec (BINFO_ELTS);
 492   BINFO_TYPE (interface_binfo) = interface_class;
 493   BINFO_OFFSET (interface_binfo) = integer_zero_node;
 494   BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node;
 495   TREE_VIA_VIRTUAL (interface_binfo) = 1;
 496   TREE_VEC_ELT (basetype_vec, i) = interface_binfo;
 497 }
 498
 499 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
 500    found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
 501    if attempt is made to add it twice. */
 502
 503 tree
 504 maybe_add_interface (tree this_class, tree interface_class)
 505 {
 506   tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
 507   int i;
 508   int n = TREE_VEC_LENGTH (basetype_vec);
 509   for (i = 0; ; i++)
 510     {
 511       if (i >= n)
 512         {
 513           error ("internal error - too many interface type");
 514           return NULL_TREE;
 515         }
 516       else if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
 517         break;
 518       else if (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)) == interface_class)
 519         return interface_class;
 520     }
 521   add_interface_do (basetype_vec, interface_class, i);
 522   return NULL_TREE;
 523 }
 524
 525 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
 526
 527 void
 528 add_interface (tree this_class, tree interface_class)
 529 {
 530   tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
 531   int i;
 532   int n = TREE_VEC_LENGTH (basetype_vec);
 533   for (i = 0; ; i++)
 534     {
 535       if (i >= n)
 536         {
 537           error ("internal error - too many interface type");
 538           return;
 539         }
 540       else if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
 541         break;
 542     }
 543   add_interface_do (basetype_vec, interface_class, i);
 544 }
 545
 546 #if 0
 547 /* Return the address of a pointer to the first FUNCTION_DECL
 548    in the list (*LIST) whose DECL_NAME is NAME. */
 549
 550 static tree *
 551 find_named_method (tree *list, tree name)
 552 {
 553   while (*list && DECL_NAME (*list) != name)
 554     list = &TREE_CHAIN (*list);
 555   return list;
 556 }
 557 #endif
 558
 559 static tree
 560 build_java_method_type (tree fntype, tree this_class, int access_flags)
 561 {
 562   if (access_flags & ACC_STATIC)
 563     return fntype;
 564   return build_method_type (this_class, fntype);
 565 }
 566
 567 tree
 568 add_method_1 (tree this_class, int access_flags, tree name, tree function_type)
 569 {
 570   tree method_type, fndecl;
 571
 572   method_type = build_java_method_type (function_type,
 573                                         this_class, access_flags);
 574
 575   fndecl = build_decl (FUNCTION_DECL, name, method_type);
 576   DECL_CONTEXT (fndecl) = this_class;
 577
 578   DECL_LANG_SPECIFIC (fndecl)
 579     = ggc_alloc_cleared (sizeof (struct lang_decl));
 580   DECL_LANG_SPECIFIC (fndecl)->desc = LANG_DECL_FUNC;
 581
 582   /* Initialize the static initializer test table.  */
 583
 584   DECL_FUNCTION_INIT_TEST_TABLE (fndecl) =
 585     java_treetreehash_create (10, 1);
 586
 587   /* Initialize the initialized (static) class table. */
 588   if (access_flags & ACC_STATIC)
 589     DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) =
 590       htab_create_ggc (50, htab_hash_pointer, htab_eq_pointer, NULL);
 591
 592   /* Initialize the static method invocation compound list */
 593   DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = NULL_TREE;
 594
 595   TREE_CHAIN (fndecl) = TYPE_METHODS (this_class);
 596   TYPE_METHODS (this_class) = fndecl;
 597
 598   /* Notice that this is a finalizer and update the class type
 599      accordingly. This is used to optimize instance allocation. */
 600   if (name == finalize_identifier_node
 601       && TREE_TYPE (function_type) == void_type_node
 602       && TREE_VALUE (TYPE_ARG_TYPES (function_type)) == void_type_node)
 603     HAS_FINALIZER_P (this_class) = 1;
 604
 605   if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
 606   if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
 607   if (access_flags & ACC_PRIVATE)
 608     METHOD_PRIVATE (fndecl) = DECL_INLINE (fndecl) = 1;
 609   if (access_flags & ACC_NATIVE)
 610     {
 611       METHOD_NATIVE (fndecl) = 1;
 612       DECL_EXTERNAL (fndecl) = 1;
 613     }
 614   if (access_flags & ACC_STATIC)
 615     METHOD_STATIC (fndecl) = DECL_INLINE (fndecl) = 1;
 616   if (access_flags & ACC_FINAL)
 617     METHOD_FINAL (fndecl) = DECL_INLINE (fndecl) = 1;
 618   if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
 619   if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
 620   if (access_flags & ACC_TRANSIENT) METHOD_TRANSIENT (fndecl) = 1;
 621   if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
 622   return fndecl;
 623 }
 624
 625 /* Add a method to THIS_CLASS.
 626    The method's name is NAME.
 627    Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
 628
 629 tree
 630 add_method (tree this_class, int access_flags, tree name, tree method_sig)
 631 {
 632   tree function_type, fndecl;
 633   const unsigned char *sig
 634     = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
 635
 636   if (sig[0] != '(')
 637     fatal_error ("bad method signature");
 638
 639   function_type = get_type_from_signature (method_sig);
 640   fndecl = add_method_1 (this_class, access_flags, name, function_type);
 641   set_java_signature (TREE_TYPE (fndecl), method_sig);
 642   return fndecl;
 643 }
 644
 645 tree
 646 add_field (tree class, tree name, tree field_type, int flags)
 647 {
 648   int is_static = (flags & ACC_STATIC) != 0;
 649   tree field;
 650   field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type);
 651   TREE_CHAIN (field) = TYPE_FIELDS (class);
 652   TYPE_FIELDS (class) = field;
 653   DECL_CONTEXT (field) = class;
 654
 655   if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
 656   if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
 657   if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
 658   if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
 659   if (flags & ACC_VOLATILE) FIELD_VOLATILE (field) = 1;
 660   if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
 661   if (is_static)
 662     {
 663       FIELD_STATIC (field) = 1;
 664       /* Always make field externally visible.  This is required so
 665          that native methods can always access the field.  */
 666       TREE_PUBLIC (field) = 1;
 667       /* Considered external until we know what classes are being
 668          compiled into this object file.  */
 669       DECL_EXTERNAL (field) = 1;
 670     }
 671
 672   return field;
 673 }
 674
 675 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
 676
 677 void
 678 set_constant_value (tree field, tree constant)
 679 {
 680   if (field == NULL_TREE)
 681     warning ("misplaced ConstantValue attribute (not in any field)");
 682   else if (DECL_INITIAL (field) != NULL_TREE)
 683     warning ("duplicate ConstantValue attribute for field '%s'",
 684              IDENTIFIER_POINTER (DECL_NAME (field)));
 685   else
 686     {
 687       DECL_INITIAL (field) = constant;
 688       if (TREE_TYPE (constant) != TREE_TYPE (field)
 689           && ! (TREE_TYPE (constant) == int_type_node
 690                 && INTEGRAL_TYPE_P (TREE_TYPE (field))
 691                 && TYPE_PRECISION (TREE_TYPE (field)) <= 32)
 692           && ! (TREE_TYPE (constant) == utf8const_ptr_type
 693                 && TREE_TYPE (field) == string_ptr_type_node))
 694         error ("ConstantValue attribute of field '%s' has wrong type",
 695                IDENTIFIER_POINTER (DECL_NAME (field)));
 696       if (FIELD_FINAL (field))
 697         DECL_FIELD_FINAL_IUD (field) = 1;
 698     }
 699 }
 700
 701 /* Count the number of Unicode chars encoded in a given Ut8 string. */
 702
 703 #if 0
 704 int
 705 strLengthUtf8 (char *str, int len)
 706 {
 707   register unsigned char* ptr = (unsigned char*) str;
 708   register unsigned char *limit = ptr + len;
 709   int str_length = 0;
 710   for (; ptr < limit; str_length++) {
 711     if (UTF8_GET (ptr, limit) < 0)
 712       return -1;
 713   }
 714   return str_length;
 715 }
 716 #endif
 717
 718
 719 /* Calculate a hash value for a string encoded in Utf8 format.
 720  * This returns the same hash value as specified for java.lang.String.hashCode.
 721  */
 722
 723 static int32
 724 hashUtf8String (const char *str, int len)
 725 {
 726   register const unsigned char* ptr = (const unsigned char*) str;
 727   register const unsigned char *limit = ptr + len;
 728   int32 hash = 0;
 729   for (; ptr < limit;)
 730     {
 731       int ch = UTF8_GET (ptr, limit);
 732       /* Updated specification from
 733          http://www.javasoft.com/docs/books/jls/clarify.html. */
 734       hash = (31 * hash) + ch;
 735     }
 736   return hash;
 737 }
 738
 739 static GTY(()) tree utf8_decl_list = NULL_TREE;
 740
 741 tree
 742 build_utf8_ref (tree name)
 743 {
 744   const char * name_ptr = IDENTIFIER_POINTER(name);
 745   int name_len = IDENTIFIER_LENGTH(name);
 746   char buf[60];
 747   tree ctype, field = NULL_TREE, str_type, cinit, string;
 748   static int utf8_count = 0;
 749   int name_hash;
 750   tree ref = IDENTIFIER_UTF8_REF (name);
 751   tree decl;
 752   if (ref != NULL_TREE)
 753     return ref;
 754
 755   ctype = make_node (RECORD_TYPE);
 756   str_type = build_prim_array_type (unsigned_byte_type_node,
 757                                     name_len + 1); /* Allow for final '\0'. */
 758   PUSH_FIELD (ctype, field, "hash", unsigned_short_type_node);
 759   PUSH_FIELD (ctype, field, "length", unsigned_short_type_node);
 760   PUSH_FIELD (ctype, field, "data", str_type);
 761   FINISH_RECORD (ctype);
 762   START_RECORD_CONSTRUCTOR (cinit, ctype);
 763   name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
 764   PUSH_FIELD_VALUE (cinit, "hash", build_int_2 (name_hash, 0));
 765   PUSH_FIELD_VALUE (cinit, "length", build_int_2 (name_len, 0));
 766   string = build_string (name_len, name_ptr);
 767   TREE_TYPE (string) = str_type;
 768   PUSH_FIELD_VALUE (cinit, "data", string);
 769   FINISH_RECORD_CONSTRUCTOR (cinit);
 770   TREE_CONSTANT (cinit) = 1;
 771
 772   /* Generate a unique-enough identifier.  */
 773   sprintf(buf, "_Utf%d", ++utf8_count);
 774
 775   decl = build_decl (VAR_DECL, get_identifier (buf), utf8const_type);
 776   TREE_STATIC (decl) = 1;
 777   DECL_ARTIFICIAL (decl) = 1;
 778   DECL_IGNORED_P (decl) = 1;
 779   TREE_READONLY (decl) = 1;
 780   TREE_THIS_VOLATILE (decl) = 0;
 781   DECL_INITIAL (decl) = cinit;
 782 #ifdef HAVE_GAS_SHF_MERGE
 783   {
 784     int decl_size;
 785     /* Ensure decl_size is a multiple of utf8const_type's alignment. */
 786     decl_size = (name_len + 5 + TYPE_ALIGN_UNIT (utf8const_type) - 1)
 787                  & ~(TYPE_ALIGN_UNIT (utf8const_type) - 1);
 788     if (flag_merge_constants && decl_size < 256)
 789       {
 790         char buf[32];
 791         int flags = (SECTION_OVERRIDE
 792                    | SECTION_MERGE | (SECTION_ENTSIZE & decl_size));
 793         sprintf (buf, ".rodata.jutf8.%d", decl_size);
 794         named_section_flags (buf, flags);
 795         DECL_SECTION_NAME (decl) = build_string (strlen (buf), buf);
 796       }
 797   }
 798 #endif
 799   TREE_CHAIN (decl) = utf8_decl_list;
 800   layout_decl (decl, 0);
 801   pushdecl (decl);
 802   rest_of_decl_compilation (decl, (char*) 0, global_bindings_p (), 0);
 803   utf8_decl_list = decl;
 804   make_decl_rtl (decl, (char*) 0);
 805   ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
 806   IDENTIFIER_UTF8_REF (name) = ref;
 807   return ref;
 808 }
 809
 810 /* Build a reference to the class TYPE.
 811    Also handles primitive types and array types. */
 812
 813 tree
 814 build_class_ref (tree type)
 815 {
 816   int is_compiled = is_compiled_class (type);
 817   if (is_compiled)
 818     {
 819       tree ref, decl_name, decl;
 820       if (TREE_CODE (type) == POINTER_TYPE)
 821         type = TREE_TYPE (type);
 822       if (TREE_CODE (type) == RECORD_TYPE)
 823         {
 824           if (TYPE_SIZE (type) == error_mark_node)
 825             return null_pointer_node;
 826           decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
 827                                         "", '/', '/', ".class");
 828           decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
 829           if (decl == NULL_TREE)
 830             {
 831               decl = build_decl (VAR_DECL, decl_name, class_type_node);
 832               DECL_SIZE (decl) = TYPE_SIZE (class_type_node);
 833               DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (class_type_node);
 834               TREE_STATIC (decl) = 1;
 835               TREE_PUBLIC (decl) = 1;
 836               DECL_IGNORED_P (decl) = 1;
 837               DECL_ARTIFICIAL (decl) = 1;
 838               if (is_compiled == 1)
 839                 DECL_EXTERNAL (decl) = 1;
 840               SET_DECL_ASSEMBLER_NAME (decl,
 841                                        java_mangle_class_field
 842                                        (&temporary_obstack, type));
 843               make_decl_rtl (decl, NULL);
 844               pushdecl_top_level (decl);
 845             }
 846         }
 847       else
 848         {
 849           const char *name;
 850           char buffer[25];
 851           if (flag_emit_class_files)
 852             {
 853               const char *prim_class_name;
 854               tree prim_class;
 855               if (type == char_type_node)
 856                 prim_class_name = "java.lang.Character";
 857               else if (type == boolean_type_node)
 858                 prim_class_name = "java.lang.Boolean";
 859               else if (type == byte_type_node)
 860                 prim_class_name = "java.lang.Byte";
 861               else if (type == short_type_node)
 862                 prim_class_name = "java.lang.Short";
 863               else if (type == int_type_node)
 864                 prim_class_name = "java.lang.Integer";
 865               else if (type == long_type_node)
 866                 prim_class_name = "java.lang.Long";
 867               else if (type == float_type_node)
 868                 prim_class_name = "java.lang.Float";
 869               else if (type == double_type_node)
 870                 prim_class_name = "java.lang.Double";
 871               else if (type == void_type_node)
 872                 prim_class_name = "java.lang.Void";
 873               else
 874                 abort ();
 875
 876               prim_class = lookup_class (get_identifier (prim_class_name));
 877               return build (COMPONENT_REF, NULL_TREE,
 878                             prim_class, TYPE_identifier_node);
 879             }
 880           decl_name = TYPE_NAME (type);
 881           if (TREE_CODE (decl_name) == TYPE_DECL)
 882             decl_name = DECL_NAME (decl_name);
 883           name = IDENTIFIER_POINTER (decl_name);
 884           if (strncmp (name, "promoted_", 9) == 0)
 885             name += 9;
 886           sprintf (buffer, "_Jv_%sClass", name);
 887           decl_name = get_identifier (buffer);
 888           decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
 889           if (decl == NULL_TREE)
 890             {
 891               decl = build_decl (VAR_DECL, decl_name, class_type_node);
 892               TREE_STATIC (decl) = 1;
 893               TREE_PUBLIC (decl) = 1;
 894               DECL_EXTERNAL (decl) = 1;
 895               make_decl_rtl (decl, NULL);
 896               pushdecl_top_level (decl);
 897             }
 898         }
 899
 900       ref = build1 (ADDR_EXPR, class_ptr_type, decl);
 901       return ref;
 902     }
 903   else
 904     {
 905       int index;
 906       tree cl;
 907       index = alloc_class_constant (type);
 908       cl = build_ref_from_constant_pool (index);
 909       TREE_TYPE (cl) = promote_type (class_ptr_type);
 910       return cl;
 911     }
 912 }
 913
 914 tree
 915 build_static_field_ref (tree fdecl)
 916 {
 917   tree fclass = DECL_CONTEXT (fdecl);
 918   int is_compiled = is_compiled_class (fclass);
 919
 920   /* Allow static final fields to fold to a constant.  When using
 921      -fno-assume-compiled, gcj will sometimes try to fold a field from
 922      an uncompiled class.  This is required when the field in question
 923      meets the appropriate criteria for a compile-time constant.
 924      However, currently sometimes gcj is too eager and will end up
 925      returning the field itself, leading to an incorrect external
 926      reference being generated.  */
 927   if (is_compiled
 928       || (FIELD_FINAL (fdecl) && DECL_INITIAL (fdecl) != NULL_TREE
 929           && (JSTRING_TYPE_P (TREE_TYPE (fdecl))
 930               || JNUMERIC_TYPE_P (TREE_TYPE (fdecl)))
 931           && TREE_CONSTANT (DECL_INITIAL (fdecl))))
 932     {
 933       if (!DECL_RTL_SET_P (fdecl))
 934         {
 935           if (is_compiled == 1)
 936             DECL_EXTERNAL (fdecl) = 1;
 937           make_decl_rtl (fdecl, NULL);
 938         }
 939       return fdecl;
 940     }
 941   else
 942     {
 943       /* Compile as:
 944        * *(FTYPE*)build_class_ref(FCLASS)->fields[INDEX].info.addr */
 945       tree ref = build_class_ref (fclass);
 946       tree fld;
 947       int field_index = 0;
 948       ref = build1 (INDIRECT_REF, class_type_node, ref);
 949       ref = build (COMPONENT_REF, field_ptr_type_node, ref,
 950                    lookup_field (&class_type_node, fields_ident));
 951
 952       for (fld = TYPE_FIELDS (fclass); ; fld = TREE_CHAIN (fld))
 953         {
 954           if (fld == fdecl)
 955             break;
 956           if (fld == NULL_TREE)
 957             fatal_error ("field '%s' not found in class",
 958                          IDENTIFIER_POINTER (DECL_NAME (fdecl)));
 959           if (FIELD_STATIC (fld))
 960             field_index++;
 961         }
 962       field_index *= int_size_in_bytes (field_type_node);
 963       ref = fold (build (PLUS_EXPR, field_ptr_type_node,
 964                          ref, build_int_2 (field_index, 0)));
 965       ref = build1 (INDIRECT_REF, field_type_node, ref);
 966       ref = build (COMPONENT_REF, field_info_union_node,
 967                    ref, lookup_field (&field_type_node, info_ident));
 968       ref = build (COMPONENT_REF, ptr_type_node,
 969                    ref, TREE_CHAIN (TYPE_FIELDS (field_info_union_node)));
 970       return fold (build1 (INDIRECT_REF, TREE_TYPE(fdecl), ref));
 971     }
 972 }
 973
 974 int
 975 get_access_flags_from_decl (tree decl)
 976 {
 977   int access_flags = 0;
 978   if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
 979     {
 980       if (FIELD_STATIC (decl))
 981         access_flags |= ACC_STATIC;
 982       if (FIELD_PUBLIC (decl))
 983         access_flags |= ACC_PUBLIC;
 984       if (FIELD_PROTECTED (decl))
 985         access_flags |= ACC_PROTECTED;
 986       if (FIELD_PRIVATE (decl))
 987         access_flags |= ACC_PRIVATE;
 988       if (FIELD_FINAL (decl))
 989         access_flags |= ACC_FINAL;
 990       if (FIELD_VOLATILE (decl))
 991         access_flags |= ACC_VOLATILE;
 992       if (FIELD_TRANSIENT (decl))
 993         access_flags |= ACC_TRANSIENT;
 994       return access_flags;
 995     }
 996   if (TREE_CODE (decl) == TYPE_DECL)
 997     {
 998       if (CLASS_PUBLIC (decl))
 999         access_flags |= ACC_PUBLIC;
1000       if (CLASS_FINAL (decl))
1001         access_flags |= ACC_FINAL;
1002       if (CLASS_SUPER (decl))
1003         access_flags |= ACC_SUPER;
1004       if (CLASS_INTERFACE (decl))
1005         access_flags |= ACC_INTERFACE;
1006       if (CLASS_ABSTRACT (decl))
1007         access_flags |= ACC_ABSTRACT;
1008       if (CLASS_STATIC (decl))
1009         access_flags |= ACC_STATIC;
1010       if (CLASS_PRIVATE (decl))
1011         access_flags |= ACC_PRIVATE;
1012       if (CLASS_PROTECTED (decl))
1013         access_flags |= ACC_PROTECTED;
1014       if (CLASS_STRICTFP (decl))
1015         access_flags |= ACC_STRICT;
1016       return access_flags;
1017     }
1018   if (TREE_CODE (decl) == FUNCTION_DECL)
1019     {
1020       if (METHOD_PUBLIC (decl))
1021         access_flags |= ACC_PUBLIC;
1022       if (METHOD_PRIVATE (decl))
1023         access_flags |= ACC_PRIVATE;
1024       if (METHOD_PROTECTED (decl))
1025         access_flags |= ACC_PROTECTED;
1026       if (METHOD_STATIC (decl))
1027         access_flags |= ACC_STATIC;
1028       if (METHOD_FINAL (decl))
1029         access_flags |= ACC_FINAL;
1030       if (METHOD_SYNCHRONIZED (decl))
1031         access_flags |= ACC_SYNCHRONIZED;
1032       if (METHOD_NATIVE (decl))
1033         access_flags |= ACC_NATIVE;
1034       if (METHOD_ABSTRACT (decl))
1035         access_flags |= ACC_ABSTRACT;
1036       if (METHOD_TRANSIENT (decl))
1037         access_flags |= ACC_TRANSIENT;
1038       if (METHOD_STRICTFP (decl))
1039         access_flags |= ACC_STRICT;
1040       return access_flags;
1041     }
1042   abort ();
1043 }
1044
1045 static tree
1046 make_field_value (tree fdecl)
1047 {
1048   tree finit;
1049   int flags;
1050   tree type = TREE_TYPE (fdecl);
1051   int resolved = is_compiled_class (type);
1052
1053   START_RECORD_CONSTRUCTOR (finit, field_type_node);
1054   PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl)));
1055   if (resolved)
1056     type = build_class_ref (type);
1057   else
1058     {
1059       tree signature = build_java_signature (type);
1060
1061       type = build_utf8_ref (unmangle_classname
1062                              (IDENTIFIER_POINTER (signature),
1063                               IDENTIFIER_LENGTH (signature)));
1064     }
1065   PUSH_FIELD_VALUE (finit, "type", type);
1066
1067   flags = get_access_flags_from_decl (fdecl);
1068   if (! resolved)
1069     flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1070
1071   PUSH_FIELD_VALUE (finit, "accflags", build_int_2 (flags, 0));
1072   PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
1073
1074   PUSH_FIELD_VALUE
1075     (finit, "info",
1076      build_constructor (field_info_union_node,
1077             build_tree_list
1078             ((FIELD_STATIC (fdecl)
1079               ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
1080               : TYPE_FIELDS (field_info_union_node)),
1081              (FIELD_STATIC (fdecl)
1082               ? build_address_of (build_static_field_ref (fdecl))
1083               : byte_position (fdecl)))));
1084
1085   FINISH_RECORD_CONSTRUCTOR (finit);
1086   return finit;
1087 }
1088
1089 static tree
1090 make_method_value (tree mdecl)
1091 {
1092   static int method_name_count = 0;
1093   tree minit;
1094   tree index;
1095   tree code;
1096 #define ACC_TRANSLATED          0x4000
1097   int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
1098
1099   if (!flag_indirect_dispatch && DECL_VINDEX (mdecl) != NULL_TREE)
1100     index = DECL_VINDEX (mdecl);
1101   else
1102     index = integer_minus_one_node;
1103
1104   code = null_pointer_node;
1105   if (DECL_RTL_SET_P (mdecl))
1106     code = build1 (ADDR_EXPR, nativecode_ptr_type_node, mdecl);
1107   START_RECORD_CONSTRUCTOR (minit, method_type_node);
1108   PUSH_FIELD_VALUE (minit, "name",
1109                     build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
1110                                     init_identifier_node
1111                                     : DECL_NAME (mdecl)));
1112   {
1113     tree signature = build_java_signature (TREE_TYPE (mdecl));
1114     PUSH_FIELD_VALUE (minit, "signature",
1115                       (build_utf8_ref
1116                        (unmangle_classname
1117                         (IDENTIFIER_POINTER(signature),
1118                          IDENTIFIER_LENGTH(signature)))));
1119   }
1120   PUSH_FIELD_VALUE (minit, "accflags", build_int_2 (accflags, 0));
1121   PUSH_FIELD_VALUE (minit, "index", index);
1122   PUSH_FIELD_VALUE (minit, "ncode", code);
1123
1124   {
1125     /* Compute the `throws' information for the method.  */
1126     tree table = null_pointer_node;
1127     if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE)
1128       {
1129         int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl));
1130         tree iter, type, array;
1131         char buf[60];
1132
1133         table = tree_cons (NULL_TREE, table, NULL_TREE);
1134         for (iter = DECL_FUNCTION_THROWS (mdecl);
1135              iter != NULL_TREE;
1136              iter = TREE_CHAIN (iter))
1137           {
1138             tree sig = DECL_NAME (TYPE_NAME (TREE_VALUE (iter)));
1139             tree utf8
1140               = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
1141                                                     IDENTIFIER_LENGTH (sig)));
1142             table = tree_cons (NULL_TREE, utf8, table);
1143           }
1144         type = build_prim_array_type (ptr_type_node, length);
1145         table = build_constructor (type, table);
1146         /* Compute something unique enough.  */
1147         sprintf (buf, "_methods%d", method_name_count++);
1148         array = build_decl (VAR_DECL, get_identifier (buf), type);
1149         DECL_INITIAL (array) = table;
1150         TREE_STATIC (array) = 1;
1151         DECL_ARTIFICIAL (array) = 1;
1152         DECL_IGNORED_P (array) = 1;
1153         rest_of_decl_compilation (array, (char*) 0, 1, 0);
1154
1155         table = build1 (ADDR_EXPR, ptr_type_node, array);
1156       }
1157
1158     PUSH_FIELD_VALUE (minit, "throws", table);
1159   }
1160
1161   FINISH_RECORD_CONSTRUCTOR (minit);
1162   return minit;
1163 }
1164
1165 static tree
1166 get_dispatch_vector (tree type)
1167 {
1168   tree vtable = TYPE_VTABLE (type);
1169
1170   if (vtable == NULL_TREE)
1171     {
1172       HOST_WIDE_INT i;
1173       tree method;
1174       tree super = CLASSTYPE_SUPER (type);
1175       HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1176       vtable = make_tree_vec (nvirtuals);
1177       TYPE_VTABLE (type) = vtable;
1178       if (super != NULL_TREE)
1179         {
1180           tree super_vtable = get_dispatch_vector (super);
1181
1182           for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1183             TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1184         }
1185
1186       for (method = TYPE_METHODS (type);  method != NULL_TREE;
1187            method = TREE_CHAIN (method))
1188         if (DECL_VINDEX (method) != NULL_TREE
1189             && host_integerp (DECL_VINDEX (method), 0))
1190           TREE_VEC_ELT (vtable, tree_low_cst (DECL_VINDEX (method), 0))
1191             = method;
1192     }
1193
1194   return vtable;
1195 }
1196
1197 static tree
1198 get_dispatch_table (tree type, tree this_class_addr)
1199 {
1200   int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1201   tree vtable = get_dispatch_vector (type);
1202   int i, j;
1203   tree list = NULL_TREE;
1204   int nvirtuals = TREE_VEC_LENGTH (vtable);
1205   int arraysize;
1206   tree gc_descr;
1207
1208   for (i = nvirtuals;  --i >= 0; )
1209     {
1210       tree method = TREE_VEC_ELT (vtable, i);
1211       if (METHOD_ABSTRACT (method))
1212         {
1213           if (! abstract_p)
1214             warning ("%Habstract method in non-abstract class",
1215                      &DECL_SOURCE_FILE (method));
1216
1217           if (TARGET_VTABLE_USES_DESCRIPTORS)
1218             for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1219               list = tree_cons (NULL_TREE, null_pointer_node, list);
1220           else
1221             list = tree_cons (NULL_TREE, null_pointer_node, list);
1222         }
1223       else
1224         {
1225           if (!DECL_RTL_SET_P (method))
1226             make_decl_rtl (method, NULL);
1227
1228           if (TARGET_VTABLE_USES_DESCRIPTORS)
1229             for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1230               {
1231                 tree fdesc = build (FDESC_EXPR, nativecode_ptr_type_node,
1232                                     method, build_int_2 (j, 0));
1233                 TREE_CONSTANT (fdesc) = 1;
1234                 list = tree_cons (NULL_TREE, fdesc, list);
1235               }
1236           else
1237             list = tree_cons (NULL_TREE,
1238                               build1 (ADDR_EXPR, nativecode_ptr_type_node,
1239                                       method),
1240                               list);
1241         }
1242     }
1243
1244   /* Dummy entry for compatibility with G++ -fvtable-thunks.  When
1245      using the Boehm GC we sometimes stash a GC type descriptor
1246      there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1247      the emitted byte count during the output to the assembly file. */
1248   /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1249      fake "function descriptor".  It's first word is the is the class
1250      pointer, and subsequent words (usually one) contain the GC descriptor.
1251      In all other cases, we reserve two extra vtable slots. */
1252   gc_descr =  get_boehm_type_descriptor (type);
1253   list = tree_cons (NULL_TREE, gc_descr, list);
1254   for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
1255     list = tree_cons (NULL_TREE, gc_descr, list);
1256   list = tree_cons (NULL_TREE, this_class_addr, list);
1257
1258   /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1259   list = tree_cons (NULL_TREE, null_pointer_node, list);
1260   /** Offset to start of whole object.  Always (ptrdiff_t)0 for Java. */
1261   list = tree_cons (integer_zero_node, null_pointer_node, list);
1262
1263   arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
1264   if (TARGET_VTABLE_USES_DESCRIPTORS)
1265     arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
1266   arraysize += 2;
1267   return build_constructor (build_prim_array_type (nativecode_ptr_type_node,
1268                                                    arraysize), list);
1269 }
1270
1271 static int
1272 supers_all_compiled (tree type)
1273 {
1274   while (type != NULL_TREE)
1275     {
1276       if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
1277         return 0;
1278       type = CLASSTYPE_SUPER (type);
1279     }
1280   return 1;
1281 }
1282
1283 void
1284 make_class_data (tree type)
1285 {
1286   tree decl, cons, temp;
1287   tree field, fields_decl;
1288   tree static_fields = NULL_TREE;
1289   tree instance_fields = NULL_TREE;
1290   HOST_WIDE_INT static_field_count = 0;
1291   HOST_WIDE_INT instance_field_count = 0;
1292   HOST_WIDE_INT field_count;
1293   tree field_array_type;
1294   tree method;
1295   tree methods = NULL_TREE;
1296   tree dtable_decl = NULL_TREE;
1297   HOST_WIDE_INT method_count = 0;
1298   tree method_array_type;
1299   tree methods_decl;
1300   tree super;
1301   tree this_class_addr;
1302   tree constant_pool_constructor;
1303   tree interfaces = null_pointer_node;
1304   int interface_len = 0;
1305   tree type_decl = TYPE_NAME (type);
1306   /** Offset from start of virtual function table declaration
1307       to where objects actually point at, following new g++ ABI. */
1308   tree dtable_start_offset = build_int_2 (2 * POINTER_SIZE / BITS_PER_UNIT, 0);
1309
1310   this_class_addr = build_class_ref (type);
1311   decl = TREE_OPERAND (this_class_addr, 0);
1312
1313   /* Build Field array. */
1314   field = TYPE_FIELDS (type);
1315   if (DECL_NAME (field) == NULL_TREE)
1316     field = TREE_CHAIN (field);  /* Skip dummy field for inherited data. */
1317   for ( ;  field != NULL_TREE;  field = TREE_CHAIN (field))
1318     {
1319       if (! DECL_ARTIFICIAL (field))
1320         {
1321           tree init = make_field_value (field);
1322           if (FIELD_STATIC (field))
1323             {
1324               tree initial = DECL_INITIAL (field);
1325               static_field_count++;
1326               static_fields = tree_cons (NULL_TREE, init, static_fields);
1327               /* If the initial value is a string constant,
1328                  prevent output_constant from trying to assemble the value. */
1329               if (initial != NULL_TREE
1330                   && TREE_TYPE (initial) == string_ptr_type_node)
1331                 DECL_INITIAL (field) = NULL_TREE;
1332               rest_of_decl_compilation (field, (char*) 0, 1, 1);
1333               DECL_INITIAL (field) = initial;
1334             }
1335           else
1336             {
1337               instance_field_count++;
1338               instance_fields = tree_cons (NULL_TREE, init, instance_fields);
1339             }
1340         }
1341     }
1342   field_count = static_field_count + instance_field_count;
1343   if (field_count > 0)
1344     {
1345       static_fields = nreverse (static_fields);
1346       instance_fields = nreverse (instance_fields);
1347       static_fields = chainon (static_fields, instance_fields);
1348       field_array_type = build_prim_array_type (field_type_node, field_count);
1349       fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
1350                                 field_array_type);
1351       DECL_INITIAL (fields_decl) = build_constructor (field_array_type,
1352                                                       static_fields);
1353       TREE_STATIC (fields_decl) = 1;
1354       DECL_ARTIFICIAL (fields_decl) = 1;
1355       DECL_IGNORED_P (fields_decl) = 1;
1356       rest_of_decl_compilation (fields_decl, (char*) 0, 1, 0);
1357     }
1358   else
1359     fields_decl = NULL_TREE;
1360
1361   /* Build Method array. */
1362   for (method = TYPE_METHODS (type);
1363        method != NULL_TREE; method = TREE_CHAIN (method))
1364     {
1365       tree init;
1366       if (METHOD_PRIVATE (method)
1367           && ! flag_keep_inline_functions
1368           && (flag_inline_functions || optimize))
1369         continue;
1370       init = make_method_value (method);
1371       method_count++;
1372       methods = tree_cons (NULL_TREE, init, methods);
1373     }
1374   method_array_type = build_prim_array_type (method_type_node, method_count);
1375   methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
1376                              method_array_type);
1377   DECL_INITIAL (methods_decl) = build_constructor (method_array_type,
1378                                                    nreverse (methods));
1379   TREE_STATIC (methods_decl) = 1;
1380   DECL_ARTIFICIAL (methods_decl) = 1;
1381   DECL_IGNORED_P (methods_decl) = 1;
1382   rest_of_decl_compilation (methods_decl, (char*) 0, 1, 0);
1383
1384   if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
1385       && !flag_indirect_dispatch)
1386     {
1387       tree dtable = get_dispatch_table (type, this_class_addr);
1388       dtable_decl = build_dtable_decl (type);
1389       DECL_INITIAL (dtable_decl) = dtable;
1390       TREE_STATIC (dtable_decl) = 1;
1391       DECL_ARTIFICIAL (dtable_decl) = 1;
1392       DECL_IGNORED_P (dtable_decl) = 1;
1393       TREE_PUBLIC (dtable_decl) = 1;
1394       rest_of_decl_compilation (dtable_decl, (char*) 0, 1, 0);
1395       if (type == class_type_node)
1396         class_dtable_decl = dtable_decl;
1397     }
1398
1399   if (class_dtable_decl == NULL_TREE)
1400     {
1401       class_dtable_decl = build_dtable_decl (class_type_node);
1402       TREE_STATIC (class_dtable_decl) = 1;
1403       DECL_ARTIFICIAL (class_dtable_decl) = 1;
1404       DECL_IGNORED_P (class_dtable_decl) = 1;
1405       if (is_compiled_class (class_type_node) != 2)
1406         DECL_EXTERNAL (class_dtable_decl) = 1;
1407       rest_of_decl_compilation (class_dtable_decl, (char*) 0, 1, 0);
1408     }
1409
1410   super = CLASSTYPE_SUPER (type);
1411   if (super == NULL_TREE)
1412     super = null_pointer_node;
1413   else if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
1414            && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
1415     super = build_class_ref (super);
1416   else
1417     {
1418       int super_index = alloc_class_constant (super);
1419       super = build_int_2 (super_index, 0);
1420       TREE_TYPE (super) = ptr_type_node;
1421     }
1422
1423   /* Build and emit the array of implemented interfaces. */
1424   if (type != object_type_node)
1425       interface_len = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)) - 1;
1426   if (interface_len > 0)
1427     {
1428       tree init = NULL_TREE;
1429       int i;
1430       tree interface_array_type, idecl;
1431       interface_array_type
1432         = build_prim_array_type (class_ptr_type, interface_len);
1433       idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type),
1434                           interface_array_type);
1435       for (i = interface_len;  i > 0; i--)
1436         {
1437           tree child = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i);
1438           tree iclass = BINFO_TYPE (child);
1439           tree index;
1440           if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass)))))
1441             index = build_class_ref (iclass);
1442           else
1443             {
1444                 int int_index = alloc_class_constant (iclass);
1445                 index = build_int_2 (int_index, 0);
1446                 TREE_TYPE (index) = ptr_type_node;
1447             }
1448           init = tree_cons (NULL_TREE, index, init);
1449         }
1450       DECL_INITIAL (idecl) = build_constructor (interface_array_type, init);
1451       TREE_STATIC (idecl) = 1;
1452       DECL_ARTIFICIAL (idecl) = 1;
1453       DECL_IGNORED_P (idecl) = 1;
1454       interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
1455       rest_of_decl_compilation (idecl,  (char*) 0, 1, 0);
1456     }
1457
1458   constant_pool_constructor = build_constants_constructor ();
1459
1460   START_RECORD_CONSTRUCTOR (temp, object_type_node);
1461   PUSH_FIELD_VALUE (temp, "vtable",
1462                     build (PLUS_EXPR, dtable_ptr_type,
1463                            build1 (ADDR_EXPR, dtable_ptr_type, class_dtable_decl),
1464                            dtable_start_offset));
1465   if (! flag_hash_synchronization)
1466     PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
1467   FINISH_RECORD_CONSTRUCTOR (temp);
1468   START_RECORD_CONSTRUCTOR (cons, class_type_node);
1469   PUSH_SUPER_VALUE (cons, temp);
1470   PUSH_FIELD_VALUE (cons, "next", null_pointer_node);
1471   PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
1472   PUSH_FIELD_VALUE (cons, "accflags",
1473                     build_int_2 (get_access_flags_from_decl (type_decl), 0));
1474
1475   PUSH_FIELD_VALUE (cons, "superclass",
1476                     CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
1477   PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
1478   PUSH_FIELD_VALUE (cons, "methods",
1479                     build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
1480   PUSH_FIELD_VALUE (cons, "method_count",  build_int_2 (method_count, 0));
1481
1482   if (flag_indirect_dispatch)
1483     PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node)
1484   else
1485     PUSH_FIELD_VALUE (cons, "vtable_method_count", TYPE_NVIRTUALS (type));
1486
1487   PUSH_FIELD_VALUE (cons, "fields",
1488                     fields_decl == NULL_TREE ? null_pointer_node
1489                     : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
1490   PUSH_FIELD_VALUE (cons, "size_in_bytes", size_in_bytes (type));
1491   PUSH_FIELD_VALUE (cons, "field_count", build_int_2 (field_count, 0));
1492   PUSH_FIELD_VALUE (cons, "static_field_count",
1493                     build_int_2 (static_field_count, 0));
1494
1495   if (flag_indirect_dispatch)
1496     PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node)
1497   else
1498     PUSH_FIELD_VALUE (cons, "vtable",
1499                       dtable_decl == NULL_TREE ? null_pointer_node
1500                       : build (PLUS_EXPR, dtable_ptr_type,
1501                                build1 (ADDR_EXPR, dtable_ptr_type, dtable_decl),
1502                                dtable_start_offset));
1503
1504   if (otable_methods == NULL_TREE)
1505     {
1506       PUSH_FIELD_VALUE (cons, "otable", null_pointer_node);
1507       PUSH_FIELD_VALUE (cons, "otable_syms", null_pointer_node);
1508     }
1509   else
1510     {
1511       PUSH_FIELD_VALUE (cons, "otable",
1512                         build1 (ADDR_EXPR, otable_ptr_type, otable_decl));
1513       PUSH_FIELD_VALUE (cons, "otable_syms",
1514                         build1 (ADDR_EXPR, method_symbols_array_ptr_type,
1515                                 otable_syms_decl));
1516     }
1517   PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
1518   PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
1519   PUSH_FIELD_VALUE (cons, "interface_count", build_int_2 (interface_len, 0));
1520   PUSH_FIELD_VALUE (cons, "state", integer_zero_node);
1521
1522   PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
1523   PUSH_FIELD_VALUE (cons, "depth", integer_zero_node);
1524   PUSH_FIELD_VALUE (cons, "ancestors", null_pointer_node);
1525   PUSH_FIELD_VALUE (cons, "idt", null_pointer_node);
1526   PUSH_FIELD_VALUE (cons, "arrayclass", null_pointer_node);
1527   PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
1528   PUSH_FIELD_VALUE (cons, "chain", null_pointer_node);
1529
1530   FINISH_RECORD_CONSTRUCTOR (cons);
1531
1532   DECL_INITIAL (decl) = cons;
1533
1534   /* Hash synchronization requires at least 64-bit alignment. */
1535   if (flag_hash_synchronization && POINTER_SIZE < 64)
1536     DECL_ALIGN (decl) = 64;
1537
1538   rest_of_decl_compilation (decl, (char*) 0, 1, 0);
1539 }
1540
1541 void
1542 finish_class (void)
1543 {
1544   tree method;
1545   tree type_methods = TYPE_METHODS (current_class);
1546   int saw_native_method = 0;
1547
1548   /* Find out if we have any native methods.  We use this information
1549      later.  */
1550   for (method = type_methods;
1551        method != NULL_TREE;
1552        method = TREE_CHAIN (method))
1553     {
1554       if (METHOD_NATIVE (method))
1555         {
1556           saw_native_method = 1;
1557           break;
1558         }
1559     }
1560
1561   /* Emit deferred inline methods. */
1562   for (method = type_methods; method != NULL_TREE; )
1563     {
1564       if (! TREE_ASM_WRITTEN (method) && DECL_SAVED_INSNS (method) != 0)
1565         {
1566           output_inline_function (method);
1567           /* Scan the list again to see if there are any earlier
1568              methods to emit. */
1569           method = type_methods;
1570           continue;
1571         }
1572       method = TREE_CHAIN (method);
1573     }
1574
1575   current_function_decl = NULL_TREE;
1576   make_class_data (current_class);
1577   register_class ();
1578   rest_of_decl_compilation (TYPE_NAME (current_class), (char*) 0, 1, 0);
1579 }
1580
1581 /* Return 2 if CLASS is compiled by this compilation job;
1582    return 1 if CLASS can otherwise be assumed to be compiled;
1583    return 0 if we cannot assume that CLASS is compiled.
1584    Returns 1 for primitive and 0 for array types.  */
1585 int
1586 is_compiled_class (tree class)
1587 {
1588   int seen_in_zip;
1589   if (TREE_CODE (class) == POINTER_TYPE)
1590     class = TREE_TYPE (class);
1591   if (TREE_CODE (class) != RECORD_TYPE)  /* Primitive types are static. */
1592     return 1;
1593   if (TYPE_ARRAY_P (class))
1594     return 0;
1595   if (class == current_class)
1596     return 2;
1597
1598   seen_in_zip = (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1599   if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip)
1600     {
1601       /* The class was seen in the current ZIP file and will be
1602          available as a compiled class in the future but may not have
1603          been loaded already. Load it if necessary. This prevent
1604          build_class_ref () from crashing. */
1605
1606       if (seen_in_zip && !CLASS_LOADED_P (class))
1607         load_class (class, 1);
1608
1609       /* We return 2 for class seen in ZIP and class from files
1610          belonging to the same compilation unit */
1611       return 2;
1612     }
1613
1614   if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1615     {
1616       if (!CLASS_LOADED_P (class))
1617         {
1618           if (CLASS_FROM_SOURCE_P (class))
1619             safe_layout_class (class);
1620           else
1621             load_class (class, 1);
1622         }
1623       return 1;
1624     }
1625
1626   return 0;
1627 }
1628
1629 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1630
1631 tree
1632 build_dtable_decl (tree type)
1633 {
1634   tree dtype;
1635
1636   /* We need to build a new dtable type so that its size is uniquely
1637      computed when we're dealing with the class for real and not just
1638      faking it (like java.lang.Class during the initialization of the
1639      compiler.) We know we're not faking a class when CURRENT_CLASS is
1640      TYPE. */
1641   if (current_class == type)
1642     {
1643       tree dummy = NULL_TREE;
1644       int n;
1645
1646       dtype = make_node (RECORD_TYPE);
1647
1648       PUSH_FIELD (dtype, dummy, "top_offset", ptr_type_node);
1649       PUSH_FIELD (dtype, dummy, "type_info", ptr_type_node);
1650
1651       PUSH_FIELD (dtype, dummy, "class", class_ptr_type);
1652       for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
1653         {
1654           tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
1655           TREE_CHAIN (dummy) = tmp_field;
1656           DECL_CONTEXT (tmp_field) = dtype;
1657           DECL_ARTIFICIAL (tmp_field) = 1;
1658           dummy = tmp_field;
1659         }
1660
1661       PUSH_FIELD (dtype, dummy, "gc_descr", ptr_type_node);
1662       for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
1663         {
1664           tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
1665           TREE_CHAIN (dummy) = tmp_field;
1666           DECL_CONTEXT (tmp_field) = dtype;
1667           DECL_ARTIFICIAL (tmp_field) = 1;
1668           dummy = tmp_field;
1669         }
1670
1671       n = TREE_VEC_LENGTH (get_dispatch_vector (type));
1672       if (TARGET_VTABLE_USES_DESCRIPTORS)
1673         n *= TARGET_VTABLE_USES_DESCRIPTORS;
1674
1675       PUSH_FIELD (dtype, dummy, "methods",
1676                   build_prim_array_type (nativecode_ptr_type_node, n));
1677       layout_type (dtype);
1678     }
1679   else
1680     dtype = dtable_type;
1681
1682   return build_decl (VAR_DECL,
1683                      java_mangle_vtable (&temporary_obstack, type), dtype);
1684 }
1685
1686 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
1687    fields inherited from SUPER_CLASS. */
1688
1689 void
1690 push_super_field (tree this_class, tree super_class)
1691 {
1692   tree base_decl;
1693   /* Don't insert the field if we're just re-laying the class out. */
1694   if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
1695     return;
1696   base_decl = build_decl (FIELD_DECL, NULL_TREE, super_class);
1697   DECL_IGNORED_P (base_decl) = 1;
1698   TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
1699   TYPE_FIELDS (this_class) = base_decl;
1700   DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
1701   DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
1702 }
1703
1704 /* Handle the different manners we may have to lay out a super class.  */
1705
1706 static tree
1707 maybe_layout_super_class (tree super_class, tree this_class)
1708 {
1709   if (TREE_CODE (super_class) == RECORD_TYPE)
1710     {
1711       if (!CLASS_LOADED_P (super_class) && CLASS_FROM_SOURCE_P (super_class))
1712         safe_layout_class (super_class);
1713       if (!CLASS_LOADED_P (super_class))
1714         load_class (super_class, 1);
1715     }
1716   /* We might have to layout the class before its dependency on
1717      the super class gets resolved by java_complete_class  */
1718   else if (TREE_CODE (super_class) == POINTER_TYPE)
1719     {
1720       if (TREE_TYPE (super_class) != NULL_TREE)
1721         super_class = TREE_TYPE (super_class);
1722       else
1723         {
1724           /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
1725              we give it one.  */
1726           tree this_wrap = NULL_TREE;
1727
1728           if (this_class)
1729             {
1730               tree this_decl = TYPE_NAME (this_class);
1731               this_wrap = build_expr_wfl (this_class,
1732                                           DECL_SOURCE_FILE (this_decl),
1733                                           DECL_SOURCE_LINE (this_decl), 0);
1734             }
1735           super_class = do_resolve_class (NULL_TREE, /* FIXME? */
1736                                           super_class, NULL_TREE, this_wrap);
1737           if (!super_class)
1738             return NULL_TREE;   /* FIXME, NULL_TREE not checked by caller. */
1739           super_class = TREE_TYPE (super_class);
1740         }
1741     }
1742   if (!TYPE_SIZE (super_class))
1743     safe_layout_class (super_class);
1744
1745   return super_class;
1746 }
1747
1748 void
1749 layout_class (tree this_class)
1750 {
1751   tree super_class = CLASSTYPE_SUPER (this_class);
1752   tree field;
1753
1754   class_list = tree_cons (this_class, NULL_TREE, class_list);
1755   if (CLASS_BEING_LAIDOUT (this_class))
1756     {
1757       char buffer [1024];
1758       char *report;
1759       tree current;
1760
1761       sprintf (buffer, " with `%s'",
1762                IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
1763       obstack_grow (&temporary_obstack, buffer, strlen (buffer));
1764
1765       for (current = TREE_CHAIN (class_list); current;
1766            current = TREE_CHAIN (current))
1767         {
1768           tree decl = TYPE_NAME (TREE_PURPOSE (current));
1769           sprintf (buffer, "\n  which inherits from `%s' (%s:%d)",
1770                    IDENTIFIER_POINTER (DECL_NAME (decl)),
1771                    DECL_SOURCE_FILE (decl),
1772                    DECL_SOURCE_LINE (decl));
1773           obstack_grow (&temporary_obstack, buffer, strlen (buffer));
1774         }
1775       obstack_1grow (&temporary_obstack, '\0');
1776       report = obstack_finish (&temporary_obstack);
1777       cyclic_inheritance_report = ggc_strdup (report);
1778       obstack_free (&temporary_obstack, report);
1779       TYPE_SIZE (this_class) = error_mark_node;
1780       return;
1781     }
1782   CLASS_BEING_LAIDOUT (this_class) = 1;
1783
1784   if (super_class && !CLASS_BEING_LAIDOUT (super_class))
1785     {
1786       tree maybe_super_class
1787         = maybe_layout_super_class (super_class, this_class);
1788       if (maybe_super_class == NULL
1789           || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
1790         {
1791           TYPE_SIZE (this_class) = error_mark_node;
1792           CLASS_BEING_LAIDOUT (this_class) = 0;
1793           class_list = TREE_CHAIN (class_list);
1794           return;
1795         }
1796       if (TYPE_SIZE (this_class) == NULL_TREE)
1797         push_super_field (this_class, maybe_super_class);
1798     }
1799
1800   for (field = TYPE_FIELDS (this_class);
1801        field != NULL_TREE;  field = TREE_CHAIN (field))
1802     {
1803       if (FIELD_STATIC (field))
1804         {
1805           /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
1806           SET_DECL_ASSEMBLER_NAME (field,
1807                                    java_mangle_decl
1808                                    (&temporary_obstack, field));
1809         }
1810     }
1811
1812   layout_type (this_class);
1813
1814   /* Also recursively load/layout any superinterfaces, but only if class was
1815   loaded from bytecode. The source parser will take care of this itself. */
1816   if (!CLASS_FROM_SOURCE_P (this_class))
1817     {
1818       tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
1819
1820       if (basetype_vec)
1821         {
1822           int n = TREE_VEC_LENGTH (basetype_vec) - 1;
1823           int i;
1824           for (i = n; i > 0; i--)
1825             {
1826               tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
1827               tree super_interface = BINFO_TYPE (vec_elt);
1828
1829               tree maybe_super_interface
1830                 = maybe_layout_super_class (super_interface, NULL_TREE);
1831               if (maybe_super_interface == NULL
1832                   || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
1833                 {
1834                   TYPE_SIZE (this_class) = error_mark_node;
1835                   CLASS_BEING_LAIDOUT (this_class) = 0;
1836                   class_list = TREE_CHAIN (class_list);
1837                   return;
1838                 }
1839             }
1840         }
1841     }
1842
1843   /* Convert the size back to an SI integer value */
1844   TYPE_SIZE_UNIT (this_class) =
1845     fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
1846
1847   CLASS_BEING_LAIDOUT (this_class) = 0;
1848   class_list = TREE_CHAIN (class_list);
1849 }
1850
1851 void
1852 layout_class_methods (tree this_class)
1853 {
1854   tree method_decl, dtable_count;
1855   tree super_class;
1856
1857   if (TYPE_NVIRTUALS (this_class))
1858     return;
1859
1860   super_class = CLASSTYPE_SUPER (this_class);
1861
1862   if (super_class)
1863     {
1864       super_class = maybe_layout_super_class (super_class, this_class);
1865       if (!TYPE_NVIRTUALS (super_class))
1866         layout_class_methods (super_class);
1867       dtable_count = TYPE_NVIRTUALS (super_class);
1868     }
1869   else
1870     dtable_count = integer_zero_node;
1871
1872   TYPE_METHODS (this_class) = nreverse (TYPE_METHODS (this_class));
1873
1874   for (method_decl = TYPE_METHODS (this_class);
1875        method_decl; method_decl = TREE_CHAIN (method_decl))
1876     dtable_count = layout_class_method (this_class, super_class,
1877                                         method_decl, dtable_count);
1878
1879   TYPE_NVIRTUALS (this_class) = dtable_count;
1880 }
1881
1882 /* Lay METHOD_DECL out, returning a possibly new value of
1883    DTABLE_COUNT. Also mangle the method's name. */
1884
1885 tree
1886 layout_class_method (tree this_class, tree super_class,
1887                      tree method_decl, tree dtable_count)
1888 {
1889   tree method_name = DECL_NAME (method_decl);
1890
1891   TREE_PUBLIC (method_decl) = 1;
1892   /* Considered external until we know what classes are being
1893      compiled into this object file.  */
1894   DECL_EXTERNAL (method_decl) = 1;
1895
1896   /* This is a good occasion to mangle the method's name */
1897   SET_DECL_ASSEMBLER_NAME (method_decl,
1898                            java_mangle_decl (&temporary_obstack,
1899                                              method_decl));
1900   /* We don't generate a RTL for the method if it's abstract, or if
1901      it's an interface method that isn't clinit. */
1902   if (! METHOD_ABSTRACT (method_decl)
1903       || (CLASS_INTERFACE (TYPE_NAME (this_class))
1904           && (DECL_CLINIT_P (method_decl))))
1905     make_decl_rtl (method_decl, NULL);
1906
1907   if (ID_INIT_P (method_name))
1908     {
1909       const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
1910       const char *ptr;
1911       for (ptr = p; *ptr; )
1912         {
1913           if (*ptr++ == '.')
1914             p = ptr;
1915         }
1916       DECL_CONSTRUCTOR_P (method_decl) = 1;
1917       build_java_argument_signature (TREE_TYPE (method_decl));
1918     }
1919   else if (! METHOD_STATIC (method_decl) && !DECL_ARTIFICIAL (method_decl))
1920     {
1921       tree method_sig =
1922         build_java_argument_signature (TREE_TYPE (method_decl));
1923       tree super_method = lookup_argument_method (super_class, method_name,
1924                                                   method_sig);
1925       if (super_method != NULL_TREE && ! METHOD_PRIVATE (super_method))
1926         {
1927           DECL_VINDEX (method_decl) = DECL_VINDEX (super_method);
1928           if (DECL_VINDEX (method_decl) == NULL_TREE
1929               && !CLASS_FROM_SOURCE_P (this_class))
1930             error ("%Hnon-static method '%D' overrides static method",
1931                    &DECL_SOURCE_LOCATION (method_decl), method_decl);
1932         }
1933       else if (! METHOD_FINAL (method_decl)
1934                && ! METHOD_PRIVATE (method_decl)
1935                && ! CLASS_FINAL (TYPE_NAME (this_class))
1936                && dtable_count)
1937         {
1938           DECL_VINDEX (method_decl) = dtable_count;
1939           dtable_count = fold (build (PLUS_EXPR, integer_type_node,
1940                                       dtable_count, integer_one_node));
1941         }
1942     }
1943
1944   return dtable_count;
1945 }
1946
1947 void
1948 register_class (void)
1949 {
1950   /* END does not need to be registered with the garbage collector
1951      because it always points into the list given by REGISTERED_CLASS,
1952      and that variable is registered with the collector.  */
1953   static tree end;
1954   tree node    = TREE_OPERAND (build_class_ref (current_class), 0);
1955   tree current = copy_node (node);
1956
1957   XEXP (DECL_RTL (current), 0) = copy_rtx (XEXP (DECL_RTL(node), 0));
1958   if (!registered_class)
1959     registered_class = current;
1960   else
1961     TREE_CHAIN (end) = current;
1962
1963   end = current;
1964 }
1965
1966 /* Emit something to register classes at start-up time.
1967
1968    The preferred mechanism is through the .jcr section, which contain
1969    a list of pointers to classes which get registered during
1970    constructor invocation time.  The fallback mechanism is to generate
1971    a `constructor' function which calls _Jv_RegisterClass for each
1972    class in this file.  */
1973
1974 void
1975 emit_register_classes (void)
1976 {
1977   /* ??? This isn't quite the correct test.  We also have to know
1978      that the target is using gcc's crtbegin/crtend objects rather
1979      than the ones that come with the operating system.  */
1980   if (SUPPORTS_WEAK && targetm.have_named_sections)
1981     {
1982 #ifdef JCR_SECTION_NAME
1983       tree t;
1984       named_section_flags (JCR_SECTION_NAME, SECTION_WRITE);
1985       assemble_align (POINTER_SIZE);
1986       for (t = registered_class; t; t = TREE_CHAIN (t))
1987         assemble_integer (XEXP (DECL_RTL (t), 0),
1988                           POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1989 #else
1990       abort ();
1991 #endif
1992     }
1993   else
1994     {
1995       extern tree get_file_function_name (int);
1996       tree init_name = get_file_function_name ('I');
1997       tree init_type = build_function_type (void_type_node, end_params_node);
1998       tree init_decl;
1999       tree t;
2000       location_t saved_loc = input_location;
2001
2002       init_decl = build_decl (FUNCTION_DECL, init_name, init_type);
2003       SET_DECL_ASSEMBLER_NAME (init_decl, init_name);
2004       DECL_SOURCE_LINE (init_decl) = 0;
2005       TREE_STATIC (init_decl) = 1;
2006       current_function_decl = init_decl;
2007       DECL_RESULT (init_decl) = build_decl (RESULT_DECL, NULL_TREE,
2008                                             void_type_node);
2009
2010       /* It can be a static function as long as collect2 does not have
2011          to scan the object file to find its ctor/dtor routine.  */
2012       TREE_PUBLIC (init_decl) = ! targetm.have_ctors_dtors;
2013
2014       /* Suppress spurious warnings.  */
2015       TREE_USED (init_decl) = 1;
2016
2017       pushlevel (0);
2018       make_decl_rtl (init_decl, NULL);
2019       init_function_start (init_decl);
2020       expand_function_start (init_decl, 0);
2021
2022       /* Do not allow the function to be deferred.  */
2023       current_function_cannot_inline
2024         = "static constructors and destructors cannot be inlined";
2025
2026       for ( t = registered_class; t; t = TREE_CHAIN (t))
2027         emit_library_call (registerClass_libfunc, 0, VOIDmode, 1,
2028                            XEXP (DECL_RTL (t), 0), Pmode);
2029       input_location = DECL_SOURCE_LOCATION (init_decl);
2030       expand_function_end ();
2031       poplevel (1, 0, 1);
2032       rest_of_compilation (init_decl);
2033       current_function_decl = NULL_TREE;
2034
2035       if (targetm.have_ctors_dtors)
2036         (* targetm.asm_out.constructor) (XEXP (DECL_RTL (init_decl), 0),
2037                                          DEFAULT_INIT_PRIORITY);
2038       input_location = saved_loc;
2039     }
2040 }
2041
2042 /* Make a method_symbol_type (_Jv_MethodSymbol) node for METHOD. */
2043
2044 static tree
2045 build_method_symbols_entry (tree method)
2046 {
2047   tree clname, name, signature, method_symbol;
2048
2049   clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (method))));
2050   name = build_utf8_ref (DECL_NAME (method));
2051   signature = build_java_signature (TREE_TYPE (method));
2052   signature = build_utf8_ref (unmangle_classname
2053                               (IDENTIFIER_POINTER (signature),
2054                                IDENTIFIER_LENGTH (signature)));
2055
2056   START_RECORD_CONSTRUCTOR (method_symbol, method_symbol_type);
2057   PUSH_FIELD_VALUE (method_symbol, "clname", clname);
2058   PUSH_FIELD_VALUE (method_symbol, "name", name);
2059   PUSH_FIELD_VALUE (method_symbol, "signature", signature);
2060   FINISH_RECORD_CONSTRUCTOR (method_symbol);
2061   TREE_CONSTANT (method_symbol) = 1;
2062
2063   return method_symbol;
2064 }
2065
2066 /* Emit the offset symbols table for indirect virtual dispatch. */
2067
2068 void
2069 emit_offset_symbol_table (void)
2070 {
2071   tree method_list, method, table, list, null_symbol;
2072   tree otable_bound, otable_array_type;
2073   int index;
2074
2075   /* Only emit an offset table if this translation unit actually made virtual
2076      calls. */
2077   if (otable_methods == NULL_TREE)
2078     return;
2079
2080   /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2081   index = 0;
2082   method_list = otable_methods;
2083   list = NULL_TREE;
2084   while (method_list != NULL_TREE)
2085     {
2086       method = TREE_VALUE (method_list);
2087       list = tree_cons (NULL_TREE, build_method_symbols_entry (method), list);
2088       method_list = TREE_CHAIN (method_list);
2089       index++;
2090     }
2091
2092   /* Terminate the list with a "null" entry. */
2093   START_RECORD_CONSTRUCTOR (null_symbol, method_symbol_type);
2094   PUSH_FIELD_VALUE (null_symbol, "clname", null_pointer_node);
2095   PUSH_FIELD_VALUE (null_symbol, "name", null_pointer_node);
2096   PUSH_FIELD_VALUE (null_symbol, "signature", null_pointer_node);
2097   FINISH_RECORD_CONSTRUCTOR (null_symbol);
2098   TREE_CONSTANT (null_symbol) = 1;
2099   list = tree_cons (NULL_TREE, null_symbol, list);
2100
2101   /* Put the list in the right order and make it a constructor. */
2102   list = nreverse (list);
2103   table = build_constructor (method_symbols_array_type, list);
2104
2105   /* Make it the initial value for otable_syms and emit the decl. */
2106   DECL_INITIAL (otable_syms_decl) = table;
2107   DECL_ARTIFICIAL (otable_syms_decl) = 1;
2108   DECL_IGNORED_P (otable_syms_decl) = 1;
2109   rest_of_decl_compilation (otable_syms_decl, NULL, 1, 0);
2110
2111   /* Now that its size is known, redefine otable as an uninitialized static
2112      array of INDEX + 1 integers. The extra entry is used by the runtime
2113      to track whether the otable has been initialized. */
2114   otable_bound = build_index_type (build_int_2 (index, 0));
2115   otable_array_type = build_array_type (integer_type_node, otable_bound);
2116   otable_decl = build_decl (VAR_DECL, get_identifier ("otable"),
2117                             otable_array_type);
2118   TREE_STATIC (otable_decl) = 1;
2119   TREE_READONLY (otable_decl) = 1;
2120   rest_of_decl_compilation (otable_decl, NULL, 1, 0);
2121 }
2122
2123 void
2124 init_class_processing (void)
2125 {
2126   registerClass_libfunc = gen_rtx_SYMBOL_REF (Pmode, "_Jv_RegisterClass");
2127   fields_ident = get_identifier ("fields");
2128   info_ident = get_identifier ("info");
2129   gcc_obstack_init (&temporary_obstack);
2130 }
2131 \f
2132 static hashval_t java_treetreehash_hash (const void *);
2133 static int java_treetreehash_compare (const void *, const void *);
2134
2135 /* A hash table mapping trees to trees.  Used generally.  */
2136
2137 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2138
2139 static hashval_t
2140 java_treetreehash_hash (const void *k_p)
2141 {
2142   struct treetreehash_entry *k = (struct treetreehash_entry *) k_p;
2143   return JAVA_TREEHASHHASH_H (k->key);
2144 }
2145
2146 static int
2147 java_treetreehash_compare (const void * k1_p, const void * k2_p)
2148 {
2149   struct treetreehash_entry * k1 = (struct treetreehash_entry *) k1_p;
2150   tree k2 = (tree) k2_p;
2151   return (k1->key == k2);
2152 }
2153
2154 tree
2155 java_treetreehash_find (htab_t ht, tree t)
2156 {
2157   struct treetreehash_entry *e;
2158   hashval_t hv = JAVA_TREEHASHHASH_H (t);
2159   e = htab_find_with_hash (ht, t, hv);
2160   if (e == NULL)
2161     return NULL;
2162   else
2163     return e->value;
2164 }
2165
2166 tree *
2167 java_treetreehash_new (htab_t ht, tree t)
2168 {
2169   void **e;
2170   struct treetreehash_entry *tthe;
2171   hashval_t hv = JAVA_TREEHASHHASH_H (t);
2172
2173   e = htab_find_slot_with_hash (ht, t, hv, INSERT);
2174   if (*e == NULL)
2175     {
2176       tthe = (*ht->alloc_f) (1, sizeof (*tthe));
2177       tthe->key = t;
2178       *e = tthe;
2179     }
2180   else
2181     tthe = (struct treetreehash_entry *) *e;
2182   return &tthe->value;
2183 }
2184
2185 htab_t
2186 java_treetreehash_create (size_t size, int gc)
2187 {
2188   if (gc)
2189     return htab_create_ggc (size, java_treetreehash_hash,
2190                             java_treetreehash_compare, NULL);
2191   else
2192     return htab_create_alloc (size, java_treetreehash_hash,
2193                               java_treetreehash_compare, free, xcalloc, free);
2194 }
2195
2196 #include "gt-java-class.h"