[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,
   2008 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 3 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, see <http://www.gnu.org/licenses/>.  */

#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 (gdbarch_ptr_bit (current_gdbarch) / 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 += gdbarch_ptr_bit (current_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));
		}

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