gcc/java/class.c

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