+++ /dev/null
-// 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 main
-
-import (
- "fmt"
- "go/token"
- "go/types"
-
- "golang.org/x/tools/cmd/guru/serial"
- "golang.org/x/tools/go/callgraph"
- "golang.org/x/tools/go/loader"
- "golang.org/x/tools/go/ssa"
- "golang.org/x/tools/go/ssa/ssautil"
-)
-
-// The callers function reports the possible callers of the function
-// immediately enclosing the specified source location.
-//
-func callers(q *Query) error {
- lconf := loader.Config{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?)")
- }
-
- // If the function is never address-taken, all calls are direct
- // and can be found quickly by inspecting the whole SSA program.
- cg := directCallsTo(target, entryPoints(ptaConfig.Mains))
- if cg == nil {
- // Run the pointer analysis, recording each
- // call found to originate from target.
- // (Pointer analysis may return fewer results than
- // directCallsTo because it ignores dead code.)
- ptaConfig.BuildCallGraph = true
- cg = ptrAnalysis(ptaConfig).CallGraph
- }
- cg.DeleteSyntheticNodes()
- edges := cg.CreateNode(target).In
-
- // TODO(adonovan): sort + dedup calls to ensure test determinism.
-
- q.Output(lprog.Fset, &callersResult{
- target: target,
- callgraph: cg,
- edges: edges,
- })
- return nil
-}
-
-// directCallsTo inspects the whole program and returns a callgraph
-// containing edges for all direct calls to the target function.
-// directCallsTo returns nil if the function is ever address-taken.
-func directCallsTo(target *ssa.Function, entrypoints []*ssa.Function) *callgraph.Graph {
- cg := callgraph.New(nil) // use nil as root *Function
- targetNode := cg.CreateNode(target)
-
- // Is the function a program entry point?
- // If so, add edge from callgraph root.
- for _, f := range entrypoints {
- if f == target {
- callgraph.AddEdge(cg.Root, nil, targetNode)
- }
- }
-
- // Find receiver type (for methods).
- var recvType types.Type
- if recv := target.Signature.Recv(); recv != nil {
- recvType = recv.Type()
- }
-
- // Find all direct calls to function,
- // or a place where its address is taken.
- var space [32]*ssa.Value // preallocate
- for fn := range ssautil.AllFunctions(target.Prog) {
- for _, b := range fn.Blocks {
- for _, instr := range b.Instrs {
- // Is this a method (T).f of a concrete type T
- // whose runtime type descriptor is address-taken?
- // (To be fully sound, we would have to check that
- // the type doesn't make it to reflection as a
- // subelement of some other address-taken type.)
- if recvType != nil {
- if mi, ok := instr.(*ssa.MakeInterface); ok {
- if types.Identical(mi.X.Type(), recvType) {
- return nil // T is address-taken
- }
- if ptr, ok := mi.X.Type().(*types.Pointer); ok &&
- types.Identical(ptr.Elem(), recvType) {
- return nil // *T is address-taken
- }
- }
- }
-
- // Direct call to target?
- rands := instr.Operands(space[:0])
- if site, ok := instr.(ssa.CallInstruction); ok &&
- site.Common().Value == target {
- callgraph.AddEdge(cg.CreateNode(fn), site, targetNode)
- rands = rands[1:] // skip .Value (rands[0])
- }
-
- // Address-taken?
- for _, rand := range rands {
- if rand != nil && *rand == target {
- return nil
- }
- }
- }
- }
- }
-
- return cg
-}
-
-func entryPoints(mains []*ssa.Package) []*ssa.Function {
- var entrypoints []*ssa.Function
- for _, pkg := range mains {
- entrypoints = append(entrypoints, pkg.Func("init"))
- if main := pkg.Func("main"); main != nil && pkg.Pkg.Name() == "main" {
- entrypoints = append(entrypoints, main)
- }
- }
- return entrypoints
-}
-
-type callersResult struct {
- target *ssa.Function
- callgraph *callgraph.Graph
- edges []*callgraph.Edge
-}
-
-func (r *callersResult) PrintPlain(printf printfFunc) {
- root := r.callgraph.Root
- if r.edges == nil {
- printf(r.target, "%s is not reachable in this program.", r.target)
- } else {
- printf(r.target, "%s is called from these %d sites:", r.target, len(r.edges))
- for _, edge := range r.edges {
- if edge.Caller == root {
- printf(r.target, "the root of the call graph")
- } else {
- printf(edge, "\t%s from %s", edge.Description(), edge.Caller.Func)
- }
- }
- }
-}
-
-func (r *callersResult) JSON(fset *token.FileSet) []byte {
- var callers []serial.Caller
- for _, edge := range r.edges {
- callers = append(callers, serial.Caller{
- Caller: edge.Caller.Func.String(),
- Pos: fset.Position(edge.Pos()).String(),
- Desc: edge.Description(),
- })
- }
- return toJSON(callers)
-}
projects / dotfiles / .git / blobdiff