Add EFI support for amd64 and arm64 platforms.

Some decisions points:
- no external libc dependency, builtin functions replaced by Go equivalent (runtime_minimal_libc.go)
- assembly efi_main entrypoint as assembly stub is required for sbat and few symbols anyway
- a default sbat section (required for Linux shim secure boot)
- dedicated rand reader in crypto/rand for EFI as it doesn't fit well with the generic machine interface
- the timer calibration is deliberately simple but hopefully good enough for EFI purpose
- no heap grow support, just get the biggest memory region available

Author: cclerget

GNUmakefile

@@ -814,6 +814,18 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=waveshare-rp2040-tiny examples/echo
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.exe -target=uefi-amd64          examples/echo2
+	@$(MD5SUM) test.exe
+	$(TINYGO) build -size short -o test.exe -target=uefi-amd64          examples/empty
+	@$(MD5SUM) test.exe
+	$(TINYGO) build -size short -o test.exe -target=uefi-amd64          examples/time-offset
+	@$(MD5SUM) test.exe
+	$(TINYGO) build -size short -o test.exe -target=uefi-arm64          examples/echo2
+	@$(MD5SUM) test.exe
+	$(TINYGO) build -size short -o test.exe -target=uefi-arm64          examples/empty
+	@$(MD5SUM) test.exe
+	$(TINYGO) build -size short -o test.exe -target=uefi-arm64          examples/time-offset
+	@$(MD5SUM) test.exe
 	# test pwm
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/pwm
 	@$(MD5SUM) test.hex

builder/build.go

@@ -19,6 +19,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -813,6 +814,11 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				ldflags = append(ldflags,
 					"-Xlink=/opt:lldlto="+strconv.Itoa(speedLevel),
 					"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"))
