[llvm-reduce] Unify pass logging

[aeubanks]

Summary

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

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

 /// * Test: The main TestRunner instance which is used to run the provided
 /// interesting-ness test, as well as to store and access the reduced Program.
 /// * 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, ReductionFunc ExtractChunksFromModule);
+void runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
+                  StringRef Message);
 } // namespace llvm
 
 #endif

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

SmallString<0> ProcessChunkFromSerializedBitcode(
   }
   return Result;
 }
 
 /// Runs the Delta Debugging algorithm, splits the code into chunks and
 /// 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)) {
     errs() << "\nInput isn't interesting! Verify interesting-ness test\n";
     exit(1);
   }
 
   int Targets;
#ifndef NDEBUG
     ExtractChunksFromModule(NoChunksCounter, *Clone);
     assert(Targets == NoChunksCounter.count() &&
            "number of chunks changes when reducing");
 #endif
   }
   if (!Targets) {
     if (Verbose)
       errs() << "\nNothing to reduce\n";
+    errs() << "----------------------------\n";
     return;
   }
 
   std::vector<Chunk> ChunksStillConsideredInteresting = {{0, Targets - 1}};
   std::unique_ptr<ReducerWorkItem> ReducedProgram;
 
   for (unsigned int Level = 0; Level < StartingGranularityLevel; Level++) {
     increaseGranularity(ChunksStillConsideredInteresting);
erase_if(ChunksStillConsideredInteresting,
            (FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity ||
             increaseGranularity(ChunksStillConsideredInteresting)));
 
   // If we reduced the testcase replace it
   if (ReducedProgram)
     Test.setProgram(std::move(ReducedProgram));
   if (Verbose)
     errs() << "Couldn't increase anymore.\n";
+  errs() << "----------------------------\n";
 }

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

for (auto &GA : make_early_inc_range(Program.aliases())) {
     if (!O.shouldKeep()) {
       GA.replaceAllUsesWith(GA.getAliasee());
       GA.eraseFromParent();
     }
   }
 }
 
 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

for (auto *F : Funcs) {
     std::string FName = std::string(F->getName());
     F->replaceAllUsesWith(ConstantExpr::getBitCast(ClonedFunc, F->getType()));
     F->eraseFromParent();
     ClonedFunc->setName(FName);
   }
 }
 
 void llvm::reduceArgumentsDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Arguments...\n";
-  runDeltaPass(Test, extractArgumentsFromModule);
+  runDeltaPass(Test, extractArgumentsFromModule, "Reducing Arguments");
 }

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

for (const auto &I : R.GlobalVariablesToRefine)
     I.first->setAttributes(convertAttributeRefToAttributeSet(C, I.second));
   for (const auto &I : R.FunctionsToRefine)
     I.first->setAttributes(convertAttributeRefVecToAttributeList(C, I.second));
   for (const auto &I : R.CallsToRefine)
     I.first->setAttributes(convertAttributeRefVecToAttributeList(C, I.second));
 }
 
 void llvm::reduceAttributesDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Attributes...\n";
-  runDeltaPass(Test, extractAttributesFromModule);
+  runDeltaPass(Test, extractAttributesFromModule, "Reducing Attributes");
 }

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

for (auto &I : *BB)
       I.replaceAllUsesWith(getDefaultValue(I.getType()));
     // Should not be completely removing the body of a function.
     assert(BB->getParent()->size() > 1);
     BB->eraseFromParent();
   }
 }
 
 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

for (Function &F : Program.functions()) {
     for (Instruction &I : instructions(F))
       if (auto *DI = I.getMetadata(llvm::LLVMContext::MD_dbg))
         MDs.push_back(DI);
   }
   identifyUninterestingMDNodes(O, MDs);
 }
 
 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

for (auto &F : Program) {
     if (!F.isDeclaration() && !hasAliasUse(F) && !O.shouldKeep()) {
       F.deleteBody();
       F.setComdat(nullptr);
     }
   }
 }
 
 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

for (Function &F : FuncsToRemove) {
     // Replace all *still* remaining uses with the default value.
     F.replaceAllUsesWith(getDefaultValue(F.getType()));
     // And finally, fully drop it.
     F.eraseFromParent();
   }
 }
 
 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

for (auto &GO : Program.global_objects()) {
     if (shouldReduceAlign(GO) && !O.shouldKeep())
       GO.setAlignment(MaybeAlign());
     if (shouldReduceComdat(GO) && !O.shouldKeep())
       GO.setComdat(nullptr);
   }
 }
 
 void llvm::reduceGlobalObjectsDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing GlobalObjects...\n";
-  runDeltaPass(Test, reduceGOs);
+  runDeltaPass(Test, reduceGOs, "Reducing GlobalObjects");
 }

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

