[deliverable/binutils-gdb.git] / gdb / jv-valprint.c

/* Support for printing Java values for GDB, the GNU debugger.

   Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
   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 2 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, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

#include "defs.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "gdbcore.h"
#include "expression.h"
#include "value.h"
#include "demangle.h"
#include "valprint.h"
#include "language.h"
#include "jv-lang.h"
#include "c-lang.h"
#include "annotate.h"
#include "gdb_string.h"

/* Local functions */

int
java_value_print (struct value *val, struct ui_file *stream, int format,
		  enum val_prettyprint pretty)
{
  struct type *type;
  CORE_ADDR address;
  int i;
  char *name;

  type = value_type (val);
  address = VALUE_ADDRESS (val) + value_offset (val);

  if (is_object_type (type))
    {
      CORE_ADDR obj_addr;

      /* Get the run-time type, and cast the object into that */

      obj_addr = unpack_pointer (type, value_contents (val));

      if (obj_addr != 0)
	{
	  type = type_from_class (java_class_from_object (val));
	  type = lookup_pointer_type (type);

	  val = value_at (type, address);
	}
    }

  if (TYPE_CODE (type) == TYPE_CODE_PTR && !value_logical_not (val))
    type_print (TYPE_TARGET_TYPE (type), "", stream, -1);

  name = TYPE_TAG_NAME (type);
  if (TYPE_CODE (type) == TYPE_CODE_STRUCT && name != NULL
      && (i = strlen (name), name[i - 1] == ']'))
    {
      gdb_byte buf4[4];
      long length;
      unsigned int things_printed = 0;
      int reps;
      struct type *el_type = java_primitive_type_from_name (name, i - 2);

      i = 0;
      read_memory (address + JAVA_OBJECT_SIZE, buf4, 4);

      length = (long) extract_signed_integer (buf4, 4);
      fprintf_filtered (stream, "{length: %ld", length);

      if (el_type == NULL)
	{
	  CORE_ADDR element;
	  CORE_ADDR next_element = -1; /* dummy initial value */

	  address += JAVA_OBJECT_SIZE + 4;	/* Skip object header and length. */

	  while (i < length && things_printed < print_max)
	    {
	      gdb_byte *buf;

	      buf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT);
	      fputs_filtered (", ", stream);
	      wrap_here (n_spaces (2));

	      if (i > 0)
		element = next_element;
	      else
		{
		  read_memory (address, buf, sizeof (buf));
		  address += TARGET_PTR_BIT / 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));
		}

	      for (reps = 1; i + reps < length; reps++)
		{
		  read_memory (address, buf, sizeof (buf));
		  address += TARGET_PTR_BIT / 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));
		  if (next_element != element)
		    break;
		}

	      if (reps == 1)
		fprintf_filtered (stream, "%d: ", i);
	      else
		fprintf_filtered (stream, "%d..%d: ", i, i + reps - 1);

	      if (element == 0)
		fprintf_filtered (stream, "null");
	      else
		fprintf_filtered (stream, "@%s", paddr_nz (element));

	      things_printed++;
	      i += reps;
	    }
	}
      else
	{
	  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);

	  while (i < length && things_printed < print_max)
	    {
	      fputs_filtered (", ", stream);
	      wrap_here (n_spaces (2));

	      if (i > 0)
		{
		  struct value *tmp;

		  tmp = next_v;
		  next_v = v;
		  v = tmp;
		}
	      else
		{
		  set_value_lazy (v, 1);
		  set_value_offset (v, 0);
		}

	      set_value_offset (next_v, value_offset (v));

	      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)
		    break;
		}

	      if (reps == 1)
		fprintf_filtered (stream, "%d: ", i);
	      else
		fprintf_filtered (stream, "%d..%d: ", i, i + reps - 1);

	      common_val_print (v, stream, format, 2, 1, pretty);

	      things_printed++;
	      i += reps;
	    }
	}

      if (i < length)
	fprintf_filtered (stream, "...");

      fprintf_filtered (stream, "}");

      return 0;
    }

  /* If it's type String, print it */

  if (TYPE_CODE (type) == TYPE_CODE_PTR
      && TYPE_TARGET_TYPE (type)
      && TYPE_TAG_NAME (TYPE_TARGET_TYPE (type))
      && strcmp (TYPE_TAG_NAME (TYPE_TARGET_TYPE (type)),
		 "java.lang.String") == 0
      && (format == 0 || format == 's')
      && address != 0
      && value_as_address (val) != 0)
    {
      struct value *data_val;
      CORE_ADDR data;
      struct value *boffset_val;
      unsigned long boffset;
      struct value *count_val;
      unsigned long count;
      struct value *mark;

      mark = value_mark ();	/* Remember start of new values */

      data_val = value_struct_elt (&val, NULL, "data", NULL, NULL);
      data = value_as_address (data_val);

      boffset_val = value_struct_elt (&val, NULL, "boffset", NULL, NULL);
      boffset = value_as_address (boffset_val);

      count_val = value_struct_elt (&val, NULL, "count", NULL, NULL);
      count = value_as_address (count_val);

      value_free_to_mark (mark);	/* Release unnecessary values */

      val_print_string (data + boffset, count, 2, stream);

      return 0;
    }

  return common_val_print (val, stream, format, 1, 0, pretty);
}

/* TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
   same meanings as in cp_print_value and c_val_print.

   DONT_PRINT is an array of baseclass types that we
   should not print, or zero if called from top level.  */

static void
java_print_value_fields (struct type *type, const gdb_byte *valaddr,
			 CORE_ADDR address, struct ui_file *stream,
			 int format, int recurse, enum val_prettyprint pretty)
{
  int i, len, n_baseclasses;

  CHECK_TYPEDEF (type);

  fprintf_filtered (stream, "{");
  len = TYPE_NFIELDS (type);
  n_baseclasses = TYPE_N_BASECLASSES (type);

  if (n_baseclasses > 0)
    {
      int i, n_baseclasses = TYPE_N_BASECLASSES (type);

      for (i = 0; i < n_baseclasses; i++)
	{
	  int boffset;
	  struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
	  char *basename = TYPE_NAME (baseclass);
	  const gdb_byte *base_valaddr;

	  if (BASETYPE_VIA_VIRTUAL (type, i))
	    continue;

	  if (basename != NULL && strcmp (basename, "java.lang.Object") == 0)
	    continue;

	  boffset = 0;

	  if (pretty)
	    {
	      fprintf_filtered (stream, "\n");
	      print_spaces_filtered (2 * (recurse + 1), stream);
	    }
	  fputs_filtered ("<", stream);
	  /* Not sure what the best notation is in the case where there is no
	     baseclass name.  */
	  fputs_filtered (basename ? basename : "", stream);
	  fputs_filtered ("> = ", stream);

	  base_valaddr = valaddr;

	  java_print_value_fields (baseclass, base_valaddr, address + boffset,
				   stream, format, recurse + 1, pretty);
	  fputs_filtered (", ", stream);
	}

    }

  if (!len && n_baseclasses == 1)
    fprintf_filtered (stream, "<No data fields>");
  else
    {
      int fields_seen = 0;

      for (i = n_baseclasses; i < len; i++)
	{
	  /* If requested, skip printing of static fields.  */
	  if (TYPE_FIELD_STATIC (type, i))
	    {
	      char *name = TYPE_FIELD_NAME (type, i);
	      if (!static_field_print)
		continue;
	      if (name != NULL && strcmp (name, "class") == 0)
		continue;
	    }
	  if (fields_seen)
	    fprintf_filtered (stream, ", ");
	  else if (n_baseclasses > 0)
	    {
	      if (pretty)
		{
		  fprintf_filtered (stream, "\n");
		  print_spaces_filtered (2 + 2 * recurse, stream);
		  fputs_filtered ("members of ", stream);
		  fputs_filtered (type_name_no_tag (type), stream);
		  fputs_filtered (": ", stream);
		}
	    }
	  fields_seen = 1;

	  if (pretty)
	    {
	      fprintf_filtered (stream, "\n");
	      print_spaces_filtered (2 + 2 * recurse, stream);
	    }
	  else
	    {
	      wrap_here (n_spaces (2 + 2 * recurse));
	    }
	  if (inspect_it)
	    {
	      if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
		fputs_filtered ("\"( ptr \"", stream);
	      else
		fputs_filtered ("\"( nodef \"", stream);
	      if (TYPE_FIELD_STATIC (type, i))
		fputs_filtered ("static ", stream);
	      fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
				       language_cplus,
				       DMGL_PARAMS | DMGL_ANSI);
	      fputs_filtered ("\" \"", stream);
	      fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
				       language_cplus,
				       DMGL_PARAMS | DMGL_ANSI);
	      fputs_filtered ("\") \"", stream);
	    }
	  else
	    {
	      annotate_field_begin (TYPE_FIELD_TYPE (type, i));

	      if (TYPE_FIELD_STATIC (type, i))
		fputs_filtered ("static ", stream);
	      fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
				       language_cplus,
				       DMGL_PARAMS | DMGL_ANSI);
	      annotate_field_name_end ();
	      fputs_filtered (": ", stream);
	      annotate_field_value ();
	    }

	  if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
	    {
	      struct value *v;

	      /* Bitfields require special handling, especially due to byte
	         order problems.  */
	      if (TYPE_FIELD_IGNORE (type, i))
		{
		  fputs_filtered ("<optimized out or zero length>", stream);
		}
	      else
		{
		  v = value_from_longest (TYPE_FIELD_TYPE (type, i),
				   unpack_field_as_long (type, valaddr, i));

		  common_val_print (v, stream, format, 0, recurse + 1, pretty);
		}
	    }
	  else
	    {
	      if (TYPE_FIELD_IGNORE (type, i))
		{
		  fputs_filtered ("<optimized out or zero length>", stream);
		}
	      else if (TYPE_FIELD_STATIC (type, i))
		{
		  struct value *v = value_static_field (type, i);
		  if (v == NULL)
		    fputs_filtered ("<optimized out>", stream);
		  else
		    {
		      struct type *t = check_typedef (value_type (v));
		      if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
			v = value_addr (v);
		      common_val_print (v, stream, format, 0, recurse + 1,
					pretty);
		    }
		}
	      else if (TYPE_FIELD_TYPE (type, i) == NULL)
		fputs_filtered ("<unknown type>", stream);
	      else
		{
		  val_print (TYPE_FIELD_TYPE (type, i),
			     valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0,
			     address + TYPE_FIELD_BITPOS (type, i) / 8,
			     stream, format, 0, recurse + 1, pretty);
		}
	    }
	  annotate_field_end ();
	}

      if (pretty)
	{
	  fprintf_filtered (stream, "\n");
	  print_spaces_filtered (2 * recurse, stream);
	}
    }
  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
   FORMAT (a letter or 0 for natural format).  The data at VALADDR is in
   target byte order.

   If the data are a string pointer, returns the number of string characters
   printed.

   If DEREF_REF is nonzero, then dereference references, otherwise just print
   them like pointers.

   The PRETTY parameter controls prettyprinting.  */

