146283Sdfr/* Support for printing Java values for GDB, the GNU debugger. 246283Sdfr 3130803Smarcel Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free 4130803Smarcel Software Foundation, Inc. 5130803Smarcel 698944Sobrien This file is part of GDB. 746283Sdfr 898944Sobrien This program is free software; you can redistribute it and/or modify 998944Sobrien it under the terms of the GNU General Public License as published by 1098944Sobrien the Free Software Foundation; either version 2 of the License, or 1198944Sobrien (at your option) any later version. 1246283Sdfr 1398944Sobrien This program is distributed in the hope that it will be useful, 1498944Sobrien but WITHOUT ANY WARRANTY; without even the implied warranty of 1598944Sobrien MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1698944Sobrien GNU General Public License for more details. 1746283Sdfr 1898944Sobrien You should have received a copy of the GNU General Public License 1998944Sobrien along with this program; if not, write to the Free Software 2098944Sobrien Foundation, Inc., 59 Temple Place - Suite 330, 2198944Sobrien Boston, MA 02111-1307, USA. */ 2246283Sdfr 2346283Sdfr#include "defs.h" 2446283Sdfr#include "symtab.h" 2546283Sdfr#include "gdbtypes.h" 2698944Sobrien#include "gdbcore.h" 2746283Sdfr#include "expression.h" 2846283Sdfr#include "value.h" 2946283Sdfr#include "demangle.h" 3046283Sdfr#include "valprint.h" 3146283Sdfr#include "language.h" 3246283Sdfr#include "jv-lang.h" 3346283Sdfr#include "c-lang.h" 3498944Sobrien#include "annotate.h" 35130803Smarcel#include "gdb_string.h" 3646283Sdfr 3798944Sobrien/* Local functions */ 3898944Sobrien 3998944Sobrienstatic void java_print_value_fields (struct type * type, char *valaddr, 4098944Sobrien CORE_ADDR address, 4198944Sobrien struct ui_file *stream, int format, 4298944Sobrien int recurse, 4398944Sobrien enum val_prettyprint pretty); 4498944Sobrien 4598944Sobrien 4646283Sdfrint 4798944Sobrienjava_value_print (struct value *val, struct ui_file *stream, int format, 4898944Sobrien enum val_prettyprint pretty) 4946283Sdfr{ 5046283Sdfr struct type *type; 5146283Sdfr CORE_ADDR address; 5246283Sdfr int i; 5346283Sdfr char *name; 5446283Sdfr 5546283Sdfr type = VALUE_TYPE (val); 5646283Sdfr address = VALUE_ADDRESS (val) + VALUE_OFFSET (val); 5746283Sdfr 5846283Sdfr if (is_object_type (type)) 5946283Sdfr { 6046283Sdfr CORE_ADDR obj_addr; 6146283Sdfr 6246283Sdfr /* Get the run-time type, and cast the object into that */ 6346283Sdfr 6446283Sdfr obj_addr = unpack_pointer (type, VALUE_CONTENTS (val)); 6546283Sdfr 6646283Sdfr if (obj_addr != 0) 6746283Sdfr { 6846283Sdfr type = type_from_class (java_class_from_object (val)); 6946283Sdfr type = lookup_pointer_type (type); 7046283Sdfr 7146283Sdfr val = value_at (type, address, NULL); 7246283Sdfr } 7346283Sdfr } 7446283Sdfr 7598944Sobrien if (TYPE_CODE (type) == TYPE_CODE_PTR && !value_logical_not (val)) 7646283Sdfr type_print (TYPE_TARGET_TYPE (type), "", stream, -1); 7746283Sdfr 7846283Sdfr name = TYPE_TAG_NAME (type); 7946283Sdfr if (TYPE_CODE (type) == TYPE_CODE_STRUCT && name != NULL 8098944Sobrien && (i = strlen (name), name[i - 1] == ']')) 8146283Sdfr { 8246283Sdfr char buf4[4]; 8346283Sdfr long length; 8446283Sdfr unsigned int things_printed = 0; 8598944Sobrien int reps; 8646283Sdfr struct type *el_type = java_primitive_type_from_name (name, i - 2); 8746283Sdfr 8846283Sdfr i = 0; 8946283Sdfr read_memory (address + JAVA_OBJECT_SIZE, buf4, 4); 9046283Sdfr 9146283Sdfr length = (long) extract_signed_integer (buf4, 4); 9246283Sdfr fprintf_filtered (stream, "{length: %ld", length); 9346283Sdfr 9446283Sdfr if (el_type == NULL) 9546283Sdfr { 9698944Sobrien CORE_ADDR element; 9798944Sobrien CORE_ADDR next_element = -1; /* dummy initial value */ 9846283Sdfr 9998944Sobrien address += JAVA_OBJECT_SIZE + 4; /* Skip object header and length. */ 10046283Sdfr 10146283Sdfr while (i < length && things_printed < print_max) 10246283Sdfr { 10398944Sobrien char *buf; 10446283Sdfr 10598944Sobrien buf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT); 10646283Sdfr fputs_filtered (", ", stream); 10746283Sdfr wrap_here (n_spaces (2)); 10846283Sdfr 10946283Sdfr if (i > 0) 11046283Sdfr element = next_element; 11146283Sdfr else 11246283Sdfr { 11398944Sobrien read_memory (address, buf, sizeof (buf)); 11446283Sdfr address += TARGET_PTR_BIT / HOST_CHAR_BIT; 115130803Smarcel /* FIXME: cagney/2003-05-24: Bogus or what. It 116130803Smarcel pulls a host sized pointer out of the target and 117130803Smarcel then extracts that as an address (while assuming 118130803Smarcel that the address is unsigned)! */ 119130803Smarcel element = extract_unsigned_integer (buf, sizeof (buf)); 12046283Sdfr } 12146283Sdfr 12298944Sobrien for (reps = 1; i + reps < length; reps++) 12346283Sdfr { 12498944Sobrien read_memory (address, buf, sizeof (buf)); 12546283Sdfr address += TARGET_PTR_BIT / HOST_CHAR_BIT; 126130803Smarcel /* FIXME: cagney/2003-05-24: Bogus or what. It 127130803Smarcel pulls a host sized pointer out of the target and 128130803Smarcel then extracts that as an address (while assuming 129130803Smarcel that the address is unsigned)! */ 130130803Smarcel next_element = extract_unsigned_integer (buf, sizeof (buf)); 13146283Sdfr if (next_element != element) 13246283Sdfr break; 13346283Sdfr } 13446283Sdfr 13546283Sdfr if (reps == 1) 13646283Sdfr fprintf_filtered (stream, "%d: ", i); 13746283Sdfr else 13846283Sdfr fprintf_filtered (stream, "%d..%d: ", i, i + reps - 1); 13946283Sdfr 14046283Sdfr if (element == 0) 14146283Sdfr fprintf_filtered (stream, "null"); 14246283Sdfr else 14398944Sobrien fprintf_filtered (stream, "@%s", paddr_nz (element)); 14446283Sdfr 14546283Sdfr things_printed++; 14646283Sdfr i += reps; 14746283Sdfr } 14846283Sdfr } 14946283Sdfr else 15046283Sdfr { 15198944Sobrien struct value *v = allocate_value (el_type); 15298944Sobrien struct value *next_v = allocate_value (el_type); 15346283Sdfr 15446283Sdfr VALUE_ADDRESS (v) = address + JAVA_OBJECT_SIZE + 4; 15546283Sdfr VALUE_ADDRESS (next_v) = VALUE_ADDRESS (v); 15646283Sdfr 15746283Sdfr while (i < length && things_printed < print_max) 15846283Sdfr { 15946283Sdfr fputs_filtered (", ", stream); 16046283Sdfr wrap_here (n_spaces (2)); 16146283Sdfr 16246283Sdfr if (i > 0) 16346283Sdfr { 16498944Sobrien struct value *tmp; 16546283Sdfr 16646283Sdfr tmp = next_v; 16746283Sdfr next_v = v; 16846283Sdfr v = tmp; 16946283Sdfr } 17046283Sdfr else 17146283Sdfr { 17246283Sdfr VALUE_LAZY (v) = 1; 17346283Sdfr VALUE_OFFSET (v) = 0; 17446283Sdfr } 17546283Sdfr 17646283Sdfr VALUE_OFFSET (next_v) = VALUE_OFFSET (v); 17746283Sdfr 17898944Sobrien for (reps = 1; i + reps < length; reps++) 17946283Sdfr { 18046283Sdfr VALUE_LAZY (next_v) = 1; 18146283Sdfr VALUE_OFFSET (next_v) += TYPE_LENGTH (el_type); 18246283Sdfr if (memcmp (VALUE_CONTENTS (v), VALUE_CONTENTS (next_v), 18346283Sdfr TYPE_LENGTH (el_type)) != 0) 18446283Sdfr break; 18546283Sdfr } 18646283Sdfr 18746283Sdfr if (reps == 1) 18846283Sdfr fprintf_filtered (stream, "%d: ", i); 18946283Sdfr else 19046283Sdfr fprintf_filtered (stream, "%d..%d: ", i, i + reps - 1); 19146283Sdfr 192242936Semaste common_val_print (v, stream, format, 2, 1, pretty); 19346283Sdfr 19446283Sdfr things_printed++; 19546283Sdfr i += reps; 19646283Sdfr } 19746283Sdfr } 19846283Sdfr 19946283Sdfr if (i < length) 20046283Sdfr fprintf_filtered (stream, "..."); 20146283Sdfr 20246283Sdfr fprintf_filtered (stream, "}"); 20346283Sdfr 20446283Sdfr return 0; 20546283Sdfr } 20646283Sdfr 20746283Sdfr /* If it's type String, print it */ 20846283Sdfr 20946283Sdfr if (TYPE_CODE (type) == TYPE_CODE_PTR 21046283Sdfr && TYPE_TARGET_TYPE (type) 211130803Smarcel && TYPE_TAG_NAME (TYPE_TARGET_TYPE (type)) 212130803Smarcel && strcmp (TYPE_TAG_NAME (TYPE_TARGET_TYPE (type)), 213130803Smarcel "java.lang.String") == 0 21446283Sdfr && (format == 0 || format == 's') 21598944Sobrien && address != 0 21698944Sobrien && value_as_address (val) != 0) 21746283Sdfr { 21898944Sobrien struct value *data_val; 21946283Sdfr CORE_ADDR data; 22098944Sobrien struct value *boffset_val; 22146283Sdfr unsigned long boffset; 22298944Sobrien struct value *count_val; 22346283Sdfr unsigned long count; 22498944Sobrien struct value *mark; 22546283Sdfr 22646283Sdfr mark = value_mark (); /* Remember start of new values */ 22746283Sdfr 22846283Sdfr data_val = value_struct_elt (&val, NULL, "data", NULL, NULL); 22998944Sobrien data = value_as_address (data_val); 23046283Sdfr 23146283Sdfr boffset_val = value_struct_elt (&val, NULL, "boffset", NULL, NULL); 23298944Sobrien boffset = value_as_address (boffset_val); 23346283Sdfr 23446283Sdfr count_val = value_struct_elt (&val, NULL, "count", NULL, NULL); 23598944Sobrien count = value_as_address (count_val); 23646283Sdfr 23798944Sobrien value_free_to_mark (mark); /* Release unnecessary values */ 23846283Sdfr 23946283Sdfr val_print_string (data + boffset, count, 2, stream); 24046283Sdfr 24146283Sdfr return 0; 24246283Sdfr } 24346283Sdfr 244242936Semaste return common_val_print (val, stream, format, 1, 0, pretty); 24546283Sdfr} 24646283Sdfr 24746283Sdfr/* TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the 24846283Sdfr same meanings as in cp_print_value and c_val_print. 24946283Sdfr 25046283Sdfr DONT_PRINT is an array of baseclass types that we 25146283Sdfr should not print, or zero if called from top level. */ 25246283Sdfr 25398944Sobrienstatic void 25498944Sobrienjava_print_value_fields (struct type *type, char *valaddr, CORE_ADDR address, 25598944Sobrien struct ui_file *stream, int format, int recurse, 25698944Sobrien enum val_prettyprint pretty) 25746283Sdfr{ 25846283Sdfr int i, len, n_baseclasses; 25946283Sdfr 26046283Sdfr CHECK_TYPEDEF (type); 26146283Sdfr 26246283Sdfr fprintf_filtered (stream, "{"); 26346283Sdfr len = TYPE_NFIELDS (type); 26446283Sdfr n_baseclasses = TYPE_N_BASECLASSES (type); 26546283Sdfr 26646283Sdfr if (n_baseclasses > 0) 26746283Sdfr { 26846283Sdfr int i, n_baseclasses = TYPE_N_BASECLASSES (type); 26946283Sdfr 27046283Sdfr for (i = 0; i < n_baseclasses; i++) 27146283Sdfr { 27246283Sdfr int boffset; 27346283Sdfr struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i)); 27446283Sdfr char *basename = TYPE_NAME (baseclass); 27546283Sdfr char *base_valaddr; 27698944Sobrien 27746283Sdfr if (BASETYPE_VIA_VIRTUAL (type, i)) 27846283Sdfr continue; 27946283Sdfr 28046283Sdfr if (basename != NULL && strcmp (basename, "java.lang.Object") == 0) 28146283Sdfr continue; 28246283Sdfr 28346283Sdfr boffset = 0; 28446283Sdfr 28546283Sdfr if (pretty) 28646283Sdfr { 28746283Sdfr fprintf_filtered (stream, "\n"); 28898944Sobrien print_spaces_filtered (2 * (recurse + 1), stream); 28946283Sdfr } 29046283Sdfr fputs_filtered ("<", stream); 29146283Sdfr /* Not sure what the best notation is in the case where there is no 29246283Sdfr baseclass name. */ 29346283Sdfr fputs_filtered (basename ? basename : "", stream); 29446283Sdfr fputs_filtered ("> = ", stream); 29546283Sdfr 29646283Sdfr base_valaddr = valaddr; 29746283Sdfr 29846283Sdfr java_print_value_fields (baseclass, base_valaddr, address + boffset, 29998944Sobrien stream, format, recurse + 1, pretty); 30046283Sdfr fputs_filtered (", ", stream); 30146283Sdfr } 30246283Sdfr 30346283Sdfr } 30446283Sdfr 30546283Sdfr if (!len && n_baseclasses == 1) 30646283Sdfr fprintf_filtered (stream, "<No data fields>"); 30746283Sdfr else 30846283Sdfr { 30946283Sdfr int fields_seen = 0; 31046283Sdfr 31146283Sdfr for (i = n_baseclasses; i < len; i++) 31246283Sdfr { 31346283Sdfr /* If requested, skip printing of static fields. */ 31446283Sdfr if (TYPE_FIELD_STATIC (type, i)) 31546283Sdfr { 31646283Sdfr char *name = TYPE_FIELD_NAME (type, i); 31746283Sdfr if (!static_field_print) 31846283Sdfr continue; 31946283Sdfr if (name != NULL && strcmp (name, "class") == 0) 32046283Sdfr continue; 32146283Sdfr } 32246283Sdfr if (fields_seen) 32346283Sdfr fprintf_filtered (stream, ", "); 32446283Sdfr else if (n_baseclasses > 0) 32546283Sdfr { 32646283Sdfr if (pretty) 32746283Sdfr { 32846283Sdfr fprintf_filtered (stream, "\n"); 32946283Sdfr print_spaces_filtered (2 + 2 * recurse, stream); 33046283Sdfr fputs_filtered ("members of ", stream); 33146283Sdfr fputs_filtered (type_name_no_tag (type), stream); 33246283Sdfr fputs_filtered (": ", stream); 33346283Sdfr } 33446283Sdfr } 33546283Sdfr fields_seen = 1; 33646283Sdfr 33746283Sdfr if (pretty) 33846283Sdfr { 33946283Sdfr fprintf_filtered (stream, "\n"); 34046283Sdfr print_spaces_filtered (2 + 2 * recurse, stream); 34146283Sdfr } 34298944Sobrien else 34346283Sdfr { 34446283Sdfr wrap_here (n_spaces (2 + 2 * recurse)); 34546283Sdfr } 34646283Sdfr if (inspect_it) 34746283Sdfr { 34846283Sdfr if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR) 34946283Sdfr fputs_filtered ("\"( ptr \"", stream); 35046283Sdfr else 35146283Sdfr fputs_filtered ("\"( nodef \"", stream); 35246283Sdfr if (TYPE_FIELD_STATIC (type, i)) 35346283Sdfr fputs_filtered ("static ", stream); 35446283Sdfr fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i), 35546283Sdfr language_cplus, 35646283Sdfr DMGL_PARAMS | DMGL_ANSI); 35746283Sdfr fputs_filtered ("\" \"", stream); 35846283Sdfr fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i), 35946283Sdfr language_cplus, 36046283Sdfr DMGL_PARAMS | DMGL_ANSI); 36146283Sdfr fputs_filtered ("\") \"", stream); 36246283Sdfr } 36346283Sdfr else 36446283Sdfr { 36546283Sdfr annotate_field_begin (TYPE_FIELD_TYPE (type, i)); 36646283Sdfr 36746283Sdfr if (TYPE_FIELD_STATIC (type, i)) 36846283Sdfr fputs_filtered ("static ", stream); 36946283Sdfr fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i), 37046283Sdfr language_cplus, 37146283Sdfr DMGL_PARAMS | DMGL_ANSI); 37246283Sdfr annotate_field_name_end (); 37346283Sdfr fputs_filtered (": ", stream); 37446283Sdfr annotate_field_value (); 37546283Sdfr } 37646283Sdfr 37746283Sdfr if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i)) 37846283Sdfr { 37998944Sobrien struct value *v; 38046283Sdfr 38146283Sdfr /* Bitfields require special handling, especially due to byte 38298944Sobrien order problems. */ 38346283Sdfr if (TYPE_FIELD_IGNORE (type, i)) 38446283Sdfr { 38598944Sobrien fputs_filtered ("<optimized out or zero length>", stream); 38646283Sdfr } 38746283Sdfr else 38846283Sdfr { 38998944Sobrien v = value_from_longest (TYPE_FIELD_TYPE (type, i), 39046283Sdfr unpack_field_as_long (type, valaddr, i)); 39146283Sdfr 392242936Semaste common_val_print (v, stream, format, 0, recurse + 1, pretty); 39346283Sdfr } 39446283Sdfr } 39546283Sdfr else 39646283Sdfr { 39746283Sdfr if (TYPE_FIELD_IGNORE (type, i)) 39846283Sdfr { 39998944Sobrien fputs_filtered ("<optimized out or zero length>", stream); 40046283Sdfr } 40146283Sdfr else if (TYPE_FIELD_STATIC (type, i)) 40246283Sdfr { 40398944Sobrien struct value *v = value_static_field (type, i); 40446283Sdfr if (v == NULL) 40546283Sdfr fputs_filtered ("<optimized out>", stream); 40646283Sdfr else 40746283Sdfr { 40846283Sdfr struct type *t = check_typedef (VALUE_TYPE (v)); 40946283Sdfr if (TYPE_CODE (t) == TYPE_CODE_STRUCT) 41046283Sdfr v = value_addr (v); 411242936Semaste common_val_print (v, stream, format, 0, recurse + 1, 412242936Semaste pretty); 41346283Sdfr } 41446283Sdfr } 41598944Sobrien else if (TYPE_FIELD_TYPE (type, i) == NULL) 41698944Sobrien fputs_filtered ("<unknown type>", stream); 41746283Sdfr else 41846283Sdfr { 41998944Sobrien val_print (TYPE_FIELD_TYPE (type, i), 42098944Sobrien valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0, 42198944Sobrien address + TYPE_FIELD_BITPOS (type, i) / 8, 42298944Sobrien stream, format, 0, recurse + 1, pretty); 42346283Sdfr } 42446283Sdfr } 42546283Sdfr annotate_field_end (); 42646283Sdfr } 42746283Sdfr 42846283Sdfr if (pretty) 42946283Sdfr { 43046283Sdfr fprintf_filtered (stream, "\n"); 43146283Sdfr print_spaces_filtered (2 * recurse, stream); 43246283Sdfr } 43346283Sdfr } 43446283Sdfr fprintf_filtered (stream, "}"); 43546283Sdfr} 43646283Sdfr 43746283Sdfr/* Print data of type TYPE located at VALADDR (within GDB), which came from 43846283Sdfr the inferior at address ADDRESS, onto stdio stream STREAM according to 43946283Sdfr FORMAT (a letter or 0 for natural format). The data at VALADDR is in 44046283Sdfr target byte order. 44146283Sdfr 44246283Sdfr If the data are a string pointer, returns the number of string characters 44346283Sdfr printed. 44446283Sdfr 44546283Sdfr If DEREF_REF is nonzero, then dereference references, otherwise just print 44646283Sdfr them like pointers. 44746283Sdfr 44846283Sdfr The PRETTY parameter controls prettyprinting. */ 44946283Sdfr 45046283Sdfrint 45198944Sobrienjava_val_print (struct type *type, char *valaddr, int embedded_offset, 45298944Sobrien CORE_ADDR address, struct ui_file *stream, int format, 45398944Sobrien int deref_ref, int recurse, enum val_prettyprint pretty) 45446283Sdfr{ 455130803Smarcel unsigned int i = 0; /* Number of characters printed */ 45646283Sdfr struct type *target_type; 45746283Sdfr CORE_ADDR addr; 45846283Sdfr 45946283Sdfr CHECK_TYPEDEF (type); 46046283Sdfr switch (TYPE_CODE (type)) 46146283Sdfr { 46246283Sdfr case TYPE_CODE_PTR: 46346283Sdfr if (format && format != 's') 46446283Sdfr { 46546283Sdfr print_scalar_formatted (valaddr, type, format, 0, stream); 46646283Sdfr break; 46746283Sdfr } 46846283Sdfr#if 0 46998944Sobrien if (vtblprint && cp_is_vtbl_ptr_type (type)) 47046283Sdfr { 47198944Sobrien /* Print the unmangled name if desired. */ 47246283Sdfr /* Print vtable entry - we only get here if we ARE using 47346283Sdfr -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */ 474130803Smarcel /* Extract an address, assume that it is unsigned. */ 475130803Smarcel print_address_demangle (extract_unsigned_integer (valaddr, TYPE_LENGTH (type)), 47698944Sobrien stream, demangle); 47746283Sdfr break; 47846283Sdfr } 47946283Sdfr#endif 48046283Sdfr addr = unpack_pointer (type, valaddr); 48146283Sdfr if (addr == 0) 48246283Sdfr { 48346283Sdfr fputs_filtered ("null", stream); 48446283Sdfr return i; 48546283Sdfr } 48646283Sdfr target_type = check_typedef (TYPE_TARGET_TYPE (type)); 48746283Sdfr 48846283Sdfr if (TYPE_CODE (target_type) == TYPE_CODE_FUNC) 48946283Sdfr { 49046283Sdfr /* Try to print what function it points to. */ 49146283Sdfr print_address_demangle (addr, stream, demangle); 49246283Sdfr /* Return value is irrelevant except for string pointers. */ 49346283Sdfr return (0); 49446283Sdfr } 49546283Sdfr 49646283Sdfr if (addressprint && format != 's') 49746283Sdfr { 49846283Sdfr fputs_filtered ("@", stream); 49946283Sdfr print_longest (stream, 'x', 0, (ULONGEST) addr); 50046283Sdfr } 50146283Sdfr 50246283Sdfr return i; 50346283Sdfr 50446283Sdfr case TYPE_CODE_CHAR: 505130803Smarcel case TYPE_CODE_INT: 506130803Smarcel /* Can't just call c_val_print because that prints bytes as C 507130803Smarcel chars. */ 50846283Sdfr format = format ? format : output_format; 50946283Sdfr if (format) 51046283Sdfr print_scalar_formatted (valaddr, type, format, 0, stream); 511130803Smarcel else if (TYPE_CODE (type) == TYPE_CODE_CHAR 512130803Smarcel || (TYPE_CODE (type) == TYPE_CODE_INT 513130803Smarcel && TYPE_LENGTH (type) == 2 514130803Smarcel && strcmp (TYPE_NAME (type), "char") == 0)) 51546283Sdfr LA_PRINT_CHAR ((int) unpack_long (type, valaddr), stream); 51646283Sdfr else 51746283Sdfr val_print_type_code_int (type, valaddr, stream); 51846283Sdfr break; 51946283Sdfr 52046283Sdfr case TYPE_CODE_STRUCT: 52146283Sdfr java_print_value_fields (type, valaddr, address, stream, format, 52246283Sdfr recurse, pretty); 52346283Sdfr break; 52446283Sdfr 52546283Sdfr default: 52646283Sdfr return c_val_print (type, valaddr, embedded_offset, address, stream, 52746283Sdfr format, deref_ref, recurse, pretty); 52846283Sdfr } 52946283Sdfr 53046283Sdfr return 0; 53146283Sdfr} 532