Makefile.def: Remove libjava.

2016-09-30  Andrew Haley  <aph@redhat.com>

	* Makefile.def: Remove libjava.
	* Makefile.tpl: Likewise.
	* Makefile.in: Regenerate.
	* configure.ac: Likewise.
	* configure: Likewise.
	* gcc/java: Remove.
	* libjava: Likewise.

From-SVN: r240662

1 files changed, 0 insertions, 2065 deletions

diff --git a/gcc/java/decl.c b/gcc/java/decl.c
deleted file mode 100644
index 70eac31..0000000
--- a/gcc/java/decl.c
+++ /dev/null
@@ -1,2065 +0,0 @@
-/* Process declarations and variables for the GNU compiler for the
-   Java(TM) language.
-   Copyright (C) 1996-2016 Free Software Foundation, Inc.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3, or (at your option)
-any later version.
-
-GCC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3.  If not see
-<http://www.gnu.org/licenses/>.
-
-Java and all Java-based marks are trademarks or registered trademarks
-of Sun Microsystems, Inc. in the United States and other countries.
-The Free Software Foundation is independent of Sun Microsystems, Inc.  */
-
-/* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "target.h"
-#include "function.h"
-#include "tree.h"
-#include "stringpool.h"
-#include "cgraph.h"
-#include "diagnostic-core.h"
-#include "stor-layout.h"
-#include "varasm.h"
-#include "toplev.h"
-#include "java-tree.h"
-#include "jcf.h"
-#include "java-except.h"
-#include "version.h"
-#include "tree-iterator.h"
-#include "langhooks.h"
-
-#if defined (DEBUG_JAVA_BINDING_LEVELS)
-extern void indent (void);
-#endif
-
-static tree push_jvm_slot (int, tree);
-static tree lookup_name_current_level (tree);
-static tree push_promoted_type (const char *, tree);
-static struct binding_level *make_binding_level (void);
-static tree create_primitive_vtable (const char *);
-static tree check_local_unnamed_variable (tree, tree, tree);
-static void parse_version (void);
-
-
-/* The following ABI flags are used in the high-order bits of the version
-   ID field. The version ID number itself should never be larger than 
-   0xfffff, so it should be safe to use top 12 bits for these flags. */
-
-#define FLAG_BINARYCOMPAT_ABI (1<<31)  /* Class is built with the BC-ABI. */
-
-#define FLAG_BOOTSTRAP_LOADER (1<<30)  /* Used when defining a class that 
-					  should be loaded by the bootstrap
-					  loader.  */
-
-/* If an ABI change is made within a GCC release series, rendering current
-   binaries incompatible with the old runtimes, this number must be set to
-   enforce the compatibility rules. */
-#define MINOR_BINARYCOMPAT_ABI_VERSION 1
-
-/* The runtime may recognize a variety of BC ABIs (objects generated by 
-   different version of gcj), but will probably always require strict 
-   matching for the ordinary (C++) ABI.  */
-
-/* The version ID of the BC ABI that we generate.  This must be kept in
-   sync with parse_version(), libgcj, and reality (if the BC format changes, 
-   this must change).  */
-#define GCJ_CURRENT_BC_ABI_VERSION \
-  (4 * 100000 + 0 * 1000 + MINOR_BINARYCOMPAT_ABI_VERSION)
-
-/* The ABI version number.  */
-tree gcj_abi_version;
-
-/* Name of the Cloneable class.  */
-tree java_lang_cloneable_identifier_node;
-
-/* Name of the Serializable class.  */
-tree java_io_serializable_identifier_node;
-
-/* The DECL_MAP is a mapping from (index, type) to a decl node.
-   If index < max_locals, it is the index of a local variable.
-   if index >= max_locals, then index-max_locals is a stack slot.
-   The DECL_MAP mapping is represented as a TREE_VEC whose elements
-   are a list of decls (VAR_DECL or PARM_DECL) chained by
-   DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
-   we search the chain for a decl with a matching TREE_TYPE. */
-
-static GTY(()) tree decl_map;
-
-/* The base_decl_map is contains one variable of ptr_type: this is
-   used to contain every variable of reference type that is ever
-   stored in a local variable slot.  */
-
-static GTY(()) tree base_decl_map;
-
-/* An index used to make temporary identifiers unique.  */
-static int uniq;
-
-/* A list of local variables VAR_DECLs for this method that we have seen
-   debug information, but we have not reached their starting (byte) PC yet. */
-
-static GTY(()) tree pending_local_decls;
-
-/* The decl for "_Jv_ResolvePoolEntry".  */
-tree soft_resolvepoolentry_node;
-
-/* The decl for the .constants field of an instance of Class.  */
-tree constants_field_decl_node;
-
-/* The decl for the .data field of an instance of Class.  */
-tree constants_data_field_decl_node;
-
-#if defined(DEBUG_JAVA_BINDING_LEVELS)
-int binding_depth = 0;
-int is_class_level = 0;
-int current_pc;
-
-void
-indent (void)
-{
-  int i;
-
-  for (i = 0; i < binding_depth*2; i++)
-    putc (' ', stderr);
-}
-#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
-
-/* True if decl is a named local variable, i.e. if it is an alias
-   that's used only for debugging purposes.  */
-
-static bool
-debug_variable_p (tree decl)
-{
-  if (TREE_CODE (decl) == PARM_DECL)
-    return false;
-
-  if (LOCAL_SLOT_P (decl))
-    return false;
-
-  return true;
-}
- 
-static tree
-push_jvm_slot (int index, tree decl)
-{
-  DECL_CONTEXT (decl) = current_function_decl;
-  layout_decl (decl, 0);
-
-  /* Now link the decl into the decl_map. */
-  if (DECL_LANG_SPECIFIC (decl) == NULL)
-    {
-      MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
-      DECL_LOCAL_START_PC (decl) = 0;
-      DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
-      DECL_LOCAL_SLOT_NUMBER (decl) = index;
-    }
-  DECL_LOCAL_SLOT_CHAIN (decl) = TREE_VEC_ELT (decl_map, index);
-  TREE_VEC_ELT (decl_map, index) = decl;
-
-  return decl;
-}
-
-/* Find the best declaration based upon type.  If 'decl' fits 'type' better
-   than 'best', return 'decl'.  Otherwise return 'best'.  */
-
-static tree
-check_local_unnamed_variable (tree best, tree decl, tree type)
-{
-  tree decl_type = TREE_TYPE (decl);
-  
-  gcc_assert (! LOCAL_VAR_OUT_OF_SCOPE_P (decl));
-
-  /* Use the same decl for all integer types <= 32 bits.  This is
-     necessary because sometimes a value is stored as (for example)
-     boolean but loaded as int.  */
-  if (decl_type == type
-      || (INTEGRAL_TYPE_P (decl_type)
-	  && INTEGRAL_TYPE_P (type)
-	  && TYPE_PRECISION (decl_type) <= 32
-	  && TYPE_PRECISION (type) <= 32
-	  && TYPE_PRECISION (decl_type) >= TYPE_PRECISION (type))      
-      /*  ptr_type_node is used for null pointers, which are
-	  assignment compatible with everything.  */
-      || (TREE_CODE (decl_type) == POINTER_TYPE
-	  && type == ptr_type_node)
-      /* Whenever anyone wants to use a slot that is initially
-	 occupied by a PARM_DECL of pointer type they must get that
-	 decl, even if they asked for a pointer to a different type.
-	 However, if someone wants a scalar variable in a slot that
-	 initially held a pointer arg -- or vice versa -- we create a
-	 new VAR_DECL.  
-
-      	 ???: As long as verification is correct, this will be a
-	 compatible type.  But maybe we should create a dummy variable
-	 and replace all references to it with the DECL and a
-	 NOP_EXPR.  
-      */
-      || (TREE_CODE (decl_type) == POINTER_TYPE
-	  && TREE_CODE (decl) == PARM_DECL
-	  && TREE_CODE (type) == POINTER_TYPE))
-    {
-      if (best == NULL_TREE
-	  || (decl_type == type && TREE_TYPE (best) != type))
-	return decl;
-    }
-
-  return best;
-}
-
-
-/* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
-   that is valid at PC (or -1 if any pc).
-   If there is no existing matching decl, allocate one.  */
-
-tree
-find_local_variable (int index, tree type, int pc ATTRIBUTE_UNUSED)
-{
-  tree tmp = TREE_VEC_ELT (decl_map, index);
-  tree decl = NULL_TREE;
-
-  /* Scan through every declaration that has been created in this
-     slot.  We're only looking for variables that correspond to local
-     index declarations and PARM_DECLs, not named variables: such
-     local variables are used only for debugging information.  */
-  while (tmp != NULL_TREE)
-    {
-      if (! debug_variable_p (tmp))
-	decl = check_local_unnamed_variable (decl, tmp, type);
-      tmp = DECL_LOCAL_SLOT_CHAIN (tmp);
-    }
-
-  /* gcj has a function called promote_type(), which is used by both
-     the bytecode compiler and the source compiler.  Unfortunately,
-     the type systems for the Java VM and the Java language are not
-     the same: a boolean in the VM promotes to an int, not to a wide
-     boolean.  If our caller wants something to hold a boolean, that
-     had better be an int, because that slot might be re-used
-     later in integer context.  */
-  if (TREE_CODE (type) == BOOLEAN_TYPE)
-    type = integer_type_node;
-
-  /* If we don't find a match, create one with the type passed in.
-     The name of the variable is #n#m, which n is the variable index
-     in the local variable area and m is a dummy identifier for
-     uniqueness -- multiple variables may share the same local
-     variable index.  We don't call pushdecl() to push pointer types
-     into a binding expr because they'll all be replaced by a single
-     variable that is used for every reference in that local variable
-     slot.  */
-  if (! decl)
-    {
-      char buf[64];
-      tree name;
-      sprintf (buf, "#slot#%d#%d", index, uniq++);
-      name = get_identifier (buf);
-      decl = build_decl (input_location, VAR_DECL, name, type);
-      DECL_IGNORED_P (decl) = 1;
-      DECL_ARTIFICIAL (decl) = 1;
-      decl = push_jvm_slot (index, decl);
-      LOCAL_SLOT_P (decl) = 1;
-
-      if (TREE_CODE (type) != POINTER_TYPE)
-	pushdecl_function_level (decl);
-    }
-
-  /* As well as creating a local variable that matches the type, we
-     also create a base variable (of ptr_type) that will hold all its
-     aliases.  */
-  if (TREE_CODE (type) == POINTER_TYPE
-      && ! TREE_VEC_ELT (base_decl_map, index))
-    {
-      char buf[64];
-      tree name;
-      tree base_decl;
-      sprintf (buf, "#ref#%d#%d", index, uniq++);
-      name = get_identifier (buf);
-      base_decl
-	= TREE_VEC_ELT (base_decl_map, index)
-	= build_decl (input_location, VAR_DECL, name, ptr_type_node);
-      pushdecl_function_level (base_decl);
-      DECL_IGNORED_P (base_decl) = 1;
-      DECL_ARTIFICIAL (base_decl) = 1;
-    }
-
-  return decl;
-}
-
-/* Called during genericization for every variable.  If the variable
-   is a temporary of pointer type, replace it with a common variable
-   thath is used to hold all pointer types that are ever stored in
-   that slot.  Set WANT_LVALUE if you want a variable that is to be
-   written to.  */
-
-static tree 
-java_replace_reference (tree var_decl, bool want_lvalue)
-{
-  tree decl_type;
-
-  if (! base_decl_map)
-    return var_decl;
-
-  decl_type = TREE_TYPE (var_decl);
-
-  if (TREE_CODE (decl_type) == POINTER_TYPE)
-    {
-      if (DECL_LANG_SPECIFIC (var_decl)
-	  && LOCAL_SLOT_P (var_decl))
-	{
-	  int index = DECL_LOCAL_SLOT_NUMBER (var_decl);
-	  tree base_decl = TREE_VEC_ELT (base_decl_map, index); 
-
-	  gcc_assert (base_decl);
-	  if (! want_lvalue)
-	    base_decl = build1 (NOP_EXPR, decl_type, base_decl);
-
-	  return base_decl;
-	}
-    }
-
-  return var_decl;
-}
-
-/* Helper for java_genericize.  */
-
-tree
-java_replace_references (tree *tp, int *walk_subtrees,
-			 void *data ATTRIBUTE_UNUSED)
-{
-  if (TREE_CODE (*tp) == MODIFY_EXPR)
-    {
-      source_location loc = EXPR_LOCATION (*tp);
-      tree lhs = TREE_OPERAND (*tp, 0);
-      /* This is specific to the bytecode compiler.  If a variable has
-	 LOCAL_SLOT_P set, replace an assignment to it with an assignment
-	 to the corresponding variable that holds all its aliases.  */
-      if (TREE_CODE (lhs) == VAR_DECL
-	  && DECL_LANG_SPECIFIC (lhs)
-	  && LOCAL_SLOT_P (lhs)
-	  && TREE_CODE (TREE_TYPE (lhs)) == POINTER_TYPE)
-	{
-	  tree new_lhs = java_replace_reference (lhs, /* want_lvalue */ true);
-	  tree new_rhs = build1 (NOP_EXPR, TREE_TYPE (new_lhs),
-				 TREE_OPERAND (*tp, 1));
-	  tree tem = build2 (MODIFY_EXPR, TREE_TYPE (new_lhs),
-			     new_lhs, new_rhs);
-	  *tp = build1 (NOP_EXPR, TREE_TYPE (lhs), tem);
-	  SET_EXPR_LOCATION (tem, loc);
-	  SET_EXPR_LOCATION (new_rhs, loc);
-	  SET_EXPR_LOCATION (*tp, loc);
-	}
-    }
-  if (TREE_CODE (*tp) == VAR_DECL)
-    {
-      *tp = java_replace_reference (*tp, /* want_lvalue */ false);
-      *walk_subtrees = 0;
-    }
-
-  return NULL_TREE;
-}
-
-/* Same as find_local_index, except that INDEX is a stack index. */
-
-tree
-find_stack_slot (int index, tree type)
-{
-  return find_local_variable (index + DECL_MAX_LOCALS (current_function_decl),
-			      type, -1);
-}
-
-struct GTY(())
-  binding_level {
-    /* A chain of _DECL nodes for all variables, constants, functions,
-     * and typedef types.  These are in the reverse of the order supplied.
-     */
-    tree names;
-
-    /* For each level, a list of shadowed outer-level local definitions
-       to be restored when this level is popped.
-       Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
-       whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
-    tree shadowed;
-
-    /* For each level (except not the global one),
-       a chain of BLOCK nodes for all the levels
-       that were entered and exited one level down.  */
-    tree blocks;
-
-    /* The binding level which this one is contained in (inherits from).  */
-    struct binding_level *level_chain;
-
-    /* The bytecode PC that marks the end of this level. */
-    int end_pc;
-    /* The bytecode PC that marks the start of this level. */
-    int start_pc;
-
-    /* The statements in this binding level.  */
-    tree stmts;
-
-    /* An exception range associated with this binding level.  */
-    struct eh_range * GTY((skip (""))) exception_range;
-
-    /* Binding depth at which this level began.  Used only for debugging.  */
-    unsigned binding_depth;
-
-    /* The location at which this level began.  */
-    source_location loc;
-  };
-
-#define NULL_BINDING_LEVEL (struct binding_level *) NULL
-
-/* The binding level currently in effect.  */
-
-static GTY(()) struct binding_level *current_binding_level;
-
-/* A chain of binding_level structures awaiting reuse.  */
-
-static GTY(()) struct binding_level *free_binding_level;
-
-/* The outermost binding level, for names of file scope.
-   This is created when the compiler is started and exists
-   through the entire run.  */
-
-static GTY(()) struct binding_level *global_binding_level;
-
-/* The binding level that holds variables declared at the outermost
-   level within a function body.  */
-
-static struct binding_level *function_binding_level;
-
-/* A PC value bigger than any PC value we may ever may encounter. */
-
-#define LARGEST_PC (( (unsigned int)1 << (HOST_BITS_PER_INT - 1)) - 1)
-
-/* Binding level structures are initialized by copying this one.  */
-
-static const struct binding_level clear_binding_level
-= {
-    NULL_TREE, /* names */
-    NULL_TREE, /* shadowed */
-    NULL_TREE, /* blocks */
-    NULL_BINDING_LEVEL, /* level_chain */
-    LARGEST_PC, /* end_pc */
-    0, /* start_pc */
-    NULL, /* stmts */
-    NULL, /* exception_range */
-    0, /* binding_depth */
-    0, /* loc */
-  };
-
-tree java_global_trees[JTI_MAX];
-
-/* Build (and pushdecl) a "promoted type" for all standard
-   types shorter than int.  */
-
-static tree
-push_promoted_type (const char *name, tree actual_type)
-{
-  tree type = make_node (TREE_CODE (actual_type));
-#if 1
-  tree in_min = TYPE_MIN_VALUE (int_type_node);
-  tree in_max = TYPE_MAX_VALUE (int_type_node);
-#else
-  tree in_min = TYPE_MIN_VALUE (actual_type);
-  tree in_max = TYPE_MAX_VALUE (actual_type);
-#endif
-  TYPE_MIN_VALUE (type) = copy_node (in_min);
-  TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
-  TYPE_MAX_VALUE (type) = copy_node (in_max);
-  TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
-  TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node);
-  TYPE_STRING_FLAG (type) = TYPE_STRING_FLAG (actual_type);
-  layout_type (type);
-  pushdecl (build_decl (input_location,
-			TYPE_DECL, get_identifier (name), type));
-  return type;
-}
-
-/* Return tree that represents a vtable for a primitive array.  */
-static tree
-create_primitive_vtable (const char *name)
-{
-  tree r;
-  char buf[50];
-
-  sprintf (buf, "_Jv_%sVTable", name);
-  r = build_decl (input_location,
-		  VAR_DECL, get_identifier (buf), ptr_type_node);
-  DECL_EXTERNAL (r) = 1;
-  return r;
-}
-
-/* Parse the version string and compute the ABI version number.  */
-static void
-parse_version (void)
-{
-  const char *p = version_string;
-  unsigned int major = 0;
-  unsigned int abi_version;
-
-  /* Skip leading junk.  */
-  while (*p && !ISDIGIT (*p))
-    ++p;
-  gcc_assert (*p);
-
-  /* Extract major version.  */
-  while (ISDIGIT (*p))
-    {
-      major = major * 10 + *p - '0';
-      ++p;
-    }
-
-  gcc_assert (*p == '.' && ISDIGIT (p[1]));
-  ++p;
-
-  if (flag_indirect_dispatch)
-    {
-      abi_version = GCJ_CURRENT_BC_ABI_VERSION;
-      abi_version |= FLAG_BINARYCOMPAT_ABI;
-    }
-  else /* C++ ABI */
-    {
-      /* Implicit in this computation is the idea that we won't break the
-	 old-style binary ABI in a minor release (e.g., from 6.1.0 to
-	 6.2.0).  */
-      abi_version = 100000 * major;
-    }
-  if (flag_bootstrap_classes)
-    abi_version |= FLAG_BOOTSTRAP_LOADER;
-
-  gcj_abi_version = build_int_cstu (ptr_type_node, abi_version);
-}
-
-void
-java_init_decl_processing (void)
-{
-  tree field = NULL_TREE;
-  tree t;
-
-  init_class_processing ();
-
-  current_function_decl = NULL;
-  current_binding_level = NULL_BINDING_LEVEL;
-  free_binding_level = NULL_BINDING_LEVEL;
-  pushlevel (0);	/* make the binding_level structure for global names */
-  global_binding_level = current_binding_level;
-
-  /* Build common tree nodes, Java has an unsigned char.  */
-  build_common_tree_nodes (false);
-
-  /* ???  Now we continue and override some of the built types again
-     with Java specific types.  As the above generated types are
-     supposed to match the targets C ABI this isn't really the way
-     to go and any Java specifics should _not_ use those global types
-     if the Java ABI does not match the C one.  */
-
-  byte_type_node = make_signed_type (8);
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("byte"), byte_type_node));
-  short_type_node = make_signed_type (16);
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("short"), short_type_node));
-  int_type_node = make_signed_type (32);
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("int"), int_type_node));
-  long_type_node = make_signed_type (64);
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("long"), long_type_node));
-
-  unsigned_byte_type_node = make_unsigned_type (8);
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("unsigned byte"),
-			unsigned_byte_type_node));
-  unsigned_short_type_node = make_unsigned_type (16);
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("unsigned short"),
-			unsigned_short_type_node));
-  unsigned_int_type_node = make_unsigned_type (32);
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("unsigned int"),
-			unsigned_int_type_node));
-  unsigned_long_type_node = make_unsigned_type (64);
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("unsigned long"),
-			unsigned_long_type_node));
-
-  /* Define these next since types below may used them.  */
-  integer_type_node = java_type_for_size (INT_TYPE_SIZE, 0);
-  integer_zero_node = build_int_cst (NULL_TREE, 0);
-  integer_one_node = build_int_cst (NULL_TREE, 1);
-  integer_two_node = build_int_cst (NULL_TREE, 2);
-  integer_three_node = build_int_cst (NULL_TREE, 3);
-  integer_four_node = build_int_cst (NULL_TREE, 4);
-  integer_minus_one_node = build_int_cst (NULL_TREE, -1);
-
-  /* A few values used for range checking in the lexer.  */
-  decimal_int_max = build_int_cstu (unsigned_int_type_node, 0x80000000);
-  decimal_long_max
-    = double_int_to_tree (unsigned_long_type_node,
-			  double_int_zero.set_bit (64));
-
-  long_zero_node = build_int_cst (long_type_node, 0);
-
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("void"), void_type_node));
-
-  t = make_node (VOID_TYPE);
-  layout_type (t); /* Uses size_zero_node */
-  return_address_type_node = build_pointer_type (t);
-
-  char_type_node = make_unsigned_type (16);
-  TYPE_STRING_FLAG (char_type_node) = 1;
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("char"), char_type_node));
-
-  boolean_type_node = make_unsigned_type (1);
-  TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("boolean"),
-			boolean_type_node));
-  boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
-  boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
-
-  promoted_byte_type_node
-    = push_promoted_type ("promoted_byte", byte_type_node);
-  promoted_short_type_node
-    = push_promoted_type ("promoted_short", short_type_node);
-  promoted_char_type_node
-    = push_promoted_type ("promoted_char", char_type_node);
-  promoted_boolean_type_node
-    = push_promoted_type ("promoted_boolean", boolean_type_node);
-
-  float_type_node = make_node (REAL_TYPE);
-  TYPE_PRECISION (float_type_node) = 32;
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("float"),
-                        float_type_node));
-  layout_type (float_type_node);
-
-  double_type_node = make_node (REAL_TYPE);
-  TYPE_PRECISION (double_type_node) = 64;
-  pushdecl (build_decl (BUILTINS_LOCATION,
-			TYPE_DECL, get_identifier ("double"),
-                        double_type_node));
-  layout_type (double_type_node);
-
-  float_zero_node = build_real (float_type_node, dconst0);
-  double_zero_node = build_real (double_type_node, dconst0);
-
-  /* These are the vtables for arrays of primitives.  */
-  boolean_array_vtable = create_primitive_vtable ("boolean");
-  byte_array_vtable = create_primitive_vtable ("byte");
-  char_array_vtable = create_primitive_vtable ("char");
-  short_array_vtable = create_primitive_vtable ("short");
-  int_array_vtable = create_primitive_vtable ("int");
-  long_array_vtable = create_primitive_vtable ("long");
-  float_array_vtable = create_primitive_vtable ("float");
-  double_array_vtable = create_primitive_vtable ("double");
-
-  one_elt_array_domain_type = build_index_type (integer_one_node);
-  utf8const_type = make_node (RECORD_TYPE);
-  PUSH_FIELD (input_location,
-	      utf8const_type, field, "hash", unsigned_short_type_node);
-  PUSH_FIELD (input_location,
-	      utf8const_type, field, "length", unsigned_short_type_node);
-  FINISH_RECORD (utf8const_type);
-  utf8const_ptr_type = build_pointer_type (utf8const_type);
-
-  atable_type = build_array_type (ptr_type_node, 
-				  one_elt_array_domain_type);
-  TYPE_NONALIASED_COMPONENT (atable_type) = 1;
-  atable_ptr_type = build_pointer_type (atable_type);
-
-  itable_type = build_array_type (ptr_type_node, 
-				  one_elt_array_domain_type);
-  TYPE_NONALIASED_COMPONENT (itable_type) = 1;
-  itable_ptr_type = build_pointer_type (itable_type);
-
-  symbol_type = make_node (RECORD_TYPE);
-  PUSH_FIELD (input_location,
-	      symbol_type, field, "clname", utf8const_ptr_type);
-  PUSH_FIELD (input_location, symbol_type, field, "name", utf8const_ptr_type);
-  PUSH_FIELD (input_location,
-	      symbol_type, field, "signature", utf8const_ptr_type);
-  FINISH_RECORD (symbol_type);
-
-  symbols_array_type = build_array_type (symbol_type, 
-					 one_elt_array_domain_type);
-  symbols_array_ptr_type = build_pointer_type (symbols_array_type);
-
-  assertion_entry_type = make_node (RECORD_TYPE);
-  PUSH_FIELD (input_location,
-	      assertion_entry_type, field, "assertion_code", integer_type_node);
-  PUSH_FIELD (input_location,
-	      assertion_entry_type, field, "op1", utf8const_ptr_type);
-  PUSH_FIELD (input_location,
-	      assertion_entry_type, field, "op2", utf8const_ptr_type);
-  FINISH_RECORD (assertion_entry_type);
-  
-  assertion_table_type = build_array_type (assertion_entry_type,
-                                           one_elt_array_domain_type);
-
-  /* As you're adding items here, please update the code right after
-     this section, so that the filename containing the source code of
-     the pre-defined class gets registered correctly. */
-  unqualified_object_id_node = get_identifier ("Object");
-  object_type_node = lookup_class (get_identifier ("java.lang.Object"));
-  object_ptr_type_node = promote_type (object_type_node);
-  string_type_node = lookup_class (get_identifier ("java.lang.String"));
-  string_ptr_type_node = promote_type (string_type_node);
-  class_type_node = lookup_class (get_identifier ("java.lang.Class"));
-  throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable"));
-  exception_type_node = lookup_class (get_identifier ("java.lang.Exception"));
-  runtime_exception_type_node = 
-    lookup_class (get_identifier ("java.lang.RuntimeException"));
-  error_exception_type_node = 
-    lookup_class (get_identifier ("java.lang.Error"));
-
-  rawdata_ptr_type_node
-    = promote_type (lookup_class (get_identifier ("gnu.gcj.RawData")));
-
-  add_predefined_file (get_identifier ("java/lang/Class.java"));
-  add_predefined_file (get_identifier ("java/lang/Error.java"));
-  add_predefined_file (get_identifier ("java/lang/Object.java"));
-  add_predefined_file (get_identifier ("java/lang/RuntimeException.java"));
-  add_predefined_file (get_identifier ("java/lang/String.java"));
-  add_predefined_file (get_identifier ("java/lang/Throwable.java"));
-  add_predefined_file (get_identifier ("gnu/gcj/RawData.java"));
-  add_predefined_file (get_identifier ("java/lang/Exception.java"));
-  add_predefined_file (get_identifier ("java/lang/ClassNotFoundException.java"));
-  add_predefined_file (get_identifier ("java/lang/NoClassDefFoundError.java"));
-
-  methodtable_type = make_node (RECORD_TYPE);
-  layout_type (methodtable_type);
-  build_decl (BUILTINS_LOCATION,
-	      TYPE_DECL, get_identifier ("methodtable"), methodtable_type);
-  methodtable_ptr_type = build_pointer_type (methodtable_type);
-
-  TYPE_identifier_node = get_identifier ("TYPE");
-  init_identifier_node = get_identifier ("<init>");
-  clinit_identifier_node = get_identifier ("<clinit>");
-  void_signature_node = get_identifier ("()V");
-  finalize_identifier_node = get_identifier ("finalize");
-  this_identifier_node = get_identifier ("this");
-
-  java_lang_cloneable_identifier_node = get_identifier ("java.lang.Cloneable");
-  java_io_serializable_identifier_node =
-    get_identifier ("java.io.Serializable");
-
-  /* for lack of a better place to put this stub call */
-  init_expr_processing();
-
-  constants_type_node = make_node (RECORD_TYPE);
-  PUSH_FIELD (input_location,
-	      constants_type_node, field, "size", unsigned_int_type_node);
-  PUSH_FIELD (input_location,
-	      constants_type_node, field, "tags", ptr_type_node);
-  PUSH_FIELD (input_location,
-	      constants_type_node, field, "data", ptr_type_node);
-  constants_data_field_decl_node = field;
-  FINISH_RECORD (constants_type_node);
-  build_decl (BUILTINS_LOCATION,
-	      TYPE_DECL, get_identifier ("constants"), constants_type_node);
-
-  access_flags_type_node = unsigned_short_type_node;
-
-  dtable_type = make_node (RECORD_TYPE);
-  dtable_ptr_type = build_pointer_type (dtable_type);
-
-  otable_type = build_array_type (integer_type_node, 
-				  one_elt_array_domain_type);
-  TYPE_NONALIASED_COMPONENT (otable_type) = 1;
-  otable_ptr_type = build_pointer_type (otable_type);
-
-  PUSH_FIELD (input_location,
-	      object_type_node, field, "vtable", dtable_ptr_type);
-  DECL_FCONTEXT (field) = object_type_node;
-  TYPE_VFIELD (object_type_node) = field;
-
-  /* This isn't exactly true, but it is what we have in the source.
-     There is an unresolved issue here, which is whether the vtable
-     should be marked by the GC.  */
-  if (! flag_hash_synchronization)
-    PUSH_FIELD (input_location, object_type_node, field, "sync_info",
-		build_pointer_type (object_type_node));
-  for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = DECL_CHAIN (t))
-    FIELD_PRIVATE (t) = 1;
-  FINISH_RECORD (object_type_node);
-
-  field_type_node = make_node (RECORD_TYPE);
-  field_ptr_type_node = build_pointer_type (field_type_node);
-  method_type_node = make_node (RECORD_TYPE);
-  method_ptr_type_node = build_pointer_type (method_type_node);
-
-  set_super_info (0, class_type_node, object_type_node, 0);
-  set_super_info (0, string_type_node, object_type_node, 0);
-  class_ptr_type = build_pointer_type (class_type_node);
-
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "next_or_version", class_ptr_type);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "name", utf8const_ptr_type);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "accflags", access_flags_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "superclass", class_ptr_type);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "constants", constants_type_node);
-  constants_field_decl_node = field;
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "methods", method_ptr_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "method_count", short_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "vtable_method_count", short_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "fields", field_ptr_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "size_in_bytes", int_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "field_count", short_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "static_field_count", short_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "vtable", dtable_ptr_type);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "otable", otable_ptr_type);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "otable_syms", 
-  	      symbols_array_ptr_type);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "atable", atable_ptr_type);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "atable_syms", 
-  	      symbols_array_ptr_type);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "itable", itable_ptr_type);
-  PUSH_FIELD (input_location, class_type_node, field, "itable_syms", 
-  	      symbols_array_ptr_type);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "catch_classes", ptr_type_node);
-  PUSH_FIELD (input_location, class_type_node, field, "interfaces",
-	      build_pointer_type (class_ptr_type));
-  PUSH_FIELD (input_location, class_type_node, field, "loader", ptr_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "interface_count", short_type_node);
-  PUSH_FIELD (input_location, class_type_node, field, "state", byte_type_node);
-  PUSH_FIELD (input_location, class_type_node, field, "thread", ptr_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "depth", short_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "ancestors", ptr_type_node);
-  PUSH_FIELD (input_location, class_type_node, field, "idt", ptr_type_node);  
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "arrayclass", ptr_type_node);  
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "protectionDomain", ptr_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "assertion_table", ptr_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "hack_signers", ptr_type_node);
-  PUSH_FIELD (input_location, class_type_node, field, "chain", ptr_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "aux_info", ptr_type_node);
-  PUSH_FIELD (input_location, class_type_node, field, "engine", ptr_type_node);
-  PUSH_FIELD (input_location,
-	      class_type_node, field, "reflection_data", ptr_type_node);
-  for (t = TYPE_FIELDS (class_type_node);  t != NULL_TREE;  t = DECL_CHAIN (t))
-    FIELD_PRIVATE (t) = 1;
-  push_super_field (class_type_node, object_type_node);
-
-  FINISH_RECORD (class_type_node);
-  build_decl (BUILTINS_LOCATION,
-	      TYPE_DECL, get_identifier ("Class"), class_type_node);
-
-  field_info_union_node = make_node (UNION_TYPE);
-  PUSH_FIELD (input_location,
-	      field_info_union_node, field, "boffset", int_type_node);
-  PUSH_FIELD (input_location,
-	      field_info_union_node, field, "addr", ptr_type_node);
-  layout_type (field_info_union_node);
-
-  PUSH_FIELD (input_location,
-	      field_type_node, field, "name", utf8const_ptr_type);
-  PUSH_FIELD (input_location, field_type_node, field, "type", class_ptr_type);
-  PUSH_FIELD (input_location,
-	      field_type_node, field, "accflags", access_flags_type_node);
-  PUSH_FIELD (input_location,
-	      field_type_node, field, "bsize", unsigned_short_type_node);
-  PUSH_FIELD (input_location,
-	      field_type_node, field, "info", field_info_union_node);
-  FINISH_RECORD (field_type_node);
-  build_decl (BUILTINS_LOCATION,
-	      TYPE_DECL, get_identifier ("Field"), field_type_node);
-
-  nativecode_ptr_array_type_node
-    = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type);
-
-  PUSH_FIELD (input_location,
-	      dtable_type, field, "class", class_ptr_type);
-  PUSH_FIELD (input_location,
-	      dtable_type, field, "methods", nativecode_ptr_array_type_node);
-  FINISH_RECORD (dtable_type);
-  build_decl (BUILTINS_LOCATION,
-	      TYPE_DECL, get_identifier ("dispatchTable"), dtable_type);
-
-  jexception_type = make_node (RECORD_TYPE);
-  PUSH_FIELD (input_location,
-	      jexception_type, field, "start_pc", ptr_type_node);
-  PUSH_FIELD (input_location, jexception_type, field, "end_pc", ptr_type_node);
-  PUSH_FIELD (input_location,
-	      jexception_type, field, "handler_pc", ptr_type_node);
-  PUSH_FIELD (input_location,
-	      jexception_type, field, "catch_type", class_ptr_type);
-  FINISH_RECORD (jexception_type);
-  build_decl (BUILTINS_LOCATION,
-	      TYPE_DECL, get_identifier ("jexception"), field_type_node);
-  jexception_ptr_type = build_pointer_type (jexception_type);
-
-  lineNumberEntry_type = make_node (RECORD_TYPE);
-  PUSH_FIELD (input_location,
-	      lineNumberEntry_type, field, "line_nr", unsigned_short_type_node);
-  PUSH_FIELD (input_location,
-	      lineNumberEntry_type, field, "start_pc", ptr_type_node);
-  FINISH_RECORD (lineNumberEntry_type);
-
-  lineNumbers_type = make_node (RECORD_TYPE);
-  PUSH_FIELD (input_location,
-	      lineNumbers_type, field, "length", unsigned_int_type_node);
-  FINISH_RECORD (lineNumbers_type);
-
-  PUSH_FIELD (input_location,
-	      method_type_node, field, "name", utf8const_ptr_type);
-  PUSH_FIELD (input_location,
-	      method_type_node, field, "signature", utf8const_ptr_type);
-  PUSH_FIELD (input_location,
-	      method_type_node, field, "accflags", access_flags_type_node);
-  PUSH_FIELD (input_location,
-	      method_type_node, field, "index", unsigned_short_type_node);
-  PUSH_FIELD (input_location,
-	      method_type_node, field, "ncode", nativecode_ptr_type_node);
-  PUSH_FIELD (input_location,
-	      method_type_node, field, "throws", ptr_type_node);
-  FINISH_RECORD (method_type_node);
-  build_decl (BUILTINS_LOCATION,
-	      TYPE_DECL, get_identifier ("Method"), method_type_node);
-
-  end_params_node = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
-
-  t = build_function_type_list (ptr_type_node, class_ptr_type, NULL_TREE);
-  alloc_object_node = add_builtin_function ("_Jv_AllocObject", t,
-					    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  DECL_IS_MALLOC (alloc_object_node) = 1;
-  alloc_no_finalizer_node =
-    add_builtin_function ("_Jv_AllocObjectNoFinalizer", t,
-			  0, NOT_BUILT_IN, NULL, NULL_TREE);
-  DECL_IS_MALLOC (alloc_no_finalizer_node) = 1;
-
-  t = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
-  soft_initclass_node = add_builtin_function ("_Jv_InitClass", t,
-					      0, NOT_BUILT_IN, NULL, NULL_TREE);
-  t = build_function_type_list (ptr_type_node,
-				class_ptr_type, int_type_node, NULL_TREE);
-  soft_resolvepoolentry_node
-    = add_builtin_function ("_Jv_ResolvePoolEntry", t,
-			    0,NOT_BUILT_IN, NULL, NULL_TREE);
-  DECL_PURE_P (soft_resolvepoolentry_node) = 1;
-  t = build_function_type_list (void_type_node,
-				class_ptr_type, int_type_node, NULL_TREE);
-  throw_node = add_builtin_function ("_Jv_Throw", t,
-				     0, NOT_BUILT_IN, NULL, NULL_TREE);
-  /* Mark throw_nodes as `noreturn' functions with side effects.  */
-  TREE_THIS_VOLATILE (throw_node) = 1;
-  TREE_SIDE_EFFECTS (throw_node) = 1;
-
-  t = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
-  soft_monitorenter_node
-    = add_builtin_function ("_Jv_MonitorEnter", t, 0, NOT_BUILT_IN,
-			    NULL, NULL_TREE);
-  soft_monitorexit_node
-    = add_builtin_function ("_Jv_MonitorExit", t, 0, NOT_BUILT_IN,
-			    NULL, NULL_TREE);
-
-  t = build_function_type_list (ptr_type_node,
-				ptr_type_node, int_type_node, NULL_TREE);
-  soft_newarray_node
-      = add_builtin_function ("_Jv_NewPrimArray", t,
-			      0, NOT_BUILT_IN, NULL, NULL_TREE);
-  DECL_IS_MALLOC (soft_newarray_node) = 1;
-
-  t = build_function_type_list (ptr_type_node,
-				int_type_node, class_ptr_type,
-				object_ptr_type_node, NULL_TREE);
-  soft_anewarray_node
-      = add_builtin_function ("_Jv_NewObjectArray", t,
-			      0, NOT_BUILT_IN, NULL, NULL_TREE);
-  DECL_IS_MALLOC (soft_anewarray_node) = 1;
-
-  t = build_varargs_function_type_list (ptr_type_node,
-					ptr_type_node, int_type_node,
-					NULL_TREE);
-  soft_multianewarray_node
-      = add_builtin_function ("_Jv_NewMultiArray", t,
-			      0, NOT_BUILT_IN, NULL, NULL_TREE);
-  DECL_IS_MALLOC (soft_multianewarray_node) = 1;
-
-  t = build_function_type_list (void_type_node, int_type_node, NULL_TREE);
-  soft_badarrayindex_node
-      = add_builtin_function ("_Jv_ThrowBadArrayIndex", t,
-			      0, NOT_BUILT_IN, NULL, NULL_TREE);
-  /* Mark soft_badarrayindex_node as a `noreturn' function with side
-     effects.  */
-  TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
-  TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
-
-  t = build_function_type_list (void_type_node, NULL_TREE);
-  soft_nullpointer_node
-    = add_builtin_function ("_Jv_ThrowNullPointerException", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  /* Mark soft_nullpointer_node as a `noreturn' function with side
-     effects.  */
-  TREE_THIS_VOLATILE (soft_nullpointer_node) = 1;
-  TREE_SIDE_EFFECTS (soft_nullpointer_node) = 1;
-
-  soft_abstractmethod_node
-    = add_builtin_function ("_Jv_ThrowAbstractMethodError", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  /* Mark soft_abstractmethod_node as a `noreturn' function with side
-     effects.  */
-  TREE_THIS_VOLATILE (soft_abstractmethod_node) = 1;
-  TREE_SIDE_EFFECTS (soft_abstractmethod_node) = 1;
-
-  soft_nosuchfield_node
-    = add_builtin_function ("_Jv_ThrowNoSuchFieldError", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  /* Mark soft_nosuchfield_node as a `noreturn' function with side
-     effects.  */
-  TREE_THIS_VOLATILE (soft_nosuchfield_node) = 1;
-  TREE_SIDE_EFFECTS (soft_nosuchfield_node) = 1;
-
-  t = build_function_type_list (ptr_type_node,
-				class_ptr_type, object_ptr_type_node,
-				NULL_TREE);
-  soft_checkcast_node
-    = add_builtin_function ("_Jv_CheckCast", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  t = build_function_type_list (boolean_type_node,
-				object_ptr_type_node, class_ptr_type,
-				NULL_TREE);
-  soft_instanceof_node
-    = add_builtin_function ("_Jv_IsInstanceOf", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  DECL_PURE_P (soft_instanceof_node) = 1;
-  t = build_function_type_list (void_type_node,
-				object_ptr_type_node, object_ptr_type_node,
-				NULL_TREE);
-  soft_checkarraystore_node
-    = add_builtin_function ("_Jv_CheckArrayStore", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  t = build_function_type_list (ptr_type_node,
-				ptr_type_node, ptr_type_node, int_type_node,
-				NULL_TREE);
-  soft_lookupinterfacemethod_node
-    = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  DECL_PURE_P (soft_lookupinterfacemethod_node) = 1;
-
-  t = build_function_type_list (ptr_type_node,
-				ptr_type_node, ptr_type_node, ptr_type_node,
-				NULL_TREE);
-  soft_lookupinterfacemethodbyname_node
-    = add_builtin_function ("_Jv_LookupInterfaceMethod", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  t = build_function_type_list (ptr_type_node,
-				object_ptr_type_node, ptr_type_node,
-				ptr_type_node, int_type_node, NULL_TREE);
-  soft_lookupjnimethod_node
-    = add_builtin_function ("_Jv_LookupJNIMethod", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  t = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE);
-  soft_getjnienvnewframe_node
-    = add_builtin_function ("_Jv_GetJNIEnvNewFrame", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-  t = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
-  soft_jnipopsystemframe_node
-    = add_builtin_function ("_Jv_JNI_PopSystemFrame", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-
-  t = build_function_type_list (object_ptr_type_node,
-				object_ptr_type_node, NULL_TREE);
-  soft_unwrapjni_node
-    = add_builtin_function ("_Jv_UnwrapJNIweakReference", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-
-  t = build_function_type_list (int_type_node,
-				int_type_node, int_type_node, NULL_TREE);
-  soft_idiv_node
-    = add_builtin_function ("_Jv_divI", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-
-  soft_irem_node
-    = add_builtin_function ("_Jv_remI", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-
-  t = build_function_type_list (long_type_node,
-				long_type_node, long_type_node, NULL_TREE);
-  soft_ldiv_node
-    = add_builtin_function ("_Jv_divJ", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-
-  soft_lrem_node
-    = add_builtin_function ("_Jv_remJ", t,
-			    0, NOT_BUILT_IN, NULL, NULL_TREE);
-
-  initialize_builtins ();
-
-  soft_fmod_node = builtin_decl_explicit (BUILT_IN_FMOD);
-
-  parse_version ();
-}
-
-
-/* Look up NAME in the current binding level and its superiors
-   in the namespace of variables, functions and typedefs.
-   Return a ..._DECL node of some kind representing its definition,
-   or return 0 if it is undefined.  */
-
-tree
-lookup_name (tree name)
-{
-  tree val;
-  if (current_binding_level != global_binding_level
-      && IDENTIFIER_LOCAL_VALUE (name))
-    val = IDENTIFIER_LOCAL_VALUE (name);
-  else
-    val = IDENTIFIER_GLOBAL_VALUE (name);
-  return val;
-}
-
-/* Similar to `lookup_name' but look only at current binding level and
-   the previous one if it's the parameter level.  */
-
-static tree
-lookup_name_current_level (tree name)
-{
-  tree t;
-
-  if (current_binding_level == global_binding_level)
-    return IDENTIFIER_GLOBAL_VALUE (name);
-
-  if (IDENTIFIER_LOCAL_VALUE (name) == 0)
-    return 0;
-
-  for (t = current_binding_level->names; t; t = DECL_CHAIN (t))
-    if (DECL_NAME (t) == name)
-      break;
-
-  return t;
-}
-
-/* Record a decl-node X as belonging to the current lexical scope.
-   Check for errors (such as an incompatible declaration for the same
-   name already seen in the same scope).
-
-   Returns either X or an old decl for the same name.
-   If an old decl is returned, it may have been smashed
-   to agree with what X says.  */
-
-tree
-pushdecl (tree x)
-{
-  tree t;
-  tree name = DECL_NAME (x);
-  struct binding_level *b = current_binding_level;
-  
-  if (TREE_CODE (x) != TYPE_DECL)
-    DECL_CONTEXT (x) = current_function_decl;
-  if (name)
-    {
-      t = lookup_name_current_level (name);
-      if (t != 0 && t == error_mark_node)
-	/* error_mark_node is 0 for a while during initialization!  */
-	{
-	  t = 0;
-	  error ("%q+D used prior to declaration", x);
-	}
-
-      /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
-	 to point to the TYPE_DECL.
-	 Since Java does not have typedefs, a type can only have
-	 one (true) name, given by a class, interface, or builtin. */
-      if (TREE_CODE (x) == TYPE_DECL
-	  && TYPE_NAME (TREE_TYPE (x)) == 0
-	  && TREE_TYPE (x) != error_mark_node)
-	{
-	  TYPE_NAME (TREE_TYPE (x)) = x;
-	  TYPE_STUB_DECL (TREE_TYPE (x)) = x;
-	}
-
-      /* This name is new in its binding level.
-	 Install the new declaration and return it.  */
-      if (b == global_binding_level)
-	{
-	  /* Install a global value.  */
-	  
-	  IDENTIFIER_GLOBAL_VALUE (name) = x;
-	}
-      else
-	{
-	  /* Here to install a non-global value.  */
-	  tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
-	  IDENTIFIER_LOCAL_VALUE (name) = x;
-
-	  /* If storing a local value, there may already be one (inherited).
-	     If so, record it for restoration when this binding level ends.  */
-	  if (oldlocal != 0)
-	    b->shadowed = tree_cons (name, oldlocal, b->shadowed);
-	}
-    }
-
-  /* Put decls on list in reverse order.
-     We will reverse them later if necessary.  */
-  DECL_CHAIN (x) = b->names;
-  b->names = x;
-
-  return x;
-}
-
-void
-pushdecl_force_head (tree x)
-{
-  current_binding_level->names = x;
-}
-
-/* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate.  */
-
-tree
-pushdecl_top_level (tree x)
-{
-  tree t;
-  struct binding_level *b = current_binding_level;
-
-  current_binding_level = global_binding_level;
-  t = pushdecl (x);
-  current_binding_level = b;
-  return t;
-}
-
-/* Like pushdecl, only it places X in FUNCTION_BINDING_LEVEL, if appropriate.  */
-
-tree
-pushdecl_function_level (tree x)
-{
-  tree t;
-  struct binding_level *b = current_binding_level;
-
-  current_binding_level = function_binding_level;
-  t = pushdecl (x);
-  current_binding_level = b;
-  return t;
-}
-
-/* Return true if we are in the global binding level.  */
-
-bool
-global_bindings_p (void)
-{
-  return current_binding_level == global_binding_level;
-}
-
-/* Return the list of declarations of the current level.
-   Note that this list is in reverse order unless/until
-   you nreverse it; and when you do nreverse it, you must
-   store the result back using `storedecls' or you will lose.  */
-
-tree
-getdecls (void)
-{
-  return current_binding_level->names;
-}
-
-/* Create a new `struct binding_level'.  */
-
-static struct binding_level *
-make_binding_level (void)
-{
-  /* NOSTRICT */
-  return ggc_cleared_alloc<binding_level> ();
-}
-
-void
-pushlevel (int unused ATTRIBUTE_UNUSED)
-{
-  struct binding_level *newlevel = NULL_BINDING_LEVEL;
-
-  /* Reuse or create a struct for this binding level.  */
-
-  if (free_binding_level)
-    {
-      newlevel = free_binding_level;
-      free_binding_level = free_binding_level->level_chain;
-    }
-  else
-    {
-      newlevel = make_binding_level ();
-    }
-
-  /* Add this level to the front of the chain (stack) of levels that
-     are active.  */
-
-  *newlevel = clear_binding_level;
-  newlevel->level_chain = current_binding_level;
-  newlevel->loc = input_location;
-  current_binding_level = newlevel;  
-#if defined(DEBUG_JAVA_BINDING_LEVELS)
-  newlevel->binding_depth = binding_depth;
-  indent ();
-  fprintf (stderr, "push %s level %p pc %d\n",
-	   (is_class_level) ? "class" : "block", newlevel, current_pc);
-  is_class_level = 0;
-  binding_depth++;
-#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
-}
-
-/* Exit a binding level.
-   Pop the level off, and restore the state of the identifier-decl mappings
-   that were in effect when this level was entered.
-
-   If KEEP is nonzero, this level had explicit declarations, so
-   and create a "block" (a BLOCK node) for the level
-   to record its declarations and subblocks for symbol table output.
-
-   If FUNCTIONBODY is nonzero, this level is the body of a function,
-   so create a block as if KEEP were set and also clear out all
-   label names.
-
-   If REVERSE is nonzero, reverse the order of decls before putting
-   them into the BLOCK.  */
-
-tree
-poplevel (int keep, int reverse, int functionbody)
-{
-  tree link;
-  /* The chain of decls was accumulated in reverse order.
-     Put it into forward order, just for cleanliness.  */
-  tree decls;
-  tree subblocks = current_binding_level->blocks;
-  tree block = 0;
-  tree decl;
-  tree bind = 0;
-
-#if defined(DEBUG_JAVA_BINDING_LEVELS)
-  binding_depth--;
-  indent ();
-  if (current_binding_level->end_pc != LARGEST_PC)
-    fprintf (stderr, "pop  %s level %p pc %d (end pc %d)\n",
-	     (is_class_level) ? "class" : "block", current_binding_level, current_pc,
-	     current_binding_level->end_pc);
-  else
-    fprintf (stderr, "pop  %s level %p pc %d\n",
-	     (is_class_level) ? "class" : "block", current_binding_level, current_pc);
-#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
-
-  /* Get the decls in the order they were written.
-     Usually current_binding_level->names is in reverse order.
-     But parameter decls were previously put in forward order.  */
-
-  if (reverse)
-    current_binding_level->names
-      = decls = nreverse (current_binding_level->names);
-  else
-    decls = current_binding_level->names;
-
-  for (decl = decls; decl; decl = DECL_CHAIN (decl))
-    if (TREE_CODE (decl) == VAR_DECL
-	&& DECL_LANG_SPECIFIC (decl) != NULL
-	&& DECL_LOCAL_SLOT_NUMBER (decl))
-      LOCAL_VAR_OUT_OF_SCOPE_P (decl) = 1;
-
-  /* If there were any declarations in that level,
-     or if this level is a function body,
-     create a BLOCK to record them for the life of this function.  */
-
-  block = 0;
-  if (keep || functionbody)
-    block = make_node (BLOCK);
-
-  if (current_binding_level->exception_range)
-    expand_end_java_handler (current_binding_level->exception_range);
-
-  if (block != 0)
-    {
-      /* If any statements have been generated at this level, create a
-	 BIND_EXPR to hold them and copy the variables to it.  This
-	 only applies to the bytecode compiler.  */
-      if (current_binding_level->stmts)
-	{
-	  tree decl = decls;
-	  tree *var = &BLOCK_VARS (block);
-
-	  /* Copy decls from names list, ignoring labels.  */
-	  while (decl)
-	    {
-	      tree next = DECL_CHAIN (decl);
-	      if (TREE_CODE (decl) != LABEL_DECL)
-		{
-		  *var = decl;
-		  var = &DECL_CHAIN (decl);
-		}
-	      decl = next;
-	    }
-	  *var = NULL;
-	    
-	  bind = build3 (BIND_EXPR, void_type_node, BLOCK_VARS (block), 
-			 BLOCK_EXPR_BODY (block), block);
-	  BIND_EXPR_BODY (bind) = current_binding_level->stmts;
-	  
-	  if (BIND_EXPR_BODY (bind)
-	      && TREE_SIDE_EFFECTS (BIND_EXPR_BODY (bind)))
-	    TREE_SIDE_EFFECTS (bind) = 1;
-	  
-	  /* FIXME: gimplifier brain damage.  */
-	  if (BIND_EXPR_BODY (bind) == NULL)
-	    BIND_EXPR_BODY (bind) = build_java_empty_stmt ();
-
-	  SET_EXPR_LOCATION (bind, current_binding_level->loc);
-
-	  current_binding_level->stmts = NULL;
-	}
-      else
-	{
-	  BLOCK_VARS (block) = decls;
-	}
-      BLOCK_SUBBLOCKS (block) = subblocks;
-    }	
-
-  /* In each subblock, record that this is its superior.  */
-
-  for (link = subblocks; link; link = BLOCK_CHAIN (link))
-    BLOCK_SUPERCONTEXT (link) = block;
-
-  /* Clear out the meanings of the local variables of this level.  */
-
-  for (link = decls; link; link = DECL_CHAIN (link))
-    {
-      tree name = DECL_NAME (link);
-      if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link)
-	{
-	  /* If the ident. was used or addressed via a local extern decl,
-	     don't forget that fact.  */
-	  if (DECL_EXTERNAL (link))
-	    {
-	      if (TREE_USED (link))
-		TREE_USED (name) = 1;
-	      if (TREE_ADDRESSABLE (link))
-		TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
-	    }
-	  IDENTIFIER_LOCAL_VALUE (name) = 0;
-	}
-    }
-
-  /* Restore all name-meanings of the outer levels
-     that were shadowed by this level.  */
-
-  for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
-    IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
-
-  /* If the level being exited is the top level of a function,
-     check over all the labels, and clear out the current
-     (function local) meanings of their names.  */
-
-  if (functionbody)
-    {
-      /* If this is the top level block of a function,
-	 the vars are the function's parameters.
-	 Don't leave them in the BLOCK because they are
-	 found in the FUNCTION_DECL instead.  */
-
-      BLOCK_VARS (block) = 0;
-    }
-
-  /* Pop the current level, and free the structure for reuse.  */
-
-  {
-    struct binding_level *level = current_binding_level;
-    current_binding_level = current_binding_level->level_chain;
-
-    level->level_chain = free_binding_level;
-    free_binding_level = level;
-  }
-
-  /* Dispose of the block that we just made inside some higher level.  */
-  if (functionbody)
-    {
-      DECL_INITIAL (current_function_decl) = block;
-      DECL_SAVED_TREE (current_function_decl) = bind;
-    }
-  else 
-    {
-      if (block)
-	{
-	  current_binding_level->blocks
-	    = block_chainon (current_binding_level->blocks, block);
-	}
-      /* If we did not make a block for the level just exited,
-	 any blocks made for inner levels
-	 (since they cannot be recorded as subblocks in that level)
-	 must be carried forward so they will later become subblocks
-	 of something else.  */
-      else if (subblocks)
-	current_binding_level->blocks
-	  = block_chainon (current_binding_level->blocks, subblocks);
-
-      if (bind)
-	java_add_stmt (bind);
-    }
-
-  if (block)
-    TREE_USED (block) = 1;
-  return block;
-}
-
-void
-maybe_pushlevels (int pc)
-{
-#if defined(DEBUG_JAVA_BINDING_LEVELS)
-  current_pc = pc;
-#endif
-
-  while (pending_local_decls != NULL_TREE &&
-	 DECL_LOCAL_START_PC (pending_local_decls) <= pc)
-    {
-      tree *ptr = &pending_local_decls;
-      tree decl = *ptr, next;
-      int end_pc = DECL_LOCAL_END_PC (decl);
-
-      while (*ptr != NULL_TREE
-	     && DECL_LOCAL_START_PC (*ptr) <= pc
-	     && DECL_LOCAL_END_PC (*ptr) == end_pc)
-	ptr = &DECL_CHAIN (*ptr);
-      pending_local_decls = *ptr;
-      *ptr = NULL_TREE;
-
-      /* Force non-nested range to be nested in current range by
-	 truncating variable lifetimes. */
-      if (end_pc > current_binding_level->end_pc)
-	{
-	  tree t;
-	  end_pc = current_binding_level->end_pc;
-	  for (t = decl; t != NULL_TREE; t = DECL_CHAIN (t))
-	    DECL_LOCAL_END_PC (t) = end_pc;
-	}
-
-      maybe_start_try (pc, end_pc);
-      
-      pushlevel (1);
-
-      current_binding_level->end_pc = end_pc;
-      current_binding_level->start_pc = pc;      
-      current_binding_level->names = NULL;
-      for ( ; decl != NULL_TREE; decl = next)
-	{
-	  int index = DECL_LOCAL_SLOT_NUMBER (decl);
-	  tree base_decl;
-	  next = DECL_CHAIN (decl);
-	  push_jvm_slot (index, decl);
-	  pushdecl (decl);
-	  base_decl
-	    = find_local_variable (index, TREE_TYPE (decl), pc);
-	  if (TREE_CODE (TREE_TYPE (base_decl)) == POINTER_TYPE)
-	    base_decl = TREE_VEC_ELT (base_decl_map, index);
-	  SET_DECL_VALUE_EXPR (decl, base_decl);
-	  DECL_HAS_VALUE_EXPR_P (decl) = 1;
-	}
-    }      
-
-  maybe_start_try (pc, 0);
-}
-
-void
-maybe_poplevels (int pc)
-{
-#if defined(DEBUG_JAVA_BINDING_LEVELS)
-  current_pc = pc;
-#endif
-
-  /* FIXME: I'm pretty sure that this is wrong.  Variable scopes are
-     inclusive, so a variable is live if pc == end_pc.  Here, we
-     terminate a range if the current pc is equal to the end of the
-     range, and this is *before* we have generated code for the
-     instruction at end_pc.  We're closing a binding level one
-     instruction too early.*/
-  while (current_binding_level->end_pc <= pc)
-    poplevel (1, 0, 0);
-}
-
-/* Terminate any binding which began during the range beginning at
-   start_pc.  This tidies up improperly nested local variable ranges
-   and exception handlers; a variable declared within an exception
-   range is forcibly terminated when that exception ends. */
-
-void
-force_poplevels (int start_pc)
-{
-  while (current_binding_level->start_pc > start_pc)
-    {
-      if (pedantic && current_binding_level->start_pc > start_pc)
-	warning (0, "In %+D: overlapped variable and exception ranges at %d",
-                 current_function_decl,
-		 current_binding_level->start_pc);
-      poplevel (1, 0, 0);
-    }
-}
-
-/* integrate_decl_tree calls this function. */
-
-void
-java_dup_lang_specific_decl (tree node)
-{
-  int lang_decl_size;
-  struct lang_decl *x;
-
-  if (!DECL_LANG_SPECIFIC (node))
-    return;
-
-  lang_decl_size = sizeof (struct lang_decl);
-  x = ggc_alloc<struct lang_decl> ();
-  memcpy (x, DECL_LANG_SPECIFIC (node), lang_decl_size);
-  DECL_LANG_SPECIFIC (node) = x;
-}
-
-void
-give_name_to_locals (JCF *jcf)
-{
-  int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl);
-  int code_offset = DECL_CODE_OFFSET (current_function_decl);
-  tree parm;
-  pending_local_decls = NULL_TREE;
-  if (n == 0)
-    return;
-  JCF_SEEK (jcf, n);
-  n = JCF_readu2 (jcf);
-  for (i = 0; i < n; i++)
-    {
-      int start_pc = JCF_readu2 (jcf);
-      int length = JCF_readu2 (jcf);
-      int name_index = JCF_readu2 (jcf);
-      int signature_index = JCF_readu2 (jcf);
-      int slot = JCF_readu2 (jcf);
-      tree name = get_name_constant (jcf, name_index);
-      tree type = parse_signature (jcf, signature_index);
-      if (slot < DECL_ARG_SLOT_COUNT (current_function_decl)
-	  && start_pc == 0
-	  && length == DECL_CODE_LENGTH (current_function_decl))
-	{
-	  tree decl = TREE_VEC_ELT (decl_map, slot);
-	  DECL_NAME (decl) = name;
-	  if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
-	    warning (0, "bad type in parameter debug info");
-	}
-      else
-	{
-	  tree *ptr;
-	  int end_pc = start_pc + length;
-	  tree decl = build_decl (input_location, VAR_DECL, name, type);
-	  if (end_pc > DECL_CODE_LENGTH (current_function_decl))
-	    {
-	      warning (0, "bad PC range for debug info for local %q+D",
-                       decl);
-	      end_pc = DECL_CODE_LENGTH (current_function_decl);
-	    }
-
-	  /* Adjust start_pc if necessary so that the local's first
-	     store operation will use the relevant DECL as a
-	     destination. Fore more information, read the leading
-	     comments for expr.c:maybe_adjust_start_pc. */
-	  start_pc = maybe_adjust_start_pc (jcf, code_offset, start_pc, slot);
-
-	  MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
-	  DECL_LOCAL_SLOT_NUMBER (decl) = slot;
-	  DECL_LOCAL_START_PC (decl) = start_pc;
-	  DECL_LOCAL_END_PC (decl) = end_pc;
-
-	  /* Now insert the new decl in the proper place in
-	     pending_local_decls.  We are essentially doing an insertion sort,
-	     which works fine, since the list input will normally already
-	     be sorted. */
-	  ptr = &pending_local_decls;
-	  while (*ptr != NULL_TREE
-		 && (DECL_LOCAL_START_PC (*ptr) > start_pc
-		     || (DECL_LOCAL_START_PC (*ptr) == start_pc
-			 && DECL_LOCAL_END_PC (*ptr) < end_pc)))
-	    ptr = &DECL_CHAIN (*ptr);
-	  DECL_CHAIN (decl) = *ptr;
-	  *ptr = decl;
-	}
-    }
-
-  pending_local_decls = nreverse (pending_local_decls);
-
-  /* Fill in default names for the parameters. */ 
-  for (parm = DECL_ARGUMENTS (current_function_decl), i = 0;
-       parm != NULL_TREE;  parm = DECL_CHAIN (parm), i++)
-    {
-      if (DECL_NAME (parm) == NULL_TREE)
-	{
-	  int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i;
-	  if (arg_i == 0)
-	    DECL_NAME (parm) = get_identifier ("this");
-	  else
-	    {
-	      /* Buffer large enough for INT_MAX plus prefix.  */
-	      char buffer[15];
-	      sprintf (buffer, "ARG_%d", arg_i);
-	      DECL_NAME (parm) = get_identifier (buffer);
-	    }
-	}
-    }
-}
-
-tree
-build_result_decl (tree fndecl)
-{
-  tree restype = TREE_TYPE (TREE_TYPE (fndecl));
-  tree result = DECL_RESULT (fndecl);
-  if (! result)
-    {
-      result = build_decl (DECL_SOURCE_LOCATION (fndecl),
-			   RESULT_DECL, NULL_TREE, restype);
-      DECL_ARTIFICIAL (result) = 1;
-      DECL_IGNORED_P (result) = 1;
-      DECL_CONTEXT (result) = fndecl;
-      DECL_RESULT (fndecl) = result;
-    }
-  return result;
-}
-
-void
-start_java_method (tree fndecl)
-{
-  tree tem, *ptr;
-  int i;
-
-  uniq = 0;
-
-  current_function_decl = fndecl;
-  announce_function (fndecl);
-
-  i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
-  decl_map = make_tree_vec (i);
-  base_decl_map = make_tree_vec (i);
-  type_map = XRESIZEVEC (tree, type_map, i);
-
-#if defined(DEBUG_JAVA_BINDING_LEVELS)
-  fprintf (stderr, "%s:\n", lang_printable_name (fndecl, 2));
-  current_pc = 0;
-#endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
-  pushlevel (1);  /* Push parameters. */
-
-  ptr = &DECL_ARGUMENTS (fndecl);
-  for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
-       tem != end_params_node; tem = TREE_CHAIN (tem), i++)
-    {
-      tree parm_name = NULL_TREE, parm_decl;
-      tree parm_type = TREE_VALUE (tem);
-      gcc_assert (i < DECL_MAX_LOCALS (fndecl));
-
-      parm_decl = build_decl (input_location, PARM_DECL, parm_name, parm_type);
-      DECL_CONTEXT (parm_decl) = fndecl;
-      if (targetm.calls.promote_prototypes (parm_type)
-	  && TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
-	  && INTEGRAL_TYPE_P (parm_type))
-	parm_type = integer_type_node;
-      DECL_ARG_TYPE (parm_decl) = parm_type;
-
-      *ptr = parm_decl;
-      ptr = &DECL_CHAIN (parm_decl);
-
-      /* Add parm_decl to the decl_map. */
-      push_jvm_slot (i, parm_decl);
-
-      /* The this parameter of methods is artificial.  */
-      if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE && i == 0)
-	DECL_ARTIFICIAL (parm_decl) = 1;
-
-      type_map[i] = TREE_TYPE (parm_decl);
-      if (TYPE_IS_WIDE (TREE_TYPE (parm_decl)))
-	{
-	  i++;
-	  type_map[i] = void_type_node;
-	}
-    }
-  *ptr = NULL_TREE;
-  DECL_ARG_SLOT_COUNT (current_function_decl) = i;
-
-  while (i < DECL_MAX_LOCALS(fndecl))
-    type_map[i++] = NULL_TREE;
-
-  build_result_decl (fndecl);
-  DECL_SOURCE_LOCATION (fndecl) = input_location;
-
-  /* Push local variables.  */
-  pushlevel (2);
-
-  function_binding_level = current_binding_level;
-}
-
-void
-end_java_method (void)
-{
-  tree fndecl = current_function_decl;
-
-  /* pop out of function */
-  poplevel (1, 1, 0);
-
-  /* pop out of its parameters */
-  poplevel (1, 0, 1);
-
-  BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
-  
-  if (DECL_SAVED_TREE (fndecl))
-    {
-      tree fbody, block_body;
-      /* Before we check initialization, attached all class initialization
-	 variable to the block_body */
-      fbody = DECL_SAVED_TREE (fndecl);
-      block_body = BIND_EXPR_BODY (fbody);
-      hash_table<treetreehasher> *ht = DECL_FUNCTION_INIT_TEST_TABLE (fndecl);
-      ht->traverse<tree, attach_init_test_initialization_flags> (block_body);
-    }
-
-  finish_method (fndecl);
-
-  current_function_decl = NULL_TREE;
-  base_decl_map = NULL_TREE;
-}
-
-/* Prepare a method for expansion.  */
-
-void
-finish_method (tree fndecl)
-{
-  tree *tp = &DECL_SAVED_TREE (fndecl);
-
-  /* Wrap body of synchronized methods in a monitorenter,
-     plus monitorexit cleanup.  */
-  if (METHOD_SYNCHRONIZED (fndecl))
-    {
-      tree enter, exit, lock;
-      if (METHOD_STATIC (fndecl))
-	lock = build_class_ref (DECL_CONTEXT (fndecl));
-      else
-	lock = DECL_ARGUMENTS (fndecl);
-      BUILD_MONITOR_ENTER (enter, lock);
-      BUILD_MONITOR_EXIT (exit, lock);
-      *tp = build2 (COMPOUND_EXPR, void_type_node, enter,
-		    build2 (TRY_FINALLY_EXPR, void_type_node, *tp, exit));
-    }
-
-  /* Convert function tree to GENERIC prior to inlining.  */
-  java_genericize (fndecl);
-
-  /* Store the end of the function, so that we get good line number
-     info for the epilogue.  */
-  if (DECL_STRUCT_FUNCTION (fndecl))
-    set_cfun (DECL_STRUCT_FUNCTION (fndecl));
-  else
-    allocate_struct_function (fndecl, false);
-  cfun->function_end_locus = DECL_FUNCTION_LAST_LINE (fndecl);
-
-  /* Defer inlining and expansion to the cgraph optimizers.  */
-  cgraph_node::finalize_function (fndecl, false);
-}
-
-/* We pessimistically marked all methods and fields external until we
-   knew what set of classes we were planning to compile.  Now mark those
-   associated with CLASS to be generated locally as not external.  */
-
-static void
-java_mark_decl_local (tree decl)
-{
-  DECL_EXTERNAL (decl) = 0;
-
-  /* Double check that we didn't pass the function to the callgraph early.  */
-  if (flag_checking && TREE_CODE (decl) == FUNCTION_DECL)
-    {
-      struct cgraph_node *node = cgraph_node::get (decl);
-      gcc_assert (!node || !node->definition);
-    }
-  gcc_assert (!DECL_RTL_SET_P (decl));
-}
-
-/* Given appropriate target support, G++ will emit hidden aliases for native
-   methods.  Using this hidden name is required for proper operation of
-   _Jv_Method::ncode, but it doesn't hurt to use it everywhere.  Look for
-   proper target support, then mark the method for aliasing.  */
-
-static void
-java_mark_cni_decl_local (tree decl)
-{
-#if !defined(HAVE_GAS_HIDDEN) || !defined(ASM_OUTPUT_DEF)
-  return;
-#endif
-
-  DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
-  DECL_LOCAL_CNI_METHOD_P (decl) = 1;
-
-  /* Setting DECL_LOCAL_CNI_METHOD_P changes the behavior of the
-     mangler.  We might have already referenced this native method and
-     therefore created its name, but even if we have it won't hurt.
-     We'll just go via its externally visible name, rather than its
-     hidden alias.  However, we must force things so that the correct
-     mangling is done.  */
-
-  if (DECL_ASSEMBLER_NAME_SET_P (decl))
-    java_mangle_decl (decl);
-  if (DECL_RTL_SET_P (decl))
-    {
-      SET_DECL_RTL (decl, 0);
-      make_decl_rtl (decl);
-    }
-}
-
-/* Use the preceding two functions and mark all members of the class.  */
-
-void
-java_mark_class_local (tree klass)
-{
-  tree t;
-
-  for (t = TYPE_FIELDS (klass); t ; t = DECL_CHAIN (t))
-    if (FIELD_STATIC (t))
-      java_mark_decl_local (t);
-
-  for (t = TYPE_METHODS (klass); t ; t = DECL_CHAIN (t))
-    if (!METHOD_ABSTRACT (t))
-      {
-	if (METHOD_NATIVE (t) && !flag_jni)
-	  java_mark_cni_decl_local (t);
-        else
-	  java_mark_decl_local (t);
-      }
-}
-
-/* Add a statement to a compound_expr.  */
-
-tree
-add_stmt_to_compound (tree existing, tree type, tree stmt)
-{
-  if (!stmt)
-    return existing;
-  else if (existing)
-    {
-      tree expr = build2 (COMPOUND_EXPR, type, existing, stmt);
-      TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (existing)
-				 | TREE_SIDE_EFFECTS (stmt);
-      return expr;
-    }
-  else
-    return stmt;
-}
-
-/* If this node is an expr, mark its input location.  Called from
-   walk_tree().  */
-
-static tree
-set_input_location (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
-		    void *data ATTRIBUTE_UNUSED)
-{
-  tree t = *tp;
-
-  if (CAN_HAVE_LOCATION_P (t))
-    {
-      if (EXPR_HAS_LOCATION(t))
-	return t;  /* Don't walk any further into this expr.   */
-      else
-	SET_EXPR_LOCATION (t, input_location);
-    }
-
-  return NULL_TREE;  /* Continue walking this expr.   */
-}
-
-/* Add a statement to the statement_list currently being constructed.
-   If the statement_list is null, we don't create a singleton list.
-   This is necessary because poplevel() assumes that adding a
-   statement to a null statement_list returns the statement.  */
-
-tree
-java_add_stmt (tree new_stmt)
-{
-  tree stmts = current_binding_level->stmts;
-  tree_stmt_iterator i;
-
-  if (LOCATION_FILE (input_location))
-    walk_tree (&new_stmt, set_input_location, NULL, NULL);
-
-  if (stmts == NULL)
-    return current_binding_level->stmts = new_stmt;
-
-  /* Force STMTS to be a statement_list.  */
-  if (TREE_CODE (stmts) != STATEMENT_LIST)
-    {
-      tree t = make_node (STATEMENT_LIST);
-      i = tsi_last (t);
-      tsi_link_after (&i, stmts, TSI_CONTINUE_LINKING);
-      stmts = t;
-    }  
-      
-  i = tsi_last (stmts);
-  tsi_link_after (&i, new_stmt, TSI_CONTINUE_LINKING);
-  TREE_TYPE (stmts) = void_type_node;
-
-  return current_binding_level->stmts = stmts;
-}
-
-/* Add a variable to the current scope.  */
-
-tree
-java_add_local_var (tree decl)
-{
-  tree *vars = &current_binding_level->names;
-  tree next = *vars;
-  DECL_CHAIN (decl) = next;
-  *vars = decl;
-  DECL_CONTEXT (decl) = current_function_decl;
-  MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (decl);
-  return decl;
-}
-
-/* Return a pointer to the compound_expr currently being
-   constructed.  */
-
-tree *
-get_stmts (void)
-{
-  return &current_binding_level->stmts;
-}
-
-/* Register an exception range as belonging to the current binding
-   level.  There may only be one: if there are more, we'll create more
-   binding levels.  However, each range can have multiple handlers,
-   and these are expanded when we call expand_end_java_handler().  */
-
-void
-register_exception_range (struct eh_range *range, int pc, int end_pc)
-{
-  gcc_assert (! current_binding_level->exception_range);
-  current_binding_level->exception_range = range;
-  current_binding_level->end_pc = end_pc;
-  current_binding_level->start_pc = pc;      
-}
-
-#include "gt-java-decl.h"