← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
 
1
//===-- Execution.cpp - Implement code to simulate the program ------------===//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
//  This file contains the actual instruction interpreter.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#define DEBUG_TYPE "interpreter"
 
15
#include "Interpreter.h"
 
16
#include "llvm/Constants.h"
 
17
#include "llvm/DerivedTypes.h"
 
18
#include "llvm/Instructions.h"
 
19
#include "llvm/CodeGen/IntrinsicLowering.h"
 
20
#include "llvm/Support/GetElementPtrTypeIterator.h"
 
21
#include "llvm/ADT/APInt.h"
 
22
#include "llvm/ADT/Statistic.h"
 
23
#include "llvm/Support/CommandLine.h"
 
24
#include "llvm/Support/Debug.h"
 
25
#include "llvm/Support/ErrorHandling.h"
 
26
#include "llvm/Support/MathExtras.h"
 
27
#include <algorithm>
 
28
#include <cmath>
 
29
using namespace llvm;
 
30
 
 
31
STATISTIC(NumDynamicInsts, "Number of dynamic instructions executed");
 
32
 
 
33
static cl::opt<bool> PrintVolatile("interpreter-print-volatile", cl::Hidden,
 
34
          cl::desc("make the interpreter print every volatile load and store"));
 
35
 
 
36
//===----------------------------------------------------------------------===//
 
37
//                     Various Helper Functions
 
38
//===----------------------------------------------------------------------===//
 
39
 
 
40
static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) {
 
41
  SF.Values[V] = Val;
 
42
}
 
43
 
 
44
//===----------------------------------------------------------------------===//
 
45
//                    Binary Instruction Implementations
 
46
//===----------------------------------------------------------------------===//
 
47
 
 
48
#define IMPLEMENT_BINARY_OPERATOR(OP, TY) \
 
49
   case Type::TY##TyID: \
 
50
     Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; \
 
51
     break
 
52
 
 
53
static void executeFAddInst(GenericValue &Dest, GenericValue Src1,
 
54
                            GenericValue Src2, const Type *Ty) {
 
55
  switch (Ty->getTypeID()) {
 
56
    IMPLEMENT_BINARY_OPERATOR(+, Float);
 
57
    IMPLEMENT_BINARY_OPERATOR(+, Double);
 
58
  default:
 
59
    dbgs() << "Unhandled type for FAdd instruction: " << *Ty << "\n";
 
60
    llvm_unreachable(0);
 
61
  }
 
62
}
 
63
 
 
64
static void executeFSubInst(GenericValue &Dest, GenericValue Src1,
 
65
                            GenericValue Src2, const Type *Ty) {
 
66
  switch (Ty->getTypeID()) {
 
67
    IMPLEMENT_BINARY_OPERATOR(-, Float);
 
68
    IMPLEMENT_BINARY_OPERATOR(-, Double);
 
69
  default:
 
70
    dbgs() << "Unhandled type for FSub instruction: " << *Ty << "\n";
 
71
    llvm_unreachable(0);
 
72
  }
 
73
}
 
74
 
 
75
static void executeFMulInst(GenericValue &Dest, GenericValue Src1,
 
76
                            GenericValue Src2, const Type *Ty) {
 
77
  switch (Ty->getTypeID()) {
 
78
    IMPLEMENT_BINARY_OPERATOR(*, Float);
 
79
    IMPLEMENT_BINARY_OPERATOR(*, Double);
 
80
  default:
 
81
    dbgs() << "Unhandled type for FMul instruction: " << *Ty << "\n";
 
82
    llvm_unreachable(0);
 
83
  }
 
84
}
 
85
 
 
86
static void executeFDivInst(GenericValue &Dest, GenericValue Src1, 
 
87
                            GenericValue Src2, const Type *Ty) {
 
88
  switch (Ty->getTypeID()) {
 
89
    IMPLEMENT_BINARY_OPERATOR(/, Float);
 
90
    IMPLEMENT_BINARY_OPERATOR(/, Double);
 
91
  default:
 
92
    dbgs() << "Unhandled type for FDiv instruction: " << *Ty << "\n";
 
93
    llvm_unreachable(0);
 
94
  }
 
95
}
 
96
 
 
97
static void executeFRemInst(GenericValue &Dest, GenericValue Src1, 
 
98
                            GenericValue Src2, const Type *Ty) {
 
99
  switch (Ty->getTypeID()) {
 
100
  case Type::FloatTyID:
 
101
    Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal);
 
102
    break;
 
103
  case Type::DoubleTyID:
 
104
    Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal);
 
105
    break;
 
106
  default:
 
107
    dbgs() << "Unhandled type for Rem instruction: " << *Ty << "\n";
 
108
    llvm_unreachable(0);
 
109
  }
 
110
}
 
111
 
 
112
#define IMPLEMENT_INTEGER_ICMP(OP, TY) \
 
113
   case Type::IntegerTyID:  \
 
114
      Dest.IntVal = APInt(1,Src1.IntVal.OP(Src2.IntVal)); \
 
115
      break;
 
116
 
 
117
// Handle pointers specially because they must be compared with only as much
 
118
// width as the host has.  We _do not_ want to be comparing 64 bit values when
 
119
// running on a 32-bit target, otherwise the upper 32 bits might mess up
 
120
// comparisons if they contain garbage.
 
121
#define IMPLEMENT_POINTER_ICMP(OP) \
 
122
   case Type::PointerTyID: \
 
123
      Dest.IntVal = APInt(1,(void*)(intptr_t)Src1.PointerVal OP \
 
124
                            (void*)(intptr_t)Src2.PointerVal); \
 
125
      break;
 
126
 
 
127
static GenericValue executeICMP_EQ(GenericValue Src1, GenericValue Src2,
 
128
                                   const Type *Ty) {
 
129
  GenericValue Dest;
 
130
  switch (Ty->getTypeID()) {
 
131
    IMPLEMENT_INTEGER_ICMP(eq,Ty);
 
132
    IMPLEMENT_POINTER_ICMP(==);
 
133
  default:
 
134
    dbgs() << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n";
 
135
    llvm_unreachable(0);
 
136
  }
 
137
  return Dest;
 
138
}
 
139
 
 
140
static GenericValue executeICMP_NE(GenericValue Src1, GenericValue Src2,
 
141
                                   const Type *Ty) {
 
142
  GenericValue Dest;
 
143
  switch (Ty->getTypeID()) {
 
144
    IMPLEMENT_INTEGER_ICMP(ne,Ty);
 
145
    IMPLEMENT_POINTER_ICMP(!=);
 
146
  default:
 
147
    dbgs() << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n";
 
148
    llvm_unreachable(0);
 
149
  }
 
150
  return Dest;
 
151
}
 
