• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- llvm-stress.cpp - Generate random LL files to stress-test LLVM ----===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This program is a utility that generates random .ll files to stress-test
11 // different components in LLVM.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/Analysis/CallGraphSCCPass.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/IRPrintingPasses.h"
18 #include "llvm/IR/Instruction.h"
19 #include "llvm/IR/LLVMContext.h"
20 #include "llvm/IR/LegacyPassManager.h"
21 #include "llvm/IR/LegacyPassNameParser.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/IR/Verifier.h"
24 #include "llvm/Support/Debug.h"
25 #include "llvm/Support/FileSystem.h"
26 #include "llvm/Support/ManagedStatic.h"
27 #include "llvm/Support/PluginLoader.h"
28 #include "llvm/Support/PrettyStackTrace.h"
29 #include "llvm/Support/ToolOutputFile.h"
30 #include <algorithm>
31 #include <vector>
32 
33 namespace llvm {
34 
35 static cl::opt<unsigned> SeedCL("seed",
36   cl::desc("Seed used for randomness"), cl::init(0));
37 static cl::opt<unsigned> SizeCL("size",
38   cl::desc("The estimated size of the generated function (# of instrs)"),
39   cl::init(100));
40 static cl::opt<std::string>
41 OutputFilename("o", cl::desc("Override output filename"),
42                cl::value_desc("filename"));
43 
44 static LLVMContext Context;
45 
46 namespace cl {
47 template <> class parser<Type*> final : public basic_parser<Type*> {
48 public:
parser(Option & O)49   parser(Option &O) : basic_parser(O) {}
50 
51   // Parse options as IR types. Return true on error.
parse(Option & O,StringRef,StringRef Arg,Type * & Value)52   bool parse(Option &O, StringRef, StringRef Arg, Type *&Value) {
53     if      (Arg == "half")      Value = Type::getHalfTy(Context);
54     else if (Arg == "fp128")     Value = Type::getFP128Ty(Context);
55     else if (Arg == "x86_fp80")  Value = Type::getX86_FP80Ty(Context);
56     else if (Arg == "ppc_fp128") Value = Type::getPPC_FP128Ty(Context);
57     else if (Arg == "x86_mmx")   Value = Type::getX86_MMXTy(Context);
58     else if (Arg.startswith("i")) {
59       unsigned N = 0;
60       Arg.drop_front().getAsInteger(10, N);
61       if (N > 0)
62         Value = Type::getIntNTy(Context, N);
63     }
64 
65     if (!Value)
66       return O.error("Invalid IR scalar type: '" + Arg + "'!");
67     return false;
68   }
69 
getValueName() const70   const char *getValueName() const override { return "IR scalar type"; }
71 };
72 }
73 
74 
75 static cl::list<Type*> AdditionalScalarTypes("types", cl::CommaSeparated,
76   cl::desc("Additional IR scalar types "
77            "(always includes i1, i8, i16, i32, i64, float and double)"));
78 
79 namespace {
80 /// A utility class to provide a pseudo-random number generator which is
81 /// the same across all platforms. This is somewhat close to the libc
82 /// implementation. Note: This is not a cryptographically secure pseudorandom
83 /// number generator.
84 class Random {
85 public:
86   /// C'tor
Random(unsigned _seed)87   Random(unsigned _seed):Seed(_seed) {}
88 
89   /// Return a random integer, up to a
90   /// maximum of 2**19 - 1.
Rand()91   uint32_t Rand() {
92     uint32_t Val = Seed + 0x000b07a1;
93     Seed = (Val * 0x3c7c0ac1);
94     // Only lowest 19 bits are random-ish.
95     return Seed & 0x7ffff;
96   }
97 
98   /// Return a random 32 bit integer.
Rand32()99   uint32_t Rand32() {
100     uint32_t Val = Rand();
101     Val &= 0xffff;
102     return Val | (Rand() << 16);
103   }
104 
105   /// Return a random 64 bit integer.
Rand64()106   uint64_t Rand64() {
107     uint64_t Val = Rand32();
108     return Val | (uint64_t(Rand32()) << 32);
109   }
110 
111   /// Rand operator for STL algorithms.
operator ()(ptrdiff_t y)112   ptrdiff_t operator()(ptrdiff_t y) {
113     return  Rand64() % y;
114   }
115 
116 private:
117   unsigned Seed;
118 };
119 
120 /// Generate an empty function with a default argument list.
GenEmptyFunction(Module * M)121 Function *GenEmptyFunction(Module *M) {
122   // Define a few arguments
123   LLVMContext &Context = M->getContext();
124   Type* ArgsTy[] = {
125     Type::getInt8PtrTy(Context),
126     Type::getInt32PtrTy(Context),
127     Type::getInt64PtrTy(Context),
128     Type::getInt32Ty(Context),
129     Type::getInt64Ty(Context),
130     Type::getInt8Ty(Context)
131   };
132 
133   auto *FuncTy = FunctionType::get(Type::getVoidTy(Context), ArgsTy, false);
134   // Pick a unique name to describe the input parameters
135   Twine Name = "autogen_SD" + Twine{SeedCL};
136   auto *Func = Function::Create(FuncTy, GlobalValue::ExternalLinkage, Name, M);
137   Func->setCallingConv(CallingConv::C);
138   return Func;
139 }
140 
141 /// A base class, implementing utilities needed for
142 /// modifying and adding new random instructions.
143 struct Modifier {
144   /// Used to store the randomly generated values.
145   typedef std::vector<Value*> PieceTable;
146 
147 public:
148   /// C'tor
Modifierllvm::__anon8e3836720111::Modifier149   Modifier(BasicBlock *Block, PieceTable *PT, Random *R):
150     BB(Block),PT(PT),Ran(R),Context(BB->getContext()) {}
151 
152   /// virtual D'tor to silence warnings.
~Modifierllvm::__anon8e3836720111::Modifier153   virtual ~Modifier() {}
154 
155   /// Add a new instruction.
156   virtual void Act() = 0;
157   /// Add N new instructions,
ActNllvm::__anon8e3836720111::Modifier158   virtual void ActN(unsigned n) {
159     for (unsigned i=0; i<n; ++i)
160       Act();
161   }
162 
163 protected:
164   /// Return a random value from the list of known values.
getRandomValllvm::__anon8e3836720111::Modifier165   Value *getRandomVal() {
166     assert(PT->size());
167     return PT->at(Ran->Rand() % PT->size());
168   }
169 
getRandomConstantllvm::__anon8e3836720111::Modifier170   Constant *getRandomConstant(Type *Tp) {
171     if (Tp->isIntegerTy()) {
172       if (Ran->Rand() & 1)
173         return ConstantInt::getAllOnesValue(Tp);
174       return ConstantInt::getNullValue(Tp);
175     } else if (Tp->isFloatingPointTy()) {
176       if (Ran->Rand() & 1)
177         return ConstantFP::getAllOnesValue(Tp);
178       return ConstantFP::getNullValue(Tp);
179     }
180     return UndefValue::get(Tp);
181   }
182 
183   /// Return a random value with a known type.
getRandomValuellvm::__anon8e3836720111::Modifier184   Value *getRandomValue(Type *Tp) {
185     unsigned index = Ran->Rand();
186     for (unsigned i=0; i<PT->size(); ++i) {
187       Value *V = PT->at((index + i) % PT->size());
188       if (V->getType() == Tp)
189         return V;
190     }
191 
192     // If the requested type was not found, generate a constant value.
193     if (Tp->isIntegerTy()) {
194       if (Ran->Rand() & 1)
195         return ConstantInt::getAllOnesValue(Tp);
196       return ConstantInt::getNullValue(Tp);
197     } else if (Tp->isFloatingPointTy()) {
198       if (Ran->Rand() & 1)
199         return ConstantFP::getAllOnesValue(Tp);
200       return ConstantFP::getNullValue(Tp);
201     } else if (Tp->isVectorTy()) {
202       VectorType *VTp = cast<VectorType>(Tp);
203 
204       std::vector<Constant*> TempValues;
205       TempValues.reserve(VTp->getNumElements());
206       for (unsigned i = 0; i < VTp->getNumElements(); ++i)
207         TempValues.push_back(getRandomConstant(VTp->getScalarType()));
208 
209       ArrayRef<Constant*> VectorValue(TempValues);
210       return ConstantVector::get(VectorValue);
211     }
212 
213     return UndefValue::get(Tp);
214   }
215 
216   /// Return a random value of any pointer type.
getRandomPointerValuellvm::__anon8e3836720111::Modifier217   Value *getRandomPointerValue() {
218     unsigned index = Ran->Rand();
219     for (unsigned i=0; i<PT->size(); ++i) {
220       Value *V = PT->at((index + i) % PT->size());
221       if (V->getType()->isPointerTy())
222         return V;
223     }
224     return UndefValue::get(pickPointerType());
225   }
226 
227   /// Return a random value of any vector type.
getRandomVectorValuellvm::__anon8e3836720111::Modifier228   Value *getRandomVectorValue() {
229     unsigned index = Ran->Rand();
230     for (unsigned i=0; i<PT->size(); ++i) {
231       Value *V = PT->at((index + i) % PT->size());
232       if (V->getType()->isVectorTy())
233         return V;
234     }
235     return UndefValue::get(pickVectorType());
236   }
237 
238   /// Pick a random type.
pickTypellvm::__anon8e3836720111::Modifier239   Type *pickType() {
240     return (Ran->Rand() & 1 ? pickVectorType() : pickScalarType());
241   }
242 
243   /// Pick a random pointer type.
pickPointerTypellvm::__anon8e3836720111::Modifier244   Type *pickPointerType() {
245     Type *Ty = pickType();
246     return PointerType::get(Ty, 0);
247   }
248 
249   /// Pick a random vector type.
pickVectorTypellvm::__anon8e3836720111::Modifier250   Type *pickVectorType(unsigned len = (unsigned)-1) {
251     // Pick a random vector width in the range 2**0 to 2**4.
252     // by adding two randoms we are generating a normal-like distribution
253     // around 2**3.
254     unsigned width = 1<<((Ran->Rand() % 3) + (Ran->Rand() % 3));
255     Type *Ty;
256 
257     // Vectors of x86mmx are illegal; keep trying till we get something else.
258     do {
259       Ty = pickScalarType();
260     } while (Ty->isX86_MMXTy());
261 
262     if (len != (unsigned)-1)
263       width = len;
264     return VectorType::get(Ty, width);
265   }
266 
267   /// Pick a random scalar type.
pickScalarTypellvm::__anon8e3836720111::Modifier268   Type *pickScalarType() {
269     static std::vector<Type*> ScalarTypes;
270     if (ScalarTypes.empty()) {
271       ScalarTypes.assign({
272         Type::getInt1Ty(Context),
273         Type::getInt8Ty(Context),
274         Type::getInt16Ty(Context),
275         Type::getInt32Ty(Context),
276         Type::getInt64Ty(Context),
277         Type::getFloatTy(Context),
278         Type::getDoubleTy(Context)
279       });
280       ScalarTypes.insert(ScalarTypes.end(),
281         AdditionalScalarTypes.begin(), AdditionalScalarTypes.end());
282     }
283 
284     return ScalarTypes[Ran->Rand() % ScalarTypes.size()];
285   }
286 
287   /// Basic block to populate
288   BasicBlock *BB;
289   /// Value table
290   PieceTable *PT;
291   /// Random number generator
292   Random *Ran;
293   /// Context
294   LLVMContext &Context;
295 };
296 
297 struct LoadModifier: public Modifier {
LoadModifierllvm::__anon8e3836720111::LoadModifier298   LoadModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
Actllvm::__anon8e3836720111::LoadModifier299   void Act() override {
300     // Try to use predefined pointers. If non-exist, use undef pointer value;
301     Value *Ptr = getRandomPointerValue();
302     Value *V = new LoadInst(Ptr, "L", BB->getTerminator());
303     PT->push_back(V);
304   }
305 };
306 
307 struct StoreModifier: public Modifier {
StoreModifierllvm::__anon8e3836720111::StoreModifier308   StoreModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
Actllvm::__anon8e3836720111::StoreModifier309   void Act() override {
310     // Try to use predefined pointers. If non-exist, use undef pointer value;
311     Value *Ptr = getRandomPointerValue();
312     Type  *Tp = Ptr->getType();
313     Value *Val = getRandomValue(Tp->getContainedType(0));
314     Type  *ValTy = Val->getType();
315 
316     // Do not store vectors of i1s because they are unsupported
317     // by the codegen.
318     if (ValTy->isVectorTy() && ValTy->getScalarSizeInBits() == 1)
319       return;
320 
321     new StoreInst(Val, Ptr, BB->getTerminator());
322   }
323 };
324 
325 struct BinModifier: public Modifier {
BinModifierllvm::__anon8e3836720111::BinModifier326   BinModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
327 
Actllvm::__anon8e3836720111::BinModifier328   void Act() override {
329     Value *Val0 = getRandomVal();
330     Value *Val1 = getRandomValue(Val0->getType());
331 
332     // Don't handle pointer types.
333     if (Val0->getType()->isPointerTy() ||
334         Val1->getType()->isPointerTy())
335       return;
336 
337     // Don't handle i1 types.
338     if (Val0->getType()->getScalarSizeInBits() == 1)
339       return;
340 
341 
342     bool isFloat = Val0->getType()->getScalarType()->isFloatingPointTy();
343     Instruction* Term = BB->getTerminator();
344     unsigned R = Ran->Rand() % (isFloat ? 7 : 13);
345     Instruction::BinaryOps Op;
346 
347     switch (R) {
348     default: llvm_unreachable("Invalid BinOp");
349     case 0:{Op = (isFloat?Instruction::FAdd : Instruction::Add); break; }
350     case 1:{Op = (isFloat?Instruction::FSub : Instruction::Sub); break; }
351     case 2:{Op = (isFloat?Instruction::FMul : Instruction::Mul); break; }
352     case 3:{Op = (isFloat?Instruction::FDiv : Instruction::SDiv); break; }
353     case 4:{Op = (isFloat?Instruction::FDiv : Instruction::UDiv); break; }
354     case 5:{Op = (isFloat?Instruction::FRem : Instruction::SRem); break; }
355     case 6:{Op = (isFloat?Instruction::FRem : Instruction::URem); break; }
356     case 7: {Op = Instruction::Shl;  break; }
357     case 8: {Op = Instruction::LShr; break; }
358     case 9: {Op = Instruction::AShr; break; }
359     case 10:{Op = Instruction::And;  break; }
360     case 11:{Op = Instruction::Or;   break; }
361     case 12:{Op = Instruction::Xor;  break; }
362     }
363 
364     PT->push_back(BinaryOperator::Create(Op, Val0, Val1, "B", Term));
365   }
366 };
367 
368 /// Generate constant values.
369 struct ConstModifier: public Modifier {
ConstModifierllvm::__anon8e3836720111::ConstModifier370   ConstModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
Actllvm::__anon8e3836720111::ConstModifier371   void Act() override {
372     Type *Ty = pickType();
373 
374     if (Ty->isVectorTy()) {
375       switch (Ran->Rand() % 2) {
376       case 0: if (Ty->getScalarType()->isIntegerTy())
377                 return PT->push_back(ConstantVector::getAllOnesValue(Ty));
378       case 1: if (Ty->getScalarType()->isIntegerTy())
379                 return PT->push_back(ConstantVector::getNullValue(Ty));
380       }
381     }
382 
383     if (Ty->isFloatingPointTy()) {
384       // Generate 128 random bits, the size of the (currently)
385       // largest floating-point types.
386       uint64_t RandomBits[2];
387       for (unsigned i = 0; i < 2; ++i)
388         RandomBits[i] = Ran->Rand64();
389 
390       APInt RandomInt(Ty->getPrimitiveSizeInBits(), makeArrayRef(RandomBits));
391       APFloat RandomFloat(Ty->getFltSemantics(), RandomInt);
392 
393       if (Ran->Rand() & 1)
394         return PT->push_back(ConstantFP::getNullValue(Ty));
395       return PT->push_back(ConstantFP::get(Ty->getContext(), RandomFloat));
396     }
397 
398     if (Ty->isIntegerTy()) {
399       switch (Ran->Rand() % 7) {
400       case 0: if (Ty->isIntegerTy())
401                 return PT->push_back(ConstantInt::get(Ty,
402                   APInt::getAllOnesValue(Ty->getPrimitiveSizeInBits())));
403       case 1: if (Ty->isIntegerTy())
404                 return PT->push_back(ConstantInt::get(Ty,
405                   APInt::getNullValue(Ty->getPrimitiveSizeInBits())));
406       case 2: case 3: case 4: case 5:
407       case 6: if (Ty->isIntegerTy())
408                 PT->push_back(ConstantInt::get(Ty, Ran->Rand()));
409       }
410     }
411 
412   }
413 };
414 
415 struct AllocaModifier: public Modifier {
AllocaModifierllvm::__anon8e3836720111::AllocaModifier416   AllocaModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R){}
417 
Actllvm::__anon8e3836720111::AllocaModifier418   void Act() override {
419     Type *Tp = pickType();
420     PT->push_back(new AllocaInst(Tp, "A", BB->getFirstNonPHI()));
421   }
422 };
423 
424 struct ExtractElementModifier: public Modifier {
ExtractElementModifierllvm::__anon8e3836720111::ExtractElementModifier425   ExtractElementModifier(BasicBlock *BB, PieceTable *PT, Random *R):
426     Modifier(BB, PT, R) {}
427 
Actllvm::__anon8e3836720111::ExtractElementModifier428   void Act() override {
429     Value *Val0 = getRandomVectorValue();
430     Value *V = ExtractElementInst::Create(Val0,
431              ConstantInt::get(Type::getInt32Ty(BB->getContext()),
432              Ran->Rand() % cast<VectorType>(Val0->getType())->getNumElements()),
433              "E", BB->getTerminator());
434     return PT->push_back(V);
435   }
436 };
437 
438 struct ShuffModifier: public Modifier {
ShuffModifierllvm::__anon8e3836720111::ShuffModifier439   ShuffModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
Actllvm::__anon8e3836720111::ShuffModifier440   void Act() override {
441 
442     Value *Val0 = getRandomVectorValue();
443     Value *Val1 = getRandomValue(Val0->getType());
444 
445     unsigned Width = cast<VectorType>(Val0->getType())->getNumElements();
446     std::vector<Constant*> Idxs;
447 
448     Type *I32 = Type::getInt32Ty(BB->getContext());
449     for (unsigned i=0; i<Width; ++i) {
450       Constant *CI = ConstantInt::get(I32, Ran->Rand() % (Width*2));
451       // Pick some undef values.
452       if (!(Ran->Rand() % 5))
453         CI = UndefValue::get(I32);
454       Idxs.push_back(CI);
455     }
456 
457     Constant *Mask = ConstantVector::get(Idxs);
458 
459     Value *V = new ShuffleVectorInst(Val0, Val1, Mask, "Shuff",
460                                      BB->getTerminator());
461     PT->push_back(V);
462   }
463 };
464 
465 struct InsertElementModifier: public Modifier {
InsertElementModifierllvm::__anon8e3836720111::InsertElementModifier466   InsertElementModifier(BasicBlock *BB, PieceTable *PT, Random *R):
467     Modifier(BB, PT, R) {}
468 
Actllvm::__anon8e3836720111::InsertElementModifier469   void Act() override {
470     Value *Val0 = getRandomVectorValue();
471     Value *Val1 = getRandomValue(Val0->getType()->getScalarType());
472 
473     Value *V = InsertElementInst::Create(Val0, Val1,
474               ConstantInt::get(Type::getInt32Ty(BB->getContext()),
475               Ran->Rand() % cast<VectorType>(Val0->getType())->getNumElements()),
476               "I",  BB->getTerminator());
477     return PT->push_back(V);
478   }
479 
480 };
481 
482 struct CastModifier: public Modifier {
CastModifierllvm::__anon8e3836720111::CastModifier483   CastModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
Actllvm::__anon8e3836720111::CastModifier484   void Act() override {
485 
486     Value *V = getRandomVal();
487     Type *VTy = V->getType();
488     Type *DestTy = pickScalarType();
489 
490     // Handle vector casts vectors.
491     if (VTy->isVectorTy()) {
492       VectorType *VecTy = cast<VectorType>(VTy);
493       DestTy = pickVectorType(VecTy->getNumElements());
494     }
495 
496     // no need to cast.
497     if (VTy == DestTy) return;
498 
499     // Pointers:
500     if (VTy->isPointerTy()) {
501       if (!DestTy->isPointerTy())
502         DestTy = PointerType::get(DestTy, 0);
503       return PT->push_back(
504         new BitCastInst(V, DestTy, "PC", BB->getTerminator()));
505     }
506 
507     unsigned VSize = VTy->getScalarType()->getPrimitiveSizeInBits();
508     unsigned DestSize = DestTy->getScalarType()->getPrimitiveSizeInBits();
509 
510     // Generate lots of bitcasts.
511     if ((Ran->Rand() & 1) && VSize == DestSize) {
512       return PT->push_back(
513         new BitCastInst(V, DestTy, "BC", BB->getTerminator()));
514     }
515 
516     // Both types are integers:
517     if (VTy->getScalarType()->isIntegerTy() &&
518         DestTy->getScalarType()->isIntegerTy()) {
519       if (VSize > DestSize) {
520         return PT->push_back(
521           new TruncInst(V, DestTy, "Tr", BB->getTerminator()));
522       } else {
523         assert(VSize < DestSize && "Different int types with the same size?");
524         if (Ran->Rand() & 1)
525           return PT->push_back(
526             new ZExtInst(V, DestTy, "ZE", BB->getTerminator()));
527         return PT->push_back(new SExtInst(V, DestTy, "Se", BB->getTerminator()));
528       }
529     }
530 
531     // Fp to int.
532     if (VTy->getScalarType()->isFloatingPointTy() &&
533         DestTy->getScalarType()->isIntegerTy()) {
534       if (Ran->Rand() & 1)
535         return PT->push_back(
536           new FPToSIInst(V, DestTy, "FC", BB->getTerminator()));
537       return PT->push_back(new FPToUIInst(V, DestTy, "FC", BB->getTerminator()));
538     }
539 
540     // Int to fp.
541     if (VTy->getScalarType()->isIntegerTy() &&
542         DestTy->getScalarType()->isFloatingPointTy()) {
543       if (Ran->Rand() & 1)
544         return PT->push_back(
545           new SIToFPInst(V, DestTy, "FC", BB->getTerminator()));
546       return PT->push_back(new UIToFPInst(V, DestTy, "FC", BB->getTerminator()));
547 
548     }
549 
550     // Both floats.
551     if (VTy->getScalarType()->isFloatingPointTy() &&
552         DestTy->getScalarType()->isFloatingPointTy()) {
553       if (VSize > DestSize) {
554         return PT->push_back(
555           new FPTruncInst(V, DestTy, "Tr", BB->getTerminator()));
556       } else if (VSize < DestSize) {
557         return PT->push_back(
558           new FPExtInst(V, DestTy, "ZE", BB->getTerminator()));
559       }
560       // If VSize == DestSize, then the two types must be fp128 and ppc_fp128,
561       // for which there is no defined conversion. So do nothing.
562     }
563   }
564 
565 };
566 
567 struct SelectModifier: public Modifier {
SelectModifierllvm::__anon8e3836720111::SelectModifier568   SelectModifier(BasicBlock *BB, PieceTable *PT, Random *R):
569     Modifier(BB, PT, R) {}
570 
Actllvm::__anon8e3836720111::SelectModifier571   void Act() override {
572     // Try a bunch of different select configuration until a valid one is found.
573       Value *Val0 = getRandomVal();
574       Value *Val1 = getRandomValue(Val0->getType());
575 
576       Type *CondTy = Type::getInt1Ty(Context);
577 
578       // If the value type is a vector, and we allow vector select, then in 50%
579       // of the cases generate a vector select.
580       if (Val0->getType()->isVectorTy() && (Ran->Rand() % 1)) {
581         unsigned NumElem = cast<VectorType>(Val0->getType())->getNumElements();
582         CondTy = VectorType::get(CondTy, NumElem);
583       }
584 
585       Value *Cond = getRandomValue(CondTy);
586       Value *V = SelectInst::Create(Cond, Val0, Val1, "Sl", BB->getTerminator());
587       return PT->push_back(V);
588   }
589 };
590 
591 
592 struct CmpModifier: public Modifier {
CmpModifierllvm::__anon8e3836720111::CmpModifier593   CmpModifier(BasicBlock *BB, PieceTable *PT, Random *R):Modifier(BB, PT, R) {}
Actllvm::__anon8e3836720111::CmpModifier594   void Act() override {
595 
596     Value *Val0 = getRandomVal();
597     Value *Val1 = getRandomValue(Val0->getType());
598 
599     if (Val0->getType()->isPointerTy()) return;
600     bool fp = Val0->getType()->getScalarType()->isFloatingPointTy();
601 
602     int op;
603     if (fp) {
604       op = Ran->Rand() %
605       (CmpInst::LAST_FCMP_PREDICATE - CmpInst::FIRST_FCMP_PREDICATE) +
606        CmpInst::FIRST_FCMP_PREDICATE;
607     } else {
608       op = Ran->Rand() %
609       (CmpInst::LAST_ICMP_PREDICATE - CmpInst::FIRST_ICMP_PREDICATE) +
610        CmpInst::FIRST_ICMP_PREDICATE;
611     }
612 
613     Value *V = CmpInst::Create(fp ? Instruction::FCmp : Instruction::ICmp,
614                                (CmpInst::Predicate)op, Val0, Val1, "Cmp",
615                                BB->getTerminator());
616     return PT->push_back(V);
617   }
618 };
619 
620 } // end anonymous namespace
621 
FillFunction(Function * F,Random & R)622 static void FillFunction(Function *F, Random &R) {
623   // Create a legal entry block.
624   BasicBlock *BB = BasicBlock::Create(F->getContext(), "BB", F);
625   ReturnInst::Create(F->getContext(), BB);
626 
627   // Create the value table.
628   Modifier::PieceTable PT;
629 
630   // Consider arguments as legal values.
631   for (auto &arg : F->args())
632     PT.push_back(&arg);
633 
634   // List of modifiers which add new random instructions.
635   std::vector<std::unique_ptr<Modifier>> Modifiers;
636   Modifiers.emplace_back(new LoadModifier(BB, &PT, &R));
637   Modifiers.emplace_back(new StoreModifier(BB, &PT, &R));
638   auto SM = Modifiers.back().get();
639   Modifiers.emplace_back(new ExtractElementModifier(BB, &PT, &R));
640   Modifiers.emplace_back(new ShuffModifier(BB, &PT, &R));
641   Modifiers.emplace_back(new InsertElementModifier(BB, &PT, &R));
642   Modifiers.emplace_back(new BinModifier(BB, &PT, &R));
643   Modifiers.emplace_back(new CastModifier(BB, &PT, &R));
644   Modifiers.emplace_back(new SelectModifier(BB, &PT, &R));
645   Modifiers.emplace_back(new CmpModifier(BB, &PT, &R));
646 
647   // Generate the random instructions
648   AllocaModifier{BB, &PT, &R}.ActN(5); // Throw in a few allocas
649   ConstModifier{BB, &PT, &R}.ActN(40); // Throw in a few constants
650 
651   for (unsigned i = 0; i < SizeCL / Modifiers.size(); ++i)
652     for (auto &Mod : Modifiers)
653       Mod->Act();
654 
655   SM->ActN(5); // Throw in a few stores.
656 }
657 
IntroduceControlFlow(Function * F,Random & R)658 static void IntroduceControlFlow(Function *F, Random &R) {
659   std::vector<Instruction*> BoolInst;
660   for (auto &Instr : F->front()) {
661     if (Instr.getType() == IntegerType::getInt1Ty(F->getContext()))
662       BoolInst.push_back(&Instr);
663   }
664 
665   std::random_shuffle(BoolInst.begin(), BoolInst.end(), R);
666 
667   for (auto *Instr : BoolInst) {
668     BasicBlock *Curr = Instr->getParent();
669     BasicBlock::iterator Loc = Instr->getIterator();
670     BasicBlock *Next = Curr->splitBasicBlock(Loc, "CF");
671     Instr->moveBefore(Curr->getTerminator());
672     if (Curr != &F->getEntryBlock()) {
673       BranchInst::Create(Curr, Next, Instr, Curr->getTerminator());
674       Curr->getTerminator()->eraseFromParent();
675     }
676   }
677 }
678 
679 }
680 
main(int argc,char ** argv)681 int main(int argc, char **argv) {
682   using namespace llvm;
683 
684   // Init LLVM, call llvm_shutdown() on exit, parse args, etc.
685   PrettyStackTraceProgram X(argc, argv);
686   cl::ParseCommandLineOptions(argc, argv, "llvm codegen stress-tester\n");
687   llvm_shutdown_obj Y;
688 
689   auto M = make_unique<Module>("/tmp/autogen.bc", Context);
690   Function *F = GenEmptyFunction(M.get());
691 
692   // Pick an initial seed value
693   Random R(SeedCL);
694   // Generate lots of random instructions inside a single basic block.
695   FillFunction(F, R);
696   // Break the basic block into many loops.
697   IntroduceControlFlow(F, R);
698 
699   // Figure out what stream we are supposed to write to...
700   std::unique_ptr<tool_output_file> Out;
701   // Default to standard output.
702   if (OutputFilename.empty())
703     OutputFilename = "-";
704 
705   std::error_code EC;
706   Out.reset(new tool_output_file(OutputFilename, EC, sys::fs::F_None));
707   if (EC) {
708     errs() << EC.message() << '\n';
709     return 1;
710   }
711 
712   legacy::PassManager Passes;
713   Passes.add(createVerifierPass());
714   Passes.add(createPrintModulePass(Out->os()));
715   Passes.run(*M.get());
716   Out->keep();
717 
718   return 0;
719 }
720