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