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
 553       if (! CLASS_LOADED_P (type1))
 554         load_class (type1, 1);
 555
 556       type1 = maybe_layout_super_class (CLASSTYPE_SUPER (type1), type1);
 557     }
 558   return 0;
 559 }
 560
 561 /* Return a 1 iff TYPE1 is an enclosing context for TYPE2 */
 562
 563 int
 564 enclosing_context_p (tree type1, tree type2)
 565 {
 566   if (!INNER_CLASS_TYPE_P (type2))
 567     return 0;
 568
 569   for (type2 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2)));
 570        type2;
 571        type2 = (INNER_CLASS_TYPE_P (type2) ?
 572                 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))) : NULL_TREE))
 573     {
 574       if (type2 == type1)
 575         return 1;
 576     }
 577
 578   return 0;
 579 }
 580
 581
 582 /* Return 1 iff TYPE1 and TYPE2 share a common enclosing class, regardless of
 583    nesting level.  */
 584
 585 int
 586 common_enclosing_context_p (tree type1, tree type2)
 587 {
 588   while (type1)
 589     {
 590       tree current;
 591       for (current = type2; current;
 592            current = (INNER_CLASS_TYPE_P (current) ?
 593                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
 594                       NULL_TREE))
 595         if (type1 == current)
 596           return 1;
 597
 598       if (INNER_CLASS_TYPE_P (type1))
 599         type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1)));
 600       else
 601         break;
 602     }
 603   return 0;
 604 }
 605
 606 /* Return 1 iff there exists a common enclosing "this" between TYPE1
 607    and TYPE2, without crossing any static context.  */
 608
 609 int
 610 common_enclosing_instance_p (tree type1, tree type2)
 611 {
 612   if (!PURE_INNER_CLASS_TYPE_P (type1) || !PURE_INNER_CLASS_TYPE_P (type2))
 613     return 0;
 614
 615   for (type1 = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))); type1;
 616        type1 = (PURE_INNER_CLASS_TYPE_P (type1) ?
 617                 TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type1))) : NULL_TREE))
 618     {
 619       tree current;
 620       for (current = TREE_TYPE (DECL_CONTEXT (TYPE_NAME (type2))); current;
 621            current = (PURE_INNER_CLASS_TYPE_P (current) ?
 622                       TREE_TYPE (DECL_CONTEXT (TYPE_NAME (current))) :
 623                       NULL_TREE))
 624         if (type1 == current)
 625           return 1;
 626     }
 627   return 0;
 628 }
 629
 630 /* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
 631    found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
 632    if attempt is made to add it twice. */
 633
 634 tree
 635 maybe_add_interface (tree this_class, tree interface_class)
 636 {
 637   tree binfo, base_binfo;
 638   int i;
 639
 640   for (binfo = TYPE_BINFO (this_class), i = 0;
 641        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
 642     if (BINFO_TYPE (base_binfo) == interface_class)
 643       return interface_class;
 644   add_interface (this_class, interface_class);
 645   return NULL_TREE;
 646 }
 647
 648 /* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
 649
 650 void
 651 add_interface (tree this_class, tree interface_class)
 652 {
 653   tree interface_binfo = make_tree_binfo (0);
 654
 655   BINFO_TYPE (interface_binfo) = interface_class;
 656   BINFO_OFFSET (interface_binfo) = integer_zero_node;
 657   BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node;
 658   BINFO_VIRTUAL_P (interface_binfo) = 1;
 659
 660   BINFO_BASE_APPEND (TYPE_BINFO (this_class), interface_binfo);
 661 }
 662
 663 #if 0
 664 /* Return the address of a pointer to the first FUNCTION_DECL
 665    in the list (*LIST) whose DECL_NAME is NAME. */
 666
 667 static tree *
 668 find_named_method (tree *list, tree name)
 669 {
 670   while (*list && DECL_NAME (*list) != name)
 671     list = &TREE_CHAIN (*list);
 672   return list;
 673 }
 674 #endif
 675
 676 static tree
 677 build_java_method_type (tree fntype, tree this_class, int access_flags)
 678 {
 679   if (access_flags & ACC_STATIC)
 680     return fntype;
 681   return build_method_type (this_class, fntype);
 682 }
 683
 684 tree
 685 add_method_1 (tree this_class, int access_flags, tree name, tree function_type)
 686 {
 687   tree method_type, fndecl;
 688
 689   method_type = build_java_method_type (function_type,
 690                                         this_class, access_flags);
 691
 692   fndecl = build_decl (FUNCTION_DECL, name, method_type);
 693   DECL_CONTEXT (fndecl) = this_class;
 694
 695   DECL_LANG_SPECIFIC (fndecl)
 696     = ggc_alloc_cleared (sizeof (struct lang_decl));
 697   DECL_LANG_SPECIFIC (fndecl)->desc = LANG_DECL_FUNC;
 698
 699   /* Initialize the static initializer test table.  */
 700
 701   DECL_FUNCTION_INIT_TEST_TABLE (fndecl) =
 702     java_treetreehash_create (10, 1);
 703
 704   /* Initialize the initialized (static) class table. */
 705   if (access_flags & ACC_STATIC)
 706     DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl) =
 707       htab_create_ggc (50, htab_hash_pointer, htab_eq_pointer, NULL);
 708
 709   /* Initialize the static method invocation compound list */
 710   DECL_FUNCTION_STATIC_METHOD_INVOCATION_COMPOUND (fndecl) = NULL_TREE;
 711
 712   TREE_CHAIN (fndecl) = TYPE_METHODS (this_class);
 713   TYPE_METHODS (this_class) = fndecl;
 714
 715   /* Notice that this is a finalizer and update the class type
 716      accordingly. This is used to optimize instance allocation. */
 717   if (name == finalize_identifier_node
 718       && TREE_TYPE (function_type) == void_type_node
 719       && TREE_VALUE (TYPE_ARG_TYPES (function_type)) == void_type_node)
 720     HAS_FINALIZER_P (this_class) = 1;
 721
 722   if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
 723   if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
 724   if (access_flags & ACC_PRIVATE)
 725     METHOD_PRIVATE (fndecl) = DECL_INLINE (fndecl) = 1;
 726   if (access_flags & ACC_NATIVE)
 727     {
 728       METHOD_NATIVE (fndecl) = 1;
 729       DECL_EXTERNAL (fndecl) = 1;
 730     }
 731   if (access_flags & ACC_STATIC)
 732     METHOD_STATIC (fndecl) = DECL_INLINE (fndecl) = 1;
 733   if (access_flags & ACC_FINAL)
 734     METHOD_FINAL (fndecl) = DECL_INLINE (fndecl) = 1;
 735   if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
 736   if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
 737   if (access_flags & ACC_STRICT) METHOD_STRICTFP (fndecl) = 1;
 738   return fndecl;
 739 }
 740
 741 /* Add a method to THIS_CLASS.
 742    The method's name is NAME.
 743    Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
 744
 745 tree
 746 add_method (tree this_class, int access_flags, tree name, tree method_sig)
 747 {
 748   tree function_type, fndecl;
 749   const unsigned char *sig
 750     = (const unsigned char *) IDENTIFIER_POINTER (method_sig);
 751
 752   if (sig[0] != '(')
 753     fatal_error ("bad method signature");
 754
 755   function_type = get_type_from_signature (method_sig);
 756   fndecl = add_method_1 (this_class, access_flags, name, function_type);
 757   set_java_signature (TREE_TYPE (fndecl), method_sig);
 758   return fndecl;
 759 }
 760
 761 tree
 762 add_field (tree class, tree name, tree field_type, int flags)
 763 {
 764   int is_static = (flags & ACC_STATIC) != 0;
 765   tree field;
 766   field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type);
 767   TREE_CHAIN (field) = TYPE_FIELDS (class);
 768   TYPE_FIELDS (class) = field;
 769   DECL_CONTEXT (field) = class;
 770
 771   if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
 772   if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
 773   if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
 774   if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
 775   if (flags & ACC_VOLATILE) FIELD_VOLATILE (field) = 1;
 776   if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
 777   if (is_static)
 778     {
 779       FIELD_STATIC (field) = 1;
 780       /* Always make field externally visible.  This is required so
 781          that native methods can always access the field.  */
 782       TREE_PUBLIC (field) = 1;
 783       /* Considered external until we know what classes are being
 784          compiled into this object file.  */
 785       DECL_EXTERNAL (field) = 1;
 786     }
 787
 788   return field;
 789 }
 790
 791 /* Associate a constant value CONSTANT with VAR_DECL FIELD. */
 792
 793 void
 794 set_constant_value (tree field, tree constant)
 795 {
 796   if (field == NULL_TREE)
 797     warning (OPT_Wattributes,
 798              "misplaced ConstantValue attribute (not in any field)");
 799   else if (DECL_INITIAL (field) != NULL_TREE)
 800     warning (OPT_Wattributes,
 801              "duplicate ConstantValue attribute for field '%s'",
 802              IDENTIFIER_POINTER (DECL_NAME (field)));
 803   else
 804     {
 805       DECL_INITIAL (field) = constant;
 806       if (TREE_TYPE (constant) != TREE_TYPE (field)
 807           && ! (TREE_TYPE (constant) == int_type_node
 808                 && INTEGRAL_TYPE_P (TREE_TYPE (field))
 809                 && TYPE_PRECISION (TREE_TYPE (field)) <= 32)
 810           && ! (TREE_TYPE (constant) == utf8const_ptr_type
 811                 && TREE_TYPE (field) == string_ptr_type_node))
 812         error ("ConstantValue attribute of field '%s' has wrong type",
 813                IDENTIFIER_POINTER (DECL_NAME (field)));
 814       if (FIELD_FINAL (field))
 815         DECL_FIELD_FINAL_IUD (field) = 1;
 816     }
 817 }
 818
 819 /* Count the number of Unicode chars encoded in a given Ut8 string. */
 820
 821 #if 0
 822 int
 823 strLengthUtf8 (char *str, int len)
 824 {
 825   register unsigned char* ptr = (unsigned char*) str;
 826   register unsigned char *limit = ptr + len;
 827   int str_length = 0;
 828   for (; ptr < limit; str_length++) {
 829     if (UTF8_GET (ptr, limit) < 0)
 830       return -1;
 831   }
 832   return str_length;
 833 }
 834 #endif
 835
 836
 837 /* Calculate a hash value for a string encoded in Utf8 format.
 838  * This returns the same hash value as specified for java.lang.String.hashCode.
 839  */
 840
 841 static int32
 842 hashUtf8String (const char *str, int len)
 843 {
 844   const unsigned char* ptr = (const unsigned char*) str;
 845   const unsigned char *limit = ptr + len;
 846   int32 hash = 0;
 847   for (; ptr < limit;)
 848     {
 849       int ch = UTF8_GET (ptr, limit);
 850       /* Updated specification from
 851          http://www.javasoft.com/docs/books/jls/clarify.html. */
 852       hash = (31 * hash) + ch;
 853     }
 854   return hash;
 855 }
 856
 857 static GTY(()) tree utf8_decl_list = NULL_TREE;
 858
 859 tree
 860 build_utf8_ref (tree name)
 861 {
 862   const char * name_ptr = IDENTIFIER_POINTER(name);
 863   int name_len = IDENTIFIER_LENGTH(name);
 864   char buf[60];
 865   tree ctype, field = NULL_TREE, str_type, cinit, string;
 866   static int utf8_count = 0;
 867   int name_hash;
 868   tree ref = IDENTIFIER_UTF8_REF (name);
 869   tree decl;
 870   if (ref != NULL_TREE)
 871     return ref;
 872
 873   ctype = make_node (RECORD_TYPE);
 874   str_type = build_prim_array_type (unsigned_byte_type_node,
 875                                     name_len + 1); /* Allow for final '\0'. */
 876   PUSH_FIELD (ctype, field, "hash", unsigned_short_type_node);
 877   PUSH_FIELD (ctype, field, "length", unsigned_short_type_node);
 878   PUSH_FIELD (ctype, field, "data", str_type);
 879   FINISH_RECORD (ctype);
 880   START_RECORD_CONSTRUCTOR (cinit, ctype);
 881   name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
 882   PUSH_FIELD_VALUE (cinit, "hash", build_int_cst (NULL_TREE, name_hash));
 883   PUSH_FIELD_VALUE (cinit, "length", build_int_cst (NULL_TREE, name_len));
 884   string = build_string (name_len, name_ptr);
 885   TREE_TYPE (string) = str_type;
 886   PUSH_FIELD_VALUE (cinit, "data", string);
 887   FINISH_RECORD_CONSTRUCTOR (cinit);
 888   TREE_CONSTANT (cinit) = 1;
 889   TREE_INVARIANT (cinit) = 1;
 890
 891   /* Generate a unique-enough identifier.  */
 892   sprintf(buf, "_Utf%d", ++utf8_count);
 893
 894   decl = build_decl (VAR_DECL, get_identifier (buf), utf8const_type);
 895   TREE_STATIC (decl) = 1;
 896   DECL_ARTIFICIAL (decl) = 1;
 897   DECL_IGNORED_P (decl) = 1;
 898   TREE_READONLY (decl) = 1;
 899   TREE_THIS_VOLATILE (decl) = 0;
 900   DECL_INITIAL (decl) = cinit;
 901
 902   if (HAVE_GAS_SHF_MERGE)
 903     {
 904       int decl_size;
 905       /* Ensure decl_size is a multiple of utf8const_type's alignment. */
 906       decl_size = (name_len + 5 + TYPE_ALIGN_UNIT (utf8const_type) - 1)
 907         & ~(TYPE_ALIGN_UNIT (utf8const_type) - 1);
 908       if (flag_merge_constants && decl_size < 256)
 909         {
 910           char buf[32];
 911           int flags = (SECTION_OVERRIDE
 912                        | SECTION_MERGE | (SECTION_ENTSIZE & decl_size));
 913           sprintf (buf, ".rodata.jutf8.%d", decl_size);
 914           named_section_flags (buf, flags);
 915           DECL_SECTION_NAME (decl) = build_string (strlen (buf), buf);
 916         }
 917     }
 918
 919   TREE_CHAIN (decl) = utf8_decl_list;
 920   layout_decl (decl, 0);
 921   pushdecl (decl);
 922   rest_of_decl_compilation (decl, global_bindings_p (), 0);
 923   cgraph_varpool_mark_needed_node (cgraph_varpool_node (decl));
 924   utf8_decl_list = decl;
 925   ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
 926   IDENTIFIER_UTF8_REF (name) = ref;
 927   return ref;
 928 }
 929
 930 /* Like build_class_ref, but instead of a direct reference generate a
 931    pointer into the constant pool.  */
 932
 933 static tree
 934 build_indirect_class_ref (tree type)
 935 {
 936   int index;
 937   tree cl;
 938   index = alloc_class_constant (type);
 939   cl = build_ref_from_constant_pool (index);
 940   return convert (promote_type (class_ptr_type), cl);
 941 }
 942
 943 /* Build a reference to the class TYPE.
 944    Also handles primitive types and array types. */
 945
 946 tree
 947 build_class_ref (tree type)
 948 {
 949   int is_compiled = is_compiled_class (type);
 950   if (is_compiled)
 951     {
 952       tree ref, decl_name, decl;
 953       if (TREE_CODE (type) == POINTER_TYPE)
 954         type = TREE_TYPE (type);
 955
 956       if (flag_indirect_dispatch
 957           && type != output_class
 958           && TREE_CODE (type) == RECORD_TYPE)
 959         return build_indirect_class_ref (type);
 960
 961       if (TREE_CODE (type) == RECORD_TYPE)
 962         {
 963           if (TYPE_SIZE (type) == error_mark_node)
 964             return null_pointer_node;
 965           decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
 966                                         "", '/', '/', ".class");
 967           decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
 968           if (decl == NULL_TREE)
 969             {
 970               decl = build_decl (VAR_DECL, decl_name, class_type_node);
 971               TREE_STATIC (decl) = 1;
 972               TREE_PUBLIC (decl) = 1;
 973               DECL_IGNORED_P (decl) = 1;
 974               DECL_ARTIFICIAL (decl) = 1;
 975               if (is_compiled == 1)
 976                 DECL_EXTERNAL (decl) = 1;
 977               MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
 978               DECL_CLASS_FIELD_P (decl) = 1;
 979               DECL_CONTEXT (decl) = type;
 980
 981               /* ??? We want to preserve the DECL_CONTEXT we set just above,
 982                  that that means not calling pushdecl_top_level.  */
 983               IDENTIFIER_GLOBAL_VALUE (decl_name) = decl;
 984             }
 985         }
 986       else
 987         {
 988           const char *name;
 989           char buffer[25];
 990           if (flag_emit_class_files)
 991             {
 992               const char *prim_class_name;
 993               tree prim_class;
 994               if (type == char_type_node)
 995                 prim_class_name = "java.lang.Character";
 996               else if (type == boolean_type_node)
 997                 prim_class_name = "java.lang.Boolean";
 998               else if (type == byte_type_node)
 999                 prim_class_name = "java.lang.Byte";
1000               else if (type == short_type_node)
1001                 prim_class_name = "java.lang.Short";
1002               else if (type == int_type_node)
1003                 prim_class_name = "java.lang.Integer";
1004               else if (type == long_type_node)
1005                 prim_class_name = "java.lang.Long";
1006               else if (type == float_type_node)
1007                 prim_class_name = "java.lang.Float";
1008               else if (type == double_type_node)
1009                 prim_class_name = "java.lang.Double";
1010               else if (type == void_type_node)
1011                 prim_class_name = "java.lang.Void";
1012               else
1013                 abort ();
1014
1015               prim_class = lookup_class (get_identifier (prim_class_name));
1016               /* We wrap the class in a NOP_EXPR, because it is a
1017                  type.  We can't hold it in the COMPONENT_REF itself,
1018                  as that type must remain NULL.  */
1019               prim_class = build1 (NOP_EXPR, prim_class, NULL_TREE);
1020
1021               return build3 (COMPONENT_REF, NULL_TREE,
1022                              prim_class, TYPE_identifier_node, NULL_TREE);
1023             }
1024           decl_name = TYPE_NAME (type);
1025           if (TREE_CODE (decl_name) == TYPE_DECL)
1026             decl_name = DECL_NAME (decl_name);
1027           name = IDENTIFIER_POINTER (decl_name);
1028           if (strncmp (name, "promoted_", 9) == 0)
1029             name += 9;
1030           sprintf (buffer, "_Jv_%sClass", name);
1031           decl_name = get_identifier (buffer);
1032           decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1033           if (decl == NULL_TREE)
1034             {
1035               decl = build_decl (VAR_DECL, decl_name, class_type_node);
1036               TREE_STATIC (decl) = 1;
1037               TREE_PUBLIC (decl) = 1;
1038               DECL_EXTERNAL (decl) = 1;
1039               DECL_ARTIFICIAL (decl) = 1;
1040               pushdecl_top_level (decl);
1041             }
1042         }
1043
1044       ref = build1 (ADDR_EXPR, class_ptr_type, decl);
1045       return ref;
1046     }
1047   else
1048     return build_indirect_class_ref (type);
1049 }
1050
1051 /* Create a local statically allocated variable that will hold a
1052    pointer to a static field.  */
1053
1054 static tree
1055 build_fieldref_cache_entry (int index, tree fdecl ATTRIBUTE_UNUSED)
1056 {
1057   tree decl, decl_name;
1058   const char *name = IDENTIFIER_POINTER (mangled_classname ("_cpool_", output_class));
1059   char *buf = alloca (strlen (name) + 20);
1060   sprintf (buf, "%s_%d_ref", name, index);
1061   decl_name = get_identifier (buf);
1062   decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
1063   if (decl == NULL_TREE)
1064     {
1065       decl = build_decl (VAR_DECL, decl_name, ptr_type_node);
1066       TREE_STATIC (decl) = 1;
1067       TREE_PUBLIC (decl) = 0;
1068       DECL_EXTERNAL (decl) = 0;
1069       DECL_ARTIFICIAL (decl) = 1;
1070       pushdecl_top_level (decl);
1071     }
1072   return decl;
1073 }
1074
1075 tree
1076 build_static_field_ref (tree fdecl)
1077 {
1078   tree fclass = DECL_CONTEXT (fdecl);
1079   int is_compiled = is_compiled_class (fclass);
1080   int from_class = ! CLASS_FROM_SOURCE_P (current_class);
1081
1082   /* Allow static final fields to fold to a constant.  When using
1083      -findirect-dispatch, we simply never do this folding if compiling
1084      from .class; in the .class file constants will be referred to via
1085      the constant pool.  */
1086   if ((!flag_indirect_dispatch || !from_class)
1087       && (is_compiled
1088           || (FIELD_FINAL (fdecl) && DECL_INITIAL (fdecl) != NULL_TREE
1089               && (JSTRING_TYPE_P (TREE_TYPE (fdecl))
1090                   || JNUMERIC_TYPE_P (TREE_TYPE (fdecl)))
1091               && TREE_CONSTANT (DECL_INITIAL (fdecl)))))
1092     {
1093       if (is_compiled == 1)
1094         DECL_EXTERNAL (fdecl) = 1;
1095     }
1096   else
1097     {
1098       /* Generate a CONSTANT_FieldRef for FDECL in the constant pool
1099          and a class local static variable CACHE_ENTRY, then
1100
1101       *(fdecl **)((__builtin_expect (cache_entry == null, false))
1102                   ? cache_entry = _Jv_ResolvePoolEntry (output_class, cpool_index)
1103                   : cache_entry)
1104
1105       This can mostly be optimized away, so that the usual path is a
1106       load followed by a test and branch.  _Jv_ResolvePoolEntry is
1107       only called once for each constant pool entry.
1108
1109       There is an optimization that we don't do: at the start of a
1110       method, create a local copy of CACHE_ENTRY and use that instead.
1111
1112       */
1113
1114       int cpool_index = alloc_constant_fieldref (output_class, fdecl);
1115       tree cache_entry = build_fieldref_cache_entry (cpool_index, fdecl);
1116       tree test
1117         = build3 (CALL_EXPR, boolean_type_node,
1118                   build_address_of (built_in_decls[BUILT_IN_EXPECT]),
1119                   tree_cons (NULL_TREE, build2 (EQ_EXPR, boolean_type_node,
1120                                                 cache_entry, null_pointer_node),
1121                              build_tree_list (NULL_TREE, boolean_false_node)),
1122                   NULL_TREE);
1123       tree cpool_index_cst = build_int_cst (NULL_TREE, cpool_index);
1124       tree init
1125         = build3 (CALL_EXPR, ptr_type_node,
1126                   build_address_of (soft_resolvepoolentry_node),
1127                   tree_cons (NULL_TREE, build_class_ref (output_class),
1128                              build_tree_list (NULL_TREE, cpool_index_cst)),
1129                   NULL_TREE);
1130       init = build2 (MODIFY_EXPR, ptr_type_node, cache_entry, init);
1131       init = build3 (COND_EXPR, ptr_type_node, test, init, cache_entry);
1132       init = fold_convert (build_pointer_type (TREE_TYPE (fdecl)), init);
1133       fdecl = build1 (INDIRECT_REF, TREE_TYPE (fdecl), init);
1134     }
1135   return fdecl;
1136 }
1137
1138 int
1139 get_access_flags_from_decl (tree decl)
1140 {
1141   int access_flags = 0;
1142   if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
1143     {
1144       if (FIELD_STATIC (decl))
1145         access_flags |= ACC_STATIC;
1146       if (FIELD_PUBLIC (decl))
1147         access_flags |= ACC_PUBLIC;
1148       if (FIELD_PROTECTED (decl))
1149         access_flags |= ACC_PROTECTED;
1150       if (FIELD_PRIVATE (decl))
1151         access_flags |= ACC_PRIVATE;
1152       if (FIELD_FINAL (decl))
1153         access_flags |= ACC_FINAL;
1154       if (FIELD_VOLATILE (decl))
1155         access_flags |= ACC_VOLATILE;
1156       if (FIELD_TRANSIENT (decl))
1157         access_flags |= ACC_TRANSIENT;
1158       return access_flags;
1159     }
1160   if (TREE_CODE (decl) == TYPE_DECL)
1161     {
1162       if (CLASS_PUBLIC (decl))
1163         access_flags |= ACC_PUBLIC;
1164       if (CLASS_FINAL (decl))
1165         access_flags |= ACC_FINAL;
1166       if (CLASS_SUPER (decl))
1167         access_flags |= ACC_SUPER;
1168       if (CLASS_INTERFACE (decl))
1169         access_flags |= ACC_INTERFACE;
1170       if (CLASS_ABSTRACT (decl))
1171         access_flags |= ACC_ABSTRACT;
1172       if (CLASS_STATIC (decl))
1173         access_flags |= ACC_STATIC;
1174       if (CLASS_PRIVATE (decl))
1175         access_flags |= ACC_PRIVATE;
1176       if (CLASS_PROTECTED (decl))
1177         access_flags |= ACC_PROTECTED;
1178       if (CLASS_STRICTFP (decl))
1179         access_flags |= ACC_STRICT;
1180       return access_flags;
1181     }
1182   if (TREE_CODE (decl) == FUNCTION_DECL)
1183     {
1184       if (METHOD_PUBLIC (decl))
1185         access_flags |= ACC_PUBLIC;
1186       if (METHOD_PRIVATE (decl))
1187         access_flags |= ACC_PRIVATE;
1188       if (METHOD_PROTECTED (decl))
1189         access_flags |= ACC_PROTECTED;
1190       if (METHOD_STATIC (decl))
1191         access_flags |= ACC_STATIC;
1192       if (METHOD_FINAL (decl))
1193         access_flags |= ACC_FINAL;
1194       if (METHOD_SYNCHRONIZED (decl))
1195         access_flags |= ACC_SYNCHRONIZED;
1196       if (METHOD_NATIVE (decl))
1197         access_flags |= ACC_NATIVE;
1198       if (METHOD_ABSTRACT (decl))
1199         access_flags |= ACC_ABSTRACT;
1200       if (METHOD_STRICTFP (decl))
1201         access_flags |= ACC_STRICT;
1202       if (METHOD_INVISIBLE (decl))
1203         access_flags |= ACC_INVISIBLE;
1204       return access_flags;
1205     }
1206   abort ();
1207 }
1208
1209 static GTY (()) int alias_labelno = 0;
1210
1211 /* Create a private alias for METHOD. Using this alias instead of the method
1212    decl ensures that ncode entries in the method table point to the real function
1213    at runtime, not a PLT entry.  */
1214
1215 static tree
1216 make_local_function_alias (tree method)
1217 {
1218 #ifdef ASM_OUTPUT_DEF
1219   tree alias;
1220
1221   const char *method_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (method));
1222   char *name = alloca (strlen (method_name) + 2);
1223   char *buf = alloca (strlen (method_name) + 128);
1224
1225   /* Only create aliases for local functions.  */
1226   if (DECL_EXTERNAL (method))
1227     return method;
1228
1229   /* Prefix method_name with 'L' for the alias label.  */
1230   *name = 'L';
1231   strcpy (name + 1, method_name);
1232
1233   ASM_GENERATE_INTERNAL_LABEL (buf, name, alias_labelno++);
1234   alias = build_decl (FUNCTION_DECL, get_identifier (buf),
1235                       TREE_TYPE (method));
1236   DECL_CONTEXT (alias) = NULL;
1237   TREE_READONLY (alias) = TREE_READONLY (method);
1238   TREE_THIS_VOLATILE (alias) = TREE_THIS_VOLATILE (method);
1239   TREE_PUBLIC (alias) = 0;
1240   DECL_EXTERNAL (alias) = 0;
1241   DECL_ARTIFICIAL (alias) = 1;
1242   DECL_INLINE (alias) = 0;
1243   DECL_INITIAL (alias) = error_mark_node;
1244   TREE_ADDRESSABLE (alias) = 1;
1245   TREE_USED (alias) = 1;
1246   TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias)) = 1;
1247   if (!flag_syntax_only)
1248     assemble_alias (alias, DECL_ASSEMBLER_NAME (method));
1249   return alias;
1250 #else
1251   return method;
1252 #endif
1253 }
1254
1255 /** Make reflection data (_Jv_Field) for field FDECL. */
1256
1257 static tree
1258 make_field_value (tree fdecl)
1259 {
1260   tree finit;
1261   int flags;
1262   tree type = TREE_TYPE (fdecl);
1263   int resolved = is_compiled_class (type) && ! flag_indirect_dispatch;
1264
1265   START_RECORD_CONSTRUCTOR (finit, field_type_node);
1266   PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl)));
1267   if (resolved)
1268     type = build_class_ref (type);
1269   else
1270     {
1271       tree signature = build_java_signature (type);
1272
1273       type = build_utf8_ref (unmangle_classname
1274                              (IDENTIFIER_POINTER (signature),
1275                               IDENTIFIER_LENGTH (signature)));
1276     }
1277   PUSH_FIELD_VALUE (finit, "type", type);
1278
1279   flags = get_access_flags_from_decl (fdecl);
1280   if (! resolved)
1281     flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
1282
1283   PUSH_FIELD_VALUE (finit, "accflags", build_int_cst (NULL_TREE, flags));
1284   PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
1285
1286   PUSH_FIELD_VALUE
1287     (finit, "info",
1288      build_constructor_from_list (field_info_union_node,
1289             build_tree_list
1290             ((FIELD_STATIC (fdecl)
1291               ? TREE_CHAIN (TYPE_FIELDS (field_info_union_node))
1292               : TYPE_FIELDS (field_info_union_node)),
1293              (FIELD_STATIC (fdecl)
1294               ? build_address_of (fdecl)
1295               : byte_position (fdecl)))));
1296
1297   FINISH_RECORD_CONSTRUCTOR (finit);
1298   return finit;
1299 }
1300
1301 /** Make reflection data (_Jv_Method) for method MDECL. */
1302
1303 static tree
1304 make_method_value (tree mdecl)
1305 {
1306   static int method_name_count = 0;
1307   tree minit;
1308   tree index;
1309   tree code;
1310   tree class_decl;
1311 #define ACC_TRANSLATED          0x4000
1312   int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
1313
1314   class_decl = DECL_CONTEXT (mdecl);
1315   /* For interfaces, the index field contains the dispatch index. */
1316   if (CLASS_INTERFACE (TYPE_NAME (class_decl)))
1317     index = build_int_cst (NULL_TREE,
1318                            get_interface_method_index (mdecl, class_decl));
1319   else if (!flag_indirect_dispatch && get_method_index (mdecl) != NULL_TREE)
1320     index = get_method_index (mdecl);
1321   else
1322     index = integer_minus_one_node;
1323
1324   code = null_pointer_node;
1325   if (METHOD_ABSTRACT (mdecl))
1326     code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1327                    soft_abstractmethod_node);
1328   else
1329     code = build1 (ADDR_EXPR, nativecode_ptr_type_node,
1330                    make_local_function_alias (mdecl));
1331   START_RECORD_CONSTRUCTOR (minit, method_type_node);
1332   PUSH_FIELD_VALUE (minit, "name",
1333                     build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
1334                                     init_identifier_node
1335                                     : DECL_NAME (mdecl)));
1336   {
1337     tree signature = build_java_signature (TREE_TYPE (mdecl));
1338     PUSH_FIELD_VALUE (minit, "signature",
1339                       (build_utf8_ref
1340                        (unmangle_classname
1341                         (IDENTIFIER_POINTER(signature),
1342                          IDENTIFIER_LENGTH(signature)))));
1343   }
1344   PUSH_FIELD_VALUE (minit, "accflags", build_int_cst (NULL_TREE, accflags));
1345   PUSH_FIELD_VALUE (minit, "index", index);
1346   PUSH_FIELD_VALUE (minit, "ncode", code);
1347
1348   {
1349     /* Compute the `throws' information for the method.  */
1350     tree table = null_pointer_node;
1351     if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE)
1352       {
1353         int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl));
1354         tree iter, type, array;
1355         char buf[60];
1356
1357         table = tree_cons (NULL_TREE, table, NULL_TREE);
1358         for (iter = DECL_FUNCTION_THROWS (mdecl);
1359              iter != NULL_TREE;
1360              iter = TREE_CHAIN (iter))
1361           {
1362             tree sig = DECL_NAME (TYPE_NAME (TREE_VALUE (iter)));
1363             tree utf8
1364               = build_utf8_ref (unmangle_classname (IDENTIFIER_POINTER (sig),
1365                                                     IDENTIFIER_LENGTH (sig)));
1366             table = tree_cons (NULL_TREE, utf8, table);
1367           }
1368         type = build_prim_array_type (ptr_type_node, length);
1369         table = build_constructor_from_list (type, table);
1370         /* Compute something unique enough.  */
1371         sprintf (buf, "_methods%d", method_name_count++);
1372         array = build_decl (VAR_DECL, get_identifier (buf), type);
1373         DECL_INITIAL (array) = table;
1374         TREE_STATIC (array) = 1;
1375         DECL_ARTIFICIAL (array) = 1;
1376         DECL_IGNORED_P (array) = 1;
1377         rest_of_decl_compilation (array, 1, 0);
1378
1379         table = build1 (ADDR_EXPR, ptr_type_node, array);
1380       }
1381
1382     PUSH_FIELD_VALUE (minit, "throws", table);
1383   }
1384
1385   FINISH_RECORD_CONSTRUCTOR (minit);
1386   return minit;
1387 }
1388
1389 static tree
1390 get_dispatch_vector (tree type)
1391 {
1392   tree vtable = TYPE_VTABLE (type);
1393
1394   if (vtable == NULL_TREE)
1395     {
1396       HOST_WIDE_INT i;
1397       tree method;
1398       tree super = CLASSTYPE_SUPER (type);
1399       HOST_WIDE_INT nvirtuals = tree_low_cst (TYPE_NVIRTUALS (type), 0);
1400       vtable = make_tree_vec (nvirtuals);
1401       TYPE_VTABLE (type) = vtable;
1402       if (super != NULL_TREE)
1403         {
1404           tree super_vtable = get_dispatch_vector (super);
1405
1406           for (i = tree_low_cst (TYPE_NVIRTUALS (super), 0); --i >= 0; )
1407             TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
1408         }
1409
1410       for (method = TYPE_METHODS (type);  method != NULL_TREE;
1411            method = TREE_CHAIN (method))
1412         {
1413           tree method_index = get_method_index (method);
1414           if (method_index != NULL_TREE
1415               && host_integerp (method_index, 0))
1416             TREE_VEC_ELT (vtable, tree_low_cst (method_index, 0)) = method;
1417         }
1418     }
1419
1420   return vtable;
1421 }
1422
1423 static tree
1424 get_dispatch_table (tree type, tree this_class_addr)
1425 {
1426   int abstract_p = CLASS_ABSTRACT (TYPE_NAME (type));
1427   tree vtable = get_dispatch_vector (type);
1428   int i, j;
1429   tree list = NULL_TREE;
1430   int nvirtuals = TREE_VEC_LENGTH (vtable);
1431   int arraysize;
1432   tree gc_descr;
1433
1434   for (i = nvirtuals;  --i >= 0; )
1435     {
1436       tree method = TREE_VEC_ELT (vtable, i);
1437       if (METHOD_ABSTRACT (method))
1438         {
1439           if (! abstract_p)
1440             warning (0, "%Jabstract method in non-abstract class", method);
1441
1442           if (TARGET_VTABLE_USES_DESCRIPTORS)
1443             for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1444               list = tree_cons (NULL_TREE, null_pointer_node, list);
1445           else
1446             list = tree_cons (NULL_TREE, null_pointer_node, list);
1447         }
1448       else
1449         {
1450           if (TARGET_VTABLE_USES_DESCRIPTORS)
1451             for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
1452               {
1453                 tree fdesc = build2 (FDESC_EXPR, nativecode_ptr_type_node,
1454                                      method, build_int_cst (NULL_TREE, j));
1455                 TREE_CONSTANT (fdesc) = 1;
1456                 TREE_INVARIANT (fdesc) = 1;
1457                 list = tree_cons (NULL_TREE, fdesc, list);
1458               }
1459           else
1460             list = tree_cons (NULL_TREE,
1461                               build1 (ADDR_EXPR, nativecode_ptr_type_node,
1462                                       method),
1463                               list);
1464         }
1465     }
1466
1467   /* Dummy entry for compatibility with G++ -fvtable-thunks.  When
1468      using the Boehm GC we sometimes stash a GC type descriptor
1469      there. We set the PURPOSE to NULL_TREE not to interfere (reset)
1470      the emitted byte count during the output to the assembly file. */
1471   /* With TARGET_VTABLE_USES_DESCRIPTORS, we only add one extra
1472      fake "function descriptor".  It's first word is the is the class
1473      pointer, and subsequent words (usually one) contain the GC descriptor.
1474      In all other cases, we reserve two extra vtable slots. */
1475   gc_descr =  get_boehm_type_descriptor (type);
1476   list = tree_cons (NULL_TREE, gc_descr, list);
1477   for (j = 1; j < TARGET_VTABLE_USES_DESCRIPTORS-1; ++j)
1478     list = tree_cons (NULL_TREE, gc_descr, list);
1479   list = tree_cons (NULL_TREE, this_class_addr, list);
1480
1481   /** Pointer to type_info object (to be implemented), according to g++ ABI. */
1482   list = tree_cons (NULL_TREE, null_pointer_node, list);
1483   /** Offset to start of whole object.  Always (ptrdiff_t)0 for Java. */
1484   list = tree_cons (integer_zero_node, null_pointer_node, list);
1485
1486   arraysize = (TARGET_VTABLE_USES_DESCRIPTORS? nvirtuals + 1 : nvirtuals + 2);
1487   if (TARGET_VTABLE_USES_DESCRIPTORS)
1488     arraysize *= TARGET_VTABLE_USES_DESCRIPTORS;
1489   arraysize += 2;
1490   return build_constructor_from_list
1491           (build_prim_array_type (nativecode_ptr_type_node,
1492                                   arraysize), list);
1493 }
1494
1495
1496 /* Set the method_index for a method decl.  */
1497 void
1498 set_method_index (tree decl, tree method_index)
1499 {
1500   if (method_index != NULL_TREE)
1501     {
1502       /* method_index is null if we're using indirect dispatch.  */
1503       method_index = fold (convert (sizetype, method_index));
1504
1505       if (TARGET_VTABLE_USES_DESCRIPTORS)
1506         /* Add one to skip bogus descriptor for class and GC descriptor. */
1507         method_index = size_binop (PLUS_EXPR, method_index, size_int (1));
1508       else
1509         /* Add 1 to skip "class" field of dtable, and 1 to skip GC
1510            descriptor.  */
1511         method_index = size_binop (PLUS_EXPR, method_index, size_int (2));
1512     }
1513
1514   DECL_VINDEX (decl) = method_index;
1515 }
1516
1517 /* Get the method_index for a method decl.  */
1518 tree
1519 get_method_index (tree decl)
1520 {
1521   tree method_index = DECL_VINDEX (decl);
1522
1523   if (! method_index)
1524     return NULL;
1525
1526   if (TARGET_VTABLE_USES_DESCRIPTORS)
1527     /* Sub one to skip bogus descriptor for class and GC descriptor. */
1528     method_index = size_binop (MINUS_EXPR, method_index, size_int (1));
1529   else
1530     /* Sub 1 to skip "class" field of dtable, and 1 to skip GC descriptor.  */
1531     method_index = size_binop (MINUS_EXPR, method_index, size_int (2));
1532
1533   return method_index;
1534 }
1535
1536 static int
1537 supers_all_compiled (tree type)
1538 {
1539   while (type != NULL_TREE)
1540     {
1541       if (!assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)))))
1542         return 0;
1543       type = CLASSTYPE_SUPER (type);
1544     }
1545   return 1;
1546 }
1547
1548 void
1549 make_class_data (tree type)
1550 {
1551   tree decl, cons, temp;
1552   tree field, fields_decl;
1553   tree static_fields = NULL_TREE;
1554   tree instance_fields = NULL_TREE;
1555   HOST_WIDE_INT static_field_count = 0;
1556   HOST_WIDE_INT instance_field_count = 0;
1557   HOST_WIDE_INT field_count;
1558   tree field_array_type;
1559   tree method;
1560   tree methods = NULL_TREE;
1561   tree dtable_decl = NULL_TREE;
1562   HOST_WIDE_INT method_count = 0;
1563   tree method_array_type;
1564   tree methods_decl;
1565   tree super;
1566   tree this_class_addr;
1567   tree constant_pool_constructor;
1568   tree interfaces = null_pointer_node;
1569   int interface_len = 0;
1570   tree type_decl = TYPE_NAME (type);
1571   /** Offset from start of virtual function table declaration
1572       to where objects actually point at, following new g++ ABI. */
1573   tree dtable_start_offset = build_int_cst (NULL_TREE,
1574                                             2 * POINTER_SIZE / BITS_PER_UNIT);
1575
1576   this_class_addr = build_class_ref (type);
1577   decl = TREE_OPERAND (this_class_addr, 0);
1578
1579   /* Build Field array. */
1580   field = TYPE_FIELDS (type);
1581   while (field && DECL_ARTIFICIAL (field))
1582     field = TREE_CHAIN (field);  /* Skip dummy fields.  */
1583   if (field && DECL_NAME (field) == NULL_TREE)
1584     field = TREE_CHAIN (field);  /* Skip dummy field for inherited data. */
1585   for ( ;  field != NULL_TREE;  field = TREE_CHAIN (field))
1586     {
1587       if (! DECL_ARTIFICIAL (field))
1588         {
1589           tree init = make_field_value (field);
1590           if (FIELD_STATIC (field))
1591             {
1592               tree initial = DECL_INITIAL (field);
1593               static_field_count++;
1594               static_fields = tree_cons (NULL_TREE, init, static_fields);
1595               /* If the initial value is a string constant,
1596                  prevent output_constant from trying to assemble the value. */
1597               if (initial != NULL_TREE
1598                   && TREE_TYPE (initial) == string_ptr_type_node)
1599                 DECL_INITIAL (field) = NULL_TREE;
1600               rest_of_decl_compilation (field, 1, 1);
1601               DECL_INITIAL (field) = initial;
1602             }
1603           else
1604             {
1605               instance_field_count++;
1606               instance_fields = tree_cons (NULL_TREE, init, instance_fields);
1607             }
1608         }
1609     }
1610   field_count = static_field_count + instance_field_count;
1611   if (field_count > 0)
1612     {
1613       static_fields = nreverse (static_fields);
1614       instance_fields = nreverse (instance_fields);
1615       static_fields = chainon (static_fields, instance_fields);
1616       field_array_type = build_prim_array_type (field_type_node, field_count);
1617       fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
1618                                 field_array_type);
1619       DECL_INITIAL (fields_decl) = build_constructor_from_list
1620                                     (field_array_type, static_fields);
1621       TREE_STATIC (fields_decl) = 1;
1622       DECL_ARTIFICIAL (fields_decl) = 1;
1623       DECL_IGNORED_P (fields_decl) = 1;
1624       rest_of_decl_compilation (fields_decl, 1, 0);
1625     }
1626   else
1627     fields_decl = NULL_TREE;
1628
1629   /* Build Method array. */
1630   for (method = TYPE_METHODS (type);
1631        method != NULL_TREE; method = TREE_CHAIN (method))
1632     {
1633       tree init;
1634       if (METHOD_PRIVATE (method)
1635           && ! flag_keep_inline_functions
1636           && optimize)
1637         continue;
1638       /* Even if we have a decl, we don't necessarily have the code.
1639          This can happen if we inherit a method from a superclass for
1640          which we don't have a .class file.  */
1641       if (METHOD_DUMMY (method))
1642         continue;
1643       init = make_method_value (method);
1644       method_count++;
1645       methods = tree_cons (NULL_TREE, init, methods);
1646     }
1647   method_array_type = build_prim_array_type (method_type_node, method_count);
1648   methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
1649                              method_array_type);
1650   DECL_INITIAL (methods_decl) = build_constructor_from_list
1651                                  (method_array_type, nreverse (methods));
1652   TREE_STATIC (methods_decl) = 1;
1653   DECL_ARTIFICIAL (methods_decl) = 1;
1654   DECL_IGNORED_P (methods_decl) = 1;
1655   rest_of_decl_compilation (methods_decl, 1, 0);
1656
1657   if (supers_all_compiled (type) && ! CLASS_INTERFACE (type_decl)
1658       && !flag_indirect_dispatch)
1659     {
1660       tree dtable = get_dispatch_table (type, this_class_addr);
1661       dtable_decl = build_dtable_decl (type);
1662       DECL_INITIAL (dtable_decl) = dtable;
1663       TREE_STATIC (dtable_decl) = 1;
1664       DECL_ARTIFICIAL (dtable_decl) = 1;
1665       DECL_IGNORED_P (dtable_decl) = 1;
1666       TREE_PUBLIC (dtable_decl) = 1;
1667       rest_of_decl_compilation (dtable_decl, 1, 0);
1668       if (type == class_type_node)
1669         class_dtable_decl = dtable_decl;
1670     }
1671
1672   if (class_dtable_decl == NULL_TREE)
1673     {
1674       class_dtable_decl = build_dtable_decl (class_type_node);
1675       TREE_STATIC (class_dtable_decl) = 1;
1676       DECL_ARTIFICIAL (class_dtable_decl) = 1;
1677       DECL_IGNORED_P (class_dtable_decl) = 1;
1678       if (is_compiled_class (class_type_node) != 2)
1679         DECL_EXTERNAL (class_dtable_decl) = 1;
1680       rest_of_decl_compilation (class_dtable_decl, 1, 0);
1681     }
1682
1683   super = CLASSTYPE_SUPER (type);
1684   if (super == NULL_TREE)
1685     super = null_pointer_node;
1686   else if (! flag_indirect_dispatch
1687            && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))
1688            && assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (super)))))
1689     super = build_class_ref (super);
1690   else
1691     {
1692       int super_index = alloc_class_constant (super);
1693       super = build_int_cst (ptr_type_node, super_index);
1694     }
1695
1696   /* Build and emit the array of implemented interfaces. */
1697   if (type != object_type_node)
1698     interface_len = BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) - 1;
1699
1700   if (interface_len > 0)
1701     {
1702       tree init = NULL_TREE;
1703       int i;
1704       tree interface_array_type, idecl;
1705       interface_array_type
1706         = build_prim_array_type (class_ptr_type, interface_len);
1707       idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type),
1708                           interface_array_type);
1709
1710       for (i = interface_len;  i > 0; i--)
1711         {
1712           tree child = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
1713           tree iclass = BINFO_TYPE (child);
1714           tree index;
1715           if (! flag_indirect_dispatch
1716               && (assume_compiled
1717                   (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))))
1718             index = build_class_ref (iclass);
1719           else
1720             {
1721               int int_index = alloc_class_constant (iclass);
1722               index = build_int_cst (ptr_type_node, int_index);
1723             }
1724           init = tree_cons (NULL_TREE, index, init);
1725         }
1726       DECL_INITIAL (idecl) = build_constructor_from_list (interface_array_type,
1727                                                           init);
1728       TREE_STATIC (idecl) = 1;
1729       DECL_ARTIFICIAL (idecl) = 1;
1730       DECL_IGNORED_P (idecl) = 1;
1731       interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
1732       rest_of_decl_compilation (idecl, 1, 0);
1733     }
1734
1735   constant_pool_constructor = build_constants_constructor ();
1736
1737   if (flag_indirect_dispatch)
1738     {
1739       TYPE_OTABLE_DECL (type)
1740         = emit_symbol_table
1741         (DECL_NAME (TYPE_OTABLE_DECL (type)),
1742          TYPE_OTABLE_DECL (type), TYPE_OTABLE_METHODS (type),
1743          TYPE_OTABLE_SYMS_DECL (type), integer_type_node, 1);
1744
1745       TYPE_ATABLE_DECL (type)
1746         = emit_symbol_table
1747         (DECL_NAME (TYPE_ATABLE_DECL (type)),
1748          TYPE_ATABLE_DECL (type), TYPE_ATABLE_METHODS (type),
1749          TYPE_ATABLE_SYMS_DECL (type), ptr_type_node, 1);
1750
1751       TYPE_ITABLE_DECL (type)
1752         = emit_symbol_table
1753         (DECL_NAME (TYPE_ITABLE_DECL (type)),
1754          TYPE_ITABLE_DECL (type), TYPE_ITABLE_METHODS (type),
1755          TYPE_ITABLE_SYMS_DECL (type), ptr_type_node, 2);
1756     }
1757
1758   TYPE_CTABLE_DECL (type) = emit_catch_table (type);
1759
1760   START_RECORD_CONSTRUCTOR (temp, object_type_node);
1761   PUSH_FIELD_VALUE (temp, "vtable",
1762                     build2 (PLUS_EXPR, dtable_ptr_type,
1763                             build1 (ADDR_EXPR, dtable_ptr_type,
1764                                     class_dtable_decl),
1765                             dtable_start_offset));
1766   if (! flag_hash_synchronization)
1767     PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
1768   FINISH_RECORD_CONSTRUCTOR (temp);
1769   START_RECORD_CONSTRUCTOR (cons, class_type_node);
1770   PUSH_SUPER_VALUE (cons, temp);
1771   PUSH_FIELD_VALUE (cons, "next_or_version", gcj_abi_version);
1772   PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
1773   PUSH_FIELD_VALUE (cons, "accflags",
1774                     build_int_cst (NULL_TREE,
1775                                    get_access_flags_from_decl (type_decl)));
1776
1777   PUSH_FIELD_VALUE (cons, "superclass",
1778                     CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
1779   PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
1780   PUSH_FIELD_VALUE (cons, "methods",
1781                     build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
1782   PUSH_FIELD_VALUE (cons, "method_count",
1783                     build_int_cst (NULL_TREE, method_count));
1784
1785   if (flag_indirect_dispatch)
1786     PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node);
1787   else
1788     PUSH_FIELD_VALUE (cons, "vtable_method_count", TYPE_NVIRTUALS (type));
1789
1790   PUSH_FIELD_VALUE (cons, "fields",
1791                     fields_decl == NULL_TREE ? null_pointer_node
1792                     : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
1793   /* If we're using the binary compatibility ABI we don't know the
1794      size until load time.  */
1795   PUSH_FIELD_VALUE (cons, "size_in_bytes",
1796                     (flag_indirect_dispatch
1797                      ? integer_minus_one_node
1798                      : size_in_bytes (type)));
1799   PUSH_FIELD_VALUE (cons, "field_count",
1800                     build_int_cst (NULL_TREE, field_count));
1801   PUSH_FIELD_VALUE (cons, "static_field_count",
1802                     build_int_cst (NULL_TREE, static_field_count));
1803
1804   if (flag_indirect_dispatch)
1805     PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node);
1806   else
1807     PUSH_FIELD_VALUE (cons, "vtable",
1808                       dtable_decl == NULL_TREE ? null_pointer_node
1809                       : build2 (PLUS_EXPR, dtable_ptr_type,
1810                                 build1 (ADDR_EXPR, dtable_ptr_type,
1811                                         dtable_decl),
1812                                 dtable_start_offset));
1813   if (TYPE_OTABLE_METHODS (type) == NULL_TREE)
1814     {
1815       PUSH_FIELD_VALUE (cons, "otable", null_pointer_node);
1816       PUSH_FIELD_VALUE (cons, "otable_syms", null_pointer_node);
1817     }
1818   else
1819     {
1820       PUSH_FIELD_VALUE (cons, "otable",
1821                         build1 (ADDR_EXPR, otable_ptr_type, TYPE_OTABLE_DECL (type)));
1822       PUSH_FIELD_VALUE (cons, "otable_syms",
1823                         build1 (ADDR_EXPR, symbols_array_ptr_type,
1824                                 TYPE_OTABLE_SYMS_DECL (type)));
1825       TREE_CONSTANT (TYPE_OTABLE_DECL (type)) = 1;
1826       TREE_INVARIANT (TYPE_OTABLE_DECL (type)) = 1;
1827     }
1828   if (TYPE_ATABLE_METHODS(type) == NULL_TREE)
1829     {
1830       PUSH_FIELD_VALUE (cons, "atable", null_pointer_node);
1831       PUSH_FIELD_VALUE (cons, "atable_syms", null_pointer_node);
1832     }
1833   else
1834     {
1835       PUSH_FIELD_VALUE (cons, "atable",
1836                         build1 (ADDR_EXPR, atable_ptr_type, TYPE_ATABLE_DECL (type)));
1837       PUSH_FIELD_VALUE (cons, "atable_syms",
1838                         build1 (ADDR_EXPR, symbols_array_ptr_type,
1839                                 TYPE_ATABLE_SYMS_DECL (type)));
1840       TREE_CONSTANT (TYPE_ATABLE_DECL (type)) = 1;
1841       TREE_INVARIANT (TYPE_ATABLE_DECL (type)) = 1;
1842     }
1843    if (TYPE_ITABLE_METHODS(type) == NULL_TREE)
1844     {
1845       PUSH_FIELD_VALUE (cons, "itable", null_pointer_node);
1846       PUSH_FIELD_VALUE (cons, "itable_syms", null_pointer_node);
1847     }
1848   else
1849     {
1850       PUSH_FIELD_VALUE (cons, "itable",
1851                         build1 (ADDR_EXPR, itable_ptr_type, TYPE_ITABLE_DECL (type)));
1852       PUSH_FIELD_VALUE (cons, "itable_syms",
1853                         build1 (ADDR_EXPR, symbols_array_ptr_type,
1854                                 TYPE_ITABLE_SYMS_DECL (type)));
1855       TREE_CONSTANT (TYPE_ITABLE_DECL (type)) = 1;
1856       TREE_INVARIANT (TYPE_ITABLE_DECL (type)) = 1;
1857     }
1858
1859   PUSH_FIELD_VALUE (cons, "catch_classes",
1860                     build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type)));
1861   PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
1862   PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
1863   PUSH_FIELD_VALUE (cons, "interface_count",
1864                     build_int_cst (NULL_TREE, interface_len));
1865   PUSH_FIELD_VALUE (cons, "state",
1866                     convert (byte_type_node,
1867                              build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
1868
1869   PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
1870   PUSH_FIELD_VALUE (cons, "depth", integer_zero_node);
1871   PUSH_FIELD_VALUE (cons, "ancestors", null_pointer_node);
1872   PUSH_FIELD_VALUE (cons, "idt", null_pointer_node);
1873   PUSH_FIELD_VALUE (cons, "arrayclass", null_pointer_node);
1874   PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
1875
1876   {
1877     tree assertion_table_ref;
1878     if (TYPE_ASSERTIONS (type) == NULL)
1879       assertion_table_ref = null_pointer_node;
1880     else
1881       assertion_table_ref = build1 (ADDR_EXPR,
1882                                     build_pointer_type (assertion_table_type),
1883                                     emit_assertion_table (type));
1884
1885     PUSH_FIELD_VALUE (cons, "assertion_table", assertion_table_ref);
1886   }
1887
1888   PUSH_FIELD_VALUE (cons, "hack_signers", null_pointer_node);
1889   PUSH_FIELD_VALUE (cons, "chain", null_pointer_node);
1890   PUSH_FIELD_VALUE (cons, "aux_info", null_pointer_node);
1891   PUSH_FIELD_VALUE (cons, "engine", null_pointer_node);
1892
1893   FINISH_RECORD_CONSTRUCTOR (cons);
1894
1895   DECL_INITIAL (decl) = cons;
1896
1897   /* Hash synchronization requires at least 64-bit alignment. */
1898   if (flag_hash_synchronization && POINTER_SIZE < 64)
1899     DECL_ALIGN (decl) = 64;
1900
1901   rest_of_decl_compilation (decl, 1, 0);
1902
1903   TYPE_OTABLE_DECL (type) = NULL_TREE;
1904   TYPE_ATABLE_DECL (type) = NULL_TREE;
1905   TYPE_CTABLE_DECL (type) = NULL_TREE;
1906 }
1907
1908 void
1909 finish_class (void)
1910 {
1911   if (TYPE_VERIFY_METHOD (output_class))
1912     {
1913       tree verify_method = TYPE_VERIFY_METHOD (output_class);
1914       DECL_SAVED_TREE (verify_method)
1915         = add_stmt_to_compound (DECL_SAVED_TREE (verify_method), void_type_node,
1916                                 build (RETURN_EXPR, void_type_node, NULL));
1917       java_genericize (verify_method);
1918       cgraph_finalize_function (verify_method, false);
1919       TYPE_ASSERTIONS (current_class) = NULL;
1920     }
1921
1922   java_expand_catch_classes (current_class);
1923
1924   current_function_decl = NULL_TREE;
1925   TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (current_class)) = 0;
1926   make_class_data (current_class);
1927   register_class ();
1928   rest_of_decl_compilation (TYPE_NAME (current_class), 1, 0);
1929 }
1930
1931 /* Return 2 if CLASS is compiled by this compilation job;
1932    return 1 if CLASS can otherwise be assumed to be compiled;
1933    return 0 if we cannot assume that CLASS is compiled.
1934    Returns 1 for primitive and 0 for array types.  */
1935 int
1936 is_compiled_class (tree class)
1937 {
1938   int seen_in_zip;
1939   if (TREE_CODE (class) == POINTER_TYPE)
1940     class = TREE_TYPE (class);
1941   if (TREE_CODE (class) != RECORD_TYPE)  /* Primitive types are static. */
1942     return 1;
1943   if (TYPE_ARRAY_P (class))
1944     return 0;
1945   if (class == current_class)
1946     return 2;
1947
1948   seen_in_zip = (TYPE_JCF (class) && JCF_SEEN_IN_ZIP (TYPE_JCF (class)));
1949   if (CLASS_FROM_CURRENTLY_COMPILED_P (class) || seen_in_zip)
1950     {
1951       /* The class was seen in the current ZIP file and will be
1952          available as a compiled class in the future but may not have
1953          been loaded already. Load it if necessary. This prevent
1954          build_class_ref () from crashing. */
1955
1956       if (seen_in_zip && !CLASS_LOADED_P (class))
1957         load_class (class, 1);
1958
1959       /* We return 2 for class seen in ZIP and class from files
1960          belonging to the same compilation unit */
1961       return 2;
1962     }
1963
1964   if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class)))))
1965     {
1966       if (!CLASS_LOADED_P (class))
1967         {
1968           if (CLASS_FROM_SOURCE_P (class))
1969             safe_layout_class (class);
1970           else
1971             load_class (class, 1);
1972         }
1973       return 1;
1974     }
1975
1976   return 0;
1977 }
1978
1979 /* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
1980
1981 tree
1982 build_dtable_decl (tree type)
1983 {
1984   tree dtype, decl;
1985
1986   /* We need to build a new dtable type so that its size is uniquely
1987      computed when we're dealing with the class for real and not just
1988      faking it (like java.lang.Class during the initialization of the
1989      compiler.) We know we're not faking a class when CURRENT_CLASS is
1990      TYPE. */
1991   if (current_class == type)
1992     {
1993       tree dummy = NULL_TREE;
1994       int n;
1995
1996       dtype = make_node (RECORD_TYPE);
1997
1998       PUSH_FIELD (dtype, dummy, "top_offset", ptr_type_node);
1999       PUSH_FIELD (dtype, dummy, "type_info", ptr_type_node);
2000
2001       PUSH_FIELD (dtype, dummy, "class", class_ptr_type);
2002       for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2003         {
2004           tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2005           TREE_CHAIN (dummy) = tmp_field;
2006           DECL_CONTEXT (tmp_field) = dtype;
2007           DECL_ARTIFICIAL (tmp_field) = 1;
2008           dummy = tmp_field;
2009         }
2010
2011       PUSH_FIELD (dtype, dummy, "gc_descr", ptr_type_node);
2012       for (n = 1; n < TARGET_VTABLE_USES_DESCRIPTORS; ++n)
2013         {
2014           tree tmp_field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
2015           TREE_CHAIN (dummy) = tmp_field;
2016           DECL_CONTEXT (tmp_field) = dtype;
2017           DECL_ARTIFICIAL (tmp_field) = 1;
2018           dummy = tmp_field;
2019         }
2020
2021       n = TREE_VEC_LENGTH (get_dispatch_vector (type));
2022       if (TARGET_VTABLE_USES_DESCRIPTORS)
2023         n *= TARGET_VTABLE_USES_DESCRIPTORS;
2024
2025       PUSH_FIELD (dtype, dummy, "methods",
2026                   build_prim_array_type (nativecode_ptr_type_node, n));
2027       layout_type (dtype);
2028     }
2029   else
2030     dtype = dtable_type;
2031
2032   decl = build_decl (VAR_DECL, get_identifier ("vt$"), dtype);
2033   DECL_CONTEXT (decl) = type;
2034   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2035   DECL_VTABLE_P (decl) = 1;
2036
2037   return decl;
2038 }
2039
2040 /* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
2041    fields inherited from SUPER_CLASS. */
2042
2043 void
2044 push_super_field (tree this_class, tree super_class)
2045 {
2046   tree base_decl;
2047   /* Don't insert the field if we're just re-laying the class out. */
2048   if (TYPE_FIELDS (this_class) && !DECL_NAME (TYPE_FIELDS (this_class)))
2049     return;
2050   base_decl = build_decl (FIELD_DECL, NULL_TREE, super_class);
2051   DECL_IGNORED_P (base_decl) = 1;
2052   TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
2053   TYPE_FIELDS (this_class) = base_decl;
2054   DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
2055   DECL_SIZE_UNIT (base_decl) = TYPE_SIZE_UNIT (super_class);
2056 }
2057
2058 /* Handle the different manners we may have to lay out a super class.  */
2059
2060 static tree
2061 maybe_layout_super_class (tree super_class, tree this_class)
2062 {
2063   if (!super_class)
2064     return NULL_TREE;
2065   else 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"