Added Reduce as Dependency to Tests & fixed warnings

[diegotf]

Summary

Fixes broken builds

llvm/trunk/test/CMakeLists.txt

set(LLVM_TEST_DEPENDS
           llvm-opt-fuzzer
           llvm-opt-report
           llvm-pdbutil
           llvm-profdata
           llvm-ranlib
           llvm-rc
           llvm-readobj
           llvm-readelf
+          llvm-reduce
           llvm-rtdyld
           llvm-size
           llvm-split
           llvm-strings
           llvm-strip
           llvm-symbolizer
           llvm-tblgen
           llvm-undname

llvm/trunk/tools/llvm-reduce/deltas/Delta.h

 #include "llvm/Support/ToolOutputFile.h"
 #include <fstream>
 #include <set>
 #include <vector>
 
 using namespace llvm;
 
 struct Chunk {
-  int begin;
-  int end;
+  unsigned begin;
+  unsigned end;
 
   /// Operator when populating CurrentChunks in Generic Delta Pass
   friend bool operator!=(const Chunk &C1, const Chunk &C2) {
     return C1.begin != C2.begin && C1.end != C2.end;
   }
 
   /// Operator used for sets
   friend bool operator<(const Chunk &C1, const Chunk &C2) {

 /// initialized GVs.
 /// * ExtractChunksFromModule: A function used to tailor the main program so it
 /// only contains Targets that are inside Chunks of the given iteration.
 /// Note: This function is implemented by each specialized Delta pass
 ///
 /// Other implementations of the Delta Debugging algorithm can also be found in
 /// the CReduce, Delta, and Lithium projects.
 void runDeltaPass(
-    TestRunner &Test, int Targets,
+    TestRunner &Test, unsigned Targets,
     std::function<std::unique_ptr<Module>(std::vector<Chunk>, Module *)>
         ExtractChunksFromModule);
 
 } // namespace llvm
 
 #endif

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

static bool increaseGranularity(std::vector<Chunk> &Chunks) {
   outs() << "Increasing granularity...";
   std::vector<Chunk> NewChunks;
   bool SplitOne = false;
 
   for (auto &C : Chunks) {
     if (C.end - C.begin == 0)
       NewChunks.push_back(C);
     else {
-      int Half = (C.begin + C.end) / 2;
+      unsigned Half = (C.begin + C.end) / 2;
       NewChunks.push_back({C.begin, Half});
       NewChunks.push_back({Half + 1, C.end});
       SplitOne = true;
     }
   }
   if (SplitOne) {
     Chunks = NewChunks;
     outs() << "Success! New Chunks:\n";
     printChunks(Chunks);
   }
   return SplitOne;
 }
 
 void llvm::runDeltaPass(
-    TestRunner &Test, int Targets,
+    TestRunner &Test, unsigned Targets,
     std::function<std::unique_ptr<Module>(std::vector<Chunk>, Module *)>
         ExtractChunksFromModule) {
   if (!Targets)
     return;
 
   std::vector<Chunk> Chunks = {{1, Targets}};
   std::set<Chunk> UninterestingChunks;
   std::unique_ptr<Module> ReducedProgram;
void llvm::runDeltaPass(
   } while (!UninterestingChunks.empty() || increaseGranularity(Chunks));
 
   // If we reduced the testcase replace it
   if (ReducedProgram)
     Test.setProgram(std::move(ReducedProgram));
   outs() << "Couldn't increase anymore.\n";
   outs() << "----------------------------\n";
 }
 No newline at end of file

llvm/trunk/tools/llvm-reduce/deltas/RemoveFunctions.cpp

 /// that aren't inside any of the desired Chunks.
 /// @returns the Module stripped of out-of-chunk functions
 static std::unique_ptr<Module>
 extractFunctionsFromModule(std::vector<Chunk> ChunksToKeep, Module *Program) {
   std::unique_ptr<Module> Clone = CloneModule(*Program);
 
   // Get functions inside desired chunks
   std::set<Function *> FuncsToKeep;
-  int I = 0, FunctionCount = 1;
+  unsigned I = 0, FunctionCount = 1;
   for (auto &F : *Clone) {
     if (!F.isDeclaration() && I < ChunksToKeep.size()) {
       if (FunctionCount >= ChunksToKeep[I].begin &&
           FunctionCount <= ChunksToKeep[I].end)
         FuncsToKeep.insert(&F);
       if (FunctionCount == ChunksToKeep[I].end)
         ++I;
       ++FunctionCount;
static int countFunctions(Module *Program) {
   outs() << "----------------------------\n";
   return FunctionCount;
 }
 
 void llvm::removeFunctionsDeltaPass(TestRunner &Test) {
   int FunctionCount = countFunctions(Test.getProgram());
   runDeltaPass(Test, FunctionCount, extractFunctionsFromModule);
 }
 No newline at end of file

llvm/trunk/tools/llvm-reduce/deltas/RemoveGlobalVars.cpp

 /// Removes all the Initialized GVs that aren't inside the desired Chunks.
 /// @returns the Module stripped of out-of-chunk GVs
 static std::unique_ptr<Module>
 extractGVsFromModule(std::vector<Chunk> ChunksToKeep, Module *Program) {
   std::unique_ptr<Module> Clone = CloneModule(*Program);
 
   // Get GVs inside desired chunks
   std::set<GlobalVariable *> GVsToKeep;
-  int I = 0, GVCount = 1;
+  unsigned I = 0, GVCount = 1;
   for (auto &GV : Clone->globals()) {
     if (GV.hasInitializer() && I < ChunksToKeep.size()) {
       if (GVCount >= ChunksToKeep[I].begin && GVCount <= ChunksToKeep[I].end)
         GVsToKeep.insert(&GV);
       if (GVCount == ChunksToKeep[I].end)
         ++I;
       ++GVCount;
     }