Go 获取函数调用链

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
package main

import (
	"fmt"
	"go/build"
	"path/filepath"
	"strings"
	"testing"

	"golang.org/x/tools/go/callgraph"
	"golang.org/x/tools/go/packages"
	"golang.org/x/tools/go/pointer"
	"golang.org/x/tools/go/ssa"
	"golang.org/x/tools/go/ssa/ssautil"
)

var projectPath = "your project path"

func TestPointer(m *testing.T) {

	// 生成Go Packages
	cfg := &packages.Config{
		Mode: packages.LoadAllSyntax,
		Dir:  projectPath,
	}
	pkgs, err := packages.Load(cfg)
	if err != nil {
		fmt.Printf("load: %vn", err)
	}

	// 生成ssa
	prog, ssaPkgs := ssautil.AllPackages(pkgs, 0)
	prog.Build()

	// 找出main package
	mains, err := mainPackages(ssaPkgs)
	if err != nil {
		fmt.Println(err)
	}

	// 使用pointer生成调用链路
	config := &pointer.Config{
		Mains:          mains,
		BuildCallGraph: true,
	}
	result, err := pointer.Analyze(config)
	if err != nil {
		fmt.Println(err)
	}

	// 遍历调用链路
	err = callgraph.GraphVisitEdges(result.CallGraph, func(edge *callgraph.Edge) error {
		// 过滤非源代码
		if isSynthetic(edge) {
			return nil
		}

		caller := edge.Caller
		callee := edge.Callee

		// 过滤标准库代码
		if inStd(caller) || inStd(callee) {
			return nil
		}

		// 过滤依赖包
		limits := []string{"git.", "github.", "golang.", "go.", "google.", "gopkg."}
		if inLimits(caller, limits) || inLimits(callee, limits) {
			return nil
		}

		// 调用方信息
		// 包路径
		callerPkgPath := caller.Func.Pkg.Pkg.Path()
		posCaller := prog.Fset.Position(caller.Func.Pos())
		// 文件名
		callerFileName := strings.TrimSuffix(filepath.Base(posCaller.Filename), ".go")
		// 函数名
		callerFuncName := caller.Func.Name()

		// 被调用方信息
		calleePkgPath := callee.Func.Pkg.Pkg.Path()
		posCallee := prog.Fset.Position(callee.Func.Pos())
		calleeFileName := strings.TrimSuffix(filepath.Base(posCallee.Filename), ".go")
		calleeFuncName := callee.Func.Name()

		// $ 排除重复调用、递归
		// . 排除 -> init
		if strings.Contains(callerFuncName, "$") || callerFileName == "." || strings.Contains(calleeFuncName, "$") {
			return nil
		}

		fmt.Printf("%s/%s:%s -调用-> %s/%s:%sn", callerPkgPath, callerFileName, callerFuncName, calleePkgPath, calleeFileName, calleeFuncName)

		return nil
	})
	if err != nil {
		return
	}
}

func mainPackages(pkgs []*ssa.Package) ([]*ssa.Package, error) {
	var mains []*ssa.Package
	for _, p := range pkgs {
		if p != nil && p.Pkg.Name() == "main" && p.Func("main") != nil {
			mains = append(mains, p)
		}
	}
	if len(mains) == 0 {
		return nil, fmt.Errorf("no main packages")
	}
	return mains, nil
}

func isSynthetic(edge *callgraph.Edge) bool {
	return edge.Caller.Func.Pkg == nil || edge.Callee.Func.Synthetic != ""
}

func inStd(node *callgraph.Node) bool {
	pkg, _ := build.Import(node.Func.Pkg.Pkg.Path(), "", 0)
	return pkg.Goroot
}

func inLimits(node *callgraph.Node, limitPaths []string) bool {
	pkgPath := node.Func.Pkg.Pkg.Path()
	for _, p := range limitPaths {
		if strings.HasPrefix(pkgPath, p) {
			return true
		}
	}
	return false
}