--- /dev/null
+/*-*- 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 <stdarg.h> /* ANSI varargs stuff */
+#include <setjmp.h> /* 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 "??<pid>?? "; '?' 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_<args>_<retval>". '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 <stddef.h> /* 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: */
projects / thirdparty / valgrind.git / commitdiff
