3e88418f808bf2840646504481d6a5be1df16541 |
|
15-Apr-2003 |
njn <njn@a5019735-40e9-0310-863c-91ae7b9d1cf9> |
----------------------------------------------------------------------------- overview ----------------------------------------------------------------------------- Previously Valgrind had its own versions of malloc() et al that replaced glibc's. This is necessary for various reasons for Memcheck, but isn't needed, and was actually detrimental, to some other skins. I never managed to treat this satisfactorily w.r.t the core/skin split. Now I have. If a skin needs to know about malloc() et al, it must provide its own replacements. But because this is not uncommon, the core provides a module vg_replace_malloc.c which a skin can link with, which provides skeleton definitions, to reduce the amount of work a skin must do. The skeletons handle the transfer of control from the simd CPU to the real CPU, and also the --alignment, --sloppy-malloc and --trace-malloc options. These skeleton definitions subsequently call functions SK_(malloc), SK_(free), etc, which the skin must define; in these functions the skin can do the things it needs to do about tracking heap blocks. For skins that track extra info about malloc'd blocks -- previously done with ShadowChunks -- there is a new file vg_hashtable.c that implements a generic-ish hash table (using dodgy C-style inheritance using struct overlays) which allows skins to continue doing this fairly easily. Skins can also replace other functions too, eg. Memcheck has its own versions of strcpy(), memcpy(), etc. Overall, it's slightly more work now for skins that need to replace malloc(), but other skins don't have to use Valgrind's malloc(), so they're getting a "purer" program run, which is good, and most of the remaining rough edges from the core/skin split have been removed. ----------------------------------------------------------------------------- details ----------------------------------------------------------------------------- Moved malloc() et al intercepts from vg_clientfuncs.c into vg_replace_malloc.c. Skins can link to it if they want to replace malloc() and friends; it does some stuff then passes control to SK_(malloc)() et al which the skin must define. They can call VG_(cli_malloc)() and VG_(cli_free)() to do the actual allocation/deallocation. Redzone size for the client (the CLIENT arena) is specified by the static variable VG_(vg_malloc_redzone_szB). vg_replace_malloc.c thus represents a kind of "mantle" level service. To get automake to build vg_replace_malloc.o, had to resort to a similar trick as used for the demangler -- ask for a "no install" library (which is never used) to be built from it. Note that all malloc, calloc, realloc, builtin_new, builtin_vec_new, memalign are now aware of --alignment, when running on simd CPU or real CPU. This means the new_mem_heap, die_mem_heap, copy_mem_heap and ban_mem_heap events no longer exist, since the core doesn't control malloc() any more, and skins can watch for these events themselves. This required moving all the ShadowChunk stuff out of the core, which meant the sizeof_shadow_block ``need'' could be removed, yay -- it was a horrible hack. Now ShadowChunks are done with a generic HashTable type, in vg_hashtable.c, which skins can "inherit from" (in a dodgy C-only fashion by using structs with similar layouts). Also, the free_list stuff was all moved as a part of this. Also, VgAllocKind was moved out of core into Memcheck/Addrcheck and renamed MAC_AllocKind. Moved these options out of core into vg_replace_malloc.c: --trace-malloc --sloppy-malloc --alignment The alternative_free ``need'' could go, too, since Memcheck is now in complete control of free(), yay -- another horribility. The bad_free and free_mismatch events could go too, since they're now not detected by core, yay -- yet another horribility. Moved malloc() et al wrappers for Memcheck out of vg_clientmalloc.c into mac_malloc_wrappers.c. Helgrind has its own wrappers now too. Introduced VG_USERREQ__CLIENT_CALL[123] client requests. When a skin function is operating on the simd CPU, this will call a given function and run it on the real CPU. The macros VG_NON_SIMD_CALL[123] in valgrind.h present a cleaner interface to actually use. Also introduce analogues of these that pass 'tst' from the scheduler as the first arg to the called function -- needed for MC_(client_malloc)() et al. Fiddled with USERREQ_{MALLOC,FREE} etc. in vg_scheduler.c; they call SK_({malloc,free})() which by default call VG_(cli_malloc)() -- can't call glibc's malloc() here. All the other default SK_(calloc)() etc. instantly panic; there's a lock variable to ensure that the default SK_({malloc,free})() are only called from the scheduler, which prevents a skin from forgetting to override SK_({malloc,free})(). Got rid of the unused USERREQ_CALLOC, USERREQ_BUILTIN_NEW, etc. Moved special versions of strcpy/strlen, etc, memcpy() and memchr() into mac_replace_strmem.c -- they are only necessary for memcheck, because the hyper-optimised normal glibc versions confuse it, and for memcpy() etc. overlap checking. Also added dst/src overlap checks to strcpy(), memcpy(), strcat(). They are reported not as proper errors, but just with single line warnings, as for silly args to malloc() et al; this is mainly because they're on the simulated CPU and proper error handling would be a pain; hopefully they're rare enough to not be a problem. The strcpy check is done after the copy, because it would require counting the length of the string beforehand. Also added strncpy() and strncat(), which have overlap checks too. Note that addrcheck doesn't do overlap checking. Put USERREQ__LOGMESSAGE in vg_skin.h to do the overlap check error messages. After removing malloc() et al and strcpy() et al out of vg_clientfuncs.c, moved the remaining three things (sigsuspend, VG_(__libc_freeres_wrapper), __errno_location) into vg_intercept.c, since it contains things that run on the simulated CPU too. Removed vg_clientfuncs.c altogether. Moved regression test "malloc3" out of corecheck into memcheck, since corecheck no longer looks for silly (eg. negative) args to malloc(). Removed the m_eip, m_esp, m_ebp fields from the `Error' type. They were being set up, and then read immediately only once, only if GDB attachment was done. So now they're just being held in local variables. This saves 12 bytes per Error. Made replacement calloc() check for --sloppy-malloc; previously it didn't. Added "silly" negative size arg check to realloc(), it didn't have one. Changed VG_(read_selfprocmaps)() so it can parse the file directly, or from a previously read buffer. Buffer can be filled with the new VG_(read_selfprocmaps_contents)(). Using this at start-up to snapshot /proc/self/maps before the skins do anything, and then parsing it once they have done their setup stuff. Skins can now safely call VG_(malloc)() in SK_({pre,post}_clo_init)() without the mmap'd superblock erroneously being identified as client memory. Changed the --help usage message slightly, now divided into four sections: core normal, skin normal, core debugging, skin debugging. Changed the interface for the command_line_options need slightly -- now two functions, VG_(print_usage)() and VG_(print_debug_usage)(), and they do the printing themselves, instead of just returning a string -- that's more flexible. Removed DEBUG_CLIENTMALLOC code, it wasn't being used and was a pain. Added a regression test testing leak suppressions (nanoleak_supp), and another testing strcpy/memcpy/etc overlap warnings (overlap). Also changed Addrcheck to link with the files shared with Memcheck, rather than #including the .c files directly. Commoned up a little more shared Addrcheck/Memcheck code, for the usage message, and initialisation/finalisation. Added a Bool param to VG_(unique_error)() dictating whether it should allow GDB to be attached; for leak checks, because we don't want to attach GDB on leak errors (causes seg faults). A bit hacky, but it will do. Had to change lots of the expected outputs from regression files now that malloc() et al are in vg_replace_malloc.c rather than vg_clientfuncs.c. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@1524 a5019735-40e9-0310-863c-91ae7b9d1cf9
/external/valgrind/memcheck/tests/malloc3.stderr.exp
|