int
java_val_print (struct type *type, const gdb_byte *valaddr,
		int embedded_offset, CORE_ADDR address,
		struct ui_file *stream, int format, int deref_ref,
		int recurse, enum val_prettyprint pretty)
{
  unsigned int i = 0;	/* Number of characters printed */
  struct type *target_type;
  CORE_ADDR addr;

  CHECK_TYPEDEF (type);
  switch (TYPE_CODE (type))
    {
    case TYPE_CODE_PTR:
      if (format && format != 's')
	{
	  print_scalar_formatted (valaddr, type, format, 0, stream);
	  break;
	}
#if 0
      if (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);
	  break;
	}
#endif
      addr = unpack_pointer (type, valaddr);
      if (addr == 0)
	{
	  fputs_filtered ("null", stream);
	  return i;
	}
      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);
	}

      if (addressprint && format != 's')
	{
	  fputs_filtered ("@", stream);
	  print_longest (stream, 'x', 0, (ULONGEST) addr);
	}

      return i;

    case TYPE_CODE_CHAR:
    case TYPE_CODE_INT:
      /* Can't just call c_val_print because that prints bytes as C
	 chars.  */
      format = format ? format : output_format;
      if (format)
	print_scalar_formatted (valaddr, type, format, 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), stream);
      else
	val_print_type_code_int (type, valaddr, stream);
      break;

    case TYPE_CODE_STRUCT:
      java_print_value_fields (type, valaddr, address, stream, format,
			       recurse, pretty);
      break;

    default:
      return c_val_print (type, valaddr, embedded_offset, address, stream,
			  format, deref_ref, recurse, pretty);
    }

  return 0;
}
Commit	Line	Data
c906108c	1	/* Support for printing Java values for GDB, the GNU debugger.
1e4728e7	2
6aba47ca DJ	3	Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
6aba47ca DJ	4	Free Software Foundation, Inc.
c906108c	5
c5aa993b	6	This file is part of GDB.
c906108c	7
c5aa993b JM	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
c906108c	12
c5aa993b JM	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
c906108c	17
c5aa993b JM	18	You should have received a copy of the GNU General Public License
c5aa993b JM	19	along with this program; if not, write to the Free Software
197e01b6 EZ	20	Foundation, Inc., 51 Franklin Street, Fifth Floor,
197e01b6 EZ	21	Boston, MA 02110-1301, USA. */
c906108c SS	22
	23	#include "defs.h"
	24	#include "symtab.h"
	25	#include "gdbtypes.h"
