For Linux/X86 platform
[dyninst.git] / dyninstAPI / src / arch-x86.h
1 /*
2  * Copyright (c) 1996 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 /*
43  * arch-x86.h - x86 instruction declarations
44  *
45  * $Log: arch-x86.h,v $
46  * Revision 1.4  1997/12/01 02:27:52  tung
47  * For Linux/X86 platform
48  *
49  * Revision 1.3  1997/02/26 23:42:46  mjrg
50  * First part on WindowsNT port: changes for compiling with Visual C++;
51  * moved unix specific code to unix.C
52  *
53  * Revision 1.2  1996/11/12 17:48:27  mjrg
54  * Moved the computation of cost to the basetramp in the x86 platform,
55  * and changed other platform to keep code consistent.
56  * Removed warnings, and made changes for compiling with Visual C++
57  *
58  * Revision 1.1  1996/10/18 23:54:12  mjrg
59  * Solaris/X86 port
60  *
61  *
62  *
63  */
64
65 #if !(defined(i386_unknown_solaris2_5) || defined(i386_unknown_nt4_0) || defined(i386_unknown_linux2_0))
66 #error "invalid architecture-os inclusion"
67 #endif
68
69 #ifndef _ARCH_X86_H
70 #define _ARCH_X86_H
71
72
73 /* operand types */
74 typedef char byte_t;   /* a byte operand */
75 typedef short word_t;  /* a word (16-bit) operand */
76 typedef int dword_t;   /* a double word (32-bit) operand */
77
78 /* operand sizes */
79 #define byteSzB (1)    /* size of a byte operand */
80 #define wordSzB (2)    /* size of a word operand */
81 #define dwordSzB (4)   /* size of a dword operand */
82
83 /* The following values are or'ed together to form an instruction type descriptor */
84 /* the instruction types of interest */
85 #define IS_CALL (1<<1)   /* call instruction */
86 #define IS_RET  (1<<2)   /* near return instruction */
87 #define IS_RETF (1<<3)   /* far return instruction */
88 #define IS_JUMP (1<<4)   /* jump instruction */
89 #define IS_JCC  (1<<5)   /* conditional jump instruction */
90 #define ILLEGAL (1<<6)   /* illegal instruction */
91
92 /* addressing modes for calls and jumps */
93 #define REL_B   (1<<10)  /* relative address, byte offset */
94 #define REL_W   (1<<11)  /* relative address, word offset */
95 #define REL_D   (1<<12)  /* relative address, dword offset */
96 #define REL_X   (1<<13)  /* relative address, word or dword offset */
97 #define INDIR   (1<<14)  /* indirect (register or memory) address */
98 #define PTR_WW  (1<<15)  /* 4-byte pointer */
99 #define PTR_WD  (1<<16)  /* 6-byte pointer */
100 #define PTR_WX  (1<<17)  /* 4 or 6-byte pointer */
101
102 /* prefixes */
103 #define PREFIX_INST (1<<20) /* instruction prefix */
104 #define PREFIX_SEG  (1<<21) /* segment override prefix */
105 #define PREFIX_OPR  (1<<22) /* operand size override */
106 #define PREFIX_ADDR (1<<23) /* address size override */
107 /* end of instruction type descriptor values */
108
109
110 /* opcodes of some instructions */
111 #define PUSHAD   (0x60)
112 #define PUSHFD   (0x9C)
113 #define POPAD    (0x61)
114 #define POPFD    (0x9D)
115 #define PUSH_DS  (0x1E)
116 #define POP_DS   (0X1F)
117 #define NOP      (0x90)
118
119 #define JCXZ     (0xE3)
120
121 #define JE_R8    (0x74)
122 #define JNE_R8   (0x75)
123 #define JL_R8    (0x7C)
124 #define JLE_R8   (0x7E)
125 #define JG_R8    (0x7F)
126 #define JGE_R8   (0x7D)
127
128 /* limits */
129 #define MIN_IMM8 (-128)
130 #define MAX_IMM8 (127)
131 #define MIN_IMM16 (-32768)
132 #define MAX_IMM16 (32767)
133
134
135 /*
136    get_instruction: get the instruction that starts at instr.
137    return the size of the instruction and set instType to a type descriptor
138 */
139 unsigned get_instruction(const unsigned char *instr, unsigned &instType);
140
141 /* get the target of a jump or call */
142 unsigned get_target(const unsigned char *instr, unsigned type, unsigned size, unsigned addr);
143
144
145 class instruction {
146  public:
147   instruction(): type_(0), size_(0), ptr_(0) {}
148
149   instruction(const unsigned char *p, unsigned type, unsigned sz):
150     type_(type), size_(sz), ptr_(p) {}
151
152   instruction(const instruction &insn) {
153     type_ = insn.type_;
154     size_ = insn.size_;
155     ptr_ = insn.ptr_;
156   }
157
158   unsigned getNextInstruction(const unsigned char *p) {
159     ptr_ = p;
160     size_ = get_instruction(ptr_, type_);
161     return size_;
162   }
163
164   // if the instruction is a jump or call, return the target, else return zero
165   Address getTarget(Address addr) const { 
166     return (Address)get_target(ptr_, type_, size_, addr); 
167   }
168
169   // return the size of the instruction in bytes
170   unsigned size() const { return size_; }
171
172   // return the type of the instruction
173   unsigned type() const { return type_; }
174
175   // return a pointer to the instruction
176   const unsigned char *ptr() const { return ptr_; }
177
178   bool isCall() const { return type_ & IS_CALL; }
179   bool isCallIndir() const { return (type_ & IS_CALL) && (type_ & INDIR); }
180   bool isReturn() const { return (type_ & IS_RET) || (type_ & IS_RETF); }
181   bool isRetFar() const { return type_ & IS_RETF; }
182   bool isJumpIndir() const { return (type_ & IS_JUMP) && (type_ & INDIR); }
183   bool isJumpDir() const
184     { return ~(type_ & INDIR) && ((type_ & IS_JUMP) || (type_ & IS_JCC)); }
185   bool isNop() const { return *ptr_ == 0x90; }
186   bool isIndir() const { return type_ & INDIR; }
187   bool isIllegal() const { return type_ & ILLEGAL; }
188
189  private:
190   unsigned type_;   // type of the instruction (e.g. IS_CALL | INDIR)
191   unsigned size_;   // size in bytes
192   const unsigned char *ptr_;       // pointer to the instruction
193 };
194
195
196
197 /* addresses on x86 don't have to be aligned */
198 inline bool isAligned(const Address ) { return true; }
199
200
201 #endif