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