7a292a7a	26	#include "gdbcore.h"
c906108c SS	27	#include "expression.h"
	28	#include "value.h"
	29	#include "demangle.h"
	30	#include "valprint.h"
	31	#include "language.h"
	32	#include "jv-lang.h"
	33	#include "c-lang.h"
7a292a7a	34	#include "annotate.h"
309367d4	35	#include "gdb_string.h"
c906108c	36
392a587b JM	37	/* Local functions */
392a587b JM	38
c906108c	39	int
75c9979e	40	java_value_print (struct value val, struct ui_file stream, int format,
fba45db2	41	enum val_prettyprint pretty)
c906108c SS	42	{
	43	struct type *type;
	44	CORE_ADDR address;
	45	int i;
	46	char *name;
	47
df407dfe AC	48	type = value_type (val);
df407dfe AC	49	address = VALUE_ADDRESS (val) + value_offset (val);
c906108c SS	50
	51	if (is_object_type (type))
	52	{
	53	CORE_ADDR obj_addr;
	54
	55	/* Get the run-time type, and cast the object into that */
	56
0fd88904	57	obj_addr = unpack_pointer (type, value_contents (val));
c906108c SS	58
	59	if (obj_addr != 0)
	60	{
	61	type = type_from_class (java_class_from_object (val));
	62	type = lookup_pointer_type (type);
	63
00a4c844	64	val = value_at (type, address);
c906108c SS	65	}
	66	}
	67
c5aa993b	68	if (TYPE_CODE (type) == TYPE_CODE_PTR && !value_logical_not (val))
c906108c SS	69	type_print (TYPE_TARGET_TYPE (type), "", stream, -1);
	70
	71	name = TYPE_TAG_NAME (type);
	72	if (TYPE_CODE (type) == TYPE_CODE_STRUCT && name != NULL
c5aa993b	73	&& (i = strlen (name), name[i - 1] == ']'))
c906108c	74	{
c68a6671	75	gdb_byte buf4[4];
c906108c SS	76	long length;
c906108c SS	77	unsigned int things_printed = 0;
c5aa993b	78	int reps;
c906108c SS	79	struct type *el_type = java_primitive_type_from_name (name, i - 2);
	80
	81	i = 0;
	82	read_memory (address + JAVA_OBJECT_SIZE, buf4, 4);
	83
	84	length = (long) extract_signed_integer (buf4, 4);
	85	fprintf_filtered (stream, "{length: %ld", length);
	86
	87	if (el_type == NULL)
	88	{
c65ecaf3 AC	89	CORE_ADDR element;
c65ecaf3 AC	90	CORE_ADDR next_element = -1; /* dummy initial value */
c906108c	91
c5aa993b	92	address += JAVA_OBJECT_SIZE + 4; /* Skip object header and length. */
c906108c SS	93
	94	while (i < length && things_printed < print_max)
	95	{
c68a6671	96	gdb_byte *buf;
c906108c	97
35fc8285	98	buf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT);
c906108c SS	99	fputs_filtered (", ", stream);
	100	wrap_here (n_spaces (2));
	101
	102	if (i > 0)
	103	element = next_element;
	104	else
	105	{
c5aa993b	106	read_memory (address, buf, sizeof (buf));
c906108c	107	address += TARGET_PTR_BIT / HOST_CHAR_BIT;
b276f1bb AC	108	/* FIXME: cagney/2003-05-24: Bogus or what. It
	109	pulls a host sized pointer out of the target and
	110	then extracts that as an address (while assuming
	111	that the address is unsigned)! */
	112	element = extract_unsigned_integer (buf, sizeof (buf));
c906108c SS	113	}
c906108c SS	114
c5aa993b	115	for (reps = 1; i + reps < length; reps++)
c906108c	116	{
c5aa993b	117	read_memory (address, buf, sizeof (buf));
c906108c	118	address += TARGET_PTR_BIT / HOST_CHAR_BIT;
b276f1bb AC	119	/* FIXME: cagney/2003-05-24: Bogus or what. It
	120	pulls a host sized pointer out of the target and
	121	then extracts that as an address (while assuming
	122	that the address is unsigned)! */
	123	next_element = extract_unsigned_integer (buf, sizeof (buf));
c906108c SS	124	if (next_element != element)
	125	break;
	126	}
	127
	128	if (reps == 1)
	129	fprintf_filtered (stream, "%d: ", i);
	130	else
	131	fprintf_filtered (stream, "%d..%d: ", i, i + reps - 1);
	132
	133	if (element == 0)
	134	fprintf_filtered (stream, "null");
	135	else
d4f3574e	136	fprintf_filtered (stream, "@%s", paddr_nz (element));
c906108c SS	137
	138	things_printed++;
	139	i += reps;
	140	}
	141	}
	142	else
	143	{
75c9979e AC	144	struct value *v = allocate_value (el_type);
75c9979e AC	145	struct value *next_v = allocate_value (el_type);
c906108c SS	146
	147	VALUE_ADDRESS (v) = address + JAVA_OBJECT_SIZE + 4;
	148	VALUE_ADDRESS (next_v) = VALUE_ADDRESS (v);
	149
	150	while (i < length && things_printed < print_max)
	151	{
	152	fputs_filtered (", ", stream);
	153	wrap_here (n_spaces (2));
	154
	155	if (i > 0)
	156	{
75c9979e	157	struct value *tmp;
c906108c SS	158
	159	tmp = next_v;
	160	next_v = v;
	161	v = tmp;
	162	}
	163	else
	164	{
dfa52d88	165	set_value_lazy (v, 1);
f5cf64a7	166	set_value_offset (v, 0);
c906108c SS	167	}
c906108c SS	168
f5cf64a7	169	set_value_offset (next_v, value_offset (v));
c906108c	170
c5aa993b	171	for (reps = 1; i + reps < length; reps++)
c906108c	172	{
dfa52d88	173	set_value_lazy (next_v, 1);
f5cf64a7	174	set_value_offset (next_v, value_offset (next_v) + TYPE_LENGTH (el_type));
0fd88904	175	if (memcmp (value_contents (v), value_contents (next_v),
c906108c SS	176	TYPE_LENGTH (el_type)) != 0)
	177	break;
	178	}
	179
	180	if (reps == 1)
	181	fprintf_filtered (stream, "%d: ", i);
	182	else
	183	fprintf_filtered (stream, "%d..%d: ", i, i + reps - 1);
	184
806048c6	185	common_val_print (v, stream, format, 2, 1, pretty);
c906108c SS	186
	187	things_printed++;
	188	i += reps;
	189	}
	190	}
	191
	192	if (i < length)
	193	fprintf_filtered (stream, "...");
	194
	195	fprintf_filtered (stream, "}");
	196
	197	return 0;
	198	}
	199
	200	/* If it's type String, print it */
	201
	202	if (TYPE_CODE (type) == TYPE_CODE_PTR
	203	&& TYPE_TARGET_TYPE (type)
d4cad8db TT	204	&& TYPE_TAG_NAME (TYPE_TARGET_TYPE (type))
	205	&& strcmp (TYPE_TAG_NAME (TYPE_TARGET_TYPE (type)),
	206	"java.lang.String") == 0
c906108c	207	&& (format == 0 \|\| format == 's')
8dccf761	208	&& address != 0
1aa20aa8	209	&& value_as_address (val) != 0)
c906108c	210	{
75c9979e	211	struct value *data_val;
c906108c	212	CORE_ADDR data;
75c9979e	213	struct value *boffset_val;
c906108c	214	unsigned long boffset;
75c9979e	215	struct value *count_val;
c906108c	216	unsigned long count;
75c9979e	217	struct value *mark;
c906108c SS	218
	219	mark = value_mark (); /* Remember start of new values */
	220
	221	data_val = value_struct_elt (&val, NULL, "data", NULL, NULL);
1aa20aa8	222	data = value_as_address (data_val);
c906108c SS	223
c906108c SS	224	boffset_val = value_struct_elt (&val, NULL, "boffset", NULL, NULL);
1aa20aa8	225	boffset = value_as_address (boffset_val);
c906108c SS	226
c906108c SS	227	count_val = value_struct_elt (&val, NULL, "count", NULL, NULL);
1aa20aa8	228	count = value_as_address (count_val);
c906108c	229
c5aa993b	230	value_free_to_mark (mark); /* Release unnecessary values */
c906108c SS	231
	232	val_print_string (data + boffset, count, 2, stream);
	233
	234	return 0;
	235	}
	236
