diff --git a/src/base/base_core.c b/src/base/base_core.c index 79655432..8988f41e 100644 --- a/src/base/base_core.c +++ b/src/base/base_core.c @@ -79,19 +79,21 @@ u64_up_to_pow2(U64 x){ } internal S32 -extend_sign32(U32 x, U32 size){ - U32 high_bit = size * 8; - U32 shift = 32 - high_bit; - S32 result = ((S32)x << shift) >> shift; - return result; +extend_sign32(U32 x, U32 size) +{ + U32 n = size * 8; + U32 m = (U32)1 << (n - 1); + S32 r = (S32)((x ^ m) - m); + return r; } internal S64 -extend_sign64(U64 x, U64 size){ - U64 high_bit = size * 8; - U64 shift = 64 - high_bit; - S64 result = ((S64)x << shift) >> shift; - return result; +extend_sign64(U64 x, U64 size) +{ + U64 n = size * 8; + U64 m = (U64)1 << (n - 1); + S64 r = (S64)((x ^ m) - m); + return r; } internal F32 @@ -286,6 +288,44 @@ memory_is_zero(void *ptr, U64 size) return result; } +internal void UBSAN_NO_ALIGN +memory_write32(void *ptr, U32 v) +{ + MemoryCopy(ptr, &v, sizeof(v)); +} + +internal U8 UBSAN_NO_ALIGN +memory_read8(void *ptr) +{ + U8 result; + MemoryCopy(&result, ptr, sizeof(result)); + return result; +} + +internal U16 UBSAN_NO_ALIGN +memory_read16(void *ptr) +{ + U16 result; + MemoryCopy(&result, ptr, sizeof(result)); + return result; +} + +internal U32 UBSAN_NO_ALIGN +memory_read32(void *ptr) +{ + U32 result; + MemoryCopy(&result, ptr, sizeof(result)); + return result; +} + +internal U64 UBSAN_NO_ALIGN +memory_read64(void *ptr) +{ + U64 result; + MemoryCopy(&result, ptr, sizeof(result)); + return result; +} + //////////////////////////////// //~ rjf: Text 2D Coordinate/Range Functions diff --git a/src/base/base_core.h b/src/base/base_core.h index aa00a278..ba7d20cc 100644 --- a/src/base/base_core.h +++ b/src/base/base_core.h @@ -7,12 +7,13 @@ //////////////////////////////// //~ rjf: Foreign Includes -#include #include +#include +#include +#include +#include #include #include -#include -#include //////////////////////////////// //~ rjf: Third Party Includes @@ -181,8 +182,9 @@ //~ rjf: Member Offsets #define Member(T,m) (((T*)0)->m) -#define OffsetOf(T,m) IntFromPtr(&Member(T,m)) +#define OffsetOf(T,m) offsetof(T, m) #define MemberFromOffset(T,ptr,off) (T)((((U8 *)ptr)+(off))) +#define MemberFromPtr(T,ptr,m) (void*)((((U8 *)ptr)+OffsetOf(T,m))) #define CastFromMember(T,m,ptr) (T*)(((U8*)ptr) - OffsetOf(T,m)) //////////////////////////////// @@ -366,9 +368,9 @@ CheckNil(nil,p) ? \ #if COMPILER_MSVC # if defined(__SANITIZE_ADDRESS__) # define ASAN_ENABLED 1 -# define NO_ASAN __declspec(no_sanitize_address) +# define ASAN_NO_ADDR __declspec(no_sanitize_address) # else -# define NO_ASAN +# define UBSAN_NO_ALIGN # endif #elif COMPILER_CLANG # if defined(__has_feature) @@ -376,9 +378,15 @@ CheckNil(nil,p) ? \ # define ASAN_ENABLED 1 # endif # endif -# define NO_ASAN __attribute__((no_sanitize("address"))) -#else -# define NO_ASAN +# define ASAN_NO_ADDR __attribute__((no_sanitize("address"))) +# define UBSAN_NO_ALIGN __attribute__((no_sanitize("alignment"))) +#endif + +#ifndef ASAN_NO_ADDR +# define ASAN_NO_ADDR +#endif +#ifndef UBSAN_NO_ALIGN +# define UBSAN_NO_ALIGN #endif #if ASAN_ENABLED @@ -1001,6 +1009,13 @@ internal F32 sign_from_side_F32(Side side); internal B32 memory_is_zero(void *ptr, U64 size); +internal void memory_write32(void *ptr, U32 v); + +internal U8 memory_read8(void *ptr); +internal U16 memory_read16(void *ptr); +internal U32 memory_read32(void *ptr); +internal U64 memory_read64(void *ptr); + //////////////////////////////// //~ rjf: Text 2D Coordinate/Range Functions diff --git a/src/codeview/codeview_parse.c b/src/codeview/codeview_parse.c index bab4371f..a460de63 100644 --- a/src/codeview/codeview_parse.c +++ b/src/codeview/codeview_parse.c @@ -29,7 +29,7 @@ cv_numeric_from_data_range(U8 *first, U8 *opl) CV_NumericParsed result = {0}; if(first + 2 <= opl) { - U16 x = *(U16*)first; + U16 x = memory_read16(first); if(x < 0x8000) { result.kind = CV_NumericKind_USHORT; diff --git a/src/font_provider/dwrite/font_provider_dwrite.c b/src/font_provider/dwrite/font_provider_dwrite.c index 66c4a235..91dbd89e 100644 --- a/src/font_provider/dwrite/font_provider_dwrite.c +++ b/src/font_provider/dwrite/font_provider_dwrite.c @@ -447,7 +447,7 @@ fp_metrics_from_font(FP_Handle handle) return result; } -fp_hook NO_ASAN FP_RasterResult +fp_hook ASAN_NO_ADDR FP_RasterResult fp_raster(Arena *arena, FP_Handle font_handle, F32 size, FP_RasterFlags flags, String8 string) { ProfBeginFunction(); diff --git a/src/font_provider/font_provider.h b/src/font_provider/font_provider.h index 80fd608d..3f010552 100644 --- a/src/font_provider/font_provider.h +++ b/src/font_provider/font_provider.h @@ -54,6 +54,6 @@ fp_hook FP_Handle fp_font_open(String8 path); fp_hook FP_Handle fp_font_open_from_static_data_string(String8 *data_ptr); fp_hook void fp_font_close(FP_Handle handle); fp_hook FP_Metrics fp_metrics_from_font(FP_Handle font); -fp_hook NO_ASAN FP_RasterResult fp_raster(Arena *arena, FP_Handle font, F32 size, FP_RasterFlags flags, String8 string); +fp_hook ASAN_NO_ADDR FP_RasterResult fp_raster(Arena *arena, FP_Handle font, F32 size, FP_RasterFlags flags, String8 string); #endif // FONT_PROVIDER_H diff --git a/src/linker/base_ext/base_bit_array.c b/src/linker/base_ext/base_bit_array.c index a4f39b4a..8c0a8d1e 100644 --- a/src/linker/base_ext/base_bit_array.c +++ b/src/linker/base_ext/base_bit_array.c @@ -238,9 +238,9 @@ bit_array_set_bit32(U32Array bit_array, U64 idx, B32 state) U64 word_idx = idx / 32; U64 bit_idx = idx % 32; if (state) { - bit_array.v[word_idx] |= (1 << bit_idx); + bit_array.v[word_idx] |= (1u << bit_idx); } else { - bit_array.v[word_idx] &= ~(1 << bit_idx); + bit_array.v[word_idx] &= ~(1u << bit_idx); } } @@ -269,7 +269,7 @@ bit_array_is_bit_set(U32Array bit_arr, U64 bit_pos) Assert(word_idx < bit_arr.count); U32 word = bit_arr.v[word_idx]; U64 bit_idx = bit_pos % 32; - B32 is_set = !!(word & (1 << bit_idx)); + B32 is_set = !!(word & (1u << bit_idx)); return is_set; } diff --git a/src/linker/codeview_ext/codeview.c b/src/linker/codeview_ext/codeview.c index 4dceeaa2..ba22e2e8 100644 --- a/src/linker/codeview_ext/codeview.c +++ b/src/linker/codeview_ext/codeview.c @@ -170,17 +170,18 @@ cv_deserial_leaf(String8 raw_data, U64 off, U64 align, CV_Leaf *leaf_out) // do we have enough bytes to read header? Assert(raw_data.size >= sizeof(CV_LeafHeader)); - CV_LeafHeader *header = (CV_LeafHeader*)(raw_data.str + off); + StaticAssert(sizeof(CV_LeafHeader) == 4, g_leaf_header_size_check); + CV_LeafHeader header = { .v = memory_read32(raw_data.str + off) }; // leaf size must have enough bytes for the kind enum - Assert(header->size >= sizeof(CV_LeafKind)); + Assert(header.size >= sizeof(CV_LeafKind)); // do we have enough bytes to read leaf data? - Assert(sizeof(CV_LeafSize) + header->size <= raw_data.size); + Assert(sizeof(CV_LeafSize) + header.size <= raw_data.size); // fill out leaf - leaf_out->kind = header->kind; - leaf_out->data = str8(raw_data.str + sizeof(CV_LeafHeader), header->size - sizeof(CV_LeafKind)); + leaf_out->kind = header.kind; + leaf_out->data = str8(raw_data.str + sizeof(CV_LeafHeader), header.size - sizeof(CV_LeafKind)); U64 leaf_size = AlignPow2(sizeof(CV_LeafHeader) + leaf_out->data.size, align); Assert(leaf_size <= raw_data.size); @@ -449,12 +450,20 @@ cv_parse_debug_s_c13_list(Arena *arena, String8List raw_debug_s) return debug_s; } +internal force_inline UBSAN_NO_ALIGN CV_Signature +cv_signature_from_debug_s(String8 raw_debug_s) +{ + CV_Signature sig; + MemoryCopy(&sig, raw_debug_s.str, sizeof(sig)); + return sig; +} + internal CV_DebugS cv_parse_debug_s(Arena *arena, String8 raw_debug_s) { CV_DebugS result; MemoryZeroStruct(&result); if (raw_debug_s.size >= sizeof(CV_Signature)) { - CV_Signature sig = *(CV_Signature *)raw_debug_s.str; + CV_Signature sig = cv_signature_from_debug_s(raw_debug_s); switch (sig) { case CV_Signature_C13: { String8 raw_debug_s_past_sig = str8_substr(raw_debug_s, r1u64(sizeof(sig), raw_debug_s.size)); @@ -1130,11 +1139,9 @@ internal String8 cv_debug_t_get_raw_leaf(CV_DebugT debug_t, U64 leaf_idx) { Assert(leaf_idx < debug_t.count); - U8 *leaf_ptr = debug_t.v[leaf_idx]; - CV_LeafSize *size_ptr = (CV_LeafSize *)leaf_ptr; - CV_LeafSize total_size = sizeof(*size_ptr) + *size_ptr; - String8 raw_leaf = str8(leaf_ptr, total_size); - return raw_leaf; + U8 *leaf_ptr = debug_t.v[leaf_idx]; + CV_LeafSize size = memory_read16(debug_t.v[leaf_idx]); + return str8(leaf_ptr, sizeof(size) + size); } internal CV_LeafHeader * @@ -1474,19 +1481,16 @@ cv_symbol_tree_from_symbol_list(Arena *arena, CV_SymbolList list) internal U64 cv_patch_symbol_tree_offsets(CV_SymbolList list, U64 base_offset, U64 align) { - Temp scratch = scratch_begin(0, 0); - struct Stack { struct Stack *next; CV_Symbol *symbol; U64 offset; }; + Temp scratch = scratch_begin(0, 0); struct Stack *stack = 0; struct Stack *free_list = 0; - - U64 cursor = base_offset; - - for (CV_SymbolNode *symbol_n = list.first; symbol_n != 0; symbol_n = symbol_n->next) { + U32 cursor = safe_cast_u32(base_offset); + for EachNode(symbol_n, CV_SymbolNode, list.first) { CV_Symbol symbol = symbol_n->data; if (cv_is_scope_symbol(symbol.kind)) { // NOTE: We don't patch 'next' offset in PROC symbols because @@ -1494,10 +1498,9 @@ cv_patch_symbol_tree_offsets(CV_SymbolList list, U64 base_offset, U64 align) // zeroed. LLD is on the same page. Assert(symbol.data.size >= sizeof(U32)*2); - // patch symbol parent + // patch parent symbol offset if (stack) { - U32 *parent_off_ptr = (U32 *)symbol.data.str; - *parent_off_ptr = stack->offset; + memory_write32(symbol.data.str, stack->offset); } // reuse/alloc frame @@ -1516,7 +1519,7 @@ cv_patch_symbol_tree_offsets(CV_SymbolList list, U64 base_offset, U64 align) } else if (cv_is_end_symbol(symbol.kind)) { // patch symbol end U32 *end_off_ptr = (U32 *)stack->symbol->data.str + /* skip parent off */ 1; - *end_off_ptr = cursor; + memory_write32(end_off_ptr, cursor); // recycle frame struct Stack *free_frame = stack; diff --git a/src/linker/codeview_ext/codeview.h b/src/linker/codeview_ext/codeview.h index 421af3c2..db8ad632 100644 --- a/src/linker/codeview_ext/codeview.h +++ b/src/linker/codeview_ext/codeview.h @@ -5,10 +5,13 @@ //- Symbol and Leaf Headers -typedef struct CV_LeafHeader +typedef union CV_LeafHeader { - CV_LeafSize size; - CV_LeafKind kind; + struct { + CV_LeafSize size; + CV_LeafKind kind; + }; + U32 v; } CV_LeafHeader; typedef struct CV_SymbolHeader @@ -404,6 +407,7 @@ internal CV_SymbolList cv_make_proc_refs(Arena *arena, CV_ModIndex imod, CV_Symb internal CV_DebugS cv_parse_debug_s_c13(Arena *arena, String8 raw_debug_s); internal CV_DebugS cv_parse_debug_s_c13_list(Arena *arena, String8List raw_debug_s); +internal CV_Signature cv_signature_from_debug_s(String8 raw_debug_s); internal CV_DebugS cv_parse_debug_s(Arena *arena, String8 raw_debug_s); internal void cv_debug_s_concat_in_place(CV_DebugS *dst, CV_DebugS *src); internal String8List cv_data_c13_from_debug_s(Arena *arena, CV_DebugS *debug_s, B32 write_sig); diff --git a/src/linker/lnk.c b/src/linker/lnk.c index e3a35416..cac11a07 100644 --- a/src/linker/lnk.c +++ b/src/linker/lnk.c @@ -1635,9 +1635,10 @@ lnk_link_inputs(TP_Context *tp, LNK_Lib *lib = member_ref->lib; LNK_Symbol *link_symbol = member_ref->link_symbol; - COFF_ArchiveMember member_info = coff_archive_member_from_offset(lib->data, lib->member_offsets[member_ref->member_idx]); - COFF_DataType member_type = coff_data_type_from_data(member_info.data); - String8 member_name = coff_decode_member_name(lib->long_names, member_info.header.name); + U32 member_offset = memory_read32(lib->member_offsets + member_ref->member_idx); + COFF_ArchiveMember member_info = coff_archive_member_from_offset(lib->data, member_offset); + COFF_DataType member_type = coff_data_type_from_data(member_info.data); + String8 member_name = coff_decode_member_name(lib->long_names, member_info.header.name); U64 refs_count = 0; LNK_ObjSymbolRef **refs = lnk_ref_from_symbol_many(temp.arena, link_symbol, &refs_count); @@ -1656,9 +1657,10 @@ lnk_link_inputs(TP_Context *tp, U64 member_idx = member_ref->member_idx; // parse member info - COFF_ArchiveMember member_info = coff_archive_member_from_offset(lib->data, lib->member_offsets[member_idx]); - COFF_DataType member_type = coff_data_type_from_data(member_info.data); - String8 member_name = coff_decode_member_name(lib->long_names, member_info.header.name); + U32 member_offset = memory_read32(lib->member_offsets + member_idx); + COFF_ArchiveMember member_info = coff_archive_member_from_offset(lib->data, member_offset); + COFF_DataType member_type = coff_data_type_from_data(member_info.data); + String8 member_name = coff_decode_member_name(lib->long_names, member_info.header.name); switch (member_type) { case COFF_DataType_Import: { @@ -1809,7 +1811,8 @@ lnk_link_image(TP_Context *tp, TP_Arena *arena, LNK_Config *config, LNK_Inputer LNK_LibMemberInfo *member_infos = hash_table_search_raw_raw(link->lib_member_infos_ht, lib); LNK_Symbol *link_symbol = member_infos[member_idx].link; - COFF_ArchiveMember member_info = coff_archive_member_from_offset(lib->data, lib->member_offsets[member_idx]); + U32 member_offset = memory_read32(lib->member_offsets + member_idx); + COFF_ArchiveMember member_info = coff_archive_member_from_offset(lib->data, member_offset); COFF_DataType member_type = coff_data_type_from_data(member_info.data); String8 member_name = coff_decode_member_name(lib->long_names, member_info.header.name); COFF_ParsedArchiveImportHeader import_header = coff_archive_import_from_data(member_info.data); diff --git a/src/linker/lnk_debug_info.c b/src/linker/lnk_debug_info.c index 74a53a95..fd10a371 100644 --- a/src/linker/lnk_debug_info.c +++ b/src/linker/lnk_debug_info.c @@ -80,8 +80,8 @@ THREAD_POOL_TASK_FUNC(lnk_check_debug_t_sig_and_get_data_task) lnk_error_obj(LNK_Error_IllData, obj, ".debug$T must have at least 4 bytes for CodeView signature"); } - CV_Signature *sig_ptr = (CV_Signature *)data_ptr->str; - switch (*sig_ptr) { + CV_Signature sig = cv_signature_from_debug_s(*data_ptr); + switch (sig) { default: { lnk_error_obj(LNK_Warning_IllData, obj, "unknown CodeView type signature in section (TODO: print section index)"); *data_ptr = str8(0,0); @@ -1172,7 +1172,7 @@ lnk_hash_cv_leaf(Arena *arena, // mix-in sub leaf hashes for (CV_TypeIndexInfo *ti_n = ti_info_list.first; ti_n != 0; ti_n = ti_n->next) { - CV_TypeIndex sub_ti = *(CV_TypeIndex *) (leaf.data.str + ti_n->offset); + CV_TypeIndex sub_ti = memory_read32(leaf.data.str + ti_n->offset); // is type index complex? if (sub_ti >= ti_ranges[ti_n->source].min) { @@ -1278,12 +1278,13 @@ lnk_hash_cv_leaf_deep(Arena *arena, // get type index info CV_TypeIndex *ti_ptr = (CV_TypeIndex *) (stack->data.str + curr_ti_info->offset); + CV_TypeIndex ti = memory_read32(ti_ptr); // is index complex? - if (*ti_ptr >= ti_ranges[curr_ti_info->source].min) { + if (ti >= ti_ranges[curr_ti_info->source].min) { // TODO: handle malformed index - AssertAlways(*ti_ptr < ti_ranges[curr_ti_info->source].max); - U64 ti_idx = (*ti_ptr - ti_ranges[curr_ti_info->source].min); + AssertAlways(ti < ti_ranges[curr_ti_info->source].max); + U64 ti_idx = (ti - ti_ranges[curr_ti_info->source].min); // was leaf hashed? if (curr_hashes[curr_ti_info->source][ti_idx] == 0) { // :zero_hash_array @@ -1301,7 +1302,7 @@ lnk_hash_cv_leaf_deep(Arena *arena, frame->ti_info = sub_ti_info_list.first; frame->leaf = leaf; frame->data = leaf.data; - frame->ti = *ti_ptr; + frame->ti = ti; frame->ti_source = curr_ti_info->source; // recurse to sub leaf @@ -1443,7 +1444,8 @@ THREAD_POOL_TASK_FUNC(lnk_count_per_source_leaf_task) CV_DebugT debug_t = *leaf_range->debug_t; for EachInRange(leaf_idx, leaf_range->range) { CV_LeafHeader *leaf_header = cv_debug_t_get_leaf_header(debug_t, leaf_idx); - CV_TypeIndexSource leaf_source = cv_type_index_source_from_leaf_kind(leaf_header->kind); + CV_LeafKind kind = memory_read16(MemberFromPtr(CV_LeafHeader, leaf_header, kind)); + CV_TypeIndexSource leaf_source = cv_type_index_source_from_leaf_kind(kind); counts[leaf_source] += 1; } } @@ -1550,7 +1552,8 @@ THREAD_POOL_TASK_FUNC(lnk_leaf_dedup_internal_task) LNK_LeafRef *bucket = 0; for EachIndex(leaf_idx, debug_t.count) { CV_LeafHeader *leaf_header = cv_debug_t_get_leaf_header(debug_t, leaf_idx); - CV_TypeIndexSource ti_source = cv_type_index_source_from_leaf_kind(leaf_header->kind); + CV_LeafKind leaf_kind = memory_read16(MemberFromPtr(CV_LeafHeader, leaf_header, kind)); + CV_TypeIndexSource ti_source = cv_type_index_source_from_leaf_kind(leaf_kind); LNK_LeafHashTable *leaf_ht = &task->leaf_ht_arr[ti_source]; LNK_LeafRef leaf_ref = lnk_obj_leaf_ref(obj_idx, leaf_idx); @@ -1974,25 +1977,26 @@ THREAD_POOL_TASK_FUNC(lnk_cv_patcher_symbols_task) // overwrite type indices in symbol for EachNode(ti_info, CV_TypeIndexInfo, ti_info_list.first) { CV_TypeIndex *ti_ptr = (CV_TypeIndex *)(symbol_n->data.data.str + ti_info->offset); + CV_TypeIndex ti = memory_read32(ti_ptr); // skip simple type indices - if (*ti_ptr < ti_lo_arr[ti_info->source]) { continue; } + if (ti < ti_lo_arr[ti_info->source]) { continue; } - U64 assigned_types_cap = task->assigned_type_caps[ti_info->source]; - CV_TypeIndex *assigned_types_ht = task->assigned_type_hts[ti_info->source]; - CV_TypeIndex min_type_index = task->min_type_indices[ti_info->source]; - LNK_LeafRefArray unique_leaf_refs = task->unique_leaf_refs_arr[ti_info->source]; + U64 assigned_types_cap = task->assigned_type_caps [ti_info->source]; + CV_TypeIndex *assigned_types_ht = task->assigned_type_hts [ti_info->source]; + CV_TypeIndex min_type_index = task->min_type_indices [ti_info->source]; + LNK_LeafRefArray unique_leaf_refs = task->unique_leaf_refs_arr[ti_info->source]; + LNK_LeafHashTable *leaf_ht = &task->leaf_ht_arr [ti_info->source]; // find unique leaf refernece - LNK_LeafHashTable *leaf_ht = &task->leaf_ht_arr[ti_info->source]; - LNK_LeafRef leaf_ref = lnk_leaf_ref_from_loc_idx_and_ti(task->input, loc_type, ti_info->source, loc_idx, *ti_ptr); + LNK_LeafRef leaf_ref = lnk_leaf_ref_from_loc_idx_and_ti(task->input, loc_type, ti_info->source, loc_idx, ti); LNK_LeafRef *leaf_ref_unique = lnk_leaf_hash_table_search(leaf_ht, task->input, task->hashes, leaf_ref); U64 leaf_ref_unique_hash = u64_hash_from_str8(str8_struct(&leaf_ref_unique)); - CV_TypeIndex type_index = lnk_assigned_type_ht_search(assigned_types_cap, assigned_types_ht, min_type_index, unique_leaf_refs, leaf_ref_unique, leaf_ref_unique_hash); + CV_TypeIndex final_ti = lnk_assigned_type_ht_search(assigned_types_cap, assigned_types_ht, min_type_index, unique_leaf_refs, leaf_ref_unique, leaf_ref_unique_hash); // we overwrite section memory directly - *ti_ptr = type_index; + memory_write32(ti_ptr, final_ti); } temp_end(temp); @@ -2022,26 +2026,27 @@ THREAD_POOL_TASK_FUNC(lnk_cv_patcher_inlines_task) for EachNode(ti_info, CV_TypeIndexInfo, ti_info_list.first) { CV_TypeIndex *ti_ptr = (CV_TypeIndex *)(inline_data_node->string.str + ti_info->offset); - CV_TypeIndex ti_lo = lnk_ti_lo_from_loc(task->input, loc_type, loc_idx, ti_info->source); + CV_TypeIndex ti = memory_read32(ti_ptr); // skip simple type indices - if (*ti_ptr < ti_lo) { continue; } + CV_TypeIndex ti_lo = lnk_ti_lo_from_loc(task->input, loc_type, loc_idx, ti_info->source); + if (ti < ti_lo) { continue; } - U64 assigned_types_cap = task->assigned_type_caps[ti_info->source]; - CV_TypeIndex *assigned_types_ht = task->assigned_type_hts[ti_info->source]; - CV_TypeIndex min_type_index = task->min_type_indices[ti_info->source]; - LNK_LeafRefArray unique_leaf_refs = task->unique_leaf_refs_arr[ti_info->source]; + U64 assigned_types_cap = task->assigned_type_caps [ti_info->source]; + CV_TypeIndex *assigned_types_ht = task->assigned_type_hts [ti_info->source]; + CV_TypeIndex min_type_index = task->min_type_indices [ti_info->source]; + LNK_LeafRefArray unique_leaf_refs = task->unique_leaf_refs_arr[ti_info->source]; + LNK_LeafHashTable *leaf_ht = &task->leaf_ht_arr [ti_info->source]; // find unique leaf refernece - LNK_LeafHashTable *leaf_ht = &task->leaf_ht_arr[ti_info->source]; - LNK_LeafRef leaf_ref = lnk_leaf_ref_from_loc_idx_and_ti(task->input, loc_type, ti_info->source, loc_idx, *ti_ptr); + LNK_LeafRef leaf_ref = lnk_leaf_ref_from_loc_idx_and_ti(task->input, loc_type, ti_info->source, loc_idx, ti); LNK_LeafRef *leaf_ref_unique = lnk_leaf_hash_table_search(leaf_ht, task->input, task->hashes, leaf_ref); U64 leaf_ref_unique_hash = u64_hash_from_str8(str8_struct(&leaf_ref_unique)); - CV_TypeIndex type_index = lnk_assigned_type_ht_search(assigned_types_cap, assigned_types_ht, min_type_index, unique_leaf_refs, leaf_ref_unique, leaf_ref_unique_hash); + CV_TypeIndex final_ti = lnk_assigned_type_ht_search(assigned_types_cap, assigned_types_ht, min_type_index, unique_leaf_refs, leaf_ref_unique, leaf_ref_unique_hash); // patch index - *ti_ptr = type_index; + memory_write32(ti_ptr, final_ti); } temp_end(temp); @@ -2074,25 +2079,26 @@ THREAD_POOL_TASK_FUNC(lnk_cv_patcher_leaves_task) for EachNode(ti_info, CV_TypeIndexInfo, ti_info_list.first) { CV_TypeIndex *ti_ptr = (CV_TypeIndex *)(leaf.data.str + ti_info->offset); + CV_TypeIndex ti = memory_read32(ti_ptr); // skip simple type indices - if (*ti_ptr < ti_lo) { continue; } + if (ti < ti_lo) { continue; } - U64 assigned_types_cap = task->assigned_type_caps[ti_info->source]; - CV_TypeIndex *assigned_types_ht = task->assigned_type_hts[ti_info->source]; - CV_TypeIndex min_type_index = task->min_type_indices[ti_info->source]; - LNK_LeafRefArray unique_leaf_refs = task->unique_leaf_refs_arr[ti_info->source]; + U64 assigned_types_cap = task->assigned_type_caps [ti_info->source]; + CV_TypeIndex *assigned_types_ht = task->assigned_type_hts [ti_info->source]; + CV_TypeIndex min_type_index = task->min_type_indices [ti_info->source]; + LNK_LeafRefArray unique_leaf_refs = task->unique_leaf_refs_arr[ti_info->source]; + LNK_LeafHashTable *leaf_ht = &task->leaf_ht_arr [ti_info->source]; - // find unique leaf refernece - LNK_LeafHashTable *leaf_ht = &task->leaf_ht_arr[ti_info->source]; - LNK_LeafRef leaf_ref = lnk_leaf_ref_from_loc_idx_and_ti(task->input, loc_type, ti_info->source, loc_idx, *ti_ptr); + // find unique leaf ref + LNK_LeafRef leaf_ref = lnk_leaf_ref_from_loc_idx_and_ti(task->input, loc_type, ti_info->source, loc_idx, ti); LNK_LeafRef *leaf_ref_unique = lnk_leaf_hash_table_search(leaf_ht, task->input, task->hashes, leaf_ref); U64 leaf_ref_unique_hash = u64_hash_from_str8(str8_struct(&leaf_ref_unique)); - CV_TypeIndex type_index = lnk_assigned_type_ht_search(assigned_types_cap, assigned_types_ht, min_type_index, unique_leaf_refs, leaf_ref_unique, leaf_ref_unique_hash); + CV_TypeIndex final_ti = lnk_assigned_type_ht_search(assigned_types_cap, assigned_types_ht, min_type_index, unique_leaf_refs, leaf_ref_unique, leaf_ref_unique_hash); // patch index - *ti_ptr = type_index; + memory_write32(ti_ptr, final_ti); } temp_end(temp); diff --git a/src/linker/lnk_debug_info.h b/src/linker/lnk_debug_info.h index d9461fd1..61f34cfa 100644 --- a/src/linker/lnk_debug_info.h +++ b/src/linker/lnk_debug_info.h @@ -69,8 +69,8 @@ typedef enum LNK_LeafLocType_Count } LNK_LeafLocType; -#define LNK_LeafRefFlag_LocIdxExternal (1 << 31) -#define LNK_LeafRefFlag_LeafIdxIPI (1 << 31) +#define LNK_LeafRefFlag_LocIdxExternal (1u << 31) +#define LNK_LeafRefFlag_LeafIdxIPI (1u << 31) typedef struct { U32 enc_loc_idx; diff --git a/src/linker/lnk_lib.h b/src/linker/lnk_lib.h index 79b682c7..eed5e2de 100644 --- a/src/linker/lnk_lib.h +++ b/src/linker/lnk_lib.h @@ -66,5 +66,5 @@ internal LNK_Lib ** lnk_array_from_lib_list(Arena *arena, LNK_LibList list internal void lnk_lib_list_push_node(LNK_LibList *list, LNK_LibNode *node); internal LNK_LibNodeArray lnk_lib_list_push_parallel(TP_Context *tp, TP_Arena *arena, LNK_LibList *list, U64 inputs_count, struct LNK_Input **inputs); -internal B32 lnk_search_lib(LNK_Lib *lib, String8 symbol_name, U32 *member_idx_out); +internal force_inline B32 lnk_search_lib(LNK_Lib *lib, String8 symbol_name, U32 *member_idx_out); diff --git a/src/linker/pdb_ext/pdb_builder.c b/src/linker/pdb_ext/pdb_builder.c index d1c80b5d..b20901e6 100644 --- a/src/linker/pdb_ext/pdb_builder.c +++ b/src/linker/pdb_ext/pdb_builder.c @@ -2384,7 +2384,7 @@ gsi_build_ex(TP_Context *tp, Arena *arena, PDB_GsiContext *gsi, U64 symbol_data_ if (bucket_list.count) { U64 word_idx = bucket_idx / gsi->word_size; Assert(word_idx < bitmap_count); - bitmap[word_idx] |= 1 << (bucket_idx % gsi->word_size); + bitmap[word_idx] |= 1u << (bucket_idx % gsi->word_size); compressed_offset_arr[compressed_offset_count] = hash_idx * sizeof(PDB_GsiHashRecordOffsetCalc); // store in-memory offset for first bucket compressed_offset_count += 1; } diff --git a/src/metagen/metagen_base/metagen_base_core.h b/src/metagen/metagen_base/metagen_base_core.h index 191e1e7f..a56382a0 100644 --- a/src/metagen/metagen_base/metagen_base_core.h +++ b/src/metagen/metagen_base/metagen_base_core.h @@ -290,9 +290,9 @@ CheckNil(nil,p) ? \ #if COMPILER_MSVC # if defined(__SANITIZE_ADDRESS__) # define ASAN_ENABLED 1 -# define NO_ASAN __declspec(no_sanitize_address) +# define ASAN_NO_ADDR __declspec(no_sanitize_address) # else -# define NO_ASAN +# define ASAN_NO_ADDR # endif #elif COMPILER_CLANG # if defined(__has_feature) @@ -300,9 +300,9 @@ CheckNil(nil,p) ? \ # define ASAN_ENABLED 1 # endif # endif -# define NO_ASAN __attribute__((no_sanitize("address"))) +# define ASAN_NO_ADDR __attribute__((no_sanitize("address"))) #else -# define NO_ASAN +# define ASAN_NO_ADDR #endif #if ASAN_ENABLED diff --git a/src/pdb/pdb.c b/src/pdb/pdb.c index 035ca375..e334f51c 100644 --- a/src/pdb/pdb.c +++ b/src/pdb/pdb.c @@ -6,18 +6,17 @@ pdb_hash_v1(String8 string) { U32 result = 0; U8 *ptr = string.str; - U8 *opl = ptr + (string.size&(~3)); - for(; ptr < opl; ptr += 4) + for(U8 *opl = ptr + (string.size & (~3)); ptr < opl; ptr += 4) { - result ^= *(U32*)ptr; + result ^= memory_read32(ptr); } - if((string.size&2) != 0) + if((string.size & 2) != 0) { - result ^= *(U16*)ptr; ptr += 2; + result ^= memory_read16(ptr); ptr += 2; } - if((string.size&1) != 0) + if((string.size & 1) != 0) { - result ^= *ptr; + result ^= memory_read8(ptr); } result |= 0x20202020; result ^= (result >> 11); diff --git a/src/third_party/stb/stb_sprintf.h b/src/third_party/stb/stb_sprintf.h index 515ba6c5..7614dfbf 100644 --- a/src/third_party/stb/stb_sprintf.h +++ b/src/third_party/stb/stb_sprintf.h @@ -436,7 +436,7 @@ cl = lg; \ } else #endif { - *(stbsp__uint32 *)bf = v; + memory_write32(bf, v); } bf += 4; f += 4;