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