caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[llvm-reduce]: print short form, actionable names in the log (#133561)

Browse Source 
Closes #132696

before the patch like this:
```
----------------------------
*** Reducing GlobalObjects...
----------------------------
*** Reducing GV Initializers...
----------------------------
*** Reducing GlobalVariables...
----------------------------
```
after the patch like this:
```
----------------------------
*** Reducing GlobalObjects (global-objects)...
----------------------------
*** Reducing GV Initializers (global-initializers)...
----------------------------
*** Reducing GlobalVariables (global-variables)...
----------------------------
```
This commit is contained in:
YLChenZ
2025-03-30 13:37:48 +08:00
committed by GitHub
parent 9747bb182f
commit fea6b38805
77 changed files with 302 additions and 458 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
llvm/tools/llvm-reduce/DeltaManager.cpp
View File

@@ -12,9 +12,8 @@
//===----------------------------------------------------------------------===//
#include "DeltaManager.h"
#include "ReducerWorkItem.h"
#include "DeltaPass.h"
#include "TestRunner.h"
#include "deltas/Delta.h"
#include "deltas/ReduceAliases.h"
#include "deltas/ReduceArguments.h"
#include "deltas/ReduceAttributes.h"
@@ -71,91 +70,56 @@ static cl::list<std::string>
"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)
// 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
};
#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)
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)) {
runDeltaPass(Tester, Pass);
}
}
} else {
DELTA_PASSES;
for (const DeltaPass &Pass : IR_Passes) {
if (!SkipPass.count(Pass.Name)) {
runDeltaPass(Tester, Pass);
}
}
}
#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) {
runDeltaPass(Tester, Pass);
return;
}
}
} else {
DELTA_PASSES;
for (const DeltaPass &Pass : IR_Passes) {
if (PassName == Pass.Name) {
runDeltaPass(Tester, Pass);
return;
}
}
}
#undef DELTA_PASS
// We should have errored on unrecognized passes before trying to run
// anything.
@@ -164,24 +128,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

24
llvm/tools/llvm-reduce/DeltaPass.h Normal file
View File

@@ -0,0 +1,24 @@
//===--- 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 "ReducerWorkItem.h"
#include "deltas/Delta.h"
#include "llvm/ADT/StringRef.h"
namespace llvm {
struct DeltaPass {
StringRef Name; // e.g., "strip-debug-info"
void (*Func)(Oracle &, ReducerWorkItem &); // e.g., stripDebugInfoDeltaPass
StringRef Desc; // e.g., "Stripping Debug Info"
};
} // namespace llvm
#endif

68
llvm/tools/llvm-reduce/DeltaPasses.def Normal file
View File

@@ -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")

24
llvm/tools/llvm-reduce/deltas/Delta.cpp
View File

@@ -13,6 +13,7 @@
//===----------------------------------------------------------------------===//
#include "Delta.h"
#include "DeltaPass.h"
#include "ReducerWorkItem.h"
#include "TestRunner.h"
#include "Utils.h"
@@ -180,11 +181,10 @@ using SharedTaskQueue = std::deque<std::shared_future<SmallString<0>>>;
/// 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,
StringRef Message) {
void llvm::runDeltaPass(TestRunner &Test, const DeltaPass &Pass) {
assert(!Test.getProgram().verify(&errs()) &&
"input module is broken before making changes");
errs() << "*** " << Message << "...\n";
errs() << "*** " << Pass.Desc << " (" << Pass.Name << ")...\n";
int Targets;
{
@@ -193,7 +193,7 @@ void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
// made.
std::vector<Chunk> AllChunks = {{0, INT_MAX}};
Oracle Counter(AllChunks);
ExtractChunksFromModule(Counter, Test.getProgram());
Pass.Func(Counter, Test.getProgram());
Targets = Counter.count();
assert(!Test.getProgram().verify(&errs()) &&
@@ -215,7 +215,7 @@ void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
Oracle NoChunksCounter(NoChunks);
std::unique_ptr<ReducerWorkItem> Clone =
Test.getProgram().clone(Test.getTargetMachine());
ExtractChunksFromModule(NoChunksCounter, *Clone);
Pass.Func(NoChunksCounter, *Clone);
assert(Targets == NoChunksCounter.count() &&
"number of chunks changes when reducing");
#endif
@@ -281,9 +281,8 @@ void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
Chunk ChunkToCheck = *(I + J);
TaskQueue.emplace_back(ChunkThreadPool.async(
ProcessChunkFromSerializedBitcode, ChunkToCheck, std::ref(Test),
ExtractChunksFromModule, UninterestingChunks,
ChunksStillConsideredInteresting, OriginalBC,
std::ref(AnyReduced)));
Pass.Func, UninterestingChunks, ChunksStillConsideredInteresting,
OriginalBC, std::ref(AnyReduced)));
}
// Start processing results of the queued tasks. We wait for the first
@@ -305,7 +304,7 @@ void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
Chunk ChunkToCheck = *(I + NumScheduledTasks);
TaskQueue.emplace_back(ChunkThreadPool.async(
ProcessChunkFromSerializedBitcode, ChunkToCheck,
std::ref(Test), ExtractChunksFromModule, UninterestingChunks,
std::ref(Test), Pass.Func, UninterestingChunks,
ChunksStillConsideredInteresting, OriginalBC,
std::ref(AnyReduced)));
}
@@ -330,10 +329,9 @@ void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
// Forward I to the last chunk processed in parallel.
I += NumChunksProcessed - 1;
} else {
Result =
CheckChunk(*I, Test.getProgram().clone(Test.getTargetMachine()),
Test, ExtractChunksFromModule, UninterestingChunks,
ChunksStillConsideredInteresting);
Result = CheckChunk(
*I, Test.getProgram().clone(Test.getTargetMachine()), Test,
Pass.Func, UninterestingChunks, ChunksStillConsideredInteresting);
}
if (!Result)

4
llvm/tools/llvm-reduce/deltas/Delta.h
View File

@@ -24,6 +24,7 @@
namespace llvm {
class TestRunner;
struct DeltaPass;
struct Chunk {
int Begin;
@@ -134,8 +135,7 @@ 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,
StringRef Message);
void runDeltaPass(TestRunner &Test, const DeltaPass &Pass);
} // namespace llvm
#endif

13
llvm/tools/llvm-reduce/deltas/ReduceAliases.cpp
View File

