adding untested type table creation

diff --git a/bin/onyx b/bin/onyx
index e0bd10c24c0e03c0cf0681d665318c9a5626dac9..7a061c3bc6f9d30bc3fce96e76b79e1029ef5c8b 100755 (executable)
Binary files a/bin/onyx and b/bin/onyx differ

diff --git a/core/type_info.onyx b/core/type_info.onyx
index ec435f1584d22b367c574d6b4c466b069f47aeae..bad1026e5fe2280cd5d71ef7cc5621ee2175fa96 100644 (file)
--- a/core/type_info.onyx
+++ b/core/type_info.onyx
@@ -115,8 +115,9 @@ Type_Info_Enum :: struct {
         value: u64; // This assumes enums are always represented as ints.
     }
 
-    name: str;
+    // This is first for better alignment
     backing_type: Type_Index;
+    name: str;
     members: [] Member;
 
     is_flags: bool;
@@ -142,4 +143,10 @@ Type_Info_Compound :: struct {
     use base : Type_Info;
 
     components : [] Type_Index;
+}
+
+get_type_info :: (t: Type_Index) -> ^Type_Info {
+    if t < 0 || t >= type_table.count do return null;
+
+    return type_table[t];
 }
\ No newline at end of file

diff --git a/include/bh.h b/include/bh.h
index 068f8e0a355382b536a8f5d90afe20ea9eec90bb..742034c575383411defb91b60a0448a3c114266a 100644 (file)
--- a/include/bh.h
+++ b/include/bh.h
@@ -470,7 +470,9 @@ void bh_buffer_grow(bh_buffer* buffer, i32 length);
 void bh_buffer_append(bh_buffer* buffer, const void * data, i32 length);
 void bh_buffer_concat(bh_buffer* buffer, bh_buffer other);
 void bh_buffer_write_byte(bh_buffer* buffer, u8 byte);
-
+void bh_buffer_write_u32(bh_buffer* buffer, u32 i);
+void bh_buffer_write_u64(bh_buffer* buffer, u64 i);
+void bh_buffer_align(bh_buffer* buffer, u32 alignment);
 
 
 
@@ -1953,7 +1955,26 @@ void bh_buffer_write_byte(bh_buffer* buffer, u8 byte) {
     buffer->data[buffer->length++] = byte;
 }
 
+void bh_buffer_write_u32(bh_buffer* buffer, u32 i) {
+    bh_buffer_grow(buffer, buffer->length + 4);
+    *((u32 *) bh_pointer_add(buffer->data, buffer->length)) = i;
+    buffer->length += 4;
+}
+
+void bh_buffer_write_u64(bh_buffer* buffer, u64 i) {
+    bh_buffer_grow(buffer, buffer->length + 8);
+    *((u8 *) bh_pointer_add(buffer->data, buffer->length)) = i;
+    buffer->length += 8;
+}
 
+void bh_buffer_align(bh_buffer* buffer, u32 alignment) {
+    if (buffer->length % alignment != 0) {
+        u32 difference = alignment - (buffer->length % alignment);
+        buffer->length += difference;
+
+        bh_buffer_grow(buffer, buffer->length);
+    }
+}
 
 
 #endif

diff --git a/include/onyxtypes.h b/include/onyxtypes.h
index 48cd409b49a3ca61c9c85e8e562c12e4359af2d6..9bacca848ae86e6f74269717c0b48dd3a03a5dab 100644 (file)
--- a/include/onyxtypes.h
+++ b/include/onyxtypes.h
@@ -154,6 +154,8 @@ struct Type {
     };
 };
 
+extern bh_imap type_map;
+
 extern Type basic_types[];
 
 struct AstType;

diff --git a/src/onyxtypes.c b/src/onyxtypes.c
index 29e2ac257c8d1df612fc90db974110844ea51ac6..90fccfd14db016958454f17490307965de375b5a 100644 (file)
--- a/src/onyxtypes.c
+++ b/src/onyxtypes.c
@@ -37,7 +37,8 @@ Type basic_types[] = {
     { Type_Kind_Basic, 0, 0, (AstType *) &basic_type_v128,  { Basic_Kind_V128,   Basic_Flag_SIMD,                        16, 16, "v128"  } },
 };
 
-static bh_imap type_map;
+// TODO: Document this!!
+       bh_imap type_map;
 static bh_imap type_pointer_map;
 static bh_imap type_slice_map;
 static bh_imap type_dynarr_map;

diff --git a/src/onyxwasm.c b/src/onyxwasm.c
index 55c8b280220307571a8a82de6b832d0f11444354..f2a9a7ac2ee81f34c593ab6d7980c425b2851f6b 100644 (file)
--- a/src/onyxwasm.c
+++ b/src/onyxwasm.c
@@ -264,6 +264,7 @@ EMIT_FUNC(enter_structured_block,        StructuredBlockType sbt);
 EMIT_FUNC_NO_ARGS(leave_structured_block);
 
 #include "onyxwasm_intrinsics.c"
