Mercurial > lcfOS
annotate python/target/arminstructionselector.py @ 341:4d204f6f7d4e devel
Rewrite of assembler parts
author | Windel Bouwman |
---|---|
date | Fri, 28 Feb 2014 18:07:14 +0100 |
parents | d1ecc493384e |
children |
rev | line source |
---|---|
322 | 1 import os |
336
d1ecc493384e
Added spiffy armtoken class for bit fiddeling. Added cool test that checks for build repeatability
Windel Bouwman
parents:
323
diff
changeset
|
2 from ppci import ir, same_dir |
301 | 3 from ppci.irmach import AbstractInstruction as makeIns |
322 | 4 from ppci.ir2tree import makeTree |
5 import pyburg | |
292 | 6 from .basetarget import Label, Comment, Alignment, LabelRef, DebugInfo, Nop |
7 from .instructionselector import InstructionSelector | |
305 | 8 from .arminstructions import Orr, Lsl, Str2, Ldr2, Ldr3 |
9 from .arminstructions import B, Bl, Bgt, Blt, Beq, Bne | |
292 | 10 from .arminstructions import Mov2, Mov3 |
341 | 11 from .arminstructions import Cmp, Sub2, Mul |
292 | 12 from .basetarget import Imm8, Imm7, Imm3 |
13 | |
322 | 14 # Import BURG spec for arm: |
336
d1ecc493384e
Added spiffy armtoken class for bit fiddeling. Added cool test that checks for build repeatability
Windel Bouwman
parents:
323
diff
changeset
|
15 spec_file = same_dir(__file__, 'arm.brg') |
322 | 16 arm_matcher = pyburg.load_as_module(spec_file) |
17 | |
323 | 18 |
322 | 19 class ArmMatcher(arm_matcher.Matcher): |
323 | 20 """ Matcher that derives from a burg spec generated matcher """ |
21 def __init__(self, selector): | |
322 | 22 super().__init__() |
323 | 23 self.newTmp = selector.newTmp |
24 self.emit = selector.emit | |
25 self.selector = selector | |
322 | 26 |
292 | 27 |
28 class ArmInstructionSelector(InstructionSelector): | |
29 """ Instruction selector for the arm architecture """ | |
322 | 30 def __init__(self): |
31 super().__init__() | |
323 | 32 self.matcher = ArmMatcher(self) |
322 | 33 |
292 | 34 def munchExpr(self, e): |
323 | 35 # Use BURG system here: |
36 t = makeTree(e) | |
37 return self.matcher.gen(t) | |
322 | 38 |
323 | 39 def munchCall(self, e): |
40 """ Generate code for call sequence """ | |
41 # Move arguments into proper locations: | |
42 reguses = [] | |
43 for i, a in enumerate(e.arguments): | |
44 loc = self.frame.argLoc(i) | |
45 m = ir.Move(loc, a) | |
46 self.munchStm(m) | |
47 if isinstance(loc, ir.Temp): | |
48 reguses.append(loc) | |
49 self.emit(Bl(LabelRef(e.f)), src=reguses, dst=[self.frame.rv]) | |
50 d = self.newTmp() | |
51 self.move(d, self.frame.rv) | |
52 return d | |
292 | 53 |
54 def munchStm(self, s): | |
55 if isinstance(s, ir.Terminator): | |
56 pass | |
57 elif isinstance(s, ir.Move) and isinstance(s.dst, ir.Mem) and \ | |
58 isinstance(s.dst.e, ir.Binop) and s.dst.e.operation == '+' and \ | |
59 isinstance(s.dst.e.b, ir.Const): | |
60 a = self.munchExpr(s.dst.e.a) | |
61 val = self.munchExpr(s.src) | |
62 c = s.dst.e.b.value | |
63 self.emit(Str2, others=[c], src=[a, val]) | |
64 elif isinstance(s, ir.Move) and isinstance(s.dst, ir.Mem): | |
65 memloc = self.munchExpr(s.dst.e) | |
66 val = self.munchExpr(s.src) | |
67 self.emit(Str2, others=[0], src=[memloc, val]) | |
68 elif isinstance(s, ir.Move) and isinstance(s.dst, ir.Temp): | |
69 val = self.munchExpr(s.src) | |
70 dreg = s.dst | |
71 self.move(dreg, val) | |
72 elif isinstance(s, ir.Exp): | |
73 # Generate expression code and discard the result. | |
74 x = self.munchExpr(s.e) | |
75 self.emit(Nop(), src=[x]) | |
76 elif isinstance(s, ir.Jump): | |
77 tgt = self.targets[s.target] | |
336
d1ecc493384e
Added spiffy armtoken class for bit fiddeling. Added cool test that checks for build repeatability
Windel Bouwman
parents:
323
diff
changeset
|
78 self.emit(B(LabelRef(ir.label_name(s.target))), jumps=[tgt]) |
292 | 79 elif isinstance(s, ir.CJump): |
80 a = self.munchExpr(s.a) | |
81 b = self.munchExpr(s.b) | |
82 self.emit(Cmp, src=[a, b]) | |
83 ntgt = self.targets[s.lab_no] | |
84 ytgt = self.targets[s.lab_yes] | |
336
d1ecc493384e
Added spiffy armtoken class for bit fiddeling. Added cool test that checks for build repeatability
Windel Bouwman
parents:
323
diff
changeset
|
85 jmp_ins = makeIns(B(LabelRef(ir.label_name(s.lab_no))), jumps=[ntgt]) |
305 | 86 opnames = {'<': Blt, '>':Bgt, '==':Beq, '!=':Bne} |
336
d1ecc493384e
Added spiffy armtoken class for bit fiddeling. Added cool test that checks for build repeatability
Windel Bouwman
parents:
323
diff
changeset
|
87 op = opnames[s.cond](LabelRef(ir.label_name(s.lab_yes))) |
292 | 88 self.emit(op, jumps=[ytgt, jmp_ins]) # Explicitely add fallthrough |
89 self.emit2(jmp_ins) | |
90 else: | |
91 raise NotImplementedError('Stmt --> {}'.format(s)) | |
92 | |
93 def move(self, dst, src): | |
318 | 94 self.emit(Mov2, src=[src], dst=[dst], ismove=True) |