@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceAliases.h"
#include "Delta.h"
#include "Utils.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/GlobalValue.h"
@@ -22,7 +21,7 @@ using namespace llvm;
/// Removes all aliases aren't inside any of the
/// desired Chunks.
static void extractAliasesFromModule(Oracle &O, ReducerWorkItem &Program) {
void llvm::reduceAliasesDeltaPass(Oracle &O, ReducerWorkItem &Program) {
for (auto &GA : make_early_inc_range(Program.getModule().aliases())) {
if (!O.shouldKeep()) {
GA.replaceAllUsesWith(GA.getAliasee());
@@ -31,7 +30,7 @@ static void extractAliasesFromModule(Oracle &O, ReducerWorkItem &Program) {
}
}
static void extractIFuncsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceIFuncsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Mod = WorkItem.getModule();
std::vector<GlobalIFunc *> IFuncs;
@@ -43,11 +42,3 @@ static void extractIFuncsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
if (!IFuncs.empty())
lowerGlobalIFuncUsersAsGlobalCtor(Mod, IFuncs);
}
void llvm::reduceAliasesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractAliasesFromModule, "Reducing Aliases");
}
void llvm::reduceIFuncsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractIFuncsFromModule, "Reducing Ifuncs");
}

4
llvm/tools/llvm-reduce/deltas/ReduceAliases.h
View File

@@ -17,8 +17,8 @@
#include "Delta.h"
namespace llvm {
void reduceAliasesDeltaPass(TestRunner &Test);
void reduceIFuncsDeltaPass(TestRunner &Test);
void reduceAliasesDeltaPass(Oracle &O, ReducerWorkItem &Program);
void reduceIFuncsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

7
llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp
View File

@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceArguments.h"
#include "Delta.h"
#include "Utils.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/IR/Constants.h"
@@ -112,7 +111,7 @@ static bool allFuncUsersRewritable(const Function &F) {
/// Removes out-of-chunk arguments from functions, and modifies their calls
/// accordingly. It also removes allocations of out-of-chunk arguments.
static void extractArgumentsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceArgumentsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
std::vector<Argument *> InitArgsToKeep;
std::vector<Function *> Funcs;
@@ -177,7 +176,3 @@ static void extractArgumentsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
F->eraseFromParent();
}
}
void llvm::reduceArgumentsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractArgumentsFromModule, "Reducing Arguments");
}

2
llvm/tools/llvm-reduce/deltas/ReduceArguments.h
View File

@@ -20,7 +20,7 @@
#include "llvm/Transforms/Utils/Cloning.h"
namespace llvm {
void reduceArgumentsDeltaPass(TestRunner &Test);
void reduceArgumentsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

7
llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp
View File

@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceAttributes.h"
#include "Delta.h"
#include "TestRunner.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
@@ -166,11 +165,7 @@ public:
} // namespace
/// Removes out-of-chunk attributes from module.
static void extractAttributesFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceAttributesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
AttributeRemapper R(O, WorkItem.getModule());
R.visit(WorkItem.getModule());
}
void llvm::reduceAttributesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractAttributesFromModule, "Reducing Attributes");
}

5
llvm/tools/llvm-reduce/deltas/ReduceAttributes.h
View File

@@ -14,9 +14,10 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEATTRIBUTES_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEATTRIBUTES_H
#include "Delta.h"
namespace llvm {
class TestRunner;
void reduceAttributesDeltaPass(TestRunner &Test);
void reduceAttributesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

17
llvm/tools/llvm-reduce/deltas/ReduceBasicBlocks.cpp
View File

@@ -23,8 +23,8 @@
#include "llvm/Support/Casting.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/Utils/Local.h"
#include <vector>
#define DEBUG_TYPE "llvm-reduce"
@@ -141,7 +141,7 @@ removeUninterestingBBsFromSwitch(SwitchInst &SwInst,
/// Removes out-of-chunk arguments from functions, and modifies their calls
/// accordingly. It also removes allocations of out-of-chunk arguments.
static void extractBasicBlocksFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceBasicBlocksDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
DenseSet<BasicBlock *> BBsToDelete;
df_iterator_default_set<BasicBlock *> Reachable;
@@ -188,12 +188,8 @@ static void extractBasicBlocksFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
}
}
void llvm::reduceBasicBlocksDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractBasicBlocksFromModule, "Reducing Basic Blocks");
}
static void removeUnreachableBasicBlocksFromModule(Oracle &O,
ReducerWorkItem &WorkItem) {
void llvm::reduceUnreachableBasicBlocksDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
std::vector<BasicBlock *> DeadBlocks;
df_iterator_default_set<BasicBlock *> Reachable;
@@ -219,8 +215,3 @@ static void removeUnreachableBasicBlocksFromModule(Oracle &O,
Reachable.clear();
}
}
void llvm::reduceUnreachableBasicBlocksDeltaPass(TestRunner &Test) {
runDeltaPass(Test, removeUnreachableBasicBlocksFromModule,
"Removing Unreachable Basic Blocks");
}

7
llvm/tools/llvm-reduce/deltas/ReduceBasicBlocks.h
View File

@@ -14,12 +14,11 @@
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEBASICBLOCKS_H
#include "Delta.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/Cloning.h"
namespace llvm {
void reduceBasicBlocksDeltaPass(TestRunner &Test);
void reduceUnreachableBasicBlocksDeltaPass(TestRunner &Test);
void reduceBasicBlocksDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
void reduceUnreachableBasicBlocksDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

7
llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.cpp
View File

@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceDIMetadata.h"
#include "Delta.h"
#include "llvm/ADT/Sequence.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallVector.h"
@@ -76,7 +75,7 @@ void identifyUninterestingMDNodes(Oracle &O, MDNodeList &MDs) {
}
}
static void extractDIMetadataFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceDIMetadataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
MDNodeList MDs;
@@ -94,7 +93,3 @@ static void extractDIMetadataFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
}
identifyUninterestingMDNodes(O, MDs);
}
void llvm::reduceDIMetadataDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractDIMetadataFromModule, "Reducing DIMetadata");
}

4
llvm/tools/llvm-reduce/deltas/ReduceDIMetadata.h
View File

@@ -14,10 +14,10 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEDIMETADATA_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEDIMETADATA_H
#include "TestRunner.h"
#include "Delta.h"
namespace llvm {
void reduceDIMetadataDeltaPass(TestRunner &Test);
void reduceDIMetadataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

8
llvm/tools/llvm-reduce/deltas/ReduceDbgRecords.cpp
View File

@@ -20,10 +20,12 @@
#include "ReduceDbgRecords.h"
#include "Utils.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/DebugProgramInstruction.h"
using namespace llvm;
static void extractDbgRecordsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceDbgRecordDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &M = WorkItem.getModule();
for (auto &F : M)
@@ -33,7 +35,3 @@ static void extractDbgRecordsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
if (!O.shouldKeep())
DR.eraseFromParent();
}
void llvm::reduceDbgRecordDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractDbgRecordsFromModule, "Reducing DbgRecords");
}

