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