loader和obj中同时引入同一个package，如果package里有结构，并在loader中碰了，就完 #43

yedemon · 2021-12-02T07:33:34Z

pkujhd 好：）

和这个主题里面的例子一样，
https://github.com/pkujhd/goloader/issues/34#issue-926287173

不过我们在 global 前面添加一个结构

type BaseContext struct {
        ID   string
        Name string
}

var bc *BaseContext

var Global = 0

在 init 函数里面添加一个初始化

func init() {
        bc = &BaseContext{
                ID:   "1",
                Name: "2",
        }
        fmt.Println("basecontext init")
}

go build github.com/pkujhd/goloader/examples/loader 
go install github.com/pkujhd/goloader/examples/basecontext
go tool compile -I $GOPATH/pkg/`go env GOOS`_`go env GOARCH`/ $GOPATH/src/github.com/pkujhd/goloader/examples/inter/inter.go 
./loader -o $GOPATH/pkg/`go env GOOS`_`go env GOARCH`/github.com/pkujhd/goloader/examples/basecontext.a:github.com/pkujhd/goloader/examples/basecontext -o inter.o -times 2

使用相同的编译过程

执行后输出如下

basecontext init
In Loader: 10
gcprog: Ptr at index -135629908 but current index is 0
panic: gcprog: invalid Ptr index

goroutine 1 [running]:
cmd/objfile/gcprog.(*Writer).Ptr(0x6923c0, 0xfffffffff7ea73ac)
	/ext1/soft/go1.17.2/src/cmd/objfile/gcprog/gcprog.go:93 +0x14c
github.com/pkujhd/goloader.genGCData(0xc0000bc7e0, 0xc000125c00, 0x2c, 0x2c, 0xc00013d2c0)
	/ext1/gopath/src/github.com/pkujhd/goloader/gcdata.go:88 +0x6b9
github.com/pkujhd/goloader.fillGCData(0xc0000bc7e0, 0xc000125c00, 0xc0000155c0)
	/ext1/gopath/src/github.com/pkujhd/goloader/gcdata.go:140 +0x2f0
github.com/pkujhd/goloader.(*Linker).buildModule(0xc0000bc7e0, 0xc000125c00, 0xc000125c00)
	/ext1/gopath/src/github.com/pkujhd/goloader/dymcode.go:658 +0x525
github.com/pkujhd/goloader.Load(0xc0000bc7e0, 0x2)
	/ext1/gopath/src/github.com/pkujhd/goloader/dymcode.go:714 +0x36d
main.main()
	/ext1/gopath/src/github.com/pkujhd/goloader/examples/loader/loader.go:88 +0x6d6

如果注释掉

bc = &BaseContext{
  ID:   "1",
  Name: "2",
}

这段代码，就没有问题。

我这里的运行环境是

Distributor ID:	Ubuntu
Description:	Ubuntu 18.04.5 LTS
Release:	18.04
Codename:	bionic

go环境是

GO111MODULE="auto"
GOARCH="amd64"
GOBIN=""
GOCACHE="/root/.cache/go-build"
GOENV="/root/.config/go/env"
GOEXE=""
GOEXPERIMENT=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOINSECURE=""
GOMODCACHE="/ext1/gopath/pkg/mod"
GONOPROXY="*.chuangcache.com"
GONOSUMDB="*.chuangcache.com"
GOOS="linux"
GOPATH="/ext1/gopath"
GOPRIVATE="*.chuangcache.com"
GOPROXY="https://goproxy.io"
GOROOT="/ext1/soft/go1.17.2"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/ext1/soft/go1.17.2/pkg/tool/linux_amd64"
GOVCS=""
GOVERSION="go1.17.2"
GCCGO="gccgo"
AR="ar"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD="/ext1/gopath/src/github.com/pkujhd/goloader/go.mod"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build1614020744=/tmp/go-build -gno-record-gcc-switches"

麻烦帮忙看看这个问题是怎么回事。或者说正确的该是怎么个用法。

