slidge-whatsapp 0.3.0__cp311-cp311-manylinux_2_36_aarch64.whl → 0.3.1__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/github.com/ebitengine/purego/struct_loong64.go

@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
+
+package purego
+
+import (
+	"math"
+	"reflect"
+	"unsafe"
+)
+
+func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) {
+	outSize := outType.Size()
+	switch {
+	case outSize == 0:
+		return reflect.New(outType).Elem()
+	case outSize <= 8:
+		r1 := syscall.a1
+		if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
+			r1 = syscall.f1
+			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 isAllFloats, numFields := isAllSameFloat(outType); isAllFloats {
+			switch numFields {
+			case 4:
+				r1 = syscall.f2<<32 | syscall.f1
+				r2 = syscall.f4<<32 | syscall.f3
+			case 3:
+				r1 = syscall.f2<<32 | syscall.f1
+				r2 = syscall.f3
+			case 2:
+				r1 = syscall.f1
+				r2 = syscall.f2
+			default:
+				panic("unreachable")
+			}
+		}
+		return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem()
+	default:
+		// create struct from the Go pointer created above
+		// weird pointer dereference to circumvent go vet
+		return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))).Elem()
+	}
+}
+
+const (
+	_NO_CLASS = 0b00
+	_FLOAT    = 0b01
+	_INT      = 0b11
+)
+
+func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any {
+	if v.Type().Size() == 0 {
+		return keepAlive
+	}
+
+	if size := v.Type().Size(); size <= 16 {
+		placeRegisters(v, addFloat, addInt)
+	} else {
+		keepAlive = placeStack(v, keepAlive, addInt)
+	}
+	return keepAlive // the struct was allocated so don't panic
+}
+
+func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) {
+	var val uint64
+	var shift byte
+	var flushed bool
+	class := _NO_CLASS
+	var place func(v reflect.Value)
+	place = func(v reflect.Value) {
+		var numFields int
+		if v.Kind() == reflect.Struct {
+			numFields = v.Type().NumField()
+		} else {
+			numFields = v.Type().Len()
+		}
+		for k := 0; k < numFields; k++ {
+			flushed = false
+			var f reflect.Value
+			if v.Kind() == reflect.Struct {
+				f = v.Field(k)
+			} else {
+				f = v.Index(k)
+			}
+			align := byte(f.Type().Align()*8 - 1)
+			shift = (shift + align) &^ align
+			if shift >= 64 {
+				shift = 0
+				flushed = true
+				if class == _FLOAT {
+					addFloat(uintptr(val))
+				} else {
+					addInt(uintptr(val))
+				}
+			}
+			switch f.Type().Kind() {
+			case reflect.Struct:
+				place(f)
+			case reflect.Bool:
+				if f.Bool() {
+					val |= 1
+				}
+				shift += 8
+				class |= _INT
+			case reflect.Uint8:
+				val |= f.Uint() << shift
+				shift += 8
+				class |= _INT
+			case reflect.Uint16:
+				val |= f.Uint() << shift
+				shift += 16
+				class |= _INT
+			case reflect.Uint32:
+				val |= f.Uint() << shift
+				shift += 32
+				class |= _INT
+			case reflect.Uint64, reflect.Uint, reflect.Uintptr:
+				addInt(uintptr(f.Uint()))
+				shift = 0
+				flushed = true
+				class = _NO_CLASS
+			case reflect.Int8:
+				val |= uint64(f.Int()&0xFF) << shift
+				shift += 8
+				class |= _INT
+			case reflect.Int16:
+				val |= uint64(f.Int()&0xFFFF) << shift
+				shift += 16
+				class |= _INT
+			case reflect.Int32:
+				val |= uint64(f.Int()&0xFFFF_FFFF) << shift
+				shift += 32
+				class |= _INT
+			case reflect.Int64, reflect.Int:
+				addInt(uintptr(f.Int()))
+				shift = 0
+				flushed = true
+				class = _NO_CLASS
+			case reflect.Float32:
+				if class == _FLOAT {
+					addFloat(uintptr(val))
+					val = 0
+					shift = 0
+				}
+				val |= uint64(math.Float32bits(float32(f.Float()))) << shift
+				shift += 32
+				class |= _FLOAT
+			case reflect.Float64:
+				addFloat(uintptr(math.Float64bits(float64(f.Float()))))
+				shift = 0
+				flushed = true
+				class = _NO_CLASS
+			case reflect.Ptr:
+				addInt(f.Pointer())
+				shift = 0
+				flushed = true
+				class = _NO_CLASS
+			case reflect.Array:
+				place(f)
+			default:
+				panic("purego: unsupported kind " + f.Kind().String())
+			}
+		}
+	}
+	place(v)
+	if !flushed {
+		if class == _FLOAT {
+			addFloat(uintptr(val))
+		} else {
+			addInt(uintptr(val))
+		}
+	}
+}
+
+func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any {
+	// Struct is too big to be placed in registers.
+	// Copy to heap and place the pointer in register
+	ptrStruct := reflect.New(v.Type())
+	ptrStruct.Elem().Set(v)
+	ptr := ptrStruct.Elem().Addr().UnsafePointer()
+	keepAlive = append(keepAlive, ptr)
+	addInt(uintptr(ptr))
+	return keepAlive
+}

