ssa: makeSlice both len/cap be non-nil

internal/runtime/goarch/goarch.go

@@ -0,0 +1,3 @@
+package goarch
+
+const PtrSize = 4 << (^uintptr(0) >> 63)

internal/runtime/math/math.go

@@ -0,0 +1,15 @@
+package math
+
+import "github.com/goplus/llgo/internal/runtime/goarch"
+
+const MaxUintptr = ^uintptr(0)
+
+// MulUintptr returns a * b and whether the multiplication overflowed.
+// On supported platforms this is an intrinsic lowered by the compiler.
+func MulUintptr(a, b uintptr) (uintptr, bool) {
+	if a|b < 1<<(4*goarch.PtrSize) || a == 0 {
+		return a * b, false
+	}
+	overflow := b > MaxUintptr/a
+	return a * b, overflow
+}

internal/runtime/stubs.go

@@ -36,3 +36,10 @@ func fastrand() uint32 {
 	return s0 + s1
 }
 */
+
+const (
+	// _64bit = 1 on 64-bit systems, 0 on 32-bit systems
+	_64bit       = 1 << (^uintptr(0) >> 63) / 2
+	heapAddrBits = (_64bit)*48 + (1-_64bit)*(32)
+	maxAlloc     = (1 << heapAddrBits) - (1-_64bit)*1
+)

internal/runtime/z_slice.go

@@ -20,6 +20,7 @@ import (
 	"unsafe"
 
 	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/internal/runtime/math"
 )
 
 // -----------------------------------------------------------------------------
@@ -120,32 +121,10 @@ func SliceCopy(dst Slice, data unsafe.Pointer, num int, etSize int) int {
 	return n
 }
 
-const (
-	// _64bit = 1 on 64-bit systems, 0 on 32-bit systems
-	_64bit       = 1 << (^uintptr(0) >> 63) / 2
-	heapAddrBits = (_64bit)*48 + (1-_64bit)*(32)
-	maxAlloc     = (1 << heapAddrBits) - (1-_64bit)*1
-)
-
-const (
-	PtrSize    = 4 << (^uintptr(0) >> 63)
-	MaxUintptr = ^uintptr(0)
-)
-
-// MulUintptr returns a * b and whether the multiplication overflowed.
-// On supported platforms this is an intrinsic lowered by the compiler.
-func MulUintptr(a, b uintptr) (uintptr, bool) {
-	if a|b < 1<<(4*PtrSize) || a == 0 {
-		return a * b, false
-	}
-	overflow := b > MaxUintptr/a
-	return a * b, overflow
-}
-
 func MakeSlice(len, cap int, etSize int) Slice {
-	mem, overflow := MulUintptr(uintptr(etSize), uintptr(cap))
+	mem, overflow := math.MulUintptr(uintptr(etSize), uintptr(cap))
 	if overflow || mem > maxAlloc || len < 0 || len > cap {
-		mem, overflow := MulUintptr(uintptr(etSize), uintptr(len))
+		mem, overflow := math.MulUintptr(uintptr(etSize), uintptr(len))
 		if overflow || mem > maxAlloc || len < 0 {
 			panicmakeslicelen()
 		}