runtime: mark all global variables explicitly for GC

builder/bdwgc.go

@@ -30,10 +30,11 @@ var BoehmGC = Library{
 			// Use a minimal environment.
 			"-DNO_MSGBOX_ON_ERROR", // don't call MessageBoxA on Windows
 			"-DDONT_USE_ATEXIT",
-			"-DNO_GETENV",          // smaller binary, more predictable configuration
-			"-DNO_CLOCK",           // don't use system clock
-			"-DNO_DEBUGGING",       // reduce code size
-			"-DGC_NO_FINALIZATION", // finalization is not used at the moment
+			"-DNO_GETENV",               // smaller binary, more predictable configuration
+			"-DNO_CLOCK",                // don't use system clock
+			"-DNO_DEBUGGING",            // reduce code size
+			"-DGC_NO_FINALIZATION",      // finalization is not used at the moment
+			"-DGC_ATOMIC_UNCOLLECTABLE", // pointer-free storage retained until GC_free
 
 			// Special flag to work around the lack of __data_start in ld.lld.
 			// TODO: try to fix this in LLVM/lld directly so we don't have to

builder/build.go

@@ -1286,6 +1286,7 @@ func makeGlobalsModule(ctx llvm.Context, globals map[string]map[string]string, m
 			global := llvm.AddGlobal(mod, stringType, globalName)
 			global.SetInitializer(initializer)
 			global.SetAlignment(targetData.PrefTypeAlignment(stringType))
+			global.SetVisibility(llvm.HiddenVisibility)
 		}
 	}
 

builder/sizes_test.go

