Add unfinished TLSF as test case fwiw

tests/compiler/tlsf.ts

@@ -0,0 +1,139 @@
+// An unfinished implementation of tlsf in low-level AssemblyScript.
+// Useful as a compiler test in this state, but nothing more.
+// based upon: https://github.com/mattconte/tlsf/blob/master/tlsf.c (BSD)
+
+/// <reference path="../../assembly.d.ts" />
+
+/** Finds the index of the least bit set. */
+function fls(word: u32): i32 {
+  return !word ? -1: 31 - clz<i32>(word);
+}
+
+assert(fls(0) == -1);
+assert(fls(1) == 0);
+assert(fls(0x80000008) == 31);
+assert(fls(0x7FFFFFFF) == 30);
+
+/** Finds the index of the first bit set. */
+function ffs(word: u32): i32 {
+  return !word ? -1 : ctz<i32>(word);
+}
+
+assert(ffs(0) == -1);
+assert(ffs(1) == 0);
+assert(ffs(0x80000000) == 31);
+
+// Align allocated blocks to 8 bytes so that any native type is aligned
+
+const ALIGN_SIZE_LOG2: i32 = 3;
+const ALIGN_SIZE: i32 = 1 << ALIGN_SIZE_LOG2;
+
+assert(ALIGN_SIZE == 8);
+
+// Define bitmap constants
+
+const SL_INDEX_COUNT_LOG2: i32 = 5;
+const FL_INDEX_MAX: i32 = 30;
+const SL_INDEX_COUNT: i32 = 1 << SL_INDEX_COUNT_LOG2;
+const FL_INDEX_SHIFT: i32 = SL_INDEX_COUNT_LOG2 + ALIGN_SIZE_LOG2;
+const FL_INDEX_COUNT: i32 = FL_INDEX_MAX - FL_INDEX_SHIFT + 1;
+const SMALL_BLOCK_SIZE: i32 = 1 << FL_INDEX_SHIFT;
+
+// struct block_header_t {
+//   struct block_header_t* prev_phys_block;
+//   size_t size;
+//   struct block_header_t* next_free;
+//   struct block_header_t* prev_free;
+// }
+
+const BLOCK_PREV_PHYS_OFFSET: usize = 0;
+const BLOCK_SIZE_OFFSET: usize = BLOCK_PREV_PHYS_OFFSET + sizeof<usize>();
+const BLOCK_NEXT_FREE_OFFSET: usize = BLOCK_SIZE_OFFSET + sizeof<usize>();
+const BLOCK_PREV_FREE_OFFSET: usize = BLOCK_NEXT_FREE_OFFSET + sizeof<usize>();
+
+function block_get_prev_phys_block(ptr: usize): usize {
+  return load<usize>(ptr + BLOCK_PREV_PHYS_OFFSET);
+}
+
+function block_set_prev_phys_block(ptr: usize, value: usize): void {
+  store<usize>(ptr + BLOCK_PREV_PHYS_OFFSET, value);
+}
+
+function block_get_size(ptr: usize): usize {
+  return load<usize>(ptr + BLOCK_SIZE_OFFSET);
+}
+
+function block_set_size(ptr: usize, value: usize): void {
+  store<usize>(ptr + BLOCK_SIZE_OFFSET, value);
+}
+
+function block_get_next_free(ptr: usize): usize {
+  return load<usize>(ptr + BLOCK_NEXT_FREE_OFFSET);
+}
+
+function block_set_next_free(ptr: usize, value: usize): void {
+  store<usize>(ptr + BLOCK_NEXT_FREE_OFFSET, value);
+}
+
+function block_get_prev_free(ptr: usize): usize {
+  return load<usize>(ptr + BLOCK_PREV_FREE_OFFSET);
+}
+
+function block_set_prev_free(ptr: usize, value: usize): void {
+  store<usize>(ptr + BLOCK_PREV_FREE_OFFSET, value);
+}
+
+// struct control_t {
+//   block_header_t block_null;
+//   unsigned int fl_bitmap;
+//   unsigned int sl_bitmap[FL_INDEX_COUNT];
+//   block_header_t* blocks[FL_INDEX_COUNT][SL_INDEX_COUNT];
+// }
+
+const CONTROL_FL_BITMAP_OFFSET: usize = BLOCK_PREV_FREE_OFFSET + sizeof<usize>();
+const CONTROL_SL_BITMAP_OFFSET: usize = CONTROL_FL_BITMAP_OFFSET + sizeof<u32>();
+const CONTROL_BLOCKS_OFFSET: usize = CONTROL_SL_BITMAP_OFFSET + FL_INDEX_COUNT * sizeof<u32>();
+
+function control_get_fl(ptr: usize): u32 {
+  return load<u32>(ptr + CONTROL_FL_BITMAP_OFFSET);
+}
+
+function control_set_fl(ptr: usize, value: u32): void {
+  store<u32>(ptr + CONTROL_FL_BITMAP_OFFSET, value);
+}
+
+function control_get_sl(ptr: usize, flIndex: usize): u32 {
+  assert(flIndex < FL_INDEX_COUNT);
+  return load<u32>(ptr + flIndex * sizeof<u32>());
+}
+
+function control_set_sl(ptr: usize, flIndex: usize, value: u32): void {
+  assert(flIndex < FL_INDEX_COUNT);
+  store<u32>(ptr + flIndex * sizeof<u32>(), value);
+}
+
+function control_get_block(ptr: usize, flIndex: usize, slIndex: usize): usize {
+  assert(flIndex < FL_INDEX_COUNT);
+  assert(slIndex < SL_INDEX_COUNT);
+  return load<usize>(ptr + (flIndex * SL_INDEX_COUNT + slIndex) * sizeof<usize>());
+}
+
+function control_set_block(ptr: usize, flIndex: usize, slIndex: usize, value: usize): void {
+  assert(flIndex < FL_INDEX_COUNT);
+  assert(slIndex < SL_INDEX_COUNT);
+  store<usize>(ptr + (flIndex * SL_INDEX_COUNT + slIndex) * sizeof<usize>(), value);
+}
+
+/* Clear structure and point all empty lists at the null block. */
+export function control_construct(ptr: usize): void {
+  block_set_next_free(ptr, ptr);
+  block_set_prev_free(ptr, ptr);
+  control_set_fl(ptr, 0);
+  for (let flIndex: usize = 0; flIndex < FL_INDEX_COUNT; ++flIndex) {
+    control_set_sl(ptr, flIndex, 0);
+    for (let slIndex: usize = 0; slIndex < SL_INDEX_COUNT; ++slIndex)
+      control_set_block(ptr, flIndex, slIndex, ptr);
+  }
+}
+
+control_construct(load<usize>(8));