152
 
 
153
static GenericValue executeICMP_ULT(GenericValue Src1, GenericValue Src2,
 
154
                                    const Type *Ty) {
 
155
  GenericValue Dest;
 
156
  switch (Ty->getTypeID()) {
 
157
    IMPLEMENT_INTEGER_ICMP(ult,Ty);
 
158
    IMPLEMENT_POINTER_ICMP(<);
 
159
  default:
 
160
    dbgs() << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n";
 
161
    llvm_unreachable(0);
 
162
  }
 
163
  return Dest;
 
164
}
 
165
 
 
166
static GenericValue executeICMP_SLT(GenericValue Src1, GenericValue Src2,
 
167
                                    const Type *Ty) {
 
168
  GenericValue Dest;
 
169
  switch (Ty->getTypeID()) {
 
170
    IMPLEMENT_INTEGER_ICMP(slt,Ty);
 
171
    IMPLEMENT_POINTER_ICMP(<);
 
172
  default:
 
173
    dbgs() << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n";
 
174
    llvm_unreachable(0);
 
175
  }
 
176
  return Dest;
 
177
}
 
178
 
 
179
static GenericValue executeICMP_UGT(GenericValue Src1, GenericValue Src2,
 
180
                                    const Type *Ty) {
 
181
  GenericValue Dest;
 
182
  switch (Ty->getTypeID()) {
 
183
    IMPLEMENT_INTEGER_ICMP(ugt,Ty);
 
184
    IMPLEMENT_POINTER_ICMP(>);
 
185
  default:
 
186
    dbgs() << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n";
 
187
    llvm_unreachable(0);
 
188
  }
 
189
  return Dest;
 
190
}
 
191
 
 
192
static GenericValue executeICMP_SGT(GenericValue Src1, GenericValue Src2,
 
193
                                    const Type *Ty) {
 
194
  GenericValue Dest;
 
195
  switch (Ty->getTypeID()) {
 
196
    IMPLEMENT_INTEGER_ICMP(sgt,Ty);
 
197
    IMPLEMENT_POINTER_ICMP(>);
 
198
  default:
 
199
    dbgs() << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n";
 
200
    llvm_unreachable(0);
 
201
  }
 
202
  return Dest;
 
203
}
 
204
 
 
205
static GenericValue executeICMP_ULE(GenericValue Src1, GenericValue Src2,
 
206
                                    const Type *Ty) {
 
207
  GenericValue Dest;
 
208
  switch (Ty->getTypeID()) {
 
209
    IMPLEMENT_INTEGER_ICMP(ule,Ty);
 
210
    IMPLEMENT_POINTER_ICMP(<=);
 
211
  default:
 
212
    dbgs() << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n";
 
213
    llvm_unreachable(0);
 
214
  }
 
215
  return Dest;
 
216
}
 
217
 
 
218
static GenericValue executeICMP_SLE(GenericValue Src1, GenericValue Src2,
 
219
                                    const Type *Ty) {
 
220
  GenericValue Dest;
 
221
  switch (Ty->getTypeID()) {
 
222
    IMPLEMENT_INTEGER_ICMP(sle,Ty);
 
223
    IMPLEMENT_POINTER_ICMP(<=);
 
224
  default:
 
225
    dbgs() << "Unhandled type for ICMP_SLE predicate: " << *Ty << "\n";
 
226
    llvm_unreachable(0);
 
227
  }
 
228
  return Dest;
 
229
}
 
230
 
 
231
static GenericValue executeICMP_UGE(GenericValue Src1, GenericValue Src2,
 
232
                                    const Type *Ty) {
 
233
  GenericValue Dest;
 
234
  switch (Ty->getTypeID()) {
 
235
    IMPLEMENT_INTEGER_ICMP(uge,Ty);
 
236
    IMPLEMENT_POINTER_ICMP(>=);
 
237
  default:
 
238
    dbgs() << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n";
 
239
    llvm_unreachable(0);
 
240
  }
 
241
  return Dest;
 
242
}
 
243
 
 
244
static GenericValue executeICMP_SGE(GenericValue Src1, GenericValue Src2,
 
245
                                    const Type *Ty) {
 
246
  GenericValue Dest;
 
247
  switch (Ty->getTypeID()) {
 
248
    IMPLEMENT_INTEGER_ICMP(sge,Ty);
 
249
    IMPLEMENT_POINTER_ICMP(>=);
 
250
  default:
 
251
    dbgs() << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n";
 
252
    llvm_unreachable(0);
 
253
  }
 
254
  return Dest;
 
255
}
 
256
 
 
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()) {
 
265
  case ICmpInst::ICMP_EQ:  R = executeICMP_EQ(Src1,  Src2, Ty); break;
 
266
  case ICmpInst::ICMP_NE:  R = executeICMP_NE(Src1,  Src2, Ty); break;
 
267
  case ICmpInst::ICMP_ULT: R = executeICMP_ULT(Src1, Src2, Ty); break;
 
268
  case ICmpInst::ICMP_SLT: R = executeICMP_SLT(Src1, Src2, Ty); break;
 
269
  case ICmpInst::ICMP_UGT: R = executeICMP_UGT(Src1, Src2, Ty); break;
 
270
  case ICmpInst::ICMP_SGT: R = executeICMP_SGT(Src1, Src2, Ty); break;
 
271
  case ICmpInst::ICMP_ULE: R = executeICMP_ULE(Src1, Src2, Ty); break;
 
272
  case ICmpInst::ICMP_SLE: R = executeICMP_SLE(Src1, Src2, Ty); break;
 
273
  case ICmpInst::ICMP_UGE: R = executeICMP_UGE(Src1, Src2, Ty); break;
 
274
  case ICmpInst::ICMP_SGE: R = executeICMP_SGE(Src1, Src2, Ty); break;
 
275
  default:
 
276
    dbgs() << "Don't know how to handle this ICmp predicate!\n-->" << I;
 
277
    llvm_unreachable(0);
 
278
  }
 
279
 
 
280
  SetValue(&I, R, SF);
 
281
}
 
282
 
 
283
#define IMPLEMENT_FCMP(OP, TY) \
 
284
   case Type::TY##TyID: \
 
