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 (ix = 0;
1548              VEC_iterate (tree, DECL_FUNCTION_THROWS (mdecl), ix, t);
1549              ix++)
1550           {
1551             tree sig = DECL_NAME (TYPE_NAME (t));
1552             tree utf8
1553               = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
1554                                                     IDENTIFIER_LENGTH (sig)));
1555             e = VEC_index (constructor_elt, v, idx--);
1556             e->value = utf8;
1557           }
1558         gcc_assert (idx == -1);
1559         type = build_prim_array_type (ptr_type_node, length);
1560         table = build_constructor (type, v);
1561         /* Compute something unique enough.  */
1562         sprintf (buf, "_methods%d", method_name_count++);
1563         array = build_decl (input_location,
1564                             VAR_DECL, get_identifier (buf), type);
1565         DECL_INITIAL (array) = table;
1566         TREE_STATIC (array) = 1;
1567         DECL_ARTIFICIAL (array) = 1;
1568         DECL_IGNORED_P (array) = 1;
1569         rest_of_decl_compilation (array, 1, 0);
1570
1571         table = build1 (ADDR_EXPR, ptr_type_node, array);
1572       }
1573
1574     PUSH_FIELD_VALUE (v, "throws", table);
1575   }
1576
1577   FINISH_RECORD_CONSTRUCTOR (minit, v, method_type_node);
1578   return minit;
1579 }
1580
1581 static tree
1582 get_dispatch_vector (tree type)
1583 {
1584   tree vtable = TYPE_VTABLE (type);
1585
1586   if (vtable == NULL_TREE)
1587     {
1588       HOST_WIDE_INT i;
1589       tree method;
1590       tree super = CLASSTYPE_SUPER (type);
1591       HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1592       vtable = make_tree_vec (nvirtuals);
1593       TYPE_VTABLE (type) = vtable;
1594       if (super != NULL_TREE)
1595         {
1596           tree super_vtable = get_dispatch_vector (super);
1597
1598           for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1599             TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1600         }
1601
1602       for (method = TYPE_METHODS (type);  method != NULL_TREE;
1603            method = DECL_CHAIN (method))
1604         {
1605           tree method_index = get_method_index (method);
1606           if (method_index != NULL_TREE
1607               && host_integerp (method_index, 0))
1608             TREE_VEC_ELT (vtable, tree_low_cst (method_index, 0)) = method;
1609         }
1610     }
1611
1612   return vtable;
1613 }
1614
1615 static tree
1616 get_dispatch_table (tree type, tree this_class_addr)
1617 {
1618   int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1619   tree vtable = get_dispatch_vector (type);
1620   int i, j;
1621   int nvirtuals = TREE_VEC_LENGTH (vtable);
1622   int arraysize;
1623   tree gc_descr;
1624   VEC(constructor_elt,gc) *v = NULL;
1625   constructor_elt *e;
1626   tree arraytype;
1627
1628   arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
1629   if (TARGET_VTABLE_USES_DESCRIPTORS)
1630     arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
1631   arraysize += 2;
1632
1633   VEC_safe_grow_cleared (constructor_elt, gc, v, arraysize);
1634   e = VEC_index (constructor_elt, v, arraysize - 1);
1635
1636 #define CONSTRUCTOR_PREPEND_VALUE(E, V) E->value = V, E--
1637   for (i = nvirtuals;  --i >= 0; )
1638     {
1639       tree method = TREE_VEC_ELT (vtable, i);
1640       if (METHOD_ABSTRACT (method))
1641         {
1642           if (! abstract_p)
1643             warning_at (DECL_SOURCE_LOCATION (method), 0,
1644                         "abstract method in non-abstract class");
1645
1646           if (TARGET_VTABLE_USES_DESCRIPTORS)
1647             for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1648               CONSTRUCTOR_PREPEND_VALUE (e, null_pointer_node);
1649           else
1650             CONSTRUCTOR_PREPEND_VALUE (e, null_pointer_node);
1651         }
1652       else
1653         {
1654           if (TARGET_VTABLE_USES_DESCRIPTORS)
1655             for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1656               {
1657                 tree fdesc = build2 (FDESC_EXPR, nativecode_ptr_type_node,
1658                                      method, build_int_cst (NULL_TREE, j));
1659                 TREE_CONSTANT (fdesc) = 1;
1660                 CONSTRUCTOR_PREPEND_VALUE (e, fdesc);
1661               }
1662           else
1663             CONSTRUCTOR_PREPEND_VALUE (e,
1664                                        build1 (ADDR_EXPR,
1665                                                nativecode_ptr_type_node,
1666                                                method));
1667         }
1668     }
1669
1670   /* Dummy entry for compatibility with G++ -fvtable-thunks.  When
1671      using the Boehm GC we sometimes stash a GC type descriptor
1672      there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1673      the emitted byte count during the output to the assembly file. */
1674   /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1675      fake "function descriptor".  It's first word is the is the class
1676      pointer, and subsequent words (usually one) contain the GC descriptor.
1677      In all other cases, we reserve two extra vtable slots. */
1678   gc_descr =  get_boehm_type_descriptor (type);
1679   CONSTRUCTOR_PREPEND_VALUE (e, gc_descr);
1680   for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
1681     CONSTRUCTOR_PREPEND_VALUE (e, gc_descr);
1682   CONSTRUCTOR_PREPEND_VALUE (e, this_class_addr);
1683
1684   /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1685   CONSTRUCTOR_PREPEND_VALUE (e, null_pointer_node);
1686   /** Offset to start of whole object.  Always (ptrdiff_t)0 for Java. */
1687   gcc_assert (e == VEC_address (constructor_elt, v));
1688   e->index = integer_zero_node;
1689   e->value = null_pointer_node;
1690 #undef CONSTRUCTOR_PREPEND_VALUE
1691
1692   arraytype = build_prim_array_type (nativecode_ptr_type_node, arraysize);
1693   return build_constructor (arraytype, v);
1694 }
1695
1696
1697 /* Set the method_index for a method decl.  */
1698 void
1699 set_method_index (tree decl, tree method_index)
1700 {
1701   if (method_index != NULL_TREE)
1702     {
1703       /* method_index is null if we're using indirect dispatch.  */
1704       method_index = fold (convert (sizetype, method_index));
1705
1706       if (TARGET_VTABLE_USES_DESCRIPTORS)
1707         /* Add one to skip bogus descriptor for class and GC descriptor. */
1708         method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
1709       else
1710         /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1711            descriptor.  */
1712         method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1713     }
1714
1715   DECL_VINDEX (decl) = method_index;
1716 }
1717
1718 /* Get the method_index for a method decl.  */
1719 tree
1720 get_method_index (tree decl)
1721 {
1722   tree method_index = DECL_VINDEX (decl);
1723
1724   if (! method_index)
1725     return NULL;
1726
1727   if (TARGET_VTABLE_USES_DESCRIPTORS)
1728     /* Sub one to skip bogus descriptor for class and GC descriptor. */
1729     method_index = size_binop (MINUS_EXPR, method_index, size_int (1));
1730   else
1731     /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor.  */
1732     method_index = size_binop (MINUS_EXPR, method_index, size_int (2));
1733
1734   return method_index;
1735 }
1736
1737 static int
1738 supers_all_compiled (tree type)
1739 {
1740   while (type != NULL_TREE)
1741     {
1742       if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
1743         return 0;
1744       type = CLASSTYPE_SUPER (type);
1745     }
1746   return 1;
1747 }
1748
1749 static void
1750 add_table_and_syms (VEC(constructor_elt,gc) **v,
1751                     VEC(method_entry,gc) *methods,
1752                     const char *table_name, tree table_slot, tree table_type,
1753                     const char *syms_name, tree syms_slot)
1754 {
1755   if (methods == NULL)
1756     {
1757       PUSH_FIELD_VALUE (*v, table_name, null_pointer_node);
1758       PUSH_FIELD_VALUE (*v, syms_name, null_pointer_node);
1759     }
1760   else
1761     {
1762       pushdecl_top_level (syms_slot);
1763       PUSH_FIELD_VALUE (*v, table_name,
1764                         build1 (ADDR_EXPR, table_type, table_slot));
1765       PUSH_FIELD_VALUE (*v, syms_name,
1766                         build1 (ADDR_EXPR, symbols_array_ptr_type,
1767                                 syms_slot));
1768       TREE_CONSTANT (table_slot) = 1;
1769     }
1770 }
1771
1772 void
1773 make_class_data (tree type)
1774 {
1775   tree decl, cons, temp;
1776   tree field, fields_decl;
1777   HOST_WIDE_INT static_field_count = 0;
1778   HOST_WIDE_INT instance_field_count = 0;
1779   HOST_WIDE_INT field_count;
1780   tree field_array_type;
1781   tree method;
1782   tree dtable_decl = NULL_TREE;
1783   HOST_WIDE_INT method_count = 0;
1784   tree method_array_type;
1785   tree methods_decl;
1786   tree super;
1787   tree this_class_addr;
1788   tree constant_pool_constructor;
1789   tree interfaces = null_pointer_node;
1790   int interface_len = 0;
1791   int uses_jv_markobj = 0;
1792   tree type_decl = TYPE_NAME (type);
1793   tree id_main = get_identifier("main");
1794   tree id_class = get_identifier("java.lang.Class");
1795   /** Offset from start of virtual function table declaration
1796       to where objects actually point at, following new g++ ABI. */
1797   tree dtable_start_offset = size_int (2 * POINTER_SIZE / BITS_PER_UNIT);
1798   VEC(int, heap) *field_indexes;
1799   tree first_real_field;
1800   VEC(constructor_elt,gc) *v1 = NULL, *v2 = NULL;
1801   tree reflection_data;
1802   VEC(constructor_elt,gc) *static_fields = NULL;
1803   VEC(constructor_elt,gc) *instance_fields = NULL;
1804   VEC(constructor_elt,gc) *methods = NULL;
1805
1806   this_class_addr = build_static_class_ref (type);
1807   decl = TREE_OPERAND (this_class_addr, 0);
1808
1809   if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
1810       && !flag_indirect_dispatch)
1811     {
1812       tree dtable = get_dispatch_table (type, this_class_addr);
1813       uses_jv_markobj = uses_jv_markobj_p (dtable);
1814       if (type == class_type_node && class_dtable_decl != NULL_TREE)
1815         {
1816           /* We've already created some other class, and consequently
1817              we made class_dtable_decl.  Now we just want to fill it
1818              in.  */
1819           dtable_decl = class_dtable_decl;
1820         }
1821       else
1822         {
1823           dtable_decl = build_dtable_decl (type);
1824           TREE_STATIC (dtable_decl) = 1;
1825           DECL_ARTIFICIAL (dtable_decl) = 1;
1826           DECL_IGNORED_P (dtable_decl) = 1;
1827         }
1828
1829       TREE_PUBLIC (dtable_decl) = 1;
1830       DECL_INITIAL (dtable_decl) = dtable;
1831       /* The only dispatch table exported from a DSO is the dispatch
1832          table for java.lang.Class.  */
1833       if (DECL_NAME (type_decl) != id_class)
1834         java_hide_decl (dtable_decl);
1835       if (! flag_indirect_classes)
1836         rest_of_decl_compilation (dtable_decl, 1, 0);
1837       /* Maybe we're compiling Class as the first class.  If so, set
1838          class_dtable_decl to the decl we just made.  */
1839       if (type == class_type_node && class_dtable_decl == NULL_TREE)
1840         class_dtable_decl = dtable_decl;
1841     }
1842
1843   /* Build Field array. */
1844   field = TYPE_FIELDS (type);
1845   while (field && DECL_ARTIFICIAL (field))
1846     field = DECL_CHAIN (field);  /* Skip dummy fields.  */
1847   if (field && DECL_NAME (field) == NULL_TREE)
1848     field = DECL_CHAIN (field);  /* Skip dummy field for inherited data. */
1849   first_real_field = field;
1850
1851   /* First count static and instance fields.  */
1852   for ( ; field != NULL_TREE; field = DECL_CHAIN (field))
1853     {
1854       if (! DECL_ARTIFICIAL (field))
1855         {
1856           if (FIELD_STATIC (field))
1857             static_field_count++;
1858           else if (uses_jv_markobj || !flag_reduced_reflection)
1859             instance_field_count++;
1860         }
1861     }
1862   field_count = static_field_count + instance_field_count;
1863   field_indexes = VEC_alloc (int, heap, field_count);
1864
1865   /* gcj sorts fields so that static fields come first, followed by
1866      instance fields.  Unfortunately, by the time this takes place we
1867      have already generated the reflection_data for this class, and
1868      that data contains indexes into the fields.  So, we generate a
1869      permutation that maps each original field index to its final
1870      position.  Then we pass this permutation to
1871      rewrite_reflection_indexes(), which fixes up the reflection
1872      data.  */
1873   {
1874     int i;
1875     int static_count = 0;
1876     int instance_count = static_field_count;
1877     int field_index;
1878
1879     for (i = 0, field = first_real_field;
1880          field != NULL_TREE;
1881          field = DECL_CHAIN (field), i++)
1882     {
1883       if (! DECL_ARTIFICIAL (field))
1884         {
1885           field_index = 0;
1886           if (FIELD_STATIC (field))
1887             field_index = static_count++;
1888           else if (uses_jv_markobj || !flag_reduced_reflection)
1889             field_index = instance_count++;
1890           else
1891             continue;
1892           VEC_quick_push (int, field_indexes, field_index);
1893         }
1894     }
1895   }
1896
1897   for (field = first_real_field; field != NULL_TREE;
1898        field = DECL_CHAIN (field))
1899     {
1900       if (! DECL_ARTIFICIAL (field))
1901         {
1902           if (FIELD_STATIC (field))
1903             {
1904               /* We must always create reflection data for static fields
1905                  as it is used in the creation of the field itself. */
1906               tree init = make_field_value (field);
1907               tree initial = DECL_INITIAL (field);
1908               CONSTRUCTOR_APPEND_ELT (static_fields, NULL_TREE, init);
1909               /* If the initial value is a string constant,
1910                  prevent output_constant from trying to assemble the value. */
1911               if (initial != NULL_TREE
1912                   && TREE_TYPE (initial) == string_ptr_type_node)
1913                 DECL_INITIAL (field) = NULL_TREE;
1914               rest_of_decl_compilation (field, 1, 1);
1915               DECL_INITIAL (field) = initial;
1916             }
1917           else if (uses_jv_markobj || !flag_reduced_reflection)
1918             {
1919               tree init = make_field_value (field);
1920               CONSTRUCTOR_APPEND_ELT (instance_fields, NULL_TREE, init);
1921             }
1922         }
1923     }
1924
1925   gcc_assert (static_field_count
1926               == (int) VEC_length (constructor_elt, static_fields));
1927   gcc_assert (instance_field_count
1928               == (int) VEC_length (constructor_elt, instance_fields));
1929
1930   if (field_count > 0)
1931     {
1932       VEC_safe_splice (constructor_elt, gc, static_fields, instance_fields);
1933       field_array_type = build_prim_array_type (field_type_node, field_count);
1934       fields_decl = build_decl (input_location,
1935                                 VAR_DECL, mangled_classname ("_FL_", type),
1936                                 field_array_type);
1937       DECL_INITIAL (fields_decl)
1938         = build_constructor (field_array_type, static_fields);
1939       TREE_STATIC (fields_decl) = 1;
1940       DECL_ARTIFICIAL (fields_decl) = 1;
1941       DECL_IGNORED_P (fields_decl) = 1;
1942       rest_of_decl_compilation (fields_decl, 1, 0);
1943     }
1944   else
1945     fields_decl = NULL_TREE;
1946
1947   /* Build Method array. */
1948   for (method = TYPE_METHODS (type);
1949        method != NULL_TREE; method = DECL_CHAIN (method))
1950     {
1951       tree init;
1952       if (METHOD_PRIVATE (method)
1953           && ! flag_keep_inline_functions
1954           && optimize)
1955         continue;
1956       /* Even if we have a decl, we don't necessarily have the code.
1957          This can happen if we inherit a method from a superclass for
1958          which we don't have a .class file.  */
1959       if (METHOD_DUMMY (method))
1960         continue;
1961
1962       /* Generate method reflection data if:
1963
1964           - !flag_reduced_reflection.
1965
1966           - <clinit> -- The runtime uses reflection to initialize the
1967             class.
1968
1969           - Any method in class java.lang.Class -- Class.forName() and
1970             perhaps other things require it.
1971
1972           - class$ -- It does not work if reflection data missing.
1973
1974           - main -- Reflection is used to find main(String[]) methods.
1975
1976           - public not static -- It is potentially part of an
1977             interface.  The runtime uses reflection data to build
1978             interface dispatch tables.  */
1979       if (!flag_reduced_reflection
1980           || DECL_CLINIT_P (method)
1981           || DECL_NAME (type_decl) == id_class
1982           || DECL_NAME (method) == id_main
1983           || (METHOD_PUBLIC (method) && !METHOD_STATIC (method)))
1984         {
1985           init = make_method_value (method);
1986           method_count++;
1987           CONSTRUCTOR_APPEND_ELT (methods, NULL_TREE, init);
1988         }
1989     }
1990   method_array_type = build_prim_array_type (method_type_node, method_count);
1991   methods_decl = build_decl (input_location,
1992                              VAR_DECL, mangled_classname ("_MT_", type),
1993                              method_array_type);
1994   DECL_INITIAL (methods_decl) = build_constructor (method_array_type, methods);
1995   TREE_STATIC (methods_decl) = 1;
1996   DECL_ARTIFICIAL (methods_decl) = 1;
1997   DECL_IGNORED_P (methods_decl) = 1;
1998   rest_of_decl_compilation (methods_decl, 1, 0);
1999
2000   if (class_dtable_decl == NULL_TREE)
2001     {
2002       class_dtable_decl = build_dtable_decl (class_type_node);
2003       TREE_STATIC (class_dtable_decl) = 1;
2004       DECL_ARTIFICIAL (class_dtable_decl) = 1;
2005       DECL_IGNORED_P (class_dtable_decl) = 1;
2006       if (is_compiled_class (class_type_node) != 2)
2007         {
2008           DECL_EXTERNAL (class_dtable_decl) = 1;
2009           rest_of_decl_compilation (class_dtable_decl, 1, 0);
2010         }
2011     }
2012
2013   super = CLASSTYPE_SUPER (type);
2014   if (super == NULL_TREE)
2015     super = null_pointer_node;
2016   else if (! flag_indirect_dispatch
2017            && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
2018            && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
2019     super = build_class_ref (super);
2020   else
2021     {
2022       int super_index = alloc_class_constant (super);
2023       super = build_int_cst (ptr_type_node, super_index);
2024     }
2025
2026   /* Build and emit the array of implemented interfaces. */
2027   if (type != object_type_node)
2028     interface_len = BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) - 1;
2029
2030   if (interface_len > 0)
2031     {
2032       int i;
2033       tree interface_array_type, idecl;
2034       VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc,
2035                                                  interface_len);
2036       interface_array_type
2037         = build_prim_array_type (class_ptr_type, interface_len);
2038       idecl = build_decl (input_location,
2039                           VAR_DECL, mangled_classname ("_IF_", type),
2040                           interface_array_type);
2041
2042       for (i = 1; i <= interface_len; i++)
2043         {
2044           tree child = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
2045           tree iclass = BINFO_TYPE (child);
2046           tree index;
2047           if (! flag_indirect_dispatch
2048               && (assume_compiled
2049                   (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))))
2050             index = build_class_ref (iclass);
2051           else
2052             {
2053               int int_index = alloc_class_constant (iclass);
2054               index = build_int_cst (ptr_type_node, int_index);
2055             }
2056           CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, index);
2057         }
2058       DECL_INITIAL (idecl) = build_constructor (interface_array_type, init);
2059       TREE_STATIC (idecl) = 1;
2060       DECL_ARTIFICIAL (idecl) = 1;
2061       DECL_IGNORED_P (idecl) = 1;
2062       interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
2063       rest_of_decl_compilation (idecl, 1, 0);
2064     }
2065
2066   constant_pool_constructor = build_constants_constructor ();
2067
2068   if (flag_indirect_dispatch)
2069     {
2070       TYPE_OTABLE_DECL (type)
2071         = emit_symbol_table
2072         (DECL_NAME (TYPE_OTABLE_DECL (type)),
2073          TYPE_OTABLE_DECL (type), TYPE_OTABLE_METHODS (type),
2074          TYPE_OTABLE_SYMS_DECL (type), integer_type_node, 1);
2075
2076       TYPE_ATABLE_DECL (type)
2077         = emit_symbol_table
2078         (DECL_NAME (TYPE_ATABLE_DECL (type)),
2079          TYPE_ATABLE_DECL (type), TYPE_ATABLE_METHODS (type),
2080          TYPE_ATABLE_SYMS_DECL (type), ptr_type_node, 1);
2081
2082       TYPE_ITABLE_DECL (type)
2083         = emit_symbol_table
2084         (DECL_NAME (TYPE_ITABLE_DECL (type)),
2085          TYPE_ITABLE_DECL (type), TYPE_ITABLE_METHODS (type),
2086          TYPE_ITABLE_SYMS_DECL (type), ptr_type_node, 2);
2087     }
2088
2089   TYPE_CTABLE_DECL (type) = emit_catch_table (type);
2090
2091   START_RECORD_CONSTRUCTOR (v1, object_type_node);
2092   PUSH_FIELD_VALUE (v1, "vtable",
2093                     (flag_indirect_classes
2094                      ? null_pointer_node
2095                      : build2 (POINTER_PLUS_EXPR, dtable_ptr_type,
2096                                build1 (ADDR_EXPR, dtable_ptr_type,
2097                                        class_dtable_decl),
2098                                dtable_start_offset)));
2099   if (! flag_hash_synchronization)
2100     PUSH_FIELD_VALUE (v1, "sync_info", null_pointer_node);
2101   FINISH_RECORD_CONSTRUCTOR (temp, v1, object_type_node);
2102   START_RECORD_CONSTRUCTOR (v2, class_type_node);
2103   PUSH_SUPER_VALUE (v2, temp);
2104   PUSH_FIELD_VALUE (v2, "next_or_version", gcj_abi_version);
2105   PUSH_FIELD_VALUE (v2, "name", build_utf8_ref (DECL_NAME (type_decl)));
2106   PUSH_FIELD_VALUE (v2, "accflags",
2107                     build_int_cst (NULL_TREE,
2108                                    get_access_flags_from_decl (type_decl)));
2109
2110   PUSH_FIELD_VALUE (v2, "superclass",
2111                     CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
2112   PUSH_FIELD_VALUE (v2, "constants", constant_pool_constructor);
2113   PUSH_FIELD_VALUE (v2, "methods",
2114                     methods_decl == NULL_TREE ? null_pointer_node
2115                     : build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
2116   PUSH_FIELD_VALUE (v2, "method_count",
2117                     build_int_cst (NULL_TREE, method_count));
2118
2119   PUSH_FIELD_VALUE (v2, "vtable_method_count",
2120                     (flag_indirect_dispatch
2121                      ? integer_minus_one_node
2122                      : TYPE_NVIRTUALS (type)));
2123
2124   PUSH_FIELD_VALUE (v2, "fields",
2125                     fields_decl == NULL_TREE ? null_pointer_node
2126                     : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
2127   /* If we're using the binary compatibility ABI we don't know the
2128      size until load time.  */
2129   PUSH_FIELD_VALUE (v2, "size_in_bytes",
2130                     (flag_indirect_dispatch
2131                      ? integer_minus_one_node
2132                      : size_in_bytes (type)));
2133   PUSH_FIELD_VALUE (v2, "field_count",
2134                     build_int_cst (NULL_TREE, field_count));
2135   PUSH_FIELD_VALUE (v2, "static_field_count",
2136                     build_int_cst (NULL_TREE, static_field_count));
2137
2138   PUSH_FIELD_VALUE (v2, "vtable",
2139                     (flag_indirect_dispatch || dtable_decl == NULL_TREE
2140                      ? null_pointer_node
2141                      : build2 (POINTER_PLUS_EXPR, dtable_ptr_type,
2142                                 build1 (ADDR_EXPR, dtable_ptr_type,
2143                                         dtable_decl),
2144                                dtable_start_offset)));
2145   add_table_and_syms (&v2, TYPE_OTABLE_METHODS (type),
2146                       "otable", TYPE_OTABLE_DECL (type), otable_ptr_type,
2147                       "otable_syms", TYPE_OTABLE_SYMS_DECL (type));
2148   add_table_and_syms (&v2, TYPE_ATABLE_METHODS (type),
2149                       "atable", TYPE_ATABLE_DECL (type), atable_ptr_type,
2150                       "atable_syms", TYPE_ATABLE_SYMS_DECL (type));
2151   add_table_and_syms (&v2, TYPE_ITABLE_METHODS (type),
2152                       "itable", TYPE_ITABLE_DECL (type), itable_ptr_type,
2153                       "itable_syms", TYPE_ITABLE_SYMS_DECL (type));
2154
2155   PUSH_FIELD_VALUE (v2, "catch_classes",
2156                     build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
2157   PUSH_FIELD_VALUE (v2, "interfaces", interfaces);
2158   PUSH_FIELD_VALUE (v2, "loader", null_pointer_node);
2159   PUSH_FIELD_VALUE (v2, "interface_count",
2160                     build_int_cst (NULL_TREE, interface_len));
2161   PUSH_FIELD_VALUE (v2, "state",
2162                     convert (byte_type_node,
2163                              build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
2164
2165   PUSH_FIELD_VALUE (v2, "thread", null_pointer_node);
2166   PUSH_FIELD_VALUE (v2, "depth", integer_zero_node);
2167   PUSH_FIELD_VALUE (v2, "ancestors", null_pointer_node);
2168   PUSH_FIELD_VALUE (v2, "idt", null_pointer_node);
2169   PUSH_FIELD_VALUE (v2, "arrayclass", null_pointer_node);
2170   PUSH_FIELD_VALUE (v2, "protectionDomain", null_pointer_node);
2171
2172   {
2173     tree assertion_table_ref;
2174     if (TYPE_ASSERTIONS (type) == NULL)
2175       assertion_table_ref = null_pointer_node;
2176     else
2177       assertion_table_ref = build1 (ADDR_EXPR,
2178                                     build_pointer_type (assertion_table_type),
2179                                     emit_assertion_table (type));
2180
2181     PUSH_FIELD_VALUE (v2, "assertion_table", assertion_table_ref);
2182   }
2183
2184   PUSH_FIELD_VALUE (v2, "hack_signers", null_pointer_node);
2185   PUSH_FIELD_VALUE (v2, "chain", null_pointer_node);
2186   PUSH_FIELD_VALUE (v2, "aux_info", null_pointer_node);
2187   PUSH_FIELD_VALUE (v2, "engine", null_pointer_node);
2188
2189   if (TYPE_REFLECTION_DATA (current_class))
2190     {
2191       int i;
2192       int count = TYPE_REFLECTION_DATASIZE (current_class);
2193       VEC (constructor_elt, gc) *v
2194         = VEC_alloc (constructor_elt, gc, count);
2195       unsigned char *data = TYPE_REFLECTION_DATA (current_class);
2196       tree max_index = build_int_cst (sizetype, count);
2197       tree index = build_index_type (max_index);
2198       tree type = build_array_type (unsigned_byte_type_node, index);
2199       char buf[64];
2200       tree array;
2201       static int reflection_data_count;
2202
2203       sprintf (buf, "_reflection_data_%d", reflection_data_count++);
2204       array = build_decl (input_location,
2205                           VAR_DECL, get_identifier (buf), type);
2206
2207       rewrite_reflection_indexes (field_indexes);
2208
2209       for (i = 0; i < count; i++)
2210         {
2211           constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
2212           elt->index = build_int_cst (sizetype, i);
2213           elt->value = build_int_cstu (byte_type_node, data[i]);
2214         }
2215
2216       DECL_INITIAL (array) = build_constructor (type, v);
2217       TREE_STATIC (array) = 1;
2218       DECL_ARTIFICIAL (array) = 1;
2219       DECL_IGNORED_P (array) = 1;
2220       TREE_READONLY (array) = 1;
2221       TREE_CONSTANT (DECL_INITIAL (array)) = 1;
2222       rest_of_decl_compilation (array, 1, 0);
2223
2224       reflection_data = build_address_of (array);
2225
2226       free (data);
2227       TYPE_REFLECTION_DATA (current_class) = NULL;
2228     }
2229   else
2230     reflection_data = null_pointer_node;
2231
2232   PUSH_FIELD_VALUE (v2, "reflection_data", reflection_data);
2233   FINISH_RECORD_CONSTRUCTOR (cons, v2, class_type_node);
2234
2235   DECL_INITIAL (decl) = cons;
2236
2237   /* Hash synchronization requires at least 64-bit alignment. */
2238   if (flag_hash_synchronization && POINTER_SIZE < 64)
2239     DECL_ALIGN (decl) = 64;
2240
2241   if (flag_indirect_classes)
2242     {
2243       TREE_READONLY (decl) = 1;
2244       TREE_CONSTANT (DECL_INITIAL (decl)) = 1;
2245     }
2246
2247   rest_of_decl_compilation (decl, 1, 0);
2248
2249   {
2250     tree classdollar_field = build_classdollar_field (type);
2251     if (!flag_indirect_classes)
2252       DECL_INITIAL (classdollar_field) = build_static_class_ref (type);
2253     rest_of_decl_compilation (classdollar_field, 1, 0);
2254   }
2255
2256   TYPE_OTABLE_DECL (type) = NULL_TREE;
2257   TYPE_ATABLE_DECL (type) = NULL_TREE;
2258   TYPE_CTABLE_DECL (type) = NULL_TREE;
2259 }
2260
2261 void
2262 finish_class (void)
2263 {
2264   java_expand_catch_classes (current_class);
2265
2266   current_function_decl = NULL_TREE;
2267   TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class)) = 0;
2268   make_class_data (current_class);
2269   register_class ();
2270   rest_of_decl_compilation (TYPE_NAME (current_class), 1, 0);
2271 }
2272
2273 /* Return 2 if KLASS is compiled by this compilation job;
2274    return 1 if KLASS can otherwise be assumed to be compiled;
2275    return 0 if we cannot assume that KLASS is compiled.
2276    Returns 1 for primitive and 0 for array types.  */
2277 int
2278 is_compiled_class (tree klass)
2279 {
2280   int seen_in_zip;
2281   if (TREE_CODE (klass) == POINTER_TYPE)
2282     klass = TREE_TYPE (klass);
2283   if (TREE_CODE (klass) != RECORD_TYPE)  /* Primitive types are static. */
2284     return 1;
2285   if (TYPE_ARRAY_P (klass))
2286     return 0;
2287
2288   seen_in_zip = (TYPE_JCF (klass) && JCF_SEEN_IN_ZIP (TYPE_JCF (klass)));
2289   if (CLASS_FROM_CURRENTLY_COMPILED_P (klass))
2290     {
2291       /* The class was seen in the current ZIP file and will be
2292          available as a compiled class in the future but may not have
2293          been loaded already. Load it if necessary. This prevent
2294          build_class_ref () from crashing. */
2295
2296       if (seen_in_zip && !CLASS_LOADED_P (klass) && (klass != current_class))
2297         load_class (klass, 1);
2298
2299       /* We return 2 for class seen in ZIP and class from files
2300          belonging to the same compilation unit */
2301       return 2;
2302     }
2303
2304   if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (klass)))))
2305     {
2306       if (!CLASS_LOADED_P (klass))
2307         {
2308           if (klass != current_class)
2309             load_class (klass, 1);
2310         }
2311       return 1;
2312     }
2313
2314   return 0;
2315 }
2316
2317 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
2318
2319 tree
2320 build_dtable_decl (tree type)
2321 {
2322   tree dtype, decl;
2323
2324   /* We need to build a new dtable type so that its size is uniquely
2325      computed when we're dealing with the class for real and not just
2326      faking it (like java.lang.Class during the initialization of the
2327      compiler.) We know we're not faking a class when CURRENT_CLASS is
2328      TYPE. */
2329   if (current_class == type)
2330     {
2331       tree dummy = NULL_TREE;
2332       int n;
2333
2334       dtype = make_node (RECORD_TYPE);
2335
2336       PUSH_FIELD (input_location, dtype, dummy, "top_offset", ptr_type_node);
2337       PUSH_FIELD (input_location, dtype, dummy, "type_info", ptr_type_node);
2338
2339       PUSH_FIELD (input_location, dtype, dummy, "class", class_ptr_type);
2340       for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2341         {
2342           tree tmp_field = build_decl (input_location,
2343                                        FIELD_DECL, NULL_TREE, ptr_type_node);
2344           TREE_CHAIN (dummy) = tmp_field;
2345           DECL_CONTEXT (tmp_field) = dtype;
2346           DECL_ARTIFICIAL (tmp_field) = 1;
2347           dummy = tmp_field;
2348         }
2349
2350       PUSH_FIELD (input_location, dtype, dummy, "gc_descr", ptr_type_node);
2351       for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2352         {
2353           tree tmp_field = build_decl (input_location,
2354                                        FIELD_DECL, NULL_TREE, ptr_type_node);
2355           TREE_CHAIN (dummy) = tmp_field;
2356           DECL_CONTEXT (tmp_field) = dtype;
2357           DECL_ARTIFICIAL (tmp_field) = 1;
2358           dummy = tmp_field;
2359         }
2360
2361       n = TREE_VEC_LENGTH (get_dispatch_vector (type));
2362       if (TARGET_VTABLE_USES_DESCRIPTORS)
2363         n *= TARGET_VTABLE_USES_DESCRIPTORS;
2364
2365       PUSH_FIELD (input_location, dtype, dummy, "methods",
2366                   build_prim_array_type (nativecode_ptr_type_node, n));
2367       layout_type (dtype);
2368     }
2369   else
2370     dtype = dtable_type;
2371
2372   decl = build_decl (input_location,
2373                      VAR_DECL, get_identifier ("vt$"), dtype);
2374   DECL_CONTEXT (decl) = type;
2375   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2376   DECL_VTABLE_P (decl) = 1;
2377
2378   return decl;
2379 }
2380
2381 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2382    fields inherited from SUPER_CLASS. */
2383
2384 void
2385 push_super_field (tree this_class, tree super_class)
2386 {
2387   tree base_decl;
2388   /* Don't insert the field if we're just re-laying the class out. */
2389   if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
2390     return;
2391   base_decl = build_decl (input_location,
2392                           FIELD_DECL, NULL_TREE, super_class);
2393   DECL_IGNORED_P (base_decl) = 1;
2394   DECL_CHAIN (base_decl) = TYPE_FIELDS (this_class);
2395   TYPE_FIELDS (this_class) = base_decl;
2396   DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
2397   DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
2398 }
2399
2400 /* Handle the different manners we may have to lay out a super class.  */
2401
2402 static tree
2403 maybe_layout_super_class (tree super_class, tree this_class ATTRIBUTE_UNUSED)
2404 {
2405   if (!super_class)
2406     return NULL_TREE;
2407   else if (TREE_CODE (super_class) == RECORD_TYPE)
2408     {
2409       if (!CLASS_LOADED_P (super_class))
2410         load_class (super_class, 1);
2411     }
2412   /* We might have to layout the class before its dependency on
2413      the super class gets resolved by java_complete_class  */
2414   else if (TREE_CODE (super_class) == POINTER_TYPE)
2415     {
2416       if (TREE_TYPE (super_class) != NULL_TREE)
2417         super_class = TREE_TYPE (super_class);
2418       else
2419         gcc_unreachable ();
2420     }
2421   if (!TYPE_SIZE (super_class))
2422     safe_layout_class (super_class);
2423
2424   return super_class;
2425 }
2426
2427 /* safe_layout_class just makes sure that we can load a class without
2428    disrupting the current_class, input_file, input_line, etc, information
2429    about the class processed currently.  */
2430
2431 void
2432 safe_layout_class (tree klass)
2433 {
2434   tree save_current_class = current_class;
2435   location_t save_location = input_location;
2436
2437   layout_class (klass);
2438
2439   current_class = save_current_class;
2440   input_location = save_location;
2441 }
2442
2443 void
2444 layout_class (tree this_class)
2445 {
2446   int i;
2447   tree super_class = CLASSTYPE_SUPER (this_class);
2448
2449   class_list = tree_cons (this_class, NULL_TREE, class_list);
2450   if (CLASS_BEING_LAIDOUT (this_class))
2451     {
2452       char buffer [1024];
2453       char *report;
2454       tree current;
2455
2456       sprintf (buffer, " with '%s'",
2457                IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class))));
2458       obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2459
2460       for (current = TREE_CHAIN (class_list); current;
2461            current = TREE_CHAIN (current))
2462         {
2463           tree decl = TYPE_NAME (TREE_PURPOSE (current));
2464           sprintf (buffer, "\n  which inherits from '%s' (%s:%d)",
2465                    IDENTIFIER_POINTER (DECL_NAME (decl)),
2466                    DECL_SOURCE_FILE (decl),
2467                    DECL_SOURCE_LINE (decl));
2468           obstack_grow (&temporary_obstack, buffer, strlen (buffer));
2469         }
2470       obstack_1grow (&temporary_obstack, '\0');
2471       report = XOBFINISH (&temporary_obstack, char *);
2472       cyclic_inheritance_report = ggc_strdup (report);
2473       obstack_free (&temporary_obstack, report);
2474       TYPE_SIZE (this_class) = error_mark_node;
2475       return;
2476     }
2477   CLASS_BEING_LAIDOUT (this_class) = 1;
2478
2479   if (super_class && !CLASS_BEING_LAIDOUT (super_class))
2480     {
2481       tree maybe_super_class
2482         = maybe_layout_super_class (super_class, this_class);
2483       if (maybe_super_class == NULL
2484           || TREE_CODE (TYPE_SIZE (maybe_super_class)) == ERROR_MARK)
2485         {
2486           TYPE_SIZE (this_class) = error_mark_node;
2487           CLASS_BEING_LAIDOUT (this_class) = 0;
2488           class_list = TREE_CHAIN (class_list);
2489           return;
2490         }
2491       if (TYPE_SIZE (this_class) == NULL_TREE)
2492         push_super_field (this_class, maybe_super_class);
2493     }
2494
2495   layout_type (this_class);
2496
2497   /* Also recursively load/layout any superinterfaces.  */
2498   if (TYPE_BINFO (this_class))
2499     {
2500       for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (this_class)) - 1; i > 0; i--)
2501         {
2502           tree binfo = BINFO_BASE_BINFO (TYPE_BINFO (this_class), i);
2503           tree super_interface = BINFO_TYPE (binfo);
2504           tree maybe_super_interface
2505             = maybe_layout_super_class (super_interface, NULL_TREE);
2506           if (maybe_super_interface == NULL
2507               || TREE_CODE (TYPE_SIZE (maybe_super_interface)) == ERROR_MARK)
2508             {
2509               TYPE_SIZE (this_class) = error_mark_node;
2510               CLASS_BEING_LAIDOUT (this_class) = 0;
2511               class_list = TREE_CHAIN (class_list);
2512               return;
2513             }
2514         }
2515     }
2516
2517   /* Convert the size back to an SI integer value.  */
2518   TYPE_SIZE_UNIT (this_class) =
2519     fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
2520
2521   CLASS_BEING_LAIDOUT (this_class) = 0;
2522   class_list = TREE_CHAIN (class_list);
2523 }
2524
2525 static void
2526 add_miranda_methods (tree base_class, tree search_class)
2527 {
2528   int i;
2529   tree binfo, base_binfo;
2530
2531   if (!CLASS_PARSED_P (search_class))
2532     load_class (search_class, 1);
2533
2534   for (binfo = TYPE_BINFO (search_class), i = 1;
2535        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2536     {
2537       tree method_decl;
2538       tree elt = BINFO_TYPE (base_binfo);
2539
2540       /* FIXME: This is totally bogus.  We should not be handling
2541          Miranda methods at all if we're using the BC ABI.  */
2542       if (TYPE_DUMMY (elt))
2543         continue;
2544
2545       /* Ensure that interface methods are seen in declared order.  */
2546       if (!CLASS_LOADED_P (elt))
2547         load_class (elt, 1);
2548       layout_class_methods (elt);
2549
2550       /* All base classes will have been laid out at this point, so the order
2551          will be correct.  This code must match similar layout code in the
2552          runtime.  */
2553       for (method_decl = TYPE_METHODS (elt);
2554            method_decl; method_decl = DECL_CHAIN (method_decl))
2555         {
2556           tree sig, override;
2557
2558           /* An interface can have <clinit>.  */
2559           if (ID_CLINIT_P (DECL_NAME (method_decl)))
2560             continue;
2561
2562           sig = build_java_argument_signature (TREE_TYPE (method_decl));
2563           override = lookup_argument_method (base_class,
2564                                              DECL_NAME (method_decl), sig);
2565           if (override == NULL_TREE)
2566             {
2567               /* Found a Miranda method.  Add it.  */
2568               tree new_method;
2569               sig = build_java_signature (TREE_TYPE (method_decl));
2570               new_method
2571                 = add_method (base_class,
2572                               get_access_flags_from_decl (method_decl),
2573                               DECL_NAME (method_decl), sig);
2574               METHOD_INVISIBLE (new_method) = 1;
2575             }
2576         }
2577
2578       /* Try superinterfaces.  */
2579       add_miranda_methods (base_class, elt);
2580     }
2581 }
2582
2583 void
2584 layout_class_methods (tree this_class)
2585 {
2586   tree method_decl, dtable_count;
2587   tree super_class, type_name;
2588
2589   if (TYPE_NVIRTUALS (this_class))
2590     return;
2591
2592   super_class = CLASSTYPE_SUPER (this_class);
2593
2594   if (super_class)
2595     {
2596       super_class = maybe_layout_super_class (super_class, this_class);
2597       if (!TYPE_NVIRTUALS (super_class))
2598         layout_class_methods (super_class);
2599       dtable_count = TYPE_NVIRTUALS (super_class);
2600     }
2601   else
2602     dtable_count = integer_zero_node;
2603
2604   type_name = TYPE_NAME (this_class);
2605   if (!flag_indirect_dispatch
2606       && (CLASS_ABSTRACT (type_name) || CLASS_INTERFACE (type_name)))
2607     {
2608       /* An abstract class can have methods which are declared only in
2609          an implemented interface.  These are called "Miranda
2610          methods".  We make a dummy method entry for such methods
2611          here.  */
2612       add_miranda_methods (this_class, this_class);
2613     }
2614
2615   TYPE_METHODS (this_class) = nreverse (TYPE_METHODS (this_class));
2616
2617   for (method_decl = TYPE_METHODS (this_class);
2618        method_decl; method_decl = DECL_CHAIN (method_decl))
2619     dtable_count = layout_class_method (this_class, super_class,
2620                                         method_decl, dtable_count);
2621
2622   TYPE_NVIRTUALS (this_class) = dtable_count;
2623 }
2624
2625 /* Return the index of METHOD in INTERFACE.  This index begins at 1
2626    and is used as an argument for _Jv_LookupInterfaceMethodIdx(). */
2627 int
2628 get_interface_method_index (tree method, tree interface)
2629 {
2630   tree meth;
2631   int i = 1;
2632
2633   for (meth = TYPE_METHODS (interface); ; meth = DECL_CHAIN (meth))
2634     {
2635       if (meth == method)
2636         return i;
2637       /* We don't want to put <clinit> into the interface table.  */
2638       if (! ID_CLINIT_P (DECL_NAME (meth)))
2639         ++i;
2640       gcc_assert (meth != NULL_TREE);
2641     }
2642 }
2643
2644 /* Lay METHOD_DECL out, returning a possibly new value of
2645    DTABLE_COUNT. Also mangle the method's name. */
2646
2647 tree
2648 layout_class_method (tree this_class, tree super_class,
2649                      tree method_decl, tree dtable_count)
2650 {
2651   tree method_name = DECL_NAME (method_decl);
2652
2653   TREE_PUBLIC (method_decl) = 1;
2654
2655   if (flag_indirect_classes
2656       || (METHOD_PRIVATE (method_decl) && METHOD_STATIC (method_decl)
2657           && ! METHOD_NATIVE (method_decl)
2658           && ! special_method_p (method_decl)))
2659     java_hide_decl (method_decl);
2660
2661   /* Considered external unless it is being compiled into this object
2662      file, or it was already flagged as external.  */
2663   if (!DECL_EXTERNAL (method_decl))
2664     DECL_EXTERNAL (method_decl) = ((is_compiled_class (this_class) != 2)
2665                                    || METHOD_NATIVE (method_decl));
2666
2667   if (ID_INIT_P (method_name))
2668     {
2669       const char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
2670       const char *ptr;
2671       for (ptr = p; *ptr; )
2672         {
2673           if (*ptr++ == '.')
2674             p = ptr;
2675         }
2676       DECL_CONSTRUCTOR_P (method_decl) = 1;
2677       build_java_signature (TREE_TYPE (method_decl));
2678     }
2679   else if (! METHOD_STATIC (method_decl))
2680     {
2681       tree method_sig =
2682         build_java_signature (TREE_TYPE (method_decl));
2683       bool method_override = false;
2684       tree super_method = lookup_java_method (super_class, method_name,
2685                                                   method_sig);
2686       if (super_method != NULL_TREE
2687           && ! METHOD_DUMMY (super_method))
2688         {
2689           method_override = true;
2690           if (! METHOD_PUBLIC (super_method) &&
2691               ! METHOD_PROTECTED (super_method))
2692             {
2693               /* Don't override private method, or default-access method in
2694                  another package.  */
2695               if (METHOD_PRIVATE (super_method) ||
2696                   ! in_same_package (TYPE_NAME (this_class),
2697                                      TYPE_NAME (super_class)))
2698                 method_override = false;
2699            }
2700         }
2701       if (method_override)
2702         {
2703           tree method_index = get_method_index (super_method);
2704           set_method_index (method_decl, method_index);
2705           if (method_index == NULL_TREE
2706               && ! flag_indirect_dispatch
2707               && ! DECL_ARTIFICIAL (super_method))
2708             error ("non-static method %q+D overrides static method",
2709                    method_decl);
2710         }
2711       else if (this_class == object_type_node
2712                && (METHOD_FINAL (method_decl)
2713                    || METHOD_PRIVATE (method_decl)))
2714         {
2715           /* We don't generate vtable entries for final Object
2716              methods.  This is simply to save space, since every
2717              object would otherwise have to define them.  */
2718         }
2719       else if (! METHOD_PRIVATE (method_decl)
2720                && dtable_count)
2721         {
2722           /* We generate vtable entries for final methods because they
2723              may one day be changed to non-final.  */
2724           set_method_index (method_decl, dtable_count);
2725           dtable_count = fold_build2 (PLUS_EXPR, integer_type_node,
2726                                       dtable_count, integer_one_node);
2727         }
2728     }
2729
2730   return dtable_count;
2731 }
2732
2733 static void
2734 register_class (void)
2735 {
2736   tree node;
2737
2738   if (!registered_class)
2739     registered_class = VEC_alloc (tree, gc, 8);
2740
2741   if (flag_indirect_classes)
2742     node = current_class;
2743   else
2744     node = TREE_OPERAND (build_class_ref (current_class), 0);
2745   VEC_safe_push (tree, gc, registered_class, node);
2746 }
2747
2748 /* Emit a function that calls _Jv_RegisterNewClasses with a list of
2749    all the classes we have emitted.  */
2750
2751 static void
2752 emit_indirect_register_classes (tree *list_p)
2753 {
2754   tree klass, t, register_class_fn;
2755   int i;
2756
2757   int size = VEC_length (tree, registered_class) * 2 + 1;
2758   VEC(constructor_elt,gc) *init = VEC_alloc (constructor_elt, gc, size);
2759   tree class_array_type
2760     = build_prim_array_type (ptr_type_node, size);
2761   tree cdecl = build_decl (input_location,
2762                            VAR_DECL, get_identifier ("_Jv_CLS"),
2763                            class_array_type);
2764   tree reg_class_list;
2765   for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2766     {
2767       t = fold_convert (ptr_type_node, build_static_class_ref (klass));
2768       CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, t);
2769       t = fold_convert (ptr_type_node,
2770                         build_address_of (build_classdollar_field (klass)));
2771       CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, t);
2772     }
2773   CONSTRUCTOR_APPEND_ELT (init, NULL_TREE, integer_zero_node);
2774   DECL_INITIAL (cdecl) = build_constructor (class_array_type, init);
2775   TREE_CONSTANT (DECL_INITIAL (cdecl)) = 1;
2776   TREE_STATIC (cdecl) = 1;
2777   DECL_ARTIFICIAL (cdecl) = 1;
2778   DECL_IGNORED_P (cdecl) = 1;
2779   TREE_READONLY (cdecl) = 1;
2780   TREE_CONSTANT (cdecl) = 1;
2781   rest_of_decl_compilation (cdecl, 1, 0);
2782   reg_class_list = fold_convert (ptr_type_node, build_address_of (cdecl));
2783
2784   t = build_function_type_list (void_type_node,
2785                                 build_pointer_type (ptr_type_node), NULL);
2786   t = build_decl (input_location,
2787                   FUNCTION_DECL,
2788                   get_identifier ("_Jv_RegisterNewClasses"), t);
2789   TREE_PUBLIC (t) = 1;
2790   DECL_EXTERNAL (t) = 1;
2791   register_class_fn = t;
2792   t = build_call_expr (register_class_fn, 1, reg_class_list);
2793   append_to_statement_list (t, list_p);
2794 }
2795
2796
2797 /* Emit something to register classes at start-up time.
2798
2799    The preferred mechanism is through the .jcr section, which contain
2800    a list of pointers to classes which get registered during constructor
2801    invocation time.
2802
2803    The fallback mechanism is to add statements to *LIST_P to call
2804    _Jv_RegisterClass for each class in this file.  These statements will
2805    be added to a static constructor function for this translation unit.  */
2806
2807 void
2808 emit_register_classes (tree *list_p)
2809 {
2810   if (registered_class == NULL)
2811     return;
2812
2813   if (flag_indirect_classes)
2814     {
2815       emit_indirect_register_classes (list_p);
2816       return;
2817     }
2818
2819   /* TARGET_USE_JCR_SECTION defaults to 1 if SUPPORTS_WEAK and
2820      TARGET_ASM_NAMED_SECTION, else 0.  Some targets meet those conditions
2821      but lack suitable crtbegin/end objects or linker support.  These
2822      targets can override the default in tm.h to use the fallback mechanism.  */
2823   if (TARGET_USE_JCR_SECTION)
2824     {
2825       tree klass, t;
2826       int i;
2827
2828 #ifdef JCR_SECTION_NAME
2829       switch_to_section (get_section (JCR_SECTION_NAME, SECTION_WRITE, NULL));
2830 #else
2831       /* A target has defined TARGET_USE_JCR_SECTION,
2832          but doesn't have a JCR_SECTION_NAME.  */
2833       gcc_unreachable ();
2834 #endif
2835       assemble_align (POINTER_SIZE);
2836
2837       for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2838         {
2839           t = build_fold_addr_expr (klass);
2840           output_constant (t, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE);
2841         }
2842     }
2843   else
2844     {
2845       tree klass, t, register_class_fn;
2846       int i;
2847
2848       t = build_function_type_list (void_type_node, class_ptr_type, NULL);
2849       t = build_decl (input_location,
2850                       FUNCTION_DECL, get_identifier ("_Jv_RegisterClass"), t);
2851       TREE_PUBLIC (t) = 1;
2852       DECL_EXTERNAL (t) = 1;
2853       register_class_fn = t;
2854
2855       for (i = 0; VEC_iterate (tree, registered_class, i, klass); ++i)
2856         {
2857           t = build_fold_addr_expr (klass);
2858           t = build_call_expr (register_class_fn, 1, t);
2859           append_to_statement_list (t, list_p);
2860         }
2861     }
2862 }
2863
2864 /* Build a constructor for an entry in the symbol table.  */
2865
2866 static tree
2867 build_symbol_table_entry (tree clname, tree name, tree signature)
2868 {
2869   tree symbol;
2870   VEC(constructor_elt,gc) *v = NULL;
2871
2872   START_RECORD_CONSTRUCTOR (v, symbol_type);
2873   PUSH_FIELD_VALUE (v, "clname", clname);
2874   PUSH_FIELD_VALUE (v, "name", name);
2875   PUSH_FIELD_VALUE (v, "signature", signature);
2876   FINISH_RECORD_CONSTRUCTOR (symbol, v, symbol_type);
2877   TREE_CONSTANT (symbol) = 1;
2878
2879   return symbol;
2880 }
2881
2882 /* Make a symbol_type (_Jv_MethodSymbol) node for DECL. */
2883
2884 static tree
2885 build_symbol_entry (tree decl, tree special)
2886 {
2887   tree clname, name, signature;
2888   clname = build_utf8_ref (DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))));
2889   /* ???  Constructors are given the name foo.foo all the way through
2890      the compiler, but in the method table they're all renamed
2891      foo.<init>.  So, we have to do the same here unless we want an
2892      unresolved reference at runtime.  */
2893   name = build_utf8_ref ((TREE_CODE (decl) == FUNCTION_DECL
2894                           && DECL_CONSTRUCTOR_P (decl))
2895                          ? init_identifier_node
2896                          : DECL_NAME (decl));
2897   signature = build_java_signature (TREE_TYPE (decl));
2898   signature = build_utf8_ref (unmangle_classname
2899                               (IDENTIFIER_POINTER (signature),
2900                                IDENTIFIER_LENGTH (signature)));
2901   /* SPECIAL is either NULL_TREE or integer_one_node.  We emit
2902      signature addr+1 if SPECIAL, and this indicates to the runtime
2903      system that this is a "special" symbol, i.e. one that should
2904      bypass access controls.  */
2905   if (special != NULL_TREE)
2906     signature = build2 (POINTER_PLUS_EXPR, TREE_TYPE (signature), signature,
2907                         fold_convert (sizetype, special));
2908
2909   return build_symbol_table_entry (clname, name, signature);
2910 }
2911
2912 /* Emit a symbol table: used by -findirect-dispatch.  */
2913
2914 tree
2915 emit_symbol_table (tree name, tree the_table,
2916                    VEC(method_entry,gc) *decl_table,
2917                    tree the_syms_decl, tree the_array_element_type,
2918                    int element_size)
2919 {
2920   tree table, null_symbol, table_size, the_array_type;
2921   unsigned index;
2922   method_entry *e;
2923   VEC(constructor_elt,gc) *v = NULL;
2924
2925   /* Only emit a table if this translation unit actually made any
2926      references via it. */
2927   if (decl_table == NULL)
2928     return the_table;
2929
2930   /* Build a list of _Jv_MethodSymbols for each entry in otable_methods. */
2931   for (index = 0; VEC_iterate (method_entry, decl_table, index, e); index++)
2932     CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
2933                             build_symbol_entry (e->method, e->special));
2934
2935   /* Terminate the list with a "null" entry. */
2936   null_symbol = build_symbol_table_entry (null_pointer_node,
2937                                           null_pointer_node,
2938                                           null_pointer_node);
2939   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, null_symbol);
2940
2941   table = build_constructor (symbols_array_type, v);
2942
2943   /* Make it the initial value for otable_syms and emit the decl. */
2944   DECL_INITIAL (the_syms_decl) = table;
2945   DECL_ARTIFICIAL (the_syms_decl) = 1;
2946   DECL_IGNORED_P (the_syms_decl) = 1;
2947   rest_of_decl_compilation (the_syms_decl, 1, 0);
2948
2949   /* Now that its size is known, redefine the table as an
2950      uninitialized static array of INDEX + 1 elements. The extra entry
2951      is used by the runtime to track whether the table has been
2952      initialized. */
2953   table_size
2954     = build_index_type (build_int_cst (NULL_TREE, index * element_size + 1));
2955   the_array_type = build_array_type (the_array_element_type, table_size);
2956   the_table = build_decl (input_location,
2957                           VAR_DECL, name, the_array_type);
2958   TREE_STATIC (the_table) = 1;
2959   TREE_READONLY (the_table) = 1;
2960   rest_of_decl_compilation (the_table, 1, 0);
2961
2962   return the_table;
2963 }
2964
2965 /* Make an entry for the catch_classes list.  */
2966 tree
2967 make_catch_class_record (tree catch_class, tree classname)
2968 {
2969   tree entry;
2970   tree type = TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (output_class)));
2971   VEC(constructor_elt,gc) *v = NULL;
2972   START_RECORD_CONSTRUCTOR (v, type);
2973   PUSH_FIELD_VALUE (v, "address", catch_class);
2974   PUSH_FIELD_VALUE (v, "classname", classname);
2975   FINISH_RECORD_CONSTRUCTOR (entry, v, type);
2976   return entry;
2977 }
2978
2979
2980 /* Generate the list of Throwable classes that are caught by exception
2981    handlers in this class.  */
2982 tree
2983 emit_catch_table (tree this_class)
2984 {
2985   tree table, table_size, array_type;
2986   int n_catch_classes;
2987   constructor_elt *e;
2988   /* Fill in the dummy entry that make_class created.  */
2989   e = VEC_index (constructor_elt, TYPE_CATCH_CLASSES (this_class), 0);
2990   e->value = make_catch_class_record (null_pointer_node, null_pointer_node);
2991   CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (this_class), NULL_TREE,
2992                           make_catch_class_record (null_pointer_node,
2993                                                    null_pointer_node));
2994   n_catch_classes = VEC_length (constructor_elt,
2995                                 TYPE_CATCH_CLASSES (this_class));
2996   table_size = build_index_type (build_int_cst (NULL_TREE, n_catch_classes));
2997   array_type
2998     = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
2999                         table_size);
3000   table =
3001     build_decl (input_location,
3002                 VAR_DECL, DECL_NAME (TYPE_CTABLE_DECL (this_class)), array_type);
3003   DECL_INITIAL (table) =
3004     build_constructor (array_type, TYPE_CATCH_CLASSES (this_class));
3005   TREE_STATIC (table) = 1;
3006   TREE_READONLY (table) = 1;
3007   DECL_IGNORED_P (table) = 1;
3008   rest_of_decl_compilation (table, 1, 0);
3009   return table;
3010 }
3011
3012 /* Given a type, return the signature used by
3013    _Jv_FindClassFromSignature() in libgcj.  This isn't exactly the
3014    same as build_java_signature() because we want the canonical array
3015    type.  */
3016
3017 static tree
3018 build_signature_for_libgcj (tree type)
3019 {
3020   tree sig, ref;
3021
3022   sig = build_java_signature (type);
3023   ref = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
3024                                             IDENTIFIER_LENGTH (sig)));
3025   return ref;
3026 }
3027
3028 /* Build an entry in the type assertion table.  */
3029
3030 static tree
3031 build_assertion_table_entry (tree code, tree op1, tree op2)
3032 {
3033   VEC(constructor_elt,gc) *v = NULL;
3034   tree entry;
3035
3036   START_RECORD_CONSTRUCTOR (v, assertion_entry_type);
3037   PUSH_FIELD_VALUE (v, "assertion_code", code);
3038   PUSH_FIELD_VALUE (v, "op1", op1);
3039   PUSH_FIELD_VALUE (v, "op2", op2);
3040   FINISH_RECORD_CONSTRUCTOR (entry, v, assertion_entry_type);
3041
3042   return entry;
3043 }
3044
3045 /* Add an entry to the type assertion table. Callback used during hashtable
3046    traversal.  */
3047
3048 static int
3049 add_assertion_table_entry (void **htab_entry, void *ptr)
3050 {
3051   tree entry;
3052   tree code_val, op1_utf8, op2_utf8;
3053   VEC(constructor_elt,gc) **v = (VEC(constructor_elt,gc) **) ptr;
3054   type_assertion *as = (type_assertion *) *htab_entry;
3055
3056   code_val = build_int_cst (NULL_TREE, as->assertion_code);
3057
3058   if (as->op1 == NULL_TREE)
3059     op1_utf8 = null_pointer_node;
3060   else
3061     op1_utf8 = build_signature_for_libgcj (as->op1);
3062
3063   if (as->op2 == NULL_TREE)
3064     op2_utf8 = null_pointer_node;
3065   else
3066     op2_utf8 = build_signature_for_libgcj (as->op2);
3067
3068   entry = build_assertion_table_entry (code_val, op1_utf8, op2_utf8);
3069
3070   CONSTRUCTOR_APPEND_ELT (*v, NULL_TREE, entry);
3071   return true;
3072 }
3073
3074 /* Generate the type assertion table for KLASS, and return its DECL.  */
3075
3076 static tree
3077 emit_assertion_table (tree klass)
3078 {
3079   tree null_entry, ctor, table_decl;
3080   htab_t assertions_htab = TYPE_ASSERTIONS (klass);
3081   VEC(constructor_elt,gc) *v = NULL;
3082
3083   /* Iterate through the hash table.  */
3084   htab_traverse (assertions_htab, add_assertion_table_entry, &v);
3085
3086   /* Finish with a null entry.  */
3087   null_entry = build_assertion_table_entry (integer_zero_node,
3088                                             null_pointer_node,
3089                                             null_pointer_node);
3090
3091   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, null_entry);
3092
3093   ctor = build_constructor (assertion_table_type, v);
3094
3095   table_decl = build_decl (input_location,
3096                            VAR_DECL, mangled_classname ("_type_assert_", klass),
3097                            assertion_table_type);
3098
3099   TREE_STATIC (table_decl) = 1;
3100   TREE_READONLY (table_decl) = 1;
3101   TREE_CONSTANT (table_decl) = 1;
3102   DECL_IGNORED_P (table_decl) = 1;
3103
3104   DECL_INITIAL (table_decl) = ctor;
3105   DECL_ARTIFICIAL (table_decl) = 1;
3106   rest_of_decl_compilation (table_decl, 1, 0);
3107
3108   return table_decl;
3109 }
3110
3111 void
3112 init_class_processing (void)
3113 {
3114   fields_ident = get_identifier ("fields");
3115   info_ident = get_identifier ("info");
3116
3117   gcc_obstack_init (&temporary_obstack);
3118 }
3119 \f
3120 static hashval_t java_treetreehash_hash (const void *);
3121 static int java_treetreehash_compare (const void *, const void *);
3122
3123 /* A hash table mapping trees to trees.  Used generally.  */
3124
3125 #define JAVA_TREEHASHHASH_H(t) ((hashval_t)TYPE_UID (t))
3126
3127 static hashval_t
3128 java_treetreehash_hash (const void *k_p)
3129 {
3130   const struct treetreehash_entry *const k
3131     = (const struct treetreehash_entry *) k_p;
3132   return JAVA_TREEHASHHASH_H (k->key);
3133 }
3134
3135 static int
3136 java_treetreehash_compare (const void * k1_p, const void * k2_p)
3137 {
3138   const struct treetreehash_entry *const k1
3139     = (const struct treetreehash_entry *) k1_p;
3140   const_tree const k2 = (const_tree) k2_p;
3141   return (k1->key == k2);
3142 }
3143
3144 tree
3145 java_treetreehash_find (htab_t ht, tree t)
3146 {
3147   struct treetreehash_entry *e;
3148   hashval_t hv = JAVA_TREEHASHHASH_H (t);
3149   e = (struct treetreehash_entry *) htab_find_with_hash (ht, t, hv);
3150   if (e == NULL)
3151     return NULL;
3152   else
3153     return e->value;
3154 }
3155
3156 tree *
3157 java_treetreehash_new (htab_t ht, tree t)
3158 {
3159   void **e;
3160   struct treetreehash_entry *tthe;
3161   hashval_t hv = JAVA_TREEHASHHASH_H (t);
3162
3163   e = htab_find_slot_with_hash (ht, t, hv, INSERT);
3164   if (*e == NULL)
3165     {
3166       tthe = ggc_alloc_cleared_treetreehash_entry ();
3167       tthe->key = t;
3168       *e = tthe;
3169     }
3170   else
3171     tthe = (struct treetreehash_entry *) *e;
3172   return &tthe->value;
3173 }
3174
3175 htab_t
3176 java_treetreehash_create (size_t size)
3177 {
3178   return htab_create_ggc (size, java_treetreehash_hash,
3179                           java_treetreehash_compare, NULL);
3180 }
3181
3182 /* Break down qualified IDENTIFIER into package and class-name components.
3183    For example, given SOURCE "pkg.foo.Bar", LEFT will be set to
3184    "pkg.foo", and RIGHT to "Bar". */
3185
3186 int
3187 split_qualified_name (tree *left, tree *right, tree source)
3188 {
3189   char *p, *base;
3190   int l = IDENTIFIER_LENGTH (source);
3191
3192   base = (char *) alloca (l + 1);
3193   memcpy (base, IDENTIFIER_POINTER (source), l + 1);
3194
3195   /* Breakdown NAME into REMAINDER . IDENTIFIER.  */
3196   p = base + l - 1;
3197   while (*p != '.' && p != base)
3198     p--;
3199
3200   /* We didn't find a '.'. Return an error.  */
3201   if (p == base)
3202     return 1;
3203
3204   *p = '\0';
3205   if (right)
3206     *right = get_identifier (p+1);
3207   *left = get_identifier (base);
3208
3209   return 0;
3210 }
3211
3212 /* Given two classes (TYPE_DECL) or class names (IDENTIFIER), return TRUE
3213    if the classes are from the same package. */
3214
3215 int
3216 in_same_package (tree name1, tree name2)
3217 {
3218   tree tmp;
3219   tree pkg1;
3220   tree pkg2;
3221
3222   if (TREE_CODE (name1) == TYPE_DECL)
3223     name1 = DECL_NAME (name1);
3224   if (TREE_CODE (name2) == TYPE_DECL)
3225     name2 = DECL_NAME (name2);
3226
3227   if (QUALIFIED_P (name1) != QUALIFIED_P (name2))
3228     /* One in empty package. */
3229     return 0;
3230
3231   if (QUALIFIED_P (name1) == 0 && QUALIFIED_P (name2) == 0)
3232     /* Both in empty package. */
3233     return 1;
3234
3235   split_qualified_name (&pkg1, &tmp, name1);
3236   split_qualified_name (&pkg2, &tmp, name2);
3237
3238   return (pkg1 == pkg2);
3239 }
3240
3241 /* lang_hooks.decls.final_write_globals: perform final processing on
3242    global variables.  */
3243
3244 void
3245 java_write_globals (void)
3246 {
3247   tree *vec = VEC_address (tree, pending_static_fields);
3248   int len = VEC_length (tree, pending_static_fields);
3249   write_global_declarations ();
3250   emit_debug_global_declarations (vec, len);
3251   VEC_free (tree, gc, pending_static_fields);
3252 }
3253
3254 #include "gt-java-class.h"