Renamed VG_(skin_panic) as VG_(tool_panic).

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

diff --git a/addrcheck/ac_main.c b/addrcheck/ac_main.c
index b2020c998451005238152ae23a9bde289810a0ea..51f931af14df974b4a5e7cb40bdefe93f9ee2757 100644 (file)
--- a/addrcheck/ac_main.c
+++ b/addrcheck/ac_main.c
@@ -564,7 +564,7 @@ void ac_check_is_accessible ( CorePart part, ThreadId tid,
          break;
 
       default:
-         VG_(skin_panic)("ac_check_is_accessible: unexpected CorePart");
+         VG_(tool_panic)("ac_check_is_accessible: unexpected CorePart");
       }
    }
 
@@ -908,7 +908,7 @@ void ac_fpu_ACCESS_check ( Addr addr, SizeT size, Bool isWrite )
    }
 
    VG_(printf)("size is %d\n", size);
-   VG_(skin_panic)("fpu_ACCESS_check: unhandled size");
+   VG_(tool_panic)("fpu_ACCESS_check: unhandled size");
 #  endif
 }
 
@@ -979,7 +979,7 @@ UCodeBlock* SK_(instrument)(UCodeBlock* cb_in, Addr orig_addr)
                case 4:  helper = (Addr)ac_helperc_LOAD4; break;
                case 2:  helper = (Addr)ac_helperc_LOAD2; break;
                case 1:  helper = (Addr)ac_helperc_LOAD1; break;
-               default: VG_(skin_panic)
+               default: VG_(tool_panic)
                            ("addrcheck::SK_(instrument):LOAD");
             }
             uInstr1(cb, CCALL, 0, TempReg, u_in->val1);
@@ -992,7 +992,7 @@ UCodeBlock* SK_(instrument)(UCodeBlock* cb_in, Addr orig_addr)
                case 4:  helper = (Addr)ac_helperc_STORE4; break;
                case 2:  helper = (Addr)ac_helperc_STORE2; break;
                case 1:  helper = (Addr)ac_helperc_STORE1; break;
-               default: VG_(skin_panic)
+               default: VG_(tool_panic)
                            ("addrcheck::SK_(instrument):STORE");
             }
             uInstr1(cb, CCALL, 0, TempReg, u_in->val2);

diff --git a/cachegrind/cg_main.c b/cachegrind/cg_main.c
index f795dc4efe5d602446d1904c8992816196cd8eb8..983260531f9bad66c2b4ad06930d934b3e8020b9 100644 (file)
--- a/cachegrind/cg_main.c
+++ b/cachegrind/cg_main.c
@@ -486,7 +486,7 @@ void end_of_x86_instr(UCodeBlock* cb, instr_info* i_node, Bool bb_seen_before,
                             TempReg, t_data_addr1,
                             TempReg, t_data_addr2);
    else
-      VG_(skin_panic)("argc... not 1 or 2 or 3?");
+      VG_(tool_panic)("argc... not 1 or 2 or 3?");
 
    uCCall(cb, helper, argc, argc, False);
 }

diff --git a/cachegrind/cg_sim.c b/cachegrind/cg_sim.c
index 5d42c1ba4a0dc93d9811960d38eb94e1d3d16ec3..bc849dbf995d81235db960c8e58d78e542667a31 100644 (file)
--- a/cachegrind/cg_sim.c
+++ b/cachegrind/cg_sim.c
@@ -195,7 +195,7 @@ miss_treatment:                                                             \
                                                                             \
    } else {                                                                 \
        VG_(printf)("addr: %x  size: %u  sets: %d %d", a, size, set1, set2); \
-       VG_(skin_panic)("item straddles more than two cache sets");          \
+       VG_(tool_panic)("item straddles more than two cache sets");          \
    }                                                                        \
    return;                                                                  \
 }

diff --git a/cachegrind/x86/cg_arch.c b/cachegrind/x86/cg_arch.c
index 13d01ebc73e10cccd1bd87462121cdaebd80f875..7d6cafa09a7355b30d1a1aeca8bee22514ca8dd8 100644 (file)
--- a/cachegrind/x86/cg_arch.c
+++ b/cachegrind/x86/cg_arch.c
@@ -100,7 +100,7 @@ Int Intel_cache_info(Int level, cache_t* I1c, cache_t* D1c, cache_t* L2c)
       case 0x10: case 0x15: case 0x1a: 
       case 0x88: case 0x89: case 0x8a: case 0x8d:
       case 0x90: case 0x96: case 0x9b:
-         VG_(skin_panic)("IA-64 cache detected?!");
+         VG_(tool_panic)("IA-64 cache detected?!");
 
       case 0x22: case 0x23: case 0x25: case 0x29: 
           VG_(message)(Vg_DebugMsg, 

diff --git a/coregrind/docs/coregrind_tools.html b/coregrind/docs/coregrind_tools.html
index 5aa335d463f0807013939c1528583200afef7dee..34b07ba3f9851d3ff1aeeb39b0c4102fa04f9e90 100644 (file)
--- a/coregrind/docs/coregrind_tools.html
+++ b/coregrind/docs/coregrind_tools.html
@@ -446,7 +446,7 @@ options and must do some initialisation after option processing takes place
 First of all, various ``details'' need to be set for a tool, using the
 functions <code>VG_(details_*)()</code>.  Some are all compulsory, some aren't. 
 Some are used when constructing the startup message,
-<code>detail_bug_reports_to</code> is used if <code>VG_(skin_panic)()</code> is
+<code>detail_bug_reports_to</code> is used if <code>VG_(tool_panic)()</code> is
 ever called, or a tool assertion fails.  Others have other uses.<p>
 
 Second, various ``needs'' can be set for a tool, using the functions

diff --git a/coregrind/vg_default.c b/coregrind/vg_default.c
index de6e222b1e3dd452d21f827c0b392ccf5fff84af..daeaecd6be3ffae64b89d844c1739dbc220d9be5 100644 (file)
--- a/coregrind/vg_default.c
+++ b/coregrind/vg_default.c
@@ -48,7 +48,7 @@ void VG_(missing_tool_func) ( const Char* fn )
       "  The tool you have selected is missing the function `%s',\n"
       "  which is required.\n\n",
       fn);
