mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-12-27 04:52:05 +08:00
Code Issues Packages Projects Releases Wiki Activity
96fe45624e
binutils-gdb/gdb/cp-abi.h
Pedro Alves 2f408ecb92 Use ui_file_as_string throughout more 
This replaces most of the remaining ui_file_xstrdup calls with
ui_file_as_string calls.  Whenever a call was replaced, that led to a
cascade of other necessary adjustments throughout, to make the code
use std::string instead of raw pointers.  And then whenever I added a
std::string as member of a struct, I needed to adjust
allocation/destruction of said struct to use new/delete instead of
xmalloc/xfree.

The stopping point was once gdb built again.  These doesn't seem to be
a way to reasonably split this out further.

Maybe-not-obvious changes:

 - demangle_for_lookup returns a cleanup today.  To get rid of that,
   and avoid unnecessary string dupping/copying, this introduces a
   demangle_result_storage type that the caller instantiates and
   passes to demangle_for_lookup.

 - Many methods returned a "char *" to indicate that the caller owns
   the memory and must free it.  Those are switched to return a
   std::string instead.  Methods that return a "view" into some
   internal string return a "const char *" instead.  I.e., we only
   copy/allocate when necessary.

gdb/ChangeLog:
2016-11-08  Pedro Alves  <palves@redhat.com>

	* ada-lang.c (ada_name_for_lookup, type_as_string): Use and return
	std::string.
	(type_as_string_and_cleanup): Delete.
	(ada_lookup_struct_elt_type): Use type_as_string.
	* ada-lang.h (ada_name_for_lookup): Now returns std::string.
	* ada-varobj.c (ada_varobj_scalar_image): Return a std::string.
	(ada_varobj_describe_child): Make 'child_name' and
	'child_path_expr' parameters std::string pointers.
	(ada_varobj_describe_struct_child, ada_varobj_describe_ptr_child):
	Likewise, and use string_printf.
	(ada_varobj_describe_simple_array_child)
	(ada_varobj_describe_child): Likewise.
	(ada_varobj_get_name_of_child, ada_varobj_get_path_expr_of_child)
	(ada_varobj_get_value_image)
	(ada_varobj_get_value_of_array_variable)
	(ada_varobj_get_value_of_variable, ada_name_of_variable)
	(ada_name_of_child, ada_path_expr_of_child)
	(ada_value_of_variable): Now returns std::string.  Use
	string_printf.
	(ada_value_of_child): Adjust.
	* break-catch-throw.c (check_status_exception_catchpoint): Adjust
	to use std::string.
	* breakpoint.c (watch_command_1): Adjust to use std::string.
	* c-lang.c (c_get_string): Adjust to use std::string.
	* c-typeprint.c (print_name_maybe_canonical): Use std::string.
	* c-varobj.c (varobj_is_anonymous_child): Use ==/!= std::string
	operators.
	(c_name_of_variable): Now returns a std::string.
	(c_describe_child): The 'cname' and 'cfull_expression' output
	parameters are now std::string pointers.  Adjust.
	(c_name_of_child, c_path_expr_of_child, c_value_of_variable)
	(cplus_number_of_children): Adjust to use std::string and
	string_printf.
	(cplus_name_of_variable): Now returns a std::string.
	(cplus_describe_child): The 'cname' and 'cfull_expression' output
	parameters are now std::string pointers.  Adjust.
	(cplus_name_of_child, cplus_path_expr_of_child)
	(cplus_value_of_variable): Now returns a std::string.
	* cp-abi.c (cplus_typename_from_type_info): Return std::string.
	* cp-abi.h (cplus_typename_from_type_info): Return std::string.
	(struct cp_abi_ops) <get_typename_from_type_info>: Return
	std::string.
	* cp-support.c (inspect_type): Use std::string.
	(cp_canonicalize_string_full, cp_canonicalize_string_no_typedefs)
	(cp_canonicalize_string): Return std::string and adjust.
	* cp-support.h (cp_canonicalize_string)
	(cp_canonicalize_string_no_typedefs, cp_canonicalize_string_full):
	Return std::string.
	* dbxread.c (read_dbx_symtab): Use std::string.
	* dwarf2read.c (dwarf2_canonicalize_name): Adjust to use std::string.
	* gdbcmd.h (lookup_struct_elt_type): Adjust to use std::string.
	* gnu-v3-abi.c (gnuv3_get_typeid): Use std::string.
	(gnuv3_get_typename_from_type_info): Return a std::string and
	adjust.
	(gnuv3_get_type_from_type_info): Adjust to use std::string.
	* guile/guile.c (gdbscm_execute_gdb_command): Adjust to use
	std::string.
	* infcmd.c (print_return_value_1): Adjust to use std::string.
	* linespec.c (find_linespec_symbols): Adjust to
	demangle_for_lookup API change.  Use std::string.
	* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_set_format)
	(mi_cmd_var_info_type, mi_cmd_var_info_path_expression)
	(mi_cmd_var_info_expression, mi_cmd_var_evaluate_expression)
	(mi_cmd_var_assign, varobj_update_one): Adjust to use std::string.
	* minsyms.c (lookup_minimal_symbol): Use std::string.
	* python/py-varobj.c (py_varobj_iter_next): Use new instead of
	XNEW.  vitem->name is a std::string now, adjust.
	* rust-exp.y (convert_ast_to_type, convert_name): Adjust to use
	std::string.
	* stabsread.c (define_symbol): Adjust to use std::string.
	* symtab.c (demangle_for_lookup): Now returns 'const char *'.  Add
	a demangle_result_storage parameter.  Use it for storage.
	(lookup_symbol_in_language)
	(lookup_symbol_in_objfile_from_linkage_name): Adjust to new
	demangle_for_lookup API.
	* symtab.h (struct demangle_result_storage): New type.
	(demangle_for_lookup): Now returns 'const char *'.  Add a
	demangle_result_storage parameter.
	* typeprint.c (type_to_string): Return std::string and use
	ui_file_as_string.
	* value.h (type_to_string): Change return type to std::string.
	* varobj-iter.h (struct varobj_item) <name>: Now a std::string.
	(varobj_iter_delete): Use delete instead of xfree.
	* varobj.c (create_child): Return std::string instead of char * in
	output parameter.
	(name_of_variable, name_of_child, my_value_of_variable): Return
	std::string instead of char *.
	(varobj_create, varobj_get_handle): Constify 'objname' parameter.
	Adjust to std::string fields.
	(varobj_get_objname): Return a const char * instead of a char *.
	(varobj_get_expression): Return a std::string.
	(varobj_list_children): Adjust to use std::string.
	(varobj_get_type): Return a std::string.
	(varobj_get_path_expr): Return a const char * instead of a char *.
	Adjust to std::string fields.
	(varobj_get_formatted_value, varobj_get_value): Return a
	std::string.
	(varobj_set_value): Change type of 'expression' parameter to
	std::string.  Use std::string.
	(install_new_value): Use std::string.
	(delete_variable_1): Adjust to use std::string.
	(create_child): Change the 'name' parameter to a std::string
	reference.  Swap it into the new item's name.
	(create_child_with_value): Swap item's name into the new child's
	name.  Use string_printf.
	(new_variable): Use new instead of XNEW.
	(free_variable): Don't xfree fields that are now std::string.
	(name_of_variable, name_of_child): Now returns std::string.
	(value_of_root): Adjust to use std::string.
	(my_value_of_variable, varobj_value_get_print_value): Return
	and use std::string.
	(varobj_value_get_print_value): Adjust to use ui_file_as_string
	and std::string.
	* varobj.h (struct varobj) <name, path_expr, obj_name,
	print_value>: Now std::string's.
	<name_of_variable, name_of_child, path_expr_of_child,
	value_of_variable>: Return std::string.
	(varobj_create, varobj_get_handle): Constify 'objname' parameter.
	(varobj_get_objname): Return a const char * instead of a char *.
	(varobj_get_expression, varobj_get_type): Return a std::string.
	(varobj_get_path_expr): Return a const char * instead of a char *.
	(varobj_get_formatted_value, varobj_get_value): Return a
	std::string.
	(varobj_set_value): Constify 'expression' parameter.
	(varobj_value_get_print_value): Return a std::string.