806048c6	237	return common_val_print (val, stream, format, 1, 0, pretty);
c906108c SS	238	}
	239
	240	/* TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
	241	same meanings as in cp_print_value and c_val_print.
	242
	243	DONT_PRINT is an array of baseclass types that we
	244	should not print, or zero if called from top level. */
	245
392a587b	246	static void
fc1a4b47	247	java_print_value_fields (struct type type, const gdb_byte valaddr,
a2bd3dcd AC	248	CORE_ADDR address, struct ui_file *stream,
a2bd3dcd AC	249	int format, int recurse, enum val_prettyprint pretty)
c906108c SS	250	{
	251	int i, len, n_baseclasses;
	252
	253	CHECK_TYPEDEF (type);
	254
	255	fprintf_filtered (stream, "{");
	256	len = TYPE_NFIELDS (type);
	257	n_baseclasses = TYPE_N_BASECLASSES (type);
	258
	259	if (n_baseclasses > 0)
	260	{
	261	int i, n_baseclasses = TYPE_N_BASECLASSES (type);
	262
	263	for (i = 0; i < n_baseclasses; i++)
	264	{
	265	int boffset;
	266	struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
	267	char *basename = TYPE_NAME (baseclass);
fc1a4b47	268	const gdb_byte *base_valaddr;
c5aa993b	269
c906108c SS	270	if (BASETYPE_VIA_VIRTUAL (type, i))
	271	continue;
	272
	273	if (basename != NULL && strcmp (basename, "java.lang.Object") == 0)
	274	continue;
	275
	276	boffset = 0;
	277
	278	if (pretty)
	279	{
	280	fprintf_filtered (stream, "\n");
c5aa993b	281	print_spaces_filtered (2 * (recurse + 1), stream);
c906108c SS	282	}
	283	fputs_filtered ("<", stream);
	284	/* Not sure what the best notation is in the case where there is no
	285	baseclass name. */
	286	fputs_filtered (basename ? basename : "", stream);
	287	fputs_filtered ("> = ", stream);
	288
	289	base_valaddr = valaddr;
	290
	291	java_print_value_fields (baseclass, base_valaddr, address + boffset,
c5aa993b	292	stream, format, recurse + 1, pretty);
c906108c	293	fputs_filtered (", ", stream);
c906108c SS	294	}
	295
	296	}
	297
	298	if (!len && n_baseclasses == 1)
	299	fprintf_filtered (stream, "<No data fields>");
	300	else
	301	{
c906108c SS	302	int fields_seen = 0;
	303
	304	for (i = n_baseclasses; i < len; i++)
	305	{
	306	/* If requested, skip printing of static fields. */
	307	if (TYPE_FIELD_STATIC (type, i))
	308	{
	309	char *name = TYPE_FIELD_NAME (type, i);
	310	if (!static_field_print)
	311	continue;
	312	if (name != NULL && strcmp (name, "class") == 0)
	313	continue;
	314	}
	315	if (fields_seen)
	316	fprintf_filtered (stream, ", ");
	317	else if (n_baseclasses > 0)
	318	{
	319	if (pretty)
	320	{
	321	fprintf_filtered (stream, "\n");
	322	print_spaces_filtered (2 + 2 * recurse, stream);
	323	fputs_filtered ("members of ", stream);
	324	fputs_filtered (type_name_no_tag (type), stream);
	325	fputs_filtered (": ", stream);
	326	}
	327	}
	328	fields_seen = 1;
	329
	330	if (pretty)
	331	{
	332	fprintf_filtered (stream, "\n");
	333	print_spaces_filtered (2 + 2 * recurse, stream);
	334	}
c5aa993b	335	else
c906108c SS	336	{
	337	wrap_here (n_spaces (2 + 2 * recurse));
	338	}
	339	if (inspect_it)
	340	{
	341	if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
	342	fputs_filtered ("\"( ptr \"", stream);
	343	else
	344	fputs_filtered ("\"( nodef \"", stream);
	345	if (TYPE_FIELD_STATIC (type, i))
	346	fputs_filtered ("static ", stream);
	347	fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
	348	language_cplus,
	349	DMGL_PARAMS \| DMGL_ANSI);
	350	fputs_filtered ("\" \"", stream);
	351	fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
	352	language_cplus,
	353	DMGL_PARAMS \| DMGL_ANSI);
	354	fputs_filtered ("\") \"", stream);
	355	}
	356	else
	357	{
	358	annotate_field_begin (TYPE_FIELD_TYPE (type, i));
	359
	360	if (TYPE_FIELD_STATIC (type, i))
	361	fputs_filtered ("static ", stream);
	362	fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
	363	language_cplus,
	364	DMGL_PARAMS \| DMGL_ANSI);
	365	annotate_field_name_end ();
	366	fputs_filtered (": ", stream);
	367	annotate_field_value ();
	368	}
	369
	370	if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
	371	{
75c9979e	372	struct value *v;
c906108c SS	373
c906108c SS	374	/* Bitfields require special handling, especially due to byte
c5aa993b	375	order problems. */
c906108c SS	376	if (TYPE_FIELD_IGNORE (type, i))
c906108c SS	377	{
c5aa993b	378	fputs_filtered ("<optimized out or zero length>", stream);
c906108c SS	379	}
	380	else
	381	{
c5aa993b	382	v = value_from_longest (TYPE_FIELD_TYPE (type, i),
c906108c SS	383	unpack_field_as_long (type, valaddr, i));
c906108c SS	384
806048c6	385	common_val_print (v, stream, format, 0, recurse + 1, pretty);
c906108c SS	386	}
	387	}
	388	else
	389	{
	390	if (TYPE_FIELD_IGNORE (type, i))
	391	{
c5aa993b	392	fputs_filtered ("<optimized out or zero length>", stream);
c906108c SS	393	}
	394	else if (TYPE_FIELD_STATIC (type, i))
	395	{
75c9979e	396	struct value *v = value_static_field (type, i);
c906108c SS	397	if (v == NULL)
	398	fputs_filtered ("<optimized out>", stream);
	399	else
	400	{
df407dfe	401	struct type *t = check_typedef (value_type (v));
c906108c SS	402	if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
c906108c SS	403	v = value_addr (v);
806048c6 DJ	404	common_val_print (v, stream, format, 0, recurse + 1,
806048c6 DJ	405	pretty);
c906108c SS	406	}
c906108c SS	407	}
7a292a7a SS	408	else if (TYPE_FIELD_TYPE (type, i) == NULL)
7a292a7a SS	409	fputs_filtered ("<unknown type>", stream);
c906108c SS	410	else
c906108c SS	411	{
c5aa993b JM	412	val_print (TYPE_FIELD_TYPE (type, i),
	413	valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0,
	414	address + TYPE_FIELD_BITPOS (type, i) / 8,
	415	stream, format, 0, recurse + 1, pretty);
c906108c SS	416	}
	417	}
	418	annotate_field_end ();
	419	}
	420
	421	if (pretty)
	422	{
	423	fprintf_filtered (stream, "\n");
	424	print_spaces_filtered (2 * recurse, stream);
	425	}
	426	}
	427	fprintf_filtered (stream, "}");
	428	}
	429
	430	/* Print data of type TYPE located at VALADDR (within GDB), which came from
	431	the inferior at address ADDRESS, onto stdio stream STREAM according to
	432	FORMAT (a letter or 0 for natural format). The data at VALADDR is in
	433	target byte order.
	434
	435	If the data are a string pointer, returns the number of string characters
	436	printed.
	437
	438	If DEREF_REF is nonzero, then dereference references, otherwise just print
	439	them like pointers.
	440
	441	The PRETTY parameter controls prettyprinting. */
	442
	443	int