+#include "onyxwasm_type_table.c"
 
 EMIT_FUNC(function_body, AstFunction* fd) {
     if (fd->body == NULL) return;

diff --git a/src/onyxwasm_type_table.c b/src/onyxwasm_type_table.c
new file mode 100644 (file)
index 0000000..c945f17
--- /dev/null
+++ b/src/onyxwasm_type_table.c
@@ -0,0 +1,195 @@
+// This file is directly included in src/onxywasm.c
+// It is here purely to decrease the amount of clutter in the main file.
+
+
+void build_type_table(OnyxWasmModule* module) {
+
+    bh_arr(u32) base_patch_locations=NULL;
+    bh_arr_new(global_heap_allocator, base_patch_locations, 256);
+
+#define PATCH (bh_arr_push(base_patch_locations, table_buffer.length))
+
+    // This is the data behind the "type_table" slice in type_info.onyx
+    u32* table_info = bh_alloc_array(global_heap_allocator, u32, bh_arr_length(type_map.entries));
+
+    bh_buffer table_buffer;
+    bh_buffer_init(&table_buffer, global_heap_allocator, 4096);
+
+    bh_arr_each(bh__imap_entry, type_entry, type_map.entries) {
+        u64 type_idx = type_entry->key;
+        Type* type = (Type *) type_entry->value;
+
+
+        switch (type->kind) {
+            case Type_Kind_Basic: {
+                table_info[type_idx] = table_buffer.length;
+                bh_buffer_write_u32(&table_buffer, type->kind);
+                bh_buffer_write_u32(&table_buffer, type_size_of(type));
+                bh_buffer_write_u32(&table_buffer, type_alignment_of(type));
+                bh_buffer_write_u32(&table_buffer, type->Basic.kind);
+                break;
+            }
+
+            case Type_Kind_Pointer: {
+                table_info[type_idx] = table_buffer.length;
+                bh_buffer_write_u32(&table_buffer, type->kind);
+                bh_buffer_write_u32(&table_buffer, type_size_of(type));
+                bh_buffer_write_u32(&table_buffer, type_alignment_of(type));
+                bh_buffer_write_u32(&table_buffer, type->Pointer.elem->id);
+                break;
+            }
+
+            case Type_Kind_Array: {
+                table_info[type_idx] = table_buffer.length;
+                bh_buffer_write_u32(&table_buffer, type->kind);
+                bh_buffer_write_u32(&table_buffer, type_size_of(type));
+                bh_buffer_write_u32(&table_buffer, type_alignment_of(type));
+                bh_buffer_write_u32(&table_buffer, type->Array.elem->id);
+                bh_buffer_write_u32(&table_buffer, type->Array.count);
+                break;
+            }
+
+            case Type_Kind_Slice: {
+                table_info[type_idx] = table_buffer.length;
+                bh_buffer_write_u32(&table_buffer, type->kind);
+                bh_buffer_write_u32(&table_buffer, type_size_of(type));
+                bh_buffer_write_u32(&table_buffer, type_alignment_of(type));
+                bh_buffer_write_u32(&table_buffer, type->Slice.ptr_to_data->Pointer.elem->id);
+                break;
+            }
+
+            case Type_Kind_DynArray: {
+                table_info[type_idx] = table_buffer.length;
+                bh_buffer_write_u32(&table_buffer, type->kind);
+                bh_buffer_write_u32(&table_buffer, type_size_of(type));
+                bh_buffer_write_u32(&table_buffer, type_alignment_of(type));
+                bh_buffer_write_u32(&table_buffer, type->DynArray.ptr_to_data->Pointer.elem->id);
+                break;
+            }
+
+            case Type_Kind_VarArgs: {
+                table_info[type_idx] = table_buffer.length;
+                bh_buffer_write_u32(&table_buffer, type->kind);
+                bh_buffer_write_u32(&table_buffer, type_size_of(type));
+                bh_buffer_write_u32(&table_buffer, type_alignment_of(type));
+                bh_buffer_write_u32(&table_buffer, type->VarArgs.ptr_to_data->Pointer.elem->id);
+                break;
+            }
+
+            case Type_Kind_Compound: {
+                u32 components_base = table_buffer.length;
+
+                u32 components_count = type->Compound.count;
+                fori (i, 0, components_count) {
+                    u32 type_idx = type->Compound.types[i]->id;
+                    bh_buffer_write_u32(&table_buffer, type_idx);
+                }
+
+                table_info[type_idx] = table_buffer.length;
+                bh_buffer_write_u32(&table_buffer, type->kind);
+                bh_buffer_write_u32(&table_buffer, type_size_of(type));
+                bh_buffer_write_u32(&table_buffer, type_alignment_of(type));
+                PATCH;
+                bh_buffer_write_u64(&table_buffer, components_base);
+                bh_buffer_write_u64(&table_buffer, components_count);
+                break;
+            }
+
+            case Type_Kind_Function: {
+                u32 parameters_base = table_buffer.length;
+
+                u32 parameters_count = type->Function.param_count;
+                fori (i, 0, parameters_count) {
+                    u32 type_idx = type->Function.params[i]->id;
+                    bh_buffer_write_u32(&table_buffer, type_idx);
+                }
+
+                table_info[type_idx] = table_buffer.length;
+                bh_buffer_write_u32(&table_buffer, type->kind);
+                bh_buffer_write_u32(&table_buffer, type_size_of(type));
+                bh_buffer_write_u32(&table_buffer, type_alignment_of(type));
+                bh_buffer_write_u32(&table_buffer, type->Function.return_type->id);
+
+                PATCH;
+                bh_buffer_write_u64(&table_buffer, parameters_base);
+                bh_buffer_write_u64(&table_buffer, parameters_count);
+
+                bh_buffer_write_u32(&table_buffer, type->Function.vararg_arg_pos > 0 ? 1 : 0);
+                break;
+            }
+
+            case Type_Kind_Enum: {
+
+                u32 name_base = table_buffer.length;
+                u32 name_length = strlen(type->Enum.name);
+                bh_buffer_append(&table_buffer, type->Enum.name, name_length);
+                bh_buffer_align(&table_buffer, 8);
+
+                // u32 member_base = table_buffer.length;
+
+                table_info[type_idx] = table_buffer.length;
+                bh_buffer_write_u32(&table_buffer, type->kind);
+                bh_buffer_write_u32(&table_buffer, type_size_of(type));
+                bh_buffer_write_u32(&table_buffer, type_alignment_of(type));
+                bh_buffer_write_u32(&table_buffer, type->Enum.backing->id);
+                PATCH;
+                bh_buffer_write_u64(&table_buffer, name_base);
+                bh_buffer_write_u64(&table_buffer, name_length);
+                bh_buffer_write_u64(&table_buffer, 0);                   // TODO: Add member info here. Also, Patching
+                bh_buffer_write_u64(&table_buffer, 0);
+                bh_buffer_write_u32(&table_buffer, type->Enum.is_flags ? 1 : 0);
+            }
+
+            case Type_Kind_Struct: {
+                TypeStruct* s = &type->Struct;
+                u32* name_locations = bh_alloc_array(global_scratch_allocator, u32, s->mem_count);
+
+                u32 i = 0;
+                bh_arr_each(StructMember*, pmem, s->memarr) {
+                    StructMember* mem = *pmem;
+
+                    name_locations[i++] = table_buffer.length;
+                    bh_buffer_append(&table_buffer, mem->name, strlen(mem->name));
+                }
+
+                bh_buffer_align(&table_buffer, 8);
+
+                u32 members_base = table_buffer.length;
+
+                i = 0;
+                bh_arr_each(StructMember*, pmem, s->memarr) {
+                    StructMember* mem = *pmem;
+
+                    u32 name_loc = name_locations[i++];
+
+                    bh_buffer_align(&table_buffer, 8);
+                    PATCH;
+                    bh_buffer_write_u64(&table_buffer, name_loc);
+                    bh_buffer_write_u64(&table_buffer, strlen(mem->name));
+                    bh_buffer_write_u32(&table_buffer, mem->offset);
+                    bh_buffer_write_u32(&table_buffer, mem->type->id);
+                    bh_buffer_write_byte(&table_buffer, mem->used ? 1 : 0);
+                    bh_buffer_write_byte(&table_buffer, mem->initial_value != NULL ? 1 : 0);
+                }
+
+                u32 name_base = table_buffer.length;
+                u32 name_length = strlen(s->name);
+                bh_buffer_append(&table_buffer, s->name, name_length);
+                bh_buffer_align(&table_buffer, 8);
+
+                table_info[type_idx] = table_buffer.length;
+                bh_buffer_write_u32(&table_buffer, type->kind);
+                bh_buffer_write_u32(&table_buffer, type_size_of(type));
+                bh_buffer_write_u32(&table_buffer, type_alignment_of(type));
+                PATCH;
+                bh_buffer_write_u64(&table_buffer, name_base);
+                bh_buffer_write_u64(&table_buffer, name_length);
+                PATCH;
+                bh_buffer_write_u64(&table_buffer, members_base);
+                bh_buffer_write_u64(&table_buffer, s->mem_count);
+            }
+        }
+    }
+
+#undef PATCH
+}
\ No newline at end of file