|
342
|
1
|
|
364
|
2 from ..basetarget import Target, Label
|
|
345
|
3 from ..arm.registers import R0, R1, R2, R3, R4, R5, R6, R7
|
|
|
4 from ..arm.registers import R8, R9, R10, R11, R12, SP, LR, PC
|
|
342
|
5 from ..arm.registers import register_range
|
|
|
6
|
|
398
|
7 from .instructions import Dcd, Mov, Mov1, Add, Add2, Sub, Orr1, Mul, Mov2
|
|
|
8 from .instructions import Add1, Mul1
|
|
356
|
9 from .instructions import Lsr1, Lsl1, And1, Sub1
|
|
352
|
10 from .instructions import B, Bl, Ble, Bgt, Beq, Blt, Cmp, Cmp2
|
|
354
|
11 from .instructions import Push, Pop, Str, Ldr, Ldr3, Str1, Ldr1, Adr
|
|
362
|
12 from .instructions import Mcr, Mrc
|
|
375
|
13 from .instructions import LdrPseudo
|
|
346
|
14 from .selector import ArmInstructionSelector
|
|
|
15 from .frame import ArmFrame
|
|
381
|
16 from ...assembler import BaseAssembler
|
|
|
17
|
|
|
18
|
|
|
19 class ArmAssembler(BaseAssembler):
|
|
|
20 def __init__(self, target):
|
|
|
21 super().__init__(target)
|
|
|
22 self.target.add_keyword('section')
|
|
|
23 self.target.add_instruction(['section', 'ID'],
|
|
|
24 lambda rhs: self.select_section(rhs[1].val))
|
|
386
|
25 self.target.add_keyword('repeat')
|
|
|
26 self.target.add_keyword('endrepeat')
|
|
|
27 self.target.add_instruction(['repeat', 'imm32'], self.begin_repeat)
|
|
|
28 self.target.add_instruction(['endrepeat'], self.end_repeat)
|
|
|
29
|
|
398
|
30 # Construct the parser from the given rules:
|
|
381
|
31 self.make_parser()
|
|
|
32 self.lit_pool = []
|
|
|
33 self.lit_counter = 0
|
|
386
|
34 self.inMacro = False
|
|
|
35
|
|
|
36 def prepare(self):
|
|
|
37 self.inMacro = False
|
|
|
38
|
|
|
39 def begin_repeat(self, rhs):
|
|
|
40 if self.inMacro:
|
|
|
41 raise Exception()
|
|
|
42 self.inMacro = True
|
|
|
43 self.rep_count = rhs[1]
|
|
|
44 self.recording = []
|
|
|
45
|
|
|
46 def end_repeat(self, rhs):
|
|
|
47 if not self.inMacro:
|
|
|
48 raise Exception()
|
|
|
49 self.inMacro = False
|
|
|
50 for rec in self.recording * self.rep_count:
|
|
|
51 self.emit(*rec)
|
|
|
52
|
|
|
53 def emit(self, *args):
|
|
|
54 if self.inMacro:
|
|
|
55 self.recording.append(args)
|
|
|
56 else:
|
|
|
57 super().emit(*args)
|
|
381
|
58
|
|
|
59 def select_section(self, name):
|
|
|
60 self.flush()
|
|
|
61 self.stream.select_section(name)
|
|
|
62
|
|
|
63 def flush(self):
|
|
386
|
64 if self.inMacro:
|
|
|
65 raise Exception()
|
|
381
|
66 while self.lit_pool:
|
|
|
67 i = self.lit_pool.pop(0)
|
|
|
68 self.emit(i)
|
|
|
69
|
|
|
70 def add_literal(self, v):
|
|
|
71 """ For use in the pseudo instruction LDR r0, =SOMESYM """
|
|
|
72 # Invent some label for the literal and store it.
|
|
|
73 self.lit_counter += 1
|
|
|
74 label_name = "_lit_{}".format(self.lit_counter)
|
|
|
75 self.lit_pool.append(Label(label_name))
|
|
|
76 self.lit_pool.append(Dcd(v))
|
|
|
77 return label_name
|
|
342
|
78
|
|
386
|
79
|
|
345
|
80 class ArmTarget(Target):
|
|
342
|
81 def __init__(self):
|
|
346
|
82 super().__init__('arm')
|
|
|
83 self.make_parser()
|
|
|
84 self.ins_sel = ArmInstructionSelector()
|
|
|
85 self.FrameClass = ArmFrame
|
|
381
|
86 self.assembler = ArmAssembler(self)
|
|
342
|
87
|
|
346
|
88 self.add_lowering(Ldr3, lambda im: Ldr3(im.dst[0], im.others[0]))
|
|
|
89 self.add_lowering(Str1, lambda im: Str1(im.src[1], im.src[0], im.others[0]))
|
|
|
90 self.add_lowering(Ldr1, lambda im: Ldr1(im.dst[0], im.src[0], im.others[0]))
|
|
354
|
91 self.add_lowering(Adr, lambda im: Adr(im.dst[0], im.others[0]))
|
|
346
|
92 self.add_lowering(Mov2, lambda im: Mov2(im.dst[0], im.src[0]))
|
|
352
|
93 self.add_lowering(Cmp2, lambda im: Cmp2(im.src[0], im.src[1]))
|
|
|
94 self.add_lowering(Add1, lambda im: Add1(im.dst[0], im.src[0], im.src[1]))
|
|
359
|
95 self.add_lowering(Add2, lambda im: Add2(im.dst[0], im.src[0], im.others[0]))
|
|
356
|
96 self.add_lowering(Sub1, lambda im: Sub1(im.dst[0], im.src[0], im.src[1]))
|
|
354
|
97 self.add_lowering(Mul1, lambda im: Mul1(im.dst[0], im.src[0], im.src[1]))
|
|
356
|
98 self.add_lowering(Lsr1, lambda im: Lsr1(im.dst[0], im.src[0], im.src[1]))
|
|
|
99 self.add_lowering(And1, lambda im: And1(im.dst[0], im.src[0], im.src[1]))
|
|
357
|
100 self.add_lowering(Mov1, lambda im: Mov1(im.dst[0], im.others[0]))
|
|
346
|
101
|
|
364
|
102 def emit_global(self, outs, lname):
|
|
|
103 outs.emit(Label(lname))
|
|
|
104 outs.emit(Dcd(0))
|
|
|
105
|
|
346
|
106 def make_parser(self):
|
|
342
|
107 # Assembly grammar:
|
|
|
108 self.add_keyword('r0')
|
|
|
109 self.add_keyword('r1')
|
|
|
110 self.add_keyword('r2')
|
|
|
111 self.add_keyword('r3')
|
|
|
112 self.add_keyword('r4')
|
|
|
113 self.add_keyword('r5')
|
|
|
114 self.add_keyword('r6')
|
|
|
115 self.add_keyword('r7')
|
|
345
|
116 self.add_keyword('r8')
|
|
|
117 self.add_keyword('r9')
|
|
|
118 self.add_keyword('r10')
|
|
|
119 self.add_keyword('r11')
|
|
|
120 self.add_keyword('r12')
|
|
346
|
121 self.add_keyword('sp')
|
|
|
122 self.add_keyword('lr')
|
|
|
123 self.add_keyword('pc')
|
|
342
|
124
|
|
|
125 self.add_rule('reg', ['r0'], lambda rhs: R0)
|
|
|
126 self.add_rule('reg', ['r1'], lambda rhs: R1)
|
|
|
127 self.add_rule('reg', ['r2'], lambda rhs: R2)
|
|
|
128 self.add_rule('reg', ['r3'], lambda rhs: R3)
|
|
|
129 self.add_rule('reg', ['r4'], lambda rhs: R4)
|
|
|
130 self.add_rule('reg', ['r5'], lambda rhs: R5)
|
|
|
131 self.add_rule('reg', ['r6'], lambda rhs: R6)
|
|
|
132 self.add_rule('reg', ['r7'], lambda rhs: R7)
|
|
345
|
133 self.add_rule('reg', ['r8'], lambda rhs: R8)
|
|
|
134 self.add_rule('reg', ['r9'], lambda rhs: R9)
|
|
|
135 self.add_rule('reg', ['r10'], lambda rhs: R10)
|
|
|
136 self.add_rule('reg', ['r11'], lambda rhs: R11)
|
|
|
137 self.add_rule('reg', ['r12'], lambda rhs: R12)
|
|
346
|
138 self.add_rule('reg', ['sp'], lambda rhs: SP)
|
|
|
139 self.add_rule('reg', ['lr'], lambda rhs: LR)
|
|
|
140 self.add_rule('reg', ['pc'], lambda rhs: PC)
|
|
342
|
141
|
|
346
|
142 self.add_keyword('dcd')
|
|
|
143 self.add_instruction(['dcd', 'imm32'],
|
|
|
144 lambda rhs: Dcd(rhs[1]))
|
|
342
|
145
|
|
345
|
146 self.add_keyword('mov')
|
|
346
|
147 self.add_instruction(['mov', 'reg', ',', 'imm32'],
|
|
342
|
148 lambda rhs: Mov(rhs[1], rhs[3]))
|
|
362
|
149 self.add_instruction(['mov', 'reg', ',', 'reg'],
|
|
|
150 lambda rhs: Mov(rhs[1], rhs[3]))
|
|
342
|
151
|
|
352
|
152 self.add_keyword('cmp')
|
|
|
153 self.add_instruction(['cmp', 'reg', ',', 'imm32'],
|
|
|
154 lambda rhs: Cmp(rhs[1], rhs[3]))
|
|
|
155 self.add_instruction(['cmp', 'reg', ',', 'reg'],
|
|
|
156 lambda rhs: Cmp(rhs[1], rhs[3]))
|
|
|
157
|
|
|
158 # Arithmatic:
|
|
345
|
159 self.add_keyword('add')
|
|
|
160 self.add_instruction(['add', 'reg', ',', 'reg', ',', 'imm32'],
|
|
|
161 lambda rhs: Add(rhs[1], rhs[3], rhs[5]))
|
|
|
162
|
|
|
163 self.add_instruction(['add', 'reg', ',', 'reg', ',', 'reg'],
|
|
|
164 lambda rhs: Add(rhs[1], rhs[3], rhs[5]))
|
|
|
165
|
|
|
166 self.add_keyword('sub')
|
|
|
167 self.add_instruction(['sub', 'reg', ',', 'reg', ',', 'imm32'],
|
|
|
168 lambda rhs: Sub(rhs[1], rhs[3], rhs[5]))
|
|
|
169
|
|
|
170 self.add_instruction(['sub', 'reg', ',', 'reg', ',', 'reg'],
|
|
|
171 lambda rhs: Sub(rhs[1], rhs[3], rhs[5]))
|
|
|
172
|
|
346
|
173 self.add_keyword('mul')
|
|
|
174 self.add_instruction(['mul', 'reg', ',', 'reg', ',', 'reg'],
|
|
|
175 lambda rhs: Mul(rhs[1], rhs[3], rhs[5]))
|
|
|
176
|
|
345
|
177 self.add_keyword('orr')
|
|
|
178 self.add_instruction(['orr', 'reg', ',', 'reg', ',', 'reg'],
|
|
|
179 lambda rhs: Orr1(rhs[1], rhs[3], rhs[5]))
|
|
|
180
|
|
356
|
181 self.add_keyword('and')
|
|
|
182 self.add_instruction(['and', 'reg', ',', 'reg', ',', 'reg'],
|
|
|
183 lambda rhs: And1(rhs[1], rhs[3], rhs[5]))
|
|
|
184
|
|
|
185 self.add_keyword('lsr')
|
|
|
186 self.add_instruction(['lsr', 'reg', ',', 'reg', ',', 'reg'],
|
|
|
187 lambda rhs: Lsr1(rhs[1], rhs[3], rhs[5]))
|
|
|
188
|
|
|
189 self.add_keyword('lsl')
|
|
|
190 self.add_instruction(['lsl', 'reg', ',', 'reg', ',', 'reg'],
|
|
|
191 lambda rhs: Lsl1(rhs[1], rhs[3], rhs[5]))
|
|
|
192
|
|
345
|
193
|
|
|
194 # Jumping:
|
|
|
195 self.add_keyword('b')
|
|
|
196 self.add_instruction(['b', 'ID'], lambda rhs: B(rhs[1].val))
|
|
|
197 self.add_keyword('ble')
|
|
|
198 self.add_instruction(['ble', 'ID'], lambda rhs: Ble(rhs[1].val))
|
|
|
199 self.add_keyword('bgt')
|
|
|
200 self.add_instruction(['bgt', 'ID'], lambda rhs: Bgt(rhs[1].val))
|
|
|
201 self.add_keyword('beq')
|
|
|
202 self.add_instruction(['beq', 'ID'], lambda rhs: Beq(rhs[1].val))
|
|
346
|
203 self.add_keyword('blt')
|
|
|
204 self.add_instruction(['blt', 'ID'], lambda rhs: Blt(rhs[1].val))
|
|
345
|
205
|
|
|
206 self.add_keyword('bl')
|
|
|
207 self.add_instruction(['bl', 'ID'], lambda rhs: Bl(rhs[1].val))
|
|
346
|
208
|
|
|
209 # memory:
|
|
|
210 self.add_keyword('pop')
|
|
|
211 self.add_instruction(['pop', 'reg_list'], lambda rhs: Pop(rhs[1]))
|
|
|
212
|
|
|
213 self.add_keyword('push')
|
|
|
214 self.add_instruction(['push', 'reg_list'], lambda rhs: Push(rhs[1]))
|
|
|
215
|
|
|
216 self.add_keyword('ldr')
|
|
|
217 self.add_instruction(['ldr', 'reg', ',', '[', 'reg', ',', 'imm8', ']'],
|
|
|
218 lambda rhs: Ldr(rhs[1], rhs[4], rhs[6]))
|
|
|
219
|
|
350
|
220 self.add_instruction(['ldr', 'reg', ',', 'ID'],
|
|
|
221 lambda rhs: Ldr(rhs[1], rhs[3].val))
|
|
|
222
|
|
375
|
223 # This is a pseudo instruction:
|
|
|
224 self.add_instruction(['ldr', 'reg', ',', '=', 'ID'],
|
|
381
|
225 lambda rhs: LdrPseudo(rhs[1], rhs[4].val, self.assembler.add_literal))
|
|
375
|
226
|
|
346
|
227 self.add_keyword('str')
|
|
|
228 self.add_instruction(['str', 'reg', ',', '[', 'reg', ',', 'imm8', ']'],
|
|
|
229 lambda rhs: Str(rhs[1], rhs[4], rhs[6]))
|
|
|
230
|
|
|
231 self.add_instruction(['str', 'reg', ',', '[', 'reg', ',', 'reg', ']'],
|
|
|
232 lambda rhs: Str(rhs[1], rhs[4], rhs[6]))
|
|
|
233
|
|
354
|
234 self.add_keyword('adr')
|
|
|
235 self.add_instruction(['adr', 'reg', ',', 'ID'],
|
|
|
236 lambda rhs: Adr(rhs[1], rhs[3].val))
|
|
|
237
|
|
375
|
238
|
|
346
|
239 # Register list grammar:
|
|
|
240 self.add_rule('reg_list', ['{', 'reg_list_inner', '}'],
|
|
|
241 lambda rhs: rhs[1])
|
|
|
242 self.add_rule('reg_list_inner', ['reg_or_range'],
|
|
|
243 lambda rhs: rhs[0])
|
|
|
244 self.add_rule('reg_list_inner', ['reg_or_range', ',', 'reg_list_inner'],
|
|
|
245 lambda rhs: rhs[0] | rhs[2])
|
|
|
246 self.add_rule('reg_or_range', ['reg'], lambda rhs: {rhs[0]})
|
|
|
247
|
|
|
248 self.add_rule('reg_or_range', ['reg', '-', 'reg'],
|
|
|
249 lambda rhs: register_range(rhs[0], rhs[2]))
|
|
362
|
250
|
|
|
251 # Add MCR and MRC (co-processor)
|
|
|
252 for i in range(16):
|
|
|
253 creg = 'c{}'.format(i)
|
|
|
254 self.add_keyword(creg)
|
|
|
255 self.add_rule('coreg', [creg], i)
|
|
|
256
|
|
|
257 for i in range(8, 16):
|
|
|
258 px = 'p{}'.format(i)
|
|
|
259 self.add_keyword(px)
|
|
|
260 # Ran into trouble when using i inside lambda function:
|
|
|
261 # When using inside lambda (as a closure), i is bound to the latest
|
|
|
262 # value (15)
|
|
|
263 self.add_rule('coproc', [px], i)
|
|
|
264
|
|
|
265 self.add_keyword('mcr')
|
|
|
266 self.add_instruction(['mcr', 'coproc', ',', 'imm3', ',', 'reg', ',', 'coreg', ',', 'coreg', ',', 'imm3'],
|
|
|
267 lambda rhs: Mcr(rhs[1], rhs[3], rhs[5], rhs[7], rhs[9], rhs[11]))
|
|
|
268
|
|
|
269 self.add_keyword('mrc')
|
|
|
270 self.add_instruction(['mrc', 'coproc', ',', 'imm3', ',', 'reg', ',', 'coreg', ',', 'coreg', ',', 'imm3'],
|
|
|
271 lambda rhs: Mrc(rhs[1], rhs[3], rhs[5], rhs[7], rhs[9], rhs[11]))
|
