third_party/gofrontend/libgo/go/reflect/makefuncgo_s390.go - llvm-project/llgo - Git at Google

 // Copyright 2014 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.

 // MakeFunc s390 implementation.

 package reflect

 import "unsafe"

 // Convenience types and constants.
 const s390_arch_stack_slot_align uintptr = 4
 const s390_num_gr = 5
 const s390_num_fr = 2

 type s390_arch_gr_t uint32
 type s390_arch_fr_t uint64

 // The assembler stub will pass a pointer to this structure.
 // This will come in holding all the registers that might hold
 // function parameters.  On return we will set the registers that
 // might hold result values.
 type s390_regs struct {
 	r2         s390_arch_gr_t
 	r3         s390_arch_gr_t
 	r4         s390_arch_gr_t
 	r5         s390_arch_gr_t
 	r6         s390_arch_gr_t
 	stack_args s390_arch_gr_t
 	f0         s390_arch_fr_t
 	f2         s390_arch_fr_t
 }

 // Argument classifications that arise for Go types.
 type s390_arg_t int

 const (
 	s390_general_reg s390_arg_t = iota
 	s390_general_reg_pair
 	s390_float_reg
 	// Argument passed as a pointer to an in-memory value.
 	s390_mem_ptr
 	s390_empty
 )

 // s390ClassifyParameter returns the register class needed to
 // pass the value of type TYP.  s390_empty means the register is
 // not used.  The second and third return values are the offset of
 // an rtype parameter passed in a register (second) or stack slot
 // (third).
 func s390ClassifyParameter(typ *rtype) (s390_arg_t, uintptr, uintptr) {
 	offset := s390_arch_stack_slot_align - typ.Size()
 	if typ.Size() > s390_arch_stack_slot_align {
 		offset = 0
 	}
 	switch typ.Kind() {
 	default:
 		panic("internal error--unknown kind in s390ClassifyParameter")
 	case Bool, Int, Int8, Int16, Int32, Uint, Uint8, Uint16, Uint32:
 		return s390_general_reg, offset, offset
 	case Int64, Uint64:
 		return s390_general_reg_pair, 0, 0
 	case Uintptr, Chan, Func, Map, Ptr, UnsafePointer:
 		return s390_general_reg, 0, 0
 	case Float32, Float64:
 		return s390_float_reg, 0, offset
 	case Complex64, Complex128:
 		// Complex numbers are passed by reference.
 		return s390_mem_ptr, 0, 0
 	case Array, Struct:
 		var ityp *rtype
 		var length int

 		if typ.Size() == 0 {
 			return s390_empty, 0, 0
 		}
 		switch typ.Size() {
 		default:
 			// Pointer to memory.
 			return s390_mem_ptr, 0, 0
 		case 1, 2:
 			// Pass in an integer register.
 			return s390_general_reg, offset, offset

 		case 4, 8:
 			// See below.
 		}
 		if typ.Kind() == Array {
 			atyp := (*arrayType)(unsafe.Pointer(typ))
 			length = atyp.Len()
 			ityp = atyp.elem
 		} else {
 			styp := (*structType)(unsafe.Pointer(typ))
 			length = len(styp.fields)
 			ityp = styp.fields[0].typ
 		}
 		if length == 1 {
 			class, off_reg, off_slot := s390ClassifyParameter(ityp)
 			if class == s390_float_reg {
 				// The array (stored in a structure) or struct
 				// is "equivalent to a floating point type" as
 				// defined in the S390 Abi.  Note that this
 				// can only be the case in the case 4 of the
 				// switch above.
 				return s390_float_reg, off_reg, off_slot
 			}
 		}
 		switch typ.Size() {
 		case 4:
 			return s390_general_reg, offset, offset
 		case 8:
 			return s390_general_reg_pair, 0, 0
 		default:
 			return s390_general_reg, 0, 0
 		}
 	case Interface, String:
 		// Structure of size 8.
 		return s390_general_reg_pair, 0, 0

 	case Slice:
 		return s390_mem_ptr, 0, 0
 	}
 }

 // s390ClassifyReturn returns the register classes needed to
 // return the value of type TYP.  s390_empty means the register is
 // not used.  The second value is the offset of an rtype return
 // parameter if stored in a register.
 func s390ClassifyReturn(typ *rtype) (s390_arg_t, uintptr) {
 	offset := s390_arch_stack_slot_align - typ.Size()
 	if typ.Size() > s390_arch_stack_slot_align {
 		offset = 0
 	}
 	switch typ.Kind() {
 	default:
 		panic("internal error--unknown kind in s390ClassifyReturn")
 	case Bool, Int, Int8, Int16, Int32,
 		Uint, Uint8, Uint16, Uint32, Uintptr:

 		return s390_general_reg, offset
 	case Int64, Uint64:
 		return s390_general_reg_pair, 0
 	case Chan, Func, Map, Ptr, UnsafePointer:
 		return s390_general_reg, 0
 	case Float32, Float64:
 		return s390_float_reg, 0
 	case Complex64, Complex128:
 		return s390_mem_ptr, 0
 	case Interface, Slice, String:
 		return s390_mem_ptr, 0
 	case Array, Struct:
 		if typ.size == 0 {
 			return s390_empty, 0
 		}
 		// No optimization is done for returned structures and arrays.
 		return s390_mem_ptr, 0
 	}
 }

 // Given a value of type *rtype left aligned in an unsafe.Pointer,
 // reload the value so that it can be stored in a general or
 // floating point register.  For general registers the value is
 // sign extend and right aligned.
 func s390ReloadForRegister(typ *rtype, w uintptr, offset uintptr) uintptr {
 	var do_sign_extend bool = false
 	var gr s390_arch_gr_t

 	switch typ.Kind() {
 	case Int, Int8, Int16, Int32:
 		do_sign_extend = true
 	default:
 		// Handle all other cases in the next switch.
 	}
 	switch typ.size {
 	case 1:
 		if do_sign_extend == true {
 			se := int32(*(*int8)(unsafe.Pointer(&w)))
 			gr = *(*s390_arch_gr_t)(unsafe.Pointer(&se))
 		} else {
 			e := int32(*(*uint8)(unsafe.Pointer(&w)))
 			gr = *(*s390_arch_gr_t)(unsafe.Pointer(&e))
 		}
 	case 2:
 		if do_sign_extend == true {
 			se := int32(*(*int16)(unsafe.Pointer(&w)))
 			gr = *(*s390_arch_gr_t)(unsafe.Pointer(&se))
 		} else {
 			e := int32(*(*uint16)(unsafe.Pointer(&w)))
 			gr = *(*s390_arch_gr_t)(unsafe.Pointer(&e))
 		}
 	default:
 		panic("reflect: bad size in s390ReloadForRegister")
 	}

 	return *(*uintptr)(unsafe.Pointer(&gr))
 }

 // MakeFuncStubGo implements the s390 calling convention for
 // MakeFunc.  This should not be called.  It is exported so that
 // assembly code can call it.
 func S390MakeFuncStubGo(regs *s390_regs, c *makeFuncImpl) {
 	ftyp := c.typ
 	gr := 0
 	fr := 0
 	ap := uintptr(regs.stack_args)

 	// See if the result requires a struct.  If it does, the first
 	// parameter is a pointer to the struct.
 	var ret_class s390_arg_t
 	var ret_off_reg uintptr
 	var ret_type *rtype

 	switch len(ftyp.out) {
 	case 0:
 		ret_type = nil
 		ret_class, ret_off_reg = s390_empty, 0
 	case 1:
 		ret_type = ftyp.out[0]
 		ret_class, ret_off_reg = s390ClassifyReturn(ret_type)
 	default:
 		ret_type = nil
 		ret_class, ret_off_reg = s390_mem_ptr, 0
 	}
 	in := make([]Value, 0, len(ftyp.in))
 	if ret_class == s390_mem_ptr {
 		// We are returning a value in memory, which means
 		// that the first argument is a hidden parameter
 		// pointing to that return area.
 		gr++
 	}

 argloop:
 	for _, rt := range ftyp.in {
 		class, off_reg, off_slot := s390ClassifyParameter(rt)
 		fl := flag(rt.Kind()) << flagKindShift
 		switch class {
 		case s390_empty:
 			v := Value{rt, nil, fl | flagIndir}
 			in = append(in, v)
 			continue argloop
 		case s390_general_reg:
 			// Values stored in a general register are right
 			// aligned.
 			if gr < s390_num_gr {
 				val := s390_general_reg_val(regs, gr)
 				iw := unsafe.Pointer(&val)
 				k := rt.Kind()
 				if k != Ptr && k != UnsafePointer {
 					ix := uintptr(unsafe.Pointer(&val))
 					ix += off_reg
 					iw = unsafe.Pointer(ix)
 					fl |= flagIndir
 				}
 				v := Value{rt, iw, fl}
 				in = append(in, v)
 				gr++
 			} else {
 				in, ap = s390_add_stackreg(
 					in, ap, rt, off_slot)
 			}
 			continue argloop
 		case s390_general_reg_pair:
 			// 64-bit integers and structs are passed in a register
 			// pair.
 			if gr+1 < s390_num_gr {
 				val := uint64(s390_general_reg_val(regs, gr))<<32 + uint64(s390_general_reg_val(regs, gr+1))
 				iw := unsafe.Pointer(&val)
 				v := Value{rt, iw, fl | flagIndir}
 				in = append(in, v)
 				gr += 2
 			} else {
 				in, ap = s390_add_stackreg(in, ap, rt, off_slot)
 				gr = s390_num_gr
 			}
 			continue argloop
 		case s390_float_reg:
 			// In a register, floats are left aligned, but in a
 			// stack slot they are right aligned.
 			if fr < s390_num_fr {
 				val := s390_float_reg_val(regs, fr)
 				ix := uintptr(unsafe.Pointer(&val))
 				v := Value{
 					rt, unsafe.Pointer(unsafe.Pointer(ix)),
 					fl | flagIndir,
 				}
 				in = append(in, v)
 				fr++
 			} else {
 				in, ap = s390_add_stackreg(
 					in, ap, rt, off_slot)
 			}
 			continue argloop
 		case s390_mem_ptr:
 			if gr < s390_num_gr {
 				// Register holding a pointer to memory.
 				val := s390_general_reg_val(regs, gr)
 				v := Value{
 					rt, unsafe.Pointer(uintptr(val)),
 					fl | flagIndir}
 				in = append(in, v)
 				gr++
 			} else {
 				// Stack slot holding a pointer to memory.
 				in, ap = s390_add_memarg(in, ap, rt)
 			}
 			continue argloop
 		}
 		panic("reflect: argtype not handled in MakeFunc:argloop")
 	}

 	// All the real arguments have been found and turned into
 	// Values.  Call the real function.

 	out := c.call(in)

 	if len(out) != len(ftyp.out) {
 		panic("reflect: wrong return count from function created by MakeFunc")
 	}

 	for i, typ := range ftyp.out {
 		v := out[i]
 		if v.typ != typ {
 			panic(
 				"reflect: function created by MakeFunc using " +
 					funcName(c.fn) + " returned wrong type: have " +
 					out[i].typ.String() + " for " + typ.String())
 		}
 		if v.flag&flagRO != 0 {
 			panic(
 				"reflect: function created by MakeFunc using " +
 					funcName(c.fn) + " returned value obtained " +
 					"from unexported field")
 		}
 	}

 	switch ret_class {
 	case s390_general_reg, s390_float_reg, s390_general_reg_pair:
 		// Single return value in a general or floating point register.
 		v := out[0]
 		var w uintptr
 		if v.Kind() == Ptr || v.Kind() == UnsafePointer {
 			w = uintptr(v.pointer())
 		} else {
 			w = uintptr(loadScalar(v.ptr, v.typ.size))
 			if ret_off_reg != 0 {
 				w = s390ReloadForRegister(
 					ret_type, w, ret_off_reg)
 			}
 		}
 		if ret_class == s390_float_reg {
 			regs.f0 = s390_arch_fr_t(uintptr(w))
 		} else if ret_class == s390_general_reg {
 			regs.r2 = s390_arch_gr_t(uintptr(w))
 		} else {
 			regs.r2 = s390_arch_gr_t(uintptr(w) >> 32)
 			regs.r3 = s390_arch_gr_t(uintptr(w) & 0xffffffff)
 		}

 	case s390_mem_ptr:
 		// The address of the memory area was passed as a hidden
 		// parameter in %r2.  Multiple return values are always returned
 		// in an in-memory structure.
 		ptr := unsafe.Pointer(uintptr(regs.r2))
 		off := uintptr(0)
 		for i, typ := range ftyp.out {
 			v := out[i]
 			off = align(off, uintptr(typ.fieldAlign))
 			addr := unsafe.Pointer(uintptr(ptr) + off)
 			if v.flag&flagIndir == 0 && (v.kind() == Ptr || v.kind() == UnsafePointer) {
 				*(*unsafe.Pointer)(addr) = v.ptr
 			} else {
 				memmove(addr, v.ptr, typ.size)
 			}
 			off += typ.size
 		}

 	case s390_empty:
 	}

 	return
 }

 // The s390_add_stackreg function adds an argument passed on the
 // stack that could be passed in a register.
 func s390_add_stackreg(in []Value, ap uintptr, rt *rtype, offset uintptr) ([]Value, uintptr) {
 	// If we're not already at the beginning of a stack slot, round up to
 	// the beginning of the next one.
 	ap = align(ap, s390_arch_stack_slot_align)
 	// If offset is > 0, the data is right aligned on the stack slot.
 	ap += offset

 	// We have to copy the argument onto the heap in case the
 	// function hangs onto the reflect.Value we pass it.
 	p := unsafe_New(rt)
 	memmove(p, unsafe.Pointer(ap), rt.size)

 	v := Value{rt, p, flag(rt.Kind()<<flagKindShift) | flagIndir}
 	in = append(in, v)
 	ap += rt.size
 	ap = align(ap, s390_arch_stack_slot_align)

 	return in, ap
 }

 // The s390_add_memarg function adds an argument passed in memory.
 func s390_add_memarg(in []Value, ap uintptr, rt *rtype) ([]Value, uintptr) {
 	// If we're not already at the beginning of a stack slot,
 	// round up to the beginning of the next one.
 	ap = align(ap, s390_arch_stack_slot_align)

 	// We have to copy the argument onto the heap in case the
 	// function hangs onto the reflect.Value we pass it.
 	p := unsafe_New(rt)
 	memmove(p, *(*unsafe.Pointer)(unsafe.Pointer(ap)), rt.size)

 	v := Value{rt, p, flag(rt.Kind()<<flagKindShift) | flagIndir}
 	in = append(in, v)
 	ap += s390_arch_stack_slot_align

 	return in, ap
 }

 // The s390_general_reg_val function returns the value of integer register GR.
 func s390_general_reg_val(regs *s390_regs, gr int) s390_arch_gr_t {
 	switch gr {
 	case 0:
 		return regs.r2
 	case 1:
 		return regs.r3
 	case 2:
 		return regs.r4
 	case 3:
 		return regs.r5
 	case 4:
 		return regs.r6
 	default:
 		panic("s390_general_reg_val: bad integer register")
 	}
 }

 // The s390_float_reg_val function returns the value of float register FR.
 func s390_float_reg_val(regs *s390_regs, fr int) uintptr {
 	var r s390_arch_fr_t
 	switch fr {
 	case 0:
 		r = regs.f0
 	case 1:
 		r = regs.f2
 	default:
 		panic("s390_float_reg_val: bad floating point register")
 	}
 	return uintptr(r)
 }
	// Copyright 2014 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.

	// MakeFunc s390 implementation.

	package reflect

	import "unsafe"

	// Convenience types and constants.
	const s390_arch_stack_slot_align uintptr = 4
	const s390_num_gr = 5
	const s390_num_fr = 2

	type s390_arch_gr_t uint32
	type s390_arch_fr_t uint64

	// The assembler stub will pass a pointer to this structure.
	// This will come in holding all the registers that might hold
	// function parameters. On return we will set the registers that
	// might hold result values.
	type s390_regs struct {
	r2 s390_arch_gr_t
	r3 s390_arch_gr_t
	r4 s390_arch_gr_t
	r5 s390_arch_gr_t
	r6 s390_arch_gr_t
	stack_args s390_arch_gr_t
	f0 s390_arch_fr_t
	f2 s390_arch_fr_t
	}

	// Argument classifications that arise for Go types.
	type s390_arg_t int

	const (
	s390_general_reg s390_arg_t = iota
	s390_general_reg_pair
	s390_float_reg
	// Argument passed as a pointer to an in-memory value.
	s390_mem_ptr
	s390_empty
	)

	// s390ClassifyParameter returns the register class needed to
	// pass the value of type TYP. s390_empty means the register is
	// not used. The second and third return values are the offset of
	// an rtype parameter passed in a register (second) or stack slot
	// (third).
	func s390ClassifyParameter(typ *rtype) (s390_arg_t, uintptr, uintptr) {
	offset := s390_arch_stack_slot_align - typ.Size()
	if typ.Size() > s390_arch_stack_slot_align {
	offset = 0
	}
	switch typ.Kind() {
	default:
	panic("internal error--unknown kind in s390ClassifyParameter")
	case Bool, Int, Int8, Int16, Int32, Uint, Uint8, Uint16, Uint32:
	return s390_general_reg, offset, offset
	case Int64, Uint64:
	return s390_general_reg_pair, 0, 0
	case Uintptr, Chan, Func, Map, Ptr, UnsafePointer:
	return s390_general_reg, 0, 0
	case Float32, Float64:
	return s390_float_reg, 0, offset
	case Complex64, Complex128:
	// Complex numbers are passed by reference.
	return s390_mem_ptr, 0, 0
	case Array, Struct:
	var ityp *rtype
	var length int

	if typ.Size() == 0 {
	return s390_empty, 0, 0
	}
	switch typ.Size() {
	default:
	// Pointer to memory.
	return s390_mem_ptr, 0, 0
	case 1, 2:
	// Pass in an integer register.
	return s390_general_reg, offset, offset

	case 4, 8:
	// See below.
	}
	if typ.Kind() == Array {
	atyp := (*arrayType)(unsafe.Pointer(typ))
	length = atyp.Len()
	ityp = atyp.elem
	} else {
	styp := (*structType)(unsafe.Pointer(typ))
	length = len(styp.fields)
	ityp = styp.fields[0].typ
	}
	if length == 1 {
	class, off_reg, off_slot := s390ClassifyParameter(ityp)
	if class == s390_float_reg {
	// The array (stored in a structure) or struct
	// is "equivalent to a floating point type" as
	// defined in the S390 Abi. Note that this
	// can only be the case in the case 4 of the
	// switch above.
	return s390_float_reg, off_reg, off_slot
	}
	}
	switch typ.Size() {
	case 4:
	return s390_general_reg, offset, offset
	case 8:
	return s390_general_reg_pair, 0, 0
	default:
	return s390_general_reg, 0, 0
	}
	case Interface, String:
	// Structure of size 8.
	return s390_general_reg_pair, 0, 0

	case Slice:
	return s390_mem_ptr, 0, 0
	}
	}

	// s390ClassifyReturn returns the register classes needed to
	// return the value of type TYP. s390_empty means the register is
	// not used. The second value is the offset of an rtype return
	// parameter if stored in a register.
	func s390ClassifyReturn(typ *rtype) (s390_arg_t, uintptr) {
	offset := s390_arch_stack_slot_align - typ.Size()
	if typ.Size() > s390_arch_stack_slot_align {
	offset = 0
	}
	switch typ.Kind() {
	default:
	panic("internal error--unknown kind in s390ClassifyReturn")
	case Bool, Int, Int8, Int16, Int32,
	Uint, Uint8, Uint16, Uint32, Uintptr:

	return s390_general_reg, offset
	case Int64, Uint64:
	return s390_general_reg_pair, 0
	case Chan, Func, Map, Ptr, UnsafePointer:
	return s390_general_reg, 0
	case Float32, Float64:
	return s390_float_reg, 0
	case Complex64, Complex128:
	return s390_mem_ptr, 0
	case Interface, Slice, String:
	return s390_mem_ptr, 0
	case Array, Struct:
	if typ.size == 0 {
	return s390_empty, 0
	}
	// No optimization is done for returned structures and arrays.
	return s390_mem_ptr, 0
	}
	}

	// Given a value of type *rtype left aligned in an unsafe.Pointer,
	// reload the value so that it can be stored in a general or
	// floating point register. For general registers the value is
	// sign extend and right aligned.
	func s390ReloadForRegister(typ *rtype, w uintptr, offset uintptr) uintptr {
	var do_sign_extend bool = false
	var gr s390_arch_gr_t

	switch typ.Kind() {
	case Int, Int8, Int16, Int32:
	do_sign_extend = true
	default:
	// Handle all other cases in the next switch.
	}
	switch typ.size {
	case 1:
	if do_sign_extend == true {
	se := int32((int8)(unsafe.Pointer(&w)))
	gr = (s390_arch_gr_t)(unsafe.Pointer(&se))
	} else {
	e := int32((uint8)(unsafe.Pointer(&w)))
	gr = (s390_arch_gr_t)(unsafe.Pointer(&e))
	}
	case 2:
	if do_sign_extend == true {
	se := int32((int16)(unsafe.Pointer(&w)))
	gr = (s390_arch_gr_t)(unsafe.Pointer(&se))
	} else {
	e := int32((uint16)(unsafe.Pointer(&w)))
	gr = (s390_arch_gr_t)(unsafe.Pointer(&e))
	}
	default:
	panic("reflect: bad size in s390ReloadForRegister")
	}

	return (uintptr)(unsafe.Pointer(&gr))
	}

	// MakeFuncStubGo implements the s390 calling convention for
	// MakeFunc. This should not be called. It is exported so that
	// assembly code can call it.
	func S390MakeFuncStubGo(regs s390_regs, c makeFuncImpl) {
	ftyp := c.typ
	gr := 0
	fr := 0
	ap := uintptr(regs.stack_args)

	// See if the result requires a struct. If it does, the first
	// parameter is a pointer to the struct.
	var ret_class s390_arg_t
	var ret_off_reg uintptr
	var ret_type *rtype

	switch len(ftyp.out) {
	case 0:
	ret_type = nil
	ret_class, ret_off_reg = s390_empty, 0
	case 1:
	ret_type = ftyp.out[0]
	ret_class, ret_off_reg = s390ClassifyReturn(ret_type)
	default:
	ret_type = nil
	ret_class, ret_off_reg = s390_mem_ptr, 0
	}
	in := make([]Value, 0, len(ftyp.in))
	if ret_class == s390_mem_ptr {
	// We are returning a value in memory, which means
	// that the first argument is a hidden parameter
	// pointing to that return area.
	gr++
	}

	argloop:
	for _, rt := range ftyp.in {
	class, off_reg, off_slot := s390ClassifyParameter(rt)
	fl := flag(rt.Kind()) << flagKindShift
	switch class {
	case s390_empty:
	v := Value{rt, nil, fl \| flagIndir}
	in = append(in, v)
	continue argloop
	case s390_general_reg:
	// Values stored in a general register are right
	// aligned.
	if gr < s390_num_gr {
	val := s390_general_reg_val(regs, gr)
	iw := unsafe.Pointer(&val)
	k := rt.Kind()
	if k != Ptr && k != UnsafePointer {
	ix := uintptr(unsafe.Pointer(&val))
	ix += off_reg
	iw = unsafe.Pointer(ix)
	fl \|= flagIndir
	}
	v := Value{rt, iw, fl}
	in = append(in, v)
	gr++
	} else {
	in, ap = s390_add_stackreg(
	in, ap, rt, off_slot)
	}
	continue argloop
	case s390_general_reg_pair:
	// 64-bit integers and structs are passed in a register
	// pair.
	if gr+1 < s390_num_gr {
	val := uint64(s390_general_reg_val(regs, gr))<<32 + uint64(s390_general_reg_val(regs, gr+1))
	iw := unsafe.Pointer(&val)
	v := Value{rt, iw, fl \| flagIndir}
	in = append(in, v)
	gr += 2
	} else {
	in, ap = s390_add_stackreg(in, ap, rt, off_slot)
	gr = s390_num_gr
	}
	continue argloop
	case s390_float_reg:
	// In a register, floats are left aligned, but in a
	// stack slot they are right aligned.
	if fr < s390_num_fr {
	val := s390_float_reg_val(regs, fr)
	ix := uintptr(unsafe.Pointer(&val))
	v := Value{
	rt, unsafe.Pointer(unsafe.Pointer(ix)),
	fl \| flagIndir,
	}
	in = append(in, v)
	fr++
	} else {
	in, ap = s390_add_stackreg(
	in, ap, rt, off_slot)
	}
	continue argloop
	case s390_mem_ptr:
	if gr < s390_num_gr {
	// Register holding a pointer to memory.
	val := s390_general_reg_val(regs, gr)
	v := Value{
	rt, unsafe.Pointer(uintptr(val)),
	fl \| flagIndir}
	in = append(in, v)
	gr++
	} else {
	// Stack slot holding a pointer to memory.
	in, ap = s390_add_memarg(in, ap, rt)
	}
	continue argloop
	}
	panic("reflect: argtype not handled in MakeFunc:argloop")
	}

	// All the real arguments have been found and turned into
	// Values. Call the real function.

	out := c.call(in)

	if len(out) != len(ftyp.out) {
	panic("reflect: wrong return count from function created by MakeFunc")
	}

	for i, typ := range ftyp.out {
	v := out[i]
	if v.typ != typ {
	panic(
	"reflect: function created by MakeFunc using " +
	funcName(c.fn) + " returned wrong type: have " +
	out[i].typ.String() + " for " + typ.String())
	}
	if v.flag&flagRO != 0 {
	panic(
	"reflect: function created by MakeFunc using " +
	funcName(c.fn) + " returned value obtained " +
	"from unexported field")
	}
	}

	switch ret_class {
	case s390_general_reg, s390_float_reg, s390_general_reg_pair:
	// Single return value in a general or floating point register.
	v := out[0]
	var w uintptr
	if v.Kind() == Ptr \|\| v.Kind() == UnsafePointer {
	w = uintptr(v.pointer())
	} else {
	w = uintptr(loadScalar(v.ptr, v.typ.size))
	if ret_off_reg != 0 {
	w = s390ReloadForRegister(
	ret_type, w, ret_off_reg)
	}
	}
	if ret_class == s390_float_reg {
	regs.f0 = s390_arch_fr_t(uintptr(w))
	} else if ret_class == s390_general_reg {
	regs.r2 = s390_arch_gr_t(uintptr(w))
	} else {
	regs.r2 = s390_arch_gr_t(uintptr(w) >> 32)
	regs.r3 = s390_arch_gr_t(uintptr(w) & 0xffffffff)
	}

	case s390_mem_ptr:
	// The address of the memory area was passed as a hidden
	// parameter in %r2. Multiple return values are always returned
	// in an in-memory structure.
	ptr := unsafe.Pointer(uintptr(regs.r2))
	off := uintptr(0)
	for i, typ := range ftyp.out {
	v := out[i]
	off = align(off, uintptr(typ.fieldAlign))
	addr := unsafe.Pointer(uintptr(ptr) + off)
	if v.flag&flagIndir == 0 && (v.kind() == Ptr \|\| v.kind() == UnsafePointer) {
	(unsafe.Pointer)(addr) = v.ptr
	} else {
	memmove(addr, v.ptr, typ.size)
	}
	off += typ.size
	}

	case s390_empty:
	}

	return
	}

	// The s390_add_stackreg function adds an argument passed on the
	// stack that could be passed in a register.
	func s390_add_stackreg(in []Value, ap uintptr, rt *rtype, offset uintptr) ([]Value, uintptr) {
	// If we're not already at the beginning of a stack slot, round up to
	// the beginning of the next one.
	ap = align(ap, s390_arch_stack_slot_align)
	// If offset is > 0, the data is right aligned on the stack slot.
	ap += offset

	// We have to copy the argument onto the heap in case the
	// function hangs onto the reflect.Value we pass it.
	p := unsafe_New(rt)
	memmove(p, unsafe.Pointer(ap), rt.size)

	v := Value{rt, p, flag(rt.Kind()<<flagKindShift) \| flagIndir}
	in = append(in, v)
	ap += rt.size
	ap = align(ap, s390_arch_stack_slot_align)

	return in, ap
	}

	// The s390_add_memarg function adds an argument passed in memory.
	func s390_add_memarg(in []Value, ap uintptr, rt *rtype) ([]Value, uintptr) {
	// If we're not already at the beginning of a stack slot,
	// round up to the beginning of the next one.
	ap = align(ap, s390_arch_stack_slot_align)

	// We have to copy the argument onto the heap in case the
	// function hangs onto the reflect.Value we pass it.
	p := unsafe_New(rt)
	memmove(p, (unsafe.Pointer)(unsafe.Pointer(ap)), rt.size)

	v := Value{rt, p, flag(rt.Kind()<<flagKindShift) \| flagIndir}
	in = append(in, v)
	ap += s390_arch_stack_slot_align

	return in, ap
	}

	// The s390_general_reg_val function returns the value of integer register GR.
	func s390_general_reg_val(regs *s390_regs, gr int) s390_arch_gr_t {
	switch gr {
	case 0:
	return regs.r2
	case 1:
	return regs.r3
	case 2:
	return regs.r4
	case 3:
	return regs.r5
	case 4:
	return regs.r6
	default:
	panic("s390_general_reg_val: bad integer register")
	}
	}

	// The s390_float_reg_val function returns the value of float register FR.
	func s390_float_reg_val(regs *s390_regs, fr int) uintptr {
	var r s390_arch_fr_t
	switch fr {
	case 0:
	r = regs.f0
	case 1:
	r = regs.f2
	default:
	panic("s390_float_reg_val: bad floating point register")
	}
	return uintptr(r)
	}