#include "ExecutionAnnotations.h"
#include "llvm/iOther.h"
#include "llvm/iTerminators.h"
+#include "llvm/iMemory.h"
#include "llvm/Type.h"
#include "llvm/ConstPoolVals.h"
#include "llvm/Assembly/Writer.h"
+#include "llvm/Support/DataTypes.h"
+#include "llvm/CodeGen/TargetData.h"
static unsigned getOperandSlot(Value *V) {
SlotNumber *SN = (SlotNumber*)V->getAnnotation(SlotNumberAID);
return Result;
} else {
unsigned TyP = V->getType()->getUniqueID(); // TypePlane for value
+ unsigned Slot = getOperandSlot(V);
+ void *ElementPtr = &SF.Values[TyP][getOperandSlot(V)];
return SF.Values[TyP][getOperandSlot(V)];
}
}
+static void printOperandInfo(Value *V, ExecutionContext &SF) {
+ if (!V->isConstant()) {
+ unsigned TyP = V->getType()->getUniqueID(); // TypePlane for value
+ unsigned Slot = getOperandSlot(V);
+ cout << "Value=" << (void*)V << " TypeID=" << TyP << " Slot=" << Slot
+ << " Addr=" << &SF.Values[TyP][Slot] << " SF=" << &SF << endl;
+ }
+}
+
+
+
static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) {
unsigned TyP = V->getType()->getUniqueID(); // TypePlane for value
+
+ //cout << "Setting value: " << &SF.Values[TyP][getOperandSlot(V)] << endl;
SF.Values[TyP][getOperandSlot(V)] = Val;
}
#define IMPLEMENT_BINARY_OPERATOR(OP, TY) \
case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; break
+#define IMPLEMENT_BINARY_PTR_OPERATOR(OP) \
+ case Type::PointerTyID: Dest.PointerVal = \
+ (GenericValue*)((unsigned long)Src1.PointerVal OP (unsigned long)Src2.PointerVal); break
static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
const Type *Ty, ExecutionContext &SF) {
IMPLEMENT_BINARY_OPERATOR(+, Int);
IMPLEMENT_BINARY_OPERATOR(+, Float);
IMPLEMENT_BINARY_OPERATOR(+, Double);
+ IMPLEMENT_BINARY_PTR_OPERATOR(+);
case Type::ULongTyID:
case Type::LongTyID:
default:
IMPLEMENT_BINARY_OPERATOR(-, Int);
IMPLEMENT_BINARY_OPERATOR(-, Float);
IMPLEMENT_BINARY_OPERATOR(-, Double);
+ IMPLEMENT_BINARY_PTR_OPERATOR(-);
case Type::ULongTyID:
case Type::LongTyID:
default:
#define IMPLEMENT_SETCC(OP, TY) \
case Type::TY##TyID: Dest.BoolVal = Src1.TY##Val OP Src2.TY##Val; break
-
static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
const Type *Ty, ExecutionContext &SF) {
GenericValue Dest;
IMPLEMENT_SETCC(==, Int);
IMPLEMENT_SETCC(==, Float);
IMPLEMENT_SETCC(==, Double);
+ IMPLEMENT_SETCC(==, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
IMPLEMENT_SETCC(!=, Int);
IMPLEMENT_SETCC(!=, Float);
IMPLEMENT_SETCC(!=, Double);
+ IMPLEMENT_SETCC(!=, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
IMPLEMENT_SETCC(<=, Int);
IMPLEMENT_SETCC(<=, Float);
IMPLEMENT_SETCC(<=, Double);
+ IMPLEMENT_SETCC(<=, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
IMPLEMENT_SETCC(>=, Int);
IMPLEMENT_SETCC(>=, Float);
IMPLEMENT_SETCC(>=, Double);
+ IMPLEMENT_SETCC(>=, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
IMPLEMENT_SETCC(<, Int);
IMPLEMENT_SETCC(<, Float);
IMPLEMENT_SETCC(<, Double);
+ IMPLEMENT_SETCC(<, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
IMPLEMENT_SETCC(>, Int);
IMPLEMENT_SETCC(>, Float);
IMPLEMENT_SETCC(>, Double);
+ IMPLEMENT_SETCC(>, Pointer);
case Type::ULongTyID:
case Type::LongTyID:
default:
SetValue(I, R, SF);
}
-
//===----------------------------------------------------------------------===//
// Terminator Instruction Implementations
//===----------------------------------------------------------------------===//
SF.CurInst = SF.CurBB->begin(); // Update new instruction ptr...
}
+//===----------------------------------------------------------------------===//
+// Memory Instruction Implementations
+//===----------------------------------------------------------------------===//
+
+// Create a TargetData structure to handle memory addressing and size/alignment
+// computations
+//
+static TargetData TD("lli Interpreter");
+
+void Interpreter::executeAllocInst(AllocationInst *I, ExecutionContext &SF) {
+ const Type *Ty = I->getType()->getValueType(); // Type to be allocated
+ unsigned NumElements = 1;
+
+ if (I->getNumOperands()) { // Allocating a unsized array type?
+ assert(Ty->isArrayType() && Ty->isArrayType()->isUnsized() &&
+ "Allocation inst with size operand for !unsized array type???");
+ Ty = ((const ArrayType*)Ty)->getElementType(); // Get the actual type...
+
+ // Get the number of elements being allocated by the array...
+ GenericValue NumEl = getOperandValue(I->getOperand(0), SF);
+ NumElements = NumEl.UIntVal;
+ }
+
+ // Allocate enough memory to hold the type...
+ GenericValue Result;
+ Result.PointerVal = (GenericValue*)malloc(NumElements * TD.getTypeSize(Ty));
+ assert(Result.PointerVal != 0 && "Null pointer returned by malloc!");
+ SetValue(I, Result, SF);
+
+ if (I->getOpcode() == Instruction::Alloca) {
+ // Keep track to free it later...
+ }
+}
+
+static void executeFreeInst(FreeInst *I, ExecutionContext &SF) {
+ assert(I->getOperand(0)->getType()->isPointerType() && "Freeing nonptr?");
+ GenericValue Value = getOperandValue(I->getOperand(0), SF);
+ // TODO: Check to make sure memory is allocated
+ free(Value.PointerVal); // Free memory
+}
+
+static void executeLoadInst(LoadInst *I, ExecutionContext &SF) {
+ assert(I->getNumOperands() == 1 && "NI!");
+ GenericValue *Ptr = getOperandValue(I->getPtrOperand(), SF).PointerVal;
+ GenericValue Result;
+
+ switch (I->getType()->getPrimitiveID()) {
+ case Type::BoolTyID:
+ case Type::UByteTyID:
+ case Type::SByteTyID: Result.SByteVal = Ptr->SByteVal; break;
+ case Type::UShortTyID:
+ case Type::ShortTyID: Result.ShortVal = Ptr->ShortVal; break;
+ case Type::UIntTyID:
+ case Type::IntTyID: Result.IntVal = Ptr->IntVal; break;
+ //case Type::ULongTyID:
+ //case Type::LongTyID: Result.LongVal = Ptr->LongVal; break;
+ case Type::FloatTyID: Result.FloatVal = Ptr->FloatVal; break;
+ case Type::DoubleTyID: Result.DoubleVal = Ptr->DoubleVal; break;
+ case Type::PointerTyID: Result.PointerVal = Ptr->PointerVal; break;
+ default:
+ cout << "Cannot load value of type " << I->getType() << "!\n";
+ }
+
+ SetValue(I, Result, SF);
+}
+
+static void executeStoreInst(StoreInst *I, ExecutionContext &SF) {
+ GenericValue *Ptr = getOperandValue(I->getPtrOperand(), SF).PointerVal;
+ GenericValue Val = getOperandValue(I->getOperand(0), SF);
+ assert(I->getNumOperands() == 2 && "NI!");
+
+ switch (I->getOperand(0)->getType()->getPrimitiveID()) {
+ case Type::BoolTyID:
+ case Type::UByteTyID:
+ case Type::SByteTyID: Ptr->SByteVal = Val.SByteVal; break;
+ case Type::UShortTyID:
+ case Type::ShortTyID: Ptr->ShortVal = Val.ShortVal; break;
+ case Type::UIntTyID:
+ case Type::IntTyID: Ptr->IntVal = Val.IntVal; break;
+ //case Type::ULongTyID:
+ //case Type::LongTyID: Ptr->LongVal = Val.LongVal; break;
+ case Type::FloatTyID: Ptr->FloatVal = Val.FloatVal; break;
+ case Type::DoubleTyID: Ptr->DoubleVal = Val.DoubleVal; break;
+ case Type::PointerTyID: Ptr->PointerVal = Val.PointerVal; break;
+ default:
+ cout << "Cannot store value of type " << I->getType() << "!\n";
+ }
+}
+
+
//===----------------------------------------------------------------------===//
// Miscellaneous Instruction Implementations
//===----------------------------------------------------------------------===//
void Interpreter::executeCallInst(CallInst *I, ExecutionContext &SF) {
ECStack.back().Caller = I;
- callMethod(I->getCalledMethod(), &ECStack.back());
+ callMethod(I->getCalledMethod(), ECStack.size()-1);
}
static void executePHINode(PHINode *I, ExecutionContext &SF) {
SetValue(I, getOperandValue(IncomingValue, SF), SF);
}
+#define IMPLEMENT_SHIFT(OP, TY) \
+ case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.UByteVal; break
+
+static void executeShlInst(ShiftInst *I, ExecutionContext &SF) {
+ const Type *Ty = I->getOperand(0)->getType();
+ GenericValue Src1 = getOperandValue(I->getOperand(0), SF);
+ GenericValue Src2 = getOperandValue(I->getOperand(1), SF);
+ GenericValue Dest;
+
+ switch (Ty->getPrimitiveID()) {
+ IMPLEMENT_SHIFT(<<, UByte);
+ IMPLEMENT_SHIFT(<<, SByte);
+ IMPLEMENT_SHIFT(<<, UShort);
+ IMPLEMENT_SHIFT(<<, Short);
+ IMPLEMENT_SHIFT(<<, UInt);
+ IMPLEMENT_SHIFT(<<, Int);
+ case Type::ULongTyID:
+ case Type::LongTyID:
+ default:
+ cout << "Unhandled type for Shl instruction: " << Ty << endl;
+ }
+ SetValue(I, Dest, SF);
+}
+
+static void executeShrInst(ShiftInst *I, ExecutionContext &SF) {
+ const Type *Ty = I->getOperand(0)->getType();
+ GenericValue Src1 = getOperandValue(I->getOperand(0), SF);
+ GenericValue Src2 = getOperandValue(I->getOperand(1), SF);
+ GenericValue Dest;
+
+ switch (Ty->getPrimitiveID()) {
+ IMPLEMENT_SHIFT(>>, UByte);
+ IMPLEMENT_SHIFT(>>, SByte);
+ IMPLEMENT_SHIFT(>>, UShort);
+ IMPLEMENT_SHIFT(>>, Short);
+ IMPLEMENT_SHIFT(>>, UInt);
+ IMPLEMENT_SHIFT(>>, Int);
+ case Type::ULongTyID:
+ case Type::LongTyID:
+ default:
+ cout << "Unhandled type for Shr instruction: " << Ty << endl;
+ }
+ SetValue(I, Dest, SF);
+}
+
+#define IMPLEMENT_CAST(DTY, DCTY, STY) \
+ case Type::STY##TyID: Dest.DTY##Val = (DCTY)Src.STY##Val; break;
+
+#define IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY) \
+ case Type::DESTTY##TyID: \
+ switch (SrcTy->getPrimitiveID()) { \
+ IMPLEMENT_CAST(DESTTY, DESTCTY, UByte); \
+ IMPLEMENT_CAST(DESTTY, DESTCTY, SByte); \
+ IMPLEMENT_CAST(DESTTY, DESTCTY, UShort); \
+ IMPLEMENT_CAST(DESTTY, DESTCTY, Short); \
+ IMPLEMENT_CAST(DESTTY, DESTCTY, UInt); \
+ IMPLEMENT_CAST(DESTTY, DESTCTY, Int);
+
+#define IMPLEMENT_CAST_CASE_PTR_IMP(DESTTY, DESTCTY) \
+ IMPLEMENT_CAST(DESTTY, DESTCTY, Pointer)
+
+#define IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY) \
+ IMPLEMENT_CAST(DESTTY, DESTCTY, Float); \
+ IMPLEMENT_CAST(DESTTY, DESTCTY, Double)
+
+#define IMPLEMENT_CAST_CASE_END() \
+ default: cout << "Unhandled cast: " << SrcTy << " to " << Ty << endl; \
+ break; \
+ } \
+ break
+
+#define IMPLEMENT_CAST_CASE(DESTTY, DESTCTY) \
+ IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY); \
+ IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY); \
+ IMPLEMENT_CAST_CASE_PTR_IMP(DESTTY, DESTCTY); \
+ IMPLEMENT_CAST_CASE_END()
+
+#define IMPLEMENT_CAST_CASE_FP(DESTTY, DESTCTY) \
+ IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY); \
+ IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY); \
+ IMPLEMENT_CAST_CASE_END()
+
+#define IMPLEMENT_CAST_CASE_PTR(DESTTY, DESTCTY) \
+ IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY); \
+ IMPLEMENT_CAST_CASE_PTR_IMP(DESTTY, DESTCTY); \
+ IMPLEMENT_CAST_CASE_END()
+
+static void executeCastInst(CastInst *I, ExecutionContext &SF) {
+ const Type *Ty = I->getType();
+ const Type *SrcTy = I->getOperand(0)->getType();
+ GenericValue Src = getOperandValue(I->getOperand(0), SF);
+ GenericValue Dest;
+
+ switch (Ty->getPrimitiveID()) {
+ IMPLEMENT_CAST_CASE(UByte , unsigned char);
+ IMPLEMENT_CAST_CASE(SByte , signed char);
+ IMPLEMENT_CAST_CASE(UShort, unsigned short);
+ IMPLEMENT_CAST_CASE(Short , signed char);
+ IMPLEMENT_CAST_CASE(UInt , unsigned int );
+ IMPLEMENT_CAST_CASE(Int , signed int );
+ IMPLEMENT_CAST_CASE_FP(Float , float);
+ IMPLEMENT_CAST_CASE_FP(Double, double);
+ IMPLEMENT_CAST_CASE_PTR(Pointer, GenericValue *);
+ case Type::ULongTyID:
+ case Type::LongTyID:
+ default:
+ cout << "Unhandled dest type for cast instruction: " << Ty << endl;
+ }
+ SetValue(I, Dest, SF);
+}
AnnotationManager::registerAnnotationFactory(MethodInfoAID, CreateMethodInfo);
}
-
-
//===----------------------------------------------------------------------===//
// callMethod - Execute the specified method...
//
-void Interpreter::callMethod(Method *M, ExecutionContext *CallingSF = 0) {
+void Interpreter::callMethod(Method *M, int CallingSF = -1) {
if (M->isExternal()) {
// Handle builtin methods
cout << "Error: Method '" << M->getName() << "' is external!\n";
// the method. Also calculate the number of values for each type slot active.
//
MethodInfo *MethInfo = (MethodInfo*)M->getOrCreateAnnotation(MethodInfoAID);
-
ECStack.push_back(ExecutionContext()); // Make a new stack frame...
+
ExecutionContext &StackFrame = ECStack.back(); // Fill it in...
StackFrame.CurMethod = M;
StackFrame.CurBB = M->front();
StackFrame.PrevBB = 0; // No previous BB for PHI nodes...
// Run through the method arguments and initialize their values...
- if (CallingSF) {
- CallInst *Call = CallingSF->Caller;
+ if (CallingSF != -1) {
+ CallInst *Call = ECStack[CallingSF].Caller;
assert(Call && "Caller improperly initialized!");
- unsigned i = 0;
+ unsigned i = 1;
for (Method::ArgumentListType::iterator MI = M->getArgumentList().begin(),
ME = M->getArgumentList().end(); MI != ME; ++MI, ++i) {
- Value *V = Call->getOperand(i+1);
+ Value *V = Call->getOperand(i);
MethodArgument *MA = *MI;
- SetValue(MA, getOperandValue(V, *CallingSF), StackFrame);
+ SetValue(MA, getOperandValue(V, ECStack[CallingSF]), StackFrame);
}
}
}
executeBinaryInst((BinaryOperator*)I, SF);
} else {
switch (I->getOpcode()) {
+ // Terminators
case Instruction::Ret: executeRetInst ((ReturnInst*)I, SF); break;
case Instruction::Br: executeBrInst ((BranchInst*)I, SF); break;
+ // Memory Instructions
+ case Instruction::Alloca:
+ case Instruction::Malloc: executeAllocInst ((AllocationInst*)I, SF); break;
+ case Instruction::Free: executeFreeInst ((FreeInst*) I, SF); break;
+ case Instruction::Load: executeLoadInst ((LoadInst*) I, SF); break;
+ case Instruction::Store: executeStoreInst ((StoreInst*) I, SF); break;
+
+ // Miscellaneous Instructions
case Instruction::Call: executeCallInst ((CallInst*) I, SF); break;
case Instruction::PHINode: executePHINode ((PHINode*) I, SF); break;
+ case Instruction::Shl: executeShlInst ((ShiftInst*) I, SF); break;
+ case Instruction::Shr: executeShrInst ((ShiftInst*) I, SF); break;
+ case Instruction::Cast: executeCastInst ((CastInst*) I, SF); break;
default:
cout << "Don't know how to execute this instruction!\n-->" << I;
}
case Type::UIntTyID: cout << V.UIntVal; break;
case Type::FloatTyID: cout << V.FloatVal; break;
case Type::DoubleTyID: cout << V.DoubleVal; break;
+ case Type::PointerTyID:cout << V.PointerVal; break;
default:
cout << "- Don't know how to print value of this type!";
break;
}
+void Interpreter::infoValue(const string &Name) {
+ Value *PickedVal = ChooseOneOption(Name, LookupMatchingNames(Name));
+ if (!PickedVal) return;
+
+ cout << "Value: ";
+ printValue(PickedVal->getType(),
+ getOperandValue(PickedVal, ECStack[CurFrame]));
+ cout << endl;
+ printOperandInfo(PickedVal, ECStack[CurFrame]);
+}
+
void Interpreter::list() {
if (ECStack.empty())
cout << "Error: No program executing!\n";
projects / oota-llvm.git / commitdiff