Subversion Repositories openrisc_me

/* Process declarations and variables for the GNU compiler for the

   Java(TM) language.

   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007,

   2005, 2006, 2007, 2008, 2009 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 "tm.h"

#include "tree.h"

#include "rtl.h"

#include "real.h"

#include "toplev.h"

#include "flags.h"

#include "java-tree.h"

#include "jcf.h"

#include "function.h"

#include "expr.h"

#include "libfuncs.h"

#include "except.h"

#include "java-except.h"

#include "ggc.h"

#include "timevar.h"

#include "cgraph.h"

#include "tree-inline.h"

#include "target.h"

#include "version.h"

#include "tree-iterator.h"

#include "langhooks.h"

#include "cgraph.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, minor = 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;

  /* Extract minor version.  */

  while (ISDIGIT (*p))

    {

      minor = minor * 10 + *p - '0';

      ++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 sub-minor release (e.g., from 4.0.0 to

         4.0.1).  */

      abi_version = 100000 * major + 1000 * minor;

    }

  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 endlink;

  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;

  /* The code here must be similar to build_common_tree_nodes{,_2} in

     tree.c, especially as to the order of initializing common nodes.  */

  error_mark_node = make_node (ERROR_MARK);

  TREE_TYPE (error_mark_node) = error_mark_node;

  /* Create sizetype first - needed for other types. */

  initialize_sizetypes (false);

  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));

  /* This is not a java type, however tree-dfa requires a definition for

     size_type_node.  */

  size_type_node = make_unsigned_type (POINTER_SIZE);

  set_sizetype (size_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_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);

#if HOST_BITS_PER_WIDE_INT == 64

  decimal_long_max = build_int_cstu (unsigned_long_type_node,

                                     0x8000000000000000LL);

#elif HOST_BITS_PER_WIDE_INT == 32

  decimal_long_max = build_int_cst_wide (unsigned_long_type_node,

                                         0, 0x80000000);

#else

 #error "unsupported size"

#endif

  size_zero_node = size_int (0);

  size_one_node = size_int (1);

  bitsize_zero_node = bitsize_int (0);

  bitsize_one_node = bitsize_int (1);

  bitsize_unit_node = bitsize_int (BITS_PER_UNIT);

  long_zero_node = build_int_cst (long_type_node, 0);

  void_type_node = make_node (VOID_TYPE);

  pushdecl (build_decl (BUILTINS_LOCATION,

                        TYPE_DECL, get_identifier ("void"), void_type_node));

  layout_type (void_type_node); /* Uses size_zero_node */

  ptr_type_node = build_pointer_type (void_type_node);

  const_ptr_type_node

    = build_pointer_type (build_type_variant (void_type_node, 1, 0));

  t = make_node (VOID_TYPE);

  layout_type (t); /* Uses size_zero_node */

  return_address_type_node = build_pointer_type (t);

  null_pointer_node = build_int_cst (ptr_type_node, 0);

  char_type_node = make_node (INTEGER_TYPE);

  TYPE_STRING_FLAG (char_type_node) = 1;

  TYPE_PRECISION (char_type_node) = 16;

  fixup_unsigned_type (char_type_node);

  pushdecl (build_decl (BUILTINS_LOCATION,

                        TYPE_DECL, get_identifier ("char"), char_type_node));

  boolean_type_node = make_node (BOOLEAN_TYPE);

  TYPE_PRECISION (boolean_type_node) = 1;

  fixup_unsigned_type (boolean_type_node);

  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");