def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(self.n)
except EndOfInstruction:
pass
else:
address = processor.registers.get(self.n)
for i in xrange(15):
if self.registers[15 - i]:
processor.registers.set(
i, processor.mem_a_get(address, 4))
address = add(address, BitArray(bin="100"), 32)
if self.registers[0]:
processor.load_write_pc(processor.mem_a_get(address, 4))
if self.wback and not self.registers[15 - self.n]:
processor.registers.set(
self.n,
add(
processor.registers.get(self.n),
BitArray(uint=(4 * self.registers.count(1)),
length=32), 32))
if self.wback and self.registers[15 - self.n]:
processor.registers.set(self.n,
BitArray(length=32)) # unknown
def execute(self, processor):
if processor.condition_passed():
if processor.registers.current_mode_is_hyp():
raise UndefinedInstructionException()
elif (not processor.registers.current_mode_is_not_user() or
processor.registers.current_instr_set() == InstrSet.InstrSet_ThumbEE):
print "unpredictable"
else:
address = (processor.registers.get(self.n)
if self.increment
else sub(processor.registers.get(self.n), BitArray(bin="1000"), 32))
if self.word_higher:
address = add(address, BitArray(bin="100"), 32)
new_pc_value = processor.mem_a_get(address, 4)
spsr_value = processor.mem_a_get(add(address, BitArray(bin="100"), 32), 4)
if self.wback:
processor.registers.set(
self.n,
(add(processor.registers.get(self.n), BitArray(bin="1000"), 32)
if self.increment
else sub(processor.registers.get(self.n), BitArray(bin="1000"), 32))
)
processor.registers.cpsr_write_by_instr(spsr_value, BitArray(bin="1111"), True)
if (processor.registers.cpsr.get_m() == "0b11010" and
processor.registers.cpsr.get_j() and
processor.registers.cpsr.get_t()):
print "unpredictable"
else:
processor.branch_write_pc(new_pc_value)
def execute(self, processor):
if processor.condition_passed():
if processor.registers.current_mode_is_hyp():
raise UndefinedInstructionException()
elif (processor.registers.current_mode_is_user_or_system()
or processor.registers.current_instr_set()
== InstrSet.THUMB_EE):
print('unpredictable')
else:
length = (4 * bit_count(self.registers, 1, 16)) + 4
address = processor.registers.get(
self.n) if self.increment else sub(
processor.registers.get(self.n), length, 32)
if self.word_higher:
address = add(address, 4, 32)
for i in range(15):
if bit_at(self.registers, i):
processor.registers.set(
i, processor.mem_a_get(address, 4))
address = add(address, 4, 32)
new_pc_value = processor.mem_a_get(address, 4)
if self.wback and not bit_at(self.registers, self.n):
processor.registers.set(
self.n, (add(processor.registers.get(
self.n), length, 32) if self.increment else sub(
processor.registers.get(self.n), length, 32)))
if self.wback and bit_at(self.registers, self.n):
processor.registers.set(self.n, 0x00000000) # unknown
processor.registers.cpsr_write_by_instr(
processor.registers.get_spsr(), 0b1111, True)
if processor.registers.cpsr.m == 0b11010 and processor.registers.cpsr.j and processor.registers.cpsr.t:
print('unpredictable')
else:
processor.branch_write_pc(new_pc_value)
def execute(self, processor):
if processor.condition_passed():
if processor.registers.current_mode_is_hyp():
raise UndefinedInstructionException()
elif (not processor.registers.current_mode_is_not_user() or
processor.registers.current_instr_set() == InstrSet.THUMB_EE):
print('unpredictable')
else:
address = (processor.registers.get(self.n)
if self.increment else sub(processor.registers.get(self.n), 8, 32))
if self.word_higher:
address = add(address, 4, 32)
new_pc_value = processor.mem_a_get(address, 4)
spsr_value = processor.mem_a_get(add(address, 4, 32), 4)
if self.wback:
processor.registers.set(
self.n,
(add(processor.registers.get(self.n), 8, 32)
if self.increment else sub(processor.registers.get(self.n), 8, 32))
)
processor.registers.cpsr_write_by_instr(spsr_value, 0b1111, True)
if (processor.registers.cpsr.m == 0b11010 and
processor.registers.cpsr.j and
processor.registers.cpsr.t):
print('unpredictable')
else:
processor.branch_write_pc(new_pc_value)
def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(13)
except EndOfInstruction:
pass
else:
address = processor.registers.get_sp()
for i in range(15):
if bit_at(self.registers, i):
processor.registers.set(
i,
(processor.mem_u_get(address, 4) if self.unaligned_allowed else processor.mem_a_get(address,
4))
)
address = add(address, 4, 32)
if bit_at(self.registers, 15):
if self.unaligned_allowed:
if substring(address, 1, 0) == 0b00:
processor.load_write_pc(processor.mem_u_get(address, 4))
else:
print('unpredictable')
else:
processor.load_write_pc(processor.mem_a_get(address, 4))
if not bit_at(self.registers, 13):
processor.registers.set_sp(add(
processor.registers.get_sp(), 4 * bit_count(self.registers, 1, 16), 32
))
if bit_at(self.registers, 13):
processor.registers.set_sp(0x00000000) # unknown
def execute(self, processor):
if processor.condition_passed():
if processor.registers.current_mode_is_hyp():
raise UndefinedInstructionException()
elif processor.registers.current_mode_is_user_or_system():
print('unpredictable')
elif self.mode == 0b11010:
print('unpredictable')
else:
if not processor.registers.is_secure():
if self.mode == 0b10110 or (self.mode == 0b10001 and
processor.registers.nsacr.rfr):
print('unpredictable')
base = processor.registers.get_rmode(13, self.mode)
address = base if self.increment else sub(base, 8, 32)
if self.word_higher:
address = add(address, 0b100, 32)
processor.mem_a_set(address, 4, processor.registers.get_lr())
processor.mem_a_set(add(address, 4, 32), 4,
processor.registers.get_spsr())
if self.wback:
processor.registers.set_rmode(
13, self.mode,
add(base, 8, 32) if self.increment else sub(
base, 8, 32))
def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(13)
except EndOfInstruction:
pass
else:
address = processor.registers.get_sp()
for i in xrange(15):
if self.registers[15 - i]:
processor.registers.set(
i,
(processor.mem_u_get(address, 4)
if self.unaligned_allowed
else processor.mem_a_get(address, 4))
)
address = add(address, BitArray(bin="100"), 32)
if self.registers[0]:
if self.unaligned_allowed:
if address[30:32] == "0b00":
processor.load_write_pc(processor.mem_u_get(address, 4))
else:
print "unpredictable"
else:
processor.load_write_pc(processor.mem_a_get(address, 4))
if not self.registers[2]:
processor.registers.set_sp(
add(processor.registers.get_sp(),
BitArray(uint=(4 * self.registers.count(1)), length=32), 32))
if self.registers[2]:
processor.registers.set_sp(BitArray(length=32)) # unknown
def execute(self, processor):
if processor.condition_passed():
rotated = ror(processor.registers.get(self.m), 32, self.rotation)
n = processor.registers.get(self.n)
lower_half = add(substring(n, 15, 0), substring(rotated, 7, 0), 16)
temp_rd = set_substring(0, 15, 0, lower_half)
upper_half = add(substring(n, 31, 16), substring(rotated, 23, 16),
16)
temp_rd = set_substring(temp_rd, 31, 16, upper_half)
processor.registers.set(self.d, temp_rd)
def execute(self, processor):
if processor.condition_passed():
if processor.registers.current_instr_set() == InstrSet.ARM:
processor.registers.set_lr(
sub(processor.registers.get_pc(), 4, 32))
else:
processor.registers.set_lr(processor.registers.get_pc() | 0b1)
if self.target_instr_set == InstrSet.ARM:
target_address = add(align(processor.registers.get_pc(), 4),
self.imm32, 32)
else:
target_address = add(processor.registers.get_pc(), self.imm32,
32)
processor.registers.select_instr_set(self.target_instr_set)
processor.branch_write_pc(target_address)
def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(13)
except EndOfInstruction:
pass
else:
address = sub(processor.registers.get_sp(),
4 * bit_count(self.registers, 1, 32), 32)
for i in range(15):
if bit_at(self.registers, i):
if i == 13 and i != lowest_set_bit_ref(self.registers):
processor.mem_a_set(address, 4,
0x00000000) # unknown
else:
if self.unaligned_allowed:
processor.mem_u_set(address, 4,
processor.registers.get(i))
else:
processor.mem_a_set(address, 4,
processor.registers.get(i))
address = add(address, 4, 32)
if bit_at(self.registers, 15):
if self.unaligned_allowed:
processor.mem_u_set(
address, 4, processor.registers.pc_store_value())
else:
processor.mem_a_set(
address, 4, processor.registers.pc_store_value())
processor.registers.set_sp(
sub(processor.registers.get_sp(),
4 * bit_count(self.registers, 1, 32), 32))
def execute(self, processor):
if processor.condition_passed():
rotated = ror(processor.registers.get(self.m), 32, self.rotation)
processor.registers.set(
self.d,
add(processor.registers.get(self.n), sign_extend(lower_chunk(rotated, 8), 8, 32), 32)
)
def take_svc_exception(self):
self.it_advance()
new_lr_value = bits_ops.sub(self.get_pc(), 2,
32) if self.cpsr.t else bits_ops.sub(
self.get_pc(), 4, 32)
new_spsr_value = self.cpsr.value
vect_offset = 8
take_to_hyp = have_virt_ext() and have_security_ext(
) and self.scr.ns and self.cpsr.m == 0b11010
route_to_hyp = (have_virt_ext() and have_security_ext()
and not self.is_secure() and self.hcr.tge
and self.cpsr.m == 0b10000)
preferred_exceptn_return = new_lr_value
if take_to_hyp:
self.enter_hyp_mode(new_spsr_value, preferred_exceptn_return,
vect_offset)
elif route_to_hyp:
self.enter_hyp_mode(new_spsr_value, preferred_exceptn_return, 20)
else:
if self.cpsr.m == 0b10110:
self.scr.ns = 0
self.cpsr.m = 0b10011
self.set_spsr(new_spsr_value)
self.set(14, new_lr_value)
self.cpsr.i = 1
self.cpsr.it = 0b00000000
self.cpsr.j = 0
self.cpsr.t = self.sctlr.te
self.cpsr.e = self.sctlr.ee
self.branch_to(
bits_ops.add(self.exc_vector_base(), vect_offset, 32))
def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(self.n)
except EndOfInstruction:
pass
else:
address = sub(processor.registers.get(self.n),
4 * bit_count(self.registers, 1, 16), 32)
for i in range(15):
if bit_at(self.registers, i):
if i == self.n and self.wback and i != lowest_set_bit_ref(
self.registers):
processor.mem_a_set(address, 4,
0x00000000) # unknown
else:
processor.mem_a_set(address, 4,
processor.registers.get(i))
address = add(address, 4, 32)
if bit_at(self.registers, 15):
processor.mem_a_set(address, 4,
processor.registers.pc_store_value())
if self.wback:
processor.registers.set(
self.n,
sub(processor.registers.get(self.n),
4 * bit_count(self.registers, 1, 16), 32))
def execute(self, processor):
if processor.condition_passed():
if processor.registers.current_mode_is_hyp():
raise UndefinedInstructionException()
elif processor.registers.current_mode_is_user_or_system():
print "unpredictable"
else:
length = 4 * self.registers.count(1)
address = processor.registers.get(self.n) if self.increment else sub(
processor.registers.get(self.n),
BitArray(uint=length, length=32), 32)
if self.word_higher:
address = add(address, BitArray(bin="100"), 32)
for i in xrange(15):
if self.registers[15 - i]:
processor.registers.set_rmode(i, BitArray(bin="10000"), processor.mem_a_get(address, 4))
address = add(address, BitArray(bin="100"), 32)
def get(self, n):
assert 0 <= n <= 15
if n == 15:
offset = 8 if (self.current_instr_set() == InstrSet.ARM) else 4
result = bits_ops.add(self._R[RName.PC], offset, 32)
else:
result = self.get_rmode(n, self.cpsr.m)
return result
def take_data_abort_exception(self, dabort_exception):
new_lr_value = bits_ops.add(self.get_pc(), 4,
32) if self.cpsr.t else self.get_pc()
new_spsr_value = self.cpsr.value
vect_offset = 16
preferred_exceptn_return = bits_ops.sub(new_lr_value, 8, 32)
route_to_monitor = have_security_ext(
) and self.scr.ea and self.is_external_abort()
take_to_hyp = have_virt_ext() and have_security_ext(
) and self.scr.ns and self.cpsr.m == 0b11010
route_to_hyp = (
have_virt_ext() and have_security_ext() and not self.is_secure()
and (dabort_exception.second_stage_abort() or
(self.cpsr.m != 0b11010 and
(self.is_external_abort() and self.is_async_abort()
and self.hcr.amo) or
(self.debug_exception() and self.hdcr.tde)) or
(self.cpsr.m == 0b10000 and self.hcr.tge and
(dabort_exception.is_alignment_fault() or
(self.is_external_abort() and not self.is_async_abort())))))
if route_to_monitor:
if self.cpsr.m == 0b10110:
self.scr.ns = 0
self.enter_monitor_mode(new_spsr_value, new_lr_value, vect_offset)
elif take_to_hyp:
self.enter_hyp_mode(new_spsr_value, preferred_exceptn_return,
vect_offset)
elif route_to_hyp:
self.enter_hyp_mode(new_spsr_value, preferred_exceptn_return, 20)
else:
if have_security_ext() and self.cpsr.m == 0b10110:
self.scr.ns = 0
self.cpsr.m = 0b10111
self.set_spsr(new_spsr_value)
self.set(14, new_lr_value)
self.cpsr.i = 1
if not have_security_ext() or have_virt_ext(
) or not self.scr.ns or self.scr.aw:
self.cpsr.a = 1
self.cpsr.it = 0b00000000
self.cpsr.j = 0
self.cpsr.t = self.sctlr.te
self.cpsr.e = self.sctlr.ee
self.branch_to(
bits_ops.add(self.exc_vector_base(), vect_offset, 32))
def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(self.n)
except EndOfInstruction:
pass
else:
if self.is_tbh:
halfwords = processor.mem_u_get(
add(processor.registers.get(self.n),
lsl(processor.registers.get(self.m), 32, 1), 32),
2)
else:
halfwords = processor.mem_u_get(
add(processor.registers.get(self.n),
processor.registers.get(self.m), 32), 1)
processor.branch_write_pc(
add(processor.registers.get_pc(), 2 * halfwords, 32))
def execute(self, processor):
if processor.condition_passed():
if processor.registers.current_mode_is_hyp():
raise UndefinedInstructionException()
elif processor.registers.current_mode_is_user_or_system():
print('unpredictable')
else:
length = 4 * bit_count(self.registers, 1, 16)
address = processor.registers.get(
self.n) if self.increment else sub(
processor.registers.get(self.n), length, 32)
if self.word_higher:
address = add(address, 4, 32)
for i in range(15):
if bit_at(self.registers, i):
processor.registers.set_rmode(
i, 0b10000, processor.mem_a_get(address, 4))
address = add(address, 4, 32)
def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(self.n)
except EndOfInstruction:
pass
else:
address = add(processor.registers.get(self.n), self.imm32, 32)
processor.set_exclusive_monitors(address, 4)
processor.registers.set(self.t,
processor.mem_a_get(address, 4))
def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(self.n)
except EndOfInstruction:
pass
else:
address = processor.registers.get(self.n)
for i in range(15):
if bit_at(self.registers, i):
processor.registers.set(i, processor.mem_a_get(address, 4))
address = add(address, 4, 32)
if bit_at(self.registers, 15):
processor.load_write_pc(processor.mem_a_get(address, 4))
if self.wback and not bit_at(self.registers, self.n):
processor.registers.set(
self.n, add(processor.registers.get(self.n), 4 * bit_count(self.registers, 1, 16), 32)
)
if self.wback and bit_at(self.registers, self.n):
processor.registers.set(self.n, 0x00000000) # unknown
def execute(self, processor):
if processor.condition_passed():
address = add(processor.registers.get(self.n), 4, 32)
for i in range(15):
if bit_at(self.registers, i):
if i == self.n and self.wback and i != lowest_set_bit_ref(
self.registers):
processor.mem_a_set(address, 4, 0x00000000) # unknown
else:
processor.mem_a_set(address, 4,
processor.registers.get(i))
address = add(address, 4, 32)
if bit_at(self.registers, 15):
processor.mem_a_set(address, 4,
processor.registers.pc_store_value())
if self.wback:
processor.registers.set(
self.n,
add(processor.registers.get(self.n),
4 * bit_count(self.registers, 1, 16), 32))
def execute(self, processor):
if processor.condition_passed():
if processor.registers.current_mode_is_hyp():
raise UndefinedInstructionException()
elif (processor.registers.current_mode_is_user_or_system()
or processor.registers.current_instr_set()
== InstrSet.InstrSet_ThumbEE):
print "unpredictable"
else:
length = 4 * self.registers.count(1) + 4
address = processor.registers.get(
self.n) if self.increment else sub(
processor.registers.get(self.n),
BitArray(uint=length, length=32), 32)
if self.word_higher:
address = add(address, BitArray(bin="100"), 32)
for i in xrange(15):
if self.registers[15 - i]:
processor.registers.set(
i, processor.mem_a_get(address, 4))
address = add(address, BitArray(bin="100"), 32)
new_pc_value = processor.mem_a_get(address, 4)
if self.wback and not self.registers[15 - self.n]:
processor.registers.set(
self.n, (add(processor.registers.get(self.n),
BitArray(uint=length, length=32), 32)
if self.increment else sub(
processor.registers.get(self.n),
BitArray(uint=length, length=32), 32)))
if self.wback and self.registers[15 - self.n]:
processor.registers.set(self.n,
BitArray(length=32)) # unknown
processor.registers.cpsr_write_by_instr(
processor.registers.get_spsr(), BitArray(bin="1111"), True)
if (processor.registers.cpsr.get_m() == "0b11010"
and processor.registers.cpsr.get_j()
and processor.registers.cpsr.get_t()):
print "unpredictable"
else:
processor.branch_write_pc(new_pc_value)
def execute(self, processor):
registers_count = bit_count(self.registers, 1, 16)
if processor.condition_passed():
address = sub(processor.registers.get(self.n), 4 * registers_count,
32) + 4
for i in range(15):
if bit_at(self.registers, i):
processor.registers.set(i, processor.mem_a_get(address, 4))
address = add(address, 4, 32)
if bit_at(self.registers, 15):
processor.load_write_pc(processor.mem_a_get(address, 4))
if self.wback and not bit_at(self.registers, self.n):
processor.registers.set(
self.n,
sub(processor.registers.get(self.n), 4 * registers_count,
32))
if self.wback and bit_at(self.registers, self.n):
processor.registers.set(self.n, 0x00000000) # unknown
def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(self.n)
except EndOfInstruction:
pass
else:
offset = shift(processor.registers.get(self.m), self.shift_t, self.shift_n,
processor.registers.cpsr.get_c())
offset_addr = add(processor.registers.get(self.n), offset, 32)
address = offset_addr
data = processor.mem_u_get(address, 4)
if self.t == 15:
if address[30:32] == "0b00":
processor.load_write_pc(address)
else:
print "unpredictable"
elif processor.unaligned_support() or address[30:32] == "0b00":
processor.registers.set(self.t, data)
else:
processor.registers.set(self.t, BitArray(length=32)) # unknown
def execute(self, processor):
if processor.condition_passed():
address = sub(
processor.registers.get(self.n),
BitArray(uint=(4 * self.registers.count(1) - 4), length=32),
32)
for i in xrange(15):
if self.registers[15 - i]:
processor.registers.set(i, processor.mem_a_get(address, 4))
address = add(address, BitArray(bin="100"), 32)
if self.registers[0]:
processor.load_write_pc(processor.mem_a_get(address, 4))
if self.wback and not self.registers[15 - self.n]:
processor.registers.set(
self.n,
sub(
processor.registers.get(self.n),
BitArray(uint=(4 * self.registers.count(1)),
length=32), 32))
if self.wback and self.registers[15 - self.n]:
processor.registers.set(self.n, BitArray(length=32)) # unknown
def take_physical_fiq_exception(self):
new_lr_value = self.get_pc() if self.cpsr.t else bits_ops.sub(
self.get_pc(), 4, 32)
new_spsr_value = self.cpsr.value
vect_offset = 28
route_to_monitor = have_security_ext() and self.scr.fiq
route_to_hyp = ((have_virt_ext() and have_security_ext()
and not self.scr.fiq and self.hcr.fmo
and not self.is_secure()) or self.cpsr.m == 0b11010)
if route_to_monitor:
if self.cpsr.m == 0b10110:
self.scr.ns = 0
self.enter_monitor_mode(new_spsr_value, new_lr_value, vect_offset)
elif route_to_hyp:
self.hsr.value = 0x00000000 # unknown
preferred_exceptn_return = bits_ops.sub(new_lr_value, 4, 32)
self.enter_hyp_mode(new_spsr_value, preferred_exceptn_return,
vect_offset)
else:
if self.cpsr.m == 0b10110:
self.scr.ns = 0
self.cpsr.m = 0b10001
self.set_spsr(new_spsr_value)
self.set(14, new_lr_value)
self.cpsr.i = 1
if not have_security_ext() or have_virt_ext(
) or not self.scr.ns or self.scr.fw:
self.cpsr.f = 1
if not have_security_ext() or have_virt_ext(
) or not self.scr.ns or self.scr.aw:
self.cpsr.a = 1
self.cpsr.it = 0b00000000
self.cpsr.j = 0
self.cpsr.t = self.sctlr.te
self.cpsr.e = self.sctlr.ee
if self.sctlr.ve:
self.branch_to(configurations.impdef_fiq_vector)
else:
self.branch_to(
bits_ops.add(self.exc_vector_base(), vect_offset, 32))
def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(self.n)
except EndOfInstruction:
pass
else:
offset = shift(processor.registers.get(self.m), 32,
self.shift_t, self.shift_n,
processor.registers.cpsr.c)
address = add(processor.registers.get(self.n), offset, 32)
data = processor.mem_u_get(address, 4)
if self.t == 15:
if lower_chunk(address, 2) == 0b00:
processor.load_write_pc(address)
else:
print('unpredictable')
elif processor.unaligned_support() or lower_chunk(address,
2) == 0b00:
processor.registers.set(self.t, data)
else:
processor.registers.set(self.t, 0x00000000) # unknown
def execute(self, processor):
if processor.condition_passed():
try:
processor.null_check_if_thumbee(13)
except EndOfInstruction:
pass
else:
address = sub(
processor.registers.get_sp(),
BitArray(uint=(4 * self.registers.count(1)), length=32),
32)
for i in xrange(15):
if self.registers[15 - i]:
if i == 13 and i != lowest_set_bit_ref(self.registers):
processor.mem_a_set(address, 4,
BitArray(length=32)) # unknown
else:
if self.unaligned_allowed:
processor.mem_u_set(address, 4,
processor.registers.get(i))
else:
processor.mem_a_set(address, 4,
processor.registers.get(i))
address = add(address, BitArray(bin="100"), 32)
if self.registers[0]:
if self.unaligned_allowed:
processor.mem_u_set(
address, 4, processor.registers.pc_store_value())
else:
processor.mem_a_set(
address, 4, processor.registers.pc_store_value())
processor.registers.set_sp(
sub(
processor.registers.get_sp(),
BitArray(uint=(4 * self.registers.count(1)),
length=32), 32))
def execute(self, processor):
if self.nonzero != processor.registers.get(self.n).all(0):
processor.branch_write_pc(
add(processor.registers.get_pc(), self.imm32, 32))
def execute(self, processor):
if processor.condition_passed():
processor.branch_write_pc(add(processor.registers.get_pc(), self.imm32, 32))
