mirror of
https://github.com/golang/go
synced 2024-11-19 04:44:41 -07:00
c28bf6e069
CanonicalPos was inadequate since many pairs of instruction share the same pos (e.g. Allocs and Phis). Instead, we generalize the DebugRef instruction to associate not just Idents but Exprs with ssa.Values.
We no longer store any DebugRefs for constant expressions, to save space. (The type and value of such expressions can be obtained by other means, at a cost in complexity.)
Function.ValueForExpr queries the DebugRef info to return the ssa.Value of a given Expr.
Added tests.
Also:
- the DebugInfo flag is now per package, not global.
It must be set between Create and Build phases if desired.
- {Value,Instruction}.Pos() documentation updated: we still maintain
this information in the instruction stream even in non-debug mode,
but we make fewer claims about its invariants.
- Go and Defer instructions can now use their respective go/defer
token positions (not the call's lparen), so they do.
- SelectState:
Posn token.Pos indicates the <- position
DebugNode ast.Expr is the send stmt or receive expr.
- In building SelectStmt, we introduce extra temporaries in debug
mode to hold the result of the receive in 'case <-ch' even though
this value isn't ordinarily needed.
- Use *SelectState (indirectly) since the struct is getting bigger.
- Document some missing instructions in doc.go.
R=gri
CC=golang-dev
https://golang.org/cl/12147043
117 lines
2.8 KiB
Go
117 lines
2.8 KiB
Go
package ssa
|
|
|
|
// lvalues are the union of addressable expressions and map-index
|
|
// expressions.
|
|
|
|
import (
|
|
"go/ast"
|
|
"go/token"
|
|
|
|
"code.google.com/p/go.tools/go/types"
|
|
)
|
|
|
|
// An lvalue represents an assignable location that may appear on the
|
|
// left-hand side of an assignment. This is a generalization of a
|
|
// pointer to permit updates to elements of maps.
|
|
//
|
|
type lvalue interface {
|
|
store(fn *Function, v Value) // stores v into the location
|
|
load(fn *Function) Value // loads the contents of the location
|
|
address(fn *Function) Value // address of the location
|
|
typ() types.Type // returns the type of the location
|
|
}
|
|
|
|
// An address is an lvalue represented by a true pointer.
|
|
type address struct {
|
|
addr Value
|
|
starPos token.Pos // source position, if from explicit *addr
|
|
expr ast.Expr // source syntax [debug mode]
|
|
object types.Object // source var, if from *ast.Ident
|
|
}
|
|
|
|
func (a *address) load(fn *Function) Value {
|
|
load := emitLoad(fn, a.addr)
|
|
load.pos = a.starPos
|
|
return load
|
|
}
|
|
|
|
func (a *address) store(fn *Function, v Value) {
|
|
store := emitStore(fn, a.addr, v)
|
|
store.pos = a.starPos
|
|
if a.expr != nil {
|
|
// store.Val is v converted for assignability.
|
|
emitDebugRef(fn, a.expr, store.Val)
|
|
}
|
|
}
|
|
|
|
func (a *address) address(fn *Function) Value {
|
|
if a.expr != nil {
|
|
// NB: this kind of DebugRef yields the object's address.
|
|
emitDebugRef(fn, a.expr, a.addr)
|
|
}
|
|
return a.addr
|
|
}
|
|
|
|
func (a *address) typ() types.Type {
|
|
return deref(a.addr.Type())
|
|
}
|
|
|
|
// An element is an lvalue represented by m[k], the location of an
|
|
// element of a map or string. These locations are not addressable
|
|
// since pointers cannot be formed from them, but they do support
|
|
// load(), and in the case of maps, store().
|
|
//
|
|
type element struct {
|
|
m, k Value // map or string
|
|
t types.Type // map element type or string byte type
|
|
}
|
|
|
|
func (e *element) load(fn *Function) Value {
|
|
l := &Lookup{
|
|
X: e.m,
|
|
Index: e.k,
|
|
}
|
|
l.setType(e.t)
|
|
return fn.emit(l)
|
|
}
|
|
|
|
func (e *element) store(fn *Function, v Value) {
|
|
fn.emit(&MapUpdate{
|
|
Map: e.m,
|
|
Key: e.k,
|
|
Value: emitConv(fn, v, e.t),
|
|
})
|
|
}
|
|
|
|
func (e *element) address(fn *Function) Value {
|
|
panic("map/string elements are not addressable")
|
|
}
|
|
|
|
func (e *element) typ() types.Type {
|
|
return e.t
|
|
}
|
|
|
|
// A blanks is a dummy variable whose name is "_".
|
|
// It is not reified: loads are illegal and stores are ignored.
|
|
//
|
|
type blank struct{}
|
|
|
|
func (bl blank) load(fn *Function) Value {
|
|
panic("blank.load is illegal")
|
|
}
|
|
|
|
func (bl blank) store(fn *Function, v Value) {
|
|
// no-op
|
|
}
|
|
|
|
func (bl blank) address(fn *Function) Value {
|
|
panic("blank var is not addressable")
|
|
}
|
|
|
|
func (bl blank) typ() types.Type {
|
|
// This should be the type of the blank Ident; the typechecker
|
|
// doesn't provide this yet, but fortunately, we don't need it
|
|
// yet either.
|
|
panic("blank.typ is unimplemented")
|
|
}
|