gcc/java/class.c

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