OXIESEC PANEL

Name	Size	Modified	Perms
📁 ..	-	02/02/2024 06:09:55 PM	rwxr-xr-x
📄 abi.go	15.02 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 abi_test.go	26.39 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 all_test.go	214.57 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 arena.go	570 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_386.s	1.07 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_amd64.s	2.76 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_arm.s	1.13 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_arm64.s	2.77 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_loong64.s	2.87 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_mips64x.s	1.16 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_mipsx.s	1.16 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_ppc64x.s	3.31 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_riscv64.s	2.58 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_s390x.s	1.1 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 asm_wasm.s	1.15 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 benchmark_test.go	8.82 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 deepequal.go	7.42 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 example_test.go	4.53 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 export_test.go	3.73 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 float32reg_generic.go	681 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 float32reg_ppc64x.s	838 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 float32reg_riscv64.s	794 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📁 internal	-	02/02/2024 06:09:55 PM	rwxr-xr-x
📄 makefunc.go	5.91 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 nih_test.go	1004 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 set_test.go	5.71 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 stubs_ppc64x.go	292 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 stubs_riscv64.go	263 bytes	02/02/2024 06:09:55 PM	rw-r--r--
📄 swapper.go	2 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 tostring_test.go	2.14 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 type.go	80.47 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 type_test.go	1.26 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 value.go	118.95 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 visiblefields.go	2.97 KB	02/02/2024 06:09:55 PM	rw-r--r--
📄 visiblefields_test.go	5.27 KB	02/02/2024 06:09:55 PM	rw-r--r--

Editing: makefunc.go

// Copyright 2012 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 implementation.

package reflect

import (
	"internal/abi"
	"unsafe"
)

// makeFuncImpl is the closure value implementing the function
// returned by MakeFunc.
// The first three words of this type must be kept in sync with
// methodValue and runtime.reflectMethodValue.
// Any changes should be reflected in all three.
type makeFuncImpl struct {
	makeFuncCtxt
	ftyp *funcType
	fn   func([]Value) []Value
}

// MakeFunc returns a new function of the given Type
// that wraps the function fn. When called, that new function
// does the following:
//
//   - converts its arguments to a slice of Values.
//   - runs results := fn(args).
//   - returns the results as a slice of Values, one per formal result.
//
// The implementation fn can assume that the argument Value slice
// has the number and type of arguments given by typ.
// If typ describes a variadic function, the final Value is itself
// a slice representing the variadic arguments, as in the
// body of a variadic function. The result Value slice returned by fn
// must have the number and type of results given by typ.
//
// The Value.Call method allows the caller to invoke a typed function
// in terms of Values; in contrast, MakeFunc allows the caller to implement
// a typed function in terms of Values.
//
// The Examples section of the documentation includes an illustration
// of how to use MakeFunc to build a swap function for different types.
func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
	if typ.Kind() != Func {
		panic("reflect: call of MakeFunc with non-Func type")
	}

t := typ.common()
	ftyp := (*funcType)(unsafe.Pointer(t))

code := abi.FuncPCABI0(makeFuncStub)

// makeFuncImpl contains a stack map for use by the runtime
	_, _, abid := funcLayout(ftyp, nil)

impl := &makeFuncImpl{
		makeFuncCtxt: makeFuncCtxt{
			fn:      code,
			stack:   abid.stackPtrs,
			argLen:  abid.stackCallArgsSize,
			regPtrs: abid.inRegPtrs,
		},
		ftyp: ftyp,
		fn:   fn,
	}

return Value{t, unsafe.Pointer(impl), flag(Func)}
}

// makeFuncStub is an assembly function that is the code half of
// the function returned from MakeFunc. It expects a *callReflectFunc
// as its context register, and its job is to invoke callReflect(ctxt, frame)
// where ctxt is the context register and frame is a pointer to the first
// word in the passed-in argument frame.
func makeFuncStub()

// The first 3 words of this type must be kept in sync with
// makeFuncImpl and runtime.reflectMethodValue.
// Any changes should be reflected in all three.
type methodValue struct {
	makeFuncCtxt
	method int
	rcvr   Value
}

// makeMethodValue converts v from the rcvr+method index representation
// of a method value to an actual method func value, which is
// basically the receiver value with a special bit set, into a true
// func value - a value holding an actual func. The output is
// semantically equivalent to the input as far as the user of package
// reflect can tell, but the true func representation can be handled
// by code like Convert and Interface and Assign.
func makeMethodValue(op string, v Value) Value {
	if v.flag&flagMethod == 0 {
		panic("reflect: internal error: invalid use of makeMethodValue")
	}

// Ignoring the flagMethod bit, v describes the receiver, not the method type.
	fl := v.flag & (flagRO | flagAddr | flagIndir)
	fl |= flag(v.typ().Kind())
	rcvr := Value{v.typ(), v.ptr, fl}

// v.Type returns the actual type of the method value.
	ftyp := (*funcType)(unsafe.Pointer(v.Type().(*rtype)))

code := methodValueCallCodePtr()

// methodValue contains a stack map for use by the runtime
	_, _, abid := funcLayout(ftyp, nil)
	fv := &methodValue{
		makeFuncCtxt: makeFuncCtxt{
			fn:      code,
			stack:   abid.stackPtrs,
			argLen:  abid.stackCallArgsSize,
			regPtrs: abid.inRegPtrs,
		},
		method: int(v.flag) >> flagMethodShift,
		rcvr:   rcvr,
	}

// Cause panic if method is not appropriate.
	// The panic would still happen during the call if we omit this,
	// but we want Interface() and other operations to fail early.
	methodReceiver(op, fv.rcvr, fv.method)

return Value{ftyp.Common(), unsafe.Pointer(fv), v.flag&flagRO | flag(Func)}
}

func methodValueCallCodePtr() uintptr {
	return abi.FuncPCABI0(methodValueCall)
}

// methodValueCall is an assembly function that is the code half of
// the function returned from makeMethodValue. It expects a *methodValue
// as its context register, and its job is to invoke callMethod(ctxt, frame)
// where ctxt is the context register and frame is a pointer to the first
// word in the passed-in argument frame.
func methodValueCall()

// This structure must be kept in sync with runtime.reflectMethodValue.
// Any changes should be reflected in all both.
type makeFuncCtxt struct {
	fn      uintptr
	stack   *bitVector // ptrmap for both stack args and results
	argLen  uintptr    // just args
	regPtrs abi.IntArgRegBitmap
}

// moveMakeFuncArgPtrs uses ctxt.regPtrs to copy integer pointer arguments
// in args.Ints to args.Ptrs where the GC can see them.
//
// This is similar to what reflectcallmove does in the runtime, except
// that happens on the return path, whereas this happens on the call path.
//
// nosplit because pointers are being held in uintptr slots in args, so
// having our stack scanned now could lead to accidentally freeing
// memory.
//
//go:nosplit
func moveMakeFuncArgPtrs(ctxt *makeFuncCtxt, args *abi.RegArgs) {
	for i, arg := range args.Ints {
		// Avoid write barriers! Because our write barrier enqueues what
		// was there before, we might enqueue garbage.
		if ctxt.regPtrs.Get(i) {
			*(*uintptr)(unsafe.Pointer(&args.Ptrs[i])) = arg
		} else {
			// We *must* zero this space ourselves because it's defined in
			// assembly code and the GC will scan these pointers. Otherwise,
			// there will be garbage here.
			*(*uintptr)(unsafe.Pointer(&args.Ptrs[i])) = 0
		}
	}
}