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, 2004, 2005, 2006
   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, 51 Franklin Street, Fifth Floor,
  20 Boston, MA 02110-1301, 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 #include "except.h"
  46 #include "cgraph.h"
  47 #include "tree-iterator.h"
  48 #include "cgraph.h"
  49
  50 /* DOS brain-damage */
  51 #ifndef O_BINARY
  52 #define O_BINARY 0 /* MS-DOS brain-damage */
  53 #endif
  54
  55 static tree make_method_value (tree);
  56 static tree build_java_method_type (tree, tree, int);
  57 static int32 hashUtf8String (const char *, int);
  58 static tree make_field_value (tree);
  59 static tree get_dispatch_vector (tree);
  60 static tree get_dispatch_table (tree, tree);
  61 static int supers_all_compiled (tree type);
  62 static tree maybe_layout_super_class (tree, tree);
  63 static void add_miranda_methods (tree, tree);
  64 static int assume_compiled (const char *);
  65 static tree build_symbol_entry (tree, tree);
  66 static tree emit_assertion_table (tree);
  67 static void register_class (void);
  68
  69 struct obstack temporary_obstack;
  70
  71 /* The compiler generates different code depending on whether or not
  72    it can assume certain classes have been compiled down to native
  73    code or not.  The compiler options -fassume-compiled= and
  74    -fno-assume-compiled= are used to create a tree of
  75    class_flag_node objects.  This tree is queried to determine if
  76    a class is assume to be compiled or not.  Each node in the tree
  77    represents either a package or a specific class.  */
  78
  79 typedef struct class_flag_node_struct
  80 {
  81   /* The class or package name.  */
  82   const char *ident;
  83
  84   /* Nonzero if this represents an exclusion.  */
  85   int value;
  86
  87   /* Pointers to other nodes in the tree.  */
  88   struct class_flag_node_struct *parent;
  89   struct class_flag_node_struct *sibling;
  90   struct class_flag_node_struct *child;
  91 } class_flag_node;
  92
  93 static class_flag_node *find_class_flag_node (class_flag_node *, const char *);
  94 static void add_class_flag (class_flag_node **, const char *, int);
  95
  96 /* This is the root of the include/exclude tree.  */
  97
  98 static class_flag_node *assume_compiled_tree;
  99
 100 static class_flag_node *enable_assert_tree;
 101
 102 static GTY(()) tree class_roots[4];
 103 #define fields_ident class_roots[0]  /* get_identifier ("fields") */
 104 #define info_ident class_roots[1]  /* get_identifier ("info") */
 105 #define class_list class_roots[2]
 106 #define class_dtable_decl class_roots[3]
 107
 108 static GTY(()) VEC(tree,gc) *registered_class;
 109
 110 /* Return the node that most closely represents the class whose name
 111    is IDENT.  Start the search from NODE (followed by its siblings).
 112    Return NULL if an appropriate node does not exist.  */
 113
 114 static class_flag_node *
 115 find_class_flag_node (class_flag_node *node, const char *ident)
 116 {
 117   while (node)
 118     {
 119       size_t node_ident_length = strlen (node->ident);
 120
 121       /* node_ident_length is zero at the root of the tree.  If the
 122          identifiers are the same length, then we have matching
 123          classes.  Otherwise check if we've matched an enclosing
 124          package name.  */
 125
 126       if (node_ident_length == 0
 127           || (strncmp (ident, node->ident, node_ident_length) == 0
 128               && (ident[node_ident_length] == '\0'
 129                   || ident[node_ident_length] == '.')))
 130         {
 131           /* We've found a match, however, there might be a more
 132              specific match.  */
 133
 134           class_flag_node *found = find_class_flag_node (node->child, ident);
 135           if (found)
 136             return found;
 137           else
 138             return node;
 139         }
 140
 141       /* No match yet.  Continue through the sibling list.  */
 142       node = node->sibling;
 143     }
 144
 145   /* No match at all in this tree.  */
 146   return NULL;
 147 }
 148
 149 void
 150 add_class_flag (class_flag_node **rootp, const char *ident, int value)
 151 {
 152   class_flag_node *root = *rootp;
 153   class_flag_node *parent, *node;
 154
 155   /* Create the root of the tree if it doesn't exist yet.  */
 156
 157   if (NULL == root)
 158     {
 159       root = XNEW (class_flag_node);
 160       root->ident = "";
 161       root->value = 0;
 162       root->sibling = NULL;
 163       root->child = NULL;
 164       root->parent = NULL;
 165       *rootp = root;
 166     }
 167
 168   /* Calling the function with the empty string means we're setting
 169      value for the root of the hierarchy.  */
 170
 171   if (0 == ident[0])
 172     {
 173       root->value = value;
 174       return;
 175     }
 176
 177   /* Find the parent node for this new node.  PARENT will either be a
 178      class or a package name.  Adjust PARENT accordingly.  */
 179
 180   parent = find_class_flag_node (root, ident);
 181   if (strcmp (ident, parent->ident) == 0)
 182     parent->value = value;
 183   else
 184     {
 185       /* Insert new node into the tree.  */
 186       node = XNEW (class_flag_node);
 187
 188       node->ident = xstrdup (ident);
 189       node->value = value;
 190       node->child = NULL;
 191
 192       node->parent = parent;
 193       node->sibling = parent->child;
 194       parent->child = node;
 195     }
 196 }
 197
 198 /* Add a new IDENT to the include/exclude tree.  It's an exclusion
 199    if EXCLUDEP is nonzero.  */
 200
 201 void
 202 add_assume_compiled (const char *ident, int excludep)
 203 {
 204   add_class_flag (&assume_compiled_tree, ident, excludep);
 205 }
 206
 207 /* The default value returned by enable_assertions. */
 208
 209 #define DEFAULT_ENABLE_ASSERT (flag_emit_class_files || optimize == 0)
 210
 211 /* Enter IDENT (a class or package name) into the enable-assertions table.
 212    VALUE is true to enable and false to disable. */
 213
 214 void
 215 add_enable_assert (const char *ident, int value)
 216 {
 217   if (enable_assert_tree == NULL)
 218     add_class_flag (&enable_assert_tree, "", DEFAULT_ENABLE_ASSERT);
 219   add_class_flag (&enable_assert_tree, ident, value);
 220 }
 221
 222 /* Returns nonzero if IDENT is the name of a class that the compiler
 223    should assume has been compiled to object code.  */
 224
 225 static int
 226 assume_compiled (const char *ident)
 227 {
 228   class_flag_node *i;
 229   int result;
 230
 231   if (NULL == assume_compiled_tree)
 232     return 1;
 233
 234   i = find_class_flag_node (assume_compiled_tree, ident);
 235
 236   result = ! i->value;
 237
 238   return (result);
 239 }
 240
 241 /* Return true if we should generate code to check assertions within KLASS. */
 242
 243 bool
 244 enable_assertions (tree klass)
 245 {
 246   /* Check if command-line specifies whether we should check assertions. */
 247
 248   if (klass != NULL_TREE && DECL_NAME (klass) && enable_assert_tree != NULL)
 249     {
 250       const char *ident = IDENTIFIER_POINTER (DECL_NAME (klass));
 251       class_flag_node *node
 252         = find_class_flag_node (enable_assert_tree, ident);
 253       return node->value;
 254     }
 255
 256   /* The default is to enable assertions if generating class files,
 257      or not optimizing. */
 258   return DEFAULT_ENABLE_ASSERT;
 259 }
 260
 261 /* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
 262    except that characters matching OLD_CHAR are substituted by NEW_CHAR.
 263    Also, PREFIX is prepended, and SUFFIX is appended. */
 264
 265 tree
 266 ident_subst (const char* old_name,
 267              int old_length,
 268              const char *prefix,
 269              int old_char,
 270              int new_char,
 271              const char *suffix)
 272 {
 273   int prefix_len = strlen (prefix);
 274   int suffix_len = strlen (suffix);
 275   int i = prefix_len + old_length + suffix_len + 1;
 276   char *buffer = alloca (i);
 277
 278   strcpy (buffer, prefix);
 279   for (i = 0; i < old_length; i++)
 280     {
 281       char ch = old_name[i];
 282       if (ch == old_char)
 283         ch = new_char;
 284       buffer[prefix_len + i] = ch;
 285     }
 286   strcpy (buffer + prefix_len + old_length, suffix);
 287   return get_identifier (buffer);
 288 }
 289
 290 /* Return an IDENTIFIER_NODE the same as OLD_ID,
 291    except that characters matching OLD_CHAR are substituted by NEW_CHAR.
 292    Also, PREFIX is prepended, and SUFFIX is appended. */
 293
 294 tree
 295 identifier_subst (const tree old_id,
 296                   const char *prefix,
 297                   int old_char,
 298                   int new_char,
 299                   const char *suffix)
 300 {
 301   return ident_subst (IDENTIFIER_POINTER (old_id), IDENTIFIER_LENGTH (old_id),
 302                       prefix, old_char, new_char, suffix);
 303 }
 304
 305 /* Generate a valid C identifier from the name of the class TYPE,
 306    prefixed by PREFIX. */
 307
 308 tree
 309 mangled_classname (const char *prefix, tree type)
 310 {
 311   tree ident = TYPE_NAME (type);
 312   if (TREE_CODE (ident) != IDENTIFIER_NODE)
 313     ident = DECL_NAME (ident);
 314   return identifier_subst (ident, prefix, '.', '_', "");
 315 }
 316
 317 tree
 318 make_class (void)
 319 {
 320   tree type;
 321   type = make_node (RECORD_TYPE);
 322   /* Unfortunately we must create the binfo here, so that class
 323      loading works.  */
 324   TYPE_BINFO (type) = make_tree_binfo (0);
 325   MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);
 326
 327   return type;
 328 }
 329
 330 /* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
 331    and where each of the constituents is separated by '/',
 332    return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
 333
 334 tree
 335 unmangle_classname (const char *name, int name_length)
 336 {
 337   tree to_return = ident_subst (name, name_length, "", '/', '.', "");
 338   /* It's not sufficient to compare to_return and get_identifier
 339      (name) to determine whether to_return is qualified. There are
 340      cases in signature analysis where name will be stripped of a
 341      trailing ';'. */
 342   name = IDENTIFIER_POINTER (to_return);
 343   while (*name)
 344     if (*name++ == '.')
 345       {
 346         QUALIFIED_P (to_return) = 1;
 347         break;
 348       }
 349
 350   return to_return;
 351 }
 352
 353 #define GEN_TABLE(TABLE, NAME, TABLE_TYPE, TYPE)                        \
 354 do                                                                      \
 355 {                                                                       \
 356   const char *typename = IDENTIFIER_POINTER (mangled_classname ("", TYPE)); \
 357   char *buf = alloca (strlen (typename) + strlen (#NAME "_syms_") + 1); \
 358   tree decl;                                                            \
 359                                                                         \
 360   sprintf (buf, #NAME "_%s", typename);                                 \
 361   TYPE_## TABLE ##_DECL (type) = decl =                                 \
 362     build_decl (VAR_DECL, get_identifier (buf), TABLE_TYPE);            \
 363   DECL_EXTERNAL (decl) = 1;                                             \
 364   TREE_STATIC (decl) = 1;                                               \
 365   TREE_READONLY (decl) = 1;                                             \
 366   TREE_CONSTANT (decl) = 1;                                             \
 367   DECL_IGNORED_P (decl) = 1;                                            \
 368   /* Mark the table as belonging to this class.  */                     \
 369   pushdecl (decl);                                                      \
 370   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);                           \
 371   DECL_OWNER (decl) = TYPE;                                             \
 372   sprintf (buf, #NAME "_syms_%s", typename);                            \
 373   TYPE_## TABLE ##_SYMS_DECL (TYPE) =                                   \
 374     build_decl (VAR_DECL, get_identifier (buf), symbols_array_type);    \
 375   TREE_STATIC (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1;                  \
 376   TREE_CONSTANT (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1;                \
 377   DECL_IGNORED_P (TYPE_## TABLE ##_SYMS_DECL (TYPE)) = 1;               \
 378 }                                                                       \
 379 while (0)
 380
 381 /* Given a class, create the DECLs for all its associated indirect
 382    dispatch tables.  */
 383 void
 384 gen_indirect_dispatch_tables (tree type)
 385 {
 386   const char *typename = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
 387   {
 388     tree field = NULL;
 389     char *buf = alloca (strlen (typename) + strlen ("_catch_classes_") + 1);
 390     tree catch_class_type = make_node (RECORD_TYPE);
 391
 392     sprintf (buf, "_catch_classes_%s", typename);
 393     PUSH_FIELD (catch_class_type, field, "address", utf8const_ptr_type);
 394     PUSH_FIELD (catch_class_type, field, "classname", ptr_type_node);
 395     FINISH_RECORD (catch_class_type);
 396
 397     TYPE_CTABLE_DECL (type)
 398       = build_decl (VAR_DECL, get_identifier (buf),
 399                     build_array_type (catch_class_type, 0));
 400     DECL_EXTERNAL (TYPE_CTABLE_DECL (type)) = 1;
 401     TREE_STATIC (TYPE_CTABLE_DECL (type)) = 1;
 402     TREE_READONLY (TYPE_CTABLE_DECL (type)) = 1;
 403     TREE_CONSTANT (TYPE_CTABLE_DECL (type)) = 1;
 404     DECL_IGNORED_P (TYPE_CTABLE_DECL (type)) = 1;
 405     pushdecl (TYPE_CTABLE_DECL (type));
 406   }
 407
 408   if (flag_indirect_dispatch)
 409     {
 410       GEN_TABLE (ATABLE, _atable, atable_type, type);
 411       GEN_TABLE (OTABLE, _otable, otable_type, type);
 412       GEN_TABLE (ITABLE, _itable, itable_type, type);
 413     }
 414 }
 415
 416 #undef GEN_TABLE
 417
 418 tree
 419 push_class (tree class_type, tree class_name)
 420 {
 421   tree decl, signature;
 422   location_t saved_loc = input_location;
 423 #ifndef USE_MAPPED_LOCATION
 424   tree source_name = identifier_subst (class_name, "", '.', '/', ".java");
 425   input_filename = IDENTIFIER_POINTER (source_name);
 426   input_line = 0;
 427 #endif
 428   CLASS_P (class_type) = 1;
 429   decl = build_decl (TYPE_DECL, class_name, class_type);
 430   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
 431
 432   /* dbxout needs a DECL_SIZE if in gstabs mode */
 433   DECL_SIZE (decl) = integer_zero_node;
 434
 435   input_location = saved_loc;
 436   signature = identifier_subst (class_name, "L", '.', '/', ";");
 437   IDENTIFIER_SIGNATURE_TYPE (signature) = build_pointer_type (class_type);
 438
 439   /* Setting DECL_ARTIFICIAL forces dbxout.c to specific the type is
 440      both a typedef and in the struct name-space.  We may want to re-visit
 441      this later, but for now it reduces the changes needed for gdb. */
 442   DECL_ARTIFICIAL (decl) = 1;
 443
 444   pushdecl_top_level (decl);
 445
 446   return decl;
 447 }
 448
 449 /* Finds the (global) class named NAME.  Creates the class if not found.
 450    Also creates associated TYPE_DECL.
 451    Does not check if the class actually exists, load the class,
 452    fill in field or methods, or do layout_type. */
 453
 454 tree
 455 lookup_class (tree name)
 456 {
 457   tree decl = IDENTIFIER_CLASS_VALUE (name);
 458   if (decl == NULL_TREE)
 459     decl = push_class (make_class (), name);
 460   return TREE_TYPE (decl);
 461 }
 462
 463 void
 464 set_super_info (int access_flags, tree this_class,
 465                 tree super_class, int interfaces_count)
 466 {
 467   int total_supers = interfaces_count;
 468   tree class_decl = TYPE_NAME (this_class);
 469
 470   if (super_class)
 471     total_supers++;
 472
 473   if (total_supers)
 474     TYPE_BINFO (this_class) = make_tree_binfo (total_supers);
 475   TYPE_VFIELD (this_class) = TYPE_VFIELD (object_type_node);
 476   if (super_class)
 477     {
 478       tree super_binfo = make_tree_binfo (0);
 479       BINFO_TYPE (super_binfo) = super_class;
 480       BINFO_OFFSET (super_binfo) = integer_zero_node;
 481       BINFO_BASE_APPEND (TYPE_BINFO (this_class), super_binfo);
 482       CLASS_HAS_SUPER_FLAG (TYPE_BINFO (this_class)) = 1;
 483     }
 484
 485   set_class_decl_access_flags (access_flags, class_decl);
 486 }
 487
 488 void
 489 set_class_decl_access_flags (int access_flags, tree class_decl)
 490 {
 491   if (access_flags & ACC_PUBLIC)    CLASS_PUBLIC (class_decl) = 1;
 492   if (access_flags & ACC_FINAL)     CLASS_FINAL (class_decl) = 1;
 493   if (access_flags & ACC_SUPER)     CLASS_SUPER (class_decl) = 1;
 494   if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
 495   if (access_flags & ACC_ABSTRACT)  CLASS_ABSTRACT (class_decl) = 1;
 496   if (access_flags & ACC_STATIC)    CLASS_STATIC (class_decl) = 1;
 497   if (access_flags & ACC_PRIVATE)   CLASS_PRIVATE (class_decl) = 1;
 498   if (access_flags & ACC_PROTECTED) CLASS_PROTECTED (class_decl) = 1;
 499   if (access_flags & ACC_STRICT)    CLASS_STRICTFP (class_decl) = 1;
 500 }
 501
 502 /* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
 503    direct sub-classes of Object are 1, and so on. */
 504
 505 int
 506 class_depth (tree clas)
 507 {
 508   int depth = 0;
 509   if (! CLASS_LOADED_P (clas))
 510     load_class (clas, 1);
 511   if (TYPE_SIZE (clas) == error_mark_node)
 512     return -1;
 513   while (clas != object_type_node)
 514     {
 515       depth++;
 516       clas = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (clas), 0));
 517     }
 518   return depth;
 519 }
 520
 521 /* Return true iff TYPE2 is an interface that extends interface TYPE1 */
 522
 523 int
 524 interface_of_p (tree type1, tree type2)
 525 {
 526   int i;
 527   tree binfo, base_binfo;
 528
 529   if (! TYPE_BINFO (type2))
 530     return 0;
 531
 532   for (binfo = TYPE_BINFO (type2), i = 0;
 533        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 534     if (BINFO_TYPE (base_binfo) == type1)
 535       return 1;
 536
 537   for (binfo = TYPE_BINFO (type2), i = 0;
 538        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) /*  */
 539     if (BINFO_TYPE (base_binfo)
 540         && interface_of_p (type1, BINFO_TYPE (base_binfo)))
 541       return 1;
 542
 543   return 0;
 544 }
 545
 546 /* Return true iff TYPE1 inherits from TYPE2. */
 547
 548 int
 549 inherits_from_p (tree type1, tree type2)
 550 {
 551   while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
 552     {
 553       if (type1 == type2)
 554         return 1;
 555
 556       if (! CLASS_LOADED_P (type1))
 557         load_class (type1, 1);
 558
 559       type1 = maybe_layout_super_class (CLASSTYPE_SUPER (type1), type1);
 560     }
 561   return 0;
 562 }
 563
 564 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
 565
 566 int
 567 enclosing_context_p (tree type1, tree type2)
 568 {
 569   if (!INNER_CLASS_TYPE_P (type2))
 570     return 0;
 571
 572   for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
 573        type2;
 574        type2 = (INNER_CLASS_TYPE_P (type2) ?
 575                 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
 576     {
 577       if (type2 == type1)
 578         return 1;
 579     }
 580
 581   return 0;
 582 }
 583
 584
 585 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
 586    nesting level.  */
 587
 588 int
 589 common_enclosing_context_p (tree type1, tree type2)
 590 {
 591   while (type1)
 592     {
 593       tree current;
 594       for (current = type2; current;
 595            current = (INNER_CLASS_TYPE_P (current) ?
 596                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
 597                       NULL_TREE))
 598         if (type1 == current)
 599           return 1;
 600
 601       if (INNER_CLASS_TYPE_P (type1))
 602         type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1)));
 603       else
 604         break;
 605     }
 606   return 0;
 607 }
 608
 609 /* Return 1 iff there exists a common enclosing "this" between TYPE1
 610    and TYPE2, without crossing any static context.  */
 611
 612 int
 613 common_enclosing_instance_p (tree type1, tree type2)
 614 {
 615   if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
 616     return 0;
 617
 618   for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1;
 619        type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
 620                 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
 621     {
 622       tree current;
 623       for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
 624            current = (PURE_INNER_CLASS_TYPE_P (current) ?
 625                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
 626                       NULL_TREE))
 627         if (type1 == current)
 628           return 1;
 629     }
 630   return 0;
 631 }
 632
 633 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
 634    found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
 635    if attempt is made to add it twice. */
 636
 637 tree
 638 maybe_add_interface (tree this_class, tree interface_class)
 639 {
 640   tree binfo, base_binfo;
 641   int i;
 642
 643   for (binfo = TYPE_BINFO (this_class), i = 0;
 644        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 645     if (BINFO_TYPE (base_binfo) == interface_class)
 646       return interface_class;
 647   add_interface (this_class, interface_class);
 648   return NULL_TREE;
 649 }
 650
 651 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
 652
 653 void
 654 add_interface (tree this_class, tree interface_class)
 655 {
 656   tree interface_binfo = make_tree_binfo (0);
 657
 658   BINFO_TYPE (interface_binfo) = interface_class;
 659   BINFO_OFFSET (interface_binfo) = integer_zero_node;
 660   BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node;
 661   BINFO_VIRTUAL_P (interface_binfo) = 1;
 662
 663   BINFO_BASE_APPEND (TYPE_BINFO (this_class), interface_binfo);
 664 }
 665
 666 #if 0
 667 /* Return the address of a pointer to the first FUNCTION_DECL
 668    in the list (*LIST) whose DECL_NAME is NAME. */
 669
 670 static tree *
 671 find_named_method (tree *list, tree name)
 672 {
 673   while (*list && DECL_NAME (*list) != name)
 674     list = &TREE_CHAIN (*list);
 675   return list;
 676 }
 677 #endif
 678
 679 static tree
 680 build_java_method_type (tree fntype, tree this_class, int access_flags)
 681 {
 682   if (access_flags & ACC_STATIC)
 683     return fntype;
 684   fntype = build_method_type (this_class, fntype);
 685
 686   /* We know that arg 1 of every nonstatic method is non-null; tell
 687      the back-end so.  */
 688   TYPE_ATTRIBUTES (fntype) = (tree_cons
 689                               (get_identifier ("nonnull"),
 690                                tree_cons (NULL_TREE,
 691                                           build_int_cst (NULL_TREE, 1),
 692                                           NULL_TREE),
 693                                TYPE_ATTRIBUTES (fntype)));
 694   return fntype;
 695 }
 696
 697 tree
 698 add_method_1 (tree this_class, int access_flags, tree name, tree function_type)
 699 {
 700   tree method_type, fndecl;
 701
 702   method_type = build_java_method_type (function_type,
 703                                         this_class, access_flags);
 704
 705   fndecl = build_decl (FUNCTION_DECL, name, method_type);
 706   DECL_CONTEXT (fndecl) = this_class;
 707
 708   DECL_LANG_SPECIFIC (fndecl)
 709     = ggc_alloc_cleared (sizeof (struct lang_decl));
 710   DECL_LANG_SPECIFIC (fndecl)->desc = LANG_DECL_FUNC;
 711
 712   /* Initialize the static initializer test table.  */
 713
 714   DECL_FUNCTION_INIT_TEST_TABLE (fndecl) =
 715     java_treetreehash_create (10, 1);
 716
 717   /* Initialize the initialized (static) class table. */
 718   if (access_flags & ACC_STATIC)
 719     DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) =
 720       htab_create_ggc (50, htab_hash_pointer, htab_eq_pointer, NULL);
 721
 722   /* Initialize the static method invocation compound list */
 723   DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = NULL_TREE;
 724
 725   TREE_CHAIN (fndecl) = TYPE_METHODS (this_class);
 726   TYPE_METHODS (this_class) = fndecl;
 727
 728   /* Notice that this is a finalizer and update the class type
 729      accordingly. This is used to optimize instance allocation. */
 730   if (name == finalize_identifier_node
 731       && TREE_TYPE (function_type) == void_type_node
 732       && TREE_VALUE (TYPE_ARG_TYPES (function_type)) == void_type_node)
 733     HAS_FINALIZER_P (this_class) = 1;
 734
 735   if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
 736   if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
 737   if (access_flags & ACC_PRIVATE)
 738     METHOD_PRIVATE (fndecl) = DECL_INLINE (fndecl) = 1;
 739   if (access_flags & ACC_NATIVE)
 740     {
 741       METHOD_NATIVE (fndecl) = 1;
 742       DECL_EXTERNAL (fndecl) = 1;
 743     }
 744   if (access_flags & ACC_STATIC)
 745     METHOD_STATIC (fndecl) = DECL_INLINE (fndecl) = 1;
 746   if (access_flags & ACC_FINAL)
 747     METHOD_FINAL (fndecl) = DECL_INLINE (fndecl) = 1;
 748   if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
 749   if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
 750   if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
 751   return fndecl;
 752 }
 753
 754 /* Add a method to THIS_CLASS.
 755    The method's name is NAME.
 756    Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
 757
 758 tree
 759 add_method (tree this_class, int access_flags, tree name, tree method_sig)
 760 {
 761   tree function_type, fndecl;
 762   const unsigned char *sig
 763     = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
 764
 765   if (sig[0] != '(')
 766     fatal_error ("bad method signature");
 767
 768   function_type = get_type_from_signature (method_sig);
 769   fndecl = add_method_1 (this_class, access_flags, name, function_type);
 770   set_java_signature (TREE_TYPE (fndecl), method_sig);
 771   return fndecl;
 772 }
 773
 774 tree
 775 add_field (tree class, tree name, tree field_type, int flags)
 776 {
 777   int is_static = (flags & ACC_STATIC) != 0;
 778   tree field;
 779   field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type);
 780   TREE_CHAIN (field) = TYPE_FIELDS (class);
 781   TYPE_FIELDS (class) = field;
 782   DECL_CONTEXT (field) = class;
 783
 784   if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
 785   if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
 786   if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
 787   if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
 788   if (flags & ACC_VOLATILE)
 789     {
 790       FIELD_VOLATILE (field) = 1;
 791       TREE_THIS_VOLATILE (field) = 1;
 792     }
 793   if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
 794   if (is_static)
 795     {
 796       FIELD_STATIC (field) = 1;
 797       /* Always make field externally visible.  This is required so
 798          that native methods can always access the field.  */
 799       TREE_PUBLIC (field) = 1;
 800       /* Considered external until we know what classes are being
 801          compiled into this object file.  */
 802       DECL_EXTERNAL (field) = 1;
 803     }
 804
 805   return field;
 806 }
 807
 808 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
 809
 810 void
 811 set_constant_value (tree field, tree constant)
 812 {
 813   if (field == NULL_TREE)
 814     warning (OPT_Wattributes,
 815              "misplaced ConstantValue attribute (not in any field)");
 816   else if (DECL_INITIAL (field) != NULL_TREE)
 817     warning (OPT_Wattributes,
 818              "duplicate ConstantValue attribute for field '%s'",
 819              IDENTIFIER_POINTER (DECL_NAME (field)));
 820   else
 821     {
 822       DECL_INITIAL (field) = constant;
 823       if (TREE_TYPE (constant) != TREE_TYPE (field)
 824           && ! (TREE_TYPE (constant) == int_type_node
 825                 && INTEGRAL_TYPE_P (TREE_TYPE (field))
 826                 && TYPE_PRECISION (TREE_TYPE (field)) <= 32)
 827           && ! (TREE_TYPE (constant) == utf8const_ptr_type
 828                 && TREE_TYPE (field) == string_ptr_type_node))
 829         error ("ConstantValue attribute of field '%s' has wrong type",
 830                IDENTIFIER_POINTER (DECL_NAME (field)));
 831       if (FIELD_FINAL (field))
 832         DECL_FIELD_FINAL_IUD (field) = 1;
 833     }
 834 }
 835
 836 /* Count the number of Unicode chars encoded in a given Ut8 string. */
 837
 838 #if 0
 839 int
 840 strLengthUtf8 (char *str, int len)
 841 {
 842   register unsigned char* ptr = (unsigned char*) str;
 843   register unsigned char *limit = ptr + len;
 844   int str_length = 0;
 845   for (; ptr < limit; str_length++) {
 846     if (UTF8_GET (ptr, limit) < 0)
 847       return -1;
 848   }
 849   return str_length;
 850 }
 851 #endif
 852
 853
 854 /* Calculate a hash value for a string encoded in Utf8 format.
 855  * This returns the same hash value as specified for java.lang.String.hashCode.
 856  */
 857
 858 static int32
 859 hashUtf8String (const char *str, int len)
 860 {
 861   const unsigned char* ptr = (const unsigned char*) str;
 862   const unsigned char *limit = ptr + len;
 863   int32 hash = 0;
 864   for (; ptr < limit;)
 865     {
 866       int ch = UTF8_GET (ptr, limit);
 867       /* Updated specification from
 868          http://www.javasoft.com/docs/books/jls/clarify.html. */
 869       hash = (31 * hash) + ch;
 870     }
 871   return hash;
 872 }
 873
 874 static GTY(()) tree utf8_decl_list = NULL_TREE;
 875
 876 tree
 877 build_utf8_ref (tree name)
 878 {
 879   const char * name_ptr = IDENTIFIER_POINTER(name);
 880   int name_len = IDENTIFIER_LENGTH(name);
 881   char buf[60];
 882   tree ctype, field = NULL_TREE, str_type, cinit, string;
 883   static int utf8_count = 0;
 884   int name_hash;
 885   tree ref = IDENTIFIER_UTF8_REF (name);
 886   tree decl;
 887   if (ref != NULL_TREE)
 888     return ref;
 889
 890   ctype = make_node (RECORD_TYPE);
 891   str_type = build_prim_array_type (unsigned_byte_type_node,
 892                                     name_len + 1); /* Allow for final '\0'. */
 893   PUSH_FIELD (ctype, field, "hash", unsigned_short_type_node);
 894   PUSH_FIELD (ctype, field, "length", unsigned_short_type_node);
 895   PUSH_FIELD (ctype, field, "data", str_type);
 896   FINISH_RECORD (ctype);
 897   START_RECORD_CONSTRUCTOR (cinit, ctype);
 898   name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
 899   PUSH_FIELD_VALUE (cinit, "hash", build_int_cst (NULL_TREE, name_hash));
 900   PUSH_FIELD_VALUE (cinit, "length", build_int_cst (NULL_TREE, name_len));
 901   string = build_string (name_len, name_ptr);
 902   TREE_TYPE (string) = str_type;
 903   PUSH_FIELD_VALUE (cinit, "data", string);
 904   FINISH_RECORD_CONSTRUCTOR (cinit);
 905   TREE_CONSTANT (cinit) = 1;
 906   TREE_INVARIANT (cinit) = 1;
 907
 908   /* Generate a unique-enough identifier.  */
 909   sprintf(buf, "_Utf%d", ++utf8_count);
 910
 911   decl = build_decl (VAR_DECL, get_identifier (buf), utf8const_type);
 912   TREE_STATIC (decl) = 1;
 913   DECL_ARTIFICIAL (decl) = 1;
 914   DECL_IGNORED_P (decl) = 1;
 915   TREE_READONLY (decl) = 1;
 916   TREE_THIS_VOLATILE (decl) = 0;
 917   DECL_INITIAL (decl) = cinit;
 918
 919   if (HAVE_GAS_SHF_MERGE)
 920     {
 921       int decl_size;
 922       /* Ensure decl_size is a multiple of utf8const_type's alignment. */
 923       decl_size = (name_len + 5 + TYPE_ALIGN_UNIT (utf8const_type) - 1)
 924         & ~(TYPE_ALIGN_UNIT (utf8const_type) - 1);
 925       if (flag_merge_constants && decl_size < 256)
 926         {
 927           char buf[32];
 928           int flags = (SECTION_OVERRIDE
 929                        | SECTION_MERGE | (SECTION_ENTSIZE & decl_size));
 930           sprintf (buf, ".rodata.jutf8.%d", decl_size);
 931           switch_to_section (get_section (buf, flags, NULL));
 932           DECL_SECTION_NAME (decl) = build_string (strlen (buf), buf);
 933         }
 934     }
 935
 936   TREE_CHAIN (decl) = utf8_decl_list;
 937   layout_decl (decl, 0);
 938   pushdecl (decl);
 939   rest_of_decl_compilation (decl, global_bindings_p (), 0);
 940   cgraph_varpool_mark_needed_node (cgraph_varpool_node (decl));
 941   utf8_decl_list = decl;
 942   ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
 943   IDENTIFIER_UTF8_REF (name) = ref;
 944   return ref;
 945 }
 946
 947 /* Like build_class_ref, but instead of a direct reference generate a
 948    pointer into the constant pool.  */
 949
 950 static tree
 951 build_indirect_class_ref (tree type)
 952 {
 953   int index;
 954   tree cl;
 955   index = alloc_class_constant (type);
 956   cl = build_ref_from_constant_pool (index);
 957   return convert (promote_type (class_ptr_type), cl);
 958 }
 959
 960 static tree
 961 build_static_class_ref (tree type)
 962 {
 963   tree decl_name, decl, ref;
 964
 965   if (TYPE_SIZE (type) == error_mark_node)
 966     return null_pointer_node;
 967   decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
 968                                 "", '/', '/', ".class$$");
 969   decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
 970   if (decl == NULL_TREE)
 971     {
 972       decl = build_decl (VAR_DECL, decl_name, class_type_node);
 973       TREE_STATIC (decl) = 1;
 974       if (! flag_indirect_classes)
 975         TREE_PUBLIC (decl) = 1;
 976       DECL_IGNORED_P (decl) = 1;
 977       DECL_ARTIFICIAL (decl) = 1;
 978       if (is_compiled_class (type) == 1)
 979         DECL_EXTERNAL (decl) = 1;
 980       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
 981       DECL_CLASS_FIELD_P (decl) = 1;
 982       DECL_CONTEXT (decl) = type;
 983
 984       /* ??? We want to preserve the DECL_CONTEXT we set just above,
 985          that that means not calling pushdecl_top_level.  */
 986       IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
 987     }
 988
 989   ref = build1 (ADDR_EXPR, class_ptr_type, decl);
 990   return ref;
 991 }
 992
 993 static tree
 994 build_classdollar_field (tree type)
 995 {
 996   tree decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
 997                                      "", '/', '/', ".class$");
 998   tree decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
 999
