Method read_data_reference_syms

src/config.cpp:731–834

Reads a data symbol file and adds its contents into this context's reference data symbols.

// Reads a data symbol file and adds its contents into this context's reference data symbols.
bool N64Recomp::Context::read_data_reference_syms(const std::filesystem::path& data_syms_file_path) {
    try {
        const toml::table data_syms_file_data = toml::parse_file(data_syms_file_path.u8string());
        const toml::node_view data_sections_value = data_syms_file_data["section"];

        if (!data_sections_value.is_array()) {
            return false;
        }

        // Create a mapping of rom address to section to ensure that the same section indexes are used for both function and data reference symbols.
        std::unordered_map<uint32_t, uint16_t> ref_section_indices_by_vrom;

        for (uint16_t section_index = 0; section_index < reference_sections.size(); section_index++) {
            ref_section_indices_by_vrom.emplace(reference_sections[section_index].rom_addr, section_index);
        }
        
        const toml::array* data_sections = data_sections_value.as_array();
        
        data_sections->for_each([this, &ref_section_indices_by_vrom](auto&& el) {
            if constexpr (toml::is_table<decltype(el)>) {
                std::optional<uint64_t> rom_addr = el["rom"].template value<uint64_t>();
                std::optional<uint32_t> vram_addr = el["vram"].template value<uint32_t>();
                std::optional<uint32_t> size = el["size"].template value<uint32_t>();
                std::optional<std::string> name = el["name"].template value<std::string>();

                if (!vram_addr.has_value() || !size.has_value() || !name.has_value()) {
                    throw toml::parse_error("Section entry missing required field(s)", el.source());
                }

                uint16_t ref_section_index;
                if (!rom_addr.has_value()) {
                    ref_section_index = N64Recomp::SectionAbsolute; // Non-relocatable bss section or absolute symbols, mark this as an absolute symbol
                }
                else if (rom_addr.value() > 0xFFFFFFFF) {
                    throw toml::parse_error("Section has invalid ROM address", el.source());
                }
                else {
                    // Find the matching section from the function reference symbol file to ensure 
                    auto find_section_it = ref_section_indices_by_vrom.find(rom_addr.value());
                    if (find_section_it != ref_section_indices_by_vrom.end()) {
                        ref_section_index = find_section_it->second;
                    }
                    else {
                        ref_section_index = N64Recomp::SectionAbsolute; // Not in the function symbol reference file, so this section can be treated as non-relocatable.
                    }
                }

                static ReferenceSection dummy_absolute_section {
                    .rom_addr = 0,
                    .ram_addr = 0,
                    .size = 0,
                    .relocatable = 0
                };
                const ReferenceSection& ref_section = ref_section_index == N64Recomp::SectionAbsolute ? dummy_absolute_section : this->reference_sections[ref_section_index];

                // Sanity check this section against the matching one in the function reference symbol file if one exists.
                if (ref_section_index != N64Recomp::SectionAbsolute) {
                    if (ref_section.ram_addr != vram_addr.value()) {