gcc/java/class.c

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