func setIBOutletValue(obj reflect.Value, name string, value Object) {
	val := obj.Elem()
	typ := val.Type()
	fieldIdx := -1
	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		if field.Tag.Get("objc") == "IBOutlet" && field.Type.Implements(objectInterfaceType) {
			if field.Name == name {
				fieldIdx = i
				break
			}
		}
	}
	if fieldIdx == -1 {
		panic("objc: bad setter for IBOutlet field '" + name + "'")
	}
	fieldVal := val.Field(fieldIdx)
	fieldVal.Set(reflect.ValueOf(value))
	value.Retain()
}
setIBOutletValue attempts to assign the Objective-C object represented
by 'value' to the field named 'name' in the Go struct represented by 'obj'.

The function sends the 'retain' message to the Objective-C object represented
by 'value' if the assignment was successful.

If the assignment operation fails, this function will raise a runtime panic.
package objc
import "C"
import (
	"math"
	"reflect"
	"unsafe"
)
type amd64frame struct {
	rdi  uintptr
	rsi  uintptr
	rdx  uintptr
	rcx  uintptr
	r8   uintptr
	r9   uintptr
	xmm0 uintptr
	xmm1 uintptr
	xmm2 uintptr
	xmm3 uintptr
	xmm4 uintptr
	xmm5 uintptr
	xmm6 uintptr
	xmm7 uintptr
}
type amd64frameFetcher struct {
	frame  *amd64frame
	ints   *[6]uintptr
	floats *[8]uintptr
	stack  *[10]uintptr
	ioff   int
	foff   int
	soff   int
}
func frameFetcher(frame *amd64frame) amd64frameFetcher {
	ints := (*[6]uintptr)(unsafe.Pointer(frame))
	floats := (*[8]uintptr)(unsafe.Pointer(&frame.xmm0))
	stack := (*[10]uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&frame.xmm7)) + 8))
	return amd64frameFetcher{
		ints:   ints,
		floats: floats,
		stack:  stack,
	}
}
func (ff *amd64frameFetcher) Int() uintptr {
	if ff.ioff < len(ff.ints) {
		val := ff.ints[ff.ioff]
		ff.ioff++
		return val
	}
	return ff.Stack()
}
func (ff *amd64frameFetcher) Float() uintptr {
	if ff.foff < len(ff.floats) {
		val := ff.floats[ff.foff]
		ff.foff++
		return val
	}
	return ff.Stack()
}
func (ff *amd64frameFetcher) Stack() uintptr {
	if ff.soff < len(ff.stack) {
		val := ff.stack[ff.soff]
		ff.soff++
		return val
	}
	panic("call: argument list exhausted")
}
func methodCallTarget() unsafe.Pointer {
	return unsafe.Pointer(&C.GoObjc_CallTargetFrameSetup)
}