feat 新的运行时环境

runtime/libutils/src/hashtable.c

@@ -0,0 +1,140 @@
+#include <hashtable.h>
+
+#define INIT_HASH_TABLE_SIZE (32)
+
+void init_hashtable(hash_table_t* ht) {
+    vector_init(ht->entries);
+    ht->count = 0;
+    ht->tombstone_count = 0;
+    // Assert(ht->key_cmp != NULL && ht->hash_func != NULL);
+}
+
+static int next_power_of_two(int n) {
+    n--;
+    n |= n >> 1;
+    n |= n >> 2;
+    n |= n >> 4;
+    n |= n >> 8;
+    n |= n >> 16;
+    return n + 1;
+}
+
+static hash_entry_t* find_entry(hash_table_t* ht, const void* key, u32 hash) {
+    if (ht->entries.cap == 0) return NULL;
+    
+    u32 index = hash & (ht->entries.cap - 1); // 容量是2的幂
+    u32 probe = 0;
+
+    hash_entry_t* tombstone = NULL;
+    
+    while (1) {
+        hash_entry_t* entry = &vector_at(ht->entries, index);
+        if (entry->state == ENTRY_EMPTY) {
+            return tombstone ? tombstone : entry;
+        }
+        
+        if (entry->state == ENTRY_TOMBSTONE) {
+            if (!tombstone) tombstone = entry;
+        } else if (entry->hash == hash && ht->key_cmp(entry->key, key) == 0) {
+            return entry;
+        }
+        
+        // Liner finding
+        index = (index + 1) & (ht->entries.cap - 1);
+        probe++;
+        if (probe >= ht->entries.cap) break;
+    }
+    LOG_ERROR("hashset_find: hash table is full");
+    return NULL;
+}
+
+static void adjust_capacity(hash_table_t* ht, int new_cap) {
+    new_cap = next_power_of_two(new_cap);
+    Assert(new_cap >= ht->entries.cap);
+
+    VECTOR_HEADER(old_entries, hash_entry_t);
+    old_entries.data = ht->entries.data;
+    old_entries.cap = ht->entries.cap;
+
+    // Not used size but for gdb python extention debug
+    ht->entries.size = new_cap;
+    ht->entries.cap = new_cap;
+    ht->entries.data = smcc_realloc(NULL, new_cap * sizeof(hash_entry_t));
+    smcc_memset(ht->entries.data, 0, new_cap * sizeof(hash_entry_t));
+
+    // rehash the all of the old data
+    for (usize i = 0; i < old_entries.cap; i++) {
+        hash_entry_t* entry = &vector_at(old_entries, i);
+        if (entry->state == ENTRY_ACTIVE) {
+            hash_entry_t* dest = find_entry(ht, entry->key, entry->hash);
+            *dest = *entry;
+        }
+    }
+
+    vector_free(old_entries);
+    ht->tombstone_count = 0;
+}
+
+void* hashtable_set(hash_table_t* ht, const void* key, void* value) {
+    if (ht->count + ht->tombstone_count >= ht->entries.cap * 0.75) {
+        int new_cap = ht->entries.cap < INIT_HASH_TABLE_SIZE ? INIT_HASH_TABLE_SIZE : ht->entries.cap * 2;
+        adjust_capacity(ht, new_cap);
+    }
+
+    u32 hash = ht->hash_func(key);
+    hash_entry_t* entry = find_entry(ht, key, hash);
+    
+    void* old_value = NULL;
+    if (entry->state == ENTRY_ACTIVE) {
+        old_value = entry->value;
+    } else {
+        if (entry->state == ENTRY_TOMBSTONE) ht->tombstone_count--;
+        ht->count++;
+    }
+    
+    entry->key = key;
+    entry->value = value;
+    entry->hash = hash;
+    entry->state = ENTRY_ACTIVE;
+    return old_value;
+}
+
+void* hashtable_get(hash_table_t* ht, const void* key) {
+    if (ht->entries.cap == 0) return NULL;
+    
+    u32 hash = ht->hash_func(key);
+    hash_entry_t* entry = find_entry(ht, key, hash);
+    return (entry && entry->state == ENTRY_ACTIVE) ? entry->value : NULL;
+}
+
+void* hashtable_del(hash_table_t* ht, const void* key) {
+    if (ht->entries.cap == 0) return NULL;
+    
+    u32 hash = ht->hash_func(key);
+    hash_entry_t* entry = find_entry(ht, key, hash);
+    
+    if (entry == NULL || entry->state != ENTRY_ACTIVE) return NULL;
+    
+    void* value = entry->value;
+    entry->state = ENTRY_TOMBSTONE;
+    ht->count--;
+    ht->tombstone_count++;
+    return value;
+}
+
+void hashtable_destory(hash_table_t* ht) {
+    vector_free(ht->entries);
+    ht->count = 0;
+    ht->tombstone_count = 0;
+}
+
+void hashtable_foreach(hash_table_t* ht, hash_table_iter_func iter_func, void* context) {
+    for (usize i = 0; i < ht->entries.cap; i++) {
+        hash_entry_t* entry = &vector_at(ht->entries, i);
+        if (entry->state == ENTRY_ACTIVE) {
+            if (!iter_func(entry->key, entry->value, context)) {
+                break; // enable callback function terminal the iter
+            }
+        }
+    }
+}

