// SPDX-License-Identifier: MIT #include "platform.hpp" #include "link/assign.hpp" #include #include #include #include #include #include #include #include #include #include #include "helpers.hpp" #include "itertools.hpp" #include "linkdefs.hpp" #include "verbosity.hpp" #include "link/main.hpp" #include "link/output.hpp" #include "link/section.hpp" #include "link/symbol.hpp" #include "link/warning.hpp" struct FreeSpace { uint16_t address; uint16_t size; // Never zero. uint16_t addrOnePast() const { return address + size; } }; // Table of free space for each bank static std::vector> memory[SECTTYPE_INVALID]; using FreeSpaceIter = std::deque::iterator; static std::deque &freeSpaceOfBank(Section const §ion, uint32_t bank) { assume(bank >= section.typeInfo().firstBank); assume(bank <= section.typeInfo().lastBank); return memory[section.type][bank - section.typeInfo().firstBank]; } struct Scrambling { uint16_t romxOfs = 0; uint16_t sramOfs = 0; uint16_t wramxOfs = 0; // Helper for the next function, to give names to its two returned values. struct ScramblingInfo { uint16_t &curOfs; uint16_t maxOfs; }; std::optional getInfoFor(SectionType type) { switch (type) { case SECTTYPE_ROMX: return { {romxOfs, options.scrambleROMX} }; case SECTTYPE_SRAM: return { {sramOfs, options.scrambleSRAM} }; case SECTTYPE_WRAMX: return { {wramxOfs, options.scrambleWRAMX} }; // Non-banked sections don't need scrambling support... case SECTTYPE_ROM0: case SECTTYPE_WRAM0: case SECTTYPE_OAM: case SECTTYPE_HRAM: assume(!sectionTypeInfo[type].isBanked()); return std::nullopt; // ...but VRAM doesn't either, regardless of whether it's banked or not. case SECTTYPE_VRAM: return std::nullopt; case SECTTYPE_INVALID: unreachable_(); } return std::nullopt; // Dead code, but some compilers don't recognize that. } }; static Scrambling scrambling; struct MemoryLocation { uint16_t address; uint32_t bank; static MemoryLocation initFor(Section const §ion) { MemoryLocation location; if (section.isAddressFixed) { // This will never change. location.address = section.org; } if (section.isBankFixed) { location.bank = section.bank; } else { location.bank = section.typeInfo().firstBank; if (auto info = scrambling.getInfoFor(section.type); info.has_value() && info->maxOfs != 0) { // If scrambling is enabled... // ...then we will begin the search from a different offset for each section. // Go to the next offset (backwards), wrapping around. (Thus, no underflow!) info->curOfs = (info->curOfs != 0 ? info->curOfs : info->maxOfs) - 1; location.bank += info->curOfs; } } return location; } // Try again in the next bank, if one is available. [[nodiscard("This returns whether iteration can be continued")]] bool goToNextApplicableBankFor(Section const §ion) { assume(bank >= section.typeInfo().firstBank); assume(bank <= section.typeInfo().lastBank); assume(!section.isBankFixed); // Try scrambled banks in descending order until no bank in the scrambled range is // available. if (auto info = scrambling.getInfoFor(section.type); info.has_value() && info->maxOfs != 0) { // All floating sections within a scrambled region should be // within the scrambled bank pool. assume(bank < info->maxOfs + section.typeInfo().firstBank); uint16_t ofsWithinPool = bank - section.typeInfo().firstBank; // Go to the next bank (backwards), wrapping around. (Thus, no overflow!) ofsWithinPool = (ofsWithinPool != 0 ? ofsWithinPool : info->maxOfs) - 1; bank = ofsWithinPool + section.typeInfo().firstBank; // Keep iterating unless we have wrapped back around to the start offset. return ofsWithinPool != info->curOfs; } // Otherwise, try in ascending order. if (bank == section.typeInfo().lastBank) { return false; } ++bank; return true; } void makeAddressAligned(uint16_t alignMask, uint16_t alignOfs) { // By how much the address is past the target offset within the current alignment "page". uint16_t offset = (address - alignOfs) & alignMask; // Move by one page *minus* that "overshoot" offset. // If it's 0, then this would move by a whole page, but `& alignMask` resets it back to 0. address += ((alignMask + 1) - offset) & alignMask; } }; static FreeSpaceIter tryPlacingInBank(Section const §ion, MemoryLocation &location) { std::deque &bankMem = freeSpaceOfBank(section, location.bank); if (section.isAddressFixed) { // There is only one candidate location in this bank: the address at which the section is // fixed. assume(location.address == section.org); FreeSpaceIter iter = std::find_if(RANGE(bankMem), [&location](FreeSpace const &freeSpace) { // If they both exactly match, that means the next block will begin past the requested // addr, so the function would fail anyway. return freeSpace.addrOnePast() >= location.address; }); if (iter != bankMem.end()) { // We have the first block ending after the section's address, so all that's left is // checking that the address does fall into the block, and then that the section fits. if (location.address < iter->address || location.address + section.size > iter->addrOnePast()) { return bankMem.end(); // Failed! Better luck next bank? } } return iter; } else { // There are many possible locations within the bank, so we are going to iterate on free // blocks. If it is impossible to fit at the earliest (constraint-satisfying) address, then // no other address in the block will do; thus, we make only one attempt per block. return std::find_if(RANGE(bankMem), [&location, §ion](FreeSpace const &freeSpace) { location.address = freeSpace.address; if (section.isAlignFixed) { location.makeAddressAligned(section.alignMask, section.alignOfs); // Did it advance past the block? Or, rarely, overflowed? if (location.address >= freeSpace.addrOnePast() || location.address < freeSpace.address) { return false; } } // Since `location.address` lies within the block, // we only need to check that its end address also does. return location.address + section.size <= freeSpace.addrOnePast(); }); } } // Place section using first-fit decreasing algorithm // // Returns an iterator to within `freeSpaceOfBank(section, location.bank)` // (guaranteeing that `location.bank` remains valid) pointing at the free block that // the section can go into (at `location.address`). // The iterator is an end iterator if and only if no suitable location was found. // `location` is updated accordingly. static FreeSpaceIter tryPlacing(Section const §ion, MemoryLocation &location) { if (section.isBankFixed) { assume(location.bank == section.bank); return tryPlacingInBank(section, location); } do { if (FreeSpaceIter iter = tryPlacingInBank(section, location); iter != freeSpaceOfBank(section, location.bank).end()) { return iter; // Found one! } } while (location.goToNextApplicableBankFor(section)); // Return a deque's end iterator to signal failure. // The exact deque doesn't matter, but the caller will use `freeSpaceOfBank` also. return freeSpaceOfBank(section, location.bank).end(); } static void updateFreeSpace(FreeSpaceIter iter, std::deque &bankMem, Section const §ion) { assume(section.org + section.size <= UINT16_MAX); uint16_t sectionEnd = section.org + section.size; assume(section.org >= iter->address); assume(sectionEnd <= iter->addrOnePast()); bool noLeftSpace = iter->address == section.org; bool noRightSpace = iter->address + iter->size == sectionEnd; if (noLeftSpace && noRightSpace) { // The free space is entirely deleted bankMem.erase(iter); } else if (!noLeftSpace && !noRightSpace) { // The free space is split in two uint16_t size = static_cast(iter->address + iter->size - sectionEnd); // Resize the original space (address is unmodified) iter->size = section.org - iter->address; // Append the new space after the original one bankMem.insert(iter + 1, {.address = sectionEnd, .size = size}); // `iter` cannot be reused from this point on, because `bankMem.insert` // invalidates iterators to itself! } else { // The amount of free spaces doesn't change: resize! iter->size -= section.size; if (noLeftSpace) { // The free space is moved *and* resized iter->address += section.size; } } } // Assigns a section to a given memory location static void assignSection(Section §ion, MemoryLocation const &location) { assume(location.address >= section.typeInfo().startAddr); // Zero-sized sections can start one past the end of their region. assume(location.address <= section.typeInfo().onePastEndAddr()); // This one is not redundant, it guards against overflow! assume(location.address + section.size >= section.typeInfo().startAddr); assume(location.address + section.size <= section.typeInfo().onePastEndAddr()); if (section.isAddressFixed) { assume(location.address == section.org); } else if (section.isAlignFixed) { assume((location.address & section.alignMask) == section.alignOfs); } if (section.isBankFixed) { assume(location.bank == section.bank); } // Propagate the assigned location to all UNIONs/FRAGMENTs // so `jr` patches in them will have the correct offset for (Section &piece : section.pieces()) { piece.org = location.address; piece.bank = location.bank; } out_AddSection(section); } static std::string describeConstraintsOf(Section const §ion) { std::string description = "\"" + section.name + "\" (" + section.typeInfo().name + " section) "; if (section.isBankFixed && section.typeInfo().isBanked()) { char bank[9]; sprintf_to_array(bank, "%02" PRIx32, section.bank); if (section.isAddressFixed) { char addr[5]; sprintf_to_array(addr, "%04" PRIx16, section.org); description = description + "at $" + bank + ":" + addr; } else if (section.isAlignFixed) { char mask[5]; sprintf_to_array(mask, "%" PRIx16, static_cast(~section.alignMask)); description = description + "in bank $" + bank + " with align mask $" + mask; } else { description = description + "in bank $" + bank; } } else { if (section.isAddressFixed) { char addr[5]; sprintf_to_array(addr, "%04" PRIx16, section.org); description = description + "at address $" + addr; } else if (section.isAlignFixed) { char mask[5], offset[5]; sprintf_to_array(mask, "%" PRIx16, static_cast(~section.alignMask)); sprintf_to_array(offset, "%" PRIx16, section.alignOfs); description = description + "with align mask $" + mask + " and offset $" + offset; } else { description = description + "anywhere"; } if (auto info = scrambling.getInfoFor(section.type); info.has_value() && info->maxOfs != 0) { // Only mention scrambling if it is enabled. char size[6]; sprintf_to_array(size, "%" PRIu16, info->maxOfs); description = description + " within the " + size + " scrambled banks"; } } return description; } // Places a section in a suitable location, or error out if it fails to. // Due to the implemented algorithm, this should be called with sections of decreasing size! static void placeSection(Section §ion) { MemoryLocation location = MemoryLocation::initFor(section); // Specially handle 0-byte SECTIONs, as they ignore free space entirely. if (section.size == 0) { if (!section.isAddressFixed) { location.address = section.typeInfo().startAddr; if (section.isAlignFixed) { location.makeAddressAligned(section.alignMask, section.alignOfs); } } // This check safely handles sections with impossible alignment and no fixed address. // The above `location.address = section.typeInfo().startAddr` would be valid on its own, // but `location.makeAddressAligned(...)` can increase `location.address` above the valid // range for its `section`, which would violate an assumption in `assignSection`. // Note that sections with fixed addresses are handled earlier by `sect_DoSanityChecks`, // but this check would safely handle them too if they ever reached it. if (location.address <= section.typeInfo().onePastEndAddr()) { assignSection(section, location); return; } } FreeSpaceIter iter = tryPlacing(section, location); if (std::deque &bankMem = freeSpaceOfBank(section, location.bank); iter != bankMem.end()) { assignSection(section, location); updateFreeSpace(iter, bankMem, section); return; } if (!section.isBankFixed || !section.isAddressFixed) { // If a section failed to go to several places, nothing we can report fatal("Unable to place %s", describeConstraintsOf(section).c_str()); } else if (section.org + section.size > section.typeInfo().onePastEndAddr()) { // If the section just can't fit the bank, report that fatal( "Unable to place %s: section runs past end of region ($%04x > $%04x)", describeConstraintsOf(section).c_str(), section.org + section.size, section.typeInfo().onePastEndAddr() ); } else { // Otherwise there is overlap with another section Section const *overlap = out_OverlappingSection(section); assume(overlap != nullptr); fatal( "Unable to place %s: section overlaps with \"%s\"", describeConstraintsOf(section).c_str(), overlap->name.c_str() ); } } static std::deque
unassignedSections; // Categorize a section depending on how constrained it is. // This is so the most-constrained sections are placed first. static void categorizeSection(Section §ion) { // Insert section while keeping the list sorted by decreasing constraints, alignment, and size. auto const compareSections = [](Section const *prev, Section const §) { // Sort more-constrained sections first (bank > address > alignment). if (prev->isBankFixed != sect.isBankFixed) { return prev->isBankFixed > sect.isBankFixed; } if (prev->isAddressFixed != sect.isAddressFixed) { return prev->isAddressFixed > sect.isAddressFixed; } if (prev->isAlignFixed != sect.isAlignFixed) { return prev->isAlignFixed > sect.isAlignFixed; } // For equally-constrained sections, sort more-aligned ones first. assume(prev->isAlignFixed == sect.isAlignFixed); if (sect.isAlignFixed && prev->alignMask != sect.alignMask) { return prev->alignMask > sect.alignMask; } // For equally-aligned sections, sort larger ones first. return prev->size > sect.size; }; unassignedSections.insert( std::lower_bound(RANGE(unassignedSections), section, compareSections), §ion ); } static void checkOverlayCompat() { std::string unfixedList; size_t nbListed = 0; size_t nbUnlisted = 0; for (Section const *section : unassignedSections) { if (section->isBankFixed && section->isAddressFixed) { continue; } if (nbListed == 10) { ++nbUnlisted; continue; } unfixedList += "\n- \""; unfixedList += section->name; unfixedList += "\" ("; if (!section->isBankFixed && !section->isAddressFixed) { unfixedList += "bank and address"; } else if (!section->isBankFixed) { unfixedList += "bank"; } else { assume(!section->isAddressFixed); unfixedList += "address"; } unfixedList += " not specified)"; ++nbListed; } size_t nbUnfixedSections = nbListed + nbUnlisted; if (nbUnfixedSections == 0) { return; } if (nbUnlisted > 0) { unfixedList += "\n- and "; unfixedList += std::to_string(nbUnlisted); unfixedList += " more"; } fatal( "All sections must be fixed when using an overlay file; %zu %s not:%s", nbUnfixedSections, nbUnfixedSections == 1 ? "is" : "are", unfixedList.c_str() ); } void assign_AssignSections() { verbosePrint(VERB_NOTICE, "Beginning assignment...\n"); // Initialize the free space-modelling structs for (SectionType type : EnumSeq(SECTTYPE_INVALID)) { SectionTypeInfo const &typeInfo = sectionTypeInfo[type]; memory[type].resize(typeInfo.nbBanks()); for (std::deque &bankMem : memory[type]) { bankMem.push_back({ .address = typeInfo.startAddr, .size = typeInfo.size, }); } } // Generate sorted list of sections to assign sect_ForEach(categorizeSection); // Overlaying requires only fully-constrained sections if (options.overlayFileName) { checkOverlayCompat(); } // Assign sections in the order they were sorted for (Section *section : unassignedSections) { placeSection(*section); } }