另外想再请教一个问题，如果 .o 里面的依赖包比较多，有什么办法可以把所有依赖都打进一个 .a 里嘛？我本来是想在 loader 程序里面引用这些依赖，然后直接用这些依赖来充数，结果调着调着还发现这么个问题，我感觉需要大大出手帮忙了。

pkujhd · 2021-12-02T08:41:53Z

@yedemon , 可以打进一个包，具体你可以看go自己的编译过程，但是你依旧要制定所有的包的path，否则会查不到符号。

btw，没必要这么干，如果你依赖了很多包，那这些包应该在loader里，而不是依赖在外边，就如你现在这个问题，你应该直接把basecontext编译进loader里. 保证你需要.o中要调用的函数在loader里都存在，那么在加载的时候不需要加载它

yedemon · 2021-12-03T01:19:12Z

@yedemon , 可以打进一个包，具体你可以看go自己的编译过程，但是你依旧要制定所有的包的path，否则会查不到符号。

btw，没必要这么干，如果你依赖了很多包，那这些包应该在loader里，而不是依赖在外边，就如你现在这个问题，你应该直接把basecontext编译进loader里. 保证你需要.o中要调用的函数在loader里都存在，那么在加载的时候不需要加载它

！大神手速真快，我再试试新版··· 嗯我也是在想把可以和loader放在一起的包都打进loader里，这样 .o 就可以直接用 loader 带的东西，但是我第一次尝试 basecontext 的时候，似乎读不到。我更新下再试试。

pkujhd · 2021-12-03T01:51:33Z

@yedemon , 可以打进一个包，具体你可以看go自己的编译过程，但是你依旧要制定所有的包的path，否则会查不到符号。
btw，没必要这么干，如果你依赖了很多包，那这些包应该在loader里，而不是依赖在外边，就如你现在这个问题，你应该直接把basecontext编译进loader里. 保证你需要.o中要调用的函数在loader里都存在，那么在加载的时候不需要加载它

！大神手速真快，我再试试新版··· 嗯我也是在想把可以和loader放在一起的包都打进loader里，这样 .o 就可以直接用 loader 带的东西，但是我第一次尝试 basecontext 的时候，似乎读不到。我更新下再试试。

你的.o中使用的符号，需要在loader中被使用，这样loader在编译的过程中这个符号才存在

yedemon · 2021-12-03T03:38:17Z

@yedemon , 可以打进一个包，具体你可以看go自己的编译过程，但是你依旧要制定所有的包的path，否则会查不到符号。
btw，没必要这么干，如果你依赖了很多包，那这些包应该在loader里，而不是依赖在外边，就如你现在这个问题，你应该直接把basecontext编译进loader里. 保证你需要.o中要调用的函数在loader里都存在，那么在加载的时候不需要加载它

！大神手速真快，我再试试新版··· 嗯我也是在想把可以和loader放在一起的包都打进loader里，这样 .o 就可以直接用 loader 带的东西，但是我第一次尝试 basecontext 的时候，似乎读不到。我更新下再试试。

你的.o中使用的符号，需要在loader中被使用，这样loader在编译的过程中这个符号才存在

嗯，这个已经确认了，可以。但是好像需要把basecontext 里面所有的公开的方法都在 loader里面显式的引用一次。

现在唯一的一个问题就是，怎么做比较好？
目前正在探索和找。不知道大大有什么好的写法没有？比如 import * 这样的简单的宏。或者有什么注释能让 go build 去主动保留一些没有被用到包（或者包的方法）

pkujhd · 2021-12-03T03:43:00Z

@yedemon , 可以打进一个包，具体你可以看go自己的编译过程，但是你依旧要制定所有的包的path，否则会查不到符号。
btw，没必要这么干，如果你依赖了很多包，那这些包应该在loader里，而不是依赖在外边，就如你现在这个问题，你应该直接把basecontext编译进loader里. 保证你需要.o中要调用的函数在loader里都存在，那么在加载的时候不需要加载它