4
llvm/tools/llvm-reduce/deltas/ReduceDbgRecords.h
View File

@@ -15,11 +15,9 @@
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEDBGRECORDS_H
#include "Delta.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/DebugProgramInstruction.h"
namespace llvm {
void reduceDbgRecordDeltaPass(TestRunner &Test);
void reduceDbgRecordDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

10
llvm/tools/llvm-reduce/deltas/ReduceDistinctMetadata.cpp
View File

@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceDistinctMetadata.h"
#include "Delta.h"
#include "llvm/ADT/Sequence.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallVector.h"
@@ -118,8 +117,8 @@ static void cleanUpTemporaries(NamedMDNode &NamedNode, MDTuple *TemporaryTuple,
}
}
static void extractDistinctMetadataFromModule(Oracle &O,
ReducerWorkItem &WorkItem) {
void llvm::reduceDistinctMetadataDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
MDTuple *TemporaryTuple =
MDTuple::getDistinct(Program.getContext(), SmallVector<Metadata *, 1>{});
@@ -135,8 +134,3 @@ static void extractDistinctMetadataFromModule(Oracle &O,
for (NamedMDNode &NamedNode : Program.named_metadata())
cleanUpTemporaries(NamedNode, TemporaryTuple, Program);
}
void llvm::reduceDistinctMetadataDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractDistinctMetadataFromModule,
"Reducing Distinct Metadata");
}

4
llvm/tools/llvm-reduce/deltas/ReduceDistinctMetadata.h
View File

@@ -14,10 +14,10 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEDISTINCTMETADATA_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEDISTINCTMETADATA_H
#include "TestRunner.h"
#include "Delta.h"
namespace llvm {
void reduceDistinctMetadataDeltaPass(TestRunner &Test);
void reduceDistinctMetadataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

15
llvm/tools/llvm-reduce/deltas/ReduceFunctionBodies.cpp
View File

@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceFunctionBodies.h"
#include "Delta.h"
#include "Utils.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/Instructions.h"
@@ -21,8 +20,7 @@ using namespace llvm;
/// Removes all the bodies of defined functions that aren't inside any of the
/// desired Chunks.
static void extractFunctionBodiesFromModule(Oracle &O,
ReducerWorkItem &WorkItem) {
void llvm::reduceFunctionBodiesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
// Delete out-of-chunk function bodies
for (auto &F : WorkItem.getModule()) {
if (!F.isDeclaration() && !hasAliasUse(F) && !O.shouldKeep()) {
@@ -32,12 +30,7 @@ static void extractFunctionBodiesFromModule(Oracle &O,
}
}
void llvm::reduceFunctionBodiesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractFunctionBodiesFromModule,
"Reducing Function Bodies");
}
static void reduceFunctionData(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceFunctionDataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
for (Function &F : WorkItem.getModule()) {
if (F.hasPersonalityFn()) {
if (none_of(F,
@@ -56,7 +49,3 @@ static void reduceFunctionData(Oracle &O, ReducerWorkItem &WorkItem) {
F.setPrologueData(nullptr);
}
}
void llvm::reduceFunctionDataDeltaPass(TestRunner &Test) {
runDeltaPass(Test, reduceFunctionData, "Reducing Function Data");
}

4
llvm/tools/llvm-reduce/deltas/ReduceFunctionBodies.h
View File

@@ -17,8 +17,8 @@
#include "Delta.h"
namespace llvm {
void reduceFunctionBodiesDeltaPass(TestRunner &Test);
void reduceFunctionDataDeltaPass(TestRunner &Test);
void reduceFunctionBodiesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
void reduceFunctionDataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

8
llvm/tools/llvm-reduce/deltas/ReduceFunctions.cpp
View File

@@ -13,9 +13,9 @@
//===----------------------------------------------------------------------===//
#include "ReduceFunctions.h"
#include "Delta.h"
#include "Utils.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/Utils/ModuleUtils.h"
#include <iterator>
@@ -23,7 +23,7 @@ using namespace llvm;
/// Removes all the Defined Functions
/// that aren't inside any of the desired Chunks.
static void extractFunctionsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceFunctionsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
// Record all out-of-chunk functions.
@@ -54,7 +54,3 @@ static void extractFunctionsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
cast<Function>(F)->eraseFromParent();
}
}
void llvm::reduceFunctionsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractFunctionsFromModule, "Reducing Functions");
}

3
llvm/tools/llvm-reduce/deltas/ReduceFunctions.h
View File

@@ -15,10 +15,9 @@
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEFUNCTIONS_H
#include "Delta.h"
#include "llvm/Transforms/Utils/Cloning.h"
namespace llvm {
void reduceFunctionsDeltaPass(TestRunner &Test);
void reduceFunctionsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

6
llvm/tools/llvm-reduce/deltas/ReduceGlobalObjects.cpp
View File

@@ -19,7 +19,7 @@ static bool shouldReduceAlign(GlobalObject &GO) {
static bool shouldReduceComdat(GlobalObject &GO) { return GO.hasComdat(); }
static void reduceGOs(Oracle &O, ReducerWorkItem &Program) {
void llvm::reduceGlobalObjectsDeltaPass(Oracle &O, ReducerWorkItem &Program) {
for (auto &GO : Program.getModule().global_objects()) {
if (shouldReduceSection(GO) && !O.shouldKeep())
GO.setSection("");
@@ -29,7 +29,3 @@ static void reduceGOs(Oracle &O, ReducerWorkItem &Program) {
GO.setComdat(nullptr);
}
}
void llvm::reduceGlobalObjectsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, reduceGOs, "Reducing GlobalObjects");
}

2
llvm/tools/llvm-reduce/deltas/ReduceGlobalObjects.h
View File

@@ -12,7 +12,7 @@
#include "Delta.h"
namespace llvm {
void reduceGlobalObjectsDeltaPass(TestRunner &Test);
void reduceGlobalObjectsDeltaPass(Oracle &O, ReducerWorkItem &Program);
} // namespace llvm
#endif

6
llvm/tools/llvm-reduce/deltas/ReduceGlobalValues.cpp
View File

@@ -41,7 +41,7 @@ static bool shouldReduceLinkage(GlobalValue &GV) {
return !GV.hasExternalLinkage() && !GV.hasAppendingLinkage();
}
static void reduceGVs(Oracle &O, ReducerWorkItem &Program) {
void llvm::reduceGlobalValuesDeltaPass(Oracle &O, ReducerWorkItem &Program) {
for (auto &GV : Program.getModule().global_values()) {
if (shouldReduceDSOLocal(GV) && !O.shouldKeep())
GV.setDSOLocal(false);
@@ -66,7 +66,3 @@ static void reduceGVs(Oracle &O, ReducerWorkItem &Program) {
}
}
}
void llvm::reduceGlobalValuesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, reduceGVs, "Reducing GlobalValues");
}

2
llvm/tools/llvm-reduce/deltas/ReduceGlobalValues.h
View File

@@ -17,7 +17,7 @@
#include "Delta.h"
namespace llvm {
void reduceGlobalValuesDeltaPass(TestRunner &Test);
void reduceGlobalValuesDeltaPass(Oracle &O, ReducerWorkItem &Program);
} // namespace llvm
#endif

9
llvm/tools/llvm-reduce/deltas/ReduceGlobalVarInitializers.cpp
View File

@@ -14,11 +14,14 @@
#include "ReduceGlobalVarInitializers.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/Value.h"
#include "llvm/Transforms/Utils/Cloning.h"
using namespace llvm;
/// Removes all the Initialized GVs that aren't inside the desired Chunks.
static void extractGVsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceGlobalsInitializersDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
// Drop initializers of out-of-chunk GVs
for (auto &GV : WorkItem.getModule().globals())
if (GV.hasInitializer() && !O.shouldKeep()) {
@@ -27,7 +30,3 @@ static void extractGVsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
GV.setComdat(nullptr);
}
}
void llvm::reduceGlobalsInitializersDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractGVsFromModule, "Reducing GV Initializers");
}

