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