1//===-- Execution.cpp - Implement code to simulate the program ------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file contains the actual instruction interpreter. 11// 12//===----------------------------------------------------------------------===// 13 14#define DEBUG_TYPE "interpreter" 15#include "Interpreter.h" 16#include "llvm/Constants.h" 17#include "llvm/DerivedTypes.h" 18#include "llvm/Instructions.h" 19#include "llvm/CodeGen/IntrinsicLowering.h" 20#include "llvm/Support/GetElementPtrTypeIterator.h" 21#include "llvm/ADT/APInt.h" 22#include "llvm/ADT/Statistic.h" 23#include "llvm/Support/CommandLine.h" 24#include "llvm/Support/Debug.h" 25#include "llvm/Support/ErrorHandling.h" 26#include "llvm/Support/MathExtras.h" 27#include <algorithm> 28#include <cmath> 29using namespace llvm; 30 31STATISTIC(NumDynamicInsts, "Number of dynamic instructions executed"); 32 33static cl::opt<bool> PrintVolatile("interpreter-print-volatile", cl::Hidden, 34 cl::desc("make the interpreter print every volatile load and store")); 35 36//===----------------------------------------------------------------------===// 37// Various Helper Functions 38//===----------------------------------------------------------------------===// 39 40static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) { 41 SF.Values[V] = Val; 42} 43 44//===----------------------------------------------------------------------===// 45// Binary Instruction Implementations 46//===----------------------------------------------------------------------===// 47 48#define IMPLEMENT_BINARY_OPERATOR(OP, TY) \ 49 case Type::TY##TyID: \ 50 Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; \ 51 break 52 53static void executeFAddInst(GenericValue &Dest, GenericValue Src1, 54 GenericValue Src2, Type *Ty) { 55 switch (Ty->getTypeID()) { 56 IMPLEMENT_BINARY_OPERATOR(+, Float); 57 IMPLEMENT_BINARY_OPERATOR(+, Double); 58 default: 59 dbgs() << "Unhandled type for FAdd instruction: " << *Ty << "\n"; 60 llvm_unreachable(0); 61 } 62} 63 64static void executeFSubInst(GenericValue &Dest, GenericValue Src1, 65 GenericValue Src2, Type *Ty) { 66 switch (Ty->getTypeID()) { 67 IMPLEMENT_BINARY_OPERATOR(-, Float); 68 IMPLEMENT_BINARY_OPERATOR(-, Double); 69 default: 70 dbgs() << "Unhandled type for FSub instruction: " << *Ty << "\n"; 71 llvm_unreachable(0); 72 } 73} 74 75static void executeFMulInst(GenericValue &Dest, GenericValue Src1, 76 GenericValue Src2, Type *Ty) { 77 switch (Ty->getTypeID()) { 78 IMPLEMENT_BINARY_OPERATOR(*, Float); 79 IMPLEMENT_BINARY_OPERATOR(*, Double); 80 default: 81 dbgs() << "Unhandled type for FMul instruction: " << *Ty << "\n"; 82 llvm_unreachable(0); 83 } 84} 85 86static void executeFDivInst(GenericValue &Dest, GenericValue Src1, 87 GenericValue Src2, Type *Ty) { 88 switch (Ty->getTypeID()) { 89 IMPLEMENT_BINARY_OPERATOR(/, Float); 90 IMPLEMENT_BINARY_OPERATOR(/, Double); 91 default: 92 dbgs() << "Unhandled type for FDiv instruction: " << *Ty << "\n"; 93 llvm_unreachable(0); 94 } 95} 96 97static void executeFRemInst(GenericValue &Dest, GenericValue Src1, 98 GenericValue Src2, Type *Ty) { 99 switch (Ty->getTypeID()) { 100 case Type::FloatTyID: 101 Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal); 102 break; 103 case Type::DoubleTyID: 104 Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal); 105 break; 106 default: 107 dbgs() << "Unhandled type for Rem instruction: " << *Ty << "\n"; 108 llvm_unreachable(0); 109 } 110} 111 112#define IMPLEMENT_INTEGER_ICMP(OP, TY) \ 113 case Type::IntegerTyID: \ 114 Dest.IntVal = APInt(1,Src1.IntVal.OP(Src2.IntVal)); \ 115 break; 116 117// Handle pointers specially because they must be compared with only as much 118// width as the host has. We _do not_ want to be comparing 64 bit values when 119// running on a 32-bit target, otherwise the upper 32 bits might mess up 120// comparisons if they contain garbage. 121#define IMPLEMENT_POINTER_ICMP(OP) \ 122 case Type::PointerTyID: \ 123 Dest.IntVal = APInt(1,(void*)(intptr_t)Src1.PointerVal OP \ 124 (void*)(intptr_t)Src2.PointerVal); \ 125 break; 126 127static GenericValue executeICMP_EQ(GenericValue Src1, GenericValue Src2, 128 Type *Ty) { 129 GenericValue Dest; 130 switch (Ty->getTypeID()) { 131 IMPLEMENT_INTEGER_ICMP(eq,Ty); 132 IMPLEMENT_POINTER_ICMP(==); 133 default: 134 dbgs() << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n"; 135 llvm_unreachable(0); 136 } 137 return Dest; 138} 139 140static GenericValue executeICMP_NE(GenericValue Src1, GenericValue Src2, 141 Type *Ty) { 142 GenericValue Dest; 143 switch (Ty->getTypeID()) { 144 IMPLEMENT_INTEGER_ICMP(ne,Ty); 145 IMPLEMENT_POINTER_ICMP(!=); 146 default: 147 dbgs() << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n"; 148 llvm_unreachable(0); 149 } 150 return Dest; 151} 152 153static GenericValue executeICMP_ULT(GenericValue Src1, GenericValue Src2, 154 Type *Ty) { 155 GenericValue Dest; 156 switch (Ty->getTypeID()) { 157 IMPLEMENT_INTEGER_ICMP(ult,Ty); 158 IMPLEMENT_POINTER_ICMP(<); 159 default: 160 dbgs() << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n"; 161 llvm_unreachable(0); 162 } 163 return Dest; 164} 165 166static GenericValue executeICMP_SLT(GenericValue Src1, GenericValue Src2, 167 Type *Ty) { 168 GenericValue Dest; 169 switch (Ty->getTypeID()) { 170 IMPLEMENT_INTEGER_ICMP(slt,Ty); 171 IMPLEMENT_POINTER_ICMP(<); 172 default: 173 dbgs() << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n"; 174 llvm_unreachable(0); 175 } 176 return Dest; 177} 178 179static GenericValue executeICMP_UGT(GenericValue Src1, GenericValue Src2, 180 Type *Ty) { 181 GenericValue Dest; 182 switch (Ty->getTypeID()) { 183 IMPLEMENT_INTEGER_ICMP(ugt,Ty); 184 IMPLEMENT_POINTER_ICMP(>); 185 default: 186 dbgs() << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n"; 187 llvm_unreachable(0); 188 } 189 return Dest; 190} 191 192static GenericValue executeICMP_SGT(GenericValue Src1, GenericValue Src2, 193 Type *Ty) { 194 GenericValue Dest; 195 switch (Ty->getTypeID()) { 196 IMPLEMENT_INTEGER_ICMP(sgt,Ty); 197 IMPLEMENT_POINTER_ICMP(>); 198 default: 199 dbgs() << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n"; 200 llvm_unreachable(0); 201 } 202 return Dest; 203} 204 205static GenericValue executeICMP_ULE(GenericValue Src1, GenericValue Src2, 206 Type *Ty) { 207 GenericValue Dest; 208 switch (Ty->getTypeID()) { 209 IMPLEMENT_INTEGER_ICMP(ule,Ty); 210 IMPLEMENT_POINTER_ICMP(<=); 211 default: 212 dbgs() << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n"; 213 llvm_unreachable(0); 214 } 215 return Dest; 216} 217 218static GenericValue executeICMP_SLE(GenericValue Src1, GenericValue Src2, 219 Type *Ty) { 220 GenericValue Dest; 221 switch (Ty->getTypeID()) { 222 IMPLEMENT_INTEGER_ICMP(sle,Ty); 223 IMPLEMENT_POINTER_ICMP(<=); 224 default: 225 dbgs() << "Unhandled type for ICMP_SLE predicate: " << *Ty << "\n"; 226 llvm_unreachable(0); 227 } 228 return Dest; 229} 230 231static GenericValue executeICMP_UGE(GenericValue Src1, GenericValue Src2, 232 Type *Ty) { 233 GenericValue Dest; 234 switch (Ty->getTypeID()) { 235 IMPLEMENT_INTEGER_ICMP(uge,Ty); 236 IMPLEMENT_POINTER_ICMP(>=); 237 default: 238 dbgs() << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n"; 239 llvm_unreachable(0); 240 } 241 return Dest; 242} 243 244static GenericValue executeICMP_SGE(GenericValue Src1, GenericValue Src2, 245 Type *Ty) { 246 GenericValue Dest; 247 switch (Ty->getTypeID()) { 248 IMPLEMENT_INTEGER_ICMP(sge,Ty); 249 IMPLEMENT_POINTER_ICMP(>=); 250 default: 251 dbgs() << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n"; 252 llvm_unreachable(0); 253 } 254 return Dest; 255} 256 257void Interpreter::visitICmpInst(ICmpInst &I) { 258 ExecutionContext &SF = ECStack.back(); 259 Type *Ty = I.getOperand(0)->getType(); 260 GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 261 GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 262 GenericValue R; // Result 263 264 switch (I.getPredicate()) { 265 case ICmpInst::ICMP_EQ: R = executeICMP_EQ(Src1, Src2, Ty); break; 266 case ICmpInst::ICMP_NE: R = executeICMP_NE(Src1, Src2, Ty); break; 267 case ICmpInst::ICMP_ULT: R = executeICMP_ULT(Src1, Src2, Ty); break; 268 case ICmpInst::ICMP_SLT: R = executeICMP_SLT(Src1, Src2, Ty); break; 269 case ICmpInst::ICMP_UGT: R = executeICMP_UGT(Src1, Src2, Ty); break; 270 case ICmpInst::ICMP_SGT: R = executeICMP_SGT(Src1, Src2, Ty); break; 271 case ICmpInst::ICMP_ULE: R = executeICMP_ULE(Src1, Src2, Ty); break; 272 case ICmpInst::ICMP_SLE: R = executeICMP_SLE(Src1, Src2, Ty); break; 273 case ICmpInst::ICMP_UGE: R = executeICMP_UGE(Src1, Src2, Ty); break; 274 case ICmpInst::ICMP_SGE: R = executeICMP_SGE(Src1, Src2, Ty); break; 275 default: 276 dbgs() << "Don't know how to handle this ICmp predicate!\n-->" << I; 277 llvm_unreachable(0); 278 } 279 280 SetValue(&I, R, SF); 281} 282 283#define IMPLEMENT_FCMP(OP, TY) \ 284 case Type::TY##TyID: \ 285 Dest.IntVal = APInt(1,Src1.TY##Val OP Src2.TY##Val); \ 286 break 287 288static GenericValue executeFCMP_OEQ(GenericValue Src1, GenericValue Src2, 289 Type *Ty) { 290 GenericValue Dest; 291 switch (Ty->getTypeID()) { 292 IMPLEMENT_FCMP(==, Float); 293 IMPLEMENT_FCMP(==, Double); 294 default: 295 dbgs() << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n"; 296 llvm_unreachable(0); 297 } 298 return Dest; 299} 300 301static GenericValue executeFCMP_ONE(GenericValue Src1, GenericValue Src2, 302 Type *Ty) { 303 GenericValue Dest; 304 switch (Ty->getTypeID()) { 305 IMPLEMENT_FCMP(!=, Float); 306 IMPLEMENT_FCMP(!=, Double); 307 308 default: 309 dbgs() << "Unhandled type for FCmp NE instruction: " << *Ty << "\n"; 310 llvm_unreachable(0); 311 } 312 return Dest; 313} 314 315static GenericValue executeFCMP_OLE(GenericValue Src1, GenericValue Src2, 316 Type *Ty) { 317 GenericValue Dest; 318 switch (Ty->getTypeID()) { 319 IMPLEMENT_FCMP(<=, Float); 320 IMPLEMENT_FCMP(<=, Double); 321 default: 322 dbgs() << "Unhandled type for FCmp LE instruction: " << *Ty << "\n"; 323 llvm_unreachable(0); 324 } 325 return Dest; 326} 327 328static GenericValue executeFCMP_OGE(GenericValue Src1, GenericValue Src2, 329 Type *Ty) { 330 GenericValue Dest; 331 switch (Ty->getTypeID()) { 332 IMPLEMENT_FCMP(>=, Float); 333 IMPLEMENT_FCMP(>=, Double); 334 default: 335 dbgs() << "Unhandled type for FCmp GE instruction: " << *Ty << "\n"; 336 llvm_unreachable(0); 337 } 338 return Dest; 339} 340 341static GenericValue executeFCMP_OLT(GenericValue Src1, GenericValue Src2, 342 Type *Ty) { 343 GenericValue Dest; 344 switch (Ty->getTypeID()) { 345 IMPLEMENT_FCMP(<, Float); 346 IMPLEMENT_FCMP(<, Double); 347 default: 348 dbgs() << "Unhandled type for FCmp LT instruction: " << *Ty << "\n"; 349 llvm_unreachable(0); 350 } 351 return Dest; 352} 353 354static GenericValue executeFCMP_OGT(GenericValue Src1, GenericValue Src2, 355 Type *Ty) { 356 GenericValue Dest; 357 switch (Ty->getTypeID()) { 358 IMPLEMENT_FCMP(>, Float); 359 IMPLEMENT_FCMP(>, Double); 360 default: 361 dbgs() << "Unhandled type for FCmp GT instruction: " << *Ty << "\n"; 362 llvm_unreachable(0); 363 } 364 return Dest; 365} 366 367#define IMPLEMENT_UNORDERED(TY, X,Y) \ 368 if (TY->isFloatTy()) { \ 369 if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) { \ 370 Dest.IntVal = APInt(1,true); \ 371 return Dest; \ 372 } \ 373 } else if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) { \ 374 Dest.IntVal = APInt(1,true); \ 375 return Dest; \ 376 } 377 378 379static GenericValue executeFCMP_UEQ(GenericValue Src1, GenericValue Src2, 380 Type *Ty) { 381 GenericValue Dest; 382 IMPLEMENT_UNORDERED(Ty, Src1, Src2) 383 return executeFCMP_OEQ(Src1, Src2, Ty); 384} 385 386static GenericValue executeFCMP_UNE(GenericValue Src1, GenericValue Src2, 387 Type *Ty) { 388 GenericValue Dest; 389 IMPLEMENT_UNORDERED(Ty, Src1, Src2) 390 return executeFCMP_ONE(Src1, Src2, Ty); 391} 392 393static GenericValue executeFCMP_ULE(GenericValue Src1, GenericValue Src2, 394 Type *Ty) { 395 GenericValue Dest; 396 IMPLEMENT_UNORDERED(Ty, Src1, Src2) 397 return executeFCMP_OLE(Src1, Src2, Ty); 398} 399 400static GenericValue executeFCMP_UGE(GenericValue Src1, GenericValue Src2, 401 Type *Ty) { 402 GenericValue Dest; 403 IMPLEMENT_UNORDERED(Ty, Src1, Src2) 404 return executeFCMP_OGE(Src1, Src2, Ty); 405} 406 407static GenericValue executeFCMP_ULT(GenericValue Src1, GenericValue Src2, 408 Type *Ty) { 409 GenericValue Dest; 410 IMPLEMENT_UNORDERED(Ty, Src1, Src2) 411 return executeFCMP_OLT(Src1, Src2, Ty); 412} 413 414static GenericValue executeFCMP_UGT(GenericValue Src1, GenericValue Src2, 415 Type *Ty) { 416 GenericValue Dest; 417 IMPLEMENT_UNORDERED(Ty, Src1, Src2) 418 return executeFCMP_OGT(Src1, Src2, Ty); 419} 420 421static GenericValue executeFCMP_ORD(GenericValue Src1, GenericValue Src2, 422 Type *Ty) { 423 GenericValue Dest; 424 if (Ty->isFloatTy()) 425 Dest.IntVal = APInt(1,(Src1.FloatVal == Src1.FloatVal && 426 Src2.FloatVal == Src2.FloatVal)); 427 else 428 Dest.IntVal = APInt(1,(Src1.DoubleVal == Src1.DoubleVal && 429 Src2.DoubleVal == Src2.DoubleVal)); 430 return Dest; 431} 432 433static GenericValue executeFCMP_UNO(GenericValue Src1, GenericValue Src2, 434 Type *Ty) { 435 GenericValue Dest; 436 if (Ty->isFloatTy()) 437 Dest.IntVal = APInt(1,(Src1.FloatVal != Src1.FloatVal || 438 Src2.FloatVal != Src2.FloatVal)); 439 else 440 Dest.IntVal = APInt(1,(Src1.DoubleVal != Src1.DoubleVal || 441 Src2.DoubleVal != Src2.DoubleVal)); 442 return Dest; 443} 444 445void Interpreter::visitFCmpInst(FCmpInst &I) { 446 ExecutionContext &SF = ECStack.back(); 447 Type *Ty = I.getOperand(0)->getType(); 448 GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 449 GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 450 GenericValue R; // Result 451 452 switch (I.getPredicate()) { 453 case FCmpInst::FCMP_FALSE: R.IntVal = APInt(1,false); break; 454 case FCmpInst::FCMP_TRUE: R.IntVal = APInt(1,true); break; 455 case FCmpInst::FCMP_ORD: R = executeFCMP_ORD(Src1, Src2, Ty); break; 456 case FCmpInst::FCMP_UNO: R = executeFCMP_UNO(Src1, Src2, Ty); break; 457 case FCmpInst::FCMP_UEQ: R = executeFCMP_UEQ(Src1, Src2, Ty); break; 458 case FCmpInst::FCMP_OEQ: R = executeFCMP_OEQ(Src1, Src2, Ty); break; 459 case FCmpInst::FCMP_UNE: R = executeFCMP_UNE(Src1, Src2, Ty); break; 460 case FCmpInst::FCMP_ONE: R = executeFCMP_ONE(Src1, Src2, Ty); break; 461 case FCmpInst::FCMP_ULT: R = executeFCMP_ULT(Src1, Src2, Ty); break; 462 case FCmpInst::FCMP_OLT: R = executeFCMP_OLT(Src1, Src2, Ty); break; 463 case FCmpInst::FCMP_UGT: R = executeFCMP_UGT(Src1, Src2, Ty); break; 464 case FCmpInst::FCMP_OGT: R = executeFCMP_OGT(Src1, Src2, Ty); break; 465 case FCmpInst::FCMP_ULE: R = executeFCMP_ULE(Src1, Src2, Ty); break; 466 case FCmpInst::FCMP_OLE: R = executeFCMP_OLE(Src1, Src2, Ty); break; 467 case FCmpInst::FCMP_UGE: R = executeFCMP_UGE(Src1, Src2, Ty); break; 468 case FCmpInst::FCMP_OGE: R = executeFCMP_OGE(Src1, Src2, Ty); break; 469 default: 470 dbgs() << "Don't know how to handle this FCmp predicate!\n-->" << I; 471 llvm_unreachable(0); 472 } 473 474 SetValue(&I, R, SF); 475} 476 477static GenericValue executeCmpInst(unsigned predicate, GenericValue Src1, 478 GenericValue Src2, Type *Ty) { 479 GenericValue Result; 480 switch (predicate) { 481 case ICmpInst::ICMP_EQ: return executeICMP_EQ(Src1, Src2, Ty); 482 case ICmpInst::ICMP_NE: return executeICMP_NE(Src1, Src2, Ty); 483 case ICmpInst::ICMP_UGT: return executeICMP_UGT(Src1, Src2, Ty); 484 case ICmpInst::ICMP_SGT: return executeICMP_SGT(Src1, Src2, Ty); 485 case ICmpInst::ICMP_ULT: return executeICMP_ULT(Src1, Src2, Ty); 486 case ICmpInst::ICMP_SLT: return executeICMP_SLT(Src1, Src2, Ty); 487 case ICmpInst::ICMP_UGE: return executeICMP_UGE(Src1, Src2, Ty); 488 case ICmpInst::ICMP_SGE: return executeICMP_SGE(Src1, Src2, Ty); 489 case ICmpInst::ICMP_ULE: return executeICMP_ULE(Src1, Src2, Ty); 490 case ICmpInst::ICMP_SLE: return executeICMP_SLE(Src1, Src2, Ty); 491 case FCmpInst::FCMP_ORD: return executeFCMP_ORD(Src1, Src2, Ty); 492 case FCmpInst::FCMP_UNO: return executeFCMP_UNO(Src1, Src2, Ty); 493 case FCmpInst::FCMP_OEQ: return executeFCMP_OEQ(Src1, Src2, Ty); 494 case FCmpInst::FCMP_UEQ: return executeFCMP_UEQ(Src1, Src2, Ty); 495 case FCmpInst::FCMP_ONE: return executeFCMP_ONE(Src1, Src2, Ty); 496 case FCmpInst::FCMP_UNE: return executeFCMP_UNE(Src1, Src2, Ty); 497 case FCmpInst::FCMP_OLT: return executeFCMP_OLT(Src1, Src2, Ty); 498 case FCmpInst::FCMP_ULT: return executeFCMP_ULT(Src1, Src2, Ty); 499 case FCmpInst::FCMP_OGT: return executeFCMP_OGT(Src1, Src2, Ty); 500 case FCmpInst::FCMP_UGT: return executeFCMP_UGT(Src1, Src2, Ty); 501 case FCmpInst::FCMP_OLE: return executeFCMP_OLE(Src1, Src2, Ty); 502 case FCmpInst::FCMP_ULE: return executeFCMP_ULE(Src1, Src2, Ty); 503 case FCmpInst::FCMP_OGE: return executeFCMP_OGE(Src1, Src2, Ty); 504 case FCmpInst::FCMP_UGE: return executeFCMP_UGE(Src1, Src2, Ty); 505 case FCmpInst::FCMP_FALSE: { 506 GenericValue Result; 507 Result.IntVal = APInt(1, false); 508 return Result; 509 } 510 case FCmpInst::FCMP_TRUE: { 511 GenericValue Result; 512 Result.IntVal = APInt(1, true); 513 return Result; 514 } 515 default: 516 dbgs() << "Unhandled Cmp predicate\n"; 517 llvm_unreachable(0); 518 } 519} 520 521void Interpreter::visitBinaryOperator(BinaryOperator &I) { 522 ExecutionContext &SF = ECStack.back(); 523 Type *Ty = I.getOperand(0)->getType(); 524 GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 525 GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 526 GenericValue R; // Result 527 528 switch (I.getOpcode()) { 529 case Instruction::Add: R.IntVal = Src1.IntVal + Src2.IntVal; break; 530 case Instruction::Sub: R.IntVal = Src1.IntVal - Src2.IntVal; break; 531 case Instruction::Mul: R.IntVal = Src1.IntVal * Src2.IntVal; break; 532 case Instruction::FAdd: executeFAddInst(R, Src1, Src2, Ty); break; 533 case Instruction::FSub: executeFSubInst(R, Src1, Src2, Ty); break; 534 case Instruction::FMul: executeFMulInst(R, Src1, Src2, Ty); break; 535 case Instruction::FDiv: executeFDivInst(R, Src1, Src2, Ty); break; 536 case Instruction::FRem: executeFRemInst(R, Src1, Src2, Ty); break; 537 case Instruction::UDiv: R.IntVal = Src1.IntVal.udiv(Src2.IntVal); break; 538 case Instruction::SDiv: R.IntVal = Src1.IntVal.sdiv(Src2.IntVal); break; 539 case Instruction::URem: R.IntVal = Src1.IntVal.urem(Src2.IntVal); break; 540 case Instruction::SRem: R.IntVal = Src1.IntVal.srem(Src2.IntVal); break; 541 case Instruction::And: R.IntVal = Src1.IntVal & Src2.IntVal; break; 542 case Instruction::Or: R.IntVal = Src1.IntVal | Src2.IntVal; break; 543 case Instruction::Xor: R.IntVal = Src1.IntVal ^ Src2.IntVal; break; 544 default: 545 dbgs() << "Don't know how to handle this binary operator!\n-->" << I; 546 llvm_unreachable(0); 547 } 548 549 SetValue(&I, R, SF); 550} 551 552static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2, 553 GenericValue Src3) { 554 return Src1.IntVal == 0 ? Src3 : Src2; 555} 556 557void Interpreter::visitSelectInst(SelectInst &I) { 558 ExecutionContext &SF = ECStack.back(); 559 GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 560 GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 561 GenericValue Src3 = getOperandValue(I.getOperand(2), SF); 562 GenericValue R = executeSelectInst(Src1, Src2, Src3); 563 SetValue(&I, R, SF); 564} 565 566 567//===----------------------------------------------------------------------===// 568// Terminator Instruction Implementations 569//===----------------------------------------------------------------------===// 570 571void Interpreter::exitCalled(GenericValue GV) { 572 // runAtExitHandlers() assumes there are no stack frames, but 573 // if exit() was called, then it had a stack frame. Blow away 574 // the stack before interpreting atexit handlers. 575 ECStack.clear(); 576 runAtExitHandlers(); 577 exit(GV.IntVal.zextOrTrunc(32).getZExtValue()); 578} 579 580/// Pop the last stack frame off of ECStack and then copy the result 581/// back into the result variable if we are not returning void. The 582/// result variable may be the ExitValue, or the Value of the calling 583/// CallInst if there was a previous stack frame. This method may 584/// invalidate any ECStack iterators you have. This method also takes 585/// care of switching to the normal destination BB, if we are returning 586/// from an invoke. 587/// 588void Interpreter::popStackAndReturnValueToCaller(Type *RetTy, 589 GenericValue Result) { 590 // Pop the current stack frame. 591 ECStack.pop_back(); 592 593 if (ECStack.empty()) { // Finished main. Put result into exit code... 594 if (RetTy && !RetTy->isVoidTy()) { // Nonvoid return type? 595 ExitValue = Result; // Capture the exit value of the program 596 } else { 597 memset(&ExitValue.Untyped, 0, sizeof(ExitValue.Untyped)); 598 } 599 } else { 600 // If we have a previous stack frame, and we have a previous call, 601 // fill in the return value... 602 ExecutionContext &CallingSF = ECStack.back(); 603 if (Instruction *I = CallingSF.Caller.getInstruction()) { 604 // Save result... 605 if (!CallingSF.Caller.getType()->isVoidTy()) 606 SetValue(I, Result, CallingSF); 607 if (InvokeInst *II = dyn_cast<InvokeInst> (I)) 608 SwitchToNewBasicBlock (II->getNormalDest (), CallingSF); 609 CallingSF.Caller = CallSite(); // We returned from the call... 610 } 611 } 612} 613 614void Interpreter::visitReturnInst(ReturnInst &I) { 615 ExecutionContext &SF = ECStack.back(); 616 Type *RetTy = Type::getVoidTy(I.getContext()); 617 GenericValue Result; 618 619 // Save away the return value... (if we are not 'ret void') 620 if (I.getNumOperands()) { 621 RetTy = I.getReturnValue()->getType(); 622 Result = getOperandValue(I.getReturnValue(), SF); 623 } 624 625 popStackAndReturnValueToCaller(RetTy, Result); 626} 627 628void Interpreter::visitUnwindInst(UnwindInst &I) { 629 // Unwind stack 630 Instruction *Inst; 631 do { 632 ECStack.pop_back(); 633 if (ECStack.empty()) 634 report_fatal_error("Empty stack during unwind!"); 635 Inst = ECStack.back().Caller.getInstruction(); 636 } while (!(Inst && isa<InvokeInst>(Inst))); 637 638 // Return from invoke 639 ExecutionContext &InvokingSF = ECStack.back(); 640 InvokingSF.Caller = CallSite(); 641 642 // Go to exceptional destination BB of invoke instruction 643 SwitchToNewBasicBlock(cast<InvokeInst>(Inst)->getUnwindDest(), InvokingSF); 644} 645 646void Interpreter::visitUnreachableInst(UnreachableInst &I) { 647 report_fatal_error("Program executed an 'unreachable' instruction!"); 648} 649 650void Interpreter::visitBranchInst(BranchInst &I) { 651 ExecutionContext &SF = ECStack.back(); 652 BasicBlock *Dest; 653 654 Dest = I.getSuccessor(0); // Uncond branches have a fixed dest... 655 if (!I.isUnconditional()) { 656 Value *Cond = I.getCondition(); 657 if (getOperandValue(Cond, SF).IntVal == 0) // If false cond... 658 Dest = I.getSuccessor(1); 659 } 660 SwitchToNewBasicBlock(Dest, SF); 661} 662 663void Interpreter::visitSwitchInst(SwitchInst &I) { 664 ExecutionContext &SF = ECStack.back(); 665 Value* Cond = I.getCondition(); 666 Type *ElTy = Cond->getType(); 667 GenericValue CondVal = getOperandValue(Cond, SF); 668 669 // Check to see if any of the cases match... 670 BasicBlock *Dest = 0; 671 unsigned NumCases = I.getNumCases(); 672 // Skip the first item since that's the default case. 673 for (unsigned i = 1; i < NumCases; ++i) { 674 GenericValue CaseVal = getOperandValue(I.getCaseValue(i), SF); 675 if (executeICMP_EQ(CondVal, CaseVal, ElTy).IntVal != 0) { 676 Dest = cast<BasicBlock>(I.getSuccessor(i)); 677 break; 678 } 679 } 680 if (!Dest) Dest = I.getDefaultDest(); // No cases matched: use default 681 SwitchToNewBasicBlock(Dest, SF); 682} 683 684void Interpreter::visitIndirectBrInst(IndirectBrInst &I) { 685 ExecutionContext &SF = ECStack.back(); 686 void *Dest = GVTOP(getOperandValue(I.getAddress(), SF)); 687 SwitchToNewBasicBlock((BasicBlock*)Dest, SF); 688} 689 690 691// SwitchToNewBasicBlock - This method is used to jump to a new basic block. 692// This function handles the actual updating of block and instruction iterators 693// as well as execution of all of the PHI nodes in the destination block. 694// 695// This method does this because all of the PHI nodes must be executed 696// atomically, reading their inputs before any of the results are updated. Not 697// doing this can cause problems if the PHI nodes depend on other PHI nodes for 698// their inputs. If the input PHI node is updated before it is read, incorrect 699// results can happen. Thus we use a two phase approach. 700// 701void Interpreter::SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF){ 702 BasicBlock *PrevBB = SF.CurBB; // Remember where we came from... 703 SF.CurBB = Dest; // Update CurBB to branch destination 704 SF.CurInst = SF.CurBB->begin(); // Update new instruction ptr... 705 706 if (!isa<PHINode>(SF.CurInst)) return; // Nothing fancy to do 707 708 // Loop over all of the PHI nodes in the current block, reading their inputs. 709 std::vector<GenericValue> ResultValues; 710 711 for (; PHINode *PN = dyn_cast<PHINode>(SF.CurInst); ++SF.CurInst) { 712 // Search for the value corresponding to this previous bb... 713 int i = PN->getBasicBlockIndex(PrevBB); 714 assert(i != -1 && "PHINode doesn't contain entry for predecessor??"); 715 Value *IncomingValue = PN->getIncomingValue(i); 716 717 // Save the incoming value for this PHI node... 718 ResultValues.push_back(getOperandValue(IncomingValue, SF)); 719 } 720 721 // Now loop over all of the PHI nodes setting their values... 722 SF.CurInst = SF.CurBB->begin(); 723 for (unsigned i = 0; isa<PHINode>(SF.CurInst); ++SF.CurInst, ++i) { 724 PHINode *PN = cast<PHINode>(SF.CurInst); 725 SetValue(PN, ResultValues[i], SF); 726 } 727} 728 729//===----------------------------------------------------------------------===// 730// Memory Instruction Implementations 731//===----------------------------------------------------------------------===// 732 733void Interpreter::visitAllocaInst(AllocaInst &I) { 734 ExecutionContext &SF = ECStack.back(); 735 736 Type *Ty = I.getType()->getElementType(); // Type to be allocated 737 738 // Get the number of elements being allocated by the array... 739 unsigned NumElements = 740 getOperandValue(I.getOperand(0), SF).IntVal.getZExtValue(); 741 742 unsigned TypeSize = (size_t)TD.getTypeAllocSize(Ty); 743 744 // Avoid malloc-ing zero bytes, use max()... 745 unsigned MemToAlloc = std::max(1U, NumElements * TypeSize); 746 747 // Allocate enough memory to hold the type... 748 void *Memory = malloc(MemToAlloc); 749 750 DEBUG(dbgs() << "Allocated Type: " << *Ty << " (" << TypeSize << " bytes) x " 751 << NumElements << " (Total: " << MemToAlloc << ") at " 752 << uintptr_t(Memory) << '\n'); 753 754 GenericValue Result = PTOGV(Memory); 755 assert(Result.PointerVal != 0 && "Null pointer returned by malloc!"); 756 SetValue(&I, Result, SF); 757 758 if (I.getOpcode() == Instruction::Alloca) 759 ECStack.back().Allocas.add(Memory); 760} 761 762// getElementOffset - The workhorse for getelementptr. 763// 764GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I, 765 gep_type_iterator E, 766 ExecutionContext &SF) { 767 assert(Ptr->getType()->isPointerTy() && 768 "Cannot getElementOffset of a nonpointer type!"); 769 770 uint64_t Total = 0; 771 772 for (; I != E; ++I) { 773 if (StructType *STy = dyn_cast<StructType>(*I)) { 774 const StructLayout *SLO = TD.getStructLayout(STy); 775 776 const ConstantInt *CPU = cast<ConstantInt>(I.getOperand()); 777 unsigned Index = unsigned(CPU->getZExtValue()); 778 779 Total += SLO->getElementOffset(Index); 780 } else { 781 SequentialType *ST = cast<SequentialType>(*I); 782 // Get the index number for the array... which must be long type... 783 GenericValue IdxGV = getOperandValue(I.getOperand(), SF); 784 785 int64_t Idx; 786 unsigned BitWidth = 787 cast<IntegerType>(I.getOperand()->getType())->getBitWidth(); 788 if (BitWidth == 32) 789 Idx = (int64_t)(int32_t)IdxGV.IntVal.getZExtValue(); 790 else { 791 assert(BitWidth == 64 && "Invalid index type for getelementptr"); 792 Idx = (int64_t)IdxGV.IntVal.getZExtValue(); 793 } 794 Total += TD.getTypeAllocSize(ST->getElementType())*Idx; 795 } 796 } 797 798 GenericValue Result; 799 Result.PointerVal = ((char*)getOperandValue(Ptr, SF).PointerVal) + Total; 800 DEBUG(dbgs() << "GEP Index " << Total << " bytes.\n"); 801 return Result; 802} 803 804void Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) { 805 ExecutionContext &SF = ECStack.back(); 806 SetValue(&I, executeGEPOperation(I.getPointerOperand(), 807 gep_type_begin(I), gep_type_end(I), SF), SF); 808} 809 810void Interpreter::visitLoadInst(LoadInst &I) { 811 ExecutionContext &SF = ECStack.back(); 812 GenericValue SRC = getOperandValue(I.getPointerOperand(), SF); 813 GenericValue *Ptr = (GenericValue*)GVTOP(SRC); 814 GenericValue Result; 815 LoadValueFromMemory(Result, Ptr, I.getType()); 816 SetValue(&I, Result, SF); 817 if (I.isVolatile() && PrintVolatile) 818 dbgs() << "Volatile load " << I; 819} 820 821void Interpreter::visitStoreInst(StoreInst &I) { 822 ExecutionContext &SF = ECStack.back(); 823 GenericValue Val = getOperandValue(I.getOperand(0), SF); 824 GenericValue SRC = getOperandValue(I.getPointerOperand(), SF); 825 StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC), 826 I.getOperand(0)->getType()); 827 if (I.isVolatile() && PrintVolatile) 828 dbgs() << "Volatile store: " << I; 829} 830 831//===----------------------------------------------------------------------===// 832// Miscellaneous Instruction Implementations 833//===----------------------------------------------------------------------===// 834 835void Interpreter::visitCallSite(CallSite CS) { 836 ExecutionContext &SF = ECStack.back(); 837 838 // Check to see if this is an intrinsic function call... 839 Function *F = CS.getCalledFunction(); 840 if (F && F->isDeclaration()) 841 switch (F->getIntrinsicID()) { 842 case Intrinsic::not_intrinsic: 843 break; 844 case Intrinsic::vastart: { // va_start 845 GenericValue ArgIndex; 846 ArgIndex.UIntPairVal.first = ECStack.size() - 1; 847 ArgIndex.UIntPairVal.second = 0; 848 SetValue(CS.getInstruction(), ArgIndex, SF); 849 return; 850 } 851 case Intrinsic::vaend: // va_end is a noop for the interpreter 852 return; 853 case Intrinsic::vacopy: // va_copy: dest = src 854 SetValue(CS.getInstruction(), getOperandValue(*CS.arg_begin(), SF), SF); 855 return; 856 default: 857 // If it is an unknown intrinsic function, use the intrinsic lowering 858 // class to transform it into hopefully tasty LLVM code. 859 // 860 BasicBlock::iterator me(CS.getInstruction()); 861 BasicBlock *Parent = CS.getInstruction()->getParent(); 862 bool atBegin(Parent->begin() == me); 863 if (!atBegin) 864 --me; 865 IL->LowerIntrinsicCall(cast<CallInst>(CS.getInstruction())); 866 867 // Restore the CurInst pointer to the first instruction newly inserted, if 868 // any. 869 if (atBegin) { 870 SF.CurInst = Parent->begin(); 871 } else { 872 SF.CurInst = me; 873 ++SF.CurInst; 874 } 875 return; 876 } 877 878 879 SF.Caller = CS; 880 std::vector<GenericValue> ArgVals; 881 const unsigned NumArgs = SF.Caller.arg_size(); 882 ArgVals.reserve(NumArgs); 883 uint16_t pNum = 1; 884 for (CallSite::arg_iterator i = SF.Caller.arg_begin(), 885 e = SF.Caller.arg_end(); i != e; ++i, ++pNum) { 886 Value *V = *i; 887 ArgVals.push_back(getOperandValue(V, SF)); 888 } 889 890 // To handle indirect calls, we must get the pointer value from the argument 891 // and treat it as a function pointer. 892 GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF); 893 callFunction((Function*)GVTOP(SRC), ArgVals); 894} 895 896void Interpreter::visitShl(BinaryOperator &I) { 897 ExecutionContext &SF = ECStack.back(); 898 GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 899 GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 900 GenericValue Dest; 901 if (Src2.IntVal.getZExtValue() < Src1.IntVal.getBitWidth()) 902 Dest.IntVal = Src1.IntVal.shl(Src2.IntVal.getZExtValue()); 903 else 904 Dest.IntVal = Src1.IntVal; 905 906 SetValue(&I, Dest, SF); 907} 908 909void Interpreter::visitLShr(BinaryOperator &I) { 910 ExecutionContext &SF = ECStack.back(); 911 GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 912 GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 913 GenericValue Dest; 914 if (Src2.IntVal.getZExtValue() < Src1.IntVal.getBitWidth()) 915 Dest.IntVal = Src1.IntVal.lshr(Src2.IntVal.getZExtValue()); 916 else 917 Dest.IntVal = Src1.IntVal; 918 919 SetValue(&I, Dest, SF); 920} 921 922void Interpreter::visitAShr(BinaryOperator &I) { 923 ExecutionContext &SF = ECStack.back(); 924 GenericValue Src1 = getOperandValue(I.getOperand(0), SF); 925 GenericValue Src2 = getOperandValue(I.getOperand(1), SF); 926 GenericValue Dest; 927 if (Src2.IntVal.getZExtValue() < Src1.IntVal.getBitWidth()) 928 Dest.IntVal = Src1.IntVal.ashr(Src2.IntVal.getZExtValue()); 929 else 930 Dest.IntVal = Src1.IntVal; 931 932 SetValue(&I, Dest, SF); 933} 934 935GenericValue Interpreter::executeTruncInst(Value *SrcVal, Type *DstTy, 936 ExecutionContext &SF) { 937 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 938 IntegerType *DITy = cast<IntegerType>(DstTy); 939 unsigned DBitWidth = DITy->getBitWidth(); 940 Dest.IntVal = Src.IntVal.trunc(DBitWidth); 941 return Dest; 942} 943 944GenericValue Interpreter::executeSExtInst(Value *SrcVal, Type *DstTy, 945 ExecutionContext &SF) { 946 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 947 IntegerType *DITy = cast<IntegerType>(DstTy); 948 unsigned DBitWidth = DITy->getBitWidth(); 949 Dest.IntVal = Src.IntVal.sext(DBitWidth); 950 return Dest; 951} 952 953GenericValue Interpreter::executeZExtInst(Value *SrcVal, Type *DstTy, 954 ExecutionContext &SF) { 955 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 956 IntegerType *DITy = cast<IntegerType>(DstTy); 957 unsigned DBitWidth = DITy->getBitWidth(); 958 Dest.IntVal = Src.IntVal.zext(DBitWidth); 959 return Dest; 960} 961 962GenericValue Interpreter::executeFPTruncInst(Value *SrcVal, Type *DstTy, 963 ExecutionContext &SF) { 964 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 965 assert(SrcVal->getType()->isDoubleTy() && DstTy->isFloatTy() && 966 "Invalid FPTrunc instruction"); 967 Dest.FloatVal = (float) Src.DoubleVal; 968 return Dest; 969} 970 971GenericValue Interpreter::executeFPExtInst(Value *SrcVal, Type *DstTy, 972 ExecutionContext &SF) { 973 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 974 assert(SrcVal->getType()->isFloatTy() && DstTy->isDoubleTy() && 975 "Invalid FPTrunc instruction"); 976 Dest.DoubleVal = (double) Src.FloatVal; 977 return Dest; 978} 979 980GenericValue Interpreter::executeFPToUIInst(Value *SrcVal, Type *DstTy, 981 ExecutionContext &SF) { 982 Type *SrcTy = SrcVal->getType(); 983 uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth(); 984 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 985 assert(SrcTy->isFloatingPointTy() && "Invalid FPToUI instruction"); 986 987 if (SrcTy->getTypeID() == Type::FloatTyID) 988 Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth); 989 else 990 Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth); 991 return Dest; 992} 993 994GenericValue Interpreter::executeFPToSIInst(Value *SrcVal, Type *DstTy, 995 ExecutionContext &SF) { 996 Type *SrcTy = SrcVal->getType(); 997 uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth(); 998 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 999 assert(SrcTy->isFloatingPointTy() && "Invalid FPToSI instruction"); 1000 1001 if (SrcTy->getTypeID() == Type::FloatTyID) 1002 Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth); 1003 else 1004 Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth); 1005 return Dest; 1006} 1007 1008GenericValue Interpreter::executeUIToFPInst(Value *SrcVal, Type *DstTy, 1009 ExecutionContext &SF) { 1010 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 1011 assert(DstTy->isFloatingPointTy() && "Invalid UIToFP instruction"); 1012 1013 if (DstTy->getTypeID() == Type::FloatTyID) 1014 Dest.FloatVal = APIntOps::RoundAPIntToFloat(Src.IntVal); 1015 else 1016 Dest.DoubleVal = APIntOps::RoundAPIntToDouble(Src.IntVal); 1017 return Dest; 1018} 1019 1020GenericValue Interpreter::executeSIToFPInst(Value *SrcVal, Type *DstTy, 1021 ExecutionContext &SF) { 1022 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 1023 assert(DstTy->isFloatingPointTy() && "Invalid SIToFP instruction"); 1024 1025 if (DstTy->getTypeID() == Type::FloatTyID) 1026 Dest.FloatVal = APIntOps::RoundSignedAPIntToFloat(Src.IntVal); 1027 else 1028 Dest.DoubleVal = APIntOps::RoundSignedAPIntToDouble(Src.IntVal); 1029 return Dest; 1030 1031} 1032 1033GenericValue Interpreter::executePtrToIntInst(Value *SrcVal, Type *DstTy, 1034 ExecutionContext &SF) { 1035 uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth(); 1036 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 1037 assert(SrcVal->getType()->isPointerTy() && "Invalid PtrToInt instruction"); 1038 1039 Dest.IntVal = APInt(DBitWidth, (intptr_t) Src.PointerVal); 1040 return Dest; 1041} 1042 1043GenericValue Interpreter::executeIntToPtrInst(Value *SrcVal, Type *DstTy, 1044 ExecutionContext &SF) { 1045 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 1046 assert(DstTy->isPointerTy() && "Invalid PtrToInt instruction"); 1047 1048 uint32_t PtrSize = TD.getPointerSizeInBits(); 1049 if (PtrSize != Src.IntVal.getBitWidth()) 1050 Src.IntVal = Src.IntVal.zextOrTrunc(PtrSize); 1051 1052 Dest.PointerVal = PointerTy(intptr_t(Src.IntVal.getZExtValue())); 1053 return Dest; 1054} 1055 1056GenericValue Interpreter::executeBitCastInst(Value *SrcVal, Type *DstTy, 1057 ExecutionContext &SF) { 1058 1059 Type *SrcTy = SrcVal->getType(); 1060 GenericValue Dest, Src = getOperandValue(SrcVal, SF); 1061 if (DstTy->isPointerTy()) { 1062 assert(SrcTy->isPointerTy() && "Invalid BitCast"); 1063 Dest.PointerVal = Src.PointerVal; 1064 } else if (DstTy->isIntegerTy()) { 1065 if (SrcTy->isFloatTy()) { 1066 Dest.IntVal = APInt::floatToBits(Src.FloatVal); 1067 } else if (SrcTy->isDoubleTy()) { 1068 Dest.IntVal = APInt::doubleToBits(Src.DoubleVal); 1069 } else if (SrcTy->isIntegerTy()) { 1070 Dest.IntVal = Src.IntVal; 1071 } else 1072 llvm_unreachable("Invalid BitCast"); 1073 } else if (DstTy->isFloatTy()) { 1074 if (SrcTy->isIntegerTy()) 1075 Dest.FloatVal = Src.IntVal.bitsToFloat(); 1076 else 1077 Dest.FloatVal = Src.FloatVal; 1078 } else if (DstTy->isDoubleTy()) { 1079 if (SrcTy->isIntegerTy()) 1080 Dest.DoubleVal = Src.IntVal.bitsToDouble(); 1081 else 1082 Dest.DoubleVal = Src.DoubleVal; 1083 } else 1084 llvm_unreachable("Invalid Bitcast"); 1085 1086 return Dest; 1087} 1088 1089void Interpreter::visitTruncInst(TruncInst &I) { 1090 ExecutionContext &SF = ECStack.back(); 1091 SetValue(&I, executeTruncInst(I.getOperand(0), I.getType(), SF), SF); 1092} 1093 1094void Interpreter::visitSExtInst(SExtInst &I) { 1095 ExecutionContext &SF = ECStack.back(); 1096 SetValue(&I, executeSExtInst(I.getOperand(0), I.getType(), SF), SF); 1097} 1098 1099void Interpreter::visitZExtInst(ZExtInst &I) { 1100 ExecutionContext &SF = ECStack.back(); 1101 SetValue(&I, executeZExtInst(I.getOperand(0), I.getType(), SF), SF); 1102} 1103 1104void Interpreter::visitFPTruncInst(FPTruncInst &I) { 1105 ExecutionContext &SF = ECStack.back(); 1106 SetValue(&I, executeFPTruncInst(I.getOperand(0), I.getType(), SF), SF); 1107} 1108 1109void Interpreter::visitFPExtInst(FPExtInst &I) { 1110 ExecutionContext &SF = ECStack.back(); 1111 SetValue(&I, executeFPExtInst(I.getOperand(0), I.getType(), SF), SF); 1112} 1113 1114void Interpreter::visitUIToFPInst(UIToFPInst &I) { 1115 ExecutionContext &SF = ECStack.back(); 1116 SetValue(&I, executeUIToFPInst(I.getOperand(0), I.getType(), SF), SF); 1117} 1118 1119void Interpreter::visitSIToFPInst(SIToFPInst &I) { 1120 ExecutionContext &SF = ECStack.back(); 1121 SetValue(&I, executeSIToFPInst(I.getOperand(0), I.getType(), SF), SF); 1122} 1123 1124void Interpreter::visitFPToUIInst(FPToUIInst &I) { 1125 ExecutionContext &SF = ECStack.back(); 1126 SetValue(&I, executeFPToUIInst(I.getOperand(0), I.getType(), SF), SF); 1127} 1128 1129void Interpreter::visitFPToSIInst(FPToSIInst &I) { 1130 ExecutionContext &SF = ECStack.back(); 1131 SetValue(&I, executeFPToSIInst(I.getOperand(0), I.getType(), SF), SF); 1132} 1133 1134void Interpreter::visitPtrToIntInst(PtrToIntInst &I) { 1135 ExecutionContext &SF = ECStack.back(); 1136 SetValue(&I, executePtrToIntInst(I.getOperand(0), I.getType(), SF), SF); 1137} 1138 1139void Interpreter::visitIntToPtrInst(IntToPtrInst &I) { 1140 ExecutionContext &SF = ECStack.back(); 1141 SetValue(&I, executeIntToPtrInst(I.getOperand(0), I.getType(), SF), SF); 1142} 1143 1144void Interpreter::visitBitCastInst(BitCastInst &I) { 1145 ExecutionContext &SF = ECStack.back(); 1146 SetValue(&I, executeBitCastInst(I.getOperand(0), I.getType(), SF), SF); 1147} 1148 1149#define IMPLEMENT_VAARG(TY) \ 1150 case Type::TY##TyID: Dest.TY##Val = Src.TY##Val; break 1151 1152void Interpreter::visitVAArgInst(VAArgInst &I) { 1153 ExecutionContext &SF = ECStack.back(); 1154 1155 // Get the incoming valist parameter. LLI treats the valist as a 1156 // (ec-stack-depth var-arg-index) pair. 1157 GenericValue VAList = getOperandValue(I.getOperand(0), SF); 1158 GenericValue Dest; 1159 GenericValue Src = ECStack[VAList.UIntPairVal.first] 1160 .VarArgs[VAList.UIntPairVal.second]; 1161 Type *Ty = I.getType(); 1162 switch (Ty->getTypeID()) { 1163 case Type::IntegerTyID: Dest.IntVal = Src.IntVal; 1164 IMPLEMENT_VAARG(Pointer); 1165 IMPLEMENT_VAARG(Float); 1166 IMPLEMENT_VAARG(Double); 1167 default: 1168 dbgs() << "Unhandled dest type for vaarg instruction: " << *Ty << "\n"; 1169 llvm_unreachable(0); 1170 } 1171 1172 // Set the Value of this Instruction. 1173 SetValue(&I, Dest, SF); 1174 1175 // Move the pointer to the next vararg. 1176 ++VAList.UIntPairVal.second; 1177} 1178 1179GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE, 1180 ExecutionContext &SF) { 1181 switch (CE->getOpcode()) { 1182 case Instruction::Trunc: 1183 return executeTruncInst(CE->getOperand(0), CE->getType(), SF); 1184 case Instruction::ZExt: 1185 return executeZExtInst(CE->getOperand(0), CE->getType(), SF); 1186 case Instruction::SExt: 1187 return executeSExtInst(CE->getOperand(0), CE->getType(), SF); 1188 case Instruction::FPTrunc: 1189 return executeFPTruncInst(CE->getOperand(0), CE->getType(), SF); 1190 case Instruction::FPExt: 1191 return executeFPExtInst(CE->getOperand(0), CE->getType(), SF); 1192 case Instruction::UIToFP: 1193 return executeUIToFPInst(CE->getOperand(0), CE->getType(), SF); 1194 case Instruction::SIToFP: 1195 return executeSIToFPInst(CE->getOperand(0), CE->getType(), SF); 1196 case Instruction::FPToUI: 1197 return executeFPToUIInst(CE->getOperand(0), CE->getType(), SF); 1198 case Instruction::FPToSI: 1199 return executeFPToSIInst(CE->getOperand(0), CE->getType(), SF); 1200 case Instruction::PtrToInt: 1201 return executePtrToIntInst(CE->getOperand(0), CE->getType(), SF); 1202 case Instruction::IntToPtr: 1203 return executeIntToPtrInst(CE->getOperand(0), CE->getType(), SF); 1204 case Instruction::BitCast: 1205 return executeBitCastInst(CE->getOperand(0), CE->getType(), SF); 1206 case Instruction::GetElementPtr: 1207 return executeGEPOperation(CE->getOperand(0), gep_type_begin(CE), 1208 gep_type_end(CE), SF); 1209 case Instruction::FCmp: 1210 case Instruction::ICmp: 1211 return executeCmpInst(CE->getPredicate(), 1212 getOperandValue(CE->getOperand(0), SF), 1213 getOperandValue(CE->getOperand(1), SF), 1214 CE->getOperand(0)->getType()); 1215 case Instruction::Select: 1216 return executeSelectInst(getOperandValue(CE->getOperand(0), SF), 1217 getOperandValue(CE->getOperand(1), SF), 1218 getOperandValue(CE->getOperand(2), SF)); 1219 default : 1220 break; 1221 } 1222 1223 // The cases below here require a GenericValue parameter for the result 1224 // so we initialize one, compute it and then return it. 1225 GenericValue Op0 = getOperandValue(CE->getOperand(0), SF); 1226 GenericValue Op1 = getOperandValue(CE->getOperand(1), SF); 1227 GenericValue Dest; 1228 Type * Ty = CE->getOperand(0)->getType(); 1229 switch (CE->getOpcode()) { 1230 case Instruction::Add: Dest.IntVal = Op0.IntVal + Op1.IntVal; break; 1231 case Instruction::Sub: Dest.IntVal = Op0.IntVal - Op1.IntVal; break; 1232 case Instruction::Mul: Dest.IntVal = Op0.IntVal * Op1.IntVal; break; 1233 case Instruction::FAdd: executeFAddInst(Dest, Op0, Op1, Ty); break; 1234 case Instruction::FSub: executeFSubInst(Dest, Op0, Op1, Ty); break; 1235 case Instruction::FMul: executeFMulInst(Dest, Op0, Op1, Ty); break; 1236 case Instruction::FDiv: executeFDivInst(Dest, Op0, Op1, Ty); break; 1237 case Instruction::FRem: executeFRemInst(Dest, Op0, Op1, Ty); break; 1238 case Instruction::SDiv: Dest.IntVal = Op0.IntVal.sdiv(Op1.IntVal); break; 1239 case Instruction::UDiv: Dest.IntVal = Op0.IntVal.udiv(Op1.IntVal); break; 1240 case Instruction::URem: Dest.IntVal = Op0.IntVal.urem(Op1.IntVal); break; 1241 case Instruction::SRem: Dest.IntVal = Op0.IntVal.srem(Op1.IntVal); break; 1242 case Instruction::And: Dest.IntVal = Op0.IntVal & Op1.IntVal; break; 1243 case Instruction::Or: Dest.IntVal = Op0.IntVal | Op1.IntVal; break; 1244 case Instruction::Xor: Dest.IntVal = Op0.IntVal ^ Op1.IntVal; break; 1245 case Instruction::Shl: 1246 Dest.IntVal = Op0.IntVal.shl(Op1.IntVal.getZExtValue()); 1247 break; 1248 case Instruction::LShr: 1249 Dest.IntVal = Op0.IntVal.lshr(Op1.IntVal.getZExtValue()); 1250 break; 1251 case Instruction::AShr: 1252 Dest.IntVal = Op0.IntVal.ashr(Op1.IntVal.getZExtValue()); 1253 break; 1254 default: 1255 dbgs() << "Unhandled ConstantExpr: " << *CE << "\n"; 1256 llvm_unreachable(0); 1257 return GenericValue(); 1258 } 1259 return Dest; 1260} 1261 1262GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) { 1263 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { 1264 return getConstantExprValue(CE, SF); 1265 } else if (Constant *CPV = dyn_cast<Constant>(V)) { 1266 return getConstantValue(CPV); 1267 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) { 1268 return PTOGV(getPointerToGlobal(GV)); 1269 } else { 1270 return SF.Values[V]; 1271 } 1272} 1273 1274//===----------------------------------------------------------------------===// 1275// Dispatch and Execution Code 1276//===----------------------------------------------------------------------===// 1277 1278//===----------------------------------------------------------------------===// 1279// callFunction - Execute the specified function... 1280// 1281void Interpreter::callFunction(Function *F, 1282 const std::vector<GenericValue> &ArgVals) { 1283 assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 || 1284 ECStack.back().Caller.arg_size() == ArgVals.size()) && 1285 "Incorrect number of arguments passed into function call!"); 1286 // Make a new stack frame... and fill it in. 1287 ECStack.push_back(ExecutionContext()); 1288 ExecutionContext &StackFrame = ECStack.back(); 1289 StackFrame.CurFunction = F; 1290 1291 // Special handling for external functions. 1292 if (F->isDeclaration()) { 1293 GenericValue Result = callExternalFunction (F, ArgVals); 1294 // Simulate a 'ret' instruction of the appropriate type. 1295 popStackAndReturnValueToCaller (F->getReturnType (), Result); 1296 return; 1297 } 1298 1299 // Get pointers to first LLVM BB & Instruction in function. 1300 StackFrame.CurBB = F->begin(); 1301 StackFrame.CurInst = StackFrame.CurBB->begin(); 1302 1303 // Run through the function arguments and initialize their values... 1304 assert((ArgVals.size() == F->arg_size() || 1305 (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&& 1306 "Invalid number of values passed to function invocation!"); 1307 1308 // Handle non-varargs arguments... 1309 unsigned i = 0; 1310 for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); 1311 AI != E; ++AI, ++i) 1312 SetValue(AI, ArgVals[i], StackFrame); 1313 1314 // Handle varargs arguments... 1315 StackFrame.VarArgs.assign(ArgVals.begin()+i, ArgVals.end()); 1316} 1317 1318 1319void Interpreter::run() { 1320 while (!ECStack.empty()) { 1321 // Interpret a single instruction & increment the "PC". 1322 ExecutionContext &SF = ECStack.back(); // Current stack frame 1323 Instruction &I = *SF.CurInst++; // Increment before execute 1324 1325 // Track the number of dynamic instructions executed. 1326 ++NumDynamicInsts; 1327 1328 DEBUG(dbgs() << "About to interpret: " << I); 1329 visit(I); // Dispatch to one of the visit* methods... 1330#if 0 1331 // This is not safe, as visiting the instruction could lower it and free I. 1332DEBUG( 1333 if (!isa<CallInst>(I) && !isa<InvokeInst>(I) && 1334 I.getType() != Type::VoidTy) { 1335 dbgs() << " --> "; 1336 const GenericValue &Val = SF.Values[&I]; 1337 switch (I.getType()->getTypeID()) { 1338 default: llvm_unreachable("Invalid GenericValue Type"); 1339 case Type::VoidTyID: dbgs() << "void"; break; 1340 case Type::FloatTyID: dbgs() << "float " << Val.FloatVal; break; 1341 case Type::DoubleTyID: dbgs() << "double " << Val.DoubleVal; break; 1342 case Type::PointerTyID: dbgs() << "void* " << intptr_t(Val.PointerVal); 1343 break; 1344 case Type::IntegerTyID: 1345 dbgs() << "i" << Val.IntVal.getBitWidth() << " " 1346 << Val.IntVal.toStringUnsigned(10) 1347 << " (0x" << Val.IntVal.toStringUnsigned(16) << ")\n"; 1348 break; 1349 } 1350 }); 1351#endif 1352 } 1353} 1354