|
191
|
1 #!/usr/bin/python
|
|
|
2
|
|
|
3 import unittest
|
|
398
|
4 from ppci.target.target_list import x86target
|
|
292
|
5 from testasm import AsmTestCaseBase
|
|
398
|
6 from ppci.outstream import BinaryOutputStream
|
|
|
7 from ppci.objectfile import ObjectFile
|
|
191
|
8
|
|
|
9
|
|
292
|
10 class AssemblerTestCase(AsmTestCaseBase):
|
|
398
|
11 """
|
|
|
12 test methods start with 'test*'
|
|
191
|
13 Checks several assembly constructs agains their bytecodes
|
|
292
|
14 """
|
|
|
15 def setUp(self):
|
|
398
|
16 self.target = x86target
|
|
|
17 self.obj = ObjectFile()
|
|
|
18 self.ostream = BinaryOutputStream(self.obj)
|
|
|
19 self.ostream.select_section('code')
|
|
|
20 self.assembler = self.target.assembler
|
|
|
21 self.assembler.prepare()
|
|
191
|
22
|
|
292
|
23 def testX86(self):
|
|
398
|
24 self.feed('mov rax, rbx')
|
|
|
25 self.feed('xor rcx, rbx')
|
|
|
26 self.feed('inc rcx')
|
|
292
|
27 self.check('48 89 d8 48 31 d9 48 ff c1')
|
|
191
|
28
|
|
398
|
29 @unittest.skip('not implemented')
|
|
|
30 def testJumpingAround(self):
|
|
|
31 """ Check all kind of assembler cases """
|
|
|
32 assert(assembler.shortjump(5) == [0xeb, 0x5])
|
|
|
33 assert(assembler.shortjump(-2) == [0xeb, 0xfc])
|
|
|
34 assert(assembler.shortjump(10,'GE') == [0x7d, 0xa])
|
|
|
35 assert(assembler.nearjump(5) == [0xe9, 0x5,0x0,0x0,0x0])
|
|
|
36 assert(assembler.nearjump(-2) == [0xe9, 0xf9, 0xff,0xff,0xff])
|
|
|
37 assert(assembler.nearjump(10,'LE') == [0x0f, 0x8e, 0xa,0x0,0x0,0x0])
|
|
|
38
|
|
|
39 @unittest.skip('not implemented')
|
|
292
|
40 def testCall(self):
|
|
|
41 self.feed('call r10')
|
|
|
42 self.check('')
|
|
|
43 self.feed('call rcx')
|
|
|
44 # assert(assembler.call('r10') == [0x41, 0xff, 0xd2])
|
|
|
45 # assert(assembler.call('rcx') == [0xff, 0xd1])
|
|
287
|
46
|
|
292
|
47 def testXOR(self):
|
|
395
|
48 self.feed('xor rax, rax')
|
|
|
49 self.feed('xor r9, r8')
|
|
|
50 self.feed('xor rbx, r11')
|
|
|
51 self.check('48 31 c0 4d 31 c1 4c 31 db')
|
|
191
|
52
|
|
292
|
53 def testINC(self):
|
|
395
|
54 self.feed('inc r11')
|
|
|
55 self.feed('inc rcx')
|
|
|
56 self.check('49 ff c3 48 ff c1')
|
|
191
|
57
|
|
292
|
58 def testPush(self):
|
|
395
|
59 self.feed('push rbp')
|
|
|
60 self.feed('push rbx')
|
|
|
61 self.feed('push r12')
|
|
|
62 self.check('55 53 41 54')
|
|
191
|
63
|
|
292
|
64 def testPop(self):
|
|
|
65 self.feed('pop rbx')
|
|
|
66 self.feed('pop rbp')
|
|
|
67 self.feed('pop r12')
|
|
395
|
68 self.check('5b 5d 41 5c')
|
|
292
|
69
|
|
398
|
70 @unittest.skip('not implemented')
|
|
292
|
71 def testAsmLoads(self):
|
|
398
|
72 self.feed('mov rbx, r14')
|
|
|
73 self.feed('mov r12, r8')
|
|
|
74 self.feed('mov rdi, rsp')
|
|
|
75 self.check('4c 89 f3 4d 89 c4 48 89 e7')
|
|
191
|
76
|
|
398
|
77 @unittest.skip('not implemented')
|
|
292
|
78 def testAsmMemLoads(self):
|
|
191
|
79 assert(assembler.mov('rax', ['r8','r15',0x11]) == [0x4b,0x8b,0x44,0x38,0x11])
|
|
|
80 assert(assembler.mov('r13', ['rbp','rcx',0x23]) == [0x4c,0x8b,0x6c,0xd,0x23])
|
|
|
81
|
|
|
82 assert(assembler.mov('r9', ['rbp',-0x33]) == [0x4c,0x8b,0x4d,0xcd])
|
|
|
83 #assert(assembler.movreg64('rbx', ['rax']) == [0x48, 0x8b,0x18])
|
|
|
84
|
|
|
85 assert(assembler.mov('rax', [0xb000]) == [0x48,0x8b,0x4,0x25,0x0,0xb0,0x0,0x0])
|
|
|
86 assert(assembler.mov('r11', [0xa0]) == [0x4c,0x8b,0x1c,0x25,0xa0,0x0,0x0,0x0])
|
|
|
87
|
|
|
88 assert(assembler.mov('r11', ['RIP', 0xf]) == [0x4c,0x8b,0x1d,0x0f,0x0,0x0,0x0])
|
|
|
89
|
|
398
|
90 @unittest.skip
|
|
292
|
91 def testAsmMemStores(self):
|
|
191
|
92 assert(assembler.mov(['rbp', 0x13],'rbx') == [0x48,0x89,0x5d,0x13])
|
|
|
93 assert(assembler.mov(['r12', 0x12],'r9') == [0x4d,0x89,0x4c,0x24,0x12])
|
|
|
94 assert(assembler.mov(['rcx', 0x11],'r14') == [0x4c,0x89,0x71,0x11])
|
|
|
95
|
|
|
96
|
|
|
97 assert(assembler.mov([0xab], 'rbx') == [0x48,0x89,0x1c,0x25,0xab,0x0,0x0,0x0])
|
|
|
98 assert(assembler.mov([0xcd], 'r13') == [0x4c,0x89,0x2c,0x25,0xcd,0x0,0x0,0x0])
|
|
|
99
|
|
|
100 assert(assembler.mov(['RIP', 0xf], 'r9') == [0x4c,0x89,0x0d,0x0f,0x0,0x0,0x0])
|
|
|
101
|
|
398
|
102 @unittest.skip
|
|
292
|
103 def testAsmMOV8(self):
|
|
191
|
104 assert(assembler.mov(['rbp', -8], 'al') == [0x88, 0x45, 0xf8])
|
|
|
105 assert(assembler.mov(['r11', 9], 'cl') == [0x41, 0x88, 0x4b, 0x09])
|
|
|
106
|
|
|
107 assert(assembler.mov(['rbx'], 'al') == [0x88, 0x03])
|
|
|
108 assert(assembler.mov(['r11'], 'dl') == [0x41, 0x88, 0x13])
|
|
|
109
|
|
398
|
110 @unittest.skip
|
|
292
|
111 def testAsmLea(self):
|
|
191
|
112 assert(assembler.leareg64('r11', ['RIP', 0xf]) == [0x4c,0x8d,0x1d,0x0f,0x0,0x0,0x0])
|
|
|
113 assert(assembler.leareg64('rsi', ['RIP', 0x7]) == [0x48,0x8d,0x35,0x07,0x0,0x0,0x0])
|
|
|
114
|
|
|
115 assert(assembler.leareg64('rcx', ['rbp', -8]) == [0x48,0x8d,0x4d,0xf8])
|
|
|
116
|
|
398
|
117 @unittest.skip
|
|
292
|
118 def testAssemblerCMP(self):
|
|
191
|
119 assert(assembler.cmpreg64('rdi', 'r13') == [0x4c, 0x39, 0xef])
|
|
|
120 assert(assembler.cmpreg64('rbx', 'r14') == [0x4c, 0x39, 0xf3])
|
|
|
121 assert(assembler.cmpreg64('r12', 'r9') == [0x4d, 0x39, 0xcc])
|
|
|
122
|
|
|
123 assert(assembler.cmpreg64('rdi', 1) == [0x48, 0x83, 0xff, 0x01])
|
|
|
124 assert(assembler.cmpreg64('r11', 2) == [0x49, 0x83, 0xfb, 0x02])
|
|
292
|
125
|
|
398
|
126 @unittest.skip
|
|
292
|
127 def testAssemblerADD(self):
|
|
191
|
128 assert(assembler.addreg64('rbx', 'r13') == [0x4c, 0x01, 0xeb])
|
|
|
129 assert(assembler.addreg64('rax', 'rbx') == [0x48, 0x01, 0xd8])
|
|
|
130 assert(assembler.addreg64('r12', 'r13') == [0x4d, 0x01, 0xec])
|
|
|
131
|
|
|
132 assert(assembler.addreg64('rbx', 0x13) == [0x48, 0x83, 0xc3, 0x13])
|
|
|
133 assert(assembler.addreg64('r11', 0x1234567) == [0x49, 0x81, 0xc3, 0x67, 0x45,0x23,0x1])
|
|
|
134 assert(assembler.addreg64('rsp', 0x33) == [0x48, 0x83, 0xc4, 0x33])
|
|
|
135
|
|
398
|
136 @unittest.skip
|
|
292
|
137 def testAssemblerSUB(self):
|
|
191
|
138 assert(assembler.subreg64('rdx', 'r14') == [0x4c, 0x29, 0xf2])
|
|
|
139 assert(assembler.subreg64('r15', 'rbx') == [0x49, 0x29, 0xdf])
|
|
|
140 assert(assembler.subreg64('r8', 'r9') == [0x4d, 0x29, 0xc8])
|
|
|
141
|
|
|
142 assert(assembler.subreg64('rsp', 0x123456) == [0x48, 0x81, 0xec, 0x56,0x34,0x12,0x0])
|
|
|
143 assert(assembler.subreg64('rsp', 0x12) == [0x48, 0x83, 0xec, 0x12])
|
|
|
144
|
|
398
|
145 @unittest.skip
|
|
292
|
146 def testAssemblerIDIV(self):
|
|
191
|
147 assert(assembler.idivreg64('r11') == [0x49, 0xf7, 0xfb])
|
|
|
148 assert(assembler.idivreg64('rcx') == [0x48, 0xf7, 0xf9])
|
|
|
149 assert(assembler.idivreg64('rsp') == [0x48, 0xf7, 0xfc])
|
|
|
150
|
|
398
|
151 @unittest.skip
|
|
292
|
152 def testAssemblerIMUL(self):
|
|
191
|
153 assert(assembler.imulreg64_rax('rdi') == [0x48, 0xf7, 0xef])
|
|
|
154 assert(assembler.imulreg64_rax('r10') == [0x49, 0xf7, 0xea])
|
|
|
155 assert(assembler.imulreg64_rax('rdx') == [0x48, 0xf7, 0xea])
|
|
|
156
|
|
|
157 assert(assembler.imulreg64('r11', 'rdi') == [0x4c, 0xf, 0xaf, 0xdf])
|
|
|
158 assert(assembler.imulreg64('r12', 'rbx') == [0x4c, 0xf, 0xaf, 0xe3])
|
|
|
159 # nasm generates this machine code: 0x4d, 0x6b, 0xff, 0xee
|
|
|
160 # This also works: 4D0FAFFE (another variant?? )
|
|
|
161 assert(assembler.imulreg64('r15', 'r14') == [0x4d, 0x0f, 0xaf, 0xfe])
|
|
|
162
|
|
|
163
|
|
|
164 if __name__ == '__main__':
|
|
|
165 unittest.main()
|