4
llvm/tools/llvm-reduce/deltas/ReduceGlobalVarInitializers.h
View File

@@ -15,11 +15,9 @@
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEGLOBALVARINITIALIZERS_H
#include "Delta.h"
#include "llvm/IR/Value.h"
#include "llvm/Transforms/Utils/Cloning.h"
namespace llvm {
void reduceGlobalsInitializersDeltaPass(TestRunner &Test);
void reduceGlobalsInitializersDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

8
llvm/tools/llvm-reduce/deltas/ReduceGlobalVars.cpp
View File

@@ -14,6 +14,8 @@
#include "ReduceGlobalVars.h"
#include "Utils.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Value.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/Utils/ModuleUtils.h"
using namespace llvm;
@@ -23,7 +25,7 @@ static bool shouldAlwaysKeep(const GlobalVariable &GV) {
}
/// Removes all the GVs that aren't inside the desired Chunks.
static void extractGVsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceGlobalsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
// Get GVs inside desired chunks
@@ -53,7 +55,3 @@ static void extractGVsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
cast<GlobalVariable>(GV)->eraseFromParent();
}
}
void llvm::reduceGlobalsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractGVsFromModule, "Reducing GlobalVariables");
}

4
llvm/tools/llvm-reduce/deltas/ReduceGlobalVars.h
View File

@@ -15,11 +15,9 @@
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEGLOBALVARS_H
#include "Delta.h"
#include "llvm/IR/Value.h"
#include "llvm/Transforms/Utils/Cloning.h"
namespace llvm {
void reduceGlobalsDeltaPass(TestRunner &Test);
void reduceGlobalsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

24
llvm/tools/llvm-reduce/deltas/ReduceIRReferences.cpp
View File

@@ -13,7 +13,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceIRReferences.h"
#include "Delta.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
@@ -37,14 +36,16 @@ static void dropIRReferencesFromInstructions(Oracle &O, MachineFunction &MF) {
}
}
static void stripIRFromInstructions(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceIRInstructionReferencesDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
for (const Function &F : WorkItem.getModule()) {
if (auto *MF = WorkItem.MMI->getMachineFunction(F))
dropIRReferencesFromInstructions(O, *MF);
}
}
static void stripIRFromBlocks(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceIRBlockReferencesDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
for (const Function &F : WorkItem.getModule()) {
if (auto *MF = WorkItem.MMI->getMachineFunction(F)) {
for (MachineBasicBlock &MBB : *MF) {
@@ -55,7 +56,8 @@ static void stripIRFromBlocks(Oracle &O, ReducerWorkItem &WorkItem) {
}
}
static void stripIRFromFunctions(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceIRFunctionReferencesDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
for (const Function &F : WorkItem.getModule()) {
if (!O.shouldKeep()) {
if (auto *MF = WorkItem.MMI->getMachineFunction(F)) {
@@ -67,17 +69,3 @@ static void stripIRFromFunctions(Oracle &O, ReducerWorkItem &WorkItem) {
}
}
}
void llvm::reduceIRInstructionReferencesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, stripIRFromInstructions,
"Reducing IR references from instructions");
}
void llvm::reduceIRBlockReferencesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, stripIRFromBlocks, "Reducing IR references from blocks");
}
void llvm::reduceIRFunctionReferencesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, stripIRFromFunctions,
"Reducing IR references from functions");
}

10
llvm/tools/llvm-reduce/deltas/ReduceIRReferences.h
View File

@@ -14,17 +14,19 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEIRREFERENCES_MIR_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEIRREFERENCES_MIR_H
#include "Delta.h"
namespace llvm {
class TestRunner;
/// Remove IR references from instructions (i.e. from memory operands)
void reduceIRInstructionReferencesDeltaPass(TestRunner &Test);
void reduceIRInstructionReferencesDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem);
/// Remove IR BasicBlock references (the block names)
void reduceIRBlockReferencesDeltaPass(TestRunner &Test);
void reduceIRBlockReferencesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
/// Remove IR references from function level fields (e.g. frame object names)
void reduceIRFunctionReferencesDeltaPass(TestRunner &Test);
void reduceIRFunctionReferencesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm

8
llvm/tools/llvm-reduce/deltas/ReduceInstructionFlags.cpp
View File

@@ -11,7 +11,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceInstructionFlags.h"
#include "Delta.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
@@ -19,7 +18,8 @@
using namespace llvm;
static void reduceFlagsInModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceInstructionFlagsDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
// Keep this in sync with computeIRComplexityScoreImpl().
for (Function &F : WorkItem.getModule()) {
for (Instruction &I : instructions(F)) {
@@ -83,7 +83,3 @@ static void reduceFlagsInModule(Oracle &O, ReducerWorkItem &WorkItem) {
}
}
}
void llvm::reduceInstructionFlagsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, reduceFlagsInModule, "Reducing Instruction Flags");
}

4
llvm/tools/llvm-reduce/deltas/ReduceInstructionFlags.h
View File

