X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FExecutionEngine%2FRuntimeDyld%2FRuntimeDyldMachO.cpp;h=c9bd11a1e1de3b8149ec5c556e528915a30b0a74;hp=7130e0e17498a0a9897aee92d9b072596cf5a43c;hb=ce8287db09f12375b81f0a10404900bb140ca33b;hpb=288967dfac246c8e35dc4f85afb667e74d1d26a8 diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp index 7130e0e1749..c9bd11a1e1d 100644 --- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp +++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp @@ -11,688 +11,330 @@ // //===----------------------------------------------------------------------===// -#define DEBUG_TYPE "dyld" -#include "llvm/ADT/OwningPtr.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/ADT/STLExtras.h" #include "RuntimeDyldMachO.h" +#include "Targets/RuntimeDyldMachOAArch64.h" +#include "Targets/RuntimeDyldMachOARM.h" +#include "Targets/RuntimeDyldMachOI386.h" +#include "Targets/RuntimeDyldMachOX86_64.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/StringRef.h" + using namespace llvm; using namespace llvm::object; -namespace llvm { +#define DEBUG_TYPE "dyld" -bool RuntimeDyldMachO:: -resolveRelocation(uint8_t *LocalAddress, - uint64_t FinalAddress, - uint64_t Value, - bool isPCRel, - unsigned Type, - unsigned Size, - int64_t Addend) { - // This just dispatches to the proper target specific routine. - switch (CPUType) { - default: llvm_unreachable("Unsupported CPU type!"); - case mach::CTM_i386: - return resolveI386Relocation(LocalAddress, - FinalAddress, - (uintptr_t)Value, - isPCRel, - Type, - Size, - Addend); - case mach::CTM_x86_64: - return resolveX86_64Relocation(LocalAddress, - FinalAddress, - (uintptr_t)Value, - isPCRel, - Type, - Size, - Addend); - case mach::CTM_ARM: - return resolveARMRelocation(LocalAddress, - FinalAddress, - (uintptr_t)Value, - isPCRel, - Type, - Size, - Addend); - } -} +namespace { -bool RuntimeDyldMachO:: -resolveI386Relocation(uint8_t *LocalAddress, - uint64_t FinalAddress, - uint64_t Value, - bool isPCRel, - unsigned Type, - unsigned Size, - int64_t Addend) { - if (isPCRel) - Value -= FinalAddress + 4; // see resolveX86_64Relocation - - switch (Type) { - default: - llvm_unreachable("Invalid relocation type!"); - case macho::RIT_Vanilla: { - uint8_t *p = LocalAddress; - uint64_t ValueToWrite = Value + Addend; - for (unsigned i = 0; i < Size; ++i) { - *p++ = (uint8_t)(ValueToWrite & 0xff); - ValueToWrite >>= 8; - } - } - case macho::RIT_Difference: - case macho::RIT_Generic_LocalDifference: - case macho::RIT_Generic_PreboundLazyPointer: - return Error("Relocation type not implemented yet!"); - } -} +class LoadedMachOObjectInfo + : public RuntimeDyld::LoadedObjectInfoHelper { +public: + LoadedMachOObjectInfo(RuntimeDyldImpl &RTDyld, + ObjSectionToIDMap ObjSecToIDMap) + : LoadedObjectInfoHelper(RTDyld, std::move(ObjSecToIDMap)) {} -bool RuntimeDyldMachO:: -resolveX86_64Relocation(uint8_t *LocalAddress, - uint64_t FinalAddress, - uint64_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) - // FIXME: It seems this value needs to be adjusted by 4 for an effective PC - // address. Is that expected? Only for branches, perhaps? - Value -= FinalAddress + 4; - - 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*)LocalAddress; - for (unsigned i = 0; i < Size; ++i) { - *p++ = (uint8_t)Value; - Value >>= 8; - } - return false; + OwningBinary + getObjectForDebug(const ObjectFile &Obj) const override { + return OwningBinary(); } - case macho::RIT_X86_64_GOTLoad: - case macho::RIT_X86_64_GOT: - case macho::RIT_X86_64_Subtractor: - case macho::RIT_X86_64_TLV: - return Error("Relocation type not implemented yet!"); - } -} +}; -bool RuntimeDyldMachO:: -resolveARMRelocation(uint8_t *LocalAddress, - uint64_t FinalAddress, - uint64_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) { - Value -= FinalAddress; - // ARM PCRel relocations have an effective-PC offset of two instructions - // (four bytes in Thumb mode, 8 bytes in ARM mode). - // FIXME: For now, assume ARM mode. - Value -= 8; - } - - switch(Type) { - default: - llvm_unreachable("Invalid relocation type!"); - case macho::RIT_Vanilla: { - // 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*)LocalAddress; - for (unsigned i = 0; i < Size; ++i) { - *p++ = (uint8_t)Value; - Value >>= 8; - } - break; - } - case macho::RIT_ARM_Branch24Bit: { - // Mask the value into the target address. We know instructions are - // 32-bit aligned, so we can do it all at once. - uint32_t *p = (uint32_t*)LocalAddress; - // The low two bits of the value are not encoded. - Value >>= 2; - // Mask the value to 24 bits. - Value &= 0xffffff; - // FIXME: If the destination is a Thumb function (and the instruction - // is a non-predicated BL instruction), we need to change it to a BLX - // instruction instead. - - // Insert the value into the instruction. - *p = (*p & ~0xffffff) | Value; - break; - } - case macho::RIT_ARM_ThumbBranch22Bit: - case macho::RIT_ARM_ThumbBranch32Bit: - case macho::RIT_ARM_Half: - case macho::RIT_ARM_HalfDifference: - case macho::RIT_Pair: - case macho::RIT_Difference: - case macho::RIT_ARM_LocalDifference: - case macho::RIT_ARM_PreboundLazyPointer: - return Error("Relocation type not implemented yet!"); - } - return false; } -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) + "'"); - - // Allocate memory via the MM for the section. - uint8_t *Buffer; - uint32_t SectionID = Sections.size(); - if (Sect->Flags == 0x80000400) - 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); - - // 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); - - // 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); - Referrers.grow(Referrers.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); - if (RE->Word0 & macho::RF_Scattered) - return Error("NOT YET IMPLEMENTED: scattered relocations."); - // Word0 of the relocation is the offset into the section where the - // 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; - 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]). - uint32_t SourceNum = RE->Word1 & 0xffffff; // 24-bit value - 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. - uint32_t RelocationIndex = Relocations[SectionID].size(); - Relocations[SectionID].push_back(RelocationEntry(TargetID, - Offset, - RE->Word1, - 0 /*Addend*/)); - Referrers[TargetID].push_back(Referrer(SectionID, RelocationIndex)); - } 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"); - } - } - } +namespace llvm { - // 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]); +int64_t RuntimeDyldMachO::memcpyAddend(const RelocationEntry &RE) const { + unsigned NumBytes = 1 << RE.Size; + uint8_t *Src = Sections[RE.SectionID].Address + RE.Offset; - return false; + return static_cast(readBytesUnaligned(Src, NumBytes)); } +relocation_iterator RuntimeDyldMachO::processScatteredVANILLA( + unsigned SectionID, relocation_iterator RelI, + const ObjectFile &BaseObjT, + RuntimeDyldMachO::ObjSectionToIDMap &ObjSectionToID) { + const MachOObjectFile &Obj = + static_cast(BaseObjT); + MachO::any_relocation_info RE = + Obj.getRelocation(RelI->getRawDataRefImpl()); + + SectionEntry &Section = Sections[SectionID]; + uint32_t RelocType = Obj.getAnyRelocationType(RE); + bool IsPCRel = Obj.getAnyRelocationPCRel(RE); + unsigned Size = Obj.getAnyRelocationLength(RE); + uint64_t Offset = RelI->getOffset(); + uint8_t *LocalAddress = Section.Address + Offset; + unsigned NumBytes = 1 << Size; + int64_t Addend = readBytesUnaligned(LocalAddress, NumBytes); + + unsigned SymbolBaseAddr = Obj.getScatteredRelocationValue(RE); + section_iterator TargetSI = getSectionByAddress(Obj, SymbolBaseAddr); + assert(TargetSI != Obj.section_end() && "Can't find section for symbol"); + uint64_t SectionBaseAddr = TargetSI->getAddress(); + SectionRef TargetSection = *TargetSI; + bool IsCode = TargetSection.isText(); + uint32_t TargetSectionID = + findOrEmitSection(Obj, TargetSection, IsCode, ObjSectionToID); + + Addend -= SectionBaseAddr; + RelocationEntry R(SectionID, Offset, RelocType, Addend, IsPCRel, Size); + + addRelocationForSection(R, TargetSectionID); + + return ++RelI; +} -bool RuntimeDyldMachO:: -loadSegment64(const MachOObject *Obj, - const MachOObject::LoadCommandInfo *SegmentLCI, - const InMemoryStruct &SymtabLC) { - InMemoryStruct Segment64LC; - Obj->ReadSegment64LoadCommand(*SegmentLCI, Segment64LC); - 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) + "'"); - - // 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, Align, SectionID); - else - 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. - uint8_t *Base = (uint8_t*)Obj->getData(Segment64LC->FileOffset, - Segment64LC->FileSize).data(); - memcpy(Buffer, Base + Sect->Address, Sect->Size); - - // 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); - - // 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); - Referrers.grow(Referrers.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); - if (RE->Word0 & macho::RF_Scattered) - return Error("NOT YET IMPLEMENTED: scattered relocations."); - // Word0 of the relocation is the offset into the section where the - // 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; - 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]). - uint32_t SourceNum = RE->Word1 & 0xffffff; // 24-bit value - 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. - uint32_t RelocationIndex = Relocations[SectionID].size(); - Relocations[SectionID].push_back(RelocationEntry(TargetID, - Offset, - RE->Word1, - 0 /*Addend*/)); - Referrers[TargetID].push_back(Referrer(SectionID, RelocationIndex)); - } 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"); - } +RelocationValueRef RuntimeDyldMachO::getRelocationValueRef( + const ObjectFile &BaseTObj, const relocation_iterator &RI, + const RelocationEntry &RE, ObjSectionToIDMap &ObjSectionToID) { + + const MachOObjectFile &Obj = + static_cast(BaseTObj); + MachO::any_relocation_info RelInfo = + Obj.getRelocation(RI->getRawDataRefImpl()); + RelocationValueRef Value; + + bool IsExternal = Obj.getPlainRelocationExternal(RelInfo); + if (IsExternal) { + symbol_iterator Symbol = RI->getSymbol(); + ErrorOr TargetNameOrErr = Symbol->getName(); + if (std::error_code EC = TargetNameOrErr.getError()) + report_fatal_error(EC.message()); + StringRef TargetName = *TargetNameOrErr; + RTDyldSymbolTable::const_iterator SI = + GlobalSymbolTable.find(TargetName.data()); + if (SI != GlobalSymbolTable.end()) { + const auto &SymInfo = SI->second; + Value.SectionID = SymInfo.getSectionID(); + Value.Offset = SymInfo.getOffset() + RE.Addend; + } else { + Value.SymbolName = TargetName.data(); + Value.Offset = RE.Addend; } + } else { + SectionRef Sec = Obj.getAnyRelocationSection(RelInfo); + bool IsCode = Sec.isText(); + Value.SectionID = findOrEmitSection(Obj, Sec, IsCode, ObjSectionToID); + uint64_t Addr = Sec.getAddress(); + Value.Offset = RE.Addend - Addr; } - // 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; + return Value; } -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; +void RuntimeDyldMachO::makeValueAddendPCRel(RelocationValueRef &Value, + const relocation_iterator &RI, + unsigned OffsetToNextPC) { + auto &O = *cast(RI->getObject()); + section_iterator SecI = O.getRelocationRelocatedSection(RI); + Value.Offset += RI->getOffset() + OffsetToNextPC + SecI->getAddress(); +} - // Remember the symbol. - uint32_t SectionID = SectionMap[STE->SectionIndex - 1]; - SymbolTable[Name] = SymbolLoc(SectionID, STE->Value); +void RuntimeDyldMachO::dumpRelocationToResolve(const RelocationEntry &RE, + uint64_t Value) const { + const SectionEntry &Section = Sections[RE.SectionID]; + uint8_t *LocalAddress = Section.Address + RE.Offset; + uint64_t FinalAddress = Section.LoadAddress + RE.Offset; + + dbgs() << "resolveRelocation Section: " << RE.SectionID + << " LocalAddress: " << format("%p", LocalAddress) + << " FinalAddress: " << format("0x%016" PRIx64, FinalAddress) + << " Value: " << format("0x%016" PRIx64, Value) << " Addend: " << RE.Addend + << " isPCRel: " << RE.IsPCRel << " MachoType: " << RE.RelType + << " Size: " << (1 << RE.Size) << "\n"; +} - DEBUG(dbgs() << "Symbol: '" << Name << "' @ " - << (getSectionAddress(SectionID) + STE->Value) - << "\n"); +section_iterator +RuntimeDyldMachO::getSectionByAddress(const MachOObjectFile &Obj, + uint64_t Addr) { + section_iterator SI = Obj.section_begin(); + section_iterator SE = Obj.section_end(); + + for (; SI != SE; ++SI) { + uint64_t SAddr = SI->getAddress(); + uint64_t SSize = SI->getSize(); + if ((Addr >= SAddr) && (Addr < SAddr + SSize)) + return SI; } - 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; + return SE; +} - // 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"); +// Populate __pointers section. +void RuntimeDyldMachO::populateIndirectSymbolPointersSection( + const MachOObjectFile &Obj, + const SectionRef &PTSection, + unsigned PTSectionID) { + assert(!Obj.is64Bit() && + "Pointer table section not supported in 64-bit MachO."); + + MachO::dysymtab_command DySymTabCmd = Obj.getDysymtabLoadCommand(); + MachO::section Sec32 = Obj.getSection(PTSection.getRawDataRefImpl()); + uint32_t PTSectionSize = Sec32.size; + unsigned FirstIndirectSymbol = Sec32.reserved1; + const unsigned PTEntrySize = 4; + unsigned NumPTEntries = PTSectionSize / PTEntrySize; + unsigned PTEntryOffset = 0; + + assert((PTSectionSize % PTEntrySize) == 0 && + "Pointers section does not contain a whole number of stubs?"); + + DEBUG(dbgs() << "Populating pointer table section " + << Sections[PTSectionID].Name + << ", Section ID " << PTSectionID << ", " + << NumPTEntries << " entries, " << PTEntrySize + << " bytes each:\n"); + + for (unsigned i = 0; i < NumPTEntries; ++i) { + unsigned SymbolIndex = + Obj.getIndirectSymbolTableEntry(DySymTabCmd, FirstIndirectSymbol + i); + symbol_iterator SI = Obj.getSymbolByIndex(SymbolIndex); + ErrorOr IndirectSymbolNameOrErr = SI->getName(); + if (std::error_code EC = IndirectSymbolNameOrErr.getError()) + report_fatal_error(EC.message()); + StringRef IndirectSymbolName = *IndirectSymbolNameOrErr; + DEBUG(dbgs() << " " << IndirectSymbolName << ": index " << SymbolIndex + << ", PT offset: " << PTEntryOffset << "\n"); + RelocationEntry RE(PTSectionID, PTEntryOffset, + MachO::GENERIC_RELOC_VANILLA, 0, false, 2); + addRelocationForSymbol(RE, IndirectSymbolName); + PTEntryOffset += PTEntrySize; } - 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; - uint32_t RelocationIndex = Relocations[Loc->second.first].size(); - Relocations[Loc->second.first].push_back(Entry); - Referrers[Entry.SectionID].push_back(Referrer(Loc->second.first, RelocationIndex)); - } - // FIXME: Keep a worklist of the relocations we've added so that we can - // resolve more selectively later. - Relocs.clear(); +bool RuntimeDyldMachO::isCompatibleFile(const object::ObjectFile &Obj) const { + return Obj.isMachO(); } -bool RuntimeDyldMachO::loadObject(MemoryBuffer *InputBuffer) { - // If the linker is in an error state, don't do anything. - if (hasError()) - return true; - // Load the Mach-O wrapper object. - std::string ErrorStr; - OwningPtr Obj( - MachOObject::LoadFromBuffer(InputBuffer, &ErrorStr)); - if (!Obj) - return Error("unable to load object: '" + ErrorStr + "'"); - - // Get the CPU type information from the header. - const macho::Header &Header = Obj->getHeader(); - - // FIXME: Error checking that the loaded object is compatible with - // the system we're running on. - CPUType = Header.CPUType; - CPUSubtype = Header.CPUSubtype; - - // Validate that the load commands match what we expect. - const MachOObject::LoadCommandInfo *SegmentLCI = 0, *SymtabLCI = 0, - *DysymtabLCI = 0; - for (unsigned i = 0; i != Header.NumLoadCommands; ++i) { - const MachOObject::LoadCommandInfo &LCI = Obj->getLoadCommandInfo(i); - switch (LCI.Command.Type) { - case macho::LCT_Segment: - case macho::LCT_Segment64: - if (SegmentLCI) - return Error("unexpected input object (multiple segments)"); - SegmentLCI = &LCI; - break; - case macho::LCT_Symtab: - if (SymtabLCI) - return Error("unexpected input object (multiple symbol tables)"); - SymtabLCI = &LCI; - break; - case macho::LCT_Dysymtab: - if (DysymtabLCI) - return Error("unexpected input object (multiple symbol tables)"); - DysymtabLCI = &LCI; - break; - default: - return Error("unexpected input object (unexpected load command"); +template +void RuntimeDyldMachOCRTPBase::finalizeLoad(const ObjectFile &Obj, + ObjSectionToIDMap &SectionMap) { + unsigned EHFrameSID = RTDYLD_INVALID_SECTION_ID; + unsigned TextSID = RTDYLD_INVALID_SECTION_ID; + unsigned ExceptTabSID = RTDYLD_INVALID_SECTION_ID; + + for (const auto &Section : Obj.sections()) { + StringRef Name; + Section.getName(Name); + + // Force emission of the __text, __eh_frame, and __gcc_except_tab sections + // if they're present. Otherwise call down to the impl to handle other + // sections that have already been emitted. + if (Name == "__text") + TextSID = findOrEmitSection(Obj, Section, true, SectionMap); + else if (Name == "__eh_frame") + EHFrameSID = findOrEmitSection(Obj, Section, false, SectionMap); + else if (Name == "__gcc_except_tab") + ExceptTabSID = findOrEmitSection(Obj, Section, true, SectionMap); + else { + auto I = SectionMap.find(Section); + if (I != SectionMap.end()) + impl().finalizeSection(Obj, I->second, Section); } } + UnregisteredEHFrameSections.push_back( + EHFrameRelatedSections(EHFrameSID, TextSID, ExceptTabSID)); +} - if (!SymtabLCI) - return Error("no symbol table found in object"); - if (!SegmentLCI) - return Error("no segments found in object"); - - // Read and register the symbol table data. - InMemoryStruct SymtabLC; - Obj->ReadSymtabLoadCommand(*SymtabLCI, SymtabLC); - if (!SymtabLC) - return Error("unable to load symbol table load command"); - Obj->RegisterStringTable(*SymtabLC); - - // Read the dynamic link-edit information, if present (not present in static - // objects). - if (DysymtabLCI) { - InMemoryStruct DysymtabLC; - Obj->ReadDysymtabLoadCommand(*DysymtabLCI, DysymtabLC); - if (!DysymtabLC) - return Error("unable to load dynamic link-exit load command"); - - // FIXME: We don't support anything interesting yet. -// if (DysymtabLC->LocalSymbolsIndex != 0) -// return Error("NOT YET IMPLEMENTED: local symbol entries"); -// if (DysymtabLC->ExternalSymbolsIndex != 0) -// return Error("NOT YET IMPLEMENTED: non-external symbol entries"); -// if (DysymtabLC->UndefinedSymbolsIndex != SymtabLC->NumSymbolTableEntries) -// return Error("NOT YET IMPLEMENTED: undefined symbol entries"); - } - - // Load the segment load command. - if (SegmentLCI->Command.Type == macho::LCT_Segment) { - if (loadSegment32(Obj.get(), SegmentLCI, SymtabLC)) - return true; - } else { - if (loadSegment64(Obj.get(), SegmentLCI, SymtabLC)) - return true; +template +unsigned char *RuntimeDyldMachOCRTPBase::processFDE(unsigned char *P, + int64_t DeltaForText, + int64_t DeltaForEH) { + typedef typename Impl::TargetPtrT TargetPtrT; + + DEBUG(dbgs() << "Processing FDE: Delta for text: " << DeltaForText + << ", Delta for EH: " << DeltaForEH << "\n"); + uint32_t Length = readBytesUnaligned(P, 4); + P += 4; + unsigned char *Ret = P + Length; + uint32_t Offset = readBytesUnaligned(P, 4); + if (Offset == 0) // is a CIE + return Ret; + + P += 4; + TargetPtrT FDELocation = readBytesUnaligned(P, sizeof(TargetPtrT)); + TargetPtrT NewLocation = FDELocation - DeltaForText; + writeBytesUnaligned(NewLocation, P, sizeof(TargetPtrT)); + + P += sizeof(TargetPtrT); + + // Skip the FDE address range + P += sizeof(TargetPtrT); + + uint8_t Augmentationsize = *P; + P += 1; + if (Augmentationsize != 0) { + TargetPtrT LSDA = readBytesUnaligned(P, sizeof(TargetPtrT)); + TargetPtrT NewLSDA = LSDA - DeltaForEH; + writeBytesUnaligned(NewLSDA, P, sizeof(TargetPtrT)); } - // 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 Ret; +} - return false; +static int64_t computeDelta(SectionEntry *A, SectionEntry *B) { + int64_t ObjDistance = + static_cast(A->ObjAddress) - static_cast(B->ObjAddress); + int64_t MemDistance = A->LoadAddress - B->LoadAddress; + return ObjDistance - MemDistance; } -// Assign an address to a symbol name and resolve all the relocations -// associated with it. -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 = (uint8_t*)Sections[RE.SectionID].base() + RE.Offset; - uint64_t FinalTarget = (uint64_t)SectionLoadAddress[RE.SectionID] + 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 Section #" << RE.SectionID - << " + " << RE.Offset << " (" << format("%p", Target) << ")" - << " from Section #" << SectionID << " (" << format("%p", Addr) << ")" - << "(" << (isPCRel ? "pcrel" : "absolute") - << ", type: " << Type << ", Size: " << Size << ", Addend: " - << RE.Addend << ").\n"); - - resolveRelocation(Target, - FinalTarget, - Addr, - isPCRel, - Type, - Size, - RE.Addend); +template +void RuntimeDyldMachOCRTPBase::registerEHFrames() { + + for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) { + EHFrameRelatedSections &SectionInfo = UnregisteredEHFrameSections[i]; + if (SectionInfo.EHFrameSID == RTDYLD_INVALID_SECTION_ID || + SectionInfo.TextSID == RTDYLD_INVALID_SECTION_ID) + continue; + SectionEntry *Text = &Sections[SectionInfo.TextSID]; + SectionEntry *EHFrame = &Sections[SectionInfo.EHFrameSID]; + SectionEntry *ExceptTab = nullptr; + if (SectionInfo.ExceptTabSID != RTDYLD_INVALID_SECTION_ID) + ExceptTab = &Sections[SectionInfo.ExceptTabSID]; + + int64_t DeltaForText = computeDelta(Text, EHFrame); + int64_t DeltaForEH = 0; + if (ExceptTab) + DeltaForEH = computeDelta(ExceptTab, EHFrame); + + unsigned char *P = EHFrame->Address; + unsigned char *End = P + EHFrame->Size; + do { + P = processFDE(P, DeltaForText, DeltaForEH); + } while (P != End); + + MemMgr.registerEHFrames(EHFrame->Address, EHFrame->LoadAddress, + EHFrame->Size); } - ReferrerList &Refers = Referrers[SectionID]; - for (unsigned i = 0, e = Refers.size(); i != e; ++i) { - Referrer &R = Refers[i]; - RelocationEntry &RE = Relocations[R.SectionID][R.Index]; - uint8_t *Target = (uint8_t*)Sections[RE.SectionID].base() + RE.Offset; - uint64_t FinalTarget = (uint64_t)SectionLoadAddress[RE.SectionID] + 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 Section #" << RE.SectionID - << " + " << RE.Offset << " (" << format("%p", Target) << ")" - << " from Section #" << SectionID << " (" << format("%p", Addr) << ")" - << "(" << (isPCRel ? "pcrel" : "absolute") - << ", type: " << Type << ", Size: " << Size << ", Addend: " - << RE.Addend << ").\n"); - - resolveRelocation(Target, - FinalTarget, - Addr, - isPCRel, - Type, - Size, - RE.Addend); + UnregisteredEHFrameSections.clear(); +} + +std::unique_ptr +RuntimeDyldMachO::create(Triple::ArchType Arch, + RuntimeDyld::MemoryManager &MemMgr, + RuntimeDyld::SymbolResolver &Resolver) { + switch (Arch) { + default: + llvm_unreachable("Unsupported target for RuntimeDyldMachO."); + break; + case Triple::arm: + return make_unique(MemMgr, Resolver); + case Triple::aarch64: + return make_unique(MemMgr, Resolver); + case Triple::x86: + return make_unique(MemMgr, Resolver); + case Triple::x86_64: + return make_unique(MemMgr, Resolver); } } -bool RuntimeDyldMachO::isKnownFormat(const MemoryBuffer *InputBuffer) { - StringRef Magic = InputBuffer->getBuffer().slice(0, 4); - if (Magic == "\xFE\xED\xFA\xCE") return true; - if (Magic == "\xCE\xFA\xED\xFE") return true; - if (Magic == "\xFE\xED\xFA\xCF") return true; - if (Magic == "\xCF\xFA\xED\xFE") return true; - return false; +std::unique_ptr +RuntimeDyldMachO::loadObject(const object::ObjectFile &O) { + return llvm::make_unique(*this, loadObjectImpl(O)); } } // end namespace llvm