Rust character drawing

2025-11-14 09:58:58 +01:00
parent d8596b2247 f5d8c77d06
commit ca03b29774
9 changed files with 334 additions and 108 deletions
--- a/4
+++ b/4
@@ -50,7 +50,7 @@ OBJCOPY := $(PREFIX)objcopy
 OBTOMEM := common/objtomem.awk

 ## Flags
-ASFLAGS       :=-march=rv64im -mabi=lp64 -ffreestanding -nostdlib -T $(BENCH_DIR)/link.ld 
+ASFLAGS       :=-march=rv64i -mabi=lp64 -ffreestanding -nostdlib -T $(BENCH_DIR)/link.ld 
 CFLAGS        :=$(ASFLAGS)
 ELFFLAGS      :=$(ASFLAGS) $(MEM_DIR)/crt.o -Os -fno-unroll-loops 
 ODFLAGS       :=-j .text -j .rodata -j .data -s 
@@ -70,7 +70,7 @@ $(MEM_DIR):
 	@mkdir -p $@/programs
 	@mkdir -p $@/programs_rust

-$(MEM_DIR)/programs_rust/%.elf: bench/programs_rust/% force |$(MEM_DIR)
+$(MEM_DIR)/programs_rust/%.elf: bench/programs_rust/% force $(MEM_DIR)/crt.o |$(MEM_DIR)
 	cd bench/programs_rust && cargo build --release --bin=$(basename $(notdir $@))
 	cp -f bench/programs_rust/target/riscv64i/release/$(basename $(notdir $@)) $@
 $(MEM_DIR)/crt.o: $(BENCH_DIR)/crt.S |$(MEM_DIR)
--- a/bench/tests/op/beq.s
+++ b/bench/tests/op/beq.s
@@ -1,15 +1,54 @@
-# expected: 000001BC, 000002BC
+# expected: 000001BC, 000002BC, 000003BC, 00000AC, 00000AC
    .text
 _start:
+    li x5, 0x0
+    # case1: not equal -> should not jump -> write 0x1BC
    add x1, x0, 0x00A
    add x2, x0, 0x00B
-    beq x1, x2, finish # Should not jump
+    beq x1, x2, case1_skip
    add x31, x0, 0x1BC
+case1_skip:

+    # case2: equal -> should jump -> write 0x2BC
    add x1, x0, 0x1BC
    add x2, x0, 0x1BC
-    beq x1, x2, finish # Should jump to finish 
+    beq x1, x2, case2_target
    add x31, x0, 0x3BC
-
-finish: 
+case2_target:
    add x31, x0, 0x2BC
+
+back_label:
+    bne x5, x0, back_label_flagged
+    add x1, x0, 0x000
+    add x2, x0, 0x001
+    add x31, x0, 0x3BC
+    jal x0, back_label_cont
+back_label_flagged:
+    add x31, x0, 0x0BC
+    add x5, x0, 0x0
+    jal x0, after_backward
+back_label_cont:
+
+    # case3: zero equality -> should jump -> write 0x4BC
+    add x1, x0, 0x000
+    add x2, x0, 0x000
+    beq x1, x2, case3_target
+    add x31, x0, 0x5BC
+case3_target:
+
+    # set flag and branch backwards to test negative offset
+    add x5, x0, 0x1
+    add x1, x0, 0x002
+    add x2, x0, 0x001
+    beq x1, x2, back_label
+
+    # same-register: always equal -> should jump -> write 0x0AC
+    add x1, x0, 0x00A
+    beq x1, x1, same_reg_target
+    add x31, x0, 0x6BC
+same_reg_target:
+    add x31, x0, 0x0AC
+
+after_backward:
+    # final marker
+    add x31, x0, 0x0AC
--- a/bench/tests/op/bge.s
+++ b/bench/tests/op/bge.s
@@ -1,15 +1,61 @@
-# expected: 000001BC, 000002BC
+# expected: 000001BC, 000002BC, 000003BC, 000004BC, 000006BC, 000000BC, 00003BC
    .text
 _start:
-    add x1, x0, -29
-    add x2, x0, -28
-    bge x1, x2, finish # Should not jump
+    li x5, 0x0
+    # case1: greater -> should jump -> write 0x1BC
+    add x1, x0, 0x010
+    add x2, x0, 0x00F
+    bge x1, x2, case1_target
+    add x31, x0, 0x3BC
+case1_target:
    add x31, x0, 0x1BC

-    add x1, x0, 12
-    add x2, x0, 12
-    bge x1, x2, finish # Should jump to finish 
+    # case2: equal -> should jump -> write 0x2BC
+    add x1, x0, 0x1BC
+    add x2, x0, 0x1BC
+    bge x1, x2, case2_target
    add x31, x0, 0x3BC
