LLVM 17.0.0git
Execution.cpp
Go to the documentation of this file.
1//===-- Execution.cpp - Implement code to simulate the program ------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains the actual instruction interpreter.
10//
11//===----------------------------------------------------------------------===//
12
13#include "Interpreter.h"
14#include "llvm/ADT/APInt.h"
15#include "llvm/ADT/Statistic.h"
17#include "llvm/IR/Constants.h"
22#include "llvm/Support/Debug.h"
26#include <algorithm>
27#include <cmath>
28using namespace llvm;
29
30#define DEBUG_TYPE "interpreter"
31
32STATISTIC(NumDynamicInsts, "Number of dynamic instructions executed");
33
34static cl::opt<bool> PrintVolatile("interpreter-print-volatile", cl::Hidden,
35 cl::desc("make the interpreter print every volatile load and store"));
36
37//===----------------------------------------------------------------------===//
38// Various Helper Functions
39//===----------------------------------------------------------------------===//
40
41static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) {
42 SF.Values[V] = Val;
43}
44
45//===----------------------------------------------------------------------===//
46// Unary Instruction Implementations
47//===----------------------------------------------------------------------===//
48
49static void executeFNegInst(GenericValue &Dest, GenericValue Src, Type *Ty) {
50 switch (Ty->getTypeID()) {
51 case Type::FloatTyID:
52 Dest.FloatVal = -Src.FloatVal;
53 break;
55 Dest.DoubleVal = -Src.DoubleVal;
56 break;
57 default:
58 llvm_unreachable("Unhandled type for FNeg instruction");
59 }
60}
61
63 ExecutionContext &SF = ECStack.back();
64 Type *Ty = I.getOperand(0)->getType();
65 GenericValue Src = getOperandValue(I.getOperand(0), SF);
66 GenericValue R; // Result
67
68 // First process vector operation
69 if (Ty->isVectorTy()) {
70 R.AggregateVal.resize(Src.AggregateVal.size());
71
72 switch(I.getOpcode()) {
73 default:
74 llvm_unreachable("Don't know how to handle this unary operator");
75 break;
76 case Instruction::FNeg:
77 if (cast<VectorType>(Ty)->getElementType()->isFloatTy()) {
78 for (unsigned i = 0; i < R.AggregateVal.size(); ++i)
79 R.AggregateVal[i].FloatVal = -Src.AggregateVal[i].FloatVal;
80 } else if (cast<VectorType>(Ty)->getElementType()->isDoubleTy()) {
81 for (unsigned i = 0; i < R.AggregateVal.size(); ++i)
82 R.AggregateVal[i].DoubleVal = -Src.AggregateVal[i].DoubleVal;
83 } else {
84 llvm_unreachable("Unhandled type for FNeg instruction");
85 }
86 break;
87 }
88 } else {
89 switch (I.getOpcode()) {
90 default:
91 llvm_unreachable("Don't know how to handle this unary operator");
92 break;
93 case Instruction::FNeg: executeFNegInst(R, Src, Ty); break;
94 }
95 }
96 SetValue(&I, R, SF);
97}
98
99//===----------------------------------------------------------------------===//
100// Binary Instruction Implementations
101//===----------------------------------------------------------------------===//
102
103#define IMPLEMENT_BINARY_OPERATOR(OP, TY) \
104 case Type::TY##TyID: \
105 Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; \
106 break
107
109 GenericValue Src2, Type *Ty) {
110 switch (Ty->getTypeID()) {
112 IMPLEMENT_BINARY_OPERATOR(+, Double);
113 default:
114 dbgs() << "Unhandled type for FAdd instruction: " << *Ty << "\n";
115 llvm_unreachable(nullptr);
116 }
117}
118
120 GenericValue Src2, Type *Ty) {
121 switch (Ty->getTypeID()) {
123 IMPLEMENT_BINARY_OPERATOR(-, Double);
124 default:
125 dbgs() << "Unhandled type for FSub instruction: " << *Ty << "\n";
126 llvm_unreachable(nullptr);
127 }
128}
129
131 GenericValue Src2, Type *Ty) {
132 switch (Ty->getTypeID()) {
134 IMPLEMENT_BINARY_OPERATOR(*, Double);
135 default:
136 dbgs() << "Unhandled type for FMul instruction: " << *Ty << "\n";
137 llvm_unreachable(nullptr);
138 }
139}
140
142 GenericValue Src2, Type *Ty) {
143 switch (Ty->getTypeID()) {
145 IMPLEMENT_BINARY_OPERATOR(/, Double);
146 default:
147 dbgs() << "Unhandled type for FDiv instruction: " << *Ty << "\n";
148 llvm_unreachable(nullptr);
149 }
150}
151
153 GenericValue Src2, Type *Ty) {
154 switch (Ty->getTypeID()) {
155 case Type::FloatTyID:
156 Dest.FloatVal = fmod(Src1.FloatVal, Src2.FloatVal);
157 break;
158 case Type::DoubleTyID:
159 Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal);
160 break;
161 default:
162 dbgs() << "Unhandled type for Rem instruction: " << *Ty << "\n";
163 llvm_unreachable(nullptr);
164 }
165}
166
167#define IMPLEMENT_INTEGER_ICMP(OP, TY) \
168 case Type::IntegerTyID: \
169 Dest.IntVal = APInt(1,Src1.IntVal.OP(Src2.IntVal)); \
170 break;
171
172#define IMPLEMENT_VECTOR_INTEGER_ICMP(OP, TY) \
173 case Type::FixedVectorTyID: \
174 case Type::ScalableVectorTyID: { \
175 assert(Src1.AggregateVal.size() == Src2.AggregateVal.size()); \
176 Dest.AggregateVal.resize(Src1.AggregateVal.size()); \
177 for (uint32_t _i = 0; _i < Src1.AggregateVal.size(); _i++) \
178 Dest.AggregateVal[_i].IntVal = APInt( \
179 1, Src1.AggregateVal[_i].IntVal.OP(Src2.AggregateVal[_i].IntVal)); \
180 } break;
181
182// Handle pointers specially because they must be compared with only as much
183// width as the host has. We _do not_ want to be comparing 64 bit values when
184// running on a 32-bit target, otherwise the upper 32 bits might mess up
185// comparisons if they contain garbage.
186#define IMPLEMENT_POINTER_ICMP(OP) \
187 case Type::PointerTyID: \
188 Dest.IntVal = APInt(1,(void*)(intptr_t)Src1.PointerVal OP \
189 (void*)(intptr_t)Src2.PointerVal); \
190 break;
191
193 Type *Ty) {
194 GenericValue Dest;
195 switch (Ty->getTypeID()) {
199 default:
200 dbgs() << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n";
201 llvm_unreachable(nullptr);
202 }
203 return Dest;
204}
205
207 Type *Ty) {
208 GenericValue Dest;
209 switch (Ty->getTypeID()) {
213 default:
214 dbgs() << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n";
215 llvm_unreachable(nullptr);
216 }
217 return Dest;
218}
219
221 Type *Ty) {
222 GenericValue Dest;
223 switch (Ty->getTypeID()) {
227 default:
228 dbgs() << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n";
229 llvm_unreachable(nullptr);
230 }
231 return Dest;
232}
233
235 Type *Ty) {
236 GenericValue Dest;
237 switch (Ty->getTypeID()) {
241 default:
242 dbgs() << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n";
243 llvm_unreachable(nullptr);
244 }
245 return Dest;
246}
247
249 Type *Ty) {
250 GenericValue Dest;
251 switch (Ty->getTypeID()) {
255 default:
256 dbgs() << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n";
257 llvm_unreachable(nullptr);
258 }
259 return Dest;
260}
261
263 Type *Ty) {
264 GenericValue Dest;
265 switch (Ty->getTypeID()) {
269 default:
270 dbgs() << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n";
271 llvm_unreachable(nullptr);
272 }
273 return Dest;
274}
275
277 Type *Ty) {
278 GenericValue Dest;
279 switch (Ty->getTypeID()) {
283 default:
284 dbgs() << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n";
285 llvm_unreachable(nullptr);
286 }
287 return Dest;
288}
289
291 Type *Ty) {
292 GenericValue Dest;
293 switch (Ty->getTypeID()) {
297 default:
298 dbgs() << "Unhandled type for ICMP_SLE predicate: " << *Ty << "\n";
299 llvm_unreachable(nullptr);
300 }
301 return Dest;
302}
303
305 Type *Ty) {
306 GenericValue Dest;
307 switch (Ty->getTypeID()) {
311 default:
312 dbgs() << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n";
313 llvm_unreachable(nullptr);
314 }
315 return Dest;
316}
317
319 Type *Ty) {
320 GenericValue Dest;
321 switch (Ty->getTypeID()) {
325 default:
326 dbgs() << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n";
327 llvm_unreachable(nullptr);
328 }
329 return Dest;
330}
331
333 ExecutionContext &SF = ECStack.back();
334 Type *Ty = I.getOperand(0)->getType();
335 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
336 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
337 GenericValue R; // Result
338
339 switch (I.getPredicate()) {
340 case ICmpInst::ICMP_EQ: R = executeICMP_EQ(Src1, Src2, Ty); break;
341 case ICmpInst::ICMP_NE: R = executeICMP_NE(Src1, Src2, Ty); break;
342 case ICmpInst::ICMP_ULT: R = executeICMP_ULT(Src1, Src2, Ty); break;
343 case ICmpInst::ICMP_SLT: R = executeICMP_SLT(Src1, Src2, Ty); break;
344 case ICmpInst::ICMP_UGT: R = executeICMP_UGT(Src1, Src2, Ty); break;
345 case ICmpInst::ICMP_SGT: R = executeICMP_SGT(Src1, Src2, Ty); break;
346 case ICmpInst::ICMP_ULE: R = executeICMP_ULE(Src1, Src2, Ty); break;
347 case ICmpInst::ICMP_SLE: R = executeICMP_SLE(Src1, Src2, Ty); break;
348 case ICmpInst::ICMP_UGE: R = executeICMP_UGE(Src1, Src2, Ty); break;
349 case ICmpInst::ICMP_SGE: R = executeICMP_SGE(Src1, Src2, Ty); break;
350 default:
351 dbgs() << "Don't know how to handle this ICmp predicate!\n-->" << I;
352 llvm_unreachable(nullptr);
353 }
354
355 SetValue(&I, R, SF);
356}
357
358#define IMPLEMENT_FCMP(OP, TY) \
359 case Type::TY##TyID: \
360 Dest.IntVal = APInt(1,Src1.TY##Val OP Src2.TY##Val); \
361 break
362
363#define IMPLEMENT_VECTOR_FCMP_T(OP, TY) \
364 assert(Src1.AggregateVal.size() == Src2.AggregateVal.size()); \
365 Dest.AggregateVal.resize( Src1.AggregateVal.size() ); \
366 for( uint32_t _i=0;_i<Src1.AggregateVal.size();_i++) \
367 Dest.AggregateVal[_i].IntVal = APInt(1, \
368 Src1.AggregateVal[_i].TY##Val OP Src2.AggregateVal[_i].TY##Val);\
369 break;
370
371#define IMPLEMENT_VECTOR_FCMP(OP) \
372 case Type::FixedVectorTyID: \
373 case Type::ScalableVectorTyID: \
374 if (cast<VectorType>(Ty)->getElementType()->isFloatTy()) { \
375 IMPLEMENT_VECTOR_FCMP_T(OP, Float); \
376 } else { \
377 IMPLEMENT_VECTOR_FCMP_T(OP, Double); \
378 }
379
381 Type *Ty) {
382 GenericValue Dest;
383 switch (Ty->getTypeID()) {
384 IMPLEMENT_FCMP(==, Float);
385 IMPLEMENT_FCMP(==, Double);
387 default:
388 dbgs() << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n";
389 llvm_unreachable(nullptr);
390 }
391 return Dest;
392}
393
394#define IMPLEMENT_SCALAR_NANS(TY, X,Y) \
395 if (TY->isFloatTy()) { \
396 if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) { \
397 Dest.IntVal = APInt(1,false); \
398 return Dest; \
399 } \
400 } else { \
401 if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) { \
402 Dest.IntVal = APInt(1,false); \
403 return Dest; \
404 } \
405 }
406
407#define MASK_VECTOR_NANS_T(X,Y, TZ, FLAG) \
408 assert(X.AggregateVal.size() == Y.AggregateVal.size()); \
409 Dest.AggregateVal.resize( X.AggregateVal.size() ); \
410 for( uint32_t _i=0;_i<X.AggregateVal.size();_i++) { \
411 if (X.AggregateVal[_i].TZ##Val != X.AggregateVal[_i].TZ##Val || \
412 Y.AggregateVal[_i].TZ##Val != Y.AggregateVal[_i].TZ##Val) \
413 Dest.AggregateVal[_i].IntVal = APInt(1,FLAG); \
414 else { \
415 Dest.AggregateVal[_i].IntVal = APInt(1,!FLAG); \
416 } \
417 }
418
419#define MASK_VECTOR_NANS(TY, X,Y, FLAG) \
420 if (TY->isVectorTy()) { \
421 if (cast<VectorType>(TY)->getElementType()->isFloatTy()) { \
422 MASK_VECTOR_NANS_T(X, Y, Float, FLAG) \
423 } else { \
424 MASK_VECTOR_NANS_T(X, Y, Double, FLAG) \
425 } \
426 } \
427
428
429
431 Type *Ty)
432{
433 GenericValue Dest;
434 // if input is scalar value and Src1 or Src2 is NaN return false
435 IMPLEMENT_SCALAR_NANS(Ty, Src1, Src2)
436 // if vector input detect NaNs and fill mask
437 MASK_VECTOR_NANS(Ty, Src1, Src2, false)
438 GenericValue DestMask = Dest;
439 switch (Ty->getTypeID()) {
440 IMPLEMENT_FCMP(!=, Float);
441 IMPLEMENT_FCMP(!=, Double);
443 default:
444 dbgs() << "Unhandled type for FCmp NE instruction: " << *Ty << "\n";
445 llvm_unreachable(nullptr);
446 }
447 // in vector case mask out NaN elements
448 if (Ty->isVectorTy())
449 for( size_t _i=0; _i<Src1.AggregateVal.size(); _i++)
450 if (DestMask.AggregateVal[_i].IntVal == false)
451 Dest.AggregateVal[_i].IntVal = APInt(1,false);
452
453 return Dest;
454}
455
457 Type *Ty) {
458 GenericValue Dest;
459 switch (Ty->getTypeID()) {
460 IMPLEMENT_FCMP(<=, Float);
461 IMPLEMENT_FCMP(<=, Double);
463 default:
464 dbgs() << "Unhandled type for FCmp LE instruction: " << *Ty << "\n";
465 llvm_unreachable(nullptr);
466 }
467 return Dest;
468}
469
471 Type *Ty) {
472 GenericValue Dest;
473 switch (Ty->getTypeID()) {
474 IMPLEMENT_FCMP(>=, Float);
475 IMPLEMENT_FCMP(>=, Double);
477 default:
478 dbgs() << "Unhandled type for FCmp GE instruction: " << *Ty << "\n";
479 llvm_unreachable(nullptr);
480 }
481 return Dest;
482}
483
485 Type *Ty) {
486 GenericValue Dest;
487 switch (Ty->getTypeID()) {
488 IMPLEMENT_FCMP(<, Float);
489 IMPLEMENT_FCMP(<, Double);
491 default:
492 dbgs() << "Unhandled type for FCmp LT instruction: " << *Ty << "\n";
493 llvm_unreachable(nullptr);
494 }
495 return Dest;
496}
497
499 Type *Ty) {
500 GenericValue Dest;
501 switch (Ty->getTypeID()) {
502 IMPLEMENT_FCMP(>, Float);
503 IMPLEMENT_FCMP(>, Double);
505 default:
506 dbgs() << "Unhandled type for FCmp GT instruction: " << *Ty << "\n";
507 llvm_unreachable(nullptr);
508 }
509 return Dest;
510}
511
512#define IMPLEMENT_UNORDERED(TY, X,Y) \
513 if (TY->isFloatTy()) { \
514 if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) { \
515 Dest.IntVal = APInt(1,true); \
516 return Dest; \
517 } \
518 } else if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) { \
519 Dest.IntVal = APInt(1,true); \
520 return Dest; \
521 }
522
523#define IMPLEMENT_VECTOR_UNORDERED(TY, X, Y, FUNC) \
524 if (TY->isVectorTy()) { \
525 GenericValue DestMask = Dest; \
526 Dest = FUNC(Src1, Src2, Ty); \
527 for (size_t _i = 0; _i < Src1.AggregateVal.size(); _i++) \
528 if (DestMask.AggregateVal[_i].IntVal == true) \
529 Dest.AggregateVal[_i].IntVal = APInt(1, true); \
530 return Dest; \
531 }
532
534 Type *Ty) {
535 GenericValue Dest;
536 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
537 MASK_VECTOR_NANS(Ty, Src1, Src2, true)
539 return executeFCMP_OEQ(Src1, Src2, Ty);
540
541}
542
544 Type *Ty) {
545 GenericValue Dest;
546 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
547 MASK_VECTOR_NANS(Ty, Src1, Src2, true)
549 return executeFCMP_ONE(Src1, Src2, Ty);
550}
551
553 Type *Ty) {
554 GenericValue Dest;
555 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
556 MASK_VECTOR_NANS(Ty, Src1, Src2, true)
558 return executeFCMP_OLE(Src1, Src2, Ty);
559}
560
562 Type *Ty) {
563 GenericValue Dest;
564 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
565 MASK_VECTOR_NANS(Ty, Src1, Src2, true)
567 return executeFCMP_OGE(Src1, Src2, Ty);
568}
569
571 Type *Ty) {
572 GenericValue Dest;
573 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
574 MASK_VECTOR_NANS(Ty, Src1, Src2, true)
576 return executeFCMP_OLT(Src1, Src2, Ty);
577}
578
580 Type *Ty) {
581 GenericValue Dest;
582 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
583 MASK_VECTOR_NANS(Ty, Src1, Src2, true)
585 return executeFCMP_OGT(Src1, Src2, Ty);
586}
587
589 Type *Ty) {
590 GenericValue Dest;
591 if(Ty->isVectorTy()) {
592 assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
593 Dest.AggregateVal.resize( Src1.AggregateVal.size() );
594 if (cast<VectorType>(Ty)->getElementType()->isFloatTy()) {
595 for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
596 Dest.AggregateVal[_i].IntVal = APInt(1,
597 ( (Src1.AggregateVal[_i].FloatVal ==
598 Src1.AggregateVal[_i].FloatVal) &&
599 (Src2.AggregateVal[_i].FloatVal ==
600 Src2.AggregateVal[_i].FloatVal)));
601 } else {
602 for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
603 Dest.AggregateVal[_i].IntVal = APInt(1,
604 ( (Src1.AggregateVal[_i].DoubleVal ==
605 Src1.AggregateVal[_i].DoubleVal) &&
606 (Src2.AggregateVal[_i].DoubleVal ==
607 Src2.AggregateVal[_i].DoubleVal)));
608 }
609 } else if (Ty->isFloatTy())
610 Dest.IntVal = APInt(1,(Src1.FloatVal == Src1.FloatVal &&
611 Src2.FloatVal == Src2.FloatVal));
612 else {
613 Dest.IntVal = APInt(1,(Src1.DoubleVal == Src1.DoubleVal &&
614 Src2.DoubleVal == Src2.DoubleVal));
615 }
616 return Dest;
617}
618
620 Type *Ty) {
621 GenericValue Dest;
622 if(Ty->isVectorTy()) {
623 assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
624 Dest.AggregateVal.resize( Src1.AggregateVal.size() );
625 if (cast<VectorType>(Ty)->getElementType()->isFloatTy()) {
626 for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
627 Dest.AggregateVal[_i].IntVal = APInt(1,
628 ( (Src1.AggregateVal[_i].FloatVal !=
629 Src1.AggregateVal[_i].FloatVal) ||
630 (Src2.AggregateVal[_i].FloatVal !=
631 Src2.AggregateVal[_i].FloatVal)));
632 } else {
633 for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
634 Dest.AggregateVal[_i].IntVal = APInt(1,
635 ( (Src1.AggregateVal[_i].DoubleVal !=
636 Src1.AggregateVal[_i].DoubleVal) ||
637 (Src2.AggregateVal[_i].DoubleVal !=
638 Src2.AggregateVal[_i].DoubleVal)));
639 }
640 } else if (Ty->isFloatTy())
641 Dest.IntVal = APInt(1,(Src1.FloatVal != Src1.FloatVal ||
642 Src2.FloatVal != Src2.FloatVal));
643 else {
644 Dest.IntVal = APInt(1,(Src1.DoubleVal != Src1.DoubleVal ||
645 Src2.DoubleVal != Src2.DoubleVal));
646 }
647 return Dest;
648}
649
651 Type *Ty, const bool val) {
652 GenericValue Dest;
653 if(Ty->isVectorTy()) {
654 assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
655 Dest.AggregateVal.resize( Src1.AggregateVal.size() );
656 for( size_t _i=0; _i<Src1.AggregateVal.size(); _i++)
657 Dest.AggregateVal[_i].IntVal = APInt(1,val);
658 } else {
659 Dest.IntVal = APInt(1, val);
660 }
661
662 return Dest;
663}
664
666 ExecutionContext &SF = ECStack.back();
667 Type *Ty = I.getOperand(0)->getType();
668 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
669 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
670 GenericValue R; // Result
671
672 switch (I.getPredicate()) {
673 default:
674 dbgs() << "Don't know how to handle this FCmp predicate!\n-->" << I;
675 llvm_unreachable(nullptr);
676 break;
677 case FCmpInst::FCMP_FALSE: R = executeFCMP_BOOL(Src1, Src2, Ty, false);
678 break;
679 case FCmpInst::FCMP_TRUE: R = executeFCMP_BOOL(Src1, Src2, Ty, true);
680 break;
681 case FCmpInst::FCMP_ORD: R = executeFCMP_ORD(Src1, Src2, Ty); break;
682 case FCmpInst::FCMP_UNO: R = executeFCMP_UNO(Src1, Src2, Ty); break;
683 case FCmpInst::FCMP_UEQ: R = executeFCMP_UEQ(Src1, Src2, Ty); break;
684 case FCmpInst::FCMP_OEQ: R = executeFCMP_OEQ(Src1, Src2, Ty); break;
685 case FCmpInst::FCMP_UNE: R = executeFCMP_UNE(Src1, Src2, Ty); break;
686 case FCmpInst::FCMP_ONE: R = executeFCMP_ONE(Src1, Src2, Ty); break;
687 case FCmpInst::FCMP_ULT: R = executeFCMP_ULT(Src1, Src2, Ty); break;
688 case FCmpInst::FCMP_OLT: R = executeFCMP_OLT(Src1, Src2, Ty); break;
689 case FCmpInst::FCMP_UGT: R = executeFCMP_UGT(Src1, Src2, Ty); break;
690 case FCmpInst::FCMP_OGT: R = executeFCMP_OGT(Src1, Src2, Ty); break;
691 case FCmpInst::FCMP_ULE: R = executeFCMP_ULE(Src1, Src2, Ty); break;
692 case FCmpInst::FCMP_OLE: R = executeFCMP_OLE(Src1, Src2, Ty); break;
693 case FCmpInst::FCMP_UGE: R = executeFCMP_UGE(Src1, Src2, Ty); break;
694 case FCmpInst::FCMP_OGE: R = executeFCMP_OGE(Src1, Src2, Ty); break;
695 }
696
697 SetValue(&I, R, SF);
698}
699
700static GenericValue executeCmpInst(unsigned predicate, GenericValue Src1,
701 GenericValue Src2, Type *Ty) {
702 GenericValue Result;
703 switch (predicate) {
704 case ICmpInst::ICMP_EQ: return executeICMP_EQ(Src1, Src2, Ty);
705 case ICmpInst::ICMP_NE: return executeICMP_NE(Src1, Src2, Ty);
706 case ICmpInst::ICMP_UGT: return executeICMP_UGT(Src1, Src2, Ty);
707 case ICmpInst::ICMP_SGT: return executeICMP_SGT(Src1, Src2, Ty);
708 case ICmpInst::ICMP_ULT: return executeICMP_ULT(Src1, Src2, Ty);
709 case ICmpInst::ICMP_SLT: return executeICMP_SLT(Src1, Src2, Ty);
710 case ICmpInst::ICMP_UGE: return executeICMP_UGE(Src1, Src2, Ty);
711 case ICmpInst::ICMP_SGE: return executeICMP_SGE(Src1, Src2, Ty);
712 case ICmpInst::ICMP_ULE: return executeICMP_ULE(Src1, Src2, Ty);
713 case ICmpInst::ICMP_SLE: return executeICMP_SLE(Src1, Src2, Ty);
714 case FCmpInst::FCMP_ORD: return executeFCMP_ORD(Src1, Src2, Ty);
715 case FCmpInst::FCMP_UNO: return executeFCMP_UNO(Src1, Src2, Ty);
716 case FCmpInst::FCMP_OEQ: return executeFCMP_OEQ(Src1, Src2, Ty);
717 case FCmpInst::FCMP_UEQ: return executeFCMP_UEQ(Src1, Src2, Ty);
718 case FCmpInst::FCMP_ONE: return executeFCMP_ONE(Src1, Src2, Ty);
719 case FCmpInst::FCMP_UNE: return executeFCMP_UNE(Src1, Src2, Ty);
720 case FCmpInst::FCMP_OLT: return executeFCMP_OLT(Src1, Src2, Ty);
721 case FCmpInst::FCMP_ULT: return executeFCMP_ULT(Src1, Src2, Ty);
722 case FCmpInst::FCMP_OGT: return executeFCMP_OGT(Src1, Src2, Ty);
723 case FCmpInst::FCMP_UGT: return executeFCMP_UGT(Src1, Src2, Ty);
724 case FCmpInst::FCMP_OLE: return executeFCMP_OLE(Src1, Src2, Ty);
725 case FCmpInst::FCMP_ULE: return executeFCMP_ULE(Src1, Src2, Ty);
726 case FCmpInst::FCMP_OGE: return executeFCMP_OGE(Src1, Src2, Ty);
727 case FCmpInst::FCMP_UGE: return executeFCMP_UGE(Src1, Src2, Ty);
728 case FCmpInst::FCMP_FALSE: return executeFCMP_BOOL(Src1, Src2, Ty, false);
729 case FCmpInst::FCMP_TRUE: return executeFCMP_BOOL(Src1, Src2, Ty, true);
730 default:
731 dbgs() << "Unhandled Cmp predicate\n";
732 llvm_unreachable(nullptr);
733 }
734}
735
737 ExecutionContext &SF = ECStack.back();
738 Type *Ty = I.getOperand(0)->getType();
739 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
740 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
741 GenericValue R; // Result
742
743 // First process vector operation
744 if (Ty->isVectorTy()) {
745 assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
746 R.AggregateVal.resize(Src1.AggregateVal.size());
747
748 // Macros to execute binary operation 'OP' over integer vectors
749#define INTEGER_VECTOR_OPERATION(OP) \
750 for (unsigned i = 0; i < R.AggregateVal.size(); ++i) \
751 R.AggregateVal[i].IntVal = \
752 Src1.AggregateVal[i].IntVal OP Src2.AggregateVal[i].IntVal;
753
754 // Additional macros to execute binary operations udiv/sdiv/urem/srem since
755 // they have different notation.
756#define INTEGER_VECTOR_FUNCTION(OP) \
757 for (unsigned i = 0; i < R.AggregateVal.size(); ++i) \
758 R.AggregateVal[i].IntVal = \
759 Src1.AggregateVal[i].IntVal.OP(Src2.AggregateVal[i].IntVal);
760
761 // Macros to execute binary operation 'OP' over floating point type TY
762 // (float or double) vectors
763#define FLOAT_VECTOR_FUNCTION(OP, TY) \
764 for (unsigned i = 0; i < R.AggregateVal.size(); ++i) \
765 R.AggregateVal[i].TY = \
766 Src1.AggregateVal[i].TY OP Src2.AggregateVal[i].TY;
767
768 // Macros to choose appropriate TY: float or double and run operation
769 // execution
770#define FLOAT_VECTOR_OP(OP) { \
771 if (cast<VectorType>(Ty)->getElementType()->isFloatTy()) \
772 FLOAT_VECTOR_FUNCTION(OP, FloatVal) \
773 else { \
774 if (cast<VectorType>(Ty)->getElementType()->isDoubleTy()) \
775 FLOAT_VECTOR_FUNCTION(OP, DoubleVal) \
776 else { \
777 dbgs() << "Unhandled type for OP instruction: " << *Ty << "\n"; \
778 llvm_unreachable(0); \
779 } \
780 } \
781}
782
783 switch(I.getOpcode()){
784 default:
785 dbgs() << "Don't know how to handle this binary operator!\n-->" << I;
786 llvm_unreachable(nullptr);
787 break;
788 case Instruction::Add: INTEGER_VECTOR_OPERATION(+) break;
789 case Instruction::Sub: INTEGER_VECTOR_OPERATION(-) break;
790 case Instruction::Mul: INTEGER_VECTOR_OPERATION(*) break;
791 case Instruction::UDiv: INTEGER_VECTOR_FUNCTION(udiv) break;
792 case Instruction::SDiv: INTEGER_VECTOR_FUNCTION(sdiv) break;
793 case Instruction::URem: INTEGER_VECTOR_FUNCTION(urem) break;
794 case Instruction::SRem: INTEGER_VECTOR_FUNCTION(srem) break;
795 case Instruction::And: INTEGER_VECTOR_OPERATION(&) break;
796 case Instruction::Or: INTEGER_VECTOR_OPERATION(|) break;
797 case Instruction::Xor: INTEGER_VECTOR_OPERATION(^) break;
798 case Instruction::FAdd: FLOAT_VECTOR_OP(+) break;
799 case Instruction::FSub: FLOAT_VECTOR_OP(-) break;
800 case Instruction::FMul: FLOAT_VECTOR_OP(*) break;
801 case Instruction::FDiv: FLOAT_VECTOR_OP(/) break;
802 case Instruction::FRem:
803 if (cast<VectorType>(Ty)->getElementType()->isFloatTy())
804 for (unsigned i = 0; i < R.AggregateVal.size(); ++i)
805 R.AggregateVal[i].FloatVal =
806 fmod(Src1.AggregateVal[i].FloatVal, Src2.AggregateVal[i].FloatVal);
807 else {
808 if (cast<VectorType>(Ty)->getElementType()->isDoubleTy())
809 for (unsigned i = 0; i < R.AggregateVal.size(); ++i)
810 R.AggregateVal[i].DoubleVal =
811 fmod(Src1.AggregateVal[i].DoubleVal, Src2.AggregateVal[i].DoubleVal);
812 else {
813 dbgs() << "Unhandled type for Rem instruction: " << *Ty << "\n";
814 llvm_unreachable(nullptr);
815 }
816 }
817 break;
818 }
819 } else {
820 switch (I.getOpcode()) {
821 default:
822 dbgs() << "Don't know how to handle this binary operator!\n-->" << I;
823 llvm_unreachable(nullptr);
824 break;
825 case Instruction::Add: R.IntVal = Src1.IntVal + Src2.IntVal; break;
826 case Instruction::Sub: R.IntVal = Src1.IntVal - Src2.IntVal; break;
827 case Instruction::Mul: R.IntVal = Src1.IntVal * Src2.IntVal; break;
828 case Instruction::FAdd: executeFAddInst(R, Src1, Src2, Ty); break;
829 case Instruction::FSub: executeFSubInst(R, Src1, Src2, Ty); break;
830 case Instruction::FMul: executeFMulInst(R, Src1, Src2, Ty); break;
831 case Instruction::FDiv: executeFDivInst(R, Src1, Src2, Ty); break;
832 case Instruction::FRem: executeFRemInst(R, Src1, Src2, Ty); break;
833 case Instruction::UDiv: R.IntVal = Src1.IntVal.udiv(Src2.IntVal); break;
834 case Instruction::SDiv: R.IntVal = Src1.IntVal.sdiv(Src2.IntVal); break;
835 case Instruction::URem: R.IntVal = Src1.IntVal.urem(Src2.IntVal); break;
836 case Instruction::SRem: R.IntVal = Src1.IntVal.srem(Src2.IntVal); break;
837 case Instruction::And: R.IntVal = Src1.IntVal & Src2.IntVal; break;
838 case Instruction::Or: R.IntVal = Src1.IntVal | Src2.IntVal; break;
839 case Instruction::Xor: R.IntVal = Src1.IntVal ^ Src2.IntVal; break;
840 }
841 }
842 SetValue(&I, R, SF);
843}
844
846 GenericValue Src3, Type *Ty) {
847 GenericValue Dest;
848 if(Ty->isVectorTy()) {
849 assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
850 assert(Src2.AggregateVal.size() == Src3.AggregateVal.size());
851 Dest.AggregateVal.resize( Src1.AggregateVal.size() );
852 for (size_t i = 0; i < Src1.AggregateVal.size(); ++i)
853 Dest.AggregateVal[i] = (Src1.AggregateVal[i].IntVal == 0) ?
854 Src3.AggregateVal[i] : Src2.AggregateVal[i];
855 } else {
856 Dest = (Src1.IntVal == 0) ? Src3 : Src2;
857 }
858 return Dest;
859}
860
862 ExecutionContext &SF = ECStack.back();
863 Type * Ty = I.getOperand(0)->getType();
864 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
865 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
866 GenericValue Src3 = getOperandValue(I.getOperand(2), SF);
867 GenericValue R = executeSelectInst(Src1, Src2, Src3, Ty);
868 SetValue(&I, R, SF);
869}
870
871//===----------------------------------------------------------------------===//
872// Terminator Instruction Implementations
873//===----------------------------------------------------------------------===//
874
876 // runAtExitHandlers() assumes there are no stack frames, but
877 // if exit() was called, then it had a stack frame. Blow away
878 // the stack before interpreting atexit handlers.
879 ECStack.clear();
881 exit(GV.IntVal.zextOrTrunc(32).getZExtValue());
882}
883
884/// Pop the last stack frame off of ECStack and then copy the result
885/// back into the result variable if we are not returning void. The
886/// result variable may be the ExitValue, or the Value of the calling
887/// CallInst if there was a previous stack frame. This method may
888/// invalidate any ECStack iterators you have. This method also takes
889/// care of switching to the normal destination BB, if we are returning
890/// from an invoke.
891///
892void Interpreter::popStackAndReturnValueToCaller(Type *RetTy,
893 GenericValue Result) {
894 // Pop the current stack frame.
895 ECStack.pop_back();
896
897 if (ECStack.empty()) { // Finished main. Put result into exit code...
898 if (RetTy && !RetTy->isVoidTy()) { // Nonvoid return type?
899 ExitValue = Result; // Capture the exit value of the program
900 } else {
901 memset(&ExitValue.Untyped, 0, sizeof(ExitValue.Untyped));
902 }
903 } else {
904 // If we have a previous stack frame, and we have a previous call,
905 // fill in the return value...
906 ExecutionContext &CallingSF = ECStack.back();
907 if (CallingSF.Caller) {
908 // Save result...
909 if (!CallingSF.Caller->getType()->isVoidTy())
910 SetValue(CallingSF.Caller, Result, CallingSF);
911 if (InvokeInst *II = dyn_cast<InvokeInst>(CallingSF.Caller))
912 SwitchToNewBasicBlock (II->getNormalDest (), CallingSF);
913 CallingSF.Caller = nullptr; // We returned from the call...
914 }
915 }
916}
917
919 ExecutionContext &SF = ECStack.back();
920 Type *RetTy = Type::getVoidTy(I.getContext());
921 GenericValue Result;
922
923 // Save away the return value... (if we are not 'ret void')
924 if (I.getNumOperands()) {
925 RetTy = I.getReturnValue()->getType();
926 Result = getOperandValue(I.getReturnValue(), SF);
927 }
928
929 popStackAndReturnValueToCaller(RetTy, Result);
930}
931
933 report_fatal_error("Program executed an 'unreachable' instruction!");
934}
935
937 ExecutionContext &SF = ECStack.back();
938 BasicBlock *Dest;
939
940 Dest = I.getSuccessor(0); // Uncond branches have a fixed dest...
941 if (!I.isUnconditional()) {
942 Value *Cond = I.getCondition();
943 if (getOperandValue(Cond, SF).IntVal == 0) // If false cond...
944 Dest = I.getSuccessor(1);
945 }
946 SwitchToNewBasicBlock(Dest, SF);
947}
948
950 ExecutionContext &SF = ECStack.back();
951 Value* Cond = I.getCondition();
952 Type *ElTy = Cond->getType();
953 GenericValue CondVal = getOperandValue(Cond, SF);
954
955 // Check to see if any of the cases match...
956 BasicBlock *Dest = nullptr;
957 for (auto Case : I.cases()) {
958 GenericValue CaseVal = getOperandValue(Case.getCaseValue(), SF);
959 if (executeICMP_EQ(CondVal, CaseVal, ElTy).IntVal != 0) {
960 Dest = cast<BasicBlock>(Case.getCaseSuccessor());
961 break;
962 }
963 }
964 if (!Dest) Dest = I.getDefaultDest(); // No cases matched: use default
965 SwitchToNewBasicBlock(Dest, SF);
966}
967
969 ExecutionContext &SF = ECStack.back();
970 void *Dest = GVTOP(getOperandValue(I.getAddress(), SF));
971 SwitchToNewBasicBlock((BasicBlock*)Dest, SF);
972}
973
974
975// SwitchToNewBasicBlock - This method is used to jump to a new basic block.
976// This function handles the actual updating of block and instruction iterators
977// as well as execution of all of the PHI nodes in the destination block.
978//
979// This method does this because all of the PHI nodes must be executed
980// atomically, reading their inputs before any of the results are updated. Not
981// doing this can cause problems if the PHI nodes depend on other PHI nodes for
982// their inputs. If the input PHI node is updated before it is read, incorrect
983// results can happen. Thus we use a two phase approach.
984//
985void Interpreter::SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF){
986 BasicBlock *PrevBB = SF.CurBB; // Remember where we came from...
987 SF.CurBB = Dest; // Update CurBB to branch destination
988 SF.CurInst = SF.CurBB->begin(); // Update new instruction ptr...
989
990 if (!isa<PHINode>(SF.CurInst)) return; // Nothing fancy to do
991
992 // Loop over all of the PHI nodes in the current block, reading their inputs.
993 std::vector<GenericValue> ResultValues;
994
995 for (; PHINode *PN = dyn_cast<PHINode>(SF.CurInst); ++SF.CurInst) {
996 // Search for the value corresponding to this previous bb...
997 int i = PN->getBasicBlockIndex(PrevBB);
998 assert(i != -1 && "PHINode doesn't contain entry for predecessor??");
999 Value *IncomingValue = PN->getIncomingValue(i);
1000
1001 // Save the incoming value for this PHI node...
1002 ResultValues.push_back(getOperandValue(IncomingValue, SF));
1003 }
1004
1005 // Now loop over all of the PHI nodes setting their values...
1006 SF.CurInst = SF.CurBB->begin();
1007 for (unsigned i = 0; isa<PHINode>(SF.CurInst); ++SF.CurInst, ++i) {
1008 PHINode *PN = cast<PHINode>(SF.CurInst);
1009 SetValue(PN, ResultValues[i], SF);
1010 }
1011}
1012
1013//===----------------------------------------------------------------------===//
1014// Memory Instruction Implementations
1015//===----------------------------------------------------------------------===//
1016
1018 ExecutionContext &SF = ECStack.back();
1019
1020 Type *Ty = I.getAllocatedType(); // Type to be allocated
1021
1022 // Get the number of elements being allocated by the array...
1023 unsigned NumElements =
1024 getOperandValue(I.getOperand(0), SF).IntVal.getZExtValue();
1025
1026 unsigned TypeSize = (size_t)getDataLayout().getTypeAllocSize(Ty);
1027
1028 // Avoid malloc-ing zero bytes, use max()...
1029 unsigned MemToAlloc = std::max(1U, NumElements * TypeSize);
1030
1031 // Allocate enough memory to hold the type...
1032 void *Memory = safe_malloc(MemToAlloc);
1033
1034 LLVM_DEBUG(dbgs() << "Allocated Type: " << *Ty << " (" << TypeSize
1035 << " bytes) x " << NumElements << " (Total: " << MemToAlloc
1036 << ") at " << uintptr_t(Memory) << '\n');
1037
1038 GenericValue Result = PTOGV(Memory);
1039 assert(Result.PointerVal && "Null pointer returned by malloc!");
1040 SetValue(&I, Result, SF);
1041
1042 if (I.getOpcode() == Instruction::Alloca)
1043 ECStack.back().Allocas.add(Memory);
1044}
1045
1046// getElementOffset - The workhorse for getelementptr.
1047//
1048GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
1050 ExecutionContext &SF) {
1051 assert(Ptr->getType()->isPointerTy() &&
1052 "Cannot getElementOffset of a nonpointer type!");
1053
1054 uint64_t Total = 0;
1055
1056 for (; I != E; ++I) {
1057 if (StructType *STy = I.getStructTypeOrNull()) {
1058 const StructLayout *SLO = getDataLayout().getStructLayout(STy);
1059
1060 const ConstantInt *CPU = cast<ConstantInt>(I.getOperand());
1061 unsigned Index = unsigned(CPU->getZExtValue());
1062
1063 Total += SLO->getElementOffset(Index);
1064 } else {
1065 // Get the index number for the array... which must be long type...
1066 GenericValue IdxGV = getOperandValue(I.getOperand(), SF);
1067
1068 int64_t Idx;
1069 unsigned BitWidth =
1070 cast<IntegerType>(I.getOperand()->getType())->getBitWidth();
1071 if (BitWidth == 32)
1072 Idx = (int64_t)(int32_t)IdxGV.IntVal.getZExtValue();
1073 else {
1074 assert(BitWidth == 64 && "Invalid index type for getelementptr");
1075 Idx = (int64_t)IdxGV.IntVal.getZExtValue();
1076 }
1077 Total += getDataLayout().getTypeAllocSize(I.getIndexedType()) * Idx;
1078 }
1079 }
1080
1082 Result.PointerVal = ((char*)getOperandValue(Ptr, SF).PointerVal) + Total;
1083 LLVM_DEBUG(dbgs() << "GEP Index " << Total << " bytes.\n");
1084 return Result;
1085}
1086
1088 ExecutionContext &SF = ECStack.back();
1089 SetValue(&I, executeGEPOperation(I.getPointerOperand(),
1090 gep_type_begin(I), gep_type_end(I), SF), SF);
1091}
1092
1094 ExecutionContext &SF = ECStack.back();
1095 GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
1097 GenericValue Result;
1098 LoadValueFromMemory(Result, Ptr, I.getType());
1099 SetValue(&I, Result, SF);
1100 if (I.isVolatile() && PrintVolatile)
1101 dbgs() << "Volatile load " << I;
1102}
1103
1105 ExecutionContext &SF = ECStack.back();
1106 GenericValue Val = getOperandValue(I.getOperand(0), SF);
1107 GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
1109 I.getOperand(0)->getType());
1110 if (I.isVolatile() && PrintVolatile)
1111 dbgs() << "Volatile store: " << I;
1112}
1113
1114//===----------------------------------------------------------------------===//
1115// Miscellaneous Instruction Implementations
1116//===----------------------------------------------------------------------===//
1117
1119 ExecutionContext &SF = ECStack.back();
1120 GenericValue ArgIndex;
1121 ArgIndex.UIntPairVal.first = ECStack.size() - 1;
1122 ArgIndex.UIntPairVal.second = 0;
1123 SetValue(&I, ArgIndex, SF);
1124}
1125
1127 // va_end is a noop for the interpreter
1128}
1129
1131 ExecutionContext &SF = ECStack.back();
1132 SetValue(&I, getOperandValue(*I.arg_begin(), SF), SF);
1133}
1134
1136 ExecutionContext &SF = ECStack.back();
1137
1138 // If it is an unknown intrinsic function, use the intrinsic lowering
1139 // class to transform it into hopefully tasty LLVM code.
1140 //
1142 BasicBlock *Parent = I.getParent();
1143 bool atBegin(Parent->begin() == Me);
1144 if (!atBegin)
1145 --Me;
1146 IL->LowerIntrinsicCall(&I);
1147
1148 // Restore the CurInst pointer to the first instruction newly inserted, if
1149 // any.
1150 if (atBegin) {
1151 SF.CurInst = Parent->begin();
1152 } else {
1153 SF.CurInst = Me;
1154 ++SF.CurInst;
1155 }
1156}
1157
1159 ExecutionContext &SF = ECStack.back();
1160
1161 SF.Caller = &I;
1162 std::vector<GenericValue> ArgVals;
1163 const unsigned NumArgs = SF.Caller->arg_size();
1164 ArgVals.reserve(NumArgs);
1165 for (Value *V : SF.Caller->args())
1166 ArgVals.push_back(getOperandValue(V, SF));
1167
1168 // To handle indirect calls, we must get the pointer value from the argument
1169 // and treat it as a function pointer.
1170 GenericValue SRC = getOperandValue(SF.Caller->getCalledOperand(), SF);
1171 callFunction((Function*)GVTOP(SRC), ArgVals);
1172}
1173
1174// auxiliary function for shift operations
1175static unsigned getShiftAmount(uint64_t orgShiftAmount,
1176 llvm::APInt valueToShift) {
1177 unsigned valueWidth = valueToShift.getBitWidth();
1178 if (orgShiftAmount < (uint64_t)valueWidth)
1179 return orgShiftAmount;
1180 // according to the llvm documentation, if orgShiftAmount > valueWidth,
1181 // the result is undfeined. but we do shift by this rule:
1182 return (NextPowerOf2(valueWidth-1) - 1) & orgShiftAmount;
1183}
1184
1185
1187 ExecutionContext &SF = ECStack.back();
1188 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
1189 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
1190 GenericValue Dest;
1191 Type *Ty = I.getType();
1192
1193 if (Ty->isVectorTy()) {
1194 uint32_t src1Size = uint32_t(Src1.AggregateVal.size());
1195 assert(src1Size == Src2.AggregateVal.size());
1196 for (unsigned i = 0; i < src1Size; i++) {
1197 GenericValue Result;
1198 uint64_t shiftAmount = Src2.AggregateVal[i].IntVal.getZExtValue();
1199 llvm::APInt valueToShift = Src1.AggregateVal[i].IntVal;
1200 Result.IntVal = valueToShift.shl(getShiftAmount(shiftAmount, valueToShift));
1201 Dest.AggregateVal.push_back(Result);
1202 }
1203 } else {
1204 // scalar
1205 uint64_t shiftAmount = Src2.IntVal.getZExtValue();
1206 llvm::APInt valueToShift = Src1.IntVal;
1207 Dest.IntVal = valueToShift.shl(getShiftAmount(shiftAmount, valueToShift));
1208 }
1209
1210 SetValue(&I, Dest, SF);
1211}
1212
1214 ExecutionContext &SF = ECStack.back();
1215 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
1216 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
1217 GenericValue Dest;
1218 Type *Ty = I.getType();
1219
1220 if (Ty->isVectorTy()) {
1221 uint32_t src1Size = uint32_t(Src1.AggregateVal.size());
1222 assert(src1Size == Src2.AggregateVal.size());
1223 for (unsigned i = 0; i < src1Size; i++) {
1224 GenericValue Result;
1225 uint64_t shiftAmount = Src2.AggregateVal[i].IntVal.getZExtValue();
1226 llvm::APInt valueToShift = Src1.AggregateVal[i].IntVal;
1227 Result.IntVal = valueToShift.lshr(getShiftAmount(shiftAmount, valueToShift));
1228 Dest.AggregateVal.push_back(Result);
1229 }
1230 } else {
1231 // scalar
1232 uint64_t shiftAmount = Src2.IntVal.getZExtValue();
1233 llvm::APInt valueToShift = Src1.IntVal;
1234 Dest.IntVal = valueToShift.lshr(getShiftAmount(shiftAmount, valueToShift));
1235 }
1236
1237 SetValue(&I, Dest, SF);
1238}
1239
1241 ExecutionContext &SF = ECStack.back();
1242 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
1243 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
1244 GenericValue Dest;
1245 Type *Ty = I.getType();
1246
1247 if (Ty->isVectorTy()) {
1248 size_t src1Size = Src1.AggregateVal.size();
1249 assert(src1Size == Src2.AggregateVal.size());
1250 for (unsigned i = 0; i < src1Size; i++) {
1251 GenericValue Result;
1252 uint64_t shiftAmount = Src2.AggregateVal[i].IntVal.getZExtValue();
1253 llvm::APInt valueToShift = Src1.AggregateVal[i].IntVal;
1254 Result.IntVal = valueToShift.ashr(getShiftAmount(shiftAmount, valueToShift));
1255 Dest.AggregateVal.push_back(Result);
1256 }
1257 } else {
1258 // scalar
1259 uint64_t shiftAmount = Src2.IntVal.getZExtValue();
1260 llvm::APInt valueToShift = Src1.IntVal;
1261 Dest.IntVal = valueToShift.ashr(getShiftAmount(shiftAmount, valueToShift));
1262 }
1263
1264 SetValue(&I, Dest, SF);
1265}
1266
1267GenericValue Interpreter::executeTruncInst(Value *SrcVal, Type *DstTy,
1268 ExecutionContext &SF) {
1269 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1270 Type *SrcTy = SrcVal->getType();
1271 if (SrcTy->isVectorTy()) {
1272 Type *DstVecTy = DstTy->getScalarType();
1273 unsigned DBitWidth = cast<IntegerType>(DstVecTy)->getBitWidth();
1274 unsigned NumElts = Src.AggregateVal.size();
1275 // the sizes of src and dst vectors must be equal
1276 Dest.AggregateVal.resize(NumElts);
1277 for (unsigned i = 0; i < NumElts; i++)
1278 Dest.AggregateVal[i].IntVal = Src.AggregateVal[i].IntVal.trunc(DBitWidth);
1279 } else {
1280 IntegerType *DITy = cast<IntegerType>(DstTy);
1281 unsigned DBitWidth = DITy->getBitWidth();
1282 Dest.IntVal = Src.IntVal.trunc(DBitWidth);
1283 }
1284 return Dest;
1285}
1286
1287GenericValue Interpreter::executeSExtInst(Value *SrcVal, Type *DstTy,
1288 ExecutionContext &SF) {
1289 Type *SrcTy = SrcVal->getType();
1290 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1291 if (SrcTy->isVectorTy()) {
1292 Type *DstVecTy = DstTy->getScalarType();
1293 unsigned DBitWidth = cast<IntegerType>(DstVecTy)->getBitWidth();
1294 unsigned size = Src.AggregateVal.size();
1295 // the sizes of src and dst vectors must be equal.
1296 Dest.AggregateVal.resize(size);
1297 for (unsigned i = 0; i < size; i++)
1298 Dest.AggregateVal[i].IntVal = Src.AggregateVal[i].IntVal.sext(DBitWidth);
1299 } else {
1300 auto *DITy = cast<IntegerType>(DstTy);
1301 unsigned DBitWidth = DITy->getBitWidth();
1302 Dest.IntVal = Src.IntVal.sext(DBitWidth);
1303 }
1304 return Dest;
1305}
1306
1307GenericValue Interpreter::executeZExtInst(Value *SrcVal, Type *DstTy,
1308 ExecutionContext &SF) {
1309 Type *SrcTy = SrcVal->getType();
1310 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1311 if (SrcTy->isVectorTy()) {
1312 Type *DstVecTy = DstTy->getScalarType();
1313 unsigned DBitWidth = cast<IntegerType>(DstVecTy)->getBitWidth();
1314
1315 unsigned size = Src.AggregateVal.size();
1316 // the sizes of src and dst vectors must be equal.
1317 Dest.AggregateVal.resize(size);
1318 for (unsigned i = 0; i < size; i++)
1319 Dest.AggregateVal[i].IntVal = Src.AggregateVal[i].IntVal.zext(DBitWidth);
1320 } else {
1321 auto *DITy = cast<IntegerType>(DstTy);
1322 unsigned DBitWidth = DITy->getBitWidth();
1323 Dest.IntVal = Src.IntVal.zext(DBitWidth);
1324 }
1325 return Dest;
1326}
1327
1328GenericValue Interpreter::executeFPTruncInst(Value *SrcVal, Type *DstTy,
1329 ExecutionContext &SF) {
1330 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1331
1332 if (isa<VectorType>(SrcVal->getType())) {
1333 assert(SrcVal->getType()->getScalarType()->isDoubleTy() &&
1334 DstTy->getScalarType()->isFloatTy() &&
1335 "Invalid FPTrunc instruction");
1336
1337 unsigned size = Src.AggregateVal.size();
1338 // the sizes of src and dst vectors must be equal.
1339 Dest.AggregateVal.resize(size);
1340 for (unsigned i = 0; i < size; i++)
1341 Dest.AggregateVal[i].FloatVal = (float)Src.AggregateVal[i].DoubleVal;
1342 } else {
1343 assert(SrcVal->getType()->isDoubleTy() && DstTy->isFloatTy() &&
1344 "Invalid FPTrunc instruction");
1345 Dest.FloatVal = (float)Src.DoubleVal;
1346 }
1347
1348 return Dest;
1349}
1350
1351GenericValue Interpreter::executeFPExtInst(Value *SrcVal, Type *DstTy,
1352 ExecutionContext &SF) {
1353 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1354
1355 if (isa<VectorType>(SrcVal->getType())) {
1356 assert(SrcVal->getType()->getScalarType()->isFloatTy() &&
1357 DstTy->getScalarType()->isDoubleTy() && "Invalid FPExt instruction");
1358
1359 unsigned size = Src.AggregateVal.size();
1360 // the sizes of src and dst vectors must be equal.
1361 Dest.AggregateVal.resize(size);
1362 for (unsigned i = 0; i < size; i++)
1363 Dest.AggregateVal[i].DoubleVal = (double)Src.AggregateVal[i].FloatVal;
1364 } else {
1365 assert(SrcVal->getType()->isFloatTy() && DstTy->isDoubleTy() &&
1366 "Invalid FPExt instruction");
1367 Dest.DoubleVal = (double)Src.FloatVal;
1368 }
1369
1370 return Dest;
1371}
1372
1373GenericValue Interpreter::executeFPToUIInst(Value *SrcVal, Type *DstTy,
1374 ExecutionContext &SF) {
1375 Type *SrcTy = SrcVal->getType();
1376 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1377
1378 if (isa<VectorType>(SrcTy)) {
1379 Type *DstVecTy = DstTy->getScalarType();
1380 Type *SrcVecTy = SrcTy->getScalarType();
1381 uint32_t DBitWidth = cast<IntegerType>(DstVecTy)->getBitWidth();
1382 unsigned size = Src.AggregateVal.size();
1383 // the sizes of src and dst vectors must be equal.
1384 Dest.AggregateVal.resize(size);
1385
1386 if (SrcVecTy->getTypeID() == Type::FloatTyID) {
1387 assert(SrcVecTy->isFloatingPointTy() && "Invalid FPToUI instruction");
1388 for (unsigned i = 0; i < size; i++)
1390 Src.AggregateVal[i].FloatVal, DBitWidth);
1391 } else {
1392 for (unsigned i = 0; i < size; i++)
1394 Src.AggregateVal[i].DoubleVal, DBitWidth);
1395 }
1396 } else {
1397 // scalar
1398 uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth();
1399 assert(SrcTy->isFloatingPointTy() && "Invalid FPToUI instruction");
1400
1401 if (SrcTy->getTypeID() == Type::FloatTyID)
1402 Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth);
1403 else {
1404 Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth);
1405 }
1406 }
1407
1408 return Dest;
1409}
1410
1411GenericValue Interpreter::executeFPToSIInst(Value *SrcVal, Type *DstTy,
1412 ExecutionContext &SF) {
1413 Type *SrcTy = SrcVal->getType();
1414 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1415
1416 if (isa<VectorType>(SrcTy)) {
1417 Type *DstVecTy = DstTy->getScalarType();
1418 Type *SrcVecTy = SrcTy->getScalarType();
1419 uint32_t DBitWidth = cast<IntegerType>(DstVecTy)->getBitWidth();
1420 unsigned size = Src.AggregateVal.size();
1421 // the sizes of src and dst vectors must be equal
1422 Dest.AggregateVal.resize(size);
1423
1424 if (SrcVecTy->getTypeID() == Type::FloatTyID) {
1425 assert(SrcVecTy->isFloatingPointTy() && "Invalid FPToSI instruction");
1426 for (unsigned i = 0; i < size; i++)
1428 Src.AggregateVal[i].FloatVal, DBitWidth);
1429 } else {
1430 for (unsigned i = 0; i < size; i++)
1432 Src.AggregateVal[i].DoubleVal, DBitWidth);
1433 }
1434 } else {
1435 // scalar
1436 unsigned DBitWidth = cast<IntegerType>(DstTy)->getBitWidth();
1437 assert(SrcTy->isFloatingPointTy() && "Invalid FPToSI instruction");
1438
1439 if (SrcTy->getTypeID() == Type::FloatTyID)
1440 Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth);
1441 else {
1442 Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth);
1443 }
1444 }
1445 return Dest;
1446}
1447
1448GenericValue Interpreter::executeUIToFPInst(Value *SrcVal, Type *DstTy,
1449 ExecutionContext &SF) {
1450 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1451
1452 if (isa<VectorType>(SrcVal->getType())) {
1453 Type *DstVecTy = DstTy->getScalarType();
1454 unsigned size = Src.AggregateVal.size();
1455 // the sizes of src and dst vectors must be equal
1456 Dest.AggregateVal.resize(size);
1457
1458 if (DstVecTy->getTypeID() == Type::FloatTyID) {
1459 assert(DstVecTy->isFloatingPointTy() && "Invalid UIToFP instruction");
1460 for (unsigned i = 0; i < size; i++)
1461 Dest.AggregateVal[i].FloatVal =
1462 APIntOps::RoundAPIntToFloat(Src.AggregateVal[i].IntVal);
1463 } else {
1464 for (unsigned i = 0; i < size; i++)
1465 Dest.AggregateVal[i].DoubleVal =
1466 APIntOps::RoundAPIntToDouble(Src.AggregateVal[i].IntVal);
1467 }
1468 } else {
1469 // scalar
1470 assert(DstTy->isFloatingPointTy() && "Invalid UIToFP instruction");
1471 if (DstTy->getTypeID() == Type::FloatTyID)
1472 Dest.FloatVal = APIntOps::RoundAPIntToFloat(Src.IntVal);
1473 else {
1474 Dest.DoubleVal = APIntOps::RoundAPIntToDouble(Src.IntVal);
1475 }
1476 }
1477 return Dest;
1478}
1479
1480GenericValue Interpreter::executeSIToFPInst(Value *SrcVal, Type *DstTy,
1481 ExecutionContext &SF) {
1482 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1483
1484 if (isa<VectorType>(SrcVal->getType())) {
1485 Type *DstVecTy = DstTy->getScalarType();
1486 unsigned size = Src.AggregateVal.size();
1487 // the sizes of src and dst vectors must be equal
1488 Dest.AggregateVal.resize(size);
1489
1490 if (DstVecTy->getTypeID() == Type::FloatTyID) {
1491 assert(DstVecTy->isFloatingPointTy() && "Invalid SIToFP instruction");
1492 for (unsigned i = 0; i < size; i++)
1493 Dest.AggregateVal[i].FloatVal =
1494 APIntOps::RoundSignedAPIntToFloat(Src.AggregateVal[i].IntVal);
1495 } else {
1496 for (unsigned i = 0; i < size; i++)
1497 Dest.AggregateVal[i].DoubleVal =
1498 APIntOps::RoundSignedAPIntToDouble(Src.AggregateVal[i].IntVal);
1499 }
1500 } else {
1501 // scalar
1502 assert(DstTy->isFloatingPointTy() && "Invalid SIToFP instruction");
1503
1504 if (DstTy->getTypeID() == Type::FloatTyID)
1506 else {
1508 }
1509 }
1510
1511 return Dest;
1512}
1513
1514GenericValue Interpreter::executePtrToIntInst(Value *SrcVal, Type *DstTy,
1515 ExecutionContext &SF) {
1516 uint32_t DBitWidth = cast<IntegerType>(DstTy)->getBitWidth();
1517 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1518 assert(SrcVal->getType()->isPointerTy() && "Invalid PtrToInt instruction");
1519
1520 Dest.IntVal = APInt(DBitWidth, (intptr_t) Src.PointerVal);
1521 return Dest;
1522}
1523
1524GenericValue Interpreter::executeIntToPtrInst(Value *SrcVal, Type *DstTy,
1525 ExecutionContext &SF) {
1526 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1527 assert(DstTy->isPointerTy() && "Invalid PtrToInt instruction");
1528
1530 if (PtrSize != Src.IntVal.getBitWidth())
1531 Src.IntVal = Src.IntVal.zextOrTrunc(PtrSize);
1532
1533 Dest.PointerVal = PointerTy(intptr_t(Src.IntVal.getZExtValue()));
1534 return Dest;
1535}
1536
1537GenericValue Interpreter::executeBitCastInst(Value *SrcVal, Type *DstTy,
1538 ExecutionContext &SF) {
1539
1540 // This instruction supports bitwise conversion of vectors to integers and
1541 // to vectors of other types (as long as they have the same size)
1542 Type *SrcTy = SrcVal->getType();
1543 GenericValue Dest, Src = getOperandValue(SrcVal, SF);
1544
1545 if (isa<VectorType>(SrcTy) || isa<VectorType>(DstTy)) {
1546 // vector src bitcast to vector dst or vector src bitcast to scalar dst or
1547 // scalar src bitcast to vector dst
1548 bool isLittleEndian = getDataLayout().isLittleEndian();
1549 GenericValue TempDst, TempSrc, SrcVec;
1550 Type *SrcElemTy;
1551 Type *DstElemTy;
1552 unsigned SrcBitSize;
1553 unsigned DstBitSize;
1554 unsigned SrcNum;
1555 unsigned DstNum;
1556
1557 if (isa<VectorType>(SrcTy)) {
1558 SrcElemTy = SrcTy->getScalarType();
1559 SrcBitSize = SrcTy->getScalarSizeInBits();
1560 SrcNum = Src.AggregateVal.size();
1561 SrcVec = Src;
1562 } else {
1563 // if src is scalar value, make it vector <1 x type>
1564 SrcElemTy = SrcTy;
1565 SrcBitSize = SrcTy->getPrimitiveSizeInBits();
1566 SrcNum = 1;
1567 SrcVec.AggregateVal.push_back(Src);
1568 }
1569
1570 if (isa<VectorType>(DstTy)) {
1571 DstElemTy = DstTy->getScalarType();
1572 DstBitSize = DstTy->getScalarSizeInBits();
1573 DstNum = (SrcNum * SrcBitSize) / DstBitSize;
1574 } else {
1575 DstElemTy = DstTy;
1576 DstBitSize = DstTy->getPrimitiveSizeInBits();
1577 DstNum = 1;
1578 }
1579
1580 if (SrcNum * SrcBitSize != DstNum * DstBitSize)
1581 llvm_unreachable("Invalid BitCast");
1582
1583 // If src is floating point, cast to integer first.
1584 TempSrc.AggregateVal.resize(SrcNum);
1585 if (SrcElemTy->isFloatTy()) {
1586 for (unsigned i = 0; i < SrcNum; i++)
1587 TempSrc.AggregateVal[i].IntVal =
1588 APInt::floatToBits(SrcVec.AggregateVal[i].FloatVal);
1589
1590 } else if (SrcElemTy->isDoubleTy()) {
1591 for (unsigned i = 0; i < SrcNum; i++)
1592 TempSrc.AggregateVal[i].IntVal =
1593 APInt::doubleToBits(SrcVec.AggregateVal[i].DoubleVal);
1594 } else if (SrcElemTy->isIntegerTy()) {
1595 for (unsigned i = 0; i < SrcNum; i++)
1596 TempSrc.AggregateVal[i].IntVal = SrcVec.AggregateVal[i].IntVal;
1597 } else {
1598 // Pointers are not allowed as the element type of vector.
1599 llvm_unreachable("Invalid Bitcast");
1600 }
1601
1602 // now TempSrc is integer type vector
1603 if (DstNum < SrcNum) {
1604 // Example: bitcast <4 x i32> <i32 0, i32 1, i32 2, i32 3> to <2 x i64>
1605 unsigned Ratio = SrcNum / DstNum;
1606 unsigned SrcElt = 0;
1607 for (unsigned i = 0; i < DstNum; i++) {
1608 GenericValue Elt;
1609 Elt.IntVal = 0;
1610 Elt.IntVal = Elt.IntVal.zext(DstBitSize);
1611 unsigned ShiftAmt = isLittleEndian ? 0 : SrcBitSize * (Ratio - 1);
1612 for (unsigned j = 0; j < Ratio; j++) {
1613 APInt Tmp;
1614 Tmp = Tmp.zext(SrcBitSize);
1615 Tmp = TempSrc.AggregateVal[SrcElt++].IntVal;
1616 Tmp = Tmp.zext(DstBitSize);
1617 Tmp <<= ShiftAmt;
1618 ShiftAmt += isLittleEndian ? SrcBitSize : -SrcBitSize;
1619 Elt.IntVal |= Tmp;
1620 }
1621 TempDst.AggregateVal.push_back(Elt);
1622 }
1623 } else {
1624 // Example: bitcast <2 x i64> <i64 0, i64 1> to <4 x i32>
1625 unsigned Ratio = DstNum / SrcNum;
1626 for (unsigned i = 0; i < SrcNum; i++) {
1627 unsigned ShiftAmt = isLittleEndian ? 0 : DstBitSize * (Ratio - 1);
1628 for (unsigned j = 0; j < Ratio; j++) {
1629 GenericValue Elt;
1630 Elt.IntVal = Elt.IntVal.zext(SrcBitSize);
1631 Elt.IntVal = TempSrc.AggregateVal[i].IntVal;
1632 Elt.IntVal.lshrInPlace(ShiftAmt);
1633 // it could be DstBitSize == SrcBitSize, so check it
1634 if (DstBitSize < SrcBitSize)
1635 Elt.IntVal = Elt.IntVal.trunc(DstBitSize);
1636 ShiftAmt += isLittleEndian ? DstBitSize : -DstBitSize;
1637 TempDst.AggregateVal.push_back(Elt);
1638 }
1639 }
1640 }
1641
1642 // convert result from integer to specified type
1643 if (isa<VectorType>(DstTy)) {
1644 if (DstElemTy->isDoubleTy()) {
1645 Dest.AggregateVal.resize(DstNum);
1646 for (unsigned i = 0; i < DstNum; i++)
1647 Dest.AggregateVal[i].DoubleVal =
1648 TempDst.AggregateVal[i].IntVal.bitsToDouble();
1649 } else if (DstElemTy->isFloatTy()) {
1650 Dest.AggregateVal.resize(DstNum);
1651 for (unsigned i = 0; i < DstNum; i++)
1652 Dest.AggregateVal[i].FloatVal =
1653 TempDst.AggregateVal[i].IntVal.bitsToFloat();
1654 } else {
1655 Dest = TempDst;
1656 }
1657 } else {
1658 if (DstElemTy->isDoubleTy())
1659 Dest.DoubleVal = TempDst.AggregateVal[0].IntVal.bitsToDouble();
1660 else if (DstElemTy->isFloatTy()) {
1661 Dest.FloatVal = TempDst.AggregateVal[0].IntVal.bitsToFloat();
1662 } else {
1663 Dest.IntVal = TempDst.AggregateVal[0].IntVal;
1664 }
1665 }
1666 } else { // if (isa<VectorType>(SrcTy)) || isa<VectorType>(DstTy))
1667
1668 // scalar src bitcast to scalar dst
1669 if (DstTy->isPointerTy()) {
1670 assert(SrcTy->isPointerTy() && "Invalid BitCast");
1671 Dest.PointerVal = Src.PointerVal;
1672 } else if (DstTy->isIntegerTy()) {
1673 if (SrcTy->isFloatTy())
1674 Dest.IntVal = APInt::floatToBits(Src.FloatVal);
1675 else if (SrcTy->isDoubleTy()) {
1676 Dest.IntVal = APInt::doubleToBits(Src.DoubleVal);
1677 } else if (SrcTy->isIntegerTy()) {
1678 Dest.IntVal = Src.IntVal;
1679 } else {
1680 llvm_unreachable("Invalid BitCast");
1681 }
1682 } else if (DstTy->isFloatTy()) {
1683 if (SrcTy->isIntegerTy())
1684 Dest.FloatVal = Src.IntVal.bitsToFloat();
1685 else {
1686 Dest.FloatVal = Src.FloatVal;
1687 }
1688 } else if (DstTy->isDoubleTy()) {
1689 if (SrcTy->isIntegerTy())
1690 Dest.DoubleVal = Src.IntVal.bitsToDouble();
1691 else {
1692 Dest.DoubleVal = Src.DoubleVal;
1693 }
1694 } else {
1695 llvm_unreachable("Invalid Bitcast");
1696 }
1697 }
1698
1699 return Dest;
1700}
1701
1703 ExecutionContext &SF = ECStack.back();
1704 SetValue(&I, executeTruncInst(I.getOperand(0), I.getType(), SF), SF);
1705}
1706
1708 ExecutionContext &SF = ECStack.back();
1709 SetValue(&I, executeSExtInst(I.getOperand(0), I.getType(), SF), SF);
1710}
1711
1713 ExecutionContext &SF = ECStack.back();
1714 SetValue(&I, executeZExtInst(I.getOperand(0), I.getType(), SF), SF);
1715}
1716
1718 ExecutionContext &SF = ECStack.back();
1719 SetValue(&I, executeFPTruncInst(I.getOperand(0), I.getType(), SF), SF);
1720}
1721
1723 ExecutionContext &SF = ECStack.back();
1724 SetValue(&I, executeFPExtInst(I.getOperand(0), I.getType(), SF), SF);
1725}
1726
1728 ExecutionContext &SF = ECStack.back();
1729 SetValue(&I, executeUIToFPInst(I.getOperand(0), I.getType(), SF), SF);
1730}
1731
1733 ExecutionContext &SF = ECStack.back();
1734 SetValue(&I, executeSIToFPInst(I.getOperand(0), I.getType(), SF), SF);
1735}
1736
1738 ExecutionContext &SF = ECStack.back();
1739 SetValue(&I, executeFPToUIInst(I.getOperand(0), I.getType(), SF), SF);
1740}
1741
1743 ExecutionContext &SF = ECStack.back();
1744 SetValue(&I, executeFPToSIInst(I.getOperand(0), I.getType(), SF), SF);
1745}
1746
1748 ExecutionContext &SF = ECStack.back();
1749 SetValue(&I, executePtrToIntInst(I.getOperand(0), I.getType(), SF), SF);
1750}
1751
1753 ExecutionContext &SF = ECStack.back();
1754 SetValue(&I, executeIntToPtrInst(I.getOperand(0), I.getType(), SF), SF);
1755}
1756
1758 ExecutionContext &SF = ECStack.back();
1759 SetValue(&I, executeBitCastInst(I.getOperand(0), I.getType(), SF), SF);
1760}
1761
1762#define IMPLEMENT_VAARG(TY) \
1763 case Type::TY##TyID: Dest.TY##Val = Src.TY##Val; break
1764
1766 ExecutionContext &SF = ECStack.back();
1767
1768 // Get the incoming valist parameter. LLI treats the valist as a
1769 // (ec-stack-depth var-arg-index) pair.
1770 GenericValue VAList = getOperandValue(I.getOperand(0), SF);
1771 GenericValue Dest;
1772 GenericValue Src = ECStack[VAList.UIntPairVal.first]
1773 .VarArgs[VAList.UIntPairVal.second];
1774 Type *Ty = I.getType();
1775 switch (Ty->getTypeID()) {
1776 case Type::IntegerTyID:
1777 Dest.IntVal = Src.IntVal;
1778 break;
1779 IMPLEMENT_VAARG(Pointer);
1780 IMPLEMENT_VAARG(Float);
1781 IMPLEMENT_VAARG(Double);
1782 default:
1783 dbgs() << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
1784 llvm_unreachable(nullptr);
1785 }
1786
1787 // Set the Value of this Instruction.
1788 SetValue(&I, Dest, SF);
1789
1790 // Move the pointer to the next vararg.
1791 ++VAList.UIntPairVal.second;
1792}
1793
1795 ExecutionContext &SF = ECStack.back();
1796 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
1797 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
1798 GenericValue Dest;
1799
1800 Type *Ty = I.getType();
1801 const unsigned indx = unsigned(Src2.IntVal.getZExtValue());
1802
1803 if(Src1.AggregateVal.size() > indx) {
1804 switch (Ty->getTypeID()) {
1805 default:
1806 dbgs() << "Unhandled destination type for extractelement instruction: "
1807 << *Ty << "\n";
1808 llvm_unreachable(nullptr);
1809 break;
1810 case Type::IntegerTyID:
1811 Dest.IntVal = Src1.AggregateVal[indx].IntVal;
1812 break;
1813 case Type::FloatTyID:
1814 Dest.FloatVal = Src1.AggregateVal[indx].FloatVal;
1815 break;
1816 case Type::DoubleTyID:
1817 Dest.DoubleVal = Src1.AggregateVal[indx].DoubleVal;
1818 break;
1819 }
1820 } else {
1821 dbgs() << "Invalid index in extractelement instruction\n";
1822 }
1823
1824 SetValue(&I, Dest, SF);
1825}
1826
1828 ExecutionContext &SF = ECStack.back();
1829 VectorType *Ty = cast<VectorType>(I.getType());
1830
1831 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
1832 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
1833 GenericValue Src3 = getOperandValue(I.getOperand(2), SF);
1834 GenericValue Dest;
1835
1836 Type *TyContained = Ty->getElementType();
1837
1838 const unsigned indx = unsigned(Src3.IntVal.getZExtValue());
1839 Dest.AggregateVal = Src1.AggregateVal;
1840
1841 if(Src1.AggregateVal.size() <= indx)
1842 llvm_unreachable("Invalid index in insertelement instruction");
1843 switch (TyContained->getTypeID()) {
1844 default:
1845 llvm_unreachable("Unhandled dest type for insertelement instruction");
1846 case Type::IntegerTyID:
1847 Dest.AggregateVal[indx].IntVal = Src2.IntVal;
1848 break;
1849 case Type::FloatTyID:
1850 Dest.AggregateVal[indx].FloatVal = Src2.FloatVal;
1851 break;
1852 case Type::DoubleTyID:
1853 Dest.AggregateVal[indx].DoubleVal = Src2.DoubleVal;
1854 break;
1855 }
1856 SetValue(&I, Dest, SF);
1857}
1858
1860 ExecutionContext &SF = ECStack.back();
1861
1862 VectorType *Ty = cast<VectorType>(I.getType());
1863
1864 GenericValue Src1 = getOperandValue(I.getOperand(0), SF);
1865 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
1866 GenericValue Dest;
1867
1868 // There is no need to check types of src1 and src2, because the compiled
1869 // bytecode can't contain different types for src1 and src2 for a
1870 // shufflevector instruction.
1871
1872 Type *TyContained = Ty->getElementType();
1873 unsigned src1Size = (unsigned)Src1.AggregateVal.size();
1874 unsigned src2Size = (unsigned)Src2.AggregateVal.size();
1875 unsigned src3Size = I.getShuffleMask().size();
1876
1877 Dest.AggregateVal.resize(src3Size);
1878
1879 switch (TyContained->getTypeID()) {
1880 default:
1881 llvm_unreachable("Unhandled dest type for insertelement instruction");
1882 break;
1883 case Type::IntegerTyID:
1884 for( unsigned i=0; i<src3Size; i++) {
1885 unsigned j = std::max(0, I.getMaskValue(i));
1886 if(j < src1Size)
1887 Dest.AggregateVal[i].IntVal = Src1.AggregateVal[j].IntVal;
1888 else if(j < src1Size + src2Size)
1889 Dest.AggregateVal[i].IntVal = Src2.AggregateVal[j-src1Size].IntVal;
1890 else
1891 // The selector may not be greater than sum of lengths of first and
1892 // second operands and llasm should not allow situation like
1893 // %tmp = shufflevector <2 x i32> <i32 3, i32 4>, <2 x i32> undef,
1894 // <2 x i32> < i32 0, i32 5 >,
1895 // where i32 5 is invalid, but let it be additional check here:
1896 llvm_unreachable("Invalid mask in shufflevector instruction");
1897 }
1898 break;
1899 case Type::FloatTyID:
1900 for( unsigned i=0; i<src3Size; i++) {
1901 unsigned j = std::max(0, I.getMaskValue(i));
1902 if(j < src1Size)
1903 Dest.AggregateVal[i].FloatVal = Src1.AggregateVal[j].FloatVal;
1904 else if(j < src1Size + src2Size)
1905 Dest.AggregateVal[i].FloatVal = Src2.AggregateVal[j-src1Size].FloatVal;
1906 else
1907 llvm_unreachable("Invalid mask in shufflevector instruction");
1908 }
1909 break;
1910 case Type::DoubleTyID:
1911 for( unsigned i=0; i<src3Size; i++) {
1912 unsigned j = std::max(0, I.getMaskValue(i));
1913 if(j < src1Size)
1914 Dest.AggregateVal[i].DoubleVal = Src1.AggregateVal[j].DoubleVal;
1915 else if(j < src1Size + src2Size)
1916 Dest.AggregateVal[i].DoubleVal =
1917 Src2.AggregateVal[j-src1Size].DoubleVal;
1918 else
1919 llvm_unreachable("Invalid mask in shufflevector instruction");
1920 }
1921 break;
1922 }
1923 SetValue(&I, Dest, SF);
1924}
1925
1927 ExecutionContext &SF = ECStack.back();
1928 Value *Agg = I.getAggregateOperand();
1929 GenericValue Dest;
1930 GenericValue Src = getOperandValue(Agg, SF);
1931
1932 ExtractValueInst::idx_iterator IdxBegin = I.idx_begin();
1933 unsigned Num = I.getNumIndices();
1934 GenericValue *pSrc = &Src;
1935
1936 for (unsigned i = 0 ; i < Num; ++i) {
1937 pSrc = &pSrc->AggregateVal[*IdxBegin];
1938 ++IdxBegin;
1939 }
1940
1941 Type *IndexedType = ExtractValueInst::getIndexedType(Agg->getType(), I.getIndices());
1942 switch (IndexedType->getTypeID()) {
1943 default:
1944 llvm_unreachable("Unhandled dest type for extractelement instruction");
1945 break;
1946 case Type::IntegerTyID:
1947 Dest.IntVal = pSrc->IntVal;
1948 break;
1949 case Type::FloatTyID:
1950 Dest.FloatVal = pSrc->FloatVal;
1951 break;
1952 case Type::DoubleTyID:
1953 Dest.DoubleVal = pSrc->DoubleVal;
1954 break;
1955 case Type::ArrayTyID:
1956 case Type::StructTyID:
1959 Dest.AggregateVal = pSrc->AggregateVal;
1960 break;
1961 case Type::PointerTyID:
1962 Dest.PointerVal = pSrc->PointerVal;
1963 break;
1964 }
1965
1966 SetValue(&I, Dest, SF);
1967}
1968
1970
1971 ExecutionContext &SF = ECStack.back();
1972 Value *Agg = I.getAggregateOperand();
1973
1974 GenericValue Src1 = getOperandValue(Agg, SF);
1975 GenericValue Src2 = getOperandValue(I.getOperand(1), SF);
1976 GenericValue Dest = Src1; // Dest is a slightly changed Src1
1977
1978 ExtractValueInst::idx_iterator IdxBegin = I.idx_begin();
1979 unsigned Num = I.getNumIndices();
1980
1981 GenericValue *pDest = &Dest;
1982 for (unsigned i = 0 ; i < Num; ++i) {
1983 pDest = &pDest->AggregateVal[*IdxBegin];
1984 ++IdxBegin;
1985 }
1986 // pDest points to the target value in the Dest now
1987
1988 Type *IndexedType = ExtractValueInst::getIndexedType(Agg->getType(), I.getIndices());
1989
1990 switch (IndexedType->getTypeID()) {
1991 default:
1992 llvm_unreachable("Unhandled dest type for insertelement instruction");
1993 break;
1994 case Type::IntegerTyID:
1995 pDest->IntVal = Src2.IntVal;
1996 break;
1997 case Type::FloatTyID:
1998 pDest->FloatVal = Src2.FloatVal;
1999 break;
2000 case Type::DoubleTyID:
2001 pDest->DoubleVal = Src2.DoubleVal;
2002 break;
2003 case Type::ArrayTyID:
2004 case Type::StructTyID:
2007 pDest->AggregateVal = Src2.AggregateVal;
2008 break;
2009 case Type::PointerTyID:
2010 pDest->PointerVal = Src2.PointerVal;
2011 break;
2012 }
2013
2014 SetValue(&I, Dest, SF);
2015}
2016
2017GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE,
2018 ExecutionContext &SF) {
2019 switch (CE->getOpcode()) {
2020 case Instruction::Trunc:
2021 return executeTruncInst(CE->getOperand(0), CE->getType(), SF);
2022 case Instruction::ZExt:
2023 return executeZExtInst(CE->getOperand(0), CE->getType(), SF);
2024 case Instruction::SExt:
2025 return executeSExtInst(CE->getOperand(0), CE->getType(), SF);
2026 case Instruction::FPTrunc:
2027 return executeFPTruncInst(CE->getOperand(0), CE->getType(), SF);
2028 case Instruction::FPExt:
2029 return executeFPExtInst(CE->getOperand(0), CE->getType(), SF);
2030 case Instruction::UIToFP:
2031 return executeUIToFPInst(CE->getOperand(0), CE->getType(), SF);
2032 case Instruction::SIToFP:
2033 return executeSIToFPInst(CE->getOperand(0), CE->getType(), SF);
2034 case Instruction::FPToUI:
2035 return executeFPToUIInst(CE->getOperand(0), CE->getType(), SF);
2036 case Instruction::FPToSI:
2037 return executeFPToSIInst(CE->getOperand(0), CE->getType(), SF);
2038 case Instruction::PtrToInt:
2039 return executePtrToIntInst(CE->getOperand(0), CE->getType(), SF);
2040 case Instruction::IntToPtr:
2041 return executeIntToPtrInst(CE->getOperand(0), CE->getType(), SF);
2042 case Instruction::BitCast:
2043 return executeBitCastInst(CE->getOperand(0), CE->getType(), SF);
2044 case Instruction::GetElementPtr:
2045 return executeGEPOperation(CE->getOperand(0), gep_type_begin(CE),
2046 gep_type_end(CE), SF);
2047 case Instruction::FCmp:
2048 case Instruction::ICmp:
2049 return executeCmpInst(CE->getPredicate(),
2050 getOperandValue(CE->getOperand(0), SF),
2051 getOperandValue(CE->getOperand(1), SF),
2052 CE->getOperand(0)->getType());
2053 case Instruction::Select:
2054 return executeSelectInst(getOperandValue(CE->getOperand(0), SF),
2055 getOperandValue(CE->getOperand(1), SF),
2056 getOperandValue(CE->getOperand(2), SF),
2057 CE->getOperand(0)->getType());
2058 default :
2059 break;
2060 }
2061
2062 // The cases below here require a GenericValue parameter for the result
2063 // so we initialize one, compute it and then return it.
2064 GenericValue Op0 = getOperandValue(CE->getOperand(0), SF);
2065 GenericValue Op1 = getOperandValue(CE->getOperand(1), SF);
2066 GenericValue Dest;
2067 Type * Ty = CE->getOperand(0)->getType();
2068 switch (CE->getOpcode()) {
2069 case Instruction::Add: Dest.IntVal = Op0.IntVal + Op1.IntVal; break;
2070 case Instruction::Sub: Dest.IntVal = Op0.IntVal - Op1.IntVal; break;
2071 case Instruction::Mul: Dest.IntVal = Op0.IntVal * Op1.IntVal; break;
2072 case Instruction::FAdd: executeFAddInst(Dest, Op0, Op1, Ty); break;
2073 case Instruction::FSub: executeFSubInst(Dest, Op0, Op1, Ty); break;
2074 case Instruction::FMul: executeFMulInst(Dest, Op0, Op1, Ty); break;
2075 case Instruction::FDiv: executeFDivInst(Dest, Op0, Op1, Ty); break;
2076 case Instruction::FRem: executeFRemInst(Dest, Op0, Op1, Ty); break;
2077 case Instruction::SDiv: Dest.IntVal = Op0.IntVal.sdiv(Op1.IntVal); break;
2078 case Instruction::UDiv: Dest.IntVal = Op0.IntVal.udiv(Op1.IntVal); break;
2079 case Instruction::URem: Dest.IntVal = Op0.IntVal.urem(Op1.IntVal); break;
2080 case Instruction::SRem: Dest.IntVal = Op0.IntVal.srem(Op1.IntVal); break;
2081 case Instruction::And: Dest.IntVal = Op0.IntVal & Op1.IntVal; break;
2082 case Instruction::Or: Dest.IntVal = Op0.IntVal | Op1.IntVal; break;
2083 case Instruction::Xor: Dest.IntVal = Op0.IntVal ^ Op1.IntVal; break;
2084 case Instruction::Shl:
2085 Dest.IntVal = Op0.IntVal.shl(Op1.IntVal.getZExtValue());
2086 break;
2087 case Instruction::LShr:
2088 Dest.IntVal = Op0.IntVal.lshr(Op1.IntVal.getZExtValue());
2089 break;
2090 case Instruction::AShr:
2091 Dest.IntVal = Op0.IntVal.ashr(Op1.IntVal.getZExtValue());
2092 break;
2093 default:
2094 dbgs() << "Unhandled ConstantExpr: " << *CE << "\n";
2095 llvm_unreachable("Unhandled ConstantExpr");
2096 }
2097 return Dest;
2098}
2099
2100GenericValue Interpreter::getOperandValue(Value *V, ExecutionContext &SF) {
2101 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
2102 return getConstantExprValue(CE, SF);
2103 } else if (Constant *CPV = dyn_cast<Constant>(V)) {
2104 return getConstantValue(CPV);
2105 } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2106 return PTOGV(getPointerToGlobal(GV));
2107 } else {
2108 return SF.Values[V];
2109 }
2110}
2111
2112//===----------------------------------------------------------------------===//
2113// Dispatch and Execution Code
2114//===----------------------------------------------------------------------===//
2115
2116//===----------------------------------------------------------------------===//
2117// callFunction - Execute the specified function...
2118//
2120 assert((ECStack.empty() || !ECStack.back().Caller ||
2121 ECStack.back().Caller->arg_size() == ArgVals.size()) &&
2122 "Incorrect number of arguments passed into function call!");
2123 // Make a new stack frame... and fill it in.
2124 ECStack.emplace_back();
2125 ExecutionContext &StackFrame = ECStack.back();
2126 StackFrame.CurFunction = F;
2127
2128 // Special handling for external functions.
2129 if (F->isDeclaration()) {
2130 GenericValue Result = callExternalFunction (F, ArgVals);
2131 // Simulate a 'ret' instruction of the appropriate type.
2132 popStackAndReturnValueToCaller (F->getReturnType (), Result);
2133 return;
2134 }
2135
2136 // Get pointers to first LLVM BB & Instruction in function.
2137 StackFrame.CurBB = &F->front();
2138 StackFrame.CurInst = StackFrame.CurBB->begin();
2139
2140 // Run through the function arguments and initialize their values...
2141 assert((ArgVals.size() == F->arg_size() ||
2142 (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&&
2143 "Invalid number of values passed to function invocation!");
2144
2145 // Handle non-varargs arguments...
2146 unsigned i = 0;
2147 for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
2148 AI != E; ++AI, ++i)
2149 SetValue(&*AI, ArgVals[i], StackFrame);
2150
2151 // Handle varargs arguments...
2152 StackFrame.VarArgs.assign(ArgVals.begin()+i, ArgVals.end());
2153}
2154
2155
2157 while (!ECStack.empty()) {
2158 // Interpret a single instruction & increment the "PC".
2159 ExecutionContext &SF = ECStack.back(); // Current stack frame
2160 Instruction &I = *SF.CurInst++; // Increment before execute
2161
2162 // Track the number of dynamic instructions executed.
2163 ++NumDynamicInsts;
2164
2165 LLVM_DEBUG(dbgs() << "About to interpret: " << I << "\n");
2166 visit(I); // Dispatch to one of the visit* methods...
2167 }
2168}
This file implements a class to represent arbitrary precision integral constant values and operations...
SmallVector< MachineOperand, 4 > Cond
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
return RetTy
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
#define LLVM_DEBUG(X)
Definition: Debug.h:101
static GenericValue executeFCMP_UGE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:561
static GenericValue executeFCMP_OGE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:470
static GenericValue executeICMP_UGT(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:248
static GenericValue executeICMP_SLT(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:234
static GenericValue executeICMP_UGE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:304
static void executeFSubInst(GenericValue &Dest, GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:119
static GenericValue executeFCMP_ULE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:552
#define FLOAT_VECTOR_OP(OP)
#define IMPLEMENT_VECTOR_INTEGER_ICMP(OP, TY)
Definition: Execution.cpp:172
static GenericValue executeCmpInst(unsigned predicate, GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:700
static GenericValue executeICMP_SGT(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:262
static void executeFDivInst(GenericValue &Dest, GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:141
static GenericValue executeICMP_SLE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:290
static GenericValue executeICMP_SGE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:318
static GenericValue executeFCMP_OGT(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:498
#define INTEGER_VECTOR_OPERATION(OP)
#define IMPLEMENT_BINARY_OPERATOR(OP, TY)
Definition: Execution.cpp:103
static GenericValue executeFCMP_UNE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:543
#define IMPLEMENT_SCALAR_NANS(TY, X, Y)
Definition: Execution.cpp:394
static void executeFAddInst(GenericValue &Dest, GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:108
static GenericValue executeFCMP_UNO(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:619
static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2, GenericValue Src3, Type *Ty)
Definition: Execution.cpp:845
static GenericValue executeFCMP_OEQ(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:380
static GenericValue executeFCMP_OLE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:456
static void executeFNegInst(GenericValue &Dest, GenericValue Src, Type *Ty)
Definition: Execution.cpp:49
static cl::opt< bool > PrintVolatile("interpreter-print-volatile", cl::Hidden, cl::desc("make the interpreter print every volatile load and store"))
#define INTEGER_VECTOR_FUNCTION(OP)
#define MASK_VECTOR_NANS(TY, X, Y, FLAG)
Definition: Execution.cpp:419
#define IMPLEMENT_VECTOR_FCMP(OP)
Definition: Execution.cpp:371
static GenericValue executeICMP_ULE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:276
static GenericValue executeFCMP_OLT(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:484
static GenericValue executeFCMP_ULT(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:570
static GenericValue executeICMP_NE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:206
#define IMPLEMENT_POINTER_ICMP(OP)
Definition: Execution.cpp:186
static GenericValue executeFCMP_ORD(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:588
#define IMPLEMENT_UNORDERED(TY, X, Y)
Definition: Execution.cpp:512
static GenericValue executeFCMP_BOOL(GenericValue Src1, GenericValue Src2, Type *Ty, const bool val)
Definition: Execution.cpp:650
static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF)
Definition: Execution.cpp:41
#define IMPLEMENT_VECTOR_UNORDERED(TY, X, Y, FUNC)
Definition: Execution.cpp:523
#define IMPLEMENT_VAARG(TY)
Definition: Execution.cpp:1762
static void executeFRemInst(GenericValue &Dest, GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:152
static unsigned getShiftAmount(uint64_t orgShiftAmount, llvm::APInt valueToShift)
Definition: Execution.cpp:1175
#define IMPLEMENT_INTEGER_ICMP(OP, TY)
Definition: Execution.cpp:167
#define IMPLEMENT_FCMP(OP, TY)
Definition: Execution.cpp:358
static GenericValue executeFCMP_ONE(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:430
static GenericValue executeFCMP_UEQ(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:533
static GenericValue executeICMP_EQ(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:192
static GenericValue executeFCMP_UGT(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:579
static void executeFMulInst(GenericValue &Dest, GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:130
static GenericValue executeICMP_ULT(GenericValue Src1, GenericValue Src2, Type *Ty)
Definition: Execution.cpp:220
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
return ToRemove size() > 0
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:167
Class for arbitrary precision integers.
Definition: APInt.h:75
APInt udiv(const APInt &RHS) const
Unsigned division operation.
Definition: APInt.cpp:1571
APInt zext(unsigned width) const
Zero extend to a new width.
Definition: APInt.cpp:973
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1494
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
Definition: APInt.cpp:994
APInt trunc(unsigned width) const
Truncate to new width.
Definition: APInt.cpp:898
static APInt floatToBits(float V)
Converts a float to APInt bits.
Definition: APInt.h:1691
APInt urem(const APInt &RHS) const
Unsigned remainder operation.
Definition: APInt.cpp:1664
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1439
APInt sdiv(const APInt &RHS) const
Signed division function for APInt.
Definition: APInt.cpp:1642
APInt ashr(unsigned ShiftAmt) const
Arithmetic right-shift function.
Definition: APInt.h:815
APInt srem(const APInt &RHS) const
Function for signed remainder operation.
Definition: APInt.cpp:1734
static APInt doubleToBits(double V)
Converts a double to APInt bits.
Definition: APInt.h:1683
APInt shl(unsigned shiftAmt) const
Left-shift function.
Definition: APInt.h:861
void lshrInPlace(unsigned ShiftAmt)
Logical right-shift this APInt by ShiftAmt in place.
Definition: APInt.h:846
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
Definition: APInt.h:839
an instruction to allocate memory on the stack
Definition: Instructions.h:58
This class represents an incoming formal argument to a Function.
Definition: Argument.h:28
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
iterator end() const
Definition: ArrayRef.h:152
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
iterator begin() const
Definition: ArrayRef.h:151
LLVM Basic Block Representation.
Definition: BasicBlock.h:56
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:314
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:87
This class represents a no-op cast from one type to another.
Conditional or Unconditional Branch instruction.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1184
Value * getCalledOperand() const
Definition: InstrTypes.h:1399
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
Definition: InstrTypes.h:1342
unsigned arg_size() const
Definition: InstrTypes.h:1349
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:721
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:735
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:747
@ ICMP_SLE
signed less or equal
Definition: InstrTypes.h:748
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:724
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:733
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:722
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:723
@ ICMP_UGE
unsigned greater or equal
Definition: InstrTypes.h:742
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:741
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:745
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:732
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:726
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:729
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:743
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:730
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:725
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:727
@ ICMP_EQ
equal
Definition: InstrTypes.h:739
@ ICMP_NE
not equal
Definition: InstrTypes.h:740
@ ICMP_SGE
signed greater or equal
Definition: InstrTypes.h:746
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:734
@ ICMP_ULE
unsigned less or equal
Definition: InstrTypes.h:744
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:731
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:720
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:728
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:998
This is the shared class of boolean and integer constants.
Definition: Constants.h:78
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:141
This is an important base class in LLVM.
Definition: Constant.h:41
unsigned getPointerSizeInBits(unsigned AS=0) const
Layout pointer size, in bits FIXME: The defaults need to be removed once all of the backends/clients ...
Definition: DataLayout.h:413
bool isLittleEndian() const
Layout endianness...
Definition: DataLayout.h:245
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
Definition: DataLayout.cpp:681
TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:507
void StoreValueToMemory(const GenericValue &Val, GenericValue *Ptr, Type *Ty)
StoreValueToMemory - Stores the data in Val of type Ty at address Ptr.
GenericValue getConstantValue(const Constant *C)
Converts a Constant* into a GenericValue, including handling of ConstantExpr values.
const DataLayout & getDataLayout() const
void * getPointerToGlobal(const GlobalValue *GV)
getPointerToGlobal - This returns the address of the specified global value.
void LoadValueFromMemory(GenericValue &Result, GenericValue *Ptr, Type *Ty)
FIXME: document.
This instruction extracts a single (scalar) element from a VectorType value.
This instruction extracts a struct member or array element value from an aggregate value.
static Type * getIndexedType(Type *Agg, ArrayRef< unsigned > Idxs)
Returns the type of the element that would be extracted with an extractvalue instruction with the spe...
This instruction compares its operands according to the predicate given to the constructor.
This class represents an extension of floating point types.
This class represents a cast from floating point to signed integer.
This class represents a cast from floating point to unsigned integer.
This class represents a truncation of floating point types.
an instruction for type-safe pointer arithmetic to access elements of arrays and structs
Definition: Instructions.h:940
This instruction compares its operands according to the predicate given to the constructor.
Indirect Branch Instruction.
This instruction inserts a single (scalar) element into a VectorType value.
This instruction inserts a struct field of array element value into an aggregate value.
void visit(Iterator Start, Iterator End)
Definition: InstVisitor.h:87
This class represents a cast from an integer to a pointer.
Class to represent integer types.
Definition: DerivedTypes.h:40
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:72
void visitSIToFPInst(SIToFPInst &I)
Definition: Execution.cpp:1732
void visitFCmpInst(FCmpInst &I)
Definition: Execution.cpp:665
void visitPtrToIntInst(PtrToIntInst &I)
Definition: Execution.cpp:1747
void visitShuffleVectorInst(ShuffleVectorInst &I)
Definition: Execution.cpp:1859
void visitCallBase(CallBase &I)
Definition: Execution.cpp:1158
void visitAllocaInst(AllocaInst &I)
Definition: Execution.cpp:1017
void visitSelectInst(SelectInst &I)
Definition: Execution.cpp:861
void exitCalled(GenericValue GV)
Definition: Execution.cpp:875
void visitReturnInst(ReturnInst &I)
Definition: Execution.cpp:918
void visitIntToPtrInst(IntToPtrInst &I)
Definition: Execution.cpp:1752
void visitUnreachableInst(UnreachableInst &I)
Definition: Execution.cpp:932
void visitICmpInst(ICmpInst &I)
Definition: Execution.cpp:332
void visitLShr(BinaryOperator &I)
Definition: Execution.cpp:1213
void visitUIToFPInst(UIToFPInst &I)
Definition: Execution.cpp:1727
void visitIndirectBrInst(IndirectBrInst &I)
Definition: Execution.cpp:968
void visitInsertValueInst(InsertValueInst &I)
Definition: Execution.cpp:1969
void runAtExitHandlers()
runAtExitHandlers - Run any functions registered by the program's calls to atexit(3),...
Definition: Interpreter.cpp:70
void visitBranchInst(BranchInst &I)
Definition: Execution.cpp:936
void visitVAArgInst(VAArgInst &I)
Definition: Execution.cpp:1765
void visitStoreInst(StoreInst &I)
Definition: Execution.cpp:1104
void visitExtractValueInst(ExtractValueInst &I)
Definition: Execution.cpp:1926
void visitSwitchInst(SwitchInst &I)
Definition: Execution.cpp:949
void visitExtractElementInst(ExtractElementInst &I)
Definition: Execution.cpp:1794
void visitVACopyInst(VACopyInst &I)
Definition: Execution.cpp:1130
void visitVAEndInst(VAEndInst &I)
Definition: Execution.cpp:1126
void visitTruncInst(TruncInst &I)
Definition: Execution.cpp:1702
void visitFPToUIInst(FPToUIInst &I)
Definition: Execution.cpp:1737
void visitLoadInst(LoadInst &I)
Definition: Execution.cpp:1093
void visitGetElementPtrInst(GetElementPtrInst &I)
Definition: Execution.cpp:1087
void callFunction(Function *F, ArrayRef< GenericValue > ArgVals)
Definition: Execution.cpp:2119
void visitInsertElementInst(InsertElementInst &I)
Definition: Execution.cpp:1827
void visitUnaryOperator(UnaryOperator &I)
Definition: Execution.cpp:62
void visitFPExtInst(FPExtInst &I)
Definition: Execution.cpp:1722
void visitVAStartInst(VAStartInst &I)
Definition: Execution.cpp:1118
void visitBitCastInst(BitCastInst &I)
Definition: Execution.cpp:1757
void visitSExtInst(SExtInst &I)
Definition: Execution.cpp:1707
void visitAShr(BinaryOperator &I)
Definition: Execution.cpp:1240
GenericValue callExternalFunction(Function *F, ArrayRef< GenericValue > ArgVals)
void visitFPTruncInst(FPTruncInst &I)
Definition: Execution.cpp:1717
void visitBinaryOperator(BinaryOperator &I)
Definition: Execution.cpp:736
void visitShl(BinaryOperator &I)
Definition: Execution.cpp:1186
void visitZExtInst(ZExtInst &I)
Definition: Execution.cpp:1712
void visitFPToSIInst(FPToSIInst &I)
Definition: Execution.cpp:1742
void visitIntrinsicInst(IntrinsicInst &I)
Definition: Execution.cpp:1135
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:47
void LowerIntrinsicCall(CallInst *CI)
Replace a call to the specified intrinsic function.
Invoke instruction.
An instruction for reading from memory.
Definition: Instructions.h:177
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
int getBasicBlockIndex(const BasicBlock *BB) const
Return the first index of the specified basic block in the value list for this PHI.
This class represents a cast from a pointer to an integer.
Return a value (possibly void), from a function.
This class represents a sign extension of integer types.
This class represents a cast from signed integer to floating point.
This class represents the LLVM 'select' instruction.
This instruction constructs a fixed permutation of two input vectors.
An instruction for storing to memory.
Definition: Instructions.h:301
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:625
uint64_t getElementOffset(unsigned Idx) const
Definition: DataLayout.h:655
Class to represent struct types.
Definition: DerivedTypes.h:213
Multiway switch.
This class represents a truncation of integer types.
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:258
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:249
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:154
@ ArrayTyID
Arrays.
Definition: Type.h:75
@ ScalableVectorTyID
Scalable SIMD vector type.
Definition: Type.h:77
@ FloatTyID
32-bit floating point type
Definition: Type.h:58
@ StructTyID
Structures.
Definition: Type.h:74
@ IntegerTyID
Arbitrary bit width integers.
Definition: Type.h:71
@ FixedVectorTyID
Fixed width SIMD vector type.
Definition: Type.h:76
@ DoubleTyID
64-bit floating point type
Definition: Type.h:59
@ PointerTyID
Pointers.
Definition: Type.h:73
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
static Type * getVoidTy(LLVMContext &C)
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:157
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
Definition: Type.h:185
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:222
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:137
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:140
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
Definition: Type.h:341
This class represents a cast unsigned integer to floating point.
This function has undefined behavior.
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
This represents the llvm.va_copy intrinsic.
This represents the llvm.va_end intrinsic.
This represents the llvm.va_start intrinsic.
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
Base class of all SIMD vector types.
Definition: DerivedTypes.h:389
Type * getElementType() const
Definition: DerivedTypes.h:422
This class represents zero extension of integer types.
This class provides various memory handling functions that manipulate MemoryBlock instances.
Definition: Memory.h:52
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
float RoundAPIntToFloat(const APInt &APIVal)
Converts the given APInt to a float value.
Definition: APInt.h:2217
double RoundAPIntToDouble(const APInt &APIVal)
Converts the given APInt to a double value.
Definition: APInt.h:2205
APInt RoundFloatToAPInt(float Float, unsigned width)
Converts a float value into a APInt.
Definition: APInt.h:2236
APInt RoundDoubleToAPInt(double Double, unsigned width)
Converts the given double value into a APInt.
Definition: APInt.cpp:802
double RoundSignedAPIntToDouble(const APInt &APIVal)
Converts the given APInt to a double value.
Definition: APInt.h:2212
float RoundSignedAPIntToFloat(const APInt &APIVal)
Converts the given APInt to a float value.
Definition: APInt.h:2224
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void * PointerTy
Definition: GenericValue.h:21
gep_type_iterator gep_type_end(const User *GEP)
GenericValue PTOGV(void *P)
Definition: GenericValue.h:49
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:145
LLVM_ATTRIBUTE_RETURNS_NONNULL void * safe_malloc(size_t Sz)
Definition: MemAlloc.h:25
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:147
void * GVTOP(const GenericValue &GV)
Definition: GenericValue.h:50
gep_type_iterator gep_type_begin(const User *GEP)
constexpr uint64_t NextPowerOf2(uint64_t A)
Returns the next power of two (in 64-bits) that is strictly greater than A.
Definition: MathExtras.h:437
BasicBlock::iterator CurInst
Definition: Interpreter.h:62
std::map< Value *, GenericValue > Values
Definition: Interpreter.h:65
std::vector< GenericValue > VarArgs
Definition: Interpreter.h:66
Function * CurFunction
Definition: Interpreter.h:60
BasicBlock * CurBB
Definition: Interpreter.h:61
PointerTy PointerVal
Definition: GenericValue.h:31
unsigned char Untyped[8]
Definition: GenericValue.h:33
struct IntPair UIntPairVal
Definition: GenericValue.h:32
std::vector< GenericValue > AggregateVal
Definition: GenericValue.h:37