Update copyright to LGPL on all files
[dyninst.git] / instructionAPI / src / arch-x86.h
1 /*
2  * Copyright (c) 1996-2009 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  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 // $Id: arch-x86.h,v 1.6 2008/10/28 18:42:41 bernat Exp $
33 // x86 instruction declarations
34
35 #include <stdio.h>
36 #include <set>
37 #include <map>
38 #include <vector>
39 #include "../../common/h/Types.h"
40 #include "../h/RegisterIDs-x86.h"
41 #include "../h/entryIDs-IA32.h"
42
43 #ifndef _ARCH_X86_IAPI_H
44 #define _ARCH_X86_IAPI_H
45
46 #if defined(i386_unknown_nt4_0)
47 // disable VC++ warning C4800: (performance warning)
48 // forcing 'unsigned int' value to bool 'true' or 'false'
49 #pragma warning (disable : 4800)
50 #endif
51
52 /* operand types */
53 typedef char byte_t;   /* a byte operand */
54 typedef short word_t;  /* a word (16-bit) operand */
55 typedef int dword_t;   /* a double word (32-bit) operand */
56
57 #if defined(arch_x86_64)
58 #define maxGPR 16
59 #else
60 #define maxGPR 8
61 #endif 
62
63 #define READ_OP 0
64 #define WRITE_OP 1
65
66 /* operand sizes */
67 #define byteSzB (1)    /* size of a byte operand */
68 #define wordSzB (2)    /* size of a word operand */
69 #define dwordSzB (4)   /* size of a dword operand */
70 #define qwordSzB (8)   /* size of a qword operand */
71 #define dqwordSzB (16)   /* size of a double qword (oword) operand */
72
73 /* The following values are or'ed together to form an instruction type descriptor */
74 /* the instruction types of interest */
75 #define IS_CALL (1<<1)   /* call instruction */
76 #define IS_RET  (1<<2)   /* near return instruction */
77 #define IS_RETF (1<<3)   /* far return instruction */
78 #define IS_JUMP (1<<4)   /* jump instruction */
79 #define IS_JCC  (1<<5)   /* conditional jump instruction */
80 #define ILLEGAL (1<<6)   /* illegal instruction */
81 #define PRVLGD  (1<<7)   /* privileged */
82 #define IS_RETC (1<<8)   /* return and pop bytes off of stack*/
83 #define IS_NOP  (1<<9)   /* Nop, Lea--lea is only sometime a return, be sure to double check */
84
85 /* addressing modes for calls and jumps */
86 #define REL_B   (1<<10)  /* relative address, byte offset */
87 #define REL_W   (1<<11)  /* relative address, word offset */
88 #define REL_D   (1<<12)  /* relative address, dword offset */
89 #define REL_X   (1<<13)  /* relative address, word or dword offset */
90 #define INDIR   (1<<14)  /* indirect (register or memory) address */
91 #define PTR_WW  (1<<15)  /* 4-byte pointer */
92 #define PTR_WD  (1<<16)  /* 6-byte pointer */
93 #define PTR_WX  (1<<17)  /* 4 or 6-byte pointer */
94 #define REL_D_DATA (1<<18) /* AMD64 RIP-relative data addressing */
95
96 /* prefixes */
97 #define PREFIX_INST   (1<<20) /* instruction prefix */
98 #define PREFIX_SEG    (1<<21) /* segment override prefix */
99 #define PREFIX_OPR    (1<<22) /* operand size override */
100 #define PREFIX_ADDR   (1<<23) /* address size override */
101 #define PREFIX_REX    (1<<24) /* AMD64 REX prefix */
102 #define PREFIX_OPCODE (1<<25) /* prefix is part of opcode (SSE) */
103
104 /* end of instruction type descriptor values */
105
106  
107 /* opcodes of some one byte opcode instructions */
108 /* ADD */
109 #define ADD_EB_GB (0x00)
110 #define ADD_EV_GV (0x01)
111 #define ADD_GB_EB (0x02)
112 #define ADD_GV_EV (0x03)
113 #define ADD_AL_LB (0x04)
114 #define ADD_RAX_LZ (0x05)
115
116 #define PUSHES    (0x06) /* Invalid in 64 bit mode */
117 #define POPES     (0x07) /* Invalid in 64 bit mode */
118
119 /* OR */
120 #define OR_EB_GB (0x08)
121 #define OR_EV_GV (0x09)
122 #define OR_GB_EB (0x0A)
123 #define OR_GV_EV (0x0B)
124 #define OR_AL_LB (0x0C)
125 #define OR_RAX_LZ (0x0D)
126
127 #define PUSHCS    (0x0E) /* Invalid in 64 bit mode */
128 #define TWO_BYTE_OPCODE (0x0F)
129
130 /* ADC */
131 #define ADC_EB_GB (0x10)
132 #define ADC_EV_GV (0x11)
133 #define ADC_GB_EB (0x12)
134 #define ADC_GV_EV (0x13)
135 #define ADC_AL_LB (0x14)
136 #define ADC_RAX_LZ (0x15)
137
138 #define PUSHSS    (0x16) /* Invalid in 64 bit mode */
139 #define POPSS     (0x17) /* Invalid in 64 bit mode */
140
141 /* SBB */
142 #define SBB_EB_GB (0x18)
143 #define SBB_EV_GV (0x19)
144 #define SBB_GB_EB (0x1A)
145 #define SBB_GV_EV (0x1B)
146 #define SBB_AL_LB (0x1C)
147 #define SBB_RAX_LZ (0x1D)
148
149 #define PUSH_DS  (0x1E) /* Invalid in 64 bit mode */
150 #define POP_DS   (0X1F) /* Invalid in 64 bit mode */
151
152 /* AND */
153 #define AND_EB_GB (0x20)
154 #define AND_EV_GV (0x21)
155 #define AND_GB_EB (0x22)
156 #define AND_GV_EV (0x23)
157 #define AND_AL_LB (0x24)
158 #define AND_RAX_LZ (0x25)
159
160 #define SEG_ES (0x26) /* Null prefix in 64-bit mode */
161 #define DAA    (0x27) /* Invalid in 64-bit mode */
162
163 /* SUB */
164 #define SUB_EB_GB (0x28)
165 #define SUB_EV_GV (0x29)
166 #define SUB_GB_EB (0x2A)
167 #define SUB_GV_EV (0x2B)
168 #define SUB_AL_LB (0x2C)
169 #define SUB_RAX_LZ (0x2D)
170
171 //(0x2E)
172 //   (0x2F)
173
174 /* XOR */
175 #define XOR_EB_GB (0x30)
176 #define XOR_EV_GV (0x31)
177 #define XOR_GB_EB (0x32)
178 #define XOR_GV_EV (0x33)
179 #define XOR_AL_LB (0x34)
180 #define XOR_RAX_LZ (0x35)
181
182 #define XOR_RM16_R16 (0x31)
183 #define XOR_RM32_R32 (0x31)
184 #define XOR_R8_RM8 (0x32)
185 #define XOR_R16_RM16 (0x33)
186 #define XOR_R32_RM32 (0x33)
187
188 #define SEG_SS (0x36) /* Null prefix in 64 bit mode */
189 #define AAA (0x37)    /* Invalid in 64-bit mode */
190
191
192 /* CMP */
193 #define CMP_EB_GB (0x38)
194 #define CMP_EV_GV (0x39)
195 #define CMP_GB_EB (0x3A)
196 #define CMP_GV_EV (0x3B)
197 #define CMP_AL_LB (0x3C)
198 #define CMP_RAX_LZ (0x3D)
199
200 //   (0x3E)
201 //   (0x3F)
202
203 /* INC - REX Prefixes in 64 bit mode*/
204 #define INC_EAX  (0x40)
205 #define INC_ECX  (0x41)
206 #define INC_EDX  (0x42)
207 #define INC_EBX  (0x43)
208 #define INC_ESP  (0x44)
209 #define INC_EBP  (0x45)
210 #define INC_ESI  (0x46)
211 #define INC_EDI  (0x47)
212
213 /* DEC - REX Prefixes in 64 bit mode */
214 #define DEC_EAX  (0x48)
215 #define DEC_ECX  (0x49)
216 #define DEC_EDX  (0x50)
217 #define DEC_EBX  (0x51)
218 #define DEC_ESP  (0x52)
219 #define DEC_EBP  (0x53)
220 #define DEC_ESI  (0x54)
221 #define DEC_EDI  (0x55)
222
223 /* PUSH */
224 #define PUSHEAX  (0x50)
225 #define PUSHECX  (0x51)
226 #define PUSHEDX  (0x52)
227 #define PUSHEBX  (0x53)
228 #define PUSHESP  (0x54)
229 #define PUSHEBP  (0x55)
230 #define PUSHESI  (0x56)
231 #define PUSHEDI  (0x57)
232
233 /* POP */
234 #define POP_EAX  (0x58)
235 #define POP_ECX  (0x59)
236 #define POP_EDX  (0x5A)
237 #define POP_EBX  (0x5b)
238 #define POP_ESP  (0x5c)
239 #define POP_EBP  (0x5d)
240 #define POP_EBI  (0x5e)
241 #define POP_EDI  (0x5f)
242
243
244 #define PUSHAD   (0x60)
245 #define POPAD    (0x61)
246
247
248
249
250 #define JE_R8    (0x74)
251 #define JNE_R8   (0x75)
252 #define JL_R8    (0x7C)
253 #define JLE_R8   (0x7E)
254 #define JG_R8    (0x7F)
255 #define JGE_R8   (0x7D)
256
257
258 #define MOVREGMEM_REG (0x8b) 
259 #define MOV_R8_TO_RM8 (0x88)     //move r8 to r/m8
260 #define MOV_R16_TO_RM16 (0x89)   //move r16 to r/m16
261 #define MOV_R32_TO_RM32 (0x89)   //move r32 to r/m32
262 #define MOV_RM8_TO_R8 (0x8A)
263 #define MOV_RM16_TO_R16 (0x8b)
264 #define MOV_RM32_TO_R32 (0x8b)
265
266
267
268 #define NOP      (0x90)
269 #define PUSHFD   (0x9C)
270 #define POPFD    (0x9D)
271
272
273 #define JCXZ     (0xE3)
274
275
276
277
278
279
280 #define FSAVE    (0x9BDD)
281 #define FSAVE_OP (6)
282
283 #define FRSTOR   (0xDD)
284 #define FRSTOR_OP (4)
285
286 const unsigned char SYSCALL[] = {0x0F, 0x05};
287
288 /* limits */
289 #define MIN_IMM8 (-128)
290 #define MAX_IMM8 (127)
291 #define MIN_IMM16 (-32768)
292 #define MAX_IMM16 (32767)
293
294 // Size of floating point information saved by FSAVE
295 #define FSAVE_STATE_SIZE 108
296
297 // Prefix groups
298 enum {
299   RepGroup = 0
300 };
301
302
303
304 #ifndef PREFIX_LOCK
305
306 #define PREFIX_LOCK   (unsigned char)(0xF0)
307 #define PREFIX_REPNZ  (unsigned char)(0xF2)
308 #define PREFIX_REP    (unsigned char)(0xF3)
309
310 #define PREFIX_SEGCS  (unsigned char)(0x2E)
311 #define PREFIX_SEGSS  (unsigned char)(0x36)
312 #define PREFIX_SEGDS  (unsigned char)(0x3E)
313 #define PREFIX_SEGES  (unsigned char)(0x26)
314 #define PREFIX_SEGFS  (unsigned char)(0x64)
315 #define PREFIX_SEGGS  (unsigned char)(0x65)
316
317 #define PREFIX_BRANCH0 (unsigned char)(0x2E)
318 #define PREFIX_BRANCH1 (unsigned char)(0x3E)
319
320 #define PREFIX_SZOPER  (unsigned char)(0x66)
321 #define PREFIX_SZADDR  (unsigned char)(0x67)
322 #endif
323
324
325 INSTRUCTION_EXPORT void ia32_set_mode_64(bool mode);
326 INSTRUCTION_EXPORT bool ia32_is_mode_64();
327
328 // addressing methods (see appendix A-2)
329 // I've added am_reg (for registers implicitely encoded in instruciton), 
330 // and am_stackX for stack operands [this kinda' messy since there are actually two operands:
331 // the stack byte/word/dword and the (E)SP register itself - but is better than naught]
332 // added: am_reg, am_stack, am_allgprs
333 enum { am_A=1, am_C, am_D, am_E, am_F, am_G, am_I, am_J, am_M, am_O, // 10
334        am_P, am_Q, am_R, am_S, am_T, am_V, am_W, am_X, am_Y, am_reg, // 20
335        am_stackH, am_stackP, am_allgprs, am_VR }; // pusH and poP produce different addresses
336
337 // operand types - idem, but I invented quite a few to make implicit operands explicit.
338 enum { op_a=1, op_b, op_c, op_d, op_dq, op_p, op_pd, op_pi, op_ps, // 9 
339        op_q, op_s, op_sd, op_ss, op_si, op_v, op_w, op_z, op_lea, op_allgprs, op_512,
340        op_f, op_dbl, op_14, op_28};
341
342
343 // tables and pseudotables
344 enum {
345   t_ill=0, t_oneB, t_twoB, t_prefixedSSE, t_coprocEsc, t_grp, t_sse, t_grpsse, t_3dnow, t_done=99
346 };
347
348
349 // registers [only fancy names, not used right now]
350 /* enum RegisterID { r_AH=100, r_BH, r_CH, r_DH, r_AL, r_BL, r_CL, r_DL, //107 */
351 /*                r_AX, r_DX, //109 */
352 /*                r_eAX, r_eBX, r_eCX, r_eDX, //113 */
353 /*                r_EAX, r_EBX, r_ECX, r_EDX, //117 */
354 /*                r_CS, r_DS, r_ES, r_FS, r_GS, r_SS, //123 */
355 /*                r_eSP, r_eBP, r_eSI, r_eDI, //127 */
356 /*                r_ESP, r_EBP, r_ESI, r_EDI, //131 */
357 /*                r_EDXEAX, r_ECXEBX, //133 */
358 /*                // above two are hacks for cmpxch8b which would have 5 operands otherwise!!! */
359 /*                r_OF, r_SF, r_ZF, r_AF, r_PF, r_CF, r_TF, r_IF, r_DF, r_NT, r_RF, */
360 /*                // flags need to be separate registers for proper liveness analysis */
361 /*                r_DummyFPR, r_Reserved, */
362 /*                // and we have a dummy register to make liveness consistent since floating point saves are all/none at present */
363 /*                r_R8, r_R9, r_R10, r_R11, r_R12, r_R13, r_R14, r_R15 */
364 /*                // AMD64 GPRs */
365 /* };  */
366
367
368
369 // registers used for memory access
370 enum { mRAX=0, mRCX, mRDX, mRBX,
371        mRSP, mRBP, mRSI, mRDI,
372        mR8, mR9, mR10, mR11, 
373        mR12,mR13, MR14, mR15, mRIP };
374
375 enum { mEAX=0, mECX, mEDX, mEBX,
376        mESP, mEBP, mESI, mEDI };
377
378 enum { mAX=0, mCX, mDX, mBX,
379        mSP, mBP, mSI, mDI };
380
381
382 // operand semantic - these make explicit all the implicit stuff in the Intel tables
383 // they are needed for memory access, but may be useful for other things: dataflow etc.
384 // Instructions that do not deal with memory are not tested, so caveat emptor...
385 // Also note that the stack is never specified as an operand in Intel tables, so it
386 // has to be dealt with here.
387
388 enum { sNONE=0, // the instruction does something that cannot be classified as read/write (by me)
389        s1R,     // reads one operand, e.g. jumps
390        s1W,     // e.g. lea
391        s1RW,    // one operand read and written, e.g. inc
392        s1R2R,   // reads two operands, e.g. cmp
393        s1W2R,   // second operand read, first operand written (e.g. mov)
394        s1RW2R,  // two operands read, first written (e.g. add)
395        s1RW2RW, // e.g. xchg
396        s1W2R3R, // e.g. imul
397        s1W2W3R, // e.g. les
398        s1W2RW3R, // some mul
399        s1R2RW, // (stack) push
400        s1W2RW, // pop
401        s1W2R3RW, // additional push/pop
402        s1RW2R3R, // shld/shrd
403        s1RW2RW3R, // [i]div, cmpxch8b
404 }; // should be no more than 2^16 otherwise adjust FPOS below
405
406
407 struct modRMByte {
408   unsigned mod : 2;
409   unsigned reg : 3;
410   unsigned rm  : 3;
411 };
412
413 struct sIBByte {
414   unsigned scale : 2;
415   unsigned index : 3;
416   unsigned base  : 3;
417 };
418
419
420 /**
421  * This structure can be passed to ia32_decode to have it fill in the 
422  * locations of where it found the individual parts of an instruction.
423  **/
424 typedef struct ia32_locations {
425    ia32_locations() : num_prefixes(0), opcode_size(0), opcode_position(-1),
426         disp_size(0), disp_position(-1), imm_position(-1), imm_size(0),
427         modrm_position(-1), modrm_operand(-1), modrm_byte(0), modrm_mod(0),
428         modrm_rm(0), modrm_reg(0), sib_byte(0), sib_position(-1), 
429         rex_position(-1), rex_byte(0), rex_w(0), rex_r(0), rex_x(0), rex_b(0),
430         address_size(0) {}
431    int num_prefixes;
432    unsigned opcode_size;
433    int opcode_position;
434    
435    unsigned disp_size;
436    int disp_position;
437
438    int imm_position;
439    unsigned imm_size;
440    
441    int modrm_position;
442    int modrm_operand;
443    unsigned char modrm_byte;
444    unsigned char modrm_mod;
445    unsigned char modrm_rm;
446    unsigned char modrm_reg;
447
448    unsigned char sib_byte;
449    int sib_position;
450    
451    int rex_position;
452    unsigned char rex_byte;
453    unsigned char rex_w;
454    unsigned char rex_r;
455    unsigned char rex_x;
456    unsigned char rex_b;
457
458    int address_size;
459 } ia32_locations;
460
461 class ia32_prefixes
462 {
463   friend bool ia32_decode_prefixes(const unsigned char* addr, ia32_prefixes&,
464                                    ia32_locations *loc);
465   friend bool ia32_decode_rex(const unsigned char* addr, ia32_prefixes&,
466                               ia32_locations *loc);
467  private:
468   unsigned int count;
469   // At most 4 prefixes are allowed for Intel 32-bit CPUs
470   // There also 4 groups, so this array is 0 if no prefix
471   // from that group is present, otherwise it contains the
472   // prefix opcode
473   // For 64-bit CPUs, an additional REX prefix is possible,
474   // so this array is extended to 5 elements
475   unsigned char prfx[5];
476   unsigned char opcode_prefix;
477  public:
478   unsigned int getCount() const { return count; }
479   unsigned char getPrefix(unsigned char group) const { assert(group <= 4); return prfx[group]; }
480   bool rexW() const { return prfx[4] & 0x8; }
481   bool rexR() const { return prfx[4] & 0x4; }
482   bool rexX() const { return prfx[4] & 0x2; }
483   bool rexB() const { return prfx[4] & 0x1; }
484   unsigned char getOpcodePrefix() const { return opcode_prefix; }
485   unsigned char getAddrSzPrefix() const { return prfx[3]; }
486   unsigned char getOperSzPrefix() const { return prfx[2]; }
487 };
488
489 // helper routine to tack-on rex bit when needed
490 inline int apply_rex_bit(int reg, bool rex_bit)
491 {
492     if (rex_bit)
493         return reg + 8;
494     else
495         return reg;
496 }
497
498 //VG(6/20/02): To support Paradyn without forcing it to include BPatch_memoryAccess, we
499 //             define this IA-32 "specific" class to encapsulate the same info - yuck
500
501 struct ia32_memacc
502 {
503   bool is;
504   bool read;
505   bool write;
506   bool nt;     // non-temporal, e.g. movntq...
507   bool prefetch;
508
509   int addr_size; // size of address in 16-bit words
510   long imm;
511   int scale;
512   int regs[2]; // register encodings (in ISA order): 0-7
513                // (E)AX, (E)CX, (E)DX, (E)BX
514                // (E)SP, (E)BP, (E)SI, (E)DI
515
516   int size;
517   int sizehack;  // register (E)CX or string based
518   int prefetchlvl; // prefetch level
519   int prefetchstt; // prefetch state (AMD)
520
521   ia32_memacc() : is(false), read(false), write(false), nt(false), 
522        prefetch(false), addr_size(2), imm(0), scale(0), size(0), sizehack(0),
523        prefetchlvl(-1), prefetchstt(-1)
524   {
525     regs[0] = -1;
526     regs[1] = -1;
527   }
528
529   void set16(int reg0, int reg1, long disp)
530   { 
531     is = true;
532     addr_size  = 1; 
533     regs[0] = reg0; 
534     regs[1] = reg1; 
535     imm     = disp;
536   }
537
538   void set(int reg, long disp, int addr_sz)
539   { 
540     is = true;
541     addr_size = addr_sz;
542     regs[0] = reg; 
543     imm     = disp;
544   }
545
546   void set_sib(int base, int scal, int indx, long disp, int addr_sz)
547   {
548     is = true;
549     addr_size = addr_sz;
550     regs[0] = base;
551     regs[1] = indx;
552     scale   = scal;
553     imm     = disp;
554   }
555
556   void setXY(int reg, int _size, int _addr_size)
557   {
558     is = true;
559     regs[0] = reg;
560     size = _size;
561     addr_size = _addr_size;
562   }
563
564   void print();
565 };
566
567 enum sizehacks {
568   shREP=1,
569   shREPECMPS,
570   shREPESCAS,
571   shREPNECMPS,
572   shREPNESCAS
573 };
574
575
576 struct ia32_condition
577 {
578   bool is;
579   // TODO: add a field/hack for ECX [not needed for CMOVcc, but for Jcc]
580   int tttn;
581
582   ia32_condition() : is(false) {}
583   void set(int _tttn) { is = true; tttn = _tttn; }
584 };
585
586 bool ia32_decode_prefixes(const unsigned char* addr, ia32_prefixes&,
587                           ia32_locations *loc = NULL);
588
589
590 struct ia32_operand {  // operand as given in Intel book tables
591   unsigned int admet;  // addressing method
592   unsigned int optype; // operand type;
593 };
594
595 // An instruction table entry
596 struct ia32_entry {
597   const char* name(ia32_locations* locs = NULL);
598   INSTRUCTION_EXPORT entryID getID(ia32_locations* locs = NULL) const;
599   // returns true if any flags are read/written, false otherwise
600   INSTRUCTION_EXPORT bool flagsUsed(std::set<Dyninst::InstructionAPI::IA32Regs>& flagsRead, std::set<Dyninst::InstructionAPI::IA32Regs>& flagsWritten,
601                  ia32_locations* locs = NULL);
602   entryID id;
603   unsigned int otable;       // which opcode table is next; if t_done it is the current one
604   unsigned char tabidx;      // at what index to look, 0 if it easy to deduce from opcode
605   bool hasModRM;             // true if the instruction has a MOD/RM byte
606   ia32_operand operands[3];  // operand descriptors
607   unsigned int legacyType;   // legacy type of the instruction (e.g. (IS_CALL | REL_W))
608   // code to decode memory access - this field should be seen as two 16 bit fields
609   // the lower half gives operand semantics, e.g. s1RW2R, the upper half is a fXXX hack if needed
610   // before hating me for this: it takes a LOT less time to add ONE field to ~2000 table lines!
611   unsigned int opsema;  
612 };
613
614 using std::vector;
615 struct flagInfo
616 {
617   flagInfo(const vector<Dyninst::InstructionAPI::IA32Regs>& rf, const vector<Dyninst::InstructionAPI::IA32Regs>& wf) : readFlags(rf), writtenFlags(wf) 
618   {
619   }
620   flagInfo() 
621   {
622   }
623   
624   vector<Dyninst::InstructionAPI::IA32Regs> readFlags;
625   vector<Dyninst::InstructionAPI::IA32Regs> writtenFlags;
626 };
627
628 class ia32_instruction
629 {
630   friend unsigned int ia32_decode_operands (const ia32_prefixes& pref, 
631                                             const ia32_entry& gotit, 
632                                             const char* addr, 
633                                             ia32_instruction& instruct);
634   friend INSTRUCTION_EXPORT ia32_instruction& ia32_decode(unsigned int capa, const unsigned char* addr,
635                                        ia32_instruction& instruct);
636   friend unsigned int ia32_decode_operands (const ia32_prefixes& pref, const ia32_entry& gotit, 
637                                             const unsigned char* addr, ia32_instruction& instruct,
638                                             ia32_memacc *mac = NULL);
639   friend ia32_instruction& ia32_decode_FP(const ia32_prefixes& pref, const unsigned char* addr,
640                                           ia32_instruction& instruct);
641   friend unsigned int ia32_emulate_old_type(ia32_instruction& instruct);
642   friend ia32_instruction& ia32_decode_FP(unsigned int opcode, 
643                                           const ia32_prefixes& pref,
644                                           const unsigned char* addr, 
645                                           ia32_instruction& instruct,
646                                           ia32_entry * entry,
647                                           ia32_memacc *mac = NULL);
648
649   unsigned int   size;
650   ia32_prefixes  prf;
651   ia32_memacc    *mac;
652   ia32_condition *cond;
653   ia32_entry     *entry;
654   ia32_locations *loc;
655   unsigned int   legacy_type;
656   bool           rip_relative_data;
657
658
659  public:
660   ia32_instruction(ia32_memacc* _mac = NULL, ia32_condition* _cnd = NULL,
661                    ia32_locations *loc_ = NULL)
662     : mac(_mac), cond(_cnd), entry(NULL), loc(loc_), rip_relative_data(false) {}
663
664   ia32_entry * getEntry() { return entry; }
665   unsigned int getSize() const { return size; }
666   unsigned int getPrefixCount() const { return prf.getCount(); }
667   ia32_prefixes * getPrefix() { return &prf; }
668   unsigned int getLegacyType() const { return legacy_type; }
669   bool hasRipRelativeData() const { return rip_relative_data; }
670   const ia32_memacc& getMac(int which) const { return mac[which]; }
671   const ia32_condition& getCond() const { return *cond; }
672   const ia32_locations& getLocationInfo() const { return *loc; }
673
674   static const dyn_hash_map<entryID, flagInfo>& getFlagTable();
675   static void initFlagTable(dyn_hash_map<entryID, flagInfo>&);
676   
677 };
678
679 // VG(02/07/2002): Information that the decoder can return is
680 //   #defined below. The decoder always returns the size of the 
681 //   instruction because that has to be determined anyway.
682 //   Please don't add things that should be external to the
683 //   decoder, e.g.: how may bytes a relocated instruction needs
684 //   IMHO that stuff should go into inst-x86...
685
686 #define IA32_DECODE_PREFIXES    (1<<0)
687 #define IA32_DECODE_MNEMONICS   (1<<1)
688 #define IA32_DECODE_OPERANDS    (1<<2)
689 #define IA32_DECODE_JMPS        (1<<3)
690 #define IA32_DECODE_MEMACCESS   (1<<4)
691 #define IA32_DECODE_CONDITION   (1<<5)
692
693 #define IA32_FULL_DECODER (IA32_DECODE_PREFIXES | IA32_DECODE_MNEMONICS | IA32_DECODE_OPERANDS | IA32_DECODE_JMPS | IA32_DECODE_MEMACCESS | IA32_DECODE_CONDITION)
694 #define IA32_SIZE_DECODER 0
695
696 INSTRUCTION_EXPORT ia32_instruction& ia32_decode(unsigned int capabilities, const unsigned char* addr, ia32_instruction&);
697
698
699 enum dynamic_call_address_mode {
700   REGISTER_DIRECT, REGISTER_INDIRECT,
701   REGISTER_INDIRECT_DISPLACED, SIB, DISPLACED,
702   IP_INDIRECT_DISPLACED
703 };
704
705 /*
706    get_instruction: get the instruction that starts at instr.
707    return the size of the instruction and set instType to a type descriptor
708 */
709 INSTRUCTION_EXPORT unsigned get_instruction(const unsigned char *instr, unsigned &instType,
710                          const unsigned char** op_ptr = NULL);
711
712 /* get the target of a jump or call */
713 INSTRUCTION_EXPORT Address get_target(const unsigned char *instr, unsigned type, unsigned size,
714                    Address addr);
715
716 // Size of a jump rel32 instruction
717 #define JUMP_REL32_SZ (6)
718 // Maxium size of an emitted jump
719 #define JUMP_SZ (5)
720 // Size of a call rel32 instruction
721 #define CALL_REL32_SZ (5)
722
723 #if defined(arch_x86_64)
724 // size of instruction seqeunce to get anywhere in address space
725 // without touching any registers
726 #define JUMP_ABS64_SZ (17)
727 // Jump is push/return; call is push/push/return, so subtract a return
728 #define CALL_ABS64_SZ (JUMP_ABS64_SZ+JUMP_ABS64_SZ-1)
729 #endif
730
731 #define PUSH_RM_OPC1 (0xFF)
732 #define PUSH_RM_OPC2 (6)
733 #define CALL_RM_OPC1 (0xFF)
734 #define CALL_RM_OPC2 (2)
735 #define PUSH_EBP (0x50+REGNUM_EBP)
736 #define SUB_REG_IMM32 (5)
737 #define LEAVE (0xC9)
738
739 #define EXTENDED_0x81_ADD 0
740 #define EXTENDED_0x81_OR 1
741 #define EXTENDED_0x81_ADDC 2
742 #define EXTENDED_0x81_SHIFT 3
743 #define EXTENDED_0x81_AND 4
744 #define EXTENDED_0x81_SUB 5
745 #define EXTENDED_0x81_XOR 6
746 #define EXTENDED_0x81_CMP 7
747
748 INSTRUCTION_EXPORT int displacement(const unsigned char *instr, unsigned type);
749
750 inline bool is_disp8(long disp) {
751    return (disp >= -128 && disp < 127);
752 }
753
754 inline bool is_disp16(long disp) {
755    return (disp >= -32768 && disp < 32767);
756 }
757
758
759 INSTRUCTION_EXPORT int get_instruction_operand(const unsigned char *i_ptr, Register& base_reg,
760                             Register& index_reg, int& displacement, 
761                             unsigned& scale, unsigned &mod);
762 INSTRUCTION_EXPORT void decode_SIB(unsigned sib, unsigned& scale, Register& index_reg, Register& base_reg);
763 INSTRUCTION_EXPORT const unsigned char* skip_headers(const unsigned char*, ia32_prefixes* = NULL);
764
765 /* addresses on x86 don't have to be aligned */
766 /* Address bounds of new dynamic heap segments.  On x86 we don't try
767 to allocate new segments near base tramps, so heap segments can be
768 allocated anywhere (the tramp address "x" is ignored). */
769 inline Address region_lo(const Address /*x*/) { return 0x00000000; }
770 inline Address region_hi(const Address /*x*/) { return 0xf0000000; }
771
772 #if defined(arch_x86_64)
773 // range functions for AMD64
774
775 inline Address region_lo_64(const Address x) { return x & 0xffffffff80000000; }
776 inline Address region_hi_64(const Address x) { return x | 0x000000007fffffff; }
777
778 #endif
779
780 INSTRUCTION_EXPORT bool insn_hasSIB(unsigned,unsigned&,unsigned&,unsigned&);
781 INSTRUCTION_EXPORT bool insn_hasDisp8(unsigned ModRM);
782 INSTRUCTION_EXPORT bool insn_hasDisp32(unsigned ModRM);
783
784
785 #endif