strongly typed memory WIP

Author: niaow

compiler/compiler.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
+	"github.com/tinygo-org/tinygo/compiler/gctype"
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"github.com/tinygo-org/tinygo/ir"
 	"github.com/tinygo-org/tinygo/loader"
@@ -51,6 +52,7 @@ type compilerContext struct {
 	ir               *ir.Program
 	diagnostics      []error
 	astComments      map[string]*ast.CommentGroup
+	typer            *gctype.Typer
 }
 
 // builder contains all information relevant to build a single function.
@@ -249,6 +251,13 @@ func Compile(pkgName string, machine llvm.TargetMachine, config *compileopts.Con
 		c.createFunctionDeclaration(f)
 	}
 
+	allocTyped := c.mod.NamedFunction("runtime.allocTyped")
+	if !allocTyped.IsNil() {
+		// The runtime has precise types available.
+		// Initialize garbage collector type system.
+		c.typer = gctype.NewTyper(c.ctx, c.mod, c.targetData)
+	}
+
 	// Add definitions to declarations.
 	var initFuncs []llvm.Value
 	irbuilder := c.ctx.NewBuilder()
@@ -314,8 +323,14 @@ func Compile(pkgName string, machine llvm.TargetMachine, config *compileopts.Con
 
 	// Tell the optimizer that runtime.alloc is an allocator, meaning that it
 	// returns values that are never null and never alias to an existing value.
+	// Do the same for the typed allocator.
+	alloc := c.mod.NamedFunction("runtime.alloc")
 	for _, attrName := range []string{"noalias", "nonnull"} {
-		c.mod.NamedFunction("runtime.alloc").AddAttributeAtIndex(0, getAttr(attrName))
+		attr := getAttr(attrName)
+		alloc.AddAttributeAtIndex(0, attr)
+		if !allocTyped.IsNil() {
+			allocTyped.AddAttributeAtIndex(0, attr)
+		}
 	}
 
 	// On *nix systems, the "abort" functuion in libc is used to handle fatal panics.
@@ -1462,7 +1477,18 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 				return llvm.Value{}, b.makeError(expr.Pos(), fmt.Sprintf("value is too big (%v bytes)", size))
 			}
 			sizeValue := llvm.ConstInt(b.uintptrType, size, false)
-			buf := b.createRuntimeCall("alloc", []llvm.Value{sizeValue}, expr.Comment)
+			var buf llvm.Value
+			if b.typer != nil {
+				// Allocate a typed value.
+				t, err := b.typer.Create(typ)
+				if err != nil {
+					return llvm.Value{}, b.makeError(expr.Pos(), err.Error())
+				}
+				buf = b.createRuntimeCall("allocTyped", []llvm.Value{sizeValue, t}, expr.Comment)
+			} else {
+				// Allocate an untyped value.
+				buf = b.createRuntimeCall("alloc", []llvm.Value{sizeValue}, expr.Comment)
+			}
 			buf = b.CreateBitCast(buf, llvm.PointerType(typ, 0), "")
 			return buf, nil
 		} else {
@@ -1675,7 +1701,18 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			return llvm.Value{}, err
 		}
 		sliceSize := b.CreateBinOp(llvm.Mul, elemSizeValue, sliceCapCast, "makeslice.cap")
-		slicePtr := b.createRuntimeCall("alloc", []llvm.Value{sliceSize}, "makeslice.buf")
+		var slicePtr llvm.Value
+		if b.typer != nil {
+			// Allocate a typed value.
+			t, err := b.typer.Create(llvmElemType)
+			if err != nil {
+				return llvm.Value{}, b.makeError(expr.Pos(), err.Error())
+			}
+			slicePtr = b.createRuntimeCall("allocTyped", []llvm.Value{sliceSize, t}, "makeslice.buf")
+		} else {
+			// Allocate an untyped value.
+			slicePtr = b.createRuntimeCall("alloc", []llvm.Value{sliceSize}, "makeslice.buf")
+		}
 		slicePtr = b.CreateBitCast(slicePtr, llvm.PointerType(llvmElemType, 0), "makeslice.array")
 
 		// Extend or truncate if necessary. This is safe as we've already done

compiler/gctype/gctype.go

@@ -1,6 +1,8 @@
 package gctype
 
 import (
+	"errors"
+	"fmt"
 	"math/big"
 
 	"tinygo.org/x/go-llvm"
@@ -48,56 +50,109 @@ func getPointerBitmap(targetData llvm.TargetData, typ llvm.Type, name string) *b
 	}
 }
 
