[llvm-reduce] Move code to check chunk to function, to enable reuse (NFC).

[fhahn]

Summary

This patch moves the logic to clone and check a new chunk into a new
function, to allow re-use in a follow-up patch that implements parallel
reductions.

[dblaikie]

Might even be worth pulling out as a named function - given how long the outer function is.

llvm/tools/llvm-reduce/deltas/Delta.cpp

219–220

Usually I'd suggest any lambda that doesn't escape its scope should default capture by ref [&] rather than enumerating the captures (since it's like any other local scope - like a loop, etc - and should have access to all local variables without needing to declare them) - but given the intended direction involves parallelism, I'm with you here that it's good to enumerate the captures to avoid using some shared state accidentally that isn't thread safe.

[fhahn]

Move code to separate function instead of lambda, as suggested.

[fhahn]

remove stray whitespace change

llvm/tools/llvm-reduce/deltas/Delta.cpp

if (SplitOne) {
     for (auto C : Chunks) {
       errs() << '\t';
       C.print();
       errs() << '\n';
     }
   }
   return SplitOne;
 }
+// Check if \p ChunkToCheckForUninterestingness is interesting. Returns the
+// modified module if the chunk resulted in a reduction.
+template <typename T>
+static std::unique_ptr<ReducerWorkItem>
+CheckChunk(Chunk &ChunkToCheckForUninterestingness, TestRunner &Test,
+           function_ref<void(Oracle &, T &)> ExtractChunksFromModule,
+           std::set<Chunk> &UninterestingChunks,
+           std::vector<Chunk> &ChunksStillConsideredInteresting) {
+  // Take all of ChunksStillConsideredInteresting chunks, except those we've
+  // already deemed uninteresting (UninterestingChunks) but didn't remove
+  // from ChunksStillConsideredInteresting yet, and additionally ignore
+  // ChunkToCheckForUninterestingness chunk.
+  std::vector<Chunk> CurrentChunks;
+  CurrentChunks.reserve(ChunksStillConsideredInteresting.size() -
+                        UninterestingChunks.size() - 1);
+  copy_if(ChunksStillConsideredInteresting, std::back_inserter(CurrentChunks),
+          [&](const Chunk &C) {
+            return !UninterestingChunks.count(C) &&
+                   C != ChunkToCheckForUninterestingness;
+          });
+
+  // Clone module before hacking it up..
+  std::unique_ptr<ReducerWorkItem> Clone =
+      cloneReducerWorkItem(Test.getProgram());
+  // Generate Module with only Targets inside Current Chunks
+  Oracle O(CurrentChunks);
+  ExtractChunksFromModule(O, *Clone);
+
+  // Some reductions may result in invalid IR. Skip such reductions.
+  if (verifyReducerWorkItem(*Clone, &errs())) {
+    if (AbortOnInvalidReduction) {
+      errs() << "Invalid reduction\n";
+      exit(1);
+    }
+    errs() << " **** WARNING | reduction resulted in invalid module, "
+              "skipping\n";
+    return nullptr;
+  }
+
+  errs() << "Ignoring: ";
+  ChunkToCheckForUninterestingness.print();
+  for (const Chunk &C : UninterestingChunks)
+    C.print();
+
+  SmallString<128> CurrentFilepath;
+  if (!isReduced(*Clone, Test, CurrentFilepath)) {
+    // Program became non-reduced, so this chunk appears to be interesting.
+    errs() << "\n";
+    return nullptr;
+  }
+  return Clone;
+}
 
 /// Runs the Delta Debugging algorithm, splits the code into chunks and
 /// reduces the amount of chunks that are considered interesting by the
 /// given test.
 template <typename T>
 void runDeltaPassInt(
     TestRunner &Test,
     function_ref<void(Oracle &, T &)> ExtractChunksFromModule) {
void runDeltaPassInt(
 
   bool FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity;
   do {
     FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = false;
 
     std::set<Chunk> UninterestingChunks;
     for (Chunk &ChunkToCheckForUninterestingness :
          reverse(ChunksStillConsideredInteresting)) {
-      // Take all of ChunksStillConsideredInteresting chunks, except those we've
-      // already deemed uninteresting (UninterestingChunks) but didn't remove
-      // from ChunksStillConsideredInteresting yet, and additionally ignore
-      // ChunkToCheckForUninterestingness chunk.
-      std::vector<Chunk> CurrentChunks;
-      CurrentChunks.reserve(ChunksStillConsideredInteresting.size() -
-                            UninterestingChunks.size() - 1);
-      copy_if(ChunksStillConsideredInteresting,
-              std::back_inserter(CurrentChunks), [&](const Chunk &C) {
-                return !UninterestingChunks.count(C) &&
-                       C != ChunkToCheckForUninterestingness;
-              });
-
-      // Clone module before hacking it up..
-      std::unique_ptr<ReducerWorkItem> Clone =
-          cloneReducerWorkItem(Test.getProgram());
-      // Generate Module with only Targets inside Current Chunks
-      Oracle O(CurrentChunks);
-      ExtractChunksFromModule(O, *Clone);
-
-      // Some reductions may result in invalid IR. Skip such reductions.
-      if (verifyReducerWorkItem(*Clone, &errs())) {
-        if (AbortOnInvalidReduction) {
-          errs() << "Invalid reduction\n";
-          exit(1);
-        }
-        errs() << " **** WARNING | reduction resulted in invalid module, "
-                  "skipping\n";
+      std::unique_ptr<ReducerWorkItem> Result = CheckChunk(
+          ChunkToCheckForUninterestingness, Test, ExtractChunksFromModule,
+          UninterestingChunks, ChunksStillConsideredInteresting);
+      if (!Result)
         continue;
-      }
-
-      errs() << "Ignoring: ";
-      ChunkToCheckForUninterestingness.print();
-      for (const Chunk &C : UninterestingChunks)
-        C.print();
-
-      SmallString<128> CurrentFilepath;
-      if (!isReduced(*Clone, Test, CurrentFilepath)) {
-        // Program became non-reduced, so this chunk appears to be interesting.
-        errs() << "\n";
-        continue;
-      }
 
       FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = true;
       UninterestingChunks.insert(ChunkToCheckForUninterestingness);
-      ReducedProgram = std::move(Clone);
+      ReducedProgram = std::move(Result);
       errs() << " **** SUCCESS | lines: " << getLines(CurrentFilepath) << "\n";
       writeOutput(*ReducedProgram, "Saved new best reduction to ");
     }
     // Delete uninteresting chunks
     erase_if(ChunksStillConsideredInteresting,
              [&UninterestingChunks](const Chunk &C) {
                return UninterestingChunks.count(C);
              });