LCOV - code coverage report
Current view: top level - lib/ExecutionEngine/Interpreter - Execution.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 653 1260 51.8 %
Date: 2017-09-14 15:23:50 Functions: 54 90 60.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13