153 lines
4.6 KiB
Go
153 lines
4.6 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 pointer
|
|
|
|
import (
|
|
"fmt"
|
|
"go/token"
|
|
"go/types"
|
|
"strings"
|
|
|
|
"golang.org/x/tools/go/ssa"
|
|
)
|
|
|
|
// A Label is an entity that may be pointed to by a pointer, map,
|
|
// channel, 'func', slice or interface.
|
|
//
|
|
// Labels include:
|
|
// - functions
|
|
// - globals
|
|
// - tagged objects, representing interfaces and reflect.Values
|
|
// - arrays created by conversions (e.g. []byte("foo"), []byte(s))
|
|
// - stack- and heap-allocated variables (including composite literals)
|
|
// - channels, maps and arrays created by make()
|
|
// - intrinsic or reflective operations that allocate (e.g. append, reflect.New)
|
|
// - intrinsic objects, e.g. the initial array behind os.Args.
|
|
// - and their subelements, e.g. "alloc.y[*].z"
|
|
//
|
|
// Labels are so varied that they defy good generalizations;
|
|
// some have no value, no callgraph node, or no position.
|
|
// Many objects have types that are inexpressible in Go:
|
|
// maps, channels, functions, tagged objects.
|
|
//
|
|
// At most one of Value() or ReflectType() may return non-nil.
|
|
//
|
|
type Label struct {
|
|
obj *object // the addressable memory location containing this label
|
|
subelement *fieldInfo // subelement path within obj, e.g. ".a.b[*].c"
|
|
}
|
|
|
|
// Value returns the ssa.Value that allocated this label's object, if any.
|
|
func (l Label) Value() ssa.Value {
|
|
val, _ := l.obj.data.(ssa.Value)
|
|
return val
|
|
}
|
|
|
|
// ReflectType returns the type represented by this label if it is an
|
|
// reflect.rtype instance object or *reflect.rtype-tagged object.
|
|
//
|
|
func (l Label) ReflectType() types.Type {
|
|
rtype, _ := l.obj.data.(types.Type)
|
|
return rtype
|
|
}
|
|
|
|
// Path returns the path to the subelement of the object containing
|
|
// this label. For example, ".x[*].y".
|
|
//
|
|
func (l Label) Path() string {
|
|
return l.subelement.path()
|
|
}
|
|
|
|
// Pos returns the position of this label, if known, zero otherwise.
|
|
func (l Label) Pos() token.Pos {
|
|
switch data := l.obj.data.(type) {
|
|
case ssa.Value:
|
|
return data.Pos()
|
|
case types.Type:
|
|
if nt, ok := deref(data).(*types.Named); ok {
|
|
return nt.Obj().Pos()
|
|
}
|
|
}
|
|
if cgn := l.obj.cgn; cgn != nil {
|
|
return cgn.fn.Pos()
|
|
}
|
|
return token.NoPos
|
|
}
|
|
|
|
// String returns the printed form of this label.
|
|
//
|
|
// Examples: Object type:
|
|
// x (a variable)
|
|
// (sync.Mutex).Lock (a function)
|
|
// convert (array created by conversion)
|
|
// makemap (map allocated via make)
|
|
// makechan (channel allocated via make)
|
|
// makeinterface (tagged object allocated by makeinterface)
|
|
// <alloc in reflect.Zero> (allocation in instrinsic)
|
|
// sync.Mutex (a reflect.rtype instance)
|
|
// <command-line arguments> (an intrinsic object)
|
|
//
|
|
// Labels within compound objects have subelement paths:
|
|
// x.y[*].z (a struct variable, x)
|
|
// append.y[*].z (array allocated by append)
|
|
// makeslice.y[*].z (array allocated via make)
|
|
//
|
|
// TODO(adonovan): expose func LabelString(*types.Package, Label).
|
|
//
|
|
func (l Label) String() string {
|
|
var s string
|
|
switch v := l.obj.data.(type) {
|
|
case types.Type:
|
|
return v.String()
|
|
|
|
case string:
|
|
s = v // an intrinsic object (e.g. os.Args[*])
|
|
|
|
case nil:
|
|
if l.obj.cgn != nil {
|
|
// allocation by intrinsic or reflective operation
|
|
s = fmt.Sprintf("<alloc in %s>", l.obj.cgn.fn)
|
|
} else {
|
|
s = "<unknown>" // should be unreachable
|
|
}
|
|
|
|
case *ssa.Function:
|
|
s = v.String()
|
|
|
|
case *ssa.Global:
|
|
s = v.String()
|
|
|
|
case *ssa.Const:
|
|
s = v.Name()
|
|
|
|
case *ssa.Alloc:
|
|
s = v.Comment
|
|
if s == "" {
|
|
s = "alloc"
|
|
}
|
|
|
|
case *ssa.Call:
|
|
// Currently only calls to append can allocate objects.
|
|
if v.Call.Value.(*ssa.Builtin).Object().Name() != "append" {
|
|
panic("unhandled *ssa.Call label: " + v.Name())
|
|
}
|
|
s = "append"
|
|
|
|
case *ssa.MakeMap, *ssa.MakeChan, *ssa.MakeSlice, *ssa.Convert:
|
|
s = strings.ToLower(strings.TrimPrefix(fmt.Sprintf("%T", v), "*ssa."))
|
|
|
|
case *ssa.MakeInterface:
|
|
// MakeInterface is usually implicit in Go source (so
|
|
// Pos()==0), and tagged objects may be allocated
|
|
// synthetically (so no *MakeInterface data).
|
|
s = "makeinterface:" + v.X.Type().String()
|
|
|
|
default:
|
|
panic(fmt.Sprintf("unhandled object data type: %T", v))
|
|
}
|
|
|
|
return s + l.subelement.path()
|
|
}
|