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