@@ -9,10 +9,10 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINSTRUCTIONFLAGS_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINSTRUCTIONFLAGS_H
#include "TestRunner.h"
#include "Delta.h"
namespace llvm {
void reduceInstructionFlagsDeltaPass(TestRunner &Test);
void reduceInstructionFlagsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

8
llvm/tools/llvm-reduce/deltas/ReduceInstructionFlagsMIR.cpp
View File

@@ -14,9 +14,11 @@
#include "ReduceInstructionFlagsMIR.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
using namespace llvm;
static void removeFlagsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceInstructionFlagsMIRDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
for (const Function &F : WorkItem.getModule()) {
if (auto *MF = WorkItem.MMI->getMachineFunction(F)) {
for (MachineBasicBlock &MBB : *MF) {
@@ -29,7 +31,3 @@ static void removeFlagsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
}
}
}
void llvm::reduceInstructionFlagsMIRDeltaPass(TestRunner &Test) {
runDeltaPass(Test, removeFlagsFromModule, "Reducing Instruction Flags");
}

2
llvm/tools/llvm-reduce/deltas/ReduceInstructionFlagsMIR.h
View File

@@ -17,7 +17,7 @@
#include "Delta.h"
namespace llvm {
void reduceInstructionFlagsMIRDeltaPass(TestRunner &Test);
void reduceInstructionFlagsMIRDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

8
llvm/tools/llvm-reduce/deltas/ReduceInstructions.cpp
View File

@@ -14,6 +14,8 @@
#include "ReduceInstructions.h"
#include "Utils.h"
#include "llvm/IR/Constants.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include <set>
using namespace llvm;
@@ -29,7 +31,7 @@ static bool shouldAlwaysKeep(const Instruction &I) {
/// Removes out-of-chunk arguments from functions, and modifies their calls
/// accordingly. It also removes allocations of out-of-chunk arguments.
static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceInstructionsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
for (auto &F : Program) {
@@ -46,7 +48,3 @@ static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
}
}
}
void llvm::reduceInstructionsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractInstrFromModule, "Reducing Instructions");
}

4
llvm/tools/llvm-reduce/deltas/ReduceInstructions.h
View File

@@ -15,11 +15,9 @@
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINSTRUCTIONS_H
#include "Delta.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/Cloning.h"
namespace llvm {
void reduceInstructionsDeltaPass(TestRunner &Test);
void reduceInstructionsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

9
llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.cpp
View File

@@ -12,8 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceInstructionsMIR.h"
#include "Delta.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/CodeGen/MachineDominators.h"
#include "llvm/CodeGen/MachineFunction.h"
@@ -151,13 +149,10 @@ static void extractInstrFromFunction(Oracle &O, MachineFunction &MF) {
MI->eraseFromParent();
}
static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceInstructionsMIRDeltaPass(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) {
runDeltaPass(Test, extractInstrFromModule, "Reducing Instructions");
}

6
llvm/tools/llvm-reduce/deltas/ReduceInstructionsMIR.h
View File

@@ -14,10 +14,10 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINSTRUCTIONS_MIR_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINSTRUCTIONS_MIR_H
namespace llvm {
class TestRunner;
#include "Delta.h"
void reduceInstructionsMIRDeltaPass(TestRunner &Test);
namespace llvm {
void reduceInstructionsMIRDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

7
llvm/tools/llvm-reduce/deltas/ReduceInvokes.cpp
View File

@@ -11,7 +11,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceInvokes.h"
#include "Delta.h"
#include "llvm/IR/Instructions.h"
#include "llvm/Transforms/Utils/Local.h"
@@ -29,13 +28,9 @@ static void reduceInvokesInFunction(Oracle &O, Function &F) {
// reduction.
}
static void reduceInvokesInModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceInvokesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
for (Function &F : WorkItem.getModule()) {
if (F.hasPersonalityFn())
reduceInvokesInFunction(O, F);
}
}
void llvm::reduceInvokesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, reduceInvokesInModule, "Reducing Invokes");
}

4
llvm/tools/llvm-reduce/deltas/ReduceInvokes.h
View File

@@ -9,10 +9,10 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINVOKES_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEINVOKES_H
#include "TestRunner.h"
#include "Delta.h"
namespace llvm {
void reduceInvokesDeltaPass(TestRunner &Test);
void reduceInvokesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

21
llvm/tools/llvm-reduce/deltas/ReduceMemoryOperations.cpp
View File

@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceMemoryOperations.h"
#include "Delta.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
@@ -36,15 +35,12 @@ static void removeVolatileInFunction(Oracle &O, Function &F) {
}
}
static void removeVolatileInModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceVolatileInstructionsDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
for (Function &F : WorkItem.getModule())
removeVolatileInFunction(O, F);
}
void llvm::reduceVolatileInstructionsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, removeVolatileInModule, "Reducing Volatile Instructions");
}
static void reduceAtomicSyncScopesInFunction(Oracle &O, Function &F) {
for (Instruction &I : instructions(F)) {
if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
@@ -66,17 +62,12 @@ static void reduceAtomicSyncScopesInFunction(Oracle &O, Function &F) {
}
}
static void reduceAtomicSyncScopesInModule(Oracle &O,
void llvm::reduceAtomicSyncScopesDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
for (Function &F : WorkItem.getModule())
reduceAtomicSyncScopesInFunction(O, F);
}
void llvm::reduceAtomicSyncScopesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, reduceAtomicSyncScopesInModule,
"Reducing Atomic Sync Scopes");
}
// TODO: Might be helpful to incrementally relax orders
static void reduceAtomicOrderingInFunction(Oracle &O, Function &F) {
for (Instruction &I : instructions(F)) {
@@ -100,11 +91,7 @@ static void reduceAtomicOrderingInFunction(Oracle &O, Function &F) {
}
}
static void reduceAtomicOrderingInModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceAtomicOrderingDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
for (Function &F : WorkItem.getModule())
reduceAtomicOrderingInFunction(O, F);
}
void llvm::reduceAtomicOrderingDeltaPass(TestRunner &Test) {
runDeltaPass(Test, reduceAtomicOrderingInModule, "Reducing Atomic Ordering");
}

8
llvm/tools/llvm-reduce/deltas/ReduceMemoryOperations.h
View File

