/* Java language support routines for GDB, the GNU debugger.
- Copyright (C) 1997, 1998, 1999, 2000, 2003, 2004, 2005, 2007, 2008, 2009,
- 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1997-2013 Free Software Foundation, Inc.
This file is part of GDB.
#include "dictionary.h"
#include <ctype.h>
#include "gdb_assert.h"
+#include "charset.h"
+#include "valprint.h"
/* Local functions */
extern void _initialize_java_language (void);
-static int java_demangled_signature_length (char *);
-static void java_demangled_signature_copy (char *, char *);
+static int java_demangled_signature_length (const char *);
+static void java_demangled_signature_copy (char *, const char *);
static struct symtab *get_java_class_symtab (struct gdbarch *gdbarch);
static char *get_java_utf8_name (struct obstack *obstack, struct value *name);
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. */
+/* The dynamic objfile is kept per-program-space. This key lets us
+ associate the objfile with the program space. */
-static struct objfile *dynamics_objfile = NULL;
-
-/* symtab contains classes read from the inferior. */
-
-static struct symtab *class_symtab = NULL;
+static const struct program_space_data *jv_dynamics_progspace_key;
static struct type *java_link_class_type (struct gdbarch *,
struct type *, struct value *);
jv_per_objfile_free (struct objfile *objfile, void *data)
{
struct jv_per_objfile_data *jv_data = data;
+ struct objfile *dynamics_objfile;
+ dynamics_objfile = program_space_data (current_program_space,
+ jv_dynamics_progspace_key);
gdb_assert (objfile == dynamics_objfile);
- /* Clean up all our cached state. */
- dynamics_objfile = NULL;
- class_symtab = NULL;
if (jv_data->dict)
dict_free (jv_data->dict);
xfree (jv_data);
+
+ set_program_space_data (current_program_space,
+ jv_dynamics_progspace_key,
+ NULL);
}
/* FIXME: carlton/2003-02-04: This is the main or only caller of
static struct objfile *
get_dynamics_objfile (struct gdbarch *gdbarch)
{
+ struct objfile *dynamics_objfile;
+
+ dynamics_objfile = program_space_data (current_program_space,
+ jv_dynamics_progspace_key);
+
if (dynamics_objfile == NULL)
{
struct jv_per_objfile_data *data;
data = XCNEW (struct jv_per_objfile_data);
set_objfile_data (dynamics_objfile, jv_dynamics_objfile_data_key, data);
+
+ set_program_space_data (current_program_space,
+ jv_dynamics_progspace_key,
+ dynamics_objfile);
}
return dynamics_objfile;
}
static struct symtab *
get_java_class_symtab (struct gdbarch *gdbarch)
{
+ struct objfile *objfile = get_dynamics_objfile (gdbarch);
+ struct symtab *class_symtab = objfile->symtabs;
+
if (class_symtab == NULL)
{
- struct objfile *objfile = get_dynamics_objfile (gdbarch);
struct blockvector *bv;
struct block *bl;
struct jv_per_objfile_data *jv_data;
BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
/* Allocate GLOBAL_BLOCK. */
- bl = allocate_block (&objfile->objfile_obstack);
+ bl = allocate_global_block (&objfile->objfile_obstack);
BLOCK_DICT (bl) = dict_create_hashed_expandable ();
+ set_block_symtab (bl, class_symtab);
BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
/* Arrange to free the dict. */
add_class_symbol (struct type *type, CORE_ADDR addr)
{
struct symbol *sym;
+ struct objfile *objfile = get_dynamics_objfile (get_type_arch (type));
sym = (struct symbol *)
- obstack_alloc (&dynamics_objfile->objfile_obstack, sizeof (struct symbol));
+ obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
memset (sym, 0, sizeof (struct symbol));
SYMBOL_SET_LANGUAGE (sym, language_java);
SYMBOL_SET_LINKAGE_NAME (sym, TYPE_TAG_NAME (type));
struct value *utf8_name;
char *nptr;
CORE_ADDR addr;
- int is_array = 0;
type = check_typedef (value_type (clas));
if (TYPE_CODE (type) == TYPE_CODE_PTR)
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");
struct type *type, struct value *clas)
{
struct value *temp;
- char *unqualified_name;
- char *name = TYPE_TAG_NAME (type);
+ const char *unqualified_name;
+ const char *name = TYPE_TAG_NAME (type);
int ninterfaces, nfields, nmethods;
int type_is_object = 0;
struct fn_field *fn_fields;
if (accflags & 0x0008) /* ACC_STATIC */
SET_FIELD_PHYSADDR (TYPE_FIELD (type, i), boffset);
else
- TYPE_FIELD_BITPOS (type, i) = 8 * boffset;
+ SET_FIELD_BITPOS (TYPE_FIELD (type, i), 8 * boffset);
if (accflags & 0x8000) /* FIELD_UNRESOLVED_FLAG */
{
TYPE_FIELD_TYPE (type, i) = get_java_object_type (); /* FIXME */
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);
+ obstack_alloc (&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;
+ const char *mname;
int k;
if (methods == NULL)
j = TYPE_NFN_FIELDS (type) * sizeof (struct fn_fieldlist);
TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
- obstack_alloc (&dynamics_objfile->objfile_obstack, j);
+ obstack_alloc (&objfile->objfile_obstack, j);
memcpy (TYPE_FN_FIELDLISTS (type), fn_fieldlists, j);
return type;
}
-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;
+ struct symbol *sym;
- sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN, NULL);
- if (sym == NULL)
- error (_("cannot find java.lang.Object"));
- set_java_object_type (SYMBOL_TYPE (sym));
- }
- return java_object_type;
+ sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN, NULL);
+ if (sym == NULL)
+ error (_("cannot find java.lang.Object"));
+ return SYMBOL_TYPE (sym);
}
int
if (TYPE_CODE (type) == TYPE_CODE_PTR)
{
struct type *ttype = check_typedef (TYPE_TARGET_TYPE (type));
- char *name;
+ const char *name;
if (TYPE_CODE (ttype) != TYPE_CODE_STRUCT)
return 0;
while (TYPE_N_BASECLASSES (ttype) > 0)
name
= TYPE_NFIELDS (ttype) > 0 ? TYPE_FIELD_NAME (ttype, 0) : (char *) 0;
if (name != NULL && strcmp (name, "vtable") == 0)
- {
- if (java_object_type == NULL)
- set_java_object_type (type);
- return 1;
- }
+ return 1;
}
return 0;
}
struct type *
java_primitive_type_from_name (struct gdbarch *gdbarch,
- char *name, int namelen)
+ const char *name, int namelen)
{
const struct builtin_java_type *builtin = builtin_java_type (gdbarch);
signature string SIGNATURE. */
static int
-java_demangled_signature_length (char *signature)
+java_demangled_signature_length (const char *signature)
{
int array = 0;
RESULT. */
static void
-java_demangled_signature_copy (char *result, char *signature)
+java_demangled_signature_copy (char *result, const char *signature)
{
int array = 0;
char *ptr;
as a freshly allocated copy. */
char *
-java_demangle_type_signature (char *signature)
+java_demangle_type_signature (const char *signature)
{
int length = java_demangled_signature_length (signature);
char *result = xmalloc (length + 1);
error (_("not implemented - java_value_string")); /* FIXME */
}
+/* Return the encoding that should be used for the character type
+ TYPE. */
+
+static const char *
+java_get_encoding (struct type *type)
+{
+ struct gdbarch *arch = get_type_arch (type);
+ const char *encoding;
+
+ if (type == builtin_java_type (arch)->builtin_char)
+ {
+ if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG)
+ encoding = "UTF-16BE";
+ else
+ encoding = "UTF-16LE";
+ }
+ else
+ encoding = target_charset (arch);
+
+ return encoding;
+}
+
/* Print the character C on STREAM as part of the contents of a literal
string whose delimiter is QUOTER. Note that that format for printing
characters and strings is language specific. */
static void
java_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
{
- switch (c)
- {
- case '\\':
- case '\'':
- fprintf_filtered (stream, "\\%c", c);
- break;
- case '\b':
- fputs_filtered ("\\b", stream);
- break;
- case '\t':
- fputs_filtered ("\\t", stream);
- break;
- case '\n':
- fputs_filtered ("\\n", stream);
- break;
- case '\f':
- fputs_filtered ("\\f", stream);
- break;
- case '\r':
- fputs_filtered ("\\r", stream);
- break;
- default:
- if (isprint (c))
- fputc_filtered (c, stream);
- else
- fprintf_filtered (stream, "\\u%.4x", (unsigned int) c);
- break;
- }
+ const char *encoding = java_get_encoding (type);
+
+ generic_emit_char (c, type, stream, quoter, encoding);
+}
+
+/* Implementation of la_printchar method. */
+
+static void
+java_printchar (int c, struct type *type, struct ui_file *stream)
+{
+ fputs_filtered ("'", stream);
+ LA_EMIT_CHAR (c, type, stream, '\'');
+ fputs_filtered ("'", stream);
+}
+
+/* Implementation of la_printstr method. */
+
+static void
+java_printstr (struct ui_file *stream, struct type *type,
+ const gdb_byte *string,
+ unsigned int length, const char *encoding, int force_ellipses,
+ const struct value_print_options *options)
+{
+ const char *type_encoding = java_get_encoding (type);
+
+ if (!encoding || !*encoding)
+ encoding = type_encoding;
+
+ generic_printstr (stream, type, string, length, encoding,
+ force_ellipses, '"', 0, options);
}
static struct value *
{
int pc = *pos;
int i;
- char *name;
+ const char *name;
enum exp_opcode op = exp->elts[*pos].opcode;
struct value *arg1;
struct value *arg2;
"java", /* Language name */
language_java,
range_check_off,
- type_check_off,
case_sensitive_on,
array_row_major,
macro_expansion_no,
java_parse,
java_error,
null_post_parser,
- c_printchar, /* Print a character constant */
- c_printstr, /* Function to print string constant */
+ java_printchar, /* Print a character constant */
+ java_printstr, /* Function to print string constant */
java_emit_char, /* Function to print a single character */
java_print_type, /* Print a type using appropriate syntax */
default_print_typedef, /* Print a typedef using appropriate syntax */
java_val_print, /* Print a value using appropriate syntax */
java_value_print, /* Print a top-level value */
+ default_read_var_value, /* la_read_var_value */
NULL, /* Language specific skip_trampoline */
"this", /* name_of_this */
basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
default_print_array_index,
default_pass_by_reference,
default_get_string,
+ NULL, /* la_get_symbol_name_cmp */
+ iterate_over_symbols,
LANG_MAGIC
};
{
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);
+ jv_dynamics_progspace_key = register_program_space_data ();
java_type_data = gdbarch_data_register_post_init (build_java_types);
projects / external / binutils.git / blobdiff