X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FExecutionEngine%2FInterpreter%2FExecution.cpp;h=91c7c57f95b25f2db63c5cd65c74a39db4a6508b;hb=c00a43092ed960cdb28f4f3f00606f572869848d;hp=3d6cf0bfb9cde10375e5a25cc25ad17b91ba867a;hpb=bbdabce1e97f77d383def3f06a51c4fc75d114cf;p=oota-llvm.git diff --git a/lib/ExecutionEngine/Interpreter/Execution.cpp b/lib/ExecutionEngine/Interpreter/Execution.cpp index 3d6cf0bfb9c..91c7c57f95b 100644 --- a/lib/ExecutionEngine/Interpreter/Execution.cpp +++ b/lib/ExecutionEngine/Interpreter/Execution.cpp @@ -1,684 +1,923 @@ //===-- Execution.cpp - Implement code to simulate the program ------------===// -// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// // This file contains the actual instruction interpreter. // //===----------------------------------------------------------------------===// +#define DEBUG_TYPE "interpreter" #include "Interpreter.h" -#include "ExecutionAnnotations.h" -#include "llvm/iPHINode.h" -#include "llvm/iOther.h" -#include "llvm/iTerminators.h" -#include "llvm/iMemory.h" -#include "llvm/DerivedTypes.h" #include "llvm/Constants.h" -#include "llvm/Assembly/Writer.h" -#include "llvm/Target/TargetData.h" -#include "Support/CommandLine.h" -#include "Support/Statistic.h" -#include // For fmod -#include -#include -using std::vector; -using std::cout; -using std::cerr; - -namespace { - Statistic<> NumDynamicInsts("lli", "Number of dynamic instructions executed"); -} - -static cl::opt -QuietMode("quiet", cl::desc("Do not emit any non-program output")); - -static cl::alias -QuietModeA("q", cl::desc("Alias for -quiet"), cl::aliasopt(QuietMode)); - -static cl::opt -ArrayChecksEnabled("array-checks", cl::desc("Enable array bound checks")); - -static cl::opt -AbortOnExceptions("abort-on-exception", - cl::desc("Halt execution on a machine exception")); - -// Create a TargetData structure to handle memory addressing and size/alignment -// computations -// -TargetData TD("lli Interpreter"); -CachedWriter CW; // Object to accelerate printing of LLVM - - -#ifdef PROFILE_STRUCTURE_FIELDS -static cl::opt -ProfileStructureFields("profilestructfields", - cl::desc("Profile Structure Field Accesses")); -#include -static std::map > FieldAccessCounts; -#endif - -sigjmp_buf SignalRecoverBuffer; -static bool InInstruction = false; - -extern "C" { -static void SigHandler(int Signal) { - if (InInstruction) - siglongjmp(SignalRecoverBuffer, Signal); -} -} +#include "llvm/DerivedTypes.h" +#include "llvm/Instructions.h" +#include "llvm/CodeGen/IntrinsicLowering.h" +#include "llvm/Support/GetElementPtrTypeIterator.h" +#include "llvm/ADT/Statistic.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/MathExtras.h" +#include +using namespace llvm; -static void initializeSignalHandlers() { - struct sigaction Action; - Action.sa_handler = SigHandler; - Action.sa_flags = SA_SIGINFO; - sigemptyset(&Action.sa_mask); - sigaction(SIGSEGV, &Action, 0); - sigaction(SIGBUS, &Action, 0); - sigaction(SIGINT, &Action, 0); - sigaction(SIGFPE, &Action, 0); -} +STATISTIC(NumDynamicInsts, "Number of dynamic instructions executed"); +static Interpreter *TheEE = 0; //===----------------------------------------------------------------------===// // Value Manipulation code //===----------------------------------------------------------------------===// -static unsigned getOperandSlot(Value *V) { - SlotNumber *SN = (SlotNumber*)V->getAnnotation(SlotNumberAID); - assert(SN && "Operand does not have a slot number annotation!"); - return SN->SlotNum; -} - -#define GET_CONST_VAL(TY, CLASS) \ - case Type::TY##TyID: Result.TY##Val = cast(C)->getValue(); break - -// Operations used by constant expr implementations... -static GenericValue executeCastOperation(Value *Src, const Type *DestTy, - ExecutionContext &SF); -static GenericValue executeGEPOperation(Value *Src, User::op_iterator IdxBegin, - User::op_iterator IdxEnd, - ExecutionContext &SF); -static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF); - -static GenericValue getConstantValue(const Constant *C) { - GenericValue Result; - switch (C->getType()->getPrimitiveID()) { - GET_CONST_VAL(Bool , ConstantBool); - GET_CONST_VAL(UByte , ConstantUInt); - GET_CONST_VAL(SByte , ConstantSInt); - GET_CONST_VAL(UShort , ConstantUInt); - GET_CONST_VAL(Short , ConstantSInt); - GET_CONST_VAL(UInt , ConstantUInt); - GET_CONST_VAL(Int , ConstantSInt); - GET_CONST_VAL(ULong , ConstantUInt); - GET_CONST_VAL(Long , ConstantSInt); - GET_CONST_VAL(Float , ConstantFP); - GET_CONST_VAL(Double , ConstantFP); - case Type::PointerTyID: - if (isa(C)) { - Result.PointerVal = 0; - } else if (const ConstantPointerRef *CPR = dyn_cast(C)){ - GlobalAddress *Address = - (GlobalAddress*)CPR->getValue()->getOrCreateAnnotation(GlobalAddressAID); - Result.PointerVal = (PointerTy)Address->Ptr; - } else { - assert(0 && "Unknown constant pointer type!"); - } - break; +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 executeUDivInst(GenericValue Src1, GenericValue Src2, + const Type *Ty); +static GenericValue executeSDivInst(GenericValue Src1, GenericValue Src2, + const Type *Ty); +static GenericValue executeFDivInst(GenericValue Src1, GenericValue Src2, + const Type *Ty); +static GenericValue executeURemInst(GenericValue Src1, GenericValue Src2, + const Type *Ty); +static GenericValue executeSRemInst(GenericValue Src1, GenericValue Src2, + const Type *Ty); +static GenericValue executeFRemInst(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 executeCmpInst(unsigned predicate, GenericValue Src1, + GenericValue Src2, const Type *Ty); +static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2, + const Type *Ty); +static GenericValue executeLShrInst(GenericValue Src1, GenericValue Src2, + const Type *Ty); +static GenericValue executeAShrInst(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()) { + case Instruction::Trunc: + return executeTruncInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::ZExt: + return executeZExtInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::SExt: + return executeSExtInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::FPTrunc: + return executeFPTruncInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::FPExt: + return executeFPExtInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::UIToFP: + return executeUIToFPInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::SIToFP: + return executeSIToFPInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::FPToUI: + return executeFPToUIInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::FPToSI: + return executeFPToSIInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::PtrToInt: + return executePtrToIntInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::IntToPtr: + return executeIntToPtrInst(CE->getOperand(0), CE->getType(), SF); + case Instruction::BitCast: + return executeBitCastInst(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::SDiv: + return executeSDivInst(getOperandValue(CE->getOperand(0), SF), + getOperandValue(CE->getOperand(1), SF), + CE->getOperand(0)->getType()); + case Instruction::UDiv: + return executeUDivInst(getOperandValue(CE->getOperand(0), SF), + getOperandValue(CE->getOperand(1), SF), + CE->getOperand(0)->getType()); + case Instruction::FDiv: + return executeFDivInst(getOperandValue(CE->getOperand(0), SF), + getOperandValue(CE->getOperand(1), SF), + CE->getOperand(0)->getType()); + case Instruction::URem: + return executeURemInst(getOperandValue(CE->getOperand(0), SF), + getOperandValue(CE->getOperand(1), SF), + CE->getOperand(0)->getType()); + case Instruction::SRem: + return executeSRemInst(getOperandValue(CE->getOperand(0), SF), + getOperandValue(CE->getOperand(1), SF), + CE->getOperand(0)->getType()); + case Instruction::FRem: + return executeFRemInst(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::FCmp: + case Instruction::ICmp: + return executeCmpInst(CE->getPredicate(), + 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::LShr: + return executeLShrInst(getOperandValue(CE->getOperand(0), SF), + getOperandValue(CE->getOperand(1), SF), + CE->getOperand(0)->getType()); + case Instruction::AShr: + return executeAShrInst(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: - cout << "ERROR: Constant unimp for type: " << C->getType() << "\n"; + cerr << "Unhandled ConstantExpr: " << *CE << "\n"; + abort(); + return GenericValue(); } - return Result; } -static GenericValue getOperandValue(Value *V, ExecutionContext &SF) { +GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) { if (ConstantExpr *CE = dyn_cast(V)) { - switch (CE->getOpcode()) { - case Instruction::Cast: - return executeCastOperation(CE->getOperand(0), CE->getType(), SF); - case Instruction::GetElementPtr: - return 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(), SF); - default: - cerr << "Unhandled ConstantExpr: " << CE << "\n"; - abort(); - { GenericValue V; return V; } - } + return getConstantExprValue(CE, SF); } else if (Constant *CPV = dyn_cast(V)) { return getConstantValue(CPV); } else if (GlobalValue *GV = dyn_cast(V)) { - GlobalAddress *Address = - (GlobalAddress*)GV->getOrCreateAnnotation(GlobalAddressAID); - GenericValue Result; - Result.PointerVal = (PointerTy)(GenericValue*)Address->Ptr; - return Result; + return PTOGV(getPointerToGlobal(GV)); } else { - unsigned TyP = V->getType()->getUniqueID(); // TypePlane for value - unsigned OpSlot = getOperandSlot(V); - assert(TyP < SF.Values.size() && - OpSlot < SF.Values[TyP].size() && "Value out of range!"); - return SF.Values[TyP][getOperandSlot(V)]; + return SF.Values[V]; } } -static void printOperandInfo(Value *V, ExecutionContext &SF) { - if (isa(V)) { - cout << "Constant Pool Value\n"; - } else if (isa(V)) { - cout << "Global Value\n"; - } else { - 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 - << " Contents=0x"; - - const unsigned char *Buf = (const unsigned char*)&SF.Values[TyP][Slot]; - for (unsigned i = 0; i < sizeof(GenericValue); ++i) { - unsigned char Cur = Buf[i]; - cout << ( Cur >= 160? char((Cur>>4)+'A'-10) : char((Cur>>4) + '0')) - << ((Cur&15) >= 10? char((Cur&15)+'A'-10) : char((Cur&15) + '0')); - } - cout << "\n"; - } -} - - - 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)] << "\n"; - SF.Values[TyP][getOperandSlot(V)] = Val; + SF.Values[V] = Val; } - -//===----------------------------------------------------------------------===// -// Annotation Wrangling code -//===----------------------------------------------------------------------===// - void Interpreter::initializeExecutionEngine() { - AnnotationManager::registerAnnotationFactory(MethodInfoAID, - &MethodInfo::Create); - AnnotationManager::registerAnnotationFactory(GlobalAddressAID, - &GlobalAddress::Create); - initializeSignalHandlers(); + TheEE = this; } -static void StoreValueToMemory(GenericValue Val, GenericValue *Ptr, - const Type *Ty); +//===----------------------------------------------------------------------===// +// Binary Instruction Implementations +//===----------------------------------------------------------------------===// -// InitializeMemory - Recursive function to apply a Constant value into the -// specified memory location... -// -static void InitializeMemory(const Constant *Init, char *Addr) { +#define IMPLEMENT_BINARY_OPERATOR(OP, TY) \ + case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; break - if (Init->getType()->isFirstClassType()) { - GenericValue Val = getConstantValue(Init); - StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType()); - return; +#define IMPLEMENT_INTEGER_BINOP(OP, TY) \ + case Type::IntegerTyID: { \ + unsigned BitWidth = cast(TY)->getBitWidth(); \ + if (BitWidth == 1) \ + Dest.Int1Val = Src1.Int1Val OP Src2.Int1Val; \ + else if (BitWidth <= 8) \ + Dest.Int8Val = Src1.Int8Val OP Src2.Int8Val; \ + else if (BitWidth <= 16) \ + Dest.Int16Val = Src1.Int16Val OP Src2.Int16Val; \ + else if (BitWidth <= 32) \ + Dest.Int32Val = Src1.Int32Val OP Src2.Int32Val; \ + else if (BitWidth <= 64) \ + Dest.Int64Val = Src1.Int64Val OP Src2.Int64Val; \ + else \ + cerr << "Integer types > 64 bits not supported: " << *Ty << "\n"; \ + maskToBitWidth(Dest, BitWidth); \ + break; \ + } + +#define IMPLEMENT_SIGNED_BINOP(OP, TY) \ + if (const IntegerType *ITy = dyn_cast(TY)) { \ + unsigned BitWidth = ITy->getBitWidth(); \ + if (BitWidth <= 8) \ + Dest.Int8Val = ((int8_t)Src1.Int8Val) OP ((int8_t)Src2.Int8Val); \ + else if (BitWidth <= 16) \ + Dest.Int16Val = ((int16_t)Src1.Int16Val) OP ((int16_t)Src2.Int16Val); \ + else if (BitWidth <= 32) \ + Dest.Int32Val = ((int32_t)Src1.Int32Val) OP ((int32_t)Src2.Int32Val); \ + else if (BitWidth <= 64) \ + Dest.Int64Val = ((int64_t)Src1.Int64Val) OP ((int64_t)Src2.Int64Val); \ + else { \ + cerr << "Integer types > 64 bits not supported: " << *Ty << "\n"; \ + abort(); \ + } \ + maskToBitWidth(Dest, BitWidth); \ + } else { \ + cerr << "Unhandled type for " #OP " operator: " << *Ty << "\n"; \ + abort(); \ + } + +#define IMPLEMENT_UNSIGNED_BINOP(OP, TY) \ + if (const IntegerType *ITy = dyn_cast(TY)) { \ + unsigned BitWidth = ITy->getBitWidth(); \ + if (BitWidth <= 8) \ + Dest.Int8Val = ((uint8_t)Src1.Int8Val) OP ((uint8_t)Src2.Int8Val); \ + else if (BitWidth <= 16) \ + Dest.Int16Val = ((uint16_t)Src1.Int16Val) OP ((uint16_t)Src2.Int16Val); \ + else if (BitWidth <= 32) \ + Dest.Int32Val = ((uint32_t)Src1.Int32Val) OP ((uint32_t)Src2.Int32Val); \ + else if (BitWidth <= 64) \ + Dest.Int64Val = ((uint64_t)Src1.Int64Val) OP ((uint64_t)Src2.Int64Val); \ + else { \ + cerr << "Integer types > 64 bits not supported: " << *Ty << "\n"; \ + abort(); \ + } \ + maskToBitWidth(Dest, BitWidth); \ + } else { \ + cerr << "Unhandled type for " #OP " operator: " << *Ty << "\n"; \ + abort(); \ } - switch (Init->getType()->getPrimitiveID()) { - case Type::ArrayTyID: { - const ConstantArray *CPA = cast(Init); - const vector &Val = CPA->getValues(); - unsigned ElementSize = - TD.getTypeSize(cast(CPA->getType())->getElementType()); - for (unsigned i = 0; i < Val.size(); ++i) - InitializeMemory(cast(Val[i].get()), Addr+i*ElementSize); - return; +static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_INTEGER_BINOP(+, Ty); + IMPLEMENT_BINARY_OPERATOR(+, Float); + IMPLEMENT_BINARY_OPERATOR(+, Double); + default: + cerr << "Unhandled type for Add instruction: " << *Ty << "\n"; + abort(); } + return Dest; +} - case Type::StructTyID: { - const ConstantStruct *CPS = cast(Init); - const StructLayout *SL=TD.getStructLayout(cast(CPS->getType())); - const vector &Val = CPS->getValues(); - for (unsigned i = 0; i < Val.size(); ++i) - InitializeMemory(cast(Val[i].get()), - Addr+SL->MemberOffsets[i]); - return; +static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_INTEGER_BINOP(-, Ty); + IMPLEMENT_BINARY_OPERATOR(-, Float); + IMPLEMENT_BINARY_OPERATOR(-, Double); + default: + cerr << "Unhandled type for Sub instruction: " << *Ty << "\n"; + abort(); } + return Dest; +} +static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_INTEGER_BINOP(*, Ty); + IMPLEMENT_BINARY_OPERATOR(*, Float); + IMPLEMENT_BINARY_OPERATOR(*, Double); default: - CW << "Bad Type: " << Init->getType() << "\n"; - assert(0 && "Unknown constant type to initialize memory with!"); + cerr << "Unhandled type for Mul instruction: " << *Ty << "\n"; + abort(); } + return Dest; } -Annotation *GlobalAddress::Create(AnnotationID AID, const Annotable *O, void *){ - assert(AID == GlobalAddressAID); +static GenericValue executeUDivInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNSIGNED_BINOP(/,Ty) + return Dest; +} - // This annotation will only be created on GlobalValue objects... - GlobalValue *GVal = cast((Value*)O); +static GenericValue executeSDivInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_SIGNED_BINOP(/,Ty) + return Dest; +} - if (isa(GVal)) { - // The GlobalAddress object for a function is just a pointer to function - // itself. Don't delete it when the annotation is gone though! - return new GlobalAddress(GVal, false); +static GenericValue executeFDivInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_BINARY_OPERATOR(/, Float); + IMPLEMENT_BINARY_OPERATOR(/, Double); + default: + cerr << "Unhandled type for FDiv instruction: " << *Ty << "\n"; + abort(); } + return Dest; +} - // Handle the case of a global variable... - assert(isa(GVal) && - "Global value found that isn't a function or global variable!"); - GlobalVariable *GV = cast(GVal); - - // First off, we must allocate space for the global variable to point at... - const Type *Ty = GV->getType()->getElementType(); // Type to be allocated +static GenericValue executeURemInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNSIGNED_BINOP(%, Ty) + return Dest; +} - // Allocate enough memory to hold the type... - void *Addr = calloc(1, TD.getTypeSize(Ty)); - assert(Addr != 0 && "Null pointer returned by malloc!"); +static GenericValue executeSRemInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_SIGNED_BINOP(%, Ty) + return Dest; +} - // Initialize the memory if there is an initializer... - if (GV->hasInitializer()) - InitializeMemory(GV->getInitializer(), (char*)Addr); +static GenericValue executeFRemInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + case Type::FloatTyID: + Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal); + break; + case Type::DoubleTyID: + Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal); + break; + default: + cerr << "Unhandled type for Rem instruction: " << *Ty << "\n"; + abort(); + } + return Dest; +} - return new GlobalAddress(Addr, true); // Simply invoke the ctor +static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNSIGNED_BINOP(&, Ty) + return Dest; } -//===----------------------------------------------------------------------===// -// Binary Instruction Implementations -//===----------------------------------------------------------------------===// +static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNSIGNED_BINOP(|, Ty) + return Dest; +} -#define IMPLEMENT_BINARY_OPERATOR(OP, TY) \ - case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; break +static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNSIGNED_BINOP(^, Ty) + return Dest; +} -static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +#define IMPLEMENT_SIGNED_ICMP(OP, TY) \ + case Type::IntegerTyID: { \ + unsigned BitWidth = cast(TY)->getBitWidth(); \ + if (BitWidth == 1) \ + Dest.Int1Val = ((int8_t)Src1.Int1Val) OP ((int8_t)Src2.Int1Val); \ + else if (BitWidth <= 8) \ + Dest.Int1Val = ((int8_t)Src1.Int8Val) OP ((int8_t)Src2.Int8Val); \ + else if (BitWidth <= 16) \ + Dest.Int1Val = ((int16_t)Src1.Int16Val) OP ((int16_t)Src2.Int16Val); \ + else if (BitWidth <= 32) \ + Dest.Int1Val = ((int32_t)Src1.Int32Val) OP ((int32_t)Src2.Int32Val); \ + else if (BitWidth <= 64) \ + Dest.Int1Val = ((int64_t)Src1.Int64Val) OP ((int64_t)Src2.Int64Val); \ + else { \ + cerr << "Integer types > 64 bits not supported: " << *Ty << "\n"; \ + abort(); \ + } \ + maskToBitWidth(Dest, BitWidth); \ + break; \ + } + +#define IMPLEMENT_UNSIGNED_ICMP(OP, TY) \ + case Type::IntegerTyID: { \ + unsigned BitWidth = cast(TY)->getBitWidth(); \ + if (BitWidth == 1) \ + Dest.Int1Val = ((uint8_t)Src1.Int1Val) OP ((uint8_t)Src2.Int1Val); \ + else if (BitWidth <= 8) \ + Dest.Int1Val = ((uint8_t)Src1.Int8Val) OP ((uint8_t)Src2.Int8Val); \ + else if (BitWidth <= 16) \ + Dest.Int1Val = ((uint16_t)Src1.Int16Val) OP ((uint16_t)Src2.Int16Val); \ + else if (BitWidth <= 32) \ + Dest.Int1Val = ((uint32_t)Src1.Int32Val) OP ((uint32_t)Src2.Int32Val); \ + else if (BitWidth <= 64) \ + Dest.Int1Val = ((uint64_t)Src1.Int64Val) OP ((uint64_t)Src2.Int64Val); \ + else { \ + cerr << "Integer types > 64 bits not supported: " << *Ty << "\n"; \ + abort(); \ + } \ + maskToBitWidth(Dest, BitWidth); \ + break; \ + } + +// Handle pointers specially because they must be compared with only as much +// width as the host has. We _do not_ want to be comparing 64 bit values when +// running on a 32-bit target, otherwise the upper 32 bits might mess up +// comparisons if they contain garbage. +#define IMPLEMENT_POINTER_ICMP(OP) \ + case Type::PointerTyID: \ + Dest.Int1Val = (void*)(intptr_t)Src1.PointerVal OP \ + (void*)(intptr_t)Src2.PointerVal; break + +static GenericValue executeICMP_EQ(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_BINARY_OPERATOR(+, UByte); - IMPLEMENT_BINARY_OPERATOR(+, SByte); - IMPLEMENT_BINARY_OPERATOR(+, UShort); - IMPLEMENT_BINARY_OPERATOR(+, Short); - IMPLEMENT_BINARY_OPERATOR(+, UInt); - IMPLEMENT_BINARY_OPERATOR(+, Int); - IMPLEMENT_BINARY_OPERATOR(+, ULong); - IMPLEMENT_BINARY_OPERATOR(+, Long); - IMPLEMENT_BINARY_OPERATOR(+, Float); - IMPLEMENT_BINARY_OPERATOR(+, Double); - IMPLEMENT_BINARY_OPERATOR(+, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_UNSIGNED_ICMP(==, Ty); + IMPLEMENT_POINTER_ICMP(==); default: - cout << "Unhandled type for Add instruction: " << Ty << "\n"; + cerr << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n"; + abort(); } return Dest; } -static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeICMP_NE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_BINARY_OPERATOR(-, UByte); - IMPLEMENT_BINARY_OPERATOR(-, SByte); - IMPLEMENT_BINARY_OPERATOR(-, UShort); - IMPLEMENT_BINARY_OPERATOR(-, Short); - IMPLEMENT_BINARY_OPERATOR(-, UInt); - IMPLEMENT_BINARY_OPERATOR(-, Int); - IMPLEMENT_BINARY_OPERATOR(-, ULong); - IMPLEMENT_BINARY_OPERATOR(-, Long); - IMPLEMENT_BINARY_OPERATOR(-, Float); - IMPLEMENT_BINARY_OPERATOR(-, Double); - IMPLEMENT_BINARY_OPERATOR(-, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_UNSIGNED_ICMP(!=, Ty); + IMPLEMENT_POINTER_ICMP(!=); default: - cout << "Unhandled type for Sub instruction: " << Ty << "\n"; + cerr << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n"; + abort(); } return Dest; } -static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeICMP_ULT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_BINARY_OPERATOR(*, UByte); - IMPLEMENT_BINARY_OPERATOR(*, SByte); - IMPLEMENT_BINARY_OPERATOR(*, UShort); - IMPLEMENT_BINARY_OPERATOR(*, Short); - IMPLEMENT_BINARY_OPERATOR(*, UInt); - IMPLEMENT_BINARY_OPERATOR(*, Int); - IMPLEMENT_BINARY_OPERATOR(*, ULong); - IMPLEMENT_BINARY_OPERATOR(*, Long); - IMPLEMENT_BINARY_OPERATOR(*, Float); - IMPLEMENT_BINARY_OPERATOR(*, Double); - IMPLEMENT_BINARY_OPERATOR(*, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_UNSIGNED_ICMP(<, Ty); + IMPLEMENT_POINTER_ICMP(<); default: - cout << "Unhandled type for Mul instruction: " << Ty << "\n"; + cerr << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n"; + abort(); } return Dest; } -static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeICMP_SLT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_BINARY_OPERATOR(/, UByte); - IMPLEMENT_BINARY_OPERATOR(/, SByte); - IMPLEMENT_BINARY_OPERATOR(/, UShort); - IMPLEMENT_BINARY_OPERATOR(/, Short); - IMPLEMENT_BINARY_OPERATOR(/, UInt); - IMPLEMENT_BINARY_OPERATOR(/, Int); - IMPLEMENT_BINARY_OPERATOR(/, ULong); - IMPLEMENT_BINARY_OPERATOR(/, Long); - IMPLEMENT_BINARY_OPERATOR(/, Float); - IMPLEMENT_BINARY_OPERATOR(/, Double); - IMPLEMENT_BINARY_OPERATOR(/, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_SIGNED_ICMP(<, Ty); + IMPLEMENT_POINTER_ICMP(<); default: - cout << "Unhandled type for Div instruction: " << Ty << "\n"; + cerr << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n"; + abort(); } return Dest; } -static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeICMP_UGT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_BINARY_OPERATOR(%, UByte); - IMPLEMENT_BINARY_OPERATOR(%, SByte); - IMPLEMENT_BINARY_OPERATOR(%, UShort); - IMPLEMENT_BINARY_OPERATOR(%, Short); - IMPLEMENT_BINARY_OPERATOR(%, UInt); - IMPLEMENT_BINARY_OPERATOR(%, Int); - IMPLEMENT_BINARY_OPERATOR(%, ULong); - IMPLEMENT_BINARY_OPERATOR(%, Long); - IMPLEMENT_BINARY_OPERATOR(%, Pointer); - case Type::FloatTyID: - Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal); - break; - case Type::DoubleTyID: - Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal); - break; + switch (Ty->getTypeID()) { + IMPLEMENT_UNSIGNED_ICMP(>, Ty); + IMPLEMENT_POINTER_ICMP(>); default: - cout << "Unhandled type for Rem instruction: " << Ty << "\n"; + cerr << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n"; + abort(); } return Dest; } -static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeICMP_SGT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_BINARY_OPERATOR(&, UByte); - IMPLEMENT_BINARY_OPERATOR(&, SByte); - IMPLEMENT_BINARY_OPERATOR(&, UShort); - IMPLEMENT_BINARY_OPERATOR(&, Short); - IMPLEMENT_BINARY_OPERATOR(&, UInt); - IMPLEMENT_BINARY_OPERATOR(&, Int); - IMPLEMENT_BINARY_OPERATOR(&, ULong); - IMPLEMENT_BINARY_OPERATOR(&, Long); - IMPLEMENT_BINARY_OPERATOR(&, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_SIGNED_ICMP(>, Ty); + IMPLEMENT_POINTER_ICMP(>); default: - cout << "Unhandled type for And instruction: " << Ty << "\n"; + cerr << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n"; + abort(); } return Dest; } +static GenericValue executeICMP_ULE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_UNSIGNED_ICMP(<=, Ty); + IMPLEMENT_POINTER_ICMP(<=); + default: + cerr << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n"; + abort(); + } + return Dest; +} -static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeICMP_SLE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_BINARY_OPERATOR(|, UByte); - IMPLEMENT_BINARY_OPERATOR(|, SByte); - IMPLEMENT_BINARY_OPERATOR(|, UShort); - IMPLEMENT_BINARY_OPERATOR(|, Short); - IMPLEMENT_BINARY_OPERATOR(|, UInt); - IMPLEMENT_BINARY_OPERATOR(|, Int); - IMPLEMENT_BINARY_OPERATOR(|, ULong); - IMPLEMENT_BINARY_OPERATOR(|, Long); - IMPLEMENT_BINARY_OPERATOR(|, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_SIGNED_ICMP(<=, Ty); + IMPLEMENT_POINTER_ICMP(<=); default: - cout << "Unhandled type for Or instruction: " << Ty << "\n"; + cerr << "Unhandled type for ICMP_SLE predicate: " << *Ty << "\n"; + abort(); } return Dest; } +static GenericValue executeICMP_UGE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_UNSIGNED_ICMP(>=,Ty); + IMPLEMENT_POINTER_ICMP(>=); + default: + cerr << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n"; + abort(); + } + return Dest; +} -static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeICMP_SGE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_BINARY_OPERATOR(^, UByte); - IMPLEMENT_BINARY_OPERATOR(^, SByte); - IMPLEMENT_BINARY_OPERATOR(^, UShort); - IMPLEMENT_BINARY_OPERATOR(^, Short); - IMPLEMENT_BINARY_OPERATOR(^, UInt); - IMPLEMENT_BINARY_OPERATOR(^, Int); - IMPLEMENT_BINARY_OPERATOR(^, ULong); - IMPLEMENT_BINARY_OPERATOR(^, Long); - IMPLEMENT_BINARY_OPERATOR(^, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_SIGNED_ICMP(>=, Ty); + IMPLEMENT_POINTER_ICMP(>=); default: - cout << "Unhandled type for Xor instruction: " << Ty << "\n"; + cerr << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n"; + abort(); } return Dest; } +void Interpreter::visitICmpInst(ICmpInst &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 R; // Result + + switch (I.getPredicate()) { + case ICmpInst::ICMP_EQ: R = executeICMP_EQ(Src1, Src2, Ty); break; + case ICmpInst::ICMP_NE: R = executeICMP_NE(Src1, Src2, Ty); break; + case ICmpInst::ICMP_ULT: R = executeICMP_ULT(Src1, Src2, Ty); break; + case ICmpInst::ICMP_SLT: R = executeICMP_SLT(Src1, Src2, Ty); break; + case ICmpInst::ICMP_UGT: R = executeICMP_UGT(Src1, Src2, Ty); break; + case ICmpInst::ICMP_SGT: R = executeICMP_SGT(Src1, Src2, Ty); break; + case ICmpInst::ICMP_ULE: R = executeICMP_ULE(Src1, Src2, Ty); break; + case ICmpInst::ICMP_SLE: R = executeICMP_SLE(Src1, Src2, Ty); break; + case ICmpInst::ICMP_UGE: R = executeICMP_UGE(Src1, Src2, Ty); break; + case ICmpInst::ICMP_SGE: R = executeICMP_SGE(Src1, Src2, Ty); break; + default: + cerr << "Don't know how to handle this ICmp predicate!\n-->" << I; + abort(); + } + + SetValue(&I, R, SF); +} -#define IMPLEMENT_SETCC(OP, TY) \ - case Type::TY##TyID: Dest.BoolVal = Src1.TY##Val OP Src2.TY##Val; break +#define IMPLEMENT_FCMP(OP, TY) \ + case Type::TY##TyID: Dest.Int1Val = Src1.TY##Val OP Src2.TY##Val; break -static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeFCMP_OEQ(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_SETCC(==, UByte); - IMPLEMENT_SETCC(==, SByte); - IMPLEMENT_SETCC(==, UShort); - IMPLEMENT_SETCC(==, Short); - IMPLEMENT_SETCC(==, UInt); - IMPLEMENT_SETCC(==, Int); - IMPLEMENT_SETCC(==, ULong); - IMPLEMENT_SETCC(==, Long); - IMPLEMENT_SETCC(==, Float); - IMPLEMENT_SETCC(==, Double); - IMPLEMENT_SETCC(==, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(==, Float); + IMPLEMENT_FCMP(==, Double); default: - cout << "Unhandled type for SetEQ instruction: " << Ty << "\n"; + cerr << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n"; + abort(); } return Dest; } -static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeFCMP_ONE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_SETCC(!=, UByte); - IMPLEMENT_SETCC(!=, SByte); - IMPLEMENT_SETCC(!=, UShort); - IMPLEMENT_SETCC(!=, Short); - IMPLEMENT_SETCC(!=, UInt); - IMPLEMENT_SETCC(!=, Int); - IMPLEMENT_SETCC(!=, ULong); - IMPLEMENT_SETCC(!=, Long); - IMPLEMENT_SETCC(!=, Float); - IMPLEMENT_SETCC(!=, Double); - IMPLEMENT_SETCC(!=, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(!=, Float); + IMPLEMENT_FCMP(!=, Double); default: - cout << "Unhandled type for SetNE instruction: " << Ty << "\n"; + cerr << "Unhandled type for FCmp NE instruction: " << *Ty << "\n"; + abort(); } return Dest; } -static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeFCMP_OLE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_SETCC(<=, UByte); - IMPLEMENT_SETCC(<=, SByte); - IMPLEMENT_SETCC(<=, UShort); - IMPLEMENT_SETCC(<=, Short); - IMPLEMENT_SETCC(<=, UInt); - IMPLEMENT_SETCC(<=, Int); - IMPLEMENT_SETCC(<=, ULong); - IMPLEMENT_SETCC(<=, Long); - IMPLEMENT_SETCC(<=, Float); - IMPLEMENT_SETCC(<=, Double); - IMPLEMENT_SETCC(<=, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(<=, Float); + IMPLEMENT_FCMP(<=, Double); default: - cout << "Unhandled type for SetLE instruction: " << Ty << "\n"; + cerr << "Unhandled type for FCmp LE instruction: " << *Ty << "\n"; + abort(); } return Dest; } -static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeFCMP_OGE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_SETCC(>=, UByte); - IMPLEMENT_SETCC(>=, SByte); - IMPLEMENT_SETCC(>=, UShort); - IMPLEMENT_SETCC(>=, Short); - IMPLEMENT_SETCC(>=, UInt); - IMPLEMENT_SETCC(>=, Int); - IMPLEMENT_SETCC(>=, ULong); - IMPLEMENT_SETCC(>=, Long); - IMPLEMENT_SETCC(>=, Float); - IMPLEMENT_SETCC(>=, Double); - IMPLEMENT_SETCC(>=, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(>=, Float); + IMPLEMENT_FCMP(>=, Double); default: - cout << "Unhandled type for SetGE instruction: " << Ty << "\n"; + cerr << "Unhandled type for FCmp GE instruction: " << *Ty << "\n"; + abort(); } return Dest; } -static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeFCMP_OLT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_SETCC(<, UByte); - IMPLEMENT_SETCC(<, SByte); - IMPLEMENT_SETCC(<, UShort); - IMPLEMENT_SETCC(<, Short); - IMPLEMENT_SETCC(<, UInt); - IMPLEMENT_SETCC(<, Int); - IMPLEMENT_SETCC(<, ULong); - IMPLEMENT_SETCC(<, Long); - IMPLEMENT_SETCC(<, Float); - IMPLEMENT_SETCC(<, Double); - IMPLEMENT_SETCC(<, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(<, Float); + IMPLEMENT_FCMP(<, Double); default: - cout << "Unhandled type for SetLT instruction: " << Ty << "\n"; + cerr << "Unhandled type for FCmp LT instruction: " << *Ty << "\n"; + abort(); } return Dest; } -static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2, - const Type *Ty, ExecutionContext &SF) { +static GenericValue executeFCMP_OGT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; - switch (Ty->getPrimitiveID()) { - IMPLEMENT_SETCC(>, UByte); - IMPLEMENT_SETCC(>, SByte); - IMPLEMENT_SETCC(>, UShort); - IMPLEMENT_SETCC(>, Short); - IMPLEMENT_SETCC(>, UInt); - IMPLEMENT_SETCC(>, Int); - IMPLEMENT_SETCC(>, ULong); - IMPLEMENT_SETCC(>, Long); - IMPLEMENT_SETCC(>, Float); - IMPLEMENT_SETCC(>, Double); - IMPLEMENT_SETCC(>, Pointer); + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(>, Float); + IMPLEMENT_FCMP(>, Double); default: - cout << "Unhandled type for SetGT instruction: " << Ty << "\n"; + cerr << "Unhandled type for FCmp GT instruction: " << *Ty << "\n"; + abort(); } return Dest; } -static void executeBinaryInst(BinaryOperator &I, ExecutionContext &SF) { +#define IMPLEMENT_UNORDERED(TY, X,Y) \ + if (TY == Type::FloatTy) \ + if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) { \ + Dest.Int1Val = true; \ + return Dest; \ + } \ + else if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) { \ + Dest.Int1Val = true; \ + return Dest; \ + } + + +static GenericValue executeFCMP_UEQ(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNORDERED(Ty, Src1, Src2) + return executeFCMP_OEQ(Src1, Src2, Ty); +} + +static GenericValue executeFCMP_UNE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNORDERED(Ty, Src1, Src2) + return executeFCMP_ONE(Src1, Src2, Ty); +} + +static GenericValue executeFCMP_ULE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNORDERED(Ty, Src1, Src2) + return executeFCMP_OLE(Src1, Src2, Ty); +} + +static GenericValue executeFCMP_UGE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNORDERED(Ty, Src1, Src2) + return executeFCMP_OGE(Src1, Src2, Ty); +} + +static GenericValue executeFCMP_ULT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNORDERED(Ty, Src1, Src2) + return executeFCMP_OLT(Src1, Src2, Ty); +} + +static GenericValue executeFCMP_UGT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + IMPLEMENT_UNORDERED(Ty, Src1, Src2) + return executeFCMP_OGT(Src1, Src2, Ty); +} + +static GenericValue executeFCMP_ORD(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + if (Ty == Type::FloatTy) + Dest.Int1Val = (Src1.FloatVal == Src1.FloatVal && + Src2.FloatVal == Src2.FloatVal); + else + Dest.Int1Val = (Src1.DoubleVal == Src1.DoubleVal && + Src2.DoubleVal == Src2.DoubleVal); + return Dest; +} + +static GenericValue executeFCMP_UNO(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + if (Ty == Type::FloatTy) + Dest.Int1Val = (Src1.FloatVal != Src1.FloatVal || + Src2.FloatVal != Src2.FloatVal); + else + Dest.Int1Val = (Src1.DoubleVal != Src1.DoubleVal || + Src2.DoubleVal != Src2.DoubleVal); + return Dest; +} + +void Interpreter::visitFCmpInst(FCmpInst &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 R; // Result + + switch (I.getPredicate()) { + case FCmpInst::FCMP_FALSE: R.Int1Val = false; break; + case FCmpInst::FCMP_TRUE: R.Int1Val = true; break; + case FCmpInst::FCMP_ORD: R = executeFCMP_ORD(Src1, Src2, Ty); break; + case FCmpInst::FCMP_UNO: R = executeFCMP_UNO(Src1, Src2, Ty); break; + case FCmpInst::FCMP_UEQ: R = executeFCMP_UEQ(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OEQ: R = executeFCMP_OEQ(Src1, Src2, Ty); break; + case FCmpInst::FCMP_UNE: R = executeFCMP_UNE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_ONE: R = executeFCMP_ONE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_ULT: R = executeFCMP_ULT(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OLT: R = executeFCMP_OLT(Src1, Src2, Ty); break; + case FCmpInst::FCMP_UGT: R = executeFCMP_UGT(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OGT: R = executeFCMP_OGT(Src1, Src2, Ty); break; + case FCmpInst::FCMP_ULE: R = executeFCMP_ULE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OLE: R = executeFCMP_OLE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_UGE: R = executeFCMP_UGE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OGE: R = executeFCMP_OGE(Src1, Src2, Ty); break; + default: + cerr << "Don't know how to handle this FCmp predicate!\n-->" << I; + abort(); + } + + SetValue(&I, R, SF); +} + +static GenericValue executeCmpInst(unsigned predicate, GenericValue Src1, + GenericValue Src2, const Type *Ty) { + GenericValue Result; + switch (predicate) { + case ICmpInst::ICMP_EQ: return executeICMP_EQ(Src1, Src2, Ty); + case ICmpInst::ICMP_NE: return executeICMP_NE(Src1, Src2, Ty); + case ICmpInst::ICMP_UGT: return executeICMP_UGT(Src1, Src2, Ty); + case ICmpInst::ICMP_SGT: return executeICMP_SGT(Src1, Src2, Ty); + case ICmpInst::ICMP_ULT: return executeICMP_ULT(Src1, Src2, Ty); + case ICmpInst::ICMP_SLT: return executeICMP_SLT(Src1, Src2, Ty); + case ICmpInst::ICMP_UGE: return executeICMP_UGE(Src1, Src2, Ty); + case ICmpInst::ICMP_SGE: return executeICMP_SGE(Src1, Src2, Ty); + case ICmpInst::ICMP_ULE: return executeICMP_ULE(Src1, Src2, Ty); + case ICmpInst::ICMP_SLE: return executeICMP_SLE(Src1, Src2, Ty); + case FCmpInst::FCMP_ORD: return executeFCMP_ORD(Src1, Src2, Ty); + case FCmpInst::FCMP_UNO: return executeFCMP_UNO(Src1, Src2, Ty); + case FCmpInst::FCMP_OEQ: return executeFCMP_OEQ(Src1, Src2, Ty); + case FCmpInst::FCMP_UEQ: return executeFCMP_UEQ(Src1, Src2, Ty); + case FCmpInst::FCMP_ONE: return executeFCMP_ONE(Src1, Src2, Ty); + case FCmpInst::FCMP_UNE: return executeFCMP_UNE(Src1, Src2, Ty); + case FCmpInst::FCMP_OLT: return executeFCMP_OLT(Src1, Src2, Ty); + case FCmpInst::FCMP_ULT: return executeFCMP_ULT(Src1, Src2, Ty); + case FCmpInst::FCMP_OGT: return executeFCMP_OGT(Src1, Src2, Ty); + case FCmpInst::FCMP_UGT: return executeFCMP_UGT(Src1, Src2, Ty); + case FCmpInst::FCMP_OLE: return executeFCMP_OLE(Src1, Src2, Ty); + case FCmpInst::FCMP_ULE: return executeFCMP_ULE(Src1, Src2, Ty); + case FCmpInst::FCMP_OGE: return executeFCMP_OGE(Src1, Src2, Ty); + case FCmpInst::FCMP_UGE: return executeFCMP_UGE(Src1, Src2, Ty); + case FCmpInst::FCMP_FALSE: { + GenericValue Result; + Result.Int1Val = false; + return Result; + } + case FCmpInst::FCMP_TRUE: { + GenericValue Result; + Result.Int1Val = true; + return Result; + } + default: + cerr << "Unhandled Cmp predicate\n"; + abort(); + } +} + +void Interpreter::visitBinaryOperator(BinaryOperator &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 R; // Result switch (I.getOpcode()) { - case Instruction::Add: R = executeAddInst (Src1, Src2, Ty, SF); break; - case Instruction::Sub: R = executeSubInst (Src1, Src2, Ty, SF); break; - case Instruction::Mul: R = executeMulInst (Src1, Src2, Ty, SF); break; - case Instruction::Div: R = executeDivInst (Src1, Src2, Ty, SF); break; - case Instruction::Rem: R = executeRemInst (Src1, Src2, Ty, SF); break; - case Instruction::And: R = executeAndInst (Src1, Src2, Ty, SF); break; - case Instruction::Or: R = executeOrInst (Src1, Src2, Ty, SF); break; - case Instruction::Xor: R = executeXorInst (Src1, Src2, Ty, SF); break; - case Instruction::SetEQ: R = executeSetEQInst(Src1, Src2, Ty, SF); break; - case Instruction::SetNE: R = executeSetNEInst(Src1, Src2, Ty, SF); break; - case Instruction::SetLE: R = executeSetLEInst(Src1, Src2, Ty, SF); break; - case Instruction::SetGE: R = executeSetGEInst(Src1, Src2, Ty, SF); break; - case Instruction::SetLT: R = executeSetLTInst(Src1, Src2, Ty, SF); break; - case Instruction::SetGT: R = executeSetGTInst(Src1, Src2, Ty, SF); break; + case Instruction::Add: R = executeAddInst (Src1, Src2, Ty); break; + case Instruction::Sub: R = executeSubInst (Src1, Src2, Ty); break; + case Instruction::Mul: R = executeMulInst (Src1, Src2, Ty); break; + case Instruction::UDiv: R = executeUDivInst (Src1, Src2, Ty); break; + case Instruction::SDiv: R = executeSDivInst (Src1, Src2, Ty); break; + case Instruction::FDiv: R = executeFDivInst (Src1, Src2, Ty); break; + case Instruction::URem: R = executeURemInst (Src1, Src2, Ty); break; + case Instruction::SRem: R = executeSRemInst (Src1, Src2, Ty); break; + case Instruction::FRem: R = executeFRemInst (Src1, Src2, Ty); break; + case Instruction::And: R = executeAndInst (Src1, Src2, Ty); break; + case Instruction::Or: R = executeOrInst (Src1, Src2, Ty); break; + case Instruction::Xor: R = executeXorInst (Src1, Src2, Ty); break; default: - cout << "Don't know how to handle this binary operator!\n-->" << I; - R = Src1; + cerr << "Don't know how to handle this binary operator!\n-->" << I; + abort(); } SetValue(&I, R, SF); } +static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2, + GenericValue Src3) { + return Src1.Int1Val ? 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 //===----------------------------------------------------------------------===// -static void PerformExitStuff() { -#ifdef PROFILE_STRUCTURE_FIELDS - // Print out structure field accounting information... - if (!FieldAccessCounts.empty()) { - CW << "Profile Field Access Counts:\n"; - std::map >::iterator - I = FieldAccessCounts.begin(), E = FieldAccessCounts.end(); - for (; I != E; ++I) { - vector &OfC = I->second; - CW << " '" << (Value*)I->first << "'\t- Sum="; - - unsigned Sum = 0; - for (unsigned i = 0; i < OfC.size(); ++i) - Sum += OfC[i]; - CW << Sum << " - "; - - for (unsigned i = 0; i < OfC.size(); ++i) { - if (i) CW << ", "; - CW << OfC[i]; - } - CW << "\n"; - } - CW << "\n"; - - CW << "Profile Field Access Percentages:\n"; - cout.precision(3); - for (I = FieldAccessCounts.begin(); I != E; ++I) { - vector &OfC = I->second; - unsigned Sum = 0; - for (unsigned i = 0; i < OfC.size(); ++i) - Sum += OfC[i]; - - CW << " '" << (Value*)I->first << "'\t- "; - for (unsigned i = 0; i < OfC.size(); ++i) { - if (i) CW << ", "; - CW << double(OfC[i])/Sum; - } - CW << "\n"; - } - CW << "\n"; - - FieldAccessCounts.clear(); - } -#endif +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.Int32Val); } -void Interpreter::exitCalled(GenericValue GV) { - if (!QuietMode) { - cout << "Program returned "; - print(Type::IntTy, GV); - cout << " via 'void exit(int)'\n"; - } +/// 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 ExitValue, or the Value of the calling +/// 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) { + // Pop the current stack frame. + ECStack.pop_back(); - ExitCode = GV.SByteVal; - ECStack.clear(); - PerformExitStuff(); + if (ECStack.empty()) { // Finished main. Put result into exit code... + if (RetTy && RetTy->isInteger()) { // Nonvoid return type? + ExitValue = Result; // Capture the exit value of the program + } else { + memset(&ExitValue, 0, sizeof(ExitValue)); + } + } else { + // If we have a previous stack frame, and we have a previous call, + // fill in the return value... + ExecutionContext &CallingSF = ECStack.back(); + if (Instruction *I = CallingSF.Caller.getInstruction()) { + if (CallingSF.Caller.getType() != Type::VoidTy) // Save result... + SetValue(I, Result, CallingSF); + if (InvokeInst *II = dyn_cast (I)) + SwitchToNewBasicBlock (II->getNormalDest (), CallingSF); + CallingSF.Caller = CallSite(); // We returned from the call... + } + } } -void Interpreter::executeRetInst(ReturnInst &I, ExecutionContext &SF) { - const Type *RetTy = 0; +void Interpreter::visitReturnInst(ReturnInst &I) { + ExecutionContext &SF = ECStack.back(); + const Type *RetTy = Type::VoidTy; GenericValue Result; // Save away the return value... (if we are not 'ret void') @@ -687,81 +926,117 @@ void Interpreter::executeRetInst(ReturnInst &I, ExecutionContext &SF) { Result = getOperandValue(I.getReturnValue(), SF); } - // Save previously executing meth - const Function *M = ECStack.back().CurMethod; - - // Pop the current stack frame... this invalidates SF - ECStack.pop_back(); - - if (ECStack.empty()) { // Finished main. Put result into exit code... - if (RetTy) { // Nonvoid return type? - if (!QuietMode) { - CW << "Function " << M->getType() << " \"" << M->getName() - << "\" returned "; - print(RetTy, Result); - cout << "\n"; - } - - if (RetTy->isIntegral()) - ExitCode = Result.IntVal; // Capture the exit code of the program - } else { - ExitCode = 0; - } + popStackAndReturnValueToCaller(RetTy, Result); +} - PerformExitStuff(); - return; - } +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 (Inst))); + + // Return from invoke + ExecutionContext &InvokingSF = ECStack.back (); + InvokingSF.Caller = CallSite (); + + // Go to exceptional destination BB of invoke instruction + SwitchToNewBasicBlock(cast(Inst)->getUnwindDest(), InvokingSF); +} - // If we have a previous stack frame, and we have a previous call, fill in - // the return value... - // - ExecutionContext &NewSF = ECStack.back(); - if (NewSF.Caller) { - if (NewSF.Caller->getType() != Type::VoidTy) // Save result... - SetValue(NewSF.Caller, Result, NewSF); - - NewSF.Caller = 0; // We returned from the call... - } else if (!QuietMode) { - // This must be a function that is executing because of a user 'call' - // instruction. - CW << "Function " << M->getType() << " \"" << M->getName() - << "\" returned "; - print(RetTy, Result); - cout << "\n"; - } +void Interpreter::visitUnreachableInst(UnreachableInst &I) { + cerr << "ERROR: Program executed an 'unreachable' instruction!\n"; + abort(); } -void Interpreter::executeBrInst(BranchInst &I, ExecutionContext &SF) { - SF.PrevBB = SF.CurBB; // Update PrevBB so that PHI nodes work... +void Interpreter::visitBranchInst(BranchInst &I) { + ExecutionContext &SF = ECStack.back(); BasicBlock *Dest; Dest = I.getSuccessor(0); // Uncond branches have a fixed dest... if (!I.isUnconditional()) { Value *Cond = I.getCondition(); - GenericValue CondVal = getOperandValue(Cond, SF); - if (CondVal.BoolVal == 0) // If false cond... - Dest = I.getSuccessor(1); + if (getOperandValue(Cond, SF).Int1Val == 0) // If false cond... + Dest = I.getSuccessor(1); } + SwitchToNewBasicBlock(Dest, SF); +} + +void Interpreter::visitSwitchInst(SwitchInst &I) { + ExecutionContext &SF = ECStack.back(); + GenericValue CondVal = getOperandValue(I.getOperand(0), SF); + const Type *ElTy = I.getOperand(0)->getType(); + + // Check to see if any of the cases match... + BasicBlock *Dest = 0; + for (unsigned i = 2, e = I.getNumOperands(); i != e; i += 2) + if (executeICMP_EQ(CondVal, + getOperandValue(I.getOperand(i), SF), ElTy).Int1Val) { + Dest = cast(I.getOperand(i+1)); + break; + } + + if (!Dest) Dest = I.getDefaultDest(); // No cases matched: use default + SwitchToNewBasicBlock(Dest, SF); +} + +// SwitchToNewBasicBlock - This method is used to jump to a new basic block. +// This function handles the actual updating of block and instruction iterators +// as well as execution of all of the PHI nodes in the destination block. +// +// This method does this because all of the PHI nodes must be executed +// atomically, reading their inputs before any of the results are updated. Not +// doing this can cause problems if the PHI nodes depend on other PHI nodes for +// their inputs. If the input PHI node is updated before it is read, incorrect +// results can happen. Thus we use a two phase approach. +// +void Interpreter::SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF){ + BasicBlock *PrevBB = SF.CurBB; // Remember where we came from... SF.CurBB = Dest; // Update CurBB to branch destination SF.CurInst = SF.CurBB->begin(); // Update new instruction ptr... + + if (!isa(SF.CurInst)) return; // Nothing fancy to do + + // Loop over all of the PHI nodes in the current block, reading their inputs. + std::vector ResultValues; + + for (; PHINode *PN = dyn_cast(SF.CurInst); ++SF.CurInst) { + // Search for the value corresponding to this previous bb... + int i = PN->getBasicBlockIndex(PrevBB); + assert(i != -1 && "PHINode doesn't contain entry for predecessor??"); + Value *IncomingValue = PN->getIncomingValue(i); + + // Save the incoming value for this PHI node... + ResultValues.push_back(getOperandValue(IncomingValue, SF)); + } + + // Now loop over all of the PHI nodes setting their values... + SF.CurInst = SF.CurBB->begin(); + for (unsigned i = 0; isa(SF.CurInst); ++SF.CurInst, ++i) { + PHINode *PN = cast(SF.CurInst); + SetValue(PN, ResultValues[i], SF); + } } //===----------------------------------------------------------------------===// // Memory Instruction Implementations //===----------------------------------------------------------------------===// -void Interpreter::executeAllocInst(AllocationInst &I, ExecutionContext &SF) { +void Interpreter::visitAllocationInst(AllocationInst &I) { + ExecutionContext &SF = ECStack.back(); + const Type *Ty = I.getType()->getElementType(); // Type to be allocated // Get the number of elements being allocated by the array... - unsigned NumElements = getOperandValue(I.getOperand(0), SF).UIntVal; + unsigned NumElements = getOperandValue(I.getOperand(0), SF).Int32Val; // Allocate enough memory to hold the type... - // FIXME: Don't use CALLOC, use a tainted malloc. - void *Memory = calloc(NumElements, TD.getTypeSize(Ty)); + void *Memory = malloc(NumElements * (size_t)TD.getTypeSize(Ty)); - GenericValue Result; - Result.PointerVal = (PointerTy)Memory; + GenericValue Result = PTOGV(Memory); assert(Result.PointerVal != 0 && "Null pointer returned by malloc!"); SetValue(&I, Result, SF); @@ -769,63 +1044,48 @@ void Interpreter::executeAllocInst(AllocationInst &I, ExecutionContext &SF) { ECStack.back().Allocas.add(Memory); } -static void executeFreeInst(FreeInst &I, ExecutionContext &SF) { +void Interpreter::visitFreeInst(FreeInst &I) { + ExecutionContext &SF = ECStack.back(); assert(isa(I.getOperand(0)->getType()) && "Freeing nonptr?"); GenericValue Value = getOperandValue(I.getOperand(0), SF); // TODO: Check to make sure memory is allocated - free((void*)Value.PointerVal); // Free memory + free(GVTOP(Value)); // Free memory } - // getElementOffset - The workhorse for getelementptr. // -static GenericValue executeGEPOperation(Value *Ptr, User::op_iterator I, - User::op_iterator E, - ExecutionContext &SF) { +GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I, + gep_type_iterator E, + ExecutionContext &SF) { assert(isa(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(Ty)) { + if (const StructType *STy = dyn_cast(*I)) { const StructLayout *SLO = TD.getStructLayout(STy); - - // Indicies must be ubyte constants... - const ConstantUInt *CPU = cast(*I); - assert(CPU->getType() == Type::UByteTy); - unsigned Index = CPU->getValue(); - -#ifdef PROFILE_STRUCTURE_FIELDS - if (ProfileStructureFields) { - // Do accounting for this field... - vector &OfC = FieldAccessCounts[STy]; - if (OfC.size() == 0) OfC.resize(STy->getElementTypes().size()); - OfC[Index]++; - } -#endif - - Total += SLO->MemberOffsets[Index]; - Ty = STy->getElementTypes()[Index]; - } else if (const SequentialType *ST = cast(Ty)) { - - // Get the index number for the array... which must be uint type... - assert((*I)->getType() == Type::LongTy); - unsigned Idx = getOperandValue(*I, SF).LongVal; - if (const ArrayType *AT = dyn_cast(ST)) - if (Idx >= AT->getNumElements() && ArrayChecksEnabled) { - cerr << "Out of range memory access to element #" << Idx - << " of a " << AT->getNumElements() << " element array." - << " Subscript #" << *I << "\n"; - // Get outta here!!! - siglongjmp(SignalRecoverBuffer, SIGTRAP); - } - - Ty = ST->getElementType(); - unsigned Size = TD.getTypeSize(Ty); - Total += Size*Idx; - } + + const ConstantInt *CPU = cast(I.getOperand()); + unsigned Index = unsigned(CPU->getZExtValue()); + + Total += (PointerTy)SLO->MemberOffsets[Index]; + } else { + const SequentialType *ST = cast(*I); + // Get the index number for the array... which must be long type... + GenericValue IdxGV = getOperandValue(I.getOperand(), SF); + + int64_t Idx; + unsigned BitWidth = + cast(I.getOperand()->getType())->getBitWidth(); + if (BitWidth == 32) + Idx = (int64_t)(int32_t)IdxGV.Int32Val; + else if (BitWidth == 64) + Idx = (int64_t)IdxGV.Int64Val; + else + assert(0 && "Invalid index type for getelementptr"); + Total += PointerTy(TD.getTypeSize(ST->getElementType())*Idx); + } } GenericValue Result; @@ -833,672 +1093,664 @@ static GenericValue executeGEPOperation(Value *Ptr, User::op_iterator I, return Result; } -static void executeGEPInst(GetElementPtrInst &I, ExecutionContext &SF) { - SetValue(&I, executeGEPOperation(I.getPointerOperand(), - I.idx_begin(), I.idx_end(), SF), SF); +void Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, TheEE->executeGEPOperation(I.getPointerOperand(), + gep_type_begin(I), gep_type_end(I), SF), SF); } -static void executeLoadInst(LoadInst &I, ExecutionContext &SF) { +void Interpreter::visitLoadInst(LoadInst &I) { + ExecutionContext &SF = ECStack.back(); GenericValue SRC = getOperandValue(I.getPointerOperand(), SF); - GenericValue *Ptr = (GenericValue*)SRC.PointerVal; - GenericValue Result; - - if (TD.isLittleEndian()) { - switch (I.getType()->getPrimitiveID()) { - case Type::BoolTyID: - case Type::UByteTyID: - case Type::SByteTyID: Result.UByteVal = Ptr->Untyped[0]; break; - case Type::UShortTyID: - case Type::ShortTyID: Result.UShortVal = (unsigned)Ptr->Untyped[0] | - ((unsigned)Ptr->Untyped[1] << 8); - break; - case Type::FloatTyID: - case Type::UIntTyID: - case Type::IntTyID: Result.UIntVal = (unsigned)Ptr->Untyped[0] | - ((unsigned)Ptr->Untyped[1] << 8) | - ((unsigned)Ptr->Untyped[2] << 16) | - ((unsigned)Ptr->Untyped[3] << 24); - break; - case Type::DoubleTyID: - case Type::ULongTyID: - case Type::LongTyID: - case Type::PointerTyID: Result.ULongVal = (uint64_t)Ptr->Untyped[0] | - ((uint64_t)Ptr->Untyped[1] << 8) | - ((uint64_t)Ptr->Untyped[2] << 16) | - ((uint64_t)Ptr->Untyped[3] << 24) | - ((uint64_t)Ptr->Untyped[4] << 32) | - ((uint64_t)Ptr->Untyped[5] << 40) | - ((uint64_t)Ptr->Untyped[6] << 48) | - ((uint64_t)Ptr->Untyped[7] << 56); - break; - default: - cout << "Cannot load value of type " << I.getType() << "!\n"; - } - } else { - switch (I.getType()->getPrimitiveID()) { - case Type::BoolTyID: - case Type::UByteTyID: - case Type::SByteTyID: Result.UByteVal = Ptr->Untyped[0]; break; - case Type::UShortTyID: - case Type::ShortTyID: Result.UShortVal = (unsigned)Ptr->Untyped[1] | - ((unsigned)Ptr->Untyped[0] << 8); - break; - case Type::FloatTyID: - case Type::UIntTyID: - case Type::IntTyID: Result.UIntVal = (unsigned)Ptr->Untyped[3] | - ((unsigned)Ptr->Untyped[2] << 8) | - ((unsigned)Ptr->Untyped[1] << 16) | - ((unsigned)Ptr->Untyped[0] << 24); - break; - case Type::DoubleTyID: - case Type::ULongTyID: - case Type::LongTyID: - case Type::PointerTyID: Result.ULongVal = (uint64_t)Ptr->Untyped[7] | - ((uint64_t)Ptr->Untyped[6] << 8) | - ((uint64_t)Ptr->Untyped[5] << 16) | - ((uint64_t)Ptr->Untyped[4] << 24) | - ((uint64_t)Ptr->Untyped[3] << 32) | - ((uint64_t)Ptr->Untyped[2] << 40) | - ((uint64_t)Ptr->Untyped[1] << 48) | - ((uint64_t)Ptr->Untyped[0] << 56); - break; - default: - cout << "Cannot load value of type " << I.getType() << "!\n"; - } - } - + GenericValue *Ptr = (GenericValue*)GVTOP(SRC); + GenericValue Result = LoadValueFromMemory(Ptr, I.getType()); SetValue(&I, Result, SF); } -static void StoreValueToMemory(GenericValue Val, GenericValue *Ptr, - const Type *Ty) { - if (TD.isLittleEndian()) { - switch (Ty->getPrimitiveID()) { - case Type::BoolTyID: - case Type::UByteTyID: - case Type::SByteTyID: Ptr->Untyped[0] = Val.UByteVal; break; - case Type::UShortTyID: - case Type::ShortTyID: Ptr->Untyped[0] = Val.UShortVal & 255; - Ptr->Untyped[1] = (Val.UShortVal >> 8) & 255; - break; - case Type::FloatTyID: - case Type::UIntTyID: - case Type::IntTyID: Ptr->Untyped[0] = Val.UIntVal & 255; - Ptr->Untyped[1] = (Val.UIntVal >> 8) & 255; - Ptr->Untyped[2] = (Val.UIntVal >> 16) & 255; - Ptr->Untyped[3] = (Val.UIntVal >> 24) & 255; - break; - case Type::DoubleTyID: - case Type::ULongTyID: - case Type::LongTyID: - case Type::PointerTyID: Ptr->Untyped[0] = Val.ULongVal & 255; - Ptr->Untyped[1] = (Val.ULongVal >> 8) & 255; - Ptr->Untyped[2] = (Val.ULongVal >> 16) & 255; - Ptr->Untyped[3] = (Val.ULongVal >> 24) & 255; - Ptr->Untyped[4] = (Val.ULongVal >> 32) & 255; - Ptr->Untyped[5] = (Val.ULongVal >> 40) & 255; - Ptr->Untyped[6] = (Val.ULongVal >> 48) & 255; - Ptr->Untyped[7] = (Val.ULongVal >> 56) & 255; - break; - default: - cout << "Cannot store value of type " << Ty << "!\n"; - } - } else { - switch (Ty->getPrimitiveID()) { - case Type::BoolTyID: - case Type::UByteTyID: - case Type::SByteTyID: Ptr->Untyped[0] = Val.UByteVal; break; - case Type::UShortTyID: - case Type::ShortTyID: Ptr->Untyped[1] = Val.UShortVal & 255; - Ptr->Untyped[0] = (Val.UShortVal >> 8) & 255; - break; - case Type::FloatTyID: - case Type::UIntTyID: - case Type::IntTyID: Ptr->Untyped[3] = Val.UIntVal & 255; - Ptr->Untyped[2] = (Val.UIntVal >> 8) & 255; - Ptr->Untyped[1] = (Val.UIntVal >> 16) & 255; - Ptr->Untyped[0] = (Val.UIntVal >> 24) & 255; - break; - case Type::DoubleTyID: - case Type::ULongTyID: - case Type::LongTyID: - case Type::PointerTyID: Ptr->Untyped[7] = Val.ULongVal & 255; - Ptr->Untyped[6] = (Val.ULongVal >> 8) & 255; - Ptr->Untyped[5] = (Val.ULongVal >> 16) & 255; - Ptr->Untyped[4] = (Val.ULongVal >> 24) & 255; - Ptr->Untyped[3] = (Val.ULongVal >> 32) & 255; - Ptr->Untyped[2] = (Val.ULongVal >> 40) & 255; - Ptr->Untyped[1] = (Val.ULongVal >> 48) & 255; - Ptr->Untyped[0] = (Val.ULongVal >> 56) & 255; - break; - default: - cout << "Cannot store value of type " << Ty << "!\n"; - } - } -} - -static void executeStoreInst(StoreInst &I, ExecutionContext &SF) { +void Interpreter::visitStoreInst(StoreInst &I) { + ExecutionContext &SF = ECStack.back(); GenericValue Val = getOperandValue(I.getOperand(0), SF); GenericValue SRC = getOperandValue(I.getPointerOperand(), SF); - StoreValueToMemory(Val, (GenericValue *)SRC.PointerVal, + StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC), I.getOperand(0)->getType()); } - -GenericValue Interpreter::CreateArgv(const std::vector &InputArgv){ - // Pointers are 64 bits... - PointerTy *Result = new PointerTy[InputArgv.size()+1]; // 64 bit assumption - - for (unsigned i = 0; i < InputArgv.size(); ++i) { - unsigned Size = InputArgv[i].size()+1; - char *Dest = new char[Size]; - copy(InputArgv[i].begin(), InputArgv[i].end(), Dest); - Dest[Size-1] = 0; - - GenericValue GV; GV.PointerVal = (PointerTy)Dest; - // Endian safe: Result[i] = (PointerTy)Dest; - StoreValueToMemory(GV, (GenericValue*)(Result+i), - Type::LongTy); // 64 bit assumption - } - - Result[InputArgv.size()] = 0; - GenericValue GV; GV.PointerVal = (PointerTy)Result; - return GV; -} - - //===----------------------------------------------------------------------===// // Miscellaneous Instruction Implementations //===----------------------------------------------------------------------===// -void Interpreter::executeCallInst(CallInst &I, ExecutionContext &SF) { - ECStack.back().Caller = &I; - vector ArgVals; - ArgVals.reserve(I.getNumOperands()-1); - for (unsigned i = 1; i < I.getNumOperands(); ++i) - ArgVals.push_back(getOperandValue(I.getOperand(i), SF)); +void Interpreter::visitCallSite(CallSite CS) { + ExecutionContext &SF = ECStack.back(); - // To handle indirect calls, we must get the pointer value from the argument + // Check to see if this is an intrinsic function call... + if (Function *F = CS.getCalledFunction()) + if (F->isExternal ()) + switch (F->getIntrinsicID()) { + case Intrinsic::not_intrinsic: + break; + 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::vaend: // va_end is a noop for the interpreter + return; + case Intrinsic::vacopy: // va_copy: dest = src + SetValue(CS.getInstruction(), getOperandValue(*CS.arg_begin(), SF), SF); + return; + default: + // If it is an unknown intrinsic function, use 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(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; + } + return; + } + + SF.Caller = CS; + std::vector ArgVals; + const unsigned NumArgs = SF.Caller.arg_size(); + ArgVals.reserve(NumArgs); + for (CallSite::arg_iterator i = SF.Caller.arg_begin(), + e = SF.Caller.arg_end(); i != e; ++i) { + Value *V = *i; + ArgVals.push_back(getOperandValue(V, SF)); + // Promote all integral types whose size is < sizeof(int) into ints. We do + // this by zero or sign extending the value as appropriate according to the + // source type. + const Type *Ty = V->getType(); + if (Ty->isInteger()) { + if (Ty->getPrimitiveSizeInBits() == 1) + ArgVals.back().Int32Val = ArgVals.back().Int1Val; + else if (Ty->getPrimitiveSizeInBits() <= 8) + ArgVals.back().Int32Val = ArgVals.back().Int8Val; + else if (Ty->getPrimitiveSizeInBits() <= 16) + ArgVals.back().Int32Val = ArgVals.back().Int16Val; + } + } + + // To handle indirect calls, we must get the pointer value from the argument // and treat it as a function pointer. - GenericValue SRC = getOperandValue(I.getCalledValue(), SF); - - callMethod((Function*)SRC.PointerVal, ArgVals); + GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF); + callFunction((Function*)GVTOP(SRC), ArgVals); } -static void executePHINode(PHINode &I, ExecutionContext &SF) { - BasicBlock *PrevBB = SF.PrevBB; - Value *IncomingValue = 0; - - // Search for the value corresponding to this previous bb... - for (unsigned i = I.getNumIncomingValues(); i > 0;) { - if (I.getIncomingBlock(--i) == PrevBB) { - IncomingValue = I.getIncomingValue(i); - break; +static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + if (const IntegerType *ITy = cast(Ty)) { + unsigned BitWidth = ITy->getBitWidth(); + if (BitWidth <= 8) + Dest.Int8Val = ((uint8_t)Src1.Int8Val) << ((uint32_t)Src2.Int8Val); + else if (BitWidth <= 16) + Dest.Int16Val = ((uint16_t)Src1.Int16Val) << ((uint32_t)Src2.Int8Val); + else if (BitWidth <= 32) + Dest.Int32Val = ((uint32_t)Src1.Int32Val) << ((uint32_t)Src2.Int8Val); + else if (BitWidth <= 64) + Dest.Int64Val = ((uint64_t)Src1.Int64Val) << ((uint32_t)Src2.Int8Val); + else { + cerr << "Integer types > 64 bits not supported: " << *Ty << "\n"; + abort(); } + maskToBitWidth(Dest, BitWidth); + } else { + cerr << "Unhandled type for Shl instruction: " << *Ty << "\n"; + abort(); } - assert(IncomingValue && "No PHI node predecessor for current PrevBB!"); + return Dest; +} - // Found the value, set as the result... - SetValue(&I, getOperandValue(IncomingValue, SF), SF); +static GenericValue executeLShrInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + if (const IntegerType *ITy = cast(Ty)) { + unsigned BitWidth = ITy->getBitWidth(); + if (BitWidth <= 8) + Dest.Int8Val = ((uint8_t)Src1.Int8Val) >> ((uint32_t)Src2.Int8Val); + else if (BitWidth <= 16) + Dest.Int16Val = ((uint16_t)Src1.Int16Val) >> ((uint32_t)Src2.Int8Val); + else if (BitWidth <= 32) + Dest.Int32Val = ((uint32_t)Src1.Int32Val) >> ((uint32_t)Src2.Int8Val); + else if (BitWidth <= 64) + Dest.Int64Val = ((uint64_t)Src1.Int64Val) >> ((uint32_t)Src2.Int8Val); + else { + cerr << "Integer types > 64 bits not supported: " << *Ty << "\n"; + abort(); + } + maskToBitWidth(Dest, BitWidth); + } else { + cerr << "Unhandled type for LShr instruction: " << *Ty << "\n"; + abort(); + } + return Dest; } -#define IMPLEMENT_SHIFT(OP, TY) \ - case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.UByteVal; break +static GenericValue executeAShrInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + if (const IntegerType *ITy = cast(Ty)) { + unsigned BitWidth = ITy->getBitWidth(); + if (BitWidth <= 8) + Dest.Int8Val = ((int8_t)Src1.Int8Val) >> ((int32_t)Src2.Int8Val); + else if (BitWidth <= 16) + Dest.Int16Val = ((int16_t)Src1.Int16Val) >> ((int32_t)Src2.Int8Val); + else if (BitWidth <= 32) + Dest.Int32Val = ((int32_t)Src1.Int32Val) >> ((int32_t)Src2.Int8Val); + else if (BitWidth <= 64) + Dest.Int64Val = ((int64_t)Src1.Int64Val) >> ((int32_t)Src2.Int8Val); + else { + cerr << "Integer types > 64 bits not supported: " << *Ty << "\n"; \ + abort(); + } + maskToBitWidth(Dest, BitWidth); + } else { + cerr << "Unhandled type for AShr instruction: " << *Ty << "\n"; + abort(); + } + return Dest; +} -static void executeShlInst(ShiftInst &I, ExecutionContext &SF) { +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; - - switch (Ty->getPrimitiveID()) { - IMPLEMENT_SHIFT(<<, UByte); - IMPLEMENT_SHIFT(<<, SByte); - IMPLEMENT_SHIFT(<<, UShort); - IMPLEMENT_SHIFT(<<, Short); - IMPLEMENT_SHIFT(<<, UInt); - IMPLEMENT_SHIFT(<<, Int); - IMPLEMENT_SHIFT(<<, ULong); - IMPLEMENT_SHIFT(<<, Long); - IMPLEMENT_SHIFT(<<, Pointer); - default: - cout << "Unhandled type for Shl instruction: " << Ty << "\n"; - } + Dest = executeShlInst (Src1, Src2, Ty); SetValue(&I, Dest, SF); } -static void executeShrInst(ShiftInst &I, ExecutionContext &SF) { +void Interpreter::visitLShr(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; - - switch (Ty->getPrimitiveID()) { - IMPLEMENT_SHIFT(>>, UByte); - IMPLEMENT_SHIFT(>>, SByte); - IMPLEMENT_SHIFT(>>, UShort); - IMPLEMENT_SHIFT(>>, Short); - IMPLEMENT_SHIFT(>>, UInt); - IMPLEMENT_SHIFT(>>, Int); - IMPLEMENT_SHIFT(>>, ULong); - IMPLEMENT_SHIFT(>>, Long); - IMPLEMENT_SHIFT(>>, Pointer); - default: - cout << "Unhandled type for Shr instruction: " << Ty << "\n"; - } + Dest = executeLShrInst (Src1, Src2, Ty); 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, Bool); \ - 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); \ - IMPLEMENT_CAST(DESTTY, DESTCTY, ULong); \ - IMPLEMENT_CAST(DESTTY, DESTCTY, Long); \ - 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 << "\n"; \ - break; \ - } \ - break - -#define IMPLEMENT_CAST_CASE(DESTTY, DESTCTY) \ - IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY); \ - IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY); \ - IMPLEMENT_CAST_CASE_END() - -static GenericValue executeCastOperation(Value *SrcVal, const Type *Ty, - ExecutionContext &SF) { - const Type *SrcTy = SrcVal->getType(); - GenericValue Dest, Src = getOperandValue(SrcVal, SF); +void Interpreter::visitAShr(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 = executeAShrInst (Src1, Src2, Ty); + SetValue(&I, Dest, SF); +} - 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 short)); - IMPLEMENT_CAST_CASE(UInt , (unsigned int )); - IMPLEMENT_CAST_CASE(Int , ( signed int )); - IMPLEMENT_CAST_CASE(ULong , (uint64_t)); - IMPLEMENT_CAST_CASE(Long , ( int64_t)); - IMPLEMENT_CAST_CASE(Pointer, (PointerTy)); - IMPLEMENT_CAST_CASE(Float , (float)); - IMPLEMENT_CAST_CASE(Double , (double)); - default: - cout << "Unhandled dest type for cast instruction: " << Ty << "\n"; +#define INTEGER_ASSIGN(DEST, BITWIDTH, VAL) \ + { \ + uint64_t Mask = (1ull << BITWIDTH) - 1; \ + if (BITWIDTH == 1) { \ + Dest.Int1Val = (bool) (VAL & Mask); \ + } else if (BITWIDTH <= 8) { \ + Dest.Int8Val = (uint8_t) (VAL & Mask); \ + } else if (BITWIDTH <= 16) { \ + Dest.Int16Val = (uint16_t) (VAL & Mask); \ + } else if (BITWIDTH <= 32) { \ + Dest.Int32Val = (uint32_t) (VAL & Mask); \ + } else \ + Dest.Int64Val = (uint64_t) (VAL & Mask); \ } +GenericValue Interpreter::executeTruncInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + const IntegerType *DITy = cast(DstTy); + const IntegerType *SITy = cast(SrcTy); + unsigned DBitWidth = DITy->getBitWidth(); + unsigned SBitWidth = SITy->getBitWidth(); + assert(SBitWidth <= 64 && DBitWidth <= 64 && + "Integer types > 64 bits not supported"); + assert(SBitWidth > DBitWidth && "Invalid truncate"); + + // Mask the source value to its actual bit width. This ensures that any + // high order bits are cleared. + uint64_t Mask = (1ULL << DBitWidth) - 1; + uint64_t MaskedVal = 0; + if (SBitWidth <= 8) + MaskedVal = Src.Int8Val & Mask; + else if (SBitWidth <= 16) + MaskedVal = Src.Int16Val & Mask; + else if (SBitWidth <= 32) + MaskedVal = Src.Int32Val & Mask; + else + MaskedVal = Src.Int64Val & Mask; + + INTEGER_ASSIGN(Dest, DBitWidth, MaskedVal); return Dest; } - -static void executeCastInst(CastInst &I, ExecutionContext &SF) { - SetValue(&I, executeCastOperation(I.getOperand(0), I.getType(), SF), SF); +GenericValue Interpreter::executeSExtInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + const IntegerType *DITy = cast(DstTy); + const IntegerType *SITy = cast(SrcTy); + unsigned DBitWidth = DITy->getBitWidth(); + unsigned SBitWidth = SITy->getBitWidth(); + assert(SBitWidth <= 64 && DBitWidth <= 64 && + "Integer types > 64 bits not supported"); + assert(SBitWidth < DBitWidth && "Invalid sign extend"); + + // Normalize to a 64-bit value. + uint64_t Normalized = 0; + if (SBitWidth <= 8) + Normalized = Src.Int8Val; + else if (SBitWidth <= 16) + Normalized = Src.Int16Val; + else if (SBitWidth <= 32) + Normalized = Src.Int32Val; + else + Normalized = Src.Int64Val; + + // Now do the bit-accurate sign extension manually. + bool isSigned = (Normalized & (1 << (SBitWidth-1))) != 0; + if (isSigned) + Normalized |= ~SITy->getBitMask(); + + // Now that we have a sign extended value, assign it to the destination + INTEGER_ASSIGN(Dest, DBitWidth, Normalized); + return Dest; } - -//===----------------------------------------------------------------------===// -// Dispatch and Execution Code -//===----------------------------------------------------------------------===// - -MethodInfo::MethodInfo(Function *F) : Annotation(MethodInfoAID) { - // Assign slot numbers to the function arguments... - for (Function::const_aiterator AI = F->abegin(), E = F->aend(); AI != E; ++AI) - AI->addAnnotation(new SlotNumber(getValueSlot(AI))); - - // Iterate over all of the instructions... - unsigned InstNum = 0; - for (Function::iterator BB = F->begin(), BBE = F->end(); BB != BBE; ++BB) - for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE; ++II) - // For each instruction... Add Annote - II->addAnnotation(new InstNumber(++InstNum, getValueSlot(II))); +GenericValue Interpreter::executeZExtInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + const IntegerType *DITy = cast(DstTy); + const IntegerType *SITy = cast(SrcTy); + unsigned DBitWidth = DITy->getBitWidth(); + unsigned SBitWidth = SITy->getBitWidth(); + assert(SBitWidth <= 64 && DBitWidth <= 64 && + "Integer types > 64 bits not supported"); + assert(SBitWidth < DBitWidth && "Invalid sign extend"); + uint64_t Extended = 0; + if (SBitWidth == 1) + // For sign extension from bool, we must extend the source bits. + Extended = (uint64_t) (Src.Int1Val & 1); + else if (SBitWidth <= 8) + Extended = (uint64_t) (uint8_t)Src.Int8Val; + else if (SBitWidth <= 16) + Extended = (uint64_t) (uint16_t)Src.Int16Val; + else if (SBitWidth <= 32) + Extended = (uint64_t) (uint32_t)Src.Int32Val; + else + Extended = (uint64_t) Src.Int64Val; + + // Now that we have a sign extended value, assign it to the destination + INTEGER_ASSIGN(Dest, DBitWidth, Extended); + return Dest; } -unsigned MethodInfo::getValueSlot(const Value *V) { - unsigned Plane = V->getType()->getUniqueID(); - if (Plane >= NumPlaneElements.size()) - NumPlaneElements.resize(Plane+1, 0); - return NumPlaneElements[Plane]++; +GenericValue Interpreter::executeFPTruncInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + assert(SrcTy == Type::DoubleTy && DstTy == Type::FloatTy && + "Invalid FPTrunc instruction"); + Dest.FloatVal = (float) Src.DoubleVal; + return Dest; } +GenericValue Interpreter::executeFPExtInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + assert(SrcTy == Type::FloatTy && DstTy == Type::DoubleTy && + "Invalid FPTrunc instruction"); + Dest.DoubleVal = (double) Src.FloatVal; + return Dest; +} -//===----------------------------------------------------------------------===// -// callMethod - Execute the specified function... -// -void Interpreter::callMethod(Function *M, const vector &ArgVals) { - assert((ECStack.empty() || ECStack.back().Caller == 0 || - ECStack.back().Caller->getNumOperands()-1 == ArgVals.size()) && - "Incorrect number of arguments passed into function call!"); - if (M->isExternal()) { - GenericValue Result = callExternalMethod(M, ArgVals); - const Type *RetTy = M->getReturnType(); - - // Copy the result back into the result variable if we are not returning - // void. - if (RetTy != Type::VoidTy) { - if (!ECStack.empty() && ECStack.back().Caller) { - ExecutionContext &SF = ECStack.back(); - SetValue(SF.Caller, Result, SF); - - SF.Caller = 0; // We returned from the call... - } else if (!QuietMode) { - // print it. - CW << "Function " << M->getType() << " \"" << M->getName() - << "\" returned "; - print(RetTy, Result); - cout << "\n"; - - if (RetTy->isIntegral()) - ExitCode = Result.IntVal; // Capture the exit code of the program - } - } - - return; - } - - // Process the function, assigning instruction numbers to the instructions in - // the function. 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->begin(); - StackFrame.CurInst = StackFrame.CurBB->begin(); - StackFrame.MethInfo = MethInfo; - - // Initialize the values to nothing... - StackFrame.Values.resize(MethInfo->NumPlaneElements.size()); - for (unsigned i = 0; i < MethInfo->NumPlaneElements.size(); ++i) { - StackFrame.Values[i].resize(MethInfo->NumPlaneElements[i]); +GenericValue Interpreter::executeFPToUIInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + const IntegerType *DITy = cast(DstTy); + unsigned DBitWidth = DITy->getBitWidth(); + assert(DBitWidth <= 64 && "Integer types > 64 bits not supported"); + assert(SrcTy->isFloatingPoint() && "Invalid FPToUI instruction"); + uint64_t Converted = 0; + if (SrcTy->getTypeID() == Type::FloatTyID) + Converted = (uint64_t) Src.FloatVal; + else + Converted = (uint64_t) Src.DoubleVal; + + INTEGER_ASSIGN(Dest, DBitWidth, Converted); + return Dest; +} - // Taint the initial values of stuff - memset(&StackFrame.Values[i][0], 42, - MethInfo->NumPlaneElements[i]*sizeof(GenericValue)); - } +GenericValue Interpreter::executeFPToSIInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + const IntegerType *DITy = cast(DstTy); + unsigned DBitWidth = DITy->getBitWidth(); + assert(DBitWidth <= 64 && "Integer types > 64 bits not supported"); + assert(SrcTy->isFloatingPoint() && "Invalid FPToSI instruction"); + int64_t Converted = 0; + if (SrcTy->getTypeID() == Type::FloatTyID) + Converted = (int64_t) Src.FloatVal; + else + Converted = (int64_t) Src.DoubleVal; + + INTEGER_ASSIGN(Dest, DBitWidth, Converted); + return Dest; +} - StackFrame.PrevBB = 0; // No previous BB for PHI nodes... +GenericValue Interpreter::executeUIToFPInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + const IntegerType *SITy = cast(SrcTy); + unsigned SBitWidth = SITy->getBitWidth(); + assert(SBitWidth <= 64 && "Integer types > 64 bits not supported"); + assert(DstTy->isFloatingPoint() && "Invalid UIToFP instruction"); + uint64_t Converted = 0; + if (SBitWidth == 1) + Converted = (uint64_t) Src.Int1Val; + else if (SBitWidth <= 8) + Converted = (uint64_t) Src.Int8Val; + else if (SBitWidth <= 16) + Converted = (uint64_t) Src.Int16Val; + else if (SBitWidth <= 32) + Converted = (uint64_t) Src.Int32Val; + else + Converted = (uint64_t) Src.Int64Val; + + if (DstTy->getTypeID() == Type::FloatTyID) + Dest.FloatVal = (float) Converted; + else + Dest.DoubleVal = (double) Converted; + return Dest; +} +GenericValue Interpreter::executeSIToFPInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + const IntegerType *SITy = cast(SrcTy); + unsigned SBitWidth = SITy->getBitWidth(); + assert(SBitWidth <= 64 && "Integer types > 64 bits not supported"); + assert(DstTy->isFloatingPoint() && "Invalid UIToFP instruction"); + int64_t Converted = 0; + if (SBitWidth == 1) + Converted = 0LL - Src.Int1Val; + else if (SBitWidth <= 8) + Converted = (int64_t) (int8_t)Src.Int8Val; + else if (SBitWidth <= 16) + Converted = (int64_t) (int16_t)Src.Int16Val; + else if (SBitWidth <= 32) + Converted = (int64_t) (int32_t)Src.Int32Val; + else + Converted = (int64_t) Src.Int64Val; + + if (DstTy->getTypeID() == Type::FloatTyID) + Dest.FloatVal = (float) Converted; + else + Dest.DoubleVal = (double) Converted; + return Dest; +} - // Run through the function arguments and initialize their values... - assert(ArgVals.size() == M->asize() && - "Invalid number of values passed to function invocation!"); - unsigned i = 0; - for (Function::aiterator AI = M->abegin(), E = M->aend(); AI != E; ++AI, ++i) - SetValue(AI, ArgVals[i], StackFrame); +GenericValue Interpreter::executePtrToIntInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + const IntegerType *DITy = cast(DstTy); + unsigned DBitWidth = DITy->getBitWidth(); + assert(DBitWidth <= 64 && "Integer types > 64 bits not supported"); + assert(isa(SrcTy) && "Invalid PtrToInt instruction"); + INTEGER_ASSIGN(Dest, DBitWidth, (intptr_t) Src.PointerVal); + return Dest; } -// executeInstruction - Interpret a single instruction, increment the "PC", and -// return true if the next instruction is a breakpoint... -// -bool Interpreter::executeInstruction() { - assert(!ECStack.empty() && "No program running, cannot execute inst!"); - - ExecutionContext &SF = ECStack.back(); // Current stack frame - Instruction &I = *SF.CurInst++; // Increment before execute - - if (Trace) - CW << "Run:" << I; - - // Track the number of dynamic instructions executed. - ++NumDynamicInsts; - - // Set a sigsetjmp buffer so that we can recover if an error happens during - // instruction execution... - // - if (int SigNo = sigsetjmp(SignalRecoverBuffer, 1)) { - --SF.CurInst; // Back up to erroring instruction - if (SigNo != SIGINT) { - cout << "EXCEPTION OCCURRED [" << strsignal(SigNo) << "]:\n"; - printStackTrace(); - // If -abort-on-exception was specified, terminate LLI instead of trying - // to debug it. - // - if (AbortOnExceptions) exit(1); - } else if (SigNo == SIGINT) { - cout << "CTRL-C Detected, execution halted.\n"; - } - InInstruction = false; - return true; - } +GenericValue Interpreter::executeIntToPtrInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + const IntegerType *SITy = cast(SrcTy); + unsigned SBitWidth = SITy->getBitWidth(); + assert(SBitWidth <= 64 && "Integer types > 64 bits not supported"); + assert(isa(DstTy) && "Invalid PtrToInt instruction"); + uint64_t Converted = 0; + if (SBitWidth == 1) + Converted = (uint64_t) Src.Int1Val; + else if (SBitWidth <= 8) + Converted = (uint64_t) Src.Int8Val; + else if (SBitWidth <= 16) + Converted = (uint64_t) Src.Int16Val; + else if (SBitWidth <= 32) + Converted = (uint64_t) Src.Int32Val; + else + Converted = (uint64_t) Src.Int64Val; + + Dest.PointerVal = (PointerTy) Converted; + return Dest; +} - InInstruction = true; - if (I.isBinaryOp()) { - executeBinaryInst(cast(I), SF); - } else { - switch (I.getOpcode()) { - // Terminators - case Instruction::Ret: executeRetInst (cast(I), SF); break; - case Instruction::Br: executeBrInst (cast(I), SF); break; - // Memory Instructions - case Instruction::Alloca: - case Instruction::Malloc: executeAllocInst((AllocationInst&)I, SF); break; - case Instruction::Free: executeFreeInst (cast (I), SF); break; - case Instruction::Load: executeLoadInst (cast (I), SF); break; - case Instruction::Store: executeStoreInst(cast(I), SF); break; - case Instruction::GetElementPtr: - executeGEPInst(cast(I), SF); break; - - // Miscellaneous Instructions - case Instruction::Call: executeCallInst (cast (I), SF); break; - case Instruction::PHINode: executePHINode (cast (I), SF); break; - case Instruction::Shl: executeShlInst (cast(I), SF); break; - case Instruction::Shr: executeShrInst (cast(I), SF); break; - case Instruction::Cast: executeCastInst (cast (I), SF); break; - default: - cout << "Don't know how to execute this instruction!\n-->" << I; - } - } - InInstruction = false; +GenericValue Interpreter::executeBitCastInst(Value *SrcVal, const Type *DstTy, + ExecutionContext &SF) { - // Reset the current frame location to the top of stack - CurFrame = ECStack.size()-1; - - if (CurFrame == -1) return false; // No breakpoint if no code + const Type *SrcTy = SrcVal->getType(); + GenericValue Dest, Src = getOperandValue(SrcVal, SF); + if (isa(DstTy)) { + assert(isa(SrcTy) && "Invalid BitCast"); + Dest.PointerVal = Src.PointerVal; + } else if (DstTy->isInteger()) { + const IntegerType *DITy = cast(DstTy); + unsigned DBitWidth = DITy->getBitWidth(); + if (SrcTy == Type::FloatTy) { + Dest.Int32Val = FloatToBits(Src.FloatVal); + } else if (SrcTy == Type::DoubleTy) { + Dest.Int64Val = DoubleToBits(Src.DoubleVal); + } else if (SrcTy->isInteger()) { + const IntegerType *SITy = cast(SrcTy); + unsigned SBitWidth = SITy->getBitWidth(); + assert(SBitWidth <= 64 && "Integer types > 64 bits not supported"); + assert(SBitWidth == DBitWidth && "Invalid BitCast"); + if (SBitWidth == 1) + Dest.Int1Val = Src.Int1Val; + else if (SBitWidth <= 8) + Dest.Int8Val = Src.Int8Val; + else if (SBitWidth <= 16) + Dest.Int16Val = Src.Int16Val; + else if (SBitWidth <= 32) + Dest.Int32Val = Src.Int32Val; + else + Dest.Int64Val = Src.Int64Val; + maskToBitWidth(Dest, DBitWidth); + } else + assert(0 && "Invalid BitCast"); + } else if (DstTy == Type::FloatTy) { + if (SrcTy->isInteger()) + Dest.FloatVal = BitsToFloat(Src.Int32Val); + else + Dest.FloatVal = Src.FloatVal; + } else if (DstTy == Type::DoubleTy) { + if (SrcTy->isInteger()) + Dest.DoubleVal = BitsToDouble(Src.Int64Val); + else + Dest.DoubleVal = Src.DoubleVal; + } else + assert(0 && "Invalid Bitcast"); - // Return true if there is a breakpoint annotation on the instruction... - return ECStack[CurFrame].CurInst->getAnnotation(BreakpointAID) != 0; + return Dest; } -void Interpreter::stepInstruction() { // Do the 'step' command - if (ECStack.empty()) { - cout << "Error: no program running, cannot step!\n"; - return; - } - - // Run an instruction... - executeInstruction(); - - // Print the next instruction to execute... - printCurrentInstruction(); +void Interpreter::visitTruncInst(TruncInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeTruncInst(I.getOperand(0), I.getType(), SF), SF); } -// --- UI Stuff... -void Interpreter::nextInstruction() { // Do the 'next' command - if (ECStack.empty()) { - cout << "Error: no program running, cannot 'next'!\n"; - return; - } - - // If this is a call instruction, step over the call instruction... - // TODO: ICALL, CALL WITH, ... - if (ECStack.back().CurInst->getOpcode() == Instruction::Call) { - unsigned StackSize = ECStack.size(); - // Step into the function... - if (executeInstruction()) { - // Hit a breakpoint, print current instruction, then return to user... - cout << "Breakpoint hit!\n"; - printCurrentInstruction(); - return; - } +void Interpreter::visitSExtInst(SExtInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeSExtInst(I.getOperand(0), I.getType(), SF), SF); +} - // If we we able to step into the function, finish it now. We might not be - // able the step into a function, if it's external for example. - if (ECStack.size() != StackSize) - finish(); // Finish executing the function... - else - printCurrentInstruction(); +void Interpreter::visitZExtInst(ZExtInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeZExtInst(I.getOperand(0), I.getType(), SF), SF); +} - } else { - // Normal instruction, just step... - stepInstruction(); - } +void Interpreter::visitFPTruncInst(FPTruncInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeFPTruncInst(I.getOperand(0), I.getType(), SF), SF); } -void Interpreter::run() { - if (ECStack.empty()) { - cout << "Error: no program running, cannot run!\n"; - return; - } +void Interpreter::visitFPExtInst(FPExtInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeFPExtInst(I.getOperand(0), I.getType(), SF), SF); +} - bool HitBreakpoint = false; - while (!ECStack.empty() && !HitBreakpoint) { - // Run an instruction... - HitBreakpoint = executeInstruction(); - } +void Interpreter::visitUIToFPInst(UIToFPInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeUIToFPInst(I.getOperand(0), I.getType(), SF), SF); +} - if (HitBreakpoint) { - cout << "Breakpoint hit!\n"; - } - // Print the next instruction to execute... - printCurrentInstruction(); +void Interpreter::visitSIToFPInst(SIToFPInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeSIToFPInst(I.getOperand(0), I.getType(), SF), SF); } -void Interpreter::finish() { - if (ECStack.empty()) { - cout << "Error: no program running, cannot run!\n"; - return; - } +void Interpreter::visitFPToUIInst(FPToUIInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeFPToUIInst(I.getOperand(0), I.getType(), SF), SF); +} - unsigned StackSize = ECStack.size(); - bool HitBreakpoint = false; - while (ECStack.size() >= StackSize && !HitBreakpoint) { - // Run an instruction... - HitBreakpoint = executeInstruction(); - } +void Interpreter::visitFPToSIInst(FPToSIInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeFPToSIInst(I.getOperand(0), I.getType(), SF), SF); +} - if (HitBreakpoint) { - cout << "Breakpoint hit!\n"; - } +void Interpreter::visitPtrToIntInst(PtrToIntInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executePtrToIntInst(I.getOperand(0), I.getType(), SF), SF); +} - // Print the next instruction to execute... - printCurrentInstruction(); +void Interpreter::visitIntToPtrInst(IntToPtrInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeIntToPtrInst(I.getOperand(0), I.getType(), SF), SF); } +void Interpreter::visitBitCastInst(BitCastInst &I) { + ExecutionContext &SF = ECStack.back(); + SetValue(&I, executeBitCastInst(I.getOperand(0), I.getType(), SF), SF); +} +#define IMPLEMENT_VAARG(TY) \ + case Type::TY##TyID: Dest.TY##Val = Src.TY##Val; break -// printCurrentInstruction - Print out the instruction that the virtual PC is -// at, or fail silently if no program is running. -// -void Interpreter::printCurrentInstruction() { - if (!ECStack.empty()) { - if (ECStack.back().CurBB->begin() == ECStack.back().CurInst) // print label - WriteAsOperand(cout, ECStack.back().CurBB) << ":\n"; - - Instruction &I = *ECStack.back().CurInst; - InstNumber *IN = (InstNumber*)I.getAnnotation(SlotNumberAID); - assert(IN && "Instruction has no numbering annotation!"); - cout << "#" << IN->InstNum << I; - } -} +void Interpreter::visitVAArgInst(VAArgInst &I) { + ExecutionContext &SF = ECStack.back(); -void Interpreter::printValue(const Type *Ty, GenericValue V) { - switch (Ty->getPrimitiveID()) { - case Type::BoolTyID: cout << (V.BoolVal?"true":"false"); break; - case Type::SByteTyID: - cout << (int)V.SByteVal << " '" << V.SByteVal << "'"; break; - case Type::UByteTyID: - cout << (unsigned)V.UByteVal << " '" << V.UByteVal << "'"; break; - case Type::ShortTyID: cout << V.ShortVal; break; - case Type::UShortTyID: cout << V.UShortVal; break; - case Type::IntTyID: cout << V.IntVal; break; - case Type::UIntTyID: cout << V.UIntVal; break; - case Type::LongTyID: cout << (long)V.LongVal; break; - case Type::ULongTyID: cout << (unsigned long)V.ULongVal; break; - case Type::FloatTyID: cout << V.FloatVal; break; - case Type::DoubleTyID: cout << V.DoubleVal; break; - case Type::PointerTyID:cout << (void*)V.PointerVal; break; + // 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); + GenericValue Dest; + GenericValue Src = ECStack[VAList.UIntPairVal.first] + .VarArgs[VAList.UIntPairVal.second]; + const Type *Ty = I.getType(); + switch (Ty->getTypeID()) { + case Type::IntegerTyID: { + unsigned BitWidth = cast(Ty)->getBitWidth(); + if (BitWidth == 1) + Dest.Int1Val = Src.Int1Val; + else if (BitWidth <= 8) + Dest.Int8Val = Src.Int8Val; + else if (BitWidth <= 16) + Dest.Int16Val = Src.Int16Val; + else if (BitWidth <= 32) + Dest.Int32Val = Src.Int32Val; + else if (BitWidth <= 64) + Dest.Int64Val = Src.Int64Val; + else + assert("Integer types > 64 bits not supported"); + maskToBitWidth(Dest, BitWidth); + } + IMPLEMENT_VAARG(Pointer); + IMPLEMENT_VAARG(Float); + IMPLEMENT_VAARG(Double); default: - cout << "- Don't know how to print value of this type!"; - break; + cerr << "Unhandled dest type for vaarg instruction: " << *Ty << "\n"; + abort(); } -} -void Interpreter::print(const Type *Ty, GenericValue V) { - CW << Ty << " "; - printValue(Ty, V); + // Set the Value of this Instruction. + SetValue(&I, Dest, SF); + + // Move the pointer to the next vararg. + ++VAList.UIntPairVal.second; } -void Interpreter::print(const std::string &Name) { - Value *PickedVal = ChooseOneOption(Name, LookupMatchingNames(Name)); - if (!PickedVal) return; +//===----------------------------------------------------------------------===// +// Dispatch and Execution Code +//===----------------------------------------------------------------------===// - if (const Function *F = dyn_cast(PickedVal)) { - CW << F; // Print the function - } else if (const Type *Ty = dyn_cast(PickedVal)) { - CW << "type %" << Name << " = " << Ty->getDescription() << "\n"; - } else if (const BasicBlock *BB = dyn_cast(PickedVal)) { - CW << BB; // Print the basic block - } else { // Otherwise there should be an annotation for the slot# - print(PickedVal->getType(), - getOperandValue(PickedVal, ECStack[CurFrame])); - cout << "\n"; +//===----------------------------------------------------------------------===// +// callFunction - Execute the specified function... +// +void Interpreter::callFunction(Function *F, + const std::vector &ArgVals) { + assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 || + ECStack.back().Caller.arg_size() == ArgVals.size()) && + "Incorrect number of arguments passed into function call!"); + // Make a new stack frame... and fill it in. + ECStack.push_back(ExecutionContext()); + ExecutionContext &StackFrame = ECStack.back(); + StackFrame.CurFunction = F; + + // Special handling for external functions. + if (F->isExternal()) { + GenericValue Result = callExternalFunction (F, ArgVals); + // Simulate a 'ret' instruction of the appropriate type. + popStackAndReturnValueToCaller (F->getReturnType (), Result); + return; } -} - -void Interpreter::infoValue(const std::string &Name) { - Value *PickedVal = ChooseOneOption(Name, LookupMatchingNames(Name)); - if (!PickedVal) return; - cout << "Value: "; - print(PickedVal->getType(), - getOperandValue(PickedVal, ECStack[CurFrame])); - cout << "\n"; - printOperandInfo(PickedVal, ECStack[CurFrame]); -} + // Get pointers to first LLVM BB & Instruction in function. + StackFrame.CurBB = F->begin(); + StackFrame.CurInst = StackFrame.CurBB->begin(); -// printStackFrame - Print information about the specified stack frame, or -1 -// for the default one. -// -void Interpreter::printStackFrame(int FrameNo) { - if (FrameNo == -1) FrameNo = CurFrame; - Function *F = ECStack[FrameNo].CurMethod; - const Type *RetTy = F->getReturnType(); + // Run through the function arguments and initialize their values... + assert((ArgVals.size() == F->arg_size() || + (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&& + "Invalid number of values passed to function invocation!"); - CW << ((FrameNo == CurFrame) ? '>' : '-') << "#" << FrameNo << ". " - << (Value*)RetTy << " \"" << F->getName() << "\"("; - + // Handle non-varargs arguments... unsigned i = 0; - for (Function::aiterator I = F->abegin(), E = F->aend(); I != E; ++I, ++i) { - if (i != 0) cout << ", "; - CW << *I << "="; - - printValue(I->getType(), getOperandValue(I, ECStack[FrameNo])); - } + for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); AI != E; ++AI, ++i) + SetValue(AI, ArgVals[i], StackFrame); - cout << ")\n"; + // Handle varargs arguments... + StackFrame.VarArgs.assign(ArgVals.begin()+i, ArgVals.end()); +} - if (FrameNo != int(ECStack.size()-1)) { - BasicBlock::iterator I = ECStack[FrameNo].CurInst; - CW << --I; - } else { - CW << *ECStack[FrameNo].CurInst; +void Interpreter::run() { + while (!ECStack.empty()) { + // Interpret a single instruction & increment the "PC". + ExecutionContext &SF = ECStack.back(); // Current stack frame + Instruction &I = *SF.CurInst++; // Increment before execute + + // Track the number of dynamic instructions executed. + ++NumDynamicInsts; + + DOUT << "About to interpret: " << I; + visit(I); // Dispatch to one of the visit* methods... } } -