From 11a2b2a9421ddf3bb397603120db3222d9eef142 Mon Sep 17 00:00:00 2001 From: Damian Tarnawski Date: Fri, 27 Oct 2023 00:05:38 +0200 Subject: [PATCH 1/6] Add system_random and random_bytes for js target --- core/crypto/rand_generic.odin | 4 ++-- core/crypto/rand_js.odin | 20 ++++++++++++++++++++ core/math/rand/system_js.odin | 11 +++++++++++ vendor/wasm/js/runtime.js | 6 ++++++ 4 files changed, 39 insertions(+), 2 deletions(-) create mode 100644 core/crypto/rand_js.odin create mode 100644 core/math/rand/system_js.odin diff --git a/core/crypto/rand_generic.odin b/core/crypto/rand_generic.odin index 52abfe4d7..fde91f85a 100644 --- a/core/crypto/rand_generic.odin +++ b/core/crypto/rand_generic.odin @@ -1,7 +1,7 @@ package crypto -when ODIN_OS != .Linux && ODIN_OS != .OpenBSD && ODIN_OS != .Windows { - _rand_bytes :: proc (dst: []byte) { +when ODIN_OS != .Linux && ODIN_OS != .OpenBSD && ODIN_OS != .Windows && ODIN_OS != .JS { + _rand_bytes :: proc(dst: []byte) { unimplemented("crypto: rand_bytes not supported on this OS") } } diff --git a/core/crypto/rand_js.odin b/core/crypto/rand_js.odin new file mode 100644 index 000000000..99a5bbcbc --- /dev/null +++ b/core/crypto/rand_js.odin @@ -0,0 +1,20 @@ +package crypto + +foreign import "odin_env" +foreign odin_env { + @(link_name = "rand_bytes") + env_rand_bytes :: proc "contextless" (buf: []byte) --- +} + +_MAX_PER_CALL_BYTES :: 65536 + +_rand_bytes :: proc(dst: []byte) { + dst := dst + + for len(dst) > 0 { + to_read := min(len(dst), _MAX_PER_CALL_BYTES) + env_rand_bytes(dst[:to_read]) + + dst = dst[to_read:] + } +} diff --git a/core/math/rand/system_js.odin b/core/math/rand/system_js.odin new file mode 100644 index 000000000..11e1385a2 --- /dev/null +++ b/core/math/rand/system_js.odin @@ -0,0 +1,11 @@ +package rand + +foreign import "odin_env" +foreign odin_env { + rand :: proc "contextless" () -> f64 --- +} + +@(require_results) +_system_random :: proc() -> u64 { + return u64(rand() * 0x1fffffffffffff) +} diff --git a/vendor/wasm/js/runtime.js b/vendor/wasm/js/runtime.js index d5ab383f0..33ce9640e 100644 --- a/vendor/wasm/js/runtime.js +++ b/vendor/wasm/js/runtime.js @@ -1349,6 +1349,12 @@ function odinSetupDefaultImports(wasmMemoryInterface, consoleElement) { ln: Math.log, exp: Math.exp, ldexp: (x, exp) => x * Math.pow(2, exp), + + rand: Math.random, + rand_bytes: (ptr, len) => { + const view = new Uint8Array(wasm_memory.buffer, ptr, len) + crypto.getRandomValues(view) + }, }, "odin_dom": { init_event_raw: (ep) => { From 166803a2a5ae2670d23b069f86f1aa8090f4bb14 Mon Sep 17 00:00:00 2001 From: Damian Tarnawski Date: Fri, 27 Oct 2023 00:18:41 +0200 Subject: [PATCH 2/6] Rename rand to rand_f64 --- core/math/rand/system_js.odin | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/core/math/rand/system_js.odin b/core/math/rand/system_js.odin index 11e1385a2..14949000e 100644 --- a/core/math/rand/system_js.odin +++ b/core/math/rand/system_js.odin @@ -2,10 +2,11 @@ package rand foreign import "odin_env" foreign odin_env { - rand :: proc "contextless" () -> f64 --- + @(link_name = "rand") + rand_f64 :: proc "contextless" () -> f64 --- } @(require_results) _system_random :: proc() -> u64 { - return u64(rand() * 0x1fffffffffffff) + return u64(rand_f64() * 0x1fffffffffffff) } From 8b2f62000addd72098e277b8b4e691a74c3c40a8 Mon Sep 17 00:00:00 2001 From: Damian Tarnawski Date: Fri, 27 Oct 2023 00:50:29 +0200 Subject: [PATCH 3/6] Use wasmMemoryInterface for rand_bytes --- vendor/wasm/js/runtime.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vendor/wasm/js/runtime.js b/vendor/wasm/js/runtime.js index 33ce9640e..16ef5d3aa 100644 --- a/vendor/wasm/js/runtime.js +++ b/vendor/wasm/js/runtime.js @@ -1352,7 +1352,7 @@ function odinSetupDefaultImports(wasmMemoryInterface, consoleElement) { rand: Math.random, rand_bytes: (ptr, len) => { - const view = new Uint8Array(wasm_memory.buffer, ptr, len) + const view = new Uint8Array(wasmMemoryInterface.memory.buffer, ptr, len) crypto.getRandomValues(view) }, }, From 49da19e013cc26abad75b552f06ee2ba925718c9 Mon Sep 17 00:00:00 2001 From: Damian Tarnawski Date: Fri, 27 Oct 2023 12:06:35 +0200 Subject: [PATCH 4/6] Replace Math.random with crypto.getRandomValues for _system_number --- core/crypto/rand_js.odin | 2 +- core/math/rand/system_js.odin | 8 +++++--- vendor/wasm/js/runtime.js | 1 - 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/core/crypto/rand_js.odin b/core/crypto/rand_js.odin index 99a5bbcbc..353b1e6b9 100644 --- a/core/crypto/rand_js.odin +++ b/core/crypto/rand_js.odin @@ -6,7 +6,7 @@ foreign odin_env { env_rand_bytes :: proc "contextless" (buf: []byte) --- } -_MAX_PER_CALL_BYTES :: 65536 +_MAX_PER_CALL_BYTES :: 65536 // 64kiB _rand_bytes :: proc(dst: []byte) { dst := dst diff --git a/core/math/rand/system_js.odin b/core/math/rand/system_js.odin index 14949000e..b9b71c4a6 100644 --- a/core/math/rand/system_js.odin +++ b/core/math/rand/system_js.odin @@ -2,11 +2,13 @@ package rand foreign import "odin_env" foreign odin_env { - @(link_name = "rand") - rand_f64 :: proc "contextless" () -> f64 --- + @(link_name = "rand_bytes") + env_rand_bytes :: proc "contextless" (buf: []byte) --- } @(require_results) _system_random :: proc() -> u64 { - return u64(rand_f64() * 0x1fffffffffffff) + buf: [8]u8 + env_rand_bytes(buf[:]) + return transmute(u64)buf } diff --git a/vendor/wasm/js/runtime.js b/vendor/wasm/js/runtime.js index 16ef5d3aa..78fdcca18 100644 --- a/vendor/wasm/js/runtime.js +++ b/vendor/wasm/js/runtime.js @@ -1350,7 +1350,6 @@ function odinSetupDefaultImports(wasmMemoryInterface, consoleElement) { exp: Math.exp, ldexp: (x, exp) => x * Math.pow(2, exp), - rand: Math.random, rand_bytes: (ptr, len) => { const view = new Uint8Array(wasmMemoryInterface.memory.buffer, ptr, len) crypto.getRandomValues(view) From bc0fa1240ba9230d6ac5c99c77a509ce7e5cfb3e Mon Sep 17 00:00:00 2001 From: gingerBill Date: Fri, 27 Oct 2023 13:03:21 +0100 Subject: [PATCH 5/6] Disable using giant packed struct for type info table for the time being --- src/llvm_backend.cpp | 4 +- src/llvm_backend_const.cpp | 3 ++ src/llvm_backend_type.cpp | 95 ++++++++++++++++++++++---------------- 3 files changed, 62 insertions(+), 40 deletions(-) diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp index 00c62f0f1..b2900b125 100644 --- a/src/llvm_backend.cpp +++ b/src/llvm_backend.cpp @@ -2247,7 +2247,9 @@ gb_internal bool lb_generate_code(lbGenerator *gen) { lb_add_entity(m, lb_global_type_info_data_entity, value); if (LB_USE_GIANT_PACKED_STRUCT) { - lb_make_global_private_const(g); + LLVMSetLinkage(g, LLVMPrivateLinkage); + LLVMSetUnnamedAddress(g, LLVMGlobalUnnamedAddr); + LLVMSetGlobalConstant(g, /*true*/false); } } { // Type info member buffer diff --git a/src/llvm_backend_const.cpp b/src/llvm_backend_const.cpp index a16b2293c..7584df3ee 100644 --- a/src/llvm_backend_const.cpp +++ b/src/llvm_backend_const.cpp @@ -94,6 +94,9 @@ gb_internal LLVMValueRef llvm_const_cast(LLVMValueRef val, LLVMTypeRef dst) { LLVMTypeKind kind = LLVMGetTypeKind(dst); switch (kind) { case LLVMPointerTypeKind: + if (LB_USE_NEW_PASS_SYSTEM) { + return val; + } return LLVMConstPointerCast(val, dst); case LLVMStructTypeKind: // GB_PANIC("%s -> %s", LLVMPrintValueToString(val), LLVMPrintTypeToString(dst)); diff --git a/src/llvm_backend_type.cpp b/src/llvm_backend_type.cpp index a78c0eacd..02dad2a3a 100644 --- a/src/llvm_backend_type.cpp +++ b/src/llvm_backend_type.cpp @@ -175,7 +175,8 @@ gb_internal lbValue lb_type_info_member_tags_offset(lbModule *m, isize count, i6 return offset; } -enum {LB_USE_GIANT_PACKED_STRUCT = LB_USE_NEW_PASS_SYSTEM}; +// enum {LB_USE_GIANT_PACKED_STRUCT = LB_USE_NEW_PASS_SYSTEM}; +enum {LB_USE_GIANT_PACKED_STRUCT = 0}; gb_internal LLVMTypeRef lb_setup_type_info_data_internal_type(lbModule *m, isize max_type_info_count) { if (!LB_USE_GIANT_PACKED_STRUCT) { @@ -269,7 +270,7 @@ gb_internal LLVMTypeRef lb_setup_type_info_data_internal_type(lbModule *m, isize return LLVMStructType(element_types, cast(unsigned)max_type_info_count, true); } -gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 global_type_info_data_entity_count) { // NOTE(bill): Setup type_info data +gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 global_type_info_data_entity_count, lbProcedure *p) { // NOTE(bill): Setup type_info data CheckerInfo *info = m->info; // Useful types @@ -286,7 +287,6 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl defer (gb_free(heap_allocator(), entries_handled.data)); entries_handled[0] = true; - LLVMValueRef giant_struct = lb_global_type_info_data_ptr(m).value; LLVMTypeRef giant_struct_type = LLVMGlobalGetValueType(giant_struct); GB_ASSERT(LLVMGetTypeKind(giant_struct_type) == LLVMStructTypeKind); @@ -320,6 +320,30 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl type_info_allocate_values(lb_global_type_info_member_usings); type_info_allocate_values(lb_global_type_info_member_tags); + + i64 const type_info_struct_size = type_size_of(t_type_info); + LLVMTypeRef llvm_u8 = lb_type(m, t_u8); + LLVMTypeRef llvm_int = lb_type(m, t_int); + // LLVMTypeRef llvm_type_info_ptr = lb_type(m, t_type_info_ptr); + + auto const get_type_info_ptr = [&](lbModule *m, Type *type) -> LLVMValueRef { + type = default_type(type); + + isize index = lb_type_info_index(m->info, type); + GB_ASSERT(index >= 0); + + u64 offset = cast(u64)(index * type_info_struct_size); + + LLVMValueRef indices[1] = { + LLVMConstInt(llvm_int, offset, false) + }; + + // LLVMValueRef ptr = LLVMConstInBoundsGEP2(llvm_u8, giant_struct, indices, gb_count_of(indices)); + LLVMValueRef ptr = LLVMConstGEP2(llvm_u8, giant_struct, indices, gb_count_of(indices)); + return ptr; + // return LLVMConstPointerCast(ptr, llvm_type_info_ptr); + }; + for_array(type_info_type_index, info->type_info_types) { Type *t = info->type_info_types[type_info_type_index]; if (t == nullptr || t == t_invalid) { @@ -394,7 +418,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl LLVMValueRef vals[4] = { lb_const_string(m, t->Named.type_name->token.string).value, - lb_type_info(m, t->Named.base).value, + get_type_info_ptr(m, t->Named.base), pkg_name, loc.value }; @@ -541,10 +565,8 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl case Type_Pointer: { tag_type = t_type_info_pointer; - lbValue gep = lb_type_info(m, t->Pointer.elem); - LLVMValueRef vals[1] = { - gep.value, + get_type_info_ptr(m, t->Pointer.elem), }; @@ -553,10 +575,9 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl } case Type_MultiPointer: { tag_type = t_type_info_multi_pointer; - lbValue gep = lb_type_info(m, t->MultiPointer.elem); LLVMValueRef vals[1] = { - gep.value, + get_type_info_ptr(m, t->MultiPointer.elem), }; variant_value = llvm_const_named_struct(m, tag_type, vals, gb_count_of(vals)); @@ -564,10 +585,9 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl } case Type_SoaPointer: { tag_type = t_type_info_soa_pointer; - lbValue gep = lb_type_info(m, t->SoaPointer.elem); LLVMValueRef vals[1] = { - gep.value, + get_type_info_ptr(m, t->SoaPointer.elem), }; variant_value = llvm_const_named_struct(m, tag_type, vals, gb_count_of(vals)); @@ -578,7 +598,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl i64 ez = type_size_of(t->Array.elem); LLVMValueRef vals[3] = { - lb_type_info(m, t->Array.elem).value, + get_type_info_ptr(m, t->Array.elem), lb_const_int(m, t_int, ez).value, lb_const_int(m, t_int, t->Array.count).value, }; @@ -590,8 +610,8 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl tag_type = t_type_info_enumerated_array; LLVMValueRef vals[7] = { - lb_type_info(m, t->EnumeratedArray.elem).value, - lb_type_info(m, t->EnumeratedArray.index).value, + get_type_info_ptr(m, t->EnumeratedArray.elem), + get_type_info_ptr(m, t->EnumeratedArray.index), lb_const_int(m, t_int, type_size_of(t->EnumeratedArray.elem)).value, lb_const_int(m, t_int, t->EnumeratedArray.count).value, @@ -609,7 +629,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl tag_type = t_type_info_dynamic_array; LLVMValueRef vals[2] = { - lb_type_info(m, t->DynamicArray.elem).value, + get_type_info_ptr(m, t->DynamicArray.elem), lb_const_int(m, t_int, type_size_of(t->DynamicArray.elem)).value, }; @@ -620,7 +640,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl tag_type = t_type_info_slice; LLVMValueRef vals[2] = { - lb_type_info(m, t->Slice.elem).value, + get_type_info_ptr(m, t->Slice.elem), lb_const_int(m, t_int, type_size_of(t->Slice.elem)).value, }; @@ -633,10 +653,10 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl LLVMValueRef params = LLVMConstNull(lb_type(m, t_type_info_ptr)); LLVMValueRef results = LLVMConstNull(lb_type(m, t_type_info_ptr)); if (t->Proc.params != nullptr) { - params = lb_type_info(m, t->Proc.params).value; + params = get_type_info_ptr(m, t->Proc.params); } if (t->Proc.results != nullptr) { - results = lb_type_info(m, t->Proc.results).value; + results = get_type_info_ptr(m, t->Proc.results); } LLVMValueRef vals[4] = { @@ -663,7 +683,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl lbValue index = lb_const_int(m, t_int, i); lbValue type_info = lb_const_ptr_offset(m, memory_types, index); - lb_global_type_info_member_types_values[type_offset+i] = lb_type_info(m, f->type).value; + lb_global_type_info_member_types_values[type_offset+i] = get_type_info_ptr(m, f->type); if (f->token.string.len > 0) { lb_global_type_info_member_names_values[name_offset+i] = lb_const_string(m, f->token.string).value; } @@ -692,7 +712,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl LLVMValueRef vals[3] = {}; - vals[0] = lb_type_info(m, t->Enum.base_type).value; + vals[0] = get_type_info_ptr(m, t->Enum.base_type); if (t->Enum.fields.count > 0) { auto fields = t->Enum.fields; lbValue name_array = lb_generate_global_array(m, t_string, fields.count, @@ -744,9 +764,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl for (isize variant_index = 0; variant_index < variant_count; variant_index++) { Type *vt = t->Union.variants[variant_index]; - lbValue tip = lb_type_info(m, vt); - - lb_global_type_info_member_types_values[variant_offset+variant_index] = lb_type_info(m, vt).value; + lb_global_type_info_member_types_values[variant_offset+variant_index] = get_type_info_ptr(m, vt); } lbValue count = lb_const_int(m, t_int, variant_count); @@ -756,7 +774,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl if (tag_size > 0) { i64 tag_offset = align_formula(t->Union.variant_block_size, tag_size); vals[1] = lb_const_int(m, t_uintptr, tag_offset).value; - vals[2] = lb_type_info(m, union_tag_type(t)).value; + vals[2] = get_type_info_ptr(m, union_tag_type(t)); } else { vals[1] = lb_const_int(m, t_uintptr, 0).value; vals[2] = LLVMConstNull(lb_type(m, t_type_info_ptr)); @@ -805,11 +823,11 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl Type *kind_type = get_struct_field_type(tag_type, 10); lbValue soa_kind = lb_const_value(m, kind_type, exact_value_i64(t->Struct.soa_kind)); - lbValue soa_type = lb_type_info(m, t->Struct.soa_elem); + LLVMValueRef soa_type = get_type_info_ptr(m, t->Struct.soa_elem); lbValue soa_len = lb_const_int(m, t_int, t->Struct.soa_count); vals[10] = soa_kind.value; - vals[11] = soa_type.value; + vals[11] = soa_type; vals[12] = soa_len.value; } } @@ -831,7 +849,6 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl type_set_offsets(t); // NOTE(bill): Just incase the offsets have not been set yet for (isize source_index = 0; source_index < count; source_index++) { Entity *f = t->Struct.fields[source_index]; - lbValue tip = lb_type_info(m, f->type); i64 foffset = 0; if (!t->Struct.is_raw_union) { GB_ASSERT(t->Struct.offsets != nullptr); @@ -841,7 +858,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl GB_ASSERT(f->kind == Entity_Variable && f->flags & EntityFlag_Field); - lb_global_type_info_member_types_values[types_offset+source_index] = lb_type_info(m, f->type).value; + lb_global_type_info_member_types_values[types_offset+source_index] = get_type_info_ptr(m, f->type); lb_global_type_info_member_offsets_values[offsets_offset+source_index] = lb_const_int(m, t_uintptr, foffset).value; lb_global_type_info_member_usings_values[usings_offset+source_index] = lb_const_bool(m, t_bool, (f->flags&EntityFlag_Using) != 0).value; @@ -880,8 +897,8 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl init_map_internal_types(t); LLVMValueRef vals[3] = { - lb_type_info(m, t->Map.key).value, - lb_type_info(m, t->Map.value).value, + get_type_info_ptr(m, t->Map.key), + get_type_info_ptr(m, t->Map.value), lb_gen_map_info_ptr(m, t).value }; @@ -897,13 +914,13 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl LLVMValueRef vals[4] = { - lb_type_info(m, t->BitSet.elem).value, + get_type_info_ptr(m, t->BitSet.elem), LLVMConstNull(lb_type(m, t_type_info_ptr)), lb_const_int(m, t_i64, t->BitSet.lower).value, lb_const_int(m, t_i64, t->BitSet.upper).value, }; if (t->BitSet.underlying != nullptr) { - vals[1] = lb_type_info(m, t->BitSet.underlying).value; + vals[1] = get_type_info_ptr(m, t->BitSet.underlying); } variant_value = llvm_const_named_struct(m, tag_type, vals, gb_count_of(vals)); @@ -916,7 +933,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl LLVMValueRef vals[3] = {}; - vals[0] = lb_type_info(m, t->SimdVector.elem).value; + vals[0] = get_type_info_ptr(m, t->SimdVector.elem); vals[1] = lb_const_int(m, t_int, type_size_of(t->SimdVector.elem)).value; vals[2] = lb_const_int(m, t_int, t->SimdVector.count).value; @@ -928,8 +945,8 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl { tag_type = t_type_info_relative_pointer; LLVMValueRef vals[2] = { - lb_type_info(m, t->RelativePointer.pointer_type).value, - lb_type_info(m, t->RelativePointer.base_integer).value, + get_type_info_ptr(m, t->RelativePointer.pointer_type), + get_type_info_ptr(m, t->RelativePointer.base_integer), }; variant_value = llvm_const_named_struct(m, tag_type, vals, gb_count_of(vals)); @@ -940,8 +957,8 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl { tag_type = t_type_info_relative_multi_pointer; LLVMValueRef vals[2] = { - lb_type_info(m, t->RelativeMultiPointer.pointer_type).value, - lb_type_info(m, t->RelativeMultiPointer.base_integer).value, + get_type_info_ptr(m, t->RelativeMultiPointer.pointer_type), + get_type_info_ptr(m, t->RelativeMultiPointer.base_integer), }; variant_value = llvm_const_named_struct(m, tag_type, vals, gb_count_of(vals)); @@ -954,7 +971,7 @@ gb_internal void lb_setup_type_info_data_giant_packed_struct(lbModule *m, i64 gl i64 ez = type_size_of(t->Matrix.elem); LLVMValueRef vals[5] = { - lb_type_info(m, t->Matrix.elem).value, + get_type_info_ptr(m, t->Matrix.elem), lb_const_int(m, t_int, ez).value, lb_const_int(m, t_int, matrix_type_stride_in_elems(t)).value, lb_const_int(m, t_int, t->Matrix.row_count).value, @@ -1037,7 +1054,7 @@ gb_internal void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup } if (LB_USE_GIANT_PACKED_STRUCT) { - lb_setup_type_info_data_giant_packed_struct(m, global_type_info_data_entity_count); + lb_setup_type_info_data_giant_packed_struct(m, global_type_info_data_entity_count, p); return; } From c8a5bafc6b794c75cd89efca86e51106fac15837 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Fri, 27 Oct 2023 14:53:48 +0100 Subject: [PATCH 6/6] Fix static map calls and default to them! --- src/build_settings.cpp | 2 +- src/llvm_backend.cpp | 32 ++++++++++++++++++++++++++------ 2 files changed, 27 insertions(+), 7 deletions(-) diff --git a/src/build_settings.cpp b/src/build_settings.cpp index d734073c0..1852013d5 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1389,7 +1389,7 @@ gb_internal void init_build_context(TargetMetrics *cross_target, Subtarget subta bc->optimization_level = gb_clamp(bc->optimization_level, -1, 3); // ENFORCE DYNAMIC MAP CALLS - bc->dynamic_map_calls = true; + // bc->dynamic_map_calls = false; bc->ODIN_VALGRIND_SUPPORT = false; if (build_context.metrics.os != TargetOs_windows) { diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp index b2900b125..8f5d8966d 100644 --- a/src/llvm_backend.cpp +++ b/src/llvm_backend.cpp @@ -692,7 +692,7 @@ gb_internal lbValue lb_map_set_proc_for_type(lbModule *m, Type *type) { } lbValue map_ptr = {LLVMGetParam(p->value, 0), t_rawptr}; - lbValue hash = {LLVMGetParam(p->value, 1), t_uintptr}; + lbValue hash_param = {LLVMGetParam(p->value, 1), t_uintptr}; lbValue key_ptr = {LLVMGetParam(p->value, 2), t_rawptr}; lbValue value_ptr = {LLVMGetParam(p->value, 3), t_rawptr}; lbValue location_ptr = {LLVMGetParam(p->value, 4), t_source_code_location_ptr}; @@ -700,6 +700,12 @@ gb_internal lbValue lb_map_set_proc_for_type(lbModule *m, Type *type) { map_ptr = lb_emit_conv(p, map_ptr, alloc_type_pointer(type)); key_ptr = lb_emit_conv(p, key_ptr, alloc_type_pointer(type->Map.key)); + LLVM_SET_VALUE_NAME(map_ptr.value, "map_ptr"); + LLVM_SET_VALUE_NAME(hash_param.value, "hash_param"); + LLVM_SET_VALUE_NAME(key_ptr.value, "key_ptr"); + LLVM_SET_VALUE_NAME(value_ptr.value, "value_ptr"); + LLVM_SET_VALUE_NAME(location_ptr.value, "location"); + lb_add_proc_attribute_at_index(p, 1+0, "nonnull"); lb_add_proc_attribute_at_index(p, 1+0, "noalias"); @@ -719,6 +725,10 @@ gb_internal lbValue lb_map_set_proc_for_type(lbModule *m, Type *type) { lb_add_proc_attribute_at_index(p, 1+4, "noalias"); lb_add_proc_attribute_at_index(p, 1+4, "readonly"); + lbAddr hash_addr = lb_add_local_generated(p, t_uintptr, false); + lb_addr_store(p, hash_addr, hash_param); + LLVM_SET_VALUE_NAME(hash_addr.addr.value, "hash"); + //// lbValue found_ptr = {}; { @@ -726,17 +736,19 @@ gb_internal lbValue lb_map_set_proc_for_type(lbModule *m, Type *type) { auto args = array_make(temporary_allocator(), 3); args[0] = lb_emit_conv(p, map_ptr, t_rawptr); - args[1] = hash; + args[1] = lb_addr_load(p, hash_addr); args[2] = key_ptr; found_ptr = lb_emit_call(p, map_get_proc, args); } + LLVM_SET_VALUE_NAME(found_ptr.value, "found_ptr"); lbBlock *found_block = lb_create_block(p, "found"); lbBlock *check_grow_block = lb_create_block(p, "check-grow"); lbBlock *grow_fail_block = lb_create_block(p, "grow-fail"); lbBlock *insert_block = lb_create_block(p, "insert"); + lbBlock *check_has_grown_block = lb_create_block(p, "check-has-grown"); lbBlock *rehash_block = lb_create_block(p, "rehash"); lb_emit_if(p, lb_emit_comp_against_nil(p, Token_NotEq, found_ptr), found_block, check_grow_block); @@ -749,6 +761,7 @@ gb_internal lbValue lb_map_set_proc_for_type(lbModule *m, Type *type) { lbValue map_info = lb_gen_map_info_ptr(p->module, type); + LLVM_SET_VALUE_NAME(map_info.value, "map_info"); { auto args = array_make(temporary_allocator(), 3); @@ -758,16 +771,23 @@ gb_internal lbValue lb_map_set_proc_for_type(lbModule *m, Type *type) { lbValue grow_err_and_has_grown = lb_emit_runtime_call(p, "__dynamic_map_check_grow", args); lbValue grow_err = lb_emit_struct_ev(p, grow_err_and_has_grown, 0); lbValue has_grown = lb_emit_struct_ev(p, grow_err_and_has_grown, 1); + LLVM_SET_VALUE_NAME(grow_err.value, "grow_err"); + LLVM_SET_VALUE_NAME(has_grown.value, "has_grown"); - lb_emit_if(p, lb_emit_comp_against_nil(p, Token_NotEq, grow_err), grow_fail_block, insert_block); + lb_emit_if(p, lb_emit_comp_against_nil(p, Token_NotEq, grow_err), grow_fail_block, check_has_grown_block); lb_start_block(p, grow_fail_block); LLVMBuildRet(p->builder, LLVMConstNull(lb_type(m, t_rawptr))); - lb_emit_if(p, has_grown, grow_fail_block, rehash_block); + lb_start_block(p, check_has_grown_block); + + lb_emit_if(p, has_grown, rehash_block, insert_block); lb_start_block(p, rehash_block); lbValue key = lb_emit_load(p, key_ptr); - hash = lb_gen_map_key_hash(p, map_ptr, key, nullptr); + lbValue new_hash = lb_gen_map_key_hash(p, map_ptr, key, nullptr); + LLVM_SET_VALUE_NAME(new_hash.value, "new_hash"); + lb_addr_store(p, hash_addr, new_hash); + lb_emit_jump(p, insert_block); } lb_start_block(p, insert_block); @@ -775,7 +795,7 @@ gb_internal lbValue lb_map_set_proc_for_type(lbModule *m, Type *type) { auto args = array_make(temporary_allocator(), 5); args[0] = lb_emit_conv(p, map_ptr, t_rawptr); args[1] = map_info; - args[2] = hash; + args[2] = lb_addr_load(p, hash_addr); args[3] = lb_emit_conv(p, key_ptr, t_uintptr); args[4] = lb_emit_conv(p, value_ptr, t_uintptr);