gcc/java/decl.c

   1 /* Process declarations and variables for the GNU compiler for the
   2    Java(TM) language.
   3    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007,
   4    2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.
  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 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tree.h"
  32 #include "diagnostic-core.h"
  33 #include "toplev.h"
  34 #include "flags.h"
  35 #include "java-tree.h"
  36 #include "jcf.h"
  37 #include "libfuncs.h"
  38 #include "java-except.h"
  39 #include "ggc.h"
  40 #include "cgraph.h"
  41 #include "tree-inline.h"
  42 #include "target.h"
  43 #include "version.h"
  44 #include "tree-iterator.h"
  45 #include "langhooks.h"
  46 #include "cgraph.h"
  47
  48 #if defined (DEBUG_JAVA_BINDING_LEVELS)
  49 extern void indent (void);
  50 #endif
  51
  52 static tree push_jvm_slot (int, tree);
  53 static tree lookup_name_current_level (tree);
  54 static tree push_promoted_type (const char *, tree);
  55 static struct binding_level *make_binding_level (void);
  56 static tree create_primitive_vtable (const char *);
  57 static tree check_local_unnamed_variable (tree, tree, tree);
  58 static void parse_version (void);
  59
  60
  61 /* The following ABI flags are used in the high-order bits of the version
  62    ID field. The version ID number itself should never be larger than
  63    0xfffff, so it should be safe to use top 12 bits for these flags. */
  64
  65 #define FLAG_BINARYCOMPAT_ABI (1<<31)  /* Class is built with the BC-ABI. */
  66
  67 #define FLAG_BOOTSTRAP_LOADER (1<<30)  /* Used when defining a class that
  68                                           should be loaded by the bootstrap
  69                                           loader.  */
  70
  71 /* If an ABI change is made within a GCC release series, rendering current
  72    binaries incompatible with the old runtimes, this number must be set to
  73    enforce the compatibility rules. */
  74 #define MINOR_BINARYCOMPAT_ABI_VERSION 1
  75
  76 /* The runtime may recognize a variety of BC ABIs (objects generated by
  77    different version of gcj), but will probably always require strict
  78    matching for the ordinary (C++) ABI.  */
  79
  80 /* The version ID of the BC ABI that we generate.  This must be kept in
  81    sync with parse_version(), libgcj, and reality (if the BC format changes,
  82    this must change).  */
  83 #define GCJ_CURRENT_BC_ABI_VERSION \
  84   (4 * 100000 + 0 * 1000 + MINOR_BINARYCOMPAT_ABI_VERSION)
  85
  86 /* The ABI version number.  */
  87 tree gcj_abi_version;
  88
  89 /* Name of the Cloneable class.  */
  90 tree java_lang_cloneable_identifier_node;
  91
  92 /* Name of the Serializable class.  */
  93 tree java_io_serializable_identifier_node;
  94
  95 /* The DECL_MAP is a mapping from (index, type) to a decl node.
  96    If index < max_locals, it is the index of a local variable.
  97    if index >= max_locals, then index-max_locals is a stack slot.
  98    The DECL_MAP mapping is represented as a TREE_VEC whose elements
  99    are a list of decls (VAR_DECL or PARM_DECL) chained by
 100    DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
 101    we search the chain for a decl with a matching TREE_TYPE. */
 102
 103 static GTY(()) tree decl_map;
 104
 105 /* The base_decl_map is contains one variable of ptr_type: this is
 106    used to contain every variable of reference type that is ever
 107    stored in a local variable slot.  */
 108
 109 static GTY(()) tree base_decl_map;
 110
 111 /* An index used to make temporary identifiers unique.  */
 112 static int uniq;
 113
 114 /* A list of local variables VAR_DECLs for this method that we have seen
 115    debug information, but we have not reached their starting (byte) PC yet. */
 116
 117 static GTY(()) tree pending_local_decls;
 118
 119 /* The decl for "_Jv_ResolvePoolEntry".  */
 120 tree soft_resolvepoolentry_node;
 121
 122 /* The decl for the .constants field of an instance of Class.  */
 123 tree constants_field_decl_node;
 124
 125 /* The decl for the .data field of an instance of Class.  */
 126 tree constants_data_field_decl_node;
 127
 128 #if defined(DEBUG_JAVA_BINDING_LEVELS)
 129 int binding_depth = 0;
 130 int is_class_level = 0;
 131 int current_pc;
 132
 133 void
 134 indent (void)
 135 {
 136   int i;
 137
 138   for (i = 0; i < binding_depth*2; i++)
 139     putc (' ', stderr);
 140 }
 141 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
 142
 143 /* True if decl is a named local variable, i.e. if it is an alias
 144    that's used only for debugging purposes.  */
 145
 146 static bool
 147 debug_variable_p (tree decl)
 148 {
 149   if (TREE_CODE (decl) == PARM_DECL)
 150     return false;
 151
 152   if (LOCAL_SLOT_P (decl))
 153     return false;
 154
 155   return true;
 156 }
 157
 158 static tree
 159 push_jvm_slot (int index, tree decl)
 160 {
 161   DECL_CONTEXT (decl) = current_function_decl;
 162   layout_decl (decl, 0);
 163
 164   /* Now link the decl into the decl_map. */
 165   if (DECL_LANG_SPECIFIC (decl) == NULL)
 166     {
 167       MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
 168       DECL_LOCAL_START_PC (decl) = 0;
 169       DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
 170       DECL_LOCAL_SLOT_NUMBER (decl) = index;
 171     }
 172   DECL_LOCAL_SLOT_CHAIN (decl) = TREE_VEC_ELT (decl_map, index);
 173   TREE_VEC_ELT (decl_map, index) = decl;
 174
 175   return decl;
 176 }
 177
 178 /* Find the best declaration based upon type.  If 'decl' fits 'type' better
 179    than 'best', return 'decl'.  Otherwise return 'best'.  */
 180
 181 static tree
 182 check_local_unnamed_variable (tree best, tree decl, tree type)
 183 {
 184   tree decl_type = TREE_TYPE (decl);
 185
 186   gcc_assert (! LOCAL_VAR_OUT_OF_SCOPE_P (decl));
 187
 188   /* Use the same decl for all integer types <= 32 bits.  This is
 189      necessary because sometimes a value is stored as (for example)
 190      boolean but loaded as int.  */
 191   if (decl_type == type
 192       || (INTEGRAL_TYPE_P (decl_type)
 193           && INTEGRAL_TYPE_P (type)
 194           && TYPE_PRECISION (decl_type) <= 32
 195           && TYPE_PRECISION (type) <= 32
 196           && TYPE_PRECISION (decl_type) >= TYPE_PRECISION (type))
 197       /*  ptr_type_node is used for null pointers, which are
 198           assignment compatible with everything.  */
 199       || (TREE_CODE (decl_type) == POINTER_TYPE
 200           && type == ptr_type_node)
 201       /* Whenever anyone wants to use a slot that is initially
 202          occupied by a PARM_DECL of pointer type they must get that
 203          decl, even if they asked for a pointer to a different type.
 204          However, if someone wants a scalar variable in a slot that
 205          initially held a pointer arg -- or vice versa -- we create a
 206          new VAR_DECL.
 207
 208          ???: As long as verification is correct, this will be a
 209          compatible type.  But maybe we should create a dummy variable
 210          and replace all references to it with the DECL and a
 211          NOP_EXPR.
 212       */
 213       || (TREE_CODE (decl_type) == POINTER_TYPE
 214           && TREE_CODE (decl) == PARM_DECL
 215           && TREE_CODE (type) == POINTER_TYPE))
 216     {
 217       if (best == NULL_TREE
 218           || (decl_type == type && TREE_TYPE (best) != type))
 219         return decl;
 220     }
 221
 222   return best;
 223 }
 224
 225
 226 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
 227    that is valid at PC (or -1 if any pc).
 228    If there is no existing matching decl, allocate one.  */
 229
 230 tree
 231 find_local_variable (int index, tree type, int pc ATTRIBUTE_UNUSED)
 232 {
 233   tree tmp = TREE_VEC_ELT (decl_map, index);
 234   tree decl = NULL_TREE;
 235
 236   /* Scan through every declaration that has been created in this
 237      slot.  We're only looking for variables that correspond to local
 238      index declarations and PARM_DECLs, not named variables: such
 239      local variables are used only for debugging information.  */
 240   while (tmp != NULL_TREE)
 241     {
 242       if (! debug_variable_p (tmp))
 243         decl = check_local_unnamed_variable (decl, tmp, type);
 244       tmp = DECL_LOCAL_SLOT_CHAIN (tmp);
 245     }
 246
 247   /* gcj has a function called promote_type(), which is used by both
 248      the bytecode compiler and the source compiler.  Unfortunately,
 249      the type systems for the Java VM and the Java language are not
 250      the same: a boolean in the VM promotes to an int, not to a wide
 251      boolean.  If our caller wants something to hold a boolean, that
 252      had better be an int, because that slot might be re-used
 253      later in integer context.  */
 254   if (TREE_CODE (type) == BOOLEAN_TYPE)
 255     type = integer_type_node;
 256
 257   /* If we don't find a match, create one with the type passed in.
 258      The name of the variable is #n#m, which n is the variable index
 259      in the local variable area and m is a dummy identifier for
 260      uniqueness -- multiple variables may share the same local
 261      variable index.  We don't call pushdecl() to push pointer types
 262      into a binding expr because they'll all be replaced by a single
 263      variable that is used for every reference in that local variable
 264      slot.  */
 265   if (! decl)
 266     {
 267       char buf[64];
 268       tree name;
 269       sprintf (buf, "#slot#%d#%d", index, uniq++);
 270       name = get_identifier (buf);
 271       decl = build_decl (input_location, VAR_DECL, name, type);
 272       DECL_IGNORED_P (decl) = 1;
 273       DECL_ARTIFICIAL (decl) = 1;
 274       decl = push_jvm_slot (index, decl);
 275       LOCAL_SLOT_P (decl) = 1;
 276
 277       if (TREE_CODE (type) != POINTER_TYPE)
 278         pushdecl_function_level (decl);
 279     }
 280
 281   /* As well as creating a local variable that matches the type, we
 282      also create a base variable (of ptr_type) that will hold all its
 283      aliases.  */
 284   if (TREE_CODE (type) == POINTER_TYPE
 285       && ! TREE_VEC_ELT (base_decl_map, index))
 286     {
 287       char buf[64];
 288       tree name;
 289       tree base_decl;
 290       sprintf (buf, "#ref#%d#%d", index, uniq++);
 291       name = get_identifier (buf);
 292       base_decl
 293         = TREE_VEC_ELT (base_decl_map, index)
 294         = build_decl (input_location, VAR_DECL, name, ptr_type_node);
 295       pushdecl_function_level (base_decl);
 296       DECL_IGNORED_P (base_decl) = 1;
 297       DECL_ARTIFICIAL (base_decl) = 1;
 298     }
 299
 300   return decl;
 301 }
 302
 303 /* Called during genericization for every variable.  If the variable
 304    is a temporary of pointer type, replace it with a common variable
 305    thath is used to hold all pointer types that are ever stored in
 306    that slot.  Set WANT_LVALUE if you want a variable that is to be
 307    written to.  */
 308
 309 static tree
 310 java_replace_reference (tree var_decl, bool want_lvalue)
 311 {
 312   tree decl_type;
 313
 314   if (! base_decl_map)
 315     return var_decl;
 316
 317   decl_type = TREE_TYPE (var_decl);
 318
 319   if (TREE_CODE (decl_type) == POINTER_TYPE)
 320     {
 321       if (DECL_LANG_SPECIFIC (var_decl)
 322           && LOCAL_SLOT_P (var_decl))
 323         {
 324           int index = DECL_LOCAL_SLOT_NUMBER (var_decl);
 325           tree base_decl = TREE_VEC_ELT (base_decl_map, index);
 326
 327           gcc_assert (base_decl);
 328           if (! want_lvalue)
 329             base_decl = build1 (NOP_EXPR, decl_type, base_decl);
 330
 331           return base_decl;
 332         }
 333     }
 334
 335   return var_decl;
 336 }
 337
 338 /* Helper for java_genericize.  */
 339
 340 tree
 341 java_replace_references (tree *tp, int *walk_subtrees,
 342                          void *data ATTRIBUTE_UNUSED)
 343 {
 344   if (TREE_CODE (*tp) == MODIFY_EXPR)
 345     {
 346       source_location loc = EXPR_LOCATION (*tp);
 347       tree lhs = TREE_OPERAND (*tp, 0);
 348       /* This is specific to the bytecode compiler.  If a variable has
 349          LOCAL_SLOT_P set, replace an assignment to it with an assignment
 350          to the corresponding variable that holds all its aliases.  */
 351       if (TREE_CODE (lhs) == VAR_DECL
 352           && DECL_LANG_SPECIFIC (lhs)
 353           && LOCAL_SLOT_P (lhs)
 354           && TREE_CODE (TREE_TYPE (lhs)) == POINTER_TYPE)
 355         {
 356           tree new_lhs = java_replace_reference (lhs, /* want_lvalue */ true);
 357           tree new_rhs = build1 (NOP_EXPR, TREE_TYPE (new_lhs),
 358                                  TREE_OPERAND (*tp, 1));
 359           tree tem = build2 (MODIFY_EXPR, TREE_TYPE (new_lhs),
 360                              new_lhs, new_rhs);
 361           *tp = build1 (NOP_EXPR, TREE_TYPE (lhs), tem);
 362           SET_EXPR_LOCATION (tem, loc);
 363           SET_EXPR_LOCATION (new_rhs, loc);
 364           SET_EXPR_LOCATION (*tp, loc);
 365         }
 366     }
 367   if (TREE_CODE (*tp) == VAR_DECL)
 368     {
 369       *tp = java_replace_reference (*tp, /* want_lvalue */ false);
 370       *walk_subtrees = 0;
 371     }
 372
 373   return NULL_TREE;
 374 }
 375
 376 /* Same as find_local_index, except that INDEX is a stack index. */
 377
 378 tree
 379 find_stack_slot (int index, tree type)
 380 {
 381   return find_local_variable (index + DECL_MAX_LOCALS (current_function_decl),
 382                               type, -1);
 383 }
 384
 385 struct GTY(())
 386   binding_level {
 387     /* A chain of _DECL nodes for all variables, constants, functions,
 388      * and typedef types.  These are in the reverse of the order supplied.
 389      */
 390     tree names;
 391
 392     /* For each level, a list of shadowed outer-level local definitions
 393        to be restored when this level is popped.
 394        Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
 395        whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
 396     tree shadowed;
 397
 398     /* For each level (except not the global one),
 399        a chain of BLOCK nodes for all the levels
 400        that were entered and exited one level down.  */
 401     tree blocks;
 402
 403     /* The binding level which this one is contained in (inherits from).  */
 404     struct binding_level *level_chain;
 405
 406     /* The bytecode PC that marks the end of this level. */
 407     int end_pc;
 408     /* The bytecode PC that marks the start of this level. */
 409     int start_pc;
 410
 411     /* The statements in this binding level.  */
 412     tree stmts;
 413
 414     /* An exception range associated with this binding level.  */
 415     struct eh_range * GTY((skip (""))) exception_range;
 416
 417     /* Binding depth at which this level began.  Used only for debugging.  */
 418     unsigned binding_depth;
 419
 420     /* The location at which this level began.  */
 421     source_location loc;
 422   };
 423
 424 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
 425
 426 /* The binding level currently in effect.  */
 427
 428 static GTY(()) struct binding_level *current_binding_level;
 429
 430 /* A chain of binding_level structures awaiting reuse.  */
 431
 432 static GTY(()) struct binding_level *free_binding_level;
 433
 434 /* The outermost binding level, for names of file scope.
 435    This is created when the compiler is started and exists
 436    through the entire run.  */
 437
 438 static GTY(()) struct binding_level *global_binding_level;
 439
 440 /* The binding level that holds variables declared at the outermost
 441    level within a function body.  */
 442
 443 static struct binding_level *function_binding_level;
 444
 445 /* A PC value bigger than any PC value we may ever may encounter. */
 446
 447 #define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
 448
 449 /* Binding level structures are initialized by copying this one.  */
 450
 451 static const struct binding_level clear_binding_level
 452 = {
 453     NULL_TREE, /* names */
 454     NULL_TREE, /* shadowed */
 455     NULL_TREE, /* blocks */
 456     NULL_BINDING_LEVEL, /* level_chain */
 457     LARGEST_PC, /* end_pc */
 458     0, /* start_pc */
 459     NULL, /* stmts */
 460     NULL, /* exception_range */
 461     0, /* binding_depth */
 462     0, /* loc */
 463   };
 464
 465 tree java_global_trees[JTI_MAX];
 466
 467 /* Build (and pushdecl) a "promoted type" for all standard
 468    types shorter than int.  */
 469
 470 static tree
 471 push_promoted_type (const char *name, tree actual_type)
 472 {
 473   tree type = make_node (TREE_CODE (actual_type));
 474 #if 1
 475   tree in_min = TYPE_MIN_VALUE (int_type_node);
 476   tree in_max = TYPE_MAX_VALUE (int_type_node);
 477 #else
 478   tree in_min = TYPE_MIN_VALUE (actual_type);
 479   tree in_max = TYPE_MAX_VALUE (actual_type);
 480 #endif
 481   TYPE_MIN_VALUE (type) = copy_node (in_min);
 482   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
 483   TYPE_MAX_VALUE (type) = copy_node (in_max);
 484   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
 485   TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node);
 486   TYPE_STRING_FLAG (type) = TYPE_STRING_FLAG (actual_type);
 487   layout_type (type);
 488   pushdecl (build_decl (input_location,
 489                         TYPE_DECL, get_identifier (name), type));
 490   return type;
 491 }
 492
 493 /* Return tree that represents a vtable for a primitive array.  */
 494 static tree
 495 create_primitive_vtable (const char *name)
 496 {
 497   tree r;
 498   char buf[50];
 499
 500   sprintf (buf, "_Jv_%sVTable", name);
 501   r = build_decl (input_location,
 502                   VAR_DECL, get_identifier (buf), ptr_type_node);
 503   DECL_EXTERNAL (r) = 1;
 504   return r;
 505 }
 506
 507 /* Parse the version string and compute the ABI version number.  */
 508 static void
 509 parse_version (void)
 510 {
 511   const char *p = version_string;
 512   unsigned int major = 0, minor = 0;
 513   unsigned int abi_version;
 514
 515   /* Skip leading junk.  */
 516   while (*p && !ISDIGIT (*p))
 517     ++p;
 518   gcc_assert (*p);
 519
 520   /* Extract major version.  */
 521   while (ISDIGIT (*p))
 522     {
 523       major = major * 10 + *p - '0';
 524       ++p;
 525     }
 526
 527   gcc_assert (*p == '.' && ISDIGIT (p[1]));
 528   ++p;
 529
 530   /* Extract minor version.  */
 531   while (ISDIGIT (*p))
 532     {
 533       minor = minor * 10 + *p - '0';
 534       ++p;
 535     }
 536
 537   if (flag_indirect_dispatch)
 538     {
 539       abi_version = GCJ_CURRENT_BC_ABI_VERSION;
 540       abi_version |= FLAG_BINARYCOMPAT_ABI;
 541     }
 542   else /* C++ ABI */
 543     {
 544       /* Implicit in this computation is the idea that we won't break the
 545          old-style binary ABI in a sub-minor release (e.g., from 4.0.0 to
 546          4.0.1).  */
 547       abi_version = 100000 * major + 1000 * minor;
 548     }
 549   if (flag_bootstrap_classes)
 550     abi_version |= FLAG_BOOTSTRAP_LOADER;
 551
 552   gcj_abi_version = build_int_cstu (ptr_type_node, abi_version);
 553 }
 554
 555 void
 556 java_init_decl_processing (void)
 557 {
 558   tree field = NULL_TREE;
 559   tree t;
 560
 561   init_class_processing ();
 562
 563   current_function_decl = NULL;
 564   current_binding_level = NULL_BINDING_LEVEL;
 565   free_binding_level = NULL_BINDING_LEVEL;
 566   pushlevel (0);        /* make the binding_level structure for global names */
 567   global_binding_level = current_binding_level;
 568
 569   /* The code here must be similar to build_common_tree_nodes{,_2} in
 570      tree.c, especially as to the order of initializing common nodes.  */
 571   error_mark_node = make_node (ERROR_MARK);
 572   TREE_TYPE (error_mark_node) = error_mark_node;
 573
 574   /* Create sizetype first - needed for other types. */
 575   initialize_sizetypes ();
 576
 577   byte_type_node = make_signed_type (8);
 578   pushdecl (build_decl (BUILTINS_LOCATION,
 579                         TYPE_DECL, get_identifier ("byte"), byte_type_node));
 580   short_type_node = make_signed_type (16);
 581   pushdecl (build_decl (BUILTINS_LOCATION,
 582                         TYPE_DECL, get_identifier ("short"), short_type_node));
 583   int_type_node = make_signed_type (32);
 584   pushdecl (build_decl (BUILTINS_LOCATION,
 585                         TYPE_DECL, get_identifier ("int"), int_type_node));
 586   long_type_node = make_signed_type (64);
 587   pushdecl (build_decl (BUILTINS_LOCATION,
 588                         TYPE_DECL, get_identifier ("long"), long_type_node));
 589
 590   unsigned_byte_type_node = make_unsigned_type (8);
 591   pushdecl (build_decl (BUILTINS_LOCATION,
 592                         TYPE_DECL, get_identifier ("unsigned byte"),
 593                         unsigned_byte_type_node));
 594   unsigned_short_type_node = make_unsigned_type (16);
 595   pushdecl (build_decl (BUILTINS_LOCATION,
 596                         TYPE_DECL, get_identifier ("unsigned short"),
 597                         unsigned_short_type_node));
 598   unsigned_int_type_node = make_unsigned_type (32);
 599   pushdecl (build_decl (BUILTINS_LOCATION,
 600                         TYPE_DECL, get_identifier ("unsigned int"),
 601                         unsigned_int_type_node));
 602   unsigned_long_type_node = make_unsigned_type (64);
 603   pushdecl (build_decl (BUILTINS_LOCATION,
 604                         TYPE_DECL, get_identifier ("unsigned long"),
 605                         unsigned_long_type_node));
 606
 607   /* This is not a java type, however tree-dfa requires a definition for
 608      size_type_node.  */
 609   size_type_node = make_unsigned_type (POINTER_SIZE);
 610   set_sizetype (size_type_node);
 611
 612   /* Define these next since types below may used them.  */
 613   integer_type_node = java_type_for_size (INT_TYPE_SIZE, 0);
 614   integer_zero_node = build_int_cst (NULL_TREE, 0);
 615   integer_one_node = build_int_cst (NULL_TREE, 1);
 616   integer_two_node = build_int_cst (NULL_TREE, 2);
 617   integer_three_node = build_int_cst (NULL_TREE, 3);
 618   integer_four_node = build_int_cst (NULL_TREE, 4);
 619   integer_minus_one_node = build_int_cst (NULL_TREE, -1);
 620
 621   /* A few values used for range checking in the lexer.  */
 622   decimal_int_max = build_int_cstu (unsigned_int_type_node, 0x80000000);
 623   decimal_long_max
 624     = double_int_to_tree (unsigned_long_type_node,
 625                           double_int_setbit (double_int_zero, 64));
 626
 627   size_zero_node = size_int (0);
 628   size_one_node = size_int (1);
 629   bitsize_zero_node = bitsize_int (0);
 630   bitsize_one_node = bitsize_int (1);
 631   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
 632
 633   long_zero_node = build_int_cst (long_type_node, 0);
 634
 635   void_type_node = make_node (VOID_TYPE);
 636   pushdecl (build_decl (BUILTINS_LOCATION,
 637                         TYPE_DECL, get_identifier ("void"), void_type_node));
 638   layout_type (void_type_node); /* Uses size_zero_node */
 639
 640   ptr_type_node = build_pointer_type (void_type_node);
 641   const_ptr_type_node
 642     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
 643
 644   t = make_node (VOID_TYPE);
 645   layout_type (t); /* Uses size_zero_node */
 646   return_address_type_node = build_pointer_type (t);
 647
 648   null_pointer_node = build_int_cst (ptr_type_node, 0);
 649
 650   char_type_node = make_node (INTEGER_TYPE);
 651   TYPE_STRING_FLAG (char_type_node) = 1;
 652   TYPE_PRECISION (char_type_node) = 16;
 653   fixup_unsigned_type (char_type_node);
 654   pushdecl (build_decl (BUILTINS_LOCATION,
 655                         TYPE_DECL, get_identifier ("char"), char_type_node));
 656
 657   boolean_type_node = make_node (BOOLEAN_TYPE);
 658   TYPE_PRECISION (boolean_type_node) = 1;
 659   fixup_unsigned_type (boolean_type_node);
 660   pushdecl (build_decl (BUILTINS_LOCATION,
 661                         TYPE_DECL, get_identifier ("boolean"),
 662                         boolean_type_node));
 663   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
 664   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
 665
 666   promoted_byte_type_node
 667     = push_promoted_type ("promoted_byte", byte_type_node);
 668   promoted_short_type_node
 669     = push_promoted_type ("promoted_short", short_type_node);
 670   promoted_char_type_node
 671     = push_promoted_type ("promoted_char", char_type_node);
 672   promoted_boolean_type_node
 673     = push_promoted_type ("promoted_boolean", boolean_type_node);
 674
 675   float_type_node = make_node (REAL_TYPE);
 676   TYPE_PRECISION (float_type_node) = 32;
 677   pushdecl (build_decl (BUILTINS_LOCATION,
 678                         TYPE_DECL, get_identifier ("float"),
 679                         float_type_node));
 680   layout_type (float_type_node);
 681
 682   double_type_node = make_node (REAL_TYPE);
 683   TYPE_PRECISION (double_type_node) = 64;
 684   pushdecl (build_decl (BUILTINS_LOCATION,
 685                         TYPE_DECL, get_identifier ("double"),
 686                         double_type_node));
 687   layout_type (double_type_node);
 688
 689   float_zero_node = build_real (float_type_node, dconst0);
 690   double_zero_node = build_real (double_type_node, dconst0);
 691
 692   /* These are the vtables for arrays of primitives.  */
 693   boolean_array_vtable = create_primitive_vtable ("boolean");
 694   byte_array_vtable = create_primitive_vtable ("byte");
 695   char_array_vtable = create_primitive_vtable ("char");
 696   short_array_vtable = create_primitive_vtable ("short");
 697   int_array_vtable = create_primitive_vtable ("int");
 698   long_array_vtable = create_primitive_vtable ("long");
 699   float_array_vtable = create_primitive_vtable ("float");
 700   double_array_vtable = create_primitive_vtable ("double");
 701
 702   one_elt_array_domain_type = build_index_type (integer_one_node);
 703   utf8const_type = make_node (RECORD_TYPE);
 704   PUSH_FIELD (input_location,
 705               utf8const_type, field, "hash", unsigned_short_type_node);
 706   PUSH_FIELD (input_location,
 707               utf8const_type, field, "length", unsigned_short_type_node);
 708   FINISH_RECORD (utf8const_type);
 709   utf8const_ptr_type = build_pointer_type (utf8const_type);
 710
 711   atable_type = build_array_type (ptr_type_node,
 712                                   one_elt_array_domain_type);
 713   TYPE_NONALIASED_COMPONENT (atable_type) = 1;
 714   atable_ptr_type = build_pointer_type (atable_type);
 715
 716   itable_type = build_array_type (ptr_type_node,
 717                                   one_elt_array_domain_type);
 718   TYPE_NONALIASED_COMPONENT (itable_type) = 1;
 719   itable_ptr_type = build_pointer_type (itable_type);
 720
 721   symbol_type = make_node (RECORD_TYPE);
 722   PUSH_FIELD (input_location,
 723               symbol_type, field, "clname", utf8const_ptr_type);
 724   PUSH_FIELD (input_location, symbol_type, field, "name", utf8const_ptr_type);
 725   PUSH_FIELD (input_location,
 726               symbol_type, field, "signature", utf8const_ptr_type);
 727   FINISH_RECORD (symbol_type);
 728
 729   symbols_array_type = build_array_type (symbol_type,
 730                                          one_elt_array_domain_type);
 731   symbols_array_ptr_type = build_pointer_type (symbols_array_type);
 732
 733   assertion_entry_type = make_node (RECORD_TYPE);
 734   PUSH_FIELD (input_location,
 735               assertion_entry_type, field, "assertion_code", integer_type_node);
 736   PUSH_FIELD (input_location,
 737               assertion_entry_type, field, "op1", utf8const_ptr_type);
 738   PUSH_FIELD (input_location,
 739               assertion_entry_type, field, "op2", utf8const_ptr_type);
 740   FINISH_RECORD (assertion_entry_type);
 741
 742   assertion_table_type = build_array_type (assertion_entry_type,
 743                                            one_elt_array_domain_type);
 744
 745   /* As you're adding items here, please update the code right after
 746      this section, so that the filename containing the source code of
 747      the pre-defined class gets registered correctly. */
 748   unqualified_object_id_node = get_identifier ("Object");
 749   object_type_node = lookup_class (get_identifier ("java.lang.Object"));
 750   object_ptr_type_node = promote_type (object_type_node);
 751   string_type_node = lookup_class (get_identifier ("java.lang.String"));
 752   string_ptr_type_node = promote_type (string_type_node);
 753   class_type_node = lookup_class (get_identifier ("java.lang.Class"));
 754   throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable"));
 755   exception_type_node = lookup_class (get_identifier ("java.lang.Exception"));
 756   runtime_exception_type_node =
 757     lookup_class (get_identifier ("java.lang.RuntimeException"));
 758   error_exception_type_node =
 759     lookup_class (get_identifier ("java.lang.Error"));
 760
 761   rawdata_ptr_type_node
 762     = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
 763
 764   add_predefined_file (get_identifier ("java/lang/Class.java"));
 765   add_predefined_file (get_identifier ("java/lang/Error.java"));
 766   add_predefined_file (get_identifier ("java/lang/Object.java"));
 767   add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
 768   add_predefined_file (get_identifier ("java/lang/String.java"));
 769   add_predefined_file (get_identifier ("java/lang/Throwable.java"));
 770   add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
 771   add_predefined_file (get_identifier ("java/lang/Exception.java"));
 772   add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
 773   add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
 774
 775   methodtable_type = make_node (RECORD_TYPE);
 776   layout_type (methodtable_type);
 777   build_decl (BUILTINS_LOCATION,
 778               TYPE_DECL, get_identifier ("methodtable"), methodtable_type);
 779   methodtable_ptr_type = build_pointer_type (methodtable_type);
 780
 781   TYPE_identifier_node = get_identifier ("TYPE");
 782   init_identifier_node = get_identifier ("<init>");
 783   clinit_identifier_node = get_identifier ("<clinit>");
 784   void_signature_node = get_identifier ("()V");
 785   finalize_identifier_node = get_identifier ("finalize");
 786   this_identifier_node = get_identifier ("this");
 787
 788   java_lang_cloneable_identifier_node = get_identifier ("java.lang.Cloneable");
 789   java_io_serializable_identifier_node =
 790     get_identifier ("java.io.Serializable");
 791
 792   /* for lack of a better place to put this stub call */
 793   init_expr_processing();
 794
 795   constants_type_node = make_node (RECORD_TYPE);
 796   PUSH_FIELD (input_location,
 797               constants_type_node, field, "size", unsigned_int_type_node);
 798   PUSH_FIELD (input_location,
 799               constants_type_node, field, "tags", ptr_type_node);
 800   PUSH_FIELD (input_location,
 801               constants_type_node, field, "data", ptr_type_node);
 802   constants_data_field_decl_node = field;
 803   FINISH_RECORD (constants_type_node);
 804   build_decl (BUILTINS_LOCATION,
 805               TYPE_DECL, get_identifier ("constants"), constants_type_node);
 806
 807   access_flags_type_node = unsigned_short_type_node;
 808
 809   dtable_type = make_node (RECORD_TYPE);
 810   dtable_ptr_type = build_pointer_type (dtable_type);
 811
 812   otable_type = build_array_type (integer_type_node,
 813                                   one_elt_array_domain_type);
 814   TYPE_NONALIASED_COMPONENT (otable_type) = 1;
 815   otable_ptr_type = build_pointer_type (otable_type);
 816
 817   PUSH_FIELD (input_location,
 818               object_type_node, field, "vtable", dtable_ptr_type);
 819   DECL_FCONTEXT (field) = object_type_node;
 820   TYPE_VFIELD (object_type_node) = field;
 821
 822   /* This isn't exactly true, but it is what we have in the source.
 823      There is an unresolved issue here, which is whether the vtable
 824      should be marked by the GC.  */
 825   if (! flag_hash_synchronization)
 826     PUSH_FIELD (input_location, object_type_node, field, "sync_info",
 827                 build_pointer_type (object_type_node));
 828   for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = DECL_CHAIN (t))
 829     FIELD_PRIVATE (t) = 1;
 830   FINISH_RECORD (object_type_node);
 831
 832   field_type_node = make_node (RECORD_TYPE);
 833   field_ptr_type_node = build_pointer_type (field_type_node);
 834   method_type_node = make_node (RECORD_TYPE);
 835   method_ptr_type_node = build_pointer_type (method_type_node);
 836
 837   set_super_info (0, class_type_node, object_type_node, 0);
 838   set_super_info (0, string_type_node, object_type_node, 0);
 839   class_ptr_type = build_pointer_type (class_type_node);
 840
 841   PUSH_FIELD (input_location,
 842               class_type_node, field, "next_or_version", class_ptr_type);
 843   PUSH_FIELD (input_location,
 844               class_type_node, field, "name", utf8const_ptr_type);
 845   PUSH_FIELD (input_location,
 846               class_type_node, field, "accflags", access_flags_type_node);
 847   PUSH_FIELD (input_location,
 848               class_type_node, field, "superclass", class_ptr_type);
 849   PUSH_FIELD (input_location,
 850               class_type_node, field, "constants", constants_type_node);
 851   constants_field_decl_node = field;
 852   PUSH_FIELD (input_location,
 853               class_type_node, field, "methods", method_ptr_type_node);
 854   PUSH_FIELD (input_location,
 855               class_type_node, field, "method_count", short_type_node);
 856   PUSH_FIELD (input_location,
 857               class_type_node, field, "vtable_method_count", short_type_node);
 858   PUSH_FIELD (input_location,
 859               class_type_node, field, "fields", field_ptr_type_node);
 860   PUSH_FIELD (input_location,
 861               class_type_node, field, "size_in_bytes", int_type_node);
 862   PUSH_FIELD (input_location,
 863               class_type_node, field, "field_count", short_type_node);
 864   PUSH_FIELD (input_location,
 865               class_type_node, field, "static_field_count", short_type_node);
 866   PUSH_FIELD (input_location,
 867               class_type_node, field, "vtable", dtable_ptr_type);
 868   PUSH_FIELD (input_location,
 869               class_type_node, field, "otable", otable_ptr_type);
 870   PUSH_FIELD (input_location,
 871               class_type_node, field, "otable_syms",
 872               symbols_array_ptr_type);
 873   PUSH_FIELD (input_location,
 874               class_type_node, field, "atable", atable_ptr_type);
 875   PUSH_FIELD (input_location,
 876               class_type_node, field, "atable_syms",
 877               symbols_array_ptr_type);
 878   PUSH_FIELD (input_location,
 879               class_type_node, field, "itable", itable_ptr_type);
 880   PUSH_FIELD (input_location, class_type_node, field, "itable_syms",
 881               symbols_array_ptr_type);
 882   PUSH_FIELD (input_location,
 883               class_type_node, field, "catch_classes", ptr_type_node);
 884   PUSH_FIELD (input_location, class_type_node, field, "interfaces",
 885               build_pointer_type (class_ptr_type));
 886   PUSH_FIELD (input_location, class_type_node, field, "loader", ptr_type_node);
 887   PUSH_FIELD (input_location,
 888               class_type_node, field, "interface_count", short_type_node);
 889   PUSH_FIELD (input_location, class_type_node, field, "state", byte_type_node);
 890   PUSH_FIELD (input_location, class_type_node, field, "thread", ptr_type_node);
 891   PUSH_FIELD (input_location,
 892               class_type_node, field, "depth", short_type_node);
 893   PUSH_FIELD (input_location,
 894               class_type_node, field, "ancestors", ptr_type_node);
 895   PUSH_FIELD (input_location, class_type_node, field, "idt", ptr_type_node);
 896   PUSH_FIELD (input_location,
 897               class_type_node, field, "arrayclass", ptr_type_node);
 898   PUSH_FIELD (input_location,
 899               class_type_node, field, "protectionDomain", ptr_type_node);
 900   PUSH_FIELD (input_location,
 901               class_type_node, field, "assertion_table", ptr_type_node);
 902   PUSH_FIELD (input_location,
 903               class_type_node, field, "hack_signers", ptr_type_node);
 904   PUSH_FIELD (input_location, class_type_node, field, "chain", ptr_type_node);
 905   PUSH_FIELD (input_location,
 906               class_type_node, field, "aux_info", ptr_type_node);
 907   PUSH_FIELD (input_location, class_type_node, field, "engine", ptr_type_node);
 908   PUSH_FIELD (input_location,
 909               class_type_node, field, "reflection_data", ptr_type_node);
 910   for (t = TYPE_FIELDS (class_type_node);  t != NULL_TREE;  t = DECL_CHAIN (t))
 911     FIELD_PRIVATE (t) = 1;
 912   push_super_field (class_type_node, object_type_node);
 913
 914   FINISH_RECORD (class_type_node);
 915   build_decl (BUILTINS_LOCATION,
 916               TYPE_DECL, get_identifier ("Class"), class_type_node);
 917
 918   field_info_union_node = make_node (UNION_TYPE);
 919   PUSH_FIELD (input_location,
 920               field_info_union_node, field, "boffset", int_type_node);
 921   PUSH_FIELD (input_location,
 922               field_info_union_node, field, "addr", ptr_type_node);
 923   layout_type (field_info_union_node);
 924
 925   PUSH_FIELD (input_location,
 926               field_type_node, field, "name", utf8const_ptr_type);
 927   PUSH_FIELD (input_location, field_type_node, field, "type", class_ptr_type);
 928   PUSH_FIELD (input_location,
 929               field_type_node, field, "accflags", access_flags_type_node);
 930   PUSH_FIELD (input_location,
 931               field_type_node, field, "bsize", unsigned_short_type_node);
 932   PUSH_FIELD (input_location,
 933               field_type_node, field, "info", field_info_union_node);
 934   FINISH_RECORD (field_type_node);
 935   build_decl (BUILTINS_LOCATION,
 936               TYPE_DECL, get_identifier ("Field"), field_type_node);
 937
 938   nativecode_ptr_array_type_node
 939     = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type);
 940
 941   PUSH_FIELD (input_location,
 942               dtable_type, field, "class", class_ptr_type);
 943   PUSH_FIELD (input_location,
 944               dtable_type, field, "methods", nativecode_ptr_array_type_node);
 945   FINISH_RECORD (dtable_type);
 946   build_decl (BUILTINS_LOCATION,
 947               TYPE_DECL, get_identifier ("dispatchTable"), dtable_type);
 948
 949   jexception_type = make_node (RECORD_TYPE);
 950   PUSH_FIELD (input_location,
 951               jexception_type, field, "start_pc", ptr_type_node);
 952   PUSH_FIELD (input_location, jexception_type, field, "end_pc", ptr_type_node);
 953   PUSH_FIELD (input_location,
 954               jexception_type, field, "handler_pc", ptr_type_node);
 955   PUSH_FIELD (input_location,
 956               jexception_type, field, "catch_type", class_ptr_type);
 957   FINISH_RECORD (jexception_type);
 958   build_decl (BUILTINS_LOCATION,
 959               TYPE_DECL, get_identifier ("jexception"), field_type_node);
 960   jexception_ptr_type = build_pointer_type (jexception_type);
 961
 962   lineNumberEntry_type = make_node (RECORD_TYPE);
 963   PUSH_FIELD (input_location,
 964               lineNumberEntry_type, field, "line_nr", unsigned_short_type_node);
 965   PUSH_FIELD (input_location,
 966               lineNumberEntry_type, field, "start_pc", ptr_type_node);
 967   FINISH_RECORD (lineNumberEntry_type);
 968
 969   lineNumbers_type = make_node (RECORD_TYPE);
 970   PUSH_FIELD (input_location,
 971               lineNumbers_type, field, "length", unsigned_int_type_node);
 972   FINISH_RECORD (lineNumbers_type);
 973
 974   PUSH_FIELD (input_location,
 975               method_type_node, field, "name", utf8const_ptr_type);
 976   PUSH_FIELD (input_location,
 977               method_type_node, field, "signature", utf8const_ptr_type);
 978   PUSH_FIELD (input_location,
 979               method_type_node, field, "accflags", access_flags_type_node);
 980   PUSH_FIELD (input_location,
 981               method_type_node, field, "index", unsigned_short_type_node);
 982   PUSH_FIELD (input_location,
 983               method_type_node, field, "ncode", nativecode_ptr_type_node);
 984   PUSH_FIELD (input_location,
 985               method_type_node, field, "throws", ptr_type_node);
 986   FINISH_RECORD (method_type_node);
 987   build_decl (BUILTINS_LOCATION,
 988               TYPE_DECL, get_identifier ("Method"), method_type_node);
 989
 990   end_params_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
 991
 992   t = build_function_type_list (ptr_type_node, class_ptr_type, NULL_TREE);
 993   alloc_object_node = add_builtin_function ("_Jv_AllocObject", t,
 994                                             0, NOT_BUILT_IN, NULL, NULL_TREE);
 995   DECL_IS_MALLOC (alloc_object_node) = 1;
 996   alloc_no_finalizer_node =
 997     add_builtin_function ("_Jv_AllocObjectNoFinalizer", t,
 998                           0, NOT_BUILT_IN, NULL, NULL_TREE);
 999   DECL_IS_MALLOC (alloc_no_finalizer_node) = 1;
