@grain/stdlib 0.4.4 → 0.5.0

package/runtime/gc.gr

@@ -25,23 +25,38 @@ import WasmI32, {
   sub as (-),
   mul as (*),
   and as (&),
-  eq as (==)
+  eq as (==),
 } from "runtime/unsafe/wasmi32"
 
 // Using foreigns directly here to avoid cyclic dependency
-import foreign wasm fd_write : (WasmI32, WasmI32, WasmI32, WasmI32) -> WasmI32 from "wasi_snapshot_preview1"
+import foreign wasm fd_write: (
+  WasmI32,
+  WasmI32,
+  WasmI32,
+  WasmI32,
+) -> WasmI32 from "wasi_snapshot_preview1"
 
-primitive (&&) : (Bool, Bool) -> Bool = "@and"
-primitive (||) : (Bool, Bool) -> Bool = "@or"
-primitive throw : Exception -> a = "@throw"
-primitive ignore : a -> Void = "@ignore"
-primitive box : a -> Box<a> = "@box"
-primitive unbox : Box<a> -> a = "@unbox"
+primitive (&&): (Bool, Bool) -> Bool = "@and"
+primitive (||): (Bool, Bool) -> Bool = "@or"
+primitive throw: Exception -> a = "@throw"
+primitive ignore: a -> Void = "@ignore"
+primitive box: a -> Box<a> = "@box"
+primitive unbox: Box<a> -> a = "@unbox"
 
 exception DecRefError
 
-export let decimalCount32 = box((n: WasmI32) => 0n)
-export let utoa32Buffered = box((a: WasmI32, b: WasmI32, c: WasmI32) => void)
+let decimalCount32Dummy = (n: WasmI32) => 0n
+let utoa32BufferedDummy = (a: WasmI32, b: WasmI32, c: WasmI32) => void
+
+// When these boxes are backpatched, the reference count of each function will
+// fall to zero which would cause them to be freed. We can't free anything that
+// got allocated in runtime mode (since that memory space is not managed by the
+// GC, so here we prevent that by manually setting a higher refcount.
+WasmI32.store(WasmI32.fromGrain(decimalCount32Dummy) - 8n, 2n, 0n)
+WasmI32.store(WasmI32.fromGrain(utoa32BufferedDummy) - 8n, 2n, 0n)
+
+export let decimalCount32 = box(decimalCount32Dummy)
+export let utoa32Buffered = box(utoa32BufferedDummy)
 
 let mut _DEBUG = false
 
@@ -154,7 +169,10 @@ export let free = (userPtr: WasmI32) => {
 }
 
 export let incRef = (userPtr: WasmI32) => {
-  if (WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) && WasmI32.ne(userPtr, 0n)) {
+  if (
+    WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) &&
+    WasmI32.ne(userPtr, 0n)
+  ) {
     // if (_DEBUG) {
     //   logIncRef(userPtr, getRefCount(userPtr))
     //   void;
@@ -165,7 +183,10 @@ export let incRef = (userPtr: WasmI32) => {
 }
 
 let rec decRef = (userPtr: WasmI32, ignoreZeros: Bool) => {
-  if (WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) && WasmI32.ne(userPtr, 0n)) {
+  if (
+    WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) &&
+    WasmI32.ne(userPtr, 0n)
+  ) {
     let refCount = getRefCount(userPtr)
     // if (_DEBUG) {
     //   logDecRef(userPtr, refCount, ignoreZeros)
@@ -194,43 +215,52 @@ let rec decRef = (userPtr: WasmI32, ignoreZeros: Bool) => {
   }
 }, decRefChildren = (userPtr: WasmI32) => {
   match (WasmI32.load(userPtr, 0n)) {
+    t when t == Tags._GRAIN_BOXED_NUM_HEAP_TAG => {
+      let tag = WasmI32.load(userPtr, 4n)
+      if (userPtr == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG) {
+        // decRef underlying BigInts
+        ignore(decRef(WasmI32.load(userPtr, 8n), false))
+        ignore(decRef(WasmI32.load(userPtr, 12n), false))
+      }
+    },
     t when t == Tags._GRAIN_ADT_HEAP_TAG => {
       let arity = WasmI32.load(userPtr, 16n)
       let maxOffset = arity * 4n
-      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i = i + 4n) {
+      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i += 4n) {
         ignore(decRef(WasmI32.load(userPtr + i, 20n), false))
       }
     },
     t when t == Tags._GRAIN_RECORD_HEAP_TAG => {
       let arity = WasmI32.load(userPtr, 12n)
       let maxOffset = arity * 4n
-      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i = i + 4n) {
+      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i += 4n) {
         ignore(decRef(WasmI32.load(userPtr + i, 16n), false))
       }
     },
-    t when t == Tags._GRAIN_ARRAY_HEAP_TAG || t == Tags._GRAIN_TUPLE_HEAP_TAG => {
+    t when (
+      t == Tags._GRAIN_ARRAY_HEAP_TAG || t == Tags._GRAIN_TUPLE_HEAP_TAG
+    ) => {
       let arity = WasmI32.load(userPtr, 4n)
       let maxOffset = arity * 4n
-      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i = i + 4n) {
+      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i += 4n) {
         ignore(decRef(WasmI32.load(userPtr + i, 8n), false))
       }
     },
     t when t == Tags._GRAIN_LAMBDA_HEAP_TAG => {
       let arity = WasmI32.load(userPtr, 12n)
       let maxOffset = arity * 4n
-      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i = i + 4n) {
+      for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i += 4n) {
         ignore(decRef(WasmI32.load(userPtr + i, 16n), false))
       }
     },
     _ => {
       // No travelsal necessary for other tags
       void
-    }
+    },
   }
 }
 