-   VG_(skin_panic)("Missing tool function");
+   VG_(tool_panic)("Missing tool function");
 }
 
 static __attribute__ ((noreturn))
@@ -59,7 +59,7 @@ void malloc_panic ( const Char* fn )
       "  The tool you have selected is missing the function `%s'\n"
       "  required because it is replacing malloc() et al.\n\n",
       fn);
-   VG_(skin_panic)("Missing tool function");
+   VG_(tool_panic)("Missing tool function");
 }
 
 /*------------------------------------------------------------*/

diff --git a/coregrind/vg_errcontext.c b/coregrind/vg_errcontext.c
index 26a7d67d568e1f9550028326a58500af049063cd..4ba0272856a8d5c11f40695eb95380e8046bf999 100644 (file)
--- a/coregrind/vg_errcontext.c
+++ b/coregrind/vg_errcontext.c
@@ -219,7 +219,7 @@ static Bool eq_Error ( VgRes res, Error* e1, Error* e2 )
             VG_(printf)("\nUnhandled error type: %u. VG_(needs).tool_errors\n"
                         "probably needs to be set.\n",
                         e1->ekind);
-            VG_(skin_panic)("unhandled error type");
+            VG_(tool_panic)("unhandled error type");
          }
    }
 }
@@ -244,7 +244,7 @@ static void pp_Error ( Error* err, Bool printCount )
             VG_(printf)("\nUnhandled error type: %u.  VG_(needs).tool_errors\n"
                         "probably needs to be set?\n",
                         err->ekind);
-            VG_(skin_panic)("unhandled error type");
+            VG_(tool_panic)("unhandled error type");
          }
    }
 }
@@ -658,7 +658,7 @@ void VG_(show_all_errors) ( void )
             p_min = p;
          }
       }
-      if (p_min == NULL) VG_(skin_panic)("show_all_errors()");
+      if (p_min == NULL) VG_(tool_panic)("show_all_errors()");
 
       VG_(message)(Vg_UserMsg, "");
       VG_(message)(Vg_UserMsg, "%d errors in context %d of %d:",
@@ -963,7 +963,7 @@ Bool supp_matches_error(Supp* su, Error* err)
                "\nUnhandled suppression type: %u.  VG_(needs).tool_errors\n"
                "probably needs to be set.\n",
                err->ekind);
-            VG_(skin_panic)("unhandled suppression type");
+            VG_(tool_panic)("unhandled suppression type");
          }
    }
 }
@@ -982,7 +982,7 @@ Bool supp_matches_callers(Supp* su, Char caller_obj[][M_VG_ERRTXT],
          case FunName: if (VG_(string_match)(su->caller[i], 
                                              caller_fun[i])) break;
                        return False;
-         default: VG_(skin_panic)("supp_matches_callers");
+         default: VG_(tool_panic)("supp_matches_callers");
       }
    }
 

diff --git a/coregrind/vg_main.c b/coregrind/vg_main.c
index 48562b15d0ffa5d27928befaf88f5a4b39ea1866..51bf48a46672e0631218ee27a853baea93b0c8e5 100644 (file)
--- a/coregrind/vg_main.c
+++ b/coregrind/vg_main.c
@@ -2329,7 +2329,7 @@ Int VG_(helper_offset)(Addr a)
       VG_(printf)("%p ", VG_(noncompact_helper_addrs)[i]);
 
    VG_(printf)("\n");
-   VG_(skin_panic)("Unfound helper");
+   VG_(tool_panic)("Unfound helper");
 }
 
 

diff --git a/coregrind/vg_mylibc.c b/coregrind/vg_mylibc.c
index 650696acf0e58f30448a677a7ec657117b36c290..ef80acaa86d1d5d22279e576fe87f8575d05bd4e 100644 (file)
--- a/coregrind/vg_mylibc.c
+++ b/coregrind/vg_mylibc.c
@@ -1182,7 +1182,7 @@ void VG_(core_panic_at) ( Char* str, ExeContext *ec )
    panic("valgrind", VG_BUGS_TO, str, ec);
 }
 
-void VG_(skin_panic) ( Char* str )
+void VG_(tool_panic) ( Char* str )
 {
    panic(VG_(details).name, VG_(details).bug_reports_to, str, NULL);
 }

diff --git a/coregrind/vg_needs.c b/coregrind/vg_needs.c
index 0055423a35a08b0307b5efaad8169e65647ad2fd..07a9342ece4e0dd8c691d19016d9e6ffe2684b0d 100644 (file)
--- a/coregrind/vg_needs.c
+++ b/coregrind/vg_needs.c
@@ -68,7 +68,7 @@ void VG_(sanity_check_needs) ( void)
    if ((var)==(value)) {                                    \
       VG_(printf)("\nTool error: `%s' not initialised\n",   \
                   VG__STRING(var));                         \
-      VG_(skin_panic)("Uninitialised details field\n");     \
+      VG_(tool_panic)("Uninitialised details field\n");     \
    }
    
    /* Ones that must be set */
