// Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) // TODO(rjf): eliminate redundant null checks, just always allocate // empty results, and have nulls gracefully fall through // // (search for != 0 instances, inserted to prevent prior crashes) global RDIM_LocalState *g_p2r_local_state = 0; //////////////////////////////// //~ rjf: Basic Helpers internal U64 p2r_end_of_cplusplus_container_name(String8 str) { // NOTE: This finds the index one past the last "::" contained in str. // if no "::" is contained in str, then the returned index is 0. // The intent is that [0,clamp_bot(0,result - 2)) gives the // "container name" and [result,str.size) gives the leaf name. U64 result = 0; if(str.size >= 2) { for(U64 i = str.size; i >= 2; i -= 1) { if(str.str[i - 2] == ':' && str.str[i - 1] == ':') { result = i; break; } } } return(result); } internal U64 p2r_hash_from_voff(U64 voff) { U64 hash = (voff >> 3) ^ ((7 & voff) << 6); return hash; } //////////////////////////////// //~ rjf: Location Info Building Helpers internal RDIM_Location * p2r_location_from_addr_reg_off(Arena *arena, RDI_Arch arch, RDI_RegCode reg_code, U32 reg_byte_size, U32 reg_byte_pos, S64 offset, B32 extra_indirection) { RDIM_Location *result = 0; if(0 <= offset && offset <= (S64)max_U16) { if(extra_indirection) { result = rdim_push_location_addr_addr_reg_plus_u16(arena, reg_code, (U16)offset); } else { result = rdim_push_location_addr_reg_plus_u16(arena, reg_code, (U16)offset); } } else { RDIM_EvalBytecode bytecode = {0}; U32 regread_param = RDI_EncodeRegReadParam(reg_code, reg_byte_size, reg_byte_pos); rdim_bytecode_push_op(arena, &bytecode, RDI_EvalOp_RegRead, regread_param); rdim_bytecode_push_sconst(arena, &bytecode, offset); rdim_bytecode_push_op(arena, &bytecode, RDI_EvalOp_Add, 0); if(extra_indirection) { U64 addr_size = rdi_addr_size_from_arch(arch); rdim_bytecode_push_op(arena, &bytecode, RDI_EvalOp_MemRead, addr_size); } result = rdim_push_location_addr_bytecode_stream(arena, &bytecode); } return result; } internal void p2r_location_over_lvar_addr_range(Arena *arena, RDIM_ScopeChunkList *scopes, RDIM_LocationSet *locset, RDIM_Location *location, CV_LvarAddrRange *range, COFF_SectionHeader *section, CV_LvarAddrGap *gaps, U64 gap_count) { //- rjf: extract range info U64 voff_first = 0; U64 voff_opl = 0; if(section != 0) { voff_first = section->voff + range->off; voff_opl = voff_first + range->len; } //- rjf: emit ranges CV_LvarAddrGap *gap_ptr = gaps; U64 voff_cursor = voff_first; for(U64 i = 0; i < gap_count; i += 1, gap_ptr += 1) { 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) { RDIM_Rng1U64 voff_range = {voff_cursor, voff_gap_first}; rdim_location_set_push_case(arena, scopes, locset, voff_range, location); } voff_cursor = voff_gap_opl; } //- rjf: emit remaining range if(voff_cursor < voff_opl) { RDIM_Rng1U64 voff_range = {voff_cursor, voff_opl}; rdim_location_set_push_case(arena, scopes, locset, voff_range, location); } } //////////////////////////////// //~ rjf: Initial Parsing & Preparation Pass Tasks ASYNC_WORK_DEF(p2r_exe_hash_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; P2R_EXEHashIn *in = (P2R_EXEHashIn *)input; U64 *out = push_array(arena, U64, 1); ProfScope("hash exe") *out = rdi_hash(in->exe_data.str, in->exe_data.size); ProfEnd(); return out; } ASYNC_WORK_DEF(p2r_tpi_hash_parse_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; P2R_TPIHashParseIn *in = (P2R_TPIHashParseIn *)input; void *out = 0; ProfScope("parse tpi hash") out = pdb_tpi_hash_from_data(arena, in->strtbl, in->tpi, in->hash_data, in->aux_data); ProfEnd(); return out; } ASYNC_WORK_DEF(p2r_tpi_leaf_parse_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; P2R_TPILeafParseIn *in = (P2R_TPILeafParseIn *)input; void *out = 0; ProfScope("parse tpi leaf") out = cv_leaf_from_data(arena, in->leaf_data, in->itype_first); ProfEnd(); return out; } ASYNC_WORK_DEF(p2r_symbol_stream_parse_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; P2R_SymbolStreamParseIn *in = (P2R_SymbolStreamParseIn *)input; void *out = 0; ProfScope("parse symbol stream") out = cv_sym_from_data(arena, in->data, 4); ProfEnd(); return out; } ASYNC_WORK_DEF(p2r_c13_stream_parse_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; P2R_C13StreamParseIn *in = (P2R_C13StreamParseIn *)input; void *out = 0; ProfScope("parse c13 stream") out = cv_c13_parsed_from_data(arena, in->data, in->strtbl, in->coff_sections); ProfEnd(); return out; } ASYNC_WORK_DEF(p2r_comp_unit_parse_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; P2R_CompUnitParseIn *in = (P2R_CompUnitParseIn *)input; void *out = 0; ProfScope("parse comp units") out = pdb_comp_unit_array_from_data(arena, in->data); ProfEnd(); return out; } ASYNC_WORK_DEF(p2r_comp_unit_contributions_parse_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; P2R_CompUnitContributionsParseIn *in = (P2R_CompUnitContributionsParseIn *)input; void *out = 0; ProfScope("parse comp unit contributions") out = pdb_comp_unit_contribution_array_from_data(arena, in->data, in->coff_sections); ProfEnd(); return out; } //////////////////////////////// //~ rjf: Unit Conversion Tasks ASYNC_WORK_DEF(p2r_units_convert_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; Temp scratch = scratch_begin(&arena, 1); P2R_UnitConvertIn *in = (P2R_UnitConvertIn *)input; P2R_UnitConvertOut *out = push_array(arena, P2R_UnitConvertOut, 1); ProfScope("build units, initial src file map, & collect unit source files") if(in->comp_units != 0) { U64 units_chunk_cap = in->comp_units->count; P2R_SrcFileMap src_file_map = {0}; src_file_map.slots_count = 65536; src_file_map.slots = push_array(scratch.arena, P2R_SrcFileNode *, src_file_map.slots_count); //////////////////////////// //- rjf: pass 1: build per-unit info & per-unit line tables // ProfScope("pass 1: build per-unit info & per-unit line tables") for(U64 comp_unit_idx = 0; comp_unit_idx < in->comp_units->count; comp_unit_idx += 1) { PDB_CompUnit *pdb_unit = in->comp_units->units[comp_unit_idx]; CV_SymParsed *pdb_unit_sym = in->comp_unit_syms[comp_unit_idx]; CV_C13Parsed *pdb_unit_c13 = in->comp_unit_c13s[comp_unit_idx]; //- rjf: produce unit name String8 unit_name = pdb_unit->obj_name; if(unit_name.size != 0) { String8 unit_name_past_last_slash = str8_skip_last_slash(unit_name); if(unit_name_past_last_slash.size != 0) { unit_name = unit_name_past_last_slash; } } //- rjf: produce obj name String8 obj_name = pdb_unit->obj_name; if(str8_match(obj_name, str8_lit("* Linker *"), 0) || str8_match(obj_name, str8_lit("Import:"), StringMatchFlag_RightSideSloppy)) { MemoryZeroStruct(&obj_name); } //- rjf: build this unit's line table, fill out primary line info (inline info added after) RDIM_LineTable *line_table = 0; for(CV_C13SubSectionNode *node = pdb_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) { CV_C13LinesParsed *lines = &lines_n->v; // rjf: file name -> normalized file path String8 file_path = lines->file_name; String8 file_path_normalized = lower_from_str8(scratch.arena, str8_skip_chop_whitespace(file_path)); for(U64 idx = 0; idx < file_path_normalized.size; idx += 1) { if(file_path_normalized.str[idx] == '\\') { file_path_normalized.str[idx] = '/'; } } // rjf: normalized file path -> source file node U64 file_path_normalized_hash = rdi_hash(file_path_normalized.str, file_path_normalized.size); U64 src_file_slot = file_path_normalized_hash%src_file_map.slots_count; P2R_SrcFileNode *src_file_node = 0; for(P2R_SrcFileNode *n = src_file_map.slots[src_file_slot]; n != 0; n = n->next) { if(str8_match(n->src_file->normal_full_path, file_path_normalized, 0)) { src_file_node = n; break; } } if(src_file_node == 0) { src_file_node = push_array(scratch.arena, P2R_SrcFileNode, 1); SLLStackPush(src_file_map.slots[src_file_slot], src_file_node); src_file_node->src_file = rdim_src_file_chunk_list_push(arena, &out->src_files, 4096); src_file_node->src_file->normal_full_path = push_str8_copy(arena, file_path_normalized); } // rjf: push sequence into both line table & source file's line map if(lines->line_count != 0) { if(line_table == 0) { line_table = rdim_line_table_chunk_list_push(arena, &out->line_tables, 256); } RDIM_LineSequence *seq = rdim_line_table_push_sequence(arena, &out->line_tables, line_table, src_file_node->src_file, lines->voffs, lines->line_nums, lines->col_nums, lines->line_count); rdim_src_file_push_line_sequence(arena, &out->src_files, src_file_node->src_file, seq); } } } } //- rjf: build unit RDIM_Unit *dst_unit = rdim_unit_chunk_list_push(arena, &out->units, units_chunk_cap); dst_unit->unit_name = unit_name; dst_unit->compiler_name = pdb_unit_sym->info.compiler_name; dst_unit->object_file = obj_name; dst_unit->archive_file = pdb_unit->group_name; dst_unit->language = cv2r_rdi_language_from_cv_language(pdb_unit_sym->info.language); dst_unit->line_table = line_table; } //////////////////////////// //- rjf: pass 2: build per-unit voff ranges from comp unit contributions table // PDB_CompUnitContribution *contrib_ptr = in->comp_unit_contributions->contributions; PDB_CompUnitContribution *contrib_opl = contrib_ptr + in->comp_unit_contributions->count; ProfScope("pass 2: build per-unit voff ranges from comp unit contributions table") for(;contrib_ptr < contrib_opl; contrib_ptr += 1) { if(contrib_ptr->mod < in->comp_units->count) { RDIM_Unit *unit = &out->units.first->v[contrib_ptr->mod]; RDIM_Rng1U64 range = {contrib_ptr->voff_first, contrib_ptr->voff_opl}; rdim_rng1u64_list_push(arena, &unit->voff_ranges, range); } } //////////////////////////// //- rjf: pass 3: parse all inlinee line tables // out->units_first_inline_site_line_tables = push_array(arena, RDIM_LineTable *, in->comp_units->count); ProfScope("pass 3: parse all inlinee line tables") for(U64 comp_unit_idx = 0; comp_unit_idx < in->comp_units->count; comp_unit_idx += 1) { CV_SymParsed *unit_sym = in->comp_unit_syms[comp_unit_idx]; CV_C13Parsed *unit_c13 = in->comp_unit_c13s[comp_unit_idx]; CV_RecRange *rec_ranges_first = unit_sym->sym_ranges.ranges; CV_RecRange *rec_ranges_opl = rec_ranges_first+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) { //- 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 > unit_sym->data.size || sym_off_first > unit_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 = unit_sym->data.str + sym_off_first; void *sym_data_opl = unit_sym->data.str + sym_off_opl; //- rjf: skip bad sizes if(sym_off_first + sym_header_struct_size > sym_off_opl) { continue; } //- rjf: process symbol switch(kind) { default:{}break; //- rjf: LPROC32/GPROC32 (gather base address) 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 <= in->coff_sections.count) ? &in->coff_sections.v[proc32->sec-1] : 0; if(section != 0) { base_voff = section->voff + proc32->off; } }break; //- rjf: INLINESITE case CV_SymKind_INLINESITE: { // rjf: unpack sym CV_SymInlineSite *sym = (CV_SymInlineSite *)sym_header_struct_base; String8 binary_annots = str8((U8 *)(sym+1), rec_range->hdr.size - sizeof(rec_range->hdr.kind) - sizeof(*sym)); // rjf: map inlinee -> parsed cv c13 inlinee line info CV_C13InlineeLinesParsed *inlinee_lines_parsed = 0; { U64 hash = cv_hash_from_item_id(sym->inlinee); U64 slot_idx = hash%unit_c13->inlinee_lines_parsed_slots_count; for(CV_C13InlineeLinesParsedNode *n = unit_c13->inlinee_lines_parsed_slots[slot_idx]; n != 0; n = n->hash_next) { if(n->v.inlinee == sym->inlinee) { inlinee_lines_parsed = &n->v; break; } } } // rjf: build line table, fill with parsed binary annotations if(inlinee_lines_parsed != 0) { // rjf: grab checksums sub-section CV_C13SubSectionNode *file_chksms = unit_c13->file_chksms_sub_section; // rjf: gathered lines typedef struct LineChunk LineChunk; struct LineChunk { LineChunk *next; U64 cap; U64 count; U64 *voffs; // [line_count + 1] (sorted) U32 *line_nums; // [line_count] U16 *col_nums; // [2*line_count] }; LineChunk *first_line_chunk = 0; LineChunk *last_line_chunk = 0; U64 total_line_chunk_line_count = 0; U32 last_file_off = max_U32; U32 curr_file_off = max_U32; RDIM_LineTable* line_table = 0; CV_C13InlineSiteDecoder decoder = cv_c13_inline_site_decoder_init(inlinee_lines_parsed->file_off, inlinee_lines_parsed->first_source_ln, base_voff); for(;;) { CV_C13InlineSiteDecoderStep step = cv_c13_inline_site_decoder_step(&decoder, binary_annots); if(step.flags & CV_C13InlineSiteDecoderStepFlag_EmitFile) { last_file_off = curr_file_off; curr_file_off = step.file_off; } if(step.flags == 0 && total_line_chunk_line_count > 0) { last_file_off = curr_file_off; curr_file_off = max_U32; } if((last_file_off != max_U32 && last_file_off != curr_file_off)) { String8 seq_file_name = {0}; if(last_file_off + sizeof(CV_C13Checksum) <= file_chksms->size) { CV_C13Checksum *checksum = (CV_C13Checksum*)(unit_c13->data.str + file_chksms->off + last_file_off); U32 name_off = checksum->name_off; seq_file_name = pdb_strtbl_string_from_off(in->pdb_strtbl, name_off); } // rjf: file name -> normalized file path String8 file_path = seq_file_name; String8 file_path_normalized = lower_from_str8(scratch.arena, str8_skip_chop_whitespace(file_path)); for(U64 idx = 0; idx < file_path_normalized.size; idx += 1) { if(file_path_normalized.str[idx] == '\\') { file_path_normalized.str[idx] = '/'; } } // rjf: normalized file path -> source file node U64 file_path_normalized_hash = rdi_hash(file_path_normalized.str, file_path_normalized.size); U64 src_file_slot = file_path_normalized_hash%src_file_map.slots_count; P2R_SrcFileNode *src_file_node = 0; for(P2R_SrcFileNode *n = src_file_map.slots[src_file_slot]; n != 0; n = n->next) { if(str8_match(n->src_file->normal_full_path, file_path_normalized, 0)) { src_file_node = n; break; } } if(src_file_node == 0) { src_file_node = push_array(scratch.arena, P2R_SrcFileNode, 1); SLLStackPush(src_file_map.slots[src_file_slot], src_file_node); src_file_node->src_file = rdim_src_file_chunk_list_push(arena, &out->src_files, 4096); src_file_node->src_file->normal_full_path = push_str8_copy(arena, file_path_normalized); } // rjf: gather all lines RDI_U64 *voffs = push_array_no_zero(arena, RDI_U64, total_line_chunk_line_count+1); RDI_U32 *line_nums = push_array_no_zero(arena, RDI_U32, total_line_chunk_line_count); RDI_U64 line_count = total_line_chunk_line_count; { U64 dst_idx = 0; for(LineChunk *chunk = first_line_chunk; chunk != 0; chunk = chunk->next) { MemoryCopy(voffs+dst_idx, chunk->voffs, sizeof(U64)*(chunk->count+1)); MemoryCopy(line_nums+dst_idx, chunk->line_nums, sizeof(U32)*chunk->count); dst_idx += chunk->count; } } // rjf: push if(line_count != 0) { if(line_table == 0) { line_table = rdim_line_table_chunk_list_push(arena, &out->line_tables, 256); if(out->units_first_inline_site_line_tables[comp_unit_idx] == 0) { out->units_first_inline_site_line_tables[comp_unit_idx] = line_table; } } RDIM_LineSequence *seq = rdim_line_table_push_sequence(arena, &out->line_tables, line_table, src_file_node->src_file, voffs, line_nums, 0, line_count); rdim_src_file_push_line_sequence(arena, &out->src_files, src_file_node->src_file, seq); } // rjf: clear line chunks for subsequent sequences first_line_chunk = last_line_chunk = 0; total_line_chunk_line_count = 0; } if(step.flags & CV_C13InlineSiteDecoderStepFlag_EmitLine) { LineChunk *chunk = last_line_chunk; if(chunk == 0 || chunk->count+1 >= chunk->cap) { chunk = push_array(scratch.arena, LineChunk, 1); SLLQueuePush(first_line_chunk, last_line_chunk, chunk); chunk->cap = 256; chunk->voffs = push_array_no_zero(scratch.arena, U64, chunk->cap); chunk->line_nums = push_array_no_zero(scratch.arena, U32, chunk->cap); } chunk->voffs[chunk->count] = step.line_voff; chunk->voffs[chunk->count+1] = step.line_voff_end; chunk->line_nums[chunk->count] = step.ln; chunk->count += 1; total_line_chunk_line_count += 1; } if(step.flags == 0) { break; } } } }break; } } } } scratch_end(scratch); ProfEnd(); return out; } //////////////////////////////// //~ rjf: Link Name Map Building Tasks ASYNC_WORK_DEF(p2r_link_name_map_build_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; P2R_LinkNameMapBuildIn *in = (P2R_LinkNameMapBuildIn *)input; CV_RecRange *rec_ranges_first = in->sym->sym_ranges.ranges; CV_RecRange *rec_ranges_opl = rec_ranges_first + in->sym->sym_ranges.count; for(CV_RecRange *rec_range = rec_ranges_first; rec_range < rec_ranges_opl; rec_range += 1) { //- rjf: unpack symbol range info CV_SymKind kind = rec_range->hdr.kind; U64 header_struct_size = cv_header_struct_size_from_sym_kind(kind); U8 *sym_first = in->sym->data.str + rec_range->off + 2; U8 *sym_opl = sym_first + rec_range->hdr.size; //- rjf: skip bad ranges if(sym_opl > in->sym->data.str + in->sym->data.size || sym_first + header_struct_size > in->sym->data.str + in->sym->data.size) { continue; } //- rjf: consume symbol switch(kind) { default:{}break; case CV_SymKind_PUB32: { // rjf: unpack sym CV_SymPub32 *pub32 = (CV_SymPub32 *)sym_first; String8 name = str8_cstring_capped(pub32+1, sym_opl); COFF_SectionHeader *section = (0 < pub32->sec && pub32->sec <= in->coff_sections.count) ? &in->coff_sections.v[pub32->sec-1] : 0; U64 voff = 0; if(section != 0) { voff = section->voff + pub32->off; } // rjf: commit to link name map U64 hash = p2r_hash_from_voff(voff); U64 bucket_idx = hash%in->link_name_map->buckets_count; P2R_LinkNameNode *node = push_array(arena, P2R_LinkNameNode, 1); SLLStackPush(in->link_name_map->buckets[bucket_idx], node); node->voff = voff; node->name = name; in->link_name_map->link_name_count += 1; in->link_name_map->bucket_collision_count += (node->next != 0); }break; } } ProfEnd(); return 0; } //////////////////////////////// //~ rjf: UDT Conversion Tasks ASYNC_WORK_DEF(p2r_udt_convert_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; P2R_UDTConvertIn *in = (P2R_UDTConvertIn *)input; #define p2r_type_ptr_from_itype(itype) ((in->itype_type_ptrs && (itype) < in->tpi_leaf->itype_opl) ? (in->itype_type_ptrs[itype]) : 0) RDIM_UDTChunkList *udts = push_array(arena, RDIM_UDTChunkList, 1); RDI_U64 udts_chunk_cap = 1024; ProfScope("convert UDT info") { for(CV_TypeId itype = in->itype_first; itype < in->itype_opl; itype += 1) { //- rjf: skip basics if(itype < in->tpi_leaf->itype_first) { continue; } //- rjf: grab type for this itype - skip if empty RDIM_Type *dst_type = in->itype_type_ptrs[itype]; if(dst_type == 0) { continue; } //- rjf: unpack itype leaf range - skip if out-of-range CV_RecRange *range = &in->tpi_leaf->leaf_ranges.ranges[itype-in->tpi_leaf->itype_first]; CV_LeafKind kind = range->hdr.kind; U64 header_struct_size = cv_header_struct_size_from_leaf_kind(kind); U8 *itype_leaf_first = in->tpi_leaf->data.str + range->off+2; U8 *itype_leaf_opl = itype_leaf_first + range->hdr.size-2; if(range->off+range->hdr.size > in->tpi_leaf->data.size || range->off+2+header_struct_size > in->tpi_leaf->data.size || range->hdr.size < 2) { continue; } //- rjf: build UDT CV_TypeId field_itype = 0; switch(kind) { default:{}break; //////////////////////// //- rjf: structs/unions/classes -> equip members // case CV_LeafKind_CLASS: case CV_LeafKind_STRUCTURE: { CV_LeafStruct *lf = (CV_LeafStruct *)itype_leaf_first; if(lf->props & CV_TypeProp_FwdRef) { break; } field_itype = lf->field_itype; }goto equip_members; case CV_LeafKind_UNION: { CV_LeafUnion *lf = (CV_LeafUnion *)itype_leaf_first; if(lf->props & CV_TypeProp_FwdRef) { break; } field_itype = lf->field_itype; }goto equip_members; case CV_LeafKind_CLASS2: case CV_LeafKind_STRUCT2: { CV_LeafStruct2 *lf = (CV_LeafStruct2 *)itype_leaf_first; if(lf->props & CV_TypeProp_FwdRef) { break; } field_itype = lf->field_itype; }goto equip_members; equip_members: { Temp scratch = scratch_begin(&arena, 1); //- rjf: grab UDT info RDIM_UDT *dst_udt = dst_type->udt; if(dst_udt == 0) { dst_udt = dst_type->udt = rdim_udt_chunk_list_push(arena, udts, udts_chunk_cap); dst_udt->self_type = dst_type; } //- rjf: gather all fields typedef struct FieldListTask FieldListTask; struct FieldListTask { FieldListTask *next; CV_TypeId itype; }; FieldListTask start_fl_task = {0, field_itype}; FieldListTask *fl_todo_stack = &start_fl_task; FieldListTask *fl_done_stack = 0; for(;fl_todo_stack != 0;) { //- rjf: take & unpack task FieldListTask *fl_task = fl_todo_stack; SLLStackPop(fl_todo_stack); SLLStackPush(fl_done_stack, fl_task); CV_TypeId field_list_itype = fl_task->itype; //- rjf: skip bad itypes if(field_list_itype < in->tpi_leaf->itype_first || in->tpi_leaf->itype_opl <= field_list_itype) { continue; } //- rjf: field list itype -> range CV_RecRange *range = &in->tpi_leaf->leaf_ranges.ranges[field_list_itype-in->tpi_leaf->itype_first]; //- rjf: skip bad headers if(range->off+range->hdr.size > in->tpi_leaf->data.size || range->hdr.size < 2 || range->hdr.kind != CV_LeafKind_FIELDLIST) { continue; } //- rjf: loop over all fields { U8 *field_list_first = in->tpi_leaf->data.str+range->off+2; U8 *field_list_opl = field_list_first+range->hdr.size-2; for(U8 *read_ptr = field_list_first, *next_read_ptr = field_list_opl; read_ptr < field_list_opl; read_ptr = next_read_ptr) { // rjf: unpack field CV_LeafKind field_kind = *(CV_LeafKind *)read_ptr; U64 field_leaf_header_size = cv_header_struct_size_from_leaf_kind(field_kind); U8 *field_leaf_first = read_ptr+2; U8 *field_leaf_opl = field_list_opl; next_read_ptr = field_leaf_opl; // rjf: skip out-of-bounds fields if(field_leaf_first+field_leaf_header_size > field_list_opl) { continue; } // rjf: process field switch(field_kind) { //- rjf: unhandled/invalid cases default: { // TODO(rjf): log }break; //- rjf: INDEX case CV_LeafKind_INDEX: { // rjf: unpack leaf CV_LeafIndex *lf = (CV_LeafIndex *)field_leaf_first; CV_TypeId new_itype = lf->itype; // rjf: bump next read pointer past header next_read_ptr = (U8 *)(lf+1); // rjf: determine if index itype is new B32 is_new = 1; for(FieldListTask *t = fl_done_stack; t != 0; t = t->next) { if(t->itype == new_itype) { is_new = 0; break; } } // rjf: if new -> push task to follow new itype if(is_new) { FieldListTask *new_task = push_array(scratch.arena, FieldListTask, 1); SLLStackPush(fl_todo_stack, new_task); new_task->itype = new_itype; } }break; //- rjf: MEMBER case CV_LeafKind_MEMBER: { // TODO(rjf): log on bad offset // rjf: unpack leaf CV_LeafMember *lf = (CV_LeafMember *)field_leaf_first; U8 *offset_ptr = (U8 *)(lf+1); CV_NumericParsed offset = cv_numeric_from_data_range(offset_ptr, field_leaf_opl); U64 offset64 = cv_u64_from_numeric(&offset); U8 *name_ptr = offset_ptr + offset.encoded_size; String8 name = str8_cstring_capped(name_ptr, field_leaf_opl); // rjf: bump next read pointer past variable length parts next_read_ptr = name.str+name.size+1; // rjf: emit member RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_DataField; mem->name = name; mem->type = p2r_type_ptr_from_itype(lf->itype); mem->off = (U32)offset64; }break; //- rjf: STMEMBER case CV_LeafKind_STMEMBER: { // TODO(rjf): handle attribs // rjf: unpack leaf CV_LeafStMember *lf = (CV_LeafStMember *)field_leaf_first; U8 *name_ptr = (U8 *)(lf+1); String8 name = str8_cstring_capped(name_ptr, field_leaf_opl); // rjf: bump next read pointer past variable length parts next_read_ptr = name.str+name.size+1; // rjf: emit member RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_StaticData; mem->name = name; mem->type = p2r_type_ptr_from_itype(lf->itype); }break; //- rjf: METHOD case CV_LeafKind_METHOD: { // rjf: unpack leaf CV_LeafMethod *lf = (CV_LeafMethod *)field_leaf_first; U8 *name_ptr = (U8 *)(lf+1); String8 name = str8_cstring_capped(name_ptr, field_leaf_opl); // rjf: bump next read pointer past variable length parts next_read_ptr = name.str+name.size+1; //- rjf: method list itype -> range CV_RecRange *method_list_range = &in->tpi_leaf->leaf_ranges.ranges[lf->list_itype-in->tpi_leaf->itype_first]; //- rjf: skip bad method lists if(method_list_range->off+method_list_range->hdr.size > in->tpi_leaf->data.size || method_list_range->hdr.size < 2 || method_list_range->hdr.kind != CV_LeafKind_METHODLIST) { break; } //- rjf: loop through all methods & emit members U8 *method_list_first = in->tpi_leaf->data.str + method_list_range->off + 2; U8 *method_list_opl = method_list_first + method_list_range->hdr.size-2; for(U8 *method_read_ptr = method_list_first, *next_method_read_ptr = method_list_opl; method_read_ptr < method_list_opl; method_read_ptr = next_method_read_ptr) { CV_LeafMethodListMember *method = (CV_LeafMethodListMember*)method_read_ptr; CV_MethodProp prop = CV_FieldAttribs_Extract_MethodProp(method->attribs); RDIM_Type *method_type = p2r_type_ptr_from_itype(method->itype); next_method_read_ptr = (U8 *)(method+1); // TODO(allen): PROBLEM // We only get offsets for virtual functions (the "vbaseoff") from // "Intro" and "PureIntro". In C++ inheritance, when we have a chain // of inheritance (let's just talk single inheritance for now) the // first class in the chain that introduces a new virtual function // has this "Intro" method. If a later class in the chain redefines // the virtual function it only has a "Virtual" method which does // not update the offset. There is a "Virtual" and "PureVirtual" // variant of "Virtual". The "Pure" in either case means there // is no concrete procedure. When there is no "Pure" the method // should have a corresponding procedure symbol id. // // The issue is we will want to mark all of our virtual methods as // virtual and give them an offset, but that means we have to do // some extra figuring to propogate offsets from "Intro" methods // to "Virtual" methods in inheritance trees. That is - IF we want // to start preserving the offsets of virtuals. There is room in // the method struct to make this work, but for now I've just // decided to drop this information. It is not urgently useful to // us and greatly complicates matters. // rjf: read vbaseoff U32 vbaseoff = 0; if(prop == CV_MethodProp_Intro || prop == CV_MethodProp_PureIntro) { if(next_method_read_ptr+4 <= method_list_opl) { vbaseoff = *(U32 *)next_method_read_ptr; } next_method_read_ptr += 4; } // rjf: emit method switch(prop) { default: { RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_Method; mem->name = name; mem->type = method_type; }break; case CV_MethodProp_Static: { RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_StaticMethod; mem->name = name; mem->type = method_type; }break; case CV_MethodProp_Virtual: case CV_MethodProp_PureVirtual: case CV_MethodProp_Intro: case CV_MethodProp_PureIntro: { RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_VirtualMethod; mem->name = name; mem->type = method_type; }break; } } }break; //- rjf: ONEMETHOD case CV_LeafKind_ONEMETHOD: { // TODO(rjf): handle attribs // rjf: unpack leaf CV_LeafOneMethod *lf = (CV_LeafOneMethod *)field_leaf_first; CV_MethodProp prop = CV_FieldAttribs_Extract_MethodProp(lf->attribs); U8 *vbaseoff_ptr = (U8 *)(lf+1); U8 *vbaseoff_opl_ptr = vbaseoff_ptr; U32 vbaseoff = 0; if(prop == CV_MethodProp_Intro || prop == CV_MethodProp_PureIntro) { vbaseoff = *(U32 *)(vbaseoff_ptr); vbaseoff_opl_ptr += sizeof(U32); } U8 *name_ptr = vbaseoff_opl_ptr; String8 name = str8_cstring_capped(name_ptr, field_leaf_opl); RDIM_Type *method_type = p2r_type_ptr_from_itype(lf->itype); // rjf: bump next read pointer past variable length parts next_read_ptr = name.str+name.size+1; // rjf: emit method switch(prop) { default: { RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_Method; mem->name = name; mem->type = method_type; }break; case CV_MethodProp_Static: { RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_StaticMethod; mem->name = name; mem->type = method_type; }break; case CV_MethodProp_Virtual: case CV_MethodProp_PureVirtual: case CV_MethodProp_Intro: case CV_MethodProp_PureIntro: { RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_VirtualMethod; mem->name = name; mem->type = method_type; }break; } }break; //- rjf: NESTTYPE case CV_LeafKind_NESTTYPE: { // rjf: unpack leaf CV_LeafNestType *lf = (CV_LeafNestType *)field_leaf_first; U8 *name_ptr = (U8 *)(lf+1); String8 name = str8_cstring_capped(name_ptr, field_leaf_opl); // rjf: bump next read pointer past variable length parts next_read_ptr = name.str+name.size+1; // rjf: emit member RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_NestedType; mem->name = name; mem->type = p2r_type_ptr_from_itype(lf->itype); }break; //- rjf: NESTTYPEEX case CV_LeafKind_NESTTYPEEX: { // TODO(rjf): handle attribs // rjf: unpack leaf CV_LeafNestTypeEx *lf = (CV_LeafNestTypeEx *)field_leaf_first; U8 *name_ptr = (U8 *)(lf+1); String8 name = str8_cstring_capped(name_ptr, field_leaf_opl); // rjf: bump next read pointer past variable length parts next_read_ptr = name.str+name.size+1; // rjf: emit member RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_NestedType; mem->name = name; mem->type = p2r_type_ptr_from_itype(lf->itype); }break; //- rjf: BCLASS case CV_LeafKind_BCLASS: { // TODO(rjf): log on bad offset // rjf: unpack leaf CV_LeafBClass *lf = (CV_LeafBClass *)field_leaf_first; U8 *offset_ptr = (U8 *)(lf+1); CV_NumericParsed offset = cv_numeric_from_data_range(offset_ptr, field_leaf_opl); U64 offset64 = cv_u64_from_numeric(&offset); // rjf: bump next read pointer past variable length parts next_read_ptr = offset_ptr+offset.encoded_size; // rjf: emit member RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_Base; mem->type = p2r_type_ptr_from_itype(lf->itype); mem->off = (U32)offset64; }break; //- rjf: VBCLASS/IVBCLASS case CV_LeafKind_VBCLASS: case CV_LeafKind_IVBCLASS: { // TODO(rjf): log on bad offsets // TODO(rjf): handle attribs // TODO(rjf): offsets? // rjf: unpack leaf CV_LeafVBClass *lf = (CV_LeafVBClass *)field_leaf_first; U8 *num1_ptr = (U8 *)(lf+1); CV_NumericParsed num1 = cv_numeric_from_data_range(num1_ptr, field_leaf_opl); U8 *num2_ptr = num1_ptr + num1.encoded_size; CV_NumericParsed num2 = cv_numeric_from_data_range(num2_ptr, field_leaf_opl); // rjf: bump next read pointer past header next_read_ptr = (U8 *)(lf+1); // rjf: emit member RDIM_UDTMember *mem = rdim_udt_push_member(arena, udts, dst_udt); mem->kind = RDI_MemberKind_VirtualBase; mem->type = p2r_type_ptr_from_itype(lf->itype); }break; //- rjf: VFUNCTAB case CV_LeafKind_VFUNCTAB: { CV_LeafVFuncTab *lf = (CV_LeafVFuncTab *)field_leaf_first; // rjf: bump next read pointer past header next_read_ptr = (U8 *)(lf+1); // NOTE(rjf): currently no-op this case (void)lf; }break; } // rjf: align-up next field next_read_ptr = (U8 *)AlignPow2((U64)next_read_ptr, 4); } } } scratch_end(scratch); }break; //////////////////////// //- rjf: enums -> equip enumerates // case CV_LeafKind_ENUM: { CV_LeafEnum *lf = (CV_LeafEnum *)itype_leaf_first; if(lf->props & CV_TypeProp_FwdRef) { break; } field_itype = lf->field_itype; }goto equip_enum_vals; equip_enum_vals:; { Temp scratch = scratch_begin(&arena, 1); //- rjf: grab UDT info RDIM_UDT *dst_udt = dst_type->udt; if(dst_udt == 0) { dst_udt = dst_type->udt = rdim_udt_chunk_list_push(arena, udts, udts_chunk_cap); dst_udt->self_type = dst_type; } //- rjf: gather all fields typedef struct FieldListTask FieldListTask; struct FieldListTask { FieldListTask *next; CV_TypeId itype; }; FieldListTask start_fl_task = {0, field_itype}; FieldListTask *fl_todo_stack = &start_fl_task; FieldListTask *fl_done_stack = 0; for(;fl_todo_stack != 0;) { //- rjf: take & unpack task FieldListTask *fl_task = fl_todo_stack; SLLStackPop(fl_todo_stack); SLLStackPush(fl_done_stack, fl_task); CV_TypeId field_list_itype = fl_task->itype; //- rjf: skip bad itypes if(field_list_itype < in->tpi_leaf->itype_first || in->tpi_leaf->itype_opl <= field_list_itype) { continue; } //- rjf: field list itype -> range CV_RecRange *range = &in->tpi_leaf->leaf_ranges.ranges[field_list_itype-in->tpi_leaf->itype_first]; //- rjf: skip bad headers if(range->off+range->hdr.size > in->tpi_leaf->data.size || range->hdr.size < 2 || range->hdr.kind != CV_LeafKind_FIELDLIST) { continue; } //- rjf: loop over all fields { U8 *field_list_first = in->tpi_leaf->data.str+range->off+2; U8 *field_list_opl = field_list_first+range->hdr.size-2; for(U8 *read_ptr = field_list_first, *next_read_ptr = field_list_opl; read_ptr < field_list_opl; read_ptr = next_read_ptr) { // rjf: unpack field CV_LeafKind field_kind = *(CV_LeafKind *)read_ptr; U64 field_leaf_header_size = cv_header_struct_size_from_leaf_kind(field_kind); U8 *field_leaf_first = read_ptr+2; U8 *field_leaf_opl = field_leaf_first+range->hdr.size-2; next_read_ptr = field_leaf_opl; // rjf: skip out-of-bounds fields if(field_leaf_first+field_leaf_header_size > field_list_opl) { continue; } // rjf: process field switch(field_kind) { //- rjf: unhandled/invalid cases default: { // TODO(rjf): log }break; //- rjf: INDEX case CV_LeafKind_INDEX: { // rjf: unpack leaf CV_LeafIndex *lf = (CV_LeafIndex *)field_leaf_first; CV_TypeId new_itype = lf->itype; // rjf: determine if index itype is new B32 is_new = 1; for(FieldListTask *t = fl_done_stack; t != 0; t = t->next) { if(t->itype == new_itype) { is_new = 0; break; } } // rjf: if new -> push task to follow new itype if(is_new) { FieldListTask *new_task = push_array(scratch.arena, FieldListTask, 1); SLLStackPush(fl_todo_stack, new_task); new_task->itype = new_itype; } }break; //- rjf: ENUMERATE case CV_LeafKind_ENUMERATE: { // TODO(rjf): attribs // rjf: unpack leaf CV_LeafEnumerate *lf = (CV_LeafEnumerate *)field_leaf_first; U8 *val_ptr = (U8 *)(lf+1); CV_NumericParsed val = cv_numeric_from_data_range(val_ptr, field_leaf_opl); U64 val64 = cv_u64_from_numeric(&val); U8 *name_ptr = val_ptr + val.encoded_size; String8 name = str8_cstring_capped(name_ptr, field_leaf_opl); // rjf: bump next read pointer past variable length parts next_read_ptr = name.str+name.size+1; // rjf: emit member RDIM_UDTEnumVal *enum_val = rdim_udt_push_enum_val(arena, udts, dst_udt); enum_val->name = name; enum_val->val = val64; }break; } // rjf: align-up next field next_read_ptr = (U8 *)AlignPow2((U64)next_read_ptr, 4); } } } scratch_end(scratch); }break; } } } #undef p2r_type_ptr_from_itype ProfEnd(); return udts; } //////////////////////////////// //~ rjf: Symbol Stream Conversion Path & Thread ASYNC_WORK_DEF(p2r_symbol_stream_convert_work) { ProfBeginFunction(); Arena *arena = g_p2r_local_state->work_thread_arenas[thread_idx]; Temp scratch = scratch_begin(&arena, 1); P2R_SymbolStreamConvertIn *in = (P2R_SymbolStreamConvertIn *)input; #define p2r_type_ptr_from_itype(itype) ((in->itype_type_ptrs && (itype) < in->tpi_leaf->itype_opl) ? (in->itype_type_ptrs[itype]) : 0) ////////////////////////// //- rjf: set up outputs for this sym stream // U64 sym_procedures_chunk_cap = 1024; U64 sym_global_variables_chunk_cap = 1024; U64 sym_thread_variables_chunk_cap = 1024; U64 sym_scopes_chunk_cap = 1024; U64 sym_inline_sites_chunk_cap = 1024; RDIM_SymbolChunkList sym_procedures = {0}; RDIM_SymbolChunkList sym_global_variables = {0}; RDIM_SymbolChunkList sym_thread_variables = {0}; RDIM_ScopeChunkList sym_scopes = {0}; RDIM_InlineSiteChunkList sym_inline_sites = {0}; ////////////////////////// //- rjf: symbols pass 1: produce procedure frame info map (procedure -> frame info) // U64 procedure_frameprocs_count = 0; U64 procedure_frameprocs_cap = (in->sym_ranges_opl - in->sym_ranges_first); CV_SymFrameproc **procedure_frameprocs = push_array_no_zero(scratch.arena, CV_SymFrameproc *, procedure_frameprocs_cap); ProfScope("symbols pass 1: produce procedure frame info map (procedure -> frame info)") { U64 procedure_num = 0; CV_RecRange *rec_ranges_first = in->sym->sym_ranges.ranges + in->sym_ranges_first; CV_RecRange *rec_ranges_opl = in->sym->sym_ranges.ranges + in->sym_ranges_opl; 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 > in->sym->data.size || sym_off_first > in->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 = in->sym->data.str + sym_off_first; //- rjf: skip bad sizes if(sym_off_first + sym_header_struct_size > sym_off_opl) { continue; } //- rjf: consume symbol based on kind switch(kind) { default:{}break; //- rjf: FRAMEPROC case CV_SymKind_FRAMEPROC: { if(procedure_num == 0) { break; } if(procedure_num > procedure_frameprocs_cap) { break; } CV_SymFrameproc *frameproc = (CV_SymFrameproc*)sym_header_struct_base; procedure_frameprocs[procedure_num-1] = frameproc; procedure_frameprocs_count = Max(procedure_frameprocs_count, procedure_num); }break; //- rjf: LPROC32/GPROC32 case CV_SymKind_LPROC32: case CV_SymKind_GPROC32: { procedure_num += 1; }break; } } U64 scratch_overkill = sizeof(procedure_frameprocs[0])*(procedure_frameprocs_cap-procedure_frameprocs_count); arena_pop(scratch.arena, scratch_overkill); } ////////////////////////// //- rjf: symbols pass 2: construct all symbols, given procedure frame info map // ProfScope("symbols pass 2: construct all symbols, given procedure frame info map") { RDIM_LocationSet *defrange_target = 0; B32 defrange_target_is_param = 0; U64 procedure_num = 0; U64 procedure_base_voff = 0; CV_RecRange *rec_ranges_first = in->sym->sym_ranges.ranges + in->sym_ranges_first; CV_RecRange *rec_ranges_opl = in->sym->sym_ranges.ranges + in->sym_ranges_opl; typedef struct P2R_ScopeNode P2R_ScopeNode; struct P2R_ScopeNode { P2R_ScopeNode *next; RDIM_Scope *scope; }; P2R_ScopeNode *top_scope_node = 0; P2R_ScopeNode *free_scope_node = 0; RDIM_LineTable *inline_site_line_table = in->first_inline_site_line_table; 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 > in->sym->data.size || sym_off_first > in->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 = in->sym->data.str + sym_off_first; void *sym_data_opl = in->sym->data.str + sym_off_opl; //- rjf: skip bad sizes if(sym_off_first + sym_header_struct_size > sym_off_opl) { continue; } //- rjf: consume symbol based on kind switch(kind) { default:{}break; //- rjf: END case CV_SymKind_END: { P2R_ScopeNode *n = top_scope_node; if(n != 0) { SLLStackPop(top_scope_node); SLLStackPush(free_scope_node, n); } defrange_target = 0; defrange_target_is_param = 0; }break; //- rjf: BLOCK32 case CV_SymKind_BLOCK32: { // rjf: unpack sym 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); { if(top_scope_node == 0) { // TODO(rjf): log } if(top_scope_node != 0) { RDIM_Scope *top_scope = top_scope_node->scope; SLLQueuePush_N(top_scope->first_child, top_scope->last_child, scope, next_sibling); scope->parent_scope = top_scope; scope->symbol = top_scope->symbol; } COFF_SectionHeader *section = (0 < block32->sec && block32->sec <= in->coff_sections.count) ? &in->coff_sections.v[block32->sec-1] : 0; if(section != 0) { 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); } } // rjf: push this scope to scope stack { P2R_ScopeNode *node = free_scope_node; if(node != 0) { SLLStackPop(free_scope_node); } else { node = push_array_no_zero(scratch.arena, P2R_ScopeNode, 1); } node->scope = scope; SLLStackPush(top_scope_node, node); } }break; //- rjf: LDATA32/GDATA32 case CV_SymKind_LDATA32: case CV_SymKind_GDATA32: { // rjf: unpack sym CV_SymData32 *data32 = (CV_SymData32 *)sym_header_struct_base; String8 name = str8_cstring_capped(data32+1, sym_data_opl); COFF_SectionHeader *section = (0 < data32->sec && data32->sec <= in->coff_sections.count) ? &in->coff_sections.v[data32->sec-1] : 0; U64 voff = (section ? section->voff : 0) + data32->off; // rjf: determine if this is an exact duplicate global // // PDB likes to have duplicates of these spread across different // symbol streams so we deduplicate across the entire translation // context. // B32 is_duplicate = 0; { // TODO(rjf): @important global symbol dedup } // rjf: is not duplicate -> push new global if(!is_duplicate) { // rjf: unpack global variable's type RDIM_Type *type = p2r_type_ptr_from_itype(data32->itype); // rjf: unpack global's container type RDIM_Type *container_type = 0; U64 container_name_opl = p2r_end_of_cplusplus_container_name(name); if(container_name_opl > 2) { String8 container_name = str8(name.str, container_name_opl - 2); CV_TypeId cv_type_id = pdb_tpi_first_itype_from_name(in->tpi_hash, in->tpi_leaf, container_name, 0); container_type = p2r_type_ptr_from_itype(cv_type_id); } // rjf: unpack global's container symbol RDIM_Symbol *container_symbol = 0; if(container_type == 0 && top_scope_node != 0) { container_symbol = top_scope_node->scope->symbol; } // form a VOFF location #if 0 RDIM_LocationSet locset = {0}; RDIM_Location *voff_loc = rdim_push_location_voff(arena, voff); rdim_location_set_push_case(arena, &locset, (RDIM_Rng1U64){0,max_U64}, voff_loc); #endif // rjf: build symbol 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; //symbol->locset = locset; symbol->container_symbol = container_symbol; symbol->container_type = container_type; } }break; //- rjf: LPROC32/GPROC32 case CV_SymKind_LPROC32: case CV_SymKind_GPROC32: { // rjf: unpack sym CV_SymProc32 *proc32 = (CV_SymProc32 *)sym_header_struct_base; String8 name = str8_cstring_capped(proc32+1, sym_data_opl); RDIM_Type *type = p2r_type_ptr_from_itype(proc32->itype); // rjf: unpack proc's container type RDIM_Type *container_type = 0; U64 container_name_opl = p2r_end_of_cplusplus_container_name(name); if(container_name_opl > 2 && in->tpi_hash != 0 && in->tpi_leaf != 0) { String8 container_name = str8(name.str, container_name_opl - 2); CV_TypeId cv_type_id = pdb_tpi_first_itype_from_name(in->tpi_hash, in->tpi_leaf, container_name, 0); container_type = p2r_type_ptr_from_itype(cv_type_id); } // rjf: unpack proc's container symbol RDIM_Symbol *container_symbol = 0; if(container_type == 0 && top_scope_node != 0) { container_symbol = top_scope_node->scope->symbol; } // rjf: build procedure's root scope // // NOTE: even if there could be a containing scope at this point (which should be // illegal in C/C++ but not necessarily in another language) we would not use // 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); { COFF_SectionHeader *section = (0 < proc32->sec && proc32->sec <= in->coff_sections.count) ? &in->coff_sections.v[proc32->sec-1] : 0; if(section != 0) { 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); procedure_base_voff = voff_first; } } // rjf: root scope voff minimum range -> link name String8 link_name = {0}; if(procedure_root_scope->voff_ranges.min != 0) { U64 voff = procedure_root_scope->voff_ranges.min; U64 hash = p2r_hash_from_voff(voff); U64 bucket_idx = hash%in->link_name_map->buckets_count; P2R_LinkNameNode *node = 0; for(P2R_LinkNameNode *n = in->link_name_map->buckets[bucket_idx]; n != 0; n = n->next) { if(n->voff == voff) { link_name = n->name; break; } } } // rjf: build procedure symbol 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; procedure_symbol->type = type; procedure_symbol->container_symbol = container_symbol; procedure_symbol->container_type = container_type; procedure_symbol->root_scope = procedure_root_scope; // rjf: fill root scope's symbol procedure_root_scope->symbol = procedure_symbol; // rjf: push scope to scope stack { P2R_ScopeNode *node = free_scope_node; if(node != 0) { SLLStackPop(free_scope_node); } else { node = push_array_no_zero(scratch.arena, P2R_ScopeNode, 1); } node->scope = procedure_root_scope; SLLStackPush(top_scope_node, node); } // rjf: increment procedure counter procedure_num += 1; }break; //- rjf: REGREL32 case CV_SymKind_REGREL32: { // TODO(rjf): apparently some of the information here may end up being // redundant with "better" information from CV_SymKind_LOCAL record. // we don't currently handle this, but if those cases arise then it // will obviously be better to prefer the better information from both // records. // rjf: no containing scope? -> malformed data; locals cannot be produced // outside of a containing scope if(top_scope_node == 0) { break; } // rjf: unpack sym CV_SymRegrel32 *regrel32 = (CV_SymRegrel32 *)sym_header_struct_base; String8 name = str8_cstring_capped(regrel32+1, sym_data_opl); RDIM_Type *type = p2r_type_ptr_from_itype(regrel32->itype); CV_Reg cv_reg = regrel32->reg; U32 var_off = regrel32->reg_off; // rjf: determine if this is a parameter RDI_LocalKind local_kind = RDI_LocalKind_Variable; { B32 is_stack_reg = 0; switch(in->arch) { default:{}break; case RDI_Arch_X86:{is_stack_reg = (cv_reg == CV_Regx86_ESP);}break; case RDI_Arch_X64:{is_stack_reg = (cv_reg == CV_Regx64_RSP);}break; } if(is_stack_reg) { U32 frame_size = 0xFFFFFFFF; if(procedure_num != 0 && procedure_frameprocs[procedure_num-1] != 0 && procedure_num < procedure_frameprocs_count) { CV_SymFrameproc *frameproc = procedure_frameprocs[procedure_num-1]; frame_size = frameproc->frame_size; } if(var_off > frame_size) { local_kind = RDI_LocalKind_Parameter; } } } // TODO(rjf): is this correct? // rjf: redirect type, if 0, and if outside frame, to the return type of the // containing procedure if(local_kind == RDI_LocalKind_Parameter && regrel32->itype == 0 && top_scope_node->scope->symbol != 0 && top_scope_node->scope->symbol->type != 0) { type = top_scope_node->scope->symbol->type->direct_type; } // rjf: build local RDIM_Scope *scope = top_scope_node->scope; RDIM_Local *local = rdim_scope_push_local(arena, &sym_scopes, scope); local->kind = local_kind; local->name = name; local->type = type; // rjf: add location info to local if(type != 0) { // rjf: determine if we need an extra indirection to the value B32 extra_indirection_to_value = 0; switch(in->arch) { case RDI_Arch_X86: { extra_indirection_to_value = (local_kind == RDI_LocalKind_Parameter && (type->byte_size > 4 || !IsPow2OrZero(type->byte_size))); }break; case RDI_Arch_X64: { extra_indirection_to_value = (local_kind == RDI_LocalKind_Parameter && (type->byte_size > 8 || !IsPow2OrZero(type->byte_size))); }break; } // rjf: get raddbg register code RDI_RegCode reg_code = cv2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); // TODO(rjf): real byte_size & byte_pos from cv_reg goes here U32 byte_size = 8; U32 byte_pos = 0; // rjf: set location case RDIM_Location *loc = p2r_location_from_addr_reg_off(arena, in->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); } }break; //- rjf: LTHREAD32/GTHREAD32 case CV_SymKind_LTHREAD32: case CV_SymKind_GTHREAD32: { // rjf: unpack sym CV_SymThread32 *thread32 = (CV_SymThread32 *)sym_header_struct_base; String8 name = str8_cstring_capped(thread32+1, sym_data_opl); U32 tls_off = thread32->tls_off; RDIM_Type *type = p2r_type_ptr_from_itype(thread32->itype); // rjf: unpack thread variable's container type RDIM_Type *container_type = 0; U64 container_name_opl = p2r_end_of_cplusplus_container_name(name); if(container_name_opl > 2) { String8 container_name = str8(name.str, container_name_opl - 2); CV_TypeId cv_type_id = pdb_tpi_first_itype_from_name(in->tpi_hash, in->tpi_leaf, container_name, 0); container_type = p2r_type_ptr_from_itype(cv_type_id); } // rjf: unpack thread variable's container symbol RDIM_Symbol *container_symbol = 0; if(container_type == 0 && top_scope_node != 0) { container_symbol = top_scope_node->scope->symbol; } // form TLS OFF location #if 0 RDIM_LocationSet locset = {0}; RDIM_Location *tls_off_loc = rdim_push_location_tls_off(arena, tls_off); rdim_location_set_push_case(arena, &locset, (RDIM_Rng1U64){0,max_U64}, tls_off_loc); #endif // rjf: build symbol 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); //tvar->locset = locset; tvar->container_type = container_type; tvar->container_symbol = container_symbol; }break; //- rjf: LOCAL case CV_SymKind_LOCAL: { // rjf: no containing scope? -> malformed data; locals cannot be produced // outside of a containing scope if(top_scope_node == 0) { break; } // rjf: unpack sym CV_SymLocal *slocal = (CV_SymLocal *)sym_header_struct_base; String8 name = str8_cstring_capped(slocal+1, sym_data_opl); RDIM_Type *type = p2r_type_ptr_from_itype(slocal->itype); // rjf: determine if this symbol encodes the beginning of a global modification B32 is_global_modification = 0; if((slocal->flags & CV_LocalFlag_Global) || (slocal->flags & CV_LocalFlag_Static)) { is_global_modification = 1; } // rjf: is global modification -> emit global modification symbol if(is_global_modification) { // TODO(rjf): add global modification symbols defrange_target = 0; defrange_target_is_param = 0; } // rjf: is not a global modification -> emit a local variable if(!is_global_modification) { // rjf: determine local kind RDI_LocalKind local_kind = RDI_LocalKind_Variable; if(slocal->flags & CV_LocalFlag_Param) { local_kind = RDI_LocalKind_Parameter; } // rjf: build local RDIM_Scope *scope = top_scope_node->scope; RDIM_Local *local = rdim_scope_push_local(arena, &sym_scopes, scope); local->kind = local_kind; local->name = name; local->type = type; // rjf: save defrange target, for subsequent defrange symbols defrange_target = &local->locset; defrange_target_is_param = (local_kind == RDI_LocalKind_Parameter); } }break; //- rjf: DEFRANGE_REGISTESR case CV_SymKind_DEFRANGE_REGISTER: { // rjf: no defrange target? -> somehow we got to a defrange symbol without first seeing // a local - break immediately if(defrange_target == 0) { break; } // rjf: unpack sym CV_SymDefrangeRegister *defrange_register = (CV_SymDefrangeRegister*)sym_header_struct_base; CV_Reg cv_reg = defrange_register->reg; CV_LvarAddrRange *range = &defrange_register->range; COFF_SectionHeader *range_section = (0 < range->sec && range->sec <= in->coff_sections.count) ? &in->coff_sections.v[range->sec-1] : 0; CV_LvarAddrGap *gaps = (CV_LvarAddrGap*)(defrange_register+1); U64 gap_count = ((U8*)sym_data_opl - (U8*)gaps) / sizeof(*gaps); RDI_RegCode reg_code = cv2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); // rjf: build location 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); }break; //- rjf: DEFRANGE_FRAMEPOINTER_REL case CV_SymKind_DEFRANGE_FRAMEPOINTER_REL: { // rjf: no defrange target? -> somehow we got to a defrange symbol without first seeing // a local - break immediately if(defrange_target == 0) { break; } // rjf: find current procedure's frameproc CV_SymFrameproc *frameproc = 0; if(procedure_num != 0 && procedure_num <= procedure_frameprocs_count && procedure_frameprocs[procedure_num-1] != 0) { frameproc = procedure_frameprocs[procedure_num-1]; } // rjf: no current valid frameproc? -> somehow we got a to a framepointer-relative defrange // without having an actually active procedure - break if(frameproc == 0) { break; } // rjf: unpack sym CV_SymDefrangeFramepointerRel *defrange_fprel = (CV_SymDefrangeFramepointerRel*)sym_header_struct_base; CV_LvarAddrRange *range = &defrange_fprel->range; COFF_SectionHeader *range_section = (0 < range->sec && range->sec <= in->coff_sections.count) ? &in->coff_sections.v[range->sec-1] : 0; CV_LvarAddrGap *gaps = (CV_LvarAddrGap*)(defrange_fprel + 1); U64 gap_count = ((U8*)sym_data_opl - (U8*)gaps) / sizeof(*gaps); // rjf: select frame pointer register CV_EncodedFramePtrReg encoded_fp_reg = cv_pick_fp_encoding(frameproc, defrange_target_is_param); RDI_RegCode fp_register_code = cv2r_reg_code_from_arch_encoded_fp_reg(in->arch, encoded_fp_reg); // rjf: build location B32 extra_indirection = 0; U32 byte_size = rdi_addr_size_from_arch(in->arch); U32 byte_pos = 0; S64 var_off = (S64)defrange_fprel->off; RDIM_Location *location = p2r_location_from_addr_reg_off(arena, in->arch, fp_register_code, byte_size, byte_pos, var_off, extra_indirection); // rjf: emit locations over ranges p2r_location_over_lvar_addr_range(arena, &sym_scopes, defrange_target, location, range, range_section, gaps, gap_count); }break; //- rjf: DEFRANGE_SUBFIELD_REGISTER case CV_SymKind_DEFRANGE_SUBFIELD_REGISTER: { // rjf: no defrange target? -> somehow we got to a defrange symbol without first seeing // a local - break immediately if(defrange_target == 0) { break; } // rjf: unpack sym CV_SymDefrangeSubfieldRegister *defrange_subfield_register = (CV_SymDefrangeSubfieldRegister*)sym_header_struct_base; CV_Reg cv_reg = defrange_subfield_register->reg; CV_LvarAddrRange *range = &defrange_subfield_register->range; COFF_SectionHeader *range_section = (0 < range->sec && range->sec <= in->coff_sections.count) ? &in->coff_sections.v[range->sec-1] : 0; CV_LvarAddrGap *gaps = (CV_LvarAddrGap*)(defrange_subfield_register + 1); U64 gap_count = ((U8*)sym_data_opl - (U8*)gaps) / sizeof(*gaps); RDI_RegCode reg_code = cv2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); // rjf: skip "subfield" location info - currently not supported if(defrange_subfield_register->field_offset != 0) { break; } // rjf: build location 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); }break; //- rjf: DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE case CV_SymKind_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE: { // rjf: no defrange target? -> somehow we got to a defrange symbol without first seeing // a local - break immediately if(defrange_target == 0) { break; } // rjf: find current procedure's frameproc CV_SymFrameproc *frameproc = 0; if(procedure_num != 0 && procedure_num <= procedure_frameprocs_count && procedure_frameprocs[procedure_num-1] != 0) { frameproc = procedure_frameprocs[procedure_num-1]; } // rjf: no current valid frameproc? -> somehow we got a to a framepointer-relative defrange // without having an actually active procedure - break if(frameproc == 0) { break; } // rjf: unpack sym CV_SymDefrangeFramepointerRelFullScope *defrange_fprel_full_scope = (CV_SymDefrangeFramepointerRelFullScope*)sym_header_struct_base; CV_EncodedFramePtrReg encoded_fp_reg = cv_pick_fp_encoding(frameproc, defrange_target_is_param); RDI_RegCode fp_register_code = cv2r_reg_code_from_arch_encoded_fp_reg(in->arch, encoded_fp_reg); // rjf: build location B32 extra_indirection = 0; U32 byte_size = rdi_addr_size_from_arch(in->arch); U32 byte_pos = 0; S64 var_off = (S64)defrange_fprel_full_scope->off; RDIM_Location *location = p2r_location_from_addr_reg_off(arena, in->arch, fp_register_code, byte_size, byte_pos, var_off, extra_indirection); // 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); }break; //- rjf: DEFRANGE_REGISTER_REL case CV_SymKind_DEFRANGE_REGISTER_REL: { // rjf: no defrange target? -> somehow we got to a defrange symbol without first seeing // a local - break immediately if(defrange_target == 0) { break; } // rjf: unpack sym CV_SymDefrangeRegisterRel *defrange_register_rel = (CV_SymDefrangeRegisterRel*)sym_header_struct_base; CV_Reg cv_reg = defrange_register_rel->reg; RDI_RegCode reg_code = cv2r_rdi_reg_code_from_cv_reg_code(in->arch, cv_reg); CV_LvarAddrRange *range = &defrange_register_rel->range; COFF_SectionHeader *range_section = (0 < range->sec && range->sec <= in->coff_sections.count) ? &in->coff_sections.v[range->sec-1] : 0; CV_LvarAddrGap *gaps = (CV_LvarAddrGap*)(defrange_register_rel + 1); U64 gap_count = ((U8*)sym_data_opl - (U8*)gaps) / sizeof(*gaps); // rjf: build location // TODO(rjf): offset & size from cv_reg code U32 byte_size = rdi_addr_size_from_arch(in->arch); U32 byte_pos = 0; B32 extra_indirection_to_value = 0; S64 var_off = defrange_register_rel->reg_off; RDIM_Location *location = p2r_location_from_addr_reg_off(arena, in->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); }break; //- rjf: FILESTATIC case CV_SymKind_FILESTATIC: { CV_SymFileStatic *file_static = (CV_SymFileStatic*)sym_header_struct_base; String8 name = str8_cstring_capped(file_static+1, sym_data_opl); RDIM_Type *type = p2r_type_ptr_from_itype(file_static->itype); // TODO(rjf): emit a global modifier symbol defrange_target = 0; defrange_target_is_param = 0; }break; //- rjf: INLINESITE case CV_SymKind_INLINESITE: { // rjf: unpack sym CV_SymInlineSite *sym = (CV_SymInlineSite *)sym_header_struct_base; String8 binary_annots = str8((U8 *)(sym+1), rec_range->hdr.size - sizeof(rec_range->hdr.kind) - sizeof(*sym)); // rjf: extract external info about inline site String8 name = str8_zero(); RDIM_Type *type = 0; RDIM_Type *owner = 0; if(in->ipi_leaf != 0 && in->ipi_leaf->itype_first <= sym->inlinee && sym->inlinee < in->ipi_leaf->itype_opl) { CV_RecRange rec_range = in->ipi_leaf->leaf_ranges.ranges[sym->inlinee - in->ipi_leaf->itype_first]; String8 rec_data = str8_substr(in->ipi_leaf->data, rng_1u64(rec_range.off, rec_range.off + rec_range.hdr.size)); void *raw_leaf = rec_data.str + sizeof(U16); // rjf: extract method inline info if(rec_range.hdr.kind == CV_LeafKind_MFUNC_ID && rec_range.hdr.size >= sizeof(CV_LeafMFuncId)) { CV_LeafMFuncId *mfunc_id = (CV_LeafMFuncId*)raw_leaf; name = str8_cstring_capped(mfunc_id + 1, rec_data.str + rec_data.size); type = p2r_type_ptr_from_itype(mfunc_id->itype); owner = mfunc_id->owner_itype != 0 ? p2r_type_ptr_from_itype(mfunc_id->owner_itype) : 0; } // rjf: extract non-method function inline info else if(rec_range.hdr.kind == CV_LeafKind_FUNC_ID && rec_range.hdr.size >= sizeof(CV_LeafFuncId)) { CV_LeafFuncId *func_id = (CV_LeafFuncId*)raw_leaf; name = str8_cstring_capped(func_id + 1, rec_data.str + rec_data.size); type = p2r_type_ptr_from_itype(func_id->itype); owner = func_id->scope_string_id != 0 ? p2r_type_ptr_from_itype(func_id->scope_string_id) : 0; } } // rjf: build inline site 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; inline_site->line_table = inline_site_line_table; // rjf: increment to next inline site line table in this unit if(inline_site_line_table != 0 && inline_site_line_table->chunk != 0) { RDIM_LineTableChunkNode *chunk = inline_site_line_table->chunk; U64 current_idx = (U64)(inline_site_line_table - chunk->v); if(current_idx+1 < chunk->count) { inline_site_line_table += 1; } else { chunk = chunk->next; inline_site_line_table = 0; if(chunk != 0) { inline_site_line_table = chunk->v; } } } // rjf: build scope 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) { // TODO(rjf): log } if(top_scope_node != 0) { RDIM_Scope *top_scope = top_scope_node->scope; SLLQueuePush_N(top_scope->first_child, top_scope->last_child, scope, next_sibling); scope->parent_scope = top_scope; scope->symbol = top_scope->symbol; } // rjf: push this scope to scope stack { P2R_ScopeNode *node = free_scope_node; if(node != 0) { SLLStackPop(free_scope_node); } else { node = push_array_no_zero(scratch.arena, P2R_ScopeNode, 1); } node->scope = scope; SLLStackPush(top_scope_node, node); } // rjf: parse offset ranges of this inline site - attach to scope { CV_C13InlineSiteDecoder decoder = cv_c13_inline_site_decoder_init(0, 0, procedure_base_voff); for(;;) { CV_C13InlineSiteDecoderStep step = cv_c13_inline_site_decoder_step(&decoder, binary_annots); if(step.flags & CV_C13InlineSiteDecoderStepFlag_EmitRange) { // 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); } if(step.flags & CV_C13InlineSiteDecoderStepFlag_ExtendLastRange) { if(scope->voff_ranges.last != 0) { scope->voff_ranges.last->v.max = step.range.max; } } if(step.flags == 0) { break; } } } }break; //- rjf: INLINESITE_END case CV_SymKind_INLINESITE_END: { P2R_ScopeNode *n = top_scope_node; if(n != 0) { SLLStackPop(top_scope_node); SLLStackPush(free_scope_node, n); } defrange_target = 0; defrange_target_is_param = 0; }break; } } } ////////////////////////// //- rjf: allocate & fill output // P2R_SymbolStreamConvertOut *out = push_array(arena, P2R_SymbolStreamConvertOut, 1); { out->procedures = sym_procedures; out->global_variables = sym_global_variables; out->thread_variables = sym_thread_variables; out->scopes = sym_scopes; out->inline_sites = sym_inline_sites; } #undef p2r_type_ptr_from_itype scratch_end(scratch); ProfEnd(); return out; } //////////////////////////////// //~ rjf: Top-Level Conversion Entry Point internal RDIM_BakeParams * p2r_convert(Arena *arena, RDIM_LocalState *local_state, RC_Context *in) { Temp scratch = scratch_begin(&arena, 1); g_p2r_local_state = local_state; ////////////////////////////////////////////////////////////// //- rjf: parse MSF structure // MSF_Parsed *msf = 0; if(in->debug_data.size != 0) ProfScope("parse MSF structure") { msf = msf_parsed_from_data(arena, in->debug_data); } ////////////////////////////////////////////////////////////// //- rjf: parse PDB auth_guid & named streams table // PDB_NamedStreamTable *named_streams = 0; Guid auth_guid = {0}; if(msf != 0) ProfScope("parse PDB auth_guid & named streams table") { Temp scratch = scratch_begin(&arena, 1); String8 info_data = msf_data_from_stream(msf, PDB_FixedStream_Info); PDB_Info *info = pdb_info_from_data(scratch.arena, info_data); named_streams = pdb_named_stream_table_from_info(arena, info); MemoryCopyStruct(&auth_guid, &info->auth_guid); scratch_end(scratch); if (info->features & PDB_FeatureFlag_MINIMAL_DBG_INFO) { fprintf(stderr, "ERROR: PDB was linked with /DEBUG:FASTLINK (partial debug info is not supported). Please relink using /DEBUG:FULL."); os_abort(1); } } ////////////////////////////////////////////////////////////// //- rjf: parse PDB strtbl // PDB_Strtbl *strtbl = 0; String8 raw_strtbl = str8_zero(); if(named_streams != 0) ProfScope("parse PDB strtbl") { MSF_StreamNumber strtbl_sn = named_streams->sn[PDB_NamedStream_StringTable]; String8 strtbl_data = msf_data_from_stream(msf, strtbl_sn); strtbl = pdb_strtbl_from_data(arena, strtbl_data); raw_strtbl = str8_substr(strtbl_data, rng_1u64(strtbl->strblock_min, strtbl->strblock_max)); } ////////////////////////////////////////////////////////////// //- rjf: parse dbi // PDB_DbiParsed *dbi = 0; if(msf != 0) ProfScope("parse dbi") { String8 dbi_data = msf_data_from_stream(msf, PDB_FixedStream_Dbi); dbi = pdb_dbi_from_data(arena, dbi_data); } ////////////////////////////////////////////////////////////// //- rjf: parse tpi // PDB_TpiParsed *tpi = 0; if(msf != 0) ProfScope("parse tpi") { String8 tpi_data = msf_data_from_stream(msf, PDB_FixedStream_Tpi); tpi = pdb_tpi_from_data(arena, tpi_data); } ////////////////////////////////////////////////////////////// //- rjf: parse ipi // PDB_TpiParsed *ipi = 0; if(msf != 0) ProfScope("parse ipi") { String8 ipi_data = msf_data_from_stream(msf, PDB_FixedStream_Ipi); ipi = pdb_tpi_from_data(arena, ipi_data); } ////////////////////////////////////////////////////////////// //- rjf: parse coff sections // COFF_SectionHeaderArray coff_sections = {0}; if(dbi != 0) ProfScope("parse coff sections") { MSF_StreamNumber section_stream = dbi->dbg_streams[PDB_DbiStream_SECTION_HEADER]; String8 section_data = msf_data_from_stream(msf, section_stream); coff_sections = pdb_coff_section_array_from_data(arena, section_data); } ////////////////////////////////////////////////////////////// //- rjf: parse gsi // PDB_GsiParsed *gsi = 0; if(dbi != 0) ProfScope("parse gsi") { String8 gsi_data = msf_data_from_stream(msf, dbi->gsi_sn); gsi = pdb_gsi_from_data(arena, gsi_data); } ////////////////////////////////////////////////////////////// //- rjf: parse psi // PDB_GsiParsed *psi_gsi_part = 0; if(dbi != 0) ProfScope("parse psi") { String8 psi_data = msf_data_from_stream(msf, dbi->psi_sn); String8 psi_data_gsi_part = str8_range(psi_data.str + sizeof(PDB_PsiHeader), psi_data.str + psi_data.size); psi_gsi_part = pdb_gsi_from_data(arena, psi_data_gsi_part); } ////////////////////////////////////////////////////////////// //- rjf: kickoff EXE hash // P2R_EXEHashIn exe_hash_in = {in->image_data}; ASYNC_Task *exe_hash_task = async_task_launch(scratch.arena, p2r_exe_hash_work, .input = &exe_hash_in); ////////////////////////////////////////////////////////////// //- rjf: kickoff TPI hash parse // P2R_TPIHashParseIn tpi_hash_in = {0}; ASYNC_Task *tpi_hash_task = 0; if(tpi != 0) { tpi_hash_in.strtbl = strtbl; tpi_hash_in.tpi = tpi; tpi_hash_in.hash_data = msf_data_from_stream(msf, tpi->hash_sn); tpi_hash_in.aux_data = msf_data_from_stream(msf, tpi->hash_sn_aux); tpi_hash_task = async_task_launch(scratch.arena, p2r_tpi_hash_parse_work, .input = &tpi_hash_in); } ////////////////////////////////////////////////////////////// //- rjf: kickoff TPI leaf parse // P2R_TPILeafParseIn tpi_leaf_in = {0}; ASYNC_Task *tpi_leaf_task = 0; if(tpi != 0) { tpi_leaf_in.leaf_data = pdb_leaf_data_from_tpi(tpi); tpi_leaf_in.itype_first = tpi->itype_first; tpi_leaf_task = async_task_launch(scratch.arena, p2r_tpi_leaf_parse_work, .input = &tpi_leaf_in); } ////////////////////////////////////////////////////////////// //- rjf: kickoff IPI hash parse // P2R_TPIHashParseIn ipi_hash_in = {0}; ASYNC_Task *ipi_hash_task = 0; if(ipi != 0) { ipi_hash_in.strtbl = strtbl; ipi_hash_in.tpi = ipi; ipi_hash_in.hash_data = msf_data_from_stream(msf, ipi->hash_sn); ipi_hash_in.aux_data = msf_data_from_stream(msf, ipi->hash_sn_aux); ipi_hash_task = async_task_launch(scratch.arena, p2r_tpi_hash_parse_work, .input = &ipi_hash_in); } ////////////////////////////////////////////////////////////// //- rjf: kickoff IPI leaf parse // P2R_TPILeafParseIn ipi_leaf_in = {0}; ASYNC_Task *ipi_leaf_task = 0; if(ipi != 0) { ipi_leaf_in.leaf_data = pdb_leaf_data_from_tpi(ipi); ipi_leaf_in.itype_first = ipi->itype_first; ipi_leaf_task = async_task_launch(scratch.arena, p2r_tpi_leaf_parse_work, .input = &ipi_leaf_in); } ////////////////////////////////////////////////////////////// //- rjf: kickoff top-level global symbol stream parse // P2R_SymbolStreamParseIn sym_parse_in = {dbi ? msf_data_from_stream(msf, dbi->sym_sn) : str8_zero()}; ASYNC_Task *sym_parse_task = !dbi ? 0 : async_task_launch(scratch.arena, p2r_symbol_stream_parse_work, .input = &sym_parse_in); ////////////////////////////////////////////////////////////// //- rjf: kickoff compilation unit parses // P2R_CompUnitParseIn comp_unit_parse_in = {dbi ? pdb_data_from_dbi_range(dbi, PDB_DbiRange_ModuleInfo) : str8_zero()}; P2R_CompUnitContributionsParseIn comp_unit_contributions_parse_in = {dbi ? pdb_data_from_dbi_range(dbi, PDB_DbiRange_SecCon) : str8_zero(), coff_sections}; ASYNC_Task *comp_unit_parse_task = !dbi ? 0 : async_task_launch(scratch.arena, p2r_comp_unit_parse_work, .input = &comp_unit_parse_in); ASYNC_Task *comp_unit_contributions_parse_task = !dbi ? 0 : async_task_launch(scratch.arena, p2r_comp_unit_contributions_parse_work, .input = &comp_unit_contributions_parse_in); ////////////////////////////////////////////////////////////// //- rjf: join compilation unit parses // PDB_CompUnitArray *comp_units = 0; U64 comp_unit_count = 0; PDB_CompUnitContributionArray *comp_unit_contributions = 0; U64 comp_unit_contribution_count = 0; { comp_units = async_task_join_struct(comp_unit_parse_task, PDB_CompUnitArray); comp_unit_contributions = async_task_join_struct(comp_unit_contributions_parse_task, PDB_CompUnitContributionArray); comp_unit_count = comp_units ? comp_units->count : 0; comp_unit_contribution_count = comp_unit_contributions ? comp_unit_contributions->count : 0; } ////////////////////////////////////////////////////////////// //- rjf: parse syms & line info for each compilation unit // CV_SymParsed **sym_for_unit = push_array(arena, CV_SymParsed *, comp_unit_count); CV_C13Parsed **c13_for_unit = push_array(arena, CV_C13Parsed *, comp_unit_count); if(comp_units != 0) ProfScope("parse syms & line info for each compilation unit") { //- rjf: kick off tasks P2R_SymbolStreamParseIn *sym_tasks_inputs = push_array(scratch.arena, P2R_SymbolStreamParseIn, comp_unit_count); ASYNC_Task **sym_tasks = push_array(scratch.arena, ASYNC_Task *, comp_unit_count); P2R_C13StreamParseIn *c13_tasks_inputs = push_array(scratch.arena, P2R_C13StreamParseIn, comp_unit_count); ASYNC_Task **c13_tasks = push_array(scratch.arena, ASYNC_Task *, comp_unit_count); for(U64 idx = 0; idx < comp_unit_count; idx += 1) { PDB_CompUnit *unit = comp_units->units[idx]; sym_tasks_inputs[idx].data = pdb_data_from_unit_range(msf, unit, PDB_DbiCompUnitRange_Symbols); sym_tasks[idx] = async_task_launch(scratch.arena, p2r_symbol_stream_parse_work, .input = &sym_tasks_inputs[idx]); c13_tasks_inputs[idx].data = pdb_data_from_unit_range(msf, unit, PDB_DbiCompUnitRange_C13); c13_tasks_inputs[idx].strtbl = raw_strtbl; c13_tasks_inputs[idx].coff_sections = coff_sections; c13_tasks[idx] = async_task_launch(scratch.arena, p2r_c13_stream_parse_work, .input = &c13_tasks_inputs[idx]); } //- rjf: join tasks for(U64 idx = 0; idx < comp_unit_count; idx += 1) { sym_for_unit[idx] = async_task_join_struct(sym_tasks[idx], CV_SymParsed); c13_for_unit[idx] = async_task_join_struct(c13_tasks[idx], CV_C13Parsed); } } ////////////////////////////////////////////////////////////// //- rjf: determine architecture // RDI_Arch arch = c2r_rdi_arch_from_coff_machine(dbi->machine_type); U64 arch_addr_size = rdi_addr_size_from_arch(arch); ////////////////////////////////////////////////////////////// //- rjf: join EXE hash // U64 exe_hash = *async_task_join_struct(exe_hash_task, U64); ////////////////////////////////////////////////////////////// //- rjf: build binary sections list // RDIM_BinarySectionList binary_sections = c2r_rdi_binary_sections_from_coff_sections(arena, str8_zero(), str8_zero(), coff_sections.count, coff_sections.v); ////////////////////////////////////////////////////////////// //- rjf: produce top-level-info // RDIM_TopLevelInfo top_level_info = rdim_make_top_level_info(in->image_name, arch_from_coff_machine(dbi->machine_type), exe_hash, binary_sections); ////////////////////////////////////////////////////////////// //- rjf: kick off unit conversion & source file collection // P2R_UnitConvertIn unit_convert_in = {strtbl, coff_sections, comp_units, comp_unit_contributions, sym_for_unit, c13_for_unit}; ASYNC_Task *unit_convert_task = async_task_launch(scratch.arena, p2r_units_convert_work, .input = &unit_convert_in); ////////////////////////////////////////////////////////////// //- rjf: join global sym stream parse // CV_SymParsed *sym = async_task_join_struct(sym_parse_task, CV_SymParsed); ////////////////////////////// //- rjf: predict symbol count // U64 symbol_count_prediction = 0; ProfScope("predict symbol count") { U64 rec_range_count = 0; if(sym != 0) { rec_range_count += sym->sym_ranges.count; } for(U64 comp_unit_idx = 0; comp_unit_idx < comp_unit_count; comp_unit_idx += 1) { CV_SymParsed *unit_sym = sym_for_unit[comp_unit_idx]; rec_range_count += unit_sym->sym_ranges.count; } symbol_count_prediction = rec_range_count/8; if(symbol_count_prediction < 256) { symbol_count_prediction = 256; } } ////////////////////////////////////////////////////////////// //- rjf: kick off link name map production // P2R_LinkNameMap link_name_map__in_progress = {0}; P2R_LinkNameMapBuildIn link_name_map_build_in = {0}; ASYNC_Task *link_name_map_task = 0; if(sym != 0) ProfScope("kick off link name map build task") { link_name_map__in_progress.buckets_count = symbol_count_prediction; link_name_map__in_progress.buckets = push_array(arena, P2R_LinkNameNode *, link_name_map__in_progress.buckets_count); link_name_map_build_in.sym = sym; link_name_map_build_in.coff_sections = coff_sections; link_name_map_build_in.link_name_map = &link_name_map__in_progress; link_name_map_task = async_task_launch(scratch.arena, p2r_link_name_map_build_work, .input = &link_name_map_build_in); } ////////////////////////////////////////////////////////////// //- rjf: join ipi/tpi hash/leaf parses // PDB_TpiHashParsed *tpi_hash = 0; CV_LeafParsed *tpi_leaf = 0; PDB_TpiHashParsed *ipi_hash = 0; CV_LeafParsed *ipi_leaf = 0; { tpi_hash = async_task_join_struct(tpi_hash_task, PDB_TpiHashParsed); tpi_leaf = async_task_join_struct(tpi_leaf_task, CV_LeafParsed); ipi_hash = async_task_join_struct(ipi_hash_task, PDB_TpiHashParsed); ipi_leaf = async_task_join_struct(ipi_leaf_task, CV_LeafParsed); } ////////////////////////////////////////////////////////////// //- rjf: types pass 1: construct all types from TPI // // this doesn't gather struct/class/union/enum members, which is done by // subsequent passes, to build RDI "UDT" information, which is distinct // from regular type info. // RDIM_Type **itype_type_ptrs = 0; RDIM_TypeChunkList all_types = rdim_init_type_chunk_list(arena, arch); #define p2r_type_ptr_from_itype(itype) (((itype) < tpi_leaf->itype_opl) ? itype_type_ptrs[itype] : 0) if(in->flags & RC_Flag_Types) ProfScope("types pass 1: construct all root/stub types from TPI") { itype_type_ptrs = push_array(arena, RDIM_Type *, tpi_leaf->itype_opl); ////////////////////////// //- build basic types // { RDIM_DataModel data_model = rdim_infer_data_model(OperatingSystem_Windows, top_level_info.arch); RDI_TypeKind short_type = rdim_short_type_from_data_model(data_model); RDI_TypeKind long_type = rdim_long_type_from_data_model(data_model); RDI_TypeKind long_long_type = rdim_long_long_type_from_data_model(data_model); RDI_TypeKind ushort_type = rdim_unsigned_short_type_from_data_model(data_model); RDI_TypeKind ulong_type = rdim_unsigned_long_type_from_data_model(data_model); RDI_TypeKind ulong_long_type = rdim_unsigned_long_long_type_from_data_model(data_model); RDI_TypeKind ptr_type = rdim_pointer_size_t_type_from_data_model(data_model); struct { char * name; RDI_TypeKind kind_rdi; CV_LeafKind kind_cv; B32 make_pointer_near; B32 make_pointer_32; B32 make_pointer_64; } table[] = { { "" , RDI_TypeKind_NULL , CV_BasicType_NOTYPE , 0, 0, 0 }, { "void" , RDI_TypeKind_Void , CV_BasicType_VOID , 1, 1, 1 }, { "HRESULT" , RDI_TypeKind_Handle , CV_BasicType_HRESULT , 0, 1, 1 }, { "signed char" , RDI_TypeKind_Char8 , CV_BasicType_CHAR , 1, 1, 1 }, { "short" , short_type , CV_BasicType_SHORT , 1, 1, 1 }, { "long" , long_type , CV_BasicType_LONG , 1, 1, 1 }, { "long long" , long_long_type , CV_BasicType_QUAD , 1, 1, 1 }, { "__int128" , RDI_TypeKind_S128 , CV_BasicType_OCT , 1, 1, 1 }, // Clang type { "unsigned char" , RDI_TypeKind_UChar8 , CV_BasicType_UCHAR , 1, 1, 1 }, { "unsigned short" , ushort_type , CV_BasicType_USHORT , 1, 1, 1 }, { "unsigned long" , ulong_type , CV_BasicType_ULONG , 1, 1, 1 }, { "unsigned long long" , ulong_long_type , CV_BasicType_UQUAD , 1, 1, 1 }, { "__uint128" , RDI_TypeKind_U128 , CV_BasicType_UOCT , 1, 1, 1 }, // Clang type { "bool" , RDI_TypeKind_S8 , CV_BasicType_BOOL8 , 1, 1, 1 }, { "__bool16" , RDI_TypeKind_S16 , CV_BasicType_BOOL16 , 1, 1, 1 }, // not real C type { "__bool32" , RDI_TypeKind_S32 , CV_BasicType_BOOL32 , 1, 1, 1 }, // not real C type { "float" , RDI_TypeKind_F32 , CV_BasicType_FLOAT32 , 1, 1, 1 }, { "double" , RDI_TypeKind_F64 , CV_BasicType_FLOAT64 , 1, 1, 1 }, { "long double" , RDI_TypeKind_F80 , CV_BasicType_FLOAT80 , 1, 1, 1 }, { "__float128" , RDI_TypeKind_F128 , CV_BasicType_FLOAT128 , 1, 1, 1 }, // Clang type { "__float48" , RDI_TypeKind_F48 , CV_BasicType_FLOAT48 , 1, 1, 1 }, // not real C type { "__float32pp" , RDI_TypeKind_F32PP , CV_BasicType_FLOAT32PP , 1, 1, 1 }, // not real C type { "_Complex float" , RDI_TypeKind_ComplexF32 , CV_BasicType_COMPLEX32 , 0, 0, 0 }, { "_Complex double" , RDI_TypeKind_ComplexF64 , CV_BasicType_COMPLEX64 , 0, 0, 0 }, { "_Complex long double" , RDI_TypeKind_ComplexF80 , CV_BasicType_COMPLEX80 , 0, 0, 0 }, { "_Complex __float128" , RDI_TypeKind_ComplexF128, CV_BasicType_COMPLEX128 , 0, 0, 0 }, { "__int8" , RDI_TypeKind_S8 , CV_BasicType_INT8 , 1, 1, 1 }, { "__uint8" , RDI_TypeKind_U8 , CV_BasicType_UINT8 , 1, 1, 1 }, { "__int16" , RDI_TypeKind_S16 , CV_BasicType_INT16 , 1, 1, 1 }, { "__uint16" , RDI_TypeKind_U16 , CV_BasicType_UINT16 , 1, 1, 1 }, { "int" , RDI_TypeKind_S32 , CV_BasicType_INT32 , 1, 1, 1 }, { "unsigned int" , RDI_TypeKind_U32 , CV_BasicType_UINT32 , 1, 1, 1 }, { "__int64" , RDI_TypeKind_S64 , CV_BasicType_INT64 , 1, 1, 1 }, { "__uint64" , RDI_TypeKind_U64 , CV_BasicType_UINT64 , 1, 1, 1 }, { "__int128" , RDI_TypeKind_S128 , CV_BasicType_INT128 , 1, 1, 1 }, { "__uint128" , RDI_TypeKind_U128 , CV_BasicType_UINT128 , 1, 1, 1 }, { "char" , RDI_TypeKind_Char8 , CV_BasicType_RCHAR , 1, 1, 1 }, // always ASCII { "wchar_t" , RDI_TypeKind_UChar16 , CV_BasicType_WCHAR , 1, 1, 1 }, // on windows always UTF-16 { "char8_t" , RDI_TypeKind_Char8 , CV_BasicType_CHAR8 , 1, 1, 1 }, // always UTF-8 { "char16_t" , RDI_TypeKind_Char16 , CV_BasicType_CHAR16 , 1, 1, 1 }, // always UTF-16 { "char32_t" , RDI_TypeKind_Char32 , CV_BasicType_CHAR32 , 1, 1, 1 }, // always UTF-32 { "__pointer" , ptr_type , CV_BasicType_PTR , 0, 0, 0 } }; for(U64 i = 0; i < ArrayCount(table); i += 1) { RDIM_Type *type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); type->kind = RDI_TypeKind_Alias; type->name = str8_cstring(table[i].name); type->direct_type = rdim_builtin_type_from_kind(all_types, table[i].kind_rdi); itype_type_ptrs[table[i].kind_cv] = type; if(table[i].make_pointer_near) { CV_TypeIndex near_ptr_itype = table[i].kind_cv | 0x100; RDIM_Type *ptr_near = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); ptr_near->kind = RDI_TypeKind_Ptr; ptr_near->byte_size = 2; ptr_near->direct_type = type; itype_type_ptrs[near_ptr_itype] = ptr_near; } if(table[i].make_pointer_32) { CV_TypeIndex ptr_32_itype = table[i].kind_cv | 0x400; RDIM_Type *ptr_32 = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); ptr_32->kind = RDI_TypeKind_Ptr; ptr_32->byte_size = 4; ptr_32->direct_type = type; itype_type_ptrs[ptr_32_itype] = ptr_32; } if(table[i].make_pointer_64) { CV_TypeIndex ptr_64_itype = table[i].kind_cv | 0x600; RDIM_Type *ptr_64 = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); ptr_64->kind = RDI_TypeKind_Ptr; ptr_64->byte_size = 8; ptr_64->direct_type = type; itype_type_ptrs[ptr_64_itype] = ptr_64; } } } ////////////////////////// //- rjf: build complex type // for(CV_TypeId itype = tpi_leaf->itype_first; itype < tpi_leaf->itype_opl; itype += 1) { RDIM_Type *dst_type = 0; CV_RecRange *range = &tpi_leaf->leaf_ranges.ranges[itype-tpi_leaf->itype_first]; CV_LeafKind kind = range->hdr.kind; U64 header_struct_size = cv_header_struct_size_from_leaf_kind(kind); if(range->off+range->hdr.size <= tpi_leaf->data.size && range->off+2+header_struct_size <= tpi_leaf->data.size && range->hdr.size >= 2) { U8 *itype_leaf_first = tpi_leaf->data.str + range->off+2; U8 *itype_leaf_opl = itype_leaf_first + range->hdr.size-2; switch(kind) { //- rjf: MODIFIER case CV_LeafKind_MODIFIER: { // rjf: unpack leaf CV_LeafModifier *lf = (CV_LeafModifier *)itype_leaf_first; // rjf: cv -> rdi flags RDI_TypeModifierFlags flags = 0; if(lf->flags & CV_ModifierFlag_Const) {flags |= RDI_TypeModifierFlag_Const;} if(lf->flags & CV_ModifierFlag_Volatile) {flags |= RDI_TypeModifierFlag_Volatile;} // rjf: fill type if(flags == 0) { dst_type = p2r_type_ptr_from_itype(lf->itype); } else { dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); dst_type->kind = RDI_TypeKind_Modifier; dst_type->flags = flags; dst_type->direct_type = p2r_type_ptr_from_itype(lf->itype); dst_type->byte_size = dst_type->direct_type ? dst_type->direct_type->byte_size : 0; } }break; //- rjf: POINTER case CV_LeafKind_POINTER: { // TODO(rjf): if ptr_mode in {PtrMem, PtrMethod} then output a member pointer instead // rjf: unpack leaf CV_LeafPointer *lf = (CV_LeafPointer *)itype_leaf_first; RDIM_Type *direct_type = p2r_type_ptr_from_itype(lf->itype); CV_PointerKind ptr_kind = CV_PointerAttribs_Extract_Kind(lf->attribs); CV_PointerMode ptr_mode = CV_PointerAttribs_Extract_Mode(lf->attribs); U32 ptr_size = CV_PointerAttribs_Extract_Size(lf->attribs); // rjf: cv -> rdi modifier flags RDI_TypeModifierFlags modifier_flags = 0; if(lf->attribs & CV_PointerAttrib_Const) {modifier_flags |= RDI_TypeModifierFlag_Const;} if(lf->attribs & CV_PointerAttrib_Volatile) {modifier_flags |= RDI_TypeModifierFlag_Volatile;} if(lf->attribs & CV_PointerAttrib_Restricted) {modifier_flags |= RDI_TypeModifierFlag_Restrict;} // rjf: cv info -> rdi pointer type kind RDI_TypeKind type_kind = RDI_TypeKind_Ptr; { if(lf->attribs & CV_PointerAttrib_LRef) { type_kind = RDI_TypeKind_LRef; } else if(lf->attribs & CV_PointerAttrib_RRef) { type_kind = RDI_TypeKind_RRef; } if(ptr_mode == CV_PointerMode_LRef) { type_kind = RDI_TypeKind_LRef; } else if(ptr_mode == CV_PointerMode_RRef) { type_kind = RDI_TypeKind_RRef; } } // rjf: fill type if(modifier_flags != 0) { RDIM_Type *pointer_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); dst_type->kind = RDI_TypeKind_Modifier; dst_type->flags = modifier_flags; dst_type->direct_type = pointer_type; dst_type->byte_size = arch_addr_size; pointer_type->kind = type_kind; pointer_type->byte_size = arch_addr_size; pointer_type->direct_type = direct_type; } else { dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); dst_type->kind = type_kind; dst_type->byte_size = arch_addr_size; dst_type->direct_type = direct_type; } }break; //- rjf: PROCEDURE case CV_LeafKind_PROCEDURE: { // TODO(rjf): handle call_kind & attribs // rjf: unpack leaf CV_LeafProcedure *lf = (CV_LeafProcedure *)itype_leaf_first; RDIM_Type *ret_type = p2r_type_ptr_from_itype(lf->ret_itype); // rjf: fill type's basics dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); dst_type->kind = RDI_TypeKind_Function; dst_type->byte_size = arch_addr_size; dst_type->direct_type = ret_type; // rjf: unpack arglist range CV_RecRange *arglist_range = &tpi_leaf->leaf_ranges.ranges[lf->arg_itype-tpi_leaf->itype_first]; if(arglist_range->hdr.kind != CV_LeafKind_ARGLIST || arglist_range->hdr.size<2 || arglist_range->off + arglist_range->hdr.size > tpi_leaf->data.size) { break; } U8 *arglist_first = tpi_leaf->data.str + arglist_range->off + 2; U8 *arglist_opl = arglist_first+arglist_range->hdr.size-2; if(arglist_first + sizeof(CV_LeafArgList) > arglist_opl) { break; } // rjf: unpack arglist info CV_LeafArgList *arglist = (CV_LeafArgList*)arglist_first; CV_TypeId *arglist_itypes_base = (CV_TypeId *)(arglist+1); U32 arglist_itypes_count = arglist->count; // rjf: build param type array RDIM_Type **params = push_array(arena, RDIM_Type *, arglist_itypes_count); for(U32 idx = 0; idx < arglist_itypes_count; idx += 1) { params[idx] = p2r_type_ptr_from_itype(arglist_itypes_base[idx]); } // rjf: fill dst type dst_type->count = arglist_itypes_count; dst_type->param_types = params; }break; //- rjf: MFUNCTION case CV_LeafKind_MFUNCTION: { // TODO(rjf): handle call_kind & attribs // TODO(rjf): preserve "this_adjust" // rjf: unpack leaf CV_LeafMFunction *lf = (CV_LeafMFunction *)itype_leaf_first; RDIM_Type *ret_type = p2r_type_ptr_from_itype(lf->ret_itype); // rjf: fill type dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); dst_type->kind = (lf->this_itype != 0) ? RDI_TypeKind_Method : RDI_TypeKind_Function; dst_type->byte_size = arch_addr_size; dst_type->direct_type = ret_type; // rjf: unpack arglist range CV_RecRange *arglist_range = &tpi_leaf->leaf_ranges.ranges[lf->arg_itype-tpi_leaf->itype_first]; if(arglist_range->hdr.kind != CV_LeafKind_ARGLIST || arglist_range->hdr.size<2 || arglist_range->off + arglist_range->hdr.size > tpi_leaf->data.size) { break; } U8 *arglist_first = tpi_leaf->data.str + arglist_range->off + 2; U8 *arglist_opl = arglist_first+arglist_range->hdr.size-2; if(arglist_first + sizeof(CV_LeafArgList) > arglist_opl) { break; } // rjf: unpack arglist info CV_LeafArgList *arglist = (CV_LeafArgList*)arglist_first; CV_TypeId *arglist_itypes_base = (CV_TypeId *)(arglist+1); U32 arglist_itypes_count = arglist->count; // rjf: build param type array U64 num_this_extras = 1; if(lf->this_itype == 0) { num_this_extras = 0; } RDIM_Type **params = push_array(arena, RDIM_Type *, arglist_itypes_count+num_this_extras); for(U32 idx = 0; idx < arglist_itypes_count; idx += 1) { params[idx+num_this_extras] = p2r_type_ptr_from_itype(arglist_itypes_base[idx]); } if(lf->this_itype != 0) { params[0] = p2r_type_ptr_from_itype(lf->this_itype); } // rjf: fill dst type dst_type->count = arglist_itypes_count+num_this_extras; dst_type->param_types = params; }break; //- rjf: BITFIELD case CV_LeafKind_BITFIELD: { // rjf: unpack leaf CV_LeafBitField *lf = (CV_LeafBitField *)itype_leaf_first; RDIM_Type *direct_type = p2r_type_ptr_from_itype(lf->itype); // rjf: fill type dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); dst_type->kind = RDI_TypeKind_Bitfield; dst_type->off = lf->pos; dst_type->count = lf->len; dst_type->byte_size = direct_type?direct_type->byte_size:0; dst_type->direct_type = direct_type; }break; //- rjf: ARRAY case CV_LeafKind_ARRAY: { // rjf: unpack leaf CV_LeafArray *lf = (CV_LeafArray *)itype_leaf_first; RDIM_Type *direct_type = p2r_type_ptr_from_itype(lf->entry_itype); U8 *numeric_ptr = (U8*)(lf + 1); CV_NumericParsed array_count = cv_numeric_from_data_range(numeric_ptr, itype_leaf_opl); U64 full_size = cv_u64_from_numeric(&array_count); // rjf: fill type dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); dst_type->kind = RDI_TypeKind_Array; dst_type->direct_type = direct_type; dst_type->byte_size = full_size; }break; //- rjf: CLASS/STRUCTURE case CV_LeafKind_CLASS: case CV_LeafKind_STRUCTURE: { // TODO(rjf): handle props // rjf: unpack leaf CV_LeafStruct *lf = (CV_LeafStruct *)itype_leaf_first; U8 *numeric_ptr = (U8*)(lf + 1); CV_NumericParsed size = cv_numeric_from_data_range(numeric_ptr, itype_leaf_opl); U64 size_u64 = cv_u64_from_numeric(&size); U8 *name_ptr = numeric_ptr + size.encoded_size; String8 name = str8_cstring_capped(name_ptr, itype_leaf_opl); // rjf: fill type dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); if(lf->props & CV_TypeProp_FwdRef) { dst_type->kind = (kind == CV_LeafKind_CLASS ? RDI_TypeKind_IncompleteClass : RDI_TypeKind_IncompleteStruct); } else { dst_type->kind = (kind == CV_LeafKind_CLASS ? RDI_TypeKind_Class : RDI_TypeKind_Struct); } B32 do_unique_name_lookup = (((lf->props & CV_TypeProp_Scoped) != 0) && ((lf->props & CV_TypeProp_HasUniqueName) != 0)); if(do_unique_name_lookup) { U8 *unique_name_ptr = name_ptr + name.size + 1; dst_type->link_name = str8_cstring_capped(unique_name_ptr, itype_leaf_opl); } dst_type->name = name; dst_type->byte_size = safe_cast_u32(size_u64); }break; //- rjf: CLASS2/STRUCT2 case CV_LeafKind_CLASS2: case CV_LeafKind_STRUCT2: { // TODO(rjf): handle props // rjf: unpack leaf CV_LeafStruct2 *lf = (CV_LeafStruct2 *)itype_leaf_first; U8 *numeric_ptr = (U8*)(lf + 1); CV_NumericParsed size = cv_numeric_from_data_range(numeric_ptr, itype_leaf_opl); U64 size_u64 = cv_u64_from_numeric(&size); U8 *name_ptr = numeric_ptr + size.encoded_size; String8 name = str8_cstring_capped(name_ptr, itype_leaf_opl); // rjf: fill type dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); if(lf->props & CV_TypeProp_FwdRef) { dst_type->kind = (kind == CV_LeafKind_CLASS2 ? RDI_TypeKind_IncompleteClass : RDI_TypeKind_IncompleteStruct); dst_type->name = name; } else { dst_type->kind = (kind == CV_LeafKind_CLASS2 ? RDI_TypeKind_Class : RDI_TypeKind_Struct); dst_type->byte_size = (U32)size_u64; dst_type->name = name; } B32 do_unique_name_lookup = (((lf->props & CV_TypeProp_Scoped) != 0) && ((lf->props & CV_TypeProp_HasUniqueName) != 0)); if(do_unique_name_lookup) { U8 *unique_name_ptr = name_ptr + name.size + 1; dst_type->link_name = str8_cstring_capped(unique_name_ptr, itype_leaf_opl); } }break; //- rjf: UNION case CV_LeafKind_UNION: { // TODO(rjf): handle props // rjf: unpack leaf CV_LeafUnion *lf = (CV_LeafUnion *)itype_leaf_first; U8 *numeric_ptr = (U8*)(lf + 1); CV_NumericParsed size = cv_numeric_from_data_range(numeric_ptr, itype_leaf_opl); U64 size_u64 = cv_u64_from_numeric(&size); U8 *name_ptr = numeric_ptr + size.encoded_size; String8 name = str8_cstring_capped(name_ptr, itype_leaf_opl); // rjf: fill type dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); if(lf->props & CV_TypeProp_FwdRef) { dst_type->kind = RDI_TypeKind_IncompleteUnion; dst_type->name = name; } else { dst_type->kind = RDI_TypeKind_Union; dst_type->byte_size = (U32)size_u64; dst_type->name = name; } B32 do_unique_name_lookup = (((lf->props & CV_TypeProp_Scoped) != 0) && ((lf->props & CV_TypeProp_HasUniqueName) != 0)); if(do_unique_name_lookup) { U8 *unique_name_ptr = name_ptr + name.size + 1; dst_type->link_name = str8_cstring_capped(unique_name_ptr, itype_leaf_opl); } }break; //- rjf: ENUM case CV_LeafKind_ENUM: { // TODO(rjf): handle props // rjf: unpack leaf CV_LeafEnum *lf = (CV_LeafEnum *)itype_leaf_first; RDIM_Type *direct_type = p2r_type_ptr_from_itype(lf->base_itype); U8 *name_ptr = (U8 *)(lf + 1); String8 name = str8_cstring_capped(name_ptr, itype_leaf_opl); // rjf: fill type dst_type = rdim_type_chunk_list_push(arena, &all_types, tpi_leaf->itype_opl); if(lf->props & CV_TypeProp_FwdRef) { dst_type->kind = RDI_TypeKind_IncompleteEnum; dst_type->name = name; } else { dst_type->kind = RDI_TypeKind_Enum; dst_type->direct_type = direct_type; dst_type->byte_size = direct_type ? direct_type->byte_size : 0; dst_type->name = name; } B32 do_unique_name_lookup = (((lf->props & CV_TypeProp_Scoped) != 0) && ((lf->props & CV_TypeProp_HasUniqueName) != 0)); if(do_unique_name_lookup) { U8 *unique_name_ptr = name_ptr + name.size + 1; dst_type->link_name = str8_cstring_capped(unique_name_ptr, itype_leaf_opl); } }break; } } //- rjf: store finalized type to this itype's slot itype_type_ptrs[itype] = dst_type; } } ////////////////////////////////////////////////////////////// //- rjf: types pass 2: kick off UDT build // U64 udt_task_size_itypes = 4096; U64 udt_tasks_count = (tpi_leaf->itype_opl+(udt_task_size_itypes-1))/udt_task_size_itypes; P2R_UDTConvertIn *udt_tasks_inputs = push_array(scratch.arena, P2R_UDTConvertIn, udt_tasks_count); ASYNC_Task **udt_tasks = push_array(scratch.arena, ASYNC_Task *, udt_tasks_count); if(in->flags & RC_Flag_UDTs) ProfScope("types pass 2: kick off UDT build") { for(U64 idx = 0; idx < udt_tasks_count; idx += 1) { udt_tasks_inputs[idx].tpi_leaf = tpi_leaf; udt_tasks_inputs[idx].itype_first = idx*udt_task_size_itypes; udt_tasks_inputs[idx].itype_opl = udt_tasks_inputs[idx].itype_first + udt_task_size_itypes; udt_tasks_inputs[idx].itype_opl = ClampTop(udt_tasks_inputs[idx].itype_opl, tpi_leaf->itype_opl); udt_tasks_inputs[idx].itype_type_ptrs = itype_type_ptrs; udt_tasks[idx] = async_task_launch(scratch.arena, p2r_udt_convert_work, .input = &udt_tasks_inputs[idx]); } } ////////////////////////////////////////////////////////////// //- rjf: join link name map building task // P2R_LinkNameMap *link_name_map = 0; ProfScope("join link name map building task") { async_task_join(link_name_map_task); link_name_map = &link_name_map__in_progress; } ////////////////////////////////////////////////////////////// //- rjf: join unit conversion & src file & line table tasks // RDIM_UnitChunkList all_units = {0}; RDIM_SrcFileChunkList all_src_files = {0}; RDIM_LineTableChunkList all_line_tables = {0}; RDIM_LineTable **units_first_inline_site_line_tables = 0; ProfScope("join unit conversion & src file tasks") { P2R_UnitConvertOut *out = async_task_join_struct(unit_convert_task, P2R_UnitConvertOut); all_units = out->units; all_src_files = out->src_files; all_line_tables = out->line_tables; units_first_inline_site_line_tables = out->units_first_inline_site_line_tables; } ////////////////////////////////////////////////////////////// //- rjf: produce symbols from all streams // RDIM_SymbolChunkList all_procedures = {0}; RDIM_SymbolChunkList all_global_variables = {0}; RDIM_SymbolChunkList all_thread_variables = {0}; RDIM_ScopeChunkList all_scopes = {0}; RDIM_InlineSiteChunkList all_inline_sites = {0}; ProfScope("produce symbols from all streams") { //////////////////////////// //- rjf: kick off all symbol conversion tasks // U64 global_stream_subdivision_tasks_count = sym ? (sym->sym_ranges.count+16383)/16384 : 0; U64 global_stream_syms_per_task = sym ? sym->sym_ranges.count/global_stream_subdivision_tasks_count : 0; U64 tasks_count = comp_unit_count + global_stream_subdivision_tasks_count; P2R_SymbolStreamConvertIn *tasks_inputs = push_array(scratch.arena, P2R_SymbolStreamConvertIn, tasks_count); ASYNC_Task **tasks = push_array(scratch.arena, ASYNC_Task *, tasks_count); ProfScope("kick off all symbol conversion tasks") { for(U64 idx = 0; idx < tasks_count; idx += 1) { tasks_inputs[idx].arch = arch; tasks_inputs[idx].coff_sections = coff_sections; tasks_inputs[idx].tpi_hash = tpi_hash; tasks_inputs[idx].tpi_leaf = tpi_leaf; tasks_inputs[idx].ipi_leaf = ipi_leaf; tasks_inputs[idx].itype_type_ptrs = itype_type_ptrs; tasks_inputs[idx].link_name_map = link_name_map; if(idx < global_stream_subdivision_tasks_count) { tasks_inputs[idx].sym = sym; tasks_inputs[idx].sym_ranges_first= idx*global_stream_syms_per_task; tasks_inputs[idx].sym_ranges_opl = tasks_inputs[idx].sym_ranges_first + global_stream_syms_per_task; tasks_inputs[idx].sym_ranges_opl = ClampTop(tasks_inputs[idx].sym_ranges_opl, sym->sym_ranges.count); } else { tasks_inputs[idx].sym = sym_for_unit[idx-global_stream_subdivision_tasks_count]; tasks_inputs[idx].sym_ranges_first= 0; tasks_inputs[idx].sym_ranges_opl = sym_for_unit[idx-global_stream_subdivision_tasks_count]->sym_ranges.count; tasks_inputs[idx].first_inline_site_line_table = units_first_inline_site_line_tables[idx-global_stream_subdivision_tasks_count]; } tasks[idx] = async_task_launch(scratch.arena, p2r_symbol_stream_convert_work, .input = &tasks_inputs[idx]); } } //////////////////////////// //- rjf: join tasks, merge with top-level collections // ProfScope("join tasks, merge with top-level collections") { for(U64 idx = 0; idx < tasks_count; idx += 1) { P2R_SymbolStreamConvertOut *out = async_task_join_struct(tasks[idx], P2R_SymbolStreamConvertOut); rdim_symbol_chunk_list_concat_in_place(&all_procedures, &out->procedures); rdim_symbol_chunk_list_concat_in_place(&all_global_variables, &out->global_variables); rdim_symbol_chunk_list_concat_in_place(&all_thread_variables, &out->thread_variables); rdim_scope_chunk_list_concat_in_place(&all_scopes, &out->scopes); rdim_inline_site_chunk_list_concat_in_place(&all_inline_sites,&out->inline_sites); } } } ////////////////////////////////////////////////////////////// //- rjf: types pass 5: join UDT build tasks // RDIM_UDTChunkList all_udts = {0}; for(U64 idx = 0; idx < udt_tasks_count; idx += 1) { RDIM_UDTChunkList *udts = async_task_join_struct(udt_tasks[idx], RDIM_UDTChunkList); rdim_udt_chunk_list_concat_in_place(&all_udts, udts); } ////////////////////////////////////////////////////////////// //- rjf: fill output // RDIM_BakeParams *out = push_array(arena, RDIM_BakeParams, 1); { out->top_level_info = top_level_info; out->binary_sections = binary_sections; out->units = all_units; out->types = all_types; out->udts = all_udts; out->src_files = all_src_files; out->line_tables = all_line_tables; out->global_variables = all_global_variables; out->thread_variables = all_thread_variables; out->procedures = all_procedures; out->scopes = all_scopes; out->inline_sites = all_inline_sites; } scratch_end(scratch); return out; } //////////////////////////////// internal B32 p2r_has_symbol_ref(String8 msf_data, String8List symbol_list, MSF_RawStreamTable *st) { Temp scratch = scratch_begin(0,0); B32 has_ref = 0; String8 dbi_data = msf_data_from_stream_number(scratch.arena, msf_data, st, PDB_FixedStream_Dbi); PDB_DbiParsed *dbi = pdb_dbi_from_data(scratch.arena, dbi_data); if(dbi) { String8 gsi_data = msf_data_from_stream_number(scratch.arena, msf_data, st, dbi->gsi_sn); PDB_GsiParsed *gsi_parsed = pdb_gsi_from_data(scratch.arena, gsi_data); if(gsi_parsed) { String8 symbol_data = msf_data_from_stream_number(scratch.arena, msf_data, st, dbi->sym_sn); for(String8Node *symbol_n = symbol_list.first; symbol_n != 0; symbol_n = symbol_n->next) { U64 symbol_off = pdb_gsi_symbol_from_string(gsi_parsed, symbol_data, symbol_n->string); if(symbol_off < symbol_data.size) { has_ref = 1; break; } } } } scratch_end(scratch); return has_ref; } internal B32 p2r_has_file_ref(String8 msf_data, String8List file_list, MSF_RawStreamTable *st) { Temp scratch = scratch_begin(0,0); B32 has_ref = 0; String8 info_data = msf_data_from_stream_number(scratch.arena, msf_data, st, PDB_FixedStream_Info); PDB_Info *info = pdb_info_from_data(scratch.arena, info_data); if(info) { PDB_NamedStreamTable *named_streams = pdb_named_stream_table_from_info(scratch.arena, info); if(named_streams) { MSF_StreamNumber strtbl_sn = named_streams->sn[PDB_NamedStream_StringTable]; String8 strtbl_data = msf_data_from_stream_number(scratch.arena, msf_data, st, strtbl_sn); PDB_Strtbl *strtbl = pdb_strtbl_from_data(scratch.arena, strtbl_data); if(strtbl) { for(String8Node *file_n = file_list.first; file_n != 0; file_n = file_n->next) { U32 off = pdb_strtbl_off_from_string(strtbl, file_n->string); if(off != max_U32) { has_ref = 1; break; } } } } } scratch_end(scratch); return has_ref; } internal B32 p2r_has_symbol_or_file_ref(String8 msf_data, String8List symbol_list, String8List file_list) { Temp scratch = scratch_begin(0,0); B32 has_ref = 0; MSF_RawStreamTable *st = msf_raw_stream_table_from_data(scratch.arena, msf_data); if(!has_ref && symbol_list.node_count) { has_ref = p2r_has_symbol_ref(msf_data, symbol_list, st); } if(!has_ref && file_list.node_count) { has_ref = p2r_has_file_ref(msf_data, file_list, st); } scratch_end(scratch); return has_ref; }