[llvm-reduce] Unify pass logging

We randomly use outs() or errs(), which makes test logs confusing.
We also randomly add/don't add a line afterward.

Reviewed By: arsenm

Differential Revision: https://reviews.llvm.org/D136130

Author: aeubanks

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

@@ -235,10 +235,11 @@ SmallString<0> ProcessChunkFromSerializedBitcode(
 /// reduces the amount of chunks that are considered interesting by the
 /// given test. The number of chunks is determined by a preliminary run of the
 /// reduction pass where no change must be made to the module.
-void llvm::runDeltaPass(TestRunner &Test,
-                        ReductionFunc ExtractChunksFromModule) {
+void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
+                        StringRef Message) {
   assert(!verifyReducerWorkItem(Test.getProgram(), &errs()) &&
          "input module is broken before making changes");
+  errs() << "*** " << Message << "...\n";
 
   SmallString<128> CurrentFilepath;
   if (!isReduced(Test.getProgram(), Test, CurrentFilepath)) {
@@ -275,6 +276,7 @@ void llvm::runDeltaPass(TestRunner &Test,
   if (!Targets) {
     if (Verbose)
       errs() << "\nNothing to reduce\n";
+    errs() << "----------------------------\n";
     return;
   }
 
@@ -412,4 +414,5 @@ void llvm::runDeltaPass(TestRunner &Test,
     Test.setProgram(std::move(ReducedProgram));
   if (Verbose)
     errs() << "Couldn't increase anymore.\n";
+  errs() << "----------------------------\n";
 }

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

@@ -105,7 +105,8 @@ using ReductionFunc = function_ref<void(Oracle &, ReducerWorkItem &)>;
 ///
 /// Other implementations of the Delta Debugging algorithm can also be found in
 /// the CReduce, Delta, and Lithium projects.
-void runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule);
+void runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
+                  StringRef Message);
 } // namespace llvm
 
 #endif

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

@@ -30,7 +30,5 @@ static void extractAliasesFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceAliasesDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing Aliases ...\n";
-  runDeltaPass(Test, extractAliasesFromModule);
-  errs() << "----------------------------\n";
+  runDeltaPass(Test, extractAliasesFromModule, "Reducing Aliases");
 }

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

@@ -119,6 +119,5 @@ static void extractArgumentsFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceArgumentsDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Arguments...\n";
-  runDeltaPass(Test, extractArgumentsFromModule);
+  runDeltaPass(Test, extractArgumentsFromModule, "Reducing Arguments");
 }

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

@@ -178,6 +178,5 @@ static void extractAttributesFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceAttributesDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Attributes...\n";
-  runDeltaPass(Test, extractAttributesFromModule);
+  runDeltaPass(Test, extractAttributesFromModule, "Reducing Attributes");
 }

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

@@ -173,6 +173,5 @@ static void extractBasicBlocksFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceBasicBlocksDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing Basic Blocks...\n";
-  runDeltaPass(Test, extractBasicBlocksFromModule);
+  runDeltaPass(Test, extractBasicBlocksFromModule, "Reducing Basic Blocks");
 }

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

@@ -96,7 +96,5 @@ static void extractDIMetadataFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceDIMetadataDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing DIMetadata...\n";
-  runDeltaPass(Test, extractDIMetadataFromModule);
-  outs() << "----------------------------\n";
+  runDeltaPass(Test, extractDIMetadataFromModule, "Reducing DIMetadata");
 }

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

@@ -31,7 +31,6 @@ static void extractFunctionBodiesFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceFunctionBodiesDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing Function Bodies...\n";
-  runDeltaPass(Test, extractFunctionBodiesFromModule);
-  errs() << "----------------------------\n";
+  runDeltaPass(Test, extractFunctionBodiesFromModule,
+               "Reducing Function Bodies");
 }

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

@@ -50,7 +50,5 @@ static void extractFunctionsFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceFunctionsDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing Functions...\n";
-  runDeltaPass(Test, extractFunctionsFromModule);
-  errs() << "----------------------------\n";
+  runDeltaPass(Test, extractFunctionsFromModule, "Reducing Functions");
 }

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

@@ -31,6 +31,5 @@ static void reduceGOs(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceGlobalObjectsDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing GlobalObjects...\n";
-  runDeltaPass(Test, reduceGOs);
+  runDeltaPass(Test, reduceGOs, "Reducing GlobalObjects");
 }

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

@@ -58,6 +58,5 @@ static void reduceGVs(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceGlobalValuesDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing GlobalValues...\n";
-  runDeltaPass(Test, reduceGVs);
+  runDeltaPass(Test, reduceGVs, "Reducing GlobalValues");
 }

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

@@ -29,6 +29,5 @@ static void extractGVsFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceGlobalsInitializersDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing GVs initializers...\n";
-  runDeltaPass(Test, extractGVsFromModule);
+  runDeltaPass(Test, extractGVsFromModule, "Reducing GV Initializers");
 }

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

