mirror of
https://github.com/Zenithsiz/ftmemsim-valgrind.git
synced 2026-02-03 10:05:29 +00:00
665280aeaf
This patch changes the interface and behaviour of VG_(demangle) and VG_(maybe_Z_demangle). Instead of copying the demangled name into a fixed sized buffer that is passed in from the caller (HChar *buf, Int n_buf), the demangling functions will now return a pointer to the full-length demangled name (HChar **result). It is the caller's responsiblilty to make a copy if needed. This change in function parameters ripples upward - first: to get_sym_name - then to the convenience wrappers - VG_(get_fnname) - VG_(get_fnname_w_offset) - VG_(get_fnname_if_entry) - VG_(get_fnname_raw) - VG_(get_fnname_no_cxx_demangle) - VG_(get_datasym_and_offset) The changes in foComplete then forces the arguments of - VG_(get_objname) to be changed as well There are some issues regarding the ownership and persistence of character strings to consider. In general, the returned character string is owned by "somebody else" which means the caller must not free it. Also, the caller must not modify the returned string as it possibly points to read only memory. Additionally, the returned string is not necessarily persistent. Here are the scenarios: - the returned string is a demangled function name in which case the memory holding the string will be freed when the demangler is called again. - the returned string hangs off of a DebugInfo structure in which case it will be freed when the DebugInfo is discarded - the returned string hangs off of a segment in the address space manager in which case it may be overwritten when the segment is merged with another segment So the rule of thunb here is: if in doubt strdup the string. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@14664
225 lines
9.1 KiB
C
225 lines
9.1 KiB
C
|
|
/*--------------------------------------------------------------------*/
|
|
/*--- Debug info. pub_core_debuginfo.h ---*/
|
|
/*--------------------------------------------------------------------*/
|
|
|
|
/*
|
|
This file is part of Valgrind, a dynamic binary instrumentation
|
|
framework.
|
|
|
|
Copyright (C) 2000-2013 Julian Seward
|
|
jseward@acm.org
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the
|
|
License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
02111-1307, USA.
|
|
|
|
The GNU General Public License is contained in the file COPYING.
|
|
*/
|
|
|
|
#ifndef __PUB_CORE_DEBUGINFO_H
|
|
#define __PUB_CORE_DEBUGINFO_H
|
|
|
|
//--------------------------------------------------------------------
|
|
// PURPOSE: This module deals with reading debug info and symbol tables
|
|
// to get file and function names, line numbers, variable types, and
|
|
// to help stack unwinding.
|
|
//--------------------------------------------------------------------
|
|
|
|
#include "pub_tool_debuginfo.h"
|
|
|
|
/* Initialise the entire module. Must be called first of all. */
|
|
extern void VG_(di_initialise) ( void );
|
|
|
|
/* LINUX: Notify the debuginfo system about a new mapping, or the
|
|
disappearance of such, or a permissions change on an existing
|
|
mapping. This is the way new debug information gets loaded. If
|
|
allow_SkFileV is True, it will try load debug info if the mapping
|
|
at 'a' belongs to Valgrind; whereas normally (False) it will not do
|
|
that. This allows us to carefully control when the thing will read
|
|
symbols from the Valgrind executable itself.
|
|
|
|
If a call to VG_(di_notify_mmap) causes debug info to be read, then
|
|
the returned ULong is an abstract handle which can later be used to
|
|
refer to the debuginfo read as a result of this specific mapping,
|
|
in later queries to m_debuginfo. In this case the handle value
|
|
will be one or above. If the returned value is zero, no debug info
|
|
was read.
|
|
|
|
For VG_(di_notify_mmap), if use_fd is not -1, that is used instead
|
|
of the filename; this avoids perturbing fcntl locks, which are
|
|
released by simply re-opening and closing the same file (even via
|
|
different fd!).
|
|
*/
|
|
#if defined(VGO_linux) || defined(VGO_darwin)
|
|
extern ULong VG_(di_notify_mmap)( Addr a, Bool allow_SkFileV, Int use_fd );
|
|
|
|
extern void VG_(di_notify_munmap)( Addr a, SizeT len );
|
|
|
|
extern void VG_(di_notify_mprotect)( Addr a, SizeT len, UInt prot );
|
|
|
|
/* this should really return ULong, as per VG_(di_notify_mmap). */
|
|
extern void VG_(di_notify_pdb_debuginfo)( Int fd, Addr avma,
|
|
SizeT total_size,
|
|
PtrdiffT bias );
|
|
|
|
/* this should also really return ULong */
|
|
extern void VG_(di_notify_vm_protect)( Addr a, SizeT len, UInt prot );
|
|
#endif
|
|
|
|
extern void VG_(di_discard_ALL_debuginfo)( void );
|
|
|
|
/* Like VG_(get_fnname), but it does not do C++ demangling nor Z-demangling
|
|
* nor below-main renaming.
|
|
* It should not be used for any names that will be shown to users.
|
|
* It should only be used in cases where the names of interest will have
|
|
* particular (ie. non-mangled) forms, or the mangled form is acceptable. */
|
|
extern
|
|
Bool VG_(get_fnname_raw) ( Addr a, const HChar** buf );
|
|
|
|
/* Like VG_(get_fnname), but without C++ demangling. (But it does
|
|
Z-demangling and below-main renaming.)
|
|
iipc argument: same usage as in VG_(describe_IP) in pub_tool_debuginfo.h. */
|
|
extern
|
|
Bool VG_(get_fnname_no_cxx_demangle) ( Addr a, const HChar** buf,
|
|
const InlIPCursor* iipc );
|
|
|
|
/* mips-linux only: find the offset of current address. This is needed for
|
|
stack unwinding for MIPS.
|
|
*/
|
|
extern
|
|
Bool VG_(get_inst_offset_in_function)( Addr a, /*OUT*/PtrdiffT* offset );
|
|
|
|
|
|
/* Use DWARF2/3 CFA information to do one step of stack unwinding.
|
|
D3UnwindRegs holds the current register values, and is
|
|
arch-specific. Note that the x86 and amd64 definitions are shared
|
|
and so the regs are named 'xip' etc rather than 'eip' and 'rip'. */
|
|
#if defined(VGA_amd64) || defined(VGA_x86)
|
|
typedef
|
|
struct { Addr xip; Addr xsp; Addr xbp; }
|
|
D3UnwindRegs;
|
|
#elif defined(VGA_arm)
|
|
typedef
|
|
struct { Addr r15; Addr r14; Addr r13; Addr r12; Addr r11; Addr r7; }
|
|
D3UnwindRegs;
|
|
#elif defined(VGA_arm64)
|
|
typedef
|
|
struct { Addr pc; Addr sp; Addr x30; Addr x29; } /* PC, SP, LR, FP */
|
|
D3UnwindRegs;
|
|
#elif defined(VGA_ppc32) || defined(VGA_ppc64be) || defined(VGA_ppc64le)
|
|
typedef
|
|
UChar /* should be void, but gcc complains at use points */
|
|
D3UnwindRegs;
|
|
#elif defined(VGA_s390x)
|
|
typedef
|
|
struct { Addr ia; Addr sp; Addr fp; Addr lr;}
|
|
D3UnwindRegs;
|
|
#elif defined(VGA_mips32) || defined(VGA_mips64)
|
|
typedef
|
|
struct { Addr pc; Addr sp; Addr fp; Addr ra; }
|
|
D3UnwindRegs;
|
|
#else
|
|
# error "Unsupported arch"
|
|
#endif
|
|
|
|
extern Bool VG_(use_CF_info) ( /*MOD*/D3UnwindRegs* uregs,
|
|
Addr min_accessible,
|
|
Addr max_accessible );
|
|
|
|
/* returns the "generation" of the CF info.
|
|
Each time some debuginfo is changed (e.g. loaded or unloaded),
|
|
the VG_(CF_info_generation) value returned will be increased.
|
|
This can be used to flush cached information derived from the CF info. */
|
|
extern UInt VG_(CF_info_generation) (void);
|
|
|
|
|
|
|
|
/* Use MSVC FPO data to do one step of stack unwinding. */
|
|
extern Bool VG_(use_FPO_info) ( /*MOD*/Addr* ipP,
|
|
/*MOD*/Addr* spP,
|
|
/*MOD*/Addr* fpP,
|
|
Addr min_accessible,
|
|
Addr max_accessible );
|
|
|
|
/* AVMAs for a symbol. Usually only the lowest address of the entity.
|
|
On ppc64 platforms, also contains tocptr and local_ep.
|
|
These fields should only be accessed using the macros
|
|
GET_TOCPTR_AVMA/SET_TOCPTR_AVMA/GET_LOCAL_EP_AVMA/SET_LOCAL_EP_AVMA. */
|
|
typedef
|
|
struct {
|
|
Addr main; /* lowest address of entity */
|
|
# if defined(VGA_ppc64be) || defined(VGA_ppc64le)
|
|
Addr tocptr; /* ppc64be/le-linux only: value that R2 should have */
|
|
# endif
|
|
# if defined(VGA_ppc64le)
|
|
Addr local_ep; /* address for local entry point, ppc64le only */
|
|
# endif
|
|
}
|
|
SymAVMAs;
|
|
|
|
#if defined(VGA_ppc64be) || defined(VGA_ppc64le)
|
|
# define GET_TOCPTR_AVMA(_sym_avmas) (_sym_avmas).tocptr
|
|
# define SET_TOCPTR_AVMA(_sym_avmas, _val) (_sym_avmas).tocptr = (_val)
|
|
#else
|
|
# define GET_TOCPTR_AVMA(_sym_avmas) ((Addr)0)
|
|
# define SET_TOCPTR_AVMA(_sym_avmas, _val) /* */
|
|
#endif
|
|
|
|
#if defined(VGA_ppc64le)
|
|
# define GET_LOCAL_EP_AVMA(_sym_avmas) (_sym_avmas).local_ep
|
|
# define SET_LOCAL_EP_AVMA(_sym_avmas, _val) (_sym_avmas).local_ep = (_val)
|
|
#else
|
|
# define GET_LOCAL_EP_AVMA(_sym_avmas) ((Addr)0)
|
|
# define SET_LOCAL_EP_AVMA(_sym_avmas, _val) /* */
|
|
#endif
|
|
|
|
/* Functions for traversing all the symbols in a DebugInfo. _howmany
|
|
tells how many symbol table entries there are. _getidx retrieves
|
|
the n'th entry, for n in 0 .. _howmany-1. You may not modify the
|
|
function names thereby acquired; if you want to do so, first strdup
|
|
them. The primary name is returned in *pri_name, and *sec_names is
|
|
set either to NULL or to a NULL terminated vector containing
|
|
pointers to the secondary names. */
|
|
Int VG_(DebugInfo_syms_howmany) ( const DebugInfo *di );
|
|
void VG_(DebugInfo_syms_getidx) ( const DebugInfo *di,
|
|
Int idx,
|
|
/*OUT*/SymAVMAs* ad,
|
|
/*OUT*/UInt* size,
|
|
/*OUT*/const HChar** pri_name,
|
|
/*OUT*/const HChar*** sec_names,
|
|
/*OUT*/Bool* isText,
|
|
/*OUT*/Bool* isIFunc );
|
|
/* ppc64-linux only: find the TOC pointer (R2 value) that should be in
|
|
force at the entry point address of the function containing
|
|
guest_code_addr. Returns 0 if not known. */
|
|
extern Addr VG_(get_tocptr) ( Addr guest_code_addr );
|
|
|
|
/* Map a function name to its SymAVMAs. Is done by
|
|
sequential search of all symbol tables, so is very slow. To
|
|
mitigate the worst performance effects, you may specify a soname
|
|
pattern, and only objects matching that pattern are searched.
|
|
Therefore specify "*" to search all the objects. On TOC-afflicted
|
|
platforms, a symbol is deemed to be found only if it has a nonzero
|
|
TOC pointer. */
|
|
extern
|
|
Bool VG_(lookup_symbol_SLOW)(const HChar* sopatt, const HChar* name,
|
|
SymAVMAs* avmas);
|
|
|
|
#endif // __PUB_CORE_DEBUGINFO_H
|
|
|
|
/*--------------------------------------------------------------------*/
|
|
/*--- end ---*/
|
|
/*--------------------------------------------------------------------*/
|