blob: 2eb100a4bec11abaf30a235166cbd3aa0f5cb975 [file] [log] [blame]
njn25e49d8e72002-09-23 09:36:25 +00001
2/*--------------------------------------------------------------------*/
3/*--- The only header your skin will ever need to #include... ---*/
4/*--- vg_skin.h ---*/
5/*--------------------------------------------------------------------*/
6
7/*
njnc9539842002-10-02 13:26:35 +00008 This file is part of Valgrind, an extensible x86 protected-mode
9 emulator for monitoring program execution on x86-Unixes.
njn25e49d8e72002-09-23 09:36:25 +000010
njn0e1b5142003-04-15 14:58:06 +000011 Copyright (C) 2000-2003 Julian Seward
njn25e49d8e72002-09-23 09:36:25 +000012 jseward@acm.org
13
14 This program is free software; you can redistribute it and/or
15 modify it under the terms of the GNU General Public License as
16 published by the Free Software Foundation; either version 2 of the
17 License, or (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
27 02111-1307, USA.
28
29 The GNU General Public License is contained in the file COPYING.
30*/
31
32#ifndef __VG_SKIN_H
33#define __VG_SKIN_H
34
35#include <stdarg.h> /* ANSI varargs stuff */
36#include <setjmp.h> /* for jmp_buf */
37
38#include "vg_constants_skin.h"
39
40
41/*====================================================================*/
42/*=== Build options and table sizes. ===*/
43/*====================================================================*/
44
45/* You should be able to change these options or sizes, recompile, and
46 still have a working system. */
47
48/* The maximum number of pthreads that we support. This is
49 deliberately not very high since our implementation of some of the
50 scheduler algorithms is surely O(N) in the number of threads, since
51 that's simple, at least. And (in practice) we hope that most
52 programs do not need many threads. */
sewardj989dad92003-07-06 01:52:32 +000053#define VG_N_THREADS 100
njn25e49d8e72002-09-23 09:36:25 +000054
55/* Maximum number of pthread keys available. Again, we start low until
56 the need for a higher number presents itself. */
57#define VG_N_THREAD_KEYS 50
58
59/* Total number of integer registers available for allocation -- all of
60 them except %esp, %ebp. %ebp permanently points at VG_(baseBlock).
61
njn211b6ad2003-02-03 12:33:31 +000062 If you increase this you'll have to also change at least these:
njn4ba5a792002-09-30 10:23:54 +000063 - VG_(rank_to_realreg)()
64 - VG_(realreg_to_rank)()
njn25e49d8e72002-09-23 09:36:25 +000065 - ppRegsLiveness()
66 - the RegsLive type (maybe -- RegsLive type must have more than
67 VG_MAX_REALREGS bits)
njn211b6ad2003-02-03 12:33:31 +000068
69 You can decrease it, and performance will drop because more spills will
70 occur. If you decrease it too much, everything will fall over.
njn25e49d8e72002-09-23 09:36:25 +000071
72 Do not change this unless you really know what you are doing! */
73#define VG_MAX_REALREGS 6
74
75
76/*====================================================================*/
njn1a1dd8b2002-09-27 10:42:20 +000077/*=== Basic types, useful macros ===*/
njn25e49d8e72002-09-23 09:36:25 +000078/*====================================================================*/
79
njn25e49d8e72002-09-23 09:36:25 +000080typedef unsigned char UChar;
81typedef unsigned short UShort;
82typedef unsigned int UInt;
83typedef unsigned long long int ULong;
84
85typedef signed char Char;
86typedef signed short Short;
87typedef signed int Int;
88typedef signed long long int Long;
89
90typedef unsigned int Addr;
91
92typedef unsigned char Bool;
93#define False ((Bool)0)
94#define True ((Bool)1)
95
96
njn1a1dd8b2002-09-27 10:42:20 +000097#define mycat_wrk(aaa,bbb) aaa##bbb
98#define mycat(aaa,bbb) mycat_wrk(aaa,bbb)
99
100/* No, really. I _am_ that strange. */
101#define OINK(nnn) VG_(message)(Vg_DebugMsg, "OINK %d",nnn)
102
njn25e49d8e72002-09-23 09:36:25 +0000103/* ---------------------------------------------------------------------
104 Now the basic types are set up, we can haul in the kernel-interface
105 definitions.
106 ------------------------------------------------------------------ */
107
njn78adbf42003-07-24 19:35:00 +0000108#include "vg_kerneliface.h"
njn25e49d8e72002-09-23 09:36:25 +0000109
110
111/*====================================================================*/
njn27f1a382002-11-08 15:48:16 +0000112/*=== Core/skin interface version ===*/
113/*====================================================================*/
114
115/* The major version number indicates binary-incompatible changes to the
116 interface; if the core and skin major versions don't match, Valgrind
117 will abort. The minor version indicates binary-compatible changes.
njn27f1a382002-11-08 15:48:16 +0000118*/
njn72718642003-07-24 08:45:32 +0000119#define VG_CORE_INTERFACE_MAJOR_VERSION 3
njn9b007f62003-04-07 14:40:25 +0000120#define VG_CORE_INTERFACE_MINOR_VERSION 0
njn27f1a382002-11-08 15:48:16 +0000121
122extern const Int VG_(skin_interface_major_version);
123extern const Int VG_(skin_interface_minor_version);
124
njn563f96f2003-02-03 11:17:46 +0000125/* Every skin must include this macro somewhere, exactly once. */
njn27f1a382002-11-08 15:48:16 +0000126#define VG_DETERMINE_INTERFACE_VERSION \
127const Int VG_(skin_interface_major_version) = VG_CORE_INTERFACE_MAJOR_VERSION; \
128const Int VG_(skin_interface_minor_version) = VG_CORE_INTERFACE_MINOR_VERSION;
129
njn211b6ad2003-02-03 12:33:31 +0000130
njn27f1a382002-11-08 15:48:16 +0000131/*====================================================================*/
njn25e49d8e72002-09-23 09:36:25 +0000132/*=== Command-line options ===*/
133/*====================================================================*/
134
njn43c799e2003-04-08 00:08:52 +0000135/* Use this for normal null-termination-style string comparison */
136#define VG_STREQ(s1,s2) (s1 != NULL && s2 != NULL \
137 && VG_(strcmp)((s1),(s2))==0)
138
139/* Use these for recognising skin command line options -- stops comparing
140 once whitespace is reached. */
141# define VG_CLO_STREQ(s1,s2) (0==VG_(strcmp_ws)((s1),(s2)))
142# define VG_CLO_STREQN(nn,s1,s2) (0==VG_(strncmp_ws)((s1),(s2),(nn)))
143
njn25e49d8e72002-09-23 09:36:25 +0000144/* Verbosity level: 0 = silent, 1 (default), > 1 = more verbose. */
145extern Int VG_(clo_verbosity);
146
147/* Profile? */
148extern Bool VG_(clo_profile);
149
njn25e49d8e72002-09-23 09:36:25 +0000150/* Call this if a recognised option was bad for some reason.
151 Note: don't use it just because an option was unrecognised -- return 'False'
152 from SKN_(process_cmd_line_option) to indicate that. */
153extern void VG_(bad_option) ( Char* opt );
154
155/* Client args */
156extern Int VG_(client_argc);
157extern Char** VG_(client_argv);
158
njnd5bb0a52002-09-27 10:24:48 +0000159/* Client environment. Can be inspected with VG_(getenv)() */
njn25e49d8e72002-09-23 09:36:25 +0000160extern Char** VG_(client_envp);
161
162
163/*====================================================================*/
164/*=== Printing messages for the user ===*/
165/*====================================================================*/
166
167/* Print a message prefixed by "??<pid>?? "; '?' depends on the VgMsgKind.
168 Should be used for all user output. */
169
170typedef
171 enum { Vg_UserMsg, /* '?' == '=' */
172 Vg_DebugMsg, /* '?' == '-' */
173 Vg_DebugExtraMsg /* '?' == '+' */
174 }
175 VgMsgKind;
176
177/* Functions for building a message from multiple parts. */
178extern void VG_(start_msg) ( VgMsgKind kind );
179extern void VG_(add_to_msg) ( Char* format, ... );
180/* Ends and prints the message. Appends a newline. */
181extern void VG_(end_msg) ( void );
182
njnd5bb0a52002-09-27 10:24:48 +0000183/* Send a single-part message. Appends a newline. */
njn25e49d8e72002-09-23 09:36:25 +0000184extern void VG_(message) ( VgMsgKind kind, Char* format, ... );
185
186
187/*====================================================================*/
188/*=== Profiling ===*/
189/*====================================================================*/
190
191/* Nb: VGP_(register_profile_event)() relies on VgpUnc being the first one */
192#define VGP_CORE_LIST \
193 /* These ones depend on the core */ \
194 VGP_PAIR(VgpUnc, "unclassified"), \
195 VGP_PAIR(VgpRun, "running"), \
196 VGP_PAIR(VgpSched, "scheduler"), \
197 VGP_PAIR(VgpMalloc, "low-lev malloc/free"), \
198 VGP_PAIR(VgpCliMalloc, "client malloc/free"), \
njn25e49d8e72002-09-23 09:36:25 +0000199 VGP_PAIR(VgpTranslate, "translate-main"), \
200 VGP_PAIR(VgpToUCode, "to-ucode"), \
201 VGP_PAIR(VgpFromUcode, "from-ucode"), \
202 VGP_PAIR(VgpImprove, "improve"), \
njn9b007f62003-04-07 14:40:25 +0000203 VGP_PAIR(VgpESPUpdate, "ESP-update"), \
njn25e49d8e72002-09-23 09:36:25 +0000204 VGP_PAIR(VgpRegAlloc, "reg-alloc"), \
205 VGP_PAIR(VgpLiveness, "liveness-analysis"), \
206 VGP_PAIR(VgpDoLRU, "do-lru"), \
207 VGP_PAIR(VgpSlowFindT, "slow-search-transtab"), \
208 VGP_PAIR(VgpInitMem, "init-memory"), \
209 VGP_PAIR(VgpExeContext, "exe-context"), \
210 VGP_PAIR(VgpReadSyms, "read-syms"), \
211 VGP_PAIR(VgpSearchSyms, "search-syms"), \
212 VGP_PAIR(VgpAddToT, "add-to-transtab"), \
213 VGP_PAIR(VgpCoreSysWrap, "core-syscall-wrapper"), \
214 VGP_PAIR(VgpDemangle, "demangle"), \
njn37cea302002-09-30 11:24:00 +0000215 VGP_PAIR(VgpCoreCheapSanity, "core-cheap-sanity"), \
216 VGP_PAIR(VgpCoreExpensiveSanity, "core-expensive-sanity"), \
njn25e49d8e72002-09-23 09:36:25 +0000217 /* These ones depend on the skin */ \
218 VGP_PAIR(VgpPreCloInit, "pre-clo-init"), \
219 VGP_PAIR(VgpPostCloInit, "post-clo-init"), \
220 VGP_PAIR(VgpInstrument, "instrument"), \
221 VGP_PAIR(VgpSkinSysWrap, "skin-syscall-wrapper"), \
njn37cea302002-09-30 11:24:00 +0000222 VGP_PAIR(VgpSkinCheapSanity, "skin-cheap-sanity"), \
223 VGP_PAIR(VgpSkinExpensiveSanity, "skin-expensive-sanity"), \
njn25e49d8e72002-09-23 09:36:25 +0000224 VGP_PAIR(VgpFini, "fini")
225
226#define VGP_PAIR(n,name) n
227typedef enum { VGP_CORE_LIST } VgpCoreCC;
228#undef VGP_PAIR
229
230/* When registering skin profiling events, ensure that the 'n' value is in
231 * the range (VgpFini+1..) */
232extern void VGP_(register_profile_event) ( Int n, Char* name );
233
234extern void VGP_(pushcc) ( UInt cc );
235extern void VGP_(popcc) ( UInt cc );
236
237/* Define them only if they haven't already been defined by vg_profile.c */
238#ifndef VGP_PUSHCC
239# define VGP_PUSHCC(x)
240#endif
241#ifndef VGP_POPCC
242# define VGP_POPCC(x)
243#endif
244
245
246/*====================================================================*/
247/*=== Useful stuff to call from generated code ===*/
248/*====================================================================*/
249
250/* ------------------------------------------------------------------ */
251/* General stuff */
252
njn41557122002-10-14 09:25:37 +0000253/* 64-bit counter for the number of basic blocks done. */
254extern ULong VG_(bbs_done);
255
njn25e49d8e72002-09-23 09:36:25 +0000256/* Get the simulated %esp */
257extern Addr VG_(get_stack_pointer) ( void );
258
sewardjecf8e102003-07-12 12:11:39 +0000259/* Detect if an address is within Valgrind's stack, Valgrind's
260 m_state_static, or the VG_(threads) array. This is useful for
261 memory leak detectors to rule out spurious pointers to a block. */
njn25e49d8e72002-09-23 09:36:25 +0000262extern Bool VG_(within_stack)(Addr a);
sewardjecf8e102003-07-12 12:11:39 +0000263extern Bool VG_(within_m_state_static_OR_threads)(Addr a);
njn25e49d8e72002-09-23 09:36:25 +0000264
265/* Check if an address is 4-byte aligned */
266#define IS_ALIGNED4_ADDR(aaa_p) (0 == (((UInt)(aaa_p)) & 3))
njn9b007f62003-04-07 14:40:25 +0000267#define IS_ALIGNED8_ADDR(aaa_p) (0 == (((UInt)(aaa_p)) & 7))
njn25e49d8e72002-09-23 09:36:25 +0000268
269
270/* ------------------------------------------------------------------ */
271/* Thread-related stuff */
272
273/* Special magic value for an invalid ThreadId. It corresponds to
274 LinuxThreads using zero as the initial value for
275 pthread_mutex_t.__m_owner and pthread_cond_t.__c_waiting. */
276#define VG_INVALID_THREADID ((ThreadId)(0))
277
njn72718642003-07-24 08:45:32 +0000278/* ThreadIds are simply indices into the VG_(threads)[] array. */
njn25e49d8e72002-09-23 09:36:25 +0000279typedef
280 UInt
281 ThreadId;
282
njn72718642003-07-24 08:45:32 +0000283/* When looking for the current ThreadId, this is the safe option and
284 probably the one you want.
285
286 Details: Use this one from non-generated code, eg. from functions called
287 on events like 'new_mem_heap'. In such a case, the "current" thread is
288 temporarily suspended as Valgrind's dispatcher is running. This function
289 is also suitable to be called from generated code (ie. from UCode, or a C
290 function called directly from UCode).
291
292 If you use VG_(get_current_tid)() from non-generated code, it will return
293 0 signifying the invalid thread, which is probably not what you want. */
294extern ThreadId VG_(get_current_or_recent_tid) ( void );
njn25e49d8e72002-09-23 09:36:25 +0000295
njn72718642003-07-24 08:45:32 +0000296/* When looking for the current ThreadId, only use this one if you know what
297 you are doing.
298
299 Details: Use this one from generated code, eg. from C functions called
300 from UCode. (VG_(get_current_or_recent_tid)() is also suitable in that
301 case.) If you use this function from non-generated code, it will return
302 0 signifying the invalid thread, which is probably not what you want. */
303extern ThreadId VG_(get_current_tid) ( void );
njn25e49d8e72002-09-23 09:36:25 +0000304
njn3e884182003-04-15 13:03:23 +0000305/* Searches through all thread's stacks to see if any match. Returns
njn72718642003-07-24 08:45:32 +0000306 VG_INVALID_THREADID if none match. */
njn3e884182003-04-15 13:03:23 +0000307extern ThreadId VG_(first_matching_thread_stack)
308 ( Bool (*p) ( Addr stack_min, Addr stack_max ));
309
njn25e49d8e72002-09-23 09:36:25 +0000310
311/*====================================================================*/
312/*=== Valgrind's version of libc ===*/
313/*====================================================================*/
314
315/* Valgrind doesn't use libc at all, for good reasons (trust us). So here
316 are its own versions of C library functions, but with VG_ prefixes. Note
317 that the types of some are slightly different to the real ones. Some
njnf4ce3d32003-02-10 10:17:26 +0000318 additional useful functions are provided too; descriptions of how they
319 work are given below. */
njn25e49d8e72002-09-23 09:36:25 +0000320
321#if !defined(NULL)
322# define NULL ((void*)0)
323#endif
324
325
326/* ------------------------------------------------------------------ */
327/* stdio.h
328 *
329 * Note that they all output to the file descriptor given by the
330 * --logfile-fd=N argument, which defaults to 2 (stderr). Hence no
331 * need for VG_(fprintf)().
njn25e49d8e72002-09-23 09:36:25 +0000332 */
sewardj78e3cd92002-10-22 04:45:48 +0000333extern UInt VG_(printf) ( const char *format, ... );
njn25e49d8e72002-09-23 09:36:25 +0000334/* too noisy ... __attribute__ ((format (printf, 1, 2))) ; */
sewardj78e3cd92002-10-22 04:45:48 +0000335extern UInt VG_(sprintf) ( Char* buf, Char *format, ... );
336extern UInt VG_(vprintf) ( void(*send)(Char),
njn25e49d8e72002-09-23 09:36:25 +0000337 const Char *format, va_list vargs );
338
njn41557122002-10-14 09:25:37 +0000339extern Int VG_(rename) ( Char* old_name, Char* new_name );
340
njn25e49d8e72002-09-23 09:36:25 +0000341/* ------------------------------------------------------------------ */
342/* stdlib.h */
343
344extern void* VG_(malloc) ( Int nbytes );
njnd5bb0a52002-09-27 10:24:48 +0000345extern void VG_(free) ( void* p );
346extern void* VG_(calloc) ( Int n, Int nbytes );
347extern void* VG_(realloc) ( void* p, Int size );
348extern void* VG_(malloc_aligned) ( Int align_bytes, Int nbytes );
njn25e49d8e72002-09-23 09:36:25 +0000349
350extern void VG_(print_malloc_stats) ( void );
351
352
353extern void VG_(exit)( Int status )
354 __attribute__ ((__noreturn__));
njne427a662002-10-02 11:08:25 +0000355/* Prints a panic message (a constant string), appends newline and bug
356 reporting info, aborts. */
357__attribute__ ((__noreturn__))
358extern void VG_(skin_panic) ( Char* str );
njn25e49d8e72002-09-23 09:36:25 +0000359
njnd5bb0a52002-09-27 10:24:48 +0000360/* Looks up VG_(client_envp) */
njn25e49d8e72002-09-23 09:36:25 +0000361extern Char* VG_(getenv) ( Char* name );
362
363/* Crude stand-in for the glibc system() call. */
364extern Int VG_(system) ( Char* cmd );
365
njnd5bb0a52002-09-27 10:24:48 +0000366extern Long VG_(atoll) ( Char* str );
njn25e49d8e72002-09-23 09:36:25 +0000367
368/* Like atoll(), but converts a number of base 2..36 */
369extern Long VG_(atoll36) ( UInt base, Char* str );
370
371
372/* ------------------------------------------------------------------ */
njnd5bb0a52002-09-27 10:24:48 +0000373/* ctype.h */
njn25e49d8e72002-09-23 09:36:25 +0000374extern Bool VG_(isspace) ( Char c );
375extern Bool VG_(isdigit) ( Char c );
376extern Char VG_(toupper) ( Char c );
377
378
379/* ------------------------------------------------------------------ */
380/* string.h */
381extern Int VG_(strlen) ( const Char* str );
382extern Char* VG_(strcat) ( Char* dest, const Char* src );
383extern Char* VG_(strncat) ( Char* dest, const Char* src, Int n );
384extern Char* VG_(strpbrk) ( const Char* s, const Char* accept );
385extern Char* VG_(strcpy) ( Char* dest, const Char* src );
386extern Char* VG_(strncpy) ( Char* dest, const Char* src, Int ndest );
387extern Int VG_(strcmp) ( const Char* s1, const Char* s2 );
388extern Int VG_(strncmp) ( const Char* s1, const Char* s2, Int nmax );
389extern Char* VG_(strstr) ( const Char* haystack, Char* needle );
390extern Char* VG_(strchr) ( const Char* s, Char c );
391extern Char* VG_(strdup) ( const Char* s);
sewardj7ab2aca2002-10-20 19:40:32 +0000392extern void* VG_(memcpy) ( void *d, const void *s, Int sz );
393extern void* VG_(memset) ( void *s, Int c, Int sz );
njn6d68e792003-02-24 10:49:08 +0000394extern Int VG_(memcmp) ( const void* s1, const void* s2, Int n );
njn25e49d8e72002-09-23 09:36:25 +0000395
njnd5bb0a52002-09-27 10:24:48 +0000396/* Like strcmp() and strncmp(), but stop comparing at any whitespace. */
njn25e49d8e72002-09-23 09:36:25 +0000397extern Int VG_(strcmp_ws) ( const Char* s1, const Char* s2 );
njn25e49d8e72002-09-23 09:36:25 +0000398extern Int VG_(strncmp_ws) ( const Char* s1, const Char* s2, Int nmax );
399
njnd5bb0a52002-09-27 10:24:48 +0000400/* Like strncpy(), but if 'src' is longer than 'ndest' inserts a '\0' as the
401 last character. */
njn25e49d8e72002-09-23 09:36:25 +0000402extern void VG_(strncpy_safely) ( Char* dest, const Char* src, Int ndest );
403
404/* Mini-regexp function. Searches for 'pat' in 'str'. Supports
405 * meta-symbols '*' and '?'. '\' escapes meta-symbols. */
njn4ba5a792002-09-30 10:23:54 +0000406extern Bool VG_(string_match) ( Char* pat, Char* str );
njn25e49d8e72002-09-23 09:36:25 +0000407
408
409/* ------------------------------------------------------------------ */
410/* math.h */
njnd5bb0a52002-09-27 10:24:48 +0000411/* Returns the base-2 logarithm of x. */
njn25e49d8e72002-09-23 09:36:25 +0000412extern Int VG_(log2) ( Int x );
413
414
415/* ------------------------------------------------------------------ */
njnd5bb0a52002-09-27 10:24:48 +0000416/* unistd.h, fcntl.h, sys/stat.h */
sewardj4cf05692002-10-27 20:28:29 +0000417extern Int VG_(getpid) ( void );
418extern Int VG_(getppid) ( void );
njnd5bb0a52002-09-27 10:24:48 +0000419
njn4aca2d22002-10-04 10:29:38 +0000420extern Int VG_(open) ( const Char* pathname, Int flags, Int mode );
421extern Int VG_(read) ( Int fd, void* buf, Int count);
422extern Int VG_(write) ( Int fd, void* buf, Int count);
423extern void VG_(close) ( Int fd );
njnd5bb0a52002-09-27 10:24:48 +0000424
njn41557122002-10-14 09:25:37 +0000425/* Nb: VG_(rename)() declared in stdio.h section above */
njn4aca2d22002-10-04 10:29:38 +0000426extern Int VG_(unlink) ( Char* file_name );
427extern Int VG_(stat) ( Char* file_name, struct vki_stat* buf );
njn25e49d8e72002-09-23 09:36:25 +0000428
njn13f02932003-04-30 20:23:58 +0000429extern Char* VG_(getcwd) ( Char* buf, Int size );
430
njn25e49d8e72002-09-23 09:36:25 +0000431
432/* ------------------------------------------------------------------ */
433/* assert.h */
434/* Asserts permanently enabled -- no turning off with NDEBUG. Hurrah! */
435#define VG__STRING(__str) #__str
436
njne427a662002-10-02 11:08:25 +0000437#define sk_assert(expr) \
njn25e49d8e72002-09-23 09:36:25 +0000438 ((void) ((expr) ? 0 : \
njne427a662002-10-02 11:08:25 +0000439 (VG_(skin_assert_fail) (VG__STRING(expr), \
440 __FILE__, __LINE__, \
441 __PRETTY_FUNCTION__), 0)))
njn25e49d8e72002-09-23 09:36:25 +0000442
njne427a662002-10-02 11:08:25 +0000443__attribute__ ((__noreturn__))
444extern void VG_(skin_assert_fail) ( Char* expr, Char* file,
445 Int line, Char* fn );
njn25e49d8e72002-09-23 09:36:25 +0000446
447
448/* ------------------------------------------------------------------ */
njnd5bb0a52002-09-27 10:24:48 +0000449/* system/mman.h */
njn25e49d8e72002-09-23 09:36:25 +0000450extern void* VG_(mmap)( void* start, UInt length,
451 UInt prot, UInt flags, UInt fd, UInt offset );
452extern Int VG_(munmap)( void* start, Int length );
453
454/* Get memory by anonymous mmap. */
455extern void* VG_(get_memory_from_mmap) ( Int nBytes, Char* who );
456
457
458/* ------------------------------------------------------------------ */
459/* signal.h.
460
461 Note that these use the vk_ (kernel) structure
462 definitions, which are different in places from those that glibc
463 defines -- hence the 'k' prefix. Since we're operating right at the
464 kernel interface, glibc's view of the world is entirely irrelevant. */
465
466/* --- Signal set ops --- */
njnd5bb0a52002-09-27 10:24:48 +0000467extern Int VG_(ksigfillset) ( vki_ksigset_t* set );
468extern Int VG_(ksigemptyset) ( vki_ksigset_t* set );
njn25e49d8e72002-09-23 09:36:25 +0000469
njnd5bb0a52002-09-27 10:24:48 +0000470extern Bool VG_(kisfullsigset) ( vki_ksigset_t* set );
471extern Bool VG_(kisemptysigset) ( vki_ksigset_t* set );
njn25e49d8e72002-09-23 09:36:25 +0000472
njnd5bb0a52002-09-27 10:24:48 +0000473extern Int VG_(ksigaddset) ( vki_ksigset_t* set, Int signum );
474extern Int VG_(ksigdelset) ( vki_ksigset_t* set, Int signum );
njn25e49d8e72002-09-23 09:36:25 +0000475extern Int VG_(ksigismember) ( vki_ksigset_t* set, Int signum );
476
njnd5bb0a52002-09-27 10:24:48 +0000477extern void VG_(ksigaddset_from_set) ( vki_ksigset_t* dst, vki_ksigset_t* src );
478extern void VG_(ksigdelset_from_set) ( vki_ksigset_t* dst, vki_ksigset_t* src );
njn25e49d8e72002-09-23 09:36:25 +0000479
480/* --- Mess with the kernel's sig state --- */
njnd5bb0a52002-09-27 10:24:48 +0000481extern Int VG_(ksigprocmask) ( Int how, const vki_ksigset_t* set,
njn25e49d8e72002-09-23 09:36:25 +0000482 vki_ksigset_t* oldset );
njnd5bb0a52002-09-27 10:24:48 +0000483extern Int VG_(ksigaction) ( Int signum,
484 const vki_ksigaction* act,
485 vki_ksigaction* oldact );
njn25e49d8e72002-09-23 09:36:25 +0000486
njnd5bb0a52002-09-27 10:24:48 +0000487extern Int VG_(ksignal) ( Int signum, void (*sighandler)(Int) );
488extern Int VG_(ksigaltstack) ( const vki_kstack_t* ss, vki_kstack_t* oss );
njn25e49d8e72002-09-23 09:36:25 +0000489
sewardjdcaf3122002-09-30 23:12:33 +0000490extern Int VG_(kkill) ( Int pid, Int signo );
491extern Int VG_(ksigpending) ( vki_ksigset_t* set );
njn25e49d8e72002-09-23 09:36:25 +0000492
493
494/*====================================================================*/
495/*=== UCode definition ===*/
496/*====================================================================*/
497
sewardje1042472002-09-30 12:33:11 +0000498/* Tags which describe what operands are. Must fit into 4 bits, which
499 they clearly do. */
njn25e49d8e72002-09-23 09:36:25 +0000500typedef
sewardje1042472002-09-30 12:33:11 +0000501enum { TempReg =0, /* virtual temp-reg */
502 ArchReg =1, /* simulated integer reg */
503 ArchRegS =2, /* simulated segment reg */
504 RealReg =3, /* real machine's real reg */
505 SpillNo =4, /* spill slot location */
506 Literal =5, /* literal; .lit32 field has actual value */
507 Lit16 =6, /* literal; .val[123] field has actual value */
508 NoValue =7 /* operand not in use */
509 }
510 Tag;
njn25e49d8e72002-09-23 09:36:25 +0000511
njnd5bb0a52002-09-27 10:24:48 +0000512/* Invalid register numbers (can't be negative) */
njn25e49d8e72002-09-23 09:36:25 +0000513#define INVALID_TEMPREG 999999999
514#define INVALID_REALREG 999999999
515
516/* Microinstruction opcodes. */
517typedef
518 enum {
njnd5bb0a52002-09-27 10:24:48 +0000519 NOP, /* Null op */
njn25e49d8e72002-09-23 09:36:25 +0000520
daywalker7e73e5f2003-07-04 16:18:15 +0000521 LOCK, /* Indicate the existence of a LOCK prefix (functionally NOP) */
sewardj7a5ebcf2002-11-13 22:42:13 +0000522
njnd5bb0a52002-09-27 10:24:48 +0000523 /* Moving values around */
524 GET, PUT, /* simulated register <--> TempReg */
525 GETF, PUTF, /* simulated %eflags <--> TempReg */
526 LOAD, STORE, /* memory <--> TempReg */
527 MOV, /* TempReg <--> TempReg */
528 CMOV, /* Used for cmpxchg and cmov */
njn25e49d8e72002-09-23 09:36:25 +0000529
njnd5bb0a52002-09-27 10:24:48 +0000530 /* Arithmetic/logical ops */
531 ADD, ADC, SUB, SBB, /* Add/subtract (w/wo carry) */
532 AND, OR, XOR, NOT, /* Boolean ops */
533 SHL, SHR, SAR, ROL, ROR, RCL, RCR, /* Shift/rotate (w/wo carry) */
534 NEG, /* Negate */
535 INC, DEC, /* Increment/decrement */
536 BSWAP, /* Big-endian <--> little-endian */
537 CC2VAL, /* Condition code --> 0 or 1 */
538 WIDEN, /* Signed or unsigned widening */
njn25e49d8e72002-09-23 09:36:25 +0000539
njnd5bb0a52002-09-27 10:24:48 +0000540 /* Conditional or unconditional jump */
541 JMP,
542
543 /* FPU ops */
544 FPU, /* Doesn't touch memory */
545 FPU_R, FPU_W, /* Reads/writes memory */
546
sewardj3d7c9c82003-03-26 21:08:13 +0000547 /* ------------ MMX ops ------------ */
sewardj8cec6ee2003-05-18 11:56:39 +0000548 /* In this and the SSE encoding, bytes at higher addresses are
549 held in bits [7:0] in these 16-bit words. I guess this means
550 it is a big-endian encoding. */
sewardj3d7c9c82003-03-26 21:08:13 +0000551
552 /* 1 byte, no memrefs, no iregdefs, copy exactly to the
553 output. Held in val1[7:0]. */
554 MMX1,
555
556 /* 2 bytes, no memrefs, no iregdefs, copy exactly to the
557 output. Held in val1[15:0]. */
558 MMX2,
559
560 /* 3 bytes, no memrefs, no iregdefs, copy exactly to the
561 output. Held in val1[15:0] and val2[7:0]. */
562 MMX3,
563
564 /* 2 bytes, reads/writes mem. Insns of the form
565 bbbbbbbb:mod mmxreg r/m.
566 Held in val1[15:0], and mod and rm are to be replaced
567 at codegen time by a reference to the Temp/RealReg holding
568 the address. Arg2 holds this Temp/Real Reg.
569 Transfer is always at size 8.
570 */
571 MMX2_MemRd,
572 MMX2_MemWr,
573
sewardj4fbe6e92003-06-15 21:54:34 +0000574 /* 2 bytes, reads/writes an integer ("E") register. Insns of the form
sewardj3d7c9c82003-03-26 21:08:13 +0000575 bbbbbbbb:11 mmxreg ireg.
576 Held in val1[15:0], and ireg is to be replaced
577 at codegen time by a reference to the relevant RealReg.
578 Transfer is always at size 4. Arg2 holds this Temp/Real Reg.
579 */
sewardj4fbe6e92003-06-15 21:54:34 +0000580 MMX2_ERegRd,
581 MMX2_ERegWr,
sewardj3d7c9c82003-03-26 21:08:13 +0000582
sewardj8cec6ee2003-05-18 11:56:39 +0000583 /* ------------ SSE/SSE2 ops ------------ */
584 /* In the following:
585
sewardjfebaa3b2003-05-25 01:07:34 +0000586 a digit N indicates the next N bytes are to be copied exactly
587 to the output.
sewardj8cec6ee2003-05-18 11:56:39 +0000588
589 'a' indicates a mod-xmmreg-rm byte, where the mod-rm part is
590 to be replaced at codegen time to a Temp/RealReg holding the
591 address.
592
sewardj4fbe6e92003-06-15 21:54:34 +0000593 'e' indicates a byte of the form '11 xmmreg ireg', where ireg
594 is read or written, and is to be replaced at codegen time by
595 a reference to the relevant RealReg. 'e' because it's the E
596 reg in Intel encoding parlance.
sewardj8cec6ee2003-05-18 11:56:39 +0000597
sewardj4fbe6e92003-06-15 21:54:34 +0000598 'g' indicates a byte of the form '11 ireg xmmreg', where ireg
599 is read or written, and is to be replaced at codegen time by
600 a reference to the relevant RealReg. 'g' because it's called
601 G in Intel parlance. */
sewardj8cec6ee2003-05-18 11:56:39 +0000602
603 /* 3 bytes, no memrefs, no iregdefs, copy exactly to the
604 output. Held in val1[15:0] and val2[7:0]. */
605 SSE3,
606
607 /* 3 bytes, reads/writes mem. Insns of the form
608 bbbbbbbb:bbbbbbbb:mod mmxreg r/m.
609 Held in val1[15:0] and val2[7:0], and mod and rm are to be
610 replaced at codegen time by a reference to the Temp/RealReg
611 holding the address. Arg3 holds this Temp/Real Reg.
sewardjfebaa3b2003-05-25 01:07:34 +0000612 Transfer is usually, but not always, at size 16. */
sewardj8cec6ee2003-05-18 11:56:39 +0000613 SSE2a_MemRd,
614 SSE2a_MemWr,
615
616 /* 4 bytes, no memrefs, no iregdefs, copy exactly to the
617 output. Held in val1[15:0] and val2[15:0]. */
618 SSE4,
619
620 /* 4 bytes, reads/writes mem. Insns of the form
621 bbbbbbbb:bbbbbbbb:bbbbbbbb:mod mmxreg r/m.
622 Held in val1[15:0] and val2[15:0], and mod and rm are to be
623 replaced at codegen time by a reference to the Temp/RealReg
624 holding the address. Arg3 holds this Temp/Real Reg.
sewardj9dd209f2003-06-18 23:30:52 +0000625 Transfer is at stated size. */
sewardj8cec6ee2003-05-18 11:56:39 +0000626 SSE3a_MemRd,
627 SSE3a_MemWr,
628
629 /* 4 bytes, reads/writes mem. Insns of the form
630 bbbbbbbb:bbbbbbbb:mod mmxreg r/m:bbbbbbbb
631 Held in val1[15:0] and val2[15:0], and mod and rm are to be
632 replaced at codegen time by a reference to the Temp/RealReg
633 holding the address. Arg3 holds this Temp/Real Reg.
sewardj9dd209f2003-06-18 23:30:52 +0000634 Transfer is at stated size. */
sewardj8cec6ee2003-05-18 11:56:39 +0000635 SSE2a1_MemRd,
sewardj9dd209f2003-06-18 23:30:52 +0000636#if 0
sewardj8cec6ee2003-05-18 11:56:39 +0000637 SSE2a1_MemWr,
sewardj6bc40552003-06-15 01:40:58 +0000638#endif
sewardj8cec6ee2003-05-18 11:56:39 +0000639 /* 4 bytes, writes an integer register. Insns of the form
sewardj4fbe6e92003-06-15 21:54:34 +0000640 bbbbbbbb:bbbbbbbb:bbbbbbbb:11 ireg bbb.
sewardj8cec6ee2003-05-18 11:56:39 +0000641 Held in val1[15:0] and val2[15:0], and ireg is to be replaced
642 at codegen time by a reference to the relevant RealReg.
643 Transfer is always at size 4. Arg3 holds this Temp/Real Reg.
644 */
645 SSE3g_RegWr,
646
sewardjb31b06d2003-06-13 00:26:02 +0000647 /* 5 bytes, writes an integer register. Insns of the form
648 bbbbbbbb:bbbbbbbb:bbbbbbbb: 11 ireg bbb :bbbbbbbb. Held in
649 val1[15:0] and val2[15:0] and lit32[7:0], and ireg is to be
650 replaced at codegen time by a reference to the relevant
651 RealReg. Transfer is always at size 4. Arg3 holds this
652 Temp/Real Reg.
653 */
654 SSE3g1_RegWr,
655
sewardj4fbe6e92003-06-15 21:54:34 +0000656 /* 4 bytes, reads an integer register. Insns of the form
657 bbbbbbbb:bbbbbbbb:bbbbbbbb:11 bbb ireg.
658 Held in val1[15:0] and val2[15:0], and ireg is to be replaced
659 at codegen time by a reference to the relevant RealReg.
660 Transfer is always at size 4. Arg3 holds this Temp/Real Reg.
661 */
662 SSE3e_RegRd,
sewardjabf8bf82003-06-15 22:28:05 +0000663 SSE3e_RegWr, /* variant that writes Ereg, not reads it */
sewardj4fbe6e92003-06-15 21:54:34 +0000664
sewardjb31b06d2003-06-13 00:26:02 +0000665 /* 5 bytes, reads an integer register. Insns of the form
666 bbbbbbbb:bbbbbbbb:bbbbbbbb: 11 bbb ireg :bbbbbbbb. Held in
667 val1[15:0] and val2[15:0] and lit32[7:0], and ireg is to be
668 replaced at codegen time by a reference to the relevant
669 RealReg. Transfer is always at size 4. Arg3 holds this
670 Temp/Real Reg.
671 */
sewardj4fbe6e92003-06-15 21:54:34 +0000672 SSE3e1_RegRd,
sewardj8cec6ee2003-05-18 11:56:39 +0000673
sewardj02af6bc2003-06-12 00:56:06 +0000674 /* 4 bytes, reads memory, writes an integer register, but is
675 nevertheless an SSE insn. The insn is of the form
676 bbbbbbbb:bbbbbbbb:bbbbbbbb:mod ireg rm where mod indicates
677 memory (ie is not 11b) and ireg is the int reg written. The
sewardje3891fa2003-06-15 03:13:48 +0000678 first 4 bytes are held in lit32[31:0] since there is
sewardj02af6bc2003-06-12 00:56:06 +0000679 insufficient space elsewhere. mod and rm are to be replaced
680 at codegen time by a reference to the Temp/RealReg holding
681 the address. Arg1 holds this Temp/RealReg. ireg is to be
682 replaced at codegen time by a reference to the relevant
683 RealReg in which the answer is to be written. Arg2 holds
684 this Temp/RealReg. Transfer to the destination reg is always
685 at size 4. However the memory read can be at sizes 4 or 8
sewardje3891fa2003-06-15 03:13:48 +0000686 and so this is what the sz field holds. Note that the 4th
687 byte of the instruction (the modrm byte) is redundant, but we
688 store it anyway so as to be consistent with all other SSE
689 uinstrs.
sewardj02af6bc2003-06-12 00:56:06 +0000690 */
691 SSE3ag_MemRd_RegWr,
sewardje3891fa2003-06-15 03:13:48 +0000692
sewardj8cec6ee2003-05-18 11:56:39 +0000693 /* 5 bytes, no memrefs, no iregdefs, copy exactly to the
694 output. Held in val1[15:0], val2[15:0] and val3[7:0]. */
695 SSE5,
sewardj6bc40552003-06-15 01:40:58 +0000696#if 0
sewardj8cec6ee2003-05-18 11:56:39 +0000697 /* 5 bytes, reads/writes mem. Insns of the form
698 bbbbbbbb:bbbbbbbb:bbbbbbbb:mod mmxreg r/m:bbbbbbbb
699 Held in val1[15:0], val2[15:0], lit32[7:0].
700 mod and rm are to be replaced at codegen time by a reference
701 to the Temp/RealReg holding the address. Arg3 holds this
702 Temp/Real Reg. Transfer is always at size 16. */
703 SSE3a1_MemRd,
704 SSE3a1_MemWr,
sewardj6bc40552003-06-15 01:40:58 +0000705#endif
sewardj3d7c9c82003-03-26 21:08:13 +0000706 /* ------------------------ */
707
njnd5bb0a52002-09-27 10:24:48 +0000708 /* Not strictly needed, but improve address calculation translations. */
njn25e49d8e72002-09-23 09:36:25 +0000709 LEA1, /* reg2 := const + reg1 */
710 LEA2, /* reg3 := const + reg1 + reg2 * 1,2,4 or 8 */
711
sewardj8cec6ee2003-05-18 11:56:39 +0000712 /* Hack for x86 REP insns. Jump to literal if TempReg/RealReg
713 is zero. */
njnd5bb0a52002-09-27 10:24:48 +0000714 JIFZ,
njn25e49d8e72002-09-23 09:36:25 +0000715
njnd5bb0a52002-09-27 10:24:48 +0000716 /* Advance the simulated %eip by some small (< 128) number. */
717 INCEIP,
njn25e49d8e72002-09-23 09:36:25 +0000718
sewardje1042472002-09-30 12:33:11 +0000719 /* Dealing with segment registers */
720 GETSEG, PUTSEG, /* simulated segment register <--> TempReg */
721 USESEG, /* (LDT/GDT index, virtual addr) --> linear addr */
722
njnd5bb0a52002-09-27 10:24:48 +0000723 /* Not for translating x86 calls -- only to call helpers */
724 CALLM_S, CALLM_E, /* Mark start/end of CALLM push/pop sequence */
725 PUSH, POP, CLEAR, /* Add/remove/zap args for helpers */
726 CALLM, /* Call assembly-code helper */
727
728 /* Not for translating x86 calls -- only to call C helper functions of
729 up to three arguments (or two if the functions has a return value).
730 Arguments and return value must be word-sized. More arguments can
731 be faked with global variables (eg. use VG_(set_global_var)()).
732
733 Seven possibilities: 'arg[123]' show where args go, 'ret' shows
734 where return value goes (if present).
njn25e49d8e72002-09-23 09:36:25 +0000735
736 CCALL(-, -, - ) void f(void)
737 CCALL(arg1, -, - ) void f(UInt arg1)
738 CCALL(arg1, arg2, - ) void f(UInt arg1, UInt arg2)
739 CCALL(arg1, arg2, arg3) void f(UInt arg1, UInt arg2, UInt arg3)
740 CCALL(-, -, ret ) UInt f(UInt)
741 CCALL(arg1, -, ret ) UInt f(UInt arg1)
njnd5bb0a52002-09-27 10:24:48 +0000742 CCALL(arg1, arg2, ret ) UInt f(UInt arg1, UInt arg2) */
njn25e49d8e72002-09-23 09:36:25 +0000743 CCALL,
744
njnd5bb0a52002-09-27 10:24:48 +0000745 /* This opcode makes it easy for skins that extend UCode to do this to
746 avoid opcode overlap:
njn25e49d8e72002-09-23 09:36:25 +0000747
njnd5bb0a52002-09-27 10:24:48 +0000748 enum { EU_OP1 = DUMMY_FINAL_UOPCODE + 1, ... }
njn25e49d8e72002-09-23 09:36:25 +0000749
750 WARNING: Do not add new opcodes after this one! They can be added
751 before, though. */
752 DUMMY_FINAL_UOPCODE
753 }
754 Opcode;
755
756
njnd5bb0a52002-09-27 10:24:48 +0000757/* Condition codes, using the Intel encoding. CondAlways is an extra. */
njn25e49d8e72002-09-23 09:36:25 +0000758typedef
759 enum {
760 CondO = 0, /* overflow */
761 CondNO = 1, /* no overflow */
762 CondB = 2, /* below */
763 CondNB = 3, /* not below */
764 CondZ = 4, /* zero */
765 CondNZ = 5, /* not zero */
766 CondBE = 6, /* below or equal */
767 CondNBE = 7, /* not below or equal */
768 CondS = 8, /* negative */
sewardje1042472002-09-30 12:33:11 +0000769 CondNS = 9, /* not negative */
njn25e49d8e72002-09-23 09:36:25 +0000770 CondP = 10, /* parity even */
771 CondNP = 11, /* not parity even */
772 CondL = 12, /* jump less */
773 CondNL = 13, /* not less */
774 CondLE = 14, /* less or equal */
775 CondNLE = 15, /* not less or equal */
776 CondAlways = 16 /* Jump always */
777 }
778 Condcode;
779
780
781/* Descriptions of additional properties of *unconditional* jumps. */
782typedef
783 enum {
784 JmpBoring=0, /* boring unconditional jump */
785 JmpCall=1, /* jump due to an x86 call insn */
786 JmpRet=2, /* jump due to an x86 ret insn */
787 JmpSyscall=3, /* do a system call, then jump */
788 JmpClientReq=4 /* do a client request, then jump */
789 }
790 JmpKind;
791
792
793/* Flags. User-level code can only read/write O(verflow), S(ign),
794 Z(ero), A(ux-carry), C(arry), P(arity), and may also write
795 D(irection). That's a total of 7 flags. A FlagSet is a bitset,
796 thusly:
797 76543210
798 DOSZACP
799 and bit 7 must always be zero since it is unused.
sewardj2370f3b2002-11-30 15:01:01 +0000800
801 Note: these Flag? values are **not** the positions in the actual
802 %eflags register. */
803
njn25e49d8e72002-09-23 09:36:25 +0000804typedef UChar FlagSet;
805
806#define FlagD (1<<6)
807#define FlagO (1<<5)
808#define FlagS (1<<4)
809#define FlagZ (1<<3)
810#define FlagA (1<<2)
811#define FlagC (1<<1)
812#define FlagP (1<<0)
813
814#define FlagsOSZACP (FlagO | FlagS | FlagZ | FlagA | FlagC | FlagP)
815#define FlagsOSZAP (FlagO | FlagS | FlagZ | FlagA | FlagP)
816#define FlagsOSZCP (FlagO | FlagS | FlagZ | FlagC | FlagP)
817#define FlagsOSACP (FlagO | FlagS | FlagA | FlagC | FlagP)
818#define FlagsSZACP ( FlagS | FlagZ | FlagA | FlagC | FlagP)
819#define FlagsSZAP ( FlagS | FlagZ | FlagA | FlagP)
820#define FlagsZCP ( FlagZ | FlagC | FlagP)
821#define FlagsOC (FlagO | FlagC )
822#define FlagsAC ( FlagA | FlagC )
823
824#define FlagsALL (FlagsOSZACP | FlagD)
825#define FlagsEmpty (FlagSet)0
826
827
sewardj2370f3b2002-11-30 15:01:01 +0000828/* flag positions in eflags */
829#define EFlagC (1 << 0) /* carry */
830#define EFlagP (1 << 2) /* parity */
sewardjfa492d42002-12-08 18:20:01 +0000831#define EFlagA (1 << 4) /* aux carry */
sewardj2370f3b2002-11-30 15:01:01 +0000832#define EFlagZ (1 << 6) /* zero */
833#define EFlagS (1 << 7) /* sign */
sewardjfa492d42002-12-08 18:20:01 +0000834#define EFlagD (1 << 10) /* direction */
sewardj2370f3b2002-11-30 15:01:01 +0000835#define EFlagO (1 << 11) /* overflow */
836
njn25e49d8e72002-09-23 09:36:25 +0000837/* Liveness of general purpose registers, useful for code generation.
838 Reg rank order 0..N-1 corresponds to bits 0..N-1, ie. first
839 reg's liveness in bit 0, last reg's in bit N-1. Note that
840 these rankings don't match the Intel register ordering. */
841typedef UInt RRegSet;
842
843#define ALL_RREGS_DEAD 0 /* 0000...00b */
njne7c258c2002-10-03 08:57:01 +0000844#define ALL_RREGS_LIVE ((1 << VG_MAX_REALREGS)-1) /* 0011...11b */
njn25e49d8e72002-09-23 09:36:25 +0000845#define UNIT_RREGSET(rank) (1 << (rank))
846
847#define IS_RREG_LIVE(rank,rregs_live) (rregs_live & UNIT_RREGSET(rank))
848#define SET_RREG_LIVENESS(rank,rregs_live,b) \
849 do { RRegSet unit = UNIT_RREGSET(rank); \
850 if (b) rregs_live |= unit; \
851 else rregs_live &= ~unit; \
852 } while(0)
853
854
855/* A Micro (u)-instruction. */
856typedef
857 struct {
858 /* word 1 */
859 UInt lit32; /* 32-bit literal */
860
861 /* word 2 */
862 UShort val1; /* first operand */
863 UShort val2; /* second operand */
864
865 /* word 3 */
866 UShort val3; /* third operand */
867 UChar opcode; /* opcode */
868 UChar size; /* data transfer size */
869
870 /* word 4 */
871 FlagSet flags_r; /* :: FlagSet */
872 FlagSet flags_w; /* :: FlagSet */
873 UChar tag1:4; /* first operand tag */
874 UChar tag2:4; /* second operand tag */
875 UChar tag3:4; /* third operand tag */
876 UChar extra4b:4; /* Spare field, used by WIDEN for src
877 -size, and by LEA2 for scale (1,2,4 or 8),
878 and by JMPs for original x86 instr size */
879
880 /* word 5 */
881 UChar cond; /* condition, for jumps */
882 Bool signed_widen:1; /* signed or unsigned WIDEN ? */
883 JmpKind jmpkind:3; /* additional properties of unconditional JMP */
884
885 /* Additional properties for UInstrs that call C functions:
886 - CCALL
887 - PUT (when %ESP is the target)
888 - possibly skin-specific UInstrs
889 */
890 UChar argc:2; /* Number of args, max 3 */
891 UChar regparms_n:2; /* Number of args passed in registers */
892 Bool has_ret_val:1; /* Function has return value? */
893
894 /* RealReg liveness; only sensical after reg alloc and liveness
895 analysis done. This info is a little bit arch-specific --
896 VG_MAX_REALREGS can vary on different architectures. Note that
897 to use this information requires converting between register ranks
njn4ba5a792002-09-30 10:23:54 +0000898 and the Intel register numbers, using VG_(realreg_to_rank)()
899 and/or VG_(rank_to_realreg)() */
njn25e49d8e72002-09-23 09:36:25 +0000900 RRegSet regs_live_after:VG_MAX_REALREGS;
901 }
902 UInstr;
903
904
njn25e49d8e72002-09-23 09:36:25 +0000905typedef
njn810086f2002-11-14 12:42:47 +0000906 struct _UCodeBlock
njn25e49d8e72002-09-23 09:36:25 +0000907 UCodeBlock;
908
njn810086f2002-11-14 12:42:47 +0000909extern Int VG_(get_num_instrs) (UCodeBlock* cb);
910extern Int VG_(get_num_temps) (UCodeBlock* cb);
njn25e49d8e72002-09-23 09:36:25 +0000911
njn810086f2002-11-14 12:42:47 +0000912extern UInstr* VG_(get_instr) (UCodeBlock* cb, Int i);
913extern UInstr* VG_(get_last_instr) (UCodeBlock* cb);
914
njn211b6ad2003-02-03 12:33:31 +0000915
njn25e49d8e72002-09-23 09:36:25 +0000916/*====================================================================*/
917/*=== Instrumenting UCode ===*/
918/*====================================================================*/
919
njnf4ce3d32003-02-10 10:17:26 +0000920/* Maximum number of registers read or written by a single UInstruction. */
921#define VG_MAX_REGS_USED 3
njn25e49d8e72002-09-23 09:36:25 +0000922
njnf4ce3d32003-02-10 10:17:26 +0000923/* Find what this instruction does to its regs, useful for
924 analysis/optimisation passes. `tag' indicates whether we're considering
925 TempRegs (pre-reg-alloc) or RealRegs (post-reg-alloc). `regs' is filled
926 with the affected register numbers, `isWrites' parallels it and indicates
927 if the reg is read or written. If a reg is read and written, it will
928 appear twice in `regs'. `regs' and `isWrites' must be able to fit
929 VG_MAX_REGS_USED elements. */
njn810086f2002-11-14 12:42:47 +0000930extern Int VG_(get_reg_usage) ( UInstr* u, Tag tag, Int* regs, Bool* isWrites );
njn25e49d8e72002-09-23 09:36:25 +0000931
932
njnd5bb0a52002-09-27 10:24:48 +0000933/* Used to register helper functions to be called from generated code. A
934 limited number of compact helpers can be registered; the code generated
935 to call them is slightly shorter -- so register the mostly frequently
936 called helpers as compact. */
njn25e49d8e72002-09-23 09:36:25 +0000937extern void VG_(register_compact_helper) ( Addr a );
938extern void VG_(register_noncompact_helper) ( Addr a );
939
940
941/* ------------------------------------------------------------------ */
942/* Virtual register allocation */
943
944/* Get a new virtual register */
njn4ba5a792002-09-30 10:23:54 +0000945extern Int VG_(get_new_temp) ( UCodeBlock* cb );
njn25e49d8e72002-09-23 09:36:25 +0000946
947/* Get a new virtual shadow register */
njn4ba5a792002-09-30 10:23:54 +0000948extern Int VG_(get_new_shadow) ( UCodeBlock* cb );
njn25e49d8e72002-09-23 09:36:25 +0000949
950/* Get a virtual register's corresponding virtual shadow register */
951#define SHADOW(tempreg) ((tempreg)+1)
952
953
954/* ------------------------------------------------------------------ */
955/* Low-level UInstr builders */
njn4ba5a792002-09-30 10:23:54 +0000956extern void VG_(new_NOP) ( UInstr* u );
957extern void VG_(new_UInstr0) ( UCodeBlock* cb, Opcode opcode, Int sz );
958extern void VG_(new_UInstr1) ( UCodeBlock* cb, Opcode opcode, Int sz,
njn25e49d8e72002-09-23 09:36:25 +0000959 Tag tag1, UInt val1 );
njn4ba5a792002-09-30 10:23:54 +0000960extern void VG_(new_UInstr2) ( UCodeBlock* cb, Opcode opcode, Int sz,
njn25e49d8e72002-09-23 09:36:25 +0000961 Tag tag1, UInt val1,
962 Tag tag2, UInt val2 );
njn4ba5a792002-09-30 10:23:54 +0000963extern void VG_(new_UInstr3) ( UCodeBlock* cb, Opcode opcode, Int sz,
njn25e49d8e72002-09-23 09:36:25 +0000964 Tag tag1, UInt val1,
965 Tag tag2, UInt val2,
966 Tag tag3, UInt val3 );
njn25e49d8e72002-09-23 09:36:25 +0000967
njn810086f2002-11-14 12:42:47 +0000968/* Set read/write/undefined flags. Undefined flags are treaten as written,
969 but it's worth keeping them logically distinct. */
970extern void VG_(set_flag_fields) ( UCodeBlock* cb, FlagSet fr, FlagSet fw,
971 FlagSet fu);
njn4ba5a792002-09-30 10:23:54 +0000972extern void VG_(set_lit_field) ( UCodeBlock* cb, UInt lit32 );
973extern void VG_(set_ccall_fields) ( UCodeBlock* cb, Addr fn, UChar argc,
974 UChar regparms_n, Bool has_ret_val );
njn810086f2002-11-14 12:42:47 +0000975extern void VG_(set_cond_field) ( UCodeBlock* cb, Condcode code );
njn25e49d8e72002-09-23 09:36:25 +0000976
njn4ba5a792002-09-30 10:23:54 +0000977extern void VG_(copy_UInstr) ( UCodeBlock* cb, UInstr* instr );
978
979extern Bool VG_(any_flag_use)( UInstr* u );
njn25e49d8e72002-09-23 09:36:25 +0000980
njnac6c1762002-10-04 14:34:15 +0000981/* Macro versions of the above; just shorter to type. */
982#define uInstr0 VG_(new_UInstr0)
983#define uInstr1 VG_(new_UInstr1)
984#define uInstr2 VG_(new_UInstr2)
985#define uInstr3 VG_(new_UInstr3)
986#define uLiteral VG_(set_lit_field)
987#define uCCall VG_(set_ccall_fields)
njn810086f2002-11-14 12:42:47 +0000988#define uCond VG_(set_cond_field)
989#define uFlagsRWU VG_(set_flag_fields)
njnac6c1762002-10-04 14:34:15 +0000990#define newTemp VG_(get_new_temp)
991#define newShadow VG_(get_new_shadow)
992
njn25e49d8e72002-09-23 09:36:25 +0000993/* Refer to `the last instruction stuffed in' (can be lvalue). */
994#define LAST_UINSTR(cb) (cb)->instrs[(cb)->used-1]
995
996
997/* ------------------------------------------------------------------ */
998/* Higher-level UInstr sequence builders */
njn4ba5a792002-09-30 10:23:54 +0000999extern void VG_(call_helper_0_0) ( UCodeBlock* cb, Addr f);
1000extern void VG_(call_helper_1_0) ( UCodeBlock* cb, Addr f, UInt arg1,
1001 UInt regparms_n);
1002extern void VG_(call_helper_2_0) ( UCodeBlock* cb, Addr f, UInt arg1, UInt arg2,
1003 UInt regparms_n);
njn25e49d8e72002-09-23 09:36:25 +00001004
1005/* One way around the 3-arg C function limit is to pass args via global
njn6fefa1b2003-02-24 10:32:51 +00001006 * variables... ugly, but it works. This one puts a literal in there. */
njn4ba5a792002-09-30 10:23:54 +00001007extern void VG_(set_global_var) ( UCodeBlock* cb, Addr globvar_ptr, UInt val);
njn25e49d8e72002-09-23 09:36:25 +00001008
njn6fefa1b2003-02-24 10:32:51 +00001009/* This one puts the contents of a TempReg in the global variable. */
1010extern void VG_(set_global_var_tempreg) ( UCodeBlock* cb, Addr globvar_ptr,
1011 UInt t_val);
1012
njn25e49d8e72002-09-23 09:36:25 +00001013/* ------------------------------------------------------------------ */
njnd5bb0a52002-09-27 10:24:48 +00001014/* Allocating/freeing basic blocks of UCode */
njn810086f2002-11-14 12:42:47 +00001015extern UCodeBlock* VG_(setup_UCodeBlock) ( UCodeBlock* cb );
njn4ba5a792002-09-30 10:23:54 +00001016extern void VG_(free_UCodeBlock) ( UCodeBlock* cb );
njnd5bb0a52002-09-27 10:24:48 +00001017
1018/* ------------------------------------------------------------------ */
1019/* UCode pretty/ugly printing. Probably only useful to call from a skin
njn25e49d8e72002-09-23 09:36:25 +00001020 if VG_(needs).extended_UCode == True. */
1021
1022/* When True, all generated code is/should be printed. */
1023extern Bool VG_(print_codegen);
1024
njn4ba5a792002-09-30 10:23:54 +00001025/* Pretty/ugly printing functions */
1026extern void VG_(pp_UCodeBlock) ( UCodeBlock* cb, Char* title );
1027extern void VG_(pp_UInstr) ( Int instrNo, UInstr* u );
1028extern void VG_(pp_UInstr_regs) ( Int instrNo, UInstr* u );
1029extern void VG_(up_UInstr) ( Int instrNo, UInstr* u );
1030extern Char* VG_(name_UOpcode) ( Bool upper, Opcode opc );
njn563f96f2003-02-03 11:17:46 +00001031extern Char* VG_(name_UCondcode) ( Condcode cond );
njn4ba5a792002-09-30 10:23:54 +00001032extern void VG_(pp_UOperand) ( UInstr* u, Int operandNo,
1033 Int sz, Bool parens );
njn25e49d8e72002-09-23 09:36:25 +00001034
njnb93d1782003-02-03 12:03:22 +00001035/* ------------------------------------------------------------------ */
njnf4ce3d32003-02-10 10:17:26 +00001036/* Accessing archregs and their shadows */
1037extern UInt VG_(get_archreg) ( UInt archreg );
1038extern UInt VG_(get_thread_archreg) ( ThreadId tid, UInt archreg );
1039
njnb93d1782003-02-03 12:03:22 +00001040extern UInt VG_(get_shadow_archreg) ( UInt archreg );
1041extern void VG_(set_shadow_archreg) ( UInt archreg, UInt val );
njnd3040452003-05-19 15:04:06 +00001042extern void VG_(set_shadow_eflags) ( UInt val );
njnb93d1782003-02-03 12:03:22 +00001043extern Addr VG_(shadow_archreg_address) ( UInt archreg );
njn25e49d8e72002-09-23 09:36:25 +00001044
njnf4ce3d32003-02-10 10:17:26 +00001045extern UInt VG_(get_thread_shadow_archreg) ( ThreadId tid, UInt archreg );
1046extern void VG_(set_thread_shadow_archreg) ( ThreadId tid, UInt archreg,
1047 UInt val );
njn211b6ad2003-02-03 12:33:31 +00001048
1049/* ------------------------------------------------------------------ */
1050/* Offsets of addresses of helper functions. A "helper" function is one
1051 which is called from generated code via CALLM. */
1052
1053extern Int VGOFF_(helper_idiv_64_32);
1054extern Int VGOFF_(helper_div_64_32);
1055extern Int VGOFF_(helper_idiv_32_16);
1056extern Int VGOFF_(helper_div_32_16);
1057extern Int VGOFF_(helper_idiv_16_8);
1058extern Int VGOFF_(helper_div_16_8);
1059
1060extern Int VGOFF_(helper_imul_32_64);
1061extern Int VGOFF_(helper_mul_32_64);
1062extern Int VGOFF_(helper_imul_16_32);
1063extern Int VGOFF_(helper_mul_16_32);
1064extern Int VGOFF_(helper_imul_8_16);
1065extern Int VGOFF_(helper_mul_8_16);
1066
1067extern Int VGOFF_(helper_CLD);
1068extern Int VGOFF_(helper_STD);
1069extern Int VGOFF_(helper_get_dirflag);
1070
1071extern Int VGOFF_(helper_CLC);
1072extern Int VGOFF_(helper_STC);
1073
1074extern Int VGOFF_(helper_shldl);
1075extern Int VGOFF_(helper_shldw);
1076extern Int VGOFF_(helper_shrdl);
1077extern Int VGOFF_(helper_shrdw);
1078
1079extern Int VGOFF_(helper_RDTSC);
1080extern Int VGOFF_(helper_CPUID);
1081
1082extern Int VGOFF_(helper_bsf);
1083extern Int VGOFF_(helper_bsr);
1084
1085extern Int VGOFF_(helper_fstsw_AX);
1086extern Int VGOFF_(helper_SAHF);
njnd6251f12003-06-03 13:38:51 +00001087extern Int VGOFF_(helper_LAHF);
njn211b6ad2003-02-03 12:33:31 +00001088extern Int VGOFF_(helper_DAS);
1089extern Int VGOFF_(helper_DAA);
1090
1091
njn25e49d8e72002-09-23 09:36:25 +00001092/*====================================================================*/
njnd5bb0a52002-09-27 10:24:48 +00001093/*=== Generating x86 code from UCode ===*/
njn25e49d8e72002-09-23 09:36:25 +00001094/*====================================================================*/
1095
njnd5bb0a52002-09-27 10:24:48 +00001096/* All this only necessary for skins with VG_(needs).extends_UCode == True. */
njn25e49d8e72002-09-23 09:36:25 +00001097
sewardje1042472002-09-30 12:33:11 +00001098/* This is the Intel register encoding -- integer regs. */
njn25e49d8e72002-09-23 09:36:25 +00001099#define R_EAX 0
1100#define R_ECX 1
1101#define R_EDX 2
1102#define R_EBX 3
1103#define R_ESP 4
1104#define R_EBP 5
1105#define R_ESI 6
1106#define R_EDI 7
1107
1108#define R_AL (0+R_EAX)
1109#define R_CL (0+R_ECX)
1110#define R_DL (0+R_EDX)
1111#define R_BL (0+R_EBX)
1112#define R_AH (4+R_EAX)
1113#define R_CH (4+R_ECX)
1114#define R_DH (4+R_EDX)
1115#define R_BH (4+R_EBX)
1116
sewardje1042472002-09-30 12:33:11 +00001117/* This is the Intel register encoding -- segment regs. */
1118#define R_ES 0
1119#define R_CS 1
1120#define R_SS 2
1121#define R_DS 3
1122#define R_FS 4
1123#define R_GS 5
1124
njn25e49d8e72002-09-23 09:36:25 +00001125/* For pretty printing x86 code */
sewardj3d7c9c82003-03-26 21:08:13 +00001126extern Char* VG_(name_of_mmx_gran) ( UChar gran );
1127extern Char* VG_(name_of_mmx_reg) ( Int mmxreg );
sewardje1042472002-09-30 12:33:11 +00001128extern Char* VG_(name_of_seg_reg) ( Int sreg );
njn4ba5a792002-09-30 10:23:54 +00001129extern Char* VG_(name_of_int_reg) ( Int size, Int reg );
1130extern Char VG_(name_of_int_size) ( Int size );
njn25e49d8e72002-09-23 09:36:25 +00001131
njnac6c1762002-10-04 14:34:15 +00001132/* Shorter macros for convenience */
sewardj3d7c9c82003-03-26 21:08:13 +00001133#define nameIReg VG_(name_of_int_reg)
1134#define nameISize VG_(name_of_int_size)
1135#define nameSReg VG_(name_of_seg_reg)
1136#define nameMMXReg VG_(name_of_mmx_reg)
1137#define nameMMXGran VG_(name_of_mmx_gran)
sewardjfebaa3b2003-05-25 01:07:34 +00001138#define nameXMMReg VG_(name_of_xmm_reg)
njnac6c1762002-10-04 14:34:15 +00001139
njn25e49d8e72002-09-23 09:36:25 +00001140/* Randomly useful things */
1141extern UInt VG_(extend_s_8to32) ( UInt x );
1142
1143/* Code emitters */
njn4ba5a792002-09-30 10:23:54 +00001144extern void VG_(emitB) ( UInt b );
1145extern void VG_(emitW) ( UInt w );
1146extern void VG_(emitL) ( UInt l );
sewardjfa492d42002-12-08 18:20:01 +00001147extern void VG_(new_emit) ( Bool upd_cc, FlagSet uses_flags, FlagSet sets_flags );
njn25e49d8e72002-09-23 09:36:25 +00001148
1149/* Finding offsets */
njn4ba5a792002-09-30 10:23:54 +00001150extern Int VG_(helper_offset) ( Addr a );
1151extern Int VG_(shadow_reg_offset) ( Int arch );
1152extern Int VG_(shadow_flags_offset) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001153
njnd5bb0a52002-09-27 10:24:48 +00001154/* Convert reg ranks <-> Intel register ordering, for using register
1155 liveness information. */
njn4ba5a792002-09-30 10:23:54 +00001156extern Int VG_(realreg_to_rank) ( Int realreg );
1157extern Int VG_(rank_to_realreg) ( Int rank );
njn25e49d8e72002-09-23 09:36:25 +00001158
njnd5bb0a52002-09-27 10:24:48 +00001159/* Call a subroutine. Does no argument passing, stack manipulations, etc. */
sewardjfa492d42002-12-08 18:20:01 +00001160extern void VG_(synth_call) ( Bool ensure_shortform, Int word_offset,
1161 Bool upd_cc, FlagSet use_flags, FlagSet set_flags );
njn25e49d8e72002-09-23 09:36:25 +00001162
njnd5bb0a52002-09-27 10:24:48 +00001163/* For calling C functions -- saves caller save regs, pushes args, calls,
1164 clears the stack, restores caller save regs. `fn' must be registered in
1165 the baseBlock first. Acceptable tags are RealReg and Literal. Optimises
1166 things, eg. by not preserving non-live caller-save registers.
njn25e49d8e72002-09-23 09:36:25 +00001167
njnd5bb0a52002-09-27 10:24:48 +00001168 WARNING: a UInstr should *not* be translated with synth_ccall() followed
1169 by some other x86 assembly code; this will invalidate the results of
1170 vg_realreg_liveness_analysis() and everything will fall over. */
njn4ba5a792002-09-30 10:23:54 +00001171extern void VG_(synth_ccall) ( Addr fn, Int argc, Int regparms_n, UInt argv[],
1172 Tag tagv[], Int ret_reg,
1173 RRegSet regs_live_before,
1174 RRegSet regs_live_after );
njn25e49d8e72002-09-23 09:36:25 +00001175
1176/* Addressing modes */
njn4ba5a792002-09-30 10:23:54 +00001177extern void VG_(emit_amode_offregmem_reg)( Int off, Int regmem, Int reg );
1178extern void VG_(emit_amode_ereg_greg) ( Int e_reg, Int g_reg );
njn25e49d8e72002-09-23 09:36:25 +00001179
1180/* v-size (4, or 2 with OSO) insn emitters */
njn4ba5a792002-09-30 10:23:54 +00001181extern void VG_(emit_movv_offregmem_reg) ( Int sz, Int off, Int areg, Int reg );
1182extern void VG_(emit_movv_reg_offregmem) ( Int sz, Int reg, Int off, Int areg );
1183extern void VG_(emit_movv_reg_reg) ( Int sz, Int reg1, Int reg2 );
sewardjfa492d42002-12-08 18:20:01 +00001184extern void VG_(emit_nonshiftopv_lit_reg)( Bool upd_cc, Int sz, Opcode opc, UInt lit,
njn4ba5a792002-09-30 10:23:54 +00001185 Int reg );
sewardjfa492d42002-12-08 18:20:01 +00001186extern void VG_(emit_shiftopv_lit_reg) ( Bool upd_cc, Int sz, Opcode opc, UInt lit,
njn4ba5a792002-09-30 10:23:54 +00001187 Int reg );
sewardjfa492d42002-12-08 18:20:01 +00001188extern void VG_(emit_nonshiftopv_reg_reg)( Bool upd_cc, Int sz, Opcode opc,
njn4ba5a792002-09-30 10:23:54 +00001189 Int reg1, Int reg2 );
1190extern void VG_(emit_movv_lit_reg) ( Int sz, UInt lit, Int reg );
sewardjfa492d42002-12-08 18:20:01 +00001191extern void VG_(emit_unaryopv_reg) ( Bool upd_cc, Int sz, Opcode opc, Int reg );
njn4ba5a792002-09-30 10:23:54 +00001192extern void VG_(emit_pushv_reg) ( Int sz, Int reg );
1193extern void VG_(emit_popv_reg) ( Int sz, Int reg );
njn25e49d8e72002-09-23 09:36:25 +00001194
njn4ba5a792002-09-30 10:23:54 +00001195extern void VG_(emit_pushl_lit32) ( UInt int32 );
1196extern void VG_(emit_pushl_lit8) ( Int lit8 );
sewardjfa492d42002-12-08 18:20:01 +00001197extern void VG_(emit_cmpl_zero_reg) ( Bool upd_cc, Int reg );
njn4ba5a792002-09-30 10:23:54 +00001198extern void VG_(emit_swapl_reg_EAX) ( Int reg );
1199extern void VG_(emit_movv_lit_offregmem) ( Int sz, UInt lit, Int off,
1200 Int memreg );
njn25e49d8e72002-09-23 09:36:25 +00001201
1202/* b-size (1 byte) instruction emitters */
njn4ba5a792002-09-30 10:23:54 +00001203extern void VG_(emit_movb_lit_offregmem) ( UInt lit, Int off, Int memreg );
1204extern void VG_(emit_movb_reg_offregmem) ( Int reg, Int off, Int areg );
sewardjfa492d42002-12-08 18:20:01 +00001205extern void VG_(emit_unaryopb_reg) ( Bool upd_cc, Opcode opc, Int reg );
1206extern void VG_(emit_testb_lit_reg) ( Bool upd_cc, UInt lit, Int reg );
njn25e49d8e72002-09-23 09:36:25 +00001207
1208/* zero-extended load emitters */
njn4ba5a792002-09-30 10:23:54 +00001209extern void VG_(emit_movzbl_offregmem_reg) ( Int off, Int regmem, Int reg );
1210extern void VG_(emit_movzwl_offregmem_reg) ( Int off, Int areg, Int reg );
njn25e49d8e72002-09-23 09:36:25 +00001211
1212/* misc instruction emitters */
njn4ba5a792002-09-30 10:23:54 +00001213extern void VG_(emit_call_reg) ( Int reg );
1214extern void VG_(emit_add_lit_to_esp) ( Int lit );
njn4ba5a792002-09-30 10:23:54 +00001215extern void VG_(emit_pushal) ( void );
1216extern void VG_(emit_popal) ( void );
1217extern void VG_(emit_AMD_prefetch_reg) ( Int reg );
njn25e49d8e72002-09-23 09:36:25 +00001218
sewardja2113f92002-12-12 23:42:48 +00001219/* jump emitters */
1220extern void VG_(init_target) ( Int *tgt );
1221
1222extern void VG_(target_back) ( Int *tgt );
1223extern void VG_(target_forward) ( Int *tgt );
1224extern void VG_(emit_target_delta) ( Int *tgt );
1225
1226extern void VG_(emit_jcondshort_delta) ( Bool simd_cc, Condcode cond, Int delta );
1227extern void VG_(emit_jcondshort_target)( Bool simd_cc, Condcode cond, Int *tgt );
1228
njn25e49d8e72002-09-23 09:36:25 +00001229
1230/*====================================================================*/
1231/*=== Execution contexts ===*/
1232/*====================================================================*/
1233
1234/* Generic resolution type used in a few different ways, such as deciding
1235 how closely to compare two errors for equality. */
1236typedef
1237 enum { Vg_LowRes, Vg_MedRes, Vg_HighRes }
1238 VgRes;
1239
1240typedef
1241 struct _ExeContext
1242 ExeContext;
1243
njnd5bb0a52002-09-27 10:24:48 +00001244/* Compare two ExeContexts. Number of callers considered depends on `res':
1245 Vg_LowRes: 2
1246 Vg_MedRes: 4
1247 Vg_HighRes: all */
njn25e49d8e72002-09-23 09:36:25 +00001248extern Bool VG_(eq_ExeContext) ( VgRes res,
1249 ExeContext* e1, ExeContext* e2 );
1250
1251/* Print an ExeContext. */
1252extern void VG_(pp_ExeContext) ( ExeContext* );
1253
1254/* Take a snapshot of the client's stack. Search our collection of
1255 ExeContexts to see if we already have it, and if not, allocate a
njn7b456f52003-05-19 11:16:50 +00001256 new one. Either way, return a pointer to the context.
1257
njn72718642003-07-24 08:45:32 +00001258 If called from generated code, use VG_(get_current_tid)() to get the
1259 current ThreadId. If called from non-generated code, the current
1260 ThreadId should be passed in by the core.
njn7b456f52003-05-19 11:16:50 +00001261*/
njn72718642003-07-24 08:45:32 +00001262extern ExeContext* VG_(get_ExeContext) ( ThreadId tid );
njn25e49d8e72002-09-23 09:36:25 +00001263
sewardj499e3de2002-11-13 22:22:25 +00001264/* Just grab the client's EIP, as a much smaller and cheaper
njn72718642003-07-24 08:45:32 +00001265 indication of where they are. Use is basically same as for
1266 VG_(get_ExeContext)() above.
1267*/
1268extern Addr VG_(get_EIP)( ThreadId tid );
njn25e49d8e72002-09-23 09:36:25 +00001269
njn211b6ad2003-02-03 12:33:31 +00001270
njn25e49d8e72002-09-23 09:36:25 +00001271/*====================================================================*/
1272/*=== Error reporting ===*/
1273/*====================================================================*/
1274
1275/* ------------------------------------------------------------------ */
1276/* Suppressions describe errors which we want to suppress, ie, not
1277 show the user, usually because it is caused by a problem in a library
1278 which we can't fix, replace or work around. Suppressions are read from
njnd5bb0a52002-09-27 10:24:48 +00001279 a file at startup time. This gives flexibility so that new
njn25e49d8e72002-09-23 09:36:25 +00001280 suppressions can be added to the file as and when needed.
1281*/
1282
1283typedef
1284 Int /* Do not make this unsigned! */
1285 SuppKind;
1286
njn810086f2002-11-14 12:42:47 +00001287/* The skin-relevant parts of a suppression are:
1288 kind: what kind of suppression; must be in the range (0..)
1289 string: use is optional. NULL by default.
1290 extra: use is optional. NULL by default. void* so it's extensible.
njn25e49d8e72002-09-23 09:36:25 +00001291*/
1292typedef
njn810086f2002-11-14 12:42:47 +00001293 struct _Supp
1294 Supp;
1295
1296/* Useful in SK_(error_matches_suppression)() */
1297SuppKind VG_(get_supp_kind) ( Supp* su );
1298Char* VG_(get_supp_string) ( Supp* su );
1299void* VG_(get_supp_extra) ( Supp* su );
1300
1301/* Must be used in VG_(recognised_suppression)() */
1302void VG_(set_supp_kind) ( Supp* su, SuppKind suppkind );
1303/* May be used in VG_(read_extra_suppression_info)() */
1304void VG_(set_supp_string) ( Supp* su, Char* string );
1305void VG_(set_supp_extra) ( Supp* su, void* extra );
njn25e49d8e72002-09-23 09:36:25 +00001306
1307
1308/* ------------------------------------------------------------------ */
1309/* Error records contain enough info to generate an error report. The idea
1310 is that (typically) the same few points in the program generate thousands
njnd5bb0a52002-09-27 10:24:48 +00001311 of errors, and we don't want to spew out a fresh error message for each
1312 one. Instead, we use these structures to common up duplicates.
njn25e49d8e72002-09-23 09:36:25 +00001313*/
1314
1315typedef
1316 Int /* Do not make this unsigned! */
1317 ErrorKind;
1318
njn810086f2002-11-14 12:42:47 +00001319/* The skin-relevant parts of an Error are:
1320 kind: what kind of error; must be in the range (0..)
1321 addr: use is optional. 0 by default.
1322 string: use is optional. NULL by default.
1323 extra: use is optional. NULL by default. void* so it's extensible.
njn25e49d8e72002-09-23 09:36:25 +00001324*/
1325typedef
njn810086f2002-11-14 12:42:47 +00001326 struct _Error
1327 Error;
njn25e49d8e72002-09-23 09:36:25 +00001328
njn810086f2002-11-14 12:42:47 +00001329/* Useful in SK_(error_matches_suppression)(), SK_(pp_SkinError)(), etc */
njnb877d492003-01-28 20:40:57 +00001330ExeContext* VG_(get_error_where) ( Error* err );
1331SuppKind VG_(get_error_kind) ( Error* err );
1332Addr VG_(get_error_address) ( Error* err );
1333Char* VG_(get_error_string) ( Error* err );
1334void* VG_(get_error_extra) ( Error* err );
njn25e49d8e72002-09-23 09:36:25 +00001335
njnd5bb0a52002-09-27 10:24:48 +00001336/* Call this when an error occurs. It will be recorded if it hasn't been
njn25e49d8e72002-09-23 09:36:25 +00001337 seen before. If it has, the existing error record will have its count
1338 incremented.
1339
njn72718642003-07-24 08:45:32 +00001340 'tid' can be found as for VG_(get_ExeContext)(). The `extra' field can
1341 be stack-allocated; it will be copied by the core if needed (but it
1342 won't be copied if it's NULL).
njnd5bb0a52002-09-27 10:24:48 +00001343
1344 If no 'a', 's' or 'extra' of interest needs to be recorded, just use
njn3e884182003-04-15 13:03:23 +00001345 NULL for them. */
njn72718642003-07-24 08:45:32 +00001346extern void VG_(maybe_record_error) ( ThreadId tid, ErrorKind ekind,
njn25e49d8e72002-09-23 09:36:25 +00001347 Addr a, Char* s, void* extra );
1348
njn43c799e2003-04-08 00:08:52 +00001349/* Similar to VG_(maybe_record_error)(), except this one doesn't record the
1350 error -- useful for errors that can only happen once. The errors can be
1351 suppressed, though. Return value is True if it was suppressed.
1352 `print_error' dictates whether to print the error, which is a bit of a
1353 hack that's useful sometimes if you just want to know if the error would
njn47363ab2003-04-21 13:24:40 +00001354 be suppressed without possibly printing it. `count_error' dictates
1355 whether to add the error in the error total count (another mild hack). */
njn72718642003-07-24 08:45:32 +00001356extern Bool VG_(unique_error) ( ThreadId tid, ErrorKind ekind,
njn43c799e2003-04-08 00:08:52 +00001357 Addr a, Char* s, void* extra,
njn3e884182003-04-15 13:03:23 +00001358 ExeContext* where, Bool print_error,
njn47363ab2003-04-21 13:24:40 +00001359 Bool allow_GDB_attach, Bool count_error );
njn43c799e2003-04-08 00:08:52 +00001360
njn25e49d8e72002-09-23 09:36:25 +00001361/* Gets a non-blank, non-comment line of at most nBuf chars from fd.
1362 Skips leading spaces on the line. Returns True if EOF was hit instead.
njn3e884182003-04-15 13:03:23 +00001363 Useful for reading in extra skin-specific suppression lines. */
njn4ba5a792002-09-30 10:23:54 +00001364extern Bool VG_(get_line) ( Int fd, Char* buf, Int nBuf );
njn25e49d8e72002-09-23 09:36:25 +00001365
1366
1367/*====================================================================*/
1368/*=== Obtaining debug information ===*/
1369/*====================================================================*/
1370
sewardj6e008cb2002-12-15 13:11:39 +00001371/* Get the file/function/line number of the instruction at address
1372 'a'. For these four, if debug info for the address is found, it
1373 copies the info into the buffer/UInt and returns True. If not, it
1374 returns False and nothing is copied. VG_(get_fnname) always
1375 demangles C++ function names. VG_(get_fnname_w_offset) is the
njn3e884182003-04-15 13:03:23 +00001376 same, except it appends "+N" to symbol names to indicate offsets. */
njn25e49d8e72002-09-23 09:36:25 +00001377extern Bool VG_(get_filename) ( Addr a, Char* filename, Int n_filename );
1378extern Bool VG_(get_fnname) ( Addr a, Char* fnname, Int n_fnname );
1379extern Bool VG_(get_linenum) ( Addr a, UInt* linenum );
sewardj6e008cb2002-12-15 13:11:39 +00001380extern Bool VG_(get_fnname_w_offset)
1381 ( Addr a, Char* fnname, Int n_fnname );
njn25e49d8e72002-09-23 09:36:25 +00001382
1383/* This one is more efficient if getting both filename and line number,
1384 because the two lookups are done together. */
1385extern Bool VG_(get_filename_linenum)
1386 ( Addr a, Char* filename, Int n_filename,
1387 UInt* linenum );
1388
1389/* Succeeds only if we find from debug info that 'a' is the address of the
1390 first instruction in a function -- as opposed to VG_(get_fnname) which
1391 succeeds if we find from debug info that 'a' is the address of any
1392 instruction in a function. Use this to instrument the start of
njnd5bb0a52002-09-27 10:24:48 +00001393 a particular function. Nb: if an executable/shared object is stripped
njn25e49d8e72002-09-23 09:36:25 +00001394 of its symbols, this function will not be able to recognise function
1395 entry points within it. */
njn497ec3f2003-05-19 08:38:23 +00001396extern Bool VG_(get_fnname_if_entry) ( Addr a, Char* fnname, Int n_fnname );
njn25e49d8e72002-09-23 09:36:25 +00001397
1398/* Succeeds if the address is within a shared object or the main executable.
1399 It doesn't matter if debug info is present or not. */
1400extern Bool VG_(get_objname) ( Addr a, Char* objname, Int n_objname );
1401
sewardj47104382002-10-20 18:35:48 +00001402/* A way to get information about what segments are mapped */
1403typedef struct _SegInfo SegInfo;
1404
njnb877d492003-01-28 20:40:57 +00001405/* Returns NULL if the SegInfo isn't found. It doesn't matter if debug info
1406 is present or not. */
1407extern SegInfo* VG_(get_obj) ( Addr a );
1408
1409extern const SegInfo* VG_(next_seginfo) ( const SegInfo *seg );
1410extern Addr VG_(seg_start) ( const SegInfo *seg );
1411extern UInt VG_(seg_size) ( const SegInfo *seg );
1412extern const UChar* VG_(seg_filename) ( const SegInfo *seg );
1413extern UInt VG_(seg_sym_offset)( const SegInfo *seg );
sewardj47104382002-10-20 18:35:48 +00001414
1415typedef
1416 enum {
1417 Vg_SectUnknown,
1418 Vg_SectText,
sewardj8fe15a32002-10-20 19:29:21 +00001419 Vg_SectData,
1420 Vg_SectBSS,
sewardj47104382002-10-20 18:35:48 +00001421 Vg_SectGOT,
sewardj8fe15a32002-10-20 19:29:21 +00001422 Vg_SectPLT,
sewardj47104382002-10-20 18:35:48 +00001423 }
1424 VgSectKind;
1425
1426extern VgSectKind VG_(seg_sect_kind)(Addr);
1427
njn25e49d8e72002-09-23 09:36:25 +00001428
1429/*====================================================================*/
njn3e884182003-04-15 13:03:23 +00001430/*=== Generic hash table ===*/
njn25e49d8e72002-09-23 09:36:25 +00001431/*====================================================================*/
1432
njn3e884182003-04-15 13:03:23 +00001433/* Generic type for a separately-chained hash table. Via a kind of dodgy
1434 C-as-C++ style inheritance, skins can extend the VgHashNode type, so long
1435 as the first two fields match the sizes of these two fields. Requires
1436 a bit of casting by the skin. */
njn25e49d8e72002-09-23 09:36:25 +00001437typedef
njn3e884182003-04-15 13:03:23 +00001438 struct _VgHashNode {
1439 struct _VgHashNode * next;
1440 UInt key;
1441 }
1442 VgHashNode;
njn25e49d8e72002-09-23 09:36:25 +00001443
njn3e884182003-04-15 13:03:23 +00001444typedef
1445 VgHashNode**
1446 VgHashTable;
njn810086f2002-11-14 12:42:47 +00001447
njn3e884182003-04-15 13:03:23 +00001448/* Make a new table. */
1449extern VgHashTable VG_(HT_construct) ( void );
1450
1451/* Add a node to the table. */
1452extern void VG_(HT_add_node) ( VgHashTable t, VgHashNode* node );
1453
1454/* Looks up a node in the hash table. Also returns the address of the
1455 previous node's `next' pointer which allows it to be removed from the
1456 list later without having to look it up again. */
1457extern VgHashNode* VG_(HT_get_node) ( VgHashTable t, UInt key,
1458 /*OUT*/VgHashNode*** next_ptr );
1459
1460/* Allocates a sorted array of pointers to all the shadow chunks of malloc'd
1461 blocks. */
1462extern VgHashNode** VG_(HT_to_sorted_array) ( VgHashTable t,
1463 /*OUT*/ UInt* n_shadows );
1464
1465/* Returns first node that matches predicate `p', or NULL if none do.
1466 Extra arguments can be implicitly passed to `p' using nested functions;
1467 see memcheck/mc_errcontext.c for an example. */
1468extern VgHashNode* VG_(HT_first_match) ( VgHashTable t,
1469 Bool (*p)(VgHashNode*) );
1470
1471/* Applies a function f() once to each node. Again, nested functions
1472 can be very useful. */
1473extern void VG_(HT_apply_to_all_nodes)( VgHashTable t, void (*f)(VgHashNode*) );
1474
1475/* Destroy a table. */
1476extern void VG_(HT_destruct) ( VgHashTable t );
njn810086f2002-11-14 12:42:47 +00001477
1478
njn3e884182003-04-15 13:03:23 +00001479/*====================================================================*/
njnd3040452003-05-19 15:04:06 +00001480/*=== Functions for shadow registers ===*/
1481/*====================================================================*/
1482
1483/* Nb: make sure the shadow_regs 'need' is set before using these! */
1484
1485/* This one lets you override the shadow of the return value register for a
1486 syscall. Call it from SK_(post_syscall)() (not SK_(pre_syscall)()!) to
1487 override the default shadow register value. */
1488extern void VG_(set_return_from_syscall_shadow) ( ThreadId tid,
1489 UInt ret_shadow );
1490
1491/* This can be called from SK_(fini)() to find the shadow of the argument
1492 to exit(), ie. the shadow of the program's return value. */
1493extern UInt VG_(get_exit_status_shadow) ( void );
1494
1495
1496/*====================================================================*/
njn3e884182003-04-15 13:03:23 +00001497/*=== General stuff for replacing functions ===*/
1498/*====================================================================*/
njn25e49d8e72002-09-23 09:36:25 +00001499
njn3e884182003-04-15 13:03:23 +00001500/* Some skins need to replace the standard definitions of some functions. */
njn25e49d8e72002-09-23 09:36:25 +00001501
njn3e884182003-04-15 13:03:23 +00001502/* ------------------------------------------------------------------ */
1503/* General stuff, for replacing any functions */
njn25e49d8e72002-09-23 09:36:25 +00001504
njn3e884182003-04-15 13:03:23 +00001505/* Is the client running on the simulated CPU or the real one?
njn25e49d8e72002-09-23 09:36:25 +00001506
njn3e884182003-04-15 13:03:23 +00001507 Nb: If it is, and you want to call a function to be run on the real CPU,
njn057c65f2003-04-21 13:30:55 +00001508 use one of the VALGRIND_NON_SIMD_CALL[123] macros in valgrind.h to call it.
njn25e49d8e72002-09-23 09:36:25 +00001509
njn3e884182003-04-15 13:03:23 +00001510 Nb: don't forget the function parentheses when using this in a
1511 condition... write this:
1512
1513 if (VG_(is_running_on_simd_CPU)()) { ... } // calls function
1514
1515 not this:
1516
1517 if (VG_(is_running_on_simd_CPU)) { ... } // address of var!
1518*/
1519extern Bool VG_(is_running_on_simd_CPU) ( void );
1520
1521
1522/*====================================================================*/
1523/*=== Specific stuff for replacing malloc() and friends ===*/
1524/*====================================================================*/
1525
njn3e884182003-04-15 13:03:23 +00001526/* If a skin replaces malloc() et al, the easiest way to do so is to link
1527 with coregrind/vg_replace_malloc.c, and follow the following instructions.
1528 You can do it from scratch, though, if you enjoy that sort of thing. */
1529
1530/* Arena size for valgrind's own malloc(); default value is 0, but can
1531 be overridden by skin -- but must be done so *statically*, eg:
1532
1533 Int VG_(vg_malloc_redzone_szB) = 4;
1534
1535 It can't be done from a function like SK_(pre_clo_init)(). So it can't,
1536 for example, be controlled with a command line option, unfortunately. */
1537extern UInt VG_(vg_malloc_redzone_szB);
1538
1539/* If a skin links with vg_replace_malloc.c, the following functions will be
1540 called appropriately when malloc() et al are called. */
njn72718642003-07-24 08:45:32 +00001541extern void* SK_(malloc) ( Int n );
1542extern void* SK_(__builtin_new) ( Int n );
1543extern void* SK_(__builtin_vec_new) ( Int n );
1544extern void* SK_(memalign) ( Int align, Int n );
1545extern void* SK_(calloc) ( Int nmemb, Int n );
1546extern void SK_(free) ( void* p );
1547extern void SK_(__builtin_delete) ( void* p );
1548extern void SK_(__builtin_vec_delete) ( void* p );
1549extern void* SK_(realloc) ( void* p, Int size );
njn3e884182003-04-15 13:03:23 +00001550
1551/* Can be called from SK_(malloc) et al to do the actual alloc/freeing. */
1552extern void* VG_(cli_malloc) ( UInt align, Int nbytes );
1553extern void VG_(cli_free) ( void* p );
1554
1555/* Check if an address is within a range, allowing for redzones at edges */
1556extern Bool VG_(addr_is_in_block)( Addr a, Addr start, UInt size );
1557
1558/* ------------------------------------------------------------------ */
1559/* Some options that can be used by a skin if malloc() et al are replaced.
njnd3040452003-05-19 15:04:06 +00001560 The skin should call the functions in the appropriate places to give
1561 control over these aspects of Valgrind's version of malloc(). */
njn3e884182003-04-15 13:03:23 +00001562
1563/* Round malloc sizes upwards to integral number of words? default: NO */
1564extern Bool VG_(clo_sloppy_malloc);
1565/* DEBUG: print malloc details? default: NO */
1566extern Bool VG_(clo_trace_malloc);
1567/* Minimum alignment in functions that don't specify alignment explicitly.
1568 default: 0, i.e. use default of the machine (== 4) */
1569extern Int VG_(clo_alignment);
1570
1571extern Bool VG_(replacement_malloc_process_cmd_line_option) ( Char* arg );
1572extern void VG_(replacement_malloc_print_usage) ( void );
1573extern void VG_(replacement_malloc_print_debug_usage) ( void );
sewardja4495682002-10-21 07:29:59 +00001574
1575
njn25e49d8e72002-09-23 09:36:25 +00001576/*====================================================================*/
1577/*=== Skin-specific stuff ===*/
1578/*====================================================================*/
1579
njnd04b7c62002-10-03 14:05:52 +00001580/* ------------------------------------------------------------------ */
1581/* Details */
njnd04b7c62002-10-03 14:05:52 +00001582
njn120281f2003-02-03 12:20:07 +00001583/* Default value for avg_translations_sizeB (in bytes), indicating typical
1584 code expansion of about 6:1. */
1585#define VG_DEFAULT_TRANS_SIZEB 100
1586
njn810086f2002-11-14 12:42:47 +00001587/* Information used in the startup message. `name' also determines the
1588 string used for identifying suppressions in a suppression file as
1589 belonging to this skin. `version' can be NULL, in which case (not
1590 surprisingly) no version info is printed; this mechanism is designed for
1591 skins distributed with Valgrind that share a version number with
1592 Valgrind. Other skins not distributed as part of Valgrind should
sewardjc0d8f682002-11-30 00:49:43 +00001593 probably have their own version number. */
1594extern void VG_(details_name) ( Char* name );
1595extern void VG_(details_version) ( Char* version );
1596extern void VG_(details_description) ( Char* description );
1597extern void VG_(details_copyright_author) ( Char* copyright_author );
1598
1599/* Average size of a translation, in bytes, so that the translation
njn120281f2003-02-03 12:20:07 +00001600 storage machinery can allocate memory appropriately. Not critical,
1601 setting is optional. */
1602extern void VG_(details_avg_translation_sizeB) ( UInt size );
njnd04b7c62002-10-03 14:05:52 +00001603
njn810086f2002-11-14 12:42:47 +00001604/* String printed if an `sk_assert' assertion fails or VG_(skin_panic)
1605 is called. Should probably be an email address. */
1606extern void VG_(details_bug_reports_to) ( Char* bug_reports_to );
njnd04b7c62002-10-03 14:05:52 +00001607
1608/* ------------------------------------------------------------------ */
1609/* Needs */
1610
njn810086f2002-11-14 12:42:47 +00001611/* Booleans that decide core behaviour, but don't require extra
1612 operations to be defined if `True' */
njnd5bb0a52002-09-27 10:24:48 +00001613
njn810086f2002-11-14 12:42:47 +00001614/* Should __libc_freeres() be run? Bugs in it can crash the skin. */
1615extern void VG_(needs_libc_freeres) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001616
njn810086f2002-11-14 12:42:47 +00001617/* Want to have errors detected by Valgrind's core reported? Includes:
1618 - pthread API errors (many; eg. unlocking a non-locked mutex)
njn810086f2002-11-14 12:42:47 +00001619 - invalid file descriptors to blocking syscalls read() and write()
1620 - bad signal numbers passed to sigaction()
1621 - attempt to install signal handler for SIGKILL or SIGSTOP */
1622extern void VG_(needs_core_errors) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001623
njn810086f2002-11-14 12:42:47 +00001624/* Booleans that indicate extra operations are defined; if these are True,
1625 the corresponding template functions (given below) must be defined. A
1626 lot like being a member of a type class. */
njn25e49d8e72002-09-23 09:36:25 +00001627
njn810086f2002-11-14 12:42:47 +00001628/* Want to report errors from skin? This implies use of suppressions, too. */
1629extern void VG_(needs_skin_errors) ( void );
njnd5bb0a52002-09-27 10:24:48 +00001630
njn810086f2002-11-14 12:42:47 +00001631/* Is information kept about specific individual basic blocks? (Eg. for
1632 cachegrind there are cost-centres for every instruction, stored at a
1633 basic block level.) If so, it sometimes has to be discarded, because
1634 .so mmap/munmap-ping or self-modifying code (informed by the
1635 DISCARD_TRANSLATIONS user request) can cause one instruction address
1636 to be used for more than one instruction in one program run... */
1637extern void VG_(needs_basic_block_discards) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001638
njn810086f2002-11-14 12:42:47 +00001639/* Skin maintains information about each register? */
1640extern void VG_(needs_shadow_regs) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001641
njn810086f2002-11-14 12:42:47 +00001642/* Skin defines its own command line options? */
1643extern void VG_(needs_command_line_options) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001644
njn810086f2002-11-14 12:42:47 +00001645/* Skin defines its own client requests? */
1646extern void VG_(needs_client_requests) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001647
njn810086f2002-11-14 12:42:47 +00001648/* Skin defines its own UInstrs? */
1649extern void VG_(needs_extended_UCode) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001650
njn810086f2002-11-14 12:42:47 +00001651/* Skin does stuff before and/or after system calls? */
1652extern void VG_(needs_syscall_wrapper) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001653
njn810086f2002-11-14 12:42:47 +00001654/* Are skin-state sanity checks performed? */
1655extern void VG_(needs_sanity_checks) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001656
njn810086f2002-11-14 12:42:47 +00001657/* Do we need to see data symbols? */
1658extern void VG_(needs_data_syms) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001659
1660/* ------------------------------------------------------------------ */
1661/* Core events to track */
1662
1663/* Part of the core from which this call was made. Useful for determining
njnd5bb0a52002-09-27 10:24:48 +00001664 what kind of error message should be emitted. */
njn25e49d8e72002-09-23 09:36:25 +00001665typedef
1666 enum { Vg_CorePThread, Vg_CoreSignal, Vg_CoreSysCall, Vg_CoreTranslate }
1667 CorePart;
1668
njn810086f2002-11-14 12:42:47 +00001669#define EV extern void
njn25e49d8e72002-09-23 09:36:25 +00001670
njn810086f2002-11-14 12:42:47 +00001671/* Events happening in core to track. To be notified, pass a callback
1672 function to the appropriate function. To ignore an event, don't do
njn72718642003-07-24 08:45:32 +00001673 anything (default is for events to be ignored).
1674
1675 Note that most events aren't passed a ThreadId. To find out the ThreadId
1676 of the affected thread, use VG_(get_current_or_recent_tid)(). For the
1677 ones passed a ThreadId, use that instead, since
1678 VG_(get_current_or_recent_tid)() might not give the right ThreadId in
1679 that case.
1680*/
njn810086f2002-11-14 12:42:47 +00001681
njn810086f2002-11-14 12:42:47 +00001682
njn3e884182003-04-15 13:03:23 +00001683/* Memory events (Nb: to track heap allocation/freeing, a skin must replace
1684 malloc() et al. See above how to do this.) */
1685
1686/* These ones occur at startup, upon some signals, and upon some syscalls */
njn810086f2002-11-14 12:42:47 +00001687EV VG_(track_new_mem_startup) ( void (*f)(Addr a, UInt len,
1688 Bool rr, Bool ww, Bool xx) );
njn810086f2002-11-14 12:42:47 +00001689EV VG_(track_new_mem_stack_signal) ( void (*f)(Addr a, UInt len) );
1690EV VG_(track_new_mem_brk) ( void (*f)(Addr a, UInt len) );
1691EV VG_(track_new_mem_mmap) ( void (*f)(Addr a, UInt len,
1692 Bool rr, Bool ww, Bool xx) );
1693
njn3e884182003-04-15 13:03:23 +00001694EV VG_(track_copy_mem_remap) ( void (*f)(Addr from, Addr to, UInt len) );
1695EV VG_(track_change_mem_mprotect) ( void (*f)(Addr a, UInt len,
1696 Bool rr, Bool ww, Bool xx) );
1697EV VG_(track_die_mem_stack_signal) ( void (*f)(Addr a, UInt len) );
1698EV VG_(track_die_mem_brk) ( void (*f)(Addr a, UInt len) );
1699EV VG_(track_die_mem_munmap) ( void (*f)(Addr a, UInt len) );
1700
1701
1702/* These ones are called when %esp changes. A skin could track these itself
1703 (except for ban_mem_stack) but it's much easier to use the core's help.
1704
1705 The specialised ones are called in preference to the general one, if they
njn9b007f62003-04-07 14:40:25 +00001706 are defined. These functions are called a lot if they are used, so
1707 specialising can optimise things significantly. If any of the
1708 specialised cases are defined, the general case must be defined too.
1709
1710 Nb: they must all use the __attribute__((regparm(n))) attribute. */
1711EV VG_(track_new_mem_stack_4) ( void (*f)(Addr new_ESP) );
1712EV VG_(track_new_mem_stack_8) ( void (*f)(Addr new_ESP) );
1713EV VG_(track_new_mem_stack_12) ( void (*f)(Addr new_ESP) );
1714EV VG_(track_new_mem_stack_16) ( void (*f)(Addr new_ESP) );
1715EV VG_(track_new_mem_stack_32) ( void (*f)(Addr new_ESP) );
1716EV VG_(track_new_mem_stack) ( void (*f)(Addr a, UInt len) );
1717
njn9b007f62003-04-07 14:40:25 +00001718EV VG_(track_die_mem_stack_4) ( void (*f)(Addr die_ESP) );
1719EV VG_(track_die_mem_stack_8) ( void (*f)(Addr die_ESP) );
1720EV VG_(track_die_mem_stack_12) ( void (*f)(Addr die_ESP) );
1721EV VG_(track_die_mem_stack_16) ( void (*f)(Addr die_ESP) );
1722EV VG_(track_die_mem_stack_32) ( void (*f)(Addr die_ESP) );
1723EV VG_(track_die_mem_stack) ( void (*f)(Addr a, UInt len) );
1724
njn3e884182003-04-15 13:03:23 +00001725/* Used for redzone at end of thread stacks */
1726EV VG_(track_ban_mem_stack) ( void (*f)(Addr a, UInt len) );
njn25e49d8e72002-09-23 09:36:25 +00001727
njn3e884182003-04-15 13:03:23 +00001728/* These ones occur around syscalls, signal handling, etc */
njn72718642003-07-24 08:45:32 +00001729EV VG_(track_pre_mem_read) ( void (*f)(CorePart part, ThreadId tid,
njn810086f2002-11-14 12:42:47 +00001730 Char* s, Addr a, UInt size) );
njn72718642003-07-24 08:45:32 +00001731EV VG_(track_pre_mem_read_asciiz) ( void (*f)(CorePart part, ThreadId tid,
njn810086f2002-11-14 12:42:47 +00001732 Char* s, Addr a) );
njn72718642003-07-24 08:45:32 +00001733EV VG_(track_pre_mem_write) ( void (*f)(CorePart part, ThreadId tid,
njn810086f2002-11-14 12:42:47 +00001734 Char* s, Addr a, UInt size) );
1735/* Not implemented yet -- have to add in lots of places, which is a
1736 pain. Won't bother unless/until there's a need. */
njn72718642003-07-24 08:45:32 +00001737/* EV VG_(track_post_mem_read) ( void (*f)(ThreadId tid, Char* s,
njn810086f2002-11-14 12:42:47 +00001738 Addr a, UInt size) ); */
1739EV VG_(track_post_mem_write) ( void (*f)(Addr a, UInt size) );
njn25e49d8e72002-09-23 09:36:25 +00001740
1741
njnd3040452003-05-19 15:04:06 +00001742/* Register events -- if `shadow_regs' need is set, all should probably be
1743 used. Use VG_(set_thread_shadow_archreg)() to set the shadow of the
1744 changed register. */
1745
1746/* Use VG_(set_shadow_archreg)() to set the eight general purpose regs,
1747 and use VG_(set_shadow_eflags)() to set eflags. */
1748EV VG_(track_post_regs_write_init) ( void (*f)() );
1749
1750/* Use VG_(set_thread_shadow_archreg)() to set the shadow regs for these
1751 events. */
1752EV VG_(track_post_reg_write_syscall_return)
1753 ( void (*f)(ThreadId tid, UInt reg) );
1754EV VG_(track_post_reg_write_deliver_signal)
1755 ( void (*f)(ThreadId tid, UInt reg) );
1756EV VG_(track_post_reg_write_pthread_return)
1757 ( void (*f)(ThreadId tid, UInt reg) );
1758EV VG_(track_post_reg_write_clientreq_return)
1759 ( void (*f)(ThreadId tid, UInt reg) );
1760 /* This one is called for malloc() et al if they are replaced by a skin. */
1761EV VG_(track_post_reg_write_clientcall_return)
1762 ( void (*f)(ThreadId tid, UInt reg,
1763 Addr called_function) );
1764
1765
njn810086f2002-11-14 12:42:47 +00001766/* Scheduler events (not exhaustive) */
njn25e49d8e72002-09-23 09:36:25 +00001767
njn810086f2002-11-14 12:42:47 +00001768EV VG_(track_thread_run) ( void (*f)(ThreadId tid) );
njn25e49d8e72002-09-23 09:36:25 +00001769
njn810086f2002-11-14 12:42:47 +00001770/* Thread events (not exhaustive) */
sewardjdca84112002-11-13 22:29:34 +00001771
njn810086f2002-11-14 12:42:47 +00001772/* Called during thread create, before the new thread has run any
1773 instructions (or touched any memory). */
1774EV VG_(track_post_thread_create)( void (*f)(ThreadId tid, ThreadId child) );
1775/* Called once the joinee thread is terminated and the joining thread is
1776 about to resume. */
1777EV VG_(track_post_thread_join) ( void (*f)(ThreadId joiner, ThreadId joinee) );
njn25e49d8e72002-09-23 09:36:25 +00001778
njnd5bb0a52002-09-27 10:24:48 +00001779
njn810086f2002-11-14 12:42:47 +00001780/* Mutex events (not exhaustive) */
njn25e49d8e72002-09-23 09:36:25 +00001781
njn810086f2002-11-14 12:42:47 +00001782/* Called before a thread can block while waiting for a mutex (called
1783 regardless of whether the thread will block or not). */
1784EV VG_(track_pre_mutex_lock) ( void (*f)(ThreadId tid,
1785 void* /*pthread_mutex_t* */ mutex) );
1786/* Called once the thread actually holds the mutex (always paired with
1787 pre_mutex_lock). */
1788EV VG_(track_post_mutex_lock) ( void (*f)(ThreadId tid,
1789 void* /*pthread_mutex_t* */ mutex) );
1790/* Called after a thread has released a mutex (no need for a corresponding
1791 pre_mutex_unlock, because unlocking can't block). */
1792EV VG_(track_post_mutex_unlock) ( void (*f)(ThreadId tid,
1793 void* /*pthread_mutex_t* */ mutex) );
njn25e49d8e72002-09-23 09:36:25 +00001794
njn1045b0a2003-02-24 10:42:47 +00001795
1796/* Signal events (not exhaustive) */
1797
njn7b456f52003-05-19 11:16:50 +00001798/* ... pre_send_signal, post_send_signal ... */
1799
njn1045b0a2003-02-24 10:42:47 +00001800/* Called before a signal is delivered; `alt_stack' indicates if it is
1801 delivered on an alternative stack. */
1802EV VG_(track_pre_deliver_signal) ( void (*f)(ThreadId tid, Int sigNum,
1803 Bool alt_stack) );
njn7b456f52003-05-19 11:16:50 +00001804/* Called after a signal is delivered. Nb: unfortunately, if the signal
1805 handler longjmps, this won't be called. */
njn1045b0a2003-02-24 10:42:47 +00001806EV VG_(track_post_deliver_signal) ( void (*f)(ThreadId tid, Int sigNum ) );
1807
1808
1809/* Others... condition variables... */
njn810086f2002-11-14 12:42:47 +00001810/* ... */
1811
1812#undef EV
njn25e49d8e72002-09-23 09:36:25 +00001813
1814/* ------------------------------------------------------------------ */
1815/* Template functions */
1816
1817/* These are the parameterised functions in the core. The default definitions
njnd5bb0a52002-09-27 10:24:48 +00001818 are overridden by LD_PRELOADed skin version. At the very least, a skin
1819 must define the fundamental template functions. Depending on what needs
1820 are set, extra template functions will be used too. Functions are
1821 grouped under the needs that govern their use. */
njn25e49d8e72002-09-23 09:36:25 +00001822
1823
1824/* ------------------------------------------------------------------ */
1825/* Fundamental template functions */
1826
1827/* Initialise skin. Must do the following:
njn810086f2002-11-14 12:42:47 +00001828 - initialise the `details' struct, via the VG_(details_*)() functions
njn25e49d8e72002-09-23 09:36:25 +00001829 - register any helpers called by generated code
1830
1831 May do the following:
njn810086f2002-11-14 12:42:47 +00001832 - initialise the `needs' struct to indicate certain requirements, via
1833 the VG_(needs_*)() functions
1834 - initialise the `track' struct to indicate core events of interest, via
1835 the VG_(track_*)() functions
njn25e49d8e72002-09-23 09:36:25 +00001836 - register any skin-specific profiling events
1837 - any other skin-specific initialisation
1838*/
njn810086f2002-11-14 12:42:47 +00001839extern void SK_(pre_clo_init) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001840
njnd5bb0a52002-09-27 10:24:48 +00001841/* Do initialisation that can only be done after command line processing. */
njn25e49d8e72002-09-23 09:36:25 +00001842extern void SK_(post_clo_init)( void );
1843
1844/* Instrument a basic block. Must be a true function, ie. the same input
1845 always results in the same output, because basic blocks can be
1846 retranslated. Unless you're doing something really strange...
1847 'orig_addr' is the address of the first instruction in the block. */
1848extern UCodeBlock* SK_(instrument) ( UCodeBlock* cb, Addr orig_addr );
1849
njn7d9f94d2003-04-22 21:41:40 +00001850/* Finish up, print out any results, etc. `exitcode' is program's exit
1851 code. The shadow (if the `shadow_regs' need is set) can be found with
1852 VG_(get_shadow_archreg)(R_EBX), since %ebx holds the argument to the
1853 exit() syscall. */
1854extern void SK_(fini) ( Int exitcode );
njn25e49d8e72002-09-23 09:36:25 +00001855
1856
1857/* ------------------------------------------------------------------ */
njn6a230532003-07-21 10:38:23 +00001858/* VG_(needs).core_errors */
1859
1860/* (none needed) */
1861
1862/* ------------------------------------------------------------------ */
1863/* VG_(needs).skin_errors */
njn25e49d8e72002-09-23 09:36:25 +00001864
1865/* Identify if two errors are equal, or equal enough. `res' indicates how
1866 close is "close enough". `res' should be passed on as necessary, eg. if
njn810086f2002-11-14 12:42:47 +00001867 the Error's `extra' part contains an ExeContext, `res' should be
njn25e49d8e72002-09-23 09:36:25 +00001868 passed to VG_(eq_ExeContext)() if the ExeContexts are considered. Other
1869 than that, probably don't worry about it unless you have lots of very
1870 similar errors occurring.
1871 */
njn810086f2002-11-14 12:42:47 +00001872extern Bool SK_(eq_SkinError) ( VgRes res, Error* e1, Error* e2 );
njn25e49d8e72002-09-23 09:36:25 +00001873
njn43c799e2003-04-08 00:08:52 +00001874/* Print error context. */
1875extern void SK_(pp_SkinError) ( Error* err );
njn25e49d8e72002-09-23 09:36:25 +00001876
njn43c799e2003-04-08 00:08:52 +00001877/* Should fill in any details that could be postponed until after the
njn810086f2002-11-14 12:42:47 +00001878 decision whether to ignore the error (ie. details not affecting the
1879 result of SK_(eq_SkinError)()). This saves time when errors are ignored.
njn25e49d8e72002-09-23 09:36:25 +00001880 Yuk.
njn43c799e2003-04-08 00:08:52 +00001881
1882 Return value: must be the size of the `extra' part in bytes -- used by
1883 the core to make a copy.
njn25e49d8e72002-09-23 09:36:25 +00001884*/
njn43c799e2003-04-08 00:08:52 +00001885extern UInt SK_(update_extra) ( Error* err );
njn25e49d8e72002-09-23 09:36:25 +00001886
njn810086f2002-11-14 12:42:47 +00001887/* Return value indicates recognition. If recognised, must set skind using
1888 VG_(set_supp_kind)(). */
1889extern Bool SK_(recognised_suppression) ( Char* name, Supp* su );
njn25e49d8e72002-09-23 09:36:25 +00001890
njn810086f2002-11-14 12:42:47 +00001891/* Read any extra info for this suppression kind. Most likely for filling
1892 in the `extra' and `string' parts (with VG_(set_supp_{extra,string})())
1893 of a suppression if necessary. Should return False if a syntax error
1894 occurred, True otherwise. */
1895extern Bool SK_(read_extra_suppression_info) ( Int fd, Char* buf, Int nBuf,
1896 Supp* su );
njn25e49d8e72002-09-23 09:36:25 +00001897
1898/* This should just check the kinds match and maybe some stuff in the
njn810086f2002-11-14 12:42:47 +00001899 `string' and `extra' field if appropriate (using VG_(get_supp_*)() to
1900 get the relevant suppression parts). */
njn43c799e2003-04-08 00:08:52 +00001901extern Bool SK_(error_matches_suppression) ( Error* err, Supp* su );
1902
1903/* This should return the suppression name, for --gen-suppressions, or NULL
1904 if that error type cannot be suppressed. This is the inverse of
1905 SK_(recognised_suppression)(). */
1906extern Char* SK_(get_error_name) ( Error* err );
1907
1908/* This should print any extra info for the error, for --gen-suppressions,
1909 including the newline. This is the inverse of
1910 SK_(read_extra_suppression_info)(). */
1911extern void SK_(print_extra_suppression_info) ( Error* err );
njn25e49d8e72002-09-23 09:36:25 +00001912
1913
1914/* ------------------------------------------------------------------ */
1915/* VG_(needs).basic_block_discards */
1916
njnd5bb0a52002-09-27 10:24:48 +00001917/* Should discard any information that pertains to specific basic blocks
1918 or instructions within the address range given. */
njn25e49d8e72002-09-23 09:36:25 +00001919extern void SK_(discard_basic_block_info) ( Addr a, UInt size );
1920
1921
1922/* ------------------------------------------------------------------ */
1923/* VG_(needs).shadow_regs */
1924
njnd3040452003-05-19 15:04:06 +00001925/* No functions must be defined, but the post_reg[s]_write_* events should
1926 be tracked. */
njn25e49d8e72002-09-23 09:36:25 +00001927
1928/* ------------------------------------------------------------------ */
1929/* VG_(needs).command_line_options */
1930
njnd5bb0a52002-09-27 10:24:48 +00001931/* Return True if option was recognised. Presumably sets some state to
1932 record the option as well. */
1933extern Bool SK_(process_cmd_line_option) ( Char* argv );
njn25e49d8e72002-09-23 09:36:25 +00001934
njn3e884182003-04-15 13:03:23 +00001935/* Print out command line usage for options for normal skin operation. */
1936extern void SK_(print_usage) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001937
njn3e884182003-04-15 13:03:23 +00001938/* Print out command line usage for options for debugging the skin. */
1939extern void SK_(print_debug_usage) ( void );
njn25e49d8e72002-09-23 09:36:25 +00001940
1941/* ------------------------------------------------------------------ */
1942/* VG_(needs).client_requests */
1943
njnd3040452003-05-19 15:04:06 +00001944/* If using client requests, the number of the first request should be equal
1945 to VG_USERREQ_SKIN_BASE('X','Y'), where 'X' and 'Y' form a suitable two
1946 character identification for the string. The second and subsequent
1947 requests should follow. */
1948
1949/* This function should use the VG_IS_SKIN_USERREQ macro (in
1950 include/valgrind.h) to first check if it's a request for this skin. Then
1951 should handle it if it's recognised (and return True), or return False if
1952 not recognised. arg_block[0] holds the request number, any further args
1953 from the request are in arg_block[1..]. 'ret' is for the return value...
1954 it should probably be filled, if only with 0. */
njn72718642003-07-24 08:45:32 +00001955extern Bool SK_(handle_client_request) ( ThreadId tid, UInt* arg_block,
njnd3040452003-05-19 15:04:06 +00001956 UInt *ret );
njn25e49d8e72002-09-23 09:36:25 +00001957
1958
1959/* ------------------------------------------------------------------ */
1960/* VG_(needs).extends_UCode */
1961
njn4ba5a792002-09-30 10:23:54 +00001962/* Useful to use in VG_(get_Xreg_usage)() */
njn810086f2002-11-14 12:42:47 +00001963#define VG_UINSTR_READS_REG(ono,regs,isWrites) \
njn25e49d8e72002-09-23 09:36:25 +00001964 { if (mycat(u->tag,ono) == tag) \
njn810086f2002-11-14 12:42:47 +00001965 { regs[n] = mycat(u->val,ono); \
1966 isWrites[n] = False; \
njn25e49d8e72002-09-23 09:36:25 +00001967 n++; \
1968 } \
1969 }
njn810086f2002-11-14 12:42:47 +00001970#define VG_UINSTR_WRITES_REG(ono,regs,isWrites) \
njnd5bb0a52002-09-27 10:24:48 +00001971 { if (mycat(u->tag,ono) == tag) \
njn810086f2002-11-14 12:42:47 +00001972 { regs[n] = mycat(u->val,ono); \
1973 isWrites[n] = True; \
njnd5bb0a52002-09-27 10:24:48 +00001974 n++; \
1975 } \
njn25e49d8e72002-09-23 09:36:25 +00001976 }
1977
njn4ba5a792002-09-30 10:23:54 +00001978/* 'X' prefix indicates eXtended UCode. */
njn810086f2002-11-14 12:42:47 +00001979extern Int SK_(get_Xreg_usage) ( UInstr* u, Tag tag, Int* regs,
1980 Bool* isWrites );
njn4ba5a792002-09-30 10:23:54 +00001981extern void SK_(emit_XUInstr) ( UInstr* u, RRegSet regs_live_before );
1982extern Bool SK_(sane_XUInstr) ( Bool beforeRA, Bool beforeLiveness,
njn25e49d8e72002-09-23 09:36:25 +00001983 UInstr* u );
njn4ba5a792002-09-30 10:23:54 +00001984extern Char* SK_(name_XUOpcode) ( Opcode opc );
1985extern void SK_(pp_XUInstr) ( UInstr* u );
njn25e49d8e72002-09-23 09:36:25 +00001986
1987
1988/* ------------------------------------------------------------------ */
1989/* VG_(needs).syscall_wrapper */
1990
1991/* If either of the pre_ functions malloc() something to return, the
1992 * corresponding post_ function had better free() it!
1993 */
1994extern void* SK_( pre_syscall) ( ThreadId tid, UInt syscallno,
1995 Bool is_blocking );
1996extern void SK_(post_syscall) ( ThreadId tid, UInt syscallno,
1997 void* pre_result, Int res,
1998 Bool is_blocking );
1999
njnd5bb0a52002-09-27 10:24:48 +00002000
njn25e49d8e72002-09-23 09:36:25 +00002001/* ---------------------------------------------------------------------
2002 VG_(needs).sanity_checks */
2003
njnd5bb0a52002-09-27 10:24:48 +00002004/* Can be useful for ensuring a skin's correctness. SK_(cheap_sanity_check)
2005 is called very frequently; SK_(expensive_sanity_check) is called less
2006 frequently and can be more involved. */
njn25e49d8e72002-09-23 09:36:25 +00002007extern Bool SK_(cheap_sanity_check) ( void );
2008extern Bool SK_(expensive_sanity_check) ( void );
2009
2010
2011#endif /* NDEF __VG_SKIN_H */
2012
2013/*--------------------------------------------------------------------*/
2014/*--- end vg_skin.h ---*/
2015/*--------------------------------------------------------------------*/
2016