/*--------------------------------------------------------------------*/
/*--- Ptrcheck: a pointer-use checker. ---*/
/*--- Provides stuff shared between sg_ and h_ subtools. ---*/
/*--- pc_common.c ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Ptrcheck, a Valgrind tool for checking pointer
use in programs.
Copyright (C) 2008-2013 OpenWorks Ltd
info@open-works.co.uk
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
Neither the names of the U.S. Department of Energy nor the
University of California nor the names of its contributors may be
used to endorse or promote products derived from this software
without prior written permission.
*/
#include "pub_tool_basics.h"
#include "pub_tool_libcbase.h"
#include "pub_tool_libcprint.h"
#include "pub_tool_xarray.h"
#include "pub_tool_mallocfree.h"
#include "pub_tool_libcassert.h"
#include "pub_tool_options.h"
#include "pub_tool_replacemalloc.h"
#include "pub_tool_execontext.h"
#include "pub_tool_tooliface.h" // CorePart
#include "pub_tool_threadstate.h" // VG_(get_running_tid)
#include "pub_tool_debuginfo.h"
#include "pc_common.h" // self, & Seg
#include "h_main.h" // NONPTR, BOTTOM, UNKNOWN
//////////////////////////////////////////////////////////////
// //
// Command line options //
// //
//////////////////////////////////////////////////////////////
Bool h_clo_partial_loads_ok = True; /* user visible */
/* Bool h_clo_lossage_check = False; */ /* dev flag only */
Bool sg_clo_enable_sg_checks = True; /* user visible */
Bool pc_process_cmd_line_options(const HChar* arg)
{
if VG_BOOL_CLO(arg, "--partial-loads-ok", h_clo_partial_loads_ok) {}
/* else if VG_BOOL_CLO(arg, "--lossage-check", h_clo_lossage_check) {} */
else if VG_BOOL_CLO(arg, "--enable-sg-checks", sg_clo_enable_sg_checks) {}
else
return VG_(replacement_malloc_process_cmd_line_option)(arg);
return True;
}
void pc_print_usage(void)
{
VG_(printf)(
" --partial-loads-ok=no|yes same as for Memcheck [yes]\n"
" --enable-sg-checks=no|yes enable stack & global array checking? [yes]\n"
);
}
void pc_print_debug_usage(void)
{
VG_(printf)(
" (none)\n"
//" --lossage-check=no|yes gather stats for quality control [no]\n"
);
}
//////////////////////////////////////////////////////////////
// //
// Error management -- storage //
// //
//////////////////////////////////////////////////////////////
/* What kind of error it is. */
typedef
enum {
XE_SorG=1202, // sg: stack or global array inconsistency
XE_Heap, // h: mismatched ptr/addr segments on load/store
XE_Arith, // h: bad arithmetic between two segment pointers
XE_SysParam // h: block straddling >1 segment passed to syscall
}
XErrorTag;
typedef
enum {
XS_SorG=2021,
XS_Heap,
XS_Arith,
XS_SysParam
}
XSuppTag;
typedef
struct {
XErrorTag tag;
union {
struct {
Addr addr;
SSizeT sszB; /* -ve is write, +ve is read */
HChar expect[128];
HChar actual[128];
HChar delta[32]; // text showing relation to expected
} SorG;
struct {
Addr addr;
SSizeT sszB; /* -ve is write, +ve is read */
Seg* vseg;
XArray* descr1; /* XArray* of HChar */
XArray* descr2; /* XArray* of HChar */
HChar datasym[96];
PtrdiffT datasymoff;
} Heap;
struct {
Seg* seg1;
Seg* seg2;
const HChar* opname; // user-understandable text name
} Arith;
struct {
CorePart part;
Addr lo;
Addr hi;
Seg* seglo;
Seg* seghi;
} SysParam;
} XE;
}
XError;
void sg_record_error_SorG ( ThreadId tid,
Addr addr, SSizeT sszB,
HChar* expect, HChar* actual, HChar* delta )
{
XError xe;
VG_(memset)(&xe, 0, sizeof(xe));
xe.tag = XE_SorG;
xe.XE.SorG.addr = addr;
xe.XE.SorG.sszB = sszB;
VG_(strncpy)( &xe.XE.SorG.expect[0],
expect, sizeof(xe.XE.SorG.expect) );
VG_(strncpy)( &xe.XE.SorG.actual[0],
actual, sizeof(xe.XE.SorG.actual) );
VG_(strncpy)( &xe.XE.SorG.delta[0],
delta, sizeof(xe.XE.SorG.delta) );
xe.XE.SorG.expect[ sizeof(xe.XE.SorG.expect)-1 ] = 0;
xe.XE.SorG.actual[ sizeof(xe.XE.SorG.actual)-1 ] = 0;
xe.XE.SorG.delta[ sizeof(xe.XE.SorG.delta)-1 ] = 0;
VG_(maybe_record_error)( tid, XE_SorG, 0, NULL, &xe );
}
void h_record_heap_error( Addr a, SizeT size, Seg* vseg, Bool is_write )
{
XError xe;
tl_assert(size > 0);
VG_(memset)(&xe, 0, sizeof(xe));
xe.tag = XE_Heap;
xe.XE.Heap.addr = a;
xe.XE.Heap.sszB = is_write ? -size : size;
xe.XE.Heap.vseg = vseg;
VG_(maybe_record_error)( VG_(get_running_tid)(), XE_Heap,
/*a*/0, /*str*/NULL, /*extra*/(void*)&xe);
}
void h_record_arith_error( Seg* seg1, Seg* seg2, HChar* opname )
{
XError xe;
VG_(memset)(&xe, 0, sizeof(xe));
xe.tag = XE_Arith;
xe.XE.Arith.seg1 = seg1;
xe.XE.Arith.seg2 = seg2;
xe.XE.Arith.opname = opname;
VG_(maybe_record_error)( VG_(get_running_tid)(), XE_Arith,
/*a*/0, /*str*/NULL, /*extra*/(void*)&xe);
}
void h_record_sysparam_error( ThreadId tid, CorePart part, const HChar* s,
Addr lo, Addr hi, Seg* seglo, Seg* seghi )
{
XError xe;
VG_(memset)(&xe, 0, sizeof(xe));
xe.tag = XE_SysParam;
xe.XE.SysParam.part = part;
xe.XE.SysParam.lo = lo;
xe.XE.SysParam.hi = hi;
xe.XE.SysParam.seglo = seglo;
xe.XE.SysParam.seghi = seghi;
VG_(maybe_record_error)( tid, XE_SysParam, /*a*/(Addr)0, /*str*/s,
/*extra*/(void*)&xe);
}
Bool pc_eq_Error ( VgRes res, Error* e1, Error* e2 )
{
XError *xe1, *xe2;
tl_assert(VG_(get_error_kind)(e1) == VG_(get_error_kind)(e2));
//tl_assert(VG_(get_error_string)(e1) == NULL);
//tl_assert(VG_(get_error_string)(e2) == NULL);
xe1 = (XError*)VG_(get_error_extra)(e1);
xe2 = (XError*)VG_(get_error_extra)(e2);
tl_assert(xe1);
tl_assert(xe2);
if (xe1->tag != xe2->tag)
return False;
switch (xe1->tag) {
case XE_SorG:
return //xe1->XE.SorG.addr == xe2->XE.SorG.addr
//&&
xe1->XE.SorG.sszB == xe2->XE.SorG.sszB
&& 0 == VG_(strncmp)( &xe1->XE.SorG.expect[0],
&xe2->XE.SorG.expect[0],
sizeof(xe1->XE.SorG.expect) )
&& 0 == VG_(strncmp)( &xe1->XE.SorG.actual[0],
&xe2->XE.SorG.actual[0],
sizeof(xe1->XE.SorG.actual) );
case XE_Heap:
case XE_Arith:
case XE_SysParam:
return True;
default:
VG_(tool_panic)("eq_Error: unrecognised error kind");
}
}
//////////////////////////////////////////////////////////////
// //
// Error management -- printing //
// //
//////////////////////////////////////////////////////////////
/* This is the "this error is due to be printed shortly; so have a
look at it any print any preamble you want" function. Which, in
Ptrcheck, we don't use. Hence a no-op.
*/
void pc_before_pp_Error ( Error* err ) {
}
/* Do a printf-style operation on either the XML or normal output
channel, depending on the setting of VG_(clo_xml).
*/
static void emit_WRK ( const HChar* format, va_list vargs )
{
if (VG_(clo_xml)) {
VG_(vprintf_xml)(format, vargs);
} else {
VG_(vmessage)(Vg_UserMsg, format, vargs);
}
}
static void emit ( const HChar* format, ... ) PRINTF_CHECK(1, 2);
static void emit ( const HChar* format, ... )
{
va_list vargs;
va_start(vargs, format);
emit_WRK(format, vargs);
va_end(vargs);
}
static void emiN ( const HChar* format, ... ) /* With NO FORMAT CHECK */
{
va_list vargs;
va_start(vargs, format);
emit_WRK(format, vargs);
va_end(vargs);
}
static const HChar* readwrite(SSizeT sszB)
{
return ( sszB < 0 ? "write" : "read" );
}
static Word Word__abs ( Word w ) {
return w < 0 ? -w : w;
}
void pc_pp_Error ( Error* err )
{
const Bool xml = VG_(clo_xml); /* a shorthand, that's all */
XError *xe = (XError*)VG_(get_error_extra)(err);
tl_assert(xe);
if (xml)
emit( " <kind>%s</kind>\n", pc_get_error_name(err));
switch (VG_(get_error_kind)(err)) {
//----------------------------------------------------------
case XE_SorG:
if (xml) {
emit( " <what>Invalid %s of size %ld</what>\n",
xe->XE.SorG.sszB < 0 ? "write" : "read",
Word__abs(xe->XE.SorG.sszB) );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
emit( " <auxwhat>Address %#lx expected vs actual:</auxwhat>\n",
xe->XE.SorG.addr );
emiN( " <auxwhat>Expected: %pS</auxwhat>\n",
&xe->XE.SorG.expect[0] );
emiN( " <auxwhat>Actual: %pS</auxwhat>\n",
&xe->XE.SorG.actual[0] );
} else {
emit( "Invalid %s of size %ld\n",
xe->XE.SorG.sszB < 0 ? "write" : "read",
Word__abs(xe->XE.SorG.sszB) );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
emit( " Address %#lx expected vs actual:\n", xe->XE.SorG.addr );
emit( " Expected: %s\n", &xe->XE.SorG.expect[0] );
emit( " Actual: %s\n", &xe->XE.SorG.actual[0] );
if (xe->XE.SorG.delta[0] != 0)
emit(" Actual: is %s Expected\n", &xe->XE.SorG.delta[0]);
}
break;
//----------------------------------------------------------
case XE_Heap: {
const HChar *place, *legit, *how_invalid;
Addr a = xe->XE.Heap.addr;
Seg* vseg = xe->XE.Heap.vseg;
tl_assert(is_known_segment(vseg) || NONPTR == vseg);
if (NONPTR == vseg) {
// Access via a non-pointer
if (xml) {
emit( " <what>Invalid %s of size %ld</what>\n",
readwrite(xe->XE.Heap.sszB),
Word__abs(xe->XE.Heap.sszB) );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
emit( " <auxwhat>Address %#lx is not derived from "
"any known block</auxwhat>\n", a );
} else {
emit( "Invalid %s of size %ld\n",
readwrite(xe->XE.Heap.sszB),
Word__abs(xe->XE.Heap.sszB) );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
emit( " Address %#lx is not derived from "
"any known block\n", a );
}
} else {
// Access via a pointer, but outside its range.
Int cmp;
UWord miss_size;
Seg__cmp(vseg, a, &cmp, &miss_size);
if (cmp < 0) place = "before";
else if (cmp == 0) place = "inside";
else place = "after";
how_invalid = ( ( Seg__is_freed(vseg) && 0 != cmp )
? "Doubly-invalid" : "Invalid" );
legit = ( Seg__is_freed(vseg) ? "once-" : "" );
if (xml) {
emit( " <what>%s %s of size %ld</what>\n",
how_invalid,
readwrite(xe->XE.Heap.sszB),
Word__abs(xe->XE.Heap.sszB) );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
emit( " <auxwhat>Address %#lx is %lu bytes %s "
"the accessing pointer's</auxwhat>\n",
a, miss_size, place );
emit( " <auxwhat>%slegitimate range, "
"a block of size %lu %s</auxwhat>\n",
legit, Seg__size(vseg),
Seg__is_freed(vseg) ? "free'd" : "alloc'd" );
VG_(pp_ExeContext)(Seg__where(vseg));
} else {
emit( "%s %s of size %ld\n",
how_invalid,
readwrite(xe->XE.Heap.sszB),
Word__abs(xe->XE.Heap.sszB) );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
emit( " Address %#lx is %lu bytes %s the accessing pointer's\n",
a, miss_size, place );
emit( " %slegitimate range, a block of size %lu %s\n",
legit, Seg__size(vseg),
Seg__is_freed(vseg) ? "free'd" : "alloc'd" );
VG_(pp_ExeContext)(Seg__where(vseg));
}
}
/* If we have a better description of the address, show it.
Note that in XML mode, it will already by nicely wrapped up
in tags, either <auxwhat> or <xauxwhat>, so we can just emit
it verbatim. */
if (xml) {
if (xe->XE.Heap.descr1)
emiN( " %pS\n",
(HChar*)VG_(indexXA)( xe->XE.Heap.descr1, 0 ) );
if (xe->XE.Heap.descr2)
emiN( " %pS\n",
(HChar*)VG_(indexXA)( xe->XE.Heap.descr2, 0 ) );
if (xe->XE.Heap.datasym[0] != 0)
emiN( " <auxwhat>Address 0x%llx is %llu bytes "
"inside data symbol \"%pS\"</auxwhat>\n",
(ULong)xe->XE.Heap.addr,
(ULong)xe->XE.Heap.datasymoff,
xe->XE.Heap.datasym );
} else {
if (xe->XE.Heap.descr1)
emit( " %s\n",
(HChar*)VG_(indexXA)( xe->XE.Heap.descr1, 0 ) );
if (xe->XE.Heap.descr2)
emit( " %s\n",
(HChar*)VG_(indexXA)( xe->XE.Heap.descr2, 0 ) );
if (xe->XE.Heap.datasym[0] != 0)
emit( " Address 0x%llx is %llu bytes "
"inside data symbol \"%s\"\n",
(ULong)xe->XE.Heap.addr,
(ULong)xe->XE.Heap.datasymoff,
xe->XE.Heap.datasym );
}
break;
}
//----------------------------------------------------------
case XE_Arith: {
Seg* seg1 = xe->XE.Arith.seg1;
Seg* seg2 = xe->XE.Arith.seg2;
const HChar* which;
tl_assert(BOTTOM != seg1);
tl_assert(BOTTOM != seg2 && UNKNOWN != seg2);
if (xml) {
emit( " <what>Invalid arguments to %s</what>\n",
xe->XE.Arith.opname );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
if (seg1 != seg2) {
if (NONPTR == seg1) {
emit( " <auxwhat>First arg not a pointer</auxwhat>\n" );
} else if (UNKNOWN == seg1) {
emit( " <auxwhat>First arg may be a pointer</auxwhat>\n" );
} else {
emit( " <auxwhat>First arg derived from address %#lx of "
"%lu-byte block alloc'd</auxwhat>\n",
Seg__addr(seg1), Seg__size(seg1) );
VG_(pp_ExeContext)(Seg__where(seg1));
}
which = "Second arg";
} else {
which = "Both args";
}
if (NONPTR == seg2) {
emit( " <auxwhat>%s not a pointer</auxwhat>\n", which );
} else {
emit( " <auxwhat>%s derived from address %#lx of "
"%lu-byte block alloc'd</auxwhat>\n",
which, Seg__addr(seg2), Seg__size(seg2) );
VG_(pp_ExeContext)(Seg__where(seg2));
}
} else {
emit( "Invalid arguments to %s\n",
xe->XE.Arith.opname );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
if (seg1 != seg2) {
if (NONPTR == seg1) {
emit( " First arg not a pointer\n" );
} else if (UNKNOWN == seg1) {
emit( " First arg may be a pointer\n" );
} else {
emit( " First arg derived from address %#lx of "
"%lu-byte block alloc'd\n",
Seg__addr(seg1), Seg__size(seg1) );
VG_(pp_ExeContext)(Seg__where(seg1));
}
which = "Second arg";
} else {
which = "Both args";
}
if (NONPTR == seg2) {
emit( " %s not a pointer\n", which );
} else {
emit( " %s derived from address %#lx of "
"%lu-byte block alloc'd\n",
which, Seg__addr(seg2), Seg__size(seg2) );
VG_(pp_ExeContext)(Seg__where(seg2));
}
}
break;
}
//----------------------------------------------------------
case XE_SysParam: {
Addr lo = xe->XE.SysParam.lo;
Addr hi = xe->XE.SysParam.hi;
Seg* seglo = xe->XE.SysParam.seglo;
Seg* seghi = xe->XE.SysParam.seghi;
const HChar* s = VG_(get_error_string) (err);
const HChar* what;
tl_assert(BOTTOM != seglo && BOTTOM != seghi);
if (Vg_CoreSysCall == xe->XE.SysParam.part)
what = "Syscall param ";
else VG_(tool_panic)("bad CorePart");
if (seglo == seghi) {
// freed block
tl_assert(is_known_segment(seglo));
tl_assert(Seg__is_freed(seglo)); // XXX what if it's now recycled?
if (xml) {
emit( " <what>%s%s contains unaddressable byte(s)</what>\n",
what, s );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
emit( " <auxwhat>Address %#lx is %ld bytes inside a "
"%ld-byte block free'd</auxwhat>\n",
lo, lo-Seg__addr(seglo), Seg__size(seglo) );
VG_(pp_ExeContext)(Seg__where(seglo));
} else {
emit( " %s%s contains unaddressable byte(s)\n",
what, s );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
emit( " Address %#lx is %ld bytes inside a "
"%ld-byte block free'd\n",
lo, lo-Seg__addr(seglo), Seg__size(seglo) );
VG_(pp_ExeContext)(Seg__where(seglo));
}
} else {
// mismatch
if (xml) {
emit( " <what>%s%s is non-contiguous</what>\n",
what, s );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
if (UNKNOWN == seglo) {
emit( " <auxwhat>First byte is "
"not inside a known block</auxwhat>\n" );
} else {
emit( " <auxwhat>First byte (%#lx) is %ld bytes inside a "
"%ld-byte block alloc'd</auxwhat>\n",
lo, lo-Seg__addr(seglo), Seg__size(seglo) );
VG_(pp_ExeContext)(Seg__where(seglo));
}
if (UNKNOWN == seghi) {
emit( " <auxwhat>Last byte is "
"not inside a known block</auxwhat>\n" );
} else {
emit( " <auxwhat>Last byte (%#lx) is %ld bytes inside a "
"%ld-byte block alloc'd</auxwhat>\n",
hi, hi-Seg__addr(seghi), Seg__size(seghi) );
VG_(pp_ExeContext)(Seg__where(seghi));
}
} else {
emit( "%s%s is non-contiguous\n",
what, s );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
if (UNKNOWN == seglo) {
emit( " First byte is not inside a known block\n" );
} else {
emit( " First byte (%#lx) is %ld bytes inside a "
"%ld-byte block alloc'd\n",
lo, lo-Seg__addr(seglo), Seg__size(seglo) );
VG_(pp_ExeContext)(Seg__where(seglo));
}
if (UNKNOWN == seghi) {
emit( " Last byte is not inside a known block\n" );
} else {
emit( " Last byte (%#lx) is %ld bytes inside a "
"%ld-byte block alloc'd\n",
hi, hi-Seg__addr(seghi), Seg__size(seghi) );
VG_(pp_ExeContext)(Seg__where(seghi));
}
}
}
break;
}
default:
VG_(tool_panic)("pp_Error: unrecognised error kind");
}
}
UInt pc_update_Error_extra ( Error* err )
{
XError *xe = (XError*)VG_(get_error_extra)(err);
tl_assert(xe);
switch (xe->tag) {
case XE_SorG:
break;
case XE_Heap: {
Bool have_descr;
tl_assert(sizeof(xe->XE.Heap.datasym) > 0);
xe->XE.Heap.datasymoff = 0;
xe->XE.Heap.datasym[0] = 0;
tl_assert(!xe->XE.Heap.descr1);
tl_assert(!xe->XE.Heap.descr2);
xe->XE.Heap.descr1
= VG_(newXA)( VG_(malloc), "pc.update_extra.Heap.descr1",
VG_(free), sizeof(HChar) );
xe->XE.Heap.descr2
= VG_(newXA)( VG_(malloc), "pc.update_extra.Heap.descr1",
VG_(free), sizeof(HChar) );
VG_(memset)(&xe->XE.Heap.datasym, 0, sizeof(xe->XE.Heap.datasym));
xe->XE.Heap.datasymoff = 0;
have_descr
= VG_(get_data_description)( xe->XE.Heap.descr1,
xe->XE.Heap.descr2,
xe->XE.Heap.addr );
/* If there's nothing in descr1/2, free it. Why is it safe to
to VG_(indexXA) at zero here? Because
VG_(get_data_description) guarantees to zero terminate
descr1/2 regardless of the outcome of the call. So there's
always at least one element in each XA after the call.
*/
if (0 == VG_(strlen)( VG_(indexXA)( xe->XE.Heap.descr1, 0 ))
|| !have_descr) {
VG_(deleteXA)( xe->XE.Heap.descr1 );
xe->XE.Heap.descr1 = NULL;
}
if (0 == VG_(strlen)( VG_(indexXA)( xe->XE.Heap.descr2, 0 ))
|| !have_descr) {
VG_(deleteXA)( xe->XE.Heap.descr2 );
xe->XE.Heap.descr2 = NULL;
}
/* If Dwarf3 info produced nothing useful, see at least if
we can fish something useful out of the ELF symbol info. */
if (!have_descr) {
if (VG_(get_datasym_and_offset)(
xe->XE.Heap.addr, &xe->XE.Heap.datasym[0],
sizeof(xe->XE.Heap.datasym)-1,
&xe->XE.Heap.datasymoff )
) {
tl_assert(xe->XE.Heap.datasym[sizeof(xe->XE.Heap.datasym)-1]
== 0);
}
}
break;
}
case XE_Arith:
break;
case XE_SysParam:
break;
default:
VG_(tool_panic)("update_extra");
}
return sizeof(XError);
}
Bool pc_is_recognised_suppression ( const HChar* name, Supp *su )
{
SuppKind skind;
if (VG_STREQ(name, "SorG")) skind = XS_SorG;
else if (VG_STREQ(name, "Heap")) skind = XS_Heap;
else if (VG_STREQ(name, "Arith")) skind = XS_Arith;
else if (VG_STREQ(name, "SysParam")) skind = XS_SysParam;
else
return False;
VG_(set_supp_kind)(su, skind);
return True;
}
Bool pc_read_extra_suppression_info ( Int fd, HChar** bufpp,
SizeT* nBufp, Int* lineno, Supp* su )
{
Bool eof;
if (VG_(get_supp_kind)(su) == XS_SysParam) {
eof = VG_(get_line) ( fd, bufpp, nBufp, lineno );
if (eof) return False;
VG_(set_supp_string)(su, VG_(strdup)("pc.common.presi.1", *bufpp));
}
return True;
}
Bool pc_error_matches_suppression (Error* err, Supp* su)
{
ErrorKind ekind = VG_(get_error_kind)(err);
switch (VG_(get_supp_kind)(su)) {
case XS_SorG: return ekind == XE_SorG;
case XS_Heap: return ekind == XE_Heap;
case XS_Arith: return ekind == XE_Arith;
case XS_SysParam: return ekind == XE_SysParam;
default:
VG_(printf)("Error:\n"
" unknown suppression type %d\n",
VG_(get_supp_kind)(su));
VG_(tool_panic)("unknown suppression type in "
"pc_error_matches_suppression");
}
}
const HChar* pc_get_error_name ( Error* err )
{
XError *xe = (XError*)VG_(get_error_extra)(err);
tl_assert(xe);
switch (xe->tag) {
case XE_SorG: return "SorG";
case XE_Heap: return "Heap";
case XE_Arith: return "Arith";
case XE_SysParam: return "SysParam";
default: VG_(tool_panic)("get_error_name: unexpected type");
}
}
Bool pc_get_extra_suppression_info ( Error* err,
/*OUT*/HChar* buf, Int nBuf )
{
ErrorKind ekind = VG_(get_error_kind )(err);
tl_assert(buf);
tl_assert(nBuf >= 16); // stay sane
if (XE_SysParam == ekind) {
const HChar* errstr = VG_(get_error_string)(err);
tl_assert(errstr);
VG_(snprintf)(buf, nBuf-1, "%s", errstr);
return True;
} else {
return False;
}
}
Bool pc_print_extra_suppression_use ( Supp* su,
/*OUT*/HChar* buf, Int nBuf )
{
return False;
}
void pc_update_extra_suppression_use (Error* err, Supp* su)
{
return;
}
/*--------------------------------------------------------------------*/
/*--- end pc_common.c ---*/
/*--------------------------------------------------------------------*/