1
2/*---------------------------------------------------------------*/
3/*--- begin                                  guest_x86_defs.h ---*/
4/*---------------------------------------------------------------*/
5
6/*
7   This file is part of Valgrind, a dynamic binary instrumentation
8   framework.
9
10   Copyright (C) 2004-2011 OpenWorks LLP
11      info@open-works.net
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., 51 Franklin Street, Fifth Floor, Boston, MA
26   02110-1301, USA.
27
28   The GNU General Public License is contained in the file COPYING.
29
30   Neither the names of the U.S. Department of Energy nor the
31   University of California nor the names of its contributors may be
32   used to endorse or promote products derived from this software
33   without prior written permission.
34*/
35
36/* Only to be used within the guest-x86 directory. */
37
38#ifndef __VEX_GUEST_X86_DEFS_H
39#define __VEX_GUEST_X86_DEFS_H
40
41
42/*---------------------------------------------------------*/
43/*--- x86 to IR conversion                              ---*/
44/*---------------------------------------------------------*/
45
46/* Convert one x86 insn to IR.  See the type DisOneInstrFn in
47   bb_to_IR.h. */
48extern
49DisResult disInstr_X86 ( IRSB*        irbb,
50                         Bool         put_IP,
51                         Bool         (*resteerOkFn) ( void*, Addr64 ),
52                         Bool         resteerCisOk,
53                         void*        callback_opaque,
54                         UChar*       guest_code,
55                         Long         delta,
56                         Addr64       guest_IP,
57                         VexArch      guest_arch,
58                         VexArchInfo* archinfo,
59                         VexAbiInfo*  abiinfo,
60                         Bool         host_bigendian );
61
62/* Used by the optimiser to specialise calls to helpers. */
63extern
64IRExpr* guest_x86_spechelper ( HChar*   function_name,
65                               IRExpr** args,
66                               IRStmt** precedingStmts,
67                               Int      n_precedingStmts );
68
69/* Describes to the optimiser which part of the guest state require
70   precise memory exceptions.  This is logically part of the guest
71   state description. */
72extern
73Bool guest_x86_state_requires_precise_mem_exns ( Int, Int );
74
75extern
76VexGuestLayout x86guest_layout;
77
78
79/*---------------------------------------------------------*/
80/*--- x86 guest helpers                                 ---*/
81/*---------------------------------------------------------*/
82
83/* --- CLEAN HELPERS --- */
84
85extern UInt  x86g_calculate_eflags_all (
86                UInt cc_op, UInt cc_dep1, UInt cc_dep2, UInt cc_ndep
87             );
88
89VEX_REGPARM(3)
90extern UInt  x86g_calculate_eflags_c (
91                UInt cc_op, UInt cc_dep1, UInt cc_dep2, UInt cc_ndep
92             );
93
94extern UInt  x86g_calculate_condition (
95                UInt/*X86Condcode*/ cond,
96                UInt cc_op,
97                UInt cc_dep1, UInt cc_dep2, UInt cc_ndep
98             );
99
100extern UInt  x86g_calculate_FXAM ( UInt tag, ULong dbl );
101
102extern ULong x86g_calculate_RCR (
103                UInt arg, UInt rot_amt, UInt eflags_in, UInt sz
104             );
105extern ULong x86g_calculate_RCL (
106                UInt arg, UInt rot_amt, UInt eflags_in, UInt sz
107             );
108
109extern UInt x86g_calculate_daa_das_aaa_aas ( UInt AX_and_flags, UInt opcode );
110
111extern UInt x86g_calculate_aad_aam ( UInt AX_and_flags, UInt opcode );
112
113extern ULong x86g_check_fldcw ( UInt fpucw );
114
115extern UInt  x86g_create_fpucw ( UInt fpround );
116
117extern ULong x86g_check_ldmxcsr ( UInt mxcsr );
118
119extern UInt  x86g_create_mxcsr ( UInt sseround );
120
121
122/* Translate a guest virtual_addr into a guest linear address by
123   consulting the supplied LDT/GDT structures.  Their representation
124   must be as specified in pub/libvex_guest_x86.h.  To indicate a
125   translation failure, 1<<32 is returned.  On success, the lower 32
126   bits of the returned result indicate the linear address.
127*/
128extern
129ULong x86g_use_seg_selector ( HWord ldt, HWord gdt,
130                              UInt seg_selector, UInt virtual_addr );
131
132extern ULong x86g_calculate_mmx_pmaddwd  ( ULong, ULong );
133extern ULong x86g_calculate_mmx_psadbw   ( ULong, ULong );
134extern UInt  x86g_calculate_mmx_pmovmskb ( ULong );
135extern UInt  x86g_calculate_sse_pmovmskb ( ULong w64hi, ULong w64lo );
136
137
138/* --- DIRTY HELPERS --- */
139
140extern ULong x86g_dirtyhelper_loadF80le  ( UInt );
141
142extern void  x86g_dirtyhelper_storeF80le ( UInt, ULong );
143
144extern void  x86g_dirtyhelper_CPUID_sse0 ( VexGuestX86State* );
145extern void  x86g_dirtyhelper_CPUID_sse1 ( VexGuestX86State* );
146extern void  x86g_dirtyhelper_CPUID_sse2 ( VexGuestX86State* );
147
148extern void  x86g_dirtyhelper_FINIT ( VexGuestX86State* );
149
150extern void  x86g_dirtyhelper_FXSAVE ( VexGuestX86State*, HWord );
151extern void  x86g_dirtyhelper_FSAVE  ( VexGuestX86State*, HWord );
152extern void  x86g_dirtyhelper_FSTENV ( VexGuestX86State*, HWord );
153
154extern ULong x86g_dirtyhelper_RDTSC ( void );
155
156extern UInt x86g_dirtyhelper_IN  ( UInt portno, UInt sz/*1,2 or 4*/ );
157extern void x86g_dirtyhelper_OUT ( UInt portno, UInt data,
158                                   UInt sz/*1,2 or 4*/ );
159
160extern void x86g_dirtyhelper_SxDT ( void* address,
161                                    UInt op /* 0 or 1 */ );
162
163extern VexEmWarn
164            x86g_dirtyhelper_FXRSTOR ( VexGuestX86State*, HWord );
165
166extern VexEmWarn
167            x86g_dirtyhelper_FRSTOR ( VexGuestX86State*, HWord );
168
169extern VexEmWarn
170            x86g_dirtyhelper_FLDENV ( VexGuestX86State*, HWord );
171
172
173/*---------------------------------------------------------*/
174/*--- Condition code stuff                              ---*/
175/*---------------------------------------------------------*/
176
177/* eflags masks */
178#define X86G_CC_SHIFT_O   11
179#define X86G_CC_SHIFT_S   7
180#define X86G_CC_SHIFT_Z   6
181#define X86G_CC_SHIFT_A   4
182#define X86G_CC_SHIFT_C   0
183#define X86G_CC_SHIFT_P   2
184
185#define X86G_CC_MASK_O    (1 << X86G_CC_SHIFT_O)
186#define X86G_CC_MASK_S    (1 << X86G_CC_SHIFT_S)
187#define X86G_CC_MASK_Z    (1 << X86G_CC_SHIFT_Z)
188#define X86G_CC_MASK_A    (1 << X86G_CC_SHIFT_A)
189#define X86G_CC_MASK_C    (1 << X86G_CC_SHIFT_C)
190#define X86G_CC_MASK_P    (1 << X86G_CC_SHIFT_P)
191
192/* FPU flag masks */
193#define X86G_FC_SHIFT_C3   14
194#define X86G_FC_SHIFT_C2   10
195#define X86G_FC_SHIFT_C1   9
196#define X86G_FC_SHIFT_C0   8
197
198#define X86G_FC_MASK_C3    (1 << X86G_FC_SHIFT_C3)
199#define X86G_FC_MASK_C2    (1 << X86G_FC_SHIFT_C2)
200#define X86G_FC_MASK_C1    (1 << X86G_FC_SHIFT_C1)
201#define X86G_FC_MASK_C0    (1 << X86G_FC_SHIFT_C0)
202
203
204/* %EFLAGS thunk descriptors.  A four-word thunk is used to record
205   details of the most recent flag-setting operation, so the flags can
206   be computed later if needed.  It is possible to do this a little
207   more efficiently using a 3-word thunk, but that makes it impossible
208   to describe the flag data dependencies sufficiently accurately for
209   Memcheck.  Hence 4 words are used, with minimal loss of efficiency.
210
211   The four words are:
212
213      CC_OP, which describes the operation.
214
215      CC_DEP1 and CC_DEP2.  These are arguments to the operation.
216         We want Memcheck to believe that the resulting flags are
217         data-dependent on both CC_DEP1 and CC_DEP2, hence the
218         name DEP.
219
220      CC_NDEP.  This is a 3rd argument to the operation which is
221         sometimes needed.  We arrange things so that Memcheck does
222         not believe the resulting flags are data-dependent on CC_NDEP
223         ("not dependent").
224
225   To make Memcheck believe that (the definedness of) the encoded
226   flags depends only on (the definedness of) CC_DEP1 and CC_DEP2
227   requires two things:
228
229   (1) In the guest state layout info (x86guest_layout), CC_OP and
230       CC_NDEP are marked as always defined.
231
232   (2) When passing the thunk components to an evaluation function
233       (calculate_condition, calculate_eflags, calculate_eflags_c) the
234       IRCallee's mcx_mask must be set so as to exclude from
235       consideration all passed args except CC_DEP1 and CC_DEP2.
236
237   Strictly speaking only (2) is necessary for correctness.  However,
238   (1) helps efficiency in that since (2) means we never ask about the
239   definedness of CC_OP or CC_NDEP, we may as well not even bother to
240   track their definedness.
241
242   When building the thunk, it is always necessary to write words into
243   CC_DEP1 and CC_DEP2, even if those args are not used given the
244   CC_OP field (eg, CC_DEP2 is not used if CC_OP is CC_LOGIC1/2/4).
245   This is important because otherwise Memcheck could give false
246   positives as it does not understand the relationship between the
247   CC_OP field and CC_DEP1 and CC_DEP2, and so believes that the
248   definedness of the stored flags always depends on both CC_DEP1 and
249   CC_DEP2.
250
251   However, it is only necessary to set CC_NDEP when the CC_OP value
252   requires it, because Memcheck ignores CC_NDEP, and the evaluation
253   functions do understand the CC_OP fields and will only examine
254   CC_NDEP for suitable values of CC_OP.
255
256   A summary of the field usages is:
257
258   Operation          DEP1               DEP2               NDEP
259   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
260
261   add/sub/mul        first arg          second arg         unused
262
263   adc/sbb            first arg          (second arg)
264                                         XOR old_carry      old_carry
265
266   and/or/xor         result             zero               unused
267
268   inc/dec            result             zero               old_carry
269
270   shl/shr/sar        result             subshifted-        unused
271                                         result
272
273   rol/ror            result             zero               old_flags
274
275   copy               old_flags          zero               unused.
276
277
278   Therefore Memcheck will believe the following:
279
280   * add/sub/mul -- definedness of result flags depends on definedness
281     of both args.
282
283   * adc/sbb -- definedness of result flags depends on definedness of
284     both args and definedness of the old C flag.  Because only two
285     DEP fields are available, the old C flag is XOR'd into the second
286     arg so that Memcheck sees the data dependency on it.  That means
287     the NDEP field must contain a second copy of the old C flag
288     so that the evaluation functions can correctly recover the second
289     arg.
290
291   * and/or/xor are straightforward -- definedness of result flags
292     depends on definedness of result value.
293
294   * inc/dec -- definedness of result flags depends only on
295     definedness of result.  This isn't really true -- it also depends
296     on the old C flag.  However, we don't want Memcheck to see that,
297     and so the old C flag must be passed in NDEP and not in DEP2.
298     It's inconceivable that a compiler would generate code that puts
299     the C flag in an undefined state, then does an inc/dec, which
300     leaves C unchanged, and then makes a conditional jump/move based
301     on C.  So our fiction seems a good approximation.
302
303   * shl/shr/sar -- straightforward, again, definedness of result
304     flags depends on definedness of result value.  The subshifted
305     value (value shifted one less) is also needed, but its
306     definedness is the same as the definedness of the shifted value.
307
308   * rol/ror -- these only set O and C, and leave A Z C P alone.
309     However it seems prudent (as per inc/dec) to say the definedness
310     of all resulting flags depends on the definedness of the result,
311     hence the old flags must go in as NDEP and not DEP2.
312
313   * rcl/rcr are too difficult to do in-line, and so are done by a
314     helper function.  They are not part of this scheme.  The helper
315     function takes the value to be rotated, the rotate amount and the
316     old flags, and returns the new flags and the rotated value.
317     Since the helper's mcx_mask does not have any set bits, Memcheck
318     will lazily propagate undefinedness from any of the 3 args into
319     both results (flags and actual value).
320*/
321enum {
322    X86G_CC_OP_COPY=0,  /* DEP1 = current flags, DEP2 = 0, NDEP = unused */
323                        /* just copy DEP1 to output */
324
325    X86G_CC_OP_ADDB,    /* 1 */
326    X86G_CC_OP_ADDW,    /* 2 DEP1 = argL, DEP2 = argR, NDEP = unused */
327    X86G_CC_OP_ADDL,    /* 3 */
328
329    X86G_CC_OP_SUBB,    /* 4 */
330    X86G_CC_OP_SUBW,    /* 5 DEP1 = argL, DEP2 = argR, NDEP = unused */
331    X86G_CC_OP_SUBL,    /* 6 */
332
333    X86G_CC_OP_ADCB,    /* 7 */
334    X86G_CC_OP_ADCW,    /* 8 DEP1 = argL, DEP2 = argR ^ oldCarry, NDEP = oldCarry */
335    X86G_CC_OP_ADCL,    /* 9 */
336
337    X86G_CC_OP_SBBB,    /* 10 */
338    X86G_CC_OP_SBBW,    /* 11 DEP1 = argL, DEP2 = argR ^ oldCarry, NDEP = oldCarry */
339    X86G_CC_OP_SBBL,    /* 12 */
340
341    X86G_CC_OP_LOGICB,  /* 13 */
342    X86G_CC_OP_LOGICW,  /* 14 DEP1 = result, DEP2 = 0, NDEP = unused */
343    X86G_CC_OP_LOGICL,  /* 15 */
344
345    X86G_CC_OP_INCB,    /* 16 */
346    X86G_CC_OP_INCW,    /* 17 DEP1 = result, DEP2 = 0, NDEP = oldCarry (0 or 1) */
347    X86G_CC_OP_INCL,    /* 18 */
348
349    X86G_CC_OP_DECB,    /* 19 */
350    X86G_CC_OP_DECW,    /* 20 DEP1 = result, DEP2 = 0, NDEP = oldCarry (0 or 1) */
351    X86G_CC_OP_DECL,    /* 21 */
352
353    X86G_CC_OP_SHLB,    /* 22 DEP1 = res, DEP2 = res', NDEP = unused */
354    X86G_CC_OP_SHLW,    /* 23 where res' is like res but shifted one bit less */
355    X86G_CC_OP_SHLL,    /* 24 */
356
357    X86G_CC_OP_SHRB,    /* 25 DEP1 = res, DEP2 = res', NDEP = unused */
358    X86G_CC_OP_SHRW,    /* 26 where res' is like res but shifted one bit less */
359    X86G_CC_OP_SHRL,    /* 27 */
360
361    X86G_CC_OP_ROLB,    /* 28 */
362    X86G_CC_OP_ROLW,    /* 29 DEP1 = res, DEP2 = 0, NDEP = old flags */
363    X86G_CC_OP_ROLL,    /* 30 */
364
365    X86G_CC_OP_RORB,    /* 31 */
366    X86G_CC_OP_RORW,    /* 32 DEP1 = res, DEP2 = 0, NDEP = old flags */
367    X86G_CC_OP_RORL,    /* 33 */
368
369    X86G_CC_OP_UMULB,   /* 34 */
370    X86G_CC_OP_UMULW,   /* 35 DEP1 = argL, DEP2 = argR, NDEP = unused */
371    X86G_CC_OP_UMULL,   /* 36 */
372
373    X86G_CC_OP_SMULB,   /* 37 */
374    X86G_CC_OP_SMULW,   /* 38 DEP1 = argL, DEP2 = argR, NDEP = unused */
375    X86G_CC_OP_SMULL,   /* 39 */
376
377    X86G_CC_OP_NUMBER
378};
379
380typedef
381   enum {
382      X86CondO      = 0,  /* overflow           */
383      X86CondNO     = 1,  /* no overflow        */
384
385      X86CondB      = 2,  /* below              */
386      X86CondNB     = 3,  /* not below          */
387
388      X86CondZ      = 4,  /* zero               */
389      X86CondNZ     = 5,  /* not zero           */
390
391      X86CondBE     = 6,  /* below or equal     */
392      X86CondNBE    = 7,  /* not below or equal */
393
394      X86CondS      = 8,  /* negative           */
395      X86CondNS     = 9,  /* not negative       */
396
397      X86CondP      = 10, /* parity even        */
398      X86CondNP     = 11, /* not parity even    */
399
400      X86CondL      = 12, /* jump less          */
401      X86CondNL     = 13, /* not less           */
402
403      X86CondLE     = 14, /* less or equal      */
404      X86CondNLE    = 15, /* not less or equal  */
405
406      X86CondAlways = 16  /* HACK */
407   }
408   X86Condcode;
409
410#endif /* ndef __VEX_GUEST_X86_DEFS_H */
411
412/*---------------------------------------------------------------*/
413/*--- end                                    guest_x86_defs.h ---*/
414/*---------------------------------------------------------------*/
415