From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 3 Aug 2004 13:29:09 +0000 (+0000)
Subject: Comment changes only: s/skin/tool/
X-Git-Tag: svn/VALGRIND_2_2_0~81
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=38ff4e69d115a4ba70a2dc24dc26bacd2398f7ed;p=thirdparty%2Fvalgrind.git

Comment changes only: s/skin/tool/


git-svn-id: svn://svn.valgrind.org/valgrind/trunk@2555
---

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