2016-11-08 15:26:47 +00:00

258 lines
9.5 KiB
C++
Raw Blame History

/* Abstraction of various C++ ABI's we support, and the info we need
to get from them.
Contributed by Daniel Berlin <dberlin@redhat.com>
Copyright (C) 2001-2016 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/>. */
#ifndef CP_ABI_H_
#define CP_ABI_H_ 1
struct fn_field;
struct type;
struct value;
struct ui_file;
struct frame_info;
/* The functions here that attempt to determine what sort of thing a
mangled name refers to may well be revised in the future. It would
certainly be cleaner to carry this information explicitly in GDB's
data structures than to derive it from the mangled name. */
/* Kinds of constructors. All these values are guaranteed to be
non-zero. */
enum ctor_kinds {
/* Initialize a complete object, including virtual bases, using
memory provided by caller. */
complete_object_ctor = 1,
/* Initialize a base object of some larger object. */
base_object_ctor,
/* An allocating complete-object constructor. */
complete_object_allocating_ctor
};
/* Return non-zero iff NAME is the mangled name of a constructor.
Actually, return an `enum ctor_kind' value describing what *kind*
of constructor it is. */
extern enum ctor_kinds is_constructor_name (const char *name);
/* Kinds of destructors. All these values are guaranteed to be
non-zero. */
enum dtor_kinds {
/* A destructor which finalizes the entire object, and then calls
`delete' on its storage. */
deleting_dtor = 1,
/* A destructor which finalizes the entire object, but does not call
`delete'. */
complete_object_dtor,
/* A destructor which finalizes a subobject of some larger
object. */
base_object_dtor
};
/* Return non-zero iff NAME is the mangled name of a destructor.
Actually, return an `enum dtor_kind' value describing what *kind*
of destructor it is. */
extern enum dtor_kinds is_destructor_name (const char *name);
/* Return non-zero iff NAME is the mangled name of a vtable. */
extern int is_vtable_name (const char *name);
/* Return non-zero iff NAME is the un-mangled name of an operator,
perhaps scoped within some class. */
extern int is_operator_name (const char *name);
/* Return an object's virtual function as a value.
VALUEP is a pointer to a pointer to a value, holding the object
whose virtual function we want to invoke. If the ABI requires a
virtual function's caller to adjust the `this' pointer by an amount
retrieved from the vtable before invoking the function (i.e., we're
not using "vtable thunks" to do the adjustment automatically), then
this function may set *VALUEP to point to a new object with an
appropriately tweaked address.
The J'th element of the overload set F is the virtual function of
*VALUEP we want to invoke.
TYPE is the base type of *VALUEP whose method we're invoking ---
this is the type containing F. OFFSET is the offset of that base
type within *VALUEP. */
extern struct value *value_virtual_fn_field (struct value **valuep,
struct fn_field *f,
int j,
struct type *type,
int offset);
/* Try to find the run-time type of VALUE, using C++ run-time type
information. Return the run-time type, or zero if we can't figure
it out.
If we do find the run-time type:
- Set *FULL to non-zero if VALUE already contains the complete
run-time object, not just some embedded base class of the object.
- Set *TOP and *USING_ENC to indicate where the enclosing object
starts relative to VALUE:
- If *USING_ENC is zero, then *TOP is the offset from the start
of the complete object to the start of the embedded subobject
VALUE represents. In other words, the enclosing object starts
at VALUE_ADDR (VALUE) + VALUE_OFFSET (VALUE) +
value_embedded_offset (VALUE) + *TOP
- If *USING_ENC is non-zero, then *TOP is the offset from the
address of the complete object to the enclosing object stored
in VALUE. In other words, the enclosing object starts at
VALUE_ADDR (VALUE) + VALUE_OFFSET (VALUE) + *TOP.
If VALUE's type and enclosing type are the same, then these two
cases are equivalent.
FULL, TOP, and USING_ENC can each be zero, in which case we don't
provide the corresponding piece of information. */
extern struct type *value_rtti_type (struct value *value,
int *full, LONGEST *top,
int *using_enc);
/* Compute the offset of the baseclass which is the INDEXth baseclass
of class TYPE, for value at VALADDR (in host) at ADDRESS (in
target), offset by EMBEDDED_OFFSET. VALADDR points to the raw
contents of VAL. The result is the offset of the baseclass value
relative to (the address of)(ARG) + OFFSET. */
extern int baseclass_offset (struct type *type,
int index, const gdb_byte *valaddr,
LONGEST embedded_offset,
CORE_ADDR address,
const struct value *val);
/* Describe the target of a pointer to method. CONTENTS is the byte
pattern representing the pointer to method. TYPE is the pointer to
method type. STREAM is the stream to print it to. */
void cplus_print_method_ptr (const gdb_byte *contents,
struct type *type,
struct ui_file *stream);
/* Return the size of a pointer to member function of type
TO_TYPE. */
int cplus_method_ptr_size (struct type *to_type);
/* Return the method which should be called by applying METHOD_PTR to
*THIS_P, and adjust *THIS_P if necessary. */
struct value *cplus_method_ptr_to_value (struct value **this_p,
struct value *method_ptr);
/* Create the byte pattern in CONTENTS representing a pointer of type
TYPE to member function at ADDRESS (if IS_VIRTUAL is 0) or with
virtual table offset ADDRESS (if IS_VIRTUAL is 1). This is the
opposite of cplus_method_ptr_to_value. */
void cplus_make_method_ptr (struct type *type, gdb_byte *CONTENTS,
CORE_ADDR address, int is_virtual);
/* Print the vtable for VALUE, if there is one. If there is no
vtable, print a message, but do not throw. */
void cplus_print_vtable (struct value *value);
/* Implement 'typeid': find the type info for VALUE, if possible. If
the type info cannot be found, throw an exception. */
extern struct value *cplus_typeid (struct value *value);
/* Return the type of 'typeid' for the current C++ ABI on the given
architecture. */
extern struct type *cplus_typeid_type (struct gdbarch *gdbarch);
/* Given a value which holds a pointer to a std::type_info, return the
type which that type_info represents. Throw an exception if the
type cannot be found. */
extern struct type *cplus_type_from_type_info (struct value *value);
/* Given a value which holds a pointer to a std::type_info, return the
name of the type which that type_info represents. Throw an
exception if the type name cannot be found. */
extern std::string cplus_typename_from_type_info (struct value *value);
/* Determine if we are currently in a C++ thunk. If so, get the
address of the routine we are thunking to and continue to there
instead. */
CORE_ADDR cplus_skip_trampoline (struct frame_info *frame,
CORE_ADDR stop_pc);
/* Return non-zero if an argument of type TYPE should be passed by
reference instead of value. */
extern int cp_pass_by_reference (struct type *type);
struct cp_abi_ops
{
const char *shortname;
const char *longname;
const char *doc;
/* ABI-specific implementations for the functions declared
above. */
enum ctor_kinds (*is_constructor_name) (const char *name);
enum dtor_kinds (*is_destructor_name) (const char *name);
int (*is_vtable_name) (const char *name);
int (*is_operator_name) (const char *name);
struct value *(*virtual_fn_field) (struct value **arg1p,
struct fn_field * f,
int j, struct type * type,
int offset);
struct type *(*rtti_type) (struct value *v, int *full,
LONGEST *top, int *using_enc);
int (*baseclass_offset) (struct type *type, int index,
const bfd_byte *valaddr, LONGEST embedded_offset,
CORE_ADDR address, const struct value *val);
void (*print_method_ptr) (const gdb_byte *contents,
struct type *type,
struct ui_file *stream);
int (*method_ptr_size) (struct type *);
void (*make_method_ptr) (struct type *, gdb_byte *,
CORE_ADDR, int);
struct value * (*method_ptr_to_value) (struct value **,
struct value *);
void (*print_vtable) (struct value *);
struct value *(*get_typeid) (struct value *value);
struct type *(*get_typeid_type) (struct gdbarch *gdbarch);
struct type *(*get_type_from_type_info) (struct value *value);
std::string (*get_typename_from_type_info) (struct value *value);
CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
int (*pass_by_reference) (struct type *type);
};
extern int register_cp_abi (struct cp_abi_ops *abi);
extern void set_cp_abi_as_auto_default (const char *short_name);
#endif
Reference in New Issue View Git Blame Copy Permalink