From 1eb189b4b2a99fc0b03f4d8df9f469c3ef7ad4f5 Mon Sep 17 00:00:00 2001 From: Eli Bendersky Date: Fri, 6 Jan 2012 07:49:17 +0000 Subject: Fix typo in string git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@147654 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index f5a68c8..36235f1 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -451,7 +451,7 @@ bool RuntimeDyldMachO::loadObject(MemoryBuffer *InputBuffer) { if (!SymtabLCI) return Error("no symbol table found in object"); if (!SegmentLCI) - return Error("no symbol table found in object"); + return Error("no segments found in object"); // Read and register the symbol table data. InMemoryStruct SymtabLC; -- cgit v1.1 From 61425c0a7f4e3608a85f7bbf254cd052a15b7446 Mon Sep 17 00:00:00 2001 From: Jim Grosbach Date: Mon, 16 Jan 2012 22:26:39 +0000 Subject: MCJIT support for non-function sections. Move to a by-section allocation and relocation scheme. This allows better support for sections which do not contain externally visible symbols. Flesh out the relocation address vs. local storage address separation a bit more as well. Remote process JITs use this to tell the relocation resolution code where the code will live when it executes. The startFunctionBody/endFunctionBody interfaces to the JIT and the memory manager are deprecated. They'll stick around for as long as the old JIT does, but the MCJIT doesn't use them anymore. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@148258 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../RuntimeDyld/RuntimeDyldMachO.cpp | 494 ++++++++++++--------- 1 file changed, 281 insertions(+), 213 deletions(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 36235f1..81b2d17 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -22,25 +22,24 @@ using namespace llvm::object; namespace llvm { bool RuntimeDyldMachO:: -resolveRelocation(uint8_t *Address, uint8_t *Value, bool isPCRel, - unsigned Type, unsigned Size) { +resolveRelocation(uint8_t *Address, uint64_t Value, bool isPCRel, + unsigned Type, unsigned Size, int64_t Addend) { // This just dispatches to the proper target specific routine. switch (CPUType) { default: assert(0 && "Unsupported CPU type!"); case mach::CTM_x86_64: return resolveX86_64Relocation((uintptr_t)Address, (uintptr_t)Value, - isPCRel, Type, Size); + isPCRel, Type, Size, Addend); case mach::CTM_ARM: return resolveARMRelocation((uintptr_t)Address, (uintptr_t)Value, - isPCRel, Type, Size); + isPCRel, Type, Size, Addend); } llvm_unreachable(""); } bool RuntimeDyldMachO:: -resolveX86_64Relocation(uintptr_t Address, uintptr_t Value, - bool isPCRel, unsigned Type, - unsigned Size) { +resolveX86_64Relocation(uintptr_t Address, uintptr_t Value, bool isPCRel, + unsigned Type, unsigned Size, int64_t Addend) { // If the relocation is PC-relative, the value to be encoded is the // pointer difference. if (isPCRel) @@ -75,9 +74,9 @@ resolveX86_64Relocation(uintptr_t Address, uintptr_t Value, return false; } -bool RuntimeDyldMachO::resolveARMRelocation(uintptr_t Address, uintptr_t Value, - bool isPCRel, unsigned Type, - unsigned Size) { +bool RuntimeDyldMachO:: +resolveARMRelocation(uintptr_t Address, uintptr_t Value, bool isPCRel, + unsigned Type, unsigned Size, int64_t Addend) { // If the relocation is PC-relative, the value to be encoded is the // pointer difference. if (isPCRel) { @@ -135,84 +134,63 @@ bool RuntimeDyldMachO:: loadSegment32(const MachOObject *Obj, const MachOObject::LoadCommandInfo *SegmentLCI, const InMemoryStruct &SymtabLC) { + // FIXME: This should really be combined w/ loadSegment64. Templatized + // function on the 32/64 datatypes maybe? InMemoryStruct SegmentLC; Obj->ReadSegmentLoadCommand(*SegmentLCI, SegmentLC); if (!SegmentLC) return Error("unable to load segment load command"); + + SmallVector SectionMap; for (unsigned SectNum = 0; SectNum != SegmentLC->NumSections; ++SectNum) { InMemoryStruct Sect; Obj->ReadSection(*SegmentLCI, SectNum, Sect); if (!Sect) return Error("unable to load section: '" + Twine(SectNum) + "'"); - // FIXME: For the time being, we're only loading text segments. + // Allocate memory via the MM for the section. + uint8_t *Buffer; + uint32_t SectionID = Sections.size(); if (Sect->Flags != 0x80000400) - continue; + Buffer = MemMgr->allocateCodeSection(Sect->Size, Sect->Align, SectionID); + else + Buffer = MemMgr->allocateDataSection(Sect->Size, Sect->Align, SectionID); + + DEBUG(dbgs() << "Loading " + << ((Sect->Flags == 0x80000400) ? "text" : "data") + << " (ID #" << SectionID << ")" + << " '" << Sect->SegmentName << "," + << Sect->Name << "' of size " << Sect->Size + << " to address " << Buffer << ".\n"); + + // Copy the payload from the object file into the allocated buffer. + uint8_t *Base = (uint8_t*)Obj->getData(SegmentLC->FileOffset, + SegmentLC->FileSize).data(); + memcpy(Buffer, Base + Sect->Address, Sect->Size); - // Address and names of symbols in the section. - typedef std::pair SymbolEntry; - SmallVector Symbols; - // Index of all the names, in this section or not. Used when we're - // dealing with relocation entries. - SmallVector SymbolNames; - for (unsigned i = 0; i != SymtabLC->NumSymbolTableEntries; ++i) { - InMemoryStruct STE; - Obj->ReadSymbolTableEntry(SymtabLC->SymbolTableOffset, i, STE); - if (!STE) - return Error("unable to read symbol: '" + Twine(i) + "'"); - if (STE->SectionIndex > SegmentLC->NumSections) - return Error("invalid section index for symbol: '" + Twine(i) + "'"); - // Get the symbol name. - StringRef Name = Obj->getStringAtIndex(STE->StringIndex); - SymbolNames.push_back(Name); - - // Just skip symbols not defined in this section. - if ((unsigned)STE->SectionIndex - 1 != SectNum) - continue; - - // FIXME: Check the symbol type and flags. - if (STE->Type != 0xF) // external, defined in this section. - continue; - // Flags == 0x8 marks a thumb function for ARM, which is fine as it - // doesn't require any special handling here. - // Flags in the upper nibble we don't care about. - if ((STE->Flags & 0xf) != 0x0 && STE->Flags != 0x8) - continue; - - // Remember the symbol. - Symbols.push_back(SymbolEntry(STE->Value, Name)); - - DEBUG(dbgs() << "Function sym: '" << Name << "' @ " << - (Sect->Address + STE->Value) << "\n"); - } - // Sort the symbols by address, just in case they didn't come in that way. - array_pod_sort(Symbols.begin(), Symbols.end()); + // Remember what got allocated for this SectionID. + Sections.push_back(sys::MemoryBlock(Buffer, Sect->Size)); - // If there weren't any functions (odd, but just in case...) - if (!Symbols.size()) - continue; + // By default, the load address of a section is its memory buffer. + SectionLoadAddress.push_back((uint64_t)Buffer); - // Extract the function data. - uint8_t *Base = (uint8_t*)Obj->getData(SegmentLC->FileOffset, - SegmentLC->FileSize).data(); - for (unsigned i = 0, e = Symbols.size() - 1; i != e; ++i) { - uint64_t StartOffset = Sect->Address + Symbols[i].first; - uint64_t EndOffset = Symbols[i + 1].first - 1; - DEBUG(dbgs() << "Extracting function: " << Symbols[i].second - << " from [" << StartOffset << ", " << EndOffset << "]\n"); - extractFunction(Symbols[i].second, Base + StartOffset, Base + EndOffset); - } - // The last symbol we do after since the end address is calculated - // differently because there is no next symbol to reference. - uint64_t StartOffset = Symbols[Symbols.size() - 1].first; - uint64_t EndOffset = Sect->Size - 1; - DEBUG(dbgs() << "Extracting function: " << Symbols[Symbols.size()-1].second - << " from [" << StartOffset << ", " << EndOffset << "]\n"); - extractFunction(Symbols[Symbols.size()-1].second, - Base + StartOffset, Base + EndOffset); - - // Now extract the relocation information for each function and process it. + // Keep a map of object file section numbers to corresponding SectionIDs + // while processing the file. + SectionMap.push_back(SectionID); + } + + // Process the symbol table. + SmallVector SymbolNames; + processSymbols32(Obj, SectionMap, SymbolNames, SymtabLC); + + // Process the relocations for each section we're loading. + Relocations.grow(Relocations.size() + SegmentLC->NumSections); + for (unsigned SectNum = 0; SectNum != SegmentLC->NumSections; ++SectNum) { + InMemoryStruct Sect; + Obj->ReadSection(*SegmentLCI, SectNum, Sect); + if (!Sect) + return Error("unable to load section: '" + Twine(SectNum) + "'"); for (unsigned j = 0; j != Sect->NumRelocationTableEntries; ++j) { InMemoryStruct RE; Obj->ReadRelocationEntry(Sect->RelocationTableOffset, j, RE); @@ -222,51 +200,53 @@ loadSegment32(const MachOObject *Obj, // relocation should be applied. We need to translate that into an // offset into a function since that's our atom. uint32_t Offset = RE->Word0; - // Look for the function containing the address. This is used for JIT - // code, so the number of functions in section is almost always going - // to be very small (usually just one), so until we have use cases - // where that's not true, just use a trivial linear search. - unsigned SymbolNum; - unsigned NumSymbols = Symbols.size(); - assert(NumSymbols > 0 && Symbols[0].first <= Offset && - "No symbol containing relocation!"); - for (SymbolNum = 0; SymbolNum < NumSymbols - 1; ++SymbolNum) - if (Symbols[SymbolNum + 1].first > Offset) - break; - // Adjust the offset to be relative to the symbol. - Offset -= Symbols[SymbolNum].first; - // Get the name of the symbol containing the relocation. - StringRef TargetName = SymbolNames[SymbolNum]; - bool isExtern = (RE->Word1 >> 27) & 1; + + // FIXME: Get the relocation addend from the target address. + // FIXME: VERY imporant for internal relocations. + // Figure out the source symbol of the relocation. If isExtern is true, // this relocation references the symbol table, otherwise it references // a section in the same object, numbered from 1 through NumSections // (SectionBases is [0, NumSections-1]). - // FIXME: Some targets (ARM) use internal relocations even for - // externally visible symbols, if the definition is in the same - // file as the reference. We need to convert those back to by-name - // references. We can resolve the address based on the section - // offset and see if we have a symbol at that address. If we do, - // use that; otherwise, puke. - if (!isExtern) - return Error("Internal relocations not supported."); uint32_t SourceNum = RE->Word1 & 0xffffff; // 24-bit value - StringRef SourceName = SymbolNames[SourceNum]; - - // FIXME: Get the relocation addend from the target address. - - // Now store the relocation information. Associate it with the source - // symbol. - Relocations[SourceName].push_back(RelocationEntry(TargetName, - Offset, - RE->Word1, - 0 /*Addend*/)); - DEBUG(dbgs() << "Relocation at '" << TargetName << "' + " << Offset - << " from '" << SourceName << "(Word1: " - << format("0x%x", RE->Word1) << ")\n"); + if (!isExtern) { + assert(SourceNum > 0 && "Invalid relocation section number!"); + unsigned SectionID = SectionMap[SourceNum - 1]; + unsigned TargetID = SectionMap[SectNum]; + DEBUG(dbgs() << "Internal relocation at Section #" + << TargetID << " + " << Offset + << " from Section #" + << SectionID << " (Word1: " + << format("0x%x", RE->Word1) << ")\n"); + + // Store the relocation information. It will get resolved when + // the section addresses are assigned. + Relocations[SectionID].push_back(RelocationEntry(TargetID, + Offset, + RE->Word1, + 0 /*Addend*/)); + } else { + StringRef SourceName = SymbolNames[SourceNum]; + + // Now store the relocation information. Associate it with the source + // symbol. Just add it to the unresolved list and let the general + // path post-load resolve it if we know where the symbol is. + UnresolvedRelocations[SourceName].push_back(RelocationEntry(SectNum, + Offset, + RE->Word1, + 0 /*Addend*/)); + DEBUG(dbgs() << "Relocation at Section #" << SectNum << " + " << Offset + << " from '" << SourceName << "(Word1: " + << format("0x%x", RE->Word1) << ")\n"); + } } } + + // Resolve the addresses of any symbols that were defined in this segment. + for (int i = 0, e = SymbolNames.size(); i != e; ++i) + resolveSymbol(SymbolNames[i]); + return false; } @@ -280,77 +260,56 @@ loadSegment64(const MachOObject *Obj, if (!Segment64LC) return Error("unable to load segment load command"); + + SmallVector SectionMap; for (unsigned SectNum = 0; SectNum != Segment64LC->NumSections; ++SectNum) { InMemoryStruct Sect; Obj->ReadSection64(*SegmentLCI, SectNum, Sect); if (!Sect) return Error("unable to load section: '" + Twine(SectNum) + "'"); - // FIXME: For the time being, we're only loading text segments. + // Allocate memory via the MM for the section. + uint8_t *Buffer; + uint32_t SectionID = Sections.size(); if (Sect->Flags != 0x80000400) - continue; + Buffer = MemMgr->allocateCodeSection(Sect->Size, Sect->Align, SectionID); + else + Buffer = MemMgr->allocateDataSection(Sect->Size, Sect->Align, SectionID); + + DEBUG(dbgs() << "Loading " + << ((Sect->Flags == 0x80000400) ? "text" : "data") + << " (ID #" << SectionID << ")" + << " '" << Sect->SegmentName << "," + << Sect->Name << "' of size " << Sect->Size + << " to address " << Buffer << ".\n"); + + // Copy the payload from the object file into the allocated buffer. + uint8_t *Base = (uint8_t*)Obj->getData(Segment64LC->FileOffset, + Segment64LC->FileSize).data(); + memcpy(Buffer, Base + Sect->Address, Sect->Size); - // Address and names of symbols in the section. - typedef std::pair SymbolEntry; - SmallVector Symbols; - // Index of all the names, in this section or not. Used when we're - // dealing with relocation entries. - SmallVector SymbolNames; - for (unsigned i = 0; i != SymtabLC->NumSymbolTableEntries; ++i) { - InMemoryStruct STE; - Obj->ReadSymbol64TableEntry(SymtabLC->SymbolTableOffset, i, STE); - if (!STE) - return Error("unable to read symbol: '" + Twine(i) + "'"); - if (STE->SectionIndex > Segment64LC->NumSections) - return Error("invalid section index for symbol: '" + Twine(i) + "'"); - // Get the symbol name. - StringRef Name = Obj->getStringAtIndex(STE->StringIndex); - SymbolNames.push_back(Name); - - // Just skip symbols not defined in this section. - if ((unsigned)STE->SectionIndex - 1 != SectNum) - continue; - - // FIXME: Check the symbol type and flags. - if (STE->Type != 0xF) // external, defined in this section. - continue; - // Flags in the upper nibble we don't care about. - if ((STE->Flags & 0xf) != 0x0) - continue; - - // Remember the symbol. - Symbols.push_back(SymbolEntry(STE->Value, Name)); - - DEBUG(dbgs() << "Function sym: '" << Name << "' @ " << - (Sect->Address + STE->Value) << "\n"); - } - // Sort the symbols by address, just in case they didn't come in that way. - array_pod_sort(Symbols.begin(), Symbols.end()); + // Remember what got allocated for this SectionID. + Sections.push_back(sys::MemoryBlock(Buffer, Sect->Size)); - // If there weren't any functions (odd, but just in case...) - if (!Symbols.size()) - continue; + // By default, the load address of a section is its memory buffer. + SectionLoadAddress.push_back((uint64_t)Buffer); - // Extract the function data. - uint8_t *Base = (uint8_t*)Obj->getData(Segment64LC->FileOffset, - Segment64LC->FileSize).data(); - for (unsigned i = 0, e = Symbols.size() - 1; i != e; ++i) { - uint64_t StartOffset = Sect->Address + Symbols[i].first; - uint64_t EndOffset = Symbols[i + 1].first - 1; - DEBUG(dbgs() << "Extracting function: " << Symbols[i].second - << " from [" << StartOffset << ", " << EndOffset << "]\n"); - extractFunction(Symbols[i].second, Base + StartOffset, Base + EndOffset); - } - // The last symbol we do after since the end address is calculated - // differently because there is no next symbol to reference. - uint64_t StartOffset = Symbols[Symbols.size() - 1].first; - uint64_t EndOffset = Sect->Size - 1; - DEBUG(dbgs() << "Extracting function: " << Symbols[Symbols.size()-1].second - << " from [" << StartOffset << ", " << EndOffset << "]\n"); - extractFunction(Symbols[Symbols.size()-1].second, - Base + StartOffset, Base + EndOffset); - - // Now extract the relocation information for each function and process it. + // Keep a map of object file section numbers to corresponding SectionIDs + // while processing the file. + SectionMap.push_back(SectionID); + } + + // Process the symbol table. + SmallVector SymbolNames; + processSymbols64(Obj, SectionMap, SymbolNames, SymtabLC); + + // Process the relocations for each section we're loading. + Relocations.grow(Relocations.size() + Segment64LC->NumSections); + for (unsigned SectNum = 0; SectNum != Segment64LC->NumSections; ++SectNum) { + InMemoryStruct Sect; + Obj->ReadSection64(*SegmentLCI, SectNum, Sect); + if (!Sect) + return Error("unable to load section: '" + Twine(SectNum) + "'"); for (unsigned j = 0; j != Sect->NumRelocationTableEntries; ++j) { InMemoryStruct RE; Obj->ReadRelocationEntry(Sect->RelocationTableOffset, j, RE); @@ -360,48 +319,142 @@ loadSegment64(const MachOObject *Obj, // relocation should be applied. We need to translate that into an // offset into a function since that's our atom. uint32_t Offset = RE->Word0; - // Look for the function containing the address. This is used for JIT - // code, so the number of functions in section is almost always going - // to be very small (usually just one), so until we have use cases - // where that's not true, just use a trivial linear search. - unsigned SymbolNum; - unsigned NumSymbols = Symbols.size(); - assert(NumSymbols > 0 && Symbols[0].first <= Offset && - "No symbol containing relocation!"); - for (SymbolNum = 0; SymbolNum < NumSymbols - 1; ++SymbolNum) - if (Symbols[SymbolNum + 1].first > Offset) - break; - // Adjust the offset to be relative to the symbol. - Offset -= Symbols[SymbolNum].first; - // Get the name of the symbol containing the relocation. - StringRef TargetName = SymbolNames[SymbolNum]; - bool isExtern = (RE->Word1 >> 27) & 1; + + // FIXME: Get the relocation addend from the target address. + // FIXME: VERY imporant for internal relocations. + // Figure out the source symbol of the relocation. If isExtern is true, // this relocation references the symbol table, otherwise it references // a section in the same object, numbered from 1 through NumSections // (SectionBases is [0, NumSections-1]). - if (!isExtern) - return Error("Internal relocations not supported."); uint32_t SourceNum = RE->Word1 & 0xffffff; // 24-bit value - StringRef SourceName = SymbolNames[SourceNum]; + if (!isExtern) { + assert(SourceNum > 0 && "Invalid relocation section number!"); + unsigned SectionID = SectionMap[SourceNum - 1]; + unsigned TargetID = SectionMap[SectNum]; + DEBUG(dbgs() << "Internal relocation at Section #" + << TargetID << " + " << Offset + << " from Section #" + << SectionID << " (Word1: " + << format("0x%x", RE->Word1) << ")\n"); + + // Store the relocation information. It will get resolved when + // the section addresses are assigned. + Relocations[SectionID].push_back(RelocationEntry(TargetID, + Offset, + RE->Word1, + 0 /*Addend*/)); + } else { + StringRef SourceName = SymbolNames[SourceNum]; + + // Now store the relocation information. Associate it with the source + // symbol. Just add it to the unresolved list and let the general + // path post-load resolve it if we know where the symbol is. + UnresolvedRelocations[SourceName].push_back(RelocationEntry(SectNum, + Offset, + RE->Word1, + 0 /*Addend*/)); + DEBUG(dbgs() << "Relocation at Section #" << SectNum << " + " << Offset + << " from '" << SourceName << "(Word1: " + << format("0x%x", RE->Word1) << ")\n"); + } + } + } - // FIXME: Get the relocation addend from the target address. + // Resolve the addresses of any symbols that were defined in this segment. + for (int i = 0, e = SymbolNames.size(); i != e; ++i) + resolveSymbol(SymbolNames[i]); - // Now store the relocation information. Associate it with the source - // symbol. - Relocations[SourceName].push_back(RelocationEntry(TargetName, - Offset, - RE->Word1, - 0 /*Addend*/)); - DEBUG(dbgs() << "Relocation at '" << TargetName << "' + " << Offset - << " from '" << SourceName << "(Word1: " - << format("0x%x", RE->Word1) << ")\n"); - } + return false; +} + +bool RuntimeDyldMachO:: +processSymbols32(const MachOObject *Obj, + SmallVectorImpl &SectionMap, + SmallVectorImpl &SymbolNames, + const InMemoryStruct &SymtabLC) { + // FIXME: Combine w/ processSymbols64. Factor 64/32 datatype and such. + for (unsigned i = 0; i != SymtabLC->NumSymbolTableEntries; ++i) { + InMemoryStruct STE; + Obj->ReadSymbolTableEntry(SymtabLC->SymbolTableOffset, i, STE); + if (!STE) + return Error("unable to read symbol: '" + Twine(i) + "'"); + // Get the symbol name. + StringRef Name = Obj->getStringAtIndex(STE->StringIndex); + SymbolNames.push_back(Name); + + // FIXME: Check the symbol type and flags. + if (STE->Type != 0xF) // external, defined in this segment. + continue; + // Flags in the upper nibble we don't care about. + if ((STE->Flags & 0xf) != 0x0) + continue; + + // Remember the symbol. + uint32_t SectionID = SectionMap[STE->SectionIndex - 1]; + SymbolTable[Name] = SymbolLoc(SectionID, STE->Value); + + DEBUG(dbgs() << "Symbol: '" << Name << "' @ " + << (getSectionAddress(SectionID) + STE->Value) + << "\n"); + } + return false; +} + +bool RuntimeDyldMachO:: +processSymbols64(const MachOObject *Obj, + SmallVectorImpl &SectionMap, + SmallVectorImpl &SymbolNames, + const InMemoryStruct &SymtabLC) { + for (unsigned i = 0; i != SymtabLC->NumSymbolTableEntries; ++i) { + InMemoryStruct STE; + Obj->ReadSymbol64TableEntry(SymtabLC->SymbolTableOffset, i, STE); + if (!STE) + return Error("unable to read symbol: '" + Twine(i) + "'"); + // Get the symbol name. + StringRef Name = Obj->getStringAtIndex(STE->StringIndex); + SymbolNames.push_back(Name); + + // FIXME: Check the symbol type and flags. + if (STE->Type != 0xF) // external, defined in this segment. + continue; + // Flags in the upper nibble we don't care about. + if ((STE->Flags & 0xf) != 0x0) + continue; + + // Remember the symbol. + uint32_t SectionID = SectionMap[STE->SectionIndex - 1]; + SymbolTable[Name] = SymbolLoc(SectionID, STE->Value); + + DEBUG(dbgs() << "Symbol: '" << Name << "' @ " + << (getSectionAddress(SectionID) + STE->Value) + << "\n"); } return false; } +// resolveSymbol - Resolve any relocations to the specified symbol if +// we know where it lives. +void RuntimeDyldMachO::resolveSymbol(StringRef Name) { + StringMap::const_iterator Loc = SymbolTable.find(Name); + if (Loc == SymbolTable.end()) + return; + + RelocationList &Relocs = UnresolvedRelocations[Name]; + DEBUG(dbgs() << "Resolving symbol '" << Name << "'\n"); + for (int i = 0, e = Relocs.size(); i != e; ++i) { + // Change the relocation to be section relative rather than symbol + // relative and move it to the resolved relocation list. + RelocationEntry Entry = Relocs[i]; + Entry.Addend += Loc->second.second; + Relocations[Loc->second.first].push_back(Entry); + } + // FIXME: Keep a worklist of the relocations we've added so that we can + // resolve more selectively later. + Relocs.clear(); +} + bool RuntimeDyldMachO::loadObject(MemoryBuffer *InputBuffer) { // If the linker is in an error state, don't do anything. if (hasError()) @@ -486,31 +539,46 @@ bool RuntimeDyldMachO::loadObject(MemoryBuffer *InputBuffer) { return true; } + // Assign the addresses of the sections from the object so that any + // relocations to them get set properly. + // FIXME: This is done directly from the client at the moment. We should + // default the values to the local storage, at least when the target arch + // is the same as the host arch. + return false; } // Assign an address to a symbol name and resolve all the relocations // associated with it. -void RuntimeDyldMachO::reassignSymbolAddress(StringRef Name, uint8_t *Addr) { - // Assign the address in our symbol table. - SymbolTable[Name] = Addr; - - RelocationList &Relocs = Relocations[Name]; +void RuntimeDyldMachO::reassignSectionAddress(unsigned SectionID, + uint64_t Addr) { + // The address to use for relocation resolution is not + // the address of the local section buffer. We must be doing + // a remote execution environment of some sort. Re-apply any + // relocations referencing this section with the given address. + // + // Addr is a uint64_t because we can't assume the pointer width + // of the target is the same as that of the host. Just use a generic + // "big enough" type. + + SectionLoadAddress[SectionID] = Addr; + + RelocationList &Relocs = Relocations[SectionID]; for (unsigned i = 0, e = Relocs.size(); i != e; ++i) { RelocationEntry &RE = Relocs[i]; - uint8_t *Target = SymbolTable[RE.Target] + RE.Offset; + uint8_t *Target = (uint8_t*)Sections[RE.SectionID].base() + RE.Offset; bool isPCRel = (RE.Data >> 24) & 1; unsigned Type = (RE.Data >> 28) & 0xf; unsigned Size = 1 << ((RE.Data >> 25) & 3); - DEBUG(dbgs() << "Resolving relocation at '" << RE.Target - << "' + " << RE.Offset << " (" << format("%p", Target) << ")" - << " from '" << Name << " (" << format("%p", Addr) << ")" + DEBUG(dbgs() << "Resolving relocation at Section #" << RE.SectionID + << " + " << RE.Offset << " (" << format("%p", Target) << ")" + << " from Section #" << SectionID << " (" << format("%p", Addr) << ")" << "(" << (isPCRel ? "pcrel" : "absolute") - << ", type: " << Type << ", Size: " << Size << ").\n"); + << ", type: " << Type << ", Size: " << Size << ", Addend: " + << RE.Addend << ").\n"); - resolveRelocation(Target, Addr, isPCRel, Type, Size); - RE.isResolved = true; + resolveRelocation(Target, Addr, isPCRel, Type, Size, RE.Addend); } } -- cgit v1.1 From 652ca2fe0c8bd406222d064937adc28b281d7b89 Mon Sep 17 00:00:00 2001 From: Jim Grosbach Date: Mon, 16 Jan 2012 23:50:49 +0000 Subject: MCJIT handle a few more simple x86 relocations for MachO. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@148263 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 81b2d17..a3b4919 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -50,8 +50,13 @@ resolveX86_64Relocation(uintptr_t Address, uintptr_t Value, bool isPCRel, switch(Type) { default: llvm_unreachable("Invalid relocation type!"); + case macho::RIT_X86_64_Signed1: + case macho::RIT_X86_64_Signed2: + case macho::RIT_X86_64_Signed4: + case macho::RIT_X86_64_Signed: case macho::RIT_X86_64_Unsigned: case macho::RIT_X86_64_Branch: { + Value += Addend; // Mask in the target value a byte at a time (we don't have an alignment // guarantee for the target address, so this is safest). uint8_t *p = (uint8_t*)Address; @@ -61,13 +66,9 @@ resolveX86_64Relocation(uintptr_t Address, uintptr_t Value, bool isPCRel, } return false; } - case macho::RIT_X86_64_Signed: case macho::RIT_X86_64_GOTLoad: case macho::RIT_X86_64_GOT: case macho::RIT_X86_64_Subtractor: - case macho::RIT_X86_64_Signed1: - case macho::RIT_X86_64_Signed2: - case macho::RIT_X86_64_Signed4: case macho::RIT_X86_64_TLV: return Error("Relocation type not implemented yet!"); } -- cgit v1.1 From 020f4e861a9a32059f76377e787703c92ba55a98 Mon Sep 17 00:00:00 2001 From: Jim Grosbach Date: Mon, 16 Jan 2012 23:50:55 +0000 Subject: ExecutionEngine interface to re-map addresses for engines that support it. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@148264 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 2 ++ 1 file changed, 2 insertions(+) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index a3b4919..1cc021a 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -172,6 +172,7 @@ loadSegment32(const MachOObject *Obj, // Remember what got allocated for this SectionID. Sections.push_back(sys::MemoryBlock(Buffer, Sect->Size)); + SectionLocalMemToID[Buffer] = SectionID; // By default, the load address of a section is its memory buffer. SectionLoadAddress.push_back((uint64_t)Buffer); @@ -291,6 +292,7 @@ loadSegment64(const MachOObject *Obj, // Remember what got allocated for this SectionID. Sections.push_back(sys::MemoryBlock(Buffer, Sect->Size)); + SectionLocalMemToID[Buffer] = SectionID; // By default, the load address of a section is its memory buffer. SectionLoadAddress.push_back((uint64_t)Buffer); -- cgit v1.1 From e0934bee3a4f40731169bc42b15a39ce39978175 Mon Sep 17 00:00:00 2001 From: Jim Grosbach Date: Mon, 16 Jan 2012 23:50:58 +0000 Subject: Tidy up. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@148265 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 1cc021a..32cf2a8 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -1,4 +1,4 @@ -//===-- RuntimeDyldMachO.cpp - Run-time dynamic linker for MC-JIT ------*- C++ -*-===// +//===-- RuntimeDyldMachO.cpp - Run-time dynamic linker for MC-JIT -*- C++ -*-=// // // The LLVM Compiler Infrastructure // -- cgit v1.1 From 4d6ccb5f68cd7c6418a209f1fa4dbade569e4493 Mon Sep 17 00:00:00 2001 From: David Blaikie Date: Fri, 20 Jan 2012 21:51:11 +0000 Subject: More dead code removal (using -Wunreachable-code) git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@148578 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 1 - 1 file changed, 1 deletion(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 32cf2a8..d40e659 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -72,7 +72,6 @@ resolveX86_64Relocation(uintptr_t Address, uintptr_t Value, bool isPCRel, case macho::RIT_X86_64_TLV: return Error("Relocation type not implemented yet!"); } - return false; } bool RuntimeDyldMachO:: -- cgit v1.1 From b442d7c6bf920b892b4b098923c1652700ee07e6 Mon Sep 17 00:00:00 2001 From: Jim Grosbach Date: Fri, 20 Jan 2012 22:44:03 +0000 Subject: Fix inverted condition. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@148593 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index d40e659..1926af8 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -272,7 +272,7 @@ loadSegment64(const MachOObject *Obj, // Allocate memory via the MM for the section. uint8_t *Buffer; uint32_t SectionID = Sections.size(); - if (Sect->Flags != 0x80000400) + if (Sect->Flags == 0x80000400) Buffer = MemMgr->allocateCodeSection(Sect->Size, Sect->Align, SectionID); else Buffer = MemMgr->allocateDataSection(Sect->Size, Sect->Align, SectionID); -- cgit v1.1 From 93391348dc00b4078463515149eeb214796f553d Mon Sep 17 00:00:00 2001 From: Jim Grosbach Date: Sat, 21 Jan 2012 00:21:53 +0000 Subject: RuntimeDyld alignment adjustment from MachO file. The MachO file stores section alignment as log2(alignment-in-bytes). The allocation routines want the raw alignment-in-bytes value, so adjust for that. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@148604 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 1926af8..fb005bb 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -272,16 +272,18 @@ loadSegment64(const MachOObject *Obj, // Allocate memory via the MM for the section. uint8_t *Buffer; uint32_t SectionID = Sections.size(); + unsigned Align = 1 << Sect->Align; // .o file has log2 alignment. if (Sect->Flags == 0x80000400) - Buffer = MemMgr->allocateCodeSection(Sect->Size, Sect->Align, SectionID); + Buffer = MemMgr->allocateCodeSection(Sect->Size, Align, SectionID); else - Buffer = MemMgr->allocateDataSection(Sect->Size, Sect->Align, SectionID); + Buffer = MemMgr->allocateDataSection(Sect->Size, Align, SectionID); DEBUG(dbgs() << "Loading " << ((Sect->Flags == 0x80000400) ? "text" : "data") << " (ID #" << SectionID << ")" << " '" << Sect->SegmentName << "," << Sect->Name << "' of size " << Sect->Size + << " (align " << Align << ")" << " to address " << Buffer << ".\n"); // Copy the payload from the object file into the allocated buffer. -- cgit v1.1 From 76463fdeb603e1d89b05f094bfd6fe73b90d0b61 Mon Sep 17 00:00:00 2001 From: Eli Bendersky Date: Sun, 22 Jan 2012 07:05:02 +0000 Subject: Split the lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h header to smaller logical headers. ELF and MachO implementations of RuntimeDyldImpl go into their own header files now. Reviewed on llvm-commits git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@148652 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index fb005bb..669ff4c 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -15,7 +15,7 @@ #include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/STLExtras.h" -#include "RuntimeDyldImpl.h" +#include "RuntimeDyldMachO.h" using namespace llvm; using namespace llvm::object; -- cgit v1.1 From 858143816d43e58b17bfd11cb1b57afbd7f0f893 Mon Sep 17 00:00:00 2001 From: Craig Topper Date: Tue, 7 Feb 2012 05:05:23 +0000 Subject: Convert assert(0) to llvm_unreachable git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@149967 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 669ff4c..4be91d3 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -26,7 +26,7 @@ resolveRelocation(uint8_t *Address, uint64_t Value, bool isPCRel, unsigned Type, unsigned Size, int64_t Addend) { // This just dispatches to the proper target specific routine. switch (CPUType) { - default: assert(0 && "Unsupported CPU type!"); + default: llvm_unreachable("Unsupported CPU type!"); case mach::CTM_x86_64: return resolveX86_64Relocation((uintptr_t)Address, (uintptr_t)Value, isPCRel, Type, Size, Addend); -- cgit v1.1 From b83a67e1e3fe210bd99a82eccd3dc5b1b44f1503 Mon Sep 17 00:00:00 2001 From: Ahmed Charles Date: Mon, 13 Feb 2012 06:30:56 +0000 Subject: Fix various issues (or do cleanups) found by enabling certain MSVC warnings. - Use unsigned literals when the desired result is unsigned. This mostly allows unsigned/signed mismatch warnings to be less noisy even if they aren't on by default. - Remove misplaced llvm_unreachable. - Add static to a declaration of a function on MSVC x86 only. - Change some instances of calling a static function through a variable to simply calling that function while removing the unused variable. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@150364 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 1 - 1 file changed, 1 deletion(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 4be91d3..75e4f71 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -91,7 +91,6 @@ resolveARMRelocation(uintptr_t Address, uintptr_t Value, bool isPCRel, default: llvm_unreachable("Invalid relocation type!"); case macho::RIT_Vanilla: { - llvm_unreachable("Invalid relocation type!"); // Mask in the target value a byte at a time (we don't have an alignment // guarantee for the target address, so this is safest). uint8_t *p = (uint8_t*)Address; -- cgit v1.1 From b0934ab7d811e23bf530371976b8b35f3242169c Mon Sep 17 00:00:00 2001 From: Ahmed Charles Date: Sun, 19 Feb 2012 11:37:01 +0000 Subject: Remove dead code. Improve llvm_unreachable text. Simplify some control flow. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@150918 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 1 - 1 file changed, 1 deletion(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 75e4f71..4553ef4 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -34,7 +34,6 @@ resolveRelocation(uint8_t *Address, uint64_t Value, bool isPCRel, return resolveARMRelocation((uintptr_t)Address, (uintptr_t)Value, isPCRel, Type, Size, Addend); } - llvm_unreachable(""); } bool RuntimeDyldMachO:: -- cgit v1.1 From 996d6fdfb4242f935a8c97cbfa0af5ba6db4a743 Mon Sep 17 00:00:00 2001 From: Sean Callanan Date: Thu, 1 Mar 2012 00:15:29 +0000 Subject: Fixed the 32-bit runtime dynamic loader to allocate code sections when needed. It just had a conditional the wrong way around. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@151777 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp') diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 4553ef4..c11b2c3 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -150,7 +150,7 @@ loadSegment32(const MachOObject *Obj, // Allocate memory via the MM for the section. uint8_t *Buffer; uint32_t SectionID = Sections.size(); - if (Sect->Flags != 0x80000400) + if (Sect->Flags == 0x80000400) Buffer = MemMgr->allocateCodeSection(Sect->Size, Sect->Align, SectionID); else Buffer = MemMgr->allocateDataSection(Sect->Size, Sect->Align, SectionID); -- cgit v1.1