1 //===-- RuntimeDyld.h - Run-time dynamic linker for MC-JIT ------*- C++ -*-===// 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 // Interface for the runtime dynamic linker facilities of the MC-JIT. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_RUNTIME_DYLD_H 15 #define LLVM_RUNTIME_DYLD_H 16 17 #include "llvm/ADT/StringRef.h" 18 #include "llvm/Support/Memory.h" 19 20 namespace llvm { 21 22 class RuntimeDyldImpl; 23 class MemoryBuffer; 24 25 // RuntimeDyld clients often want to handle the memory management of 26 // what gets placed where. For JIT clients, this is an abstraction layer 27 // over the JITMemoryManager, which references objects by their source 28 // representations in LLVM IR. 29 // FIXME: As the RuntimeDyld fills out, additional routines will be needed 30 // for the varying types of objects to be allocated. 31 class RTDyldMemoryManager { 32 RTDyldMemoryManager(const RTDyldMemoryManager&); // DO NOT IMPLEMENT 33 void operator=(const RTDyldMemoryManager&); // DO NOT IMPLEMENT 34 public: RTDyldMemoryManager()35 RTDyldMemoryManager() {} 36 virtual ~RTDyldMemoryManager(); 37 38 /// allocateCodeSection - Allocate a memory block of (at least) the given 39 /// size suitable for executable code. 40 virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment, 41 unsigned SectionID) = 0; 42 43 /// allocateDataSection - Allocate a memory block of (at least) the given 44 /// size suitable for data. 45 virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment, 46 unsigned SectionID) = 0; 47 48 virtual void *getPointerToNamedFunction(const std::string &Name, 49 bool AbortOnFailure = true) = 0; 50 }; 51 52 class RuntimeDyld { 53 RuntimeDyld(const RuntimeDyld &); // DO NOT IMPLEMENT 54 void operator=(const RuntimeDyld &); // DO NOT IMPLEMENT 55 56 // RuntimeDyldImpl is the actual class. RuntimeDyld is just the public 57 // interface. 58 RuntimeDyldImpl *Dyld; 59 RTDyldMemoryManager *MM; 60 protected: 61 // Change the address associated with a section when resolving relocations. 62 // Any relocations already associated with the symbol will be re-resolved. 63 void reassignSectionAddress(unsigned SectionID, uint64_t Addr); 64 public: 65 RuntimeDyld(RTDyldMemoryManager*); 66 ~RuntimeDyld(); 67 68 bool loadObject(MemoryBuffer *InputBuffer); 69 // Get the address of our local copy of the symbol. This may or may not 70 // be the address used for relocation (clients can copy the data around 71 // and resolve relocatons based on where they put it). 72 void *getSymbolAddress(StringRef Name); 73 // Resolve the relocations for all symbols we currently know about. 74 void resolveRelocations(); 75 76 /// mapSectionAddress - map a section to its target address space value. 77 /// Map the address of a JIT section as returned from the memory manager 78 /// to the address in the target process as the running code will see it. 79 /// This is the address which will be used for relocation resolution. 80 void mapSectionAddress(void *LocalAddress, uint64_t TargetAddress); 81 82 StringRef getErrorString(); 83 }; 84 85 } // end namespace llvm 86 87 #endif 88