gcc/java/class.c

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