Pr/minimal uefi target support

builder/build.go

@@ -842,22 +842,25 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 			}
 			ldflags = append(ldflags, "-mllvm", "-mcpu="+config.CPU())
 			ldflags = append(ldflags, "-mllvm", "-mattr="+config.Features()) // needed for MIPS softfloat
-			if config.GOOS() == "windows" {
-				// Options for the MinGW wrapper for the lld COFF linker.
+			switch config.LinkerFlavor() {
+			case "coff":
+				// Options for driving ld.lld in PE/COFF mode.
 				ldflags = append(ldflags,
 					"-Xlink=/opt:lldlto="+strconv.Itoa(speedLevel),
 					"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"))
-			} else if config.GOOS() == "darwin" {
+			case "darwin":
 				// Options for the ld64-compatible lld linker.
 				ldflags = append(ldflags,
 					"--lto-O"+strconv.Itoa(speedLevel),
 					"-cache_path_lto", filepath.Join(cacheDir, "thinlto"))
-			} else {
+			case "gnu":
 				// Options for the ELF linker.
 				ldflags = append(ldflags,
 					"--lto-O"+strconv.Itoa(speedLevel),
 					"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"),
 				)
+			default:
+				return fmt.Errorf("unknown linker flavor: %s", config.LinkerFlavor())
 			}
 			if config.CodeModel() != "default" {
 				ldflags = append(ldflags,

builder/builder_test.go

@@ -35,6 +35,7 @@ func TestClangAttributes(t *testing.T) {
 		"nintendoswitch",
 		"riscv-qemu",
 		"tkey",
+		"uefi-amd64",
 		"wasip1",
 		"wasip2",
 		"wasm",

compileopts/config.go

@@ -466,6 +466,26 @@ func (c *Config) LDFlags() []string {
 	return ldflags
 }
 
+// LinkerFlavor returns how the configured linker should be driven.
+// Usually this is derived from GOOS, but targets may override it explicitly.
+func (c *Config) LinkerFlavor() string {
+	if c.Target.LinkerFlavor != "" {
+		return c.Target.LinkerFlavor
+	}
+	goos := c.GOOS()
+	if goos == "" {
+		goos = c.Options.GOOS
+	}
+	switch goos {
+	case "windows":
+		return "coff"
+	case "darwin":
+		return "darwin"
+	default:
+		return "gnu"
+	}
+}
+
 // ExtraFiles returns the list of extra files to be built and linked with the
 // executable. This can include extra C and assembly files.
 func (c *Config) ExtraFiles() []string {

compileopts/target.go

@@ -38,7 +38,8 @@ type TargetSpec struct {
 	Scheduler        string   `json:"scheduler,omitempty"`
 	Serial           string   `json:"serial,omitempty"` // which serial output to use (uart, usb, none)
 	Linker           string   `json:"linker,omitempty"`
-	RTLib            string   `json:"rtlib,omitempty"` // compiler runtime library (libgcc, compiler-rt)
+	LinkerFlavor     string   `json:"linker-flavor,omitempty"` // how to drive the configured linker (for example: gnu, coff, darwin)
+	RTLib            string   `json:"rtlib,omitempty"`         // compiler runtime library (libgcc, compiler-rt)
 	Libc             string   `json:"libc,omitempty"`
 	AutoStackSize    *bool    `json:"automatic-stack-size,omitempty"` // Determine stack size automatically at compile time.
 	DefaultStackSize uint64   `json:"default-stack-size,omitempty"`   // Default stack size if the size couldn't be determined at compile time.

compileopts/target_test.go

@@ -112,3 +112,51 @@ func TestOverrideProperties(t *testing.T) {
 	}
 
 }
+
+func TestConfigLinkerFlavor(t *testing.T) {
+	tests := []struct {
+		name   string
+		target *TargetSpec
+		goos   string
+		want   string
+	}{
+		{
+			name:   "default gnu",
+			target: &TargetSpec{},
+			goos:   "linux",
+			want:   "gnu",
+		},
+		{
+			name:   "default coff",
+			target: &TargetSpec{},
+			goos:   "windows",
+			want:   "coff",
+		},
+		{
+			name:   "default darwin",
+			target: &TargetSpec{},
+			goos:   "darwin",
+			want:   "darwin",
+		},
+		{
+			name: "target override",
+			target: &TargetSpec{
+				LinkerFlavor: "coff",
+			},
+			goos: "linux",
+			want: "coff",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			config := &Config{
+				Options: &Options{GOOS: tc.goos},
+				Target:  tc.target,
+			}
+			if got := config.LinkerFlavor(); got != tc.want {
+				t.Fatalf("LinkerFlavor() = %q, want %q", got, tc.want)
+			}
+		})
+	}
+}

examples/uefi-exit/main.go

@@ -0,0 +1,4 @@
+package main
+
+func main() {
+}

src/device/amd64/cpu.go

@@ -0,0 +1,74 @@
+//go:build amd64
+
+package amd64
+
+const (
+	CPUIDTimeStampCounter   = 0x15
+	CPUIDProcessorFrequency = 0x16
+)
+
+type CPUExtendedFamily uint16
+
+const (
+	CPUFamilyIntelCore CPUExtendedFamily = 6
+)
+
+//export asmPause
+func AsmPause()
+
+//export asmReadRdtsc
+func AsmReadRdtsc() uint64
+
+//export asmCpuid
+func AsmCpuid(index uint32, registerEax *uint32, registerEbx *uint32, registerEcx *uint32) int
+
+var maxCpuidIndex uint32
+var stdVendorName0 uint32
+var stdCpuid1Eax uint32
+
+func init() {
+	AsmCpuid(0, &maxCpuidIndex, &stdVendorName0, nil)
+	AsmCpuid(1, &stdCpuid1Eax, nil, nil)
+}
+
+func getExtendedCPUFamily() CPUExtendedFamily {
+	family := CPUExtendedFamily((stdCpuid1Eax >> 8) & 0x0f)
+	family += CPUExtendedFamily((stdCpuid1Eax >> 20) & 0xff)
+	return family
+}
+
+func isIntel() bool {
+	return stdVendorName0 == 0x756e6547
+}
+
+func isIntelFamilyCore() bool {
+	return isIntel() && getExtendedCPUFamily() == CPUFamilyIntelCore
+}
+
+func InternalGetPerformanceCounterFrequency() uint64 {
+	if maxCpuidIndex >= CPUIDTimeStampCounter {
+		return cpuidCoreClockCalculateTSCFrequency()
+	}
+	return 0
+}
+
+func cpuidCoreClockCalculateTSCFrequency() uint64 {
+	var eax uint32
+	var ebx uint32
+	var ecx uint32
+
+	AsmCpuid(CPUIDTimeStampCounter, &eax, &ebx, &ecx)
+	if eax == 0 || ebx == 0 {
+		return 0
+	}
+
+	coreCrystalFrequency := uint64(ecx)
+	if coreCrystalFrequency == 0 {
+		if !isIntelFamilyCore() {
+			return 0
+		}
+		coreCrystalFrequency = 24000000
+	}
+
+	return ((coreCrystalFrequency * uint64(ebx)) + (uint64(eax) / 2)) / uint64(eax)
+}

src/device/amd64/cpu_amd64.S

@@ -0,0 +1,39 @@
+.section .text
+
+.global asmPause
+asmPause:
+    pause
+    ret
+
+.global asmReadRdtsc
+asmReadRdtsc:
+    rdtsc
+    shlq  $0x20, %rdx
+    orq   %rdx, %rax
+    ret
+
+.global asmCpuid
+asmCpuid:
+    pushq  %rbx
+
+    mov    %ecx, %eax
+    pushq  %rax
+
+    pushq  %rdx
+    cpuid
+
+    test   %r9, %r9
+    jz     .SkipEcx
+    mov    %ecx, (%r9)
+.SkipEcx:
+    popq   %rcx
+    jrcxz  .SkipEax
+    mov    %eax, (%rcx)
+.SkipEax:
+    mov    %r8, %rcx
+    jrcxz  .SkipEbx
+    mov    %ebx, (%rcx)
+.SkipEbx:
+    popq   %rax
+    popq   %rbx
+    ret

src/device/uefi/arch_x86.go

@@ -0,0 +1,17 @@
+//go:build i386 || amd64
+
+package uefi
+
+import "device/amd64"
+
+func Ticks() uint64 {
+	return amd64.AsmReadRdtsc()
+}
+
+func CpuPause() {
+	amd64.AsmPause()
+}
+
+func getTSCFrequency() uint64 {
+	return amd64.InternalGetPerformanceCounterFrequency()
+}