Allow dyninst to be compiled using clang
[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 #define EVEXGET_VVVV(b) (unsigned char)(((b) >> 0x03) & (0x0F))
436
437 #endif
438
439 #ifndef PREFIX_LOCK
440 #define PREFIX_LOCK   (unsigned char)(0xF0)
441 #define PREFIX_REPNZ  (unsigned char)(0xF2)
442 #define PREFIX_REP    (unsigned char)(0xF3)
443
444 #define PREFIX_SEGCS  (unsigned char)(0x2E)
445 #define PREFIX_SEGSS  (unsigned char)(0x36)
446 #define PREFIX_SEGDS  (unsigned char)(0x3E)
447 #define PREFIX_SEGES  (unsigned char)(0x26)
448 #define PREFIX_SEGFS  (unsigned char)(0x64)
449 #define PREFIX_SEGGS  (unsigned char)(0x65)
450
451 #define PREFIX_XOP  (unsigned char)(0x8F)
452
453 #define PREFIX_BRANCH0 (unsigned char)(0x2E)
454 #define PREFIX_BRANCH1 (unsigned char)(0x3E)
455
456 #define PREFIX_SZOPER  (unsigned char)(0x66)
457 #define PREFIX_SZADDR  (unsigned char)(0x67)
458 #endif
459
460 COMMON_EXPORT void ia32_set_mode_64(bool mode);
461 COMMON_EXPORT bool ia32_is_mode_64();
462
463 // addressing methods (see appendix A-2)
464 // I've added am_reg (for registers implicitely encoded in instruciton), 
465 // and am_stackX for stack operands [this kinda' messy since there are actually two operands:
466 // the stack byte/word/dword and the (E)SP register itself - but is better than naught]
467 // added: am_reg, am_stack, am_allgprs
468 // ADDED: am_ImplImm for implicit immediates
469 // ADDED: am_RM, am_UM,
470 enum { am_A=1, am_C, am_D, am_E, am_F, am_G, am_H, am_I, am_J, am_M, //10 
471       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
472       am_Y, am_reg, am_stackH, am_stackP, am_allgprs, am_VR, am_tworeghack, am_ImplImm, am_RM }; // pusH and poP produce different addresses
473
474 // operand types - idem, but I invented quite a few to make implicit operands explicit.
475 // ADDED: op_y
476 enum { op_a=1, op_b, op_c, op_d, op_dq, op_p, op_pd, op_pi, op_ps, op_q, // 10
477        op_qq, op_s, op_sd, op_ss, op_si, op_v, op_w, op_y, op_z, op_lea, op_allgprs, op_512,
478        op_f, op_dbl, op_14, op_28, op_edxeax, op_ecxebx};
479
480
481 // tables and pseudotables
482 enum {
483   t_ill=0, t_oneB, t_twoB, t_threeB, t_threeB2, t_prefixedSSE, t_coprocEsc, 
484   t_grp, t_sse, t_sse_mult, t_sse_bis, t_sse_bis_mult, 
485   t_sse_ter, t_sse_ter_mult, t_grpsse, t_3dnow, t_vexl, t_vexw, t_done=99
486 };
487
488 // registers used for memory access
489 enum { mRAX=0, mRCX, mRDX, mRBX,
490        mRSP, mRBP, mRSI, mRDI,
491        mR8, mR9, mR10, mR11, 
492        mR12,mR13, MR14, mR15, mRIP };
493
494 enum { mEAX=0, mECX, mEDX, mEBX,
495        mESP, mEBP, mESI, mEDI };
496
497 enum { mAX=0, mCX, mDX, mBX,
498        mSP, mBP, mSI, mDI };
499
500
501 // operand semantic - these make explicit all the implicit stuff in the Intel tables
502 // they are needed for memory access, but may be useful for other things: dataflow etc.
503 // Instructions that do not deal with memory are not tested, so caveat emptor...
504 // Also note that the stack is never specified as an operand in Intel tables, so it
505 // has to be dealt with here.
506
507 enum { sNONE=0, // the instruction does something that cannot be classified as read/write (by me)
508        s1R,     // reads one operand, e.g. jumps
509        s1W,     // e.g. lea
510        s1RW,    // one operand read and written, e.g. inc
511        s1R2R,   // reads two operands, e.g. cmp
512        s1W2R,   // second operand read, first operand written (e.g. mov)
513        s1RW2R,  // two operands read, first written (e.g. add)
514        s1RW2RW, // e.g. xchg
515        s1W2R3R, // e.g. imul
516        s1W2W3R, // e.g. les
517        s1W2RW3R, // some mul
518        s1R2RW, // (stack) push
519        s1W2RW, // pop
520        s1W2R3RW, // additional push/pop
521        s1RW2R3R, // shld/shrd
522        s1RW2RW3R, // [i]div, cmpxch8b
523        s1RW2R3RW, // v[p]gather[ps, pd, qq, qd]
524        s1R2R3R,
525
526 /* Only 4 operands below here */
527        s1W2R3R4R,
528        s1RW2R3R4R 
529 }; // should be strictly less than 2^17 otherwise adjust FPOS below
530
531 /* This should equal the first operand semantic where 4 operands are used. */
532 #define s4OP s1W2R3R4R
533
534
535 struct modRMByte {
536   unsigned mod : 2;
537   unsigned reg : 3;
538   unsigned rm  : 3;
539 };
540
541 struct sIBByte {
542   unsigned scale : 2;
543   unsigned index : 3;
544   unsigned base  : 3;
545 };
546
547
548 class ia32_prefixes
549 {
550   friend bool ia32_decode_prefixes(const unsigned char* addr, ia32_prefixes&,
551                                    ia32_locations *loc);
552   friend bool ia32_decode_rex(const unsigned char* addr, ia32_prefixes&,
553                               ia32_locations *loc);
554  private:
555   unsigned int count;
556   // At most 4 prefixes are allowed for Intel 32-bit CPUs
557   // There also 4 groups, so this array is 0 if no prefix
558   // from that group is present, otherwise it contains the
559   // prefix opcode
560   // For 64-bit CPUs, an additional REX prefix is possible,
561   // so this array is extended to 5 elements
562   unsigned char prfx[5];
563   unsigned char opcode_prefix;
564   
565  public:
566   unsigned int getCount() const { return count; }
567   unsigned char getPrefix(unsigned char group) const { assert(group <= 4); return prfx[group]; }
568   bool rexW() const { return prfx[4] & 0x8; }
569   bool rexR() const { return prfx[4] & 0x4; }
570   bool rexX() const { return prfx[4] & 0x2; }
571   bool rexB() const { return prfx[4] & 0x1; }
572   unsigned char getOpcodePrefix() const { return opcode_prefix; }
573   unsigned char getAddrSzPrefix() const { return prfx[3]; }
574   unsigned char getOperSzPrefix() const { return prfx[2]; }
575   bool vex_present; /* Does this instruction have a vex prefix?  */
576   unsigned char vex_prefix[4]; /* support up to EVEX (VEX-512) */
577   unsigned char vex_l; /* l bit for VEX2 and VEX3 */
578   unsigned char vex_w; /* w bit for VEX2 and VEX3 */
579   int sse_mult; /* 0 VEX2, 1 VEX3, 2 EVEX */
580   //int vvvv_reg; /* The register specified by this prefix. */
581 };
582
583 // helper routine to tack-on rex bit when needed
584 inline int apply_rex_bit(int reg, bool rex_bit)
585 {
586     if (rex_bit)
587         return reg + 8;
588     else
589         return reg;
590 }
591
592 //VG(6/20/02): To support Paradyn without forcing it to include BPatch_memoryAccess, we
593 //             define this IA-32 "specific" class to encapsulate the same info - yuck
594
595 struct ia32_memacc
596 {
597   bool is;
598   bool read;
599   bool write;
600   bool nt;     // non-temporal, e.g. movntq...
601   bool prefetch;
602
603   int addr_size; // size of address in 16-bit words
604   long imm;
605   int scale;
606   int regs[2]; // register encodings (in ISA order): 0-7
607                // (E)AX, (E)CX, (E)DX, (E)BX
608                // (E)SP, (E)BP, (E)SI, (E)DI
609
610   int size;
611   int sizehack;  // register (E)CX or string based
612   int prefetchlvl; // prefetch level
613   int prefetchstt; // prefetch state (AMD)
614
615   ia32_memacc() : is(false), read(false), write(false), nt(false), 
616        prefetch(false), addr_size(2), imm(0), scale(0), size(0), sizehack(0),
617        prefetchlvl(-1), prefetchstt(-1)
618   {
619     regs[0] = -1;
620     regs[1] = -1;
621   }
622
623   void set16(int reg0, int reg1, long disp)
624   { 
625     is = true;
626     addr_size  = 1; 
627     regs[0] = reg0; 
628     regs[1] = reg1; 
629     imm     = disp;
630   }
631
632   void set(int reg, long disp, int addr_sz)
633   { 
634     is = true;
635     addr_size = addr_sz;
636     regs[0] = reg; 
637     imm     = disp;
638   }
639
640   void set_sib(int base, int scal, int indx, long disp, int addr_sz)
641   {
642     is = true;
643     addr_size = addr_sz;
644     regs[0] = base;
645     regs[1] = indx;
646     scale   = scal;
647     imm     = disp;
648   }
649
650   void setXY(int reg, int _size, int _addr_size)
651   {
652     is = true;
653     regs[0] = reg;
654     size = _size;
655     addr_size = _addr_size;
656   }
657
658   void print();
659 };
660
661 enum sizehacks {
662   shREP=1,
663   shREPECMPS,
664   shREPESCAS,
665   shREPNECMPS,
666   shREPNESCAS
667 };
668
669
670 struct ia32_condition
671 {
672   bool is;
673   // TODO: add a field/hack for ECX [not needed for CMOVcc, but for Jcc]
674   int tttn;
675
676   ia32_condition() : is(false), tttn(-1) {}
677   void set(int _tttn) { is = true; tttn = _tttn; }
678 };
679
680 bool ia32_decode_prefixes(const unsigned char* addr, ia32_prefixes&,
681                           ia32_locations *loc = NULL);
682
683
684 struct ia32_operand {  // operand as given in Intel book tables
685   unsigned int admet;  // addressing method
686   unsigned int optype; // operand type;
687 };
688
689 // An instruction table entry
690 struct ia32_entry {
691   COMMON_EXPORT const char* name(ia32_locations* locs = NULL);
692   COMMON_EXPORT entryID getID(ia32_locations* locs = NULL) const;
693   // returns true if any flags are read/written, false otherwise
694   COMMON_EXPORT bool flagsUsed(std::set<Dyninst::MachRegister>& flagsRead, std::set<Dyninst::MachRegister>& flagsWritten,
695                  ia32_locations* locs = NULL);
696   entryID id;
697   unsigned int otable;       // which opcode table is next; if t_done it is the current one
698   unsigned char tabidx;      // at what index to look, 0 if it easy to deduce from opcode
699   bool hasModRM;             // true if the instruction has a MOD/RM byte
700   ia32_operand operands[3];  // operand descriptors
701   unsigned int legacyType;   // legacy type of the instruction (e.g. (IS_CALL | REL_W))
702   // code to decode memory access - this field should be seen as two 16 bit fields
703   // the lower half gives operand semantics, e.g. s1RW2R, the upper half is a fXXX hack if needed
704   // before hating me for this: it takes a LOT less time to add ONE field to ~2000 table lines!
705   unsigned int opsema;  
706 };
707
708 using std::vector;
709 struct flagInfo
710 {
711   flagInfo(const vector<Dyninst::MachRegister>& rf, const vector<Dyninst::MachRegister>& wf) : readFlags(rf), writtenFlags(wf)
712   {
713   }
714   flagInfo() 
715   {
716   }
717   
718   vector<Dyninst::MachRegister> readFlags;
719   vector<Dyninst::MachRegister> writtenFlags;
720 };
721
722 class ia32_instruction
723 {
724   friend unsigned int ia32_decode_operands (const ia32_prefixes& pref, 
725                                             const ia32_entry& gotit, 
726                                             const char* addr, 
727                                             ia32_instruction& instruct);
728   friend COMMON_EXPORT ia32_instruction& ia32_decode(unsigned int capa, const unsigned char* addr,
729                                        ia32_instruction& instruct);
730   friend unsigned int ia32_decode_operands (const ia32_prefixes& pref, const ia32_entry& gotit, 
731                                             const unsigned char* addr, ia32_instruction& instruct,
732                                             ia32_memacc *mac);
733   friend ia32_instruction& ia32_decode_FP(const ia32_prefixes& pref, const unsigned char* addr,
734                                           ia32_instruction& instruct);
735   friend unsigned int ia32_emulate_old_type(ia32_instruction& instruct);
736   friend ia32_instruction& ia32_decode_FP(unsigned int opcode, 
737                                           const ia32_prefixes& pref,
738                                           const unsigned char* addr, 
739                                           ia32_instruction& instruct,
740                                           ia32_entry * entry,
741                                           ia32_memacc *mac);
742
743   unsigned int   size;
744   ia32_prefixes  prf;
745   ia32_memacc    *mac;
746   ia32_condition *cond;
747   ia32_entry     *entry;
748   ia32_locations *loc;
749   unsigned int   legacy_type;
750   bool           rip_relative_data;
751
752
753  public:
754   ia32_instruction(ia32_memacc* _mac = NULL, ia32_condition* _cnd = NULL,
755                    ia32_locations *loc_ = NULL)
756     : size(0), prf(), mac(_mac), cond(_cnd), entry(NULL), loc(loc_),
757       legacy_type(0), rip_relative_data(false)
758   {}
759
760   ia32_entry * getEntry() { return entry; }
761   unsigned int getSize() const { return size; }
762   unsigned int getPrefixCount() const { return prf.getCount(); }
763   ia32_prefixes * getPrefix() { return &prf; }
764   unsigned int getLegacyType() const { return legacy_type; }
765   bool hasRipRelativeData() const { return rip_relative_data; }
766   const ia32_memacc& getMac(int which) const { return mac[which]; }
767   const ia32_condition& getCond() const { return *cond; }
768   const ia32_locations& getLocationInfo() const { return *loc; }
769
770   COMMON_EXPORT static dyn_hash_map<entryID, flagInfo> const& getFlagTable();
771   static void initFlagTable(dyn_hash_map<entryID, flagInfo>&);
772   
773 };
774
775 // VG(02/07/2002): Information that the decoder can return is
776 //   #defined below. The decoder always returns the size of the 
777 //   instruction because that has to be determined anyway.
778 //   Please don't add things that should be external to the
779 //   decoder, e.g.: how may bytes a relocated instruction needs
780 //   IMHO that stuff should go into inst-x86...
781
782 #define IA32_DECODE_PREFIXES    (1<<0)
783 #define IA32_DECODE_MNEMONICS   (1<<1)
784 #define IA32_DECODE_OPERANDS    (1<<2)
785 #define IA32_DECODE_JMPS        (1<<3)
786 #define IA32_DECODE_MEMACCESS   (1<<4)
787 #define IA32_DECODE_CONDITION   (1<<5)
788
789 #define IA32_FULL_DECODER (IA32_DECODE_PREFIXES | IA32_DECODE_MNEMONICS | IA32_DECODE_OPERANDS | IA32_DECODE_JMPS | IA32_DECODE_MEMACCESS | IA32_DECODE_CONDITION)
790 #define IA32_SIZE_DECODER 0
791
792 COMMON_EXPORT ia32_instruction& ia32_decode(unsigned int capabilities, const unsigned char* addr, ia32_instruction&);
793
794
795 enum dynamic_call_address_mode {
796   REGISTER_DIRECT, REGISTER_INDIRECT,
797   REGISTER_INDIRECT_DISPLACED, SIB, DISPLACED, 
798   IP_INDIRECT_DISPLACED
799 };
800
801 /*
802    get_instruction: get the instruction that starts at instr.
803    return the size of the instruction and set instType to a type descriptor
804 */
805 COMMON_EXPORT unsigned get_instruction(const unsigned char *instr, unsigned &instType,
806                          const unsigned char** op_ptr = NULL);
807
808 /* get the target of a jump or call */
809 COMMON_EXPORT Address get_target(const unsigned char *instr, unsigned type, unsigned size,
810                    Address addr);
811
812 // Size of a jump rel32 instruction
813 #define JUMP_REL32_SZ (6)
814 // Maxium size of an emitted jump
815 #define JUMP_SZ (5)
816 // Size of a call rel32 instruction
817 #define CALL_REL32_SZ (5)
818 // >2gb displacement in 32 bit mode
819 #define CALL_ABS32_SZ (11)
820 #define JUMP_ABS32_SZ (6)
821 // Max size of a relocated thunk call
822 #define CALL_RELOC_THUNK (13)
823
824 #if defined(arch_x86_64)
825 // size of instruction seqeunce to get anywhere in address space
826 // without touching any registers
827 //#define JUMP_ABS64_SZ (17)
828 #define JUMP_ABS64_SZ (14)
829 // Jump is push/return; call is push/push/return, so subtract a return
830 #define CALL_ABS64_SZ (JUMP_ABS64_SZ+JUMP_ABS64_SZ-1)
831 #endif
832
833 #define PUSH_RM_OPC1 (0xFF)
834 #define PUSH_RM_OPC2 (6)
835 #define CALL_RM_OPC1 (0xFF)
836 #define CALL_RM_OPC2 (2)
837 #define JUMP_RM_OPC1 (0xFF)
838 #define JUMP_RM_OPC2 (4)
839 #define PUSH_EBP (0x50+REGNUM_EBP)
840 #define SUB_REG_IMM32 (5)
841 #define LEAVE (0xC9)
842
843 #define EXTENDED_0x81_ADD 0
844 #define EXTENDED_0x81_OR 1
845 #define EXTENDED_0x81_ADDC 2
846 #define EXTENDED_0x81_SHIFT 3
847 #define EXTENDED_0x81_AND 4
848 #define EXTENDED_0x81_SUB 5
849 #define EXTENDED_0x81_XOR 6
850 #define EXTENDED_0x81_CMP 7
851 #define EXTENDED_0x83_AND 4
852
853 unsigned int swapBytesIfNeeded(unsigned int i);
854
855 class instruction {
856  public:
857     instruction(): type_(0), size_(0), ptr_(0), op_ptr_(0) {}
858
859   instruction(const unsigned char *p, unsigned type, unsigned sz, const unsigned char* op = 0):
860       type_(type), size_(sz), ptr_(p), op_ptr_(op ? op : p) {}
861
862   instruction(const instruction &insn)
863   {
864     type_ = insn.type_;
865     size_ = insn.size_;
866     ptr_ = insn.ptr_;
867     op_ptr_ = insn.op_ptr_;
868   }
869   
870   COMMON_EXPORT instruction *copy() const;
871
872   instruction(const void *ptr) :
873       type_(0), size_(0), ptr_(NULL), op_ptr_(0) {
874       setInstruction((const unsigned char*)ptr);
875   }
876
877   unsigned setInstruction(const unsigned char *p, Address = 0) {
878       ptr_ = p;
879       size_ = get_instruction(ptr_, type_, &op_ptr_);
880       return size_;
881   }
882
883   // if the instruction is a jump or call, return the target, else return zero
884   Address getTarget(Address addr) const { 
885     return (Address)get_target(ptr_, type_, size_, addr); 
886   }
887
888   // return the size of the instruction in bytes
889   unsigned size() const { return size_; }
890
891   // And the size necessary to reproduce this instruction
892   // at some random point.
893   COMMON_EXPORT unsigned spaceToRelocate() const;
894
895   // return the type of the instruction
896   unsigned type() const { return type_; }
897
898   // return a pointer to the instruction
899   const unsigned char *ptr() const { 
900       return ptr_; 
901   }
902
903   // return a pointer to the instruction's opcode
904   const unsigned char* op_ptr() const { return op_ptr_; }
905
906   // Function relocation...
907   static unsigned maxInterFunctionJumpSize(unsigned addr_width) { return maxJumpSize(addr_width); }
908
909   // And tell us how much space we'll need...
910   COMMON_EXPORT static unsigned jumpSize(Address from, Address to, unsigned addr_width);
911   COMMON_EXPORT static unsigned jumpSize(long disp, unsigned addr_width);
912   COMMON_EXPORT static unsigned maxJumpSize(unsigned addr_width);
913
914   COMMON_EXPORT bool getUsedRegs(pdvector<int> &regs);
915   
916   bool isCall() const { return type_ & IS_CALL; }
917   bool isCallIndir() const { return (type_ & IS_CALL) && (type_ & INDIR); }
918   bool isReturn() const { return (type_ & IS_RET) || (type_ & IS_RETF); }
919   bool isRetFar() const { return type_ & IS_RETF; }
920   bool isCleaningRet() const {return type_ & IS_RETC; }
921   bool isJumpIndir() const { return (type_ & IS_JUMP) && (type_ & INDIR); }
922   bool isJumpDir() const
923     { return !(type_ & INDIR) && ((type_ & IS_JUMP) || (type_ & IS_JCC)); }
924   bool isUncondJump() const
925     { return ((type_ & IS_JUMP) && !(type_ & IS_JCC)); }
926   bool isNop() const;
927   bool isIndir() const { return type_ & INDIR; }
928   bool isIllegal() const { return type_ & ILLEGAL; }
929   bool isLeave() const { return *ptr_ == 0xC9; }  
930   bool isPrivileged() const { return (type_ & PRVLGD); }
931   bool isMoveRegMemToRegMem() const 
932     { const unsigned char* p = op_ptr_ ? op_ptr_ : ptr_;
933       return *p == MOV_R8_TO_RM8   || *p == MOV_R16_TO_RM16 ||
934              *p == MOV_R32_TO_RM32 || *p ==  MOV_RM8_TO_R8  ||
935              *p == MOV_RM16_TO_R16 || *p == MOV_RM32_TO_R32;   }
936   bool isXORRegMemRegMem() const
937       { const unsigned char* p = op_ptr_ ? op_ptr_ : ptr_;
938         return *p == XOR_RM16_R16 || *p ==  XOR_RM32_R32 ||
939                *p ==  XOR_R8_RM8  || *p ==  XOR_R16_RM16 ||
940                *p == XOR_R32_RM32; }
941   bool isANearBranch() const { return isJumpDir(); }
942
943   bool isTrueCallInsn() const { return (isCall() && !isCallIndir()); }
944   bool isSysCallInsn() const { return op_ptr_[0] == SYSCALL[0] &&
945                                    op_ptr_[1] == SYSCALL[1]; }
946
947   static bool isAligned(const Address ) { return true; }
948
949   bool isCmp() const;
950
951   void print()
952   {
953       for (unsigned i = 0; i < size_; i++)
954           fprintf(stderr, " %02x", *(ptr_ + i));
955       fprintf(stderr, "\n");
956   }
957                   
958   int getStackDelta();
959
960  private:
961   unsigned type_;   // type of the instruction (e.g. IS_CALL | INDIR)
962   unsigned size_;   // size in bytes
963   const unsigned char *ptr_;       // pointer to the instruction
964   const unsigned char *op_ptr_;    // pointer to the opcode
965 };
966
967 /** Only appropriate for call/jump functions **/
968 COMMON_EXPORT int get_disp(instruction *insn);
969 int set_disp(bool setDisp, instruction *insn, int newOffset, bool outOfFunc);
970 int displacement(const unsigned char *instr, unsigned type);
971
972 /** Returns the immediate operand of an instruction **/
973 COMMON_EXPORT Address get_immediate_operand(instruction *instr);
974
975 COMMON_EXPORT int count_prefixes(unsigned insnType);
976
977 inline bool is_disp8(long disp) {
978    return (disp >= -128 && disp < 127);
979 }
980
981 inline bool is_disp16(long disp) {
982    return (disp >= -32768 && disp < 32767);
983 }
984
985 inline bool is_disp32(long disp) {
986   return (disp <= I32_MAX && disp >= I32_MIN);
987 }
988 inline bool is_disp32(Address a1, Address a2) {
989   return is_disp32(a2 - (a1 + JUMP_REL32_SZ));
990 }
991 inline bool is_addr32(Address addr) {
992     return (addr < UI32_MAX);
993 }
994
995 COMMON_EXPORT void decode_SIB(unsigned sib, unsigned& scale, Register& index_reg, Register& base_reg);
996 COMMON_EXPORT const unsigned char* skip_headers(const unsigned char*, ia32_prefixes* = NULL);
997
998 /* addresses on x86 don't have to be aligned */
999 /* Address bounds of new dynamic heap segments.  On x86 we don't try
1000 to allocate new segments near base tramps, so heap segments can be
1001 allocated anywhere (the tramp address "x" is ignored). */
1002 inline Address region_lo(const Address /*x*/) { return 0x00000000; }
1003 inline Address region_hi(const Address /*x*/) { return 0xf0000000; }
1004
1005 #if defined(arch_x86_64)
1006 // range functions for AMD64
1007
1008 inline Address region_lo_64(const Address x) { return x & 0xffffffff80000000; }
1009 inline Address region_hi_64(const Address x) { return x | 0x000000007fffffff; }
1010
1011 #endif
1012
1013 COMMON_EXPORT bool insn_hasSIB(unsigned,unsigned&,unsigned&,unsigned&);
1014 COMMON_EXPORT bool insn_hasDisp8(unsigned ModRM);
1015 COMMON_EXPORT bool insn_hasDisp32(unsigned ModRM);
1016
1017 COMMON_EXPORT bool isStackFramePrecheck_msvs( const unsigned char *buffer );
1018 COMMON_EXPORT bool isStackFramePrecheck_gcc( const unsigned char *buffer );
1019
1020 }; // namespace arch_x86
1021
1022 #endif
1023