@@ -42,9 +42,9 @@ func TestBinarySize(t *testing.T) {
 	// This is a small number of very diverse targets that we want to test.
 	tests := []sizeTest{
 		// microcontrollers
-		{"hifive1b", "examples/echo", 4313, 323, 0, 2260},
-		{"microbit", "examples/serial", 2838, 382, 8, 2256},
-		{"wioterminal", "examples/pininterrupt", 8027, 1665, 132, 7488},
+		{"hifive1b", "examples/echo", 4477, 323, 0, 2260},
+		{"microbit", "examples/serial", 2946, 382, 8, 2256},
+		{"wioterminal", "examples/pininterrupt", 8507, 1717, 148, 7488},
 
 		// TODO: also check wasm. Right now this is difficult, because
 		// wasm binaries are run through wasm-opt and therefore the

compileopts/config.go

@@ -24,7 +24,7 @@ import (
 // library path in advance in several places).
 var libVersions = map[string]int{
 	"musl":  3,
-	"bdwgc": 2,
+	"bdwgc": 3,
 }
 
 // Config keeps all configuration affecting the build in a single struct.

compiler/channel.go

@@ -14,16 +14,18 @@ import (
 )
 
 func (b *builder) createMakeChan(expr *ssa.MakeChan) llvm.Value {
-	elementSize := b.targetData.TypeAllocSize(b.getLLVMType(expr.Type().Underlying().(*types.Chan).Elem()))
+	elementType := b.getLLVMType(expr.Type().Underlying().(*types.Chan).Elem())
+	elementSize := b.targetData.TypeAllocSize(elementType)
 	elementSizeValue := llvm.ConstInt(b.uintptrType, elementSize, false)
+	elementLayout := b.createObjectLayout(elementType, expr.Pos())
 	bufSize := b.getValue(expr.Size, getPos(expr))
 	b.createChanBoundsCheck(elementSize, bufSize, expr.Size.Type().Underlying().(*types.Basic), expr.Pos())
 	if bufSize.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
 		bufSize = b.CreateZExt(bufSize, b.uintptrType, "")
 	} else if bufSize.Type().IntTypeWidth() > b.uintptrType.IntTypeWidth() {
 		bufSize = b.CreateTrunc(bufSize, b.uintptrType, "")
 	}
-	return b.createRuntimeCall("chanMake", []llvm.Value{elementSizeValue, bufSize}, "")
+	return b.createRuntimeCall("chanMake", []llvm.Value{elementSizeValue, bufSize, elementLayout}, "")
 }
 
 // createChanSend emits a pseudo chan send operation. It is lowered to the

compiler/interface.go

@@ -284,13 +284,15 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
 				types.NewVar(token.NoPos, nil, "length", types.Typ[types.Uintptr]),
 				types.NewVar(token.NoPos, nil, "sliceOf", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "layout", types.Typ[types.UnsafePointer]),
 			)
 		case *types.Map:
 			typeFieldTypes = append(typeFieldTypes,
 				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
 				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
 				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
 				types.NewVar(token.NoPos, nil, "keyType", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "hashmapTypeInfo", types.Typ[types.UnsafePointer]),
 			)
 		case *types.Struct:
 			typeFieldTypes = append(typeFieldTypes,
@@ -299,6 +301,7 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				types.NewVar(token.NoPos, nil, "pkgpath", types.Typ[types.UnsafePointer]),
 				types.NewVar(token.NoPos, nil, "size", types.Typ[types.Uint32]),
 				types.NewVar(token.NoPos, nil, "numFields", types.Typ[types.Uint16]),
+				types.NewVar(token.NoPos, nil, "layout", types.Typ[types.UnsafePointer]),
 				types.NewVar(token.NoPos, nil, "fields", types.NewArray(c.getRuntimeType("structField"), int64(typ.NumFields()))),
 			)
 			if len(methods) > 0 {
@@ -418,13 +421,15 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				c.getTypeCode(typ.Elem()),                              // elementType
 				llvm.ConstInt(c.uintptrType, uint64(typ.Len()), false), // length
 				c.getTypeCode(types.NewSlice(typ.Elem())),              // slicePtr
+				c.createObjectLayout(c.getLLVMType(typ), token.NoPos),  // layout
 			}
 		case *types.Map:
 			typeFields = []llvm.Value{
 				llvm.ConstInt(c.ctx.Int16Type(), 0, false), // numMethods
 				c.getTypeCode(types.NewPointer(typ)),       // ptrTo
 				c.getTypeCode(typ.Elem()),                  // elem
 				c.getTypeCode(typ.Key()),                   // key
+				c.getHashmapTypeInfo(typ, token.NoPos),     // hashmapTypeInfo
 			}
 		case *types.Struct:
 			var pkgpath string
@@ -450,6 +455,7 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				pkgPathPtr,
 				llvm.ConstInt(c.ctx.Int32Type(), uint64(size), false),            // size
 				llvm.ConstInt(c.ctx.Int16Type(), uint64(typ.NumFields()), false), // numFields
+				c.createObjectLayout(llvmStructType, token.NoPos),                // layout
 			}
 			structFieldType := c.getLLVMRuntimeType("structField")
 
@@ -510,7 +516,7 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
 			// TODO: params, return values, etc
 		}
-		// Prepend metadata byte.
+		// Prepend the common RawType field.
 		typeFields = append([]llvm.Value{
 			llvm.ConstInt(c.ctx.Int8Type(), uint64(metabyte), false),
 		}, typeFields...)

compiler/map.go

