Lots of changes to future-proof the core/skin interface, making it less likely
that changes will cause binary incompatibilities. Mostly done by hiding naked
structs with function calls.
Structs hidden in this way were: UCodeBlock, SkinSupp and SkinError (which were
merged back with CoreSupp and CoreError into single types Supp and Error),
ShadowChunk, VgDetails, VgNeeds and VgTrackEvents. The last three are the most
important ones, as they are (I think) the most likely to change.
Suitable get()/set() methods were defined for each one. The way UCodeBlocks
are copied for instrumentation by skins is a little different now, using
setup_UCodeBlock. Had to add a few other functions here n there. Changed
how SK_(complete_shadow_chunk) works a bit.
Added a file coregrind/vg_needs.c which contains all the get/set functions.
It's pretty simple.
The changes are not totally ideal -- eg. ShadowChunks has get()/set() methods
for its `next' field which arguably shouldn't be exposed (betraying the fact
that it's a linked list), and the get()/set() methods are a bit cumbersome at
times, esp. for `Error' because the fields are accessed quite a few times, and
the treatment of Supps and Errors is a bit inconsistent (but they are used in
different ways), and sizeof_shadow_blocks is still a hack. But still better
than naked structs. And one advantage is that a bit of sanity checking can be
performed by the get()/set() methods, as is done for VG_({get,set}_sc_extra)()
to make sure no reading/writing occurs outside the allowed area.
I didn't do it for UInstr, because its fields are accessed directly in lots and
lots of spots, which would have been a great big pain and I was a little
worried about overhead of calling lots of extra functions, although in practice
translation times are small enough that it probably doesn't matter.
Updated the example skin and the docs, too, hurrah.
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@1314 a5019735-40e9-0310-863c-91ae7b9d1cf9
diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c
index 288359a..0d6e0f7 100644
--- a/memcheck/mc_main.c
+++ b/memcheck/mc_main.c
@@ -1519,18 +1519,18 @@
static __inline__
void set_where( ShadowChunk* sc, ExeContext* ec )
{
- sc->skin_extra[0] = (UInt)ec;
+ VG_(set_sc_extra)( sc, 0, (UInt)ec );
}
static __inline__
ExeContext *get_where( ShadowChunk* sc )
{
- return (ExeContext*)sc->skin_extra[0];
+ return (ExeContext*)VG_(get_sc_extra)(sc, 0);
}
void SK_(complete_shadow_chunk) ( ShadowChunk* sc, ThreadState* tst )
{
- set_where( sc, VG_(get_ExeContext) ( tst ) );
+ VG_(set_sc_extra) ( sc, 0, (UInt)VG_(get_ExeContext)(tst) );
}
/*------------------------------------------------------------*/
@@ -1547,7 +1547,7 @@
{
ShadowChunk* sc;
Int n = 0;
- for (sc = vg_freed_list_start; sc != NULL; sc = sc->next)
+ for (sc = vg_freed_list_start; sc != NULL; sc = VG_(get_sc_next)(sc))
n++;
return n;
}
@@ -1558,8 +1558,8 @@
ShadowChunk* sc;
Int n = 0;
/* VG_(printf)("freelist sanity\n"); */
- for (sc = vg_freed_list_start; sc != NULL; sc = sc->next)
- n += sc->size;
+ for (sc = vg_freed_list_start; sc != NULL; sc = VG_(get_sc_next)(sc))
+ n += VG_(get_sc_size)(sc);
sk_assert(n == vg_freed_list_volume);
}
@@ -1573,14 +1573,14 @@
if (vg_freed_list_end == NULL) {
sk_assert(vg_freed_list_start == NULL);
vg_freed_list_end = vg_freed_list_start = sc;
- vg_freed_list_volume = sc->size;
+ vg_freed_list_volume = VG_(get_sc_size)(sc);
} else {
- sk_assert(vg_freed_list_end->next == NULL);
- vg_freed_list_end->next = sc;
+ sk_assert(VG_(get_sc_next)(vg_freed_list_end) == NULL);
+ VG_(set_sc_next)(vg_freed_list_end, sc);
vg_freed_list_end = sc;
- vg_freed_list_volume += sc->size;
+ vg_freed_list_volume += VG_(get_sc_size)(sc);
}
- sc->next = NULL;
+ VG_(set_sc_next)(sc, NULL);
/* Release enough of the oldest blocks to bring the free queue
volume below vg_clo_freelist_vol. */
@@ -1591,16 +1591,16 @@
sk_assert(vg_freed_list_end != NULL);
sc1 = vg_freed_list_start;
- vg_freed_list_volume -= sc1->size;
+ vg_freed_list_volume -= VG_(get_sc_size)(sc1);
/* VG_(printf)("volume now %d\n", vg_freed_list_volume); */
sk_assert(vg_freed_list_volume >= 0);
if (vg_freed_list_start == vg_freed_list_end) {
vg_freed_list_start = vg_freed_list_end = NULL;
} else {
- vg_freed_list_start = sc1->next;
+ vg_freed_list_start = VG_(get_sc_next)(sc1);
}
- sc1->next = NULL; /* just paranoia */
+ VG_(set_sc_next)(sc1, NULL); /* just paranoia */
VG_(free_ShadowChunk) ( sc1 );
}
}
@@ -1613,7 +1613,7 @@
/* No point looking through freed blocks if we're not keeping
them around for a while... */
- for (sc = vg_freed_list_start; sc != NULL; sc = sc->next)
+ for (sc = vg_freed_list_start; sc != NULL; sc = VG_(get_sc_next)(sc))
if (p(sc))
return sc;
@@ -1937,57 +1937,56 @@
/*--- Setup ---*/
/*------------------------------------------------------------*/
-void SK_(pre_clo_init)(VgDetails* details, VgNeeds* needs, VgTrackEvents* track)
+void SK_(pre_clo_init)(void)
{
- details->name = "Memcheck";
- details->version = NULL;
- details->description = "a.k.a. Valgrind, a memory error detector";
- details->copyright_author =
- "Copyright (C) 2000-2002, and GNU GPL'd, by Julian Seward.";
- details->bug_reports_to = "jseward@acm.org";
+ VG_(details_name) ("Memcheck");
+ VG_(details_version) (NULL);
+ VG_(details_description) ("a.k.a. Valgrind, a memory error detector");
+ VG_(details_copyright_author)(
+ "Copyright (C) 2002, and GNU GPL'd, by Julian Seward.");
+ VG_(details_bug_reports_to) ("jseward@acm.org");
- needs->core_errors = True;
- needs->skin_errors = True;
- needs->libc_freeres = True;
- needs->sizeof_shadow_block = 1;
- needs->basic_block_discards = False;
- needs->shadow_regs = True;
- needs->command_line_options = True;
- needs->client_requests = True;
- needs->extended_UCode = True;
- needs->syscall_wrapper = True;
- needs->alternative_free = True;
- needs->sanity_checks = True;
+ VG_(needs_core_errors) ();
+ VG_(needs_skin_errors) ();
+ VG_(needs_libc_freeres) ();
+ VG_(needs_sizeof_shadow_block) ( 1 );
+ VG_(needs_shadow_regs) ();
+ VG_(needs_command_line_options)();
+ VG_(needs_client_requests) ();
+ VG_(needs_extended_UCode) ();
+ VG_(needs_syscall_wrapper) ();
+ VG_(needs_alternative_free) ();
+ VG_(needs_sanity_checks) ();
- track->new_mem_startup = & memcheck_new_mem_startup;
- track->new_mem_heap = & memcheck_new_mem_heap;
- track->new_mem_stack = & SK_(make_writable);
- track->new_mem_stack_aligned = & make_writable_aligned;
- track->new_mem_stack_signal = & SK_(make_writable);
- track->new_mem_brk = & SK_(make_writable);
- track->new_mem_mmap = & memcheck_set_perms;
+ VG_(track_new_mem_startup) ( & memcheck_new_mem_startup );
+ VG_(track_new_mem_heap) ( & memcheck_new_mem_heap );
+ VG_(track_new_mem_stack) ( & SK_(make_writable) );
+ VG_(track_new_mem_stack_aligned)( & make_writable_aligned );
+ VG_(track_new_mem_stack_signal) ( & SK_(make_writable) );
+ VG_(track_new_mem_brk) ( & SK_(make_writable) );
+ VG_(track_new_mem_mmap) ( & memcheck_set_perms );
- track->copy_mem_heap = & copy_address_range_state;
- track->copy_mem_remap = & copy_address_range_state;
- track->change_mem_mprotect = & memcheck_set_perms;
+ VG_(track_copy_mem_heap) ( & copy_address_range_state );
+ VG_(track_copy_mem_remap) ( & copy_address_range_state );
+ VG_(track_change_mem_mprotect) ( & memcheck_set_perms );
- track->ban_mem_heap = & SK_(make_noaccess);
- track->ban_mem_stack = & SK_(make_noaccess);
+ VG_(track_ban_mem_heap) ( & SK_(make_noaccess) );
+ VG_(track_ban_mem_stack) ( & SK_(make_noaccess) );
- track->die_mem_heap = & SK_(make_noaccess);
- track->die_mem_stack = & SK_(make_noaccess);
- track->die_mem_stack_aligned = & make_noaccess_aligned;
- track->die_mem_stack_signal = & SK_(make_noaccess);
- track->die_mem_brk = & SK_(make_noaccess);
- track->die_mem_munmap = & SK_(make_noaccess);
+ VG_(track_die_mem_heap) ( & SK_(make_noaccess) );
+ VG_(track_die_mem_stack) ( & SK_(make_noaccess) );
+ VG_(track_die_mem_stack_aligned)( & make_noaccess_aligned );
+ VG_(track_die_mem_stack_signal) ( & SK_(make_noaccess) );
+ VG_(track_die_mem_brk) ( & SK_(make_noaccess) );
+ VG_(track_die_mem_munmap) ( & SK_(make_noaccess) );
- track->bad_free = & SK_(record_free_error);
- track->mismatched_free = & SK_(record_freemismatch_error);
+ VG_(track_bad_free) ( & SK_(record_free_error) );
+ VG_(track_mismatched_free) ( & SK_(record_freemismatch_error) );
- track->pre_mem_read = & check_is_readable;
- track->pre_mem_read_asciiz = & check_is_readable_asciiz;
- track->pre_mem_write = & check_is_writable;
- track->post_mem_write = & SK_(make_readable);
+ VG_(track_pre_mem_read) ( & check_is_readable );
+ VG_(track_pre_mem_read_asciiz) ( & check_is_readable_asciiz );
+ VG_(track_pre_mem_write) ( & check_is_writable );
+ VG_(track_post_mem_write) ( & SK_(make_readable) );
VG_(register_compact_helper)((Addr) & SK_(helper_value_check4_fail));
VG_(register_compact_helper)((Addr) & SK_(helper_value_check0_fail));