if (shouldReduceDLLStorageClass(GV) && !O.shouldKeep())
       GV.setDLLStorageClass(
           GlobalValue::DLLStorageClassTypes::DefaultStorageClass);
     if (shouldReduceThreadLocal(GV) && !O.shouldKeep())
       GV.setThreadLocal(false);
   }
 }
 
 void llvm::reduceGlobalValuesDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing GlobalValues...\n";
-  runDeltaPass(Test, reduceGVs);
+  runDeltaPass(Test, reduceGVs, "Reducing GlobalValues");
 }

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

for (auto &GV : Program.globals())
     if (GV.hasInitializer() && !O.shouldKeep()) {
       GV.setInitializer(nullptr);
       GV.setLinkage(GlobalValue::LinkageTypes::ExternalLinkage);
       GV.setComdat(nullptr);
     }
 }
 
 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

for (Value *V : InstToRemove) {
     Inst->eraseFromParent();
   }
 
   for (auto *GV : ToRemove)
     GV->eraseFromParent();
 }
 
 void llvm::reduceGlobalsDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing GVs...\n";
-  runDeltaPass(Test, extractGVsFromModule);
+  runDeltaPass(Test, extractGVsFromModule, "Reducing GlobalVariables");
 }

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

if (!O.shouldKeep()) {
              I != E; ++I)
           MFI.clearObjectAllocation(I);
       }
     }
   }
 }
 
 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

if (auto *MF = WorkItem.MMI->getMachineFunction(F)) {
             MI.setFlags(0);
         }
       }
     }
   }
 }
 
 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

for (auto &BB : F)
           InstToDelete.push_back(&Inst);
         }
 
   for (auto &I : InstToDelete)
     I->eraseFromParent();
 }
 
 void llvm::reduceInstructionsDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Instructions...\n";
-  runDeltaPass(Test, extractInstrFromModule);
+  runDeltaPass(Test, extractInstrFromModule, "Reducing Instructions");
 }

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

 static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
   for (const Function &F : WorkItem.getModule()) {
     if (MachineFunction *MF = WorkItem.MMI->getMachineFunction(F))
       extractInstrFromFunction(O, *MF);
   }
 }
 
 void llvm::reduceInstructionsMIRDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Instructions...\n";
-  runDeltaPass(Test, extractInstrFromModule);
+  runDeltaPass(Test, extractInstrFromModule, "Reducing Instructions");
 }

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

for (Instruction &I : instructions(F)) {
         if (!shouldKeepDebugIntrinsicMetadata(I, *MD.second) && !O.shouldKeep())
           I.setMetadata(MD.first, nullptr);
       }
     }
   }
 }
 
 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

static void clearModuleData(Oracle &O, Module &Program) {
   if (!Program.getSourceFileName().empty() && !O.shouldKeep())
     Program.setSourceFileName("");
   // TODO: clear line by line rather than all at once
   if (!Program.getModuleInlineAsm().empty() && !O.shouldKeep())
     Program.setModuleInlineAsm("");
 }
 
 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

for (BasicBlock &BB : F)
           I.replaceAllUsesWith(Replacement);
           I.eraseFromParent();
         }
       }
   }
 }
 
 void llvm::reduceOpcodesDeltaPass(TestRunner &Test) {
-  outs() << "*** Reducing Opcodes...\n";
-  runDeltaPass(Test, replaceOpcodesInModule);
+  runDeltaPass(Test, replaceOpcodesInModule, "Reducing Opcodes");
 }

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