@@ -9,12 +9,12 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEMEMORYOPERATIONS_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEMEMORYOPERATIONS_H
#include "TestRunner.h"
#include "Delta.h"
namespace llvm {
void reduceVolatileInstructionsDeltaPass(TestRunner &Test);
void reduceAtomicSyncScopesDeltaPass(TestRunner &Test);
void reduceAtomicOrderingDeltaPass(TestRunner &Test);
void reduceVolatileInstructionsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
void reduceAtomicSyncScopesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
void reduceAtomicOrderingDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

13
llvm/tools/llvm-reduce/deltas/ReduceMetadata.cpp
View File

@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceMetadata.h"
#include "Delta.h"
#include "llvm/ADT/Sequence.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/IR/InstIterator.h"
@@ -48,7 +47,7 @@ static constexpr StringLiteral ListNamedMetadata[] = {
};
/// Remove unneeded arguments to named metadata.
static void reduceNamedMetadataOperands(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceNamedMetadataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &M = WorkItem.getModule();
for (NamedMDNode &I : M.named_metadata()) {
@@ -77,7 +76,7 @@ static void reduceNamedMetadataOperands(Oracle &O, ReducerWorkItem &WorkItem) {
/// Removes all the Named and Unnamed Metadata Nodes, as well as any debug
/// functions that aren't inside the desired Chunks.
static void extractMetadataFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceMetadataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
// Get out-of-chunk Named metadata nodes
@@ -122,11 +121,3 @@ static void extractMetadataFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
}
}
}
void llvm::reduceMetadataDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractMetadataFromModule, "Reducing Metadata");
}
void llvm::reduceNamedMetadataDeltaPass(TestRunner &Test) {
runDeltaPass(Test, reduceNamedMetadataOperands, "Reducing Named Metadata");
}

6
llvm/tools/llvm-reduce/deltas/ReduceMetadata.h
View File

@@ -14,11 +14,11 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEMETADATA_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEMETADATA_H
#include "TestRunner.h"
#include "Delta.h"
namespace llvm {
void reduceMetadataDeltaPass(TestRunner &Test);
void reduceNamedMetadataDeltaPass(TestRunner &Test);
void reduceMetadataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
void reduceNamedMetadataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

6
llvm/tools/llvm-reduce/deltas/ReduceModuleData.cpp
View File

@@ -14,7 +14,7 @@
using namespace llvm;
static void clearModuleData(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceModuleDataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
if (!Program.getModuleIdentifier().empty() && !O.shouldKeep())
@@ -25,7 +25,3 @@ static void clearModuleData(Oracle &O, ReducerWorkItem &WorkItem) {
if (!Program.getModuleInlineAsm().empty() && !O.shouldKeep())
Program.setModuleInlineAsm("");
}
void llvm::reduceModuleDataDeltaPass(TestRunner &Test) {
runDeltaPass(Test, clearModuleData, "Reducing Module Data");
}

2
llvm/tools/llvm-reduce/deltas/ReduceModuleData.h
View File

@@ -12,7 +12,7 @@
#include "Delta.h"
namespace llvm {
void reduceModuleDataDeltaPass(TestRunner &Test);
void reduceModuleDataDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

7
llvm/tools/llvm-reduce/deltas/ReduceOpcodes.cpp
View File

@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceOpcodes.h"
#include "Delta.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
@@ -240,7 +239,7 @@ static Value *reduceInstruction(Oracle &O, Module &M, Instruction &I) {
return nullptr;
}
static void replaceOpcodesInModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceOpcodesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Mod = WorkItem.getModule();
for (Function &F : Mod) {
@@ -261,7 +260,3 @@ static void replaceOpcodesInModule(Oracle &O, ReducerWorkItem &WorkItem) {
}
}
}
void llvm::reduceOpcodesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, replaceOpcodesInModule, "Reducing Opcodes");
}

4
llvm/tools/llvm-reduce/deltas/ReduceOpcodes.h
View File

@@ -9,10 +9,10 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPCODES_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPCODES_H
#include "TestRunner.h"
#include "Delta.h"
namespace llvm {
void reduceOpcodesDeltaPass(TestRunner &Test);
void reduceOpcodesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

9
llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp
View File

@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceOperandBundles.h"
#include "Delta.h"
#include "TestRunner.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
@@ -95,8 +94,7 @@ static void maybeRewriteCallWithDifferentBundles(
}
/// Removes out-of-chunk operand bundles from calls.
static void extractOperandBundesFromModule(Oracle &O,
ReducerWorkItem &WorkItem) {
void llvm::reduceOperandBundesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
OperandBundleRemapper R(O);
R.visit(Program);
@@ -104,8 +102,3 @@ static void extractOperandBundesFromModule(Oracle &O,
for (const auto &I : R.CallsToRefine)
maybeRewriteCallWithDifferentBundles(I.first, I.second);
}
void llvm::reduceOperandBundesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractOperandBundesFromModule,
"Reducing Operand Bundles");
}

5
llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.h
View File

@@ -14,9 +14,10 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDBUNDLES_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDBUNDLES_H
#include "Delta.h"
namespace llvm {
class TestRunner;
void reduceOperandBundesDeltaPass(TestRunner &Test);
void reduceOperandBundesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

27
llvm/tools/llvm-reduce/deltas/ReduceOperands.cpp
View File

@@ -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(Oracle &O, ReducerWorkItem &WorkItem) {
auto ReduceValue = [](Use &Op) -> Value * {
if (!shouldReduceOperand(Op))
return nullptr;
@@ -118,15 +118,10 @@ void llvm::reduceOperandsOneDeltaPass(TestRunner &Test) {
return nullptr;
};
runDeltaPass(
Test,
[ReduceValue](Oracle &O, ReducerWorkItem &WorkItem) {
extractOperandsFromModule(O, WorkItem, ReduceValue);
},
"Reducing Operands to one");
extractOperandsFromModule(O, WorkItem, ReduceValue);
}
void llvm::reduceOperandsZeroDeltaPass(TestRunner &Test) {
void llvm::reduceOperandsZeroDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
auto ReduceValue = [](Use &Op) -> Value * {
if (!shouldReduceOperand(Op))
return nullptr;
@@ -148,15 +143,10 @@ void llvm::reduceOperandsZeroDeltaPass(TestRunner &Test) {
// Don't replace existing zeroes.
return isZero(Op) ? nullptr : Constant::getNullValue(Op->getType());
};
runDeltaPass(
Test,
[ReduceValue](Oracle &O, ReducerWorkItem &Program) {
extractOperandsFromModule(O, Program, ReduceValue);
},
"Reducing Operands to zero");
extractOperandsFromModule(O, WorkItem, ReduceValue);
}
void llvm::reduceOperandsNaNDeltaPass(TestRunner &Test) {
void llvm::reduceOperandsNaNDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
auto ReduceValue = [](Use &Op) -> Value * {
Type *Ty = Op->getType();
if (!Ty->isFPOrFPVectorTy())
@@ -176,10 +166,5 @@ void llvm::reduceOperandsNaNDeltaPass(TestRunner &Test) {
return ConstantFP::getQNaN(Ty);
};
runDeltaPass(
Test,
[ReduceValue](Oracle &O, ReducerWorkItem &Program) {
extractOperandsFromModule(O, Program, ReduceValue);
},
"Reducing Operands to NaN");
extractOperandsFromModule(O, WorkItem, ReduceValue);
}

6
llvm/tools/llvm-reduce/deltas/ReduceOperands.h
View File

@@ -12,9 +12,9 @@
#include "Delta.h"
namespace llvm {
void reduceOperandsOneDeltaPass(TestRunner &Test);
void reduceOperandsZeroDeltaPass(TestRunner &Test);
void reduceOperandsNaNDeltaPass(TestRunner &Test);
void reduceOperandsOneDeltaPass(Oracle &, ReducerWorkItem &);
void reduceOperandsZeroDeltaPass(Oracle &, ReducerWorkItem &);
void reduceOperandsNaNDeltaPass(Oracle &, ReducerWorkItem &);
} // namespace llvm
#endif

7
llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.cpp
View File

@@ -194,7 +194,7 @@ opportunities(Function &F,
}
}
static void extractOperandsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceOperandsSkipDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
for (Function &F : Program.functions()) {
@@ -229,8 +229,3 @@ static void extractOperandsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
}
}
}
void llvm::reduceOperandsSkipDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractOperandsFromModule,
"Reducing operands by skipping over instructions");
}

