gcc/java/class.c

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