compiler, runtime: add layout parameter to runtime.alloc

This layout parameter is currently always nil and ignored, but will
eventually contain a pointer to a memory layout.

This commit also adds module verification to the transform tests, as I
found out that it didn't (and therefore didn't initially catch all
bugs).

src/runtime/arch_tinygowasm.go

@@ -66,7 +66,7 @@ func growHeap() bool {
 
 //export malloc
 func libc_malloc(size uintptr) unsafe.Pointer {
-	return alloc(size)
+	return alloc(size, nil)
 }
 
 //export free
@@ -79,7 +79,7 @@ func libc_calloc(nmemb, size uintptr) unsafe.Pointer {
 	// Note: we could be even more correct here and check that nmemb * size
 	// doesn't overflow. However the current implementation should normally work
 	// fine.
-	return alloc(nmemb * size)
+	return alloc(nmemb*size, nil)
 }
 
 //export realloc

src/runtime/baremetal.go

@@ -38,7 +38,7 @@ func growHeap() bool {
 
 //export malloc
 func libc_malloc(size uintptr) unsafe.Pointer {
-	return alloc(size)
+	return alloc(size, nil)
 }
 
 //export free

src/runtime/chan.go

@@ -133,7 +133,7 @@ func chanMake(elementSize uintptr, bufSize uintptr) *channel {
 	return &channel{
 		elementSize: elementSize,
 		bufSize:     bufSize,
-		buf:         alloc(elementSize * bufSize),
+		buf:         alloc(elementSize*bufSize, nil),
 	}
 }
 

src/runtime/gc_conservative.go

@@ -263,7 +263,7 @@ func calculateHeapAddresses() {
 // alloc 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 alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer {
 	if size == 0 {
 		return unsafe.Pointer(&zeroSizedAlloc)
 	}

src/runtime/gc_extalloc.go

@@ -527,7 +527,7 @@ var zeroSizedAlloc uint8
 // alloc 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 alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer {
 	if size == 0 {
 		return unsafe.Pointer(&zeroSizedAlloc)
 	}

src/runtime/gc_leaking.go

@@ -13,7 +13,7 @@ import (
 // Ever-incrementing pointer: no memory is freed.
 var heapptr = heapStart
 
-func alloc(size uintptr) unsafe.Pointer {
+func alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer {
 	// TODO: this can be optimized by not casting between pointers and ints so
 	// much. And by using platform-native data types (e.g. *uint8 for 8-bit
 	// systems).

src/runtime/gc_none.go

@@ -10,7 +10,7 @@ import (
 	"unsafe"
 )
 
-func alloc(size uintptr) unsafe.Pointer
+func alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer
 
 func free(ptr unsafe.Pointer) {
 	// Nothing to free when nothing gets allocated.

src/runtime/hashmap.go

@@ -69,7 +69,7 @@ func hashmapMake(keySize, valueSize uint8, sizeHint uintptr) *hashmap {
 		bucketBits++
 	}
 	bucketBufSize := unsafe.Sizeof(hashmapBucket{}) + uintptr(keySize)*8 + uintptr(valueSize)*8
-	buckets := alloc(bucketBufSize * (1 << bucketBits))
+	buckets := alloc(bucketBufSize*(1<<bucketBits), nil)
 	return &hashmap{
 		buckets:    buckets,
 		keySize:    keySize,
@@ -157,7 +157,7 @@ func hashmapSet(m *hashmap, key unsafe.Pointer, value unsafe.Pointer, hash uint3
 // value into the bucket, and returns a pointer to this bucket.
 func hashmapInsertIntoNewBucket(m *hashmap, key, value unsafe.Pointer, tophash uint8) *hashmapBucket {
 	bucketBufSize := unsafe.Sizeof(hashmapBucket{}) + uintptr(m.keySize)*8 + uintptr(m.valueSize)*8
-	bucketBuf := alloc(bucketBufSize)
+	bucketBuf := alloc(bucketBufSize, nil)
 	// Insert into the first slot, which is empty as it has just been allocated.
 	slotKeyOffset := unsafe.Sizeof(hashmapBucket{})
 	slotKey := unsafe.Pointer(uintptr(bucketBuf) + slotKeyOffset)

src/runtime/slice.go

@@ -27,7 +27,7 @@ func sliceAppend(srcBuf, elemsBuf unsafe.Pointer, srcLen, srcCap, elemsLen uintp
 			// programs).
 			srcCap *= 2
 		}
-		buf := alloc(srcCap * elemSize)
+		buf := alloc(srcCap*elemSize, nil)
 
 		// Copy the old slice to the new slice.
 		if srcLen != 0 {

src/runtime/string.go

@@ -57,7 +57,7 @@ func stringConcat(x, y _string) _string {
 		return x
 	} else {
 		length := x.length + y.length
-		buf := alloc(length)
+		buf := alloc(length, nil)
 		memcpy(buf, unsafe.Pointer(x.ptr), x.length)
 		memcpy(unsafe.Pointer(uintptr(buf)+x.length), unsafe.Pointer(y.ptr), y.length)
 		return _string{ptr: (*byte)(buf), length: length}
@@ -70,7 +70,7 @@ func stringFromBytes(x struct {
 	len uintptr
 	cap uintptr
 }) _string {
-	buf := alloc(x.len)
+	buf := alloc(x.len, nil)
 	memcpy(buf, unsafe.Pointer(x.ptr), x.len)
 	return _string{ptr: (*byte)(buf), length: x.len}
 }
@@ -81,7 +81,7 @@ func stringToBytes(x _string) (slice struct {
 	len uintptr
 	cap uintptr
 }) {
-	buf := alloc(x.length)
+	buf := alloc(x.length, nil)
 	memcpy(buf, unsafe.Pointer(x.ptr), x.length)
 	slice.ptr = (*byte)(buf)
 	slice.len = x.length
@@ -98,7 +98,7 @@ func stringFromRunes(runeSlice []rune) (s _string) {
 	}
 
 	// Allocate memory for the string.
-	s.ptr = (*byte)(alloc(s.length))
+	s.ptr = (*byte)(alloc(s.length, nil))
 
 	// Encode runes to UTF-8 and store the resulting bytes in the string.
 	index := uintptr(0)