fc1a4b47	444	java_val_print (struct type type, const gdb_byte valaddr,
a2bd3dcd AC	445	int embedded_offset, CORE_ADDR address,
	446	struct ui_file *stream, int format, int deref_ref,
	447	int recurse, enum val_prettyprint pretty)
c906108c	448	{
52f0bd74	449	unsigned int i = 0; /* Number of characters printed */
c906108c SS	450	struct type *target_type;
	451	CORE_ADDR addr;
	452
	453	CHECK_TYPEDEF (type);
	454	switch (TYPE_CODE (type))
	455	{
	456	case TYPE_CODE_PTR:
	457	if (format && format != 's')
	458	{
	459	print_scalar_formatted (valaddr, type, format, 0, stream);
	460	break;
	461	}
	462	#if 0
c5aa993b	463	if (vtblprint && cp_is_vtbl_ptr_type (type))
c906108c	464	{
c5aa993b	465	/* Print the unmangled name if desired. */
c906108c SS	466	/* Print vtable entry - we only get here if we ARE using
c906108c SS	467	-fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
b276f1bb AC	468	/* Extract an address, assume that it is unsigned. */
b276f1bb AC	469	print_address_demangle (extract_unsigned_integer (valaddr, TYPE_LENGTH (type)),
c5aa993b	470	stream, demangle);
c906108c SS	471	break;
	472	}
	473	#endif
	474	addr = unpack_pointer (type, valaddr);
	475	if (addr == 0)
	476	{
	477	fputs_filtered ("null", stream);
	478	return i;
	479	}
	480	target_type = check_typedef (TYPE_TARGET_TYPE (type));
	481
	482	if (TYPE_CODE (target_type) == TYPE_CODE_FUNC)
	483	{
	484	/* Try to print what function it points to. */
	485	print_address_demangle (addr, stream, demangle);
	486	/* Return value is irrelevant except for string pointers. */
	487	return (0);
	488	}
	489
	490	if (addressprint && format != 's')
	491	{
	492	fputs_filtered ("@", stream);
	493	print_longest (stream, 'x', 0, (ULONGEST) addr);
	494	}
	495
	496	return i;
	497
	498	case TYPE_CODE_CHAR:
c906108c	499	case TYPE_CODE_INT:
c55a3f73 TT	500	/* Can't just call c_val_print because that prints bytes as C
c55a3f73 TT	501	chars. */
c906108c SS	502	format = format ? format : output_format;
	503	if (format)
	504	print_scalar_formatted (valaddr, type, format, 0, stream);
c55a3f73 TT	505	else if (TYPE_CODE (type) == TYPE_CODE_CHAR
	506	\|\| (TYPE_CODE (type) == TYPE_CODE_INT
	507	&& TYPE_LENGTH (type) == 2
	508	&& strcmp (TYPE_NAME (type), "char") == 0))
	509	LA_PRINT_CHAR ((int) unpack_long (type, valaddr), stream);
c906108c SS	510	else
	511	val_print_type_code_int (type, valaddr, stream);
	512	break;
	513
	514	case TYPE_CODE_STRUCT:
	515	java_print_value_fields (type, valaddr, address, stream, format,
	516	recurse, pretty);
	517	break;
	518
	519	default:
	520	return c_val_print (type, valaddr, embedded_offset, address, stream,
	521	format, deref_ref, recurse, pretty);
	522	}
	523
	524	return 0;
	525	}