| |
| /*--------------------------------------------------------------------*/ |
| /*--- Default panicky definitions of template functions that skins ---*/ |
| /*--- should override. ---*/ |
| /*--- vg_defaults.c ---*/ |
| /*--------------------------------------------------------------------*/ |
| |
| /* |
| This file is part of Valgrind, an extensible x86 protected-mode |
| emulator for monitoring program execution on x86-Unixes. |
| |
| Copyright (C) 2000-2003 Nicholas Nethercote |
| njn25@cam.ac.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. |
| */ |
| |
| |
| /* These functions aren't intended to be run. Replacement functions used by |
| * the chosen skin are substituted by compiling the skin into a .so and |
| * LD_PRELOADing it. Nasty :) */ |
| |
| #include "vg_include.h" |
| |
| /* --------------------------------------------------------------------- |
| Error messages (for malformed skins) |
| ------------------------------------------------------------------ */ |
| |
| /* If the skin fails to define one or more of the required functions, |
| * make it very clear what went wrong! */ |
| |
| static __attribute__ ((noreturn)) |
| void fund_panic ( Char* fn ) |
| { |
| VG_(printf)( |
| "\nSkin error:\n" |
| " The skin you have selected is missing the function `%s',\n" |
| " which is required.\n\n", |
| fn); |
| VG_(skin_panic)("Missing skin function"); |
| } |
| |
| static __attribute__ ((noreturn)) |
| void non_fund_panic ( Char* fn ) |
| { |
| VG_(printf)( |
| "\nSkin error:\n" |
| " The skin you have selected is missing the function `%s'\n" |
| " required by one of its needs.\n\n", |
| fn); |
| VG_(skin_panic)("Missing skin function"); |
| } |
| |
| static __attribute__ ((noreturn)) |
| void malloc_panic ( Char* fn ) |
| { |
| VG_(printf)( |
| "\nSkin error:\n" |
| " The skin you have selected is missing the function `%s'\n" |
| " required because it is replacing malloc() et al.\n\n", |
| fn); |
| VG_(skin_panic)("Missing skin function"); |
| } |
| |
| #define FUND(proto) \ |
| __attribute__((weak)) \ |
| proto \ |
| { \ |
| fund_panic(__PRETTY_FUNCTION__); \ |
| } |
| |
| #define NON_FUND(proto) \ |
| __attribute__((weak)) \ |
| proto \ |
| { \ |
| non_fund_panic(__PRETTY_FUNCTION__); \ |
| } |
| |
| #define MALLOC(proto) \ |
| __attribute__((weak)) \ |
| proto \ |
| { \ |
| malloc_panic(__PRETTY_FUNCTION__); \ |
| } |
| |
| /* --------------------------------------------------------------------- |
| Default functions |
| ------------------------------------------------------------------ */ |
| |
| /* Fundamental template functions */ |
| FUND( void SK_(pre_clo_init) (void) ); |
| FUND( void SK_(post_clo_init)(void) ); |
| FUND( UCodeBlock* SK_(instrument) (UCodeBlock* cb, Addr not_used) ); |
| FUND( void SK_(fini) (Int exitcode) ); |
| |
| /* For error reporting and suppression handling */ |
| NON_FUND( Bool SK_(eq_SkinError)(VgRes res, Error* e1, Error* e2) ); |
| NON_FUND( void SK_(pp_SkinError)(Error* err) ); |
| NON_FUND( UInt SK_(update_extra)(Error* err) ); |
| NON_FUND( Bool SK_(recognised_suppression)(Char* name, Supp* su) ); |
| NON_FUND( Bool SK_(read_extra_suppression_info)(Int fd, Char* buf, Int nBuf, |
| Supp* su) ); |
| NON_FUND( Bool SK_(error_matches_suppression)(Error* err, Supp* su) ); |
| NON_FUND( Char* SK_(get_error_name)(Error* err) ); |
| NON_FUND( void SK_(print_extra_suppression_info)(Error* err) ); |
| |
| /* For throwing out basic block level info when code is invalidated */ |
| NON_FUND( void SK_(discard_basic_block_info)(Addr a, UInt size) ); |
| |
| /* For throwing out basic block level info when code is invalidated */ |
| NON_FUND( void SK_(written_shadow_regs_values)(UInt* gen_reg, UInt* eflags) ); |
| |
| /* Command line arg handling functions */ |
| NON_FUND( Bool SK_(process_cmd_line_option)(Char* argv) ); |
| NON_FUND( void SK_(print_usage)(void) ); |
| NON_FUND( void SK_(print_debug_usage)(void) ); |
| |
| /* Client request template function */ |
| NON_FUND( Bool SK_(handle_client_request)(ThreadState* tst, UInt* arg_block, |
| UInt *ret) ); |
| |
| /* UCode extension */ |
| NON_FUND( void SK_(emit_XUInstr) (UInstr* u, RRegSet regs_live_before) ); |
| NON_FUND( Bool SK_(sane_XUInstr) (Bool beforeRA, Bool beforeLiveness, |
| UInstr* u) ); |
| NON_FUND( Char* SK_(name_XUOpcode) (Opcode opc) ); |
| NON_FUND( void SK_(pp_XUInstr) (UInstr* u) ); |
| NON_FUND( Int SK_(get_Xreg_usage)(UInstr* u, Tag tag, Int* regs, |
| Bool* isWrites) ); |
| |
| /* Syscall wrapping */ |
| NON_FUND( void* SK_(pre_syscall) (ThreadId tid, UInt syscallno, |
| Bool is_blocking) ); |
| NON_FUND( void SK_(post_syscall)(ThreadId tid, UInt syscallno, |
| void* pre_result, Int res, Bool is_blocking) ); |
| |
| /* Sanity checks */ |
| NON_FUND( Bool SK_(cheap_sanity_check)(void) ); |
| NON_FUND( Bool SK_(expensive_sanity_check)(void) ); |
| |
| /*------------------------------------------------------------*/ |
| /*--- Replacing malloc et al ---*/ |
| /*------------------------------------------------------------*/ |
| |
| /* Default redzone for CLIENT arena of Valgrind's malloc() is 4 bytes */ |
| __attribute__ ((weak)) |
| UInt VG_(vg_malloc_redzone_szB) = 4; |
| |
| Bool VG_(sk_malloc_called_by_scheduler) = False; |
| |
| /* If the skin hasn't replaced malloc(), this one can be called from the |
| scheduler, for the USERREQ__MALLOC user request used by vg_libpthread.c. |
| (Nb: it cannot call glibc's malloc().) The lock variable ensures that the |
| scheduler is the only place this can be called from; this ensures that a |
| malloc()-replacing skin cannot forget to implement SK_(malloc)() or |
| SK_(free)(). */ |
| __attribute__ ((weak)) |
| void* SK_(malloc)( ThreadState* tst, Int size ) |
| { |
| if (VG_(sk_malloc_called_by_scheduler)) |
| return VG_(cli_malloc)(4, size); |
| else |
| malloc_panic(__PRETTY_FUNCTION__); |
| } |
| |
| __attribute__ ((weak)) |
| void SK_(free)( ThreadState* tst, void* p ) |
| { |
| /* see comment for SK_(malloc)() above */ |
| if (VG_(sk_malloc_called_by_scheduler)) |
| VG_(cli_free)(p); |
| else |
| malloc_panic(__PRETTY_FUNCTION__); |
| } |
| |
| MALLOC( void* SK_(__builtin_new) ( ThreadState* tst, Int size ) ); |
| MALLOC( void* SK_(__builtin_vec_new)( ThreadState* tst, Int size ) ); |
| MALLOC( void* SK_(memalign) ( ThreadState* tst, Int align, Int size ) ); |
| MALLOC( void* SK_(calloc) ( ThreadState* tst, Int nmemb, Int size ) ); |
| |
| MALLOC( void SK_(__builtin_delete) ( ThreadState* tst, void* p ) ); |
| MALLOC( void SK_(__builtin_vec_delete) ( ThreadState* tst, void* p ) ); |
| MALLOC( void* SK_(realloc) ( ThreadState* tst, void* p, |
| Int new_size ) ); |
| |
| /*--------------------------------------------------------------------*/ |
| /*--- end vg_defaults.c ---*/ |
| /*--------------------------------------------------------------------*/ |