13#ifndef LLVM_LIB_EXECUTIONENGINE_INTERPRETER_INTERPRETER_H
14#define LLVM_LIB_EXECUTIONENGINE_INTERPRETER_INTERPRETER_H
26class IntrinsicLowering;
27template<
typename T>
class generic_gep_type_iterator;
37 std::vector<void *> Allocations;
47 for (
void *Allocation : Allocations)
51 void add(
void *Mem) { Allocations.push_back(Mem); }
65 std::map<Value *, GenericValue>
Values;
80 std::vector<ExecutionContext> ECStack;
84 std::vector<Function*> AtExitHandlers;
102 std::string *ErrorStr =
nullptr);
110 bool AbortOnFailure =
true)
override {
180 AtExitHandlers.push_back(
F);
184 return &(ECStack.back ().VarArgs[0]);
197 void *getPointerToFunction(
Function *
F)
override {
return (
void*)
F; }
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);
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
AllocaHolder & operator=(AllocaHolder &&RHS)=default
AllocaHolder(AllocaHolder &&)=default
an instruction to allocate memory on the stack
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
InstListType::iterator iterator
Instruction iterators...
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...
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 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
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.
This class represents a cast from an integer to a pointer.
void visitSIToFPInst(SIToFPInst &I)
void visitFCmpInst(FCmpInst &I)
void visitPtrToIntInst(PtrToIntInst &I)
void visitPHINode(PHINode &PN)
void visitShuffleVectorInst(ShuffleVectorInst &I)
void addAtExitHandler(Function *F)
void visitCallBase(CallBase &I)
void visitAllocaInst(AllocaInst &I)
void visitSelectInst(SelectInst &I)
void exitCalled(GenericValue GV)
void visitReturnInst(ReturnInst &I)
void visitIntToPtrInst(IntToPtrInst &I)
void visitUnreachableInst(UnreachableInst &I)
void visitICmpInst(ICmpInst &I)
void visitLShr(BinaryOperator &I)
void visitUIToFPInst(UIToFPInst &I)
void visitIndirectBrInst(IndirectBrInst &I)
void visitInsertValueInst(InsertValueInst &I)
GenericValue * getFirstVarArg()
void runAtExitHandlers()
runAtExitHandlers - Run any functions registered by the program's calls to atexit(3),...
void visitBranchInst(BranchInst &I)
void visitVAArgInst(VAArgInst &I)
void visitStoreInst(StoreInst &I)
void visitExtractValueInst(ExtractValueInst &I)
void visitSwitchInst(SwitchInst &I)
void visitExtractElementInst(ExtractElementInst &I)
void * getPointerToNamedFunction(StringRef Name, bool AbortOnFailure=true) override
getPointerToNamedFunction - This method returns the address of the specified function by using the dl...
void visitVACopyInst(VACopyInst &I)
void visitVAEndInst(VAEndInst &I)
void visitTruncInst(TruncInst &I)
void visitFPToUIInst(FPToUIInst &I)
void visitLoadInst(LoadInst &I)
void visitGetElementPtrInst(GetElementPtrInst &I)
void callFunction(Function *F, ArrayRef< GenericValue > ArgVals)
void visitInsertElementInst(InsertElementInst &I)
void visitUnaryOperator(UnaryOperator &I)
GenericValue runFunction(Function *F, ArrayRef< GenericValue > ArgValues) override
run - Start execution with the specified function and arguments.
void visitFPExtInst(FPExtInst &I)
void visitVAStartInst(VAStartInst &I)
void visitBitCastInst(BitCastInst &I)
void visitSExtInst(SExtInst &I)
void visitAShr(BinaryOperator &I)
GenericValue callExternalFunction(Function *F, ArrayRef< GenericValue > ArgVals)
void visitFPTruncInst(FPTruncInst &I)
void visitBinaryOperator(BinaryOperator &I)
void visitShl(BinaryOperator &I)
void visitZExtInst(ZExtInst &I)
void visitFPToSIInst(FPToSIInst &I)
void visitIntrinsicInst(IntrinsicInst &I)
static ExecutionEngine * create(std::unique_ptr< Module > M, std::string *ErrorStr=nullptr)
Create an interpreter ExecutionEngine.
void visitInstruction(Instruction &I)
A wrapper class for inspecting calls to intrinsic functions.
An instruction for reading from memory.
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.
StringRef - Represent a constant reference to a string, i.e.
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.
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.
std::vector< GenericValue > ValuePlaneTy
generic_gep_type_iterator<> gep_type_iterator
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
BasicBlock::iterator CurInst
std::map< Value *, GenericValue > Values
std::vector< GenericValue > VarArgs