go_1_21.go

//go:build go1.21
// +build go1.21

package forceexport

import (
	"runtime"
	"unsafe"
)

type (

	// pcHeader holds data used by the pclntab lookups.
	pcHeader struct {
		magic          uint32  // 0xFFFFFFF1
		pad1, pad2     uint8   // 0,0
		minLC          uint8   // min instruction size
		ptrSize        uint8   // size of a ptr in bytes
		nfunc          int     // number of functions in the module
		nfiles         uint    // number of entries in the file tab
		textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
		funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
		cuOffset       uintptr // offset to the cutab variable from pcHeader
		filetabOffset  uintptr // offset to the filetab variable from pcHeader
		pctabOffset    uintptr // offset to the pctab variable from pcHeader
		pclnOffset     uintptr // offset to the pclntab variable from pcHeader
	}

	newModuleWrapper moduledata

	Moduledata struct {
		pcHeader *pcHeader
	}

	Functab1_18 struct {
		entry   uint32
		funcoff uint32
	}
)

// moduledata records information about the layout of the executable
// image. It is written by the linker. Any changes here must be
// matched changes to the code in cmd/link/internal/ld/symtab.go:symtab.
// moduledata is stored in statically allocated non-pointer memory;
// none of the pointers here are visible to the garbage collector.
type moduledata struct {
	pcHeader     *pcHeader
	funcnametab  []byte
	cutab        []uint32
	filetab      []byte
	pctab        []byte
	pclntable    []byte
	ftab         []functab
	findfunctab  uintptr
	minpc, maxpc uintptr

	text, etext           uintptr
	noptrdata, enoptrdata uintptr
	data, edata           uintptr
	bss, ebss             uintptr
	noptrbss, enoptrbss   uintptr
	covctrs, ecovctrs     uintptr
	end, gcdata, gcbss    uintptr
	types, etypes         uintptr
	rodata                uintptr
	gofunc                uintptr // go.func.*

	textsectmap []textsect
	typelinks   []int32 // offsets from types
	itablinks   []*itab

	ptab []ptabEntry

	pluginpath string
	pkghashes  []modulehash

	// This slice records the initializing tasks that need to be
	// done to start up the program. It is built by the linker.
	inittasks []uintptr //[]*initTask

	modulename   string
	modulehashes []modulehash

	hasmain uint8 // 1 if module contains the main function, 0 otherwise

	gcdatamask, gcbssmask bitvector

	typemap map[typeOff]*_type // offset to *_rtype in previous module

	bad bool // module failed to load and should be ignored

	next *moduledata
}

type functab struct {
	entryoff uint32 // relative to runtime.text
	funcoff  uint32
}

// Mapping information for secondary text sections

type textsect struct {
	vaddr    uintptr // prelinked section vaddr
	end      uintptr // vaddr + section length
	baseaddr uintptr // relocated section address
}

// layout of Itab known to compilers
// allocated in non-garbage-collected memory
// Needs to be in sync with
// ../cmd/compile/internal/reflectdata/reflect.go:/^func.WriteTabs.
type itab struct {
	inter *interfacetype
	_type *_type
	hash  uint32 // copy of _type.hash. Used for type switches.
	_     [4]byte
	fun   [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter.
}

type interfacetype struct {
	typ     _type
	pkgpath name
	mhdr    []imethod
}

// Needs to be in sync with ../cmd/link/internal/ld/decodesym.go:/^func.commonsize,
// ../cmd/compile/internal/reflectdata/reflect.go:/^func.dcommontype and
// ../reflect/type.go:/^type.rtype.
// ../internal/reflectlite/type.go:/^type.rtype.
type _type struct {
	size       uintptr
	ptrdata    uintptr // size of memory prefix holding all pointers
	hash       uint32
	tflag      tflag
	align      uint8
	fieldAlign uint8
	kind       uint8
	// function for comparing objects of this type
	// (ptr to object A, ptr to object B) -> ==?
	equal func(unsafe.Pointer, unsafe.Pointer) bool
	// gcdata stores the GC type data for the garbage collector.
	// If the KindGCProg bit is set in kind, gcdata is a GC program.
	// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
	gcdata    *byte
	str       nameOff
	ptrToThis typeOff
}

type nameOff int32
type typeOff int32
type textOff int32

// A ptabEntry is generated by the compiler for each exported function
// and global variable in the main package of a plugin. It is used to
// initialize the plugin module's symbol map.
type ptabEntry struct {
	name nameOff
	typ  typeOff
}

// A modulehash is used to compare the ABI of a new module or a
// package in a new module with the loaded program.
//
// For each shared library a module links against, the linker creates an entry in the
// moduledata.modulehashes slice containing the name of the module, the abi hash seen
// at link time and a pointer to the runtime abi hash. These are checked in
// moduledataverify1 below.
//
// For each loaded plugin, the pkghashes slice has a modulehash of the
// newly loaded package that can be used to check the plugin's version of
// a package against any previously loaded version of the package.
// This is done in plugin.lastmoduleinit.
type modulehash struct {
	modulename   string
	linktimehash string
	runtimehash  *string
}

// name is an encoded type name with optional extra data.
// See reflect/type.go for details.
type name struct {
	bytes *byte
}

type imethod struct {
	name nameOff
	ityp typeOff
}

// tflag is documented in reflect/type.go.
//
// tflag values must be kept in sync with copies in:
//
//		cmd/compile/internal/reflectdata/reflect.go
//		cmd/link/internal/ld/decodesym.go
//		reflect/type.go
//	     internal/reflectlite/type.go
type tflag uint8

func (me *newModuleWrapper) GetNext() moduleWrapper {
	if me.next != nil {
		return (*newModuleWrapper)(me.next)
	}
	return nil
}

func (me *newModuleWrapper) GetFtab() []functab {
	return me.ftab
}

func (me *newModuleWrapper) GetFunc(ftab functab) *runtime.Func {
	ftab1_18 := (*Functab1_18)(unsafe.Pointer(&ftab))
	return (*runtime.Func)(unsafe.Pointer(uintptr(unsafe.Pointer(me.pcHeader)) + uintptr(me.pcHeader.pclnOffset) + uintptr(ftab1_18.funcoff)))
	//return (*runtime.Func)(unsafe.Pointer(&(*pcIntable)[ftab.funcoff]))
}

func getModuleWrapper() moduleWrapper {
	new1_18 := (*newModuleWrapper)(unsafe.Pointer(&Firstmoduledata))
	return new1_18
}

//go:linkname Firstmoduledata runtime.firstmoduledata
var Firstmoduledata Moduledata