-func bitmapToValue(b *big.Int, size uintptr, byte llvm.Type) llvm.Value {
-	// Create a bitmap (a new global) that stores for each word in the globals
-	// bundle whether it contains a pointer. This allows globals to be scanned
-	// precisely: no non-pointers will be considered pointers if the bit pattern
-	// looks like one.
-	// This code assumes that pointers are self-aligned. For example, that a
-	// 32-bit (4-byte) pointer is also aligned to 4 bytes.
-	bitmapBytes := b.Bytes()
-	bitmapValues := make([]llvm.Value, len(bitmapBytes))
-	for i, b := range bitmapBytes {
-		bitmapValues[len(bitmapBytes)-i-1] = llvm.ConstInt(byte, uint64(b), false)
+// NewTyper creates a Typer.
+func NewTyper(ctx llvm.Context, mod llvm.Module, td llvm.TargetData) *Typer {
+	ptr := llvm.PointerType(ctx.Int8Type(), 0)
+	return &Typer{
+		tcache:   make(map[llvm.Type]llvm.Value),
+		td:       td,
+		mod:      mod,
+		uintptr:  ctx.IntType(int(td.TypeSizeInBits(ptr))),
+		i8:       ctx.Int8Type(),
+		ptrSize:  td.TypeAllocSize(ptr),
+		ptrAlign: uint64(td.ABITypeAlignment(ptr)),
 	}
-	return llvm.ConstArray(byte, bitmapValues)
 }
 
 // Typer creates GC types.
 type Typer struct {
 	// tcache is a cache of GC types by LLVM type.
 	tcache map[llvm.Type]llvm.Value
 
-	// bcache is a cache of GC types by size and GC bitmap.
-	bcache map[uint64]map[string]llvm.Value
-
 	// td is the target platform data.
 	td llvm.TargetData
 
-	// idIntrinsic is used on AVR to map a type bitmap to a uintptr ID.
-	idIntrinsic llvm.Value
+	mod llvm.Module
 
 	uintptr, i8 llvm.Type
+
+	ptrSize, ptrAlign uint64
+}
+
+// Create a GC type for the given LLVM type.
+func (t *Typer) Create(typ llvm.Type) (llvm.Value, error) {
+	// Check the cache before attempting to create the global.
+	if g, ok := t.tcache[typ]; ok {
+		return g, nil
+	}
+
+	// Find the type size.
+	size := t.td.TypeAllocSize(typ)
+
+	// Compute a pointer bitmap.
+	// TODO: clean this up and maybe use error handling?
+	b := getPointerBitmap(t.td, typ, "")
+	if b.Cmp(big.NewInt(0)) == 0 {
+		// The type has no pointers.
+		return llvm.ConstNull(llvm.PointerType(t.uintptr, 0)), nil
+	}
+
+	// Use some limited sanity-checking.
+	align := uint64(t.td.ABITypeAlignment(typ))
+	switch {
+	case size < t.ptrSize:
+		return llvm.Value{}, errors.New("type has pointers but is smaller than a pointer")
+	case align%t.ptrAlign != 0:
+		return llvm.Value{}, errors.New("alignment of pointery type is not a multiple of pointer alignment")
+	case size%align != 0:
+		return llvm.Value{}, errors.New("type violates the array alignment invariant")
+	}
+
+	// Convert size into increments of pointer-align.
+	size /= t.ptrAlign
+
+	// Create a global for the type.
+	g := t.createGlobal(size, b.Bytes())
+
+	// Save the global to the cache.
+	t.tcache[typ] = g
+
+	return g, nil
 }
 
 func (t *Typer) createGlobal(size uint64, layout []byte) llvm.Value {
 	// TODO: compression?
 
-	// Check the cache before attempting to create the global.
-	if g, ok := t.bcache[size][string(layout)]; ok {
-		return g
-	}
+	// Generate the name of the global.
+	name := fmt.Sprintf("tinygo.gc.type.%d.%x", size, layout)
+
+	// Create the global if it does not exist.
+	g := t.mod.NamedGlobal(name)
+	if g.IsNil() {
+		// Convert the encoded layout to a byte array.
+		bitmapValues := make([]llvm.Value, len(layout))
+		for i, b := range layout {
+			bitmapValues[len(layout)-i-1] = llvm.ConstInt(t.i8, uint64(b), false)
+		}
+		bitmapArray := llvm.ConstArray(t.i8, bitmapValues)
 
-	// Convert the encoded layout to a byte array.
-	bitmapValues := make([]llvm.Value, len(layout))
-	for i, b := range layout {
-		bitmapValues[len(layout)-i-1] = llvm.ConstInt(t.i8, uint64(b), false)
+		// Construct a tuple of the size + the array.
+		tuple := llvm.ConstStruct([]llvm.Value{
+			llvm.ConstInt(t.uintptr, size, false),
+			bitmapArray,
+		}, false)
+
+		// Create a global constant initialized with the tuple.
+		g = llvm.AddGlobal(t.mod, tuple.Type(), name)
+		g.SetInitializer(tuple)
+		g.SetGlobalConstant(true)
+		g.SetUnnamedAddr(true)
+		g.SetLinkage(llvm.InternalLinkage)
 	}
-	bitmapArray := llvm.ConstArray(t.i8, bitmapValues)
 
-	// Construct a tuple of the size + the array.
-	tuple := llvm.ConstStruct([]llvm.Value{
-		llvm.ConstInt(t.uintptr, size, false),
-		bitmapArray,
-	}, false)
+	// Get a pointer to the size component of the global.
+	// This is used because different globals will end up with different sizes.
+	g = llvm.ConstBitCast(g, llvm.PointerType(t.uintptr, 0))
+
+	return g
 }

interp/frame.go

@@ -177,7 +177,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 			operand := inst.Operand(0)
 			if !operand.IsACallInst().IsNil() {
 				fn := operand.CalledValue()
-				if !fn.IsAFunction().IsNil() && fn.Name() == "runtime.alloc" {
+				if !fn.IsAFunction().IsNil() && (fn.Name() == "runtime.alloc" || fn.Name() == "runtime.allocTyped") {
 					continue // special case: bitcast of alloc
 				}
 			}
@@ -245,7 +245,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 		case !inst.IsACallInst().IsNil():
 			callee := inst.CalledValue()
 			switch {
-			case callee.Name() == "runtime.alloc":
+			case callee.Name() == "runtime.alloc" || callee.Name() == "runtime.allocTyped":
 				// heap allocation
 				users := getUses(inst)
 				var resultInst = inst

src/runtime/gc_list.go

@@ -21,6 +21,28 @@ func isInHeap(addr uintptr) bool {
 	return addr >= heapStart && addr < heapEnd
 }
 
+// gcType is a chunk of metadata used to semi-precisely scan an allocation.
+// The compiler will produce constant globals which can be used in this form.
+type gcType struct {
+	// size is the element size, measured in increments of pointer alignment.
+	size uintptr
+
+	// data is a bitmap following the size value.
+	// It is organized as a []byte, and set bits indicate places where a pointer may be present.
+	data struct{}
+}
+
+// untypedType is a placeholder type used for now to deal with untyped allocations.
+var untypedType = struct {
+	t    gcType
+	data [1]byte
+}{
+	t: gcType{
+		size: 1,
+	},
+	data: [1]byte{1},
+}
+
 // allocNode is a node in the allocations list.
 // It is prepended to every allocation, resulting in an overhead of 4 bytes per allocation.
 type allocNode struct {
@@ -30,6 +52,9 @@ type allocNode struct {
 	// len is the length of the body of this node in bytes.
 	len uintptr
 
+	// typ is the memory type of this node.
+	typ *gcType
+
 	// base is the start of the body of this node.
 	base struct{}
 }
@@ -46,7 +71,7 @@ func markRoot(addr, root uintptr) {
 }
 
 func markRoots(start, end uintptr) {
-	markMem(start, end)
+	untypedType.t.markMem(start, end)
 }
 
 // markAddr marks the allocation containing the specified address.
@@ -69,6 +94,7 @@ func markAddr(addr uintptr) {
 		if addr < endAddr {
 			// The address is included in this allocation.
 			// Move the allocation to the scan stack.
+			println("    mark", addr)
 			*prev = node.next
 			scanList, node.next = node, scanList
 			return
@@ -79,7 +105,9 @@ func markAddr(addr uintptr) {
 // GC runs a garbage collection cycle.
 func GC() {
 	// Mark phase: mark all reachable objects, recursively.
+	println("scan globals")
 	markGlobals()
+	println("scan stack")
 	markStack()
 	var markedTaskQueue task.Queue
 runqueueScan:
@@ -98,16 +126,19 @@ runqueueScan:
 		}
 	}
 
+	println("scan work list")
 	var keep *allocNode
 	for scanList != nil {
 		// Pop a node off of the scan list.
 		node := scanList
 		scanList = node.next
 
+		println(" scan node", node, node.typ)
+
 		// Scan the node.
 		baseAddr := uintptr(unsafe.Pointer(&node.base))
 		endAddr := baseAddr + node.len
-		markMem(baseAddr, endAddr)
+		node.typ.markMem(baseAddr, endAddr)
 
 		// Insert the node into the output heap.
 		var prev *allocNode
@@ -205,10 +236,16 @@ searchLoop:
 	return mem
 }
 
-// alloc tries to find some free space on the heap, possibly doing a garbage
+// alloc a chunk of untyped memory.
+//go:inline
+func alloc(size uintptr) unsafe.Pointer {
+	return allocTyped(size, &untypedType.t.size)
+}
+
+// allocTyped tries to find some free space on the heap, possibly doing a garbage
 // collection cycle if needed. If no space is free, it panics.
 //go:noinline
-func alloc(size uintptr) unsafe.Pointer {
+func allocTyped(size uintptr, typ *uintptr) unsafe.Pointer {
 	var ranGC bool
 tryAlloc:
 	// Search for available memory.
@@ -227,9 +264,13 @@ tryAlloc:
 		goto tryAlloc
 	}
 
-	// Zero the allocation and return it.
+	// Zero the allocation.
 	ptr := unsafe.Pointer(&node.base)
 	memzero(ptr, size)
+
+	// Apply the type to the allocation.
+	node.typ = (*gcType)(unsafe.Pointer(typ))
+
 	return ptr
 }