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