1000
1001   t = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
1002   soft_initclass_node = add_builtin_function ("_Jv_InitClass", t,
1003                                               0, NOT_BUILT_IN, NULL, NULL_TREE);
1004   t = build_function_type_list (ptr_type_node,
1005                                 class_ptr_type, int_type_node, NULL_TREE);
1006   soft_resolvepoolentry_node
1007     = add_builtin_function ("_Jv_ResolvePoolEntry", t,
1008                             0,NOT_BUILT_IN, NULL, NULL_TREE);
1009   DECL_PURE_P (soft_resolvepoolentry_node) = 1;
1010   t = build_function_type_list (void_type_node,
1011                                 class_ptr_type, int_type_node, NULL_TREE);
1012   throw_node = add_builtin_function ("_Jv_Throw", t,
1013                                      0, NOT_BUILT_IN, NULL, NULL_TREE);
1014   /* Mark throw_nodes as `noreturn' functions with side effects.  */
1015   TREE_THIS_VOLATILE (throw_node) = 1;
1016   TREE_SIDE_EFFECTS (throw_node) = 1;
1017
1018   t = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
1019   soft_monitorenter_node
1020     = add_builtin_function ("_Jv_MonitorEnter", t, 0, NOT_BUILT_IN,
1021                             NULL, NULL_TREE);
1022   soft_monitorexit_node
1023     = add_builtin_function ("_Jv_MonitorExit", t, 0, NOT_BUILT_IN,
1024                             NULL, NULL_TREE);
1025
1026   t = build_function_type_list (ptr_type_node,
1027                                 ptr_type_node, int_type_node, NULL_TREE);
1028   soft_newarray_node
1029       = add_builtin_function ("_Jv_NewPrimArray", t,
1030                               0, NOT_BUILT_IN, NULL, NULL_TREE);
1031   DECL_IS_MALLOC (soft_newarray_node) = 1;
1032
1033   t = build_function_type_list (ptr_type_node,
1034                                 int_type_node, class_ptr_type,
1035                                 object_ptr_type_node, NULL_TREE);
1036   soft_anewarray_node
1037       = add_builtin_function ("_Jv_NewObjectArray", t,
1038                               0, NOT_BUILT_IN, NULL, NULL_TREE);
1039   DECL_IS_MALLOC (soft_anewarray_node) = 1;
1040
1041   t = build_varargs_function_type_list (ptr_type_node,
1042                                         ptr_type_node, int_type_node,
1043                                         NULL_TREE);
1044   soft_multianewarray_node
1045       = add_builtin_function ("_Jv_NewMultiArray", t,
1046                               0, NOT_BUILT_IN, NULL, NULL_TREE);
1047   DECL_IS_MALLOC (soft_multianewarray_node) = 1;
1048
1049   t = build_function_type_list (void_type_node, int_type_node, NULL_TREE);
1050   soft_badarrayindex_node
1051       = add_builtin_function ("_Jv_ThrowBadArrayIndex", t,
1052                               0, NOT_BUILT_IN, NULL, NULL_TREE);
1053   /* Mark soft_badarrayindex_node as a `noreturn' function with side
1054      effects.  */
1055   TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
1056   TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
1057
1058   t = build_function_type_list (void_type_node, NULL_TREE);
1059   soft_nullpointer_node
1060     = add_builtin_function ("_Jv_ThrowNullPointerException", t,
1061                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1062   /* Mark soft_nullpointer_node as a `noreturn' function with side
1063      effects.  */
1064   TREE_THIS_VOLATILE (soft_nullpointer_node) = 1;
1065   TREE_SIDE_EFFECTS (soft_nullpointer_node) = 1;
1066
1067   soft_abstractmethod_node
1068     = add_builtin_function ("_Jv_ThrowAbstractMethodError", t,
1069                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1070   /* Mark soft_abstractmethod_node as a `noreturn' function with side
1071      effects.  */
1072   TREE_THIS_VOLATILE (soft_abstractmethod_node) = 1;
1073   TREE_SIDE_EFFECTS (soft_abstractmethod_node) = 1;
1074
1075   soft_nosuchfield_node
1076     = add_builtin_function ("_Jv_ThrowNoSuchFieldError", t,
1077                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1078   /* Mark soft_nosuchfield_node as a `noreturn' function with side
1079      effects.  */
1080   TREE_THIS_VOLATILE (soft_nosuchfield_node) = 1;
1081   TREE_SIDE_EFFECTS (soft_nosuchfield_node) = 1;
1082
1083   t = build_function_type_list (ptr_type_node,
1084                                 class_ptr_type, object_ptr_type_node,
1085                                 NULL_TREE);
1086   soft_checkcast_node
1087     = add_builtin_function ("_Jv_CheckCast", t,
1088                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1089   t = build_function_type_list (boolean_type_node,
1090                                 object_ptr_type_node, class_ptr_type,
1091                                 NULL_TREE);
1092   soft_instanceof_node
1093     = add_builtin_function ("_Jv_IsInstanceOf", t,
1094                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1095   DECL_PURE_P (soft_instanceof_node) = 1;
1096   t = build_function_type_list (void_type_node,
1097                                 object_ptr_type_node, object_ptr_type_node,
1098                                 NULL_TREE);
1099   soft_checkarraystore_node
1100     = add_builtin_function ("_Jv_CheckArrayStore", t,
1101                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1102   t = build_function_type_list (ptr_type_node,
1103                                 ptr_type_node, ptr_type_node, int_type_node,
1104                                 NULL_TREE);
1105   soft_lookupinterfacemethod_node
1106     = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", t,
1107                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1108   DECL_PURE_P (soft_lookupinterfacemethod_node) = 1;
1109
1110   t = build_function_type_list (ptr_type_node,
1111                                 ptr_type_node, ptr_type_node, ptr_type_node,
1112                                 NULL_TREE);
1113   soft_lookupinterfacemethodbyname_node
1114     = add_builtin_function ("_Jv_LookupInterfaceMethod", t,
1115                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1116   t = build_function_type_list (ptr_type_node,
1117                                 object_ptr_type_node, ptr_type_node,
1118                                 ptr_type_node, int_type_node, NULL_TREE);
1119   soft_lookupjnimethod_node
1120     = add_builtin_function ("_Jv_LookupJNIMethod", t,
1121                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1122   t = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
1123   soft_getjnienvnewframe_node
1124     = add_builtin_function ("_Jv_GetJNIEnvNewFrame", t,
1125                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1126   t = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
1127   soft_jnipopsystemframe_node
1128     = add_builtin_function ("_Jv_JNI_PopSystemFrame", t,
1129                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1130
1131   t = build_function_type_list (object_ptr_type_node,
1132                                 object_ptr_type_node, NULL_TREE);
1133   soft_unwrapjni_node
1134     = add_builtin_function ("_Jv_UnwrapJNIweakReference", t,
1135                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1136
1137   t = build_function_type_list (int_type_node,
1138                                 int_type_node, int_type_node, NULL_TREE);
1139   soft_idiv_node
1140     = add_builtin_function ("_Jv_divI", t,
1141                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1142
1143   soft_irem_node
1144     = add_builtin_function ("_Jv_remI", t,
1145                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1146
1147   t = build_function_type_list (long_type_node,
1148                                 long_type_node, long_type_node, NULL_TREE);
1149   soft_ldiv_node
1150     = add_builtin_function ("_Jv_divJ", t,
1151                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1152
1153   soft_lrem_node
1154     = add_builtin_function ("_Jv_remJ", t,
1155                             0, NOT_BUILT_IN, NULL, NULL_TREE);
1156
1157   initialize_builtins ();
1158
1159   soft_fmod_node = built_in_decls[BUILT_IN_FMOD];
1160
1161   parse_version ();
1162 }
1163
1164
1165 /* Look up NAME in the current binding level and its superiors
1166    in the namespace of variables, functions and typedefs.
1167    Return a ..._DECL node of some kind representing its definition,
1168    or return 0 if it is undefined.  */
1169
1170 tree
1171 lookup_name (tree name)
1172 {
1173   tree val;
1174   if (current_binding_level != global_binding_level
1175       && IDENTIFIER_LOCAL_VALUE (name))
1176     val = IDENTIFIER_LOCAL_VALUE (name);
1177   else
1178     val = IDENTIFIER_GLOBAL_VALUE (name);
1179   return val;
1180 }
1181
1182 /* Similar to `lookup_name' but look only at current binding level and
1183    the previous one if it's the parameter level.  */
1184
1185 static tree
1186 lookup_name_current_level (tree name)
1187 {
1188   tree t;
1189
1190   if (current_binding_level == global_binding_level)
1191     return IDENTIFIER_GLOBAL_VALUE (name);
1192
1193   if (IDENTIFIER_LOCAL_VALUE (name) == 0)
1194     return 0;
1195
1196   for (t = current_binding_level->names; t; t = DECL_CHAIN (t))
1197     if (DECL_NAME (t) == name)
1198       break;
1199
1200   return t;
1201 }
1202
1203 /* Record a decl-node X as belonging to the current lexical scope.
1204    Check for errors (such as an incompatible declaration for the same
1205    name already seen in the same scope).
1206
1207    Returns either X or an old decl for the same name.
1208    If an old decl is returned, it may have been smashed
1209    to agree with what X says.  */
1210
1211 tree
1212 pushdecl (tree x)
1213 {
1214   tree t;
1215   tree name = DECL_NAME (x);
1216   struct binding_level *b = current_binding_level;
1217
1218   if (TREE_CODE (x) != TYPE_DECL)
1219     DECL_CONTEXT (x) = current_function_decl;
1220   if (name)
1221     {
1222       t = lookup_name_current_level (name);
1223       if (t != 0 && t == error_mark_node)
1224         /* error_mark_node is 0 for a while during initialization!  */
1225         {
1226           t = 0;
1227           error ("%q+D used prior to declaration", x);
1228         }
1229
1230       /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
1231          to point to the TYPE_DECL.
1232          Since Java does not have typedefs, a type can only have
1233          one (true) name, given by a class, interface, or builtin. */
1234       if (TREE_CODE (x) == TYPE_DECL
1235           && TYPE_NAME (TREE_TYPE (x)) == 0
1236           && TREE_TYPE (x) != error_mark_node)
1237         {
1238           TYPE_NAME (TREE_TYPE (x)) = x;
1239           TYPE_STUB_DECL (TREE_TYPE (x)) = x;
1240         }
1241
1242       /* This name is new in its binding level.
1243          Install the new declaration and return it.  */
1244       if (b == global_binding_level)
1245         {
1246           /* Install a global value.  */
1247
1248           IDENTIFIER_GLOBAL_VALUE (name) = x;
1249         }
1250       else
1251         {
1252           /* Here to install a non-global value.  */
1253           tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
1254           IDENTIFIER_LOCAL_VALUE (name) = x;
1255
1256           /* If storing a local value, there may already be one (inherited).
1257              If so, record it for restoration when this binding level ends.  */
1258           if (oldlocal != 0)
1259             b->shadowed = tree_cons (name, oldlocal, b->shadowed);
1260         }
1261     }
1262
1263   /* Put decls on list in reverse order.
1264      We will reverse them later if necessary.  */
1265   DECL_CHAIN (x) = b->names;
1266   b->names = x;
1267
1268   return x;
1269 }
1270
1271 void
1272 pushdecl_force_head (tree x)
1273 {
1274   current_binding_level->names = x;
1275 }
1276
1277 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate.  */
1278
1279 tree
1280 pushdecl_top_level (tree x)
1281 {
1282   tree t;
1283   struct binding_level *b = current_binding_level;
1284
1285   current_binding_level = global_binding_level;
1286   t = pushdecl (x);
1287   current_binding_level = b;
1288   return t;
1289 }
1290
1291 /* Like pushdecl, only it places X in FUNCTION_BINDING_LEVEL, if appropriate.  */
1292
1293 tree
1294 pushdecl_function_level (tree x)
1295 {
1296   tree t;
1297   struct binding_level *b = current_binding_level;
1298
1299   current_binding_level = function_binding_level;
1300   t = pushdecl (x);
1301   current_binding_level = b;
1302   return t;
1303 }
1304
1305 /* Return true if we are in the global binding level.  */
1306
1307 bool
1308 global_bindings_p (void)
1309 {
1310   return current_binding_level == global_binding_level;
1311 }
1312
1313 /* Return the list of declarations of the current level.
1314    Note that this list is in reverse order unless/until
1315    you nreverse it; and when you do nreverse it, you must
1316    store the result back using `storedecls' or you will lose.  */
1317
1318 tree
1319 getdecls (void)
1320 {
1321   return current_binding_level->names;
1322 }
1323
1324 /* Create a new `struct binding_level'.  */
1325
1326 static struct binding_level *
1327 make_binding_level (void)
1328 {
1329   /* NOSTRICT */
1330   return ggc_alloc_cleared_binding_level ();
1331 }
1332
1333 void
1334 pushlevel (int unused ATTRIBUTE_UNUSED)
1335 {
1336   struct binding_level *newlevel = NULL_BINDING_LEVEL;
1337
1338   /* Reuse or create a struct for this binding level.  */
1339
1340   if (free_binding_level)
1341     {
1342       newlevel = free_binding_level;
1343       free_binding_level = free_binding_level->level_chain;
1344     }
1345   else
1346     {
1347       newlevel = make_binding_level ();
1348     }
1349
1350   /* Add this level to the front of the chain (stack) of levels that
1351      are active.  */
1352
1353   *newlevel = clear_binding_level;
1354   newlevel->level_chain = current_binding_level;
1355   newlevel->loc = input_location;
1356   current_binding_level = newlevel;
1357 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1358   newlevel->binding_depth = binding_depth;
1359   indent ();
1360   fprintf (stderr, "push %s level %p pc %d\n",
1361            (is_class_level) ? "class" : "block", newlevel, current_pc);
1362   is_class_level = 0;
1363   binding_depth++;
1364 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1365 }
1366
1367 /* Exit a binding level.
1368    Pop the level off, and restore the state of the identifier-decl mappings
1369    that were in effect when this level was entered.
1370
1371    If KEEP is nonzero, this level had explicit declarations, so
1372    and create a "block" (a BLOCK node) for the level
1373    to record its declarations and subblocks for symbol table output.
1374
1375    If FUNCTIONBODY is nonzero, this level is the body of a function,
1376    so create a block as if KEEP were set and also clear out all
1377    label names.
1378
1379    If REVERSE is nonzero, reverse the order of decls before putting
1380    them into the BLOCK.  */
1381
1382 tree
1383 poplevel (int keep, int reverse, int functionbody)
1384 {
1385   tree link;
1386   /* The chain of decls was accumulated in reverse order.
1387      Put it into forward order, just for cleanliness.  */
1388   tree decls;
1389   tree subblocks = current_binding_level->blocks;
1390   tree block = 0;
1391   tree decl;
1392   tree bind = 0;
1393
1394 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1395   binding_depth--;
1396   indent ();
1397   if (current_binding_level->end_pc != LARGEST_PC)
1398     fprintf (stderr, "pop  %s level %p pc %d (end pc %d)\n",
1399              (is_class_level) ? "class" : "block", current_binding_level, current_pc,
1400              current_binding_level->end_pc);
1401   else
1402     fprintf (stderr, "pop  %s level %p pc %d\n",
1403              (is_class_level) ? "class" : "block", current_binding_level, current_pc);
1404 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1405
1406   /* Get the decls in the order they were written.
1407      Usually current_binding_level->names is in reverse order.
1408      But parameter decls were previously put in forward order.  */
1409
1410   if (reverse)
1411     current_binding_level->names
1412       = decls = nreverse (current_binding_level->names);
1413   else
1414     decls = current_binding_level->names;
1415
1416   for (decl = decls; decl; decl = DECL_CHAIN (decl))
1417     if (TREE_CODE (decl) == VAR_DECL
1418         && DECL_LANG_SPECIFIC (decl) != NULL
1419         && DECL_LOCAL_SLOT_NUMBER (decl))
1420       LOCAL_VAR_OUT_OF_SCOPE_P (decl) = 1;
1421
1422   /* If there were any declarations in that level,
1423      or if this level is a function body,
1424      create a BLOCK to record them for the life of this function.  */
1425
1426   block = 0;
1427   if (keep || functionbody)
1428     block = make_node (BLOCK);
1429
1430   if (current_binding_level->exception_range)
1431     expand_end_java_handler (current_binding_level->exception_range);
1432
1433   if (block != 0)
1434     {
1435       /* If any statements have been generated at this level, create a
1436          BIND_EXPR to hold them and copy the variables to it.  This
1437          only applies to the bytecode compiler.  */
1438       if (current_binding_level->stmts)
1439         {
1440           tree decl = decls;
1441           tree *var = &BLOCK_VARS (block);
1442
1443           /* Copy decls from names list, ignoring labels.  */
1444           while (decl)
1445             {
1446               tree next = DECL_CHAIN (decl);
1447               if (TREE_CODE (decl) != LABEL_DECL)
1448                 {
1449                   *var = decl;
1450                   var = &DECL_CHAIN (decl);
1451                 }
1452               decl = next;
1453             }
1454           *var = NULL;
1455
1456           bind = build3 (BIND_EXPR, void_type_node, BLOCK_VARS (block),
1457                          BLOCK_EXPR_BODY (block), block);
1458           BIND_EXPR_BODY (bind) = current_binding_level->stmts;
1459
1460           if (BIND_EXPR_BODY (bind)
1461               && TREE_SIDE_EFFECTS (BIND_EXPR_BODY (bind)))
1462             TREE_SIDE_EFFECTS (bind) = 1;
1463
1464           /* FIXME: gimplifier brain damage.  */
1465           if (BIND_EXPR_BODY (bind) == NULL)
1466             BIND_EXPR_BODY (bind) = build_java_empty_stmt ();
1467
1468           SET_EXPR_LOCATION (bind, current_binding_level->loc);
1469
1470           current_binding_level->stmts = NULL;
1471         }
1472       else
1473         {
1474           BLOCK_VARS (block) = decls;
1475         }
1476       BLOCK_SUBBLOCKS (block) = subblocks;
1477     }
1478
1479   /* In each subblock, record that this is its superior.  */
1480
1481   for (link = subblocks; link; link = BLOCK_CHAIN (link))
1482     BLOCK_SUPERCONTEXT (link) = block;
1483
1484   /* Clear out the meanings of the local variables of this level.  */
1485
1486   for (link = decls; link; link = DECL_CHAIN (link))
1487     {
1488       tree name = DECL_NAME (link);
1489       if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link)
1490         {
1491           /* If the ident. was used or addressed via a local extern decl,
1492              don't forget that fact.  */
1493           if (DECL_EXTERNAL (link))
1494             {
1495               if (TREE_USED (link))
1496                 TREE_USED (name) = 1;
1497               if (TREE_ADDRESSABLE (link))
1498                 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1499             }
1500           IDENTIFIER_LOCAL_VALUE (name) = 0;
1501         }
1502     }
1503
1504   /* Restore all name-meanings of the outer levels
1505      that were shadowed by this level.  */
1506
1507   for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1508     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1509
1510   /* If the level being exited is the top level of a function,
1511      check over all the labels, and clear out the current
1512      (function local) meanings of their names.  */
1513
1514   if (functionbody)
1515     {
1516       /* If this is the top level block of a function,
1517          the vars are the function's parameters.
1518          Don't leave them in the BLOCK because they are
1519          found in the FUNCTION_DECL instead.  */
1520
1521       BLOCK_VARS (block) = 0;
1522     }
1523
1524   /* Pop the current level, and free the structure for reuse.  */
1525
1526   {
1527     struct binding_level *level = current_binding_level;
1528     current_binding_level = current_binding_level->level_chain;
1529
1530     level->level_chain = free_binding_level;
1531     free_binding_level = level;
1532   }
1533
1534   /* Dispose of the block that we just made inside some higher level.  */
1535   if (functionbody)
1536     {
1537       DECL_INITIAL (current_function_decl) = block;
1538       DECL_SAVED_TREE (current_function_decl) = bind;
1539     }
1540   else
1541     {
1542       if (block)
1543         {
1544           current_binding_level->blocks
1545             = block_chainon (current_binding_level->blocks, block);
1546         }
1547       /* If we did not make a block for the level just exited,
1548          any blocks made for inner levels
1549          (since they cannot be recorded as subblocks in that level)
1550          must be carried forward so they will later become subblocks
1551          of something else.  */
1552       else if (subblocks)
1553         current_binding_level->blocks
1554           = block_chainon (current_binding_level->blocks, subblocks);
1555
1556       if (bind)
1557         java_add_stmt (bind);
1558     }
1559
1560   if (block)
1561     TREE_USED (block) = 1;
1562   return block;
1563 }
1564
1565 void
1566 maybe_pushlevels (int pc)
1567 {
1568 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1569   current_pc = pc;
1570 #endif
1571
1572   while (pending_local_decls != NULL_TREE &&
1573          DECL_LOCAL_START_PC (pending_local_decls) <= pc)
1574     {
1575       tree *ptr = &pending_local_decls;
1576       tree decl = *ptr, next;
1577       int end_pc = DECL_LOCAL_END_PC (decl);
1578
1579       while (*ptr != NULL_TREE
1580              && DECL_LOCAL_START_PC (*ptr) <= pc
1581              && DECL_LOCAL_END_PC (*ptr) == end_pc)
1582         ptr = &DECL_CHAIN (*ptr);
1583       pending_local_decls = *ptr;
1584       *ptr = NULL_TREE;
1585
1586       /* Force non-nested range to be nested in current range by
1587          truncating variable lifetimes. */
1588       if (end_pc > current_binding_level->end_pc)
1589         {
1590           tree t;
1591           end_pc = current_binding_level->end_pc;
1592           for (t = decl; t != NULL_TREE; t = DECL_CHAIN (t))
1593             DECL_LOCAL_END_PC (t) = end_pc;
1594         }
1595
1596       maybe_start_try (pc, end_pc);
1597
1598       pushlevel (1);
1599
1600       current_binding_level->end_pc = end_pc;
1601       current_binding_level->start_pc = pc;
1602       current_binding_level->names = NULL;
1603       for ( ; decl != NULL_TREE; decl = next)
1604         {
1605           int index = DECL_LOCAL_SLOT_NUMBER (decl);
1606           tree base_decl;
1607           next = DECL_CHAIN (decl);
1608           push_jvm_slot (index, decl);
1609           pushdecl (decl);
1610           base_decl
1611             = find_local_variable (index, TREE_TYPE (decl), pc);
1612           if (TREE_CODE (TREE_TYPE (base_decl)) == POINTER_TYPE)
1613             base_decl = TREE_VEC_ELT (base_decl_map, index);
1614           SET_DECL_VALUE_EXPR (decl, base_decl);
1615           DECL_HAS_VALUE_EXPR_P (decl) = 1;
1616         }
1617     }
1618
1619   maybe_start_try (pc, 0);
1620 }
1621
1622 void
1623 maybe_poplevels (int pc)
1624 {
1625 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1626   current_pc = pc;
1627 #endif
1628
1629   /* FIXME: I'm pretty sure that this is wrong.  Variable scopes are
1630      inclusive, so a variable is live if pc == end_pc.  Here, we
1631      terminate a range if the current pc is equal to the end of the
1632      range, and this is *before* we have generated code for the
1633      instruction at end_pc.  We're closing a binding level one
1634      instruction too early.*/
1635   while (current_binding_level->end_pc <= pc)
1636     poplevel (1, 0, 0);
1637 }
1638
1639 /* Terminate any binding which began during the range beginning at
1640    start_pc.  This tidies up improperly nested local variable ranges
1641    and exception handlers; a variable declared within an exception
1642    range is forcibly terminated when that exception ends. */
1643
1644 void
1645 force_poplevels (int start_pc)
1646 {
1647   while (current_binding_level->start_pc > start_pc)
1648     {
1649       if (pedantic && current_binding_level->start_pc > start_pc)
1650         warning (0, "In %+D: overlapped variable and exception ranges at %d",
1651                  current_function_decl,
1652                  current_binding_level->start_pc);
1653       poplevel (1, 0, 0);
1654     }
1655 }
1656
1657 /* integrate_decl_tree calls this function. */
1658
1659 void
1660 java_dup_lang_specific_decl (tree node)
1661 {
1662   int lang_decl_size;
1663   struct lang_decl *x;
1664
1665   if (!DECL_LANG_SPECIFIC (node))
1666     return;
1667
1668   lang_decl_size = sizeof (struct lang_decl);
1669   x = ggc_alloc_lang_decl (lang_decl_size);
1670   memcpy (x, DECL_LANG_SPECIFIC (node), lang_decl_size);
1671   DECL_LANG_SPECIFIC (node) = x;
1672 }
1673
1674 void
1675 give_name_to_locals (JCF *jcf)
1676 {
1677   int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl);
1678   int code_offset = DECL_CODE_OFFSET (current_function_decl);
1679   tree parm;
1680   pending_local_decls = NULL_TREE;
1681   if (n == 0)
1682     return;
1683   JCF_SEEK (jcf, n);
1684   n = JCF_readu2 (jcf);
1685   for (i = 0; i < n; i++)
1686     {
1687       int start_pc = JCF_readu2 (jcf);
1688       int length = JCF_readu2 (jcf);
1689       int name_index = JCF_readu2 (jcf);
1690       int signature_index = JCF_readu2 (jcf);
1691       int slot = JCF_readu2 (jcf);
1692       tree name = get_name_constant (jcf, name_index);
1693       tree type = parse_signature (jcf, signature_index);
1694       if (slot < DECL_ARG_SLOT_COUNT (current_function_decl)
1695           && start_pc == 0
1696           && length == DECL_CODE_LENGTH (current_function_decl))
1697         {
1698           tree decl = TREE_VEC_ELT (decl_map, slot);
1699           DECL_NAME (decl) = name;
1700           if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
1701             warning (0, "bad type in parameter debug info");
1702         }
1703       else
1704         {
1705           tree *ptr;
1706           int end_pc = start_pc + length;
1707           tree decl = build_decl (input_location, VAR_DECL, name, type);
1708           if (end_pc > DECL_CODE_LENGTH (current_function_decl))
1709             {
1710               warning (0, "bad PC range for debug info for local %q+D",
1711                        decl);
1712               end_pc = DECL_CODE_LENGTH (current_function_decl);
1713             }
1714
1715           /* Adjust start_pc if necessary so that the local's first
1716              store operation will use the relevant DECL as a
1717              destination. Fore more information, read the leading
1718              comments for expr.c:maybe_adjust_start_pc. */
1719           start_pc = maybe_adjust_start_pc (jcf, code_offset, start_pc, slot);
1720
1721           MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
1722           DECL_LOCAL_SLOT_NUMBER (decl) = slot;
1723           DECL_LOCAL_START_PC (decl) = start_pc;
1724           DECL_LOCAL_END_PC (decl) = end_pc;
1725
1726           /* Now insert the new decl in the proper place in
1727              pending_local_decls.  We are essentially doing an insertion sort,
1728              which works fine, since the list input will normally already
1729              be sorted. */
1730           ptr = &pending_local_decls;
1731           while (*ptr != NULL_TREE
1732                  && (DECL_LOCAL_START_PC (*ptr) > start_pc
1733                      || (DECL_LOCAL_START_PC (*ptr) == start_pc
1734                          && DECL_LOCAL_END_PC (*ptr) < end_pc)))
1735             ptr = &DECL_CHAIN (*ptr);
1736           DECL_CHAIN (decl) = *ptr;
1737           *ptr = decl;
1738         }
1739     }
1740
1741   pending_local_decls = nreverse (pending_local_decls);
1742
1743   /* Fill in default names for the parameters. */
1744   for (parm = DECL_ARGUMENTS (current_function_decl), i = 0;
1745        parm != NULL_TREE;  parm = DECL_CHAIN (parm), i++)
1746     {
1747       if (DECL_NAME (parm) == NULL_TREE)
1748         {
1749           int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i;
1750           if (arg_i == 0)
1751             DECL_NAME (parm) = get_identifier ("this");
1752           else
1753             {
1754               char buffer[12];
1755               sprintf (buffer, "ARG_%d", arg_i);
1756               DECL_NAME (parm) = get_identifier (buffer);
1757             }
1758         }
1759     }
1760 }
1761
1762 tree
1763 build_result_decl (tree fndecl)
1764 {
1765   tree restype = TREE_TYPE (TREE_TYPE (fndecl));
1766   tree result = DECL_RESULT (fndecl);
1767   if (! result)
1768     {
1769       result = build_decl (DECL_SOURCE_LOCATION (fndecl),
1770                            RESULT_DECL, NULL_TREE, restype);
1771       DECL_ARTIFICIAL (result) = 1;
1772       DECL_IGNORED_P (result) = 1;
1773       DECL_CONTEXT (result) = fndecl;
1774       DECL_RESULT (fndecl) = result;
1775     }
1776   return result;
1777 }
1778
1779 void
1780 start_java_method (tree fndecl)
1781 {
1782   tree tem, *ptr;
1783   int i;
1784
1785   uniq = 0;
1786
1787   current_function_decl = fndecl;
1788   announce_function (fndecl);
1789
1790   i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
1791   decl_map = make_tree_vec (i);
1792   base_decl_map = make_tree_vec (i);
1793   type_map = XRESIZEVEC (tree, type_map, i);
1794
1795 #if defined(DEBUG_JAVA_BINDING_LEVELS)
1796   fprintf (stderr, "%s:\n", lang_printable_name (fndecl, 2));
1797   current_pc = 0;
1798 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
1799   pushlevel (1);  /* Push parameters. */
1800
1801   ptr = &DECL_ARGUMENTS (fndecl);
1802   for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
1803        tem != end_params_node; tem = TREE_CHAIN (tem), i++)
1804     {
1805       tree parm_name = NULL_TREE, parm_decl;
1806       tree parm_type = TREE_VALUE (tem);
1807       gcc_assert (i < DECL_MAX_LOCALS (fndecl));
1808
1809       parm_decl = build_decl (input_location, PARM_DECL, parm_name, parm_type);
1810       DECL_CONTEXT (parm_decl) = fndecl;
1811       if (targetm.calls.promote_prototypes (parm_type)
1812           && TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
1813           && INTEGRAL_TYPE_P (parm_type))
1814         parm_type = integer_type_node;
1815       DECL_ARG_TYPE (parm_decl) = parm_type;
1816
1817       *ptr = parm_decl;
1818       ptr = &DECL_CHAIN (parm_decl);
1819
1820       /* Add parm_decl to the decl_map. */
1821       push_jvm_slot (i, parm_decl);
1822
1823       /* The this parameter of methods is artificial.  */
1824       if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE && i == 0)
1825         DECL_ARTIFICIAL (parm_decl) = 1;
1826
1827       type_map[i] = TREE_TYPE (parm_decl);
1828       if (TYPE_IS_WIDE (TREE_TYPE (parm_decl)))
1829         {
1830           i++;
1831           type_map[i] = void_type_node;
1832         }
1833     }
1834   *ptr = NULL_TREE;
1835   DECL_ARG_SLOT_COUNT (current_function_decl) = i;
1836
1837   while (i < DECL_MAX_LOCALS(fndecl))
1838     type_map[i++] = NULL_TREE;
1839
1840   build_result_decl (fndecl);
1841   DECL_SOURCE_LOCATION (fndecl) = input_location;
1842
1843   /* Push local variables.  */
1844   pushlevel (2);
1845
1846   function_binding_level = current_binding_level;
1847 }
1848
1849 void
1850 end_java_method (void)
1851 {
1852   tree fndecl = current_function_decl;
1853
1854   /* pop out of function */
1855   poplevel (1, 1, 0);
1856
1857   /* pop out of its parameters */
1858   poplevel (1, 0, 1);
1859
1860   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
1861
1862   if (DECL_SAVED_TREE (fndecl))
1863     {
1864       tree fbody, block_body;
1865       /* Before we check initialization, attached all class initialization
1866          variable to the block_body */
1867       fbody = DECL_SAVED_TREE (fndecl);
1868       block_body = BIND_EXPR_BODY (fbody);
1869       htab_traverse (DECL_FUNCTION_INIT_TEST_TABLE (fndecl),
1870                      attach_init_test_initialization_flags, block_body);
1871     }
1872
1873   finish_method (fndecl);
1874
1875   current_function_decl = NULL_TREE;
1876   base_decl_map = NULL_TREE;
1877 }
1878
1879 /* Prepare a method for expansion.  */
1880
1881 void
1882 finish_method (tree fndecl)
1883 {
1884   tree *tp = &DECL_SAVED_TREE (fndecl);
1885
1886   /* Wrap body of synchronized methods in a monitorenter,
1887      plus monitorexit cleanup.  */
1888   if (METHOD_SYNCHRONIZED (fndecl))
1889     {
1890       tree enter, exit, lock;
1891       if (METHOD_STATIC (fndecl))
1892         lock = build_class_ref (DECL_CONTEXT (fndecl));
1893       else
1894         lock = DECL_ARGUMENTS (fndecl);
1895       BUILD_MONITOR_ENTER (enter, lock);
1896       BUILD_MONITOR_EXIT (exit, lock);
1897       *tp = build2 (COMPOUND_EXPR, void_type_node, enter,
1898                     build2 (TRY_FINALLY_EXPR, void_type_node, *tp, exit));
1899     }
1900
1901   /* Convert function tree to GENERIC prior to inlining.  */
1902   java_genericize (fndecl);
1903
1904   /* Store the end of the function, so that we get good line number
1905      info for the epilogue.  */
1906   if (DECL_STRUCT_FUNCTION (fndecl))
1907     set_cfun (DECL_STRUCT_FUNCTION (fndecl));
1908   else
1909     allocate_struct_function (fndecl, false);
1910   cfun->function_end_locus = DECL_FUNCTION_LAST_LINE (fndecl);
1911
1912   /* Defer inlining and expansion to the cgraph optimizers.  */
1913   cgraph_finalize_function (fndecl, false);
1914 }
1915
1916 /* We pessimistically marked all methods and fields external until we
1917    knew what set of classes we were planning to compile.  Now mark those
1918    associated with CLASS to be generated locally as not external.  */
1919
1920 static void
1921 java_mark_decl_local (tree decl)
1922 {
1923   DECL_EXTERNAL (decl) = 0;
1924
1925 #ifdef ENABLE_CHECKING
1926   /* Double check that we didn't pass the function to the callgraph early.  */
1927   if (TREE_CODE (decl) == FUNCTION_DECL)
1928     {
1929       struct cgraph_node *node = cgraph_get_node (decl);
1930       gcc_assert (!node || !node->local.finalized);
1931     }
1932 #endif
1933   gcc_assert (!DECL_RTL_SET_P (decl));
1934 }
1935
1936 /* Given appropriate target support, G++ will emit hidden aliases for native
1937    methods.  Using this hidden name is required for proper operation of
1938    _Jv_Method::ncode, but it doesn't hurt to use it everywhere.  Look for
1939    proper target support, then mark the method for aliasing.  */
1940
1941 static void
1942 java_mark_cni_decl_local (tree decl)
1943 {
1944 #if !defined(HAVE_GAS_HIDDEN) || !defined(ASM_OUTPUT_DEF)
1945   return;
1946 #endif
1947
1948   DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
1949   DECL_LOCAL_CNI_METHOD_P (decl) = 1;
1950
1951   /* Setting DECL_LOCAL_CNI_METHOD_P changes the behavior of the
1952      mangler.  We might have already referenced this native method and
1953      therefore created its name, but even if we have it won't hurt.
1954      We'll just go via its externally visible name, rather than its
1955      hidden alias.  However, we must force things so that the correct
1956      mangling is done.  */
1957
1958   if (DECL_ASSEMBLER_NAME_SET_P (decl))
1959     java_mangle_decl (decl);
1960   if (DECL_RTL_SET_P (decl))
1961     {
1962       SET_DECL_RTL (decl, 0);
1963       make_decl_rtl (decl);
1964     }
1965 }
1966
1967 /* Use the preceding two functions and mark all members of the class.  */
1968
1969 void
1970 java_mark_class_local (tree klass)
1971 {
1972   tree t;
1973
1974   for (t = TYPE_FIELDS (klass); t ; t = DECL_CHAIN (t))
1975     if (FIELD_STATIC (t))
1976       {
1977         if (DECL_EXTERNAL (t))
1978           VEC_safe_push (tree, gc, pending_static_fields, t);
1979         java_mark_decl_local (t);
1980       }
1981
1982   for (t = TYPE_METHODS (klass); t ; t = DECL_CHAIN (t))
1983     if (!METHOD_ABSTRACT (t))
1984       {
1985         if (METHOD_NATIVE (t) && !flag_jni)
1986           java_mark_cni_decl_local (t);
1987         else
1988           java_mark_decl_local (t);
1989       }
1990 }
1991
1992 /* Add a statement to a compound_expr.  */
1993
1994 tree
1995 add_stmt_to_compound (tree existing, tree type, tree stmt)
1996 {
1997   if (!stmt)
1998     return existing;
1999   else if (existing)
2000     {
2001       tree expr = build2 (COMPOUND_EXPR, type, existing, stmt);
2002       TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (existing)
2003                                  | TREE_SIDE_EFFECTS (stmt);
2004       return expr;
2005     }
2006   else
2007     return stmt;
2008 }
2009
2010 /* If this node is an expr, mark its input location.  Called from
2011    walk_tree().  */
2012
2013 static tree
2014 set_input_location (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
2015                     void *data ATTRIBUTE_UNUSED)
2016 {
2017   tree t = *tp;
2018
2019   if (CAN_HAVE_LOCATION_P (t))
2020     {
2021       if (EXPR_HAS_LOCATION(t))
2022         return t;  /* Don't walk any further into this expr.   */
2023       else
2024         SET_EXPR_LOCATION (t, input_location);
2025     }
2026
2027   return NULL_TREE;  /* Continue walking this expr.   */
2028 }
2029
2030 /* Add a statement to the statement_list currently being constructed.
2031    If the statement_list is null, we don't create a singleton list.
2032    This is necessary because poplevel() assumes that adding a
2033    statement to a null statement_list returns the statement.  */
2034
2035 tree
2036 java_add_stmt (tree new_stmt)
2037 {
2038   tree stmts = current_binding_level->stmts;
2039   tree_stmt_iterator i;
2040
2041   if (input_filename)
2042     walk_tree (&new_stmt, set_input_location, NULL, NULL);
2043
2044   if (stmts == NULL)
2045     return current_binding_level->stmts = new_stmt;
2046
2047   /* Force STMTS to be a statement_list.  */
2048   if (TREE_CODE (stmts) != STATEMENT_LIST)
2049     {
2050       tree t = make_node (STATEMENT_LIST);
2051       i = tsi_last (t);
2052       tsi_link_after (&i, stmts, TSI_CONTINUE_LINKING);
2053       stmts = t;
2054     }
2055
2056   i = tsi_last (stmts);
2057   tsi_link_after (&i, new_stmt, TSI_CONTINUE_LINKING);
2058   TREE_TYPE (stmts) = void_type_node;
2059
2060   return current_binding_level->stmts = stmts;
2061 }
2062
2063 /* Add a variable to the current scope.  */
2064
2065 tree
2066 java_add_local_var (tree decl)
2067 {
2068   tree *vars = &current_binding_level->names;
2069   tree next = *vars;
2070   DECL_CHAIN (decl) = next;
2071   *vars = decl;
2072   DECL_CONTEXT (decl) = current_function_decl;
2073   MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
2074   return decl;
2075 }
2076
2077 /* Return a pointer to the compound_expr currently being
2078    constructed.  */
2079
2080 tree *
2081 get_stmts (void)
2082 {
2083   return &current_binding_level->stmts;
2084 }
2085
2086 /* Register an exception range as belonging to the current binding
2087    level.  There may only be one: if there are more, we'll create more
2088    binding levels.  However, each range can have multiple handlers,
2089    and these are expanded when we call expand_end_java_handler().  */
2090
2091 void
2092 register_exception_range (struct eh_range *range, int pc, int end_pc)
2093 {
2094   gcc_assert (! current_binding_level->exception_range);
2095   current_binding_level->exception_range = range;
2096   current_binding_level->end_pc = end_pc;
2097   current_binding_level->start_pc = pc;
2098 }
2099
2100 #include "gt-java-decl.h"