/* Support for printing C++ values for GDB, the GNU debugger.
- Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
- 2000, 2001, 2002
- Free Software Foundation, Inc.
+
+ Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+ 2000, 2001, 2002, 2003, 2005, 2006, 2007 Free Software Foundation, Inc.
This file is part of GDB.
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include "gdb_obstack.h"
#include "c-lang.h"
#include "target.h"
#include "cp-abi.h"
+#include "valprint.h"
+#include "cp-support.h"
+#include "language.h"
-/* Indication of presence of HP-compiled object files */
-extern int hp_som_som_object_present; /* defined in symtab.c */
+/* Controls printing of vtbl's */
+int vtblprint;
+static void
+show_vtblprint (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+Printing of C++ virtual function tables is %s.\n"),
+ value);
+}
+/* Controls looking up an object's derived type using what we find in
+ its vtables. */
+int objectprint;
+static void
+show_objectprint (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ fprintf_filtered (file, _("\
+Printing of object's derived type based on vtable info is %s.\n"),
+ value);
+}
-int vtblprint; /* Controls printing of vtbl's */
-int objectprint; /* Controls looking up an object's derived type
- using what we find in its vtables. */
int static_field_print; /* Controls printing of static fields. */
+static void
+show_static_field_print (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Printing of C++ static members is %s.\n"),
+ value);
+}
+
static struct obstack dont_print_vb_obstack;
static struct obstack dont_print_statmem_obstack;
struct ui_file *, int, int,
enum val_prettyprint);
-static void cp_print_value (struct type *, struct type *, char *, int,
- CORE_ADDR, struct ui_file *, int, int,
+static void cp_print_value (struct type *, struct type *, const gdb_byte *,
+ int, CORE_ADDR, struct ui_file *, int, int,
enum val_prettyprint, struct type **);
static void cp_print_hpacc_virtual_table_entries (struct type *, int *,
enum val_prettyprint);
-void
-cp_print_class_method (char *valaddr,
- struct type *type,
- struct ui_file *stream)
-{
- struct type *domain;
- struct fn_field *f = NULL;
- int j = 0;
- int len2;
- int offset;
- char *kind = "";
- CORE_ADDR addr;
- struct symbol *sym;
- unsigned len;
- unsigned int i;
- struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
-
- domain = TYPE_DOMAIN_TYPE (target_type);
- if (domain == (struct type *) NULL)
- {
- fprintf_filtered (stream, "<unknown>");
- return;
- }
- addr = unpack_pointer (lookup_pointer_type (builtin_type_void), valaddr);
- if (METHOD_PTR_IS_VIRTUAL (addr))
- {
- offset = METHOD_PTR_TO_VOFFSET (addr);
- len = TYPE_NFN_FIELDS (domain);
- for (i = 0; i < len; i++)
- {
- f = TYPE_FN_FIELDLIST1 (domain, i);
- len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
-
- check_stub_method_group (domain, i);
- for (j = 0; j < len2; j++)
- {
- if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
- {
- kind = "virtual ";
- goto common;
- }
- }
- }
- }
- else
- {
- sym = find_pc_function (addr);
- if (sym == 0)
- {
- /* 1997-08-01 Currently unsupported with HP aCC */
- if (hp_som_som_object_present)
- {
- fputs_filtered ("?? <not supported with HP aCC>", stream);
- return;
- }
- error ("invalid pointer to member function");
- }
- len = TYPE_NFN_FIELDS (domain);
- for (i = 0; i < len; i++)
- {
- f = TYPE_FN_FIELDLIST1 (domain, i);
- len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
-
- check_stub_method_group (f, j);
- for (j = 0; j < len2; j++)
- {
- if (STREQ (SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j)))
- goto common;
- }
- }
- }
- common:
- if (i < len)
- {
- char *demangled_name;
-
- fprintf_filtered (stream, "&");
- fprintf_filtered (stream, kind);
- demangled_name = cplus_demangle (TYPE_FN_FIELD_PHYSNAME (f, j),
- DMGL_ANSI | DMGL_PARAMS);
- if (demangled_name == NULL)
- fprintf_filtered (stream, "<badly mangled name %s>",
- TYPE_FN_FIELD_PHYSNAME (f, j));
- else
- {
- fputs_filtered (demangled_name, stream);
- xfree (demangled_name);
- }
- }
- else
- {
- fprintf_filtered (stream, "(");
- type_print (type, "", stream, -1);
- fprintf_filtered (stream, ") %d", (int) addr >> 3);
- }
-}
-
-/* This was what it was for gcc 2.4.5 and earlier. */
-static const char vtbl_ptr_name_old[] =
-{
- CPLUS_MARKER, 'v', 't', 'b', 'l', '_', 'p', 't', 'r', '_',
- 't', 'y', 'p', 'e', 0
-};
-
-/* It was changed to this after 2.4.5. */
+/* GCC versions after 2.4.5 use this. */
const char vtbl_ptr_name[] = "__vtbl_ptr_type";
-/* HP aCC uses different names */
+/* HP aCC uses different names. */
const char hpacc_vtbl_ptr_name[] = "__vfp";
const char hpacc_vtbl_ptr_type_name[] = "__vftyp";
-
/* Return truth value for assertion that TYPE is of the type
"pointer to virtual function". */
{
char *typename = type_name_no_tag (type);
- return (typename != NULL
- && (STREQ (typename, vtbl_ptr_name)
- || STREQ (typename, vtbl_ptr_name_old)));
+ return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
}
/* Return truth value for the assertion that TYPE is of the type
should not print, or zero if called from top level. */
void
-cp_print_value_fields (struct type *type, struct type *real_type, char *valaddr,
- int offset, CORE_ADDR address, struct ui_file *stream,
- int format, int recurse, enum val_prettyprint pretty,
- struct type **dont_print_vb, int dont_print_statmem)
+cp_print_value_fields (struct type *type, struct type *real_type,
+ const gdb_byte *valaddr, int offset, CORE_ADDR address,
+ struct ui_file *stream, int format, int recurse,
+ enum val_prettyprint pretty,
+ struct type **dont_print_vb,int dont_print_statmem)
{
int i, len, n_baseclasses;
- struct obstack tmp_obstack;
char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
int fields_seen = 0;
if ((len == n_baseclasses)
|| ((len - n_baseclasses == 1)
&& TYPE_HAS_VTABLE (type)
- && STREQN (TYPE_FIELD_NAME (type, n_baseclasses),
- hpacc_vtbl_ptr_name, 5))
+ && strncmp (TYPE_FIELD_NAME (type, n_baseclasses),
+ hpacc_vtbl_ptr_name, 5) == 0)
|| !len)
fprintf_filtered (stream, "<No data fields>");
else
{
- extern int inspect_it;
+ struct obstack tmp_obstack = dont_print_statmem_obstack;
if (dont_print_statmem == 0)
{
/* If we're at top level, carve out a completely fresh
chunk of the obstack and use that until this particular
invocation returns. */
- tmp_obstack = dont_print_statmem_obstack;
obstack_finish (&dont_print_statmem_obstack);
}
/* If a vtable pointer appears, we'll print it out later */
if (TYPE_HAS_VTABLE (type)
- && STREQN (TYPE_FIELD_NAME (type, i), hpacc_vtbl_ptr_name, 5))
+ && strncmp (TYPE_FIELD_NAME (type, i), hpacc_vtbl_ptr_name,
+ 5) == 0)
continue;
if (fields_seen)
if (TYPE_FIELD_STATIC (type, i))
fputs_filtered ("static ", stream);
fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
- language_cplus,
+ current_language->la_language,
DMGL_PARAMS | DMGL_ANSI);
fputs_filtered ("\" \"", stream);
fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
- language_cplus,
+ current_language->la_language,
DMGL_PARAMS | DMGL_ANSI);
fputs_filtered ("\") \"", stream);
}
if (TYPE_FIELD_STATIC (type, i))
fputs_filtered ("static ", stream);
fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
- language_cplus,
+ current_language->la_language,
DMGL_PARAMS | DMGL_ANSI);
annotate_field_name_end ();
/* do not print leading '=' in case of anonymous unions */
(TYPE_FIELD_TYPE (type, i),
unpack_field_as_long (type, valaddr + offset, i));
- val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v),
- 0, 0, stream, format, 0, recurse + 1, pretty);
+ common_val_print (v, stream, format, 0, recurse + 1, pretty);
}
}
else
} /* if there are data fields */
/* Now print out the virtual table pointer if there is one */
if (TYPE_HAS_VTABLE (type)
- && STREQN (TYPE_FIELD_NAME (type, n_baseclasses),
- hpacc_vtbl_ptr_name,
- 5))
+ && strncmp (TYPE_FIELD_NAME (type, n_baseclasses),
+ hpacc_vtbl_ptr_name, 5) == 0)
{
struct value *v;
/* First get the virtual table pointer and print it out */
v = value_from_pointer (lookup_pointer_type (builtin_type_unsigned_long),
*(unsigned long *) (valaddr + offset));
- val_print (VALUE_TYPE (v), VALUE_CONTENTS (v), 0, 0,
- stream, format, 0, recurse + 1, pretty);
+ common_val_print (v, stream, format, 0, recurse + 1, pretty);
fields_seen = 1;
if (vtblprint)
baseclasses. */
static void
-cp_print_value (struct type *type, struct type *real_type, char *valaddr,
- int offset, CORE_ADDR address, struct ui_file *stream,
- int format, int recurse, enum val_prettyprint pretty,
- struct type **dont_print_vb)
+cp_print_value (struct type *type, struct type *real_type,
+ const gdb_byte *valaddr, int offset, CORE_ADDR address,
+ struct ui_file *stream, int format, int recurse,
+ enum val_prettyprint pretty, struct type **dont_print_vb)
{
- struct obstack tmp_obstack;
struct type **last_dont_print
= (struct type **) obstack_next_free (&dont_print_vb_obstack);
+ struct obstack tmp_obstack = dont_print_vb_obstack;
int i, n_baseclasses = TYPE_N_BASECLASSES (type);
int thisoffset;
struct type *thistype;
/* If we're at top level, carve out a completely fresh
chunk of the obstack and use that until this particular
invocation returns. */
- tmp_obstack = dont_print_vb_obstack;
/* Bump up the high-water mark. Now alpha is omega. */
obstack_finish (&dont_print_vb_obstack);
}
int skip;
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
char *basename = TYPE_NAME (baseclass);
- char *base_valaddr;
+ const gdb_byte *base_valaddr;
if (BASETYPE_VIA_VIRTUAL (type, i))
{
find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
valaddr, offset, &boffset, &skip);
if (skip >= 0)
- error ("Virtual base class offset not found from vtable while"
- " printing");
+ error (_("Virtual base class offset not found from vtable while"
+ " printing"));
base_valaddr = valaddr;
}
else
{
boffset = baseclass_offset (type, i,
valaddr + offset,
- address + offset);
+ address);
skip = ((boffset == -1) || (boffset + offset) < 0) ? 1 : -1;
if (BASETYPE_VIA_VIRTUAL (type, i))
|| (boffset + offset) >= TYPE_LENGTH (type)))
{
/* FIXME (alloca): unsafe if baseclass is really really large. */
- base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
- if (target_read_memory (address + offset + boffset, base_valaddr,
+ gdb_byte *buf = alloca (TYPE_LENGTH (baseclass));
+ base_valaddr = buf;
+ if (target_read_memory (address + boffset, buf,
TYPE_LENGTH (baseclass)) != 0)
skip = 1;
+ address = address + boffset;
thisoffset = 0;
boffset = 0;
thistype = baseclass;
fprintf_filtered (stream, "<invalid address>");
else
cp_print_value_fields (baseclass, thistype, base_valaddr,
- thisoffset + boffset, address, stream, format,
+ thisoffset + boffset, address + boffset,
+ stream, format,
recurse, pretty,
((struct type **)
obstack_base (&dont_print_vb_obstack)),
sizeof (CORE_ADDR));
CHECK_TYPEDEF (type);
- cp_print_value_fields (type, type, VALUE_CONTENTS_ALL (val),
- VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
+ cp_print_value_fields (type, type, value_contents_all (val),
+ value_embedded_offset (val), VALUE_ADDRESS (val),
stream, format, recurse, pretty, NULL, 1);
return;
}
- val_print (type, VALUE_CONTENTS_ALL (val),
- VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
+ val_print (type, value_contents_all (val),
+ value_embedded_offset (val), VALUE_ADDRESS (val),
stream, format, 0, recurse, pretty);
}
+
+/* Find the field in *DOMAIN, or its non-virtual base classes, with bit offset
+ OFFSET. Set *DOMAIN to the containing type and *FIELDNO to the containing
+ field number. If OFFSET is not exactly at the start of some field, set
+ *DOMAIN to NULL. */
+
void
-cp_print_class_member (char *valaddr, struct type *domain,
- struct ui_file *stream, char *prefix)
+cp_find_class_member (struct type **domain_p, int *fieldno,
+ LONGEST offset)
{
+ struct type *domain;
+ unsigned int i;
+ unsigned len;
+
+ *domain_p = check_typedef (*domain_p);
+ domain = *domain_p;
+ len = TYPE_NFIELDS (domain);
+ for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
+ {
+ LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
+
+ QUIT;
+ if (offset == bitpos)
+ {
+ *fieldno = i;
+ return;
+ }
+ }
+
+ for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
+ {
+ LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
+ LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
+
+ if (offset >= bitpos && offset < bitpos + bitsize)
+ {
+ *domain_p = TYPE_FIELD_TYPE (domain, i);
+ cp_find_class_member (domain_p, fieldno, offset - bitpos);
+ return;
+ }
+ }
+
+ *domain_p = NULL;
+}
+
+void
+cp_print_class_member (const gdb_byte *valaddr, struct type *domain,
+ struct ui_file *stream, char *prefix)
+{
/* VAL is a byte offset into the structure type DOMAIN.
Find the name of the field for that offset and
print it. */
- int extra = 0;
- int bits = 0;
- register unsigned int i;
- unsigned len = TYPE_NFIELDS (domain);
-
- /* @@ Make VAL into bit offset */
+ unsigned int fieldno;
- /* Note: HP aCC generates offsets that are the real byte offsets added
- to a constant bias 0x20000000 (1 << 29). This constant bias gets
- shifted out in the code below -- joyous happenstance! */
+ LONGEST val = unpack_long (builtin_type_long, valaddr);
- /* Note: HP cfront uses a constant bias of 1; if we support this
- compiler ever, we will have to adjust the computation below */
+ /* Pointers to data members are usually byte offsets into an object.
+ Because a data member can have offset zero, and a NULL pointer to
+ member must be distinct from any valid non-NULL pointer to
+ member, either the value is biased or the NULL value has a
+ special representation; both are permitted by ISO C++. HP aCC
+ used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
+ and other compilers which use the Itanium ABI use -1 as the NULL
+ value. GDB only supports that last form; to add support for
+ another form, make this into a cp-abi hook. */
- LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
- for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
+ if (val == -1)
{
- int bitpos = TYPE_FIELD_BITPOS (domain, i);
- QUIT;
- if (val == bitpos)
- break;
- if (val < bitpos && i != 0)
- {
- /* Somehow pointing into a field. */
- i -= 1;
- extra = (val - TYPE_FIELD_BITPOS (domain, i));
- if (extra & 0x7)
- bits = 1;
- else
- extra >>= 3;
- break;
- }
+ fprintf_filtered (stream, "NULL");
+ return;
}
- if (i < len)
+
+ cp_find_class_member (&domain, &fieldno, val << 3);
+
+ if (domain != NULL)
{
char *name;
- fprintf_filtered (stream, prefix);
+ fputs_filtered (prefix, stream);
name = type_name_no_tag (domain);
if (name)
fputs_filtered (name, stream);
else
c_type_print_base (domain, stream, 0, 0);
fprintf_filtered (stream, "::");
- fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
- if (extra)
- fprintf_filtered (stream, " + %d bytes", extra);
- if (bits)
- fprintf_filtered (stream, " (offset in bits)");
+ fputs_filtered (TYPE_FIELD_NAME (domain, fieldno), stream);
}
else
- fprintf_filtered (stream, "%ld", (long) (val >> 3));
+ fprintf_filtered (stream, "%ld", (long) val);
}
/* Get the address of the vfunction entry */
struct value *vf = value_copy (v);
- if (VALUE_LAZY (vf))
+ if (value_lazy (vf))
(void) value_fetch_lazy (vf);
/* adjust by offset */
- vf->aligner.contents[0] += 4 * (HP_ACC_VFUNC_START + vx);
+ /* NOTE: cagney/2005-01-02: THIS IS BOGUS. */
+ value_contents_writeable (vf)[0] += 4 * (HP_ACC_VFUNC_START + vx);
vf = value_ind (vf); /* get the entry */
- VALUE_TYPE (vf) = VALUE_TYPE (v); /* make it a pointer */
+ /* make it a pointer */
+ deprecated_set_value_type (vf, value_type (v));
/* print out the entry */
- val_print (VALUE_TYPE (vf), VALUE_CONTENTS (vf), 0, 0,
- stream, format, 0, recurse + 1, pretty);
+ common_val_print (vf, stream, format, 0, recurse + 1, pretty);
field_physname
= TYPE_FN_FIELD_PHYSNAME (TYPE_FN_FIELDLIST1 (type, fn), oi);
/* pai: (temp) FIXME Maybe this should be DMGL_ANSI */
void
_initialize_cp_valprint (void)
{
- add_show_from_set
- (add_set_cmd ("static-members", class_support, var_boolean,
- (char *) &static_field_print,
- "Set printing of C++ static members.",
- &setprintlist),
- &showprintlist);
+ add_setshow_boolean_cmd ("static-members", class_support,
+ &static_field_print, _("\
+Set printing of C++ static members."), _("\
+Show printing of C++ static members."), NULL,
+ NULL,
+ show_static_field_print,
+ &setprintlist, &showprintlist);
/* Turn on printing of static fields. */
static_field_print = 1;
- add_show_from_set
- (add_set_cmd ("vtbl", class_support, var_boolean, (char *) &vtblprint,
- "Set printing of C++ virtual function tables.",
- &setprintlist),
- &showprintlist);
-
- add_show_from_set
- (add_set_cmd ("object", class_support, var_boolean, (char *) &objectprint,
- "Set printing of object's derived type based on vtable info.",
- &setprintlist),
- &showprintlist);
+ add_setshow_boolean_cmd ("vtbl", class_support, &vtblprint, _("\
+Set printing of C++ virtual function tables."), _("\
+Show printing of C++ virtual function tables."), NULL,
+ NULL,
+ show_vtblprint,
+ &setprintlist, &showprintlist);
+
+ add_setshow_boolean_cmd ("object", class_support, &objectprint, _("\
+Set printing of object's derived type based on vtable info."), _("\
+Show printing of object's derived type based on vtable info."), NULL,
+ NULL,
+ show_objectprint,
+ &setprintlist, &showprintlist);
/* Give people the defaults which they are used to. */
objectprint = 0;