mirror of
https://github.com/tinygo-org/tinygo.git
synced 2026-08-05 19:43:44 +00:00
Ayke van Laethem
98f84a497d
There were a few issues that were causing qemu-system-arm and
qemu-system-riscv to give the wrong exit codes. They are in fact capable
of exiting with 0 or 1 signalled from the running application, but this
functionality wasn't used. This commit changes this in the following
ways:
* It fixes SemiHosting codes, which were incorrectly written in
decimal while they should have been written in hexadecimal (oops!).
* It modifies all the baremetal main functions (aka reset handlers) to
exit with `exit(0)` instead of `abort()`.
* It changes `syscall.Exit` to call `exit(code)` instead of `abort()`
on baremetal targets.
* It adds these new exit functions where necessary, implemented in a
way that signals the correct exit status if running under QEMU.
All in all, this means that `tinygo test` doesn't have to look at the
output of a test to determine the outcome. It can simply look at the
exit code.
77 lines
1.5 KiB
Go
77 lines
1.5 KiB
Go
// +build tinygo.riscv,virt,qemu
|
|
|
|
package runtime
|
|
|
|
import (
|
|
"device/riscv"
|
|
"runtime/volatile"
|
|
"unsafe"
|
|
)
|
|
|
|
// This file implements the VirtIO RISC-V interface implemented in QEMU, which
|
|
// is an interface designed for emulation.
|
|
|
|
type timeUnit int64
|
|
|
|
var timestamp timeUnit
|
|
|
|
func postinit() {}
|
|
|
|
//export main
|
|
func main() {
|
|
preinit()
|
|
run()
|
|
exit(0)
|
|
}
|
|
|
|
func ticksToNanoseconds(ticks timeUnit) int64 {
|
|
return int64(ticks)
|
|
}
|
|
|
|
func nanosecondsToTicks(ns int64) timeUnit {
|
|
return timeUnit(ns)
|
|
}
|
|
|
|
func sleepTicks(d timeUnit) {
|
|
// TODO: actually sleep here for the given time.
|
|
timestamp += d
|
|
}
|
|
|
|
func ticks() timeUnit {
|
|
return timestamp
|
|
}
|
|
|
|
// Memory-mapped I/O as defined by QEMU.
|
|
// Source: https://github.com/qemu/qemu/blob/master/hw/riscv/virt.c
|
|
// Technically this is an implementation detail but hopefully they won't change
|
|
// the memory-mapped I/O registers.
|
|
var (
|
|
// UART0 output register.
|
|
stdoutWrite = (*volatile.Register8)(unsafe.Pointer(uintptr(0x10000000)))
|
|
// SiFive test finisher
|
|
testFinisher = (*volatile.Register32)(unsafe.Pointer(uintptr(0x100000)))
|
|
)
|
|
|
|
func putchar(c byte) {
|
|
stdoutWrite.Set(uint8(c))
|
|
}
|
|
|
|
func abort() {
|
|
exit(1)
|
|
}
|
|
|
|
func exit(code int) {
|
|
// Make sure the QEMU process exits.
|
|
if code == 0 {
|
|
testFinisher.Set(0x5555) // FINISHER_PASS
|
|
} else {
|
|
// Exit code is stored in the upper 16 bits of the 32 bit value.
|
|
testFinisher.Set(uint32(code)<<16 | 0x3333) // FINISHER_FAIL
|
|
}
|
|
|
|
// Lock up forever (as a fallback).
|
|
for {
|
|
riscv.Asm("wfi")
|
|
}
|
|
}
|