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