zenithsiz/ftmemsim-valgrind
1
0
Fork 0
mirror of https://github.com/Zenithsiz/ftmemsim-valgrind.git synced 2026-02-03 18:13:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Renamed VG_(skin_panic) as VG_(tool_panic).

Browse Source 
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@3057
This commit is contained in:
Nicholas Nethercote 2004-11-22 18:02:32 +00:00
parent 213ef621b7
commit 3093a1768b
20 changed files with 88 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
addrcheck/ac_main.c
View File

@ -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);

2
cachegrind/cg_main.c
View File

@ -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);
}

2
cachegrind/cg_sim.c
View File

@ -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; \
}

2
cachegrind/x86/cg_arch.c
View File

@ -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,

2
coregrind/docs/coregrind_tools.html
View File

@ -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

4
coregrind/vg_default.c
View File

@ -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");
}
/*------------------------------------------------------------*/

10
coregrind/vg_errcontext.c
View File

@ -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");
}
}

2
coregrind/vg_main.c
View File

@ -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");
}

2
coregrind/vg_mylibc.c
View File

@ -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);
}

10
coregrind/vg_needs.c
View File

@ -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

18
helgrind/hg_main.c
View File

@ -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");
}
}

4
include/tool.h.base
View File

@ -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 );

10
include/vg_profile.c
View File

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

2
massif/ms_main.c
View File

@ -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;
}

2
memcheck/mac_leakcheck.c
View File

@ -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;
}

4
memcheck/mac_malloc_wrappers.c
View File

@ -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 );

24
memcheck/mac_needs.c
View File

@ -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!");
}
}

22
memcheck/mc_from_ucode.c
View File

@ -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");
}
}

10
memcheck/mc_main.c
View File

@ -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
}

36
memcheck/mc_translate.c
View File

@ -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)(