def test_assemble_compression_alignment():
source = r"""
foo:
addi x0 x0 0
align 4
bar:
"""
labels = {}
asm.assemble(source, labels=labels, compress=True)
assert labels['bar'] == 4
def test_assembler_bytes():
source = """
bytes 1 2 0x03 0b100 5 0x06 0b111 8
"""
binary = asm.assemble(source)
target = b'\x01\x02\x03\x04\x05\x06\x07\x08'
assert binary == target
def test_assembler_modifiers():
source = """
ADDR = 0x20000000
addi zero zero 0
addi zero zero 0
addi zero zero 0
main:
# without nestable exprs under hi / lo
lui t0 %hi ADDR
addi t0 t0 %lo(ADDR)
addi t0 t0 main
# with nestable exprs under hi / lo
lui t0 %hi %position main ADDR
addi t0 t0 %lo(%position(main, ADDR))
"""
binary = asm.assemble(source)
target = b''.join([
asm.ADDI(0, 0, 0),
asm.ADDI(0, 0, 0),
asm.ADDI(0, 0, 0),
asm.LUI('t0', asm.relocate_hi(0x20000000)),
asm.ADDI('t0', 't0', asm.relocate_lo(0x20000000)),
asm.ADDI('t0', 't0', 12),
asm.LUI('t0', asm.relocate_hi(0x20000000 + 12)),
asm.ADDI('t0', 't0', asm.relocate_lo(0x20000000 + 12)),
])
assert binary == target
def test_assemble_lui_signedness():
source = r"""
lui a4,0xfffff
"""
binary = asm.assemble(source)
target = b''.join(
struct.pack('<I', inst) for inst in [
asm.LUI('a4', -1),
])
assert binary == target
def test_assemble_hex_register():
source = r"""
slli a4,a4,0xa
"""
binary = asm.assemble(source)
target = b''.join(
struct.pack('<I', inst) for inst in [
asm.SLLI('a4', 'a4', 10),
])
assert binary == target
def test_assembler_string():
source = """
string hello
string world
string hello world
string hello world
"""
binary = asm.assemble(source)
target = b'helloworldhello worldhello world'
assert binary == target
def test_assemble_string():
source = r"""
string hello
string "world"
string "hello world"
string hello ## world
string hello\nworld
string hello\\nworld
"""
binary = asm.assemble(source)
target = b'hello"world""hello world"hello ## worldhello\nworld hello\\nworld'
assert binary == target
def test_assemble_align():
source = r"""
addi zero zero 0
pack <B 42
align 4
addi zero zero 0
"""
binary = asm.assemble(source)
target = b''.join([
struct.pack('<I', asm.ADDI(0, 0, 0)),
b'\x2a\x00\x00\x00',
struct.pack('<I', asm.ADDI(0, 0, 0)),
])
assert binary == target
def test_assembler_basic_uppercase():
source = """
ADDI t0 zero 1
ADDI t1, zero, 2
ADDI(t2, zero, 3)
"""
binary = asm.assemble(source)
target = b''.join([
# can use nums OR names for registers
asm.ADDI(5, 0, 1),
asm.ADDI('t1', 'zero', 2),
asm.ADDI('t2', 'zero', 3),
])
assert binary == target
def test_assembler_align():
source = """
addi zero zero 0
pack <B 42
align 4
addi zero zero 0
"""
binary = asm.assemble(source)
target = b''.join([
asm.ADDI(0, 0, 0),
b'\x2a\x00\x00\x00',
asm.ADDI(0, 0, 0),
])
assert binary == target
def test_assemble_pack():
source = r"""
ADDR = 0x20000000
pack <B 0
pack <B 255
pack <I ADDR
"""
binary = asm.assemble(source)
target = b''.join([
struct.pack('<B', 0),
struct.pack('<B', 255),
struct.pack('<I', 0x20000000),
])
assert binary == target
def test_assembler_constants():
source = """
FOO = 42
BAR = FOO * 2
BAZ = BAR >> 1 & 0b11111
W = 's0'
IP = gp
addi zero zero BAR
addi W IP BAZ
"""
binary = asm.assemble(source)
target = b''.join([
asm.ADDI(0, 0, 84),
asm.ADDI('s0', 'gp', 10),
])
assert binary == target
def test_assemble_alternate_offset_syntax_compressed():
source = r"""
c.lw x8, x9, 0
c.lw x8, 0(x9)
c.sw x8, x9, 0
c.sw x9, 0(x8)
"""
binary = asm.assemble(source)
target = b''.join(
struct.pack('<H', inst) for inst in [
asm.C_LW('x8', 'x9', 0),
asm.C_LW('x8', 'x9', 0),
asm.C_SW('x8', 'x9', 0),
asm.C_SW('x8', 'x9', 0),
])
assert binary == target
def test_assemble_alternate_offset_syntax():
source = r"""
jalr x0, x1, 0
jalr x0, 0(x1)
lw x0, x1, 0
lw x0, 0(x1)
sb x0, x1, 0
sb x1, 0(x0)
"""
binary = asm.assemble(source)
target = b''.join(
struct.pack('<I', inst) for inst in [
asm.JALR('x0', 'x1', 0),
asm.JALR('x0', 'x1', 0),
asm.LW('x0', 'x1', 0),
asm.LW('x0', 'x1', 0),
asm.SB('x0', 'x1', 0),
asm.SB('x0', 'x1', 0),
])
assert binary == target
def test_assemble_aq_rl():
source = r"""
lr.w zero zero
sc.w zero zero zero 0 0
sc.w zero zero zero 1 0
sc.w zero zero zero 0 1
sc.w zero zero zero 1 1
amomaxu.w t0 t1 t2
"""
binary = asm.assemble(source)
target = b''.join(
struct.pack('<I', inst) for inst in [
asm.LR_W(0, 0),
asm.SC_W(0, 0, 0, aq=0, rl=0),
asm.SC_W(0, 0, 0, aq=1, rl=0),
asm.SC_W(0, 0, 0, aq=0, rl=1),
asm.SC_W(0, 0, 0, aq=1, rl=1),
asm.AMOMAXU_W('t0', 't1', 't2'),
])
assert binary == target
def test_assemble_constants():
source = r"""
FOO = 42
BAR = FOO * 2
BAZ = BAR >> 1 & 0b11111
W = s0
IP = gp
addi zero zero BAR
addi W IP BAZ
QMARK = '?'
addi x0 x0 QMARK
"""
binary = asm.assemble(source)
target = b''.join(
struct.pack('<I', inst) for inst in [
asm.ADDI(0, 0, 84),
asm.ADDI('s0', 'gp', 10),
asm.ADDI(0, 0, ord('?')), # ord('?') == 63
])
assert binary == target
def test_assembler_labels_and_jumps():
source = """
start:
addi t0 zero 42
jal zero end
middle:
beq t0 zero main
addi t0 t0 -1
end:
jal zero %offset middle
main:
addi zero zero 0
"""
binary = asm.assemble(source)
target = b''.join([
asm.ADDI('t0', 'zero', 42),
asm.JAL('zero', 12),
asm.BEQ('t0', 'zero', 12),
asm.ADDI('t0', 't0', -1),
asm.JAL('zero', -8),
asm.ADDI(0, 0, 0),
])
assert binary == target
def test_assemble_labels_and_jumps():
source = r"""
start:
addi t0 zero 42
jal zero end
middle:
beq t0 zero main
addi t0 t0 -1
end:
jal zero middle
main:
addi zero zero 0
"""
binary = asm.assemble(source)
target = b''.join(
struct.pack('<I', inst) for inst in [
asm.ADDI('t0', 'zero', 42),
asm.JAL('zero', 12),
asm.BEQ('t0', 'zero', 12),
asm.ADDI('t0', 't0', -1),
asm.JAL('zero', -8),
asm.ADDI(0, 0, 0),
])
assert binary == target
def test_assemble_sequence(source, expected):
binary = asm.assemble(source)
assert binary == expected
def test_assemble_pseudo_instructions(pseudo, transformed):
labels = {'test': 0, 'near': 0, 'far': 0x20000000}
pseudo_bin = asm.assemble(pseudo, labels=labels)
transformed_bin = asm.assemble(transformed, labels=labels)
assert pseudo_bin == transformed_bin
def test_assemble_compress(regular, compressed):
labels = {'test': 0, 'near': 0, 'far': 0x20000000}
regular_bin = asm.assemble(regular, labels=labels, compress=True)
compressed_bin = asm.assemble(compressed, labels=labels)
assert regular_bin == compressed_bin
def test_assemble_shorthand_packs(shorthand, transformed):
shorthand_bin = asm.assemble(shorthand)
transformed_bin = asm.assemble(transformed)
assert shorthand_bin == transformed_bin
def test_constraints(source):
with pytest.raises(asm.AssemblerError):
asm.assemble(source)
def test_assemble_ext_c(source, expected):
binary = asm.assemble(source)
target = struct.pack('<H', expected)
assert binary == target