@@ -13,6 +13,12 @@ import (
 
 const hashArrayUnrollLimit = 4
 
+const (
+	hashmapBucketSlots  = 8
+	hashmapMaxKeySize   = 128
+	hashmapMaxValueSize = 128
+)
+
 // createMakeMap creates a new map object (runtime.hashmap) by allocating and
 // initializing an appropriately sized object.
 func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
@@ -25,6 +31,8 @@ func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
 	valueSize := b.targetData.TypeAllocSize(llvmValueType)
 	llvmKeySize := llvm.ConstInt(b.uintptrType, keySize, false)
 	llvmValueSize := llvm.ConstInt(b.uintptrType, valueSize, false)
+	mapLayout := b.getHashmapTypeInfo(mapType, expr.Pos())
+
 	sizeHint := llvm.ConstInt(b.uintptrType, 8, false)
 	if expr.Reserve != nil {
 		sizeHint = b.getValue(expr.Reserve, getPos(expr))
@@ -54,11 +62,72 @@ func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
 
 	hashmap := b.createRuntimeCall("hashmapMakeGeneric", []llvm.Value{
 		llvmKeySize, llvmValueSize, sizeHint,
+		mapLayout,
 		hashFn, equalFn,
 	}, "")
 	return hashmap, nil
 }
 
+func (c *compilerContext) getHashmapTypeInfo(mapType *types.Map, pos token.Pos) llvm.Value {
+	llvmKeyType := c.getLLVMType(mapType.Key().Underlying())
+	llvmValueType := c.getLLVMType(mapType.Elem().Underlying())
+	keySize := c.targetData.TypeAllocSize(llvmKeyType)
+	valueSize := c.targetData.TypeAllocSize(llvmValueType)
+	keyLayout := c.createObjectLayout(llvmKeyType, pos)
+	valueLayout := c.createObjectLayout(llvmValueType, pos)
+
+	llvmKeySlotType := llvmKeyType
+	if keySize > hashmapMaxKeySize {
+		llvmKeySlotType = c.dataPtrType
+	}
+	llvmValueSlotType := llvmValueType
+	if valueSize > hashmapMaxValueSize {
+		llvmValueSlotType = c.dataPtrType
+	}
+
+	// Keep this in sync with runtime.hashmapBucket and
+	// runtime.hashmapBucketHeaderSize.
+	pointerSize := c.targetData.TypeAllocSize(c.dataPtrType)
+	headerSize := (uint64(8) + pointerSize + 7) &^ 7
+	headerPadding := headerSize - uint64(8) - pointerSize
+	bucketFields := []llvm.Type{
+		llvm.ArrayType(c.ctx.Int8Type(), hashmapBucketSlots),
+		c.dataPtrType,
+	}
+	if headerPadding != 0 {
+		bucketFields = append(bucketFields, llvm.ArrayType(c.ctx.Int8Type(), int(headerPadding)))
+	}
+	bucketFields = append(bucketFields,
+		llvm.ArrayType(llvmKeySlotType, hashmapBucketSlots),
+		llvm.ArrayType(llvmValueSlotType, hashmapBucketSlots),
+	)
+	bucketType := c.ctx.StructType(bucketFields, true)
+	bucketSize := headerSize +
+		c.targetData.TypeAllocSize(llvmKeySlotType)*hashmapBucketSlots +
+		c.targetData.TypeAllocSize(llvmValueSlotType)*hashmapBucketSlots
+	if c.targetData.TypeAllocSize(bucketType) != bucketSize {
+		panic("compiler hashmap bucket layout does not match runtime")
+	}
+	bucketLayout := c.createObjectLayout(bucketType, pos)
+	mapLayoutName := "runtime.hashmapType:" +
+		hashmapCanonicalTypeName(mapType.Key()) + ":" +
+		hashmapCanonicalTypeName(mapType.Elem())
+	mapLayout := c.mod.NamedGlobal(mapLayoutName)
+	if mapLayout.IsNil() {
+		initializer := c.ctx.ConstStruct([]llvm.Value{
+			keyLayout,
+			valueLayout,
+			bucketLayout,
+		}, false)
+		mapLayout = llvm.AddGlobal(c.mod, initializer.Type(), mapLayoutName)
+		mapLayout.SetInitializer(initializer)
+		mapLayout.SetGlobalConstant(true)
+		mapLayout.SetUnnamedAddr(true)
+		mapLayout.SetLinkage(llvm.LinkOnceODRLinkage)
+	}
+	return mapLayout
+}
+
 // getRuntimeFunctionValue returns a TinyGo function value (with nil context)
 // for the named runtime function.
 func (b *builder) getRuntimeFunctionValue(name string, sig *types.Signature) llvm.Value {

compiler/testdata/go1.21.ll

@@ -166,13 +166,13 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.clearMap(ptr dereferenceable_or_null(48) %m, ptr %context) unnamed_addr #1 {
+define hidden void @main.clearMap(ptr dereferenceable_or_null(52) %m, ptr %context) unnamed_addr #1 {
 entry:
   call void @runtime.hashmapClear(ptr %m, ptr undef) #4
   ret void
 }
 
-declare void @runtime.hashmapClear(ptr dereferenceable_or_null(48), ptr) #0
+declare void @runtime.hashmapClear(ptr dereferenceable_or_null(52), ptr) #0
 
 attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
 attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }

compiler/testdata/go1.27.ll

@@ -14,7 +14,7 @@ target triple = "wasm32-unknown-wasi"
 @"main$string" = internal unnamed_addr constant [18 x i8] c"main.genericMethod", align 1
 @"main$string.1" = internal unnamed_addr constant [7 x i8] c"Regular", align 1
 @"pointer:named:main.genericMethod$methodset" = linkonce_odr unnamed_addr constant { i32, [1 x ptr], { ptr } } { i32 1, [1 x ptr] [ptr @"reflect/methods.Regular:func:{basic:int}{basic:int}"], { ptr } { ptr @"(*main.genericMethod).Regular" } }
-@"reflect/types.type:struct:{}" = linkonce_odr constant { i8, i16, ptr, ptr, i32, i16, [0 x %runtime.structField] } { i8 90, i16 0, ptr @"reflect/types.type:pointer:struct:{}", ptr @"reflect/types.type.pkgpath.empty", i32 0, i16 0, [0 x %runtime.structField] zeroinitializer }, align 4
+@"reflect/types.type:struct:{}" = linkonce_odr constant { i8, i16, ptr, ptr, i32, i16, ptr, [0 x %runtime.structField] } { i8 90, i16 0, ptr @"reflect/types.type:pointer:struct:{}", ptr @"reflect/types.type.pkgpath.empty", i32 0, i16 0, ptr inttoptr (i32 3 to ptr), [0 x %runtime.structField] zeroinitializer }, align 4
 @"reflect/types.type.pkgpath.empty" = linkonce_odr unnamed_addr constant [1 x i8] zeroinitializer, align 1
 @"reflect/types.type:pointer:struct:{}" = linkonce_odr constant { i8, i16, ptr } { i8 -43, i16 0, ptr @"reflect/types.type:struct:{}" }, align 4
 @"named:main.genericMethod$methodset" = linkonce_odr unnamed_addr constant { i32, [1 x ptr], { ptr } } { i32 1, [1 x ptr] [ptr @"reflect/methods.Regular:func:{basic:int}{basic:int}"], { ptr } { ptr @"(main.genericMethod).Regular$invoke" } }

compiler/testdata/large.ll

@@ -9,6 +9,7 @@ target triple = "wasm32-unknown-wasi"
 
 @"runtime/gc.layout:258-000000000000000000000000000000000000000000000000000000000000000002" = linkonce_odr unnamed_addr constant { i32, [33 x i8] } { i32 258, [33 x i8] c"\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\02" }
 @"reflect/types.typeid:named:main.largeValue" = external constant i8
+@"runtime.hashmapType:[1025]byte:[1025]byte" = linkonce_odr unnamed_addr constant { ptr, ptr, ptr } { ptr inttoptr (i32 3 to ptr), ptr inttoptr (i32 3 to ptr), ptr inttoptr (i32 67108137 to ptr) }
 @llvm.used = appending global [15 x ptr] [ptr @"(main.largeReceiver).makeLargeValue", ptr @"(main.largeReceiver).readLargeValue", ptr @main.makeLargeValue, ptr @main.makeZeroLargeValue, ptr @main.readLargeValue, ptr @main.deferLargeValue, ptr @main.goLargeValue, ptr @main.makeLargeResults, ptr @main.makeTwoLargeResults, ptr @main.makeMixedLargeResults, ptr @main.chooseLargeValue, ptr @main.makePointerLargeValue, ptr @main.useLargeMap, ptr @main.useLargeChannel, ptr @main.selectLargeChannel]
 @"main$string" = internal unnamed_addr constant [31 x i8] c"blocking select matched no case", align 1
 @"main$pack" = internal unnamed_addr constant { %runtime._string } { %runtime._string { ptr @"main$string", i32 31 } }