slidge_whatsapp/vendor/github.com/ebitengine/purego/struct_other.go

@@ -1,16 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors
 
-//go:build !amd64 && !arm64
+//go:build !amd64 && !arm64 && !loong64
 
 package purego
 
 import "reflect"
 
-func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []interface{}) []interface{} {
+func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any {
 	panic("purego: struct arguments are not supported")
 }
 
 func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) {
 	panic("purego: struct returns are not supported")
 }
+
+func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) {
+	panic("purego: not needed on other platforms")
+}

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

@@ -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 || netbsd
 
 #include "textflag.h"
 #include "abi_amd64.h"

slidge_whatsapp/vendor/github.com/ebitengine/purego/sys_arm64.s

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

slidge_whatsapp/vendor/github.com/ebitengine/purego/sys_loong64.s

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
+
+//go:build linux
+
+#include "textflag.h"
+#include "go_asm.h"
+#include "funcdata.h"
+
+#define STACK_SIZE 64
+#define PTR_ADDRESS (STACK_SIZE - 8)
+
+// syscall15X calls a function in libc on behalf of the syscall package.
+// syscall15X takes a pointer to a struct like:
+// struct {
+//	fn    uintptr
+//	a1    uintptr
+//	a2    uintptr
+//	a3    uintptr
+//	a4    uintptr
+//	a5    uintptr
+//	a6    uintptr
+//	a7    uintptr
+//	a8    uintptr
+//	a9    uintptr
+//	a10    uintptr
+//	a11    uintptr
+//	a12    uintptr
+//	a13    uintptr
+//	a14    uintptr
+//	a15    uintptr
+//	r1    uintptr
+//	r2    uintptr
+//	err   uintptr
+// }
+// syscall15X must be called on the g0 stack with the
+// C calling convention (use libcCall).
+GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8
+DATA ·syscall15XABI0(SB)/8, $syscall15X(SB)
+TEXT syscall15X(SB), NOSPLIT, $0
+	// push structure pointer
+	SUBV	$STACK_SIZE, R3
+	MOVV	R4, PTR_ADDRESS(R3)
+	MOVV	R4, R13
+
+	MOVD	syscall15Args_f1(R13), F0	// f1
+	MOVD	syscall15Args_f2(R13), F1	// f2
+	MOVD	syscall15Args_f3(R13), F2	// f3
+	MOVD	syscall15Args_f4(R13), F3	// f4
+	MOVD	syscall15Args_f5(R13), F4	// f5
+	MOVD	syscall15Args_f6(R13), F5	// f6
+	MOVD	syscall15Args_f7(R13), F6	// f7
+	MOVD	syscall15Args_f8(R13), F7	// f8
+
+	MOVV	syscall15Args_a1(R13), R4	// a1
+	MOVV	syscall15Args_a2(R13), R5	// a2
+	MOVV	syscall15Args_a3(R13), R6	// a3
+	MOVV	syscall15Args_a4(R13), R7	// a4
+	MOVV	syscall15Args_a5(R13), R8	// a5
+	MOVV	syscall15Args_a6(R13), R9	// a6
+	MOVV	syscall15Args_a7(R13), R10	// a7
+	MOVV	syscall15Args_a8(R13), R11	// a8
+
+	// push a9-a15 onto stack
+	MOVV	syscall15Args_a9(R13), R12
+	MOVV	R12, 0(R3)
+	MOVV	syscall15Args_a10(R13), R12
+	MOVV	R12, 8(R3)
+	MOVV	syscall15Args_a11(R13), R12
+	MOVV	R12, 16(R3)
+	MOVV	syscall15Args_a12(R13), R12
+	MOVV	R12, 24(R3)
+	MOVV	syscall15Args_a13(R13), R12
+	MOVV	R12, 32(R3)
+	MOVV	syscall15Args_a14(R13), R12
+	MOVV	R12, 40(R3)
+	MOVV	syscall15Args_a15(R13), R12
+	MOVV	R12, 48(R3)
+
+	MOVV	syscall15Args_fn(R13), R12
+	JAL	(R12)
+
+	// pop structure pointer
+	MOVV	PTR_ADDRESS(R3), R13
+	ADDV	$STACK_SIZE, R3
+
+	// save R4, R5
+	MOVV	R4, syscall15Args_a1(R13)
+	MOVV	R5, syscall15Args_a2(R13)
+
+	// save f0-f3
+	MOVD	F0, syscall15Args_f1(R13)
+	MOVD	F1, syscall15Args_f2(R13)
+	MOVD	F2, syscall15Args_f3(R13)
+	MOVD	F3, syscall15Args_f4(R13)
+	RET

