github.com/ebitengine/purego

The 386 callback trampoline returned only EAX, losing the upper half
of int64 and uint64 results. Its callbackArgs area also overlapped
the copied C arguments.

Reserve space for the full callbackArgs struct, move the argument
copy past it, and return both result words in EDX:EAX.

Add regression tests for signed and unsigned 64-bit callback results,
including a callback with stack arguments.

Closes #524

MatchString does substring matching, so the unanchored pattern let
names like Bar or 'foo bar' through RegisterClass validation. Anchor
it for a full-string match.

Closes #508

• Fix SyscallN returning the third input argument as an error code on platforms that do not capture errno; it now returns 0 (#505)
• Fix 64-bit integer callback return values losing their upper 32 bits on 386 (#524)

• Require Go 1.25 or later (#469)
• Support structs on Windows amd64/arm64, Android, iOS, loong64, and ppc64le (#237, #466, #473, #475)
• Support structs as arguments and return values in callbacks (#225, #418)
• Add NetBSD (amd64, arm64) as a Tier 2 platform (#349)
• Support the ARM soft-float ABI (#490)
• Support linux/s390x without Cgo (#422)
• Support up to 32 arguments on 64-bit platforms (#425)
• Add cstrings.NSStringToString (#438)
• Fix some bugs

Go 1.27's go fix rewrites constructs that newer standard library APIs
express better. Running it over every GOOS/GOARCH this module builds
for turns up three sites, all mechanical:

compareStatus walks the lines of a /proc status file, so the slice
from strings.Split only exists to be ranged over; SplitSeq yields the
same lines without materializing it. The same function sorts a field
list with sort.Slice and a less function that is plain string
comparison, which is what slices.Sort does for an ordered element
type.

NewCallback asks whether an argument is assignable to CDecl, a type
known at compile time, so reflect.TypeFor names it directly instead of
building a value to take the type of.

The cgo-enabled cross builds could not be analyzed on the machine this
ran on, which has no cross C toolchain; darwin/amd64 and darwin/arm64
with cgo were covered and reported nothing.

Co-authored-by: Claude Opus 5 noreply@anthropic.com

Go 1.23 added structs.HostLayout, a zero-sized marker field that tells
the compiler a struct must be laid out the way the host's C ABI expects
rather than by Go's own rules. Until now purego relied on Go's current
layout happening to match C.

Declare the marker on every struct that stands in for a C one: objc_super,
MethodDescription, PropertyAttribute, blockDescriptor and blockLayout in
package objc; G, ThreadStart, the Darwin pthread types, the NetBSD stack_t
and argset in internal/fakecgo; syscallArgs, which internal/cgo hands to C
as a struct syscallArgs; the window example's NSPoint/NSSize/NSRect and
WNDCLASSEX/RECT/POINT/MSG; and the C-representative structs in the tests.
Structs that never cross into C, such as MethodDef, FieldDef and the
callback argument block filled in by Go assembly, are left alone.

The marker field is zero-sized, so it takes no part in the C ABI. Teach
the argument classification to skip zero-sized fields, otherwise a struct
that declares it is misclassified: isAllSameFloat would panic descending
into the marker, isHFA/isHVA would stop recognizing homogeneous
aggregates, and objc's @encode would emit the marker as a member.

Closes #259

Co-Authored-By: Claude Opus 5 noreply@anthropic.com

• Pull runtime variable 'goarmsoftfp' to detect if soft-float ABI is used.
• Assembly trampolines skips load/store to FP registers if soft-float is detected. This was implemented in exactly same way how it's done in Go runtime.
• Apply integer passing rules for float arguments/return values.
• Run tests for GOARM=5 (no FPU) in test workflow and add some arm-specific test cases.

Closes #490

Co-authored-by: Hirador 63920290+Hirador@users.noreply.github.com

internal/fakecgo: use libthr.so.3 instead of libpthread.so on FreeBSD…

Pass and return structs by value when calling C functions under the
ELFv2 ABI: a homogeneous floating-point aggregate is passed and returned
in the floating-point registers whatever its size, any other aggregate
occupies successive doublewords in the general-purpose registers and the
parameter save area, and a non-homogeneous aggregate larger than two
doublewords is returned through a caller-allocated buffer. Scalar float32
arguments are passed in double-precision format, matching the FMOVD-based
convention already used for float32 struct members and float returns;
reading float32 callback arguments does the inverse conversion.

Widen structReturnInMemory to take the return type rather than its size,
so ppc64le can keep a homogeneous floating-point aggregate in registers
regardless of size while every other architecture keeps its size-only
rule.

Struct arguments and returns in callbacks remain unsupported, as on the
other non-amd64/arm64 architectures. Aggregates that need more than eight
floating-point argument registers, and functions taking mixed scalar
floating-point and integer arguments, are not yet handled; the latter
needs the ELFv2 general-purpose register shadowing that purego does not
model for scalar arguments.

Updates #474

Co-authored-by: Claude Opus 4.8 noreply@anthropic.com

fakecgo: add s390x support for CGO_ENABLED=0 (#422)

Revert the sync.Pool removal #452 and copy syscall.a1 into a local variable
before taking its address, so the reflect.Value points to an independent location
that is not affected by pool recycling.

Updates #451

• Fixed an issue with FreeBSD 15 or later (#480)