def __init__(self, inner, postcond, continue_label): self.name = 'do-while' self.addr = address.fromVirtual(0) self.inner = inner self.postcond = postcond self.continue_label = continue_label continue_label.addContinue(self)
def __init__(self, addr): super(Label, self).__init__('label', [operand.AddressConstant(addr)]) self.addr = address.fromVirtual(0) self.gotos = set() self.breaks = set() self.continues = set() self.needed = regutil.ALL_REGS - set(['FZ', 'FC', 'FN', 'FH']) self.depset = depend.unknown()
def getLimit(addr): if addr.inPhysicalMem(): bank_limit = address.fromVirtualAndBank(0x4000, addr.bank()+1) else: bank_limit = address.fromVirtual(0xFFFF) next_owned = database.getNextOwnedAddress(addr) if not next_owned or bank_limit < next_owned: return bank_limit else: return next_owned
def __init__(self, target, addr=None): self.addr = addr if hasattr(target, "getAddress"): self.target = target elif target.value is not None: if addr is not None: self.target = DataAddress(address.fromVirtualAndCurrent(target.value, addr)) else: self.target = DataAddress(address.fromVirtual(target.value)) else: self.target = target self.childs = (self.target,)
def process(self, x, after, break_target, continue_target, need_label=False): after = self.graph.skipSimpleJumps(after) break_target = self.graph.skipSimpleJumps(break_target) continue_target = self.graph.skipSimpleJumps(continue_target) out = [] while True: x = self.graph.skipSimpleJumps(x) if x is None or x in self._visited: if x == after: pass elif x == break_target: if x is None and None not in self.labels: self.labels[None] = flowcontrol.Label(address.fromVirtual(0)) out.append(flowcontrol.Break(self.labels[x])) elif x == continue_target: out.append(flowcontrol.Continue(self.labels[x])) elif x is None: out.append(flowcontrol.Return()) else: out.append(flowcontrol.Goto(self.labels[x])) return flowcontrol.Block(out) cycle = self.get_unused_cycle(x) if cycle: exits = find_cycle_exits(self.graph, cycle) if exits: exits = set([select_any(exits)]) cascades, next_after = self._process_cascades(exits, after, break_target, continue_target) inner = self.process(x, x, next_after, x, True) continue_label = self.labels[x] out.append(self.make_while(inner, continue_label)) return flowcontrol.Block(out + cascades) self._visited.add(x) childs = self.graph.childs(x) if (len(self.graph.parents(x)) > 1 or need_label) and x not in self.labels: self.labels[x] = flowcontrol.Label(x) out.append(self.labels[x]) need_label = False if len(childs) > 1: cascades, next_after = self._process_cascades(self.merges[x], after, break_target, continue_target) prev_contents = self.graph.getContents(x)[:-1] out += prev_contents if self.graph.isSwitch(x): break_target = next_after branches = [] for ch in reversed(childs): branches.append(self.process(ch, next_after, break_target, continue_target)) next_after = ch branches.reverse() out += self.make_switch(x, branches) else: branches = [] for ch in childs: branches.append(self.process(ch, next_after, break_target, continue_target)) out += self.make_if(x, branches[0], branches[1]) return flowcontrol.Block(out + cascades) else: out += self.graph.getContents(x) x = select_any(childs) continue
def testDepend(self): self.assertFalse('A' in operand.Constant(1).getDependencies()) self.assertFalse('B' in operand.LabelAddress(address.fromVirtual(1)).getDependencies()) self.assertTrue('A' in placeholders.A.getDependencies()) self.assertFalse('A' in placeholders.BC.getDependencies()) self.assertTrue(regutil.splitRegister('HL') <= regutil.splitRegisters(placeholders.deref_HL.getDependencies()))
def __init__(self, name, addr=None): self.name = name self.addr = addr if not self.addr: self.addr = address.fromVirtual(0)
from operand import Register, Condition, Dereference BC = Register("BC") DE = Register("DE") HL = Register("HL") SP = Register("SP") AF = Register("AF") B = Register("B") C = Register("C") D = Register("D") E = Register("E") H = Register("H") L = Register("L") A = Register("A") deref_HL = Dereference(HL, address.fromVirtual(0)) # XXX: TODO: very very bad FNZ = Condition("FNZ") FZ = Condition("FZ") FNC = Condition("FNC") FC = Condition("FC") ALWAYS = Condition("ALWAYS") ROMBANK = Register('ROMBANK') tab = dict( R=[BC, DE, HL, SP], Q=[BC, DE, HL, AF], S=[B, C, D, E, H, L, deref_HL, A], Z=[B, C, D, E, H, L, deref_HL, A], F=[FNZ, FZ, FNC, FC],
def __init__(self, addr): if not hasattr(addr, 'virtual'): addr = address.fromVirtual(addr) super(AddressConstant, self).__init__(addr.virtual()) self.addr = addr self.value = addr.virtual()
def optimizedWithContext(self, ctx): target = self.target.optimizedWithContext(ctx) if not hasattr(target, 'getAddress') and target.value is not None: target = DataAddress(address.fromVirtual(target.value)).optimizedWithContext(ctx) return Dereference(target, self.addr)