ed/raddebugger
1
0
Fork 0
mirror of https://github.com/Ed94/raddebugger.git synced 2026-06-15 16:42:23 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
8a8f1e4fc2fcc3db553bbbf1cc51ea2bcf4aa204
raddebugger/src/rdi_dump/rdi_dump_main.c
T

516 lines
20 KiB
C
Raw Blame History

// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Build Options
#define BUILD_TITLE "rdi_dump"
#define BUILD_CONSOLE_INTERFACE 1
////////////////////////////////
//~ rjf: Includes
//- rjf: [lib]
#include "third_party/rad_lzb_simple/rad_lzb_simple.h"
#include "third_party/rad_lzb_simple/rad_lzb_simple.c"
//- rjf: [h]
#include "base/base_inc.h"
#include "os/os_inc.h"
#include "rdi_format/rdi_format_local.h"
#include "rdi_dump.h"
//- rjf: [c]
#include "base/base_inc.c"
#include "os/os_inc.c"
#include "rdi_format/rdi_format_local.c"
#include "rdi_dump.c"
////////////////////////////////
//~ rjf: Entry Point
internal void
entry_point(CmdLine *cmd_line)
{
//////////////////////////////
//- rjf: set up
//
Arena *arena = arena_alloc();
String8List errors = {0};
//////////////////////////////
//- rjf: extract command line parameters
//
typedef U32 DumpFlags;
enum
{
DumpFlag_DataSections = (1<<0),
DumpFlag_TopLevelInfo = (1<<1),
DumpFlag_BinarySections = (1<<2),
DumpFlag_FilePaths = (1<<3),
DumpFlag_SourceFiles = (1<<4),
DumpFlag_LineTables = (1<<5),
DumpFlag_SourceLineMaps = (1<<6),
DumpFlag_Units = (1<<7),
DumpFlag_UnitVMap = (1<<8),
DumpFlag_TypeNodes = (1<<9),
DumpFlag_UDTs = (1<<10),
DumpFlag_GlobalVariables = (1<<11),
DumpFlag_GlobalVMap = (1<<12),
DumpFlag_ThreadVariables = (1<<13),
DumpFlag_Procedures = (1<<14),
DumpFlag_Scopes = (1<<15),
DumpFlag_ScopeVMap = (1<<16),
DumpFlag_InlineSites = (1<<17),
DumpFlag_NameMaps = (1<<18),
DumpFlag_Strings = (1<<19),
};
String8 input_name = {0};
DumpFlags dump_flags = (U32)0xffffffff;
{
// rjf: extract input file path
input_name = str8_list_first(&cmd_line->inputs);
// rjf: extract "only" options
{
String8List dump_options = cmd_line_strings(cmd_line, str8_lit("only"));
if(dump_options.first != 0)
{
dump_flags = 0;
for(String8Node *n = dump_options.first; n != 0; n = n->next)
{
if(0){}
else if(str8_match(n->string, str8_lit("data_sections"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_DataSections; }
else if(str8_match(n->string, str8_lit("top_level_info"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_TopLevelInfo; }
else if(str8_match(n->string, str8_lit("binary_sections"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_BinarySections; }
else if(str8_match(n->string, str8_lit("file_paths"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_FilePaths; }
else if(str8_match(n->string, str8_lit("source_files"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_SourceFiles; }
else if(str8_match(n->string, str8_lit("line_tables"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_LineTables; }
else if(str8_match(n->string, str8_lit("source_line_maps"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_SourceLineMaps; }
else if(str8_match(n->string, str8_lit("units"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_Units; }
else if(str8_match(n->string, str8_lit("unit_vmap"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_UnitVMap; }
else if(str8_match(n->string, str8_lit("type_nodes"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_TypeNodes; }
else if(str8_match(n->string, str8_lit("udt_data"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_UDTs; }
else if(str8_match(n->string, str8_lit("global_variables"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_GlobalVariables; }
else if(str8_match(n->string, str8_lit("global_vmap"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_GlobalVMap; }
else if(str8_match(n->string, str8_lit("thread_variables"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_ThreadVariables; }
else if(str8_match(n->string, str8_lit("procedures"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_Procedures; }
else if(str8_match(n->string, str8_lit("scopes"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_Scopes; }
else if(str8_match(n->string, str8_lit("scope_vmap"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_ScopeVMap; }
else if(str8_match(n->string, str8_lit("inline_sites"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_InlineSites; }
else if(str8_match(n->string, str8_lit("name_maps"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_NameMaps; }
else if(str8_match(n->string, str8_lit("strings"), StringMatchFlag_CaseInsensitive)) { dump_flags |= DumpFlag_Strings; }
}
}
}
}
//////////////////////////////
//- rjf: load file
//
String8 input_data = os_data_from_file_path(arena, input_name);
if(input_name.size == 0)
{
str8_list_pushf(arena, &errors, "error (input): No input RDI file specified.");
}
else if(input_data.size == 0)
{
str8_list_pushf(arena, &errors, "error (input): No input RDI file successfully loaded; either the path or file contents are invalid.");
}
//////////////////////////////
//- rjf: obtain initial rdi parse
//
RDI_Parsed rdi_ = {0};
RDI_Parsed *rdi = &rdi_;
RDI_ParseStatus status = rdi_parse(input_data.str, input_data.size, rdi);
//////////////////////////////
//- rjf: decompress rdi if necessary
//
{
U64 decompressed_size = rdi_decompressed_size_from_parsed(rdi);
if(decompressed_size > input_data.size)
{
U8 *decompressed_data = push_array_no_zero(arena, U8, decompressed_size);
rdi_decompress_parsed(decompressed_data, decompressed_size, rdi);
status = rdi_parse(decompressed_data, decompressed_size, rdi);
}
}
//////////////////////////////
//- rjf: error on bad parse status
//
if(status != RDI_ParseStatus_Good)
{
str8_list_pushf(arena, &errors, "error (input): RDI file could not be successfully decoded.");
}
//////////////////////////////
//- rjf: output error strings to stderr
//
for(String8Node *n = errors.first; n != 0; n = n->next)
{
fwrite(n->string.str, 1, n->string.size, stderr);
fprintf(stderr, "\n");
}
//////////////////////////////
//- rjf: build dump strings
//
String8List dump = {0};
if(errors.node_count == 0)
{
//- rjf: DATA SECTIONS
if(dump_flags & DumpFlag_DataSections)
{
str8_list_pushf(arena, &dump, "# DATA SECTIONS:\n");
rdi_stringize_data_sections(arena, &dump, rdi, 1);
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: TOP LEVEL INFO
RDI_TopLevelInfo *tli = rdi_element_from_name_idx(rdi, TopLevelInfo, 0);
if(dump_flags & DumpFlag_TopLevelInfo)
{
str8_list_pushf(arena, &dump, "# TOP LEVEL INFO:\n");
rdi_stringize_top_level_info(arena, &dump, rdi, tli, 1);
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: BINARY SECTIONS
if(dump_flags & DumpFlag_BinarySections)
{
str8_list_pushf(arena, &dump, "# BINARY SECTIONS:\n");
U64 count = 0;
RDI_BinarySection *v = rdi_table_from_name(rdi, BinarySections, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " section[%I64u]:\n", idx);
rdi_stringize_binary_section(arena, &dump, rdi, &v[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: FILE PATHS
if(dump_flags & DumpFlag_FilePaths)
{
RDI_FilePathBundle file_path_bundle = {0};
file_path_bundle.file_paths = rdi_table_from_name(rdi, FilePathNodes, &file_path_bundle.file_path_count);
str8_list_pushf(arena, &dump, "# FILE PATHS\n");
RDI_FilePathNode *ptr = file_path_bundle.file_paths;
for(U32 i = 0; i < file_path_bundle.file_path_count; i += 1, ptr += 1)
{
if(ptr->parent_path_node == 0)
{
rdi_stringize_file_path(arena, &dump, rdi, &file_path_bundle, ptr, 1);
}
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: SOURCE FILES
if(dump_flags & DumpFlag_SourceFiles)
{
str8_list_pushf(arena, &dump, "# SOURCE FILES\n");
U64 count = 0;
RDI_SourceFile *v = rdi_table_from_name(rdi, SourceFiles, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " source_file[%I64u]:\n", idx);
rdi_stringize_source_file(arena, &dump, rdi, &v[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: LINE TABLES
if(dump_flags & DumpFlag_LineTables)
{
str8_list_pushf(arena, &dump, "# LINE TABLES\n");
U64 count = 0;
RDI_LineTable *v = rdi_table_from_name(rdi, LineTables, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " line_table[%I64u]:\n", idx);
rdi_stringize_line_table(arena, &dump, rdi, &v[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: SOURCE LINE MAPS
if(dump_flags & DumpFlag_SourceLineMaps)
{
str8_list_pushf(arena, &dump, "# SOURCE LINE MAPS\n");
U64 count = 0;
RDI_SourceLineMap *v = rdi_table_from_name(rdi, SourceLineMaps, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " source_line_map[%I64u]:\n", idx);
rdi_stringize_source_line_map(arena, &dump, rdi, &v[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: UNITS
if(dump_flags & DumpFlag_Units)
{
str8_list_pushf(arena, &dump, "# UNITS\n");
U64 count = 0;
RDI_Unit *v = rdi_table_from_name(rdi, Units, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " unit[%I64u]:\n", idx);
rdi_stringize_unit(arena, &dump, rdi, &v[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: UNIT VMAP
if(dump_flags & DumpFlag_UnitVMap)
{
str8_list_pushf(arena, &dump, "# UNIT VMAP\n");
U64 count = 0;
RDI_VMapEntry *v = rdi_table_from_name(rdi, UnitVMap, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " 0x%08x: %llu\n", v[idx].voff, v[idx].idx);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: TYPE NODES
if(dump_flags & DumpFlag_TypeNodes)
{
str8_list_pushf(arena, &dump, "# TYPE NODES:\n");
U64 count = 0;
RDI_TypeNode *v = rdi_table_from_name(rdi, TypeNodes, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " type[%I64u]:\n", idx);
rdi_stringize_type_node(arena, &dump, rdi, &v[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: UDT DATA
if(dump_flags & DumpFlag_UDTs)
{
U64 all_members_count = 0;
RDI_Member *all_members = rdi_table_from_name(rdi, Members, &all_members_count);
U64 all_enum_members_count = 0;
RDI_EnumMember *all_enum_members = rdi_table_from_name(rdi, EnumMembers, &all_enum_members_count);
U64 all_udts_count = 0;
RDI_UDT *all_udts = rdi_table_from_name(rdi, UDTs, &all_udts_count);
RDI_UDTMemberBundle member_bundle = {0};
{
member_bundle.members = all_members;
member_bundle.enum_members = all_enum_members;
member_bundle.member_count = (RDI_U32)all_members_count;
member_bundle.enum_member_count = (RDI_U32)all_enum_members_count;
}
str8_list_pushf(arena, &dump, "# UDTS:\n");
for(U64 idx = 0; idx < all_udts_count; idx += 1)
{
str8_list_pushf(arena, &dump, " udt[%I64u]:\n", idx);
rdi_stringize_udt(arena, &dump, rdi, &member_bundle, &all_udts[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: GLOBAL VARIABLES
if(dump_flags & DumpFlag_GlobalVariables)
{
str8_list_pushf(arena, &dump, "# GLOBAL VARIABLES:\n");
RDI_U64 count = 0;
RDI_GlobalVariable *v = rdi_table_from_name(rdi, GlobalVariables, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " global_variable[%I64u]:\n", idx);
rdi_stringize_global_variable(arena, &dump, rdi, &v[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: GLOBAL VMAP
if(dump_flags & DumpFlag_GlobalVMap)
{
str8_list_pushf(arena, &dump, "# GLOBAL VMAP:\n");
U64 count = 0;
RDI_VMapEntry *v = rdi_table_from_name(rdi, GlobalVMap, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " 0x%08x: %llu\n", v[idx].voff, v[idx].idx);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: THREAD LOCAL VARIABLES
if(dump_flags & DumpFlag_ThreadVariables)
{
str8_list_pushf(arena, &dump, "# THREAD VARIABLES:\n");
U64 count = 0;
RDI_ThreadVariable *v = rdi_table_from_name(rdi, ThreadVariables, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " thread_variable[%I64u]:\n", idx);
rdi_stringize_thread_variable(arena, &dump, rdi, &v[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: PROCEDURES
if(dump_flags & DumpFlag_Procedures)
{
str8_list_pushf(arena, &dump, "# PROCEDURES:\n");
U64 count = 0;
RDI_Procedure *v = rdi_table_from_name(rdi, Procedures, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " procedure[%I64u]:\n", idx);
rdi_stringize_procedure(arena, &dump, rdi, &v[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: SCOPES
if(dump_flags & DumpFlag_Scopes)
{
U64 scopes_count = 0;
RDI_Scope *scopes = rdi_table_from_name(rdi, Scopes, &scopes_count);
U64 scopes_voffs_count = 0;
U64 *scopes_voffs = rdi_table_from_name(rdi, ScopeVOffData, &scopes_voffs_count);
U64 locals_count = 0;
RDI_Local *locals = rdi_table_from_name(rdi, Locals, &locals_count);
U64 location_block_count = 0;
RDI_LocationBlock *location_blocks = rdi_table_from_name(rdi, LocationBlocks, &location_block_count);
U64 location_data_size = 0;
RDI_U8 *location_data = rdi_table_from_name(rdi, LocationData, &location_data_size);
RDI_ScopeBundle scope_bundle = {0};
{
scope_bundle.scopes = scopes;
scope_bundle.scope_count = scopes_count;
scope_bundle.scope_voffs = scopes_voffs;
scope_bundle.scope_voff_count = scopes_voffs_count;
scope_bundle.locals = locals;
scope_bundle.local_count = locals_count;
scope_bundle.location_blocks = location_blocks;
scope_bundle.location_block_count = location_block_count;
scope_bundle.location_data = location_data;
scope_bundle.location_data_size = location_data_size;
}
str8_list_pushf(arena, &dump, "# SCOPES:\n");
for(U64 idx = 0; idx < scopes_count; idx += 1)
{
if(scopes[idx].parent_scope_idx == 0)
{
rdi_stringize_scope(arena, &dump, rdi, tli->arch, &scope_bundle, &scopes[idx], 1);
}
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: SCOPE VMAP
if(dump_flags & DumpFlag_ScopeVMap)
{
str8_list_pushf(arena, &dump, "# SCOPE VMAP:\n");
U64 count = 0;
RDI_VMapEntry *v = rdi_table_from_name(rdi, ScopeVMap, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " 0x%08x: %llu\n", v[idx].voff, v[idx].idx);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: INLINE SITES
if(dump_flags & DumpFlag_InlineSites)
{
str8_list_pushf(arena, &dump, "# INLINE SITES:\n");
U64 count = 0;
RDI_InlineSite *v = rdi_table_from_name(rdi, InlineSites, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
str8_list_pushf(arena, &dump, " inline_site[%I64u]:\n", idx);
rdi_stringize_inline_site(arena, &dump, rdi, &v[idx], 2);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: NAME MAPS
if(dump_flags & DumpFlag_NameMaps)
{
str8_list_pushf(arena, &dump, "# NAME MAP:\n");
U64 count = 0;
RDI_NameMap *v = rdi_table_from_name(rdi, NameMaps, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
RDI_ParsedNameMap name_map = {0};
rdi_parsed_from_name_map(rdi, &v[idx], &name_map);
str8_list_pushf(arena, &dump, " name_map[%I64u]:\n", idx);
RDI_NameMapBucket *bucket = name_map.buckets;
for(U32 j = 0; j < name_map.bucket_count; j += 1, bucket += 1)
{
if(bucket->node_count > 0)
{
str8_list_pushf(arena, &dump, " bucket[%u]:\n", j);
RDI_NameMapNode *node = name_map.nodes + bucket->first_node;
RDI_NameMapNode *node_opl = node + bucket->node_count;
for(;node < node_opl; node += 1)
{
String8 string = {0};
string.str = rdi_string_from_idx(rdi, node->string_idx, &string.size);
str8_list_pushf(arena, &dump, " match \"%.*s\": ", str8_varg(string));
if(node->match_count == 1)
{
str8_list_pushf(arena, &dump, "%u", node->match_idx_or_idx_run_first);
}
else
{
RDI_U32 idx_count = 0;
RDI_U32 *idx_run =
rdi_idx_run_from_first_count(rdi, node->match_idx_or_idx_run_first,
node->match_count, &idx_count);
if(idx_count > 0)
{
RDI_U32 last = idx_count - 1;
for(U32 k = 0; k < last; k += 1)
{
str8_list_pushf(arena, &dump, "%u, ", idx_run[k]);
}
str8_list_pushf(arena, &dump, "%u", idx_run[last]);
}
}
str8_list_pushf(arena, &dump, "\n");
}
}
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
//- rjf: STRINGS
if(dump_flags & DumpFlag_Strings)
{
str8_list_pushf(arena, &dump, "# STRINGS:\n");
U64 count = 0;
U32 *v = rdi_table_from_name(rdi, StringTable, &count);
for(U64 idx = 0; idx < count; idx += 1)
{
String8 string = {0};
string.str = rdi_string_from_idx(rdi, (RDI_U32)idx, &string.size);
str8_list_pushf(arena, &dump, " string[%I64u]: \"%S\"\n", idx, string);
}
str8_list_push(arena, &dump, str8_lit("\n"));
}
}
//////////////////////////////
//- rjf: write dump to stdout
//
for(String8Node *n = dump.first; n != 0; n = n->next)
{
fwrite(n->string.str, 1, n->string.size, stdout);
}
}
Reference in New Issue View Git Blame Copy Permalink