diff --git a/clang/lib/Frontend/ASTUnit.cpp b/clang/lib/Frontend/ASTUnit.cpp index 0a5f1cfd1a264..4bc0496253f70 100644 --- a/clang/lib/Frontend/ASTUnit.cpp +++ b/clang/lib/Frontend/ASTUnit.cpp @@ -832,11 +832,10 @@ std::unique_ptr ASTUnit::LoadFromASTFile( AST->ModCache = createCrossProcessModuleCache(); AST->HSOpts = HSOpts ? HSOpts : std::make_shared(); AST->HSOpts->ModuleFormat = std::string(PCHContainerRdr.getFormats().front()); - AST->HeaderInfo.reset(new HeaderSearch(AST->getHeaderSearchOpts(), - AST->getSourceManager(), - AST->getDiagnostics(), - AST->getLangOpts(), - /*Target=*/nullptr)); + AST->HeaderInfo.reset( + new HeaderSearch(AST->getHeaderSearchOpts(), AST->getSourceManager(), + AST->getDiagnostics(), AST->getLangOpts(), + /*Target=*/nullptr)); AST->PPOpts = std::make_shared(); // Gather Info for preprocessor construction later on. diff --git a/clang/lib/Lex/ModuleMap.cpp b/clang/lib/Lex/ModuleMap.cpp index a1394fd3900b0..c9b5f767555cf 100644 --- a/clang/lib/Lex/ModuleMap.cpp +++ b/clang/lib/Lex/ModuleMap.cpp @@ -353,8 +353,7 @@ ModuleMap::ModuleMap(SourceManager &SourceMgr, DiagnosticsEngine &Diags, const LangOptions &LangOpts, const TargetInfo *Target, HeaderSearch &HeaderInfo) : SourceMgr(SourceMgr), Diags(Diags), LangOpts(LangOpts), Target(Target), - HeaderInfo(HeaderInfo) { -} + HeaderInfo(HeaderInfo) {} ModuleMap::~ModuleMap() = default; diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index 0cd2cedb48dd9..ce7b9d966d736 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -9613,9 +9613,11 @@ ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &M, unsigned ID) const { return I == GlobalSubmoduleMap.end() ? nullptr : I->second; } else { // It's a prefix (preamble, PCH, ...). Look it up by index. - int IndexFromEnd = static_cast(ID >> 1); + int IndexFromEnd = static_cast(ID >> 1); assert(IndexFromEnd && "got reference to unknown module file"); - return getModuleManager().pch_modules().end()[-static_cast(IndexFromEnd)]; + return getModuleManager() + .pch_modules() + .end()[-static_cast(IndexFromEnd)]; } } diff --git a/flang/lib/Evaluate/fold-logical.cpp b/flang/lib/Evaluate/fold-logical.cpp index 6950caf327419..731e79b9337da 100644 --- a/flang/lib/Evaluate/fold-logical.cpp +++ b/flang/lib/Evaluate/fold-logical.cpp @@ -880,7 +880,7 @@ Expr> FoldIntrinsicFunction( if (args[0]) { if (const auto *cst{UnwrapExpr>(args[0])}) { if (auto constr{cst->GetScalarValue()}) { - if (StructureConstructorValues & values{constr->values()}; + if (StructureConstructorValues &values{constr->values()}; values.size() == 1) { const Expr &value{values.begin()->second.value()}; if (auto flag{ToInt64(value)}) { diff --git a/libcxx/test/std/utilities/utility/forward/forward_like.verify.cpp b/libcxx/test/std/utilities/utility/forward/forward_like.verify.cpp index 279f0e60a1c38..5f7a319ff38ee 100644 --- a/libcxx/test/std/utilities/utility/forward/forward_like.verify.cpp +++ b/libcxx/test/std/utilities/utility/forward/forward_like.verify.cpp @@ -39,8 +39,8 @@ void test() { (void)std::forward_like(i); // expected-error {{no matching function for call to 'forward_like'}} (void)std::forward_like(i); // expected-error {{no matching function for call to 'forward_like'}} - using fpr = void()&; - using fprr = void()&&; + using fpr = void() &; + using fprr = void() &&; (void)std::forward_like(i); // expected-error {{no matching function for call to 'forward_like'}} (void)std::forward_like(i); // expected-error {{no matching function for call to 'forward_like'}} } diff --git a/llvm/tools/llvm-reduce/DeltaManager.cpp b/llvm/tools/llvm-reduce/DeltaManager.cpp index 624b5306bc71b..dfa4aa6a534fd 100644 --- a/llvm/tools/llvm-reduce/DeltaManager.cpp +++ b/llvm/tools/llvm-reduce/DeltaManager.cpp @@ -53,6 +53,8 @@ #include "deltas/StripDebugInfo.h" #include "llvm/ADT/SmallSet.h" #include "llvm/Support/CommandLine.h" +#include "DeltaPass.h" +#include "llvm/ADT/ArrayRef.h" using namespace llvm; @@ -71,91 +73,77 @@ static cl::list "default, run all delta passes."), cl::cat(LLVMReduceOptions), cl::CommaSeparated); -#define DELTA_PASSES \ - do { \ - DELTA_PASS("strip-debug-info", stripDebugInfoDeltaPass) \ - DELTA_PASS("functions", reduceFunctionsDeltaPass) \ - DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass) \ - DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass) \ - DELTA_PASS("aliases", reduceAliasesDeltaPass) \ - DELTA_PASS("ifuncs", reduceIFuncsDeltaPass) \ - DELTA_PASS("simplify-conditionals-true", reduceConditionalsTrueDeltaPass) \ - DELTA_PASS("simplify-conditionals-false", \ - reduceConditionalsFalseDeltaPass) \ - DELTA_PASS("invokes", reduceInvokesDeltaPass) \ - DELTA_PASS("unreachable-basic-blocks", \ - reduceUnreachableBasicBlocksDeltaPass) \ - DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass) \ - DELTA_PASS("simplify-cfg", reduceUsingSimplifyCFGDeltaPass) \ - DELTA_PASS("function-data", reduceFunctionDataDeltaPass) \ - DELTA_PASS("global-values", reduceGlobalValuesDeltaPass) \ - DELTA_PASS("global-objects", reduceGlobalObjectsDeltaPass) \ - DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass) \ - DELTA_PASS("global-variables", reduceGlobalsDeltaPass) \ - DELTA_PASS("di-metadata", reduceDIMetadataDeltaPass) \ - DELTA_PASS("dbg-records", reduceDbgRecordDeltaPass) \ - DELTA_PASS("distinct-metadata", reduceDistinctMetadataDeltaPass) \ - DELTA_PASS("metadata", reduceMetadataDeltaPass) \ - DELTA_PASS("named-metadata", reduceNamedMetadataDeltaPass) \ - DELTA_PASS("arguments", reduceArgumentsDeltaPass) \ - DELTA_PASS("instructions", reduceInstructionsDeltaPass) \ - DELTA_PASS("simplify-instructions", simplifyInstructionsDeltaPass) \ - DELTA_PASS("ir-passes", runIRPassesDeltaPass) \ - DELTA_PASS("operands-zero", reduceOperandsZeroDeltaPass) \ - DELTA_PASS("operands-one", reduceOperandsOneDeltaPass) \ - DELTA_PASS("operands-nan", reduceOperandsNaNDeltaPass) \ - DELTA_PASS("operands-to-args", reduceOperandsToArgsDeltaPass) \ - DELTA_PASS("operands-skip", reduceOperandsSkipDeltaPass) \ - DELTA_PASS("operand-bundles", reduceOperandBundesDeltaPass) \ - DELTA_PASS("attributes", reduceAttributesDeltaPass) \ - DELTA_PASS("module-data", reduceModuleDataDeltaPass) \ - DELTA_PASS("opcodes", reduceOpcodesDeltaPass) \ - DELTA_PASS("volatile", reduceVolatileInstructionsDeltaPass) \ - DELTA_PASS("atomic-ordering", reduceAtomicOrderingDeltaPass) \ - DELTA_PASS("syncscopes", reduceAtomicSyncScopesDeltaPass) \ - DELTA_PASS("instruction-flags", reduceInstructionFlagsDeltaPass) \ - } while (false) - -#define DELTA_PASSES_MIR \ - do { \ - DELTA_PASS("instructions", reduceInstructionsMIRDeltaPass) \ - DELTA_PASS("ir-instruction-references", \ - reduceIRInstructionReferencesDeltaPass) \ - DELTA_PASS("ir-block-references", reduceIRBlockReferencesDeltaPass) \ - DELTA_PASS("ir-function-references", reduceIRFunctionReferencesDeltaPass) \ - DELTA_PASS("instruction-flags", reduceInstructionFlagsMIRDeltaPass) \ - DELTA_PASS("register-uses", reduceRegisterUsesMIRDeltaPass) \ - DELTA_PASS("register-defs", reduceRegisterDefsMIRDeltaPass) \ - DELTA_PASS("register-hints", reduceVirtualRegisterHintsDeltaPass) \ - DELTA_PASS("register-masks", reduceRegisterMasksMIRDeltaPass) \ - } while (false) +// Generate two separate Pass lists: IR_Passes and MIR_Passes +static const DeltaPass IR_Passes[] = { + #undef DELTA_PASS_IR + #undef DELTA_PASS_MIR + #define DELTA_PASS_IR(NAME, FUNC, DESC) {NAME, FUNC, DESC}, + #include "DeltaPasses.def" + #undef DELTA_PASS_IR +}; + +static const DeltaPass MIR_Passes[] = { + #undef DELTA_PASS_IR +#undef DELTA_PASS_MIR +#define DELTA_PASS_MIR(NAME, FUNC, DESC) {NAME, FUNC, DESC}, +#include "DeltaPasses.def" +#undef DELTA_PASS_MIR +}; + static void runAllDeltaPasses(TestRunner &Tester, const SmallStringSet &SkipPass) { -#define DELTA_PASS(NAME, FUNC) \ - if (!SkipPass.count(NAME)) { \ - FUNC(Tester); \ - } if (Tester.getProgram().isMIR()) { - DELTA_PASSES_MIR; + for(const DeltaPass &Pass : MIR_Passes) { + if (!SkipPass.count(Pass.Name)) { + SmallString<64> Message; + Message += Pass.Desc; + Message += " ("; + Message += Pass.Name; + Message += ")"; + Pass.Func(Tester,Message); + } + } } else { - DELTA_PASSES; + for(const DeltaPass &Pass : IR_Passes) { + if (!SkipPass.count(Pass.Name)) { + SmallString<64> Message; + Message += Pass.Desc; + Message += " ("; + Message += Pass.Name; + Message += ")"; + Pass.Func(Tester,Message); + } + } } -#undef DELTA_PASS } static void runDeltaPassName(TestRunner &Tester, StringRef PassName) { -#define DELTA_PASS(NAME, FUNC) \ - if (PassName == NAME) { \ - FUNC(Tester); \ - return; \ - } if (Tester.getProgram().isMIR()) { - DELTA_PASSES_MIR; + for(const DeltaPass &Pass : MIR_Passes) { + if (PassName == Pass.Name) { + SmallString<64> Message; + Message += Pass.Desc; + Message += " ("; + Message += Pass.Name; + Message += ")"; + Pass.Func(Tester,Message); + return; + } + } } else { - DELTA_PASSES; + for(const DeltaPass &Pass : IR_Passes) { + if (PassName == Pass.Name) { + SmallString<64> Message; + Message += Pass.Desc; + Message += " ("; + Message += Pass.Name; + Message += ")"; + Pass.Func(Tester,Message); + return; + } + } } -#undef DELTA_PASS // We should have errored on unrecognized passes before trying to run // anything. @@ -164,24 +152,25 @@ static void runDeltaPassName(TestRunner &Tester, StringRef PassName) { void llvm::printDeltaPasses(raw_ostream &OS) { OS << "Delta passes (pass to `--delta-passes=` as a comma separated list):\n"; -#define DELTA_PASS(NAME, FUNC) OS << " " << NAME << "\n"; OS << " IR:\n"; - DELTA_PASSES; + for (const DeltaPass &Pass : IR_Passes) { + OS << " " << Pass.Name << "\n"; + } OS << " MIR:\n"; - DELTA_PASSES_MIR; -#undef DELTA_PASS + for (const DeltaPass &Pass : MIR_Passes) { + OS << " " << Pass.Name << "\n"; + } } // Built a set of available delta passes. static void collectPassNames(const TestRunner &Tester, SmallStringSet &NameSet) { -#define DELTA_PASS(NAME, FUNC) NameSet.insert(NAME); - if (Tester.getProgram().isMIR()) { - DELTA_PASSES_MIR; - } else { - DELTA_PASSES; + for (const DeltaPass &Pass : MIR_Passes) { + NameSet.insert(Pass.Name); + } + for (const DeltaPass &Pass : IR_Passes) { + NameSet.insert(Pass.Name); } -#undef DELTA_PASS } /// Verify all requested or skipped passes are valid names, and return them in a diff --git a/llvm/tools/llvm-reduce/DeltaPass.h b/llvm/tools/llvm-reduce/DeltaPass.h new file mode 100644 index 0000000000000..ae8fd489e4308 --- /dev/null +++ b/llvm/tools/llvm-reduce/DeltaPass.h @@ -0,0 +1,25 @@ +//===--- DeltaPass.h - Delta Pass Structure --------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + + + +#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAPASS_H +#define LLVM_TOOLS_LLVM_REDUCE_DELTAPASS_H + +#include "TestRunner.h" + +namespace llvm { +struct DeltaPass { + StringRef Name; // e.g., "strip-debug-info" + void (*Func)(TestRunner &, StringRef); // function pointer, e.g.,stripDebugInfoDeltaPass + StringRef Desc; // e.g., "Stripping Debug Info" +}; +} // namespace llvm + + +#endif \ No newline at end of file diff --git a/llvm/tools/llvm-reduce/DeltaPasses.def b/llvm/tools/llvm-reduce/DeltaPasses.def new file mode 100644 index 0000000000000..5ef3f79604918 --- /dev/null +++ b/llvm/tools/llvm-reduce/DeltaPasses.def @@ -0,0 +1,68 @@ +//===--- DeltaPasses.def - Delta Pass Definitions --------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + + +#ifndef DELTA_PASS_IR +#define DELTA_PASS_IR(NAME, FUNC, DESC) +#endif +DELTA_PASS_IR("strip-debug-info", stripDebugInfoDeltaPass, "Stripping Debug Info") +DELTA_PASS_IR("functions", reduceFunctionsDeltaPass, "Reducing Functions") +DELTA_PASS_IR("function-bodies", reduceFunctionBodiesDeltaPass, "Reducing Function Bodies") +DELTA_PASS_IR("special-globals", reduceSpecialGlobalsDeltaPass, "Reducing Special Globals") +DELTA_PASS_IR("aliases", reduceAliasesDeltaPass, "Reducing Aliases") +DELTA_PASS_IR("ifuncs", reduceIFuncsDeltaPass, "Reducing Ifuncs") +DELTA_PASS_IR("simplify-conditionals-true", reduceConditionalsTrueDeltaPass,"Reducing conditional branches to true") +DELTA_PASS_IR("simplify-conditionals-false", + reduceConditionalsFalseDeltaPass,"Reducing conditional branches to false") +DELTA_PASS_IR("invokes", reduceInvokesDeltaPass, "Reducing Invokes") +DELTA_PASS_IR("unreachable-basic-blocks", + reduceUnreachableBasicBlocksDeltaPass, "Removing Unreachable Basic Blocks") +DELTA_PASS_IR("basic-blocks", reduceBasicBlocksDeltaPass, "Reducing Basic Blocks") +DELTA_PASS_IR("simplify-cfg", reduceUsingSimplifyCFGDeltaPass,"Reducing using SimplifyCFG") +DELTA_PASS_IR("function-data", reduceFunctionDataDeltaPass, "Reducing Function Data") +DELTA_PASS_IR("global-values", reduceGlobalValuesDeltaPass, "Reducing GlobalValues") +DELTA_PASS_IR("global-objects", reduceGlobalObjectsDeltaPass, "Reducing GlobalObjects") +DELTA_PASS_IR("global-initializers", reduceGlobalsInitializersDeltaPass, "Reducing GV Initializers") +DELTA_PASS_IR("global-variables", reduceGlobalsDeltaPass, "Reducing GlobalVariables") +DELTA_PASS_IR("di-metadata", reduceDIMetadataDeltaPass, "Reducing DIMetadata") +DELTA_PASS_IR("dbg-records", reduceDbgRecordDeltaPass, "Reducing DbgRecords") +DELTA_PASS_IR("distinct-metadata", reduceDistinctMetadataDeltaPass, "Reducing Distinct Metadata") +DELTA_PASS_IR("metadata", reduceMetadataDeltaPass,"Reducing Metadata") +DELTA_PASS_IR("named-metadata", reduceNamedMetadataDeltaPass,"Reducing Named Metadata") +DELTA_PASS_IR("arguments", reduceArgumentsDeltaPass, "Reducing Arguments") +DELTA_PASS_IR("instructions", reduceInstructionsDeltaPass, "Reducing Instructions") +DELTA_PASS_IR("simplify-instructions", simplifyInstructionsDeltaPass,"Simplifying Instructions") +DELTA_PASS_IR("ir-passes", runIRPassesDeltaPass,"Running passes") +DELTA_PASS_IR("operands-zero", reduceOperandsZeroDeltaPass,"Reducing Operands to zero") +DELTA_PASS_IR("operands-one", reduceOperandsOneDeltaPass,"Reducing Operands to one") +DELTA_PASS_IR("operands-nan", reduceOperandsNaNDeltaPass,"Reducing Operands to NaN") +DELTA_PASS_IR("operands-to-args", reduceOperandsToArgsDeltaPass,"Converting operands to function arguments") +DELTA_PASS_IR("operands-skip", reduceOperandsSkipDeltaPass,"Reducing operands by skipping over instructions") +DELTA_PASS_IR("operand-bundles", reduceOperandBundesDeltaPass,"Reducing Operand Bundles") +DELTA_PASS_IR("attributes", reduceAttributesDeltaPass, "Reducing Attributes") +DELTA_PASS_IR("module-data", reduceModuleDataDeltaPass,"Reducing Module Data") +DELTA_PASS_IR("opcodes", reduceOpcodesDeltaPass,"Reducing Opcodes") +DELTA_PASS_IR("volatile", reduceVolatileInstructionsDeltaPass,"Reducing Volatile Instructions") +DELTA_PASS_IR("atomic-ordering", reduceAtomicOrderingDeltaPass,"Reducing Atomic Ordering") +DELTA_PASS_IR("syncscopes", reduceAtomicSyncScopesDeltaPass,"Reducing Atomic Sync Scopes") +DELTA_PASS_IR("instruction-flags", reduceInstructionFlagsDeltaPass, "Reducing Instruction Flags") + + +#ifndef DELTA_PASS_MIR +#define DELTA_PASS_MIR(NAME, FUNC, DESC) +#endif +DELTA_PASS_MIR("instructions", reduceInstructionsMIRDeltaPass, "Reducing Instructions") +DELTA_PASS_MIR("ir-instruction-references", + reduceIRInstructionReferencesDeltaPass,"Reducing IR references from instructions") +DELTA_PASS_MIR("ir-block-references", reduceIRBlockReferencesDeltaPass,"Reducing IR references from blocks") +DELTA_PASS_MIR("ir-function-references", reduceIRFunctionReferencesDeltaPass,"Reducing IR references from functions") +DELTA_PASS_MIR("instruction-flags", reduceInstructionFlagsMIRDeltaPass, "Reducing Instruction Flags") +DELTA_PASS_MIR("register-uses", reduceRegisterUsesMIRDeltaPass,"Reducing register uses") +DELTA_PASS_MIR("register-defs", reduceRegisterDefsMIRDeltaPass,"Reducing register defs") +DELTA_PASS_MIR("register-hints", reduceVirtualRegisterHintsDeltaPass,"Reducing virtual register hints from functions") +DELTA_PASS_MIR("register-masks", reduceRegisterMasksMIRDeltaPass,"Reducing register masks") \ No newline at end of file diff --git a/llvm/tools/llvm-reduce/deltas/Delta.h b/llvm/tools/llvm-reduce/deltas/Delta.h index 96fcea89484c0..140fa1e870055 100644 --- a/llvm/tools/llvm-reduce/deltas/Delta.h +++ b/llvm/tools/llvm-reduce/deltas/Delta.h @@ -20,6 +20,7 @@ #include "llvm/Support/raw_ostream.h" #include #include +#include "llvm/ADT/StringRef.h" namespace llvm { diff --git a/llvm/tools/llvm-reduce/deltas/ReduceAliases.cpp b/llvm/tools/llvm-reduce/deltas/ReduceAliases.cpp index 2f2df549b6728..8c6faab51b6b8 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceAliases.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceAliases.cpp @@ -44,10 +44,10 @@ static void extractIFuncsFromModule(Oracle &O, ReducerWorkItem &WorkItem) { lowerGlobalIFuncUsersAsGlobalCtor(Mod, IFuncs); } -void llvm::reduceAliasesDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractAliasesFromModule, "Reducing Aliases"); +void llvm::reduceAliasesDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractAliasesFromModule, PassMessage); } -void llvm::reduceIFuncsDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractIFuncsFromModule, "Reducing Ifuncs"); +void llvm::reduceIFuncsDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractIFuncsFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceAliases.h b/llvm/tools/llvm-reduce/deltas/ReduceAliases.h index 404677d221ca4..b4dbc3082a97f 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceAliases.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceAliases.h @@ -17,8 +17,8 @@ #include "Delta.h" namespace llvm { -void reduceAliasesDeltaPass(TestRunner &Test); -void reduceIFuncsDeltaPass(TestRunner &Test); +void reduceAliasesDeltaPass(TestRunner &Test, StringRef PassMessage); +void reduceIFuncsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp b/llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp index 5b1363d3293a6..774e641aee20a 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp @@ -119,6 +119,6 @@ static void extractArgumentsFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceArgumentsDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractArgumentsFromModule, "Reducing Arguments"); +void llvm::reduceArgumentsDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractArgumentsFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceArguments.h b/llvm/tools/llvm-reduce/deltas/ReduceArguments.h index 5adcfe89266bc..f4a327a848cdf 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceArguments.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceArguments.h @@ -20,7 +20,7 @@ #include "llvm/Transforms/Utils/Cloning.h" namespace llvm { -void reduceArgumentsDeltaPass(TestRunner &Test); +void reduceArgumentsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp b/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp index e643fe2a51967..e1bd2adaf4fff 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp @@ -148,6 +148,6 @@ static void extractAttributesFromModule(Oracle &O, ReducerWorkItem &WorkItem) { R.visit(WorkItem.getModule()); } -void llvm::reduceAttributesDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractAttributesFromModule, "Reducing Attributes"); +void llvm::reduceAttributesDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractAttributesFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceAttributes.h b/llvm/tools/llvm-reduce/deltas/ReduceAttributes.h index a2e9955ac5bb4..f8c9a52d20a6b 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceAttributes.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceAttributes.h @@ -14,9 +14,11 @@ #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEATTRIBUTES_H #define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEATTRIBUTES_H +#include "llvm/ADT/StringRef.h" + namespace llvm { class TestRunner; -void reduceAttributesDeltaPass(TestRunner &Test); +void reduceAttributesDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceBasicBlocks.cpp b/llvm/tools/llvm-reduce/deltas/ReduceBasicBlocks.cpp index da363df77d0c0..c8cfea3f73dac 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceBasicBlocks.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceBasicBlocks.cpp @@ -188,8 +188,8 @@ static void extractBasicBlocksFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceBasicBlocksDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractBasicBlocksFromModule, "Reducing Basic Blocks"); +void llvm::reduceBasicBlocksDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractBasicBlocksFromModule, PassMessage); } static void removeUnreachableBasicBlocksFromModule(Oracle &O, @@ -220,7 +220,7 @@ static void removeUnreachableBasicBlocksFromModule(Oracle &O, } } -void llvm::reduceUnreachableBasicBlocksDeltaPass(TestRunner &Test) { +void llvm::reduceUnreachableBasicBlocksDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass(Test, removeUnreachableBasicBlocksFromModule, - "Removing Unreachable Basic Blocks"); + PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceBasicBlocks.h b/llvm/tools/llvm-reduce/deltas/ReduceBasicBlocks.h index a090d675ef822..93d5122e75a74 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceBasicBlocks.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceBasicBlocks.h @@ -18,8 +18,8 @@ #include "llvm/Transforms/Utils/Cloning.h" namespace llvm { -void reduceBasicBlocksDeltaPass(TestRunner &Test); -void reduceUnreachableBasicBlocksDeltaPass(TestRunner &Test); +void reduceBasicBlocksDeltaPass(TestRunner &Test, StringRef PassMessage); +void reduceUnreachableBasicBlocksDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.cpp b/llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.cpp index 38352d6342d4f..a78c92bdf23a0 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.cpp @@ -97,6 +97,6 @@ static void extractDIMetadataFromModule(Oracle &O, ReducerWorkItem &WorkItem) { identifyUninterestingMDNodes(O, MDs); } -void llvm::reduceDIMetadataDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractDIMetadataFromModule, "Reducing DIMetadata"); +void llvm::reduceDIMetadataDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractDIMetadataFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.h b/llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.h index 379c14a0db200..f035e063eb154 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.h @@ -17,7 +17,7 @@ #include "TestRunner.h" namespace llvm { -void reduceDIMetadataDeltaPass(TestRunner &Test); +void reduceDIMetadataDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceDbgRecords.cpp b/llvm/tools/llvm-reduce/deltas/ReduceDbgRecords.cpp index 25de659109c9f..b7b675bb24477 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceDbgRecords.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceDbgRecords.cpp @@ -34,6 +34,6 @@ static void extractDbgRecordsFromModule(Oracle &O, ReducerWorkItem &WorkItem) { DR.eraseFromParent(); } -void llvm::reduceDbgRecordDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractDbgRecordsFromModule, "Reducing DbgRecords"); +void llvm::reduceDbgRecordDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractDbgRecordsFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceDbgRecords.h b/llvm/tools/llvm-reduce/deltas/ReduceDbgRecords.h index 07a1e04fceaee..b36d15490bca8 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceDbgRecords.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceDbgRecords.h @@ -19,7 +19,7 @@ #include "llvm/IR/DebugProgramInstruction.h" namespace llvm { -void reduceDbgRecordDeltaPass(TestRunner &Test); +void reduceDbgRecordDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceDistinctMetadata.cpp b/llvm/tools/llvm-reduce/deltas/ReduceDistinctMetadata.cpp index 0f46409977a33..aaa1a9569eb2c 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceDistinctMetadata.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceDistinctMetadata.cpp @@ -136,7 +136,7 @@ static void extractDistinctMetadataFromModule(Oracle &O, cleanUpTemporaries(NamedNode, TemporaryTuple, Program); } -void llvm::reduceDistinctMetadataDeltaPass(TestRunner &Test) { +void llvm::reduceDistinctMetadataDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass(Test, extractDistinctMetadataFromModule, - "Reducing Distinct Metadata"); + PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceDistinctMetadata.h b/llvm/tools/llvm-reduce/deltas/ReduceDistinctMetadata.h index d02e8e6107b75..1467004c2ba8c 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceDistinctMetadata.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceDistinctMetadata.h @@ -17,7 +17,7 @@ #include "TestRunner.h" namespace llvm { -void reduceDistinctMetadataDeltaPass(TestRunner &Test); +void reduceDistinctMetadataDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceFunctionBodies.cpp b/llvm/tools/llvm-reduce/deltas/ReduceFunctionBodies.cpp index 21875ba00cf8b..d856db74f8491 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceFunctionBodies.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceFunctionBodies.cpp @@ -32,9 +32,9 @@ static void extractFunctionBodiesFromModule(Oracle &O, } } -void llvm::reduceFunctionBodiesDeltaPass(TestRunner &Test) { +void llvm::reduceFunctionBodiesDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass(Test, extractFunctionBodiesFromModule, - "Reducing Function Bodies"); + PassMessage); } static void reduceFunctionData(Oracle &O, ReducerWorkItem &WorkItem) { @@ -57,6 +57,6 @@ static void reduceFunctionData(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceFunctionDataDeltaPass(TestRunner &Test) { - runDeltaPass(Test, reduceFunctionData, "Reducing Function Data"); +void llvm::reduceFunctionDataDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, reduceFunctionData, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceFunctionBodies.h b/llvm/tools/llvm-reduce/deltas/ReduceFunctionBodies.h index ae738fb1b88e3..082f9cc0451f5 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceFunctionBodies.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceFunctionBodies.h @@ -17,8 +17,8 @@ #include "Delta.h" namespace llvm { -void reduceFunctionBodiesDeltaPass(TestRunner &Test); -void reduceFunctionDataDeltaPass(TestRunner &Test); +void reduceFunctionBodiesDeltaPass(TestRunner &Test, StringRef PassMessage); +void reduceFunctionDataDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceFunctions.cpp b/llvm/tools/llvm-reduce/deltas/ReduceFunctions.cpp index 619811c89202e..286d98a7a0b71 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceFunctions.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceFunctions.cpp @@ -55,6 +55,6 @@ static void extractFunctionsFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceFunctionsDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractFunctionsFromModule, "Reducing Functions"); +void llvm::reduceFunctionsDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractFunctionsFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceFunctions.h b/llvm/tools/llvm-reduce/deltas/ReduceFunctions.h index d3ff0d9511289..a847387ea84db 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceFunctions.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceFunctions.h @@ -18,7 +18,7 @@ #include "llvm/Transforms/Utils/Cloning.h" namespace llvm { -void reduceFunctionsDeltaPass(TestRunner &Test); +void reduceFunctionsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceGlobalObjects.cpp b/llvm/tools/llvm-reduce/deltas/ReduceGlobalObjects.cpp index 1d1463a055bd8..27b354ce86965 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceGlobalObjects.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceGlobalObjects.cpp @@ -30,6 +30,6 @@ static void reduceGOs(Oracle &O, ReducerWorkItem &Program) { } } -void llvm::reduceGlobalObjectsDeltaPass(TestRunner &Test) { - runDeltaPass(Test, reduceGOs, "Reducing GlobalObjects"); +void llvm::reduceGlobalObjectsDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, reduceGOs, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceGlobalObjects.h b/llvm/tools/llvm-reduce/deltas/ReduceGlobalObjects.h index 35c38a9ecf212..d743dc8539913 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceGlobalObjects.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceGlobalObjects.h @@ -12,7 +12,7 @@ #include "Delta.h" namespace llvm { -void reduceGlobalObjectsDeltaPass(TestRunner &Test); +void reduceGlobalObjectsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceGlobalValues.cpp b/llvm/tools/llvm-reduce/deltas/ReduceGlobalValues.cpp index 6e8c21008502f..c956efad9a6ef 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceGlobalValues.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceGlobalValues.cpp @@ -67,6 +67,6 @@ static void reduceGVs(Oracle &O, ReducerWorkItem &Program) { } } -void llvm::reduceGlobalValuesDeltaPass(TestRunner &Test) { - runDeltaPass(Test, reduceGVs, "Reducing GlobalValues"); +void llvm::reduceGlobalValuesDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, reduceGVs, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceGlobalValues.h b/llvm/tools/llvm-reduce/deltas/ReduceGlobalValues.h index 19c0707936528..b97a7885a829f 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceGlobalValues.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceGlobalValues.h @@ -17,7 +17,7 @@ #include "Delta.h" namespace llvm { -void reduceGlobalValuesDeltaPass(TestRunner &Test); +void reduceGlobalValuesDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceGlobalVarInitializers.cpp b/llvm/tools/llvm-reduce/deltas/ReduceGlobalVarInitializers.cpp index 4c7125217f252..4569de706195e 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceGlobalVarInitializers.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceGlobalVarInitializers.cpp @@ -28,6 +28,6 @@ static void extractGVsFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceGlobalsInitializersDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractGVsFromModule, "Reducing GV Initializers"); +void llvm::reduceGlobalsInitializersDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractGVsFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceGlobalVarInitializers.h b/llvm/tools/llvm-reduce/deltas/ReduceGlobalVarInitializers.h index 318b29b6ca5e4..25b5be7ab145c 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceGlobalVarInitializers.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceGlobalVarInitializers.h @@ -19,7 +19,7 @@ #include "llvm/Transforms/Utils/Cloning.h" namespace llvm { -void reduceGlobalsInitializersDeltaPass(TestRunner &Test); +void reduceGlobalsInitializersDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceGlobalVars.cpp b/llvm/tools/llvm-reduce/deltas/ReduceGlobalVars.cpp index b448081ee1a27..87c2e7823f82b 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceGlobalVars.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceGlobalVars.cpp @@ -54,6 +54,6 @@ static void extractGVsFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceGlobalsDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractGVsFromModule, "Reducing GlobalVariables"); +void llvm::reduceGlobalsDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractGVsFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceGlobalVars.h b/llvm/tools/llvm-reduce/deltas/ReduceGlobalVars.h index 1198dceb45368..e62b4dd19bef4 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceGlobalVars.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceGlobalVars.h @@ -19,7 +19,7 @@ #include "llvm/Transforms/Utils/Cloning.h" namespace llvm { -void reduceGlobalsDeltaPass(TestRunner &Test); +void reduceGlobalsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceIRReferences.cpp b/llvm/tools/llvm-reduce/deltas/ReduceIRReferences.cpp index 4bb1eb7db1d09..43c4b6a785af6 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceIRReferences.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceIRReferences.cpp @@ -68,16 +68,14 @@ static void stripIRFromFunctions(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceIRInstructionReferencesDeltaPass(TestRunner &Test) { - runDeltaPass(Test, stripIRFromInstructions, - "Reducing IR references from instructions"); +void llvm::reduceIRInstructionReferencesDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, stripIRFromInstructions, PassMessage); } -void llvm::reduceIRBlockReferencesDeltaPass(TestRunner &Test) { - runDeltaPass(Test, stripIRFromBlocks, "Reducing IR references from blocks"); +void llvm::reduceIRBlockReferencesDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, stripIRFromBlocks, PassMessage); } -void llvm::reduceIRFunctionReferencesDeltaPass(TestRunner &Test) { - runDeltaPass(Test, stripIRFromFunctions, - "Reducing IR references from functions"); +void llvm::reduceIRFunctionReferencesDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, stripIRFromFunctions, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceIRReferences.h b/llvm/tools/llvm-reduce/deltas/ReduceIRReferences.h index 548559a0775b4..1b0a64a212975 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceIRReferences.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceIRReferences.h @@ -14,17 +14,19 @@ #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEIRREFERENCES_MIR_H #define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEIRREFERENCES_MIR_H +#include "llvm/ADT/StringRef.h" + namespace llvm { class TestRunner; /// Remove IR references from instructions (i.e. from memory operands) -void reduceIRInstructionReferencesDeltaPass(TestRunner &Test); +void reduceIRInstructionReferencesDeltaPass(TestRunner &Test, StringRef PassMessage); /// Remove IR BasicBlock references (the block names) -void reduceIRBlockReferencesDeltaPass(TestRunner &Test); +void reduceIRBlockReferencesDeltaPass(TestRunner &Test, StringRef PassMessage); /// Remove IR references from function level fields (e.g. frame object names) -void reduceIRFunctionReferencesDeltaPass(TestRunner &Test); +void reduceIRFunctionReferencesDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm diff --git a/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlags.cpp b/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlags.cpp index e157747004782..a9f08fc54135f 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlags.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlags.cpp @@ -84,6 +84,6 @@ static void reduceFlagsInModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceInstructionFlagsDeltaPass(TestRunner &Test) { - runDeltaPass(Test, reduceFlagsInModule, "Reducing Instruction Flags"); +void llvm::reduceInstructionFlagsDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, reduceFlagsInModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlags.h b/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlags.h index 1764c0199da87..e1a5d5c5d28a8 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlags.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlags.h @@ -12,7 +12,7 @@ #include "TestRunner.h" namespace llvm { -void reduceInstructionFlagsDeltaPass(TestRunner &Test); +void reduceInstructionFlagsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlagsMIR.cpp b/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlagsMIR.cpp index f2895b31947ec..9d4ff7c045877 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlagsMIR.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlagsMIR.cpp @@ -30,6 +30,6 @@ static void removeFlagsFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceInstructionFlagsMIRDeltaPass(TestRunner &Test) { - runDeltaPass(Test, removeFlagsFromModule, "Reducing Instruction Flags"); +void llvm::reduceInstructionFlagsMIRDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, removeFlagsFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlagsMIR.h b/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlagsMIR.h index a5a34d275e2f0..43e4471c3aaa7 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlagsMIR.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceInstructionFlagsMIR.h @@ -17,7 +17,7 @@ #include "Delta.h" namespace llvm { -void reduceInstructionFlagsMIRDeltaPass(TestRunner &Test); +void reduceInstructionFlagsMIRDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceInstructions.cpp b/llvm/tools/llvm-reduce/deltas/ReduceInstructions.cpp index 9917fed000b7a..8273dbc828d60 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceInstructions.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceInstructions.cpp @@ -63,6 +63,6 @@ static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) { I->eraseFromParent(); } -void llvm::reduceInstructionsDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractInstrFromModule, "Reducing Instructions"); +void llvm::reduceInstructionsDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractInstrFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceInstructions.h b/llvm/tools/llvm-reduce/deltas/ReduceInstructions.h index 8c13a02cb98f3..b7f8c21239ebc 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceInstructions.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceInstructions.h @@ -19,7 +19,7 @@ #include "llvm/Transforms/Utils/Cloning.h" namespace llvm { -void reduceInstructionsDeltaPass(TestRunner &Test); +void reduceInstructionsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.cpp b/llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.cpp index 40bc6b180fb88..a02f2a158f135 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.cpp @@ -158,6 +158,6 @@ static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceInstructionsMIRDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractInstrFromModule, "Reducing Instructions"); +void llvm::reduceInstructionsMIRDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractInstrFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.h b/llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.h index 70e0ac5fcf37f..1cb2c76b901cd 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.h @@ -14,10 +14,11 @@ #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINSTRUCTIONS_MIR_H #define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINSTRUCTIONS_MIR_H +#include "llvm/ADT/StringRef.h" namespace llvm { class TestRunner; -void reduceInstructionsMIRDeltaPass(TestRunner &Test); +void reduceInstructionsMIRDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceInvokes.cpp b/llvm/tools/llvm-reduce/deltas/ReduceInvokes.cpp index c6425a753df54..0dc57cf906080 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceInvokes.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceInvokes.cpp @@ -36,6 +36,6 @@ static void reduceInvokesInModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceInvokesDeltaPass(TestRunner &Test) { - runDeltaPass(Test, reduceInvokesInModule, "Reducing Invokes"); +void llvm::reduceInvokesDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, reduceInvokesInModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceInvokes.h b/llvm/tools/llvm-reduce/deltas/ReduceInvokes.h index 9607add166005..351a82fa4b888 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceInvokes.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceInvokes.h @@ -12,7 +12,7 @@ #include "TestRunner.h" namespace llvm { -void reduceInvokesDeltaPass(TestRunner &Test); +void reduceInvokesDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceMemoryOperations.cpp b/llvm/tools/llvm-reduce/deltas/ReduceMemoryOperations.cpp index 8e73ea076034c..ed11c177f39fc 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceMemoryOperations.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceMemoryOperations.cpp @@ -41,8 +41,8 @@ static void removeVolatileInModule(Oracle &O, ReducerWorkItem &WorkItem) { removeVolatileInFunction(O, F); } -void llvm::reduceVolatileInstructionsDeltaPass(TestRunner &Test) { - runDeltaPass(Test, removeVolatileInModule, "Reducing Volatile Instructions"); +void llvm::reduceVolatileInstructionsDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, removeVolatileInModule, PassMessage); } static void reduceAtomicSyncScopesInFunction(Oracle &O, Function &F) { @@ -72,9 +72,9 @@ static void reduceAtomicSyncScopesInModule(Oracle &O, reduceAtomicSyncScopesInFunction(O, F); } -void llvm::reduceAtomicSyncScopesDeltaPass(TestRunner &Test) { +void llvm::reduceAtomicSyncScopesDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass(Test, reduceAtomicSyncScopesInModule, - "Reducing Atomic Sync Scopes"); + PassMessage); } // TODO: Might be helpful to incrementally relax orders @@ -105,6 +105,6 @@ static void reduceAtomicOrderingInModule(Oracle &O, ReducerWorkItem &WorkItem) { reduceAtomicOrderingInFunction(O, F); } -void llvm::reduceAtomicOrderingDeltaPass(TestRunner &Test) { - runDeltaPass(Test, reduceAtomicOrderingInModule, "Reducing Atomic Ordering"); +void llvm::reduceAtomicOrderingDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, reduceAtomicOrderingInModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceMemoryOperations.h b/llvm/tools/llvm-reduce/deltas/ReduceMemoryOperations.h index ca6a770dff081..406d271bee52f 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceMemoryOperations.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceMemoryOperations.h @@ -12,9 +12,9 @@ #include "TestRunner.h" namespace llvm { -void reduceVolatileInstructionsDeltaPass(TestRunner &Test); -void reduceAtomicSyncScopesDeltaPass(TestRunner &Test); -void reduceAtomicOrderingDeltaPass(TestRunner &Test); +void reduceVolatileInstructionsDeltaPass(TestRunner &Test, StringRef PassMessage); +void reduceAtomicSyncScopesDeltaPass(TestRunner &Test, StringRef PassMessage); +void reduceAtomicOrderingDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceMetadata.cpp b/llvm/tools/llvm-reduce/deltas/ReduceMetadata.cpp index 316c74876025a..3d5dca19cfc5d 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceMetadata.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceMetadata.cpp @@ -123,10 +123,10 @@ static void extractMetadataFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceMetadataDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractMetadataFromModule, "Reducing Metadata"); +void llvm::reduceMetadataDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractMetadataFromModule, PassMessage); } -void llvm::reduceNamedMetadataDeltaPass(TestRunner &Test) { - runDeltaPass(Test, reduceNamedMetadataOperands, "Reducing Named Metadata"); +void llvm::reduceNamedMetadataDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, reduceNamedMetadataOperands, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceMetadata.h b/llvm/tools/llvm-reduce/deltas/ReduceMetadata.h index f3af31a2759bc..60bdead193292 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceMetadata.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceMetadata.h @@ -17,8 +17,8 @@ #include "TestRunner.h" namespace llvm { -void reduceMetadataDeltaPass(TestRunner &Test); -void reduceNamedMetadataDeltaPass(TestRunner &Test); +void reduceMetadataDeltaPass(TestRunner &Test, StringRef PassMessage); +void reduceNamedMetadataDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceModuleData.cpp b/llvm/tools/llvm-reduce/deltas/ReduceModuleData.cpp index 17930abe6dbfe..1d0f92e7e866b 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceModuleData.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceModuleData.cpp @@ -26,6 +26,6 @@ static void clearModuleData(Oracle &O, ReducerWorkItem &WorkItem) { Program.setModuleInlineAsm(""); } -void llvm::reduceModuleDataDeltaPass(TestRunner &Test) { - runDeltaPass(Test, clearModuleData, "Reducing Module Data"); +void llvm::reduceModuleDataDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, clearModuleData, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceModuleData.h b/llvm/tools/llvm-reduce/deltas/ReduceModuleData.h index 960fe8c6d3a6d..d5b1470d3cabc 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceModuleData.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceModuleData.h @@ -12,7 +12,7 @@ #include "Delta.h" namespace llvm { -void reduceModuleDataDeltaPass(TestRunner &Test); +void reduceModuleDataDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOpcodes.cpp b/llvm/tools/llvm-reduce/deltas/ReduceOpcodes.cpp index 9fb4fd61c74e7..97c4b5352fc91 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceOpcodes.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceOpcodes.cpp @@ -262,6 +262,6 @@ static void replaceOpcodesInModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceOpcodesDeltaPass(TestRunner &Test) { - runDeltaPass(Test, replaceOpcodesInModule, "Reducing Opcodes"); +void llvm::reduceOpcodesDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, replaceOpcodesInModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOpcodes.h b/llvm/tools/llvm-reduce/deltas/ReduceOpcodes.h index 79edc7f32facf..0d62d7ed15838 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceOpcodes.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceOpcodes.h @@ -12,7 +12,7 @@ #include "TestRunner.h" namespace llvm { -void reduceOpcodesDeltaPass(TestRunner &Test); +void reduceOpcodesDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp b/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp index d2274877f126b..1887ec4b1e5f3 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp @@ -105,7 +105,7 @@ static void extractOperandBundesFromModule(Oracle &O, maybeRewriteCallWithDifferentBundles(I.first, I.second); } -void llvm::reduceOperandBundesDeltaPass(TestRunner &Test) { +void llvm::reduceOperandBundesDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass(Test, extractOperandBundesFromModule, - "Reducing Operand Bundles"); + PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.h b/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.h index 390b029242536..fd38b824b6c7e 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.h @@ -14,9 +14,11 @@ #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDBUNDLES_H #define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDBUNDLES_H +#include "llvm/ADT/StringRef.h" + namespace llvm { class TestRunner; -void reduceOperandBundesDeltaPass(TestRunner &Test); +void reduceOperandBundesDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperands.cpp b/llvm/tools/llvm-reduce/deltas/ReduceOperands.cpp index 5babdc7d0a940..e3e72b18239fc 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceOperands.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceOperands.cpp @@ -83,7 +83,7 @@ static bool switchCaseExists(Use &Op, ConstantInt *CI) { return SI->findCaseValue(CI) != SI->case_default(); } -void llvm::reduceOperandsOneDeltaPass(TestRunner &Test) { +void llvm::reduceOperandsOneDeltaPass(TestRunner &Test, StringRef PassMessage) { auto ReduceValue = [](Use &Op) -> Value * { if (!shouldReduceOperand(Op)) return nullptr; @@ -123,10 +123,10 @@ void llvm::reduceOperandsOneDeltaPass(TestRunner &Test) { [ReduceValue](Oracle &O, ReducerWorkItem &WorkItem) { extractOperandsFromModule(O, WorkItem, ReduceValue); }, - "Reducing Operands to one"); + PassMessage); } -void llvm::reduceOperandsZeroDeltaPass(TestRunner &Test) { +void llvm::reduceOperandsZeroDeltaPass(TestRunner &Test, StringRef PassMessage) { auto ReduceValue = [](Use &Op) -> Value * { if (!shouldReduceOperand(Op)) return nullptr; @@ -153,10 +153,10 @@ void llvm::reduceOperandsZeroDeltaPass(TestRunner &Test) { [ReduceValue](Oracle &O, ReducerWorkItem &Program) { extractOperandsFromModule(O, Program, ReduceValue); }, - "Reducing Operands to zero"); + PassMessage); } -void llvm::reduceOperandsNaNDeltaPass(TestRunner &Test) { +void llvm::reduceOperandsNaNDeltaPass(TestRunner &Test, StringRef PassMessage) { auto ReduceValue = [](Use &Op) -> Value * { Type *Ty = Op->getType(); if (!Ty->isFPOrFPVectorTy()) @@ -181,5 +181,5 @@ void llvm::reduceOperandsNaNDeltaPass(TestRunner &Test) { [ReduceValue](Oracle &O, ReducerWorkItem &Program) { extractOperandsFromModule(O, Program, ReduceValue); }, - "Reducing Operands to NaN"); + PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperands.h b/llvm/tools/llvm-reduce/deltas/ReduceOperands.h index b4a18998f8e20..5a29e0e868c3d 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceOperands.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceOperands.h @@ -12,9 +12,9 @@ #include "Delta.h" namespace llvm { -void reduceOperandsOneDeltaPass(TestRunner &Test); -void reduceOperandsZeroDeltaPass(TestRunner &Test); -void reduceOperandsNaNDeltaPass(TestRunner &Test); +void reduceOperandsOneDeltaPass(TestRunner &Test, StringRef PassMessage); +void reduceOperandsZeroDeltaPass(TestRunner &Test, StringRef PassMessage); +void reduceOperandsNaNDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.cpp b/llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.cpp index 1763feedcdbc3..fe8b240bed559 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.cpp @@ -230,7 +230,7 @@ static void extractOperandsFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceOperandsSkipDeltaPass(TestRunner &Test) { +void llvm::reduceOperandsSkipDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass(Test, extractOperandsFromModule, - "Reducing operands by skipping over instructions"); + PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.h b/llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.h index 79897011639a2..2b0969cf37502 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.h @@ -12,7 +12,7 @@ #include "Delta.h" namespace llvm { -void reduceOperandsSkipDeltaPass(TestRunner &Test); +void reduceOperandsSkipDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif /* LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDSSKIP_H */ diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.cpp b/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.cpp index 66d4bd3048171..d90913db42a65 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.cpp @@ -214,7 +214,7 @@ static void reduceOperandsToArgs(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceOperandsToArgsDeltaPass(TestRunner &Test) { +void llvm::reduceOperandsToArgsDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass(Test, reduceOperandsToArgs, - "Converting operands to function arguments"); + PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.h b/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.h index 23043dd60b6ff..b45e5b6218716 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.h @@ -12,7 +12,7 @@ #include "Delta.h" namespace llvm { -void reduceOperandsToArgsDeltaPass(TestRunner &Test); +void reduceOperandsToArgsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif /* LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDSTOARGS_H */ diff --git a/llvm/tools/llvm-reduce/deltas/ReduceRegisterDefs.cpp b/llvm/tools/llvm-reduce/deltas/ReduceRegisterDefs.cpp index 97259649ab858..609bb531322d2 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceRegisterDefs.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceRegisterDefs.cpp @@ -117,6 +117,6 @@ static void removeDefsFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceRegisterDefsMIRDeltaPass(TestRunner &Test) { - runDeltaPass(Test, removeDefsFromModule, "Reducing register defs"); +void llvm::reduceRegisterDefsMIRDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, removeDefsFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceRegisterDefs.h b/llvm/tools/llvm-reduce/deltas/ReduceRegisterDefs.h index 031d24125bac8..c5318ca2d24a4 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceRegisterDefs.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceRegisterDefs.h @@ -17,7 +17,7 @@ #include "Delta.h" namespace llvm { -void reduceRegisterDefsMIRDeltaPass(TestRunner &Test); +void reduceRegisterDefsMIRDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceRegisterMasks.cpp b/llvm/tools/llvm-reduce/deltas/ReduceRegisterMasks.cpp index 953e0e51afd82..f077c42553454 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceRegisterMasks.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceRegisterMasks.cpp @@ -67,6 +67,6 @@ static void reduceMasksInModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceRegisterMasksMIRDeltaPass(TestRunner &Test) { - runDeltaPass(Test, reduceMasksInModule, "Reducing register masks"); +void llvm::reduceRegisterMasksMIRDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, reduceMasksInModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceRegisterMasks.h b/llvm/tools/llvm-reduce/deltas/ReduceRegisterMasks.h index b8bb109e5c996..aca5cd712b6be 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceRegisterMasks.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceRegisterMasks.h @@ -12,7 +12,7 @@ #include "Delta.h" namespace llvm { -void reduceRegisterMasksMIRDeltaPass(TestRunner &Test); +void reduceRegisterMasksMIRDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceRegisterUses.cpp b/llvm/tools/llvm-reduce/deltas/ReduceRegisterUses.cpp index a608935736d1a..572bc61ae6514 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceRegisterUses.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceRegisterUses.cpp @@ -62,6 +62,6 @@ static void removeUsesFromModule(Oracle &O, ReducerWorkItem &WorkItem) { } } -void llvm::reduceRegisterUsesMIRDeltaPass(TestRunner &Test) { - runDeltaPass(Test, removeUsesFromModule, "Reducing register uses"); +void llvm::reduceRegisterUsesMIRDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, removeUsesFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceRegisterUses.h b/llvm/tools/llvm-reduce/deltas/ReduceRegisterUses.h index 91ecba488f37c..4398d77518066 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceRegisterUses.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceRegisterUses.h @@ -17,7 +17,7 @@ #include "Delta.h" namespace llvm { -void reduceRegisterUsesMIRDeltaPass(TestRunner &Test); +void reduceRegisterUsesMIRDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.cpp b/llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.cpp index aadd038033d5c..a4d173bff1351 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.cpp @@ -41,7 +41,7 @@ static void extractSpecialGlobalsFromModule(Oracle &O, } } -void llvm::reduceSpecialGlobalsDeltaPass(TestRunner &Test) { +void llvm::reduceSpecialGlobalsDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass(Test, extractSpecialGlobalsFromModule, - "Reducing Special Globals"); + PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.h b/llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.h index d17790529e06b..bae815a85a570 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.h @@ -20,7 +20,7 @@ #include "Delta.h" namespace llvm { -void reduceSpecialGlobalsDeltaPass(TestRunner &Test); +void reduceSpecialGlobalsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceUsingSimplifyCFG.cpp b/llvm/tools/llvm-reduce/deltas/ReduceUsingSimplifyCFG.cpp index c49fcb9855d41..af1c64150cab2 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceUsingSimplifyCFG.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceUsingSimplifyCFG.cpp @@ -31,8 +31,8 @@ static void reduceUsingSimplifyCFG(Oracle &O, ReducerWorkItem &WorkItem) { simplifyCFG(BB, TTI); } -void llvm::reduceUsingSimplifyCFGDeltaPass(TestRunner &Test) { - runDeltaPass(Test, reduceUsingSimplifyCFG, "Reducing using SimplifyCFG"); +void llvm::reduceUsingSimplifyCFGDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, reduceUsingSimplifyCFG, PassMessage); } static void reduceConditionals(Oracle &O, ReducerWorkItem &WorkItem, bool Direction) { @@ -59,20 +59,20 @@ static void reduceConditionals(Oracle &O, ReducerWorkItem &WorkItem, simplifyCFG(BB, TTI); } -void llvm::reduceConditionalsTrueDeltaPass(TestRunner &Test) { +void llvm::reduceConditionalsTrueDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass( Test, [](Oracle &O, ReducerWorkItem &WorkItem) { reduceConditionals(O, WorkItem, true); }, - "Reducing conditional branches to true"); + PassMessage); } -void llvm::reduceConditionalsFalseDeltaPass(TestRunner &Test) { +void llvm::reduceConditionalsFalseDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass( Test, [](Oracle &O, ReducerWorkItem &WorkItem) { reduceConditionals(O, WorkItem, false); }, - "Reducing conditional branches to false"); + PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceUsingSimplifyCFG.h b/llvm/tools/llvm-reduce/deltas/ReduceUsingSimplifyCFG.h index 01a14602909b3..3be5667eb6a73 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceUsingSimplifyCFG.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceUsingSimplifyCFG.h @@ -17,9 +17,9 @@ #include "Delta.h" namespace llvm { -void reduceUsingSimplifyCFGDeltaPass(TestRunner &Test); -void reduceConditionalsTrueDeltaPass(TestRunner &Test); -void reduceConditionalsFalseDeltaPass(TestRunner &Test); +void reduceUsingSimplifyCFGDeltaPass(TestRunner &Test, StringRef PassMessage); +void reduceConditionalsTrueDeltaPass(TestRunner &Test, StringRef PassMessage); +void reduceConditionalsFalseDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/ReduceVirtualRegisters.cpp b/llvm/tools/llvm-reduce/deltas/ReduceVirtualRegisters.cpp index 3ec9555c0f2f5..e183fb5f68a69 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceVirtualRegisters.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceVirtualRegisters.cpp @@ -41,7 +41,7 @@ static void dropRegisterHintsFromFunctions(Oracle &O, } } -void llvm::reduceVirtualRegisterHintsDeltaPass(TestRunner &Test) { +void llvm::reduceVirtualRegisterHintsDeltaPass(TestRunner &Test, StringRef PassMessage) { runDeltaPass(Test, dropRegisterHintsFromFunctions, - "Reducing virtual register hints from functions"); + PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/ReduceVirtualRegisters.h b/llvm/tools/llvm-reduce/deltas/ReduceVirtualRegisters.h index 405ba31703e54..fbf4f923a0e5e 100644 --- a/llvm/tools/llvm-reduce/deltas/ReduceVirtualRegisters.h +++ b/llvm/tools/llvm-reduce/deltas/ReduceVirtualRegisters.h @@ -14,11 +14,13 @@ #ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEVIRTUALREGISTERS_H #define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEVIRTUALREGISTERS_H +#include "llvm/ADT/StringRef.h" + namespace llvm { class TestRunner; /// Remove register allocation hints from virtual registes. -void reduceVirtualRegisterHintsDeltaPass(TestRunner &Test); +void reduceVirtualRegisterHintsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm diff --git a/llvm/tools/llvm-reduce/deltas/RunIRPasses.cpp b/llvm/tools/llvm-reduce/deltas/RunIRPasses.cpp index e3af05616fe04..9ef1f72d75cca 100644 --- a/llvm/tools/llvm-reduce/deltas/RunIRPasses.cpp +++ b/llvm/tools/llvm-reduce/deltas/RunIRPasses.cpp @@ -50,6 +50,6 @@ static void runPasses(Oracle &O, ReducerWorkItem &WorkItem) { MPM.run(Program, MAM); } -void llvm::runIRPassesDeltaPass(TestRunner &Test) { - runDeltaPass(Test, runPasses, "Running passes"); +void llvm::runIRPassesDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, runPasses, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/RunIRPasses.h b/llvm/tools/llvm-reduce/deltas/RunIRPasses.h index f1d4140d5b57f..9c010ecf4ae6f 100644 --- a/llvm/tools/llvm-reduce/deltas/RunIRPasses.h +++ b/llvm/tools/llvm-reduce/deltas/RunIRPasses.h @@ -12,7 +12,7 @@ #include "Delta.h" namespace llvm { -void runIRPassesDeltaPass(TestRunner &Test); +void runIRPassesDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/SimplifyInstructions.cpp b/llvm/tools/llvm-reduce/deltas/SimplifyInstructions.cpp index fc21593c5415c..d151e40afc7ea 100644 --- a/llvm/tools/llvm-reduce/deltas/SimplifyInstructions.cpp +++ b/llvm/tools/llvm-reduce/deltas/SimplifyInstructions.cpp @@ -45,6 +45,6 @@ static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) { I->eraseFromParent(); } -void llvm::simplifyInstructionsDeltaPass(TestRunner &Test) { - runDeltaPass(Test, extractInstrFromModule, "Simplifying Instructions"); +void llvm::simplifyInstructionsDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, extractInstrFromModule, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/SimplifyInstructions.h b/llvm/tools/llvm-reduce/deltas/SimplifyInstructions.h index 215cffcd4d12e..49256735998e7 100644 --- a/llvm/tools/llvm-reduce/deltas/SimplifyInstructions.h +++ b/llvm/tools/llvm-reduce/deltas/SimplifyInstructions.h @@ -12,7 +12,7 @@ #include "Delta.h" namespace llvm { -void simplifyInstructionsDeltaPass(TestRunner &Test); +void simplifyInstructionsDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif diff --git a/llvm/tools/llvm-reduce/deltas/StripDebugInfo.cpp b/llvm/tools/llvm-reduce/deltas/StripDebugInfo.cpp index c9e1261c366a7..f7c0ee789cef5 100644 --- a/llvm/tools/llvm-reduce/deltas/StripDebugInfo.cpp +++ b/llvm/tools/llvm-reduce/deltas/StripDebugInfo.cpp @@ -24,6 +24,6 @@ static void stripDebugInfoImpl(Oracle &O, ReducerWorkItem &WorkItem) { StripDebugInfo(Program); } -void llvm::stripDebugInfoDeltaPass(TestRunner &Test) { - runDeltaPass(Test, stripDebugInfoImpl, "Stripping Debug Info"); +void llvm::stripDebugInfoDeltaPass(TestRunner &Test, StringRef PassMessage) { + runDeltaPass(Test, stripDebugInfoImpl, PassMessage); } diff --git a/llvm/tools/llvm-reduce/deltas/StripDebugInfo.h b/llvm/tools/llvm-reduce/deltas/StripDebugInfo.h index 56be459546e94..a2be1182f4279 100644 --- a/llvm/tools/llvm-reduce/deltas/StripDebugInfo.h +++ b/llvm/tools/llvm-reduce/deltas/StripDebugInfo.h @@ -12,7 +12,7 @@ #include "Delta.h" namespace llvm { -void stripDebugInfoDeltaPass(TestRunner &Test); +void stripDebugInfoDeltaPass(TestRunner &Test, StringRef PassMessage); } // namespace llvm #endif