-
-finish: 
+case2_target:
    add x31, x0, 0x2BC
+
+back_label:
+    bne x5, x0, back_label_flagged
+    # no-flag path (fall-through)
+    add x1, x0, 0x000
+    add x2, x0, 0x001
+    li x31, 0x3BC
+    jal x0, back_label_cont
+back_label_flagged:
+    li x31, 0x0BC
+    li x5, 0x0
+    jal x0, after_backward
+back_label_cont:
+
+    # case3: less -> should not jump -> write 0x4BC
+    add x1, x0, 0x001
+    add x2, x0, 0x002
+    bge x1, x2, case3_target
+    add x31, x0, 0x4BC
+case3_target:
+    # case4: negative values -> signed compare, should jump
+    add x1, x0, -1
+    add x2, x0, -2
+    bge x1, x2, case4_target
+    add x31, x0, 0x7BC
+case4_target:
+    add x31, x0, 0x6BC
+
+    add x5, x0, 0x1
+    add x1, x0, 0x002
+    add x2, x0, 0x001
+    bge x1, x2, back_label
+
+    li x1, 0xABC
+    bge x1, x1, same_reg_target
+    li x31, 0x2BC
+same_reg_target:
+    li x31, 0x1BC
+
+after_backward:
+    # final marker
+    li x31, 0x3BC
--- a/bench/tests/op/bgeu.s
+++ b/bench/tests/op/bgeu.s
@@ -1,15 +1,53 @@
-# expected: 000001BC, 000002BC
+# expected: 000001BC, 000003BC, 000002BC, 000004BC, 000000BC, 000000AC
    .text
 _start:
-    add x1, x0, 21
-    add x2, x0, 22
-    bgeu x1, x2, finish # Should not jump
+    li x5, 0x0
+    # case1: unsigned greater -> should jump -> write 0x1BC
+    add x1, x0, 0x0F0
+    add x2, x0, 0x00F
+    bgeu x1, x2, case1_target
+    add x31, x0, 0x3BC
+case1_target:
    add x31, x0, 0x1BC

-    add x1, x0, 12
-    add x2, x0, 12
-    bgeu x1, x2, finish # Should jump to finish 
+back_label:
+    bne x5, x0, back_label_flagged
+    add x1, x0, 0x000
+    add x2, x0, 0x001
    add x31, x0, 0x3BC
+    jal x0, back_label_cont
+back_label_flagged:
+    add x31, x0, 0x0BC
+    add x5, x0, 0x0
+    jal x0, after_backward
+back_label_cont:

-finish: 
+    # case2: equal -> should jump -> write 0x2BC
+    add x1, x0, 0x1BC
+    add x2, x0, 0x1BC
+    bgeu x1, x2, case2_target
+    add x31, x0, 0x3BC
+case2_target:
    add x31, x0, 0x2BC
+
+    # case3: unsigned less -> should not jump -> write 0x4BC
+    add x1, x0, 0x001
+    add x2, x0, 0x002
+    bgeu x1, x2, case3_target
+    add x31, x0, 0x4BC
+case3_target:
+    # backward branch trigger
+    add x5, x0, 0x1
+    add x1, x0, 0x002
+    add x2, x0, 0x001
+    bgeu x1, x2, back_label
+
+    # same-register unsigned -> should jump
+    add x1, x0, 0x00A
+    bgeu x1, x1, same_reg_target
+    add x31, x0, 0x6BC
+same_reg_target:
+    add x31, x0, 0x0AC
+
+after_backward:
+    add x31, x0, 0x0AC
--- a/bench/tests/op/blt.s
+++ b/bench/tests/op/blt.s
@@ -1,15 +1,55 @@
-# expected: 000001BC, 000002BC
+# expected: 000001BC, 000003BC, 000002BC, 000003BC, 000004BC, 000000AC
    .text
 _start:
-    add x1, x0, -28
-    add x2, x0, -28
-    blt x1, x2, finish # Should not jump
+    li x5, 0x0
+    # case1: less -> should jump -> write 0x1BC
+    add x1, x0, 0x001
+    add x2, x0, 0x002
+    blt x1, x2, case1_target
+    add x31, x0, 0x3BC
+case1_target:
    add x31, x0, 0x1BC

-    add x1, x0, -28
-    add x2, x0, 12
-    blt x1, x2, finish # Should jump to finish 
+back_label:
+    bne x5, x0, back_label_flagged
+    add x1, x0, 0x000
+    add x2, x0, 0x001
+    add x31, x0, 0x3BC
+    jal x0, back_label_cont
+back_label_flagged:
+    add x31, x0, 0x0BC
+    add x5, x0, 0x0
+    jal x0, after_backward
+back_label_cont:
+
+    # case2: equal -> should not jump -> write 0x2BC
+    add x1, x0, 0x1BC
+    add x2, x0, 0x1BC
+    blt x1, x2, case2_target
+    add x31, x0, 0x2BC
+case2_target:
    add x31, x0, 0x3BC

