Converted the SK_ prefix to TL_ everywhere.
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@3060 a5019735-40e9-0310-863c-91ae7b9d1cf9
diff --git a/addrcheck/ac_main.c b/addrcheck/ac_main.c
index 51f931a..63fd5fb 100644
--- a/addrcheck/ac_main.c
+++ b/addrcheck/ac_main.c
@@ -39,7 +39,7 @@
/*--- Comparing and printing errors ---*/
/*------------------------------------------------------------*/
-void SK_(pp_Error) ( Error* err )
+void TL_(pp_Error) ( Error* err )
{
MAC_Error* err_extra = VG_(get_error_extra)(err);
@@ -75,7 +75,7 @@
/*--- Suppressions ---*/
/*------------------------------------------------------------*/
-Bool SK_(recognised_suppression) ( Char* name, Supp* su )
+Bool TL_(recognised_suppression) ( Char* name, Supp* su )
{
return MAC_(shared_recognised_suppression)(name, su);
}
@@ -350,7 +350,7 @@
/* Check that zero page and highest page have not been written to
-- this could happen with buggy syscall wrappers. Today
(2001-04-26) had precisely such a problem with __NR_setitimer. */
- tl_assert(SK_(cheap_sanity_check)());
+ tl_assert(TL_(cheap_sanity_check)());
VGP_POPCC(VgpSetMem);
}
@@ -949,7 +949,7 @@
/*--- Our instrumenter ---*/
/*------------------------------------------------------------*/
-UCodeBlock* SK_(instrument)(UCodeBlock* cb_in, Addr orig_addr)
+UCodeBlock* TL_(instrument)(UCodeBlock* cb_in, Addr orig_addr)
{
/* Use this rather than eg. -1 because it's a UInt. */
#define INVALID_DATA_SIZE 999999
@@ -980,7 +980,7 @@
case 2: helper = (Addr)ac_helperc_LOAD2; break;
case 1: helper = (Addr)ac_helperc_LOAD1; break;
default: VG_(tool_panic)
- ("addrcheck::SK_(instrument):LOAD");
+ ("addrcheck::TL_(instrument):LOAD");
}
uInstr1(cb, CCALL, 0, TempReg, u_in->val1);
uCCall (cb, helper, 1, 1, False );
@@ -993,7 +993,7 @@
case 2: helper = (Addr)ac_helperc_STORE2; break;
case 1: helper = (Addr)ac_helperc_STORE1; break;
default: VG_(tool_panic)
- ("addrcheck::SK_(instrument):STORE");
+ ("addrcheck::TL_(instrument):STORE");
}
uInstr1(cb, CCALL, 0, TempReg, u_in->val2);
uCCall (cb, helper, 1, 1, False );
@@ -1133,13 +1133,13 @@
Sanity check machinery (permanently engaged).
------------------------------------------------------------------ */
-Bool SK_(cheap_sanity_check) ( void )
+Bool TL_(cheap_sanity_check) ( void )
{
/* nothing useful we can rapidly check */
return True;
}
-Bool SK_(expensive_sanity_check) ( void )
+Bool TL_(expensive_sanity_check) ( void )
{
Int i;
@@ -1161,7 +1161,7 @@
/*--- Client requests ---*/
/*------------------------------------------------------------*/
-Bool SK_(handle_client_request) ( ThreadId tid, UWord* arg, UWord *ret )
+Bool TL_(handle_client_request) ( ThreadId tid, UWord* arg, UWord *ret )
{
#define IGNORE(what) \
do { \
@@ -1230,17 +1230,17 @@
/*--- Setup ---*/
/*------------------------------------------------------------*/
-Bool SK_(process_cmd_line_option)(Char* arg)
+Bool TL_(process_cmd_line_option)(Char* arg)
{
return MAC_(process_common_cmd_line_option)(arg);
}
-void SK_(print_usage)(void)
+void TL_(print_usage)(void)
{
MAC_(print_common_usage)();
}
-void SK_(print_debug_usage)(void)
+void TL_(print_debug_usage)(void)
{
MAC_(print_common_debug_usage)();
}
@@ -1250,7 +1250,7 @@
/*--- Setup ---*/
/*------------------------------------------------------------*/
-void SK_(pre_clo_init)(void)
+void TL_(pre_clo_init)(void)
{
VG_(details_name) ("Addrcheck");
VG_(details_version) (NULL);
@@ -1325,16 +1325,16 @@
MAC_(common_pre_clo_init)();
}
-void SK_(post_clo_init) ( void )
+void TL_(post_clo_init) ( void )
{
}
-void SK_(fini) ( Int exitcode )
+void TL_(fini) ( Int exitcode )
{
MAC_(common_fini)( ac_detect_memory_leaks );
}
-VG_DETERMINE_INTERFACE_VERSION(SK_(pre_clo_init), 1./8)
+VG_DETERMINE_INTERFACE_VERSION(TL_(pre_clo_init), 1./8)
/*--------------------------------------------------------------------*/
diff --git a/cachegrind/cg_main.c b/cachegrind/cg_main.c
index 9832605..1a028be 100644
--- a/cachegrind/cg_main.c
+++ b/cachegrind/cg_main.c
@@ -491,7 +491,7 @@
uCCall(cb, helper, argc, argc, False);
}
-UCodeBlock* SK_(instrument)(UCodeBlock* cb_in, Addr orig_addr)
+UCodeBlock* TL_(instrument)(UCodeBlock* cb_in, Addr orig_addr)
{
UCodeBlock* cb;
UInstr* u_in;
@@ -762,7 +762,7 @@
}
/*------------------------------------------------------------*/
-/*--- SK_(fini)() and related function ---*/
+/*--- TL_(fini)() and related function ---*/
/*------------------------------------------------------------*/
// Total reads/writes/misses. Calculated during CC traversal at the end.
@@ -901,7 +901,7 @@
for (i = 0; i < space; i++) buf[i] = ' ';
}
-void SK_(fini)(Int exitcode)
+void TL_(fini)(Int exitcode)
{
static char buf1[128], buf2[128], buf3[128], fmt [128];
@@ -1024,7 +1024,7 @@
/*--------------------------------------------------------------------*/
// Called when a translation is invalidated due to code unloading.
-void SK_(discard_basic_block_info) ( Addr a, SizeT size )
+void TL_(discard_basic_block_info) ( Addr a, SizeT size )
{
VgHashNode** prev_next_ptr;
VgHashNode* bb_info;
@@ -1074,7 +1074,7 @@
VG_(bad_option)(opt);
}
-Bool SK_(process_cmd_line_option)(Char* arg)
+Bool TL_(process_cmd_line_option)(Char* arg)
{
// 5 is length of "--I1="
if (VG_CLO_STREQN(5, arg, "--I1="))
@@ -1089,7 +1089,7 @@
return True;
}
-void SK_(print_usage)(void)
+void TL_(print_usage)(void)
{
VG_(printf)(
" --I1=<size>,<assoc>,<line_size> set I1 cache manually\n"
@@ -1098,7 +1098,7 @@
);
}
-void SK_(print_debug_usage)(void)
+void TL_(print_debug_usage)(void)
{
VG_(printf)(
" (none)\n"
@@ -1109,7 +1109,7 @@
/*--- Setup ---*/
/*--------------------------------------------------------------------*/
-void SK_(pre_clo_init)(void)
+void TL_(pre_clo_init)(void)
{
Char* base_dir = NULL;
@@ -1141,7 +1141,7 @@
instr_info_table = VG_(HT_construct)();
}
-void SK_(post_clo_init)(void)
+void TL_(post_clo_init)(void)
{
cache_t I1c, D1c, L2c;
@@ -1156,7 +1156,7 @@
VGP_(register_profile_event)(VgpCacheResults, "cache-results");
}
-VG_DETERMINE_INTERFACE_VERSION(SK_(pre_clo_init), 0)
+VG_DETERMINE_INTERFACE_VERSION(TL_(pre_clo_init), 0)
/*--------------------------------------------------------------------*/
/*--- end cg_main.c ---*/
diff --git a/corecheck/cc_main.c b/corecheck/cc_main.c
index fc3e1c7..218d055 100644
--- a/corecheck/cc_main.c
+++ b/corecheck/cc_main.c
@@ -31,7 +31,7 @@
#include "tool.h"
-void SK_(pre_clo_init)(void)
+void TL_(pre_clo_init)(void)
{
VG_(details_name) ("Coregrind");
VG_(details_version) (NULL);
@@ -45,18 +45,18 @@
/* No core events to track */
}
-VG_DETERMINE_INTERFACE_VERSION(SK_(pre_clo_init), 0)
+VG_DETERMINE_INTERFACE_VERSION(TL_(pre_clo_init), 0)
-void SK_(post_clo_init)(void)
+void TL_(post_clo_init)(void)
{
}
-UCodeBlock* SK_(instrument)(UCodeBlock* cb, Addr a)
+UCodeBlock* TL_(instrument)(UCodeBlock* cb, Addr a)
{
return cb;
}
-void SK_(fini)(Int exitcode)
+void TL_(fini)(Int exitcode)
{
}
diff --git a/coregrind/core.h b/coregrind/core.h
index 4ad5b6c..4988c03 100644
--- a/coregrind/core.h
+++ b/coregrind/core.h
@@ -96,8 +96,8 @@
#include "valgrind.h"
-#undef SK_
-#define SK_(x) vgSkinInternal_##x
+#undef TL_
+#define TL_(x) vgToolInternal_##x
/* ---------------------------------------------------------------------
@@ -1649,10 +1649,10 @@
// Macros used in syscall wrappers
#define PRRSN \
- SK_(pre_reg_read)(Vg_CoreSysCall, tid, "(syscallno)", \
+ TL_(pre_reg_read)(Vg_CoreSysCall, tid, "(syscallno)", \
R_SYSCALL_NUM, sizeof(UWord));
#define PRRAn(n,s,t,a) \
- SK_(pre_reg_read)(Vg_CoreSysCall, tid, s"("#a")", \
+ TL_(pre_reg_read)(Vg_CoreSysCall, tid, s"("#a")", \
R_SYSCALL_ARG##n, sizeof(t));
#define PRE_REG_READ0(tr, s) \
if (VG_(defined_pre_reg_read)()) { \
@@ -1772,7 +1772,7 @@
#define VG_TRACK(fn, args...) \
do { \
if (VG_(defined_##fn)()) \
- SK_(fn)(args); \
+ TL_(fn)(args); \
} while(0)
__attribute__ ((noreturn))
diff --git a/coregrind/docs/coregrind_tools.html b/coregrind/docs/coregrind_tools.html
index 34b07ba..90203ae 100644
--- a/coregrind/docs/coregrind_tools.html
+++ b/coregrind/docs/coregrind_tools.html
@@ -294,7 +294,7 @@
then loaded ahead of the core shared object <code>valgrind.so</code>, using the
dynamic linker's <code>LD_PRELOAD</code> variable. Any functions defined in
the tool that share the name with a function defined in core (such as
-the instrumentation function <code>SK_(instrument)()</code>) override the
+the instrumentation function <code>TL_(instrument)()</code>) override the
core's definition. Thus the core can call the necessary tool functions.<p>
This magic is all done for you; the shared object used is chosen with the
@@ -360,7 +360,7 @@
<li>Copy <code>none/nl_main.c</code> into
<code>foobar/</code>, renaming it as <code>fb_main.c</code>.
- Edit it by changing the lines in <code>SK_(pre_clo_init)()</code>
+ Edit it by changing the lines in <code>TL_(pre_clo_init)()</code>
to something appropriate for the tool. These fields are used in the
startup message, except for <code>bug_reports_to</code> which is used
if a tool assertion fails.
@@ -420,10 +420,10 @@
A tool must define at least these four functions:
<pre>
- SK_(pre_clo_init)()
- SK_(post_clo_init)()
- SK_(instrument)()
- SK_(fini)()
+ TL_(pre_clo_init)()
+ TL_(post_clo_init)()
+ TL_(instrument)()
+ TL_(fini)()
</pre>
Also, it must use the macro <code>VG_DETERMINE_INTERFACE_VERSION</code>
@@ -438,8 +438,8 @@
<a name="init"></a>
<h3>2.7 Initialisation</h3>
-Most of the initialisation should be done in <code>SK_(pre_clo_init)()</code>.
-Only use <code>SK_(post_clo_init)()</code> if a tool provides command line
+Most of the initialisation should be done in <code>TL_(pre_clo_init)()</code>.
+Only use <code>TL_(post_clo_init)()</code> if a tool provides command line
options and must do some initialisation after option processing takes place
(``<code>clo</code>'' stands for ``command line options'').<p>
@@ -483,7 +483,7 @@
<a name="instr"></a>
<h3>2.8 Instrumentation</h3>
-<code>SK_(instrument)()</code> is the interesting one. It allows you to
+<code>TL_(instrument)()</code> is the interesting one. It allows you to
instrument <i>UCode</i>, which is Valgrind's RISC-like intermediate language.
UCode is described in the <a href="mc_techdocs.html">technical docs</a> for
Memcheck.
@@ -530,9 +530,9 @@
distributed (Memcheck, Addrcheck, Cachegrind, Lackey, etc.) are probably the
best documentation of all, for the moment.<p>
-Note that the <code>VG_</code> and <code>SK_</code> macros are used heavily.
+Note that the <code>VG_</code> and <code>TL_</code> macros are used heavily.
These just prepend longer strings in front of names to avoid potential
-namespace clashes. We strongly recommend using the <code>SK_</code> macro for
+namespace clashes. We strongly recommend using the <code>TL_</code> macro for
any global functions and variables in your tool, or writing a similar macro.<p>
<a name="wordsofadvice"></a>
diff --git a/coregrind/gen_toolint.pl b/coregrind/gen_toolint.pl
index 95f93c1..841396a 100644
--- a/coregrind/gen_toolint.pl
+++ b/coregrind/gen_toolint.pl
@@ -36,9 +36,9 @@
my $struct = "VG_(tool_interface)";
-my %pfxmap = ("track" => "SK_",
- "tool" => "SK_",
- "malloc"=> "SK_",
+my %pfxmap = ("track" => "TL_",
+ "tool" => "TL_",
+ "malloc"=> "TL_",
);
sub getargnames(@) {
@@ -152,7 +152,7 @@
func = missing_${pfx}_$func;
if (VG_(defined_$func)())
VG_(printf)("Warning tool is redefining $func\\n");
- if (func == SK_($func))
+ if (func == TL_($func))
VG_(printf)("Warning tool is defining $func recursively\\n");
$struct.${pfx}_$func = func;
}
@@ -183,7 +183,7 @@
my $args = join ", ", getargtypes(@args);
print <<EOF;
- ret = dlsym(dlhandle, "vgSkin_$func");
+ ret = dlsym(dlhandle, "vgTool_$func");
if (ret != NULL)
VG_(init_$func)(($ret (*)($args))ret);
diff --git a/coregrind/toolfuncs.def b/coregrind/toolfuncs.def
index 747a10d..55c8616 100644
--- a/coregrind/toolfuncs.def
+++ b/coregrind/toolfuncs.def
@@ -53,7 +53,7 @@
## Should fill in any details that could be postponed until after the
## decision whether to ignore the error (ie. details not affecting the
-## result of SK_(eq_Error)()). This saves time when errors are ignored.
+## result of TL_(eq_Error)()). This saves time when errors are ignored.
## Yuk.
## Return value: must be the size of the `extra' part in bytes -- used by
@@ -77,12 +77,12 @@
## This should return the suppression name, for --gen-suppressions, or NULL
## if that error type cannot be suppressed. This is the inverse of
-## SK_(recognised_suppression)().
+## TL_(recognised_suppression)().
Char*, get_error_name, Error* err
## This should print any extra info for the error, for --gen-suppressions,
## including the newline. This is the inverse of
-## SK_(read_extra_suppression_info)().
+## TL_(read_extra_suppression_info)().
void, print_extra_suppression_info, Error* err
@@ -154,8 +154,8 @@
## ---------------------------------------------------------------------
## VG_(needs).sanity_checks
-## Can be useful for ensuring a tool's correctness. SK_(cheap_sanity_check)
-## is called very frequently; SK_(expensive_sanity_check) is called less
+## Can be useful for ensuring a tool's correctness. TL_(cheap_sanity_check)
+## is called very frequently; TL_(expensive_sanity_check) is called less
## frequently and can be more involved.
Bool, cheap_sanity_check
Bool, expensive_sanity_check
diff --git a/coregrind/valgrind.vs b/coregrind/valgrind.vs
index a246684..30ded82 100644
--- a/coregrind/valgrind.vs
+++ b/coregrind/valgrind.vs
@@ -1,7 +1,7 @@
VALGRIND_2.1 {
global:
vgPlain_*;
- vgSkin_*;
+ vgTool_*;
vgProf_*;
vgOff_*;
vgArch_*;
diff --git a/coregrind/vg_default.c b/coregrind/vg_default.c
index daeaecd..967aa9d 100644
--- a/coregrind/vg_default.c
+++ b/coregrind/vg_default.c
@@ -76,10 +76,10 @@
scheduler, for the USERREQ__MALLOC user request used by vg_libpthread.c.
(Nb: it cannot call glibc's malloc().) The lock variable ensures that the
scheduler is the only place this can be called from; this ensures that a
- malloc()-replacing tool cannot forget to implement SK_(malloc)() or
- SK_(free)(). */
+ malloc()-replacing tool cannot forget to implement TL_(malloc)() or
+ TL_(free)(). */
__attribute__ ((weak))
-void* SK_(malloc)( SizeT size )
+void* TL_(malloc)( SizeT size )
{
if (VG_(sk_malloc_called_by_scheduler))
return VG_(cli_malloc)(VG_MIN_MALLOC_SZB, size);
@@ -88,9 +88,9 @@
}
__attribute__ ((weak))
-void SK_(free)( void* p )
+void TL_(free)( void* p )
{
- /* see comment for SK_(malloc)() above */
+ /* see comment for TL_(malloc)() above */
if (VG_(sk_malloc_called_by_scheduler))
VG_(cli_free)(p);
else
diff --git a/coregrind/vg_errcontext.c b/coregrind/vg_errcontext.c
index 4ba0272..cd4c225 100644
--- a/coregrind/vg_errcontext.c
+++ b/coregrind/vg_errcontext.c
@@ -214,7 +214,7 @@
return False;
default:
if (VG_(needs).tool_errors)
- return SK_(eq_Error)(res, e1, e2);
+ return TL_(eq_Error)(res, e1, e2);
else {
VG_(printf)("\nUnhandled error type: %u. VG_(needs).tool_errors\n"
"probably needs to be set.\n",
@@ -239,7 +239,7 @@
break;
default:
if (VG_(needs).tool_errors)
- SK_(pp_Error)( err );
+ TL_(pp_Error)( err );
else {
VG_(printf)("\nUnhandled error type: %u. VG_(needs).tool_errors\n"
"probably needs to be set?\n",
@@ -348,14 +348,14 @@
VG_(printf)(" core:PThread\n");
} else {
- Char* name = SK_(get_error_name)(err);
+ Char* name = TL_(get_error_name)(err);
if (NULL == name) {
VG_(message)(Vg_UserMsg,
"(tool does not allow error to be suppressed)");
return;
}
VG_(printf)(" %s:%s\n", VG_(details).name, name);
- SK_(print_extra_suppression_info)(err);
+ TL_(print_extra_suppression_info)(err);
}
/* This loop condensed from VG_(mini_stack_dump)() */
@@ -515,14 +515,14 @@
will disappear shortly, so we must copy it. First do the main
(non-`extra') part.
- Then SK_(update_extra) can update the `extra' part. This is for when
+ Then TL_(update_extra) can update the `extra' part. This is for when
there are more details to fill in which take time to work out but
don't affect our earlier decision to include the error -- by
postponing those details until now, we avoid the extra work in the
case where we ignore the error. Ugly.
Then, if there is an `extra' part, copy it too, using the size that
- SK_(update_extra) returned. Also allow for people using the void*
+ TL_(update_extra) returned. Also allow for people using the void*
extra field for a scalar value like an integer.
*/
@@ -532,7 +532,7 @@
/* update `extra', for non-core errors (core ones don't use 'extra') */
if (VG_(needs).tool_errors && PThreadErr != ekind) {
- extra_size = SK_(update_extra)(p);
+ extra_size = TL_(update_extra)(p);
/* copy block pointed to by `extra', if there is one */
if (NULL != p->extra && 0 != extra_size) {
@@ -578,10 +578,10 @@
/* Unless it's suppressed, we're going to show it. Don't need to make
a copy, because it's only temporary anyway.
- Then update the `extra' part with SK_(update_extra), because that can
+ Then update the `extra' part with TL_(update_extra), because that can
have an affect on whether it's suppressed. Ignore the size return
- value of SK_(update_extra), because we're not copying `extra'. */
- (void)SK_(update_extra)(&err);
+ value of TL_(update_extra), because we're not copying `extra'. */
+ (void)TL_(update_extra)(&err);
if (NULL == is_suppressible_error(&err)) {
if (count_error)
@@ -846,7 +846,7 @@
else if (VG_(needs).tool_errors &&
tool_name_present(VG_(details).name, tool_names))
{
- if (SK_(recognised_suppression)(supp_name, supp))
+ if (TL_(recognised_suppression)(supp_name, supp))
{
/* Do nothing, function fills in supp->skind */
} else
@@ -865,7 +865,7 @@
}
if (VG_(needs).tool_errors &&
- !SK_(read_extra_suppression_info)(fd, buf, N_BUF, supp))
+ !TL_(read_extra_suppression_info)(fd, buf, N_BUF, supp))
goto syntax_error;
/* "i > 0" ensures at least one caller read. */
@@ -957,7 +957,7 @@
return (err->ekind == PThreadErr);
default:
if (VG_(needs).tool_errors) {
- return SK_(error_matches_suppression)(err, su);
+ return TL_(error_matches_suppression)(err, su);
} else {
VG_(printf)(
"\nUnhandled suppression type: %u. VG_(needs).tool_errors\n"
diff --git a/coregrind/vg_from_ucode.c b/coregrind/vg_from_ucode.c
index 5f1fcc7..cf747cd 100644
--- a/coregrind/vg_from_ucode.c
+++ b/coregrind/vg_from_ucode.c
@@ -4427,7 +4427,7 @@
emit_put_sse_state();
*sselive = False;
}
- SK_(emit_XUInstr)(u, regs_live_before);
+ TL_(emit_XUInstr)(u, regs_live_before);
} else {
VG_(printf)("\nError:\n"
" unhandled opcode: %u. Perhaps "
diff --git a/coregrind/vg_main.c b/coregrind/vg_main.c
index 5a69316..b7797ea 100644
--- a/coregrind/vg_main.c
+++ b/coregrind/vg_main.c
@@ -1265,10 +1265,10 @@
goto bad_load;
}
- toolinfo = dlsym(handle, "vgSkin_tool_info");
+ toolinfo = dlsym(handle, "vgTool_tool_info");
ok = (NULL != toolinfo);
if (!ok) {
- fprintf(stderr, "Tool \"%s\" doesn't define SK_(tool_info) - "
+ fprintf(stderr, "Tool \"%s\" doesn't define TL_(tool_info) - "
"add VG_DETERMINE_INTERFACE_VERSION?\n", toolname);
goto bad_load;
}
@@ -1606,7 +1606,7 @@
if (VG_(details).name) {
VG_(printf)(" user options for %s:\n", VG_(details).name);
if (VG_(needs).command_line_options)
- SK_(print_usage)();
+ TL_(print_usage)();
else
VG_(printf)(" (none)\n");
}
@@ -1617,7 +1617,7 @@
VG_(printf)(" debugging options for %s:\n", VG_(details).name);
if (VG_(needs).command_line_options)
- SK_(print_debug_usage)();
+ TL_(print_debug_usage)();
else
VG_(printf)(" (none)\n");
}
@@ -1837,7 +1837,7 @@
VG_(clo_trace_pthread_level) = 2;
else if ( ! VG_(needs).command_line_options
- || ! SK_(process_cmd_line_option)(arg) ) {
+ || ! TL_(process_cmd_line_option)(arg) ) {
VG_(bad_option)(arg);
}
}
@@ -2428,7 +2428,7 @@
last 16 pages of memory have become accessible [...] */
if (VG_(needs).sanity_checks) {
VGP_PUSHCC(VgpToolCheapSanity);
- vg_assert(SK_(cheap_sanity_check)());
+ vg_assert(TL_(cheap_sanity_check)());
VGP_POPCC(VgpToolCheapSanity);
}
@@ -2453,7 +2453,7 @@
if (VG_(needs).sanity_checks) {
VGP_PUSHCC(VgpToolExpensiveSanity);
- vg_assert(SK_(expensive_sanity_check)());
+ vg_assert(TL_(expensive_sanity_check)());
VGP_POPCC(VgpToolExpensiveSanity);
}
/*
@@ -2726,7 +2726,7 @@
}
process_cmd_line_options(client_auxv, tool);
- SK_(post_clo_init)();
+ TL_(post_clo_init)();
//--------------------------------------------------------------
// Build segment map (all segments)
@@ -2881,7 +2881,7 @@
if (VG_(needs).core_errors || VG_(needs).tool_errors)
VG_(show_all_errors)();
- SK_(fini)( exitcode );
+ TL_(fini)( exitcode );
VG_(sanity_check_general)( True /*include expensive checks*/ );
diff --git a/coregrind/vg_needs.c b/coregrind/vg_needs.c
index 07a9342..cbf6fa4 100644
--- a/coregrind/vg_needs.c
+++ b/coregrind/vg_needs.c
@@ -121,7 +121,7 @@
else
VG_(printf)("\nTool error: tool didn't allocate shadow memory, but apparently "
"needs it.\n");
- VG_(tool_panic)("VG_(needs).shadow_memory need should be set to match SK_(shadow_ratio)\n");
+ VG_(tool_panic)("VG_(needs).shadow_memory need should be set to match TL_(shadow_ratio)\n");
}
#undef CHECK_NOT
diff --git a/coregrind/vg_replace_malloc.c.base b/coregrind/vg_replace_malloc.c.base
index ec8023f..10a5658 100644
--- a/coregrind/vg_replace_malloc.c.base
+++ b/coregrind/vg_replace_malloc.c.base
@@ -38,7 +38,7 @@
This file can be linked into the injected so file for any tool that
wishes to know about calls to malloc(). It should define functions
- SK_(malloc) et al that will be called.
+ TL_(malloc) et al that will be called.
------------------------------------------------------------------ */
#include "valgrind.h" /* for VALGRIND_NON_SIMD_CALL[12] */
diff --git a/coregrind/vg_scheduler.c b/coregrind/vg_scheduler.c
index d6e64fd..a986e2b 100644
--- a/coregrind/vg_scheduler.c
+++ b/coregrind/vg_scheduler.c
@@ -2933,23 +2933,23 @@
/* Note: for tools that replace malloc() et al, we want to call
the replacement versions. For those that don't, we want to call
- VG_(cli_malloc)() et al. We do this by calling SK_(malloc)(), which
+ VG_(cli_malloc)() et al. We do this by calling TL_(malloc)(), which
malloc-replacing tools must replace, but have the default definition
- of SK_(malloc)() call VG_(cli_malloc)(). */
+ of TL_(malloc)() call VG_(cli_malloc)(). */
/* Note: for MALLOC and FREE, must set the appropriate "lock"... see
- the comment in vg_defaults.c/SK_(malloc)() for why. */
+ the comment in vg_defaults.c/TL_(malloc)() for why. */
case VG_USERREQ__MALLOC:
VG_(sk_malloc_called_by_scheduler) = True;
SET_PTHREQ_RETVAL(
- tid, (Addr)SK_(malloc) ( arg[1] )
+ tid, (Addr)TL_(malloc) ( arg[1] )
);
VG_(sk_malloc_called_by_scheduler) = False;
break;
case VG_USERREQ__FREE:
VG_(sk_malloc_called_by_scheduler) = True;
- SK_(free) ( (void*)arg[1] );
+ TL_(free) ( (void*)arg[1] );
VG_(sk_malloc_called_by_scheduler) = False;
SET_PTHREQ_RETVAL(tid, 0); /* irrelevant */
break;
@@ -3190,15 +3190,15 @@
case VG_USERREQ__GET_MALLOCFUNCS: {
struct vg_mallocfunc_info *info = (struct vg_mallocfunc_info *)arg[1];
- info->sk_malloc = (Addr)SK_(malloc);
- info->sk_calloc = (Addr)SK_(calloc);
- info->sk_realloc = (Addr)SK_(realloc);
- info->sk_memalign = (Addr)SK_(memalign);
- info->sk___builtin_new = (Addr)SK_(__builtin_new);
- info->sk___builtin_vec_new = (Addr)SK_(__builtin_vec_new);
- info->sk_free = (Addr)SK_(free);
- info->sk___builtin_delete = (Addr)SK_(__builtin_delete);
- info->sk___builtin_vec_delete = (Addr)SK_(__builtin_vec_delete);
+ info->sk_malloc = (Addr)TL_(malloc);
+ info->sk_calloc = (Addr)TL_(calloc);
+ info->sk_realloc = (Addr)TL_(realloc);
+ info->sk_memalign = (Addr)TL_(memalign);
+ info->sk___builtin_new = (Addr)TL_(__builtin_new);
+ info->sk___builtin_vec_new = (Addr)TL_(__builtin_vec_new);
+ info->sk_free = (Addr)TL_(free);
+ info->sk___builtin_delete = (Addr)TL_(__builtin_delete);
+ info->sk___builtin_vec_delete = (Addr)TL_(__builtin_vec_delete);
info->arena_payload_szB = (Addr)VG_(arena_payload_szB);
@@ -3235,7 +3235,7 @@
VG_(printf)("client request: code %x, addr %p, len %d\n",
arg[0], (void*)arg[1], arg[2] );
- if (SK_(handle_client_request) ( tid, arg, &ret ))
+ if (TL_(handle_client_request) ( tid, arg, &ret ))
SET_CLREQ_RETVAL(tid, ret);
} else {
static Bool whined = False;
diff --git a/coregrind/vg_syscalls.c b/coregrind/vg_syscalls.c
index c2898f7..36ab595 100644
--- a/coregrind/vg_syscalls.c
+++ b/coregrind/vg_syscalls.c
@@ -858,7 +858,7 @@
if (VG_(defined_pre_mem_write)()) {
UInt buflen_in = deref_UInt( tid, buflen_p, buflen_s);
if (buflen_in > 0) {
- SK_(pre_mem_write) ( Vg_CoreSysCall,
+ TL_(pre_mem_write) ( Vg_CoreSysCall,
tid, buf_s, buf_p, buflen_in );
}
}
@@ -871,7 +871,7 @@
if (!VG_(is_kerror)(res) && VG_(defined_post_mem_write)()) {
UInt buflen_out = deref_UInt( tid, buflen_p, s);
if (buflen_out > 0 && buf_p != (Addr)NULL) {
- SK_(post_mem_write) ( buf_p, buflen_out );
+ TL_(post_mem_write) ( buf_p, buflen_out );
}
}
}
@@ -5794,7 +5794,7 @@
/* Do any pre-syscall actions */
if (VG_(needs).syscall_wrapper) {
VGP_PUSHCC(VgpToolSysWrap);
- tst->sys_pre_res = SK_(pre_syscall)(tid, syscallno, mayBlock);
+ tst->sys_pre_res = TL_(pre_syscall)(tid, syscallno, mayBlock);
VGP_POPCC(VgpToolSysWrap);
}
@@ -5927,7 +5927,7 @@
*/
if (VG_(needs).syscall_wrapper) {
VGP_PUSHCC(VgpToolSysWrap);
- SK_(post_syscall)(tid, syscallno, pre_res, res, /*isBlocking*/True); // did block
+ TL_(post_syscall)(tid, syscallno, pre_res, res, /*isBlocking*/True); // did block
VGP_POPCC(VgpToolSysWrap);
}
}
diff --git a/coregrind/vg_translate.c b/coregrind/vg_translate.c
index 264a9da..a652708 100644
--- a/coregrind/vg_translate.c
+++ b/coregrind/vg_translate.c
@@ -632,7 +632,7 @@
return SZ48 && CC0 && TR1 && TR2 && N3 && XOTHER;
default:
if (VG_(needs).extended_UCode)
- return SK_(sane_XUInstr)(beforeRA, beforeLiveness, u);
+ return TL_(sane_XUInstr)(beforeRA, beforeLiveness, u);
else {
VG_(printf)("unhandled opcode: %u. Perhaps "
"VG_(needs).extended_UCode should be set?",
@@ -989,7 +989,7 @@
case SSE3ag_MemRd_RegWr: return "SSE3ag_MemRd_RegWr";
default:
if (VG_(needs).extended_UCode)
- return SK_(name_XUOpcode)(opc);
+ return TL_(name_XUOpcode)(opc);
else {
VG_(printf)("unhandled opcode: %u. Perhaps "
"VG_(needs).extended_UCode should be set?",
@@ -1297,7 +1297,7 @@
default:
if (VG_(needs).extended_UCode)
- SK_(pp_XUInstr)(u);
+ TL_(pp_XUInstr)(u);
else {
VG_(printf)("unhandled opcode: %u. Perhaps "
"VG_(needs).extended_UCode should be set?",
@@ -1441,7 +1441,7 @@
default:
if (VG_(needs).extended_UCode)
- return SK_(get_Xreg_usage)(u, tag, regs, isWrites);
+ return TL_(get_Xreg_usage)(u, tag, regs, isWrites);
else {
VG_(printf)("unhandled opcode: %u. Perhaps "
"VG_(needs).extended_UCode should be set?",
@@ -2525,10 +2525,10 @@
}
/* Tool's instrumentation (Nb: must set VG_(print_codegen) in case
- SK_(instrument) looks at it. */
+ TL_(instrument) looks at it. */
VG_(print_codegen) = DECIDE_IF_PRINTING_CODEGEN_FOR_PHASE(3);
VGP_PUSHCC(VgpInstrument);
- cb = SK_(instrument) ( cb, orig_addr );
+ cb = TL_(instrument) ( cb, orig_addr );
if (VG_(print_codegen))
VG_(pp_UCodeBlock) ( cb, "Instrumented UCode:" );
sanity_check_UCodeBlock( cb );
diff --git a/coregrind/vg_transtab.c b/coregrind/vg_transtab.c
index eaca972..6849526 100644
--- a/coregrind/vg_transtab.c
+++ b/coregrind/vg_transtab.c
@@ -656,7 +656,7 @@
continue;
if (VG_(needs).basic_block_discards)
- SK_(discard_basic_block_info)( tce->orig_addr,
+ TL_(discard_basic_block_info)( tce->orig_addr,
tce->orig_size );
vg_tt[i].orig_addr = VG_TTE_DELETED;
diff --git a/helgrind/hg_main.c b/helgrind/hg_main.c
index 36015f9..a759eda 100644
--- a/helgrind/hg_main.c
+++ b/helgrind/hg_main.c
@@ -1655,7 +1655,7 @@
-- this could happen with buggy syscall wrappers. Today
(2001-04-26) had precisely such a problem with
__NR_setitimer. */
- tl_assert(SK_(cheap_sanity_check)());
+ tl_assert(TL_(cheap_sanity_check)());
VGP_POPCC(VgpSARP);
}
@@ -1842,27 +1842,27 @@
return (void*)p;
}
-void* SK_(malloc) ( SizeT n )
+void* TL_(malloc) ( SizeT n )
{
return alloc_and_new_mem ( n, VG_(clo_alignment), /*is_zeroed*/False );
}
-void* SK_(__builtin_new) ( SizeT n )
+void* TL_(__builtin_new) ( SizeT n )
{
return alloc_and_new_mem ( n, VG_(clo_alignment), /*is_zeroed*/False );
}
-void* SK_(__builtin_vec_new) ( SizeT n )
+void* TL_(__builtin_vec_new) ( SizeT n )
{
return alloc_and_new_mem ( n, VG_(clo_alignment), /*is_zeroed*/False );
}
-void* SK_(memalign) ( SizeT align, SizeT n )
+void* TL_(memalign) ( SizeT align, SizeT n )
{
return alloc_and_new_mem ( n, align, /*is_zeroed*/False );
}
-void* SK_(calloc) ( SizeT nmemb, SizeT size )
+void* TL_(calloc) ( SizeT nmemb, SizeT size )
{
return alloc_and_new_mem ( nmemb*size, VG_(clo_alignment),
/*is_zeroed*/True );
@@ -1929,22 +1929,22 @@
hc, prev_chunks_next_ptr );
}
-void SK_(free) ( void* p )
+void TL_(free) ( void* p )
{
handle_free(p);
}
-void SK_(__builtin_delete) ( void* p )
+void TL_(__builtin_delete) ( void* p )
{
handle_free(p);
}
-void SK_(__builtin_vec_delete) ( void* p )
+void TL_(__builtin_vec_delete) ( void* p )
{
handle_free(p);
}
-void* SK_(realloc) ( void* p, SizeT new_size )
+void* TL_(realloc) ( void* p, SizeT new_size )
{
HG_Chunk *hc;
HG_Chunk **prev_chunks_next_ptr;
@@ -2002,13 +2002,13 @@
/*--- Machinery to support sanity checking ---*/
/*--------------------------------------------------------------*/
-Bool SK_(cheap_sanity_check) ( void )
+Bool TL_(cheap_sanity_check) ( void )
{
/* nothing useful we can rapidly check */
return True;
}
-Bool SK_(expensive_sanity_check)(void)
+Bool TL_(expensive_sanity_check)(void)
{
Int i;
@@ -2030,7 +2030,7 @@
/* Create and return an instrumented version of cb_in. Free cb_in
before returning. */
-UCodeBlock* SK_(instrument) ( UCodeBlock* cb_in, Addr not_used )
+UCodeBlock* TL_(instrument) ( UCodeBlock* cb_in, Addr not_used )
{
UCodeBlock* cb;
Int i;
@@ -2462,7 +2462,7 @@
/* Updates the copy with address info if necessary. */
-UInt SK_(update_extra)(Error* err)
+UInt TL_(update_extra)(Error* err)
{
HelgrindError* extra;
@@ -2536,7 +2536,7 @@
VG_(maybe_record_error)(tid, LockGraphErr, mutex->mutexp, "", &err_extra);
}
-Bool SK_(eq_Error) ( VgRes not_used, Error* e1, Error* e2 )
+Bool TL_(eq_Error) ( VgRes not_used, Error* e1, Error* e2 )
{
Char *e1s, *e2s;
@@ -2645,7 +2645,7 @@
return buf;
}
-void SK_(pp_Error) ( Error* err )
+void TL_(pp_Error) ( Error* err )
{
HelgrindError *extra = (HelgrindError *)VG_(get_error_extra)(err);
Char buf[100];
@@ -2777,7 +2777,7 @@
}
-Bool SK_(recognised_suppression) ( Char* name, Supp *su )
+Bool TL_(recognised_suppression) ( Char* name, Supp *su )
{
if (0 == VG_(strcmp)(name, "Eraser")) {
VG_(set_supp_kind)(su, EraserSupp);
@@ -2788,7 +2788,7 @@
}
-Bool SK_(read_extra_suppression_info) ( Int fd, Char* buf, Int nBuf, Supp* su )
+Bool TL_(read_extra_suppression_info) ( Int fd, Char* buf, Int nBuf, Supp* su )
{
/* do nothing -- no extra suppression info present. Return True to
indicate nothing bad happened. */
@@ -2796,14 +2796,14 @@
}
-Bool SK_(error_matches_suppression)(Error* err, Supp* su)
+Bool TL_(error_matches_suppression)(Error* err, Supp* su)
{
tl_assert(VG_(get_supp_kind)(su) == EraserSupp);
return (VG_(get_error_kind)(err) == EraserErr);
}
-extern Char* SK_(get_error_name) ( Error* err )
+extern Char* TL_(get_error_name) ( Error* err )
{
if (EraserErr == VG_(get_error_kind)(err)) {
return "Eraser";
@@ -2812,7 +2812,7 @@
}
}
-extern void SK_(print_extra_suppression_info) ( Error* err )
+extern void TL_(print_extra_suppression_info) ( Error* err )
{
/* Do nothing */
}
@@ -3233,7 +3233,7 @@
/*--- Client requests ---*/
/*--------------------------------------------------------------------*/
-Bool SK_(handle_client_request)(ThreadId tid, UWord *args, UWord *ret)
+Bool TL_(handle_client_request)(ThreadId tid, UWord *args, UWord *ret)
{
if (!VG_IS_SKIN_USERREQ('H','G',args[0]))
return False;
@@ -3261,7 +3261,7 @@
/*--- Setup ---*/
/*--------------------------------------------------------------------*/
-void SK_(pre_clo_init)(void)
+void TL_(pre_clo_init)(void)
{
Int i;
LockSet *empty;
@@ -3340,7 +3340,7 @@
hg_malloc_list = VG_(HT_construct)();
}
-Bool SK_(process_cmd_line_option)(Char* arg)
+Bool TL_(process_cmd_line_option)(Char* arg)
{
if (VG_CLO_STREQ(arg, "--show-last-access=no"))
clo_execontext = EC_None;
@@ -3357,7 +3357,7 @@
return True;
}
-void SK_(print_usage)(void)
+void TL_(print_usage)(void)
{
VG_(printf)(
" --private-stacks=yes|no assume thread stacks are used privately [no]\n"
@@ -3367,12 +3367,12 @@
VG_(replacement_malloc_print_usage)();
}
-void SK_(print_debug_usage)(void)
+void TL_(print_debug_usage)(void)
{
VG_(replacement_malloc_print_debug_usage)();
}
-void SK_(post_clo_init)(void)
+void TL_(post_clo_init)(void)
{
void (*stack_tracker)(Addr a, SizeT len);
@@ -3391,7 +3391,7 @@
}
-void SK_(fini)(Int exitcode)
+void TL_(fini)(Int exitcode)
{
if (DEBUG_LOCK_TABLE) {
pp_all_LockSets();
@@ -3399,7 +3399,7 @@
}
if (LOCKSET_SANITY)
- sanity_check_locksets("SK_(fini)");
+ sanity_check_locksets("TL_(fini)");
if (VG_(clo_verbosity) > 0)
VG_(message)(Vg_UserMsg, "%u possible data races found; %u lock order problems",
@@ -3413,7 +3413,7 @@
}
/* Uses a 1:1 mapping */
-VG_DETERMINE_INTERFACE_VERSION(SK_(pre_clo_init), 1.0)
+VG_DETERMINE_INTERFACE_VERSION(TL_(pre_clo_init), 1.0)
/*--------------------------------------------------------------------*/
/*--- end hg_main.c ---*/
diff --git a/include/tool.h.base b/include/tool.h.base
index 747ec88..6feb534 100644
--- a/include/tool.h.base
+++ b/include/tool.h.base
@@ -111,7 +111,7 @@
/* Every tool must include this macro somewhere, exactly once. */
#define VG_DETERMINE_INTERFACE_VERSION(pre_clo_init, shadow) \
- const ToolInfo SK_(tool_info) = { \
+ const ToolInfo TL_(tool_info) = { \
.sizeof_ToolInfo = sizeof(ToolInfo), \
.interface_major_version = VG_CORE_INTERFACE_MAJOR_VERSION, \
.interface_minor_version = VG_CORE_INTERFACE_MINOR_VERSION, \
@@ -236,9 +236,9 @@
VGP_PAIR(VgpPreCloInit, "pre-clo-init"), \
VGP_PAIR(VgpPostCloInit, "post-clo-init"), \
VGP_PAIR(VgpInstrument, "instrument"), \
- VGP_PAIR(VgpSkinSysWrap, "tool-syscall-wrapper"), \
- VGP_PAIR(VgpSkinCheapSanity, "tool-cheap-sanity"), \
- VGP_PAIR(VgpSkinExpensiveSanity, "tool-expensive-sanity"), \
+ VGP_PAIR(VgpToolSysWrap, "tool-syscall-wrapper"), \
+ VGP_PAIR(VgpToolCheapSanity, "tool-cheap-sanity"), \
+ VGP_PAIR(VgpToolExpensiveSanity, "tool-expensive-sanity"), \
VGP_PAIR(VgpFini, "fini")
#define VGP_PAIR(n,name) n
@@ -1432,7 +1432,7 @@
struct _Supp
Supp;
-/* Useful in SK_(error_matches_suppression)() */
+/* Useful in TL_(error_matches_suppression)() */
SuppKind VG_(get_supp_kind) ( Supp* su );
Char* VG_(get_supp_string) ( Supp* su );
void* VG_(get_supp_extra) ( Supp* su );
@@ -1465,7 +1465,7 @@
struct _Error
Error;
-/* Useful in SK_(error_matches_suppression)(), SK_(pp_Error)(), etc */
+/* Useful in TL_(error_matches_suppression)(), TL_(pp_Error)(), etc */
ExeContext* VG_(get_error_where) ( Error* err );
SuppKind VG_(get_error_kind) ( Error* err );
Addr VG_(get_error_address) ( Error* err );
@@ -1716,12 +1716,12 @@
/* Nb: make sure the shadow_regs 'need' is set before using these! */
/* This one lets you override the shadow of the return value register for a
- syscall. Call it from SK_(post_syscall)() (not SK_(pre_syscall)()!) to
+ syscall. Call it from TL_(post_syscall)() (not TL_(pre_syscall)()!) to
override the default shadow register value. */
extern void VG_(set_return_from_syscall_shadow) ( ThreadId tid,
UInt ret_shadow );
-/* This can be called from SK_(fini)() to find the shadow of the argument
+/* This can be called from TL_(fini)() to find the shadow of the argument
to exit(), ie. the shadow of the program's return value. */
extern UInt VG_(get_exit_status_shadow) ( void );
@@ -1740,11 +1740,11 @@
UInt VG_(vg_malloc_redzone_szB) = 4;
- It can't be done from a function like SK_(pre_clo_init)(). So it can't,
+ It can't be done from a function like TL_(pre_clo_init)(). So it can't,
for example, be controlled with a command line option, unfortunately. */
extern UInt VG_(vg_malloc_redzone_szB);
-/* Can be called from SK_(malloc) et al to do the actual alloc/freeing. */
+/* Can be called from TL_(malloc) et al to do the actual alloc/freeing. */
extern void* VG_(cli_malloc) ( SizeT align, SizeT nbytes );
extern void VG_(cli_free) ( void* p );
@@ -1854,11 +1854,11 @@
extern void VG_(needs_data_syms) ( void );
/* Does the tool need shadow memory allocated (if you set this, you must also statically initialize
- float SK_(shadow_ratio) = n./m;
+ float TL_(shadow_ratio) = n./m;
to define how many shadow bits you need per client address space bit.
*/
extern void VG_(needs_shadow_memory)( void );
-extern float SK_(shadow_ratio);
+extern float TL_(shadow_ratio);
/* ------------------------------------------------------------------ */
/* Core events to track */
diff --git a/include/tool_asm.h b/include/tool_asm.h
index 9e0ea2a..db36a85 100644
--- a/include/tool_asm.h
+++ b/include/tool_asm.h
@@ -46,7 +46,7 @@
#define VGA_(str) VGAPPEND(vgArch_,str)
/* Tool-specific ones. Note that final name still starts with "vg". */
-#define SK_(str) VGAPPEND(vgSkin_,str)
+#define TL_(str) VGAPPEND(vgTool_,str)
/* This is specifically for stringifying VG_(x) function names. We
need to do two macroexpansions to get the VG_ macro expanded before
diff --git a/lackey/lk_main.c b/lackey/lk_main.c
index 3eb4457..540cd09 100644
--- a/lackey/lk_main.c
+++ b/lackey/lk_main.c
@@ -44,7 +44,7 @@
n_dlrr_calls++;
}
-/* See comment above SK_(instrument) for reason why n_machine_instrs is
+/* See comment above TL_(instrument) for reason why n_machine_instrs is
incremented here. */
static void add_one_BB(void)
{
@@ -72,7 +72,7 @@
n_Jccs_untaken++;
}
-void SK_(pre_clo_init)(void)
+void TL_(pre_clo_init)(void)
{
VG_(details_name) ("Lackey");
VG_(details_version) (NULL);
@@ -90,7 +90,7 @@
VG_(register_compact_helper)((Addr) & add_one_Jcc_untaken);
}
-void SK_(post_clo_init)(void)
+void TL_(post_clo_init)(void)
{
}
@@ -136,7 +136,7 @@
Which gives us the right answer. And just to avoid two C calls, we fold
the basic-block-beginning call in with add_one_BB(). Phew.
*/
-UCodeBlock* SK_(instrument)(UCodeBlock* cb_in, Addr orig_addr)
+UCodeBlock* TL_(instrument)(UCodeBlock* cb_in, Addr orig_addr)
{
UCodeBlock* cb;
Int i;
@@ -192,7 +192,7 @@
return cb;
}
-void SK_(fini)(Int exitcode)
+void TL_(fini)(Int exitcode)
{
VG_(message)(Vg_UserMsg,
"Counted %d calls to _dl_runtime_resolve()", n_dlrr_calls);
@@ -222,7 +222,7 @@
VG_(message)(Vg_UserMsg, "Exit code: %d", exitcode);
}
-VG_DETERMINE_INTERFACE_VERSION(SK_(pre_clo_init), 0)
+VG_DETERMINE_INTERFACE_VERSION(TL_(pre_clo_init), 0)
/*--------------------------------------------------------------------*/
diff --git a/massif/ms_main.c b/massif/ms_main.c
index 1cd5d5f..6b3770a 100644
--- a/massif/ms_main.c
+++ b/massif/ms_main.c
@@ -288,7 +288,7 @@
static Bool clo_depth = 3;
static XFormat clo_format = XText;
-Bool SK_(process_cmd_line_option)(Char* arg)
+Bool TL_(process_cmd_line_option)(Char* arg)
{
VG_BOOL_CLO("--heap", clo_heap)
else VG_BOOL_CLO("--stacks", clo_stacks)
@@ -316,7 +316,7 @@
return True;
}
-void SK_(print_usage)(void)
+void TL_(print_usage)(void)
{
VG_(printf)(
" --heap=no|yes profile heap blocks [yes]\n"
@@ -329,7 +329,7 @@
VG_(replacement_malloc_print_usage)();
}
-void SK_(print_debug_usage)(void)
+void TL_(print_debug_usage)(void)
{
VG_(replacement_malloc_print_debug_usage)();
}
@@ -738,47 +738,47 @@
}
-void* SK_(malloc) ( SizeT n )
+void* TL_(malloc) ( SizeT n )
{
return new_block( NULL, n, VG_(clo_alignment), /*is_zeroed*/False );
}
-void* SK_(__builtin_new) ( SizeT n )
+void* TL_(__builtin_new) ( SizeT n )
{
return new_block( NULL, n, VG_(clo_alignment), /*is_zeroed*/False );
}
-void* SK_(__builtin_vec_new) ( SizeT n )
+void* TL_(__builtin_vec_new) ( SizeT n )
{
return new_block( NULL, n, VG_(clo_alignment), /*is_zeroed*/False );
}
-void* SK_(calloc) ( SizeT m, SizeT size )
+void* TL_(calloc) ( SizeT m, SizeT size )
{
return new_block( NULL, m*size, VG_(clo_alignment), /*is_zeroed*/True );
}
-void *SK_(memalign)( SizeT align, SizeT n )
+void *TL_(memalign)( SizeT align, SizeT n )
{
return new_block( NULL, n, align, False );
}
-void SK_(free) ( void* p )
+void TL_(free) ( void* p )
{
die_block( p, /*custom_free*/False );
}
-void SK_(__builtin_delete) ( void* p )
+void TL_(__builtin_delete) ( void* p )
{
die_block( p, /*custom_free*/False);
}
-void SK_(__builtin_vec_delete) ( void* p )
+void TL_(__builtin_vec_delete) ( void* p )
{
die_block( p, /*custom_free*/False );
}
-void* SK_(realloc) ( void* p_old, SizeT new_size )
+void* TL_(realloc) ( void* p_old, SizeT new_size )
{
HP_Chunk* hc;
HP_Chunk** remove_handle;
@@ -1128,7 +1128,7 @@
/*--- Client Requests ---*/
/*------------------------------------------------------------*/
-Bool SK_(handle_client_request) ( ThreadId tid, UWord* argv, UWord* ret )
+Bool TL_(handle_client_request) ( ThreadId tid, UWord* argv, UWord* ret )
{
switch (argv[0]) {
case VG_USERREQ__MALLOCLIKE_BLOCK: {
@@ -1161,7 +1161,7 @@
UInt VG_(vg_malloc_redzone_szB) = 0;
-void SK_(pre_clo_init)()
+void TL_(pre_clo_init)()
{
VG_(details_name) ("Massif");
VG_(details_version) (NULL);
@@ -1199,7 +1199,7 @@
tl_assert( VG_(getcwd_alloc)(&base_dir) );
}
-void SK_(post_clo_init)(void)
+void TL_(post_clo_init)(void)
{
ms_interval = 1;
@@ -1211,7 +1211,7 @@
/*--- Instrumentation ---*/
/*------------------------------------------------------------*/
-UCodeBlock* SK_(instrument)(UCodeBlock* cb_in, Addr orig_addr)
+UCodeBlock* TL_(instrument)(UCodeBlock* cb_in, Addr orig_addr)
{
return cb_in;
}
@@ -1792,7 +1792,7 @@
}
}
-void SK_(fini)(Int exit_status)
+void TL_(fini)(Int exit_status)
{
ULong total_ST = 0;
ULong heap_ST = 0;
@@ -1810,7 +1810,7 @@
print_summary ( total_ST, heap_ST, heap_admin_ST, stack_ST );
}
-VG_DETERMINE_INTERFACE_VERSION(SK_(pre_clo_init), 0)
+VG_DETERMINE_INTERFACE_VERSION(TL_(pre_clo_init), 0)
/*--------------------------------------------------------------------*/
/*--- end ms_main.c ---*/
diff --git a/memcheck/mac_malloc_wrappers.c b/memcheck/mac_malloc_wrappers.c
index 0bbe1a0..1cc3575 100644
--- a/memcheck/mac_malloc_wrappers.c
+++ b/memcheck/mac_malloc_wrappers.c
@@ -213,7 +213,7 @@
return (void*)p;
}
-void* SK_(malloc) ( SizeT n )
+void* TL_(malloc) ( SizeT n )
{
if (complain_about_silly_args(n, "malloc")) {
return NULL;
@@ -224,7 +224,7 @@
}
}
-void* SK_(__builtin_new) ( SizeT n )
+void* TL_(__builtin_new) ( SizeT n )
{
if (complain_about_silly_args(n, "__builtin_new")) {
return NULL;
@@ -235,7 +235,7 @@
}
}
-void* SK_(__builtin_vec_new) ( SizeT n )
+void* TL_(__builtin_vec_new) ( SizeT n )
{
if (complain_about_silly_args(n, "__builtin_vec_new")) {
return NULL;
@@ -246,7 +246,7 @@
}
}
-void* SK_(memalign) ( SizeT align, SizeT n )
+void* TL_(memalign) ( SizeT align, SizeT n )
{
if (complain_about_silly_args(n, "memalign")) {
return NULL;
@@ -257,7 +257,7 @@
}
}
-void* SK_(calloc) ( SizeT nmemb, SizeT size1 )
+void* TL_(calloc) ( SizeT nmemb, SizeT size1 )
{
if (complain_about_silly_args2(nmemb, size1)) {
return NULL;
@@ -321,22 +321,22 @@
VGP_POPCC(VgpCliMalloc);
}
-void SK_(free) ( void* p )
+void TL_(free) ( void* p )
{
MAC_(handle_free)((Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocMalloc);
}
-void SK_(__builtin_delete) ( void* p )
+void TL_(__builtin_delete) ( void* p )
{
MAC_(handle_free)((Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocNew);
}
-void SK_(__builtin_vec_delete) ( void* p )
+void TL_(__builtin_vec_delete) ( void* p )
{
MAC_(handle_free)((Addr)p, VG_(vg_malloc_redzone_szB), MAC_AllocNewVec);
}
-void* SK_(realloc) ( void* p, SizeT new_size )
+void* TL_(realloc) ( void* p, SizeT new_size )
{
MAC_Chunk *mc;
MAC_Chunk **prev_chunks_next_ptr;
diff --git a/memcheck/mac_needs.c b/memcheck/mac_needs.c
index 753f602..d6d431d 100644
--- a/memcheck/mac_needs.c
+++ b/memcheck/mac_needs.c
@@ -137,7 +137,7 @@
are otherwise the same, the faulting addrs and associated rwoffsets
are allowed to be different. */
-Bool SK_(eq_Error) ( VgRes res, Error* e1, Error* e2 )
+Bool TL_(eq_Error) ( VgRes res, Error* e1, Error* e2 )
{
MAC_Error* e1_extra = VG_(get_error_extra)(e1);
MAC_Error* e2_extra = VG_(get_error_extra)(e2);
@@ -193,7 +193,7 @@
return True;
case LeakErr:
- VG_(tool_panic)("Shouldn't get LeakErr in SK_(eq_Error),\n"
+ VG_(tool_panic)("Shouldn't get LeakErr in TL_(eq_Error),\n"
"since it's handled with VG_(unique_error)()!");
case IllegalMempoolErr:
@@ -202,7 +202,7 @@
default:
VG_(printf)("Error:\n unknown error code %d\n",
VG_(get_error_kind)(e1));
- VG_(tool_panic)("unknown error code in SK_(eq_Error)");
+ VG_(tool_panic)("unknown error code in TL_(eq_Error)");
}
}
@@ -297,7 +297,7 @@
"stated on the next line");
break;
default:
- VG_(tool_panic)("SK_(pp_shared_Error)(axskind)");
+ VG_(tool_panic)("TL_(pp_shared_Error)(axskind)");
}
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
MAC_(pp_AddrInfo)(VG_(get_error_address)(err), &err_extra->addrinfo);
@@ -522,7 +522,7 @@
/* Updates the copy with address info if necessary (but not for all errors). */
-UInt SK_(update_extra)( Error* err )
+UInt TL_(update_extra)( Error* err )
{
switch (VG_(get_error_kind)(err)) {
case ValueErr:
@@ -574,7 +574,7 @@
return True;
}
-Bool SK_(read_extra_suppression_info) ( Int fd, Char* buf, Int nBuf, Supp *su )
+Bool TL_(read_extra_suppression_info) ( Int fd, Char* buf, Int nBuf, Supp *su )
{
Bool eof;
@@ -586,7 +586,7 @@
return True;
}
-Bool SK_(error_matches_suppression)(Error* err, Supp* su)
+Bool TL_(error_matches_suppression)(Error* err, Supp* su)
{
Int su_size;
MAC_Error* err_extra = VG_(get_error_extra)(err);
@@ -637,11 +637,11 @@
" unknown suppression type %d\n",
VG_(get_supp_kind)(su));
VG_(tool_panic)("unknown suppression type in "
- "SK_(error_matches_suppression)");
+ "TL_(error_matches_suppression)");
}
}
-Char* SK_(get_error_name) ( Error* err )
+Char* TL_(get_error_name) ( Error* err )
{
Char* s;
switch (VG_(get_error_kind)(err)) {
@@ -678,7 +678,7 @@
VG_(printf)(s);
}
-void SK_(print_extra_suppression_info) ( Error* err )
+void TL_(print_extra_suppression_info) ( Error* err )
{
if (ParamErr == VG_(get_error_kind)(err)) {
VG_(printf)(" %s\n", VG_(get_error_string)(err));
@@ -941,17 +941,17 @@
/*--- Syscall wrappers ---*/
/*------------------------------------------------------------*/
-void* SK_(pre_syscall) ( ThreadId tid, UInt syscallno, Bool isBlocking )
+void* TL_(pre_syscall) ( ThreadId tid, UInt syscallno, Bool isBlocking )
{
- Int sane = SK_(cheap_sanity_check)();
+ Int sane = TL_(cheap_sanity_check)();
return (void*)sane;
}
-void SK_(post_syscall) ( ThreadId tid, UInt syscallno,
+void TL_(post_syscall) ( ThreadId tid, UInt syscallno,
void* pre_result, Int res, Bool isBlocking )
{
Int sane_before_call = (Int)pre_result;
- Bool sane_after_call = SK_(cheap_sanity_check)();
+ Bool sane_after_call = TL_(cheap_sanity_check)();
if ((Int)sane_before_call && (!sane_after_call)) {
VG_(message)(Vg_DebugMsg, "post-syscall: ");
diff --git a/memcheck/mc_errcontext.c b/memcheck/mc_errcontext.c
index 9c2e43c..9fc2b6a 100644
--- a/memcheck/mc_errcontext.c
+++ b/memcheck/mc_errcontext.c
@@ -35,7 +35,7 @@
/*--- Printing errors ---*/
/*------------------------------------------------------------*/
-void SK_(pp_Error) ( Error* err )
+void TL_(pp_Error) ( Error* err )
{
MAC_Error* err_extra = VG_(get_error_extra)(err);
@@ -125,7 +125,7 @@
/*--- Suppressions ---*/
/*------------------------------------------------------------*/
-Bool SK_(recognised_suppression) ( Char* name, Supp* su )
+Bool TL_(recognised_suppression) ( Char* name, Supp* su )
{
SuppKind skind;
diff --git a/memcheck/mc_from_ucode.c b/memcheck/mc_from_ucode.c
index 7b7aa07..0680eff 100644
--- a/memcheck/mc_from_ucode.c
+++ b/memcheck/mc_from_ucode.c
@@ -583,7 +583,7 @@
/*--- Generate code for a single UInstr. ---*/
/*----------------------------------------------------*/
-void SK_(emit_XUInstr) ( UInstr* u, RRegSet regs_live_before )
+void TL_(emit_XUInstr) ( UInstr* u, RRegSet regs_live_before )
{
switch (u->opcode) {
diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c
index 1e78611..8d90ecc 100644
--- a/memcheck/mc_main.c
+++ b/memcheck/mc_main.c
@@ -383,7 +383,7 @@
/* Check that zero page and highest page have not been written to
-- this could happen with buggy syscall wrappers. Today
(2001-04-26) had precisely such a problem with __NR_setitimer. */
- tl_assert(SK_(cheap_sanity_check)());
+ tl_assert(TL_(cheap_sanity_check)());
VGP_POPCC(VgpSetMem);
}
@@ -1508,13 +1508,13 @@
Sanity check machinery (permanently engaged).
------------------------------------------------------------------ */
-Bool SK_(cheap_sanity_check) ( void )
+Bool TL_(cheap_sanity_check) ( void )
{
/* nothing useful we can rapidly check */
return True;
}
-Bool SK_(expensive_sanity_check) ( void )
+Bool TL_(expensive_sanity_check) ( void )
{
Int i;
@@ -1637,7 +1637,7 @@
Bool MC_(clo_avoid_strlen_errors) = True;
Bool MC_(clo_cleanup) = True;
-Bool SK_(process_cmd_line_option)(Char* arg)
+Bool TL_(process_cmd_line_option)(Char* arg)
{
VG_BOOL_CLO("--avoid-strlen-errors", MC_(clo_avoid_strlen_errors))
else VG_BOOL_CLO("--cleanup", MC_(clo_cleanup))
@@ -1647,7 +1647,7 @@
return True;
}
-void SK_(print_usage)(void)
+void TL_(print_usage)(void)
{
MAC_(print_common_usage)();
VG_(printf)(
@@ -1655,7 +1655,7 @@
);
}
-void SK_(print_debug_usage)(void)
+void TL_(print_debug_usage)(void)
{
MAC_(print_common_debug_usage)();
VG_(printf)(
@@ -1803,7 +1803,7 @@
return False;
}
-Bool SK_(handle_client_request) ( ThreadId tid, UWord* arg, UWord* ret )
+Bool TL_(handle_client_request) ( ThreadId tid, UWord* arg, UWord* ret )
{
Int i;
Bool ok;
@@ -1919,7 +1919,7 @@
/*--- Setup ---*/
/*------------------------------------------------------------*/
-void SK_(pre_clo_init)(void)
+void TL_(pre_clo_init)(void)
{
VG_(details_name) ("Memcheck");
VG_(details_version) (NULL);
@@ -2015,11 +2015,11 @@
MAC_(common_pre_clo_init)();
}
-void SK_(post_clo_init) ( void )
+void TL_(post_clo_init) ( void )
{
}
-void SK_(fini) ( Int exitcode )
+void TL_(fini) ( Int exitcode )
{
MAC_(common_fini)( mc_detect_memory_leaks );
@@ -2030,7 +2030,7 @@
}
}
-VG_DETERMINE_INTERFACE_VERSION(SK_(pre_clo_init), 9./8)
+VG_DETERMINE_INTERFACE_VERSION(TL_(pre_clo_init), 9./8)
/*--------------------------------------------------------------------*/
/*--- end mc_main.c ---*/
diff --git a/memcheck/mc_translate.c b/memcheck/mc_translate.c
index 6a815c9..8d03ed7 100644
--- a/memcheck/mc_translate.c
+++ b/memcheck/mc_translate.c
@@ -39,7 +39,7 @@
vg_translate.c:is_sane_UInstr(). Everything general said there
applies here too.
*/
-Bool SK_(sane_XUInstr)(Bool beforeRA, Bool beforeLiveness, UInstr* u)
+Bool TL_(sane_XUInstr)(Bool beforeRA, Bool beforeLiveness, UInstr* u)
{
// SSS: duplicating these macros really sucks
# define LIT0 (u->lit32 == 0)
@@ -93,7 +93,7 @@
case TAG2: return LIT0 && SZ0 && CC0 && TR1 && TR2 && Ls3 && XOTHER;
default:
VG_(printf)("unhandled opcode: %u\n", u->opcode);
- VG_(tool_panic)("SK_(sane_XUInstr): unhandled opcode");
+ VG_(tool_panic)("TL_(sane_XUInstr): unhandled opcode");
}
# undef LIT0
# undef LIT1
@@ -159,7 +159,7 @@
}
-Char* SK_(name_XUOpcode)(Opcode opc)
+Char* TL_(name_XUOpcode)(Opcode opc)
{
switch (opc) {
case GETVF: return "GETVF";
@@ -174,7 +174,7 @@
case SETV: return "SETV";
default:
VG_(printf)("unhandled opcode: %u\n", opc);
- VG_(tool_panic)("SK_(name_XUOpcode): unhandled case");
+ VG_(tool_panic)("TL_(name_XUOpcode): unhandled case");
}
}
@@ -182,7 +182,7 @@
Debugging stuff.
------------------------------------------------------------------ */
-void SK_(pp_XUInstr)(UInstr* u)
+void TL_(pp_XUInstr)(UInstr* u)
{
switch (u->opcode) {
case TAG1:
@@ -223,12 +223,12 @@
default:
VG_(printf)("unhandled opcode: %u\n", u->opcode);
- VG_(tool_panic)("SK_(pp_XUInstr): unhandled opcode");
+ VG_(tool_panic)("TL_(pp_XUInstr): unhandled opcode");
}
}
-Int SK_(get_Xreg_usage)(UInstr* u, Tag tag, Int* regs, Bool* isWrites)
+Int TL_(get_Xreg_usage)(UInstr* u, Tag tag, Int* regs, Bool* isWrites)
{
# define RD(ono) VG_UINSTR_READS_REG(ono, regs, isWrites)
# define WR(ono) VG_UINSTR_WRITES_REG(ono, regs, isWrites)
@@ -248,7 +248,7 @@
default:
VG_(printf)("unhandled opcode: %u\n", u->opcode);
- VG_(tool_panic)("SK_(get_Xreg_usage): unhandled opcode");
+ VG_(tool_panic)("TL_(get_Xreg_usage): unhandled opcode");
}
return n;
@@ -1638,7 +1638,7 @@
/* Caller will print out final instrumented code if necessary; we
print out intermediate instrumented code here if necessary. */
-UCodeBlock* SK_(instrument) ( UCodeBlock* cb, Addr not_used )
+UCodeBlock* TL_(instrument) ( UCodeBlock* cb, Addr not_used )
{
cb = memcheck_instrument ( cb );
if (MC_(clo_cleanup)) {
diff --git a/none/nl_main.c b/none/nl_main.c
index f9b2f46..1210ff4 100644
--- a/none/nl_main.c
+++ b/none/nl_main.c
@@ -30,7 +30,7 @@
#include "tool.h"
-void SK_(pre_clo_init)(void)
+void TL_(pre_clo_init)(void)
{
VG_(details_name) ("Nulgrind");
VG_(details_version) (NULL);
@@ -42,20 +42,20 @@
/* No needs, no core events to track */
}
-void SK_(post_clo_init)(void)
+void TL_(post_clo_init)(void)
{
}
-UCodeBlock* SK_(instrument)(UCodeBlock* cb, Addr a)
+UCodeBlock* TL_(instrument)(UCodeBlock* cb, Addr a)
{
return cb;
}
-void SK_(fini)(Int exitcode)
+void TL_(fini)(Int exitcode)
{
}
-VG_DETERMINE_INTERFACE_VERSION(SK_(pre_clo_init), 0)
+VG_DETERMINE_INTERFACE_VERSION(TL_(pre_clo_init), 0)
/*--------------------------------------------------------------------*/
/*--- end ---*/