@@ -59,6 +59,5 @@ static void extractGVsFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceGlobalsDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing GVs...\n";
-  runDeltaPass(Test, extractGVsFromModule);
+  runDeltaPass(Test, extractGVsFromModule, "Reducing GlobalVariables");
 }

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

@@ -67,16 +67,15 @@ static void stripIRFromFunctions(Oracle &O, ReducerWorkItem &WorkItem) {
 }
 
 void llvm::reduceIRInstructionReferencesDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing IR references from instructions...\n";
-  runDeltaPass(Test, stripIRFromInstructions);
+  runDeltaPass(Test, stripIRFromInstructions,
+               "Reducing IR references from instructions");
 }
 
 void llvm::reduceIRBlockReferencesDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing IR references from blocks...\n";
-  runDeltaPass(Test, stripIRFromBlocks);
+  runDeltaPass(Test, stripIRFromBlocks, "Reducing IR references from blocks");
 }
 
 void llvm::reduceIRFunctionReferencesDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing IR references from functions...\n";
-  runDeltaPass(Test, stripIRFromFunctions);
+  runDeltaPass(Test, stripIRFromFunctions,
+               "Reducing IR references from functions");
 }

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

@@ -30,6 +30,5 @@ static void removeFlagsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
 }
 
 void llvm::reduceInstructionFlagsMIRDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Instruction flags...\n";
-  runDeltaPass(Test, removeFlagsFromModule);
+  runDeltaPass(Test, removeFlagsFromModule, "Reducing Instruction Flags");
 }

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

@@ -52,6 +52,5 @@ static void extractInstrFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceInstructionsDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Instructions...\n";
-  runDeltaPass(Test, extractInstrFromModule);
+  runDeltaPass(Test, extractInstrFromModule, "Reducing Instructions");
 }

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

@@ -158,6 +158,5 @@ static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
 }
 
 void llvm::reduceInstructionsMIRDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Instructions...\n";
-  runDeltaPass(Test, extractInstrFromModule);
+  runDeltaPass(Test, extractInstrFromModule, "Reducing Instructions");
 }

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

@@ -76,7 +76,5 @@ static void extractMetadataFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceMetadataDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Metadata...\n";
-  runDeltaPass(Test, extractMetadataFromModule);
-  outs() << "----------------------------\n";
+  runDeltaPass(Test, extractMetadataFromModule, "Reducing Metadata");
 }

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

@@ -25,6 +25,5 @@ static void clearModuleData(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceModuleDataDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Module Data...\n";
-  runDeltaPass(Test, clearModuleData);
+  runDeltaPass(Test, clearModuleData, "Reducing Module Data");
 }

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

@@ -107,6 +107,5 @@ static void replaceOpcodesInModule(Oracle &O, Module &Mod) {
 }
 
 void llvm::reduceOpcodesDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Opcodes...\n";
-  runDeltaPass(Test, replaceOpcodesInModule);
+  runDeltaPass(Test, replaceOpcodesInModule, "Reducing Opcodes");
 }

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

@@ -104,6 +104,6 @@ static void extractOperandBundesFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceOperandBundesDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing OperandBundes...\n";
-  runDeltaPass(Test, extractOperandBundesFromModule);
+  runDeltaPass(Test, extractOperandBundesFromModule,
+               "Reducing Operand Bundles");
 }

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

@@ -82,7 +82,6 @@ static bool switchCaseExists(Use &Op, ConstantInt *CI) {
 }
 
 void llvm::reduceOperandsOneDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing Operands to one...\n";
   auto ReduceValue = [](Use &Op) -> Value * {
     if (!shouldReduceOperand(Op))
       return nullptr;
@@ -117,13 +116,15 @@ void llvm::reduceOperandsOneDeltaPass(TestRunner &Test) {
 
     return nullptr;
   };
-  runDeltaPass(Test, [ReduceValue](Oracle &O, Module &Program) {
-    extractOperandsFromModule(O, Program, ReduceValue);
-  });
+  runDeltaPass(
+      Test,
+      [ReduceValue](Oracle &O, Module &Program) {
+        extractOperandsFromModule(O, Program, ReduceValue);
+      },
+      "Reducing Operands to one");
 }
 
 void llvm::reduceOperandsZeroDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing Operands to zero...\n";
   auto ReduceValue = [](Use &Op) -> Value * {
     if (!shouldReduceOperand(Op))
       return nullptr;
@@ -134,13 +135,15 @@ void llvm::reduceOperandsZeroDeltaPass(TestRunner &Test) {
     // Don't replace existing zeroes.
     return isZero(Op) ? nullptr : Constant::getNullValue(Op->getType());
   };
-  runDeltaPass(Test, [ReduceValue](Oracle &O, Module &Program) {
-    extractOperandsFromModule(O, Program, ReduceValue);
-  });
+  runDeltaPass(
+      Test,
+      [ReduceValue](Oracle &O, Module &Program) {
+        extractOperandsFromModule(O, Program, ReduceValue);
+      },
+      "Reducing Operands to zero");
 }
 
 void llvm::reduceOperandsNaNDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing Operands to NaN...\n";
   auto ReduceValue = [](Use &Op) -> Value * {
     Type *Ty = Op->getType();
     if (!Ty->isFPOrFPVectorTy())
@@ -160,7 +163,10 @@ void llvm::reduceOperandsNaNDeltaPass(TestRunner &Test) {
 
     return ConstantFP::getQNaN(Ty);
   };
-  runDeltaPass(Test, [ReduceValue](Oracle &O, Module &Program) {
-    extractOperandsFromModule(O, Program, ReduceValue);
-  });
+  runDeltaPass(
+      Test,
+      [ReduceValue](Oracle &O, Module &Program) {
+        extractOperandsFromModule(O, Program, ReduceValue);
+      },
+      "Reducing Operands to NaN");
 }

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

