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