* Bugfix: InstrucIter no longer used for int_function iteration.
[dyninst.git] / dyninstAPI / src / arch-x86.h
1 /*
2  * Copyright (c) 1996-2004 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 // $Id: arch-x86.h,v 1.58 2007/12/11 20:22:06 bill Exp $
43 // x86 instruction declarations
44
45 #include <stdio.h>
46 #include <common/h/Vector.h>
47 #include <common/h/Annotatable.h>
48 #include <set>
49 #include <map>
50
51 #if !defined(i386_unknown_solaris2_5) \
52  && !defined(i386_unknown_nt4_0) \
53  && !defined(i386_unknown_linux2_0) \
54  && !defined(x86_64_unknown_linux2_4)
55 #error "invalid architecture-os inclusion"
56 #endif
57
58 #ifndef _ARCH_X86_H
59 #define _ARCH_X86_H
60
61 // Code generation
62
63 typedef unsigned char codeBuf_t;
64 typedef unsigned codeBufIndex_t;
65
66 class codeGen;
67 class process; // relocation may need to look up a target
68 class AddressSpace;
69
70 #if defined(i386_unknown_nt4_0)
71 // disable VC++ warning C4800: (performance warning)
72 // forcing 'unsigned int' value to bool 'true' or 'false'
73 #pragma warning (disable : 4800)
74 #endif
75
76 /* operand types */
77 typedef char byte_t;   /* a byte operand */
78 typedef short word_t;  /* a word (16-bit) operand */
79 typedef int dword_t;   /* a double word (32-bit) operand */
80
81 #if defined(arch_x86_64)
82 #define maxGPR 16
83 #else
84 #define maxGPR 8
85 #endif 
86
87 #define READ_OP 0
88 #define WRITE_OP 1
89
90 /* operand sizes */
91 #define byteSzB (1)    /* size of a byte operand */
92 #define wordSzB (2)    /* size of a word operand */
93 #define dwordSzB (4)   /* size of a dword operand */
94 #define qwordSzB (8)   /* size of a qword operand */
95 #define dqwordSzB (16)   /* size of a double qword (oword) operand */
96
97 /* The following values are or'ed together to form an instruction type descriptor */
98 /* the instruction types of interest */
99 #define IS_CALL (1<<1)   /* call instruction */
100 #define IS_RET  (1<<2)   /* near return instruction */
101 #define IS_RETF (1<<3)   /* far return instruction */
102 #define IS_JUMP (1<<4)   /* jump instruction */
103 #define IS_JCC  (1<<5)   /* conditional jump instruction */
104 #define ILLEGAL (1<<6)   /* illegal instruction */
105 #define PRVLGD  (1<<7)   /* privileged */
106 #define IS_RETC (1<<8)   /* return and pop bytes off of stack*/
107
108 /* addressing modes for calls and jumps */
109 #define REL_B   (1<<10)  /* relative address, byte offset */
110 #define REL_W   (1<<11)  /* relative address, word offset */
111 #define REL_D   (1<<12)  /* relative address, dword offset */
112 #define REL_X   (1<<13)  /* relative address, word or dword offset */
113 #define INDIR   (1<<14)  /* indirect (register or memory) address */
114 #define PTR_WW  (1<<15)  /* 4-byte pointer */
115 #define PTR_WD  (1<<16)  /* 6-byte pointer */
116 #define PTR_WX  (1<<17)  /* 4 or 6-byte pointer */
117 #define REL_D_DATA (1<<18) /* AMD64 RIP-relative data addressing */
118
119 /* prefixes */
120 #define PREFIX_INST   (1<<20) /* instruction prefix */
121 #define PREFIX_SEG    (1<<21) /* segment override prefix */
122 #define PREFIX_OPR    (1<<22) /* operand size override */
123 #define PREFIX_ADDR   (1<<23) /* address size override */
124 #define PREFIX_REX    (1<<24) /* AMD64 REX prefix */
125 #define PREFIX_OPCODE (1<<25) /* prefix is part of opcode (SSE) */
126
127 /* end of instruction type descriptor values */
128
129  
130 /* opcodes of some one byte opcode instructions */
131 /* ADD */
132 #define ADD_EB_GB (0x00)
133 #define ADD_EV_GV (0x01)
134 #define ADD_GB_EB (0x02)
135 #define ADD_GV_EV (0x03)
136 #define ADD_AL_LB (0x04)
137 #define ADD_RAX_LZ (0x05)
138
139 #define PUSHES    (0x06) /* Invalid in 64 bit mode */
140 #define POPES     (0x07) /* Invalid in 64 bit mode */
141
142 /* OR */
143 #define OR_EB_GB (0x08)
144 #define OR_EV_GV (0x09)
145 #define OR_GB_EB (0x0A)
146 #define OR_GV_EV (0x0B)
147 #define OR_AL_LB (0x0C)
148 #define OR_RAX_LZ (0x0D)
149
150 #define PUSHCS    (0x0E) /* Invalid in 64 bit mode */
151 #define TWO_BYTE_OPCODE (0x0F)
152
153 /* ADC */
154 #define ADC_EB_GB (0x10)
155 #define ADC_EV_GV (0x11)
156 #define ADC_GB_EB (0x12)
157 #define ADC_GV_EV (0x13)
158 #define ADC_AL_LB (0x14)
159 #define ADC_RAX_LZ (0x15)
160
161 #define PUSHSS    (0x16) /* Invalid in 64 bit mode */
162 #define POPSS     (0x17) /* Invalid in 64 bit mode */
163
164 /* SBB */
165 #define SBB_EB_GB (0x18)
166 #define SBB_EV_GV (0x19)
167 #define SBB_GB_EB (0x1A)
168 #define SBB_GV_EV (0x1B)
169 #define SBB_AL_LB (0x1C)
170 #define SBB_RAX_LZ (0x1D)
171
172 #define PUSH_DS  (0x1E) /* Invalid in 64 bit mode */
173 #define POP_DS   (0X1F) /* Invalid in 64 bit mode */
174
175 /* AND */
176 #define AND_EB_GB (0x20)
177 #define AND_EV_GV (0x21)
178 #define AND_GB_EB (0x22)
179 #define AND_GV_EV (0x23)
180 #define AND_AL_LB (0x24)
181 #define AND_RAX_LZ (0x25)
182
183 #define SEG_ES (0x26) /* Null prefix in 64-bit mode */
184 #define DAA    (0x27) /* Invalid in 64-bit mode */
185
186 /* SUB */
187 #define SUB_EB_GB (0x28)
188 #define SUB_EV_GV (0x29)
189 #define SUB_GB_EB (0x2A)
190 #define SUB_GV_EV (0x2B)
191 #define SUB_AL_LB (0x2C)
192 #define SUB_RAX_LZ (0x2D)
193
194 //(0x2E)
195 //   (0x2F)
196
197 /* XOR */
198 #define XOR_EB_GB (0x30)
199 #define XOR_EV_GV (0x31)
200 #define XOR_GB_EB (0x32)
201 #define XOR_GV_EV (0x33)
202 #define XOR_AL_LB (0x34)
203 #define XOR_RAX_LZ (0x35)
204
205 #define XOR_RM16_R16 (0x31)
206 #define XOR_RM32_R32 (0x31)
207 #define XOR_R8_RM8 (0x32)
208 #define XOR_R16_RM16 (0x33)
209 #define XOR_R32_RM32 (0x33)
210
211 #define SEG_SS (0x36) /* Null prefix in 64 bit mode */
212 #define AAA (0x37)    /* Invalid in 64-bit mode */
213
214
215 /* CMP */
216 #define CMP_EB_GB (0x38)
217 #define CMP_EV_GV (0x39)
218 #define CMP_GB_EB (0x3A)
219 #define CMP_GV_EV (0x3B)
220 #define CMP_AL_LB (0x3C)
221 #define CMP_RAX_LZ (0x3D)
222
223 //   (0x3E)
224 //   (0x3F)
225
226 /* INC - REX Prefixes in 64 bit mode*/
227 #define INC_EAX  (0x40)
228 #define INC_ECX  (0x41)
229 #define INC_EDX  (0x42)
230 #define INC_EBX  (0x43)
231 #define INC_ESP  (0x44)
232 #define INC_EBP  (0x45)
233 #define INC_ESI  (0x46)
234 #define INC_EDI  (0x47)
235
236 /* DEC - REX Prefixes in 64 bit mode */
237 #define DEC_EAX  (0x48)
238 #define DEC_ECX  (0x49)
239 #define DEC_EDX  (0x50)
240 #define DEC_EBX  (0x51)
241 #define DEC_ESP  (0x52)
242 #define DEC_EBP  (0x53)
243 #define DEC_ESI  (0x54)
244 #define DEC_EDI  (0x55)
245
246 /* PUSH */
247 #define PUSHEAX  (0x50)
248 #define PUSHECX  (0x51)
249 #define PUSHEDX  (0x52)
250 #define PUSHEBX  (0x53)
251 #define PUSHESP  (0x54)
252 #define PUSHEBP  (0x55)
253 #define PUSHESI  (0x56)
254 #define PUSHEDI  (0x57)
255
256 /* POP */
257 #define POP_EAX  (0x58)
258 #define POP_ECX  (0x59)
259 #define POP_EDX  (0x5A)
260 #define POP_EBX  (0x5b)
261 #define POP_ESP  (0x5c)
262 #define POP_EBP  (0x5d)
263 #define POP_EBI  (0x5e)
264 #define POP_EDI  (0x5f)
265
266
267 #define PUSHAD   (0x60)
268 #define POPAD    (0x61)
269
270
271
272
273 #define JE_R8    (0x74)
274 #define JNE_R8   (0x75)
275 #define JL_R8    (0x7C)
276 #define JLE_R8   (0x7E)
277 #define JG_R8    (0x7F)
278 #define JGE_R8   (0x7D)
279
280
281 #define MOVREGMEM_REG (0x8b) 
282 #define MOV_R8_TO_RM8 (0x88)     //move r8 to r/m8
283 #define MOV_R16_TO_RM16 (0x89)   //move r16 to r/m16
284 #define MOV_R32_TO_RM32 (0x89)   //move r32 to r/m32
285 #define MOV_RM8_TO_R8 (0x8A)
286 #define MOV_RM16_TO_R16 (0x8b)
287 #define MOV_RM32_TO_R32 (0x8b)
288
289
290
291 #define NOP      (0x90)
292 #define PUSHFD   (0x9C)
293 #define POPFD    (0x9D)
294
295
296 #define JCXZ     (0xE3)
297
298
299
300
301
302
303 #define FSAVE    (0x9BDD)
304 #define FSAVE_OP (6)
305
306 #define FRSTOR   (0xDD)
307 #define FRSTOR_OP (4)
308
309 const unsigned char SYSCALL[] = {0x0F, 0x05};
310
311 /* limits */
312 #define MIN_IMM8 (-128)
313 #define MAX_IMM8 (127)
314 #define MIN_IMM16 (-32768)
315 #define MAX_IMM16 (32767)
316
317 // Size of floating point information saved by FSAVE
318 #define FSAVE_STATE_SIZE 108
319
320 // Prefix groups
321 enum {
322   RepGroup = 0
323 };
324
325
326
327 #define PREFIX_LOCK   0xF0
328 #define PREFIX_REPNZ  0xF2
329 #define PREFIX_REP    0xF3
330
331 #define PREFIX_SEGCS  0x2E
332 #define PREFIX_SEGSS  0x36
333 #define PREFIX_SEGDS  0x3E
334 #define PREFIX_SEGES  0x26
335 #define PREFIX_SEGFS  0x64
336 #define PREFIX_SEGGS  0x65
337
338 #define PREFIX_BRANCH0 0x2E
339 #define PREFIX_BRANCH1 0x3E
340
341 #define PREFIX_SZOPER  0x66
342 #define PREFIX_SZADDR  0x67
343
344 void ia32_set_mode_64(bool mode);
345 bool ia32_is_mode_64();
346
347 // addressing methods (see appendix A-2)
348 // I've added am_reg (for registers implicitely encoded in instruciton), 
349 // and am_stackX for stack operands [this kinda' messy since there are actually two operands:
350 // the stack byte/word/dword and the (E)SP register itself - but is better than naught]
351 // added: am_reg, am_stack, am_allgprs
352 enum { am_A=1, am_C, am_D, am_E, am_F, am_G, am_I, am_J, am_M, am_O, // 10
353        am_P, am_Q, am_R, am_S, am_T, am_V, am_W, am_X, am_Y, am_reg, // 20
354        am_stackH, am_stackP, am_allgprs }; // pusH and poP produce different addresses
355
356 // operand types - idem, but I invented quite a few to make implicit operands explicit.
357 enum { op_a=1, op_b, op_c, op_d, op_dq, op_p, op_pd, op_pi, op_ps, // 9 
358        op_q, op_s, op_sd, op_ss, op_si, op_v, op_w, op_z, op_lea, op_allgprs, op_512 };
359
360
361 // tables and pseudotables
362 enum {
363   t_ill=0, t_oneB, t_twoB, t_prefixedSSE, t_coprocEsc, t_grp, t_sse, t_grpsse, t_3dnow, t_done=99
364 };
365
366
367 // registers [only fancy names, not used right now]
368 enum RegisterID { r_AH=0, r_BH, r_CH, r_DH, r_AL, r_BL, r_CL, r_DL, //107
369                   r_AX, r_DX, //109
370                   r_eAX, r_eBX, r_eCX, r_eDX, //113
371                   r_EAX, r_EBX, r_ECX, r_EDX, //117
372                   r_CS, r_DS, r_ES, r_FS, r_GS, r_SS, //123
373                   r_eSP, r_eBP, r_eSI, r_eDI, //127
374                   r_ESP, r_EBP, r_ESI, r_EDI, //131
375                   r_EDXEAX, r_ECXEBX, //133
376                   // above two are hacks for cmpxch8b which would have 5 operands otherwise!!!
377                   r_OF, r_SF, r_ZF, r_AF, r_PF, r_CF, r_TF, r_IF, r_DF, r_NT, r_RF,
378                   // flags need to be separate registers for proper liveness analysis
379                   r_DummyFPR, r_Reserved,
380                   // and we have a dummy register to make liveness consistent since floating point saves are all/none at present
381                   r_R8, r_R9, r_R10, r_R11, r_R12, r_R13, r_R14, r_R15
382                   // AMD64 GPRs
383 }; 
384
385
386
387 // registers used for memory access
388 enum { mRAX=0, mRCX, mRDX, mRBX,
389        mRSP, mRBP, mRSI, mRDI,
390        mR8, mR9, mR10, mR11, 
391        mR12,mR13, MR14, mR15, mRIP };
392
393 enum { mEAX=0, mECX, mEDX, mEBX,
394        mESP, mEBP, mESI, mEDI };
395
396 enum { mAX=0, mCX, mDX, mBX,
397        mSP, mBP, mSI, mDI };
398
399
400 // operand semantic - these make explicit all the implicit stuff in the Intel tables
401 // they are needed for memory access, but may be useful for other things: dataflow etc.
402 // Instructions that do not deal with memory are not tested, so caveat emptor...
403 // Also note that the stack is never specified as an operand in Intel tables, so it
404 // has to be dealt with here.
405
406 enum { sNONE=0, // the instruction does something that cannot be classified as read/write (by me)
407        s1R,     // reads one operand, e.g. jumps
408        s1W,     // e.g. lea
409        s1RW,    // one operand read and written, e.g. inc
410        s1R2R,   // reads two operands, e.g. cmp
411        s1W2R,   // second operand read, first operand written (e.g. mov)
412        s1RW2R,  // two operands read, first written (e.g. add)
413        s1RW2RW, // e.g. xchg
414        s1W2R3R, // e.g. imul
415        s1W2W3R, // e.g. les
416        s1W2RW3R, // some mul
417        s1W2R3RW, // (stack) push & pop
418        s1RW2R3R, // shld/shrd
419        s1RW2RW3R, // [i]div, cmpxch8b
420 }; // should be no more than 2^16 otherwise adjust FPOS below
421
422
423 struct modRMByte {
424   unsigned mod : 2;
425   unsigned reg : 3;
426   unsigned rm  : 3;
427 };
428
429 struct sIBByte {
430   unsigned scale : 2;
431   unsigned index : 3;
432   unsigned base  : 3;
433 };
434
435
436 /**
437  * This structure can be passed to ia32_decode to have it fill in the 
438  * locations of where it found the individual parts of an instruction.
439  **/
440 typedef struct ia32_locations {
441    ia32_locations() : num_prefixes(0), opcode_size(0), opcode_position(-1),
442         disp_size(0), disp_position(-1), imm_position(-1), imm_size(0),
443         modrm_position(-1), modrm_operand(-1), modrm_byte(0), modrm_mod(0),
444         modrm_rm(0), modrm_reg(0), sib_byte(0), sib_position(-1), 
445         rex_position(-1), rex_byte(0), rex_w(0), rex_r(0), rex_x(0), rex_b(0),
446         address_size(0) {}
447    int num_prefixes;
448    unsigned opcode_size;
449    int opcode_position;
450    
451    unsigned disp_size;
452    int disp_position;
453
454    int imm_position;
455    unsigned imm_size;
456    
457    int modrm_position;
458    int modrm_operand;
459    unsigned char modrm_byte;
460    unsigned char modrm_mod;
461    unsigned char modrm_rm;
462    unsigned char modrm_reg;
463
464    unsigned char sib_byte;
465    int sib_position;
466    
467    int rex_position;
468    unsigned char rex_byte;
469    unsigned char rex_w;
470    unsigned char rex_r;
471    unsigned char rex_x;
472    unsigned char rex_b;
473
474    int address_size;
475 } ia32_locations;
476
477 class ia32_prefixes
478 {
479   friend bool ia32_decode_prefixes(const unsigned char* addr, ia32_prefixes&,
480                                    ia32_locations *loc);
481   friend bool ia32_decode_rex(const unsigned char* addr, ia32_prefixes&,
482                               ia32_locations *loc);
483  private:
484   unsigned int count;
485   // At most 4 prefixes are allowed for Intel 32-bit CPUs
486   // There also 4 groups, so this array is 0 if no prefix
487   // from that group is present, otherwise it contains the
488   // prefix opcode
489   // For 64-bit CPUs, an additional REX prefix is possible,
490   // so this array is extended to 5 elements
491   unsigned char prfx[5];
492   unsigned char opcode_prefix;
493  public:
494   unsigned int const getCount() const { return count; }
495   unsigned char getPrefix(unsigned char group) const { return prfx[group]; }
496   bool rexW() const { return prfx[4] & 0x8; }
497   bool rexR() const { return prfx[4] & 0x4; }
498   bool rexX() const { return prfx[4] & 0x2; }
499   bool rexB() const { return prfx[4] & 0x1; }
500   unsigned char getOpcodePrefix() const { return opcode_prefix; }
501   unsigned char getAddrSzPrefix() const { return prfx[3]; }
502   unsigned char getOperSzPrefix() const { return prfx[2]; }
503 };
504
505 // helper routine to tack-on rex bit when needed
506 inline int apply_rex_bit(int reg, bool rex_bit)
507 {
508     if (rex_bit)
509         return reg + 8;
510     else
511         return reg;
512 }
513
514 //VG(6/20/02): To support Paradyn without forcing it to include BPatch_memoryAccess, we
515 //             define this IA-32 "specific" class to encapsulate the same info - yuck
516
517 struct ia32_memacc
518 {
519   bool is;
520   bool read;
521   bool write;
522   bool nt;     // non-temporal, e.g. movntq...
523   bool prefetch;
524
525   int addr_size; // size of address in 16-bit words
526   long imm;
527   int scale;
528   int regs[2]; // register encodings (in ISA order): 0-7
529                // (E)AX, (E)CX, (E)DX, (E)BX
530                // (E)SP, (E)BP, (E)SI, (E)DI
531
532   int size;
533   int sizehack;  // register (E)CX or string based
534   int prefetchlvl; // prefetch level
535   int prefetchstt; // prefetch state (AMD)
536
537   ia32_memacc() : is(false), read(false), write(false), nt(false), 
538        prefetch(false), addr_size(2), imm(0), scale(0), size(0), sizehack(0),
539        prefetchlvl(-1), prefetchstt(-1)
540   {
541     regs[0] = -1;
542     regs[1] = -1;
543   }
544
545   void set16(int reg0, int reg1, long disp)
546   { 
547     is = true;
548     addr_size  = 1; 
549     regs[0] = reg0; 
550     regs[1] = reg1; 
551     imm     = disp;
552   }
553
554   void set(int reg, long disp, int addr_sz)
555   { 
556     is = true;
557     addr_size = addr_sz;
558     regs[0] = reg; 
559     imm     = disp;
560   }
561
562   void set_sib(int base, int scal, int indx, long disp, int addr_sz)
563   {
564     is = true;
565     addr_size = addr_sz;
566     regs[0] = base;
567     regs[1] = indx;
568     scale   = scal;
569     imm     = disp;
570   }
571
572   void setXY(int reg, int _size, int _addr_size)
573   {
574     is = true;
575     regs[0] = reg;
576     size = _size;
577     addr_size = _addr_size;
578   }
579
580   void print();
581 };
582
583 enum sizehacks {
584   shREP=1,
585   shREPECMPS,
586   shREPESCAS,
587   shREPNECMPS,
588   shREPNESCAS
589 };
590
591
592 struct ia32_condition
593 {
594   bool is;
595   // TODO: add a field/hack for ECX [not needed for CMOVcc, but for Jcc]
596   int tttn;
597
598   ia32_condition() : is(false) {}
599   void set(int _tttn) { is = true; tttn = _tttn; }
600 };
601
602 bool ia32_decode_prefixes(const unsigned char* addr, ia32_prefixes&,
603                           ia32_locations *loc = NULL);
604
605
606 struct ia32_operand {  // operand as given in Intel book tables
607   unsigned int admet;  // addressing method
608   unsigned int optype; // operand type;
609 };
610
611 enum entryID {
612   e_No_Entry = 0,
613   e_aaa,
614   e_aad,
615   e_aam,
616   e_aas,
617   e_adc,
618   e_add,
619   e_addpd,
620   e_addps,
621   e_addsd,
622   e_addss,
623   e_and,
624   e_andnpd,
625   e_andnps,
626   e_andpd,
627   e_andps,
628   e_arpl,
629   e_bound,
630   e_bsf,
631   e_bsr,
632   e_bswap,
633   e_bt,
634   e_btc,
635   e_btr,
636   e_bts,
637   e_call,
638   e_cbw_cwde,
639   e_clc,
640   e_cld,
641   e_clflush,
642   e_cli,
643   e_clts,
644   e_cmc,
645   e_cmovbe,
646   e_cmove,
647   e_cmovnae,
648   e_cmovnb,
649   e_cmovnbe,
650   e_cmovne,
651   e_cmovng,
652   e_cmovnge,
653   e_cmovnl,
654   e_cmovno,
655   e_cmovns,
656   e_cmovo,
657   e_cmovpe,
658   e_cmovpo,
659   e_cmovs,
660   e_cmp,
661   e_cmppd,
662   e_cmpps,
663   e_cmpsb,
664   e_cmpsd,
665   e_cmpss,
666   e_cmpsw,
667   e_cmpxch,
668   e_cmpxch8b,
669   e_comisd,
670   e_comiss,
671   e_cpuid,
672   e_cvtdq2pd,
673   e_cvtdq2ps,
674   e_cvtpd2dq,
675   e_cvtpd2pi,
676   e_cvtpd2ps,
677   e_cvtpi2pd,
678   e_cvtpi2ps,
679   e_cvtps2dq,
680   e_cvtps2pd,
681   e_cvtps2pi,
682   e_cvtsd2si,
683   e_cvtsd2ss,
684   e_cvtsi2sd,
685   e_cvtsi2ss,
686   e_cvtss2sd,
687   e_cvtss2si,
688   e_cvttpd2dq,
689   e_cvttpd2pi,
690   e_cvttps2dq,
691   e_cvttps2pi,
692   e_cvttsd2si,
693   e_cvttss2si,
694   e_cwd_cdq,
695   e_daa,
696   e_das,
697   e_dec,
698   e_div,
699   e_divpd,
700   e_divps,
701   e_divsd,
702   e_divss,
703   e_emms,
704   e_enter,
705   e_femms,
706   e_fxrstor,
707   e_fxsave,
708   e_hlt,
709   e_idiv,
710   e_imul,
711   e_in,
712   e_inc,
713   e_insb,
714   e_insw_d,
715   e_int,
716   e_int3,
717   e_int1,
718   e_into,
719   e_invd,
720   e_invlpg,
721   e_iret,
722   e_jb,
723   e_jb_jnaej_j,
724   e_jbe,
725   e_jcxz_jec,
726   e_jl,
727   e_jle,
728   e_jmp,
729   e_jnb,
730   e_jnb_jae_j,
731   e_jnbe,
732   e_jnl,
733   e_jnle,
734   e_jno,
735   e_jnp,
736   e_jns,
737   e_jnz,
738   e_jo,
739   e_jp,
740   e_js,
741   e_jz,
742   e_lahf,
743   e_lar,
744   e_ldmxcsr,
745   e_lds,
746   e_lea,
747   e_leave,
748   e_les,
749   e_lfence,
750   e_lfs,
751   e_lgdt,
752   e_lgs,
753   e_lidt,
754   e_lldt,
755   e_lmsw,
756   e_lodsb,
757   e_lodsw,
758   e_loop,
759   e_loope,
760   e_loopn,
761   e_lsl,
762   e_lss,
763   e_ltr,
764   e_maskmovdqu,
765   e_maskmovq,
766   e_maxpd,
767   e_maxps,
768   e_maxsd,
769   e_maxss,
770   e_mfence,
771   e_minpd,
772   e_minps,
773   e_minsd,
774   e_minss,
775   e_mmxud,
776   e_mov,
777   e_movapd,
778   e_movaps,
779   e_movd,
780   e_movdq2q,
781   e_movdqa,
782   e_movdqu,
783   e_movhpd,
784   e_movhps,
785   e_movhps_movlhps,
786   e_movlpd,
787   e_movlps,
788   e_movlps_movhlps,
789   e_movmskpd,
790   e_movmskps,
791   e_movntdq,
792   e_movnti,
793   e_movntpd,
794   e_movntps,
795   e_movntq,
796   e_movq,
797   e_movq2dq,
798   e_movsb,
799   e_movsd,
800   e_movss,
801   e_movsw_d,
802   e_movsx,
803   e_movsxd,
804   e_movupd,
805   e_movups,
806   e_movzx,
807   e_mul,
808   e_mulpd,
809   e_mulps,
810   e_mulsd,
811   e_mulss,
812   e_neg,
813   e_nop,
814   e_not,
815   e_or,
816   e_orpd,
817   e_orps,
818   e_out,
819   e_outsb,
820   e_outsw_d,
821   e_packssdw,
822   e_packsswb,
823   e_packuswb,
824   e_paddb,
825   e_paddd,
826   e_paddq,
827   e_paddsb,
828   e_paddsw,
829   e_paddusb,
830   e_paddusw,
831   e_paddw,
832   e_pand,
833   e_pandn,
834   e_pavgb,
835   e_pavgw,
836   e_pcmpeqb,
837   e_pcmpeqd,
838   e_pcmpeqw,
839   e_pcmpgdt,
840   e_pcmpgtb,
841   e_pcmpgtw,
842   e_pextrw,
843   e_pinsrw,
844   e_pmaddwd,
845   e_pmaxsw,
846   e_pmaxub,
847   e_pminsw,
848   e_pminub,
849   e_pmovmskb,
850   e_pmulhuw,
851   e_pmulhw,
852   e_pmullw,
853   e_pmuludq,
854   e_pop,
855   e_popa_d,
856   e_popf_d,
857   e_por,
858   e_prefetch,
859   e_prefetchNTA,
860   e_prefetchT0,
861   e_prefetchT1,
862   e_prefetchT2,
863   e_prefetch_w,
864   e_prefetchw,
865   e_psadbw,
866   e_pshufd,
867   e_pshufhw,
868   e_pshuflw,
869   e_pshufw,
870   e_pslld,
871   e_pslldq,
872   e_psllq,
873   e_psllw,
874   e_psrad,
875   e_psraw,
876   e_psrld,
877   e_psrldq,
878   e_psrlq,
879   e_psrlw,
880   e_psubb,
881   e_psubd,
882   e_psubsb,
883   e_psubsw,
884   e_psubusb,
885   e_psubusw,
886   e_psubw,
887   e_punpckhbw,
888   e_punpckhdq,
889   e_punpckhqd,
890   e_punpckhwd,
891   e_punpcklbw,
892   e_punpcklqd,
893   e_punpcklqld,
894   e_punpcklwd,
895   e_push,
896   e_pusha_d,
897   e_pushf_d,
898   e_pxor,
899   e_rcl,
900   e_rcpps,
901   e_rcpss,
902   e_rcr,
903   e_rdmsr,
904   e_rdpmc,
905   e_rdtsc,
906   e_ret_far,
907   e_ret_near,
908   e_rol,
909   e_ror,
910   e_rsm,
911   e_rsqrtps,
912   e_rsqrtss,
913   e_sahf,
914   e_salc,
915   e_sar,
916   e_sbb,
917   e_scasb,
918   e_scasw_d,
919   e_setb,
920   e_setbe,
921   e_setl,
922   e_setle,
923   e_setnb,
924   e_setnbe,
925   e_setnl,
926   e_setnle,
927   e_setno,
928   e_setnp,
929   e_setns,
930   e_setnz,
931   e_seto,
932   e_setp,
933   e_sets,
934   e_setz,
935   e_sfence,
936   e_sgdt,
937   e_shl_sal,
938   e_shld,
939   e_shr,
940   e_shrd,
941   e_shufpd,
942   e_shufps,
943   e_sidt,
944   e_sldt,
945   e_smsw,
946   e_sqrtpd,
947   e_sqrtps,
948   e_sqrtsd,
949   e_sqrtss,
950   e_stc,
951   e_std,
952   e_sti,
953   e_stmxcsr,
954   e_stosb,
955   e_stosw_d,
956   e_str,
957   e_sub,
958   e_subpd,
959   e_subps,
960   e_subsd,
961   e_subss,
962   e_syscall,
963   e_sysenter,
964   e_sysexit,
965   e_sysret,
966   e_test,
967   e_ucomisd,
968   e_ucomiss,
969   e_ud2,
970   e_ud2grp10,
971   e_unpckhpd,
972   e_unpckhps,
973   e_unpcklpd,
974   e_unpcklps,
975   e_verr,
976   e_verw,
977   e_wait,
978   e_wbinvd,
979   e_wrmsr,
980   e_xadd,
981   e_xchg,
982   e_xlat,
983   e_xor,
984   e_xorpd,
985   e_xorps
986 };
987
988 // An instruction table entry
989 struct ia32_entry {
990   const char* name();
991   // returns true if any flags are read/written, false otherwise
992   bool flagsUsed(std::set<RegisterID>& flagsRead, std::set<RegisterID>& flagsWritten);
993   entryID id;
994   unsigned int otable;       // which opcode table is next; if t_done it is the current one
995   unsigned char tabidx;      // at what index to look, 0 if it easy to deduce from opcode
996   bool hasModRM;             // true if the instruction has a MOD/RM byte
997   ia32_operand operands[3];  // operand descriptors
998   unsigned int legacyType;   // legacy type of the instruction (e.g. (IS_CALL | REL_W))
999   // code to decode memory access - this field should be seen as two 16 bit fields
1000   // the lower half gives operand semantics, e.g. s1RW2R, the upper half is a fXXX hack if needed
1001   // before hating me for this: it takes a LOT less time to add ONE field to ~2000 table lines!
1002   unsigned int opsema;  
1003 };
1004
1005 struct flagInfo
1006 {
1007   flagInfo(const vector<RegisterID>& rf, const vector<RegisterID>& wf) : readFlags(rf), writtenFlags(wf) 
1008   {
1009   }
1010   flagInfo() 
1011   {
1012   }
1013   
1014   vector<RegisterID> readFlags;
1015   vector<RegisterID> writtenFlags;
1016 };
1017
1018 class ia32_instruction
1019 {
1020   friend unsigned int ia32_decode_operands (const ia32_prefixes& pref, 
1021                                             const ia32_entry& gotit, 
1022                                             const char* addr, 
1023                                             ia32_instruction& instruct);
1024   friend ia32_instruction& ia32_decode(unsigned int capa, const unsigned char* addr,
1025                                        ia32_instruction& instruct);
1026   friend unsigned int ia32_decode_operands (const ia32_prefixes& pref, const ia32_entry& gotit, 
1027                                             const unsigned char* addr, ia32_instruction& instruct,
1028                                             ia32_memacc *mac = NULL);
1029   friend ia32_instruction& ia32_decode_FP(const ia32_prefixes& pref, const unsigned char* addr,
1030                                           ia32_instruction& instruct);
1031   friend unsigned int ia32_emulate_old_type(ia32_instruction& instruct);
1032   friend ia32_instruction& ia32_decode_FP(unsigned int opcode, 
1033                                           const ia32_prefixes& pref,
1034                                           const unsigned char* addr, 
1035                                           ia32_instruction& instruct,
1036                                           ia32_entry * entry,
1037                                           ia32_memacc *mac = NULL);
1038
1039   unsigned int   size;
1040   ia32_prefixes  prf;
1041   ia32_memacc    *mac;
1042   ia32_condition *cond;
1043   ia32_entry     *entry;
1044   ia32_locations *loc;
1045   unsigned int   legacy_type;
1046   bool           rip_relative_data;
1047
1048
1049  public:
1050   ia32_instruction(ia32_memacc* _mac = NULL, ia32_condition* _cnd = NULL,
1051                    ia32_locations *loc_ = NULL)
1052     : mac(_mac), cond(_cnd), entry(NULL), loc(loc_), rip_relative_data(false) {}
1053
1054   ia32_entry * getEntry() { return entry; }
1055   unsigned int getSize() const { return size; }
1056   unsigned int getPrefixCount() const { return prf.getCount(); }
1057   ia32_prefixes * getPrefix() { return &prf; }
1058   unsigned int getLegacyType() const { return legacy_type; }
1059   bool hasRipRelativeData() const { return rip_relative_data; }
1060   const ia32_memacc& getMac(int which) const { return mac[which]; }
1061   const ia32_condition& getCond() const { return *cond; }
1062   const ia32_locations& getLocationInfo() const { return *loc; }
1063
1064   static const std::map<entryID, flagInfo>& getFlagTable();
1065   static void initFlagTable(std::map<entryID, flagInfo>&);
1066   
1067 };
1068
1069 // VG(02/07/2002): Information that the decoder can return is
1070 //   #defined below. The decoder always returns the size of the 
1071 //   instruction because that has to be determined anyway.
1072 //   Please don't add things that should be external to the
1073 //   decoder, e.g.: how may bytes a relocated instruction needs
1074 //   IMHO that stuff should go into inst-x86...
1075
1076 #define IA32_DECODE_PREFIXES    (1<<0)
1077 #define IA32_DECODE_MNEMONICS   (1<<1)
1078 #define IA32_DECODE_OPERANDS    (1<<2)
1079 #define IA32_DECODE_JMPS        (1<<3)
1080 #define IA32_DECODE_MEMACCESS   (1<<4)
1081 #define IA32_DECODE_CONDITION   (1<<5)
1082
1083 #define IA32_FULL_DECODER (IA32_DECODE_PREFIXES | IA32_DECODE_MNEMONICS | IA32_DECODE_OPERANDS | IA32_DECODE_JMPS | IA32_DECODE_MEMACCESS | IA32_DECODE_CONDITION)
1084 #define IA32_SIZE_DECODER 0
1085
1086 ia32_instruction& ia32_decode(unsigned int capabilities, const unsigned char* addr, ia32_instruction&);
1087
1088
1089 enum dynamic_call_address_mode {
1090   REGISTER_DIRECT, REGISTER_INDIRECT,
1091   REGISTER_INDIRECT_DISPLACED, SIB, DISPLACED
1092 };
1093
1094 /*
1095    get_instruction: get the instruction that starts at instr.
1096    return the size of the instruction and set instType to a type descriptor
1097 */
1098 unsigned get_instruction(const unsigned char *instr, unsigned &instType,
1099                          const unsigned char** op_ptr = NULL);
1100
1101 /* get the target of a jump or call */
1102 Address get_target(const unsigned char *instr, unsigned type, unsigned size,
1103                    Address addr);
1104
1105 // Size of a jump rel32 instruction
1106 #define JUMP_REL32_SZ (5)
1107 #define JUMP_SZ (5)
1108 // Size of a call rel32 instruction
1109 #define CALL_REL32_SZ (5)
1110
1111 #if defined(arch_x86_64)
1112 // size of instruction seqeunce to get anywhere in address space
1113 // without touching any registers
1114 #define JUMP_ABS64_SZ (17)
1115 // Jump is push/return; call is push/push/return, so subtract a return
1116 #define CALL_ABS64_SZ (JUMP_ABS64_SZ+JUMP_ABS64_SZ-1)
1117 #endif
1118
1119 #define PUSH_RM_OPC1 (0xFF)
1120 #define PUSH_RM_OPC2 (6)
1121 #define CALL_RM_OPC1 (0xFF)
1122 #define CALL_RM_OPC2 (2)
1123 #define PUSH_EBP (0x50+REGNUM_EBP)
1124 #define SUB_REG_IMM32 (5)
1125 #define LEAVE (0xC9)
1126
1127 #define EXTENDED_0x81_ADD 0
1128 #define EXTENDED_0x81_OR 1
1129 #define EXTENDED_0x81_ADDC 2
1130 #define EXTENDED_0x81_SHIFT 3
1131 #define EXTENDED_0x81_AND 4
1132 #define EXTENDED_0x81_SUB 5
1133 #define EXTENDED_0x81_XOR 6
1134 #define EXTENDED_0x81_CMP 7
1135
1136 class instruction: public Annotatable<instruction> {
1137  public:
1138     instruction(): type_(0), size_(0), ptr_(0), op_ptr_(0) {}
1139
1140   instruction(const unsigned char *p, unsigned type, unsigned sz, const unsigned char* op = 0):
1141       type_(type), size_(sz), ptr_(p), op_ptr_(op ? op : p) {}
1142
1143   instruction(const instruction &insn): Annotatable<instruction>() {
1144     type_ = insn.type_;
1145     size_ = insn.size_;
1146     ptr_ = insn.ptr_;
1147     op_ptr_ = insn.op_ptr_;
1148   }
1149   
1150   instruction *copy() const;
1151
1152   instruction(const void *ptr) :
1153       type_(0), size_(0), ptr_(NULL), op_ptr_(0) {
1154       setInstruction((const unsigned char*)ptr);
1155   }
1156
1157   unsigned setInstruction(const unsigned char *p, Address = 0) {
1158       ptr_ = p;
1159       size_ = get_instruction(ptr_, type_, &op_ptr_);
1160       return size_;
1161   }
1162
1163   // if the instruction is a jump or call, return the target, else return zero
1164   Address getTarget(Address addr) const { 
1165     return (Address)get_target(ptr_, type_, size_, addr); 
1166   }
1167
1168   // return the size of the instruction in bytes
1169   unsigned size() const { return size_; }
1170
1171   // And the size necessary to reproduce this instruction
1172   // at some random point.
1173   unsigned spaceToRelocate() const;
1174
1175   // return the type of the instruction
1176   unsigned type() const { return type_; }
1177
1178   // return a pointer to the instruction
1179   const unsigned char *ptr() const { 
1180       return ptr_; 
1181   }
1182
1183   // return a pointer to the instruction's opcode
1184   const unsigned char* op_ptr() const { return op_ptr_; }
1185
1186   // More code generation
1187   static void generatePush64(codeGen &gen, Address val);
1188
1189   // Code generation
1190   static void generateBranch(codeGen &gen, Address from, Address to); 
1191   static void generateBranch(codeGen &gen, int disp); 
1192   static void generateBranch64(codeGen &gen, Address to);
1193   static void generateCall(codeGen &gen, Address from, Address to);
1194   
1195   // Function relocation...
1196   static void generateInterFunctionBranch(codeGen &gen, Address from, Address to) { generateBranch(gen, from, to); }
1197   static unsigned maxInterFunctionJumpSize() { return maxJumpSize(); }
1198
1199   // And tell us how much space we'll need...
1200   static unsigned jumpSize(Address from, Address to);
1201   static unsigned jumpSize(long disp);
1202   static unsigned maxJumpSize();
1203
1204
1205   // We may want to generate an efficient set 'o nops
1206   static void generateNOOP(codeGen &gen, unsigned size = 1);
1207   
1208   static void generateIllegal(codeGen &gen);
1209   static void generateTrap(codeGen &gen);
1210
1211   void generate(codeGen &gen);
1212
1213   // And generate an equivalent stream somewhere else...
1214   // fallthroughOverride and targetOverride are used for
1215   // making the behavior of jumps change. It won't work for 
1216   // jumptables; that should be cleared up sometime.
1217   bool generate(codeGen &gen,
1218                 AddressSpace *addrSpace,
1219                 Address origAddr,
1220                 Address newAddr,
1221                 Address fallthroughOverride = 0,
1222                 Address targetOverride = 0);
1223
1224   bool getUsedRegs(pdvector<int> &regs);
1225   bool generateMem(codeGen &gen,
1226                    Address origAddr,
1227                    Address newAddr,
1228                    Register newLoadReg,
1229                    Register newStoreReg);
1230   
1231   bool isCall() const { return type_ & IS_CALL; }
1232   bool isCallIndir() const { return (type_ & IS_CALL) && (type_ & INDIR); }
1233   bool isReturn() const { return (type_ & IS_RET) || (type_ & IS_RETF); }
1234   bool isRetFar() const { return type_ & IS_RETF; }
1235   bool isCleaningRet() const {return type_ & IS_RETC; }
1236   bool isJumpIndir() const { return (type_ & IS_JUMP) && (type_ & INDIR); }
1237   bool isJumpDir() const
1238     { return ~(type_ & INDIR) && ((type_ & IS_JUMP) || (type_ & IS_JCC)); }
1239   bool isUncondJump() const
1240     { return ((type_ & IS_JUMP) && !(type_ & IS_JCC)); }
1241   bool isNop() const { return *ptr_ == 0x90; }
1242   bool isIndir() const { return type_ & INDIR; }
1243   bool isIllegal() const { return type_ & ILLEGAL; }
1244   bool isLeave() const { return *ptr_ == 0xC9; }  
1245   bool isPrivileged() const { return (type_ & PRVLGD); }
1246   bool isMoveRegMemToRegMem() const 
1247     { const unsigned char* p = op_ptr_ ? op_ptr_ : ptr_;
1248       return *p == MOV_R8_TO_RM8   || *p == MOV_R16_TO_RM16 ||
1249              *p == MOV_R32_TO_RM32 || *p ==  MOV_RM8_TO_R8  ||
1250              *p == MOV_RM16_TO_R16 || *p == MOV_RM32_TO_R32;   }
1251   bool isXORRegMemRegMem() const
1252       { const unsigned char* p = op_ptr_ ? op_ptr_ : ptr_;
1253         return *p == XOR_RM16_R16 || *p ==  XOR_RM32_R32 ||
1254                *p ==  XOR_R8_RM8  || *p ==  XOR_R16_RM16 ||
1255                *p == XOR_R32_RM32; }
1256   bool isANearBranch() const { return isJumpDir(); }
1257
1258   bool isTrueCallInsn() const { return (isCall() && !isCallIndir()); }
1259   bool isSysCallInsn() const { return op_ptr_[0] == SYSCALL[0] &&
1260                                    op_ptr_[1] == SYSCALL[1]; }
1261
1262   static bool isAligned(const Address ) { return true; }
1263
1264   bool isCmp() const;
1265
1266   void print()
1267   {
1268       for (unsigned i = 0; i < size_; i++)
1269           fprintf(stderr, " %x", *(ptr_ + i));
1270       fprintf(stderr, "\n");
1271   }
1272                   
1273
1274  private:
1275   unsigned type_;   // type of the instruction (e.g. IS_CALL | INDIR)
1276   unsigned size_;   // size in bytes
1277   const unsigned char *ptr_;       // pointer to the instruction
1278   const unsigned char *op_ptr_;    // pointer to the opcode
1279 };
1280
1281
1282 int get_disp(instruction *insn);
1283 int set_disp(bool setDisp, instruction *insn, int newOffset, bool outOfFunc);
1284 int displacement(const unsigned char *instr, unsigned type);
1285
1286 int sizeOfMachineInsn(instruction *insn);
1287 long addressOfMachineInsn(instruction *insn);
1288
1289 inline bool is_disp32(long disp) {
1290   return (disp <= I32_MAX && disp >= I32_MIN);
1291 }
1292 inline bool is_disp32(Address a1, Address a2) {
1293   return is_disp32(a2 - (a1 + JUMP_REL32_SZ));
1294 }
1295 inline bool is_addr32(Address addr) {
1296     return (addr < UI32_MAX);
1297 }
1298
1299 int get_instruction_operand(const unsigned char *i_ptr, Register& base_reg,
1300                             Register& index_reg, int& displacement, 
1301                             unsigned& scale, unsigned &mod);
1302 void decode_SIB(unsigned sib, unsigned& scale, Register& index_reg, Register& base_reg);
1303 const unsigned char* skip_headers(const unsigned char*, ia32_prefixes* = NULL);
1304
1305 /* addresses on x86 don't have to be aligned */
1306 /* Address bounds of new dynamic heap segments.  On x86 we don't try
1307 to allocate new segments near base tramps, so heap segments can be
1308 allocated anywhere (the tramp address "x" is ignored). */
1309 inline Address region_lo(const Address /*x*/) { return 0x00000000; }
1310 inline Address region_hi(const Address /*x*/) { return 0xf0000000; }
1311
1312 #if defined(arch_x86_64)
1313 // range functions for AMD64
1314
1315 #if 0
1316 inline Address region_lo_64(const Address x) { return 0x0; }
1317 inline Address region_hi_64(const Address x) { return ~0x0; }
1318 #endif
1319 inline Address region_lo_64(const Address x) { return x & 0xffffffff80000000; }
1320 inline Address region_hi_64(const Address x) { return x | 0x000000007fffffff; }
1321
1322 #endif
1323
1324 bool insn_hasSIB(unsigned,unsigned&,unsigned&,unsigned&);
1325 bool insn_hasDisp8(unsigned ModRM);
1326 bool insn_hasDisp32(unsigned ModRM);
1327 bool isFunctionPrologue( instruction& insn1 );
1328 bool isStackFramePreamble( instruction& insn );
1329
1330 #endif