@@ -222,6 +222,6 @@ static void extractOperandsFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceOperandsSkipDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing operands by skipping over instructions ...\n";
-  runDeltaPass(Test, extractOperandsFromModule);
+  runDeltaPass(Test, extractOperandsFromModule,
+               "Reducing operands by skipping over instructions");
 }

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

@@ -195,6 +195,6 @@ static void reduceOperandsToArgs(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceOperandsToArgsDeltaPass(TestRunner &Test) {
-  outs() << "*** Converting operands to function arguments ...\n";
-  return runDeltaPass(Test, reduceOperandsToArgs);
+  runDeltaPass(Test, reduceOperandsToArgs,
+               "Converting operands to function arguments");
 }

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

@@ -117,6 +117,5 @@ static void removeDefsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
 }
 
 void llvm::reduceRegisterDefsMIRDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing register defs...\n";
-  runDeltaPass(Test, removeDefsFromModule);
+  runDeltaPass(Test, removeDefsFromModule, "Reducing register defs");
 }

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

@@ -68,6 +68,5 @@ static void reduceMasksInModule(Oracle &O, ReducerWorkItem &WorkItem) {
 }
 
 void llvm::reduceRegisterMasksMIRDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing register masks...\n";
-  runDeltaPass(Test, reduceMasksInModule);
+  runDeltaPass(Test, reduceMasksInModule, "Reducing register masks");
 }

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

@@ -62,6 +62,5 @@ static void removeUsesFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
 }
 
 void llvm::reduceRegisterUsesMIRDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing register uses...\n";
-  runDeltaPass(Test, removeUsesFromModule);
+  runDeltaPass(Test, removeUsesFromModule, "Reducing register uses");
 }

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

@@ -37,7 +37,6 @@ static void extractSpecialGlobalsFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceSpecialGlobalsDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing Special Globals ...\n";
-  runDeltaPass(Test, extractSpecialGlobalsFromModule);
-  errs() << "----------------------------\n";
+  runDeltaPass(Test, extractSpecialGlobalsFromModule,
+               "Reducing Special Globals");
 }

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

@@ -29,6 +29,5 @@ static void reduceUsingSimplifyCFG(Oracle &O, Module &Program) {
 }
 
 void llvm::reduceUsingSimplifyCFGDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing using SimplifyCFG...\n";
-  runDeltaPass(Test, reduceUsingSimplifyCFG);
+  runDeltaPass(Test, reduceUsingSimplifyCFG, "Reducing using SimplifyCFG");
 }

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

@@ -41,6 +41,6 @@ static void dropRegisterHintsFromFunctions(Oracle &O,
 }
 
 void llvm::reduceVirtualRegisterHintsDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing virtual register hints from functions...\n";
-  runDeltaPass(Test, dropRegisterHintsFromFunctions);
+  runDeltaPass(Test, dropRegisterHintsFromFunctions,
+               "Reducing virtual register hints from functions");
 }

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

@@ -47,7 +47,5 @@ static void runPasses(Oracle &O, Module &Program) {
 }
 
 void llvm::runIRPassesDeltaPass(TestRunner &Test) {
-  errs() << "*** Running passes ...\n";
-  runDeltaPass(Test, runPasses);
-  errs() << "----------------------------\n";
+  runDeltaPass(Test, runPasses, "Running passes");
 }

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

@@ -45,6 +45,5 @@ static void extractInstrFromModule(Oracle &O, Module &Program) {
 }
 
 void llvm::simplifyInstructionsDeltaPass(TestRunner &Test) {
-  outs() << "*** Simplifying Instructions...\n";
-  runDeltaPass(Test, extractInstrFromModule);
+  runDeltaPass(Test, extractInstrFromModule, "Simplifying Instructions");
 }

llvm/tools/llvm-reduce/llvm-reduce.cpp

@@ -189,7 +189,7 @@ int main(int Argc, char **Argv) {
   if (OutputFilename == "-")
     Tester.getProgram().print(outs(), nullptr);
   else
-    writeOutput(Tester.getProgram(), "\nDone reducing! Reduced testcase: ");
+    writeOutput(Tester.getProgram(), "Done reducing! Reduced testcase: ");
 
   return 0;
 }