refactor reflect.SliceHeader uses to allow tinygo cross-compilation

internal/engine/wazevo/backend/isa/amd64/reflect.go

@@ -0,0 +1,11 @@
+//go:build !tinygo
+
+package amd64
+
+import "reflect"
+
+// setSliceLimits sets both Cap and Len for the given reflected slice.
+func setSliceLimits(s *reflect.SliceHeader, limit uintptr) {
+	s.Len = int(limit)
+	s.Cap = int(limit)
+}

internal/engine/wazevo/backend/isa/amd64/reflect_tinygo.go

@@ -0,0 +1,11 @@
+//go:build tinygo
+
+package amd64
+
+import "reflect"
+
+// setSliceLimits sets both Cap and Len for the given reflected slice.
+func setSliceLimits(s *reflect.SliceHeader, limit uintptr) {
+	s.Len = limit
+	s.Len = limit
+}

internal/engine/wazevo/backend/isa/amd64/stack.go

@@ -9,14 +9,12 @@ import (
 )
 
 func stackView(rbp, top uintptr) []byte {
-	l := int(top - rbp)
 	var stackBuf []byte
 	{
 		// TODO: use unsafe.Slice after floor version is set to Go 1.20.
 		hdr := (*reflect.SliceHeader)(unsafe.Pointer(&stackBuf))
 		hdr.Data = rbp
-		hdr.Len = l
-		hdr.Cap = l
+		setSliceLimits(hdr, top-rbp)
 	}
 	return stackBuf
 }
@@ -74,15 +72,9 @@ func GoCallStackView(stackPointerBeforeGoCall *uint64) []uint64 {
 	//              |   SizeInBytes   |
 	//              +-----------------+ <---- stackPointerBeforeGoCall
 	//                 (low address)
+	data := unsafe.Pointer(uintptr(unsafe.Pointer(stackPointerBeforeGoCall)) + 8)
 	size := *stackPointerBeforeGoCall / 8
-	var view []uint64
-	{
-		sh := (*reflect.SliceHeader)(unsafe.Pointer(&view))
-		sh.Data = uintptr(unsafe.Pointer(stackPointerBeforeGoCall)) + 8 // skips the(sliceSize.
-		sh.Len = int(size)
-		sh.Cap = int(size)
-	}
-	return view
+	return unsafe.Slice((*uint64)(data), int(size))
 }
 
 func AdjustClonedStack(oldRsp, oldTop, rsp, rbp, top uintptr) {

internal/engine/wazevo/call_engine.go

@@ -528,8 +528,7 @@ func opaqueViewFromPtr(ptr uintptr) []byte {
 	var opaque []byte
 	sh := (*reflect.SliceHeader)(unsafe.Pointer(&opaque))
 	sh.Data = ptr
-	sh.Len = 24
-	sh.Cap = 24
+	setSliceLimits(sh, 24, 24)
 	return opaque
 }
 
@@ -574,17 +573,15 @@ func (c *callEngine) cloneStack(l uintptr) (newSP, newFP, newTop uintptr, newSta
 	{
 		sh := (*reflect.SliceHeader)(unsafe.Pointer(&prevStackAligned))
 		sh.Data = c.stackTop - relSp
-		sh.Len = int(relSp)
-		sh.Cap = int(relSp)
+		setSliceLimits(sh, relSp, relSp)
 	}
 	newTop = alignedStackTop(newStack)
 	{
 		newSP = newTop - relSp
 		newFP = newTop - relFp
 		sh := (*reflect.SliceHeader)(unsafe.Pointer(&newStackAligned))
 		sh.Data = newSP
-		sh.Len = int(relSp)
-		sh.Cap = int(relSp)
+		setSliceLimits(sh, relSp, relSp)
 	}
 	copy(newStackAligned, prevStackAligned)
 	return

internal/engine/wazevo/hostmodule.go

@@ -53,8 +53,7 @@ func hostModuleListenersSliceFromOpaque(opaqueBegin uintptr) []experimental.Func
 	var ret []experimental.FunctionListener
 	sh = (*reflect.SliceHeader)(unsafe.Pointer(&ret))
 	sh.Data = uintptr(b)
-	sh.Len = int(l)
-	sh.Cap = int(c)
+	setSliceLimits(sh, uintptr(l), uintptr(c))
 	return ret
 }
 

internal/engine/wazevo/reflect.go

@@ -0,0 +1,11 @@
+//go:build !tinygo
+
+package wazevo
+
+import "reflect"
+
+// setSliceLimits sets both Cap and Len for the given reflected slice.
+func setSliceLimits(s *reflect.SliceHeader, l, c uintptr) {
+	s.Len = int(l)
+	s.Cap = int(c)
+}

internal/engine/wazevo/reflect_tinygo.go

@@ -0,0 +1,11 @@
+//go:build tinygo
+
+package wazevo
+
+import "reflect"
+
+// setSliceLimits sets both Cap and Len for the given reflected slice.
+func setSliceLimits(s *reflect.SliceHeader, l, c uintptr) {
+	s.Len = l
+	s.Cap = c
+}

internal/wasm/memory.go

@@ -266,12 +266,12 @@ func (m *MemoryInstance) Grow(delta uint32) (result uint32, ok bool) {
 		m.Cap = newPages
 		return currentPages, true
 	} else { // We already have the capacity we need.
-		sp := (*reflect.SliceHeader)(unsafe.Pointer(&m.Buffer))
 		if m.Shared {
+			sp := (*reflect.SliceHeader)(unsafe.Pointer(&m.Buffer))
 			// Use atomic write to ensure new length is visible across threads.
 			atomic.StoreUintptr((*uintptr)(unsafe.Pointer(&sp.Len)), uintptr(MemoryPagesToBytesNum(newPages)))
 		} else {
-			sp.Len = int(MemoryPagesToBytesNum(newPages))
+			m.Buffer = m.Buffer[:MemoryPagesToBytesNum(newPages)]
 		}
 		return currentPages, true
 	}