#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Instructions.h"
-#include "llvm/IntrinsicLowering.h"
+#include "llvm/CodeGen/IntrinsicLowering.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
-#include "Support/Statistic.h"
-#include "Support/Debug.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/Support/Debug.h"
#include <cmath> // For fmod
using namespace llvm;
const Type *Ty);
static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
const Type *Ty);
-
+static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
+ GenericValue Src3);
+
GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE,
ExecutionContext &SF) {
switch (CE->getOpcode()) {
return executeShrInst(getOperandValue(CE->getOperand(0), SF),
getOperandValue(CE->getOperand(1), SF),
CE->getOperand(0)->getType());
-
+ case Instruction::Select:
+ return executeSelectInst(getOperandValue(CE->getOperand(0), SF),
+ getOperandValue(CE->getOperand(1), SF),
+ getOperandValue(CE->getOperand(2), SF));
default:
- std::cerr << "Unhandled ConstantExpr: " << CE << "\n";
+ std::cerr << "Unhandled ConstantExpr: " << *CE << "\n";
abort();
return GenericValue();
}
static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(+, UByte);
IMPLEMENT_BINARY_OPERATOR(+, SByte);
IMPLEMENT_BINARY_OPERATOR(+, UShort);
static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(-, UByte);
IMPLEMENT_BINARY_OPERATOR(-, SByte);
IMPLEMENT_BINARY_OPERATOR(-, UShort);
static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(*, UByte);
IMPLEMENT_BINARY_OPERATOR(*, SByte);
IMPLEMENT_BINARY_OPERATOR(*, UShort);
IMPLEMENT_BINARY_OPERATOR(*, Float);
IMPLEMENT_BINARY_OPERATOR(*, Double);
default:
- std::cout << "Unhandled type for Mul instruction: " << Ty << "\n";
+ std::cout << "Unhandled type for Mul instruction: " << *Ty << "\n";
abort();
}
return Dest;
static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(/, UByte);
IMPLEMENT_BINARY_OPERATOR(/, SByte);
IMPLEMENT_BINARY_OPERATOR(/, UShort);
static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(%, UByte);
IMPLEMENT_BINARY_OPERATOR(%, SByte);
IMPLEMENT_BINARY_OPERATOR(%, UShort);
static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(&, Bool);
IMPLEMENT_BINARY_OPERATOR(&, UByte);
IMPLEMENT_BINARY_OPERATOR(&, SByte);
static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(|, Bool);
IMPLEMENT_BINARY_OPERATOR(|, UByte);
IMPLEMENT_BINARY_OPERATOR(|, SByte);
static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(^, Bool);
IMPLEMENT_BINARY_OPERATOR(^, UByte);
IMPLEMENT_BINARY_OPERATOR(^, SByte);
static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(==, UByte);
IMPLEMENT_SETCC(==, SByte);
IMPLEMENT_SETCC(==, UShort);
static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(!=, UByte);
IMPLEMENT_SETCC(!=, SByte);
IMPLEMENT_SETCC(!=, UShort);
static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(<=, UByte);
IMPLEMENT_SETCC(<=, SByte);
IMPLEMENT_SETCC(<=, UShort);
IMPLEMENT_SETCC(<=, Double);
IMPLEMENT_POINTERSETCC(<=);
default:
- std::cout << "Unhandled type for SetLE instruction: " << Ty << "\n";
+ std::cout << "Unhandled type for SetLE instruction: " << *Ty << "\n";
abort();
}
return Dest;
static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(>=, UByte);
IMPLEMENT_SETCC(>=, SByte);
IMPLEMENT_SETCC(>=, UShort);
static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(<, UByte);
IMPLEMENT_SETCC(<, SByte);
IMPLEMENT_SETCC(<, UShort);
static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(>, UByte);
IMPLEMENT_SETCC(>, SByte);
IMPLEMENT_SETCC(>, UShort);
SetValue(&I, R, SF);
}
+static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
+ GenericValue Src3) {
+ return Src1.BoolVal ? Src2 : Src3;
+}
+
+void Interpreter::visitSelectInst(SelectInst &I) {
+ ExecutionContext &SF = ECStack.back();
+ GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
+ GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
+ GenericValue Src3 = getOperandValue(I.getOperand(2), SF);
+ GenericValue R = executeSelectInst(Src1, Src2, Src3);
+ SetValue(&I, R, SF);
+}
+
+
//===----------------------------------------------------------------------===//
// Terminator Instruction Implementations
//===----------------------------------------------------------------------===//
void Interpreter::exitCalled(GenericValue GV) {
+ // runAtExitHandlers() assumes there are no stack frames, but
+ // if exit() was called, then it had a stack frame. Blow away
+ // the stack before interpreting atexit handlers.
+ ECStack.clear ();
runAtExitHandlers ();
exit (GV.IntVal);
}
GenericValue IdxGV = getOperandValue(I.getOperand(), SF);
uint64_t Idx;
- switch (I.getOperand()->getType()->getPrimitiveID()) {
+ switch (I.getOperand()->getType()->getTypeID()) {
default: assert(0 && "Illegal getelementptr index for sequential type!");
case Type::SByteTyID: Idx = IdxGV.SByteVal; break;
case Type::ShortTyID: Idx = IdxGV.ShortVal; break;
switch (F->getIntrinsicID()) {
case Intrinsic::not_intrinsic:
break;
- case Intrinsic::va_start: // va_start: implemented by getFirstVarArg()
- SetValue(CS.getInstruction(), getFirstVarArg(), SF);
+ case Intrinsic::vastart: { // va_start
+ GenericValue ArgIndex;
+ ArgIndex.UIntPairVal.first = ECStack.size() - 1;
+ ArgIndex.UIntPairVal.second = 0;
+ SetValue(CS.getInstruction(), ArgIndex, SF);
return;
- case Intrinsic::va_end: // va_end is a noop for the interpreter
+ }
+ case Intrinsic::vaend: // va_end is a noop for the interpreter
return;
- case Intrinsic::va_copy: // va_copy: dest = src
+ case Intrinsic::vacopy: // va_copy: dest = src
SetValue(CS.getInstruction(), getOperandValue(*CS.arg_begin(), SF), SF);
return;
default:
SF.CurInst = Prev;
++SF.CurInst;
}
+ return;
}
SF.Caller = CS;
static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_SHIFT(<<, UByte);
IMPLEMENT_SHIFT(<<, SByte);
IMPLEMENT_SHIFT(<<, UShort);
static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_SHIFT(>>, UByte);
IMPLEMENT_SHIFT(>>, SByte);
IMPLEMENT_SHIFT(>>, UShort);
#define IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY) \
case Type::DESTTY##TyID: \
- switch (SrcTy->getPrimitiveID()) { \
+ switch (SrcTy->getTypeID()) { \
IMPLEMENT_CAST(DESTTY, DESTCTY, Bool); \
IMPLEMENT_CAST(DESTTY, DESTCTY, UByte); \
IMPLEMENT_CAST(DESTTY, DESTCTY, SByte); \
IMPLEMENT_CAST(DESTTY, DESTCTY, Double)
#define IMPLEMENT_CAST_CASE_END() \
- default: std::cout << "Unhandled cast: " << SrcTy << " to " << Ty << "\n"; \
+ default: std::cout << "Unhandled cast: " << *SrcTy << " to " << *Ty << "\n"; \
abort(); \
} \
break
const Type *SrcTy = SrcVal->getType();
GenericValue Dest, Src = getOperandValue(SrcVal, SF);
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_CAST_CASE(UByte , (unsigned char));
IMPLEMENT_CAST_CASE(SByte , ( signed char));
IMPLEMENT_CAST_CASE(UShort , (unsigned short));
void Interpreter::visitVANextInst(VANextInst &I) {
ExecutionContext &SF = ECStack.back();
- // Get the incoming valist parameter. LLI treats the valist as a pointer
- // to the next argument.
+ // Get the incoming valist parameter. LLI treats the valist as a
+ // (ec-stack-depth var-arg-index) pair.
GenericValue VAList = getOperandValue(I.getOperand(0), SF);
// Move the pointer to the next vararg.
- GenericValue *ArgPtr = (GenericValue *) GVTOP (VAList);
- ++ArgPtr;
- VAList = PTOGV (ArgPtr);
+ ++VAList.UIntPairVal.second;
SetValue(&I, VAList, SF);
}
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.
+ // Get the incoming valist parameter. LLI treats the valist as a
+ // (ec-stack-depth var-arg-index) pair.
GenericValue VAList = getOperandValue(I.getOperand(0), SF);
- assert (GVTOP (VAList) != 0 && "VAList was null in vaarg instruction");
- GenericValue Dest, Src = *(GenericValue *) GVTOP (VAList);
+ GenericValue Dest;
+ GenericValue Src = ECStack[VAList.UIntPairVal.first]
+ .VarArgs[VAList.UIntPairVal.second];
const Type *Ty = I.getType();
- switch (Ty->getPrimitiveID()) {
+ switch (Ty->getTypeID()) {
IMPLEMENT_VAARG(UByte);
IMPLEMENT_VAARG(SByte);
IMPLEMENT_VAARG(UShort);