/* Java language support routines for GDB, the GNU debugger.
- Copyright (C) 1997, 1998, 1999, 2000, 2003, 2004, 2005, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 1997, 1998, 1999, 2000, 2003, 2004, 2005, 2007, 2008, 2009,
+ 2010 Free Software Foundation, Inc.
This file is part of GDB.
static int java_demangled_signature_length (char *);
static void java_demangled_signature_copy (char *, char *);
-static struct symtab *get_java_class_symtab (void);
+static struct symtab *get_java_class_symtab (struct gdbarch *gdbarch);
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 char *java_class_name_from_physname (const char *physname);
+static const struct objfile_data *jv_dynamics_objfile_data_key;
+static const struct objfile_data *jv_type_objfile_data_key;
+
/* 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;
+/* symtab contains classes read from the inferior. */
+
+static struct symtab *class_symtab = NULL;
+
static struct type *java_link_class_type (struct gdbarch *,
struct type *, struct value *);
+/* A function called when the dynamics_objfile is freed. We use this
+ to clean up some internal state. */
+static void
+jv_per_objfile_free (struct objfile *objfile, void *ignore)
+{
+ gdb_assert (objfile == dynamics_objfile);
+ /* Clean up all our cached state. These objects are all allocated
+ in the dynamics_objfile, so we don't need to actually free
+ anything. */
+ dynamics_objfile = NULL;
+ class_symtab = NULL;
+}
+
/* 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
dynamic library) after this code has been called. */
static struct objfile *
-get_dynamics_objfile (void)
+get_dynamics_objfile (struct gdbarch *gdbarch)
{
if (dynamics_objfile == NULL)
{
- dynamics_objfile = allocate_objfile (NULL, 0);
+ /* Mark it as shared so that it is cleared when the inferior is
+ re-run. */
+ dynamics_objfile = allocate_objfile (NULL, OBJF_SHARED);
+ dynamics_objfile->gdbarch = gdbarch;
+ /* We don't have any data to store, but this lets us get a
+ notification when the objfile is destroyed. Since we have to
+ store a non-NULL value, we just pick something arbitrary and
+ safe. */
+ set_objfile_data (dynamics_objfile, jv_dynamics_objfile_data_key,
+ &dynamics_objfile);
}
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)
+get_java_class_symtab (struct gdbarch *gdbarch)
{
if (class_symtab == NULL)
{
- struct objfile *objfile = get_dynamics_objfile ();
+ struct objfile *objfile = get_dynamics_objfile (gdbarch);
struct blockvector *bv;
struct block *bl;
+
class_symtab = allocate_symtab ("<java-classes>", objfile);
class_symtab->language = language_java;
bv = (struct blockvector *)
static void
add_class_symtab_symbol (struct symbol *sym)
{
- struct symtab *symtab = get_java_class_symtab ();
+ struct symtab *symtab
+ = get_java_class_symtab (get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile));
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));
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, 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_STUB (type) = 1;
- TYPE ? = addr;
- return type;
-#else
/* FIXME - should search inferior's symbol table. */
return NULL;
-#endif
}
/* Return a nul-terminated string (allocated on OBSTACK) for
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) + TYPE_LENGTH (value_type (temp));
{
struct value *vtable = value_struct_elt (&clas, NULL, "vtable", NULL, "struct");
CORE_ADDR i = value_as_address (vtable);
+
return (int) (i & 0x7fffffff) == (int) 0x7fffffff;
}
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));
}
addr = value_address (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 ();
+ objfile = get_dynamics_objfile (gdbarch);
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 (gdbarch, value_as_long (sig));
if (type != NULL)
return type;
- /* Do not use the "fake" dynamics objfile to own dynamically generated
- types, as it does not provide an architecture, and it would not help
- manage the lifetime of these types anyway. */
- type = alloc_type_arch (gdbarch);
+ type = alloc_type (objfile);
TYPE_CODE (type) = TYPE_CODE_STRUCT;
INIT_CPLUS_SPECIFIC (type);
{
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);
/* Fill in class TYPE with data from the CLAS value. */
-struct type *
+static struct type *
java_link_class_type (struct gdbarch *gdbarch,
struct type *type, struct value *clas)
{
struct value *method = NULL;
struct value *field = NULL;
int i, j;
- struct objfile *objfile = get_dynamics_objfile ();
+ struct objfile *objfile = get_dynamics_objfile (gdbarch);
struct type *tsuper;
gdb_assert (name != NULL);
{
int accflags;
int boffset;
+
if (fields == NULL)
{
temp = clas;
{ /* Re-use field value for next field. */
CORE_ADDR addr
= value_address (field) + TYPE_LENGTH (value_type (field));
+
set_value_address (field, addr);
set_value_lazy (field, 1);
}
else
{
struct type *ftype;
+
temp = field;
temp = value_struct_elt (&temp, NULL, "type", NULL, "structure");
ftype = type_from_class (gdbarch, temp);
{
char *mname;
int k;
+
if (methods == NULL)
{
temp = clas;
{ /* Re-use method value for next method. */
CORE_ADDR addr
= value_address (method) + TYPE_LENGTH (value_type (method));
+
set_value_address (method, addr);
set_value_lazy (method, 1);
}
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;
static struct type *java_object_type;
+/* A free function that is attached to the objfile defining
+ java_object_type. This is used to clear the cached type whenever
+ its owning objfile is destroyed. */
+static void
+jv_clear_object_type (struct objfile *objfile, void *ignore)
+{
+ java_object_type = NULL;
+}
+
+static void
+set_java_object_type (struct type *type)
+{
+ struct objfile *owner;
+
+ gdb_assert (java_object_type == NULL);
+
+ owner = TYPE_OBJFILE (type);
+ if (owner)
+ set_objfile_data (owner, jv_type_objfile_data_key, &java_object_type);
+ java_object_type = 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, NULL);
if (sym == NULL)
error (_("cannot find java.lang.Object"));
- java_object_type = SYMBOL_TYPE (sym);
+ set_java_object_type (SYMBOL_TYPE (sym));
}
return java_object_type;
}
get_java_object_header_size (struct gdbarch *gdbarch)
{
struct type *objtype = get_java_object_type ();
+
if (objtype == NULL)
return (2 * gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
else
if (name != NULL && strcmp (name, "vtable") == 0)
{
if (java_object_type == NULL)
- java_object_type = type;
+ set_java_object_type (type);
return 1;
}
}
java_demangled_signature_length (char *signature)
{
int array = 0;
+
for (; *signature == '['; signature++)
array += 2; /* Two chars for "[]". */
switch (signature[0])
int array = 0;
char *ptr;
int i;
+
while (*signature == '[')
{
array++;
{
int length = java_demangled_signature_length (signature);
char *result = xmalloc (length + 1);
+
java_demangled_signature_copy (result, signature);
result[length] = '\0';
return result;
struct value *arg1;
struct value *arg2;
struct type *type;
+
switch (op)
{
case UNOP_IND:
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
&& i > 2 && name[i - 1] == ']')
{
+ enum bfd_endian byte_order = gdbarch_byte_order (exp->gdbarch);
CORE_ADDR address;
long length, index;
struct type *el_type;
address = value_as_address (arg1);
address += get_java_object_header_size (exp->gdbarch);
read_memory (address, buf4, 4);
- length = (long) extract_signed_integer (buf4, 4);
+ length = (long) extract_signed_integer (buf4, 4, byte_order);
index = (long) value_as_long (arg2);
if (index >= length || index < 0)
error (_("array index (%ld) out of bounds (length: %ld)"),
{
char *ret = NULL;
const char *end;
- int depth = 0;
char *demangled_name = java_demangle (physname, DMGL_PARAMS | DMGL_ANSI);
if (demangled_name == NULL)
{"<", BINOP_LESS, PREC_ORDER, 0},
{">>", BINOP_RSH, PREC_SHIFT, 0},
{"<<", BINOP_LSH, PREC_SHIFT, 0},
-#if 0
- {">>>", BINOP_ ? ? ?, PREC_SHIFT, 0},
-#endif
{"+", BINOP_ADD, PREC_ADD, 0},
{"-", BINOP_SUB, PREC_ADD, 0},
{"*", BINOP_MUL, PREC_MUL, 0},
{"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
{"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
{"*", UNOP_IND, PREC_PREFIX, 0},
-#if 0
- {"instanceof", ? ? ?, ? ? ?, 0},
-#endif
{"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
{"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
{NULL, 0, 0, 0}
{
print_subexp_standard,
operator_length_standard,
+ operator_check_standard,
op_name_standard,
dump_subexp_body_standard,
evaluate_subexp_java
void
_initialize_java_language (void)
{
+ jv_dynamics_objfile_data_key
+ = register_objfile_data_with_cleanup (NULL, jv_per_objfile_free);
+ jv_type_objfile_data_key
+ = register_objfile_data_with_cleanup (NULL, jv_clear_object_type);
+
java_type_data = gdbarch_data_register_post_init (build_java_types);
add_language (&java_language_defn);