@@ -87,7 +87,7 @@ void VG_(sanity_check_needs) ( void)
    {
       VG_(printf)("\nTool error: one of the specialised `new_mem_stack_n'\n"
                   "events tracked, but not the generic `new_mem_stack' one.\n");
-      VG_(skin_panic)("`new_mem_stack' should be defined\n");
+      VG_(tool_panic)("`new_mem_stack' should be defined\n");
    }
 
    if ( (VG_(defined_die_mem_stack_4)()  ||
@@ -99,7 +99,7 @@ void VG_(sanity_check_needs) ( void)
    {
       VG_(printf)("\nTool error: one of the specialised `die_mem_stack_n'\n"
                   "events tracked, but not the generic `die_mem_stack' one.\n");
-      VG_(skin_panic)("`die_mem_stack' should be defined\n");
+      VG_(tool_panic)("`die_mem_stack' should be defined\n");
    }
 
    if ( (VG_(defined_post_reg_write_syscall_return)()    ||
@@ -111,7 +111,7 @@ void VG_(sanity_check_needs) ( void)
    {
       VG_(printf)("\nTool error: one of the `post_reg_write'\n"
                   "events tracked, but `shadow_regs' need not set.\n");
-      VG_(skin_panic)("`shadow_regs' should be set\n");
+      VG_(tool_panic)("`shadow_regs' should be set\n");
    }
 
    if (VG_(needs).shadow_memory != (VG_(get_shadow_size)() != 0)) {
@@ -121,7 +121,7 @@ void VG_(sanity_check_needs) ( void)
       else
         VG_(printf)("\nTool error: tool didn't allocate shadow memory, but apparently "
                     "needs it.\n");
-      VG_(skin_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 SK_(shadow_ratio)\n");
    }
 
 #undef CHECK_NOT

diff --git a/helgrind/hg_main.c b/helgrind/hg_main.c
index 27efc30f247be2f375fb6fb8e694cdba51f2a489..36015f9b8cab799795443633146e334ae93d7d7c 100644 (file)
--- a/helgrind/hg_main.c
+++ b/helgrind/hg_main.c
@@ -531,7 +531,7 @@ void set_sword ( Addr a, shadow_word sword )
    if (VGE_IS_DISTINGUISHED_SM(sm)) {
       VG_(printf)("wrote to distinguished 2ndary map! 0x%x\n", a);
       // XXX: may be legit, but I want to know when it happens --njn
-      VG_(skin_panic)("wrote to distinguished 2ndary map!");
+      VG_(tool_panic)("wrote to distinguished 2ndary map!");
    }
 }
 
@@ -546,7 +546,7 @@ shadow_word* get_sword_addr ( Addr a )
    if (VGE_IS_DISTINGUISHED_SM(sm)) {
       VG_(printf)("accessed distinguished 2ndary map! 0x%x\n", a);
       // XXX: may be legit, but I want to know when it happens --njn
-      //VG_(skin_panic)("accessed distinguished 2ndary map!");
+      //VG_(tool_panic)("accessed distinguished 2ndary map!");
       return SEC_MAP_ACCESS;
    }
 
@@ -996,7 +996,7 @@ void sanity_check_locksets ( const Char* caller )
                "i = %d, ls=%p badness = %s, caller = %s\n", 
                i, ls, badness, caller);
    pp_all_LockSets();
-   VG_(skin_panic)("sanity_check_locksets");
+   VG_(tool_panic)("sanity_check_locksets");
 }
 
 static
@@ -1535,7 +1535,7 @@ static void set_mutex_state(Mutex *mutex, MutexState state, ThreadId tid)
            record_mutex_error(tid, mutex, "take lock we already hold", 
                               mutex->location);
 
-        VG_(skin_panic)("core should have checked this\n");
+        VG_(tool_panic)("core should have checked this\n");
         break;
       }
 
@@ -1648,7 +1648,7 @@ void set_address_range_state ( Addr a, SizeT len /* in bytes */,
    
    default:
       VG_(printf)("init_status = %u\n", status);
-      VG_(skin_panic)("Unexpected Vge_InitStatus");
+      VG_(tool_panic)("Unexpected Vge_InitStatus");
    }
       
    /* Check that zero page and highest page have not been written to
@@ -1713,7 +1713,7 @@ static
 void eraser_pre_mem_read(CorePart part, ThreadId tid,
                          Char* s, Addr base, SizeT size )
 {
-   if (tid > 50) { VG_(printf)("pid = %d, s = `%s`, part = %d\n", tid, s, part); VG_(skin_panic)("a");}
+   if (tid > 50) { VG_(printf)("pid = %d, s = `%s`, part = %d\n", tid, s, part); VG_(tool_panic)("a");}
    eraser_mem_read(base, size, tid);
 }
 
@@ -2114,7 +2114,7 @@ UCodeBlock* SK_(instrument) ( UCodeBlock* cb_in, Addr not_used )
               case 2: help = eraser_mem_help_read_2; break;
               case 4: help = eraser_mem_help_read_4; break;
               default:
-                 VG_(skin_panic)("bad size");
+                 VG_(tool_panic)("bad size");
               }
 
               /* XXX all registers should be flushed to baseblock
@@ -2199,7 +2199,7 @@ UCodeBlock* SK_(instrument) ( UCodeBlock* cb_in, Addr not_used )
               case 2: help = eraser_mem_help_write_2; break;
               case 4: help = eraser_mem_help_write_4; break;
               default:
-                 VG_(skin_panic)("bad size");
+                 VG_(tool_panic)("bad size");
               }
 
               /* XXX all registers should be flushed to baseblock
@@ -2616,7 +2616,7 @@ static void pp_AddrInfo ( Addr a, AddrInfo* ai )
          break;
       }   
       default:
-         VG_(skin_panic)("pp_AddrInfo");
+         VG_(tool_panic)("pp_AddrInfo");
    }
 }
 

diff --git a/include/tool.h.base b/include/tool.h.base
index 4298ab9b8de9b93939465d0c530cdaa0479ef64b..747ec88c11db0671793fa86c41ce5f07180d6bf1 100644 (file)
--- a/include/tool.h.base
+++ b/include/tool.h.base
@@ -368,7 +368,7 @@ extern void  VG_(exit)( Int status )
 /* Prints a panic message (a constant string), appends newline and bug
    reporting info, aborts. */
 __attribute__ ((__noreturn__))
-extern void  VG_(skin_panic) ( Char* str );
+extern void  VG_(tool_panic) ( Char* str );
 
 /* Looks up VG_(client_envp) */
 extern Char* VG_(getenv) ( Char* name );
@@ -1797,7 +1797,7 @@ extern void VG_(details_copyright_author)      ( Char* copyright_author );
    setting is optional. */
 extern void VG_(details_avg_translation_sizeB) ( UInt size );
 
-/* String printed if an `tl_assert' assertion fails or VG_(skin_panic)
+/* String printed if an `tl_assert' assertion fails or VG_(tool_panic)
    is called.  Should probably be an email address. */
 extern void VG_(details_bug_reports_to)   ( Char* bug_reports_to );
 

diff --git a/include/vg_profile.c b/include/vg_profile.c
index 8e8bb950725a0407b5523340b508e0f825c996bc..a497858f04cf5068985086f02b4e8cef1db04839 100644 (file)
--- a/include/vg_profile.c
+++ b/include/vg_profile.c
@@ -71,14 +71,14 @@ void VGP_(register_profile_event) ( Int n, Char* name )
                   "If you really need this many profile events, increase\n"
                   "VGP_MAX_CCS and recompile Valgrind.\n",
                   n, VGP_MAX_CCS);