285
     Dest.IntVal = APInt(1,Src1.TY##Val OP Src2.TY##Val); \
 
286
     break
 
287
 
 
288
static GenericValue executeFCMP_OEQ(GenericValue Src1, GenericValue Src2,
 
289
                                   const Type *Ty) {
 
290
  GenericValue Dest;
 
291
  switch (Ty->getTypeID()) {
 
292
    IMPLEMENT_FCMP(==, Float);
 
293
    IMPLEMENT_FCMP(==, Double);
 
294
  default:
 
295
    dbgs() << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n";
 
296
    llvm_unreachable(0);
 
297
  }
 
298
  return Dest;
 
299
}
 
300
 
 
301
static GenericValue executeFCMP_ONE(GenericValue Src1, GenericValue Src2,
 
302
                                   const Type *Ty) {
 
303
  GenericValue Dest;
 
304
  switch (Ty->getTypeID()) {
 
305
    IMPLEMENT_FCMP(!=, Float);
 
306
    IMPLEMENT_FCMP(!=, Double);
 
307
 
 
308
  default:
 
309
    dbgs() << "Unhandled type for FCmp NE instruction: " << *Ty << "\n";
 
310
    llvm_unreachable(0);
 
311
  }
 
312
  return Dest;
 
313
}
 
314
 
 
315
static GenericValue executeFCMP_OLE(GenericValue Src1, GenericValue Src2,
 
316
                                   const Type *Ty) {
 
317
  GenericValue Dest;
 
318
  switch (Ty->getTypeID()) {
 
319
    IMPLEMENT_FCMP(<=, Float);
 
320
    IMPLEMENT_FCMP(<=, Double);
 
321
  default:
 
322
    dbgs() << "Unhandled type for FCmp LE instruction: " << *Ty << "\n";
 
323
    llvm_unreachable(0);
 
324
  }
 
325
  return Dest;
 
326
}
 
327
 
 
328
static GenericValue executeFCMP_OGE(GenericValue Src1, GenericValue Src2,
 
329
                                   const Type *Ty) {
 
330
  GenericValue Dest;
 
331
  switch (Ty->getTypeID()) {
 
332
    IMPLEMENT_FCMP(>=, Float);
 
333
    IMPLEMENT_FCMP(>=, Double);
 
334
  default:
 
335
    dbgs() << "Unhandled type for FCmp GE instruction: " << *Ty << "\n";
 
336
    llvm_unreachable(0);
 
337
  }
 
338
  return Dest;
 
339
}
 
340
 
 
341
static GenericValue executeFCMP_OLT(GenericValue Src1, GenericValue Src2,
 
342
                                   const Type *Ty) {
 
343
  GenericValue Dest;
 
344
  switch (Ty->getTypeID()) {
 
345
    IMPLEMENT_FCMP(<, Float);
 
346
    IMPLEMENT_FCMP(<, Double);
 
347
  default:
 
348
    dbgs() << "Unhandled type for FCmp LT instruction: " << *Ty << "\n";
 
349
    llvm_unreachable(0);
 
350
  }
 
351
  return Dest;
 
352
}
 
353
 
 
354
static GenericValue executeFCMP_OGT(GenericValue Src1, GenericValue Src2,
 
355
                                     const Type *Ty) {
 
356
  GenericValue Dest;
 
357
  switch (Ty->getTypeID()) {
 
358
    IMPLEMENT_FCMP(>, Float);
 
359
    IMPLEMENT_FCMP(>, Double);
 
360
  default:
 
361
    dbgs() << "Unhandled type for FCmp GT instruction: " << *Ty << "\n";
 
362
    llvm_unreachable(0);
 
363
  }
 
364
  return Dest;
 
365
}
 
366
 
 
367
#define IMPLEMENT_UNORDERED(TY, X,Y)                                     \
 
368
  if (TY->isFloatTy()) {                                                 \
 
369
    if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) {          \
 
370
      Dest.IntVal = APInt(1,true);                                       \
 
371
      return Dest;                                                       \
 
372
    }                                                                    \
 
373
  } else if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) { \
 
374
    Dest.IntVal = APInt(1,true);                                         \
 
375
    return Dest;                                                         \
 
376
  }
 
377
 
 
378
 
 
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;
 
424
  if (Ty->isFloatTy())
 
425
    Dest.IntVal = APInt(1,(Src1.FloatVal == Src1.FloatVal && 
 
426
                           Src2.FloatVal == Src2.FloatVal));
 
427
  else
 
428
    Dest.IntVal = APInt(1,(Src1.DoubleVal == Src1.DoubleVal && 
 
429
                           Src2.DoubleVal == Src2.DoubleVal));
 
430
  return Dest;
 
431
}
 
432
 
 
433
static GenericValue executeFCMP_UNO(GenericValue Src1, GenericValue Src2,
 
434
                                     const Type *Ty) {
 
435
  GenericValue Dest;
 
436
  if (Ty->isFloatTy())
 
437
    Dest.IntVal = APInt(1,(Src1.FloatVal != Src1.FloatVal || 
 
438
                           Src2.FloatVal != Src2.FloatVal));
 
439
  else
 
440
    Dest.IntVal = APInt(1,(Src1.DoubleVal != Src1.DoubleVal || 
 
441
                           Src2.DoubleVal != Src2.DoubleVal));
 
442
  return Dest;
 
443
}
 
444
 
 
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()) {
 
453
  case FCmpInst::FCMP_FALSE: R.IntVal = APInt(1,false); break;
 
454
  case FCmpInst::FCMP_TRUE:  R.IntVal = APInt(1,true); break;
 
455
  case FCmpInst::FCMP_ORD:   R = executeFCMP_ORD(Src1, Src2, Ty); break;
 
456
  case FCmpInst::FCMP_UNO:   R = executeFCMP_UNO(Src1, Src2, Ty); break;
 
457
  case FCmpInst::FCMP_UEQ:   R = executeFCMP_UEQ(Src1, Src2, Ty); break;
 
458
  case FCmpInst::FCMP_OEQ:   R = executeFCMP_OEQ(Src1, Src2, Ty); break;
 
459
  case FCmpInst::FCMP_UNE:   R = executeFCMP_UNE(Src1, Src2, Ty); break;
 
460
  case FCmpInst::FCMP_ONE:   R = executeFCMP_ONE(Src1, Src2, Ty); break;
 
461
  case FCmpInst::FCMP_ULT:   R = executeFCMP_ULT(Src1, Src2, Ty); break;
 
462
  case FCmpInst::FCMP_OLT:   R = executeFCMP_OLT(Src1, Src2, Ty); break;
 
463
  case FCmpInst::FCMP_UGT:   R = executeFCMP_UGT(Src1, Src2, Ty); break;
 
464
  case FCmpInst::FCMP_OGT:   R = executeFCMP_OGT(Src1, Src2, Ty); break;
 
465
  case FCmpInst::FCMP_ULE:   R = executeFCMP_ULE(Src1, Src2, Ty); break;
 
466
  case FCmpInst::FCMP_OLE:   R = executeFCMP_OLE(Src1, Src2, Ty); break;
 
467
  case FCmpInst::FCMP_UGE:   R = executeFCMP_UGE(Src1, Src2, Ty); break;
 
468
  case FCmpInst::FCMP_OGE:   R = executeFCMP_OGE(Src1, Src2, Ty); break;
 
469
  default:
 
470
    dbgs() << "Don't know how to handle this FCmp predicate!\n-->" << I;
 
471
    llvm_unreachable(0);
 
472
  }
 
