X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FExecutionEngine%2FInterpreter%2FExecution.cpp;h=af47be9c5b56f45e10cd18fd770dbca148bf9391;hb=3d3abe0852d5f499bed7ab014519dd582a0a795d;hp=2e36875e492b19e14dee2e1dccd10e20e3ea8fe7;hpb=5cbf985dcbc89fba3208e7baf8b6f488b06d3ec9;p=oota-llvm.git diff --git a/lib/ExecutionEngine/Interpreter/Execution.cpp b/lib/ExecutionEngine/Interpreter/Execution.cpp index 2e36875e492..af47be9c5b5 100644 --- a/lib/ExecutionEngine/Interpreter/Execution.cpp +++ b/lib/ExecutionEngine/Interpreter/Execution.cpp @@ -2,8 +2,8 @@ // // 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 is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -18,345 +18,84 @@ #include "llvm/Instructions.h" #include "llvm/CodeGen/IntrinsicLowering.h" #include "llvm/Support/GetElementPtrTypeIterator.h" +#include "llvm/ADT/APInt.h" #include "llvm/ADT/Statistic.h" +#include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" +#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/MathExtras.h" +#include #include using namespace llvm; STATISTIC(NumDynamicInsts, "Number of dynamic instructions executed"); -static Interpreter *TheEE = 0; +static cl::opt PrintVolatile("interpreter-print-volatile", cl::Hidden, + cl::desc("make the interpreter print every volatile load and store")); //===----------------------------------------------------------------------===// -// Value Manipulation code +// Various Helper Functions //===----------------------------------------------------------------------===// -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); - -inline uint64_t doSignExtension(uint64_t Val, const IntegerType* ITy) { - // Determine if the value is signed or not - bool isSigned = (Val & (1 << (ITy->getBitWidth()-1))) != 0; - // If its signed, extend the sign bits - if (isSigned) - Val |= ~ITy->getBitMask(); - return Val; -} - -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: - cerr << "Unhandled ConstantExpr: " << *CE << "\n"; - abort(); - return GenericValue(); - } -} - -GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) { - if (ConstantExpr *CE = dyn_cast(V)) { - return getConstantExprValue(CE, SF); - } else if (Constant *CPV = dyn_cast(V)) { - return getConstantValue(CPV); - } else if (GlobalValue *GV = dyn_cast(V)) { - return PTOGV(getPointerToGlobal(GV)); - } else { - return SF.Values[V]; - } -} - static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) { SF.Values[V] = Val; } -void Interpreter::initializeExecutionEngine() { - TheEE = this; -} - //===----------------------------------------------------------------------===// // Binary Instruction Implementations //===----------------------------------------------------------------------===// #define IMPLEMENT_BINARY_OPERATOR(OP, TY) \ - case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; break - -#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(); \ - } + case Type::TY##TyID: \ + Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; \ + break -static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; +static void executeFAddInst(GenericValue &Dest, GenericValue Src1, + GenericValue Src2, Type *Ty) { 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(); + dbgs() << "Unhandled type for FAdd instruction: " << *Ty << "\n"; + llvm_unreachable(0); } - return Dest; } -static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; +static void executeFSubInst(GenericValue &Dest, GenericValue Src1, + GenericValue Src2, Type *Ty) { 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(); + dbgs() << "Unhandled type for FSub instruction: " << *Ty << "\n"; + llvm_unreachable(0); } - return Dest; } -static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; +static void executeFMulInst(GenericValue &Dest, GenericValue Src1, + GenericValue Src2, Type *Ty) { switch (Ty->getTypeID()) { - IMPLEMENT_INTEGER_BINOP(*, Ty); IMPLEMENT_BINARY_OPERATOR(*, Float); IMPLEMENT_BINARY_OPERATOR(*, Double); default: - cerr << "Unhandled type for Mul instruction: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for FMul instruction: " << *Ty << "\n"; + llvm_unreachable(0); } - return Dest; -} - -static GenericValue executeUDivInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; - IMPLEMENT_UNSIGNED_BINOP(/,Ty) - return Dest; -} - -static GenericValue executeSDivInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; - IMPLEMENT_SIGNED_BINOP(/,Ty) - return Dest; } -static GenericValue executeFDivInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; +static void executeFDivInst(GenericValue &Dest, GenericValue Src1, + GenericValue Src2, Type *Ty) { switch (Ty->getTypeID()) { IMPLEMENT_BINARY_OPERATOR(/, Float); IMPLEMENT_BINARY_OPERATOR(/, Double); default: - cerr << "Unhandled type for FDiv instruction: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for FDiv instruction: " << *Ty << "\n"; + llvm_unreachable(0); } - return Dest; -} - -static GenericValue executeURemInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; - IMPLEMENT_UNSIGNED_BINOP(%, Ty) - return Dest; -} - -static GenericValue executeSRemInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; - IMPLEMENT_SIGNED_BINOP(%, Ty) - return Dest; } -static GenericValue executeFRemInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; +static void executeFRemInst(GenericValue &Dest, GenericValue Src1, + GenericValue Src2, Type *Ty) { switch (Ty->getTypeID()) { case Type::FloatTyID: Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal); @@ -365,78 +104,15 @@ static GenericValue executeFRemInst(GenericValue Src1, GenericValue Src2, Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal); break; default: - cerr << "Unhandled type for Rem instruction: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for Rem instruction: " << *Ty << "\n"; + llvm_unreachable(0); } - return Dest; } -static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; - IMPLEMENT_UNSIGNED_BINOP(&, Ty) - return Dest; -} - -static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; - IMPLEMENT_UNSIGNED_BINOP(|, Ty) - return Dest; -} - -static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2, - const Type *Ty) { - GenericValue Dest; - IMPLEMENT_UNSIGNED_BINOP(^, Ty) - return Dest; -} - -#define IMPLEMENT_SIGNED_ICMP(OP, TY) \ - case Type::IntegerTyID: { \ - const IntegerType* ITy = cast(TY); \ - unsigned BitWidth = ITy->getBitWidth(); \ - int64_t LHS = 0, RHS = 0; \ - if (BitWidth <= 8) { \ - LHS = int64_t(doSignExtension(uint64_t(Src1.Int8Val), ITy)); \ - RHS = int64_t(doSignExtension(uint64_t(Src2.Int8Val), ITy)); \ - } else if (BitWidth <= 16) { \ - LHS = int64_t(doSignExtension(uint64_t(Src1.Int16Val), ITy)); \ - RHS = int64_t(doSignExtension(uint64_t(Src2.Int16Val), ITy)); \ - } else if (BitWidth <= 32) { \ - LHS = int64_t(doSignExtension(uint64_t(Src1.Int32Val), ITy)); \ - RHS = int64_t(doSignExtension(uint64_t(Src2.Int32Val), ITy)); \ - } else if (BitWidth <= 64) { \ - LHS = int64_t(doSignExtension(uint64_t(Src1.Int64Val), ITy)); \ - RHS = int64_t(doSignExtension(uint64_t(Src2.Int64Val), ITy)); \ - } else { \ - cerr << "Integer types > 64 bits not supported: " << *Ty << "\n"; \ - abort(); \ - } \ - Dest.Int1Val = LHS OP RHS; \ - 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; \ - } +#define IMPLEMENT_INTEGER_ICMP(OP, TY) \ + case Type::IntegerTyID: \ + Dest.IntVal = APInt(1,Src1.IntVal.OP(Src2.IntVal)); \ + 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 @@ -444,142 +120,143 @@ static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2, // 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 + Dest.IntVal = APInt(1,(void*)(intptr_t)Src1.PointerVal OP \ + (void*)(intptr_t)Src2.PointerVal); \ + break; static GenericValue executeICMP_EQ(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_UNSIGNED_ICMP(==, Ty); + IMPLEMENT_INTEGER_ICMP(eq,Ty); IMPLEMENT_POINTER_ICMP(==); default: - cerr << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeICMP_NE(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_UNSIGNED_ICMP(!=, Ty); + IMPLEMENT_INTEGER_ICMP(ne,Ty); IMPLEMENT_POINTER_ICMP(!=); default: - cerr << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeICMP_ULT(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_UNSIGNED_ICMP(<, Ty); + IMPLEMENT_INTEGER_ICMP(ult,Ty); IMPLEMENT_POINTER_ICMP(<); default: - cerr << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeICMP_SLT(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_SIGNED_ICMP(<, Ty); + IMPLEMENT_INTEGER_ICMP(slt,Ty); IMPLEMENT_POINTER_ICMP(<); default: - cerr << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeICMP_UGT(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_UNSIGNED_ICMP(>, Ty); + IMPLEMENT_INTEGER_ICMP(ugt,Ty); IMPLEMENT_POINTER_ICMP(>); default: - cerr << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeICMP_SGT(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_SIGNED_ICMP(>, Ty); + IMPLEMENT_INTEGER_ICMP(sgt,Ty); IMPLEMENT_POINTER_ICMP(>); default: - cerr << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeICMP_ULE(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_UNSIGNED_ICMP(<=, Ty); + IMPLEMENT_INTEGER_ICMP(ule,Ty); IMPLEMENT_POINTER_ICMP(<=); default: - cerr << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeICMP_SLE(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_SIGNED_ICMP(<=, Ty); + IMPLEMENT_INTEGER_ICMP(sle,Ty); IMPLEMENT_POINTER_ICMP(<=); default: - cerr << "Unhandled type for ICMP_SLE predicate: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for ICMP_SLE predicate: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeICMP_UGE(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_UNSIGNED_ICMP(>=,Ty); + IMPLEMENT_INTEGER_ICMP(uge,Ty); IMPLEMENT_POINTER_ICMP(>=); default: - cerr << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeICMP_SGE(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { - IMPLEMENT_SIGNED_ICMP(>=, Ty); + IMPLEMENT_INTEGER_ICMP(sge,Ty); IMPLEMENT_POINTER_ICMP(>=); default: - cerr << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } void Interpreter::visitICmpInst(ICmpInst &I) { ExecutionContext &SF = ECStack.back(); - const Type *Ty = I.getOperand(0)->getType(); + Type *Ty = I.getOperand(0)->getType(); GenericValue Src1 = getOperandValue(I.getOperand(0), SF); GenericValue Src2 = getOperandValue(I.getOperand(1), SF); GenericValue R; // Result @@ -596,183 +273,185 @@ void Interpreter::visitICmpInst(ICmpInst &I) { 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(); + dbgs() << "Don't know how to handle this ICmp predicate!\n-->" << I; + llvm_unreachable(0); } SetValue(&I, R, SF); } #define IMPLEMENT_FCMP(OP, TY) \ - case Type::TY##TyID: Dest.Int1Val = Src1.TY##Val OP Src2.TY##Val; break + case Type::TY##TyID: \ + Dest.IntVal = APInt(1,Src1.TY##Val OP Src2.TY##Val); \ + break static GenericValue executeFCMP_OEQ(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { IMPLEMENT_FCMP(==, Float); IMPLEMENT_FCMP(==, Double); default: - cerr << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeFCMP_ONE(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { IMPLEMENT_FCMP(!=, Float); IMPLEMENT_FCMP(!=, Double); default: - cerr << "Unhandled type for FCmp NE instruction: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for FCmp NE instruction: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeFCMP_OLE(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { IMPLEMENT_FCMP(<=, Float); IMPLEMENT_FCMP(<=, Double); default: - cerr << "Unhandled type for FCmp LE instruction: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for FCmp LE instruction: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeFCMP_OGE(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { IMPLEMENT_FCMP(>=, Float); IMPLEMENT_FCMP(>=, Double); default: - cerr << "Unhandled type for FCmp GE instruction: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for FCmp GE instruction: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeFCMP_OLT(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { IMPLEMENT_FCMP(<, Float); IMPLEMENT_FCMP(<, Double); default: - cerr << "Unhandled type for FCmp LT instruction: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for FCmp LT instruction: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } static GenericValue executeFCMP_OGT(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; switch (Ty->getTypeID()) { IMPLEMENT_FCMP(>, Float); IMPLEMENT_FCMP(>, Double); default: - cerr << "Unhandled type for FCmp GT instruction: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled type for FCmp GT instruction: " << *Ty << "\n"; + llvm_unreachable(0); } return Dest; } -#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; \ - } +#define IMPLEMENT_UNORDERED(TY, X,Y) \ + if (TY->isFloatTy()) { \ + if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) { \ + Dest.IntVal = APInt(1,true); \ + return Dest; \ + } \ + } else if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) { \ + Dest.IntVal = APInt(1,true); \ + return Dest; \ + } static GenericValue executeFCMP_UEQ(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + 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) { + 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) { + 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) { + 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) { + 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) { + 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) { + Type *Ty) { GenericValue Dest; - if (Ty == Type::FloatTy) - Dest.Int1Val = (Src1.FloatVal == Src1.FloatVal && - Src2.FloatVal == Src2.FloatVal); + if (Ty->isFloatTy()) + Dest.IntVal = APInt(1,(Src1.FloatVal == Src1.FloatVal && + Src2.FloatVal == Src2.FloatVal)); else - Dest.Int1Val = (Src1.DoubleVal == Src1.DoubleVal && - Src2.DoubleVal == Src2.DoubleVal); + Dest.IntVal = APInt(1,(Src1.DoubleVal == Src1.DoubleVal && + Src2.DoubleVal == Src2.DoubleVal)); return Dest; } static GenericValue executeFCMP_UNO(GenericValue Src1, GenericValue Src2, - const Type *Ty) { + Type *Ty) { GenericValue Dest; - if (Ty == Type::FloatTy) - Dest.Int1Val = (Src1.FloatVal != Src1.FloatVal || - Src2.FloatVal != Src2.FloatVal); + if (Ty->isFloatTy()) + Dest.IntVal = APInt(1,(Src1.FloatVal != Src1.FloatVal || + Src2.FloatVal != Src2.FloatVal)); else - Dest.Int1Val = (Src1.DoubleVal != Src1.DoubleVal || - Src2.DoubleVal != Src2.DoubleVal); + Dest.IntVal = APInt(1,(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(); + 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_FALSE: R.IntVal = APInt(1,false); break; + case FCmpInst::FCMP_TRUE: R.IntVal = APInt(1,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; @@ -788,15 +467,15 @@ void Interpreter::visitFCmpInst(FCmpInst &I) { 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(); + dbgs() << "Don't know how to handle this FCmp predicate!\n-->" << I; + llvm_unreachable(0); } SetValue(&I, R, SF); } static GenericValue executeCmpInst(unsigned predicate, GenericValue Src1, - GenericValue Src2, const Type *Ty) { + GenericValue Src2, Type *Ty) { GenericValue Result; switch (predicate) { case ICmpInst::ICMP_EQ: return executeICMP_EQ(Src1, Src2, Ty); @@ -825,43 +504,46 @@ static GenericValue executeCmpInst(unsigned predicate, GenericValue Src1, case FCmpInst::FCMP_UGE: return executeFCMP_UGE(Src1, Src2, Ty); case FCmpInst::FCMP_FALSE: { GenericValue Result; - Result.Int1Val = false; + Result.IntVal = APInt(1, false); return Result; } case FCmpInst::FCMP_TRUE: { GenericValue Result; - Result.Int1Val = true; + Result.IntVal = APInt(1, true); return Result; } default: - cerr << "Unhandled Cmp predicate\n"; - abort(); + dbgs() << "Unhandled Cmp predicate\n"; + llvm_unreachable(0); } } void Interpreter::visitBinaryOperator(BinaryOperator &I) { ExecutionContext &SF = ECStack.back(); - const Type *Ty = I.getOperand(0)->getType(); + 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); 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; + case Instruction::Add: R.IntVal = Src1.IntVal + Src2.IntVal; break; + case Instruction::Sub: R.IntVal = Src1.IntVal - Src2.IntVal; break; + case Instruction::Mul: R.IntVal = Src1.IntVal * Src2.IntVal; break; + case Instruction::FAdd: executeFAddInst(R, Src1, Src2, Ty); break; + case Instruction::FSub: executeFSubInst(R, Src1, Src2, Ty); break; + case Instruction::FMul: executeFMulInst(R, Src1, Src2, Ty); break; + case Instruction::FDiv: executeFDivInst(R, Src1, Src2, Ty); break; + case Instruction::FRem: executeFRemInst(R, Src1, Src2, Ty); break; + case Instruction::UDiv: R.IntVal = Src1.IntVal.udiv(Src2.IntVal); break; + case Instruction::SDiv: R.IntVal = Src1.IntVal.sdiv(Src2.IntVal); break; + case Instruction::URem: R.IntVal = Src1.IntVal.urem(Src2.IntVal); break; + case Instruction::SRem: R.IntVal = Src1.IntVal.srem(Src2.IntVal); break; + case Instruction::And: R.IntVal = Src1.IntVal & Src2.IntVal; break; + case Instruction::Or: R.IntVal = Src1.IntVal | Src2.IntVal; break; + case Instruction::Xor: R.IntVal = Src1.IntVal ^ Src2.IntVal; break; default: - cerr << "Don't know how to handle this binary operator!\n-->" << I; - abort(); + dbgs() << "Don't know how to handle this binary operator!\n-->" << I; + llvm_unreachable(0); } SetValue(&I, R, SF); @@ -869,7 +551,7 @@ void Interpreter::visitBinaryOperator(BinaryOperator &I) { static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2, GenericValue Src3) { - return Src1.Int1Val ? Src2 : Src3; + return Src1.IntVal == 0 ? Src3 : Src2; } void Interpreter::visitSelectInst(SelectInst &I) { @@ -890,9 +572,9 @@ 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); + ECStack.clear(); + runAtExitHandlers(); + exit(GV.IntVal.zextOrTrunc(32).getZExtValue()); } /// Pop the last stack frame off of ECStack and then copy the result @@ -903,23 +585,24 @@ void Interpreter::exitCalled(GenericValue GV) { /// care of switching to the normal destination BB, if we are returning /// from an invoke. /// -void Interpreter::popStackAndReturnValueToCaller (const Type *RetTy, - GenericValue Result) { +void Interpreter::popStackAndReturnValueToCaller(Type *RetTy, + GenericValue Result) { // Pop the current stack frame. ECStack.pop_back(); if (ECStack.empty()) { // Finished main. Put result into exit code... - if (RetTy && RetTy->isInteger()) { // Nonvoid return type? + if (RetTy && !RetTy->isVoidTy()) { // Nonvoid return type? ExitValue = Result; // Capture the exit value of the program } else { - memset(&ExitValue, 0, sizeof(ExitValue)); + memset(&ExitValue.Untyped, 0, sizeof(ExitValue.Untyped)); } } 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... + // Save result... + if (!CallingSF.Caller.getType()->isVoidTy()) SetValue(I, Result, CallingSF); if (InvokeInst *II = dyn_cast (I)) SwitchToNewBasicBlock (II->getNormalDest (), CallingSF); @@ -930,7 +613,7 @@ void Interpreter::popStackAndReturnValueToCaller (const Type *RetTy, void Interpreter::visitReturnInst(ReturnInst &I) { ExecutionContext &SF = ECStack.back(); - const Type *RetTy = Type::VoidTy; + Type *RetTy = Type::getVoidTy(I.getContext()); GenericValue Result; // Save away the return value... (if we are not 'ret void') @@ -942,27 +625,8 @@ void Interpreter::visitReturnInst(ReturnInst &I) { popStackAndReturnValueToCaller(RetTy, Result); } -void Interpreter::visitUnwindInst(UnwindInst &I) { - // Unwind stack - Instruction *Inst; - do { - ECStack.pop_back (); - if (ECStack.empty ()) - abort (); - Inst = ECStack.back ().Caller.getInstruction (); - } while (!(Inst && isa (Inst))); - - // Return from invoke - ExecutionContext &InvokingSF = ECStack.back (); - InvokingSF.Caller = CallSite (); - - // Go to exceptional destination BB of invoke instruction - SwitchToNewBasicBlock(cast(Inst)->getUnwindDest(), InvokingSF); -} - void Interpreter::visitUnreachableInst(UnreachableInst &I) { - cerr << "ERROR: Program executed an 'unreachable' instruction!\n"; - abort(); + report_fatal_error("Program executed an 'unreachable' instruction!"); } void Interpreter::visitBranchInst(BranchInst &I) { @@ -972,7 +636,7 @@ void Interpreter::visitBranchInst(BranchInst &I) { Dest = I.getSuccessor(0); // Uncond branches have a fixed dest... if (!I.isUnconditional()) { Value *Cond = I.getCondition(); - if (getOperandValue(Cond, SF).Int1Val == 0) // If false cond... + if (getOperandValue(Cond, SF).IntVal == 0) // If false cond... Dest = I.getSuccessor(1); } SwitchToNewBasicBlock(Dest, SF); @@ -980,22 +644,30 @@ void Interpreter::visitBranchInst(BranchInst &I) { void Interpreter::visitSwitchInst(SwitchInst &I) { ExecutionContext &SF = ECStack.back(); - GenericValue CondVal = getOperandValue(I.getOperand(0), SF); - const Type *ElTy = I.getOperand(0)->getType(); + Value* Cond = I.getCondition(); + Type *ElTy = Cond->getType(); + GenericValue CondVal = getOperandValue(Cond, SF); // 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)); + for (SwitchInst::CaseIt i = I.case_begin(), e = I.case_end(); i != e; ++i) { + GenericValue CaseVal = getOperandValue(i.getCaseValue(), SF); + if (executeICMP_EQ(CondVal, CaseVal, ElTy).IntVal != 0) { + Dest = cast(i.getCaseSuccessor()); break; } - + } if (!Dest) Dest = I.getDefaultDest(); // No cases matched: use default SwitchToNewBasicBlock(Dest, SF); } +void Interpreter::visitIndirectBrInst(IndirectBrInst &I) { + ExecutionContext &SF = ECStack.back(); + void *Dest = GVTOP(getOperandValue(I.getAddress(), SF)); + SwitchToNewBasicBlock((BasicBlock*)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. @@ -1038,16 +710,26 @@ void Interpreter::SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF){ // Memory Instruction Implementations //===----------------------------------------------------------------------===// -void Interpreter::visitAllocationInst(AllocationInst &I) { +void Interpreter::visitAllocaInst(AllocaInst &I) { ExecutionContext &SF = ECStack.back(); - const Type *Ty = I.getType()->getElementType(); // Type to be allocated + 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).Int32Val; + unsigned NumElements = + getOperandValue(I.getOperand(0), SF).IntVal.getZExtValue(); + + unsigned TypeSize = (size_t)TD.getTypeAllocSize(Ty); + + // Avoid malloc-ing zero bytes, use max()... + unsigned MemToAlloc = std::max(1U, NumElements * TypeSize); // Allocate enough memory to hold the type... - void *Memory = malloc(NumElements * (size_t)TD.getTypeSize(Ty)); + void *Memory = malloc(MemToAlloc); + + DEBUG(dbgs() << "Allocated Type: " << *Ty << " (" << TypeSize << " bytes) x " + << NumElements << " (Total: " << MemToAlloc << ") at " + << uintptr_t(Memory) << '\n'); GenericValue Result = PTOGV(Memory); assert(Result.PointerVal != 0 && "Null pointer returned by malloc!"); @@ -1057,34 +739,26 @@ void Interpreter::visitAllocationInst(AllocationInst &I) { ECStack.back().Allocas.add(Memory); } -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(GVTOP(Value)); // Free memory -} - // getElementOffset - The workhorse for getelementptr. // GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I, gep_type_iterator E, ExecutionContext &SF) { - assert(isa(Ptr->getType()) && + assert(Ptr->getType()->isPointerTy() && "Cannot getElementOffset of a nonpointer type!"); - PointerTy Total = 0; + uint64_t Total = 0; for (; I != E; ++I) { - if (const StructType *STy = dyn_cast(*I)) { + if (StructType *STy = dyn_cast(*I)) { const StructLayout *SLO = TD.getStructLayout(STy); const ConstantInt *CPU = cast(I.getOperand()); unsigned Index = unsigned(CPU->getZExtValue()); - Total += (PointerTy)SLO->MemberOffsets[Index]; + Total += SLO->getElementOffset(Index); } else { - const SequentialType *ST = cast(*I); + SequentialType *ST = cast(*I); // Get the index number for the array... which must be long type... GenericValue IdxGV = getOperandValue(I.getOperand(), SF); @@ -1092,23 +766,24 @@ GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I, 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); + Idx = (int64_t)(int32_t)IdxGV.IntVal.getZExtValue(); + else { + assert(BitWidth == 64 && "Invalid index type for getelementptr"); + Idx = (int64_t)IdxGV.IntVal.getZExtValue(); + } + Total += TD.getTypeAllocSize(ST->getElementType())*Idx; } } GenericValue Result; - Result.PointerVal = getOperandValue(Ptr, SF).PointerVal + Total; + Result.PointerVal = ((char*)getOperandValue(Ptr, SF).PointerVal) + Total; + DEBUG(dbgs() << "GEP Index " << Total << " bytes.\n"); return Result; } void Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) { ExecutionContext &SF = ECStack.back(); - SetValue(&I, TheEE->executeGEPOperation(I.getPointerOperand(), + SetValue(&I, executeGEPOperation(I.getPointerOperand(), gep_type_begin(I), gep_type_end(I), SF), SF); } @@ -1116,8 +791,11 @@ void Interpreter::visitLoadInst(LoadInst &I) { ExecutionContext &SF = ECStack.back(); GenericValue SRC = getOperandValue(I.getPointerOperand(), SF); GenericValue *Ptr = (GenericValue*)GVTOP(SRC); - GenericValue Result = LoadValueFromMemory(Ptr, I.getType()); + GenericValue Result; + LoadValueFromMemory(Result, Ptr, I.getType()); SetValue(&I, Result, SF); + if (I.isVolatile() && PrintVolatile) + dbgs() << "Volatile load " << I; } void Interpreter::visitStoreInst(StoreInst &I) { @@ -1126,6 +804,8 @@ void Interpreter::visitStoreInst(StoreInst &I) { GenericValue SRC = getOperandValue(I.getPointerOperand(), SF); StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC), I.getOperand(0)->getType()); + if (I.isVolatile() && PrintVolatile) + dbgs() << "Volatile store: " << I; } //===----------------------------------------------------------------------===// @@ -1136,8 +816,8 @@ void Interpreter::visitCallSite(CallSite CS) { ExecutionContext &SF = ECStack.back(); // Check to see if this is an intrinsic function call... - if (Function *F = CS.getCalledFunction()) - if (F->isDeclaration ()) + Function *F = CS.getCalledFunction(); + if (F && F->isDeclaration()) switch (F->getIntrinsicID()) { case Intrinsic::not_intrinsic: break; @@ -1157,41 +837,34 @@ void Interpreter::visitCallSite(CallSite CS) { // 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::iterator me(CS.getInstruction()); BasicBlock *Parent = CS.getInstruction()->getParent(); + bool atBegin(Parent->begin() == me); + if (!atBegin) + --me; IL->LowerIntrinsicCall(cast(CS.getInstruction())); // Restore the CurInst pointer to the first instruction newly inserted, if // any. - if (!Prev) { + if (atBegin) { SF.CurInst = Parent->begin(); } else { - SF.CurInst = Prev; + SF.CurInst = me; ++SF.CurInst; } return; } + SF.Caller = CS; std::vector ArgVals; const unsigned NumArgs = SF.Caller.arg_size(); ArgVals.reserve(NumArgs); + uint16_t pNum = 1; for (CallSite::arg_iterator i = SF.Caller.arg_begin(), - e = SF.Caller.arg_end(); i != e; ++i) { + e = SF.Caller.arg_end(); i != e; ++i, ++pNum) { 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 @@ -1200,405 +873,195 @@ void Interpreter::visitCallSite(CallSite CS) { callFunction((Function*)GVTOP(SRC), ArgVals); } -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(); - } - return Dest; -} - -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; -} - -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; -} - -void Interpreter::visitShl(ShiftInst &I) { +void Interpreter::visitShl(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 Dest; - Dest = executeShlInst (Src1, Src2, Ty); + if (Src2.IntVal.getZExtValue() < Src1.IntVal.getBitWidth()) + Dest.IntVal = Src1.IntVal.shl(Src2.IntVal.getZExtValue()); + else + Dest.IntVal = Src1.IntVal; + SetValue(&I, Dest, SF); } -void Interpreter::visitLShr(ShiftInst &I) { +void Interpreter::visitLShr(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 Dest; - Dest = executeLShrInst (Src1, Src2, Ty); + if (Src2.IntVal.getZExtValue() < Src1.IntVal.getBitWidth()) + Dest.IntVal = Src1.IntVal.lshr(Src2.IntVal.getZExtValue()); + else + Dest.IntVal = Src1.IntVal; + SetValue(&I, Dest, SF); } -void Interpreter::visitAShr(ShiftInst &I) { +void Interpreter::visitAShr(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 Dest; - Dest = executeAShrInst (Src1, Src2, Ty); + if (Src2.IntVal.getZExtValue() < Src1.IntVal.getBitWidth()) + Dest.IntVal = Src1.IntVal.ashr(Src2.IntVal.getZExtValue()); + else + Dest.IntVal = Src1.IntVal; + SetValue(&I, Dest, SF); } -#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, +GenericValue Interpreter::executeTruncInst(Value *SrcVal, 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); + IntegerType *DITy = cast(DstTy); 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); + Dest.IntVal = Src.IntVal.trunc(DBitWidth); return Dest; } -GenericValue Interpreter::executeSExtInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executeSExtInst(Value *SrcVal, 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); + IntegerType *DITy = cast(DstTy); 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; - - Normalized = doSignExtension(Normalized, SITy); - - // Now that we have a sign extended value, assign it to the destination - INTEGER_ASSIGN(Dest, DBitWidth, Normalized); + Dest.IntVal = Src.IntVal.sext(DBitWidth); return Dest; } -GenericValue Interpreter::executeZExtInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executeZExtInst(Value *SrcVal, 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); + IntegerType *DITy = cast(DstTy); 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); + Dest.IntVal = Src.IntVal.zext(DBitWidth); return Dest; } -GenericValue Interpreter::executeFPTruncInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executeFPTruncInst(Value *SrcVal, Type *DstTy, ExecutionContext &SF) { - const Type *SrcTy = SrcVal->getType(); GenericValue Dest, Src = getOperandValue(SrcVal, SF); - assert(SrcTy == Type::DoubleTy && DstTy == Type::FloatTy && + assert(SrcVal->getType()->isDoubleTy() && DstTy->isFloatTy() && "Invalid FPTrunc instruction"); Dest.FloatVal = (float) Src.DoubleVal; return Dest; } -GenericValue Interpreter::executeFPExtInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executeFPExtInst(Value *SrcVal, Type *DstTy, ExecutionContext &SF) { - const Type *SrcTy = SrcVal->getType(); GenericValue Dest, Src = getOperandValue(SrcVal, SF); - assert(SrcTy == Type::FloatTy && DstTy == Type::DoubleTy && + assert(SrcVal->getType()->isFloatTy() && DstTy->isDoubleTy() && "Invalid FPTrunc instruction"); Dest.DoubleVal = (double) Src.FloatVal; return Dest; } -GenericValue Interpreter::executeFPToUIInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executeFPToUIInst(Value *SrcVal, Type *DstTy, ExecutionContext &SF) { - const Type *SrcTy = SrcVal->getType(); + Type *SrcTy = SrcVal->getType(); + uint32_t DBitWidth = cast(DstTy)->getBitWidth(); 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; + assert(SrcTy->isFloatingPointTy() && "Invalid FPToUI instruction"); + if (SrcTy->getTypeID() == Type::FloatTyID) - Converted = (uint64_t) Src.FloatVal; + Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth); else - Converted = (uint64_t) Src.DoubleVal; - - INTEGER_ASSIGN(Dest, DBitWidth, Converted); + Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth); return Dest; } -GenericValue Interpreter::executeFPToSIInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executeFPToSIInst(Value *SrcVal, Type *DstTy, ExecutionContext &SF) { - const Type *SrcTy = SrcVal->getType(); + Type *SrcTy = SrcVal->getType(); + uint32_t DBitWidth = cast(DstTy)->getBitWidth(); 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; + assert(SrcTy->isFloatingPointTy() && "Invalid FPToSI instruction"); + if (SrcTy->getTypeID() == Type::FloatTyID) - Converted = (int64_t) Src.FloatVal; + Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth); else - Converted = (int64_t) Src.DoubleVal; - - INTEGER_ASSIGN(Dest, DBitWidth, Converted); + Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth); return Dest; } -GenericValue Interpreter::executeUIToFPInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executeUIToFPInst(Value *SrcVal, 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; + assert(DstTy->isFloatingPointTy() && "Invalid UIToFP instruction"); if (DstTy->getTypeID() == Type::FloatTyID) - Dest.FloatVal = (float) Converted; + Dest.FloatVal = APIntOps::RoundAPIntToFloat(Src.IntVal); else - Dest.DoubleVal = (double) Converted; + Dest.DoubleVal = APIntOps::RoundAPIntToDouble(Src.IntVal); return Dest; } -GenericValue Interpreter::executeSIToFPInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executeSIToFPInst(Value *SrcVal, 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 SIToFP 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; + assert(DstTy->isFloatingPointTy() && "Invalid SIToFP instruction"); if (DstTy->getTypeID() == Type::FloatTyID) - Dest.FloatVal = (float) Converted; + Dest.FloatVal = APIntOps::RoundSignedAPIntToFloat(Src.IntVal); else - Dest.DoubleVal = (double) Converted; + Dest.DoubleVal = APIntOps::RoundSignedAPIntToDouble(Src.IntVal); return Dest; + } -GenericValue Interpreter::executePtrToIntInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executePtrToIntInst(Value *SrcVal, Type *DstTy, ExecutionContext &SF) { - const Type *SrcTy = SrcVal->getType(); + uint32_t DBitWidth = cast(DstTy)->getBitWidth(); 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); + assert(SrcVal->getType()->isPointerTy() && "Invalid PtrToInt instruction"); + + Dest.IntVal = APInt(DBitWidth, (intptr_t) Src.PointerVal); return Dest; } -GenericValue Interpreter::executeIntToPtrInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executeIntToPtrInst(Value *SrcVal, 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; + assert(DstTy->isPointerTy() && "Invalid PtrToInt instruction"); + + uint32_t PtrSize = TD.getPointerSizeInBits(); + if (PtrSize != Src.IntVal.getBitWidth()) + Src.IntVal = Src.IntVal.zextOrTrunc(PtrSize); + + Dest.PointerVal = PointerTy(intptr_t(Src.IntVal.getZExtValue())); return Dest; } -GenericValue Interpreter::executeBitCastInst(Value *SrcVal, const Type *DstTy, +GenericValue Interpreter::executeBitCastInst(Value *SrcVal, Type *DstTy, ExecutionContext &SF) { - const Type *SrcTy = SrcVal->getType(); + Type *SrcTy = SrcVal->getType(); GenericValue Dest, Src = getOperandValue(SrcVal, SF); - if (isa(DstTy)) { - assert(isa(SrcTy) && "Invalid BitCast"); + if (DstTy->isPointerTy()) { + assert(SrcTy->isPointerTy() && "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 if (DstTy->isIntegerTy()) { + if (SrcTy->isFloatTy()) { + Dest.IntVal = APInt::floatToBits(Src.FloatVal); + } else if (SrcTy->isDoubleTy()) { + Dest.IntVal = APInt::doubleToBits(Src.DoubleVal); + } else if (SrcTy->isIntegerTy()) { + Dest.IntVal = Src.IntVal; } else - assert(0 && "Invalid BitCast"); - } else if (DstTy == Type::FloatTy) { - if (SrcTy->isInteger()) - Dest.FloatVal = BitsToFloat(Src.Int32Val); + llvm_unreachable("Invalid BitCast"); + } else if (DstTy->isFloatTy()) { + if (SrcTy->isIntegerTy()) + Dest.FloatVal = Src.IntVal.bitsToFloat(); else Dest.FloatVal = Src.FloatVal; - } else if (DstTy == Type::DoubleTy) { - if (SrcTy->isInteger()) - Dest.DoubleVal = BitsToDouble(Src.Int64Val); + } else if (DstTy->isDoubleTy()) { + if (SrcTy->isIntegerTy()) + Dest.DoubleVal = Src.IntVal.bitsToDouble(); else Dest.DoubleVal = Src.DoubleVal; } else - assert(0 && "Invalid Bitcast"); + llvm_unreachable("Invalid Bitcast"); return Dest; } @@ -1674,31 +1137,16 @@ void Interpreter::visitVAArgInst(VAArgInst &I) { GenericValue VAList = getOperandValue(I.getOperand(0), SF); GenericValue Dest; GenericValue Src = ECStack[VAList.UIntPairVal.first] - .VarArgs[VAList.UIntPairVal.second]; - const Type *Ty = I.getType(); + .VarArgs[VAList.UIntPairVal.second]; + 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); - } + case Type::IntegerTyID: Dest.IntVal = Src.IntVal; IMPLEMENT_VAARG(Pointer); IMPLEMENT_VAARG(Float); IMPLEMENT_VAARG(Double); default: - cerr << "Unhandled dest type for vaarg instruction: " << *Ty << "\n"; - abort(); + dbgs() << "Unhandled dest type for vaarg instruction: " << *Ty << "\n"; + llvm_unreachable(0); } // Set the Value of this Instruction. @@ -1708,6 +1156,100 @@ void Interpreter::visitVAArgInst(VAArgInst &I) { ++VAList.UIntPairVal.second; } +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::FCmp: + case Instruction::ICmp: + return executeCmpInst(CE->getPredicate(), + 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 : + break; + } + + // The cases below here require a GenericValue parameter for the result + // so we initialize one, compute it and then return it. + GenericValue Op0 = getOperandValue(CE->getOperand(0), SF); + GenericValue Op1 = getOperandValue(CE->getOperand(1), SF); + GenericValue Dest; + Type * Ty = CE->getOperand(0)->getType(); + switch (CE->getOpcode()) { + case Instruction::Add: Dest.IntVal = Op0.IntVal + Op1.IntVal; break; + case Instruction::Sub: Dest.IntVal = Op0.IntVal - Op1.IntVal; break; + case Instruction::Mul: Dest.IntVal = Op0.IntVal * Op1.IntVal; break; + case Instruction::FAdd: executeFAddInst(Dest, Op0, Op1, Ty); break; + case Instruction::FSub: executeFSubInst(Dest, Op0, Op1, Ty); break; + case Instruction::FMul: executeFMulInst(Dest, Op0, Op1, Ty); break; + case Instruction::FDiv: executeFDivInst(Dest, Op0, Op1, Ty); break; + case Instruction::FRem: executeFRemInst(Dest, Op0, Op1, Ty); break; + case Instruction::SDiv: Dest.IntVal = Op0.IntVal.sdiv(Op1.IntVal); break; + case Instruction::UDiv: Dest.IntVal = Op0.IntVal.udiv(Op1.IntVal); break; + case Instruction::URem: Dest.IntVal = Op0.IntVal.urem(Op1.IntVal); break; + case Instruction::SRem: Dest.IntVal = Op0.IntVal.srem(Op1.IntVal); break; + case Instruction::And: Dest.IntVal = Op0.IntVal & Op1.IntVal; break; + case Instruction::Or: Dest.IntVal = Op0.IntVal | Op1.IntVal; break; + case Instruction::Xor: Dest.IntVal = Op0.IntVal ^ Op1.IntVal; break; + case Instruction::Shl: + Dest.IntVal = Op0.IntVal.shl(Op1.IntVal.getZExtValue()); + break; + case Instruction::LShr: + Dest.IntVal = Op0.IntVal.lshr(Op1.IntVal.getZExtValue()); + break; + case Instruction::AShr: + Dest.IntVal = Op0.IntVal.ashr(Op1.IntVal.getZExtValue()); + break; + default: + dbgs() << "Unhandled ConstantExpr: " << *CE << "\n"; + llvm_unreachable("Unhandled ConstantExpr"); + } + return Dest; +} + +GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) { + if (ConstantExpr *CE = dyn_cast(V)) { + return getConstantExprValue(CE, SF); + } else if (Constant *CPV = dyn_cast(V)) { + return getConstantValue(CPV); + } else if (GlobalValue *GV = dyn_cast(V)) { + return PTOGV(getPointerToGlobal(GV)); + } else { + return SF.Values[V]; + } +} + //===----------------------------------------------------------------------===// // Dispatch and Execution Code //===----------------------------------------------------------------------===// @@ -1744,13 +1286,15 @@ void Interpreter::callFunction(Function *F, // Handle non-varargs arguments... unsigned i = 0; - for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); AI != E; ++AI, ++i) + for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); + AI != E; ++AI, ++i) SetValue(AI, ArgVals[i], StackFrame); // Handle varargs arguments... StackFrame.VarArgs.assign(ArgVals.begin()+i, ArgVals.end()); } + void Interpreter::run() { while (!ECStack.empty()) { // Interpret a single instruction & increment the "PC". @@ -1760,7 +1304,29 @@ void Interpreter::run() { // Track the number of dynamic instructions executed. ++NumDynamicInsts; - DOUT << "About to interpret: " << I; + DEBUG(dbgs() << "About to interpret: " << I); visit(I); // Dispatch to one of the visit* methods... +#if 0 + // This is not safe, as visiting the instruction could lower it and free I. +DEBUG( + if (!isa(I) && !isa(I) && + I.getType() != Type::VoidTy) { + dbgs() << " --> "; + const GenericValue &Val = SF.Values[&I]; + switch (I.getType()->getTypeID()) { + default: llvm_unreachable("Invalid GenericValue Type"); + case Type::VoidTyID: dbgs() << "void"; break; + case Type::FloatTyID: dbgs() << "float " << Val.FloatVal; break; + case Type::DoubleTyID: dbgs() << "double " << Val.DoubleVal; break; + case Type::PointerTyID: dbgs() << "void* " << intptr_t(Val.PointerVal); + break; + case Type::IntegerTyID: + dbgs() << "i" << Val.IntVal.getBitWidth() << " " + << Val.IntVal.toStringUnsigned(10) + << " (0x" << Val.IntVal.toStringUnsigned(16) << ")\n"; + break; + } + }); +#endif } }