def test_load_undef(ctx, func, bld):
zero = ctx.reg_a.type.create(0)
bld.build_rload(ctx.reg_a)
bld.build_rstore(ctx.reg_a, zero)
bld.build_ret()
regs = {}
interpreter.run(func, regs)
assert regs == {ctx.reg_a: LiveValue.from_value(zero)}
def test_store_undef(ctx, func, bld):
undef_value = bld.build_rload(ctx.reg_a)
bld.build_rstore(ctx.reg_b, undef_value)
bld.build_ret()
regs = {}
interpreter.run(func, regs)
print(regs)
assert regs == {ctx.reg_b: LiveValue(ctx.reg_a.type)}
def run_before_and_after_optimization(func, optimization, regs, expected_regs):
for run_opt in (False, True):
if run_opt:
optimization.process_function(func)
import decompil.utils
print(decompil.utils.format_to_str(func))
regs_copy = dict(regs)
interpreter.run(func, regs_copy)
for reg, value in expected_regs.items():
assert regs_copy[reg] == value
def run_before_and_after_optimization(func, optimization, regs, expected_regs):
for run_opt in (False, True):
if run_opt:
optimization.process_function(func)
import decompil.utils
print(decompil.utils.format_to_str(func))
regs_copy = dict(regs)
interpreter.run(func, regs_copy)
for reg, value in expected_regs.items():
assert regs_copy[reg] == value
def test_use_undef(ctx, func, bld):
undef_value = bld.build_rload(ctx.reg_a)
error_value = bld.build_add(undef_value, undef_value)
bld.build_rstore(ctx.reg_b, error_value)
bld.build_ret()
try:
interpreter.run(func, {})
except AssertionError:
pass
else:
assert False
def test_basic(ctx, func, bld):
"""Test that ALLOCA + STORE + LOAD in a raw works properly."""
var_addr = bld.build_alloca(ctx.reg_a.type)
bld.build_store(var_addr, ctx.reg_a.type.create(0))
bld.build_rstore(ctx.reg_b, bld.build_load(var_addr))
bld.build_ret()
regs = {ctx.reg_a: LiveValue(ctx.reg_a.type, 0)}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 0),
ctx.reg_b: LiveValue(ctx.reg_a.type, 0),
}
def test_same_alloca_twice(ctx, func, bld):
"""
Test that one ALLOCA executed multiple times yields different pointers.
"""
bb_loop_start = bld.create_basic_block()
bb_loop_store_1 = bld.create_basic_block()
bb_loop_store_2 = bld.create_basic_block()
bb_loop_end = bld.create_basic_block()
bb_end = bld.create_basic_block()
i_reg = ctx.reg_a
reg_1 = ctx.reg_b
reg_2 = ctx.reg_c
bld.build_rstore(i_reg, i_reg.type.create(2))
bld.build_jump(bb_loop_start)
bld.position_at_end(bb_loop_start)
var_addr = bld.build_alloca(ctx.double_type)
var_int = bld.build_bitcast(reg_1.type, var_addr)
bld.build_rstore(
i_reg, bld.build_sub(bld.build_rload(i_reg), i_reg.type.create(1)))
bld.build_branch(
bld.build_eq(bld.build_rload(i_reg), i_reg.type.create(0)),
bb_loop_store_1, bb_loop_store_2)
bld.position_at_end(bb_loop_store_1)
bld.build_rstore(reg_1, var_int)
bld.build_jump(bb_loop_end)
bld.position_at_end(bb_loop_store_2)
bld.build_rstore(reg_2, var_int)
bld.build_jump(bb_loop_end)
bld.position_at_end(bb_loop_end)
bld.build_branch(
bld.build_ugt(bld.build_rload(i_reg), i_reg.type.create(0)),
bb_loop_start, bb_end)
bld.position_at_end(bb_end)
bld.build_ret()
regs = {}
interpreter.run(func, regs)
assert set(regs) == {ctx.reg_a, ctx.reg_b, ctx.reg_c}
assert regs[ctx.reg_a] == LiveValue(ctx.reg_a.type, 0)
assert regs[ctx.reg_b] != regs[ctx.reg_c]
def test_asymetric_phi(ctx, func):
zero = LiveValue(ctx.reg_a.type, 0)
one = LiveValue(ctx.reg_a.type, 1)
two = LiveValue(ctx.reg_a.type, 2)
regs = {ctx.reg_a: zero, ctx.reg_b: one}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: zero,
ctx.reg_b: one,
ctx.reg_c: one,
}
regs = {ctx.reg_a: two, ctx.reg_b: one}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: two,
ctx.reg_b: one,
ctx.reg_c: two,
}
def test_asymetric_phi(ctx, func):
zero = LiveValue(ctx.reg_a.type, 0)
one = LiveValue(ctx.reg_a.type, 1)
two = LiveValue(ctx.reg_a.type, 2)
regs = {ctx.reg_a: zero, ctx.reg_b: one}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: zero,
ctx.reg_b: one,
ctx.reg_c: one,
}
regs = {ctx.reg_a: two, ctx.reg_b: one}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: two,
ctx.reg_b: one,
ctx.reg_c: two,
}
def test_simple_phi(ctx, func):
base_regs = {
ctx.reg_b: LiveValue(ctx.reg_b.type, 1),
ctx.reg_c: LiveValue(ctx.reg_c.type, 2),
}
regs = dict(base_regs)
regs[ctx.reg_a] = LiveValue(ctx.reg_b.type, 1)
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 1),
ctx.reg_b: base_regs[ctx.reg_b],
ctx.reg_c: base_regs[ctx.reg_c],
ctx.reg_d: base_regs[ctx.reg_b],
}
regs = dict(base_regs)
regs[ctx.reg_a] = LiveValue(ctx.reg_b.type, 0)
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 0),
ctx.reg_b: base_regs[ctx.reg_b],
ctx.reg_c: base_regs[ctx.reg_c],
ctx.reg_d: base_regs[ctx.reg_c],
}
def test_simple_phi(ctx, func):
base_regs = {
ctx.reg_b: LiveValue(ctx.reg_b.type, 1),
ctx.reg_c: LiveValue(ctx.reg_c.type, 2),
}
regs = dict(base_regs)
regs[ctx.reg_a] = LiveValue(ctx.reg_b.type, 1)
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 1),
ctx.reg_b: base_regs[ctx.reg_b],
ctx.reg_c: base_regs[ctx.reg_c],
ctx.reg_d: base_regs[ctx.reg_b],
}
regs = dict(base_regs)
regs[ctx.reg_a] = LiveValue(ctx.reg_b.type, 0)
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 0),
ctx.reg_b: base_regs[ctx.reg_b],
ctx.reg_c: base_regs[ctx.reg_c],
ctx.reg_d: base_regs[ctx.reg_c],
}
def test_simple_loop(ctx, func):
regs = {ctx.reg_a: LiveValue(ctx.reg_a.type, 0)}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 0),
ctx.reg_b: LiveValue(ctx.reg_b.type, 1),
}
regs = {ctx.reg_a: LiveValue(ctx.reg_a.type, 1)}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 1),
ctx.reg_b: LiveValue(ctx.reg_b.type, 2),
}
regs = {ctx.reg_a: LiveValue(ctx.reg_a.type, 2)}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 2),
ctx.reg_b: LiveValue(ctx.reg_b.type, 4),
}
def test_simple_loop(ctx, func):
regs = {ctx.reg_a: LiveValue(ctx.reg_a.type, 0)}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 0),
ctx.reg_b: LiveValue(ctx.reg_b.type, 1),
}
regs = {ctx.reg_a: LiveValue(ctx.reg_a.type, 1)}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 1),
ctx.reg_b: LiveValue(ctx.reg_b.type, 2),
}
regs = {ctx.reg_a: LiveValue(ctx.reg_a.type, 2)}
interpreter.run(func, regs)
assert regs == {
ctx.reg_a: LiveValue(ctx.reg_a.type, 2),
ctx.reg_b: LiveValue(ctx.reg_b.type, 4),
}
def test_simple_rstore(ctx, func, i):
regs = {}
interpreter.run(func, regs)
assert regs == {ctx.reg_a: LiveValue(ctx.reg_a.type, i)}
def test_simple_rstore(ctx, func, i):
regs = {}
interpreter.run(func, regs)
assert regs == {ctx.reg_a: LiveValue(ctx.reg_a.type, i)}
def test_empty(ctx, func):
regs = {}
assert interpreter.run(func, regs) is None
assert not regs
def test_empty(ctx, func):
regs = {}
assert interpreter.run(func, regs) is None
assert not regs