-      VG_(skin_panic)("profile event too high");
+      VG_(tool_panic)("profile event too high");
    }
    if (vgp_names[n] != NULL) {
       VG_(printf)("\nProfile event #%d being registered as `%s'\n"
                   "already registered as `%s'.\n"
                   "Note that tool and core event numbers must not overlap.\n",
                   n, name, vgp_names[n]);
-      VG_(skin_panic)("profile event already registered");
+      VG_(tool_panic)("profile event already registered");
    }
 
    vgp_names[n] = name;
@@ -115,7 +115,7 @@ void VGP_(init_profiling) ( void )
 
    signal(SIGPROF, VGP_(tick) );
    ret = setitimer(ITIMER_PROF, &value, NULL);
-   if (ret != 0) VG_(skin_panic)("vgp_init_profiling");
+   if (ret != 0) VG_(tool_panic)("vgp_init_profiling");
 }
 
 void VGP_(done_profiling) ( void )
@@ -141,7 +141,7 @@ void VGP_(pushcc) ( UInt cc )
          "Or if you are nesting profiling events very deeply, increase\n"
          "VGP_M_STACK and recompile Valgrind.\n",
          VGP_M_STACK, cc, vgp_names[cc]);
-      VG_(skin_panic)("Profiling stack overflow");
+      VG_(tool_panic)("Profiling stack overflow");
    }
    vgp_sp++;
    vgp_stack[vgp_sp] = cc;
@@ -154,7 +154,7 @@ void VGP_(popcc) ( UInt cc )
       VG_(printf)(
          "\nProfile stack underflow.  This is due to a VGP_(popcc)() without\n"
          "a matching VGP_(pushcc)().  Make sure they all match.\n");
-      VG_(skin_panic)("Profiling stack underflow");
+      VG_(tool_panic)("Profiling stack underflow");
    }
    if (vgp_stack[vgp_sp] != cc) {
       Int i;

diff --git a/massif/ms_main.c b/massif/ms_main.c
index 2f126257d151143cd225041f560b15fdb4eee092..3d96f55ae246e51cd8fd9ca94c9b21dbab6efb8a 100644 (file)
--- a/massif/ms_main.c
+++ b/massif/ms_main.c
@@ -453,7 +453,7 @@ static XPt* get_XCon( ThreadId tid, Bool custom_malloc )
       if (L == n_eips) {
          overestimate += 2;
          if (overestimate > MAX_ALLOC_FNS)
-            VG_(skin_panic)("No stk snapshot big enough to find non-alloc fns");
+            VG_(tool_panic)("No stk snapshot big enough to find non-alloc fns");
       } else {
          break;
       }

diff --git a/memcheck/mac_leakcheck.c b/memcheck/mac_leakcheck.c
index 6320feb27a0a2579e95204ec3d75eff2e82c0aaa..6cd7e32649d42b2173dbb179786a3fd5a31c25d5 100644 (file)
--- a/memcheck/mac_leakcheck.c
+++ b/memcheck/mac_leakcheck.c
@@ -521,7 +521,7 @@ void MAC_(do_detect_memory_leaks) (
          MAC_(bytes_reachable) += p_min->total_bytes;
 
       } else {
-         VG_(skin_panic)("generic_detect_memory_leaks: unknown loss mode");
+         VG_(tool_panic)("generic_detect_memory_leaks: unknown loss mode");
       }
       p_min->num_blocks = 0;
    }

