LLVM  10.0.0svn
Interpreter.cpp
Go to the documentation of this file.
1 //===- Interpreter.cpp - Top-Level LLVM Interpreter Implementation --------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the top-level functionality for the LLVM interpreter.
10 // This interpreter is designed to be a very simple, portable, inefficient
11 // interpreter.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "Interpreter.h"
17 #include "llvm/IR/DerivedTypes.h"
18 #include "llvm/IR/Module.h"
19 #include <cstring>
20 using namespace llvm;
21 
22 namespace {
23 
24 static struct RegisterInterp {
25  RegisterInterp() { Interpreter::Register(); }
26 } InterpRegistrator;
27 
28 }
29 
30 extern "C" void LLVMLinkInInterpreter() { }
31 
32 /// Create a new interpreter object.
33 ///
34 ExecutionEngine *Interpreter::create(std::unique_ptr<Module> M,
35  std::string *ErrStr) {
36  // Tell this Module to materialize everything and release the GVMaterializer.
37  if (Error Err = M->materializeAll()) {
38  std::string Msg;
39  handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
40  Msg = EIB.message();
41  });
42  if (ErrStr)
43  *ErrStr = Msg;
44  // We got an error, just return 0
45  return nullptr;
46  }
47 
48  return new Interpreter(std::move(M));
49 }
50 
51 //===----------------------------------------------------------------------===//
52 // Interpreter ctor - Initialize stuff
53 //
54 Interpreter::Interpreter(std::unique_ptr<Module> M)
55  : ExecutionEngine(std::move(M)) {
56 
57  memset(&ExitValue.Untyped, 0, sizeof(ExitValue.Untyped));
58  // Initialize the "backend"
59  initializeExecutionEngine();
60  initializeExternalFunctions();
61  emitGlobals();
62 
63  IL = new IntrinsicLowering(getDataLayout());
64 }
65 
67  delete IL;
68 }
69 
71  while (!AtExitHandlers.empty()) {
72  callFunction(AtExitHandlers.back(), None);
73  AtExitHandlers.pop_back();
74  run();
75  }
76 }
77 
78 /// run - Start execution with the specified function and arguments.
79 ///
81  ArrayRef<GenericValue> ArgValues) {
82  assert (F && "Function *F was null at entry to run()");
83 
84  // Try extra hard not to pass extra args to a function that isn't
85  // expecting them. C programmers frequently bend the rules and
86  // declare main() with fewer parameters than it actually gets
87  // passed, and the interpreter barfs if you pass a function more
88  // parameters than it is declared to take. This does not attempt to
89  // take into account gratuitous differences in declared types,
90  // though.
91  const size_t ArgCount = F->getFunctionType()->getNumParams();
92  ArrayRef<GenericValue> ActualArgs =
93  ArgValues.slice(0, std::min(ArgValues.size(), ArgCount));
94 
95  // Set up the function call.
96  callFunction(F, ActualArgs);
97 
98  // Start executing the function.
99  run();
100 
101  return ExitValue;
102 }
static ExecutionEngine * create(std::unique_ptr< Module > M, std::string *ErrorStr=nullptr)
Create an interpreter ExecutionEngine.
Definition: Interpreter.cpp:34
Interpreter(std::unique_ptr< Module > M)
Definition: Interpreter.cpp:54
This class represents lattice values for constants.
Definition: AllocatorList.h:23
unsigned char Untyped[8]
Definition: GenericValue.h:33
virtual std::string message() const
Return the error message as a string.
Definition: Error.h:56
F(f)
const DataLayout & getDataLayout() const
Base class for error info classes.
Definition: Error.h:48
Definition: BitVector.h:937
void callFunction(Function *F, ArrayRef< GenericValue > ArgVals)
Definition: Execution.cpp:2123
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
void emitGlobals()
EmitGlobals - Emit all of the global variables to memory, storing their addresses into GlobalAddress...
static void Register()
Definition: Interpreter.h:96
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
~Interpreter() override
Definition: Interpreter.cpp:66
Abstract interface for implementation execution of LLVM modules, designed to support both interpreter...
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition: Error.h:904
Module.h This file contains the declarations for the Module class.
GenericValue runFunction(Function *F, ArrayRef< GenericValue > ArgValues) override
run - Start execution with the specified function and arguments.
Definition: Interpreter.cpp:80
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:163
void runAtExitHandlers()
runAtExitHandlers - Run any functions registered by the program&#39;s calls to atexit(3), which we intercept and store in AtExitHandlers.
Definition: Interpreter.cpp:70
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array...
Definition: ArrayRef.h:178
void LLVMLinkInInterpreter()
Definition: Interpreter.cpp:30
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157