Add early-exit AMDGPU loop fuzzing

Author: jlebar

amdgpu/README.md

@@ -23,10 +23,11 @@ structured two-way branches, wider multi-way switches, and deeper bounded
 nested acyclic subgraphs with `i32` phi joins. It also generates counted loops
 with small bounded constant or dynamically masked trip counts whose bodies can
 contain nested diamonds and switches. Some generated loops carry two independent
-`i32` accumulator phis and combine them after the loop, so corpus entries
-exercise both expression simplification and CFG and loop transforms. CFG arms
-include the same scalar integer, bit, boolean, narrowing, saturating,
-funnel-shift, and vector expression families as the linear mutator.
+`i32` accumulator phis, combine them after the loop, or take a guarded early
+exit from the loop body through an exit phi, so corpus entries exercise both
+expression simplification and CFG and loop transforms. CFG arms include the same
+scalar integer, bit, boolean, narrowing, saturating, funnel-shift, and vector
+expression families as the linear mutator.
 Corpus files can be inspected directly with `opt -S corpus-entry -o -`.
 
 ## Requirements

amdgpu/fuzzer/llvm_amdgpu_diff_fuzzer.cpp

@@ -2192,6 +2192,7 @@ void mutateIRAddCountedLoop(Module &M, std::minstd_rand &Gen) {
   Value *Current = Store->getValueOperand();
   Value *Other = chooseI32Value(Store, Gen);
   bool UseSecondAccumulator = (Gen() % 3) == 0;
+  bool UseEarlyExit = (Gen() % 4) == 0;
 
   BasicBlock *Preheader = Store->getParent();
   BasicBlock *Exit =
@@ -2242,16 +2243,44 @@ void mutateIRAddCountedLoop(Module &M, std::minstd_rand &Gen) {
                               "fuzz.loop.acc2.mix");
   }
 
-  IRBuilder<NoFolder> BodyTailB(FinalFrag.Tail);
+  Value *NextAcc = BodyFrag.Result;
+  Value *BreakValue = nullptr;
+  BasicBlock *Backedge = FinalFrag.Tail;
+  if (UseEarlyExit) {
+    IRBuilder<NoFolder> BreakB(FinalFrag.Tail);
+    BreakValue = NextAcc;
+    if (Acc2)
+      BreakValue =
+          BreakB.CreateAdd(NextAcc, NextAcc2, "fuzz.loop.break.value");
+    Value *BreakCond = BreakB.CreateICmp(randomICmpPredicate(Gen), BreakValue,
+                                         chooseCFGValue(Ctx, Other, Gen),
+                                         "fuzz.loop.break");
+    Backedge = BasicBlock::Create(Ctx, "fuzz.loop.continue", F, Exit);
+    BreakB.CreateCondBr(BreakCond, Exit, Backedge);
+  }
+
+  IRBuilder<NoFolder> BodyTailB(Backedge);
   Value *NextIndex =
       BodyTailB.CreateAdd(Index, ci32(Ctx, 1), "fuzz.loop.next");
   BodyTailB.CreateBr(Header);
-  Index->addIncoming(NextIndex, FinalFrag.Tail);
-  Acc->addIncoming(BodyFrag.Result, FinalFrag.Tail);
+  Index->addIncoming(NextIndex, Backedge);
+  Acc->addIncoming(NextAcc, Backedge);
   if (Acc2)
-    Acc2->addIncoming(NextAcc2, FinalFrag.Tail);
-
-  if (Acc2) {
+    Acc2->addIncoming(NextAcc2, Backedge);
+
+  if (UseEarlyExit) {
+    Value *NaturalExitValue = Acc;
+    if (Acc2) {
+      IRBuilder<NoFolder> HeaderExitB(Header->getTerminator());
+      NaturalExitValue =
+          HeaderExitB.CreateAdd(Acc, Acc2, "fuzz.loop.natural.value");
+    }
+    PHINode *ExitValue =
+        PHINode::Create(I32, 2, "fuzz.loop.exit.value", Exit->begin());
+    ExitValue->addIncoming(NaturalExitValue, Header);
+    ExitValue->addIncoming(BreakValue, FinalFrag.Tail);
+    Store->setOperand(0, ExitValue);
+  } else if (Acc2) {
     IRBuilder<NoFolder> ExitB(Store);
     Value *Mixed = ExitB.CreateAdd(Acc, Acc2, "fuzz.loop.acc.mix");
     Store->setOperand(0, Mixed);