Subversion Repositories scarts

/* Java language support routines for GDB, the GNU debugger.

   Copyright (C) 1997, 1998, 1999, 2000, 2003, 2004, 2005, 2007, 2008

   Free Software Foundation, Inc.

   This file is part of GDB.

   This program 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 of the License, or

   (at your option) any later version.

   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "symtab.h"

#include "gdbtypes.h"

#include "expression.h"

#include "parser-defs.h"

#include "language.h"

#include "gdbtypes.h"

#include "symtab.h"

#include "symfile.h"

#include "objfiles.h"

#include "gdb_string.h"

#include "value.h"

#include "c-lang.h"

#include "jv-lang.h"

#include "gdbcore.h"

#include "block.h"

#include "demangle.h"

#include "dictionary.h"

#include <ctype.h>

#include "gdb_assert.h"

struct type *java_int_type;

struct type *java_byte_type;

struct type *java_short_type;

struct type *java_long_type;

struct type *java_boolean_type;

struct type *java_char_type;

struct type *java_float_type;

struct type *java_double_type;

struct type *java_void_type;

/* Local functions */

extern void _initialize_java_language (void);

static int java_demangled_signature_length (char *);

static void java_demangled_signature_copy (char *, char *);

static struct symtab *get_java_class_symtab (void);

static char *get_java_utf8_name (struct obstack *obstack, struct value *name);

static int java_class_is_primitive (struct value *clas);

static struct value *java_value_string (char *ptr, int len);

static void java_emit_char (int c, struct ui_file * stream, int quoter);

static char *java_class_name_from_physname (const char *physname);

/* This objfile contains symtabs that have been dynamically created

   to record dynamically loaded Java classes and dynamically

   compiled java methods. */

static struct objfile *dynamics_objfile = NULL;

static struct type *java_link_class_type (struct type *, struct value *);

/* FIXME: carlton/2003-02-04: This is the main or only caller of

   allocate_objfile with first argument NULL; as a result, this code

   breaks every so often.  Somebody should write a test case that

   exercises GDB in various ways (e.g. something involving loading a

   dynamic library) after this code has been called.  */

static struct objfile *

get_dynamics_objfile (void)

{

  if (dynamics_objfile == NULL)

    {

      dynamics_objfile = allocate_objfile (NULL, 0);

    }

  return dynamics_objfile;

}

#if 1

/* symtab contains classes read from the inferior. */

static struct symtab *class_symtab = NULL;

static void free_class_block (struct symtab *symtab);

static struct symtab *

get_java_class_symtab (void)

{

  if (class_symtab == NULL)

    {

      struct objfile *objfile = get_dynamics_objfile ();

      struct blockvector *bv;

      struct block *bl;

      class_symtab = allocate_symtab ("<java-classes>", objfile);

      class_symtab->language = language_java;

      bv = (struct blockvector *)

        obstack_alloc (&objfile->objfile_obstack,

                       sizeof (struct blockvector) + sizeof (struct block *));

      BLOCKVECTOR_NBLOCKS (bv) = 1;

      BLOCKVECTOR (class_symtab) = bv;

      /* Allocate dummy STATIC_BLOCK. */

      bl = allocate_block (&objfile->objfile_obstack);

      BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,

                                            NULL);

      BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;

      /* Allocate GLOBAL_BLOCK.  */

      bl = allocate_block (&objfile->objfile_obstack);

      BLOCK_DICT (bl) = dict_create_hashed_expandable ();

      BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;

      class_symtab->free_func = free_class_block;

    }

  return class_symtab;

}

static void

add_class_symtab_symbol (struct symbol *sym)

{

  struct symtab *symtab = get_java_class_symtab ();

  struct blockvector *bv = BLOCKVECTOR (symtab);

  dict_add_symbol (BLOCK_DICT (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)), sym);

}

static struct symbol *add_class_symbol (struct type *type, CORE_ADDR addr);

static struct symbol *

add_class_symbol (struct type *type, CORE_ADDR addr)

