leverage compiler irgen for linking

Author: xhd2015

asset.go

@@ -0,0 +1,18 @@
+package asset
+
+import "embed"
+
+// since go:embed does not work with ../ paths
+// so we add a global asset here.
+// https://github.com/golang/go/issues/46056
+
+const (
+	CompilerPatchGen = "compiler_patch_gen"
+	RuntimeGen       = "runtime_gen"
+)
+
+//go:embed compiler_patch_gen
+var CompilerPatchGenFS embed.FS
+
+//go:embed runtime_gen
+var RuntimeGenFS embed.FS

cmd/xgo/asset/asset.go

@@ -0,0 +1,24 @@
+//go:build go1.17 && !go1.22
+// +build go1.17,!go1.22
+
+package funcs
+
+import (
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+)
+
+// for go1.20, target does not have Target.Funcs, instead, use Target.Decls
+func ForEach(callback func(fn *ir.Func) bool) {
+	// for go1.21 and above, this can just be:
+	//   for _, fn := range typecheck.Target.Funcs
+	for _, decl := range typecheck.Target.Decls {
+		fn, ok := decl.(*ir.Func)
+		if !ok {
+			continue
+		}
+		if !callback(fn) {
+			return
+		}
+	}
+}

cmd/xgo/asset/compiler_patch_gen/funcs/for_each_go1.21.go

@@ -0,0 +1,17 @@
+//go:build go1.22
+// +build go1.22
+
+package funcs
+
+import (
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+)
+
+func ForEach(callback func(fn *ir.Func) bool) {
+	for _, fn := range typecheck.Target.Funcs {
+		if !callback(fn) {
+			return
+		}
+	}
+}

cmd/xgo/asset/compiler_patch_gen/funcs/for_each_go1.22.go

@@ -0,0 +1,3 @@
+module github.com/xhd2015/xgo/patch
+
+go 1.14

cmd/xgo/asset/compiler_patch_gen/go.mod.txt

@@ -0,0 +1,79 @@
+package link
+
+import (
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/typecheck"
+	"strings"
+)
+
+const xgoPrefix = "__xgo_"
+
+// LinkXgoInit links function defined in
+// runtime
+// the function template:
+//
+//	  var __xgo_trap_0 = func() {}
+//
+//	  func init() {
+//		  __xgo_init_0()
+//	  }
+//
+//	  //go:noinline
+//	  func __xgo_init_0() {
+//	  	__xgo_trap_0 = __xgo_trap_0
+//	  }
+func LinkXgoInit(fn *ir.Func) {
+	if fn.Body == nil {
+		// in go, function can have name without body
+		return
+	}
+
+	fnName := fn.Sym().Name
+	if !strings.HasPrefix(fnName, "__xgo_init_") {
+		return
+	}
+	for _, node := range fn.Body {
+		assign, ok := node.(*ir.AssignStmt)
+		if !ok {
+			continue
+		}
+		if assign.Def {
+			continue
+		}
+		xName, ok := assign.X.(*ir.Name)
+		if !ok {
+			continue
+		}
+		symName := xName.Sym().Name
+		if !strings.HasPrefix(symName, xgoPrefix) {
+			continue
+		}
+
+		switch {
+		case strings.HasPrefix(symName, "__xgo_trap_var_"):
+			sym := typecheck.LookupRuntime("XgoTrapVar")
+			if sym == nil {
+				continue
+			}
+			assign.Y = sym
+		case strings.HasPrefix(symName, "__xgo_trap_varptr_"):
+			sym := typecheck.LookupRuntime("XgoTrapVarPtr")
+			if sym == nil {
+				continue
+			}
+			assign.Y = sym
+		case strings.HasPrefix(symName, "__xgo_trap_"):
+			sym := typecheck.LookupRuntime("XgoTrap")
+			if sym == nil {
+				continue
+			}
+			assign.Y = sym
+		case strings.HasPrefix(symName, "__xgo_register_"):
+			sym := typecheck.LookupRuntime("XgoRegister")
+			if sym == nil {
+				continue
+			}
+			assign.Y = sym
+		}
+	}
+}

cmd/xgo/asset/compiler_patch_gen/link/link_ir.go

@@ -0,0 +1,19 @@
+package patch
+
+import (
+	"cmd/compile/internal/ir"
+
+	"cmd/compile/internal/xgo_rewrite_internal/patch/funcs"
+	"cmd/compile/internal/xgo_rewrite_internal/patch/link"
+)
+
+func Patch() {
+	linkFuncs()
+}
+
+func linkFuncs() {
+	funcs.ForEach(func(fn *ir.Func) bool {
+		link.LinkXgoInit(fn)
+		return true
+	})
+}