-finish: 
-    add x31, x0, 0x2BC
+    # case3: negative vs positive -> should jump -> write 0x4BC
+    add x1, x0, -5
+    add x2, x0, 0x001
+    blt x1, x2, case3_target
+    add x31, x0, 0x5BC
+case3_target:
+    add x31, x0, 0x4BC
+
+    # backward branch trigger
+    add x5, x0, 0x1
+    add x1, x0, 0x002
+    add x2, x0, 0x001
+    blt x1, x2, back_label
+
+    # same-register -> not taken -> write 0x0AC
+    add x1, x0, 0x00A
+    blt x1, x1, same_reg_target
+    add x31, x0, 0x0AC
+same_reg_target:
+    add x31, x0, 0x6BC
+
+after_backward:
+    add x31, x0, 0x0AC
--- a/bench/tests/op/bltu.s
+++ b/bench/tests/op/bltu.s
@@ -1,47 +1,54 @@
-# expected: 0000000000000001, 0000000000000004, 0000000000000008, 000000000000000D, 0000000000000014
+# expected: 000001BC, 000003BC, 000002BC, 000003BC, 000004BC, 000000AC
    .text
 _start:
-    # Test 1: Equal values (should NOT branch)
-    li x1, 5
-    li x2, 5
-    bltu x1, x2, label1
-    addi x31, x0, 1         # expected path (not taken)
-label1:
-    
-    # Test 2: x1 < x2 unsigned (should branch)
-    li x1, 5
-    li x2, 10
-    bltu x1, x2, label2
-    addi x31, x31, 2         # skipped if branch taken
-    j label2_end
-label2:
-    addi x31, x31, 3         # expected path (branch taken)
-label2_end:
+    li x5, 0x0
+    # case1: unsigned less -> should jump -> write 0x1BC
+    add x1, x0, 0x001
+    add x2, x0, 0x002
+    bltu x1, x2, case1_target
+    add x31, x0, 0x3BC
+case1_target:
+    add x31, x0, 0x1BC

-    # Test 3: x1 > x2 unsigned (should NOT branch)
-    li x1, 10
-    li x2, 5
-    bltu x1, x2, label3
-    addi x31, x31, 4         # expected path (not taken)
-label3:
+back_label:
+    bne x5, x0, back_label_flagged
+    add x1, x0, 0x000
+    add x2, x0, 0x001
+    add x31, x0, 0x3BC
+    jal x0, back_label_cont
+back_label_flagged:
+    add x31, x0, 0x0BC
+    add x5, x0, 0x0
+    jal x0, after_backward
+back_label_cont:

-    # Test 4: x1 = 0xFFFFFFFFFFFFFFFF, x2 = 0 (max unsigned vs min unsigned)
-    li x1, -1                # 0xFFFFFFFFFFFFFFFF
-    li x2, 0
-    bltu x1, x2, label4
-    addi x31, x31, 5         # expected path (not taken)
-label4:
+    # case2: equal -> should not jump -> write 0x2BC
+    add x1, x0, 0x1BC
+    add x2, x0, 0x1BC
+    bltu x1, x2, case2_target
+    add x31, x0, 0x2BC
+case2_target:
+    add x31, x0, 0x3BC

-    # Test 5: x1 = 0, x2 = 0xFFFFFFFFFFFFFFFF (min unsigned vs max unsigned)
-    li x1, 0
-    li x2, -1
-    bltu x1, x2, label5
-    addi x31, x31, 6         # skipped if branch taken
-    j label5_end
-label5:
-    addi x31, x31, 7         # expected path (branch taken)
-label5_end:
+    # case3: large unsigned compare -> should not jump -> write 0x4BC
+    add x1, x0, -1
+    add x2, x0, 0x7F
+    bltu x1, x2, case3_target
+    add x31, x0, 0x4BC
+case3_target:

-    # Done
-    nop
+    # backward branch trigger
+    add x5, x0, 0x1
+    add x1, x0, 0x002
+    add x2, x0, 0x001
+    bltu x1, x2, back_label

+    # same-register unsigned -> not taken -> write 0x0AC
+    add x1, x0, 0x00A
+    bltu x1, x1, same_reg_target
+    add x31, x0, 0x0AC
+same_reg_target:
+    add x31, x0, 0x6BC
+
+after_backward:
+    add x31, x0, 0x0AC
--- a/bench/tests/op/bne.s
+++ b/bench/tests/op/bne.s
@@ -1,15 +1,55 @@
-# expected: 000001BC, 000002BC
+# expected: 000001BC, 000003BC, 000002BC, 000003BC, 000000AC
    .text
 _start:
