//
//===----------------------------------------------------------------------===//
+#define DEBUG_TYPE "interpreter"
#include "Interpreter.h"
-#include "llvm/Instructions.h"
-#include "llvm/DerivedTypes.h"
#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Instructions.h"
+#include "llvm/IntrinsicLowering.h"
+#include "llvm/Intrinsics.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "Support/Statistic.h"
+#include "Support/Debug.h"
#include <cmath> // For fmod
-
-Interpreter *TheEE = 0;
+using namespace llvm;
namespace {
Statistic<> NumDynamicInsts("lli", "Number of dynamic instructions executed");
+
+ Interpreter *TheEE = 0;
}
+
//===----------------------------------------------------------------------===//
// Value Manipulation code
//===----------------------------------------------------------------------===//
-// Operations used by constant expr implementations...
-static GenericValue executeCastOperation(Value *Src, const Type *DestTy,
- ExecutionContext &SF);
static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
const Type *Ty);
+static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+
+GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE,
+ ExecutionContext &SF) {
+ switch (CE->getOpcode()) {
+ case Instruction::Cast:
+ return executeCastOperation(CE->getOperand(0), CE->getType(), SF);
+ case Instruction::GetElementPtr:
+ return executeGEPOperation(CE->getOperand(0), gep_type_begin(CE),
+ gep_type_end(CE), SF);
+ case Instruction::Add:
+ return executeAddInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::Sub:
+ return executeSubInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::Mul:
+ return executeMulInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::Div:
+ return executeDivInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::Rem:
+ return executeRemInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::And:
+ return executeAndInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::Or:
+ return executeOrInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::Xor:
+ return executeXorInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::SetEQ:
+ return executeSetEQInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::SetNE:
+ return executeSetNEInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::SetLE:
+ return executeSetLEInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::SetGE:
+ return executeSetGEInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::SetLT:
+ return executeSetLTInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::SetGT:
+ return executeSetGTInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::Shl:
+ return executeShlInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+ case Instruction::Shr:
+ return executeShrInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ CE->getOperand(0)->getType());
+
+ default:
+ std::cerr << "Unhandled ConstantExpr: " << CE << "\n";
+ abort();
+ return GenericValue();
+ }
+}
GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) {
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
- switch (CE->getOpcode()) {
- case Instruction::Cast:
- return executeCastOperation(CE->getOperand(0), CE->getType(), SF);
- case Instruction::GetElementPtr:
- return TheEE->executeGEPOperation(CE->getOperand(0), CE->op_begin()+1,
- CE->op_end(), SF);
- case Instruction::Add:
- return executeAddInst(getOperandValue(CE->getOperand(0), SF),
- getOperandValue(CE->getOperand(1), SF),
- CE->getType());
- default:
- std::cerr << "Unhandled ConstantExpr: " << CE << "\n";
- abort();
- return GenericValue();
- }
+ return getConstantExprValue(CE, SF);
} else if (Constant *CPV = dyn_cast<Constant>(V)) {
- return TheEE->getConstantValue(CPV);
+ return getConstantValue(CPV);
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
- return PTOGV(TheEE->getPointerToGlobal(GV));
+ return PTOGV(getPointerToGlobal(GV));
} else {
return SF.Values[V];
}
SF.Values[V] = Val;
}
-//===----------------------------------------------------------------------===//
-// Annotation Wrangling code
-//===----------------------------------------------------------------------===//
-
void Interpreter::initializeExecutionEngine() {
TheEE = this;
}
//===----------------------------------------------------------------------===//
void Interpreter::exitCalled(GenericValue GV) {
- ExitCode = GV.SByteVal;
- ECStack.clear();
+ runAtExitHandlers ();
+ exit (GV.IntVal);
}
/// Pop the last stack frame off of ECStack and then copy the result
/// back into the result variable if we are not returning void. The
/// result variable may be the ExitCode, or the Value of the calling
-/// CallInst if there was a previous stack frame. This procedure may
-/// invalidate any ECStack iterators you have.
+/// CallInst if there was a previous stack frame. This method may
+/// invalidate any ECStack iterators you have. This method also takes
+/// care of switching to the normal destination BB, if we are returning
+/// from an invoke.
///
void Interpreter::popStackAndReturnValueToCaller (const Type *RetTy,
GenericValue Result) {
// If we have a previous stack frame, and we have a previous call,
// fill in the return value...
ExecutionContext &CallingSF = ECStack.back();
- if (CallingSF.Caller.getInstruction()) {
+ if (Instruction *I = CallingSF.Caller.getInstruction()) {
if (CallingSF.Caller.getType() != Type::VoidTy) // Save result...
- SetValue(CallingSF.Caller.getInstruction(), Result, CallingSF);
+ SetValue(I, Result, CallingSF);
+ if (InvokeInst *II = dyn_cast<InvokeInst> (I))
+ SwitchToNewBasicBlock (II->getNormalDest (), CallingSF);
CallingSF.Caller = CallSite(); // We returned from the call...
}
}
popStackAndReturnValueToCaller(RetTy, Result);
}
+void Interpreter::visitUnwindInst(UnwindInst &I) {
+ // Unwind stack
+ Instruction *Inst;
+ do {
+ ECStack.pop_back ();
+ if (ECStack.empty ())
+ abort ();
+ Inst = ECStack.back ().Caller.getInstruction ();
+ } while (!(Inst && isa<InvokeInst> (Inst)));
+
+ // Return from invoke
+ ExecutionContext &InvokingSF = ECStack.back ();
+ InvokingSF.Caller = CallSite ();
+
+ // Go to exceptional destination BB of invoke instruction
+ SwitchToNewBasicBlock (cast<InvokeInst> (Inst)->getExceptionalDest (),
+ InvokingSF);
+}
+
void Interpreter::visitBranchInst(BranchInst &I) {
ExecutionContext &SF = ECStack.back();
BasicBlock *Dest;
// getElementOffset - The workhorse for getelementptr.
//
-GenericValue Interpreter::executeGEPOperation(Value *Ptr, User::op_iterator I,
- User::op_iterator E,
+GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
+ gep_type_iterator E,
ExecutionContext &SF) {
assert(isa<PointerType>(Ptr->getType()) &&
"Cannot getElementOffset of a nonpointer type!");
PointerTy Total = 0;
- const Type *Ty = Ptr->getType();
for (; I != E; ++I) {
- if (const StructType *STy = dyn_cast<StructType>(Ty)) {
+ if (const StructType *STy = dyn_cast<StructType>(*I)) {
const StructLayout *SLO = TD.getStructLayout(STy);
- // Indices must be ubyte constants...
- const ConstantUInt *CPU = cast<ConstantUInt>(*I);
- assert(CPU->getType() == Type::UByteTy);
+ const ConstantUInt *CPU = cast<ConstantUInt>(I.getOperand());
unsigned Index = CPU->getValue();
Total += SLO->MemberOffsets[Index];
- Ty = STy->getElementTypes()[Index];
- } else if (const SequentialType *ST = cast<SequentialType>(Ty)) {
+ } else {
+ const SequentialType *ST = cast<SequentialType>(*I);
// Get the index number for the array... which must be long type...
- assert((*I)->getType() == Type::LongTy);
- unsigned Idx = getOperandValue(*I, SF).LongVal;
- Ty = ST->getElementType();
- unsigned Size = TD.getTypeSize(Ty);
- Total += Size*Idx;
+ GenericValue IdxGV = getOperandValue(I.getOperand(), SF);
+
+ uint64_t Idx;
+ switch (I.getOperand()->getType()->getPrimitiveID()) {
+ default: assert(0 && "Illegal getelementptr index for sequential type!");
+ case Type::SByteTyID: Idx = IdxGV.SByteVal; break;
+ case Type::ShortTyID: Idx = IdxGV.ShortVal; break;
+ case Type::IntTyID: Idx = IdxGV.IntVal; break;
+ case Type::LongTyID: Idx = IdxGV.LongVal; break;
+ case Type::UByteTyID: Idx = IdxGV.UByteVal; break;
+ case Type::UShortTyID: Idx = IdxGV.UShortVal; break;
+ case Type::UIntTyID: Idx = IdxGV.UIntVal; break;
+ case Type::ULongTyID: Idx = IdxGV.ULongVal; break;
+ }
+ Total += TD.getTypeSize(ST->getElementType())*Idx;
}
}
void Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) {
ExecutionContext &SF = ECStack.back();
SetValue(&I, TheEE->executeGEPOperation(I.getPointerOperand(),
- I.idx_begin(), I.idx_end(), SF), SF);
+ gep_type_begin(I), gep_type_end(I), SF), SF);
}
void Interpreter::visitLoadInst(LoadInst &I) {
void Interpreter::visitCallSite(CallSite CS) {
ExecutionContext &SF = ECStack.back();
+
+ // Check to see if this is an intrinsic function call...
+ if (Function *F = CS.getCalledFunction())
+ switch (F->getIntrinsicID()) {
+ case Intrinsic::va_start: // va_start: implemented by getFirstVarArg()
+ SetValue(CS.getInstruction(), getFirstVarArg(), SF);
+ return;
+ case Intrinsic::va_end: // va_end is a noop for the interpreter
+ return;
+ case Intrinsic::va_copy: // va_copy: dest = src
+ SetValue(CS.getInstruction(), getOperandValue(*CS.arg_begin(), SF), SF);
+ return;
+ default:
+ // If it is an unknown intrinsic function, using the intrinsic lowering
+ // class to transform it into hopefully tasty LLVM code.
+ //
+ Instruction *Prev = CS.getInstruction()->getPrev();
+ BasicBlock *Parent = CS.getInstruction()->getParent();
+ IL->LowerIntrinsicCall(cast<CallInst>(CS.getInstruction()));
+
+ // Restore the CurInst pointer to the first instruction newly inserted, if
+ // any.
+ if (!Prev) {
+ SF.CurInst = Parent->begin();
+ } else {
+ SF.CurInst = Prev;
+ ++SF.CurInst;
+ }
+ }
+
SF.Caller = CS;
std::vector<GenericValue> ArgVals;
const unsigned NumArgs = SF.Caller.arg_size();
#define IMPLEMENT_SHIFT(OP, TY) \
case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.UByteVal; break
-void Interpreter::visitShl(ShiftInst &I) {
- ExecutionContext &SF = ECStack.back();
- const Type *Ty = I.getOperand(0)->getType();
- GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
- GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
+static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
-
switch (Ty->getPrimitiveID()) {
IMPLEMENT_SHIFT(<<, UByte);
IMPLEMENT_SHIFT(<<, SByte);
default:
std::cout << "Unhandled type for Shl instruction: " << *Ty << "\n";
}
- SetValue(&I, Dest, SF);
+ return Dest;
}
-void Interpreter::visitShr(ShiftInst &I) {
- ExecutionContext &SF = ECStack.back();
- const Type *Ty = I.getOperand(0)->getType();
- GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
- GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
+static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
-
switch (Ty->getPrimitiveID()) {
IMPLEMENT_SHIFT(>>, UByte);
IMPLEMENT_SHIFT(>>, SByte);
std::cout << "Unhandled type for Shr instruction: " << *Ty << "\n";
abort();
}
+ return Dest;
+}
+
+void Interpreter::visitShl(ShiftInst &I) {
+ ExecutionContext &SF = ECStack.back();
+ const Type *Ty = I.getOperand(0)->getType();
+ GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
+ GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
+ GenericValue Dest;
+ Dest = executeShlInst (Src1, Src2, Ty);
+ SetValue(&I, Dest, SF);
+}
+
+void Interpreter::visitShr(ShiftInst &I) {
+ ExecutionContext &SF = ECStack.back();
+ const Type *Ty = I.getOperand(0)->getType();
+ GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
+ GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
+ GenericValue Dest;
+ Dest = executeShrInst (Src1, Src2, Ty);
SetValue(&I, Dest, SF);
}
void Interpreter::visitVANextInst(VANextInst &I) {
ExecutionContext &SF = ECStack.back();
- // Get the incoming valist element. LLI treats the valist as an integer.
+ // Get the incoming valist parameter. LLI treats the valist as a pointer
+ // to the next argument.
GenericValue VAList = getOperandValue(I.getOperand(0), SF);
- // Move to the next operand.
- unsigned Argument = VAList.IntVal++;
- assert(Argument < SF.VarArgs.size() &&
- "Accessing past the last vararg argument!");
+ // Move the pointer to the next vararg.
+ GenericValue *ArgPtr = (GenericValue *) GVTOP (VAList);
+ ++ArgPtr;
+ VAList = PTOGV (ArgPtr);
SetValue(&I, VAList, SF);
}
+#define IMPLEMENT_VAARG(TY) \
+ case Type::TY##TyID: Dest.TY##Val = Src.TY##Val; break
+
+void Interpreter::visitVAArgInst(VAArgInst &I) {
+ ExecutionContext &SF = ECStack.back();
+
+ // Get the incoming valist parameter. LLI treats the valist as a pointer
+ // to the next argument.
+ GenericValue VAList = getOperandValue(I.getOperand(0), SF);
+ assert (GVTOP (VAList) != 0 && "VAList was null in vaarg instruction");
+ GenericValue Dest, Src = *(GenericValue *) GVTOP (VAList);
+ const Type *Ty = I.getType();
+ switch (Ty->getPrimitiveID()) {
+ IMPLEMENT_VAARG(UByte);
+ IMPLEMENT_VAARG(SByte);
+ IMPLEMENT_VAARG(UShort);
+ IMPLEMENT_VAARG(Short);
+ IMPLEMENT_VAARG(UInt);
+ IMPLEMENT_VAARG(Int);
+ IMPLEMENT_VAARG(ULong);
+ IMPLEMENT_VAARG(Long);
+ IMPLEMENT_VAARG(Pointer);
+ IMPLEMENT_VAARG(Float);
+ IMPLEMENT_VAARG(Double);
+ IMPLEMENT_VAARG(Bool);
+ default:
+ std::cout << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
+ abort();
+ }
+
+ // Set the Value of this Instruction.
+ SetValue(&I, Dest, SF);
+}
+
//===----------------------------------------------------------------------===//
// Dispatch and Execution Code
//===----------------------------------------------------------------------===//
// Track the number of dynamic instructions executed.
++NumDynamicInsts;
+ DEBUG(std::cerr << "About to interpret: " << I);
visit(I); // Dispatch to one of the visit* methods...
}
}