gcc/java/class.c

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