def tryExpandJumptable(self, jumptable_addr):
manual_limit = manualJumptableLimit(jumptable_addr)
if manual_limit and self.jumptable_sizes[jumptable_addr] >= manual_limit:
print "INFO: manual jumptable limit", jumptable_addr
self.suspicious_switch = True
return
next_target_addr = jumptable_addr.offset(self.jumptable_sizes[jumptable_addr] * 2)
if not manual_limit and not self.isAvailableAddr(next_target_addr):
return
rom = disasm.cur_rom
next_target = address.fromVirtualAndCurrent(rom.get_word(next_target_addr), self.start_addr)
if not manual_limit:
if not next_target.inPhysicalMem() or next_target.virtual() <= 0x4A:
print 'WARN: jumptable at', jumptable_addr, 'bounded by bad addr', next_target
self.suspicious_switch = True
return
self.log.append('=== expand jumptable === ' + str(next_target))
# everything ok, expand jumptable
self.jumptable_sizes[jumptable_addr] += 1
self.ownByteRange(next_target_addr, 2)
self.jumptable_queue.add(jumptable_addr)
self.queue.add(next_target)
self.labels.add(next_target)
self.block_starts.add(next_target)
def optimizedWithContext(self, ctx):
self.target = self.target.optimizedWithContext(ctx)
if hasattr(self.target, 'getAddress'):
self.targetAddr = self.target.getAddress()
else:
self.targetAddr = address.fromVirtualAndCurrent(self.target.value, self.addr)
deps = self.getDependencySet()
ins = regutil.joinRegisters(deps.reads - set(['mem']))
for param in ins:
if ctx.hasConstantValue(param):
self.constant_params[param] = ctx.getValue(param)
for w in deps.writes:
ctx.setValueComplex(w)
# TODO: XXX
if self.targetAddr.virtual() == 0x07B9:
if 'A' in self.constant_params:
ctx.setValue('ROMBANK', self.constant_params['A'])
return self
def __init__(self, name, target, cond, addr):
super(CallInstruction, self).__init__(name, addr)
self.cond = cond
if hasattr(target, 'getAddress'):
self.targetAddr = target.getAddress()
else:
self.targetAddr = address.fromVirtualAndCurrent(target.value, addr)
self.target = operand.ProcAddress(self.targetAddr)
self.returns_used = regutil.ALL_REGS
self.constant_params = dict()
def __init__(self, name, target, cond, addr):
super(JumpInstruction, self).__init__(name, addr)
self.cond = cond
if hasattr(target, 'getAddress'):
self.targetAddr = target.getAddress()
self.target = target
if target.value is not None:
self.targetAddr = address.fromVirtualAndCurrent(target.value, addr)
self.target = operand.ProcAddress(self.targetAddr)
else:
self.targetAddr = None
self.target = target
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 __init__(self, addr):
self.addr = addr
self.targets = []
import disasm
rom = disasm.cur_rom
for i in range(256):
a = addr.offset(i*2)
lo = rom.get(a)
hi = rom.get(a.offset(1))
value = address.fromVirtualAndCurrent((hi<<8) | lo, addr)
if not value.inPhysicalMem():
break
self.targets.append(operand.ProcAddress(value))
