291 lines
8.1 KiB
Go
291 lines
8.1 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 main
|
||
|
|
|
||
|
|
import (
|
||
|
|
"fmt"
|
||
|
|
"go/ast"
|
||
|
|
"go/token"
|
||
|
|
"go/types"
|
||
|
|
"sort"
|
||
|
|
|
||
|
|
"golang.org/x/tools/cmd/guru/serial"
|
||
|
|
"golang.org/x/tools/go/ast/astutil"
|
||
|
|
"golang.org/x/tools/go/loader"
|
||
|
|
"golang.org/x/tools/go/pointer"
|
||
|
|
"golang.org/x/tools/go/ssa"
|
||
|
|
"golang.org/x/tools/go/ssa/ssautil"
|
||
|
|
)
|
||
|
|
|
||
|
|
// pointsto runs the pointer analysis on the selected expression,
|
||
|
|
// and reports its points-to set (for a pointer-like expression)
|
||
|
|
// or its dynamic types (for an interface, reflect.Value, or
|
||
|
|
// reflect.Type expression) and their points-to sets.
|
||
|
|
//
|
||
|
|
// All printed sets are sorted to ensure determinism.
|
||
|
|
//
|
||
|
|
func pointsto(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, true) // needs exact pos
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
prog := ssautil.CreateProgram(lprog, ssa.GlobalDebug)
|
||
|
|
|
||
|
|
ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
path, action := findInterestingNode(qpos.info, qpos.path)
|
||
|
|
if action != actionExpr {
|
||
|
|
return fmt.Errorf("pointer analysis wants an expression; got %s",
|
||
|
|
astutil.NodeDescription(qpos.path[0]))
|
||
|
|
}
|
||
|
|
|
||
|
|
var expr ast.Expr
|
||
|
|
var obj types.Object
|
||
|
|
switch n := path[0].(type) {
|
||
|
|
case *ast.ValueSpec:
|
||
|
|
// ambiguous ValueSpec containing multiple names
|
||
|
|
return fmt.Errorf("multiple value specification")
|
||
|
|
case *ast.Ident:
|
||
|
|
obj = qpos.info.ObjectOf(n)
|
||
|
|
expr = n
|
||
|
|
case ast.Expr:
|
||
|
|
expr = n
|
||
|
|
default:
|
||
|
|
// TODO(adonovan): is this reachable?
|
||
|
|
return fmt.Errorf("unexpected AST for expr: %T", n)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Reject non-pointerlike types (includes all constants---except nil).
|
||
|
|
// TODO(adonovan): reject nil too.
|
||
|
|
typ := qpos.info.TypeOf(expr)
|
||
|
|
if !pointer.CanPoint(typ) {
|
||
|
|
return fmt.Errorf("pointer analysis wants an expression of reference type; got %s", typ)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Determine the ssa.Value for the expression.
|
||
|
|
var value ssa.Value
|
||
|
|
var isAddr bool
|
||
|
|
if obj != nil {
|
||
|
|
// def/ref of func/var object
|
||
|
|
value, isAddr, err = ssaValueForIdent(prog, qpos.info, obj, path)
|
||
|
|
} else {
|
||
|
|
value, isAddr, err = ssaValueForExpr(prog, qpos.info, path)
|
||
|
|
}
|
||
|
|
if err != nil {
|
||
|
|
return err // e.g. trivially dead code
|
||
|
|
}
|
||
|
|
|
||
|
|
// Defer SSA construction till after errors are reported.
|
||
|
|
prog.Build()
|
||
|
|
|
||
|
|
// Run the pointer analysis.
|
||
|
|
ptrs, err := runPTA(ptaConfig, value, isAddr)
|
||
|
|
if err != nil {
|
||
|
|
return err // e.g. analytically unreachable
|
||
|
|
}
|
||
|
|
|
||
|
|
q.Output(lprog.Fset, &pointstoResult{
|
||
|
|
qpos: qpos,
|
||
|
|
typ: typ,
|
||
|
|
ptrs: ptrs,
|
||
|
|
})
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// ssaValueForIdent returns the ssa.Value for the ast.Ident whose path
|
||
|
|
// to the root of the AST is path. isAddr reports whether the
|
||
|
|
// ssa.Value is the address denoted by the ast.Ident, not its value.
|
||
|
|
//
|
||
|
|
func ssaValueForIdent(prog *ssa.Program, qinfo *loader.PackageInfo, obj types.Object, path []ast.Node) (value ssa.Value, isAddr bool, err error) {
|
||
|
|
switch obj := obj.(type) {
|
||
|
|
case *types.Var:
|
||
|
|
pkg := prog.Package(qinfo.Pkg)
|
||
|
|
pkg.Build()
|
||
|
|
if v, addr := prog.VarValue(obj, pkg, path); v != nil {
|
||
|
|
return v, addr, nil
|
||
|
|
}
|
||
|
|
return nil, false, fmt.Errorf("can't locate SSA Value for var %s", obj.Name())
|
||
|
|
|
||
|
|
case *types.Func:
|
||
|
|
fn := prog.FuncValue(obj)
|
||
|
|
if fn == nil {
|
||
|
|
return nil, false, fmt.Errorf("%s is an interface method", obj)
|
||
|
|
}
|
||
|
|
// TODO(adonovan): there's no point running PTA on a *Func ident.
|
||
|
|
// Eliminate this feature.
|
||
|
|
return fn, false, nil
|
||
|
|
}
|
||
|
|
panic(obj)
|
||
|
|
}
|
||
|
|
|
||
|
|
// ssaValueForExpr returns the ssa.Value of the non-ast.Ident
|
||
|
|
// expression whose path to the root of the AST is path.
|
||
|
|
//
|
||
|
|
func ssaValueForExpr(prog *ssa.Program, qinfo *loader.PackageInfo, path []ast.Node) (value ssa.Value, isAddr bool, err error) {
|
||
|
|
pkg := prog.Package(qinfo.Pkg)
|
||
|
|
pkg.SetDebugMode(true)
|
||
|
|
pkg.Build()
|
||
|
|
|
||
|
|
fn := ssa.EnclosingFunction(pkg, path)
|
||
|
|
if fn == nil {
|
||
|
|
return nil, false, fmt.Errorf("no SSA function built for this location (dead code?)")
|
||
|
|
}
|
||
|
|
|
||
|
|
if v, addr := fn.ValueForExpr(path[0].(ast.Expr)); v != nil {
|
||
|
|
return v, addr, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil, false, fmt.Errorf("can't locate SSA Value for expression in %s", fn)
|
||
|
|
}
|
||
|
|
|
||
|
|
// runPTA runs the pointer analysis of the selected SSA value or address.
|
||
|
|
func runPTA(conf *pointer.Config, v ssa.Value, isAddr bool) (ptrs []pointerResult, err error) {
|
||
|
|
T := v.Type()
|
||
|
|
if isAddr {
|
||
|
|
conf.AddIndirectQuery(v)
|
||
|
|
T = deref(T)
|
||
|
|
} else {
|
||
|
|
conf.AddQuery(v)
|
||
|
|
}
|
||
|
|
ptares := ptrAnalysis(conf)
|
||
|
|
|
||
|
|
var ptr pointer.Pointer
|
||
|
|
if isAddr {
|
||
|
|
ptr = ptares.IndirectQueries[v]
|
||
|
|
} else {
|
||
|
|
ptr = ptares.Queries[v]
|
||
|
|
}
|
||
|
|
if ptr == (pointer.Pointer{}) {
|
||
|
|
return nil, fmt.Errorf("pointer analysis did not find expression (dead code?)")
|
||
|
|
}
|
||
|
|
pts := ptr.PointsTo()
|
||
|
|
|
||
|
|
if pointer.CanHaveDynamicTypes(T) {
|
||
|
|
// Show concrete types for interface/reflect.Value expression.
|
||
|
|
if concs := pts.DynamicTypes(); concs.Len() > 0 {
|
||
|
|
concs.Iterate(func(conc types.Type, pta interface{}) {
|
||
|
|
labels := pta.(pointer.PointsToSet).Labels()
|
||
|
|
sort.Sort(byPosAndString(labels)) // to ensure determinism
|
||
|
|
ptrs = append(ptrs, pointerResult{conc, labels})
|
||
|
|
})
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Show labels for other expressions.
|
||
|
|
labels := pts.Labels()
|
||
|
|
sort.Sort(byPosAndString(labels)) // to ensure determinism
|
||
|
|
ptrs = append(ptrs, pointerResult{T, labels})
|
||
|
|
}
|
||
|
|
sort.Sort(byTypeString(ptrs)) // to ensure determinism
|
||
|
|
return ptrs, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
type pointerResult struct {
|
||
|
|
typ types.Type // type of the pointer (always concrete)
|
||
|
|
labels []*pointer.Label // set of labels
|
||
|
|
}
|
||
|
|
|
||
|
|
type pointstoResult struct {
|
||
|
|
qpos *queryPos
|
||
|
|
typ types.Type // type of expression
|
||
|
|
ptrs []pointerResult // pointer info (typ is concrete => len==1)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (r *pointstoResult) PrintPlain(printf printfFunc) {
|
||
|
|
if pointer.CanHaveDynamicTypes(r.typ) {
|
||
|
|
// Show concrete types for interface, reflect.Type or
|
||
|
|
// reflect.Value expression.
|
||
|
|
|
||
|
|
if len(r.ptrs) > 0 {
|
||
|
|
printf(r.qpos, "this %s may contain these dynamic types:", r.qpos.typeString(r.typ))
|
||
|
|
for _, ptr := range r.ptrs {
|
||
|
|
var obj types.Object
|
||
|
|
if nt, ok := deref(ptr.typ).(*types.Named); ok {
|
||
|
|
obj = nt.Obj()
|
||
|
|
}
|
||
|
|
if len(ptr.labels) > 0 {
|
||
|
|
printf(obj, "\t%s, may point to:", r.qpos.typeString(ptr.typ))
|
||
|
|
printLabels(printf, ptr.labels, "\t\t")
|
||
|
|
} else {
|
||
|
|
printf(obj, "\t%s", r.qpos.typeString(ptr.typ))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
printf(r.qpos, "this %s cannot contain any dynamic types.", r.typ)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Show labels for other expressions.
|
||
|
|
if ptr := r.ptrs[0]; len(ptr.labels) > 0 {
|
||
|
|
printf(r.qpos, "this %s may point to these objects:",
|
||
|
|
r.qpos.typeString(r.typ))
|
||
|
|
printLabels(printf, ptr.labels, "\t")
|
||
|
|
} else {
|
||
|
|
printf(r.qpos, "this %s may not point to anything.",
|
||
|
|
r.qpos.typeString(r.typ))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func (r *pointstoResult) JSON(fset *token.FileSet) []byte {
|
||
|
|
var pts []serial.PointsTo
|
||
|
|
for _, ptr := range r.ptrs {
|
||
|
|
var namePos string
|
||
|
|
if nt, ok := deref(ptr.typ).(*types.Named); ok {
|
||
|
|
namePos = fset.Position(nt.Obj().Pos()).String()
|
||
|
|
}
|
||
|
|
var labels []serial.PointsToLabel
|
||
|
|
for _, l := range ptr.labels {
|
||
|
|
labels = append(labels, serial.PointsToLabel{
|
||
|
|
Pos: fset.Position(l.Pos()).String(),
|
||
|
|
Desc: l.String(),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
pts = append(pts, serial.PointsTo{
|
||
|
|
Type: r.qpos.typeString(ptr.typ),
|
||
|
|
NamePos: namePos,
|
||
|
|
Labels: labels,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
return toJSON(pts)
|
||
|
|
}
|
||
|
|
|
||
|
|
type byTypeString []pointerResult
|
||
|
|
|
||
|
|
func (a byTypeString) Len() int { return len(a) }
|
||
|
|
func (a byTypeString) Less(i, j int) bool { return a[i].typ.String() < a[j].typ.String() }
|
||
|
|
func (a byTypeString) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
||
|
|
|
||
|
|
type byPosAndString []*pointer.Label
|
||
|
|
|
||
|
|
func (a byPosAndString) Len() int { return len(a) }
|
||
|
|
func (a byPosAndString) Less(i, j int) bool {
|
||
|
|
cmp := a[i].Pos() - a[j].Pos()
|
||
|
|
return cmp < 0 || (cmp == 0 && a[i].String() < a[j].String())
|
||
|
|
}
|
||
|
|
func (a byPosAndString) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
||
|
|
|
||
|
|
func printLabels(printf printfFunc, labels []*pointer.Label, prefix string) {
|
||
|
|
// TODO(adonovan): due to context-sensitivity, many of these
|
||
|
|
// labels may differ only by context, which isn't apparent.
|
||
|
|
for _, label := range labels {
|
||
|
|
printf(label, "%s%s", prefix, label)
|
||
|
|
}
|
||
|
|
}
|