}
-/* 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 );
# 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.
## 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
## ------------------------------------------------------------------
## 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...
## ---------------------------------------------------------------------
## 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
## 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
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
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
/*--- 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 {
else
err->where = where;
- /* Skin-relevant parts */
+ /* Tool-relevant parts */
err->ekind = ekind;
err->addr = a;
err->extra = extra;
/*--- 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)
{
#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"
/* 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 */
#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 {
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.
/* 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
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);
extern const Int VG_(tramp_syscall_offset);
/* ---------------------------------------------------------------------
- Things relating to the used skin
+ Things relating to the used tool
------------------------------------------------------------------ */
#define VG_TRACK(fn, args...) \
/* 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);
*/
/* 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"
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 */
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;
}
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 ? "" : "-",
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);
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[])
{
/*
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.
| redzone |
shadow_base +-------------------------+
| |
- : shadow memory for skins :
+ : shadow memory for tools :
| (may be 0 sized) |
shadow_end +-------------------------+
: gap (may be 0 sized) :
/*------------------------------------------------------------*/
-/*--- Skin-visible functions. ---*/
+/*--- Tool-visible functions. ---*/
/*------------------------------------------------------------*/
/* All just wrappers to avoid exposing arenas to tools */
#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)
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;
*/
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;
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);
/* 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.
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;
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));
/* 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 )
/*--- %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.
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)
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);
/*-*- c -*- ----------------------------------------------------------*/
-/*--- The only header your skin will ever need to #include... ---*/
+/*--- The only header your tool will ever need to #include... ---*/
/*--- vg_skin.h ---*/
/*--------------------------------------------------------------------*/
/*====================================================================*/
-/*=== 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
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
- 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 );
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), \
#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)))
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 );
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, ... }
/* 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 */
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. */
/*=== 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
*/
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. */
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.
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.
/* 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 );
/*====================================================================*/
/* 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;
/*=== 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;
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 */
/*====================================================================*/
-/*=== Skin-specific stuff ===*/
+/*=== Tool-specific stuff ===*/
/*====================================================================*/
/* ------------------------------------------------------------------ */
/* 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 );
/* 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:
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
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.
*/
/*--------------------------------------------------------------------*/
-/*--- 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
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 ),
/* 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.
}
-/* 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 );
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. */
#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. */
projects / thirdparty / valgrind.git / commitdiff
