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