runtime/libutils/src/strpool.c

@@ -0,0 +1,47 @@
+#include "strpool.h"
+
+u32 rt_strhash(const char* s) {
+    u32 hash = 2166136261u; // FNV-1a偏移基础值
+    while (*s) {
+        hash ^= *s++;
+        hash *= 16777619u;
+    }
+    return hash;
+}
+
+int rt_strcmp(const char* s1, const char* s2) {
+    while (*s1 && *s2 && *s1 == *s2) {
+        s1++;
+        s2++;
+    }
+    return *s1 - *s2;
+}
+
+void init_strpool(strpool_t* pool) {
+    pool->ht.hash_func = (u32(*)(const void*))rt_strhash;
+    pool->ht.key_cmp = (int(*)(const void*, const void*))rt_strcmp;
+    init_hashtable(&pool->ht);
+}
+
+const char* strpool_intern(strpool_t* pool, const char* str) {
+    void* existing = hashtable_get(&pool->ht, str);
+    if (existing) {
+        return existing;
+    }
+
+    rt_size_t len = rt_strlen(str) + 1;
+    char* new_str = lalloc_alloc(&pool->stralloc, len);
+    if (!new_str) {
+        LOG_ERROR("strpool: Failed to allocate memory for string");
+        return NULL;
+    }
+    rt_memcpy(new_str, str, len);
+
+    hashtable_set(&pool->ht, new_str, new_str);
+    return new_str;
+}
+
+void strpool_destroy(strpool_t* pool) {
+    hashtable_destory(&pool->ht);
+    lalloc_destroy(&pool->stralloc);
+}

runtime/libutils/src/vector-gdb.py

@@ -0,0 +1,112 @@
+# vector_gdb.py
+import gdb # type: ignore
+from gdb.printing import PrettyPrinter # type: ignore
+
+class VectorPrinter:
+    """兼容新旧注册方式的最终方案"""
+    
+    def __init__(self, val: gdb.Value):
+        self.val:gdb.Value = val
+        
+    def check_type(self) -> bool:
+        """类型检查（兼容匿名结构体）"""
+        try:
+            if self.val.type.code != gdb.TYPE_CODE_STRUCT:
+                return False
+            fields = self.val.type.fields()
+            if not fields:
+                return False
+            exp = ['size', 'cap', 'data']
+            for t in fields:
+                if t.name in exp:
+                    exp.remove(t.name)
+                else:
+                    return False
+            return True
+        except gdb.error:
+            return False
+    
+    def to_string(self):
+        if not self.check_type():
+            return "Not a vector"
+            
+        return "vector({} size={}, cap={})".format(
+            self.val.address,
+            self.val['size'],
+            self.val['cap'],
+        )
+    
+    def display_hint(self):
+        return 'array'
+    
+    def children(self):
+        """生成数组元素（关键改进点）"""
+        if not self.check_type():
+            return []
+            
+        size = int(self.val['size'])
+        cap = int(self.val['cap'])
+        data_ptr = self.val['data']
+        
+        if cap == 0 or data_ptr == 0:
+            return []
+        
+        # 使用 GDB 内置数组转换
+        array = data_ptr.dereference()
+        array = array.cast(data_ptr.type.target().array(cap - 1))
+        
+        for i in range(size):
+            # state = "<used>" if i < size else "<unused>"
+            try:
+                value = array[i]
+                yield (f"[{i}] {value.type} {value.address}", value)
+            except gdb.MemoryError:
+                yield (f"[{i}]", "<invalid>")
+
+# 注册方式一：传统append方法（您之前有效的方式）self
+def append_printer():
+    gdb.pretty_printers.append(
+        lambda val: VectorPrinter(val) if VectorPrinter(val).check_type() else None
+    )
+
+# 注册方式二：新版注册方法（备用方案）  
+def register_new_printer():
+    class VectorPrinterLocator(PrettyPrinter):
+        def __init__(self):
+            super().__init__("vector_printer")
+            
+        def __call__(self, val):
+            ret = VectorPrinter(val).check_type()
+            print(f"ret {ret}, type {val.type}, {[(i.name, i.type) for i in  val.type.fields()]}")
+            return None
+    
+    gdb.printing.register_pretty_printer(
+        gdb.current_objfile(),
+        VectorPrinterLocator()
+    )
+
+# 双重注册保证兼容性
+append_printer()  # 保留您原来有效的方式
+# register_new_printer()  # 添加新版注册
+
+class VectorInfoCommand(gdb.Command):
+    """保持原有命令不变"""
+    def __init__(self):
+        super().__init__("vector_info", gdb.COMMAND_USER)
+        
+    def invoke(self, argument, from_tty):
+        val = gdb.parse_and_eval(argument)
+        printer = VectorPrinter(val)
+        
+        if not printer.check_type():
+            print("Invalid vector")
+            return
+            
+        print("=== Vector Details ===")
+        print("Size:", val['size'])
+        print("Capacity:", val['cap'])
+        print("Elements:")
+        for name, value in printer.children():
+            print(f"  {name}: {value}")
+
+VectorInfoCommand()