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