473
 
 
474
  SetValue(&I, R, SF);
 
475
}
 
476
 
 
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);
 
491
  case FCmpInst::FCMP_ORD:   return executeFCMP_ORD(Src1, Src2, Ty);
 
492
  case FCmpInst::FCMP_UNO:   return executeFCMP_UNO(Src1, Src2, Ty);
 
493
  case FCmpInst::FCMP_OEQ:   return executeFCMP_OEQ(Src1, Src2, Ty);
 
494
  case FCmpInst::FCMP_UEQ:   return executeFCMP_UEQ(Src1, Src2, Ty);
 
495
  case FCmpInst::FCMP_ONE:   return executeFCMP_ONE(Src1, Src2, Ty);
 
496
  case FCmpInst::FCMP_UNE:   return executeFCMP_UNE(Src1, Src2, Ty);
 
497
  case FCmpInst::FCMP_OLT:   return executeFCMP_OLT(Src1, Src2, Ty);
 
498
  case FCmpInst::FCMP_ULT:   return executeFCMP_ULT(Src1, Src2, Ty);
 
499
  case FCmpInst::FCMP_OGT:   return executeFCMP_OGT(Src1, Src2, Ty);
 
500
  case FCmpInst::FCMP_UGT:   return executeFCMP_UGT(Src1, Src2, Ty);
 
501
  case FCmpInst::FCMP_OLE:   return executeFCMP_OLE(Src1, Src2, Ty);
 
502
  case FCmpInst::FCMP_ULE:   return executeFCMP_ULE(Src1, Src2, Ty);
 
503
  case FCmpInst::FCMP_OGE:   return executeFCMP_OGE(Src1, Src2, Ty);
 
504
  case FCmpInst::FCMP_UGE:   return executeFCMP_UGE(Src1, Src2, Ty);
 
505
  case FCmpInst::FCMP_FALSE: { 
 
506
    GenericValue Result;
 
507
    Result.IntVal = APInt(1, false);
 
508
    return Result;
 
509
  }
 
510
  case FCmpInst::FCMP_TRUE: {
 
511
    GenericValue Result;
 
512
    Result.IntVal = APInt(1, true);
 
513
    return Result;
 
514
  }
 
515
  default:
 
516
    dbgs() << "Unhandled Cmp predicate\n";
 
517
    llvm_unreachable(0);
 
518
  }
 
519
}
 
520
 
 
521
void Interpreter::visitBinaryOperator(BinaryOperator &I) {
 
522
  ExecutionContext &SF = ECStack.back();
 
523
  const Type *Ty    = I.getOperand(0)->getType();
 
524
  GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
 
525
  GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
 
526
  GenericValue R;   // Result
 
527
 
 
528
  switch (I.getOpcode()) {
 
529
  case Instruction::Add:   R.IntVal = Src1.IntVal + Src2.IntVal; break;
 
530
  case Instruction::Sub:   R.IntVal = Src1.IntVal - Src2.IntVal; break;
 
531
  case Instruction::Mul:   R.IntVal = Src1.IntVal * Src2.IntVal; break;
 
532
  case Instruction::FAdd:  executeFAddInst(R, Src1, Src2, Ty); break;
 
533
  case Instruction::FSub:  executeFSubInst(R, Src1, Src2, Ty); break;
 
534
  case Instruction::FMul:  executeFMulInst(R, Src1, Src2, Ty); break;
 
535
  case Instruction::FDiv:  executeFDivInst(R, Src1, Src2, Ty); break;
 
536
  case Instruction::FRem:  executeFRemInst(R, Src1, Src2, Ty); break;
 
537
  case Instruction::UDiv:  R.IntVal = Src1.IntVal.udiv(Src2.IntVal); break;
 
538
  case Instruction::SDiv:  R.IntVal = Src1.IntVal.sdiv(Src2.IntVal); break;
 
539
  case Instruction::URem:  R.IntVal = Src1.IntVal.urem(Src2.IntVal); break;
 
540
  case Instruction::SRem:  R.IntVal = Src1.IntVal.srem(Src2.IntVal); break;
 
541
  case Instruction::And:   R.IntVal = Src1.IntVal & Src2.IntVal; break;
 
542
  case Instruction::Or:    R.IntVal = Src1.IntVal | Src2.IntVal; break;
 
543
  case Instruction::Xor:   R.IntVal = Src1.IntVal ^ Src2.IntVal; break;
 
544
  default:
 
545
    dbgs() << "Don't know how to handle this binary operator!\n-->" << I;
 
546
    llvm_unreachable(0);
 
547
  }
 
548
 
 
549
  SetValue(&I, R, SF);
 
550
}
 
551
 
 
552
static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
 
553
                                      GenericValue Src3) {
 
554
  return Src1.IntVal == 0 ? Src3 : Src2;
 
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);
 
562
  GenericValue R = executeSelectInst(Src1, Src2, Src3);
 
563
  SetValue(&I, R, SF);
 
564
}
 
565
 
 
566
 
 
567
//===----------------------------------------------------------------------===//
 
568
//                     Terminator Instruction Implementations
 
569
//===----------------------------------------------------------------------===//
 
570
 
 
571
void Interpreter::exitCalled(GenericValue GV) {
 
572
  // runAtExitHandlers() assumes there are no stack frames, but
 
573
  // if exit() was called, then it had a stack frame. Blow away
 
574
  // the stack before interpreting atexit handlers.
 
575
  ECStack.clear();
 
576
  runAtExitHandlers();
 
577
  exit(GV.IntVal.zextOrTrunc(32).getZExtValue());
 
578
}
 
579
 
 
580
/// Pop the last stack frame off of ECStack and then copy the result
 
581
/// back into the result variable if we are not returning void. The
 
582
/// result variable may be the ExitValue, or the Value of the calling
 
583
/// CallInst if there was a previous stack frame. This method may
 
584
/// invalidate any ECStack iterators you have. This method also takes
 
585
/// care of switching to the normal destination BB, if we are returning
 
586
/// from an invoke.
 
587
///
 
