Files
raddebugger/src/linker/lnk_obj.c
T

1595 lines
63 KiB
C

// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
internal String8
lnk_loc_from_obj(Arena *arena, LNK_Obj *obj)
{
String8 obj_path = str8_skip_last_slash(obj ? obj->path : str8_lit("RADLINK"));
String8 lib_path = str8_skip_last_slash(lnk_obj_get_lib_path(obj));
String8 result;
if (lib_path.size) {
result = push_str8f(arena, "%S(%S)", lib_path, obj_path);
} else {
result = push_str8_copy(arena, obj_path);
}
return result;
}
internal void
lnk_error_obj(LNK_ErrorCode code, LNK_Obj *obj, char *fmt, ...)
{
va_list args; va_start(args, fmt);
String8 obj_path = obj ? obj->path : str8_zero();
String8 lib_path = lnk_obj_get_lib_path(obj);
lnk_error_with_loc_fv(code, obj_path, lib_path, fmt, args);
va_end(args);
}
internal void
lnk_error_input_obj(LNK_ErrorCode code, LNK_Input *input, char *fmt, ...)
{
va_list args; va_start(args, fmt);
LNK_LibMemberRef *link_member = input->link_member;
LNK_Lib *link_lib = link_member ? link_member->lib : 0;
lnk_error_with_loc_fv(code, input->path, link_lib ? link_lib->path : str8_zero(), fmt, args);
va_end(args);
}
internal LNK_Obj **
lnk_array_from_obj_list(Arena *arena, LNK_ObjList list)
{
LNK_Obj **arr = push_array_no_zero(arena, LNK_Obj *, list.count);
U64 idx = 0;
for (LNK_ObjNode *node = list.first; node != 0; node = node->next, ++idx) {
arr[idx] = &node->data;
}
return arr;
}
internal
THREAD_POOL_TASK_FUNC(lnk_obj_initer)
{
LNK_ObjIniter *task = raw_task;
LNK_Input *input = task->inputs[task_id];
LNK_Obj *obj = &task->objs[task_id].data;
//ProfBeginV("Init Obj [%S%s%S]", input->lib_path, (input->lib_path.size ? ": " : 0), input->path);
//
// parse obj header
//
COFF_FileHeaderInfo header = coff_file_header_info_from_data(input->data);
//
// set & check machine compatibility
//
if (header.machine != COFF_MachineType_Unknown) {
COFF_MachineType current_machine = ins_atomic_u32_eval_cond_assign(&task->machine, header.machine, COFF_MachineType_Unknown);
if (current_machine != COFF_MachineType_Unknown && current_machine != header.machine) {
lnk_error_input_obj(LNK_Error_IncompatibleMachine, input,
"conflicting machine types expected %S but got %S",
coff_string_from_machine_type(current_machine),
coff_string_from_machine_type(header.machine));
}
}
//
// extract COFF info
//
String8 raw_coff_section_table = str8_substr(input->data, header.section_table_range);
String8 raw_coff_symbol_table = str8_substr(input->data, header.symbol_table_range);
String8 raw_coff_string_table = str8_substr(input->data, header.string_table_range);
//
// error check section table / symbol table / string table
//
if (raw_coff_section_table.size != dim_1u64(header.section_table_range)) {
lnk_error_input_obj(LNK_Error_IllData, input, "corrupted file, unable to read section header table");
}
if (raw_coff_symbol_table.size != dim_1u64(header.symbol_table_range)) {
lnk_error_input_obj(LNK_Error_IllData, input, "corrupted file, unable to read symbol table");
}
if (raw_coff_string_table.size != dim_1u64(header.string_table_range)) {
lnk_error_input_obj(LNK_Error_IllData, input, "corrupted file, unable to read string table");
}
COFF_SectionHeader *section_headers = push_array(arena, COFF_SectionHeader, header.section_count_no_null + 1);
MemoryCopy(section_headers + 1, raw_coff_section_table.str, raw_coff_section_table.size);
//
// section table pass
// - error check headers fields
// - collect section header flags
// - find debug info and meta-data leaders
//
COFF_SectionHeader *coff_section_table = (COFF_SectionHeader *)raw_coff_section_table.str;
U32 debug_t_section_number = 0;
U32 debug_p_section_number = 0;
U32 debug_h_section_number = 0;
U32 llvm_addrsig_section_number = 0;
for EachIndex(sect_idx, header.section_count_no_null) {
U64 section_number = sect_idx + 1;
COFF_SectionHeader *coff_sect_header = &coff_section_table[sect_idx];
COFF_SectionFlags *section_flags = &section_headers[section_number].flags;
String8 sect_name = coff_name_from_section_header(raw_coff_string_table, coff_sect_header);
*section_flags = coff_sect_header->flags & ~3; // linker reserves low 2 bits for internal flags
if (str8_starts_with(sect_name, str8_lit(".debug$"))) {
*section_flags |= LNK_SECTION_FLAG_DEBUG;
}
if (str8_ends_with(sect_name, str8_lit("$fo$"), 0) ||
str8_ends_with(sect_name, str8_lit("$fo_rvas$"), 0) ||
str8_ends_with(sect_name, str8_lit("$fo_bdd$"), 0)) {
*section_flags |= COFF_SectionFlag_LnkInfo;
}
if (str8_match(sect_name, str8_lit(".debug$T"), 0)) {
debug_t_section_number = section_number;
} else if (str8_match(sect_name, str8_lit(".debug$P"), 0)) {
debug_p_section_number = section_number;
} else if (str8_match(sect_name, str8_lit(".debug$H"), 0)) {
debug_h_section_number = section_number;
}
if (llvm_addrsig_section_number == 0 && str8_match(sect_name, str8_lit(".llvm_addrsig"), 0)) {
llvm_addrsig_section_number = section_number;
}
if (~*section_flags & COFF_SectionFlag_CntUninitializedData) {
if (coff_sect_header->fsize > 0) {
Rng1U64 sect_range = rng_1u64(coff_sect_header->foff, coff_sect_header->foff + coff_sect_header->fsize);
if (contains_1u64(header.header_range, coff_sect_header->foff) ||
(coff_sect_header->fsize > 0 && contains_1u64(header.header_range, sect_range.max-1))) {
lnk_error_input_obj(LNK_Error_IllData, input, "header (%S No. %#llx) defines out of bounds section data (file offsets point into file header)", sect_name, sect_idx+1);
}
if (contains_1u64(header.section_table_range, coff_sect_header->foff) ||
(coff_sect_header->fsize > 0 && contains_1u64(header.section_table_range, sect_range.max-1))) {
lnk_error_input_obj(LNK_Error_IllData, input, "header (%S No. %#llx) defines out of bounds section data (file offsets point into section header table)", sect_name, sect_idx+1);
}
if (contains_1u64(header.symbol_table_range, coff_sect_header->foff) ||
(coff_sect_header->fsize > 0 && contains_1u64(header.symbol_table_range, sect_range.max-1))) {
lnk_error_input_obj(LNK_Error_IllData, input, "header (%S No. %#llx) defines out of bounds section data (file offsets point into symbol table)", sect_name, sect_idx+1);
}
if (dim_1u64(sect_range) != coff_sect_header->fsize) {
lnk_error_input_obj(LNK_Error_IllData, input, "header (%S No. %#llx) defines out of bounds section data", sect_name, sect_idx+1);
}
}
}
}
//
// error check symbol table and cache name lengths for primary symbols
//
U64 primary_symbol_count = 0;
{
COFF_ParsedSymbol symbol;
for (U64 symbol_idx = 0; symbol_idx < header.symbol_count; symbol_idx += 1 + symbol.aux_symbol_count) {
symbol = coff_parse_symbol_no_name(header, raw_coff_symbol_table, symbol_idx);
primary_symbol_count += 1;
}
}
U64 symbol_block_count = CeilIntegerDiv(header.symbol_count, 64);
LNK_ObjSymbolArray symbols = {
.count = primary_symbol_count,
.primary_bits = bit_array_init32(arena, header.symbol_count),
.block_bases = push_array_no_zero(arena, U32, symbol_block_count),
.values = push_array_no_zero(arena, U64, primary_symbol_count),
.section_numbers = push_array_no_zero(arena, U32, primary_symbol_count),
.types = push_array_no_zero(arena, COFF_SymbolType, primary_symbol_count),
.storage_classes = push_array_no_zero(arena, COFF_SymStorageClass, primary_symbol_count),
.aux_counts = push_array_no_zero(arena, U8, primary_symbol_count),
.name_offsets = push_array_no_zero(arena, U32, primary_symbol_count),
.name_sizes = push_array_no_zero(arena, U32, primary_symbol_count),
};
{
U64 next_block = 0;
U32 primary_idx = 0;
COFF_ParsedSymbol symbol;
for (U64 symbol_idx = 0; symbol_idx < header.symbol_count; symbol_idx += (1 + symbol.aux_symbol_count)) {
symbol = coff_parse_symbol(header, raw_coff_string_table, raw_coff_symbol_table, symbol_idx);
// copy out primary symbols
{
U64 block_idx = symbol_idx >> 6;
while (next_block <= block_idx) { symbols.block_bases[next_block++] = primary_idx; }
bit_array_set_bit32(symbols.primary_bits, symbol_idx, 1);
symbols.values [primary_idx] = symbol.value;
symbols.section_numbers[primary_idx] = symbol.section_number;
symbols.types [primary_idx] = symbol.type;
symbols.storage_classes[primary_idx] = symbol.storage_class;
symbols.aux_counts [primary_idx] = symbol.aux_symbol_count;
symbols.name_offsets [primary_idx] = symbol.name.size ? safe_cast_u32(symbol.name.str - input->data.str) : 0;
symbols.name_sizes [primary_idx] = safe_cast_u32(symbol.name.size);
primary_idx += 1;
}
COFF_SymbolValueInterpType interp = coff_interp_symbol(symbol.section_number, symbol.value, symbol.storage_class);
if (interp == COFF_SymbolValueInterp_Regular) {
if (symbol.section_number == 0 || symbol.section_number > header.section_count_no_null) {
lnk_error_input_obj(LNK_Error_IllData, input, "symbol %S (No. 0x%x) points to an out of bounds section 0x%x", symbol.name, symbol_idx, symbol.section_number);
}
if (symbol.storage_class == COFF_SymStorageClass_Static && symbol.aux_symbol_count > 0) {
COFF_ComdatSelectType select;
U32 section_number = 0;
coff_parse_secdef(symbol, header.is_big_obj, &select, &section_number, 0, 0);
if (select == COFF_ComdatSelect_Associative) {
if (section_number == 0 || section_number > header.section_count_no_null) {
lnk_error_input_obj(LNK_Error_IllData, input, "section definition symbol %S (No. 0x%x) associates with an out of bounds section 0x%x", symbol.name, symbol_idx, section_number);
}
}
}
}
}
while (next_block < symbol_block_count) {
symbols.block_bases[next_block++] = primary_idx;
}
Assert(primary_idx == primary_symbol_count);
}
//
// create symbol links to COMDAT sections
//
U32 *comdats;
{
comdats = push_array_no_zero(arena, U32, header.section_count_no_null + 1);
MemorySet(comdats, 0xff, (header.section_count_no_null + 1) * sizeof(comdats[0]));
COFF_ParsedSymbol symbol;
for (U64 symbol_idx = 0; symbol_idx < header.symbol_count; symbol_idx += (1 + symbol.aux_symbol_count)) {
symbol = coff_parse_symbol_no_name(header, raw_coff_symbol_table, symbol_idx);
COFF_SymbolValueInterpType interp = coff_interp_symbol(symbol.section_number, symbol.value, symbol.storage_class);
if (interp == COFF_SymbolValueInterp_Regular) {
if (symbol.storage_class == COFF_SymStorageClass_Static) {
if (symbol.section_number > 0 && symbol.section_number <= header.section_count_no_null) {
COFF_SectionHeader *sect_header = &coff_section_table[symbol.section_number-1];
if (section_headers[symbol.section_number].flags & COFF_SectionFlag_LnkCOMDAT) {
if (symbol.aux_symbol_count) {
U32 section_length = 0;
coff_parse_secdef(symbol, header.is_big_obj, 0, 0, &section_length, 0);
if (sect_header->fsize == section_length) {
if (comdats[symbol.section_number] == ~0) {
comdats[symbol.section_number] = symbol_idx;
} else {
lnk_error_input_obj(LNK_Error_IllData, input, "section definition symbo (No. 0x%llx) tries to ovewrite comdat", symbol_idx);
}
} else {
lnk_error_input_obj(LNK_Error_IllData, input, "section size specified by section definition symbol (No 0x%llx) doesn't match size in section header (No. 0x%x); expected 0x%x got 0x%x", symbol_idx, symbol.section_number, section_length, sect_header->fsize);
}
}
}
} else {
lnk_error_input_obj(LNK_Error_IllData, input, "section definition symbol (No. 0x%llx) has out of bounds section number 0x%x", symbol_idx, symbol.section_number);
}
}
}
}
}
//
// COMDAT loop checker
//
{
Temp scratch = scratch_begin(&arena, 1);
HashTable *visited_sections = hash_table_init(scratch.arena, 32);
for (U32 section_number = 1; section_number <= header.section_count_no_null; section_number += 1) {
for (U32 curr_section_number = section_number;;) {
U32 symbol_idx = comdats[curr_section_number];
// is section COMDAT?
if (symbol_idx == max_U32) {
break;
}
// extract COMDAT info for current section
COFF_ParsedSymbol symbol = coff_parse_symbol_no_name(header, raw_coff_symbol_table, symbol_idx);
COFF_ComdatSelectType select = COFF_ComdatSelect_Null;
U32 associated_section_number = 0;
coff_parse_secdef(symbol, header.is_big_obj, &select, &associated_section_number, 0, 0);
if (select != COFF_ComdatSelect_Associative) {
// section terminates at non-associative COMDAT -- no loop
break;
}
// was section visited? -- loop found
if (hash_table_search_u64(visited_sections, curr_section_number)) {
COFF_ParsedSymbol symbol = coff_parse_symbol(header, raw_coff_string_table, raw_coff_symbol_table, comdats[section_number]);
lnk_error_input_obj(LNK_Error_AssociativeLoop, input, "section symbol %S (No. 0x%x) does not terminate on a non-associate COMDAT symbol", symbol.name, comdats[section_number]);
break;
}
// track visited sections
hash_table_push_u64_u64(scratch.arena, visited_sections, curr_section_number, 0);
// follow association
Assert(associated_section_number > 0);
curr_section_number = associated_section_number;
}
// purge hash table for next run
hash_table_purge(visited_sections);
}
scratch_end(scratch);
}
//
// collect sections associations
//
U32Node **associated_sections = push_array(arena, U32Node *, header.section_count_no_null + 1);
{
COFF_ParsedSymbol symbol;
for (U32 symbol_idx = 0; symbol_idx < header.symbol_count; symbol_idx += (1 + symbol.aux_symbol_count)) {
symbol = coff_parse_symbol_no_name(header, raw_coff_symbol_table, symbol_idx);
COFF_SymbolValueInterpType interp = coff_interp_from_parsed_symbol(symbol);
if (interp == COFF_SymbolValueInterp_Regular && symbol.storage_class == COFF_SymStorageClass_Static && symbol.aux_symbol_count > 0) {
COFF_ComdatSelectType selection = COFF_ComdatSelect_Null;
U32 section_number = 0;
coff_parse_secdef(symbol, header.is_big_obj, &selection, &section_number, 0, 0);
if (selection != COFF_ComdatSelect_Associative) { continue; }
U32Node *associated_node = push_array(arena, U32Node, 1);
associated_node->data = symbol.section_number;
SLLStackPush(associated_sections[section_number], associated_node);
}
}
}
B8 hotpatch = 0;
if (header.machine == COFF_MachineType_X64) {
hotpatch = 1;
}
//
// extract obj features from compile symbol in .debug$S
//
else {
Temp scratch = scratch_begin(&arena, 1);
CV_Symbol comp_symbol = {0};
for EachIndex(sect_idx, header.section_count_no_null) {
COFF_SectionHeader *sect_header = &coff_section_table[sect_idx];
if (section_headers[sect_idx + 1].flags & LNK_SECTION_FLAG_DEBUG) {
String8 name = str8_cstring_capped(sect_header->name, sect_header->name+sizeof(sect_header->name));
if (str8_match(name, str8_lit(".debug$S"), 0)) {
Temp temp = temp_begin(scratch.arena);
String8 debug_s_data = str8_substr(input->data, rng_1u64(sect_header->foff, sect_header->foff+sect_header->fsize));
CV_DebugS debug_s = cv_debug_s_from_data(temp.arena, debug_s_data);
for EachNode(symbols_n, String8Node, debug_s.data_list[CV_C13SubSectionIdxKind_Symbols].first) {
for (U64 cursor = 0, count = 0; cursor < symbols_n->string.size && count < 2; count += 1) {
CV_SymbolHeader symbol_header;
TryReadBreak(str8_deserial_read_struct(symbols_n->string, cursor, &symbol_header), cursor);
if (symbol_header.kind == CV_SymKind_COMPILE3) {
String8 raw_symbol = str8_substr(symbols_n->string, r1u64(cursor, cursor + symbol_header.size + sizeof(CV_SymSize)));
comp_symbol = cv_symbol_from_ptr(raw_symbol.str);
goto found_comp_symbol;
}
cursor += symbol_header.size + sizeof(CV_SymSize);
cursor = AlignPow2(cursor, CV_SymbolAlign);
}
}
temp_end(temp);
}
}
}
found_comp_symbol:;
if (comp_symbol.kind == CV_SymKind_COMPILE3 && comp_symbol.data.size >= sizeof(CV_SymCompile3)) {
CV_SymCompile3 *comp = (CV_SymCompile3 *)comp_symbol.data.str;
hotpatch = !!(comp->flags & CV_Compile3Flag_HotPatch);
}
scratch_end(scratch);
}
// fill out obj
obj->coff = (LNK_ObjCoff){
.data = input->data,
.header = header,
.sections = {
.count_no_null = header.section_count_no_null,
.headers = section_headers,
.comdats = comdats,
.associated_section_numbers = associated_sections,
},
.symbols = symbols,
.debug_t_section_number = debug_t_section_number,
.debug_p_section_number = debug_p_section_number,
.debug_h_section_number = debug_h_section_number,
.llvm_addrsig_section_number = llvm_addrsig_section_number,
.hotpatch = hotpatch,
};
obj->path = push_str8_copy(arena, input->path);
obj->exclude_from_debug_info = input->exclude_from_debug_info;
obj->self = &task->objs[task_id];
obj->link_member = input->link_member;
}
internal LNK_ObjNode *
lnk_obj_from_input_many(TP_Context *tp, TP_Arena *arena, LNK_Config *config, U64 inputs_count, LNK_Input **inputs)
{
LNK_ObjNode *objs = 0;
if (inputs_count) {
objs = push_array(arena->v[0], LNK_ObjNode, inputs_count);
LNK_ObjIniter task = {
.inputs = inputs,
.objs = objs,
.machine = config->machine,
};
tp_for_parallel(tp, arena, inputs_count, lnk_obj_initer, &task);
}
return objs;
}
internal LNK_ObjNode *
lnk_obj_from_input(Arena *arena, LNK_Config *config, LNK_Input *input)
{
Temp scratch = scratch_begin(&arena, 1);
TP_Context *tp = tp_alloc(scratch.arena, 1, 1, str8_zero());
TP_Arena tp_arena = { .count = 1, .v = &arena };
LNK_ObjNode *result = lnk_obj_from_input_many(tp, &tp_arena, config, 1, &input);
scratch_end(scratch);
return result;
}
internal void
lnk_obj_list_push_node_many(LNK_ObjList *list, U64 count, LNK_ObjNode *nodes)
{
for EachIndex(i, count) {
DLLPushBack(list->first, list->last, &nodes[i]);
}
list->count += count;
}
internal void
lnk_obj_list_push_node(LNK_ObjList *list, LNK_ObjNode *node)
{
lnk_obj_list_push_node_many(list, 1, node);
}
internal
THREAD_POOL_TASK_FUNC(lnk_input_coff_symbol_table)
{
LNK_InputCoffSymbolTable *task = raw_task;
LNK_Obj *obj = task->objs[task_id];
for LNK_EachCoffSymbol(it, obj) {
U64 symbol_idx = it.symbol_idx;
COFF_ParsedSymbol symbol = it.v;
COFF_SymbolValueInterpType interp = coff_interp_from_parsed_symbol(symbol);
LNK_SymbolSearchType search_type = lnk_symbol_search_type_from_coff(obj, symbol, interp);
switch (interp) {
case COFF_SymbolValueInterp_Regular: {
if (symbol.storage_class == COFF_SymStorageClass_External) {
LNK_ObjSection section = lnk_obj_section_from_section_number(obj, symbol.section_number);
if (*section.flags & COFF_SectionFlag_LnkRemove) {
break;
}
LNK_Symbol *defn = lnk_make_symbol(arena, lnk_symbol_name_from_coff_symbol_idx(obj, symbol_idx), obj, symbol_idx, search_type);
lnk_symbol_table_push_(task->symtab, arena, worker_id, defn);
}
} break;
case COFF_SymbolValueInterp_Weak: {
LNK_Symbol *defn = lnk_make_symbol(arena, lnk_symbol_name_from_coff_symbol_idx(obj, symbol_idx), obj, symbol_idx, search_type);
lnk_symbol_table_push_(task->symtab, arena, worker_id, defn);
} break;
case COFF_SymbolValueInterp_Undefined: {
if (symbol.storage_class == COFF_SymStorageClass_External) {
LNK_Symbol *defn = lnk_make_symbol(arena, lnk_symbol_name_from_coff_symbol_idx(obj, symbol_idx), obj, symbol_idx, search_type);
lnk_symbol_table_push_(task->symtab, arena, worker_id, defn);
}
} break;
case COFF_SymbolValueInterp_Common: {
LNK_Symbol *defn = lnk_make_symbol(arena, lnk_symbol_name_from_coff_symbol_idx(obj, symbol_idx), obj, symbol_idx, search_type);
lnk_symbol_table_push_(task->symtab, arena, worker_id, defn);
} break;
case COFF_SymbolValueInterp_Abs: {
if (symbol.storage_class == COFF_SymStorageClass_External) {
LNK_Symbol *defn = lnk_make_symbol(arena, lnk_symbol_name_from_coff_symbol_idx(obj, symbol_idx), obj, symbol_idx, search_type);
lnk_symbol_table_push_(task->symtab, arena, worker_id, defn);
}
} break;
case COFF_SymbolValueInterp_Debug: {
// not used
} break;
default: { InvalidPath; } break;
}
}
}
internal LNK_ObjSymbolRef *
lnk_symlinks_from_obj(Arena *arena, LNK_SymbolTable *symtab, LNK_Obj *obj)
{
LNK_ObjSymbolRef *symlinks = push_array(arena, LNK_ObjSymbolRef, obj->coff.sections.count_no_null + 1);
for LNK_EachCoffSymbol(it, obj) {
U64 symbol_idx = it.symbol_idx;
COFF_ParsedSymbol symbol = it.v;
COFF_SymbolValueInterpType interp = coff_interp_from_parsed_symbol(symbol);
if (interp != COFF_SymbolValueInterp_Regular) { continue; }
COFF_SectionFlags section_flags = obj->coff.sections.headers[symbol.section_number].flags;
if (~section_flags & COFF_SectionFlag_LnkCOMDAT) { continue; }
LNK_ObjSymbolRef *symlink = &symlinks[symbol.section_number];
// external symbols
if (symbol.storage_class == COFF_SymStorageClass_External && symbol.aux_symbol_count == 0) {
String8 symbol_name = lnk_symbol_name_from_coff_symbol_idx(obj, symbol_idx);
B32 can_set_symlink = (symlink->obj == 0 || symbol.value == 0);
if (!can_set_symlink && symlink->obj == obj) {
COFF_ParsedSymbol leader = lnk_parsed_symbol_from_coff_symbol_idx_no_name(symlink->obj, symlink->symbol_idx);
B32 leader_is_same_section = leader.section_number == symbol.section_number;
B32 leader_is_static_anchor = (leader_is_same_section && leader.storage_class == COFF_SymStorageClass_Static && leader.aux_symbol_count == 0);
B32 leader_is_vftable = str8_starts_with(lnk_symbol_name_from_coff_symbol_idx(symlink->obj, symlink->symbol_idx), str8_lit(MSCRT_VFTABLE_SYMBOL_PREFIX));
B32 current_is_vftable = str8_starts_with(symbol_name, str8_lit(MSCRT_VFTABLE_SYMBOL_PREFIX));
// prefer public symbols to local static anchors; prefer vftable public
// symbols to other public symbols so ICF keeps vftables in their own color space
can_set_symlink = (leader_is_static_anchor || (leader_is_same_section && current_is_vftable && !leader_is_vftable));
}
if (can_set_symlink) {
LNK_SymbolHashTrie *link_symbol = lnk_symbol_table_search_(symtab, symbol_name);
if (link_symbol) {
*symlink = lnk_ref_from_symbol(link_symbol->symbol);
}
}
}
// static symbols
else if (symbol.storage_class == COFF_SymStorageClass_Static) {
if (symbol.aux_symbol_count == 0) {
if (symlink->obj == 0) {
*symlink = (LNK_ObjSymbolRef){ obj, symbol_idx };
}
}
}
}
return symlinks;
}
internal U32List
lnk_obj_collect_associated_section_numbers(Arena *arena, LNK_Obj *obj, U32 root_section_number, COFF_SectionFlags skip_flags)
{
Assert(1 <= root_section_number && root_section_number <= obj->coff.sections.count_no_null);
Temp scratch = scratch_begin(&arena, 1);
// track each child before enqueueing it because COFF associations can cycle
HashMap seen_hm = {0};
U32List queue = {0};
U32Node root_n = { root_section_number };
u32_list_push_node(&queue, &root_n);
hash_map_push_u64_u64(scratch.arena, &seen_hm, root_section_number, 1);
// walk the complete descendant chain because associated COMDATs can nest
for EachNode(parent_n, U32Node, queue.first) {
for EachNode(associated_n, U32Node, obj->coff.sections.associated_section_numbers[parent_n->data]) {
U32 child_section_number = associated_n->data;
if (child_section_number == 0) { continue; }
if (hash_map_search_u64_u64(&seen_hm, child_section_number)) { continue; }
if (obj->coff.sections.headers[child_section_number].flags & skip_flags) { continue; }
hash_map_push_u64_u64(scratch.arena, &seen_hm, child_section_number, 1);
u32_list_push(arena, &queue, child_section_number);
}
}
// return only child sections so callers choose whether the root participates
U32List result = {0};
if (queue.count > 1) {
result.first = queue.first->next;
result.last = queue.last;
result.count = queue.count - 1;
}
scratch_end(scratch);
return result;
}
internal
THREAD_POOL_TASK_FUNC(lnk_assign_comdat_symlinks_task)
{
LNK_InputCoffSymbolTable *task = raw_task;
LNK_Obj *obj = task->objs[task_id];
obj->symlinks = lnk_symlinks_from_obj(arena, task->symtab, obj);
}
internal void
lnk_assign_comdat_symlinks(TP_Context *tp, TP_Arena *arena, LNK_SymbolTable *symtab, U64 objs_count, LNK_Obj **objs)
{
ProfBeginFunction();
LNK_InputCoffSymbolTable task = { .symtab = symtab, .objs = objs };
tp_for_parallel(tp, arena, objs_count, lnk_assign_comdat_symlinks_task, &task);
ProfEnd();
}
internal void
lnk_push_obj_symbols(TP_Context *tp, TP_Arena *arena, LNK_SymbolTable *symtab, U64 objs_count, LNK_Obj **objs)
{
ProfBeginFunction();
LNK_InputCoffSymbolTable task = { .symtab = symtab, .objs = objs };
tp_for_parallel(tp, arena, objs_count, lnk_input_coff_symbol_table, &task);
ProfEnd();
}
internal COFF_ParsedSymbol
lnk_obj_match_symbol(LNK_Obj *obj, String8 match_name)
{
for LNK_EachCoffSymbol(it, obj) {
COFF_ParsedSymbol symbol = it.v;
symbol.name = lnk_symbol_name_from_coff_symbol_idx(obj, it.symbol_idx);
if (str8_match(symbol.name, match_name, 0)) {
return symbol;
}
}
return (COFF_ParsedSymbol){0};
}
internal MSCRT_FeatFlags
lnk_obj_get_features(LNK_Obj *obj)
{
return lnk_obj_match_symbol(obj, str8_lit("@feat.00")).value;
}
internal LNK_Lib *
lnk_obj_get_lib(LNK_Obj *obj)
{
return obj->link_member ? obj->link_member->lib : 0;
}
internal String8
lnk_obj_get_lib_path(LNK_Obj *obj)
{
String8 lib_path = {0};
if (obj) {
LNK_Lib *lib = lnk_obj_get_lib(obj);
lib_path = lib ? lib->path : str8_zero();
}
return lib_path;
}
internal U32
lnk_obj_get_removed_section_number(LNK_Obj *obj)
{
return obj->coff.header.is_big_obj ? LNK_REMOVED_SECTION_NUMBER_32 : LNK_REMOVED_SECTION_NUMBER_16;
}
internal B32
lnk_obj_get_comdat_symlink_from_section_number(LNK_Obj *obj, U64 section_number, LNK_ObjSymbolRef *symlink_out)
{
Assert(1 <= section_number && section_number <= obj->coff.sections.count_no_null);
LNK_ObjSymbolRef symlink = obj->symlinks[section_number];
B32 is_valid = symlink.obj != 0;
if (is_valid && symlink_out) {
*symlink_out = symlink;
}
return is_valid;
}
internal String8
lnk_obj_section_data_from_number(LNK_Obj *obj, U64 section_number)
{
Assert(1 <= section_number && section_number <= obj->coff.sections.count_no_null);
COFF_SectionHeader *section_table = (COFF_SectionHeader *)str8_substr(obj->coff.data, obj->coff.header.section_table_range).str;
COFF_SectionHeader *section = &section_table[section_number-1];
return str8_substr(obj->coff.data, r1u64s(section->foff, section->fsize));
}
internal U64
lnk_obj_foff_from_section_data_ptr(LNK_Obj *obj, void *ptr)
{
U64 data_min = IntFromPtr(obj->coff.data.str);
U64 ptr_v = IntFromPtr(ptr);
Assert(data_min <= ptr_v && ptr_v < data_min + obj->coff.data.size);
return ptr_v - data_min;
}
internal String8
lnk_obj_section_name_from_section_number(LNK_Obj *obj, U64 section_number)
{
Assert(1 <= section_number && section_number <= obj->coff.sections.count_no_null);
COFF_SectionHeader *section_header = &obj->coff.sections.headers[section_number];
return coff_name_from_section_header(lnk_coff_string_table_from_obj(obj), section_header);
}
internal LNK_ObjSection
lnk_obj_section_from_section_number(LNK_Obj *obj, U64 section_number)
{
Assert(1 <= section_number && section_number <= obj->coff.sections.count_no_null);
COFF_SectionHeader *header = &obj->coff.sections.headers[section_number];
LNK_ObjSection section = {
.obj = obj,
.section_number = section_number,
.header = header,
.flags = &header->flags,
.vrange = rng_1u64(header->voff, header->voff + header->vsize),
.frange = rng_1u64(header->foff, header->foff + header->fsize),
.reloc_count = header->reloc_count,
};
return section;
}
internal force_inline B32
lnk_obj_section_iter_next(LNK_Obj *obj, LNK_ObjSectionIter *it)
{
U64 section_number = it->v.section_number + 1;
B32 is_valid = section_number <= obj->coff.sections.count_no_null;
if (is_valid) {
it->v = lnk_obj_section_from_section_number(obj, section_number);
}
return is_valid;
}
internal COFF_RelocArray
lnk_coff_relocs_from_section_header(LNK_Obj *obj, COFF_SectionHeader *section_header)
{
COFF_RelocInfo reloc_info = coff_reloc_info_from_section_header(obj->coff.data, section_header);
COFF_Reloc *relocs = (COFF_Reloc *)(obj->coff.data.str + reloc_info.array_off);
COFF_RelocArray result = { .count = reloc_info.count, .v = relocs };
return result;
}
internal String8
lnk_coff_string_table_from_obj(LNK_Obj *obj)
{
return str8_substr(obj->coff.data, obj->coff.header.string_table_range);
}
internal String8
lnk_coff_symbol_table_from_obj(LNK_Obj *obj)
{
return str8_substr(obj->coff.data, obj->coff.header.symbol_table_range);
}
internal COFF_RelocArray
lnk_coff_reloc_info_from_section_number(LNK_Obj *obj, U64 section_number)
{
LNK_ObjSection section = lnk_obj_section_from_section_number(obj, section_number);
COFF_RelocInfo reloc_info = coff_reloc_info_from_section_header(obj->coff.data, section.header);
COFF_Reloc *relocs = str8_deserial_get_raw_ptr(obj->coff.data, reloc_info.array_off, sizeof(*relocs)*reloc_info.count);
COFF_RelocArray result = { .count = reloc_info.count, .v = relocs };
return result;
}
internal B32
lnk_try_comdat_props_from_section_number(LNK_Obj *obj, U32 section_number, COFF_ComdatSelectType *select_out, U32 *section_number_out, U32 *section_length_out, U32 *check_sum_out)
{
Assert(1 <= section_number && section_number <= obj->coff.sections.count_no_null);
U32 symbol_idx = obj->coff.sections.comdats[section_number];
if (symbol_idx != max_U32) {
COFF_ParsedSymbol secdef = lnk_parsed_symbol_from_coff_symbol_idx_no_name(obj, symbol_idx);
coff_parse_secdef(secdef, obj->coff.header.is_big_obj, select_out, section_number_out, section_length_out, check_sum_out);
return 1;
}
return 0;
}
internal COFF_SectionHeader *
lnk_coff_section_header_from_section_number(LNK_Obj *obj, U64 section_number)
{
Assert(1 <= section_number && section_number <= obj->coff.sections.count_no_null);
return &obj->coff.sections.headers[section_number];
}
internal force_inline U64
lnk_obj_primary_symbol_idx_from_coff_symbol_idx(LNK_Obj *obj, U64 symbol_idx)
{
U64 block_idx = symbol_idx >> 6;
U64 word_idx = symbol_idx >> 5;
U32 bit_idx = symbol_idx & 31;
U32Array primary_bits = obj->coff.symbols.primary_bits;
Assert(bit_array_get_bit32(primary_bits, symbol_idx));
U64 primary_idx = obj->coff.symbols.block_bases[block_idx];
if (word_idx & 1) {
primary_idx += count_bits_set32(primary_bits.v[word_idx - 1]);
}
primary_idx += count_bits_set32(primary_bits.v[word_idx] & ((1u << bit_idx) - 1));
return primary_idx;
}
internal force_inline B32
lnk_obj_symbol_iter_next(LNK_Obj *obj, LNK_ObjSymbolIter *it)
{
if (it->next_primary_idx >= obj->coff.symbols.count) {
Assert(it->next_symbol_idx >= obj->coff.header.symbol_count);
return 0;
}
Assert(it->next_symbol_idx < obj->coff.header.symbol_count);
U64 symbol_size = obj->coff.header.is_big_obj ? sizeof(COFF_Symbol32) : sizeof(COFF_Symbol16);
it->symbol_idx = it->next_symbol_idx;
it->primary_idx = it->next_primary_idx;
it->v = (COFF_ParsedSymbol){
.value = obj->coff.symbols.values[it->primary_idx],
.section_number = obj->coff.symbols.section_numbers[it->primary_idx],
.type = obj->coff.symbols.types[it->primary_idx],
.storage_class = obj->coff.symbols.storage_classes[it->primary_idx],
.aux_symbol_count = obj->coff.symbols.aux_counts[it->primary_idx],
.raw_symbol = lnk_coff_symbol_table_from_obj(obj).str + it->symbol_idx * symbol_size,
};
it->next_symbol_idx += 1 + it->v.aux_symbol_count;
it->next_primary_idx += 1;
return 1;
}
internal force_inline COFF_ParsedSymbol
lnk_parsed_symbol_from_coff_symbol_idx_no_name(LNK_Obj *obj, U64 symbol_idx)
{
U64 primary_idx = lnk_obj_primary_symbol_idx_from_coff_symbol_idx(obj, symbol_idx);
U64 symbol_size = obj->coff.header.is_big_obj ? sizeof(COFF_Symbol32) : sizeof(COFF_Symbol16);
COFF_ParsedSymbol result = {
.value = obj->coff.symbols.values[primary_idx],
.section_number = obj->coff.symbols.section_numbers[primary_idx],
.type = obj->coff.symbols.types[primary_idx],
.storage_class = obj->coff.symbols.storage_classes[primary_idx],
.aux_symbol_count = obj->coff.symbols.aux_counts[primary_idx],
.raw_symbol = lnk_coff_symbol_table_from_obj(obj).str + symbol_idx * symbol_size,
};
return result;
}
internal force_inline String8
lnk_symbol_name_from_coff_symbol_idx(LNK_Obj *obj, U64 symbol_idx)
{
U64 primary_idx = lnk_obj_primary_symbol_idx_from_coff_symbol_idx(obj, symbol_idx);
return str8(obj->coff.data.str + obj->coff.symbols.name_offsets[primary_idx], obj->coff.symbols.name_sizes[primary_idx]);
}
internal force_inline COFF_ParsedSymbol
lnk_parsed_symbol_from_coff_symbol_idx(LNK_Obj *obj, U64 symbol_idx)
{
COFF_ParsedSymbol result = lnk_parsed_symbol_from_coff_symbol_idx_no_name(obj, symbol_idx);
result.name = lnk_symbol_name_from_coff_symbol_idx(obj, symbol_idx);
return result;
}
internal
THREAD_POOL_TASK_FUNC(lnk_collect_obj_chunks_task)
{
LNK_SectionCollector *task = raw_task;
LNK_Obj *obj = task->objs[task_id];
for LNK_EachCoffSection(it, obj) {
LNK_ObjSection section = it.v;
if (*section.flags & COFF_SectionFlag_LnkRemove && !task->collect_discarded) {
continue;
}
String8 section_name = lnk_obj_section_name_from_section_number(obj, section.section_number);
if (str8_match(section_name, task->name, 0)) {
String8 section_data = lnk_obj_section_data_from_number(obj, section.section_number);
str8_list_push(arena, &task->out_lists[task_id], section_data);
}
}
}
internal String8List *
lnk_collect_obj_sections(TP_Context *tp, TP_Arena *arena, U64 objs_count, LNK_Obj **objs, String8 name, B32 collect_discarded)
{
ProfBeginFunction();
LNK_SectionCollector task = {0};
task.objs = objs;
task.name = name;
task.collect_discarded = collect_discarded;
task.out_lists = push_array(arena->v[0], String8List, objs_count);
tp_for_parallel(tp, arena, objs_count, lnk_collect_obj_chunks_task, &task);
ProfEnd();
return task.out_lists;
}
internal B32
lnk_obj_is_before(void *raw_a, void *raw_b)
{
LNK_Obj *a = raw_a, *b = raw_b;
return a->input_idx < b->input_idx;
}
internal void
lnk_parse_msvc_linker_directive(Arena *arena, LNK_Obj *obj, LNK_DirectiveInfo *directive_info, String8 buffer)
{
Temp scratch = scratch_begin(&arena, 1);
String8 to_parse;
{
local_persist const U8 bom_sig[] = { 0xEF, 0xBB, 0xBF };
local_persist const U8 ascii_sig[] = { 0x20, 0x20, 0x20 };
if (MemoryMatch(buffer.str, &bom_sig[0], sizeof(bom_sig))) {
to_parse = str8_zero();
lnk_error_obj(LNK_Error_IllData, obj, "TODO: support for BOM encoding");
} else if (MemoryMatch(buffer.str, &ascii_sig[0], sizeof(ascii_sig))) {
to_parse = str8_skip(buffer, sizeof(ascii_sig));
} else {
to_parse = buffer;
}
}
String8List arg_list = lnk_arg_list_parse_windows_rules(scratch.arena, to_parse);
LNK_CmdLine cmd_line = lnk_cmd_line_parse_windows_rules(scratch.arena, arg_list);
for EachNode(opt, LNK_CmdOption, cmd_line.first_option) {
LNK_CmdSwitch *cmd_switch = lnk_cmd_switch_from_string(opt->string);
if (cmd_switch == 0) {
lnk_error_obj(LNK_Warning_UnknownDirective, obj, "unknown directive \"%S\"", opt->string);
continue;
}
if (cmd_switch->is_legal_directive == 0) {
lnk_error_obj(LNK_Warning_IllegalDirective, obj, "illegal directive \"%S\"", opt->string);
continue;
}
LNK_Directive *directive = push_array_no_zero(arena, LNK_Directive, 1);
directive->next = 0;
directive->id = str8_cstring(cmd_switch->name);
directive->value = push_str8_copy(arena, opt->value);
LNK_DirectiveList *directive_list = &directive_info->v[cmd_switch->type];
SLLQueuePush(directive_list->first, directive_list->last, directive);
++directive_list->count;
}
scratch_end(scratch);
}
internal String8List
lnk_raw_directives_from_obj(Arena *arena, LNK_Obj *obj)
{
String8List drectve_data = {0};
for LNK_EachCoffSection(it, obj) {
LNK_ObjSection section = it.v;
if (*section.flags & COFF_SectionFlag_LnkInfo) {
String8 section_name = lnk_obj_section_name_from_section_number(obj, section.section_number);
if (str8_match(section_name, str8_lit(".drectve"), 0)) {
if (*section.flags & COFF_SectionFlag_CntUninitializedData) {
lnk_error_obj(LNK_Error_IllData, obj, ".drectve section header has flag COFF_SectionFlag_CntUninitializedData");
break;
}
if (dim_1u64(section.frange) < 3) {
lnk_error_obj(LNK_Error_IllData, obj, "not enough bytes to parse .drectve");
break;
}
if (section.reloc_count > 0) {
lnk_error_obj(LNK_Error_IllData, obj, ".drectve must not have relocations");
break;
}
str8_list_push(arena, &drectve_data, lnk_obj_section_data_from_number(obj, section.section_number));
}
}
}
return drectve_data;
}
internal LNK_DirectiveInfo
lnk_directive_info_from_raw_directives(Arena *arena, LNK_Obj *obj, String8List raw_directives)
{
LNK_DirectiveInfo directive_info = {0};
for (String8Node *drectve_n = raw_directives.first; drectve_n != 0; drectve_n = drectve_n->next) {
lnk_parse_msvc_linker_directive(arena, obj, &directive_info, drectve_n->string);
}
return directive_info;
}
internal force_inline int
lnk_section_offset_symbol_is_before(void *raw_a, void *raw_b)
{
LNK_SectionOffsetSymbol *a = raw_a, *b = raw_b;
if (a->key == b->key) {
return a->symbol_idx < b->symbol_idx;
}
return a->key < b->key;
}
internal LNK_ObjSymbolMap *
lnk_symbol_map_from_obj(Arena *arena, LNK_Obj *obj)
{
// count functions
U64 count = 0;
for LNK_EachCoffSymbol(it, obj) {
COFF_ParsedSymbol symbol = it.v;
if (coff_interp_from_parsed_symbol(symbol) == COFF_SymbolValueInterp_Regular && COFF_SymbolType_IsFunc(symbol.type)) {
count += 1;
}
}
LNK_ObjSymbolMap *map = push_array(arena, LNK_ObjSymbolMap, 1);
map->v = push_array_no_zero(arena, LNK_SectionOffsetSymbol, count);
for LNK_EachCoffSymbol(it, obj) {
COFF_ParsedSymbol symbol = it.v;
if (coff_interp_from_parsed_symbol(symbol) == COFF_SymbolValueInterp_Regular && COFF_SymbolType_IsFunc(symbol.type)) {
LNK_SectionOffsetSymbol *entry = &map->v[map->count++];
entry->key = Compose64Bit(symbol.section_number, symbol.value);
entry->symbol_idx = safe_cast_u32(it.symbol_idx);
}
}
Assert(map->count == count);
radsort(map->v, map->count, lnk_section_offset_symbol_is_before);
return map;
}
internal U32
lnk_symbol_from_section_offset(LNK_ObjSymbolMap *map, U32 section_number, U32 offset)
{
U64 key = Compose64Bit(section_number, offset);
U64 min = 0;
U64 opl = map->count;
while (min < opl) {
U64 mid = min + (opl - min) / 2;
if (map->v[mid].key <= key) {
min = mid + 1;
} else {
opl = mid;
}
}
U32 symbol_idx = max_U32;
if (min > 0) {
LNK_SectionOffsetSymbol *entry = &map->v[min - 1];
if (entry->key >> 32 == section_number) {
symbol_idx = entry->symbol_idx;
}
}
return symbol_idx;
}
internal CV_DebugS
lnk_debug_s_from_obj(Arena *arena, LNK_Obj *obj)
{
Temp scratch = scratch_begin(&arena, 1);
String8List raw_debug_s = {0};
{
for LNK_EachCoffSection(it, obj) {
LNK_ObjSection section = it.v;
String8 section_name = lnk_obj_section_name_from_section_number(obj, section.section_number);
if (str8_match(section_name, str8_lit(".debug$S"), 0)) {
String8 debug_s = lnk_obj_section_data_from_number(obj, section.section_number);
str8_list_push(scratch.arena, &raw_debug_s, debug_s);
}
}
}
CV_DebugS debug_s = {0};
{
for (String8Node *node = raw_debug_s.first; node != 0; node = node->next) {
// parse & merge sub sections
CV_DebugS ds = cv_debug_s_from_data(arena, node->string);
cv_debug_s_concat_in_place(&debug_s, &ds);
// make sure there is one string table
String8List string_data_list = cv_sub_section_from_debug_s(debug_s, CV_C13SubSectionKind_StringTable);
if (string_data_list.node_count > 1) {
break;
}
// make sure there is one file checksum table
String8List checksum_data_list = cv_sub_section_from_debug_s(debug_s, CV_C13SubSectionKind_FileChksms);
if (checksum_data_list.node_count > 1) {
continue;
}
}
}
scratch_end(scratch);
return debug_s;
}
internal force_inline int
lnk_line_table_block_is_before(void *raw_a, void *raw_b)
{
LNK_LineTableBlock *a = raw_a, *b = raw_b;
U64 key_a = Compose64Bit(a->header->sec_idx, a->header->sec_off_lo);
U64 key_b = Compose64Bit(b->header->sec_idx, b->header->sec_off_lo);
if (key_a == key_b) { return a->header->sec_off_hi < b->header->sec_off_hi; }
return key_a < key_b;
}
internal force_inline int
lnk_inline_range_is_before(void *raw_a, void *raw_b)
{
LNK_InlineRange *a = raw_a, *b = raw_b;
if (a->key_min != b->key_min) { return a->key_min < b->key_min; }
return a->site_idx < b->site_idx;
}
internal LNK_ObjLineMap *
lnk_line_map_from_obj(Arena *arena, LNK_Obj *obj)
{
Temp scratch = scratch_begin(&arena, 1);
//
// build .debug$S section file offset -> relocation value
//
#define DebugRelocValueFromFileOffset(foff) hash_map_search_u64_u64(&debug_reloc_hm, foff)
HashMap debug_reloc_hm = {0};
for LNK_EachCoffSection(it, obj) {
LNK_ObjSection section = it.v;
if (!str8_match(lnk_obj_section_name_from_section_number(obj, section.section_number), str8_lit(".debug$S"), 0)) { continue; }
String8 section_data = lnk_obj_section_data_from_number(obj, section.section_number);
COFF_RelocArray relocs = lnk_coff_relocs_from_section_header(obj, section.header);
for EachIndex(reloc_idx, relocs.count) {
COFF_Reloc *reloc = &relocs.v[reloc_idx];
COFF_ParsedSymbol symbol = lnk_parsed_symbol_from_coff_symbol_idx_no_name(obj, reloc->isymbol);
if (coff_interp_from_parsed_symbol(symbol) != COFF_SymbolValueInterp_Regular) { continue; }
U64 reloc_size = 0;
U64 reloc_value = 0;
if ((obj->coff.header.machine == COFF_MachineType_X64 && reloc->type == COFF_Reloc_X64_Section) ||
(obj->coff.header.machine == COFF_MachineType_X86 && reloc->type == COFF_Reloc_X86_Section)) {
reloc_size = sizeof(U16);
reloc_value = symbol.section_number;
} else if ((obj->coff.header.machine == COFF_MachineType_X64 && reloc->type == COFF_Reloc_X64_SecRel) ||
(obj->coff.header.machine == COFF_MachineType_X86 && reloc->type == COFF_Reloc_X86_SecRel)) {
reloc_size = sizeof(U32);
reloc_value = symbol.value;
}
if (reloc_size > 0 && reloc->apply_off + reloc_size <= section_data.size) {
U64 addend = 0;
str8_deserial_read(section_data, reloc->apply_off, &addend, reloc_size, 1);
U64 foff = section.frange.min + reloc->apply_off;
U64 value = reloc_value + extend_sign64(addend, reloc_size);
U64 *existing = hash_map_search_u64_u64(&debug_reloc_hm, foff);
if (existing) {
*existing = value;
} else {
hash_map_push_u64_u64(scratch.arena, &debug_reloc_hm, foff, value);
}
}
}
}
CV_DebugS debug_s = lnk_debug_s_from_obj(scratch.arena, obj);
String8List raw_lines_list = cv_sub_section_from_debug_s(debug_s, CV_C13SubSectionKind_Lines);
String8List raw_checksums = cv_sub_section_from_debug_s(debug_s, CV_C13SubSectionKind_FileChksms);
String8List raw_strings = cv_sub_section_from_debug_s(debug_s, CV_C13SubSectionKind_StringTable);
//
// estimate requried line table block capacity
//
U64 line_table_blocks_cap = 0;
for EachNode(raw_lines_node, String8Node, raw_lines_list.first) {
Temp temp = temp_begin(scratch.arena);
CV_C13LinesHeaderList parsed_list = cv_c13_lines_from_sub_sections(temp.arena, raw_lines_node->string, rng_1u64(0, raw_lines_node->string.size));
line_table_blocks_cap += parsed_list.count;
temp_end(temp);
}
LNK_ObjLineMap *map = push_array(arena, LNK_ObjLineMap, 1);
map->arena = arena;
map->debug_checksums = str8_list_first(&raw_checksums);
map->debug_strings = str8_list_first(&raw_strings);
map->line_table_blocks = push_array(arena, LNK_LineTableBlock, line_table_blocks_cap);
map->tables = push_array(arena, LNK_LineTable, line_table_blocks_cap);
for EachNode(raw_lines_node, String8Node, raw_lines_list.first) {
Temp temp = temp_begin(scratch.arena);
String8 raw_lines = raw_lines_node->string;
CV_C13LinesHeaderList parsed_list = cv_c13_lines_from_sub_sections(temp.arena, raw_lines, rng_1u64(0, raw_lines.size));
for EachNode(header_node, CV_C13LinesHeaderNode, parsed_list.first) {
if (header_node->v.line_count == 0) { continue; }
LNK_LineTableBlock *block = &map->line_table_blocks[map->line_table_block_count++];
block->raw_lines = raw_lines;
block->header = push_array(arena, CV_C13LinesHeader, 1);
*block->header = header_node->v;
// resovle lines header
{
CV_C13LinesHeader *header = block->header;
U64 header_foff = lnk_obj_foff_from_section_data_ptr(obj, raw_lines.str) + header->header_off;
U64 *sec_off = DebugRelocValueFromFileOffset(header_foff + OffsetOf(CV_C13SubSecLinesHeader, sec_off));
if (sec_off) {
U64 len = header->sec_off_hi - header->sec_off_lo;
header->sec_off_lo = *sec_off;
header->sec_off_hi = *sec_off + len;
}
U64 *sec = DebugRelocValueFromFileOffset(header_foff + OffsetOf(CV_C13SubSecLinesHeader, sec));
if (sec) {
header->sec_idx = *sec;
}
}
}
temp_end(temp);
}
Assert(map->line_table_block_count <= line_table_blocks_cap);
radsort(map->line_table_blocks, map->line_table_block_count, lnk_line_table_block_is_before);
for (U64 block_idx = 0; block_idx < map->line_table_block_count;) {
LNK_LineTableBlock *block = &map->line_table_blocks[block_idx];
U64 key_min = Compose64Bit(block->header->sec_idx, block->header->sec_off_lo);
U64 key_max = Compose64Bit(block->header->sec_idx, block->header->sec_off_hi);
U64 block_opl = block_idx + 1;
for (; block_opl < map->line_table_block_count; block_opl += 1) {
LNK_LineTableBlock *next = &map->line_table_blocks[block_opl];
if (next->header->sec_idx != block->header->sec_idx ||
next->header->sec_off_lo != block->header->sec_off_lo ||
next->header->sec_off_hi != block->header->sec_off_hi) {
break;
}
}
LNK_LineTable *table = &map->tables[map->table_count++];
table->key_min = key_min;
table->key_max = key_max;
table->prefix_max = map->table_count > 1 ? Max(map->tables[map->table_count - 2].prefix_max, key_max) : key_max;
table->block_first = block_idx;
table->block_count = block_opl - block_idx;
block_idx = block_opl;
}
//
// build inlinee id -> inlinee name
//
HashMap inlinee_hm = {0};
if (obj->coff.debug_t_section_number) {
String8 raw_debug_t = lnk_obj_section_data_from_number(obj, obj->coff.debug_t_section_number);
CV_Signature debug_t_sig = cv_signature_from_debug_s(raw_debug_t);
if (debug_t_sig == CV_Signature_C13) {
CV_DebugT debug_t = cv_debug_t_from_data(scratch.arena, str8_skip(raw_debug_t, sizeof(CV_Signature)), CV_LeafAlign);
CV_TypeIndex ti_base = CV_MinComplexTypeIndex;
if (cv_debug_t_is_pch(&debug_t)) {
CV_Leaf precomp_leaf = cv_debug_t_get_leaf(&debug_t, 0);
CV_PrecompInfo precomp = cv_precomp_info_from_leaf(precomp_leaf);
// discard LF_PRECOMP
debug_t.offsets += 1;
debug_t.count -= 1;
ti_base = precomp.start_index + precomp.leaf_count;
}
for EachIndex(leaf_idx, debug_t.count) {
CV_Leaf leaf = cv_debug_t_get_leaf(&debug_t, leaf_idx);
String8 name = str8_zero();
if (leaf.kind == CV_LeafKind_FUNC_ID) {
String8 data = str8_substr(leaf.data, r1u64(sizeof(CV_LeafFuncId), leaf.data.size));
name = str8_cstring_capped(data.str, data.str + data.size);
} else if (leaf.kind == CV_LeafKind_MFUNC_ID) {
String8 data = str8_substr(leaf.data, r1u64(sizeof(CV_LeafMFuncId), leaf.data.size));
name = str8_cstring_capped(data.str, data.str + data.size);
}
if (name.size) {
U64 inlinee_itype = ti_base + leaf_idx;
hash_map_push_u64_string(scratch.arena, &inlinee_hm, inlinee_itype, name);
}
}
}
}
//
// build inlinee lines accelerator
//
String8List raw_inlinee_lines = cv_sub_section_from_debug_s(debug_s, CV_C13SubSectionKind_InlineeLines);
CV_C13InlineeLinesParsedList inlinee_lines = cv_c13_inlinee_lines_from_sub_sections(scratch.arena, raw_inlinee_lines);
CV_InlineeLinesAccel *inlinee_lines_accel = cv_c13_make_inlinee_lines_accel(scratch.arena, inlinee_lines);
//
// estimate required inline site capacity
//
String8List raw_symbols = cv_sub_section_from_debug_s(debug_s, CV_C13SubSectionKind_Symbols);
U64 inline_site_cap = 0;
for EachNode(raw_symbols_node, String8Node, raw_symbols.first) {
for (U64 cursor = 0; cursor < raw_symbols_node->string.size;) {
CV_Symbol symbol = {0};
TryReadBreak(cv_read_symbol(raw_symbols_node->string, cursor, CV_SymbolAlign, &symbol), cursor);
inline_site_cap += symbol.kind == CV_SymKind_INLINESITE || symbol.kind == CV_SymKind_INLINESITE2;
}
}
//
// extract inline site info from the .debug$S sections
//
typedef struct LNK_InlineRangeNode LNK_InlineRangeNode;
struct LNK_InlineRangeNode {
LNK_InlineRangeNode *next;
LNK_InlineRange v;
};
LNK_InlineRangeNode *range_first = 0, *range_last = 0;
map->inline_sites = push_array(arena, LNK_InlineSite, inline_site_cap);
for EachNode(raw_symbols_node, String8Node, raw_symbols.first) {
U32 proc_section = 0;
U32 proc_offset = 0;
U64 inline_site_stack_count = 0;
U32 *inline_site_stack = push_array_no_zero(scratch.arena, U32, inline_site_cap);
for (U64 cursor = 0; cursor < raw_symbols_node->string.size;) {
CV_Symbol symbol = {0};
TryReadBreak(cv_read_symbol(raw_symbols_node->string, cursor, CV_SymbolAlign, &symbol), cursor);
if (CV_IsProc32(symbol.kind)) {
CV_SymProc32 *proc = str8_deserial_get_raw_ptr(symbol.data, 0, sizeof(*proc));
if (proc) {
U64 proc_foff = lnk_obj_foff_from_section_data_ptr(obj, symbol.data.str);
U64 *off_reloc = DebugRelocValueFromFileOffset(proc_foff + OffsetOf(CV_SymProc32, off));
U64 *sec_reloc = DebugRelocValueFromFileOffset(proc_foff + OffsetOf(CV_SymProc32, sec));
proc_offset = off_reloc ? safe_cast_u32(*off_reloc) : proc->off;
proc_section = sec_reloc ? safe_cast_u32(*sec_reloc) : proc->sec;
inline_site_stack_count = 0;
}
} else if (symbol.kind == CV_SymKind_INLINESITE || symbol.kind == CV_SymKind_INLINESITE2) {
U64 header_size = symbol.kind == CV_SymKind_INLINESITE ? sizeof(CV_SymInlineSite) : sizeof(CV_SymInlineSite2);
if (proc_section && symbol.data.size >= header_size) {
CV_ItemId inlinee = symbol.kind == CV_SymKind_INLINESITE ? ((CV_SymInlineSite *)symbol.data.str)->inlinee : ((CV_SymInlineSite2 *)symbol.data.str)->inlinee;
String8 raw_annots = str8_skip(symbol.data, header_size);
String8 *inlinee_name = hash_map_search_u64_string(&inlinee_hm, inlinee);
U32 inline_site_idx = safe_cast_u32(map->inline_site_count++);
LNK_InlineSite *inline_site = &map->inline_sites[inline_site_idx];
inline_site->parent_idx_plus_one = inline_site_stack_count ? inline_site_stack[inline_site_stack_count - 1] + 1 : 0;
inline_site->depth = inline_site->parent_idx_plus_one ? map->inline_sites[inline_site->parent_idx_plus_one - 1].depth + 1 : 1;
inline_site->inlinee = inlinee;
inline_site->name = inlinee_name ? *inlinee_name : str8_zero();
inline_site_stack[inline_site_stack_count++] = inline_site_idx;
CV_C13InlineeLinesParsed *inlinee_info = cv_c13_inlinee_lines_accel_find(inlinee_lines_accel, inlinee);
if (inlinee_info) {
//
// decode inline site line table
//
typedef struct LNK_InlineLineNode LNK_InlineLineNode;
struct LNK_InlineLineNode {
LNK_InlineLineNode *next;
CV_Line v;
};
LNK_InlineLineNode *line_first = 0;
LNK_InlineLineNode *line_last = 0;
LNK_InlineRangeNode *last_site_range = 0;
U32 current_file_off = inlinee_info->file_off;
CV_C13InlineSiteDecoder decoder = cv_c13_inline_site_decoder_init(inlinee_info->file_off, inlinee_info->first_source_ln, proc_offset);
for (;;) {
U64 old_cursor = decoder.cursor;
CV_C13InlineSiteDecoderStep step = cv_c13_inline_site_decoder_step(&decoder, raw_annots);
if (step.flags == 0 || decoder.cursor <= old_cursor) { break; }
if (step.flags & CV_C13InlineSiteDecoderStepFlag_EmitFile) {
current_file_off = step.file_off;
}
if (step.range.min < step.range.max) {
if ((step.flags & CV_C13InlineSiteDecoderStepFlag_EmitRange) ||
((step.flags & CV_C13InlineSiteDecoderStepFlag_ExtendLastRange) && last_site_range == 0)) {
LNK_InlineRangeNode *node = push_array(scratch.arena, LNK_InlineRangeNode, 1);
node->v.key_min = Compose64Bit(proc_section, step.range.min);
node->v.key_max = Compose64Bit(proc_section, step.range.max);
node->v.site_idx = inline_site_idx;
SLLQueuePush(range_first, range_last, node);
last_site_range = node;
map->inline_range_count += 1;
}
}
if ((step.flags & CV_C13InlineSiteDecoderStepFlag_ExtendLastRange) && last_site_range) {
last_site_range->v.key_max = Compose64Bit(proc_section, step.range.max);
}
if (step.flags & CV_C13InlineSiteDecoderStepFlag_EmitLine) {
LNK_InlineLineNode *node = push_array(scratch.arena, LNK_InlineLineNode, 1);
node->v.voff = step.line_voff;
node->v.file_off = current_file_off;
node->v.line_num = step.ln;
SLLQueuePush(line_first, line_last, node);
inline_site->line_count += 1;
}
}
// line list -> sorted line array
inline_site->lines = push_array_no_zero(arena, CV_Line, inline_site->line_count);
U64 line_idx = 0;
for EachNode(line, LNK_InlineLineNode, line_first) { inline_site->lines[line_idx++] = line->v; }
radsort(inline_site->lines, inline_site->line_count, cv_c13_voff_map_is_before);
}
}
} else if (symbol.kind == CV_SymKind_CALLEES) {
if (inline_site_stack_count && symbol.data.size >= sizeof(CV_SymFunctionList)) {
CV_SymFunctionList *func_list = (CV_SymFunctionList *)symbol.data.str;
U64 callee_count = Min(func_list->count, (symbol.data.size - sizeof(*func_list)) / sizeof(CV_ItemId));
CV_ItemId *callees = (CV_ItemId *)(func_list + 1);
LNK_InlineSite *inline_site = &map->inline_sites[inline_site_stack[inline_site_stack_count - 1]];
inline_site->callee_count = callee_count;
inline_site->callee_names = push_array(arena, String8, callee_count);
for EachIndex(callee_idx, callee_count) {
String8 *callee_name = hash_map_search_u64_string(&inlinee_hm, callees[callee_idx]);
inline_site->callee_names[callee_idx] = callee_name ? *callee_name : str8_zero();
}
}
} else if (symbol.kind == CV_SymKind_INLINESITE_END) {
if (inline_site_stack_count > 0) {
inline_site_stack_count -= 1;
}
} else if (symbol.kind == CV_SymKind_END || symbol.kind == CV_SymKind_PROC_ID_END) {
proc_section = 0;
proc_offset = 0;
inline_site_stack_count = 0;
}
}
}
//
// fill out & sort inline site ranges
//
{
map->inline_ranges = push_array_no_zero(arena, LNK_InlineRange, map->inline_range_count);
U64 range_idx = 0;
for EachNode(range, LNK_InlineRangeNode, range_first) {
map->inline_ranges[range_idx++] = range->v;
}
radsort(map->inline_ranges, map->inline_range_count, lnk_inline_range_is_before);
for EachIndex(i, map->inline_range_count) {
map->inline_ranges[i].prefix_max = i ?
Max(map->inline_ranges[i - 1].prefix_max, map->inline_ranges[i].key_max) :
map->inline_ranges[i].key_max;
}
}
#undef DebugRelocValueFromFileOff
scratch_end(scratch);
return map;
}
internal CV_Line *
lnk_lines_from_section_offset(LNK_ObjLineMap *map, U64 section_number, U64 offset, U64 *line_count_out)
{
U64 key = Compose64Bit(safe_cast_u32(section_number), safe_cast_u32(offset));
// upper bound search
U64 min = 0;
U64 opl = map->table_count;
while (min < opl) {
U64 mid = min + (opl - min) / 2;
if (map->tables[mid].key_min <= key) {
min = mid + 1;
} else {
opl = mid;
}
}
// backward search until containing interval is found
LNK_LineTable *table = 0;
while (min > 0) {
LNK_LineTable *candidate = &map->tables[--min];
if (key < candidate->key_max) {
table = candidate;
break;
}
if (min == 0 || map->tables[min - 1].prefix_max <= key) {
break;
}
}
CV_Line *lines = 0;
U64 line_count = 0;
if (table) {
if (table->accel == 0) {
Temp scratch = scratch_begin(&map->arena, 1);
// unpack lines from line table blocks
CV_LineArray *line_arrays = push_array_no_zero(scratch.arena, CV_LineArray, table->block_count);
for EachIndex(i, table->block_count) {
LNK_LineTableBlock *block = &map->line_table_blocks[table->block_first + i];
CV_C13LinesHeader header = *block->header;
header.sec_off_hi -= header.sec_off_lo;
header.sec_off_lo = 0;
line_arrays[i] = cv_c13_line_array_from_data(scratch.arena, block->raw_lines, 0, header);
}
// cache line table accel
table->accel = cv_c13_make_lines_accel(map->arena, table->block_count, line_arrays);
scratch_end(scratch);
}
// match (section, offset) => lines
U32 table_offset = safe_cast_u32(key - table->key_min);
lines = cv_line_from_voff(table->accel, table_offset, &line_count);
}
if (line_count_out) {
*line_count_out = line_count;
}
return lines;
}
internal LNK_InlineSite *
lnk_inline_site_from_section_offset(LNK_ObjLineMap *map, U64 section_number, U64 offset, LNK_Symbol *callee_symbol)
{
U64 key = Compose64Bit(safe_cast_u32(section_number), safe_cast_u32(offset));
// find upper bound
U64 min = 0;
U64 opl = map->inline_range_count;
while (min < opl) {
U64 mid = min + (opl - min) / 2;
if (map->inline_ranges[mid].key_min <= key) {
min = mid + 1;
} else {
opl = mid;
}
}
// hacky demangle
String8 callee_name = callee_symbol ? callee_symbol->name : str8_zero();
if (str8_starts_with(callee_name, str8_lit("__imp_"))) {
callee_name = str8_skip(callee_name, 6);
}
if (str8_starts_with(callee_name, str8_lit("?"))) {
U64 name_opl = str8_find_needle(callee_name, 1, str8_lit("@"), 0);
callee_name = str8_substr(callee_name, r1u64(1, name_opl));
}
// scan back to the lower bound and match inline sites
LNK_InlineSite *site = 0;
LNK_InlineSite *callee_site = 0;
B32 callee_site_is_ambiguous = 0;
while (min > 0) {
LNK_InlineRange *range = &map->inline_ranges[--min];
if (key < range->key_max) {
LNK_InlineSite *candidate = &map->inline_sites[range->site_idx];
if (site == 0 || site->depth < candidate->depth) {
site = candidate;
}
for EachIndex(callee_idx, candidate->callee_count) {
String8 pdb_callee_name = candidate->callee_names[callee_idx];
if (str8_match(callee_name, pdb_callee_name, 0)) {
// candidate matches callee
if (callee_site == 0 || callee_site->depth < candidate->depth) {
callee_site = candidate;
callee_site_is_ambiguous = 0;
} else if (candidate->depth == callee_site->depth && candidate != callee_site) {
callee_site_is_ambiguous = 1;
}
break;
}
}
}
if (min == 0 || map->inline_ranges[min - 1].prefix_max <= key) {
break;
}
}
return (callee_site && !callee_site_is_ambiguous) ? callee_site : site;
}
internal CV_Line *
lnk_line_from_inline_site(LNK_InlineSite *site, U32 offset)
{
U64 min = 0;
U64 opl = site->line_count;
while (min < opl) {
U64 mid = min + (opl - min) / 2;
if (site->lines[mid].voff <= offset) {
min = mid + 1;
} else {
opl = mid;
}
}
return min > 0 ? &site->lines[min - 1] : 0;
}