From ad4003e70dfc2fb2209aafa1e348ad28cbc2e673 Mon Sep 17 00:00:00 2001 From: Ryan Fleury Date: Mon, 12 Feb 2024 15:17:23 -0800 Subject: [PATCH] cons -> raddbgic --- README.md | 2 +- src/raddbg/raddbg.c | 2 +- src/raddbgi_cons/raddbgi_cons.c | 1288 ++++++++--------- src/raddbgi_cons/raddbgi_cons.h | 782 +++++----- src/raddbgi_convert/pdb/raddbgi_from_pdb.c | 416 +++--- src/raddbgi_convert/pdb/raddbgi_from_pdb.h | 54 +- .../pdb/raddbgi_from_pdb_main.c | 2 +- 7 files changed, 1273 insertions(+), 1273 deletions(-) diff --git a/README.md b/README.md index 2725e66c..a7f465a3 100644 --- a/README.md +++ b/README.md @@ -292,7 +292,7 @@ A list of the layers in the codebase and their associated namespaces is below: - `raddbg_markup` (`RADDBG_`): Standalone header file for marking up user programs to work with various features in the `raddbg` debugger. Does not depend on `base`. -- `raddbgi_cons` (`CONS_`): Implements an API for constructing files of the +- `raddbgi_cons` (`RADDBGIC_`): Implements an API for constructing files of the RADDBGI debug info file format. - `raddbgi_dump` (`DUMP_`): A dumper utility program for dumping textualizations of RADDBGI debug info files. diff --git a/src/raddbg/raddbg.c b/src/raddbg/raddbg.c index 88f48b56..6ced157b 100644 --- a/src/raddbg/raddbg.c +++ b/src/raddbg/raddbg.c @@ -634,7 +634,7 @@ entry_point(int argc, char **argv) if(out != 0 && params->output_name.size > 0) { String8List baked = {0}; - cons_bake_file(scratch.arena, out->root, &baked); + raddbgic_bake_file(scratch.arena, out->root, &baked); U64 off = 0; for(String8Node *node = baked.first; node != 0; node = node->next) { diff --git a/src/raddbgi_cons/raddbgi_cons.c b/src/raddbgi_cons/raddbgi_cons.c index 17612767..219cea0e 100644 --- a/src/raddbgi_cons/raddbgi_cons.c +++ b/src/raddbgi_cons/raddbgi_cons.c @@ -4,8 +4,8 @@ //////////////////////////////// //~ rjf: API Implementation Helper Macros -#define cons_require(root, b32, else_code, error_msg) do { if(!(b32)) {cons_error((root), (error_msg)); else_code;} }while(0) -#define cons_requiref(root, b32, else_code, fmt, ...) do { if(!(b32)) {cons_errorf((root), (fmt), __VA_ARGS__); else_code;} }while(0) +#define raddbgic_require(root, b32, else_code, error_msg) do { if(!(b32)) {raddbgic_error((root), (error_msg)); else_code;} }while(0) +#define raddbgic_requiref(root, b32, else_code, fmt, ...) do { if(!(b32)) {raddbgic_errorf((root), (fmt), __VA_ARGS__); else_code;} }while(0) //////////////////////////////// //~ rjf: Basic Type Helpers @@ -13,9 +13,9 @@ //- rjf: type lists static void -cons_type_list_push(Arena *arena, CONS_TypeList *list, CONS_Type *type) +raddbgic_type_list_push(Arena *arena, RADDBGIC_TypeList *list, RADDBGIC_Type *type) { - CONS_TypeNode *node = push_array(arena, CONS_TypeNode, 1); + RADDBGIC_TypeNode *node = push_array(arena, RADDBGIC_TypeNode, 1); SLLQueuePush(list->first, list->last, node); list->count += 1; node->type = type; @@ -24,12 +24,12 @@ cons_type_list_push(Arena *arena, CONS_TypeList *list, CONS_Type *type) //- rjf: bytecode lists static void -cons_bytecode_push_op(Arena *arena, CONS_EvalBytecode *bytecode, RADDBGI_EvalOp op, U64 p) +raddbgic_bytecode_push_op(Arena *arena, RADDBGIC_EvalBytecode *bytecode, RADDBGI_EvalOp op, U64 p) { U8 ctrlbits = raddbgi_eval_opcode_ctrlbits[op]; U32 p_size = RADDBGI_DECODEN_FROM_CTRLBITS(ctrlbits); - CONS_EvalBytecodeOp *node = push_array(arena, CONS_EvalBytecodeOp, 1); + RADDBGIC_EvalBytecodeOp *node = push_array(arena, RADDBGIC_EvalBytecodeOp, 1); node->op = op; node->p_size = p_size; node->p = p; @@ -40,52 +40,52 @@ cons_bytecode_push_op(Arena *arena, CONS_EvalBytecode *bytecode, RADDBGI_EvalOp } static void -cons_bytecode_push_uconst(Arena *arena, CONS_EvalBytecode *bytecode, U64 x) +raddbgic_bytecode_push_uconst(Arena *arena, RADDBGIC_EvalBytecode *bytecode, U64 x) { if(x <= 0xFF) { - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU8, x); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU8, x); } else if(x <= 0xFFFF) { - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU16, x); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU16, x); } else if(x <= 0xFFFFFFFF) { - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU32, x); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU32, x); } else { - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU64, x); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU64, x); } } static void -cons_bytecode_push_sconst(Arena *arena, CONS_EvalBytecode *bytecode, S64 x) +raddbgic_bytecode_push_sconst(Arena *arena, RADDBGIC_EvalBytecode *bytecode, S64 x) { if(-0x80 <= x && x <= 0x7F) { - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU8, (U64)x); - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_TruncSigned, 8); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU8, (U64)x); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_TruncSigned, 8); } else if(-0x8000 <= x && x <= 0x7FFF) { - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU16, (U64)x); - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_TruncSigned, 16); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU16, (U64)x); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_TruncSigned, 16); } else if(-0x80000000ll <= x && x <= 0x7FFFFFFFll) { - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU32, (U64)x); - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_TruncSigned, 32); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU32, (U64)x); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_TruncSigned, 32); } else { - cons_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU64, (U64)x); + raddbgic_bytecode_push_op(arena, bytecode, RADDBGI_EvalOp_ConstU64, (U64)x); } } static void -cons_bytecode_concat_in_place(CONS_EvalBytecode *left_dst, CONS_EvalBytecode *right_destroyed) +raddbgic_bytecode_concat_in_place(RADDBGIC_EvalBytecode *left_dst, RADDBGIC_EvalBytecode *right_destroyed) { if(right_destroyed->first_op != 0) { @@ -105,8 +105,8 @@ cons_bytecode_concat_in_place(CONS_EvalBytecode *left_dst, CONS_EvalBytecode *ri //- rjf: sortable range sorting -static CONS_SortKey* -cons_sort_key_array(Arena *arena, CONS_SortKey *keys, U64 count) +static RADDBGIC_SortKey* +raddbgic_sort_key_array(Arena *arena, RADDBGIC_SortKey *keys, U64 count) { // This sort is designed to take advantage of lots of pre-existing sorted ranges. // Most line info is already sorted or close to already sorted. @@ -114,9 +114,9 @@ cons_sort_key_array(Arena *arena, CONS_SortKey *keys, U64 count) // Also - this sort should be a "stable" sort. In the use case of sorting vmap // ranges, we want to be able to rely on order, so it needs to be preserved here. - ProfBegin("cons_sort_key_array"); + ProfBegin("raddbgic_sort_key_array"); Temp scratch = scratch_begin(&arena, 1); - CONS_SortKey *result = 0; + RADDBGIC_SortKey *result = 0; if(count <= 1) { @@ -124,8 +124,8 @@ cons_sort_key_array(Arena *arena, CONS_SortKey *keys, U64 count) } else { - CONS_OrderedRange *ranges_first = 0; - CONS_OrderedRange *ranges_last = 0; + RADDBGIC_OrderedRange *ranges_first = 0; + RADDBGIC_OrderedRange *ranges_last = 0; U64 range_count = 0; { U64 pos = 0; @@ -137,7 +137,7 @@ cons_sort_key_array(Arena *arena, CONS_SortKey *keys, U64 count) for(; opl < count && keys[opl - 1].key <= keys[opl].key; opl += 1); // generate an ordered range node - CONS_OrderedRange *new_range = push_array(scratch.arena, CONS_OrderedRange, 1); + RADDBGIC_OrderedRange *new_range = push_array(scratch.arena, RADDBGIC_OrderedRange, 1); SLLQueuePush(ranges_first, ranges_last, new_range); range_count += 1; new_range->first = first; @@ -154,12 +154,12 @@ cons_sort_key_array(Arena *arena, CONS_SortKey *keys, U64 count) } else { - CONS_SortKey *keys_swap = push_array_no_zero(arena, CONS_SortKey, count); - CONS_SortKey *src = keys; - CONS_SortKey *dst = keys_swap; - CONS_OrderedRange *src_ranges = ranges_first; - CONS_OrderedRange *dst_ranges = 0; - CONS_OrderedRange *dst_ranges_last = 0; + RADDBGIC_SortKey *keys_swap = push_array_no_zero(arena, RADDBGIC_SortKey, count); + RADDBGIC_SortKey *src = keys; + RADDBGIC_SortKey *dst = keys_swap; + RADDBGIC_OrderedRange *src_ranges = ranges_first; + RADDBGIC_OrderedRange *dst_ranges = 0; + RADDBGIC_OrderedRange *dst_ranges_last = 0; for(;;) { @@ -173,7 +173,7 @@ cons_sort_key_array(Arena *arena, CONS_SortKey *keys, U64 count) } // get first range - CONS_OrderedRange *range1 = src_ranges; + RADDBGIC_OrderedRange *range1 = src_ranges; SLLStackPop(src_ranges); // if this range is the whole array, we are done @@ -193,7 +193,7 @@ cons_sort_key_array(Arena *arena, CONS_SortKey *keys, U64 count) } // get second range - CONS_OrderedRange *range2 = src_ranges; + RADDBGIC_OrderedRange *range2 = src_ranges; SLLStackPop(src_ranges); Assert(range1->opl == range2->first); @@ -242,7 +242,7 @@ cons_sort_key_array(Arena *arena, CONS_SortKey *keys, U64 count) } // end pass by swapping buffers and range nodes - Swap(CONS_SortKey*, src, dst); + Swap(RADDBGIC_SortKey*, src, dst); src_ranges = dst_ranges; dst_ranges = 0; dst_ranges_last = 0; @@ -270,18 +270,18 @@ cons_sort_key_array(Arena *arena, CONS_SortKey *keys, U64 count) //- rjf: u64 -> ptr map static void -cons_u64toptr_init(Arena *arena, CONS_U64ToPtrMap *map, U64 bucket_count) +raddbgic_u64toptr_init(Arena *arena, RADDBGIC_U64ToPtrMap *map, U64 bucket_count) { Assert(IsPow2OrZero(bucket_count) && bucket_count > 0); - map->buckets = push_array(arena, CONS_U64ToPtrNode*, bucket_count); + map->buckets = push_array(arena, RADDBGIC_U64ToPtrNode*, bucket_count); map->buckets_count = bucket_count; } static void -cons_u64toptr_lookup(CONS_U64ToPtrMap *map, U64 key, U64 hash, CONS_U64ToPtrLookup *lookup_out) +raddbgic_u64toptr_lookup(RADDBGIC_U64ToPtrMap *map, U64 key, U64 hash, RADDBGIC_U64ToPtrLookup *lookup_out) { U64 bucket_idx = hash&(map->buckets_count - 1); - CONS_U64ToPtrNode *check_node = map->buckets[bucket_idx]; + RADDBGIC_U64ToPtrNode *check_node = map->buckets[bucket_idx]; for(;check_node != 0; check_node = check_node->next){ for(U32 k = 0; k < ArrayCount(check_node->key); k += 1){ if(check_node->ptr[k] == 0){ @@ -298,11 +298,11 @@ cons_u64toptr_lookup(CONS_U64ToPtrMap *map, U64 key, U64 hash, CONS_U64ToPtrLook } static void -cons_u64toptr_insert(Arena *arena, CONS_U64ToPtrMap *map, U64 key, U64 hash, CONS_U64ToPtrLookup *lookup, void *ptr) +raddbgic_u64toptr_insert(Arena *arena, RADDBGIC_U64ToPtrMap *map, U64 key, U64 hash, RADDBGIC_U64ToPtrLookup *lookup, void *ptr) { if(lookup->fill_node != 0) { - CONS_U64ToPtrNode *node = lookup->fill_node; + RADDBGIC_U64ToPtrNode *node = lookup->fill_node; U32 k = lookup->fill_k; node->key[k] = key; node->ptr[k] = ptr; @@ -311,7 +311,7 @@ cons_u64toptr_insert(Arena *arena, CONS_U64ToPtrMap *map, U64 key, U64 hash, CON { U64 bucket_idx = hash&(map->buckets_count - 1); - CONS_U64ToPtrNode *node = push_array(arena, CONS_U64ToPtrNode, 1); + RADDBGIC_U64ToPtrNode *node = push_array(arena, RADDBGIC_U64ToPtrNode, 1); SLLStackPush(map->buckets[bucket_idx], node); node->key[0] = key; node->ptr[0] = ptr; @@ -327,18 +327,18 @@ cons_u64toptr_insert(Arena *arena, CONS_U64ToPtrMap *map, U64 key, U64 hash, CON //- rjf: string8 -> ptr map static void -cons_str8toptr_init(Arena *arena, CONS_Str8ToPtrMap *map, U64 bucket_count) +raddbgic_str8toptr_init(Arena *arena, RADDBGIC_Str8ToPtrMap *map, U64 bucket_count) { map->buckets_count = bucket_count; - map->buckets = push_array(arena, CONS_Str8ToPtrNode*, map->buckets_count); + map->buckets = push_array(arena, RADDBGIC_Str8ToPtrNode*, map->buckets_count); } static void* -cons_str8toptr_lookup(CONS_Str8ToPtrMap *map, String8 key, U64 hash) +raddbgic_str8toptr_lookup(RADDBGIC_Str8ToPtrMap *map, String8 key, U64 hash) { void *result = 0; U64 bucket_idx = hash%map->buckets_count; - for(CONS_Str8ToPtrNode *node = map->buckets[bucket_idx]; + for(RADDBGIC_Str8ToPtrNode *node = map->buckets[bucket_idx]; node != 0; node = node->next) { @@ -352,11 +352,11 @@ cons_str8toptr_lookup(CONS_Str8ToPtrMap *map, String8 key, U64 hash) } static void -cons_str8toptr_insert(Arena *arena, CONS_Str8ToPtrMap *map, String8 key, U64 hash, void *ptr) +raddbgic_str8toptr_insert(Arena *arena, RADDBGIC_Str8ToPtrMap *map, String8 key, U64 hash, void *ptr) { U64 bucket_idx = hash%map->buckets_count; - CONS_Str8ToPtrNode *node = push_array(arena, CONS_Str8ToPtrNode, 1); + RADDBGIC_Str8ToPtrNode *node = push_array(arena, RADDBGIC_Str8ToPtrNode, 1); SLLStackPush(map->buckets[bucket_idx], node); node->key = push_str8_copy(arena, key); @@ -371,11 +371,11 @@ cons_str8toptr_insert(Arena *arena, CONS_Str8ToPtrMap *map, String8 key, U64 has //- rjf: root creation -static CONS_Root* -cons_root_new(CONS_RootParams *params) +static RADDBGIC_Root* +raddbgic_root_new(RADDBGIC_RootParams *params) { Arena *arena = arena_alloc__sized(GB(64), MB(64)); - CONS_Root *result = push_array(arena, CONS_Root, 1); + RADDBGIC_Root *result = push_array(arena, RADDBGIC_Root, 1); result->arena = arena; // fill in root parameters @@ -385,8 +385,8 @@ cons_root_new(CONS_RootParams *params) // setup singular types { - result->nil_type = cons_type_new(result); - result->variadic_type = cons_type_new(result); + result->nil_type = raddbgic_type_new(result); + result->variadic_type = raddbgic_type_new(result); result->variadic_type->kind = RADDBGI_TypeKind_Variadic; // references to "handled nil type" should be emitted as @@ -397,26 +397,26 @@ cons_root_new(CONS_RootParams *params) // setup a null scope { - CONS_Scope *scope = push_array(result->arena, CONS_Scope, 1); + RADDBGIC_Scope *scope = push_array(result->arena, RADDBGIC_Scope, 1); SLLQueuePush_N(result->first_scope, result->last_scope, scope, next_order); result->scope_count += 1; } // rjf: setup null UDT { - cons_type_udt_from_any_type(result, result->nil_type); + raddbgic_type_udt_from_any_type(result, result->nil_type); } // initialize maps { #define BKTCOUNT(x) ((x)?(u64_up_to_pow2(x)):(128)) - cons_u64toptr_init(arena, &result->unit_map, BKTCOUNT(params->bucket_count_units)); - cons_u64toptr_init(arena, &result->symbol_map, BKTCOUNT(params->bucket_count_symbols)); - cons_u64toptr_init(arena, &result->scope_map, BKTCOUNT(params->bucket_count_scopes)); - cons_u64toptr_init(arena, &result->local_map, BKTCOUNT(params->bucket_count_locals)); - cons_u64toptr_init(arena, &result->type_from_id_map, BKTCOUNT(params->bucket_count_types)); - cons_str8toptr_init(arena, &result->construct_map, BKTCOUNT(params->bucket_count_type_constructs)); + raddbgic_u64toptr_init(arena, &result->unit_map, BKTCOUNT(params->bucket_count_units)); + raddbgic_u64toptr_init(arena, &result->symbol_map, BKTCOUNT(params->bucket_count_symbols)); + raddbgic_u64toptr_init(arena, &result->scope_map, BKTCOUNT(params->bucket_count_scopes)); + raddbgic_u64toptr_init(arena, &result->local_map, BKTCOUNT(params->bucket_count_locals)); + raddbgic_u64toptr_init(arena, &result->type_from_id_map, BKTCOUNT(params->bucket_count_types)); + raddbgic_str8toptr_init(arena, &result->construct_map, BKTCOUNT(params->bucket_count_type_constructs)); #undef BKTCOUNT } @@ -425,7 +425,7 @@ cons_root_new(CONS_RootParams *params) } static void -cons_root_release(CONS_Root *root) +raddbgic_root_release(RADDBGIC_Root *root) { arena_release(root->arena); } @@ -433,26 +433,26 @@ cons_root_release(CONS_Root *root) //- rjf: error accumulation static void -cons_error(CONS_Root *root, String8 string) +raddbgic_error(RADDBGIC_Root *root, String8 string) { - CONS_Error *error = push_array(root->arena, CONS_Error, 1); + RADDBGIC_Error *error = push_array(root->arena, RADDBGIC_Error, 1); SLLQueuePush(root->errors.first, root->errors.last, error); root->errors.count += 1; error->msg = string; } static void -cons_errorf(CONS_Root *root, char *fmt, ...) +raddbgic_errorf(RADDBGIC_Root *root, char *fmt, ...) { va_list args; va_start(args, fmt); String8 str = push_str8fv(root->arena, fmt, args); - cons_error(root, str); + raddbgic_error(root, str); va_end(args); } -static CONS_Error* -cons_get_first_error(CONS_Root *root) +static RADDBGIC_Error* +raddbgic_get_first_error(RADDBGIC_Root *root) { return root->errors.first; } @@ -460,9 +460,9 @@ cons_get_first_error(CONS_Root *root) //- rjf: top-level info specification static void -cons_set_top_level_info(CONS_Root *root, CONS_TopLevelInfo *tli) +raddbgic_set_top_level_info(RADDBGIC_Root *root, RADDBGIC_TopLevelInfo *tli) { - cons_requiref(root, !root->top_level_info_is_set, return, "Top level information set multiple times."); + raddbgic_requiref(root, !root->top_level_info_is_set, return, "Top level information set multiple times."); MemoryCopyStruct(&root->top_level_info, tli); root->top_level_info_is_set = 1; } @@ -470,9 +470,9 @@ cons_set_top_level_info(CONS_Root *root, CONS_TopLevelInfo *tli) //- rjf: binary section building static void -cons_add_binary_section(CONS_Root *root, String8 name, RADDBGI_BinarySectionFlags flags, U64 voff_first, U64 voff_opl, U64 foff_first, U64 foff_opl) +raddbgic_add_binary_section(RADDBGIC_Root *root, String8 name, RADDBGI_BinarySectionFlags flags, U64 voff_first, U64 voff_opl, U64 foff_first, U64 foff_opl) { - CONS_BinarySection *sec = push_array(root->arena, CONS_BinarySection, 1); + RADDBGIC_BinarySection *sec = push_array(root->arena, RADDBGIC_BinarySection, 1); SLLQueuePush(root->binary_section_first, root->binary_section_last, sec); root->binary_section_count += 1; sec->name = name; @@ -485,31 +485,31 @@ cons_add_binary_section(CONS_Root *root, String8 name, RADDBGI_BinarySectionFlag //- rjf: unit info building -static CONS_Unit* -cons_unit_handle_from_user_id(CONS_Root *root, U64 unit_user_id, U64 unit_user_id_hash) +static RADDBGIC_Unit* +raddbgic_unit_handle_from_user_id(RADDBGIC_Root *root, U64 unit_user_id, U64 unit_user_id_hash) { - CONS_U64ToPtrLookup lookup = {0}; - cons_u64toptr_lookup(&root->unit_map, unit_user_id, unit_user_id_hash, &lookup); - CONS_Unit *result = 0; + RADDBGIC_U64ToPtrLookup lookup = {0}; + raddbgic_u64toptr_lookup(&root->unit_map, unit_user_id, unit_user_id_hash, &lookup); + RADDBGIC_Unit *result = 0; if(lookup.match != 0) { - result = (CONS_Unit*)lookup.match; + result = (RADDBGIC_Unit*)lookup.match; } else { - result = push_array(root->arena, CONS_Unit, 1); + result = push_array(root->arena, RADDBGIC_Unit, 1); result->idx = root->unit_count; SLLQueuePush_N(root->unit_first, root->unit_last, result, next_order); root->unit_count += 1; - cons_u64toptr_insert(root->arena, &root->unit_map, unit_user_id, unit_user_id, &lookup, result); + raddbgic_u64toptr_insert(root->arena, &root->unit_map, unit_user_id, unit_user_id, &lookup, result); } return result; } static void -cons_unit_set_info(CONS_Root *root, CONS_Unit *unit, CONS_UnitInfo *info) +raddbgic_unit_set_info(RADDBGIC_Root *root, RADDBGIC_Unit *unit, RADDBGIC_UnitInfo *info) { - cons_requiref(root, !unit->info_is_set, return, "Unit information set multiple times."); + raddbgic_requiref(root, !unit->info_is_set, return, "Unit information set multiple times."); unit->info_is_set = 1; unit->unit_name = push_str8_copy(root->arena, info->unit_name); unit->compiler_name = push_str8_copy(root->arena, info->compiler_name); @@ -521,9 +521,9 @@ cons_unit_set_info(CONS_Root *root, CONS_Unit *unit, CONS_UnitInfo *info) } static void -cons_unit_add_line_sequence(CONS_Root *root, CONS_Unit *unit, CONS_LineSequence *line_sequence) +raddbgic_unit_add_line_sequence(RADDBGIC_Root *root, RADDBGIC_Unit *unit, RADDBGIC_LineSequence *line_sequence) { - CONS_LineSequenceNode *node = push_array(root->arena, CONS_LineSequenceNode, 1); + RADDBGIC_LineSequenceNode *node = push_array(root->arena, RADDBGIC_LineSequenceNode, 1); SLLQueuePush(unit->line_seq_first, unit->line_seq_last, node); unit->line_seq_count += 1; @@ -545,9 +545,9 @@ cons_unit_add_line_sequence(CONS_Root *root, CONS_Unit *unit, CONS_LineSequence } static void -cons_unit_vmap_add_range(CONS_Root *root, CONS_Unit *unit, U64 first, U64 opl) +raddbgic_unit_vmap_add_range(RADDBGIC_Root *root, RADDBGIC_Unit *unit, U64 first, U64 opl) { - CONS_UnitVMapRange *node = push_array(root->arena, CONS_UnitVMapRange, 1); + RADDBGIC_UnitVMapRange *node = push_array(root->arena, RADDBGIC_UnitVMapRange, 1); SLLQueuePush(root->unit_vmap_range_first, root->unit_vmap_range_last, node); root->unit_vmap_range_count += 1; node->unit = unit; @@ -557,32 +557,32 @@ cons_unit_vmap_add_range(CONS_Root *root, CONS_Unit *unit, U64 first, U64 opl) //- rjf: type info lookups/reservations -static CONS_Type* -cons_type_from_id(CONS_Root *root, U64 type_user_id, U64 type_user_id_hash) +static RADDBGIC_Type* +raddbgic_type_from_id(RADDBGIC_Root *root, U64 type_user_id, U64 type_user_id_hash) { - CONS_U64ToPtrLookup lookup = {0}; - cons_u64toptr_lookup(&root->type_from_id_map, type_user_id, type_user_id_hash, &lookup); - CONS_Type *result = (CONS_Type*)lookup.match; + RADDBGIC_U64ToPtrLookup lookup = {0}; + raddbgic_u64toptr_lookup(&root->type_from_id_map, type_user_id, type_user_id_hash, &lookup); + RADDBGIC_Type *result = (RADDBGIC_Type*)lookup.match; return result; } -static CONS_Reservation* -cons_type_reserve_id(CONS_Root *root, U64 type_user_id, U64 type_user_id_hash) +static RADDBGIC_Reservation* +raddbgic_type_reserve_id(RADDBGIC_Root *root, U64 type_user_id, U64 type_user_id_hash) { - CONS_Reservation *result = 0; - CONS_U64ToPtrLookup lookup = {0}; - cons_u64toptr_lookup(&root->type_from_id_map, type_user_id, type_user_id_hash, &lookup); + RADDBGIC_Reservation *result = 0; + RADDBGIC_U64ToPtrLookup lookup = {0}; + raddbgic_u64toptr_lookup(&root->type_from_id_map, type_user_id, type_user_id_hash, &lookup); if(lookup.match == 0) { - cons_u64toptr_insert(root->arena, &root->type_from_id_map, type_user_id, type_user_id_hash, &lookup, root->nil_type); + raddbgic_u64toptr_insert(root->arena, &root->type_from_id_map, type_user_id, type_user_id_hash, &lookup, root->nil_type); void **slot = &lookup.fill_node->ptr[lookup.fill_k]; - result = (CONS_Reservation*)slot; + result = (RADDBGIC_Reservation*)slot; } return result; } static void -cons_type_fill_id(CONS_Root *root, CONS_Reservation *res, CONS_Type *type) +raddbgic_type_fill_id(RADDBGIC_Root *root, RADDBGIC_Reservation *res, RADDBGIC_Type *type) { if(res != 0 && type != 0) { @@ -593,88 +593,88 @@ cons_type_fill_id(CONS_Root *root, CONS_Reservation *res, CONS_Type *type) //- rjf: nil/singleton types static B32 -cons_type_is_unhandled_nil(CONS_Root *root, CONS_Type *type) +raddbgic_type_is_unhandled_nil(RADDBGIC_Root *root, RADDBGIC_Type *type) { B32 result = (type->kind == RADDBGI_TypeKind_NULL && type != &root->handled_nil_type); return result; } -static CONS_Type* -cons_type_handled_nil(CONS_Root *root) +static RADDBGIC_Type* +raddbgic_type_handled_nil(RADDBGIC_Root *root) { return &root->handled_nil_type; } -static CONS_Type* -cons_type_nil(CONS_Root *root) +static RADDBGIC_Type* +raddbgic_type_nil(RADDBGIC_Root *root) { return root->nil_type; } -static CONS_Type* -cons_type_variadic(CONS_Root *root) +static RADDBGIC_Type* +raddbgic_type_variadic(RADDBGIC_Root *root) { return root->variadic_type; } //- rjf: base type info constructors -static CONS_Type* -cons_type_new(CONS_Root *root) +static RADDBGIC_Type* +raddbgic_type_new(RADDBGIC_Root *root) { - CONS_Type *result = push_array(root->arena, CONS_Type, 1); + RADDBGIC_Type *result = push_array(root->arena, RADDBGIC_Type, 1); result->idx = root->type_count; SLLQueuePush_N(root->first_type, root->last_type, result, next_order); root->type_count += 1; return result; } -static CONS_TypeUDT* -cons_type_udt_from_any_type(CONS_Root *root, CONS_Type *type) +static RADDBGIC_TypeUDT* +raddbgic_type_udt_from_any_type(RADDBGIC_Root *root, RADDBGIC_Type *type) { if(type->udt == 0) { - CONS_TypeUDT *new_udt = push_array(root->arena, CONS_TypeUDT, 1); + RADDBGIC_TypeUDT *new_udt = push_array(root->arena, RADDBGIC_TypeUDT, 1); new_udt->idx = root->type_udt_count; SLLQueuePush_N(root->first_udt, root->last_udt, new_udt, next_order); root->type_udt_count += 1; new_udt->self_type = type; type->udt = new_udt; } - CONS_TypeUDT *result = type->udt; + RADDBGIC_TypeUDT *result = type->udt; return result; } -static CONS_TypeUDT* -cons_type_udt_from_record_type(CONS_Root *root, CONS_Type *type) +static RADDBGIC_TypeUDT* +raddbgic_type_udt_from_record_type(RADDBGIC_Root *root, RADDBGIC_Type *type) { - cons_requiref(root, (type->kind == RADDBGI_TypeKind_Struct || - type->kind == RADDBGI_TypeKind_Class || - type->kind == RADDBGI_TypeKind_Union), - return 0, - "Tried to use non-user-defined-type-kind to create user-defined-type."); - CONS_TypeUDT *result = 0; - result = cons_type_udt_from_any_type(root, type); + raddbgic_requiref(root, (type->kind == RADDBGI_TypeKind_Struct || + type->kind == RADDBGI_TypeKind_Class || + type->kind == RADDBGI_TypeKind_Union), + return 0, + "Tried to use non-user-defined-type-kind to create user-defined-type."); + RADDBGIC_TypeUDT *result = 0; + result = raddbgic_type_udt_from_any_type(root, type); return result; } //- rjf: basic/operator type construction helpers -static CONS_Type* -cons_type_basic(CONS_Root *root, RADDBGI_TypeKind type_kind, String8 name) +static RADDBGIC_Type* +raddbgic_type_basic(RADDBGIC_Root *root, RADDBGI_TypeKind type_kind, String8 name) { - cons_requiref(root, (RADDBGI_TypeKind_FirstBuiltIn <= type_kind && type_kind <= RADDBGI_TypeKind_LastBuiltIn), return root->nil_type, "Non-basic type kind passed to construct basic type."); - CONS_Type *result = root->nil_type; + raddbgic_requiref(root, (RADDBGI_TypeKind_FirstBuiltIn <= type_kind && type_kind <= RADDBGI_TypeKind_LastBuiltIn), return root->nil_type, "Non-basic type kind passed to construct basic type."); + RADDBGIC_Type *result = root->nil_type; Temp scratch = scratch_begin(0, 0); // setup construct buffer - U64 buf_size = sizeof(CONS_TypeConstructKind) + sizeof(type_kind) + name.size; + U64 buf_size = sizeof(RADDBGIC_TypeConstructKind) + sizeof(type_kind) + name.size; U8 *buf = push_array(scratch.arena, U8, buf_size); { U8 *ptr = buf; // "basic" - *(CONS_TypeConstructKind*)ptr = CONS_TypeConstructKind_Basic; - ptr += sizeof(CONS_TypeConstructKind); + *(RADDBGIC_TypeConstructKind*)ptr = RADDBGIC_TypeConstructKind_Basic; + ptr += sizeof(RADDBGIC_TypeConstructKind); // type_kind MemoryCopy(ptr, &type_kind, sizeof(type_kind)); ptr += sizeof(type_kind); @@ -686,8 +686,8 @@ cons_type_basic(CONS_Root *root, RADDBGI_TypeKind type_kind, String8 name) // check for duplicate construct String8 blob = str8(buf, buf_size); U64 blob_hash = raddbgi_hash(buf, buf_size); - void *lookup_ptr = cons_str8toptr_lookup(&root->construct_map, blob, blob_hash); - result = (CONS_Type*)lookup_ptr; + void *lookup_ptr = raddbgic_str8toptr_lookup(&root->construct_map, blob, blob_hash); + result = (RADDBGIC_Type*)lookup_ptr; if(result == 0) { // calculate size @@ -698,18 +698,18 @@ cons_type_basic(CONS_Root *root, RADDBGI_TypeKind type_kind, String8 name) } // setup new node - result = cons_type_new(root); + result = raddbgic_type_new(root); result->kind = type_kind; result->name = push_str8_copy(root->arena, name); result->byte_size = byte_size; // save in construct map - cons_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); + raddbgic_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); // save in name map { - CONS_NameMap *map = cons_name_map_for_kind(root, RADDBGI_NameMapKind_Types); - cons_name_map_add_pair(root, map, result->name, result->idx); + RADDBGIC_NameMap *map = raddbgic_name_map_for_kind(root, RADDBGI_NameMapKind_Types); + raddbgic_name_map_add_pair(root, map, result->name, result->idx); } } @@ -718,20 +718,20 @@ cons_type_basic(CONS_Root *root, RADDBGI_TypeKind type_kind, String8 name) return result; } -static CONS_Type* -cons_type_modifier(CONS_Root *root, CONS_Type *direct_type, RADDBGI_TypeModifierFlags flags) +static RADDBGIC_Type* +raddbgic_type_modifier(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, RADDBGI_TypeModifierFlags flags) { - CONS_Type *result = root->nil_type; + RADDBGIC_Type *result = root->nil_type; Temp scratch = scratch_begin(0, 0); // setup construct buffer - U64 buf_size = sizeof(CONS_TypeConstructKind) + sizeof(flags) + sizeof(direct_type->idx); + U64 buf_size = sizeof(RADDBGIC_TypeConstructKind) + sizeof(flags) + sizeof(direct_type->idx); U8 *buf = push_array(scratch.arena, U8, buf_size); { U8 *ptr = buf; // "modifier" - *(CONS_TypeConstructKind*)ptr = CONS_TypeConstructKind_Modifier; - ptr += sizeof(CONS_TypeConstructKind); + *(RADDBGIC_TypeConstructKind*)ptr = RADDBGIC_TypeConstructKind_Modifier; + ptr += sizeof(RADDBGIC_TypeConstructKind); // flags MemoryCopy(ptr, &flags, sizeof(flags)); ptr += sizeof(flags); @@ -743,19 +743,19 @@ cons_type_modifier(CONS_Root *root, CONS_Type *direct_type, RADDBGI_TypeModifier // check for duplicate construct String8 blob = str8(buf, buf_size); U64 blob_hash = raddbgi_hash(buf, buf_size); - void *lookup_ptr = cons_str8toptr_lookup(&root->construct_map, blob, blob_hash); - result = (CONS_Type*)lookup_ptr; + void *lookup_ptr = raddbgic_str8toptr_lookup(&root->construct_map, blob, blob_hash); + result = (RADDBGIC_Type*)lookup_ptr; if(result == 0){ // setup new node - result = cons_type_new(root); + result = raddbgic_type_new(root); result->kind = RADDBGI_TypeKind_Modifier; result->flags = flags; result->byte_size = direct_type->byte_size; result->direct_type = direct_type; // save in construct map - cons_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); + raddbgic_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); } scratch_end(scratch); @@ -763,20 +763,20 @@ cons_type_modifier(CONS_Root *root, CONS_Type *direct_type, RADDBGI_TypeModifier return result; } -static CONS_Type* -cons_type_bitfield(CONS_Root *root, CONS_Type *direct_type, U32 bit_off, U32 bit_count) +static RADDBGIC_Type* +raddbgic_type_bitfield(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, U32 bit_off, U32 bit_count) { - CONS_Type *result = root->nil_type; + RADDBGIC_Type *result = root->nil_type; Temp scratch = scratch_begin(0, 0); // setup construct buffer - U64 buf_size = sizeof(CONS_TypeConstructKind) + sizeof(direct_type->idx) + sizeof(U32)*2; + U64 buf_size = sizeof(RADDBGIC_TypeConstructKind) + sizeof(direct_type->idx) + sizeof(U32)*2; U8 *buf = push_array(scratch.arena, U8, buf_size); { U8 *ptr = buf; // "bitfield" - *(CONS_TypeConstructKind*)ptr = CONS_TypeConstructKind_Bitfield; - ptr += sizeof(CONS_TypeConstructKind); + *(RADDBGIC_TypeConstructKind*)ptr = RADDBGIC_TypeConstructKind_Bitfield; + ptr += sizeof(RADDBGIC_TypeConstructKind); // direct_type->idx MemoryCopy(ptr, &direct_type->idx, sizeof(direct_type->idx)); ptr += sizeof(direct_type->idx); @@ -791,12 +791,12 @@ cons_type_bitfield(CONS_Root *root, CONS_Type *direct_type, U32 bit_off, U32 bit // check for duplicate construct String8 blob = str8(buf, buf_size); U64 blob_hash = raddbgi_hash(buf, buf_size); - void *lookup_ptr = cons_str8toptr_lookup(&root->construct_map, blob, blob_hash); - result = (CONS_Type*)lookup_ptr; + void *lookup_ptr = raddbgic_str8toptr_lookup(&root->construct_map, blob, blob_hash); + result = (RADDBGIC_Type*)lookup_ptr; if(result == 0) { // setup new node - result = cons_type_new(root); + result = raddbgic_type_new(root); result->kind = RADDBGI_TypeKind_Bitfield; result->byte_size = direct_type->byte_size; result->off = bit_off; @@ -804,7 +804,7 @@ cons_type_bitfield(CONS_Root *root, CONS_Type *direct_type, U32 bit_off, U32 bit result->direct_type = direct_type; // save in construct map - cons_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); + raddbgic_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); } scratch_end(scratch); @@ -812,25 +812,25 @@ cons_type_bitfield(CONS_Root *root, CONS_Type *direct_type, U32 bit_off, U32 bit return result; } -static CONS_Type* -cons_type_pointer(CONS_Root *root, CONS_Type *direct_type, RADDBGI_TypeKind ptr_type_kind) +static RADDBGIC_Type* +raddbgic_type_pointer(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, RADDBGI_TypeKind ptr_type_kind) { - cons_requiref(root, (ptr_type_kind == RADDBGI_TypeKind_Ptr || - ptr_type_kind == RADDBGI_TypeKind_LRef || - ptr_type_kind == RADDBGI_TypeKind_RRef), - return root->nil_type, - "Non-pointer type kind used to construct pointer type."); - CONS_Type *result = root->nil_type; + raddbgic_requiref(root, (ptr_type_kind == RADDBGI_TypeKind_Ptr || + ptr_type_kind == RADDBGI_TypeKind_LRef || + ptr_type_kind == RADDBGI_TypeKind_RRef), + return root->nil_type, + "Non-pointer type kind used to construct pointer type."); + RADDBGIC_Type *result = root->nil_type; Temp scratch = scratch_begin(0, 0); // setup construct buffer - U64 buf_size = sizeof(CONS_TypeConstructKind) + sizeof(ptr_type_kind) + sizeof(direct_type->idx); + U64 buf_size = sizeof(RADDBGIC_TypeConstructKind) + sizeof(ptr_type_kind) + sizeof(direct_type->idx); U8 *buf = push_array(scratch.arena, U8, buf_size); { U8 *ptr = buf; // "pointer" - *(CONS_TypeConstructKind*)ptr = CONS_TypeConstructKind_Pointer; - ptr += sizeof(CONS_TypeConstructKind); + *(RADDBGIC_TypeConstructKind*)ptr = RADDBGIC_TypeConstructKind_Pointer; + ptr += sizeof(RADDBGIC_TypeConstructKind); // type_kind MemoryCopy(ptr, &ptr_type_kind, sizeof(ptr_type_kind)); ptr += sizeof(ptr_type_kind); @@ -842,18 +842,18 @@ cons_type_pointer(CONS_Root *root, CONS_Type *direct_type, RADDBGI_TypeKind ptr_ // check for duplicate construct String8 blob = str8(buf, buf_size); U64 blob_hash = raddbgi_hash(buf, buf_size); - void *lookup_ptr = cons_str8toptr_lookup(&root->construct_map, blob, blob_hash); - result = (CONS_Type*)lookup_ptr; + void *lookup_ptr = raddbgic_str8toptr_lookup(&root->construct_map, blob, blob_hash); + result = (RADDBGIC_Type*)lookup_ptr; if(result == 0) { // setup new node - result = cons_type_new(root); + result = raddbgic_type_new(root); result->kind = ptr_type_kind; result->byte_size = root->addr_size; result->direct_type = direct_type; // save in construct map - cons_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); + raddbgic_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); } scratch_end(scratch); @@ -861,21 +861,21 @@ cons_type_pointer(CONS_Root *root, CONS_Type *direct_type, RADDBGI_TypeKind ptr_ return result; } -static CONS_Type* -cons_type_array(CONS_Root *root, CONS_Type *direct_type, U64 count) +static RADDBGIC_Type* +raddbgic_type_array(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, U64 count) { - CONS_Type *result = root->nil_type; + RADDBGIC_Type *result = root->nil_type; Temp scratch = scratch_begin(0, 0); // setup construct buffer U64 buf_size = - sizeof(CONS_TypeConstructKind) + sizeof(direct_type->idx) + sizeof(count); + sizeof(RADDBGIC_TypeConstructKind) + sizeof(direct_type->idx) + sizeof(count); U8 *buf = push_array(scratch.arena, U8, buf_size); { U8 *ptr = buf; // "array" - *(CONS_TypeConstructKind*)ptr = CONS_TypeConstructKind_Array; - ptr += sizeof(CONS_TypeConstructKind); + *(RADDBGIC_TypeConstructKind*)ptr = RADDBGIC_TypeConstructKind_Array; + ptr += sizeof(RADDBGIC_TypeConstructKind); // direct_type->idx MemoryCopy(ptr, &direct_type->idx, sizeof(direct_type->idx)); ptr += sizeof(direct_type->idx); @@ -887,19 +887,19 @@ cons_type_array(CONS_Root *root, CONS_Type *direct_type, U64 count) // check for duplicate construct String8 blob = str8(buf, buf_size); U64 blob_hash = raddbgi_hash(buf, buf_size); - void *lookup_ptr = cons_str8toptr_lookup(&root->construct_map, blob, blob_hash); - result = (CONS_Type*)lookup_ptr; + void *lookup_ptr = raddbgic_str8toptr_lookup(&root->construct_map, blob, blob_hash); + result = (RADDBGIC_Type*)lookup_ptr; if(result == 0) { // setup new node - result = cons_type_new(root); + result = raddbgic_type_new(root); result->kind = RADDBGI_TypeKind_Array; result->count = count; result->direct_type = direct_type; result->byte_size = direct_type->byte_size*count; // save in construct map - cons_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); + raddbgic_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); } scratch_end(scratch); @@ -907,25 +907,25 @@ cons_type_array(CONS_Root *root, CONS_Type *direct_type, U64 count) return result; } -static CONS_Type* -cons_type_proc(CONS_Root *root, CONS_Type *return_type, struct CONS_TypeList *params) +static RADDBGIC_Type* +raddbgic_type_proc(RADDBGIC_Root *root, RADDBGIC_Type *return_type, struct RADDBGIC_TypeList *params) { - CONS_Type *result = root->nil_type; + RADDBGIC_Type *result = root->nil_type; Temp scratch = scratch_begin(0, 0); // setup construct buffer - U64 buf_size = sizeof(CONS_TypeConstructKind) + sizeof(return_type->idx)*(1 + params->count); + U64 buf_size = sizeof(RADDBGIC_TypeConstructKind) + sizeof(return_type->idx)*(1 + params->count); U8 *buf = push_array(scratch.arena, U8, buf_size); { U8 *ptr = buf; // "procedure" - *(CONS_TypeConstructKind*)ptr = CONS_TypeConstructKind_Procedure; - ptr += sizeof(CONS_TypeConstructKind); + *(RADDBGIC_TypeConstructKind*)ptr = RADDBGIC_TypeConstructKind_Procedure; + ptr += sizeof(RADDBGIC_TypeConstructKind); // ret_type->idx MemoryCopy(ptr, &return_type->idx, sizeof(return_type->idx)); ptr += sizeof(return_type->idx); // (params ...)->idx - for(CONS_TypeNode *node = params->first; + for(RADDBGIC_TypeNode *node = params->first; node != 0; node = node->next) { @@ -937,15 +937,15 @@ cons_type_proc(CONS_Root *root, CONS_Type *return_type, struct CONS_TypeList *pa // check for duplicate construct String8 blob = str8(buf, buf_size); U64 blob_hash = raddbgi_hash(buf, buf_size); - void *lookup_ptr = cons_str8toptr_lookup(&root->construct_map, blob, blob_hash); - result = (CONS_Type*)lookup_ptr; + void *lookup_ptr = raddbgic_str8toptr_lookup(&root->construct_map, blob, blob_hash); + result = (RADDBGIC_Type*)lookup_ptr; if(result == 0) { // setup param buffer - CONS_Type **param_types = push_array(root->arena, CONS_Type*, params->count); + RADDBGIC_Type **param_types = push_array(root->arena, RADDBGIC_Type*, params->count); { - CONS_Type **ptr = param_types; - for(CONS_TypeNode *node = params->first; + RADDBGIC_Type **ptr = param_types; + for(RADDBGIC_TypeNode *node = params->first; node != 0; node = node->next) { @@ -955,7 +955,7 @@ cons_type_proc(CONS_Root *root, CONS_Type *return_type, struct CONS_TypeList *pa } // setup new node - result = cons_type_new(root); + result = raddbgic_type_new(root); result->kind = RADDBGI_TypeKind_Function; result->byte_size = root->addr_size; result->count = params->count; @@ -963,7 +963,7 @@ cons_type_proc(CONS_Root *root, CONS_Type *return_type, struct CONS_TypeList *pa result->param_types = param_types; // save in construct map - cons_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); + raddbgic_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); } scratch_end(scratch); @@ -971,21 +971,21 @@ cons_type_proc(CONS_Root *root, CONS_Type *return_type, struct CONS_TypeList *pa return result; } -static CONS_Type* -cons_type_method(CONS_Root *root, CONS_Type *this_type, CONS_Type *return_type, struct CONS_TypeList *params) +static RADDBGIC_Type* +raddbgic_type_method(RADDBGIC_Root *root, RADDBGIC_Type *this_type, RADDBGIC_Type *return_type, struct RADDBGIC_TypeList *params) { - CONS_Type *result = root->nil_type; + RADDBGIC_Type *result = root->nil_type; Temp scratch = scratch_begin(0, 0); // setup construct buffer U64 buf_size = - sizeof(CONS_TypeConstructKind) + sizeof(return_type->idx)*(2 + params->count); + sizeof(RADDBGIC_TypeConstructKind) + sizeof(return_type->idx)*(2 + params->count); U8 *buf = push_array(scratch.arena, U8, buf_size); { U8 *ptr = buf; // "method" - *(CONS_TypeConstructKind*)ptr = CONS_TypeConstructKind_Method; - ptr += sizeof(CONS_TypeConstructKind); + *(RADDBGIC_TypeConstructKind*)ptr = RADDBGIC_TypeConstructKind_Method; + ptr += sizeof(RADDBGIC_TypeConstructKind); // ret_type->idx MemoryCopy(ptr, &return_type->idx, sizeof(return_type->idx)); ptr += sizeof(return_type->idx); @@ -993,7 +993,7 @@ cons_type_method(CONS_Root *root, CONS_Type *this_type, CONS_Type *return_type, MemoryCopy(ptr, &this_type->idx, sizeof(this_type->idx)); ptr += sizeof(this_type->idx); // (params ...)->idx - for(CONS_TypeNode *node = params->first; + for(RADDBGIC_TypeNode *node = params->first; node != 0; node = node->next) { @@ -1005,19 +1005,19 @@ cons_type_method(CONS_Root *root, CONS_Type *this_type, CONS_Type *return_type, // check for duplicate construct String8 blob = str8(buf, buf_size); U64 blob_hash = raddbgi_hash(buf, buf_size); - void *lookup_ptr = cons_str8toptr_lookup(&root->construct_map, blob, blob_hash); - result = (CONS_Type*)lookup_ptr; + void *lookup_ptr = raddbgic_str8toptr_lookup(&root->construct_map, blob, blob_hash); + result = (RADDBGIC_Type*)lookup_ptr; if(result == 0) { // setup param buffer - CONS_Type **param_types = push_array(root->arena, CONS_Type*, params->count + 1); + RADDBGIC_Type **param_types = push_array(root->arena, RADDBGIC_Type*, params->count + 1); { - CONS_Type **ptr = param_types; + RADDBGIC_Type **ptr = param_types; { *ptr = this_type; ptr += 1; } - for(CONS_TypeNode *node = params->first; + for(RADDBGIC_TypeNode *node = params->first; node != 0; node = node->next) { @@ -1027,7 +1027,7 @@ cons_type_method(CONS_Root *root, CONS_Type *this_type, CONS_Type *return_type, } // setup new node - result = cons_type_new(root); + result = raddbgic_type_new(root); result->kind = RADDBGI_TypeKind_Method; result->byte_size = root->addr_size; result->count = params->count; @@ -1035,7 +1035,7 @@ cons_type_method(CONS_Root *root, CONS_Type *this_type, CONS_Type *return_type, result->param_types = param_types; // save in construct map - cons_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); + raddbgic_str8toptr_insert(root->arena, &root->construct_map, blob, blob_hash, result); } scratch_end(scratch); @@ -1045,35 +1045,35 @@ cons_type_method(CONS_Root *root, CONS_Type *this_type, CONS_Type *return_type, //- rjf: udt type constructors -static CONS_Type* -cons_type_udt(CONS_Root *root, RADDBGI_TypeKind record_type_kind, String8 name, U64 size) +static RADDBGIC_Type* +raddbgic_type_udt(RADDBGIC_Root *root, RADDBGI_TypeKind record_type_kind, String8 name, U64 size) { - cons_requiref(root, (record_type_kind == RADDBGI_TypeKind_Struct || - record_type_kind == RADDBGI_TypeKind_Class || - record_type_kind == RADDBGI_TypeKind_Union), - return root->nil_type, - "Non-user-defined-type-kind used to create user-defined type."); + raddbgic_requiref(root, (record_type_kind == RADDBGI_TypeKind_Struct || + record_type_kind == RADDBGI_TypeKind_Class || + record_type_kind == RADDBGI_TypeKind_Union), + return root->nil_type, + "Non-user-defined-type-kind used to create user-defined type."); // rjf: make type - CONS_Type *result = cons_type_new(root); + RADDBGIC_Type *result = raddbgic_type_new(root); result->kind = record_type_kind; result->byte_size = size; result->name = push_str8_copy(root->arena, name); // rjf: save in name map { - CONS_NameMap *map = cons_name_map_for_kind(root, RADDBGI_NameMapKind_Types); - cons_name_map_add_pair(root, map, result->name, result->idx); + RADDBGIC_NameMap *map = raddbgic_name_map_for_kind(root, RADDBGI_NameMapKind_Types); + raddbgic_name_map_add_pair(root, map, result->name, result->idx); } return result; } -static CONS_Type* -cons_type_enum(CONS_Root *root, CONS_Type *direct_type, String8 name) +static RADDBGIC_Type* +raddbgic_type_enum(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, String8 name) { // rjf: make type - CONS_Type *result = cons_type_new(root); + RADDBGIC_Type *result = raddbgic_type_new(root); result->kind = RADDBGI_TypeKind_Enum; result->byte_size = direct_type->byte_size; result->name = push_str8_copy(root->arena, name); @@ -1081,18 +1081,18 @@ cons_type_enum(CONS_Root *root, CONS_Type *direct_type, String8 name) // rjf: save in name map { - CONS_NameMap *map = cons_name_map_for_kind(root, RADDBGI_NameMapKind_Types); - cons_name_map_add_pair(root, map, result->name, result->idx); + RADDBGIC_NameMap *map = raddbgic_name_map_for_kind(root, RADDBGI_NameMapKind_Types); + raddbgic_name_map_add_pair(root, map, result->name, result->idx); } return result; } -static CONS_Type* -cons_type_alias(CONS_Root *root, CONS_Type *direct_type, String8 name) +static RADDBGIC_Type* +raddbgic_type_alias(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, String8 name) { // rjf: make type - CONS_Type *result = cons_type_new(root); + RADDBGIC_Type *result = raddbgic_type_new(root); result->kind = RADDBGI_TypeKind_Alias; result->byte_size = direct_type->byte_size; result->name = push_str8_copy(root->arena, name); @@ -1100,32 +1100,32 @@ cons_type_alias(CONS_Root *root, CONS_Type *direct_type, String8 name) // rjf: save in name map { - CONS_NameMap *map = cons_name_map_for_kind(root, RADDBGI_NameMapKind_Types); - cons_name_map_add_pair(root, map, result->name, result->idx); + RADDBGIC_NameMap *map = raddbgic_name_map_for_kind(root, RADDBGI_NameMapKind_Types); + raddbgic_name_map_add_pair(root, map, result->name, result->idx); } return result; } -static CONS_Type* -cons_type_incomplete(CONS_Root *root, RADDBGI_TypeKind type_kind, String8 name) +static RADDBGIC_Type* +raddbgic_type_incomplete(RADDBGIC_Root *root, RADDBGI_TypeKind type_kind, String8 name) { - cons_requiref(root, (type_kind == RADDBGI_TypeKind_IncompleteStruct || - type_kind == RADDBGI_TypeKind_IncompleteClass || - type_kind == RADDBGI_TypeKind_IncompleteUnion || - type_kind == RADDBGI_TypeKind_IncompleteEnum), - return root->nil_type, - "Non-incomplete-type-kind used to create incomplete type."); + raddbgic_requiref(root, (type_kind == RADDBGI_TypeKind_IncompleteStruct || + type_kind == RADDBGI_TypeKind_IncompleteClass || + type_kind == RADDBGI_TypeKind_IncompleteUnion || + type_kind == RADDBGI_TypeKind_IncompleteEnum), + return root->nil_type, + "Non-incomplete-type-kind used to create incomplete type."); // rjf: make type - CONS_Type *result = cons_type_new(root); + RADDBGIC_Type *result = raddbgic_type_new(root); result->kind = type_kind; result->name = push_str8_copy(root->arena, name); // save in name map { - CONS_NameMap *map = cons_name_map_for_kind(root, RADDBGI_NameMapKind_Types); - cons_name_map_add_pair(root, map, result->name, result->idx); + RADDBGIC_NameMap *map = raddbgic_name_map_for_kind(root, RADDBGI_NameMapKind_Types); + raddbgic_name_map_add_pair(root, map, result->name, result->idx); } return result; @@ -1134,12 +1134,12 @@ cons_type_incomplete(CONS_Root *root, RADDBGI_TypeKind type_kind, String8 name) //- rjf: type member building static void -cons_type_add_member_data_field(CONS_Root *root, CONS_Type *record_type, String8 name, CONS_Type *mem_type, U32 off) +raddbgic_type_add_member_data_field(RADDBGIC_Root *root, RADDBGIC_Type *record_type, String8 name, RADDBGIC_Type *mem_type, U32 off) { - CONS_TypeUDT *udt = cons_type_udt_from_record_type(root, record_type); + RADDBGIC_TypeUDT *udt = raddbgic_type_udt_from_record_type(root, record_type); if(udt != 0) { - CONS_TypeMember *member = push_array(root->arena, CONS_TypeMember, 1); + RADDBGIC_TypeMember *member = push_array(root->arena, RADDBGIC_TypeMember, 1); SLLQueuePush(udt->first_member, udt->last_member, member); udt->member_count += 1; root->total_member_count += 1; @@ -1151,12 +1151,12 @@ cons_type_add_member_data_field(CONS_Root *root, CONS_Type *record_type, String8 } static void -cons_type_add_member_static_data(CONS_Root *root, CONS_Type *record_type, String8 name, CONS_Type *mem_type) +raddbgic_type_add_member_static_data(RADDBGIC_Root *root, RADDBGIC_Type *record_type, String8 name, RADDBGIC_Type *mem_type) { - CONS_TypeUDT *udt = cons_type_udt_from_record_type(root, record_type); + RADDBGIC_TypeUDT *udt = raddbgic_type_udt_from_record_type(root, record_type); if(udt != 0) { - CONS_TypeMember *member = push_array(root->arena, CONS_TypeMember, 1); + RADDBGIC_TypeMember *member = push_array(root->arena, RADDBGIC_TypeMember, 1); SLLQueuePush(udt->first_member, udt->last_member, member); udt->member_count += 1; root->total_member_count += 1; @@ -1167,12 +1167,12 @@ cons_type_add_member_static_data(CONS_Root *root, CONS_Type *record_type, String } static void -cons_type_add_member_method(CONS_Root *root, CONS_Type *record_type, String8 name, CONS_Type *mem_type) +raddbgic_type_add_member_method(RADDBGIC_Root *root, RADDBGIC_Type *record_type, String8 name, RADDBGIC_Type *mem_type) { - CONS_TypeUDT *udt = cons_type_udt_from_record_type(root, record_type); + RADDBGIC_TypeUDT *udt = raddbgic_type_udt_from_record_type(root, record_type); if(udt != 0) { - CONS_TypeMember *member = push_array(root->arena, CONS_TypeMember, 1); + RADDBGIC_TypeMember *member = push_array(root->arena, RADDBGIC_TypeMember, 1); SLLQueuePush(udt->first_member, udt->last_member, member); udt->member_count += 1; root->total_member_count += 1; @@ -1183,12 +1183,12 @@ cons_type_add_member_method(CONS_Root *root, CONS_Type *record_type, String8 nam } static void -cons_type_add_member_static_method(CONS_Root *root, CONS_Type *record_type, String8 name, CONS_Type *mem_type) +raddbgic_type_add_member_static_method(RADDBGIC_Root *root, RADDBGIC_Type *record_type, String8 name, RADDBGIC_Type *mem_type) { - CONS_TypeUDT *udt = cons_type_udt_from_record_type(root, record_type); + RADDBGIC_TypeUDT *udt = raddbgic_type_udt_from_record_type(root, record_type); if(udt != 0) { - CONS_TypeMember *member = push_array(root->arena, CONS_TypeMember, 1); + RADDBGIC_TypeMember *member = push_array(root->arena, RADDBGIC_TypeMember, 1); SLLQueuePush(udt->first_member, udt->last_member, member); udt->member_count += 1; @@ -1201,12 +1201,12 @@ cons_type_add_member_static_method(CONS_Root *root, CONS_Type *record_type, Stri } static void -cons_type_add_member_virtual_method(CONS_Root *root, CONS_Type *record_type, String8 name, CONS_Type *mem_type) +raddbgic_type_add_member_virtual_method(RADDBGIC_Root *root, RADDBGIC_Type *record_type, String8 name, RADDBGIC_Type *mem_type) { - CONS_TypeUDT *udt = cons_type_udt_from_record_type(root, record_type); + RADDBGIC_TypeUDT *udt = raddbgic_type_udt_from_record_type(root, record_type); if(udt != 0) { - CONS_TypeMember *member = push_array(root->arena, CONS_TypeMember, 1); + RADDBGIC_TypeMember *member = push_array(root->arena, RADDBGIC_TypeMember, 1); SLLQueuePush(udt->first_member, udt->last_member, member); udt->member_count += 1; root->total_member_count += 1; @@ -1217,12 +1217,12 @@ cons_type_add_member_virtual_method(CONS_Root *root, CONS_Type *record_type, Str } static void -cons_type_add_member_base(CONS_Root *root, CONS_Type *record_type, CONS_Type *base_type, U32 off) +raddbgic_type_add_member_base(RADDBGIC_Root *root, RADDBGIC_Type *record_type, RADDBGIC_Type *base_type, U32 off) { - CONS_TypeUDT *udt = cons_type_udt_from_record_type(root, record_type); + RADDBGIC_TypeUDT *udt = raddbgic_type_udt_from_record_type(root, record_type); if(udt != 0) { - CONS_TypeMember *member = push_array(root->arena, CONS_TypeMember, 1); + RADDBGIC_TypeMember *member = push_array(root->arena, RADDBGIC_TypeMember, 1); SLLQueuePush(udt->first_member, udt->last_member, member); udt->member_count += 1; root->total_member_count += 1; @@ -1233,12 +1233,12 @@ cons_type_add_member_base(CONS_Root *root, CONS_Type *record_type, CONS_Type *ba } static void -cons_type_add_member_virtual_base(CONS_Root *root, CONS_Type *record_type, CONS_Type *base_type, U32 vptr_off, U32 vtable_off) +raddbgic_type_add_member_virtual_base(RADDBGIC_Root *root, RADDBGIC_Type *record_type, RADDBGIC_Type *base_type, U32 vptr_off, U32 vtable_off) { - CONS_TypeUDT *udt = cons_type_udt_from_record_type(root, record_type); + RADDBGIC_TypeUDT *udt = raddbgic_type_udt_from_record_type(root, record_type); if(udt != 0) { - CONS_TypeMember *member = push_array(root->arena, CONS_TypeMember, 1); + RADDBGIC_TypeMember *member = push_array(root->arena, RADDBGIC_TypeMember, 1); SLLQueuePush(udt->first_member, udt->last_member, member); udt->member_count += 1; root->total_member_count += 1; @@ -1249,12 +1249,12 @@ cons_type_add_member_virtual_base(CONS_Root *root, CONS_Type *record_type, CONS_ } static void -cons_type_add_member_nested_type(CONS_Root *root, CONS_Type *record_type, CONS_Type *nested_type) +raddbgic_type_add_member_nested_type(RADDBGIC_Root *root, RADDBGIC_Type *record_type, RADDBGIC_Type *nested_type) { - CONS_TypeUDT *udt = cons_type_udt_from_record_type(root, record_type); + RADDBGIC_TypeUDT *udt = raddbgic_type_udt_from_record_type(root, record_type); if(udt != 0) { - CONS_TypeMember *member = push_array(root->arena, CONS_TypeMember, 1); + RADDBGIC_TypeMember *member = push_array(root->arena, RADDBGIC_TypeMember, 1); SLLQueuePush(udt->first_member, udt->last_member, member); udt->member_count += 1; root->total_member_count += 1; @@ -1264,13 +1264,13 @@ cons_type_add_member_nested_type(CONS_Root *root, CONS_Type *record_type, CONS_T } static void -cons_type_add_enum_val(CONS_Root *root, CONS_Type *enum_type, String8 name, U64 val) +raddbgic_type_add_enum_val(RADDBGIC_Root *root, RADDBGIC_Type *enum_type, String8 name, U64 val) { - cons_requiref(root, (enum_type->kind == RADDBGI_TypeKind_Enum), return, "Tried to add enum value to non-enum type."); - CONS_TypeUDT *udt = cons_type_udt_from_any_type(root, enum_type); + raddbgic_requiref(root, (enum_type->kind == RADDBGI_TypeKind_Enum), return, "Tried to add enum value to non-enum type."); + RADDBGIC_TypeUDT *udt = raddbgic_type_udt_from_any_type(root, enum_type); if(udt != 0) { - CONS_TypeEnumVal *enum_val = push_array(root->arena, CONS_TypeEnumVal, 1); + RADDBGIC_TypeEnumVal *enum_val = push_array(root->arena, RADDBGIC_TypeEnumVal, 1); SLLQueuePush(udt->first_enum_val, udt->last_enum_val, enum_val); udt->enum_val_count += 1; root->total_enum_val_count += 1; @@ -1281,11 +1281,11 @@ cons_type_add_enum_val(CONS_Root *root, CONS_Type *enum_type, String8 name, U64 //- rjf: type source coordinate specifications static void -cons_type_set_source_coordinates(CONS_Root *root, CONS_Type *defined_type, String8 source_path, U32 line, U32 col) +raddbgic_type_set_source_coordinates(RADDBGIC_Root *root, RADDBGIC_Type *defined_type, String8 source_path, U32 line, U32 col) { - cons_requiref(root, (RADDBGI_TypeKind_FirstUserDefined <= defined_type->kind && defined_type->kind <= RADDBGI_TypeKind_LastUserDefined), - return, "Tried to add source coordinates to non-user-defined type."); - CONS_TypeUDT *udt = cons_type_udt_from_any_type(root, defined_type); + raddbgic_requiref(root, (RADDBGI_TypeKind_FirstUserDefined <= defined_type->kind && defined_type->kind <= RADDBGI_TypeKind_LastUserDefined), + return, "Tried to add source coordinates to non-user-defined type."); + RADDBGIC_TypeUDT *udt = raddbgic_type_udt_from_any_type(root, defined_type); if(udt != 0) { udt->source_path = push_str8_copy(root->arena, source_path); @@ -1296,39 +1296,39 @@ cons_type_set_source_coordinates(CONS_Root *root, CONS_Type *defined_type, Strin //- rjf: symbol info building -static CONS_Symbol* -cons_symbol_handle_from_user_id(CONS_Root *root, U64 symbol_user_id, U64 symbol_user_id_hash) +static RADDBGIC_Symbol* +raddbgic_symbol_handle_from_user_id(RADDBGIC_Root *root, U64 symbol_user_id, U64 symbol_user_id_hash) { - CONS_U64ToPtrLookup lookup = {0}; - cons_u64toptr_lookup(&root->symbol_map, symbol_user_id, symbol_user_id_hash, &lookup); - CONS_Symbol *result = 0; + RADDBGIC_U64ToPtrLookup lookup = {0}; + raddbgic_u64toptr_lookup(&root->symbol_map, symbol_user_id, symbol_user_id_hash, &lookup); + RADDBGIC_Symbol *result = 0; if(lookup.match != 0) { - result = (CONS_Symbol*)lookup.match; + result = (RADDBGIC_Symbol*)lookup.match; } else { - result = push_array(root->arena, CONS_Symbol, 1); + result = push_array(root->arena, RADDBGIC_Symbol, 1); SLLQueuePush_N(root->first_symbol, root->last_symbol, result, next_order); root->symbol_count += 1; - cons_u64toptr_insert(root->arena, &root->symbol_map, symbol_user_id, symbol_user_id_hash, &lookup, result); + raddbgic_u64toptr_insert(root->arena, &root->symbol_map, symbol_user_id, symbol_user_id_hash, &lookup, result); } return result; } static void -cons_symbol_set_info(CONS_Root *root, CONS_Symbol *symbol, CONS_SymbolInfo *info) +raddbgic_symbol_set_info(RADDBGIC_Root *root, RADDBGIC_Symbol *symbol, RADDBGIC_SymbolInfo *info) { // rjf: unpack - CONS_SymbolKind kind = info->kind; - CONS_Symbol *container_symbol = info->container_symbol; - CONS_Type *container_type = info->container_type; + RADDBGIC_SymbolKind kind = info->kind; + RADDBGIC_Symbol *container_symbol = info->container_symbol; + RADDBGIC_Type *container_type = info->container_type; // rjf: requirements - cons_requiref(root, CONS_SymbolKind_NULL == symbol->kind, return, "Symbol information set multiple times."); - cons_requiref(root, CONS_SymbolKind_NULL < info->kind && info->kind < CONS_SymbolKind_COUNT, return, "Invalid symbol kind used to initialize symbol."); - cons_requiref(root, info->type != 0, return, "Invalid type used to initialize symbol."); - cons_requiref(root, info->container_symbol == 0 || info->container_type == 0, container_type = 0, "Symbol initialized with both a containing symbol and containing type, when only one is allowed."); + raddbgic_requiref(root, RADDBGIC_SymbolKind_NULL == symbol->kind, return, "Symbol information set multiple times."); + raddbgic_requiref(root, RADDBGIC_SymbolKind_NULL < info->kind && info->kind < RADDBGIC_SymbolKind_COUNT, return, "Invalid symbol kind used to initialize symbol."); + raddbgic_requiref(root, info->type != 0, return, "Invalid type used to initialize symbol."); + raddbgic_requiref(root, info->container_symbol == 0 || info->container_type == 0, container_type = 0, "Symbol initialized with both a containing symbol and containing type, when only one is allowed."); // rjf: fill root->symbol_kind_counts[kind] += 1; @@ -1346,89 +1346,89 @@ cons_symbol_set_info(CONS_Root *root, CONS_Symbol *symbol, CONS_SymbolInfo *info switch(kind) { default:{}break; - case CONS_SymbolKind_GlobalVariable: - case CONS_SymbolKind_ThreadVariable: + case RADDBGIC_SymbolKind_GlobalVariable: + case RADDBGIC_SymbolKind_ThreadVariable: { - cons_requiref(root, info->root_scope == 0, NoOp, "Global or thread variable initialized with root scope."); + raddbgic_requiref(root, info->root_scope == 0, NoOp, "Global or thread variable initialized with root scope."); }break; - case CONS_SymbolKind_Procedure: + case RADDBGIC_SymbolKind_Procedure: { - cons_requiref(root, info->root_scope != 0, NoOp, "Procedure symbol initialized without root scope."); + raddbgic_requiref(root, info->root_scope != 0, NoOp, "Procedure symbol initialized without root scope."); symbol->root_scope = info->root_scope; - cons_scope_recursive_set_symbol(info->root_scope, symbol); + raddbgic_scope_recursive_set_symbol(info->root_scope, symbol); }break; } // save name map { - CONS_NameMap *map = 0; + RADDBGIC_NameMap *map = 0; switch(kind) { default:{}break; - case CONS_SymbolKind_GlobalVariable: + case RADDBGIC_SymbolKind_GlobalVariable: { - map = cons_name_map_for_kind(root, RADDBGI_NameMapKind_GlobalVariables); + map = raddbgic_name_map_for_kind(root, RADDBGI_NameMapKind_GlobalVariables); }break; - case CONS_SymbolKind_ThreadVariable: + case RADDBGIC_SymbolKind_ThreadVariable: { - map = cons_name_map_for_kind(root, RADDBGI_NameMapKind_ThreadVariables); + map = raddbgic_name_map_for_kind(root, RADDBGI_NameMapKind_ThreadVariables); }break; - case CONS_SymbolKind_Procedure: + case RADDBGIC_SymbolKind_Procedure: { - map = cons_name_map_for_kind(root, RADDBGI_NameMapKind_Procedures); + map = raddbgic_name_map_for_kind(root, RADDBGI_NameMapKind_Procedures); }break; } if(map != 0) { - cons_name_map_add_pair(root, map, symbol->name, symbol->idx); + raddbgic_name_map_add_pair(root, map, symbol->name, symbol->idx); } } // save link name map - if(kind == CONS_SymbolKind_Procedure && symbol->link_name.size > 0) + if(kind == RADDBGIC_SymbolKind_Procedure && symbol->link_name.size > 0) { - CONS_NameMap *map = cons_name_map_for_kind(root, RADDBGI_NameMapKind_LinkNameProcedures); - cons_name_map_add_pair(root, map, symbol->link_name, symbol->idx); + RADDBGIC_NameMap *map = raddbgic_name_map_for_kind(root, RADDBGI_NameMapKind_LinkNameProcedures); + raddbgic_name_map_add_pair(root, map, symbol->link_name, symbol->idx); } } //- rjf: scope info building -static CONS_Scope * -cons_scope_handle_from_user_id(CONS_Root *root, U64 scope_user_id, U64 scope_user_id_hash) +static RADDBGIC_Scope * +raddbgic_scope_handle_from_user_id(RADDBGIC_Root *root, U64 scope_user_id, U64 scope_user_id_hash) { - CONS_Scope *result = 0; - CONS_U64ToPtrLookup lookup = {0}; - cons_u64toptr_lookup(&root->scope_map, scope_user_id, scope_user_id_hash, &lookup); + RADDBGIC_Scope *result = 0; + RADDBGIC_U64ToPtrLookup lookup = {0}; + raddbgic_u64toptr_lookup(&root->scope_map, scope_user_id, scope_user_id_hash, &lookup); if(lookup.match != 0) { - result = (CONS_Scope*)lookup.match; + result = (RADDBGIC_Scope*)lookup.match; } else { - result = push_array(root->arena, CONS_Scope, 1); + result = push_array(root->arena, RADDBGIC_Scope, 1); result->idx = root->scope_count; SLLQueuePush_N(root->first_scope, root->last_scope, result, next_order); root->scope_count += 1; - cons_u64toptr_insert(root->arena, &root->scope_map, scope_user_id, scope_user_id_hash, &lookup, result); + raddbgic_u64toptr_insert(root->arena, &root->scope_map, scope_user_id, scope_user_id_hash, &lookup, result); } return result; } static void -cons_scope_set_parent(CONS_Root *root, CONS_Scope *scope, CONS_Scope *parent) +raddbgic_scope_set_parent(RADDBGIC_Root *root, RADDBGIC_Scope *scope, RADDBGIC_Scope *parent) { - cons_requiref(root, scope->parent_scope == 0, return, "Scope parent set multiple times."); - cons_requiref(root, parent != 0, return, "Tried to set invalid parent as scope parent."); + raddbgic_requiref(root, scope->parent_scope == 0, return, "Scope parent set multiple times."); + raddbgic_requiref(root, parent != 0, return, "Tried to set invalid parent as scope parent."); scope->symbol = parent->symbol; scope->parent_scope = parent; SLLQueuePush_N(parent->first_child, parent->last_child, scope, next_sibling); } static void -cons_scope_add_voff_range(CONS_Root *root, CONS_Scope *scope, U64 voff_first, U64 voff_opl) +raddbgic_scope_add_voff_range(RADDBGIC_Root *root, RADDBGIC_Scope *scope, U64 voff_first, U64 voff_opl) { - CONS_VOffRange *range = push_array(root->arena, CONS_VOffRange, 1); + RADDBGIC_VOffRange *range = push_array(root->arena, RADDBGIC_VOffRange, 1); SLLQueuePush(scope->first_range, scope->last_range, range); scope->range_count += 1; range->voff_first = voff_first; @@ -1438,45 +1438,45 @@ cons_scope_add_voff_range(CONS_Root *root, CONS_Scope *scope, U64 voff_first, U6 } static void -cons_scope_recursive_set_symbol(CONS_Scope *scope, CONS_Symbol *symbol) +raddbgic_scope_recursive_set_symbol(RADDBGIC_Scope *scope, RADDBGIC_Symbol *symbol) { scope->symbol = symbol; - for(CONS_Scope *node = scope->first_child; + for(RADDBGIC_Scope *node = scope->first_child; node != 0; node = node->next_sibling) { - cons_scope_recursive_set_symbol(node, symbol); + raddbgic_scope_recursive_set_symbol(node, symbol); } } //- rjf: local info building -static CONS_Local* -cons_local_handle_from_user_id(CONS_Root *root, U64 local_user_id, U64 local_user_id_hash) +static RADDBGIC_Local* +raddbgic_local_handle_from_user_id(RADDBGIC_Root *root, U64 local_user_id, U64 local_user_id_hash) { - CONS_Local *result = 0; - CONS_U64ToPtrLookup lookup = {0}; - cons_u64toptr_lookup(&root->local_map, local_user_id, local_user_id_hash, &lookup); + RADDBGIC_Local *result = 0; + RADDBGIC_U64ToPtrLookup lookup = {0}; + raddbgic_u64toptr_lookup(&root->local_map, local_user_id, local_user_id_hash, &lookup); if(lookup.match != 0) { - result = (CONS_Local*)lookup.match; + result = (RADDBGIC_Local*)lookup.match; } else { - result = push_array(root->arena, CONS_Local, 1); - cons_u64toptr_insert(root->arena, &root->local_map, local_user_id, local_user_id_hash, &lookup, result); + result = push_array(root->arena, RADDBGIC_Local, 1); + raddbgic_u64toptr_insert(root->arena, &root->local_map, local_user_id, local_user_id_hash, &lookup, result); } return result; } static void -cons_local_set_basic_info(CONS_Root *root, CONS_Local *local, CONS_LocalInfo *info) +raddbgic_local_set_basic_info(RADDBGIC_Root *root, RADDBGIC_Local *local, RADDBGIC_LocalInfo *info) { - cons_requiref(root, local->kind == RADDBGI_LocalKind_NULL, return, "Local information set multiple times."); - cons_requiref(root, info->scope != 0, return, "Tried to set invalid scope as local's containing scope."); - cons_requiref(root, RADDBGI_LocalKind_NULL < info->kind && info->kind < RADDBGI_LocalKind_COUNT, return, "Invalid local kind."); - cons_requiref(root, info->type != 0, return, "Tried to set invalid type as local's type."); - CONS_Scope *scope = info->scope; + raddbgic_requiref(root, local->kind == RADDBGI_LocalKind_NULL, return, "Local information set multiple times."); + raddbgic_requiref(root, info->scope != 0, return, "Tried to set invalid scope as local's containing scope."); + raddbgic_requiref(root, RADDBGI_LocalKind_NULL < info->kind && info->kind < RADDBGI_LocalKind_COUNT, return, "Invalid local kind."); + raddbgic_requiref(root, info->type != 0, return, "Tried to set invalid type as local's type."); + RADDBGIC_Scope *scope = info->scope; SLLQueuePush(scope->first_local, scope->last_local, local); scope->local_count += 1; root->local_count += 1; @@ -1485,13 +1485,13 @@ cons_local_set_basic_info(CONS_Root *root, CONS_Local *local, CONS_LocalInfo *in local->type = info->type; } -static CONS_LocationSet* -cons_location_set_from_local(CONS_Root *root, CONS_Local *local) +static RADDBGIC_LocationSet* +raddbgic_location_set_from_local(RADDBGIC_Root *root, RADDBGIC_Local *local) { - CONS_LocationSet *result = local->locset; + RADDBGIC_LocationSet *result = local->locset; if(result == 0) { - local->locset = push_array(root->arena, CONS_LocationSet, 1); + local->locset = push_array(root->arena, RADDBGIC_LocationSet, 1); result = local->locset; } return result; @@ -1500,9 +1500,9 @@ cons_location_set_from_local(CONS_Root *root, CONS_Local *local) //- rjf: location info building static void -cons_location_set_add_case(CONS_Root *root, CONS_LocationSet *locset, U64 voff_first, U64 voff_opl, CONS_Location *location) +raddbgic_location_set_add_case(RADDBGIC_Root *root, RADDBGIC_LocationSet *locset, U64 voff_first, U64 voff_opl, RADDBGIC_Location *location) { - CONS_LocationCase *location_case = push_array(root->arena, CONS_LocationCase, 1); + RADDBGIC_LocationCase *location_case = push_array(root->arena, RADDBGIC_LocationCase, 1); SLLQueuePush(locset->first_location_case, locset->last_location_case, location_case); locset->location_case_count += 1; root->location_count += 1; @@ -1511,48 +1511,48 @@ cons_location_set_add_case(CONS_Root *root, CONS_LocationSet *locset, U64 voff_f location_case->location = location; } -static CONS_Location* -cons_location_addr_bytecode_stream(CONS_Root *root, struct CONS_EvalBytecode *bytecode) +static RADDBGIC_Location* +raddbgic_location_addr_bytecode_stream(RADDBGIC_Root *root, struct RADDBGIC_EvalBytecode *bytecode) { - CONS_Location *result = push_array(root->arena, CONS_Location, 1); + RADDBGIC_Location *result = push_array(root->arena, RADDBGIC_Location, 1); result->kind = RADDBGI_LocationKind_AddrBytecodeStream; result->bytecode = *bytecode; return result; } -static CONS_Location* -cons_location_val_bytecode_stream(CONS_Root *root, struct CONS_EvalBytecode *bytecode) +static RADDBGIC_Location* +raddbgic_location_val_bytecode_stream(RADDBGIC_Root *root, struct RADDBGIC_EvalBytecode *bytecode) { - CONS_Location *result = push_array(root->arena, CONS_Location, 1); + RADDBGIC_Location *result = push_array(root->arena, RADDBGIC_Location, 1); result->kind = RADDBGI_LocationKind_ValBytecodeStream; result->bytecode = *bytecode; return result; } -static CONS_Location* -cons_location_addr_reg_plus_u16(CONS_Root *root, U8 reg_code, U16 offset) +static RADDBGIC_Location* +raddbgic_location_addr_reg_plus_u16(RADDBGIC_Root *root, U8 reg_code, U16 offset) { - CONS_Location *result = push_array(root->arena, CONS_Location, 1); + RADDBGIC_Location *result = push_array(root->arena, RADDBGIC_Location, 1); result->kind = RADDBGI_LocationKind_AddrRegisterPlusU16; result->register_code = reg_code; result->offset = offset; return result; } -static CONS_Location* -cons_location_addr_addr_reg_plus_u16(CONS_Root *root, U8 reg_code, U16 offset) +static RADDBGIC_Location* +raddbgic_location_addr_addr_reg_plus_u16(RADDBGIC_Root *root, U8 reg_code, U16 offset) { - CONS_Location *result = push_array(root->arena, CONS_Location, 1); + RADDBGIC_Location *result = push_array(root->arena, RADDBGIC_Location, 1); result->kind = RADDBGI_LocationKind_AddrAddrRegisterPlusU16; result->register_code = reg_code; result->offset = offset; return result; } -static CONS_Location* -cons_location_val_reg(CONS_Root *root, U8 reg_code) +static RADDBGIC_Location* +raddbgic_location_val_reg(RADDBGIC_Root *root, U8 reg_code) { - CONS_Location *result = push_array(root->arena, CONS_Location, 1); + RADDBGIC_Location *result = push_array(root->arena, RADDBGIC_Location, 1); result->kind = RADDBGI_LocationKind_ValRegister; result->register_code = reg_code; return result; @@ -1560,17 +1560,17 @@ cons_location_val_reg(CONS_Root *root, U8 reg_code) //- rjf: name map building -static CONS_NameMap* -cons_name_map_for_kind(CONS_Root *root, RADDBGI_NameMapKind kind) +static RADDBGIC_NameMap* +raddbgic_name_map_for_kind(RADDBGIC_Root *root, RADDBGI_NameMapKind kind) { - CONS_NameMap *result = 0; + RADDBGIC_NameMap *result = 0; if(kind < RADDBGI_NameMapKind_COUNT) { if(root->name_maps[kind] == 0) { - root->name_maps[kind] = push_array(root->arena, CONS_NameMap, 1); + root->name_maps[kind] = push_array(root->arena, RADDBGIC_NameMap, 1); root->name_maps[kind]->buckets_count = 16384; - root->name_maps[kind]->buckets = push_array(root->arena, CONS_NameMapNode *, root->name_maps[kind]->buckets_count); + root->name_maps[kind]->buckets = push_array(root->arena, RADDBGIC_NameMapNode *, root->name_maps[kind]->buckets_count); } result = root->name_maps[kind]; } @@ -1578,15 +1578,15 @@ cons_name_map_for_kind(CONS_Root *root, RADDBGI_NameMapKind kind) } static void -cons_name_map_add_pair(CONS_Root *root, CONS_NameMap *map, String8 string, U32 idx) +raddbgic_name_map_add_pair(RADDBGIC_Root *root, RADDBGIC_NameMap *map, String8 string, U32 idx) { // hash U64 hash = raddbgi_hash(string.str, string.size); U64 bucket_idx = hash%map->buckets_count; // find existing name node - CONS_NameMapNode *match = 0; - for(CONS_NameMapNode *node = map->buckets[bucket_idx]; + RADDBGIC_NameMapNode *match = 0; + for(RADDBGIC_NameMapNode *node = map->buckets[bucket_idx]; node != 0; node = node->bucket_next) { @@ -1600,7 +1600,7 @@ cons_name_map_add_pair(CONS_Root *root, CONS_NameMap *map, String8 string, U32 i // make name node if necessary if(match == 0) { - match = push_array(root->arena, CONS_NameMapNode, 1); + match = push_array(root->arena, RADDBGIC_NameMapNode, 1); match->string = push_str8_copy(root->arena, string); SLLStackPush_N(map->buckets[bucket_idx], match, bucket_next); SLLQueuePush_N(map->first, map->last, match, order_next); @@ -1610,7 +1610,7 @@ cons_name_map_add_pair(CONS_Root *root, CONS_NameMap *map, String8 string, U32 i // find existing idx B32 existing_idx = 0; - for(CONS_NameMapIdxNode *node = match->idx_first; + for(RADDBGIC_NameMapIdxNode *node = match->idx_first; node != 0; node = node->next) { @@ -1631,11 +1631,11 @@ cons_name_map_add_pair(CONS_Root *root, CONS_NameMap *map, String8 string, U32 i // insert new idx if necessary if(!existing_idx) { - CONS_NameMapIdxNode *idx_node = match->idx_last; + RADDBGIC_NameMapIdxNode *idx_node = match->idx_last; U32 insert_i = match->idx_count%ArrayCount(idx_node->idx); if(insert_i == 0) { - idx_node = push_array(root->arena, CONS_NameMapIdxNode, 1); + idx_node = push_array(root->arena, RADDBGIC_NameMapIdxNode, 1); SLLQueuePush(match->idx_first, match->idx_last, idx_node); } @@ -1649,27 +1649,27 @@ cons_name_map_add_pair(CONS_Root *root, CONS_NameMap *map, String8 string, U32 i //- rjf: bake context construction -static CONS_BakeCtx* -cons_bake_ctx_begin(CONS_BakeParams *params) +static RADDBGIC_BakeCtx* +raddbgic_bake_ctx_begin(RADDBGIC_BakeParams *params) { Arena *arena = arena_alloc(); - CONS_BakeCtx *result = push_array(arena, CONS_BakeCtx, 1); + RADDBGIC_BakeCtx *result = push_array(arena, RADDBGIC_BakeCtx, 1); result->arena = arena; #define BKTCOUNT(x) ((x)?(u64_up_to_pow2(x)):(16384)) result->strs.buckets_count = BKTCOUNT(params->strings_bucket_count); result->idxs.buckets_count = BKTCOUNT(params->idx_runs_bucket_count); #undef BKTCOUNT - result->strs.buckets = push_array(arena, CONS_StringNode *, result->strs.buckets_count); - result->idxs.buckets = push_array(arena, CONS_IdxRunNode *, result->idxs.buckets_count); + result->strs.buckets = push_array(arena, RADDBGIC_StringNode *, result->strs.buckets_count); + result->idxs.buckets = push_array(arena, RADDBGIC_IdxRunNode *, result->idxs.buckets_count); - cons_string(result, str8_lit("")); - cons_idx_run(result, 0, 0); + raddbgic_string(result, str8_lit("")); + raddbgic_idx_run(result, 0, 0); - result->tree = push_array(arena, CONS_PathTree, 1); + result->tree = push_array(arena, RADDBGIC_PathTree, 1); { - CONS_PathNode *nil_path_node = cons_paths_new_node(result); + RADDBGIC_PathNode *nil_path_node = raddbgic_paths_new_node(result); nil_path_node->name = str8_lit(""); - CONS_SrcNode *nil_src_node = cons_paths_new_src_node(result); + RADDBGIC_SrcNode *nil_src_node = raddbgic_paths_new_src_node(result); nil_src_node->path_node = nil_path_node; nil_src_node->normal_full_path = str8_lit(""); nil_path_node->src_file = nil_src_node; @@ -1679,7 +1679,7 @@ cons_bake_ctx_begin(CONS_BakeParams *params) } static void -cons_bake_ctx_release(CONS_BakeCtx *bake_ctx) +raddbgic_bake_ctx_release(RADDBGIC_BakeCtx *bake_ctx) { arena_release(bake_ctx->arena); } @@ -1687,16 +1687,16 @@ cons_bake_ctx_release(CONS_BakeCtx *bake_ctx) //- rjf: string baking static U32 -cons_string(CONS_BakeCtx *bctx, String8 str) +raddbgic_string(RADDBGIC_BakeCtx *bctx, String8 str) { Arena *arena = bctx->arena; - CONS_Strings *strs = &bctx->strs; + RADDBGIC_Strings *strs = &bctx->strs; U64 hash = raddbgi_hash(str.str, str.size); U64 bucket_idx = hash%strs->buckets_count; // look for a match - CONS_StringNode *match = 0; - for(CONS_StringNode *node = strs->buckets[bucket_idx]; + RADDBGIC_StringNode *match = 0; + for(RADDBGIC_StringNode *node = strs->buckets[bucket_idx]; node != 0; node = node->bucket_next) { @@ -1710,7 +1710,7 @@ cons_string(CONS_BakeCtx *bctx, String8 str) // insert new node if no match if(match == 0) { - CONS_StringNode *node = push_array_no_zero(arena, CONS_StringNode, 1); + RADDBGIC_StringNode *node = push_array_no_zero(arena, RADDBGIC_StringNode, 1); node->str = push_str8_copy(arena, str); node->hash = hash; node->idx = strs->count; @@ -1730,7 +1730,7 @@ cons_string(CONS_BakeCtx *bctx, String8 str) //- rjf: idx run baking static U64 -cons_idx_run_hash(U32 *idx_run, U32 count) +raddbgic_idx_run_hash(U32 *idx_run, U32 count) { U64 hash = 5381; U32 *ptr = idx_run; @@ -1743,17 +1743,17 @@ cons_idx_run_hash(U32 *idx_run, U32 count) } static U32 -cons_idx_run(CONS_BakeCtx *bctx, U32 *idx_run, U32 count) +raddbgic_idx_run(RADDBGIC_BakeCtx *bctx, U32 *idx_run, U32 count) { Arena *arena = bctx->arena; - CONS_IdxRuns *idxs = &bctx->idxs; + RADDBGIC_IdxRuns *idxs = &bctx->idxs; - U64 hash = cons_idx_run_hash(idx_run, count); + U64 hash = raddbgic_idx_run_hash(idx_run, count); U64 bucket_idx = hash%idxs->buckets_count; // look for a match - CONS_IdxRunNode *match = 0; - for(CONS_IdxRunNode *node = idxs->buckets[bucket_idx]; + RADDBGIC_IdxRunNode *match = 0; + for(RADDBGIC_IdxRunNode *node = idxs->buckets[bucket_idx]; node != 0; node = node->bucket_next) { @@ -1780,7 +1780,7 @@ cons_idx_run(CONS_BakeCtx *bctx, U32 *idx_run, U32 count) // insert new node if no match if(match == 0) { - CONS_IdxRunNode *node = push_array_no_zero(arena, CONS_IdxRunNode, 1); + RADDBGIC_IdxRunNode *node = push_array_no_zero(arena, RADDBGIC_IdxRunNode, 1); U32 *idx_run_copy = push_array_no_zero(arena, U32, count); for(U32 i = 0; i < count; i += 1) { @@ -1807,10 +1807,10 @@ cons_idx_run(CONS_BakeCtx *bctx, U32 *idx_run, U32 count) //- rjf: data section baking static U32 -cons_dsection(Arena *arena, CONS_DSections *dss, void *data, U64 size, RADDBGI_DataSectionTag tag) +raddbgic_dsection(Arena *arena, RADDBGIC_DSections *dss, void *data, U64 size, RADDBGI_DataSectionTag tag) { U32 result = dss->count; - CONS_DSectionNode *node = push_array(arena, CONS_DSectionNode, 1); + RADDBGIC_DSectionNode *node = push_array(arena, RADDBGIC_DSectionNode, 1); SLLQueuePush(dss->first, dss->last, node); node->data = data; node->size = size; @@ -1822,13 +1822,13 @@ cons_dsection(Arena *arena, CONS_DSections *dss, void *data, U64 size, RADDBGI_D //- rjf: paths baking static String8 -cons_normal_string_from_path_node(Arena *arena, CONS_PathNode *node) +raddbgic_normal_string_from_path_node(Arena *arena, RADDBGIC_PathNode *node) { Temp scratch = scratch_begin(&arena, 1); String8List list = {0}; if(node != 0) { - cons_normal_string_from_path_node_build(scratch.arena, node, &list); + raddbgic_normal_string_from_path_node_build(scratch.arena, node, &list); } StringJoin join = {0}; join.sep = str8_lit("/"); @@ -1848,12 +1848,12 @@ cons_normal_string_from_path_node(Arena *arena, CONS_PathNode *node) } static void -cons_normal_string_from_path_node_build(Arena *arena, CONS_PathNode *node, String8List *out) +raddbgic_normal_string_from_path_node_build(Arena *arena, RADDBGIC_PathNode *node, String8List *out) { // TODO(rjf): why is this recursive... if(node->parent != 0) { - cons_normal_string_from_path_node_build(arena, node->parent, out); + raddbgic_normal_string_from_path_node_build(arena, node->parent, out); } if(node->name.size > 0) { @@ -1861,23 +1861,23 @@ cons_normal_string_from_path_node_build(Arena *arena, CONS_PathNode *node, Strin } } -static CONS_PathNode* -cons_paths_new_node(CONS_BakeCtx *bctx) +static RADDBGIC_PathNode* +raddbgic_paths_new_node(RADDBGIC_BakeCtx *bctx) { - CONS_PathTree *tree = bctx->tree; - CONS_PathNode *result = push_array(bctx->arena, CONS_PathNode, 1); + RADDBGIC_PathTree *tree = bctx->tree; + RADDBGIC_PathNode *result = push_array(bctx->arena, RADDBGIC_PathNode, 1); SLLQueuePush_N(tree->first, tree->last, result, next_order); result->idx = tree->count; tree->count += 1; return result; } -static CONS_PathNode* -cons_paths_sub_path(CONS_BakeCtx *bctx, CONS_PathNode *dir, String8 sub_dir) +static RADDBGIC_PathNode* +raddbgic_paths_sub_path(RADDBGIC_BakeCtx *bctx, RADDBGIC_PathNode *dir, String8 sub_dir) { // look for existing match - CONS_PathNode *match = 0; - for(CONS_PathNode *node = dir->first_child; + RADDBGIC_PathNode *match = 0; + for(RADDBGIC_PathNode *node = dir->first_child; node != 0; node = node->next_sibling){ if(str8_match(node->name, sub_dir, StringMatchFlag_CaseInsensitive)){ @@ -1887,16 +1887,16 @@ cons_paths_sub_path(CONS_BakeCtx *bctx, CONS_PathNode *dir, String8 sub_dir) } // construct new node if no match - CONS_PathNode *new_node = 0; + RADDBGIC_PathNode *new_node = 0; if(match == 0){ - new_node = cons_paths_new_node(bctx); + new_node = raddbgic_paths_new_node(bctx); new_node->parent = dir; SLLQueuePush_N(dir->first_child, dir->last_child, new_node, next_sibling); new_node->name = push_str8_copy(bctx->arena, sub_dir); } // select result from the two paths - CONS_PathNode *result = match; + RADDBGIC_PathNode *result = match; if(match == 0){ result = new_node; } @@ -1904,10 +1904,10 @@ cons_paths_sub_path(CONS_BakeCtx *bctx, CONS_PathNode *dir, String8 sub_dir) return result; } -static CONS_PathNode* -cons_paths_node_from_path(CONS_BakeCtx *bctx, String8 path) +static RADDBGIC_PathNode* +raddbgic_paths_node_from_path(RADDBGIC_BakeCtx *bctx, String8 path) { - CONS_PathNode *node_cursor = &bctx->tree->root; + RADDBGIC_PathNode *node_cursor = &bctx->tree->root; U8 *ptr = path.str; U8 *opl = path.str + path.size; @@ -1924,42 +1924,42 @@ cons_paths_node_from_path(CONS_BakeCtx *bctx, String8 path) // if range is non-empty advance the node cursor if(range_first < ptr){ String8 sub_dir = str8_range(range_first, ptr); - node_cursor = cons_paths_sub_path(bctx, node_cursor, sub_dir); + node_cursor = raddbgic_paths_sub_path(bctx, node_cursor, sub_dir); } } - CONS_PathNode *result = node_cursor; + RADDBGIC_PathNode *result = node_cursor; return result; } static U32 -cons_paths_idx_from_path(CONS_BakeCtx *bctx, String8 path) +raddbgic_paths_idx_from_path(RADDBGIC_BakeCtx *bctx, String8 path) { - CONS_PathNode *node = cons_paths_node_from_path(bctx, path); + RADDBGIC_PathNode *node = raddbgic_paths_node_from_path(bctx, path); U32 result = node->idx; return result; } -static CONS_SrcNode* -cons_paths_new_src_node(CONS_BakeCtx *bctx) +static RADDBGIC_SrcNode* +raddbgic_paths_new_src_node(RADDBGIC_BakeCtx *bctx) { - CONS_PathTree *tree = bctx->tree; - CONS_SrcNode *result = push_array(bctx->arena, CONS_SrcNode, 1); + RADDBGIC_PathTree *tree = bctx->tree; + RADDBGIC_SrcNode *result = push_array(bctx->arena, RADDBGIC_SrcNode, 1); SLLQueuePush(tree->src_first, tree->src_last, result); result->idx = tree->src_count; tree->src_count += 1; return result; } -static CONS_SrcNode* -cons_paths_src_node_from_path_node(CONS_BakeCtx *bctx, CONS_PathNode *path_node) +static RADDBGIC_SrcNode* +raddbgic_paths_src_node_from_path_node(RADDBGIC_BakeCtx *bctx, RADDBGIC_PathNode *path_node) { - CONS_SrcNode *result = path_node->src_file; + RADDBGIC_SrcNode *result = path_node->src_file; if(result == 0) { - CONS_SrcNode *new_node = cons_paths_new_src_node(bctx); + RADDBGIC_SrcNode *new_node = raddbgic_paths_new_src_node(bctx); new_node->path_node = path_node; - new_node->normal_full_path = cons_normal_string_from_path_node(bctx->arena, path_node); + new_node->normal_full_path = raddbgic_normal_string_from_path_node(bctx->arena, path_node); result = path_node->src_file = new_node; } return result; @@ -1967,10 +1967,10 @@ cons_paths_src_node_from_path_node(CONS_BakeCtx *bctx, CONS_PathNode *path_node) //- rjf: per-unit line info baking -static CONS_UnitLinesCombined* -cons_unit_combine_lines(Arena *arena, CONS_BakeCtx *bctx, CONS_LineSequenceNode *first_seq) +static RADDBGIC_UnitLinesCombined* +raddbgic_unit_combine_lines(Arena *arena, RADDBGIC_BakeCtx *bctx, RADDBGIC_LineSequenceNode *first_seq) { - ProfBegin("cons_unit_combine_lines"); + ProfBegin("raddbgic_unit_combine_lines"); Temp scratch = scratch_begin(&arena, 1); // gather up all line info into two arrays @@ -1978,7 +1978,7 @@ cons_unit_combine_lines(Arena *arena, CONS_BakeCtx *bctx, CONS_LineSequenceNode // recs: contains all the source coordinates for a range of voffs U64 line_count = 0; U64 seq_count = 0; - for(CONS_LineSequenceNode *node = first_seq; + for(RADDBGIC_LineSequenceNode *node = first_seq; node != 0; node = node->next){ seq_count += 1; @@ -1986,19 +1986,19 @@ cons_unit_combine_lines(Arena *arena, CONS_BakeCtx *bctx, CONS_LineSequenceNode } U64 key_count = line_count + seq_count; - CONS_SortKey *line_keys = push_array_no_zero(scratch.arena, CONS_SortKey, key_count); - CONS_LineRec *line_recs = push_array_no_zero(scratch.arena, CONS_LineRec, line_count); + RADDBGIC_SortKey *line_keys = push_array_no_zero(scratch.arena, RADDBGIC_SortKey, key_count); + RADDBGIC_LineRec *line_recs = push_array_no_zero(scratch.arena, RADDBGIC_LineRec, line_count); { - CONS_SortKey *key_ptr = line_keys; - CONS_LineRec *rec_ptr = line_recs; + RADDBGIC_SortKey *key_ptr = line_keys; + RADDBGIC_LineRec *rec_ptr = line_recs; - for(CONS_LineSequenceNode *node = first_seq; + for(RADDBGIC_LineSequenceNode *node = first_seq; node != 0; node = node->next){ - CONS_PathNode *src_path = - cons_paths_node_from_path(bctx, node->line_seq.file_name); - CONS_SrcNode *src_file = cons_paths_src_node_from_path_node(bctx, src_path); + RADDBGIC_PathNode *src_path = + raddbgic_paths_node_from_path(bctx, node->line_seq.file_name); + RADDBGIC_SrcNode *src_file = raddbgic_paths_src_node_from_path_node(bctx, src_path); U32 file_id = src_file->idx; U64 node_line_count = node->line_seq.line_count; @@ -2020,14 +2020,14 @@ cons_unit_combine_lines(Arena *arena, CONS_BakeCtx *bctx, CONS_LineSequenceNode key_ptr->val = 0; key_ptr += 1; - CONS_LineMapFragment *fragment = push_array(arena, CONS_LineMapFragment, 1); + RADDBGIC_LineMapFragment *fragment = push_array(arena, RADDBGIC_LineMapFragment, 1); SLLQueuePush(src_file->first_fragment, src_file->last_fragment, fragment); fragment->sequence = node; } } // sort - CONS_SortKey *sorted_line_keys = cons_sort_key_array(scratch.arena, line_keys, key_count); + RADDBGIC_SortKey *sorted_line_keys = raddbgic_sort_key_array(scratch.arena, line_keys, key_count); // TODO(allen): do a pass over sorted keys to make sure duplicate keys are sorted with // null record first, and no more than one null record and one non-null record @@ -2041,7 +2041,7 @@ cons_unit_combine_lines(Arena *arena, CONS_BakeCtx *bctx, CONS_LineSequenceNode } arranged_voffs[key_count] = ~0ull; for(U64 i = 0; i < key_count; i += 1){ - CONS_LineRec *rec = (CONS_LineRec*)sorted_line_keys[i].val; + RADDBGIC_LineRec *rec = (RADDBGIC_LineRec*)sorted_line_keys[i].val; if(rec != 0){ arranged_lines[i].file_idx = rec->file_id; arranged_lines[i].line_num = rec->line_num; @@ -2052,7 +2052,7 @@ cons_unit_combine_lines(Arena *arena, CONS_BakeCtx *bctx, CONS_LineSequenceNode } } - CONS_UnitLinesCombined *result = push_array(arena, CONS_UnitLinesCombined, 1); + RADDBGIC_UnitLinesCombined *result = push_array(arena, RADDBGIC_UnitLinesCombined, 1); result->voffs = arranged_voffs; result->lines = arranged_lines; result->cols = 0; @@ -2066,27 +2066,27 @@ cons_unit_combine_lines(Arena *arena, CONS_BakeCtx *bctx, CONS_LineSequenceNode //- rjf: per-src line info baking -static CONS_SrcLinesCombined* -cons_source_combine_lines(Arena *arena, CONS_LineMapFragment *first) +static RADDBGIC_SrcLinesCombined* +raddbgic_source_combine_lines(Arena *arena, RADDBGIC_LineMapFragment *first) { - ProfBegin("cons_source_combine_lines"); + ProfBegin("raddbgic_source_combine_lines"); Temp scratch = scratch_begin(&arena, 1); // gather line number map - CONS_SrcLineMapBucket *first_bucket = 0; - CONS_SrcLineMapBucket *last_bucket = 0; + RADDBGIC_SrcLineMapBucket *first_bucket = 0; + RADDBGIC_SrcLineMapBucket *last_bucket = 0; U64 line_hash_slots_count = 1024; - CONS_SrcLineMapBucket **line_hash_slots = push_array(scratch.arena, CONS_SrcLineMapBucket *, line_hash_slots_count); + RADDBGIC_SrcLineMapBucket **line_hash_slots = push_array(scratch.arena, RADDBGIC_SrcLineMapBucket *, line_hash_slots_count); U64 line_count = 0; U64 voff_count = 0; U64 max_line_num = 0; ProfScope("gather line number map") { - for(CONS_LineMapFragment *map_fragment = first; + for(RADDBGIC_LineMapFragment *map_fragment = first; map_fragment != 0; map_fragment = map_fragment->next) { - CONS_LineSequence *sequence = &map_fragment->sequence->line_seq; + RADDBGIC_LineSequence *sequence = &map_fragment->sequence->line_seq; U64 *seq_voffs = sequence->voffs; U32 *seq_line_nums = sequence->line_nums; @@ -2101,9 +2101,9 @@ cons_source_combine_lines(Arena *arena, CONS_LineMapFragment *first) max_line_num = Max(max_line_num, line_num); // find match - CONS_SrcLineMapBucket *match = 0; + RADDBGIC_SrcLineMapBucket *match = 0; { - for(CONS_SrcLineMapBucket *node = line_hash_slots[line_hash_slot_idx]; + for(RADDBGIC_SrcLineMapBucket *node = line_hash_slots[line_hash_slot_idx]; node != 0; node = node->hash_next){ if(node->line_num == line_num){ @@ -2115,7 +2115,7 @@ cons_source_combine_lines(Arena *arena, CONS_LineMapFragment *first) // introduce new line if no match if(match == 0){ - match = push_array(scratch.arena, CONS_SrcLineMapBucket, 1); + match = push_array(scratch.arena, RADDBGIC_SrcLineMapBucket, 1); SLLQueuePush_N(first_bucket, last_bucket, match, order_next); SLLStackPush_N(line_hash_slots[line_hash_slot_idx], match, hash_next); match->line_num = line_num; @@ -2124,7 +2124,7 @@ cons_source_combine_lines(Arena *arena, CONS_LineMapFragment *first) // insert new voff { - CONS_SrcLineMapVoffBlock *block = push_array(scratch.arena, CONS_SrcLineMapVoffBlock, 1); + RADDBGIC_SrcLineMapVoffBlock *block = push_array(scratch.arena, RADDBGIC_SrcLineMapVoffBlock, 1); SLLQueuePush(match->first_voff_block, match->last_voff_block, block); match->voff_count += 1; block->voff = voff; @@ -2134,11 +2134,11 @@ cons_source_combine_lines(Arena *arena, CONS_LineMapFragment *first) } // bake sortable keys array - CONS_SortKey *keys = push_array_no_zero(scratch.arena, CONS_SortKey, line_count); + RADDBGIC_SortKey *keys = push_array_no_zero(scratch.arena, RADDBGIC_SortKey, line_count); ProfScope("bake sortable keys array") { - CONS_SortKey *key_ptr = keys; - for(CONS_SrcLineMapBucket *node = first_bucket; + RADDBGIC_SortKey *key_ptr = keys; + for(RADDBGIC_SrcLineMapBucket *node = first_bucket; node != 0; node = node->order_next, key_ptr += 1){ key_ptr->key = node->line_num; @@ -2147,7 +2147,7 @@ cons_source_combine_lines(Arena *arena, CONS_LineMapFragment *first) } // sort - CONS_SortKey *sorted_keys = cons_sort_key_array(scratch.arena, keys, line_count); + RADDBGIC_SortKey *sorted_keys = raddbgic_sort_key_array(scratch.arena, keys, line_count); // bake result U32 *line_nums = push_array_no_zero(arena, U32, line_count); @@ -2159,8 +2159,8 @@ cons_source_combine_lines(Arena *arena, CONS_LineMapFragment *first) for(U32 i = 0; i < line_count; i += 1){ line_nums[i] = sorted_keys[i].key; line_ranges[i] = (U32)(voff_ptr - voffs); - CONS_SrcLineMapBucket *bucket = (CONS_SrcLineMapBucket*)sorted_keys[i].val; - for(CONS_SrcLineMapVoffBlock *node = bucket->first_voff_block; + RADDBGIC_SrcLineMapBucket *bucket = (RADDBGIC_SrcLineMapBucket*)sorted_keys[i].val; + for(RADDBGIC_SrcLineMapVoffBlock *node = bucket->first_voff_block; node != 0; node = node->next){ *voff_ptr = node->voff; @@ -2170,7 +2170,7 @@ cons_source_combine_lines(Arena *arena, CONS_LineMapFragment *first) line_ranges[line_count] = voff_count; } - CONS_SrcLinesCombined *result = push_array(arena, CONS_SrcLinesCombined, 1); + RADDBGIC_SrcLinesCombined *result = push_array(arena, RADDBGIC_SrcLinesCombined, 1); result->line_nums = line_nums; result->line_ranges = line_ranges; result->line_count = line_count; @@ -2184,13 +2184,13 @@ cons_source_combine_lines(Arena *arena, CONS_LineMapFragment *first) } //- rjf: vmap baking -static CONS_VMap* -cons_vmap_from_markers(Arena *arena, CONS_VMapMarker *markers, CONS_SortKey *keys, U64 marker_count) +static RADDBGIC_VMap* +raddbgic_vmap_from_markers(Arena *arena, RADDBGIC_VMapMarker *markers, RADDBGIC_SortKey *keys, U64 marker_count) { Temp scratch = scratch_begin(&arena, 1); // sort markers - CONS_SortKey *sorted_keys = cons_sort_key_array(scratch.arena, keys, marker_count); + RADDBGIC_SortKey *sorted_keys = raddbgic_sort_key_array(scratch.arena, keys, marker_count); // determine if an extra vmap entry for zero is needed U32 extra_vmap_entry = 0; @@ -2212,11 +2212,11 @@ cons_vmap_from_markers(Arena *arena, CONS_VMapMarker *markers, CONS_SortKey *key vmap_ptr += 1; } - CONS_VMapRangeTracker *tracker_stack = 0; - CONS_VMapRangeTracker *tracker_free = 0; + RADDBGIC_VMapRangeTracker *tracker_stack = 0; + RADDBGIC_VMapRangeTracker *tracker_free = 0; - CONS_SortKey *key_ptr = sorted_keys; - CONS_SortKey *key_opl = sorted_keys + marker_count; + RADDBGIC_SortKey *key_ptr = sorted_keys; + RADDBGIC_SortKey *key_opl = sorted_keys + marker_count; for(;key_ptr < key_opl;){ // get initial map state from tracker stack U32 initial_idx = max_U32; @@ -2229,17 +2229,17 @@ cons_vmap_from_markers(Arena *arena, CONS_VMapMarker *markers, CONS_SortKey *key U64 voff = key_ptr->key; for(;key_ptr < key_opl && key_ptr->key == voff; key_ptr += 1){ - CONS_VMapMarker *marker = (CONS_VMapMarker*)key_ptr->val; + RADDBGIC_VMapMarker *marker = (RADDBGIC_VMapMarker*)key_ptr->val; U32 idx = marker->idx; // push to stack if(marker->begin_range){ - CONS_VMapRangeTracker *new_tracker = tracker_free; + RADDBGIC_VMapRangeTracker *new_tracker = tracker_free; if(new_tracker != 0){ SLLStackPop(tracker_free); } else{ - new_tracker = push_array(scratch.arena, CONS_VMapRangeTracker, 1); + new_tracker = push_array(scratch.arena, RADDBGIC_VMapRangeTracker, 1); } SLLStackPush(tracker_stack, new_tracker); new_tracker->idx = idx; @@ -2247,9 +2247,9 @@ cons_vmap_from_markers(Arena *arena, CONS_VMapMarker *markers, CONS_SortKey *key // pop matching node from stack (not always the top) else{ - CONS_VMapRangeTracker **ptr_in = &tracker_stack; - CONS_VMapRangeTracker *match = 0; - for(CONS_VMapRangeTracker *node = tracker_stack; + RADDBGIC_VMapRangeTracker **ptr_in = &tracker_stack; + RADDBGIC_VMapRangeTracker *match = 0; + for(RADDBGIC_VMapRangeTracker *node = tracker_stack; node != 0;){ if(node->idx == idx){ match = node; @@ -2325,7 +2325,7 @@ cons_vmap_from_markers(Arena *arena, CONS_VMapMarker *markers, CONS_SortKey *key } // fill result - CONS_VMap *result = push_array(arena, CONS_VMap, 1); + RADDBGIC_VMap *result = push_array(arena, RADDBGIC_VMap, 1); result->vmap = vmap; result->count = vmap_entry_count - 1; @@ -2334,8 +2334,8 @@ cons_vmap_from_markers(Arena *arena, CONS_VMapMarker *markers, CONS_SortKey *key return result; } -static CONS_VMap* -cons_vmap_from_unit_ranges(Arena *arena, CONS_UnitVMapRange *first, U64 count) +static RADDBGIC_VMap* +raddbgic_vmap_from_unit_ranges(Arena *arena, RADDBGIC_UnitVMapRange *first, U64 count) { Temp scratch = scratch_begin(&arena, 1); @@ -2343,13 +2343,13 @@ cons_vmap_from_unit_ranges(Arena *arena, CONS_UnitVMapRange *first, U64 count) U64 marker_count = count*2; // fill markers - CONS_SortKey *keys = push_array_no_zero(scratch.arena, CONS_SortKey, marker_count); - CONS_VMapMarker *markers = push_array_no_zero(scratch.arena, CONS_VMapMarker, marker_count); + RADDBGIC_SortKey *keys = push_array_no_zero(scratch.arena, RADDBGIC_SortKey, marker_count); + RADDBGIC_VMapMarker *markers = push_array_no_zero(scratch.arena, RADDBGIC_VMapMarker, marker_count); { - CONS_SortKey *key_ptr = keys; - CONS_VMapMarker *marker_ptr = markers; - for(CONS_UnitVMapRange *range = first; + RADDBGIC_SortKey *key_ptr = keys; + RADDBGIC_VMapMarker *marker_ptr = markers; + for(RADDBGIC_UnitVMapRange *range = first; range != 0; range = range->next){ if(range->first < range->opl){ @@ -2373,7 +2373,7 @@ cons_vmap_from_unit_ranges(Arena *arena, CONS_UnitVMapRange *first, U64 count) } // construct vmap - CONS_VMap *result = cons_vmap_from_markers(arena, markers, keys, marker_count); + RADDBGIC_VMap *result = raddbgic_vmap_from_markers(arena, markers, keys, marker_count); scratch_end(scratch); return result; } @@ -2381,7 +2381,7 @@ cons_vmap_from_unit_ranges(Arena *arena, CONS_UnitVMapRange *first, U64 count) //- rjf: type info baking static U32* -cons_idx_run_from_types(Arena *arena, CONS_Type **types, U32 count) +raddbgic_idx_run_from_types(Arena *arena, RADDBGIC_Type **types, U32 count) { U32 *result = push_array(arena, U32, count); for(U32 i = 0; i < count; i += 1){ @@ -2390,10 +2390,10 @@ cons_idx_run_from_types(Arena *arena, CONS_Type **types, U32 count) return result; } -static CONS_TypeData* -cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) +static RADDBGIC_TypeData* +raddbgic_type_data_combine(Arena *arena, RADDBGIC_Root *root, RADDBGIC_BakeCtx *bctx) { - ProfBegin("cons_type_data_combine"); + ProfBegin("raddbgic_type_data_combine"); Temp scratch = scratch_begin(&arena, 1); // fill type nodes @@ -2403,7 +2403,7 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) { RADDBGI_TypeNode *ptr = type_nodes; RADDBGI_TypeNode *opl = ptr + type_count; - CONS_Type *loose_type = root->first_type; + RADDBGIC_Type *loose_type = root->first_type; for(;loose_type != 0 && ptr < opl; loose_type = loose_type->next_order, ptr += 1){ @@ -2416,7 +2416,7 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) // built-in if(RADDBGI_TypeKind_FirstBuiltIn <= kind && kind <= RADDBGI_TypeKind_LastBuiltIn){ - ptr->built_in.name_string_idx = cons_string(bctx, loose_type->name); + ptr->built_in.name_string_idx = raddbgic_string(bctx, loose_type->name); } // constructed @@ -2433,8 +2433,8 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) { // parameters U32 count = loose_type->count; - U32 *idx_run = cons_idx_run_from_types(scratch.arena, loose_type->param_types, count); - ptr->constructed.param_idx_run_first = cons_idx_run(bctx, idx_run, count); + U32 *idx_run = raddbgic_idx_run_from_types(scratch.arena, loose_type->param_types, count); + ptr->constructed.param_idx_run_first = raddbgic_idx_run(bctx, idx_run, count); ptr->constructed.count = count; }break; @@ -2442,8 +2442,8 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) { // parameters U32 count = loose_type->count; - U32 *idx_run = cons_idx_run_from_types(scratch.arena, loose_type->param_types, count); - ptr->constructed.param_idx_run_first = cons_idx_run(bctx, idx_run, count); + U32 *idx_run = raddbgic_idx_run_from_types(scratch.arena, loose_type->param_types, count); + ptr->constructed.param_idx_run_first = raddbgic_idx_run(bctx, idx_run, count); ptr->constructed.count = count; }break; } @@ -2451,7 +2451,7 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) // user-defined else if(RADDBGI_TypeKind_FirstUserDefined <= kind && kind <= RADDBGI_TypeKind_LastUserDefined){ - ptr->user_defined.name_string_idx = cons_string(bctx, loose_type->name); + ptr->user_defined.name_string_idx = raddbgic_string(bctx, loose_type->name); if(loose_type->udt != 0){ ptr->user_defined.udt_idx = loose_type->udt->idx; } @@ -2495,7 +2495,7 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) RADDBGI_EnumMember *enum_member_ptr = enum_members; RADDBGI_EnumMember *enum_member_opl = enum_members + enum_member_count; - CONS_TypeUDT *loose_udt = root->first_udt; + RADDBGIC_TypeUDT *loose_udt = root->first_udt; for(;loose_udt != 0 && ptr < opl; loose_udt = loose_udt->next_order, ptr += 1){ ptr->self_type_idx = loose_udt->self_type->idx; @@ -2511,11 +2511,11 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) ptr->member_count = loose_udt->enum_val_count; U32 local_enum_val_count = loose_udt->enum_val_count; - CONS_TypeEnumVal *loose_enum_val = loose_udt->first_enum_val; + RADDBGIC_TypeEnumVal *loose_enum_val = loose_udt->first_enum_val; for(U32 i = 0; i < local_enum_val_count; i += 1, enum_member_ptr += 1, loose_enum_val = loose_enum_val->next){ - enum_member_ptr->name_string_idx = cons_string(bctx, loose_enum_val->name); + enum_member_ptr->name_string_idx = raddbgic_string(bctx, loose_enum_val->name); enum_member_ptr->val = loose_enum_val->val; } } @@ -2526,13 +2526,13 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) ptr->member_count = loose_udt->member_count; U32 local_member_count = loose_udt->member_count; - CONS_TypeMember *loose_member = loose_udt->first_member; + RADDBGIC_TypeMember *loose_member = loose_udt->first_member; for(U32 i = 0; i < local_member_count; i += 1, member_ptr += 1, loose_member = loose_member->next){ member_ptr->kind = loose_member->kind; // TODO(allen): member_ptr->visibility = ; - member_ptr->name_string_idx = cons_string(bctx, loose_member->name); + member_ptr->name_string_idx = raddbgic_string(bctx, loose_member->name); member_ptr->off = loose_member->off; member_ptr->type_idx = loose_member->type->idx; @@ -2547,8 +2547,8 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) U32 file_idx = 0; if(loose_udt->source_path.size > 0){ - CONS_PathNode *path_node = cons_paths_node_from_path(bctx, loose_udt->source_path); - CONS_SrcNode *src_node = cons_paths_src_node_from_path_node(bctx, path_node); + RADDBGIC_PathNode *path_node = raddbgic_paths_node_from_path(bctx, loose_udt->source_path); + RADDBGIC_SrcNode *src_node = raddbgic_paths_src_node_from_path_node(bctx, path_node); file_idx = src_node->idx; } @@ -2566,7 +2566,7 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) // fill result - CONS_TypeData *result = push_array(arena, CONS_TypeData, 1); + RADDBGIC_TypeData *result = push_array(arena, RADDBGIC_TypeData, 1); result->type_nodes = type_nodes; result->type_node_count = type_count; result->udts = udts; @@ -2583,16 +2583,16 @@ cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) //- rjf: symbol data baking -static CONS_SymbolData* -cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) +static RADDBGIC_SymbolData* +raddbgic_symbol_data_combine(Arena *arena, RADDBGIC_Root *root, RADDBGIC_BakeCtx *bctx) { - ProfBegin("cons_symbol_data_combine"); + ProfBegin("raddbgic_symbol_data_combine"); Temp scratch = scratch_begin(&arena, 1); // count symbol kinds - U32 globalvar_count = 1 + root->symbol_kind_counts[CONS_SymbolKind_GlobalVariable]; - U32 threadvar_count = 1 + root->symbol_kind_counts[CONS_SymbolKind_ThreadVariable]; - U32 procedure_count = 1 + root->symbol_kind_counts[CONS_SymbolKind_Procedure]; + U32 globalvar_count = 1 + root->symbol_kind_counts[RADDBGIC_SymbolKind_GlobalVariable]; + U32 threadvar_count = 1 + root->symbol_kind_counts[RADDBGIC_SymbolKind_ThreadVariable]; + U32 procedure_count = 1 + root->symbol_kind_counts[RADDBGIC_SymbolKind_Procedure]; // allocate symbol arrays RADDBGI_GlobalVariable *global_variables = @@ -2615,11 +2615,11 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) procedure_ptr += 1; // symbol nodes - for(CONS_Symbol *node = root->first_symbol; + for(RADDBGIC_Symbol *node = root->first_symbol; node != 0; node = node->next_order){ - U32 name_string_idx = cons_string(bctx, node->name); - U32 link_name_string_idx = cons_string(bctx, node->link_name); + U32 name_string_idx = raddbgic_string(bctx, node->name); + U32 link_name_string_idx = raddbgic_string(bctx, node->link_name); U32 type_idx = node->type->idx; RADDBGI_LinkFlags link_flags = 0; @@ -2641,7 +2641,7 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) switch (node->kind){ default:{}break; - case CONS_SymbolKind_GlobalVariable: + case RADDBGIC_SymbolKind_GlobalVariable: { global_ptr->name_string_idx = name_string_idx; global_ptr->link_flags = link_flags; @@ -2651,7 +2651,7 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) global_ptr += 1; }break; - case CONS_SymbolKind_ThreadVariable: + case RADDBGIC_SymbolKind_ThreadVariable: { thread_local_ptr->name_string_idx = name_string_idx; thread_local_ptr->link_flags = link_flags; @@ -2661,7 +2661,7 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) thread_local_ptr += 1; }break; - case CONS_SymbolKind_Procedure: + case RADDBGIC_SymbolKind_Procedure: { procedure_ptr->name_string_idx = name_string_idx; procedure_ptr->link_name_string_idx = link_name_string_idx; @@ -2680,23 +2680,23 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) } // global vmap - CONS_VMap *global_vmap = 0; + RADDBGIC_VMap *global_vmap = 0; { // count necessary markers U32 marker_count = globalvar_count*2; // fill markers - CONS_SortKey *keys = push_array_no_zero(scratch.arena, CONS_SortKey, marker_count); - CONS_VMapMarker *markers = push_array_no_zero(scratch.arena, CONS_VMapMarker, marker_count); + RADDBGIC_SortKey *keys = push_array_no_zero(scratch.arena, RADDBGIC_SortKey, marker_count); + RADDBGIC_VMapMarker *markers = push_array_no_zero(scratch.arena, RADDBGIC_VMapMarker, marker_count); - CONS_SortKey *key_ptr = keys; - CONS_VMapMarker *marker_ptr = markers; + RADDBGIC_SortKey *key_ptr = keys; + RADDBGIC_VMapMarker *marker_ptr = markers; // real globals - for(CONS_Symbol *node = root->first_symbol; + for(RADDBGIC_Symbol *node = root->first_symbol; node != 0; node = node->next_order){ - if(node->kind == CONS_SymbolKind_GlobalVariable){ + if(node->kind == RADDBGIC_SymbolKind_GlobalVariable){ U32 global_idx = node->idx; U64 first = node->offset; @@ -2745,7 +2745,7 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) marker_ptr - markers == marker_count); // construct vmap - global_vmap = cons_vmap_from_markers(arena, markers, keys, marker_count); + global_vmap = raddbgic_vmap_from_markers(arena, markers, keys, marker_count); } // allocate scope array @@ -2780,13 +2780,13 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) RADDBGI_Local *local_ptr = locals; RADDBGI_LocationBlock *location_block_ptr = location_blocks; - for(CONS_Scope *node = root->first_scope; + for(RADDBGIC_Scope *node = root->first_scope; node != 0; node = node->next_order, scope_ptr += 1){ // emit voffs U32 voff_first = (U32)(scope_voff_ptr - scope_voffs); - for(CONS_VOffRange *range = node->first_range; + for(RADDBGIC_VOffRange *range = node->first_range; range != 0; range = range->next){ *scope_voff_ptr = range->voff_first; @@ -2799,21 +2799,21 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) // emit locals U32 scope_local_count = node->local_count; U32 scope_local_first = (U32)(local_ptr - locals); - for(CONS_Local *slocal = node->first_local; + for(RADDBGIC_Local *slocal = node->first_local; slocal != 0; slocal = slocal->next, local_ptr += 1){ local_ptr->kind = slocal->kind; - local_ptr->name_string_idx = cons_string(bctx, slocal->name); + local_ptr->name_string_idx = raddbgic_string(bctx, slocal->name); local_ptr->type_idx = slocal->type->idx; - CONS_LocationSet *locset = slocal->locset; + RADDBGIC_LocationSet *locset = slocal->locset; if(locset != 0){ U32 location_first = (U32)(location_block_ptr - location_blocks); U32 location_opl = location_first + locset->location_case_count; local_ptr->location_first = location_first; local_ptr->location_opl = location_opl; - for(CONS_LocationCase *location_case = locset->first_location_case; + for(RADDBGIC_LocationCase *location_case = locset->first_location_case; location_case != 0; location_case = location_case->next){ location_block_ptr->scope_off_first = location_case->voff_first; @@ -2821,7 +2821,7 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) location_block_ptr->location_data_off = location_data.total_size; location_block_ptr += 1; - CONS_Location *location = location_case->location; + RADDBGIC_Location *location = location_case->location; if(location == 0){ U64 data = 0; str8_serial_push_align(scratch.arena, &location_data, 8); @@ -2840,7 +2840,7 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) case RADDBGI_LocationKind_ValBytecodeStream: { str8_list_push(scratch.arena, &location_data, push_str8_copy(scratch.arena, str8_struct(&location->kind))); - for(CONS_EvalBytecodeOp *op_node = location->bytecode.first_op; + for(RADDBGIC_EvalBytecodeOp *op_node = location->bytecode.first_op; op_node != 0; op_node = op_node->next){ U8 op_data[9]; @@ -2906,24 +2906,24 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) String8 location_data_str = str8_list_join(arena, &location_data, 0); // scope vmap - CONS_VMap *scope_vmap = 0; + RADDBGIC_VMap *scope_vmap = 0; { // count necessary markers U32 marker_count = scope_voff_count; // fill markers - CONS_SortKey *keys = push_array_no_zero(scratch.arena, CONS_SortKey, marker_count); - CONS_VMapMarker *markers = push_array_no_zero(scratch.arena, CONS_VMapMarker, marker_count); + RADDBGIC_SortKey *keys = push_array_no_zero(scratch.arena, RADDBGIC_SortKey, marker_count); + RADDBGIC_VMapMarker *markers = push_array_no_zero(scratch.arena, RADDBGIC_VMapMarker, marker_count); - CONS_SortKey *key_ptr = keys; - CONS_VMapMarker *marker_ptr = markers; + RADDBGIC_SortKey *key_ptr = keys; + RADDBGIC_VMapMarker *marker_ptr = markers; - for(CONS_Scope *node = root->first_scope; + for(RADDBGIC_Scope *node = root->first_scope; node != 0; node = node->next_order){ U32 scope_idx = node->idx; - for(CONS_VOffRange *range = node->first_range; + for(RADDBGIC_VOffRange *range = node->first_range; range != 0; range = range->next){ key_ptr->key = range->voff_first; @@ -2942,11 +2942,11 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) } } - scope_vmap = cons_vmap_from_markers(arena, markers, keys, marker_count); + scope_vmap = raddbgic_vmap_from_markers(arena, markers, keys, marker_count); } // fill result - CONS_SymbolData *result = push_array(arena, CONS_SymbolData, 1); + RADDBGIC_SymbolData *result = push_array(arena, RADDBGIC_SymbolData, 1); result->global_variables = global_variables; result->global_variable_count = globalvar_count; result->global_vmap = global_vmap; @@ -2974,8 +2974,8 @@ cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx) //- rjf: name map baking -static CONS_NameMapBaked* -cons_name_map_bake(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx, CONS_NameMap *map) +static RADDBGIC_NameMapBaked* +raddbgic_name_map_bake(Arena *arena, RADDBGIC_Root *root, RADDBGIC_BakeCtx *bctx, RADDBGIC_NameMap *map) { Temp scratch = scratch_begin(&arena, 1); @@ -2983,13 +2983,13 @@ cons_name_map_bake(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx, CONS_NameM U32 node_count = map->name_count; // setup the final bucket layouts - CONS_NameMapSemiBucket *sbuckets = push_array(scratch.arena, CONS_NameMapSemiBucket, bucket_count); - for(CONS_NameMapNode *node = map->first; + RADDBGIC_NameMapSemiBucket *sbuckets = push_array(scratch.arena, RADDBGIC_NameMapSemiBucket, bucket_count); + for(RADDBGIC_NameMapNode *node = map->first; node != 0; node = node->order_next){ U64 hash = raddbgi_hash(node->string.str, node->string.size); U64 bi = hash%bucket_count; - CONS_NameMapSemiNode *snode = push_array(scratch.arena, CONS_NameMapSemiNode, 1); + RADDBGIC_NameMapSemiNode *snode = push_array(scratch.arena, RADDBGIC_NameMapSemiNode, 1); SLLQueuePush(sbuckets[bi].first, sbuckets[bi].last, snode); snode->node = node; sbuckets[bi].count += 1; @@ -3007,13 +3007,13 @@ cons_name_map_bake(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx, CONS_NameM bucket_ptr->first_node = (U32)(node_ptr - nodes); bucket_ptr->node_count = sbuckets[i].count; - for(CONS_NameMapSemiNode *snode = sbuckets[i].first; + for(RADDBGIC_NameMapSemiNode *snode = sbuckets[i].first; snode != 0; snode = snode->next){ - CONS_NameMapNode *node = snode->node; + RADDBGIC_NameMapNode *node = snode->node; // cons name and index(es) - U32 string_idx = cons_string(bctx, node->string); + U32 string_idx = raddbgic_string(bctx, node->string); U32 match_count = node->idx_count; U32 idx = 0; if(match_count == 1){ @@ -3023,7 +3023,7 @@ cons_name_map_bake(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx, CONS_NameM Temp temp = temp_begin(scratch.arena); U32 *idx_run = push_array_no_zero(temp.arena, U32, match_count); U32 *idx_ptr = idx_run; - for(CONS_NameMapIdxNode *idxnode = node->idx_first; + for(RADDBGIC_NameMapIdxNode *idxnode = node->idx_first; idxnode != 0; idxnode = idxnode->next){ for(U32 i = 0; i < ArrayCount(idxnode->idx); i += 1){ @@ -3036,7 +3036,7 @@ cons_name_map_bake(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx, CONS_NameM } dblbreak:; Assert(idx_ptr == idx_run + match_count); - idx = cons_idx_run(bctx, idx_run, match_count); + idx = raddbgic_idx_run(bctx, idx_run, match_count); temp_end(temp); } @@ -3052,7 +3052,7 @@ cons_name_map_bake(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx, CONS_NameM scratch_end(scratch); - CONS_NameMapBaked *result = push_array(arena, CONS_NameMapBaked, 1); + RADDBGIC_NameMapBaked *result = push_array(arena, RADDBGIC_NameMapBaked, 1); result->buckets = buckets; result->nodes = nodes; result->bucket_count = bucket_count; @@ -3063,21 +3063,21 @@ cons_name_map_bake(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx, CONS_NameM //- rjf: top-level baking entry point static void -cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) +raddbgic_bake_file(Arena *arena, RADDBGIC_Root *root, String8List *out) { ProfBeginFunction(); str8_serial_begin(arena, out); // setup cons helpers - CONS_DSections dss = {0}; - cons_dsection(arena, &dss, 0, 0, RADDBGI_DataSectionTag_NULL); + RADDBGIC_DSections dss = {0}; + raddbgic_dsection(arena, &dss, 0, 0, RADDBGI_DataSectionTag_NULL); - CONS_BakeParams bctx_params = {0}; + RADDBGIC_BakeParams bctx_params = {0}; { bctx_params.strings_bucket_count = u64_up_to_pow2(root->symbol_map.pair_count*8); bctx_params.idx_runs_bucket_count = u64_up_to_pow2(root->symbol_map.pair_count*8); } - CONS_BakeCtx *bctx = cons_bake_ctx_begin(&bctx_params); + RADDBGIC_BakeCtx *bctx = raddbgic_bake_ctx_begin(&bctx_params); //////////////////////////////// // MAIN PART: allocating and filling out sections of the file @@ -3085,30 +3085,30 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) // top level info RADDBGI_TopLevelInfo *tli = push_array(arena, RADDBGI_TopLevelInfo, 1); { - CONS_TopLevelInfo *cons_tli = &root->top_level_info; - tli->architecture = cons_tli->architecture; - tli->exe_name_string_idx = cons_string(bctx, cons_tli->exe_name); - tli->exe_hash = cons_tli->exe_hash; - tli->voff_max = cons_tli->voff_max; + RADDBGIC_TopLevelInfo *raddbgic_tli = &root->top_level_info; + tli->architecture = raddbgic_tli->architecture; + tli->exe_name_string_idx = raddbgic_string(bctx, raddbgic_tli->exe_name); + tli->exe_hash = raddbgic_tli->exe_hash; + tli->voff_max = raddbgic_tli->voff_max; } - cons_dsection(arena, &dss, tli, sizeof(*tli), RADDBGI_DataSectionTag_TopLevelInfo); + raddbgic_dsection(arena, &dss, tli, sizeof(*tli), RADDBGI_DataSectionTag_TopLevelInfo); // binary sections array { U32 count = root->binary_section_count; RADDBGI_BinarySection *sections = push_array(arena, RADDBGI_BinarySection, count); RADDBGI_BinarySection *dsec = sections; - for(CONS_BinarySection *ssec = root->binary_section_first; + for(RADDBGIC_BinarySection *ssec = root->binary_section_first; ssec != 0; ssec = ssec->next, dsec += 1){ - dsec->name_string_idx = cons_string(bctx, ssec->name); + dsec->name_string_idx = raddbgic_string(bctx, ssec->name); dsec->flags = ssec->flags; dsec->voff_first = ssec->voff_first; dsec->voff_opl = ssec->voff_opl; dsec->foff_first = ssec->foff_first; dsec->foff_opl = ssec->foff_opl; } - cons_dsection(arena, &dss, sections, sizeof(*sections)*count, RADDBGI_DataSectionTag_BinarySections); + raddbgic_dsection(arena, &dss, sections, sizeof(*sections)*count, RADDBGI_DataSectionTag_BinarySections); } // units array @@ -3119,17 +3119,17 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) U32 count = root->unit_count; RADDBGI_Unit *units = push_array(arena, RADDBGI_Unit, count); RADDBGI_Unit *dunit = units; - for(CONS_Unit *sunit = root->unit_first; + for(RADDBGIC_Unit *sunit = root->unit_first; sunit != 0; sunit = sunit->next_order, dunit += 1){ // strings & paths - U32 unit_name = cons_string(bctx, sunit->unit_name); - U32 cmp_name = cons_string(bctx, sunit->compiler_name); + U32 unit_name = raddbgic_string(bctx, sunit->unit_name); + U32 cmp_name = raddbgic_string(bctx, sunit->compiler_name); - U32 src_path = cons_paths_idx_from_path(bctx, sunit->source_file); - U32 obj_path = cons_paths_idx_from_path(bctx, sunit->object_file); - U32 archive_path = cons_paths_idx_from_path(bctx, sunit->archive_file); - U32 build_path = cons_paths_idx_from_path(bctx, sunit->build_path); + U32 src_path = raddbgic_paths_idx_from_path(bctx, sunit->source_file); + U32 obj_path = raddbgic_paths_idx_from_path(bctx, sunit->object_file); + U32 archive_path = raddbgic_paths_idx_from_path(bctx, sunit->archive_file); + U32 build_path = raddbgic_paths_idx_from_path(bctx, sunit->build_path); dunit->unit_name_string_idx = unit_name; dunit->compiler_name_string_idx = cmp_name; @@ -3140,140 +3140,140 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) dunit->language = sunit->language; // line info (voff -> file*line*col) - CONS_LineSequenceNode *first_seq = sunit->line_seq_first; - CONS_UnitLinesCombined *lines = cons_unit_combine_lines(arena, bctx, first_seq); + RADDBGIC_LineSequenceNode *first_seq = sunit->line_seq_first; + RADDBGIC_UnitLinesCombined *lines = raddbgic_unit_combine_lines(arena, bctx, first_seq); U32 line_count = lines->line_count; if(line_count > 0){ dunit->line_info_voffs_data_idx = - cons_dsection(arena, &dss, lines->voffs, sizeof(U64)*(line_count + 1), - RADDBGI_DataSectionTag_LineInfoVoffs); + raddbgic_dsection(arena, &dss, lines->voffs, sizeof(U64)*(line_count + 1), + RADDBGI_DataSectionTag_LineInfoVoffs); dunit->line_info_data_idx = - cons_dsection(arena, &dss, lines->lines, sizeof(RADDBGI_Line)*line_count, - RADDBGI_DataSectionTag_LineInfoData); + raddbgic_dsection(arena, &dss, lines->lines, sizeof(RADDBGI_Line)*line_count, + RADDBGI_DataSectionTag_LineInfoData); if(lines->cols != 0){ dunit->line_info_col_data_idx = - cons_dsection(arena, &dss, lines->cols, sizeof(RADDBGI_Column)*line_count, - RADDBGI_DataSectionTag_LineInfoColumns); + raddbgic_dsection(arena, &dss, lines->cols, sizeof(RADDBGI_Column)*line_count, + RADDBGI_DataSectionTag_LineInfoColumns); } dunit->line_info_count = line_count; } } - cons_dsection(arena, &dss, units, sizeof(*units)*count, RADDBGI_DataSectionTag_Units); + raddbgic_dsection(arena, &dss, units, sizeof(*units)*count, RADDBGI_DataSectionTag_Units); } // source file line info baking // * pass for "source_combine_line" for each source file - // * can only be run after a pass that does "unit_combine_lines" for each unit. - for(CONS_SrcNode *src_node = bctx->tree->src_first; + for(RADDBGIC_SrcNode *src_node = bctx->tree->src_first; src_node != 0; src_node = src_node->next){ - CONS_LineMapFragment *first_fragment = src_node->first_fragment; - CONS_SrcLinesCombined *lines = cons_source_combine_lines(arena, first_fragment); + RADDBGIC_LineMapFragment *first_fragment = src_node->first_fragment; + RADDBGIC_SrcLinesCombined *lines = raddbgic_source_combine_lines(arena, first_fragment); U32 line_count = lines->line_count; if(line_count > 0){ src_node->line_map_count = line_count; src_node->line_map_nums_data_idx = - cons_dsection(arena, &dss, lines->line_nums, sizeof(*lines->line_nums)*line_count, - RADDBGI_DataSectionTag_LineMapNumbers); + raddbgic_dsection(arena, &dss, lines->line_nums, sizeof(*lines->line_nums)*line_count, + RADDBGI_DataSectionTag_LineMapNumbers); src_node->line_map_range_data_idx = - cons_dsection(arena, &dss, lines->line_ranges, sizeof(*lines->line_ranges)*(line_count + 1), - RADDBGI_DataSectionTag_LineMapRanges); + raddbgic_dsection(arena, &dss, lines->line_ranges, sizeof(*lines->line_ranges)*(line_count + 1), + RADDBGI_DataSectionTag_LineMapRanges); src_node->line_map_voff_data_idx = - cons_dsection(arena, &dss, lines->voffs, sizeof(*lines->voffs)*lines->voff_count, - RADDBGI_DataSectionTag_LineMapVoffs); + raddbgic_dsection(arena, &dss, lines->voffs, sizeof(*lines->voffs)*lines->voff_count, + RADDBGI_DataSectionTag_LineMapVoffs); } } // source file name mapping { - CONS_NameMap* map = cons_name_map_for_kind(root, RADDBGI_NameMapKind_NormalSourcePaths); - for(CONS_SrcNode *src_node = bctx->tree->src_first; + RADDBGIC_NameMap* map = raddbgic_name_map_for_kind(root, RADDBGI_NameMapKind_NormalSourcePaths); + for(RADDBGIC_SrcNode *src_node = bctx->tree->src_first; src_node != 0; src_node = src_node->next){ if(src_node->idx != 0){ - cons_name_map_add_pair(root, map, src_node->normal_full_path, src_node->idx); + raddbgic_name_map_add_pair(root, map, src_node->normal_full_path, src_node->idx); } } } // unit vmap baking { - CONS_VMap *vmap = cons_vmap_from_unit_ranges(arena, - root->unit_vmap_range_first, - root->unit_vmap_range_count); + RADDBGIC_VMap *vmap = raddbgic_vmap_from_unit_ranges(arena, + root->unit_vmap_range_first, + root->unit_vmap_range_count); U64 vmap_size = sizeof(*vmap->vmap)*(vmap->count + 1); - cons_dsection(arena, &dss, vmap->vmap, vmap_size, RADDBGI_DataSectionTag_UnitVmap); + raddbgic_dsection(arena, &dss, vmap->vmap, vmap_size, RADDBGI_DataSectionTag_UnitVmap); } // type info baking { - CONS_TypeData *types = cons_type_data_combine(arena, root, bctx); + RADDBGIC_TypeData *types = raddbgic_type_data_combine(arena, root, bctx); U64 type_nodes_size = sizeof(*types->type_nodes)*types->type_node_count; - cons_dsection(arena, &dss, types->type_nodes, type_nodes_size, RADDBGI_DataSectionTag_TypeNodes); + raddbgic_dsection(arena, &dss, types->type_nodes, type_nodes_size, RADDBGI_DataSectionTag_TypeNodes); U64 udt_size = sizeof(*types->udts)*types->udt_count; - cons_dsection(arena, &dss, types->udts, udt_size, RADDBGI_DataSectionTag_UDTs); + raddbgic_dsection(arena, &dss, types->udts, udt_size, RADDBGI_DataSectionTag_UDTs); U64 member_size = sizeof(*types->members)*types->member_count; - cons_dsection(arena, &dss, types->members, member_size, RADDBGI_DataSectionTag_Members); + raddbgic_dsection(arena, &dss, types->members, member_size, RADDBGI_DataSectionTag_Members); U64 enum_member_size = sizeof(*types->enum_members)*types->enum_member_count; - cons_dsection(arena, &dss, types->enum_members, enum_member_size, RADDBGI_DataSectionTag_EnumMembers); + raddbgic_dsection(arena, &dss, types->enum_members, enum_member_size, RADDBGI_DataSectionTag_EnumMembers); } // symbol info baking { - CONS_SymbolData *symbol_data = cons_symbol_data_combine(arena, root, bctx); + RADDBGIC_SymbolData *symbol_data = raddbgic_symbol_data_combine(arena, root, bctx); U64 global_variables_size = sizeof(*symbol_data->global_variables)*symbol_data->global_variable_count; - cons_dsection(arena, &dss, symbol_data->global_variables, global_variables_size, - RADDBGI_DataSectionTag_GlobalVariables); + raddbgic_dsection(arena, &dss, symbol_data->global_variables, global_variables_size, + RADDBGI_DataSectionTag_GlobalVariables); - CONS_VMap *global_vmap = symbol_data->global_vmap; + RADDBGIC_VMap *global_vmap = symbol_data->global_vmap; U64 global_vmap_size = sizeof(*global_vmap->vmap)*(global_vmap->count + 1); - cons_dsection(arena, &dss, global_vmap->vmap, global_vmap_size, - RADDBGI_DataSectionTag_GlobalVmap); + raddbgic_dsection(arena, &dss, global_vmap->vmap, global_vmap_size, + RADDBGI_DataSectionTag_GlobalVmap); U64 thread_variables_size = sizeof(*symbol_data->thread_variables)*symbol_data->thread_variable_count; - cons_dsection(arena, &dss, symbol_data->thread_variables, thread_variables_size, - RADDBGI_DataSectionTag_ThreadVariables); + raddbgic_dsection(arena, &dss, symbol_data->thread_variables, thread_variables_size, + RADDBGI_DataSectionTag_ThreadVariables); U64 procedures_size = sizeof(*symbol_data->procedures)*symbol_data->procedure_count; - cons_dsection(arena, &dss, symbol_data->procedures, procedures_size, - RADDBGI_DataSectionTag_Procedures); + raddbgic_dsection(arena, &dss, symbol_data->procedures, procedures_size, + RADDBGI_DataSectionTag_Procedures); U64 scopes_size = sizeof(*symbol_data->scopes)*symbol_data->scope_count; - cons_dsection(arena, &dss, symbol_data->scopes, scopes_size, RADDBGI_DataSectionTag_Scopes); + raddbgic_dsection(arena, &dss, symbol_data->scopes, scopes_size, RADDBGI_DataSectionTag_Scopes); U64 scope_voffs_size = sizeof(*symbol_data->scope_voffs)*symbol_data->scope_voff_count; - cons_dsection(arena, &dss, symbol_data->scope_voffs, scope_voffs_size, - RADDBGI_DataSectionTag_ScopeVoffData); + raddbgic_dsection(arena, &dss, symbol_data->scope_voffs, scope_voffs_size, + RADDBGI_DataSectionTag_ScopeVoffData); - CONS_VMap *scope_vmap = symbol_data->scope_vmap; + RADDBGIC_VMap *scope_vmap = symbol_data->scope_vmap; U64 scope_vmap_size = sizeof(*scope_vmap->vmap)*(scope_vmap->count + 1); - cons_dsection(arena, &dss, scope_vmap->vmap, scope_vmap_size, RADDBGI_DataSectionTag_ScopeVmap); + raddbgic_dsection(arena, &dss, scope_vmap->vmap, scope_vmap_size, RADDBGI_DataSectionTag_ScopeVmap); U64 local_size = sizeof(*symbol_data->locals)*symbol_data->local_count; - cons_dsection(arena, &dss, symbol_data->locals, local_size, RADDBGI_DataSectionTag_Locals); + raddbgic_dsection(arena, &dss, symbol_data->locals, local_size, RADDBGI_DataSectionTag_Locals); U64 location_blocks_size = sizeof(*symbol_data->location_blocks)*symbol_data->location_block_count; - cons_dsection(arena, &dss, symbol_data->location_blocks, location_blocks_size, - RADDBGI_DataSectionTag_LocationBlocks); + raddbgic_dsection(arena, &dss, symbol_data->location_blocks, location_blocks_size, + RADDBGI_DataSectionTag_LocationBlocks); U64 location_data_size = symbol_data->location_data_size; - cons_dsection(arena, &dss, symbol_data->location_data, location_data_size, - RADDBGI_DataSectionTag_LocationData); + raddbgic_dsection(arena, &dss, symbol_data->location_data, location_data_size, + RADDBGI_DataSectionTag_LocationData); } // name map baking @@ -3289,23 +3289,23 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) RADDBGI_NameMap *name_map_ptr = name_maps; for(U32 i = 0; i < RADDBGI_NameMapKind_COUNT; i += 1){ - CONS_NameMap *map = root->name_maps[i]; + RADDBGIC_NameMap *map = root->name_maps[i]; if(map != 0){ - CONS_NameMapBaked *baked = cons_name_map_bake(arena, root, bctx, map); + RADDBGIC_NameMapBaked *baked = raddbgic_name_map_bake(arena, root, bctx, map); name_map_ptr->kind = i; name_map_ptr->bucket_data_idx = - cons_dsection(arena, &dss, baked->buckets, sizeof(*baked->buckets)*baked->bucket_count, - RADDBGI_DataSectionTag_NameMapBuckets); + raddbgic_dsection(arena, &dss, baked->buckets, sizeof(*baked->buckets)*baked->bucket_count, + RADDBGI_DataSectionTag_NameMapBuckets); name_map_ptr->node_data_idx = - cons_dsection(arena, &dss, baked->nodes, sizeof(*baked->nodes)*baked->node_count, - RADDBGI_DataSectionTag_NameMapNodes); + raddbgic_dsection(arena, &dss, baked->nodes, sizeof(*baked->nodes)*baked->node_count, + RADDBGI_DataSectionTag_NameMapNodes); name_map_ptr += 1; } } - cons_dsection(arena, &dss, name_maps, sizeof(*name_maps)*name_map_count, - RADDBGI_DataSectionTag_NameMaps); + raddbgic_dsection(arena, &dss, name_maps, sizeof(*name_maps)*name_map_count, + RADDBGI_DataSectionTag_NameMaps); } //////////////////////////////// @@ -3317,10 +3317,10 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) RADDBGI_FilePathNode *nodes = push_array(arena, RADDBGI_FilePathNode, count); RADDBGI_FilePathNode *out_node = nodes; - for(CONS_PathNode *node = bctx->tree->first; + for(RADDBGIC_PathNode *node = bctx->tree->first; node != 0; node = node->next_order, out_node += 1){ - out_node->name_string_idx = cons_string(bctx, node->name); + out_node->name_string_idx = raddbgic_string(bctx, node->name); if(node->parent != 0){ out_node->parent_path_node = node->parent->idx; } @@ -3335,7 +3335,7 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) } } - cons_dsection(arena, &dss, nodes, sizeof(*nodes)*count, RADDBGI_DataSectionTag_FilePathNodes); + raddbgic_dsection(arena, &dss, nodes, sizeof(*nodes)*count, RADDBGI_DataSectionTag_FilePathNodes); } // generate data sections for files @@ -3344,18 +3344,18 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) RADDBGI_SourceFile *src_files = push_array(arena, RADDBGI_SourceFile, count); RADDBGI_SourceFile *out_src_file = src_files; - for(CONS_SrcNode *node = bctx->tree->src_first; + for(RADDBGIC_SrcNode *node = bctx->tree->src_first; node != 0; node = node->next, out_src_file += 1){ out_src_file->file_path_node_idx = node->path_node->idx; - out_src_file->normal_full_path_string_idx = cons_string(bctx, node->normal_full_path); + out_src_file->normal_full_path_string_idx = raddbgic_string(bctx, node->normal_full_path); out_src_file->line_map_nums_data_idx = node->line_map_nums_data_idx; out_src_file->line_map_range_data_idx = node->line_map_range_data_idx; out_src_file->line_map_count = node->line_map_count; out_src_file->line_map_voff_data_idx = node->line_map_voff_data_idx; } - cons_dsection(arena, &dss, src_files, sizeof(*src_files)*count, RADDBGI_DataSectionTag_SourceFiles); + raddbgic_dsection(arena, &dss, src_files, sizeof(*src_files)*count, RADDBGI_DataSectionTag_SourceFiles); } // generate data sections for strings @@ -3367,7 +3367,7 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) U32 *off_ptr = str_offs; *off_ptr = 0; off_ptr += 1; - for(CONS_StringNode *node = bctx->strs.order_first; + for(RADDBGIC_StringNode *node = bctx->strs.order_first; node != 0; node = node->order_next){ off_cursor += node->str.size; @@ -3379,7 +3379,7 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) U8 *buf = push_array(arena, U8, off_cursor); { U8 *ptr = buf; - for(CONS_StringNode *node = bctx->strs.order_first; + for(RADDBGIC_StringNode *node = bctx->strs.order_first; node != 0; node = node->order_next){ MemoryCopy(ptr, node->str.str, node->str.size); @@ -3387,9 +3387,9 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) } } - cons_dsection(arena, &dss, str_offs, sizeof(*str_offs)*(bctx->strs.count + 1), - RADDBGI_DataSectionTag_StringTable); - cons_dsection(arena, &dss, buf, off_cursor, RADDBGI_DataSectionTag_StringData); + raddbgic_dsection(arena, &dss, str_offs, sizeof(*str_offs)*(bctx->strs.count + 1), + RADDBGI_DataSectionTag_StringTable); + raddbgic_dsection(arena, &dss, buf, off_cursor, RADDBGI_DataSectionTag_StringData); } // generate data sections for index runs @@ -3399,7 +3399,7 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) { U32 *out_ptr = idx_data; U32 *opl = out_ptr + bctx->idxs.idx_count; - CONS_IdxRunNode *node = bctx->idxs.order_first; + RADDBGIC_IdxRunNode *node = bctx->idxs.order_first; for(;node != 0 && out_ptr < opl; node = node->order_next){ MemoryCopy(out_ptr, node->idx_run, sizeof(*node->idx_run)*node->count); @@ -3408,8 +3408,8 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) Assert(out_ptr == opl); } - cons_dsection(arena, &dss, idx_data, sizeof(*idx_data)*bctx->idxs.idx_count, - RADDBGI_DataSectionTag_IndexRuns); + raddbgic_dsection(arena, &dss, idx_data, sizeof(*idx_data)*bctx->idxs.idx_count, + RADDBGI_DataSectionTag_IndexRuns); } // layout @@ -3431,7 +3431,7 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) } { U64 test_dss_count = 0; - for(CONS_DSectionNode *node = dss.first; + for(RADDBGIC_DSectionNode *node = dss.first; node != 0; node = node->next){ test_dss_count += 1; @@ -3439,7 +3439,7 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) Assert(test_dss_count == dss.count); RADDBGI_DataSection *ptr = dstable; - for(CONS_DSectionNode *node = dss.first; + for(RADDBGIC_DSectionNode *node = dss.first; node != 0; node = node->next, ptr += 1){ U64 data_section_offset = 0; @@ -3458,6 +3458,6 @@ cons_bake_file(Arena *arena, CONS_Root *root, String8List *out) Assert(ptr == dstable + dss.count); } - cons_bake_ctx_release(bctx); + raddbgic_bake_ctx_release(bctx); ProfEnd(); } diff --git a/src/raddbgi_cons/raddbgi_cons.h b/src/raddbgi_cons/raddbgi_cons.h index e9ab4716..cadb75c1 100644 --- a/src/raddbgi_cons/raddbgi_cons.h +++ b/src/raddbgi_cons/raddbgi_cons.h @@ -7,18 +7,18 @@ //////////////////////////////// //~ rjf: Error Types -typedef struct CONS_Error CONS_Error; -struct CONS_Error +typedef struct RADDBGIC_Error RADDBGIC_Error; +struct RADDBGIC_Error { - CONS_Error *next; + RADDBGIC_Error *next; String8 msg; }; -typedef struct CONS_ErrorList CONS_ErrorList; -struct CONS_ErrorList +typedef struct RADDBGIC_ErrorList RADDBGIC_ErrorList; +struct RADDBGIC_ErrorList { - CONS_Error *first; - CONS_Error *last; + RADDBGIC_Error *first; + RADDBGIC_Error *last; U64 count; }; @@ -27,47 +27,47 @@ struct CONS_ErrorList //- rjf: u64 -> pointer map -typedef struct CONS_U64ToPtrNode CONS_U64ToPtrNode; -struct CONS_U64ToPtrNode +typedef struct RADDBGIC_U64ToPtrNode RADDBGIC_U64ToPtrNode; +struct RADDBGIC_U64ToPtrNode { - CONS_U64ToPtrNode *next; + RADDBGIC_U64ToPtrNode *next; U64 _padding_; U64 key[1]; void *ptr[1]; }; -typedef struct CONS_U64ToPtrMap CONS_U64ToPtrMap; -struct CONS_U64ToPtrMap +typedef struct RADDBGIC_U64ToPtrMap RADDBGIC_U64ToPtrMap; +struct RADDBGIC_U64ToPtrMap { - CONS_U64ToPtrNode **buckets; + RADDBGIC_U64ToPtrNode **buckets; U64 buckets_count; U64 bucket_collision_count; U64 pair_count; }; -typedef struct CONS_U64ToPtrLookup CONS_U64ToPtrLookup; -struct CONS_U64ToPtrLookup +typedef struct RADDBGIC_U64ToPtrLookup RADDBGIC_U64ToPtrLookup; +struct RADDBGIC_U64ToPtrLookup { void *match; - CONS_U64ToPtrNode *fill_node; + RADDBGIC_U64ToPtrNode *fill_node; U32 fill_k; }; //- rjf: string8 -> pointer map -typedef struct CONS_Str8ToPtrNode CONS_Str8ToPtrNode; -struct CONS_Str8ToPtrNode +typedef struct RADDBGIC_Str8ToPtrNode RADDBGIC_Str8ToPtrNode; +struct RADDBGIC_Str8ToPtrNode { - struct CONS_Str8ToPtrNode *next; + struct RADDBGIC_Str8ToPtrNode *next; String8 key; U64 hash; void *ptr; }; -typedef struct CONS_Str8ToPtrMap CONS_Str8ToPtrMap; -struct CONS_Str8ToPtrMap +typedef struct RADDBGIC_Str8ToPtrMap RADDBGIC_Str8ToPtrMap; +struct RADDBGIC_Str8ToPtrMap { - CONS_Str8ToPtrNode **buckets; + RADDBGIC_Str8ToPtrNode **buckets; U64 buckets_count; U64 bucket_collision_count; U64 pair_count; @@ -75,17 +75,17 @@ struct CONS_Str8ToPtrMap //- rjf: sortable range data structure -typedef struct CONS_SortKey CONS_SortKey; -struct CONS_SortKey +typedef struct RADDBGIC_SortKey RADDBGIC_SortKey; +struct RADDBGIC_SortKey { U64 key; void *val; }; -typedef struct CONS_OrderedRange CONS_OrderedRange; -struct CONS_OrderedRange +typedef struct RADDBGIC_OrderedRange RADDBGIC_OrderedRange; +struct RADDBGIC_OrderedRange { - CONS_OrderedRange *next; + RADDBGIC_OrderedRange *next; U64 first; U64 opl; }; @@ -93,10 +93,10 @@ struct CONS_OrderedRange //////////////////////////////// //~ rjf: Binary Section Types -typedef struct CONS_BinarySection CONS_BinarySection; -struct CONS_BinarySection +typedef struct RADDBGIC_BinarySection RADDBGIC_BinarySection; +struct RADDBGIC_BinarySection { - CONS_BinarySection *next; + RADDBGIC_BinarySection *next; String8 name; RADDBGI_BinarySectionFlags flags; U64 voff_first; @@ -108,8 +108,8 @@ struct CONS_BinarySection //////////////////////////////// //~ rjf: Per-Compilation-Unit Info Types -typedef struct CONS_LineSequence CONS_LineSequence; -struct CONS_LineSequence +typedef struct RADDBGIC_LineSequence RADDBGIC_LineSequence; +struct RADDBGIC_LineSequence { String8 file_name; U64 *voffs; // [line_count + 1] (sorted) @@ -118,15 +118,15 @@ struct CONS_LineSequence U64 line_count; }; -typedef struct CONS_LineSequenceNode CONS_LineSequenceNode; -struct CONS_LineSequenceNode +typedef struct RADDBGIC_LineSequenceNode RADDBGIC_LineSequenceNode; +struct RADDBGIC_LineSequenceNode { - CONS_LineSequenceNode *next; - CONS_LineSequence line_seq; + RADDBGIC_LineSequenceNode *next; + RADDBGIC_LineSequence line_seq; }; -typedef struct CONS_UnitInfo CONS_UnitInfo; -struct CONS_UnitInfo +typedef struct RADDBGIC_UnitInfo RADDBGIC_UnitInfo; +struct RADDBGIC_UnitInfo { String8 unit_name; String8 compiler_name; @@ -137,10 +137,10 @@ struct CONS_UnitInfo RADDBGI_Language language; }; -typedef struct CONS_Unit CONS_Unit; -struct CONS_Unit +typedef struct RADDBGIC_Unit RADDBGIC_Unit; +struct RADDBGIC_Unit { - CONS_Unit *next_order; + RADDBGIC_Unit *next_order; U32 idx; B32 info_is_set; String8 unit_name; @@ -150,16 +150,16 @@ struct CONS_Unit String8 archive_file; String8 build_path; RADDBGI_Language language; - CONS_LineSequenceNode *line_seq_first; - CONS_LineSequenceNode *line_seq_last; + RADDBGIC_LineSequenceNode *line_seq_first; + RADDBGIC_LineSequenceNode *line_seq_last; U64 line_seq_count; }; -typedef struct CONS_UnitVMapRange CONS_UnitVMapRange; -struct CONS_UnitVMapRange +typedef struct RADDBGIC_UnitVMapRange RADDBGIC_UnitVMapRange; +struct RADDBGIC_UnitVMapRange { - CONS_UnitVMapRange *next; - CONS_Unit *unit; + RADDBGIC_UnitVMapRange *next; + RADDBGIC_Unit *unit; U64 first; U64 opl; }; @@ -167,42 +167,42 @@ struct CONS_UnitVMapRange //////////////////////////////// //~ rjf: Type Info Types -typedef U8 CONS_TypeConstructKind; +typedef U8 RADDBGIC_TypeConstructKind; enum { - CONS_TypeConstructKind_Basic, - CONS_TypeConstructKind_Modifier, - CONS_TypeConstructKind_Bitfield, - CONS_TypeConstructKind_Pointer, - CONS_TypeConstructKind_Array, - CONS_TypeConstructKind_Procedure, - CONS_TypeConstructKind_Method, + RADDBGIC_TypeConstructKind_Basic, + RADDBGIC_TypeConstructKind_Modifier, + RADDBGIC_TypeConstructKind_Bitfield, + RADDBGIC_TypeConstructKind_Pointer, + RADDBGIC_TypeConstructKind_Array, + RADDBGIC_TypeConstructKind_Procedure, + RADDBGIC_TypeConstructKind_Method, }; -typedef struct CONS_Reservation CONS_Reservation; +typedef struct RADDBGIC_Reservation RADDBGIC_Reservation; -typedef struct CONS_TypeMember CONS_TypeMember; -struct CONS_TypeMember +typedef struct RADDBGIC_TypeMember RADDBGIC_TypeMember; +struct RADDBGIC_TypeMember { - CONS_TypeMember *next; + RADDBGIC_TypeMember *next; RADDBGI_MemberKind kind; String8 name; - struct CONS_Type *type; + struct RADDBGIC_Type *type; U32 off; }; -typedef struct CONS_TypeEnumVal CONS_TypeEnumVal; -struct CONS_TypeEnumVal +typedef struct RADDBGIC_TypeEnumVal RADDBGIC_TypeEnumVal; +struct RADDBGIC_TypeEnumVal { - CONS_TypeEnumVal *next; + RADDBGIC_TypeEnumVal *next; String8 name; U64 val; }; -typedef struct CONS_Type CONS_Type; -struct CONS_Type +typedef struct RADDBGIC_Type RADDBGIC_Type; +struct RADDBGIC_Type { - CONS_Type *next_order; + RADDBGIC_Type *next_order; RADDBGI_TypeKind kind; U32 idx; U32 byte_size; @@ -210,221 +210,221 @@ struct CONS_Type U32 off; U32 count; String8 name; - CONS_Type *direct_type; - CONS_Type **param_types; - struct CONS_TypeUDT *udt; + RADDBGIC_Type *direct_type; + RADDBGIC_Type **param_types; + struct RADDBGIC_TypeUDT *udt; }; -typedef struct CONS_TypeUDT CONS_TypeUDT; -struct CONS_TypeUDT +typedef struct RADDBGIC_TypeUDT RADDBGIC_TypeUDT; +struct RADDBGIC_TypeUDT { - CONS_TypeUDT *next_order; + RADDBGIC_TypeUDT *next_order; U32 idx; - CONS_Type *self_type; - CONS_TypeMember *first_member; - CONS_TypeMember *last_member; + RADDBGIC_Type *self_type; + RADDBGIC_TypeMember *first_member; + RADDBGIC_TypeMember *last_member; U64 member_count; - CONS_TypeEnumVal *first_enum_val; - CONS_TypeEnumVal *last_enum_val; + RADDBGIC_TypeEnumVal *first_enum_val; + RADDBGIC_TypeEnumVal *last_enum_val; U64 enum_val_count; String8 source_path; U32 line; U32 col; }; -typedef struct CONS_TypeNode CONS_TypeNode; -struct CONS_TypeNode +typedef struct RADDBGIC_TypeNode RADDBGIC_TypeNode; +struct RADDBGIC_TypeNode { - CONS_TypeNode *next; - CONS_Type *type; + RADDBGIC_TypeNode *next; + RADDBGIC_Type *type; }; -typedef struct CONS_TypeList CONS_TypeList; -struct CONS_TypeList +typedef struct RADDBGIC_TypeList RADDBGIC_TypeList; +struct RADDBGIC_TypeList { - CONS_TypeNode *first; - CONS_TypeNode *last; + RADDBGIC_TypeNode *first; + RADDBGIC_TypeNode *last; U64 count; }; //////////////////////////////// //~ rjf: Symbol Info Types -typedef enum CONS_SymbolKind +typedef enum RADDBGIC_SymbolKind { - CONS_SymbolKind_NULL, - CONS_SymbolKind_GlobalVariable, - CONS_SymbolKind_ThreadVariable, - CONS_SymbolKind_Procedure, - CONS_SymbolKind_COUNT + RADDBGIC_SymbolKind_NULL, + RADDBGIC_SymbolKind_GlobalVariable, + RADDBGIC_SymbolKind_ThreadVariable, + RADDBGIC_SymbolKind_Procedure, + RADDBGIC_SymbolKind_COUNT } -CONS_SymbolKind; +RADDBGIC_SymbolKind; -typedef struct CONS_SymbolInfo CONS_SymbolInfo; -struct CONS_SymbolInfo +typedef struct RADDBGIC_SymbolInfo RADDBGIC_SymbolInfo; +struct RADDBGIC_SymbolInfo { - CONS_SymbolKind kind; + RADDBGIC_SymbolKind kind; String8 name; String8 link_name; - CONS_Type *type; + RADDBGIC_Type *type; B32 is_extern; U64 offset; // TODO(allen): should this actually be "container scope"? - struct CONS_Symbol *container_symbol; - CONS_Type *container_type; - struct CONS_Scope *root_scope; + struct RADDBGIC_Symbol *container_symbol; + RADDBGIC_Type *container_type; + struct RADDBGIC_Scope *root_scope; }; -typedef struct CONS_Symbol CONS_Symbol; -struct CONS_Symbol +typedef struct RADDBGIC_Symbol RADDBGIC_Symbol; +struct RADDBGIC_Symbol { - CONS_Symbol *next_order; + RADDBGIC_Symbol *next_order; U32 idx; - CONS_SymbolKind kind; + RADDBGIC_SymbolKind kind; String8 name; String8 link_name; - CONS_Type *type; + RADDBGIC_Type *type; B32 is_extern; B8 offset_is_set; U64 offset; - CONS_Symbol *container_symbol; - CONS_Type *container_type; - struct CONS_Scope *root_scope; + RADDBGIC_Symbol *container_symbol; + RADDBGIC_Type *container_type; + struct RADDBGIC_Scope *root_scope; }; //////////////////////////////// //~ rjf: Scope Info Types -typedef struct CONS_LocalInfo CONS_LocalInfo; -struct CONS_LocalInfo +typedef struct RADDBGIC_LocalInfo RADDBGIC_LocalInfo; +struct RADDBGIC_LocalInfo { RADDBGI_LocalKind kind; - struct CONS_Scope *scope; + struct RADDBGIC_Scope *scope; String8 name; - CONS_Type *type; + RADDBGIC_Type *type; }; -typedef struct CONS_Local CONS_Local; -struct CONS_Local +typedef struct RADDBGIC_Local RADDBGIC_Local; +struct RADDBGIC_Local { - CONS_Local *next; + RADDBGIC_Local *next; RADDBGI_LocalKind kind; String8 name; - CONS_Type *type; - struct CONS_LocationSet *locset; + RADDBGIC_Type *type; + struct RADDBGIC_LocationSet *locset; }; -typedef struct CONS_VOffRange CONS_VOffRange; -struct CONS_VOffRange +typedef struct RADDBGIC_VOffRange RADDBGIC_VOffRange; +struct RADDBGIC_VOffRange { - CONS_VOffRange *next; + RADDBGIC_VOffRange *next; U64 voff_first; U64 voff_opl; }; -typedef struct CONS_Scope CONS_Scope; -struct CONS_Scope +typedef struct RADDBGIC_Scope RADDBGIC_Scope; +struct RADDBGIC_Scope { - CONS_Scope *next_order; - CONS_Symbol *symbol; - CONS_Scope *parent_scope; - CONS_Scope *first_child; - CONS_Scope *last_child; - CONS_Scope *next_sibling; + RADDBGIC_Scope *next_order; + RADDBGIC_Symbol *symbol; + RADDBGIC_Scope *parent_scope; + RADDBGIC_Scope *first_child; + RADDBGIC_Scope *last_child; + RADDBGIC_Scope *next_sibling; U64 voff_base; - CONS_VOffRange *first_range; - CONS_VOffRange *last_range; + RADDBGIC_VOffRange *first_range; + RADDBGIC_VOffRange *last_range; U32 range_count; U32 idx; - CONS_Local *first_local; - CONS_Local *last_local; + RADDBGIC_Local *first_local; + RADDBGIC_Local *last_local; U32 local_count; }; //////////////////////////////// //~ rjf: Location Info Types -typedef struct CONS_EvalBytecodeOp CONS_EvalBytecodeOp; -struct CONS_EvalBytecodeOp +typedef struct RADDBGIC_EvalBytecodeOp RADDBGIC_EvalBytecodeOp; +struct RADDBGIC_EvalBytecodeOp { - CONS_EvalBytecodeOp *next; + RADDBGIC_EvalBytecodeOp *next; RADDBGI_EvalOp op; U32 p_size; U64 p; }; -typedef struct CONS_EvalBytecode CONS_EvalBytecode; -struct CONS_EvalBytecode +typedef struct RADDBGIC_EvalBytecode RADDBGIC_EvalBytecode; +struct RADDBGIC_EvalBytecode { - CONS_EvalBytecodeOp *first_op; - CONS_EvalBytecodeOp *last_op; + RADDBGIC_EvalBytecodeOp *first_op; + RADDBGIC_EvalBytecodeOp *last_op; U32 op_count; U32 encoded_size; }; -typedef struct CONS_Location CONS_Location; -struct CONS_Location +typedef struct RADDBGIC_Location RADDBGIC_Location; +struct RADDBGIC_Location { RADDBGI_LocationKind kind; U8 register_code; U16 offset; - CONS_EvalBytecode bytecode; + RADDBGIC_EvalBytecode bytecode; }; -typedef struct CONS_LocationCase CONS_LocationCase; -struct CONS_LocationCase +typedef struct RADDBGIC_LocationCase RADDBGIC_LocationCase; +struct RADDBGIC_LocationCase { - CONS_LocationCase *next; + RADDBGIC_LocationCase *next; U64 voff_first; U64 voff_opl; - CONS_Location *location; + RADDBGIC_Location *location; }; -typedef struct CONS_LocationSet CONS_LocationSet; -struct CONS_LocationSet +typedef struct RADDBGIC_LocationSet RADDBGIC_LocationSet; +struct RADDBGIC_LocationSet { - CONS_LocationCase *first_location_case; - CONS_LocationCase *last_location_case; + RADDBGIC_LocationCase *first_location_case; + RADDBGIC_LocationCase *last_location_case; U64 location_case_count; }; //////////////////////////////// //~ rjf: Name Map Types -typedef struct CONS_NameMapIdxNode CONS_NameMapIdxNode; -struct CONS_NameMapIdxNode +typedef struct RADDBGIC_NameMapIdxNode RADDBGIC_NameMapIdxNode; +struct RADDBGIC_NameMapIdxNode { - CONS_NameMapIdxNode *next; + RADDBGIC_NameMapIdxNode *next; U32 idx[8]; }; -typedef struct CONS_NameMapNode CONS_NameMapNode; -struct CONS_NameMapNode +typedef struct RADDBGIC_NameMapNode RADDBGIC_NameMapNode; +struct RADDBGIC_NameMapNode { - CONS_NameMapNode *bucket_next; - CONS_NameMapNode *order_next; + RADDBGIC_NameMapNode *bucket_next; + RADDBGIC_NameMapNode *order_next; String8 string; - CONS_NameMapIdxNode *idx_first; - CONS_NameMapIdxNode *idx_last; + RADDBGIC_NameMapIdxNode *idx_first; + RADDBGIC_NameMapIdxNode *idx_last; U64 idx_count; }; -typedef struct CONS_NameMap CONS_NameMap; -struct CONS_NameMap +typedef struct RADDBGIC_NameMap RADDBGIC_NameMap; +struct RADDBGIC_NameMap { - CONS_NameMapNode **buckets; + RADDBGIC_NameMapNode **buckets; U64 buckets_count; U64 bucket_collision_count; - CONS_NameMapNode *first; - CONS_NameMapNode *last; + RADDBGIC_NameMapNode *first; + RADDBGIC_NameMapNode *last; U64 name_count; }; //////////////////////////////// //~ rjf: Top-Level Debug Info Types -typedef struct CONS_TopLevelInfo CONS_TopLevelInfo; -struct CONS_TopLevelInfo +typedef struct RADDBGIC_TopLevelInfo RADDBGIC_TopLevelInfo; +struct RADDBGIC_TopLevelInfo { RADDBGI_Arch architecture; String8 exe_name; @@ -435,8 +435,8 @@ struct CONS_TopLevelInfo //////////////////////////////// //~ rjf: Root Construction Bundle Types -typedef struct CONS_RootParams CONS_RootParams; -struct CONS_RootParams +typedef struct RADDBGIC_RootParams RADDBGIC_RootParams; +struct RADDBGIC_RootParams { U64 addr_size; U32 bucket_count_units; // optional; default chosen if 0 @@ -447,11 +447,11 @@ struct CONS_RootParams U64 bucket_count_type_constructs; // optional; default chosen if 0 }; -typedef struct CONS_Root CONS_Root; -struct CONS_Root +typedef struct RADDBGIC_Root RADDBGIC_Root; +struct RADDBGIC_Root { Arena *arena; - CONS_ErrorList errors; + RADDBGIC_ErrorList errors; //////// Contextual Information @@ -461,68 +461,68 @@ struct CONS_Root // top level info B32 top_level_info_is_set; - CONS_TopLevelInfo top_level_info; + RADDBGIC_TopLevelInfo top_level_info; // binary layout - CONS_BinarySection *binary_section_first; - CONS_BinarySection *binary_section_last; + RADDBGIC_BinarySection *binary_section_first; + RADDBGIC_BinarySection *binary_section_last; U64 binary_section_count; // compilation units - CONS_Unit *unit_first; - CONS_Unit *unit_last; + RADDBGIC_Unit *unit_first; + RADDBGIC_Unit *unit_last; U64 unit_count; - CONS_UnitVMapRange *unit_vmap_range_first; - CONS_UnitVMapRange *unit_vmap_range_last; + RADDBGIC_UnitVMapRange *unit_vmap_range_first; + RADDBGIC_UnitVMapRange *unit_vmap_range_last; U64 unit_vmap_range_count; // types - CONS_Type *first_type; - CONS_Type *last_type; + RADDBGIC_Type *first_type; + RADDBGIC_Type *last_type; U64 type_count; - CONS_Type *nil_type; - CONS_Type *variadic_type; + RADDBGIC_Type *nil_type; + RADDBGIC_Type *variadic_type; - CONS_Type handled_nil_type; + RADDBGIC_Type handled_nil_type; - CONS_TypeUDT *first_udt; - CONS_TypeUDT *last_udt; + RADDBGIC_TypeUDT *first_udt; + RADDBGIC_TypeUDT *last_udt; U64 type_udt_count; U64 total_member_count; U64 total_enum_val_count; // symbols - CONS_Symbol *first_symbol; - CONS_Symbol *last_symbol; + RADDBGIC_Symbol *first_symbol; + RADDBGIC_Symbol *last_symbol; union{ U64 symbol_count; - U64 symbol_kind_counts[CONS_SymbolKind_COUNT]; + U64 symbol_kind_counts[RADDBGIC_SymbolKind_COUNT]; }; - CONS_Scope *first_scope; - CONS_Scope *last_scope; + RADDBGIC_Scope *first_scope; + RADDBGIC_Scope *last_scope; U64 scope_count; U64 scope_voff_count; - CONS_Local *first_local; - CONS_Local *last_local; + RADDBGIC_Local *first_local; + RADDBGIC_Local *last_local; U64 local_count; U64 location_count; // name maps - CONS_NameMap *name_maps[RADDBGI_NameMapKind_COUNT]; + RADDBGIC_NameMap *name_maps[RADDBGI_NameMapKind_COUNT]; //////// Handle Relationship Maps - CONS_U64ToPtrMap unit_map; - CONS_U64ToPtrMap symbol_map; - CONS_U64ToPtrMap scope_map; - CONS_U64ToPtrMap local_map; - CONS_U64ToPtrMap type_from_id_map; - CONS_Str8ToPtrMap construct_map; + RADDBGIC_U64ToPtrMap unit_map; + RADDBGIC_U64ToPtrMap symbol_map; + RADDBGIC_U64ToPtrMap scope_map; + RADDBGIC_U64ToPtrMap local_map; + RADDBGIC_U64ToPtrMap type_from_id_map; + RADDBGIC_Str8ToPtrMap construct_map; }; //////////////////////////////// @@ -530,41 +530,41 @@ struct CONS_Root //- rjf: bake data section data structure -typedef struct CONS_DSectionNode CONS_DSectionNode; -struct CONS_DSectionNode +typedef struct RADDBGIC_DSectionNode RADDBGIC_DSectionNode; +struct RADDBGIC_DSectionNode { - CONS_DSectionNode *next; + RADDBGIC_DSectionNode *next; void *data; U64 size; RADDBGI_DataSectionTag tag; }; -typedef struct CONS_DSections CONS_DSections; -struct CONS_DSections +typedef struct RADDBGIC_DSections RADDBGIC_DSections; +struct RADDBGIC_DSections { - CONS_DSectionNode *first; - CONS_DSectionNode *last; + RADDBGIC_DSectionNode *first; + RADDBGIC_DSectionNode *last; U32 count; }; //- rjf: bake string data structure -typedef struct CONS_StringNode CONS_StringNode; -struct CONS_StringNode +typedef struct RADDBGIC_StringNode RADDBGIC_StringNode; +struct RADDBGIC_StringNode { - CONS_StringNode *order_next; - CONS_StringNode *bucket_next; + RADDBGIC_StringNode *order_next; + RADDBGIC_StringNode *bucket_next; String8 str; U64 hash; U32 idx; }; -typedef struct CONS_Strings CONS_Strings; -struct CONS_Strings +typedef struct RADDBGIC_Strings RADDBGIC_Strings; +struct RADDBGIC_Strings { - CONS_StringNode *order_first; - CONS_StringNode *order_last; - CONS_StringNode **buckets; + RADDBGIC_StringNode *order_first; + RADDBGIC_StringNode *order_last; + RADDBGIC_StringNode **buckets; U64 buckets_count; U64 bucket_collision_count; U32 count; @@ -572,23 +572,23 @@ struct CONS_Strings //- rjf: index run baking data structure -typedef struct CONS_IdxRunNode CONS_IdxRunNode; -struct CONS_IdxRunNode +typedef struct RADDBGIC_IdxRunNode RADDBGIC_IdxRunNode; +struct RADDBGIC_IdxRunNode { - CONS_IdxRunNode *order_next; - CONS_IdxRunNode *bucket_next; + RADDBGIC_IdxRunNode *order_next; + RADDBGIC_IdxRunNode *bucket_next; U32 *idx_run; U64 hash; U32 count; U32 first_idx; }; -typedef struct CONS_IdxRuns CONS_IdxRuns; -struct CONS_IdxRuns +typedef struct RADDBGIC_IdxRuns RADDBGIC_IdxRuns; +struct RADDBGIC_IdxRuns { - CONS_IdxRunNode *order_first; - CONS_IdxRunNode *order_last; - CONS_IdxRunNode **buckets; + RADDBGIC_IdxRunNode *order_first; + RADDBGIC_IdxRunNode *order_last; + RADDBGIC_IdxRunNode **buckets; U64 buckets_count; U64 bucket_collision_count; U32 count; @@ -597,38 +597,38 @@ struct CONS_IdxRuns //- rjf: source file & file path baking data structures -typedef struct CONS_PathNode CONS_PathNode; -struct CONS_PathNode +typedef struct RADDBGIC_PathNode RADDBGIC_PathNode; +struct RADDBGIC_PathNode { - CONS_PathNode *next_order; - CONS_PathNode *parent; - CONS_PathNode *first_child; - CONS_PathNode *last_child; - CONS_PathNode *next_sibling; + RADDBGIC_PathNode *next_order; + RADDBGIC_PathNode *parent; + RADDBGIC_PathNode *first_child; + RADDBGIC_PathNode *last_child; + RADDBGIC_PathNode *next_sibling; String8 name; - struct CONS_SrcNode *src_file; + struct RADDBGIC_SrcNode *src_file; U32 idx; }; -typedef struct CONS_LineMapFragment CONS_LineMapFragment; -struct CONS_LineMapFragment +typedef struct RADDBGIC_LineMapFragment RADDBGIC_LineMapFragment; +struct RADDBGIC_LineMapFragment { - CONS_LineMapFragment *next; - CONS_LineSequenceNode *sequence; + RADDBGIC_LineMapFragment *next; + RADDBGIC_LineSequenceNode *sequence; }; -typedef struct CONS_SrcNode CONS_SrcNode; -struct CONS_SrcNode +typedef struct RADDBGIC_SrcNode RADDBGIC_SrcNode; +struct RADDBGIC_SrcNode { - CONS_SrcNode *next; - CONS_PathNode *path_node; + RADDBGIC_SrcNode *next; + RADDBGIC_PathNode *path_node; U32 idx; String8 normal_full_path; // place to gather the line info attached to this src file - CONS_LineMapFragment *first_fragment; - CONS_LineMapFragment *last_fragment; + RADDBGIC_LineMapFragment *first_fragment; + RADDBGIC_LineMapFragment *last_fragment; // place to put the final baked version of this file's line map U32 line_map_nums_data_idx; @@ -637,22 +637,22 @@ struct CONS_SrcNode U32 line_map_voff_data_idx; }; -typedef struct CONS_PathTree CONS_PathTree; -struct CONS_PathTree +typedef struct RADDBGIC_PathTree RADDBGIC_PathTree; +struct RADDBGIC_PathTree { - CONS_PathNode *first; - CONS_PathNode *last; + RADDBGIC_PathNode *first; + RADDBGIC_PathNode *last; U32 count; - CONS_PathNode root; - CONS_SrcNode *src_first; - CONS_SrcNode *src_last; + RADDBGIC_PathNode root; + RADDBGIC_SrcNode *src_first; + RADDBGIC_SrcNode *src_last; U32 src_count; }; //- rjf: line info baking data structures -typedef struct CONS_LineRec CONS_LineRec; -struct CONS_LineRec +typedef struct RADDBGIC_LineRec RADDBGIC_LineRec; +struct RADDBGIC_LineRec { U32 file_id; U32 line_num; @@ -660,8 +660,8 @@ struct CONS_LineRec U16 col_opl; }; -typedef struct CONS_UnitLinesCombined CONS_UnitLinesCombined; -struct CONS_UnitLinesCombined +typedef struct RADDBGIC_UnitLinesCombined RADDBGIC_UnitLinesCombined; +struct RADDBGIC_UnitLinesCombined { U64 *voffs; RADDBGI_Line *lines; @@ -669,8 +669,8 @@ struct CONS_UnitLinesCombined U32 line_count; }; -typedef struct CONS_SrcLinesCombined CONS_SrcLinesCombined; -struct CONS_SrcLinesCombined +typedef struct RADDBGIC_SrcLinesCombined RADDBGIC_SrcLinesCombined; +struct RADDBGIC_SrcLinesCombined { U32 *line_nums; U32 *line_ranges; @@ -679,51 +679,51 @@ struct CONS_SrcLinesCombined U32 voff_count; }; -typedef struct CONS_SrcLineMapVoffBlock CONS_SrcLineMapVoffBlock; -struct CONS_SrcLineMapVoffBlock +typedef struct RADDBGIC_SrcLineMapVoffBlock RADDBGIC_SrcLineMapVoffBlock; +struct RADDBGIC_SrcLineMapVoffBlock { - CONS_SrcLineMapVoffBlock *next; + RADDBGIC_SrcLineMapVoffBlock *next; U64 voff; }; -typedef struct CONS_SrcLineMapBucket CONS_SrcLineMapBucket; -struct CONS_SrcLineMapBucket +typedef struct RADDBGIC_SrcLineMapBucket RADDBGIC_SrcLineMapBucket; +struct RADDBGIC_SrcLineMapBucket { - CONS_SrcLineMapBucket *order_next; - CONS_SrcLineMapBucket *hash_next; + RADDBGIC_SrcLineMapBucket *order_next; + RADDBGIC_SrcLineMapBucket *hash_next; U32 line_num; - CONS_SrcLineMapVoffBlock *first_voff_block; - CONS_SrcLineMapVoffBlock *last_voff_block; + RADDBGIC_SrcLineMapVoffBlock *first_voff_block; + RADDBGIC_SrcLineMapVoffBlock *last_voff_block; U64 voff_count; }; //- rjf: vmap baking data structure -typedef struct CONS_VMap CONS_VMap; -struct CONS_VMap +typedef struct RADDBGIC_VMap RADDBGIC_VMap; +struct RADDBGIC_VMap { RADDBGI_VMapEntry *vmap; // [count + 1] U32 count; }; -typedef struct CONS_VMapMarker CONS_VMapMarker; -struct CONS_VMapMarker +typedef struct RADDBGIC_VMapMarker RADDBGIC_VMapMarker; +struct RADDBGIC_VMapMarker { U32 idx; U32 begin_range; }; -typedef struct CONS_VMapRangeTracker CONS_VMapRangeTracker; -struct CONS_VMapRangeTracker +typedef struct RADDBGIC_VMapRangeTracker RADDBGIC_VMapRangeTracker; +struct RADDBGIC_VMapRangeTracker { - CONS_VMapRangeTracker *next; + RADDBGIC_VMapRangeTracker *next; U32 idx; }; //- rjf: type data baking types -typedef struct CONS_TypeData CONS_TypeData; -struct CONS_TypeData +typedef struct RADDBGIC_TypeData RADDBGIC_TypeData; +struct RADDBGIC_TypeData { RADDBGI_TypeNode *type_nodes; U32 type_node_count; @@ -740,13 +740,13 @@ struct CONS_TypeData //- rjf: symbol data baking types -typedef struct CONS_SymbolData CONS_SymbolData; -struct CONS_SymbolData +typedef struct RADDBGIC_SymbolData RADDBGIC_SymbolData; +struct RADDBGIC_SymbolData { RADDBGI_GlobalVariable *global_variables; U32 global_variable_count; - CONS_VMap *global_vmap; + RADDBGIC_VMap *global_vmap; RADDBGI_ThreadVariable *thread_variables; U32 thread_variable_count; @@ -760,7 +760,7 @@ struct CONS_SymbolData U64 *scope_voffs; U32 scope_voff_count; - CONS_VMap *scope_vmap; + RADDBGIC_VMap *scope_vmap; RADDBGI_Local *locals; U32 local_count; @@ -774,23 +774,23 @@ struct CONS_SymbolData //- rjf: name map baking types -typedef struct CONS_NameMapSemiNode CONS_NameMapSemiNode; -struct CONS_NameMapSemiNode +typedef struct RADDBGIC_NameMapSemiNode RADDBGIC_NameMapSemiNode; +struct RADDBGIC_NameMapSemiNode { - CONS_NameMapSemiNode *next; - CONS_NameMapNode *node; + RADDBGIC_NameMapSemiNode *next; + RADDBGIC_NameMapNode *node; }; -typedef struct CONS_NameMapSemiBucket CONS_NameMapSemiBucket; -struct CONS_NameMapSemiBucket +typedef struct RADDBGIC_NameMapSemiBucket RADDBGIC_NameMapSemiBucket; +struct RADDBGIC_NameMapSemiBucket { - CONS_NameMapSemiNode *first; - CONS_NameMapSemiNode *last; + RADDBGIC_NameMapSemiNode *first; + RADDBGIC_NameMapSemiNode *last; U64 count; }; -typedef struct CONS_NameMapBaked CONS_NameMapBaked; -struct CONS_NameMapBaked +typedef struct RADDBGIC_NameMapBaked RADDBGIC_NameMapBaked; +struct RADDBGIC_NameMapBaked { RADDBGI_NameMapBucket *buckets; RADDBGI_NameMapNode *nodes; @@ -800,198 +800,198 @@ struct CONS_NameMapBaked //- rjf: bundle baking context type -typedef struct CONS_BakeParams CONS_BakeParams; -struct CONS_BakeParams +typedef struct RADDBGIC_BakeParams RADDBGIC_BakeParams; +struct RADDBGIC_BakeParams { U64 strings_bucket_count; U64 idx_runs_bucket_count; }; -typedef struct CONS_BakeCtx CONS_BakeCtx; -struct CONS_BakeCtx +typedef struct RADDBGIC_BakeCtx RADDBGIC_BakeCtx; +struct RADDBGIC_BakeCtx { Arena *arena; - CONS_Strings strs; - CONS_IdxRuns idxs; - CONS_PathTree *tree; + RADDBGIC_Strings strs; + RADDBGIC_IdxRuns idxs; + RADDBGIC_PathTree *tree; }; //////////////////////////////// //~ rjf: Basic Type Helpers //- rjf: type lists -static void cons_type_list_push(Arena *arena, CONS_TypeList *list, CONS_Type *type); +static void raddbgic_type_list_push(Arena *arena, RADDBGIC_TypeList *list, RADDBGIC_Type *type); //- rjf: bytecode lists -static void cons_bytecode_push_op(Arena *arena, CONS_EvalBytecode *bytecode, RADDBGI_EvalOp op, U64 p); -static void cons_bytecode_push_uconst(Arena *arena, CONS_EvalBytecode *bytecode, U64 x); -static void cons_bytecode_push_sconst(Arena *arena, CONS_EvalBytecode *bytecode, S64 x); -static void cons_bytecode_concat_in_place(CONS_EvalBytecode *left_dst, CONS_EvalBytecode *right_destroyed); +static void raddbgic_bytecode_push_op(Arena *arena, RADDBGIC_EvalBytecode *bytecode, RADDBGI_EvalOp op, U64 p); +static void raddbgic_bytecode_push_uconst(Arena *arena, RADDBGIC_EvalBytecode *bytecode, U64 x); +static void raddbgic_bytecode_push_sconst(Arena *arena, RADDBGIC_EvalBytecode *bytecode, S64 x); +static void raddbgic_bytecode_concat_in_place(RADDBGIC_EvalBytecode *left_dst, RADDBGIC_EvalBytecode *right_destroyed); //- rjf: sortable range sorting -static CONS_SortKey* cons_sort_key_array(Arena *arena, CONS_SortKey *keys, U64 count); +static RADDBGIC_SortKey* raddbgic_sort_key_array(Arena *arena, RADDBGIC_SortKey *keys, U64 count); //////////////////////////////// //~ rjf: Auxiliary Data Structure Functions //- rjf: u64 -> ptr map -static void cons_u64toptr_init(Arena *arena, CONS_U64ToPtrMap *map, U64 bucket_count); -static void cons_u64toptr_lookup(CONS_U64ToPtrMap *map, U64 key, U64 hash, CONS_U64ToPtrLookup *lookup_out); -static void cons_u64toptr_insert(Arena *arena, CONS_U64ToPtrMap *map, U64 key, U64 hash, CONS_U64ToPtrLookup *lookup, void *ptr); +static void raddbgic_u64toptr_init(Arena *arena, RADDBGIC_U64ToPtrMap *map, U64 bucket_count); +static void raddbgic_u64toptr_lookup(RADDBGIC_U64ToPtrMap *map, U64 key, U64 hash, RADDBGIC_U64ToPtrLookup *lookup_out); +static void raddbgic_u64toptr_insert(Arena *arena, RADDBGIC_U64ToPtrMap *map, U64 key, U64 hash, RADDBGIC_U64ToPtrLookup *lookup, void *ptr); //- rjf: string8 -> ptr map -static void cons_str8toptr_init(Arena *arena, CONS_Str8ToPtrMap *map, U64 bucket_count); -static void*cons_str8toptr_lookup(CONS_Str8ToPtrMap *map, String8 key, U64 hash); -static void cons_str8toptr_insert(Arena *arena, CONS_Str8ToPtrMap *map, String8 key, U64 hash, void *ptr); +static void raddbgic_str8toptr_init(Arena *arena, RADDBGIC_Str8ToPtrMap *map, U64 bucket_count); +static void*raddbgic_str8toptr_lookup(RADDBGIC_Str8ToPtrMap *map, String8 key, U64 hash); +static void raddbgic_str8toptr_insert(Arena *arena, RADDBGIC_Str8ToPtrMap *map, String8 key, U64 hash, void *ptr); //////////////////////////////// //~ rjf: Loose Debug Info Construction (Anything -> Loose) Functions //- rjf: root creation -static CONS_Root* cons_root_new(CONS_RootParams *params); -static void cons_root_release(CONS_Root *root); +static RADDBGIC_Root* raddbgic_root_new(RADDBGIC_RootParams *params); +static void raddbgic_root_release(RADDBGIC_Root *root); //- rjf: error accumulation -static void cons_error(CONS_Root *root, String8 string); -static void cons_errorf(CONS_Root *root, char *fmt, ...); -static CONS_Error* cons_get_first_error(CONS_Root *root); +static void raddbgic_error(RADDBGIC_Root *root, String8 string); +static void raddbgic_errorf(RADDBGIC_Root *root, char *fmt, ...); +static RADDBGIC_Error* raddbgic_get_first_error(RADDBGIC_Root *root); //- rjf: top-level info specification -static void cons_set_top_level_info(CONS_Root *root, CONS_TopLevelInfo *tli); +static void raddbgic_set_top_level_info(RADDBGIC_Root *root, RADDBGIC_TopLevelInfo *tli); //- rjf: binary section building -static void cons_add_binary_section(CONS_Root *root, - String8 name, RADDBGI_BinarySectionFlags flags, - U64 voff_first, U64 voff_opl, U64 foff_first, - U64 foff_opl); +static void raddbgic_add_binary_section(RADDBGIC_Root *root, + String8 name, RADDBGI_BinarySectionFlags flags, + U64 voff_first, U64 voff_opl, U64 foff_first, + U64 foff_opl); //- rjf: unit info building -static CONS_Unit* cons_unit_handle_from_user_id(CONS_Root *root, U64 unit_user_id, U64 unit_user_id_hash); -static void cons_unit_set_info(CONS_Root *root, CONS_Unit *unit, CONS_UnitInfo *info); -static void cons_unit_add_line_sequence(CONS_Root *root, CONS_Unit *unit, - CONS_LineSequence *line_sequence); -static void cons_unit_vmap_add_range(CONS_Root *root, CONS_Unit *unit, U64 first, U64 opl); +static RADDBGIC_Unit* raddbgic_unit_handle_from_user_id(RADDBGIC_Root *root, U64 unit_user_id, U64 unit_user_id_hash); +static void raddbgic_unit_set_info(RADDBGIC_Root *root, RADDBGIC_Unit *unit, RADDBGIC_UnitInfo *info); +static void raddbgic_unit_add_line_sequence(RADDBGIC_Root *root, RADDBGIC_Unit *unit, + RADDBGIC_LineSequence *line_sequence); +static void raddbgic_unit_vmap_add_range(RADDBGIC_Root *root, RADDBGIC_Unit *unit, U64 first, U64 opl); //- rjf: type info lookups/reservations -static CONS_Type* cons_type_from_id(CONS_Root *root, U64 type_user_id, U64 type_user_id_hash); -static CONS_Reservation* cons_type_reserve_id(CONS_Root *root, U64 type_user_id, U64 type_user_id_hash); -static void cons_type_fill_id(CONS_Root *root, CONS_Reservation *res, CONS_Type *type); +static RADDBGIC_Type* raddbgic_type_from_id(RADDBGIC_Root *root, U64 type_user_id, U64 type_user_id_hash); +static RADDBGIC_Reservation* raddbgic_type_reserve_id(RADDBGIC_Root *root, U64 type_user_id, U64 type_user_id_hash); +static void raddbgic_type_fill_id(RADDBGIC_Root *root, RADDBGIC_Reservation *res, RADDBGIC_Type *type); //- rjf: nil/singleton types -static B32 cons_type_is_unhandled_nil(CONS_Root *root, CONS_Type *type); -static CONS_Type* cons_type_handled_nil(CONS_Root *root); -static CONS_Type* cons_type_nil(CONS_Root *root); -static CONS_Type* cons_type_variadic(CONS_Root *root); +static B32 raddbgic_type_is_unhandled_nil(RADDBGIC_Root *root, RADDBGIC_Type *type); +static RADDBGIC_Type* raddbgic_type_handled_nil(RADDBGIC_Root *root); +static RADDBGIC_Type* raddbgic_type_nil(RADDBGIC_Root *root); +static RADDBGIC_Type* raddbgic_type_variadic(RADDBGIC_Root *root); //- rjf: base type info constructors -static CONS_Type* cons_type_new(CONS_Root *root); -static CONS_TypeUDT* cons_type_udt_from_any_type(CONS_Root *root, CONS_Type *type); -static CONS_TypeUDT* cons_type_udt_from_record_type(CONS_Root *root, CONS_Type *type); +static RADDBGIC_Type* raddbgic_type_new(RADDBGIC_Root *root); +static RADDBGIC_TypeUDT* raddbgic_type_udt_from_any_type(RADDBGIC_Root *root, RADDBGIC_Type *type); +static RADDBGIC_TypeUDT* raddbgic_type_udt_from_record_type(RADDBGIC_Root *root, RADDBGIC_Type *type); //- rjf: basic/operator type construction helpers -static CONS_Type* cons_type_basic(CONS_Root *root, RADDBGI_TypeKind type_kind, String8 name); -static CONS_Type* cons_type_modifier(CONS_Root *root, CONS_Type *direct_type, RADDBGI_TypeModifierFlags flags); -static CONS_Type* cons_type_bitfield(CONS_Root *root, CONS_Type *direct_type, U32 bit_off, U32 bit_count); -static CONS_Type* cons_type_pointer(CONS_Root *root, CONS_Type *direct_type, RADDBGI_TypeKind ptr_type_kind); -static CONS_Type* cons_type_array(CONS_Root *root, CONS_Type *direct_type, U64 count); -static CONS_Type* cons_type_proc(CONS_Root *root, CONS_Type *return_type, struct CONS_TypeList *params); -static CONS_Type* cons_type_method(CONS_Root *root, CONS_Type *this_type, CONS_Type *return_type, struct CONS_TypeList *params); +static RADDBGIC_Type* raddbgic_type_basic(RADDBGIC_Root *root, RADDBGI_TypeKind type_kind, String8 name); +static RADDBGIC_Type* raddbgic_type_modifier(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, RADDBGI_TypeModifierFlags flags); +static RADDBGIC_Type* raddbgic_type_bitfield(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, U32 bit_off, U32 bit_count); +static RADDBGIC_Type* raddbgic_type_pointer(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, RADDBGI_TypeKind ptr_type_kind); +static RADDBGIC_Type* raddbgic_type_array(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, U64 count); +static RADDBGIC_Type* raddbgic_type_proc(RADDBGIC_Root *root, RADDBGIC_Type *return_type, struct RADDBGIC_TypeList *params); +static RADDBGIC_Type* raddbgic_type_method(RADDBGIC_Root *root, RADDBGIC_Type *this_type, RADDBGIC_Type *return_type, struct RADDBGIC_TypeList *params); //- rjf: udt type constructors -static CONS_Type* cons_type_udt(CONS_Root *root, RADDBGI_TypeKind record_type_kind, String8 name, U64 size); -static CONS_Type* cons_type_enum(CONS_Root *root, CONS_Type *direct_type, String8 name); -static CONS_Type* cons_type_alias(CONS_Root *root, CONS_Type *direct_type, String8 name); -static CONS_Type* cons_type_incomplete(CONS_Root *root, RADDBGI_TypeKind type_kind, String8 name); +static RADDBGIC_Type* raddbgic_type_udt(RADDBGIC_Root *root, RADDBGI_TypeKind record_type_kind, String8 name, U64 size); +static RADDBGIC_Type* raddbgic_type_enum(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, String8 name); +static RADDBGIC_Type* raddbgic_type_alias(RADDBGIC_Root *root, RADDBGIC_Type *direct_type, String8 name); +static RADDBGIC_Type* raddbgic_type_incomplete(RADDBGIC_Root *root, RADDBGI_TypeKind type_kind, String8 name); //- rjf: type member building -static void cons_type_add_member_data_field(CONS_Root *root, CONS_Type *record_type, String8 name, CONS_Type *mem_type, U32 off); -static void cons_type_add_member_static_data(CONS_Root *root, CONS_Type *record_type, String8 name, CONS_Type *mem_type); -static void cons_type_add_member_method(CONS_Root *root, CONS_Type *record_type, String8 name, CONS_Type *mem_type); -static void cons_type_add_member_static_method(CONS_Root *root, CONS_Type *record_type, String8 name, CONS_Type *mem_type); -static void cons_type_add_member_virtual_method(CONS_Root *root, CONS_Type *record_type, String8 name, CONS_Type *mem_type); -static void cons_type_add_member_base(CONS_Root *root, CONS_Type *record_type, CONS_Type *base_type, U32 off); -static void cons_type_add_member_virtual_base(CONS_Root *root, CONS_Type *record_type, CONS_Type *base_type, U32 vptr_off, U32 vtable_off); -static void cons_type_add_member_nested_type(CONS_Root *root, CONS_Type *record_type, CONS_Type *nested_type); -static void cons_type_add_enum_val(CONS_Root *root, CONS_Type *enum_type, String8 name, U64 val); +static void raddbgic_type_add_member_data_field(RADDBGIC_Root *root, RADDBGIC_Type *record_type, String8 name, RADDBGIC_Type *mem_type, U32 off); +static void raddbgic_type_add_member_static_data(RADDBGIC_Root *root, RADDBGIC_Type *record_type, String8 name, RADDBGIC_Type *mem_type); +static void raddbgic_type_add_member_method(RADDBGIC_Root *root, RADDBGIC_Type *record_type, String8 name, RADDBGIC_Type *mem_type); +static void raddbgic_type_add_member_static_method(RADDBGIC_Root *root, RADDBGIC_Type *record_type, String8 name, RADDBGIC_Type *mem_type); +static void raddbgic_type_add_member_virtual_method(RADDBGIC_Root *root, RADDBGIC_Type *record_type, String8 name, RADDBGIC_Type *mem_type); +static void raddbgic_type_add_member_base(RADDBGIC_Root *root, RADDBGIC_Type *record_type, RADDBGIC_Type *base_type, U32 off); +static void raddbgic_type_add_member_virtual_base(RADDBGIC_Root *root, RADDBGIC_Type *record_type, RADDBGIC_Type *base_type, U32 vptr_off, U32 vtable_off); +static void raddbgic_type_add_member_nested_type(RADDBGIC_Root *root, RADDBGIC_Type *record_type, RADDBGIC_Type *nested_type); +static void raddbgic_type_add_enum_val(RADDBGIC_Root *root, RADDBGIC_Type *enum_type, String8 name, U64 val); //- rjf: type source coordinate specifications -static void cons_type_set_source_coordinates(CONS_Root *root, CONS_Type *defined_type, String8 source_path, U32 line, U32 col); +static void raddbgic_type_set_source_coordinates(RADDBGIC_Root *root, RADDBGIC_Type *defined_type, String8 source_path, U32 line, U32 col); //- rjf: symbol info building -static CONS_Symbol* cons_symbol_handle_from_user_id(CONS_Root *root, U64 symbol_user_id, U64 symbol_user_id_hash); -static void cons_symbol_set_info(CONS_Root *root, CONS_Symbol *symbol, CONS_SymbolInfo *info); +static RADDBGIC_Symbol* raddbgic_symbol_handle_from_user_id(RADDBGIC_Root *root, U64 symbol_user_id, U64 symbol_user_id_hash); +static void raddbgic_symbol_set_info(RADDBGIC_Root *root, RADDBGIC_Symbol *symbol, RADDBGIC_SymbolInfo *info); //- rjf: scope info building -static CONS_Scope *cons_scope_handle_from_user_id(CONS_Root *root, U64 scope_user_id, U64 scope_user_id_hash); -static void cons_scope_set_parent(CONS_Root *root, CONS_Scope *scope, CONS_Scope *parent); -static void cons_scope_add_voff_range(CONS_Root *root, CONS_Scope *scope, U64 voff_first, U64 voff_opl); -static void cons_scope_recursive_set_symbol(CONS_Scope *scope, CONS_Symbol *symbol); +static RADDBGIC_Scope *raddbgic_scope_handle_from_user_id(RADDBGIC_Root *root, U64 scope_user_id, U64 scope_user_id_hash); +static void raddbgic_scope_set_parent(RADDBGIC_Root *root, RADDBGIC_Scope *scope, RADDBGIC_Scope *parent); +static void raddbgic_scope_add_voff_range(RADDBGIC_Root *root, RADDBGIC_Scope *scope, U64 voff_first, U64 voff_opl); +static void raddbgic_scope_recursive_set_symbol(RADDBGIC_Scope *scope, RADDBGIC_Symbol *symbol); //- rjf: local info building -static CONS_Local* cons_local_handle_from_user_id(CONS_Root *root, U64 local_user_id, U64 local_user_id_hash); -static void cons_local_set_basic_info(CONS_Root *root, CONS_Local *local, CONS_LocalInfo *info); -static CONS_LocationSet* cons_location_set_from_local(CONS_Root *root, CONS_Local *local); +static RADDBGIC_Local* raddbgic_local_handle_from_user_id(RADDBGIC_Root *root, U64 local_user_id, U64 local_user_id_hash); +static void raddbgic_local_set_basic_info(RADDBGIC_Root *root, RADDBGIC_Local *local, RADDBGIC_LocalInfo *info); +static RADDBGIC_LocationSet* raddbgic_location_set_from_local(RADDBGIC_Root *root, RADDBGIC_Local *local); //- rjf: location info building -static void cons_location_set_add_case(CONS_Root *root, CONS_LocationSet *locset, U64 voff_first, U64 voff_opl, CONS_Location *location); -static CONS_Location* cons_location_addr_bytecode_stream(CONS_Root *root, struct CONS_EvalBytecode *bytecode); -static CONS_Location* cons_location_val_bytecode_stream(CONS_Root *root, struct CONS_EvalBytecode *bytecode); -static CONS_Location* cons_location_addr_reg_plus_u16(CONS_Root *root, U8 reg_code, U16 offset); -static CONS_Location* cons_location_addr_addr_reg_plus_u16(CONS_Root *root, U8 reg_code, U16 offset); -static CONS_Location* cons_location_val_reg(CONS_Root *root, U8 reg_code); +static void raddbgic_location_set_add_case(RADDBGIC_Root *root, RADDBGIC_LocationSet *locset, U64 voff_first, U64 voff_opl, RADDBGIC_Location *location); +static RADDBGIC_Location* raddbgic_location_addr_bytecode_stream(RADDBGIC_Root *root, struct RADDBGIC_EvalBytecode *bytecode); +static RADDBGIC_Location* raddbgic_location_val_bytecode_stream(RADDBGIC_Root *root, struct RADDBGIC_EvalBytecode *bytecode); +static RADDBGIC_Location* raddbgic_location_addr_reg_plus_u16(RADDBGIC_Root *root, U8 reg_code, U16 offset); +static RADDBGIC_Location* raddbgic_location_addr_addr_reg_plus_u16(RADDBGIC_Root *root, U8 reg_code, U16 offset); +static RADDBGIC_Location* raddbgic_location_val_reg(RADDBGIC_Root *root, U8 reg_code); //- rjf: name map building -static CONS_NameMap* cons_name_map_for_kind(CONS_Root *root, RADDBGI_NameMapKind kind); -static void cons_name_map_add_pair(CONS_Root *root, CONS_NameMap *map, String8 name, U32 idx); +static RADDBGIC_NameMap* raddbgic_name_map_for_kind(RADDBGIC_Root *root, RADDBGI_NameMapKind kind); +static void raddbgic_name_map_add_pair(RADDBGIC_Root *root, RADDBGIC_NameMap *map, String8 name, U32 idx); //////////////////////////////// //~ rjf: Debug Info Baking (Loose -> Tight) Functions //- rjf: bake context construction -static CONS_BakeCtx* cons_bake_ctx_begin(CONS_BakeParams *params); -static void cons_bake_ctx_release(CONS_BakeCtx *bake_ctx); +static RADDBGIC_BakeCtx* raddbgic_bake_ctx_begin(RADDBGIC_BakeParams *params); +static void raddbgic_bake_ctx_release(RADDBGIC_BakeCtx *bake_ctx); //- rjf: string baking -static U32 cons_string(CONS_BakeCtx *bctx, String8 str); +static U32 raddbgic_string(RADDBGIC_BakeCtx *bctx, String8 str); //- rjf: idx run baking -static U64 cons_idx_run_hash(U32 *idx_run, U32 count); -static U32 cons_idx_run(CONS_BakeCtx *bctx, U32 *idx_run, U32 count); +static U64 raddbgic_idx_run_hash(U32 *idx_run, U32 count); +static U32 raddbgic_idx_run(RADDBGIC_BakeCtx *bctx, U32 *idx_run, U32 count); //- rjf: data section baking -static U32 cons_dsection(Arena *arena, CONS_DSections *dss, void *data, U64 size, RADDBGI_DataSectionTag tag); +static U32 raddbgic_dsection(Arena *arena, RADDBGIC_DSections *dss, void *data, U64 size, RADDBGI_DataSectionTag tag); //- rjf: paths baking -static String8 cons_normal_string_from_path_node(Arena *arena, CONS_PathNode *node); -static void cons_normal_string_from_path_node_build(Arena *arena, CONS_PathNode *node, String8List *out); -static CONS_PathNode* cons_paths_new_node(CONS_BakeCtx *bctx); -static CONS_PathNode* cons_paths_sub_path(CONS_BakeCtx *bctx, CONS_PathNode *dir, String8 sub_dir); -static CONS_PathNode* cons_paths_node_from_path(CONS_BakeCtx *bctx, String8 path); -static U32 cons_paths_idx_from_path(CONS_BakeCtx *bctx, String8 path); -static CONS_SrcNode* cons_paths_new_src_node(CONS_BakeCtx *bctx); -static CONS_SrcNode* cons_paths_src_node_from_path_node(CONS_BakeCtx *bctx, CONS_PathNode *path_node); +static String8 raddbgic_normal_string_from_path_node(Arena *arena, RADDBGIC_PathNode *node); +static void raddbgic_normal_string_from_path_node_build(Arena *arena, RADDBGIC_PathNode *node, String8List *out); +static RADDBGIC_PathNode* raddbgic_paths_new_node(RADDBGIC_BakeCtx *bctx); +static RADDBGIC_PathNode* raddbgic_paths_sub_path(RADDBGIC_BakeCtx *bctx, RADDBGIC_PathNode *dir, String8 sub_dir); +static RADDBGIC_PathNode* raddbgic_paths_node_from_path(RADDBGIC_BakeCtx *bctx, String8 path); +static U32 raddbgic_paths_idx_from_path(RADDBGIC_BakeCtx *bctx, String8 path); +static RADDBGIC_SrcNode* raddbgic_paths_new_src_node(RADDBGIC_BakeCtx *bctx); +static RADDBGIC_SrcNode* raddbgic_paths_src_node_from_path_node(RADDBGIC_BakeCtx *bctx, RADDBGIC_PathNode *path_node); //- rjf: per-unit line info baking -static CONS_UnitLinesCombined* cons_unit_combine_lines(Arena *arena, CONS_BakeCtx *bctx, CONS_LineSequenceNode *first_seq); +static RADDBGIC_UnitLinesCombined* raddbgic_unit_combine_lines(Arena *arena, RADDBGIC_BakeCtx *bctx, RADDBGIC_LineSequenceNode *first_seq); //- rjf: per-src line info baking -static CONS_SrcLinesCombined* cons_source_combine_lines(Arena *arena, CONS_LineMapFragment *first); +static RADDBGIC_SrcLinesCombined* raddbgic_source_combine_lines(Arena *arena, RADDBGIC_LineMapFragment *first); //- rjf: vmap baking -static CONS_VMap* cons_vmap_from_markers(Arena *arena, CONS_VMapMarker *markers, CONS_SortKey *keys, U64 marker_count); -static CONS_VMap* cons_vmap_from_unit_ranges(Arena *arena, CONS_UnitVMapRange *first, U64 count); +static RADDBGIC_VMap* raddbgic_vmap_from_markers(Arena *arena, RADDBGIC_VMapMarker *markers, RADDBGIC_SortKey *keys, U64 marker_count); +static RADDBGIC_VMap* raddbgic_vmap_from_unit_ranges(Arena *arena, RADDBGIC_UnitVMapRange *first, U64 count); //- rjf: type info baking -static U32* cons_idx_run_from_types(Arena *arena, CONS_Type **types, U32 count); -static CONS_TypeData* cons_type_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx); +static U32* raddbgic_idx_run_from_types(Arena *arena, RADDBGIC_Type **types, U32 count); +static RADDBGIC_TypeData* raddbgic_type_data_combine(Arena *arena, RADDBGIC_Root *root, RADDBGIC_BakeCtx *bctx); //- rjf: symbol data baking -static CONS_SymbolData* cons_symbol_data_combine(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx); +static RADDBGIC_SymbolData* raddbgic_symbol_data_combine(Arena *arena, RADDBGIC_Root *root, RADDBGIC_BakeCtx *bctx); //- rjf: name map baking -static CONS_NameMapBaked* cons_name_map_bake(Arena *arena, CONS_Root *root, CONS_BakeCtx *bctx, CONS_NameMap *map); +static RADDBGIC_NameMapBaked* raddbgic_name_map_bake(Arena *arena, RADDBGIC_Root *root, RADDBGIC_BakeCtx *bctx, RADDBGIC_NameMap *map); //- rjf: top-level baking entry point -static void cons_bake_file(Arena *arena, CONS_Root *root, String8List *out); +static void raddbgic_bake_file(Arena *arena, RADDBGIC_Root *root, String8List *out); #endif // RADDBGI_CONS_H diff --git a/src/raddbgi_convert/pdb/raddbgi_from_pdb.c b/src/raddbgi_convert/pdb/raddbgi_from_pdb.c index 84347d2a..5a36f3d0 100644 --- a/src/raddbgi_convert/pdb/raddbgi_from_pdb.c +++ b/src/raddbgi_convert/pdb/raddbgi_from_pdb.c @@ -139,7 +139,7 @@ pdb_convert_params_from_cmd_line(Arena *arena, CmdLine *cmdline){ //- rjf: pdb conversion context creation static PDBCONV_Ctx * -pdbconv_ctx_alloc(PDBCONV_CtxParams *params, CONS_Root *out_root) +pdbconv_ctx_alloc(PDBCONV_CtxParams *params, RADDBGIC_Root *out_root) { Arena *arena = arena_alloc(); PDBCONV_Ctx *pdb_ctx = push_array(arena, PDBCONV_Ctx, 1); @@ -193,7 +193,7 @@ pdbconv_u32_from_numeric(PDBCONV_Ctx *ctx, CV_NumericParsed *num){ U64 n_u64 = cv_u64_from_numeric(num); U32 n_u32 = (U32)n_u64; if (n_u64 > 0xFFFFFFFF){ - cons_errorf(ctx->root, "constant too large"); + raddbgic_errorf(ctx->root, "constant too large"); n_u32 = 0; } return(n_u32); @@ -219,9 +219,9 @@ pdbconv_type_cons_main_passes(PDBCONV_Ctx *ctx){ // setup variadic itype -> node ProfScope("setup variadic itype -> node") { - CONS_Type *variadic_type = cons_type_variadic(ctx->root); - CONS_Reservation *res = cons_type_reserve_id(ctx->root, CV_TypeId_Variadic, CV_TypeId_Variadic); - cons_type_fill_id(ctx->root, res, variadic_type); + RADDBGIC_Type *variadic_type = raddbgic_type_variadic(ctx->root); + RADDBGIC_Reservation *res = raddbgic_type_reserve_id(ctx->root, CV_TypeId_Variadic, CV_TypeId_Variadic); + raddbgic_type_fill_id(ctx->root, res, variadic_type); } // resolve forward references @@ -414,7 +414,7 @@ pdbconv_type_resolve_fwd(PDBCONV_Ctx *ctx, CV_TypeId itype){ return(result); } -static CONS_Type* +static RADDBGIC_Type* pdbconv_type_resolve_itype(PDBCONV_Ctx *ctx, CV_TypeId itype){ B32 is_basic = (itype < 0x1000); @@ -429,7 +429,7 @@ pdbconv_type_resolve_itype(PDBCONV_Ctx *ctx, CV_TypeId itype){ } // type handle from id - CONS_Type *result = cons_type_from_id(ctx->root, itype, itype); + RADDBGIC_Type *result = raddbgic_type_from_id(ctx->root, itype, itype); // basic type if(result == 0 && is_basic) @@ -446,14 +446,14 @@ pdbconv_type_resolve_itype(PDBCONV_Ctx *ctx, CV_TypeId itype){ // never return null, return "nil" instead if(result == 0) { - result = cons_type_nil(ctx->root); + result = raddbgic_type_nil(ctx->root); } return(result); } static void -pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId field_itype){ +pdbconv_type_equip_members(PDBCONV_Ctx *ctx, RADDBGIC_Type *owner_type, CV_TypeId field_itype){ Temp scratch = scratch_begin(0, 0); String8 data = ctx->leaf->data; @@ -554,9 +554,9 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi list_item_opl_off = name_off + name.size + 1; // emit member - CONS_Type *mem_type = pdbconv_type_resolve_itype(ctx, member->itype); + RADDBGIC_Type *mem_type = pdbconv_type_resolve_itype(ctx, member->itype); U32 offset_u32 = pdbconv_u32_from_numeric(ctx, &offset); - cons_type_add_member_data_field(ctx->root, owner_type, name, mem_type, offset_u32); + raddbgic_type_add_member_data_field(ctx->root, owner_type, name, mem_type, offset_u32); } }break; @@ -575,8 +575,8 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi // TODO(allen): handle attribs // emit member - CONS_Type *mem_type = pdbconv_type_resolve_itype(ctx, stmember->itype); - cons_type_add_member_static_data(ctx->root, owner_type, name, mem_type); + RADDBGIC_Type *mem_type = pdbconv_type_resolve_itype(ctx, stmember->itype); + raddbgic_type_add_member_static_data(ctx->root, owner_type, name, mem_type); } }break; @@ -654,17 +654,17 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi // TODO(allen): handle attribs // emit - CONS_Type *mem_type = pdbconv_type_resolve_itype(ctx, method->itype); + RADDBGIC_Type *mem_type = pdbconv_type_resolve_itype(ctx, method->itype); switch (prop){ default: { - cons_type_add_member_method(ctx->root, owner_type, name, mem_type); + raddbgic_type_add_member_method(ctx->root, owner_type, name, mem_type); }break; case CV_MethodProp_Static: { - cons_type_add_member_static_method(ctx->root, owner_type, name, mem_type); + raddbgic_type_add_member_static_method(ctx->root, owner_type, name, mem_type); }break; case CV_MethodProp_Virtual: @@ -672,7 +672,7 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi case CV_MethodProp_Intro: case CV_MethodProp_PureIntro: { - cons_type_add_member_virtual_method(ctx->root, owner_type, name, mem_type); + raddbgic_type_add_member_virtual_method(ctx->root, owner_type, name, mem_type); }break; } } @@ -705,17 +705,17 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi // TODO(allen): handle attribs // emit - CONS_Type *mem_type = pdbconv_type_resolve_itype(ctx, one_method->itype); + RADDBGIC_Type *mem_type = pdbconv_type_resolve_itype(ctx, one_method->itype); switch (prop){ default: { - cons_type_add_member_method(ctx->root, owner_type, name, mem_type); + raddbgic_type_add_member_method(ctx->root, owner_type, name, mem_type); }break; case CV_MethodProp_Static: { - cons_type_add_member_static_method(ctx->root, owner_type, name, mem_type); + raddbgic_type_add_member_static_method(ctx->root, owner_type, name, mem_type); }break; case CV_MethodProp_Virtual: @@ -723,7 +723,7 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi case CV_MethodProp_Intro: case CV_MethodProp_PureIntro: { - cons_type_add_member_virtual_method(ctx->root, owner_type, name, mem_type); + raddbgic_type_add_member_virtual_method(ctx->root, owner_type, name, mem_type); }break; } } @@ -742,8 +742,8 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi list_item_opl_off = name_off + name.size + 1; // emit member - CONS_Type *mem_type = pdbconv_type_resolve_itype(ctx, nest_type->itype); - cons_type_add_member_nested_type(ctx->root, owner_type, mem_type); + RADDBGIC_Type *mem_type = pdbconv_type_resolve_itype(ctx, nest_type->itype); + raddbgic_type_add_member_nested_type(ctx->root, owner_type, mem_type); } }break; @@ -762,8 +762,8 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi // TODO(allen): handle attribs // emit member - CONS_Type *mem_type = pdbconv_type_resolve_itype(ctx, nest_type->itype); - cons_type_add_member_nested_type(ctx->root, owner_type, mem_type); + RADDBGIC_Type *mem_type = pdbconv_type_resolve_itype(ctx, nest_type->itype); + raddbgic_type_add_member_nested_type(ctx->root, owner_type, mem_type); } }break; @@ -782,9 +782,9 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi // TODO(allen): handle attribs // emit member - CONS_Type *base_type = pdbconv_type_resolve_itype(ctx, bclass->itype); + RADDBGIC_Type *base_type = pdbconv_type_resolve_itype(ctx, bclass->itype); U32 offset_u32 = pdbconv_u32_from_numeric(ctx, &offset); - cons_type_add_member_base(ctx->root, owner_type, base_type, offset_u32); + raddbgic_type_add_member_base(ctx->root, owner_type, base_type, offset_u32); } }break; @@ -807,11 +807,11 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi // TODO(allen): handle attribs // emit member - CONS_Type *base_type = pdbconv_type_resolve_itype(ctx, vbclass->itype); + RADDBGIC_Type *base_type = pdbconv_type_resolve_itype(ctx, vbclass->itype); U32 vbptr_offset_u32 = pdbconv_u32_from_numeric(ctx, &num1); U32 vtable_offset_u32 = pdbconv_u32_from_numeric(ctx, &num2); - cons_type_add_member_virtual_base(ctx->root, owner_type, base_type, - vbptr_offset_u32, vtable_offset_u32); + raddbgic_type_add_member_virtual_base(ctx->root, owner_type, base_type, + vbptr_offset_u32, vtable_offset_u32); } }break; @@ -829,8 +829,8 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi default: { String8 kind_str = cv_string_from_leaf_kind(field_kind); - cons_errorf(ctx->root, "unhandled/invalid case: equip_members -> %.*s", - str8_varg(kind_str)); + raddbgic_errorf(ctx->root, "unhandled/invalid case: equip_members -> %.*s", + str8_varg(kind_str)); }break; } @@ -844,7 +844,7 @@ pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId fi } static void -pdbconv_type_equip_enumerates(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId field_itype){ +pdbconv_type_equip_enumerates(PDBCONV_Ctx *ctx, RADDBGIC_Type *owner_type, CV_TypeId field_itype){ Temp scratch = scratch_begin(0, 0); String8 data = ctx->leaf->data; @@ -946,15 +946,15 @@ pdbconv_type_equip_enumerates(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId // emit enum val U64 val_u64 = cv_u64_from_numeric(&val); - cons_type_add_enum_val(ctx->root, owner_type, name, val_u64); + raddbgic_type_add_enum_val(ctx->root, owner_type, name, val_u64); }break; // unhandled or invalid cases default: { String8 kind_str = cv_string_from_leaf_kind(field_kind); - cons_errorf(ctx->root, "unhandled/invalid case: equip_enumerates -> %.*s", - str8_varg(kind_str)); + raddbgic_errorf(ctx->root, "unhandled/invalid case: equip_enumerates -> %.*s", + str8_varg(kind_str)); }break; } @@ -967,188 +967,188 @@ pdbconv_type_equip_enumerates(PDBCONV_Ctx *ctx, CONS_Type *owner_type, CV_TypeId scratch_end(scratch); } -static CONS_Type* +static RADDBGIC_Type* pdbconv_type_cons_basic(PDBCONV_Ctx *ctx, CV_TypeId itype){ Assert(itype < 0x1000); CV_BasicPointerKind basic_ptr_kind = CV_BasicPointerKindFromTypeId(itype); CV_BasicType basic_type_code = CV_BasicTypeFromTypeId(itype); - CONS_Reservation *basic_res = cons_type_reserve_id(ctx->root, basic_type_code, basic_type_code); + RADDBGIC_Reservation *basic_res = raddbgic_type_reserve_id(ctx->root, basic_type_code, basic_type_code); - CONS_Type *basic_type = 0; + RADDBGIC_Type *basic_type = 0; switch (basic_type_code){ case CV_BasicType_VOID: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_Void, str8_lit("void")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_Void, str8_lit("void")); }break; case CV_BasicType_HRESULT: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_Handle, str8_lit("HRESULT")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_Handle, str8_lit("HRESULT")); }break; case CV_BasicType_RCHAR: case CV_BasicType_CHAR: case CV_BasicType_CHAR8: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_Char8, str8_lit("char")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_Char8, str8_lit("char")); }break; case CV_BasicType_UCHAR: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_UChar8, str8_lit("UCHAR")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_UChar8, str8_lit("UCHAR")); }break; case CV_BasicType_WCHAR: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_UChar16, str8_lit("WCHAR")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_UChar16, str8_lit("WCHAR")); }break; case CV_BasicType_CHAR16: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_Char16, str8_lit("CHAR16")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_Char16, str8_lit("CHAR16")); }break; case CV_BasicType_CHAR32: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_Char32, str8_lit("CHAR32")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_Char32, str8_lit("CHAR32")); }break; case CV_BasicType_BOOL8: case CV_BasicType_INT8: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_S8, str8_lit("S8")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_S8, str8_lit("S8")); }break; case CV_BasicType_BOOL16: case CV_BasicType_INT16: case CV_BasicType_SHORT: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_S16, str8_lit("S16")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_S16, str8_lit("S16")); }break; case CV_BasicType_BOOL32: case CV_BasicType_INT32: case CV_BasicType_LONG: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_S32, str8_lit("S32")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_S32, str8_lit("S32")); }break; case CV_BasicType_BOOL64: case CV_BasicType_INT64: case CV_BasicType_QUAD: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_S64, str8_lit("S64")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_S64, str8_lit("S64")); }break; case CV_BasicType_INT128: case CV_BasicType_OCT: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_S128, str8_lit("S128")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_S128, str8_lit("S128")); }break; case CV_BasicType_UINT8: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_U8, str8_lit("U8")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_U8, str8_lit("U8")); }break; case CV_BasicType_UINT16: case CV_BasicType_USHORT: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_U16, str8_lit("U16")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_U16, str8_lit("U16")); }break; case CV_BasicType_UINT32: case CV_BasicType_ULONG: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_U32, str8_lit("U32")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_U32, str8_lit("U32")); }break; case CV_BasicType_UINT64: case CV_BasicType_UQUAD: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_U64, str8_lit("U64")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_U64, str8_lit("U64")); }break; case CV_BasicType_UINT128: case CV_BasicType_UOCT: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_U128, str8_lit("U128")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_U128, str8_lit("U128")); }break; case CV_BasicType_FLOAT16: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_F16, str8_lit("F16")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_F16, str8_lit("F16")); }break; case CV_BasicType_FLOAT32: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_F32, str8_lit("F32")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_F32, str8_lit("F32")); }break; case CV_BasicType_FLOAT32PP: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_F32PP, str8_lit("F32PP")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_F32PP, str8_lit("F32PP")); }break; case CV_BasicType_FLOAT48: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_F48, str8_lit("F48")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_F48, str8_lit("F48")); }break; case CV_BasicType_FLOAT64: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_F64, str8_lit("F64")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_F64, str8_lit("F64")); }break; case CV_BasicType_FLOAT80: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_F80, str8_lit("F80")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_F80, str8_lit("F80")); }break; case CV_BasicType_FLOAT128: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_F128, str8_lit("F128")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_F128, str8_lit("F128")); }break; case CV_BasicType_COMPLEX32: { basic_type = - cons_type_basic(ctx->root, RADDBGI_TypeKind_ComplexF32, str8_lit("ComplexF32")); + raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_ComplexF32, str8_lit("ComplexF32")); }break; case CV_BasicType_COMPLEX64: { basic_type = - cons_type_basic(ctx->root, RADDBGI_TypeKind_ComplexF64, str8_lit("ComplexF64")); + raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_ComplexF64, str8_lit("ComplexF64")); }break; case CV_BasicType_COMPLEX80: { basic_type = - cons_type_basic(ctx->root, RADDBGI_TypeKind_ComplexF80, str8_lit("ComplexF80")); + raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_ComplexF80, str8_lit("ComplexF80")); }break; case CV_BasicType_COMPLEX128: { basic_type = - cons_type_basic(ctx->root, RADDBGI_TypeKind_ComplexF128, str8_lit("ComplexF128")); + raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_ComplexF128, str8_lit("ComplexF128")); }break; case CV_BasicType_PTR: { - basic_type = cons_type_basic(ctx->root, RADDBGI_TypeKind_Handle, str8_lit("PTR")); + basic_type = raddbgic_type_basic(ctx->root, RADDBGI_TypeKind_Handle, str8_lit("PTR")); }break; } // basic resolve - cons_type_fill_id(ctx->root, basic_res, basic_type); + raddbgic_type_fill_id(ctx->root, basic_res, basic_type); // wrap in constructed type - CONS_Type *constructed_type = 0; + RADDBGIC_Type *constructed_type = 0; if (basic_ptr_kind != 0 && basic_type != 0){ - CONS_Reservation *constructed_res = cons_type_reserve_id(ctx->root, itype, itype); + RADDBGIC_Reservation *constructed_res = raddbgic_type_reserve_id(ctx->root, itype, itype); switch (basic_ptr_kind){ case CV_BasicPointerKind_16BIT: @@ -1158,16 +1158,16 @@ pdbconv_type_cons_basic(PDBCONV_Ctx *ctx, CV_TypeId itype){ case CV_BasicPointerKind_16_32BIT: case CV_BasicPointerKind_64BIT: { - constructed_type = cons_type_pointer(ctx->root, basic_type, RADDBGI_TypeKind_Ptr); + constructed_type = raddbgic_type_pointer(ctx->root, basic_type, RADDBGI_TypeKind_Ptr); }break; } // constructed resolve - cons_type_fill_id(ctx->root, constructed_res, constructed_type); + raddbgic_type_fill_id(ctx->root, constructed_res, constructed_type); } // select output - CONS_Type *result = basic_type; + RADDBGIC_Type *result = basic_type; if (basic_ptr_kind != 0){ result = constructed_type; } @@ -1175,16 +1175,16 @@ pdbconv_type_cons_basic(PDBCONV_Ctx *ctx, CV_TypeId itype){ return(result); } -static CONS_Type* +static RADDBGIC_Type* pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ Assert(ctx->leaf->itype_first <= itype && itype < ctx->leaf->itype_opl); - CONS_Reservation *res = cons_type_reserve_id(ctx->root, itype, itype); + RADDBGIC_Reservation *res = raddbgic_type_reserve_id(ctx->root, itype, itype); CV_RecRange *range = &ctx->leaf->leaf_ranges.ranges[itype - ctx->leaf->itype_first]; String8 data = ctx->leaf->data; - CONS_Type *result = 0; + RADDBGIC_Type *result = 0; if (range->off + range->hdr.size <= data.size){ U8 *first = data.str + range->off + 2; U64 cap = range->hdr.size - 2; @@ -1204,9 +1204,9 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ flags |= RADDBGI_TypeModifierFlag_Volatile; } - CONS_Type *direct_type = pdbconv_type_resolve_and_check(ctx, modifier->itype); + RADDBGIC_Type *direct_type = pdbconv_type_resolve_and_check(ctx, modifier->itype); if (flags != 0){ - result = cons_type_modifier(ctx->root, direct_type, flags); + result = raddbgic_type_modifier(ctx->root, direct_type, flags); } else{ result = direct_type; @@ -1250,12 +1250,12 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ type_kind = RADDBGI_TypeKind_RRef; } - CONS_Type *direct_type = pdbconv_type_resolve_and_check(ctx, pointer->itype); - CONS_Type *ptr_type = cons_type_pointer(ctx->root, direct_type, type_kind); + RADDBGIC_Type *direct_type = pdbconv_type_resolve_and_check(ctx, pointer->itype); + RADDBGIC_Type *ptr_type = raddbgic_type_pointer(ctx->root, direct_type, type_kind); result = ptr_type; if (modifier_flags != 0){ - result = cons_type_modifier(ctx->root, ptr_type, modifier_flags); + result = raddbgic_type_modifier(ctx->root, ptr_type, modifier_flags); } } }break; @@ -1270,12 +1270,12 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ // TODO(allen): handle call_kind & attribs - CONS_Type *ret_type = pdbconv_type_resolve_and_check(ctx, procedure->ret_itype); + RADDBGIC_Type *ret_type = pdbconv_type_resolve_and_check(ctx, procedure->ret_itype); - CONS_TypeList param_list = {0}; + RADDBGIC_TypeList param_list = {0}; pdbconv_type_resolve_arglist(scratch.arena, ¶m_list, ctx, procedure->arg_itype); - result = cons_type_proc(ctx->root, ret_type, ¶m_list); + result = raddbgic_type_proc(ctx->root, ret_type, ¶m_list); scratch_end(scratch); } @@ -1292,18 +1292,18 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ // TODO(allen): handle call_kind & attribs // TODO(allen): preserve "this_adjust" - CONS_Type *ret_type = pdbconv_type_resolve_and_check(ctx, mfunction->ret_itype); + RADDBGIC_Type *ret_type = pdbconv_type_resolve_and_check(ctx, mfunction->ret_itype); - CONS_TypeList param_list = {0}; + RADDBGIC_TypeList param_list = {0}; pdbconv_type_resolve_arglist(scratch.arena, ¶m_list, ctx, mfunction->arg_itype); - CONS_Type *this_type = 0; + RADDBGIC_Type *this_type = 0; if (mfunction->this_itype != 0){ this_type = pdbconv_type_resolve_and_check(ctx, mfunction->this_itype); - result = cons_type_method(ctx->root, this_type, ret_type, ¶m_list); + result = raddbgic_type_method(ctx->root, this_type, ret_type, ¶m_list); } else{ - result = cons_type_proc(ctx->root, ret_type, ¶m_list); + result = raddbgic_type_proc(ctx->root, ret_type, ¶m_list); } scratch_end(scratch); @@ -1315,8 +1315,8 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ // TODO(allen): error if bad range if (sizeof(CV_LeafBitField) <= cap){ CV_LeafBitField *bit_field = (CV_LeafBitField*)first; - CONS_Type *direct_type = pdbconv_type_resolve_and_check(ctx, bit_field->itype); - result = cons_type_bitfield(ctx->root, direct_type, bit_field->pos, bit_field->len); + RADDBGIC_Type *direct_type = pdbconv_type_resolve_and_check(ctx, bit_field->itype); + result = raddbgic_type_bitfield(ctx->root, direct_type, bit_field->pos, bit_field->len); } }break; @@ -1332,14 +1332,14 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ U64 full_size = cv_u64_from_numeric(&array_count); - CONS_Type *direct_type = pdbconv_type_resolve_and_check(ctx, array->entry_itype); + RADDBGIC_Type *direct_type = pdbconv_type_resolve_and_check(ctx, array->entry_itype); U64 count = full_size; if (direct_type != 0 && direct_type->byte_size != 0){ count /= direct_type->byte_size; } // build type - result = cons_type_array(ctx->root, direct_type, count); + result = raddbgic_type_array(ctx->root, direct_type, count); } }break; @@ -1367,7 +1367,7 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ if (range->hdr.kind == CV_LeafKind_CLASS){ type_kind = RADDBGI_TypeKind_IncompleteClass; } - result = cons_type_incomplete(ctx->root, type_kind, name); + result = raddbgic_type_incomplete(ctx->root, type_kind, name); } // complete type @@ -1376,7 +1376,7 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ if (range->hdr.kind == CV_LeafKind_CLASS){ type_kind = RADDBGI_TypeKind_Class; } - result = cons_type_udt(ctx->root, type_kind, name, size_u64); + result = raddbgic_type_udt(ctx->root, type_kind, name, size_u64); // remember to revisit this for members { @@ -1413,7 +1413,7 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ if (range->hdr.kind == CV_LeafKind_CLASS2){ type_kind = RADDBGI_TypeKind_IncompleteClass; } - result = cons_type_incomplete(ctx->root, type_kind, name); + result = raddbgic_type_incomplete(ctx->root, type_kind, name); } // complete type @@ -1422,7 +1422,7 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ if (range->hdr.kind == CV_LeafKind_CLASS2){ type_kind = RADDBGI_TypeKind_Class; } - result = cons_type_udt(ctx->root, type_kind, name, size_u64); + result = raddbgic_type_udt(ctx->root, type_kind, name, size_u64); // remember to revisit this for members { @@ -1455,12 +1455,12 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ // incomplete type if (lf_union->props & CV_TypeProp_FwdRef){ result = - cons_type_incomplete(ctx->root, RADDBGI_TypeKind_IncompleteUnion, name); + raddbgic_type_incomplete(ctx->root, RADDBGI_TypeKind_IncompleteUnion, name); } // complete type else{ - result = cons_type_udt(ctx->root, RADDBGI_TypeKind_Union, name, size_u64); + result = raddbgic_type_udt(ctx->root, RADDBGI_TypeKind_Union, name, size_u64); // remember to revisit this for members { @@ -1487,13 +1487,13 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ // incomplete type if (lf_enum->props & CV_TypeProp_FwdRef){ - result = cons_type_incomplete(ctx->root, RADDBGI_TypeKind_IncompleteEnum, name); + result = raddbgic_type_incomplete(ctx->root, RADDBGI_TypeKind_IncompleteEnum, name); } // complete type else{ - CONS_Type *direct_type = pdbconv_type_resolve_and_check(ctx, lf_enum->base_itype); - result = cons_type_enum(ctx->root, direct_type, name); + RADDBGIC_Type *direct_type = pdbconv_type_resolve_and_check(ctx, lf_enum->base_itype); + result = raddbgic_type_enum(ctx->root, direct_type, name); // remember to revisit this for enumerates { @@ -1512,7 +1512,7 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ case CV_LeafKind_VFTABLE: case CV_LeafKind_LABEL: { - result = cons_type_handled_nil(ctx->root); + result = raddbgic_type_handled_nil(ctx->root); }break; // do nothing cases - these get handled in special passes and @@ -1653,29 +1653,29 @@ pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype){ default: { String8 kind_str = cv_string_from_leaf_kind(range->hdr.kind); - cons_errorf(ctx->root, "pdbconv: unhandled leaf case %.*s (0x%x)", - str8_varg(kind_str), range->hdr.kind); + raddbgic_errorf(ctx->root, "pdbconv: unhandled leaf case %.*s (0x%x)", + str8_varg(kind_str), range->hdr.kind); }break; } } - cons_type_fill_id(ctx->root, res, result); + raddbgic_type_fill_id(ctx->root, res, result); return(result); } -static CONS_Type* +static RADDBGIC_Type* pdbconv_type_resolve_and_check(PDBCONV_Ctx *ctx, CV_TypeId itype){ - CONS_Type *result = pdbconv_type_resolve_itype(ctx, itype); - if(cons_type_is_unhandled_nil(ctx->root, result)) + RADDBGIC_Type *result = pdbconv_type_resolve_itype(ctx, itype); + if(raddbgic_type_is_unhandled_nil(ctx->root, result)) { - cons_errorf(ctx->root, "pdbconv: could not resolve itype (itype = %u)", itype); + raddbgic_errorf(ctx->root, "pdbconv: could not resolve itype (itype = %u)", itype); } return(result); } static void -pdbconv_type_resolve_arglist(Arena *arena, CONS_TypeList *out, +pdbconv_type_resolve_arglist(Arena *arena, RADDBGIC_TypeList *out, PDBCONV_Ctx *ctx, CV_TypeId arglist_itype){ ProfBeginFunction(); @@ -1697,8 +1697,8 @@ pdbconv_type_resolve_arglist(Arena *arena, CONS_TypeList *out, U32 max_count = (cap - sizeof(*arglist))/sizeof(CV_TypeId); U32 clamped_count = ClampTop(arglist->count, max_count); for (U32 i = 0; i < clamped_count; i += 1){ - CONS_Type *param_type = pdbconv_type_resolve_and_check(ctx, itypes[i]); - cons_type_list_push(arena, out, param_type); + RADDBGIC_Type *param_type = pdbconv_type_resolve_and_check(ctx, itypes[i]); + raddbgic_type_list_push(arena, out, param_type); } } @@ -1708,11 +1708,11 @@ pdbconv_type_resolve_arglist(Arena *arena, CONS_TypeList *out, ProfEnd(); } -static CONS_Type* +static RADDBGIC_Type* pdbconv_type_from_name(PDBCONV_Ctx *ctx, String8 name){ // TODO(rjf): no idea if this is correct CV_TypeId cv_type_id = pdb_tpi_first_itype_from_name(ctx->hash, ctx->leaf, name, 0); - CONS_Type *result = cons_type_from_id(ctx->root, cv_type_id, cv_type_id); + RADDBGIC_Type *result = raddbgic_type_from_id(ctx->root, cv_type_id, cv_type_id); return(result); } @@ -1805,7 +1805,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ ProfScope("map out data associations") { // state variables - CONS_Symbol *current_proc = 0; + RADDBGIC_Symbol *current_proc = 0; // loop CV_RecRange *rec_range = sym->sym_ranges.ranges; @@ -1851,7 +1851,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ { U64 symbol_id = user_id_base + off; U64 symbol_hash = pdbconv_hash_from_symbol_user_id(sym_unique_id_hash, symbol_id); - current_proc = cons_symbol_handle_from_user_id(ctx->root, symbol_id, symbol_hash); + current_proc = raddbgic_symbol_handle_from_user_id(ctx->root, symbol_id, symbol_hash); }break; } } @@ -1861,7 +1861,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ ProfScope("main symbol construction pass") { // state variables - CONS_LocationSet *defrange_target = 0; + RADDBGIC_LocationSet *defrange_target = 0; B32 defrange_target_is_param = 0; // loop @@ -1882,8 +1882,8 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ U64 cap = (opl_off - off); // current state - CONS_Scope *current_scope = pdbconv_symbol_current_scope(ctx); - CONS_Symbol *current_procedure = 0; + RADDBGIC_Scope *current_scope = pdbconv_symbol_current_scope(ctx); + RADDBGIC_Symbol *current_procedure = 0; if(current_scope != 0) { current_procedure = current_scope->symbol; @@ -1927,8 +1927,8 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ U64 scope_id = user_id_base + scope_num; U64 scope_hash = pdbconv_hash_from_scope_user_id(sym_unique_id_hash, scope_id); scope_num += 1; - CONS_Scope *block_scope = cons_scope_handle_from_user_id(ctx->root, scope_id, scope_hash); - cons_scope_set_parent(ctx->root, block_scope, current_scope); + RADDBGIC_Scope *block_scope = raddbgic_scope_handle_from_user_id(ctx->root, scope_id, scope_hash); + raddbgic_scope_set_parent(ctx->root, block_scope, current_scope); pdbconv_symbol_push_scope(ctx, block_scope, current_procedure); // set voff range @@ -1936,7 +1936,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ if (section != 0){ U64 voff_first = section->voff + block32->off; U64 voff_last = voff_first + block32->len; - cons_scope_add_voff_range(ctx->root, block_scope, voff_first, voff_last); + raddbgic_scope_add_voff_range(ctx->root, block_scope, voff_first, voff_last); } } }break; @@ -1966,10 +1966,10 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ pdbconv_known_global_insert(ctx->arena, &ctx->known_globals, name, voff); // type of variable - CONS_Type *type = pdbconv_type_resolve_itype(ctx, data32->itype); + RADDBGIC_Type *type = pdbconv_type_resolve_itype(ctx, data32->itype); // container type - CONS_Type *container_type = 0; + RADDBGIC_Type *container_type = 0; U64 container_name_opl = pdbconv_end_of_cplusplus_container_name(name); if (container_name_opl > 2){ String8 container_name = str8(name.str, container_name_opl - 2); @@ -1977,7 +1977,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ } // container symbol - CONS_Symbol *container_symbol = 0; + RADDBGIC_Symbol *container_symbol = 0; if (container_type == 0){ container_symbol = current_procedure; } @@ -1988,10 +1988,10 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ // cons this symbol U64 symbol_id = user_id_base + off; U64 symbol_hash = pdbconv_hash_from_symbol_user_id(sym_unique_id_hash, symbol_id); - CONS_Symbol *symbol = cons_symbol_handle_from_user_id(ctx->root, symbol_id, symbol_hash); + RADDBGIC_Symbol *symbol = raddbgic_symbol_handle_from_user_id(ctx->root, symbol_id, symbol_hash); - CONS_SymbolInfo info = zero_struct; - info.kind = CONS_SymbolKind_GlobalVariable; + RADDBGIC_SymbolInfo info = zero_struct; + info.kind = RADDBGIC_SymbolKind_GlobalVariable; info.name = name; info.type = type; info.is_extern = is_extern; @@ -1999,7 +1999,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ info.container_type = container_type; info.container_symbol = container_symbol; - cons_symbol_set_info(ctx->root, symbol, &info); + raddbgic_symbol_set_info(ctx->root, symbol, &info); } } }break; @@ -2018,10 +2018,10 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ String8 name = str8_cstring_capped((char*)(proc32 + 1), first + cap); // type of procedure - CONS_Type *type = pdbconv_type_resolve_itype(ctx, proc32->itype); + RADDBGIC_Type *type = pdbconv_type_resolve_itype(ctx, proc32->itype); // container type - CONS_Type *container_type = 0; + RADDBGIC_Type *container_type = 0; U64 container_name_opl = pdbconv_end_of_cplusplus_container_name(name); if (container_name_opl > 2){ String8 container_name = str8(name.str, container_name_opl - 2); @@ -2029,7 +2029,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ } // container symbol - CONS_Symbol *container_symbol = 0; + RADDBGIC_Symbol *container_symbol = 0; if (container_type == 0){ container_symbol = current_procedure; } @@ -2037,7 +2037,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ // get this symbol handle U64 symbol_id = user_id_base + off; U64 symbol_hash = pdbconv_hash_from_symbol_user_id(sym_unique_id_hash, symbol_id); - CONS_Symbol *proc_symbol = cons_symbol_handle_from_user_id(ctx->root, symbol_id, symbol_hash); + RADDBGIC_Symbol *proc_symbol = raddbgic_symbol_handle_from_user_id(ctx->root, symbol_id, symbol_hash); // scope @@ -2048,7 +2048,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ // no parent. U64 scope_id = user_id_base + scope_num; U64 scope_hash = pdbconv_hash_from_scope_user_id(sym_unique_id_hash, scope_id); - CONS_Scope *root_scope = cons_scope_handle_from_user_id(ctx->root, scope_id, scope_hash); + RADDBGIC_Scope *root_scope = raddbgic_scope_handle_from_user_id(ctx->root, scope_id, scope_hash); pdbconv_symbol_push_scope(ctx, root_scope, proc_symbol); scope_num += 1; @@ -2058,7 +2058,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ if (section != 0){ U64 voff_first = section->voff + proc32->off; U64 voff_last = voff_first + proc32->len; - cons_scope_add_voff_range(ctx->root, root_scope, voff_first, voff_last); + raddbgic_scope_add_voff_range(ctx->root, root_scope, voff_first, voff_last); voff = voff_first; } @@ -2073,8 +2073,8 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ B32 is_extern = (kind == CV_SymKind_GPROC32); // set symbol info - CONS_SymbolInfo info = zero_struct; - info.kind = CONS_SymbolKind_Procedure; + RADDBGIC_SymbolInfo info = zero_struct; + info.kind = RADDBGIC_SymbolKind_Procedure; info.name = name; info.link_name = link_name; info.type = type; @@ -2083,7 +2083,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ info.container_symbol = container_symbol; info.root_scope = root_scope; - cons_symbol_set_info(ctx->root, proc_symbol, &info); + raddbgic_symbol_set_info(ctx->root, proc_symbol, &info); } }break; @@ -2103,7 +2103,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ String8 name = str8_cstring_capped((char*)(regrel32 + 1), first + cap); // type of variable - CONS_Type *type = pdbconv_type_resolve_itype(ctx, regrel32->itype); + RADDBGIC_Type *type = pdbconv_type_resolve_itype(ctx, regrel32->itype); // extract regrel's info CV_Reg cv_reg = regrel32->reg; @@ -2137,15 +2137,15 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ // emit local U64 local_id = user_id_base + local_num;; U64 local_id_hash = pdbconv_hash_from_local_user_id(sym_unique_id_hash, local_id); - CONS_Local *local_var = cons_local_handle_from_user_id(ctx->root, local_id, local_id_hash); + RADDBGIC_Local *local_var = raddbgic_local_handle_from_user_id(ctx->root, local_id, local_id_hash); local_num += 1; - CONS_LocalInfo info = {0}; + RADDBGIC_LocalInfo info = {0}; info.kind = local_kind; info.scope = current_scope; info.name = name; info.type = type; - cons_local_set_basic_info(ctx->root, local_var, &info); + raddbgic_local_set_basic_info(ctx->root, local_var, &info); // add location to local { @@ -2176,12 +2176,12 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ U32 byte_pos = 0; // set location case - CONS_Location *loc = + RADDBGIC_Location *loc = pdbconv_location_from_addr_reg_off(ctx, register_code, byte_size, byte_pos, (S64)(S32)var_off, extra_indirection_to_value); - CONS_LocationSet *locset = cons_location_set_from_local(ctx->root, local_var); - cons_location_set_add_case(ctx->root, locset, 0, max_U64, loc); + RADDBGIC_LocationSet *locset = raddbgic_location_set_from_local(ctx->root, local_var); + raddbgic_location_set_add_case(ctx->root, locset, 0, max_U64, loc); } } }break; @@ -2203,10 +2203,10 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ U32 tls_off = thread32->tls_off; // type of variable - CONS_Type *type = pdbconv_type_resolve_itype(ctx, thread32->itype); + RADDBGIC_Type *type = pdbconv_type_resolve_itype(ctx, thread32->itype); // container type - CONS_Type *container_type = 0; + RADDBGIC_Type *container_type = 0; U64 container_name_opl = pdbconv_end_of_cplusplus_container_name(name); if (container_name_opl > 2){ String8 container_name = str8(name.str, container_name_opl - 2); @@ -2214,7 +2214,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ } // container symbol - CONS_Symbol *container_symbol = 0; + RADDBGIC_Symbol *container_symbol = 0; if (container_type == 0){ container_symbol = current_procedure; } @@ -2225,10 +2225,10 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ // setup symbol U64 symbol_id = user_id_base + off; U64 symbol_hash = pdbconv_hash_from_symbol_user_id(sym_unique_id_hash, symbol_id); - CONS_Symbol *symbol = cons_symbol_handle_from_user_id(ctx->root, symbol_id, symbol_hash); + RADDBGIC_Symbol *symbol = raddbgic_symbol_handle_from_user_id(ctx->root, symbol_id, symbol_hash); - CONS_SymbolInfo info = zero_struct; - info.kind = CONS_SymbolKind_ThreadVariable; + RADDBGIC_SymbolInfo info = zero_struct; + info.kind = RADDBGIC_SymbolKind_ThreadVariable; info.name = name; info.type = type; info.is_extern = is_extern; @@ -2236,7 +2236,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ info.container_type = container_type; info.container_symbol = container_symbol; - cons_symbol_set_info(ctx->root, symbol, &info); + raddbgic_symbol_set_info(ctx->root, symbol, &info); } }break; @@ -2253,7 +2253,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ String8 name = str8_cstring_capped((char*)(slocal + 1), first + cap); // type of variable - CONS_Type *type = pdbconv_type_resolve_itype(ctx, slocal->itype); + RADDBGIC_Type *type = pdbconv_type_resolve_itype(ctx, slocal->itype); // determine how to handle B32 begin_a_global_modification = 0; @@ -2280,20 +2280,20 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ // emit local U64 local_id = user_id_base + local_num; U64 local_id_hash = pdbconv_hash_from_local_user_id(sym_unique_id_hash, local_id); - CONS_Local *local_var = cons_local_handle_from_user_id(ctx->root, local_id, local_id_hash); + RADDBGIC_Local *local_var = raddbgic_local_handle_from_user_id(ctx->root, local_id, local_id_hash); local_num += 1; local_var->kind = local_kind; local_var->name = name; local_var->type = type; - CONS_LocalInfo info = {0}; + RADDBGIC_LocalInfo info = {0}; info.kind = local_kind; info.scope = current_scope; info.name = name; info.type = type; - cons_local_set_basic_info(ctx->root, local_var, &info); + raddbgic_local_set_basic_info(ctx->root, local_var, &info); - defrange_target = cons_location_set_from_local(ctx->root, local_var); + defrange_target = raddbgic_location_set_from_local(ctx->root, local_var); defrange_target_is_param = (local_kind == RADDBGI_LocalKind_Parameter); } } @@ -2318,7 +2318,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ RADDBGI_RegisterCode register_code = raddbgi_reg_code_from_cv_reg_code(arch, cv_reg); // setup location - CONS_Location *location = cons_location_val_reg(ctx->root, register_code); + RADDBGIC_Location *location = raddbgic_location_val_reg(ctx->root, register_code); // extract range info CV_LvarAddrRange *range = &defrange_register->range; @@ -2356,7 +2356,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ U32 byte_size = ctx->addr_size; U32 byte_pos = 0; S64 var_off = (S64)defrange_fprel->off; - CONS_Location *location = + RADDBGIC_Location *location = pdbconv_location_from_addr_reg_off(ctx, fp_register_code, byte_size, byte_pos, var_off, extra_indirection); @@ -2394,7 +2394,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ RADDBGI_RegisterCode register_code = raddbgi_reg_code_from_cv_reg_code(arch, cv_reg); // setup location - CONS_Location *location = cons_location_val_reg(ctx->root, register_code); + RADDBGIC_Location *location = raddbgic_location_val_reg(ctx->root, register_code); // extract range info CV_LvarAddrRange *range = &defrange_subfield_register->range; @@ -2434,13 +2434,13 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ U32 byte_size = ctx->addr_size; U32 byte_pos = 0; S64 var_off = (S64)defrange_fprel_full_scope->off; - CONS_Location *location = + RADDBGIC_Location *location = pdbconv_location_from_addr_reg_off(ctx, fp_register_code, byte_size, byte_pos, var_off, extra_indirection); // emit location - cons_location_set_add_case(ctx->root, defrange_target, 0, max_U64, location); + raddbgic_location_set_add_case(ctx->root, defrange_target, 0, max_U64, location); } } }break; @@ -2470,7 +2470,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ S64 var_off = defrange_register_rel->reg_off; // setup location - CONS_Location *location = + RADDBGIC_Location *location = pdbconv_location_from_addr_reg_off(ctx, register_code, byte_size, byte_pos, var_off, extra_indirection_to_value); @@ -2500,7 +2500,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ String8 name = str8_cstring_capped((char*)(file_static + 1), first + cap); // type of variable - CONS_Type *type = pdbconv_type_resolve_itype(ctx, file_static->itype); + RADDBGIC_Type *type = pdbconv_type_resolve_itype(ctx, file_static->itype); // TODO(allen): emit a global modifier symbol @@ -2514,7 +2514,7 @@ pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_unique_id){ // if scope stack isn't empty emit an error { - CONS_Scope* scope = pdbconv_symbol_current_scope(ctx); + RADDBGIC_Scope* scope = pdbconv_symbol_current_scope(ctx); if(scope != 0) { // TODO(allen): emit error @@ -2583,7 +2583,7 @@ pdbconv_gather_link_names(PDBCONV_Ctx *ctx, CV_SymParsed *sym){ // "frameproc" map static void -pdbconv_symbol_frame_proc_write(PDBCONV_Ctx *ctx,CONS_Symbol *key,PDBCONV_FrameProcData *data){ +pdbconv_symbol_frame_proc_write(PDBCONV_Ctx *ctx,RADDBGIC_Symbol *key,PDBCONV_FrameProcData *data){ ProfBeginFunction(); U64 key_int = IntFromPtr(key); PDBCONV_FrameProcMap *map = &ctx->frame_proc_map; @@ -2618,7 +2618,7 @@ pdbconv_symbol_frame_proc_write(PDBCONV_Ctx *ctx,CONS_Symbol *key,PDBCONV_FrameP } static PDBCONV_FrameProcData* -pdbconv_symbol_frame_proc_read(PDBCONV_Ctx *ctx, CONS_Symbol *key){ +pdbconv_symbol_frame_proc_read(PDBCONV_Ctx *ctx, RADDBGIC_Symbol *key){ U64 key_int = IntFromPtr(key); PDBCONV_FrameProcMap *map = &ctx->frame_proc_map; U32 bucket_idx = key_int%map->buckets_count; @@ -2639,7 +2639,7 @@ pdbconv_symbol_frame_proc_read(PDBCONV_Ctx *ctx, CONS_Symbol *key){ // scope stack static void -pdbconv_symbol_push_scope(PDBCONV_Ctx *ctx, CONS_Scope *scope, CONS_Symbol *symbol){ +pdbconv_symbol_push_scope(PDBCONV_Ctx *ctx, RADDBGIC_Scope *scope, RADDBGIC_Symbol *symbol){ PDBCONV_ScopeNode *node = ctx->scope_node_free; if (node == 0){ node = push_array(ctx->arena, PDBCONV_ScopeNode, 1); @@ -2757,42 +2757,42 @@ pdbconv_known_global_insert(Arena *arena, PDBCONV_KnownGlobalSet *set, String8 n // location info helpers -static CONS_Location* +static RADDBGIC_Location* pdbconv_location_from_addr_reg_off(PDBCONV_Ctx *ctx, RADDBGI_RegisterCode reg_code, U32 reg_byte_size, U32 reg_byte_pos, S64 offset, B32 extra_indirection){ - CONS_Location *result = 0; + RADDBGIC_Location *result = 0; if (0 <= offset && offset <= (S64)max_U16){ if (extra_indirection){ - result = cons_location_addr_addr_reg_plus_u16(ctx->root, reg_code, (U16)offset); + result = raddbgic_location_addr_addr_reg_plus_u16(ctx->root, reg_code, (U16)offset); } else{ - result = cons_location_addr_reg_plus_u16(ctx->root, reg_code, (U16)offset); + result = raddbgic_location_addr_reg_plus_u16(ctx->root, reg_code, (U16)offset); } } else{ Arena *arena = ctx->arena; - CONS_EvalBytecode bytecode = {0}; + RADDBGIC_EvalBytecode bytecode = {0}; U32 regread_param = RADDBGI_EncodeRegReadParam(reg_code, reg_byte_size, reg_byte_pos); - cons_bytecode_push_op(arena, &bytecode, RADDBGI_EvalOp_RegRead, regread_param); - cons_bytecode_push_sconst(arena, &bytecode, offset); - cons_bytecode_push_op(arena, &bytecode, RADDBGI_EvalOp_Add, 0); + raddbgic_bytecode_push_op(arena, &bytecode, RADDBGI_EvalOp_RegRead, regread_param); + raddbgic_bytecode_push_sconst(arena, &bytecode, offset); + raddbgic_bytecode_push_op(arena, &bytecode, RADDBGI_EvalOp_Add, 0); if (extra_indirection){ - cons_bytecode_push_op(arena, &bytecode, RADDBGI_EvalOp_MemRead, ctx->addr_size); + raddbgic_bytecode_push_op(arena, &bytecode, RADDBGI_EvalOp_MemRead, ctx->addr_size); } - result = cons_location_addr_bytecode_stream(ctx->root, &bytecode); + result = raddbgic_location_addr_bytecode_stream(ctx->root, &bytecode); } return(result); } static CV_EncodedFramePtrReg -pdbconv_cv_encoded_fp_reg_from_proc(PDBCONV_Ctx *ctx, CONS_Symbol *proc, B32 param_base){ +pdbconv_cv_encoded_fp_reg_from_proc(PDBCONV_Ctx *ctx, RADDBGIC_Symbol *proc, B32 param_base){ CV_EncodedFramePtrReg result = 0; if (proc != 0){ PDBCONV_FrameProcData *frame_proc = pdbconv_symbol_frame_proc_read(ctx, proc); @@ -2855,8 +2855,8 @@ pdbconv_reg_code_from_arch_encoded_fp_reg(RADDBGI_Arch arch, CV_EncodedFramePtrR static void pdbconv_location_over_lvar_addr_range(PDBCONV_Ctx *ctx, - CONS_LocationSet *locset, - CONS_Location *location, + RADDBGIC_LocationSet *locset, + RADDBGIC_Location *location, CV_LvarAddrRange *range, CV_LvarAddrGap *gaps, U64 gap_count){ // extract range info @@ -2877,13 +2877,13 @@ pdbconv_location_over_lvar_addr_range(PDBCONV_Ctx *ctx, U64 voff_gap_first = voff_first + gap_ptr->off; U64 voff_gap_opl = voff_gap_first + gap_ptr->len; if (voff_cursor < voff_gap_first){ - cons_location_set_add_case(ctx->root, locset, voff_cursor, voff_gap_first, location); + raddbgic_location_set_add_case(ctx->root, locset, voff_cursor, voff_gap_first, location); } voff_cursor = voff_gap_opl; } if (voff_cursor < voff_opl){ - cons_location_set_add_case(ctx->root, locset, voff_cursor, voff_opl, location); + raddbgic_location_set_add_case(ctx->root, locset, voff_cursor, voff_opl, location); } } @@ -3195,7 +3195,7 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\ // setup root - CONS_RootParams root_params = {0}; + RADDBGIC_RootParams root_params = {0}; root_params.addr_size = addr_size; root_params.bucket_count_units = comp_unit_count; @@ -3205,7 +3205,7 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\ root_params.bucket_count_types = tpi->itype_opl; root_params.bucket_count_type_constructs = tpi->itype_opl; - CONS_Root *root = cons_root_new(&root_params); + RADDBGIC_Root *root = raddbgic_root_new(&root_params); out->root = root; // top level info @@ -3222,13 +3222,13 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\ } // set top level info - CONS_TopLevelInfo tli = {0}; + RADDBGIC_TopLevelInfo tli = {0}; tli.architecture = architecture; tli.exe_name = params->input_exe_name; tli.exe_hash = exe_hash; tli.voff_max = voff_max; - cons_set_top_level_info(root, &tli); + raddbgic_set_top_level_info(root, &tli); } @@ -3242,9 +3242,9 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\ String8 name = str8_cstring_capped(name_first, name_opl); RADDBGI_BinarySectionFlags flags = raddbgi_binary_section_flags_from_coff_section_flags(coff_ptr->flags); - cons_add_binary_section(root, name, flags, - coff_ptr->voff, coff_ptr->voff + coff_ptr->vsize, - coff_ptr->foff, coff_ptr->foff + coff_ptr->fsize); + raddbgic_add_binary_section(root, name, flags, + coff_ptr->voff, coff_ptr->voff + coff_ptr->vsize, + coff_ptr->foff, coff_ptr->foff + coff_ptr->fsize); } } @@ -3287,16 +3287,16 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\ RADDBGI_Language lang = raddbgi_language_from_cv_language(sym->info.language); // basic per unit info - CONS_Unit *unit_handle = cons_unit_handle_from_user_id(root, i, i); + RADDBGIC_Unit *unit_handle = raddbgic_unit_handle_from_user_id(root, i, i); - CONS_UnitInfo info = {0}; + RADDBGIC_UnitInfo info = {0}; info.unit_name = unit_name; info.compiler_name = compiler_name; info.object_file = obj_name; info.archive_file = archive_file; info.language = lang; - cons_unit_set_info(root, unit_handle, &info); + raddbgic_unit_set_info(root, unit_handle, &info); // unit's line info for (CV_C13SubSectionNode *node = unit_c13->first_sub_section; @@ -3310,13 +3310,13 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\ lines_n = lines_n->next) { CV_C13LinesParsed *lines = &lines_n->v; - CONS_LineSequence seq = {0}; + RADDBGIC_LineSequence seq = {0}; seq.file_name = lines->file_name; seq.voffs = lines->voffs; seq.line_nums = lines->line_nums; seq.col_nums = lines->col_nums; seq.line_count = lines->line_count; - cons_unit_add_line_sequence(root, unit_handle, &seq); + raddbgic_unit_add_line_sequence(root, unit_handle, &seq); } } } @@ -3330,10 +3330,10 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\ PDB_CompUnitContribution *contrib_opl = contrib_ptr + comp_unit_contribution_count; for (;contrib_ptr < contrib_opl; contrib_ptr += 1){ if (contrib_ptr->mod < root->unit_count){ - CONS_Unit *unit_handle = cons_unit_handle_from_user_id(root, contrib_ptr->mod, contrib_ptr->mod); - cons_unit_vmap_add_range(root, unit_handle, - contrib_ptr->voff_first, - contrib_ptr->voff_opl); + RADDBGIC_Unit *unit_handle = raddbgic_unit_handle_from_user_id(root, contrib_ptr->mod, contrib_ptr->mod); + raddbgic_unit_vmap_add_range(root, unit_handle, + contrib_ptr->voff_first, + contrib_ptr->voff_opl); } } } @@ -3365,7 +3365,7 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\ // conversion errors if (!params->hide_errors.converting){ - for (CONS_Error *error = cons_get_first_error(root); + for (RADDBGIC_Error *error = raddbgic_get_first_error(root); error != 0; error = error->next){ str8_list_push(arena, &out->errors, error->msg); @@ -3561,12 +3561,12 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\ {str8_lit("pdbconv_ctx frame_proc_map"), pdbconv_ctx?pdbconv_ctx->frame_proc_map.buckets_count:0, pdbconv_ctx?pdbconv_ctx->frame_proc_map.pair_count:0, pdbconv_ctx?pdbconv_ctx->frame_proc_map.bucket_collision_count:0}, {str8_lit("pdbconv_ctx known_globals"), pdbconv_ctx?pdbconv_ctx->known_globals.buckets_count:0, pdbconv_ctx?pdbconv_ctx->known_globals.global_count:0, pdbconv_ctx?pdbconv_ctx->known_globals.bucket_collision_count:0}, {str8_lit("pdbconv_ctx link_names"), pdbconv_ctx?pdbconv_ctx->link_names.buckets_count:0, pdbconv_ctx?pdbconv_ctx->link_names.link_name_count:0, pdbconv_ctx?pdbconv_ctx->link_names.bucket_collision_count:0}, - {str8_lit("cons_root unit_map"), out->root->unit_map.buckets_count, out->root->unit_map.pair_count, out->root->unit_map.bucket_collision_count}, - {str8_lit("cons_root symbol_map"), out->root->symbol_map.buckets_count, out->root->symbol_map.pair_count, out->root->symbol_map.bucket_collision_count}, - {str8_lit("cons_root scope_map"), out->root->scope_map.buckets_count, out->root->scope_map.pair_count, out->root->scope_map.bucket_collision_count}, - {str8_lit("cons_root local_map"), out->root->local_map.buckets_count, out->root->local_map.pair_count, out->root->local_map.bucket_collision_count}, - {str8_lit("cons_root type_from_id_map"), out->root->type_from_id_map.buckets_count, out->root->type_from_id_map.pair_count, out->root->type_from_id_map.bucket_collision_count}, - {str8_lit("cons_root construct_map"), out->root->construct_map.buckets_count, out->root->construct_map.pair_count, out->root->construct_map.bucket_collision_count}, + {str8_lit("raddbgic_root unit_map"), out->root->unit_map.buckets_count, out->root->unit_map.pair_count, out->root->unit_map.bucket_collision_count}, + {str8_lit("raddbgic_root symbol_map"), out->root->symbol_map.buckets_count, out->root->symbol_map.pair_count, out->root->symbol_map.bucket_collision_count}, + {str8_lit("raddbgic_root scope_map"), out->root->scope_map.buckets_count, out->root->scope_map.pair_count, out->root->scope_map.bucket_collision_count}, + {str8_lit("raddbgic_root local_map"), out->root->local_map.buckets_count, out->root->local_map.pair_count, out->root->local_map.bucket_collision_count}, + {str8_lit("raddbgic_root type_from_id_map"), out->root->type_from_id_map.buckets_count, out->root->type_from_id_map.pair_count, out->root->type_from_id_map.bucket_collision_count}, + {str8_lit("raddbgic_root construct_map"), out->root->construct_map.buckets_count, out->root->construct_map.pair_count, out->root->construct_map.bucket_collision_count}, }; for(U64 idx = 0; idx < ArrayCount(table_info); idx += 1) { diff --git a/src/raddbgi_convert/pdb/raddbgi_from_pdb.h b/src/raddbgi_convert/pdb/raddbgi_from_pdb.h index ff1c1513..094df987 100644 --- a/src/raddbgi_convert/pdb/raddbgi_from_pdb.h +++ b/src/raddbgi_convert/pdb/raddbgi_from_pdb.h @@ -62,7 +62,7 @@ typedef struct PDBCONV_FwdMap{ typedef struct PDBCONV_TypeRev{ struct PDBCONV_TypeRev *next; - CONS_Type *owner_type; + RADDBGIC_Type *owner_type; CV_TypeId field_itype; } PDBCONV_TypeRev; @@ -73,7 +73,7 @@ typedef struct PDBCONV_FrameProcData{ typedef struct PDBCONV_FrameProcNode{ struct PDBCONV_FrameProcNode *next; - CONS_Symbol *key; + RADDBGIC_Symbol *key; PDBCONV_FrameProcData data; } PDBCONV_FrameProcNode; @@ -86,8 +86,8 @@ typedef struct PDBCONV_FrameProcMap{ typedef struct PDBCONV_ScopeNode{ struct PDBCONV_ScopeNode *next; - CONS_Scope *scope; - CONS_Symbol *symbol; + RADDBGIC_Scope *scope; + RADDBGIC_Symbol *symbol; } PDBCONV_ScopeNode; typedef struct PDBCONV_KnownGlobalNode{ @@ -148,7 +148,7 @@ typedef struct PDBCONV_Ctx{ U64 section_count; // OUTPUT data - CONS_Root *root; + RADDBGIC_Root *root; // TEMPORARY STATE PDBCONV_FwdMap fwd_map; @@ -164,7 +164,7 @@ typedef struct PDBCONV_Ctx{ } PDBCONV_Ctx; //- rjf: pdb conversion context creation -static PDBCONV_Ctx *pdbconv_ctx_alloc(PDBCONV_CtxParams *params, CONS_Root *out_root); +static PDBCONV_Ctx *pdbconv_ctx_alloc(PDBCONV_CtxParams *params, RADDBGIC_Root *out_root); //- pdb types and symbols static void pdbconv_types_and_symbols(PDBCONV_Ctx *pdb_ctx, PDBCONV_TypesSymbolsParams *params); @@ -187,21 +187,21 @@ static COFF_SectionHeader* pdbconv_sec_header_from_sec_num(PDBCONV_Ctx *ctx, U32 static void pdbconv_type_cons_main_passes(PDBCONV_Ctx *ctx); static CV_TypeId pdbconv_type_resolve_fwd(PDBCONV_Ctx *ctx, CV_TypeId itype); -static CONS_Type* pdbconv_type_resolve_itype(PDBCONV_Ctx *ctx, CV_TypeId itype); -static void pdbconv_type_equip_members(PDBCONV_Ctx *ctx, CONS_Type *owern_type, +static RADDBGIC_Type* pdbconv_type_resolve_itype(PDBCONV_Ctx *ctx, CV_TypeId itype); +static void pdbconv_type_equip_members(PDBCONV_Ctx *ctx, RADDBGIC_Type *owern_type, CV_TypeId field_itype); -static void pdbconv_type_equip_enumerates(PDBCONV_Ctx *ctx, CONS_Type *owner_type, +static void pdbconv_type_equip_enumerates(PDBCONV_Ctx *ctx, RADDBGIC_Type *owner_type, CV_TypeId field_itype); // type info construction helpers -static CONS_Type* pdbconv_type_cons_basic(PDBCONV_Ctx *ctx, CV_TypeId itype); -static CONS_Type* pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype); -static CONS_Type* pdbconv_type_resolve_and_check(PDBCONV_Ctx *ctx, CV_TypeId itype); -static void pdbconv_type_resolve_arglist(Arena *arena, CONS_TypeList *out, +static RADDBGIC_Type* pdbconv_type_cons_basic(PDBCONV_Ctx *ctx, CV_TypeId itype); +static RADDBGIC_Type* pdbconv_type_cons_leaf_record(PDBCONV_Ctx *ctx, CV_TypeId itype); +static RADDBGIC_Type* pdbconv_type_resolve_and_check(PDBCONV_Ctx *ctx, CV_TypeId itype); +static void pdbconv_type_resolve_arglist(Arena *arena, RADDBGIC_TypeList *out, PDBCONV_Ctx *ctx, CV_TypeId arglist_itype); // type info resolution helpers -static CONS_Type* pdbconv_type_from_name(PDBCONV_Ctx *ctx, String8 name); +static RADDBGIC_Type* pdbconv_type_from_name(PDBCONV_Ctx *ctx, String8 name); // type fwd map static void pdbconv_type_fwd_map_set(Arena *arena, PDBCONV_FwdMap *map, @@ -219,12 +219,12 @@ static void pdbconv_symbol_cons(PDBCONV_Ctx *ctx, CV_SymParsed *sym, U32 sym_uni static void pdbconv_gather_link_names(PDBCONV_Ctx *ctx, CV_SymParsed *sym); // "frameproc" map -static void pdbconv_symbol_frame_proc_write(PDBCONV_Ctx *ctx,CONS_Symbol *key, +static void pdbconv_symbol_frame_proc_write(PDBCONV_Ctx *ctx,RADDBGIC_Symbol *key, PDBCONV_FrameProcData *data); -static PDBCONV_FrameProcData* pdbconv_symbol_frame_proc_read(PDBCONV_Ctx *ctx, CONS_Symbol *key); +static PDBCONV_FrameProcData* pdbconv_symbol_frame_proc_read(PDBCONV_Ctx *ctx, RADDBGIC_Symbol *key); // scope stack -static void pdbconv_symbol_push_scope(PDBCONV_Ctx *ctx, CONS_Scope *scope, CONS_Symbol *symbol); +static void pdbconv_symbol_push_scope(PDBCONV_Ctx *ctx, RADDBGIC_Scope *scope, RADDBGIC_Symbol *symbol); static void pdbconv_symbol_pop_scope(PDBCONV_Ctx *ctx); static void pdbconv_symbol_clear_scope_stack(PDBCONV_Ctx *ctx); @@ -246,23 +246,23 @@ static void pdbconv_known_global_insert(Arena *arena, PDBCONV_KnownGlobalSet *se // location info helpers -static CONS_Location* pdbconv_location_from_addr_reg_off(PDBCONV_Ctx *ctx, - RADDBGI_RegisterCode reg_code, - U32 reg_byte_size, - U32 reg_byte_pos, - S64 offset, - B32 extra_indirection); +static RADDBGIC_Location* pdbconv_location_from_addr_reg_off(PDBCONV_Ctx *ctx, + RADDBGI_RegisterCode reg_code, + U32 reg_byte_size, + U32 reg_byte_pos, + S64 offset, + B32 extra_indirection); static CV_EncodedFramePtrReg pdbconv_cv_encoded_fp_reg_from_proc(PDBCONV_Ctx *ctx, - CONS_Symbol *proc, + RADDBGIC_Symbol *proc, B32 param_base); static RADDBGI_RegisterCode pdbconv_reg_code_from_arch_encoded_fp_reg(RADDBGI_Arch arch, CV_EncodedFramePtrReg encoded_reg); static void pdbconv_location_over_lvar_addr_range(PDBCONV_Ctx *ctx, - CONS_LocationSet *locset, - CONS_Location *location, + RADDBGIC_LocationSet *locset, + RADDBGIC_Location *location, CV_LvarAddrRange *range, CV_LvarAddrGap *gaps, U64 gap_count); @@ -278,7 +278,7 @@ typedef struct PDBCONV_Out PDBCONV_Out; struct PDBCONV_Out { B32 good_parse; - CONS_Root *root; + RADDBGIC_Root *root; String8List dump; String8List errors; }; diff --git a/src/raddbgi_convert/pdb/raddbgi_from_pdb_main.c b/src/raddbgi_convert/pdb/raddbgi_from_pdb_main.c index 44a591a4..3245651e 100644 --- a/src/raddbgi_convert/pdb/raddbgi_from_pdb_main.c +++ b/src/raddbgi_convert/pdb/raddbgi_from_pdb_main.c @@ -98,7 +98,7 @@ main(int argc, char **argv){ if(out != 0 && out->good_parse && params->output_name.size > 0 && out->good_parse) { String8List baked = {0}; - cons_bake_file(arena, out->root, &baked); + raddbgic_bake_file(arena, out->root, &baked); for(String8Node *node = baked.first; node != 0; node = node->next) { fwrite(node->string.str, node->string.size, 1, out_file);