588
void Interpreter::popStackAndReturnValueToCaller(const Type *RetTy,
 
589
                                                 GenericValue Result) {
 
590
  // Pop the current stack frame.
 
591
  ECStack.pop_back();
 
592
 
 
593
  if (ECStack.empty()) {  // Finished main.  Put result into exit code...
 
594
    if (RetTy && RetTy->isIntegerTy()) {          // Nonvoid return type?
 
595
      ExitValue = Result;   // Capture the exit value of the program
 
596
    } else {
 
597
      memset(&ExitValue.Untyped, 0, sizeof(ExitValue.Untyped));
 
598
    }
 
599
  } else {
 
600
    // If we have a previous stack frame, and we have a previous call,
 
601
    // fill in the return value...
 
602
    ExecutionContext &CallingSF = ECStack.back();
 
603
    if (Instruction *I = CallingSF.Caller.getInstruction()) {
 
604
      // Save result...
 
605
      if (!CallingSF.Caller.getType()->isVoidTy())
 
606
        SetValue(I, Result, CallingSF);
 
607
      if (InvokeInst *II = dyn_cast<InvokeInst> (I))
 
608
        SwitchToNewBasicBlock (II->getNormalDest (), CallingSF);
 
609
      CallingSF.Caller = CallSite();          // We returned from the call...
 
610
    }
 
611
  }
 
612
}
 
613
 
 
614
void Interpreter::visitReturnInst(ReturnInst &I) {
 
615
  ExecutionContext &SF = ECStack.back();
 
616
  const Type *RetTy = Type::getVoidTy(I.getContext());
 
617
  GenericValue Result;
 
618
 
 
619
  // Save away the return value... (if we are not 'ret void')
 
620
  if (I.getNumOperands()) {
 
621
    RetTy  = I.getReturnValue()->getType();
 
622
    Result = getOperandValue(I.getReturnValue(), SF);
 
623
  }
 
624
 
 
625
  popStackAndReturnValueToCaller(RetTy, Result);
 
626
}
 
627
 
 
628
void Interpreter::visitUnwindInst(UnwindInst &I) {
 
629
  // Unwind stack
 
630
  Instruction *Inst;
 
631
  do {
 
632
    ECStack.pop_back();
 
633
    if (ECStack.empty())
 
634
      llvm_report_error("Empty stack during unwind!");
 
635
    Inst = ECStack.back().Caller.getInstruction();
 
636
  } while (!(Inst && isa<InvokeInst>(Inst)));
 
637
 
 
638
  // Return from invoke
 
639
  ExecutionContext &InvokingSF = ECStack.back();
 
640
  InvokingSF.Caller = CallSite();
 
641
 
 
642
  // Go to exceptional destination BB of invoke instruction
 
643
  SwitchToNewBasicBlock(cast<InvokeInst>(Inst)->getUnwindDest(), InvokingSF);
 
644
}
 
645
 
 
646
void Interpreter::visitUnreachableInst(UnreachableInst &I) {
 
647
  llvm_report_error("Program executed an 'unreachable' instruction!");
 
648
}
 
649
 
 
650
void Interpreter::visitBranchInst(BranchInst &I) {
 
651
  ExecutionContext &SF = ECStack.back();
 
652
  BasicBlock *Dest;
 
653
 
 
654
  Dest = I.getSuccessor(0);          // Uncond branches have a fixed dest...
 
655
  if (!I.isUnconditional()) {
 
656
    Value *Cond = I.getCondition();
 
657
    if (getOperandValue(Cond, SF).IntVal == 0) // If false cond...
 
658
      Dest = I.getSuccessor(1);
 
659
  }
 
660
  SwitchToNewBasicBlock(Dest, SF);
 
661
}
 
662
 
 
663
void Interpreter::visitSwitchInst(SwitchInst &I) {
 
664
  ExecutionContext &SF = ECStack.back();
 
665
  GenericValue CondVal = getOperandValue(I.getOperand(0), SF);
 
666
  const Type *ElTy = I.getOperand(0)->getType();
 
667
 
 
668
  // Check to see if any of the cases match...
 
669
  BasicBlock *Dest = 0;
 
670
  for (unsigned i = 2, e = I.getNumOperands(); i != e; i += 2)
 
671
    if (executeICMP_EQ(CondVal, getOperandValue(I.getOperand(i), SF), ElTy)
 
672
        .IntVal != 0) {
 
673
      Dest = cast<BasicBlock>(I.getOperand(i+1));
 
674
      break;
 
675
    }
 
676
 
 
677
  if (!Dest) Dest = I.getDefaultDest();   // No cases matched: use default
 
678
  SwitchToNewBasicBlock(Dest, SF);
 
679
}
 
680
 
 
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
 
 
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);
 
713
 
 
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();
 
720
  for (unsigned i = 0; isa<PHINode>(SF.CurInst); ++SF.CurInst, ++i) {
 
721
    PHINode *PN = cast<PHINode>(SF.CurInst);
 
722
    SetValue(PN, ResultValues[i], SF);
 
723
  }
 
724
}
 
725
 
 
726
//===----------------------------------------------------------------------===//
 
727
//                     Memory Instruction Implementations
 
728
//===----------------------------------------------------------------------===//
 
729
 
 
730
void Interpreter::visitAllocaInst(AllocaInst &I) {
 
731
  ExecutionContext &SF = ECStack.back();
 
732
 
 
733
  const Type *Ty = I.getType()->getElementType();  // Type to be allocated
 
734
 
 
735
  // Get the number of elements being allocated by the array...
 
736
  unsigned NumElements = 
 
737
    getOperandValue(I.getOperand(0), SF).IntVal.getZExtValue();
 
738
 
 
739
  unsigned TypeSize = (size_t)TD.getTypeAllocSize(Ty);
 
740
 
 
741
  // Avoid malloc-ing zero bytes, use max()...
 
742
  unsigned MemToAlloc = std::max(1U, NumElements * TypeSize);
 
743
 
 
744
  // Allocate enough memory to hold the type...
 
745
  void *Memory = malloc(MemToAlloc);
 
746
 
 
747
  DEBUG(dbgs() << "Allocated Type: " << *Ty << " (" << TypeSize << " bytes) x " 
 
748
               << NumElements << " (Total: " << MemToAlloc << ") at "
 
749
               << uintptr_t(Memory) << '\n');
 
750
 
 
751
  GenericValue Result = PTOGV(Memory);
 
752
  assert(Result.PointerVal != 0 && "Null pointer returned by malloc!");
 
753
  SetValue(&I, Result, SF);
 
754
 
 
755
  if (I.getOpcode() == Instruction::Alloca)
 
756
    ECStack.back().Allocas.add(Memory);
 
757
}
 