diff --git a/memcheck/mac_malloc_wrappers.c b/memcheck/mac_malloc_wrappers.c
index 23836af7a94f8c5804d5fd6bcd31f56a5fa68c94..0bbe1a011a8c05433d297d3761a99fa120fb64de 100644 (file)
--- a/memcheck/mac_malloc_wrappers.c
+++ b/memcheck/mac_malloc_wrappers.c
@@ -148,7 +148,7 @@ void add_MAC_Chunk ( Addr p, SizeT size, MAC_AllocKind kind, VgHashTable table)
       VG_(malloc) should be noaccess as far as the client is
       concerned. */
    if (!MAC_(check_noaccess)( (Addr)mc, sizeof(MAC_Chunk), NULL )) {
-      VG_(skin_panic)("add_MAC_chunk: shadow area is accessible");
+      VG_(tool_panic)("add_MAC_chunk: shadow area is accessible");
    } 
 
    VG_(HT_add_node)( table, (VgHashNode*)mc );
@@ -435,7 +435,7 @@ void MAC_(create_mempool)(Addr pool, UInt rzB, Bool is_zeroed)
       VG_(malloc) should be noaccess as far as the client is
       concerned. */
    if (!MAC_(check_noaccess)( (Addr)mp, sizeof(MAC_Mempool), NULL )) {
-      VG_(skin_panic)("MAC_(create_mempool): shadow area is accessible");
+      VG_(tool_panic)("MAC_(create_mempool): shadow area is accessible");
    } 
 
    VG_(HT_add_node)( MAC_(mempool_list), (VgHashNode*)mp );

diff --git a/memcheck/mac_needs.c b/memcheck/mac_needs.c
index e528c6da84e535db79f4305c4be04a6892964fe1..753f60271c4afcee62fda30bac452445d4228950 100644 (file)
--- a/memcheck/mac_needs.c
+++ b/memcheck/mac_needs.c
@@ -193,7 +193,7 @@ Bool SK_(eq_Error) ( VgRes res, Error* e1, Error* e2 )
          return True;
 
       case LeakErr:
-         VG_(skin_panic)("Shouldn't get LeakErr in SK_(eq_Error),\n"
+         VG_(tool_panic)("Shouldn't get LeakErr in SK_(eq_Error),\n"
                          "since it's handled with VG_(unique_error)()!");
 
       case IllegalMempoolErr:
@@ -202,7 +202,7 @@ Bool SK_(eq_Error) ( VgRes res, Error* e1, Error* e2 )
       default: 
          VG_(printf)("Error:\n  unknown error code %d\n",
                      VG_(get_error_kind)(e1));
-         VG_(skin_panic)("unknown error code in SK_(eq_Error)");
+         VG_(tool_panic)("unknown error code in SK_(eq_Error)");
    }
 }
 
@@ -260,7 +260,7 @@ void MAC_(pp_AddrInfo) ( Addr a, AddrInfo* ai )
          tl_assert(0 == a);
          break;
       default:
-         VG_(skin_panic)("MAC_(pp_AddrInfo)");
+         VG_(tool_panic)("MAC_(pp_AddrInfo)");
    }
 }
 
@@ -297,7 +297,7 @@ void MAC_(pp_shared_Error) ( Error* err )
                                         "stated on the next line");
                break;
             default: 
-               VG_(skin_panic)("SK_(pp_shared_Error)(axskind)");
+               VG_(tool_panic)("SK_(pp_shared_Error)(axskind)");
          }
          VG_(pp_ExeContext)( VG_(get_error_where)(err) );
          MAC_(pp_AddrInfo)(VG_(get_error_address)(err), &err_extra->addrinfo);
@@ -336,7 +336,7 @@ void MAC_(pp_shared_Error) ( Error* err )
       default: 
          VG_(printf)("Error:\n  unknown Memcheck/Addrcheck error code %d\n",
                      VG_(get_error_kind)(err));
-         VG_(skin_panic)("unknown error code in MAC_(pp_shared_Error)");
+         VG_(tool_panic)("unknown error code in MAC_(pp_shared_Error)");
    }
 }
 
@@ -543,7 +543,7 @@ UInt SK_(update_extra)( Error* err )
       VG_(unique_error)() so they're not copied anyway. */
    case LeakErr:     return 0;
    case OverlapErr:  return sizeof(OverlapExtra);
-   default: VG_(skin_panic)("update_extra: bad errkind");
+   default: VG_(tool_panic)("update_extra: bad errkind");
    }
 }
 
@@ -636,7 +636,7 @@ Bool SK_(error_matches_suppression)(Error* err, Supp* su)
          VG_(printf)("Error:\n"
                      "  unknown suppression type %d\n",
                      VG_(get_supp_kind)(su));
-         VG_(skin_panic)("unknown suppression type in "
+         VG_(tool_panic)("unknown suppression type in "
                          "SK_(error_matches_suppression)");
    }
 }
@@ -657,7 +657,7 @@ Char* SK_(get_error_name) ( Error* err )
       case 4:               return "Addr4";
       case 8:               return "Addr8";
       case 16:              return "Addr16";
-      default:              VG_(skin_panic)("unexpected size for Addr");
+      default:              VG_(tool_panic)("unexpected size for Addr");
       }
      
    case ValueErr:
@@ -668,12 +668,12 @@ Char* SK_(get_error_name) ( Error* err )
       case 4:               return "Value4";
       case 8:               return "Value8";
       case 16:              return "Value16";
-      default:              VG_(skin_panic)("unexpected size for Value");
+      default:              VG_(tool_panic)("unexpected size for Value");
       }
    case CoreMemErr:         return "CoreMem";
    case OverlapErr:         return "Overlap";
    case LeakErr:            return "Leak";
