precise gc wip

Author: niaow

compiler/gctype/gctype.go

@@ -0,0 +1,103 @@
+package gctype
+
+import (
+	"math/big"
+
+	"tinygo.org/x/go-llvm"
+)
+
+// getPointerBitmap scans the given LLVM type for pointers and sets bits in a
+// bigint at the word offset that contains a pointer. This scan is recursive.
+func getPointerBitmap(targetData llvm.TargetData, typ llvm.Type, name string) *big.Int {
+	alignment := targetData.PrefTypeAlignment(llvm.PointerType(typ.Context().Int8Type(), 0))
+	switch typ.TypeKind() {
+	case llvm.IntegerTypeKind, llvm.FloatTypeKind, llvm.DoubleTypeKind:
+		return big.NewInt(0)
+	case llvm.PointerTypeKind:
+		return big.NewInt(1)
+	case llvm.StructTypeKind:
+		ptrs := big.NewInt(0)
+		for i, subtyp := range typ.StructElementTypes() {
+			subptrs := getPointerBitmap(targetData, subtyp, name)
+			if subptrs.BitLen() == 0 {
+				continue
+			}
+			offset := targetData.ElementOffset(typ, i)
+			if offset%uint64(alignment) != 0 {
+				panic("precise GC: global contains unaligned pointer: " + name)
+			}
+			subptrs.Lsh(subptrs, uint(offset)/uint(alignment))
+			ptrs.Or(ptrs, subptrs)
+		}
+		return ptrs
+	case llvm.ArrayTypeKind:
+		subtyp := typ.ElementType()
+		subptrs := getPointerBitmap(targetData, subtyp, name)
+		ptrs := big.NewInt(0)
+		if subptrs.BitLen() == 0 {
+			return ptrs
+		}
+		elementSize := targetData.TypeAllocSize(subtyp)
+		for i := 0; i < typ.ArrayLength(); i++ {
+			ptrs.Lsh(ptrs, uint(elementSize)/uint(alignment))
+			ptrs.Or(ptrs, subptrs)
+		}
+		return ptrs
+	default:
+		panic("unknown type kind: " + name)
+	}
+}
+
+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)
+	}
+	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
+
+	uintptr, i8 llvm.Type
+}
+
+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
+	}
+
+	// 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)
+
+	// Construct a tuple of the size + the array.
+	tuple := llvm.ConstStruct([]llvm.Value{
+		llvm.ConstInt(t.uintptr, size, false),
+		bitmapArray,
+	}, false)
+}