diff --git a/3rdparty/ccc/CMakeLists.txt b/3rdparty/ccc/CMakeLists.txt
new file mode 100644
index 0000000000..7ecffbdca6
--- /dev/null
+++ b/3rdparty/ccc/CMakeLists.txt
@@ -0,0 +1,41 @@
+cmake_minimum_required(VERSION 3.14)
+project(ccc)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+add_library(ccc STATIC
+ src/ccc/ast.cpp
+ src/ccc/ast.h
+ src/ccc/elf.cpp
+ src/ccc/elf.h
+ src/ccc/elf_symtab.cpp
+ src/ccc/elf_symtab.h
+ src/ccc/importer_flags.cpp
+ src/ccc/importer_flags.h
+ src/ccc/mdebug_analysis.cpp
+ src/ccc/mdebug_analysis.h
+ src/ccc/mdebug_importer.cpp
+ src/ccc/mdebug_importer.h
+ src/ccc/mdebug_section.cpp
+ src/ccc/mdebug_section.h
+ src/ccc/mdebug_symbols.cpp
+ src/ccc/mdebug_symbols.h
+ src/ccc/sndll.cpp
+ src/ccc/sndll.h
+ src/ccc/stabs.cpp
+ src/ccc/stabs.h
+ src/ccc/stabs_to_ast.cpp
+ src/ccc/stabs_to_ast.h
+ src/ccc/symbol_database.cpp
+ src/ccc/symbol_database.h
+ src/ccc/symbol_file.cpp
+ src/ccc/symbol_file.h
+ src/ccc/symbol_table.cpp
+ src/ccc/symbol_table.h
+ src/ccc/util.cpp
+ src/ccc/util.h
+)
+
+target_include_directories(ccc PUBLIC src)
diff --git a/3rdparty/ccc/README.md b/3rdparty/ccc/README.md
new file mode 100644
index 0000000000..9c8f1efecf
--- /dev/null
+++ b/3rdparty/ccc/README.md
@@ -0,0 +1,37 @@
+# Chaos Compiler Collection
+
+This code was originally developed in the following repository and was copied
+into PCSX2 by the author:
+
+- [https://github.com/chaoticgd/ccc](https://github.com/chaoticgd/ccc)
+
+It includes additional resources that are not present in the PCSX2 repository.
+
+## Documentation
+
+### DWARF (.debug) Section
+
+- [DWARF Debugging Information Format](https://dwarfstd.org/doc/dwarf_1_1_0.pdf)
+
+### MIPS Debug (.mdebug) Section
+
+- [Third Eye Software and the MIPS symbol table (Peter Rowell)](http://datahedron.com/mips.html)
+- [MIPS Mdebug Debugging Information (David Anderson, 1996)](https://www.prevanders.net/Mdebug.ps)
+- MIPS Assembly Language Programmer's Guide, Symbol Table Chapter (Silicon Graphics, 1992)
+- Tru64 UNIX Object File and Symbol Table Format Specification, Symbol Table Chapter
+- `mdebugread.c` from gdb (reading)
+- `ecoff.c` from gas (writing)
+- `include/coff/sym.h` from binutils (headers)
+
+### MIPS EABI
+
+- [MIPS EABI](https://sourceware.org/legacy-ml/binutils/2003-06/msg00436.html)
+
+### STABS
+
+- [The "stabs" representation of debugging information (Julia Menapace, Jim Kingdon, and David MacKenzie, 1992-???)](https://sourceware.org/gdb/onlinedocs/stabs.html)
+- `stabs.c` from binutils (reading)
+- `stabsread.c` from gdb (reading)
+- `dbxread.c` from gdb (reading)
+- `dbxout.c` from gcc (writing)
+- `stab.def` from gcc (symbol codes)
diff --git a/3rdparty/ccc/ccc.vcxproj b/3rdparty/ccc/ccc.vcxproj
new file mode 100644
index 0000000000..16ab210948
--- /dev/null
+++ b/3rdparty/ccc/ccc.vcxproj
@@ -0,0 +1,75 @@
+
+
+
+
+
+ {2589F8CE-EA77-4B73-911E-64074569795B}
+
+
+
+ StaticLibrary
+ $(DefaultPlatformToolset)
+ ClangCL
+ MultiByte
+ true
+ true
+ false
+
+
+
+
+
+
+
+
+
+
+
+
+
+ AllRules.ruleset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ TurnOffAllWarnings
+ $(ProjectDir)src;%(AdditionalIncludeDirectories)
+ stdcpp20
+
+
+
+
+
diff --git a/3rdparty/ccc/ccc.vcxproj.filters b/3rdparty/ccc/ccc.vcxproj.filters
new file mode 100644
index 0000000000..9f49bde786
--- /dev/null
+++ b/3rdparty/ccc/ccc.vcxproj.filters
@@ -0,0 +1,111 @@
+
+
+
+
+ {4FC737F1-C7A5-4376-A066-2A32D752A2FF}
+ cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx
+
+
+ {93995380-89BD-4b04-88EB-625FBE52EBFB}
+ h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd
+
+
+ {67DA6AB6-F800-4c08-8B7A-83BB121AAD01}
+ rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms
+
+
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+
diff --git a/3rdparty/ccc/src/ccc/ast.cpp b/3rdparty/ccc/src/ccc/ast.cpp
new file mode 100644
index 0000000000..fb5709d366
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/ast.cpp
@@ -0,0 +1,562 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#include "ast.h"
+
+#include "importer_flags.h"
+#include "symbol_database.h"
+
+namespace ccc::ast {
+
+static bool compare_nodes_and_merge(
+ CompareResult& dest, const Node& node_lhs, const Node& node_rhs, const SymbolDatabase* database);
+static bool try_to_match_wobbly_typedefs(
+ const Node& node_lhs, const Node& node_rhs, const SymbolDatabase& database);
+
+void Node::set_access_specifier(AccessSpecifier specifier, u32 importer_flags)
+{
+ if((importer_flags & NO_ACCESS_SPECIFIERS) == 0) {
+ access_specifier = specifier;
+ }
+}
+
+std::pair Node::physical_type(SymbolDatabase& database, s32 max_depth)
+{
+ Node* type = this;
+ DataType* symbol = nullptr;
+ for(s32 i = 0; i < max_depth && type->descriptor == TYPE_NAME; i++) {
+ DataType* data_type = database.data_types.symbol_from_handle(type->as().data_type_handle);
+ if (!data_type || !data_type->type()) {
+ break;
+ }
+
+ type = data_type->type();
+ symbol = data_type;
+ }
+
+ return std::pair(type, symbol);
+}
+
+std::pair Node::physical_type(const SymbolDatabase& database, s32 max_depth) const
+{
+ return const_cast(this)->physical_type(const_cast(database), max_depth);
+}
+
+const char* member_function_modifier_to_string(MemberFunctionModifier modifier)
+{
+ switch(modifier) {
+ case MemberFunctionModifier::NONE: return "none";
+ case MemberFunctionModifier::STATIC: return "static";
+ case MemberFunctionModifier::VIRTUAL: return "virtual";
+ }
+ return "";
+}
+
+bool StructOrUnion::flatten_fields(
+ std::vector& output,
+ const DataType* symbol,
+ const SymbolDatabase& database,
+ bool skip_statics,
+ s32 base_offset,
+ s32 max_fields,
+ s32 max_depth) const
+{
+ if(max_depth == 0) {
+ return false;
+ }
+
+ for(const std::unique_ptr& type_name : base_classes) {
+ if(type_name->descriptor != TYPE_NAME) {
+ continue;
+ }
+
+ s32 new_base_offset = base_offset + type_name->offset_bytes;
+
+ DataTypeHandle handle = type_name->as().data_type_handle;
+ const DataType* base_class_symbol = database.data_types.symbol_from_handle(handle);
+ if(!base_class_symbol || !base_class_symbol->type() || base_class_symbol->type()->descriptor != STRUCT_OR_UNION) {
+ continue;
+ }
+
+ const StructOrUnion& base_class = base_class_symbol->type()->as();
+ if(!base_class.flatten_fields(output, base_class_symbol, database, skip_statics, new_base_offset, max_fields, max_depth - 1)) {
+ return false;
+ }
+ }
+
+ for(const std::unique_ptr& field : fields) {
+ if(skip_statics && field->storage_class == STORAGE_CLASS_STATIC) {
+ continue;
+ }
+
+ if((s32) output.size() >= max_fields) {
+ return false;
+ }
+
+ FlatField& flat = output.emplace_back();
+ flat.node = field.get();
+ flat.symbol = symbol;
+ flat.base_offset = base_offset;
+ }
+
+ return true;
+}
+
+const char* type_name_source_to_string(TypeNameSource source)
+{
+ switch(source) {
+ case TypeNameSource::REFERENCE: return "reference";
+ case TypeNameSource::CROSS_REFERENCE: return "cross_reference";
+ case TypeNameSource::UNNAMED_THIS: return "this";
+ }
+ return "";
+}
+
+const char* forward_declared_type_to_string(ForwardDeclaredType type)
+{
+ switch(type) {
+ case ForwardDeclaredType::STRUCT: return "struct";
+ case ForwardDeclaredType::UNION: return "union";
+ case ForwardDeclaredType::ENUM: return "enum";
+ }
+ return "";
+}
+
+DataTypeHandle TypeName::data_type_handle_unless_forward_declared() const
+{
+ if(!is_forward_declared) {
+ return data_type_handle;
+ } else {
+ return DataTypeHandle();
+ }
+}
+
+CompareResult compare_nodes(
+ const Node& node_lhs, const Node& node_rhs, const SymbolDatabase* database, bool check_intrusive_fields)
+{
+ CompareResult result = CompareResultType::MATCHES_NO_SWAP;
+
+ if(node_lhs.descriptor != node_rhs.descriptor) {
+ return CompareFailReason::DESCRIPTOR;
+ }
+
+ if(check_intrusive_fields) {
+ if(node_lhs.storage_class != node_rhs.storage_class) {
+ // In some cases we can determine that a type was typedef'd for C
+ // translation units, but not for C++ translation units, so we need
+ // to add a special case for that here.
+ if(node_lhs.storage_class == STORAGE_CLASS_TYPEDEF && node_rhs.storage_class == STORAGE_CLASS_NONE) {
+ result = CompareResultType::MATCHES_FAVOUR_LHS;
+ } else if(node_lhs.storage_class == STORAGE_CLASS_NONE && node_rhs.storage_class == STORAGE_CLASS_TYPEDEF) {
+ result = CompareResultType::MATCHES_FAVOUR_RHS;
+ } else {
+ return CompareFailReason::STORAGE_CLASS;
+ }
+ }
+
+ // Vtable pointers and constructors can sometimes contain type numbers
+ // that are different between translation units, so we don't want to
+ // compare them.
+ bool is_vtable_pointer = node_lhs.is_vtable_pointer && node_rhs.is_vtable_pointer;
+ bool is_numbered_constructor = node_lhs.name.starts_with("$_") && node_rhs.name.starts_with("$_");
+ if(node_lhs.name != node_rhs.name && !is_vtable_pointer && !is_numbered_constructor) {
+ return CompareFailReason::NAME;
+ }
+
+ if(node_lhs.offset_bytes != node_rhs.offset_bytes) {
+ return CompareFailReason::RELATIVE_OFFSET_BYTES;
+ }
+
+ if(node_lhs.size_bits != node_rhs.size_bits) {
+ return CompareFailReason::SIZE_BITS;
+ }
+
+ if(node_lhs.is_const != node_rhs.is_const) {
+ return CompareFailReason::CONSTNESS;
+ }
+ }
+
+ switch(node_lhs.descriptor) {
+ case ARRAY: {
+ const auto [lhs, rhs] = Node::as(node_lhs, node_rhs);
+
+ if(compare_nodes_and_merge(result, *lhs.element_type.get(), *rhs.element_type.get(), database)) {
+ return result;
+ }
+
+ if(lhs.element_count != rhs.element_count) {
+ return CompareFailReason::ARRAY_ELEMENT_COUNT;
+ }
+
+ break;
+ }
+ case BITFIELD: {
+ const auto [lhs, rhs] = Node::as(node_lhs, node_rhs);
+
+ if(lhs.bitfield_offset_bits != rhs.bitfield_offset_bits) {
+ return CompareFailReason::BITFIELD_OFFSET_BITS;
+ }
+
+ if(compare_nodes_and_merge(result, *lhs.underlying_type.get(), *rhs.underlying_type.get(), database)) {
+ return result;
+ }
+
+ break;
+ }
+ case BUILTIN: {
+ const auto [lhs, rhs] = Node::as(node_lhs, node_rhs);
+
+ if(lhs.bclass != rhs.bclass) {
+ return CompareFailReason::BUILTIN_CLASS;
+ }
+
+ break;
+ }
+ case ENUM: {
+ const auto [lhs, rhs] = Node::as(node_lhs, node_rhs);
+
+ if(lhs.constants != rhs.constants) {
+ return CompareFailReason::ENUM_CONSTANTS;
+ }
+
+ break;
+ }
+ case ERROR_NODE: {
+ break;
+ }
+ case FUNCTION: {
+ const auto [lhs, rhs] = Node::as(node_lhs, node_rhs);
+
+ if(lhs.return_type.has_value() != rhs.return_type.has_value()) {
+ return CompareFailReason::FUNCTION_RETURN_TYPE_HAS_VALUE;
+ }
+
+ if(lhs.return_type.has_value()) {
+ if(compare_nodes_and_merge(result, *lhs.return_type->get(), *rhs.return_type->get(), database)) {
+ return result;
+ }
+ }
+
+ if(lhs.parameters.has_value() && rhs.parameters.has_value()) {
+ if(lhs.parameters->size() != rhs.parameters->size()) {
+ return CompareFailReason::FUNCTION_PARAMAETER_COUNT;
+ }
+ for(size_t i = 0; i < lhs.parameters->size(); i++) {
+ if(compare_nodes_and_merge(result, *(*lhs.parameters)[i].get(), *(*rhs.parameters)[i].get(), database)) {
+ return result;
+ }
+ }
+ } else if(lhs.parameters.has_value() != rhs.parameters.has_value()) {
+ return CompareFailReason::FUNCTION_PARAMETERS_HAS_VALUE;
+ }
+
+ if(lhs.modifier != rhs.modifier) {
+ return CompareFailReason::FUNCTION_MODIFIER;
+ }
+
+ break;
+ }
+ case POINTER_OR_REFERENCE: {
+ const auto [lhs, rhs] = Node::as(node_lhs, node_rhs);
+
+ if(lhs.is_pointer != rhs.is_pointer) {
+ return CompareFailReason::DESCRIPTOR;
+ }
+
+ if(compare_nodes_and_merge(result, *lhs.value_type.get(), *rhs.value_type.get(), database)) {
+ return result;
+ }
+
+ break;
+ }
+ case POINTER_TO_DATA_MEMBER: {
+ const auto [lhs, rhs] = Node::as(node_lhs, node_rhs);
+
+ if(compare_nodes_and_merge(result, *lhs.class_type.get(), *rhs.class_type.get(), database)) {
+ return result;
+ }
+
+ if(compare_nodes_and_merge(result, *lhs.member_type.get(), *rhs.member_type.get(), database)) {
+ return result;
+ }
+
+ break;
+ }
+ case STRUCT_OR_UNION: {
+ const auto [lhs, rhs] = Node::as(node_lhs, node_rhs);
+
+ if(lhs.is_struct != rhs.is_struct) {
+ return CompareFailReason::DESCRIPTOR;
+ }
+
+ if(lhs.base_classes.size() != rhs.base_classes.size()) {
+ return CompareFailReason::BASE_CLASS_COUNT;
+ }
+
+ for(size_t i = 0; i < lhs.base_classes.size(); i++) {
+ if(compare_nodes_and_merge(result, *lhs.base_classes[i].get(), *rhs.base_classes[i].get(), database)) {
+ return result;
+ }
+ }
+
+ if(lhs.fields.size() != rhs.fields.size()) {
+ return CompareFailReason::FIELDS_SIZE;
+ }
+
+ for(size_t i = 0; i < lhs.fields.size(); i++) {
+ if(compare_nodes_and_merge(result, *lhs.fields[i].get(), *rhs.fields[i].get(), database)) {
+ return result;
+ }
+ }
+
+ if(lhs.member_functions.size() != rhs.member_functions.size()) {
+ return CompareFailReason::MEMBER_FUNCTION_COUNT;
+ }
+
+ for(size_t i = 0; i < lhs.member_functions.size(); i++) {
+ if(compare_nodes_and_merge(result, *lhs.member_functions[i].get(), *rhs.member_functions[i].get(), database)) {
+ return result;
+ }
+ }
+
+ break;
+ }
+ case TYPE_NAME: {
+ const auto [lhs, rhs] = Node::as(node_lhs, node_rhs);
+
+ // Don't check the source so that REFERENCE and CROSS_REFERENCE are
+ // treated as the same.
+ if(lhs.data_type_handle != rhs.data_type_handle) {
+ return CompareFailReason::TYPE_NAME;
+ }
+
+ const TypeName::UnresolvedStabs* lhs_unresolved_stabs = lhs.unresolved_stabs.get();
+ const TypeName::UnresolvedStabs* rhs_unresolved_stabs = rhs.unresolved_stabs.get();
+ if(lhs_unresolved_stabs && rhs_unresolved_stabs) {
+ if(lhs_unresolved_stabs->type_name != rhs_unresolved_stabs->type_name) {
+ return CompareFailReason::TYPE_NAME;
+ }
+ } else if(lhs_unresolved_stabs || rhs_unresolved_stabs) {
+ return CompareFailReason::TYPE_NAME;
+ }
+
+ break;
+ }
+ }
+ return result;
+}
+
+static bool compare_nodes_and_merge(
+ CompareResult& dest, const Node& node_lhs, const Node& node_rhs, const SymbolDatabase* database)
+{
+ CompareResult result = compare_nodes(node_lhs, node_rhs, database, true);
+ if(database) {
+ if(result.type == CompareResultType::DIFFERS && try_to_match_wobbly_typedefs(node_lhs, node_rhs, *database)) {
+ result.type = CompareResultType::MATCHES_FAVOUR_LHS;
+ } else if(result.type == CompareResultType::DIFFERS && try_to_match_wobbly_typedefs(node_rhs, node_lhs, *database)) {
+ result.type = CompareResultType::MATCHES_FAVOUR_RHS;
+ }
+ }
+
+ if(dest.type != result.type) {
+ if(dest.type == CompareResultType::DIFFERS || result.type == CompareResultType::DIFFERS) {
+ // If any of the inner types differ, the outer type does too.
+ dest.type = CompareResultType::DIFFERS;
+ } else if(dest.type == CompareResultType::MATCHES_CONFUSED || result.type == CompareResultType::MATCHES_CONFUSED) {
+ // Propagate confusion.
+ dest.type = CompareResultType::MATCHES_CONFUSED;
+ } else if(dest.type == CompareResultType::MATCHES_FAVOUR_LHS && result.type == CompareResultType::MATCHES_FAVOUR_RHS) {
+ // One of the results favours the LHS node and the other favours the
+ // RHS node so we are confused.
+ dest.type = CompareResultType::MATCHES_CONFUSED;
+ } else if(dest.type == CompareResultType::MATCHES_FAVOUR_RHS && result.type == CompareResultType::MATCHES_FAVOUR_LHS) {
+ // One of the results favours the LHS node and the other favours the
+ // RHS node so we are confused.
+ dest.type = CompareResultType::MATCHES_CONFUSED;
+ } else if(dest.type == CompareResultType::MATCHES_FAVOUR_LHS || result.type == CompareResultType::MATCHES_FAVOUR_LHS) {
+ // One of the results favours the LHS node and the other is neutral
+ // so go with the LHS node.
+ dest.type = CompareResultType::MATCHES_FAVOUR_LHS;
+ } else if(dest.type == CompareResultType::MATCHES_FAVOUR_RHS || result.type == CompareResultType::MATCHES_FAVOUR_RHS) {
+ // One of the results favours the RHS node and the other is neutral
+ // so go with the RHS node.
+ dest.type = CompareResultType::MATCHES_FAVOUR_RHS;
+ }
+ }
+
+ if(dest.fail_reason == CompareFailReason::NONE) {
+ dest.fail_reason = result.fail_reason;
+ }
+
+ return dest.type == CompareResultType::DIFFERS;
+}
+
+static bool try_to_match_wobbly_typedefs(
+ const Node& type_name_node, const Node& raw_node, const SymbolDatabase& database)
+{
+ // Detect if one side has a typedef when the other just has the plain type.
+ // This was previously a common reason why type deduplication would fail.
+ if(type_name_node.descriptor != TYPE_NAME) {
+ return false;
+ }
+
+ const TypeName& type_name = type_name_node.as();
+ if(const TypeName::UnresolvedStabs* unresolved_stabs = type_name.unresolved_stabs.get()) {
+ if(unresolved_stabs->referenced_file_handle == (u32) -1 || !unresolved_stabs->stabs_type_number.valid()) {
+ return false;
+ }
+
+ const SourceFile* source_file =
+ database.source_files.symbol_from_handle(unresolved_stabs->referenced_file_handle);
+ CCC_ASSERT(source_file);
+
+ auto handle = source_file->stabs_type_number_to_handle.find(unresolved_stabs->stabs_type_number);
+ if(handle != source_file->stabs_type_number_to_handle.end()) {
+ const DataType* referenced_type = database.data_types.symbol_from_handle(handle->second);
+ CCC_ASSERT(referenced_type && referenced_type->type());
+ // Don't compare 'intrusive' fields e.g. the offset.
+ CompareResult new_result = compare_nodes(*referenced_type->type(), raw_node, &database, false);
+ if(new_result.type != CompareResultType::DIFFERS) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+const char* compare_fail_reason_to_string(CompareFailReason reason)
+{
+ switch(reason) {
+ case CompareFailReason::NONE: return "error";
+ case CompareFailReason::DESCRIPTOR: return "descriptor";
+ case CompareFailReason::STORAGE_CLASS: return "storage class";
+ case CompareFailReason::NAME: return "name";
+ case CompareFailReason::RELATIVE_OFFSET_BYTES: return "relative offset";
+ case CompareFailReason::ABSOLUTE_OFFSET_BYTES: return "absolute offset";
+ case CompareFailReason::BITFIELD_OFFSET_BITS: return "bitfield offset";
+ case CompareFailReason::SIZE_BITS: return "size";
+ case CompareFailReason::CONSTNESS: return "constness";
+ case CompareFailReason::ARRAY_ELEMENT_COUNT: return "array element count";
+ case CompareFailReason::BUILTIN_CLASS: return "builtin class";
+ case CompareFailReason::FUNCTION_RETURN_TYPE_HAS_VALUE: return "function return type has value";
+ case CompareFailReason::FUNCTION_PARAMAETER_COUNT: return "function paramaeter count";
+ case CompareFailReason::FUNCTION_PARAMETERS_HAS_VALUE: return "function parameter";
+ case CompareFailReason::FUNCTION_MODIFIER: return "function modifier";
+ case CompareFailReason::ENUM_CONSTANTS: return "enum constant";
+ case CompareFailReason::BASE_CLASS_COUNT: return "base class count";
+ case CompareFailReason::FIELDS_SIZE: return "fields size";
+ case CompareFailReason::MEMBER_FUNCTION_COUNT: return "member function count";
+ case CompareFailReason::VTABLE_GLOBAL: return "vtable global";
+ case CompareFailReason::TYPE_NAME: return "type name";
+ case CompareFailReason::VARIABLE_CLASS: return "variable class";
+ case CompareFailReason::VARIABLE_TYPE: return "variable type";
+ case CompareFailReason::VARIABLE_STORAGE: return "variable storage";
+ case CompareFailReason::VARIABLE_BLOCK: return "variable block";
+ }
+ return "";
+}
+
+const char* node_type_to_string(const Node& node)
+{
+ switch(node.descriptor) {
+ case ARRAY: return "array";
+ case BITFIELD: return "bitfield";
+ case BUILTIN: return "builtin";
+ case ENUM: return "enum";
+ case ERROR_NODE: return "error";
+ case FUNCTION: return "function";
+ case POINTER_OR_REFERENCE: {
+ const PointerOrReference& pointer_or_reference = node.as();
+ if(pointer_or_reference.is_pointer) {
+ return "pointer";
+ } else {
+ return "reference";
+ }
+ }
+ case POINTER_TO_DATA_MEMBER: return "pointer_to_data_member";
+ case STRUCT_OR_UNION: {
+ const StructOrUnion& struct_or_union = node.as();
+ if(struct_or_union.is_struct) {
+ return "struct";
+ } else {
+ return "union";
+ }
+ }
+ case TYPE_NAME: return "type_name";
+ }
+ return "";
+}
+
+const char* storage_class_to_string(StorageClass storage_class)
+{
+ switch(storage_class) {
+ case STORAGE_CLASS_NONE: return "none";
+ case STORAGE_CLASS_TYPEDEF: return "typedef";
+ case STORAGE_CLASS_EXTERN: return "extern";
+ case STORAGE_CLASS_STATIC: return "static";
+ case STORAGE_CLASS_AUTO: return "auto";
+ case STORAGE_CLASS_REGISTER: return "register";
+ }
+ return "";
+}
+
+const char* access_specifier_to_string(AccessSpecifier specifier)
+{
+ switch(specifier) {
+ case AS_PUBLIC: return "public";
+ case AS_PROTECTED: return "protected";
+ case AS_PRIVATE: return "private";
+ }
+ return "";
+}
+
+const char* builtin_class_to_string(BuiltInClass bclass)
+{
+ switch(bclass) {
+ case BuiltInClass::VOID_TYPE: return "void";
+ case BuiltInClass::UNSIGNED_8: return "8-bit unsigned integer";
+ case BuiltInClass::SIGNED_8: return "8-bit signed integer";
+ case BuiltInClass::UNQUALIFIED_8: return "8-bit integer";
+ case BuiltInClass::BOOL_8: return "8-bit boolean";
+ case BuiltInClass::UNSIGNED_16: return "16-bit unsigned integer";
+ case BuiltInClass::SIGNED_16: return "16-bit signed integer";
+ case BuiltInClass::UNSIGNED_32: return "32-bit unsigned integer";
+ case BuiltInClass::SIGNED_32: return "32-bit signed integer";
+ case BuiltInClass::FLOAT_32: return "32-bit floating point";
+ case BuiltInClass::UNSIGNED_64: return "64-bit unsigned integer";
+ case BuiltInClass::SIGNED_64: return "64-bit signed integer";
+ case BuiltInClass::FLOAT_64: return "64-bit floating point";
+ case BuiltInClass::UNSIGNED_128: return "128-bit unsigned integer";
+ case BuiltInClass::SIGNED_128: return "128-bit signed integer";
+ case BuiltInClass::UNQUALIFIED_128: return "128-bit integer";
+ case BuiltInClass::FLOAT_128: return "128-bit floating point";
+ }
+ return "";
+}
+
+s32 builtin_class_size(BuiltInClass bclass)
+{
+ switch(bclass) {
+ case BuiltInClass::VOID_TYPE: return 0;
+ case BuiltInClass::UNSIGNED_8: return 1;
+ case BuiltInClass::SIGNED_8: return 1;
+ case BuiltInClass::UNQUALIFIED_8: return 1;
+ case BuiltInClass::BOOL_8: return 1;
+ case BuiltInClass::UNSIGNED_16: return 2;
+ case BuiltInClass::SIGNED_16: return 2;
+ case BuiltInClass::UNSIGNED_32: return 4;
+ case BuiltInClass::SIGNED_32: return 4;
+ case BuiltInClass::FLOAT_32: return 4;
+ case BuiltInClass::UNSIGNED_64: return 8;
+ case BuiltInClass::SIGNED_64: return 8;
+ case BuiltInClass::FLOAT_64: return 8;
+ case BuiltInClass::UNSIGNED_128: return 16;
+ case BuiltInClass::SIGNED_128: return 16;
+ case BuiltInClass::UNQUALIFIED_128: return 16;
+ case BuiltInClass::FLOAT_128: return 16;
+ }
+ return 0;
+}
+
+}
diff --git a/3rdparty/ccc/src/ccc/ast.h b/3rdparty/ccc/src/ccc/ast.h
new file mode 100644
index 0000000000..a34fa2e446
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/ast.h
@@ -0,0 +1,377 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "symbol_database.h"
+
+namespace ccc::ast {
+
+enum NodeDescriptor : u8 {
+ ARRAY,
+ BITFIELD,
+ BUILTIN,
+ ENUM,
+ ERROR_NODE,
+ FUNCTION,
+ POINTER_OR_REFERENCE,
+ POINTER_TO_DATA_MEMBER,
+ STRUCT_OR_UNION,
+ TYPE_NAME
+};
+
+enum AccessSpecifier {
+ AS_PUBLIC = 0,
+ AS_PROTECTED = 1,
+ AS_PRIVATE = 2
+};
+
+// To add a new type of node:
+// 1. Add it to the NodeDescriptor enum.
+// 2. Create a struct for it.
+// 3. Add support for it in for_each_node.
+// 4. Add support for it in compute_size_bytes_recursive.
+// 5. Add support for it in compare_nodes.
+// 6. Add support for it in node_type_to_string.
+// 7. Add support for it in CppPrinter::ast_node.
+// 8. Add support for it in write_json.
+// 9. Add support for it in refine_node.
+struct Node {
+ const NodeDescriptor descriptor;
+ u8 is_const : 1 = false;
+ u8 is_volatile : 1 = false;
+ u8 is_virtual_base_class : 1 = false;
+ u8 is_vtable_pointer : 1 = false;
+ u8 is_constructor_or_destructor : 1 = false;
+ u8 is_special_member_function : 1 = false;
+ u8 is_operator_member_function : 1 = false;
+ u8 cannot_compute_size : 1 = false;
+ u8 storage_class : 4 = STORAGE_CLASS_NONE;
+ u8 access_specifier : 2 = AS_PUBLIC;
+
+ s32 size_bytes = -1;
+
+ // If the name isn't populated for a given node, the name from the last
+ // ancestor to have one should be used i.e. when processing the tree you
+ // should pass the name down.
+ std::string name;
+
+ s32 offset_bytes = -1; // Offset relative to start of last inline struct/union.
+ s32 size_bits = -1; // Size stored in the .mdebug symbol table, may not be set.
+
+ Node(NodeDescriptor d) : descriptor(d) {}
+ Node(const Node& rhs) = default;
+ virtual ~Node() {}
+
+ template
+ SubType& as() {
+ CCC_ASSERT(descriptor == SubType::DESCRIPTOR);
+ return *static_cast(this);
+ }
+
+ template
+ const SubType& as() const {
+ CCC_ASSERT(descriptor == SubType::DESCRIPTOR);
+ return *static_cast(this);
+ }
+
+ template
+ static std::pair as(const Node& lhs, const Node& rhs) {
+ CCC_ASSERT(lhs.descriptor == SubType::DESCRIPTOR && rhs.descriptor == SubType::DESCRIPTOR);
+ return std::pair(static_cast(lhs), static_cast(rhs));
+ }
+
+ void set_access_specifier(AccessSpecifier specifier, u32 importer_flags);
+
+ // If this node is a type name, repeatedly resolve it to the type it's
+ // referencing, otherwise return (this, nullptr).
+ std::pair physical_type(SymbolDatabase& database, s32 max_depth = 100);
+ std::pair physical_type(const SymbolDatabase& database, s32 max_depth = 100) const;
+};
+
+struct Array : Node {
+ std::unique_ptr element_type;
+ s32 element_count = -1;
+
+ Array() : Node(DESCRIPTOR) {}
+ static const constexpr NodeDescriptor DESCRIPTOR = ARRAY;
+};
+
+struct BitField : Node {
+ s32 bitfield_offset_bits = -1; // Offset relative to the last byte (not the position of the underlying type!).
+ std::unique_ptr underlying_type;
+
+ BitField() : Node(DESCRIPTOR) {}
+ static const constexpr NodeDescriptor DESCRIPTOR = BITFIELD;
+};
+
+enum class BuiltInClass {
+ VOID_TYPE,
+ UNSIGNED_8, SIGNED_8, UNQUALIFIED_8, BOOL_8,
+ UNSIGNED_16, SIGNED_16,
+ UNSIGNED_32, SIGNED_32, FLOAT_32,
+ UNSIGNED_64, SIGNED_64, FLOAT_64,
+ UNSIGNED_128, SIGNED_128, UNQUALIFIED_128, FLOAT_128
+};
+
+struct BuiltIn : Node {
+ BuiltInClass bclass = BuiltInClass::VOID_TYPE;
+
+ BuiltIn() : Node(DESCRIPTOR) {}
+ static const constexpr NodeDescriptor DESCRIPTOR = BUILTIN;
+};
+
+struct Enum : Node {
+ std::vector> constants;
+
+ Enum() : Node(DESCRIPTOR) {}
+ static const constexpr NodeDescriptor DESCRIPTOR = ENUM;
+};
+
+struct Error : Node {
+ std::string message;
+
+ Error() : Node(ERROR_NODE) {}
+ static const constexpr NodeDescriptor DESCRIPTOR = ERROR_NODE;
+};
+
+enum class MemberFunctionModifier {
+ NONE,
+ STATIC,
+ VIRTUAL
+};
+
+const char* member_function_modifier_to_string(MemberFunctionModifier modifier);
+
+struct Function : Node {
+ std::optional> return_type;
+ std::optional>> parameters;
+ MemberFunctionModifier modifier = MemberFunctionModifier::NONE;
+ s32 vtable_index = -1;
+ FunctionHandle definition_handle; // Filled in by fill_in_pointers_to_member_function_definitions.
+
+ Function() : Node(DESCRIPTOR) {}
+ static const constexpr NodeDescriptor DESCRIPTOR = FUNCTION;
+};
+
+struct PointerOrReference : Node {
+ bool is_pointer = true;
+ std::unique_ptr value_type;
+
+ PointerOrReference() : Node(DESCRIPTOR) {}
+ static const constexpr NodeDescriptor DESCRIPTOR = POINTER_OR_REFERENCE;
+};
+
+struct PointerToDataMember : Node {
+ std::unique_ptr class_type;
+ std::unique_ptr member_type;
+
+ PointerToDataMember() : Node(DESCRIPTOR) {}
+ static const constexpr NodeDescriptor DESCRIPTOR = POINTER_TO_DATA_MEMBER;
+};
+
+struct StructOrUnion : Node {
+ bool is_struct = true;
+ std::vector> base_classes;
+ std::vector> fields;
+ std::vector> member_functions;
+
+ StructOrUnion() : Node(DESCRIPTOR) {}
+ static const constexpr NodeDescriptor DESCRIPTOR = STRUCT_OR_UNION;
+
+ struct FlatField {
+ // The field itself.
+ const Node* node;
+ // The symbol that owns the node.
+ const DataType* symbol;
+ // Offset of the innermost enclosing base class in the object.
+ s32 base_offset = 0;
+ };
+
+ // Generate a flat list of all the fields in this class as well as all the
+ // base classes recursively, but only until the max_fields or max_depth
+ // limits are reached. Return true if all the fields were enumerated.
+ bool flatten_fields(
+ std::vector& output,
+ const DataType* symbol,
+ const SymbolDatabase& database,
+ bool skip_statics,
+ s32 base_offset = 0,
+ s32 max_fields = 100000,
+ s32 max_depth = 100) const;
+};
+
+enum class TypeNameSource : u8 {
+ REFERENCE, // A STABS type reference.
+ CROSS_REFERENCE, // A STABS cross reference.
+ UNNAMED_THIS // A this parameter (or return type) referencing an unnamed type.
+};
+
+const char* type_name_source_to_string(TypeNameSource source);
+
+enum class ForwardDeclaredType {
+ STRUCT,
+ UNION,
+ ENUM // Should be illegal but STABS supports cross references to enums so it's here.
+};
+
+const char* forward_declared_type_to_string(ForwardDeclaredType type);
+
+struct TypeName : Node {
+ DataTypeHandle data_type_handle;
+ TypeNameSource source = TypeNameSource::REFERENCE;
+ bool is_forward_declared = false;
+
+ DataTypeHandle data_type_handle_unless_forward_declared() const;
+
+ struct UnresolvedStabs {
+ std::string type_name;
+ SourceFileHandle referenced_file_handle;
+ StabsTypeNumber stabs_type_number;
+ std::optional type;
+ };
+
+ std::unique_ptr unresolved_stabs;
+
+ TypeName() : Node(DESCRIPTOR) {}
+ static const constexpr NodeDescriptor DESCRIPTOR = TYPE_NAME;
+};
+
+enum class CompareResultType {
+ MATCHES_NO_SWAP, // Both lhs and rhs are identical.
+ MATCHES_CONFUSED, // Both lhs and rhs are almost identical, and we don't which is better.
+ MATCHES_FAVOUR_LHS, // Both lhs and rhs are almost identical, but lhs is better.
+ MATCHES_FAVOUR_RHS, // Both lhs and rhs are almost identical, but rhs is better.
+ DIFFERS, // The two nodes differ substantially.
+};
+
+enum class CompareFailReason {
+ NONE,
+ DESCRIPTOR,
+ STORAGE_CLASS,
+ NAME,
+ RELATIVE_OFFSET_BYTES,
+ ABSOLUTE_OFFSET_BYTES,
+ BITFIELD_OFFSET_BITS,
+ SIZE_BITS,
+ CONSTNESS,
+ ARRAY_ELEMENT_COUNT,
+ BUILTIN_CLASS,
+ FUNCTION_RETURN_TYPE_HAS_VALUE,
+ FUNCTION_PARAMAETER_COUNT,
+ FUNCTION_PARAMETERS_HAS_VALUE,
+ FUNCTION_MODIFIER,
+ ENUM_CONSTANTS,
+ BASE_CLASS_COUNT,
+ FIELDS_SIZE,
+ MEMBER_FUNCTION_COUNT,
+ VTABLE_GLOBAL,
+ TYPE_NAME,
+ VARIABLE_CLASS,
+ VARIABLE_TYPE,
+ VARIABLE_STORAGE,
+ VARIABLE_BLOCK
+};
+
+struct CompareResult {
+ CompareResult(CompareResultType type) : type(type), fail_reason(CompareFailReason::NONE) {}
+ CompareResult(CompareFailReason reason) : type(CompareResultType::DIFFERS), fail_reason(reason) {}
+ CompareResultType type;
+ CompareFailReason fail_reason;
+};
+
+// Compare two AST nodes and their children recursively. This will only check
+// fields that will be equal for two versions of the same type from different
+// translation units.
+CompareResult compare_nodes(const Node& lhs, const Node& rhs, const SymbolDatabase* database, bool check_intrusive_fields);
+
+const char* compare_fail_reason_to_string(CompareFailReason reason);
+const char* node_type_to_string(const Node& node);
+const char* storage_class_to_string(StorageClass storage_class);
+const char* access_specifier_to_string(AccessSpecifier specifier);
+const char* builtin_class_to_string(BuiltInClass bclass);
+
+s32 builtin_class_size(BuiltInClass bclass);
+
+enum TraversalOrder {
+ PREORDER_TRAVERSAL,
+ POSTORDER_TRAVERSAL
+};
+
+enum ExplorationMode {
+ EXPLORE_CHILDREN,
+ DONT_EXPLORE_CHILDREN
+};
+
+template
+void for_each_node(ThisNode& node, TraversalOrder order, Callback callback)
+{
+ if(order == PREORDER_TRAVERSAL && callback(node) == DONT_EXPLORE_CHILDREN) {
+ return;
+ }
+ switch(node.descriptor) {
+ case ARRAY: {
+ auto& array = node.template as();
+ for_each_node(*array.element_type.get(), order, callback);
+ break;
+ }
+ case BITFIELD: {
+ auto& bitfield = node.template as();
+ for_each_node(*bitfield.underlying_type.get(), order, callback);
+ break;
+ }
+ case BUILTIN: {
+ break;
+ }
+ case ENUM: {
+ break;
+ }
+ case ERROR_NODE: {
+ break;
+ }
+ case FUNCTION: {
+ auto& func = node.template as();
+ if(func.return_type.has_value()) {
+ for_each_node(*func.return_type->get(), order, callback);
+ }
+ if(func.parameters.has_value()) {
+ for(auto& child : *func.parameters) {
+ for_each_node(*child.get(), order, callback);
+ }
+ }
+ break;
+ }
+ case POINTER_OR_REFERENCE: {
+ auto& pointer_or_reference = node.template as();
+ for_each_node(*pointer_or_reference.value_type.get(), order, callback);
+ break;
+ }
+ case POINTER_TO_DATA_MEMBER: {
+ auto& pointer = node.template as();
+ for_each_node(*pointer.class_type.get(), order, callback);
+ for_each_node(*pointer.member_type.get(), order, callback);
+ break;
+ }
+ case STRUCT_OR_UNION: {
+ auto& struct_or_union = node.template as();
+ for(auto& child : struct_or_union.base_classes) {
+ for_each_node(*child.get(), order, callback);
+ }
+ for(auto& child : struct_or_union.fields) {
+ for_each_node(*child.get(), order, callback);
+ }
+ for(auto& child : struct_or_union.member_functions) {
+ for_each_node(*child.get(), order, callback);
+ }
+ break;
+ }
+ case TYPE_NAME: {
+ break;
+ }
+ }
+ if(order == POSTORDER_TRAVERSAL) {
+ callback(node);
+ }
+}
+
+}
diff --git a/3rdparty/ccc/src/ccc/elf.cpp b/3rdparty/ccc/src/ccc/elf.cpp
new file mode 100644
index 0000000000..8c3ed99e57
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/elf.cpp
@@ -0,0 +1,125 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#include "elf.h"
+
+namespace ccc {
+
+Result ElfFile::parse(std::vector image)
+{
+ ElfFile elf;
+ elf.image = std::move(image);
+
+ const ElfIdentHeader* ident = get_packed(elf.image, 0);
+ CCC_CHECK(ident, "ELF ident header out of range.");
+ CCC_CHECK(ident->magic == CCC_FOURCC("\x7f\x45\x4c\x46"), "Not an ELF file.");
+ CCC_CHECK(ident->e_class == ElfIdentClass::B32, "Wrong ELF class (not 32 bit).");
+
+ const ElfFileHeader* header = get_packed(elf.image, sizeof(ElfIdentHeader));
+ CCC_CHECK(header, "ELF file header out of range.");
+ elf.file_header = *header;
+
+ const ElfSectionHeader* shstr_section_header = get_packed(elf.image, header->shoff + header->shstrndx * sizeof(ElfSectionHeader));
+ CCC_CHECK(shstr_section_header, "ELF section name header out of range.");
+
+ for(u32 i = 0; i < header->shnum; i++) {
+ u64 header_offset = header->shoff + i * sizeof(ElfSectionHeader);
+ const ElfSectionHeader* section_header = get_packed(elf.image, header_offset);
+ CCC_CHECK(section_header, "ELF section header out of range.");
+
+ const char* name = get_string(elf.image, shstr_section_header->offset + section_header->name);
+ CCC_CHECK(section_header, "ELF section name out of range.");
+
+ ElfSection& section = elf.sections.emplace_back();
+ section.name = name;
+ section.header = *section_header;
+ }
+
+ for(u32 i = 0; i < header->phnum; i++) {
+ u64 header_offset = header->phoff + i * sizeof(ElfProgramHeader);
+ const ElfProgramHeader* program_header = get_packed(elf.image, header_offset);
+ CCC_CHECK(program_header, "ELF program header out of range.");
+
+ elf.segments.emplace_back(*program_header);
+ }
+
+ return elf;
+}
+
+Result ElfFile::create_section_symbols(
+ SymbolDatabase& database, const SymbolGroup& group) const
+{
+ for(const ElfSection& section : sections) {
+ Address address = Address::non_zero(section.header.addr);
+
+ Result symbol = database.sections.create_symbol(
+ section.name, address, group.source, group.module_symbol);
+ CCC_RETURN_IF_ERROR(symbol);
+
+ (*symbol)->set_size(section.header.size);
+ }
+
+ return Result();
+}
+
+const ElfSection* ElfFile::lookup_section(const char* name) const
+{
+ for(const ElfSection& section : sections) {
+ if(section.name == name) {
+ return §ion;
+ }
+ }
+ return nullptr;
+}
+
+std::optional ElfFile::file_offset_to_virtual_address(u32 file_offset) const
+{
+ for(const ElfProgramHeader& segment : segments) {
+ if(file_offset >= segment.offset && file_offset < segment.offset + segment.filesz) {
+ return segment.vaddr + file_offset - segment.offset;
+ }
+ }
+ return std::nullopt;
+}
+
+const ElfProgramHeader* ElfFile::entry_point_segment() const
+{
+ const ccc::ElfProgramHeader* entry_segment = nullptr;
+ for(const ccc::ElfProgramHeader& segment : segments) {
+ if(file_header.entry >= segment.vaddr && file_header.entry < segment.vaddr + segment.filesz) {
+ entry_segment = &segment;
+ }
+ }
+ return entry_segment;
+}
+
+Result> ElfFile::get_virtual(u32 address, u32 size) const
+{
+ u32 end_address = address + size;
+
+ if(end_address >= address) {
+ for(const ElfProgramHeader& segment : segments) {
+ if(address >= segment.vaddr && end_address <= segment.vaddr + segment.filesz) {
+ size_t begin_offset = segment.offset + (address - segment.vaddr);
+ size_t end_offset = begin_offset + size;
+ if(begin_offset <= image.size() && end_offset <= image.size()) {
+ return std::span(image.data() + begin_offset, image.data() + end_offset);
+ }
+ }
+ }
+ }
+
+ return CCC_FAILURE("No ELF segment for address range 0x%x to 0x%x.", address, end_address);
+}
+
+Result ElfFile::copy_virtual(u8* dest, u32 address, u32 size) const
+{
+ Result> block = get_virtual(address, size);
+ CCC_RETURN_IF_ERROR(block);
+
+ memcpy(dest, block->data(), size);
+
+ return Result();
+}
+
+}
diff --git a/3rdparty/ccc/src/ccc/elf.h b/3rdparty/ccc/src/ccc/elf.h
new file mode 100644
index 0000000000..33d89e759c
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/elf.h
@@ -0,0 +1,156 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "symbol_database.h"
+
+namespace ccc {
+
+enum class ElfIdentClass : u8 {
+ B32 = 0x1,
+ B64 = 0x2
+};
+
+CCC_PACKED_STRUCT(ElfIdentHeader,
+ /* 0x0 */ u32 magic; // 7f 45 4c 46
+ /* 0x4 */ ElfIdentClass e_class;
+ /* 0x5 */ u8 endianess;
+ /* 0x6 */ u8 version;
+ /* 0x7 */ u8 os_abi;
+ /* 0x8 */ u8 abi_version;
+ /* 0x9 */ u8 pad[7];
+)
+
+enum class ElfFileType : u16 {
+ NONE = 0x00,
+ REL = 0x01,
+ EXEC = 0x02,
+ DYN = 0x03,
+ CORE = 0x04,
+ LOOS = 0xfe00,
+ HIOS = 0xfeff,
+ LOPROC = 0xff00,
+ HIPROC = 0xffff
+};
+
+enum class ElfMachine : u16 {
+ MIPS = 0x08
+};
+
+CCC_PACKED_STRUCT(ElfFileHeader,
+ /* 0x10 */ ElfFileType type;
+ /* 0x12 */ ElfMachine machine;
+ /* 0x14 */ u32 version;
+ /* 0x18 */ u32 entry;
+ /* 0x1c */ u32 phoff;
+ /* 0x20 */ u32 shoff;
+ /* 0x24 */ u32 flags;
+ /* 0x28 */ u16 ehsize;
+ /* 0x2a */ u16 phentsize;
+ /* 0x2c */ u16 phnum;
+ /* 0x2e */ u16 shentsize;
+ /* 0x30 */ u16 shnum;
+ /* 0x32 */ u16 shstrndx;
+)
+
+enum class ElfSectionType : u32 {
+ NULL_SECTION = 0x0,
+ PROGBITS = 0x1,
+ SYMTAB = 0x2,
+ STRTAB = 0x3,
+ RELA = 0x4,
+ HASH = 0x5,
+ DYNAMIC = 0x6,
+ NOTE = 0x7,
+ NOBITS = 0x8,
+ REL = 0x9,
+ SHLIB = 0xa,
+ DYNSYM = 0xb,
+ INIT_ARRAY = 0xe,
+ FINI_ARRAY = 0xf,
+ PREINIT_ARRAY = 0x10,
+ GROUP = 0x11,
+ SYMTAB_SHNDX = 0x12,
+ NUM = 0x13,
+ LOOS = 0x60000000,
+ MIPS_DEBUG = 0x70000005
+};
+
+CCC_PACKED_STRUCT(ElfSectionHeader,
+ /* 0x00 */ u32 name;
+ /* 0x04 */ ElfSectionType type;
+ /* 0x08 */ u32 flags;
+ /* 0x0c */ u32 addr;
+ /* 0x10 */ u32 offset;
+ /* 0x14 */ u32 size;
+ /* 0x18 */ u32 link;
+ /* 0x1c */ u32 info;
+ /* 0x20 */ u32 addralign;
+ /* 0x24 */ u32 entsize;
+)
+
+struct ElfSection {
+ std::string name;
+ ElfSectionHeader header;
+};
+
+CCC_PACKED_STRUCT(ElfProgramHeader,
+ /* 0x00 */ u32 type;
+ /* 0x04 */ u32 offset;
+ /* 0x08 */ u32 vaddr;
+ /* 0x0c */ u32 paddr;
+ /* 0x10 */ u32 filesz;
+ /* 0x14 */ u32 memsz;
+ /* 0x18 */ u32 flags;
+ /* 0x1c */ u32 align;
+)
+
+struct ElfFile {
+ ElfFileHeader file_header;
+ std::vector image;
+ std::vector sections;
+ std::vector segments;
+
+ // Parse the ELF file header, section headers and program headers.
+ static Result parse(std::vector image);
+
+ // Create a section object for each section header in the ELF file.
+ Result create_section_symbols(SymbolDatabase& database, const SymbolGroup& group) const;
+
+ const ElfSection* lookup_section(const char* name) const;
+ std::optional file_offset_to_virtual_address(u32 file_offset) const;
+
+ // Find the program header for the segment that contains the entry point.
+ const ElfProgramHeader* entry_point_segment() const;
+
+ // Retrieve a block of data in an ELF file given its address and size.
+ Result> get_virtual(u32 address, u32 size) const;
+
+ // Copy a block of data in an ELF file to the destination buffer given its
+ // address and size.
+ Result copy_virtual(u8* dest, u32 address, u32 size) const;
+
+ // Retrieve an object of type T from an ELF file given its address.
+ template
+ Result get_object_virtual(u32 address) const
+ {
+ Result> result = get_virtual(address, sizeof(T));
+ CCC_RETURN_IF_ERROR(result);
+
+ return *(T*) result->data();
+ }
+
+ // Retrieve an array of objects of type T from an ELF file given its
+ // address and element count.
+ template
+ Result> get_array_virtual(u32 address, u32 element_count) const
+ {
+ Result> result = get_virtual(address, element_count * sizeof(T));
+ CCC_RETURN_IF_ERROR(result);
+
+ return std::span((T*) result->data(), (T*) (result->data() + result->size()));
+ }
+};
+
+}
diff --git a/3rdparty/ccc/src/ccc/elf_symtab.cpp b/3rdparty/ccc/src/ccc/elf_symtab.cpp
new file mode 100644
index 0000000000..892ea5ec2d
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/elf_symtab.cpp
@@ -0,0 +1,213 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#include "elf_symtab.h"
+
+#include "importer_flags.h"
+
+namespace ccc::elf {
+
+enum class SymbolBind : u8 {
+ LOCAL = 0,
+ GLOBAL = 1,
+ WEAK = 2,
+ NUM = 3,
+ GNU_UNIQUE = 10
+};
+
+enum class SymbolType : u8 {
+ NOTYPE = 0,
+ OBJECT = 1,
+ FUNC = 2,
+ SECTION = 3,
+ FILE = 4,
+ COMMON = 5,
+ TLS = 6,
+ NUM = 7,
+ GNU_IFUNC = 10
+};
+
+enum class SymbolVisibility {
+ DEFAULT = 0,
+ INTERNAL = 1,
+ HIDDEN = 2,
+ PROTECTED = 3
+};
+
+CCC_PACKED_STRUCT(Symbol,
+ /* 0x0 */ u32 name;
+ /* 0x4 */ u32 value;
+ /* 0x8 */ u32 size;
+ /* 0xc */ u8 info;
+ /* 0xd */ u8 other;
+ /* 0xe */ u16 shndx;
+
+ SymbolType type() const { return (SymbolType) (info & 0xf); }
+ SymbolBind bind() const { return (SymbolBind) (info >> 4); }
+ SymbolVisibility visibility() const { return (SymbolVisibility) (other & 0x3); }
+)
+
+static const char* symbol_bind_to_string(SymbolBind bind);
+static const char* symbol_type_to_string(SymbolType type);
+static const char* symbol_visibility_to_string(SymbolVisibility visibility);
+
+Result import_symbols(
+ SymbolDatabase& database,
+ const SymbolGroup& group,
+ std::span symtab,
+ std::span strtab,
+ u32 importer_flags,
+ DemanglerFunctions demangler)
+{
+ for(u32 i = 0; i < symtab.size() / sizeof(Symbol); i++) {
+ const Symbol* symbol = get_packed(symtab, i * sizeof(Symbol));
+ CCC_ASSERT(symbol);
+
+ Address address;
+ if(symbol->value != 0) {
+ address = symbol->value;
+ }
+
+ if(!address.valid() || symbol->visibility() != SymbolVisibility::DEFAULT) {
+ continue;
+ }
+
+ if(!(importer_flags & DONT_DEDUPLICATE_SYMBOLS)) {
+ if(database.functions.first_handle_from_starting_address(address).valid()) {
+ continue;
+ }
+
+ if(database.global_variables.first_handle_from_starting_address(address).valid()) {
+ continue;
+ }
+
+ if(database.local_variables.first_handle_from_starting_address(address).valid()) {
+ continue;
+ }
+ }
+
+ const char* string = get_string(strtab, symbol->name);
+ CCC_CHECK(string, "Symbol string out of range.");
+
+ switch(symbol->type()) {
+ case SymbolType::NOTYPE: {
+ Result label = database.labels.create_symbol(
+ string, group.source, group.module_symbol, address, importer_flags, demangler);
+ CCC_RETURN_IF_ERROR(label);
+
+ // These symbols get emitted at the same addresses as functions
+ // and aren't extremely useful, so we want to mark them to
+ // prevent them from possibly being used as function names.
+ (*label)->is_junk =
+ (*label)->name() == "__gnu_compiled_c" ||
+ (*label)->name() == "__gnu_compiled_cplusplus" ||
+ (*label)->name() == "gcc2_compiled.";
+
+ break;
+ }
+ case SymbolType::OBJECT: {
+ if(symbol->size != 0) {
+ Result global_variable = database.global_variables.create_symbol(
+ string, group.source, group.module_symbol, address, importer_flags, demangler);
+ CCC_RETURN_IF_ERROR(global_variable);
+
+ if(*global_variable) {
+ (*global_variable)->set_size(symbol->size);
+ }
+ } else {
+ Result label = database.labels.create_symbol(
+ string, group.source, group.module_symbol, address, importer_flags, demangler);
+ CCC_RETURN_IF_ERROR(label);
+ }
+
+ break;
+ }
+ case SymbolType::FUNC: {
+ Result function = database.functions.create_symbol(
+ string, group.source, group.module_symbol, address, importer_flags, demangler);
+ CCC_RETURN_IF_ERROR(function);
+
+ if(*function) {
+ (*function)->set_size(symbol->size);
+ }
+
+ break;
+ }
+ case SymbolType::FILE: {
+ Result source_file = database.source_files.create_symbol(
+ string, group.source, group.module_symbol);
+ CCC_RETURN_IF_ERROR(source_file);
+
+ break;
+ }
+ default: {}
+ }
+ }
+
+ return Result();
+}
+
+Result print_symbol_table(FILE* out, std::span symtab, std::span strtab)
+{
+ fprintf(out, "ELF SYMBOLS:\n");
+ fprintf(out, " Num: Value Size Type Bind Vis Ndx Name\n");
+
+ for(u32 i = 0; i < symtab.size() / sizeof(Symbol); i++) {
+ const Symbol* symbol = get_packed(symtab, i * sizeof(Symbol));
+ CCC_ASSERT(symbol);
+
+ const char* type = symbol_type_to_string(symbol->type());
+ const char* bind = symbol_bind_to_string(symbol->bind());
+ const char* visibility = symbol_visibility_to_string(symbol->visibility());
+
+ const char* string = get_string(strtab, symbol->name);
+ CCC_CHECK(string, "Symbol string out of range.");
+
+ fprintf(out, "%6u: %08x %5u %-7s %-7s %-7s %3u %s\n",
+ i, symbol->value, symbol->size, type, bind, visibility, symbol->shndx, string);
+
+ }
+
+ return Result();
+}
+
+static const char* symbol_bind_to_string(SymbolBind bind)
+{
+ switch(bind) {
+ case SymbolBind::LOCAL: return "LOCAL";
+ case SymbolBind::GLOBAL: return "GLOBAL";
+ case SymbolBind::WEAK: return "WEAK";
+ case SymbolBind::NUM: return "NUM";
+ case SymbolBind::GNU_UNIQUE: return "GNU_UNIQUE";
+ }
+ return "ERROR";
+}
+
+static const char* symbol_type_to_string(SymbolType type)
+{
+ switch(type) {
+ case SymbolType::NOTYPE: return "NOTYPE";
+ case SymbolType::OBJECT: return "OBJECT";
+ case SymbolType::FUNC: return "FUNC";
+ case SymbolType::SECTION: return "SECTION";
+ case SymbolType::FILE: return "FILE";
+ case SymbolType::COMMON: return "COMMON";
+ case SymbolType::TLS: return "TLS";
+ case SymbolType::NUM: return "NUM";
+ case SymbolType::GNU_IFUNC: return "GNU_IFUNC";
+ }
+ return "ERROR";
+}
+
+static const char* symbol_visibility_to_string(SymbolVisibility visibility)
+{
+ switch(visibility) {
+ case SymbolVisibility::DEFAULT: return "DEFAULT";
+ case SymbolVisibility::INTERNAL: return "INTERNAL";
+ case SymbolVisibility::HIDDEN: return "HIDDEN";
+ case SymbolVisibility::PROTECTED: return "PROTECTED";
+ }
+ return "ERROR";
+}
+
+}
diff --git a/3rdparty/ccc/src/ccc/elf_symtab.h b/3rdparty/ccc/src/ccc/elf_symtab.h
new file mode 100644
index 0000000000..3880de969f
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/elf_symtab.h
@@ -0,0 +1,20 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "symbol_database.h"
+
+namespace ccc::elf {
+
+Result import_symbols(
+ SymbolDatabase& database,
+ const SymbolGroup& group,
+ std::span symtab,
+ std::span strtab,
+ u32 importer_flags,
+ DemanglerFunctions demangler);
+
+Result print_symbol_table(FILE* out, std::span symtab, std::span strtab);
+
+}
diff --git a/3rdparty/ccc/src/ccc/importer_flags.cpp b/3rdparty/ccc/src/ccc/importer_flags.cpp
new file mode 100644
index 0000000000..a05d6714ac
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/importer_flags.cpp
@@ -0,0 +1,95 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#include "importer_flags.h"
+
+namespace ccc {
+
+const std::vector IMPORTER_FLAGS = {
+ {DEMANGLE_PARAMETERS, "--demangle-parameters", {
+ "Include parameters in demangled function names."
+ }},
+ {DEMANGLE_RETURN_TYPE, "--demangle-return-type", {
+ "Include return types at the end of demangled",
+ "function names if they're available."
+ }},
+ {DONT_DEDUPLICATE_SYMBOLS, "--dont-deduplicate-symbols", {
+ "Do not deduplicate matching symbols from",
+ "different symbol tables. This options has no",
+ "effect on data types."
+ }},
+ {DONT_DEDUPLICATE_TYPES, "--dont-deduplicate-types", {
+ "Do not deduplicate data types from different",
+ "translation units."
+ }},
+ {DONT_DEMANGLE_NAMES, "--dont-demangle-names", {
+ "Do not demangle function names, global variable",
+ "names, or overloaded operator names."
+ }},
+ {INCLUDE_GENERATED_MEMBER_FUNCTIONS, "--include-generated-functions", {
+ "Output member functions that were likely",
+ "automatically generated by the compiler."
+ }},
+ {NO_ACCESS_SPECIFIERS, "--no-access-specifiers", {
+ "Do not print access specifiers."
+ }},
+ {NO_MEMBER_FUNCTIONS, "--no-member-functions", {
+ "Do not print member functions."
+ }},
+ {NO_OPTIMIZED_OUT_FUNCTIONS, "--no-optimized-out-functions", {
+ "Discard functions that were optimized out."
+ }},
+ {STRICT_PARSING, "--strict", {
+ "Make more types of errors fatal."
+ }},
+ {TYPEDEF_ALL_ENUMS, "--typedef-all-enums", {
+ "Force all emitted C++ enums to be defined using",
+ "a typedef. With STABS, it is not always possible",
+ "to determine if an enum was like this in the",
+ "original source code, so this option should be",
+ "useful for reverse engineering C projects."
+ }},
+ {TYPEDEF_ALL_STRUCTS, "--typedef-all-structs", {
+ "Force all emitted C++ structure types to be",
+ "defined using a typedef."
+ }},
+ {TYPEDEF_ALL_UNIONS, "--typedef-all-unions", {
+ "Force all emitted C++ union types to be defined",
+ "using a typedef."
+ }},
+ {UNIQUE_FUNCTIONS, "--unique-functions", {
+ " If multiple identical .mdebug function symbols",
+ "are present, find the one that seems to have",
+ "actually been included in the linked binary, and",
+ "remove the addresses from all the rest. Using",
+ "this importer flag in combination with",
+ "--no-optimized-out-functions will remove these",
+ "duplicate function symbols entirely."
+ }}
+};
+
+u32 parse_importer_flag(const char* argument)
+{
+ for(const ImporterFlagInfo& flag : IMPORTER_FLAGS) {
+ if(strcmp(flag.argument, argument) == 0) {
+ return flag.flag;
+ }
+ }
+ return NO_IMPORTER_FLAGS;
+}
+
+void print_importer_flags_help(FILE* out)
+{
+ for(const ImporterFlagInfo& flag : IMPORTER_FLAGS) {
+ fprintf(out, "\n");
+ fprintf(out, " %-29s ", flag.argument);
+ for(size_t i = 0; i < flag.help_text.size(); i++) {
+ if(i > 0) {
+ fprintf(out, " ");
+ }
+ fprintf(out, "%s\n", flag.help_text[i]);
+ }
+ }
+}
+
+}
diff --git a/3rdparty/ccc/src/ccc/importer_flags.h b/3rdparty/ccc/src/ccc/importer_flags.h
new file mode 100644
index 0000000000..12ab79538a
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/importer_flags.h
@@ -0,0 +1,39 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "util.h"
+
+namespace ccc {
+
+enum ImporterFlags {
+ NO_IMPORTER_FLAGS = 0,
+ DEMANGLE_PARAMETERS = (1 << 0),
+ DEMANGLE_RETURN_TYPE = (1 << 1),
+ DONT_DEDUPLICATE_SYMBOLS = (1 << 2),
+ DONT_DEDUPLICATE_TYPES = (1 << 3),
+ DONT_DEMANGLE_NAMES = (1 << 4),
+ INCLUDE_GENERATED_MEMBER_FUNCTIONS = (1 << 5),
+ NO_ACCESS_SPECIFIERS = (1 << 6),
+ NO_MEMBER_FUNCTIONS = (1 << 7),
+ NO_OPTIMIZED_OUT_FUNCTIONS = (1 << 8),
+ STRICT_PARSING = (1 << 9),
+ TYPEDEF_ALL_ENUMS = (1 << 10),
+ TYPEDEF_ALL_STRUCTS = (1 << 11),
+ TYPEDEF_ALL_UNIONS = (1 << 12),
+ UNIQUE_FUNCTIONS = (1 << 13)
+};
+
+struct ImporterFlagInfo {
+ ImporterFlags flag;
+ const char* argument;
+ std::vector help_text;
+};
+
+extern const std::vector IMPORTER_FLAGS;
+
+u32 parse_importer_flag(const char* argument);
+void print_importer_flags_help(FILE* out);
+
+}
diff --git a/3rdparty/ccc/src/ccc/mdebug_analysis.cpp b/3rdparty/ccc/src/ccc/mdebug_analysis.cpp
new file mode 100644
index 0000000000..0309c858d4
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/mdebug_analysis.cpp
@@ -0,0 +1,349 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#include "mdebug_analysis.h"
+
+#include "stabs_to_ast.h"
+
+namespace ccc::mdebug {
+
+Result LocalSymbolTableAnalyser::stab_magic(const char* magic)
+{
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::source_file(const char* path, Address text_address)
+{
+ if(m_next_relative_path.empty()) {
+ m_next_relative_path = m_source_file.command_line_path;
+ }
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::data_type(const ParsedSymbol& symbol)
+{
+ Result> node = stabs_type_to_ast(
+ *symbol.name_colon_type.type.get(), nullptr, m_stabs_to_ast_state, 0, false, false);
+ CCC_RETURN_IF_ERROR(node);
+
+ if(symbol.is_typedef && (*node)->descriptor == ast::STRUCT_OR_UNION) {
+ ast::StructOrUnion& struct_or_union = (*node)->as();
+ const std::string& name = symbol.name_colon_type.name;
+ StabsTypeNumber type_number = symbol.name_colon_type.type->type_number;
+ fix_recursively_emitted_structures(struct_or_union, name, type_number, m_stabs_to_ast_state.file_handle);
+ }
+
+ bool is_struct = (*node)->descriptor == ast::STRUCT_OR_UNION && (*node)->as().is_struct;
+ bool force_typedef =
+ ((m_context.importer_flags & TYPEDEF_ALL_ENUMS) && (*node)->descriptor == ast::ENUM) ||
+ ((m_context.importer_flags & TYPEDEF_ALL_STRUCTS) && (*node)->descriptor == ast::STRUCT_OR_UNION && is_struct) ||
+ ((m_context.importer_flags & TYPEDEF_ALL_UNIONS) && (*node)->descriptor == ast::STRUCT_OR_UNION && !is_struct);
+
+ (*node)->name = (symbol.name_colon_type.name == " ") ? "" : symbol.name_colon_type.name;
+ if(symbol.is_typedef || force_typedef) {
+ (*node)->storage_class = STORAGE_CLASS_TYPEDEF;
+ }
+
+ const char* name = (*node)->name.c_str();
+ StabsTypeNumber number = symbol.name_colon_type.type->type_number;
+
+ if(m_context.importer_flags & DONT_DEDUPLICATE_TYPES) {
+ Result data_type = m_database.data_types.create_symbol(
+ name, m_context.group.source, m_context.group.module_symbol);
+ CCC_RETURN_IF_ERROR(data_type);
+
+ m_source_file.stabs_type_number_to_handle[number] = (*data_type)->handle();
+ (*data_type)->set_type(std::move(*node));
+
+ (*data_type)->files = {m_source_file.handle()};
+ } else {
+ Result type = m_database.create_data_type_if_unique(
+ std::move(*node), number, name, m_source_file, m_context.group);
+ CCC_RETURN_IF_ERROR(type);
+ }
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::global_variable(
+ const char* mangled_name, Address address, const StabsType& type, bool is_static, GlobalStorageLocation location)
+{
+ Result global = m_database.global_variables.create_symbol(
+ mangled_name, m_context.group.source, m_context.group.module_symbol, address, m_context.importer_flags, m_context.demangler);
+ CCC_RETURN_IF_ERROR(global);
+ CCC_ASSERT(*global);
+
+ m_global_variables.emplace_back((*global)->handle());
+
+ Result> node = stabs_type_to_ast(type, nullptr, m_stabs_to_ast_state, 0, true, false);
+ CCC_RETURN_IF_ERROR(node);
+
+ if(is_static) {
+ (*global)->storage_class = STORAGE_CLASS_STATIC;
+ }
+ (*global)->set_type(std::move(*node));
+
+ (*global)->storage.location = location;
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::sub_source_file(const char* path, Address text_address)
+{
+ if(m_current_function && m_state == IN_FUNCTION_BEGINNING) {
+ Function::SubSourceFile& sub = m_current_function->sub_source_files.emplace_back();
+ sub.address = text_address;
+ sub.relative_path = path;
+ } else {
+ m_next_relative_path = path;
+ }
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::procedure(
+ const char* mangled_name, Address address, const ProcedureDescriptor* procedure_descriptor, bool is_static)
+{
+ if(!m_current_function || strcmp(mangled_name, m_current_function->mangled_name().c_str()) != 0) {
+ Result result = create_function(mangled_name, address);
+ CCC_RETURN_IF_ERROR(result);
+ }
+
+ if(is_static) {
+ m_current_function->storage_class = STORAGE_CLASS_STATIC;
+ }
+
+ if(procedure_descriptor) {
+ m_current_function->stack_frame_size = procedure_descriptor->frame_size;
+ }
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::label(const char* label, Address address, s32 line_number)
+{
+ if(address.valid() && m_current_function && label[0] == '$') {
+ Function::LineNumberPair& pair = m_current_function->line_numbers.emplace_back();
+ pair.address = address;
+ pair.line_number = line_number;
+ }
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::text_end(const char* name, s32 function_size)
+{
+ if(m_state == IN_FUNCTION_BEGINNING) {
+ CCC_CHECK(m_current_function, "END TEXT symbol outside of function.");
+ m_current_function->set_size(function_size);
+ m_state = IN_FUNCTION_END;
+ }
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::function(const char* mangled_name, const StabsType& return_type, Address address)
+{
+ if(!m_current_function || strcmp(mangled_name, m_current_function->mangled_name().c_str()) != 0) {
+ Result result = create_function(mangled_name, address);
+ CCC_RETURN_IF_ERROR(result);
+ } else {
+ // For MTV Music Maker 2, the addresses for static functions stored in
+ // the PROC symbols are relative to the translation unit, while the
+ // addresses stored in the FUN symbol are absolute. This is the only
+ // game I've found that seems to have this problem, but since in all
+ // other cases it seems all these addresses are all absolute, I may as
+ // well add in a hack here to deal with it.
+ bool no_module_base_address = m_context.group.module_symbol && m_context.group.module_symbol->address().get_or_zero() == 0;
+ bool new_address_greater = address.valid() && address > m_current_function->address();
+ if(no_module_base_address && new_address_greater) {
+ m_database.functions.move_symbol(m_current_function->handle(), address);
+ }
+ }
+
+ Result> node = stabs_type_to_ast(return_type, nullptr, m_stabs_to_ast_state, 0, true, true);
+ CCC_RETURN_IF_ERROR(node);
+ m_current_function->set_type(std::move(*node));
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::function_end()
+{
+ if(m_current_function) {
+ m_current_function->set_parameter_variables(std::move(m_current_parameter_variables), m_database);
+ m_current_function->set_local_variables(std::move(m_current_local_variables), m_database);
+ }
+
+ m_current_function = nullptr;
+ m_current_parameter_variables = std::vector();
+ m_current_local_variables = std::vector();
+
+ m_blocks.clear();
+ m_pending_local_variables.clear();
+
+ m_state = NOT_IN_FUNCTION;
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::parameter(
+ const char* name, const StabsType& type, bool is_stack, s32 value, bool is_by_reference)
+{
+ CCC_CHECK(m_current_function, "Parameter symbol before first func/proc symbol.");
+
+ Result parameter_variable = m_database.parameter_variables.create_symbol(
+ name, m_context.group.source, m_context.group.module_symbol);
+ CCC_RETURN_IF_ERROR(parameter_variable);
+
+ m_current_parameter_variables.emplace_back((*parameter_variable)->handle());
+
+ Result> node = stabs_type_to_ast(type, nullptr, m_stabs_to_ast_state, 0, true, true);
+ CCC_RETURN_IF_ERROR(node);
+ (*parameter_variable)->set_type(std::move(*node));
+
+ if(is_stack) {
+ StackStorage& stack_storage = (*parameter_variable)->storage.emplace();
+ stack_storage.stack_pointer_offset = value;
+ } else {
+ RegisterStorage& register_storage = (*parameter_variable)->storage.emplace();
+ register_storage.dbx_register_number = value;
+ register_storage.is_by_reference = is_by_reference;
+ }
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::local_variable(
+ const char* name, const StabsType& type, u32 value, StabsSymbolDescriptor desc, SymbolClass sclass)
+{
+ if(!m_current_function) {
+ return Result();
+ }
+
+ Address address = (desc == StabsSymbolDescriptor::STATIC_LOCAL_VARIABLE) ? value : Address();
+ Result local_variable = m_database.local_variables.create_symbol(
+ name, address, m_context.group.source, m_context.group.module_symbol);
+ CCC_RETURN_IF_ERROR(local_variable);
+
+ m_current_local_variables.emplace_back((*local_variable)->handle());
+ m_pending_local_variables.emplace_back((*local_variable)->handle());
+
+ Result> node = stabs_type_to_ast(type, nullptr, m_stabs_to_ast_state, 0, true, false);
+ CCC_RETURN_IF_ERROR(node);
+
+ if(desc == StabsSymbolDescriptor::STATIC_LOCAL_VARIABLE) {
+ GlobalStorage& global_storage = (*local_variable)->storage.emplace();
+ std::optional location_opt =
+ symbol_class_to_global_variable_location(sclass);
+ CCC_CHECK(location_opt.has_value(),
+ "Invalid static local variable location %s.",
+ symbol_class(sclass));
+ global_storage.location = *location_opt;
+ (*node)->storage_class = STORAGE_CLASS_STATIC;
+ } else if(desc == StabsSymbolDescriptor::REGISTER_VARIABLE) {
+ RegisterStorage& register_storage = (*local_variable)->storage.emplace();
+ register_storage.dbx_register_number = (s32) value;
+ } else if(desc == StabsSymbolDescriptor::LOCAL_VARIABLE) {
+ StackStorage& stack_storage = (*local_variable)->storage.emplace();
+ stack_storage.stack_pointer_offset = (s32) value;
+ } else {
+ return CCC_FAILURE("LocalSymbolTableAnalyser::local_variable() called with bad symbol descriptor.");
+ }
+
+ (*local_variable)->set_type(std::move(*node));
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::lbrac(s32 begin_offset)
+{
+ for(LocalVariableHandle local_variable_handle : m_pending_local_variables) {
+ if(LocalVariable* local_variable = m_database.local_variables.symbol_from_handle(local_variable_handle)) {
+ local_variable->live_range.low = m_source_file.address().value + begin_offset;
+ }
+ }
+
+ m_blocks.emplace_back(std::move(m_pending_local_variables));
+ m_pending_local_variables = {};
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::rbrac(s32 end_offset)
+{
+ CCC_CHECK(!m_blocks.empty(), "RBRAC symbol without a matching LBRAC symbol.");
+
+ std::vector& variables = m_blocks.back();
+ for(LocalVariableHandle local_variable_handle : variables) {
+ if(LocalVariable* local_variable = m_database.local_variables.symbol_from_handle(local_variable_handle)) {
+ local_variable->live_range.high = m_source_file.address().value + end_offset;
+ }
+ }
+
+ m_blocks.pop_back();
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::finish()
+{
+ CCC_CHECK(m_state != IN_FUNCTION_BEGINNING,
+ "Unexpected end of symbol table for '%s'.", m_source_file.name().c_str());
+
+ if(m_current_function) {
+ Result result = function_end();
+ CCC_RETURN_IF_ERROR(result);
+ }
+
+ m_source_file.set_functions(std::move(m_functions), m_database);
+ m_source_file.set_global_variables(std::move(m_global_variables), m_database);
+
+ return Result();
+}
+
+Result LocalSymbolTableAnalyser::create_function(const char* mangled_name, Address address)
+{
+ if(m_current_function) {
+ Result result = function_end();
+ CCC_RETURN_IF_ERROR(result);
+ }
+
+ Result function = m_database.functions.create_symbol(
+ mangled_name, m_context.group.source, m_context.group.module_symbol, address, m_context.importer_flags, m_context.demangler);
+ CCC_RETURN_IF_ERROR(function);
+ CCC_ASSERT(*function);
+ m_current_function = *function;
+
+ m_functions.emplace_back(m_current_function->handle());
+
+ m_state = IN_FUNCTION_BEGINNING;
+
+ if(!m_next_relative_path.empty() && m_current_function->relative_path != m_source_file.command_line_path) {
+ m_current_function->relative_path = m_next_relative_path;
+ }
+
+ return Result();
+}
+
+std::optional symbol_class_to_global_variable_location(SymbolClass symbol_class)
+{
+ std::optional location;
+ switch(symbol_class) {
+ case SymbolClass::NIL: location = GlobalStorageLocation::NIL; break;
+ case SymbolClass::DATA: location = GlobalStorageLocation::DATA; break;
+ case SymbolClass::BSS: location = GlobalStorageLocation::BSS; break;
+ case SymbolClass::ABS: location = GlobalStorageLocation::ABS; break;
+ case SymbolClass::SDATA: location = GlobalStorageLocation::SDATA; break;
+ case SymbolClass::SBSS: location = GlobalStorageLocation::SBSS; break;
+ case SymbolClass::RDATA: location = GlobalStorageLocation::RDATA; break;
+ case SymbolClass::COMMON: location = GlobalStorageLocation::COMMON; break;
+ case SymbolClass::SCOMMON: location = GlobalStorageLocation::SCOMMON; break;
+ case SymbolClass::SUNDEFINED: location = GlobalStorageLocation::SUNDEFINED; break;
+ default: {}
+ }
+ return location;
+}
+
+}
diff --git a/3rdparty/ccc/src/ccc/mdebug_analysis.h b/3rdparty/ccc/src/ccc/mdebug_analysis.h
new file mode 100644
index 0000000000..61cc9b0184
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/mdebug_analysis.h
@@ -0,0 +1,99 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "importer_flags.h"
+#include "mdebug_section.h"
+#include "mdebug_symbols.h"
+#include "stabs.h"
+#include "stabs_to_ast.h"
+#include "symbol_database.h"
+
+namespace ccc::mdebug {
+
+struct AnalysisContext {
+ const mdebug::SymbolTableReader* reader = nullptr;
+ const std::map* external_functions = nullptr;
+ const std::map* external_globals = nullptr;
+ SymbolGroup group;
+ u32 importer_flags = NO_IMPORTER_FLAGS;
+ DemanglerFunctions demangler;
+};
+
+class LocalSymbolTableAnalyser {
+public:
+ LocalSymbolTableAnalyser(SymbolDatabase& database, const StabsToAstState& stabs_to_ast_state, const AnalysisContext& context, SourceFile& source_file)
+ : m_database(database)
+ , m_context(context)
+ , m_stabs_to_ast_state(stabs_to_ast_state)
+ , m_source_file(source_file) {}
+
+ // Functions for processing individual symbols.
+ //
+ // In most cases these symbols will appear in the following order:
+ // PROC TEXT
+ // ... line numbers ... ($LM)
+ // END TEXT
+ // LABEL TEXT FUN
+ // ... parameters ...
+ // ... blocks ... (... local variables ... LBRAC ... subblocks ... RBRAC)
+ // NIL NIL FUN
+ //
+ // For some compiler versions the symbols can appear in this order:
+ // LABEL TEXT FUN
+ // ... parameters ...
+ // first line number ($LM1)
+ // PROC TEXT
+ // ... line numbers ... ($LM)
+ // END TEXT
+ // ... blocks ... (... local variables ... LBRAC ... subblocks ... RBRAC)
+ Result stab_magic(const char* magic);
+ Result source_file(const char* path, Address text_address);
+ Result data_type(const ParsedSymbol& symbol);
+ Result global_variable(
+ const char* mangled_name, Address address, const StabsType& type, bool is_static, GlobalStorageLocation location);
+ Result sub_source_file(const char* name, Address text_address);
+ Result procedure(
+ const char* mangled_name, Address address, const ProcedureDescriptor* procedure_descriptor, bool is_static);
+ Result label(const char* label, Address address, s32 line_number);
+ Result text_end(const char* name, s32 function_size);
+ Result function(const char* mangled_name, const StabsType& return_type, Address address);
+ Result function_end();
+ Result parameter(
+ const char* name, const StabsType& type, bool is_stack, s32 value, bool is_by_reference);
+ Result local_variable(
+ const char* name, const StabsType& type, u32 value, StabsSymbolDescriptor desc, SymbolClass sclass);
+ Result lbrac(s32 begin_offset);
+ Result rbrac(s32 end_offset);
+
+ Result finish();
+
+ Result create_function(const char* mangled_name, Address address);
+
+protected:
+ enum AnalysisState {
+ NOT_IN_FUNCTION,
+ IN_FUNCTION_BEGINNING,
+ IN_FUNCTION_END
+ };
+
+ SymbolDatabase& m_database;
+ const AnalysisContext& m_context;
+ const StabsToAstState& m_stabs_to_ast_state;
+
+ AnalysisState m_state = NOT_IN_FUNCTION;
+ SourceFile& m_source_file;
+ std::vector m_functions;
+ std::vector m_global_variables;
+ Function* m_current_function = nullptr;
+ std::vector m_current_parameter_variables;
+ std::vector m_current_local_variables;
+ std::vector> m_blocks;
+ std::vector m_pending_local_variables;
+ std::string m_next_relative_path;
+};
+
+std::optional symbol_class_to_global_variable_location(SymbolClass symbol_class);
+
+};
diff --git a/3rdparty/ccc/src/ccc/mdebug_importer.cpp b/3rdparty/ccc/src/ccc/mdebug_importer.cpp
new file mode 100644
index 0000000000..3038aede89
--- /dev/null
+++ b/3rdparty/ccc/src/ccc/mdebug_importer.cpp
@@ -0,0 +1,668 @@
+// This file is part of the Chaos Compiler Collection.
+// SPDX-License-Identifier: MIT
+
+#include "mdebug_importer.h"
+
+namespace ccc::mdebug {
+
+static Result resolve_type_names(
+ SymbolDatabase& database, const SymbolGroup& group, u32 importer_flags);
+static Result resolve_type_name(
+ ast::TypeName& type_name,
+ SymbolDatabase& database,
+ const SymbolGroup& group,
+ u32 importer_flags);
+static void compute_size_bytes(ast::Node& node, SymbolDatabase& database);
+static void detect_duplicate_functions(SymbolDatabase& database, const SymbolGroup& group);
+static void detect_fake_functions(SymbolDatabase& database, const std::map& external_functions, const SymbolGroup& group);
+static void destroy_optimized_out_functions(
+ SymbolDatabase& database, const SymbolGroup& group);
+
+Result import_symbol_table(
+ SymbolDatabase& database,
+ std::span elf,
+ s32 section_offset,
+ const SymbolGroup& group,
+ u32 importer_flags,
+ const DemanglerFunctions& demangler,
+ const std::atomic_bool* interrupt)
+{
+ SymbolTableReader reader;
+
+ Result reader_result = reader.init(elf, section_offset);
+ CCC_RETURN_IF_ERROR(reader_result);
+
+ Result> external_symbols = reader.parse_external_symbols();
+ CCC_RETURN_IF_ERROR(external_symbols);
+
+ // The addresses of the global variables aren't present in the local symbol
+ // table, so here we extract them from the external table. In addition, for
+ // some games we need to cross reference the function symbols in the local
+ // symbol table with the entries in the external symbol table.
+ std::map external_functions;
+ std::map external_globals;
+ for(const mdebug::Symbol& external : *external_symbols) {
+ if(external.symbol_type == mdebug::SymbolType::PROC) {
+ external_functions[external.value] = &external;
+ }
+
+ if(external.symbol_type == mdebug::SymbolType::GLOBAL
+ && (external.symbol_class != mdebug::SymbolClass::UNDEFINED)) {
+ external_globals[external.string] = &external;
+ }
+ }
+
+ // Bundle together some unchanging state to pass to import_files.
+ AnalysisContext context;
+ context.reader = &reader;
+ context.external_functions = &external_functions;
+ context.external_globals = &external_globals;
+ context.group = group;
+ context.importer_flags = importer_flags;
+ context.demangler = demangler;
+
+ Result result = import_files(database, context, interrupt);
+ CCC_RETURN_IF_ERROR(result);
+
+ return Result();
+}
+
+Result import_files(SymbolDatabase& database, const AnalysisContext& context, const std::atomic_bool* interrupt)
+{
+ Result file_count = context.reader->file_count();
+ CCC_RETURN_IF_ERROR(file_count);
+
+ for(s32 i = 0; i < *file_count; i++) {
+ if(interrupt && *interrupt) {
+ return CCC_FAILURE("Operation interrupted by user.");
+ }
+
+ Result file = context.reader->parse_file(i);
+ CCC_RETURN_IF_ERROR(file);
+
+ Result result = import_file(database, *file, context);
+ CCC_RETURN_IF_ERROR(result);
+ }
+
+ // The files field may be modified by further analysis passes, so we
+ // need to save this information here.
+ for(DataType& data_type : database.data_types) {
+ if(context.group.is_in_group(data_type) && data_type.files.size() == 1) {
+ data_type.only_defined_in_single_translation_unit = true;
+ }
+ }
+
+ // Lookup data types and store data type handles in type names.
+ Result type_name_result = resolve_type_names(database, context.group, context.importer_flags);
+ CCC_RETURN_IF_ERROR(type_name_result);
+
+ // Compute the size in bytes of all the AST nodes.
+ database.for_each_symbol([&](ccc::Symbol& symbol) {
+ if(context.group.is_in_group(symbol) && symbol.type()) {
+ compute_size_bytes(*symbol.type(), database);
+ }
+ });
+
+ // Propagate the size information to the global variable symbols.
+ for(GlobalVariable& global_variable : database.global_variables) {
+ if(global_variable.type() && global_variable.type()->size_bytes > -1) {
+ global_variable.set_size((u32) global_variable.type()->size_bytes);
+ }
+ }
+
+ // Propagate the size information to the static local variable symbols.
+ for(LocalVariable& local_variable : database.local_variables) {
+ bool is_static_local = std::holds_alternative(local_variable.storage);
+ if(is_static_local && local_variable.type() && local_variable.type()->size_bytes > -1) {
+ local_variable.set_size((u32) local_variable.type()->size_bytes);
+ }
+ }
+
+ // Some games (e.g. Jet X2O) have multiple function symbols across different
+ // translation units with the same name and address.
+ if(context.importer_flags & UNIQUE_FUNCTIONS) {
+ detect_duplicate_functions(database, context.group);
+ }
+
+ // If multiple functions appear at the same address, discard the addresses
+ // of all of them except the real one.
+ if(context.external_functions) {
+ detect_fake_functions(database, *context.external_functions, context.group);
+ }
+
+ // Remove functions with no address. If there are any such functions, this
+ // will invalidate all pointers to symbols.
+ if(context.importer_flags & NO_OPTIMIZED_OUT_FUNCTIONS) {
+ destroy_optimized_out_functions(database, context.group);
+ }
+
+ return Result();
+}
+
+Result import_file(SymbolDatabase& database, const mdebug::File& input, const AnalysisContext& context)
+{
+ // Parse the stab strings into a data structure that's vaguely
+ // one-to-one with the text-based representation.
+ u32 importer_flags_for_this_file = context.importer_flags;
+ Result> symbols = parse_symbols(input.symbols, importer_flags_for_this_file);
+ CCC_RETURN_IF_ERROR(symbols);
+
+ // In stabs, types can be referenced by their number from other stabs,
+ // so here we build a map of type numbers to the parsed types.
+ std::map stabs_types;
+ for(const ParsedSymbol& symbol : *symbols) {
+ if(symbol.type == ParsedSymbolType::NAME_COLON_TYPE) {
+ symbol.name_colon_type.type->enumerate_numbered_types(stabs_types);
+ }
+ }
+
+ Result source_file = database.source_files.create_symbol(
+ input.full_path, input.address, context.group.source, context.group.module_symbol);
+ CCC_RETURN_IF_ERROR(source_file);
+
+ (*source_file)->working_dir = input.working_dir;
+ (*source_file)->command_line_path = input.command_line_path;
+
+ // Sometimes the INFO symbols contain information about what toolchain
+ // version was used for building the executable.
+ for(const mdebug::Symbol& symbol : input.symbols) {
+ if(symbol.symbol_class == mdebug::SymbolClass::INFO && strcmp(symbol.string, "@stabs") != 0) {
+ (*source_file)->toolchain_version_info.emplace(symbol.string);
+ }
+ }
+
+ StabsToAstState stabs_to_ast_state;
+ stabs_to_ast_state.file_handle = (*source_file)->handle().value;
+ stabs_to_ast_state.stabs_types = &stabs_types;
+ stabs_to_ast_state.importer_flags = importer_flags_for_this_file;
+ stabs_to_ast_state.demangler = context.demangler;
+
+ // Convert the parsed stabs symbols to a more standard C AST.
+ LocalSymbolTableAnalyser analyser(database, stabs_to_ast_state, context, **source_file);
+ for(const ParsedSymbol& symbol : *symbols) {
+ if(symbol.duplicate) {
+ continue;
+ }
+
+ switch(symbol.type) {
+ case ParsedSymbolType::NAME_COLON_TYPE: {
+ switch(symbol.name_colon_type.descriptor) {
+ case StabsSymbolDescriptor::LOCAL_FUNCTION:
+ case StabsSymbolDescriptor::GLOBAL_FUNCTION: {
+ const char* name = symbol.name_colon_type.name.c_str();
+ const StabsType& type = *symbol.name_colon_type.type.get();
+ Result result = analyser.function(name, type, symbol.raw->value);
+ CCC_RETURN_IF_ERROR(result);
+ break;
+ }
+ case StabsSymbolDescriptor::REFERENCE_PARAMETER_A:
+ case StabsSymbolDescriptor::REGISTER_PARAMETER:
+ case StabsSymbolDescriptor::VALUE_PARAMETER:
+ case StabsSymbolDescriptor::REFERENCE_PARAMETER_V: {
+ const char* name = symbol.name_colon_type.name.c_str();
+ const StabsType& type = *symbol.name_colon_type.type.get();
+ bool is_stack_variable = symbol.name_colon_type.descriptor == StabsSymbolDescriptor::VALUE_PARAMETER;
+ bool is_by_reference = symbol.name_colon_type.descriptor == StabsSymbolDescriptor::REFERENCE_PARAMETER_A
+ || symbol.name_colon_type.descriptor == StabsSymbolDescriptor::REFERENCE_PARAMETER_V;
+
+ Result result = analyser.parameter(name, type, is_stack_variable, symbol.raw->value, is_by_reference);
+ CCC_RETURN_IF_ERROR(result);
+ break;
+ }
+ case StabsSymbolDescriptor::REGISTER_VARIABLE:
+ case StabsSymbolDescriptor::LOCAL_VARIABLE:
+ case StabsSymbolDescriptor::STATIC_LOCAL_VARIABLE: {
+ const char* name = symbol.name_colon_type.name.c_str();
+ const StabsType& type = *symbol.name_colon_type.type.get();
+ Result result = analyser.local_variable(
+ name, type, symbol.raw->value, symbol.name_colon_type.descriptor, symbol.raw->symbol_class);
+ CCC_RETURN_IF_ERROR(result);
+ break;
+ }
+ case StabsSymbolDescriptor::GLOBAL_VARIABLE:
+ case StabsSymbolDescriptor::STATIC_GLOBAL_VARIABLE: {
+ const char* name = symbol.name_colon_type.name.c_str();
+ u32 address = -1;
+ std::optional location =
+ symbol_class_to_global_variable_location(symbol.raw->symbol_class);
+ if(symbol.name_colon_type.descriptor == StabsSymbolDescriptor::GLOBAL_VARIABLE) {
+ // The address for non-static global variables is
+ // only stored in the external symbol table (and
+ // the ELF symbol table), so we pull that
+ // information in here.
+ if(context.external_globals) {
+ auto global_symbol = context.external_globals->find(symbol.name_colon_type.name);
+ if(global_symbol != context.external_globals->end()) {
+ address = (u32) global_symbol->second->value;
+ location = symbol_class_to_global_variable_location(global_symbol->second->symbol_class);
+ }
+ }
+ } else {
+ // And for static global variables it's just stored
+ // in the local symbol table.
+ address = (u32) symbol.raw->value;
+ }
+ CCC_CHECK(location.has_value(), "Invalid global variable location.")
+ const StabsType& type = *symbol.name_colon_type.type.get();
+ bool is_static = symbol.name_colon_type.descriptor == StabsSymbolDescriptor::STATIC_GLOBAL_VARIABLE;
+ Result result = analyser.global_variable(name, address, type, is_static, *location);
+ CCC_RETURN_IF_ERROR(result);
+ break;
+ }
+ case StabsSymbolDescriptor::TYPE_NAME:
+ case StabsSymbolDescriptor::ENUM_STRUCT_OR_TYPE_TAG: {
+ Result result = analyser.data_type(symbol);
+ CCC_RETURN_IF_ERROR(result);
+ break;
+ }
+ }
+ break;
+ }
+ case ParsedSymbolType::SOURCE_FILE: {
+ Result result = analyser.source_file(symbol.raw->string, symbol.raw->value);
+ CCC_RETURN_IF_ERROR(result);
+ break;
+ }
+ case ParsedSymbolType::SUB_SOURCE_FILE: {
+ Result result = analyser.sub_source_file(symbol.raw->string, symbol.raw->value);
+ CCC_RETURN_IF_ERROR(result);
+ break;
+ }
+ case ParsedSymbolType::LBRAC: {
+ Result result = analyser.lbrac(symbol.raw->value);
+ CCC_RETURN_IF_ERROR(result);
+ break;
+ }
+ case ParsedSymbolType::RBRAC: {
+ Result result = analyser.rbrac(symbol.raw->value);
+ CCC_RETURN_IF_ERROR(result);
+ break;
+ }
+ case ParsedSymbolType::FUNCTION_END: {
+ Result result = analyser.function_end();
+ CCC_RETURN_IF_ERROR(result);
+ break;
+ }
+ case ParsedSymbolType::NON_STABS: {
+ if(symbol.raw->symbol_class == mdebug::SymbolClass::TEXT) {
+ if(symbol.raw->symbol_type == mdebug::SymbolType::PROC) {
+ Result result = analyser.procedure(symbol.raw->string, symbol.raw->value, symbol.raw->procedure_descriptor, false);
+ CCC_RETURN_IF_ERROR(result);
+ } else if(symbol.raw->symbol_type == mdebug::SymbolType::STATICPROC) {
+ Result result = analyser.procedure(symbol.raw->string, symbol.raw->value, symbol.raw->procedure_descriptor, true);
+ CCC_RETURN_IF_ERROR(result);
+ } else if(symbol.raw->symbol_type == mdebug::SymbolType::LABEL) {
+ Result result = analyser.label(symbol.raw->string, symbol.raw->value, symbol.raw->index);
+ CCC_RETURN_IF_ERROR(result);
+ } else if(symbol.raw->symbol_type == mdebug::SymbolType::END) {
+ Result result = analyser.text_end(symbol.raw->string, symbol.raw->value);
+ CCC_RETURN_IF_ERROR(result);
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ Result result = analyser.finish();
+ CCC_RETURN_IF_ERROR(result);
+
+ return Result();
+}
+
+static Result resolve_type_names(
+ SymbolDatabase& database, const SymbolGroup& group, u32 importer_flags)
+{
+ Result result;
+ database.for_each_symbol([&](ccc::Symbol& symbol) {
+ if(group.is_in_group(symbol) && symbol.type()) {
+ ast::for_each_node(*symbol.type(), ast::PREORDER_TRAVERSAL, [&](ast::Node& node) {
+ if(node.descriptor == ast::TYPE_NAME) {
+ Result type_name_result = resolve_type_name(node.as(), database, group, importer_flags);
+ if(!type_name_result.success()) {
+ result = std::move(type_name_result);
+ }
+ }
+ return ast::EXPLORE_CHILDREN;
+ });
+ }
+ });
+ return result;
+}
+
+static Result resolve_type_name(
+ ast::TypeName& type_name,
+ SymbolDatabase& database,
+ const SymbolGroup& group,
+ u32 importer_flags)
+{
+ ast::TypeName::UnresolvedStabs* unresolved_stabs = type_name.unresolved_stabs.get();
+ if(!unresolved_stabs) {
+ return Result();
+ }
+
+ // Lookup the type by its STABS type number. This path ensures that the
+ // correct type is found even if multiple types have the same name.
+ if(unresolved_stabs->referenced_file_handle != (u32) -1 && unresolved_stabs->stabs_type_number.valid()) {
+ const SourceFile* source_file = database.source_files.symbol_from_handle(unresolved_stabs->referenced_file_handle);
+ CCC_ASSERT(source_file);
+ auto handle = source_file->stabs_type_number_to_handle.find(unresolved_stabs->stabs_type_number);
+ if(handle != source_file->stabs_type_number_to_handle.end()) {
+ type_name.data_type_handle = handle->second.value;
+ type_name.is_forward_declared = false;
+ type_name.unresolved_stabs.reset();
+ return Result();
+ }
+ }
+
+ // Looking up the type by its STABS type number failed, so look for it by
+ // its name instead. This happens when a type is forward declared but not
+ // defined in a given translation unit.
+ if(!unresolved_stabs->type_name.empty()) {
+ for(auto& name_handle : database.data_types.handles_from_name(unresolved_stabs->type_name)) {
+ DataType* data_type = database.data_types.symbol_from_handle(name_handle.second);
+ if(data_type && group.is_in_group(*data_type)) {
+ type_name.data_type_handle = name_handle.second.value;
+ type_name.is_forward_declared = true;
+ type_name.unresolved_stabs.reset();
+ return Result();
+ }
+ }
+ }
+
+ // If this branch is taken it means the type name was probably from an
+ // automatically generated member function of a nested struct trying to
+ // reference the struct (for the this parameter). We shouldn't create a
+ // forward declared type in this case.
+ if(type_name.source == ast::TypeNameSource::UNNAMED_THIS) {
+ return Result();
+ }
+
+ // Type lookup failed. This happens when a type is forward declared in a
+ // translation unit with symbols but is not defined in one. We haven't
+ // already created a forward declared type, so we create one now.
+ std::unique_ptr forward_declared_node;
+ if(unresolved_stabs->type.has_value()) {
+ switch(*unresolved_stabs->type) {
+ case ast::ForwardDeclaredType::STRUCT: {
+ std::unique_ptr node = std::make_unique();
+ node->is_struct = true;
+ forward_declared_node = std::move(node);
+ break;
+ }
+ case ast::ForwardDeclaredType::UNION: {
+ std::unique_ptr node = std::make_unique();
+ node->is_struct = false;
+ forward_declared_node = std::move(node);
+ break;
+ }
+ case ast::ForwardDeclaredType::ENUM: {
+ std::unique_ptr node = std::make_unique();
+ forward_declared_node = std::move(node);
+ break;
+ }
+ }
+ }
+
+ if(forward_declared_node) {
+ Result