VEX2 and VEX3 prefixed instructions should be implemented
[dyninst.git] / common / src / arch-x86.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 // $Id: arch-x86.h,v 1.67 2008/10/28 18:42:39 bernat Exp $
32 // x86 instruction declarations
33
34 #ifndef _ARCH_X86_H
35 #define _ARCH_X86_H
36
37 #include "common/src/Types.h"
38 #include <stdio.h>
39 #include <common/src/Vector.h>
40 #include <set>
41 #include <map>
42 #include <vector>
43 #include "dyn_regs.h"
44 #include "entryIDs.h"
45
46 #include "common/src/ia32_locations.h"
47
48 #if defined(i386_unknown_nt4_0)
49 // disable VC++ warning C4800: (performance warning)
50 // forcing 'unsigned int' value to bool 'true' or 'false'
51 #pragma warning (disable : 4800)
52 #endif
53
54 namespace NS_x86 {
55
56 /* operand types */
57 typedef char byte_t;   /* a byte operand */
58 typedef short word_t;  /* a word (16-bit) operand */
59 typedef int dword_t;   /* a double word (32-bit) operand */
60
61 // The general machine registers.
62 // These values are taken from the Pentium manual and CANNOT be changed.
63
64 // 32-bit
65 #define REGNUM_EAX 0
66 #define REGNUM_ECX 1
67 #define REGNUM_EDX 2
68 #define REGNUM_EBX 3
69 #define REGNUM_ESP 4
70 #define REGNUM_EBP 5
71 #define REGNUM_ESI 6
72 #define REGNUM_EDI 7
73
74 // 64-bit
75 enum AMD64_REG_NUMBERS {
76     REGNUM_RAX = 0,
77     REGNUM_RCX,
78     REGNUM_RDX,
79     REGNUM_RBX,
80     REGNUM_RSP,
81     REGNUM_RBP,
82     REGNUM_RSI,
83     REGNUM_RDI,
84     REGNUM_R8,
85     REGNUM_R9,
86     REGNUM_R10,
87     REGNUM_R11,
88     REGNUM_R12,
89     REGNUM_R13,
90     REGNUM_R14,
91     REGNUM_R15,
92     REGNUM_DUMMYFPR,
93     REGNUM_OF,
94     REGNUM_SF,
95     REGNUM_ZF,
96     REGNUM_AF,
97     REGNUM_PF,
98     REGNUM_CF,
99     REGNUM_TF,
100     REGNUM_IF,
101     REGNUM_DF,
102     REGNUM_NT,
103     REGNUM_RF,
104     REGNUM_MM0,
105     REGNUM_MM1,
106     REGNUM_MM2,
107     REGNUM_MM3,
108     REGNUM_MM4,
109     REGNUM_MM5,
110     REGNUM_MM6,
111     REGNUM_MM7,
112     REGNUM_XMM0,
113     REGNUM_XMM1,
114     REGNUM_XMM2,
115     REGNUM_XMM3,
116     REGNUM_XMM4,
117     REGNUM_XMM5,
118     REGNUM_XMM6,
119     REGNUM_XMM7,
120     REGNUM_XMM8,
121     REGNUM_XMM9,
122     REGNUM_XMM10,
123     REGNUM_XMM11,
124     REGNUM_XMM12,
125     REGNUM_XMM13,
126     REGNUM_XMM14,
127     REGNUM_XMM15,
128     REGNUM_EFLAGS,
129     REGNUM_FS,
130     REGNUM_GS,
131     REGNUM_YMM0,
132     REGNUM_YMM1,
133     REGNUM_YMM2,
134     REGNUM_YMM3,
135     REGNUM_YMM4,
136     REGNUM_YMM5,
137     REGNUM_YMM6,
138     REGNUM_YMM7,
139     REGNUM_YMM8,
140     REGNUM_YMM9,
141     REGNUM_YMM10,
142     REGNUM_YMM11,
143     REGNUM_YMM12,
144     REGNUM_YMM13,
145     REGNUM_YMM14,
146     REGNUM_YMM15,
147     REGNUM_IGNORED
148 }
149 ;
150
151 #if defined(arch_x86_64)
152 #define maxGPR 16
153 #else
154 #define maxGPR 8
155 #endif 
156
157 #define READ_OP 0
158 #define WRITE_OP 1
159
160 /* operand sizes */
161 #define byteSzB (1)    /* size of a byte operand */
162 #define wordSzB (2)    /* size of a word operand */
163 #define dwordSzB (4)   /* size of a dword operand */
164 #define qwordSzB (8)   /* size of a qword operand */
165 #define dqwordSzB (16)   /* size of a double qword (oword) operand */
166
167 /* The following values are or'ed together to form an instruction type descriptor */
168 /* the instruction types of interest */
169 #define IS_CALL (1<<1)   /* call instruction */
170 #define IS_RET  (1<<2)   /* near return instruction */
171 #define IS_RETF (1<<3)   /* far return instruction */
172 #define IS_JUMP (1<<4)   /* jump instruction */
173 #define IS_JCC  (1<<5)   /* conditional jump instruction */
174 #define ILLEGAL (1<<6)   /* illegal instruction */
175 #define PRVLGD  (1<<7)   /* privileged */
176 #define IS_RETC (1<<8)   /* return and pop bytes off of stack*/
177 #define IS_NOP  (1<<9)   /* Nop, Lea--lea is only sometime a return, be sure to double check */
178
179 /* addressing modes for calls and jumps */
180 #define REL_B   (1<<10)  /* relative address, byte offset */
181 #define REL_W   (1<<11)  /* relative address, word offset */
182 #define REL_D   (1<<12)  /* relative address, dword offset */
183 #define REL_X   (1<<13)  /* relative address, word or dword offset */
184 #define INDIR   (1<<14)  /* indirect (register or memory) address */
185 #define PTR_WW  (1<<15)  /* 4-byte pointer */
186 #define PTR_WD  (1<<16)  /* 6-byte pointer */
187 #define PTR_WX  (1<<17)  /* 4 or 6-byte pointer */
188 #define REL_D_DATA (1<<18) /* AMD64 RIP-relative data addressing */
189
190 /* prefixes */
191 #define PREFIX_INST   (1<<20) /* instruction prefix */
192 #define PREFIX_SEG    (1<<21) /* segment override prefix */
193 #define PREFIX_OPR    (1<<22) /* operand size override */
194 #define PREFIX_ADDR   (1<<23) /* address size override */
195 #define PREFIX_REX    (1<<24) /* AMD64 REX prefix */
196 #define PREFIX_OPCODE (1<<25) /* prefix is part of opcode (SSE) */
197
198 /* end of instruction type descriptor values */
199
200
201 /* opcodes of some one byte opcode instructions */
202 /* ADD */
203 #define ADD_EB_GB (0x00)
204 #define ADD_EV_GV (0x01)
205 #define ADD_GB_EB (0x02)
206 #define ADD_GV_EV (0x03)
207 #define ADD_AL_LB (0x04)
208 #define ADD_RAX_LZ (0x05)
209
210 #define PUSHES    (0x06) /* Invalid in 64 bit mode */
211 #define POPES     (0x07) /* Invalid in 64 bit mode */
212
213 /* OR */
214 #define OR_EB_GB (0x08)
215 #define OR_EV_GV (0x09)
216 #define OR_GB_EB (0x0A)
217 #define OR_GV_EV (0x0B)
218 #define OR_AL_LB (0x0C)
219 #define OR_RAX_LZ (0x0D)
220
221 #define PUSHCS    (0x0E) /* Invalid in 64 bit mode */
222 #define TWO_BYTE_OPCODE (0x0F)
223
224 /* ADC */
225 #define ADC_EB_GB (0x10)
226 #define ADC_EV_GV (0x11)
227 #define ADC_GB_EB (0x12)
228 #define ADC_GV_EV (0x13)
229 #define ADC_AL_LB (0x14)
230 #define ADC_RAX_LZ (0x15)
231
232 #define PUSHSS    (0x16) /* Invalid in 64 bit mode */
233 #define POPSS     (0x17) /* Invalid in 64 bit mode */
234
235 /* SBB */
236 #define SBB_EB_GB (0x18)
237 #define SBB_EV_GV (0x19)
238 #define SBB_GB_EB (0x1A)
239 #define SBB_GV_EV (0x1B)
240 #define SBB_AL_LB (0x1C)
241 #define SBB_RAX_LZ (0x1D)
242
243 #define PUSH_DS  (0x1E) /* Invalid in 64 bit mode */
244 #define POP_DS   (0X1F) /* Invalid in 64 bit mode */
245
246 /* AND */
247 #define AND_EB_GB (0x20)
248 #define AND_EV_GV (0x21)
249 #define AND_GB_EB (0x22)
250 #define AND_GV_EV (0x23)
251 #define AND_AL_LB (0x24)
252 #define AND_RAX_LZ (0x25)
253
254 #define SEG_ES (0x26) /* Null prefix in 64-bit mode */
255 #define DAA    (0x27) /* Invalid in 64-bit mode */
256
257 /* SUB */
258 #define SUB_EB_GB (0x28)
259 #define SUB_EV_GV (0x29)
260 #define SUB_GB_EB (0x2A)
261 #define SUB_GV_EV (0x2B)
262 #define SUB_AL_LB (0x2C)
263 #define SUB_RAX_LZ (0x2D)
264
265 //(0x2E)
266 //   (0x2F)
267
268 /* XOR */
269 #define XOR_EB_GB (0x30)
270 #define XOR_EV_GV (0x31)
271 #define XOR_GB_EB (0x32)
272 #define XOR_GV_EV (0x33)
273 #define XOR_AL_LB (0x34)
274 #define XOR_RAX_LZ (0x35)
275
276 #define XOR_RM16_R16 (0x31)
277 #define XOR_RM32_R32 (0x31)
278 #define XOR_R8_RM8 (0x32)
279 #define XOR_R16_RM16 (0x33)
280 #define XOR_R32_RM32 (0x33)
281
282 #define SEG_SS (0x36) /* Null prefix in 64 bit mode */
283 #define AAA (0x37)    /* Invalid in 64-bit mode */
284
285
286 /* CMP */
287 #define CMP_EB_GB (0x38)
288 #define CMP_EV_GV (0x39)
289 #define CMP_GB_EB (0x3A)
290 #define CMP_GV_EV (0x3B)
291 #define CMP_AL_LB (0x3C)
292 #define CMP_RAX_LZ (0x3D)
293
294 #define TEST_EV_GV (0x85)
295 //   (0x3E)
296 //   (0x3F)
297
298 /* INC - REX Prefixes in 64 bit mode*/
299 #define INC_EAX  (0x40)
300 #define INC_ECX  (0x41)
301 #define INC_EDX  (0x42)
302 #define INC_EBX  (0x43)
303 #define INC_ESP  (0x44)
304 #define INC_EBP  (0x45)
305 #define INC_ESI  (0x46)
306 #define INC_EDI  (0x47)
307
308 /* DEC - REX Prefixes in 64 bit mode */
309 #define DEC_EAX  (0x48)
310 #define DEC_ECX  (0x49)
311 #define DEC_EDX  (0x50)
312 #define DEC_EBX  (0x51)
313 #define DEC_ESP  (0x52)
314 #define DEC_EBP  (0x53)
315 #define DEC_ESI  (0x54)
316 #define DEC_EDI  (0x55)
317
318 /* PUSH */
319 #define PUSHEAX  (0x50)
320 #define PUSHECX  (0x51)
321 #define PUSHEDX  (0x52)
322 #define PUSHEBX  (0x53)
323 #define PUSHESP  (0x54)
324 #define PUSHEBP  (0x55)
325 #define PUSHESI  (0x56)
326 #define PUSHEDI  (0x57)
327
328 /* POP */
329 #define POP_EAX  (0x58)
330 #define POP_ECX  (0x59)
331 #define POP_EDX  (0x5A)
332 #define POP_EBX  (0x5b)
333 #define POP_ESP  (0x5c)
334 #define POP_EBP  (0x5d)
335 #define POP_EBI  (0x5e)
336 #define POP_EDI  (0x5f)
337
338
339 #define PUSHAD   (0x60)
340 #define POPAD    (0x61)
341
342
343
344
345 #define JE_R8    (0x74)
346 #define JNE_R8   (0x75)
347 #define JL_R8    (0x7C)
348 #define JLE_R8   (0x7E)
349 #define JG_R8    (0x7F)
350 #define JGE_R8   (0x7D)
351
352
353 #define MOVREGMEM_REG (0x8b) 
354 #define MOV_R8_TO_RM8 (0x88)     //move r8 to r/m8
355 #define MOV_R16_TO_RM16 (0x89)   //move r16 to r/m16
356 #define MOV_R32_TO_RM32 (0x89)   //move r32 to r/m32
357 #define MOV_RM8_TO_R8 (0x8A)
358 #define MOV_RM16_TO_R16 (0x8b)
359 #define MOV_RM32_TO_R32 (0x8b)
360
361
362
363 #define NOP      (0x90)
364 #define PUSHFD   (0x9C)
365 #define POPFD    (0x9D)
366
367
368 #define JCXZ     (0xE3)
369
370
371
372
373
374
375 #define FSAVE    (0x9BDD)
376 #define FSAVE_OP (6)
377
378 #define FRSTOR   (0xDD)
379 #define FRSTOR_OP (4)
380
381 const unsigned char SYSCALL[] = {0x0F, 0x05};
382
383 /* limits */
384 #define MIN_IMM8 (-128)
385 #define MAX_IMM8 (127)
386 #define MIN_IMM16 (-32768)
387 #define MAX_IMM16 (32767)
388
389 // Size of floating point information saved by FSAVE
390 #define FSAVE_STATE_SIZE 108
391
392 // Prefix groups
393 enum {
394   RepGroup = 0
395 };
396
397
398 #ifndef VEX_PREFIX_MASKS
399 #define VEX_PREFIX_MASKS
400
401 /* Masks to help decode vex prefixes */
402
403 /** VEX 3 masks (2nd byte) */
404 #define PREFIX_VEX3 ((unsigned char)0xC4)
405 #define PREFIX_VEX2 ((unsigned char)0xC5)
406 #define VEX3_REXX   (1 << 6)
407 #define VEX3_REXB   (1 << 5)
408 #define VEX3_M      ((1 << 5) - 1)
409 #define VEX3_W      (1 << 7)
410
411 /* VEX2 and VEX3 share these bits on their final byte  */
412 #define VEX_VVVV   (((1 << 4) - 1) << 3)
413 #define VEX_L      (1 << 2)
414 #define VEX_PP     ((1 << 2) - 1)
415 #define VEX_REXR   (1 << 7)
416
417 /* VEX mask helper macros */
418 #define VEXGET_VVVV(b)  (char)((b & VEX_VVVV) >> 3)
419 #define VEXGET_L(b)     (char)((b & VEX_L) >> 2)
420 #define VEXGET_PP(b)    (char)(b & VEX_PP)
421
422 #define VEX3GET_W(b)    (char)((b & VEX3_W) >> 7)
423 #define VEX3GET_M(b)    (b & VEX3_M)
424
425 /** EVEX masks */
426 #define PREFIX_EVEX ((unsigned char)0x62)
427
428 #define EVEXGET_W(b) VEX3GET_W(b)
429 #define EVEXGET_L1(b) (unsigned char)((1 << 5) & (b))
430 #define EVEXGET_L2(b) (unsigned char)((1 << 6) & (b))
431 #define EVEXGET_L(b) (unsigned char)((EVEXGET_L1(b)) | (EVEXGET_L2(b)))
432 #define EVEXGET_PP(b) (unsigned char)(3 & (b))
433 #define EVEXGET_MM(b) (unsigned char)(3 & (b))
434 #define EVEXGET_AAA(b) (unsigned char)(7 & (b))
435
436 #endif
437
438 #ifndef PREFIX_LOCK
439 #define PREFIX_LOCK   (unsigned char)(0xF0)
440 #define PREFIX_REPNZ  (unsigned char)(0xF2)
441 #define PREFIX_REP    (unsigned char)(0xF3)
442
443 #define PREFIX_SEGCS  (unsigned char)(0x2E)
444 #define PREFIX_SEGSS  (unsigned char)(0x36)
445 #define PREFIX_SEGDS  (unsigned char)(0x3E)
446 #define PREFIX_SEGES  (unsigned char)(0x26)
447 #define PREFIX_SEGFS  (unsigned char)(0x64)
448 #define PREFIX_SEGGS  (unsigned char)(0x65)
449
450 #define PREFIX_XOP  (unsigned char)(0x8F)
451
452 #define PREFIX_BRANCH0 (unsigned char)(0x2E)
453 #define PREFIX_BRANCH1 (unsigned char)(0x3E)
454
455 #define PREFIX_SZOPER  (unsigned char)(0x66)
456 #define PREFIX_SZADDR  (unsigned char)(0x67)
457 #endif
458
459 COMMON_EXPORT void ia32_set_mode_64(bool mode);
460 COMMON_EXPORT bool ia32_is_mode_64();
461
462 // addressing methods (see appendix A-2)
463 // I've added am_reg (for registers implicitely encoded in instruciton), 
464 // and am_stackX for stack operands [this kinda' messy since there are actually two operands:
465 // the stack byte/word/dword and the (E)SP register itself - but is better than naught]
466 // added: am_reg, am_stack, am_allgprs
467 // ADDED: am_ImplImm for implicit immediates
468 // ADDED: am_RM, am_UM,
469 enum { am_A=1, am_C, am_D, am_E, am_F, am_G, am_H, am_I, am_J, am_M, //10 
470       am_N, am_O, am_P, am_Q, am_R, am_S, am_T, am_U, am_UM, am_V, am_W, am_X, // 20
471       am_Y, am_reg, am_stackH, am_stackP, am_allgprs, am_VR, am_tworeghack, am_ImplImm, am_RM }; // pusH and poP produce different addresses
472
473 // operand types - idem, but I invented quite a few to make implicit operands explicit.
474 // ADDED: op_y
475 enum { op_a=1, op_b, op_c, op_d, op_dq, op_p, op_pd, op_pi, op_ps, op_q, // 10
476        op_qq, op_s, op_sd, op_ss, op_si, op_v, op_w, op_y, op_z, op_lea, op_allgprs, op_512,
477        op_f, op_dbl, op_14, op_28, op_edxeax, op_ecxebx};
478
479
480 // tables and pseudotables
481 enum {
482   t_ill=0, t_oneB, t_twoB, t_threeB, t_threeB2, t_prefixedSSE, t_coprocEsc, 
483   t_grp, t_sse, t_sse_mult, t_sse_bis, t_sse_bis_mult, 
484   t_sse_ter, t_sse_ter_mult, t_grpsse, t_3dnow, t_vex2, t_vex3, t_done=99
485 };
486
487 // registers used for memory access
488 enum { mRAX=0, mRCX, mRDX, mRBX,
489        mRSP, mRBP, mRSI, mRDI,
490        mR8, mR9, mR10, mR11, 
491        mR12,mR13, MR14, mR15, mRIP };
492
493 enum { mEAX=0, mECX, mEDX, mEBX,
494        mESP, mEBP, mESI, mEDI };
495
496 enum { mAX=0, mCX, mDX, mBX,
497        mSP, mBP, mSI, mDI };
498
499
500 // operand semantic - these make explicit all the implicit stuff in the Intel tables
501 // they are needed for memory access, but may be useful for other things: dataflow etc.
502 // Instructions that do not deal with memory are not tested, so caveat emptor...
503 // Also note that the stack is never specified as an operand in Intel tables, so it
504 // has to be dealt with here.
505
506 enum { sNONE=0, // the instruction does something that cannot be classified as read/write (by me)
507        s1R,     // reads one operand, e.g. jumps
508        s1W,     // e.g. lea
509        s1RW,    // one operand read and written, e.g. inc
510        s1R2R,   // reads two operands, e.g. cmp
511        s1W2R,   // second operand read, first operand written (e.g. mov)
512        s1RW2R,  // two operands read, first written (e.g. add)
513        s1RW2RW, // e.g. xchg
514        s1W2R3R, // e.g. imul
515        s1W2W3R, // e.g. les
516        s1W2RW3R, // some mul
517        s1R2RW, // (stack) push
518        s1W2RW, // pop
519        s1W2R3RW, // additional push/pop
520        s1RW2R3R, // shld/shrd
521        s1RW2RW3R, // [i]div, cmpxch8b
522        s1RW2R3RW, // v[p]gather[ps, pd, qq, qd]
523        s1R2R3R,
524
525 /* Only 4 operands below here */
526        s1W2R3R4R,
527        s1RW2R3R4R 
528 }; // should be strictly less than 2^17 otherwise adjust FPOS below
529
530 /* This should equal the first operand semantic where 4 operands are used. */
531 #define s4OP s1W2R3R4R
532
533
534 struct modRMByte {
535   unsigned mod : 2;
536   unsigned reg : 3;
537   unsigned rm  : 3;
538 };
539
540 struct sIBByte {
541   unsigned scale : 2;
542   unsigned index : 3;
543   unsigned base  : 3;
544 };
545
546
547 class ia32_prefixes
548 {
549   friend bool ia32_decode_prefixes(const unsigned char* addr, ia32_prefixes&,
550                                    ia32_locations *loc);
551   friend bool ia32_decode_rex(const unsigned char* addr, ia32_prefixes&,
552                               ia32_locations *loc);
553  private:
554   unsigned int count;
555   // At most 4 prefixes are allowed for Intel 32-bit CPUs
556   // There also 4 groups, so this array is 0 if no prefix
557   // from that group is present, otherwise it contains the
558   // prefix opcode
559   // For 64-bit CPUs, an additional REX prefix is possible,
560   // so this array is extended to 5 elements
561   unsigned char prfx[5];
562   unsigned char opcode_prefix;
563   
564  public:
565   unsigned int getCount() const { return count; }
566   unsigned char getPrefix(unsigned char group) const { assert(group <= 4); return prfx[group]; }
567   bool rexW() const { return prfx[4] & 0x8; }
568   bool rexR() const { return prfx[4] & 0x4; }
569   bool rexX() const { return prfx[4] & 0x2; }
570   bool rexB() const { return prfx[4] & 0x1; }
571   unsigned char getOpcodePrefix() const { return opcode_prefix; }
572   unsigned char getAddrSzPrefix() const { return prfx[3]; }
573   unsigned char getOperSzPrefix() const { return prfx[2]; }
574   unsigned char vex_prefix[3]; /* support up to EVEX (VEX-512) */
575   unsigned char vex_l; /* l bit for VEX2 and VEX3 */
576   unsigned char vex_w; /* w bit for VEX2 and VEX3 */
577   bool vex_present; /* Does this instruction have a vex prefix?  */
578   int sse_mult; /* 0 VEX2, 1 VEX3, 2 EVEX */
579 };
580
581 // helper routine to tack-on rex bit when needed
582 inline int apply_rex_bit(int reg, bool rex_bit)
583 {
584     if (rex_bit)
585         return reg + 8;
586     else
587         return reg;
588 }
589
590 //VG(6/20/02): To support Paradyn without forcing it to include BPatch_memoryAccess, we
591 //             define this IA-32 "specific" class to encapsulate the same info - yuck
592
593 struct ia32_memacc
594 {
595   bool is;
596   bool read;
597   bool write;
598   bool nt;     // non-temporal, e.g. movntq...
599   bool prefetch;
600
601   int addr_size; // size of address in 16-bit words
602   long imm;
603   int scale;
604   int regs[2]; // register encodings (in ISA order): 0-7
605                // (E)AX, (E)CX, (E)DX, (E)BX
606                // (E)SP, (E)BP, (E)SI, (E)DI
607
608   int size;
609   int sizehack;  // register (E)CX or string based
610   int prefetchlvl; // prefetch level
611   int prefetchstt; // prefetch state (AMD)
612
613   ia32_memacc() : is(false), read(false), write(false), nt(false), 
614        prefetch(false), addr_size(2), imm(0), scale(0), size(0), sizehack(0),
615        prefetchlvl(-1), prefetchstt(-1)
616   {
617     regs[0] = -1;
618     regs[1] = -1;
619   }
620
621   void set16(int reg0, int reg1, long disp)
622   { 
623     is = true;
624     addr_size  = 1; 
625     regs[0] = reg0; 
626     regs[1] = reg1; 
627     imm     = disp;
628   }
629
630   void set(int reg, long disp, int addr_sz)
631   { 
632     is = true;
633     addr_size = addr_sz;
634     regs[0] = reg; 
635     imm     = disp;
636   }
637
638   void set_sib(int base, int scal, int indx, long disp, int addr_sz)
639   {
640     is = true;
641     addr_size = addr_sz;
642     regs[0] = base;
643     regs[1] = indx;
644     scale   = scal;
645     imm     = disp;
646   }
647
648   void setXY(int reg, int _size, int _addr_size)
649   {
650     is = true;
651     regs[0] = reg;
652     size = _size;
653     addr_size = _addr_size;
654   }
655
656   void print();
657 };
658
659 enum sizehacks {
660   shREP=1,
661   shREPECMPS,
662   shREPESCAS,
663   shREPNECMPS,
664   shREPNESCAS
665 };
666
667
668 struct ia32_condition
669 {
670   bool is;
671   // TODO: add a field/hack for ECX [not needed for CMOVcc, but for Jcc]
672   int tttn;
673
674   ia32_condition() : is(false), tttn(-1) {}
675   void set(int _tttn) { is = true; tttn = _tttn; }
676 };
677
678 bool ia32_decode_prefixes(const unsigned char* addr, ia32_prefixes&,
679                           ia32_locations *loc = NULL);
680
681
682 struct ia32_operand {  // operand as given in Intel book tables
683   unsigned int admet;  // addressing method
684   unsigned int optype; // operand type;
685 };
686
687 // An instruction table entry
688 struct ia32_entry {
689   COMMON_EXPORT const char* name(ia32_locations* locs = NULL);
690   COMMON_EXPORT entryID getID(ia32_locations* locs = NULL) const;
691   // returns true if any flags are read/written, false otherwise
692   COMMON_EXPORT bool flagsUsed(std::set<Dyninst::MachRegister>& flagsRead, std::set<Dyninst::MachRegister>& flagsWritten,
693                  ia32_locations* locs = NULL);
694   entryID id;
695   unsigned int otable;       // which opcode table is next; if t_done it is the current one
696   unsigned char tabidx;      // at what index to look, 0 if it easy to deduce from opcode
697   bool hasModRM;             // true if the instruction has a MOD/RM byte
698   ia32_operand operands[3];  // operand descriptors
699   unsigned int legacyType;   // legacy type of the instruction (e.g. (IS_CALL | REL_W))
700   // code to decode memory access - this field should be seen as two 16 bit fields
701   // the lower half gives operand semantics, e.g. s1RW2R, the upper half is a fXXX hack if needed
702   // before hating me for this: it takes a LOT less time to add ONE field to ~2000 table lines!
703   unsigned int opsema;  
704 };
705
706 using std::vector;
707 struct flagInfo
708 {
709   flagInfo(const vector<Dyninst::MachRegister>& rf, const vector<Dyninst::MachRegister>& wf) : readFlags(rf), writtenFlags(wf)
710   {
711   }
712   flagInfo() 
713   {
714   }
715   
716   vector<Dyninst::MachRegister> readFlags;
717   vector<Dyninst::MachRegister> writtenFlags;
718 };
719
720 class ia32_instruction
721 {
722   friend unsigned int ia32_decode_operands (const ia32_prefixes& pref, 
723                                             const ia32_entry& gotit, 
724                                             const char* addr, 
725                                             ia32_instruction& instruct);
726   friend COMMON_EXPORT ia32_instruction& ia32_decode(unsigned int capa, const unsigned char* addr,
727                                        ia32_instruction& instruct);
728   friend unsigned int ia32_decode_operands (const ia32_prefixes& pref, const ia32_entry& gotit, 
729                                             const unsigned char* addr, ia32_instruction& instruct,
730                                             ia32_memacc *mac = NULL);
731   friend ia32_instruction& ia32_decode_FP(const ia32_prefixes& pref, const unsigned char* addr,
732                                           ia32_instruction& instruct);
733   friend unsigned int ia32_emulate_old_type(ia32_instruction& instruct);
734   friend ia32_instruction& ia32_decode_FP(unsigned int opcode, 
735                                           const ia32_prefixes& pref,
736                                           const unsigned char* addr, 
737                                           ia32_instruction& instruct,
738                                           ia32_entry * entry,
739                                           ia32_memacc *mac = NULL);
740
741   unsigned int   size;
742   ia32_prefixes  prf;
743   ia32_memacc    *mac;
744   ia32_condition *cond;
745   ia32_entry     *entry;
746   ia32_locations *loc;
747   unsigned int   legacy_type;
748   bool           rip_relative_data;
749
750
751  public:
752   ia32_instruction(ia32_memacc* _mac = NULL, ia32_condition* _cnd = NULL,
753                    ia32_locations *loc_ = NULL)
754     : size(0), prf(), mac(_mac), cond(_cnd), entry(NULL), loc(loc_),
755       legacy_type(0), rip_relative_data(false)
756   {}
757
758   ia32_entry * getEntry() { return entry; }
759   unsigned int getSize() const { return size; }
760   unsigned int getPrefixCount() const { return prf.getCount(); }
761   ia32_prefixes * getPrefix() { return &prf; }
762   unsigned int getLegacyType() const { return legacy_type; }
763   bool hasRipRelativeData() const { return rip_relative_data; }
764   const ia32_memacc& getMac(int which) const { return mac[which]; }
765   const ia32_condition& getCond() const { return *cond; }
766   const ia32_locations& getLocationInfo() const { return *loc; }
767
768   COMMON_EXPORT static dyn_hash_map<entryID, flagInfo> const& getFlagTable();
769   static void initFlagTable(dyn_hash_map<entryID, flagInfo>&);
770   
771 };
772
773 // VG(02/07/2002): Information that the decoder can return is
774 //   #defined below. The decoder always returns the size of the 
775 //   instruction because that has to be determined anyway.
776 //   Please don't add things that should be external to the
777 //   decoder, e.g.: how may bytes a relocated instruction needs
778 //   IMHO that stuff should go into inst-x86...
779
780 #define IA32_DECODE_PREFIXES    (1<<0)
781 #define IA32_DECODE_MNEMONICS   (1<<1)
782 #define IA32_DECODE_OPERANDS    (1<<2)
783 #define IA32_DECODE_JMPS        (1<<3)
784 #define IA32_DECODE_MEMACCESS   (1<<4)
785 #define IA32_DECODE_CONDITION   (1<<5)
786
787 #define IA32_FULL_DECODER (IA32_DECODE_PREFIXES | IA32_DECODE_MNEMONICS | IA32_DECODE_OPERANDS | IA32_DECODE_JMPS | IA32_DECODE_MEMACCESS | IA32_DECODE_CONDITION)
788 #define IA32_SIZE_DECODER 0
789
790 COMMON_EXPORT ia32_instruction& ia32_decode(unsigned int capabilities, const unsigned char* addr, ia32_instruction&);
791
792
793 enum dynamic_call_address_mode {
794   REGISTER_DIRECT, REGISTER_INDIRECT,
795   REGISTER_INDIRECT_DISPLACED, SIB, DISPLACED, 
796   IP_INDIRECT_DISPLACED
797 };
798
799 /*
800    get_instruction: get the instruction that starts at instr.
801    return the size of the instruction and set instType to a type descriptor
802 */
803 COMMON_EXPORT unsigned get_instruction(const unsigned char *instr, unsigned &instType,
804                          const unsigned char** op_ptr = NULL);
805
806 /* get the target of a jump or call */
807 COMMON_EXPORT Address get_target(const unsigned char *instr, unsigned type, unsigned size,
808                    Address addr);
809
810 // Size of a jump rel32 instruction
811 #define JUMP_REL32_SZ (6)
812 // Maxium size of an emitted jump
813 #define JUMP_SZ (5)
814 // Size of a call rel32 instruction
815 #define CALL_REL32_SZ (5)
816 // >2gb displacement in 32 bit mode
817 #define CALL_ABS32_SZ (11)
818 #define JUMP_ABS32_SZ (6)
819 // Max size of a relocated thunk call
820 #define CALL_RELOC_THUNK (13)
821
822 #if defined(arch_x86_64)
823 // size of instruction seqeunce to get anywhere in address space
824 // without touching any registers
825 //#define JUMP_ABS64_SZ (17)
826 #define JUMP_ABS64_SZ (14)
827 // Jump is push/return; call is push/push/return, so subtract a return
828 #define CALL_ABS64_SZ (JUMP_ABS64_SZ+JUMP_ABS64_SZ-1)
829 #endif
830
831 #define PUSH_RM_OPC1 (0xFF)
832 #define PUSH_RM_OPC2 (6)
833 #define CALL_RM_OPC1 (0xFF)
834 #define CALL_RM_OPC2 (2)
835 #define JUMP_RM_OPC1 (0xFF)
836 #define JUMP_RM_OPC2 (4)
837 #define PUSH_EBP (0x50+REGNUM_EBP)
838 #define SUB_REG_IMM32 (5)
839 #define LEAVE (0xC9)
840
841 #define EXTENDED_0x81_ADD 0
842 #define EXTENDED_0x81_OR 1
843 #define EXTENDED_0x81_ADDC 2
844 #define EXTENDED_0x81_SHIFT 3
845 #define EXTENDED_0x81_AND 4
846 #define EXTENDED_0x81_SUB 5
847 #define EXTENDED_0x81_XOR 6
848 #define EXTENDED_0x81_CMP 7
849 #define EXTENDED_0x83_AND 4
850
851 unsigned int swapBytesIfNeeded(unsigned int i);
852
853 class instruction {
854  public:
855     instruction(): type_(0), size_(0), ptr_(0), op_ptr_(0) {}
856
857   instruction(const unsigned char *p, unsigned type, unsigned sz, const unsigned char* op = 0):
858       type_(type), size_(sz), ptr_(p), op_ptr_(op ? op : p) {}
859
860   instruction(const instruction &insn)
861   {
862     type_ = insn.type_;
863     size_ = insn.size_;
864     ptr_ = insn.ptr_;
865     op_ptr_ = insn.op_ptr_;
866   }
867   
868   COMMON_EXPORT instruction *copy() const;
869
870   instruction(const void *ptr) :
871       type_(0), size_(0), ptr_(NULL), op_ptr_(0) {
872       setInstruction((const unsigned char*)ptr);
873   }
874
875   unsigned setInstruction(const unsigned char *p, Address = 0) {
876       ptr_ = p;
877       size_ = get_instruction(ptr_, type_, &op_ptr_);
878       return size_;
879   }
880
881   // if the instruction is a jump or call, return the target, else return zero
882   Address getTarget(Address addr) const { 
883     return (Address)get_target(ptr_, type_, size_, addr); 
884   }
885
886   // return the size of the instruction in bytes
887   unsigned size() const { return size_; }
888
889   // And the size necessary to reproduce this instruction
890   // at some random point.
891   COMMON_EXPORT unsigned spaceToRelocate() const;
892
893   // return the type of the instruction
894   unsigned type() const { return type_; }
895
896   // return a pointer to the instruction
897   const unsigned char *ptr() const { 
898       return ptr_; 
899   }
900
901   // return a pointer to the instruction's opcode
902   const unsigned char* op_ptr() const { return op_ptr_; }
903
904   // Function relocation...
905   static unsigned maxInterFunctionJumpSize(unsigned addr_width) { return maxJumpSize(addr_width); }
906
907   // And tell us how much space we'll need...
908   COMMON_EXPORT static unsigned jumpSize(Address from, Address to, unsigned addr_width);
909   COMMON_EXPORT static unsigned jumpSize(long disp, unsigned addr_width);
910   COMMON_EXPORT static unsigned maxJumpSize(unsigned addr_width);
911
912   COMMON_EXPORT bool getUsedRegs(pdvector<int> &regs);
913   
914   bool isCall() const { return type_ & IS_CALL; }
915   bool isCallIndir() const { return (type_ & IS_CALL) && (type_ & INDIR); }
916   bool isReturn() const { return (type_ & IS_RET) || (type_ & IS_RETF); }
917   bool isRetFar() const { return type_ & IS_RETF; }
918   bool isCleaningRet() const {return type_ & IS_RETC; }
919   bool isJumpIndir() const { return (type_ & IS_JUMP) && (type_ & INDIR); }
920   bool isJumpDir() const
921     { return !(type_ & INDIR) && ((type_ & IS_JUMP) || (type_ & IS_JCC)); }
922   bool isUncondJump() const
923     { return ((type_ & IS_JUMP) && !(type_ & IS_JCC)); }
924   bool isNop() const;
925   bool isIndir() const { return type_ & INDIR; }
926   bool isIllegal() const { return type_ & ILLEGAL; }
927   bool isLeave() const { return *ptr_ == 0xC9; }  
928   bool isPrivileged() const { return (type_ & PRVLGD); }
929   bool isMoveRegMemToRegMem() const 
930     { const unsigned char* p = op_ptr_ ? op_ptr_ : ptr_;
931       return *p == MOV_R8_TO_RM8   || *p == MOV_R16_TO_RM16 ||
932              *p == MOV_R32_TO_RM32 || *p ==  MOV_RM8_TO_R8  ||
933              *p == MOV_RM16_TO_R16 || *p == MOV_RM32_TO_R32;   }
934   bool isXORRegMemRegMem() const
935       { const unsigned char* p = op_ptr_ ? op_ptr_ : ptr_;
936         return *p == XOR_RM16_R16 || *p ==  XOR_RM32_R32 ||
937                *p ==  XOR_R8_RM8  || *p ==  XOR_R16_RM16 ||
938                *p == XOR_R32_RM32; }
939   bool isANearBranch() const { return isJumpDir(); }
940
941   bool isTrueCallInsn() const { return (isCall() && !isCallIndir()); }
942   bool isSysCallInsn() const { return op_ptr_[0] == SYSCALL[0] &&
943                                    op_ptr_[1] == SYSCALL[1]; }
944
945   static bool isAligned(const Address ) { return true; }
946
947   bool isCmp() const;
948
949   void print()
950   {
951       for (unsigned i = 0; i < size_; i++)
952           fprintf(stderr, " %02x", *(ptr_ + i));
953       fprintf(stderr, "\n");
954   }
955                   
956   int getStackDelta();
957
958  private:
959   unsigned type_;   // type of the instruction (e.g. IS_CALL | INDIR)
960   unsigned size_;   // size in bytes
961   const unsigned char *ptr_;       // pointer to the instruction
962   const unsigned char *op_ptr_;    // pointer to the opcode
963 };
964
965 /** Only appropriate for call/jump functions **/
966 COMMON_EXPORT int get_disp(instruction *insn);
967 int set_disp(bool setDisp, instruction *insn, int newOffset, bool outOfFunc);
968 int displacement(const unsigned char *instr, unsigned type);
969
970 /** Returns the immediate operand of an instruction **/
971 COMMON_EXPORT Address get_immediate_operand(instruction *instr);
972
973 COMMON_EXPORT int count_prefixes(unsigned insnType);
974
975 inline bool is_disp8(long disp) {
976    return (disp >= -128 && disp < 127);
977 }
978
979 inline bool is_disp16(long disp) {
980    return (disp >= -32768 && disp < 32767);
981 }
982
983 inline bool is_disp32(long disp) {
984   return (disp <= I32_MAX && disp >= I32_MIN);
985 }
986 inline bool is_disp32(Address a1, Address a2) {
987   return is_disp32(a2 - (a1 + JUMP_REL32_SZ));
988 }
989 inline bool is_addr32(Address addr) {
990     return (addr < UI32_MAX);
991 }
992
993 COMMON_EXPORT void decode_SIB(unsigned sib, unsigned& scale, Register& index_reg, Register& base_reg);
994 COMMON_EXPORT const unsigned char* skip_headers(const unsigned char*, ia32_prefixes* = NULL);
995
996 /* addresses on x86 don't have to be aligned */
997 /* Address bounds of new dynamic heap segments.  On x86 we don't try
998 to allocate new segments near base tramps, so heap segments can be
999 allocated anywhere (the tramp address "x" is ignored). */
1000 inline Address region_lo(const Address /*x*/) { return 0x00000000; }
1001 inline Address region_hi(const Address /*x*/) { return 0xf0000000; }
1002
1003 #if defined(arch_x86_64)
1004 // range functions for AMD64
1005
1006 inline Address region_lo_64(const Address x) { return x & 0xffffffff80000000; }
1007 inline Address region_hi_64(const Address x) { return x | 0x000000007fffffff; }
1008
1009 #endif
1010
1011 COMMON_EXPORT bool insn_hasSIB(unsigned,unsigned&,unsigned&,unsigned&);
1012 COMMON_EXPORT bool insn_hasDisp8(unsigned ModRM);
1013 COMMON_EXPORT bool insn_hasDisp32(unsigned ModRM);
1014
1015 COMMON_EXPORT bool isStackFramePrecheck_msvs( const unsigned char *buffer );
1016 COMMON_EXPORT bool isStackFramePrecheck_gcc( const unsigned char *buffer );
1017
1018 }; // namespace arch_x86
1019
1020 #endif
1021