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