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