cmd/xgo/asset/compiler_patch_gen/patch.go

@@ -11,6 +11,7 @@ import (
 
 // this ensures runtime to be always imported
 var _ = runtime.NumCPU
+var _ = unsafe.Pointer(nil)
 
 type XgoFuncInfo struct{}
 

cmd/xgo/runtime_gen/core/func.go renamed to cmd/xgo/asset/runtime_gen/core/func.go

@@ -13,6 +13,7 @@ import (
 
 // this ensures runtime to be always imported
 var _ = runtime.NumCPU
+var _ = unsafe.Pointer(nil)
 
 type XgoFuncInfo = runtime.XgoFuncInfo
 

cmd/xgo/runtime_gen/core/func_template.go renamed to cmd/xgo/asset/runtime_gen/core/func_template.go

@@ -18,30 +18,36 @@ var _ = unsafe.Pointer(nil)
 
 // this signature is to avoid relying on defined type
 // just raw string,interface{},[]string, []interface{} are needed
+
+type __xgo_intf_header struct {
+	typ  unsafe.Pointer
+	data unsafe.Pointer
+}
+
 var __xgo_trap func(info unsafe.Pointer, recvPtr interface{}, args []interface{}, results []interface{}) (func(), bool)
 
 var __xgo_var_trap func(info unsafe.Pointer, varAddr interface{}, res interface{})
 var __xgo_var_ptr_trap func(info unsafe.Pointer, varAddr interface{}, res interface{})
 
-func XgoTrap(info unsafe.Pointer, recvPtr interface{}, args []interface{}, results []interface{}) (func(), bool) {
+func XgoTrap(info interface{}, recvPtr interface{}, args []interface{}, results []interface{}) (func(), bool) {
 	if __xgo_trap == nil {
 		return nil, false
 	}
-	return __xgo_trap(info, recvPtr, args, results)
+	return __xgo_trap((*__xgo_intf_header)(unsafe.Pointer(&info)).data, recvPtr, args, results)
 }
 
-func XgoTrapVar(info unsafe.Pointer, varAddr interface{}, res interface{}) {
+func XgoTrapVar(info interface{}, varAddr interface{}, res interface{}) {
 	if __xgo_var_trap == nil {
 		return
 	}
-	__xgo_var_trap(info, varAddr, res)
+	__xgo_var_trap((*__xgo_intf_header)(unsafe.Pointer(&info)).data, varAddr, res)
 }
 
-func XgoTrapVarPtr(info unsafe.Pointer, varAddr interface{}, res interface{}) {
+func XgoTrapVarPtr(info interface{}, varAddr interface{}, res interface{}) {
 	if __xgo_var_ptr_trap == nil {
 		return
 	}
-	__xgo_var_ptr_trap(info, varAddr, res)
+	__xgo_var_ptr_trap((*__xgo_intf_header)(unsafe.Pointer(&info)).data, varAddr, res)
 }
 
 func XgoSetTrap(trap func(info unsafe.Pointer, recvPtr interface{}, args []interface{}, results []interface{}) (func(), bool)) {
@@ -188,7 +194,7 @@ type XgoFuncInfo struct {
 
 // ==end xgo func==
 
-var __xgo_staging_funcs []*XgoFuncInfo
+var __xgo_staging_funcs []interface{}
 var __xgo_register_handler func(fn unsafe.Pointer)
 
 func XgoSetupRegisterHandler(register func(fn unsafe.Pointer)) {
@@ -199,13 +205,13 @@ func XgoSetupRegisterHandler(register func(fn unsafe.Pointer)) {
 	saved := __xgo_staging_funcs
 	__xgo_staging_funcs = nil
 	for _, fn := range saved {
-		register(unsafe.Pointer(fn))
+		register((*__xgo_intf_header)(unsafe.Pointer(&fn)).data)
 	}
 }
 
-func XgoRegister(fn *XgoFuncInfo) {
+func XgoRegister(fn interface{}) {
 	if __xgo_register_handler != nil {
-		__xgo_register_handler(unsafe.Pointer(fn))
+		__xgo_register_handler((*__xgo_intf_header)(unsafe.Pointer(&fn)).data)
 		return
 	}
 	__xgo_staging_funcs = append(__xgo_staging_funcs, fn)

cmd/xgo/runtime_gen/core/object.go renamed to cmd/xgo/asset/runtime_gen/core/object.go

@@ -4,6 +4,8 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+
+	"github.com/xhd2015/xgo/instrument/build"
 )
 
 // Deprecated: since xgo v1.1.0, xgo does not instrument the compiler anymore
@@ -16,27 +18,20 @@ func buildCompiler(goroot string, output string) error {
 	cmd := exec.Command(filepath.Join(goroot, "bin", "go"), args...)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	env, err := patchEnvWithGoroot(os.Environ(), goroot)
-	if err != nil {
-		return err
-	}
-	cmd.Env = env
+	cmd.Env = build.MakeGorootEnv(os.Environ(), goroot)
 	// when building the compiler, we want native
 	// build, see https://github.com/xhd2015/xgo/issues/231
-	cmd.Env = appendNativeBuildEnv(cmd.Env)
+	cmd.Env = build.AppendNativeBuildEnv(cmd.Env)
 	cmd.Dir = filepath.Join(goroot, "src", "cmd", "compile")
 	return cmd.Run()
 }
+
 func buildExecTool(dir string, execToolBin string) error {
 	// build exec tool
 	cmd := exec.Command(getNakedGo(), "build", "-o", execToolBin, "./exec_tool")
 	cmd.Dir = dir
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	cmd.Env = appendNativeBuildEnv(os.Environ())
+	cmd.Env = build.AppendNativeBuildEnv(os.Environ())
 	return cmd.Run()
 }
-
-func appendNativeBuildEnv(env []string) []string {
-	return append(env, "GOOS=", "GOARCH=")
-}

cmd/xgo/runtime_gen/core/version.go renamed to cmd/xgo/asset/runtime_gen/core/version.go

@@ -15,6 +15,7 @@ import (
 	"github.com/xhd2015/xgo/cmd/xgo/exec_tool"
 	"github.com/xhd2015/xgo/cmd/xgo/pathsum"
 	test_explorer "github.com/xhd2015/xgo/cmd/xgo/test-explorer"
+	"github.com/xhd2015/xgo/instrument/build"
 	"github.com/xhd2015/xgo/instrument/config"
 	"github.com/xhd2015/xgo/instrument/constants"
 	"github.com/xhd2015/xgo/instrument/instrument_xgo_runtime"
@@ -96,8 +97,7 @@ func main() {
 		return
 	}
 	if cmd == "shadow" {
-		err := handleShawdow()
-		consumeErrAndExit(err)
+		consumeErrAndExit(fmt.Errorf("shadow is deprecated, use `xgo setup` instead"))
 		return
 	}
 	if cmd != "build" && cmd != "run" && cmd != "test" && cmd != "exec" && cmd != "setup" {
@@ -613,10 +613,8 @@ func handleBuild(cmd string, args []string) error {
 	debugMode := runDebug || testDebug || buildDebug
 	var finalBuildOutput string
 
-	execCmdEnv, err := patchEnvWithGoroot(os.Environ(), instrumentGoroot)
-	if err != nil {
-		return err
-	}
+	execCmdEnv := build.MakeGorootEnv(os.Environ(), instrumentGoroot)
+
 	var execCmd *exec.Cmd
 	var logCmdExec func()
 	if !cmdExec {
@@ -1246,42 +1244,6 @@ func ensureDirs(binDir string, logDir string, instrumentDir string, packageDataD
 	return nil
 }
 
-func patchEnvWithGoroot(env []string, goroot string) ([]string, error) {
-	goroot, err := filepath.Abs(goroot)
-	if err != nil {
-		return nil, err
-	}
-
-	newEnv := makeGorootEnv(env, goroot)
-	return newEnv, nil
-}
-
-// makeGorootEnv makes a new env with GOROOT and PATH set
-func makeGorootEnv(env []string, goroot string) []string {
-	newEnv := make([]string, 0, len(env))
-	var lastPath string
-	for _, e := range env {
-		if strings.HasPrefix(e, "GOROOT=") {
-			continue
-		}
-		if strings.HasPrefix(e, "PATH=") {
-			lastPath = e
-			continue
-		}
-		newEnv = append(newEnv, e)
-	}
-	gorootBin := filepath.Join(goroot, "bin")
-	pathEnv := gorootBin
-	if lastPath != "" {
-		pathEnv = pathEnv + string(filepath.ListSeparator) + strings.TrimPrefix(lastPath, "PATH=")
-	}
-	newEnv = append(newEnv,
-		"GOROOT="+goroot,
-		"PATH="+pathEnv,
-	)
-	return newEnv
-}
-
 func assertDir(dir string) error {
 	fileInfo, err := os.Stat(dir)
 	if err != nil {