1 // Copyright 2013 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package ssa 6 7 // This file defines utilities for working with source positions 8 // or source-level named entities ("objects"). 9 10 // TODO(adonovan): test that {Value,Instruction}.Pos() positions match 11 // the originating syntax, as specified. 12 13 import ( 14 "go/ast" 15 "go/token" 16 "go/types" 17 18 "golang.org/x/tools/internal/typeparams" 19 ) 20 21 // EnclosingFunction returns the function that contains the syntax 22 // node denoted by path. 23 // 24 // Syntax associated with package-level variable specifications is 25 // enclosed by the package's init() function. 26 // 27 // Returns nil if not found; reasons might include: 28 // - the node is not enclosed by any function. 29 // - the node is within an anonymous function (FuncLit) and 30 // its SSA function has not been created yet 31 // (pkg.Build() has not yet been called). 32 func EnclosingFunction(pkg *Package, path []ast.Node) *Function { 33 // Start with package-level function... 34 fn := findEnclosingPackageLevelFunction(pkg, path) 35 if fn == nil { 36 return nil // not in any function 37 } 38 39 // ...then walk down the nested anonymous functions. 40 n := len(path) 41 outer: 42 for i := range path { 43 if lit, ok := path[n-1-i].(*ast.FuncLit); ok { 44 for _, anon := range fn.AnonFuncs { 45 if anon.Pos() == lit.Type.Func { 46 fn = anon 47 continue outer 48 } 49 } 50 // SSA function not found: 51 // - package not yet built, or maybe 52 // - builder skipped FuncLit in dead block 53 // (in principle; but currently the Builder 54 // generates even dead FuncLits). 55 return nil 56 } 57 } 58 return fn 59 } 60 61 // HasEnclosingFunction returns true if the AST node denoted by path 62 // is contained within the declaration of some function or 63 // package-level variable. 64 // 65 // Unlike EnclosingFunction, the behaviour of this function does not 66 // depend on whether SSA code for pkg has been built, so it can be 67 // used to quickly reject check inputs that will cause 68 // EnclosingFunction to fail, prior to SSA building. 69 func HasEnclosingFunction(pkg *Package, path []ast.Node) bool { 70 return findEnclosingPackageLevelFunction(pkg, path) != nil 71 } 72 73 // findEnclosingPackageLevelFunction returns the Function 74 // corresponding to the package-level function enclosing path. 75 func findEnclosingPackageLevelFunction(pkg *Package, path []ast.Node) *Function { 76 if n := len(path); n >= 2 { // [... {Gen,Func}Decl File] 77 switch decl := path[n-2].(type) { 78 case *ast.GenDecl: 79 if decl.Tok == token.VAR && n >= 3 { 80 // Package-level 'var' initializer. 81 return pkg.init 82 } 83 84 case *ast.FuncDecl: 85 if decl.Recv == nil && decl.Name.Name == "init" { 86 // Explicit init() function. 87 for _, b := range pkg.init.Blocks { 88 for _, instr := range b.Instrs { 89 if instr, ok := instr.(*Call); ok { 90 if callee, ok := instr.Call.Value.(*Function); ok && callee.Pkg == pkg && callee.Pos() == decl.Name.NamePos { 91 return callee 92 } 93 } 94 } 95 } 96 // Hack: return non-nil when SSA is not yet 97 // built so that HasEnclosingFunction works. 98 return pkg.init 99 } 100 // Declared function/method. 101 return findNamedFunc(pkg, decl.Name.NamePos) 102 } 103 } 104 return nil // not in any function 105 } 106 107 // findNamedFunc returns the named function whose FuncDecl.Ident is at 108 // position pos. 109 func findNamedFunc(pkg *Package, pos token.Pos) *Function { 110 // Look at all package members and method sets of named types. 111 // Not very efficient. 112 for _, mem := range pkg.Members { 113 switch mem := mem.(type) { 114 case *Function: 115 if mem.Pos() == pos { 116 return mem 117 } 118 case *Type: 119 mset := pkg.Prog.MethodSets.MethodSet(types.NewPointer(mem.Type())) 120 for i, n := 0, mset.Len(); i < n; i++ { 121 // Don't call Program.Method: avoid creating wrappers. 122 obj := mset.At(i).Obj().(*types.Func) 123 if obj.Pos() == pos { 124 return pkg.objects[obj].(*Function) 125 } 126 } 127 } 128 } 129 return nil 130 } 131 132 // ValueForExpr returns the SSA Value that corresponds to non-constant 133 // expression e. 134 // 135 // It returns nil if no value was found, e.g. 136 // - the expression is not lexically contained within f; 137 // - f was not built with debug information; or 138 // - e is a constant expression. (For efficiency, no debug 139 // information is stored for constants. Use 140 // go/types.Info.Types[e].Value instead.) 141 // - e is a reference to nil or a built-in function. 142 // - the value was optimised away. 143 // 144 // If e is an addressable expression used in an lvalue context, 145 // value is the address denoted by e, and isAddr is true. 146 // 147 // The types of e (or &e, if isAddr) and the result are equal 148 // (modulo "untyped" bools resulting from comparisons). 149 // 150 // (Tip: to find the ssa.Value given a source position, use 151 // astutil.PathEnclosingInterval to locate the ast.Node, then 152 // EnclosingFunction to locate the Function, then ValueForExpr to find 153 // the ssa.Value.) 154 func (f *Function) ValueForExpr(e ast.Expr) (value Value, isAddr bool) { 155 if f.debugInfo() { // (opt) 156 e = unparen(e) 157 for _, b := range f.Blocks { 158 for _, instr := range b.Instrs { 159 if ref, ok := instr.(*DebugRef); ok { 160 if ref.Expr == e { 161 return ref.X, ref.IsAddr 162 } 163 } 164 } 165 } 166 } 167 return 168 } 169 170 // --- Lookup functions for source-level named entities (types.Objects) --- 171 172 // Package returns the SSA Package corresponding to the specified 173 // type-checker package object. 174 // It returns nil if no such SSA package has been created. 175 func (prog *Program) Package(obj *types.Package) *Package { 176 return prog.packages[obj] 177 } 178 179 // packageLevelMember returns the package-level member corresponding to 180 // the specified named object, which may be a package-level const 181 // (*NamedConst), var (*Global) or func (*Function) of some package in 182 // prog. It returns nil if the object is not found. 183 func (prog *Program) packageLevelMember(obj types.Object) Member { 184 if pkg, ok := prog.packages[obj.Pkg()]; ok { 185 return pkg.objects[obj] 186 } 187 return nil 188 } 189 190 // originFunc returns the package-level generic function that is the 191 // origin of obj. If returns nil if the generic function is not found. 192 func (prog *Program) originFunc(obj *types.Func) *Function { 193 return prog.declaredFunc(typeparams.OriginMethod(obj)) 194 } 195 196 // FuncValue returns the concrete Function denoted by the source-level 197 // named function obj, or nil if obj denotes an interface method. 198 // 199 // TODO(adonovan): check the invariant that obj.Type() matches the 200 // result's Signature, both in the params/results and in the receiver. 201 func (prog *Program) FuncValue(obj *types.Func) *Function { 202 fn, _ := prog.packageLevelMember(obj).(*Function) 203 return fn 204 } 205 206 // ConstValue returns the SSA Value denoted by the source-level named 207 // constant obj. 208 func (prog *Program) ConstValue(obj *types.Const) *Const { 209 // TODO(adonovan): opt: share (don't reallocate) 210 // Consts for const objects and constant ast.Exprs. 211 212 // Universal constant? {true,false,nil} 213 if obj.Parent() == types.Universe { 214 return NewConst(obj.Val(), obj.Type()) 215 } 216 // Package-level named constant? 217 if v := prog.packageLevelMember(obj); v != nil { 218 return v.(*NamedConst).Value 219 } 220 return NewConst(obj.Val(), obj.Type()) 221 } 222 223 // VarValue returns the SSA Value that corresponds to a specific 224 // identifier denoting the source-level named variable obj. 225 // 226 // VarValue returns nil if a local variable was not found, perhaps 227 // because its package was not built, the debug information was not 228 // requested during SSA construction, or the value was optimized away. 229 // 230 // ref is the path to an ast.Ident (e.g. from PathEnclosingInterval), 231 // and that ident must resolve to obj. 232 // 233 // pkg is the package enclosing the reference. (A reference to a var 234 // always occurs within a function, so we need to know where to find it.) 235 // 236 // If the identifier is a field selector and its base expression is 237 // non-addressable, then VarValue returns the value of that field. 238 // For example: 239 // 240 // func f() struct {x int} 241 // f().x // VarValue(x) returns a *Field instruction of type int 242 // 243 // All other identifiers denote addressable locations (variables). 244 // For them, VarValue may return either the variable's address or its 245 // value, even when the expression is evaluated only for its value; the 246 // situation is reported by isAddr, the second component of the result. 247 // 248 // If !isAddr, the returned value is the one associated with the 249 // specific identifier. For example, 250 // 251 // var x int // VarValue(x) returns Const 0 here 252 // x = 1 // VarValue(x) returns Const 1 here 253 // 254 // It is not specified whether the value or the address is returned in 255 // any particular case, as it may depend upon optimizations performed 256 // during SSA code generation, such as registerization, constant 257 // folding, avoidance of materialization of subexpressions, etc. 258 func (prog *Program) VarValue(obj *types.Var, pkg *Package, ref []ast.Node) (value Value, isAddr bool) { 259 // All references to a var are local to some function, possibly init. 260 fn := EnclosingFunction(pkg, ref) 261 if fn == nil { 262 return // e.g. def of struct field; SSA not built? 263 } 264 265 id := ref[0].(*ast.Ident) 266 267 // Defining ident of a parameter? 268 if id.Pos() == obj.Pos() { 269 for _, param := range fn.Params { 270 if param.Object() == obj { 271 return param, false 272 } 273 } 274 } 275 276 // Other ident? 277 for _, b := range fn.Blocks { 278 for _, instr := range b.Instrs { 279 if dr, ok := instr.(*DebugRef); ok { 280 if dr.Pos() == id.Pos() { 281 return dr.X, dr.IsAddr 282 } 283 } 284 } 285 } 286 287 // Defining ident of package-level var? 288 if v := prog.packageLevelMember(obj); v != nil { 289 return v.(*Global), true 290 } 291 292 return // e.g. debug info not requested, or var optimized away 293 } 294