// uintptr cast above.
	var z uintptr
	if always {
		z = y
	} else {
		z = 0
	}
	return (*[8]uint)(unsafe.Pointer(z))
}

// g_ssa is the same as f_ssa, but with a bit of pointer
// arithmetic for added insanity.
func g_ssa() *[7]uint {
	// Make x a uintptr pointing to where a points.
	var x uintptr
	if always {
		x = uintptr(unsafe.Pointer(a))
	} else {
		x = 0
	}

// compile

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func f_ssa(x int, p *int) {
	if false {
		y := x + 5
		for {
			*p = y
		}
	}

		fmt.Fprintf(w, "  mid [%d]byte\n", s)
		fmt.Fprintf(w, "  post [8]byte\n")
		fmt.Fprintf(w, "}\n")

		// function being tested
		fmt.Fprintf(w, "//go:noinline\n")
		fmt.Fprintf(w, "func zero%d_ssa(x *[%d]byte) {\n", s, s)
		fmt.Fprintf(w, "  *x = [%d]byte{}\n", s)
		fmt.Fprintf(w, "}\n")

		// testing harness
		fmt.Fprintf(w, "func testZero%d(t *testing.T) {\n", s)

}

func assertEqual(t *testing.T, x, y int) {
	if x != y {
		mypanic(t, fmt.Sprintf("assertEqual failed got %d, want %d", x, y))
	}
}

func TestAddressed(t *testing.T) {
	x := f1_ssa(2, 3)
	output += fmt.Sprintln("*x is", *x)
	output += fmt.Sprintln("Gratuitously use some stack")
	output += fmt.Sprintln("*x is", *x)
	assertEqual(t, *x, 9)

	w := f3a_ssa(6)
	output += fmt.Sprintln("*w is", *w)

		fmt.Fprintf(w, "  add,sub,mul,div,mod int%d\n", sz)
		fmt.Fprintf(w, "}\n")
	}

	// the function being tested
	testFunc, err := template.New("testFunc").Parse(
		`//go:noinline
		func {{.Name}}_{{.Stype}}_ssa(a, b {{.Stype}}) {{.Stype}} {
	return a {{.SymFirst}} b
}
`)
	if err != nil {
		panic(err)
	}

	// generate our functions to be tested
	for _, s := range szs {
		for _, o := range ops {