2
llvm/tools/llvm-reduce/deltas/ReduceOperandsSkip.h
View File

@@ -12,7 +12,7 @@
#include "Delta.h"
namespace llvm {
void reduceOperandsSkipDeltaPass(TestRunner &Test);
void reduceOperandsSkipDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif /* LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDSSKIP_H */

8
llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.cpp
View File

@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceOperandsToArgs.h"
#include "Delta.h"
#include "Utils.h"
#include "llvm/ADT/Sequence.h"
#include "llvm/IR/Constants.h"
@@ -196,7 +195,7 @@ static void substituteOperandWithArgument(Function *OldF,
OldF->eraseFromParent();
}
static void reduceOperandsToArgs(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceOperandsToArgsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
SmallVector<Use *> OperandsToReduce;
@@ -218,8 +217,3 @@ static void reduceOperandsToArgs(Oracle &O, ReducerWorkItem &WorkItem) {
substituteOperandWithArgument(&F, OperandsToReduce);
}
}
void llvm::reduceOperandsToArgsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, reduceOperandsToArgs,
"Converting operands to function arguments");
}

2
llvm/tools/llvm-reduce/deltas/ReduceOperandsToArgs.h
View File

@@ -12,7 +12,7 @@
#include "Delta.h"
namespace llvm {
void reduceOperandsToArgsDeltaPass(TestRunner &Test);
void reduceOperandsToArgsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif /* LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEOPERANDSTOARGS_H */

7
llvm/tools/llvm-reduce/deltas/ReduceRegisterDefs.cpp
View File

@@ -110,13 +110,10 @@ static void removeDefsFromFunction(Oracle &O, MachineFunction &MF) {
}
}
static void removeDefsFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceRegisterDefsMIRDeltaPass(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) {
runDeltaPass(Test, removeDefsFromModule, "Reducing register defs");
}

2
llvm/tools/llvm-reduce/deltas/ReduceRegisterDefs.h
View File

@@ -17,7 +17,7 @@
#include "Delta.h"
namespace llvm {
void reduceRegisterDefsMIRDeltaPass(TestRunner &Test);
void reduceRegisterDefsMIRDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

7
llvm/tools/llvm-reduce/deltas/ReduceRegisterMasks.cpp
View File

@@ -60,13 +60,10 @@ static void reduceMasksInFunction(Oracle &O, MachineFunction &MF) {
}
}
static void reduceMasksInModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceRegisterMasksMIRDeltaPass(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) {
runDeltaPass(Test, reduceMasksInModule, "Reducing register masks");
}

2
llvm/tools/llvm-reduce/deltas/ReduceRegisterMasks.h
View File

@@ -12,7 +12,7 @@
#include "Delta.h"
namespace llvm {
void reduceRegisterMasksMIRDeltaPass(TestRunner &Test);
void reduceRegisterMasksMIRDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

7
llvm/tools/llvm-reduce/deltas/ReduceRegisterUses.cpp
View File

@@ -55,13 +55,10 @@ static void removeUsesFromFunction(Oracle &O, MachineFunction &MF) {
}
}
static void removeUsesFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceRegisterUsesMIRDeltaPass(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) {
runDeltaPass(Test, removeUsesFromModule, "Reducing register uses");
}

2
llvm/tools/llvm-reduce/deltas/ReduceRegisterUses.h
View File

@@ -17,7 +17,7 @@
#include "Delta.h"
namespace llvm {
void reduceRegisterUsesMIRDeltaPass(TestRunner &Test);
void reduceRegisterUsesMIRDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

9
llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.cpp
View File

@@ -15,7 +15,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceSpecialGlobals.h"
#include "Delta.h"
#include "Utils.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/Constants.h"
@@ -27,8 +26,7 @@ static StringRef SpecialGlobalNames[] = {"llvm.used", "llvm.compiler.used"};
/// Removes all special globals aren't inside any of the
/// desired Chunks.
static void extractSpecialGlobalsFromModule(Oracle &O,
ReducerWorkItem &WorkItem) {
void llvm::reduceSpecialGlobalsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
for (StringRef Name : SpecialGlobalNames) {
@@ -40,8 +38,3 @@ static void extractSpecialGlobalsFromModule(Oracle &O,
}
}
}
void llvm::reduceSpecialGlobalsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractSpecialGlobalsFromModule,
"Reducing Special Globals");
}

2
llvm/tools/llvm-reduce/deltas/ReduceSpecialGlobals.h
View File

