Function read_sections

src/elf.cpp:223–617

}

ELFIO::section* read_sections(N64Recomp::Context& context, ELFIO::section*& mdebug_section_out, const N64Recomp::ElfParsingConfig& elf_config, const ELFIO::elfio& elf_file) {
    ELFIO::section* symtab_section = nullptr;
    std::vector<SegmentEntry> segments{};
    segments.resize(elf_file.segments.size());
    bool has_reference_symbols = context.has_reference_symbols();

    // Copy the data for each segment into the segment entry list
    for (size_t segment_index = 0; segment_index < elf_file.segments.size(); segment_index++) {
        const auto& segment = *elf_file.segments[segment_index];
        segments[segment_index].data_offset = segment.get_offset();
        segments[segment_index].physical_address = segment.get_physical_address();
        segments[segment_index].memory_size = segment.get_file_size();
    }

    //// Sort the segments by physical address
    //std::sort(segments.begin(), segments.end(),
    //    [](const SegmentEntry& lhs, const SegmentEntry& rhs) {
    //        return lhs.data_offset < rhs.data_offset;
    //    }
    //);

    std::unordered_map<std::string, ELFIO::section*> reloc_sections_by_name;
    std::unordered_map<std::string, ELFIO::section*> bss_sections_by_name;

    // First pass over the sections to find the load addresses and track the minimum load address value. This mimics the objcopy raw binary output behavior.
    uint32_t min_load_address = (uint32_t)-1;
    for (const auto& section : elf_file.sections) {
        auto& section_out = context.sections[section->get_index()];
        ELFIO::Elf_Word type = section->get_type();
        ELFIO::Elf_Xword flags = section->get_flags();
        ELFIO::Elf_Xword section_size = section->get_size();

        // Check if this section will end up in the ROM. It must not be a nobits (NOLOAD) type, must have the alloc flag set and must have a nonzero size.
        if (type != ELFIO::SHT_NOBITS && (flags & ELFIO::SHF_ALLOC) && section_size != 0) {
            std::optional<size_t> segment_index = get_segment(segments, section_size, section->get_offset());
            if (!segment_index.has_value()) {
                fmt::print(stderr, "Could not find segment that section {} belongs to!\n", section->get_name());
                return nullptr;
            }

            const SegmentEntry& segment = segments[segment_index.value()];
            // Calculate the load address of the section based on that of the segment.
            // This will get modified afterwards in the next pass to offset by the minimum load address.
            section_out.rom_addr = segment.physical_address + (section->get_offset() - segment.data_offset);
            // Track the minimum load address.
            min_load_address = std::min(min_load_address, section_out.rom_addr);
        }
        else {
            // Otherwise mark this section as having an invalid rom address
            section_out.rom_addr = (uint32_t)-1;
        }
    }

    // Iterate over every section to record rom addresses and find the symbol table
    for (const auto& section : elf_file.sections) {
        auto& section_out = context.sections[section->get_index()];
        //fmt::print("  {}: {} @ 0x{:08X}, 0x{:08X}\n", section->get_index(), section->get_name(), section->get_address(), context.rom.size());
        // Set the rom address of this section to the current accumulated ROM size