1 //===-- Execution.cpp - Implement code to simulate the program ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains the actual instruction interpreter.
12 //===----------------------------------------------------------------------===//
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/IntrinsicLowering.h"
20 #include "llvm/Support/GetElementPtrTypeIterator.h"
21 #include "Support/Statistic.h"
22 #include "Support/Debug.h"
23 #include <cmath> // For fmod
27 Statistic<> NumDynamicInsts("lli", "Number of dynamic instructions executed");
29 Interpreter *TheEE = 0;
33 //===----------------------------------------------------------------------===//
34 // Value Manipulation code
35 //===----------------------------------------------------------------------===//
37 static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
39 static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
41 static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
43 static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
45 static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
47 static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
49 static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
51 static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
53 static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
55 static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
57 static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
59 static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
61 static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
63 static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
65 static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
67 static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
70 GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE,
71 ExecutionContext &SF) {
72 switch (CE->getOpcode()) {
73 case Instruction::Cast:
74 return executeCastOperation(CE->getOperand(0), CE->getType(), SF);
75 case Instruction::GetElementPtr:
76 return executeGEPOperation(CE->getOperand(0), gep_type_begin(CE),
77 gep_type_end(CE), SF);
78 case Instruction::Add:
79 return executeAddInst(getOperandValue(CE->getOperand(0), SF),
80 getOperandValue(CE->getOperand(1), SF),
81 CE->getOperand(0)->getType());
82 case Instruction::Sub:
83 return executeSubInst(getOperandValue(CE->getOperand(0), SF),
84 getOperandValue(CE->getOperand(1), SF),
85 CE->getOperand(0)->getType());
86 case Instruction::Mul:
87 return executeMulInst(getOperandValue(CE->getOperand(0), SF),
88 getOperandValue(CE->getOperand(1), SF),
89 CE->getOperand(0)->getType());
90 case Instruction::Div:
91 return executeDivInst(getOperandValue(CE->getOperand(0), SF),
92 getOperandValue(CE->getOperand(1), SF),
93 CE->getOperand(0)->getType());
94 case Instruction::Rem:
95 return executeRemInst(getOperandValue(CE->getOperand(0), SF),
96 getOperandValue(CE->getOperand(1), SF),
97 CE->getOperand(0)->getType());
98 case Instruction::And:
99 return executeAndInst(getOperandValue(CE->getOperand(0), SF),
100 getOperandValue(CE->getOperand(1), SF),
101 CE->getOperand(0)->getType());
102 case Instruction::Or:
103 return executeOrInst(getOperandValue(CE->getOperand(0), SF),
104 getOperandValue(CE->getOperand(1), SF),
105 CE->getOperand(0)->getType());
106 case Instruction::Xor:
107 return executeXorInst(getOperandValue(CE->getOperand(0), SF),
108 getOperandValue(CE->getOperand(1), SF),
109 CE->getOperand(0)->getType());
110 case Instruction::SetEQ:
111 return executeSetEQInst(getOperandValue(CE->getOperand(0), SF),
112 getOperandValue(CE->getOperand(1), SF),
113 CE->getOperand(0)->getType());
114 case Instruction::SetNE:
115 return executeSetNEInst(getOperandValue(CE->getOperand(0), SF),
116 getOperandValue(CE->getOperand(1), SF),
117 CE->getOperand(0)->getType());
118 case Instruction::SetLE:
119 return executeSetLEInst(getOperandValue(CE->getOperand(0), SF),
120 getOperandValue(CE->getOperand(1), SF),
121 CE->getOperand(0)->getType());
122 case Instruction::SetGE:
123 return executeSetGEInst(getOperandValue(CE->getOperand(0), SF),
124 getOperandValue(CE->getOperand(1), SF),
125 CE->getOperand(0)->getType());
126 case Instruction::SetLT:
127 return executeSetLTInst(getOperandValue(CE->getOperand(0), SF),
128 getOperandValue(CE->getOperand(1), SF),
129 CE->getOperand(0)->getType());
130 case Instruction::SetGT:
131 return executeSetGTInst(getOperandValue(CE->getOperand(0), SF),
132 getOperandValue(CE->getOperand(1), SF),
133 CE->getOperand(0)->getType());
134 case Instruction::Shl:
135 return executeShlInst(getOperandValue(CE->getOperand(0), SF),
136 getOperandValue(CE->getOperand(1), SF),
137 CE->getOperand(0)->getType());
138 case Instruction::Shr:
139 return executeShrInst(getOperandValue(CE->getOperand(0), SF),
140 getOperandValue(CE->getOperand(1), SF),
141 CE->getOperand(0)->getType());
144 std::cerr << "Unhandled ConstantExpr: " << CE << "\n";
146 return GenericValue();
150 GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) {
151 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
152 return getConstantExprValue(CE, SF);
153 } else if (Constant *CPV = dyn_cast<Constant>(V)) {
154 return getConstantValue(CPV);
155 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
156 return PTOGV(getPointerToGlobal(GV));
162 static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) {
166 void Interpreter::initializeExecutionEngine() {
170 //===----------------------------------------------------------------------===//
171 // Binary Instruction Implementations
172 //===----------------------------------------------------------------------===//
174 #define IMPLEMENT_BINARY_OPERATOR(OP, TY) \
175 case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; break
177 static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
180 switch (Ty->getPrimitiveID()) {
181 IMPLEMENT_BINARY_OPERATOR(+, UByte);
182 IMPLEMENT_BINARY_OPERATOR(+, SByte);
183 IMPLEMENT_BINARY_OPERATOR(+, UShort);
184 IMPLEMENT_BINARY_OPERATOR(+, Short);
185 IMPLEMENT_BINARY_OPERATOR(+, UInt);
186 IMPLEMENT_BINARY_OPERATOR(+, Int);
187 IMPLEMENT_BINARY_OPERATOR(+, ULong);
188 IMPLEMENT_BINARY_OPERATOR(+, Long);
189 IMPLEMENT_BINARY_OPERATOR(+, Float);
190 IMPLEMENT_BINARY_OPERATOR(+, Double);
192 std::cout << "Unhandled type for Add instruction: " << *Ty << "\n";
198 static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
201 switch (Ty->getPrimitiveID()) {
202 IMPLEMENT_BINARY_OPERATOR(-, UByte);
203 IMPLEMENT_BINARY_OPERATOR(-, SByte);
204 IMPLEMENT_BINARY_OPERATOR(-, UShort);
205 IMPLEMENT_BINARY_OPERATOR(-, Short);
206 IMPLEMENT_BINARY_OPERATOR(-, UInt);
207 IMPLEMENT_BINARY_OPERATOR(-, Int);
208 IMPLEMENT_BINARY_OPERATOR(-, ULong);
209 IMPLEMENT_BINARY_OPERATOR(-, Long);
210 IMPLEMENT_BINARY_OPERATOR(-, Float);
211 IMPLEMENT_BINARY_OPERATOR(-, Double);
213 std::cout << "Unhandled type for Sub instruction: " << *Ty << "\n";
219 static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
222 switch (Ty->getPrimitiveID()) {
223 IMPLEMENT_BINARY_OPERATOR(*, UByte);
224 IMPLEMENT_BINARY_OPERATOR(*, SByte);
225 IMPLEMENT_BINARY_OPERATOR(*, UShort);
226 IMPLEMENT_BINARY_OPERATOR(*, Short);
227 IMPLEMENT_BINARY_OPERATOR(*, UInt);
228 IMPLEMENT_BINARY_OPERATOR(*, Int);
229 IMPLEMENT_BINARY_OPERATOR(*, ULong);
230 IMPLEMENT_BINARY_OPERATOR(*, Long);
231 IMPLEMENT_BINARY_OPERATOR(*, Float);
232 IMPLEMENT_BINARY_OPERATOR(*, Double);
234 std::cout << "Unhandled type for Mul instruction: " << Ty << "\n";
240 static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
243 switch (Ty->getPrimitiveID()) {
244 IMPLEMENT_BINARY_OPERATOR(/, UByte);
245 IMPLEMENT_BINARY_OPERATOR(/, SByte);
246 IMPLEMENT_BINARY_OPERATOR(/, UShort);
247 IMPLEMENT_BINARY_OPERATOR(/, Short);
248 IMPLEMENT_BINARY_OPERATOR(/, UInt);
249 IMPLEMENT_BINARY_OPERATOR(/, Int);
250 IMPLEMENT_BINARY_OPERATOR(/, ULong);
251 IMPLEMENT_BINARY_OPERATOR(/, Long);
252 IMPLEMENT_BINARY_OPERATOR(/, Float);
253 IMPLEMENT_BINARY_OPERATOR(/, Double);
255 std::cout << "Unhandled type for Div instruction: " << *Ty << "\n";
261 static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
264 switch (Ty->getPrimitiveID()) {
265 IMPLEMENT_BINARY_OPERATOR(%, UByte);
266 IMPLEMENT_BINARY_OPERATOR(%, SByte);
267 IMPLEMENT_BINARY_OPERATOR(%, UShort);
268 IMPLEMENT_BINARY_OPERATOR(%, Short);
269 IMPLEMENT_BINARY_OPERATOR(%, UInt);
270 IMPLEMENT_BINARY_OPERATOR(%, Int);
271 IMPLEMENT_BINARY_OPERATOR(%, ULong);
272 IMPLEMENT_BINARY_OPERATOR(%, Long);
273 case Type::FloatTyID:
274 Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal);
276 case Type::DoubleTyID:
277 Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal);
280 std::cout << "Unhandled type for Rem instruction: " << *Ty << "\n";
286 static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
289 switch (Ty->getPrimitiveID()) {
290 IMPLEMENT_BINARY_OPERATOR(&, Bool);
291 IMPLEMENT_BINARY_OPERATOR(&, UByte);
292 IMPLEMENT_BINARY_OPERATOR(&, SByte);
293 IMPLEMENT_BINARY_OPERATOR(&, UShort);
294 IMPLEMENT_BINARY_OPERATOR(&, Short);
295 IMPLEMENT_BINARY_OPERATOR(&, UInt);
296 IMPLEMENT_BINARY_OPERATOR(&, Int);
297 IMPLEMENT_BINARY_OPERATOR(&, ULong);
298 IMPLEMENT_BINARY_OPERATOR(&, Long);
300 std::cout << "Unhandled type for And instruction: " << *Ty << "\n";
306 static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
309 switch (Ty->getPrimitiveID()) {
310 IMPLEMENT_BINARY_OPERATOR(|, Bool);
311 IMPLEMENT_BINARY_OPERATOR(|, UByte);
312 IMPLEMENT_BINARY_OPERATOR(|, SByte);
313 IMPLEMENT_BINARY_OPERATOR(|, UShort);
314 IMPLEMENT_BINARY_OPERATOR(|, Short);
315 IMPLEMENT_BINARY_OPERATOR(|, UInt);
316 IMPLEMENT_BINARY_OPERATOR(|, Int);
317 IMPLEMENT_BINARY_OPERATOR(|, ULong);
318 IMPLEMENT_BINARY_OPERATOR(|, Long);
320 std::cout << "Unhandled type for Or instruction: " << *Ty << "\n";
326 static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
329 switch (Ty->getPrimitiveID()) {
330 IMPLEMENT_BINARY_OPERATOR(^, Bool);
331 IMPLEMENT_BINARY_OPERATOR(^, UByte);
332 IMPLEMENT_BINARY_OPERATOR(^, SByte);
333 IMPLEMENT_BINARY_OPERATOR(^, UShort);
334 IMPLEMENT_BINARY_OPERATOR(^, Short);
335 IMPLEMENT_BINARY_OPERATOR(^, UInt);
336 IMPLEMENT_BINARY_OPERATOR(^, Int);
337 IMPLEMENT_BINARY_OPERATOR(^, ULong);
338 IMPLEMENT_BINARY_OPERATOR(^, Long);
340 std::cout << "Unhandled type for Xor instruction: " << *Ty << "\n";
346 #define IMPLEMENT_SETCC(OP, TY) \
347 case Type::TY##TyID: Dest.BoolVal = Src1.TY##Val OP Src2.TY##Val; break
349 // Handle pointers specially because they must be compared with only as much
350 // width as the host has. We _do not_ want to be comparing 64 bit values when
351 // running on a 32-bit target, otherwise the upper 32 bits might mess up
352 // comparisons if they contain garbage.
353 #define IMPLEMENT_POINTERSETCC(OP) \
354 case Type::PointerTyID: \
355 Dest.BoolVal = (void*)(intptr_t)Src1.PointerVal OP \
356 (void*)(intptr_t)Src2.PointerVal; break
358 static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
361 switch (Ty->getPrimitiveID()) {
362 IMPLEMENT_SETCC(==, UByte);
363 IMPLEMENT_SETCC(==, SByte);
364 IMPLEMENT_SETCC(==, UShort);
365 IMPLEMENT_SETCC(==, Short);
366 IMPLEMENT_SETCC(==, UInt);
367 IMPLEMENT_SETCC(==, Int);
368 IMPLEMENT_SETCC(==, ULong);
369 IMPLEMENT_SETCC(==, Long);
370 IMPLEMENT_SETCC(==, Float);
371 IMPLEMENT_SETCC(==, Double);
372 IMPLEMENT_POINTERSETCC(==);
374 std::cout << "Unhandled type for SetEQ instruction: " << *Ty << "\n";
380 static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
383 switch (Ty->getPrimitiveID()) {
384 IMPLEMENT_SETCC(!=, UByte);
385 IMPLEMENT_SETCC(!=, SByte);
386 IMPLEMENT_SETCC(!=, UShort);
387 IMPLEMENT_SETCC(!=, Short);
388 IMPLEMENT_SETCC(!=, UInt);
389 IMPLEMENT_SETCC(!=, Int);
390 IMPLEMENT_SETCC(!=, ULong);
391 IMPLEMENT_SETCC(!=, Long);
392 IMPLEMENT_SETCC(!=, Float);
393 IMPLEMENT_SETCC(!=, Double);
394 IMPLEMENT_POINTERSETCC(!=);
397 std::cout << "Unhandled type for SetNE instruction: " << *Ty << "\n";
403 static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
406 switch (Ty->getPrimitiveID()) {
407 IMPLEMENT_SETCC(<=, UByte);
408 IMPLEMENT_SETCC(<=, SByte);
409 IMPLEMENT_SETCC(<=, UShort);
410 IMPLEMENT_SETCC(<=, Short);
411 IMPLEMENT_SETCC(<=, UInt);
412 IMPLEMENT_SETCC(<=, Int);
413 IMPLEMENT_SETCC(<=, ULong);
414 IMPLEMENT_SETCC(<=, Long);
415 IMPLEMENT_SETCC(<=, Float);
416 IMPLEMENT_SETCC(<=, Double);
417 IMPLEMENT_POINTERSETCC(<=);
419 std::cout << "Unhandled type for SetLE instruction: " << Ty << "\n";
425 static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
428 switch (Ty->getPrimitiveID()) {
429 IMPLEMENT_SETCC(>=, UByte);
430 IMPLEMENT_SETCC(>=, SByte);
431 IMPLEMENT_SETCC(>=, UShort);
432 IMPLEMENT_SETCC(>=, Short);
433 IMPLEMENT_SETCC(>=, UInt);
434 IMPLEMENT_SETCC(>=, Int);
435 IMPLEMENT_SETCC(>=, ULong);
436 IMPLEMENT_SETCC(>=, Long);
437 IMPLEMENT_SETCC(>=, Float);
438 IMPLEMENT_SETCC(>=, Double);
439 IMPLEMENT_POINTERSETCC(>=);
441 std::cout << "Unhandled type for SetGE instruction: " << *Ty << "\n";
447 static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
450 switch (Ty->getPrimitiveID()) {
451 IMPLEMENT_SETCC(<, UByte);
452 IMPLEMENT_SETCC(<, SByte);
453 IMPLEMENT_SETCC(<, UShort);
454 IMPLEMENT_SETCC(<, Short);
455 IMPLEMENT_SETCC(<, UInt);
456 IMPLEMENT_SETCC(<, Int);
457 IMPLEMENT_SETCC(<, ULong);
458 IMPLEMENT_SETCC(<, Long);
459 IMPLEMENT_SETCC(<, Float);
460 IMPLEMENT_SETCC(<, Double);
461 IMPLEMENT_POINTERSETCC(<);
463 std::cout << "Unhandled type for SetLT instruction: " << *Ty << "\n";
469 static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
472 switch (Ty->getPrimitiveID()) {
473 IMPLEMENT_SETCC(>, UByte);
474 IMPLEMENT_SETCC(>, SByte);
475 IMPLEMENT_SETCC(>, UShort);
476 IMPLEMENT_SETCC(>, Short);
477 IMPLEMENT_SETCC(>, UInt);
478 IMPLEMENT_SETCC(>, Int);
479 IMPLEMENT_SETCC(>, ULong);
480 IMPLEMENT_SETCC(>, Long);
481 IMPLEMENT_SETCC(>, Float);
482 IMPLEMENT_SETCC(>, Double);
483 IMPLEMENT_POINTERSETCC(>);
485 std::cout << "Unhandled type for SetGT instruction: " << *Ty << "\n";
491 void Interpreter::visitBinaryOperator(BinaryOperator &I) {
492 ExecutionContext &SF = ECStack.back();
493 const Type *Ty = I.getOperand(0)->getType();
494 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
495 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
496 GenericValue R; // Result
498 switch (I.getOpcode()) {
499 case Instruction::Add: R = executeAddInst (Src1, Src2, Ty); break;
500 case Instruction::Sub: R = executeSubInst (Src1, Src2, Ty); break;
501 case Instruction::Mul: R = executeMulInst (Src1, Src2, Ty); break;
502 case Instruction::Div: R = executeDivInst (Src1, Src2, Ty); break;
503 case Instruction::Rem: R = executeRemInst (Src1, Src2, Ty); break;
504 case Instruction::And: R = executeAndInst (Src1, Src2, Ty); break;
505 case Instruction::Or: R = executeOrInst (Src1, Src2, Ty); break;
506 case Instruction::Xor: R = executeXorInst (Src1, Src2, Ty); break;
507 case Instruction::SetEQ: R = executeSetEQInst(Src1, Src2, Ty); break;
508 case Instruction::SetNE: R = executeSetNEInst(Src1, Src2, Ty); break;
509 case Instruction::SetLE: R = executeSetLEInst(Src1, Src2, Ty); break;
510 case Instruction::SetGE: R = executeSetGEInst(Src1, Src2, Ty); break;
511 case Instruction::SetLT: R = executeSetLTInst(Src1, Src2, Ty); break;
512 case Instruction::SetGT: R = executeSetGTInst(Src1, Src2, Ty); break;
514 std::cout << "Don't know how to handle this binary operator!\n-->" << I;
521 //===----------------------------------------------------------------------===//
522 // Terminator Instruction Implementations
523 //===----------------------------------------------------------------------===//
525 void Interpreter::exitCalled(GenericValue GV) {
526 // runAtExitHandlers() assumes there are no stack frames, but
527 // if exit() was called, then it had a stack frame. Blow away
528 // the stack before interpreting atexit handlers.
530 runAtExitHandlers ();
534 /// Pop the last stack frame off of ECStack and then copy the result
535 /// back into the result variable if we are not returning void. The
536 /// result variable may be the ExitCode, or the Value of the calling
537 /// CallInst if there was a previous stack frame. This method may
538 /// invalidate any ECStack iterators you have. This method also takes
539 /// care of switching to the normal destination BB, if we are returning
542 void Interpreter::popStackAndReturnValueToCaller (const Type *RetTy,
543 GenericValue Result) {
544 // Pop the current stack frame.
547 if (ECStack.empty()) { // Finished main. Put result into exit code...
548 if (RetTy && RetTy->isIntegral()) { // Nonvoid return type?
549 ExitCode = Result.IntVal; // Capture the exit code of the program
554 // If we have a previous stack frame, and we have a previous call,
555 // fill in the return value...
556 ExecutionContext &CallingSF = ECStack.back();
557 if (Instruction *I = CallingSF.Caller.getInstruction()) {
558 if (CallingSF.Caller.getType() != Type::VoidTy) // Save result...
559 SetValue(I, Result, CallingSF);
560 if (InvokeInst *II = dyn_cast<InvokeInst> (I))
561 SwitchToNewBasicBlock (II->getNormalDest (), CallingSF);
562 CallingSF.Caller = CallSite(); // We returned from the call...
567 void Interpreter::visitReturnInst(ReturnInst &I) {
568 ExecutionContext &SF = ECStack.back();
569 const Type *RetTy = Type::VoidTy;
572 // Save away the return value... (if we are not 'ret void')
573 if (I.getNumOperands()) {
574 RetTy = I.getReturnValue()->getType();
575 Result = getOperandValue(I.getReturnValue(), SF);
578 popStackAndReturnValueToCaller(RetTy, Result);
581 void Interpreter::visitUnwindInst(UnwindInst &I) {
586 if (ECStack.empty ())
588 Inst = ECStack.back ().Caller.getInstruction ();
589 } while (!(Inst && isa<InvokeInst> (Inst)));
591 // Return from invoke
592 ExecutionContext &InvokingSF = ECStack.back ();
593 InvokingSF.Caller = CallSite ();
595 // Go to exceptional destination BB of invoke instruction
596 SwitchToNewBasicBlock(cast<InvokeInst>(Inst)->getUnwindDest(), InvokingSF);
599 void Interpreter::visitBranchInst(BranchInst &I) {
600 ExecutionContext &SF = ECStack.back();
603 Dest = I.getSuccessor(0); // Uncond branches have a fixed dest...
604 if (!I.isUnconditional()) {
605 Value *Cond = I.getCondition();
606 if (getOperandValue(Cond, SF).BoolVal == 0) // If false cond...
607 Dest = I.getSuccessor(1);
609 SwitchToNewBasicBlock(Dest, SF);
612 void Interpreter::visitSwitchInst(SwitchInst &I) {
613 ExecutionContext &SF = ECStack.back();
614 GenericValue CondVal = getOperandValue(I.getOperand(0), SF);
615 const Type *ElTy = I.getOperand(0)->getType();
617 // Check to see if any of the cases match...
618 BasicBlock *Dest = 0;
619 for (unsigned i = 2, e = I.getNumOperands(); i != e; i += 2)
620 if (executeSetEQInst(CondVal,
621 getOperandValue(I.getOperand(i), SF), ElTy).BoolVal) {
622 Dest = cast<BasicBlock>(I.getOperand(i+1));
626 if (!Dest) Dest = I.getDefaultDest(); // No cases matched: use default
627 SwitchToNewBasicBlock(Dest, SF);
630 // SwitchToNewBasicBlock - This method is used to jump to a new basic block.
631 // This function handles the actual updating of block and instruction iterators
632 // as well as execution of all of the PHI nodes in the destination block.
634 // This method does this because all of the PHI nodes must be executed
635 // atomically, reading their inputs before any of the results are updated. Not
636 // doing this can cause problems if the PHI nodes depend on other PHI nodes for
637 // their inputs. If the input PHI node is updated before it is read, incorrect
638 // results can happen. Thus we use a two phase approach.
640 void Interpreter::SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF){
641 BasicBlock *PrevBB = SF.CurBB; // Remember where we came from...
642 SF.CurBB = Dest; // Update CurBB to branch destination
643 SF.CurInst = SF.CurBB->begin(); // Update new instruction ptr...
645 if (!isa<PHINode>(SF.CurInst)) return; // Nothing fancy to do
647 // Loop over all of the PHI nodes in the current block, reading their inputs.
648 std::vector<GenericValue> ResultValues;
650 for (; PHINode *PN = dyn_cast<PHINode>(SF.CurInst); ++SF.CurInst) {
651 // Search for the value corresponding to this previous bb...
652 int i = PN->getBasicBlockIndex(PrevBB);
653 assert(i != -1 && "PHINode doesn't contain entry for predecessor??");
654 Value *IncomingValue = PN->getIncomingValue(i);
656 // Save the incoming value for this PHI node...
657 ResultValues.push_back(getOperandValue(IncomingValue, SF));
660 // Now loop over all of the PHI nodes setting their values...
661 SF.CurInst = SF.CurBB->begin();
662 for (unsigned i = 0; PHINode *PN = dyn_cast<PHINode>(SF.CurInst);
664 SetValue(PN, ResultValues[i], SF);
667 //===----------------------------------------------------------------------===//
668 // Memory Instruction Implementations
669 //===----------------------------------------------------------------------===//
671 void Interpreter::visitAllocationInst(AllocationInst &I) {
672 ExecutionContext &SF = ECStack.back();
674 const Type *Ty = I.getType()->getElementType(); // Type to be allocated
676 // Get the number of elements being allocated by the array...
677 unsigned NumElements = getOperandValue(I.getOperand(0), SF).UIntVal;
679 // Allocate enough memory to hold the type...
680 void *Memory = malloc(NumElements * TD.getTypeSize(Ty));
682 GenericValue Result = PTOGV(Memory);
683 assert(Result.PointerVal != 0 && "Null pointer returned by malloc!");
684 SetValue(&I, Result, SF);
686 if (I.getOpcode() == Instruction::Alloca)
687 ECStack.back().Allocas.add(Memory);
690 void Interpreter::visitFreeInst(FreeInst &I) {
691 ExecutionContext &SF = ECStack.back();
692 assert(isa<PointerType>(I.getOperand(0)->getType()) && "Freeing nonptr?");
693 GenericValue Value = getOperandValue(I.getOperand(0), SF);
694 // TODO: Check to make sure memory is allocated
695 free(GVTOP(Value)); // Free memory
698 // getElementOffset - The workhorse for getelementptr.
700 GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
702 ExecutionContext &SF) {
703 assert(isa<PointerType>(Ptr->getType()) &&
704 "Cannot getElementOffset of a nonpointer type!");
708 for (; I != E; ++I) {
709 if (const StructType *STy = dyn_cast<StructType>(*I)) {
710 const StructLayout *SLO = TD.getStructLayout(STy);
712 const ConstantUInt *CPU = cast<ConstantUInt>(I.getOperand());
713 unsigned Index = CPU->getValue();
715 Total += SLO->MemberOffsets[Index];
717 const SequentialType *ST = cast<SequentialType>(*I);
718 // Get the index number for the array... which must be long type...
719 GenericValue IdxGV = getOperandValue(I.getOperand(), SF);
722 switch (I.getOperand()->getType()->getPrimitiveID()) {
723 default: assert(0 && "Illegal getelementptr index for sequential type!");
724 case Type::SByteTyID: Idx = IdxGV.SByteVal; break;
725 case Type::ShortTyID: Idx = IdxGV.ShortVal; break;
726 case Type::IntTyID: Idx = IdxGV.IntVal; break;
727 case Type::LongTyID: Idx = IdxGV.LongVal; break;
728 case Type::UByteTyID: Idx = IdxGV.UByteVal; break;
729 case Type::UShortTyID: Idx = IdxGV.UShortVal; break;
730 case Type::UIntTyID: Idx = IdxGV.UIntVal; break;
731 case Type::ULongTyID: Idx = IdxGV.ULongVal; break;
733 Total += TD.getTypeSize(ST->getElementType())*Idx;
738 Result.PointerVal = getOperandValue(Ptr, SF).PointerVal + Total;
742 void Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) {
743 ExecutionContext &SF = ECStack.back();
744 SetValue(&I, TheEE->executeGEPOperation(I.getPointerOperand(),
745 gep_type_begin(I), gep_type_end(I), SF), SF);
748 void Interpreter::visitLoadInst(LoadInst &I) {
749 ExecutionContext &SF = ECStack.back();
750 GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
751 GenericValue *Ptr = (GenericValue*)GVTOP(SRC);
752 GenericValue Result = LoadValueFromMemory(Ptr, I.getType());
753 SetValue(&I, Result, SF);
756 void Interpreter::visitStoreInst(StoreInst &I) {
757 ExecutionContext &SF = ECStack.back();
758 GenericValue Val = getOperandValue(I.getOperand(0), SF);
759 GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
760 StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC),
761 I.getOperand(0)->getType());
764 //===----------------------------------------------------------------------===//
765 // Miscellaneous Instruction Implementations
766 //===----------------------------------------------------------------------===//
768 void Interpreter::visitCallSite(CallSite CS) {
769 ExecutionContext &SF = ECStack.back();
771 // Check to see if this is an intrinsic function call...
772 if (Function *F = CS.getCalledFunction())
773 if (F->isExternal ())
774 switch (F->getIntrinsicID()) {
775 case Intrinsic::not_intrinsic:
777 case Intrinsic::vastart: { // va_start
778 GenericValue ArgIndex;
779 ArgIndex.UIntPairVal.first = ECStack.size() - 1;
780 ArgIndex.UIntPairVal.second = 0;
781 SetValue(CS.getInstruction(), ArgIndex, SF);
784 case Intrinsic::vaend: // va_end is a noop for the interpreter
786 case Intrinsic::vacopy: // va_copy: dest = src
787 SetValue(CS.getInstruction(), getOperandValue(*CS.arg_begin(), SF), SF);
790 // If it is an unknown intrinsic function, use the intrinsic lowering
791 // class to transform it into hopefully tasty LLVM code.
793 Instruction *Prev = CS.getInstruction()->getPrev();
794 BasicBlock *Parent = CS.getInstruction()->getParent();
795 IL->LowerIntrinsicCall(cast<CallInst>(CS.getInstruction()));
797 // Restore the CurInst pointer to the first instruction newly inserted, if
800 SF.CurInst = Parent->begin();
808 std::vector<GenericValue> ArgVals;
809 const unsigned NumArgs = SF.Caller.arg_size();
810 ArgVals.reserve(NumArgs);
811 for (CallSite::arg_iterator i = SF.Caller.arg_begin(),
812 e = SF.Caller.arg_end(); i != e; ++i) {
814 ArgVals.push_back(getOperandValue(V, SF));
815 // Promote all integral types whose size is < sizeof(int) into ints. We do
816 // this by zero or sign extending the value as appropriate according to the
818 const Type *Ty = V->getType();
819 if (Ty->isIntegral() && Ty->getPrimitiveSize() < 4) {
820 if (Ty == Type::ShortTy)
821 ArgVals.back().IntVal = ArgVals.back().ShortVal;
822 else if (Ty == Type::UShortTy)
823 ArgVals.back().UIntVal = ArgVals.back().UShortVal;
824 else if (Ty == Type::SByteTy)
825 ArgVals.back().IntVal = ArgVals.back().SByteVal;
826 else if (Ty == Type::UByteTy)
827 ArgVals.back().UIntVal = ArgVals.back().UByteVal;
828 else if (Ty == Type::BoolTy)
829 ArgVals.back().UIntVal = ArgVals.back().BoolVal;
831 assert(0 && "Unknown type!");
835 // To handle indirect calls, we must get the pointer value from the argument
836 // and treat it as a function pointer.
837 GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF);
838 callFunction((Function*)GVTOP(SRC), ArgVals);
841 #define IMPLEMENT_SHIFT(OP, TY) \
842 case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.UByteVal; break
844 static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
847 switch (Ty->getPrimitiveID()) {
848 IMPLEMENT_SHIFT(<<, UByte);
849 IMPLEMENT_SHIFT(<<, SByte);
850 IMPLEMENT_SHIFT(<<, UShort);
851 IMPLEMENT_SHIFT(<<, Short);
852 IMPLEMENT_SHIFT(<<, UInt);
853 IMPLEMENT_SHIFT(<<, Int);
854 IMPLEMENT_SHIFT(<<, ULong);
855 IMPLEMENT_SHIFT(<<, Long);
857 std::cout << "Unhandled type for Shl instruction: " << *Ty << "\n";
862 static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
865 switch (Ty->getPrimitiveID()) {
866 IMPLEMENT_SHIFT(>>, UByte);
867 IMPLEMENT_SHIFT(>>, SByte);
868 IMPLEMENT_SHIFT(>>, UShort);
869 IMPLEMENT_SHIFT(>>, Short);
870 IMPLEMENT_SHIFT(>>, UInt);
871 IMPLEMENT_SHIFT(>>, Int);
872 IMPLEMENT_SHIFT(>>, ULong);
873 IMPLEMENT_SHIFT(>>, Long);
875 std::cout << "Unhandled type for Shr instruction: " << *Ty << "\n";
881 void Interpreter::visitShl(ShiftInst &I) {
882 ExecutionContext &SF = ECStack.back();
883 const Type *Ty = I.getOperand(0)->getType();
884 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
885 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
887 Dest = executeShlInst (Src1, Src2, Ty);
888 SetValue(&I, Dest, SF);
891 void Interpreter::visitShr(ShiftInst &I) {
892 ExecutionContext &SF = ECStack.back();
893 const Type *Ty = I.getOperand(0)->getType();
894 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
895 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
897 Dest = executeShrInst (Src1, Src2, Ty);
898 SetValue(&I, Dest, SF);
901 #define IMPLEMENT_CAST(DTY, DCTY, STY) \
902 case Type::STY##TyID: Dest.DTY##Val = DCTY Src.STY##Val; break;
904 #define IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY) \
905 case Type::DESTTY##TyID: \
906 switch (SrcTy->getPrimitiveID()) { \
907 IMPLEMENT_CAST(DESTTY, DESTCTY, Bool); \
908 IMPLEMENT_CAST(DESTTY, DESTCTY, UByte); \
909 IMPLEMENT_CAST(DESTTY, DESTCTY, SByte); \
910 IMPLEMENT_CAST(DESTTY, DESTCTY, UShort); \
911 IMPLEMENT_CAST(DESTTY, DESTCTY, Short); \
912 IMPLEMENT_CAST(DESTTY, DESTCTY, UInt); \
913 IMPLEMENT_CAST(DESTTY, DESTCTY, Int); \
914 IMPLEMENT_CAST(DESTTY, DESTCTY, ULong); \
915 IMPLEMENT_CAST(DESTTY, DESTCTY, Long); \
916 IMPLEMENT_CAST(DESTTY, DESTCTY, Pointer);
918 #define IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY) \
919 IMPLEMENT_CAST(DESTTY, DESTCTY, Float); \
920 IMPLEMENT_CAST(DESTTY, DESTCTY, Double)
922 #define IMPLEMENT_CAST_CASE_END() \
923 default: std::cout << "Unhandled cast: " << SrcTy << " to " << Ty << "\n"; \
928 #define IMPLEMENT_CAST_CASE(DESTTY, DESTCTY) \
929 IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY); \
930 IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY); \
931 IMPLEMENT_CAST_CASE_END()
933 GenericValue Interpreter::executeCastOperation(Value *SrcVal, const Type *Ty,
934 ExecutionContext &SF) {
935 const Type *SrcTy = SrcVal->getType();
936 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
938 switch (Ty->getPrimitiveID()) {
939 IMPLEMENT_CAST_CASE(UByte , (unsigned char));
940 IMPLEMENT_CAST_CASE(SByte , ( signed char));
941 IMPLEMENT_CAST_CASE(UShort , (unsigned short));
942 IMPLEMENT_CAST_CASE(Short , ( signed short));
943 IMPLEMENT_CAST_CASE(UInt , (unsigned int ));
944 IMPLEMENT_CAST_CASE(Int , ( signed int ));
945 IMPLEMENT_CAST_CASE(ULong , (uint64_t));
946 IMPLEMENT_CAST_CASE(Long , ( int64_t));
947 IMPLEMENT_CAST_CASE(Pointer, (PointerTy));
948 IMPLEMENT_CAST_CASE(Float , (float));
949 IMPLEMENT_CAST_CASE(Double , (double));
950 IMPLEMENT_CAST_CASE(Bool , (bool));
952 std::cout << "Unhandled dest type for cast instruction: " << *Ty << "\n";
959 void Interpreter::visitCastInst(CastInst &I) {
960 ExecutionContext &SF = ECStack.back();
961 SetValue(&I, executeCastOperation(I.getOperand(0), I.getType(), SF), SF);
964 void Interpreter::visitVANextInst(VANextInst &I) {
965 ExecutionContext &SF = ECStack.back();
967 // Get the incoming valist parameter. LLI treats the valist as a
968 // (ec-stack-depth var-arg-index) pair.
969 GenericValue VAList = getOperandValue(I.getOperand(0), SF);
971 // Move the pointer to the next vararg.
972 ++VAList.UIntPairVal.second;
973 SetValue(&I, VAList, SF);
976 #define IMPLEMENT_VAARG(TY) \
977 case Type::TY##TyID: Dest.TY##Val = Src.TY##Val; break
979 void Interpreter::visitVAArgInst(VAArgInst &I) {
980 ExecutionContext &SF = ECStack.back();
982 // Get the incoming valist parameter. LLI treats the valist as a
983 // (ec-stack-depth var-arg-index) pair.
984 GenericValue VAList = getOperandValue(I.getOperand(0), SF);
986 GenericValue Src = ECStack[VAList.UIntPairVal.first]
987 .VarArgs[VAList.UIntPairVal.second];
988 const Type *Ty = I.getType();
989 switch (Ty->getPrimitiveID()) {
990 IMPLEMENT_VAARG(UByte);
991 IMPLEMENT_VAARG(SByte);
992 IMPLEMENT_VAARG(UShort);
993 IMPLEMENT_VAARG(Short);
994 IMPLEMENT_VAARG(UInt);
995 IMPLEMENT_VAARG(Int);
996 IMPLEMENT_VAARG(ULong);
997 IMPLEMENT_VAARG(Long);
998 IMPLEMENT_VAARG(Pointer);
999 IMPLEMENT_VAARG(Float);
1000 IMPLEMENT_VAARG(Double);
1001 IMPLEMENT_VAARG(Bool);
1003 std::cout << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
1007 // Set the Value of this Instruction.
1008 SetValue(&I, Dest, SF);
1011 //===----------------------------------------------------------------------===//
1012 // Dispatch and Execution Code
1013 //===----------------------------------------------------------------------===//
1015 //===----------------------------------------------------------------------===//
1016 // callFunction - Execute the specified function...
1018 void Interpreter::callFunction(Function *F,
1019 const std::vector<GenericValue> &ArgVals) {
1020 assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 ||
1021 ECStack.back().Caller.arg_size() == ArgVals.size()) &&
1022 "Incorrect number of arguments passed into function call!");
1023 // Make a new stack frame... and fill it in.
1024 ECStack.push_back(ExecutionContext());
1025 ExecutionContext &StackFrame = ECStack.back();
1026 StackFrame.CurFunction = F;
1028 // Special handling for external functions.
1029 if (F->isExternal()) {
1030 GenericValue Result = callExternalFunction (F, ArgVals);
1031 // Simulate a 'ret' instruction of the appropriate type.
1032 popStackAndReturnValueToCaller (F->getReturnType (), Result);
1036 // Get pointers to first LLVM BB & Instruction in function.
1037 StackFrame.CurBB = F->begin();
1038 StackFrame.CurInst = StackFrame.CurBB->begin();
1040 // Run through the function arguments and initialize their values...
1041 assert((ArgVals.size() == F->asize() ||
1042 (ArgVals.size() > F->asize() && F->getFunctionType()->isVarArg())) &&
1043 "Invalid number of values passed to function invocation!");
1045 // Handle non-varargs arguments...
1047 for (Function::aiterator AI = F->abegin(), E = F->aend(); AI != E; ++AI, ++i)
1048 SetValue(AI, ArgVals[i], StackFrame);
1050 // Handle varargs arguments...
1051 StackFrame.VarArgs.assign(ArgVals.begin()+i, ArgVals.end());
1054 void Interpreter::run() {
1055 while (!ECStack.empty()) {
1056 // Interpret a single instruction & increment the "PC".
1057 ExecutionContext &SF = ECStack.back(); // Current stack frame
1058 Instruction &I = *SF.CurInst++; // Increment before execute
1060 // Track the number of dynamic instructions executed.
1063 DEBUG(std::cerr << "About to interpret: " << I);
1064 visit(I); // Dispatch to one of the visit* methods...