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/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;