-   default:                 VG_(skin_panic)("get_error_name: unexpected type");
+   default:                 VG_(tool_panic)("get_error_name: unexpected type");
    }
    VG_(printf)(s);
 }
@@ -875,7 +875,7 @@ Bool MAC_(handle_common_client_requests)(ThreadId tid, UWord* arg, UWord* ret )
    }
    case VG_USERREQ__MALLOCLIKE_BLOCK__OLD_DO_NOT_USE:
    case VG_USERREQ__FREELIKE_BLOCK__OLD_DO_NOT_USE:
-      VG_(skin_panic)(err);
+      VG_(tool_panic)(err);
 
    case VG_USERREQ__MALLOCLIKE_BLOCK: {
       Addr p         = (Addr)arg[1];
@@ -958,7 +958,7 @@ void  SK_(post_syscall) ( ThreadId tid, UInt syscallno,
       VG_(message)(Vg_DebugMsg,
                    "probable sanity check failure for syscall number %d\n",
                    syscallno );
-      VG_(skin_panic)("aborting due to the above ... bye!");
+      VG_(tool_panic)("aborting due to the above ... bye!");
    }
 }
 

diff --git a/memcheck/mc_from_ucode.c b/memcheck/mc_from_ucode.c
index cef72db5dfbc19b68923fe9bf2dbc579b54e2c10..7b7aa07e86a5afd623f0cb55ef792cc23aa82c99 100644 (file)
--- a/memcheck/mc_from_ucode.c
+++ b/memcheck/mc_from_ucode.c
@@ -123,7 +123,7 @@ static void synth_LOADV ( Int sz, Int a_reg, Int tv_reg,
       case 4: helper = (Addr) & MC_(helperc_LOADV4); break;
       case 2: helper = (Addr) & MC_(helperc_LOADV2); break;
       case 1: helper = (Addr) & MC_(helperc_LOADV1); break;
-      default: VG_(skin_panic)("synth_LOADV");
+      default: VG_(tool_panic)("synth_LOADV");
    }
    VG_(synth_ccall) ( helper, 1, 1, argv, tagv, tv_reg,
                       regs_live_before, regs_live_after );
@@ -143,7 +143,7 @@ static void synth_STOREV ( Int sz, Int tv_tag, Int tv_val, Int a_reg,
       case 4: helper = (Addr) MC_(helperc_STOREV4); break;
       case 2: helper = (Addr) MC_(helperc_STOREV2); break;
       case 1: helper = (Addr) MC_(helperc_STOREV1); break;
-      default: VG_(skin_panic)("synth_STOREV");
+      default: VG_(tool_panic)("synth_STOREV");
    }
    VG_(synth_ccall) ( helper, 2, 2, argv, tagv, INVALID_REALREG,
                       regs_live_before, regs_live_after );
@@ -158,7 +158,7 @@ static void synth_SETV ( Int sz, Int reg )
       case 2: val = 0xFFFF0000; break;
       case 1: val = 0xFFFFFF00; break;
       case 0: val = 0xFFFFFFFE; break;
-      default: VG_(skin_panic)("synth_SETV");
+      default: VG_(tool_panic)("synth_SETV");
    }
    VG_(emit_movv_lit_reg) ( 4, val, reg );
 }
@@ -200,7 +200,7 @@ static void synth_TESTV ( Int sz, Int tag, Int val )
          case 0: 
             /* should never happen */
          default: 
-            VG_(skin_panic)("synth_TESTV(ArchReg)");
+            VG_(tool_panic)("synth_TESTV(ArchReg)");
       }
    } else {
       switch (sz) {
@@ -223,7 +223,7 @@ static void synth_TESTV ( Int sz, Int tag, Int val )
             synth_minimal_test_lit_reg ( 0x00000001, val );
             break;
          default: 
-            VG_(skin_panic)("synth_TESTV(RealReg)");
+            VG_(tool_panic)("synth_TESTV(RealReg)");
       }
    }
    
@@ -269,7 +269,7 @@ static void synth_GETV ( Int sz, Int arch, Int reg )
          VG_(emit_nonshiftopv_lit_reg) ( False, 4, OR, 0xFFFFFF00, reg );
          break;
       default: 
-         VG_(skin_panic)("synth_GETV");
+         VG_(tool_panic)("synth_GETV");
    }
 }
 
@@ -303,7 +303,7 @@ static void synth_PUTV ( Int sz, Int srcTag, UInt lit_or_reg, Int arch )
             }
             break;
          default: 
-            VG_(skin_panic)("synth_PUTV(lit)");
+            VG_(tool_panic)("synth_PUTV(lit)");
       }
 
    } else {
@@ -339,7 +339,7 @@ static void synth_PUTV ( Int sz, Int srcTag, UInt lit_or_reg, Int arch )
             }
             break;
          default: 
-            VG_(skin_panic)("synth_PUTV(reg)");
+            VG_(tool_panic)("synth_PUTV(reg)");
       }
 
       if (sz == 1 && lit_or_reg >= 4) {
@@ -508,7 +508,7 @@ static void synth_TAG1_op ( TagOp op, Int reg, RRegSet regs_live_after )
          break;
 
       default:
-         VG_(skin_panic)("synth_TAG1_op");
+         VG_(tool_panic)("synth_TAG1_op");
    }
 }
 
@@ -575,7 +575,7 @@ static void synth_TAG2_op ( TagOp op, Int regs, Int regd )
          break;
 
       default:
-         VG_(skin_panic)("synth_TAG2_op");
+         VG_(tool_panic)("synth_TAG2_op");
    }
 }
 
@@ -652,7 +652,7 @@ void SK_(emit_XUInstr) ( UInstr* u, RRegSet regs_live_before )
       default: 
          VG_(printf)("emit_XUInstr: unhandled extension insn:\n");
          VG_(pp_UInstr)(0,u);
-         VG_(skin_panic)("emit_XUInstr: unhandled extension opcode");
+         VG_(tool_panic)("emit_XUInstr: unhandled extension opcode");
    }
 }
 

diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c
index 27ac7cfb52e97f85cace7b504077f48305035c8c..1e786119aab43d2e15e254cb9b76cf394f42bb99 100644 (file)
--- a/memcheck/mc_main.c
+++ b/memcheck/mc_main.c
@@ -644,7 +644,7 @@ void mc_check_is_writable ( CorePart part, ThreadId tid, Char* s,
          break;
 
       default:
-         VG_(skin_panic)("mc_check_is_writable: unexpected CorePart");
+         VG_(tool_panic)("mc_check_is_writable: unexpected CorePart");
       }
    }
 
@@ -683,7 +683,7 @@ void mc_check_is_readable ( CorePart part, ThreadId tid, Char* s,
          break;
 
       default:
-         VG_(skin_panic)("mc_check_is_readable: unexpected CorePart");
+         VG_(tool_panic)("mc_check_is_readable: unexpected CorePart");
       }
    }
    VGP_POPCC(VgpCheckMem);
@@ -774,7 +774,7 @@ static void mc_pre_reg_read(CorePart part, ThreadId tid, Char* s, UInt reg,
    case 4:  mask = 0xffffffff; break;
    case 2:  mask = 0xffff;     break;
    case 1:  mask = 0xff;       break;
-   default: VG_(skin_panic)("Unhandled size in mc_pre_reg_read");
+   default: VG_(tool_panic)("Unhandled size in mc_pre_reg_read");
    }
 
    if (VGM_WORD_VALID != (mask & VG_(get_thread_shadow_archreg)( tid, reg )) )
@@ -1237,7 +1237,7 @@ void MC_(fpu_read_check) ( Addr addr, SizeT size )
    }
 
    VG_(printf)("size is %d\n", size);
-   VG_(skin_panic)("MC_(fpu_read_check): unhandled size");
+   VG_(tool_panic)("MC_(fpu_read_check): unhandled size");
 #  endif
 }
 
@@ -1320,7 +1320,7 @@ void MC_(fpu_write_check) ( Addr addr, SizeT size )
    }
 
    VG_(printf)("size is %d\n", size);
-   VG_(skin_panic)("MC_(fpu_write_check): unhandled size");
+   VG_(tool_panic)("MC_(fpu_write_check): unhandled size");
 #  endif
 }
 

diff --git a/memcheck/mc_translate.c b/memcheck/mc_translate.c
index 05dfb16336c1fd91caabc9480a00e6974198d434..6a815c930d21bba417289fba8ee9bad4ebb0796b 100644 (file)
--- a/memcheck/mc_translate.c
+++ b/memcheck/mc_translate.c
@@ -93,7 +93,7 @@ Bool SK_(sane_XUInstr)(Bool beforeRA, Bool beforeLiveness, UInstr* u)
    case TAG2:   return LIT0 && SZ0 && CC0 &&  TR1 && TR2 && Ls3 && XOTHER;
    default:
       VG_(printf)("unhandled opcode: %u\n", u->opcode);
-      VG_(skin_panic)("SK_(sane_XUInstr): unhandled opcode");
+      VG_(tool_panic)("SK_(sane_XUInstr): unhandled opcode");
    }
 #  undef LIT0
 #  undef LIT1
@@ -154,7 +154,7 @@ static Char* nameOfTagOp ( TagOp h )
       case Tag_ImproveOR2_TQ:  return "ImproveOR2_TQ";
       case Tag_ImproveOR1_TQ:  return "ImproveOR1_TQ";
       case Tag_DebugFn:        return "DebugFn";
-      default: VG_(skin_panic)("vg_nameOfTagOp");
+      default: VG_(tool_panic)("vg_nameOfTagOp");
    }
 }
 
@@ -174,7 +174,7 @@ Char* SK_(name_XUOpcode)(Opcode opc)
       case SETV:    return "SETV";
       default:      
          VG_(printf)("unhandled opcode: %u\n", opc);
-         VG_(skin_panic)("SK_(name_XUOpcode): unhandled case");
+         VG_(tool_panic)("SK_(name_XUOpcode): unhandled case");
    }
 }
 
@@ -223,7 +223,7 @@ void SK_(pp_XUInstr)(UInstr* u)
 
       default:
          VG_(printf)("unhandled opcode: %u\n", u->opcode);
-         VG_(skin_panic)("SK_(pp_XUInstr): unhandled opcode");
+         VG_(tool_panic)("SK_(pp_XUInstr): unhandled opcode");
    }
 
 }
@@ -248,7 +248,7 @@ Int SK_(get_Xreg_usage)(UInstr* u, Tag tag, Int* regs, Bool* isWrites)
 
       default: 
          VG_(printf)("unhandled opcode: %u\n", u->opcode);
-         VG_(skin_panic)("SK_(get_Xreg_usage): unhandled opcode");
+         VG_(tool_panic)("SK_(get_Xreg_usage): unhandled opcode");
    }
    return n;
 
@@ -267,7 +267,7 @@ TagOp get_Tag_ImproveOR_TQ ( Int sz )
       case 4: return Tag_ImproveOR4_TQ;
       case 2: return Tag_ImproveOR2_TQ;
       case 1: return Tag_ImproveOR1_TQ;
