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

First round of Char/HChar fixups for coregrind and memcheck.

Browse Source 
Little bit of ripple in tools, too.


git-svn-id: svn://svn.valgrind.org/valgrind/trunk@13074
This commit is contained in:
Florian Krohm 2012-10-21 19:43:43 +00:00
parent 979dc8596b
commit 79b79d6388
21 changed files with 110 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
coregrind/m_errormgr.c
View File

@ -139,7 +139,7 @@ struct _Error {
ExeContext* where; // Initialised by core
ErrorKind ekind; // Used by ALL. Must be in the range (0..)
Addr addr; // Used frequently
Char* string; // Used frequently
const HChar* string; // Used frequently
void* extra; // For any tool-specific extras
};
@ -159,7 +159,7 @@ Addr VG_(get_error_address) ( Error* err )
return err->addr;
}
Char* VG_(get_error_string) ( Error* err )
const HChar* VG_(get_error_string) ( Error* err )
{
return err->string;
}
@ -618,7 +618,7 @@ static void pp_Error ( Error* err, Bool allow_db_attach, Bool xml )
/* Construct an error */
static
void construct_error ( Error* err, ThreadId tid, ErrorKind ekind, Addr a,
Char* s, void* extra, ExeContext* where )
const HChar* s, void* extra, ExeContext* where )
{
/* DO NOT MAKE unique_counter NON-STATIC */
static UInt unique_counter = 0;
@ -652,7 +652,7 @@ void construct_error ( Error* err, ThreadId tid, ErrorKind ekind, Addr a,
All detected errors are notified here; this routine decides if/when the
user should see the error. */
void VG_(maybe_record_error) ( ThreadId tid,
ErrorKind ekind, Addr a, Char* s, void* extra )
ErrorKind ekind, Addr a, const HChar* s, void* extra )
{
Error err;
Error* p;
@ -824,7 +824,7 @@ void VG_(maybe_record_error) ( ThreadId tid,
suppressed. Bool 'print_error' dictates whether to print the error.
Bool 'count_error' dictates whether to count the error in n_errs_found.
*/
Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind, Addr a, Char* s,
Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind, Addr a, const HChar* s,
void* extra, ExeContext* where, Bool print_error,
Bool allow_db_attach, Bool count_error )
{

6
coregrind/m_main.c
View File

@ -108,7 +108,7 @@ static void usage_NORETURN ( Bool debug_help )
- for the name of the GDB executable
- for the name of vgdb's path prefix
which must be supplied when they are VG_(printf)'d. */
const HChar* usage1 =
const HChar usage1[] =
"usage: valgrind [options] prog-and-args\n"
"\n"
" tool-selection option, with default in [ ]:\n"
@ -200,7 +200,7 @@ static void usage_NORETURN ( Bool debug_help )
" in libxyzzy.so: --soname-synonyms=somalloc=libxyzzy.so\n"
"\n";
const HChar* usage2 =
const HChar usage2[] =
"\n"
" debugging options for all Valgrind tools:\n"
" -d show verbose debugging output\n"
@ -257,7 +257,7 @@ static void usage_NORETURN ( Bool debug_help )
" --trace-malloc=no|yes show client malloc details? [no]\n"
"\n";
const HChar* usage3 =
const HChar usage3[] =
"\n"
" Extra options read from ~/.valgrindrc, $VALGRIND_OPTS, ./.valgrindrc\n"
"\n"

18
coregrind/m_syswrap/priv_syswrap-generic.h
View File

@ -38,7 +38,7 @@
// address space.
extern
Bool ML_(valid_client_addr)(Addr start, SizeT size, ThreadId tid,
const Char *syscallname);
const HChar *syscallname);
/* Handy small function to help stop wrappers from segfaulting when
presented with bogus client addresses. Is not used for generating
@ -50,7 +50,8 @@ extern Bool ML_(client_signal_OK)(Int sigNo);
// Return true if we're allowed to use or create this fd.
extern
Bool ML_(fd_allowed)(Int fd, const Char *syscallname, ThreadId tid, Bool isNewFD);
Bool ML_(fd_allowed)(Int fd, const HChar *syscallname, ThreadId tid,
Bool isNewFD);
extern void ML_(record_fd_open_named) (ThreadId tid, Int fd);
extern void ML_(record_fd_open_nameless) (ThreadId tid, Int fd);
@ -74,10 +75,10 @@ ML_(notify_core_and_tool_of_mprotect) ( Addr a, SizeT len, Int prot );
extern void
ML_(buf_and_len_pre_check) ( ThreadId tid, Addr buf_p, Addr buflen_p,
Char* buf_s, Char* buflen_s );
const HChar* buf_s, const HChar* buflen_s );
extern void
ML_(buf_and_len_post_check) ( ThreadId tid, SysRes res,
Addr buf_p, Addr buflen_p, Char* s );
Addr buf_p, Addr buflen_p, const HChar* s );
/* PRE and POST for unknown ioctls based on ioctl request encoding */
extern
@ -235,9 +236,12 @@ extern void ML_(generic_PRE_sys_getsockname) ( TId, UW, UW, UW );
extern void ML_(generic_POST_sys_getsockname) ( TId, SR, UW, UW, UW );
extern void ML_(generic_PRE_sys_getpeername) ( TId, UW, UW, UW );
extern void ML_(generic_POST_sys_getpeername) ( TId, SR, UW, UW, UW );
extern void ML_(generic_PRE_sys_sendmsg) ( TId, Char *, struct vki_msghdr * );
extern void ML_(generic_PRE_sys_recvmsg) ( TId, Char *, struct vki_msghdr * );
extern void ML_(generic_POST_sys_recvmsg) ( TId, Char *, struct vki_msghdr *, UInt );
extern void ML_(generic_PRE_sys_sendmsg) ( TId, const HChar *,
struct vki_msghdr * );
extern void ML_(generic_PRE_sys_recvmsg) ( TId, const HChar *,
struct vki_msghdr * );
extern void ML_(generic_POST_sys_recvmsg) ( TId, const HChar *,
struct vki_msghdr *, UInt );
extern void ML_(generic_PRE_sys_semop) ( TId, UW, UW, UW );
extern void ML_(generic_PRE_sys_semtimedop) ( TId, UW, UW, UW, UW );

62
coregrind/m_syswrap/syswrap-generic.c
View File

@ -72,7 +72,7 @@
client or is free or a reservation. */
Bool ML_(valid_client_addr)(Addr start, SizeT size, ThreadId tid,
const Char *syscallname)
const HChar *syscallname)
{
Bool ret;
@ -592,7 +592,7 @@ void ML_(record_fd_open_with_given_name)(ThreadId tid, Int fd, char *pathname)
void ML_(record_fd_open_named)(ThreadId tid, Int fd)
{
static HChar buf[VKI_PATH_MAX];
Char* name;
HChar* name;
if (VG_(resolve_filename)(fd, buf, VKI_PATH_MAX))
name = buf;
else
@ -608,7 +608,7 @@ void ML_(record_fd_open_nameless)(ThreadId tid, Int fd)
}
static
Char *unix2name(struct vki_sockaddr_un *sa, UInt len, Char *name)
HChar *unix2name(struct vki_sockaddr_un *sa, UInt len, HChar *name)
{
if (sa == NULL || len == 0 || sa->sun_path[0] == '\0') {
VG_(sprintf)(name, "<unknown>");
@ -620,7 +620,7 @@ Char *unix2name(struct vki_sockaddr_un *sa, UInt len, Char *name)
}
static
Char *inet2name(struct vki_sockaddr_in *sa, UInt len, Char *name)
HChar *inet2name(struct vki_sockaddr_in *sa, UInt len, HChar *name)
{
if (sa == NULL || len == 0) {
VG_(sprintf)(name, "<unknown>");
@ -691,7 +691,7 @@ getsockdetails(Int fd)
/* Dump out a summary, and a more detailed list, of open file descriptors. */
void VG_(show_open_fds) (HChar* when)
void VG_(show_open_fds) (const HChar* when)
{
OpenFd *i = allocated_fds;
@ -802,10 +802,11 @@ void VG_(init_preopened_fds)(void)
}
static
Char *strdupcat ( HChar* cc, const Char *s1, const Char *s2, ArenaId aid )
HChar *strdupcat ( const HChar* cc, const HChar *s1, const HChar *s2,
ArenaId aid )
{
UInt len = VG_(strlen) ( s1 ) + VG_(strlen) ( s2 ) + 1;
Char *result = VG_(arena_malloc) ( aid, cc, len );
HChar *result = VG_(arena_malloc) ( aid, cc, len );
VG_(strcpy) ( result, s1 );
VG_(strcat) ( result, s2 );
return result;
@ -813,20 +814,20 @@ Char *strdupcat ( HChar* cc, const Char *s1, const Char *s2, ArenaId aid )
static
void pre_mem_read_sendmsg ( ThreadId tid, Bool read,
Char *msg, Addr base, SizeT size )
const HChar *msg, Addr base, SizeT size )
{
Char *outmsg = strdupcat ( "di.syswrap.pmrs.1",
"sendmsg", msg, VG_AR_CORE );
HChar *outmsg = strdupcat ( "di.syswrap.pmrs.1",
"sendmsg", msg, VG_AR_CORE );
PRE_MEM_READ( outmsg, base, size );
VG_(arena_free) ( VG_AR_CORE, outmsg );
}
static
void pre_mem_write_recvmsg ( ThreadId tid, Bool read,
Char *msg, Addr base, SizeT size )
const HChar *msg, Addr base, SizeT size )
{
Char *outmsg = strdupcat ( "di.syswrap.pmwr.1",
"recvmsg", msg, VG_AR_CORE );
HChar *outmsg = strdupcat ( "di.syswrap.pmwr.1",
"recvmsg", msg, VG_AR_CORE );
if ( read )
PRE_MEM_READ( outmsg, base, size );
else
@ -836,7 +837,7 @@ void pre_mem_write_recvmsg ( ThreadId tid, Bool read,
static
void post_mem_write_recvmsg ( ThreadId tid, Bool read,
Char *fieldName, Addr base, SizeT size )
const HChar *fieldName, Addr base, SizeT size )
{
if ( !read )
POST_MEM_WRITE( base, size );
@ -845,13 +846,13 @@ void post_mem_write_recvmsg ( ThreadId tid, Bool read,
static
void msghdr_foreachfield (
ThreadId tid,
Char *name,
const HChar *name,
struct vki_msghdr *msg,
UInt length,
void (*foreach_func)( ThreadId, Bool, Char *, Addr, SizeT )
void (*foreach_func)( ThreadId, Bool, const HChar *, Addr, SizeT )
)
{
Char *fieldName;
HChar *fieldName;
if ( !msg )
return;
@ -928,10 +929,10 @@ static void check_cmsg_for_fds(ThreadId tid, struct vki_msghdr *msg)
/* GrP kernel ignores sa_len (at least on Darwin); this checks the rest */
static
void pre_mem_read_sockaddr ( ThreadId tid,
Char *description,
const HChar *description,
struct vki_sockaddr *sa, UInt salen )
{
Char *outmsg;
HChar *outmsg;
struct vki_sockaddr_un* sun = (struct vki_sockaddr_un *)sa;
struct vki_sockaddr_in* sin = (struct vki_sockaddr_in *)sa;
struct vki_sockaddr_in6* sin6 = (struct vki_sockaddr_in6 *)sa;
@ -985,7 +986,7 @@ void pre_mem_read_sockaddr ( ThreadId tid,
}
/* Dereference a pointer to a UInt. */
static UInt deref_UInt ( ThreadId tid, Addr a, Char* s )
static UInt deref_UInt ( ThreadId tid, Addr a, const HChar* s )
{
UInt* a_p = (UInt*)a;
PRE_MEM_READ( s, (Addr)a_p, sizeof(UInt) );
@ -996,7 +997,7 @@ static UInt deref_UInt ( ThreadId tid, Addr a, Char* s )
}
void ML_(buf_and_len_pre_check) ( ThreadId tid, Addr buf_p, Addr buflen_p,
Char* buf_s, Char* buflen_s )
const HChar* buf_s, const HChar* buflen_s )
{
if (VG_(tdict).track_pre_mem_write) {
UInt buflen_in = deref_UInt( tid, buflen_p, buflen_s);
@ -1008,7 +1009,7 @@ void ML_(buf_and_len_pre_check) ( ThreadId tid, Addr buf_p, Addr buflen_p,
}
void ML_(buf_and_len_post_check) ( ThreadId tid, SysRes res,
Addr buf_p, Addr buflen_p, Char* s )
Addr buf_p, Addr buflen_p, const HChar* s )
{
if (!sr_isError(res) && VG_(tdict).track_post_mem_write) {
UInt buflen_out = deref_UInt( tid, buflen_p, s);
@ -1156,7 +1157,8 @@ descriptors can be created above the new soft limit.
*/
/* Return true if we're allowed to use or create this fd */
Bool ML_(fd_allowed)(Int fd, const Char *syscallname, ThreadId tid, Bool isNewFd)
Bool ML_(fd_allowed)(Int fd, const HChar *syscallname, ThreadId tid,
Bool isNewFd)
{
Bool allowed = True;
@ -1507,7 +1509,8 @@ ML_(generic_POST_sys_getpeername) ( ThreadId tid,
/* ------ */
void
ML_(generic_PRE_sys_sendmsg) ( ThreadId tid, Char *name, struct vki_msghdr *msg )
ML_(generic_PRE_sys_sendmsg) ( ThreadId tid, const HChar *name,
struct vki_msghdr *msg )
{
msghdr_foreachfield ( tid, name, msg, ~0, pre_mem_read_sendmsg );
}
@ -1515,13 +1518,15 @@ ML_(generic_PRE_sys_sendmsg) ( ThreadId tid, Char *name, struct vki_msghdr *msg
/* ------ */
void
ML_(generic_PRE_sys_recvmsg) ( ThreadId tid, Char *name, struct vki_msghdr *msg )
ML_(generic_PRE_sys_recvmsg) ( ThreadId tid, const HChar *name,
struct vki_msghdr *msg )
{
msghdr_foreachfield ( tid, name, msg, ~0, pre_mem_write_recvmsg );
}
void
ML_(generic_POST_sys_recvmsg) ( ThreadId tid, Char *name, struct vki_msghdr *msg, UInt length )
ML_(generic_POST_sys_recvmsg) ( ThreadId tid, const HChar *name,
struct vki_msghdr *msg, UInt length )
{
msghdr_foreachfield( tid, name, msg, length, post_mem_write_recvmsg );
check_cmsg_for_fds( tid, msg );
@ -2482,7 +2487,7 @@ PRE(sys_flock)
}
// Pre_read a char** argument.
static void pre_argv_envp(Addr a, ThreadId tid, Char* s1, Char* s2)
static void pre_argv_envp(Addr a, ThreadId tid, const HChar* s1, const HChar* s2)
{
while (True) {
Addr a_deref;
@ -2582,7 +2587,7 @@ PRE(sys_execve)
// ok, etc. We allow setuid executables to run only in the case when
// we are not simulating them, that is, they to be run natively.
setuid_allowed = trace_this_child ? False : True;
res = VG_(pre_exec_check)((const Char*)ARG1, NULL, setuid_allowed);
res = VG_(pre_exec_check)((const HChar *)ARG1, NULL, setuid_allowed);
if (sr_isError(res)) {
SET_STATUS_Failure( sr_Err(res) );
return;
@ -4217,4 +4222,3 @@ POST(sys_sigaltstack)
/*--------------------------------------------------------------------*/
/*--- end ---*/
/*--------------------------------------------------------------------*/

6
coregrind/m_syswrap/syswrap-linux.c
View File

@ -3684,7 +3684,7 @@ PRE(sys_process_vm_writev)
PRE(sys_sendmmsg)
{
struct vki_mmsghdr *mmsg = (struct vki_mmsghdr *)ARG2;
Char name[32];
HChar name[32];
UInt i;
*flags |= SfMayBlock;
PRINT("sys_sendmmsg ( %ld, %#lx, %ld, %ld )",ARG1,ARG2,ARG3,ARG4);
@ -3712,7 +3712,7 @@ POST(sys_sendmmsg)
PRE(sys_recvmmsg)
{
struct vki_mmsghdr *mmsg = (struct vki_mmsghdr *)ARG2;
Char name[32];
HChar name[32];
UInt i;
*flags |= SfMayBlock;
PRINT("sys_recvmmsg ( %ld, %#lx, %ld, %ld, %#lx )",ARG1,ARG2,ARG3,ARG4,ARG5);
@ -3733,7 +3733,7 @@ POST(sys_recvmmsg)
{
if (RES > 0) {
struct vki_mmsghdr *mmsg = (struct vki_mmsghdr *)ARG2;
Char name[32];
HChar name[32];
UInt i;
for (i = 0; i < RES; i++) {
VG_(sprintf)(name, "mmsg[%u].msg_hdr", i);

12
coregrind/m_tooliface.c
View File

@ -233,7 +233,7 @@ void VG_(needs_tool_errors)(
Bool (*recog) (Char*, Supp*),
Bool (*read_extra) (Int, Char**, SizeT*, Supp*),
Bool (*matches) (Error*, Supp*),
Char* (*name) (Error*),
const HChar* (*name) (Error*),
Bool (*get_xtra_si)(Error*,/*OUT*/Char*,Int)
)
{
@ -395,13 +395,13 @@ DEF0(track_die_mem_stack, Addr, SizeT)
DEF0(track_ban_mem_stack, Addr, SizeT)
DEF0(track_pre_mem_read, CorePart, ThreadId, Char*, Addr, SizeT)
DEF0(track_pre_mem_read_asciiz, CorePart, ThreadId, Char*, Addr)
DEF0(track_pre_mem_write, CorePart, ThreadId, Char*, Addr, SizeT)
DEF0(track_pre_mem_read, CorePart, ThreadId, const HChar*, Addr, SizeT)
DEF0(track_pre_mem_read_asciiz, CorePart, ThreadId, const HChar*, Addr)
DEF0(track_pre_mem_write, CorePart, ThreadId, const HChar*, Addr, SizeT)
DEF0(track_post_mem_write, CorePart, ThreadId, Addr, SizeT)
DEF0(track_pre_reg_read, CorePart, ThreadId, Char*, PtrdiffT, SizeT)
DEF0(track_post_reg_write, CorePart, ThreadId, PtrdiffT, SizeT)
DEF0(track_pre_reg_read, CorePart, ThreadId, const HChar*, PtrdiffT, SizeT)
DEF0(track_post_reg_write, CorePart, ThreadId, PtrdiffT, SizeT)
DEF0(track_post_reg_write_clientcall_return, ThreadId, PtrdiffT, SizeT, Addr)

2
coregrind/pub_core_syswrap.h
View File

@ -63,7 +63,7 @@ extern void VG_(cleanup_thread) ( ThreadArchState* );
/* fd leakage calls. */
extern void VG_(init_preopened_fds) ( void );
extern void VG_(show_open_fds) ( HChar* when );
extern void VG_(show_open_fds) ( const HChar* when );
// When the final thread is done, where shall I call to shutdown the
// system cleanly? Is set once at startup (in m_main) and never

12
coregrind/pub_core_tooliface.h
View File

@ -124,7 +124,7 @@ typedef struct {
Bool (*tool_recognised_suppression) (Char*, Supp*);
Bool (*tool_read_extra_suppression_info) (Int, Char**, SizeT*, Supp*);
Bool (*tool_error_matches_suppression) (Error*, Supp*);
Char* (*tool_get_error_name) (Error*);
const HChar* (*tool_get_error_name) (Error*);
Bool (*tool_get_extra_suppression_info) (Error*,/*OUT*/Char*,Int);
// VG_(needs).superblock_discards
@ -212,13 +212,13 @@ typedef struct {
void (*track_ban_mem_stack)(Addr, SizeT);
void (*track_pre_mem_read) (CorePart, ThreadId, Char*, Addr, SizeT);
void (*track_pre_mem_read_asciiz)(CorePart, ThreadId, Char*, Addr);
void (*track_pre_mem_write) (CorePart, ThreadId, Char*, Addr, SizeT);
void (*track_pre_mem_read) (CorePart, ThreadId, const HChar*, Addr, SizeT);
void (*track_pre_mem_read_asciiz)(CorePart, ThreadId, const HChar*, Addr);
void (*track_pre_mem_write) (CorePart, ThreadId, const HChar*, Addr, SizeT);
void (*track_post_mem_write) (CorePart, ThreadId, Addr, SizeT);
void (*track_pre_reg_read) (CorePart, ThreadId, Char*, PtrdiffT, SizeT);
void (*track_post_reg_write)(CorePart, ThreadId, PtrdiffT, SizeT);
void (*track_pre_reg_read) (CorePart, ThreadId, const HChar*, PtrdiffT, SizeT);
void (*track_post_reg_write)(CorePart, ThreadId, PtrdiffT, SizeT);
void (*track_post_reg_write_clientcall_return)(ThreadId, PtrdiffT, SizeT,
Addr);

4
drd/drd_error.c
View File

@ -43,7 +43,7 @@
/* Local function declarations. */
static Char* drd_get_error_name(Error* e);
static const HChar* drd_get_error_name(Error* e);
/* Local variables. */
@ -569,7 +569,7 @@ static Bool drd_error_matches_suppression(Error* const e, Supp* const supp)
return VG_(get_supp_kind)(supp) == VG_(get_error_kind)(e);
}
static Char* drd_get_error_name(Error* e)
static const HChar* drd_get_error_name(Error* e)
{
switch (VG_(get_error_kind)(e))
{

4
drd/drd_main.c
View File

@ -262,7 +262,7 @@ static void DRD_(print_debug_usage)(void)
static void drd_pre_mem_read(const CorePart part,
const ThreadId tid,
Char* const s,
const HChar* const s,
const Addr a,
const SizeT size)
{
@ -274,7 +274,7 @@ static void drd_pre_mem_read(const CorePart part,
static void drd_pre_mem_read_asciiz(const CorePart part,
const ThreadId tid,
Char* const s,
const HChar* const s,
const Addr a)
{
const char* p = (void*)a;

2
exp-dhat/dh_main.c
View File

@ -727,7 +727,7 @@ void dh_handle_read ( Addr addr, UWord szB )
// boundary and so we can treat it just as one giant
// read or write.
static
void dh_handle_noninsn_read ( CorePart part, ThreadId tid, Char* s,
void dh_handle_noninsn_read ( CorePart part, ThreadId tid, const HChar* s,
Addr base, SizeT size )
{
switch (part) {

6
exp-sgcheck/pc_common.c
View File

@ -544,7 +544,7 @@ void pc_pp_Error ( Error* err )
Addr hi = xe->XE.SysParam.hi;
Seg* seglo = xe->XE.SysParam.seglo;
Seg* seghi = xe->XE.SysParam.seghi;
Char* s = VG_(get_error_string) (err);
const HChar* s = VG_(get_error_string) (err);
HChar* what;
tl_assert(BOTTOM != seglo && BOTTOM != seghi);
@ -764,7 +764,7 @@ Bool pc_error_matches_suppression (Error* err, Supp* su)
}
}
HChar* pc_get_error_name ( Error* err )
const HChar* pc_get_error_name ( Error* err )
{
XError *xe = (XError*)VG_(get_error_extra)(err);
tl_assert(xe);
@ -784,7 +784,7 @@ Bool pc_get_extra_suppression_info ( Error* err,
tl_assert(buf);
tl_assert(nBuf >= 16); // stay sane
if (XE_SysParam == ekind) {
Char* errstr = VG_(get_error_string)(err);
const HChar* errstr = VG_(get_error_string)(err);
tl_assert(errstr);
VG_(snprintf)(buf, nBuf-1, "%s", errstr);
return True;

2
exp-sgcheck/pc_common.h
View File

@ -55,7 +55,7 @@ Bool pc_is_recognised_suppression ( Char* name, Supp *su );
Bool pc_read_extra_suppression_info ( Int fd, Char** bufpp,
SizeT* nBufp, Supp* su );
Bool pc_error_matches_suppression (Error* err, Supp* su);
HChar* pc_get_error_name ( Error* err );
const HChar* pc_get_error_name ( Error* err );
Bool pc_get_extra_suppression_info ( Error* err,
/*OUT*/Char* buf, Int nBuf );

2
helgrind/hg_errors.c
View File

@ -1333,7 +1333,7 @@ void HG_(pp_Error) ( Error* err )
} /* switch (VG_(get_error_kind)(err)) */
}
HChar* HG_(get_error_name) ( Error* err )
const HChar* HG_(get_error_name) ( Error* err )
{
switch (VG_(get_error_kind)(err)) {
case XE_Race: return "Race";

2
helgrind/hg_errors.h
View File

@ -43,7 +43,7 @@ Bool HG_(recognised_suppression) ( Char* name, Supp *su );
Bool HG_(read_extra_suppression_info) ( Int fd, Char** bufpp, SizeT* nBufp,
Supp* su );
Bool HG_(error_matches_suppression) ( Error* err, Supp* su );
HChar* HG_(get_error_name) ( Error* err );
const HChar* HG_(get_error_name) ( Error* err );
Bool HG_(get_extra_suppression_info) ( Error* err,
/*OUT*/Char* buf, Int nBuf );

6
helgrind/hg_main.c
View File

@ -1701,7 +1701,7 @@ void evh__HG_PTHREAD_JOIN_POST ( ThreadId stay_tid, Thread* quit_thr )
}
static
void evh__pre_mem_read ( CorePart part, ThreadId tid, Char* s,
void evh__pre_mem_read ( CorePart part, ThreadId tid, const HChar* s,
Addr a, SizeT size) {
if (SHOW_EVENTS >= 2
|| (SHOW_EVENTS >= 1 && size != 1))
@ -1714,7 +1714,7 @@ void evh__pre_mem_read ( CorePart part, ThreadId tid, Char* s,
static
void evh__pre_mem_read_asciiz ( CorePart part, ThreadId tid,
Char* s, Addr a ) {
const HChar* s, Addr a ) {
Int len;
if (SHOW_EVENTS >= 1)
VG_(printf)("evh__pre_mem_asciiz(ctid=%d, \"%s\", %p)\n",
@ -1732,7 +1732,7 @@ void evh__pre_mem_read_asciiz ( CorePart part, ThreadId tid,
}
static
void evh__pre_mem_write ( CorePart part, ThreadId tid, Char* s,
void evh__pre_mem_write ( CorePart part, ThreadId tid, const HChar* s,
Addr a, SizeT size ) {
if (SHOW_EVENTS >= 1)
VG_(printf)("evh__pre_mem_write(ctid=%d, \"%s\", %p, %lu)\n",

14
include/pub_tool_errormgr.h
View File

@ -56,11 +56,11 @@ typedef
/* Useful in VG_(tdict).tool_error_matches_suppression(),
* VG_(tdict).tool_pp_Error(), etc */
ExeContext* VG_(get_error_where) ( Error* err );
ErrorKind VG_(get_error_kind) ( Error* err );
Addr VG_(get_error_address) ( Error* err );
Char* VG_(get_error_string) ( Error* err );
void* VG_(get_error_extra) ( Error* err );
ExeContext* VG_(get_error_where) ( Error* err );
ErrorKind VG_(get_error_kind) ( Error* err );
Addr VG_(get_error_address) ( Error* err );
const HChar* VG_(get_error_string) ( Error* err );
void* VG_(get_error_extra) ( Error* err );
/* Call this when an error occurs. It will be recorded if it hasn't been
seen before. If it has, the existing error record will have its count
@ -73,7 +73,7 @@ void* VG_(get_error_extra) ( Error* err );
If no 'a', 's' or 'extra' of interest needs to be recorded, just use
NULL for them. */
extern void VG_(maybe_record_error) ( ThreadId tid, ErrorKind ekind,
Addr a, Char* s, void* extra );
Addr a, const HChar* s, void* extra );
/* Similar to VG_(maybe_record_error)(), except this one doesn't record the
error -- useful for errors that can only happen once. The errors can be
@ -83,7 +83,7 @@ extern void VG_(maybe_record_error) ( ThreadId tid, ErrorKind ekind,
be suppressed without possibly printing it. 'count_error' dictates
whether to add the error in the error total count (another mild hack). */
extern Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind,
Addr a, Char* s, void* extra,
Addr a, const HChar* s, void* extra,
ExeContext* where, Bool print_error,
Bool allow_GDB_attach, Bool count_error );

10
include/pub_tool_tooliface.h
View File

@ -331,7 +331,7 @@ extern void VG_(needs_tool_errors) (
// This should return the suppression name, for --gen-suppressions, or NULL
// if that error type cannot be suppressed. This is the inverse of
// VG_(tdict).tool_recognised_suppression().
Char* (*get_error_name)(Error* err),
const HChar* (*get_error_name)(Error* err),
// This should print into buf[0..nBuf-1] any extra info for the
// error, for --gen-suppressions, but not including any leading
@ -585,18 +585,18 @@ void VG_(track_ban_mem_stack) (void(*f)(Addr a, SizeT len));
/* These ones occur around syscalls, signal handling, etc */
void VG_(track_pre_mem_read) (void(*f)(CorePart part, ThreadId tid,
Char* s, Addr a, SizeT size));
const HChar* s, Addr a, SizeT size));
void VG_(track_pre_mem_read_asciiz)(void(*f)(CorePart part, ThreadId tid,
Char* s, Addr a));
const HChar* s, Addr a));
void VG_(track_pre_mem_write) (void(*f)(CorePart part, ThreadId tid,
Char* s, Addr a, SizeT size));
const HChar* s, Addr a, SizeT size));
void VG_(track_post_mem_write) (void(*f)(CorePart part, ThreadId tid,
Addr a, SizeT size));
/* Register events. Use VG_(set_shadow_state_area)() to set the shadow regs
for these events. */
void VG_(track_pre_reg_read) (void(*f)(CorePart part, ThreadId tid,
Char* s, PtrdiffT guest_state_offset,
const HChar* s, PtrdiffT guest_state_offset,
SizeT size));
void VG_(track_post_reg_write)(void(*f)(CorePart part, ThreadId tid,
PtrdiffT guest_state_offset,

14
memcheck/mc_errors.c
View File

@ -890,12 +890,12 @@ void MC_(record_cond_error) ( ThreadId tid, UInt otag )
/* --- Called from non-generated code --- */
/* This is for memory errors in signal-related memory. */
void MC_(record_core_mem_error) ( ThreadId tid, Char* msg )
void MC_(record_core_mem_error) ( ThreadId tid, const HChar* msg )
{
VG_(maybe_record_error)( tid, Err_CoreMem, /*addr*/0, msg, /*extra*/NULL );
}
void MC_(record_regparam_error) ( ThreadId tid, Char* msg, UInt otag )
void MC_(record_regparam_error) ( ThreadId tid, const HChar* msg, UInt otag )
{
MC_Error extra;
tl_assert(VG_INVALID_THREADID != tid);
@ -907,7 +907,7 @@ void MC_(record_regparam_error) ( ThreadId tid, Char* msg, UInt otag )
}
void MC_(record_memparam_error) ( ThreadId tid, Addr a,
Bool isAddrErr, Char* msg, UInt otag )
Bool isAddrErr, const HChar* msg, UInt otag )
{
MC_Error extra;
tl_assert(VG_INVALID_THREADID != tid);
@ -963,7 +963,7 @@ void MC_(record_illegal_mempool_error) ( ThreadId tid, Addr a )
VG_(maybe_record_error)( tid, Err_IllegalMempool, a, /*s*/NULL, &extra );
}
void MC_(record_overlap_error) ( ThreadId tid, Char* function,
void MC_(record_overlap_error) ( ThreadId tid, const HChar* function,
Addr src, Addr dst, SizeT szB )
{
MC_Error extra;
@ -1025,7 +1025,7 @@ Bool MC_(eq_Error) ( VgRes res, Error* e1, Error* e2 )
switch (VG_(get_error_kind)(e1)) {
case Err_CoreMem: {
Char *e1s, *e2s;
const HChar *e1s, *e2s;
e1s = VG_(get_error_string)(e1);
e2s = VG_(get_error_string)(e2);
if (e1s == e2s) return True;
@ -1518,7 +1518,7 @@ Bool MC_(error_matches_suppression) ( Error* err, Supp* su )
}
}
HChar* MC_(get_error_name) ( Error* err )
const HChar* MC_(get_error_name) ( Error* err )
{
switch (VG_(get_error_kind)(err)) {
case Err_RegParam: return "Param";
@ -1565,7 +1565,7 @@ Bool MC_(get_extra_suppression_info) ( Error* err,
tl_assert(buf);
tl_assert(nBuf >= 16); // stay sane
if (Err_RegParam == ekind || Err_MemParam == ekind) {
Char* errstr = VG_(get_error_string)(err);
const HChar* errstr = VG_(get_error_string)(err);
tl_assert(errstr);
VG_(snprintf)(buf, nBuf-1, "%s", errstr);
return True;

10
memcheck/mc_include.h
View File

@ -382,7 +382,7 @@ Bool MC_(error_matches_suppression) ( Error* err, Supp* su );
Bool MC_(get_extra_suppression_info) ( Error* err,
/*OUT*/Char* buf, Int nBuf );
HChar* MC_(get_error_name) ( Error* err );
const HChar* MC_(get_error_name) ( Error* err );
/* Recording of errors */
void MC_(record_address_error) ( ThreadId tid, Addr a, Int szB,
@ -395,12 +395,12 @@ void MC_(record_free_error) ( ThreadId tid, Addr a );
void MC_(record_illegal_mempool_error) ( ThreadId tid, Addr a );
void MC_(record_freemismatch_error) ( ThreadId tid, MC_Chunk* mc );
void MC_(record_overlap_error) ( ThreadId tid, Char* function,
void MC_(record_overlap_error) ( ThreadId tid, const HChar* function,
Addr src, Addr dst, SizeT szB );
void MC_(record_core_mem_error) ( ThreadId tid, Char* msg );
void MC_(record_regparam_error) ( ThreadId tid, Char* msg, UInt otag );
void MC_(record_core_mem_error) ( ThreadId tid, const HChar* msg );
void MC_(record_regparam_error) ( ThreadId tid, const HChar* msg, UInt otag );
void MC_(record_memparam_error) ( ThreadId tid, Addr a,
Bool isAddrErr, Char* msg, UInt otag );
Bool isAddrErr, const HChar* msg, UInt otag );
void MC_(record_user_error) ( ThreadId tid, Addr a,
Bool isAddrErr, UInt otag );

8
memcheck/mc_main.c
View File

@ -3723,7 +3723,7 @@ static Bool mc_is_defined_asciiz ( Addr a, Addr* bad_addr, UInt* otag )
/*------------------------------------------------------------*/
static
void check_mem_is_addressable ( CorePart part, ThreadId tid, Char* s,
void check_mem_is_addressable ( CorePart part, ThreadId tid, const HChar* s,
Addr base, SizeT size )
{
Addr bad_addr;
@ -3747,7 +3747,7 @@ void check_mem_is_addressable ( CorePart part, ThreadId tid, Char* s,
}
static
void check_mem_is_defined ( CorePart part, ThreadId tid, Char* s,
void check_mem_is_defined ( CorePart part, ThreadId tid, const HChar* s,
Addr base, SizeT size )
{
UInt otag = 0;
@ -3781,7 +3781,7 @@ void check_mem_is_defined ( CorePart part, ThreadId tid, Char* s,
static
void check_mem_is_defined_asciiz ( CorePart part, ThreadId tid,
Char* s, Addr str )
const HChar* s, Addr str )
{
MC_ReadResult res;
Addr bad_addr = 0; // shut GCC up
@ -3962,7 +3962,7 @@ void mc_post_reg_write_clientcall ( ThreadId tid,
[offset, offset+len). If any part of that is undefined, record
a parameter error.
*/
static void mc_pre_reg_read ( CorePart part, ThreadId tid, Char* s,
static void mc_pre_reg_read ( CorePart part, ThreadId tid, const HChar* s,
PtrdiffT offset, SizeT size)
{
Int i;