！大神手速真快，我再试试新版··· 嗯我也是在想把可以和loader放在一起的包都打进loader里，这样 .o 就可以直接用 loader 带的东西，但是我第一次尝试 basecontext 的时候，似乎读不到。我更新下再试试。

你的.o中使用的符号，需要在loader中被使用，这样loader在编译的过程中这个符号才存在

嗯，这个已经确认了，可以。但是好像需要把basecontext 里面所有的公开的方法都在 loader里面显式的引用一次。

现在唯一的一个问题就是，怎么做比较好？目前正在探索和找。不知道大大有什么好的写法没有？比如 import * 这样的简单的宏。或者有什么注释能让 go build 去主动保留一些没有被用到包（或者包的方法）

这个不成，你只能调用goloader.regTypes来注册，这样函数就被保留了，如果你需要保留大量的函数，建议写个脚本生成下

yedemon · 2021-12-03T06:10:43Z

@yedemon , 可以打进一个包，具体你可以看go自己的编译过程，但是你依旧要制定所有的包的path，否则会查不到符号。
btw，没必要这么干，如果你依赖了很多包，那这些包应该在loader里，而不是依赖在外边，就如你现在这个问题，你应该直接把basecontext编译进loader里. 保证你需要.o中要调用的函数在loader里都存在，那么在加载的时候不需要加载它

！大神手速真快，我再试试新版··· 嗯我也是在想把可以和loader放在一起的包都打进loader里，这样 .o 就可以直接用 loader 带的东西，但是我第一次尝试 basecontext 的时候，似乎读不到。我更新下再试试。

你的.o中使用的符号，需要在loader中被使用，这样loader在编译的过程中这个符号才存在

嗯，这个已经确认了，可以。但是好像需要把basecontext 里面所有的公开的方法都在 loader里面显式的引用一次。
现在唯一的一个问题就是，怎么做比较好？目前正在探索和找。不知道大大有什么好的写法没有？比如 import * 这样的简单的宏。或者有什么注释能让 go build 去主动保留一些没有被用到包（或者包的方法）

这个不成，你只能调用goloader.regTypes来注册，这样函数就被保留了，如果你需要保留大量的函数，建议写个脚本生成下

奥·· 原来你这个 RegTypes 是干这个用的，多谢了。我再理一理～

yedemon · 2021-12-03T14:08:54Z

求助, go 能否实现动态传递函数类型?

当我们从库的符号里面导出指针以后，能否动态转换成我们需要的函数？便于我们从参数里传入类型？

比如这样
var funcType = func(string) basecontext.ISContext
runFunc := *(*funcType)(unsafe.Pointer(&funcPtrContainer))

或者有什么好的建议么？感谢哈··

pkujhd · 2021-12-04T03:43:06Z

求助, go 能否实现动态传递函数类型?

当我们从库的符号里面导出指针以后，能否动态转换成我们需要的函数？便于我们从参数里传入类型？

比如这样 var funcType = func(string) basecontext.ISContext runFunc := *(*funcType)(unsafe.Pointer(&funcPtrContainer))

或者有什么好的建议么？感谢哈··

不了解你想干啥？函数的类型是确定的，不能随便修改，你调用的函数的函数签名是固定的，这是你在编写函数的时候就已经确定的了。

如果你想类似dl干活的话，参考dl就可以了。

yedemon · 2021-12-07T01:19:31Z

嗯，这个我确实没想好哈·· 之前java 的思路用惯了，我本来想实现在同一个函数里实现给不同的地方的钩子添加回调函数，所以想把函数类型和回调列表作为参数传进来。在函数里面实现hook。类似

func (p *glPluginManager) Hook(callbacks []interface{}, functype ???, name string, funcName string) error {
	glplugin, ok := p.pluginMap[name]
	if !ok {
		return errors.New("no plugin " + name)
	}

	runFuncPtr, ok := glplugin.codeModule.Syms["main."+funcName]
	if !ok {
		return fmt.Errorf("Load error! not find function: %s", funcName)
	}

	funcPtrContainer := (uintptr)(unsafe.Pointer(&runFuncPtr))
	runFunc := *(*functype())unsafe.Pointer(&funcPtrContainer)
	
	//???

	return nil
}

