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