758
 
 
759
// getElementOffset - The workhorse for getelementptr.
 
760
//
 
761
GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
 
762
                                              gep_type_iterator E,
 
763
                                              ExecutionContext &SF) {
 
764
  assert(Ptr->getType()->isPointerTy() &&
 
765
         "Cannot getElementOffset of a nonpointer type!");
 
766
 
 
767
  uint64_t Total = 0;
 
768
 
 
769
  for (; I != E; ++I) {
 
770
    if (const StructType *STy = dyn_cast<StructType>(*I)) {
 
771
      const StructLayout *SLO = TD.getStructLayout(STy);
 
772
 
 
773
      const ConstantInt *CPU = cast<ConstantInt>(I.getOperand());
 
774
      unsigned Index = unsigned(CPU->getZExtValue());
 
775
 
 
776
      Total += SLO->getElementOffset(Index);
 
777
    } else {
 
778
      const SequentialType *ST = cast<SequentialType>(*I);
 
779
      // Get the index number for the array... which must be long type...
 
780
      GenericValue IdxGV = getOperandValue(I.getOperand(), SF);
 
781
 
 
782
      int64_t Idx;
 
783
      unsigned BitWidth = 
 
784
        cast<IntegerType>(I.getOperand()->getType())->getBitWidth();
 
785
      if (BitWidth == 32)
 
786
        Idx = (int64_t)(int32_t)IdxGV.IntVal.getZExtValue();
 
787
      else {
 
788
        assert(BitWidth == 64 && "Invalid index type for getelementptr");
 
789
        Idx = (int64_t)IdxGV.IntVal.getZExtValue();
 
790
      }
 
791
      Total += TD.getTypeAllocSize(ST->getElementType())*Idx;
 
792
    }
 
793
  }
 
794
 
 
795
  GenericValue Result;
 
796
  Result.PointerVal = ((char*)getOperandValue(Ptr, SF).PointerVal) + Total;
 
797
  DEBUG(dbgs() << "GEP Index " << Total << " bytes.\n");
 
798
  return Result;
 
799
}
 
800
 
 
801
void Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) {
 
802
  ExecutionContext &SF = ECStack.back();
 
803
  SetValue(&I, executeGEPOperation(I.getPointerOperand(),
 
804
                                   gep_type_begin(I), gep_type_end(I), SF), SF);
 
805
}
 
806
 
 
807
void Interpreter::visitLoadInst(LoadInst &I) {
 
808
  ExecutionContext &SF = ECStack.back();
 
809
  GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
 
810
  GenericValue *Ptr = (GenericValue*)GVTOP(SRC);
 
811
  GenericValue Result;
 
812
  LoadValueFromMemory(Result, Ptr, I.getType());
 
813
  SetValue(&I, Result, SF);
 
814
  if (I.isVolatile() && PrintVolatile)
 
815
    dbgs() << "Volatile load " << I;
 
816
}
 
817
 
 
818
void Interpreter::visitStoreInst(StoreInst &I) {
 
819
  ExecutionContext &SF = ECStack.back();
 
820
  GenericValue Val = getOperandValue(I.getOperand(0), SF);
 
821
  GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
 
822
  StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC),
 
823
                     I.getOperand(0)->getType());
 
824
  if (I.isVolatile() && PrintVolatile)
 
825
    dbgs() << "Volatile store: " << I;
 
826
}
 
827
 
 
828
//===----------------------------------------------------------------------===//
 
829
//                 Miscellaneous Instruction Implementations
 
830
//===----------------------------------------------------------------------===//
 
831
 
 
832
void Interpreter::visitCallSite(CallSite CS) {
 
833
  ExecutionContext &SF = ECStack.back();
 
834
 
 
835
  // Check to see if this is an intrinsic function call...
 
836
  Function *F = CS.getCalledFunction();
 
837
  if (F && F->isDeclaration())
 
838
    switch (F->getIntrinsicID()) {
 
839
    case Intrinsic::not_intrinsic:
 
840
      break;
 
841
    case Intrinsic::vastart: { // va_start
 
842
      GenericValue ArgIndex;
 
843
      ArgIndex.UIntPairVal.first = ECStack.size() - 1;
 
844
      ArgIndex.UIntPairVal.second = 0;
 
845
      SetValue(CS.getInstruction(), ArgIndex, SF);
 
846
      return;
 
847
    }
 
848
    case Intrinsic::vaend:    // va_end is a noop for the interpreter
 
849
      return;
 
850
    case Intrinsic::vacopy:   // va_copy: dest = src
 
851
      SetValue(CS.getInstruction(), getOperandValue(*CS.arg_begin(), SF), SF);
 
852
      return;
 
853
    default:
 
854
      // If it is an unknown intrinsic function, use the intrinsic lowering
 
855
      // class to transform it into hopefully tasty LLVM code.
 
856
      //
 
857
      BasicBlock::iterator me(CS.getInstruction());
 
858
      BasicBlock *Parent = CS.getInstruction()->getParent();
 
859
      bool atBegin(Parent->begin() == me);
 
860
      if (!atBegin)
 
861
        --me;
 
862
      IL->LowerIntrinsicCall(cast<CallInst>(CS.getInstruction()));
 
863
 
 
864
      // Restore the CurInst pointer to the first instruction newly inserted, if
 
865
      // any.
 
866
      if (atBegin) {
 
867
        SF.CurInst = Parent->begin();
 
868
      } else {
 
869
        SF.CurInst = me;
 
870
        ++SF.CurInst;
 
871
      }
 
872
      return;
 
873
    }
 
874
 
 
875
 
 
876
  SF.Caller = CS;
 
877
  std::vector<GenericValue> ArgVals;
 
878
  const unsigned NumArgs = SF.Caller.arg_size();
 
879
  ArgVals.reserve(NumArgs);
 
880
  uint16_t pNum = 1;
 
881
  for (CallSite::arg_iterator i = SF.Caller.arg_begin(),
 
882
         e = SF.Caller.arg_end(); i != e; ++i, ++pNum) {
 
883
    Value *V = *i;
 
884
    ArgVals.push_back(getOperandValue(V, SF));
 
885
  }
 
886
 
 
887
  // To handle indirect calls, we must get the pointer value from the argument
 
888
  // and treat it as a function pointer.
 
889
  GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF);
 
890
  callFunction((Function*)GVTOP(SRC), ArgVals);
 
891
}
 
892
 
 
893
void Interpreter::visitShl(BinaryOperator &I) {
 
894
  ExecutionContext &SF = ECStack.back();
 
895
  GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
 
896
  GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
 
897
  GenericValue Dest;
 
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
  
 
903
  SetValue(&I, Dest, SF);
 
904
}
 