-export let decRefIgnoreZeros = (userPtr) => decRef(userPtr, true)
-export let decRef = (userPtr) => decRef(userPtr, false)
+export let decRef = userPtr => decRef(userPtr, false)
 
 // For debugging:
 

package/runtime/gc.md

@@ -0,0 +1,36 @@
+### Gc.**decimalCount32**
+
+```grain
+decimalCount32 : Box<WasmI32 -> WasmI32>
+```
+
+### Gc.**utoa32Buffered**
+
+```grain
+utoa32Buffered : Box<(WasmI32, WasmI32, WasmI32) -> Void>
+```
+
+### Gc.**malloc**
+
+```grain
+malloc : WasmI32 -> WasmI32
+```
+
+### Gc.**free**
+
+```grain
+free : WasmI32 -> Void
+```
+
+### Gc.**incRef**
+
+```grain
+incRef : WasmI32 -> WasmI32
+```
+
+### Gc.**decRef**
+
+```grain
+decRef : WasmI32 -> WasmI32
+```
+

package/runtime/malloc.gr

@@ -17,18 +17,20 @@ import WasmI32, {
   shl as (<<),
   shrU as (>>),
   eq as (==),
-  ne as (!=)
+  ne as (!=),
 } from "runtime/unsafe/wasmi32"
 import Exception from "runtime/exception"
 
 primitive memorySize: () -> WasmI32 = "@wasm.memory_size"
-primitive memoryGrow: (WasmI32) -> WasmI32 = "@wasm.memory_grow"
+primitive memoryGrow: WasmI32 -> WasmI32 = "@wasm.memory_grow"
 
-primitive (!) : Bool -> Bool = "@not"
-primitive (&&) : (Bool, Bool) -> Bool = "@and"
-primitive (||) : (Bool, Bool) -> Bool = "@or"
+primitive (!): Bool -> Bool = "@not"
+primitive (&&): (Bool, Bool) -> Bool = "@and"
+primitive (||): (Bool, Bool) -> Bool = "@or"
 
-primitive throw : Exception -> a = "@throw"
+primitive throw: Exception -> a = "@throw"
+
+primitive heapBase: WasmI32 = "@heap.base"
 
 /* UNDERSTANDING THE STRUCTURE OF THE FREE LIST
  * The original K&R definition for the free list entry type was the following:
@@ -80,7 +82,7 @@ export let _RESERVED_RUNTIME_SPACE = 0x4000n
  * The base the heap. The block at this address will be size 0 and
  * serve as the root of the free list.
  */
