mirror of
https://github.com/Zenithsiz/ftmemsim-valgrind.git
synced 2026-02-03 10:05:29 +00:00
Comment changes only: s/skin/tool/
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@2555
This commit is contained in:
Nicholas Nethercote
parent
7bdbf7377f
commit
38ff4e69d1
@ -1126,9 +1126,9 @@ Bool ac_is_valid_address ( Addr a )
|
||||
}
|
||||
|
||||
|
||||
/* Leak detector for this skin. We don't actually do anything, merely
|
||||
/* Leak detector for this tool. We don't actually do anything, merely
|
||||
run the generic leak detector with suitable parameters for this
|
||||
skin. */
|
||||
tool. */
|
||||
static void ac_detect_memory_leaks ( void )
|
||||
{
|
||||
MAC_(do_detect_memory_leaks) ( ac_is_valid_64k_chunk, ac_is_valid_address );
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
# Lines starting with : set the prefix
|
||||
|
||||
## These are the parameterised functions in the core. The default definitions
|
||||
## are overridden by LD_PRELOADed skin version. At the very least, a skin
|
||||
## are overridden by LD_PRELOADed tool version. At the very least, a tool
|
||||
## must define the fundamental template functions. Depending on what needs
|
||||
## are set, extra template functions will be used too. Functions are
|
||||
## grouped under the needs that govern their use.
|
||||
@ -108,10 +108,10 @@ void, discard_basic_block_info, Addr a, UInt size
|
||||
## record the option as well.
|
||||
Bool, process_cmd_line_option, Char* argv
|
||||
|
||||
## Print out command line usage for options for normal skin operation.
|
||||
## Print out command line usage for options for normal tool operation.
|
||||
void, print_usage
|
||||
|
||||
## Print out command line usage for options for debugging the skin.
|
||||
## Print out command line usage for options for debugging the tool.
|
||||
void, print_debug_usage
|
||||
|
||||
## ------------------------------------------------------------------
|
||||
@ -123,7 +123,7 @@ void, print_debug_usage
|
||||
## requests should follow.
|
||||
|
||||
## This function should use the VG_IS_SKIN_USERREQ macro (in
|
||||
## include/valgrind.h) to first check if it's a request for this skin. Then
|
||||
## include/valgrind.h) to first check if it's a request for this tool. Then
|
||||
## should handle it if it's recognised (and return True), or return False if
|
||||
## not recognised. arg_block[0] holds the request number, any further args
|
||||
## from the request are in arg_block[1..]. 'ret' is for the return value...
|
||||
@ -155,7 +155,7 @@ void, post_syscall, ThreadId tid, UInt syscallno, void* pre_result, Int res, Boo
|
||||
## ---------------------------------------------------------------------
|
||||
## VG_(needs).sanity_checks
|
||||
|
||||
## Can be useful for ensuring a skin's correctness. SK_(cheap_sanity_check)
|
||||
## Can be useful for ensuring a tool's correctness. SK_(cheap_sanity_check)
|
||||
## is called very frequently; SK_(expensive_sanity_check) is called less
|
||||
## frequently and can be more involved.
|
||||
Bool, cheap_sanity_check
|
||||
@ -176,7 +176,7 @@ Bool, expensive_sanity_check
|
||||
## VG_(get_current_or_recent_tid)() might not give the right ThreadId in
|
||||
## that case.
|
||||
|
||||
## Memory events (Nb: to track heap allocation/freeing, a skin must replace
|
||||
## Memory events (Nb: to track heap allocation/freeing, a tool must replace
|
||||
## malloc() et al. See above how to do this.)
|
||||
|
||||
## These ones occur at startup, upon some signals, and upon some syscalls
|
||||
@ -191,7 +191,7 @@ void, die_mem_stack_signal, Addr a, UInt len
|
||||
void, die_mem_brk, Addr a, UInt len
|
||||
void, die_mem_munmap, Addr a, UInt len
|
||||
|
||||
## These ones are called when %esp changes. A skin could track these itself
|
||||
## These ones are called when %esp changes. A tool could track these itself
|
||||
## (except for ban_mem_stack) but it's much easier to use the core's help.
|
||||
|
||||
## The specialised ones are called in preference to the general one, if they
|
||||
@ -241,7 +241,7 @@ void, post_reg_write_syscall_return, ThreadId tid, UInt reg
|
||||
void, post_reg_write_deliver_signal, ThreadId tid, UInt reg
|
||||
void, post_reg_write_pthread_return, ThreadId tid, UInt reg
|
||||
void, post_reg_write_clientreq_return, ThreadId tid, UInt reg
|
||||
## This one is called for malloc() et al if they are replaced by a skin.
|
||||
## This one is called for malloc() et al if they are replaced by a tool.
|
||||
void, post_reg_write_clientcall_return, ThreadId tid, UInt reg, Addr f
|
||||
|
||||
|
||||
|
||||
@ -56,7 +56,7 @@ static Supp* is_suppressible_error ( Error* err );
|
||||
/*--- Error type ---*/
|
||||
/*------------------------------------------------------------*/
|
||||
|
||||
/* Note: it is imperative this doesn't overlap with (0..) at all, as skins
|
||||
/* Note: it is imperative this doesn't overlap with (0..) at all, as tools
|
||||
* effectively extend it by defining their own enums in the (0..) range. */
|
||||
typedef
|
||||
enum {
|
||||
@ -319,7 +319,7 @@ void construct_error ( Error* err, ThreadId tid, ErrorKind ekind, Addr a,
|
||||
else
|
||||
err->where = where;
|
||||
|
||||
/* Skin-relevant parts */
|
||||
/* Tool-relevant parts */
|
||||
err->ekind = ekind;
|
||||
err->addr = a;
|
||||
err->extra = extra;
|
||||
|
||||
@ -2342,7 +2342,7 @@ void VG_(emit_AMD_prefetch_reg) ( Int reg )
|
||||
/*--- Helper offset -> addr translation ---*/
|
||||
/*----------------------------------------------------*/
|
||||
|
||||
/* Finds the baseBlock offset of a skin-specified helper.
|
||||
/* Finds the baseBlock offset of a tool-specified helper.
|
||||
* Searches through compacts first, then non-compacts. */
|
||||
Int VG_(helper_offset)(Addr a)
|
||||
{
|
||||
|
||||
@ -43,8 +43,8 @@
|
||||
|
||||
#include "vg_constants.h"
|
||||
|
||||
/* All stuff visible to core and skins goes in vg_skin.h. Things
|
||||
* visible to core but not visible to any skins should go in this
|
||||
/* All stuff visible to core and tools goes in vg_skin.h. Things
|
||||
* visible to core but not visible to any tools should go in this
|
||||
* file, vg_include.h. */
|
||||
#include "vg_skin.h"
|
||||
#include "valgrind.h"
|
||||
@ -252,7 +252,7 @@ extern Bool VG_(clo_track_fds);
|
||||
/* Should we run __libc_freeres at exit? Sometimes causes crashes.
|
||||
Default: YES. Note this is subservient to VG_(needs).libc_freeres;
|
||||
if the latter says False, then the setting of VG_(clo_weird_hacks)
|
||||
is ignored. Ie if a skin says no, I don't want this to run, that
|
||||
is ignored. Ie if a tool says no, I don't want this to run, that
|
||||
cannot be overridden from the command line. */
|
||||
extern Bool VG_(clo_run_libc_freeres);
|
||||
/* Use the basic-block chaining optimisation? Default: YES */
|
||||
@ -281,10 +281,10 @@ extern void VGP_(done_profiling) ( void );
|
||||
#define VGP_POPCC(x) if (VG_(clo_profile)) VGP_(popcc)(x)
|
||||
|
||||
/* ---------------------------------------------------------------------
|
||||
Skin-related types
|
||||
Tool-related types
|
||||
------------------------------------------------------------------ */
|
||||
/* These structs are not exposed to skins to mitigate possibility of
|
||||
binary-incompatibilities when the core/skin interface changes. Instead,
|
||||
/* These structs are not exposed to tools to mitigate possibility of
|
||||
binary-incompatibilities when the core/tool interface changes. Instead,
|
||||
set functions are provided (see include/vg_skin.h). */
|
||||
typedef
|
||||
struct {
|
||||
@ -345,8 +345,8 @@ void VG_(sanity_check_needs)(void);
|
||||
TOOL for the tool to use (and the only one it uses).
|
||||
SYMTAB for Valgrind's symbol table storage.
|
||||
JITTER for small storage during translation.
|
||||
CLIENT for the client's mallocs/frees, if the skin replaces glibc's
|
||||
malloc() et al -- redzone size is chosen by the skin.
|
||||
CLIENT for the client's mallocs/frees, if the tool replaces glibc's
|
||||
malloc() et al -- redzone size is chosen by the tool.
|
||||
DEMANGLE for the C++ demangler.
|
||||
EXECTXT for storing ExeContexts.
|
||||
ERRORS for storing CoreErrors.
|
||||
@ -391,7 +391,7 @@ extern Bool VG_(is_empty_arena) ( ArenaId aid );
|
||||
/* This doesn't export code or data that valgrind.so needs to link
|
||||
against. However, the scheduler does need to know the following
|
||||
request codes. A few, publically-visible, request codes are also
|
||||
defined in valgrind.h, and similar headers for some skins. */
|
||||
defined in valgrind.h, and similar headers for some tools. */
|
||||
|
||||
#define VG_USERREQ__MALLOC 0x2001
|
||||
#define VG_USERREQ__FREE 0x2002
|
||||
@ -1270,7 +1270,7 @@ extern Addr VG_(client_trampoline_code);
|
||||
|
||||
extern Addr VG_(brk_base); /* start of brk */
|
||||
extern Addr VG_(brk_limit); /* current brk */
|
||||
extern Addr VG_(shadow_base); /* skin's shadow memory */
|
||||
extern Addr VG_(shadow_base); /* tool's shadow memory */
|
||||
extern Addr VG_(shadow_end);
|
||||
extern Addr VG_(valgrind_base); /* valgrind's address range */
|
||||
extern Addr VG_(valgrind_end);
|
||||
@ -1561,7 +1561,7 @@ extern const Int VG_(tramp_sigreturn_offset);
|
||||
extern const Int VG_(tramp_syscall_offset);
|
||||
|
||||
/* ---------------------------------------------------------------------
|
||||
Things relating to the used skin
|
||||
Things relating to the used tool
|
||||
------------------------------------------------------------------ */
|
||||
|
||||
#define VG_TRACK(fn, args...) \
|
||||
@ -1646,7 +1646,7 @@ extern Int VGOFF_(ldt);
|
||||
/* This thread's TLS pointer. */
|
||||
extern Int VGOFF_(tls);
|
||||
|
||||
/* Nb: Most helper offsets are in include/vg_skin.h, for use by skins */
|
||||
/* Nb: Most helper offsets are in include/vg_skin.h, for use by tools */
|
||||
|
||||
extern Int VGOFF_(helper_undefined_instruction);
|
||||
|
||||
|
||||
@ -30,8 +30,8 @@
|
||||
*/
|
||||
|
||||
/* We only import vg_skin.h here, because this file only provides functions
|
||||
for doing things that could be done directly by the skin -- it's just to
|
||||
make skins' lives easier, rather than let them do something they
|
||||
for doing things that could be done directly by the tool -- it's just to
|
||||
make tools' lives easier, rather than let them do something they
|
||||
couldn't otherwise do. */
|
||||
#include "vg_skin.h"
|
||||
|
||||
|
||||
@ -104,7 +104,7 @@ Addr VG_(clstk_end);
|
||||
Addr VG_(brk_base); /* start of brk */
|
||||
Addr VG_(brk_limit); /* current brk */
|
||||
|
||||
Addr VG_(shadow_base); /* skin's shadow memory */
|
||||
Addr VG_(shadow_base); /* tool's shadow memory */
|
||||
Addr VG_(shadow_end);
|
||||
|
||||
Addr VG_(valgrind_base); /* valgrind's address range */
|
||||
@ -1316,9 +1316,9 @@ static void load_tool( const char *toolname, void** handle_out,
|
||||
toolinfo->sizeof_ToolInfo);
|
||||
fprintf(stderr, " You need to at least recompile, and possibly update,\n");
|
||||
if (VG_CORE_INTERFACE_MAJOR_VERSION > toolinfo->interface_major_version)
|
||||
fprintf(stderr, " your skin to work with this version of Valgrind.\n");
|
||||
fprintf(stderr, " your tool to work with this version of Valgrind.\n");
|
||||
else
|
||||
fprintf(stderr, " your version of Valgrind to work with this skin.\n");
|
||||
fprintf(stderr, " your version of Valgrind to work with this tool.\n");
|
||||
goto bad_load;
|
||||
}
|
||||
|
||||
@ -1917,7 +1917,7 @@ static void process_cmd_line_options( UInt* client_auxv, const char* toolname )
|
||||
results of a run which encompasses multiple processes. */
|
||||
|
||||
if (VG_(clo_verbosity > 0)) {
|
||||
/* Skin details */
|
||||
/* Tool details */
|
||||
VG_(message)(Vg_UserMsg, "%s%s%s, %s for x86-linux.",
|
||||
VG_(details).name,
|
||||
NULL == VG_(details).version ? "" : "-",
|
||||
@ -1979,7 +1979,7 @@ static void process_cmd_line_options( UInt* client_auxv, const char* toolname )
|
||||
|
||||
if (VG_(clo_n_suppressions) < VG_CLO_MAX_SFILES-1 &&
|
||||
(VG_(needs).core_errors || VG_(needs).skin_errors)) {
|
||||
/* If there are no suppression files specified and the skin
|
||||
/* If there are no suppression files specified and the tool
|
||||
needs one, load the default */
|
||||
static const Char default_supp[] = "default.supp";
|
||||
Int len = VG_(strlen)(VG_(libdir)) + 1 + sizeof(default_supp);
|
||||
@ -2192,7 +2192,7 @@ void VG_(register_noncompact_helper)(Addr a)
|
||||
VG_(n_noncompact_helpers)++;
|
||||
}
|
||||
|
||||
/* Allocate offsets in baseBlock for the skin helpers */
|
||||
/* Allocate offsets in baseBlock for the tool helpers */
|
||||
static
|
||||
void assign_helpers_in_baseBlock(UInt n, Int offsets[], Addr addrs[])
|
||||
{
|
||||
@ -2588,7 +2588,7 @@ void VG_(do_sanity_checks) ( Bool force_expensive )
|
||||
|
||||
/*
|
||||
This code decides on the layout of the client and Valgrind address
|
||||
spaces, loads valgrind.so and the skin.so into the valgrind part,
|
||||
spaces, loads valgrind.so and the tool.so into the valgrind part,
|
||||
loads the client executable (and the dynamic linker, if necessary)
|
||||
into the client part, and calls into Valgrind proper.
|
||||
|
||||
@ -2609,7 +2609,7 @@ void VG_(do_sanity_checks) ( Bool force_expensive )
|
||||
| redzone |
|
||||
shadow_base +-------------------------+
|
||||
| |
|
||||
: shadow memory for skins :
|
||||
: shadow memory for tools :
|
||||
| (may be 0 sized) |
|
||||
shadow_end +-------------------------+
|
||||
: gap (may be 0 sized) :
|
||||
|
||||
@ -1390,7 +1390,7 @@ void* VG_(arena_realloc) ( ArenaId aid, void* ptr,
|
||||
|
||||
|
||||
/*------------------------------------------------------------*/
|
||||
/*--- Skin-visible functions. ---*/
|
||||
/*--- Tool-visible functions. ---*/
|
||||
/*------------------------------------------------------------*/
|
||||
|
||||
/* All just wrappers to avoid exposing arenas to tools */
|
||||
|
||||
@ -670,7 +670,7 @@ Segment *VG_(next_segment)(Segment *s)
|
||||
#define VG_HUGE_DELTA (VG_PLAUSIBLE_STACK_SIZE / 4)
|
||||
|
||||
/* This function gets called if new_mem_stack and/or die_mem_stack are
|
||||
tracked by the skin, and one of the specialised cases (eg. new_mem_stack_4)
|
||||
tracked by the tool, and one of the specialised cases (eg. new_mem_stack_4)
|
||||
isn't used in preference */
|
||||
__attribute__((regparm(1)))
|
||||
void VG_(unknown_esp_update)(Addr new_ESP)
|
||||
@ -841,7 +841,7 @@ void VG_(init_shadow_range)(Addr p, UInt sz, Bool call_init)
|
||||
|
||||
if (call_init)
|
||||
while(sz) {
|
||||
/* ask the skin to initialize each page */
|
||||
/* ask the tool to initialize each page */
|
||||
VG_TRACK( init_shadow_page, PGROUNDDN(p) );
|
||||
|
||||
p += VKI_BYTES_PER_PAGE;
|
||||
|
||||
@ -159,7 +159,7 @@ struct _SegInfo {
|
||||
*/
|
||||
UInt offset;
|
||||
|
||||
/* Bounds of data, BSS, PLT and GOT, so that skins can see what
|
||||
/* Bounds of data, BSS, PLT and GOT, so that tools can see what
|
||||
section an address is in */
|
||||
Addr plt_start;
|
||||
UInt plt_size;
|
||||
|
||||
@ -676,7 +676,7 @@ static void describe_addr_addbuf(Char c) {
|
||||
else
|
||||
describe_addr_bufsz *= 2;
|
||||
|
||||
/* use tool malloc so that the skin client can free it */
|
||||
/* use tool malloc so that the tool can free it */
|
||||
n = VG_(malloc)(describe_addr_bufsz);
|
||||
if (describe_addr_buf != NULL && describe_addr_bufidx != 0)
|
||||
VG_(memcpy)(n, describe_addr_buf, describe_addr_bufidx);
|
||||
|
||||
@ -37,7 +37,7 @@
|
||||
|
||||
/* All system calls are channelled through here, doing two things:
|
||||
|
||||
* notify the skin of the memory events (reads, writes) happening
|
||||
* notify the tool of the memory events (reads, writes) happening
|
||||
|
||||
* perform the syscall, usually by passing it along to the kernel
|
||||
unmodified.
|
||||
@ -5864,7 +5864,7 @@ void VG_(post_syscall) ( ThreadId tid, Bool restart )
|
||||
|
||||
tst = VG_(get_ThreadState)(tid);
|
||||
|
||||
/* Tell the skin about the syscall return value */
|
||||
/* Tell the tool about the syscall return value */
|
||||
SET_SYSCALL_RETVAL(tst->tid, tst->m_eax);
|
||||
|
||||
syscallno = tst->syscallno;
|
||||
|
||||
@ -74,7 +74,7 @@ UCodeBlock* VG_(alloc_UCodeBlock) ( void )
|
||||
return cb;
|
||||
}
|
||||
|
||||
/* This one is called by skins */
|
||||
/* This one is called by tools */
|
||||
UCodeBlock* VG_(setup_UCodeBlock) ( UCodeBlock* cb_in )
|
||||
{
|
||||
UCodeBlock* cb = VG_(arena_malloc)(VG_AR_CORE, sizeof(UCodeBlock));
|
||||
@ -1459,7 +1459,7 @@ Int containingArchRegOf ( Int sz, Int aregno )
|
||||
|
||||
/* If u reads an ArchReg, return the number of the containing arch
|
||||
reg. Otherwise return -1. Used in redundant-PUT elimination.
|
||||
Note that this is not required for skins extending UCode because
|
||||
Note that this is not required for tools extending UCode because
|
||||
this happens before instrumentation. */
|
||||
static
|
||||
Int maybe_uinstrReadsArchReg ( UInstr* u )
|
||||
@ -1846,9 +1846,9 @@ static void vg_improve ( UCodeBlock* cb )
|
||||
/*--- %ESP-update pass ---*/
|
||||
/*------------------------------------------------------------*/
|
||||
|
||||
/* For skins that want to know about %ESP changes, this pass adds
|
||||
in the appropriate hooks. We have to do it after the skin's
|
||||
instrumentation, so the skin doesn't have to worry about the CCALLs
|
||||
/* For tools that want to know about %ESP changes, this pass adds
|
||||
in the appropriate hooks. We have to do it after the tool's
|
||||
instrumentation, so the tool doesn't have to worry about the CCALLs
|
||||
it adds in, and we must do it before register allocation because
|
||||
spilled temps make it much harder to work out the %esp deltas.
|
||||
Thus we have it as an extra phase between the two.
|
||||
@ -2053,7 +2053,7 @@ UCodeBlock* vg_do_register_allocation ( UCodeBlock* c1 )
|
||||
if (temp_info[tno].live_after == VG_NOTHING) {
|
||||
VG_(printf)("At instr %d...\n", i);
|
||||
VG_(core_panic)("First use of tmp not a write,"
|
||||
" probably a skin instrumentation error");
|
||||
" probably a tool instrumentation error");
|
||||
}
|
||||
/* Reads only hold it live until before this insn. */
|
||||
if (temp_info[tno].dead_before < i)
|
||||
@ -2491,7 +2491,7 @@ void VG_(translate) ( /*IN*/ ThreadId tid,
|
||||
VG_(saneUCodeBlock)( cb );
|
||||
VGP_POPCC(VgpInstrument);
|
||||
|
||||
/* Add %ESP-update hooks if the skin requires them */
|
||||
/* Add %ESP-update hooks if the tool requires them */
|
||||
/* Nb: We don't print out this phase, because it doesn't do much */
|
||||
if (VG_(need_to_handle_esp_assignment)()) {
|
||||
VGP_PUSHCC(VgpESPUpdate);
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*-*- c -*- ----------------------------------------------------------*/
|
||||
/*--- The only header your skin will ever need to #include... ---*/
|
||||
/*--- The only header your tool will ever need to #include... ---*/
|
||||
/*--- vg_skin.h ---*/
|
||||
/*--------------------------------------------------------------------*/
|
||||
|
||||
@ -119,11 +119,11 @@ extern const Char *VG_(libdir);
|
||||
|
||||
|
||||
/*====================================================================*/
|
||||
/*=== Core/skin interface version ===*/
|
||||
/*=== Core/tool interface version ===*/
|
||||
/*====================================================================*/
|
||||
|
||||
/* The major version number indicates binary-incompatible changes to the
|
||||
interface; if the core and skin major versions don't match, Valgrind
|
||||
interface; if the core and tool major versions don't match, Valgrind
|
||||
will abort. The minor version indicates binary-compatible changes.
|
||||
*/
|
||||
#define VG_CORE_INTERFACE_MAJOR_VERSION 6
|
||||
@ -134,7 +134,7 @@ typedef struct _ToolInfo {
|
||||
Int interface_major_version;
|
||||
Int interface_minor_version;
|
||||
|
||||
/* Initialise skin. Must do the following:
|
||||
/* Initialise tool. Must do the following:
|
||||
- initialise the `details' struct, via the VG_(details_*)() functions
|
||||
- register any helpers called by generated code
|
||||
|
||||
@ -142,8 +142,8 @@ typedef struct _ToolInfo {
|
||||
- initialise the `needs' struct to indicate certain requirements, via
|
||||
the VG_(needs_*)() functions
|
||||
- initialize all the tool's entrypoints via the VG_(init_*)() functions
|
||||
- register any skin-specific profiling events
|
||||
- any other skin-specific initialisation
|
||||
- register any tool-specific profiling events
|
||||
- any other tool-specific initialisation
|
||||
*/
|
||||
void (*sk_pre_clo_init) ( void );
|
||||
|
||||
@ -152,7 +152,7 @@ typedef struct _ToolInfo {
|
||||
float shadow_ratio;
|
||||
} ToolInfo;
|
||||
|
||||
/* Every skin must include this macro somewhere, exactly once. */
|
||||
/* Every tool must include this macro somewhere, exactly once. */
|
||||
#define VG_DETERMINE_INTERFACE_VERSION(pre_clo_init, shadow) \
|
||||
const ToolInfo SK_(tool_info) = { \
|
||||
.sizeof_ToolInfo = sizeof(ToolInfo), \
|
||||
@ -170,7 +170,7 @@ typedef struct _ToolInfo {
|
||||
#define VG_STREQ(s1,s2) (s1 != NULL && s2 != NULL \
|
||||
&& VG_(strcmp)((s1),(s2))==0)
|
||||
|
||||
/* Use these for recognising skin command line options -- stops comparing
|
||||
/* Use these for recognising tool command line options -- stops comparing
|
||||
once whitespace is reached. */
|
||||
#define VG_CLO_STREQ(s1,s2) (0==VG_(strcmp_ws)((s1),(s2)))
|
||||
#define VG_CLO_STREQN(nn,s1,s2) (0==VG_(strncmp_ws)((s1),(s2),(nn)))
|
||||
@ -275,20 +275,20 @@ extern int VG_(vmessage) ( VgMsgKind kind, Char* format, va_list vargs );
|
||||
VGP_PAIR(VgpDemangle, "demangle"), \
|
||||
VGP_PAIR(VgpCoreCheapSanity, "core-cheap-sanity"), \
|
||||
VGP_PAIR(VgpCoreExpensiveSanity, "core-expensive-sanity"), \
|
||||
/* These ones depend on the skin */ \
|
||||
/* These ones depend on the tool */ \
|
||||
VGP_PAIR(VgpPreCloInit, "pre-clo-init"), \
|
||||
VGP_PAIR(VgpPostCloInit, "post-clo-init"), \
|
||||
VGP_PAIR(VgpInstrument, "instrument"), \
|
||||
VGP_PAIR(VgpSkinSysWrap, "skin-syscall-wrapper"), \
|
||||
VGP_PAIR(VgpSkinCheapSanity, "skin-cheap-sanity"), \
|
||||
VGP_PAIR(VgpSkinExpensiveSanity, "skin-expensive-sanity"), \
|
||||
VGP_PAIR(VgpSkinSysWrap, "tool-syscall-wrapper"), \
|
||||
VGP_PAIR(VgpSkinCheapSanity, "tool-cheap-sanity"), \
|
||||
VGP_PAIR(VgpSkinExpensiveSanity, "tool-expensive-sanity"), \
|
||||
VGP_PAIR(VgpFini, "fini")
|
||||
|
||||
#define VGP_PAIR(n,name) n
|
||||
typedef enum { VGP_CORE_LIST } VgpCoreCC;
|
||||
#undef VGP_PAIR
|
||||
|
||||
/* When registering skin profiling events, ensure that the 'n' value is in
|
||||
/* When registering tool profiling events, ensure that the 'n' value is in
|
||||
* the range (VgpFini+1..) */
|
||||
extern void VGP_(register_profile_event) ( Int n, Char* name );
|
||||
|
||||
@ -899,7 +899,7 @@ typedef
|
||||
CCALL(arg1, arg2, ret ) UInt f(UInt arg1, UInt arg2) */
|
||||
CCALL,
|
||||
|
||||
/* This opcode makes it easy for skins that extend UCode to do this to
|
||||
/* This opcode makes it easy for tools that extend UCode to do this to
|
||||
avoid opcode overlap:
|
||||
|
||||
enum { EU_OP1 = DUMMY_FINAL_UOPCODE + 1, ... }
|
||||
@ -1045,7 +1045,7 @@ typedef
|
||||
/* Additional properties for UInstrs that call C functions:
|
||||
- CCALL
|
||||
- PUT (when %ESP is the target)
|
||||
- possibly skin-specific UInstrs
|
||||
- possibly tool-specific UInstrs
|
||||
*/
|
||||
UChar argc:2; /* Number of args, max 3 */
|
||||
UChar regparms_n:2; /* Number of args passed in registers */
|
||||
@ -1218,7 +1218,7 @@ extern UCodeBlock* VG_(setup_UCodeBlock) ( UCodeBlock* cb );
|
||||
extern void VG_(free_UCodeBlock) ( UCodeBlock* cb );
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* UCode pretty/ugly printing. Probably only useful to call from a skin
|
||||
/* UCode pretty/ugly printing. Probably only useful to call from a tool
|
||||
if VG_(needs).extended_UCode == True. */
|
||||
|
||||
/* When True, all generated code is/should be printed. */
|
||||
@ -1307,7 +1307,7 @@ extern Int VGOFF_(helper_cmpxchg8b);
|
||||
/*=== Generating x86 code from UCode ===*/
|
||||
/*====================================================================*/
|
||||
|
||||
/* All this only necessary for skins with VG_(needs).extends_UCode == True. */
|
||||
/* All this only necessary for tools with VG_(needs).extends_UCode == True. */
|
||||
|
||||
/* This is the Intel register encoding -- integer regs. */
|
||||
#define R_EAX 0
|
||||
@ -1494,7 +1494,7 @@ extern Addr VG_(get_EIP_from_ExeContext) ( ExeContext* e, UInt n );
|
||||
*/
|
||||
extern Addr VG_(get_EIP)( ThreadId tid );
|
||||
|
||||
/* For skins needing more control over stack traces: walks the stack to get
|
||||
/* For tools needing more control over stack traces: walks the stack to get
|
||||
%eips from the top stack frames for thread 'tid'. Maximum of 'n_eips'
|
||||
addresses put into 'eips'; 0 is the top of the stack, 1 is its caller,
|
||||
etc. */
|
||||
@ -1521,7 +1521,7 @@ typedef
|
||||
Int /* Do not make this unsigned! */
|
||||
SuppKind;
|
||||
|
||||
/* The skin-relevant parts of a suppression are:
|
||||
/* The tool-relevant parts of a suppression are:
|
||||
kind: what kind of suppression; must be in the range (0..)
|
||||
string: use is optional. NULL by default.
|
||||
extra: use is optional. NULL by default. void* so it's extensible.
|
||||
@ -1553,7 +1553,7 @@ typedef
|
||||
Int /* Do not make this unsigned! */
|
||||
ErrorKind;
|
||||
|
||||
/* The skin-relevant parts of an Error are:
|
||||
/* The tool-relevant parts of an Error are:
|
||||
kind: what kind of error; must be in the range (0..)
|
||||
addr: use is optional. 0 by default.
|
||||
string: use is optional. NULL by default.
|
||||
@ -1597,7 +1597,7 @@ extern Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind,
|
||||
|
||||
/* Gets a non-blank, non-comment line of at most nBuf chars from fd.
|
||||
Skips leading spaces on the line. Returns True if EOF was hit instead.
|
||||
Useful for reading in extra skin-specific suppression lines. */
|
||||
Useful for reading in extra tool-specific suppression lines. */
|
||||
extern Bool VG_(get_line) ( Int fd, Char* buf, Int nBuf );
|
||||
|
||||
|
||||
@ -1681,9 +1681,9 @@ extern VgSectKind VG_(seg_sect_kind)(Addr);
|
||||
/*====================================================================*/
|
||||
|
||||
/* Generic type for a separately-chained hash table. Via a kind of dodgy
|
||||
C-as-C++ style inheritance, skins can extend the VgHashNode type, so long
|
||||
C-as-C++ style inheritance, tools can extend the VgHashNode type, so long
|
||||
as the first two fields match the sizes of these two fields. Requires
|
||||
a bit of casting by the skin. */
|
||||
a bit of casting by the tool. */
|
||||
typedef
|
||||
struct _VgHashNode {
|
||||
struct _VgHashNode * next;
|
||||
@ -1828,13 +1828,13 @@ extern UInt VG_(get_exit_status_shadow) ( void );
|
||||
/*=== Specific stuff for replacing malloc() and friends ===*/
|
||||
/*====================================================================*/
|
||||
|
||||
/* If a skin replaces malloc() et al, the easiest way to do so is to
|
||||
/* If a tool replaces malloc() et al, the easiest way to do so is to
|
||||
link with vg_replace_malloc.o into its vgpreload_*.so file, and
|
||||
follow the following instructions. You can do it from scratch,
|
||||
though, if you enjoy that sort of thing. */
|
||||
|
||||
/* Arena size for valgrind's own malloc(); default value is 0, but can
|
||||
be overridden by skin -- but must be done so *statically*, eg:
|
||||
be overridden by tool -- but must be done so *statically*, eg:
|
||||
|
||||
Int VG_(vg_malloc_redzone_szB) = 4;
|
||||
|
||||
@ -1850,8 +1850,8 @@ extern void VG_(cli_free) ( void* p );
|
||||
extern Bool VG_(addr_is_in_block)( Addr a, Addr start, UInt size );
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Some options that can be used by a skin if malloc() et al are replaced.
|
||||
The skin should call the functions in the appropriate places to give
|
||||
/* Some options that can be used by a tool if malloc() et al are replaced.
|
||||
The tool should call the functions in the appropriate places to give
|
||||
control over these aspects of Valgrind's version of malloc(). */
|
||||
|
||||
/* Round malloc sizes upwards to integral number of words? default: NO */
|
||||
@ -1868,7 +1868,7 @@ extern void VG_(replacement_malloc_print_debug_usage) ( void );
|
||||
|
||||
|
||||
/*====================================================================*/
|
||||
/*=== Skin-specific stuff ===*/
|
||||
/*=== Tool-specific stuff ===*/
|
||||
/*====================================================================*/
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
@ -1880,10 +1880,10 @@ extern void VG_(replacement_malloc_print_debug_usage) ( void );
|
||||
|
||||
/* Information used in the startup message. `name' also determines the
|
||||
string used for identifying suppressions in a suppression file as
|
||||
belonging to this skin. `version' can be NULL, in which case (not
|
||||
belonging to this tool. `version' can be NULL, in which case (not
|
||||
surprisingly) no version info is printed; this mechanism is designed for
|
||||
skins distributed with Valgrind that share a version number with
|
||||
Valgrind. Other skins not distributed as part of Valgrind should
|
||||
tools distributed with Valgrind that share a version number with
|
||||
Valgrind. Other tools not distributed as part of Valgrind should
|
||||
probably have their own version number. */
|
||||
extern void VG_(details_name) ( Char* name );
|
||||
extern void VG_(details_version) ( Char* version );
|
||||
@ -1905,7 +1905,7 @@ extern void VG_(details_bug_reports_to) ( Char* bug_reports_to );
|
||||
/* Booleans that decide core behaviour, but don't require extra
|
||||
operations to be defined if `True' */
|
||||
|
||||
/* Should __libc_freeres() be run? Bugs in it can crash the skin. */
|
||||
/* Should __libc_freeres() be run? Bugs in it can crash the tool. */
|
||||
extern void VG_(needs_libc_freeres) ( void );
|
||||
|
||||
/* Want to have errors detected by Valgrind's core reported? Includes:
|
||||
@ -1919,7 +1919,7 @@ extern void VG_(needs_core_errors) ( void );
|
||||
the corresponding template functions (given below) must be defined. A
|
||||
lot like being a member of a type class. */
|
||||
|
||||
/* Want to report errors from skin? This implies use of suppressions, too. */
|
||||
/* Want to report errors from tool? This implies use of suppressions, too. */
|
||||
extern void VG_(needs_skin_errors) ( void );
|
||||
|
||||
/* Is information kept about specific individual basic blocks? (Eg. for
|
||||
@ -1930,28 +1930,28 @@ extern void VG_(needs_skin_errors) ( void );
|
||||
to be used for more than one instruction in one program run... */
|
||||
extern void VG_(needs_basic_block_discards) ( void );
|
||||
|
||||
/* Skin maintains information about each register? */
|
||||
/* Tool maintains information about each register? */
|
||||
extern void VG_(needs_shadow_regs) ( void );
|
||||
|
||||
/* Skin defines its own command line options? */
|
||||
/* Tool defines its own command line options? */
|
||||
extern void VG_(needs_command_line_options) ( void );
|
||||
|
||||
/* Skin defines its own client requests? */
|
||||
/* Tool defines its own client requests? */
|
||||
extern void VG_(needs_client_requests) ( void );
|
||||
|
||||
/* Skin defines its own UInstrs? */
|
||||
/* Tool defines its own UInstrs? */
|
||||
extern void VG_(needs_extended_UCode) ( void );
|
||||
|
||||
/* Skin does stuff before and/or after system calls? */
|
||||
/* Tool does stuff before and/or after system calls? */
|
||||
extern void VG_(needs_syscall_wrapper) ( void );
|
||||
|
||||
/* Are skin-state sanity checks performed? */
|
||||
/* Are tool-state sanity checks performed? */
|
||||
extern void VG_(needs_sanity_checks) ( void );
|
||||
|
||||
/* Do we need to see data symbols? */
|
||||
extern void VG_(needs_data_syms) ( void );
|
||||
|
||||
/* Does the skin need shadow memory allocated (if you set this, you must also statically initialize
|
||||
/* Does the tool need shadow memory allocated (if you set this, you must also statically initialize
|
||||
float SK_(shadow_ratio) = n./m;
|
||||
to define how many shadow bits you need per client address space bit.
|
||||
*/
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
|
||||
/*--------------------------------------------------------------------*/
|
||||
/*--- Massif: a heap profiling skin. ms_main.c ---*/
|
||||
/*--- Massif: a heap profiling tool. ms_main.c ---*/
|
||||
/*--------------------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
This file is part of Massif, a Valgrind skin for profiling memory
|
||||
This file is part of Massif, a Valgrind tool for profiling memory
|
||||
usage of programs.
|
||||
|
||||
Copyright (C) 2003-2004 Nicholas Nethercote
|
||||
|
||||
@ -64,8 +64,8 @@ void vg_scan_all_valid_memory_sighandler ( Int sigNo )
|
||||
on the page is valid. Only if so are that address and its contents
|
||||
passed to notify_word.
|
||||
|
||||
This is all to avoid duplication of this machinery between the
|
||||
memcheck and addrcheck skins.
|
||||
This is all to avoid duplication of this machinery between
|
||||
Memcheck and Addrcheck.
|
||||
*/
|
||||
static
|
||||
UInt vg_scan_all_valid_memory ( Bool is_valid_64k_chunk ( UInt ),
|
||||
@ -368,8 +368,8 @@ static Int lc_compar(void* n1, void* n2)
|
||||
/* Top level entry point to leak detector. Call here, passing in
|
||||
suitable address-validating functions (see comment at top of
|
||||
vg_scan_all_valid_memory above). All this is to avoid duplication
|
||||
of the leak-detection code for the Memcheck and Addrcheck skins.
|
||||
Also pass in a skin-specific function to extract the .where field
|
||||
of the leak-detection code for Memcheck and Addrcheck.
|
||||
Also pass in a tool-specific function to extract the .where field
|
||||
for allocated blocks, an indication of the resolution wanted for
|
||||
distinguishing different allocation points, and whether or not
|
||||
reachable blocks should be shown.
|
||||
|
||||
@ -1457,9 +1457,9 @@ Bool mc_is_valid_address ( Addr a )
|
||||
}
|
||||
|
||||
|
||||
/* Leak detector for this skin. We don't actually do anything, merely
|
||||
/* Leak detector for this tool. We don't actually do anything, merely
|
||||
run the generic leak detector with suitable parameters for this
|
||||
skin. */
|
||||
tool. */
|
||||
void MC_(detect_memory_leaks) ( void )
|
||||
{
|
||||
MAC_(do_detect_memory_leaks) ( mc_is_valid_64k_chunk, mc_is_valid_address );
|
||||
|
||||
@ -573,7 +573,7 @@ static UCodeBlock* memcheck_instrument ( UCodeBlock* cb_in )
|
||||
still addressible. Hence the optionalisation of the V
|
||||
check. 15 Dec 02: optionalisation removed, since it no
|
||||
longer makes much sense given we also have an addrcheck
|
||||
skin.
|
||||
tool.
|
||||
|
||||
The LOADV/STOREV does an addressibility check for the
|
||||
address. */
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
|
||||
/* The quick sanity check of Memcheck (and other skins with shadow memory)
|
||||
/* The quick sanity check of Memcheck (and other tools with shadow memory)
|
||||
relies on the first 64KB of memory never being used. So our mmap()
|
||||
refuses to touch this area. This program tests for that. */
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user