windows: add windows/386 support

compiler/calls.go

@@ -76,7 +76,15 @@ func (b *builder) createCall(fnType llvm.Type, fn llvm.Value, args []llvm.Value,
 		fragments := b.expandFormalParam(arg)
 		expanded = append(expanded, fragments...)
 	}
-	return b.CreateCall(fnType, fn, expanded, name)
+	call := b.CreateCall(fnType, fn, expanded, name)
+	if !fn.IsAFunction().IsNil() {
+		if cc := fn.FunctionCallConv(); cc != llvm.CCallConv {
+			// Set a different calling convention if needed.
+			// This is needed for GetModuleHandleExA on Windows, for example.
+			call.SetInstructionCallConv(cc)
+		}
+	}
+	return call
 }
 
 // createInvoke is like createCall but continues execution at the landing pad if

compiler/llvm.go

@@ -452,6 +452,21 @@ func (b *builder) readStackPointer() llvm.Value {
 	return b.CreateCall(stacksave.GlobalValueType(), stacksave, nil, "")
 }
 
+// writeStackPointer emits a LLVM intrinsic call that updates the current stack
+// pointer.
+func (b *builder) writeStackPointer(sp llvm.Value) {
+	name := "llvm.stackrestore.p0"
+	if llvmutil.Version() < 18 {
+		name = "llvm.stackrestore" // backwards compatibility with LLVM 17 and below
+	}
+	stackrestore := b.mod.NamedFunction(name)
+	if stackrestore.IsNil() {
+		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.dataPtrType}, false)
+		stackrestore = llvm.AddFunction(b.mod, name, fnType)
+	}
+	b.CreateCall(stackrestore.GlobalValueType(), stackrestore, []llvm.Value{sp}, "")
+}
+
 // createZExtOrTrunc lets the input value fit in the output type bits, by zero
 // extending or truncating the integer.
 func (b *builder) createZExtOrTrunc(value llvm.Value, t llvm.Type) llvm.Value {

compiler/symbol.go

@@ -208,6 +208,12 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 			// > circumstances, and should not be exposed to source languages.
 			llvmutil.AppendToGlobal(c.mod, "llvm.compiler.used", llvmFn)
 		}
+	case "GetModuleHandleExA", "GetProcAddress", "GetSystemInfo", "GetSystemTimeAsFileTime", "LoadLibraryExW", "QueryUnbiasedInterruptTime", "SetEnvironmentVariableA", "Sleep", "VirtualAlloc":
+		// On Windows we need to use a special calling convention for some
+		// external calls.
+		if c.GOOS == "windows" && c.GOARCH == "386" {
+			llvmFn.SetFunctionCallConv(llvm.X86StdcallCallConv)
+		}
 	}
 
 	// External/exported functions may not retain pointer values.

compiler/syscall.go

@@ -268,6 +268,8 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		// The signature looks like this:
 		//   func Syscall(trap, nargs, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 
+		isI386 := strings.HasPrefix(b.Triple, "i386-")
+
 		// Prepare input values.
 		var paramTypes []llvm.Type
 		var params []llvm.Value
@@ -285,11 +287,17 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		if setLastError.IsNil() {
 			llvmType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.ctx.Int32Type()}, false)
 			setLastError = llvm.AddFunction(b.mod, "SetLastError", llvmType)
+			if isI386 {
+				setLastError.SetFunctionCallConv(llvm.X86StdcallCallConv)
+			}
 		}
 		getLastError := b.mod.NamedFunction("GetLastError")
 		if getLastError.IsNil() {
 			llvmType := llvm.FunctionType(b.ctx.Int32Type(), nil, false)
 			getLastError = llvm.AddFunction(b.mod, "GetLastError", llvmType)
+			if isI386 {
+				getLastError.SetFunctionCallConv(llvm.X86StdcallCallConv)
+			}
 		}
 
 		// Now do the actual call. Pseudocode:
@@ -300,9 +308,24 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		// Note that SetLastError/GetLastError could be replaced with direct
 		// access to the thread control block, which is probably smaller and
 		// faster. The Go runtime does this in assembly.
-		b.CreateCall(setLastError.GlobalValueType(), setLastError, []llvm.Value{llvm.ConstNull(b.ctx.Int32Type())}, "")
+		// On windows/386, we also need to save/restore the stack pointer. I'm
+		// not entirely sure why this is needed, but without it these calls
+		// change the stack pointer leading to a crash soon after.
+		setLastErrorCall := b.CreateCall(setLastError.GlobalValueType(), setLastError, []llvm.Value{llvm.ConstNull(b.ctx.Int32Type())}, "")
+		var sp llvm.Value
+		if isI386 {
+			setLastErrorCall.SetInstructionCallConv(llvm.X86StdcallCallConv)
+			sp = b.readStackPointer()
+		}
 		syscallResult := b.CreateCall(llvmType, fnPtr, params, "")
+		if isI386 {
+			syscallResult.SetInstructionCallConv(llvm.X86StdcallCallConv)
+			b.writeStackPointer(sp)
+		}
 		errResult := b.CreateCall(getLastError.GlobalValueType(), getLastError, nil, "err")
+		if isI386 {
+			errResult.SetInstructionCallConv(llvm.X86StdcallCallConv)
+		}
 		if b.uintptrType != b.ctx.Int32Type() {
 			errResult = b.CreateZExt(errResult, b.uintptrType, "err.uintptr")
 		}