#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"
static cl::opt<std::string>
TripleName("triple", cl::desc("Target triple for disassembler"));
+static cl::opt<std::string>
+MCPU("mcpu",
+ cl::desc("Target a specific cpu type (-mcpu=help for details)"),
+ cl::value_desc("cpu-name"),
+ cl::init(""));
+
static cl::list<std::string>
CheckFiles("check",
cl::desc("File containing RuntimeDyld verifier checks."),
static cl::list<std::string>
SpecificSectionMappings("map-section",
- cl::desc("Map a section to a specific address."),
- cl::ZeroOrMore);
+ cl::desc("For -verify only: Map a section to a "
+ "specific address."),
+ cl::ZeroOrMore,
+ cl::Hidden);
+
+static cl::list<std::string>
+DummySymbolMappings("dummy-extern",
+ cl::desc("For -verify only: Inject a symbol into the extern "
+ "symbol table."),
+ cl::ZeroOrMore,
+ cl::Hidden);
/* *** */
// 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 {}
+private:
+ std::map<std::string, uint64_t> DummyExterns;
};
uint8_t *TrivialMemoryManager::allocateCodeSection(uintptr_t Size,
}
void TrivialMemoryManager::invalidateInstructionCache() {
- for (int i = 0, e = FunctionMemory.size(); i != e; ++i)
- sys::Memory::InvalidateInstructionCache(FunctionMemory[i].base(),
- FunctionMemory[i].size());
+ for (auto &FM : FunctionMemory)
+ sys::Memory::InvalidateInstructionCache(FM.base(), FM.size());
- for (int i = 0, e = DataMemory.size(); i != e; ++i)
- sys::Memory::InvalidateInstructionCache(DataMemory[i].base(),
- DataMemory[i].size());
+ for (auto &DM : DataMemory)
+ sys::Memory::InvalidateInstructionCache(DM.base(), DM.size());
}
static const char *ProgramName;
// 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, MemMgr);
// Load the input memory buffer.
ErrorOr<std::unique_ptr<MemoryBuffer>> InputBuffer =
- MemoryBuffer::getFileOrSTDIN(InputFileList[i]);
+ MemoryBuffer::getFileOrSTDIN(File);
if (std::error_code EC = InputBuffer.getError())
return Error("unable to read input: '" + EC.message() + "'");
if (UseDebugObj) {
DebugObj = LoadedObjInfo->getObjectForDebug(Obj);
SymbolObj = DebugObj.getBinary();
+ LoadedObjInfo.reset();
}
}
std::unique_ptr<DIContext> Context(
new DWARFContextInMemory(*SymbolObj,LoadedObjInfo.get()));
- // FIXME: This is generally useful. Figure out a place in lib/Object to
- // put utility functions.
- std::map<object::SectionRef, std::vector<uint64_t>> FuncAddresses;
- if (!isa<ELFObjectFileBase>(SymbolObj)) {
- for (object::SymbolRef Sym : SymbolObj->symbols()) {
- object::SymbolRef::Type SymType;
- if (Sym.getType(SymType))
- continue;
- if (SymType != object::SymbolRef::ST_Function)
- continue;
- uint64_t Addr;
- if (Sym.getAddress(Addr))
- continue;
- object::section_iterator Sec = SymbolObj->section_end();
- if (Sym.getSection(Sec))
- continue;
- std::vector<uint64_t> &Addrs = FuncAddresses[*Sec];
- if (Addrs.empty()) {
- uint64_t SecAddr = Sec->getAddress();
- uint64_t SecSize = Sec->getSize();
- Addrs.push_back(SecAddr + SecSize);
- }
- Addrs.push_back(Addr);
- }
- for (auto &Pair : FuncAddresses) {
- std::vector<uint64_t> &Addrs = Pair.second;
- array_pod_sort(Addrs.begin(), Addrs.end());
- }
- }
+ std::vector<std::pair<SymbolRef, uint64_t>> SymAddr =
+ object::computeSymbolSizes(*SymbolObj);
// Use symbol info to iterate functions in the object.
- for (object::SymbolRef Sym : SymbolObj->symbols()) {
- object::SymbolRef::Type SymType;
- if (Sym.getType(SymType))
- continue;
- if (SymType == object::SymbolRef::ST_Function) {
- StringRef Name;
- uint64_t Addr;
- if (Sym.getName(Name))
+ for (const auto &P : SymAddr) {
+ object::SymbolRef Sym = P.first;
+ if (Sym.getType() == object::SymbolRef::ST_Function) {
+ ErrorOr<StringRef> Name = Sym.getName();
+ if (!Name)
continue;
- if (Sym.getAddress(Addr))
+ ErrorOr<uint64_t> AddrOrErr = Sym.getAddress();
+ if (!AddrOrErr)
continue;
+ uint64_t Addr = *AddrOrErr;
- uint64_t Size;
- if (isa<ELFObjectFileBase>(SymbolObj)) {
- Size = Sym.getSize();
- } else {
- object::section_iterator Sec = SymbolObj->section_end();
- if (Sym.getSection(Sec))
- continue;
- const std::vector<uint64_t> &Addrs = FuncAddresses[*Sec];
- auto AddrI = std::find(Addrs.begin(), Addrs.end(), Addr);
- assert(AddrI != Addrs.end() && (AddrI + 1) != Addrs.end());
- assert(*AddrI == Addr);
- Size = *(AddrI + 1) - Addr;
- }
-
+ 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(SymbolObj->section_end());
- Sym.getSection(Sec);
+ object::section_iterator Sec = *Sym.getSection();
StringRef SecName;
Sec->getName(SecName);
uint64_t SectionLoadAddress =
- LoadedObjInfo->getSectionLoadAddress(SecName);
+ LoadedObjInfo->getSectionLoadAddress(*Sec);
if (SectionLoadAddress != 0)
Addr += SectionLoadAddress - Sec->getAddress();
}
- outs() << "Function: " << Name << ", Size = " << Size << ", Addr = " << Addr << "\n";
+ 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";
}
}
}
// 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.
ErrorOr<std::unique_ptr<MemoryBuffer>> InputBuffer =
- MemoryBuffer::getFileOrSTDIN(InputFileList[i]);
+ MemoryBuffer::getFileOrSTDIN(File);
if (std::error_code EC = InputBuffer.getError())
return Error("unable to read input: '" + EC.message() + "'");
ErrorOr<std::unique_ptr<ObjectFile>> MaybeObj(
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.
std::string ErrorStr;
- sys::Memory::InvalidateInstructionCache(Data.base(), Data.size());
- if (!sys::Memory::setExecutable(Data, &ErrorStr))
+ sys::Memory::InvalidateInstructionCache(FM.base(), FM.size());
+ if (!sys::Memory::setExecutable(FM, &ErrorStr))
return Error("unable to mark function executable: '" + ErrorStr + "'");
}
for (StringRef Mapping : SpecificSectionMappings) {
size_t EqualsIdx = Mapping.find_first_of("=");
- StringRef SectionIDStr = Mapping.substr(0, EqualsIdx);
+ std::string SectionIDStr = Mapping.substr(0, EqualsIdx);
size_t ComaIdx = Mapping.find_first_of(",");
if (ComaIdx == StringRef::npos) {
exit(1);
}
- StringRef FileName = SectionIDStr.substr(0, ComaIdx);
- StringRef SectionName = SectionIDStr.substr(ComaIdx + 1);
+ std::string FileName = SectionIDStr.substr(0, ComaIdx);
+ std::string SectionName = SectionIDStr.substr(ComaIdx + 1);
uint64_t OldAddrInt;
std::string ErrorMsg;
void* OldAddr = reinterpret_cast<void*>(static_cast<uintptr_t>(OldAddrInt));
- StringRef NewAddrStr = Mapping.substr(EqualsIdx + 1);
+ std::string NewAddrStr = Mapping.substr(EqualsIdx + 1);
uint64_t NewAddr;
- if (NewAddrStr.getAsInteger(0, NewAddr)) {
- errs() << "Invalid section address in mapping: " << Mapping << "\n";
+ if (StringRef(NewAddrStr).getAsInteger(0, NewAddr)) {
+ errs() << "Invalid section address in mapping '" << Mapping << "'.\n";
exit(1);
}
// Defaults to zero. Set to something big
// (e.g. 1 << 32) to stress-test stubs, GOTs, etc.
//
-static void remapSections(const llvm::Triple &TargetTriple,
- const TrivialMemoryManager &MemMgr,
- RuntimeDyldChecker &Checker) {
+static void remapSectionsAndSymbols(const llvm::Triple &TargetTriple,
+ TrivialMemoryManager &MemMgr,
+ RuntimeDyldChecker &Checker) {
// Set up a work list (section addr/size pairs).
typedef std::list<std::pair<void*, uint64_t>> WorklistT;
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 '<symbol name>=<addr>'\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
TripleName = TheTriple.getTriple();
std::unique_ptr<MCSubtargetInfo> STI(
- TheTarget->createMCSubtargetInfo(TripleName, "", ""));
+ TheTarget->createMCSubtargetInfo(TripleName, MCPU, ""));
assert(STI && "Unable to create subtarget info!");
std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
// 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.
ErrorOr<std::unique_ptr<MemoryBuffer>> InputBuffer =
- MemoryBuffer::getFileOrSTDIN(InputFileList[i]);
+ MemoryBuffer::getFileOrSTDIN(Filename);
if (std::error_code EC = InputBuffer.getError())
return Error("unable to read input: '" + EC.message() + "'");
}
}
- // Re-map the section addresses into the phony target address space.
- remapSections(TheTriple, MemMgr, Checker);
+ // 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();