ssa2pal: some work on tuples

tuples are weird, because they are not there at
runtime and so should not occupy memory like
structs do (which have their own distinct address).

Previously, I had tried to make tuples not be associated
with memory.Loc's nor objects.  This is too complicated.

This commit gives tuples their own address again.

It also adds some safety code in objects.Builder:
in order to ensure that the creation of a root compound
object triggers object creation (and not just typed
memory locations), we re-walk the object after creation
and reconstruct the object from the pal representation.

This walkObj method is still incomplete.

Author: scott-cotton

memory/model.go

@@ -234,13 +234,14 @@ func (mod *Model) p_add(gp *GenParams, p, r Loc, sum *int) Loc {
 		}
 
 	case typeset.Tuple:
+		mod.locs = append(mod.locs, l)
+		*sum++
 		tn := gp.ts.NumFields(gp.typ)
 		ttyp := gp.typ
 		for i := 0; i < tn; i++ {
 			_, gp.typ, _ = gp.ts.Field(ttyp, i)
 			mod.p_add(gp, n, r, sum)
 		}
-		added = false
 	case typeset.Named:
 		gp.typ = gp.ts.Underlying(gp.typ)
 		mod.p_add(gp, n, r, sum)

objects/builder.go

@@ -15,6 +15,7 @@
 package objects
 
 import (
+	"fmt"
 	"go/token"
 	"go/types"
 
@@ -111,14 +112,16 @@ func (b *Builder) Struct(gty *types.Struct) *Struct {
 	s.fields = make([]memory.Loc, 0, gty.NumFields())
 	for i := memory.Loc(1); i < n; i++ {
 		pfloc := b.mmod.Parent(s.loc + i)
-		if pfloc == s.loc {
-			s.fields = append(s.fields, s.loc+i)
+		if pfloc != s.loc {
+			continue
 		}
+		s.fields = append(s.fields, s.loc+i)
 	}
 	if len(s.fields) != gty.NumFields() {
 		panic("internal error")
 	}
 	b.omap[s.loc] = s
+	b.walkObj(s.loc)
 	return s
 }
 
@@ -130,6 +133,7 @@ func (b *Builder) Array(gty *types.Array) *Array {
 	a.n = gty.Len()
 	a.elemSize = int64(b.ts.Lsize(b.ts.Elem(a.typ)))
 	b.omap[a.loc] = a
+	b.walkObj(a.loc)
 	return a
 }
 
@@ -228,5 +232,86 @@ func (b *Builder) Func(sig *types.Signature, declName string, opaque memory.Attr
 	// TBD: FreeVars
 	b.omap[fn.loc] = fn
 	return fn
+}
+
+// second pass to associate objects with all object like memory locations...
+// the input is likely to just create roots at variables, but we need objects
+// everywhere...
+func (b *Builder) walkObj(m memory.Loc) {
+	ty := b.mmod.Type(m)
+	ki := b.ts.Kind(ty)
+	switch ki {
+	case typeset.Basic:
+		switch ty {
+		case typeset.Pointer:
+			if b.omap[m] == nil {
+				fmt.Printf("walk ptr\n")
+				ptr := &Pointer{}
+				ptr.loc = m
+				ptr.typ = ty
+				b.omap[m] = ptr
+			}
+		}
+	case typeset.Array:
+		var arr *Array
+		obj := b.omap[m]
+		if obj == nil {
+			fmt.Printf("walk arr\n")
+			arr = &Array{}
+			arr.loc = m
+			arr.typ = ty
+			arr.n = int64(b.ts.ArrayLen(ty))
+			arr.elemSize = int64(b.ts.Lsize(b.ts.Elem(ty)))
+			b.omap[m] = arr
+		} else {
+			arr = obj.(*Array)
+		}
+		n := b.ts.ArrayLen(ty)
+		for i := 0; i < n; i++ {
+			elt := arr.At(i)
+			b.walkObj(elt)
+		}
 
+	case typeset.Struct:
+		var strukt *Struct
+		obj := b.omap[m]
+		if obj == nil {
+			fmt.Printf("walk str\n")
+			strukt = &Struct{}
+			strukt.loc = m
+			strukt.typ = ty
+			n := b.ts.NumFields(ty)
+			strukt.fields = make([]memory.Loc, 0, n)
+			for i := 0; i < n; i++ {
+				_, _, foff := b.ts.Field(ty, i)
+				strukt.fields[i] = m + memory.Loc(foff)
+				b.walkObj(m + memory.Loc(foff))
+			}
+			b.omap[m] = strukt
+		} else {
+			strukt = obj.(*Struct)
+		}
+
+	case typeset.Chan:
+	case typeset.Map:
+		var ma *Map
+		obj := b.omap[m]
+		if obj == nil {
+			fmt.Printf("walk map\n")
+			ma := &Map{}
+			ma.loc = m
+			ma.typ = ty
+			b.omap[m] = ma
+		} else {
+			ma = obj.(*Map)
+		}
+		b.walkObj(ma.key)
+		b.walkObj(ma.elem)
+	case typeset.Slice:
+	case typeset.Interface:
+	case typeset.Func:
+	case typeset.Named:
+	case typeset.Tuple:
+
+	}
 }

objects/doc.go

@@ -38,12 +38,13 @@
 // The second set of methods relates to creating locations, objects
 // and constraints.  These are
 //
-//  1. Gen() generate a memory location.
-//  2. Add{Load,Store,Transfer,PointsTo}(dst, src)
+//  1. Builder.Gen() generate a memory location.
+//  2. Builder.Add{Load,Store,Transfer,PointsTo}(dst, src)
+//  3. Builder.{Struct,Array,Slice,Map,Func,Interface,Chan}
 //
 // The last set of methods gives access to the build results
 //
 //  1. Builder.Memory() *memory.Model
 //  2. Builder.TypeSet() *typeset.TypeSet
-//
+//  3. Builder.Object(m memory.Loc) Object (one of Struct,Array,Slice,Map,...)
 package objects

objects/tuple.go

@@ -0,0 +1,75 @@
+// Copyright 2021 The pal authors (see AUTHORS)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package objects
+
+import (
+	"io"
+
+	"github.com/go-air/pal/internal/plain"
+	"github.com/go-air/pal/memory"
+)
+
+type Tuple struct {
+	object
+	fields []memory.Loc
+}
+
+func (t *Tuple) NumFields(i int) int {
+	return len(t.fields)
+}
+
+func (t *Tuple) Field(i int) memory.Loc {
+	return t.fields[i]
+}
+
+func (t *Tuple) PlainEncode(w io.Writer) error {
+	var err error
+	err = t.object.plainEncode(w)
+	if err != nil {
+		return err
+	}
+	for i := range t.fields {
+		err = plain.Put(w, " ")
+		if err != nil {
+			return err
+		}
+		f := &t.fields[i]
+		err = f.PlainEncode(w)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *Tuple) PlainDecode(r io.Reader) error {
+	obj := &t.object
+	err := obj.plainDecode(r)
+	if err != nil {
+		return err
+	}
+	for i := range t.fields {
+		err = plain.Expect(r, " ")
+		if err != nil {
+			return err
+		}
+		f := &t.fields[i]
+		err = f.PlainDecode(r)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

ssa2pal/t.go

@@ -215,6 +215,7 @@ func (p *T) genBlockValues(name string, blk *ssa.BasicBlock) {
 // genValueLoc may need to work recursively on struct and
 // array typed structured data.
 func (p *T) genValueLoc(v ssa.Value) memory.Loc {
+	fmt.Printf("genValueLoc(%s)\n", v)
 	p.buildr.Pos(v.Pos()).GoType(v.Type()).Class(memory.Local).Attrs(memory.NoAttrs)
 	var res memory.Loc
 	switch v := v.(type) {
@@ -274,6 +275,16 @@ func (p *T) genValueLoc(v ssa.Value) memory.Loc {
 			p.buildr.AddLoad(res, qelt)
 		}
 	case *ssa.Extract:
+		tloc := p.vmap[v.Tuple]
+		if tloc == memory.NoLoc {
+			tloc = p.genValueLoc(v.Tuple)
+			// reset bld cfg for genLoc below
+			p.buildr.Pos(v.Pos()).GoType(v.Type()).Class(memory.Local).Attrs(memory.NoAttrs)
+		}
+		t := p.buildr.Object(tloc).(*objects.Tuple)
+		res = t.Field(v.Index)
+
+		//v.Tuple, v.Index
 
 	case *ssa.Const:
 		return memory.NoLoc
@@ -451,6 +462,7 @@ func (p *T) invoke(c ssa.CallCommon) {
 func (p *T) putResults() {
 	if debugLogModel {
 		fmt.Printf("built pal model for %s\n", p.pkgres.PkgPath)
+		p.buildr.TypeSet().PlainEncode(os.Stdout)
 		p.buildr.Memory().PlainEncode(os.Stdout)
 	}
 	p.results.Put(p.pass.Pkg.Path(), p.pkgres)

typeset/gotypes.go

@@ -141,7 +141,7 @@ func (t *TypeSet) FromGoType(gotype types.Type) Type {
 	case *types.Tuple:
 		N := ty.Len()
 		res := make([]named, N)
-		off := 0
+		off := 1
 		for i := 0; i < N; i++ {
 			at := ty.At(i)
 			res[i].name = at.Name()

typeset/typeset.go

@@ -203,7 +203,7 @@ func (t *TypeSet) getSignature(recv Type, params, results []named, variadic bool
 func (t *TypeSet) getTuple(elts []named) Type {
 	ty, node := t.newNode()
 	node.kind = Tuple
-	node.lsize = 0
+	node.lsize = 1
 	node.fields = elts
 	for _, field := range elts {
 		node.lsize += t.nodes[field.typ].lsize