WIP fix(gnovm): correct map key persistence

gno.land/cmd/gnoland/testdata/ptr_mapkey.txtar

@@ -0,0 +1,32 @@
+
+gnoland start
+
+# add contract
+gnokey maketx addpkg -pkgdir $WORK -pkgpath gno.land/r/demo/ptrmap -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
+stdout OK!
+
+gnokey maketx call -pkgpath gno.land/r/demo/ptrmap -func AddToMap -args 5 -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
+stdout OK!
+
+gnokey maketx call -pkgpath gno.land/r/demo/ptrmap -func GetFromMap -gas-fee 1000000ugnot -gas-wanted 2000000 -broadcast -chainid=tendermint_test test1
+stdout '(5 int)'
+stdout OK!
+
+-- gno.mod --
+module gno.land/r/demo/ptrmap
+
+-- realm.gno --
+package ptrmap
+
+var (
+	m = map[*int]int{}
+	i = new(int)
+)
+
+func AddToMap(value int) {
+	m[i] = value
+}
+
+func GetFromMap() int {
+	return m[i]
+}

gnovm/1.gno

@@ -0,0 +1,13 @@
+package main
+
+var arr1 [2]int
+var arr2 [2]int
+
+func init() {
+	arr1 = [2]int{1, 2}
+	arr2 = [2]int{1, 2}
+}
+
+func main() {
+	println(&arr1 == &arr1)
+}

gnovm/2.gno

@@ -0,0 +1,12 @@
+package main
+
+var i = new(int)
+
+func init() {
+	println(i == i)
+}
+
+func main() {
+	*i = 1
+	println(i == i)
+}

gnovm/pkg/gnolang/gonative_test.go

