luxferre/a-machine
1
0
Fork 0
Code Actions Activity
Files
06816d21a492c0da64d24f93b141dba7e2f99e07
a-machine/amach.awk
T
Luxferre 06816d21a4 speed optimization
2026-06-20 14:54:51 +03:00

927 lines
32 KiB
Awk
Raw Blame History

#!/usr/bin/env awk -f
# A-Machine: an experimental RISC-V (RV32IMAC) emulator in POSIX AWK
# with a very small subset of supported ECALLs
# Accepts a headerless binary previously converted to .dec format
# e.g. with POSIX od: od -An -v -tu1 program.bin > program.dec
# Usage: awk -f amach.awk [-v LVA=...] -- prog.dec
# Or run a .bin directly with:
# od -An -v -tu1 program.bin | awk -f amach.awk [-v LVA=...]
# Created by Luxferre in 2026, released into the public domain
# fatal error reporting function
function trapout(msg, fd) {
for(fd in FD_PATH) if(FD_DIRTY[fd]) write_fd_to_file(fd)
cmd = "cat 1>&2"
printf("Fatal: %s\n", msg) | cmd
close(cmd)
exit(1)
}
# helper functions
function uint32(val) {
val = int(val)
if (val >= 0 && val < 4294967296) return val
val = val % 4294967296
return (val < 0) ? (val + 4294967296) : val
}
function setreg(idx, val) {
if(idx > 0) {
val = int(val) % 4294967296
if(val < 0) val += 4294967296
REG[idx] = (val >= 2147483648) ? (val - 4294967296) : val
}
}
function getreg(idx) {return (idx == 0) ? 0 : int(REG[idx])}
function imm_sign_ex(val) {val = int(val); return (val >= 2048) ? (val - 4096) : val}
function imm_sign_ex_b(val) {val = int(val); return (val >= 4096) ? (val - 8192) : val}
function floor(x, i) {
i = int(x)
return (x >= 0 || x == i) ? i : (i - 1)
}
function ord(c, b) {
if(!TGL_ORD["#"]) for(b=0;b<256;b++) TGL_ORD[sprintf("%c", b)] = b
return int(TGL_ORD[c])
}
function bw_op(a, b, op, v, r) {
v = 1; r = 0; a = uint32(a); b = uint32(b)
while(a > 0 || b > 0) {
if(op == "&" && (a%2) == 1 && (b%2) == 1) r += v
else if(op == "|" && ((a%2) == 1 || (b%2) == 1)) r += v
else if(op == "^" && (a%2) != (b%2)) r += v
a = int(a/2); b = int(b/2); v *= 2
}
return int(r)
}
function bw_and(a, b) {return bw_op(a, b, "&")}
function bw_or(a, b) {return bw_op(a, b, "|")}
function bw_xor(a, b) {return bw_op(a, b, "^")}
function read_mem(addr, bytes, signed, i, val, max_val) {
addr = uint32(addr)
if (bytes == 1) {
val = MEM[addr]
if (signed && val >= 128) val -= 256
} else if (bytes == 2) {
val = MEM[addr] + MEM[addr+1] * 256
if (signed && val >= 32768) val -= 65536
} else if (bytes == 4) {
val = MEM[addr] + MEM[addr+1] * 256 + MEM[addr+2] * 65536 + MEM[addr+3] * 16777216
if (signed && val >= 2147483648) val -= 4294967296
} else {
val = 0
for(i=0; i<bytes; i++) val += MEM[addr+i] * (256^i)
if(signed) {
max_val = 256^bytes
if(val >= max_val/2) val -= max_val
}
}
return val
}
function write_mem(addr, val, bytes, i) {
addr = uint32(addr)
val = uint32(val)
if (bytes == 1) {
MEM[addr] = val % 256
} else if (bytes == 2) {
MEM[addr] = val % 256
MEM[addr+1] = int(val / 256) % 256
} else if (bytes == 4) {
MEM[addr] = val % 256
MEM[addr+1] = int(val / 256) % 256
MEM[addr+2] = int(val / 65536) % 256
MEM[addr+3] = int(val / 16777216) % 256
} else {
for(i=0; i<bytes; i++) MEM[addr+i] = int(val / (256^i)) % 256
}
}
function read_word(addr) {return read_mem(addr, 4, 1)}
function write_word(addr, val) {write_mem(addr, val, 4)}
# Escapes single quotes for shell command safety
function qquote(str) {
gsub(/'/, "'\\''", str)
return "'" str "'"
}
# Converts hex string to decimal
function hex_to_dec(hex, dec, i, len, c, val) {
dec = 0
len = length(hex)
for(i = 1; i <= len; i++) {
c = tolower(substr(hex, i, 1))
if(c ~ /[0-9]/) val = int(c)
else if(c == "a") val = 10
else if(c == "b") val = 11
else if(c == "c") val = 12
else if(c == "d") val = 13
else if(c == "e") val = 14
else if(c == "f") val = 15
else continue
dec = dec * 16 + val
}
return dec
}
# Reads a null-terminated string from memory
function read_str(addr, c, s) {
s = ""
addr = uint32(addr)
while((c = MEM[addr++]) != 0) s = s sprintf("%c", c)
return s
}
# Checks if path exists using POSIX test -e or test -L
function path_exists(path) {
return (system("test -e " qquote(path)) == 0 || system("test -L " qquote(path)) == 0)
}
# Checks if path is a directory using POSIX test -d
function is_dir(path) {return (system("test -d " qquote(path)) == 0)}
# Resolves relative path against dfd directory
function resolve_path(dfd, pathname, path) {
if(substr(pathname, 1, 1) == "/") return pathname
if(dfd == -100) return pathname
if(dfd in FD_PATH) return FD_PATH[dfd] "/" pathname
return pathname
}
# Populate timespec structure
# TV_SEC: 64-bit for clock_gettime64, 32-bit for clock_gettime
function get_system_time(time_arr, cmd, line) {
cmd = "date +%s%N"
if((cmd | getline line) > 0) {
if(length(line) > 9 && line ~ /^[0-9]+$/) {
time_arr["sec"] = int(substr(line, 1, length(line) - 9))
time_arr["nsec"] = int(substr(line, length(line) - 8))
close(cmd)
return
}
}
close(cmd)
# Fallback if %N is not supported
cmd = "date +%s"
if((cmd | getline line) > 0) {
time_arr["sec"] = int(line)
} else time_arr["sec"] = 0
close(cmd)
if(time_arr["sec"] == LAST_SEC) {
VIRT_NSEC += 500000
if(VIRT_NSEC >= 1000000000) {
VIRT_NSEC = 999999999
}
} else {
LAST_SEC = time_arr["sec"]
VIRT_NSEC = 0
}
time_arr["nsec"] = VIRT_NSEC
}
# Fills stat structure in VM memory
function fill_stat_struct(path, addr, follow, cmd, line, parts, opt, mode_hex, mode_dec, size, atime, mtime, ctime, i) {
opt = follow ? "-L " : ""
cmd = "stat " opt "-c \"%f %s %X %Y %Z\" " qquote(path)
if((cmd | getline line) > 0) {
split(line, parts)
mode_hex = parts[1]
mode_dec = hex_to_dec(mode_hex)
size = int(parts[2])
atime = int(parts[3])
mtime = int(parts[4])
ctime = int(parts[5])
close(cmd)
for(i = 0; i < 104; i++) MEM[addr + i] = 0
write_mem(addr + 0, 1, 8)
write_mem(addr + 8, 1, 8)
write_mem(addr + 16, mode_dec, 4)
write_mem(addr + 20, 1, 4)
write_mem(addr + 24, 1000, 4)
write_mem(addr + 28, 1000, 4)
write_mem(addr + 32, 0, 8)
write_mem(addr + 48, size, 8)
write_mem(addr + 56, 4096, 4)
write_mem(addr + 64, int((size + 511) / 512), 8)
write_mem(addr + 72, atime, 4)
write_mem(addr + 80, mtime, 4)
write_mem(addr + 88, ctime, 4)
return 0
} else {
close(cmd)
return -2
}
}
# Writes file descriptor cached data back to file
function write_fd_to_file(fd, path, chunk, i, size) {
path = FD_PATH[fd]
size = FD_SIZE[fd]
printf("") > path
close(path)
chunk = ""
for(i = 0; i < size; i++) {
chunk = chunk sprintf("%c", FD_DATA[fd, i])
if(length(chunk) >= 1024) {
printf("%s", chunk) >> path
chunk = ""
}
}
if(length(chunk) > 0) printf("%s", chunk) >> path
close(path)
}
function amach_exit(code, fd) {
for(fd in FD_PATH) if(FD_DIRTY[fd]) write_fd_to_file(fd)
exit(code)
}
# syscall emulation
function handle_ecall(callnum, a0, a1, a2, a3, a4, a5, i, reclen, cmd, line, arr) {
ECALL_COUNT++
if(ECALL_COUNT == 1) POST_ECALL_IC = ic
printf("ECALL #%d: call=%d a0=%d a1=0x%X a2=%d pc=0x%X ic=%d\n", ECALL_COUNT, callnum, a0, uint32(a1), a2, pc-4, ic) > "/dev/stderr"
if(callnum == 34) { # sys_mkdirat
a1 = resolve_path(a0, read_str(a1))
if(path_exists(a1)) setreg(10, -17) # -EEXIST
else setreg(10, (system("mkdir " qquote(a1)) == 0) ? 0 : -2)
} else if(callnum == 35) { # sys_unlinkat
a1 = resolve_path(a0, read_str(a1))
if(!path_exists(a1)) setreg(10, -2) # -ENOENT
else {
a2 = bw_and(a2, 512) ? "rmdir " : "rm "
setreg(10, (system(a2 qquote(a1)) == 0) ? 0 : -1)
}
} else if(callnum == 38 || callnum == 276) { # sys_renameat / sys_renameat2
a1 = resolve_path(a0, read_str(a1))
a3 = resolve_path(a2, read_str(a3))
setreg(10, (system("mv " qquote(a1) " " qquote(a3)) == 0) ? 0 : -1)
} else if(callnum == 56) { # sys_openat
a1 = resolve_path(a0, read_str(a1))
if(bw_and(a2, 64)) { # O_CREAT (0x40)
if(bw_and(a2, 128) && path_exists(a1)) { # O_EXCL (0x80)
setreg(10, -17) # -EEXIST
return
}
if(!path_exists(a1)) {
printf("") > a1
close(a1)
}
} else if(!path_exists(a1)) {
setreg(10, -2) # -ENOENT
return
}
a3 = NEXT_FD++
FD_PATH[a3] = a1
FD_FLAGS[a3] = a2
FD_OFFSET[a3] = 0
FD_SIZE[a3] = 0
FD_DIRTY[a3] = 0
if(is_dir(a1)) {
cmd = "ls -a1 " qquote(a1)
a4 = 0
while((cmd | getline line) > 0)
if(line != "") FD_DIRENTS[a3, a4++] = line
close(cmd)
FD_DIRENT_COUNT[a3] = a4
} else {
a4 = bw_and(a2, 3) # access_mode
a5 = (a4 != 0) && bw_and(a2, 512) # do_trunc
if(a4 != 1 && !a5) { # is_read && !do_trunc
cmd = "od -An -v -tu1 " qquote(a1)
a0 = 0 # reuse a0 for size
while((cmd | getline line) > 0) {
split(line, arr)
for(i = 1; i in arr; i++)
FD_DATA[a3, a0++] = arr[i]
}
close(cmd)
FD_SIZE[a3] = a0
} else if(a5) {
printf("") > a1
close(a1)
}
}
setreg(10, a3)
} else if(callnum == 57) { # sys_close
if(a0 >= 3 && (a0 in FD_PATH)) {
if(FD_DIRTY[a0]) write_fd_to_file(a0)
delete FD_PATH[a0]
delete FD_FLAGS[a0]
delete FD_OFFSET[a0]
delete FD_SIZE[a0]
delete FD_DIRTY[a0]
if(a0 in FD_DIRENT_COUNT) {
for(i = 0; i < FD_DIRENT_COUNT[a0]; i++) delete FD_DIRENTS[a0, i]
delete FD_DIRENT_COUNT[a0]
} else for(i = 0; i < FD_SIZE[a0]; i++) delete FD_DATA[a0, i]
setreg(10, 0)
} else setreg(10, -9) # -EBADF
} else if(callnum == 61) { # sys_getdents64
if(!(a0 in FD_DIRENT_COUNT)) setreg(10, -9) # -EBADF
else {
a3 = 0 # bytes_written
a4 = FD_OFFSET[a0] # idx
while(a4 < FD_DIRENT_COUNT[a0]) {
a5 = FD_DIRENTS[a0, a4] # name
reclen = int((20 + length(a5) + 7) / 8) * 8
if(a3 + reclen > a2) { # count_limit
if(a3 == 0) {
setreg(10, -22) # -EINVAL
return
}
break
}
write_mem(a1 + a3, 1, 8)
write_mem(a1 + a3 + 8, a4 + 1, 8)
write_mem(a1 + a3 + 16, reclen, 2)
write_mem(a1 + a3 + 18, is_dir(FD_PATH[a0] "/" a5) ? 4 : 8, 1) # dtype
for(i = 0; i < length(a5); i++)
MEM[a1 + a3 + 19 + i] = ord(substr(a5, i + 1, 1))
MEM[a1 + a3 + 19 + length(a5)] = 0
for(i = 19 + length(a5) + 1; i < reclen; i++)
MEM[a1 + a3 + i] = 0
a3 += reclen
a4++
}
FD_OFFSET[a0] = a4
setreg(10, a3)
}
} else if(callnum == 62) { # sys_lseek
if(a0 >= 3 && (a0 in FD_PATH) && !(a0 in FD_DIRENT_COUNT)) {
if(a2 == 0) {} # SEEK_SET, a1 is unchanged
else if(a2 == 1) a1 += FD_OFFSET[a0]
else if(a2 == 2) a1 += FD_SIZE[a0]
else {
setreg(10, -22) # -EINVAL
return
}
if(a1 < 0) setreg(10, -22) # -EINVAL
else {
FD_OFFSET[a0] = a1
setreg(10, a1)
}
} else setreg(10, -9) # -EBADF
} else if(callnum == 63) { # sys_read
if(a0 == 0) {
STARTED_IO = 1
if(length(STDIN_BUF) == 0) {
if((getline a3 < "-") > 0) STDIN_BUF = a3 "\n"
}
a4 = length(STDIN_BUF); if(a4 > a2) a4 = a2
for(i = 0; i < a4; i++) MEM[uint32(a1 + i)] = ord(substr(STDIN_BUF, i + 1, 1))
STDIN_BUF = substr(STDIN_BUF, a4 + 1)
setreg(10, a4)
} else if(a0 >= 3 && (a0 in FD_PATH) && !(a0 in FD_DIRENT_COUNT)) {
a3 = FD_OFFSET[a0] # idx
a4 = FD_SIZE[a0] # size
if(a3 >= a4) setreg(10, 0)
else {
if(a3 + a2 > a4) a2 = a4 - a3 # count
for(i = 0; i < a2; i++)
MEM[uint32(a1 + i)] = FD_DATA[a0, a3 + i]
FD_OFFSET[a0] = a3 + a2
printf("DEBUG sys_read fd=%d: wrote %d bytes to 0x%X. First 16:", a0, a2, uint32(a1)) > "/dev/stderr"
for(k=0; k<16; k++) printf(" %d", MEM[uint32(a1)+k]+0) > "/dev/stderr"
printf("\n") > "/dev/stderr"
setreg(10, a2)
}
} else setreg(10, -9) # -EBADF
} else if(callnum == 64) { # sys_write
if(a0 == 1 || a0 == 2) {
for(i = 0; i < a2; i++) printf("%c", MEM[uint32(a1 + i)])
fflush("")
setreg(10, a2)
} else if(a0 >= 3 && (a0 in FD_PATH) && !(a0 in FD_DIRENT_COUNT)) {
a3 = bw_and(FD_FLAGS[a0], 1024) ? FD_SIZE[a0] : FD_OFFSET[a0] # idx
for(i = 0; i < a2; i++)
FD_DATA[a0, a3 + i] = MEM[uint32(a1 + i)]
FD_OFFSET[a0] = a3 + a2
if(FD_OFFSET[a0] > FD_SIZE[a0]) FD_SIZE[a0] = FD_OFFSET[a0]
FD_DIRTY[a0] = 1
setreg(10, a2)
} else setreg(10, -9) # -EBADF
} else if(callnum == 78) { # sys_readlinkat
a0 = resolve_path(a0, read_str(a1))
a1 = "readlink " qquote(a0)
if((a1 | getline line) > 0) {
close(a1)
a4 = length(line)
if(a4 > a3) a4 = a3
for(i = 0; i < a4; i++)
MEM[uint32(a2 + i)] = ord(substr(line, i + 1, 1))
setreg(10, a4)
} else {
close(a1)
setreg(10, -22) # -EINVAL
}
} else if(callnum == 79) { # sys_newfstatat
a1 = read_str(a1)
if(a1 == "" && bw_and(a3, 4096)) { # AT_EMPTY_PATH
if(a0 == -100) a0 = "."
else if(a0 in FD_PATH) a0 = FD_PATH[a0]
else {
setreg(10, -9) # -EBADF
return
}
} else a0 = resolve_path(a0, a1)
a4 = (bw_and(a3, 256) == 0) # follow link if AT_SYMLINK_NOFOLLOW is NOT set
setreg(10, fill_stat_struct(a0, a2, a4))
} else if(callnum == 80) { # sys_fstat
if(a0 == 0) a0 = "/dev/stdin"
else if(a0 == 1) a0 = "/dev/stdout"
else if(a0 == 2) a0 = "/dev/stderr"
else if(a0 >= 3 && (a0 in FD_PATH)) a0 = FD_PATH[a0]
else {
setreg(10, -9) # -EBADF
return
}
setreg(10, fill_stat_struct(a0, a1, 1))
} else if(callnum == 93 || callnum == 94) { # sys_exit / sys_exit_group
amach_exit(a0)
} else if(callnum == 113 || callnum == 403) { # sys_clock_gettime / sys_clock_gettime64
get_system_time(arr)
if(callnum == 113) {
write_mem(a1, arr["sec"], 4)
write_mem(a1 + 4, arr["nsec"], 4)
} else {
write_mem(a1, arr["sec"], 8)
write_mem(a1 + 8, arr["nsec"], 4)
}
setreg(10, 0)
} else if(callnum == 169) { # sys_gettimeofday
get_system_time(arr)
write_mem(a0, arr["sec"], 4)
write_mem(a0 + 4, int(arr["nsec"] / 1000), 4)
setreg(10, 0)
} else if(callnum == 278) { # sys_getrandom
for(i = 0; i < a1; i++)
MEM[uint32(a0 + i)] = int(rand() * 256)
setreg(10, a1)
} else trapout(sprintf("Unimplemented environment call %d at 0x%X", callnum, pc - 4))
}
# instruction type executors
function amach_reg_arith(f3, f7, rd, rs1, rs2, r1, r2, ur1, ur2, shamt) {
r1 = rs1 ? int(REG[rs1]) : 0; r2 = rs2 ? int(REG[rs2]) : 0
ur1 = uint32(r1); ur2 = uint32(r2)
shamt = ur2 % 32
if(f3 == 0 && f7 == 0) setreg(rd, r1 + r2)
else if(f3 == 0 && f7 == 32) setreg(rd, r1 - r2)
else if(f3 == 4 && f7 == 0) setreg(rd, bw_xor(r1, r2))
else if(f3 == 6 && f7 == 0) setreg(rd, bw_or(r1, r2))
else if(f3 == 7 && f7 == 0) setreg(rd, bw_and(r1, r2))
else if(f3 == 1 && f7 == 0) setreg(rd, (r1 * P2[shamt]) % 4294967296)
else if(f3 == 5 && f7 == 0) setreg(rd, int(ur1 / P2[shamt]))
else if(f3 == 5 && f7 == 32) setreg(rd, floor(r1 / P2[shamt]))
else if(f3 == 2 && f7 == 0) setreg(rd, (r1 < r2) ? 1 : 0)
else if(f3 == 3 && f7 == 0) setreg(rd, (ur1 < ur2) ? 1 : 0)
else if(f3 == 0 && f7 == 1) setreg(rd, (r1 * r2) % 4294967296)
else if(f3 == 1 && f7 == 1) setreg(rd, floor((r1 * r2) / 4294967296))
else if(f3 == 2 && f7 == 1) setreg(rd, floor((r1 * ur2) / 4294967296))
else if(f3 == 3 && f7 == 1) setreg(rd, floor((ur1 * ur2) / 4294967296))
else if(f3 == 4 && f7 == 1) setreg(rd, (r2 == 0) ? -1 : int(r1 / r2))
else if(f3 == 5 && f7 == 1) setreg(rd, (r2 == 0) ? 4294967295 : int(ur1 / ur2))
else if(f3 == 6 && f7 == 1) setreg(rd, (r2 == 0) ? r1 : (r1 % r2))
else if(f3 == 7 && f7 == 1) setreg(rd, (r2 == 0) ? r1 : (ur1 % ur2))
else trapout(sprintf("Illegal instruction at 0x%X", pc-4))
}
function amach_store(f3, rs1, rs2, immval, r1, r2) {
r1 = rs1 ? int(REG[rs1]) : 0; r2 = rs2 ? int(REG[rs2]) : 0
if(f3 >= 0 && f3 <= 2) write_mem(r1 + immval, r2, P2[f3])
else trapout(sprintf("Illegal instruction at 0x%X", pc-4))
}
function amach_branch(f3, rs1, rs2, immval, r1, r2, ur1, ur2, taken) {
r1 = rs1 ? int(REG[rs1]) : 0; r2 = rs2 ? int(REG[rs2]) : 0
ur1 = uint32(r1); ur2 = uint32(r2)
taken = 0
if(f3 == 0) taken = (r1 == r2)
else if(f3 == 1) taken = (r1 != r2)
else if(f3 == 4) taken = (r1 < r2)
else if(f3 == 5) taken = (r1 >= r2)
else if(f3 == 6) taken = (ur1 < ur2)
else if(f3 == 7) taken = (ur1 >= ur2)
else trapout(sprintf("Illegal instruction at 0x%X", pc-4))
pc += (taken ? immval : 4)
}
function amach_imm(opcode, f3, rd, rs1, immval, r1, ur1, shamt) {
r1 = rs1 ? int(REG[rs1]) : 0; ur1 = uint32(r1)
if(opcode == 3) { # load
if(f3 == 0 || f3 == 1 || f3 == 2 || f3 == 4 || f3 == 5) {
setreg(rd, read_mem(r1 + immval, P2[f3 % 4], f3 < 4))
} else trapout(sprintf("Illegal instruction at 0x%X", pc-4))
} else if(opcode == 19) { # 0x13, immediate arithmetic
shamt = bw_and(immval, 31)
if(f3 == 0) setreg(rd, r1 + immval)
else if(f3 == 4) setreg(rd, bw_xor(r1, immval))
else if(f3 == 6) setreg(rd, bw_or(r1, immval))
else if(f3 == 7) setreg(rd, bw_and(r1, immval))
else if(f3 == 1) setreg(rd, (r1 * P2[shamt]) % 4294967296) # slli
else if(f3 == 5 && immval < 1024) setreg(rd, int(ur1 / P2[shamt])) # srli
else if(f3 == 5 && immval >= 1024) setreg(rd, floor(r1 / P2[shamt])) # srai
else if(f3 == 2) setreg(rd, (r1 < immval) ? 1 : 0)
else if(f3 == 3) setreg(rd, (ur1 < immval) ? 1 : 0)
else trapout(sprintf("Illegal instruction at 0x%X", pc-4))
} else if(opcode == 103) { # 0x67, JALR
setreg(rd, pc)
pc = r1 + immval
} else if(opcode == 115) { # 0x73, system call / csr
if(immval == 0) handle_ecall(REG[17], REG[10], REG[11], REG[12], REG[13], REG[14], REG[15])
else if(immval == 1) trapout(sprintf("EBREAK at 0x%X", pc-4))
else trapout(sprintf("Unimplemented external system call at 0x%X", pc-4))
} else trapout(sprintf("Illegal instruction at 0x%X", pc-4))
}
# A-extension
function amach_atomic(f3, f5, aq, rl, rd, rs1, rs2, r1, r2, val, uval, ur2) {
r1 = rs1 ? int(REG[rs1]) : 0; r2 = rs2 ? int(REG[rs2]) : 0
ur2 = uint32(r2)
if(f3 == 2) {
val = read_word(r1)
uval = uint32(val)
if(f5 == 0) { # amoadd.w
setreg(rd, val)
write_word(r1, val + r2)
} else if(f5 == 1) { # amoswap.w
setreg(rd, val)
write_word(r1, r2)
} else if(f5 == 2) { # lr.w
setreg(rd, val)
RES_ADDR = r1
} else if(f5 == 3) { # sc.w
if(RES_ADDR == r1) {
write_word(r1, r2)
setreg(rd, 0)
RES_ADDR = -1
} else setreg(rd, 1)
} else if(f5 == 4) { # amoxor.w
setreg(rd, val)
write_word(r1, bw_xor(val, r2))
} else if(f5 == 8) { # amoor.w
setreg(rd, val)
write_word(r1, bw_or(val, r2))
} else if(f5 == 12) { # amoand.w
setreg(rd, val)
write_word(r1, bw_and(val, r2))
} else if(f5 == 16) { # amomin.w
setreg(rd, val)
write_word(r1, val <= r2 ? val : r2)
} else if(f5 == 20) { # amomax.w
setreg(rd, val)
write_word(r1, val >= r2 ? val : r2)
} else if(f5 == 24) { # amominu.w
setreg(rd, val)
write_word(r1, uval <= ur2 ? val : r2)
} else if(f5 == 28) { # amomaxu.w
setreg(rd, val)
write_word(r1, uval >= ur2 ? val : r2)
} else trapout(sprintf("Unimplemented atomic instruction at 0x%X", pc-4))
} else trapout(sprintf("Illegal atomic instruction at 0x%X", pc-4))
}
# C-extension (compressed instructions) handler
function amach_comp(instr, addr, op, f3, b12, r11_7, r9_7, r6_2, r4_2, shamt, imm, base, val) {
if (addr in CACHE_COP) {
op = CACHE_COP[addr]
f3 = CACHE_CF3[addr]
b12 = CACHE_CB12[addr]
r11_7 = CACHE_CR11_7[addr]
r9_7 = CACHE_CR9_7[addr]
r6_2 = CACHE_CR6_2[addr]
r4_2 = CACHE_CR4_2[addr]
shamt = CACHE_CSHAMT[addr]
} else {
op = instr % 4
f3 = int(instr / 8192) % 8
b12 = int(instr / 4096) % 2
r11_7 = int(instr / 128) % 32
r9_7 = (r11_7 % 8) + 8
r6_2 = int(instr / 4) % 32
r4_2 = (r6_2 % 8) + 8
shamt = r6_2 + b12 * 32
CACHE_COP[addr] = op
CACHE_CF3[addr] = f3
CACHE_CB12[addr] = b12
CACHE_CR11_7[addr] = r11_7
CACHE_CR9_7[addr] = r9_7
CACHE_CR6_2[addr] = r6_2
CACHE_CR4_2[addr] = r4_2
CACHE_CSHAMT[addr] = shamt
}
if(op == 0) {
if(f3 == 0) { # C.ADDI4SPN
imm = (r11_7 % 16) * 64 + (int(r11_7 / 16) + b12 * 2) * 16 + (int(r6_2 / 8) % 2) * 8 + (int(r6_2 / 16) % 2) * 4
if(imm == 0) trapout(sprintf("Illegal instruction C.ADDI4SPN at 0x%X", pc-2))
setreg(r4_2, REG[2] + imm)
} else if(f3 == 2) { # C.LW
imm = (int(r6_2 / 8) % 2) * 64 + (int(r11_7 / 8) % 4) * 8 + b12 * 32 + (int(r6_2 / 16) % 2) * 4
setreg(r4_2, read_mem((r9_7 ? REG[r9_7] : 0) + imm, 4, 1))
} else if(f3 == 6) { # C.SW
imm = (int(r6_2 / 8) % 2) * 64 + (int(r11_7 / 8) % 4) * 8 + b12 * 32 + (int(r6_2 / 16) % 2) * 4
write_mem((r9_7 ? REG[r9_7] : 0) + imm, r4_2 ? REG[r4_2] : 0, 4)
} else trapout(sprintf("Illegal instruction at 0x%X", pc-2))
} else if(op == 1) {
if(f3 == 0) { # C.NOP / C.ADDI
imm = r6_2 + b12 * 32
if(imm >= 32) imm -= 64
setreg(r11_7, (r11_7 ? REG[r11_7] : 0) + imm)
} else if(f3 == 1 || f3 == 5) { # C.JAL / C.J
imm = b12 * 2048 + (int(r11_7 / 2) % 2) * 1024 + (int(r11_7 / 4) % 4) * 256 + (int(r6_2 / 16) % 2) * 128 + (r11_7 % 2) * 64 + (r6_2 % 2) * 32 + (int(r11_7 / 16)) * 16 + (int(r6_2 / 2) % 8) * 2
if(imm >= 2048) imm -= 4096
if(f3 == 1) setreg(1, pc)
pc = (pc - 2) + imm
} else if(f3 == 2) { # C.LI
imm = r6_2 + b12 * 32
if(imm >= 32) imm -= 64
setreg(r11_7, imm)
} else if(f3 == 3) { # C.ADDI16SP / C.LUI
if(r11_7 == 2) { # C.ADDI16SP
imm = b12 * 512 + (int(r6_2 / 2) % 4) * 128 + (int(r6_2 / 8) % 2) * 64 + (r6_2 % 2) * 32 + (int(r6_2 / 16) % 2) * 16
if(imm >= 512) imm -= 1024
if(imm == 0) trapout(sprintf("Illegal instruction C.ADDI16SP at 0x%X", pc-2))
setreg(2, REG[2] + imm)
} else if(r11_7 != 0) { # C.LUI
imm = r6_2 + b12 * 32
if(imm >= 32) imm -= 64
imm = imm * 4096
if(imm == 0) trapout(sprintf("Illegal instruction C.LUI at 0x%X", pc-2))
setreg(r11_7, imm)
}
} else if(f3 == 4) {
val = int(r11_7 / 8) % 4
if(val == 0) { # C.SRLI
if(shamt >= 32) trapout(sprintf("Illegal shift amount %d at 0x%X", shamt, pc-2))
imm = r9_7 ? REG[r9_7] : 0
if(imm < 0) imm += 4294967296
setreg(r9_7, int(imm / P2[shamt]))
} else if(val == 1) { # C.SRAI
if(shamt >= 32) trapout(sprintf("Illegal shift amount %d at 0x%X", shamt, pc-2))
setreg(r9_7, floor((r9_7 ? REG[r9_7] : 0) / P2[shamt]))
} else if(val == 2) { # C.ANDI
imm = r6_2 + b12 * 32
if(imm >= 32) imm -= 64
setreg(r9_7, bw_and(r9_7 ? REG[r9_7] : 0, imm))
} else if(val == 3) { # C.SUB, C.XOR, C.OR, C.AND
imm = int(r6_2 / 8) % 4
if(b12 != 0) trapout(sprintf("Illegal register-register instruction at 0x%X", pc-2))
r9_val = r9_7 ? REG[r9_7] : 0
r4_val = r4_2 ? REG[r4_2] : 0
if(imm == 0) setreg(r9_7, r9_val - r4_val)
else if(imm == 1) setreg(r9_7, bw_xor(r9_val, r4_val))
else if(imm == 2) setreg(r9_7, bw_or(r9_val, r4_val))
else if(imm == 3) setreg(r9_7, bw_and(r9_val, r4_val))
}
} else if(f3 == 6 || f3 == 7) { # C.BEQZ / C.BNEZ
imm = b12 * 256 + (int(r6_2 / 8) % 4) * 64 + (r6_2 % 2) * 32 + (int(r11_7 / 8) % 4) * 8 + (int(r6_2 / 2) % 4) * 2
if(imm >= 256) imm -= 512
val = (f3 == 6) ? ((r9_7 ? REG[r9_7] : 0) == 0) : ((r9_7 ? REG[r9_7] : 0) != 0)
pc = val ? (pc - 2) + imm : pc
}
} else if(op == 2) {
if(f3 == 0) { # C.SLLI
if(shamt >= 32) trapout(sprintf("Illegal shift amount %d at 0x%X", shamt, pc-2))
if(r11_7 != 0) {
setreg(r11_7, (REG[r11_7] * P2[shamt]) % 4294967296)
}
} else if(f3 == 2) { # C.LWSP
if(r11_7 == 0) trapout(sprintf("Illegal instruction C.LWSP with rd=0 at 0x%X", pc-2))
imm = (r6_2 % 4) * 64 + b12 * 32 + (int(r6_2 / 4) % 8) * 4
setreg(r11_7, read_mem(REG[2] + imm, 4, 1))
} else if(f3 == 4) { # C.JR, C.MV, C.JALR, C.ADD
if(b12 == 0) {
if(r6_2 == 0) { # C.JR
if(r11_7 == 0) trapout(sprintf("Illegal instruction C.JR with rs1=0 at 0x%X", pc-2))
pc = r11_7 ? REG[r11_7] : 0
} else setreg(r11_7, r6_2 ? REG[r6_2] : 0) # C.MV
} else {
if(r6_2 == 0) {
if(r11_7 == 0) trapout(sprintf("EBREAK at 0x%X", pc-2)) # C.EBREAK
else { # C.JALR
imm = r11_7 ? REG[r11_7] : 0
setreg(1, pc)
pc = imm
}
} else setreg(r11_7, (r11_7 ? REG[r11_7] : 0) + (r6_2 ? REG[r6_2] : 0)) # C.ADD
}
} else if(f3 == 6) { # C.SWSP
imm = (r11_7 % 4) * 64 + int(r11_7 / 4) * 4 + b12 * 32
write_mem(REG[2] + imm, r6_2 ? REG[r6_2] : 0, 4)
} else trapout(sprintf("Illegal instruction at 0x%X", pc-2))
} else trapout(sprintf("Illegal instruction at 0x%X", pc-2))
}
# main instruction decoding and execution routine
function amach_exec(instr, addr, opcode, rd, rs1, rs2, imm, funct3, funct7) {
if((instr % 4) != 3) {
amach_comp(instr, addr)
return
}
if (addr in CACHE_OPCODE) {
opcode = CACHE_OPCODE[addr]
rd = CACHE_RD[addr]
rs1 = CACHE_RS1[addr]
rs2 = CACHE_RS2[addr]
imm = CACHE_IMM[addr]
funct3 = CACHE_F3[addr]
funct7 = CACHE_F7[addr]
} else {
opcode = instr % 128
instr = int(instr / 128)
rd = instr % 32
imm = int(instr / 32)
funct3 = imm % 8
rs1 = int(imm / 8) % 32
rs2 = int(imm / 256) % 32
funct7 = int(imm / 8192)
# Reconstruct/cache final immediate values for caching
if(opcode == 3 || opcode == 19 || opcode == 103 || opcode == 115) {
imm = imm_sign_ex(rs2 + funct7 * 32)
} else if(opcode == 35) {
imm = imm_sign_ex(rd + funct7 * 32)
} else if(opcode == 99) {
imm = rd + (funct7 % 64) * 32 + (rd % 2) * 2047 + int(funct7 / 64) * 4096
imm = imm_sign_ex_b(imm)
} else if(opcode == 111) {
imm_10_1 = int(rs2 / 2) + (funct7 % 64) * 16
imm_19_12 = funct3 + rs1 * 8
imm = imm_10_1 * 2 + (rs2 % 2) * 2048 + imm_19_12 * 4096 + int(funct7 / 64) * 1048576
if(imm >= 1048576) imm -= 2097152
} else if(opcode == 55 || opcode == 23) {
imm = imm * 4096
}
CACHE_OPCODE[addr] = opcode
CACHE_RD[addr] = rd
CACHE_RS1[addr] = rs1
CACHE_RS2[addr] = rs2
CACHE_IMM[addr] = imm
CACHE_F3[addr] = funct3
CACHE_F7[addr] = funct7
}
if(opcode == 51) { # 0x33, register arithmetic, type R
amach_reg_arith(funct3, funct7, rd, rs1, rs2)
} else if(opcode == 47) { # 0x2f, atomic operations, type R
amach_atomic(funct3, int(funct7 / 4), int(funct7 / 2) % 2, funct7 % 2, rd, rs1, rs2)
} else if(opcode == 3 || opcode == 19 || opcode == 103 || opcode == 115) { # type I
amach_imm(opcode, funct3, rd, rs1, imm)
} else if(opcode == 35) { # 0x23, store, type S
amach_store(funct3, rs1, rs2, imm)
} else if(opcode == 99) { # 0x63, branch, type B
pc -= 4
amach_branch(funct3, rs1, rs2, imm)
} else if(opcode == 111) { # 0x6F, JAL, type J
setreg(rd, pc)
pc += imm - 4
} else if(opcode == 55) { # 0x37, LUI, type U
setreg(rd, imm)
} else if(opcode == 23) { # 0x17, AUIPC, type U
setreg(rd, imm + pc - 4)
} else if(opcode == 15) { # 0x0F, FENCE, type I / no-op
} else trapout(sprintf("Illegal instruction at 0x%X", pc-4))
}
# Initialization section
BEGIN {
split("", MEM) # init the memory array
split("", REG) # init the (integer) registers
REG[0] = 0 # zero register
REG[2] = 2^31 # stack pointer top
RES_ADDR = -1 # reserved address for atomic ops
LVA = int(LVA)
pc = LVA
NEXT_FD = 3
LAST_SEC = -1
VIRT_NSEC = 0
srand()
STDIN_BUF = ""
for(i=0; i<=32; i++) P2[i] = 2^i
}
# Decimal memory collection section
/^[[:space:]]*[[:digit:][:space:]]+/ {for(i=1; i<=NF; i++) MEM[pc++] = int($i)}
# Execution section
END {
# ELF detection and parsing
# The file has been loaded into MEM starting from original LVA
orig_LVA = LVA
elf_size = pc - orig_LVA
# Verify if it starts with ELF magic (0x7F, 'E', 'L', 'F') and is large enough to contain a header
if(elf_size >= 52 && MEM[LVA] == 127 && MEM[LVA+1] == 69 && MEM[LVA+2] == 76 && MEM[LVA+3] == 70) {
# Verify class is ELF32, data is LSB (little endian), and machine is RISC-V (243 / 0xf3)
if(MEM[LVA+4] != 1 || MEM[LVA+5] != 1 || (MEM[LVA+18] + MEM[LVA+19] * 256) != 243)
trapout("Incompatible ELF file (must be RV32 little-endian)")
# Read entry point (4 bytes at offset 24)
e_entry = MEM[LVA+24] + MEM[LVA+25] * 256 + MEM[LVA+26] * 65536 + MEM[LVA+27] * 16777216
# Read program header table offset (4 bytes at offset 28)
e_phoff = MEM[LVA+28] + MEM[LVA+29] * 256 + MEM[LVA+30] * 65536 + MEM[LVA+31] * 16777216
# Read number of program headers (2 bytes at offset 44)
e_phnum = MEM[LVA+44] + MEM[LVA+45] * 256
# Read size of program header entry (2 bytes at offset 42)
e_phentsize = MEM[LVA+42] + MEM[LVA+43] * 256
# Back up the entire ELF image to ELF_DATA array and clear MEM in the loaded range
for(i = 0; i < elf_size; i++) {
ELF_DATA[i] = MEM[orig_LVA + i]
delete MEM[orig_LVA + i]
}
# Load segment data into memory
for(p = 0; p < e_phnum; p++) {
ph_addr = e_phoff + p * e_phentsize
p_type = ELF_DATA[ph_addr] + ELF_DATA[ph_addr+1] * 256 + ELF_DATA[ph_addr+2] * 65536 + ELF_DATA[ph_addr+3] * 16777216
# We only load PT_LOAD (p_type == 1)
if(p_type == 1) {
p_offset = ELF_DATA[ph_addr+4] + ELF_DATA[ph_addr+5] * 256 + ELF_DATA[ph_addr+6] * 65536 + ELF_DATA[ph_addr+7] * 16777216
p_vaddr = ELF_DATA[ph_addr+8] + ELF_DATA[ph_addr+9] * 256 + ELF_DATA[ph_addr+10] * 65536 + ELF_DATA[ph_addr+11] * 16777216
p_filesz = ELF_DATA[ph_addr+16] + ELF_DATA[ph_addr+17] * 256 + ELF_DATA[ph_addr+18] * 65536 + ELF_DATA[ph_addr+19] * 16777216
p_memsz = ELF_DATA[ph_addr+20] + ELF_DATA[ph_addr+21] * 256 + ELF_DATA[ph_addr+22] * 65536 + ELF_DATA[ph_addr+23] * 16777216
# Copy p_filesz bytes from ELF_DATA to MEM
for(i = 0; i < p_filesz; i++) MEM[p_vaddr + i] = ELF_DATA[p_offset + i]
# Zero-initialize the remaining p_memsz - p_filesz bytes
for(i = p_filesz; i < p_memsz; i++) MEM[p_vaddr + i] = 0
}
}
# Override LVA to the entry point (actual memory start value inside the ELF file)
LVA = e_entry
}
# Setup command-line arguments on the stack
n = 0
if(length(CMD_OPTS) > 0) n = split(CMD_OPTS, args, "\001")
else {
n = 1
args[1] = "amach"
}
sp = REG[2]
for(i = n; i >= 1; i--) {
len = length(args[i])
sp = sp - (len + 1)
for(j = 1; j <= len; j++)
MEM[uint32(sp + j - 1)] = ord(substr(args[i], j, 1))
MEM[uint32(sp + len)] = 0
argv_ptr[i] = sp
}
sp = sp - (sp % 16)
sp = sp - 4 * (n + 3)
sp = sp - (sp % 16)
write_word(sp, n)
for(i = 1; i <= n; i++) write_word(sp + 4 * i, argv_ptr[i])
write_word(sp + 4 * (n + 1), 0)
write_word(sp + 4 * (n + 2), 0)
setreg(2, sp)
memsize = pc - LVA
pc = LVA
ic = 0
while(pc > -1) {
ic++
instr_pc = pc
if (instr_pc in CACHE_INSTR) {
instr = CACHE_INSTR[instr_pc]
pc += CACHE_LEN[instr_pc]
} else {
instr = MEM[pc++] + 256 * MEM[pc++]
if((instr % 4) == 3) { # full instruction
instr += 65536 * MEM[pc++] + 16777216 * MEM[pc++]
CACHE_LEN[instr_pc] = 4
} else {
CACHE_LEN[instr_pc] = 2
}
CACHE_INSTR[instr_pc] = instr
}
amach_exec(instr, instr_pc) # decode and execute
}
for(fd in FD_PATH) if(FD_DIRTY[fd]) write_fd_to_file(fd)
}
View Git Blame Copy Permalink