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