ed/raddebugger
1
0
Fork 0
mirror of https://github.com/Ed94/raddebugger.git synced 2026-06-12 23:31:38 -07:00
Code Issues Packages Projects Releases Wiki Activity

further progress/fixes on pdb -> rdi determinism

Browse Source
This commit is contained in:
Ryan Fleury
2025-09-03 18:57:42 -07:00
parent 27d4793900
commit 27f2acd45d
8 changed files with 335 additions and 452 deletions
Download Patch File Download Diff File Expand all files Collapse all files
project.4coder
+1 -1
View File
@@ -47,7 +47,7 @@ commands =
{
//- rjf: [raddbg]
// .f1 = { .win = "raddbg_stable --ipc kill_all && build raddbg telemetry", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
.f1 = { .win = "raddbg_stable --ipc kill_all && build radbin release telemetry", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
.f1 = { .win = "raddbg_stable --ipc kill_all && build radbin debug telemetry", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
//- rjf: [raddbg wsl]
// .f1 = { .win = "wsl ./build.sh raddbg", .linux = "", .out = "*compilation*", .footer_panel = true, .save_dirty_files = true, .cursor_at_end = false, },
src/base/base_strings.c
+19 -4
View File
@@ -367,10 +367,25 @@ str8_find_needle_reverse(String8 string, U64 start_pos, String8 needle, StringMa
}
internal B32
str8_ends_with(String8 string, String8 end, StringMatchFlags flags){
String8 postfix = str8_postfix(string, end.size);
B32 is_match = str8_match(end, postfix, flags);
return is_match;
str8_is_before(String8 a, String8 b)
{
B32 result = 0;
{
U64 common_size = Min(a.size, b.size);
for(U64 off = 0; off < common_size; off += 1)
{
if(a.str[off] < b.str[off])
{
result = 1;
break;
}
if(off+1 == common_size)
{
result = (a.size < b.size);
}
}
}
return result;
}
////////////////////////////////
src/base/base_strings.h
+2
View File
@@ -205,6 +205,8 @@ internal String8 backslashed_from_str8(Arena *arena, String8 string);
internal B32 str8_match(String8 a, String8 b, StringMatchFlags flags);
internal U64 str8_find_needle(String8 string, U64 start_pos, String8 needle, StringMatchFlags flags);
internal U64 str8_find_needle_reverse(String8 string, U64 start_pos, String8 needle, StringMatchFlags flags);
internal B32 str8_is_before(String8 a, String8 b);
#define str8_ends_with(string, end, flags) str8_match(str8_postfix((string), (end).size), (end), (flags))
////////////////////////////////
//~ rjf: String Slicing
src/lib_rdi_make/rdi_make.c
+25 -3
View File
@@ -1482,7 +1482,7 @@ rdim_bake_string_chunk_list_concat_in_place(RDIM_BakeStringChunkList *dst, RDIM_
RSFORCEINLINE int
rdim_bake_string_is_before(void *l, void *r)
{
return ((RDIM_BakeString *)l)->hash < ((RDIM_BakeString *)r)->hash;
return str8_is_before(((RDIM_BakeString *)l)->string, ((RDIM_BakeString *)r)->string);
}
RDI_PROC RDIM_BakeStringChunkList
@@ -1495,6 +1495,10 @@ rdim_bake_string_chunk_list_sorted_from_unsorted(RDIM_Arena *arena, RDIM_BakeStr
for(RDI_U64 idx = 0; idx < n->count; idx += 1)
{
RDIM_BakeString *src_str = &n->v[idx];
if(str8_match(src_str->string, str8_lit("x2"), 0))
{
int x = 0;
}
RDIM_BakeString *dst_str = rdim_bake_string_chunk_list_push(arena, &dst, src->total_count);
rdim_memcpy_struct(dst_str, src_str);
}
@@ -1728,7 +1732,25 @@ rdim_bake_idx_run_chunk_list_concat_in_place(RDIM_BakeIdxRunChunkList *dst, RDIM
RSFORCEINLINE int
rdim_bake_idx_run_is_before(void *l, void *r)
{
return ((RDIM_BakeIdxRun *)l)->hash < ((RDIM_BakeIdxRun *)r)->hash;
B32 is_less_than = 0;
{
RDIM_BakeIdxRun *lir = (RDIM_BakeIdxRun *)l;
RDIM_BakeIdxRun *rir = (RDIM_BakeIdxRun *)r;
U64 common_count = Min(lir->count, rir->count);
for(U64 off = 0; off < common_count; off += 1)
{
if(lir->idxes[off] < rir->idxes[off])
{
is_less_than = 1;
break;
}
if(off+1 == common_count)
{
is_less_than = (lir->count < rir->count);
}
}
}
return is_less_than;
}
RDI_PROC RDIM_BakeIdxRunChunkList
@@ -1923,7 +1945,7 @@ rdim_bake_name_chunk_list_concat_in_place(RDIM_BakeNameChunkList *dst, RDIM_Bake
RSFORCEINLINE int
rdim_bake_name_is_before(void *l, void *r)
{
return ((RDIM_BakeName *)l)->hash < ((RDIM_BakeName *)r)->hash;
return str8_is_before(((RDIM_BakeName *)l)->string, ((RDIM_BakeName *)r)->string);
}
RDI_PROC RDIM_BakeNameChunkList
src/raddbg/raddbg_main.c
+1
View File
@@ -12,6 +12,7 @@
// [ ] stdout/stderr path target setting is now busted >:(
// [ ] target ui entry point should override built-in entry point
// [ ] list of all tabs in palette
// [ ] u64 + (ptr - ptr) seems to produce unexpected results - double check with C rules?
//
//- memory view
// [ ] have smaller visible range than entire memory
src/rdi_from_pdb/rdi_from_pdb_2.c
+196 -372
View File
@@ -412,57 +412,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
lane_sync();
P2R_LinkNameMap link_name_map = p2r2_shared->link_name_map;
//////////////////////////////////////////////////////////////
//- rjf: organize subsets of unit symbol streams by lane
//
ProfScope("organize subsets of unit symbol streams by lane")
{
//- rjf: set up
ProfScope("set up") if(lane_idx() == 0)
{
p2r2_shared->lane_sym_blocks = push_array(arena, P2R2_SymBlockList, lane_count());
p2r2_shared->total_sym_record_count = 0;
for EachIndex(sym_idx, p2r2_shared->all_syms_count)
{
p2r2_shared->total_sym_record_count += all_syms[sym_idx]->sym_ranges.count;
}
}
lane_sync();
//- rjf: gather
ProfScope("gather")
{
Rng1U64 lane_sym_range = lane_range(p2r2_shared->total_sym_record_count);
{
U64 scan_sym_idx = 0;
for EachIndex(idx, all_syms_count)
{
Rng1U64 stream_sym_range = r1u64(scan_sym_idx, scan_sym_idx + all_syms[idx]->sym_ranges.count);
Rng1U64 sym_range_in_stream = intersect_1u64(stream_sym_range, lane_sym_range);
if(sym_range_in_stream.max > sym_range_in_stream.min)
{
P2R2_SymBlock *block = push_array(arena, P2R2_SymBlock, 1);
SLLQueuePush(p2r2_shared->lane_sym_blocks[lane_idx()].first, p2r2_shared->lane_sym_blocks[lane_idx()].last, block);
if(idx > 0)
{
block->unit = comp_units->units[idx-1];
}
else
{
block->unit = &pdb_comp_unit_nil;
}
block->sym = all_syms[idx];
block->c13 = all_c13s[idx];
block->sym_rec_range = r1u64(sym_range_in_stream.min - scan_sym_idx, sym_range_in_stream.max - scan_sym_idx);
}
scan_sym_idx += all_syms[idx]->sym_ranges.count;
}
}
}
}
lane_sync();
P2R2_SymBlockList *lane_sym_blocks = p2r2_shared->lane_sym_blocks;
//////////////////////////////////////////////////////////////
//- rjf: gather all file paths
//
@@ -471,10 +420,9 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
//- rjf: prep outputs
ProfScope("prep outputs") if(lane_idx() == 0)
{
p2r2_shared->lane_inline_file_paths = push_array(arena, String8Array, lane_count());
p2r2_shared->lane_line_file_paths = push_array(arena, String8Array, lane_count());
p2r2_shared->lane_inline_file_paths_hashes = push_array(arena, U64Array, lane_count());
p2r2_shared->lane_line_file_paths_hashes = push_array(arena, U64Array, lane_count());
p2r2_shared->unit_file_paths = push_array(arena, String8Array, comp_units->count);
p2r2_shared->unit_file_paths_hashes = push_array(arena, U64Array, comp_units->count);
p2r2_shared->sym_lane_take_counter = 0;
}
lane_sync();
@@ -482,25 +430,29 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
ProfScope("do wide gather")
{
Temp scratch = scratch_begin(&arena, 1);
String8List inline_src_file_paths = {0};
String8List line_src_file_paths = {0};
//- rjf: build local hash table to dedup files within this lane
U64 hit_path_slots_count = 4096;
String8Node **hit_path_slots = push_array(scratch.arena, String8Node *, hit_path_slots_count);
//- rjf: iterate lane blocks & gather inline site file names
ProfScope("gather inline site file names from this lane's symbols")
for(P2R2_SymBlock *lane_block = lane_sym_blocks[lane_idx()].first;
lane_block != 0;
lane_block = lane_block->next)
//- rjf: take units across lanes, find all file paths
ProfScope("take units across lanes, find all file paths")
for(;;)
{
//- rjf: take next unit
U64 unit_num = ins_atomic_u64_inc_eval(&p2r2_shared->sym_lane_take_counter);
if(unit_num > comp_units->count)
{
break;
}
U64 unit_idx = unit_num-1;
//- rjf: unpack unit
PDB_CompUnit *unit = lane_block->unit;
CV_SymParsed *sym = lane_block->sym;
CV_C13Parsed *c13 = lane_block->c13;
CV_RecRange *rec_ranges_first = sym->sym_ranges.ranges + lane_block->sym_rec_range.min;
CV_RecRange *rec_ranges_opl = sym->sym_ranges.ranges + lane_block->sym_rec_range.max;
PDB_CompUnit *unit = comp_units->units[unit_idx];
CV_SymParsed *sym = all_syms[unit_idx+1];
CV_C13Parsed *c13 = all_c13s[unit_idx+1];
CV_RecRange *rec_ranges_first = sym->sym_ranges.ranges;
CV_RecRange *rec_ranges_opl = sym->sym_ranges.ranges + sym->sym_ranges.count;
//- rjf: produce obj name/path
String8 obj_name = unit->obj_name;
@@ -514,6 +466,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
String8 obj_folder_path = backslashed_from_str8(scratch.arena, str8_chop_last_slash(obj_name));
//- rjf: find all inline site symbols & gather filenames
String8List src_file_paths = {0};
U64 base_voff = 0;
for(CV_RecRange *rec_range = rec_ranges_first;
rec_range < rec_ranges_opl;
@@ -651,7 +604,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
hit_path_node = push_array(scratch.arena, String8Node, 1);
SLLStackPush(hit_path_slots[hit_path_slot], hit_path_node);
hit_path_node->string = file_path_normalized;
str8_list_push(arena, &inline_src_file_paths, push_str8_copy(arena, file_path_normalized));
str8_list_push(arena, &src_file_paths, push_str8_copy(arena, file_path_normalized));
}
line_count = 0;
}
@@ -672,121 +625,78 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
}break;
}
}
}
//- rjf: do per-unit wide gather from unit line tables
ProfScope("do per-unit wide gather from unit line tables")
{
// rjf: iterate all units for this lane
Rng1U64 range = lane_range(comp_units->count);
for EachInRange(idx, range)
// rjf: find all files in this unit's (non-inline) line info
ProfScope("find all files in this unit's (non-inline) line info")
for(CV_C13SubSectionNode *node = c13->first_sub_section;
node != 0;
node = node->next)
{
PDB_CompUnit *unit = comp_units->units[idx];
CV_SymParsed *unit_sym = all_syms[idx+1];
CV_C13Parsed *unit_c13 = all_c13s[idx+1];
CV_RecRange *rec_ranges_first = unit_sym->sym_ranges.ranges;
CV_RecRange *rec_ranges_opl = rec_ranges_first+unit_sym->sym_ranges.count;
// rjf: produce obj name/path
String8 obj_name = unit->obj_name;
if(str8_match(obj_name, str8_lit("* Linker *"), 0) ||
str8_match(obj_name, str8_lit("Import:"), StringMatchFlag_RightSideSloppy))
if(node->kind == CV_C13SubSectionKind_Lines)
{
MemoryZeroStruct(&obj_name);
}
String8 obj_folder_path = backslashed_from_str8(scratch.arena, str8_chop_last_slash(obj_name));
// rjf: find all files in this unit's (non-inline) line info
ProfScope("find all files in this unit's (non-inline) line info")
for(CV_C13SubSectionNode *node = unit_c13->first_sub_section;
node != 0;
node = node->next)
{
if(node->kind == CV_C13SubSectionKind_Lines)
for(CV_C13LinesParsedNode *lines_n = node->lines_first;
lines_n != 0;
lines_n = lines_n->next)
{
for(CV_C13LinesParsedNode *lines_n = node->lines_first;
lines_n != 0;
lines_n = lines_n->next)
// rjf: file name -> sanitized file path
String8 file_path = lines_n->v.file_name;
String8 file_path_sanitized = str8_copy(scratch.arena, str8_skip_chop_whitespace(file_path));
{
// rjf: file name -> sanitized file path
String8 file_path = lines_n->v.file_name;
String8 file_path_sanitized = str8_copy(scratch.arena, str8_skip_chop_whitespace(file_path));
PathStyle file_path_sanitized_style = path_style_from_str8(file_path_sanitized);
String8List file_path_sanitized_parts = str8_split_path(scratch.arena, file_path_sanitized);
if(file_path_sanitized_style == PathStyle_Relative)
{
PathStyle file_path_sanitized_style = path_style_from_str8(file_path_sanitized);
String8List file_path_sanitized_parts = str8_split_path(scratch.arena, file_path_sanitized);
if(file_path_sanitized_style == PathStyle_Relative)
{
String8List obj_folder_path_parts = str8_split_path(scratch.arena, obj_folder_path);
str8_list_concat_in_place(&obj_folder_path_parts, &file_path_sanitized_parts);
file_path_sanitized_parts = obj_folder_path_parts;
file_path_sanitized_style = path_style_from_str8(obj_folder_path);
}
str8_path_list_resolve_dots_in_place(&file_path_sanitized_parts, file_path_sanitized_style);
file_path_sanitized = str8_path_list_join_by_style(scratch.arena, &file_path_sanitized_parts, file_path_sanitized_style);
String8List obj_folder_path_parts = str8_split_path(scratch.arena, obj_folder_path);
str8_list_concat_in_place(&obj_folder_path_parts, &file_path_sanitized_parts);
file_path_sanitized_parts = obj_folder_path_parts;
file_path_sanitized_style = path_style_from_str8(obj_folder_path);
}
// rjf: sanitized file path -> source file node
U64 file_path_sanitized_hash = rdi_hash(file_path_sanitized.str, file_path_sanitized.size);
U64 hit_path_slot = file_path_sanitized_hash%hit_path_slots_count;
String8Node *hit_path_node = 0;
for(String8Node *n = hit_path_slots[hit_path_slot]; n != 0; n = n->next)
str8_path_list_resolve_dots_in_place(&file_path_sanitized_parts, file_path_sanitized_style);
file_path_sanitized = str8_path_list_join_by_style(scratch.arena, &file_path_sanitized_parts, file_path_sanitized_style);
}
// rjf: sanitized file path -> source file node
U64 file_path_sanitized_hash = rdi_hash(file_path_sanitized.str, file_path_sanitized.size);
U64 hit_path_slot = file_path_sanitized_hash%hit_path_slots_count;
String8Node *hit_path_node = 0;
for(String8Node *n = hit_path_slots[hit_path_slot]; n != 0; n = n->next)
{
if(str8_match(n->string, file_path_sanitized, 0))
{
if(str8_match(n->string, file_path_sanitized, 0))
{
hit_path_node = n;
break;
}
}
if(hit_path_node == 0)
{
hit_path_node = push_array(scratch.arena, String8Node, 1);
SLLStackPush(hit_path_slots[hit_path_slot], hit_path_node);
hit_path_node->string = file_path_sanitized;
str8_list_push(scratch.arena, &line_src_file_paths, push_str8_copy(arena, file_path_sanitized));
hit_path_node = n;
break;
}
}
if(hit_path_node == 0)
{
hit_path_node = push_array(scratch.arena, String8Node, 1);
SLLStackPush(hit_path_slots[hit_path_slot], hit_path_node);
hit_path_node->string = file_path_sanitized;
str8_list_push(scratch.arena, &src_file_paths, push_str8_copy(arena, file_path_sanitized));
}
}
}
}
}
//- rjf: merge into array for this lane
p2r2_shared->lane_inline_file_paths[lane_idx()] = str8_array_from_list(arena, &inline_src_file_paths);
p2r2_shared->lane_line_file_paths[lane_idx()] = str8_array_from_list(arena, &line_src_file_paths);
//- rjf: hash this lane's file paths
{
struct
//- rjf: merge into array for this unit
p2r2_shared->unit_file_paths[unit_idx] = str8_array_from_list(arena, &src_file_paths);
//- rjf: hash this unit's file paths
U64Array hashes = {0};
hashes.count = p2r2_shared->unit_file_paths[unit_idx].count;
hashes.v = push_array(arena, U64, hashes.count);
for EachIndex(idx, p2r2_shared->unit_file_paths[unit_idx].count)
{
String8Array paths;
U64Array *hashes_out;
}
tasks[] =
{
{p2r2_shared->lane_inline_file_paths[lane_idx()], &p2r2_shared->lane_inline_file_paths_hashes[lane_idx()]},
{p2r2_shared->lane_line_file_paths[lane_idx()], &p2r2_shared->lane_line_file_paths_hashes[lane_idx()]},
};
for EachElement(task_idx, tasks)
{
U64Array hashes = {0};
hashes.count = tasks[task_idx].paths.count;
hashes.v = push_array(arena, U64, hashes.count);
for EachIndex(idx, tasks[task_idx].paths.count)
{
hashes.v[idx] = rdi_hash(tasks[task_idx].paths.v[idx].str, tasks[task_idx].paths.v[idx].size);
}
tasks[task_idx].hashes_out[0] = hashes;
hashes.v[idx] = rdi_hash(p2r2_shared->unit_file_paths[unit_idx].v[idx].str, p2r2_shared->unit_file_paths[unit_idx].v[idx].size);
}
p2r2_shared->unit_file_paths_hashes[unit_idx] = hashes;
}
scratch_end(scratch);
}
}
lane_sync();
String8Array *lane_inline_file_paths = p2r2_shared->lane_inline_file_paths;
String8Array *lane_line_file_paths = p2r2_shared->lane_line_file_paths;
U64Array *lane_inline_file_paths_hashes = p2r2_shared->lane_inline_file_paths_hashes;
U64Array *lane_line_file_paths_hashes = p2r2_shared->lane_line_file_paths_hashes;
String8Array *unit_file_paths = p2r2_shared->unit_file_paths;
U64Array *unit_file_paths_hashes = p2r2_shared->unit_file_paths_hashes;
//////////////////////////////////////////////////////////////
//- rjf: build unified collection & map for source files
@@ -796,10 +706,9 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
ProfScope("set up table") if(lane_idx() == 0)
{
p2r2_shared->total_path_count = 0;
for EachIndex(idx, lane_count())
for EachIndex(idx, comp_units->count)
{
p2r2_shared->total_path_count += lane_line_file_paths[idx].count;
p2r2_shared->total_path_count += lane_inline_file_paths[idx].count;
p2r2_shared->total_path_count += unit_file_paths[idx].count;
}
p2r2_shared->src_file_map.slots_count = p2r2_shared->total_path_count + p2r2_shared->total_path_count/2 + 1;
p2r2_shared->src_file_map.slots = push_array(arena, P2R_SrcFileNode *, p2r2_shared->src_file_map.slots_count);
@@ -809,44 +718,31 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
//- rjf: fill table
ProfScope("fill table") if(lane_idx() == 0)
{
struct
for EachIndex(idx, comp_units->count)
{
String8Array *lane_paths;
U64Array *lane_hashes;
}
tasks[] =
{
{lane_inline_file_paths, lane_inline_file_paths_hashes},
{lane_line_file_paths, lane_line_file_paths_hashes},
};
for EachElement(task_idx, tasks)
{
for EachIndex(idx, lane_count())
String8Array paths = unit_file_paths[idx];
U64Array hashes = unit_file_paths_hashes[idx];
for EachIndex(path_idx, paths.count)
{
String8Array paths = tasks[task_idx].lane_paths[idx];
U64Array hashes = tasks[task_idx].lane_hashes[idx];
for EachIndex(path_idx, paths.count)
String8 file_path_sanitized = paths.v[path_idx];
U64 file_path_sanitized_hash = hashes.v[path_idx];
U64 src_file_slot = file_path_sanitized_hash%p2r2_shared->src_file_map.slots_count;
P2R_SrcFileNode *src_file_node = 0;
for(P2R_SrcFileNode *n = p2r2_shared->src_file_map.slots[src_file_slot]; n != 0; n = n->next)
{
String8 file_path_sanitized = paths.v[path_idx];
U64 file_path_sanitized_hash = hashes.v[path_idx];
U64 src_file_slot = file_path_sanitized_hash%p2r2_shared->src_file_map.slots_count;
P2R_SrcFileNode *src_file_node = 0;
for(P2R_SrcFileNode *n = p2r2_shared->src_file_map.slots[src_file_slot]; n != 0; n = n->next)
if(str8_match(n->src_file->path, file_path_sanitized, 0))
{
if(str8_match(n->src_file->path, file_path_sanitized, 0))
{
src_file_node = n;
break;
}
}
if(src_file_node == 0)
{
src_file_node = push_array(arena, P2R_SrcFileNode, 1);
SLLStackPush(p2r2_shared->src_file_map.slots[src_file_slot], src_file_node);
src_file_node->src_file = rdim_src_file_chunk_list_push(arena, &p2r2_shared->all_src_files__sequenceless, p2r2_shared->total_path_count);
src_file_node->src_file->path = push_str8_copy(arena, file_path_sanitized);
src_file_node = n;
break;
}
}
if(src_file_node == 0)
{
src_file_node = push_array(arena, P2R_SrcFileNode, 1);
SLLStackPush(p2r2_shared->src_file_map.slots[src_file_slot], src_file_node);
src_file_node->src_file = rdim_src_file_chunk_list_push(arena, &p2r2_shared->all_src_files__sequenceless, p2r2_shared->total_path_count);
src_file_node->src_file->path = push_str8_copy(arena, file_path_sanitized);
}
}
}
}
@@ -855,80 +751,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
RDIM_SrcFileChunkList all_src_files__sequenceless = p2r2_shared->all_src_files__sequenceless;
P2R_SrcFileMap src_file_map = p2r2_shared->src_file_map;
//////////////////////////////////////////////////////////////
//- rjf: for each lane, figure out info for starting a sub-unit range
//
ProfScope("for each lane, figure out info for starting a sub-unit range")
{
// rjf: set up
if(lane_idx() == 0)
{
p2r2_shared->lane_unit_sub_start_pt_infos = push_array(arena, P2R2_UnitSubStartPtInfo, lane_count());
}
lane_sync();
// rjf: fill
{
P2R2_UnitSubStartPtInfo *out_info = &p2r2_shared->lane_unit_sub_start_pt_infos[lane_idx()];
P2R2_SymBlock *first_block = lane_sym_blocks[lane_idx()].first;
if(first_block != 0 && first_block->sym_rec_range.min > 0)
{
CV_SymParsed *sym = first_block->sym;
CV_RecRange *rec_ranges_first = sym->sym_ranges.ranges;
CV_RecRange *rec_ranges_opl = sym->sym_ranges.ranges + first_block->sym_rec_range.min;
for(CV_RecRange *rec_range = rec_ranges_first;
rec_range < rec_ranges_opl;
rec_range += 1)
{
// rjf: rec range -> symbol info range
U64 sym_off_first = rec_range->off + 2;
U64 sym_off_opl = rec_range->off + rec_range->hdr.size;
// rjf: skip invalid ranges
if(sym_off_opl > sym->data.size || sym_off_first > sym->data.size || sym_off_first > sym_off_opl)
{
continue;
}
// rjf: unpack symbol info
CV_SymKind kind = rec_range->hdr.kind;
U64 sym_header_struct_size = cv_header_struct_size_from_sym_kind(kind);
void *sym_header_struct_base = sym->data.str + sym_off_first;
void *sym_data_opl = sym->data.str + sym_off_opl;
// rjf: skip bad sizes
if(sym_off_first + sym_header_struct_size > sym_off_opl)
{
continue;
}
// rjf: find range starters
switch(kind)
{
default:{}break;
case CV_SymKind_LPROC32:
case CV_SymKind_GPROC32:
{
CV_SymProc32 *proc32 = (CV_SymProc32 *)sym_header_struct_base;
COFF_SectionHeader *section = (0 < proc32->sec && proc32->sec <= coff_sections.count) ? &coff_sections.v[proc32->sec-1] : 0;
if(section != 0)
{
out_info->last_proc_voff = section->voff + proc32->off;
}
}break;
case CV_SymKind_FRAMEPROC:
{
CV_SymFrameproc *frameproc = (CV_SymFrameproc*)sym_header_struct_base;
out_info->last_frameproc = *frameproc;
}break;
}
}
}
}
}
lane_sync();
P2R2_UnitSubStartPtInfo *lane_unit_sub_start_pt_infos = p2r2_shared->lane_unit_sub_start_pt_infos;
//////////////////////////////////////////////////////////////
//- rjf: convert unit info
//
@@ -944,6 +766,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
p2r2_shared->lanes_main_line_tables = push_array(arena, RDIM_LineTableChunkList, lane_count());
p2r2_shared->lanes_inline_line_tables = push_array(arena, RDIM_LineTableChunkList, lane_count());
p2r2_shared->lanes_first_inline_site_line_tables = push_array(arena, RDIM_LineTable *, lane_count());
p2r2_shared->sym_lane_take_counter = 0;
}
lane_sync();
RDIM_Unit *units = p2r2_shared->all_units.first->v;
@@ -1066,14 +889,21 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
//- rjf: build per-inline-site line tables
ProfScope("build per-inline-site line tables")
{
for(P2R2_SymBlock *lane_block = lane_sym_blocks[lane_idx()].first;
lane_block != 0;
lane_block = lane_block->next)
for(;;)
{
//- rjf: take next unit
U64 unit_num = ins_atomic_u64_inc_eval(&p2r2_shared->sym_lane_take_counter);
if(unit_num > comp_units->count)
{
break;
}
U64 unit_idx = unit_num-1;
//- rjf: unpack unit
Temp scratch = scratch_begin(&arena, 1);
PDB_CompUnit *src_unit = lane_block->unit;
CV_SymParsed *src_unit_sym = lane_block->sym;
CV_C13Parsed *src_unit_c13 = lane_block->c13;
PDB_CompUnit *src_unit = comp_units->units[unit_idx];
CV_SymParsed *src_unit_sym = all_syms[unit_idx+1];
CV_C13Parsed *src_unit_c13 = all_c13s[unit_idx+1];
String8 obj_name = src_unit->obj_name;
if(str8_match(obj_name, str8_lit("* Linker *"), 0) ||
str8_match(obj_name, str8_lit("Import:"), StringMatchFlag_RightSideSloppy))
@@ -1081,9 +911,9 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
MemoryZeroStruct(&obj_name);
}
String8 obj_folder_path = backslashed_from_str8(scratch.arena, str8_chop_last_slash(obj_name));
CV_RecRange *rec_ranges_first = src_unit_sym->sym_ranges.ranges + lane_block->sym_rec_range.min;
CV_RecRange *rec_ranges_opl = src_unit_sym->sym_ranges.ranges + lane_block->sym_rec_range.max;
U64 base_voff = lane_unit_sub_start_pt_infos[lane_idx()].last_proc_voff;
CV_RecRange *rec_ranges_first = src_unit_sym->sym_ranges.ranges;
CV_RecRange *rec_ranges_opl = src_unit_sym->sym_ranges.ranges + src_unit_sym->sym_ranges.count;
U64 base_voff = 0;
for(CV_RecRange *rec_range = rec_ranges_first;
rec_range < rec_ranges_opl;
rec_range += 1)
@@ -3075,49 +2905,53 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
//
if(lane_idx() == 0)
{
p2r2_shared->lanes_locations = push_array(arena, RDIM_LocationChunkList, lane_count());
p2r2_shared->lanes_location_cases = push_array(arena, RDIM_LocationCaseChunkList, lane_count());
p2r2_shared->lanes_procedures = push_array(arena, RDIM_SymbolChunkList, lane_count());
p2r2_shared->lanes_global_variables = push_array(arena, RDIM_SymbolChunkList, lane_count());
p2r2_shared->lanes_thread_variables = push_array(arena, RDIM_SymbolChunkList, lane_count());
p2r2_shared->lanes_constants = push_array(arena, RDIM_SymbolChunkList, lane_count());
p2r2_shared->lanes_scopes = push_array(arena, RDIM_ScopeChunkList, lane_count());
p2r2_shared->lanes_inline_sites = push_array(arena, RDIM_InlineSiteChunkList, lane_count());
p2r2_shared->lanes_typedefs = push_array(arena, RDIM_TypeChunkList, lane_count());
p2r2_shared->syms_locations = push_array(arena, RDIM_LocationChunkList, all_syms_count);
p2r2_shared->syms_location_cases = push_array(arena, RDIM_LocationCaseChunkList, all_syms_count);
p2r2_shared->syms_procedures = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
p2r2_shared->syms_global_variables = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
p2r2_shared->syms_thread_variables = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
p2r2_shared->syms_constants = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
p2r2_shared->syms_scopes = push_array(arena, RDIM_ScopeChunkList, all_syms_count);
p2r2_shared->syms_inline_sites = push_array(arena, RDIM_InlineSiteChunkList, all_syms_count);
p2r2_shared->syms_typedefs = push_array(arena, RDIM_TypeChunkList, all_syms_count);
p2r2_shared->sym_lane_take_counter = 0;
}
lane_sync();
////////////////////////////
//- rjf: set up outputs for this sym stream
//
U64 sym_locations_chunk_cap = 16384;
U64 sym_location_cases_chunk_cap = 16384;
U64 sym_procedures_chunk_cap = 16384;
U64 sym_global_variables_chunk_cap = 16384;
U64 sym_thread_variables_chunk_cap = 16384;
U64 sym_constants_chunk_cap = 16384;
U64 sym_scopes_chunk_cap = 16384;
U64 sym_inline_sites_chunk_cap = 16384;
RDIM_LocationChunkList sym_locations = {0};
RDIM_LocationCaseChunkList sym_location_cases = {0};
RDIM_SymbolChunkList sym_procedures = {0};
RDIM_SymbolChunkList sym_global_variables = {0};
RDIM_SymbolChunkList sym_thread_variables = {0};
RDIM_SymbolChunkList sym_constants = {0};
RDIM_ScopeChunkList sym_scopes = {0};
RDIM_InlineSiteChunkList sym_inline_sites = {0};
RDIM_TypeChunkList typedefs = {0};
////////////////////////////
//- rjf: fill outputs for all unit sym blocks in this lane
//
for(P2R2_SymBlock *lane_block = lane_sym_blocks[lane_idx()].first;
lane_block != 0;
lane_block = lane_block->next)
for(;;)
{
//- rjf: take next sym
U64 sym_num = ins_atomic_u64_inc_eval(&p2r2_shared->sym_lane_take_counter);
if(sym_num > all_syms_count)
{
break;
}
U64 sym_idx = sym_num-1;
//- rjf: unpack sym
Temp scratch = scratch_begin(&arena, 1);
CV_SymParsed *sym = lane_block->sym;
Rng1U64 sym_rec_range = lane_block->sym_rec_range;
CV_SymParsed *sym = all_syms[sym_idx];
Rng1U64 sym_rec_range = r1u64(0, sym->sym_ranges.count);
U64 sym_locations_chunk_cap = 16384;
U64 sym_location_cases_chunk_cap = 16384;
U64 sym_procedures_chunk_cap = 16384;
U64 sym_global_variables_chunk_cap = 16384;
U64 sym_thread_variables_chunk_cap = 16384;
U64 sym_constants_chunk_cap = 16384;
U64 sym_scopes_chunk_cap = 16384;
U64 sym_inline_sites_chunk_cap = 16384;
RDIM_LocationChunkList *sym_locations = &p2r2_shared->syms_locations[sym_idx];
RDIM_LocationCaseChunkList *sym_location_cases = &p2r2_shared->syms_location_cases[sym_idx];
RDIM_SymbolChunkList *sym_procedures = &p2r2_shared->syms_procedures[sym_idx];
RDIM_SymbolChunkList *sym_global_variables = &p2r2_shared->syms_global_variables[sym_idx];
RDIM_SymbolChunkList *sym_thread_variables = &p2r2_shared->syms_thread_variables[sym_idx];
RDIM_SymbolChunkList *sym_constants = &p2r2_shared->syms_constants[sym_idx];
RDIM_ScopeChunkList *sym_scopes = &p2r2_shared->syms_scopes[sym_idx];
RDIM_InlineSiteChunkList *sym_inline_sites = &p2r2_shared->syms_inline_sites[sym_idx];
RDIM_TypeChunkList *typedefs = &p2r2_shared->syms_typedefs[sym_idx];
//////////////////////////
//- rjf: symbols pass 1: produce procedure frame info map (procedure -> frame info)
@@ -3253,7 +3087,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
CV_SymBlock32 *block32 = (CV_SymBlock32 *)sym_header_struct_base;
// rjf: build scope, insert into current parent scope
RDIM_Scope *scope = rdim_scope_chunk_list_push(arena, &sym_scopes, sym_scopes_chunk_cap);
RDIM_Scope *scope = rdim_scope_chunk_list_push(arena, sym_scopes, sym_scopes_chunk_cap);
{
if(top_scope_node == 0)
{
@@ -3272,7 +3106,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
U64 voff_first = section->voff + block32->off;
U64 voff_last = voff_first + block32->len;
RDIM_Rng1U64 voff_range = {voff_first, voff_last};
rdim_scope_push_voff_range(arena, &sym_scopes, scope, voff_range);
rdim_scope_push_voff_range(arena, sym_scopes, scope, voff_range);
}
}
@@ -3331,7 +3165,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
}
// rjf: build symbol
RDIM_Symbol *symbol = rdim_symbol_chunk_list_push(arena, &sym_global_variables, sym_global_variables_chunk_cap);
RDIM_Symbol *symbol = rdim_symbol_chunk_list_push(arena, sym_global_variables, sym_global_variables_chunk_cap);
symbol->is_extern = (kind == CV_SymKind_GDATA32);
symbol->name = name;
symbol->type = type;
@@ -3347,7 +3181,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
{
CV_SymUDT *udt = (CV_SymUDT *)sym_header_struct_base;
String8 name = str8_cstring_capped(udt+1, sym_data_opl);
RDIM_Type *type = rdim_type_chunk_list_push(arena, &typedefs, 4096);
RDIM_Type *type = rdim_type_chunk_list_push(arena, typedefs, 4096);
type->kind = RDI_TypeKind_Alias;
type->name = name;
type->direct_type = p2r_type_ptr_from_itype(udt->itype);
@@ -3390,7 +3224,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
// it here because these scopes refer to the ranges of code that make up a
// procedure *not* the namespaces, so a procedure's root scope always has
// no parent.
RDIM_Scope *procedure_root_scope = rdim_scope_chunk_list_push(arena, &sym_scopes, sym_scopes_chunk_cap);
RDIM_Scope *procedure_root_scope = rdim_scope_chunk_list_push(arena, sym_scopes, sym_scopes_chunk_cap);
{
COFF_SectionHeader *section = (0 < proc32->sec && proc32->sec <= coff_sections.count) ? &coff_sections.v[proc32->sec-1] : 0;
if(section != 0)
@@ -3398,7 +3232,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
U64 voff_first = section->voff + proc32->off;
U64 voff_last = voff_first + proc32->len;
RDIM_Rng1U64 voff_range = {voff_first, voff_last};
rdim_scope_push_voff_range(arena, &sym_scopes, procedure_root_scope, voff_range);
rdim_scope_push_voff_range(arena, sym_scopes, procedure_root_scope, voff_range);
procedure_base_voff = voff_first;
}
}
@@ -3422,7 +3256,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
}
// rjf: build procedure symbol
RDIM_Symbol *procedure_symbol = rdim_symbol_chunk_list_push(arena, &sym_procedures, sym_procedures_chunk_cap);
RDIM_Symbol *procedure_symbol = rdim_symbol_chunk_list_push(arena, sym_procedures, sym_procedures_chunk_cap);
procedure_symbol->is_extern = (kind == CV_SymKind_GPROC32);
procedure_symbol->name = name;
procedure_symbol->link_name = link_name;
@@ -3507,7 +3341,11 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
// rjf: build local
RDIM_Scope *scope = top_scope_node->scope;
RDIM_Local *local = rdim_scope_push_local(arena, &sym_scopes, scope);
RDIM_Local *local = rdim_scope_push_local(arena, sym_scopes, scope);
if(str8_match(name, str8_lit("example_color_struct"), 0))
{
int x = 0;
}
local->kind = local_kind;
local->name = name;
local->type = type;
@@ -3537,8 +3375,8 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
// rjf: build location
RDIM_LocationInfo loc_info = p2r2_location_info_from_addr_reg_off(arena, arch, reg_code, byte_size, byte_pos, (S64)(S32)var_off, extra_indirection_to_value);
RDIM_Location2 *loc2 = rdim_location_chunk_list_push_new(arena, &sym_locations, sym_locations_chunk_cap, &loc_info);
RDIM_LocationCase2 *loc_case = rdim_location_case_chunk_list_push(arena, &sym_location_cases, sym_locations_chunk_cap);
RDIM_Location2 *loc2 = rdim_location_chunk_list_push_new(arena, sym_locations, sym_locations_chunk_cap, &loc_info);
RDIM_LocationCase2 *loc_case = rdim_location_case_chunk_list_push(arena, sym_location_cases, sym_locations_chunk_cap);
loc_case->location = loc2;
loc_case->voff_range.min = 0;
loc_case->voff_range.max = max_U64;
@@ -3550,7 +3388,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
// rjf: set location case
RDIM_Location *loc = p2r_location_from_addr_reg_off(arena, arch, reg_code, byte_size, byte_pos, (S64)(S32)var_off, extra_indirection_to_value);
RDIM_Rng1U64 voff_range = {0, max_U64};
rdim_location_set_push_case(arena, &sym_scopes, &local->locset, voff_range, loc);
rdim_location_set_push_case(arena, sym_scopes, &local->locset, voff_range, loc);
}
}break;
@@ -3582,7 +3420,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
}
// rjf: build symbol
RDIM_Symbol *tvar = rdim_symbol_chunk_list_push(arena, &sym_thread_variables, sym_thread_variables_chunk_cap);
RDIM_Symbol *tvar = rdim_symbol_chunk_list_push(arena, sym_thread_variables, sym_thread_variables_chunk_cap);
tvar->name = name;
tvar->type = type;
tvar->is_extern = (kind == CV_SymKind_GTHREAD32);
@@ -3634,7 +3472,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
// rjf: build local
RDIM_Scope *scope = top_scope_node->scope;
RDIM_Local *local = rdim_scope_push_local(arena, &sym_scopes, scope);
RDIM_Local *local = rdim_scope_push_local(arena, sym_scopes, scope);
local->kind = local_kind;
local->name = name;
local->type = type;
@@ -3668,7 +3506,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
RDIM_Location *location = rdim_push_location_val_reg(arena, reg_code);
// rjf: emit locations over ranges
p2r_location_over_lvar_addr_range(arena, &sym_scopes, defrange_target, location, range, range_section, gaps, gap_count);
p2r_location_over_lvar_addr_range(arena, sym_scopes, defrange_target, location, range, range_section, gaps, gap_count);
}break;
//- rjf: DEFRANGE_FRAMEPOINTER_REL
@@ -3712,7 +3550,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
U32 byte_pos = 0;
S64 var_off = (S64)defrange_fprel->off;
RDIM_LocationInfo location_info = p2r2_location_info_from_addr_reg_off(arena, arch, fp_register_code, byte_size, byte_pos, var_off, extra_indirection);
RDIM_Location2 *location = rdim_location_chunk_list_push_new(arena, &sym_locations, sym_locations_chunk_cap, &location_info);
RDIM_Location2 *location = rdim_location_chunk_list_push_new(arena, sym_locations, sym_locations_chunk_cap, &location_info);
// rjf: emit locations over ranges
// TODO(rjf): p2r_location_over_lvar_addr_range(arena, &sym_scopes, defrange_target, location, range, range_section, gaps, gap_count);
@@ -3747,7 +3585,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
RDIM_Location *location = rdim_push_location_val_reg(arena, reg_code);
// rjf: emit locations over ranges
p2r_location_over_lvar_addr_range(arena, &sym_scopes, defrange_target, location, range, range_section, gaps, gap_count);
p2r_location_over_lvar_addr_range(arena, sym_scopes, defrange_target, location, range, range_section, gaps, gap_count);
}break;
//- rjf: DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE
@@ -3788,7 +3626,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
// rjf: emit location over ranges
RDIM_Rng1U64 voff_range = {0, max_U64};
rdim_location_set_push_case(arena, &sym_scopes, defrange_target, voff_range, location);
rdim_location_set_push_case(arena, sym_scopes, defrange_target, voff_range, location);
}break;
//- rjf: DEFRANGE_REGISTER_REL
@@ -3819,7 +3657,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
RDIM_Location *location = p2r_location_from_addr_reg_off(arena, arch, reg_code, byte_size, byte_pos, var_off, extra_indirection_to_value);
// rjf: emit locations over ranges
p2r_location_over_lvar_addr_range(arena, &sym_scopes, defrange_target, location, range, range_section, gaps, gap_count);
p2r_location_over_lvar_addr_range(arena, sym_scopes, defrange_target, location, range, range_section, gaps, gap_count);
}break;
//- rjf: FILESTATIC
@@ -3872,7 +3710,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
}
// rjf: build inline site
RDIM_InlineSite *inline_site = rdim_inline_site_chunk_list_push(arena, &sym_inline_sites, sym_inline_sites_chunk_cap);
RDIM_InlineSite *inline_site = rdim_inline_site_chunk_list_push(arena, sym_inline_sites, sym_inline_sites_chunk_cap);
inline_site->name = name;
inline_site->type = type;
inline_site->owner = owner;
@@ -3899,7 +3737,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
}
// rjf: build scope
RDIM_Scope *scope = rdim_scope_chunk_list_push(arena, &sym_scopes, sym_scopes_chunk_cap);
RDIM_Scope *scope = rdim_scope_chunk_list_push(arena, sym_scopes, sym_scopes_chunk_cap);
scope->inline_site = inline_site;
if(top_scope_node == 0)
{
@@ -3933,7 +3771,7 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
{
// rjf: build new range & add to scope
RDIM_Rng1U64 voff_range = { step.range.min, step.range.max };
rdim_scope_push_voff_range(arena, &sym_scopes, scope, voff_range);
rdim_scope_push_voff_range(arena, sym_scopes, scope, voff_range);
}
if(step.flags & CV_C13InlineSiteDecoderStepFlag_ExtendLastRange)
@@ -3991,10 +3829,10 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
// rjf: build constant symbol
if(name_qualified.size != 0)
{
RDIM_Symbol *cnst = rdim_symbol_chunk_list_push(arena, &sym_constants, sym_constants_chunk_cap);
RDIM_Symbol *cnst = rdim_symbol_chunk_list_push(arena, sym_constants, sym_constants_chunk_cap);
cnst->name = name_qualified;
cnst->type = type;
rdim_symbol_push_value_data(arena, &sym_constants, cnst, val_data);
rdim_symbol_push_value_data(arena, sym_constants, cnst, val_data);
}
}break;
}
@@ -4003,20 +3841,6 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
scratch_end(scratch);
}
////////////////////////////
//- rjf: output this lane's symbols
//
p2r2_shared->lanes_locations[lane_idx()] = sym_locations;
p2r2_shared->lanes_location_cases[lane_idx()] = sym_location_cases;
p2r2_shared->lanes_procedures[lane_idx()] = sym_procedures;
p2r2_shared->lanes_global_variables[lane_idx()] = sym_global_variables;
p2r2_shared->lanes_thread_variables[lane_idx()] = sym_thread_variables;
p2r2_shared->lanes_constants[lane_idx()] = sym_constants;
p2r2_shared->lanes_scopes[lane_idx()] = sym_scopes;
p2r2_shared->lanes_inline_sites[lane_idx()] = sym_inline_sites;
p2r2_shared->lanes_typedefs[lane_idx()] = typedefs;
#undef p2r_type_ptr_from_itype
}
lane_sync();
@@ -4027,65 +3851,65 @@ p2r2_convert(Arena *arena, P2R_ConvertParams *params)
{
if(lane_idx() == lane_from_task_idx(0)) ProfScope("join locations")
{
for EachIndex(idx, lane_count())
for EachIndex(idx, all_syms_count)
{
rdim_location_chunk_list_concat_in_place(&p2r2_shared->all_locations, &p2r2_shared->lanes_locations[idx]);
rdim_location_chunk_list_concat_in_place(&p2r2_shared->all_locations, &p2r2_shared->syms_locations[idx]);
}
}
if(lane_idx() == lane_from_task_idx(1)) ProfScope("join location cases")
{
for EachIndex(idx, lane_count())
for EachIndex(idx, all_syms_count)
{
rdim_location_case_chunk_list_concat_in_place(&p2r2_shared->all_location_cases, &p2r2_shared->lanes_location_cases[idx]);
rdim_location_case_chunk_list_concat_in_place(&p2r2_shared->all_location_cases, &p2r2_shared->syms_location_cases[idx]);
}
}
if(lane_idx() == lane_from_task_idx(2)) ProfScope("join procedures")
{
for EachIndex(idx, lane_count())
for EachIndex(idx, all_syms_count)
{
rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_procedures, &p2r2_shared->lanes_procedures[idx]);
rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_procedures, &p2r2_shared->syms_procedures[idx]);
}
}
if(lane_idx() == lane_from_task_idx(3)) ProfScope("join global variables")
{
for EachIndex(idx, lane_count())
for EachIndex(idx, all_syms_count)
{
rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_global_variables, &p2r2_shared->lanes_global_variables[idx]);
rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_global_variables, &p2r2_shared->syms_global_variables[idx]);
}
}
if(lane_idx() == lane_from_task_idx(4)) ProfScope("join thread variables")
{
for EachIndex(idx, lane_count())
for EachIndex(idx, all_syms_count)
{
rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_thread_variables, &p2r2_shared->lanes_thread_variables[idx]);
rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_thread_variables, &p2r2_shared->syms_thread_variables[idx]);
}
}
if(lane_idx() == lane_from_task_idx(5)) ProfScope("join constants")
{
for EachIndex(idx, lane_count())
for EachIndex(idx, all_syms_count)
{
rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_constants, &p2r2_shared->lanes_constants[idx]);
rdim_symbol_chunk_list_concat_in_place(&p2r2_shared->all_constants, &p2r2_shared->syms_constants[idx]);
}
}
if(lane_idx() == lane_from_task_idx(6)) ProfScope("join scopes")
{
for EachIndex(idx, lane_count())
for EachIndex(idx, all_syms_count)
{
rdim_scope_chunk_list_concat_in_place(&p2r2_shared->all_scopes, &p2r2_shared->lanes_scopes[idx]);
rdim_scope_chunk_list_concat_in_place(&p2r2_shared->all_scopes, &p2r2_shared->syms_scopes[idx]);
}
}
if(lane_idx() == lane_from_task_idx(7)) ProfScope("join inline sites")
{
for EachIndex(idx, lane_count())
for EachIndex(idx, all_syms_count)
{
rdim_inline_site_chunk_list_concat_in_place(&p2r2_shared->all_inline_sites, &p2r2_shared->lanes_inline_sites[idx]);
rdim_inline_site_chunk_list_concat_in_place(&p2r2_shared->all_inline_sites, &p2r2_shared->syms_inline_sites[idx]);
}
}
if(lane_idx() == lane_from_task_idx(8)) ProfScope("join typedefs")
{
for EachIndex(idx, lane_count())
for EachIndex(idx, all_syms_count)
{
rdim_type_chunk_list_concat_in_place(&p2r2_shared->all_types__pre_typedefs, &p2r2_shared->lanes_typedefs[idx]);
rdim_type_chunk_list_concat_in_place(&p2r2_shared->all_types__pre_typedefs, &p2r2_shared->syms_typedefs[idx]);
}
p2r2_shared->all_types = p2r2_shared->all_types__pre_typedefs;
}
src/rdi_from_pdb/rdi_from_pdb_2.h
+12 -41
View File
@@ -17,30 +17,6 @@ struct P2R2_ConvertThreadParams
RDIM_BakeParams *out_bake_params;
};
typedef struct P2R2_SymBlock P2R2_SymBlock;
struct P2R2_SymBlock
{
P2R2_SymBlock *next;
PDB_CompUnit *unit;
CV_SymParsed *sym;
CV_C13Parsed *c13;
Rng1U64 sym_rec_range;
};
typedef struct P2R2_SymBlockList P2R2_SymBlockList;
struct P2R2_SymBlockList
{
P2R2_SymBlock *first;
P2R2_SymBlock *last;
};
typedef struct P2R2_UnitSubStartPtInfo P2R2_UnitSubStartPtInfo;
struct P2R2_UnitSubStartPtInfo
{
CV_SymFrameproc last_frameproc;
U64 last_proc_voff;
};
typedef struct P2R2_Shared P2R2_Shared;
struct P2R2_Shared
{
@@ -81,15 +57,10 @@ struct P2R2_Shared
P2R_LinkNameMap link_name_map;
U64 total_sym_record_count;
P2R2_SymBlockList *lane_sym_blocks;
U64 sym_lane_take_counter;
P2R2_UnitSubStartPtInfo *lane_unit_sub_start_pt_infos;
String8Array *lane_inline_file_paths;
String8Array *lane_line_file_paths;
U64Array *lane_inline_file_paths_hashes;
U64Array *lane_line_file_paths_hashes;
String8Array *unit_file_paths;
U64Array *unit_file_paths_hashes;
U64 total_path_count;
@@ -121,15 +92,15 @@ struct P2R2_Shared
RDIM_UDTMemberChunkList all_members;
RDIM_UDTEnumValChunkList all_enum_vals;
RDIM_LocationChunkList *lanes_locations;
RDIM_LocationCaseChunkList *lanes_location_cases;
RDIM_SymbolChunkList *lanes_procedures;
RDIM_SymbolChunkList *lanes_global_variables;
RDIM_SymbolChunkList *lanes_thread_variables;
RDIM_SymbolChunkList *lanes_constants;
RDIM_ScopeChunkList *lanes_scopes;
RDIM_InlineSiteChunkList *lanes_inline_sites;
RDIM_TypeChunkList *lanes_typedefs;
RDIM_LocationChunkList *syms_locations;
RDIM_LocationCaseChunkList *syms_location_cases;
RDIM_SymbolChunkList *syms_procedures;
RDIM_SymbolChunkList *syms_global_variables;
RDIM_SymbolChunkList *syms_thread_variables;
RDIM_SymbolChunkList *syms_constants;
RDIM_ScopeChunkList *syms_scopes;
RDIM_InlineSiteChunkList *syms_inline_sites;
RDIM_TypeChunkList *syms_typedefs;
RDIM_LocationChunkList all_locations;
RDIM_LocationCaseChunkList all_location_cases;
src/rdi_make/rdi_make_local_2.c
+79 -31
View File
@@ -691,6 +691,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
params->thread_variables.total_count*1 +
params->types.total_count/2);
rdim2_shared->lane_bake_string_maps__loose = push_array(arena, RDIM_BakeStringMapLoose *, lane_count());
rdim2_shared->bake_string_map__loose = rdim_bake_string_map_loose_make(arena, &rdim2_shared->bake_string_map_topology);
}
lane_sync();
@@ -838,50 +839,60 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
}
}
}
//- rjf: join & sort
if(lane_idx() == 0)
{
rdim2_shared->bake_string_map__loose = rdim_bake_string_map_loose_make(arena, &rdim2_shared->bake_string_map_topology);
}
lane_sync();
ProfScope("join & sort")
//- rjf: join
ProfScope("join")
{
//- rjf: join
ProfScope("join")
Rng1U64 slot_range = lane_range(rdim2_shared->bake_string_map_topology.slots_count);
for EachInRange(slot_idx, slot_range)
{
Rng1U64 slot_range = lane_range(rdim2_shared->bake_string_map_topology.slots_count);
for EachInRange(slot_idx, slot_range)
for EachIndex(src_lane_idx, lane_count())
{
for EachIndex(src_lane_idx, lane_count())
RDIM_BakeStringMapLoose *src_map = rdim2_shared->lane_bake_string_maps__loose[src_lane_idx];
RDIM_BakeStringMapLoose *dst_map = rdim2_shared->bake_string_map__loose;
if(dst_map->slots[slot_idx] == 0 && src_map->slots[slot_idx] != 0)
{
RDIM_BakeStringMapLoose *src_map = rdim2_shared->lane_bake_string_maps__loose[src_lane_idx];
RDIM_BakeStringMapLoose *dst_map = rdim2_shared->bake_string_map__loose;
if(dst_map->slots[slot_idx] == 0 && src_map->slots[slot_idx] != 0)
{
dst_map->slots[slot_idx] = src_map->slots[slot_idx];
}
else if(dst_map->slots[slot_idx] != 0 && src_map->slots[slot_idx] != 0)
{
rdim_bake_string_chunk_list_concat_in_place(dst_map->slots[slot_idx], src_map->slots[slot_idx]);
}
dst_map->slots[slot_idx] = src_map->slots[slot_idx];
}
else if(dst_map->slots[slot_idx] != 0 && src_map->slots[slot_idx] != 0)
{
rdim_bake_string_chunk_list_concat_in_place(dst_map->slots[slot_idx], src_map->slots[slot_idx]);
}
}
}
//- rjf: sort
ProfScope("sort")
}
lane_sync();
// TODO(rjf): debugging:
if(lane_idx() == 0)
{
for EachIndex(slot_idx, rdim2_shared->bake_string_map_topology.slots_count)
{
RDIM_BakeStringMapLoose *map = rdim2_shared->bake_string_map__loose;
Rng1U64 slot_range = lane_range(rdim2_shared->bake_string_map_topology.slots_count);
for EachInRange(slot_idx, slot_range)
if(rdim2_shared->bake_string_map__loose->slots[slot_idx] == 0) { continue; }
for EachNode(n, RDIM_BakeStringChunkNode, rdim2_shared->bake_string_map__loose->slots[slot_idx]->first)
{
if(map->slots[slot_idx] != 0 && map->slots[slot_idx]->total_count > 1)
for EachIndex(n_idx, n->count)
{
*map->slots[slot_idx] = rdim_bake_string_chunk_list_sorted_from_unsorted(arena, map->slots[slot_idx]);
// printf("%.*s\n", str8_varg(n->v[n_idx].string));
}
}
}
fflush(stdout);
}
//- rjf: sort
ProfScope("sort")
{
RDIM_BakeStringMapLoose *map = rdim2_shared->bake_string_map__loose;
Rng1U64 slot_range = lane_range(rdim2_shared->bake_string_map_topology.slots_count);
for EachInRange(slot_idx, slot_range)
{
if(map->slots[slot_idx] != 0 && map->slots[slot_idx]->total_count > 1)
{
*map->slots[slot_idx] = rdim_bake_string_chunk_list_sorted_from_unsorted(arena, map->slots[slot_idx]);
}
}
}
lane_sync();
@@ -914,6 +925,22 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
}
lane_sync();
RDIM_BakeStringMapTight *bake_strings = &rdim2_shared->bake_strings;
// TODO(rjf): debugging:
if(lane_idx() == 0)
{
for EachIndex(slot_idx, bake_strings->slots_count)
{
for EachNode(n, RDIM_BakeStringChunkNode, bake_strings->slots[slot_idx].first)
{
for EachIndex(n_idx, n->count)
{
// printf("%.*s\n", str8_varg(n->v[n_idx].string));
}
}
}
fflush(stdout);
}
//////////////////////////////////////////////////////////////
//- rjf: @rdim_bake_stage build name maps
@@ -1331,6 +1358,16 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
}
lane_sync();
RDIM_StringBakeResult baked_strings = rdim2_shared->baked_strings;
// TODO(rjf): debugging:
if(lane_idx() == 0)
{
for EachIndex(string_idx, baked_strings.string_offs_count)
{
String8 string = str8(baked_strings.string_data + baked_strings.string_offs[string_idx], baked_strings.string_offs[string_idx+1]-baked_strings.string_offs[string_idx]);
// printf("%.*s\n", str8_varg(string));
}
fflush(stdout);
}
//////////////////////////////////////////////////////////////
//- rjf: @rdim_bake_stage bake idx runs
@@ -1368,7 +1405,7 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
{
for EachIndex(idx, rdim2_shared->baked_idx_runs.idx_count)
{
printf("%u\n", rdim2_shared->baked_idx_runs.idx_runs[idx]);
// printf("%u\n", rdim2_shared->baked_idx_runs.idx_runs[idx]);
}
fflush(stdout);
}
@@ -2089,6 +2126,17 @@ rdim2_bake(Arena *arena, RDIM_BakeParams *params)
//- rjf: bake global variables
ProfScope("bake global variables")
{
if(lane_idx() == 0)
{
for EachNode(n, RDIM_SymbolChunkNode, params->global_variables.first)
{
for EachIndex(n_idx, n->count)
{
// printf("%.*s\n", str8_varg(n->v[n_idx].name));
}
}
fflush(stdout);
}
for EachNode(n, RDIM_SymbolChunkNode, params->global_variables.first)
{
Rng1U64 range = lane_range(n->count);