--- /dev/null
+// 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 file implements the generation and resolution rules for
+// constraints arising from the use of reflection in the target
+// program. See doc.go for explanation of the representation.
+//
+// For consistency, the names of all parameters match those of the
+// actual functions in the "reflect" package.
+//
+// To avoid proliferation of equivalent labels, intrinsics should
+// memoize as much as possible, like TypeOf and Zero do for their
+// tagged objects.
+//
+// TODO(adonovan): this file is rather subtle. Explain how we derive
+// the implementation of each reflect operator from its spec,
+// including the subtleties of reflect.flag{Addr,RO,Indir}.
+// [Hint: our implementation is as if reflect.flagIndir was always
+// true, i.e. reflect.Values are pointers to tagged objects, there is
+// no inline allocation optimization; and indirect tagged objects (not
+// yet implemented) correspond to reflect.Values with
+// reflect.flagAddr.]
+// A picture would help too.
+//
+// TODO(adonovan): try factoring up the common parts of the majority of
+// these constraints that are single input, single output.
+
+import (
+ "fmt"
+ "go/constant"
+ "go/types"
+ "reflect"
+
+ "golang.org/x/tools/go/ssa"
+)
+
+func init() {
+ for name, fn := range map[string]intrinsic{
+ // reflect.Value methods.
+ "(reflect.Value).Addr": ext۰reflect۰Value۰Addr,
+ "(reflect.Value).Bool": ext۰NoEffect,
+ "(reflect.Value).Bytes": ext۰reflect۰Value۰Bytes,
+ "(reflect.Value).Call": ext۰reflect۰Value۰Call,
+ "(reflect.Value).CallSlice": ext۰reflect۰Value۰CallSlice,
+ "(reflect.Value).CanAddr": ext۰NoEffect,
+ "(reflect.Value).CanInterface": ext۰NoEffect,
+ "(reflect.Value).CanSet": ext۰NoEffect,
+ "(reflect.Value).Cap": ext۰NoEffect,
+ "(reflect.Value).Close": ext۰NoEffect,
+ "(reflect.Value).Complex": ext۰NoEffect,
+ "(reflect.Value).Convert": ext۰reflect۰Value۰Convert,
+ "(reflect.Value).Elem": ext۰reflect۰Value۰Elem,
+ "(reflect.Value).Field": ext۰reflect۰Value۰Field,
+ "(reflect.Value).FieldByIndex": ext۰reflect۰Value۰FieldByIndex,
+ "(reflect.Value).FieldByName": ext۰reflect۰Value۰FieldByName,
+ "(reflect.Value).FieldByNameFunc": ext۰reflect۰Value۰FieldByNameFunc,
+ "(reflect.Value).Float": ext۰NoEffect,
+ "(reflect.Value).Index": ext۰reflect۰Value۰Index,
+ "(reflect.Value).Int": ext۰NoEffect,
+ "(reflect.Value).Interface": ext۰reflect۰Value۰Interface,
+ "(reflect.Value).InterfaceData": ext۰NoEffect,
+ "(reflect.Value).IsNil": ext۰NoEffect,
+ "(reflect.Value).IsValid": ext۰NoEffect,
+ "(reflect.Value).Kind": ext۰NoEffect,
+ "(reflect.Value).Len": ext۰NoEffect,
+ "(reflect.Value).MapIndex": ext۰reflect۰Value۰MapIndex,
+ "(reflect.Value).MapKeys": ext۰reflect۰Value۰MapKeys,
+ "(reflect.Value).Method": ext۰reflect۰Value۰Method,
+ "(reflect.Value).MethodByName": ext۰reflect۰Value۰MethodByName,
+ "(reflect.Value).NumField": ext۰NoEffect,
+ "(reflect.Value).NumMethod": ext۰NoEffect,
+ "(reflect.Value).OverflowComplex": ext۰NoEffect,
+ "(reflect.Value).OverflowFloat": ext۰NoEffect,
+ "(reflect.Value).OverflowInt": ext۰NoEffect,
+ "(reflect.Value).OverflowUint": ext۰NoEffect,
+ "(reflect.Value).Pointer": ext۰NoEffect,
+ "(reflect.Value).Recv": ext۰reflect۰Value۰Recv,
+ "(reflect.Value).Send": ext۰reflect۰Value۰Send,
+ "(reflect.Value).Set": ext۰reflect۰Value۰Set,
+ "(reflect.Value).SetBool": ext۰NoEffect,
+ "(reflect.Value).SetBytes": ext۰reflect۰Value۰SetBytes,
+ "(reflect.Value).SetComplex": ext۰NoEffect,
+ "(reflect.Value).SetFloat": ext۰NoEffect,
+ "(reflect.Value).SetInt": ext۰NoEffect,
+ "(reflect.Value).SetLen": ext۰NoEffect,
+ "(reflect.Value).SetMapIndex": ext۰reflect۰Value۰SetMapIndex,
+ "(reflect.Value).SetPointer": ext۰reflect۰Value۰SetPointer,
+ "(reflect.Value).SetString": ext۰NoEffect,
+ "(reflect.Value).SetUint": ext۰NoEffect,
+ "(reflect.Value).Slice": ext۰reflect۰Value۰Slice,
+ "(reflect.Value).String": ext۰NoEffect,
+ "(reflect.Value).TryRecv": ext۰reflect۰Value۰Recv,
+ "(reflect.Value).TrySend": ext۰reflect۰Value۰Send,
+ "(reflect.Value).Type": ext۰NoEffect,
+ "(reflect.Value).Uint": ext۰NoEffect,
+ "(reflect.Value).UnsafeAddr": ext۰NoEffect,
+
+ // Standalone reflect.* functions.
+ "reflect.Append": ext۰reflect۰Append,
+ "reflect.AppendSlice": ext۰reflect۰AppendSlice,
+ "reflect.Copy": ext۰reflect۰Copy,
+ "reflect.ChanOf": ext۰reflect۰ChanOf,
+ "reflect.DeepEqual": ext۰NoEffect,
+ "reflect.Indirect": ext۰reflect۰Indirect,
+ "reflect.MakeChan": ext۰reflect۰MakeChan,
+ "reflect.MakeFunc": ext۰reflect۰MakeFunc,
+ "reflect.MakeMap": ext۰reflect۰MakeMap,
+ "reflect.MakeSlice": ext۰reflect۰MakeSlice,
+ "reflect.MapOf": ext۰reflect۰MapOf,
+ "reflect.New": ext۰reflect۰New,
+ "reflect.NewAt": ext۰reflect۰NewAt,
+ "reflect.PtrTo": ext۰reflect۰PtrTo,
+ "reflect.Select": ext۰reflect۰Select,
+ "reflect.SliceOf": ext۰reflect۰SliceOf,
+ "reflect.TypeOf": ext۰reflect۰TypeOf,
+ "reflect.ValueOf": ext۰reflect۰ValueOf,
+ "reflect.Zero": ext۰reflect۰Zero,
+ "reflect.init": ext۰NoEffect,
+
+ // *reflect.rtype methods
+ "(*reflect.rtype).Align": ext۰NoEffect,
+ "(*reflect.rtype).AssignableTo": ext۰NoEffect,
+ "(*reflect.rtype).Bits": ext۰NoEffect,
+ "(*reflect.rtype).ChanDir": ext۰NoEffect,
+ "(*reflect.rtype).ConvertibleTo": ext۰NoEffect,
+ "(*reflect.rtype).Elem": ext۰reflect۰rtype۰Elem,
+ "(*reflect.rtype).Field": ext۰reflect۰rtype۰Field,
+ "(*reflect.rtype).FieldAlign": ext۰NoEffect,
+ "(*reflect.rtype).FieldByIndex": ext۰reflect۰rtype۰FieldByIndex,
+ "(*reflect.rtype).FieldByName": ext۰reflect۰rtype۰FieldByName,
+ "(*reflect.rtype).FieldByNameFunc": ext۰reflect۰rtype۰FieldByNameFunc,
+ "(*reflect.rtype).Implements": ext۰NoEffect,
+ "(*reflect.rtype).In": ext۰reflect۰rtype۰In,
+ "(*reflect.rtype).IsVariadic": ext۰NoEffect,
+ "(*reflect.rtype).Key": ext۰reflect۰rtype۰Key,
+ "(*reflect.rtype).Kind": ext۰NoEffect,
+ "(*reflect.rtype).Len": ext۰NoEffect,
+ "(*reflect.rtype).Method": ext۰reflect۰rtype۰Method,
+ "(*reflect.rtype).MethodByName": ext۰reflect۰rtype۰MethodByName,
+ "(*reflect.rtype).Name": ext۰NoEffect,
+ "(*reflect.rtype).NumField": ext۰NoEffect,
+ "(*reflect.rtype).NumIn": ext۰NoEffect,
+ "(*reflect.rtype).NumMethod": ext۰NoEffect,
+ "(*reflect.rtype).NumOut": ext۰NoEffect,
+ "(*reflect.rtype).Out": ext۰reflect۰rtype۰Out,
+ "(*reflect.rtype).PkgPath": ext۰NoEffect,
+ "(*reflect.rtype).Size": ext۰NoEffect,
+ "(*reflect.rtype).String": ext۰NoEffect,
+ } {
+ intrinsicsByName[name] = fn
+ }
+}
+
+// -------------------- (reflect.Value) --------------------
+
+func ext۰reflect۰Value۰Addr(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).Bytes() Value ----------
+
+// result = v.Bytes()
+type rVBytesConstraint struct {
+ v nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rVBytesConstraint) ptr() nodeid { return c.v }
+func (c *rVBytesConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rVBytes.result")
+}
+func (c *rVBytesConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.result = mapping[c.result]
+}
+
+func (c *rVBytesConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect n%d.Bytes()", c.result, c.v)
+}
+
+func (c *rVBytesConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, slice, indirect := a.taggedValue(vObj)
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ tSlice, ok := tDyn.Underlying().(*types.Slice)
+ if ok && types.Identical(tSlice.Elem(), types.Typ[types.Uint8]) {
+ if a.onlineCopy(c.result, slice) {
+ changed = true
+ }
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰Value۰Bytes(a *analysis, cgn *cgnode) {
+ a.addConstraint(&rVBytesConstraint{
+ v: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func (Value).Call(in []Value) []Value ----------
+
+// result = v.Call(in)
+type rVCallConstraint struct {
+ cgn *cgnode
+ targets nodeid // (indirect)
+ v nodeid // (ptr)
+ arg nodeid // = in[*]
+ result nodeid // (indirect)
+ dotdotdot bool // interpret last arg as a "..." slice
+}
+
+func (c *rVCallConstraint) ptr() nodeid { return c.v }
+func (c *rVCallConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.targets), "rVCall.targets")
+ h.markIndirect(onodeid(c.result), "rVCall.result")
+}
+func (c *rVCallConstraint) renumber(mapping []nodeid) {
+ c.targets = mapping[c.targets]
+ c.v = mapping[c.v]
+ c.arg = mapping[c.arg]
+ c.result = mapping[c.result]
+}
+
+func (c *rVCallConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect n%d.Call(n%d)", c.result, c.v, c.arg)
+}
+
+func (c *rVCallConstraint) solve(a *analysis, delta *nodeset) {
+ if c.targets == 0 {
+ panic("no targets")
+ }
+
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, fn, indirect := a.taggedValue(vObj)
+ 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) // TODO(adonovan): rethink when we implement Method()
+ }
+
+ // Add dynamic call target.
+ if a.onlineCopy(c.targets, fn) {
+ a.addWork(c.targets)
+ // TODO(adonovan): is 'else continue' a sound optimisation here?
+ }
+
+ // Allocate a P/R block.
+ tParams := tSig.Params()
+ tResults := tSig.Results()
+ params := a.addNodes(tParams, "rVCall.params")
+ results := a.addNodes(tResults, "rVCall.results")
+
+ // Make a dynamic call to 'fn'.
+ a.store(fn, params, 1, a.sizeof(tParams))
+ a.load(results, fn, 1+a.sizeof(tParams), a.sizeof(tResults))
+
+ // Populate P by type-asserting each actual arg (all merged in c.arg).
+ for i, n := 0, tParams.Len(); i < n; i++ {
+ T := tParams.At(i).Type()
+ a.typeAssert(T, params, c.arg, false)
+ params += nodeid(a.sizeof(T))
+ }
+
+ // Use R by tagging and copying each actual result to c.result.
+ for i, n := 0, tResults.Len(); i < n; i++ {
+ T := tResults.At(i).Type()
+ // Convert from an arbitrary type to a reflect.Value
+ // (like MakeInterface followed by reflect.ValueOf).
+ if isInterface(T) {
+ // (don't tag)
+ if a.onlineCopy(c.result, results) {
+ changed = true
+ }
+ } else {
+ obj := a.makeTagged(T, c.cgn, nil)
+ a.onlineCopyN(obj+1, results, a.sizeof(T))
+ if a.addLabel(c.result, obj) { // (true)
+ changed = true
+ }
+ }
+ results += nodeid(a.sizeof(T))
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+// Common code for direct (inlined) and indirect calls to (reflect.Value).Call.
+func reflectCallImpl(a *analysis, cgn *cgnode, site *callsite, recv, arg nodeid, dotdotdot bool) nodeid {
+ // Allocate []reflect.Value array for the result.
+ ret := a.nextNode()
+ a.addNodes(types.NewArray(a.reflectValueObj.Type(), 1), "rVCall.ret")
+ a.endObject(ret, cgn, nil)
+
+ // pts(targets) will be the set of possible call targets.
+ site.targets = a.addOneNode(tInvalid, "rvCall.targets", nil)
+
+ // All arguments are merged since they arrive in a slice.
+ argelts := a.addOneNode(a.reflectValueObj.Type(), "rVCall.args", nil)
+ a.load(argelts, arg, 1, 1) // slice elements
+
+ a.addConstraint(&rVCallConstraint{
+ cgn: cgn,
+ targets: site.targets,
+ v: recv,
+ arg: argelts,
+ result: ret + 1, // results go into elements of ret
+ dotdotdot: dotdotdot,
+ })
+ return ret
+}
+
+func reflectCall(a *analysis, cgn *cgnode, dotdotdot bool) {
+ // This is the shared contour implementation of (reflect.Value).Call
+ // and CallSlice, as used by indirect calls (rare).
+ // Direct calls are inlined in gen.go, eliding the
+ // intermediate cgnode for Call.
+ site := new(callsite)
+ cgn.sites = append(cgn.sites, site)
+ recv := a.funcParams(cgn.obj)
+ arg := recv + 1
+ ret := reflectCallImpl(a, cgn, site, recv, arg, dotdotdot)
+ a.addressOf(cgn.fn.Signature.Results().At(0).Type(), a.funcResults(cgn.obj), ret)
+}
+
+func ext۰reflect۰Value۰Call(a *analysis, cgn *cgnode) {
+ reflectCall(a, cgn, false)
+}
+
+func ext۰reflect۰Value۰CallSlice(a *analysis, cgn *cgnode) {
+ // TODO(adonovan): implement. Also, inline direct calls in gen.go too.
+ if false {
+ reflectCall(a, cgn, true)
+ }
+}
+
+func ext۰reflect۰Value۰Convert(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).Elem() Value ----------
+
+// result = v.Elem()
+type rVElemConstraint struct {
+ cgn *cgnode
+ v nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rVElemConstraint) ptr() nodeid { return c.v }
+func (c *rVElemConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rVElem.result")
+}
+func (c *rVElemConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.result = mapping[c.result]
+}
+
+func (c *rVElemConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect n%d.Elem()", c.result, c.v)
+}
+
+func (c *rVElemConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, payload, indirect := a.taggedValue(vObj)
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ switch t := tDyn.Underlying().(type) {
+ case *types.Interface:
+ if a.onlineCopy(c.result, payload) {
+ changed = true
+ }
+
+ case *types.Pointer:
+ obj := a.makeTagged(t.Elem(), c.cgn, nil)
+ a.load(obj+1, payload, 0, a.sizeof(t.Elem()))
+ if a.addLabel(c.result, obj) {
+ changed = true
+ }
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰Value۰Elem(a *analysis, cgn *cgnode) {
+ a.addConstraint(&rVElemConstraint{
+ cgn: cgn,
+ v: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+func ext۰reflect۰Value۰Field(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+func ext۰reflect۰Value۰FieldByIndex(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+func ext۰reflect۰Value۰FieldByName(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+func ext۰reflect۰Value۰FieldByNameFunc(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).Index() Value ----------
+
+// result = v.Index()
+type rVIndexConstraint struct {
+ cgn *cgnode
+ v nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rVIndexConstraint) ptr() nodeid { return c.v }
+func (c *rVIndexConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rVIndex.result")
+}
+func (c *rVIndexConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.result = mapping[c.result]
+}
+
+func (c *rVIndexConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect n%d.Index()", c.result, c.v)
+}
+
+func (c *rVIndexConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, payload, indirect := a.taggedValue(vObj)
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ var res nodeid
+ switch t := tDyn.Underlying().(type) {
+ case *types.Array:
+ res = a.makeTagged(t.Elem(), c.cgn, nil)
+ a.onlineCopyN(res+1, payload+1, a.sizeof(t.Elem()))
+
+ case *types.Slice:
+ res = a.makeTagged(t.Elem(), c.cgn, nil)
+ a.load(res+1, payload, 1, a.sizeof(t.Elem()))
+
+ case *types.Basic:
+ if t.Kind() == types.String {
+ res = a.makeTagged(types.Typ[types.Rune], c.cgn, nil)
+ }
+ }
+ if res != 0 && a.addLabel(c.result, res) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰Value۰Index(a *analysis, cgn *cgnode) {
+ a.addConstraint(&rVIndexConstraint{
+ cgn: cgn,
+ v: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func (Value).Interface() Value ----------
+
+// result = v.Interface()
+type rVInterfaceConstraint struct {
+ v nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rVInterfaceConstraint) ptr() nodeid { return c.v }
+func (c *rVInterfaceConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rVInterface.result")
+}
+func (c *rVInterfaceConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.result = mapping[c.result]
+}
+
+func (c *rVInterfaceConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect n%d.Interface()", c.result, c.v)
+}
+
+func (c *rVInterfaceConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, payload, indirect := a.taggedValue(vObj)
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ if isInterface(tDyn) {
+ if a.onlineCopy(c.result, payload) {
+ a.addWork(c.result)
+ }
+ } else {
+ if a.addLabel(c.result, vObj) {
+ changed = true
+ }
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰Value۰Interface(a *analysis, cgn *cgnode) {
+ a.addConstraint(&rVInterfaceConstraint{
+ v: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func (Value).MapIndex(Value) Value ----------
+
+// result = v.MapIndex(_)
+type rVMapIndexConstraint struct {
+ cgn *cgnode
+ v nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rVMapIndexConstraint) ptr() nodeid { return c.v }
+func (c *rVMapIndexConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rVMapIndex.result")
+}
+func (c *rVMapIndexConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.result = mapping[c.result]
+}
+
+func (c *rVMapIndexConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect n%d.MapIndex(_)", c.result, c.v)
+}
+
+func (c *rVMapIndexConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, m, indirect := a.taggedValue(vObj)
+ tMap, _ := tDyn.Underlying().(*types.Map)
+ if tMap == nil {
+ continue // not a map
+ }
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ obj := a.makeTagged(tMap.Elem(), c.cgn, nil)
+ a.load(obj+1, m, a.sizeof(tMap.Key()), a.sizeof(tMap.Elem()))
+ if a.addLabel(c.result, obj) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰Value۰MapIndex(a *analysis, cgn *cgnode) {
+ a.addConstraint(&rVMapIndexConstraint{
+ cgn: cgn,
+ v: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func (Value).MapKeys() []Value ----------
+
+// result = v.MapKeys()
+type rVMapKeysConstraint struct {
+ cgn *cgnode
+ v nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rVMapKeysConstraint) ptr() nodeid { return c.v }
+func (c *rVMapKeysConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rVMapKeys.result")
+}
+func (c *rVMapKeysConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.result = mapping[c.result]
+}
+
+func (c *rVMapKeysConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect n%d.MapKeys()", c.result, c.v)
+}
+
+func (c *rVMapKeysConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, m, indirect := a.taggedValue(vObj)
+ tMap, _ := tDyn.Underlying().(*types.Map)
+ if tMap == nil {
+ continue // not a map
+ }
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ kObj := a.makeTagged(tMap.Key(), c.cgn, nil)
+ a.load(kObj+1, m, 0, a.sizeof(tMap.Key()))
+ if a.addLabel(c.result, kObj) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰Value۰MapKeys(a *analysis, cgn *cgnode) {
+ // Allocate an array for the result.
+ obj := a.nextNode()
+ T := types.NewSlice(a.reflectValueObj.Type())
+ a.addNodes(sliceToArray(T), "reflect.MapKeys result")
+ a.endObject(obj, cgn, nil)
+ a.addressOf(T, a.funcResults(cgn.obj), obj)
+
+ a.addConstraint(&rVMapKeysConstraint{
+ cgn: cgn,
+ v: a.funcParams(cgn.obj),
+ result: obj + 1, // result is stored in array elems
+ })
+}
+
+func ext۰reflect۰Value۰Method(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+func ext۰reflect۰Value۰MethodByName(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).Recv(Value) Value ----------
+
+// result, _ = v.Recv()
+type rVRecvConstraint struct {
+ cgn *cgnode
+ v nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rVRecvConstraint) ptr() nodeid { return c.v }
+func (c *rVRecvConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rVRecv.result")
+}
+func (c *rVRecvConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.result = mapping[c.result]
+}
+
+func (c *rVRecvConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect n%d.Recv()", c.result, c.v)
+}
+
+func (c *rVRecvConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, ch, indirect := a.taggedValue(vObj)
+ tChan, _ := tDyn.Underlying().(*types.Chan)
+ if tChan == nil {
+ continue // not a channel
+ }
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ tElem := tChan.Elem()
+ elemObj := a.makeTagged(tElem, c.cgn, nil)
+ a.load(elemObj+1, ch, 0, a.sizeof(tElem))
+ if a.addLabel(c.result, elemObj) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰Value۰Recv(a *analysis, cgn *cgnode) {
+ a.addConstraint(&rVRecvConstraint{
+ cgn: cgn,
+ v: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func (Value).Send(Value) ----------
+
+// v.Send(x)
+type rVSendConstraint struct {
+ cgn *cgnode
+ v nodeid // (ptr)
+ x nodeid
+}
+
+func (c *rVSendConstraint) ptr() nodeid { return c.v }
+func (c *rVSendConstraint) presolve(*hvn) {}
+func (c *rVSendConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.x = mapping[c.x]
+}
+
+func (c *rVSendConstraint) String() string {
+ return fmt.Sprintf("reflect n%d.Send(n%d)", c.v, c.x)
+}
+
+func (c *rVSendConstraint) solve(a *analysis, delta *nodeset) {
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, ch, indirect := a.taggedValue(vObj)
+ tChan, _ := tDyn.Underlying().(*types.Chan)
+ if tChan == nil {
+ continue // not a channel
+ }
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ // Extract x's payload to xtmp, then store to channel.
+ tElem := tChan.Elem()
+ xtmp := a.addNodes(tElem, "Send.xtmp")
+ a.typeAssert(tElem, xtmp, c.x, false)
+ a.store(ch, xtmp, 0, a.sizeof(tElem))
+ }
+}
+
+func ext۰reflect۰Value۰Send(a *analysis, cgn *cgnode) {
+ params := a.funcParams(cgn.obj)
+ a.addConstraint(&rVSendConstraint{
+ cgn: cgn,
+ v: params,
+ x: params + 1,
+ })
+}
+
+func ext۰reflect۰Value۰Set(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).SetBytes(x []byte) ----------
+
+// v.SetBytes(x)
+type rVSetBytesConstraint struct {
+ cgn *cgnode
+ v nodeid // (ptr)
+ x nodeid
+}
+
+func (c *rVSetBytesConstraint) ptr() nodeid { return c.v }
+func (c *rVSetBytesConstraint) presolve(*hvn) {}
+func (c *rVSetBytesConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.x = mapping[c.x]
+}
+
+func (c *rVSetBytesConstraint) String() string {
+ return fmt.Sprintf("reflect n%d.SetBytes(n%d)", c.v, c.x)
+}
+
+func (c *rVSetBytesConstraint) solve(a *analysis, delta *nodeset) {
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, slice, indirect := a.taggedValue(vObj)
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ tSlice, ok := tDyn.Underlying().(*types.Slice)
+ if ok && types.Identical(tSlice.Elem(), types.Typ[types.Uint8]) {
+ if a.onlineCopy(slice, c.x) {
+ a.addWork(slice)
+ }
+ }
+ }
+}
+
+func ext۰reflect۰Value۰SetBytes(a *analysis, cgn *cgnode) {
+ params := a.funcParams(cgn.obj)
+ a.addConstraint(&rVSetBytesConstraint{
+ cgn: cgn,
+ v: params,
+ x: params + 1,
+ })
+}
+
+// ---------- func (Value).SetMapIndex(k Value, v Value) ----------
+
+// v.SetMapIndex(key, val)
+type rVSetMapIndexConstraint struct {
+ cgn *cgnode
+ v nodeid // (ptr)
+ key nodeid
+ val nodeid
+}
+
+func (c *rVSetMapIndexConstraint) ptr() nodeid { return c.v }
+func (c *rVSetMapIndexConstraint) presolve(*hvn) {}
+func (c *rVSetMapIndexConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.key = mapping[c.key]
+ c.val = mapping[c.val]
+}
+
+func (c *rVSetMapIndexConstraint) String() string {
+ return fmt.Sprintf("reflect n%d.SetMapIndex(n%d, n%d)", c.v, c.key, c.val)
+}
+
+func (c *rVSetMapIndexConstraint) solve(a *analysis, delta *nodeset) {
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, m, indirect := a.taggedValue(vObj)
+ tMap, _ := tDyn.Underlying().(*types.Map)
+ if tMap == nil {
+ continue // not a map
+ }
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ keysize := a.sizeof(tMap.Key())
+
+ // Extract key's payload to keytmp, then store to map key.
+ keytmp := a.addNodes(tMap.Key(), "SetMapIndex.keytmp")
+ a.typeAssert(tMap.Key(), keytmp, c.key, false)
+ a.store(m, keytmp, 0, keysize)
+
+ // Extract val's payload to vtmp, then store to map value.
+ valtmp := a.addNodes(tMap.Elem(), "SetMapIndex.valtmp")
+ a.typeAssert(tMap.Elem(), valtmp, c.val, false)
+ a.store(m, valtmp, keysize, a.sizeof(tMap.Elem()))
+ }
+}
+
+func ext۰reflect۰Value۰SetMapIndex(a *analysis, cgn *cgnode) {
+ params := a.funcParams(cgn.obj)
+ a.addConstraint(&rVSetMapIndexConstraint{
+ cgn: cgn,
+ v: params,
+ key: params + 1,
+ val: params + 2,
+ })
+}
+
+func ext۰reflect۰Value۰SetPointer(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (Value).Slice(v Value, i, j int) Value ----------
+
+// result = v.Slice(_, _)
+type rVSliceConstraint struct {
+ cgn *cgnode
+ v nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rVSliceConstraint) ptr() nodeid { return c.v }
+func (c *rVSliceConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rVSlice.result")
+}
+func (c *rVSliceConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.result = mapping[c.result]
+}
+
+func (c *rVSliceConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect n%d.Slice(_, _)", c.result, c.v)
+}
+
+func (c *rVSliceConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, payload, indirect := a.taggedValue(vObj)
+ if indirect {
+ // TODO(adonovan): we'll need to implement this
+ // when we start creating indirect tagged objects.
+ panic("indirect tagged object")
+ }
+
+ var res nodeid
+ switch t := tDyn.Underlying().(type) {
+ case *types.Pointer:
+ if tArr, ok := t.Elem().Underlying().(*types.Array); ok {
+ // pointer to array
+ res = a.makeTagged(types.NewSlice(tArr.Elem()), c.cgn, nil)
+ if a.onlineCopy(res+1, payload) {
+ a.addWork(res + 1)
+ }
+ }
+
+ case *types.Array:
+ // TODO(adonovan): implement addressable
+ // arrays when we do indirect tagged objects.
+
+ case *types.Slice:
+ res = vObj
+
+ case *types.Basic:
+ if t == types.Typ[types.String] {
+ res = vObj
+ }
+ }
+
+ if res != 0 && a.addLabel(c.result, res) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰Value۰Slice(a *analysis, cgn *cgnode) {
+ a.addConstraint(&rVSliceConstraint{
+ cgn: cgn,
+ v: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// -------------------- Standalone reflect functions --------------------
+
+func ext۰reflect۰Append(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+func ext۰reflect۰AppendSlice(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+func ext۰reflect۰Copy(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func ChanOf(ChanDir, Type) Type ----------
+
+// result = ChanOf(dir, t)
+type reflectChanOfConstraint struct {
+ cgn *cgnode
+ t nodeid // (ptr)
+ result nodeid // (indirect)
+ dirs []types.ChanDir
+}
+
+func (c *reflectChanOfConstraint) ptr() nodeid { return c.t }
+func (c *reflectChanOfConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "reflectChanOf.result")
+}
+func (c *reflectChanOfConstraint) renumber(mapping []nodeid) {
+ c.t = mapping[c.t]
+ c.result = mapping[c.result]
+}
+
+func (c *reflectChanOfConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect.ChanOf(n%d)", c.result, c.t)
+}
+
+func (c *reflectChanOfConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ tObj := nodeid(x)
+ T := a.rtypeTaggedValue(tObj)
+
+ if typeTooHigh(T) {
+ continue
+ }
+
+ for _, dir := range c.dirs {
+ if a.addLabel(c.result, a.makeRtype(types.NewChan(dir, T))) {
+ changed = true
+ }
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+// dirMap maps reflect.ChanDir to the set of channel types generated by ChanOf.
+var dirMap = [...][]types.ChanDir{
+ 0: {types.SendOnly, types.RecvOnly, types.SendRecv}, // unknown
+ reflect.RecvDir: {types.RecvOnly},
+ reflect.SendDir: {types.SendOnly},
+ reflect.BothDir: {types.SendRecv},
+}
+
+func ext۰reflect۰ChanOf(a *analysis, cgn *cgnode) {
+ // If we have access to the callsite,
+ // and the channel argument is a constant (as is usual),
+ // only generate the requested direction.
+ var dir reflect.ChanDir // unknown
+ if site := cgn.callersite; site != nil {
+ if c, ok := site.instr.Common().Args[0].(*ssa.Const); ok {
+ v, _ := constant.Int64Val(c.Value)
+ if 0 <= v && v <= int64(reflect.BothDir) {
+ dir = reflect.ChanDir(v)
+ }
+ }
+ }
+
+ params := a.funcParams(cgn.obj)
+ a.addConstraint(&reflectChanOfConstraint{
+ cgn: cgn,
+ t: params + 1,
+ result: a.funcResults(cgn.obj),
+ dirs: dirMap[dir],
+ })
+}
+
+// ---------- func Indirect(v Value) Value ----------
+
+// result = Indirect(v)
+type reflectIndirectConstraint struct {
+ cgn *cgnode
+ v nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *reflectIndirectConstraint) ptr() nodeid { return c.v }
+func (c *reflectIndirectConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "reflectIndirect.result")
+}
+func (c *reflectIndirectConstraint) renumber(mapping []nodeid) {
+ c.v = mapping[c.v]
+ c.result = mapping[c.result]
+}
+
+func (c *reflectIndirectConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect.Indirect(n%d)", c.result, c.v)
+}
+
+func (c *reflectIndirectConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ vObj := nodeid(x)
+ tDyn, _, _ := a.taggedValue(vObj)
+ var res nodeid
+ if tPtr, ok := tDyn.Underlying().(*types.Pointer); ok {
+ // load the payload of the pointer's tagged object
+ // into a new tagged object
+ res = a.makeTagged(tPtr.Elem(), c.cgn, nil)
+ a.load(res+1, vObj+1, 0, a.sizeof(tPtr.Elem()))
+ } else {
+ res = vObj
+ }
+
+ if a.addLabel(c.result, res) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰Indirect(a *analysis, cgn *cgnode) {
+ a.addConstraint(&reflectIndirectConstraint{
+ cgn: cgn,
+ v: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func MakeChan(Type) Value ----------
+
+// result = MakeChan(typ)
+type reflectMakeChanConstraint struct {
+ cgn *cgnode
+ typ nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *reflectMakeChanConstraint) ptr() nodeid { return c.typ }
+func (c *reflectMakeChanConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "reflectMakeChan.result")
+}
+func (c *reflectMakeChanConstraint) renumber(mapping []nodeid) {
+ c.typ = mapping[c.typ]
+ c.result = mapping[c.result]
+}
+
+func (c *reflectMakeChanConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect.MakeChan(n%d)", c.result, c.typ)
+}
+
+func (c *reflectMakeChanConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ typObj := nodeid(x)
+ T := a.rtypeTaggedValue(typObj)
+ tChan, ok := T.Underlying().(*types.Chan)
+ if !ok || tChan.Dir() != types.SendRecv {
+ continue // not a bidirectional channel type
+ }
+
+ obj := a.nextNode()
+ a.addNodes(tChan.Elem(), "reflect.MakeChan.value")
+ a.endObject(obj, c.cgn, nil)
+
+ // put its address in a new T-tagged object
+ id := a.makeTagged(T, c.cgn, nil)
+ a.addLabel(id+1, obj)
+
+ // flow the T-tagged object to the result
+ if a.addLabel(c.result, id) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰MakeChan(a *analysis, cgn *cgnode) {
+ a.addConstraint(&reflectMakeChanConstraint{
+ cgn: cgn,
+ typ: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+func ext۰reflect۰MakeFunc(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func MakeMap(Type) Value ----------
+
+// result = MakeMap(typ)
+type reflectMakeMapConstraint struct {
+ cgn *cgnode
+ typ nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *reflectMakeMapConstraint) ptr() nodeid { return c.typ }
+func (c *reflectMakeMapConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "reflectMakeMap.result")
+}
+func (c *reflectMakeMapConstraint) renumber(mapping []nodeid) {
+ c.typ = mapping[c.typ]
+ c.result = mapping[c.result]
+}
+
+func (c *reflectMakeMapConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect.MakeMap(n%d)", c.result, c.typ)
+}
+
+func (c *reflectMakeMapConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ typObj := nodeid(x)
+ T := a.rtypeTaggedValue(typObj)
+ tMap, ok := T.Underlying().(*types.Map)
+ if !ok {
+ continue // not a map type
+ }
+
+ mapObj := a.nextNode()
+ a.addNodes(tMap.Key(), "reflect.MakeMap.key")
+ a.addNodes(tMap.Elem(), "reflect.MakeMap.value")
+ a.endObject(mapObj, c.cgn, nil)
+
+ // put its address in a new T-tagged object
+ id := a.makeTagged(T, c.cgn, nil)
+ a.addLabel(id+1, mapObj)
+
+ // flow the T-tagged object to the result
+ if a.addLabel(c.result, id) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰MakeMap(a *analysis, cgn *cgnode) {
+ a.addConstraint(&reflectMakeMapConstraint{
+ cgn: cgn,
+ typ: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func MakeSlice(Type) Value ----------
+
+// result = MakeSlice(typ)
+type reflectMakeSliceConstraint struct {
+ cgn *cgnode
+ typ nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *reflectMakeSliceConstraint) ptr() nodeid { return c.typ }
+func (c *reflectMakeSliceConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "reflectMakeSlice.result")
+}
+func (c *reflectMakeSliceConstraint) renumber(mapping []nodeid) {
+ c.typ = mapping[c.typ]
+ c.result = mapping[c.result]
+}
+
+func (c *reflectMakeSliceConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect.MakeSlice(n%d)", c.result, c.typ)
+}
+
+func (c *reflectMakeSliceConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ typObj := nodeid(x)
+ T := a.rtypeTaggedValue(typObj)
+ if _, ok := T.Underlying().(*types.Slice); !ok {
+ continue // not a slice type
+ }
+
+ obj := a.nextNode()
+ a.addNodes(sliceToArray(T), "reflect.MakeSlice")
+ a.endObject(obj, c.cgn, nil)
+
+ // put its address in a new T-tagged object
+ id := a.makeTagged(T, c.cgn, nil)
+ a.addLabel(id+1, obj)
+
+ // flow the T-tagged object to the result
+ if a.addLabel(c.result, id) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰MakeSlice(a *analysis, cgn *cgnode) {
+ a.addConstraint(&reflectMakeSliceConstraint{
+ cgn: cgn,
+ typ: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+func ext۰reflect۰MapOf(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func New(Type) Value ----------
+
+// result = New(typ)
+type reflectNewConstraint struct {
+ cgn *cgnode
+ typ nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *reflectNewConstraint) ptr() nodeid { return c.typ }
+func (c *reflectNewConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "reflectNew.result")
+}
+func (c *reflectNewConstraint) renumber(mapping []nodeid) {
+ c.typ = mapping[c.typ]
+ c.result = mapping[c.result]
+}
+
+func (c *reflectNewConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect.New(n%d)", c.result, c.typ)
+}
+
+func (c *reflectNewConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ typObj := nodeid(x)
+ T := a.rtypeTaggedValue(typObj)
+
+ // allocate new T object
+ newObj := a.nextNode()
+ a.addNodes(T, "reflect.New")
+ a.endObject(newObj, c.cgn, nil)
+
+ // put its address in a new *T-tagged object
+ id := a.makeTagged(types.NewPointer(T), c.cgn, nil)
+ a.addLabel(id+1, newObj)
+
+ // flow the pointer to the result
+ if a.addLabel(c.result, id) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰New(a *analysis, cgn *cgnode) {
+ a.addConstraint(&reflectNewConstraint{
+ cgn: cgn,
+ typ: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+func ext۰reflect۰NewAt(a *analysis, cgn *cgnode) {
+ ext۰reflect۰New(a, cgn)
+
+ // TODO(adonovan): also report dynamic calls to unsound intrinsics.
+ if site := cgn.callersite; site != nil {
+ a.warnf(site.pos(), "unsound: %s contains a reflect.NewAt() call", site.instr.Parent())
+ }
+}
+
+// ---------- func PtrTo(Type) Type ----------
+
+// result = PtrTo(t)
+type reflectPtrToConstraint struct {
+ cgn *cgnode
+ t nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *reflectPtrToConstraint) ptr() nodeid { return c.t }
+func (c *reflectPtrToConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "reflectPtrTo.result")
+}
+func (c *reflectPtrToConstraint) renumber(mapping []nodeid) {
+ c.t = mapping[c.t]
+ c.result = mapping[c.result]
+}
+
+func (c *reflectPtrToConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect.PtrTo(n%d)", c.result, c.t)
+}
+
+func (c *reflectPtrToConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ tObj := nodeid(x)
+ T := a.rtypeTaggedValue(tObj)
+
+ if typeTooHigh(T) {
+ continue
+ }
+
+ if a.addLabel(c.result, a.makeRtype(types.NewPointer(T))) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰PtrTo(a *analysis, cgn *cgnode) {
+ a.addConstraint(&reflectPtrToConstraint{
+ cgn: cgn,
+ t: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+func ext۰reflect۰Select(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func SliceOf(Type) Type ----------
+
+// result = SliceOf(t)
+type reflectSliceOfConstraint struct {
+ cgn *cgnode
+ t nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *reflectSliceOfConstraint) ptr() nodeid { return c.t }
+func (c *reflectSliceOfConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "reflectSliceOf.result")
+}
+func (c *reflectSliceOfConstraint) renumber(mapping []nodeid) {
+ c.t = mapping[c.t]
+ c.result = mapping[c.result]
+}
+
+func (c *reflectSliceOfConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect.SliceOf(n%d)", c.result, c.t)
+}
+
+func (c *reflectSliceOfConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ tObj := nodeid(x)
+ T := a.rtypeTaggedValue(tObj)
+
+ if typeTooHigh(T) {
+ continue
+ }
+
+ if a.addLabel(c.result, a.makeRtype(types.NewSlice(T))) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰SliceOf(a *analysis, cgn *cgnode) {
+ a.addConstraint(&reflectSliceOfConstraint{
+ cgn: cgn,
+ t: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func TypeOf(v Value) Type ----------
+
+// result = TypeOf(i)
+type reflectTypeOfConstraint struct {
+ cgn *cgnode
+ i nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *reflectTypeOfConstraint) ptr() nodeid { return c.i }
+func (c *reflectTypeOfConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "reflectTypeOf.result")
+}
+func (c *reflectTypeOfConstraint) renumber(mapping []nodeid) {
+ c.i = mapping[c.i]
+ c.result = mapping[c.result]
+}
+
+func (c *reflectTypeOfConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect.TypeOf(n%d)", c.result, c.i)
+}
+
+func (c *reflectTypeOfConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ iObj := nodeid(x)
+ tDyn, _, _ := a.taggedValue(iObj)
+ if a.addLabel(c.result, a.makeRtype(tDyn)) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰TypeOf(a *analysis, cgn *cgnode) {
+ a.addConstraint(&reflectTypeOfConstraint{
+ cgn: cgn,
+ i: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func ValueOf(interface{}) Value ----------
+
+func ext۰reflect۰ValueOf(a *analysis, cgn *cgnode) {
+ // TODO(adonovan): when we start creating indirect tagged
+ // objects, we'll need to handle them specially here since
+ // they must never appear in the PTS of an interface{}.
+ a.copy(a.funcResults(cgn.obj), a.funcParams(cgn.obj), 1)
+}
+
+// ---------- func Zero(Type) Value ----------
+
+// result = Zero(typ)
+type reflectZeroConstraint struct {
+ cgn *cgnode
+ typ nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *reflectZeroConstraint) ptr() nodeid { return c.typ }
+func (c *reflectZeroConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "reflectZero.result")
+}
+func (c *reflectZeroConstraint) renumber(mapping []nodeid) {
+ c.typ = mapping[c.typ]
+ c.result = mapping[c.result]
+}
+
+func (c *reflectZeroConstraint) String() string {
+ return fmt.Sprintf("n%d = reflect.Zero(n%d)", c.result, c.typ)
+}
+
+func (c *reflectZeroConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ typObj := nodeid(x)
+ T := a.rtypeTaggedValue(typObj)
+
+ // TODO(adonovan): if T is an interface type, we need
+ // to create an indirect tagged object containing
+ // new(T). To avoid updates of such shared values,
+ // we'll need another flag on indirect tagged objects
+ // that marks whether they are addressable or
+ // readonly, just like the reflect package does.
+
+ // memoize using a.reflectZeros[T]
+ var id nodeid
+ if z := a.reflectZeros.At(T); false && z != nil {
+ id = z.(nodeid)
+ } else {
+ id = a.makeTagged(T, c.cgn, nil)
+ a.reflectZeros.Set(T, id)
+ }
+ if a.addLabel(c.result, id) {
+ changed = true
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰Zero(a *analysis, cgn *cgnode) {
+ a.addConstraint(&reflectZeroConstraint{
+ cgn: cgn,
+ typ: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// -------------------- (*reflect.rtype) methods --------------------
+
+// ---------- func (*rtype) Elem() Type ----------
+
+// result = Elem(t)
+type rtypeElemConstraint struct {
+ cgn *cgnode
+ t nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rtypeElemConstraint) ptr() nodeid { return c.t }
+func (c *rtypeElemConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rtypeElem.result")
+}
+func (c *rtypeElemConstraint) renumber(mapping []nodeid) {
+ c.t = mapping[c.t]
+ c.result = mapping[c.result]
+}
+
+func (c *rtypeElemConstraint) String() string {
+ return fmt.Sprintf("n%d = (*reflect.rtype).Elem(n%d)", c.result, c.t)
+}
+
+func (c *rtypeElemConstraint) solve(a *analysis, delta *nodeset) {
+ // Implemented by *types.{Map,Chan,Array,Slice,Pointer}.
+ type hasElem interface {
+ Elem() types.Type
+ }
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ tObj := nodeid(x)
+ T := a.nodes[tObj].obj.data.(types.Type)
+ if tHasElem, ok := T.Underlying().(hasElem); ok {
+ if a.addLabel(c.result, a.makeRtype(tHasElem.Elem())) {
+ changed = true
+ }
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰rtype۰Elem(a *analysis, cgn *cgnode) {
+ a.addConstraint(&rtypeElemConstraint{
+ cgn: cgn,
+ t: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func (*rtype) Field(int) StructField ----------
+// ---------- func (*rtype) FieldByName(string) (StructField, bool) ----------
+
+// result = FieldByName(t, name)
+// result = Field(t, _)
+type rtypeFieldByNameConstraint struct {
+ cgn *cgnode
+ name string // name of field; "" for unknown
+ t nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rtypeFieldByNameConstraint) ptr() nodeid { return c.t }
+func (c *rtypeFieldByNameConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result+3), "rtypeFieldByName.result.Type")
+}
+func (c *rtypeFieldByNameConstraint) renumber(mapping []nodeid) {
+ c.t = mapping[c.t]
+ c.result = mapping[c.result]
+}
+
+func (c *rtypeFieldByNameConstraint) String() string {
+ return fmt.Sprintf("n%d = (*reflect.rtype).FieldByName(n%d, %q)", c.result, c.t, c.name)
+}
+
+func (c *rtypeFieldByNameConstraint) solve(a *analysis, delta *nodeset) {
+ // type StructField struct {
+ // 0 __identity__
+ // 1 Name string
+ // 2 PkgPath string
+ // 3 Type Type
+ // 4 Tag StructTag
+ // 5 Offset uintptr
+ // 6 Index []int
+ // 7 Anonymous bool
+ // }
+
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ tObj := nodeid(x)
+ T := a.nodes[tObj].obj.data.(types.Type)
+ tStruct, ok := T.Underlying().(*types.Struct)
+ if !ok {
+ continue // not a struct type
+ }
+
+ n := tStruct.NumFields()
+ for i := 0; i < n; i++ {
+ f := tStruct.Field(i)
+ if c.name == "" || c.name == f.Name() {
+
+ // a.offsetOf(Type) is 3.
+ if id := c.result + 3; a.addLabel(id, a.makeRtype(f.Type())) {
+ a.addWork(id)
+ }
+ // TODO(adonovan): StructField.Index should be non-nil.
+ }
+ }
+ }
+}
+
+func ext۰reflect۰rtype۰FieldByName(a *analysis, cgn *cgnode) {
+ // If we have access to the callsite,
+ // and the argument is a string constant,
+ // return only that field.
+ var name string
+ if site := cgn.callersite; site != nil {
+ if c, ok := site.instr.Common().Args[0].(*ssa.Const); ok {
+ name = constant.StringVal(c.Value)
+ }
+ }
+
+ a.addConstraint(&rtypeFieldByNameConstraint{
+ cgn: cgn,
+ name: name,
+ t: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+func ext۰reflect۰rtype۰Field(a *analysis, cgn *cgnode) {
+ // No-one ever calls Field with a constant argument,
+ // so we don't specialize that case.
+ a.addConstraint(&rtypeFieldByNameConstraint{
+ cgn: cgn,
+ t: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+func ext۰reflect۰rtype۰FieldByIndex(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+func ext۰reflect۰rtype۰FieldByNameFunc(a *analysis, cgn *cgnode) {} // TODO(adonovan)
+
+// ---------- func (*rtype) In/Out(i int) Type ----------
+
+// result = In/Out(t, i)
+type rtypeInOutConstraint struct {
+ cgn *cgnode
+ t nodeid // (ptr)
+ result nodeid // (indirect)
+ out bool
+ i int // -ve if not a constant
+}
+
+func (c *rtypeInOutConstraint) ptr() nodeid { return c.t }
+func (c *rtypeInOutConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rtypeInOut.result")
+}
+func (c *rtypeInOutConstraint) renumber(mapping []nodeid) {
+ c.t = mapping[c.t]
+ c.result = mapping[c.result]
+}
+
+func (c *rtypeInOutConstraint) String() string {
+ return fmt.Sprintf("n%d = (*reflect.rtype).InOut(n%d, %d)", c.result, c.t, c.i)
+}
+
+func (c *rtypeInOutConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ tObj := nodeid(x)
+ T := a.nodes[tObj].obj.data.(types.Type)
+ sig, ok := T.Underlying().(*types.Signature)
+ if !ok {
+ continue // not a func type
+ }
+
+ tuple := sig.Params()
+ if c.out {
+ tuple = sig.Results()
+ }
+ for i, n := 0, tuple.Len(); i < n; i++ {
+ if c.i < 0 || c.i == i {
+ if a.addLabel(c.result, a.makeRtype(tuple.At(i).Type())) {
+ changed = true
+ }
+ }
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰rtype۰InOut(a *analysis, cgn *cgnode, out bool) {
+ // If we have access to the callsite,
+ // and the argument is an int constant,
+ // return only that parameter.
+ index := -1
+ if site := cgn.callersite; site != nil {
+ if c, ok := site.instr.Common().Args[0].(*ssa.Const); ok {
+ v, _ := constant.Int64Val(c.Value)
+ index = int(v)
+ }
+ }
+ a.addConstraint(&rtypeInOutConstraint{
+ cgn: cgn,
+ t: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ out: out,
+ i: index,
+ })
+}
+
+func ext۰reflect۰rtype۰In(a *analysis, cgn *cgnode) {
+ ext۰reflect۰rtype۰InOut(a, cgn, false)
+}
+
+func ext۰reflect۰rtype۰Out(a *analysis, cgn *cgnode) {
+ ext۰reflect۰rtype۰InOut(a, cgn, true)
+}
+
+// ---------- func (*rtype) Key() Type ----------
+
+// result = Key(t)
+type rtypeKeyConstraint struct {
+ cgn *cgnode
+ t nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rtypeKeyConstraint) ptr() nodeid { return c.t }
+func (c *rtypeKeyConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result), "rtypeKey.result")
+}
+func (c *rtypeKeyConstraint) renumber(mapping []nodeid) {
+ c.t = mapping[c.t]
+ c.result = mapping[c.result]
+}
+
+func (c *rtypeKeyConstraint) String() string {
+ return fmt.Sprintf("n%d = (*reflect.rtype).Key(n%d)", c.result, c.t)
+}
+
+func (c *rtypeKeyConstraint) solve(a *analysis, delta *nodeset) {
+ changed := false
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ tObj := nodeid(x)
+ T := a.nodes[tObj].obj.data.(types.Type)
+ if tMap, ok := T.Underlying().(*types.Map); ok {
+ if a.addLabel(c.result, a.makeRtype(tMap.Key())) {
+ changed = true
+ }
+ }
+ }
+ if changed {
+ a.addWork(c.result)
+ }
+}
+
+func ext۰reflect۰rtype۰Key(a *analysis, cgn *cgnode) {
+ a.addConstraint(&rtypeKeyConstraint{
+ cgn: cgn,
+ t: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// ---------- func (*rtype) Method(int) (Method, bool) ----------
+// ---------- func (*rtype) MethodByName(string) (Method, bool) ----------
+
+// result = MethodByName(t, name)
+// result = Method(t, _)
+type rtypeMethodByNameConstraint struct {
+ cgn *cgnode
+ name string // name of method; "" for unknown
+ t nodeid // (ptr)
+ result nodeid // (indirect)
+}
+
+func (c *rtypeMethodByNameConstraint) ptr() nodeid { return c.t }
+func (c *rtypeMethodByNameConstraint) presolve(h *hvn) {
+ h.markIndirect(onodeid(c.result+3), "rtypeMethodByName.result.Type")
+ h.markIndirect(onodeid(c.result+4), "rtypeMethodByName.result.Func")
+}
+func (c *rtypeMethodByNameConstraint) renumber(mapping []nodeid) {
+ c.t = mapping[c.t]
+ c.result = mapping[c.result]
+}
+
+func (c *rtypeMethodByNameConstraint) String() string {
+ return fmt.Sprintf("n%d = (*reflect.rtype).MethodByName(n%d, %q)", c.result, c.t, c.name)
+}
+
+// changeRecv returns sig with Recv prepended to Params().
+func changeRecv(sig *types.Signature) *types.Signature {
+ params := sig.Params()
+ n := params.Len()
+ p2 := make([]*types.Var, n+1)
+ p2[0] = sig.Recv()
+ for i := 0; i < n; i++ {
+ p2[i+1] = params.At(i)
+ }
+ return types.NewSignature(nil, types.NewTuple(p2...), sig.Results(), sig.Variadic())
+}
+
+func (c *rtypeMethodByNameConstraint) solve(a *analysis, delta *nodeset) {
+ for _, x := range delta.AppendTo(a.deltaSpace) {
+ tObj := nodeid(x)
+ T := a.nodes[tObj].obj.data.(types.Type)
+
+ isIface := isInterface(T)
+
+ // We don't use Lookup(c.name) when c.name != "" to avoid
+ // ambiguity: >1 unexported methods could match.
+ mset := a.prog.MethodSets.MethodSet(T)
+ for i, n := 0, mset.Len(); i < n; i++ {
+ sel := mset.At(i)
+ if c.name == "" || c.name == sel.Obj().Name() {
+ // type Method struct {
+ // 0 __identity__
+ // 1 Name string
+ // 2 PkgPath string
+ // 3 Type Type
+ // 4 Func Value
+ // 5 Index int
+ // }
+
+ var sig *types.Signature
+ var fn *ssa.Function
+ if isIface {
+ sig = sel.Type().(*types.Signature)
+ } else {
+ fn = a.prog.MethodValue(sel)
+ // move receiver to params[0]
+ sig = changeRecv(fn.Signature)
+ }
+
+ // a.offsetOf(Type) is 3.
+ if id := c.result + 3; a.addLabel(id, a.makeRtype(sig)) {
+ a.addWork(id)
+ }
+ if fn != nil {
+ // a.offsetOf(Func) is 4.
+ if id := c.result + 4; a.addLabel(id, a.objectNode(nil, fn)) {
+ a.addWork(id)
+ }
+ }
+ }
+ }
+ }
+}
+
+func ext۰reflect۰rtype۰MethodByName(a *analysis, cgn *cgnode) {
+ // If we have access to the callsite,
+ // and the argument is a string constant,
+ // return only that method.
+ var name string
+ if site := cgn.callersite; site != nil {
+ if c, ok := site.instr.Common().Args[0].(*ssa.Const); ok {
+ name = constant.StringVal(c.Value)
+ }
+ }
+
+ a.addConstraint(&rtypeMethodByNameConstraint{
+ cgn: cgn,
+ name: name,
+ t: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+func ext۰reflect۰rtype۰Method(a *analysis, cgn *cgnode) {
+ // No-one ever calls Method with a constant argument,
+ // so we don't specialize that case.
+ a.addConstraint(&rtypeMethodByNameConstraint{
+ cgn: cgn,
+ t: a.funcParams(cgn.obj),
+ result: a.funcResults(cgn.obj),
+ })
+}
+
+// typeHeight returns the "height" of the type, which is roughly
+// speaking the number of chan, map, pointer and slice type constructors
+// at the root of T; these are the four type kinds that can be created
+// via reflection. Chan and map constructors are counted as double the
+// height of slice and pointer constructors since they are less often
+// deeply nested.
+//
+// The solver rules for type constructors must somehow bound the set of
+// types they create to ensure termination of the algorithm in cases
+// where the output of a type constructor flows to its input, e.g.
+//
+// func f(t reflect.Type) {
+// f(reflect.PtrTo(t))
+// }
+//
+// It does this by limiting the type height to k, but this still leaves
+// a potentially exponential (4^k) number of of types that may be
+// enumerated in pathological cases.
+//
+func typeHeight(T types.Type) int {
+ switch T := T.(type) {
+ case *types.Chan:
+ return 2 + typeHeight(T.Elem())
+ case *types.Map:
+ k := typeHeight(T.Key())
+ v := typeHeight(T.Elem())
+ if v > k {
+ k = v // max(k, v)
+ }
+ return 2 + k
+ case *types.Slice:
+ return 1 + typeHeight(T.Elem())
+ case *types.Pointer:
+ return 1 + typeHeight(T.Elem())
+ }
+ return 0
+}
+
+func typeTooHigh(T types.Type) bool {
+ return typeHeight(T) > 3
+}
projects / dotfiles / .git / blobdiff