{

  struct symbol *sym;

  sym = (struct symbol *)

    obstack_alloc (&dynamics_objfile->objfile_obstack, sizeof (struct symbol));

  memset (sym, 0, sizeof (struct symbol));

  SYMBOL_LANGUAGE (sym) = language_java;

  DEPRECATED_SYMBOL_NAME (sym) = TYPE_TAG_NAME (type);

  SYMBOL_CLASS (sym) = LOC_TYPEDEF;

  /*  SYMBOL_VALUE (sym) = valu; */

  SYMBOL_TYPE (sym) = type;

  SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;

  SYMBOL_VALUE_ADDRESS (sym) = addr;

  return sym;

}

/* Free the dynamic symbols block.  */

static void

free_class_block (struct symtab *symtab)

{

  struct blockvector *bv = BLOCKVECTOR (symtab);

  struct block *bl = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);

  dict_free (BLOCK_DICT (bl));

}

#endif

struct type *

java_lookup_class (char *name)

{

  struct symbol *sym;

  sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN,

                       (int *) 0, (struct symtab **) NULL);

  if (sym != NULL)

    return SYMBOL_TYPE (sym);

#if 0

  CORE_ADDR addr;

  if (called from parser)

    {

      call lookup_class (or similar) in inferior;

      if not

      found:

        return NULL;

      addr = found in inferior;

    }

  else

    addr = 0;

  struct type *type;

  type = alloc_type (objfile);

  TYPE_CODE (type) = TYPE_CODE_STRUCT;

  INIT_CPLUS_SPECIFIC (type);

  TYPE_TAG_NAME (type) = obsavestring (name, strlen (name), &objfile->objfile_obstack);

  TYPE_FLAGS (type) |= TYPE_FLAG_STUB;

  TYPE ? = addr;

  return type;

#else

  /* FIXME - should search inferior's symbol table. */

  return NULL;

#endif

}

/* Return a nul-terminated string (allocated on OBSTACK) for

   a name given by NAME (which has type Utf8Const*). */

char *

get_java_utf8_name (struct obstack *obstack, struct value *name)

{

  char *chrs;

  struct value *temp = name;

  int name_length;

  CORE_ADDR data_addr;

  temp = value_struct_elt (&temp, NULL, "length", NULL, "structure");

  name_length = (int) value_as_long (temp);

  data_addr = VALUE_ADDRESS (temp) + value_offset (temp)

    + TYPE_LENGTH (value_type (temp));

  chrs = obstack_alloc (obstack, name_length + 1);

  chrs[name_length] = '\0';

  read_memory (data_addr, (gdb_byte *) chrs, name_length);

  return chrs;

}

struct value *

java_class_from_object (struct value *obj_val)

{

  /* This is all rather inefficient, since the offsets of vtable and

     class are fixed.  FIXME */

  struct value *vtable_val;

  if (TYPE_CODE (value_type (obj_val)) == TYPE_CODE_PTR

      && TYPE_LENGTH (TYPE_TARGET_TYPE (value_type (obj_val))) == 0)

    obj_val = value_at (get_java_object_type (),

                        value_as_address (obj_val));

  vtable_val = value_struct_elt (&obj_val, NULL, "vtable", NULL, "structure");

  return value_struct_elt (&vtable_val, NULL, "class", NULL, "structure");

}

/* Check if CLASS_IS_PRIMITIVE(value of clas): */

static int

java_class_is_primitive (struct value *clas)

{

  struct value *vtable = value_struct_elt (&clas, NULL, "vtable", NULL, "struct");

  CORE_ADDR i = value_as_address (vtable);

  return (int) (i & 0x7fffffff) == (int) 0x7fffffff;

}

/* Read a GCJ Class object, and generated a gdb (TYPE_CODE_STRUCT) type. */

struct type *

type_from_class (struct value *clas)

