examples/complex: and bugfixes

examples/add/add.s

@@ -3,8 +3,8 @@
 
 // func Add(x uint64, y uint64) uint64
 TEXT ·Add(SB),0,$0-24
-	MOVQ	x(FP), CX
-	MOVQ	y+8(FP), AX
-	ADDQ	CX, AX
+	MOVQ	x(FP), AX
+	MOVQ	y+8(FP), CX
+	ADDQ	AX, CX
 	MOVQ	CX, ret+16(FP)
 	RET	

examples/add/add_test.go

@@ -8,5 +8,8 @@ import (
 //go:generate go run asm.go -out add.s -stubs stub.go
 
 func TestAdd(t *testing.T) {
-	quick.CheckEqual(Add, func(x, y uint64) uint64 { return x + y }, nil)
+	expect := func(x, y uint64) uint64 { return x + y }
+	if err := quick.CheckEqual(Add, expect, nil); err != nil {
+		t.Fatal(err)
+	}
 }

examples/add/asm.go

@@ -11,7 +11,7 @@ func main() {
 	x := Load(Param("x"), GP64v())
 	y := Load(Param("y"), GP64v())
 	ADDQ(x, y)
-	Store(x, ReturnIndex(0))
+	Store(y, ReturnIndex(0))
 	RET()
 	Generate()
 }

examples/complex/asm.go

@@ -0,0 +1,32 @@
+// +build ignore
+
+package main
+
+import (
+	. "github.com/mmcloughlin/avo/build"
+)
+
+func main() {
+	TEXT("Real", "func(x complex128) float64")
+	r := Load(Param("x").Real(), Xv())
+	Store(r, ReturnIndex(0))
+	RET()
+
+	TEXT("Imag", "func(x complex128) float64")
+	i := Load(Param("x").Imag(), Xv())
+	Store(i, ReturnIndex(0))
+	RET()
+
+	TEXT("Norm", "func(x complex128) float64")
+	r = Load(Param("x").Real(), Xv())
+	i = Load(Param("x").Imag(), Xv())
+	MULSD(r, r)
+	MULSD(i, i)
+	ADDSD(i, r)
+	n := Xv()
+	SQRTSD(r, n)
+	Store(n, ReturnIndex(0))
+	RET()
+
+	Generate()
+}

examples/complex/complex.s

@@ -0,0 +1,23 @@
+
+#include "textflag.h"
+
+// func Real(x complex128) float64
+TEXT ·Real(SB),0,$0-24
+	MOVSD	x_real(FP), X0
+	MOVSD	X0, ret+16(FP)
+	RET	
+// func Imag(x complex128) float64
+TEXT ·Imag(SB),0,$0-24
+	MOVSD	x_imag+8(FP), X0
+	MOVSD	X0, ret+16(FP)
+	RET	
+// func Norm(x complex128) float64
+TEXT ·Norm(SB),0,$0-24
+	MOVSD	x_real(FP), X0
+	MOVSD	x_imag+8(FP), X1
+	MULSD	X0, X0
+	MULSD	X1, X1
+	ADDSD	X1, X0
+	SQRTSD	X0, X2
+	MOVSD	X2, ret+16(FP)
+	RET	

examples/complex/complex_test.go

@@ -0,0 +1,36 @@
+package complex
+
+import (
+	"math"
+	"testing"
+	"testing/quick"
+)
+
+//go:generate go run asm.go -out complex.s -stubs stub.go
+
+func TestReal(t *testing.T) {
+	expect := func(x complex128) float64 {
+		return real(x)
+	}
+	if err := quick.CheckEqual(Real, expect, nil); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestImag(t *testing.T) {
+	expect := func(x complex128) float64 {
+		return imag(x)
+	}
+	if err := quick.CheckEqual(Imag, expect, nil); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestNorm(t *testing.T) {
+	expect := func(x complex128) float64 {
+		return math.Sqrt(real(x)*real(x) + imag(x)*imag(x))
+	}
+	if err := quick.CheckEqual(Norm, expect, nil); err != nil {
+		t.Fatal(err)
+	}
+}

examples/complex/stub.go

@@ -0,0 +1,5 @@
+package complex
+
+func Real(x complex128) float64
+func Imag(x complex128) float64
+func Norm(x complex128) float64

examples/sum/sum.s

@@ -4,15 +4,15 @@
 // func Sum(xs []uint64) uint64
 TEXT ·Sum(SB),0,$0-32
 	MOVQ	xs_base(FP), DX
-	MOVQ	xs_len+8(FP), CX
-	XORQ	AX, AX
+	MOVQ	xs_len+8(FP), AX
+	XORQ	CX, CX
 loop:
-	CMPQ	CX, $0x0
+	CMPQ	AX, $0x0
 	JE	done
-	ADDQ	(DX), AX
+	ADDQ	(DX), CX
 	ADDQ	$0x8, DX
-	DECQ	CX
+	DECQ	AX
 	JMP	loop
 done:
-	MOVQ	AX, ret+24(FP)
+	MOVQ	CX, ret+24(FP)
 	RET	

examples/sum/sum_test.go

@@ -7,14 +7,15 @@ import (
 
 //go:generate go run asm.go -out sum.s -stubs stub.go
 
-func expect(xs []uint64) uint64 {
-	var s uint64
-	for _, x := range xs {
-		s += x
-	}
-	return s
-}
-
 func TestSum(t *testing.T) {
-	quick.CheckEqual(Sum, expect, nil)
+	expect := func(xs []uint64) uint64 {
+		var s uint64
+		for _, x := range xs {
+			s += x
+		}
+		return s
+	}
+	if err := quick.CheckEqual(Sum, expect, nil); err != nil {
+		t.Fatal(err)
+	}
 }