Loading...
--- dyld/dyld-1340/mach_o/NListSymbolTable.cpp
+++ dyld/dyld-1122.1/mach_o/NListSymbolTable.cpp
@@ -23,16 +23,18 @@
#include "MemoryBuffer.h"
#include <algorithm>
-#include <mach-o/loader.h>
#include <sys/types.h>
#include <assert.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
-#if !TARGET_OS_EXCLAVEKIT
+#if BUILDING_MACHO_WRITER
+#include <mach-o/loader.h>
+#include <mach-o/nlist.h>
#include <mach-o/stab.h>
-#endif
+#include "Algorithm.h"
+#endif // BUILDING_MACHO_WRITER
#include "Symbol.h"
#include "NListSymbolTable.h"
@@ -94,7 +96,6 @@
{
bool dontDeadStrip = (n_desc & N_NO_DEAD_STRIP);
bool cold = (n_desc & N_COLD_FUNC);
- bool isThumb = (n_desc & N_ARM_THUMB_DEF);
switch ( n_type & N_TYPE ) {
case N_UNDF:
if ( n_value == 0 )
@@ -103,22 +104,11 @@
return Symbol::makeHiddenTentativeDef(symbolName, n_value, GET_COMM_ALIGN(n_desc), dontDeadStrip, cold);
else
return Symbol::makeTentativeDef(symbolName, n_value, GET_COMM_ALIGN(n_desc), dontDeadStrip, cold);
- case N_ABS: {
- Symbol::Scope scope = Symbol::Scope::global;
-
- if ( (n_type & N_EXT) == 0 ) {
- if ( n_type & N_PEXT )
- scope = Symbol::Scope::wasLinkageUnit;
- else
- scope = Symbol::Scope::translationUnit;
- }
- else if ( n_type & N_PEXT )
- scope = Symbol::Scope::linkageUnit;
+ case N_ABS:
+ if ( n_type & N_EXT )
+ return Symbol::makeAbsoluteExport(symbolName, n_value, dontDeadStrip);
else
- scope = Symbol::Scope::global;
-
- return Symbol::makeAbsolute(symbolName, n_value, dontDeadStrip, scope);
- }
+ return Symbol::makeAbsoluteLocal(symbolName, n_value, dontDeadStrip);
case N_INDR: {
const char* importName = symbolName;
if ( n_value < _stringPoolSize )
@@ -136,45 +126,41 @@
}
case N_SECT: {
if ( (n_type & N_EXT) == 0 ) {
- if ( n_desc & N_ALT_ENTRY ) {
- if ( n_type & N_PEXT )
- return Symbol::makeAltEntry(symbolName, n_value - _preferredLoadAddress, n_sect, Symbol::Scope::wasLinkageUnit, dontDeadStrip, cold, (n_desc & N_WEAK_DEF) != 0);
- else
- return Symbol::makeAltEntry(symbolName, n_value - _preferredLoadAddress, n_sect, Symbol::Scope::translationUnit, dontDeadStrip, cold, (n_desc & N_WEAK_DEF) != 0);
- }
+ if ( n_desc & N_ALT_ENTRY )
+ return Symbol::makeAltEntry(symbolName, n_value - _preferredLoadAddress, n_sect, Symbol::Scope::translationUnit, dontDeadStrip, cold);
else if ( n_type & N_PEXT ) {
if ( n_desc & N_WEAK_DEF )
- return Symbol::makeWeakDefWasPrivateExtern(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold, isThumb);
+ return Symbol::makeWeakDefWasPrivateExtern(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold);
else
- return Symbol::makeRegularWasPrivateExtern(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold, isThumb);
+ return Symbol::makeRegularWasPrivateExtern(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold);
} else
- return Symbol::makeRegularLocal(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold, isThumb);
+ return Symbol::makeRegularLocal(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold);
}
else if ( n_type & N_PEXT ) {
- if ( n_desc & N_ALT_ENTRY )
- return Symbol::makeAltEntry(symbolName, n_value - _preferredLoadAddress, n_sect, Symbol::Scope::linkageUnit, dontDeadStrip, cold, (n_desc & N_WEAK_DEF) != 0);
- else if ( n_desc & N_WEAK_DEF )
- return Symbol::makeWeakDefHidden(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold, isThumb);
- else if ( n_desc & N_SYMBOL_RESOLVER ) // rdar://123349256 (ld-prime needs to handle internal resolvers)
- return Symbol::makeDynamicResolver(symbolName, n_sect, 0, n_value - _preferredLoadAddress, Symbol::Scope::linkageUnit);
+ if ( n_desc & N_WEAK_DEF )
+ return Symbol::makeWeakDefHidden(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold);
+ else if ( n_desc & N_ALT_ENTRY )
+ return Symbol::makeAltEntry(symbolName, n_value - _preferredLoadAddress, n_sect, Symbol::Scope::linkageUnit, dontDeadStrip, cold);
else
- return Symbol::makeRegularHidden(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold, isThumb);
- }
- else if ( n_desc & N_ALT_ENTRY ) {
- return Symbol::makeAltEntry(symbolName, n_value - _preferredLoadAddress, n_sect, Symbol::Scope::global, dontDeadStrip, cold, (n_desc & N_WEAK_DEF) != 0);
+ return Symbol::makeRegularHidden(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold);
}
else if ( (n_desc & (N_WEAK_DEF|N_WEAK_REF)) == (N_WEAK_DEF|N_WEAK_REF) ) {
- return Symbol::makeWeakDefAutoHide(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold, isThumb);
+ return Symbol::makeWeakDefAutoHide(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold);
}
else if ( n_desc & N_WEAK_DEF ) {
- return Symbol::makeWeakDefExport(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold, isThumb);
- }
- else if ( n_desc & N_SYMBOL_RESOLVER ) {
- return Symbol::makeDynamicResolver(symbolName, n_sect, 0, n_value - _preferredLoadAddress);
+ return Symbol::makeWeakDefExport(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold);
}
else {
- bool neverStrip = (n_desc & REFERENCED_DYNAMICALLY);
- return Symbol::makeRegularExport(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold, neverStrip, isThumb);
+ if ( n_desc & N_ALT_ENTRY ) {
+ return Symbol::makeAltEntry(symbolName, n_value - _preferredLoadAddress, n_sect, Symbol::Scope::global, dontDeadStrip, cold);
+ }
+ else if ( n_desc & N_SYMBOL_RESOLVER ) {
+ return Symbol::makeDynamicResolver(symbolName, n_sect, 0, n_value - _preferredLoadAddress);
+ }
+ else {
+ bool neverStrip = (n_desc & REFERENCED_DYNAMICALLY);
+ return Symbol::makeRegularExport(symbolName, n_value - _preferredLoadAddress, n_sect, dontDeadStrip, cold, neverStrip);
+ }
}
}
}
@@ -183,21 +169,10 @@
void NListSymbolTable::forEachExportedSymbol(void (^callback)(const Symbol& symbol, uint32_t symbolIndex, bool& stop)) const
{
- if ( (_localsCount == 0) && (_globalsCount == 0) && (_undefsCount == 0) && (_nlistCount != 0) ) {
- // if no LC_DYSYMTAB, need to scan whole table and selectively find global symbols
- forEachSymbol(^(const char* symbolName, uint64_t n_value, uint8_t n_type, uint8_t n_sect, uint16_t n_desc, uint32_t symbolIndex, bool& stop) {
- uint8_t type = n_type & N_TYPE;
- if ( (n_type & N_EXT) && ((type == N_SECT) || (type == N_ABS) || (type == N_INDR)) && ((n_type & N_STAB) == 0))
- callback(symbolFromNList(symbolName, n_value, n_type, n_sect, n_desc), symbolIndex, stop);
- });
- } else {
- uint32_t globalsStartIndex = _localsCount;
- forEachSymbol(globalsStartIndex, _globalsCount, ^(const char* symbolName, uint64_t n_value, uint8_t n_type, uint8_t n_sect, uint16_t n_desc, uint32_t symbolIndex, bool& stop) {
- uint8_t type = n_type & N_TYPE;
- if ( (n_type & N_EXT) && ((type == N_SECT) || (type == N_ABS) || (type == N_INDR)) && ((n_type & N_STAB) == 0))
- callback(symbolFromNList(symbolName, n_value, n_type, n_sect, n_desc), symbolIndex, stop);
- });
- }
+ uint32_t globalsStartIndex = _localsCount;
+ forEachSymbol(globalsStartIndex, _globalsCount, ^(const char* symbolName, uint64_t n_value, uint8_t n_type, uint8_t n_sect, uint16_t n_desc, uint32_t symbolIndex, bool& stop) {
+ callback(symbolFromNList(symbolName, n_value, n_type, n_sect, n_desc), symbolIndex, stop);
+ });
}
void NListSymbolTable::forEachDefinedSymbol(void (^callback)(const Symbol& symbol, uint32_t symbolIndex, bool& stop)) const
@@ -253,30 +228,6 @@
}
}
return stop;
-}
-
-bool NListSymbolTable::symbolAtIndex(uint32_t symbolIndex, Symbol& symbol) const
-{
- if ( symbolIndex >= _nlistCount )
- return false;
-
- if ( _nlist64 ) {
- const struct nlist_64& sym = _nlist64[symbolIndex];
- if ( sym.n_un.n_strx > _stringPoolSize )
- return false;
- symbol = symbolFromNList(&_stringPool[sym.n_un.n_strx], sym.n_value, sym.n_type, sym.n_sect, sym.n_desc);
- return true;
- }
-
- if ( _nlist32 ) {
- const struct nlist& sym = _nlist32[symbolIndex];
- if ( sym.n_un.n_strx > _stringPoolSize )
- return false;
- symbol = symbolFromNList(&_stringPool[sym.n_un.n_strx], sym.n_value, sym.n_type, sym.n_sect, sym.n_desc);
- return true;
- }
-
- return false;
}
bool NListSymbolTable::findClosestDefinedSymbol(uint64_t unslidAddr, Symbol& sym) const
@@ -344,7 +295,13 @@
return _nlist32[symbolIndex].n_value;
}
-#if !TARGET_OS_EXCLAVEKIT
+
+//
+// MARK: --- NListSymbolTable building methods ---
+//
+
+#if BUILDING_MACHO_WRITER
+
void NListSymbolTable::forEachDebugNote(bool freeFileInfo, void (^callback)(const DebugNote& note, bool& stop)) const
{
__block CString currentSrcDir = nullptr;
@@ -422,18 +379,490 @@
}
});
}
-#endif // !TARGET_OS_EXCLAVEKIT
+
+uint32_t NListSymbolTable::countDebugNoteNLists(std::span<const DebugBuilderNote> debugNotes)
+{
+ uint32_t debugStabNlists=0;
+ bool startedSO=false;
+
+ for ( const DebugBuilderNote& note : debugNotes ) {
+ if ( note.fileInfo->srcDir().empty() && note.fileInfo->srcName().empty() ) {
+ debugStabNlists += 1;
+ } else {
+ if ( !startedSO ) {
+ startedSO = true;
+ debugStabNlists += 1;
+ }
+ debugStabNlists += 4;
+ if ( note.fileInfo->hasOriginLibInfo() )
+ debugStabNlists += 1;
+
+ for ( const DebugBuilderNoteItem& item : note.items ) {
+ if ( item.type == N_FUN )
+ debugStabNlists += 4;
+ else
+ debugStabNlists += 1;
+ }
+ }
+ }
+ return debugStabNlists;
+}
+
+template <typename T>
+void NListSymbolTable::addStabsFromDebugNotes(std::span<const DebugBuilderNote> debugNotes, bool zeroModTimes, NListBuffer& nlists)
+{
+ typedef __typeof(T::n_value) V;
+
+ bool startedSOs = false;
+ for (const DebugBuilderNote& note : debugNotes) {
+ uint32_t mtime = (zeroModTimes ? 0 : note.fileInfo->objModTime());
+ if ( note.srcDirPoolOffset == 0 && note.srcNamePoolOffset == 0 ) {
+ nlists.add(T{{note.objPathPoolOffset}, N_AST, 0, 0, (V)mtime});
+ }
+ else {
+ if ( !startedSOs )
+ nlists.add(T{{1}, N_SO, 1, 0, 0}); // match ld64 which always started debug notes with an "end SO"
+ // Put this before the other N_SO's. We can't put it right before the N_OSO as lldb expects the N_OSO
+ // to be immediately preceded by the N_SO
+ if ( note.originLibPathPoolOffset != 0 ) {
+ nlists.add(T{{note.originLibPathPoolOffset}, N_LIB, 0, 0, 0});
+ }
+ startedSOs = true;
+ nlists.add(T{{note.srcDirPoolOffset}, N_SO, 0, 0, 0});
+ nlists.add(T{{note.srcNamePoolOffset}, N_SO, 0, 0, 0});
+ nlists.add(T{{note.objPathPoolOffset}, N_OSO, note.fileInfo->objSubType(), 1, (V)mtime});
+ for (const DebugBuilderNoteItem& item : note.items) {
+ uint32_t stringPoolOffset = item.stringPoolOffset;
+ switch ( item.type ) {
+ case N_FUN:
+ // for functions, we use four symbols to record the name, address, size, and sectNum
+ nlists.add(T{{1}, N_BNSYM, item.sectNum, 0, (V)item.addr});
+ nlists.add(T{{stringPoolOffset}, N_FUN, item.sectNum, 0, (V)item.addr});
+ nlists.add(T{{1}, N_FUN, 0, 0, (V)item.size});
+ nlists.add(T{{1}, N_ENSYM, item.sectNum, 0, (V)item.addr});
+ break;
+ case N_STSYM:
+ // for static variables, we record the name, address, and sectNum
+ nlists.add(T{{stringPoolOffset}, N_STSYM, item.sectNum, 0, (V)item.addr});
+ break;
+ case N_GSYM:
+ // for global variables, we record just the name
+ nlists.add(T{{stringPoolOffset}, N_GSYM, 0, 0, 0});
+ break;
+ default:
+ assert(false && "invalid debug note item");
+ break;
+ }
+ }
+ nlists.add(T{{1}, N_SO, 1, 0, 0});
+ }
+ }
+}
+
+
+/*!
+ * @class NListStringPoolBuffer
+ *
+ * @abstract
+ * Simple NList string pool buffer, used in unit-tests.
+ */
+struct NListStringPoolBuffer
+{
+ std::vector<char> buffer;
+ uint32_t pos = 0;
+
+ NListStringPoolBuffer()
+ {
+ add(' ');
+ add('\0');
+ }
+
+ NListStringPoolBuffer(const NListStringPoolBuffer&) = delete;
+ NListStringPoolBuffer(NListStringPoolBuffer&&) = default;
+ NListStringPoolBuffer& operator=(const NListStringPoolBuffer&) = delete;
+ NListStringPoolBuffer& operator=(NListStringPoolBuffer&&) = default;
+
+ uint32_t add(CString str);
+ uint32_t add(std::span<const char> bytes);
+ uint32_t add(char ch);
+ uint32_t size() { return pos; }
+ char* data() { return buffer.data(); }
+
+ void finalize(bool is64)
+ {
+ uint32_t pointerSize = is64 ? 8 : 4;
+ while ( size() % pointerSize )
+ add('\0');
+ }
+
+ std::pair<uint32_t, char*> reserve(size_t);
+};
+
+NListSymbolTable::SymbolPartition::SymbolPartition(std::span<const Symbol> symbols, bool objectFile)
+{
+ for (const Symbol& symbol : symbols) {
+ int libOrdinal;
+ bool weakImport;
+ uint64_t size;
+ uint8_t p2Align;
+ if ( symbol.isUndefined(libOrdinal, weakImport) || symbol.isTentativeDef(size, p2Align) )
+ undefs.push_back(symbol);
+ else if ( symbol.scope() == Symbol::Scope::global )
+ globals.push_back(symbol);
+ else if ( (symbol.scope() == Symbol::Scope::linkageUnit) && objectFile )
+ globals.push_back(symbol); // in .o files hidden symbols are in globals range
+ else if ( (symbol.scope() == Symbol::Scope::autoHide) && objectFile )
+ globals.push_back(symbol); // in .o files hidden symbols are in globals range
+ else
+ locals.push_back(symbol);
+ }
+
+ // for historical binary search reasons, globals are sorted by name
+ std::sort(globals.begin(), globals.end(), [&](const Symbol& a, const Symbol& b) {
+ return a.name() < b.name();
+ });
+ // undefs are sorted by name
+ std::sort(undefs.begin(), undefs.end(), [&](const Symbol& a, const Symbol& b) {
+ return a.name() < b.name();
+ });
+ // locals are already sorted by their position in their section. We don't need to sort them again
+}
+
+NListSymbolTable::NListSymbolTable(std::span<const Symbol> symbols, uint64_t prefLoadAddr, bool is64, std::span<DebugBuilderNote> debugNotes,
+ bool zeroModTimes, bool objectFile)
+ : NListSymbolTable(SymbolPartition(symbols, objectFile), debugNotes, prefLoadAddr, is64, zeroModTimes)
+{}
+
+
+NListSymbolTable::NListSymbolTable(const SymbolPartition& partition, std::span<DebugBuilderNote> debugNotes,
+ uint64_t prefLoadAddr, bool is64, bool zeroModTimes)
+ : NListSymbolTable(partition.globals, partition.undefs, partition.locals, debugNotes, prefLoadAddr, is64, zeroModTimes)
+{}
+
+NListSymbolTable::NListSymbolTable(std::span<const Symbol> globals, std::span<const Symbol> undefs,
+ std::span<const Symbol> locals, std::span<DebugBuilderNote> debugNotes, uint64_t prefLoadAddr, bool is64, bool zeroModTimes)
+{
+ uint32_t numDebugNlist = countDebugNoteNLists(debugNotes);
+ size_t nlistSize = (locals.size() + globals.size() + undefs.size() + numDebugNlist) * (is64 ? sizeof(nlist_64) : sizeof(struct nlist));
+
+ NListStringPoolBuffer stringPoolBuffer;
+
+ size_t strxAllCount = globals.size() * 2 + locals.size() + undefs.size();
+ std::vector<uint32_t> strxAll(strxAllCount);
+ std::span<uint32_t> globalsStrx = std::span(strxAll).subspan(0, globals.size());
+ std::span<uint32_t> reexportsStrx = std::span(globalsStrx.end().base(), globals.size());
+ std::span<uint32_t> undefsStrx = std::span(reexportsStrx.end().base(), undefs.size());
+ std::span<uint32_t> localsStrx = std::span(undefsStrx.end().base(), locals.size());
+ for ( size_t i = 0; i < globals.size(); ++i ) {
+ const Symbol& s = globals[i];
+ globalsStrx[i] = stringPoolBuffer.add(s.name());
+ int32_t ordinal;
+ const char* importName=nullptr;
+ if ( s.isReExport(ordinal, importName) )
+ reexportsStrx[i] = stringPoolBuffer.add(s.name());
+ }
+ for ( size_t i = 0; i < undefs.size(); ++i ) {
+ const Symbol& s = undefs[i];
+ undefsStrx[i] = stringPoolBuffer.add(s.name());
+ }
+ for ( size_t i = 0; i < locals.size(); ++i ) {
+ const Symbol& s = locals[i];
+ localsStrx[i] = stringPoolBuffer.add(s.name());
+ }
+
+ for ( DebugBuilderNote& debugNote : debugNotes ) {
+ if ( CString srcDir = debugNote.fileInfo->srcDir(); !srcDir.empty() )
+ debugNote.srcDirPoolOffset = stringPoolBuffer.add(srcDir);
+ if ( CString srcName = debugNote.fileInfo->srcName(); !srcName.empty() )
+ debugNote.srcNamePoolOffset = stringPoolBuffer.add(srcName);
+ if ( CString originLibPath = debugNote.fileInfo->originLibPath(); !originLibPath.empty() )
+ debugNote.originLibPathPoolOffset=stringPoolBuffer.add(originLibPath);
+ if ( CString objPath = debugNote.fileInfo->objPath(); !objPath.empty() )
+ debugNote.objPathPoolOffset=stringPoolBuffer.add(objPath);
+
+ for ( DebugBuilderNoteItem& item : debugNote.items ) {
+ item.stringPoolOffset=stringPoolBuffer.add(item.name);
+ }
+ }
+ stringPoolBuffer.finalize(is64);
+
+ *this = NListSymbolTable(NListLayout{ globals, globalsStrx, reexportsStrx, undefs, undefsStrx, locals, localsStrx, debugNotes, numDebugNlist }, NListBuffer(nlistSize), std::move(stringPoolBuffer.buffer), prefLoadAddr, is64, zeroModTimes);
+}
+
+NListSymbolTable::NListSymbolTable(NListLayout layout, std::span<uint8_t> nlistBuffer, uint64_t prefLoadAddr, bool is64, bool zeroModTimes): NListSymbolTable(layout, NListBuffer(nlistBuffer), {}, prefLoadAddr, is64, zeroModTimes) {}
+
+NListSymbolTable::NListSymbolTable(NListLayout layout, NListBuffer nlist, std::vector<char> stringPoolBuffer, uint64_t prefLoadAddr, bool is64, bool zeroModTimes)
+ : _nlistBuffer(std::move(nlist)), _stringPoolBuffer(std::move(stringPoolBuffer))
+{
+ // partition symbols into locals, globals, and undefs
+ _localsCount = (uint32_t)layout.locals.size() + layout.debugNotesNListCount;
+ _globalsCount = (uint32_t)layout.globals.size();
+ _undefsCount = (uint32_t)layout.undefs.size();
+ _nlistCount = _localsCount + _globalsCount + _undefsCount;
+
+ assert(layout.globals.size() == layout.globalsStrx.size());
+ assert(layout.globals.size() == layout.reexportStrx.size());
+ assert(layout.undefs.size() == layout.undefsStrx.size());
+ assert(layout.locals.size() == layout.localsStrx.size());
+ std::span<uint8_t> nlistBuffer = _nlistBuffer.buffer;
+
+ // convert each symbol to nlist
+ _preferredLoadAddress = prefLoadAddr;
+ if ( is64 ) {
+ assert(nlistBuffer.size() == (_localsCount + _globalsCount + _undefsCount) * sizeof(nlist_64));
+
+ // symbol table strings are added in the order of globals, imports, locals
+ // but the nlist itself is emitted as locals, globals, imports.
+ // So we'll walk in the string order, and then create the nlist after
+
+ std::span<nlist_64> nlist64Buffer = std::span<nlist_64>((nlist_64*)nlistBuffer.data(), nlistBuffer.size() / sizeof(nlist_64));
+ std::span<nlist_64> globalsBuffer(nlist64Buffer.subspan(_localsCount, _globalsCount));
+ std::span<nlist_64> undefsBuffer(nlist64Buffer.subspan(_localsCount + _globalsCount, _undefsCount));
+ std::span<nlist_64> localsBuffer(nlist64Buffer.subspan(0, _localsCount));
+
+ dispatchForEach(layout.globals, [this, globalsBuffer, &layout](size_t i, const Symbol& sym) {
+ globalsBuffer[i] = nlist64FromSymbol(sym, layout.globalsStrx[i], layout.reexportStrx[i]);
+ });
+ dispatchForEach(layout.undefs, [this, undefsBuffer, &layout](size_t i, const Symbol& sym) {
+ undefsBuffer[i] = nlist64FromSymbol(sym, layout.undefsStrx[i], 0);
+ });
+ dispatchForEach(layout.locals, [this, localsBuffer, &layout](size_t i, const Symbol& sym) {
+ localsBuffer[i] = nlist64FromSymbol(sym, layout.localsStrx[i], 0);
+ });
+
+ NListBuffer stabsBuffer = localsBuffer.subspan(layout.locals.size());
+ assert((stabsBuffer.buffer.size() / sizeof(nlist_64)) == layout.debugNotesNListCount);
+ addStabsFromDebugNotes<nlist_64>(layout.debugNotes, zeroModTimes, stabsBuffer);
+ }
+ else {
+ // symbol table strings are added in the order of globals, imports, locals
+ // but the nlist itself is emitted as locals, globals, imports.
+ // So we'll walk in the string order, and then create the nlist after
+
+ std::span<struct nlist> nlist32Buffer = std::span<struct nlist>((struct nlist*)nlistBuffer.data(), nlistBuffer.size() / sizeof(struct nlist));
+ std::span<struct nlist> globalsBuffer(nlist32Buffer.subspan(_localsCount, _globalsCount));
+ std::span<struct nlist> undefsBuffer(nlist32Buffer.subspan(_localsCount + _globalsCount, _undefsCount));
+ std::span<struct nlist> localsBuffer(nlist32Buffer.subspan(0, _localsCount));
+
+ dispatchForEach(layout.globals, [this, globalsBuffer, &layout](size_t i, const Symbol& sym) {
+ globalsBuffer[i] = nlistFromSymbol(sym, layout.globalsStrx[i], layout.reexportStrx[i]);
+ });
+ dispatchForEach(layout.undefs, [this, undefsBuffer, &layout](size_t i, const Symbol& sym) {
+ undefsBuffer[i] = nlistFromSymbol(sym, layout.undefsStrx[i], 0);
+ });
+ dispatchForEach(layout.locals, [this, localsBuffer, &layout](size_t i, const Symbol& sym) {
+ localsBuffer[i] = nlistFromSymbol(sym, layout.localsStrx[i], 0);
+ });
+
+ NListBuffer stabsBuffer = localsBuffer.subspan(layout.locals.size());
+ assert((stabsBuffer.buffer.size() / sizeof(struct nlist)) == layout.debugNotesNListCount);
+ addStabsFromDebugNotes<struct nlist>(layout.debugNotes, zeroModTimes, stabsBuffer);
+ }
+
+ // fill in all ivars as if this came from a mach-o file
+ _preferredLoadAddress = prefLoadAddr;
+ _stringPool = _stringPoolBuffer.data();
+ _nlist32 = is64 ? nullptr : (struct nlist*)nlistBuffer.data();
+ _nlist64 = is64 ? (nlist_64*)nlistBuffer.data() : nullptr;
+ _stringPoolSize = (uint32_t)_stringPoolBuffer.size();
+}
+
+static uint8_t ntypeFromSymbol(const Symbol& symbol)
+{
+ switch ( symbol.scope() ) {
+ case Symbol::Scope::global:
+ case Symbol::Scope::globalNeverStrip:
+ case Symbol::Scope::autoHide:
+ return N_EXT;
+ case Symbol::Scope::linkageUnit:
+ return N_EXT | N_PEXT;
+ case Symbol::Scope::translationUnit:
+ return 0;
+ case Symbol::Scope::wasLinkageUnit:
+ return N_PEXT;
+ }
+}
+
+struct nlist_64 NListSymbolTable::nlist64FromSymbol(const Symbol& symbol, uint32_t strx, uint32_t reexportStrx)
+{
+ struct nlist_64 result;
+ int libOrdinal;
+ uint64_t absAddress;
+ bool weakImport;
+ uint64_t implOffset;
+ uint64_t size;
+ uint64_t stubOffset;
+ uint8_t p2align;
+ const char* importName;
+ if ( symbol.isTentativeDef(size, p2align) ) {
+ result.n_un.n_strx = strx;
+ result.n_type = N_UNDF | ntypeFromSymbol(symbol);
+ result.n_sect = 0;
+ result.n_desc = 0;
+ result.n_value = size;
+ SET_COMM_ALIGN(result.n_desc,p2align);
+ }
+ else if ( symbol.isUndefined(libOrdinal, weakImport) ) {
+ result.n_un.n_strx = strx;
+ result.n_type = N_UNDF | N_EXT;
+ result.n_sect = 0;
+ result.n_desc = (libOrdinal << 8) | (weakImport ? N_WEAK_REF : 0);
+ result.n_value = 0;
+ }
+ else if ( symbol.isAbsolute(absAddress) ) {
+ result.n_un.n_strx = strx;
+ result.n_type = N_ABS | ntypeFromSymbol(symbol);
+ result.n_sect = 0;
+ result.n_desc = 0;
+ result.n_value = absAddress;
+ }
+ else if ( symbol.isRegular(implOffset) || symbol.isThreadLocal(implOffset) ) {
+ uint16_t desc = 0;
+ if ( symbol.isWeakDef() ) {
+ switch ( symbol.scope() ) {
+ case Symbol::Scope::globalNeverStrip:
+ case Symbol::Scope::global:
+ case Symbol::Scope::linkageUnit:
+ case Symbol::Scope::wasLinkageUnit:
+ desc = N_WEAK_DEF;
+ break;
+ case Symbol::Scope::autoHide:
+ desc = N_WEAK_DEF | N_WEAK_REF;
+ break;
+ case Symbol::Scope::translationUnit:
+ break;
+ }
+ }
+ if ( symbol.dontDeadStrip() )
+ desc |= N_NO_DEAD_STRIP;
+ if ( symbol.cold() )
+ desc |= N_COLD_FUNC;
+ if ( symbol.scope() == Symbol::Scope::globalNeverStrip )
+ desc |= REFERENCED_DYNAMICALLY;
+ result.n_un.n_strx = strx;
+ result.n_type = N_SECT | ntypeFromSymbol(symbol);
+ result.n_sect = symbol.sectionOrdinal();
+ result.n_desc = desc;
+ result.n_value = _preferredLoadAddress + implOffset;
+ }
+ else if ( symbol.isAltEntry(implOffset) ) {
+ uint64_t desc = N_ALT_ENTRY;
+ if ( symbol.dontDeadStrip() )
+ desc |= N_NO_DEAD_STRIP;
+ result.n_un.n_strx = strx;
+ result.n_type = N_SECT | ntypeFromSymbol(symbol);
+ result.n_sect = symbol.sectionOrdinal();
+ result.n_desc = desc;
+ result.n_value = _preferredLoadAddress + implOffset;
+ }
+ else if ( symbol.isReExport(libOrdinal, importName) ) {
+ // re-exports can't be local, they're always global in linked images,
+ // in object files they can have global/linkage unit scope or be undefined.
+ assert(symbol.scope() != Symbol::Scope::translationUnit && "re-exports can't have a translation unit");
+ result.n_un.n_strx = strx;
+ result.n_type = N_INDR | ntypeFromSymbol(symbol);
+ result.n_sect = 0;
+ result.n_desc = 0;
+ result.n_value = reexportStrx;
+ }
+ else if ( symbol.isDynamicResolver(stubOffset) ) {
+ result.n_un.n_strx = strx;
+ result.n_type = N_SECT | ntypeFromSymbol(symbol);
+ result.n_sect = symbol.sectionOrdinal();
+ result.n_desc = N_SYMBOL_RESOLVER;
+ result.n_value = _preferredLoadAddress + symbol.implOffset();
+ }
+ else {
+ assert(false && "unhandled symbol kind");
+ }
+
+ return result;
+}
+
+// avoid duplicating code by filling in nlist_64 and converting to nlist
+struct nlist NListSymbolTable::nlistFromSymbol(const Symbol& symbol, uint32_t strx, uint32_t reexportStrx)
+{
+ struct nlist_64 result64 = nlist64FromSymbol(symbol, strx, reexportStrx);
+ struct nlist result;
+ result.n_un.n_strx = result64.n_un.n_strx;
+ result.n_type = result64.n_type;
+ result.n_sect = result64.n_sect;
+ result.n_desc = result64.n_desc;
+ result.n_value = (uint32_t)result64.n_value;
+ return result;
+}
+
+std::pair<uint32_t, char*> NListStringPoolBuffer::reserve(size_t size)
+{
+ size_t startPos = pos;
+ pos += size;
+ buffer.resize(buffer.size() + size);
+ return std::make_pair(startPos, buffer.data() + startPos);
+}
+
+uint32_t NListStringPoolBuffer::add(std::span<const char> bytes)
+{
+ auto [startPos, ptr] = reserve(bytes.size());
+ memcpy(ptr, bytes.data(), bytes.size());
+ return startPos;
+}
+
+uint32_t NListStringPoolBuffer::add(char ch)
+{
+ auto [startPos, ptr] = reserve(1);
+ *ptr = ch;
+ return startPos;
+}
+
+uint32_t NListStringPoolBuffer::add(CString cstr)
+{
+ return add(std::span(cstr.c_str(), cstr.size() + 1));
+}
+
+
+#endif // BUILDING_MACHO_WRITER
+
const DebugNoteFileInfo* DebugNoteFileInfo::make(CString srcDir, CString srcName, CString objPath, uint32_t objModTime, uint8_t objSubType, CString libPath, CString originLibPath)
{
- DebugNoteFileInfo* result = (DebugNoteFileInfo*)calloc(1, sizeof(DebugNoteFileInfo));
+ const size_t srcDirOffset = sizeof(DebugNoteFileInfo);
+ const size_t srcNameOffset = srcDirOffset + srcDir.size() + 1;
+ const size_t objPathOffset = srcNameOffset + srcName.size() + 1;
+ size_t lastOffset = objPathOffset + objPath.size() + 1;
+ const size_t libPathOffset = libPath.size() > 0 ? lastOffset : 0;
+ lastOffset = libPathOffset > 0 ? libPathOffset : lastOffset;
+ const size_t originLibPathOffset = originLibPath.size() > 0 ? lastOffset + libPath.size() + 1 : 0;
+ lastOffset = originLibPathOffset > 0 ? originLibPathOffset : lastOffset + libPath.size() + 1;
+ // Update finalOffset if there is dynamic library information
+ const size_t finalOffset = originLibPathOffset > 0 ? lastOffset + originLibPath.size() + 1 : lastOffset;
+ const size_t contentSize = (finalOffset + 7) & (-8); // 8-byte align
+
+ DebugNoteFileInfo* result = (DebugNoteFileInfo*)calloc(contentSize, sizeof(uint8_t));
+ result->_size = (uint32_t)contentSize;
+ result->_version = 1;
+ result->_srcDirOffset = srcDirOffset;
+ result->_srcDirSize = (uint32_t)srcDir.size();
+ result->_srcNameOffset = (uint32_t)srcNameOffset;
+ result->_srcNameSize = (uint32_t)srcName.size();
+ result->_objPathOffset = (uint32_t)objPathOffset;
+ result->_objPathSize = (uint32_t)objPath.size();
result->_objModTime = objModTime;
result->_objSubType = objSubType;
- result->_srcDir = srcDir;
- result->_srcName = srcName;
- result->_objPath = objPath;
- result->_libPath = libPath;
- result->_originLibPath = originLibPath;
+ result->_libPathOffset = (uint32_t)libPathOffset;
+ result->_libPathSize = (uint32_t)libPath.size();
+ result->_originLibPathOffset = (uint32_t)originLibPathOffset;
+ result->_originLibPathSize = (uint32_t)originLibPath.size();
+
+ if ( srcDir.size() )
+ memcpy((char*)result + srcDirOffset, srcDir.c_str(), srcDir.size());
+ if ( srcName.size() )
+ memcpy((char*)result + srcNameOffset, srcName.c_str(), srcName.size());
+ if ( objPath.size() )
+ memcpy((char*)result + objPathOffset, objPath.c_str(), objPath.size());
+ if ( libPath.size() )
+ memcpy((char*)result + libPathOffset, libPath.c_str(), libPath.size());
+ if ( originLibPath.size() )
+ memcpy((char*)result + originLibPathOffset, originLibPath.c_str(), originLibPath.size());
return result;
}
@@ -445,7 +874,9 @@
const DebugNoteFileInfo* DebugNoteFileInfo::copy() const
{
- return DebugNoteFileInfo::make(_srcDir, _srcName, _objPath, _objModTime, _objSubType, _libPath, _originLibPath);
+ DebugNoteFileInfo* result = (DebugNoteFileInfo*)malloc(_size);
+ memcpy(result, this, _size);
+ return result;
}
bool DebugNoteFileInfo::shouldbeUpdated(CString libPath) const
{
@@ -462,6 +893,7 @@
__attribute__((used))
void DebugNoteFileInfo::dump() const
{
+ fprintf(stdout, "size: %u\n", this->_size);
fprintf(stdout, "scrDir: %s\n", srcDir().c_str());
fprintf(stdout, "scrName: %s\n", srcName().c_str());
fprintf(stdout, "objPath: %s\n", objPath().c_str());