-      default: VG_(skin_panic)("get_Tag_ImproveOR_TQ");
+      default: VG_(tool_panic)("get_Tag_ImproveOR_TQ");
    }
 }
 
@@ -279,7 +279,7 @@ TagOp get_Tag_ImproveAND_TQ ( Int sz )
       case 4: return Tag_ImproveAND4_TQ;
       case 2: return Tag_ImproveAND2_TQ;
       case 1: return Tag_ImproveAND1_TQ;
-      default: VG_(skin_panic)("get_Tag_ImproveAND_TQ");
+      default: VG_(tool_panic)("get_Tag_ImproveAND_TQ");
    }
 }
 
@@ -291,7 +291,7 @@ TagOp get_Tag_Left ( Int sz )
       case 4: return Tag_Left4;
       case 2: return Tag_Left2;
       case 1: return Tag_Left1;
-      default: VG_(skin_panic)("get_Tag_Left");
+      default: VG_(tool_panic)("get_Tag_Left");
    }
 }
 
@@ -304,7 +304,7 @@ TagOp get_Tag_UifU ( Int sz )
       case 2: return Tag_UifU2;
       case 1: return Tag_UifU1;
       case 0: return Tag_UifU0;
-      default: VG_(skin_panic)("get_Tag_UifU");
+      default: VG_(tool_panic)("get_Tag_UifU");
    }
 }
 
@@ -316,7 +316,7 @@ TagOp get_Tag_DifD ( Int sz )
       case 4: return Tag_DifD4;
       case 2: return Tag_DifD2;
       case 1: return Tag_DifD1;
-      default: VG_(skin_panic)("get_Tag_DifD");
+      default: VG_(tool_panic)("get_Tag_DifD");
    }
 }
 
@@ -334,7 +334,7 @@ TagOp get_Tag_PCast ( Int szs, Int szd )
    if (szs == 1 && szd == 2) return Tag_PCast12;
    if (szs == 1 && szd == 1) return Tag_PCast11;
    VG_(printf)("get_Tag_PCast(%d,%d)\n", szs, szd);
-   VG_(skin_panic)("get_Tag_PCast");
+   VG_(tool_panic)("get_Tag_PCast");
 }
 
 
@@ -351,7 +351,7 @@ TagOp get_Tag_Widen ( Bool syned, Int szs, Int szd )
    if (szs == 2 && szd == 4 && !syned) return Tag_ZWiden24;
 
    VG_(printf)("get_Tag_Widen(%d,%d,%d)\n", (Int)syned, szs, szd);
-   VG_(skin_panic)("get_Tag_Widen");
+   VG_(tool_panic)("get_Tag_Widen");
 }
 
 /* Pessimally cast the spec'd shadow from one size to another. */
@@ -477,7 +477,7 @@ Int /* TempReg */ getOperandShadow ( UCodeBlock* cb,
       uInstr2(cb, GETV, sz, ArchReg, val, TempReg, sh);
       return sh;
    }
-   VG_(skin_panic)("getOperandShadow");
+   VG_(tool_panic)("getOperandShadow");
 }
 
 /* Create and return an instrumented version of cb_in.  Free cb_in
@@ -637,7 +637,7 @@ static UCodeBlock* memcheck_instrument ( UCodeBlock* cb_in )
                               TempReg, SHADOW(u_in->val2));
                   break;
                default: 
-                  VG_(skin_panic)("memcheck_instrument: MOV");
+                  VG_(tool_panic)("memcheck_instrument: MOV");
             }
             VG_(copy_UInstr)(cb, u_in);
             break;
@@ -671,7 +671,7 @@ static UCodeBlock* memcheck_instrument ( UCodeBlock* cb_in )
                case 2: shift = 1; break;
                case 4: shift = 2; break;
                case 8: shift = 3; break;
-               default: VG_(skin_panic)( "memcheck_instrument(LEA2)" );
+               default: VG_(tool_panic)( "memcheck_instrument(LEA2)" );
             }
             qs = SHADOW(u_in->val1);
             qt = SHADOW(u_in->val2);
@@ -1221,7 +1221,7 @@ static UCodeBlock* memcheck_instrument ( UCodeBlock* cb_in )
 
          default:
             VG_(pp_UInstr)(0, u_in);
-            VG_(skin_panic)( "memcheck_instrument: unhandled case");
+            VG_(tool_panic)( "memcheck_instrument: unhandled case");
 
       } /* end of switch (u_in->opcode) */
 
@@ -1439,7 +1439,7 @@ static void vg_propagate_definedness ( UCodeBlock* cb )
                   case 4: u->lit32 = 0x00000000; break;
                   case 2: u->lit32 = 0xFFFF0000; break;
                   case 1: u->lit32 = 0xFFFFFF00; break;
-                  default: VG_(skin_panic)("vg_cleanup(PUTV)");
+                  default: VG_(tool_panic)("vg_cleanup(PUTV)");
                }
                if (dis) 
                   VG_(printf)(
@@ -1457,7 +1457,7 @@ static void vg_propagate_definedness ( UCodeBlock* cb )
                   case 4: u->lit32 = 0x00000000; break;
                   case 2: u->lit32 = 0xFFFF0000; break;
                   case 1: u->lit32 = 0xFFFFFF00; break;
-                  default: VG_(skin_panic)("vg_cleanup(STOREV)");
+                  default: VG_(tool_panic)("vg_cleanup(STOREV)");
                }
                if (dis) 
                   VG_(printf)(