mirror of
https://github.com/golang/go.git
synced 2025-05-06 08:03:03 +00:00
829d52f2e8
1) We remove context sensitivity from API. The pointer analysis is not sufficiently context-sensitive for the context information to be worth exposing. (The actual analysis precision still benefits from being context-sensitive, though.) Since all clients would discard the context info, we now do that for them. 2) Make the graph doubly-linked. Edges are now shared by the Nodes at both ends of the edge so it's possible to navigate more easily (e.g. to the callers). 3) Graph and Node are now concrete, not interfaces. Less code in every file! LGTM=crawshaw R=crawshaw CC=golang-codereviews https://golang.org/cl/66460043
96 lines
2.7 KiB
Go
96 lines
2.7 KiB
Go
// Copyright 2013 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.
|
|
|
|
package oracle
|
|
|
|
import (
|
|
"fmt"
|
|
"go/token"
|
|
|
|
"code.google.com/p/go.tools/go/callgraph"
|
|
"code.google.com/p/go.tools/go/ssa"
|
|
"code.google.com/p/go.tools/oracle/serial"
|
|
)
|
|
|
|
// Callstack displays an arbitrary path from a root of the callgraph
|
|
// to the function at the current position.
|
|
//
|
|
// The information may be misleading in a context-insensitive
|
|
// analysis. e.g. the call path X->Y->Z might be infeasible if Y never
|
|
// calls Z when it is called from X. TODO(adonovan): think about UI.
|
|
//
|
|
// TODO(adonovan): permit user to specify a starting point other than
|
|
// the analysis root.
|
|
//
|
|
func callstack(o *Oracle, qpos *QueryPos) (queryResult, error) {
|
|
pkg := o.prog.Package(qpos.info.Pkg)
|
|
if pkg == nil {
|
|
return nil, fmt.Errorf("no SSA package")
|
|
}
|
|
|
|
if !ssa.HasEnclosingFunction(pkg, qpos.path) {
|
|
return nil, fmt.Errorf("this position is not inside a function")
|
|
}
|
|
|
|
buildSSA(o)
|
|
|
|
target := ssa.EnclosingFunction(pkg, qpos.path)
|
|
if target == nil {
|
|
return nil, fmt.Errorf("no SSA function built for this location (dead code?)")
|
|
}
|
|
|
|
// Run the pointer analysis and build the complete call graph.
|
|
o.ptaConfig.BuildCallGraph = true
|
|
cg := ptrAnalysis(o).CallGraph
|
|
|
|
// Search for an arbitrary path from a root to the target function.
|
|
isEnd := func(n *callgraph.Node) bool { return n.Func == target }
|
|
callpath := callgraph.PathSearch(cg.Root, isEnd)
|
|
if callpath != nil {
|
|
callpath = callpath[1:] // remove synthetic edge from <root>
|
|
}
|
|
|
|
return &callstackResult{
|
|
qpos: qpos,
|
|
target: target,
|
|
callpath: callpath,
|
|
}, nil
|
|
}
|
|
|
|
type callstackResult struct {
|
|
qpos *QueryPos
|
|
target *ssa.Function
|
|
callpath []*callgraph.Edge
|
|
}
|
|
|
|
func (r *callstackResult) display(printf printfFunc) {
|
|
if r.callpath != nil {
|
|
printf(r.qpos, "Found a call path from root to %s", r.target)
|
|
printf(r.target, "%s", r.target)
|
|
for i := len(r.callpath) - 1; i >= 0; i-- {
|
|
edge := r.callpath[i]
|
|
printf(edge.Site, "%s from %s", edge.Site.Common().Description(), edge.Caller.Func)
|
|
}
|
|
} else {
|
|
printf(r.target, "%s is unreachable in this analysis scope", r.target)
|
|
}
|
|
}
|
|
|
|
func (r *callstackResult) toSerial(res *serial.Result, fset *token.FileSet) {
|
|
var callers []serial.Caller
|
|
for i := len(r.callpath) - 1; i >= 0; i-- { // (innermost first)
|
|
edge := r.callpath[i]
|
|
callers = append(callers, serial.Caller{
|
|
Pos: fset.Position(edge.Site.Pos()).String(),
|
|
Caller: edge.Caller.Func.String(),
|
|
Desc: edge.Site.Common().Description(),
|
|
})
|
|
}
|
|
res.Callstack = &serial.CallStack{
|
|
Pos: fset.Position(r.target.Pos()).String(),
|
|
Target: r.target.String(),
|
|
Callers: callers,
|
|
}
|
|
}
|