def loader_segload_test(binbuild):
lib_file = binbuild.make_lib('simple')
mem = MockMemory(fill=23)
alloc = MemoryAlloc(mem)
loader = SegmentLoader(mem, alloc)
seg_list = loader.load_seg(lib_file)
assert seg_list is not None
def atypes_list_alloc_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
l = List.alloc(alloc)
assert type(l) is List
assert l.get_size() == ListStruct.get_size()
l.free()
def libcore_patch_multi_trap_test(capsys):
name = 'vamostest.library'
impl = VamosTestLibrary()
fd = read_lib_fd(name)
machine = MockMachine()
ctx = LibCtx(machine)
# create stub
gen = LibStubGen()
stub = gen.gen_stub(name, impl, fd, ctx)
# now patcher
alloc = MemoryAlloc(ctx.mem)
traps = machine.get_traps()
p = LibPatcherMultiTrap(alloc, traps, stub)
base_addr = 0x100
p.patch_jump_table(base_addr)
# lookup trap for function
func = fd.get_func_by_name('PrintHello')
bias = func.get_bias()
func_addr = base_addr - bias
# check that jump table has jump + addr
op = ctx.mem.r16(func_addr)
assert op == op_jmp
trap_addr = ctx.mem.r32(func_addr + 2)
# check jump target is trap
op = ctx.mem.r16(trap_addr)
assert op & 0xf000 == 0xa000
# trigger trap
traps.trigger(op)
captured = capsys.readouterr()
assert captured.out.strip().split('\n') == ['VamosTest: PrintHello()']
# remove traps
p.cleanup()
assert traps.get_num_traps() == 0
assert alloc.is_all_free()
def libtypes_node_alloc_min_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
node = MinNode.alloc(alloc)
assert node.get_size() == MinNodeStruct.get_size()
node.free()
assert alloc.is_all_free()
def atypes_atype_base_test():
# simple type without extra contents
# wrap field 'pad' with getter/setter
@AmigaTypeDef(MyStruct, wrap={'pad': (Bla.getf, Bla.setf)})
class MyType(AmigaType):
pass
# create a type instance
mem = MockMemory()
alloc = MemoryAlloc(mem, addr=0x100)
mt = MyType(mem, 0x10)
# regular values (signed/unsigend)
mt.set_word(-3)
assert mt.get_word() == -3
# wrapped type
assert type(mt.get_pad()) is Bla
mt.set_pad(Bla(3))
assert mt.get_pad() == Bla(3)
assert mt.get_pad(raw=True) == 3
mt.set_pad(21, raw=True)
assert mt.get_pad() == Bla(21)
# cstring
assert type(mt.get_string()) is CString
txt = "hello, word!"
cstr = CString.alloc(alloc, txt)
cstr_addr = cstr.get_addr()
mt.set_string(cstr)
assert mt.get_string() == txt
assert mt.get_string() == CString(mem, cstr_addr)
assert mt.get_string(ptr=True) == cstr_addr
cstr.free()
def libtypes_process_bptr_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
# alloc proc
proc = Process.alloc(alloc)
# set list (as baddr)
proc.seg_list.bptr = 0x40
assert proc.seg_list.bptr == 0x40
# check in mem seg list baddr
off = proc.sdef.pr_SegList.offset
addr = proc.addr + off
assert mem.r32(addr) == 0x40
# setup CLI
cli = CLI.alloc(alloc)
proc.cli.ref = cli
assert type(proc.cli.ref) is CLI
assert proc.cli.aptr == cli.addr
# check in mem CLI baddr
off = proc.sdef.pr_CLI.offset
addr = proc.addr + off
assert mem.r32(addr) == cli.addr >> 2
cli.free()
# done
proc.free()
assert alloc.is_all_free()
def libtypes_resident_setup_test():
mem = MockMemory(fill=23)
alloc = MemoryAlloc(mem)
# alloc
res2 = Resident.alloc(alloc, name="bla.library", id_string="blub")
res2.new_resident(
flags=ResidentFlags.RTF_AUTOINIT,
version=42,
type=NodeType.NT_DEVICE,
pri=-7,
init=0xDEADBEEF,
)
# find resource
res = Resident.find(mem, 0, 1024)
assert res.match_word.val == res.RTC_MATCHWORD
assert res.match_tag.aptr == res.get_addr()
assert res.end_skip.aptr >= res.get_addr() + res.get_size()
assert res.flags.val == ResidentFlags.RTF_AUTOINIT
assert res.version.val == 42
assert res.type.val == NodeType.NT_DEVICE
assert res.pri.val == -7
assert res.name.str == "bla.library"
assert res.id_string.str == "blub"
assert res.init.aptr == 0xDEADBEEF
# free
res2.free()
assert alloc.is_all_free()
def mem_alloc_base_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
assert alloc.is_all_free()
addr = alloc.alloc_mem(1024)
alloc.free_mem(addr, 1024)
assert alloc.is_all_free()
def atypes_resident_setup_test():
mem = MockMemory(fill=23)
alloc = MemoryAlloc(mem)
# alloc
res2 = Resident.alloc(alloc, "bla.library", "blub")
res2.setup(
flags=ResidentFlags.RTF_AUTOINIT,
version=42,
type=NodeType.NT_DEVICE,
pri=-7,
init=0xDEADBEEF,
)
# find resource
res = Resident.find(mem, 0, 1024)
assert res.get_match_word() == res.RTC_MATCHWORD
assert res.get_match_tag() == res.get_addr()
assert res.get_end_skip() >= res.get_addr() + res.get_type_size()
assert res.get_flags() == ResidentFlags.RTF_AUTOINIT
assert res.get_version() == 42
assert res.get_type() == NodeType.NT_DEVICE
assert res.get_pri() == -7
assert res.get_name() == "bla.library"
assert res.get_id_string() == "blub"
assert res.get_init() == 0xDEADBEEF
# free
res2.free()
assert alloc.is_all_free()
def atypes_process_bptr_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
# alloc proc
proc = Process.alloc(alloc)
# set list
proc.seg_list = 0x100
assert proc.seg_list == BAddr(0x40)
# check in mem seg list baddr
struct = proc.get_type_struct()
off = struct.pr_SegList_field.offset
addr = proc.addr + off
assert mem.r32(addr) == 0x40
# setup CLI
cli = CLI.alloc(alloc)
proc.cli = cli
assert type(proc.cli) is CLI
assert proc.cli == cli.addr
# check in mem CLI baddr
off = struct.pr_CLI_field.offset
addr = proc.addr + off
assert mem.r32(addr) == BAddr.from_addr(cli.addr).get_baddr()
cli.free()
# done
proc.free()
assert alloc.is_all_free()
def setup():
mem = MockMemory(fill=23)
traps = MockTraps()
cpu = MockCPU()
alloc = MemoryAlloc(mem)
ctx = LibCtx(cpu, mem)
return mem, traps, alloc, ctx
def astructs_astruct_class_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
pc = PlainClass.alloc(alloc)
assert type(pc) == PlainClass
assert pc.foo() == ""
# alloc a name
pc.name.alloc_str(alloc, "hello")
assert pc.foo() == "hello"
# another struct
pc2 = PlainClass.alloc(alloc, name="world!")
assert type(pc2) == PlainClass
assert pc2.name.str == "world!"
assert pc2.foo() == "world!"
pc.next.ref = pc2
assert pc.foo() == "hello world!"
# more struct
pc3 = PlainClass.alloc(alloc, name="what:", bname="ugh!", next=pc2)
assert pc3.foo() == "what: world!"
assert pc3.next.ref is pc2
assert pc3.name.str == "what:"
assert pc3.bname.str == "ugh!"
pc3.free()
pc2.free()
# clean up pc
pc.name.free_str()
pc.free()
assert alloc.is_all_free()
def setup_ram_allocator(self):
mem = self.machine.get_mem()
mem_begin = 0x1000
mem_size = self.ram_total - mem_begin
log_mem_map.info("setup ram allocator: @%06x +%06x", mem_begin,
mem_size)
self.alloc = MemoryAlloc(mem, mem_begin, mem_size, self.label_mgr)
def setup():
machine = MockMachine(fill=23)
mem = machine.get_mem()
traps = machine.get_traps()
cpu = machine.get_cpu()
alloc = MemoryAlloc(mem)
ctx = LibCtx(machine)
return mem, traps, alloc, ctx
def atypes_list_alloc_min_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
l = MinList.alloc(alloc)
assert type(l) is MinList
assert l.get_size() == MinListStruct.get_size()
l.free()
assert alloc.is_all_free()
def atypes_resident_alloc_test():
mem = MockMemory(fill=23)
alloc = MemoryAlloc(mem)
# alloc
res = Resident.alloc(alloc, "bla.library", "blub")
# free
res.free()
assert alloc.is_all_free()
def __init__(self, mem, alloc, label_mgr, name, size):
self.alloc = alloc
self.chunks = None
self.label_mgr = label_mgr
self.mem = mem
self.size = size
self.mem_obj = self.alloc.alloc_memory(size, label=name)
self.chunks = MemoryAlloc(self.mem, self.mem_obj.addr, size, label_mgr)
def atypes_execlib_alloc_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
el = ExecLibrary.alloc(alloc, "exec.library", "bla", 20)
el.setup()
el.fill_funcs()
el.free()
assert alloc.is_all_free()
def libtypes_node_alloc_name_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
node = Node.alloc(alloc, name="foobar")
assert node.get_size() == NodeStruct.get_size()
assert node.name.str == "foobar"
node.free()
assert alloc.is_all_free()
def atypes_cstring_max_size_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
cs = CString.alloc(alloc, "bla")
assert cs.get_max_size() == 3
cs.set_string("foo")
assert cs == "foo"
with pytest.raises(ValueError):
cs.set_string("foo!")
def astructs_astruct_alloc_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
res = MyStruct.alloc(alloc, ms_Word=21, ms_Pad=42)
assert type(res) is MyStruct
assert res.ms_Word.val == 21
assert res.ms_Pad.val == 42
res.free()
assert alloc.is_all_free()
def astructs_astruct_class_subfield_alias_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
spc = SubPlainClass.alloc(alloc, name="abc", plain2={"name": "cde"})
assert type(spc) == SubPlainClass
assert spc.plain.name.str == "abc"
assert spc.plain2.name.str == "cde"
spc.free()
assert alloc.is_all_free()
def astructs_astruct_alloc_sub_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
res = SubStruct.alloc(alloc, ss_My={"ms_Word": 21, "ms_Pad": 42})
assert type(res) is SubStruct
assert res.ss_My.ms_Word.val == 21
assert res.ss_My.ms_Pad.val == 42
res.free()
assert alloc.is_all_free()
def atypes_cstring_null_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
# no string
cs = CString.alloc(alloc, None)
assert cs
assert cs.get_addr() == 0
assert cs.get_string() is None
with pytest.raises(RuntimeError):
cs.free()
def load_lib(mem, binbuild):
lib_file = binbuild.make_lib('simple')
alloc = MemoryAlloc(mem)
loader = SegmentLoader(mem, alloc)
seg_list = loader.load_seg(lib_file)
seg0 = seg_list.get_segment(0)
addr = seg0.get_addr()
size = seg0.get_size()
end = seg0.get_end()
return addr, size, end
def atypes_cstring_null_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
# no string
cs = CString.alloc(alloc, None)
assert cs
assert cs.get_addr() == 0
assert cs.get_string() is None
cs.free()
assert alloc.is_all_free()
def atypes_bstring_null_test():
mem = MockMemory()
alloc = MemoryAlloc(mem)
# no string
bs = BString.alloc(alloc, None)
assert bs
assert bs.get_baddr() << 2 == bs.get_addr()
assert bs.get_addr() == 0
assert bs.get_string() is None
bs.free()
assert alloc.is_all_free()
def load_lib(mem, buildlibnix):
lib_file = buildlibnix.make_lib("testnix")
alloc = MemoryAlloc(mem)
loader = SegmentLoader(alloc)
info = loader.int_load_sys_seglist(lib_file)
seg_list = info.seglist
seg = seg_list.get_segment()
addr = seg.get_addr()
size = seg.get_size()
end = seg.get_end()
return addr, size, end
def mem_alloc(request):
from amitools.vamos.machine import Machine, MockMemory
from amitools.vamos.mem import MemoryAlloc
from amitools.vamos.label import LabelManager
n = request.param
if n == 'mach':
m = Machine(use_labels=False)
mem = m.get_mem()
return mem, MemoryAlloc(mem)
elif n == 'mach-label':
m = Machine()
mem = m.get_mem()
return mem, MemoryAlloc(mem, label_mgr=m.get_label_mgr())
elif n == 'mock':
mem = MockMemory(fill=23)
return mem, MemoryAlloc(mem)
else:
mem = MockMemory(fill=23)
lm = LabelManager()
return mem, MemoryAlloc(mem, label_mgr=lm)
def setup(profiler_cfg=None):
machine = Machine()
alloc = MemoryAlloc(machine.get_mem(), machine.get_ram_begin())
mgr = VLibManager(machine, alloc, profiler_cfg=profiler_cfg)
# setup ctx map
cpu = machine.get_cpu()
mem = machine.get_mem()
cpu_type = machine.get_cpu_type()
segloader = SegmentLoader(alloc)
exec_ctx = ExecLibCtx(machine, alloc, segloader, None)
mgr.add_ctx('exec.library', exec_ctx)
return machine, alloc, mgr