/* Support for printing C++ values for GDB, the GNU debugger.
- Copyright 1986, 1988, 1989, 1991 Free Software Foundation, Inc.
-This file is part of GDB.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
-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 file is part of GDB.
-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.
+ 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.
-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., 675 Mass Ave, Cambridge, MA 02139, USA. */
+ 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 "obstack.h"
+#include "gdb_obstack.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
#include "command.h"
#include "gdbcmd.h"
#include "demangle.h"
+#include "annotate.h"
+#include "c-lang.h"
+#include "target.h"
+#include "cp-abi.h"
+#include "valprint.h"
+#include "cp-support.h"
+#include "language.h"
+#include "extension.h"
+#include "typeprint.h"
+#include "gdbsupport/byte-vector.h"
+#include "gdbarch.h"
+#include "cli/cli-style.h"
+
+static struct obstack dont_print_vb_obstack;
+static struct obstack dont_print_statmem_obstack;
+static struct obstack dont_print_stat_array_obstack;
+
+static void cp_print_static_field (struct type *, struct value *,
+ struct ui_file *, int,
+ const struct value_print_options *);
+
+static void cp_print_value (struct value *, struct ui_file *,
+ int, const struct value_print_options *,
+ struct type **);
+
+
+/* GCC versions after 2.4.5 use this. */
+const char vtbl_ptr_name[] = "__vtbl_ptr_type";
-int vtblprint; /* Controls printing of vtbl's */
-int objectprint; /* Controls looking up an object's derived type
- using what we find in its vtables. */
-struct obstack dont_print_obstack;
-
-static void
-cplus_print_value PARAMS ((struct type *, char *, GDB_FILE *, int, int,
- enum val_prettyprint, struct type **));
-
-/* BEGIN-FIXME: Hooks into typeprint.c, find a better home for prototypes. */
-
-extern void
-c_type_print_base PARAMS ((struct type *, GDB_FILE *, int, int));
-
-extern void
-c_type_print_varspec_prefix PARAMS ((struct type *, GDB_FILE *, int, int));
+/* Return truth value for assertion that TYPE is of the type
+ "pointer to virtual function". */
-extern void
-cp_type_print_method_args PARAMS ((struct type **, char *, char *, int,
- GDB_FILE *));
+int
+cp_is_vtbl_ptr_type (struct type *type)
+{
+ const char *type_name = TYPE_NAME (type);
-extern struct obstack dont_print_obstack;
+ return (type_name != NULL && !strcmp (type_name, vtbl_ptr_name));
+}
-/* END-FIXME */
+/* Return truth value for the assertion that TYPE is of the type
+ "pointer to virtual function table". */
-void
-cp_print_class_method (valaddr, type, stream)
- char *valaddr;
- struct type *type;
- GDB_FILE *stream;
+int
+cp_is_vtbl_member (struct type *type)
{
- 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;
-
- check_stub_type (TYPE_TARGET_TYPE (type));
- domain = TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (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);
-
- for (j = 0; j < len2; j++)
- {
- QUIT;
- if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
- {
- kind = "virtual ";
- goto common;
- }
- }
- }
- }
- else
+ /* With older versions of g++, the vtbl field pointed to an array of
+ structures. Nowadays it points directly to the structure. */
+ if (TYPE_CODE (type) == TYPE_CODE_PTR)
{
- sym = find_pc_function (addr);
- if (sym == 0)
- {
- error ("invalid pointer to member function");
- }
- len = TYPE_NFN_FIELDS (domain);
- for (i = 0; i < len; i++)
+ type = TYPE_TARGET_TYPE (type);
+ if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
- f = TYPE_FN_FIELDLIST1 (domain, i);
- len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
-
- for (j = 0; j < len2; j++)
+ type = TYPE_TARGET_TYPE (type);
+ if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */
+ || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
{
- QUIT;
- if (TYPE_FN_FIELD_STUB (f, j))
- check_stub_method (domain, i, j);
- if (STREQ (SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j)))
- {
- goto common;
- }
+ /* Virtual functions tables are full of pointers
+ to virtual functions. */
+ return cp_is_vtbl_ptr_type (type);
}
}
- }
- common:
- if (i < len)
- {
- fprintf_filtered (stream, "&");
- c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE (f, j), stream, 0, 0);
- fprintf_unfiltered (stream, kind);
- if (TYPE_FN_FIELD_PHYSNAME (f, j)[0] == '_'
- && TYPE_FN_FIELD_PHYSNAME (f, j)[1] == CPLUS_MARKER)
+ else if (TYPE_CODE (type) == TYPE_CODE_STRUCT) /* if not using thunks */
{
- cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j) + 1, "~",
- TYPE_FN_FIELDLIST_NAME (domain, i),
- 0, stream);
+ return cp_is_vtbl_ptr_type (type);
}
- else
+ else if (TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
{
- cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j), "",
- TYPE_FN_FIELDLIST_NAME (domain, i),
- 0, stream);
+ /* The type name of the thunk pointer is NULL when using
+ dwarf2. We could test for a pointer to a function, but
+ there is no type info for the virtual table either, so it
+ wont help. */
+ return cp_is_vtbl_ptr_type (type);
}
}
- else
- {
- fprintf_filtered (stream, "(");
- type_print (type, "", stream, -1);
- fprintf_filtered (stream, ") %d", (int) addr >> 3);
- }
-}
-
-/* Return truth value for assertion that TYPE is of the type
- "pointer to virtual function". */
-
-int
-cp_is_vtbl_ptr_type(type)
- struct type *type;
-{
- char *typename = type_name_no_tag (type);
- /* 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. */
- static const char vtbl_ptr_name[] =
- { '_','_','v','t','b','l','_','p','t','r','_','t','y','p','e', 0 };
-
- return (typename != NULL
- && (STREQ (typename, vtbl_ptr_name)
- || STREQ (typename, vtbl_ptr_name_old)));
-}
-
-/* Return truth value for the assertion that TYPE is of the type
- "pointer to virtual function table". */
-
-int
-cp_is_vtbl_member(type)
- struct type *type;
-{
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
- type = TYPE_TARGET_TYPE (type);
- else
- return 0;
-
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY
- && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT)
- /* Virtual functions tables are full of pointers to virtual functions. */
- return cp_is_vtbl_ptr_type (TYPE_TARGET_TYPE (type));
return 0;
}
-/* Mutually recursive subroutines of cplus_print_value and c_val_print to
- print out a structure's fields: cp_print_value_fields and cplus_print_value.
+/* Mutually recursive subroutines of cp_print_value and c_val_print to
+ print out a structure's fields: cp_print_value_fields and
+ cp_print_value.
+
+ TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
+ meanings as in cp_print_value and c_val_print.
- TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
- same meanings as in cplus_print_value and c_val_print.
+ 2nd argument REAL_TYPE is used to carry over the type of the
+ derived class across the recursion to base classes.
- DONT_PRINT is an array of baseclass types that we
- should not print, or zero if called from top level. */
+ DONT_PRINT is an array of baseclass types that we should not print,
+ or zero if called from top level. */
void
-cp_print_value_fields (type, valaddr, stream, format, recurse, pretty,
- dont_print)
- struct type *type;
- char *valaddr;
- GDB_FILE *stream;
- int format;
- int recurse;
- enum val_prettyprint pretty;
- struct type **dont_print;
+cp_print_value_fields (struct value *val, struct ui_file *stream,
+ int recurse, const struct value_print_options *options,
+ struct type **dont_print_vb,
+ int dont_print_statmem)
{
int i, len, n_baseclasses;
+ int fields_seen = 0;
+ static int last_set_recurse = -1;
- check_stub_type (type);
+ struct type *type = check_typedef (value_type (val));
+
+ if (recurse == 0)
+ {
+ /* Any object can be left on obstacks only during an unexpected
+ error. */
+
+ if (obstack_object_size (&dont_print_statmem_obstack) > 0)
+ {
+ obstack_free (&dont_print_statmem_obstack, NULL);
+ obstack_begin (&dont_print_statmem_obstack,
+ 32 * sizeof (CORE_ADDR));
+ }
+ if (obstack_object_size (&dont_print_stat_array_obstack) > 0)
+ {
+ obstack_free (&dont_print_stat_array_obstack, NULL);
+ obstack_begin (&dont_print_stat_array_obstack,
+ 32 * sizeof (struct type *));
+ }
+ }
fprintf_filtered (stream, "{");
len = TYPE_NFIELDS (type);
n_baseclasses = TYPE_N_BASECLASSES (type);
- /* Print out baseclasses such that we don't print
+ /* First, print out baseclasses such that we don't print
duplicates of virtual baseclasses. */
+
if (n_baseclasses > 0)
- cplus_print_value (type, valaddr, stream, format, recurse+1, pretty,
- dont_print);
+ cp_print_value (val, stream, recurse + 1, options, dont_print_vb);
+
+ /* Second, print out data fields */
- if (!len && n_baseclasses == 1)
- fprintf_filtered (stream, "<No data fields>");
+ /* If there are no data fields, skip this part */
+ if (len == n_baseclasses || !len)
+ fprintf_styled (stream, metadata_style.style (), "<No data fields>");
else
{
- extern int inspect_it;
- int fields_seen = 0;
+ size_t statmem_obstack_initial_size = 0;
+ size_t stat_array_obstack_initial_size = 0;
+ struct type *vptr_basetype = NULL;
+ int vptr_fieldno;
+ if (dont_print_statmem == 0)
+ {
+ statmem_obstack_initial_size =
+ obstack_object_size (&dont_print_statmem_obstack);
+
+ if (last_set_recurse != recurse)
+ {
+ stat_array_obstack_initial_size =
+ obstack_object_size (&dont_print_stat_array_obstack);
+
+ last_set_recurse = recurse;
+ }
+ }
+
+ vptr_fieldno = get_vptr_fieldno (type, &vptr_basetype);
for (i = n_baseclasses; i < len; i++)
{
- /* Check if static field */
- if (TYPE_FIELD_STATIC (type, i))
+ const gdb_byte *valaddr = value_contents_for_printing (val);
+
+ /* If requested, skip printing of static fields. */
+ if (!options->static_field_print
+ && field_is_static (&TYPE_FIELD (type, i)))
continue;
+
if (fields_seen)
- fprintf_filtered (stream, ", ");
+ {
+ fputs_filtered (",", stream);
+ if (!options->prettyformat)
+ fputs_filtered (" ", stream);
+ }
else if (n_baseclasses > 0)
{
- if (pretty)
+ if (options->prettyformat)
{
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);
+ fputs_filtered (TYPE_NAME (type), stream);
+ fputs_filtered (":", stream);
}
}
fields_seen = 1;
- if (pretty)
+ if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
- else
+ else
{
wrap_here (n_spaces (2 + 2 * recurse));
}
- if (inspect_it)
+
+ annotate_field_begin (TYPE_FIELD_TYPE (type, i));
+
+ if (field_is_static (&TYPE_FIELD (type, i)))
{
- if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
- fputs_filtered ("\"( ptr \"", stream);
- else
- fputs_filtered ("\"( nodef \"", 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,
+ fputs_filtered ("static ", stream);
+ fprintf_symbol_filtered (stream,
+ TYPE_FIELD_NAME (type, i),
+ current_language->la_language,
DMGL_PARAMS | DMGL_ANSI);
- fputs_filtered ("\") \"", stream);
}
+ else
+ fputs_styled (TYPE_FIELD_NAME (type, i),
+ variable_name_style.style (), stream);
+ annotate_field_name_end ();
+
+ /* We tweak various options in a few cases below. */
+ value_print_options options_copy = *options;
+ value_print_options *opts = &options_copy;
+
+ /* Do not print leading '=' in case of anonymous
+ unions. */
+ if (strcmp (TYPE_FIELD_NAME (type, i), ""))
+ fputs_filtered (" = ", stream);
else
{
- if (annotation_level > 1)
- printf_filtered ("\n\032\032field-name-begin\n");
- fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
- language_cplus,
- DMGL_PARAMS | DMGL_ANSI);
- if (annotation_level > 1)
- printf_filtered ("\n\032\032field-name-end\n");
- fputs_filtered (" = ", stream);
- }
-
- if (annotation_level > 1)
- {
- printf_filtered ("\n\032\032field-begin ");
- print_value_flags (TYPE_FIELD_TYPE (type, i));
- printf_filtered ("\n");
+ /* If this is an anonymous field then we want to consider it
+ as though it is at its parent's depth when it comes to the
+ max print depth. */
+ if (opts->max_depth != -1 && opts->max_depth < INT_MAX)
+ ++opts->max_depth;
}
+ annotate_field_value ();
- if (TYPE_FIELD_PACKED (type, i))
+ if (!field_is_static (&TYPE_FIELD (type, i))
+ && TYPE_FIELD_PACKED (type, i))
{
- value_ptr v;
+ struct value *v;
- /* Bitfields require special handling, especially due to byte
- order problems. */
+ /* Bitfields require special handling, especially due to
+ byte order problems. */
if (TYPE_FIELD_IGNORE (type, i))
{
- fputs_filtered ("<optimized out or zero length>", stream);
+ fputs_styled ("<optimized out or zero length>",
+ metadata_style.style (), stream);
+ }
+ else if (value_bits_synthetic_pointer (val,
+ TYPE_FIELD_BITPOS (type,
+ i),
+ TYPE_FIELD_BITSIZE (type,
+ i)))
+ {
+ fputs_styled (_("<synthetic pointer>"),
+ metadata_style.style (), stream);
}
else
{
- v = value_from_longest (TYPE_FIELD_TYPE (type, i),
- unpack_field_as_long (type, valaddr, i));
+ opts->deref_ref = 0;
+
+ v = value_field_bitfield (type, i, valaddr,
+ value_embedded_offset (val), val);
- val_print (TYPE_FIELD_TYPE(type, i), VALUE_CONTENTS (v), 0,
- stream, format, 0, recurse + 1, pretty);
+ common_val_print (v, stream, recurse + 1,
+ opts, current_language);
}
}
else
{
if (TYPE_FIELD_IGNORE (type, i))
{
- fputs_filtered ("<optimized out or zero length>", stream);
+ fputs_styled ("<optimized out or zero length>",
+ metadata_style.style (), stream);
+ }
+ else if (field_is_static (&TYPE_FIELD (type, i)))
+ {
+ try
+ {
+ struct value *v = value_static_field (type, i);
+
+ cp_print_static_field (TYPE_FIELD_TYPE (type, i),
+ v, stream, recurse + 1,
+ opts);
+ }
+ catch (const gdb_exception_error &ex)
+ {
+ fprintf_styled (stream, metadata_style.style (),
+ _("<error reading variable: %s>"),
+ ex.what ());
+ }
+ }
+ else if (i == vptr_fieldno && type == vptr_basetype)
+ {
+ int i_offset = TYPE_FIELD_BITPOS (type, i) / 8;
+ struct type *i_type = TYPE_FIELD_TYPE (type, i);
+
+ if (valprint_check_validity (stream, i_type, i_offset, val))
+ {
+ CORE_ADDR addr;
+
+ i_offset += value_embedded_offset (val);
+ addr = extract_typed_address (valaddr + i_offset, i_type);
+ print_function_pointer_address (opts,
+ get_type_arch (type),
+ addr, stream);
+ }
}
else
{
- val_print (TYPE_FIELD_TYPE (type, i),
- valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
- 0, stream, format, 0, recurse + 1, pretty);
+ struct value *v = value_primitive_field (val, 0, i, type);
+ opts->deref_ref = 0;
+ common_val_print (v, stream, recurse + 1, opts,
+ current_language);
}
}
- if (annotation_level > 1)
- printf_filtered ("\n\032\032field-end\n");
+ annotate_field_end ();
}
- if (pretty)
+ if (dont_print_statmem == 0)
+ {
+ size_t obstack_final_size =
+ obstack_object_size (&dont_print_statmem_obstack);
+
+ if (obstack_final_size > statmem_obstack_initial_size)
+ {
+ /* In effect, a pop of the printed-statics stack. */
+ size_t shrink_bytes
+ = statmem_obstack_initial_size - obstack_final_size;
+ obstack_blank_fast (&dont_print_statmem_obstack, shrink_bytes);
+ }
+
+ if (last_set_recurse != recurse)
+ {
+ obstack_final_size =
+ obstack_object_size (&dont_print_stat_array_obstack);
+
+ if (obstack_final_size > stat_array_obstack_initial_size)
+ {
+ void *free_to_ptr =
+ (char *) obstack_next_free (&dont_print_stat_array_obstack)
+ - (obstack_final_size
+ - stat_array_obstack_initial_size);
+
+ obstack_free (&dont_print_stat_array_obstack,
+ free_to_ptr);
+ }
+ last_set_recurse = -1;
+ }
+ }
+
+ if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
}
- }
+ } /* if there are data fields */
+
fprintf_filtered (stream, "}");
}
-/* Special val_print routine to avoid printing multiple copies of virtual
- baseclasses. */
+/* Special val_print routine to avoid printing multiple copies of
+ virtual baseclasses. */
static void
-cplus_print_value (type, valaddr, stream, format, recurse, pretty, dont_print)
- struct type *type;
- char *valaddr;
- GDB_FILE *stream;
- int format;
- int recurse;
- enum val_prettyprint pretty;
- struct type **dont_print;
+cp_print_value (struct value *val, struct ui_file *stream,
+ int recurse, const struct value_print_options *options,
+ struct type **dont_print_vb)
{
- struct obstack tmp_obstack;
+ struct type *type = check_typedef (value_type (val));
+ CORE_ADDR address = value_address (val);
struct type **last_dont_print
- = (struct type **)obstack_next_free (&dont_print_obstack);
+ = (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);
+ const gdb_byte *valaddr = value_contents_for_printing (val);
- if (dont_print == 0)
+ if (dont_print_vb == 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_obstack;
+ /* If we're at top level, carve out a completely fresh chunk of
+ the obstack and use that until this particular invocation
+ returns. */
/* Bump up the high-water mark. Now alpha is omega. */
- obstack_finish (&dont_print_obstack);
+ obstack_finish (&dont_print_vb_obstack);
}
for (i = 0; i < n_baseclasses; i++)
{
- /* FIXME-32x64--assumes that a target pointer can fit in a char *.
- Fix it by nuking baseclass_addr. */
- char *baddr;
- int err;
- char *basename;
-
- check_stub_type (TYPE_BASECLASS (type, i));
- basename = TYPE_NAME (TYPE_BASECLASS (type, i));
+ LONGEST boffset = 0;
+ int skip = 0;
+ struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
+ const char *basename = TYPE_NAME (baseclass);
+ struct value *base_val = NULL;
if (BASETYPE_VIA_VIRTUAL (type, i))
{
struct type **first_dont_print
- = (struct type **)obstack_base (&dont_print_obstack);
+ = (struct type **) obstack_base (&dont_print_vb_obstack);
- int j = (struct type **)obstack_next_free (&dont_print_obstack)
- - first_dont_print;
+ int j = (struct type **)
+ obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
while (--j >= 0)
- if (TYPE_BASECLASS (type, i) == first_dont_print[j])
+ if (baseclass == first_dont_print[j])
goto flush_it;
- obstack_ptr_grow (&dont_print_obstack, TYPE_BASECLASS (type, i));
+ obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
}
- /* Fix to use baseclass_offset instead. FIXME */
- baddr = baseclass_addr (type, i, valaddr, 0, &err);
- if (err == 0 && baddr == 0)
- error ("could not find virtual baseclass %s\n",
- basename ? basename : "");
+ try
+ {
+ boffset = baseclass_offset (type, i, valaddr,
+ value_embedded_offset (val),
+ address, val);
+ }
+ catch (const gdb_exception_error &ex)
+ {
+ if (ex.error == NOT_AVAILABLE_ERROR)
+ skip = -1;
+ else
+ skip = 1;
+ }
- if (pretty)
+ if (skip == 0)
+ {
+ if (BASETYPE_VIA_VIRTUAL (type, i))
+ {
+ /* The virtual base class pointer might have been
+ clobbered by the user program. Make sure that it
+ still points to a valid memory location. */
+
+ if (boffset < 0 || boffset >= TYPE_LENGTH (type))
+ {
+ gdb::byte_vector buf (TYPE_LENGTH (baseclass));
+
+ if (target_read_memory (address + boffset, buf.data (),
+ TYPE_LENGTH (baseclass)) != 0)
+ skip = 1;
+ base_val = value_from_contents_and_address (baseclass,
+ buf.data (),
+ address + boffset);
+ baseclass = value_type (base_val);
+ boffset = 0;
+ }
+ else
+ {
+ base_val = val;
+ }
+ }
+ else
+ {
+ base_val = val;
+ }
+ }
+
+ /* Now do the printing. */
+ if (options->prettyformat)
{
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 * recurse, stream);
}
fputs_filtered ("<", stream);
- /* Not sure what the best notation is in the case where there is no
- baseclass name. */
+ /* Not sure what the best notation is in the case where there is
+ no baseclass name. */
fputs_filtered (basename ? basename : "", stream);
fputs_filtered ("> = ", stream);
- if (err != 0)
+
+ if (skip < 0)
+ val_print_unavailable (stream);
+ else if (skip > 0)
+ val_print_invalid_address (stream);
+ else
{
- fprintf_filtered (stream, "<invalid address ");
- print_address_numeric ((CORE_ADDR) baddr, stream);
- fprintf_filtered (stream, ">");
+ int result = 0;
+
+ if (options->max_depth > -1
+ && recurse >= options->max_depth)
+ {
+ const struct language_defn *language = current_language;
+ gdb_assert (language->la_struct_too_deep_ellipsis != NULL);
+ fputs_filtered (language->la_struct_too_deep_ellipsis, stream);
+ }
+ else
+ {
+ struct value *baseclass_val = value_primitive_field (val, 0,
+ i, type);
+
+ /* Attempt to run an extension language pretty-printer on the
+ baseclass if possible. */
+ if (!options->raw)
+ result
+ = apply_ext_lang_val_pretty_printer (baseclass_val, stream,
+ recurse, options,
+ current_language);
+
+ if (!result)
+ cp_print_value_fields (baseclass_val, stream, recurse, options,
+ ((struct type **)
+ obstack_base (&dont_print_vb_obstack)),
+ 0);
+ }
}
- else
- cp_print_value_fields (TYPE_BASECLASS (type, i), baddr, stream, format,
- recurse, pretty,
- (struct type **) obstack_base (&dont_print_obstack));
fputs_filtered (", ", stream);
flush_it:
;
}
- if (dont_print == 0)
+ if (dont_print_vb == 0)
{
/* Free the space used to deal with the printing
- of this type from top level. */
- obstack_free (&dont_print_obstack, last_dont_print);
+ of this type from top level. */
+ obstack_free (&dont_print_vb_obstack, last_dont_print);
/* Reset watermark so that we can continue protecting
- ourselves from whatever we were protecting ourselves. */
- dont_print_obstack = tmp_obstack;
+ ourselves from whatever we were protecting ourselves. */
+ dont_print_vb_obstack = tmp_obstack;
}
}
-void
-cp_print_class_member (valaddr, domain, stream, prefix)
- char *valaddr;
- struct type *domain;
- GDB_FILE *stream;
- char *prefix;
+/* Print value of a static member. To avoid infinite recursion when
+ printing a class that contains a static instance of the class, we
+ keep the addresses of all printed static member classes in an
+ obstack and refuse to print them more than once.
+
+ VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
+ have the same meanings as in c_val_print. */
+
+static void
+cp_print_static_field (struct type *type,
+ struct value *val,
+ struct ui_file *stream,
+ int recurse,
+ const struct value_print_options *options)
{
-
- /* 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 */
- LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
- for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
+ struct value_print_options opts;
+
+ if (value_entirely_optimized_out (val))
+ {
+ val_print_optimized_out (val, stream);
+ return;
+ }
+
+ struct type *real_type = check_typedef (type);
+ if (TYPE_CODE (real_type) == TYPE_CODE_STRUCT)
+ {
+ CORE_ADDR *first_dont_print;
+ CORE_ADDR addr = value_address (val);
+ int i;
+
+ first_dont_print
+ = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
+ i = obstack_object_size (&dont_print_statmem_obstack)
+ / sizeof (CORE_ADDR);
+
+ while (--i >= 0)
+ {
+ if (addr == first_dont_print[i])
+ {
+ fputs_styled (_("<same as static member of an already"
+ " seen type>"),
+ metadata_style.style (), stream);
+ return;
+ }
+ }
+
+ obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
+ sizeof (CORE_ADDR));
+ cp_print_value_fields (val, stream, recurse, options, NULL, 1);
+ return;
+ }
+
+ if (TYPE_CODE (real_type) == TYPE_CODE_ARRAY)
{
- int bitpos = TYPE_FIELD_BITPOS (domain, i);
+ struct type **first_dont_print;
+ int i;
+ struct type *target_type = TYPE_TARGET_TYPE (type);
+
+ first_dont_print
+ = (struct type **) obstack_base (&dont_print_stat_array_obstack);
+ i = obstack_object_size (&dont_print_stat_array_obstack)
+ / sizeof (struct type *);
+
+ while (--i >= 0)
+ {
+ if (target_type == first_dont_print[i])
+ {
+ fputs_styled (_("<same as static member of an already"
+ " seen type>"),
+ metadata_style.style (), stream);
+ return;
+ }
+ }
+
+ obstack_grow (&dont_print_stat_array_obstack,
+ (char *) &target_type,
+ sizeof (struct type *));
+ }
+
+ opts = *options;
+ opts.deref_ref = 0;
+ common_val_print (val, stream, recurse, &opts, current_language);
+}
+
+/* Find the field in *SELF, or its non-virtual base classes, with
+ bit offset OFFSET. Set *SELF to the containing type and *FIELDNO
+ to the containing field number. If OFFSET is not exactly at the
+ start of some field, set *SELF to NULL. */
+
+static void
+cp_find_class_member (struct type **self_p, int *fieldno,
+ LONGEST offset)
+{
+ struct type *self;
+ unsigned int i;
+ unsigned len;
+
+ *self_p = check_typedef (*self_p);
+ self = *self_p;
+ len = TYPE_NFIELDS (self);
+
+ for (i = TYPE_N_BASECLASSES (self); i < len; i++)
+ {
+ LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
+
QUIT;
- if (val == bitpos)
- break;
- if (val < bitpos && i != 0)
+ if (offset == bitpos)
{
- /* Somehow pointing into a field. */
- i -= 1;
- extra = (val - TYPE_FIELD_BITPOS (domain, i));
- if (extra & 0x7)
- bits = 1;
- else
- extra >>= 3;
- break;
+ *fieldno = i;
+ return;
}
}
- if (i < len)
+
+ for (i = 0; i < TYPE_N_BASECLASSES (self); i++)
{
- char *name;
- fprintf_filtered (stream, prefix);
- name = type_name_no_tag (domain);
+ LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
+ LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (self, i));
+
+ if (offset >= bitpos && offset < bitpos + bitsize)
+ {
+ *self_p = TYPE_FIELD_TYPE (self, i);
+ cp_find_class_member (self_p, fieldno, offset - bitpos);
+ return;
+ }
+ }
+
+ *self_p = NULL;
+}
+
+void
+cp_print_class_member (const gdb_byte *valaddr, struct type *type,
+ struct ui_file *stream, const char *prefix)
+{
+ enum bfd_endian byte_order = type_byte_order (type);
+
+ /* VAL is a byte offset into the structure type SELF_TYPE.
+ Find the name of the field for that offset and
+ print it. */
+ struct type *self_type = TYPE_SELF_TYPE (type);
+ LONGEST val;
+ int fieldno;
+
+ val = extract_signed_integer (valaddr,
+ TYPE_LENGTH (type),
+ byte_order);
+
+ /* 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. */
+
+ if (val == -1)
+ {
+ fprintf_filtered (stream, "NULL");
+ return;
+ }
+
+ cp_find_class_member (&self_type, &fieldno, val << 3);
+
+ if (self_type != NULL)
+ {
+ const char *name;
+
+ fputs_filtered (prefix, stream);
+ name = TYPE_NAME (self_type);
if (name)
- fputs_filtered (name, stream);
+ fputs_filtered (name, stream);
else
- c_type_print_base (domain, stream, 0, 0);
+ c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
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_styled (TYPE_FIELD_NAME (self_type, fieldno),
+ variable_name_style.style (), stream);
}
else
- fprintf_filtered (stream, "%d", val >> 3);
+ fprintf_filtered (stream, "%ld", (long) val);
}
+
+void _initialize_cp_valprint ();
void
_initialize_cp_valprint ()
{
- 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);
-
- /* Give people the defaults which they are used to. */
- objectprint = 0;
- vtblprint = 0;
- obstack_begin (&dont_print_obstack, 32 * sizeof (struct type *));
+ obstack_begin (&dont_print_stat_array_obstack,
+ 32 * sizeof (struct type *));
+ obstack_begin (&dont_print_statmem_obstack,
+ 32 * sizeof (CORE_ADDR));
+ obstack_begin (&dont_print_vb_obstack,
+ 32 * sizeof (struct type *));
}
projects / deliverable / binutils-gdb.git / blobdiff