X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=tools%2Fllvm-rtdyld%2Fllvm-rtdyld.cpp;h=eab74543cbb94ae69ced6df2e01aa1b5ba08c25b;hp=fcda9e7f8a8e0d36b17faee8f598eb0d6c661e46;hb=c25aec11171651088a57ec6d2e330d0a15bf0acb;hpb=c3747f276a212e73119980479409281df57a8269 diff --git a/tools/llvm-rtdyld/llvm-rtdyld.cpp b/tools/llvm-rtdyld/llvm-rtdyld.cpp index fcda9e7f8a8..eab74543cbb 100644 --- a/tools/llvm-rtdyld/llvm-rtdyld.cpp +++ b/tools/llvm-rtdyld/llvm-rtdyld.cpp @@ -13,27 +13,30 @@ #include "llvm/ADT/StringMap.h" #include "llvm/DebugInfo/DIContext.h" -#include "llvm/ExecutionEngine/ObjectBuffer.h" -#include "llvm/ExecutionEngine/ObjectImage.h" +#include "llvm/DebugInfo/DWARF/DWARFContext.h" +#include "llvm/ExecutionEngine/RTDyldMemoryManager.h" #include "llvm/ExecutionEngine/RuntimeDyld.h" #include "llvm/ExecutionEngine/RuntimeDyldChecker.h" #include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCContext.h" #include "llvm/MC/MCDisassembler.h" -#include "llvm/MC/MCInstrInfo.h" #include "llvm/MC/MCInstPrinter.h" +#include "llvm/MC/MCInstrInfo.h" #include "llvm/MC/MCRegisterInfo.h" +#include "llvm/MC/MCSubtargetInfo.h" #include "llvm/Object/MachO.h" +#include "llvm/Object/SymbolSize.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/DynamicLibrary.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/Memory.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/PrettyStackTrace.h" -#include "llvm/Support/raw_ostream.h" #include "llvm/Support/Signals.h" #include "llvm/Support/TargetRegistry.h" #include "llvm/Support/TargetSelect.h" +#include "llvm/Support/raw_ostream.h" +#include #include using namespace llvm; @@ -45,7 +48,9 @@ InputFileList(cl::Positional, cl::ZeroOrMore, enum ActionType { AC_Execute, + AC_PrintObjectLineInfo, AC_PrintLineInfo, + AC_PrintDebugLineInfo, AC_Verify }; @@ -56,6 +61,10 @@ Action(cl::desc("Action to perform:"), "Load, link, and execute the inputs."), clEnumValN(AC_PrintLineInfo, "printline", "Load, link, and print line information for each function."), + clEnumValN(AC_PrintDebugLineInfo, "printdebugline", + "Load, link, and print line information for each function using the debug object"), + clEnumValN(AC_PrintObjectLineInfo, "printobjline", + "Like -printlineinfo but does not load the object first"), clEnumValN(AC_Verify, "verify", "Load, link and verify the resulting memory image."), clEnumValEnd)); @@ -73,11 +82,56 @@ Dylibs("dylib", static cl::opt TripleName("triple", cl::desc("Target triple for disassembler")); +static cl::opt +MCPU("mcpu", + cl::desc("Target a specific cpu type (-mcpu=help for details)"), + cl::value_desc("cpu-name"), + cl::init("")); + static cl::list CheckFiles("check", cl::desc("File containing RuntimeDyld verifier checks."), cl::ZeroOrMore); +static cl::opt +PreallocMemory("preallocate", + cl::desc("Allocate memory upfront rather than on-demand"), + cl::init(0)); + +static cl::opt +TargetAddrStart("target-addr-start", + cl::desc("For -verify only: start of phony target address " + "range."), + cl::init(4096), // Start at "page 1" - no allocating at "null". + cl::Hidden); + +static cl::opt +TargetAddrEnd("target-addr-end", + cl::desc("For -verify only: end of phony target address range."), + cl::init(~0ULL), + cl::Hidden); + +static cl::opt +TargetSectionSep("target-section-sep", + cl::desc("For -verify only: Separation between sections in " + "phony target address space."), + cl::init(0), + cl::Hidden); + +static cl::list +SpecificSectionMappings("map-section", + cl::desc("For -verify only: Map a section to a " + "specific address."), + cl::ZeroOrMore, + cl::Hidden); + +static cl::list +DummySymbolMappings("dummy-extern", + cl::desc("For -verify only: Inject a symbol into the extern " + "symbol table."), + cl::ZeroOrMore, + cl::Hidden); + /* *** */ // A trivial memory manager that doesn't do anything fancy, just uses the @@ -101,18 +155,69 @@ public: bool finalizeMemory(std::string *ErrMsg) override { return false; } - // Invalidate instruction cache for sections with execute permissions. - // Some platforms with separate data cache and instruction cache require - // explicit cache flush, otherwise JIT code manipulations (like resolved - // relocations) will get to the data cache but not to the instruction cache. - virtual void invalidateInstructionCache(); + void addDummySymbol(const std::string &Name, uint64_t Addr) { + DummyExterns[Name] = Addr; + } + + RuntimeDyld::SymbolInfo findSymbol(const std::string &Name) override { + auto I = DummyExterns.find(Name); + + if (I != DummyExterns.end()) + return RuntimeDyld::SymbolInfo(I->second, JITSymbolFlags::Exported); + + return RTDyldMemoryManager::findSymbol(Name); + } + + void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, + size_t Size) override {} + void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr, + size_t Size) override {} + + void preallocateSlab(uint64_t Size) { + std::string Err; + sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, nullptr, &Err); + if (!MB.base()) + report_fatal_error("Can't allocate enough memory: " + Err); + + PreallocSlab = MB; + UsePreallocation = true; + SlabSize = Size; + } + + uint8_t *allocateFromSlab(uintptr_t Size, unsigned Alignment, bool isCode) { + Size = RoundUpToAlignment(Size, Alignment); + if (CurrentSlabOffset + Size > SlabSize) + report_fatal_error("Can't allocate enough memory. Tune --preallocate"); + + uintptr_t OldSlabOffset = CurrentSlabOffset; + sys::MemoryBlock MB((void *)OldSlabOffset, Size); + if (isCode) + FunctionMemory.push_back(MB); + else + DataMemory.push_back(MB); + CurrentSlabOffset += Size; + return (uint8_t*)OldSlabOffset; + } + +private: + std::map DummyExterns; + sys::MemoryBlock PreallocSlab; + bool UsePreallocation = false; + uintptr_t SlabSize = 0; + uintptr_t CurrentSlabOffset = 0; }; uint8_t *TrivialMemoryManager::allocateCodeSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName) { - sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, nullptr, nullptr); + if (UsePreallocation) + return allocateFromSlab(Size, Alignment, true /* isCode */); + + std::string Err; + sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, nullptr, &Err); + if (!MB.base()) + report_fatal_error("MemoryManager allocation failed: " + Err); FunctionMemory.push_back(MB); return (uint8_t*)MB.base(); } @@ -122,29 +227,21 @@ uint8_t *TrivialMemoryManager::allocateDataSection(uintptr_t Size, unsigned SectionID, StringRef SectionName, bool IsReadOnly) { - sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, nullptr, nullptr); + if (UsePreallocation) + return allocateFromSlab(Size, Alignment, false /* isCode */); + + std::string Err; + sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, nullptr, &Err); + if (!MB.base()) + report_fatal_error("MemoryManager allocation failed: " + Err); DataMemory.push_back(MB); return (uint8_t*)MB.base(); } -void TrivialMemoryManager::invalidateInstructionCache() { - for (int i = 0, e = FunctionMemory.size(); i != e; ++i) - sys::Memory::InvalidateInstructionCache(FunctionMemory[i].base(), - FunctionMemory[i].size()); - - for (int i = 0, e = DataMemory.size(); i != e; ++i) - sys::Memory::InvalidateInstructionCache(DataMemory[i].base(), - DataMemory[i].size()); -} - static const char *ProgramName; -static void Message(const char *Type, const Twine &Msg) { - errs() << ProgramName << ": " << Type << ": " << Msg << "\n"; -} - static int Error(const Twine &Msg) { - Message("error", Msg); + errs() << ProgramName << ": error: " << Msg << "\n"; return 1; } @@ -162,59 +259,95 @@ static void loadDylibs() { /* *** */ -static int printLineInfoForInput() { +static int printLineInfoForInput(bool LoadObjects, bool UseDebugObj) { + assert(LoadObjects || !UseDebugObj); + // Load any dylibs requested on the command line. loadDylibs(); // If we don't have any input files, read from stdin. if (!InputFileList.size()) InputFileList.push_back("-"); - for(unsigned i = 0, e = InputFileList.size(); i != e; ++i) { + for (auto &File : InputFileList) { // Instantiate a dynamic linker. TrivialMemoryManager MemMgr; - RuntimeDyld Dyld(&MemMgr); + RuntimeDyld Dyld(MemMgr, MemMgr); // Load the input memory buffer. - std::unique_ptr InputBuffer; - std::unique_ptr LoadedObject; - if (std::error_code ec = - MemoryBuffer::getFileOrSTDIN(InputFileList[i], InputBuffer)) - return Error("unable to read input: '" + ec.message() + "'"); - // Load the object file - LoadedObject.reset(Dyld.loadObject(new ObjectBuffer(InputBuffer.release()))); - if (!LoadedObject) { - return Error(Dyld.getErrorString()); - } + ErrorOr> InputBuffer = + MemoryBuffer::getFileOrSTDIN(File); + if (std::error_code EC = InputBuffer.getError()) + return Error("unable to read input: '" + EC.message() + "'"); - // Resolve all the relocations we can. - Dyld.resolveRelocations(); + ErrorOr> MaybeObj( + ObjectFile::createObjectFile((*InputBuffer)->getMemBufferRef())); + + if (std::error_code EC = MaybeObj.getError()) + return Error("unable to create object file: '" + EC.message() + "'"); + + ObjectFile &Obj = **MaybeObj; + + OwningBinary DebugObj; + std::unique_ptr LoadedObjInfo = nullptr; + ObjectFile *SymbolObj = &Obj; + if (LoadObjects) { + // Load the object file + LoadedObjInfo = + Dyld.loadObject(Obj); + + if (Dyld.hasError()) + return Error(Dyld.getErrorString()); + + // Resolve all the relocations we can. + Dyld.resolveRelocations(); + + if (UseDebugObj) { + DebugObj = LoadedObjInfo->getObjectForDebug(Obj); + SymbolObj = DebugObj.getBinary(); + LoadedObjInfo.reset(); + } + } std::unique_ptr Context( - DIContext::getDWARFContext(LoadedObject->getObjectFile())); + new DWARFContextInMemory(*SymbolObj,LoadedObjInfo.get())); + + std::vector> SymAddr = + object::computeSymbolSizes(*SymbolObj); // Use symbol info to iterate functions in the object. - for (object::symbol_iterator I = LoadedObject->begin_symbols(), - E = LoadedObject->end_symbols(); - I != E; ++I) { - object::SymbolRef::Type SymType; - if (I->getType(SymType)) continue; - if (SymType == object::SymbolRef::ST_Function) { - StringRef Name; - uint64_t Addr; - uint64_t Size; - if (I->getName(Name)) continue; - if (I->getAddress(Addr)) continue; - if (I->getSize(Size)) continue; - - outs() << "Function: " << Name << ", Size = " << Size << "\n"; + for (const auto &P : SymAddr) { + object::SymbolRef Sym = P.first; + if (Sym.getType() == object::SymbolRef::ST_Function) { + ErrorOr Name = Sym.getName(); + if (!Name) + continue; + ErrorOr AddrOrErr = Sym.getAddress(); + if (!AddrOrErr) + continue; + uint64_t Addr = *AddrOrErr; + + uint64_t Size = P.second; + // If we're not using the debug object, compute the address of the + // symbol in memory (rather than that in the unrelocated object file) + // and use that to query the DWARFContext. + if (!UseDebugObj && LoadObjects) { + object::section_iterator Sec = *Sym.getSection(); + StringRef SecName; + Sec->getName(SecName); + uint64_t SectionLoadAddress = + LoadedObjInfo->getSectionLoadAddress(*Sec); + if (SectionLoadAddress != 0) + Addr += SectionLoadAddress - Sec->getAddress(); + } + + outs() << "Function: " << *Name << ", Size = " << Size + << ", Addr = " << Addr << "\n"; DILineInfoTable Lines = Context->getLineInfoForAddressRange(Addr, Size); - DILineInfoTable::iterator Begin = Lines.begin(); - DILineInfoTable::iterator End = Lines.end(); - for (DILineInfoTable::iterator It = Begin; It != End; ++It) { - outs() << " Line info @ " << It->first - Addr << ": " - << It->second.FileName << ", line:" << It->second.Line << "\n"; + for (auto &D : Lines) { + outs() << " Line info @ " << D.first - Addr << ": " + << D.second.FileName << ", line:" << D.second.Line << "\n"; } } } @@ -223,51 +356,72 @@ static int printLineInfoForInput() { return 0; } +static void doPreallocation(TrivialMemoryManager &MemMgr) { + // Allocate a slab of memory upfront, if required. This is used if + // we want to test small code models. + if (static_cast(PreallocMemory) < 0) + report_fatal_error("Pre-allocated bytes of memory must be a positive integer."); + + // FIXME: Limit the amount of memory that can be preallocated? + if (PreallocMemory != 0) + MemMgr.preallocateSlab(PreallocMemory); +} + static int executeInput() { // Load any dylibs requested on the command line. loadDylibs(); // Instantiate a dynamic linker. TrivialMemoryManager MemMgr; - RuntimeDyld Dyld(&MemMgr); + doPreallocation(MemMgr); + RuntimeDyld Dyld(MemMgr, MemMgr); + + // FIXME: Preserve buffers until resolveRelocations time to work around a bug + // in RuntimeDyldELF. + // This fixme should be fixed ASAP. This is a very brittle workaround. + std::vector> InputBuffers; // If we don't have any input files, read from stdin. if (!InputFileList.size()) InputFileList.push_back("-"); - for(unsigned i = 0, e = InputFileList.size(); i != e; ++i) { + for (auto &File : InputFileList) { // Load the input memory buffer. - std::unique_ptr InputBuffer; - std::unique_ptr LoadedObject; - if (std::error_code ec = - MemoryBuffer::getFileOrSTDIN(InputFileList[i], InputBuffer)) - return Error("unable to read input: '" + ec.message() + "'"); + ErrorOr> InputBuffer = + MemoryBuffer::getFileOrSTDIN(File); + if (std::error_code EC = InputBuffer.getError()) + return Error("unable to read input: '" + EC.message() + "'"); + ErrorOr> MaybeObj( + ObjectFile::createObjectFile((*InputBuffer)->getMemBufferRef())); + + if (std::error_code EC = MaybeObj.getError()) + return Error("unable to create object file: '" + EC.message() + "'"); + + ObjectFile &Obj = **MaybeObj; + InputBuffers.push_back(std::move(*InputBuffer)); // Load the object file - LoadedObject.reset(Dyld.loadObject(new ObjectBuffer(InputBuffer.release()))); - if (!LoadedObject) { + Dyld.loadObject(Obj); + if (Dyld.hasError()) { return Error(Dyld.getErrorString()); } } - // Resolve all the relocations we can. - Dyld.resolveRelocations(); - // Clear instruction cache before code will be executed. - MemMgr.invalidateInstructionCache(); - + // Resove all the relocations we can. // FIXME: Error out if there are unresolved relocations. + Dyld.resolveRelocations(); // Get the address of the entry point (_main by default). - void *MainAddress = Dyld.getSymbolAddress(EntryPoint); + void *MainAddress = Dyld.getSymbolLocalAddress(EntryPoint); if (!MainAddress) return Error("no definition for '" + EntryPoint + "'"); // Invalidate the instruction cache for each loaded function. - for (unsigned i = 0, e = MemMgr.FunctionMemory.size(); i != e; ++i) { - sys::MemoryBlock &Data = MemMgr.FunctionMemory[i]; + for (auto &FM : MemMgr.FunctionMemory) { + // Make sure the memory is executable. + // setExecutable will call InvalidateInstructionCache. std::string ErrorStr; - sys::Memory::InvalidateInstructionCache(Data.base(), Data.size()); - if (!sys::Memory::setExecutable(Data, &ErrorStr)) + if (!sys::Memory::setExecutable(FM, &ErrorStr)) return Error("unable to mark function executable: '" + ErrorStr + "'"); } @@ -285,18 +439,168 @@ static int executeInput() { static int checkAllExpressions(RuntimeDyldChecker &Checker) { for (const auto& CheckerFileName : CheckFiles) { - std::unique_ptr CheckerFileBuf; - if (std::error_code EC = - MemoryBuffer::getFileOrSTDIN(CheckerFileName, CheckerFileBuf)) + ErrorOr> CheckerFileBuf = + MemoryBuffer::getFileOrSTDIN(CheckerFileName); + if (std::error_code EC = CheckerFileBuf.getError()) return Error("unable to read input '" + CheckerFileName + "': " + EC.message()); - if (!Checker.checkAllRulesInBuffer("# rtdyld-check:", CheckerFileBuf.get())) + if (!Checker.checkAllRulesInBuffer("# rtdyld-check:", + CheckerFileBuf.get().get())) return Error("some checks in '" + CheckerFileName + "' failed"); } return 0; } +static std::map +applySpecificSectionMappings(RuntimeDyldChecker &Checker) { + + std::map SpecificMappings; + + for (StringRef Mapping : SpecificSectionMappings) { + + size_t EqualsIdx = Mapping.find_first_of("="); + std::string SectionIDStr = Mapping.substr(0, EqualsIdx); + size_t ComaIdx = Mapping.find_first_of(","); + + if (ComaIdx == StringRef::npos) { + errs() << "Invalid section specification '" << Mapping + << "'. Should be ',
='\n"; + exit(1); + } + + std::string FileName = SectionIDStr.substr(0, ComaIdx); + std::string SectionName = SectionIDStr.substr(ComaIdx + 1); + + uint64_t OldAddrInt; + std::string ErrorMsg; + std::tie(OldAddrInt, ErrorMsg) = + Checker.getSectionAddr(FileName, SectionName, true); + + if (ErrorMsg != "") { + errs() << ErrorMsg; + exit(1); + } + + void* OldAddr = reinterpret_cast(static_cast(OldAddrInt)); + + std::string NewAddrStr = Mapping.substr(EqualsIdx + 1); + uint64_t NewAddr; + + if (StringRef(NewAddrStr).getAsInteger(0, NewAddr)) { + errs() << "Invalid section address in mapping '" << Mapping << "'.\n"; + exit(1); + } + + Checker.getRTDyld().mapSectionAddress(OldAddr, NewAddr); + SpecificMappings[OldAddr] = NewAddr; + } + + return SpecificMappings; +} + +// Scatter sections in all directions! +// Remaps section addresses for -verify mode. The following command line options +// can be used to customize the layout of the memory within the phony target's +// address space: +// -target-addr-start -- Specify where the phony target addres range starts. +// -target-addr-end -- Specify where the phony target address range ends. +// -target-section-sep -- Specify how big a gap should be left between the +// end of one section and the start of the next. +// Defaults to zero. Set to something big +// (e.g. 1 << 32) to stress-test stubs, GOTs, etc. +// +static void remapSectionsAndSymbols(const llvm::Triple &TargetTriple, + TrivialMemoryManager &MemMgr, + RuntimeDyldChecker &Checker) { + + // Set up a work list (section addr/size pairs). + typedef std::list> WorklistT; + WorklistT Worklist; + + for (const auto& CodeSection : MemMgr.FunctionMemory) + Worklist.push_back(std::make_pair(CodeSection.base(), CodeSection.size())); + for (const auto& DataSection : MemMgr.DataMemory) + Worklist.push_back(std::make_pair(DataSection.base(), DataSection.size())); + + // Apply any section-specific mappings that were requested on the command + // line. + typedef std::map AppliedMappingsT; + AppliedMappingsT AppliedMappings = applySpecificSectionMappings(Checker); + + // Keep an "already allocated" mapping of section target addresses to sizes. + // Sections whose address mappings aren't specified on the command line will + // allocated around the explicitly mapped sections while maintaining the + // minimum separation. + std::map AlreadyAllocated; + + // Move the previously applied mappings into the already-allocated map. + for (WorklistT::iterator I = Worklist.begin(), E = Worklist.end(); + I != E;) { + WorklistT::iterator Tmp = I; + ++I; + AppliedMappingsT::iterator AI = AppliedMappings.find(Tmp->first); + + if (AI != AppliedMappings.end()) { + AlreadyAllocated[AI->second] = Tmp->second; + Worklist.erase(Tmp); + } + } + + // If the -target-addr-end option wasn't explicitly passed, then set it to a + // sensible default based on the target triple. + if (TargetAddrEnd.getNumOccurrences() == 0) { + if (TargetTriple.isArch16Bit()) + TargetAddrEnd = (1ULL << 16) - 1; + else if (TargetTriple.isArch32Bit()) + TargetAddrEnd = (1ULL << 32) - 1; + // TargetAddrEnd already has a sensible default for 64-bit systems, so + // there's nothing to do in the 64-bit case. + } + + // Process any elements remaining in the worklist. + while (!Worklist.empty()) { + std::pair CurEntry = Worklist.front(); + Worklist.pop_front(); + + uint64_t NextSectionAddr = TargetAddrStart; + + for (const auto &Alloc : AlreadyAllocated) + if (NextSectionAddr + CurEntry.second + TargetSectionSep <= Alloc.first) + break; + else + NextSectionAddr = Alloc.first + Alloc.second + TargetSectionSep; + + AlreadyAllocated[NextSectionAddr] = CurEntry.second; + Checker.getRTDyld().mapSectionAddress(CurEntry.first, NextSectionAddr); + } + + // Add dummy symbols to the memory manager. + for (const auto &Mapping : DummySymbolMappings) { + size_t EqualsIdx = Mapping.find_first_of("="); + + if (EqualsIdx == StringRef::npos) { + errs() << "Invalid dummy symbol specification '" << Mapping + << "'. Should be '='\n"; + exit(1); + } + + std::string Symbol = Mapping.substr(0, EqualsIdx); + std::string AddrStr = Mapping.substr(EqualsIdx + 1); + + uint64_t Addr; + if (StringRef(AddrStr).getAsInteger(0, Addr)) { + errs() << "Invalid symbol mapping '" << Mapping << "'.\n"; + exit(1); + } + + MemMgr.addDummySymbol(Symbol, Addr); + } +} + +// Load and link the objects specified on the command line, but do not execute +// anything. Instead, attach a RuntimeDyldChecker instance and call it to +// verify the correctness of the linked memory. static int linkAndVerify() { // Check for missing triple. @@ -318,7 +622,7 @@ static int linkAndVerify() { TripleName = TheTriple.getTriple(); std::unique_ptr STI( - TheTarget->createMCSubtargetInfo(TripleName, "", "")); + TheTarget->createMCSubtargetInfo(TripleName, MCPU, "")); assert(STI && "Unable to create subtarget info!"); std::unique_ptr MRI(TheTarget->createMCRegInfo(TripleName)); @@ -336,40 +640,69 @@ static int linkAndVerify() { std::unique_ptr MII(TheTarget->createMCInstrInfo()); std::unique_ptr InstPrinter( - TheTarget->createMCInstPrinter(0, *MAI, *MII, *MRI, *STI)); + TheTarget->createMCInstPrinter(Triple(TripleName), 0, *MAI, *MII, *MRI)); // Load any dylibs requested on the command line. loadDylibs(); // Instantiate a dynamic linker. TrivialMemoryManager MemMgr; - RuntimeDyld Dyld(&MemMgr); + doPreallocation(MemMgr); + RuntimeDyld Dyld(MemMgr, MemMgr); + Dyld.setProcessAllSections(true); + RuntimeDyldChecker Checker(Dyld, Disassembler.get(), InstPrinter.get(), + llvm::dbgs()); + + // FIXME: Preserve buffers until resolveRelocations time to work around a bug + // in RuntimeDyldELF. + // This fixme should be fixed ASAP. This is a very brittle workaround. + std::vector> InputBuffers; // If we don't have any input files, read from stdin. if (!InputFileList.size()) InputFileList.push_back("-"); - for(unsigned i = 0, e = InputFileList.size(); i != e; ++i) { + for (auto &Filename : InputFileList) { // Load the input memory buffer. - std::unique_ptr InputBuffer; - std::unique_ptr LoadedObject; - if (std::error_code ec = - MemoryBuffer::getFileOrSTDIN(InputFileList[i], InputBuffer)) - return Error("unable to read input: '" + ec.message() + "'"); + ErrorOr> InputBuffer = + MemoryBuffer::getFileOrSTDIN(Filename); + + if (std::error_code EC = InputBuffer.getError()) + return Error("unable to read input: '" + EC.message() + "'"); + + ErrorOr> MaybeObj( + ObjectFile::createObjectFile((*InputBuffer)->getMemBufferRef())); + + if (std::error_code EC = MaybeObj.getError()) + return Error("unable to create object file: '" + EC.message() + "'"); + + ObjectFile &Obj = **MaybeObj; + InputBuffers.push_back(std::move(*InputBuffer)); // Load the object file - LoadedObject.reset( - Dyld.loadObject(new ObjectBuffer(InputBuffer.release()))); - if (!LoadedObject) { + Dyld.loadObject(Obj); + if (Dyld.hasError()) { return Error(Dyld.getErrorString()); } } + // Re-map the section addresses into the phony target address space and add + // dummy symbols. + remapSectionsAndSymbols(TheTriple, MemMgr, Checker); + // Resolve all the relocations we can. Dyld.resolveRelocations(); - RuntimeDyldChecker Checker(Dyld, Disassembler.get(), InstPrinter.get(), - llvm::dbgs()); - return checkAllExpressions(Checker); + // Register EH frames. + Dyld.registerEHFrames(); + + int ErrorCode = checkAllExpressions(Checker); + if (Dyld.hasError()) { + errs() << "RTDyld reported an error applying relocations:\n " + << Dyld.getErrorString() << "\n"; + ErrorCode = 1; + } + + return ErrorCode; } int main(int argc, char **argv) { @@ -388,8 +721,12 @@ int main(int argc, char **argv) { switch (Action) { case AC_Execute: return executeInput(); + case AC_PrintDebugLineInfo: + return printLineInfoForInput(/* LoadObjects */ true,/* UseDebugObj */ true); case AC_PrintLineInfo: - return printLineInfoForInput(); + return printLineInfoForInput(/* LoadObjects */ true,/* UseDebugObj */false); + case AC_PrintObjectLineInfo: + return printLineInfoForInput(/* LoadObjects */false,/* UseDebugObj */false); case AC_Verify: return linkAndVerify(); }