static void extractOperandBundesFromModule(Oracle &O, Module &Program) {
   OperandBundleRemapper R(O);
   R.visit(Program);
 
   for (const auto &I : R.CallsToRefine)
     maybeRewriteCallWithDifferentBundles(I.first, I.second);
 }
 
 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

 static bool switchCaseExists(Use &Op, ConstantInt *CI) {
   SwitchInst *SI = dyn_cast<SwitchInst>(Op.getUser());
   if (!SI)
     return false;
   return SI->findCaseValue(CI) != SI->case_default();
 }
 
 void llvm::reduceOperandsOneDeltaPass(TestRunner &Test) {
-  errs() << "*** Reducing Operands to one...\n";
   auto ReduceValue = [](Use &Op) -> Value * {
     if (!shouldReduceOperand(Op))
       return nullptr;
 
     Type *Ty = Op->getType();
     if (auto *IntTy = dyn_cast<IntegerType>(Ty)) {
       // Don't duplicate an existing switch case.
       if (switchCaseExists(Op, ConstantInt::get(IntTy, 1)))
if (VectorType *VT = dyn_cast<VectorType>(Ty)) {
       } else {
         return nullptr;
       }
       return ConstantVector::getSplat(VT->getElementCount(), C);
     }
 
     return nullptr;
   };
-  runDeltaPass(Test, [ReduceValue](Oracle &O, Module &Program) {
+  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;
     // Don't duplicate an existing switch case.
     if (auto *IntTy = dyn_cast<IntegerType>(Op->getType()))
       if (switchCaseExists(Op, ConstantInt::get(IntTy, 0)))
         return nullptr;
     // Don't replace existing zeroes.
     return isZero(Op) ? nullptr : Constant::getNullValue(Op->getType());
   };
-  runDeltaPass(Test, [ReduceValue](Oracle &O, Module &Program) {
+  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())
       return nullptr;
 
     // Prefer 0.0 or 1.0 over NaN.
     //
     // TODO: Preferring NaN may make more sense because FP operations are more
     // universally foldable.
     if (match(Op.get(), m_NaN()) || isZeroOrOneFP(Op.get()))
       return nullptr;
 
     if (VectorType *VT = dyn_cast<VectorType>(Ty)) {
       return ConstantVector::getSplat(VT->getElementCount(),
                                       ConstantFP::getQNaN(VT->getElementType()));
     }
 
     return ConstantFP::getQNaN(Ty);
   };
-  runDeltaPass(Test, [ReduceValue](Oracle &O, Module &Program) {
+  runDeltaPass(
+      Test,
+      [ReduceValue](Oracle &O, Module &Program) {
         extractOperandsFromModule(O, Program, ReduceValue);
-  });
+      },
+      "Reducing Operands to NaN");
 }

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

for (std::pair<Use *, Value *> P : Replacements) {
         Phi->setIncomingValueForBlock(Phi->getIncomingBlock(*P.first), P.second);
       else
         P.first->set(P.second);
     }
   }
 }
 
 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

for (Instruction &I : instructions(&F)) {
       }
     }
 
     substituteOperandWithArgument(&F, OperandsToReduce);
   }
 }
 
 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

 static void removeDefsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
   for (const Function &F : WorkItem.getModule()) {
     if (auto *MF = WorkItem.MMI->getMachineFunction(F))
       removeDefsFromFunction(O, *MF);
   }
 }
 
 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

 static void reduceMasksInModule(Oracle &O, ReducerWorkItem &WorkItem) {
   for (const Function &F : WorkItem.getModule()) {
     if (auto *MF = WorkItem.MMI->getMachineFunction(F))
       reduceMasksInFunction(O, *MF);
   }
 }
 
 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

 static void removeUsesFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
   for (const Function &F : WorkItem.getModule()) {
     if (auto *MF = WorkItem.MMI->getMachineFunction(F))
       removeUsesFromFunction(O, *MF);
   }
 }
 
 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

for (StringRef Name : SpecialGlobalNames) {
     if (auto *Used = Program.getNamedGlobal(Name)) {
       Used->replaceAllUsesWith(getDefaultValue(Used->getType()));
       Used->eraseFromParent();
     }
   }
 }
 
 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

for (auto &BB : F)
       if (!O.shouldKeep())
         ToSimplify.push_back(&BB);
   TargetTransformInfo TTI(Program.getDataLayout());
   for (auto *BB : ToSimplify)
     simplifyCFG(BB, TTI);
 }
 
 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

static void dropRegisterHintsFromFunctions(Oracle &O,
                                            ReducerWorkItem &WorkItem) {
   for (const Function &F : WorkItem.getModule()) {
     if (auto *MF = WorkItem.MMI->getMachineFunction(F))
       dropRegisterHintsFromFunction(O, *MF);
   }
 }
 
 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

static void runPasses(Oracle &O, Module &Program) {
   if (auto Err = PB.parsePassPipeline(MPM, PassPipeline)) {
     errs() << toString(std::move(Err)) << "\n";
     report_fatal_error("Error constructing pass pipeline");
   }
   MPM.run(Program, MAM);
 }
 
 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

for (auto &F : Program) {
     }
   }
 
   for (Instruction *I : InstToDelete)
     I->eraseFromParent();
 }
 
 void llvm::simplifyInstructionsDeltaPass(TestRunner &Test) {
-  outs() << "*** Simplifying Instructions...\n";
-  runDeltaPass(Test, extractInstrFromModule);
+  runDeltaPass(Test, extractInstrFromModule, "Simplifying Instructions");
 }

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

int main(int Argc, char **Argv) {
 
   // Try to reduce code
   runDeltaPasses(Tester, MaxPassIterations);
 
   // Print reduced file to STDOUT
   if (OutputFilename == "-")
     Tester.getProgram().print(outs(), nullptr);
   else
-    writeOutput(Tester.getProgram(), "\nDone reducing! Reduced testcase: ");
+    writeOutput(Tester.getProgram(), "Done reducing! Reduced testcase: ");
 
   return 0;
 }