-    add x1, x0, 0x00B
+    li x5, 0x0
+    # case1: not equal -> should jump -> write 0x1BC
+    add x1, x0, 0x00A
    add x2, x0, 0x00B
-    bne x1, x2, finish # Should not jump
+    bne x1, x2, case1_target
+    add x31, x0, 0x3BC
+case1_target:
    add x31, x0, 0x1BC

-    add x1, x0, 0x1BA
+back_label:
+    bne x5, x0, back_label_flagged
+    # fall-through
+    add x1, x0, 0x000
+    add x2, x0, 0x001
+    add x31, x0, 0x3BC
+    jal x0, back_label_cont
+back_label_flagged:
+    add x5, x0, 0x0
+    jal x0, after_backward
+back_label_cont:
+
+    # case2: equal -> should not jump -> write 0x2BC
+    add x1, x0, 0x1BC
    add x2, x0, 0x1BC
-    bne x1, x2, finish # Should jump to finish 
+    bne x1, x2, case2_target
+    add x31, x0, 0x2BC
+case2_target:
    add x31, x0, 0x3BC

-finish: 
-    add x31, x0, 0x2BC
+    # case3: zero vs non-zero -> should jump -> write 0x4BC
+    add x1, x0, 0x000
+    add x2, x0, 0x001
+    bne x1, x2, case3_target
+    add x31, x0, 0x5BC
+case3_target:
+
+    # backward branch trigger
+    add x5, x0, 0x1
+    add x1, x0, 0x002
+    add x2, x0, 0x001
+    bne x1, x2, back_label
+
+    # same-reg: should not jump (since equal) -> write 0x0AC after fall-through
+    add x1, x0, 0x00A
+    add x2, x0, 0x00A
+    bne x1, x2, same_reg_target
+    add x31, x0, 0x0AC
+same_reg_target:
+    add x31, x0, 0x6BC
+
+after_backward:
+    add x31, x0, 0x0AC
--- a/bench/tests/op/jal.s
+++ b/bench/tests/op/jal.s
@@ -1,17 +1,28 @@
-# expected: 00000004, 0000008, 00000014, 0000000B
+# expected: 000002BC, 000004BC, 000007BC, 000005BC
    .text
 _start:
-    jal x31, step1
-step1:
-    jal x31, step2
-step4:
-    addi x31, x0, 0x00B
-    jal x0, finish
-step2:
-    jal x31, step3
-step3:
-    jal x0, step4
-    addi x31, x0, 0x00A # This instruction should never be executed
-finish:
-    nop
+    # forward jal -> should jump to target and set x1 to return addr
+    jal x1, jal_target
+    add x31, x0, 0x1BC
+jal_target:
+    add x31, x0, 0x2BC
+
+    add x5, x0, 0x1
+    jal x2, jal_back_target
+    add x31, x0, 0x3BC
+jal_back_target:
+    add x31, x0, 0x4BC
+    jal x0, after_jal_back
+jal_back_flag:
+    add x31, x0, 0x5BC
+after_jal_back:
+
+    # same-target jal to next insn (offset small) -> should set x3 and continue
+    jal x3, same_jal_target
+    add x31, x0, 0x6BC
+same_jal_target:
+    add x31, x0, 0x7BC
+
+    # final marker
+    add x31, x0, 0x5BC

--- a/bench/tests/op/jalr.s
+++ b/bench/tests/op/jalr.s
@@ -1,16 +1,21 @@
-# expected: 000000BA, 000001C, 0000000A
+# expected: 000002BC, 000003BC, 000000BC
    .text
 _start:
-    jal x1, step1
-    addi x31, x0, 0x00A
-    jal x0, finish
-step1:
-    jal x2, step2
-    addi x31, x0, 0x0AB # This instruction should never be executed
-    addi x31, x0, 0x0BA
-    jalr x31, 0(x1) # Check if return address is written to x31
-step2:
-    jalr x0, 4(x2) # return to step1, but 1 further
-finish:
-    nop
-    addi x31, x0, 0x0AB # This instruction should never be executed
+    add x5, x0, 0x00C
+    jalr x1, x5, 0
+    add x31, x0, 0x1BC
+# target for jalr (placed immediately) 
+    add x31, x0, 0x2BC
+
+    # jalr with immediate offset -> jump forward
+    add x6, x0, 0x018
+    jalr x2, x6, 0
+    add x31, x0, 0x3BC
+
+    # jalr to same register (should set rd to return addr) and continue
+    add x7, x0, 0x028
+    jalr x3, x7, 0
+    add x31, x0, 0x4BC
+
+    # final marker
+    add x31, x0, 0x0BC