// 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
cg.DeleteSyntheticNodes()
// 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
}
func checkFn(fn *ssa.Function, prog *ssa.Program, ptrResult *pointer.Result, roots []*ssa.Function) {
nam := fn.String()
if strings.HasPrefix(strings.TrimPrefix(nam, "("), *prefix) {
hasPath := false
usedExternally := false
for _, r := range roots {
if r != nil {
nod, ok := ptrResult.CallGraph.Nodes[r]
if ok {
//fmt.Println("NODE root", r.Name())
pth := callgraph.PathSearch(nod,
func(n *callgraph.Node) bool {
if n == nil {
return false
}
if n.Func == fn {
for _, ine := range n.In {
if ine.Caller.Func.Pkg != fn.Pkg {
//fmt.Println("DEBUG diff? ",
// ine.Caller.Func.Pkg, fn.Pkg)
usedExternally = true
break
}
}
return true
}
return false
})
if pth != nil {
//fmt.Printf("DEBUG path from %v to %v = %v\n",
// r, fn, pth)
hasPath = true
break
}
}
}
}
isUpper := unicode.IsUpper(rune(fn.Name()[0]))
pos := fn.Pos()
//if strings.HasPrefix(nam, "(") && (!hasPath || (!usedExternally && isUpper)) {
// fmt.Println("bad Pos", pos, prog.Fset.Position(pos).String())
//}
loc := strings.TrimPrefix(
prog.Fset.Position(pos).String(),
gopath+"/src/"+*prefix+"/")
showFuncResult(loc, nam, hasPath, usedExternally, isUpper)
}
wg.Done()
}
// 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(q *Query) error {
fset := token.NewFileSet()
lconf := loader.Config{Fset: fset, Build: q.Build}
if err := setPTAScope(&lconf, q.Scope); err != nil {
return err
}
// Load/parse/type-check the program.
lprog, err := loadWithSoftErrors(&lconf)
if err != nil {
return err
}
qpos, err := parseQueryPos(lprog, q.Pos, false)
if err != nil {
return err
}
prog := ssautil.CreateProgram(lprog, 0)
ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
if err != nil {
return err
}
pkg := prog.Package(qpos.info.Pkg)
if pkg == nil {
return fmt.Errorf("no SSA package")
}
if !ssa.HasEnclosingFunction(pkg, qpos.path) {
return fmt.Errorf("this position is not inside a function")
}
// Defer SSA construction till after errors are reported.
prog.Build()
target := ssa.EnclosingFunction(pkg, qpos.path)
if target == nil {
return fmt.Errorf("no SSA function built for this location (dead code?)")
}
var callpath []*callgraph.Edge
isEnd := func(n *callgraph.Node) bool { return n.Func == target }
// First, build a callgraph containing only static call edges,
// and search for an arbitrary path from a root to the target function.
// This is quick, and the user wants a static path if one exists.
cg := static.CallGraph(prog)
cg.DeleteSyntheticNodes()
for _, ep := range entryPoints(ptaConfig.Mains) {
callpath = callgraph.PathSearch(cg.CreateNode(ep), isEnd)
if callpath != nil {
break
}
}
// No fully static path found.
// Run the pointer analysis and build a complete call graph.
if callpath == nil {
ptaConfig.BuildCallGraph = true
cg := ptrAnalysis(ptaConfig).CallGraph
cg.DeleteSyntheticNodes()
callpath = callgraph.PathSearch(cg.Root, isEnd)
if callpath != nil {
callpath = callpath[1:] // remove synthetic edge from <root>
}
}
q.Output(fset, &callstackResult{
qpos: qpos,
target: target,
callpath: callpath,
})
return nil
}
// 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(q *Query) error {
fset := token.NewFileSet()
lconf := loader.Config{Fset: fset, Build: q.Build}
if err := setPTAScope(&lconf, q.Scope); err != nil {
return err
}
// Load/parse/type-check the program.
lprog, err := lconf.Load()
if err != nil {
return err
}
qpos, err := parseQueryPos(lprog, q.Pos, false)
if err != nil {
return err
}
prog := ssautil.CreateProgram(lprog, 0)
ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
if err != nil {
return err
}
pkg := prog.Package(qpos.info.Pkg)
if pkg == nil {
return fmt.Errorf("no SSA package")
}
if !ssa.HasEnclosingFunction(pkg, qpos.path) {
return fmt.Errorf("this position is not inside a function")
}
// Defer SSA construction till after errors are reported.
prog.BuildAll()
target := ssa.EnclosingFunction(pkg, qpos.path)
if target == nil {
return fmt.Errorf("no SSA function built for this location (dead code?)")
}
// Run the pointer analysis and build the complete call graph.
ptaConfig.BuildCallGraph = true
cg := ptrAnalysis(ptaConfig).CallGraph
cg.DeleteSyntheticNodes()
// 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>
}
q.Fset = fset
q.result = &callstackResult{
qpos: qpos,
target: target,
callpath: callpath,
}
return nil
}