{

  struct type *type;

  char *name;

  struct value *temp;

  struct objfile *objfile;

  struct value *utf8_name;

  char *nptr;

  CORE_ADDR addr;

  struct block *bl;

  struct dict_iterator iter;

  int is_array = 0;

  type = check_typedef (value_type (clas));

  if (TYPE_CODE (type) == TYPE_CODE_PTR)

    {

      if (value_logical_not (clas))

        return NULL;

      clas = value_ind (clas);

    }

  addr = VALUE_ADDRESS (clas) + value_offset (clas);

#if 0

  get_java_class_symtab ();

  bl = BLOCKVECTOR_BLOCK (BLOCKVECTOR (class_symtab), GLOBAL_BLOCK);

  ALL_BLOCK_SYMBOLS (block, iter, sym)

    {

      if (SYMBOL_VALUE_ADDRESS (sym) == addr)

        return SYMBOL_TYPE (sym);

    }

#endif

  objfile = get_dynamics_objfile ();

  if (java_class_is_primitive (clas))

    {

      struct value *sig;

      temp = clas;

      sig = value_struct_elt (&temp, NULL, "method_count", NULL, "structure");

      return java_primitive_type (value_as_long (sig));

    }

  /* Get Class name. */

  /* if clasloader non-null, prepend loader address. FIXME */

  temp = clas;

  utf8_name = value_struct_elt (&temp, NULL, "name", NULL, "structure");

  name = get_java_utf8_name (&objfile->objfile_obstack, utf8_name);

  for (nptr = name; *nptr != 0; nptr++)

    {

      if (*nptr == '/')

        *nptr = '.';

    }

  type = java_lookup_class (name);

  if (type != NULL)

    return type;

  type = alloc_type (objfile);

  TYPE_CODE (type) = TYPE_CODE_STRUCT;

  INIT_CPLUS_SPECIFIC (type);

  if (name[0] == '[')

    {

      char *signature = name;

      int namelen = java_demangled_signature_length (signature);

      if (namelen > strlen (name))

        name = obstack_alloc (&objfile->objfile_obstack, namelen + 1);

      java_demangled_signature_copy (name, signature);

      name[namelen] = '\0';

      is_array = 1;

      temp = clas;

      /* Set array element type. */

      temp = value_struct_elt (&temp, NULL, "methods", NULL, "structure");

      deprecated_set_value_type (temp, lookup_pointer_type (value_type (clas)));

      TYPE_TARGET_TYPE (type) = type_from_class (temp);

    }

  ALLOCATE_CPLUS_STRUCT_TYPE (type);

  TYPE_TAG_NAME (type) = name;

  add_class_symtab_symbol (add_class_symbol (type, addr));

  return java_link_class_type (type, clas);

}

/* Fill in class TYPE with data from the CLAS value. */

struct type *

java_link_class_type (struct type *type, struct value *clas)