905
 
 
906
void Interpreter::visitLShr(BinaryOperator &I) {
 
907
  ExecutionContext &SF = ECStack.back();
 
908
  GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
 
909
  GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
 
910
  GenericValue Dest;
 
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
  
 
916
  SetValue(&I, Dest, SF);
 
917
}
 
918
 
 
919
void Interpreter::visitAShr(BinaryOperator &I) {
 
920
  ExecutionContext &SF = ECStack.back();
 
921
  GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
 
922
  GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
 
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
  
 
929
  SetValue(&I, Dest, SF);
 
930
}
 
931
 
 
932
GenericValue Interpreter::executeTruncInst(Value *SrcVal, const Type *DstTy,
 
933
                                           ExecutionContext &SF) {
 
934
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
935
  const IntegerType *DITy = cast<IntegerType>(DstTy);
 
936
  unsigned DBitWidth = DITy->getBitWidth();
 
937
  Dest.IntVal = Src.IntVal.trunc(DBitWidth);
 
938
  return Dest;
 
939
}
 
940
 
 
941
GenericValue Interpreter::executeSExtInst(Value *SrcVal, const Type *DstTy,
 
942
                                          ExecutionContext &SF) {
 
943
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
944
  const IntegerType *DITy = cast<IntegerType>(DstTy);
 
945
  unsigned DBitWidth = DITy->getBitWidth();
 
946
  Dest.IntVal = Src.IntVal.sext(DBitWidth);
 
947
  return Dest;
 
948
}
 
949
 
 
950
GenericValue Interpreter::executeZExtInst(Value *SrcVal, const Type *DstTy,
 
951
                                          ExecutionContext &SF) {
 
952
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
953
  const IntegerType *DITy = cast<IntegerType>(DstTy);
 
954
  unsigned DBitWidth = DITy->getBitWidth();
 
955
  Dest.IntVal = Src.IntVal.zext(DBitWidth);
 
956
  return Dest;
 
957
}
 
958
 
 
959
GenericValue Interpreter::executeFPTruncInst(Value *SrcVal, const Type *DstTy,
 
960
                                             ExecutionContext &SF) {
 
961
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
962
  assert(SrcVal->getType()->isDoubleTy() && DstTy->isFloatTy() &&
 
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) {
 
970
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
971
  assert(SrcVal->getType()->isFloatTy() && DstTy->isDoubleTy() &&
 
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();
 
980
  uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth();
 
981
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
982
  assert(SrcTy->isFloatingPointTy() && "Invalid FPToUI instruction");
 
983
 
 
984
  if (SrcTy->getTypeID() == Type::FloatTyID)
 
985
    Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth);
 
986
  else
 
987
    Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth);
 
988
  return Dest;
 
989
}
 
990
 
 
991
GenericValue Interpreter::executeFPToSIInst(Value *SrcVal, const Type *DstTy,
 
992
                                            ExecutionContext &SF) {
 
993
  const Type *SrcTy = SrcVal->getType();
 
994
  uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth();
 
995
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
996
  assert(SrcTy->isFloatingPointTy() && "Invalid FPToSI instruction");
 
997
 
 
998
  if (SrcTy->getTypeID() == Type::FloatTyID)
 
999
    Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth);
 
1000
  else
 
1001
    Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth);
 
1002
  return Dest;
 
1003
}
 
1004
 
 
1005
GenericValue Interpreter::executeUIToFPInst(Value *SrcVal, const Type *DstTy,
 
1006
                                            ExecutionContext &SF) {
 
1007
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
1008
  assert(DstTy->isFloatingPointTy() && "Invalid UIToFP instruction");
 
1009
 
 
1010
  if (DstTy->getTypeID() == Type::FloatTyID)
 
1011
    Dest.FloatVal = APIntOps::RoundAPIntToFloat(Src.IntVal);
 
1012
  else
 
1013
    Dest.DoubleVal = APIntOps::RoundAPIntToDouble(Src.IntVal);
 
1014
  return Dest;
 
1015
}
 
1016
 
 
1017
GenericValue Interpreter::executeSIToFPInst(Value *SrcVal, const Type *DstTy,
 
1018
                                            ExecutionContext &SF) {
 
1019
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
1020
  assert(DstTy->isFloatingPointTy() && "Invalid SIToFP instruction");
 
1021
 
 
1022
  if (DstTy->getTypeID() == Type::FloatTyID)
 
1023
    Dest.FloatVal = APIntOps::RoundSignedAPIntToFloat(Src.IntVal);
 
1024
  else
 
1025
    Dest.DoubleVal = APIntOps::RoundSignedAPIntToDouble(Src.IntVal);
 
1026
  return Dest;
 
1027
 
 
1028
}
 
1029
 
 
1030
GenericValue Interpreter::executePtrToIntInst(Value *SrcVal, const Type *DstTy,
 
1031
                                              ExecutionContext &SF) {
 
1032
  uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth();
 
1033
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
1034
  assert(SrcVal->getType()->isPointerTy() && "Invalid PtrToInt instruction");
 
1035
 
 
1036
  Dest.IntVal = APInt(DBitWidth, (intptr_t) Src.PointerVal);
 
1037
  return Dest;
 
1038
}
 
1039
 
 
1040
GenericValue Interpreter::executeIntToPtrInst(Value *SrcVal, const Type *DstTy,
 
1041
                                              ExecutionContext &SF) {
 
1042
  GenericValue Dest, Src = getOperandValue(SrcVal, SF);
 
1043
  assert(DstTy->isPointerTy() && "Invalid PtrToInt instruction");
 
1044
 
 
1045
  uint32_t PtrSize = TD.getPointerSizeInBits();
 
1046
  if (PtrSize != Src.IntVal.getBitWidth())
 
1047
    Src.IntVal = Src.IntVal.zextOrTrunc(PtrSize);
 
1048
 
 
1049
  Dest.PointerVal = PointerTy(intptr_t(Src.IntVal.getZExtValue()));
 
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 (DstTy->isPointerTy()) {
 
1059
    assert(SrcTy->isPointerTy() && "Invalid BitCast");
 
1060
    Dest.PointerVal = Src.PointerVal;
 
1061
  } else if (DstTy->isIntegerTy()) {
 
1062
    if (SrcTy->isFloatTy()) {
 
1063
      Dest.IntVal.zext(sizeof(Src.FloatVal) * CHAR_BIT);
 
1064
      Dest.IntVal.floatToBits(Src.FloatVal);
 
1065
    } else if (SrcTy->isDoubleTy()) {
 
1066
      Dest.IntVal.zext(sizeof(Src.DoubleVal) * CHAR_BIT);
 
1067
      Dest.IntVal.doubleToBits(Src.DoubleVal);
 
1068
    } else if (SrcTy->isIntegerTy()) {
 
1069
      Dest.IntVal = Src.IntVal;
 
1070
    } else 
 
1071
      llvm_unreachable("Invalid BitCast");
 
1072
  } else if (DstTy->isFloatTy()) {
 
1073
    if (SrcTy->isIntegerTy())
 
1074
      Dest.FloatVal = Src.IntVal.bitsToFloat();
 
1075
    else
 
1076
      Dest.FloatVal = Src.FloatVal;
 
1077
  } else if (DstTy->isDoubleTy()) {
 
1078
    if (SrcTy->isIntegerTy())
 
1079
      Dest.DoubleVal = Src.IntVal.bitsToDouble();
 
1080
    else
 
1081
      Dest.DoubleVal = Src.DoubleVal;
 
1082
  } else
 
1083
    llvm_unreachable("Invalid Bitcast");
 
1084
 
 
1085
  return Dest;
 
1086
}
 