@@ -20,7 +20,7 @@
#include "Delta.h"
namespace llvm {
void reduceSpecialGlobalsDeltaPass(TestRunner &Test);
void reduceSpecialGlobalsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

26
llvm/tools/llvm-reduce/deltas/ReduceUsingSimplifyCFG.cpp
View File

@@ -19,7 +19,8 @@
using namespace llvm;
static void reduceUsingSimplifyCFG(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::reduceUsingSimplifyCFGDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
SmallVector<BasicBlock *, 16> ToSimplify;
for (auto &F : Program)
@@ -31,9 +32,6 @@ static void reduceUsingSimplifyCFG(Oracle &O, ReducerWorkItem &WorkItem) {
simplifyCFG(BB, TTI);
}
void llvm::reduceUsingSimplifyCFGDeltaPass(TestRunner &Test) {
runDeltaPass(Test, reduceUsingSimplifyCFG, "Reducing using SimplifyCFG");
}
static void reduceConditionals(Oracle &O, ReducerWorkItem &WorkItem,
bool Direction) {
Module &M = WorkItem.getModule();
@@ -59,20 +57,12 @@ static void reduceConditionals(Oracle &O, ReducerWorkItem &WorkItem,
simplifyCFG(BB, TTI);
}
void llvm::reduceConditionalsTrueDeltaPass(TestRunner &Test) {
runDeltaPass(
Test,
[](Oracle &O, ReducerWorkItem &WorkItem) {
reduceConditionals(O, WorkItem, true);
},
"Reducing conditional branches to true");
void llvm::reduceConditionalsTrueDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
reduceConditionals(O, WorkItem, true);
}
void llvm::reduceConditionalsFalseDeltaPass(TestRunner &Test) {
runDeltaPass(
Test,
[](Oracle &O, ReducerWorkItem &WorkItem) {
reduceConditionals(O, WorkItem, false);
},
"Reducing conditional branches to false");
void llvm::reduceConditionalsFalseDeltaPass(Oracle &O,
ReducerWorkItem &WorkItem) {
reduceConditionals(O, WorkItem, false);
}

6
llvm/tools/llvm-reduce/deltas/ReduceUsingSimplifyCFG.h
View File

@@ -17,9 +17,9 @@
#include "Delta.h"
namespace llvm {
void reduceUsingSimplifyCFGDeltaPass(TestRunner &Test);
void reduceConditionalsTrueDeltaPass(TestRunner &Test);
void reduceConditionalsFalseDeltaPass(TestRunner &Test);
void reduceUsingSimplifyCFGDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
void reduceConditionalsTrueDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
void reduceConditionalsFalseDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

10
llvm/tools/llvm-reduce/deltas/ReduceVirtualRegisters.cpp
View File

@@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===//
#include "ReduceVirtualRegisters.h"
#include "Delta.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
@@ -33,15 +32,10 @@ static void dropRegisterHintsFromFunction(Oracle &O, MachineFunction &MF) {
}
}
static void dropRegisterHintsFromFunctions(Oracle &O,
ReducerWorkItem &WorkItem) {
void llvm::reduceVirtualRegisterHintsDeltaPass(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) {
runDeltaPass(Test, dropRegisterHintsFromFunctions,
"Reducing virtual register hints from functions");
}

4
llvm/tools/llvm-reduce/deltas/ReduceVirtualRegisters.h
View File

@@ -14,11 +14,13 @@
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEVIRTUALREGISTERS_H
#define LLVM_TOOLS_LLVM_REDUCE_DELTAS_REDUCEVIRTUALREGISTERS_H
#include "Delta.h"
namespace llvm {
class TestRunner;
/// Remove register allocation hints from virtual registes.
void reduceVirtualRegisterHintsDeltaPass(TestRunner &Test);
void reduceVirtualRegisterHintsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm

7
llvm/tools/llvm-reduce/deltas/RunIRPasses.cpp
View File

@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "RunIRPasses.h"
#include "Delta.h"
#include "llvm/Passes/PassBuilder.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorHandling.h"
@@ -24,7 +23,7 @@ static cl::opt<std::string>
"simplifycfg,infer-address-spaces)"),
cl::cat(LLVMReduceOptions));
static void runPasses(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::runIRPassesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
LoopAnalysisManager LAM;
FunctionAnalysisManager FAM;
@@ -47,7 +46,3 @@ static void runPasses(Oracle &O, ReducerWorkItem &WorkItem) {
report_fatal_error(std::move(Err), false);
MPM.run(Program, MAM);
}
void llvm::runIRPassesDeltaPass(TestRunner &Test) {
runDeltaPass(Test, runPasses, "Running passes");
}

2
llvm/tools/llvm-reduce/deltas/RunIRPasses.h
View File

@@ -12,7 +12,7 @@
#include "Delta.h"
namespace llvm {
void runIRPassesDeltaPass(TestRunner &Test);
void runIRPassesDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

6
llvm/tools/llvm-reduce/deltas/SimplifyInstructions.cpp
View File

@@ -19,7 +19,7 @@ using namespace llvm;
/// Calls simplifyInstruction in each instruction in functions, and replaces
/// their values.
static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::simplifyInstructionsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
std::vector<Instruction *> InstsToDelete;
Module &Program = WorkItem.getModule();
@@ -44,7 +44,3 @@ static void extractInstrFromModule(Oracle &O, ReducerWorkItem &WorkItem) {
for (Instruction *I : InstToDelete)
I->eraseFromParent();
}
void llvm::simplifyInstructionsDeltaPass(TestRunner &Test) {
runDeltaPass(Test, extractInstrFromModule, "Simplifying Instructions");
}

2
llvm/tools/llvm-reduce/deltas/SimplifyInstructions.h
View File

@@ -12,7 +12,7 @@
#include "Delta.h"
namespace llvm {
void simplifyInstructionsDeltaPass(TestRunner &Test);
void simplifyInstructionsDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif

7
llvm/tools/llvm-reduce/deltas/StripDebugInfo.cpp
View File

@@ -7,7 +7,6 @@
//===----------------------------------------------------------------------===//
#include "StripDebugInfo.h"
#include "Delta.h"
#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/Metadata.h"
@@ -15,7 +14,7 @@ using namespace llvm;
/// Removes all aliases aren't inside any of the
/// desired Chunks.
static void stripDebugInfoImpl(Oracle &O, ReducerWorkItem &WorkItem) {
void llvm::stripDebugInfoDeltaPass(Oracle &O, ReducerWorkItem &WorkItem) {
Module &Program = WorkItem.getModule();
bool HasDebugInfo = any_of(Program.named_metadata(), [](NamedMDNode &NMD) {
return NMD.getName().starts_with("llvm.dbg.");
@@ -23,7 +22,3 @@ static void stripDebugInfoImpl(Oracle &O, ReducerWorkItem &WorkItem) {
if (HasDebugInfo && !O.shouldKeep())
StripDebugInfo(Program);
}
void llvm::stripDebugInfoDeltaPass(TestRunner &Test) {
runDeltaPass(Test, stripDebugInfoImpl, "Stripping Debug Info");
}

2
llvm/tools/llvm-reduce/deltas/StripDebugInfo.h
View File

@@ -12,7 +12,7 @@
#include "Delta.h"
namespace llvm {
void stripDebugInfoDeltaPass(TestRunner &Test);
void stripDebugInfoDeltaPass(Oracle &O, ReducerWorkItem &WorkItem);
} // namespace llvm
#endif