slidge_whatsapp/vendor/github.com/ebitengine/purego/sys_unix_arm64.s

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023 The Ebitengine Authors
 
-//go:build darwin || freebsd || linux
+//go:build darwin || freebsd || linux || netbsd
 
 #include "textflag.h"
 #include "go_asm.h"

slidge_whatsapp/vendor/github.com/ebitengine/purego/sys_unix_loong64.s

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2025 The Ebitengine Authors
+
+//go:build linux
+
+#include "textflag.h"
+#include "go_asm.h"
+#include "funcdata.h"
+#include "abi_loong64.h"
+
+TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
+	NO_LOCAL_POINTERS
+
+	SUBV	$(16*8), R3, R14
+	MOVD	F0, 0(R14)
+	MOVD	F1, 8(R14)
+	MOVD	F2, 16(R14)
+	MOVD	F3, 24(R14)
+	MOVD	F4, 32(R14)
+	MOVD	F5, 40(R14)
+	MOVD	F6, 48(R14)
+	MOVD	F7, 56(R14)
+	MOVV	R4, 64(R14)
+	MOVV	R5, 72(R14)
+	MOVV	R6, 80(R14)
+	MOVV	R7, 88(R14)
+	MOVV	R8, 96(R14)
+	MOVV	R9, 104(R14)
+	MOVV	R10, 112(R14)
+	MOVV	R11, 120(R14)
+
+	// Adjust SP by frame size.
+	SUBV	$(22*8), R3
+
+	// It is important to save R30 because the go assembler
+	// uses it for move instructions for a variable.
+	// This line:
+	// MOVV ·callbackWrap_call(SB), R4
+	// Creates the instructions:
+	// PCALAU12I	off1(PC), R30
+	// MOVV		off2(R30), R4
+	// R30 is a callee saved register so we are responsible
+	// for ensuring its value doesn't change. So save it and
+	// restore it at the end of this function.
+	// R1 is the link register. crosscall2 doesn't save it
+	// so it's saved here.
+	MOVV	R1, 0(R3)
+	MOVV	R30, 8(R3)
+
+	// Create a struct callbackArgs on our stack.
+	MOVV	$(callbackArgs__size)(R3), R13
+	MOVV	R12, callbackArgs_index(R13)    // callback index
+	MOVV	R14, callbackArgs_args(R13)     // address of args vector
+	MOVV	$0, callbackArgs_result(R13)    // result
+
+	// Move parameters into registers
+	// Get the ABIInternal function pointer
+	// without <ABIInternal> by using a closure.
+	MOVV	·callbackWrap_call(SB), R4
+	MOVV	(R4), R4  // fn unsafe.Pointer
+	MOVV	R13, R5   // frame (&callbackArgs{...})
+	MOVV	$0, R7	  // ctxt uintptr
+
+	JAL	crosscall2(SB)
+
+	// Get callback result.
+	MOVV	$(callbackArgs__size)(R3), R13
+	MOVV	callbackArgs_result(R13), R4
+
+	// Restore LR and R30
+	MOVV	0(R3), R1
+	MOVV	8(R3), R30
+	ADDV	$(22*8), R3
+
+	RET

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

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd || linux || windows
+//go:build darwin || freebsd || linux || netbsd || windows
 
 package purego
 
