chore: upgrade go mod library

vendor/github.com/ebitengine/purego/README.md

@@ -35,7 +35,8 @@ except for float arguments and return values.
 
 ## Example
 
-This example only works on macOS and Linux. For a complete example look at [libc](https://github.com/ebitengine/purego/tree/main/examples/libc) which supports Windows and FreeBSD.
+The example below only showcases purego use for macOS and Linux. The other platforms require special handling which can
+be seen in the complete example at [examples/libc](https://github.com/ebitengine/purego/tree/main/examples/libc) which supports Windows and FreeBSD.
 
 ```go
 package main
@@ -74,7 +75,7 @@ Then to run: `CGO_ENABLED=0 go run main.go`
 ## Questions
 
 If you have questions about how to incorporate purego in your project or want to discuss
-how it works join the [Discord](https://discord.com/channels/842049801528016967/1123106378731487345)!
+how it works join the [Discord](https://discord.gg/HzGZVD6BkY)!
 
 ### External Code
 

vendor/github.com/ebitengine/purego/dlerror.go

@@ -6,6 +6,8 @@
 package purego
 
 // Dlerror represents an error value returned from Dlopen, Dlsym, or Dlclose.
+//
+// This type is not available on Windows as there is no counterpart to it on Windows.
 type Dlerror struct {
 	s string
 }

vendor/github.com/ebitengine/purego/dlfcn.go

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd || linux
+//go:build (darwin || freebsd || linux) && !android && !faketime
 
 package purego
 
@@ -33,6 +33,10 @@ func init() {
 // A second call to Dlopen with the same path will return the same handle, but the internal
 // reference count for the handle will be incremented. Therefore, all
 // Dlopen calls should be balanced with a Dlclose call.
+//
+// This function is not available on Windows.
+// Use [golang.org/x/sys/windows.LoadLibrary], [golang.org/x/sys/windows.LoadLibraryEx],
+// [golang.org/x/sys/windows.NewLazyDLL], or [golang.org/x/sys/windows.NewLazySystemDLL] for Windows instead.
 func Dlopen(path string, mode int) (uintptr, error) {
 	u := fnDlopen(path, mode)
 	if u == 0 {
@@ -45,6 +49,9 @@ func Dlopen(path string, mode int) (uintptr, error) {
 // It returns the address where that symbol is loaded into memory. If the symbol is not found,
 // in the specified library or any of the libraries that were automatically loaded by Dlopen
 // when that library was loaded, Dlsym returns zero.
+//
+// This function is not available on Windows.
+// Use [golang.org/x/sys/windows.GetProcAddress] for Windows instead.
 func Dlsym(handle uintptr, name string) (uintptr, error) {
 	u := fnDlsym(handle, name)
 	if u == 0 {
@@ -56,6 +63,9 @@ func Dlsym(handle uintptr, name string) (uintptr, error) {
 // Dlclose decrements the reference count on the dynamic library handle.
 // If the reference count drops to zero and no other loaded libraries
 // use symbols in it, then the dynamic library is unloaded.
+//
+// This function is not available on Windows.
+// Use [golang.org/x/sys/windows.FreeLibrary] for Windows instead.
 func Dlclose(handle uintptr) error {
 	if fnDlclose(handle) {
 		return Dlerror{fnDlerror()}
@@ -63,11 +73,6 @@ func Dlclose(handle uintptr) error {
 	return nil
 }
 
-//go:linkname openLibrary openLibrary
-func openLibrary(name string) (uintptr, error) {
-	return Dlopen(name, RTLD_NOW|RTLD_GLOBAL)
-}
-
 func loadSymbol(handle uintptr, name string) (uintptr, error) {
 	return Dlsym(handle, name)
 }

vendor/github.com/ebitengine/purego/dlfcn_android.go

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
+
+package purego
+
+import "github.com/ebitengine/purego/internal/cgo"
+
+// Source for constants: https://android.googlesource.com/platform/bionic/+/refs/heads/main/libc/include/dlfcn.h
+
+const (
+	is64bit      = 1 << (^uintptr(0) >> 63) / 2
+	is32bit      = 1 - is64bit
+	RTLD_DEFAULT = is32bit * 0xffffffff
+	RTLD_LAZY    = 0x00000001
+	RTLD_NOW     = is64bit * 0x00000002
+	RTLD_LOCAL   = 0x00000000
+	RTLD_GLOBAL  = is64bit*0x00100 | is32bit*0x00000002
+)
+
+func Dlopen(path string, mode int) (uintptr, error) {
+	return cgo.Dlopen(path, mode)
+}
+
+func Dlsym(handle uintptr, name string) (uintptr, error) {
+	return cgo.Dlsym(handle, name)
+}
+
+func Dlclose(handle uintptr) error {
+	return cgo.Dlclose(handle)
+}
+
+func loadSymbol(handle uintptr, name string) (uintptr, error) {
+	return Dlsym(handle, name)
+}

vendor/github.com/ebitengine/purego/dlfcn_darwin.go

@@ -6,11 +6,11 @@ package purego
 // Source for constants: https://opensource.apple.com/source/dyld/dyld-360.14/include/dlfcn.h.auto.html
 
 const (
-	RTLD_DEFAULT = ^uintptr(0) - 1 // Pseudo-handle for dlsym so search for any loaded symbol
-	RTLD_LAZY    = 0x1             // Relocations are performed at an implementation-dependent time.
-	RTLD_NOW     = 0x2             // Relocations are performed when the object is loaded.
-	RTLD_LOCAL   = 0x4             // All symbols are not made available for relocation processing by other modules.
-	RTLD_GLOBAL  = 0x8             // All symbols are available for relocation processing of other modules.
+	RTLD_DEFAULT = 1<<64 - 2 // Pseudo-handle for dlsym so search for any loaded symbol
+	RTLD_LAZY    = 0x1       // Relocations are performed at an implementation-dependent time.
+	RTLD_NOW     = 0x2       // Relocations are performed when the object is loaded.
+	RTLD_LOCAL   = 0x4       // All symbols are not made available for relocation processing by other modules.
+	RTLD_GLOBAL  = 0x8       // All symbols are available for relocation processing of other modules.
 )
 
 //go:cgo_import_dynamic purego_dlopen dlopen "/usr/lib/libSystem.B.dylib"

vendor/github.com/ebitengine/purego/dlfcn_freebsd.go

@@ -5,9 +5,10 @@ package purego
 
 // Constants as defined in https://github.com/freebsd/freebsd-src/blob/main/include/dlfcn.h
 const (
-	RTLD_DEFAULT = ^uintptr(0) - 2 // Pseudo-handle for dlsym so search for any loaded symbol
-	RTLD_LAZY    = 0x00001         // Relocations are performed at an implementation-dependent time.
-	RTLD_NOW     = 0x00002         // Relocations are performed when the object is loaded.
-	RTLD_LOCAL   = 0x00000         // All symbols are not made available for relocation processing by other modules.
-	RTLD_GLOBAL  = 0x00100         // All symbols are available for relocation processing of other modules.
+	intSize      = 32 << (^uint(0) >> 63) // 32 or 64
+	RTLD_DEFAULT = 1<<intSize - 2         // Pseudo-handle for dlsym so search for any loaded symbol
+	RTLD_LAZY    = 0x00000001             // Relocations are performed at an implementation-dependent time.
+	RTLD_NOW     = 0x00000002             // Relocations are performed when the object is loaded.
+	RTLD_LOCAL   = 0x00000000             // All symbols are not made available for relocation processing by other modules.
+	RTLD_GLOBAL  = 0x00000100             // All symbols are available for relocation processing of other modules.
 )

vendor/github.com/ebitengine/purego/dlfcn_linux.go

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
+//go:build !android
+
 package purego
 
 // Source for constants: https://codebrowser.dev/glibc/glibc/bits/dlfcn.h.html

vendor/github.com/ebitengine/purego/dlfcn_nocgo_linux.go

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build !cgo
+//go:build !cgo && !faketime
 
 package purego
 

vendor/github.com/ebitengine/purego/dlfcn_playground.go

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2024 The Ebitengine Authors
+
+//go:build faketime
+
+package purego
+
+import "errors"
+
+func Dlopen(path string, mode int) (uintptr, error) {
+	return 0, errors.New("Dlopen is not supported in the playground")
+}
+
+func Dlsym(handle uintptr, name string) (uintptr, error) {
+	return 0, errors.New("Dlsym is not supported in the playground")
+}
+
+func Dlclose(handle uintptr) error {
+	return errors.New("Dlclose is not supported in the playground")
+}
+
+func loadSymbol(handle uintptr, name string) (uintptr, error) {
+	return Dlsym(handle, name)
+}

vendor/github.com/ebitengine/purego/dlfcn_stubs.s

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || !cgo && (freebsd ||  linux)
+//go:build darwin || !cgo && (freebsd || linux) && !faketime
 
 #include "textflag.h"
 

vendor/github.com/ebitengine/purego/func.go

@@ -117,6 +117,10 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
 	if cfn == 0 {
 		panic("purego: cfn is nil")
 	}
+	if ty.NumOut() == 1 && (ty.Out(0).Kind() == reflect.Float32 || ty.Out(0).Kind() == reflect.Float64) &&
+		runtime.GOARCH != "arm64" && runtime.GOARCH != "amd64" {
+		panic("purego: float returns are not supported")
+	}
 	{
 		// this code checks how many registers and stack this function will use
 		// to avoid crashing with too many arguments
@@ -126,15 +130,29 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
 		for i := 0; i < ty.NumIn(); i++ {
 			arg := ty.In(i)
 			switch arg.Kind() {
+			case reflect.Func:
+				// This only does preliminary testing to ensure the CDecl argument
+				// is the first argument. Full testing is done when the callback is actually
+				// created in NewCallback.
+				for j := 0; j < arg.NumIn(); j++ {
+					in := arg.In(j)
+					if !in.AssignableTo(reflect.TypeOf(CDecl{})) {
+						continue
+					}
+					if j != 0 {
+						panic("purego: CDecl must be the first argument")
+					}
+				}
 			case reflect.String, reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
-				reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Ptr, reflect.UnsafePointer, reflect.Slice,
-				reflect.Func, reflect.Bool:
+				reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Ptr, reflect.UnsafePointer,
+				reflect.Slice, reflect.Bool:
 				if ints < numOfIntegerRegisters() {
 					ints++
 				} else {
 					stack++
 				}
 			case reflect.Float32, reflect.Float64:
+				const is32bit = unsafe.Sizeof(uintptr(0)) == 4
 				if is32bit {
 					panic("purego: floats only supported on 64bit platforms")
 				}
@@ -250,7 +268,8 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
 				keepAlive = append(keepAlive, val)
 				addInt(val.Pointer())
 			} else if runtime.GOARCH == "arm64" && outType.Size() > maxRegAllocStructSize {
-				if !isAllSameFloat(outType) || outType.NumField() > 4 {
+				isAllFloats, numFields := isAllSameFloat(outType)
+				if !isAllFloats || numFields > 4 {
 					val := reflect.New(outType)
 					keepAlive = append(keepAlive, val)
 					syscall.arm64_r8 = val.Pointer()
@@ -322,8 +341,7 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
 			// We take the address and then dereference it to trick go vet from creating a possible miss-use of unsafe.Pointer
 			v.SetPointer(*(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1)))
 		case reflect.Ptr:
-			// It is safe to have the address of syscall.r1 not escape because it is immediately dereferenced with .Elem()
-			v = reflect.NewAt(outType, runtime_noescape(unsafe.Pointer(&syscall.a1))).Elem()
+			v = reflect.NewAt(outType, unsafe.Pointer(&syscall.a1)).Elem()
 		case reflect.Func:
 			// wrap this C function in a nicely typed Go function
 			v = reflect.New(outType)
@@ -351,20 +369,34 @@ func RegisterFunc(fptr interface{}, cfn uintptr) {
 // maxRegAllocStructSize is the biggest a struct can be while still fitting in registers.
 // if it is bigger than this than enough space must be allocated on the heap and then passed into
 // the function as the first parameter on amd64 or in R8 on arm64.
+//
+// If you change this make sure to update it in objc_runtime_darwin.go
 const maxRegAllocStructSize = 16
 
-func isAllSameFloat(ty reflect.Type) bool {
-	first := ty.Field(0).Type.Kind()
+func isAllSameFloat(ty reflect.Type) (allFloats bool, numFields int) {
+	allFloats = true
+	root := ty.Field(0).Type
+	for root.Kind() == reflect.Struct {
+		root = root.Field(0).Type
+	}
+	first := root.Kind()
 	if first != reflect.Float32 && first != reflect.Float64 {
-		return false
+		allFloats = false
 	}
 	for i := 0; i < ty.NumField(); i++ {
-		f := ty.Field(i)
-		if f.Type.Kind() != first {
-			return false
+		f := ty.Field(i).Type
+		if f.Kind() == reflect.Struct {
+			var structNumFields int
+			allFloats, structNumFields = isAllSameFloat(f)
+			numFields += structNumFields
+			continue
+		}
+		numFields++
+		if f.Kind() != first {
+			allFloats = false
 		}
 	}
-	return true
+	return allFloats, numFields
 }
 
 func checkStructFieldsSupported(ty reflect.Type) {
@@ -386,8 +418,6 @@ func checkStructFieldsSupported(ty reflect.Type) {
 	}
 }
 
-const is32bit = unsafe.Sizeof(uintptr(0)) == 4
-
 func roundUpTo8(val uintptr) uintptr {
 	return (val + 7) &^ 7
 }
@@ -398,12 +428,9 @@ func numOfIntegerRegisters() int {
 		return 8
 	case "amd64":
 		return 6
-	// TODO: figure out why 386 tests are not working
-	/*case "386":
-		return 0
-	case "arm":
-		return 4*/
 	default:
-		panic("purego: unknown GOARCH (" + runtime.GOARCH + ")")
+		// since this platform isn't supported and can therefore only access
+		// integer registers it is fine to return the maxArgs
+		return maxArgs
 	}
 }

vendor/github.com/ebitengine/purego/go_runtime.go

@@ -11,7 +11,3 @@ import (
 
 //go:linkname runtime_cgocall runtime.cgocall
 func runtime_cgocall(fn uintptr, arg unsafe.Pointer) int32 // from runtime/sys_libc.go
-
-//go:linkname runtime_noescape runtime.noescape
-//go:noescape
-func runtime_noescape(p unsafe.Pointer) unsafe.Pointer // from runtime/stubs.go

vendor/github.com/ebitengine/purego/internal/cgo/dlfcn_cgo_unix.go

@@ -9,9 +9,43 @@ package cgo
  #cgo LDFLAGS: -ldl
 
 #include <dlfcn.h>
+#include <stdlib.h>
 */
 import "C"
 
+import (
+	"errors"
+	"unsafe"
+)
+
+func Dlopen(filename string, flag int) (uintptr, error) {
+	cfilename := C.CString(filename)
+	defer C.free(unsafe.Pointer(cfilename))
+	handle := C.dlopen(cfilename, C.int(flag))
+	if handle == nil {
+		return 0, errors.New(C.GoString(C.dlerror()))
+	}
+	return uintptr(handle), nil
+}
+
+func Dlsym(handle uintptr, symbol string) (uintptr, error) {
+	csymbol := C.CString(symbol)
+	defer C.free(unsafe.Pointer(csymbol))
+	symbolAddr := C.dlsym(*(*unsafe.Pointer)(unsafe.Pointer(&handle)), csymbol)
+	if symbolAddr == nil {
+		return 0, errors.New(C.GoString(C.dlerror()))
+	}
+	return uintptr(symbolAddr), nil
+}
+
+func Dlclose(handle uintptr) error {
+	result := C.dlclose(*(*unsafe.Pointer)(unsafe.Pointer(&handle)))
+	if result != 0 {
+		return errors.New(C.GoString(C.dlerror()))
+	}
+	return nil
+}
+
 // all that is needed is to assign each dl function because then its
 // symbol will then be made available to the linker and linked to inside dlfcn.go
 var (

vendor/github.com/ebitengine/purego/internal/cgo/syscall_cgo_unix.go

@@ -20,7 +20,7 @@ typedef struct syscall15Args {
 	uintptr_t fn;
 	uintptr_t a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15;
 	uintptr_t f1, f2, f3, f4, f5, f6, f7, f8;
-	uintptr_t r1, r2, err;
+	uintptr_t err;
 } syscall15Args;
 
 void syscall15(struct syscall15Args *args) {
@@ -31,7 +31,7 @@ void syscall15(struct syscall15Args *args) {
 	*(void**)(&func_name) = (void*)(args->fn);
 	uintptr_t r1 =  func_name(args->a1,args->a2,args->a3,args->a4,args->a5,args->a6,args->a7,args->a8,args->a9,
 		args->a10,args->a11,args->a12,args->a13,args->a14,args->a15);
-	args->r1 = r1;
+	args->a1 = r1;
 	args->err = errno;
 }
 
@@ -48,8 +48,8 @@ func Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14,
 		C.uintptr_t(fn), C.uintptr_t(a1), C.uintptr_t(a2), C.uintptr_t(a3),
 		C.uintptr_t(a4), C.uintptr_t(a5), C.uintptr_t(a6),
 		C.uintptr_t(a7), C.uintptr_t(a8), C.uintptr_t(a9), C.uintptr_t(a10), C.uintptr_t(a11), C.uintptr_t(a12),
-		C.uintptr_t(a13), C.uintptr_t(a14), C.uintptr_t(a15), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		C.uintptr_t(a13), C.uintptr_t(a14), C.uintptr_t(a15), 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	}
 	C.syscall15(&args)
-	return uintptr(args.r1), uintptr(args.r2), uintptr(args.err)
+	return uintptr(args.a1), 0, uintptr(args.err)
 }

vendor/github.com/ebitengine/purego/internal/fakecgo/callbacks.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || freebsd || linux
+//go:build !cgo && (darwin || freebsd || linux)
 
 package fakecgo
 

vendor/github.com/ebitengine/purego/internal/fakecgo/doc.go

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd
+//go:build !cgo && (darwin || freebsd || linux)
 
 // Package fakecgo implements the Cgo runtime (runtime/cgo) entirely in Go.
 // This allows code that calls into C to function properly when CGO_ENABLED=0.
@@ -30,4 +30,3 @@
 package fakecgo
 
 //go:generate go run gen.go
-//go:generate gofmt -s -w symbols.go

vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin_amd64.go

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !cgo
+
 package fakecgo
 
 import "unsafe"

vendor/github.com/ebitengine/purego/internal/fakecgo/go_darwin_arm64.go

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !cgo
+
 package fakecgo
 
 import "unsafe"

vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd_amd64.go

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !cgo
+
 package fakecgo
 
 import "unsafe"

vendor/github.com/ebitengine/purego/internal/fakecgo/go_freebsd_arm64.go

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !cgo
+
 package fakecgo
 
 import "unsafe"
@@ -14,7 +16,7 @@ func _cgo_sys_thread_start(ts *ThreadStart) {
 	var size size_t
 	var err int
 
-	//fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug
+	// fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug
 	sigfillset(&ign)
 	pthread_sigmask(SIG_SETMASK, &ign, &oset)
 

vendor/github.com/ebitengine/purego/internal/fakecgo/go_libinit.go

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd || linux
+//go:build !cgo && (darwin || freebsd || linux)
 
 package fakecgo
 
@@ -50,9 +50,11 @@ func _cgo_try_pthread_create(thread *pthread_t, attr *pthread_attr_t, pfn unsafe
 	var err int
 
 	for tries = 0; tries < 20; tries++ {
-		err = int(pthread_create(thread, attr, pfn, unsafe.Pointer(arg)))
+		// inlined this call because it ran out of stack when inlining was disabled
+		err = int(call5(pthread_createABI0, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(pfn), uintptr(unsafe.Pointer(arg)), 0))
 		if err == 0 {
-			pthread_detach(*thread)
+			// inlined this call because it ran out of stack when inlining was disabled
+			call5(pthread_detachABI0, uintptr(*thread), 0, 0, 0, 0)
 			return 0
 		}
 		if err != int(syscall.EAGAIN) {
@@ -60,7 +62,8 @@ func _cgo_try_pthread_create(thread *pthread_t, attr *pthread_attr_t, pfn unsafe
 		}
 		ts.Sec = 0
 		ts.Nsec = (tries + 1) * 1000 * 1000 // Milliseconds.
-		nanosleep(&ts, nil)
+		// inlined this call because it ran out of stack when inlining was disabled
+		call5(nanosleepABI0, uintptr(unsafe.Pointer(&ts)), 0, 0, 0, 0)
 	}
 	return int(syscall.EAGAIN)
 }

vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux_amd64.go

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !cgo
+
 package fakecgo
 
 import "unsafe"

vendor/github.com/ebitengine/purego/internal/fakecgo/go_linux_arm64.go

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build !cgo
+
 package fakecgo
 
 import "unsafe"

vendor/github.com/ebitengine/purego/internal/fakecgo/go_setenv.go

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd || linux
+//go:build !cgo && (darwin || freebsd || linux)
 
 package fakecgo
 

vendor/github.com/ebitengine/purego/internal/fakecgo/go_util.go

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd || linux
+//go:build !cgo && (darwin || freebsd || linux)
 
 package fakecgo
 
@@ -27,7 +27,11 @@ func x_cgo_thread_start(arg *ThreadStart) {
 		println("fakecgo: out of memory in thread_start")
 		abort()
 	}
-	// *ts = *arg would cause a writebarrier so use memmove instead
-	memmove(unsafe.Pointer(ts), unsafe.Pointer(arg), unsafe.Sizeof(*ts))
+	// *ts = *arg would cause a writebarrier so copy using slices
+	s1 := unsafe.Slice((*uintptr)(unsafe.Pointer(ts)), unsafe.Sizeof(*ts)/8)
+	s2 := unsafe.Slice((*uintptr)(unsafe.Pointer(arg)), unsafe.Sizeof(*arg)/8)
+	for i := range s2 {
+		s1[i] = s2[i]
+	}
 	_cgo_sys_thread_start(ts) // OS-dependent half
 }

vendor/github.com/ebitengine/purego/internal/fakecgo/iscgo.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || freebsd || linux
+//go:build !cgo && (darwin || freebsd || linux)
 
 // The runtime package contains an uninitialized definition
 // for runtime·iscgo. Override it to tell the runtime we're here.

vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo.go

@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd || linux
+//go:build !cgo && (darwin || freebsd || linux)
 
 package fakecgo
 
 type (
-	size_t         uintptr
+	size_t uintptr
+	// Sources:
+	// Darwin (32 bytes) - https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/sys/_types.h#L74
+	// FreeBSD (32 bytes) - https://github.com/DoctorWkt/xv6-freebsd/blob/d2a294c2a984baed27676068b15ed9a29b06ab6f/include/signal.h#L98C9-L98C21
+	// Linux (128 bytes) - https://github.com/torvalds/linux/blob/ab75170520d4964f3acf8bb1f91d34cbc650688e/arch/x86/include/asm/signal.h#L25
 	sigset_t       [128]byte
 	pthread_attr_t [64]byte
 	pthread_t      int

vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_darwin.go

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
+//go:build !cgo
+
 package fakecgo
 
 type (

vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_freebsd.go

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
+//go:build !cgo
+
 package fakecgo
 
 type (

vendor/github.com/ebitengine/purego/internal/fakecgo/libcgo_linux.go

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
+//go:build !cgo
+
 package fakecgo
 
 type (

vendor/github.com/ebitengine/purego/internal/fakecgo/setenv.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || freebsd || linux
+//go:build !cgo && (darwin || freebsd || linux)
 
 package fakecgo
 

vendor/github.com/ebitengine/purego/internal/fakecgo/symbols.go

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd || linux
+//go:build !cgo && (darwin || freebsd || linux)
 
 package fakecgo
 
@@ -15,90 +15,107 @@ import (
 // setg_trampoline calls setg with the G provided
 func setg_trampoline(setg uintptr, G uintptr)
 
-//go:linkname memmove runtime.memmove
-func memmove(to, from unsafe.Pointer, n uintptr)
-
 // call5 takes fn the C function and 5 arguments and calls the function with those arguments
 func call5(fn, a1, a2, a3, a4, a5 uintptr) uintptr
 
+//go:nosplit
 func malloc(size uintptr) unsafe.Pointer {
 	ret := call5(mallocABI0, uintptr(size), 0, 0, 0, 0)
 	// this indirection is to avoid go vet complaining about possible misuse of unsafe.Pointer
 	return *(*unsafe.Pointer)(unsafe.Pointer(&ret))
 }
 
+//go:nosplit
 func free(ptr unsafe.Pointer) {
 	call5(freeABI0, uintptr(ptr), 0, 0, 0, 0)
 }
 
+//go:nosplit
 func setenv(name *byte, value *byte, overwrite int32) int32 {
 	return int32(call5(setenvABI0, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)), uintptr(overwrite), 0, 0))
 }
 
+//go:nosplit
 func unsetenv(name *byte) int32 {
 	return int32(call5(unsetenvABI0, uintptr(unsafe.Pointer(name)), 0, 0, 0, 0))
 }
 
+//go:nosplit
 func sigfillset(set *sigset_t) int32 {
 	return int32(call5(sigfillsetABI0, uintptr(unsafe.Pointer(set)), 0, 0, 0, 0))
 }
 
+//go:nosplit
 func nanosleep(ts *syscall.Timespec, rem *syscall.Timespec) int32 {
 	return int32(call5(nanosleepABI0, uintptr(unsafe.Pointer(ts)), uintptr(unsafe.Pointer(rem)), 0, 0, 0))
 }
 
+//go:nosplit
 func abort() {
 	call5(abortABI0, 0, 0, 0, 0, 0)
 }
 
+//go:nosplit
 func pthread_attr_init(attr *pthread_attr_t) int32 {
 	return int32(call5(pthread_attr_initABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0))
 }
 
+//go:nosplit
 func pthread_create(thread *pthread_t, attr *pthread_attr_t, start unsafe.Pointer, arg unsafe.Pointer) int32 {
 	return int32(call5(pthread_createABI0, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(start), uintptr(arg), 0))
 }
 
+//go:nosplit
 func pthread_detach(thread pthread_t) int32 {
 	return int32(call5(pthread_detachABI0, uintptr(thread), 0, 0, 0, 0))
 }
 
+//go:nosplit
 func pthread_sigmask(how sighow, ign *sigset_t, oset *sigset_t) int32 {
 	return int32(call5(pthread_sigmaskABI0, uintptr(how), uintptr(unsafe.Pointer(ign)), uintptr(unsafe.Pointer(oset)), 0, 0))
 }
 
+//go:nosplit
 func pthread_self() pthread_t {
 	return pthread_t(call5(pthread_selfABI0, 0, 0, 0, 0, 0))
 }
 
+//go:nosplit
 func pthread_get_stacksize_np(thread pthread_t) size_t {
 	return size_t(call5(pthread_get_stacksize_npABI0, uintptr(thread), 0, 0, 0, 0))
 }
 
+//go:nosplit
 func pthread_attr_getstacksize(attr *pthread_attr_t, stacksize *size_t) int32 {
 	return int32(call5(pthread_attr_getstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(stacksize)), 0, 0, 0))
 }
 
+//go:nosplit
 func pthread_attr_setstacksize(attr *pthread_attr_t, size size_t) int32 {
 	return int32(call5(pthread_attr_setstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(size), 0, 0, 0))
 }
 
+//go:nosplit
 func pthread_attr_destroy(attr *pthread_attr_t) int32 {
 	return int32(call5(pthread_attr_destroyABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0))
 }
 
+//go:nosplit
 func pthread_mutex_lock(mutex *pthread_mutex_t) int32 {
 	return int32(call5(pthread_mutex_lockABI0, uintptr(unsafe.Pointer(mutex)), 0, 0, 0, 0))
 }
 
+//go:nosplit
 func pthread_mutex_unlock(mutex *pthread_mutex_t) int32 {
 	return int32(call5(pthread_mutex_unlockABI0, uintptr(unsafe.Pointer(mutex)), 0, 0, 0, 0))
 }
 
+//go:nosplit
 func pthread_cond_broadcast(cond *pthread_cond_t) int32 {
 	return int32(call5(pthread_cond_broadcastABI0, uintptr(unsafe.Pointer(cond)), 0, 0, 0, 0))
 }
 
+//go:nosplit
 func pthread_setspecific(key pthread_key_t, value unsafe.Pointer) int32 {
 	return int32(call5(pthread_setspecificABI0, uintptr(key), uintptr(value), 0, 0, 0))
 }

vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_darwin.go

@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
+//go:build !cgo
+
 package fakecgo
 
 //go:cgo_import_dynamic purego_malloc malloc "/usr/lib/libSystem.B.dylib"

vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_freebsd.go

@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
+//go:build !cgo
+
 package fakecgo
 
 //go:cgo_import_dynamic purego_malloc malloc "libc.so.7"

vendor/github.com/ebitengine/purego/internal/fakecgo/symbols_linux.go

@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
+//go:build !cgo
+
 package fakecgo
 
 //go:cgo_import_dynamic purego_malloc malloc "libc.so.6"

vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_amd64.s

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || linux || freebsd
+//go:build !cgo && (darwin || linux || freebsd)
 
 /*
 trampoline for emulating required C functions for cgo in go (see cgo.go)

vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_arm64.s

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd || linux
+//go:build !cgo && (darwin || freebsd || linux)
 
 #include "textflag.h"
 #include "go_asm.h"

vendor/github.com/ebitengine/purego/internal/fakecgo/trampolines_stubs.s

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd || linux
+//go:build !cgo && (darwin || freebsd || linux)
 
 #include "textflag.h"
 

vendor/github.com/ebitengine/purego/struct_amd64.go

@@ -111,7 +111,7 @@ func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFl
 	return keepAlive
 }
 
-func postMerger(t reflect.Type) bool {
+func postMerger(t reflect.Type) (passInMemory bool) {
 	// (c) If the size of the aggregate exceeds two eightbytes and the first eight- byte isn’t SSE or any other
 	// eightbyte isn’t SSEUP, the whole argument is passed in memory.
 	if t.Kind() != reflect.Struct {
@@ -120,19 +120,7 @@ func postMerger(t reflect.Type) bool {
 	if t.Size() <= 2*8 {
 		return false
 	}
-	first := getFirst(t).Kind()
-	if first != reflect.Float32 && first != reflect.Float64 {
-		return false
-	}
-	return true
-}
-
-func getFirst(t reflect.Type) reflect.Type {
-	first := t.Field(0).Type
-	if first.Kind() == reflect.Struct {
-		return getFirst(first)
-	}
-	return first
+	return true // Go does not have an SSE/SEEUP type so this is always true
 }
 
 func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) (ok bool) {
@@ -196,7 +184,7 @@ func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintp
 				val |= uint64(f.Int()&0xFFFF_FFFF) << shift
 				shift += 32
 				class |= _INTEGER
-			case reflect.Int64:
+			case reflect.Int64, reflect.Int:
 				val = uint64(f.Int())
 				shift = 64
 				class = _INTEGER
@@ -212,7 +200,7 @@ func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintp
 				val |= f.Uint() << shift
 				shift += 32
 				class |= _INTEGER
-			case reflect.Uint64:
+			case reflect.Uint64, reflect.Uint:
 				val = f.Uint()
 				shift = 64
 				class = _INTEGER

vendor/github.com/ebitengine/purego/struct_arm64.go

@@ -16,17 +16,17 @@ func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) {
 		return reflect.New(outType).Elem()
 	case outSize <= 8:
 		r1 := syscall.a1
-		if isAllSameFloat(outType) {
+		if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
 			r1 = syscall.f1
-			if outType.NumField() == 2 {
+			if numFields == 2 {
 				r1 = syscall.f2<<32 | syscall.f1
 			}
 		}
 		return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{r1})).Elem()
 	case outSize <= 16:
 		r1, r2 := syscall.a1, syscall.a2
-		if isAllSameFloat(outType) {
-			switch outType.NumField() {
+		if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
+			switch numFields {
 			case 4:
 				r1 = syscall.f2<<32 | syscall.f1
 				r2 = syscall.f4<<32 | syscall.f3
@@ -42,8 +42,8 @@ func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) {
 		}
 		return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem()
 	default:
-		if isAllSameFloat(outType) && outType.NumField() <= 4 {
-			switch outType.NumField() {
+		if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats && numFields <= 4 {
+			switch numFields {
 			case 4:
 				return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b, c, d uintptr }{syscall.f1, syscall.f2, syscall.f3, syscall.f4})).Elem()
 			case 3:

vendor/github.com/ebitengine/purego/sys_amd64.s

@@ -122,6 +122,9 @@ TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
 
 	PUSHQ R10 // push the stack pointer below registers
 
+	// Switch from the host ABI to the Go ABI.
+	PUSH_REGS_HOST_TO_ABI0()
+
 	// determine index into runtime·cbs table
 	MOVQ $callbackasm(SB), DX
 	SUBQ DX, AX
@@ -130,9 +133,6 @@ TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
 	DIVL CX
 	SUBQ $1, AX               // subtract 1 because return PC is to the next slot
 
-	// Switch from the host ABI to the Go ABI.
-	PUSH_REGS_HOST_TO_ABI0()
-
 	// Create a struct callbackArgs on our stack to be passed as
 	// the "frame" to cgocallback and on to callbackWrap.
 	// $24 to make enough room for the arguments to runtime.cgocallback

vendor/github.com/ebitengine/purego/syscall.go

@@ -5,11 +5,24 @@
 
 package purego
 
+// CDecl marks a function as being called using the __cdecl calling convention as defined in
+// the [MSDocs] when passed to NewCallback. It must be the first argument to the function.
+// This is only useful on 386 Windows, but it is safe to use on other platforms.
+//
+// [MSDocs]: https://learn.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170
+type CDecl struct{}
+
 const (
 	maxArgs     = 15
 	numOfFloats = 8 // arm64 and amd64 both have 8 float registers
 )
 
+type syscall15Args struct {
+	fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
+	f1, f2, f3, f4, f5, f6, f7, f8                                       uintptr
+	arm64_r8                                                             uintptr
+}
+
 // SyscallN takes fn, a C function pointer and a list of arguments as uintptr.
 // There is an internal maximum number of arguments that SyscallN can take. It panics
 // when the maximum is exceeded. It returns the result and the libc error code if there is one.

vendor/github.com/ebitengine/purego/syscall_cgo_linux.go

@@ -6,21 +6,11 @@
 package purego
 
 import (
-	_ "unsafe" // for go:linkname
-
 	"github.com/ebitengine/purego/internal/cgo"
 )
 
 var syscall15XABI0 = uintptr(cgo.Syscall15XABI0)
 
-// this is only here to make the assembly files happy :)
-type syscall15Args struct {
-	fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
-	f1, f2, f3, f4, f5, f6, f7, f8                                       uintptr
-	r1, r2, err                                                          uintptr
-	arm64_r8                                                             uintptr
-}
-
 //go:nosplit
 func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
 	return cgo.Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)

vendor/github.com/ebitengine/purego/syscall_sysv.go

@@ -14,12 +14,6 @@ import (
 
 var syscall15XABI0 uintptr
 
-type syscall15Args struct {
-	fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
-	f1, f2, f3, f4, f5, f6, f7, f8                                       uintptr
-	arm64_r8                                                             uintptr
-}
-
 //go:nosplit
 func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
 	args := syscall15Args{
@@ -38,6 +32,16 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a
 // for these callbacks is never released. At least 2000 callbacks can always be created. Although this function
 // provides similar functionality to windows.NewCallback it is distinct.
 func NewCallback(fn interface{}) uintptr {
+	ty := reflect.TypeOf(fn)
+	for i := 0; i < ty.NumIn(); i++ {
+		in := ty.In(i)
+		if !in.AssignableTo(reflect.TypeOf(CDecl{})) {
+			continue
+		}
+		if i != 0 {
+			panic("purego: CDecl must be the first argument")
+		}
+	}
 	return compileCallback(fn)
 }
 
@@ -79,7 +83,12 @@ func compileCallback(fn interface{}) uintptr {
 	for i := 0; i < ty.NumIn(); i++ {
 		in := ty.In(i)
 		switch in.Kind() {
-		case reflect.Struct, reflect.Interface, reflect.Func, reflect.Slice,
+		case reflect.Struct:
+			if i == 0 && in.AssignableTo(reflect.TypeOf(CDecl{})) {
+				continue
+			}
+			fallthrough
+		case reflect.Interface, reflect.Func, reflect.Slice,
 			reflect.Chan, reflect.Complex64, reflect.Complex128,
 			reflect.String, reflect.Map, reflect.Invalid:
 			panic("purego: unsupported argument type: " + in.Kind().String())
@@ -149,7 +158,12 @@ func callbackWrap(a *callbackArgs) {
 				pos = floatsN
 			}
 			floatsN++
+		case reflect.Struct:
+			// This is the CDecl field
+			args[i] = reflect.Zero(fnType.In(i))
+			continue
 		default:
+
 			if intsN >= numOfIntegerRegisters() {
 				pos = stack
 				stack++

vendor/github.com/ebitengine/purego/syscall_windows.go

@@ -4,20 +4,12 @@
 package purego
 
 import (
+	"reflect"
 	"syscall"
-	_ "unsafe" // only for go:linkname
-
-	"golang.org/x/sys/windows"
 )
 
 var syscall15XABI0 uintptr
 
-type syscall15Args struct {
-	fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr
-	f1, f2, f3, f4, f5, f6, f7, f8                                       uintptr
-	arm64_r8                                                             uintptr
-}
-
 func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) {
 	r1, r2, errno := syscall.Syscall15(fn, 15, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
 	return r1, r2, uintptr(errno)
@@ -31,15 +23,24 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a
 // callbacks can always be created. Although this function is similiar to the darwin version it may act
 // differently.
 func NewCallback(fn interface{}) uintptr {
+	isCDecl := false
+	ty := reflect.TypeOf(fn)
+	for i := 0; i < ty.NumIn(); i++ {
+		in := ty.In(i)
+		if !in.AssignableTo(reflect.TypeOf(CDecl{})) {
+			continue
+		}
+		if i != 0 {
+			panic("purego: CDecl must be the first argument")
+		}
+		isCDecl = true
+	}
+	if isCDecl {
+		return syscall.NewCallbackCDecl(fn)
+	}
 	return syscall.NewCallback(fn)
 }
 
-//go:linkname openLibrary openLibrary
-func openLibrary(name string) (uintptr, error) {
-	handle, err := windows.LoadLibrary(name)
-	return uintptr(handle), err
-}
-
 func loadSymbol(handle uintptr, name string) (uintptr, error) {
-	return windows.GetProcAddress(windows.Handle(handle), name)
+	return syscall.GetProcAddress(syscall.Handle(handle), name)
 }