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