rbs 3.10.2 → 4.0.0.dev.1

data/src/string.c

@@ -5,6 +5,54 @@
 #include <stdio.h>
 #include <ctype.h>
 
+unsigned int rbs_utf8_string_to_codepoint(const rbs_string_t string) {
+    unsigned int codepoint = 0;
+    int remaining_bytes = 0;
+
+    const char *s = string.start;
+    const char *end = string.end;
+
+    if (s >= end) return 0;  // End of string
+
+    if ((*s & 0x80) == 0) {
+        // Single byte character (0xxxxxxx)
+        return *s;
+    } else if ((*s & 0xE0) == 0xC0) {
+        // Two byte character (110xxxxx 10xxxxxx)
+        codepoint = *s & 0x1F;
+        remaining_bytes = 1;
+    } else if ((*s & 0xF0) == 0xE0) {
+        // Three byte character (1110xxxx 10xxxxxx 10xxxxxx)
+        codepoint = *s & 0x0F;
+        remaining_bytes = 2;
+    } else if ((*s & 0xF8) == 0xF0) {
+        // Four byte character (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
+        codepoint = *s & 0x07;
+        remaining_bytes = 3;
+    } else {
+        // Invalid UTF-8 sequence
+        return 0xFFFD;  // Unicode replacement character
+    }
+
+    s++;
+    while (remaining_bytes > 0 && s < end) {
+        if ((*s & 0xC0) != 0x80) {
+            // Invalid continuation byte
+            return 0xFFFD;
+        }
+        codepoint = (codepoint << 6) | (*s & 0x3F);
+        s++;
+        remaining_bytes--;
+    }
+
+    if (remaining_bytes > 0) {
+        // Incomplete sequence
+        return 0xFFFD;
+    }
+
+    return codepoint;
+}
+
 rbs_string_t rbs_string_new(const char *start, const char *end) {
     return (rbs_string_t) {
         .start = start,

data/src/util/rbs_allocator.c

@@ -3,14 +3,6 @@
  *
  *  A simple arena allocator that can be freed all at once.
  *
-*  This allocator maintains a linked list of pages, which come in two flavours:
- *      1. Small allocation pages, which are the same size as the system page size.
- *      2. Large allocation pages, which are the exact size requested, for sizes greater than the small page size.
- *
- *  Small allocations always fit into the unused space at the end of the "head" page. If there isn't enough room, a new
- *  page is allocated, and the small allocation is placed at its start. This approach wastes that unused slack at the
- *  end of the previous page, but it means that allocations are instant and never scan the linked list to find a gap.
- *
  *  This allocator doesn't support freeing individual allocations. Only the whole arena can be freed at once at the end.
  */
 
@@ -23,24 +15,22 @@
 #include <inttypes.h>
 
 #ifdef _WIN32
-#include <windows.h>
+    #include <windows.h>
 #else
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/mman.h>
-#include <fcntl.h>
+    #include <unistd.h>
+    #include <sys/types.h>
+    #include <sys/mman.h>
 #endif
 
-typedef struct rbs_allocator_page {
-    // The previously allocated page, or NULL if this is the first page.
-    struct rbs_allocator_page *next;
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun)
+#define MAP_ANONYMOUS MAP_ANON
+#endif
 
-    // The size of the payload in bytes.
-    size_t size;
 
-    // The offset of the next available byte.
-    size_t used;
-} rbs_allocator_page_t;
+struct rbs_allocator {
+    uintptr_t heap_ptr;
+    uintptr_t size;
+};
 
 static size_t get_system_page_size(void) {
 #ifdef _WIN32
@@ -54,43 +44,74 @@ static size_t get_system_page_size(void) {
 #endif
 }
 
-static inline uintptr_t rbs_align_up_uintptr(uintptr_t value, size_t alignment) {
-    // alignment must be a non-zero power of two
-    RBS_ASSERT(alignment != 0 && (alignment & (alignment - 1)) == 0, "alignment must be a non-zero power of two. alignment: %zu", alignment);
-    return (value + (alignment - 1)) & ~(uintptr_t) (alignment - 1);
+static void *map_memory(size_t size) {
+#ifdef _WIN32
+    LPVOID result = VirtualAlloc(NULL, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+    rbs_assert(result != NULL, "VirtualAlloc failed");
+#else
+    void *result = mmap(NULL, size, PROT_READ | PROT_WRITE,
+                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    rbs_assert(result != MAP_FAILED, "mmap failed");
+#endif
+    return result;
 }
 
-static rbs_allocator_page_t *rbs_allocator_page_new(size_t payload_size) {
-    const size_t page_header_size = sizeof(rbs_allocator_page_t);
-
-    rbs_allocator_page_t *page = (rbs_allocator_page_t *) malloc(page_header_size + payload_size);
-    page->size = payload_size;
-    page->used = 0;
-
-    return page;
+static void destroy_memory(void *memory, size_t size) {
+#ifdef _WIN32
+    VirtualFree(memory, 0, MEM_RELEASE);
+#else
+    munmap(memory, size);
+#endif
 }
 
-rbs_allocator_t *rbs_allocator_init(void) {
-    rbs_allocator_t *allocator = (rbs_allocator_t *) malloc(sizeof(rbs_allocator_t));
+static void guard_page(void *memory, size_t page_size) {
+#ifdef _WIN32
+    DWORD old_protect_;
+    BOOL result = VirtualProtect(memory, page_size, PAGE_NOACCESS, &old_protect_);
+    rbs_assert(result != 0, "VirtualProtect failed");
+#else
+    int result = mprotect(memory, page_size, PROT_NONE);
+    rbs_assert(result == 0, "mprotect failed");
+#endif
+}
 
-    const size_t system_page_size = get_system_page_size();
+static size_t rbs_allocator_default_mem(void) {
+    size_t kib = 1024;
+    size_t mib = kib * 1024;
+    size_t gib = mib * 1024;
+    return 4 * gib;
+}
 
-    allocator->default_page_payload_size = system_page_size - sizeof(rbs_allocator_page_t);
+static inline bool is_power_of_two(uintptr_t value) {
+    return value > 0 && (value & (value - 1)) == 0;
+}
 
-    allocator->page = rbs_allocator_page_new(allocator->default_page_payload_size);
-    allocator->page->next = NULL;
+// Align `val' to nearest multiple of `alignment'.
+static uintptr_t align(uintptr_t size, uintptr_t alignment) {
+    rbs_assert(is_power_of_two(alignment), "alignment is not a power of two");
+    return (size + alignment - 1) & ~(alignment - 1);
+}
 
-    return allocator;
+rbs_allocator_t *rbs_allocator_init(void) {
+    size_t size = rbs_allocator_default_mem();
+    size_t page_size = get_system_page_size();
+    size = align(size, page_size);
+    void *mem = map_memory(size + page_size);
+    // Guard page; remove range checks in alloc fast path and hard fail if we
+    // consume all memory
+    void *last_page = (char *) mem + size;
+    guard_page(last_page, page_size);
+    uintptr_t start = (uintptr_t) mem;
+    rbs_allocator_t header = (rbs_allocator_t) {
+      .heap_ptr = start + sizeof header,
+      .size = size + page_size,
+    };
+    memcpy(mem, &header, sizeof header);
+    return (rbs_allocator_t *) mem;
 }
 
 void rbs_allocator_free(rbs_allocator_t *allocator) {
-    rbs_allocator_page_t *page = allocator->page;
-    while (page) {
-        rbs_allocator_page_t *next = page->next;
-        free(page);
-        page = next;
-    }
-    free(allocator);
+    destroy_memory((void *) allocator, allocator->size);
 }
 
 // Allocates `new_size` bytes from `allocator`, aligned to an `alignment`-byte boundary.
@@ -104,58 +125,21 @@ void *rbs_allocator_realloc_impl(rbs_allocator_t *allocator, void *ptr, size_t o
 
 // Allocates `size` bytes from `allocator`, aligned to an `alignment`-byte boundary.
 void *rbs_allocator_malloc_impl(rbs_allocator_t *allocator, size_t size, size_t alignment) {
-    if (allocator->default_page_payload_size < size) { // Big allocation, give it its own page.
-        // Add padding to ensure we can align the start pointer within this page
-        rbs_allocator_page_t *new_page = rbs_allocator_page_new(size + (alignment - 1));
-
-        // This simple allocator can only put small allocations into the head page.
-        // Naively prepending this large allocation page to the head of the allocator before the previous head page
-        // would waste the remaining space in the head page.
-        // So instead, we'll splice in the large page *after* the head page.
-        //
-        // +-------+    +-----------+        +-----------+
-        // | arena |    | head page |        | new_page  |
-        // |-------|    |-----------+        |-----------+
-        // | *page |--->|  size     |   +--->|  size     |   +---> ... previous tail
-        // +-------+    |  offset   |   |    |  offset   |   |
-        //              | *next ----+---+    | *next ----+---+
-        //              |    ...    |        |    ...    |
-        //              +-----------+        +-----------+
-        //
-        new_page->next = allocator->page->next;
-        allocator->page->next = new_page;
-
-        uintptr_t base = (uintptr_t) new_page + sizeof(rbs_allocator_page_t);
-        uintptr_t aligned_ptr = rbs_align_up_uintptr(base, alignment);
-        return (void *) aligned_ptr;
-    }
-
-    rbs_allocator_page_t *page = allocator->page;
-    uintptr_t base = (uintptr_t) page + sizeof(rbs_allocator_page_t);
-
-    // Compute aligned offset within the payload
-    size_t used_aligned = (size_t) (rbs_align_up_uintptr(base + page->used, alignment) - base);
-
-    if (used_aligned + size > page->size) {
-        // Not enough space. Allocate a new small page and prepend it to the allocator's linked list.
-        rbs_allocator_page_t *new_page = rbs_allocator_page_new(allocator->default_page_payload_size);
-        new_page->next = allocator->page;
-        allocator->page = new_page;
-        page = new_page;
-        base = (uintptr_t) page + sizeof(rbs_allocator_page_t);
-        used_aligned = (size_t) (rbs_align_up_uintptr(base, alignment) - base); // start of fresh page (usually 0 if header is aligned)
-    }
-
-    uintptr_t pointer = base + used_aligned;
-    page->used = used_aligned + size;
-    return (void *) pointer;
+    rbs_assert(size % alignment == 0, "size must be a multiple of the alignment. size: %zu, alignment: %zu", size, alignment);
+    uintptr_t aligned = align(allocator->heap_ptr, alignment);
+    allocator->heap_ptr = aligned + size;
+    return (void *) aligned;
 }
 
 // Note: This will eagerly fill with zeroes, unlike `calloc()` which can map a page in a page to be zeroed lazily.
 //       It's assumed that callers to this function will immediately write to the allocated memory, anyway.
 void *rbs_allocator_calloc_impl(rbs_allocator_t *allocator, size_t count, size_t size, size_t alignment) {
     void *p = rbs_allocator_malloc_many_impl(allocator, count, size, alignment);
+#if defined(__linux__)
+    // mmap with MAP_ANONYMOUS gives zero-filled pages.
+#else
     memset(p, 0, count * size);
+#endif
     return p;
 }
 

data/src/util/rbs_assert.c

@@ -5,15 +5,15 @@
 #include <stdlib.h>
 #include <stdbool.h>
 
-void rbs_assert_impl(bool condition, const char *fmt, ...) {
-    if (condition) {
-        return;
-    }
+void rbs_assert(bool condition, const char *fmt, ...) {
+  if (condition) {
+    return;
+  }
 
-    va_list args;
-    va_start(args, fmt);
-    vfprintf(stderr, fmt, args);
-    va_end(args);
-    fprintf(stderr, "\n");
-    exit(EXIT_FAILURE);
+  va_list args;
+  va_start(args, fmt);
+  vfprintf(stderr, fmt, args);
+  va_end(args);
+  fprintf(stderr, "\n");
+  exit(EXIT_FAILURE);
 }

data/src/util/rbs_buffer.c

@@ -25,7 +25,7 @@ void rbs_buffer_append_string(rbs_allocator_t *allocator, rbs_buffer_t *buffer,
     if (next_length > buffer->capacity) {
         size_t old_capacity = buffer->capacity;
 
-        RBS_ASSERT(old_capacity != 0, "Precondition: capacity must be at least 1. Got %zu", old_capacity);
+        rbs_assert(old_capacity != 0, "Precondition: capacity must be at least 1. Got %zu", old_capacity);
 
         size_t new_capacity = buffer->capacity * 2;
 
@@ -34,7 +34,7 @@ void rbs_buffer_append_string(rbs_allocator_t *allocator, rbs_buffer_t *buffer,
         }
 
         char *new_value = rbs_allocator_realloc(allocator, buffer->value, old_capacity, new_capacity, char);
-        RBS_ASSERT(new_value != NULL, "Failed to append to buffer. Old capacity: %zu, new capacity: %zu", old_capacity, new_capacity);
+        rbs_assert(new_value != NULL, "Failed to append to buffer. Old capacity: %zu, new capacity: %zu", old_capacity, new_capacity);
 
         buffer->value = new_value;
         buffer->capacity = new_capacity;

data/src/util/rbs_constant_pool.c

@@ -37,7 +37,7 @@ next_power_of_two(uint32_t v) {
     return v;
 }
 
-RBS_ATTRIBUTE_UNUSED static bool is_power_of_two(uint32_t size) {
+static bool is_power_of_two(uint32_t size) {
     return (size & (size - 1)) == 0;
 }
 
@@ -46,7 +46,7 @@ RBS_ATTRIBUTE_UNUSED static bool is_power_of_two(uint32_t size) {
  */
 static inline bool
 rbs_constant_pool_resize(rbs_constant_pool_t *pool) {
-    RBS_ASSERT(is_power_of_two(pool->capacity), "pool->capacity is not a power of two. Got %i", pool->capacity);
+    rbs_assert(is_power_of_two(pool->capacity), "pool->capacity is not a power of two. Got %i", pool->capacity);
 
     uint32_t next_capacity = pool->capacity * 2;
     if (next_capacity < pool->capacity) return false;
@@ -57,8 +57,8 @@ rbs_constant_pool_resize(rbs_constant_pool_t *pool) {
     void *next = calloc(next_capacity, element_size);
     if (next == NULL) return false;
 
-    rbs_constant_pool_bucket_t *next_buckets = (rbs_constant_pool_bucket_t *) next;
-    rbs_constant_t *next_constants = (rbs_constant_t *) (((char *) next) + next_capacity * sizeof(rbs_constant_pool_bucket_t));
+    rbs_constant_pool_bucket_t *next_buckets = next;
+    rbs_constant_t *next_constants = (void *)(((char *) next) + next_capacity * sizeof(rbs_constant_pool_bucket_t));
 
     // For each bucket in the current constant pool, find the index in the
     // next constant pool, and insert it.
@@ -96,13 +96,14 @@ rbs_constant_pool_resize(rbs_constant_pool_t *pool) {
 }
 
 // This storage is initialized by `Init_rbs_extension()` in `main.c`.
-static rbs_constant_pool_t RBS_GLOBAL_CONSTANT_POOL_STORAGE = { 0 };
+static rbs_constant_pool_t RBS_GLOBAL_CONSTANT_POOL_STORAGE = {};
 rbs_constant_pool_t *RBS_GLOBAL_CONSTANT_POOL = &RBS_GLOBAL_CONSTANT_POOL_STORAGE;
 
 /**
  * Initialize a new constant pool with a given capacity.
  */
-bool rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity) {
+bool
+rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity) {
     const uint32_t maximum = (~((uint32_t) 0));
     if (capacity >= ((maximum / 2) + 1)) return false;
 
@@ -111,8 +112,8 @@ bool rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity) {
     void *memory = calloc(capacity, element_size);
     if (memory == NULL) return false;
 
-    pool->buckets = (rbs_constant_pool_bucket_t *) memory;
-    pool->constants = (rbs_constant_t *) (((char *) memory) + capacity * sizeof(rbs_constant_pool_bucket_t));
+    pool->buckets = memory;
+    pool->constants = (void *)(((char *)memory) + capacity * sizeof(rbs_constant_pool_bucket_t));
     pool->size = 0;
     pool->capacity = capacity;
     return true;
@@ -123,7 +124,7 @@ bool rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity) {
  */
 rbs_constant_t *
 rbs_constant_pool_id_to_constant(const rbs_constant_pool_t *pool, rbs_constant_id_t constant_id) {
-    RBS_ASSERT(constant_id != RBS_CONSTANT_ID_UNSET && constant_id <= pool->size, "constant_id is not valid. Got %i, pool->size: %i", constant_id, pool->size);
+    rbs_assert(constant_id != RBS_CONSTANT_ID_UNSET && constant_id <= pool->size, "constant_id is not valid. Got %i, pool->size: %i", constant_id, pool->size);
     return &pool->constants[constant_id - 1];
 }
 
@@ -133,7 +134,7 @@ rbs_constant_pool_id_to_constant(const rbs_constant_pool_t *pool, rbs_constant_i
  */
 rbs_constant_id_t
 rbs_constant_pool_find(const rbs_constant_pool_t *pool, const uint8_t *start, size_t length) {
-    RBS_ASSERT(is_power_of_two(pool->capacity), "pool->capacity is not a power of two. Got %i", pool->capacity);
+    rbs_assert(is_power_of_two(pool->capacity), "pool->capacity is not a power of two. Got %i", pool->capacity);
     const uint32_t mask = pool->capacity - 1;
 
     uint32_t hash = rbs_constant_pool_hash(start, length);
@@ -161,7 +162,7 @@ rbs_constant_pool_insert(rbs_constant_pool_t *pool, const uint8_t *start, size_t
         if (!rbs_constant_pool_resize(pool)) return RBS_CONSTANT_ID_UNSET;
     }
 
-    RBS_ASSERT(is_power_of_two(pool->capacity), "pool->capacity is not a power of two. Got %i", pool->capacity);
+    rbs_assert(is_power_of_two(pool->capacity), "pool->capacity is not a power of two. Got %i", pool->capacity);
     const uint32_t mask = pool->capacity - 1;
 
     uint32_t hash = rbs_constant_pool_hash(start, length);
@@ -202,7 +203,7 @@ rbs_constant_pool_insert(rbs_constant_pool_t *pool, const uint8_t *start, size_t
     // IDs are allocated starting at 1, since the value 0 denotes a non-existent
     // constant.
     uint32_t id = ++pool->size;
-    RBS_ASSERT(pool->size < ((uint32_t) (1 << 30)), "pool->size is too large. Got %i", pool->size);
+    rbs_assert(pool->size < ((uint32_t) (1 << 30)), "pool->size is too large. Got %i", pool->size);
 
     *bucket = (rbs_constant_pool_bucket_t) {
         .id = (unsigned int) (id & 0x3fffffff),
@@ -255,7 +256,8 @@ rbs_constant_pool_insert_constant(rbs_constant_pool_t *pool, const uint8_t *star
 /**
  * Free the memory associated with a constant pool.
  */
-void rbs_constant_pool_free(rbs_constant_pool_t *pool) {
+void
+rbs_constant_pool_free(rbs_constant_pool_t *pool) {
     // For each constant in the current constant pool, free the contents if the
     // contents are owned.
     for (uint32_t index = 0; index < pool->capacity; index++) {