LLVM 19.0.0git
Interpreter.h
Go to the documentation of this file.
1//===-- Interpreter.h ------------------------------------------*- C++ -*--===//
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 header file defines the interpreter structure
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_LIB_EXECUTIONENGINE_INTERPRETER_INTERPRETER_H
14#define LLVM_LIB_EXECUTIONENGINE_INTERPRETER_INTERPRETER_H
15
18#include "llvm/IR/DataLayout.h"
19#include "llvm/IR/Function.h"
20#include "llvm/IR/InstVisitor.h"
24namespace llvm {
25
26class IntrinsicLowering;
27template<typename T> class generic_gep_type_iterator;
28class ConstantExpr;
29typedef generic_gep_type_iterator<User::const_op_iterator> gep_type_iterator;
30
31
32// AllocaHolder - Object to track all of the blocks of memory allocated by
33// alloca. When the function returns, this object is popped off the execution
34// stack, which causes the dtor to be run, which frees all the alloca'd memory.
35//
37 std::vector<void *> Allocations;
38
39public:
40 AllocaHolder() = default;
41
42 // Make this type move-only.
45
47 for (void *Allocation : Allocations)
48 free(Allocation);
49 }
50
51 void add(void *Mem) { Allocations.push_back(Mem); }
52};
53
54typedef std::vector<GenericValue> ValuePlaneTy;
55
56// ExecutionContext struct - This struct represents one stack frame currently
57// executing.
58//
60 Function *CurFunction;// The currently executing function
61 BasicBlock *CurBB; // The currently executing BB
62 BasicBlock::iterator CurInst; // The next instruction to execute
63 CallBase *Caller; // Holds the call that called subframes.
64 // NULL if main func or debugger invoked fn
65 std::map<Value *, GenericValue> Values; // LLVM values used in this invocation
66 std::vector<GenericValue> VarArgs; // Values passed through an ellipsis
67 AllocaHolder Allocas; // Track memory allocated by alloca
68
69 ExecutionContext() : CurFunction(nullptr), CurBB(nullptr), CurInst(nullptr) {}
70};
71
72// Interpreter - This class represents the entirety of the interpreter.
73//
74class Interpreter : public ExecutionEngine, public InstVisitor<Interpreter> {
75 GenericValue ExitValue; // The return value of the called function
77
78 // The runtime stack of executing code. The top of the stack is the current
79 // function record.
80 std::vector<ExecutionContext> ECStack;
81
82 // AtExitHandlers - List of functions to call when the program exits,
83 // registered with the atexit() library function.
84 std::vector<Function*> AtExitHandlers;
85
86public:
87 explicit Interpreter(std::unique_ptr<Module> M);
88 ~Interpreter() override;
89
90 /// runAtExitHandlers - Run any functions registered by the program's calls to
91 /// atexit(3), which we intercept and store in AtExitHandlers.
92 ///
93 void runAtExitHandlers();
94
95 static void Register() {
97 }
98
99 /// Create an interpreter ExecutionEngine.
100 ///
101 static ExecutionEngine *create(std::unique_ptr<Module> M,
102 std::string *ErrorStr = nullptr);
103
104 /// run - Start execution with the specified function and arguments.
105 ///
107 ArrayRef<GenericValue> ArgValues) override;
108
110 bool AbortOnFailure = true) override {
111 // FIXME: not implemented.
112 return nullptr;
113 }
114
115 // Methods used to execute code:
116 // Place a call on the stack
118 void run(); // Execute instructions until nothing left to do
119
120 // Opcode Implementations
125
128 void visitICmpInst(ICmpInst &I);
129 void visitFCmpInst(FCmpInst &I);
131 void visitLoadInst(LoadInst &I);
135 llvm_unreachable("PHI nodes already handled!");
136 }
138 void visitZExtInst(ZExtInst &I);
139 void visitSExtInst(SExtInst &I);
150
155 void visitCallBase(CallBase &I);
157
161
166
169
171 errs() << I << "\n";
172 llvm_unreachable("Instruction not interpretable yet!");
173 }
174
176 ArrayRef<GenericValue> ArgVals);
177 void exitCalled(GenericValue GV);
178
180 AtExitHandlers.push_back(F);
181 }
182
184 return &(ECStack.back ().VarArgs[0]);
185 }
186
187private: // Helper functions
188 GenericValue executeGEPOperation(Value *Ptr, gep_type_iterator I,
190
191 // SwitchToNewBasicBlock - Start execution in a new basic block and run any
192 // PHI nodes in the top of the block. This is used for intraprocedural
193 // control flow.
194 //
195 void SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF);
196
197 void *getPointerToFunction(Function *F) override { return (void*)F; }
198
199 void initializeExecutionEngine() { }
200 void initializeExternalFunctions();
201 GenericValue getConstantExprValue(ConstantExpr *CE, ExecutionContext &SF);
202 GenericValue getOperandValue(Value *V, ExecutionContext &SF);
203 GenericValue executeTruncInst(Value *SrcVal, Type *DstTy,
204 ExecutionContext &SF);
205 GenericValue executeSExtInst(Value *SrcVal, Type *DstTy,
206 ExecutionContext &SF);
207 GenericValue executeZExtInst(Value *SrcVal, Type *DstTy,
208 ExecutionContext &SF);
209 GenericValue executeFPTruncInst(Value *SrcVal, Type *DstTy,
210 ExecutionContext &SF);
211 GenericValue executeFPExtInst(Value *SrcVal, Type *DstTy,
212 ExecutionContext &SF);
213 GenericValue executeFPToUIInst(Value *SrcVal, Type *DstTy,
214 ExecutionContext &SF);
215 GenericValue executeFPToSIInst(Value *SrcVal, Type *DstTy,
216 ExecutionContext &SF);
217 GenericValue executeUIToFPInst(Value *SrcVal, Type *DstTy,
218 ExecutionContext &SF);
219 GenericValue executeSIToFPInst(Value *SrcVal, Type *DstTy,
220 ExecutionContext &SF);
221 GenericValue executePtrToIntInst(Value *SrcVal, Type *DstTy,
222 ExecutionContext &SF);
223 GenericValue executeIntToPtrInst(Value *SrcVal, Type *DstTy,
224 ExecutionContext &SF);
225 GenericValue executeBitCastInst(Value *SrcVal, Type *DstTy,
226 ExecutionContext &SF);
227 void popStackAndReturnValueToCaller(Type *RetTy, GenericValue Result);
228
229};
230
231} // End llvm namespace
232
233#endif
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
return RetTy
std::string Name
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
Value * RHS
AllocaHolder()=default
AllocaHolder & operator=(AllocaHolder &&RHS)=default
void add(void *Mem)
Definition: Interpreter.h:51
AllocaHolder(AllocaHolder &&)=default
an instruction to allocate memory on the stack
Definition: Instructions.h:59
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:165
This class represents a no-op cast from one type to another.
Conditional or Unconditional Branch instruction.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1467
Abstract interface for implementation execution of LLVM modules, designed to support both interpreter...
static ExecutionEngine *(* InterpCtor)(std::unique_ptr< Module > M, std::string *ErrorStr)
This instruction extracts a single (scalar) element from a VectorType value.
This instruction extracts a struct member or array element value from an aggregate value.
This instruction compares its operands according to the predicate given to the constructor.
This class represents an extension of floating point types.
This class represents a cast from floating point to signed integer.
This class represents a cast from floating point to unsigned integer.
This class represents a truncation of floating point types.
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
Definition: Instructions.h:973
This instruction compares its operands according to the predicate given to the constructor.
Indirect Branch Instruction.
This instruction inserts a single (scalar) element into a VectorType value.
This instruction inserts a struct field of array element value into an aggregate value.
Base class for instruction visitors.
Definition: InstVisitor.h:78
This class represents a cast from an integer to a pointer.
void visitSIToFPInst(SIToFPInst &I)
Definition: Execution.cpp:1732
void visitFCmpInst(FCmpInst &I)
Definition: Execution.cpp:665
void visitPtrToIntInst(PtrToIntInst &I)
Definition: Execution.cpp:1747
void visitPHINode(PHINode &PN)
Definition: Interpreter.h:134
void visitShuffleVectorInst(ShuffleVectorInst &I)
Definition: Execution.cpp:1859
void addAtExitHandler(Function *F)
Definition: Interpreter.h:179
static void Register()
Definition: Interpreter.h:95
~Interpreter() override
Definition: Interpreter.cpp:66
void visitCallBase(CallBase &I)
Definition: Execution.cpp:1158
void visitAllocaInst(AllocaInst &I)
Definition: Execution.cpp:1017
void visitSelectInst(SelectInst &I)
Definition: Execution.cpp:861
void exitCalled(GenericValue GV)
Definition: Execution.cpp:875
void visitReturnInst(ReturnInst &I)
Definition: Execution.cpp:918
void visitIntToPtrInst(IntToPtrInst &I)
Definition: Execution.cpp:1752
void visitUnreachableInst(UnreachableInst &I)
Definition: Execution.cpp:932
void visitICmpInst(ICmpInst &I)
Definition: Execution.cpp:332
void visitLShr(BinaryOperator &I)
Definition: Execution.cpp:1213
void visitUIToFPInst(UIToFPInst &I)
Definition: Execution.cpp:1727
void visitIndirectBrInst(IndirectBrInst &I)
Definition: Execution.cpp:968
void visitInsertValueInst(InsertValueInst &I)
Definition: Execution.cpp:1969
GenericValue * getFirstVarArg()
Definition: Interpreter.h:183
void runAtExitHandlers()
runAtExitHandlers - Run any functions registered by the program's calls to atexit(3),...
Definition: Interpreter.cpp:70
void visitBranchInst(BranchInst &I)
Definition: Execution.cpp:936
void visitVAArgInst(VAArgInst &I)
Definition: Execution.cpp:1765
void visitStoreInst(StoreInst &I)
Definition: Execution.cpp:1104
void visitExtractValueInst(ExtractValueInst &I)
Definition: Execution.cpp:1926
void visitSwitchInst(SwitchInst &I)
Definition: Execution.cpp:949
void visitExtractElementInst(ExtractElementInst &I)
Definition: Execution.cpp:1794
void * getPointerToNamedFunction(StringRef Name, bool AbortOnFailure=true) override
getPointerToNamedFunction - This method returns the address of the specified function by using the dl...
Definition: Interpreter.h:109
void visitVACopyInst(VACopyInst &I)
Definition: Execution.cpp:1130
void visitVAEndInst(VAEndInst &I)
Definition: Execution.cpp:1126
void visitTruncInst(TruncInst &I)
Definition: Execution.cpp:1702
void visitFPToUIInst(FPToUIInst &I)
Definition: Execution.cpp:1737
void visitLoadInst(LoadInst &I)
Definition: Execution.cpp:1093
void visitGetElementPtrInst(GetElementPtrInst &I)
Definition: Execution.cpp:1087
void callFunction(Function *F, ArrayRef< GenericValue > ArgVals)
Definition: Execution.cpp:2119
void visitInsertElementInst(InsertElementInst &I)
Definition: Execution.cpp:1827
void visitUnaryOperator(UnaryOperator &I)
Definition: Execution.cpp:62
GenericValue runFunction(Function *F, ArrayRef< GenericValue > ArgValues) override
run - Start execution with the specified function and arguments.
Definition: Interpreter.cpp:80
void visitFPExtInst(FPExtInst &I)
Definition: Execution.cpp:1722
void visitVAStartInst(VAStartInst &I)
Definition: Execution.cpp:1118
void visitBitCastInst(BitCastInst &I)
Definition: Execution.cpp:1757
void visitSExtInst(SExtInst &I)
Definition: Execution.cpp:1707
void visitAShr(BinaryOperator &I)
Definition: Execution.cpp:1240
GenericValue callExternalFunction(Function *F, ArrayRef< GenericValue > ArgVals)
void visitFPTruncInst(FPTruncInst &I)
Definition: Execution.cpp:1717
void visitBinaryOperator(BinaryOperator &I)
Definition: Execution.cpp:736
void visitShl(BinaryOperator &I)
Definition: Execution.cpp:1186
void visitZExtInst(ZExtInst &I)
Definition: Execution.cpp:1712
void visitFPToSIInst(FPToSIInst &I)
Definition: Execution.cpp:1742
void visitIntrinsicInst(IntrinsicInst &I)
Definition: Execution.cpp:1135
static ExecutionEngine * create(std::unique_ptr< Module > M, std::string *ErrorStr=nullptr)
Create an interpreter ExecutionEngine.
Definition: Interpreter.cpp:34
void visitInstruction(Instruction &I)
Definition: Interpreter.h:170
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:47
An instruction for reading from memory.
Definition: Instructions.h:184
This class represents a cast from a pointer to an integer.
Return a value (possibly void), from a function.
This class represents a sign extension of integer types.
This class represents a cast from signed integer to floating point.
This class represents the LLVM 'select' instruction.
This instruction constructs a fixed permutation of two input vectors.
An instruction for storing to memory.
Definition: Instructions.h:317
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Multiway switch.
This class represents a truncation of integer types.
This class represents a cast unsigned integer to floating point.
This function has undefined behavior.
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
This represents the llvm.va_copy intrinsic.
This represents the llvm.va_end intrinsic.
This represents the llvm.va_start intrinsic.
LLVM Value Representation.
Definition: Value.h:74
This class represents zero extension of integer types.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::vector< GenericValue > ValuePlaneTy
Definition: Interpreter.h:54
generic_gep_type_iterator<> gep_type_iterator
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
AllocaHolder Allocas
Definition: Interpreter.h:67
BasicBlock::iterator CurInst
Definition: Interpreter.h:62
std::map< Value *, GenericValue > Values
Definition: Interpreter.h:65
std::vector< GenericValue > VarArgs
Definition: Interpreter.h:66
Function * CurFunction
Definition: Interpreter.h:60
BasicBlock * CurBB
Definition: Interpreter.h:61