X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fjv-valprint.c;h=12a960f09d8e10d6f417a4ba1fd008448c25f856;hb=3a4ae681237c26ac55603f3a92c92fd748108cd2;hp=a1b8a715174844622b04a51f75e33aae03ac6f90;hpb=6c7a06a3facfa3f71606655871d0617d3cad80d9;p=binutils-gdb.git diff --git a/gdb/jv-valprint.c b/gdb/jv-valprint.c index a1b8a715174..12a960f09d8 100644 --- a/gdb/jv-valprint.c +++ b/gdb/jv-valprint.c @@ -1,7 +1,6 @@ /* Support for printing Java values for GDB, the GNU debugger. - Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, - 2008, 2009 Free Software Foundation, Inc. + Copyright (C) 1997-2005, 2007-2012 Free Software Foundation, Inc. This file is part of GDB. @@ -34,30 +33,35 @@ /* Local functions */ -int +void java_value_print (struct value *val, struct ui_file *stream, const struct value_print_options *options) { + struct gdbarch *gdbarch = get_type_arch (value_type (val)); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); struct type *type; CORE_ADDR address; int i; - char *name; + const char *name; struct value_print_options opts; type = value_type (val); - address = VALUE_ADDRESS (val) + value_offset (val); + address = value_address (val); if (is_object_type (type)) { CORE_ADDR obj_addr; + struct value *tem = val; - /* Get the run-time type, and cast the object into that */ + /* Get the run-time type, and cast the object into that. */ + while (TYPE_CODE (value_type (tem)) == TYPE_CODE_PTR) + tem = value_ind (tem); - obj_addr = unpack_pointer (type, value_contents (val)); + obj_addr = value_address (tem); if (obj_addr != 0) { - type = type_from_class (java_class_from_object (val)); + type = type_from_class (gdbarch, java_class_from_object (val)); type = lookup_pointer_type (type); val = value_at (type, address); @@ -75,26 +79,28 @@ java_value_print (struct value *val, struct ui_file *stream, long length; unsigned int things_printed = 0; int reps; - struct type *el_type = java_primitive_type_from_name (name, i - 2); + struct type *el_type + = java_primitive_type_from_name (gdbarch, name, i - 2); i = 0; - read_memory (address + JAVA_OBJECT_SIZE, buf4, 4); + read_memory (address + get_java_object_header_size (gdbarch), buf4, 4); - length = (long) extract_signed_integer (buf4, 4); + length = (long) extract_signed_integer (buf4, 4, byte_order); fprintf_filtered (stream, "{length: %ld", length); if (el_type == NULL) { CORE_ADDR element; - CORE_ADDR next_element = -1; /* dummy initial value */ + CORE_ADDR next_element = -1; /* Dummy initial value. */ - address += JAVA_OBJECT_SIZE + 4; /* Skip object header and length. */ + /* Skip object header and length. */ + address += get_java_object_header_size (gdbarch) + 4; while (i < length && things_printed < options->print_max) { gdb_byte *buf; - buf = alloca (gdbarch_ptr_bit (current_gdbarch) / HOST_CHAR_BIT); + buf = alloca (gdbarch_ptr_bit (gdbarch) / HOST_CHAR_BIT); fputs_filtered (", ", stream); wrap_here (n_spaces (2)); @@ -103,23 +109,25 @@ java_value_print (struct value *val, struct ui_file *stream, else { read_memory (address, buf, sizeof (buf)); - address += gdbarch_ptr_bit (current_gdbarch) / HOST_CHAR_BIT; + address += gdbarch_ptr_bit (gdbarch) / HOST_CHAR_BIT; /* FIXME: cagney/2003-05-24: Bogus or what. It pulls a host sized pointer out of the target and then extracts that as an address (while assuming that the address is unsigned)! */ - element = extract_unsigned_integer (buf, sizeof (buf)); + element = extract_unsigned_integer (buf, sizeof (buf), + byte_order); } for (reps = 1; i + reps < length; reps++) { read_memory (address, buf, sizeof (buf)); - address += gdbarch_ptr_bit (current_gdbarch) / HOST_CHAR_BIT; + address += gdbarch_ptr_bit (gdbarch) / HOST_CHAR_BIT; /* FIXME: cagney/2003-05-24: Bogus or what. It pulls a host sized pointer out of the target and then extracts that as an address (while assuming that the address is unsigned)! */ - next_element = extract_unsigned_integer (buf, sizeof (buf)); + next_element = extract_unsigned_integer (buf, sizeof (buf), + byte_order); if (next_element != element) break; } @@ -132,7 +140,7 @@ java_value_print (struct value *val, struct ui_file *stream, if (element == 0) fprintf_filtered (stream, "null"); else - fprintf_filtered (stream, "@%s", paddr_nz (element)); + fprintf_filtered (stream, "@%s", paddress (gdbarch, element)); things_printed++; i += reps; @@ -143,8 +151,9 @@ java_value_print (struct value *val, struct ui_file *stream, struct value *v = allocate_value (el_type); struct value *next_v = allocate_value (el_type); - VALUE_ADDRESS (v) = address + JAVA_OBJECT_SIZE + 4; - VALUE_ADDRESS (next_v) = VALUE_ADDRESS (v); + set_value_address (v, (address + + get_java_object_header_size (gdbarch) + 4)); + set_value_address (next_v, value_raw_address (v)); while (i < length && things_printed < options->print_max) { @@ -170,9 +179,13 @@ java_value_print (struct value *val, struct ui_file *stream, for (reps = 1; i + reps < length; reps++) { set_value_lazy (next_v, 1); - set_value_offset (next_v, value_offset (next_v) + TYPE_LENGTH (el_type)); - if (memcmp (value_contents (v), value_contents (next_v), - TYPE_LENGTH (el_type)) != 0) + set_value_offset (next_v, value_offset (next_v) + + TYPE_LENGTH (el_type)); + value_fetch_lazy (next_v); + if (!(value_available_contents_eq + (v, value_embedded_offset (v), + next_v, value_embedded_offset (next_v), + TYPE_LENGTH (el_type)))) break; } @@ -195,10 +208,10 @@ java_value_print (struct value *val, struct ui_file *stream, fprintf_filtered (stream, "}"); - return 0; + return; } - /* If it's type String, print it */ + /* If it's type String, print it. */ if (TYPE_CODE (type) == TYPE_CODE_PTR && TYPE_TARGET_TYPE (type) @@ -209,6 +222,7 @@ java_value_print (struct value *val, struct ui_file *stream, && address != 0 && value_as_address (val) != 0) { + struct type *char_type; struct value *data_val; CORE_ADDR data; struct value *boffset_val; @@ -217,7 +231,7 @@ java_value_print (struct value *val, struct ui_file *stream, unsigned long count; struct value *mark; - mark = value_mark (); /* Remember start of new values */ + mark = value_mark (); /* Remember start of new values. */ data_val = value_struct_elt (&val, NULL, "data", NULL, NULL); data = value_as_address (data_val); @@ -228,16 +242,18 @@ java_value_print (struct value *val, struct ui_file *stream, count_val = value_struct_elt (&val, NULL, "count", NULL, NULL); count = value_as_address (count_val); - value_free_to_mark (mark); /* Release unnecessary values */ + value_free_to_mark (mark); /* Release unnecessary values. */ - val_print_string (java_char_type, data + boffset, count, stream, options); + char_type = builtin_java_type (gdbarch)->builtin_char; + val_print_string (char_type, NULL, data + boffset, count, stream, + options); - return 0; + return; } opts = *options; opts.deref_ref = 1; - return common_val_print (val, stream, 0, &opts, current_language); + common_val_print (val, stream, 0, &opts, current_language); } /* TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the @@ -248,8 +264,10 @@ java_value_print (struct value *val, struct ui_file *stream, static void java_print_value_fields (struct type *type, const gdb_byte *valaddr, + int offset, CORE_ADDR address, struct ui_file *stream, int recurse, + const struct value *val, const struct value_print_options *options) { int i, len, n_baseclasses; @@ -268,7 +286,7 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr, { int boffset; struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); - char *basename = TYPE_NAME (baseclass); + const char *basename = TYPE_NAME (baseclass); const gdb_byte *base_valaddr; if (BASETYPE_VIA_VIRTUAL (type, i)) @@ -292,11 +310,11 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr, base_valaddr = valaddr; - java_print_value_fields (baseclass, base_valaddr, address + boffset, - stream, recurse + 1, options); + java_print_value_fields (baseclass, base_valaddr, + offset + boffset, address, + stream, recurse + 1, val, options); fputs_filtered (", ", stream); } - } if (!len && n_baseclasses == 1) @@ -310,7 +328,8 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr, /* If requested, skip printing of static fields. */ if (field_is_static (&TYPE_FIELD (type, i))) { - char *name = TYPE_FIELD_NAME (type, i); + const char *name = TYPE_FIELD_NAME (type, i); + if (!options->static_field_print) continue; if (name != NULL && strcmp (name, "class") == 0) @@ -382,12 +401,24 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr, { fputs_filtered ("", stream); } + else if (value_bits_synthetic_pointer (val, + TYPE_FIELD_BITPOS (type, + i), + TYPE_FIELD_BITSIZE (type, + i))) + { + fputs_filtered (_(""), stream); + } + else if (!value_bits_valid (val, TYPE_FIELD_BITPOS (type, i), + TYPE_FIELD_BITSIZE (type, i))) + { + val_print_optimized_out (stream); + } else { struct value_print_options opts; - v = value_from_longest (TYPE_FIELD_TYPE (type, i), - unpack_field_as_long (type, valaddr, i)); + v = value_field_bitfield (type, i, valaddr, offset, val); opts = *options; opts.deref_ref = 0; @@ -404,12 +435,14 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr, else if (field_is_static (&TYPE_FIELD (type, i))) { struct value *v = value_static_field (type, i); + if (v == NULL) - fputs_filtered ("", stream); + val_print_optimized_out (stream); else { struct value_print_options opts; struct type *t = check_typedef (value_type (v)); + if (TYPE_CODE (t) == TYPE_CODE_STRUCT) v = value_addr (v); opts = *options; @@ -423,11 +456,12 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr, else { struct value_print_options opts = *options; + opts.deref_ref = 0; val_print (TYPE_FIELD_TYPE (type, i), - valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0, - address + TYPE_FIELD_BITPOS (type, i) / 8, - stream, recurse + 1, &opts, + valaddr, + offset + TYPE_FIELD_BITPOS (type, i) / 8, + address, stream, recurse + 1, val, &opts, current_language); } } @@ -443,20 +477,18 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr, fprintf_filtered (stream, "}"); } -/* Print data of type TYPE located at VALADDR (within GDB), which came from - the inferior at address ADDRESS, onto stdio stream STREAM according to - OPTIONS. The data at VALADDR is in target byte order. - - If the data are a string pointer, returns the number of string characters - printed. */ +/* See val_print for a description of the various parameters of this + function; they are identical. */ -int +void java_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, + const struct value *val, const struct value_print_options *options) { - unsigned int i = 0; /* Number of characters printed */ + struct gdbarch *gdbarch = get_type_arch (type); + unsigned int i = 0; /* Number of characters printed. */ struct type *target_type; CORE_ADDR addr; @@ -466,35 +498,23 @@ java_val_print (struct type *type, const gdb_byte *valaddr, case TYPE_CODE_PTR: if (options->format && options->format != 's') { - print_scalar_formatted (valaddr, type, options, 0, stream); - break; - } -#if 0 - if (options->vtblprint && cp_is_vtbl_ptr_type (type)) - { - /* Print the unmangled name if desired. */ - /* Print vtable entry - we only get here if we ARE using - -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */ - /* Extract an address, assume that it is unsigned. */ - print_address_demangle (extract_unsigned_integer (valaddr, TYPE_LENGTH (type)), - stream, demangle); + val_print_scalar_formatted (type, valaddr, embedded_offset, + val, options, 0, stream); break; } -#endif - addr = unpack_pointer (type, valaddr); + addr = unpack_pointer (type, valaddr + embedded_offset); if (addr == 0) { fputs_filtered ("null", stream); - return i; + return; } target_type = check_typedef (TYPE_TARGET_TYPE (type)); if (TYPE_CODE (target_type) == TYPE_CODE_FUNC) { /* Try to print what function it points to. */ - print_address_demangle (addr, stream, demangle); - /* Return value is irrelevant except for string pointers. */ - return (0); + print_address_demangle (gdbarch, addr, stream, demangle); + return; } if (options->addressprint && options->format != 's') @@ -503,7 +523,7 @@ java_val_print (struct type *type, const gdb_byte *valaddr, print_longest (stream, 'x', 0, (ULONGEST) addr); } - return i; + return; case TYPE_CODE_CHAR: case TYPE_CODE_INT: @@ -512,28 +532,30 @@ java_val_print (struct type *type, const gdb_byte *valaddr, if (options->format || options->output_format) { struct value_print_options opts = *options; + opts.format = (options->format ? options->format : options->output_format); - print_scalar_formatted (valaddr, type, &opts, 0, stream); + val_print_scalar_formatted (type, valaddr, embedded_offset, + val, &opts, 0, stream); } else if (TYPE_CODE (type) == TYPE_CODE_CHAR || (TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) == 2 && strcmp (TYPE_NAME (type), "char") == 0)) - LA_PRINT_CHAR ((int) unpack_long (type, valaddr), type, stream); + LA_PRINT_CHAR ((int) unpack_long (type, valaddr + embedded_offset), + type, stream); else - val_print_type_code_int (type, valaddr, stream); + val_print_type_code_int (type, valaddr + embedded_offset, stream); break; case TYPE_CODE_STRUCT: - java_print_value_fields (type, valaddr, address, stream, recurse, - options); + java_print_value_fields (type, valaddr, embedded_offset, + address, stream, recurse, val, options); break; default: - return c_val_print (type, valaddr, embedded_offset, address, stream, - recurse, options); + c_val_print (type, valaddr, embedded_offset, address, stream, + recurse, val, options); + break; } - - return 0; }