-let _BASE = _RESERVED_RUNTIME_SPACE
+let _BASE = heapBase + _RESERVED_RUNTIME_SPACE
 
 /**
  * The start pointer of the heap.
@@ -114,8 +116,8 @@ let setSize = (ptr: WasmI32, val: WasmI32) => {
 /**
  * Requests that the heap be grown by the given number of bytes.
  *
- * @param nbytes: WasmI32 - The number of bytes requested
- * @return WasmI32 - If unsuccessful, -1. Otherwise, the pointer to the beginning of the extended region.
+ * @param nbytes: The number of bytes requested
+ * @returns The pointer to the beginning of the extended region if successful or -1 otherwise
  */
 let growHeap = (nbytes: WasmI32) => {
   let mut reqSize = 0n
@@ -130,7 +132,7 @@ let growHeap = (nbytes: WasmI32) => {
       // so we need to request more anyway.
       reqSize = nbytes - heapSize
       reqSize = reqSize >> 16n
-      reqSize = reqSize + 1n
+      reqSize += 1n
       reqResult = memoryGrow(reqSize)
       if (reqResult == -1n) {
         -1n
@@ -147,7 +149,7 @@ let growHeap = (nbytes: WasmI32) => {
 
     reqSize = nbytes
     reqSize = reqSize >> 16n
-    reqSize = reqSize + 1n
+    reqSize += 1n
 
     reqResult = memoryGrow(reqSize)
     if (reqResult == -1n) {
@@ -162,7 +164,7 @@ let growHeap = (nbytes: WasmI32) => {
 /**
  * Frees the given allocated pointer.
  *
- * @param ap: WasmI32 - The pointer to free
+ * @param ap: The pointer to free
  */
 export let free = (ap: WasmI32) => {
   let mut blockPtr = ap - 8n // 8 bytes for malloc header
@@ -174,7 +176,10 @@ export let free = (ap: WasmI32) => {
     // Find the location to insert this block into the free list
     while (true) {
       let nextp = getNext(p)
-      if ( ((blockPtr > p) && (blockPtr < nextp)) || ((p >= nextp) && ((blockPtr > p) || (blockPtr < nextp))) ) {
+      if (
+        blockPtr > p && blockPtr < nextp ||
+        p >= nextp && (blockPtr > p || blockPtr < nextp)
+      ) {
         break
       }
       p = nextp
@@ -207,8 +212,8 @@ export let free = (ap: WasmI32) => {
  * (if you can't tell from the fact that the name is reminiscient
  *  of the 1970s, the name of this function is taken from K&R).
  *
- * @param nbytes: WasmI32 - The number of bytes to try to grow the heap by
- * @return WasmI32 - If successful, a pointer to the start of the free list. If not successful, -1.
+ * @param nbytes: The number of bytes to try to grow the heap by
+ * @returns A pointer to the start of the free list if successful or -1 otherwise
  */
 let morecore = (nbytes: WasmI32) => {
   let origSize = heapSize
@@ -232,8 +237,8 @@ let morecore = (nbytes: WasmI32) => {
 /**
  * Allocates the requested number of bytes, returning a pointer.
  *
- * @param nbytes: WasmI32 - The number of bytes to allocate
- * @return WasmI32 - The pointer to the allocated region (8-byte aligned), or -1 if the allocation failed.
+ * @param nbytes: The number of bytes to allocate
+ * @returns The pointer to the allocated region (8-byte aligned) or -1 if the allocation failed
  */
 export let malloc = (nb: WasmI32) => {
   let mut nbytes = nb
@@ -255,7 +260,12 @@ export let malloc = (nb: WasmI32) => {
   let mut ret = -1n
 
   // Search the freelist for any blocks large enough.
-  for (let mut p = getNext(prevp); ; {prevp = p; p = getNext(p)}) {
+  for (
+    let mut p = getNext(prevp); ; {
+      prevp = p
+      p = getNext(p)
+    }
+  ) {
     let size = getSize(p)
     if (size >= nbytes) {
       // If this block is big enough, allocate from it.
@@ -266,7 +276,7 @@ export let malloc = (nb: WasmI32) => {
         // Shrink it as needed
         let newSize = size - nbytes
         setSize(p, newSize)
-        p = p + newSize
+        p += newSize
         setSize(p, nbytes)
       }
       // Update the pointer to the free list.
@@ -292,10 +302,10 @@ export let malloc = (nb: WasmI32) => {
 }
 
 /**
- * Returns the current free list pointer
- * (used for debugging)
+ * Returns the current free list pointer.
+ * Used for debugging.
  *
- * @return WasmI32 - The free list pointer
+ * @returns The free list pointer
  */
 export let getFreePtr = () => {
   freePtr

package/runtime/malloc.md

@@ -0,0 +1,55 @@
+### Malloc.**_RESERVED_RUNTIME_SPACE**
+
+```grain
+_RESERVED_RUNTIME_SPACE : WasmI32
+```
+
+### Malloc.**free**
+
+```grain
+free : WasmI32 -> Void
+```
+
+Frees the given allocated pointer.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`ap`|`WasmI32`|The pointer to free|
+
+### Malloc.**malloc**
+
+```grain
+malloc : WasmI32 -> WasmI32
+```
+
+Allocates the requested number of bytes, returning a pointer.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`nbytes`|`WasmI32`|The number of bytes to allocate|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The pointer to the allocated region (8-byte aligned) or -1 if the allocation failed|
+
+### Malloc.**getFreePtr**
+
+```grain
+getFreePtr : () -> WasmI32
+```
+
+Returns the current free list pointer.
+Used for debugging.
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`WasmI32`|The free list pointer|
+