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