{

  struct value *temp;

  char *unqualified_name;

  char *name = TYPE_TAG_NAME (type);

  int ninterfaces, nfields, nmethods;

  int type_is_object = 0;

  struct fn_field *fn_fields;

  struct fn_fieldlist *fn_fieldlists;

  struct value *fields;

  struct value *methods;

  struct value *method = NULL;

  struct value *field = NULL;

  int i, j;

  struct objfile *objfile = get_dynamics_objfile ();

  struct type *tsuper;

  gdb_assert (name != NULL);

  unqualified_name = strrchr (name, '.');

  if (unqualified_name == NULL)

    unqualified_name = name;

  temp = clas;

  temp = value_struct_elt (&temp, NULL, "superclass", NULL, "structure");

  if (strcmp (name, "java.lang.Object") == 0)

    {

      tsuper = get_java_object_type ();

      if (tsuper && TYPE_CODE (tsuper) == TYPE_CODE_PTR)

        tsuper = TYPE_TARGET_TYPE (tsuper);

      type_is_object = 1;

    }

  else

    tsuper = type_from_class (temp);

#if 1

  ninterfaces = 0;

#else

  temp = clas;

  ninterfaces = value_as_long (value_struct_elt (&temp, NULL, "interface_len", NULL, "structure"));

#endif

  TYPE_N_BASECLASSES (type) = (tsuper == NULL ? 0 : 1) + ninterfaces;

  temp = clas;

  nfields = value_as_long (value_struct_elt (&temp, NULL, "field_count", NULL, "structure"));

  nfields += TYPE_N_BASECLASSES (type);

  nfields++;                    /* Add one for dummy "class" field. */

  TYPE_NFIELDS (type) = nfields;

  TYPE_FIELDS (type) = (struct field *)

    TYPE_ALLOC (type, sizeof (struct field) * nfields);

  memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);

  TYPE_FIELD_PRIVATE_BITS (type) =

    (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));

  B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);

  TYPE_FIELD_PROTECTED_BITS (type) =

    (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));

  B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);

  TYPE_FIELD_IGNORE_BITS (type) =

    (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));

  B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);

  TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *)

    TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type)));

  B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type));

  if (tsuper != NULL)

    {

      TYPE_BASECLASS (type, 0) = tsuper;

      if (type_is_object)

        SET_TYPE_FIELD_PRIVATE (type, 0);

    }

  i = strlen (name);

  if (i > 2 && name[i - 1] == ']' && tsuper != NULL)

    {

      /* FIXME */

      TYPE_LENGTH (type) = TYPE_LENGTH (tsuper) + 4;    /* size with "length" */

    }

  else

    {

      temp = clas;

      temp = value_struct_elt (&temp, NULL, "size_in_bytes", NULL, "structure");

      TYPE_LENGTH (type) = value_as_long (temp);

    }

  fields = NULL;

  nfields--;                    /* First set up dummy "class" field. */

  SET_FIELD_PHYSADDR (TYPE_FIELD (type, nfields),

                      VALUE_ADDRESS (clas) + value_offset (clas));

  TYPE_FIELD_NAME (type, nfields) = "class";

  TYPE_FIELD_TYPE (type, nfields) = value_type (clas);

  SET_TYPE_FIELD_PRIVATE (type, nfields);

  for (i = TYPE_N_BASECLASSES (type); i < nfields; i++)

    {

      int accflags;

      int boffset;

      if (fields == NULL)

        {

          temp = clas;

          fields = value_struct_elt (&temp, NULL, "fields", NULL, "structure");

          field = value_ind (fields);

        }

      else

        {                       /* Re-use field value for next field. */

          VALUE_ADDRESS (field) += TYPE_LENGTH (value_type (field));

          set_value_lazy (field, 1);

        }

      temp = field;

      temp = value_struct_elt (&temp, NULL, "name", NULL, "structure");

      TYPE_FIELD_NAME (type, i) =

        get_java_utf8_name (&objfile->objfile_obstack, temp);

      temp = field;

      accflags = value_as_long (value_struct_elt (&temp, NULL, "accflags",

                                                  NULL, "structure"));

      temp = field;

      temp = value_struct_elt (&temp, NULL, "info", NULL, "structure");

      boffset = value_as_long (value_struct_elt (&temp, NULL, "boffset",

                                                 NULL, "structure"));

      if (accflags & 0x0001)    /* public access */

        {

          /* ??? */

        }

      if (accflags & 0x0002)    /* private access */

        {

          SET_TYPE_FIELD_PRIVATE (type, i);

        }

      if (accflags & 0x0004)    /* protected access */

        {

          SET_TYPE_FIELD_PROTECTED (type, i);

        }

      if (accflags & 0x0008)    /* ACC_STATIC */

        SET_FIELD_PHYSADDR (TYPE_FIELD (type, i), boffset);

      else

        TYPE_FIELD_BITPOS (type, i) = 8 * boffset;

      if (accflags & 0x8000)    /* FIELD_UNRESOLVED_FLAG */

        {

          TYPE_FIELD_TYPE (type, i) = get_java_object_type ();  /* FIXME */

        }

      else

        {

          struct type *ftype;

          temp = field;

          temp = value_struct_elt (&temp, NULL, "type", NULL, "structure");

          ftype = type_from_class (temp);

          if (TYPE_CODE (ftype) == TYPE_CODE_STRUCT)

            ftype = lookup_pointer_type (ftype);

          TYPE_FIELD_TYPE (type, i) = ftype;

        }

    }

  temp = clas;

  nmethods = value_as_long (value_struct_elt (&temp, NULL, "method_count",

                                              NULL, "structure"));

  TYPE_NFN_FIELDS_TOTAL (type) = nmethods;

  j = nmethods * sizeof (struct fn_field);

  fn_fields = (struct fn_field *)

    obstack_alloc (&dynamics_objfile->objfile_obstack, j);

  memset (fn_fields, 0, j);

  fn_fieldlists = (struct fn_fieldlist *)

    alloca (nmethods * sizeof (struct fn_fieldlist));

  methods = NULL;

  for (i = 0; i < nmethods; i++)

    {

      char *mname;

      int k;

      if (methods == NULL)

        {

          temp = clas;

          methods = value_struct_elt (&temp, NULL, "methods", NULL, "structure");

          method = value_ind (methods);

        }

      else

        {                       /* Re-use method value for next method. */

          VALUE_ADDRESS (method) += TYPE_LENGTH (value_type (method));

          set_value_lazy (method, 1);

        }

      /* Get method name. */

      temp = method;

      temp = value_struct_elt (&temp, NULL, "name", NULL, "structure");

      mname = get_java_utf8_name (&objfile->objfile_obstack, temp);

      if (strcmp (mname, "<init>") == 0)

        mname = unqualified_name;

      /* Check for an existing method with the same name.

       * This makes building the fn_fieldslists an O(nmethods**2)

       * operation.  That could be using hashing, but I doubt it

       * is worth it.  Note that we do maintain the order of methods

       * in the inferior's Method table (as long as that is grouped

       * by method name), which I think is desirable.  --PB */

      for (k = 0, j = TYPE_NFN_FIELDS (type);;)

        {

          if (--j < 0)

            {                   /* No match - new method name. */

              j = TYPE_NFN_FIELDS (type)++;

              fn_fieldlists[j].name = mname;

              fn_fieldlists[j].length = 1;

              fn_fieldlists[j].fn_fields = &fn_fields[i];

              k = i;

              break;

            }

          if (strcmp (mname, fn_fieldlists[j].name) == 0)

            {                   /* Found an existing method with the same name. */

              int l;

              if (mname != unqualified_name)

                obstack_free (&objfile->objfile_obstack, mname);

              mname = fn_fieldlists[j].name;

              fn_fieldlists[j].length++;

              k = i - k;        /* Index of new slot. */

              /* Shift intervening fn_fields (between k and i) down. */

              for (l = i; l > k; l--)

                fn_fields[l] = fn_fields[l - 1];

              for (l = TYPE_NFN_FIELDS (type); --l > j;)

                fn_fieldlists[l].fn_fields++;

              break;

            }

          k += fn_fieldlists[j].length;

        }

      fn_fields[k].physname = "";

      fn_fields[k].is_stub = 1;

      fn_fields[k].type = make_function_type (java_void_type, NULL);    /* FIXME */

      TYPE_CODE (fn_fields[k].type) = TYPE_CODE_METHOD;

    }

  j = TYPE_NFN_FIELDS (type) * sizeof (struct fn_fieldlist);

  TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)

    obstack_alloc (&dynamics_objfile->objfile_obstack, j);

  memcpy (TYPE_FN_FIELDLISTS (type), fn_fieldlists, j);

  return type;

}

