X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FExecutionEngine%2FInterpreter%2FExecution.cpp;h=97411d3943c26f6f647f11e05e06639354176794;hb=e49661bdf5b7a913d4e368cf511381e524ae403a;hp=5a7181f83eb92515a8ea0ce5c1903cc213cd42d7;hpb=fa8a51e041fc378d4b578c53ee3d3b29590c63a0;p=oota-llvm.git diff --git a/lib/ExecutionEngine/Interpreter/Execution.cpp b/lib/ExecutionEngine/Interpreter/Execution.cpp index 5a7181f83eb..97411d3943c 100644 --- a/lib/ExecutionEngine/Interpreter/Execution.cpp +++ b/lib/ExecutionEngine/Interpreter/Execution.cpp @@ -20,14 +20,11 @@ #include "llvm/Support/GetElementPtrTypeIterator.h" #include "llvm/ADT/Statistic.h" #include "llvm/Support/Debug.h" -#include // For fmod +#include using namespace llvm; -namespace { - Statistic<> NumDynamicInsts("lli", "Number of dynamic instructions executed"); - - Interpreter *TheEE = 0; -} +STATISTIC(NumDynamicInsts, "Number of dynamic instructions executed"); +static Interpreter *TheEE = 0; //===----------------------------------------------------------------------===// @@ -40,44 +37,52 @@ static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2, const Type *Ty); static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2, const Type *Ty); -static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2, - const Type *Ty); static GenericValue 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 executeSetEQInst(GenericValue Src1, GenericValue Src2, - const Type *Ty); -static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2, - const Type *Ty); -static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2, - const Type *Ty); -static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2, - const Type *Ty); -static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2, - const Type *Ty); -static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2, - const Type *Ty); +static GenericValue executeCmpInst(unsigned predicate, GenericValue Src1, + GenericValue Src2, const Type *Ty); static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2, const Type *Ty); -static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2, - const Type *Ty); +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::Cast: - return executeCastOperation(CE->getOperand(0), CE->getType(), SF); + case Instruction::Trunc: + case Instruction::ZExt: + case Instruction::SExt: + case Instruction::FPTrunc: + case Instruction::FPExt: + case Instruction::UIToFP: + case Instruction::SIToFP: + case Instruction::FPToUI: + case Instruction::FPToSI: + case Instruction::PtrToInt: + case Instruction::IntToPtr: + case Instruction::BitCast: + return executeCastOperation(Instruction::CastOps(CE->getOpcode()), + CE->getOperand(0), CE->getType(), SF); case Instruction::GetElementPtr: return executeGEPOperation(CE->getOperand(0), gep_type_begin(CE), gep_type_end(CE), SF); @@ -105,10 +110,18 @@ GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE, return executeFDivInst(getOperandValue(CE->getOperand(0), SF), getOperandValue(CE->getOperand(1), SF), CE->getOperand(0)->getType()); - case Instruction::Rem: - return executeRemInst(getOperandValue(CE->getOperand(0), SF), + 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), @@ -121,44 +134,30 @@ GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE, return executeXorInst(getOperandValue(CE->getOperand(0), SF), getOperandValue(CE->getOperand(1), SF), CE->getOperand(0)->getType()); - case Instruction::SetEQ: - return executeSetEQInst(getOperandValue(CE->getOperand(0), SF), - getOperandValue(CE->getOperand(1), SF), - CE->getOperand(0)->getType()); - case Instruction::SetNE: - return executeSetNEInst(getOperandValue(CE->getOperand(0), SF), - getOperandValue(CE->getOperand(1), SF), - CE->getOperand(0)->getType()); - case Instruction::SetLE: - return executeSetLEInst(getOperandValue(CE->getOperand(0), SF), - getOperandValue(CE->getOperand(1), SF), - CE->getOperand(0)->getType()); - case Instruction::SetGE: - return executeSetGEInst(getOperandValue(CE->getOperand(0), SF), - getOperandValue(CE->getOperand(1), SF), - CE->getOperand(0)->getType()); - case Instruction::SetLT: - return executeSetLTInst(getOperandValue(CE->getOperand(0), SF), - getOperandValue(CE->getOperand(1), SF), - CE->getOperand(0)->getType()); - case Instruction::SetGT: - return executeSetGTInst(getOperandValue(CE->getOperand(0), SF), - getOperandValue(CE->getOperand(1), SF), - CE->getOperand(0)->getType()); - case Instruction::Shl: - return executeShlInst(getOperandValue(CE->getOperand(0), SF), + 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::Shr: - return executeShrInst(getOperandValue(CE->getOperand(0), SF), + 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: - std::cerr << "Unhandled ConstantExpr: " << *CE << "\n"; + cerr << "Unhandled ConstantExpr: " << *CE << "\n"; abort(); return GenericValue(); } @@ -195,18 +194,14 @@ static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2, const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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(+, Int8); + IMPLEMENT_BINARY_OPERATOR(+, Int16); + IMPLEMENT_BINARY_OPERATOR(+, Int32); + IMPLEMENT_BINARY_OPERATOR(+, Int64); IMPLEMENT_BINARY_OPERATOR(+, Float); IMPLEMENT_BINARY_OPERATOR(+, Double); default: - std::cout << "Unhandled type for Add instruction: " << *Ty << "\n"; + cerr << "Unhandled type for Add instruction: " << *Ty << "\n"; abort(); } return Dest; @@ -216,18 +211,14 @@ static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2, const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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(-, Int8); + IMPLEMENT_BINARY_OPERATOR(-, Int16); + IMPLEMENT_BINARY_OPERATOR(-, Int32); + IMPLEMENT_BINARY_OPERATOR(-, Int64); IMPLEMENT_BINARY_OPERATOR(-, Float); IMPLEMENT_BINARY_OPERATOR(-, Double); default: - std::cout << "Unhandled type for Sub instruction: " << *Ty << "\n"; + cerr << "Unhandled type for Sub instruction: " << *Ty << "\n"; abort(); } return Dest; @@ -237,36 +228,33 @@ static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2, const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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(*, Int8); + IMPLEMENT_BINARY_OPERATOR(*, Int16); + IMPLEMENT_BINARY_OPERATOR(*, Int32); + IMPLEMENT_BINARY_OPERATOR(*, Int64); IMPLEMENT_BINARY_OPERATOR(*, Float); IMPLEMENT_BINARY_OPERATOR(*, Double); default: - std::cout << "Unhandled type for Mul instruction: " << *Ty << "\n"; + cerr << "Unhandled type for Mul instruction: " << *Ty << "\n"; abort(); } return Dest; } -#define IMPLEMENT_SIGNLESS_BINOP(OP, TY1, TY2) \ - case Type::TY2##TyID: IMPLEMENT_BINARY_OPERATOR(OP, TY1) +#define IMPLEMENT_SIGNLESS_BINOP(OP, TY, CAST) \ + case Type::TY##TyID: Dest.TY##Val = \ + ((CAST)Src1.TY##Val) OP ((CAST)Src2.TY##Val); break static GenericValue executeUDivInst(GenericValue Src1, GenericValue Src2, const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_SIGNLESS_BINOP(/, UByte, SByte); - IMPLEMENT_SIGNLESS_BINOP(/, UShort, Short); - IMPLEMENT_SIGNLESS_BINOP(/, UInt, Int); - IMPLEMENT_SIGNLESS_BINOP(/, ULong, Long); + IMPLEMENT_SIGNLESS_BINOP(/, Int8, uint8_t); + IMPLEMENT_SIGNLESS_BINOP(/, Int16, uint16_t); + IMPLEMENT_SIGNLESS_BINOP(/, Int32, uint32_t); + IMPLEMENT_SIGNLESS_BINOP(/, Int64, uint64_t); default: - std::cout << "Unhandled type for UDiv instruction: " << *Ty << "\n"; + cerr << "Unhandled type for UDiv instruction: " << *Ty << "\n"; abort(); } return Dest; @@ -276,12 +264,12 @@ static GenericValue executeSDivInst(GenericValue Src1, GenericValue Src2, const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_SIGNLESS_BINOP(/, SByte, UByte); - IMPLEMENT_SIGNLESS_BINOP(/, Short, UShort); - IMPLEMENT_SIGNLESS_BINOP(/, Int, UInt); - IMPLEMENT_SIGNLESS_BINOP(/, Long, ULong); + IMPLEMENT_SIGNLESS_BINOP(/, Int8, int8_t); + IMPLEMENT_SIGNLESS_BINOP(/, Int16, int16_t); + IMPLEMENT_SIGNLESS_BINOP(/, Int32, int32_t); + IMPLEMENT_SIGNLESS_BINOP(/, Int64, int64_t); default: - std::cout << "Unhandled type for SDiv instruction: " << *Ty << "\n"; + cerr << "Unhandled type for SDiv instruction: " << *Ty << "\n"; abort(); } return Dest; @@ -294,24 +282,46 @@ static GenericValue executeFDivInst(GenericValue Src1, GenericValue Src2, IMPLEMENT_BINARY_OPERATOR(/, Float); IMPLEMENT_BINARY_OPERATOR(/, Double); default: - std::cout << "Unhandled type for Div instruction: " << *Ty << "\n"; + cerr << "Unhandled type for Div instruction: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeURemInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_SIGNLESS_BINOP(%, Int8, uint8_t); + IMPLEMENT_SIGNLESS_BINOP(%, Int16, uint16_t); + IMPLEMENT_SIGNLESS_BINOP(%, Int32, uint32_t); + IMPLEMENT_SIGNLESS_BINOP(%, Int64, uint64_t ); + default: + cerr << "Unhandled type for URem instruction: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeSRemInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_SIGNLESS_BINOP(%, Int8, int8_t); + IMPLEMENT_SIGNLESS_BINOP(%, Int16, int16_t); + IMPLEMENT_SIGNLESS_BINOP(%, Int32, int32_t); + IMPLEMENT_SIGNLESS_BINOP(%, Int64, int64_t); + default: + cerr << "Unhandled type for Rem instruction: " << *Ty << "\n"; abort(); } return Dest; } -static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2, +static GenericValue executeFRemInst(GenericValue Src1, GenericValue Src2, const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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); case Type::FloatTyID: Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal); break; @@ -319,7 +329,7 @@ static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2, Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal); break; default: - std::cout << "Unhandled type for Rem instruction: " << *Ty << "\n"; + cerr << "Unhandled type for Rem instruction: " << *Ty << "\n"; abort(); } return Dest; @@ -330,16 +340,12 @@ static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2, GenericValue Dest; switch (Ty->getTypeID()) { IMPLEMENT_BINARY_OPERATOR(&, Bool); - 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(&, Int8); + IMPLEMENT_BINARY_OPERATOR(&, Int16); + IMPLEMENT_BINARY_OPERATOR(&, Int32); + IMPLEMENT_BINARY_OPERATOR(&, Int64); default: - std::cout << "Unhandled type for And instruction: " << *Ty << "\n"; + cerr << "Unhandled type for And instruction: " << *Ty << "\n"; abort(); } return Dest; @@ -350,16 +356,12 @@ static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2, GenericValue Dest; switch (Ty->getTypeID()) { IMPLEMENT_BINARY_OPERATOR(|, Bool); - 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(|, Int8); + IMPLEMENT_BINARY_OPERATOR(|, Int16); + IMPLEMENT_BINARY_OPERATOR(|, Int32); + IMPLEMENT_BINARY_OPERATOR(|, Int64); default: - std::cout << "Unhandled type for Or instruction: " << *Ty << "\n"; + cerr << "Unhandled type for Or instruction: " << *Ty << "\n"; abort(); } return Dest; @@ -370,166 +372,374 @@ static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2, GenericValue Dest; switch (Ty->getTypeID()) { IMPLEMENT_BINARY_OPERATOR(^, Bool); - 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(^, Int8); + IMPLEMENT_BINARY_OPERATOR(^, Int16); + IMPLEMENT_BINARY_OPERATOR(^, Int32); + IMPLEMENT_BINARY_OPERATOR(^, Int64); default: - std::cout << "Unhandled type for Xor instruction: " << *Ty << "\n"; + cerr << "Unhandled type for Xor instruction: " << *Ty << "\n"; abort(); } return Dest; } -#define IMPLEMENT_SETCC(OP, TY) \ - case Type::TY##TyID: Dest.BoolVal = Src1.TY##Val OP Src2.TY##Val; break +#define IMPLEMENT_ICMP(OP, TY, CAST) \ + case Type::TY##TyID: Dest.BoolVal = \ + ((CAST)Src1.TY##Val) OP ((CAST)Src2.TY##Val); 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_POINTERSETCC(OP) \ +#define IMPLEMENT_POINTERCMP(OP) \ case Type::PointerTyID: \ Dest.BoolVal = (void*)(intptr_t)Src1.PointerVal OP \ (void*)(intptr_t)Src2.PointerVal; break -static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { +static GenericValue executeICMP_EQ(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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_POINTERSETCC(==); + IMPLEMENT_ICMP(==, Int8, uint8_t); + IMPLEMENT_ICMP(==, Int16, uint16_t); + IMPLEMENT_ICMP(==, Int32, uint32_t); + IMPLEMENT_ICMP(==, Int64, uint64_t); + IMPLEMENT_POINTERCMP(==); default: - std::cout << "Unhandled type for SetEQ instruction: " << *Ty << "\n"; + cerr << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n"; abort(); } return Dest; } -static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { +static GenericValue executeICMP_NE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_ICMP(!=, Int8, uint8_t); + IMPLEMENT_ICMP(!=, Int16, uint16_t); + IMPLEMENT_ICMP(!=, Int32, uint32_t); + IMPLEMENT_ICMP(!=, Int64, uint64_t); + IMPLEMENT_POINTERCMP(!=); + default: + cerr << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeICMP_ULT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_ICMP(<, Int8, uint8_t); + IMPLEMENT_ICMP(<, Int16, uint16_t); + IMPLEMENT_ICMP(<, Int32, uint32_t); + IMPLEMENT_ICMP(<, Int64, uint64_t); + IMPLEMENT_POINTERCMP(<); + default: + cerr << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeICMP_SLT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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_POINTERSETCC(!=); + IMPLEMENT_ICMP(<, Int8, int8_t); + IMPLEMENT_ICMP(<, Int16, int16_t); + IMPLEMENT_ICMP(<, Int32, int32_t); + IMPLEMENT_ICMP(<, Int64, int64_t); + IMPLEMENT_POINTERCMP(<); + default: + cerr << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n"; + abort(); + } + return Dest; +} +static GenericValue executeICMP_UGT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_ICMP(>, Int8, uint8_t); + IMPLEMENT_ICMP(>, Int16, uint16_t); + IMPLEMENT_ICMP(>, Int32, uint32_t); + IMPLEMENT_ICMP(>, Int64, uint64_t); + IMPLEMENT_POINTERCMP(>); default: - std::cout << "Unhandled type for SetNE instruction: " << *Ty << "\n"; + cerr << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n"; abort(); } return Dest; } -static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { +static GenericValue executeICMP_SGT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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_POINTERSETCC(<=); + IMPLEMENT_ICMP(>, Int8, int8_t); + IMPLEMENT_ICMP(>, Int16, int16_t); + IMPLEMENT_ICMP(>, Int32, int32_t); + IMPLEMENT_ICMP(>, Int64, int64_t); + IMPLEMENT_POINTERCMP(>); default: - std::cout << "Unhandled type for SetLE instruction: " << *Ty << "\n"; + cerr << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n"; abort(); } return Dest; } -static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { +static GenericValue executeICMP_ULE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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_POINTERSETCC(>=); + IMPLEMENT_ICMP(<=, Int8, uint8_t); + IMPLEMENT_ICMP(<=, Int16, uint16_t); + IMPLEMENT_ICMP(<=, Int32, uint32_t); + IMPLEMENT_ICMP(<=, Int64, uint64_t); + IMPLEMENT_POINTERCMP(<=); default: - std::cout << "Unhandled type for SetGE instruction: " << *Ty << "\n"; + cerr << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n"; abort(); } return Dest; } -static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { +static GenericValue executeICMP_SLE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_ICMP(<=, Int8, int8_t); + IMPLEMENT_ICMP(<=, Int16, int16_t); + IMPLEMENT_ICMP(<=, Int32, int32_t); + IMPLEMENT_ICMP(<=, Int64, int64_t); + IMPLEMENT_POINTERCMP(<=); + default: + 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_ICMP(>=, Int8, uint8_t); + IMPLEMENT_ICMP(>=, Int16, uint16_t); + IMPLEMENT_ICMP(>=, Int32, uint32_t); + IMPLEMENT_ICMP(>=, Int64, uint64_t); + IMPLEMENT_POINTERCMP(>=); + default: + cerr << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeICMP_SGE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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_POINTERSETCC(<); + IMPLEMENT_ICMP(>=, Int8, int8_t); + IMPLEMENT_ICMP(>=, Int16, int16_t); + IMPLEMENT_ICMP(>=, Int32, int32_t); + IMPLEMENT_ICMP(>=, Int64, int64_t); + IMPLEMENT_POINTERCMP(>=); default: - std::cout << "Unhandled type for SetLT instruction: " << *Ty << "\n"; + cerr << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n"; abort(); } return Dest; } -static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2, +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_FCMP(OP, TY) \ + case Type::TY##TyID: Dest.BoolVal = Src1.TY##Val OP Src2.TY##Val; break + +static GenericValue executeFCMP_EQ(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(==, Float); + IMPLEMENT_FCMP(==, Double); + default: + cerr << "Unhandled type for SetEQ instruction: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeFCMP_NE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(!=, Float); + IMPLEMENT_FCMP(!=, Double); + + default: + cerr << "Unhandled type for SetNE instruction: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeFCMP_LE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(<=, Float); + IMPLEMENT_FCMP(<=, Double); + default: + cerr << "Unhandled type for SetLE instruction: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeFCMP_GE(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(>=, Float); + IMPLEMENT_FCMP(>=, Double); + default: + cerr << "Unhandled type for SetGE instruction: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeFCMP_LT(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_FCMP(<, Float); + IMPLEMENT_FCMP(<, Double); + default: + cerr << "Unhandled type for SetLT instruction: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeFCMP_GT(GenericValue Src1, GenericValue Src2, const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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_POINTERSETCC(>); + IMPLEMENT_FCMP(>, Float); + IMPLEMENT_FCMP(>, Double); default: - std::cout << "Unhandled type for SetGT instruction: " << *Ty << "\n"; + cerr << "Unhandled type for SetGT instruction: " << *Ty << "\n"; abort(); } 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.BoolVal = false; + case FCmpInst::FCMP_ORD: R = executeFCMP_EQ(Src1, Src2, Ty); break; ///??? + case FCmpInst::FCMP_UNO: R = executeFCMP_NE(Src1, Src2, Ty); break; ///??? + case FCmpInst::FCMP_OEQ: + case FCmpInst::FCMP_UEQ: R = executeFCMP_EQ(Src1, Src2, Ty); break; + case FCmpInst::FCMP_ONE: + case FCmpInst::FCMP_UNE: R = executeFCMP_NE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OLT: + case FCmpInst::FCMP_ULT: R = executeFCMP_LT(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OGT: + case FCmpInst::FCMP_UGT: R = executeFCMP_GT(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OLE: + case FCmpInst::FCMP_ULE: R = executeFCMP_LE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OGE: + case FCmpInst::FCMP_UGE: R = executeFCMP_GE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_TRUE: R.BoolVal = true; + 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_EQ(Src1, Src2, Ty); break; + case FCmpInst::FCMP_UNO: return executeFCMP_NE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OEQ: + case FCmpInst::FCMP_UEQ: return executeFCMP_EQ(Src1, Src2, Ty); break; + case FCmpInst::FCMP_ONE: + case FCmpInst::FCMP_UNE: return executeFCMP_NE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OLT: + case FCmpInst::FCMP_ULT: return executeFCMP_LT(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OGT: + case FCmpInst::FCMP_UGT: return executeFCMP_GT(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OLE: + case FCmpInst::FCMP_ULE: return executeFCMP_LE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_OGE: + case FCmpInst::FCMP_UGE: return executeFCMP_GE(Src1, Src2, Ty); break; + case FCmpInst::FCMP_FALSE: { + GenericValue Result; + Result.BoolVal = false; + return Result; + } + case FCmpInst::FCMP_TRUE: { + GenericValue Result; + Result.BoolVal = 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(); @@ -544,18 +754,14 @@ void Interpreter::visitBinaryOperator(BinaryOperator &I) { 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::Rem: R = executeRemInst (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; - case Instruction::SetEQ: R = executeSetEQInst(Src1, Src2, Ty); break; - case Instruction::SetNE: R = executeSetNEInst(Src1, Src2, Ty); break; - case Instruction::SetLE: R = executeSetLEInst(Src1, Src2, Ty); break; - case Instruction::SetGE: R = executeSetGEInst(Src1, Src2, Ty); break; - case Instruction::SetLT: R = executeSetLTInst(Src1, Src2, Ty); break; - case Instruction::SetGT: R = executeSetGTInst(Src1, Src2, Ty); break; default: - std::cout << "Don't know how to handle this binary operator!\n-->" << I; + cerr << "Don't know how to handle this binary operator!\n-->" << I; abort(); } @@ -587,7 +793,7 @@ void Interpreter::exitCalled(GenericValue GV) { // the stack before interpreting atexit handlers. ECStack.clear (); runAtExitHandlers (); - exit (GV.IntVal); + exit (GV.Int32Val); } /// Pop the last stack frame off of ECStack and then copy the result @@ -656,7 +862,7 @@ void Interpreter::visitUnwindInst(UnwindInst &I) { } void Interpreter::visitUnreachableInst(UnreachableInst &I) { - std::cerr << "ERROR: Program executed an 'unreachable' instruction!\n"; + cerr << "ERROR: Program executed an 'unreachable' instruction!\n"; abort(); } @@ -681,8 +887,8 @@ void Interpreter::visitSwitchInst(SwitchInst &I) { // Check to see if any of the cases match... BasicBlock *Dest = 0; for (unsigned i = 2, e = I.getNumOperands(); i != e; i += 2) - if (executeSetEQInst(CondVal, - getOperandValue(I.getOperand(i), SF), ElTy).BoolVal) { + if (executeICMP_EQ(CondVal, + getOperandValue(I.getOperand(i), SF), ElTy).BoolVal) { Dest = cast(I.getOperand(i+1)); break; } @@ -739,7 +945,7 @@ void Interpreter::visitAllocationInst(AllocationInst &I) { 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... void *Memory = malloc(NumElements * (size_t)TD.getTypeSize(Ty)); @@ -786,14 +992,10 @@ GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I, uint64_t Idx; switch (I.getOperand()->getType()->getTypeID()) { default: assert(0 && "Illegal getelementptr index for sequential type!"); - case Type::SByteTyID: Idx = IdxGV.SByteVal; break; - case Type::ShortTyID: Idx = IdxGV.ShortVal; break; - case Type::IntTyID: Idx = IdxGV.IntVal; break; - case Type::LongTyID: Idx = IdxGV.LongVal; break; - case Type::UByteTyID: Idx = IdxGV.UByteVal; break; - case Type::UShortTyID: Idx = IdxGV.UShortVal; break; - case Type::UIntTyID: Idx = IdxGV.UIntVal; break; - case Type::ULongTyID: Idx = IdxGV.ULongVal; break; + case Type::Int8TyID: Idx = IdxGV.Int8Val; break; + case Type::Int16TyID: Idx = IdxGV.Int16Val; break; + case Type::Int32TyID: Idx = IdxGV.Int32Val; break; + case Type::Int64TyID: Idx = IdxGV.Int64Val; break; } Total += PointerTy(TD.getTypeSize(ST->getElementType())*Idx); } @@ -883,16 +1085,12 @@ void Interpreter::visitCallSite(CallSite CS) { // source type. const Type *Ty = V->getType(); if (Ty->isIntegral() && Ty->getPrimitiveSize() < 4) { - if (Ty == Type::ShortTy) - ArgVals.back().IntVal = ArgVals.back().ShortVal; - else if (Ty == Type::UShortTy) - ArgVals.back().UIntVal = ArgVals.back().UShortVal; - else if (Ty == Type::SByteTy) - ArgVals.back().IntVal = ArgVals.back().SByteVal; - else if (Ty == Type::UByteTy) - ArgVals.back().UIntVal = ArgVals.back().UByteVal; + if (Ty == Type::Int16Ty) + ArgVals.back().Int32Val = ArgVals.back().Int16Val; + else if (Ty == Type::Int8Ty) + ArgVals.back().Int32Val = ArgVals.back().Int8Val; else if (Ty == Type::BoolTy) - ArgVals.back().UIntVal = ArgVals.back().BoolVal; + ArgVals.back().Int32Val = ArgVals.back().BoolVal; else assert(0 && "Unknown type!"); } @@ -905,40 +1103,51 @@ void Interpreter::visitCallSite(CallSite CS) { } #define IMPLEMENT_SHIFT(OP, TY) \ - case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.UByteVal; break + case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.Int8Val; break + +#define IMPLEMENT_SIGNLESS_SHIFT(OP, TY, CAST) \ + case Type::TY##TyID: Dest.TY##Val = ((CAST)Src1.TY##Val) OP Src2.Int8Val; \ + break static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2, const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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(<<, Int8); + IMPLEMENT_SHIFT(<<, Int16); + IMPLEMENT_SHIFT(<<, Int32); + IMPLEMENT_SHIFT(<<, Int64); default: - std::cout << "Unhandled type for Shl instruction: " << *Ty << "\n"; + cerr << "Unhandled type for Shl instruction: " << *Ty << "\n"; } return Dest; } -static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { +static GenericValue executeLShrInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - 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_SIGNLESS_SHIFT(>>, Int8, uint8_t); + IMPLEMENT_SIGNLESS_SHIFT(>>, Int16, uint16_t); + IMPLEMENT_SIGNLESS_SHIFT(>>, Int32, uint32_t); + IMPLEMENT_SIGNLESS_SHIFT(>>, Int64, uint64_t); default: - std::cout << "Unhandled type for Shr instruction: " << *Ty << "\n"; + cerr << "Unhandled type for LShr instruction: " << *Ty << "\n"; + abort(); + } + return Dest; +} + +static GenericValue executeAShrInst(GenericValue Src1, GenericValue Src2, + const Type *Ty) { + GenericValue Dest; + switch (Ty->getTypeID()) { + IMPLEMENT_SIGNLESS_SHIFT(>>, Int8, int8_t); + IMPLEMENT_SIGNLESS_SHIFT(>>, Int16, int16_t); + IMPLEMENT_SIGNLESS_SHIFT(>>, Int32, int32_t); + IMPLEMENT_SIGNLESS_SHIFT(>>, Int64, int64_t); + default: + cerr << "Unhandled type for AShr instruction: " << *Ty << "\n"; abort(); } return Dest; @@ -954,77 +1163,185 @@ void Interpreter::visitShl(ShiftInst &I) { SetValue(&I, Dest, SF); } -void Interpreter::visitShr(ShiftInst &I) { +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; - Dest = executeShrInst (Src1, Src2, Ty); + 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->getTypeID()) { \ - 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: std::cout << "Unhandled cast: " << *SrcTy << " to " << *Ty << "\n"; \ +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); +} + +#define IMPLEMENT_CAST_START \ + switch (DstTy->getTypeID()) { + +#define IMPLEMENT_CAST(STY, DTY, CAST) \ + case Type::STY##TyID: Dest.DTY##Val = (CAST(Src.STY##Val)); break; + +#define IMPLEMENT_CAST_CASE(DTY, CAST) \ + case Type::DTY##TyID: \ + switch (SrcTy->getTypeID()) { \ + IMPLEMENT_CAST(Bool, DTY, CAST); \ + IMPLEMENT_CAST(Int8, DTY, CAST); \ + IMPLEMENT_CAST(Int16, DTY, CAST); \ + IMPLEMENT_CAST(Int32, DTY, CAST); \ + IMPLEMENT_CAST(Int64, DTY, CAST); \ + IMPLEMENT_CAST(Pointer,DTY, CAST); \ + IMPLEMENT_CAST(Float, DTY, CAST); \ + IMPLEMENT_CAST(Double, DTY, CAST); \ + default: \ + cerr << "Unhandled cast: " \ + << *SrcTy << " to " << *DstTy << "\n"; \ abort(); \ } \ break -#define IMPLEMENT_CAST_CASE(DESTTY, DESTCTY) \ - IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY); \ - IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY); \ - IMPLEMENT_CAST_CASE_END() +#define IMPLEMENT_CAST_END \ + default: cerr \ + << "Unhandled dest type for cast instruction: " \ + << *DstTy << "\n"; \ + abort(); \ + } -GenericValue Interpreter::executeCastOperation(Value *SrcVal, const Type *Ty, +GenericValue Interpreter::executeCastOperation(Instruction::CastOps opcode, + Value *SrcVal, const Type *DstTy, ExecutionContext &SF) { const Type *SrcTy = SrcVal->getType(); GenericValue Dest, Src = getOperandValue(SrcVal, SF); - switch (Ty->getTypeID()) { - 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)); - IMPLEMENT_CAST_CASE(Bool , (bool)); - default: - std::cout << "Unhandled dest type for cast instruction: " << *Ty << "\n"; - abort(); + if (opcode == Instruction::Trunc && DstTy->getTypeID() == Type::BoolTyID) { + // For truncations to bool, we must clear the high order bits of the source + switch (SrcTy->getTypeID()) { + case Type::BoolTyID: Src.BoolVal &= 1; break; + case Type::Int8TyID: Src.Int8Val &= 1; break; + case Type::Int16TyID: Src.Int16Val &= 1; break; + case Type::Int32TyID: Src.Int32Val &= 1; break; + case Type::Int64TyID: Src.Int64Val &= 1; break; + default: + assert(0 && "Can't trunc a non-integer!"); + break; + } + } else if (opcode == Instruction::SExt && + SrcTy->getTypeID() == Type::BoolTyID) { + // For sign extension from bool, we must extend the source bits. + SrcTy = Type::Int64Ty; + Src.Int64Val = 0 - Src.BoolVal; } + switch (opcode) { + case Instruction::Trunc: // src integer, dest integral (can't be long) + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Bool , (bool)); + IMPLEMENT_CAST_CASE(Int8 , (uint8_t)); + IMPLEMENT_CAST_CASE(Int16, (uint16_t)); + IMPLEMENT_CAST_CASE(Int32, (uint32_t)); + IMPLEMENT_CAST_CASE(Int64, (uint64_t)); + IMPLEMENT_CAST_END + break; + case Instruction::ZExt: // src integral (can't be long), dest integer + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Int8 , (uint8_t)); + IMPLEMENT_CAST_CASE(Int16, (uint16_t)); + IMPLEMENT_CAST_CASE(Int32, (uint32_t)); + IMPLEMENT_CAST_CASE(Int64, (uint64_t)); + IMPLEMENT_CAST_END + break; + case Instruction::SExt: // src integral (can't be long), dest integer + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Int8 , (uint8_t)(int8_t)); + IMPLEMENT_CAST_CASE(Int16, (uint16_t)(int16_t)); + IMPLEMENT_CAST_CASE(Int32, (uint32_t)(int32_t)); + IMPLEMENT_CAST_CASE(Int64, (uint64_t)(int64_t)); + IMPLEMENT_CAST_END + break; + case Instruction::FPTrunc: // src double, dest float + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Float , (float)); + IMPLEMENT_CAST_END + break; + case Instruction::FPExt: // src float, dest double + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Double , (double)); + IMPLEMENT_CAST_END + break; + case Instruction::UIToFP: // src integral, dest floating + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Float , (float)(uint64_t)); + IMPLEMENT_CAST_CASE(Double , (double)(uint64_t)); + IMPLEMENT_CAST_END + break; + case Instruction::SIToFP: // src integeral, dest floating + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Float , (float)(int64_t)); + IMPLEMENT_CAST_CASE(Double , (double)(int64_t)); + IMPLEMENT_CAST_END + break; + case Instruction::FPToUI: // src floating, dest integral + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Bool , (bool)); + IMPLEMENT_CAST_CASE(Int8 , (uint8_t)); + IMPLEMENT_CAST_CASE(Int16, (uint16_t)); + IMPLEMENT_CAST_CASE(Int32, (uint32_t )); + IMPLEMENT_CAST_CASE(Int64, (uint64_t)); + IMPLEMENT_CAST_END + break; + case Instruction::FPToSI: // src floating, dest integral + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Bool , (bool)); + IMPLEMENT_CAST_CASE(Int8 , (uint8_t) (int8_t)); + IMPLEMENT_CAST_CASE(Int16, (uint16_t)(int16_t)); + IMPLEMENT_CAST_CASE(Int32, (uint32_t)(int32_t)); + IMPLEMENT_CAST_CASE(Int64, (uint64_t)(int64_t)); + IMPLEMENT_CAST_END + break; + case Instruction::PtrToInt: // src pointer, dest integral + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Bool , (bool)); + IMPLEMENT_CAST_CASE(Int8 , (uint8_t)); + IMPLEMENT_CAST_CASE(Int16, (uint16_t)); + IMPLEMENT_CAST_CASE(Int32, (uint32_t)); + IMPLEMENT_CAST_CASE(Int64, (uint64_t)); + IMPLEMENT_CAST_END + break; + case Instruction::IntToPtr: // src integral, dest pointer + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Pointer, (PointerTy)); + IMPLEMENT_CAST_END + break; + case Instruction::BitCast: // src any, dest any (same size) + IMPLEMENT_CAST_START + IMPLEMENT_CAST_CASE(Bool , (bool)); + IMPLEMENT_CAST_CASE(Int8 , (uint8_t)); + IMPLEMENT_CAST_CASE(Int16 , (uint16_t)); + IMPLEMENT_CAST_CASE(Int32 , (uint32_t)); + IMPLEMENT_CAST_CASE(Int64 , (uint64_t)); + IMPLEMENT_CAST_CASE(Pointer, (PointerTy)); + IMPLEMENT_CAST_CASE(Float , (float)); + IMPLEMENT_CAST_CASE(Double , (double)); + IMPLEMENT_CAST_END + break; + default: + cerr << "Invalid cast opcode for cast instruction: " << opcode << "\n"; + abort(); + } return Dest; } void Interpreter::visitCastInst(CastInst &I) { ExecutionContext &SF = ECStack.back(); - SetValue(&I, executeCastOperation(I.getOperand(0), I.getType(), SF), SF); + SetValue(&I, executeCastOperation(I.getOpcode(), I.getOperand(0), + I.getType(), SF), SF); } #define IMPLEMENT_VAARG(TY) \ @@ -1041,20 +1358,16 @@ void Interpreter::visitVAArgInst(VAArgInst &I) { .VarArgs[VAList.UIntPairVal.second]; const Type *Ty = I.getType(); switch (Ty->getTypeID()) { - IMPLEMENT_VAARG(UByte); - IMPLEMENT_VAARG(SByte); - IMPLEMENT_VAARG(UShort); - IMPLEMENT_VAARG(Short); - IMPLEMENT_VAARG(UInt); - IMPLEMENT_VAARG(Int); - IMPLEMENT_VAARG(ULong); - IMPLEMENT_VAARG(Long); + IMPLEMENT_VAARG(Int8); + IMPLEMENT_VAARG(Int16); + IMPLEMENT_VAARG(Int32); + IMPLEMENT_VAARG(Int64); IMPLEMENT_VAARG(Pointer); IMPLEMENT_VAARG(Float); IMPLEMENT_VAARG(Double); IMPLEMENT_VAARG(Bool); default: - std::cout << "Unhandled dest type for vaarg instruction: " << *Ty << "\n"; + cerr << "Unhandled dest type for vaarg instruction: " << *Ty << "\n"; abort(); } @@ -1117,7 +1430,7 @@ void Interpreter::run() { // Track the number of dynamic instructions executed. ++NumDynamicInsts; - DEBUG(std::cerr << "About to interpret: " << I); + DOUT << "About to interpret: " << I; visit(I); // Dispatch to one of the visit* methods... } }