1087
 
 
1088
void Interpreter::visitTruncInst(TruncInst &I) {
 
1089
  ExecutionContext &SF = ECStack.back();
 
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);
 
1146
}
 
1147
 
 
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
 
 
1154
  // Get the incoming valist parameter.  LLI treats the valist as a
 
1155
  // (ec-stack-depth var-arg-index) pair.
 
1156
  GenericValue VAList = getOperandValue(I.getOperand(0), SF);
 
1157
  GenericValue Dest;
 
1158
  GenericValue Src = ECStack[VAList.UIntPairVal.first]
 
1159
                      .VarArgs[VAList.UIntPairVal.second];
 
1160
  const Type *Ty = I.getType();
 
1161
  switch (Ty->getTypeID()) {
 
1162
    case Type::IntegerTyID: Dest.IntVal = Src.IntVal;
 
1163
    IMPLEMENT_VAARG(Pointer);
 
1164
    IMPLEMENT_VAARG(Float);
 
1165
    IMPLEMENT_VAARG(Double);
 
1166
  default:
 
1167
    dbgs() << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
 
1168
    llvm_unreachable(0);
 
1169
  }
 
1170
 
 
1171
  // Set the Value of this Instruction.
 
1172
  SetValue(&I, Dest, SF);
 
1173
 
 
1174
  // Move the pointer to the next vararg.
 
1175
  ++VAList.UIntPairVal.second;
 
1176
}
 
1177
 
 
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);
 
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));
 
1218
  default :
 
1219
    break;
 
1220
  }
 
1221
 
 
1222
  // The cases below here require a GenericValue parameter for the result
 
1223
  // so we initialize one, compute it and then return it.
 
1224
  GenericValue Op0 = getOperandValue(CE->getOperand(0), SF);
 
1225
  GenericValue Op1 = getOperandValue(CE->getOperand(1), SF);
 
1226
  GenericValue Dest;
 
1227
  const Type * Ty = CE->getOperand(0)->getType();
 
1228
  switch (CE->getOpcode()) {
 
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;
 
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;
 
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;
 
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;
 
1253
  default:
 
1254
    dbgs() << "Unhandled ConstantExpr: " << *CE << "\n";
 
1255
    llvm_unreachable(0);
 
1256
    return GenericValue();
 
1257
  }
 
1258
  return Dest;
 
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
 
 
1273
//===----------------------------------------------------------------------===//
 
1274
//                        Dispatch and Execution Code
 
1275
//===----------------------------------------------------------------------===//
 
1276
 
 
1277
//===----------------------------------------------------------------------===//
 
1278
// callFunction - Execute the specified function...
 
1279
//
 
1280
void Interpreter::callFunction(Function *F,
 
1281
                               const std::vector<GenericValue> &ArgVals) {
 
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!");
 
1285
  // Make a new stack frame... and fill it in.
 
1286
  ECStack.push_back(ExecutionContext());
 
1287
  ExecutionContext &StackFrame = ECStack.back();
 
1288
  StackFrame.CurFunction = F;
 
1289
 
 
1290
  // Special handling for external functions.
 
1291
  if (F->isDeclaration()) {
 
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.
 
1299
  StackFrame.CurBB     = F->begin();
 
1300
  StackFrame.CurInst   = StackFrame.CurBB->begin();
 
1301
 
 
1302
  // Run through the function arguments and initialize their values...
 
1303
  assert((ArgVals.size() == F->arg_size() ||
 
1304
         (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&&
 
1305
         "Invalid number of values passed to function invocation!");
 
1306
 
 
1307
  // Handle non-varargs arguments...
 
1308
  unsigned i = 0;
 
1309
  for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); 
 
1310
       AI != E; ++AI, ++i)
 
1311
    SetValue(AI, ArgVals[i], StackFrame);
 
1312
 
 
1313
  // Handle varargs arguments...
 
1314
  StackFrame.VarArgs.assign(ArgVals.begin()+i, ArgVals.end());
 
1315
}
 
1316
 
 
1317
 
 
1318
void Interpreter::run() {
 
1319
  while (!ECStack.empty()) {
 
1320
    // Interpret a single instruction & increment the "PC".
 
1321
    ExecutionContext &SF = ECStack.back();  // Current stack frame
 
1322
    Instruction &I = *SF.CurInst++;         // Increment before execute
 
1323
 
 
1324
    // Track the number of dynamic instructions executed.
 
1325
    ++NumDynamicInsts;
 
1326
 
 
1327
    DEBUG(dbgs() << "About to interpret: " << I);
 
1328
    visit(I);   // Dispatch to one of the visit* methods...
 
1329
#if 0
 
1330
    // This is not safe, as visiting the instruction could lower it and free I.
 
1331
DEBUG(
 
1332
    if (!isa<CallInst>(I) && !isa<InvokeInst>(I) && 
 
1333
        I.getType() != Type::VoidTy) {
 
1334
      dbgs() << "  --> ";
 
1335
      const GenericValue &Val = SF.Values[&I];
 
1336
      switch (I.getType()->getTypeID()) {
 
1337
      default: llvm_unreachable("Invalid GenericValue Type");
 
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);
 
1342
        break;
 
1343
      case Type::IntegerTyID: 
 
1344
        dbgs() << "i" << Val.IntVal.getBitWidth() << " "
 
1345
               << Val.IntVal.toStringUnsigned(10)
 
1346
               << " (0x" << Val.IntVal.toStringUnsigned(16) << ")\n";
 
1347
        break;
 
1348
      }
 
1349
    });
 
1350
#endif
 
1351
  }
 
1352
}