static struct type *java_object_type;

struct type *

get_java_object_type (void)

{

  if (java_object_type == NULL)

    {

      struct symbol *sym;

      sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN,

                           (int *) 0, (struct symtab **) NULL);

      if (sym == NULL)

        error (_("cannot find java.lang.Object"));

      java_object_type = SYMBOL_TYPE (sym);

    }

  return java_object_type;

}

int

get_java_object_header_size (void)

{

  struct type *objtype = get_java_object_type ();

  if (objtype == NULL)

    return (2 * gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT);

  else

    return TYPE_LENGTH (objtype);

}

int

is_object_type (struct type *type)

{

  CHECK_TYPEDEF (type);

  if (TYPE_CODE (type) == TYPE_CODE_PTR)

    {

      struct type *ttype = check_typedef (TYPE_TARGET_TYPE (type));

      char *name;

      if (TYPE_CODE (ttype) != TYPE_CODE_STRUCT)

        return 0;

      while (TYPE_N_BASECLASSES (ttype) > 0)

        ttype = TYPE_BASECLASS (ttype, 0);

      name = TYPE_TAG_NAME (ttype);

      if (name != NULL && strcmp (name, "java.lang.Object") == 0)

        return 1;

      name = TYPE_NFIELDS (ttype) > 0 ? TYPE_FIELD_NAME (ttype, 0) : (char *) 0;

      if (name != NULL && strcmp (name, "vtable") == 0)

        {

          if (java_object_type == NULL)

            java_object_type = type;

          return 1;

        }

    }

  return 0;

}

struct type *