+++ /dev/null
-// Copyright 2014 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.
-
-// callgraph: a tool for reporting the call graph of a Go program.
-// See Usage for details, or run with -help.
-package main // import "golang.org/x/tools/cmd/callgraph"
-
-// TODO(adonovan):
-//
-// Features:
-// - restrict graph to a single package
-// - output
-// - functions reachable from root (use digraph tool?)
-// - unreachable functions (use digraph tool?)
-// - dynamic (runtime) types
-// - indexed output (numbered nodes)
-// - JSON output
-// - additional template fields:
-// callee file/line/col
-
-import (
- "bufio"
- "bytes"
- "flag"
- "fmt"
- "go/build"
- "go/token"
- "io"
- "log"
- "os"
- "runtime"
- "text/template"
-
- "golang.org/x/tools/go/buildutil"
- "golang.org/x/tools/go/callgraph"
- "golang.org/x/tools/go/callgraph/cha"
- "golang.org/x/tools/go/callgraph/rta"
- "golang.org/x/tools/go/callgraph/static"
- "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"
-)
-
-// flags
-var (
- algoFlag = flag.String("algo", "rta",
- `Call graph construction algorithm (static, cha, rta, pta)`)
-
- testFlag = flag.Bool("test", false,
- "Loads test code (*_test.go) for imported packages")
-
- formatFlag = flag.String("format",
- "{{.Caller}}\t--{{.Dynamic}}-{{.Line}}:{{.Column}}-->\t{{.Callee}}",
- "A template expression specifying how to format an edge")
-
- ptalogFlag = flag.String("ptalog", "",
- "Location of the points-to analysis log file, or empty to disable logging.")
-)
-
-func init() {
- flag.Var((*buildutil.TagsFlag)(&build.Default.BuildTags), "tags", buildutil.TagsFlagDoc)
-}
-
-const Usage = `callgraph: display the call graph of a Go program.
-
-Usage:
-
- callgraph [-algo=static|cha|rta|pta] [-test] [-format=...] package...
-
-Flags:
-
--algo Specifies the call-graph construction algorithm, one of:
-
- static static calls only (unsound)
- cha Class Hierarchy Analysis
- rta Rapid Type Analysis
- pta inclusion-based Points-To Analysis
-
- The algorithms are ordered by increasing precision in their
- treatment of dynamic calls (and thus also computational cost).
- RTA and PTA require a whole program (main or test), and
- include only functions reachable from main.
-
--test Include the package's tests in the analysis.
-
--format Specifies the format in which each call graph edge is displayed.
- One of:
-
- digraph output suitable for input to
- golang.org/x/tools/cmd/digraph.
- graphviz output in AT&T GraphViz (.dot) format.
-
- All other values are interpreted using text/template syntax.
- The default value is:
-
- {{.Caller}}\t--{{.Dynamic}}-{{.Line}}:{{.Column}}-->\t{{.Callee}}
-
- The structure passed to the template is (effectively):
-
- type Edge struct {
- Caller *ssa.Function // calling function
- Callee *ssa.Function // called function
-
- // Call site:
- Filename string // containing file
- Offset int // offset within file of '('
- Line int // line number
- Column int // column number of call
- Dynamic string // "static" or "dynamic"
- Description string // e.g. "static method call"
- }
-
- Caller and Callee are *ssa.Function values, which print as
- "(*sync/atomic.Mutex).Lock", but other attributes may be
- derived from them, e.g. Caller.Pkg.Pkg.Path yields the
- import path of the enclosing package. Consult the go/ssa
- API documentation for details.
-
-Examples:
-
- Show the call graph of the trivial web server application:
-
- callgraph -format digraph $GOROOT/src/net/http/triv.go
-
- Same, but show only the packages of each function:
-
- callgraph -format '{{.Caller.Pkg.Pkg.Path}} -> {{.Callee.Pkg.Pkg.Path}}' \
- $GOROOT/src/net/http/triv.go | sort | uniq
-
- Show functions that make dynamic calls into the 'fmt' test package,
- using the pointer analysis algorithm:
-
- callgraph -format='{{.Caller}} -{{.Dynamic}}-> {{.Callee}}' -test -algo=pta fmt |
- sed -ne 's/-dynamic-/--/p' |
- sed -ne 's/-->.*fmt_test.*$//p' | sort | uniq
-
- Show all functions directly called by the callgraph tool's main function:
-
- callgraph -format=digraph golang.org/x/tools/cmd/callgraph |
- digraph succs golang.org/x/tools/cmd/callgraph.main
-`
-
-func init() {
- // If $GOMAXPROCS isn't set, use the full capacity of the machine.
- // For small machines, use at least 4 threads.
- if os.Getenv("GOMAXPROCS") == "" {
- n := runtime.NumCPU()
- if n < 4 {
- n = 4
- }
- runtime.GOMAXPROCS(n)
- }
-}
-
-func main() {
- flag.Parse()
- if err := doCallgraph("", "", *algoFlag, *formatFlag, *testFlag, flag.Args()); err != nil {
- fmt.Fprintf(os.Stderr, "callgraph: %s\n", err)
- os.Exit(1)
- }
-}
-
-var stdout io.Writer = os.Stdout
-
-func doCallgraph(dir, gopath, algo, format string, tests bool, args []string) error {
- if len(args) == 0 {
- fmt.Fprintln(os.Stderr, Usage)
- return nil
- }
-
- cfg := &packages.Config{
- Mode: packages.LoadAllSyntax,
- Tests: tests,
- Dir: dir,
- }
- if gopath != "" {
- cfg.Env = append(os.Environ(), "GOPATH="+gopath) // to enable testing
- }
- initial, err := packages.Load(cfg, args...)
- if err != nil {
- return err
- }
- if packages.PrintErrors(initial) > 0 {
- return fmt.Errorf("packages contain errors")
- }
-
- // Create and build SSA-form program representation.
- prog, pkgs := ssautil.AllPackages(initial, 0)
- prog.Build()
-
- // -- call graph construction ------------------------------------------
-
- var cg *callgraph.Graph
-
- switch algo {
- case "static":
- cg = static.CallGraph(prog)
-
- case "cha":
- cg = cha.CallGraph(prog)
-
- case "pta":
- // Set up points-to analysis log file.
- var ptalog io.Writer
- if *ptalogFlag != "" {
- if f, err := os.Create(*ptalogFlag); err != nil {
- log.Fatalf("Failed to create PTA log file: %s", err)
- } else {
- buf := bufio.NewWriter(f)
- ptalog = buf
- defer func() {
- if err := buf.Flush(); err != nil {
- log.Printf("flush: %s", err)
- }
- if err := f.Close(); err != nil {
- log.Printf("close: %s", err)
- }
- }()
- }
- }
-
- mains, err := mainPackages(pkgs)
- if err != nil {
- return err
- }
- config := &pointer.Config{
- Mains: mains,
- BuildCallGraph: true,
- Log: ptalog,
- }
- ptares, err := pointer.Analyze(config)
- if err != nil {
- return err // internal error in pointer analysis
- }
- cg = ptares.CallGraph
-
- case "rta":
- mains, err := mainPackages(pkgs)
- if err != nil {
- return err
- }
- var roots []*ssa.Function
- for _, main := range mains {
- roots = append(roots, main.Func("init"), main.Func("main"))
- }
- rtares := rta.Analyze(roots, true)
- cg = rtares.CallGraph
-
- // NB: RTA gives us Reachable and RuntimeTypes too.
-
- default:
- return fmt.Errorf("unknown algorithm: %s", algo)
- }
-
- cg.DeleteSyntheticNodes()
-
- // -- output------------------------------------------------------------
-
- var before, after string
-
- // Pre-canned formats.
- switch format {
- case "digraph":
- format = `{{printf "%q %q" .Caller .Callee}}`
-
- case "graphviz":
- before = "digraph callgraph {\n"
- after = "}\n"
- format = ` {{printf "%q" .Caller}} -> {{printf "%q" .Callee}}`
- }
-
- tmpl, err := template.New("-format").Parse(format)
- if err != nil {
- return fmt.Errorf("invalid -format template: %v", err)
- }
-
- // Allocate these once, outside the traversal.
- var buf bytes.Buffer
- data := Edge{fset: prog.Fset}
-
- fmt.Fprint(stdout, before)
- if err := callgraph.GraphVisitEdges(cg, func(edge *callgraph.Edge) error {
- data.position.Offset = -1
- data.edge = edge
- data.Caller = edge.Caller.Func
- data.Callee = edge.Callee.Func
-
- buf.Reset()
- if err := tmpl.Execute(&buf, &data); err != nil {
- return err
- }
- stdout.Write(buf.Bytes())
- if len := buf.Len(); len == 0 || buf.Bytes()[len-1] != '\n' {
- fmt.Fprintln(stdout)
- }
- return nil
- }); err != nil {
- return err
- }
- fmt.Fprint(stdout, after)
- return nil
-}
-
-// mainPackages returns the main packages to analyze.
-// Each resulting package is named "main" and has a main function.
-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
-}
-
-type Edge struct {
- Caller *ssa.Function
- Callee *ssa.Function
-
- edge *callgraph.Edge
- fset *token.FileSet
- position token.Position // initialized lazily
-}
-
-func (e *Edge) pos() *token.Position {
- if e.position.Offset == -1 {
- e.position = e.fset.Position(e.edge.Pos()) // called lazily
- }
- return &e.position
-}
-
-func (e *Edge) Filename() string { return e.pos().Filename }
-func (e *Edge) Column() int { return e.pos().Column }
-func (e *Edge) Line() int { return e.pos().Line }
-func (e *Edge) Offset() int { return e.pos().Offset }
-
-func (e *Edge) Dynamic() string {
- if e.edge.Site != nil && e.edge.Site.Common().StaticCallee() == nil {
- return "dynamic"
- }
- return "static"
-}
-
-func (e *Edge) Description() string { return e.edge.Description() }
projects / dotfiles / .git / blobdiff