@@ -43,7 +43,7 @@ func TestGoNativeDefine(t *testing.T) {
 	pkg.DefineGoNativeType(rt)
 	nt := pkg.GetValueRef(nil, Name("Foo"), true).GetType().(*NativeType)
 	assert.Equal(t, rt, nt.Type)
-	path := pkg.GetPathForName(nil, Name("Foo"))
+	path, _ := pkg.GetPathForName(nil, Name("Foo"))
 	assert.Equal(t, uint8(1), path.Depth)
 	assert.Equal(t, uint16(0), path.Index)
 	pv := pkg.NewPackage()

gnovm/pkg/gnolang/machine.go

@@ -505,19 +505,22 @@ func (m *Machine) Stacktrace() (stacktrace Stacktrace) {
 	}
 
 	calls := make([]StacktraceCall, 0, len(m.Stmts))
-	nextStmtIndex := len(m.Stmts) - 1
-	for i := len(m.Frames) - 1; i >= 0; i-- {
-		if m.Frames[i].IsCall() {
-			stm := m.Stmts[nextStmtIndex]
-			bs := stm.(*bodyStmt)
-			stm = bs.Body[bs.NextBodyIndex-1]
-			calls = append(calls, StacktraceCall{
-				Stmt:  stm,
-				Frame: m.Frames[i],
-			})
+	if len(m.Stmts) > 1 {
+
+		nextStmtIndex := len(m.Stmts) - 1
+		for i := len(m.Frames) - 1; i >= 0; i-- {
+			if m.Frames[i].IsCall() {
+				stm := m.Stmts[nextStmtIndex]
+				bs := stm.(*bodyStmt)
+				stm = bs.Body[bs.NextBodyIndex-1]
+				calls = append(calls, StacktraceCall{
+					Stmt:  stm,
+					Frame: m.Frames[i],
+				})
+			}
+			// if the frame is a call, the next statement is the last statement of the frame.
+			nextStmtIndex = m.Frames[i].NumStmts - 1
 		}
-		// if the frame is a call, the next statement is the last statement of the frame.
-		nextStmtIndex = m.Frames[i].NumStmts - 1
 	}
 
 	// if the stacktrace is too long, we trim it down to maxStacktraceSize
@@ -1749,6 +1752,7 @@ func (m *Machine) PushValue(tv TypedValue) {
 	if debug {
 		m.Printf("+v %v\n", tv)
 	}
+	fmt.Printf("+v %v\n", tv)
 	if len(m.Values) == m.NumValues {
 		// TODO tune. also see PushOp().
 		newValues := make([]TypedValue, len(m.Values)*2)
@@ -1766,6 +1770,7 @@ func (m *Machine) PopValue() (tv *TypedValue) {
 	if debug {
 		m.Printf("-v %v\n", tv)
 	}
+	fmt.Printf("-v %v\n", tv)
 	m.NumValues--
 	return tv
 }
@@ -2079,6 +2084,7 @@ func (m *Machine) PopUntilLastCallFrame() *Frame {
 }
 
 func (m *Machine) PushForPointer(lx Expr) {
+	fmt.Println("---PushForPointer, lx: ", lx)
 	switch lx := lx.(type) {
 	case *NameExpr:
 		// no Lhs eval needed.
@@ -2090,14 +2096,17 @@ func (m *Machine) PushForPointer(lx Expr) {
 		m.PushExpr(lx.X)
 		m.PushOp(OpEval)
 	case *SelectorExpr:
+		println("---selector expr")
 		// evaluate X
 		m.PushExpr(lx.X)
 		m.PushOp(OpEval)
 	case *StarExpr:
+		println("---star expr, eval .X")
 		// evaluate X (a reference)
 		m.PushExpr(lx.X)
 		m.PushOp(OpEval)
 	case *CompositeLitExpr: // for *RefExpr e.g. &mystruct{}
+		println("---CompositeLitExpr")
 		// evaluate lx.
 		m.PushExpr(lx)
 		m.PushOp(OpEval)
@@ -2109,28 +2118,22 @@ func (m *Machine) PushForPointer(lx Expr) {
 }
 
 func (m *Machine) PopAsPointer(lx Expr) PointerValue {
+	fmt.Println("---PopAsPointer, lx: ", lx)
 	switch lx := lx.(type) {
 	case *NameExpr:
-		switch lx.Type {
-		case NameExprTypeNormal:
-			lb := m.LastBlock()
-			return lb.GetPointerTo(m.Store, lx.Path)
-		case NameExprTypeHeapUse:
-			lb := m.LastBlock()
-			return lb.GetPointerToHeapUse(m.Store, lx.Path)
-		case NameExprTypeHeapClosure:
-			panic("should not happen")
-		default:
-			panic("unexpected NameExpr in PopAsPointer")
-		}
+		lb := m.LastBlock()
+		ptr := lb.GetPointerToMaybeHeapUse(m.Store, lx)
+		return ptr
 	case *IndexExpr:
 		iv := m.PopValue()
 		xv := m.PopValue()
+		fmt.Println("---index expr: ", lx)
 		return xv.GetPointerAtIndex(m.Alloc, m.Store, iv)
 	case *SelectorExpr:
 		xv := m.PopValue()
 		return xv.GetPointerToFromTV(m.Alloc, m.Store, lx.Path)
 	case *StarExpr:
+		println("---StarExpr")
 		ptr := m.PopValue().V.(PointerValue)
 		return ptr
 	case *CompositeLitExpr: // for *RefExpr

gnovm/pkg/gnolang/misc.go

@@ -104,7 +104,7 @@ func isUpper(s string) bool {
 	return unicode.IsUpper(first)
 }
 
-//----------------------------------------
+// ----------------------------------------
 // converting uintptr to bytes.
 
 const sizeOfUintPtr = unsafe.Sizeof(uintptr(0))
@@ -171,3 +171,18 @@ func DerivePkgAddr(pkgPath string) crypto.Address {
 	// NOTE: must not collide with pubkey addrs.
 	return crypto.AddressFromPreimage([]byte("pkgPath:" + pkgPath))
 }
+
+func buildAbsolutePath(n Expr) string {
+	switch n := n.(type) {
+	case *NameExpr:
+		return n.AbsPath
+	case *IndexExpr:
+		return buildAbsolutePath(n.X) + ":" + buildAbsolutePath(n.Index)
+	case *SelectorExpr:
+		return buildAbsolutePath(n.X) + ":" + string(n.Sel)
+	case *StarExpr:
+		return buildAbsolutePath(n.X)
+	default:
+		return n.String()
+	}
+}

gnovm/pkg/gnolang/nodes.go

@@ -403,12 +403,20 @@ const (
 	NameExprTypeHeapClosure                     // when closure captures name
 )
 
+type AbsPather interface {
+	GetAbsPath() string
+}
 type NameExpr struct {
 	Attributes
 	// TODO rename .Path's to .ValuePaths.
 	Path ValuePath // set by preprocessor.
 	Name
-	Type NameExprType
+	Type    NameExprType
+	AbsPath string
+}
+
+func (nx *NameExpr) GetAbsPath() string {
+	return nx.AbsPath
 }
 
 type NameExprs []NameExpr
@@ -439,16 +447,26 @@ type CallExpr struct { // Func(Args<Varg?...>)
 
 type IndexExpr struct { // X[Index]
 	Attributes
-	X     Expr // expression
-	Index Expr // index expression
-	HasOK bool // if true, is form: `value, ok := <X>[<Key>]
+	X       Expr // expression
+	Index   Expr // index expression
+	HasOK   bool // if true, is form: `value, ok := <X>[<Key>]
+	AbsPath string
+}
+
+func (ix *IndexExpr) GetAbsPath() string {
+	return ix.AbsPath
 }
 
 type SelectorExpr struct { // X.Sel
 	Attributes
-	X    Expr      // expression
-	Path ValuePath // set by preprocessor.
-	Sel  Name      // field selector
+	X       Expr      // expression
+	Path    ValuePath // set by preprocessor.
+	Sel     Name      // field selector
+	AbsPath string
+}
+
+func (sx *SelectorExpr) GetAbsPath() string {
+	return sx.AbsPath
 }
 
 type SliceExpr struct { // X[Low:High:Max]
@@ -464,7 +482,12 @@ type SliceExpr struct { // X[Low:High:Max]
 // expression, or a pointer type.
 type StarExpr struct { // *X
 	Attributes
-	X Expr // operand
+	X       Expr // operand
+	AbsPath string
+}
+
+func (sx *StarExpr) GetAbsPath() string {
+	return sx.AbsPath
 }
 
 type RefExpr struct { // &X
@@ -1364,6 +1387,7 @@ type PackageNode struct {
 	PkgPath string
 	PkgName Name
 	*FileSet
+	Time uint64
 }
 
 func PackageNodeLocation(path string) Location {
@@ -1529,7 +1553,7 @@ type BlockNode interface {
 	GetExternNames() []Name
 	GetNumNames() uint16
 	GetParentNode(Store) BlockNode
-	GetPathForName(Store, Name) ValuePath
+	GetPathForName(Store, Name) (ValuePath, string)
 	GetBlockNodeForPath(Store, ValuePath) BlockNode
 	GetIsConst(Store, Name) bool
 	GetLocalIndex(Name) (uint16, bool)
@@ -1555,6 +1579,7 @@ type StaticBlock struct {
 	Consts   []Name // TODO consider merging with Names.
 	Externs  []Name
 	Loc      Location
+	BID      BlockID
 
 	// temporary storage for rolling back redefinitions.
 	oldValues []oldValue
@@ -1662,14 +1687,16 @@ func (sb *StaticBlock) GetParentNode(store Store) BlockNode {
 
 // Implements BlockNode.
 // As a side effect, notes externally defined names.
-func (sb *StaticBlock) GetPathForName(store Store, n Name) ValuePath {
+func (sb *StaticBlock) GetPathForName(store Store, n Name) (rel ValuePath, abs string) {
+	fmt.Println("---GetPathForName, n: ", n)
 	if n == blankIdentifier {
-		return NewValuePathBlock(0, 0, blankIdentifier)
+		return NewValuePathBlock(0, 0, blankIdentifier), ""
 	}
 	// Check local.
 	gen := 1
 	if idx, ok := sb.GetLocalIndex(n); ok {
-		return NewValuePathBlock(uint8(gen), idx, n)
+		fmt.Println("---bid1: ", sb.BID)
+		return NewValuePathBlock(uint8(gen), idx, n), fmt.Sprintf("%s:[%d]", sb.BID, idx)
 	}
 	// Register as extern.
 	// NOTE: uverse names are externs too.
@@ -1684,7 +1711,11 @@ func (sb *StaticBlock) GetPathForName(store Store, n Name) ValuePath {
 	bp := sb.GetParentNode(store)
 	for bp != nil {
 		if idx, ok := bp.GetLocalIndex(n); ok {
-			return NewValuePathBlock(uint8(gen), idx, n)
+			fmt.Println("---bp: ", bp)
+			fmt.Println("---bid2: ", bp.GetStaticBlock().BID)
+			fmt.Println("---gen: ", gen)
+			fmt.Println("---idx: ", idx)
+			return NewValuePathBlock(uint8(gen), idx, n), fmt.Sprintf("%s:[%d]", bp.GetStaticBlock().BID, idx)
 		} else {
 			if !isFile(bp) {
 				bp.GetStaticBlock().addExternName(n)
@@ -1698,7 +1729,7 @@ func (sb *StaticBlock) GetPathForName(store Store, n Name) ValuePath {
 	}
 	// Finally, check uverse.
 	if idx, ok := UverseNode().GetLocalIndex(n); ok {
-		return NewValuePathUverse(idx, n)
+		return NewValuePathUverse(idx, n), ""
 	}
 	// Name does not exist.
 	panic(fmt.Sprintf("name %s not declared", n))

gnovm/pkg/gnolang/nodes_string.go

@@ -95,6 +95,7 @@ func (vp ValuePath) String() string {
 	}
 }
 
+// TODO: modify this
 func (x NameExpr) String() string {
 	switch x.Type {
 	case NameExprTypeNormal:

gnovm/pkg/gnolang/op_assign.go

@@ -1,5 +1,7 @@
 package gnolang
 
+import "fmt"
+
 func (m *Machine) doOpDefine() {
 	s := m.PopStmt().(*AssignStmt)
 	// Define each value evaluated for Lhs.
@@ -26,6 +28,7 @@ func (m *Machine) doOpDefine() {
 
 func (m *Machine) doOpAssign() {
 	s := m.PopStmt().(*AssignStmt)
+	fmt.Println("---doOpAssign, s: ", s)
 	// Assign each value evaluated for Lhs.
 	// NOTE: PopValues() returns a slice in
 	// forward order, not the usual reverse.