1000   if (decl == NULL_TREE)
1001     {
1002       decl
1003         = build_decl (VAR_DECL, decl_name,
1004                       (build_type_variant
1005                        (build_pointer_type
1006                         (build_type_variant (class_type_node,
1007                                              /* const */ 1, 0)),
1008                         /* const */ 1, 0)));
1009       TREE_STATIC (decl) = 1;
1010       TREE_INVARIANT (decl) = 1;
1011       TREE_CONSTANT (decl) = 1;
1012       TREE_READONLY (decl) = 1;
1013       TREE_PUBLIC (decl) = 1;
1014       DECL_IGNORED_P (decl) = 1;
1015       DECL_ARTIFICIAL (decl) = 1;
1016       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1017       IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
1018       DECL_CLASS_FIELD_P (decl) = 1;
1019       DECL_CONTEXT (decl) = type;
1020     }
1021
1022   return decl;
1023 }
1024
1025 /* Build a reference to the class TYPE.
1026    Also handles primitive types and array types. */
1027
1028 tree
1029 build_class_ref (tree type)
1030 {
1031   int is_compiled = is_compiled_class (type);
1032   if (is_compiled)
1033     {
1034       tree ref, decl;
1035       if (TREE_CODE (type) == POINTER_TYPE)
1036         type = TREE_TYPE (type);
1037
1038       if (flag_indirect_dispatch
1039           && type != output_class
1040           && TREE_CODE (type) == RECORD_TYPE)
1041         return build_indirect_class_ref (type);
1042
1043       if (type == output_class && flag_indirect_classes)
1044         return build_classdollar_field (type);
1045
1046       if (TREE_CODE (type) == RECORD_TYPE)
1047         return build_static_class_ref (type);
1048       else
1049         {
1050           const char *name;
1051           tree decl_name;
1052           char buffer[25];
1053           if (flag_emit_class_files)
1054             {
1055               const char *prim_class_name;
1056               tree prim_class;
1057               if (type == char_type_node)
1058                 prim_class_name = "java.lang.Character";
1059               else if (type == boolean_type_node)
1060                 prim_class_name = "java.lang.Boolean";
1061               else if (type == byte_type_node)
1062                 prim_class_name = "java.lang.Byte";
1063               else if (type == short_type_node)
1064                 prim_class_name = "java.lang.Short";
1065               else if (type == int_type_node)
1066                 prim_class_name = "java.lang.Integer";
1067               else if (type == long_type_node)
1068                 prim_class_name = "java.lang.Long";
1069               else if (type == float_type_node)
1070                 prim_class_name = "java.lang.Float";
1071               else if (type == double_type_node)
1072                 prim_class_name = "java.lang.Double";
1073               else if (type == void_type_node)
1074                 prim_class_name = "java.lang.Void";
1075               else
1076                 gcc_unreachable ();
1077
1078               prim_class = lookup_class (get_identifier (prim_class_name));
1079               /* We wrap the class in a NOP_EXPR, because it is a
1080                  type.  We can't hold it in the COMPONENT_REF itself,
1081                  as that type must remain NULL.  */
1082               prim_class = build1 (NOP_EXPR, prim_class, NULL_TREE);
1083
1084               return build3 (COMPONENT_REF, NULL_TREE,
1085                              prim_class, TYPE_identifier_node, NULL_TREE);
1086             }
1087           decl_name = TYPE_NAME (type);
1088           if (TREE_CODE (decl_name) == TYPE_DECL)
1089             decl_name = DECL_NAME (decl_name);
1090           name = IDENTIFIER_POINTER (decl_name);
1091           if (strncmp (name, "promoted_", 9) == 0)
1092             name += 9;
1093           sprintf (buffer, "_Jv_%sClass", name);
1094           decl_name = get_identifier (buffer);
1095           decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1096           if (decl == NULL_TREE)
1097             {
1098               decl = build_decl (VAR_DECL, decl_name, class_type_node);
1099               TREE_STATIC (decl) = 1;
1100               TREE_PUBLIC (decl) = 1;
1101               DECL_EXTERNAL (decl) = 1;
1102               DECL_ARTIFICIAL (decl) = 1;
1103               pushdecl_top_level (decl);
1104             }
1105         }
1106
1107       ref = build1 (ADDR_EXPR, class_ptr_type, decl);
1108       return ref;
1109     }
1110   else
1111     return build_indirect_class_ref (type);
1112 }
1113
1114 /* Create a local statically allocated variable that will hold a
1115    pointer to a static field.  */
1116
1117 static tree
1118 build_fieldref_cache_entry (int index, tree fdecl ATTRIBUTE_UNUSED)
1119 {
1120   tree decl, decl_name;
1121   const char *name = IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class));
1122   char *buf = alloca (strlen (name) + 20);
1123   sprintf (buf, "%s_%d_ref", name, index);
1124   decl_name = get_identifier (buf);
1125   decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1126   if (decl == NULL_TREE)
1127     {
1128       decl = build_decl (VAR_DECL, decl_name, ptr_type_node);
1129       TREE_STATIC (decl) = 1;
1130       TREE_PUBLIC (decl) = 0;
1131       DECL_EXTERNAL (decl) = 0;
1132       DECL_ARTIFICIAL (decl) = 1;
1133       DECL_IGNORED_P (decl) = 1;
1134       pushdecl_top_level (decl);
1135     }
1136   return decl;
1137 }
1138
1139 tree
1140 build_static_field_ref (tree fdecl)
1141 {
1142   tree fclass = DECL_CONTEXT (fdecl);
1143   int is_compiled = is_compiled_class (fclass);
1144   int from_class = ! CLASS_FROM_SOURCE_P (current_class);
1145
1146   /* Allow static final fields to fold to a constant.  When using
1147      -findirect-dispatch, we simply never do this folding if compiling
1148      from .class; in the .class file constants will be referred to via
1149      the constant pool.  */
1150   if ((!flag_indirect_dispatch || !from_class)
1151       && (is_compiled
1152           || (FIELD_FINAL (fdecl) && DECL_INITIAL (fdecl) != NULL_TREE
1153               && (JSTRING_TYPE_P (TREE_TYPE (fdecl))
1154                   || JNUMERIC_TYPE_P (TREE_TYPE (fdecl)))
1155               && TREE_CONSTANT (DECL_INITIAL (fdecl)))))
1156     {
1157       if (is_compiled == 1)
1158         DECL_EXTERNAL (fdecl) = 1;
1159     }
1160   else
1161     {
1162       /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1163          and a class local static variable CACHE_ENTRY, then
1164
1165       *(fdecl **)((__builtin_expect (cache_entry == null, false))
1166                   ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1167                   : cache_entry)
1168
1169       This can mostly be optimized away, so that the usual path is a
1170       load followed by a test and branch.  _Jv_ResolvePoolEntry is
1171       only called once for each constant pool entry.
1172
1173       There is an optimization that we don't do: at the start of a
1174       method, create a local copy of CACHE_ENTRY and use that instead.
1175
1176       */
1177
1178       int cpool_index = alloc_constant_fieldref (output_class, fdecl);
1179       tree cache_entry = build_fieldref_cache_entry (cpool_index, fdecl);
1180       tree test
1181         = build3 (CALL_EXPR, boolean_type_node,
1182                   build_address_of (built_in_decls[BUILT_IN_EXPECT]),
1183                   tree_cons (NULL_TREE, build2 (EQ_EXPR, boolean_type_node,
1184                                                 cache_entry, null_pointer_node),
1185                              build_tree_list (NULL_TREE, boolean_false_node)),
1186                   NULL_TREE);
1187       tree cpool_index_cst = build_int_cst (NULL_TREE, cpool_index);
1188       tree init
1189         = build3 (CALL_EXPR, ptr_type_node,
1190                   build_address_of (soft_resolvepoolentry_node),
1191                   tree_cons (NULL_TREE, build_class_ref (output_class),
1192                              build_tree_list (NULL_TREE, cpool_index_cst)),
1193                   NULL_TREE);
1194       init = build2 (MODIFY_EXPR, ptr_type_node, cache_entry, init);
1195       init = build3 (COND_EXPR, ptr_type_node, test, init, cache_entry);
1196       init = fold_convert (build_pointer_type (TREE_TYPE (fdecl)), init);
1197       fdecl = build1 (INDIRECT_REF, TREE_TYPE (fdecl), init);
1198     }
1199   return fdecl;
1200 }
1201
1202 int
1203 get_access_flags_from_decl (tree decl)
1204 {
1205   int access_flags = 0;
1206   if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
1207     {
1208       if (FIELD_STATIC (decl))
1209         access_flags |= ACC_STATIC;
1210       if (FIELD_PUBLIC (decl))
1211         access_flags |= ACC_PUBLIC;
1212       if (FIELD_PROTECTED (decl))
1213         access_flags |= ACC_PROTECTED;
1214       if (FIELD_PRIVATE (decl))
1215         access_flags |= ACC_PRIVATE;
1216       if (FIELD_FINAL (decl))
1217         access_flags |= ACC_FINAL;
1218       if (FIELD_VOLATILE (decl))
1219         access_flags |= ACC_VOLATILE;
1220       if (FIELD_TRANSIENT (decl))
1221         access_flags |= ACC_TRANSIENT;
1222       return access_flags;
1223     }
1224   if (TREE_CODE (decl) == TYPE_DECL)
1225     {
1226       if (CLASS_PUBLIC (decl))
1227         access_flags |= ACC_PUBLIC;
1228       if (CLASS_FINAL (decl))
1229         access_flags |= ACC_FINAL;
1230       if (CLASS_SUPER (decl))
1231         access_flags |= ACC_SUPER;
1232       if (CLASS_INTERFACE (decl))
1233         access_flags |= ACC_INTERFACE;
1234       if (CLASS_ABSTRACT (decl))
1235         access_flags |= ACC_ABSTRACT;
1236       if (CLASS_STATIC (decl))
1237         access_flags |= ACC_STATIC;
1238       if (CLASS_PRIVATE (decl))
1239         access_flags |= ACC_PRIVATE;
1240       if (CLASS_PROTECTED (decl))
1241         access_flags |= ACC_PROTECTED;
1242       if (CLASS_STRICTFP (decl))
1243         access_flags |= ACC_STRICT;
1244       return access_flags;
1245     }
1246   if (TREE_CODE (decl) == FUNCTION_DECL)
1247     {
1248       if (METHOD_PUBLIC (decl))
1249         access_flags |= ACC_PUBLIC;
1250       if (METHOD_PRIVATE (decl))
1251         access_flags |= ACC_PRIVATE;
1252       if (METHOD_PROTECTED (decl))
1253         access_flags |= ACC_PROTECTED;
1254       if (METHOD_STATIC (decl))
1255         access_flags |= ACC_STATIC;
1256       if (METHOD_FINAL (decl))
1257         access_flags |= ACC_FINAL;
1258       if (METHOD_SYNCHRONIZED (decl))
1259         access_flags |= ACC_SYNCHRONIZED;
1260       if (METHOD_NATIVE (decl))
1261         access_flags |= ACC_NATIVE;
1262       if (METHOD_ABSTRACT (decl))
1263         access_flags |= ACC_ABSTRACT;
1264       if (METHOD_STRICTFP (decl))
1265         access_flags |= ACC_STRICT;
1266       if (METHOD_INVISIBLE (decl))
1267         access_flags |= ACC_INVISIBLE;
1268       return access_flags;
1269     }
1270   gcc_unreachable ();
1271 }
1272
1273 static GTY (()) int alias_labelno = 0;
1274
1275 /* Create a private alias for METHOD. Using this alias instead of the method
1276    decl ensures that ncode entries in the method table point to the real function
1277    at runtime, not a PLT entry.  */
1278
1279 static tree
1280 make_local_function_alias (tree method)
1281 {
1282 #ifdef ASM_OUTPUT_DEF
1283   tree alias;
1284
1285   const char *method_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method));
1286   char *name = alloca (strlen (method_name) + 2);
1287   char *buf = alloca (strlen (method_name) + 128);
1288
1289   /* Only create aliases for local functions.  */
1290   if (DECL_EXTERNAL (method))
1291     return method;
1292
1293   /* Prefix method_name with 'L' for the alias label.  */
1294   *name = 'L';
1295   strcpy (name + 1, method_name);
1296
1297   ASM_GENERATE_INTERNAL_LABEL (buf, name, alias_labelno++);
1298   alias = build_decl (FUNCTION_DECL, get_identifier (buf),
1299                       TREE_TYPE (method));
1300   DECL_CONTEXT (alias) = NULL;
1301   TREE_READONLY (alias) = TREE_READONLY (method);
1302   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (method);
1303   TREE_PUBLIC (alias) = 0;
1304   DECL_EXTERNAL (alias) = 0;
1305   DECL_ARTIFICIAL (alias) = 1;
1306   DECL_INLINE (alias) = 0;
1307   DECL_INITIAL (alias) = error_mark_node;
1308   TREE_ADDRESSABLE (alias) = 1;
1309   TREE_USED (alias) = 1;
1310   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
1311   if (!flag_syntax_only)
1312     assemble_alias (alias, DECL_ASSEMBLER_NAME (method));
1313   return alias;
1314 #else
1315   return method;
1316 #endif
1317 }
1318
1319 /** Make reflection data (_Jv_Field) for field FDECL. */
1320
1321 static tree
1322 make_field_value (tree fdecl)
1323 {
1324   tree finit;
1325   int flags;
1326   tree type = TREE_TYPE (fdecl);
1327   int resolved = is_compiled_class (type) && ! flag_indirect_dispatch;
1328
1329   START_RECORD_CONSTRUCTOR (finit, field_type_node);
1330   PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl)));
1331   if (resolved)
1332     type = build_class_ref (type);
1333   else
1334     {
1335       tree signature = build_java_signature (type);
1336
1337       type = build_utf8_ref (unmangle_classname
1338                              (IDENTIFIER_POINTER (signature),
1339                               IDENTIFIER_LENGTH (signature)));
1340     }
1341   PUSH_FIELD_VALUE (finit, "type", type);
1342
1343   flags = get_access_flags_from_decl (fdecl);
1344   if (! resolved)
1345     flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1346
1347   PUSH_FIELD_VALUE (finit, "accflags", build_int_cst (NULL_TREE, flags));
1348   PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
1349
1350   {
1351     tree field_address = integer_zero_node;
1352     if ((DECL_INITIAL (fdecl) || ! flag_indirect_classes)
1353         && FIELD_STATIC (fdecl))
1354       field_address = build_address_of (fdecl);
1355
1356     PUSH_FIELD_VALUE
1357       (finit, "info",
1358        build_constructor_from_list (field_info_union_node,
1359          build_tree_list
1360            ((FIELD_STATIC (fdecl)
1361              ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
1362              : TYPE_FIELDS (field_info_union_node)),
1363             (FIELD_STATIC (fdecl)
1364              ? field_address
1365              : byte_position (fdecl)))));
1366   }
1367
1368   FINISH_RECORD_CONSTRUCTOR (finit);
1369   return finit;
1370 }
1371
1372 /** Make reflection data (_Jv_Method) for method MDECL. */
1373
1374 static tree
1375 make_method_value (tree mdecl)
1376 {
1377   static int method_name_count = 0;
1378   tree minit;
1379   tree index;
1380   tree code;
1381   tree class_decl;
1382 #define ACC_TRANSLATED          0x4000
1383   int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
1384
1385   class_decl = DECL_CONTEXT (mdecl);
1386   /* For interfaces, the index field contains the dispatch index. */
1387   if (CLASS_INTERFACE (TYPE_NAME (class_decl)))
1388     index = build_int_cst (NULL_TREE,
1389                            get_interface_method_index (mdecl, class_decl));
1390   else if (!flag_indirect_dispatch && get_method_index (mdecl) != NULL_TREE)
1391     index = get_method_index (mdecl);
1392   else
1393     index = integer_minus_one_node;
1394
1395   code = null_pointer_node;
1396   if (METHOD_ABSTRACT (mdecl))
1397     code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1398                    soft_abstractmethod_node);
1399   else
1400     code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1401                    make_local_function_alias (mdecl));
1402   START_RECORD_CONSTRUCTOR (minit, method_type_node);
1403   PUSH_FIELD_VALUE (minit, "name",
1404                     build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
1405                                     init_identifier_node
1406                                     : DECL_NAME (mdecl)));
1407   {
1408     tree signature = build_java_signature (TREE_TYPE (mdecl));
1409     PUSH_FIELD_VALUE (minit, "signature",
1410                       (build_utf8_ref
1411                        (unmangle_classname
1412                         (IDENTIFIER_POINTER(signature),
1413                          IDENTIFIER_LENGTH(signature)))));
1414   }
1415   PUSH_FIELD_VALUE (minit, "accflags", build_int_cst (NULL_TREE, accflags));
1416   PUSH_FIELD_VALUE (minit, "index", index);
1417   PUSH_FIELD_VALUE (minit, "ncode", code);
1418
1419   {
1420     /* Compute the `throws' information for the method.  */
1421     tree table = null_pointer_node;
1422     if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE)
1423       {
1424         int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl));
1425         tree iter, type, array;
1426         char buf[60];
1427
1428         table = tree_cons (NULL_TREE, table, NULL_TREE);
1429         for (iter = DECL_FUNCTION_THROWS (mdecl);
1430              iter != NULL_TREE;
1431              iter = TREE_CHAIN (iter))
1432           {
1433             tree sig = DECL_NAME (TYPE_NAME (TREE_VALUE (iter)));
1434             tree utf8
1435               = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
1436                                                     IDENTIFIER_LENGTH (sig)));
1437             table = tree_cons (NULL_TREE, utf8, table);
1438           }
1439         type = build_prim_array_type (ptr_type_node, length);
1440         table = build_constructor_from_list (type, table);
1441         /* Compute something unique enough.  */
1442         sprintf (buf, "_methods%d", method_name_count++);
1443         array = build_decl (VAR_DECL, get_identifier (buf), type);
1444         DECL_INITIAL (array) = table;
1445         TREE_STATIC (array) = 1;
1446         DECL_ARTIFICIAL (array) = 1;
1447         DECL_IGNORED_P (array) = 1;
1448         rest_of_decl_compilation (array, 1, 0);
1449
1450         table = build1 (ADDR_EXPR, ptr_type_node, array);
1451       }
1452
1453     PUSH_FIELD_VALUE (minit, "throws", table);
1454   }
1455
1456   FINISH_RECORD_CONSTRUCTOR (minit);
1457   return minit;
1458 }
1459
1460 static tree
1461 get_dispatch_vector (tree type)
1462 {
1463   tree vtable = TYPE_VTABLE (type);
1464
1465   if (vtable == NULL_TREE)
1466     {
1467       HOST_WIDE_INT i;
1468       tree method;
1469       tree super = CLASSTYPE_SUPER (type);
1470       HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1471       vtable = make_tree_vec (nvirtuals);
1472       TYPE_VTABLE (type) = vtable;
1473       if (super != NULL_TREE)
1474         {
1475           tree super_vtable = get_dispatch_vector (super);
1476
1477           for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1478             TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1479         }
1480
1481       for (method = TYPE_METHODS (type);  method != NULL_TREE;
1482            method = TREE_CHAIN (method))
1483         {
1484           tree method_index = get_method_index (method);
1485           if (method_index != NULL_TREE
1486               && host_integerp (method_index, 0))
1487             TREE_VEC_ELT (vtable, tree_low_cst (method_index, 0)) = method;
1488         }
1489     }
1490
1491   return vtable;
1492 }
1493
1494 static tree
1495 get_dispatch_table (tree type, tree this_class_addr)
1496 {
1497   int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1498   tree vtable = get_dispatch_vector (type);
1499   int i, j;
1500   tree list = NULL_TREE;
1501   int nvirtuals = TREE_VEC_LENGTH (vtable);
1502   int arraysize;
1503   tree gc_descr;
1504
1505   for (i = nvirtuals;  --i >= 0; )
1506     {
1507       tree method = TREE_VEC_ELT (vtable, i);
1508       if (METHOD_ABSTRACT (method))
1509         {
1510           if (! abstract_p)
1511             warning (0, "%Jabstract method in non-abstract class", method);
1512
1513           if (TARGET_VTABLE_USES_DESCRIPTORS)
1514             for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1515               list = tree_cons (NULL_TREE, null_pointer_node, list);
1516           else
1517             list = tree_cons (NULL_TREE, null_pointer_node, list);
1518         }
1519       else
1520         {
1521           if (TARGET_VTABLE_USES_DESCRIPTORS)
1522             for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1523               {
1524                 tree fdesc = build2 (FDESC_EXPR, nativecode_ptr_type_node,
1525                                      method, build_int_cst (NULL_TREE, j));
1526                 TREE_CONSTANT (fdesc) = 1;
1527                 TREE_INVARIANT (fdesc) = 1;
1528                 list = tree_cons (NULL_TREE, fdesc, list);
1529               }
1530           else
1531             list = tree_cons (NULL_TREE,
1532                               build1 (ADDR_EXPR, nativecode_ptr_type_node,
1533                                       method),
1534                               list);
1535         }
1536     }
1537
1538   /* Dummy entry for compatibility with G++ -fvtable-thunks.  When
1539      using the Boehm GC we sometimes stash a GC type descriptor
1540      there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1541      the emitted byte count during the output to the assembly file. */
1542   /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1543      fake "function descriptor".  It's first word is the is the class
1544      pointer, and subsequent words (usually one) contain the GC descriptor.
1545      In all other cases, we reserve two extra vtable slots. */
1546   gc_descr =  get_boehm_type_descriptor (type);
1547   list = tree_cons (NULL_TREE, gc_descr, list);
1548   for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
1549     list = tree_cons (NULL_TREE, gc_descr, list);
1550   list = tree_cons (NULL_TREE, this_class_addr, list);
1551
1552   /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1553   list = tree_cons (NULL_TREE, null_pointer_node, list);
1554   /** Offset to start of whole object.  Always (ptrdiff_t)0 for Java. */
1555   list = tree_cons (integer_zero_node, null_pointer_node, list);
1556
1557   arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
1558   if (TARGET_VTABLE_USES_DESCRIPTORS)
1559     arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
1560   arraysize += 2;
1561   return build_constructor_from_list
1562           (build_prim_array_type (nativecode_ptr_type_node,
1563                                   arraysize), list);
1564 }
1565
1566
1567 /* Set the method_index for a method decl.  */
1568 void
1569 set_method_index (tree decl, tree method_index)
1570 {
1571   if (method_index != NULL_TREE)
1572     {
1573       /* method_index is null if we're using indirect dispatch.  */
1574       method_index = fold (convert (sizetype, method_index));
1575
1576       if (TARGET_VTABLE_USES_DESCRIPTORS)
1577         /* Add one to skip bogus descriptor for class and GC descriptor. */
1578         method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
1579       else
1580         /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1581            descriptor.  */
1582         method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1583     }
1584
1585   DECL_VINDEX (decl) = method_index;
1586 }
1587
1588 /* Get the method_index for a method decl.  */
1589 tree
1590 get_method_index (tree decl)
1591 {
1592   tree method_index = DECL_VINDEX (decl);
1593
1594   if (! method_index)
1595     return NULL;
1596
1597   if (TARGET_VTABLE_USES_DESCRIPTORS)
1598     /* Sub one to skip bogus descriptor for class and GC descriptor. */
1599     method_index = size_binop (MINUS_EXPR, method_index, size_int (1));
1600   else
1601     /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor.  */
1602     method_index = size_binop (MINUS_EXPR, method_index, size_int (2));
1603
1604   return method_index;
1605 }
1606
1607 static int
1608 supers_all_compiled (tree type)
1609 {
1610   while (type != NULL_TREE)
1611     {
1612       if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
1613         return 0;
1614       type = CLASSTYPE_SUPER (type);
1615     }
1616   return 1;
1617 }
1618
1619 void
1620 make_class_data (tree type)
1621 {
1622   tree decl, cons, temp;
1623   tree field, fields_decl;
1624   tree static_fields = NULL_TREE;
1625   tree instance_fields = NULL_TREE;
1626   HOST_WIDE_INT static_field_count = 0;
1627   HOST_WIDE_INT instance_field_count = 0;
1628   HOST_WIDE_INT field_count;
1629   tree field_array_type;
1630   tree method;
1631   tree methods = NULL_TREE;
1632   tree dtable_decl = NULL_TREE;
1633   HOST_WIDE_INT method_count = 0;
1634   tree method_array_type;
1635   tree methods_decl;
1636   tree super;
1637   tree this_class_addr;
1638   tree constant_pool_constructor;
1639   tree interfaces = null_pointer_node;
1640   int interface_len = 0;
1641   int uses_jv_markobj = 0;
1642   tree type_decl = TYPE_NAME (type);
1643   tree id_main = get_identifier("main");
1644   tree id_class = get_identifier("java.lang.Class");
1645   /** Offset from start of virtual function table declaration
1646       to where objects actually point at, following new g++ ABI. */
1647   tree dtable_start_offset = build_int_cst (NULL_TREE,
1648                                             2 * POINTER_SIZE / BITS_PER_UNIT);
1649
1650   this_class_addr = build_static_class_ref (type);
1651   decl = TREE_OPERAND (this_class_addr, 0);
1652
1653   if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
1654       && !flag_indirect_dispatch)
1655     {
1656       tree dtable = get_dispatch_table (type, this_class_addr);
1657       uses_jv_markobj = uses_jv_markobj_p (dtable);
1658       dtable_decl = build_dtable_decl (type);
1659       DECL_INITIAL (dtable_decl) = dtable;
1660       TREE_STATIC (dtable_decl) = 1;
1661       DECL_ARTIFICIAL (dtable_decl) = 1;
1662       DECL_IGNORED_P (dtable_decl) = 1;
1663       TREE_PUBLIC (dtable_decl) = 1;
1664       if (! flag_indirect_classes)
1665         rest_of_decl_compilation (dtable_decl, 1, 0);
1666       if (type == class_type_node)
1667         class_dtable_decl = dtable_decl;
1668     }
1669
1670   /* Build Field array. */
1671   field = TYPE_FIELDS (type);
1672   while (field && DECL_ARTIFICIAL (field))
1673     field = TREE_CHAIN (field);  /* Skip dummy fields.  */
1674   if (field && DECL_NAME (field) == NULL_TREE)
1675     field = TREE_CHAIN (field);  /* Skip dummy field for inherited data. */
1676   for ( ;  field != NULL_TREE;  field = TREE_CHAIN (field))
1677     {
1678       if (! DECL_ARTIFICIAL (field))
1679         {
1680           if (FIELD_STATIC (field))
1681             {
1682               /* We must always create reflection data for static fields
1683                  as it is used in the creation of the field itself. */
1684               tree init = make_field_value (field);
1685               tree initial = DECL_INITIAL (field);
1686               static_field_count++;
1687               static_fields = tree_cons (NULL_TREE, init, static_fields);
1688               /* If the initial value is a string constant,
1689                  prevent output_constant from trying to assemble the value. */
1690               if (initial != NULL_TREE
1691                   && TREE_TYPE (initial) == string_ptr_type_node)
1692                 DECL_INITIAL (field) = NULL_TREE;
1693               rest_of_decl_compilation (field, 1, 1);
1694               DECL_INITIAL (field) = initial;
1695             }
1696           else if (uses_jv_markobj || !flag_reduced_reflection)
1697             {
1698               tree init = make_field_value (field);
1699               instance_field_count++;
1700               instance_fields = tree_cons (NULL_TREE, init, instance_fields);
1701             }
1702         }
1703     }
1704   field_count = static_field_count + instance_field_count;
1705   if (field_count > 0)
1706     {
1707       static_fields = nreverse (static_fields);
1708       instance_fields = nreverse (instance_fields);
1709       static_fields = chainon (static_fields, instance_fields);
1710       field_array_type = build_prim_array_type (field_type_node, field_count);
1711       fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
1712                                 field_array_type);
1713       DECL_INITIAL (fields_decl) = build_constructor_from_list
1714                                     (field_array_type, static_fields);
1715       TREE_STATIC (fields_decl) = 1;
1716       DECL_ARTIFICIAL (fields_decl) = 1;
1717       DECL_IGNORED_P (fields_decl) = 1;
1718       rest_of_decl_compilation (fields_decl, 1, 0);
1719     }
1720   else
1721     fields_decl = NULL_TREE;
1722
1723   /* Build Method array. */
1724   for (method = TYPE_METHODS (type);
1725        method != NULL_TREE; method = TREE_CHAIN (method))
1726     {
1727       tree init;
1728       if (METHOD_PRIVATE (method)
1729           && ! flag_keep_inline_functions
1730           && optimize)
1731         continue;
1732       /* Even if we have a decl, we don't necessarily have the code.
1733          This can happen if we inherit a method from a superclass for
1734          which we don't have a .class file.  */
1735       if (METHOD_DUMMY (method))
1736         continue;
1737
1738       /* Generate method reflection data if:
1739
1740           - !flag_reduced_reflection.
1741
1742           - <clinit> -- The runtime uses reflection to initialize the
1743             class.
1744
1745           - Any method in class java.lang.Class -- Class.forName() and
1746             perhaps other things require it.
1747
1748           - class$ -- It does not work if reflection data missing.
1749
1750           - main -- Reflection is used to find main(String[]) methods.
1751
1752           - public not static -- It is potentially part of an
1753             interface.  The runtime uses reflection data to build
1754             interface dispatch tables.  */
1755       if (!flag_reduced_reflection
1756           || DECL_CLINIT_P (method)
1757           || DECL_NAME (type_decl) == id_class
1758           || DECL_NAME (method) == id_main
1759           || (METHOD_PUBLIC (method) && !METHOD_STATIC (method))
1760           || TYPE_DOT_CLASS (type) == method)
1761         {
1762           init = make_method_value (method);
1763           method_count++;
1764           methods = tree_cons (NULL_TREE, init, methods);
1765         }
1766     }
1767   method_array_type = build_prim_array_type (method_type_node, method_count);
1768   methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
1769                              method_array_type);
1770   DECL_INITIAL (methods_decl) = build_constructor_from_list
1771                                  (method_array_type, nreverse (methods));
1772   TREE_STATIC (methods_decl) = 1;
1773   DECL_ARTIFICIAL (methods_decl) = 1;
1774   DECL_IGNORED_P (methods_decl) = 1;
1775   rest_of_decl_compilation (methods_decl, 1, 0);
1776
1777   if (class_dtable_decl == NULL_TREE)
1778     {
1779       class_dtable_decl = build_dtable_decl (class_type_node);
1780       TREE_STATIC (class_dtable_decl) = 1;
1781       DECL_ARTIFICIAL (class_dtable_decl) = 1;
1782       DECL_IGNORED_P (class_dtable_decl) = 1;
1783       if (is_compiled_class (class_type_node) != 2)
1784         DECL_EXTERNAL (class_dtable_decl) = 1;
1785       rest_of_decl_compilation (class_dtable_decl, 1, 0);
1786     }
1787
1788   super = CLASSTYPE_SUPER (type);
1789   if (super == NULL_TREE)
1790     super = null_pointer_node;
1791   else if (! flag_indirect_dispatch
1792            && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
1793            && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
1794     super = build_class_ref (super);
1795   else
1796     {
1797       int super_index = alloc_class_constant (super);
1798       super = build_int_cst (ptr_type_node, super_index);
1799     }
1800
1801   /* Build and emit the array of implemented interfaces. */
1802   if (type != object_type_node)
1803     interface_len = BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) - 1;
1804
1805   if (interface_len > 0)
1806     {
1807       tree init = NULL_TREE;
1808       int i;
1809       tree interface_array_type, idecl;
1810       interface_array_type
1811         = build_prim_array_type (class_ptr_type, interface_len);
1812       idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type),
1813                           interface_array_type);
1814
1815       for (i = interface_len;  i > 0; i--)
1816         {
1817           tree child = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
1818           tree iclass = BINFO_TYPE (child);
1819           tree index;
1820           if (! flag_indirect_dispatch
1821               && (assume_compiled
1822                   (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))))
1823             index = build_class_ref (iclass);
1824           else
1825             {
1826               int int_index = alloc_class_constant (iclass);
1827               index = build_int_cst (ptr_type_node, int_index);
1828             }
1829           init = tree_cons (NULL_TREE, index, init);
1830         }
1831       DECL_INITIAL (idecl) = build_constructor_from_list (interface_array_type,
1832                                                           init);
1833       TREE_STATIC (idecl) = 1;
1834       DECL_ARTIFICIAL (idecl) = 1;
1835       DECL_IGNORED_P (idecl) = 1;
1836       interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
1837       rest_of_decl_compilation (idecl, 1, 0);
1838     }
1839
1840   constant_pool_constructor = build_constants_constructor ();
1841
1842   if (flag_indirect_dispatch)
1843     {
1844       TYPE_OTABLE_DECL (type)
1845         = emit_symbol_table
1846         (DECL_NAME (TYPE_OTABLE_DECL (type)),
1847          TYPE_OTABLE_DECL (type), TYPE_OTABLE_METHODS (type),
1848          TYPE_OTABLE_SYMS_DECL (type), integer_type_node, 1);
1849
1850       TYPE_ATABLE_DECL (type)
1851         = emit_symbol_table
1852         (DECL_NAME (TYPE_ATABLE_DECL (type)),
1853          TYPE_ATABLE_DECL (type), TYPE_ATABLE_METHODS (type),
1854          TYPE_ATABLE_SYMS_DECL (type), ptr_type_node, 1);
1855
1856       TYPE_ITABLE_DECL (type)
1857         = emit_symbol_table
1858         (DECL_NAME (TYPE_ITABLE_DECL (type)),
1859          TYPE_ITABLE_DECL (type), TYPE_ITABLE_METHODS (type),
1860          TYPE_ITABLE_SYMS_DECL (type), ptr_type_node, 2);
1861     }
1862
1863   TYPE_CTABLE_DECL (type) = emit_catch_table (type);
1864
1865   START_RECORD_CONSTRUCTOR (temp, object_type_node);
1866   PUSH_FIELD_VALUE (temp, "vtable",
1867                     (flag_indirect_classes
1868                      ? null_pointer_node
1869                      : build2 (PLUS_EXPR, dtable_ptr_type,
1870                                build1 (ADDR_EXPR, dtable_ptr_type,
1871                                        class_dtable_decl),
1872                                dtable_start_offset)));
1873   if (! flag_hash_synchronization)
1874     PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
1875   FINISH_RECORD_CONSTRUCTOR (temp);
1876   START_RECORD_CONSTRUCTOR (cons, class_type_node);
1877   PUSH_SUPER_VALUE (cons, temp);
1878   PUSH_FIELD_VALUE (cons, "next_or_version", gcj_abi_version);
1879   PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
1880   PUSH_FIELD_VALUE (cons, "accflags",
1881                     build_int_cst (NULL_TREE,
1882                                    get_access_flags_from_decl (type_decl)));
1883
1884   PUSH_FIELD_VALUE (cons, "superclass",
1885                     CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
1886   PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
1887   PUSH_FIELD_VALUE (cons, "methods",
1888                     methods_decl == NULL_TREE ? null_pointer_node
1889                     : build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
1890   PUSH_FIELD_VALUE (cons, "method_count",
1891                     build_int_cst (NULL_TREE, method_count));
1892
1893   if (flag_indirect_dispatch)
1894     PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node);
1895   else
1896     PUSH_FIELD_VALUE (cons, "vtable_method_count", TYPE_NVIRTUALS (type));
1897
1898   PUSH_FIELD_VALUE (cons, "fields",
1899                     fields_decl == NULL_TREE ? null_pointer_node
1900                     : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
1901   /* If we're using the binary compatibility ABI we don't know the
1902      size until load time.  */
1903   PUSH_FIELD_VALUE (cons, "size_in_bytes",
1904                     (flag_indirect_dispatch
1905                      ? integer_minus_one_node
1906                      : size_in_bytes (type)));
1907   PUSH_FIELD_VALUE (cons, "field_count",
1908                     build_int_cst (NULL_TREE, field_count));
1909   PUSH_FIELD_VALUE (cons, "static_field_count",
1910                     build_int_cst (NULL_TREE, static_field_count));
1911
1912   if (flag_indirect_dispatch)
1913     PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node);
1914   else
1915     PUSH_FIELD_VALUE (cons, "vtable",
1916                       dtable_decl == NULL_TREE ? null_pointer_node
1917                       : build2 (PLUS_EXPR, dtable_ptr_type,
1918                                 build1 (ADDR_EXPR, dtable_ptr_type,
1919                                         dtable_decl),
1920                                 dtable_start_offset));
1921   if (TYPE_OTABLE_METHODS (type) == NULL_TREE)
1922     {
1923       PUSH_FIELD_VALUE (cons, "otable", null_pointer_node);
1924       PUSH_FIELD_VALUE (cons, "otable_syms", null_pointer_node);
1925     }
1926   else
1927     {
1928       pushdecl_top_level (TYPE_OTABLE_SYMS_DECL (type));
1929       PUSH_FIELD_VALUE (cons, "otable",
1930                         build1 (ADDR_EXPR, otable_ptr_type, TYPE_OTABLE_DECL (type)));
1931       PUSH_FIELD_VALUE (cons, "otable_syms",
1932                         build1 (ADDR_EXPR, symbols_array_ptr_type,
1933                                 TYPE_OTABLE_SYMS_DECL (type)));
1934       TREE_CONSTANT (TYPE_OTABLE_DECL (type)) = 1;
1935       TREE_INVARIANT (TYPE_OTABLE_DECL (type)) = 1;
1936     }
1937   if (TYPE_ATABLE_METHODS(type) == NULL_TREE)
1938     {
1939       PUSH_FIELD_VALUE (cons, "atable", null_pointer_node);
1940       PUSH_FIELD_VALUE (cons, "atable_syms", null_pointer_node);
1941     }
1942   else
1943     {
1944       pushdecl_top_level (TYPE_ATABLE_SYMS_DECL (type));
1945       PUSH_FIELD_VALUE (cons, "atable",
1946                         build1 (ADDR_EXPR, atable_ptr_type, TYPE_ATABLE_DECL (type)));
1947       PUSH_FIELD_VALUE (cons, "atable_syms",
1948                         build1 (ADDR_EXPR, symbols_array_ptr_type,
1949                                 TYPE_ATABLE_SYMS_DECL (type)));
1950       TREE_CONSTANT (TYPE_ATABLE_DECL (type)) = 1;
1951       TREE_INVARIANT (TYPE_ATABLE_DECL (type)) = 1;
1952     }
1953    if (TYPE_ITABLE_METHODS(type) == NULL_TREE)
1954     {
1955       PUSH_FIELD_VALUE (cons, "itable", null_pointer_node);
1956       PUSH_FIELD_VALUE (cons, "itable_syms", null_pointer_node);
1957     }
1958   else
1959     {
1960       pushdecl_top_level (TYPE_ITABLE_SYMS_DECL (type));
1961       PUSH_FIELD_VALUE (cons, "itable",
1962                         build1 (ADDR_EXPR, itable_ptr_type, TYPE_ITABLE_DECL (type)));
1963       PUSH_FIELD_VALUE (cons, "itable_syms",
1964                         build1 (ADDR_EXPR, symbols_array_ptr_type,
1965                                 TYPE_ITABLE_SYMS_DECL (type)));
1966       TREE_CONSTANT (TYPE_ITABLE_DECL (type)) = 1;
1967       TREE_INVARIANT (TYPE_ITABLE_DECL (type)) = 1;
1968     }
1969
1970   PUSH_FIELD_VALUE (cons, "catch_classes",
1971                     build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
1972   PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
1973   PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
1974   PUSH_FIELD_VALUE (cons, "interface_count",
1975                     build_int_cst (NULL_TREE, interface_len));
1976   PUSH_FIELD_VALUE (cons, "state",
1977                     convert (byte_type_node,
1978                              build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
1979
1980   PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
1981   PUSH_FIELD_VALUE (cons, "depth", integer_zero_node);
1982   PUSH_FIELD_VALUE (cons, "ancestors", null_pointer_node);
1983   PUSH_FIELD_VALUE (cons, "idt", null_pointer_node);
1984   PUSH_FIELD_VALUE (cons, "arrayclass", null_pointer_node);
1985   PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
1986
1987   {
1988     tree assertion_table_ref;
1989     if (TYPE_ASSERTIONS (type) == NULL)
1990       assertion_table_ref = null_pointer_node;
1991     else
1992       assertion_table_ref = build1 (ADDR_EXPR,
1993                                     build_pointer_type (assertion_table_type),
1994                                     emit_assertion_table (type));
1995
1996     PUSH_FIELD_VALUE (cons, "assertion_table", assertion_table_ref);
1997   }
1998
1999   PUSH_FIELD_VALUE (cons, "hack_signers", null_pointer_node);
2000   PUSH_FIELD_VALUE (cons, "chain", null_pointer_node);
2001   PUSH_FIELD_VALUE (cons, "aux_info", null_pointer_node);
2002   PUSH_FIELD_VALUE (cons, "engine", null_pointer_node);
2003
2004   FINISH_RECORD_CONSTRUCTOR (cons);
2005
2006   DECL_INITIAL (decl) = cons;
2007
2008   /* Hash synchronization requires at least 64-bit alignment. */
2009   if (flag_hash_synchronization && POINTER_SIZE < 64)
2010     DECL_ALIGN (decl) = 64;
2011
2012   if (flag_indirect_classes)
2013     {
2014       TREE_READONLY (decl) = 1;
2015       TREE_CONSTANT (DECL_INITIAL (decl)) = 1;
2016     }
2017
2018   rest_of_decl_compilation (decl, 1, 0);
2019
2020   {
2021     tree classdollar_field = build_classdollar_field (type);
2022     if (!flag_indirect_classes)
2023       DECL_INITIAL (classdollar_field) = build_static_class_ref (type);
2024     rest_of_decl_compilation (classdollar_field, 1, 0);
2025   }
2026
2027   TYPE_OTABLE_DECL (type) = NULL_TREE;
2028   TYPE_ATABLE_DECL (type) = NULL_TREE;
2029   TYPE_CTABLE_DECL (type) = NULL_TREE;
2030 }
2031
2032 void
2033 finish_class (void)
2034 {
2035   if (TYPE_VERIFY_METHOD (output_class))
2036     {
2037       tree verify_method = TYPE_VERIFY_METHOD (output_class);
2038       DECL_SAVED_TREE (verify_method)
2039         = add_stmt_to_compound (DECL_SAVED_TREE (verify_method), void_type_node,
2040                                 build1 (RETURN_EXPR, void_type_node, NULL));
2041       java_genericize (verify_method);
2042       cgraph_finalize_function (verify_method, false);
2043       TYPE_ASSERTIONS (current_class) = NULL;
2044     }
2045
2046   java_expand_catch_classes (current_class);
2047
2048   current_function_decl = NULL_TREE;
2049   TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class)) = 0;
2050   make_class_data (current_class);
2051   register_class ();
2052   rest_of_decl_compilation (TYPE_NAME (current_class), 1, 0);
2053 }
2054
2055 /* Return 2 if CLASS is compiled by this compilation job;
2056    return 1 if CLASS can otherwise be assumed to be compiled;
2057    return 0 if we cannot assume that CLASS is compiled.
2058    Returns 1 for primitive and 0 for array types.  */
2059 int
2060 is_compiled_class (tree class)
2061 {
2062   int seen_in_zip;
2063   if (TREE_CODE (class) == POINTER_TYPE)
2064     class = TREE_TYPE (class);
2065   if (TREE_CODE (class) != RECORD_TYPE)  /* Primitive types are static. */
2066     return 1;
2067   if (TYPE_ARRAY_P (class))
2068     return 0;
2069   if (class == current_class)
2070     return 2;
2071
2072   seen_in_zip = (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
2073   if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip)
2074     {
2075       /* The class was seen in the current ZIP file and will be
2076          available as a compiled class in the future but may not have
2077          been loaded already. Load it if necessary. This prevent
2078          build_class_ref () from crashing. */
2079
2080       if (seen_in_zip && !CLASS_LOADED_P (class))
2081         load_class (class, 1);
2082
2083       /* We return 2 for class seen in ZIP and class from files
2084          belonging to the same compilation unit */
2085       return 2;
2086     }
2087
2088   if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
2089     {
2090       if (!CLASS_LOADED_P (class))
2091         {
2092           if (CLASS_FROM_SOURCE_P (class))
2093             safe_layout_class (class);
2094           else
2095             load_class (class, 1);
2096         }
2097       return 1;
2098     }
2099
2100   return 0;
2101 }
2102
2103 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2104
2105 tree
2106 build_dtable_decl (tree type)
2107 {
2108   tree dtype, decl;
2109
2110   /* We need to build a new dtable type so that its size is uniquely
2111      computed when we're dealing with the class for real and not just
2112      faking it (like java.lang.Class during the initialization of the
2113      compiler.) We know we're not faking a class when CURRENT_CLASS is
2114      TYPE. */
2115   if (current_class == type)
2116     {
2117       tree dummy = NULL_TREE;
2118       int n;
2119
2120       dtype = make_node (RECORD_TYPE);
2121
2122       PUSH_FIELD (dtype, dummy, "top_offset", ptr_type_node);
2123       PUSH_FIELD (dtype, dummy, "type_info", ptr_type_node);
2124
2125       PUSH_FIELD (dtype, dummy, "class", class_ptr_type);
2126       for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2127         {
2128           tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2129           TREE_CHAIN (dummy) = tmp_field;
2130           DECL_CONTEXT (tmp_field) = dtype;
2131           DECL_ARTIFICIAL (tmp_field) = 1;
2132           dummy = tmp_field;
2133         }
2134
2135       PUSH_FIELD (dtype, dummy, "gc_descr", ptr_type_node);
2136       for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2137         {
2138           tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2139           TREE_CHAIN (dummy) = tmp_field;
2140           DECL_CONTEXT (tmp_field) = dtype;
2141           DECL_ARTIFICIAL (tmp_field) = 1;
2142           dummy = tmp_field;
2143         }
2144
2145       n = TREE_VEC_LENGTH (get_dispatch_vector (type));
2146       if (TARGET_VTABLE_USES_DESCRIPTORS)
2147         n *= TARGET_VTABLE_USES_DESCRIPTORS;
2148
2149       PUSH_FIELD (dtype, dummy, "methods",
2150                   build_prim_array_type (nativecode_ptr_type_node, n));
2151       layout_type (dtype);
2152     }
2153   else
2154     dtype = dtable_type;
2155
2156   decl = build_decl (VAR_DECL, get_identifier ("vt$"), dtype);
2157   DECL_CONTEXT (decl) = type;
2158   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2159   DECL_VTABLE_P (decl) = 1;
2160
2161   return decl;
2162 }
2163
2164 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2165    fields inherited from SUPER_CLASS. */
2166
2167 void
2168 push_super_field (tree this_class, tree super_class)
2169 {
2170   tree base_decl;
2171   /* Don't insert the field if we're just re-laying the class out. */
2172   if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
2173     return;
2174   base_decl = build_decl (FIELD_DECL, NULL_TREE, super_class);
2175   DECL_IGNORED_P (base_decl) = 1;
2176   TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
2177   TYPE_FIELDS (this_class) = base_decl;
2178   DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
2179   DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
2180 }
2181
2182 /* Handle the different manners we may have to lay out a super class.  */
2183
2184 static tree
2185 maybe_layout_super_class (tree super_class, tree this_class)
2186 {
2187   if (!super_class)
2188     return NULL_TREE;
2189   else if (TREE_CODE (super_class) == RECORD_TYPE)
2190     {
2191       if (!CLASS_LOADED_P (super_class) && CLASS_FROM_SOURCE_P (super_class))
2192         safe_layout_class (super_class);
2193       if (!CLASS_LOADED_P (super_class))
2194         load_class (super_class, 1);
2195     }
2196   /* We might have to layout the class before its dependency on
2197      the super class gets resolved by java_complete_class  */
2198   else if (TREE_CODE (super_class) == POINTER_TYPE)
2199     {
2200       if (TREE_TYPE (super_class) != NULL_TREE)
2201         super_class = TREE_TYPE (super_class);
2202       else
2203         {
2204           /* do_resolve_class expects an EXPR_WITH_FILE_LOCATION, so
2205              we give it one.  */
2206           tree this_wrap = NULL_TREE;
2207
2208           /* Set the correct context for class resolution.  */
2209           current_class = this_class;
2210
2211           if (this_class)
2212             {
2213               tree this_decl = TYPE_NAME (this_class);
2214 #ifdef USE_MAPPED_LOCATION
2215               this_wrap = build_expr_wfl (this_class,
2216                                           DECL_SOURCE_LOCATION (this_decl));
2217 #else
2218               this_wrap = build_expr_wfl (this_class,
2219                                           DECL_SOURCE_FILE (this_decl),
2220                                           DECL_SOURCE_LINE (this_decl), 0);
2221 #endif
2222             }
2223           super_class
2224             = do_resolve_class (DECL_CONTEXT (TYPE_NAME (this_class)),
2225                                 this_class, super_class, NULL_TREE, this_wrap);
2226           if (!super_class)
2227             return NULL_TREE;   /* FIXME, NULL_TREE not checked by caller. */
2228           super_class = TREE_TYPE (super_class);
2229         }
2230     }
2231   if (!TYPE_SIZE (super_class))
2232     safe_layout_class (super_class);
2233
2234   return super_class;
2235 }
2236
2237 void
2238 layout_class (tree this_class)
2239 {
2240   tree super_class = CLASSTYPE_SUPER (this_class);
2241
2242   class_list = tree_cons (this_class, NULL_TREE, class_list);
2243   if (CLASS_BEING_LAIDOUT (this_class))
2244     {
2245       char buffer [1024];
2246       char *report;
2247       tree current;
2248
2249       sprintf (buffer, " with '%s'",
2250                IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
2251       obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2252
2253       for (current = TREE_CHAIN (class_list); current;
2254            current = TREE_CHAIN (current))
2255         {
2256           tree decl = TYPE_NAME (TREE_PURPOSE (current));
2257           sprintf (buffer, "\n  which inherits from '%s' (%s:%d)",
2258                    IDENTIFIER_POINTER (DECL_NAME (decl)),
2259                    DECL_SOURCE_FILE (decl),
2260                    DECL_SOURCE_LINE (decl));
2261           obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2262         }
2263       obstack_1grow (&temporary_obstack, '\0');
2264       report = obstack_finish (&temporary_obstack);
2265       cyclic_inheritance_report = ggc_strdup (report);
2266       obstack_free (&temporary_obstack, report);
2267       TYPE_SIZE (this_class) = error_mark_node;
2268       return;
2269     }
2270   CLASS_BEING_LAIDOUT (this_class) = 1;
2271
2272   if (super_class && !CLASS_BEING_LAIDOUT (super_class))
2273     {
2274       tree maybe_super_class
2275         = maybe_layout_super_class (super_class, this_class);
2276       if (maybe_super_class == NULL
2277           || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
2278         {
2279           TYPE_SIZE (this_class) = error_mark_node;
2280           CLASS_BEING_LAIDOUT (this_class) = 0;
2281           class_list = TREE_CHAIN (class_list);
2282           return;
2283         }
2284       if (TYPE_SIZE (this_class) == NULL_TREE)
2285         push_super_field (this_class, maybe_super_class);
2286     }
2287
2288   layout_type (this_class);
2289
2290   /* Also recursively load/layout any superinterfaces, but only if
2291      class was loaded from bytecode.  The source parser will take care
2292      of this itself.  */
2293   if (!CLASS_FROM_SOURCE_P (this_class))
2294     {
2295       int i;
2296             if (TYPE_BINFO (this_class))
2297         {
2298           for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class)) - 1; i > 0; i--)
2299             {
2300               tree binfo = BINFO_BASE_BINFO (TYPE_BINFO (this_class), i);
2301               tree super_interface = BINFO_TYPE (binfo);
2302               tree maybe_super_interface
2303                 = maybe_layout_super_class (super_interface, NULL_TREE);
2304               if (maybe_super_interface == NULL
2305                   || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
2306                 {
2307                   TYPE_SIZE (this_class) = error_mark_node;
2308                   CLASS_BEING_LAIDOUT (this_class) = 0;
2309                   class_list = TREE_CHAIN (class_list);
2310                   return;
2311                 }
2312             }
2313         }
2314     }
2315
2316   /* Convert the size back to an SI integer value.  */
2317   TYPE_SIZE_UNIT (this_class) =
2318     fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
2319
2320   CLASS_BEING_LAIDOUT (this_class) = 0;
2321   class_list = TREE_CHAIN (class_list);
2322 }
2323
2324 static void
2325 add_miranda_methods (tree base_class, tree search_class)
2326 {
2327   int i;
2328   tree binfo, base_binfo;
2329
2330   if (!CLASS_PARSED_P (search_class))
2331     load_class (search_class, 1);
2332
2333   for (binfo = TYPE_BINFO (search_class), i = 1;
2334        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2335     {
2336       tree method_decl;
2337       tree elt = BINFO_TYPE (base_binfo);
2338
2339       /* FIXME: This is totally bogus.  We should not be handling
2340          Miranda methods at all if we're using the BC ABI.  */
2341       if (TYPE_DUMMY (elt))
2342         continue;
2343
2344       /* Ensure that interface methods are seen in declared order.  */
2345       if (!CLASS_LOADED_P (elt))
2346         load_class (elt, 1);
2347       layout_class_methods (elt);
2348
2349       /* All base classes will have been laid out at this point, so the order
2350          will be correct.  This code must match similar layout code in the
2351          runtime.  */
2352       for (method_decl = TYPE_METHODS (elt);
2353            method_decl; method_decl = TREE_CHAIN (method_decl))
2354         {
2355           tree sig, override;
2356
2357           /* An interface can have <clinit>.  */
2358           if (ID_CLINIT_P (DECL_NAME (method_decl)))
2359             continue;
2360
2361           sig = build_java_argument_signature (TREE_TYPE (method_decl));
2362           override = lookup_argument_method (base_class,
2363                                              DECL_NAME (method_decl), sig);
2364           if (override == NULL_TREE)
2365             {
2366               /* Found a Miranda method.  Add it.  */
2367               tree new_method;
2368               sig = build_java_signature (TREE_TYPE (method_decl));
2369               new_method
2370                 = add_method (base_class,
2371                               get_access_flags_from_decl (method_decl),
2372                               DECL_NAME (method_decl), sig);
2373               METHOD_INVISIBLE (new_method) = 1;
2374             }
2375         }
2376
2377       /* Try superinterfaces.  */
2378       add_miranda_methods (base_class, elt);
2379     }
2380 }
2381
2382 void
2383 layout_class_methods (tree this_class)
2384 {
2385   tree method_decl, dtable_count;
2386   tree super_class, type_name;
2387
2388   if (TYPE_NVIRTUALS (this_class))
2389     return;
2390
2391   super_class = CLASSTYPE_SUPER (this_class);
2392
2393   if (super_class)
2394     {
2395       super_class = maybe_layout_super_class (super_class, this_class);
2396       if (!TYPE_NVIRTUALS (super_class))
2397         layout_class_methods (super_class);
2398       dtable_count = TYPE_NVIRTUALS (super_class);
2399     }
2400   else
2401     dtable_count = integer_zero_node;
2402
2403   type_name = TYPE_NAME (this_class);
2404   if (!flag_indirect_dispatch
2405       && (CLASS_ABSTRACT (type_name) || CLASS_INTERFACE (type_name)))
2406     {
2407       /* An abstract class can have methods which are declared only in
2408          an implemented interface.  These are called "Miranda
2409          methods".  We make a dummy method entry for such methods
2410          here.  */
2411       add_miranda_methods (this_class, this_class);
2412     }
2413
2414   TYPE_METHODS (this_class) = nreverse (TYPE_METHODS (this_class));
2415
2416   for (method_decl = TYPE_METHODS (this_class);
2417        method_decl; method_decl = TREE_CHAIN (method_decl))
2418     dtable_count = layout_class_method (this_class, super_class,
2419                                         method_decl, dtable_count);
2420
2421   TYPE_NVIRTUALS (this_class) = dtable_count;
2422 }
2423
2424 /* Return the index of METHOD in INTERFACE.  This index begins at 1
2425    and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2426 int
2427 get_interface_method_index (tree method, tree interface)
2428 {
2429   tree meth;
2430   int i = 1;
2431
2432   for (meth = TYPE_METHODS (interface); ; meth = TREE_CHAIN (meth))
2433     {
2434       if (meth == method)
2435         return i;
2436       /* We don't want to put <clinit> into the interface table.  */
2437       if (! ID_CLINIT_P (DECL_NAME (meth)))
2438         ++i;
2439       gcc_assert (meth != NULL_TREE);
2440     }
2441 }
2442
2443 /* Lay METHOD_DECL out, returning a possibly new value of
2444    DTABLE_COUNT. Also mangle the method's name. */
2445
2446 tree
2447 layout_class_method (tree this_class, tree super_class,
2448                      tree method_decl, tree dtable_count)
2449 {
2450   tree method_name = DECL_NAME (method_decl);
2451
2452   TREE_PUBLIC (method_decl) = 1;
2453   /* Considered external until we know what classes are being
2454      compiled into this object file.  */
2455   DECL_EXTERNAL (method_decl) = 1;
2456
2457   if (ID_INIT_P (method_name))
2458     {
2459       const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
2460       const char *ptr;
2461       for (ptr = p; *ptr; )
2462         {
2463           if (*ptr++ == '.')
2464             p = ptr;
2465         }
2466       DECL_CONSTRUCTOR_P (method_decl) = 1;
2467       build_java_argument_signature (TREE_TYPE (method_decl));
2468     }
2469   else if (! METHOD_STATIC (method_decl))
2470     {
2471       tree method_sig =
2472         build_java_argument_signature (TREE_TYPE (method_decl));
2473       bool method_override = false;
2474       tree super_method = lookup_argument_method (super_class, method_name,
2475                                                   method_sig);
2476       if (super_method != NULL_TREE
2477           && ! METHOD_DUMMY (super_method))
2478         {
2479           method_override = true;
2480           if (! METHOD_PUBLIC (super_method) &&
2481               ! METHOD_PROTECTED (super_method))
2482             {
2483               /* Don't override private method, or default-access method in
2484                  another package.  */
2485               if (METHOD_PRIVATE (super_method) ||
2486                   ! in_same_package (TYPE_NAME (this_class),
2487                                      TYPE_NAME (super_class)))
2488                 method_override = false;
2489            }
2490         }
2491       if (method_override)
2492         {
2493           tree method_index = get_method_index (super_method);
2494           set_method_index (method_decl, method_index);
2495           if (method_index == NULL_TREE
2496               && ! flag_indirect_dispatch
2497               && !CLASS_FROM_SOURCE_P (this_class)
2498               && ! DECL_ARTIFICIAL (super_method))
2499             error ("non-static method %q+D overrides static method",
2500                    method_decl);
2501         }
2502       else if (this_class == object_type_node
2503                && (METHOD_FINAL (method_decl)
2504                    || METHOD_PRIVATE (method_decl)))
2505         {
2506           /* We don't generate vtable entries for final Object
2507              methods.  This is simply to save space, since every
2508              object would otherwise have to define them.  */
2509         }
2510       else if (! METHOD_PRIVATE (method_decl)
2511                && dtable_count)
2512         {
2513           /* We generate vtable entries for final methods because they
2514              may one day be changed to non-final.  */
2515           set_method_index (method_decl, dtable_count);
2516           dtable_count = fold_build2 (PLUS_EXPR, integer_type_node,
2517                                       dtable_count, integer_one_node);
2518         }
2519     }
2520
2521   return dtable_count;
2522 }
2523
2524 static void
2525 register_class (void)
2526 {
2527   tree node;
2528
2529   if (!registered_class)
2530     registered_class = VEC_alloc (tree, gc, 8);
2531
2532   if (flag_indirect_classes)
2533     node = current_class;
2534   else
2535     node = TREE_OPERAND (build_class_ref (current_class), 0);
2536   VEC_safe_push (tree, gc, registered_class, node);
2537 }
2538
2539 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2540    all the classes we have emitted.  */
2541
2542 static void
2543 emit_indirect_register_classes (tree *list_p)
2544 {
2545   tree klass, t, register_class_fn;
2546   int i;
2547
2548   tree init = NULL_TREE;
2549   int size = VEC_length (tree, registered_class) * 2 + 1;
2550   tree class_array_type
2551     = build_prim_array_type (ptr_type_node, size);
2552   tree cdecl = build_decl (VAR_DECL, get_identifier ("_Jv_CLS"),
2553                            class_array_type);
2554   tree reg_class_list;
2555   for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2556     {
2557       init = tree_cons (NULL_TREE,
2558                         fold_convert (ptr_type_node,
2559                                       build_static_class_ref (klass)), init);
2560       init = tree_cons
2561         (NULL_TREE,
2562          fold_convert (ptr_type_node,
2563                        build_address_of (build_classdollar_field (klass))),
2564          init);
2565     }
2566   init = tree_cons (NULL_TREE, integer_zero_node, init);
2567   DECL_INITIAL (cdecl) = build_constructor_from_list (class_array_type,
2568                                                       nreverse (init));
2569   TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2570   TREE_STATIC (cdecl) = 1;
2571   DECL_ARTIFICIAL (cdecl) = 1;
2572   DECL_IGNORED_P (cdecl) = 1;
2573   TREE_READONLY (cdecl) = 1;
2574   TREE_CONSTANT (cdecl) = 1;
2575   rest_of_decl_compilation (cdecl, 1, 0);
2576   reg_class_list = fold_convert (ptr_type_node, build_address_of (cdecl));
2577
2578   t = build_function_type_list (void_type_node,
2579                                 build_pointer_type (ptr_type_node), NULL);
2580   t = build_decl (FUNCTION_DECL,
2581                   get_identifier ("_Jv_RegisterNewClasses"), t);
2582   TREE_PUBLIC (t) = 1;
2583   DECL_EXTERNAL (t) = 1;
2584   register_class_fn = t;
2585   t = tree_cons (NULL, reg_class_list, NULL);
2586   t = build_function_call_expr (register_class_fn, t);
2587   append_to_statement_list (t, list_p);
2588 }
2589
2590
2591 /* Emit something to register classes at start-up time.
2592
2593    The preferred mechanism is through the .jcr section, which contain
2594    a list of pointers to classes which get registered during constructor
2595    invocation time.
2596
2597    The fallback mechanism is to add statements to *LIST_P to call
2598    _Jv_RegisterClass for each class in this file.  These statements will
2599    be added to a static constructor function for this translation unit.  */
2600
2601 void
2602 emit_register_classes (tree *list_p)
2603 {
2604   if (registered_class == NULL)
2605     return;
2606
2607   if (flag_indirect_classes)
2608     {
2609       emit_indirect_register_classes (list_p);
2610       return;
2611     }
2612
2613   /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2614      TARGET_ASM_NAMED_SECTION, else 0.  Some targets meet those conditions
2615      but lack suitable crtbegin/end objects or linker support.  These
2616      targets can override the default in tm.h to use the fallback mechanism.  */
2617   if (TARGET_USE_JCR_SECTION)
2618     {
2619       tree klass, t;
2620       int i;
2621
2622 #ifdef JCR_SECTION_NAME
2623       switch_to_section (get_section (JCR_SECTION_NAME, SECTION_WRITE, NULL));
2624 #else
2625       /* A target has defined TARGET_USE_JCR_SECTION,
2626          but doesn't have a JCR_SECTION_NAME.  */
2627       gcc_unreachable ();
2628 #endif
2629       assemble_align (POINTER_SIZE);
2630
2631       for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2632         {
2633           t = build_fold_addr_expr (klass);
2634           output_constant (t, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE);
2635         }
2636     }
2637   else
2638     {
2639       tree klass, t, register_class_fn;
2640       int i;
2641
2642       t = build_function_type_list (void_type_node, class_ptr_type, NULL);
2643       t = build_decl (FUNCTION_DECL, get_identifier ("_Jv_RegisterClass"), t);
2644       TREE_PUBLIC (t) = 1;
2645       DECL_EXTERNAL (t) = 1;
2646       register_class_fn = t;
2647
2648       for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2649         {
2650           t = build_fold_addr_expr (klass);
2651           t = tree_cons (NULL, t, NULL);
2652           t = build_function_call_expr (register_class_fn, t);
2653           append_to_statement_list (t, list_p);
2654         }
2655     }
2656 }
2657
2658 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2659
2660 static tree
2661 build_symbol_entry (tree decl, tree special)
2662 {
2663   tree clname, name, signature, sym;
2664   clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
2665   /* ???  Constructors are given the name foo.foo all the way through
2666      the compiler, but in the method table they're all renamed
2667      foo.<init>.  So, we have to do the same here unless we want an
2668      unresolved reference at runtime.  */
2669   name = build_utf8_ref ((TREE_CODE (decl) == FUNCTION_DECL
2670                           && DECL_CONSTRUCTOR_P (decl))
2671                          ? init_identifier_node
2672                          : DECL_NAME (decl));
2673   signature = build_java_signature (TREE_TYPE (decl));
2674   signature = build_utf8_ref (unmangle_classname
2675                               (IDENTIFIER_POINTER (signature),
2676                                IDENTIFIER_LENGTH (signature)));
2677   /* SPECIAL is either NULL_TREE or integer_one_node.  We emit
2678      signature addr+1 if SPECIAL, and this indicates to the runtime
2679      system that this is a "special" symbol, i.e. one that should
2680      bypass access controls.  */
2681   if (special != NULL_TREE)
2682     signature = build2 (PLUS_EXPR, TREE_TYPE (signature), signature, special);
2683
2684   START_RECORD_CONSTRUCTOR (sym, symbol_type);
2685   PUSH_FIELD_VALUE (sym, "clname", clname);
2686   PUSH_FIELD_VALUE (sym, "name", name);
2687   PUSH_FIELD_VALUE (sym, "signature", signature);
2688   FINISH_RECORD_CONSTRUCTOR (sym);
2689   TREE_CONSTANT (sym) = 1;
2690   TREE_INVARIANT (sym) = 1;
2691
2692   return sym;
2693 }
2694
2695 /* Emit a symbol table: used by -findirect-dispatch.  */
2696
2697 tree
2698 emit_symbol_table (tree name, tree the_table, tree decl_list,
2699                    tree the_syms_decl, tree the_array_element_type,
2700                    int element_size)
2701 {
2702   tree method_list, method, table, list, null_symbol;
2703   tree table_size, the_array_type;
2704   int index;
2705
2706   /* Only emit a table if this translation unit actually made any
2707      references via it. */
2708   if (decl_list == NULL_TREE)
2709     return the_table;
2710
2711   /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2712   index = 0;
2713   method_list = decl_list;
2714   list = NULL_TREE;
2715   while (method_list != NULL_TREE)
2716     {
2717       tree special = TREE_PURPOSE (method_list);
2718       method = TREE_VALUE (method_list);
2719       list = tree_cons (NULL_TREE, build_symbol_entry (method, special), list);
2720       method_list = TREE_CHAIN (method_list);
2721       index++;
2722     }
2723
2724   /* Terminate the list with a "null" entry. */
2725   START_RECORD_CONSTRUCTOR (null_symbol, symbol_type);
2726   PUSH_FIELD_VALUE (null_symbol, "clname", null_pointer_node);
2727   PUSH_FIELD_VALUE (null_symbol, "name", null_pointer_node);
2728   PUSH_FIELD_VALUE (null_symbol, "signature", null_pointer_node);
2729   FINISH_RECORD_CONSTRUCTOR (null_symbol);
2730   TREE_CONSTANT (null_symbol) = 1;
2731   TREE_INVARIANT (null_symbol) = 1;
2732   list = tree_cons (NULL_TREE, null_symbol, list);
2733
2734   /* Put the list in the right order and make it a constructor. */
2735   list = nreverse (list);
2736   table = build_constructor_from_list (symbols_array_type, list);
2737
2738   /* Make it the initial value for otable_syms and emit the decl. */
2739   DECL_INITIAL (the_syms_decl) = table;
2740   DECL_ARTIFICIAL (the_syms_decl) = 1;
2741   DECL_IGNORED_P (the_syms_decl) = 1;
2742   rest_of_decl_compilation (the_syms_decl, 1, 0);
2743
2744   /* Now that its size is known, redefine the table as an
2745      uninitialized static array of INDEX + 1 elements. The extra entry
2746      is used by the runtime to track whether the table has been
2747      initialized. */
2748   table_size
2749     = build_index_type (build_int_cst (NULL_TREE, index * element_size + 1));
2750   the_array_type = build_array_type (the_array_element_type, table_size);
2751   the_table = build_decl (VAR_DECL, name, the_array_type);
2752   TREE_STATIC (the_table) = 1;
2753   TREE_READONLY (the_table) = 1;
2754   rest_of_decl_compilation (the_table, 1, 0);
2755
2756   return the_table;
2757 }
2758
2759 /* Make an entry for the catch_classes list.  */
2760 tree
2761 make_catch_class_record (tree catch_class, tree classname)
2762 {
2763   tree entry;
2764   tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
2765   START_RECORD_CONSTRUCTOR (entry, type);
2766   PUSH_FIELD_VALUE (entry, "address", catch_class);
2767   PUSH_FIELD_VALUE (entry, "classname", classname);
2768   FINISH_RECORD_CONSTRUCTOR (entry);
2769   return entry;
2770 }
2771
2772
2773 /* Generate the list of Throwable classes that are caught by exception
2774    handlers in this class.  */
2775 tree
2776 emit_catch_table (tree this_class)
2777 {
2778   tree table, table_size, array_type;
2779   TYPE_CATCH_CLASSES (this_class) =
2780     tree_cons (NULL,
2781                make_catch_class_record (null_pointer_node, null_pointer_node),
2782                TYPE_CATCH_CLASSES (this_class));
2783   TYPE_CATCH_CLASSES (this_class) = nreverse (TYPE_CATCH_CLASSES (this_class));
2784   TYPE_CATCH_CLASSES (this_class) =
2785     tree_cons (NULL,
2786                make_catch_class_record (null_pointer_node, null_pointer_node),
2787                TYPE_CATCH_CLASSES (this_class));
2788   table_size = build_index_type
2789     (build_int_cst (NULL_TREE,
2790                     list_length (TYPE_CATCH_CLASSES (this_class))));
2791   array_type
2792     = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
2793                         table_size);
2794   table =
2795     build_decl (VAR_DECL, DECL_NAME (TYPE_CTABLE_DECL (this_class)), array_type);
2796   DECL_INITIAL (table) =
2797     build_constructor_from_list (array_type, TYPE_CATCH_CLASSES (this_class));
2798   TREE_STATIC (table) = 1;
2799   TREE_READONLY (table) = 1;
2800   DECL_IGNORED_P (table) = 1;
2801   rest_of_decl_compilation (table, 1, 0);
2802   return table;
2803 }
2804
2805 /* Given a type, return the signature used by
2806    _Jv_FindClassFromSignature() in libgcj.  This isn't exactly the
2807    same as build_java_signature() because we want the canonical array
2808    type.  */
2809
2810 static tree
2811 build_signature_for_libgcj (tree type)
2812 {
2813   tree sig, ref;
2814
2815   sig = build_java_signature (type);
2816   ref = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
2817                                             IDENTIFIER_LENGTH (sig)));
2818   return ref;
2819 }
2820
2821 /* Add an entry to the type assertion table. Callback used during hashtable
2822    traversal.  */
2823
2824 static int
2825 add_assertion_table_entry (void **htab_entry, void *ptr)
2826 {
2827   tree entry;
2828   tree code_val, op1_utf8, op2_utf8;
2829   tree *list = (tree *) ptr;
2830   type_assertion *as = (type_assertion *) *htab_entry;
2831
2832   code_val = build_int_cst (NULL_TREE, as->assertion_code);
2833
2834   if (as->op1 == NULL_TREE)
2835     op1_utf8 = null_pointer_node;
2836   else
2837     op1_utf8 = build_signature_for_libgcj (as->op1);
2838
2839   if (as->op2 == NULL_TREE)
2840     op2_utf8 = null_pointer_node;
2841   else
2842     op2_utf8 = build_signature_for_libgcj (as->op2);
2843
2844   START_RECORD_CONSTRUCTOR (entry, assertion_entry_type);
2845   PUSH_FIELD_VALUE (entry, "assertion_code", code_val);
2846   PUSH_FIELD_VALUE (entry, "op1", op1_utf8);
2847   PUSH_FIELD_VALUE (entry, "op2", op2_utf8);
2848   FINISH_RECORD_CONSTRUCTOR (entry);
2849
2850   *list = tree_cons (NULL_TREE, entry, *list);
2851   return true;
2852 }
2853
2854 /* Generate the type assertion table for CLASS, and return its DECL.  */
2855
2856 static tree
2857 emit_assertion_table (tree class)
2858 {
2859   tree null_entry, ctor, table_decl;
2860   tree list = NULL_TREE;
2861   htab_t assertions_htab = TYPE_ASSERTIONS (class);
2862
2863   /* Iterate through the hash table.  */
2864   htab_traverse (assertions_htab, add_assertion_table_entry, &list);
2865
2866   /* Finish with a null entry.  */
2867   START_RECORD_CONSTRUCTOR (null_entry, assertion_entry_type);
2868   PUSH_FIELD_VALUE (null_entry, "assertion_code", integer_zero_node);
2869   PUSH_FIELD_VALUE (null_entry, "op1", null_pointer_node);
2870   PUSH_FIELD_VALUE (null_entry, "op2", null_pointer_node);
2871   FINISH_RECORD_CONSTRUCTOR (null_entry);
2872
2873   list = tree_cons (NULL_TREE, null_entry, list);
2874
2875   /* Put the list in the right order and make it a constructor. */
2876   list = nreverse (list);
2877   ctor = build_constructor_from_list (assertion_table_type, list);
2878
2879   table_decl = build_decl (VAR_DECL, mangled_classname ("_type_assert_", class),
2880                            assertion_table_type);
2881
2882   TREE_STATIC (table_decl) = 1;
2883   TREE_READONLY (table_decl) = 1;
2884   TREE_CONSTANT (table_decl) = 1;
2885   DECL_IGNORED_P (table_decl) = 1;
2886
2887   DECL_INITIAL (table_decl) = ctor;
2888   DECL_ARTIFICIAL (table_decl) = 1;
2889   rest_of_decl_compilation (table_decl, 1, 0);
2890
2891   return table_decl;
2892 }
2893
2894 void
2895 init_class_processing (void)
2896 {
2897   fields_ident = get_identifier ("fields");
2898   info_ident = get_identifier ("info");
2899
2900   gcc_obstack_init (&temporary_obstack);
2901 }
2902 \f
2903 static hashval_t java_treetreehash_hash (const void *);
2904 static int java_treetreehash_compare (const void *, const void *);
2905
2906 /* A hash table mapping trees to trees.  Used generally.  */
2907
2908 #define JAVA_TREEHASHHASH_H(t) (htab_hash_pointer (t))
2909
2910 static hashval_t
2911 java_treetreehash_hash (const void *k_p)
2912 {
2913   struct treetreehash_entry *k = (struct treetreehash_entry *) k_p;
2914   return JAVA_TREEHASHHASH_H (k->key);
2915 }
2916
2917 static int
2918 java_treetreehash_compare (const void * k1_p, const void * k2_p)
2919 {
2920   struct treetreehash_entry * k1 = (struct treetreehash_entry *) k1_p;
2921   tree k2 = (tree) k2_p;
2922   return (k1->key == k2);
2923 }
2924
2925 tree
2926 java_treetreehash_find (htab_t ht, tree t)
2927 {
2928   struct treetreehash_entry *e;
2929   hashval_t hv = JAVA_TREEHASHHASH_H (t);
2930   e = htab_find_with_hash (ht, t, hv);
2931   if (e == NULL)
2932     return NULL;
2933   else
2934     return e->value;
2935 }
2936
2937 tree *
2938 java_treetreehash_new (htab_t ht, tree t)
2939 {
2940   void **e;
2941   struct treetreehash_entry *tthe;
2942   hashval_t hv = JAVA_TREEHASHHASH_H (t);
2943
2944   e = htab_find_slot_with_hash (ht, t, hv, INSERT);
2945   if (*e == NULL)
2946     {
2947       tthe = (*ht->alloc_f) (1, sizeof (*tthe));
2948       tthe->key = t;
2949       *e = tthe;
2950     }
2951   else
2952     tthe = (struct treetreehash_entry *) *e;
2953   return &tthe->value;
2954 }
2955
2956 htab_t
2957 java_treetreehash_create (size_t size, int gc)
2958 {
2959   if (gc)
2960     return htab_create_ggc (size, java_treetreehash_hash,
2961                             java_treetreehash_compare, NULL);
2962   else
2963     return htab_create_alloc (size, java_treetreehash_hash,
2964                               java_treetreehash_compare, free, xcalloc, free);
2965 }
2966
2967 /* Break down qualified IDENTIFIER into package and class-name components.
2968    For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
2969    "pkg.foo", and RIGHT to "Bar". */
2970
2971 int
2972 split_qualified_name (tree *left, tree *right, tree source)
2973 {
2974   char *p, *base;
2975   int l = IDENTIFIER_LENGTH (source);
2976
2977   base = alloca (l + 1);
2978   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
2979
2980   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
2981   p = base + l - 1;
2982   while (*p != '.' && p != base)
2983     p--;
2984
2985   /* We didn't find a '.'. Return an error.  */
2986   if (p == base)
2987     return 1;
2988
2989   *p = '\0';
2990   if (right)
2991     *right = get_identifier (p+1);
2992   *left = get_identifier (base);
2993
2994   return 0;
2995 }
2996
2997 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
2998    if the classes are from the same package. */
2999
3000 int
3001 in_same_package (tree name1, tree name2)
3002 {
3003   tree tmp;
3004   tree pkg1;
3005   tree pkg2;
3006
3007   if (TREE_CODE (name1) == TYPE_DECL)
3008     name1 = DECL_NAME (name1);
3009   if (TREE_CODE (name2) == TYPE_DECL)
3010     name2 = DECL_NAME (name2);
3011
3012   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
3013     /* One in empty package. */
3014     return 0;
3015
3016   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
3017     /* Both in empty package. */
3018     return 1;
3019
3020   split_qualified_name (&pkg1, &tmp, name1);
3021   split_qualified_name (&pkg2, &tmp, name2);
3022
3023   return (pkg1 == pkg2);
3024 }
3025
3026 #include "gt-java-class.h"