Home | History | Annotate | Download | only in Interpreter
      1 //===-- Execution.cpp - Implement code to simulate the program ------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 //  This file contains the actual instruction interpreter.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #define DEBUG_TYPE "interpreter"
     15 #include "Interpreter.h"
     16 #include "llvm/ADT/APInt.h"
     17 #include "llvm/ADT/Statistic.h"
     18 #include "llvm/CodeGen/IntrinsicLowering.h"
     19 #include "llvm/IR/Constants.h"
     20 #include "llvm/IR/DerivedTypes.h"
     21 #include "llvm/IR/Instructions.h"
     22 #include "llvm/Support/CommandLine.h"
     23 #include "llvm/Support/Debug.h"
     24 #include "llvm/Support/ErrorHandling.h"
     25 #include "llvm/Support/GetElementPtrTypeIterator.h"
     26 #include "llvm/Support/MathExtras.h"
     27 #include <algorithm>
     28 #include <cmath>
     29 using namespace llvm;
     30 
     31 STATISTIC(NumDynamicInsts, "Number of dynamic instructions executed");
     32 
     33 static cl::opt<bool> PrintVolatile("interpreter-print-volatile", cl::Hidden,
     34           cl::desc("make the interpreter print every volatile load and store"));
     35 
     36 //===----------------------------------------------------------------------===//
     37 //                     Various Helper Functions
     38 //===----------------------------------------------------------------------===//
     39 
     40 static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) {
     41   SF.Values[V] = Val;
     42 }
     43 
     44 //===----------------------------------------------------------------------===//
     45 //                    Binary Instruction Implementations
     46 //===----------------------------------------------------------------------===//
     47 
     48 #define IMPLEMENT_BINARY_OPERATOR(OP, TY) \
     49    case Type::TY##TyID: \
     50      Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; \
     51      break
     52 
     53 static void executeFAddInst(GenericValue &Dest, GenericValue Src1,
     54                             GenericValue Src2, Type *Ty) {
     55   switch (Ty->getTypeID()) {
     56     IMPLEMENT_BINARY_OPERATOR(+, Float);
     57     IMPLEMENT_BINARY_OPERATOR(+, Double);
     58   default:
     59     dbgs() << "Unhandled type for FAdd instruction: " << *Ty << "\n";
     60     llvm_unreachable(0);
     61   }
     62 }
     63 
     64 static void executeFSubInst(GenericValue &Dest, GenericValue Src1,
     65                             GenericValue Src2, Type *Ty) {
     66   switch (Ty->getTypeID()) {
     67     IMPLEMENT_BINARY_OPERATOR(-, Float);
     68     IMPLEMENT_BINARY_OPERATOR(-, Double);
     69   default:
     70     dbgs() << "Unhandled type for FSub instruction: " << *Ty << "\n";
     71     llvm_unreachable(0);
     72   }
     73 }
     74 
     75 static void executeFMulInst(GenericValue &Dest, GenericValue Src1,
     76                             GenericValue Src2, Type *Ty) {
     77   switch (Ty->getTypeID()) {
     78     IMPLEMENT_BINARY_OPERATOR(*, Float);
     79     IMPLEMENT_BINARY_OPERATOR(*, Double);
     80   default:
     81     dbgs() << "Unhandled type for FMul instruction: " << *Ty << "\n";
     82     llvm_unreachable(0);
     83   }
     84 }
     85 
     86 static void executeFDivInst(GenericValue &Dest, GenericValue Src1,
     87                             GenericValue Src2, Type *Ty) {
     88   switch (Ty->getTypeID()) {
     89     IMPLEMENT_BINARY_OPERATOR(/, Float);
     90     IMPLEMENT_BINARY_OPERATOR(/, Double);
     91   default:
     92     dbgs() << "Unhandled type for FDiv instruction: " << *Ty << "\n";
     93     llvm_unreachable(0);
     94   }
     95 }
     96 
     97 static void executeFRemInst(GenericValue &Dest, GenericValue Src1,
     98                             GenericValue Src2, Type *Ty) {
     99   switch (Ty->getTypeID()) {
    100   case Type::FloatTyID:
    101     Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal);
    102     break;
    103   case Type::DoubleTyID:
    104     Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal);
    105     break;
    106   default:
    107     dbgs() << "Unhandled type for Rem instruction: " << *Ty << "\n";
    108     llvm_unreachable(0);
    109   }
    110 }
    111 
    112 #define IMPLEMENT_INTEGER_ICMP(OP, TY) \
    113    case Type::IntegerTyID:  \
    114       Dest.IntVal = APInt(1,Src1.IntVal.OP(Src2.IntVal)); \
    115       break;
    116 
    117 #define IMPLEMENT_VECTOR_INTEGER_ICMP(OP, TY)                        \
    118   case Type::VectorTyID: {                                           \
    119     assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());    \
    120     Dest.AggregateVal.resize( Src1.AggregateVal.size() );            \
    121     for( uint32_t _i=0;_i<Src1.AggregateVal.size();_i++)             \
    122       Dest.AggregateVal[_i].IntVal = APInt(1,                        \
    123       Src1.AggregateVal[_i].IntVal.OP(Src2.AggregateVal[_i].IntVal));\
    124   } break;
    125 
    126 // Handle pointers specially because they must be compared with only as much
    127 // width as the host has.  We _do not_ want to be comparing 64 bit values when
    128 // running on a 32-bit target, otherwise the upper 32 bits might mess up
    129 // comparisons if they contain garbage.
    130 #define IMPLEMENT_POINTER_ICMP(OP) \
    131    case Type::PointerTyID: \
    132       Dest.IntVal = APInt(1,(void*)(intptr_t)Src1.PointerVal OP \
    133                             (void*)(intptr_t)Src2.PointerVal); \
    134       break;
    135 
    136 static GenericValue executeICMP_EQ(GenericValue Src1, GenericValue Src2,
    137                                    Type *Ty) {
    138   GenericValue Dest;
    139   switch (Ty->getTypeID()) {
    140     IMPLEMENT_INTEGER_ICMP(eq,Ty);
    141     IMPLEMENT_VECTOR_INTEGER_ICMP(eq,Ty);
    142     IMPLEMENT_POINTER_ICMP(==);
    143   default:
    144     dbgs() << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n";
    145     llvm_unreachable(0);
    146   }
    147   return Dest;
    148 }
    149 
    150 static GenericValue executeICMP_NE(GenericValue Src1, GenericValue Src2,
    151                                    Type *Ty) {
    152   GenericValue Dest;
    153   switch (Ty->getTypeID()) {
    154     IMPLEMENT_INTEGER_ICMP(ne,Ty);
    155     IMPLEMENT_VECTOR_INTEGER_ICMP(ne,Ty);
    156     IMPLEMENT_POINTER_ICMP(!=);
    157   default:
    158     dbgs() << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n";
    159     llvm_unreachable(0);
    160   }
    161   return Dest;
    162 }
    163 
    164 static GenericValue executeICMP_ULT(GenericValue Src1, GenericValue Src2,
    165                                     Type *Ty) {
    166   GenericValue Dest;
    167   switch (Ty->getTypeID()) {
    168     IMPLEMENT_INTEGER_ICMP(ult,Ty);
    169     IMPLEMENT_VECTOR_INTEGER_ICMP(ult,Ty);
    170     IMPLEMENT_POINTER_ICMP(<);
    171   default:
    172     dbgs() << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n";
    173     llvm_unreachable(0);
    174   }
    175   return Dest;
    176 }
    177 
    178 static GenericValue executeICMP_SLT(GenericValue Src1, GenericValue Src2,
    179                                     Type *Ty) {
    180   GenericValue Dest;
    181   switch (Ty->getTypeID()) {
    182     IMPLEMENT_INTEGER_ICMP(slt,Ty);
    183     IMPLEMENT_VECTOR_INTEGER_ICMP(slt,Ty);
    184     IMPLEMENT_POINTER_ICMP(<);
    185   default:
    186     dbgs() << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n";
    187     llvm_unreachable(0);
    188   }
    189   return Dest;
    190 }
    191 
    192 static GenericValue executeICMP_UGT(GenericValue Src1, GenericValue Src2,
    193                                     Type *Ty) {
    194   GenericValue Dest;
    195   switch (Ty->getTypeID()) {
    196     IMPLEMENT_INTEGER_ICMP(ugt,Ty);
    197     IMPLEMENT_VECTOR_INTEGER_ICMP(ugt,Ty);
    198     IMPLEMENT_POINTER_ICMP(>);
    199   default:
    200     dbgs() << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n";
    201     llvm_unreachable(0);
    202   }
    203   return Dest;
    204 }
    205 
    206 static GenericValue executeICMP_SGT(GenericValue Src1, GenericValue Src2,
    207                                     Type *Ty) {
    208   GenericValue Dest;
    209   switch (Ty->getTypeID()) {
    210     IMPLEMENT_INTEGER_ICMP(sgt,Ty);
    211     IMPLEMENT_VECTOR_INTEGER_ICMP(sgt,Ty);
    212     IMPLEMENT_POINTER_ICMP(>);
    213   default:
    214     dbgs() << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n";
    215     llvm_unreachable(0);
    216   }
    217   return Dest;
    218 }
    219 
    220 static GenericValue executeICMP_ULE(GenericValue Src1, GenericValue Src2,
    221                                     Type *Ty) {
    222   GenericValue Dest;
    223   switch (Ty->getTypeID()) {
    224     IMPLEMENT_INTEGER_ICMP(ule,Ty);
    225     IMPLEMENT_VECTOR_INTEGER_ICMP(ule,Ty);
    226     IMPLEMENT_POINTER_ICMP(<=);
    227   default:
    228     dbgs() << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n";
    229     llvm_unreachable(0);
    230   }
    231   return Dest;
    232 }
    233 
    234 static GenericValue executeICMP_SLE(GenericValue Src1, GenericValue Src2,
    235                                     Type *Ty) {
    236   GenericValue Dest;
    237   switch (Ty->getTypeID()) {
    238     IMPLEMENT_INTEGER_ICMP(sle,Ty);
    239     IMPLEMENT_VECTOR_INTEGER_ICMP(sle,Ty);
    240     IMPLEMENT_POINTER_ICMP(<=);
    241   default:
    242     dbgs() << "Unhandled type for ICMP_SLE predicate: " << *Ty << "\n";
    243     llvm_unreachable(0);
    244   }
    245   return Dest;
    246 }
    247 
    248 static GenericValue executeICMP_UGE(GenericValue Src1, GenericValue Src2,
    249                                     Type *Ty) {
    250   GenericValue Dest;
    251   switch (Ty->getTypeID()) {
    252     IMPLEMENT_INTEGER_ICMP(uge,Ty);
    253     IMPLEMENT_VECTOR_INTEGER_ICMP(uge,Ty);
    254     IMPLEMENT_POINTER_ICMP(>=);
    255   default:
    256     dbgs() << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n";
    257     llvm_unreachable(0);
    258   }
    259   return Dest;
    260 }
    261 
    262 static GenericValue executeICMP_SGE(GenericValue Src1, GenericValue Src2,
    263                                     Type *Ty) {
    264   GenericValue Dest;
    265   switch (Ty->getTypeID()) {
    266     IMPLEMENT_INTEGER_ICMP(sge,Ty);
    267     IMPLEMENT_VECTOR_INTEGER_ICMP(sge,Ty);
    268     IMPLEMENT_POINTER_ICMP(>=);
    269   default:
    270     dbgs() << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n";
    271     llvm_unreachable(0);
    272   }
    273   return Dest;
    274 }
    275 
    276 void Interpreter::visitICmpInst(ICmpInst &I) {
    277   ExecutionContext &SF = ECStack.back();
    278   Type *Ty    = I.getOperand(0)->getType();
    279   GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
    280   GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
    281   GenericValue R;   // Result
    282 
    283   switch (I.getPredicate()) {
    284   case ICmpInst::ICMP_EQ:  R = executeICMP_EQ(Src1,  Src2, Ty); break;
    285   case ICmpInst::ICMP_NE:  R = executeICMP_NE(Src1,  Src2, Ty); break;
    286   case ICmpInst::ICMP_ULT: R = executeICMP_ULT(Src1, Src2, Ty); break;
    287   case ICmpInst::ICMP_SLT: R = executeICMP_SLT(Src1, Src2, Ty); break;
    288   case ICmpInst::ICMP_UGT: R = executeICMP_UGT(Src1, Src2, Ty); break;
    289   case ICmpInst::ICMP_SGT: R = executeICMP_SGT(Src1, Src2, Ty); break;
    290   case ICmpInst::ICMP_ULE: R = executeICMP_ULE(Src1, Src2, Ty); break;
    291   case ICmpInst::ICMP_SLE: R = executeICMP_SLE(Src1, Src2, Ty); break;
    292   case ICmpInst::ICMP_UGE: R = executeICMP_UGE(Src1, Src2, Ty); break;
    293   case ICmpInst::ICMP_SGE: R = executeICMP_SGE(Src1, Src2, Ty); break;
    294   default:
    295     dbgs() << "Don't know how to handle this ICmp predicate!\n-->" << I;
    296     llvm_unreachable(0);
    297   }
    298 
    299   SetValue(&I, R, SF);
    300 }
    301 
    302 #define IMPLEMENT_FCMP(OP, TY) \
    303    case Type::TY##TyID: \
    304      Dest.IntVal = APInt(1,Src1.TY##Val OP Src2.TY##Val); \
    305      break
    306 
    307 #define IMPLEMENT_VECTOR_FCMP_T(OP, TY)                             \
    308   assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());     \
    309   Dest.AggregateVal.resize( Src1.AggregateVal.size() );             \
    310   for( uint32_t _i=0;_i<Src1.AggregateVal.size();_i++)              \
    311     Dest.AggregateVal[_i].IntVal = APInt(1,                         \
    312     Src1.AggregateVal[_i].TY##Val OP Src2.AggregateVal[_i].TY##Val);\
    313   break;
    314 
    315 #define IMPLEMENT_VECTOR_FCMP(OP)                                   \
    316   case Type::VectorTyID:                                            \
    317     if(dyn_cast<VectorType>(Ty)->getElementType()->isFloatTy()) {   \
    318       IMPLEMENT_VECTOR_FCMP_T(OP, Float);                           \
    319     } else {                                                        \
    320         IMPLEMENT_VECTOR_FCMP_T(OP, Double);                        \
    321     }
    322 
    323 static GenericValue executeFCMP_OEQ(GenericValue Src1, GenericValue Src2,
    324                                    Type *Ty) {
    325   GenericValue Dest;
    326   switch (Ty->getTypeID()) {
    327     IMPLEMENT_FCMP(==, Float);
    328     IMPLEMENT_FCMP(==, Double);
    329     IMPLEMENT_VECTOR_FCMP(==);
    330   default:
    331     dbgs() << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n";
    332     llvm_unreachable(0);
    333   }
    334   return Dest;
    335 }
    336 
    337 #define IMPLEMENT_SCALAR_NANS(TY, X,Y)                                      \
    338   if (TY->isFloatTy()) {                                                    \
    339     if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) {             \
    340       Dest.IntVal = APInt(1,false);                                         \
    341       return Dest;                                                          \
    342     }                                                                       \
    343   } else {                                                                  \
    344     if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) {         \
    345       Dest.IntVal = APInt(1,false);                                         \
    346       return Dest;                                                          \
    347     }                                                                       \
    348   }
    349 
    350 #define MASK_VECTOR_NANS_T(X,Y, TZ, FLAG)                                   \
    351   assert(X.AggregateVal.size() == Y.AggregateVal.size());                   \
    352   Dest.AggregateVal.resize( X.AggregateVal.size() );                        \
    353   for( uint32_t _i=0;_i<X.AggregateVal.size();_i++) {                       \
    354     if (X.AggregateVal[_i].TZ##Val != X.AggregateVal[_i].TZ##Val ||         \
    355         Y.AggregateVal[_i].TZ##Val != Y.AggregateVal[_i].TZ##Val)           \
    356       Dest.AggregateVal[_i].IntVal = APInt(1,FLAG);                         \
    357     else  {                                                                 \
    358       Dest.AggregateVal[_i].IntVal = APInt(1,!FLAG);                        \
    359     }                                                                       \
    360   }
    361 
    362 #define MASK_VECTOR_NANS(TY, X,Y, FLAG)                                     \
    363   if (TY->isVectorTy()) {                                                   \
    364     if (dyn_cast<VectorType>(TY)->getElementType()->isFloatTy()) {          \
    365       MASK_VECTOR_NANS_T(X, Y, Float, FLAG)                                 \
    366     } else {                                                                \
    367       MASK_VECTOR_NANS_T(X, Y, Double, FLAG)                                \
    368     }                                                                       \
    369   }                                                                         \
    370 
    371 
    372 
    373 static GenericValue executeFCMP_ONE(GenericValue Src1, GenericValue Src2,
    374                                     Type *Ty)
    375 {
    376   GenericValue Dest;
    377   // if input is scalar value and Src1 or Src2 is NaN return false
    378   IMPLEMENT_SCALAR_NANS(Ty, Src1, Src2)
    379   // if vector input detect NaNs and fill mask
    380   MASK_VECTOR_NANS(Ty, Src1, Src2, false)
    381   GenericValue DestMask = Dest;
    382   switch (Ty->getTypeID()) {
    383     IMPLEMENT_FCMP(!=, Float);
    384     IMPLEMENT_FCMP(!=, Double);
    385     IMPLEMENT_VECTOR_FCMP(!=);
    386     default:
    387       dbgs() << "Unhandled type for FCmp NE instruction: " << *Ty << "\n";
    388       llvm_unreachable(0);
    389   }
    390   // in vector case mask out NaN elements
    391   if (Ty->isVectorTy())
    392     for( size_t _i=0; _i<Src1.AggregateVal.size(); _i++)
    393       if (DestMask.AggregateVal[_i].IntVal == false)
    394         Dest.AggregateVal[_i].IntVal = APInt(1,false);
    395 
    396   return Dest;
    397 }
    398 
    399 static GenericValue executeFCMP_OLE(GenericValue Src1, GenericValue Src2,
    400                                    Type *Ty) {
    401   GenericValue Dest;
    402   switch (Ty->getTypeID()) {
    403     IMPLEMENT_FCMP(<=, Float);
    404     IMPLEMENT_FCMP(<=, Double);
    405     IMPLEMENT_VECTOR_FCMP(<=);
    406   default:
    407     dbgs() << "Unhandled type for FCmp LE instruction: " << *Ty << "\n";
    408     llvm_unreachable(0);
    409   }
    410   return Dest;
    411 }
    412 
    413 static GenericValue executeFCMP_OGE(GenericValue Src1, GenericValue Src2,
    414                                    Type *Ty) {
    415   GenericValue Dest;
    416   switch (Ty->getTypeID()) {
    417     IMPLEMENT_FCMP(>=, Float);
    418     IMPLEMENT_FCMP(>=, Double);
    419     IMPLEMENT_VECTOR_FCMP(>=);
    420   default:
    421     dbgs() << "Unhandled type for FCmp GE instruction: " << *Ty << "\n";
    422     llvm_unreachable(0);
    423   }
    424   return Dest;
    425 }
    426 
    427 static GenericValue executeFCMP_OLT(GenericValue Src1, GenericValue Src2,
    428                                    Type *Ty) {
    429   GenericValue Dest;
    430   switch (Ty->getTypeID()) {
    431     IMPLEMENT_FCMP(<, Float);
    432     IMPLEMENT_FCMP(<, Double);
    433     IMPLEMENT_VECTOR_FCMP(<);
    434   default:
    435     dbgs() << "Unhandled type for FCmp LT instruction: " << *Ty << "\n";
    436     llvm_unreachable(0);
    437   }
    438   return Dest;
    439 }
    440 
    441 static GenericValue executeFCMP_OGT(GenericValue Src1, GenericValue Src2,
    442                                      Type *Ty) {
    443   GenericValue Dest;
    444   switch (Ty->getTypeID()) {
    445     IMPLEMENT_FCMP(>, Float);
    446     IMPLEMENT_FCMP(>, Double);
    447     IMPLEMENT_VECTOR_FCMP(>);
    448   default:
    449     dbgs() << "Unhandled type for FCmp GT instruction: " << *Ty << "\n";
    450     llvm_unreachable(0);
    451   }
    452   return Dest;
    453 }
    454 
    455 #define IMPLEMENT_UNORDERED(TY, X,Y)                                     \
    456   if (TY->isFloatTy()) {                                                 \
    457     if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) {          \
    458       Dest.IntVal = APInt(1,true);                                       \
    459       return Dest;                                                       \
    460     }                                                                    \
    461   } else if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) { \
    462     Dest.IntVal = APInt(1,true);                                         \
    463     return Dest;                                                         \
    464   }
    465 
    466 #define IMPLEMENT_VECTOR_UNORDERED(TY, X,Y, _FUNC)                       \
    467   if (TY->isVectorTy()) {                                                \
    468     GenericValue DestMask = Dest;                                        \
    469     Dest = _FUNC(Src1, Src2, Ty);                                        \
    470       for( size_t _i=0; _i<Src1.AggregateVal.size(); _i++)               \
    471         if (DestMask.AggregateVal[_i].IntVal == true)                    \
    472           Dest.AggregateVal[_i].IntVal = APInt(1,true);                  \
    473       return Dest;                                                       \
    474   }
    475 
    476 static GenericValue executeFCMP_UEQ(GenericValue Src1, GenericValue Src2,
    477                                    Type *Ty) {
    478   GenericValue Dest;
    479   IMPLEMENT_UNORDERED(Ty, Src1, Src2)
    480   MASK_VECTOR_NANS(Ty, Src1, Src2, true)
    481   IMPLEMENT_VECTOR_UNORDERED(Ty, Src1, Src2, executeFCMP_OEQ)
    482   return executeFCMP_OEQ(Src1, Src2, Ty);
    483 
    484 }
    485 
    486 static GenericValue executeFCMP_UNE(GenericValue Src1, GenericValue Src2,
    487                                    Type *Ty) {
    488   GenericValue Dest;
    489   IMPLEMENT_UNORDERED(Ty, Src1, Src2)
    490   MASK_VECTOR_NANS(Ty, Src1, Src2, true)
    491   IMPLEMENT_VECTOR_UNORDERED(Ty, Src1, Src2, executeFCMP_ONE)
    492   return executeFCMP_ONE(Src1, Src2, Ty);
    493 }
    494 
    495 static GenericValue executeFCMP_ULE(GenericValue Src1, GenericValue Src2,
    496                                    Type *Ty) {
    497   GenericValue Dest;
    498   IMPLEMENT_UNORDERED(Ty, Src1, Src2)
    499   MASK_VECTOR_NANS(Ty, Src1, Src2, true)
    500   IMPLEMENT_VECTOR_UNORDERED(Ty, Src1, Src2, executeFCMP_OLE)
    501   return executeFCMP_OLE(Src1, Src2, Ty);
    502 }
    503 
    504 static GenericValue executeFCMP_UGE(GenericValue Src1, GenericValue Src2,
    505                                    Type *Ty) {
    506   GenericValue Dest;
    507   IMPLEMENT_UNORDERED(Ty, Src1, Src2)
    508   MASK_VECTOR_NANS(Ty, Src1, Src2, true)
    509   IMPLEMENT_VECTOR_UNORDERED(Ty, Src1, Src2, executeFCMP_OGE)
    510   return executeFCMP_OGE(Src1, Src2, Ty);
    511 }
    512 
    513 static GenericValue executeFCMP_ULT(GenericValue Src1, GenericValue Src2,
    514                                    Type *Ty) {
    515   GenericValue Dest;
    516   IMPLEMENT_UNORDERED(Ty, Src1, Src2)
    517   MASK_VECTOR_NANS(Ty, Src1, Src2, true)
    518   IMPLEMENT_VECTOR_UNORDERED(Ty, Src1, Src2, executeFCMP_OLT)
    519   return executeFCMP_OLT(Src1, Src2, Ty);
    520 }
    521 
    522 static GenericValue executeFCMP_UGT(GenericValue Src1, GenericValue Src2,
    523                                      Type *Ty) {
    524   GenericValue Dest;
    525   IMPLEMENT_UNORDERED(Ty, Src1, Src2)
    526   MASK_VECTOR_NANS(Ty, Src1, Src2, true)
    527   IMPLEMENT_VECTOR_UNORDERED(Ty, Src1, Src2, executeFCMP_OGT)
    528   return executeFCMP_OGT(Src1, Src2, Ty);
    529 }
    530 
    531 static GenericValue executeFCMP_ORD(GenericValue Src1, GenericValue Src2,
    532                                      Type *Ty) {
    533   GenericValue Dest;
    534   if(Ty->isVectorTy()) {
    535     assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
    536     Dest.AggregateVal.resize( Src1.AggregateVal.size() );
    537     if(dyn_cast<VectorType>(Ty)->getElementType()->isFloatTy()) {
    538       for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
    539         Dest.AggregateVal[_i].IntVal = APInt(1,
    540         ( (Src1.AggregateVal[_i].FloatVal ==
    541         Src1.AggregateVal[_i].FloatVal) &&
    542         (Src2.AggregateVal[_i].FloatVal ==
    543         Src2.AggregateVal[_i].FloatVal)));
    544     } else {
    545       for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
    546         Dest.AggregateVal[_i].IntVal = APInt(1,
    547         ( (Src1.AggregateVal[_i].DoubleVal ==
    548         Src1.AggregateVal[_i].DoubleVal) &&
    549         (Src2.AggregateVal[_i].DoubleVal ==
    550         Src2.AggregateVal[_i].DoubleVal)));
    551     }
    552   } else if (Ty->isFloatTy())
    553     Dest.IntVal = APInt(1,(Src1.FloatVal == Src1.FloatVal &&
    554                            Src2.FloatVal == Src2.FloatVal));
    555   else {
    556     Dest.IntVal = APInt(1,(Src1.DoubleVal == Src1.DoubleVal &&
    557                            Src2.DoubleVal == Src2.DoubleVal));
    558   }
    559   return Dest;
    560 }
    561 
    562 static GenericValue executeFCMP_UNO(GenericValue Src1, GenericValue Src2,
    563                                      Type *Ty) {
    564   GenericValue Dest;
    565   if(Ty->isVectorTy()) {
    566     assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
    567     Dest.AggregateVal.resize( Src1.AggregateVal.size() );
    568     if(dyn_cast<VectorType>(Ty)->getElementType()->isFloatTy()) {
    569       for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
    570         Dest.AggregateVal[_i].IntVal = APInt(1,
    571         ( (Src1.AggregateVal[_i].FloatVal !=
    572            Src1.AggregateVal[_i].FloatVal) ||
    573           (Src2.AggregateVal[_i].FloatVal !=
    574            Src2.AggregateVal[_i].FloatVal)));
    575       } else {
    576         for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
    577           Dest.AggregateVal[_i].IntVal = APInt(1,
    578           ( (Src1.AggregateVal[_i].DoubleVal !=
    579              Src1.AggregateVal[_i].DoubleVal) ||
    580             (Src2.AggregateVal[_i].DoubleVal !=
    581              Src2.AggregateVal[_i].DoubleVal)));
    582       }
    583   } else if (Ty->isFloatTy())
    584     Dest.IntVal = APInt(1,(Src1.FloatVal != Src1.FloatVal ||
    585                            Src2.FloatVal != Src2.FloatVal));
    586   else {
    587     Dest.IntVal = APInt(1,(Src1.DoubleVal != Src1.DoubleVal ||
    588                            Src2.DoubleVal != Src2.DoubleVal));
    589   }
    590   return Dest;
    591 }
    592 
    593 static GenericValue executeFCMP_BOOL(GenericValue Src1, GenericValue Src2,
    594                                     const Type *Ty, const bool val) {
    595   GenericValue Dest;
    596     if(Ty->isVectorTy()) {
    597       assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
    598       Dest.AggregateVal.resize( Src1.AggregateVal.size() );
    599       for( size_t _i=0; _i<Src1.AggregateVal.size(); _i++)
    600         Dest.AggregateVal[_i].IntVal = APInt(1,val);
    601     } else {
    602       Dest.IntVal = APInt(1, val);
    603     }
    604 
    605     return Dest;
    606 }
    607 
    608 void Interpreter::visitFCmpInst(FCmpInst &I) {
    609   ExecutionContext &SF = ECStack.back();
    610   Type *Ty    = I.getOperand(0)->getType();
    611   GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
    612   GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
    613   GenericValue R;   // Result
    614 
    615   switch (I.getPredicate()) {
    616   default:
    617     dbgs() << "Don't know how to handle this FCmp predicate!\n-->" << I;
    618     llvm_unreachable(0);
    619   break;
    620   case FCmpInst::FCMP_FALSE: R = executeFCMP_BOOL(Src1, Src2, Ty, false);
    621   break;
    622   case FCmpInst::FCMP_TRUE:  R = executeFCMP_BOOL(Src1, Src2, Ty, true);
    623   break;
    624   case FCmpInst::FCMP_ORD:   R = executeFCMP_ORD(Src1, Src2, Ty); break;
    625   case FCmpInst::FCMP_UNO:   R = executeFCMP_UNO(Src1, Src2, Ty); break;
    626   case FCmpInst::FCMP_UEQ:   R = executeFCMP_UEQ(Src1, Src2, Ty); break;
    627   case FCmpInst::FCMP_OEQ:   R = executeFCMP_OEQ(Src1, Src2, Ty); break;
    628   case FCmpInst::FCMP_UNE:   R = executeFCMP_UNE(Src1, Src2, Ty); break;
    629   case FCmpInst::FCMP_ONE:   R = executeFCMP_ONE(Src1, Src2, Ty); break;
    630   case FCmpInst::FCMP_ULT:   R = executeFCMP_ULT(Src1, Src2, Ty); break;
    631   case FCmpInst::FCMP_OLT:   R = executeFCMP_OLT(Src1, Src2, Ty); break;
    632   case FCmpInst::FCMP_UGT:   R = executeFCMP_UGT(Src1, Src2, Ty); break;
    633   case FCmpInst::FCMP_OGT:   R = executeFCMP_OGT(Src1, Src2, Ty); break;
    634   case FCmpInst::FCMP_ULE:   R = executeFCMP_ULE(Src1, Src2, Ty); break;
    635   case FCmpInst::FCMP_OLE:   R = executeFCMP_OLE(Src1, Src2, Ty); break;
    636   case FCmpInst::FCMP_UGE:   R = executeFCMP_UGE(Src1, Src2, Ty); break;
    637   case FCmpInst::FCMP_OGE:   R = executeFCMP_OGE(Src1, Src2, Ty); break;
    638   }
    639 
    640   SetValue(&I, R, SF);
    641 }
    642 
    643 static GenericValue executeCmpInst(unsigned predicate, GenericValue Src1,
    644                                    GenericValue Src2, Type *Ty) {
    645   GenericValue Result;
    646   switch (predicate) {
    647   case ICmpInst::ICMP_EQ:    return executeICMP_EQ(Src1, Src2, Ty);
    648   case ICmpInst::ICMP_NE:    return executeICMP_NE(Src1, Src2, Ty);
    649   case ICmpInst::ICMP_UGT:   return executeICMP_UGT(Src1, Src2, Ty);
    650   case ICmpInst::ICMP_SGT:   return executeICMP_SGT(Src1, Src2, Ty);
    651   case ICmpInst::ICMP_ULT:   return executeICMP_ULT(Src1, Src2, Ty);
    652   case ICmpInst::ICMP_SLT:   return executeICMP_SLT(Src1, Src2, Ty);
    653   case ICmpInst::ICMP_UGE:   return executeICMP_UGE(Src1, Src2, Ty);
    654   case ICmpInst::ICMP_SGE:   return executeICMP_SGE(Src1, Src2, Ty);
    655   case ICmpInst::ICMP_ULE:   return executeICMP_ULE(Src1, Src2, Ty);
    656   case ICmpInst::ICMP_SLE:   return executeICMP_SLE(Src1, Src2, Ty);
    657   case FCmpInst::FCMP_ORD:   return executeFCMP_ORD(Src1, Src2, Ty);
    658   case FCmpInst::FCMP_UNO:   return executeFCMP_UNO(Src1, Src2, Ty);
    659   case FCmpInst::FCMP_OEQ:   return executeFCMP_OEQ(Src1, Src2, Ty);
    660   case FCmpInst::FCMP_UEQ:   return executeFCMP_UEQ(Src1, Src2, Ty);
    661   case FCmpInst::FCMP_ONE:   return executeFCMP_ONE(Src1, Src2, Ty);
    662   case FCmpInst::FCMP_UNE:   return executeFCMP_UNE(Src1, Src2, Ty);
    663   case FCmpInst::FCMP_OLT:   return executeFCMP_OLT(Src1, Src2, Ty);
    664   case FCmpInst::FCMP_ULT:   return executeFCMP_ULT(Src1, Src2, Ty);
    665   case FCmpInst::FCMP_OGT:   return executeFCMP_OGT(Src1, Src2, Ty);
    666   case FCmpInst::FCMP_UGT:   return executeFCMP_UGT(Src1, Src2, Ty);
    667   case FCmpInst::FCMP_OLE:   return executeFCMP_OLE(Src1, Src2, Ty);
    668   case FCmpInst::FCMP_ULE:   return executeFCMP_ULE(Src1, Src2, Ty);
    669   case FCmpInst::FCMP_OGE:   return executeFCMP_OGE(Src1, Src2, Ty);
    670   case FCmpInst::FCMP_UGE:   return executeFCMP_UGE(Src1, Src2, Ty);
    671   case FCmpInst::FCMP_FALSE: return executeFCMP_BOOL(Src1, Src2, Ty, false);
    672   case FCmpInst::FCMP_TRUE:  return executeFCMP_BOOL(Src1, Src2, Ty, true);
    673   default:
    674     dbgs() << "Unhandled Cmp predicate\n";
    675     llvm_unreachable(0);
    676   }
    677 }
    678 
    679 void Interpreter::visitBinaryOperator(BinaryOperator &I) {
    680   ExecutionContext &SF = ECStack.back();
    681   Type *Ty    = I.getOperand(0)->getType();
    682   GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
    683   GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
    684   GenericValue R;   // Result
    685 
    686   // First process vector operation
    687   if (Ty->isVectorTy()) {
    688     assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
    689     R.AggregateVal.resize(Src1.AggregateVal.size());
    690 
    691     // Macros to execute binary operation 'OP' over integer vectors
    692 #define INTEGER_VECTOR_OPERATION(OP)                               \
    693     for (unsigned i = 0; i < R.AggregateVal.size(); ++i)           \
    694       R.AggregateVal[i].IntVal =                                   \
    695       Src1.AggregateVal[i].IntVal OP Src2.AggregateVal[i].IntVal;
    696 
    697     // Additional macros to execute binary operations udiv/sdiv/urem/srem since
    698     // they have different notation.
    699 #define INTEGER_VECTOR_FUNCTION(OP)                                \
    700     for (unsigned i = 0; i < R.AggregateVal.size(); ++i)           \
    701       R.AggregateVal[i].IntVal =                                   \
    702       Src1.AggregateVal[i].IntVal.OP(Src2.AggregateVal[i].IntVal);
    703 
    704     // Macros to execute binary operation 'OP' over floating point type TY
    705     // (float or double) vectors
    706 #define FLOAT_VECTOR_FUNCTION(OP, TY)                               \
    707       for (unsigned i = 0; i < R.AggregateVal.size(); ++i)          \
    708         R.AggregateVal[i].TY =                                      \
    709         Src1.AggregateVal[i].TY OP Src2.AggregateVal[i].TY;
    710 
    711     // Macros to choose appropriate TY: float or double and run operation
    712     // execution
    713 #define FLOAT_VECTOR_OP(OP) {                                         \
    714   if (dyn_cast<VectorType>(Ty)->getElementType()->isFloatTy())        \
    715     FLOAT_VECTOR_FUNCTION(OP, FloatVal)                               \
    716   else {                                                              \
    717     if (dyn_cast<VectorType>(Ty)->getElementType()->isDoubleTy())     \
    718       FLOAT_VECTOR_FUNCTION(OP, DoubleVal)                            \
    719     else {                                                            \
    720       dbgs() << "Unhandled type for OP instruction: " << *Ty << "\n"; \
    721       llvm_unreachable(0);                                            \
    722     }                                                                 \
    723   }                                                                   \
    724 }
    725 
    726     switch(I.getOpcode()){
    727     default:
    728       dbgs() << "Don't know how to handle this binary operator!\n-->" << I;
    729       llvm_unreachable(0);
    730       break;
    731     case Instruction::Add:   INTEGER_VECTOR_OPERATION(+) break;
    732     case Instruction::Sub:   INTEGER_VECTOR_OPERATION(-) break;
    733     case Instruction::Mul:   INTEGER_VECTOR_OPERATION(*) break;
    734     case Instruction::UDiv:  INTEGER_VECTOR_FUNCTION(udiv) break;
    735     case Instruction::SDiv:  INTEGER_VECTOR_FUNCTION(sdiv) break;
    736     case Instruction::URem:  INTEGER_VECTOR_FUNCTION(urem) break;
    737     case Instruction::SRem:  INTEGER_VECTOR_FUNCTION(srem) break;
    738     case Instruction::And:   INTEGER_VECTOR_OPERATION(&) break;
    739     case Instruction::Or:    INTEGER_VECTOR_OPERATION(|) break;
    740     case Instruction::Xor:   INTEGER_VECTOR_OPERATION(^) break;
    741     case Instruction::FAdd:  FLOAT_VECTOR_OP(+) break;
    742     case Instruction::FSub:  FLOAT_VECTOR_OP(-) break;
    743     case Instruction::FMul:  FLOAT_VECTOR_OP(*) break;
    744     case Instruction::FDiv:  FLOAT_VECTOR_OP(/) break;
    745     case Instruction::FRem:
    746       if (dyn_cast<VectorType>(Ty)->getElementType()->isFloatTy())
    747         for (unsigned i = 0; i < R.AggregateVal.size(); ++i)
    748           R.AggregateVal[i].FloatVal =
    749           fmod(Src1.AggregateVal[i].FloatVal, Src2.AggregateVal[i].FloatVal);
    750       else {
    751         if (dyn_cast<VectorType>(Ty)->getElementType()->isDoubleTy())
    752           for (unsigned i = 0; i < R.AggregateVal.size(); ++i)
    753             R.AggregateVal[i].DoubleVal =
    754             fmod(Src1.AggregateVal[i].DoubleVal, Src2.AggregateVal[i].DoubleVal);
    755         else {
    756           dbgs() << "Unhandled type for Rem instruction: " << *Ty << "\n";
    757           llvm_unreachable(0);
    758         }
    759       }
    760       break;
    761     }
    762   } else {
    763     switch (I.getOpcode()) {
    764     default:
    765       dbgs() << "Don't know how to handle this binary operator!\n-->" << I;
    766       llvm_unreachable(0);
    767       break;
    768     case Instruction::Add:   R.IntVal = Src1.IntVal + Src2.IntVal; break;
    769     case Instruction::Sub:   R.IntVal = Src1.IntVal - Src2.IntVal; break;
    770     case Instruction::Mul:   R.IntVal = Src1.IntVal * Src2.IntVal; break;
    771     case Instruction::FAdd:  executeFAddInst(R, Src1, Src2, Ty); break;
    772     case Instruction::FSub:  executeFSubInst(R, Src1, Src2, Ty); break;
    773     case Instruction::FMul:  executeFMulInst(R, Src1, Src2, Ty); break;
    774     case Instruction::FDiv:  executeFDivInst(R, Src1, Src2, Ty); break;
    775     case Instruction::FRem:  executeFRemInst(R, Src1, Src2, Ty); break;
    776     case Instruction::UDiv:  R.IntVal = Src1.IntVal.udiv(Src2.IntVal); break;
    777     case Instruction::SDiv:  R.IntVal = Src1.IntVal.sdiv(Src2.IntVal); break;
    778     case Instruction::URem:  R.IntVal = Src1.IntVal.urem(Src2.IntVal); break;
    779     case Instruction::SRem:  R.IntVal = Src1.IntVal.srem(Src2.IntVal); break;
    780     case Instruction::And:   R.IntVal = Src1.IntVal & Src2.IntVal; break;
    781     case Instruction::Or:    R.IntVal = Src1.IntVal | Src2.IntVal; break;
    782     case Instruction::Xor:   R.IntVal = Src1.IntVal ^ Src2.IntVal; break;
    783     }
    784   }
    785   SetValue(&I, R, SF);
    786 }
    787 
    788 static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
    789                                       GenericValue Src3) {
    790   return Src1.IntVal == 0 ? Src3 : Src2;
    791 }
    792 
    793 void Interpreter::visitSelectInst(SelectInst &I) {
    794   ExecutionContext &SF = ECStack.back();
    795   GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
    796   GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
    797   GenericValue Src3 = getOperandValue(I.getOperand(2), SF);
    798   GenericValue R = executeSelectInst(Src1, Src2, Src3);
    799   SetValue(&I, R, SF);
    800 }
    801 
    802 
    803 //===----------------------------------------------------------------------===//
    804 //                     Terminator Instruction Implementations
    805 //===----------------------------------------------------------------------===//
    806 
    807 void Interpreter::exitCalled(GenericValue GV) {
    808   // runAtExitHandlers() assumes there are no stack frames, but
    809   // if exit() was called, then it had a stack frame. Blow away
    810   // the stack before interpreting atexit handlers.
    811   ECStack.clear();
    812   runAtExitHandlers();
    813   exit(GV.IntVal.zextOrTrunc(32).getZExtValue());
    814 }
    815 
    816 /// Pop the last stack frame off of ECStack and then copy the result
    817 /// back into the result variable if we are not returning void. The
    818 /// result variable may be the ExitValue, or the Value of the calling
    819 /// CallInst if there was a previous stack frame. This method may
    820 /// invalidate any ECStack iterators you have. This method also takes
    821 /// care of switching to the normal destination BB, if we are returning
    822 /// from an invoke.
    823 ///
    824 void Interpreter::popStackAndReturnValueToCaller(Type *RetTy,
    825                                                  GenericValue Result) {
    826   // Pop the current stack frame.
    827   ECStack.pop_back();
    828 
    829   if (ECStack.empty()) {  // Finished main.  Put result into exit code...
    830     if (RetTy && !RetTy->isVoidTy()) {          // Nonvoid return type?
    831       ExitValue = Result;   // Capture the exit value of the program
    832     } else {
    833       memset(&ExitValue.Untyped, 0, sizeof(ExitValue.Untyped));
    834     }
    835   } else {
    836     // If we have a previous stack frame, and we have a previous call,
    837     // fill in the return value...
    838     ExecutionContext &CallingSF = ECStack.back();
    839     if (Instruction *I = CallingSF.Caller.getInstruction()) {
    840       // Save result...
    841       if (!CallingSF.Caller.getType()->isVoidTy())
    842         SetValue(I, Result, CallingSF);
    843       if (InvokeInst *II = dyn_cast<InvokeInst> (I))
    844         SwitchToNewBasicBlock (II->getNormalDest (), CallingSF);
    845       CallingSF.Caller = CallSite();          // We returned from the call...
    846     }
    847   }
    848 }
    849 
    850 void Interpreter::visitReturnInst(ReturnInst &I) {
    851   ExecutionContext &SF = ECStack.back();
    852   Type *RetTy = Type::getVoidTy(I.getContext());
    853   GenericValue Result;
    854 
    855   // Save away the return value... (if we are not 'ret void')
    856   if (I.getNumOperands()) {
    857     RetTy  = I.getReturnValue()->getType();
    858     Result = getOperandValue(I.getReturnValue(), SF);
    859   }
    860 
    861   popStackAndReturnValueToCaller(RetTy, Result);
    862 }
    863 
    864 void Interpreter::visitUnreachableInst(UnreachableInst &I) {
    865   report_fatal_error("Program executed an 'unreachable' instruction!");
    866 }
    867 
    868 void Interpreter::visitBranchInst(BranchInst &I) {
    869   ExecutionContext &SF = ECStack.back();
    870   BasicBlock *Dest;
    871 
    872   Dest = I.getSuccessor(0);          // Uncond branches have a fixed dest...
    873   if (!I.isUnconditional()) {
    874     Value *Cond = I.getCondition();
    875     if (getOperandValue(Cond, SF).IntVal == 0) // If false cond...
    876       Dest = I.getSuccessor(1);
    877   }
    878   SwitchToNewBasicBlock(Dest, SF);
    879 }
    880 
    881 void Interpreter::visitSwitchInst(SwitchInst &I) {
    882   ExecutionContext &SF = ECStack.back();
    883   Value* Cond = I.getCondition();
    884   Type *ElTy = Cond->getType();
    885   GenericValue CondVal = getOperandValue(Cond, SF);
    886 
    887   // Check to see if any of the cases match...
    888   BasicBlock *Dest = 0;
    889   for (SwitchInst::CaseIt i = I.case_begin(), e = I.case_end(); i != e; ++i) {
    890     IntegersSubset& Case = i.getCaseValueEx();
    891     if (Case.isSingleNumber()) {
    892       // FIXME: Currently work with ConstantInt based numbers.
    893       const ConstantInt *CI = Case.getSingleNumber(0).toConstantInt();
    894       GenericValue Val = getOperandValue(const_cast<ConstantInt*>(CI), SF);
    895       if (executeICMP_EQ(Val, CondVal, ElTy).IntVal != 0) {
    896         Dest = cast<BasicBlock>(i.getCaseSuccessor());
    897         break;
    898       }
    899     }
    900     if (Case.isSingleNumbersOnly()) {
    901       for (unsigned n = 0, en = Case.getNumItems(); n != en; ++n) {
    902         // FIXME: Currently work with ConstantInt based numbers.
    903         const ConstantInt *CI = Case.getSingleNumber(n).toConstantInt();
    904         GenericValue Val = getOperandValue(const_cast<ConstantInt*>(CI), SF);
    905         if (executeICMP_EQ(Val, CondVal, ElTy).IntVal != 0) {
    906           Dest = cast<BasicBlock>(i.getCaseSuccessor());
    907           break;
    908         }
    909       }
    910     } else
    911       for (unsigned n = 0, en = Case.getNumItems(); n != en; ++n) {
    912         IntegersSubset::Range r = Case.getItem(n);
    913         // FIXME: Currently work with ConstantInt based numbers.
    914         const ConstantInt *LowCI = r.getLow().toConstantInt();
    915         const ConstantInt *HighCI = r.getHigh().toConstantInt();
    916         GenericValue Low = getOperandValue(const_cast<ConstantInt*>(LowCI), SF);
    917         GenericValue High = getOperandValue(const_cast<ConstantInt*>(HighCI), SF);
    918         if (executeICMP_ULE(Low, CondVal, ElTy).IntVal != 0 &&
    919             executeICMP_ULE(CondVal, High, ElTy).IntVal != 0) {
    920           Dest = cast<BasicBlock>(i.getCaseSuccessor());
    921           break;
    922         }
    923       }
    924   }
    925   if (!Dest) Dest = I.getDefaultDest();   // No cases matched: use default
    926   SwitchToNewBasicBlock(Dest, SF);
    927 }
    928 
    929 void Interpreter::visitIndirectBrInst(IndirectBrInst &I) {
    930   ExecutionContext &SF = ECStack.back();
    931   void *Dest = GVTOP(getOperandValue(I.getAddress(), SF));
    932   SwitchToNewBasicBlock((BasicBlock*)Dest, SF);
    933 }
    934 
    935 
    936 // SwitchToNewBasicBlock - This method is used to jump to a new basic block.
    937 // This function handles the actual updating of block and instruction iterators
    938 // as well as execution of all of the PHI nodes in the destination block.
    939 //
    940 // This method does this because all of the PHI nodes must be executed
    941 // atomically, reading their inputs before any of the results are updated.  Not
    942 // doing this can cause problems if the PHI nodes depend on other PHI nodes for
    943 // their inputs.  If the input PHI node is updated before it is read, incorrect
    944 // results can happen.  Thus we use a two phase approach.
    945 //
    946 void Interpreter::SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF){
    947   BasicBlock *PrevBB = SF.CurBB;      // Remember where we came from...
    948   SF.CurBB   = Dest;                  // Update CurBB to branch destination
    949   SF.CurInst = SF.CurBB->begin();     // Update new instruction ptr...
    950 
    951   if (!isa<PHINode>(SF.CurInst)) return;  // Nothing fancy to do
    952 
    953   // Loop over all of the PHI nodes in the current block, reading their inputs.
    954   std::vector<GenericValue> ResultValues;
    955 
    956   for (; PHINode *PN = dyn_cast<PHINode>(SF.CurInst); ++SF.CurInst) {
    957     // Search for the value corresponding to this previous bb...
    958     int i = PN->getBasicBlockIndex(PrevBB);
    959     assert(i != -1 && "PHINode doesn't contain entry for predecessor??");
    960     Value *IncomingValue = PN->getIncomingValue(i);
    961 
    962     // Save the incoming value for this PHI node...
    963     ResultValues.push_back(getOperandValue(IncomingValue, SF));
    964   }
    965 
    966   // Now loop over all of the PHI nodes setting their values...
    967   SF.CurInst = SF.CurBB->begin();
    968   for (unsigned i = 0; isa<PHINode>(SF.CurInst); ++SF.CurInst, ++i) {
    969     PHINode *PN = cast<PHINode>(SF.CurInst);
    970     SetValue(PN, ResultValues[i], SF);
    971   }
    972 }
    973 
    974 //===----------------------------------------------------------------------===//
    975 //                     Memory Instruction Implementations
    976 //===----------------------------------------------------------------------===//
    977 
    978 void Interpreter::visitAllocaInst(AllocaInst &I) {
    979   ExecutionContext &SF = ECStack.back();
    980 
    981   Type *Ty = I.getType()->getElementType();  // Type to be allocated
    982 
    983   // Get the number of elements being allocated by the array...
    984   unsigned NumElements =
    985     getOperandValue(I.getOperand(0), SF).IntVal.getZExtValue();
    986 
    987   unsigned TypeSize = (size_t)TD.getTypeAllocSize(Ty);
    988 
    989   // Avoid malloc-ing zero bytes, use max()...
    990   unsigned MemToAlloc = std::max(1U, NumElements * TypeSize);
    991 
    992   // Allocate enough memory to hold the type...
    993   void *Memory = malloc(MemToAlloc);
    994 
    995   DEBUG(dbgs() << "Allocated Type: " << *Ty << " (" << TypeSize << " bytes) x "
    996                << NumElements << " (Total: " << MemToAlloc << ") at "
    997                << uintptr_t(Memory) << '\n');
    998 
    999   GenericValue Result = PTOGV(Memory);
   1000   assert(Result.PointerVal != 0 && "Null pointer returned by malloc!");
   1001   SetValue(&I, Result, SF);
   1002 
   1003   if (I.getOpcode() == Instruction::Alloca)
   1004     ECStack.back().Allocas.add(Memory);
   1005 }
   1006 
   1007 // getElementOffset - The workhorse for getelementptr.
   1008 //
   1009 GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
   1010                                               gep_type_iterator E,
   1011                                               ExecutionContext &SF) {
   1012   assert(Ptr->getType()->isPointerTy() &&
   1013          "Cannot getElementOffset of a nonpointer type!");
   1014 
   1015   uint64_t Total = 0;
   1016 
   1017   for (; I != E; ++I) {
   1018     if (StructType *STy = dyn_cast<StructType>(*I)) {
   1019       const StructLayout *SLO = TD.getStructLayout(STy);
   1020 
   1021       const ConstantInt *CPU = cast<ConstantInt>(I.getOperand());
   1022       unsigned Index = unsigned(CPU->getZExtValue());
   1023 
   1024       Total += SLO->getElementOffset(Index);
   1025     } else {
   1026       SequentialType *ST = cast<SequentialType>(*I);
   1027       // Get the index number for the array... which must be long type...
   1028       GenericValue IdxGV = getOperandValue(I.getOperand(), SF);
   1029 
   1030       int64_t Idx;
   1031       unsigned BitWidth =
   1032         cast<IntegerType>(I.getOperand()->getType())->getBitWidth();
   1033       if (BitWidth == 32)
   1034         Idx = (int64_t)(int32_t)IdxGV.IntVal.getZExtValue();
   1035       else {
   1036         assert(BitWidth == 64 && "Invalid index type for getelementptr");
   1037         Idx = (int64_t)IdxGV.IntVal.getZExtValue();
   1038       }
   1039       Total += TD.getTypeAllocSize(ST->getElementType())*Idx;
   1040     }
   1041   }
   1042 
   1043   GenericValue Result;
   1044   Result.PointerVal = ((char*)getOperandValue(Ptr, SF).PointerVal) + Total;
   1045   DEBUG(dbgs() << "GEP Index " << Total << " bytes.\n");
   1046   return Result;
   1047 }
   1048 
   1049 void Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) {
   1050   ExecutionContext &SF = ECStack.back();
   1051   SetValue(&I, executeGEPOperation(I.getPointerOperand(),
   1052                                    gep_type_begin(I), gep_type_end(I), SF), SF);
   1053 }
   1054 
   1055 void Interpreter::visitLoadInst(LoadInst &I) {
   1056   ExecutionContext &SF = ECStack.back();
   1057   GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
   1058   GenericValue *Ptr = (GenericValue*)GVTOP(SRC);
   1059   GenericValue Result;
   1060   LoadValueFromMemory(Result, Ptr, I.getType());
   1061   SetValue(&I, Result, SF);
   1062   if (I.isVolatile() && PrintVolatile)
   1063     dbgs() << "Volatile load " << I;
   1064 }
   1065 
   1066 void Interpreter::visitStoreInst(StoreInst &I) {
   1067   ExecutionContext &SF = ECStack.back();
   1068   GenericValue Val = getOperandValue(I.getOperand(0), SF);
   1069   GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
   1070   StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC),
   1071                      I.getOperand(0)->getType());
   1072   if (I.isVolatile() && PrintVolatile)
   1073     dbgs() << "Volatile store: " << I;
   1074 }
   1075 
   1076 //===----------------------------------------------------------------------===//
   1077 //                 Miscellaneous Instruction Implementations
   1078 //===----------------------------------------------------------------------===//
   1079 
   1080 void Interpreter::visitCallSite(CallSite CS) {
   1081   ExecutionContext &SF = ECStack.back();
   1082 
   1083   // Check to see if this is an intrinsic function call...
   1084   Function *F = CS.getCalledFunction();
   1085   if (F && F->isDeclaration())
   1086     switch (F->getIntrinsicID()) {
   1087     case Intrinsic::not_intrinsic:
   1088       break;
   1089     case Intrinsic::vastart: { // va_start
   1090       GenericValue ArgIndex;
   1091       ArgIndex.UIntPairVal.first = ECStack.size() - 1;
   1092       ArgIndex.UIntPairVal.second = 0;
   1093       SetValue(CS.getInstruction(), ArgIndex, SF);
   1094       return;
   1095     }
   1096     case Intrinsic::vaend:    // va_end is a noop for the interpreter
   1097       return;
   1098     case Intrinsic::vacopy:   // va_copy: dest = src
   1099       SetValue(CS.getInstruction(), getOperandValue(*CS.arg_begin(), SF), SF);
   1100       return;
   1101     default:
   1102       // If it is an unknown intrinsic function, use the intrinsic lowering
   1103       // class to transform it into hopefully tasty LLVM code.
   1104       //
   1105       BasicBlock::iterator me(CS.getInstruction());
   1106       BasicBlock *Parent = CS.getInstruction()->getParent();
   1107       bool atBegin(Parent->begin() == me);
   1108       if (!atBegin)
   1109         --me;
   1110       IL->LowerIntrinsicCall(cast<CallInst>(CS.getInstruction()));
   1111 
   1112       // Restore the CurInst pointer to the first instruction newly inserted, if
   1113       // any.
   1114       if (atBegin) {
   1115         SF.CurInst = Parent->begin();
   1116       } else {
   1117         SF.CurInst = me;
   1118         ++SF.CurInst;
   1119       }
   1120       return;
   1121     }
   1122 
   1123 
   1124   SF.Caller = CS;
   1125   std::vector<GenericValue> ArgVals;
   1126   const unsigned NumArgs = SF.Caller.arg_size();
   1127   ArgVals.reserve(NumArgs);
   1128   uint16_t pNum = 1;
   1129   for (CallSite::arg_iterator i = SF.Caller.arg_begin(),
   1130          e = SF.Caller.arg_end(); i != e; ++i, ++pNum) {
   1131     Value *V = *i;
   1132     ArgVals.push_back(getOperandValue(V, SF));
   1133   }
   1134 
   1135   // To handle indirect calls, we must get the pointer value from the argument
   1136   // and treat it as a function pointer.
   1137   GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF);
   1138   callFunction((Function*)GVTOP(SRC), ArgVals);
   1139 }
   1140 
   1141 // auxilary function for shift operations
   1142 static unsigned getShiftAmount(uint64_t orgShiftAmount,
   1143                                llvm::APInt valueToShift) {
   1144   unsigned valueWidth = valueToShift.getBitWidth();
   1145   if (orgShiftAmount < (uint64_t)valueWidth)
   1146     return orgShiftAmount;
   1147   // according to the llvm documentation, if orgShiftAmount > valueWidth,
   1148   // the result is undfeined. but we do shift by this rule:
   1149   return (NextPowerOf2(valueWidth-1) - 1) & orgShiftAmount;
   1150 }
   1151 
   1152 
   1153 void Interpreter::visitShl(BinaryOperator &I) {
   1154   ExecutionContext &SF = ECStack.back();
   1155   GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
   1156   GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
   1157   GenericValue Dest;
   1158   const Type *Ty = I.getType();
   1159 
   1160   if (Ty->isVectorTy()) {
   1161     uint32_t src1Size = uint32_t(Src1.AggregateVal.size());
   1162     assert(src1Size == Src2.AggregateVal.size());
   1163     for (unsigned i = 0; i < src1Size; i++) {
   1164       GenericValue Result;
   1165       uint64_t shiftAmount = Src2.AggregateVal[i].IntVal.getZExtValue();
   1166       llvm::APInt valueToShift = Src1.AggregateVal[i].IntVal;
   1167       Result.IntVal = valueToShift.shl(getShiftAmount(shiftAmount, valueToShift));
   1168       Dest.AggregateVal.push_back(Result);
   1169     }
   1170   } else {
   1171     // scalar
   1172     uint64_t shiftAmount = Src2.IntVal.getZExtValue();
   1173     llvm::APInt valueToShift = Src1.IntVal;
   1174     Dest.IntVal = valueToShift.shl(getShiftAmount(shiftAmount, valueToShift));
   1175   }
   1176 
   1177   SetValue(&I, Dest, SF);
   1178 }
   1179 
   1180 void Interpreter::visitLShr(BinaryOperator &I) {
   1181   ExecutionContext &SF = ECStack.back();
   1182   GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
   1183   GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
   1184   GenericValue Dest;
   1185   const Type *Ty = I.getType();
   1186 
   1187   if (Ty->isVectorTy()) {
   1188     uint32_t src1Size = uint32_t(Src1.AggregateVal.size());
   1189     assert(src1Size == Src2.AggregateVal.size());
   1190     for (unsigned i = 0; i < src1Size; i++) {
   1191       GenericValue Result;
   1192       uint64_t shiftAmount = Src2.AggregateVal[i].IntVal.getZExtValue();
   1193       llvm::APInt valueToShift = Src1.AggregateVal[i].IntVal;
   1194       Result.IntVal = valueToShift.lshr(getShiftAmount(shiftAmount, valueToShift));
   1195       Dest.AggregateVal.push_back(Result);
   1196     }
   1197   } else {
   1198     // scalar
   1199     uint64_t shiftAmount = Src2.IntVal.getZExtValue();
   1200     llvm::APInt valueToShift = Src1.IntVal;
   1201     Dest.IntVal = valueToShift.lshr(getShiftAmount(shiftAmount, valueToShift));
   1202   }
   1203 
   1204   SetValue(&I, Dest, SF);
   1205 }
   1206 
   1207 void Interpreter::visitAShr(BinaryOperator &I) {
   1208   ExecutionContext &SF = ECStack.back();
   1209   GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
   1210   GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
   1211   GenericValue Dest;
   1212   const Type *Ty = I.getType();
   1213 
   1214   if (Ty->isVectorTy()) {
   1215     size_t src1Size = Src1.AggregateVal.size();
   1216     assert(src1Size == Src2.AggregateVal.size());
   1217     for (unsigned i = 0; i < src1Size; i++) {
   1218       GenericValue Result;
   1219       uint64_t shiftAmount = Src2.AggregateVal[i].IntVal.getZExtValue();
   1220       llvm::APInt valueToShift = Src1.AggregateVal[i].IntVal;
   1221       Result.IntVal = valueToShift.ashr(getShiftAmount(shiftAmount, valueToShift));
   1222       Dest.AggregateVal.push_back(Result);
   1223     }
   1224   } else {
   1225     // scalar
   1226     uint64_t shiftAmount = Src2.IntVal.getZExtValue();
   1227     llvm::APInt valueToShift = Src1.IntVal;
   1228     Dest.IntVal = valueToShift.ashr(getShiftAmount(shiftAmount, valueToShift));
   1229   }
   1230 
   1231   SetValue(&I, Dest, SF);
   1232 }
   1233 
   1234 GenericValue Interpreter::executeTruncInst(Value *SrcVal, Type *DstTy,
   1235                                            ExecutionContext &SF) {
   1236   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1237   Type *SrcTy = SrcVal->getType();
   1238   if (SrcTy->isVectorTy()) {
   1239     Type *DstVecTy = DstTy->getScalarType();
   1240     unsigned DBitWidth = cast<IntegerType>(DstVecTy)->getBitWidth();
   1241     unsigned NumElts = Src.AggregateVal.size();
   1242     // the sizes of src and dst vectors must be equal
   1243     Dest.AggregateVal.resize(NumElts);
   1244     for (unsigned i = 0; i < NumElts; i++)
   1245       Dest.AggregateVal[i].IntVal = Src.AggregateVal[i].IntVal.trunc(DBitWidth);
   1246   } else {
   1247     IntegerType *DITy = cast<IntegerType>(DstTy);
   1248     unsigned DBitWidth = DITy->getBitWidth();
   1249     Dest.IntVal = Src.IntVal.trunc(DBitWidth);
   1250   }
   1251   return Dest;
   1252 }
   1253 
   1254 GenericValue Interpreter::executeSExtInst(Value *SrcVal, Type *DstTy,
   1255                                           ExecutionContext &SF) {
   1256   const Type *SrcTy = SrcVal->getType();
   1257   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1258   if (SrcTy->isVectorTy()) {
   1259     const Type *DstVecTy = DstTy->getScalarType();
   1260     unsigned DBitWidth = cast<IntegerType>(DstVecTy)->getBitWidth();
   1261     unsigned size = Src.AggregateVal.size();
   1262     // the sizes of src and dst vectors must be equal.
   1263     Dest.AggregateVal.resize(size);
   1264     for (unsigned i = 0; i < size; i++)
   1265       Dest.AggregateVal[i].IntVal = Src.AggregateVal[i].IntVal.sext(DBitWidth);
   1266   } else {
   1267     const IntegerType *DITy = cast<IntegerType>(DstTy);
   1268     unsigned DBitWidth = DITy->getBitWidth();
   1269     Dest.IntVal = Src.IntVal.sext(DBitWidth);
   1270   }
   1271   return Dest;
   1272 }
   1273 
   1274 GenericValue Interpreter::executeZExtInst(Value *SrcVal, Type *DstTy,
   1275                                           ExecutionContext &SF) {
   1276   const Type *SrcTy = SrcVal->getType();
   1277   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1278   if (SrcTy->isVectorTy()) {
   1279     const Type *DstVecTy = DstTy->getScalarType();
   1280     unsigned DBitWidth = cast<IntegerType>(DstVecTy)->getBitWidth();
   1281 
   1282     unsigned size = Src.AggregateVal.size();
   1283     // the sizes of src and dst vectors must be equal.
   1284     Dest.AggregateVal.resize(size);
   1285     for (unsigned i = 0; i < size; i++)
   1286       Dest.AggregateVal[i].IntVal = Src.AggregateVal[i].IntVal.zext(DBitWidth);
   1287   } else {
   1288     const IntegerType *DITy = cast<IntegerType>(DstTy);
   1289     unsigned DBitWidth = DITy->getBitWidth();
   1290     Dest.IntVal = Src.IntVal.zext(DBitWidth);
   1291   }
   1292   return Dest;
   1293 }
   1294 
   1295 GenericValue Interpreter::executeFPTruncInst(Value *SrcVal, Type *DstTy,
   1296                                              ExecutionContext &SF) {
   1297   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1298 
   1299   if (SrcVal->getType()->getTypeID() == Type::VectorTyID) {
   1300     assert(SrcVal->getType()->getScalarType()->isDoubleTy() &&
   1301            DstTy->getScalarType()->isFloatTy() &&
   1302            "Invalid FPTrunc instruction");
   1303 
   1304     unsigned size = Src.AggregateVal.size();
   1305     // the sizes of src and dst vectors must be equal.
   1306     Dest.AggregateVal.resize(size);
   1307     for (unsigned i = 0; i < size; i++)
   1308       Dest.AggregateVal[i].FloatVal = (float)Src.AggregateVal[i].DoubleVal;
   1309   } else {
   1310     assert(SrcVal->getType()->isDoubleTy() && DstTy->isFloatTy() &&
   1311            "Invalid FPTrunc instruction");
   1312     Dest.FloatVal = (float)Src.DoubleVal;
   1313   }
   1314 
   1315   return Dest;
   1316 }
   1317 
   1318 GenericValue Interpreter::executeFPExtInst(Value *SrcVal, Type *DstTy,
   1319                                            ExecutionContext &SF) {
   1320   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1321 
   1322   if (SrcVal->getType()->getTypeID() == Type::VectorTyID) {
   1323     assert(SrcVal->getType()->getScalarType()->isFloatTy() &&
   1324            DstTy->getScalarType()->isDoubleTy() && "Invalid FPExt instruction");
   1325 
   1326     unsigned size = Src.AggregateVal.size();
   1327     // the sizes of src and dst vectors must be equal.
   1328     Dest.AggregateVal.resize(size);
   1329     for (unsigned i = 0; i < size; i++)
   1330       Dest.AggregateVal[i].DoubleVal = (double)Src.AggregateVal[i].FloatVal;
   1331   } else {
   1332     assert(SrcVal->getType()->isFloatTy() && DstTy->isDoubleTy() &&
   1333            "Invalid FPExt instruction");
   1334     Dest.DoubleVal = (double)Src.FloatVal;
   1335   }
   1336 
   1337   return Dest;
   1338 }
   1339 
   1340 GenericValue Interpreter::executeFPToUIInst(Value *SrcVal, Type *DstTy,
   1341                                             ExecutionContext &SF) {
   1342   Type *SrcTy = SrcVal->getType();
   1343   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1344 
   1345   if (SrcTy->getTypeID() == Type::VectorTyID) {
   1346     const Type *DstVecTy = DstTy->getScalarType();
   1347     const Type *SrcVecTy = SrcTy->getScalarType();
   1348     uint32_t DBitWidth = cast<IntegerType>(DstVecTy)->getBitWidth();
   1349     unsigned size = Src.AggregateVal.size();
   1350     // the sizes of src and dst vectors must be equal.
   1351     Dest.AggregateVal.resize(size);
   1352 
   1353     if (SrcVecTy->getTypeID() == Type::FloatTyID) {
   1354       assert(SrcVecTy->isFloatingPointTy() && "Invalid FPToUI instruction");
   1355       for (unsigned i = 0; i < size; i++)
   1356         Dest.AggregateVal[i].IntVal = APIntOps::RoundFloatToAPInt(
   1357             Src.AggregateVal[i].FloatVal, DBitWidth);
   1358     } else {
   1359       for (unsigned i = 0; i < size; i++)
   1360         Dest.AggregateVal[i].IntVal = APIntOps::RoundDoubleToAPInt(
   1361             Src.AggregateVal[i].DoubleVal, DBitWidth);
   1362     }
   1363   } else {
   1364     // scalar
   1365     uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth();
   1366     assert(SrcTy->isFloatingPointTy() && "Invalid FPToUI instruction");
   1367 
   1368     if (SrcTy->getTypeID() == Type::FloatTyID)
   1369       Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth);
   1370     else {
   1371       Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth);
   1372     }
   1373   }
   1374 
   1375   return Dest;
   1376 }
   1377 
   1378 GenericValue Interpreter::executeFPToSIInst(Value *SrcVal, Type *DstTy,
   1379                                             ExecutionContext &SF) {
   1380   Type *SrcTy = SrcVal->getType();
   1381   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1382 
   1383   if (SrcTy->getTypeID() == Type::VectorTyID) {
   1384     const Type *DstVecTy = DstTy->getScalarType();
   1385     const Type *SrcVecTy = SrcTy->getScalarType();
   1386     uint32_t DBitWidth = cast<IntegerType>(DstVecTy)->getBitWidth();
   1387     unsigned size = Src.AggregateVal.size();
   1388     // the sizes of src and dst vectors must be equal
   1389     Dest.AggregateVal.resize(size);
   1390 
   1391     if (SrcVecTy->getTypeID() == Type::FloatTyID) {
   1392       assert(SrcVecTy->isFloatingPointTy() && "Invalid FPToSI instruction");
   1393       for (unsigned i = 0; i < size; i++)
   1394         Dest.AggregateVal[i].IntVal = APIntOps::RoundFloatToAPInt(
   1395             Src.AggregateVal[i].FloatVal, DBitWidth);
   1396     } else {
   1397       for (unsigned i = 0; i < size; i++)
   1398         Dest.AggregateVal[i].IntVal = APIntOps::RoundDoubleToAPInt(
   1399             Src.AggregateVal[i].DoubleVal, DBitWidth);
   1400     }
   1401   } else {
   1402     // scalar
   1403     unsigned DBitWidth = cast<IntegerType>(DstTy)->getBitWidth();
   1404     assert(SrcTy->isFloatingPointTy() && "Invalid FPToSI instruction");
   1405 
   1406     if (SrcTy->getTypeID() == Type::FloatTyID)
   1407       Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth);
   1408     else {
   1409       Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth);
   1410     }
   1411   }
   1412   return Dest;
   1413 }
   1414 
   1415 GenericValue Interpreter::executeUIToFPInst(Value *SrcVal, Type *DstTy,
   1416                                             ExecutionContext &SF) {
   1417   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1418 
   1419   if (SrcVal->getType()->getTypeID() == Type::VectorTyID) {
   1420     const Type *DstVecTy = DstTy->getScalarType();
   1421     unsigned size = Src.AggregateVal.size();
   1422     // the sizes of src and dst vectors must be equal
   1423     Dest.AggregateVal.resize(size);
   1424 
   1425     if (DstVecTy->getTypeID() == Type::FloatTyID) {
   1426       assert(DstVecTy->isFloatingPointTy() && "Invalid UIToFP instruction");
   1427       for (unsigned i = 0; i < size; i++)
   1428         Dest.AggregateVal[i].FloatVal =
   1429             APIntOps::RoundAPIntToFloat(Src.AggregateVal[i].IntVal);
   1430     } else {
   1431       for (unsigned i = 0; i < size; i++)
   1432         Dest.AggregateVal[i].DoubleVal =
   1433             APIntOps::RoundAPIntToDouble(Src.AggregateVal[i].IntVal);
   1434     }
   1435   } else {
   1436     // scalar
   1437     assert(DstTy->isFloatingPointTy() && "Invalid UIToFP instruction");
   1438     if (DstTy->getTypeID() == Type::FloatTyID)
   1439       Dest.FloatVal = APIntOps::RoundAPIntToFloat(Src.IntVal);
   1440     else {
   1441       Dest.DoubleVal = APIntOps::RoundAPIntToDouble(Src.IntVal);
   1442     }
   1443   }
   1444   return Dest;
   1445 }
   1446 
   1447 GenericValue Interpreter::executeSIToFPInst(Value *SrcVal, Type *DstTy,
   1448                                             ExecutionContext &SF) {
   1449   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1450 
   1451   if (SrcVal->getType()->getTypeID() == Type::VectorTyID) {
   1452     const Type *DstVecTy = DstTy->getScalarType();
   1453     unsigned size = Src.AggregateVal.size();
   1454     // the sizes of src and dst vectors must be equal
   1455     Dest.AggregateVal.resize(size);
   1456 
   1457     if (DstVecTy->getTypeID() == Type::FloatTyID) {
   1458       assert(DstVecTy->isFloatingPointTy() && "Invalid SIToFP instruction");
   1459       for (unsigned i = 0; i < size; i++)
   1460         Dest.AggregateVal[i].FloatVal =
   1461             APIntOps::RoundSignedAPIntToFloat(Src.AggregateVal[i].IntVal);
   1462     } else {
   1463       for (unsigned i = 0; i < size; i++)
   1464         Dest.AggregateVal[i].DoubleVal =
   1465             APIntOps::RoundSignedAPIntToDouble(Src.AggregateVal[i].IntVal);
   1466     }
   1467   } else {
   1468     // scalar
   1469     assert(DstTy->isFloatingPointTy() && "Invalid SIToFP instruction");
   1470 
   1471     if (DstTy->getTypeID() == Type::FloatTyID)
   1472       Dest.FloatVal = APIntOps::RoundSignedAPIntToFloat(Src.IntVal);
   1473     else {
   1474       Dest.DoubleVal = APIntOps::RoundSignedAPIntToDouble(Src.IntVal);
   1475     }
   1476   }
   1477 
   1478   return Dest;
   1479 }
   1480 
   1481 GenericValue Interpreter::executePtrToIntInst(Value *SrcVal, Type *DstTy,
   1482                                               ExecutionContext &SF) {
   1483   uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth();
   1484   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1485   assert(SrcVal->getType()->isPointerTy() && "Invalid PtrToInt instruction");
   1486 
   1487   Dest.IntVal = APInt(DBitWidth, (intptr_t) Src.PointerVal);
   1488   return Dest;
   1489 }
   1490 
   1491 GenericValue Interpreter::executeIntToPtrInst(Value *SrcVal, Type *DstTy,
   1492                                               ExecutionContext &SF) {
   1493   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1494   assert(DstTy->isPointerTy() && "Invalid PtrToInt instruction");
   1495 
   1496   uint32_t PtrSize = TD.getPointerSizeInBits();
   1497   if (PtrSize != Src.IntVal.getBitWidth())
   1498     Src.IntVal = Src.IntVal.zextOrTrunc(PtrSize);
   1499 
   1500   Dest.PointerVal = PointerTy(intptr_t(Src.IntVal.getZExtValue()));
   1501   return Dest;
   1502 }
   1503 
   1504 GenericValue Interpreter::executeBitCastInst(Value *SrcVal, Type *DstTy,
   1505                                              ExecutionContext &SF) {
   1506 
   1507   // This instruction supports bitwise conversion of vectors to integers and
   1508   // to vectors of other types (as long as they have the same size)
   1509   Type *SrcTy = SrcVal->getType();
   1510   GenericValue Dest, Src = getOperandValue(SrcVal, SF);
   1511 
   1512   if ((SrcTy->getTypeID() == Type::VectorTyID) ||
   1513       (DstTy->getTypeID() == Type::VectorTyID)) {
   1514     // vector src bitcast to vector dst or vector src bitcast to scalar dst or
   1515     // scalar src bitcast to vector dst
   1516     bool isLittleEndian = TD.isLittleEndian();
   1517     GenericValue TempDst, TempSrc, SrcVec;
   1518     const Type *SrcElemTy;
   1519     const Type *DstElemTy;
   1520     unsigned SrcBitSize;
   1521     unsigned DstBitSize;
   1522     unsigned SrcNum;
   1523     unsigned DstNum;
   1524 
   1525     if (SrcTy->getTypeID() == Type::VectorTyID) {
   1526       SrcElemTy = SrcTy->getScalarType();
   1527       SrcBitSize = SrcTy->getScalarSizeInBits();
   1528       SrcNum = Src.AggregateVal.size();
   1529       SrcVec = Src;
   1530     } else {
   1531       // if src is scalar value, make it vector <1 x type>
   1532       SrcElemTy = SrcTy;
   1533       SrcBitSize = SrcTy->getPrimitiveSizeInBits();
   1534       SrcNum = 1;
   1535       SrcVec.AggregateVal.push_back(Src);
   1536     }
   1537 
   1538     if (DstTy->getTypeID() == Type::VectorTyID) {
   1539       DstElemTy = DstTy->getScalarType();
   1540       DstBitSize = DstTy->getScalarSizeInBits();
   1541       DstNum = (SrcNum * SrcBitSize) / DstBitSize;
   1542     } else {
   1543       DstElemTy = DstTy;
   1544       DstBitSize = DstTy->getPrimitiveSizeInBits();
   1545       DstNum = 1;
   1546     }
   1547 
   1548     if (SrcNum * SrcBitSize != DstNum * DstBitSize)
   1549       llvm_unreachable("Invalid BitCast");
   1550 
   1551     // If src is floating point, cast to integer first.
   1552     TempSrc.AggregateVal.resize(SrcNum);
   1553     if (SrcElemTy->isFloatTy()) {
   1554       for (unsigned i = 0; i < SrcNum; i++)
   1555         TempSrc.AggregateVal[i].IntVal =
   1556             APInt::floatToBits(SrcVec.AggregateVal[i].FloatVal);
   1557 
   1558     } else if (SrcElemTy->isDoubleTy()) {
   1559       for (unsigned i = 0; i < SrcNum; i++)
   1560         TempSrc.AggregateVal[i].IntVal =
   1561             APInt::doubleToBits(SrcVec.AggregateVal[i].DoubleVal);
   1562     } else if (SrcElemTy->isIntegerTy()) {
   1563       for (unsigned i = 0; i < SrcNum; i++)
   1564         TempSrc.AggregateVal[i].IntVal = SrcVec.AggregateVal[i].IntVal;
   1565     } else {
   1566       // Pointers are not allowed as the element type of vector.
   1567       llvm_unreachable("Invalid Bitcast");
   1568     }
   1569 
   1570     // now TempSrc is integer type vector
   1571     if (DstNum < SrcNum) {
   1572       // Example: bitcast <4 x i32> <i32 0, i32 1, i32 2, i32 3> to <2 x i64>
   1573       unsigned Ratio = SrcNum / DstNum;
   1574       unsigned SrcElt = 0;
   1575       for (unsigned i = 0; i < DstNum; i++) {
   1576         GenericValue Elt;
   1577         Elt.IntVal = 0;
   1578         Elt.IntVal = Elt.IntVal.zext(DstBitSize);
   1579         unsigned ShiftAmt = isLittleEndian ? 0 : SrcBitSize * (Ratio - 1);
   1580         for (unsigned j = 0; j < Ratio; j++) {
   1581           APInt Tmp;
   1582           Tmp = Tmp.zext(SrcBitSize);
   1583           Tmp = TempSrc.AggregateVal[SrcElt++].IntVal;
   1584           Tmp = Tmp.zext(DstBitSize);
   1585           Tmp = Tmp.shl(ShiftAmt);
   1586           ShiftAmt += isLittleEndian ? SrcBitSize : -SrcBitSize;
   1587           Elt.IntVal |= Tmp;
   1588         }
   1589         TempDst.AggregateVal.push_back(Elt);
   1590       }
   1591     } else {
   1592       // Example: bitcast <2 x i64> <i64 0, i64 1> to <4 x i32>
   1593       unsigned Ratio = DstNum / SrcNum;
   1594       for (unsigned i = 0; i < SrcNum; i++) {
   1595         unsigned ShiftAmt = isLittleEndian ? 0 : DstBitSize * (Ratio - 1);
   1596         for (unsigned j = 0; j < Ratio; j++) {
   1597           GenericValue Elt;
   1598           Elt.IntVal = Elt.IntVal.zext(SrcBitSize);
   1599           Elt.IntVal = TempSrc.AggregateVal[i].IntVal;
   1600           Elt.IntVal = Elt.IntVal.lshr(ShiftAmt);
   1601           // it could be DstBitSize == SrcBitSize, so check it
   1602           if (DstBitSize < SrcBitSize)
   1603             Elt.IntVal = Elt.IntVal.trunc(DstBitSize);
   1604           ShiftAmt += isLittleEndian ? DstBitSize : -DstBitSize;
   1605           TempDst.AggregateVal.push_back(Elt);
   1606         }
   1607       }
   1608     }
   1609 
   1610     // convert result from integer to specified type
   1611     if (DstTy->getTypeID() == Type::VectorTyID) {
   1612       if (DstElemTy->isDoubleTy()) {
   1613         Dest.AggregateVal.resize(DstNum);
   1614         for (unsigned i = 0; i < DstNum; i++)
   1615           Dest.AggregateVal[i].DoubleVal =
   1616               TempDst.AggregateVal[i].IntVal.bitsToDouble();
   1617       } else if (DstElemTy->isFloatTy()) {
   1618         Dest.AggregateVal.resize(DstNum);
   1619         for (unsigned i = 0; i < DstNum; i++)
   1620           Dest.AggregateVal[i].FloatVal =
   1621               TempDst.AggregateVal[i].IntVal.bitsToFloat();
   1622       } else {
   1623         Dest = TempDst;
   1624       }
   1625     } else {
   1626       if (DstElemTy->isDoubleTy())
   1627         Dest.DoubleVal = TempDst.AggregateVal[0].IntVal.bitsToDouble();
   1628       else if (DstElemTy->isFloatTy()) {
   1629         Dest.FloatVal = TempDst.AggregateVal[0].IntVal.bitsToFloat();
   1630       } else {
   1631         Dest.IntVal = TempDst.AggregateVal[0].IntVal;
   1632       }
   1633     }
   1634   } else { //  if ((SrcTy->getTypeID() == Type::VectorTyID) ||
   1635            //     (DstTy->getTypeID() == Type::VectorTyID))
   1636 
   1637     // scalar src bitcast to scalar dst
   1638     if (DstTy->isPointerTy()) {
   1639       assert(SrcTy->isPointerTy() && "Invalid BitCast");
   1640       Dest.PointerVal = Src.PointerVal;
   1641     } else if (DstTy->isIntegerTy()) {
   1642       if (SrcTy->isFloatTy())
   1643         Dest.IntVal = APInt::floatToBits(Src.FloatVal);
   1644       else if (SrcTy->isDoubleTy()) {
   1645         Dest.IntVal = APInt::doubleToBits(Src.DoubleVal);
   1646       } else if (SrcTy->isIntegerTy()) {
   1647         Dest.IntVal = Src.IntVal;
   1648       } else {
   1649         llvm_unreachable("Invalid BitCast");
   1650       }
   1651     } else if (DstTy->isFloatTy()) {
   1652       if (SrcTy->isIntegerTy())
   1653         Dest.FloatVal = Src.IntVal.bitsToFloat();
   1654       else {
   1655         Dest.FloatVal = Src.FloatVal;
   1656       }
   1657     } else if (DstTy->isDoubleTy()) {
   1658       if (SrcTy->isIntegerTy())
   1659         Dest.DoubleVal = Src.IntVal.bitsToDouble();
   1660       else {
   1661         Dest.DoubleVal = Src.DoubleVal;
   1662       }
   1663     } else {
   1664       llvm_unreachable("Invalid Bitcast");
   1665     }
   1666   }
   1667 
   1668   return Dest;
   1669 }
   1670 
   1671 void Interpreter::visitTruncInst(TruncInst &I) {
   1672   ExecutionContext &SF = ECStack.back();
   1673   SetValue(&I, executeTruncInst(I.getOperand(0), I.getType(), SF), SF);
   1674 }
   1675 
   1676 void Interpreter::visitSExtInst(SExtInst &I) {
   1677   ExecutionContext &SF = ECStack.back();
   1678   SetValue(&I, executeSExtInst(I.getOperand(0), I.getType(), SF), SF);
   1679 }
   1680 
   1681 void Interpreter::visitZExtInst(ZExtInst &I) {
   1682   ExecutionContext &SF = ECStack.back();
   1683   SetValue(&I, executeZExtInst(I.getOperand(0), I.getType(), SF), SF);
   1684 }
   1685 
   1686 void Interpreter::visitFPTruncInst(FPTruncInst &I) {
   1687   ExecutionContext &SF = ECStack.back();
   1688   SetValue(&I, executeFPTruncInst(I.getOperand(0), I.getType(), SF), SF);
   1689 }
   1690 
   1691 void Interpreter::visitFPExtInst(FPExtInst &I) {
   1692   ExecutionContext &SF = ECStack.back();
   1693   SetValue(&I, executeFPExtInst(I.getOperand(0), I.getType(), SF), SF);
   1694 }
   1695 
   1696 void Interpreter::visitUIToFPInst(UIToFPInst &I) {
   1697   ExecutionContext &SF = ECStack.back();
   1698   SetValue(&I, executeUIToFPInst(I.getOperand(0), I.getType(), SF), SF);
   1699 }
   1700 
   1701 void Interpreter::visitSIToFPInst(SIToFPInst &I) {
   1702   ExecutionContext &SF = ECStack.back();
   1703   SetValue(&I, executeSIToFPInst(I.getOperand(0), I.getType(), SF), SF);
   1704 }
   1705 
   1706 void Interpreter::visitFPToUIInst(FPToUIInst &I) {
   1707   ExecutionContext &SF = ECStack.back();
   1708   SetValue(&I, executeFPToUIInst(I.getOperand(0), I.getType(), SF), SF);
   1709 }
   1710 
   1711 void Interpreter::visitFPToSIInst(FPToSIInst &I) {
   1712   ExecutionContext &SF = ECStack.back();
   1713   SetValue(&I, executeFPToSIInst(I.getOperand(0), I.getType(), SF), SF);
   1714 }
   1715 
   1716 void Interpreter::visitPtrToIntInst(PtrToIntInst &I) {
   1717   ExecutionContext &SF = ECStack.back();
   1718   SetValue(&I, executePtrToIntInst(I.getOperand(0), I.getType(), SF), SF);
   1719 }
   1720 
   1721 void Interpreter::visitIntToPtrInst(IntToPtrInst &I) {
   1722   ExecutionContext &SF = ECStack.back();
   1723   SetValue(&I, executeIntToPtrInst(I.getOperand(0), I.getType(), SF), SF);
   1724 }
   1725 
   1726 void Interpreter::visitBitCastInst(BitCastInst &I) {
   1727   ExecutionContext &SF = ECStack.back();
   1728   SetValue(&I, executeBitCastInst(I.getOperand(0), I.getType(), SF), SF);
   1729 }
   1730 
   1731 #define IMPLEMENT_VAARG(TY) \
   1732    case Type::TY##TyID: Dest.TY##Val = Src.TY##Val; break
   1733 
   1734 void Interpreter::visitVAArgInst(VAArgInst &I) {
   1735   ExecutionContext &SF = ECStack.back();
   1736 
   1737   // Get the incoming valist parameter.  LLI treats the valist as a
   1738   // (ec-stack-depth var-arg-index) pair.
   1739   GenericValue VAList = getOperandValue(I.getOperand(0), SF);
   1740   GenericValue Dest;
   1741   GenericValue Src = ECStack[VAList.UIntPairVal.first]
   1742                       .VarArgs[VAList.UIntPairVal.second];
   1743   Type *Ty = I.getType();
   1744   switch (Ty->getTypeID()) {
   1745   case Type::IntegerTyID:
   1746     Dest.IntVal = Src.IntVal;
   1747     break;
   1748   IMPLEMENT_VAARG(Pointer);
   1749   IMPLEMENT_VAARG(Float);
   1750   IMPLEMENT_VAARG(Double);
   1751   default:
   1752     dbgs() << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
   1753     llvm_unreachable(0);
   1754   }
   1755 
   1756   // Set the Value of this Instruction.
   1757   SetValue(&I, Dest, SF);
   1758 
   1759   // Move the pointer to the next vararg.
   1760   ++VAList.UIntPairVal.second;
   1761 }
   1762 
   1763 void Interpreter::visitExtractElementInst(ExtractElementInst &I) {
   1764   ExecutionContext &SF = ECStack.back();
   1765   GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
   1766   GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
   1767   GenericValue Dest;
   1768 
   1769   Type *Ty = I.getType();
   1770   const unsigned indx = unsigned(Src2.IntVal.getZExtValue());
   1771 
   1772   if(Src1.AggregateVal.size() > indx) {
   1773     switch (Ty->getTypeID()) {
   1774     default:
   1775       dbgs() << "Unhandled destination type for extractelement instruction: "
   1776       << *Ty << "\n";
   1777       llvm_unreachable(0);
   1778       break;
   1779     case Type::IntegerTyID:
   1780       Dest.IntVal = Src1.AggregateVal[indx].IntVal;
   1781       break;
   1782     case Type::FloatTyID:
   1783       Dest.FloatVal = Src1.AggregateVal[indx].FloatVal;
   1784       break;
   1785     case Type::DoubleTyID:
   1786       Dest.DoubleVal = Src1.AggregateVal[indx].DoubleVal;
   1787       break;
   1788     }
   1789   } else {
   1790     dbgs() << "Invalid index in extractelement instruction\n";
   1791   }
   1792 
   1793   SetValue(&I, Dest, SF);
   1794 }
   1795 
   1796 GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE,
   1797                                                 ExecutionContext &SF) {
   1798   switch (CE->getOpcode()) {
   1799   case Instruction::Trunc:
   1800       return executeTruncInst(CE->getOperand(0), CE->getType(), SF);
   1801   case Instruction::ZExt:
   1802       return executeZExtInst(CE->getOperand(0), CE->getType(), SF);
   1803   case Instruction::SExt:
   1804       return executeSExtInst(CE->getOperand(0), CE->getType(), SF);
   1805   case Instruction::FPTrunc:
   1806       return executeFPTruncInst(CE->getOperand(0), CE->getType(), SF);
   1807   case Instruction::FPExt:
   1808       return executeFPExtInst(CE->getOperand(0), CE->getType(), SF);
   1809   case Instruction::UIToFP:
   1810       return executeUIToFPInst(CE->getOperand(0), CE->getType(), SF);
   1811   case Instruction::SIToFP:
   1812       return executeSIToFPInst(CE->getOperand(0), CE->getType(), SF);
   1813   case Instruction::FPToUI:
   1814       return executeFPToUIInst(CE->getOperand(0), CE->getType(), SF);
   1815   case Instruction::FPToSI:
   1816       return executeFPToSIInst(CE->getOperand(0), CE->getType(), SF);
   1817   case Instruction::PtrToInt:
   1818       return executePtrToIntInst(CE->getOperand(0), CE->getType(), SF);
   1819   case Instruction::IntToPtr:
   1820       return executeIntToPtrInst(CE->getOperand(0), CE->getType(), SF);
   1821   case Instruction::BitCast:
   1822       return executeBitCastInst(CE->getOperand(0), CE->getType(), SF);
   1823   case Instruction::GetElementPtr:
   1824     return executeGEPOperation(CE->getOperand(0), gep_type_begin(CE),
   1825                                gep_type_end(CE), SF);
   1826   case Instruction::FCmp:
   1827   case Instruction::ICmp:
   1828     return executeCmpInst(CE->getPredicate(),
   1829                           getOperandValue(CE->getOperand(0), SF),
   1830                           getOperandValue(CE->getOperand(1), SF),
   1831                           CE->getOperand(0)->getType());
   1832   case Instruction::Select:
   1833     return executeSelectInst(getOperandValue(CE->getOperand(0), SF),
   1834                              getOperandValue(CE->getOperand(1), SF),
   1835                              getOperandValue(CE->getOperand(2), SF));
   1836   default :
   1837     break;
   1838   }
   1839 
   1840   // The cases below here require a GenericValue parameter for the result
   1841   // so we initialize one, compute it and then return it.
   1842   GenericValue Op0 = getOperandValue(CE->getOperand(0), SF);
   1843   GenericValue Op1 = getOperandValue(CE->getOperand(1), SF);
   1844   GenericValue Dest;
   1845   Type * Ty = CE->getOperand(0)->getType();
   1846   switch (CE->getOpcode()) {
   1847   case Instruction::Add:  Dest.IntVal = Op0.IntVal + Op1.IntVal; break;
   1848   case Instruction::Sub:  Dest.IntVal = Op0.IntVal - Op1.IntVal; break;
   1849   case Instruction::Mul:  Dest.IntVal = Op0.IntVal * Op1.IntVal; break;
   1850   case Instruction::FAdd: executeFAddInst(Dest, Op0, Op1, Ty); break;
   1851   case Instruction::FSub: executeFSubInst(Dest, Op0, Op1, Ty); break;
   1852   case Instruction::FMul: executeFMulInst(Dest, Op0, Op1, Ty); break;
   1853   case Instruction::FDiv: executeFDivInst(Dest, Op0, Op1, Ty); break;
   1854   case Instruction::FRem: executeFRemInst(Dest, Op0, Op1, Ty); break;
   1855   case Instruction::SDiv: Dest.IntVal = Op0.IntVal.sdiv(Op1.IntVal); break;
   1856   case Instruction::UDiv: Dest.IntVal = Op0.IntVal.udiv(Op1.IntVal); break;
   1857   case Instruction::URem: Dest.IntVal = Op0.IntVal.urem(Op1.IntVal); break;
   1858   case Instruction::SRem: Dest.IntVal = Op0.IntVal.srem(Op1.IntVal); break;
   1859   case Instruction::And:  Dest.IntVal = Op0.IntVal & Op1.IntVal; break;
   1860   case Instruction::Or:   Dest.IntVal = Op0.IntVal | Op1.IntVal; break;
   1861   case Instruction::Xor:  Dest.IntVal = Op0.IntVal ^ Op1.IntVal; break;
   1862   case Instruction::Shl:
   1863     Dest.IntVal = Op0.IntVal.shl(Op1.IntVal.getZExtValue());
   1864     break;
   1865   case Instruction::LShr:
   1866     Dest.IntVal = Op0.IntVal.lshr(Op1.IntVal.getZExtValue());
   1867     break;
   1868   case Instruction::AShr:
   1869     Dest.IntVal = Op0.IntVal.ashr(Op1.IntVal.getZExtValue());
   1870     break;
   1871   default:
   1872     dbgs() << "Unhandled ConstantExpr: " << *CE << "\n";
   1873     llvm_unreachable("Unhandled ConstantExpr");
   1874   }
   1875   return Dest;
   1876 }
   1877 
   1878 GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) {
   1879   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
   1880     return getConstantExprValue(CE, SF);
   1881   } else if (Constant *CPV = dyn_cast<Constant>(V)) {
   1882     return getConstantValue(CPV);
   1883   } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
   1884     return PTOGV(getPointerToGlobal(GV));
   1885   } else {
   1886     return SF.Values[V];
   1887   }
   1888 }
   1889 
   1890 //===----------------------------------------------------------------------===//
   1891 //                        Dispatch and Execution Code
   1892 //===----------------------------------------------------------------------===//
   1893 
   1894 //===----------------------------------------------------------------------===//
   1895 // callFunction - Execute the specified function...
   1896 //
   1897 void Interpreter::callFunction(Function *F,
   1898                                const std::vector<GenericValue> &ArgVals) {
   1899   assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 ||
   1900           ECStack.back().Caller.arg_size() == ArgVals.size()) &&
   1901          "Incorrect number of arguments passed into function call!");
   1902   // Make a new stack frame... and fill it in.
   1903   ECStack.push_back(ExecutionContext());
   1904   ExecutionContext &StackFrame = ECStack.back();
   1905   StackFrame.CurFunction = F;
   1906 
   1907   // Special handling for external functions.
   1908   if (F->isDeclaration()) {
   1909     GenericValue Result = callExternalFunction (F, ArgVals);
   1910     // Simulate a 'ret' instruction of the appropriate type.
   1911     popStackAndReturnValueToCaller (F->getReturnType (), Result);
   1912     return;
   1913   }
   1914 
   1915   // Get pointers to first LLVM BB & Instruction in function.
   1916   StackFrame.CurBB     = F->begin();
   1917   StackFrame.CurInst   = StackFrame.CurBB->begin();
   1918 
   1919   // Run through the function arguments and initialize their values...
   1920   assert((ArgVals.size() == F->arg_size() ||
   1921          (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&&
   1922          "Invalid number of values passed to function invocation!");
   1923 
   1924   // Handle non-varargs arguments...
   1925   unsigned i = 0;
   1926   for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
   1927        AI != E; ++AI, ++i)
   1928     SetValue(AI, ArgVals[i], StackFrame);
   1929 
   1930   // Handle varargs arguments...
   1931   StackFrame.VarArgs.assign(ArgVals.begin()+i, ArgVals.end());
   1932 }
   1933 
   1934 
   1935 void Interpreter::run() {
   1936   while (!ECStack.empty()) {
   1937     // Interpret a single instruction & increment the "PC".
   1938     ExecutionContext &SF = ECStack.back();  // Current stack frame
   1939     Instruction &I = *SF.CurInst++;         // Increment before execute
   1940 
   1941     // Track the number of dynamic instructions executed.
   1942     ++NumDynamicInsts;
   1943 
   1944     DEBUG(dbgs() << "About to interpret: " << I);
   1945     visit(I);   // Dispatch to one of the visit* methods...
   1946 #if 0
   1947     // This is not safe, as visiting the instruction could lower it and free I.
   1948 DEBUG(
   1949     if (!isa<CallInst>(I) && !isa<InvokeInst>(I) &&
   1950         I.getType() != Type::VoidTy) {
   1951       dbgs() << "  --> ";
   1952       const GenericValue &Val = SF.Values[&I];
   1953       switch (I.getType()->getTypeID()) {
   1954       default: llvm_unreachable("Invalid GenericValue Type");
   1955       case Type::VoidTyID:    dbgs() << "void"; break;
   1956       case Type::FloatTyID:   dbgs() << "float " << Val.FloatVal; break;
   1957       case Type::DoubleTyID:  dbgs() << "double " << Val.DoubleVal; break;
   1958       case Type::PointerTyID: dbgs() << "void* " << intptr_t(Val.PointerVal);
   1959         break;
   1960       case Type::IntegerTyID:
   1961         dbgs() << "i" << Val.IntVal.getBitWidth() << " "
   1962                << Val.IntVal.toStringUnsigned(10)
   1963                << " (0x" << Val.IntVal.toStringUnsigned(16) << ")\n";
   1964         break;
   1965       }
   1966     });
   1967 #endif
   1968   }
   1969 }
   1970