@@ -13,8 +13,8 @@ package purego
 type CDecl struct{}
 
 const (
-	maxArgs     = 15
-	numOfFloats = 8 // arm64 and amd64 both have 8 float registers
+	maxArgs             = 15
+	numOfFloatRegisters = 8 // arm64 and amd64 both have 8 float registers
 )
 
 type syscall15Args struct {
@@ -27,6 +27,9 @@ type syscall15Args struct {
 // 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.
 //
+// In order to call this function properly make sure to follow all the rules specified in [unsafe.Pointer]
+// especially point 4.
+//
 // NOTE: SyscallN does not properly call functions that have both integer and float parameters.
 // See discussion comment https://github.com/ebiten/purego/pull/1#issuecomment-1128057607
 // for an explanation of why that is.

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

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build cgo && !(amd64 || arm64)
+//go:build cgo && !(amd64 || arm64 || loong64)
 
 package purego
 
@@ -16,6 +16,6 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a
 	return cgo.Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)
 }
 
-func NewCallback(_ interface{}) uintptr {
-	panic("purego: NewCallback on Linux is only supported on amd64/arm64")
+func NewCallback(_ any) uintptr {
+	panic("purego: NewCallback on Linux is only supported on amd64/arm64/loong64")
 }

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

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors
 
-//go:build darwin || freebsd || (linux && (amd64 || arm64))
+//go:build darwin || freebsd || (linux && (amd64 || arm64 || loong64)) || netbsd
 
 package purego
 
@@ -14,14 +14,17 @@ import (
 
 var syscall15XABI0 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{
+	args := thePool.Get().(*syscall15Args)
+	defer thePool.Put(args)
+
+	*args = syscall15Args{
 		fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,
 		a1, a2, a3, a4, a5, a6, a7, a8,
 		0,
 	}
-	runtime_cgocall(syscall15XABI0, unsafe.Pointer(&args))
+
+	runtime_cgocall(syscall15XABI0, unsafe.Pointer(args))
 	return args.a1, args.a2, 0
 }
 
@@ -31,7 +34,7 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a
 // of uintptr. Only a limited number of callbacks may be created in a single Go process, and any memory allocated
 // 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 {
+func NewCallback(fn any) uintptr {
 	ty := reflect.TypeOf(fn)
 	for i := 0; i < ty.NumIn(); i++ {
 		in := ty.In(i)
@@ -71,7 +74,7 @@ type callbackArgs struct {
 	result uintptr
 }
 
-func compileCallback(fn interface{}) uintptr {
+func compileCallback(fn any) uintptr {
 	val := reflect.ValueOf(fn)
 	if val.Kind() != reflect.Func {
 		panic("purego: the type must be a function but was not")
@@ -146,12 +149,12 @@ func callbackWrap(a *callbackArgs) {
 	var intsN int   // intsN represents the number of integer arguments processed
 	// stack points to the index into frame of the current stack element.
 	// The stack begins after the float and integer registers.
-	stack := numOfIntegerRegisters() + numOfFloats
+	stack := numOfIntegerRegisters() + numOfFloatRegisters
 	for i := range args {
 		var pos int
 		switch fnType.In(i).Kind() {
 		case reflect.Float32, reflect.Float64:
-			if floatsN >= numOfFloats {
+			if floatsN >= numOfFloatRegisters {
 				pos = stack
 				stack++
 			} else {
@@ -169,7 +172,7 @@ func callbackWrap(a *callbackArgs) {
 				stack++
 			} else {
 				// the integers begin after the floats in frame
-				pos = intsN + numOfFloats
+				pos = intsN + numOfFloatRegisters
 			}
 			intsN++
 		}
@@ -214,7 +217,7 @@ func callbackasmAddr(i int) uintptr {
 		panic("purego: unsupported architecture")
 	case "386", "amd64":
 		entrySize = 5
-	case "arm", "arm64":
+	case "arm", "arm64", "loong64":
 		// On ARM and ARM64, each entry is a MOV instruction
 		// followed by a branch instruction
 		entrySize = 8

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

@@ -22,7 +22,7 @@ func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a
 // allocated for these callbacks is never released. Between NewCallback and NewCallbackCDecl, at least 1024
 // callbacks can always be created. Although this function is similiar to the darwin version it may act
 // differently.
-func NewCallback(fn interface{}) uintptr {
+func NewCallback(fn any) uintptr {
 	isCDecl := false
 	ty := reflect.TypeOf(fn)
 	for i := 0; i < ty.NumIn(); i++ {