@@ -350,7 +351,7 @@ declare void @llvm.memset.p0.i32(ptr writeonly captures(none), i8, i32, i1 immar
 define hidden i8 @main.useLargeMap(ptr readonly dereferenceable_or_null(1025) %key, ptr readonly dereferenceable_or_null(1025) %value, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call ptr @runtime.hashmapMakeGeneric(i32 1025, i32 1025, i32 1, ptr null, ptr nonnull @runtime.hash32, ptr null, ptr nonnull @runtime.memequal, ptr undef) #9
+  %0 = call ptr @runtime.hashmapMakeGeneric(i32 1025, i32 1025, i32 1, ptr nonnull @"runtime.hashmapType:[1025]byte:[1025]byte", ptr null, ptr nonnull @runtime.hash32, ptr null, ptr nonnull @runtime.memequal, ptr undef) #9
   call void @runtime.trackPointer(ptr %0, ptr nonnull %stackalloc, ptr undef) #9
   call void @runtime.hashmapBinarySet(ptr %0, ptr %key, ptr %value, ptr undef) #9
   %result = call align 1 dereferenceable(1025) ptr @runtime.alloc(i32 1025, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #9
@@ -381,11 +382,11 @@ declare i32 @runtime.hash32(ptr, i32, i32, ptr) #0
 
 declare i1 @runtime.memequal(ptr, ptr, i32, ptr) #0
 
-declare ptr @runtime.hashmapMakeGeneric(i32, i32, i32, ptr, ptr, ptr, ptr, ptr) #0
+declare ptr @runtime.hashmapMakeGeneric(i32, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr) #0
 
-declare void @runtime.hashmapBinarySet(ptr dereferenceable_or_null(48), ptr, ptr, ptr) #0
+declare void @runtime.hashmapBinarySet(ptr dereferenceable_or_null(52), ptr, ptr, ptr) #0
 
-declare i1 @runtime.hashmapBinaryGet(ptr dereferenceable_or_null(48), ptr, ptr, i32, ptr) #0
+declare i1 @runtime.hashmapBinaryGet(ptr dereferenceable_or_null(52), ptr, ptr, i32, ptr) #0
 
 ; Function Attrs: nounwind
 define hidden i8 @main.useLargeChannel(ptr dereferenceable_or_null(36) %ch, ptr readonly dereferenceable_or_null(1025) %value, ptr %context) unnamed_addr #1 {

compiler/testdata/zeromap.ll

@@ -14,7 +14,7 @@ entry:
 }
 
 ; Function Attrs: noinline nounwind
-define hidden i32 @main.testZeroGet(ptr dereferenceable_or_null(48) %m, i1 %s.b1, i32 %s.i, i1 %s.b2, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.testZeroGet(ptr dereferenceable_or_null(52) %m, i1 %s.b1, i32 %s.i, i1 %s.b2, ptr %context) unnamed_addr #2 {
 entry:
   %hashmap.key = alloca %main.hasPadding, align 8
   %hashmap.value = alloca i32, align 4
@@ -34,13 +34,13 @@ entry:
 ; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
 declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #3
 
-declare i1 @runtime.hashmapGenericGet(ptr dereferenceable_or_null(48), ptr nocapture, ptr nocapture, i32, ptr) #0
+declare i1 @runtime.hashmapGenericGet(ptr dereferenceable_or_null(52), ptr nocapture, ptr nocapture, i32, ptr) #0
 
 ; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
 declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #3
 
 ; Function Attrs: noinline nounwind
-define hidden void @main.testZeroSet(ptr dereferenceable_or_null(48) %m, i1 %s.b1, i32 %s.i, i1 %s.b2, ptr %context) unnamed_addr #2 {
+define hidden void @main.testZeroSet(ptr dereferenceable_or_null(52) %m, i1 %s.b1, i32 %s.i, i1 %s.b2, ptr %context) unnamed_addr #2 {
 entry:
   %hashmap.key = alloca %main.hasPadding, align 8
   %hashmap.value = alloca i32, align 4
@@ -57,10 +57,10 @@ entry:
   ret void
 }
 
-declare void @runtime.hashmapGenericSet(ptr dereferenceable_or_null(48), ptr nocapture, ptr nocapture, ptr) #0
+declare void @runtime.hashmapGenericSet(ptr dereferenceable_or_null(52), ptr nocapture, ptr nocapture, ptr) #0
 
 ; Function Attrs: noinline nounwind
-define hidden i32 @main.testZeroArrayGet(ptr dereferenceable_or_null(48) %m, [2 x %main.hasPadding] %s, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.testZeroArrayGet(ptr dereferenceable_or_null(52) %m, [2 x %main.hasPadding] %s, ptr %context) unnamed_addr #2 {
 entry:
   %hashmap.key = alloca [2 x %main.hasPadding], align 8
   %hashmap.value = alloca i32, align 4
@@ -79,7 +79,7 @@ entry:
 }
 
 ; Function Attrs: noinline nounwind
-define hidden void @main.testZeroArraySet(ptr dereferenceable_or_null(48) %m, [2 x %main.hasPadding] %s, ptr %context) unnamed_addr #2 {
+define hidden void @main.testZeroArraySet(ptr dereferenceable_or_null(52) %m, [2 x %main.hasPadding] %s, ptr %context) unnamed_addr #2 {
 entry:
   %hashmap.key = alloca [2 x %main.hasPadding], align 8
   %hashmap.value = alloca i32, align 4

interp/memory.go

@@ -1278,11 +1278,10 @@ func (r *runner) readObjectLayout(layoutValue value) (uint64, *big.Int) {
 	// integer value, or can be nil.
 	ptr, err := layoutValue.asPointer(r)
 	if err == errIntegerAsPointer {
-		// It's an integer, which means it's a small object or unknown.
+		// It's an integer, which means it's a small object.
 		layout := layoutValue.Uint(r)
 		if layout == 0 {
-			// Nil pointer, which means the layout is unknown.
-			return 0, nil
+			panic("runtime.alloc called without a GC layout")
 		}
 		if layout%2 != 1 {
 			// Sanity check: the least significant bit must be set. This is how
@@ -1331,11 +1330,6 @@ func (r *runner) readObjectLayout(layoutValue value) (uint64, *big.Int) {
 // have some additional repetition, for example in the buffer of a slice.
 func (r *runner) getLLVMTypeFromLayout(layoutValue value) llvm.Type {
 	objectSizeWords, bitmap := r.readObjectLayout(layoutValue)
-	if bitmap == nil {
-		// No information available.
-		return llvm.Type{}
-	}
-
 	if bitmap.BitLen() == 0 {
 		// There are no pointers in this object, so treat this as a raw byte
 		// buffer. This is important because objects without pointers may have

interp/testdata/alloc.ll

@@ -11,6 +11,7 @@ target triple = "wasm32--wasi"
 @layout3 = global ptr null
 @layout4 = global ptr null
 @bigobj1 = global ptr null
+@pointerFree10 = global ptr null
 
 declare ptr @runtime.alloc(i32, ptr) unnamed_addr
 
@@ -49,5 +50,9 @@ define internal void @main.init() unnamed_addr {
   ; Large object that needs to be stored in a separate global.
   %bigobj1 = call ptr @runtime.alloc(i32 248, ptr @"runtime/gc.layout:62-2000000000000001")
   store ptr %bigobj1, ptr @bigobj1
+
+  ; Another pointer-free object.
+  %pointerFree10 = call ptr @runtime.alloc(i32 10, ptr inttoptr (i32 3 to ptr))
+  store ptr %pointerFree10, ptr @pointerFree10
   ret void
 }