| // 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 |
| |
| // This package defines the treatment of intrinsics, i.e. library |
| // functions requiring special analytical treatment. |
| // |
| // Most of these are C or assembly functions, but even some Go |
| // functions require may special treatment if the analysis completely |
| // replaces the implementation of an API such as reflection. |
| |
| // TODO(adonovan): support a means of writing analytic summaries in |
| // the target code, so that users can summarise the effects of their |
| // own C functions using a snippet of Go. |
| |
| import ( |
| "fmt" |
| "go/types" |
| |
| "golang.org/x/tools/go/ssa" |
| ) |
| |
| // Instances of 'intrinsic' generate analysis constraints for calls to |
| // intrinsic functions. |
| // Implementations may exploit information from the calling site |
| // via cgn.callersite; for shared contours this is nil. |
| type intrinsic func(a *analysis, cgn *cgnode) |
| |
| // Initialized in explicit init() to defeat (spurious) initialization |
| // cycle error. |
| var intrinsicsByName = make(map[string]intrinsic) |
| |
| func init() { |
| // Key strings are from Function.String(). |
| // That little dot ۰ is an Arabic zero numeral (U+06F0), |
| // categories [Nd]. |
| for name, fn := range map[string]intrinsic{ |
| // Other packages. |
| "bytes.Equal": ext۰NoEffect, |
| "bytes.IndexByte": ext۰NoEffect, |
| "crypto/aes.decryptBlockAsm": ext۰NoEffect, |
| "crypto/aes.encryptBlockAsm": ext۰NoEffect, |
| "crypto/aes.expandKeyAsm": ext۰NoEffect, |
| "crypto/aes.hasAsm": ext۰NoEffect, |
| "crypto/md5.block": ext۰NoEffect, |
| "crypto/rc4.xorKeyStream": ext۰NoEffect, |
| "crypto/sha1.block": ext۰NoEffect, |
| "crypto/sha256.block": ext۰NoEffect, |
| "hash/crc32.castagnoliSSE42": ext۰NoEffect, |
| "hash/crc32.haveSSE42": ext۰NoEffect, |
| "math.Abs": ext۰NoEffect, |
| "math.Acos": ext۰NoEffect, |
| "math.Asin": ext۰NoEffect, |
| "math.Atan": ext۰NoEffect, |
| "math.Atan2": ext۰NoEffect, |
| "math.Ceil": ext۰NoEffect, |
| "math.Cos": ext۰NoEffect, |
| "math.Dim": ext۰NoEffect, |
| "math.Exp": ext۰NoEffect, |
| "math.Exp2": ext۰NoEffect, |
| "math.Expm1": ext۰NoEffect, |
| "math.Float32bits": ext۰NoEffect, |
| "math.Float32frombits": ext۰NoEffect, |
| "math.Float64bits": ext۰NoEffect, |
| "math.Float64frombits": ext۰NoEffect, |
| "math.Floor": ext۰NoEffect, |
| "math.Frexp": ext۰NoEffect, |
| "math.Hypot": ext۰NoEffect, |
| "math.Ldexp": ext۰NoEffect, |
| "math.Log": ext۰NoEffect, |
| "math.Log10": ext۰NoEffect, |
| "math.Log1p": ext۰NoEffect, |
| "math.Log2": ext۰NoEffect, |
| "math.Max": ext۰NoEffect, |
| "math.Min": ext۰NoEffect, |
| "math.Mod": ext۰NoEffect, |
| "math.Modf": ext۰NoEffect, |
| "math.Remainder": ext۰NoEffect, |
| "math.Sin": ext۰NoEffect, |
| "math.Sincos": ext۰NoEffect, |
| "math.Sqrt": ext۰NoEffect, |
| "math.Tan": ext۰NoEffect, |
| "math.Trunc": ext۰NoEffect, |
| "math/big.addMulVVW": ext۰NoEffect, |
| "math/big.addVV": ext۰NoEffect, |
| "math/big.addVW": ext۰NoEffect, |
| "math/big.bitLen": ext۰NoEffect, |
| "math/big.divWVW": ext۰NoEffect, |
| "math/big.divWW": ext۰NoEffect, |
| "math/big.mulAddVWW": ext۰NoEffect, |
| "math/big.mulWW": ext۰NoEffect, |
| "math/big.shlVU": ext۰NoEffect, |
| "math/big.shrVU": ext۰NoEffect, |
| "math/big.subVV": ext۰NoEffect, |
| "math/big.subVW": ext۰NoEffect, |
| "net.runtime_Semacquire": ext۰NoEffect, |
| "net.runtime_Semrelease": ext۰NoEffect, |
| "net.runtime_pollClose": ext۰NoEffect, |
| "net.runtime_pollOpen": ext۰NoEffect, |
| "net.runtime_pollReset": ext۰NoEffect, |
| "net.runtime_pollServerInit": ext۰NoEffect, |
| "net.runtime_pollSetDeadline": ext۰NoEffect, |
| "net.runtime_pollUnblock": ext۰NoEffect, |
| "net.runtime_pollWait": ext۰NoEffect, |
| "net.runtime_pollWaitCanceled": ext۰NoEffect, |
| "os.epipecheck": ext۰NoEffect, |
| // All other runtime functions are treated as NoEffect. |
| "runtime.SetFinalizer": ext۰runtime۰SetFinalizer, |
| "strings.IndexByte": ext۰NoEffect, |
| "sync.runtime_Semacquire": ext۰NoEffect, |
| "sync.runtime_Semrelease": ext۰NoEffect, |
| "sync.runtime_Syncsemacquire": ext۰NoEffect, |
| "sync.runtime_Syncsemcheck": ext۰NoEffect, |
| "sync.runtime_Syncsemrelease": ext۰NoEffect, |
| "sync.runtime_procPin": ext۰NoEffect, |
| "sync.runtime_procUnpin": ext۰NoEffect, |
| "sync.runtime_registerPool": ext۰NoEffect, |
| "sync/atomic.AddInt32": ext۰NoEffect, |
| "sync/atomic.AddInt64": ext۰NoEffect, |
| "sync/atomic.AddUint32": ext۰NoEffect, |
| "sync/atomic.AddUint64": ext۰NoEffect, |
| "sync/atomic.AddUintptr": ext۰NoEffect, |
| "sync/atomic.CompareAndSwapInt32": ext۰NoEffect, |
| "sync/atomic.CompareAndSwapUint32": ext۰NoEffect, |
| "sync/atomic.CompareAndSwapUint64": ext۰NoEffect, |
| "sync/atomic.CompareAndSwapUintptr": ext۰NoEffect, |
| "sync/atomic.LoadInt32": ext۰NoEffect, |
| "sync/atomic.LoadInt64": ext۰NoEffect, |
| "sync/atomic.LoadPointer": ext۰NoEffect, // ignore unsafe.Pointers |
| "sync/atomic.LoadUint32": ext۰NoEffect, |
| "sync/atomic.LoadUint64": ext۰NoEffect, |
| "sync/atomic.LoadUintptr": ext۰NoEffect, |
| "sync/atomic.StoreInt32": ext۰NoEffect, |
| "sync/atomic.StorePointer": ext۰NoEffect, // ignore unsafe.Pointers |
| "sync/atomic.StoreUint32": ext۰NoEffect, |
| "sync/atomic.StoreUintptr": ext۰NoEffect, |
| "syscall.Close": ext۰NoEffect, |
| "syscall.Exit": ext۰NoEffect, |
| "syscall.Getpid": ext۰NoEffect, |
| "syscall.Getwd": ext۰NoEffect, |
| "syscall.Kill": ext۰NoEffect, |
| "syscall.RawSyscall": ext۰NoEffect, |
| "syscall.RawSyscall6": ext۰NoEffect, |
| "syscall.Syscall": ext۰NoEffect, |
| "syscall.Syscall6": ext۰NoEffect, |
| "syscall.runtime_AfterFork": ext۰NoEffect, |
| "syscall.runtime_BeforeFork": ext۰NoEffect, |
| "syscall.setenv_c": ext۰NoEffect, |
| "time.Sleep": ext۰NoEffect, |
| "time.now": ext۰NoEffect, |
| "time.startTimer": ext۰time۰startTimer, |
| "time.stopTimer": ext۰NoEffect, |
| } { |
| intrinsicsByName[name] = fn |
| } |
| } |
| |
| // findIntrinsic returns the constraint generation function for an |
| // intrinsic function fn, or nil if the function should be handled normally. |
| // |
| func (a *analysis) findIntrinsic(fn *ssa.Function) intrinsic { |
| // Consult the *Function-keyed cache. |
| // A cached nil indicates a normal non-intrinsic function. |
| impl, ok := a.intrinsics[fn] |
| if !ok { |
| impl = intrinsicsByName[fn.String()] // may be nil |
| |
| if a.isReflect(fn) { |
| if !a.config.Reflection { |
| impl = ext۰NoEffect // reflection disabled |
| } else if impl == nil { |
| // Ensure all "reflect" code is treated intrinsically. |
| impl = ext۰NotYetImplemented |
| } |
| } else if impl == nil && fn.Pkg != nil && fn.Pkg.Pkg.Path() == "runtime" { |
| // Ignore "runtime" (except SetFinalizer): |
| // it has few interesting effects on aliasing |
| // and is full of unsafe code we can't analyze. |
| impl = ext۰NoEffect |
| } |
| |
| a.intrinsics[fn] = impl |
| } |
| return impl |
| } |
| |
| // isReflect reports whether fn belongs to the "reflect" package. |
| func (a *analysis) isReflect(fn *ssa.Function) bool { |
| if a.reflectValueObj == nil { |
| return false // "reflect" package not loaded |
| } |
| reflectPackage := a.reflectValueObj.Pkg() |
| if fn.Pkg != nil && fn.Pkg.Pkg == reflectPackage { |
| return true |
| } |
| // Synthetic wrappers have a nil Pkg, so they slip through the |
| // previous check. Check the receiver package. |
| // TODO(adonovan): should synthetic wrappers have a non-nil Pkg? |
| if recv := fn.Signature.Recv(); recv != nil { |
| if named, ok := deref(recv.Type()).(*types.Named); ok { |
| if named.Obj().Pkg() == reflectPackage { |
| return true // e.g. wrapper of (reflect.Value).f |
| } |
| } |
| } |
| return false |
| } |
| |
| // A trivial intrinsic suitable for any function that does not: |
| // 1) induce aliases between its arguments or any global variables; |
| // 2) call any functions; or |
| // 3) create any labels. |
| // |
| // Many intrinsics (such as CompareAndSwapInt32) have a fourth kind of |
| // effect: loading or storing through a pointer. Though these could |
| // be significant, we deliberately ignore them because they are |
| // generally not worth the effort. |
| // |
| // We sometimes violate condition #3 if the function creates only |
| // non-function labels, as the control-flow graph is still sound. |
| // |
| func ext۰NoEffect(a *analysis, cgn *cgnode) {} |
| |
| func ext۰NotYetImplemented(a *analysis, cgn *cgnode) { |
| fn := cgn.fn |
| a.warnf(fn.Pos(), "unsound: intrinsic treatment of %s not yet implemented", fn) |
| } |
| |
| // ---------- func runtime.SetFinalizer(x, f interface{}) ---------- |
| |
| // runtime.SetFinalizer(x, f) |
| type runtimeSetFinalizerConstraint struct { |
| targets nodeid // (indirect) |
| f nodeid // (ptr) |
| x nodeid |
| } |
| |
| func (c *runtimeSetFinalizerConstraint) ptr() nodeid { return c.f } |
| func (c *runtimeSetFinalizerConstraint) presolve(h *hvn) { |
| h.markIndirect(onodeid(c.targets), "SetFinalizer.targets") |
| } |
| func (c *runtimeSetFinalizerConstraint) renumber(mapping []nodeid) { |
| c.targets = mapping[c.targets] |
| c.f = mapping[c.f] |
| c.x = mapping[c.x] |
| } |
| |
| func (c *runtimeSetFinalizerConstraint) String() string { |
| return fmt.Sprintf("runtime.SetFinalizer(n%d, n%d)", c.x, c.f) |
| } |
| |
| func (c *runtimeSetFinalizerConstraint) solve(a *analysis, delta *nodeset) { |
| for _, fObj := range delta.AppendTo(a.deltaSpace) { |
| tDyn, f, indirect := a.taggedValue(nodeid(fObj)) |
| if indirect { |
| // TODO(adonovan): we'll need to implement this |
| // when we start creating indirect tagged objects. |
| panic("indirect tagged object") |
| } |
| |
| tSig, ok := tDyn.Underlying().(*types.Signature) |
| if !ok { |
| continue // not a function |
| } |
| if tSig.Recv() != nil { |
| panic(tSig) |
| } |
| if tSig.Params().Len() != 1 { |
| continue // not a unary function |
| } |
| |
| // Extract x to tmp. |
| tx := tSig.Params().At(0).Type() |
| tmp := a.addNodes(tx, "SetFinalizer.tmp") |
| a.typeAssert(tx, tmp, c.x, false) |
| |
| // Call f(tmp). |
| a.store(f, tmp, 1, a.sizeof(tx)) |
| |
| // Add dynamic call target. |
| if a.onlineCopy(c.targets, f) { |
| a.addWork(c.targets) |
| } |
| } |
| } |
| |
| func ext۰runtime۰SetFinalizer(a *analysis, cgn *cgnode) { |
| // This is the shared contour, used for dynamic calls. |
| targets := a.addOneNode(tInvalid, "SetFinalizer.targets", nil) |
| cgn.sites = append(cgn.sites, &callsite{targets: targets}) |
| params := a.funcParams(cgn.obj) |
| a.addConstraint(&runtimeSetFinalizerConstraint{ |
| targets: targets, |
| x: params, |
| f: params + 1, |
| }) |
| } |
| |
| // ---------- func time.startTimer(t *runtimeTimer) ---------- |
| |
| // time.StartTimer(t) |
| type timeStartTimerConstraint struct { |
| targets nodeid // (indirect) |
| t nodeid // (ptr) |
| } |
| |
| func (c *timeStartTimerConstraint) ptr() nodeid { return c.t } |
| func (c *timeStartTimerConstraint) presolve(h *hvn) { |
| h.markIndirect(onodeid(c.targets), "StartTimer.targets") |
| } |
| func (c *timeStartTimerConstraint) renumber(mapping []nodeid) { |
| c.targets = mapping[c.targets] |
| c.t = mapping[c.t] |
| } |
| |
| func (c *timeStartTimerConstraint) String() string { |
| return fmt.Sprintf("time.startTimer(n%d)", c.t) |
| } |
| |
| func (c *timeStartTimerConstraint) solve(a *analysis, delta *nodeset) { |
| for _, tObj := range delta.AppendTo(a.deltaSpace) { |
| t := nodeid(tObj) |
| |
| // We model startTimer as if it was defined thus: |
| // func startTimer(t *runtimeTimer) { t.f(t.arg) } |
| |
| // We hard-code the field offsets of time.runtimeTimer: |
| // type runtimeTimer struct { |
| // 0 __identity__ |
| // 1 i int32 |
| // 2 when int64 |
| // 3 period int64 |
| // 4 f func(int64, interface{}) |
| // 5 arg interface{} |
| // } |
| f := t + 4 |
| arg := t + 5 |
| |
| // store t.arg to t.f.params[0] |
| // (offset 1 => skip identity) |
| a.store(f, arg, 1, 1) |
| |
| // Add dynamic call target. |
| if a.onlineCopy(c.targets, f) { |
| a.addWork(c.targets) |
| } |
| } |
| } |
| |
| func ext۰time۰startTimer(a *analysis, cgn *cgnode) { |
| // This is the shared contour, used for dynamic calls. |
| targets := a.addOneNode(tInvalid, "startTimer.targets", nil) |
| cgn.sites = append(cgn.sites, &callsite{targets: targets}) |
| params := a.funcParams(cgn.obj) |
| a.addConstraint(&timeStartTimerConstraint{ |
| targets: targets, |
| t: params, |
| }) |
| } |
