diff --git a/include/.cvsignore b/include/.cvsignore index 2ed74d206..3e26277d6 100644 --- a/include/.cvsignore +++ b/include/.cvsignore @@ -1,3 +1,3 @@ Makefile.in Makefile -vg_skin.h +tool.h diff --git a/include/tool.h.base b/include/tool.h.base new file mode 100644 index 000000000..9049dd446 --- /dev/null +++ b/include/tool.h.base @@ -0,0 +1,1990 @@ +/*-*- c -*- ----------------------------------------------------------*/ +/*--- The only header your tool will ever need to #include... ---*/ +/*--- tool.h ---*/ +/*--------------------------------------------------------------------*/ + +/* + This file is part of Valgrind, an extensible x86 protected-mode + emulator for monitoring program execution on x86-Unixes. + + Copyright (C) 2000-2004 Julian Seward + jseward@acm.org + + 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. +*/ + +#ifndef __TOOL_H +#define __TOOL_H + +#include /* ANSI varargs stuff */ +#include /* for jmp_buf */ + +#include "vg_constants_skin.h" + +// XXX: here temporarily, will eventually go in arch-specific headers... +#define REGPARM(x) __attribute__((regparm (x))) + +/* --------------------------------------------------------------------- + Where to send bug reports to. + ------------------------------------------------------------------ */ + +#define VG_BUGS_TO "valgrind.kde.org" + + +/*====================================================================*/ +/*=== Build options and table sizes. ===*/ +/*====================================================================*/ + +/* You should be able to change these options or sizes, recompile, and + still have a working system. */ + +/* The maximum number of pthreads that we support. This is + deliberately not very high since our implementation of some of the + scheduler algorithms is surely O(N) in the number of threads, since + that's simple, at least. And (in practice) we hope that most + programs do not need many threads. */ +#define VG_N_THREADS 100 + +/* Maximum number of pthread keys available. Again, we start low until + the need for a higher number presents itself. */ +#define VG_N_THREAD_KEYS 50 + +/* Total number of integer registers available for allocation -- all of + them except %esp, %ebp. %ebp permanently points at VG_(baseBlock). + + If you increase this you'll have to also change at least these: + - VG_(rank_to_realreg)() + - VG_(realreg_to_rank)() + - ppRegsLiveness() + - the RegsLive type (maybe -- RegsLive type must have more than + VG_MAX_REALREGS bits) + + You can decrease it, and performance will drop because more spills will + occur. If you decrease it too much, everything will fall over. + + Do not change this unless you really know what you are doing! */ +#define VG_MAX_REALREGS 6 + + +/*====================================================================*/ +/*=== Basic types, useful macros ===*/ +/*====================================================================*/ + +typedef unsigned char UChar; +typedef unsigned short UShort; +typedef unsigned int UInt; +typedef unsigned long long int ULong; + +typedef signed char Char; +typedef signed short Short; +typedef signed int Int; +typedef signed long long int Long; + +typedef unsigned int Addr; + +typedef unsigned char Bool; +#define False ((Bool)0) +#define True ((Bool)1) + + +#define mycat_wrk(aaa,bbb) aaa##bbb +#define mycat(aaa,bbb) mycat_wrk(aaa,bbb) + +/* No, really. I _am_ that strange. */ +#define OINK(nnn) VG_(message)(Vg_DebugMsg, "OINK %d",nnn) + +/* --------------------------------------------------------------------- + Now the basic types are set up, we can haul in the kernel-interface + definitions. + ------------------------------------------------------------------ */ + +#include "vg_kerneliface.h" + + +/* Path to all our library/aux files */ +extern const Char *VG_(libdir); + + +/*====================================================================*/ +/*=== Core/tool interface version ===*/ +/*====================================================================*/ + +/* The major version number indicates binary-incompatible changes to the + interface; if the core and tool major versions don't match, Valgrind + will abort. The minor version indicates binary-compatible changes. +*/ +#define VG_CORE_INTERFACE_MAJOR_VERSION 6 +#define VG_CORE_INTERFACE_MINOR_VERSION 0 + +typedef struct _ToolInfo { + Int sizeof_ToolInfo; + Int interface_major_version; + Int interface_minor_version; + + /* Initialise tool. Must do the following: + - initialise the `details' struct, via the VG_(details_*)() functions + - register any helpers called by generated code + + May do the following: + - initialise the `needs' struct to indicate certain requirements, via + the VG_(needs_*)() functions + - initialize all the tool's entrypoints via the VG_(init_*)() functions + - register any tool-specific profiling events + - any other tool-specific initialisation + */ + void (*sk_pre_clo_init) ( void ); + + /* Specifies how big the shadow segment should be as a ratio to the + client address space. 0 for no shadow segment. */ + float shadow_ratio; +} ToolInfo; + +/* Every tool must include this macro somewhere, exactly once. */ +#define VG_DETERMINE_INTERFACE_VERSION(pre_clo_init, shadow) \ + const ToolInfo SK_(tool_info) = { \ + .sizeof_ToolInfo = sizeof(ToolInfo), \ + .interface_major_version = VG_CORE_INTERFACE_MAJOR_VERSION, \ + .interface_minor_version = VG_CORE_INTERFACE_MINOR_VERSION, \ + .sk_pre_clo_init = pre_clo_init, \ + .shadow_ratio = shadow, \ + }; + +/*====================================================================*/ +/*=== Command-line options ===*/ +/*====================================================================*/ + +/* Use this for normal null-termination-style string comparison */ +#define VG_STREQ(s1,s2) (s1 != NULL && s2 != NULL \ + && VG_(strcmp)((s1),(s2))==0) + +/* Use these for recognising tool command line options -- stops comparing + once whitespace is reached. */ +#define VG_CLO_STREQ(s1,s2) (0==VG_(strcmp_ws)((s1),(s2))) +#define VG_CLO_STREQN(nn,s1,s2) (0==VG_(strncmp_ws)((s1),(s2),(nn))) + +// Higher-level command-line option recognisers; use in if/else chains + +#define VG_BOOL_CLO(qq_option, qq_var) \ + if (VG_CLO_STREQ(arg, qq_option"=yes")) { (qq_var) = True; } \ + else if (VG_CLO_STREQ(arg, qq_option"=no")) { (qq_var) = False; } + +#define VG_STR_CLO(qq_option, qq_var) \ + if (VG_CLO_STREQN(VG_(strlen)(qq_option)+1, arg, qq_option"=")) { \ + (qq_var) = &arg[ VG_(strlen)(qq_option)+1 ]; \ + } + +#define VG_NUM_CLO(qq_option, qq_var) \ + if (VG_CLO_STREQN(VG_(strlen)(qq_option)+1, arg, qq_option"=")) { \ + (qq_var) = (Int)VG_(atoll)( &arg[ VG_(strlen)(qq_option)+1 ] ); \ + } + +// Bounded integer arg +#define VG_BNUM_CLO(qq_option, qq_var, qq_lo, qq_hi) \ + if (VG_CLO_STREQN(VG_(strlen)(qq_option)+1, arg, qq_option"=")) { \ + (qq_var) = (Int)VG_(atoll)( &arg[ VG_(strlen)(qq_option)+1 ] ); \ + if ((qq_var) < (qq_lo)) (qq_var) = (qq_lo); \ + if ((qq_var) > (qq_hi)) (qq_var) = (qq_hi); \ + } + + +/* Verbosity level: 0 = silent, 1 (default), > 1 = more verbose. */ +extern Int VG_(clo_verbosity); + +/* Profile? */ +extern Bool VG_(clo_profile); + +/* Call this if a recognised option was bad for some reason. + Note: don't use it just because an option was unrecognised -- return 'False' + from SKN_(process_cmd_line_option) to indicate that. */ +extern void VG_(bad_option) ( Char* opt ); + +/* Client args */ +extern Int VG_(client_argc); +extern Char** VG_(client_argv); + +/* Client environment. Can be inspected with VG_(getenv)() */ +extern Char** VG_(client_envp); + + +/*====================================================================*/ +/*=== Printing messages for the user ===*/ +/*====================================================================*/ + +/* Print a message prefixed by "???? "; '?' depends on the VgMsgKind. + Should be used for all user output. */ + +typedef + enum { Vg_UserMsg, /* '?' == '=' */ + Vg_DebugMsg, /* '?' == '-' */ + Vg_DebugExtraMsg, /* '?' == '+' */ + Vg_ClientMsg, /* '?' == '*' */ + } + VgMsgKind; + +/* Functions for building a message from multiple parts. */ +extern int VG_(start_msg) ( VgMsgKind kind ); +extern int VG_(add_to_msg) ( Char* format, ... ); +/* Ends and prints the message. Appends a newline. */ +extern int VG_(end_msg) ( void ); + +/* Send a single-part message. Appends a newline. */ +extern int VG_(message) ( VgMsgKind kind, Char* format, ... ); +extern int VG_(vmessage) ( VgMsgKind kind, Char* format, va_list vargs ); + + +/*====================================================================*/ +/*=== Profiling ===*/ +/*====================================================================*/ + +/* Nb: VGP_(register_profile_event)() relies on VgpUnc being the first one */ +#define VGP_CORE_LIST \ + /* These ones depend on the core */ \ + VGP_PAIR(VgpUnc, "unclassified"), \ + VGP_PAIR(VgpStartup, "startup"), \ + VGP_PAIR(VgpRun, "running"), \ + VGP_PAIR(VgpSched, "scheduler"), \ + VGP_PAIR(VgpMalloc, "low-lev malloc/free"), \ + VGP_PAIR(VgpCliMalloc, "client malloc/free"), \ + VGP_PAIR(VgpTranslate, "translate-main"), \ + VGP_PAIR(VgpToUCode, "to-ucode"), \ + VGP_PAIR(VgpFromUcode, "from-ucode"), \ + VGP_PAIR(VgpImprove, "improve"), \ + VGP_PAIR(VgpESPUpdate, "ESP-update"), \ + VGP_PAIR(VgpRegAlloc, "reg-alloc"), \ + VGP_PAIR(VgpLiveness, "liveness-analysis"), \ + VGP_PAIR(VgpDoLRU, "do-lru"), \ + VGP_PAIR(VgpSlowFindT, "slow-search-transtab"), \ + VGP_PAIR(VgpExeContext, "exe-context"), \ + VGP_PAIR(VgpReadSyms, "read-syms"), \ + VGP_PAIR(VgpSearchSyms, "search-syms"), \ + VGP_PAIR(VgpAddToT, "add-to-transtab"), \ + VGP_PAIR(VgpCoreSysWrap, "core-syscall-wrapper"), \ + VGP_PAIR(VgpDemangle, "demangle"), \ + VGP_PAIR(VgpCoreCheapSanity, "core-cheap-sanity"), \ + VGP_PAIR(VgpCoreExpensiveSanity, "core-expensive-sanity"), \ + /* These ones depend on the tool */ \ + VGP_PAIR(VgpPreCloInit, "pre-clo-init"), \ + VGP_PAIR(VgpPostCloInit, "post-clo-init"), \ + VGP_PAIR(VgpInstrument, "instrument"), \ + VGP_PAIR(VgpSkinSysWrap, "tool-syscall-wrapper"), \ + VGP_PAIR(VgpSkinCheapSanity, "tool-cheap-sanity"), \ + VGP_PAIR(VgpSkinExpensiveSanity, "tool-expensive-sanity"), \ + VGP_PAIR(VgpFini, "fini") + +#define VGP_PAIR(n,name) n +typedef enum { VGP_CORE_LIST } VgpCoreCC; +#undef VGP_PAIR + +/* When registering tool profiling events, ensure that the 'n' value is in + * the range (VgpFini+1..) */ +extern void VGP_(register_profile_event) ( Int n, Char* name ); + +extern void VGP_(pushcc) ( UInt cc ); +extern void VGP_(popcc) ( UInt cc ); + +/* Define them only if they haven't already been defined by vg_profile.c */ +#ifndef VGP_PUSHCC +# define VGP_PUSHCC(x) +#endif +#ifndef VGP_POPCC +# define VGP_POPCC(x) +#endif + + +/*====================================================================*/ +/*=== Useful stuff to call from generated code ===*/ +/*====================================================================*/ + +/* ------------------------------------------------------------------ */ +/* General stuff */ + +/* 64-bit counter for the number of basic blocks done. */ +extern ULong VG_(bbs_done); + +/* Get the simulated %esp */ +extern Addr VG_(get_stack_pointer) ( void ); + +/* Check if an address is 4-byte aligned */ +#define IS_ALIGNED4_ADDR(aaa_p) (0 == (((UInt)(aaa_p)) & 3)) +#define IS_ALIGNED8_ADDR(aaa_p) (0 == (((UInt)(aaa_p)) & 7)) + + +/* ------------------------------------------------------------------ */ +/* Thread-related stuff */ + +/* Special magic value for an invalid ThreadId. It corresponds to + LinuxThreads using zero as the initial value for + pthread_mutex_t.__m_owner and pthread_cond_t.__c_waiting. */ +#define VG_INVALID_THREADID ((ThreadId)(0)) + +/* ThreadIds are simply indices into the VG_(threads)[] array. */ +typedef + UInt + ThreadId; + +/* When looking for the current ThreadId, this is the safe option and + probably the one you want. + + Details: Use this one from non-generated code, eg. from functions called + on events like 'new_mem_heap'. In such a case, the "current" thread is + temporarily suspended as Valgrind's dispatcher is running. This function + is also suitable to be called from generated code (ie. from UCode, or a C + function called directly from UCode). + + If you use VG_(get_current_tid)() from non-generated code, it will return + 0 signifying the invalid thread, which is probably not what you want. */ +extern ThreadId VG_(get_current_or_recent_tid) ( void ); + +/* When looking for the current ThreadId, only use this one if you know what + you are doing. + + Details: Use this one from generated code, eg. from C functions called + from UCode. (VG_(get_current_or_recent_tid)() is also suitable in that + case.) If you use this function from non-generated code, it will return + 0 signifying the invalid thread, which is probably not what you want. */ +extern ThreadId VG_(get_current_tid) ( void ); + +/* Searches through all thread's stacks to see if any match. Returns + VG_INVALID_THREADID if none match. */ +extern ThreadId VG_(first_matching_thread_stack) + ( Bool (*p) ( Addr stack_min, Addr stack_max, void* d ), + void* d ); + + +/*====================================================================*/ +/*=== Valgrind's version of libc ===*/ +/*====================================================================*/ + +/* Valgrind doesn't use libc at all, for good reasons (trust us). So here + are its own versions of C library functions, but with VG_ prefixes. Note + that the types of some are slightly different to the real ones. Some + additional useful functions are provided too; descriptions of how they + work are given below. */ + +#if !defined(NULL) +# define NULL ((void*)0) +#endif + + +/* ------------------------------------------------------------------ */ +/* stdio.h + * + * Note that they all output to the file descriptor given by the + * --log-fd/--log-file/--log-socket argument, which defaults to 2 (stderr). + * Hence no need for VG_(fprintf)(). + */ +extern UInt VG_(printf) ( const char *format, ... ); +/* too noisy ... __attribute__ ((format (printf, 1, 2))) ; */ +extern UInt VG_(sprintf) ( Char* buf, Char *format, ... ); +extern UInt VG_(vprintf) ( void(*send)(Char), + const Char *format, va_list vargs ); + +extern Int VG_(rename) ( Char* old_name, Char* new_name ); + +/* ------------------------------------------------------------------ */ +/* stdlib.h */ + +extern void* VG_(malloc) ( Int nbytes ); +extern void VG_(free) ( void* p ); +extern void* VG_(calloc) ( Int n, Int nbytes ); +extern void* VG_(realloc) ( void* p, Int size ); +extern void* VG_(malloc_aligned) ( Int align_bytes, Int nbytes ); + +extern void VG_(print_malloc_stats) ( void ); + + +extern void VG_(exit)( Int status ) + __attribute__ ((__noreturn__)); +/* Prints a panic message (a constant string), appends newline and bug + reporting info, aborts. */ +__attribute__ ((__noreturn__)) +extern void VG_(skin_panic) ( Char* str ); + +/* Looks up VG_(client_envp) */ +extern Char* VG_(getenv) ( Char* name ); + +/* Get client resource limit*/ +extern Int VG_(getrlimit) ( Int resource, struct vki_rlimit *rlim ); + +/* Set client resource limit*/ +extern Int VG_(setrlimit) ( Int resource, struct vki_rlimit *rlim ); + +/* Crude stand-in for the glibc system() call. */ +extern Int VG_(system) ( Char* cmd ); + +extern Long VG_(atoll) ( Char* str ); + +/* Like atoll(), but converts a number of base 16 */ +extern Long VG_(atoll16) ( Char* str ); + +/* Like atoll(), but converts a number of base 2..36 */ +extern Long VG_(atoll36) ( UInt base, Char* str ); + +/* Like qsort(), but does shell-sort. The size==1/2/4 cases are specialised. */ +extern void VG_(ssort)( void* base, UInt nmemb, UInt size, + Int (*compar)(void*, void*) ); + + +/* ------------------------------------------------------------------ */ +/* ctype.h */ +extern Bool VG_(isspace) ( Char c ); +extern Bool VG_(isdigit) ( Char c ); +extern Char VG_(toupper) ( Char c ); + + +/* ------------------------------------------------------------------ */ +/* string.h */ +extern Int VG_(strlen) ( const Char* str ); +extern Char* VG_(strcat) ( Char* dest, const Char* src ); +extern Char* VG_(strncat) ( Char* dest, const Char* src, Int n ); +extern Char* VG_(strpbrk) ( const Char* s, const Char* accept ); +extern Char* VG_(strcpy) ( Char* dest, const Char* src ); +extern Char* VG_(strncpy) ( Char* dest, const Char* src, Int ndest ); +extern Int VG_(strcmp) ( const Char* s1, const Char* s2 ); +extern Int VG_(strncmp) ( const Char* s1, const Char* s2, Int nmax ); +extern Char* VG_(strstr) ( const Char* haystack, Char* needle ); +extern Char* VG_(strchr) ( const Char* s, Char c ); +extern Char* VG_(strrchr) ( const Char* s, Char c ); +extern Char* VG_(strdup) ( const Char* s); +extern void* VG_(memcpy) ( void *d, const void *s, Int sz ); +extern void* VG_(memset) ( void *s, Int c, Int sz ); +extern Int VG_(memcmp) ( const void* s1, const void* s2, Int n ); + +/* Like strcmp() and strncmp(), but stop comparing at any whitespace. */ +extern Int VG_(strcmp_ws) ( const Char* s1, const Char* s2 ); +extern Int VG_(strncmp_ws) ( const Char* s1, const Char* s2, Int nmax ); + +/* Like strncpy(), but if 'src' is longer than 'ndest' inserts a '\0' as the + last character. */ +extern void VG_(strncpy_safely) ( Char* dest, const Char* src, Int ndest ); + +/* Mini-regexp function. Searches for 'pat' in 'str'. Supports + * meta-symbols '*' and '?'. '\' escapes meta-symbols. */ +extern Bool VG_(string_match) ( const Char* pat, const Char* str ); + + +/* ------------------------------------------------------------------ */ +/* math.h */ +/* Returns the base-2 logarithm of x. */ +extern Int VG_(log2) ( Int x ); + + +/* ------------------------------------------------------------------ */ +/* unistd.h, fcntl.h, sys/stat.h */ +extern Int VG_(getdents)( UInt fd, struct vki_dirent *dirp, UInt count ); +extern Int VG_(readlink)( Char* path, Char* buf, UInt bufsize ); +extern Int VG_(getpid) ( void ); +extern Int VG_(getppid) ( void ); +extern Int VG_(getpgrp) ( void ); +extern Int VG_(gettid) ( void ); +extern Int VG_(setpgid) ( Int pid, Int pgrp ); + +extern Int VG_(open) ( const Char* pathname, Int flags, Int mode ); +extern Int VG_(read) ( Int fd, void* buf, Int count); +extern Int VG_(write) ( Int fd, const void* buf, Int count); +extern Int VG_(lseek) ( Int fd, Long offset, Int whence); +extern void VG_(close) ( Int fd ); + +extern Int VG_(pipe) ( Int fd[2] ); + +/* Nb: VG_(rename)() declared in stdio.h section above */ +extern Int VG_(unlink) ( Char* file_name ); +extern Int VG_(stat) ( Char* file_name, struct vki_stat* buf ); +extern Int VG_(fstat) ( Int fd, struct vki_stat* buf ); +extern Int VG_(dup2) ( Int oldfd, Int newfd ); + +extern Char* VG_(getcwd) ( Char* buf, Int size ); + +/* Easier to use than VG_(getcwd)() -- does the buffer fiddling itself. + String put into 'cwd' is VG_(malloc)'d, and should be VG_(free)'d. + Returns False if it fails. Will fail if the pathname is > 65535 bytes. */ +extern Bool VG_(getcwd_alloc) ( Char** cwd ); + +/* ------------------------------------------------------------------ */ +/* assert.h */ +/* Asserts permanently enabled -- no turning off with NDEBUG. Hurrah! */ +#define VG__STRING(__str) #__str + +#define sk_assert(expr) \ + ((void) ((expr) ? 0 : \ + (VG_(skin_assert_fail) (VG__STRING(expr), \ + __FILE__, __LINE__, \ + __PRETTY_FUNCTION__), 0))) + +__attribute__ ((__noreturn__)) +extern void VG_(skin_assert_fail) ( const Char* expr, const Char* file, + Int line, const Char* fn ); + + +/* ------------------------------------------------------------------ */ +/* Get memory by anonymous mmap. */ +extern void* VG_(get_memory_from_mmap) ( Int nBytes, Char* who ); + +extern Bool VG_(is_client_addr) (Addr a); +extern Addr VG_(get_client_base)(void); +extern Addr VG_(get_client_end) (void); +extern Addr VG_(get_client_size)(void); + +extern Bool VG_(is_shadow_addr) (Addr a); +extern Addr VG_(get_shadow_base)(void); +extern Addr VG_(get_shadow_end) (void); +extern Addr VG_(get_shadow_size)(void); + +extern void *VG_(shadow_alloc)(UInt size); + +extern Bool VG_(is_addressable)(Addr p, Int sz); + +extern Addr VG_(client_alloc)(Addr base, UInt len, UInt prot, UInt flags); +extern void VG_(client_free)(Addr addr); + +extern Bool VG_(is_valgrind_addr)(Addr a); + +/* initialize shadow pages in the range [p, p+sz) This calls + init_shadow_page for each one. It should be a lot more efficient + for bulk-initializing shadow pages than faulting on each one. +*/ +extern void VG_(init_shadow_range)(Addr p, UInt sz, Bool call_init); + +/* ------------------------------------------------------------------ */ +/* signal.h. + + Note that these use the vk_ (kernel) structure + definitions, which are different in places from those that glibc + defines -- hence the 'k' prefix. Since we're operating right at the + kernel interface, glibc's view of the world is entirely irrelevant. */ + +/* --- Signal set ops --- */ +extern Int VG_(ksigfillset) ( vki_ksigset_t* set ); +extern Int VG_(ksigemptyset) ( vki_ksigset_t* set ); + +extern Bool VG_(kisfullsigset) ( vki_ksigset_t* set ); +extern Bool VG_(kisemptysigset) ( vki_ksigset_t* set ); + +extern Int VG_(ksigaddset) ( vki_ksigset_t* set, Int signum ); +extern Int VG_(ksigdelset) ( vki_ksigset_t* set, Int signum ); +extern Int VG_(ksigismember) ( vki_ksigset_t* set, Int signum ); + +extern void VG_(ksigaddset_from_set) ( vki_ksigset_t* dst, vki_ksigset_t* src ); +extern void VG_(ksigdelset_from_set) ( vki_ksigset_t* dst, vki_ksigset_t* src ); + +/* --- Mess with the kernel's sig state --- */ +extern Int VG_(ksigprocmask) ( Int how, const vki_ksigset_t* set, + vki_ksigset_t* oldset ); +extern Int VG_(ksigaction) ( Int signum, + const vki_ksigaction* act, + vki_ksigaction* oldact ); + +extern Int VG_(ksigtimedwait)( const vki_ksigset_t *, vki_ksiginfo_t *, + const struct vki_timespec * ); + +extern Int VG_(ksignal) ( Int signum, void (*sighandler)(Int) ); +extern Int VG_(ksigaltstack) ( const vki_kstack_t* ss, vki_kstack_t* oss ); + +extern Int VG_(kkill) ( Int pid, Int signo ); +extern Int VG_(ktkill) ( Int pid, Int signo ); +extern Int VG_(ksigpending) ( vki_ksigset_t* set ); + +extern Int VG_(waitpid) ( Int pid, Int *status, Int options ); + +/* ------------------------------------------------------------------ */ +/* socket.h. */ + +extern Int VG_(getsockname) ( Int sd, struct vki_sockaddr *name, Int *namelen); +extern Int VG_(getpeername) ( Int sd, struct vki_sockaddr *name, Int *namelen); +extern Int VG_(getsockopt) ( Int sd, Int level, Int optname, void *optval, + Int *optlen); + +/* ------------------------------------------------------------------ */ +/* other, randomly useful functions */ +extern UInt VG_(read_millisecond_timer) ( void ); + +extern void VG_(cpuid) ( UInt eax, + UInt *eax_ret, UInt *ebx_ret, + UInt *ecx_ret, UInt *edx_ret ); + +/*====================================================================*/ +/*=== UCode definition ===*/ +/*====================================================================*/ + +/* Tags which describe what operands are. Must fit into 4 bits, which + they clearly do. */ +typedef +enum { TempReg =0, /* virtual temp-reg */ + ArchReg =1, /* simulated integer reg */ + ArchRegS =2, /* simulated segment reg */ + RealReg =3, /* real machine's real reg */ + SpillNo =4, /* spill slot location */ + Literal =5, /* literal; .lit32 field has actual value */ + Lit16 =6, /* literal; .val[123] field has actual value */ + NoValue =7 /* operand not in use */ + } + Tag; + +/* Invalid register numbers (can't be negative) */ +#define INVALID_TEMPREG 999999999 +#define INVALID_REALREG 999999999 + +/* Microinstruction opcodes. */ +typedef + enum { + NOP, /* Null op */ + + LOCK, /* Indicate the existence of a LOCK prefix (functionally NOP) */ + + /* Moving values around */ + GET, PUT, /* simulated register <--> TempReg */ + GETF, PUTF, /* simulated %eflags <--> TempReg */ + LOAD, STORE, /* memory <--> TempReg */ + MOV, /* TempReg <--> TempReg */ + CMOV, /* Used for cmpxchg and cmov */ + + /* Arithmetic/logical ops */ + MUL, UMUL, /* Multiply */ + ADD, ADC, SUB, SBB, /* Add/subtract (w/wo carry) */ + AND, OR, XOR, NOT, /* Boolean ops */ + SHL, SHR, SAR, ROL, ROR, RCL, RCR, /* Shift/rotate (w/wo carry) */ + NEG, /* Negate */ + INC, DEC, /* Increment/decrement */ + BSWAP, /* Big-endian <--> little-endian */ + CC2VAL, /* Condition code --> 0 or 1 */ + WIDEN, /* Signed or unsigned widening */ + + /* Conditional or unconditional jump */ + JMP, + + /* FPU ops */ + FPU, /* Doesn't touch memory */ + FPU_R, FPU_W, /* Reads/writes memory */ + + /* ------------ MMX ops ------------ */ + /* In this and the SSE encoding, bytes at higher addresses are + held in bits [7:0] in these 16-bit words. I guess this means + it is a big-endian encoding. */ + + /* 1 byte, no memrefs, no iregdefs, copy exactly to the + output. Held in val1[7:0]. */ + MMX1, + + /* 2 bytes, no memrefs, no iregdefs, copy exactly to the + output. Held in val1[15:0]. */ + MMX2, + + /* 3 bytes, no memrefs, no iregdefs, copy exactly to the + output. Held in val1[15:0] and val2[7:0]. */ + MMX3, + + /* 2 bytes, reads/writes mem. Insns of the form + bbbbbbbb:mod mmxreg r/m. + Held in val1[15:0], and mod and rm are to be replaced + at codegen time by a reference to the Temp/RealReg holding + the address. Arg2 holds this Temp/Real Reg. + Transfer is always at size 8. + */ + MMX2_MemRd, + MMX2_MemWr, + + /* 3 bytes, reads/writes mem. Insns of the form + bbbbbbbb:mod mmxreg r/m:bbbbbbbb + Held in val1[15:0] and val2[7:0], and mod and rm are to be + replaced at codegen time by a reference to the Temp/RealReg + holding the address. Arg2 holds this Temp/Real Reg. + Transfer is always at size 8. + */ + MMX2a1_MemRd, + + /* 2 bytes, reads/writes an integer ("E") register. Insns of the form + bbbbbbbb:11 mmxreg ireg. + Held in val1[15:0], and ireg is to be replaced + at codegen time by a reference to the relevant RealReg. + Transfer is always at size 4. Arg2 holds this Temp/Real Reg. + */ + MMX2_ERegRd, + MMX2_ERegWr, + + /* ------------ SSE/SSE2 ops ------------ */ + /* In the following: + + a digit N indicates the next N bytes are to be copied exactly + to the output. + + 'a' indicates a mod-xmmreg-rm byte, where the mod-rm part is + to be replaced at codegen time to a Temp/RealReg holding the + address. + + 'e' indicates a byte of the form '11 xmmreg ireg', where ireg + is read or written, and is to be replaced at codegen time by + a reference to the relevant RealReg. 'e' because it's the E + reg in Intel encoding parlance. + + 'g' indicates a byte of the form '11 ireg xmmreg', where ireg + is read or written, and is to be replaced at codegen time by + a reference to the relevant RealReg. 'g' because it's called + G in Intel parlance. */ + + /* 3 bytes, no memrefs, no iregdefs, copy exactly to the + output. Held in val1[15:0] and val2[7:0]. */ + SSE3, + + /* 3 bytes, reads/writes mem. Insns of the form + bbbbbbbb:bbbbbbbb:mod mmxreg r/m. + Held in val1[15:0] and val2[7:0], and mod and rm are to be + replaced at codegen time by a reference to the Temp/RealReg + holding the address. Arg3 holds this Temp/Real Reg. + Transfer is usually, but not always, at size 16. */ + SSE2a_MemRd, + SSE2a_MemWr, + + /* 4 bytes, writes an integer register. Insns of the form + bbbbbbbb:bbbbbbbb:11 ireg bbb. + Held in val1[15:0] and val2[7:0], and ireg is to be replaced + at codegen time by a reference to the relevant RealReg. + Transfer is always at size 4. Arg3 holds this Temp/Real Reg. + */ + SSE2g_RegWr, + + /* 5 bytes, writes an integer register. Insns of the form + bbbbbbbb:bbbbbbbb:11 ireg bbb :bbbbbbbb. Held in + val1[15:0] and val2[7:0] and lit32[7:0], and ireg is to be + replaced at codegen time by a reference to the relevant + RealReg. Transfer is always at size 4. Arg3 holds this + Temp/Real Reg. + */ + SSE2g1_RegWr, + + /* 5 bytes, reads an integer register. Insns of the form + bbbbbbbb:bbbbbbbb:11 bbb ireg :bbbbbbbb. Held in + val1[15:0] and val2[7:0] and lit32[7:0], and ireg is to be + replaced at codegen time by a reference to the relevant + RealReg. Transfer is always at size 4. Arg3 holds this + Temp/Real Reg. + */ + SSE2e1_RegRd, + + /* 4 bytes, no memrefs, no iregdefs, copy exactly to the + output. Held in val1[15:0] and val2[15:0]. */ + SSE4, + + /* 4 bytes, reads/writes mem. Insns of the form + bbbbbbbb:bbbbbbbb:bbbbbbbb:mod mmxreg r/m. + Held in val1[15:0] and val2[15:0], and mod and rm are to be + replaced at codegen time by a reference to the Temp/RealReg + holding the address. Arg3 holds this Temp/Real Reg. + Transfer is at stated size. */ + SSE3a_MemRd, + SSE3a_MemWr, + + /* 4 bytes, reads/writes mem. Insns of the form + bbbbbbbb:bbbbbbbb:mod mmxreg r/m:bbbbbbbb + Held in val1[15:0] and val2[15:0], and mod and rm are to be + replaced at codegen time by a reference to the Temp/RealReg + holding the address. Arg3 holds this Temp/Real Reg. + Transfer is at stated size. */ + SSE2a1_MemRd, + + /* 4 bytes, writes an integer register. Insns of the form + bbbbbbbb:bbbbbbbb:bbbbbbbb:11 ireg bbb. + Held in val1[15:0] and val2[15:0], and ireg is to be replaced + at codegen time by a reference to the relevant RealReg. + Transfer is always at size 4. Arg3 holds this Temp/Real Reg. + */ + SSE3g_RegWr, + + /* 5 bytes, writes an integer register. Insns of the form + bbbbbbbb:bbbbbbbb:bbbbbbbb: 11 ireg bbb :bbbbbbbb. Held in + val1[15:0] and val2[15:0] and lit32[7:0], and ireg is to be + replaced at codegen time by a reference to the relevant + RealReg. Transfer is always at size 4. Arg3 holds this + Temp/Real Reg. + */ + SSE3g1_RegWr, + + /* 4 bytes, reads an integer register. Insns of the form + bbbbbbbb:bbbbbbbb:bbbbbbbb:11 bbb ireg. + Held in val1[15:0] and val2[15:0], and ireg is to be replaced + at codegen time by a reference to the relevant RealReg. + Transfer is always at size 4. Arg3 holds this Temp/Real Reg. + */ + SSE3e_RegRd, + SSE3e_RegWr, /* variant that writes Ereg, not reads it */ + + /* 5 bytes, reads an integer register. Insns of the form + bbbbbbbb:bbbbbbbb:bbbbbbbb: 11 bbb ireg :bbbbbbbb. Held in + val1[15:0] and val2[15:0] and lit32[7:0], and ireg is to be + replaced at codegen time by a reference to the relevant + RealReg. Transfer is always at size 4. Arg3 holds this + Temp/Real Reg. + */ + SSE3e1_RegRd, + + /* 4 bytes, reads memory, writes an integer register, but is + nevertheless an SSE insn. The insn is of the form + bbbbbbbb:bbbbbbbb:bbbbbbbb:mod ireg rm where mod indicates + memory (ie is not 11b) and ireg is the int reg written. The + first 4 bytes are held in lit32[31:0] since there is + insufficient space elsewhere. mod and rm are to be replaced + at codegen time by a reference to the Temp/RealReg holding + the address. Arg1 holds this Temp/RealReg. ireg is to be + replaced at codegen time by a reference to the relevant + RealReg in which the answer is to be written. Arg2 holds + this Temp/RealReg. Transfer to the destination reg is always + at size 4. However the memory read can be at sizes 4 or 8 + and so this is what the sz field holds. Note that the 4th + byte of the instruction (the modrm byte) is redundant, but we + store it anyway so as to be consistent with all other SSE + uinstrs. + */ + SSE3ag_MemRd_RegWr, + + /* 5 bytes, no memrefs, no iregdefs, copy exactly to the + output. Held in val1[15:0], val2[15:0] and val3[7:0]. */ + SSE5, + + /* 5 bytes, reads/writes mem. Insns of the form + bbbbbbbb:bbbbbbbb:bbbbbbbb:mod mmxreg r/m:bbbbbbbb + Held in val1[15:0], val2[15:0], lit32[7:0]. + mod and rm are to be replaced at codegen time by a reference + to the Temp/RealReg holding the address. Arg3 holds this + Temp/Real Reg. Transfer is always at size 16. */ + SSE3a1_MemRd, + + /* ------------------------ */ + + /* Not strictly needed, but improve address calculation translations. */ + LEA1, /* reg2 := const + reg1 */ + LEA2, /* reg3 := const + reg1 + reg2 * 1,2,4 or 8 */ + + /* Hack for x86 REP insns. Jump to literal if TempReg/RealReg + is zero. */ + JIFZ, + + /* Advance the simulated %eip by some small (< 128) number. */ + INCEIP, + + /* Dealing with segment registers */ + GETSEG, PUTSEG, /* simulated segment register <--> TempReg */ + USESEG, /* (LDT/GDT index, virtual addr) --> linear addr */ + + /* Not for translating x86 calls -- only to call helpers */ + CALLM_S, CALLM_E, /* Mark start/end of CALLM push/pop sequence */ + PUSH, POP, CLEAR, /* Add/remove/zap args for helpers */ + CALLM, /* Call assembly-code helper */ + + /* Not for translating x86 calls -- only to call C helper functions of + up to three arguments (or two if the functions has a return value). + Arguments and return value must be word-sized. More arguments can + be faked with global variables (eg. use VG_(lit_to_globvar)()). + + Seven possibilities: 'arg[123]' show where args go, 'ret' shows + where return value goes (if present). + + CCALL(-, -, - ) void f(void) + CCALL(arg1, -, - ) void f(UInt arg1) + CCALL(arg1, arg2, - ) void f(UInt arg1, UInt arg2) + CCALL(arg1, arg2, arg3) void f(UInt arg1, UInt arg2, UInt arg3) + CCALL(-, -, ret ) UInt f(UInt) + CCALL(arg1, -, ret ) UInt f(UInt arg1) + CCALL(arg1, arg2, ret ) UInt f(UInt arg1, UInt arg2) */ + CCALL, + + /* This opcode makes it easy for tools that extend UCode to do this to + avoid opcode overlap: + + enum { EU_OP1 = DUMMY_FINAL_UOPCODE + 1, ... } + + WARNING: Do not add new opcodes after this one! They can be added + before, though. */ + DUMMY_FINAL_UOPCODE + } + Opcode; + + +/* Condition codes, using the Intel encoding. CondAlways is an extra. */ +typedef + enum { + CondO = 0, /* overflow */ + CondNO = 1, /* no overflow */ + CondB = 2, /* below */ + CondNB = 3, /* not below */ + CondZ = 4, /* zero */ + CondNZ = 5, /* not zero */ + CondBE = 6, /* below or equal */ + CondNBE = 7, /* not below or equal */ + CondS = 8, /* negative */ + CondNS = 9, /* not negative */ + CondP = 10, /* parity even */ + CondNP = 11, /* not parity even */ + CondL = 12, /* jump less */ + CondNL = 13, /* not less */ + CondLE = 14, /* less or equal */ + CondNLE = 15, /* not less or equal */ + CondAlways = 16 /* Jump always */ + } + Condcode; + + +/* Descriptions of additional properties of *unconditional* jumps. */ +typedef + enum { + JmpBoring=0, /* boring unconditional jump */ + JmpCall=1, /* jump due to an x86 call insn */ + JmpRet=2, /* jump due to an x86 ret insn */ + JmpSyscall=3, /* do a system call, then jump */ + JmpClientReq=4,/* do a client request, then jump */ + JmpYield=5 /* do a yield, then jump */ + } + JmpKind; + + +/* Flags. User-level code can only read/write O(verflow), S(ign), + Z(ero), A(ux-carry), C(arry), P(arity), and may also write + D(irection). That's a total of 7 flags. A FlagSet is a bitset, + thusly: + 76543210 + DOSZACP + and bit 7 must always be zero since it is unused. + + Note: these Flag? values are **not** the positions in the actual + %eflags register. */ + +typedef UChar FlagSet; + +#define FlagD (1<<6) +#define FlagO (1<<5) +#define FlagS (1<<4) +#define FlagZ (1<<3) +#define FlagA (1<<2) +#define FlagC (1<<1) +#define FlagP (1<<0) + +#define FlagsOSZACP (FlagO | FlagS | FlagZ | FlagA | FlagC | FlagP) +#define FlagsOSZAP (FlagO | FlagS | FlagZ | FlagA | FlagP) +#define FlagsOSZCP (FlagO | FlagS | FlagZ | FlagC | FlagP) +#define FlagsOSACP (FlagO | FlagS | FlagA | FlagC | FlagP) +#define FlagsSZACP ( FlagS | FlagZ | FlagA | FlagC | FlagP) +#define FlagsSZAP ( FlagS | FlagZ | FlagA | FlagP) +#define FlagsSZP ( FlagS | FlagZ | FlagP) +#define FlagsZCP ( FlagZ | FlagC | FlagP) +#define FlagsOC (FlagO | FlagC ) +#define FlagsAC ( FlagA | FlagC ) + +#define FlagsALL (FlagsOSZACP | FlagD) +#define FlagsEmpty (FlagSet)0 + + +/* flag positions in eflags */ +#define EFlagC (1 << 0) /* carry */ +#define EFlagP (1 << 2) /* parity */ +#define EFlagA (1 << 4) /* aux carry */ +#define EFlagZ (1 << 6) /* zero */ +#define EFlagS (1 << 7) /* sign */ +#define EFlagD (1 << 10) /* direction */ +#define EFlagO (1 << 11) /* overflow */ +#define EFlagID (1 << 21) /* changable if CPUID exists */ + +/* Liveness of general purpose registers, useful for code generation. + Reg rank order 0..N-1 corresponds to bits 0..N-1, ie. first + reg's liveness in bit 0, last reg's in bit N-1. Note that + these rankings don't match the Intel register ordering. */ +typedef UInt RRegSet; + +#define ALL_RREGS_DEAD 0 /* 0000...00b */ +#define ALL_RREGS_LIVE ((1 << VG_MAX_REALREGS)-1) /* 0011...11b */ +#define UNIT_RREGSET(rank) (1 << (rank)) + +#define IS_RREG_LIVE(rank,rregs_live) (rregs_live & UNIT_RREGSET(rank)) +#define SET_RREG_LIVENESS(rank,rregs_live,b) \ + do { RRegSet unit = UNIT_RREGSET(rank); \ + if (b) rregs_live |= unit; \ + else rregs_live &= ~unit; \ + } while(0) + + +/* A Micro (u)-instruction. */ +typedef + struct { + /* word 1 */ + UInt lit32; /* 32-bit literal */ + + /* word 2 */ + UShort val1; /* first operand */ + UShort val2; /* second operand */ + + /* word 3 */ + UShort val3; /* third operand */ + UChar opcode; /* opcode */ + UShort size; /* data transfer size */ + + /* word 4 */ + FlagSet flags_r; /* :: FlagSet */ + FlagSet flags_w; /* :: FlagSet */ + UChar tag1:4; /* first operand tag */ + UChar tag2:4; /* second operand tag */ + UChar tag3:4; /* third operand tag */ + UChar extra4b:4; /* Spare field, used by WIDEN for src + -size, and by LEA2 for scale (1,2,4 or 8), + and by JMPs for original x86 instr size */ + + /* word 5 */ + UChar cond; /* condition, for jumps */ + Bool signed_widen:1; /* signed or unsigned WIDEN ? */ + JmpKind jmpkind:3; /* additional properties of unconditional JMP */ + + /* Additional properties for UInstrs that call C functions: + - CCALL + - PUT (when %ESP is the target) + - possibly tool-specific UInstrs + */ + UChar argc:2; /* Number of args, max 3 */ + UChar regparms_n:2; /* Number of args passed in registers */ + Bool has_ret_val:1; /* Function has return value? */ + + /* RealReg liveness; only sensical after reg alloc and liveness + analysis done. This info is a little bit arch-specific -- + VG_MAX_REALREGS can vary on different architectures. Note that + to use this information requires converting between register ranks + and the Intel register numbers, using VG_(realreg_to_rank)() + and/or VG_(rank_to_realreg)() */ + RRegSet regs_live_after:VG_MAX_REALREGS; + } + UInstr; + + +typedef + struct _UCodeBlock + UCodeBlock; + +extern Int VG_(get_num_instrs) (UCodeBlock* cb); +extern Int VG_(get_num_temps) (UCodeBlock* cb); + +extern UInstr* VG_(get_instr) (UCodeBlock* cb, Int i); +extern UInstr* VG_(get_last_instr) (UCodeBlock* cb); + + +/*====================================================================*/ +/*=== Instrumenting UCode ===*/ +/*====================================================================*/ + +/* Maximum number of registers read or written by a single UInstruction. */ +#define VG_MAX_REGS_USED 3 + +/* Find what this instruction does to its regs, useful for + analysis/optimisation passes. `tag' indicates whether we're considering + TempRegs (pre-reg-alloc) or RealRegs (post-reg-alloc). `regs' is filled + with the affected register numbers, `isWrites' parallels it and indicates + if the reg is read or written. If a reg is read and written, it will + appear twice in `regs'. `regs' and `isWrites' must be able to fit + VG_MAX_REGS_USED elements. */ +extern Int VG_(get_reg_usage) ( UInstr* u, Tag tag, Int* regs, Bool* isWrites ); + + +/* Used to register helper functions to be called from generated code. A + limited number of compact helpers can be registered; the code generated + to call them is slightly shorter -- so register the mostly frequently + called helpers as compact. */ +extern void VG_(register_compact_helper) ( Addr a ); +extern void VG_(register_noncompact_helper) ( Addr a ); + + +/* ------------------------------------------------------------------ */ +/* Virtual register allocation */ + +/* Get a new virtual register */ +extern Int VG_(get_new_temp) ( UCodeBlock* cb ); + +/* Get a new virtual shadow register */ +extern Int VG_(get_new_shadow) ( UCodeBlock* cb ); + +/* Get a virtual register's corresponding virtual shadow register */ +#define SHADOW(tempreg) ((tempreg)+1) + + +/* ------------------------------------------------------------------ */ +/* Low-level UInstr builders */ +extern void VG_(new_NOP) ( UInstr* u ); +extern void VG_(new_UInstr0) ( UCodeBlock* cb, Opcode opcode, Int sz ); +extern void VG_(new_UInstr1) ( UCodeBlock* cb, Opcode opcode, Int sz, + Tag tag1, UInt val1 ); +extern void VG_(new_UInstr2) ( UCodeBlock* cb, Opcode opcode, Int sz, + Tag tag1, UInt val1, + Tag tag2, UInt val2 ); +extern void VG_(new_UInstr3) ( UCodeBlock* cb, Opcode opcode, Int sz, + Tag tag1, UInt val1, + Tag tag2, UInt val2, + Tag tag3, UInt val3 ); + +/* Set read/write/undefined flags. Undefined flags are treaten as written, + but it's worth keeping them logically distinct. */ +extern void VG_(set_flag_fields) ( UCodeBlock* cb, FlagSet fr, FlagSet fw, + FlagSet fu); +extern void VG_(set_lit_field) ( UCodeBlock* cb, UInt lit32 ); +extern void VG_(set_ccall_fields) ( UCodeBlock* cb, Addr fn, UChar argc, + UChar regparms_n, Bool has_ret_val ); +extern void VG_(set_cond_field) ( UCodeBlock* cb, Condcode code ); +extern void VG_(set_widen_fields) ( UCodeBlock* cb, UInt szs, Bool is_signed ); + +extern void VG_(copy_UInstr) ( UCodeBlock* cb, UInstr* instr ); + +extern Bool VG_(any_flag_use)( UInstr* u ); + +/* Macro versions of the above; just shorter to type. */ +#define uInstr0 VG_(new_UInstr0) +#define uInstr1 VG_(new_UInstr1) +#define uInstr2 VG_(new_UInstr2) +#define uInstr3 VG_(new_UInstr3) +#define uLiteral VG_(set_lit_field) +#define uCCall VG_(set_ccall_fields) +#define uCond VG_(set_cond_field) +#define uWiden VG_(set_widen_fields) +#define uFlagsRWU VG_(set_flag_fields) +#define newTemp VG_(get_new_temp) +#define newShadow VG_(get_new_shadow) + +/* Refer to `the last instruction stuffed in' (can be lvalue). */ +#define LAST_UINSTR(cb) (cb)->instrs[(cb)->used-1] + + +/* ------------------------------------------------------------------ */ +/* Higher-level UInstr sequence builders */ + +extern void VG_(lit_to_reg) ( UCodeBlock* cb, UInt lit, UInt t ); +extern UInt VG_(lit_to_newreg) ( UCodeBlock* cb, UInt lit ); + +#define CB_F UCodeBlock* cb, Addr f +#define EV extern void +#define RPn UInt regparms_n + +/* Various CCALL builders, of the form "ccall__". 'R' + represents a TempReg, 'L' represents a literal, '0' represents nothing + (ie. no args, or no return value). */ + +EV VG_(ccall_0_0) ( CB_F ); + +EV VG_(ccall_R_0) ( CB_F, UInt R1, RPn ); +EV VG_(ccall_L_0) ( CB_F, UInt L1, RPn ); +EV VG_(ccall_R_R) ( CB_F, UInt R1, UInt R_ret, RPn ); +EV VG_(ccall_L_R) ( CB_F, UInt L1, UInt R_ret, RPn ); + +EV VG_(ccall_RR_0) ( CB_F, UInt R1, UInt R2, RPn ); +EV VG_(ccall_RL_0) ( CB_F, UInt R1, UInt RL, RPn ); +EV VG_(ccall_LR_0) ( CB_F, UInt L1, UInt R2, RPn ); +EV VG_(ccall_LL_0) ( CB_F, UInt L1, UInt L2, RPn ); +EV VG_(ccall_RR_R) ( CB_F, UInt R1, UInt R2, UInt R_ret, RPn ); +EV VG_(ccall_RL_R) ( CB_F, UInt R1, UInt L2, UInt R_ret, RPn ); +EV VG_(ccall_LR_R) ( CB_F, UInt L1, UInt R2, UInt R_ret, RPn ); +EV VG_(ccall_LL_R) ( CB_F, UInt L1, UInt L2, UInt R_ret, RPn ); + +EV VG_(ccall_RRR_0) ( CB_F, UInt R1, UInt R2, UInt R3, RPn ); +EV VG_(ccall_RLL_0) ( CB_F, UInt R1, UInt L2, UInt L3, RPn ); +EV VG_(ccall_LRR_0) ( CB_F, UInt L1, UInt R2, UInt R3, RPn ); +EV VG_(ccall_LLR_0) ( CB_F, UInt L1, UInt L2, UInt R3, RPn ); +EV VG_(ccall_LLL_0) ( CB_F, UInt L1, UInt L2, UInt L3, RPn ); + +#undef CB_F +#undef EV +#undef RPn + +/* One way around the 3-arg C function limit is to pass args via global + * variables... ugly, but it works. */ +void VG_(reg_to_globvar)(UCodeBlock* cb, UInt t, UInt* globvar_ptr); +void VG_(lit_to_globvar)(UCodeBlock* cb, UInt lit, UInt* globvar_ptr); + + +/* Old, deprecated versions of some of the helpers (DO NOT USE) */ +extern void VG_(call_helper_0_0) ( UCodeBlock* cb, Addr f); +extern void VG_(call_helper_1_0) ( UCodeBlock* cb, Addr f, UInt arg1, + UInt regparms_n); +extern void VG_(call_helper_2_0) ( UCodeBlock* cb, Addr f, UInt arg1, UInt arg2, + UInt regparms_n); +extern void VG_(set_global_var) ( UCodeBlock* cb, Addr globvar_ptr, UInt val); +extern void VG_(set_global_var_tempreg) ( UCodeBlock* cb, Addr globvar_ptr, + UInt t_val); + +/* ------------------------------------------------------------------ */ +/* Allocating/freeing basic blocks of UCode */ +extern UCodeBlock* VG_(setup_UCodeBlock) ( UCodeBlock* cb ); +extern void VG_(free_UCodeBlock) ( UCodeBlock* cb ); + +/* ------------------------------------------------------------------ */ +/* UCode pretty/ugly printing. Probably only useful to call from a tool + if VG_(needs).extended_UCode == True. */ + +/* When True, all generated code is/should be printed. */ +extern Bool VG_(print_codegen); + +/* Pretty/ugly printing functions */ +extern void VG_(pp_UCodeBlock) ( UCodeBlock* cb, Char* title ); +extern void VG_(pp_UInstr) ( Int instrNo, UInstr* u ); +extern void VG_(pp_UInstr_regs) ( Int instrNo, UInstr* u ); +extern void VG_(up_UInstr) ( Int instrNo, UInstr* u ); +extern Char* VG_(name_UOpcode) ( Bool upper, Opcode opc ); +extern Char* VG_(name_UCondcode) ( Condcode cond ); +extern void VG_(pp_UOperand) ( UInstr* u, Int operandNo, + Int sz, Bool parens ); + +/* ------------------------------------------------------------------ */ +/* Accessing archregs and their shadows */ +extern UInt VG_(get_archreg) ( UInt archreg ); +extern UInt VG_(get_thread_archreg) ( ThreadId tid, UInt archreg ); + +extern UInt VG_(get_shadow_archreg) ( UInt archreg ); +extern void VG_(set_shadow_archreg) ( UInt archreg, UInt val ); +extern void VG_(set_shadow_eflags) ( UInt val ); +extern Addr VG_(shadow_archreg_address) ( UInt archreg ); + +extern UInt VG_(get_thread_shadow_archreg) ( ThreadId tid, UInt archreg ); +extern void VG_(set_thread_shadow_archreg) ( ThreadId tid, UInt archreg, + UInt val ); + +/* ------------------------------------------------------------------ */ +/* Offsets of addresses of helper functions. A "helper" function is one + which is called from generated code via CALLM. */ + +extern Int VGOFF_(helper_idiv_64_32); +extern Int VGOFF_(helper_div_64_32); +extern Int VGOFF_(helper_idiv_32_16); +extern Int VGOFF_(helper_div_32_16); +extern Int VGOFF_(helper_idiv_16_8); +extern Int VGOFF_(helper_div_16_8); + +extern Int VGOFF_(helper_imul_32_64); +extern Int VGOFF_(helper_mul_32_64); +extern Int VGOFF_(helper_imul_16_32); +extern Int VGOFF_(helper_mul_16_32); +extern Int VGOFF_(helper_imul_8_16); +extern Int VGOFF_(helper_mul_8_16); + +extern Int VGOFF_(helper_CLD); +extern Int VGOFF_(helper_STD); +extern Int VGOFF_(helper_get_dirflag); + +extern Int VGOFF_(helper_CLC); +extern Int VGOFF_(helper_STC); +extern Int VGOFF_(helper_CMC); + +extern Int VGOFF_(helper_shldl); +extern Int VGOFF_(helper_shldw); +extern Int VGOFF_(helper_shrdl); +extern Int VGOFF_(helper_shrdw); + +extern Int VGOFF_(helper_RDTSC); +extern Int VGOFF_(helper_CPUID); + +extern Int VGOFF_(helper_IN); +extern Int VGOFF_(helper_OUT); + +extern Int VGOFF_(helper_bsfw); +extern Int VGOFF_(helper_bsfl); +extern Int VGOFF_(helper_bsrw); +extern Int VGOFF_(helper_bsrl); + +extern Int VGOFF_(helper_fstsw_AX); +extern Int VGOFF_(helper_SAHF); +extern Int VGOFF_(helper_LAHF); +extern Int VGOFF_(helper_DAS); +extern Int VGOFF_(helper_DAA); +extern Int VGOFF_(helper_AAS); +extern Int VGOFF_(helper_AAA); +extern Int VGOFF_(helper_AAD); +extern Int VGOFF_(helper_AAM); + +extern Int VGOFF_(helper_cmpxchg8b); + + +/*====================================================================*/ +/*=== Generating x86 code from UCode ===*/ +/*====================================================================*/ + +/* All this only necessary for tools with VG_(needs).extends_UCode == True. */ + +/* This is the Intel register encoding -- integer regs. */ +#define R_EAX 0 +#define R_ECX 1 +#define R_EDX 2 +#define R_EBX 3 +#define R_ESP 4 +#define R_EBP 5 +#define R_ESI 6 +#define R_EDI 7 + +#define R_AL (0+R_EAX) +#define R_CL (0+R_ECX) +#define R_DL (0+R_EDX) +#define R_BL (0+R_EBX) +#define R_AH (4+R_EAX) +#define R_CH (4+R_ECX) +#define R_DH (4+R_EDX) +#define R_BH (4+R_EBX) + +/* This is the Intel register encoding -- segment regs. */ +#define R_ES 0 +#define R_CS 1 +#define R_SS 2 +#define R_DS 3 +#define R_FS 4 +#define R_GS 5 + +/* For pretty printing x86 code */ +extern const Char* VG_(name_of_mmx_gran) ( UChar gran ); +extern const Char* VG_(name_of_mmx_reg) ( Int mmxreg ); +extern const Char* VG_(name_of_seg_reg) ( Int sreg ); +extern const Char* VG_(name_of_int_reg) ( Int size, Int reg ); +extern const Char VG_(name_of_int_size) ( Int size ); + +/* Shorter macros for convenience */ +#define nameIReg VG_(name_of_int_reg) +#define nameISize VG_(name_of_int_size) +#define nameSReg VG_(name_of_seg_reg) +#define nameMMXReg VG_(name_of_mmx_reg) +#define nameMMXGran VG_(name_of_mmx_gran) +#define nameXMMReg VG_(name_of_xmm_reg) + +/* Randomly useful things */ +extern UInt VG_(extend_s_8to32) ( UInt x ); + +/* Code emitters */ +extern void VG_(emitB) ( UInt b ); +extern void VG_(emitW) ( UInt w ); +extern void VG_(emitL) ( UInt l ); +extern void VG_(new_emit) ( Bool upd_cc, FlagSet uses_flags, FlagSet sets_flags ); + +/* Finding offsets */ +extern Int VG_(helper_offset) ( Addr a ); +extern Int VG_(shadow_reg_offset) ( Int arch ); +extern Int VG_(shadow_flags_offset) ( void ); + +/* Convert reg ranks <-> Intel register ordering, for using register + liveness information. */ +extern Int VG_(realreg_to_rank) ( Int realreg ); +extern Int VG_(rank_to_realreg) ( Int rank ); + +/* Call a subroutine. Does no argument passing, stack manipulations, etc. */ +extern void VG_(synth_call) ( Bool ensure_shortform, Int word_offset, + Bool upd_cc, FlagSet use_flags, FlagSet set_flags ); + +/* For calling C functions -- saves caller save regs, pushes args, calls, + clears the stack, restores caller save regs. `fn' must be registered in + the baseBlock first. Acceptable tags are RealReg and Literal. Optimises + things, eg. by not preserving non-live caller-save registers. + + WARNING: a UInstr should *not* be translated with synth_ccall() followed + by some other x86 assembly code; this will invalidate the results of + vg_realreg_liveness_analysis() and everything will fall over. */ +extern void VG_(synth_ccall) ( Addr fn, Int argc, Int regparms_n, UInt argv[], + Tag tagv[], Int ret_reg, + RRegSet regs_live_before, + RRegSet regs_live_after ); + +/* Addressing modes */ +extern void VG_(emit_amode_offregmem_reg)( Int off, Int regmem, Int reg ); +extern void VG_(emit_amode_ereg_greg) ( Int e_reg, Int g_reg ); + +/* v-size (4, or 2 with OSO) insn emitters */ +extern void VG_(emit_movv_offregmem_reg) ( Int sz, Int off, Int areg, Int reg ); +extern void VG_(emit_movv_reg_offregmem) ( Int sz, Int reg, Int off, Int areg ); +extern void VG_(emit_movv_reg_reg) ( Int sz, Int reg1, Int reg2 ); +extern void VG_(emit_nonshiftopv_lit_reg)( Bool upd_cc, Int sz, Opcode opc, UInt lit, + Int reg ); +extern void VG_(emit_shiftopv_lit_reg) ( Bool upd_cc, Int sz, Opcode opc, UInt lit, + Int reg ); +extern void VG_(emit_nonshiftopv_reg_reg)( Bool upd_cc, Int sz, Opcode opc, + Int reg1, Int reg2 ); +extern void VG_(emit_movv_lit_reg) ( Int sz, UInt lit, Int reg ); +extern void VG_(emit_unaryopv_reg) ( Bool upd_cc, Int sz, Opcode opc, Int reg ); +extern void VG_(emit_pushv_reg) ( Int sz, Int reg ); +extern void VG_(emit_popv_reg) ( Int sz, Int reg ); + +extern void VG_(emit_pushl_lit32) ( UInt int32 ); +extern void VG_(emit_pushl_lit8) ( Int lit8 ); +extern void VG_(emit_cmpl_zero_reg) ( Bool upd_cc, Int reg ); +extern void VG_(emit_swapl_reg_EAX) ( Int reg ); +extern void VG_(emit_movv_lit_offregmem) ( Int sz, UInt lit, Int off, + Int memreg ); + +/* b-size (1 byte) instruction emitters */ +extern void VG_(emit_movb_lit_offregmem) ( UInt lit, Int off, Int memreg ); +extern void VG_(emit_movb_reg_offregmem) ( Int reg, Int off, Int areg ); +extern void VG_(emit_unaryopb_reg) ( Bool upd_cc, Opcode opc, Int reg ); +extern void VG_(emit_testb_lit_reg) ( Bool upd_cc, UInt lit, Int reg ); + +/* zero-extended load emitters */ +extern void VG_(emit_movzbl_offregmem_reg) ( Bool bounds, Int off, Int regmem, Int reg ); +extern void VG_(emit_movzwl_offregmem_reg) ( Bool bounds, Int off, Int areg, Int reg ); +extern void VG_(emit_movzwl_regmem_reg) ( Bool bounds, Int reg1, Int reg2 ); + +/* misc instruction emitters */ +extern void VG_(emit_call_reg) ( Int reg ); +extern void VG_(emit_add_lit_to_esp) ( Int lit ); +extern void VG_(emit_pushal) ( void ); +extern void VG_(emit_popal) ( void ); +extern void VG_(emit_AMD_prefetch_reg) ( Int reg ); + +/* jump emitters */ +extern void VG_(init_target) ( Int *tgt ); + +extern void VG_(target_back) ( Int *tgt ); +extern void VG_(target_forward) ( Int *tgt ); +extern void VG_(emit_target_delta) ( Int *tgt ); + +typedef enum { + JP_NONE, /* no prediction */ + JP_TAKEN, /* predict taken */ + JP_NOT_TAKEN, /* predict not taken */ +} JumpPred; + +extern void VG_(emit_jcondshort_delta) ( Bool simd_cc, Condcode cond, Int delta, JumpPred ); +extern void VG_(emit_jcondshort_target)( Bool simd_cc, Condcode cond, Int *tgt, JumpPred ); + + +/*====================================================================*/ +/*=== Execution contexts ===*/ +/*====================================================================*/ + +/* Generic resolution type used in a few different ways, such as deciding + how closely to compare two errors for equality. */ +typedef + enum { Vg_LowRes, Vg_MedRes, Vg_HighRes } + VgRes; + +typedef + struct _ExeContext + ExeContext; + +/* Compare two ExeContexts. Number of callers considered depends on `res': + Vg_LowRes: 2 + Vg_MedRes: 4 + Vg_HighRes: all */ +extern Bool VG_(eq_ExeContext) ( VgRes res, + ExeContext* e1, ExeContext* e2 ); + +/* Print an ExeContext. */ +extern void VG_(pp_ExeContext) ( ExeContext* ); + +/* Take a snapshot of the client's stack. Search our collection of + ExeContexts to see if we already have it, and if not, allocate a + new one. Either way, return a pointer to the context. Context size + controlled by --num-callers option. + + If called from generated code, use VG_(get_current_tid)() to get the + current ThreadId. If called from non-generated code, the current + ThreadId should be passed in by the core. +*/ +extern ExeContext* VG_(get_ExeContext) ( ThreadId tid ); + +/* Get the nth EIP from the ExeContext. 0 is the EIP of the top function, 1 + is its caller, etc. Returns 0 if there isn't one, or if n is greater + than VG_(clo_backtrace_size), set by the --num-callers option. */ +extern Addr VG_(get_EIP_from_ExeContext) ( ExeContext* e, UInt n ); + +/* Just grab the client's EIP, as a much smaller and cheaper + indication of where they are. Use is basically same as for + VG_(get_ExeContext)() above. +*/ +extern Addr VG_(get_EIP)( ThreadId tid ); + +/* For tools needing more control over stack traces: walks the stack to get + %eips from the top stack frames for thread 'tid'. Maximum of 'n_eips' + addresses put into 'eips'; 0 is the top of the stack, 1 is its caller, + etc. */ +extern UInt VG_(stack_snapshot) ( ThreadId tid, Addr* eips, UInt n_eips ); + +/* Does the same thing as VG_(pp_ExeContext)(), just with slightly + different input. */ +extern void VG_(mini_stack_dump) ( Addr eips[], UInt n_eips ); + + +/*====================================================================*/ +/*=== Error reporting ===*/ +/*====================================================================*/ + +/* ------------------------------------------------------------------ */ +/* Suppressions describe errors which we want to suppress, ie, not + show the user, usually because it is caused by a problem in a library + which we can't fix, replace or work around. Suppressions are read from + a file at startup time. This gives flexibility so that new + suppressions can be added to the file as and when needed. +*/ + +typedef + Int /* Do not make this unsigned! */ + SuppKind; + +/* The tool-relevant parts of a suppression are: + kind: what kind of suppression; must be in the range (0..) + string: use is optional. NULL by default. + extra: use is optional. NULL by default. void* so it's extensible. +*/ +typedef + struct _Supp + Supp; + +/* Useful in SK_(error_matches_suppression)() */ +SuppKind VG_(get_supp_kind) ( Supp* su ); +Char* VG_(get_supp_string) ( Supp* su ); +void* VG_(get_supp_extra) ( Supp* su ); + +/* Must be used in VG_(recognised_suppression)() */ +void VG_(set_supp_kind) ( Supp* su, SuppKind suppkind ); +/* May be used in VG_(read_extra_suppression_info)() */ +void VG_(set_supp_string) ( Supp* su, Char* string ); +void VG_(set_supp_extra) ( Supp* su, void* extra ); + + +/* ------------------------------------------------------------------ */ +/* Error records contain enough info to generate an error report. The idea + is that (typically) the same few points in the program generate thousands + of errors, and we don't want to spew out a fresh error message for each + one. Instead, we use these structures to common up duplicates. +*/ + +typedef + Int /* Do not make this unsigned! */ + ErrorKind; + +/* The tool-relevant parts of an Error are: + kind: what kind of error; must be in the range (0..) + addr: use is optional. 0 by default. + string: use is optional. NULL by default. + extra: use is optional. NULL by default. void* so it's extensible. +*/ +typedef + struct _Error + Error; + +/* Useful in SK_(error_matches_suppression)(), SK_(pp_SkinError)(), etc */ +ExeContext* VG_(get_error_where) ( Error* err ); +SuppKind 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 ); + +/* 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 + incremented. + + 'tid' can be found as for VG_(get_ExeContext)(). The `extra' field can + be stack-allocated; it will be copied by the core if needed (but it + won't be copied if it's NULL). + + 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 ); + +/* 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 + suppressed, though. Return value is True if it was suppressed. + `print_error' dictates whether to print the error, which is a bit of a + hack that's useful sometimes if you just want to know if the error would + 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, + ExeContext* where, Bool print_error, + Bool allow_GDB_attach, Bool count_error ); + +/* Gets a non-blank, non-comment line of at most nBuf chars from fd. + Skips leading spaces on the line. Returns True if EOF was hit instead. + Useful for reading in extra tool-specific suppression lines. */ +extern Bool VG_(get_line) ( Int fd, Char* buf, Int nBuf ); + + +/*====================================================================*/ +/*=== Obtaining debug information ===*/ +/*====================================================================*/ + +/* Get the file/function/line number of the instruction at address + 'a'. For these four, if debug info for the address is found, it + copies the info into the buffer/UInt and returns True. If not, it + returns False and nothing is copied. VG_(get_fnname) always + demangles C++ function names. VG_(get_fnname_w_offset) is the + same, except it appends "+N" to symbol names to indicate offsets. */ +extern Bool VG_(get_filename) ( Addr a, Char* filename, Int n_filename ); +extern Bool VG_(get_fnname) ( Addr a, Char* fnname, Int n_fnname ); +extern Bool VG_(get_linenum) ( Addr a, UInt* linenum ); +extern Bool VG_(get_fnname_w_offset) + ( Addr a, Char* fnname, Int n_fnname ); + +/* This one is more efficient if getting both filename and line number, + because the two lookups are done together. */ +extern Bool VG_(get_filename_linenum) + ( Addr a, Char* filename, Int n_filename, + UInt* linenum ); + +/* Succeeds only if we find from debug info that 'a' is the address of the + first instruction in a function -- as opposed to VG_(get_fnname) which + succeeds if we find from debug info that 'a' is the address of any + instruction in a function. Use this to instrument the start of + a particular function. Nb: if an executable/shared object is stripped + of its symbols, this function will not be able to recognise function + entry points within it. */ +extern Bool VG_(get_fnname_if_entry) ( Addr a, Char* fnname, Int n_fnname ); + +/* Succeeds if the address is within a shared object or the main executable. + It doesn't matter if debug info is present or not. */ +extern Bool VG_(get_objname) ( Addr a, Char* objname, Int n_objname ); + +/* Puts into 'buf' info about the code address %eip: the address, function + name (if known) and filename/line number (if known), like this: + + 0x4001BF05: realloc (vg_replace_malloc.c:339) + + 'n_buf' gives length of 'buf'. Returns 'buf'. +*/ +extern Char* VG_(describe_eip)(Addr eip, Char* buf, Int n_buf); + +/* Returns a string containing an expression for the given + address. String is malloced with VG_(malloc)() */ +Char *VG_(describe_addr)(ThreadId, Addr); + +/* A way to get information about what segments are mapped */ +typedef struct _SegInfo SegInfo; + +/* Returns NULL if the SegInfo isn't found. It doesn't matter if debug info + is present or not. */ +extern SegInfo* VG_(get_obj) ( Addr a ); + +extern const SegInfo* VG_(next_seginfo) ( const SegInfo *seg ); +extern Addr VG_(seg_start) ( const SegInfo *seg ); +extern UInt VG_(seg_size) ( const SegInfo *seg ); +extern const UChar* VG_(seg_filename) ( const SegInfo *seg ); +extern UInt VG_(seg_sym_offset)( const SegInfo *seg ); + +typedef + enum { + Vg_SectUnknown, + Vg_SectText, + Vg_SectData, + Vg_SectBSS, + Vg_SectGOT, + Vg_SectPLT, + } + VgSectKind; + +extern VgSectKind VG_(seg_sect_kind)(Addr); + + +/*====================================================================*/ +/*=== Generic hash table ===*/ +/*====================================================================*/ + +/* Generic type for a separately-chained hash table. Via a kind of dodgy + C-as-C++ style inheritance, tools can extend the VgHashNode type, so long + as the first two fields match the sizes of these two fields. Requires + a bit of casting by the tool. */ +typedef + struct _VgHashNode { + struct _VgHashNode * next; + UInt key; + } + VgHashNode; + +typedef + VgHashNode** + VgHashTable; + +/* Make a new table. */ +extern VgHashTable VG_(HT_construct) ( void ); + +/* Count the number of nodes in a table. */ +extern Int VG_(HT_count_nodes) ( VgHashTable table ); + +/* Add a node to the table. */ +extern void VG_(HT_add_node) ( VgHashTable t, VgHashNode* node ); + +/* Looks up a node in the hash table. Also returns the address of the + previous node's `next' pointer which allows it to be removed from the + list later without having to look it up again. */ +extern VgHashNode* VG_(HT_get_node) ( VgHashTable t, UInt key, + /*OUT*/VgHashNode*** next_ptr ); + +/* Allocates an array of pointers to all the shadow chunks of malloc'd + blocks. Must be freed with VG_(free)(). */ +extern VgHashNode** VG_(HT_to_array) ( VgHashTable t, /*OUT*/ UInt* n_shadows ); + +/* Returns first node that matches predicate `p', or NULL if none do. + Extra arguments can be implicitly passed to `p' using `d' which is an + opaque pointer passed to `p' each time it is called. */ +extern VgHashNode* VG_(HT_first_match) ( VgHashTable t, + Bool (*p)(VgHashNode*, void*), + void* d ); + +/* Applies a function f() once to each node. Again, `d' can be used + to pass extra information to the function. */ +extern void VG_(HT_apply_to_all_nodes)( VgHashTable t, + void (*f)(VgHashNode*, void*), + void* d ); + +/* Destroy a table. */ +extern void VG_(HT_destruct) ( VgHashTable t ); + + +/*====================================================================*/ +/*=== A generic skiplist ===*/ +/*====================================================================*/ + +/* + The idea here is that the skiplist puts its per-element data at the + end of the structure. When you initialize the skiplist, you tell + it what structure your list elements are going to be. Then you + should allocate them with VG_(SkipNode_Alloc), which will allocate + enough memory for the extra bits. + */ +#include /* for offsetof */ + +typedef struct _SkipList SkipList; +typedef struct _SkipNode SkipNode; + +typedef Int (*SkipCmp_t)(const void *key1, const void *key2); + +struct _SkipList { + const Short arena; /* allocation arena */ + const UShort size; /* structure size (not including SkipNode) */ + const UShort keyoff; /* key offset */ + const SkipCmp_t cmp; /* compare two keys */ + Char * (*strkey)(void *); /* stringify a key (for debugging) */ + SkipNode *head; /* list head */ +}; + +/* Use this macro to initialize your skiplist head. The arguments are pretty self explanitory: + _type is the type of your element structure + _key is the field within that type which you want to use as the key + _cmp is the comparison function for keys - it gets two typeof(_key) pointers as args + _strkey is a function which can return a string of your key - it's only used for debugging + _arena is the arena to use for allocation - -1 is the default + */ +#define SKIPLIST_INIT(_type, _key, _cmp, _strkey, _arena) \ + { \ + .arena = _arena, \ + .size = sizeof(_type), \ + .keyoff = offsetof(_type, _key), \ + .cmp = _cmp, \ + .strkey = _strkey, \ + .head = NULL, \ + } + +/* List operations: + SkipList_Find searchs a list. If it can't find an exact match, it either + returns NULL or a pointer to the element before where k would go + SkipList_Insert inserts a new element into the list. Duplicates are + forbidden. The element must have been created with SkipList_Alloc! + SkipList_Remove removes an element from the list and returns it. It + doesn't free the memory. +*/ +extern void *VG_(SkipList_Find) (const SkipList *l, void *key); +extern void VG_(SkipList_Insert)( SkipList *l, void *data); +extern void *VG_(SkipList_Remove)( SkipList *l, void *key); + +/* Node (element) operations: + SkipNode_Alloc: allocate memory for a new element on the list. Must be + used before an element can be inserted! Returns NULL if not enough + memory. + SkipNode_Free: free memory allocated above + SkipNode_First: return the first element on the list + SkipNode_Next: return the next element after "data" on the list - + NULL for none + + You can iterate through a SkipList like this: + + for(x = VG_(SkipNode_First)(&list); // or SkipList_Find + x != NULL; + x = VG_(SkipNode_Next)(&list, x)) { ... } +*/ +extern void *VG_(SkipNode_Alloc) (const SkipList *l); +extern void VG_(SkipNode_Free) (const SkipList *l, void *p); +extern void *VG_(SkipNode_First) (const SkipList *l); +extern void *VG_(SkipNode_Next) (const SkipList *l, void *data); + +/*====================================================================*/ +/*=== Functions for shadow registers ===*/ +/*====================================================================*/ + +/* Nb: make sure the shadow_regs 'need' is set before using these! */ + +/* This one lets you override the shadow of the return value register for a + syscall. Call it from SK_(post_syscall)() (not SK_(pre_syscall)()!) to + override the default shadow register value. */ +extern void VG_(set_return_from_syscall_shadow) ( ThreadId tid, + UInt ret_shadow ); + +/* This can be called from SK_(fini)() to find the shadow of the argument + to exit(), ie. the shadow of the program's return value. */ +extern UInt VG_(get_exit_status_shadow) ( void ); + + +/*====================================================================*/ +/*=== Specific stuff for replacing malloc() and friends ===*/ +/*====================================================================*/ + +/* If a tool replaces malloc() et al, the easiest way to do so is to + link with vg_replace_malloc.o into its vgpreload_*.so file, and + follow the following instructions. You can do it from scratch, + though, if you enjoy that sort of thing. */ + +/* Arena size for valgrind's own malloc(); default value is 0, but can + be overridden by tool -- but must be done so *statically*, eg: + + Int VG_(vg_malloc_redzone_szB) = 4; + + It can't be done from a function like SK_(pre_clo_init)(). So it can't, + for example, be controlled with a command line option, unfortunately. */ +extern UInt VG_(vg_malloc_redzone_szB); + +/* Can be called from SK_(malloc) et al to do the actual alloc/freeing. */ +extern void* VG_(cli_malloc) ( UInt align, Int nbytes ); +extern void VG_(cli_free) ( void* p ); + +/* Check if an address is within a range, allowing for redzones at edges */ +extern Bool VG_(addr_is_in_block)( Addr a, Addr start, UInt size ); + +/* ------------------------------------------------------------------ */ +/* Some options that can be used by a tool if malloc() et al are replaced. + The tool should call the functions in the appropriate places to give + control over these aspects of Valgrind's version of malloc(). */ + +/* Round malloc sizes upwards to integral number of words? default: NO */ +extern Bool VG_(clo_sloppy_malloc); +/* DEBUG: print malloc details? default: NO */ +extern Bool VG_(clo_trace_malloc); +/* Minimum alignment in functions that don't specify alignment explicitly. + default: 0, i.e. use default of the machine (== 4) */ +extern Int VG_(clo_alignment); + +extern Bool VG_(replacement_malloc_process_cmd_line_option) ( Char* arg ); +extern void VG_(replacement_malloc_print_usage) ( void ); +extern void VG_(replacement_malloc_print_debug_usage) ( void ); + + +/*====================================================================*/ +/*=== Tool-specific stuff ===*/ +/*====================================================================*/ + +/* ------------------------------------------------------------------ */ +/* Details */ + +/* Default value for avg_translations_sizeB (in bytes), indicating typical + code expansion of about 6:1. */ +#define VG_DEFAULT_TRANS_SIZEB 100 + +/* Information used in the startup message. `name' also determines the + string used for identifying suppressions in a suppression file as + belonging to this tool. `version' can be NULL, in which case (not + surprisingly) no version info is printed; this mechanism is designed for + tools distributed with Valgrind that share a version number with + Valgrind. Other tools not distributed as part of Valgrind should + probably have their own version number. */ +extern void VG_(details_name) ( Char* name ); +extern void VG_(details_version) ( Char* version ); +extern void VG_(details_description) ( Char* description ); +extern void VG_(details_copyright_author) ( Char* copyright_author ); + +/* Average size of a translation, in bytes, so that the translation + storage machinery can allocate memory appropriately. Not critical, + setting is optional. */ +extern void VG_(details_avg_translation_sizeB) ( UInt size ); + +/* String printed if an `sk_assert' assertion fails or VG_(skin_panic) + is called. Should probably be an email address. */ +extern void VG_(details_bug_reports_to) ( Char* bug_reports_to ); + +/* ------------------------------------------------------------------ */ +/* Needs */ + +/* Booleans that decide core behaviour, but don't require extra + operations to be defined if `True' */ + +/* Should __libc_freeres() be run? Bugs in it can crash the tool. */ +extern void VG_(needs_libc_freeres) ( void ); + +/* Want to have errors detected by Valgrind's core reported? Includes: + - pthread API errors (many; eg. unlocking a non-locked mutex) + - invalid file descriptors to blocking syscalls read() and write() + - bad signal numbers passed to sigaction() + - attempt to install signal handler for SIGKILL or SIGSTOP */ +extern void VG_(needs_core_errors) ( void ); + +/* Booleans that indicate extra operations are defined; if these are True, + the corresponding template functions (given below) must be defined. A + lot like being a member of a type class. */ + +/* Want to report errors from tool? This implies use of suppressions, too. */ +extern void VG_(needs_skin_errors) ( void ); + +/* Is information kept about specific individual basic blocks? (Eg. for + cachegrind there are cost-centres for every instruction, stored at a + basic block level.) If so, it sometimes has to be discarded, because + .so mmap/munmap-ping or self-modifying code (informed by the + DISCARD_TRANSLATIONS user request) can cause one instruction address + to be used for more than one instruction in one program run... */ +extern void VG_(needs_basic_block_discards) ( void ); + +/* Tool maintains information about each register? */ +extern void VG_(needs_shadow_regs) ( void ); + +/* Tool defines its own command line options? */ +extern void VG_(needs_command_line_options) ( void ); + +/* Tool defines its own client requests? */ +extern void VG_(needs_client_requests) ( void ); + +/* Tool defines its own UInstrs? */ +extern void VG_(needs_extended_UCode) ( void ); + +/* Tool does stuff before and/or after system calls? */ +extern void VG_(needs_syscall_wrapper) ( void ); + +/* Are tool-state sanity checks performed? */ +extern void VG_(needs_sanity_checks) ( void ); + +/* Do we need to see data symbols? */ +extern void VG_(needs_data_syms) ( void ); + +/* Does the tool need shadow memory allocated (if you set this, you must also statically initialize + float SK_(shadow_ratio) = n./m; + to define how many shadow bits you need per client address space bit. +*/ +extern void VG_(needs_shadow_memory)( void ); +extern float SK_(shadow_ratio); + +/* ------------------------------------------------------------------ */ +/* Core events to track */ + +/* Part of the core from which this call was made. Useful for determining + what kind of error message should be emitted. */ +typedef + enum { Vg_CorePThread, Vg_CoreSignal, Vg_CoreSysCall, Vg_CoreTranslate } + CorePart; + +/* Useful to use in VG_(get_Xreg_usage)() */ +#define VG_UINSTR_READS_REG(ono,regs,isWrites) \ + { if (mycat(u->tag,ono) == tag) \ + { regs[n] = mycat(u->val,ono); \ + isWrites[n] = False; \ + n++; \ + } \ + } +#define VG_UINSTR_WRITES_REG(ono,regs,isWrites) \ + { if (mycat(u->tag,ono) == tag) \ + { regs[n] = mycat(u->val,ono); \ + isWrites[n] = True; \ + n++; \ + } \ + } + +#endif /* NDEF __TOOL_H */ + +/* gen_toolint.pl will put the VG_(init_*)() functions here: */