Mercurial > lcfOS
comparison python/target/x86_2.py @ 290:7b38782ed496
File moves
author | Windel Bouwman |
---|---|
date | Sun, 24 Nov 2013 11:24:15 +0100 |
parents | python/x86_2.py@1c7c1e619be8 |
children |
comparison
equal
deleted
inserted
replaced
289:bd2593de3ff8 | 290:7b38782ed496 |
---|---|
1 """ | |
2 X86 target descriptions and encodings. | |
3 | |
4 """ | |
5 | |
6 from target import Register, Instruction, Target, Imm8, Label, Imm3, LabelRef | |
7 | |
8 | |
9 modrm = {'rax': 0, 'rbx': 1} | |
10 | |
11 # Table 3.1 of the intel manual: | |
12 # use REX.W on the table below: | |
13 regs64 = {'rax': 0,'rcx':1,'rdx':2,'rbx':3,'rsp':4,'rbp':5,'rsi':6,'rdi':7,'r8':0,'r9':1,'r10':2,'r11':3,'r12':4,'r13':5,'r14':6,'r15':7} | |
14 regs32 = {'eax': 0, 'ecx':1, 'edx':2, 'ebx': 3, 'esp': 4, 'ebp': 5, 'esi':6, 'edi':7} | |
15 regs8 = {'al':0,'cl':1,'dl':2,'bl':3,'ah':4,'ch':5,'dh':6,'bh':7} | |
16 | |
17 # Calculation of the rexb bit: | |
18 rexbit = {'rax': 0, 'rcx':0, 'rdx':0, 'rbx': 0, 'rsp': 0, 'rbp': 0, 'rsi':0, 'rdi':0,'r8':1,'r9':1,'r10':1,'r11':1,'r12':1,'r13':1,'r14':1,'r15':1} | |
19 | |
20 # Helper functions: | |
21 def imm64(x): | |
22 """ represent 64 bits integer in little endian 8 bytes""" | |
23 if x < 0: | |
24 x = x + (1 << 64) | |
25 x = x & 0xFFFFFFFFFFFFFFFF | |
26 return [ (x >> (p*8)) & 0xFF for p in range(8) ] | |
27 | |
28 def imm32(x): | |
29 """ represent 32 bits integer in little endian 4 bytes""" | |
30 if x < 0: | |
31 x = x + (1 << 32) | |
32 x = x & 0xFFFFFFFF | |
33 return [ (x >> (p*8)) & 0xFF for p in range(4) ] | |
34 | |
35 def imm8(x): | |
36 if x < 0: | |
37 x = x + (1 << 8) | |
38 x = x & 0xFF | |
39 return [ x ] | |
40 | |
41 def modrm(mod=0, rm=0, reg=0): | |
42 """ Construct the modrm byte from its components """ | |
43 assert(mod <= 3) | |
44 assert(rm <= 7) | |
45 assert(reg <= 7) | |
46 return (mod << 6) | (reg << 3) | rm | |
47 | |
48 def rex(w=0, r=0, x=0, b=0): | |
49 """ Create a REX prefix byte """ | |
50 assert(w <= 1) | |
51 assert(r <= 1) | |
52 assert(x <= 1) | |
53 assert(b <= 1) | |
54 return 0x40 | (w<<3) | (r<<2) | (x<<1) | b | |
55 | |
56 def sib(ss=0, index=0, base=0): | |
57 assert(ss <= 3) | |
58 assert(index <= 7) | |
59 assert(base <= 7) | |
60 return (ss << 6) | (index << 3) | base | |
61 | |
62 tttn = {'L':0xc,'G':0xf,'NE':0x5,'GE':0xd,'LE':0xe, 'E':0x4} | |
63 | |
64 # Actual instructions: | |
65 def nearjump(distance, condition=None): | |
66 """ jmp imm32 """ | |
67 lim = (1<<30) | |
68 if abs(distance) > lim: | |
69 Error('near jump cannot jump over more than {0} bytes'.format(lim)) | |
70 if condition: | |
71 if distance < 0: | |
72 distance -= 6 # Skip own instruction | |
73 opcode = 0x80 | tttn[condition] # Jcc imm32 | |
74 return [0x0F, opcode] + imm32(distance) | |
75 else: | |
76 if distance < 0: | |
77 distance -= 5 # Skip own instruction | |
78 return [ 0xE9 ] + imm32(distance) | |
79 | |
80 def shortjump(distance, condition=None): | |
81 """ jmp imm8 """ | |
82 lim = 118 | |
83 if abs(distance) > lim: | |
84 Error('short jump cannot jump over more than {0} bytes'.format(lim)) | |
85 if distance < 0: | |
86 distance -= 2 # Skip own instruction | |
87 if condition: | |
88 opcode = 0x70 | tttn[condition] # Jcc rel8 | |
89 else: | |
90 opcode = 0xeb # jmp rel8 | |
91 return [opcode] + imm8(distance) | |
92 | |
93 # Helper that determines jump type: | |
94 def reljump(distance): | |
95 if abs(distance) < 110: | |
96 return shortjump(distance) | |
97 else: | |
98 return nearjump(distance) | |
99 | |
100 def push(reg): | |
101 if reg in regs64: | |
102 if rexbit[reg] == 1: | |
103 return [0x41, 0x50 + regs64[reg]] | |
104 else: | |
105 return [0x50 + regs64[reg]] | |
106 else: | |
107 Error('push for {0} not implemented'.format(reg)) | |
108 | |
109 def pop(reg): | |
110 if reg in regs64: | |
111 if rexbit[reg] == 1: | |
112 rexprefix = rex(b=1) | |
113 opcode = 0x58 + regs64[reg] | |
114 return [rexprefix, opcode] | |
115 else: | |
116 opcode = 0x58 + regs64[reg] | |
117 return [ opcode ] | |
118 else: | |
119 Error('pop for {0} not implemented'.format(reg)) | |
120 | |
121 def INT(number): | |
122 opcode = 0xcd | |
123 return [opcode] + imm8(number) | |
124 | |
125 def syscall(): | |
126 return [0x0F, 0x05] | |
127 | |
128 def call(distance): | |
129 if type(distance) is int: | |
130 return [0xe8]+imm32(distance) | |
131 elif type(distance) is str and distance in regs64: | |
132 reg = distance | |
133 opcode = 0xFF # 0xFF /2 == call r/m64 | |
134 mod_rm = modrm(mod=3, reg=2, rm=regs64[reg]) | |
135 if rexbit[reg] == 1: | |
136 rexprefix = rex(b=rexbit[reg]) | |
137 return [rexprefix, opcode, mod_rm] | |
138 else: | |
139 return [opcode, mod_rm] | |
140 else: | |
141 Error('Cannot call to {0}'.format(distance)) | |
142 | |
143 def ret(): | |
144 return [ 0xc3 ] | |
145 | |
146 def increg64(reg): | |
147 assert(reg in regs64) | |
148 rexprefix = rex(w=1, b=rexbit[reg]) | |
149 opcode = 0xff | |
150 mod_rm = modrm(mod=3, rm=regs64[reg]) | |
151 return [rexprefix, opcode, mod_rm] | |
152 | |
153 def prepost8(r8, rm8): | |
154 assert(r8 in regs8) | |
155 pre = [] | |
156 if type(rm8) is list: | |
157 # TODO: merge mem access with prepost for 64 bits | |
158 if len(rm8) == 1: | |
159 base, = rm8 | |
160 if type(base) is str and base in regs64: | |
161 assert(not base in ['rbp', 'rsp', 'r12', 'r13']) | |
162 mod_rm = modrm(mod=0, rm=regs64[base], reg=regs8[r8]) | |
163 if rexbit[base] == 1: | |
164 pre.append(rex(b=1)) | |
165 post = [mod_rm] | |
166 else: | |
167 Error('One arg of type {0} not implemented'.format(base)) | |
168 elif len(rm8) == 2: | |
169 base, offset = rm8 | |
170 assert(type(offset) is int) | |
171 assert(base in regs64) | |
172 | |
173 if base == 'rsp' or base == 'r12': | |
174 Error('Cannot use rsp or r12 as base yet') | |
175 if rexbit[base] == 1: | |
176 pre.append( rex(b=1) ) | |
177 mod_rm = modrm(mod=1, rm=regs64[base], reg=regs8[r8]) | |
178 post = [mod_rm] + imm8(offset) | |
179 else: | |
180 Error('not supporting prepost8 with list len {0}'.format(len(rm8))) | |
181 else: | |
182 Error('Not supporting move with reg8 {0}'.format(r8)) | |
183 return pre, post | |
184 | |
185 def prepost(r64, rm64): | |
186 assert(r64 in regs64) | |
187 if type(rm64) is list: | |
188 if len(rm64) == 3: | |
189 base, index, disp = rm64 | |
190 assert(base in regs64) | |
191 assert(index in regs64) | |
192 assert(type(disp) is int) | |
193 # Assert that no special cases are used: | |
194 # TODO: swap base and index to avoid special cases | |
195 # TODO: exploit special cases and make better code | |
196 assert(index != 'rsp') | |
197 | |
198 rexprefix = rex(w=1, r=rexbit[r64], x=rexbit[index], b=rexbit[base]) | |
199 # mod=1 and rm=4 indicates a SIB byte: [--][--]+imm8 | |
200 mod_rm = modrm(mod=1, rm=4, reg=regs64[r64]) | |
201 si_b = sib(ss=0, index=regs64[index], base=regs64[base]) | |
202 return [rexprefix], [mod_rm, si_b] + imm8(disp) | |
203 elif len(rm64) == 2: | |
204 base, offset = rm64 | |
205 assert(type(offset) is int) | |
206 if base == 'RIP': | |
207 # RIP pointer relative addressing mode! | |
208 rexprefix = rex(w=1, r=rexbit[r64]) | |
209 mod_rm = modrm(mod=0, rm=5, reg=regs64[r64]) | |
210 return [rexprefix], [mod_rm] + imm32(offset) | |
211 else: | |
212 assert(base in regs64) | |
213 | |
214 if base == 'rsp' or base == 'r12': | |
215 # extended function that uses SIB byte | |
216 rexprefix = rex(w=1, r=rexbit[r64], b=rexbit[base]) | |
217 # rm=4 indicates a SIB byte follows | |
218 mod_rm = modrm(mod=1, rm=4, reg=regs64[r64]) | |
219 # index=4 indicates that index is not used | |
220 si_b = sib(ss=0, index=4, base=regs64[base]) | |
221 return [rexprefix], [mod_rm, si_b] + imm8(offset) | |
222 else: | |
223 rexprefix = rex(w=1, r=rexbit[r64], b=rexbit[base]) | |
224 mod_rm = modrm(mod=1, rm=regs64[base], reg=regs64[r64]) | |
225 return [rexprefix], [mod_rm] + imm8(offset) | |
226 elif len(rm64) == 1: | |
227 offset = rm64[0] | |
228 if type(offset) is int: | |
229 rexprefix = rex(w=1, r=rexbit[r64]) | |
230 mod_rm = modrm(mod=0, rm=4,reg=regs64[r64]) | |
231 si_b = sib(ss=0, index=4,base=5) # 0x25 | |
232 return [rexprefix], [mod_rm, si_b] + imm32(offset) | |
233 else: | |
234 Error('Memory reference of type {0} not implemented'.format(offset)) | |
235 else: | |
236 Error('Memory reference not implemented') | |
237 elif rm64 in regs64: | |
238 rexprefix = rex(w=1, r=rexbit[r64], b=rexbit[rm64]) | |
239 mod_rm = modrm(3, rm=regs64[rm64], reg=regs64[r64]) | |
240 return [rexprefix], [mod_rm] | |
241 | |
242 def leareg64(rega, m): | |
243 opcode = 0x8d # lea r64, m | |
244 pre, post = prepost(rega, m) | |
245 return pre + [opcode] + post | |
246 | |
247 def mov(rega, regb): | |
248 if type(regb) is int: | |
249 pre = [rex(w=1, b=rexbit[rega])] | |
250 opcode = 0xb8 + regs64[rega] | |
251 post = imm64(regb) | |
252 elif type(regb) is str: | |
253 if regb in regs64: | |
254 opcode = 0x89 # mov r/m64, r64 | |
255 pre, post = prepost(regb, rega) | |
256 elif regb in regs8: | |
257 opcode = 0x88 # mov r/m8, r8 | |
258 pre, post = prepost8(regb, rega) | |
259 else: | |
260 Error('Unknown register {0}'.format(regb)) | |
261 elif type(rega) is str: | |
262 if rega in regs64: | |
263 opcode = 0x8b # mov r64, r/m64 | |
264 pre, post = prepost(rega, regb) | |
265 else: | |
266 Error('Unknown register {0}'.format(rega)) | |
267 else: | |
268 Error('Move of this kind {0}, {1} not implemented'.format(rega, regb)) | |
269 return pre + [opcode] + post | |
270 | |
271 def xorreg64(rega, regb): | |
272 rexprefix = rex(w=1, r=rexbit[regb], b=rexbit[rega]) | |
273 opcode = 0x31 # XOR r/m64, r64 | |
274 # Alternative is 0x33 XOR r64, r/m64 | |
275 mod_rm = modrm(3, rm=regs64[rega], reg=regs64[regb]) | |
276 return [rexprefix, opcode, mod_rm] | |
277 | |
278 # integer arithmatic: | |
279 def addreg64(rega, regb): | |
280 if regb in regs64: | |
281 pre, post = prepost(regb, rega) | |
282 opcode = 0x01 # ADD r/m64, r64 | |
283 return pre + [opcode] + post | |
284 elif type(regb) is int: | |
285 if regb < 100: | |
286 rexprefix = rex(w=1, b=rexbit[rega]) | |
287 opcode = 0x83 # add r/m, imm8 | |
288 mod_rm = modrm(3, rm=regs64[rega], reg=0) | |
289 return [rexprefix, opcode, mod_rm]+imm8(regb) | |
290 elif regb < (1<<31): | |
291 rexprefix = rex(w=1, b=rexbit[rega]) | |
292 opcode = 0x81 # add r/m64, imm32 | |
293 mod_rm = modrm(3, rm=regs64[rega], reg=0) | |
294 return [rexprefix, opcode, mod_rm]+imm32(regb) | |
295 else: | |
296 Error('Constant value too large!') | |
297 else: | |
298 Error('unknown second operand!'.format(regb)) | |
299 | |
300 def subreg64(rega, regb): | |
301 if regb in regs64: | |
302 pre, post = prepost(regb, rega) | |
303 opcode = 0x29 # SUB r/m64, r64 | |
304 return pre + [opcode] + post | |
305 elif type(regb) is int: | |
306 if regb < 100: | |
307 rexprefix = rex(w=1, b=rexbit[rega]) | |
308 opcode = 0x83 # sub r/m, imm8 | |
309 mod_rm = modrm(3, rm=regs64[rega], reg=5) | |
310 return [rexprefix, opcode, mod_rm]+imm8(regb) | |
311 elif regb < (1<<31): | |
312 rexprefix = rex(w=1, b=rexbit[rega]) | |
313 opcode = 0x81 # sub r/m64, imm32 | |
314 mod_rm = modrm(3, rm=regs64[rega], reg=5) | |
315 return [rexprefix, opcode, mod_rm]+imm32(regb) | |
316 else: | |
317 Error('Constant value too large!') | |
318 | |
319 else: | |
320 Error('unknown second operand!'.format(regb)) | |
321 | |
322 def idivreg64(reg): | |
323 rexprefix = rex(w=1, b=rexbit[reg]) | |
324 opcode = 0xf7 # IDIV r/m64 | |
325 mod_rm = modrm(3, rm=regs64[reg], reg=7) | |
326 return [rexprefix, opcode, mod_rm] | |
327 | |
328 def imulreg64_rax(reg): | |
329 rexprefix = rex(w=1, b=rexbit[reg]) | |
330 opcode = 0xf7 # IMUL r/m64 | |
331 mod_rm = modrm(3, rm=regs64[reg], reg=5) | |
332 return [rexprefix, opcode, mod_rm] | |
333 | |
334 def imulreg64(rega, regb): | |
335 pre, post = prepost(rega, regb) | |
336 opcode = 0x0f # IMUL r64, r/m64 | |
337 opcode2 = 0xaf | |
338 return pre + [opcode, opcode2] + post | |
339 | |
340 def cmpreg64(rega, regb): | |
341 if regb in regs64: | |
342 pre, post = prepost(regb, rega) | |
343 opcode = 0x39 # CMP r/m64, r64 | |
344 return pre + [opcode] + post | |
345 elif type(regb) is int: | |
346 rexprefix = rex(w=1, b=rexbit[rega]) | |
347 opcode = 0x83 # CMP r/m64, imm8 | |
348 mod_rm = modrm(3, rm=regs64[rega], reg=7) | |
349 return [rexprefix, opcode, mod_rm] + imm8(regb) | |
350 | |
351 else: | |
352 Error('not implemented cmp64') | |
353 | |
354 # Mapping that maps string names to the right functions: | |
355 opcodes = {'mov':(mov,2), 'lea':(leareg64,2), 'int':(INT,1), 'syscall':(syscall,0)} | |
356 |