后来我发现可以把那个 unsafe.Pointer 返回去,在需要Hook的地方直接转成那边的函数类型就可以了。

还是感谢大大回复：）

pkujhd · 2021-12-07T02:56:52Z

嗯，这个我确实没想好哈·· 之前java 的思路用惯了，我本来想实现在同一个函数里实现给不同的地方的钩子添加回调函数，所以想把函数类型和回调列表作为参数传进来。在函数里面实现hook。类似
func (p *glPluginManager) Hook(callbacks []interface{}, functype ???, name string, funcName string) error {

	glplugin, ok := p.pluginMap[name]

	if !ok {

		return errors.New("no plugin " + name)

	}



	runFuncPtr, ok := glplugin.codeModule.Syms["main."+funcName]

	if !ok {

		return fmt.Errorf("Load error! not find function: %s", funcName)

	}



	funcPtrContainer := (uintptr)(unsafe.Pointer(&runFuncPtr))

	runFunc := *(*functype())unsafe.Pointer(&funcPtrContainer)

	

	//???



	return nil

}
后来我发现可以把那个 unsafe.Pointer 返回去,在需要Hook的地方直接转成那边的函数类型就可以了。

还是感谢大大回复：）

是的，调用者肯定明确知道需要调用的函数的签名

eh-steve · 2022-11-05T14:58:53Z

By the way, the JIT compiler in #66 adds in functionality to introspect the types of functions automatically, and build an eface which contains this type information (in a map[string]interface{} of Symbols), so it allows a safe type assertion/type switch (and even calling the function programmatically via reflect!) instead of an unsafe pointer cast to a known type.

This is closer to the go compiler generating a ptab which contains all this information, and is how the go plugin system provides type safety of plugin symbols.

See jit/jit_test.go for some examples of the type assertion, and try changing the function signature to see what happens if the function signatures doesn't match (it safely fails the assertion, so you can easily type switch in the caller code)

pkujhd closed this as completed in 3082b1d Dec 2, 2021

pkujhd added the bug Something isn't working label Dec 2, 2021

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

loader和obj中同时引入同一个package，如果package里有结构，并在loader中碰了，就完 #43

loader和obj中同时引入同一个package，如果package里有结构，并在loader中碰了，就完 #43

yedemon commented Dec 2, 2021 •

edited

Loading

pkujhd commented Dec 2, 2021

yedemon commented Dec 3, 2021

pkujhd commented Dec 3, 2021

yedemon commented Dec 3, 2021 •

edited

Loading

pkujhd commented Dec 3, 2021

yedemon commented Dec 3, 2021

yedemon commented Dec 3, 2021

pkujhd commented Dec 4, 2021 •

edited

Loading

yedemon commented Dec 7, 2021 •

edited

Loading

pkujhd commented Dec 7, 2021

eh-steve commented Nov 5, 2022 •

edited

Loading

loader和obj中同时引入同一个package，如果package里有结构，并在loader中碰了，就完 #43

loader和obj中同时引入同一个package，如果package里有结构，并在loader中碰了，就完 #43

Comments

yedemon commented Dec 2, 2021 • edited Loading

pkujhd commented Dec 2, 2021

yedemon commented Dec 3, 2021

pkujhd commented Dec 3, 2021

yedemon commented Dec 3, 2021 • edited Loading

pkujhd commented Dec 3, 2021

yedemon commented Dec 3, 2021

yedemon commented Dec 3, 2021

pkujhd commented Dec 4, 2021 • edited Loading

yedemon commented Dec 7, 2021 • edited Loading

pkujhd commented Dec 7, 2021

eh-steve commented Nov 5, 2022 • edited Loading

yedemon commented Dec 2, 2021 •

edited

Loading

yedemon commented Dec 3, 2021 •

edited

Loading

pkujhd commented Dec 4, 2021 •

edited

Loading

yedemon commented Dec 7, 2021 •

edited

Loading

eh-steve commented Nov 5, 2022 •

edited

Loading