gcc/java/class.c

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