+			} else if slices.Contains(config.Target.BuildTags, "uefi") {
+				// PE/COFF targets (e.g. UEFI) that use GOOS != "windows"
+				// but still link with ld.lld via -m i386pep/arm64pe.
+				// The PE/COFF linker --lto-O option is not supported on
+				// all versions of ld.lld, so ignore it.
 			} else if config.GOOS() == "darwin" {
 				// Options for the ld64-compatible lld linker.
 				ldflags = append(ldflags,

builder/builder_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"strings"
 	"testing"
 
 	"github.com/tinygo-org/tinygo/compileopts"
@@ -35,6 +36,8 @@ func TestClangAttributes(t *testing.T) {
 		"nintendoswitch",
 		"riscv-qemu",
 		"tkey",
+		"uefi-amd64",
+		"uefi-arm64",
 		"wasip1",
 		"wasip2",
 		"wasm",
@@ -128,7 +131,7 @@ func testClangAttributes(t *testing.T, options *compileopts.Options) {
 	defer mod.Dispose()
 
 	// Check whether the LLVM target matches.
-	if mod.Target() != config.Triple() {
+	if mod.Target() != config.Triple() || !strings.HasPrefix(mod.Target(), config.Triple()) {
 		t.Errorf("target has LLVM triple %#v but Clang makes it LLVM triple %#v", config.Triple(), mod.Target())
 	}
 

emulators/qemu-uefi-aarch64.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+set -e
+
+binary=$1
+dir=$(dirname $binary)
+
+mkdir -p ${dir}/qemu-disk/efi/boot
+mv $binary ${dir}/qemu-disk/efi/boot/bootaa64.efi
+
+ovmf_path=${OVMF_CODE:-/usr/share/AAVMF/AAVMF_CODE.no-secboot.fd}
+
+exec qemu-system-aarch64 -M virt -bios $ovmf_path -device virtio-rng-pci \
+	-cpu max,pauth-impdef=on -drive format=raw,file=fat:rw:${dir}/qemu-disk \
+	-net none -nographic -no-reboot

emulators/qemu-uefi-x86_64.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+set -e
+
+binary=$1
+dir=$(dirname $binary)
+
+mkdir -p ${dir}/qemu-disk/efi/boot
+mv $binary ${dir}/qemu-disk/efi/boot/bootx64.efi
+
+ovmf_path=${OVMF_CODE:-/usr/share/qemu/OVMF.fd}
+
+exec qemu-system-x86_64 -bios $ovmf_path -cpu qemu64,+rdrand -device virtio-rng-pci \
+	-drive format=raw,file=fat:rw:${dir}/qemu-disk -net none -nographic -no-reboot

src/crypto/rand/rand_uefi.go

@@ -0,0 +1,39 @@
+//go:build uefi
+
+package rand
+
+import (
+	"errors"
+	"machine/uefi"
+)
+
+func init() {
+	Reader = &reader{}
+}
+
+type reader struct {
+}
+
+func (r *reader) Read(b []byte) (n int, err error) {
+	if !uefi.HasRNGSupport() {
+		return 0, errors.New("no hardware rng available")
+	} else if len(b) == 0 {
+		return 0, nil
+	}
+
+	var randomByte uint64
+	for i := range b {
+		if i%8 == 0 {
+			var ok bool
+			randomByte, ok = uefi.ReadRandom()
+			if !ok {
+				return n, errors.New("no random seed available")
+			}
+		} else {
+			randomByte >>= 8
+		}
+		b[i] = byte(randomByte)
+	}
+
+	return len(b), nil
+}

src/internal/task/task_stack_amd64.go

@@ -1,4 +1,4 @@
-//go:build scheduler.tasks && amd64 && !windows
+//go:build scheduler.tasks && amd64 && !windows && !uefi
 
 package task
 

…nternal/task/task_stack_amd64_windows.go …internal/task/task_stack_amd64_winabi.gosrc/internal/task/task_stack_amd64_windows.go renamed to src/internal/task/task_stack_amd64_winabi.go src/internal/task/task_stack_amd64_windows.go renamed to src/internal/task/task_stack_amd64_winabi.go

@@ -1,4 +1,4 @@
-//go:build scheduler.tasks && amd64 && windows
+//go:build scheduler.tasks && amd64 && (windows || uefi)
 
 package task
 

src/machine/uefi/api.go

@@ -0,0 +1,17 @@
+//go:build uefi
+
+package uefi
+
+// callAsm is the single assembly stub for all UEFI calls.
+// It takes a function pointer, a pointer to an argument array, and the count.
+//
+//export uefiCall
+func callAsm(fn uintptr, args *uintptr, nargs uintptr) Status
+
+// Call invokes a UEFI function with the given arguments via the MS x64 ABI.
+func Call(fn uintptr, args ...uintptr) Status {
+	if len(args) == 0 {
+		return callAsm(fn, nil, 0)
+	}
+	return callAsm(fn, &args[0], uintptr(len(args)))
+}

src/machine/uefi/api_amd64.S

@@ -0,0 +1,80 @@
+// UEFI Call Stub for x86_64
+//
+// Generic stub for calling any UEFI function via the Microsoft x64 ABI.
+//
+// Go signature: func callAsm(fn uintptr, args *uintptr, nargs uintptr) Status
+// MS x64 entry:
+//   RCX = fn (function pointer to call)
+//   RDX = args (pointer to uintptr array of arguments)
+//   R8  = nargs (number of arguments, 0-N)
+//
+// MS x64 ABI register mapping for the callee:
+//   Args 1-4:  RCX, RDX, R8, R9
+//   Args 5+:   stack (after 32-byte shadow space)
+//   Return:    RAX
+//   Stack:     16-byte aligned before CALL
+//
+
+.section .text.uefiCall,"ax"
+.global uefiCall
+uefiCall:
+    pushq %rbp
+    movq %rsp, %rbp
+    pushq %rsi
+    pushq %rdi
+
+    movq %rcx, %r10         // Save fn
+    movq %rdx, %rsi         // Save args pointer
+    movq %r8, %rdi          // Save nargs
+
+    // Calculate stack space: align16(32 + max(0, nargs-4) * 8)
+    // After 3 pushes, RSP is 16-byte aligned. Subtracting an aligned
+    // value keeps it aligned for the CALL instruction.
+    xorq %rax, %rax
+    cmpq $4, %rdi
+    jle 1f
+    movq %rdi, %rax
+    subq $4, %rax
+1:
+    shlq $3, %rax            // nStackArgs * 8
+    addq $47, %rax           // + 32 (shadow) + 15 (round-up)
+    andq $-16, %rax          // align to 16
+    subq %rax, %rsp
+
+    // Copy stack args: args[4..nargs-1] -> RSP+32+j*8
+    movq %rdi, %rcx
+    subq $4, %rcx
+    jle 2f
+    xorq %rax, %rax
+3:  movq 32(%rsi,%rax,8), %r11
+    movq %r11, 32(%rsp,%rax,8)
+    incq %rax
+    cmpq %rcx, %rax
+    jl 3b
+2:
+    // Load register args
+    xorq %rcx, %rcx
+    xorq %rdx, %rdx
+    xorq %r8, %r8
+    xorq %r9, %r9
+
+    testq %rdi, %rdi
+    jz 4f
+    movq 0(%rsi), %rcx       // args[0] -> RCX
+    cmpq $2, %rdi
+    jl 4f
+    movq 8(%rsi), %rdx       // args[1] -> RDX
+    cmpq $3, %rdi
+    jl 4f
+    movq 16(%rsi), %r8       // args[2] -> R8
+    cmpq $4, %rdi
+    jl 4f
+    movq 24(%rsi), %r9       // args[3] -> R9
+4:
+    callq *%r10
+
+    leaq -16(%rbp), %rsp
+    popq %rdi
+    popq %rsi
+    popq %rbp
+    retq