1 //===-- llvm-rtdyld.cpp - MCJIT Testing Tool ------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This is a testing tool for use with the MC-JIT LLVM components. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/ADT/OwningPtr.h" 15 #include "llvm/ADT/StringMap.h" 16 #include "llvm/DebugInfo/DIContext.h" 17 #include "llvm/ExecutionEngine/ObjectBuffer.h" 18 #include "llvm/ExecutionEngine/ObjectImage.h" 19 #include "llvm/ExecutionEngine/RuntimeDyld.h" 20 #include "llvm/Object/MachO.h" 21 #include "llvm/Support/CommandLine.h" 22 #include "llvm/Support/ManagedStatic.h" 23 #include "llvm/Support/Memory.h" 24 #include "llvm/Support/MemoryBuffer.h" 25 #include "llvm/Support/raw_ostream.h" 26 #include "llvm/Support/system_error.h" 27 using namespace llvm; 28 using namespace llvm::object; 29 30 static cl::list<std::string> 31 InputFileList(cl::Positional, cl::ZeroOrMore, 32 cl::desc("<input file>")); 33 34 enum ActionType { 35 AC_Execute, 36 AC_PrintLineInfo 37 }; 38 39 static cl::opt<ActionType> 40 Action(cl::desc("Action to perform:"), 41 cl::init(AC_Execute), 42 cl::values(clEnumValN(AC_Execute, "execute", 43 "Load, link, and execute the inputs."), 44 clEnumValN(AC_PrintLineInfo, "printline", 45 "Load, link, and print line information for each function."), 46 clEnumValEnd)); 47 48 static cl::opt<std::string> 49 EntryPoint("entry", 50 cl::desc("Function to call as entry point."), 51 cl::init("_main")); 52 53 /* *** */ 54 55 // A trivial memory manager that doesn't do anything fancy, just uses the 56 // support library allocation routines directly. 57 class TrivialMemoryManager : public RTDyldMemoryManager { 58 public: 59 SmallVector<sys::MemoryBlock, 16> FunctionMemory; 60 SmallVector<sys::MemoryBlock, 16> DataMemory; 61 62 uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment, 63 unsigned SectionID); 64 uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment, 65 unsigned SectionID, bool IsReadOnly); 66 67 virtual void *getPointerToNamedFunction(const std::string &Name, 68 bool AbortOnFailure = true) { 69 return 0; 70 } 71 72 bool finalizeMemory(std::string *ErrMsg) { return false; } 73 74 // Invalidate instruction cache for sections with execute permissions. 75 // Some platforms with separate data cache and instruction cache require 76 // explicit cache flush, otherwise JIT code manipulations (like resolved 77 // relocations) will get to the data cache but not to the instruction cache. 78 virtual void invalidateInstructionCache(); 79 }; 80 81 uint8_t *TrivialMemoryManager::allocateCodeSection(uintptr_t Size, 82 unsigned Alignment, 83 unsigned SectionID) { 84 sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, 0, 0); 85 FunctionMemory.push_back(MB); 86 return (uint8_t*)MB.base(); 87 } 88 89 uint8_t *TrivialMemoryManager::allocateDataSection(uintptr_t Size, 90 unsigned Alignment, 91 unsigned SectionID, 92 bool IsReadOnly) { 93 sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, 0, 0); 94 DataMemory.push_back(MB); 95 return (uint8_t*)MB.base(); 96 } 97 98 void TrivialMemoryManager::invalidateInstructionCache() { 99 for (int i = 0, e = FunctionMemory.size(); i != e; ++i) 100 sys::Memory::InvalidateInstructionCache(FunctionMemory[i].base(), 101 FunctionMemory[i].size()); 102 103 for (int i = 0, e = DataMemory.size(); i != e; ++i) 104 sys::Memory::InvalidateInstructionCache(DataMemory[i].base(), 105 DataMemory[i].size()); 106 } 107 108 static const char *ProgramName; 109 110 static void Message(const char *Type, const Twine &Msg) { 111 errs() << ProgramName << ": " << Type << ": " << Msg << "\n"; 112 } 113 114 static int Error(const Twine &Msg) { 115 Message("error", Msg); 116 return 1; 117 } 118 119 /* *** */ 120 121 static int printLineInfoForInput() { 122 // If we don't have any input files, read from stdin. 123 if (!InputFileList.size()) 124 InputFileList.push_back("-"); 125 for(unsigned i = 0, e = InputFileList.size(); i != e; ++i) { 126 // Instantiate a dynamic linker. 127 TrivialMemoryManager MemMgr; 128 RuntimeDyld Dyld(&MemMgr); 129 130 // Load the input memory buffer. 131 OwningPtr<MemoryBuffer> InputBuffer; 132 OwningPtr<ObjectImage> LoadedObject; 133 if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFileList[i], 134 InputBuffer)) 135 return Error("unable to read input: '" + ec.message() + "'"); 136 137 // Load the object file 138 LoadedObject.reset(Dyld.loadObject(new ObjectBuffer(InputBuffer.take()))); 139 if (!LoadedObject) { 140 return Error(Dyld.getErrorString()); 141 } 142 143 // Resolve all the relocations we can. 144 Dyld.resolveRelocations(); 145 146 OwningPtr<DIContext> Context(DIContext::getDWARFContext(LoadedObject->getObjectFile())); 147 148 // Use symbol info to iterate functions in the object. 149 error_code ec; 150 for (object::symbol_iterator I = LoadedObject->begin_symbols(), 151 E = LoadedObject->end_symbols(); 152 I != E && !ec; 153 I.increment(ec)) { 154 object::SymbolRef::Type SymType; 155 if (I->getType(SymType)) continue; 156 if (SymType == object::SymbolRef::ST_Function) { 157 StringRef Name; 158 uint64_t Addr; 159 uint64_t Size; 160 if (I->getName(Name)) continue; 161 if (I->getAddress(Addr)) continue; 162 if (I->getSize(Size)) continue; 163 164 outs() << "Function: " << Name << ", Size = " << Size << "\n"; 165 166 DILineInfoTable Lines = Context->getLineInfoForAddressRange(Addr, Size); 167 DILineInfoTable::iterator Begin = Lines.begin(); 168 DILineInfoTable::iterator End = Lines.end(); 169 for (DILineInfoTable::iterator It = Begin; It != End; ++It) { 170 outs() << " Line info @ " << It->first - Addr << ": " 171 << It->second.getFileName() 172 << ", line:" << It->second.getLine() << "\n"; 173 } 174 } 175 } 176 } 177 178 return 0; 179 } 180 181 static int executeInput() { 182 // Instantiate a dynamic linker. 183 TrivialMemoryManager MemMgr; 184 RuntimeDyld Dyld(&MemMgr); 185 186 // If we don't have any input files, read from stdin. 187 if (!InputFileList.size()) 188 InputFileList.push_back("-"); 189 for(unsigned i = 0, e = InputFileList.size(); i != e; ++i) { 190 // Load the input memory buffer. 191 OwningPtr<MemoryBuffer> InputBuffer; 192 OwningPtr<ObjectImage> LoadedObject; 193 if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFileList[i], 194 InputBuffer)) 195 return Error("unable to read input: '" + ec.message() + "'"); 196 197 // Load the object file 198 LoadedObject.reset(Dyld.loadObject(new ObjectBuffer(InputBuffer.take()))); 199 if (!LoadedObject) { 200 return Error(Dyld.getErrorString()); 201 } 202 } 203 204 // Resolve all the relocations we can. 205 Dyld.resolveRelocations(); 206 // Clear instruction cache before code will be executed. 207 MemMgr.invalidateInstructionCache(); 208 209 // FIXME: Error out if there are unresolved relocations. 210 211 // Get the address of the entry point (_main by default). 212 void *MainAddress = Dyld.getSymbolAddress(EntryPoint); 213 if (MainAddress == 0) 214 return Error("no definition for '" + EntryPoint + "'"); 215 216 // Invalidate the instruction cache for each loaded function. 217 for (unsigned i = 0, e = MemMgr.FunctionMemory.size(); i != e; ++i) { 218 sys::MemoryBlock &Data = MemMgr.FunctionMemory[i]; 219 // Make sure the memory is executable. 220 std::string ErrorStr; 221 sys::Memory::InvalidateInstructionCache(Data.base(), Data.size()); 222 if (!sys::Memory::setExecutable(Data, &ErrorStr)) 223 return Error("unable to mark function executable: '" + ErrorStr + "'"); 224 } 225 226 // Dispatch to _main(). 227 errs() << "loaded '" << EntryPoint << "' at: " << (void*)MainAddress << "\n"; 228 229 int (*Main)(int, const char**) = 230 (int(*)(int,const char**)) uintptr_t(MainAddress); 231 const char **Argv = new const char*[2]; 232 // Use the name of the first input object module as argv[0] for the target. 233 Argv[0] = InputFileList[0].c_str(); 234 Argv[1] = 0; 235 return Main(1, Argv); 236 } 237 238 int main(int argc, char **argv) { 239 ProgramName = argv[0]; 240 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 241 242 cl::ParseCommandLineOptions(argc, argv, "llvm MC-JIT tool\n"); 243 244 switch (Action) { 245 case AC_Execute: 246 return executeInput(); 247 case AC_PrintLineInfo: 248 return printLineInfoForInput(); 249 } 250 } 251
