1
2/*--------------------------------------------------------------------*/
3/*--- Machine-related stuff.                    pub_tool_machine.h ---*/
4/*--------------------------------------------------------------------*/
5
6/*
7   This file is part of Valgrind, a dynamic binary instrumentation
8   framework.
9
10   Copyright (C) 2000-2012 Julian Seward
11      jseward@acm.org
12
13   This program is free software; you can redistribute it and/or
14   modify it under the terms of the GNU General Public License as
15   published by the Free Software Foundation; either version 2 of the
16   License, or (at your option) any later version.
17
18   This program is distributed in the hope that it will be useful, but
19   WITHOUT ANY WARRANTY; without even the implied warranty of
20   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21   General Public License for more details.
22
23   You should have received a copy of the GNU General Public License
24   along with this program; if not, write to the Free Software
25   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26   02111-1307, USA.
27
28   The GNU General Public License is contained in the file COPYING.
29*/
30
31#ifndef __PUB_TOOL_MACHINE_H
32#define __PUB_TOOL_MACHINE_H
33
34#if defined(VGP_x86_linux)
35#  define VG_MIN_INSTR_SZB          1  // min length of native instruction
36#  define VG_MAX_INSTR_SZB         16  // max length of native instruction
37#  define VG_CLREQ_SZB             14  // length of a client request, may
38                                       //   be larger than VG_MAX_INSTR_SZB
39#  define VG_STACK_REDZONE_SZB      0  // number of addressable bytes below %RSP
40
41#elif defined(VGP_amd64_linux)
42#  define VG_MIN_INSTR_SZB          1
43#  define VG_MAX_INSTR_SZB         16
44#  define VG_CLREQ_SZB             19
45#  define VG_STACK_REDZONE_SZB    128
46
47#elif defined(VGP_ppc32_linux)
48#  define VG_MIN_INSTR_SZB          4
49#  define VG_MAX_INSTR_SZB          4
50#  define VG_CLREQ_SZB             20
51#  define VG_STACK_REDZONE_SZB      0
52
53#elif defined(VGP_ppc64_linux)
54#  define VG_MIN_INSTR_SZB          4
55#  define VG_MAX_INSTR_SZB          4
56#  define VG_CLREQ_SZB             20
57#  define VG_STACK_REDZONE_SZB    288  // number of addressable bytes below R1
58                                       // from 64-bit PowerPC ELF ABI
59                                       // Supplement 1.7
60
61#elif defined(VGP_arm_linux)
62#  define VG_MIN_INSTR_SZB          2
63#  define VG_MAX_INSTR_SZB          4
64#  define VG_CLREQ_SZB             20
65#  define VG_STACK_REDZONE_SZB      0
66
67#elif defined(VGP_s390x_linux)
68#  define VG_MIN_INSTR_SZB          2
69#  define VG_MAX_INSTR_SZB          6
70#  define VG_CLREQ_SZB             10
71#  define VG_STACK_REDZONE_SZB      0  // s390 has no redzone
72
73#elif defined(VGP_x86_darwin)
74#  define VG_MIN_INSTR_SZB          1  // min length of native instruction
75#  define VG_MAX_INSTR_SZB         16  // max length of native instruction
76#  define VG_CLREQ_SZB             14  // length of a client request, may
77                                       //   be larger than VG_MAX_INSTR_SZB
78#  define VG_STACK_REDZONE_SZB      0  // number of addressable bytes below %RSP
79
80#elif defined(VGP_amd64_darwin)
81#  define VG_MIN_INSTR_SZB          1
82#  define VG_MAX_INSTR_SZB         16
83#  define VG_CLREQ_SZB             19
84#  define VG_STACK_REDZONE_SZB    128
85
86#elif defined(VGP_mips32_linux)
87#  define VG_MIN_INSTR_SZB          4
88#  define VG_MAX_INSTR_SZB          4
89#  define VG_CLREQ_SZB             20
90#  define VG_STACK_REDZONE_SZB      0
91
92#else
93#  error Unknown platform
94#endif
95
96// Guest state accessors
97// Are mostly in the core_ header.
98//  Only these two are available to tools.
99Addr VG_(get_IP) ( ThreadId tid );
100Addr VG_(get_SP) ( ThreadId tid );
101
102
103// For get/set, 'area' is where the asked-for guest state will be copied
104// into/from.  If shadowNo == 0, the real (non-shadow) guest state is
105// accessed.  If shadowNo == 1, the first shadow area is accessed, and
106// if shadowNo == 2, the second shadow area is accessed.  This gives a
107// completely general way to read/modify a thread's guest register state
108// providing you know the offsets you need.
109void
110VG_(get_shadow_regs_area) ( ThreadId tid,
111                            /*DST*/UChar* dst,
112                            /*SRC*/Int shadowNo, PtrdiffT offset, SizeT size );
113void
114VG_(set_shadow_regs_area) ( ThreadId tid,
115                            /*DST*/Int shadowNo, PtrdiffT offset, SizeT size,
116                            /*SRC*/const UChar* src );
117
118// Sets the shadow values for the syscall return value register(s).
119// This is platform specific.
120void VG_(set_syscall_return_shadows) ( ThreadId tid,
121                                       /* shadow vals for the result */
122                                       UWord s1res, UWord s2res,
123                                       /* shadow vals for the error val */
124                                       UWord s1err, UWord s2err );
125
126// Apply a function 'f' to all the general purpose registers in all the
127// current threads.
128// This is very Memcheck-specific -- it's used to find the roots when
129// doing leak checking.
130extern void VG_(apply_to_GP_regs)(void (*f)(ThreadId tid,
131                                            HChar* regname, UWord val));
132
133// This iterator lets you inspect each live thread's stack bounds.
134// Returns False at the end.  'tid' is the iterator and you can only
135// safely change it by making calls to these functions.
136extern void VG_(thread_stack_reset_iter) ( /*OUT*/ThreadId* tid );
137extern Bool VG_(thread_stack_next)       ( /*MOD*/ThreadId* tid,
138                                           /*OUT*/Addr* stack_min,
139                                           /*OUT*/Addr* stack_max );
140
141// Returns .client_stack_highest_word for the given thread
142extern Addr VG_(thread_get_stack_max) ( ThreadId tid );
143
144// Returns how many bytes have been allocated for the stack of the given thread
145extern SizeT VG_(thread_get_stack_size) ( ThreadId tid );
146
147// Returns the bottommost address of the alternate signal stack.
148// See also the man page of sigaltstack().
149extern Addr VG_(thread_get_altstack_min) ( ThreadId tid );
150
151// Returns how many bytes have been allocated for the alternate signal stack.
152// See also the man page of sigaltstack().
153extern SizeT VG_(thread_get_altstack_size) ( ThreadId tid );
154
155// Given a pointer to a function as obtained by "& functionname" in C,
156// produce a pointer to the actual entry point for the function.  For
157// most platforms it's the identity function.  Unfortunately, on
158// ppc64-linux it isn't (sigh).
159extern void* VG_(fnptr_to_fnentry)( void* );
160
161/* Returns the size of the largest guest register that we will
162   simulate in this run.  This depends on both the guest architecture
163   and on the specific capabilities we are simulating for that guest
164   (eg, AVX or non-AVX ?, for amd64). */
165extern Int VG_(machine_get_size_of_largest_guest_register) ( void );
166
167#endif   // __PUB_TOOL_MACHINE_H
168
169/*--------------------------------------------------------------------*/
170/*--- end                                                          ---*/
171/*--------------------------------------------------------------------*/
172