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/StringMap.h"
15#include "llvm/ADT/OwningPtr.h"
16#include "llvm/ExecutionEngine/RuntimeDyld.h"
17#include "llvm/Object/MachOObject.h"
18#include "llvm/Support/CommandLine.h"
19#include "llvm/Support/ManagedStatic.h"
20#include "llvm/Support/Memory.h"
21#include "llvm/Support/MemoryBuffer.h"
22#include "llvm/Support/raw_ostream.h"
23#include "llvm/Support/system_error.h"
24using namespace llvm;
25using namespace llvm::object;
26
27static cl::list<std::string>
28InputFileList(cl::Positional, cl::ZeroOrMore,
29              cl::desc("<input file>"));
30
31enum ActionType {
32  AC_Execute
33};
34
35static cl::opt<ActionType>
36Action(cl::desc("Action to perform:"),
37       cl::init(AC_Execute),
38       cl::values(clEnumValN(AC_Execute, "execute",
39                             "Load, link, and execute the inputs."),
40                  clEnumValEnd));
41
42static cl::opt<std::string>
43EntryPoint("entry",
44           cl::desc("Function to call as entry point."),
45           cl::init("_main"));
46
47/* *** */
48
49// A trivial memory manager that doesn't do anything fancy, just uses the
50// support library allocation routines directly.
51class TrivialMemoryManager : public RTDyldMemoryManager {
52public:
53  SmallVector<sys::MemoryBlock, 16> FunctionMemory;
54  SmallVector<sys::MemoryBlock, 16> DataMemory;
55
56  uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
57                               unsigned SectionID);
58  uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
59                               unsigned SectionID);
60
61  virtual void *getPointerToNamedFunction(const std::string &Name,
62                                          bool AbortOnFailure = true) {
63    return 0;
64  }
65
66  // Invalidate instruction cache for sections with execute permissions.
67  // Some platforms with separate data cache and instruction cache require
68  // explicit cache flush, otherwise JIT code manipulations (like resolved
69  // relocations) will get to the data cache but not to the instruction cache.
70  virtual void invalidateInstructionCache();
71};
72
73uint8_t *TrivialMemoryManager::allocateCodeSection(uintptr_t Size,
74                                                   unsigned Alignment,
75                                                   unsigned SectionID) {
76  sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, 0, 0);
77  FunctionMemory.push_back(MB);
78  return (uint8_t*)MB.base();
79}
80
81uint8_t *TrivialMemoryManager::allocateDataSection(uintptr_t Size,
82                                                   unsigned Alignment,
83                                                   unsigned SectionID) {
84  sys::MemoryBlock MB = sys::Memory::AllocateRWX(Size, 0, 0);
85  DataMemory.push_back(MB);
86  return (uint8_t*)MB.base();
87}
88
89void TrivialMemoryManager::invalidateInstructionCache() {
90  for (int i = 0, e = FunctionMemory.size(); i != e; ++i)
91    sys::Memory::InvalidateInstructionCache(FunctionMemory[i].base(),
92                                            FunctionMemory[i].size());
93
94  for (int i = 0, e = DataMemory.size(); i != e; ++i)
95    sys::Memory::InvalidateInstructionCache(DataMemory[i].base(),
96                                            DataMemory[i].size());
97}
98
99static const char *ProgramName;
100
101static void Message(const char *Type, const Twine &Msg) {
102  errs() << ProgramName << ": " << Type << ": " << Msg << "\n";
103}
104
105static int Error(const Twine &Msg) {
106  Message("error", Msg);
107  return 1;
108}
109
110/* *** */
111
112static int executeInput() {
113  // Instantiate a dynamic linker.
114  TrivialMemoryManager *MemMgr = new TrivialMemoryManager;
115  RuntimeDyld Dyld(MemMgr);
116
117  // If we don't have any input files, read from stdin.
118  if (!InputFileList.size())
119    InputFileList.push_back("-");
120  for(unsigned i = 0, e = InputFileList.size(); i != e; ++i) {
121    // Load the input memory buffer.
122    OwningPtr<MemoryBuffer> InputBuffer;
123    if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFileList[i],
124                                                     InputBuffer))
125      return Error("unable to read input: '" + ec.message() + "'");
126
127    // Load the object file into it.
128    if (Dyld.loadObject(InputBuffer.take())) {
129      return Error(Dyld.getErrorString());
130    }
131  }
132
133  // Resolve all the relocations we can.
134  Dyld.resolveRelocations();
135  // Clear instruction cache before code will be executed.
136  MemMgr->invalidateInstructionCache();
137
138  // FIXME: Error out if there are unresolved relocations.
139
140  // Get the address of the entry point (_main by default).
141  void *MainAddress = Dyld.getSymbolAddress(EntryPoint);
142  if (MainAddress == 0)
143    return Error("no definition for '" + EntryPoint + "'");
144
145  // Invalidate the instruction cache for each loaded function.
146  for (unsigned i = 0, e = MemMgr->FunctionMemory.size(); i != e; ++i) {
147    sys::MemoryBlock &Data = MemMgr->FunctionMemory[i];
148    // Make sure the memory is executable.
149    std::string ErrorStr;
150    sys::Memory::InvalidateInstructionCache(Data.base(), Data.size());
151    if (!sys::Memory::setExecutable(Data, &ErrorStr))
152      return Error("unable to mark function executable: '" + ErrorStr + "'");
153  }
154
155  // Dispatch to _main().
156  errs() << "loaded '" << EntryPoint << "' at: " << (void*)MainAddress << "\n";
157
158  int (*Main)(int, const char**) =
159    (int(*)(int,const char**)) uintptr_t(MainAddress);
160  const char **Argv = new const char*[2];
161  // Use the name of the first input object module as argv[0] for the target.
162  Argv[0] = InputFileList[0].c_str();
163  Argv[1] = 0;
164  return Main(1, Argv);
165}
166
167int main(int argc, char **argv) {
168  ProgramName = argv[0];
169  llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
170
171  cl::ParseCommandLineOptions(argc, argv, "llvm MC-JIT tool\n");
172
173  switch (Action) {
174  case AC_Execute:
175    return executeInput();
176  }
177}
178