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"
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 executeUDivInst(GenericValue Src1, GenericValue Src2,
45 static GenericValue executeSDivInst(GenericValue Src1, GenericValue Src2,
47 static GenericValue executeFDivInst(GenericValue Src1, GenericValue Src2,
49 static GenericValue executeURemInst(GenericValue Src1, GenericValue Src2,
51 static GenericValue executeSRemInst(GenericValue Src1, GenericValue Src2,
53 static GenericValue executeFRemInst(GenericValue Src1, GenericValue Src2,
55 static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
57 static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
59 static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
61 static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
63 static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
65 static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
67 static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
69 static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
71 static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
73 static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
75 static GenericValue executeLShrInst(GenericValue Src1, GenericValue Src2,
77 static GenericValue executeAShrInst(GenericValue Src1, GenericValue Src2,
79 static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
82 GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE,
83 ExecutionContext &SF) {
84 switch (CE->getOpcode()) {
85 case Instruction::Trunc:
86 case Instruction::ZExt:
87 case Instruction::SExt:
88 case Instruction::FPTrunc:
89 case Instruction::FPExt:
90 case Instruction::UIToFP:
91 case Instruction::SIToFP:
92 case Instruction::FPToUI:
93 case Instruction::FPToSI:
94 case Instruction::PtrToInt:
95 case Instruction::IntToPtr:
96 case Instruction::BitCast:
97 return executeCastOperation(Instruction::CastOps(CE->getOpcode()),
98 CE->getOperand(0), CE->getType(), SF);
99 case Instruction::GetElementPtr:
100 return executeGEPOperation(CE->getOperand(0), gep_type_begin(CE),
101 gep_type_end(CE), SF);
102 case Instruction::Add:
103 return executeAddInst(getOperandValue(CE->getOperand(0), SF),
104 getOperandValue(CE->getOperand(1), SF),
105 CE->getOperand(0)->getType());
106 case Instruction::Sub:
107 return executeSubInst(getOperandValue(CE->getOperand(0), SF),
108 getOperandValue(CE->getOperand(1), SF),
109 CE->getOperand(0)->getType());
110 case Instruction::Mul:
111 return executeMulInst(getOperandValue(CE->getOperand(0), SF),
112 getOperandValue(CE->getOperand(1), SF),
113 CE->getOperand(0)->getType());
114 case Instruction::SDiv:
115 return executeSDivInst(getOperandValue(CE->getOperand(0), SF),
116 getOperandValue(CE->getOperand(1), SF),
117 CE->getOperand(0)->getType());
118 case Instruction::UDiv:
119 return executeUDivInst(getOperandValue(CE->getOperand(0), SF),
120 getOperandValue(CE->getOperand(1), SF),
121 CE->getOperand(0)->getType());
122 case Instruction::FDiv:
123 return executeFDivInst(getOperandValue(CE->getOperand(0), SF),
124 getOperandValue(CE->getOperand(1), SF),
125 CE->getOperand(0)->getType());
126 case Instruction::URem:
127 return executeURemInst(getOperandValue(CE->getOperand(0), SF),
128 getOperandValue(CE->getOperand(1), SF),
129 CE->getOperand(0)->getType());
130 case Instruction::SRem:
131 return executeSRemInst(getOperandValue(CE->getOperand(0), SF),
132 getOperandValue(CE->getOperand(1), SF),
133 CE->getOperand(0)->getType());
134 case Instruction::FRem:
135 return executeFRemInst(getOperandValue(CE->getOperand(0), SF),
136 getOperandValue(CE->getOperand(1), SF),
137 CE->getOperand(0)->getType());
138 case Instruction::And:
139 return executeAndInst(getOperandValue(CE->getOperand(0), SF),
140 getOperandValue(CE->getOperand(1), SF),
141 CE->getOperand(0)->getType());
142 case Instruction::Or:
143 return executeOrInst(getOperandValue(CE->getOperand(0), SF),
144 getOperandValue(CE->getOperand(1), SF),
145 CE->getOperand(0)->getType());
146 case Instruction::Xor:
147 return executeXorInst(getOperandValue(CE->getOperand(0), SF),
148 getOperandValue(CE->getOperand(1), SF),
149 CE->getOperand(0)->getType());
150 case Instruction::SetEQ:
151 return executeSetEQInst(getOperandValue(CE->getOperand(0), SF),
152 getOperandValue(CE->getOperand(1), SF),
153 CE->getOperand(0)->getType());
154 case Instruction::SetNE:
155 return executeSetNEInst(getOperandValue(CE->getOperand(0), SF),
156 getOperandValue(CE->getOperand(1), SF),
157 CE->getOperand(0)->getType());
158 case Instruction::SetLE:
159 return executeSetLEInst(getOperandValue(CE->getOperand(0), SF),
160 getOperandValue(CE->getOperand(1), SF),
161 CE->getOperand(0)->getType());
162 case Instruction::SetGE:
163 return executeSetGEInst(getOperandValue(CE->getOperand(0), SF),
164 getOperandValue(CE->getOperand(1), SF),
165 CE->getOperand(0)->getType());
166 case Instruction::SetLT:
167 return executeSetLTInst(getOperandValue(CE->getOperand(0), SF),
168 getOperandValue(CE->getOperand(1), SF),
169 CE->getOperand(0)->getType());
170 case Instruction::SetGT:
171 return executeSetGTInst(getOperandValue(CE->getOperand(0), SF),
172 getOperandValue(CE->getOperand(1), SF),
173 CE->getOperand(0)->getType());
174 case Instruction::Shl:
175 return executeShlInst(getOperandValue(CE->getOperand(0), SF),
176 getOperandValue(CE->getOperand(1), SF),
177 CE->getOperand(0)->getType());
178 case Instruction::LShr:
179 return executeLShrInst(getOperandValue(CE->getOperand(0), SF),
180 getOperandValue(CE->getOperand(1), SF),
181 CE->getOperand(0)->getType());
182 case Instruction::AShr:
183 return executeAShrInst(getOperandValue(CE->getOperand(0), SF),
184 getOperandValue(CE->getOperand(1), SF),
185 CE->getOperand(0)->getType());
186 case Instruction::Select:
187 return executeSelectInst(getOperandValue(CE->getOperand(0), SF),
188 getOperandValue(CE->getOperand(1), SF),
189 getOperandValue(CE->getOperand(2), SF));
191 cerr << "Unhandled ConstantExpr: " << *CE << "\n";
193 return GenericValue();
197 GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) {
198 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
199 return getConstantExprValue(CE, SF);
200 } else if (Constant *CPV = dyn_cast<Constant>(V)) {
201 return getConstantValue(CPV);
202 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
203 return PTOGV(getPointerToGlobal(GV));
209 static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) {
213 void Interpreter::initializeExecutionEngine() {
217 //===----------------------------------------------------------------------===//
218 // Binary Instruction Implementations
219 //===----------------------------------------------------------------------===//
221 #define IMPLEMENT_BINARY_OPERATOR(OP, TY) \
222 case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; break
224 static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
227 switch (Ty->getTypeID()) {
228 IMPLEMENT_BINARY_OPERATOR(+, UByte);
229 IMPLEMENT_BINARY_OPERATOR(+, SByte);
230 IMPLEMENT_BINARY_OPERATOR(+, UShort);
231 IMPLEMENT_BINARY_OPERATOR(+, Short);
232 IMPLEMENT_BINARY_OPERATOR(+, UInt);
233 IMPLEMENT_BINARY_OPERATOR(+, Int);
234 IMPLEMENT_BINARY_OPERATOR(+, ULong);
235 IMPLEMENT_BINARY_OPERATOR(+, Long);
236 IMPLEMENT_BINARY_OPERATOR(+, Float);
237 IMPLEMENT_BINARY_OPERATOR(+, Double);
239 cerr << "Unhandled type for Add instruction: " << *Ty << "\n";
245 static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
248 switch (Ty->getTypeID()) {
249 IMPLEMENT_BINARY_OPERATOR(-, UByte);
250 IMPLEMENT_BINARY_OPERATOR(-, SByte);
251 IMPLEMENT_BINARY_OPERATOR(-, UShort);
252 IMPLEMENT_BINARY_OPERATOR(-, Short);
253 IMPLEMENT_BINARY_OPERATOR(-, UInt);
254 IMPLEMENT_BINARY_OPERATOR(-, Int);
255 IMPLEMENT_BINARY_OPERATOR(-, ULong);
256 IMPLEMENT_BINARY_OPERATOR(-, Long);
257 IMPLEMENT_BINARY_OPERATOR(-, Float);
258 IMPLEMENT_BINARY_OPERATOR(-, Double);
260 cerr << "Unhandled type for Sub instruction: " << *Ty << "\n";
266 static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
269 switch (Ty->getTypeID()) {
270 IMPLEMENT_BINARY_OPERATOR(*, UByte);
271 IMPLEMENT_BINARY_OPERATOR(*, SByte);
272 IMPLEMENT_BINARY_OPERATOR(*, UShort);
273 IMPLEMENT_BINARY_OPERATOR(*, Short);
274 IMPLEMENT_BINARY_OPERATOR(*, UInt);
275 IMPLEMENT_BINARY_OPERATOR(*, Int);
276 IMPLEMENT_BINARY_OPERATOR(*, ULong);
277 IMPLEMENT_BINARY_OPERATOR(*, Long);
278 IMPLEMENT_BINARY_OPERATOR(*, Float);
279 IMPLEMENT_BINARY_OPERATOR(*, Double);
281 cerr << "Unhandled type for Mul instruction: " << *Ty << "\n";
287 #define IMPLEMENT_SIGNLESS_BINOP(OP, TY1, TY2) \
288 case Type::TY2##TyID: IMPLEMENT_BINARY_OPERATOR(OP, TY1)
290 static GenericValue executeUDivInst(GenericValue Src1, GenericValue Src2,
293 switch (Ty->getTypeID()) {
294 IMPLEMENT_SIGNLESS_BINOP(/, UByte, SByte);
295 IMPLEMENT_SIGNLESS_BINOP(/, UShort, Short);
296 IMPLEMENT_SIGNLESS_BINOP(/, UInt, Int);
297 IMPLEMENT_SIGNLESS_BINOP(/, ULong, Long);
299 cerr << "Unhandled type for UDiv instruction: " << *Ty << "\n";
305 static GenericValue executeSDivInst(GenericValue Src1, GenericValue Src2,
308 switch (Ty->getTypeID()) {
309 IMPLEMENT_SIGNLESS_BINOP(/, SByte, UByte);
310 IMPLEMENT_SIGNLESS_BINOP(/, Short, UShort);
311 IMPLEMENT_SIGNLESS_BINOP(/, Int, UInt);
312 IMPLEMENT_SIGNLESS_BINOP(/, Long, ULong);
314 cerr << "Unhandled type for SDiv instruction: " << *Ty << "\n";
320 static GenericValue executeFDivInst(GenericValue Src1, GenericValue Src2,
323 switch (Ty->getTypeID()) {
324 IMPLEMENT_BINARY_OPERATOR(/, Float);
325 IMPLEMENT_BINARY_OPERATOR(/, Double);
327 cerr << "Unhandled type for Div instruction: " << *Ty << "\n";
333 static GenericValue executeURemInst(GenericValue Src1, GenericValue Src2,
336 switch (Ty->getTypeID()) {
337 IMPLEMENT_SIGNLESS_BINOP(%, UByte, SByte);
338 IMPLEMENT_SIGNLESS_BINOP(%, UShort, Short);
339 IMPLEMENT_SIGNLESS_BINOP(%, UInt, Int);
340 IMPLEMENT_SIGNLESS_BINOP(%, ULong, Long);
342 cerr << "Unhandled type for URem instruction: " << *Ty << "\n";
348 static GenericValue executeSRemInst(GenericValue Src1, GenericValue Src2,
351 switch (Ty->getTypeID()) {
352 IMPLEMENT_SIGNLESS_BINOP(%, SByte, UByte);
353 IMPLEMENT_SIGNLESS_BINOP(%, Short, UShort);
354 IMPLEMENT_SIGNLESS_BINOP(%, Int, UInt);
355 IMPLEMENT_SIGNLESS_BINOP(%, Long, ULong);
357 cerr << "Unhandled type for Rem instruction: " << *Ty << "\n";
363 static GenericValue executeFRemInst(GenericValue Src1, GenericValue Src2,
366 switch (Ty->getTypeID()) {
367 case Type::FloatTyID:
368 Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal);
370 case Type::DoubleTyID:
371 Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal);
374 cerr << "Unhandled type for Rem instruction: " << *Ty << "\n";
380 static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
383 switch (Ty->getTypeID()) {
384 IMPLEMENT_BINARY_OPERATOR(&, Bool);
385 IMPLEMENT_BINARY_OPERATOR(&, UByte);
386 IMPLEMENT_BINARY_OPERATOR(&, SByte);
387 IMPLEMENT_BINARY_OPERATOR(&, UShort);
388 IMPLEMENT_BINARY_OPERATOR(&, Short);
389 IMPLEMENT_BINARY_OPERATOR(&, UInt);
390 IMPLEMENT_BINARY_OPERATOR(&, Int);
391 IMPLEMENT_BINARY_OPERATOR(&, ULong);
392 IMPLEMENT_BINARY_OPERATOR(&, Long);
394 cerr << "Unhandled type for And instruction: " << *Ty << "\n";
400 static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
403 switch (Ty->getTypeID()) {
404 IMPLEMENT_BINARY_OPERATOR(|, Bool);
405 IMPLEMENT_BINARY_OPERATOR(|, UByte);
406 IMPLEMENT_BINARY_OPERATOR(|, SByte);
407 IMPLEMENT_BINARY_OPERATOR(|, UShort);
408 IMPLEMENT_BINARY_OPERATOR(|, Short);
409 IMPLEMENT_BINARY_OPERATOR(|, UInt);
410 IMPLEMENT_BINARY_OPERATOR(|, Int);
411 IMPLEMENT_BINARY_OPERATOR(|, ULong);
412 IMPLEMENT_BINARY_OPERATOR(|, Long);
414 cerr << "Unhandled type for Or instruction: " << *Ty << "\n";
420 static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
423 switch (Ty->getTypeID()) {
424 IMPLEMENT_BINARY_OPERATOR(^, Bool);
425 IMPLEMENT_BINARY_OPERATOR(^, UByte);
426 IMPLEMENT_BINARY_OPERATOR(^, SByte);
427 IMPLEMENT_BINARY_OPERATOR(^, UShort);
428 IMPLEMENT_BINARY_OPERATOR(^, Short);
429 IMPLEMENT_BINARY_OPERATOR(^, UInt);
430 IMPLEMENT_BINARY_OPERATOR(^, Int);
431 IMPLEMENT_BINARY_OPERATOR(^, ULong);
432 IMPLEMENT_BINARY_OPERATOR(^, Long);
434 cerr << "Unhandled type for Xor instruction: " << *Ty << "\n";
440 #define IMPLEMENT_SETCC(OP, TY) \
441 case Type::TY##TyID: Dest.BoolVal = Src1.TY##Val OP Src2.TY##Val; break
443 // Handle pointers specially because they must be compared with only as much
444 // width as the host has. We _do not_ want to be comparing 64 bit values when
445 // running on a 32-bit target, otherwise the upper 32 bits might mess up
446 // comparisons if they contain garbage.
447 #define IMPLEMENT_POINTERSETCC(OP) \
448 case Type::PointerTyID: \
449 Dest.BoolVal = (void*)(intptr_t)Src1.PointerVal OP \
450 (void*)(intptr_t)Src2.PointerVal; break
452 static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
455 switch (Ty->getTypeID()) {
456 IMPLEMENT_SETCC(==, UByte);
457 IMPLEMENT_SETCC(==, SByte);
458 IMPLEMENT_SETCC(==, UShort);
459 IMPLEMENT_SETCC(==, Short);
460 IMPLEMENT_SETCC(==, UInt);
461 IMPLEMENT_SETCC(==, Int);
462 IMPLEMENT_SETCC(==, ULong);
463 IMPLEMENT_SETCC(==, Long);
464 IMPLEMENT_SETCC(==, Float);
465 IMPLEMENT_SETCC(==, Double);
466 IMPLEMENT_POINTERSETCC(==);
468 cerr << "Unhandled type for SetEQ instruction: " << *Ty << "\n";
474 static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
477 switch (Ty->getTypeID()) {
478 IMPLEMENT_SETCC(!=, UByte);
479 IMPLEMENT_SETCC(!=, SByte);
480 IMPLEMENT_SETCC(!=, UShort);
481 IMPLEMENT_SETCC(!=, Short);
482 IMPLEMENT_SETCC(!=, UInt);
483 IMPLEMENT_SETCC(!=, Int);
484 IMPLEMENT_SETCC(!=, ULong);
485 IMPLEMENT_SETCC(!=, Long);
486 IMPLEMENT_SETCC(!=, Float);
487 IMPLEMENT_SETCC(!=, Double);
488 IMPLEMENT_POINTERSETCC(!=);
491 cerr << "Unhandled type for SetNE instruction: " << *Ty << "\n";
497 static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
500 switch (Ty->getTypeID()) {
501 IMPLEMENT_SETCC(<=, UByte);
502 IMPLEMENT_SETCC(<=, SByte);
503 IMPLEMENT_SETCC(<=, UShort);
504 IMPLEMENT_SETCC(<=, Short);
505 IMPLEMENT_SETCC(<=, UInt);
506 IMPLEMENT_SETCC(<=, Int);
507 IMPLEMENT_SETCC(<=, ULong);
508 IMPLEMENT_SETCC(<=, Long);
509 IMPLEMENT_SETCC(<=, Float);
510 IMPLEMENT_SETCC(<=, Double);
511 IMPLEMENT_POINTERSETCC(<=);
513 cerr << "Unhandled type for SetLE instruction: " << *Ty << "\n";
519 static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
522 switch (Ty->getTypeID()) {
523 IMPLEMENT_SETCC(>=, UByte);
524 IMPLEMENT_SETCC(>=, SByte);
525 IMPLEMENT_SETCC(>=, UShort);
526 IMPLEMENT_SETCC(>=, Short);
527 IMPLEMENT_SETCC(>=, UInt);
528 IMPLEMENT_SETCC(>=, Int);
529 IMPLEMENT_SETCC(>=, ULong);
530 IMPLEMENT_SETCC(>=, Long);
531 IMPLEMENT_SETCC(>=, Float);
532 IMPLEMENT_SETCC(>=, Double);
533 IMPLEMENT_POINTERSETCC(>=);
535 cerr << "Unhandled type for SetGE instruction: " << *Ty << "\n";
541 static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
544 switch (Ty->getTypeID()) {
545 IMPLEMENT_SETCC(<, UByte);
546 IMPLEMENT_SETCC(<, SByte);
547 IMPLEMENT_SETCC(<, UShort);
548 IMPLEMENT_SETCC(<, Short);
549 IMPLEMENT_SETCC(<, UInt);
550 IMPLEMENT_SETCC(<, Int);
551 IMPLEMENT_SETCC(<, ULong);
552 IMPLEMENT_SETCC(<, Long);
553 IMPLEMENT_SETCC(<, Float);
554 IMPLEMENT_SETCC(<, Double);
555 IMPLEMENT_POINTERSETCC(<);
557 cerr << "Unhandled type for SetLT instruction: " << *Ty << "\n";
563 static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
566 switch (Ty->getTypeID()) {
567 IMPLEMENT_SETCC(>, UByte);
568 IMPLEMENT_SETCC(>, SByte);
569 IMPLEMENT_SETCC(>, UShort);
570 IMPLEMENT_SETCC(>, Short);
571 IMPLEMENT_SETCC(>, UInt);
572 IMPLEMENT_SETCC(>, Int);
573 IMPLEMENT_SETCC(>, ULong);
574 IMPLEMENT_SETCC(>, Long);
575 IMPLEMENT_SETCC(>, Float);
576 IMPLEMENT_SETCC(>, Double);
577 IMPLEMENT_POINTERSETCC(>);
579 cerr << "Unhandled type for SetGT instruction: " << *Ty << "\n";
585 void Interpreter::visitBinaryOperator(BinaryOperator &I) {
586 ExecutionContext &SF = ECStack.back();
587 const Type *Ty = I.getOperand(0)->getType();
588 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
589 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
590 GenericValue R; // Result
592 switch (I.getOpcode()) {
593 case Instruction::Add: R = executeAddInst (Src1, Src2, Ty); break;
594 case Instruction::Sub: R = executeSubInst (Src1, Src2, Ty); break;
595 case Instruction::Mul: R = executeMulInst (Src1, Src2, Ty); break;
596 case Instruction::UDiv: R = executeUDivInst (Src1, Src2, Ty); break;
597 case Instruction::SDiv: R = executeSDivInst (Src1, Src2, Ty); break;
598 case Instruction::FDiv: R = executeFDivInst (Src1, Src2, Ty); break;
599 case Instruction::URem: R = executeURemInst (Src1, Src2, Ty); break;
600 case Instruction::SRem: R = executeSRemInst (Src1, Src2, Ty); break;
601 case Instruction::FRem: R = executeFRemInst (Src1, Src2, Ty); break;
602 case Instruction::And: R = executeAndInst (Src1, Src2, Ty); break;
603 case Instruction::Or: R = executeOrInst (Src1, Src2, Ty); break;
604 case Instruction::Xor: R = executeXorInst (Src1, Src2, Ty); break;
605 case Instruction::SetEQ: R = executeSetEQInst(Src1, Src2, Ty); break;
606 case Instruction::SetNE: R = executeSetNEInst(Src1, Src2, Ty); break;
607 case Instruction::SetLE: R = executeSetLEInst(Src1, Src2, Ty); break;
608 case Instruction::SetGE: R = executeSetGEInst(Src1, Src2, Ty); break;
609 case Instruction::SetLT: R = executeSetLTInst(Src1, Src2, Ty); break;
610 case Instruction::SetGT: R = executeSetGTInst(Src1, Src2, Ty); break;
612 cerr << "Don't know how to handle this binary operator!\n-->" << I;
619 static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
621 return Src1.BoolVal ? Src2 : Src3;
624 void Interpreter::visitSelectInst(SelectInst &I) {
625 ExecutionContext &SF = ECStack.back();
626 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
627 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
628 GenericValue Src3 = getOperandValue(I.getOperand(2), SF);
629 GenericValue R = executeSelectInst(Src1, Src2, Src3);
634 //===----------------------------------------------------------------------===//
635 // Terminator Instruction Implementations
636 //===----------------------------------------------------------------------===//
638 void Interpreter::exitCalled(GenericValue GV) {
639 // runAtExitHandlers() assumes there are no stack frames, but
640 // if exit() was called, then it had a stack frame. Blow away
641 // the stack before interpreting atexit handlers.
643 runAtExitHandlers ();
647 /// Pop the last stack frame off of ECStack and then copy the result
648 /// back into the result variable if we are not returning void. The
649 /// result variable may be the ExitValue, or the Value of the calling
650 /// CallInst if there was a previous stack frame. This method may
651 /// invalidate any ECStack iterators you have. This method also takes
652 /// care of switching to the normal destination BB, if we are returning
655 void Interpreter::popStackAndReturnValueToCaller (const Type *RetTy,
656 GenericValue Result) {
657 // Pop the current stack frame.
660 if (ECStack.empty()) { // Finished main. Put result into exit code...
661 if (RetTy && RetTy->isIntegral()) { // Nonvoid return type?
662 ExitValue = Result; // Capture the exit value of the program
664 memset(&ExitValue, 0, sizeof(ExitValue));
667 // If we have a previous stack frame, and we have a previous call,
668 // fill in the return value...
669 ExecutionContext &CallingSF = ECStack.back();
670 if (Instruction *I = CallingSF.Caller.getInstruction()) {
671 if (CallingSF.Caller.getType() != Type::VoidTy) // Save result...
672 SetValue(I, Result, CallingSF);
673 if (InvokeInst *II = dyn_cast<InvokeInst> (I))
674 SwitchToNewBasicBlock (II->getNormalDest (), CallingSF);
675 CallingSF.Caller = CallSite(); // We returned from the call...
680 void Interpreter::visitReturnInst(ReturnInst &I) {
681 ExecutionContext &SF = ECStack.back();
682 const Type *RetTy = Type::VoidTy;
685 // Save away the return value... (if we are not 'ret void')
686 if (I.getNumOperands()) {
687 RetTy = I.getReturnValue()->getType();
688 Result = getOperandValue(I.getReturnValue(), SF);
691 popStackAndReturnValueToCaller(RetTy, Result);
694 void Interpreter::visitUnwindInst(UnwindInst &I) {
699 if (ECStack.empty ())
701 Inst = ECStack.back ().Caller.getInstruction ();
702 } while (!(Inst && isa<InvokeInst> (Inst)));
704 // Return from invoke
705 ExecutionContext &InvokingSF = ECStack.back ();
706 InvokingSF.Caller = CallSite ();
708 // Go to exceptional destination BB of invoke instruction
709 SwitchToNewBasicBlock(cast<InvokeInst>(Inst)->getUnwindDest(), InvokingSF);
712 void Interpreter::visitUnreachableInst(UnreachableInst &I) {
713 cerr << "ERROR: Program executed an 'unreachable' instruction!\n";
717 void Interpreter::visitBranchInst(BranchInst &I) {
718 ExecutionContext &SF = ECStack.back();
721 Dest = I.getSuccessor(0); // Uncond branches have a fixed dest...
722 if (!I.isUnconditional()) {
723 Value *Cond = I.getCondition();
724 if (getOperandValue(Cond, SF).BoolVal == 0) // If false cond...
725 Dest = I.getSuccessor(1);
727 SwitchToNewBasicBlock(Dest, SF);
730 void Interpreter::visitSwitchInst(SwitchInst &I) {
731 ExecutionContext &SF = ECStack.back();
732 GenericValue CondVal = getOperandValue(I.getOperand(0), SF);
733 const Type *ElTy = I.getOperand(0)->getType();
735 // Check to see if any of the cases match...
736 BasicBlock *Dest = 0;
737 for (unsigned i = 2, e = I.getNumOperands(); i != e; i += 2)
738 if (executeSetEQInst(CondVal,
739 getOperandValue(I.getOperand(i), SF), ElTy).BoolVal) {
740 Dest = cast<BasicBlock>(I.getOperand(i+1));
744 if (!Dest) Dest = I.getDefaultDest(); // No cases matched: use default
745 SwitchToNewBasicBlock(Dest, SF);
748 // SwitchToNewBasicBlock - This method is used to jump to a new basic block.
749 // This function handles the actual updating of block and instruction iterators
750 // as well as execution of all of the PHI nodes in the destination block.
752 // This method does this because all of the PHI nodes must be executed
753 // atomically, reading their inputs before any of the results are updated. Not
754 // doing this can cause problems if the PHI nodes depend on other PHI nodes for
755 // their inputs. If the input PHI node is updated before it is read, incorrect
756 // results can happen. Thus we use a two phase approach.
758 void Interpreter::SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF){
759 BasicBlock *PrevBB = SF.CurBB; // Remember where we came from...
760 SF.CurBB = Dest; // Update CurBB to branch destination
761 SF.CurInst = SF.CurBB->begin(); // Update new instruction ptr...
763 if (!isa<PHINode>(SF.CurInst)) return; // Nothing fancy to do
765 // Loop over all of the PHI nodes in the current block, reading their inputs.
766 std::vector<GenericValue> ResultValues;
768 for (; PHINode *PN = dyn_cast<PHINode>(SF.CurInst); ++SF.CurInst) {
769 // Search for the value corresponding to this previous bb...
770 int i = PN->getBasicBlockIndex(PrevBB);
771 assert(i != -1 && "PHINode doesn't contain entry for predecessor??");
772 Value *IncomingValue = PN->getIncomingValue(i);
774 // Save the incoming value for this PHI node...
775 ResultValues.push_back(getOperandValue(IncomingValue, SF));
778 // Now loop over all of the PHI nodes setting their values...
779 SF.CurInst = SF.CurBB->begin();
780 for (unsigned i = 0; isa<PHINode>(SF.CurInst); ++SF.CurInst, ++i) {
781 PHINode *PN = cast<PHINode>(SF.CurInst);
782 SetValue(PN, ResultValues[i], SF);
786 //===----------------------------------------------------------------------===//
787 // Memory Instruction Implementations
788 //===----------------------------------------------------------------------===//
790 void Interpreter::visitAllocationInst(AllocationInst &I) {
791 ExecutionContext &SF = ECStack.back();
793 const Type *Ty = I.getType()->getElementType(); // Type to be allocated
795 // Get the number of elements being allocated by the array...
796 unsigned NumElements = getOperandValue(I.getOperand(0), SF).UIntVal;
798 // Allocate enough memory to hold the type...
799 void *Memory = malloc(NumElements * (size_t)TD.getTypeSize(Ty));
801 GenericValue Result = PTOGV(Memory);
802 assert(Result.PointerVal != 0 && "Null pointer returned by malloc!");
803 SetValue(&I, Result, SF);
805 if (I.getOpcode() == Instruction::Alloca)
806 ECStack.back().Allocas.add(Memory);
809 void Interpreter::visitFreeInst(FreeInst &I) {
810 ExecutionContext &SF = ECStack.back();
811 assert(isa<PointerType>(I.getOperand(0)->getType()) && "Freeing nonptr?");
812 GenericValue Value = getOperandValue(I.getOperand(0), SF);
813 // TODO: Check to make sure memory is allocated
814 free(GVTOP(Value)); // Free memory
817 // getElementOffset - The workhorse for getelementptr.
819 GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
821 ExecutionContext &SF) {
822 assert(isa<PointerType>(Ptr->getType()) &&
823 "Cannot getElementOffset of a nonpointer type!");
827 for (; I != E; ++I) {
828 if (const StructType *STy = dyn_cast<StructType>(*I)) {
829 const StructLayout *SLO = TD.getStructLayout(STy);
831 const ConstantInt *CPU = cast<ConstantInt>(I.getOperand());
832 unsigned Index = unsigned(CPU->getZExtValue());
834 Total += (PointerTy)SLO->MemberOffsets[Index];
836 const SequentialType *ST = cast<SequentialType>(*I);
837 // Get the index number for the array... which must be long type...
838 GenericValue IdxGV = getOperandValue(I.getOperand(), SF);
841 switch (I.getOperand()->getType()->getTypeID()) {
842 default: assert(0 && "Illegal getelementptr index for sequential type!");
843 case Type::SByteTyID: Idx = IdxGV.SByteVal; break;
844 case Type::ShortTyID: Idx = IdxGV.ShortVal; break;
845 case Type::IntTyID: Idx = IdxGV.IntVal; break;
846 case Type::LongTyID: Idx = IdxGV.LongVal; break;
847 case Type::UByteTyID: Idx = IdxGV.UByteVal; break;
848 case Type::UShortTyID: Idx = IdxGV.UShortVal; break;
849 case Type::UIntTyID: Idx = IdxGV.UIntVal; break;
850 case Type::ULongTyID: Idx = IdxGV.ULongVal; break;
852 Total += PointerTy(TD.getTypeSize(ST->getElementType())*Idx);
857 Result.PointerVal = getOperandValue(Ptr, SF).PointerVal + Total;
861 void Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) {
862 ExecutionContext &SF = ECStack.back();
863 SetValue(&I, TheEE->executeGEPOperation(I.getPointerOperand(),
864 gep_type_begin(I), gep_type_end(I), SF), SF);
867 void Interpreter::visitLoadInst(LoadInst &I) {
868 ExecutionContext &SF = ECStack.back();
869 GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
870 GenericValue *Ptr = (GenericValue*)GVTOP(SRC);
871 GenericValue Result = LoadValueFromMemory(Ptr, I.getType());
872 SetValue(&I, Result, SF);
875 void Interpreter::visitStoreInst(StoreInst &I) {
876 ExecutionContext &SF = ECStack.back();
877 GenericValue Val = getOperandValue(I.getOperand(0), SF);
878 GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
879 StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC),
880 I.getOperand(0)->getType());
883 //===----------------------------------------------------------------------===//
884 // Miscellaneous Instruction Implementations
885 //===----------------------------------------------------------------------===//
887 void Interpreter::visitCallSite(CallSite CS) {
888 ExecutionContext &SF = ECStack.back();
890 // Check to see if this is an intrinsic function call...
891 if (Function *F = CS.getCalledFunction())
892 if (F->isExternal ())
893 switch (F->getIntrinsicID()) {
894 case Intrinsic::not_intrinsic:
896 case Intrinsic::vastart: { // va_start
897 GenericValue ArgIndex;
898 ArgIndex.UIntPairVal.first = ECStack.size() - 1;
899 ArgIndex.UIntPairVal.second = 0;
900 SetValue(CS.getInstruction(), ArgIndex, SF);
903 case Intrinsic::vaend: // va_end is a noop for the interpreter
905 case Intrinsic::vacopy: // va_copy: dest = src
906 SetValue(CS.getInstruction(), getOperandValue(*CS.arg_begin(), SF), SF);
909 // If it is an unknown intrinsic function, use the intrinsic lowering
910 // class to transform it into hopefully tasty LLVM code.
912 Instruction *Prev = CS.getInstruction()->getPrev();
913 BasicBlock *Parent = CS.getInstruction()->getParent();
914 IL->LowerIntrinsicCall(cast<CallInst>(CS.getInstruction()));
916 // Restore the CurInst pointer to the first instruction newly inserted, if
919 SF.CurInst = Parent->begin();
928 std::vector<GenericValue> ArgVals;
929 const unsigned NumArgs = SF.Caller.arg_size();
930 ArgVals.reserve(NumArgs);
931 for (CallSite::arg_iterator i = SF.Caller.arg_begin(),
932 e = SF.Caller.arg_end(); i != e; ++i) {
934 ArgVals.push_back(getOperandValue(V, SF));
935 // Promote all integral types whose size is < sizeof(int) into ints. We do
936 // this by zero or sign extending the value as appropriate according to the
938 const Type *Ty = V->getType();
939 if (Ty->isIntegral() && Ty->getPrimitiveSize() < 4) {
940 if (Ty == Type::ShortTy)
941 ArgVals.back().IntVal = ArgVals.back().ShortVal;
942 else if (Ty == Type::UShortTy)
943 ArgVals.back().UIntVal = ArgVals.back().UShortVal;
944 else if (Ty == Type::SByteTy)
945 ArgVals.back().IntVal = ArgVals.back().SByteVal;
946 else if (Ty == Type::UByteTy)
947 ArgVals.back().UIntVal = ArgVals.back().UByteVal;
948 else if (Ty == Type::BoolTy)
949 ArgVals.back().UIntVal = ArgVals.back().BoolVal;
951 assert(0 && "Unknown type!");
955 // To handle indirect calls, we must get the pointer value from the argument
956 // and treat it as a function pointer.
957 GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF);
958 callFunction((Function*)GVTOP(SRC), ArgVals);
961 #define IMPLEMENT_SHIFT(OP, TY) \
962 case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.UByteVal; break
964 #define IMPLEMENT_SIGNLESS_SHIFT(OP, TY1, TY2) \
965 case Type::TY2##TyID: \
966 IMPLEMENT_SHIFT(OP, TY1)
968 static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
971 switch (Ty->getTypeID()) {
972 IMPLEMENT_SHIFT(<<, UByte);
973 IMPLEMENT_SHIFT(<<, SByte);
974 IMPLEMENT_SHIFT(<<, UShort);
975 IMPLEMENT_SHIFT(<<, Short);
976 IMPLEMENT_SHIFT(<<, UInt);
977 IMPLEMENT_SHIFT(<<, Int);
978 IMPLEMENT_SHIFT(<<, ULong);
979 IMPLEMENT_SHIFT(<<, Long);
981 cerr << "Unhandled type for Shl instruction: " << *Ty << "\n";
986 static GenericValue executeLShrInst(GenericValue Src1, GenericValue Src2,
989 switch (Ty->getTypeID()) {
990 IMPLEMENT_SIGNLESS_SHIFT(>>, UByte, SByte);
991 IMPLEMENT_SIGNLESS_SHIFT(>>, UShort, Short);
992 IMPLEMENT_SIGNLESS_SHIFT(>>, UInt, Int);
993 IMPLEMENT_SIGNLESS_SHIFT(>>, ULong, Long);
995 cerr << "Unhandled type for LShr instruction: " << *Ty << "\n";
1001 static GenericValue executeAShrInst(GenericValue Src1, GenericValue Src2,
1004 switch (Ty->getTypeID()) {
1005 IMPLEMENT_SIGNLESS_SHIFT(>>, SByte, UByte);
1006 IMPLEMENT_SIGNLESS_SHIFT(>>, Short, UShort);
1007 IMPLEMENT_SIGNLESS_SHIFT(>>, Int, UInt);
1008 IMPLEMENT_SIGNLESS_SHIFT(>>, Long, ULong);
1010 cerr << "Unhandled type for AShr instruction: " << *Ty << "\n";
1016 void Interpreter::visitShl(ShiftInst &I) {
1017 ExecutionContext &SF = ECStack.back();
1018 const Type *Ty = I.getOperand(0)->getType();
1019 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
1020 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
1022 Dest = executeShlInst (Src1, Src2, Ty);
1023 SetValue(&I, Dest, SF);
1026 void Interpreter::visitLShr(ShiftInst &I) {
1027 ExecutionContext &SF = ECStack.back();
1028 const Type *Ty = I.getOperand(0)->getType();
1029 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
1030 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
1032 Dest = executeLShrInst (Src1, Src2, Ty);
1033 SetValue(&I, Dest, SF);
1036 void Interpreter::visitAShr(ShiftInst &I) {
1037 ExecutionContext &SF = ECStack.back();
1038 const Type *Ty = I.getOperand(0)->getType();
1039 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
1040 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
1042 Dest = executeAShrInst (Src1, Src2, Ty);
1043 SetValue(&I, Dest, SF);
1046 #define IMPLEMENT_CAST_START \
1047 switch (DstTy->getTypeID()) {
1049 #define IMPLEMENT_CAST(DTY, DCTY, STY) \
1050 case Type::STY##TyID: Dest.DTY##Val = DCTY Src.STY##Val; break;
1052 #define IMPLEMENT_CAST_CASE(DESTTY, DESTCTY) \
1053 case Type::DESTTY##TyID: \
1054 switch (SrcTy->getTypeID()) { \
1055 IMPLEMENT_CAST(DESTTY, DESTCTY, Bool); \
1056 IMPLEMENT_CAST(DESTTY, DESTCTY, UByte); \
1057 IMPLEMENT_CAST(DESTTY, DESTCTY, SByte); \
1058 IMPLEMENT_CAST(DESTTY, DESTCTY, UShort); \
1059 IMPLEMENT_CAST(DESTTY, DESTCTY, Short); \
1060 IMPLEMENT_CAST(DESTTY, DESTCTY, UInt); \
1061 IMPLEMENT_CAST(DESTTY, DESTCTY, Int); \
1062 IMPLEMENT_CAST(DESTTY, DESTCTY, ULong); \
1063 IMPLEMENT_CAST(DESTTY, DESTCTY, Long); \
1064 IMPLEMENT_CAST(DESTTY, DESTCTY, Pointer); \
1065 IMPLEMENT_CAST(DESTTY, DESTCTY, Float); \
1066 IMPLEMENT_CAST(DESTTY, DESTCTY, Double) \
1068 cerr << "Unhandled cast: " \
1069 << *SrcTy << " to " << *DstTy << "\n"; \
1074 #define IMPLEMENT_CAST_END \
1076 << "Unhandled dest type for cast instruction: " \
1077 << *DstTy << "\n"; \
1081 GenericValue Interpreter::executeCastOperation(Instruction::CastOps opcode,
1082 Value *SrcVal, const Type *DstTy,
1083 ExecutionContext &SF) {
1084 const Type *SrcTy = SrcVal->getType();
1085 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1087 if (opcode == Instruction::Trunc && DstTy->getTypeID() == Type::BoolTyID) {
1088 // For truncations to bool, we must clear the high order bits of the source
1089 switch (SrcTy->getTypeID()) {
1090 case Type::BoolTyID: Src.BoolVal &= 1; break;
1091 case Type::SByteTyID: Src.SByteVal &= 1; break;
1092 case Type::UByteTyID: Src.UByteVal &= 1; break;
1093 case Type::ShortTyID: Src.ShortVal &= 1; break;
1094 case Type::UShortTyID: Src.UShortVal &= 1; break;
1095 case Type::IntTyID: Src.IntVal &= 1; break;
1096 case Type::UIntTyID: Src.UIntVal &= 1; break;
1097 case Type::LongTyID: Src.LongVal &= 1; break;
1098 case Type::ULongTyID: Src.ULongVal &= 1; break;
1100 assert(0 && "Can't trunc a non-integer!");
1103 } else if (opcode == Instruction::SExt &&
1104 SrcTy->getTypeID() == Type::BoolTyID) {
1105 // For sign extension from bool, we must extend the source bits.
1106 SrcTy = Type::LongTy;
1107 Src.LongVal = 0 - Src.BoolVal;
1111 case Instruction::Trunc: // src integer, dest integral (can't be long)
1112 IMPLEMENT_CAST_START
1113 IMPLEMENT_CAST_CASE(Bool , (bool));
1114 IMPLEMENT_CAST_CASE(UByte , (unsigned char));
1115 IMPLEMENT_CAST_CASE(SByte , ( signed char));
1116 IMPLEMENT_CAST_CASE(UShort , (unsigned short));
1117 IMPLEMENT_CAST_CASE(Short , ( signed short));
1118 IMPLEMENT_CAST_CASE(UInt , (unsigned int ));
1119 IMPLEMENT_CAST_CASE(Int , ( signed int ));
1122 case Instruction::ZExt: // src integral (can't be long), dest integer
1123 IMPLEMENT_CAST_START
1124 IMPLEMENT_CAST_CASE(UByte , (unsigned char));
1125 IMPLEMENT_CAST_CASE(SByte , (signed char)(unsigned char));
1126 IMPLEMENT_CAST_CASE(UShort , (unsigned short));
1127 IMPLEMENT_CAST_CASE(Short , (signed short)(unsigned short));
1128 IMPLEMENT_CAST_CASE(UInt , (unsigned int ));
1129 IMPLEMENT_CAST_CASE(Int , (signed int)(unsigned int ));
1130 IMPLEMENT_CAST_CASE(ULong , (uint64_t));
1131 IMPLEMENT_CAST_CASE(Long , (int64_t)(uint64_t));
1134 case Instruction::SExt: // src integral (can't be long), dest integer
1135 IMPLEMENT_CAST_START
1136 IMPLEMENT_CAST_CASE(UByte , (unsigned char)(signed char));
1137 IMPLEMENT_CAST_CASE(SByte , (signed char));
1138 IMPLEMENT_CAST_CASE(UShort , (unsigned short)(signed short));
1139 IMPLEMENT_CAST_CASE(Short , (signed short));
1140 IMPLEMENT_CAST_CASE(UInt , (unsigned int )(signed int));
1141 IMPLEMENT_CAST_CASE(Int , (signed int));
1142 IMPLEMENT_CAST_CASE(ULong , (uint64_t)(int64_t));
1143 IMPLEMENT_CAST_CASE(Long , (int64_t));
1146 case Instruction::FPTrunc: // src double, dest float
1147 IMPLEMENT_CAST_START
1148 IMPLEMENT_CAST_CASE(Float , (float));
1151 case Instruction::FPExt: // src float, dest double
1152 IMPLEMENT_CAST_START
1153 IMPLEMENT_CAST_CASE(Double , (double));
1156 case Instruction::UIToFP: // src integral, dest floating
1157 IMPLEMENT_CAST_START
1158 IMPLEMENT_CAST_CASE(Float , (float)(uint64_t));
1159 IMPLEMENT_CAST_CASE(Double , (double)(uint64_t));
1162 case Instruction::SIToFP: // src integeral, dest floating
1163 IMPLEMENT_CAST_START
1164 IMPLEMENT_CAST_CASE(Float , (float)(int64_t));
1165 IMPLEMENT_CAST_CASE(Double , (double)(int64_t));
1168 case Instruction::FPToUI: // src floating, dest integral
1169 IMPLEMENT_CAST_START
1170 IMPLEMENT_CAST_CASE(Bool , (bool));
1171 IMPLEMENT_CAST_CASE(UByte , (unsigned char));
1172 IMPLEMENT_CAST_CASE(SByte , (signed char)(unsigned char));
1173 IMPLEMENT_CAST_CASE(UShort , (unsigned short));
1174 IMPLEMENT_CAST_CASE(Short , (signed short)(unsigned short));
1175 IMPLEMENT_CAST_CASE(UInt , (unsigned int ));
1176 IMPLEMENT_CAST_CASE(Int , (signed int)(unsigned int ));
1177 IMPLEMENT_CAST_CASE(ULong , (uint64_t));
1178 IMPLEMENT_CAST_CASE(Long , (int64_t)(uint64_t));
1181 case Instruction::FPToSI: // src floating, dest integral
1182 IMPLEMENT_CAST_START
1183 IMPLEMENT_CAST_CASE(Bool , (bool));
1184 IMPLEMENT_CAST_CASE(UByte , (unsigned char)(signed char));
1185 IMPLEMENT_CAST_CASE(SByte , (signed char));
1186 IMPLEMENT_CAST_CASE(UShort , (unsigned short)(signed short));
1187 IMPLEMENT_CAST_CASE(Short , (signed short));
1188 IMPLEMENT_CAST_CASE(UInt , (unsigned int )(signed int));
1189 IMPLEMENT_CAST_CASE(Int , (signed int));
1190 IMPLEMENT_CAST_CASE(ULong , (uint64_t)(int64_t));
1191 IMPLEMENT_CAST_CASE(Long , (int64_t));
1194 case Instruction::PtrToInt: // src pointer, dest integral
1195 IMPLEMENT_CAST_START
1196 IMPLEMENT_CAST_CASE(Bool , (bool));
1197 IMPLEMENT_CAST_CASE(UByte , (unsigned char));
1198 IMPLEMENT_CAST_CASE(SByte , (signed char)(unsigned char));
1199 IMPLEMENT_CAST_CASE(UShort , (unsigned short));
1200 IMPLEMENT_CAST_CASE(Short , (signed short)(unsigned short));
1201 IMPLEMENT_CAST_CASE(UInt , (unsigned int));
1202 IMPLEMENT_CAST_CASE(Int , (signed int)(unsigned int));
1203 IMPLEMENT_CAST_CASE(ULong , (uint64_t));
1204 IMPLEMENT_CAST_CASE(Long , (int64_t)(uint64_t));
1207 case Instruction::IntToPtr: // src integral, dest pointer
1208 IMPLEMENT_CAST_START
1209 IMPLEMENT_CAST_CASE(Pointer, (PointerTy));
1212 case Instruction::BitCast: // src any, dest any (same size)
1213 IMPLEMENT_CAST_START
1214 IMPLEMENT_CAST_CASE(Bool , (bool));
1215 IMPLEMENT_CAST_CASE(UByte , (unsigned char));
1216 IMPLEMENT_CAST_CASE(SByte , ( signed char));
1217 IMPLEMENT_CAST_CASE(UShort , (unsigned short));
1218 IMPLEMENT_CAST_CASE(Short , ( signed short));
1219 IMPLEMENT_CAST_CASE(UInt , (unsigned int));
1220 IMPLEMENT_CAST_CASE(Int , ( signed int));
1221 IMPLEMENT_CAST_CASE(ULong , (uint64_t));
1222 IMPLEMENT_CAST_CASE(Long , ( int64_t));
1223 IMPLEMENT_CAST_CASE(Pointer, (PointerTy));
1224 IMPLEMENT_CAST_CASE(Float , (float));
1225 IMPLEMENT_CAST_CASE(Double , (double));
1229 cerr << "Invalid cast opcode for cast instruction: " << opcode << "\n";
1235 void Interpreter::visitCastInst(CastInst &I) {
1236 ExecutionContext &SF = ECStack.back();
1237 SetValue(&I, executeCastOperation(I.getOpcode(), I.getOperand(0),
1238 I.getType(), SF), SF);
1241 #define IMPLEMENT_VAARG(TY) \
1242 case Type::TY##TyID: Dest.TY##Val = Src.TY##Val; break
1244 void Interpreter::visitVAArgInst(VAArgInst &I) {
1245 ExecutionContext &SF = ECStack.back();
1247 // Get the incoming valist parameter. LLI treats the valist as a
1248 // (ec-stack-depth var-arg-index) pair.
1249 GenericValue VAList = getOperandValue(I.getOperand(0), SF);
1251 GenericValue Src = ECStack[VAList.UIntPairVal.first]
1252 .VarArgs[VAList.UIntPairVal.second];
1253 const Type *Ty = I.getType();
1254 switch (Ty->getTypeID()) {
1255 IMPLEMENT_VAARG(UByte);
1256 IMPLEMENT_VAARG(SByte);
1257 IMPLEMENT_VAARG(UShort);
1258 IMPLEMENT_VAARG(Short);
1259 IMPLEMENT_VAARG(UInt);
1260 IMPLEMENT_VAARG(Int);
1261 IMPLEMENT_VAARG(ULong);
1262 IMPLEMENT_VAARG(Long);
1263 IMPLEMENT_VAARG(Pointer);
1264 IMPLEMENT_VAARG(Float);
1265 IMPLEMENT_VAARG(Double);
1266 IMPLEMENT_VAARG(Bool);
1268 cerr << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
1272 // Set the Value of this Instruction.
1273 SetValue(&I, Dest, SF);
1275 // Move the pointer to the next vararg.
1276 ++VAList.UIntPairVal.second;
1279 //===----------------------------------------------------------------------===//
1280 // Dispatch and Execution Code
1281 //===----------------------------------------------------------------------===//
1283 //===----------------------------------------------------------------------===//
1284 // callFunction - Execute the specified function...
1286 void Interpreter::callFunction(Function *F,
1287 const std::vector<GenericValue> &ArgVals) {
1288 assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 ||
1289 ECStack.back().Caller.arg_size() == ArgVals.size()) &&
1290 "Incorrect number of arguments passed into function call!");
1291 // Make a new stack frame... and fill it in.
1292 ECStack.push_back(ExecutionContext());
1293 ExecutionContext &StackFrame = ECStack.back();
1294 StackFrame.CurFunction = F;
1296 // Special handling for external functions.
1297 if (F->isExternal()) {
1298 GenericValue Result = callExternalFunction (F, ArgVals);
1299 // Simulate a 'ret' instruction of the appropriate type.
1300 popStackAndReturnValueToCaller (F->getReturnType (), Result);
1304 // Get pointers to first LLVM BB & Instruction in function.
1305 StackFrame.CurBB = F->begin();
1306 StackFrame.CurInst = StackFrame.CurBB->begin();
1308 // Run through the function arguments and initialize their values...
1309 assert((ArgVals.size() == F->arg_size() ||
1310 (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&&
1311 "Invalid number of values passed to function invocation!");
1313 // Handle non-varargs arguments...
1315 for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); AI != E; ++AI, ++i)
1316 SetValue(AI, ArgVals[i], StackFrame);
1318 // Handle varargs arguments...
1319 StackFrame.VarArgs.assign(ArgVals.begin()+i, ArgVals.end());
1322 void Interpreter::run() {
1323 while (!ECStack.empty()) {
1324 // Interpret a single instruction & increment the "PC".
1325 ExecutionContext &SF = ECStack.back(); // Current stack frame
1326 Instruction &I = *SF.CurInst++; // Increment before execute
1328 // Track the number of dynamic instructions executed.
1331 DOUT << "About to interpret: " << I;
1332 visit(I); // Dispatch to one of the visit* methods...