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/CodeGen/IntrinsicLowering.h"
20 #include "llvm/Support/GetElementPtrTypeIterator.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/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 executeUDivInst(GenericValue Src1, GenericValue Src2,
47 static GenericValue executeSDivInst(GenericValue Src1, GenericValue Src2,
49 static GenericValue executeFDivInst(GenericValue Src1, GenericValue Src2,
51 static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
53 static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
55 static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
57 static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
59 static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
61 static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
63 static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
65 static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
67 static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
69 static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
71 static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
73 static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
76 GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE,
77 ExecutionContext &SF) {
78 switch (CE->getOpcode()) {
79 case Instruction::Cast:
80 return executeCastOperation(CE->getOperand(0), CE->getType(), SF);
81 case Instruction::GetElementPtr:
82 return executeGEPOperation(CE->getOperand(0), gep_type_begin(CE),
83 gep_type_end(CE), SF);
84 case Instruction::Add:
85 return executeAddInst(getOperandValue(CE->getOperand(0), SF),
86 getOperandValue(CE->getOperand(1), SF),
87 CE->getOperand(0)->getType());
88 case Instruction::Sub:
89 return executeSubInst(getOperandValue(CE->getOperand(0), SF),
90 getOperandValue(CE->getOperand(1), SF),
91 CE->getOperand(0)->getType());
92 case Instruction::Mul:
93 return executeMulInst(getOperandValue(CE->getOperand(0), SF),
94 getOperandValue(CE->getOperand(1), SF),
95 CE->getOperand(0)->getType());
96 case Instruction::SDiv:
97 return executeSDivInst(getOperandValue(CE->getOperand(0), SF),
98 getOperandValue(CE->getOperand(1), SF),
99 CE->getOperand(0)->getType());
100 case Instruction::UDiv:
101 return executeUDivInst(getOperandValue(CE->getOperand(0), SF),
102 getOperandValue(CE->getOperand(1), SF),
103 CE->getOperand(0)->getType());
104 case Instruction::FDiv:
105 return executeFDivInst(getOperandValue(CE->getOperand(0), SF),
106 getOperandValue(CE->getOperand(1), SF),
107 CE->getOperand(0)->getType());
108 case Instruction::Rem:
109 return executeRemInst(getOperandValue(CE->getOperand(0), SF),
110 getOperandValue(CE->getOperand(1), SF),
111 CE->getOperand(0)->getType());
112 case Instruction::And:
113 return executeAndInst(getOperandValue(CE->getOperand(0), SF),
114 getOperandValue(CE->getOperand(1), SF),
115 CE->getOperand(0)->getType());
116 case Instruction::Or:
117 return executeOrInst(getOperandValue(CE->getOperand(0), SF),
118 getOperandValue(CE->getOperand(1), SF),
119 CE->getOperand(0)->getType());
120 case Instruction::Xor:
121 return executeXorInst(getOperandValue(CE->getOperand(0), SF),
122 getOperandValue(CE->getOperand(1), SF),
123 CE->getOperand(0)->getType());
124 case Instruction::SetEQ:
125 return executeSetEQInst(getOperandValue(CE->getOperand(0), SF),
126 getOperandValue(CE->getOperand(1), SF),
127 CE->getOperand(0)->getType());
128 case Instruction::SetNE:
129 return executeSetNEInst(getOperandValue(CE->getOperand(0), SF),
130 getOperandValue(CE->getOperand(1), SF),
131 CE->getOperand(0)->getType());
132 case Instruction::SetLE:
133 return executeSetLEInst(getOperandValue(CE->getOperand(0), SF),
134 getOperandValue(CE->getOperand(1), SF),
135 CE->getOperand(0)->getType());
136 case Instruction::SetGE:
137 return executeSetGEInst(getOperandValue(CE->getOperand(0), SF),
138 getOperandValue(CE->getOperand(1), SF),
139 CE->getOperand(0)->getType());
140 case Instruction::SetLT:
141 return executeSetLTInst(getOperandValue(CE->getOperand(0), SF),
142 getOperandValue(CE->getOperand(1), SF),
143 CE->getOperand(0)->getType());
144 case Instruction::SetGT:
145 return executeSetGTInst(getOperandValue(CE->getOperand(0), SF),
146 getOperandValue(CE->getOperand(1), SF),
147 CE->getOperand(0)->getType());
148 case Instruction::Shl:
149 return executeShlInst(getOperandValue(CE->getOperand(0), SF),
150 getOperandValue(CE->getOperand(1), SF),
151 CE->getOperand(0)->getType());
152 case Instruction::Shr:
153 return executeShrInst(getOperandValue(CE->getOperand(0), SF),
154 getOperandValue(CE->getOperand(1), SF),
155 CE->getOperand(0)->getType());
156 case Instruction::Select:
157 return executeSelectInst(getOperandValue(CE->getOperand(0), SF),
158 getOperandValue(CE->getOperand(1), SF),
159 getOperandValue(CE->getOperand(2), SF));
161 std::cerr << "Unhandled ConstantExpr: " << *CE << "\n";
163 return GenericValue();
167 GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) {
168 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
169 return getConstantExprValue(CE, SF);
170 } else if (Constant *CPV = dyn_cast<Constant>(V)) {
171 return getConstantValue(CPV);
172 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
173 return PTOGV(getPointerToGlobal(GV));
179 static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) {
183 void Interpreter::initializeExecutionEngine() {
187 //===----------------------------------------------------------------------===//
188 // Binary Instruction Implementations
189 //===----------------------------------------------------------------------===//
191 #define IMPLEMENT_BINARY_OPERATOR(OP, TY) \
192 case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; break
194 static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
197 switch (Ty->getTypeID()) {
198 IMPLEMENT_BINARY_OPERATOR(+, UByte);
199 IMPLEMENT_BINARY_OPERATOR(+, SByte);
200 IMPLEMENT_BINARY_OPERATOR(+, UShort);
201 IMPLEMENT_BINARY_OPERATOR(+, Short);
202 IMPLEMENT_BINARY_OPERATOR(+, UInt);
203 IMPLEMENT_BINARY_OPERATOR(+, Int);
204 IMPLEMENT_BINARY_OPERATOR(+, ULong);
205 IMPLEMENT_BINARY_OPERATOR(+, Long);
206 IMPLEMENT_BINARY_OPERATOR(+, Float);
207 IMPLEMENT_BINARY_OPERATOR(+, Double);
209 std::cout << "Unhandled type for Add instruction: " << *Ty << "\n";
215 static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
218 switch (Ty->getTypeID()) {
219 IMPLEMENT_BINARY_OPERATOR(-, UByte);
220 IMPLEMENT_BINARY_OPERATOR(-, SByte);
221 IMPLEMENT_BINARY_OPERATOR(-, UShort);
222 IMPLEMENT_BINARY_OPERATOR(-, Short);
223 IMPLEMENT_BINARY_OPERATOR(-, UInt);
224 IMPLEMENT_BINARY_OPERATOR(-, Int);
225 IMPLEMENT_BINARY_OPERATOR(-, ULong);
226 IMPLEMENT_BINARY_OPERATOR(-, Long);
227 IMPLEMENT_BINARY_OPERATOR(-, Float);
228 IMPLEMENT_BINARY_OPERATOR(-, Double);
230 std::cout << "Unhandled type for Sub instruction: " << *Ty << "\n";
236 static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
239 switch (Ty->getTypeID()) {
240 IMPLEMENT_BINARY_OPERATOR(*, UByte);
241 IMPLEMENT_BINARY_OPERATOR(*, SByte);
242 IMPLEMENT_BINARY_OPERATOR(*, UShort);
243 IMPLEMENT_BINARY_OPERATOR(*, Short);
244 IMPLEMENT_BINARY_OPERATOR(*, UInt);
245 IMPLEMENT_BINARY_OPERATOR(*, Int);
246 IMPLEMENT_BINARY_OPERATOR(*, ULong);
247 IMPLEMENT_BINARY_OPERATOR(*, Long);
248 IMPLEMENT_BINARY_OPERATOR(*, Float);
249 IMPLEMENT_BINARY_OPERATOR(*, Double);
251 std::cout << "Unhandled type for Mul instruction: " << *Ty << "\n";
257 static GenericValue executeUDivInst(GenericValue Src1, GenericValue Src2,
261 Ty = Ty->getUnsignedVersion();
262 switch (Ty->getTypeID()) {
263 IMPLEMENT_BINARY_OPERATOR(/, UByte);
264 IMPLEMENT_BINARY_OPERATOR(/, UShort);
265 IMPLEMENT_BINARY_OPERATOR(/, UInt);
266 IMPLEMENT_BINARY_OPERATOR(/, ULong);
268 std::cout << "Unhandled type for UDiv instruction: " << *Ty << "\n";
274 static GenericValue executeSDivInst(GenericValue Src1, GenericValue Src2,
277 if (Ty->isUnsigned())
278 Ty = Ty->getSignedVersion();
279 switch (Ty->getTypeID()) {
280 IMPLEMENT_BINARY_OPERATOR(/, SByte);
281 IMPLEMENT_BINARY_OPERATOR(/, Short);
282 IMPLEMENT_BINARY_OPERATOR(/, Int);
283 IMPLEMENT_BINARY_OPERATOR(/, Long);
285 std::cout << "Unhandled type for SDiv instruction: " << *Ty << "\n";
291 static GenericValue executeFDivInst(GenericValue Src1, GenericValue Src2,
294 switch (Ty->getTypeID()) {
295 IMPLEMENT_BINARY_OPERATOR(/, Float);
296 IMPLEMENT_BINARY_OPERATOR(/, Double);
298 std::cout << "Unhandled type for Div instruction: " << *Ty << "\n";
304 static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
307 switch (Ty->getTypeID()) {
308 IMPLEMENT_BINARY_OPERATOR(%, UByte);
309 IMPLEMENT_BINARY_OPERATOR(%, SByte);
310 IMPLEMENT_BINARY_OPERATOR(%, UShort);
311 IMPLEMENT_BINARY_OPERATOR(%, Short);
312 IMPLEMENT_BINARY_OPERATOR(%, UInt);
313 IMPLEMENT_BINARY_OPERATOR(%, Int);
314 IMPLEMENT_BINARY_OPERATOR(%, ULong);
315 IMPLEMENT_BINARY_OPERATOR(%, Long);
316 case Type::FloatTyID:
317 Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal);
319 case Type::DoubleTyID:
320 Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal);
323 std::cout << "Unhandled type for Rem instruction: " << *Ty << "\n";
329 static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
332 switch (Ty->getTypeID()) {
333 IMPLEMENT_BINARY_OPERATOR(&, Bool);
334 IMPLEMENT_BINARY_OPERATOR(&, UByte);
335 IMPLEMENT_BINARY_OPERATOR(&, SByte);
336 IMPLEMENT_BINARY_OPERATOR(&, UShort);
337 IMPLEMENT_BINARY_OPERATOR(&, Short);
338 IMPLEMENT_BINARY_OPERATOR(&, UInt);
339 IMPLEMENT_BINARY_OPERATOR(&, Int);
340 IMPLEMENT_BINARY_OPERATOR(&, ULong);
341 IMPLEMENT_BINARY_OPERATOR(&, Long);
343 std::cout << "Unhandled type for And instruction: " << *Ty << "\n";
349 static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
352 switch (Ty->getTypeID()) {
353 IMPLEMENT_BINARY_OPERATOR(|, Bool);
354 IMPLEMENT_BINARY_OPERATOR(|, UByte);
355 IMPLEMENT_BINARY_OPERATOR(|, SByte);
356 IMPLEMENT_BINARY_OPERATOR(|, UShort);
357 IMPLEMENT_BINARY_OPERATOR(|, Short);
358 IMPLEMENT_BINARY_OPERATOR(|, UInt);
359 IMPLEMENT_BINARY_OPERATOR(|, Int);
360 IMPLEMENT_BINARY_OPERATOR(|, ULong);
361 IMPLEMENT_BINARY_OPERATOR(|, Long);
363 std::cout << "Unhandled type for Or instruction: " << *Ty << "\n";
369 static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
372 switch (Ty->getTypeID()) {
373 IMPLEMENT_BINARY_OPERATOR(^, Bool);
374 IMPLEMENT_BINARY_OPERATOR(^, UByte);
375 IMPLEMENT_BINARY_OPERATOR(^, SByte);
376 IMPLEMENT_BINARY_OPERATOR(^, UShort);
377 IMPLEMENT_BINARY_OPERATOR(^, Short);
378 IMPLEMENT_BINARY_OPERATOR(^, UInt);
379 IMPLEMENT_BINARY_OPERATOR(^, Int);
380 IMPLEMENT_BINARY_OPERATOR(^, ULong);
381 IMPLEMENT_BINARY_OPERATOR(^, Long);
383 std::cout << "Unhandled type for Xor instruction: " << *Ty << "\n";
389 #define IMPLEMENT_SETCC(OP, TY) \
390 case Type::TY##TyID: Dest.BoolVal = Src1.TY##Val OP Src2.TY##Val; break
392 // Handle pointers specially because they must be compared with only as much
393 // width as the host has. We _do not_ want to be comparing 64 bit values when
394 // running on a 32-bit target, otherwise the upper 32 bits might mess up
395 // comparisons if they contain garbage.
396 #define IMPLEMENT_POINTERSETCC(OP) \
397 case Type::PointerTyID: \
398 Dest.BoolVal = (void*)(intptr_t)Src1.PointerVal OP \
399 (void*)(intptr_t)Src2.PointerVal; break
401 static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
404 switch (Ty->getTypeID()) {
405 IMPLEMENT_SETCC(==, UByte);
406 IMPLEMENT_SETCC(==, SByte);
407 IMPLEMENT_SETCC(==, UShort);
408 IMPLEMENT_SETCC(==, Short);
409 IMPLEMENT_SETCC(==, UInt);
410 IMPLEMENT_SETCC(==, Int);
411 IMPLEMENT_SETCC(==, ULong);
412 IMPLEMENT_SETCC(==, Long);
413 IMPLEMENT_SETCC(==, Float);
414 IMPLEMENT_SETCC(==, Double);
415 IMPLEMENT_POINTERSETCC(==);
417 std::cout << "Unhandled type for SetEQ instruction: " << *Ty << "\n";
423 static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
426 switch (Ty->getTypeID()) {
427 IMPLEMENT_SETCC(!=, UByte);
428 IMPLEMENT_SETCC(!=, SByte);
429 IMPLEMENT_SETCC(!=, UShort);
430 IMPLEMENT_SETCC(!=, Short);
431 IMPLEMENT_SETCC(!=, UInt);
432 IMPLEMENT_SETCC(!=, Int);
433 IMPLEMENT_SETCC(!=, ULong);
434 IMPLEMENT_SETCC(!=, Long);
435 IMPLEMENT_SETCC(!=, Float);
436 IMPLEMENT_SETCC(!=, Double);
437 IMPLEMENT_POINTERSETCC(!=);
440 std::cout << "Unhandled type for SetNE instruction: " << *Ty << "\n";
446 static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
449 switch (Ty->getTypeID()) {
450 IMPLEMENT_SETCC(<=, UByte);
451 IMPLEMENT_SETCC(<=, SByte);
452 IMPLEMENT_SETCC(<=, UShort);
453 IMPLEMENT_SETCC(<=, Short);
454 IMPLEMENT_SETCC(<=, UInt);
455 IMPLEMENT_SETCC(<=, Int);
456 IMPLEMENT_SETCC(<=, ULong);
457 IMPLEMENT_SETCC(<=, Long);
458 IMPLEMENT_SETCC(<=, Float);
459 IMPLEMENT_SETCC(<=, Double);
460 IMPLEMENT_POINTERSETCC(<=);
462 std::cout << "Unhandled type for SetLE instruction: " << *Ty << "\n";
468 static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
471 switch (Ty->getTypeID()) {
472 IMPLEMENT_SETCC(>=, UByte);
473 IMPLEMENT_SETCC(>=, SByte);
474 IMPLEMENT_SETCC(>=, UShort);
475 IMPLEMENT_SETCC(>=, Short);
476 IMPLEMENT_SETCC(>=, UInt);
477 IMPLEMENT_SETCC(>=, Int);
478 IMPLEMENT_SETCC(>=, ULong);
479 IMPLEMENT_SETCC(>=, Long);
480 IMPLEMENT_SETCC(>=, Float);
481 IMPLEMENT_SETCC(>=, Double);
482 IMPLEMENT_POINTERSETCC(>=);
484 std::cout << "Unhandled type for SetGE instruction: " << *Ty << "\n";
490 static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
493 switch (Ty->getTypeID()) {
494 IMPLEMENT_SETCC(<, UByte);
495 IMPLEMENT_SETCC(<, SByte);
496 IMPLEMENT_SETCC(<, UShort);
497 IMPLEMENT_SETCC(<, Short);
498 IMPLEMENT_SETCC(<, UInt);
499 IMPLEMENT_SETCC(<, Int);
500 IMPLEMENT_SETCC(<, ULong);
501 IMPLEMENT_SETCC(<, Long);
502 IMPLEMENT_SETCC(<, Float);
503 IMPLEMENT_SETCC(<, Double);
504 IMPLEMENT_POINTERSETCC(<);
506 std::cout << "Unhandled type for SetLT instruction: " << *Ty << "\n";
512 static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
515 switch (Ty->getTypeID()) {
516 IMPLEMENT_SETCC(>, UByte);
517 IMPLEMENT_SETCC(>, SByte);
518 IMPLEMENT_SETCC(>, UShort);
519 IMPLEMENT_SETCC(>, Short);
520 IMPLEMENT_SETCC(>, UInt);
521 IMPLEMENT_SETCC(>, Int);
522 IMPLEMENT_SETCC(>, ULong);
523 IMPLEMENT_SETCC(>, Long);
524 IMPLEMENT_SETCC(>, Float);
525 IMPLEMENT_SETCC(>, Double);
526 IMPLEMENT_POINTERSETCC(>);
528 std::cout << "Unhandled type for SetGT instruction: " << *Ty << "\n";
534 void Interpreter::visitBinaryOperator(BinaryOperator &I) {
535 ExecutionContext &SF = ECStack.back();
536 const Type *Ty = I.getOperand(0)->getType();
537 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
538 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
539 GenericValue R; // Result
541 switch (I.getOpcode()) {
542 case Instruction::Add: R = executeAddInst (Src1, Src2, Ty); break;
543 case Instruction::Sub: R = executeSubInst (Src1, Src2, Ty); break;
544 case Instruction::Mul: R = executeMulInst (Src1, Src2, Ty); break;
545 case Instruction::UDiv: R = executeUDivInst (Src1, Src2, Ty); break;
546 case Instruction::SDiv: R = executeSDivInst (Src1, Src2, Ty); break;
547 case Instruction::FDiv: R = executeFDivInst (Src1, Src2, Ty); break;
548 case Instruction::Rem: R = executeRemInst (Src1, Src2, Ty); break;
549 case Instruction::And: R = executeAndInst (Src1, Src2, Ty); break;
550 case Instruction::Or: R = executeOrInst (Src1, Src2, Ty); break;
551 case Instruction::Xor: R = executeXorInst (Src1, Src2, Ty); break;
552 case Instruction::SetEQ: R = executeSetEQInst(Src1, Src2, Ty); break;
553 case Instruction::SetNE: R = executeSetNEInst(Src1, Src2, Ty); break;
554 case Instruction::SetLE: R = executeSetLEInst(Src1, Src2, Ty); break;
555 case Instruction::SetGE: R = executeSetGEInst(Src1, Src2, Ty); break;
556 case Instruction::SetLT: R = executeSetLTInst(Src1, Src2, Ty); break;
557 case Instruction::SetGT: R = executeSetGTInst(Src1, Src2, Ty); break;
559 std::cout << "Don't know how to handle this binary operator!\n-->" << I;
566 static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
568 return Src1.BoolVal ? Src2 : Src3;
571 void Interpreter::visitSelectInst(SelectInst &I) {
572 ExecutionContext &SF = ECStack.back();
573 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
574 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
575 GenericValue Src3 = getOperandValue(I.getOperand(2), SF);
576 GenericValue R = executeSelectInst(Src1, Src2, Src3);
581 //===----------------------------------------------------------------------===//
582 // Terminator Instruction Implementations
583 //===----------------------------------------------------------------------===//
585 void Interpreter::exitCalled(GenericValue GV) {
586 // runAtExitHandlers() assumes there are no stack frames, but
587 // if exit() was called, then it had a stack frame. Blow away
588 // the stack before interpreting atexit handlers.
590 runAtExitHandlers ();
594 /// Pop the last stack frame off of ECStack and then copy the result
595 /// back into the result variable if we are not returning void. The
596 /// result variable may be the ExitValue, or the Value of the calling
597 /// CallInst if there was a previous stack frame. This method may
598 /// invalidate any ECStack iterators you have. This method also takes
599 /// care of switching to the normal destination BB, if we are returning
602 void Interpreter::popStackAndReturnValueToCaller (const Type *RetTy,
603 GenericValue Result) {
604 // Pop the current stack frame.
607 if (ECStack.empty()) { // Finished main. Put result into exit code...
608 if (RetTy && RetTy->isIntegral()) { // Nonvoid return type?
609 ExitValue = Result; // Capture the exit value of the program
611 memset(&ExitValue, 0, sizeof(ExitValue));
614 // If we have a previous stack frame, and we have a previous call,
615 // fill in the return value...
616 ExecutionContext &CallingSF = ECStack.back();
617 if (Instruction *I = CallingSF.Caller.getInstruction()) {
618 if (CallingSF.Caller.getType() != Type::VoidTy) // Save result...
619 SetValue(I, Result, CallingSF);
620 if (InvokeInst *II = dyn_cast<InvokeInst> (I))
621 SwitchToNewBasicBlock (II->getNormalDest (), CallingSF);
622 CallingSF.Caller = CallSite(); // We returned from the call...
627 void Interpreter::visitReturnInst(ReturnInst &I) {
628 ExecutionContext &SF = ECStack.back();
629 const Type *RetTy = Type::VoidTy;
632 // Save away the return value... (if we are not 'ret void')
633 if (I.getNumOperands()) {
634 RetTy = I.getReturnValue()->getType();
635 Result = getOperandValue(I.getReturnValue(), SF);
638 popStackAndReturnValueToCaller(RetTy, Result);
641 void Interpreter::visitUnwindInst(UnwindInst &I) {
646 if (ECStack.empty ())
648 Inst = ECStack.back ().Caller.getInstruction ();
649 } while (!(Inst && isa<InvokeInst> (Inst)));
651 // Return from invoke
652 ExecutionContext &InvokingSF = ECStack.back ();
653 InvokingSF.Caller = CallSite ();
655 // Go to exceptional destination BB of invoke instruction
656 SwitchToNewBasicBlock(cast<InvokeInst>(Inst)->getUnwindDest(), InvokingSF);
659 void Interpreter::visitUnreachableInst(UnreachableInst &I) {
660 std::cerr << "ERROR: Program executed an 'unreachable' instruction!\n";
664 void Interpreter::visitBranchInst(BranchInst &I) {
665 ExecutionContext &SF = ECStack.back();
668 Dest = I.getSuccessor(0); // Uncond branches have a fixed dest...
669 if (!I.isUnconditional()) {
670 Value *Cond = I.getCondition();
671 if (getOperandValue(Cond, SF).BoolVal == 0) // If false cond...
672 Dest = I.getSuccessor(1);
674 SwitchToNewBasicBlock(Dest, SF);
677 void Interpreter::visitSwitchInst(SwitchInst &I) {
678 ExecutionContext &SF = ECStack.back();
679 GenericValue CondVal = getOperandValue(I.getOperand(0), SF);
680 const Type *ElTy = I.getOperand(0)->getType();
682 // Check to see if any of the cases match...
683 BasicBlock *Dest = 0;
684 for (unsigned i = 2, e = I.getNumOperands(); i != e; i += 2)
685 if (executeSetEQInst(CondVal,
686 getOperandValue(I.getOperand(i), SF), ElTy).BoolVal) {
687 Dest = cast<BasicBlock>(I.getOperand(i+1));
691 if (!Dest) Dest = I.getDefaultDest(); // No cases matched: use default
692 SwitchToNewBasicBlock(Dest, SF);
695 // SwitchToNewBasicBlock - This method is used to jump to a new basic block.
696 // This function handles the actual updating of block and instruction iterators
697 // as well as execution of all of the PHI nodes in the destination block.
699 // This method does this because all of the PHI nodes must be executed
700 // atomically, reading their inputs before any of the results are updated. Not
701 // doing this can cause problems if the PHI nodes depend on other PHI nodes for
702 // their inputs. If the input PHI node is updated before it is read, incorrect
703 // results can happen. Thus we use a two phase approach.
705 void Interpreter::SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF){
706 BasicBlock *PrevBB = SF.CurBB; // Remember where we came from...
707 SF.CurBB = Dest; // Update CurBB to branch destination
708 SF.CurInst = SF.CurBB->begin(); // Update new instruction ptr...
710 if (!isa<PHINode>(SF.CurInst)) return; // Nothing fancy to do
712 // Loop over all of the PHI nodes in the current block, reading their inputs.
713 std::vector<GenericValue> ResultValues;
715 for (; PHINode *PN = dyn_cast<PHINode>(SF.CurInst); ++SF.CurInst) {
716 // Search for the value corresponding to this previous bb...
717 int i = PN->getBasicBlockIndex(PrevBB);
718 assert(i != -1 && "PHINode doesn't contain entry for predecessor??");
719 Value *IncomingValue = PN->getIncomingValue(i);
721 // Save the incoming value for this PHI node...
722 ResultValues.push_back(getOperandValue(IncomingValue, SF));
725 // Now loop over all of the PHI nodes setting their values...
726 SF.CurInst = SF.CurBB->begin();
727 for (unsigned i = 0; isa<PHINode>(SF.CurInst); ++SF.CurInst, ++i) {
728 PHINode *PN = cast<PHINode>(SF.CurInst);
729 SetValue(PN, ResultValues[i], SF);
733 //===----------------------------------------------------------------------===//
734 // Memory Instruction Implementations
735 //===----------------------------------------------------------------------===//
737 void Interpreter::visitAllocationInst(AllocationInst &I) {
738 ExecutionContext &SF = ECStack.back();
740 const Type *Ty = I.getType()->getElementType(); // Type to be allocated
742 // Get the number of elements being allocated by the array...
743 unsigned NumElements = getOperandValue(I.getOperand(0), SF).UIntVal;
745 // Allocate enough memory to hold the type...
746 void *Memory = malloc(NumElements * (size_t)TD.getTypeSize(Ty));
748 GenericValue Result = PTOGV(Memory);
749 assert(Result.PointerVal != 0 && "Null pointer returned by malloc!");
750 SetValue(&I, Result, SF);
752 if (I.getOpcode() == Instruction::Alloca)
753 ECStack.back().Allocas.add(Memory);
756 void Interpreter::visitFreeInst(FreeInst &I) {
757 ExecutionContext &SF = ECStack.back();
758 assert(isa<PointerType>(I.getOperand(0)->getType()) && "Freeing nonptr?");
759 GenericValue Value = getOperandValue(I.getOperand(0), SF);
760 // TODO: Check to make sure memory is allocated
761 free(GVTOP(Value)); // Free memory
764 // getElementOffset - The workhorse for getelementptr.
766 GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
768 ExecutionContext &SF) {
769 assert(isa<PointerType>(Ptr->getType()) &&
770 "Cannot getElementOffset of a nonpointer type!");
774 for (; I != E; ++I) {
775 if (const StructType *STy = dyn_cast<StructType>(*I)) {
776 const StructLayout *SLO = TD.getStructLayout(STy);
778 const ConstantInt *CPU = cast<ConstantInt>(I.getOperand());
779 unsigned Index = unsigned(CPU->getZExtValue());
781 Total += (PointerTy)SLO->MemberOffsets[Index];
783 const SequentialType *ST = cast<SequentialType>(*I);
784 // Get the index number for the array... which must be long type...
785 GenericValue IdxGV = getOperandValue(I.getOperand(), SF);
788 switch (I.getOperand()->getType()->getTypeID()) {
789 default: assert(0 && "Illegal getelementptr index for sequential type!");
790 case Type::SByteTyID: Idx = IdxGV.SByteVal; break;
791 case Type::ShortTyID: Idx = IdxGV.ShortVal; break;
792 case Type::IntTyID: Idx = IdxGV.IntVal; break;
793 case Type::LongTyID: Idx = IdxGV.LongVal; break;
794 case Type::UByteTyID: Idx = IdxGV.UByteVal; break;
795 case Type::UShortTyID: Idx = IdxGV.UShortVal; break;
796 case Type::UIntTyID: Idx = IdxGV.UIntVal; break;
797 case Type::ULongTyID: Idx = IdxGV.ULongVal; break;
799 Total += PointerTy(TD.getTypeSize(ST->getElementType())*Idx);
804 Result.PointerVal = getOperandValue(Ptr, SF).PointerVal + Total;
808 void Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) {
809 ExecutionContext &SF = ECStack.back();
810 SetValue(&I, TheEE->executeGEPOperation(I.getPointerOperand(),
811 gep_type_begin(I), gep_type_end(I), SF), SF);
814 void Interpreter::visitLoadInst(LoadInst &I) {
815 ExecutionContext &SF = ECStack.back();
816 GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
817 GenericValue *Ptr = (GenericValue*)GVTOP(SRC);
818 GenericValue Result = LoadValueFromMemory(Ptr, I.getType());
819 SetValue(&I, Result, SF);
822 void Interpreter::visitStoreInst(StoreInst &I) {
823 ExecutionContext &SF = ECStack.back();
824 GenericValue Val = getOperandValue(I.getOperand(0), SF);
825 GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
826 StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC),
827 I.getOperand(0)->getType());
830 //===----------------------------------------------------------------------===//
831 // Miscellaneous Instruction Implementations
832 //===----------------------------------------------------------------------===//
834 void Interpreter::visitCallSite(CallSite CS) {
835 ExecutionContext &SF = ECStack.back();
837 // Check to see if this is an intrinsic function call...
838 if (Function *F = CS.getCalledFunction())
839 if (F->isExternal ())
840 switch (F->getIntrinsicID()) {
841 case Intrinsic::not_intrinsic:
843 case Intrinsic::vastart: { // va_start
844 GenericValue ArgIndex;
845 ArgIndex.UIntPairVal.first = ECStack.size() - 1;
846 ArgIndex.UIntPairVal.second = 0;
847 SetValue(CS.getInstruction(), ArgIndex, SF);
850 case Intrinsic::vaend: // va_end is a noop for the interpreter
852 case Intrinsic::vacopy: // va_copy: dest = src
853 SetValue(CS.getInstruction(), getOperandValue(*CS.arg_begin(), SF), SF);
856 // If it is an unknown intrinsic function, use the intrinsic lowering
857 // class to transform it into hopefully tasty LLVM code.
859 Instruction *Prev = CS.getInstruction()->getPrev();
860 BasicBlock *Parent = CS.getInstruction()->getParent();
861 IL->LowerIntrinsicCall(cast<CallInst>(CS.getInstruction()));
863 // Restore the CurInst pointer to the first instruction newly inserted, if
866 SF.CurInst = Parent->begin();
875 std::vector<GenericValue> ArgVals;
876 const unsigned NumArgs = SF.Caller.arg_size();
877 ArgVals.reserve(NumArgs);
878 for (CallSite::arg_iterator i = SF.Caller.arg_begin(),
879 e = SF.Caller.arg_end(); i != e; ++i) {
881 ArgVals.push_back(getOperandValue(V, SF));
882 // Promote all integral types whose size is < sizeof(int) into ints. We do
883 // this by zero or sign extending the value as appropriate according to the
885 const Type *Ty = V->getType();
886 if (Ty->isIntegral() && Ty->getPrimitiveSize() < 4) {
887 if (Ty == Type::ShortTy)
888 ArgVals.back().IntVal = ArgVals.back().ShortVal;
889 else if (Ty == Type::UShortTy)
890 ArgVals.back().UIntVal = ArgVals.back().UShortVal;
891 else if (Ty == Type::SByteTy)
892 ArgVals.back().IntVal = ArgVals.back().SByteVal;
893 else if (Ty == Type::UByteTy)
894 ArgVals.back().UIntVal = ArgVals.back().UByteVal;
895 else if (Ty == Type::BoolTy)
896 ArgVals.back().UIntVal = ArgVals.back().BoolVal;
898 assert(0 && "Unknown type!");
902 // To handle indirect calls, we must get the pointer value from the argument
903 // and treat it as a function pointer.
904 GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF);
905 callFunction((Function*)GVTOP(SRC), ArgVals);
908 #define IMPLEMENT_SHIFT(OP, TY) \
909 case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.UByteVal; break
911 static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
914 switch (Ty->getTypeID()) {
915 IMPLEMENT_SHIFT(<<, UByte);
916 IMPLEMENT_SHIFT(<<, SByte);
917 IMPLEMENT_SHIFT(<<, UShort);
918 IMPLEMENT_SHIFT(<<, Short);
919 IMPLEMENT_SHIFT(<<, UInt);
920 IMPLEMENT_SHIFT(<<, Int);
921 IMPLEMENT_SHIFT(<<, ULong);
922 IMPLEMENT_SHIFT(<<, Long);
924 std::cout << "Unhandled type for Shl instruction: " << *Ty << "\n";
929 static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
932 switch (Ty->getTypeID()) {
933 IMPLEMENT_SHIFT(>>, UByte);
934 IMPLEMENT_SHIFT(>>, SByte);
935 IMPLEMENT_SHIFT(>>, UShort);
936 IMPLEMENT_SHIFT(>>, Short);
937 IMPLEMENT_SHIFT(>>, UInt);
938 IMPLEMENT_SHIFT(>>, Int);
939 IMPLEMENT_SHIFT(>>, ULong);
940 IMPLEMENT_SHIFT(>>, Long);
942 std::cout << "Unhandled type for Shr instruction: " << *Ty << "\n";
948 void Interpreter::visitShl(ShiftInst &I) {
949 ExecutionContext &SF = ECStack.back();
950 const Type *Ty = I.getOperand(0)->getType();
951 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
952 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
954 Dest = executeShlInst (Src1, Src2, Ty);
955 SetValue(&I, Dest, SF);
958 void Interpreter::visitShr(ShiftInst &I) {
959 ExecutionContext &SF = ECStack.back();
960 const Type *Ty = I.getOperand(0)->getType();
961 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
962 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
964 Dest = executeShrInst (Src1, Src2, Ty);
965 SetValue(&I, Dest, SF);
968 #define IMPLEMENT_CAST(DTY, DCTY, STY) \
969 case Type::STY##TyID: Dest.DTY##Val = DCTY Src.STY##Val; break;
971 #define IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY) \
972 case Type::DESTTY##TyID: \
973 switch (SrcTy->getTypeID()) { \
974 IMPLEMENT_CAST(DESTTY, DESTCTY, Bool); \
975 IMPLEMENT_CAST(DESTTY, DESTCTY, UByte); \
976 IMPLEMENT_CAST(DESTTY, DESTCTY, SByte); \
977 IMPLEMENT_CAST(DESTTY, DESTCTY, UShort); \
978 IMPLEMENT_CAST(DESTTY, DESTCTY, Short); \
979 IMPLEMENT_CAST(DESTTY, DESTCTY, UInt); \
980 IMPLEMENT_CAST(DESTTY, DESTCTY, Int); \
981 IMPLEMENT_CAST(DESTTY, DESTCTY, ULong); \
982 IMPLEMENT_CAST(DESTTY, DESTCTY, Long); \
983 IMPLEMENT_CAST(DESTTY, DESTCTY, Pointer);
985 #define IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY) \
986 IMPLEMENT_CAST(DESTTY, DESTCTY, Float); \
987 IMPLEMENT_CAST(DESTTY, DESTCTY, Double)
989 #define IMPLEMENT_CAST_CASE_END() \
990 default: std::cout << "Unhandled cast: " << *SrcTy << " to " << *Ty << "\n"; \
995 #define IMPLEMENT_CAST_CASE(DESTTY, DESTCTY) \
996 IMPLEMENT_CAST_CASE_START(DESTTY, DESTCTY); \
997 IMPLEMENT_CAST_CASE_FP_IMP(DESTTY, DESTCTY); \
998 IMPLEMENT_CAST_CASE_END()
1000 GenericValue Interpreter::executeCastOperation(Value *SrcVal, const Type *Ty,
1001 ExecutionContext &SF) {
1002 const Type *SrcTy = SrcVal->getType();
1003 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1005 switch (Ty->getTypeID()) {
1006 IMPLEMENT_CAST_CASE(UByte , (unsigned char));
1007 IMPLEMENT_CAST_CASE(SByte , ( signed char));
1008 IMPLEMENT_CAST_CASE(UShort , (unsigned short));
1009 IMPLEMENT_CAST_CASE(Short , ( signed short));
1010 IMPLEMENT_CAST_CASE(UInt , (unsigned int ));
1011 IMPLEMENT_CAST_CASE(Int , ( signed int ));
1012 IMPLEMENT_CAST_CASE(ULong , (uint64_t));
1013 IMPLEMENT_CAST_CASE(Long , ( int64_t));
1014 IMPLEMENT_CAST_CASE(Pointer, (PointerTy));
1015 IMPLEMENT_CAST_CASE(Float , (float));
1016 IMPLEMENT_CAST_CASE(Double , (double));
1017 IMPLEMENT_CAST_CASE(Bool , (bool));
1019 std::cout << "Unhandled dest type for cast instruction: " << *Ty << "\n";
1026 void Interpreter::visitCastInst(CastInst &I) {
1027 ExecutionContext &SF = ECStack.back();
1028 SetValue(&I, executeCastOperation(I.getOperand(0), I.getType(), SF), SF);
1031 #define IMPLEMENT_VAARG(TY) \
1032 case Type::TY##TyID: Dest.TY##Val = Src.TY##Val; break
1034 void Interpreter::visitVAArgInst(VAArgInst &I) {
1035 ExecutionContext &SF = ECStack.back();
1037 // Get the incoming valist parameter. LLI treats the valist as a
1038 // (ec-stack-depth var-arg-index) pair.
1039 GenericValue VAList = getOperandValue(I.getOperand(0), SF);
1041 GenericValue Src = ECStack[VAList.UIntPairVal.first]
1042 .VarArgs[VAList.UIntPairVal.second];
1043 const Type *Ty = I.getType();
1044 switch (Ty->getTypeID()) {
1045 IMPLEMENT_VAARG(UByte);
1046 IMPLEMENT_VAARG(SByte);
1047 IMPLEMENT_VAARG(UShort);
1048 IMPLEMENT_VAARG(Short);
1049 IMPLEMENT_VAARG(UInt);
1050 IMPLEMENT_VAARG(Int);
1051 IMPLEMENT_VAARG(ULong);
1052 IMPLEMENT_VAARG(Long);
1053 IMPLEMENT_VAARG(Pointer);
1054 IMPLEMENT_VAARG(Float);
1055 IMPLEMENT_VAARG(Double);
1056 IMPLEMENT_VAARG(Bool);
1058 std::cout << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
1062 // Set the Value of this Instruction.
1063 SetValue(&I, Dest, SF);
1065 // Move the pointer to the next vararg.
1066 ++VAList.UIntPairVal.second;
1069 //===----------------------------------------------------------------------===//
1070 // Dispatch and Execution Code
1071 //===----------------------------------------------------------------------===//
1073 //===----------------------------------------------------------------------===//
1074 // callFunction - Execute the specified function...
1076 void Interpreter::callFunction(Function *F,
1077 const std::vector<GenericValue> &ArgVals) {
1078 assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 ||
1079 ECStack.back().Caller.arg_size() == ArgVals.size()) &&
1080 "Incorrect number of arguments passed into function call!");
1081 // Make a new stack frame... and fill it in.
1082 ECStack.push_back(ExecutionContext());
1083 ExecutionContext &StackFrame = ECStack.back();
1084 StackFrame.CurFunction = F;
1086 // Special handling for external functions.
1087 if (F->isExternal()) {
1088 GenericValue Result = callExternalFunction (F, ArgVals);
1089 // Simulate a 'ret' instruction of the appropriate type.
1090 popStackAndReturnValueToCaller (F->getReturnType (), Result);
1094 // Get pointers to first LLVM BB & Instruction in function.
1095 StackFrame.CurBB = F->begin();
1096 StackFrame.CurInst = StackFrame.CurBB->begin();
1098 // Run through the function arguments and initialize their values...
1099 assert((ArgVals.size() == F->arg_size() ||
1100 (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&&
1101 "Invalid number of values passed to function invocation!");
1103 // Handle non-varargs arguments...
1105 for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); AI != E; ++AI, ++i)
1106 SetValue(AI, ArgVals[i], StackFrame);
1108 // Handle varargs arguments...
1109 StackFrame.VarArgs.assign(ArgVals.begin()+i, ArgVals.end());
1112 void Interpreter::run() {
1113 while (!ECStack.empty()) {
1114 // Interpret a single instruction & increment the "PC".
1115 ExecutionContext &SF = ECStack.back(); // Current stack frame
1116 Instruction &I = *SF.CurInst++; // Increment before execute
1118 // Track the number of dynamic instructions executed.
1121 DEBUG(std::cerr << "About to interpret: " << I);
1122 visit(I); // Dispatch to one of the visit* methods...