Skip to content

Commit fea6b38

Browse files
YLChenZYLChenZ
authored
[llvm-reduce]: print short form, actionable names in the log (llvm#133561)
Closes llvm#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)... ---------------------------- ```
1 parent 9747bb1 commit fea6b38

File tree

77 files changed

+303
-459
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

77 files changed

+303
-459
lines changed

‎llvm/tools/llvm-reduce/DeltaManager.cpp‎

Lines changed: 50 additions & 85 deletions
Original file line numberDiff line numberDiff line change
@@ -12,9 +12,8 @@
1212
//===----------------------------------------------------------------------===//
1313

1414
#include "DeltaManager.h"
15-
#include "ReducerWorkItem.h"
15+
#include "DeltaPass.h"
1616
#include "TestRunner.h"
17-
#include "deltas/Delta.h"
1817
#include "deltas/ReduceAliases.h"
1918
#include "deltas/ReduceArguments.h"
2019
#include "deltas/ReduceAttributes.h"
@@ -71,91 +70,56 @@ static cl::list<std::string>
7170
"default, run all delta passes."),
7271
cl::cat(LLVMReduceOptions), cl::CommaSeparated);
7372

74-
#define DELTA_PASSES \
75-
do { \
76-
DELTA_PASS("strip-debug-info", stripDebugInfoDeltaPass) \
77-
DELTA_PASS("functions", reduceFunctionsDeltaPass) \
78-
DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass) \
79-
DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass) \
80-
DELTA_PASS("aliases", reduceAliasesDeltaPass) \
81-
DELTA_PASS("ifuncs", reduceIFuncsDeltaPass) \
82-
DELTA_PASS("simplify-conditionals-true", reduceConditionalsTrueDeltaPass) \
83-
DELTA_PASS("simplify-conditionals-false", \
84-
reduceConditionalsFalseDeltaPass) \
85-
DELTA_PASS("invokes", reduceInvokesDeltaPass) \
86-
DELTA_PASS("unreachable-basic-blocks", \
87-
reduceUnreachableBasicBlocksDeltaPass) \
88-
DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass) \
89-
DELTA_PASS("simplify-cfg", reduceUsingSimplifyCFGDeltaPass) \
90-
DELTA_PASS("function-data", reduceFunctionDataDeltaPass) \
91-
DELTA_PASS("global-values", reduceGlobalValuesDeltaPass) \
92-
DELTA_PASS("global-objects", reduceGlobalObjectsDeltaPass) \
93-
DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass) \
94-
DELTA_PASS("global-variables", reduceGlobalsDeltaPass) \
95-
DELTA_PASS("di-metadata", reduceDIMetadataDeltaPass) \
96-
DELTA_PASS("dbg-records", reduceDbgRecordDeltaPass) \
97-
DELTA_PASS("distinct-metadata", reduceDistinctMetadataDeltaPass) \
98-
DELTA_PASS("metadata", reduceMetadataDeltaPass) \
99-
DELTA_PASS("named-metadata", reduceNamedMetadataDeltaPass) \
100-
DELTA_PASS("arguments", reduceArgumentsDeltaPass) \
101-
DELTA_PASS("instructions", reduceInstructionsDeltaPass) \
102-
DELTA_PASS("simplify-instructions", simplifyInstructionsDeltaPass) \
103-
DELTA_PASS("ir-passes", runIRPassesDeltaPass) \
104-
DELTA_PASS("operands-zero", reduceOperandsZeroDeltaPass) \
105-
DELTA_PASS("operands-one", reduceOperandsOneDeltaPass) \
106-
DELTA_PASS("operands-nan", reduceOperandsNaNDeltaPass) \
107-
DELTA_PASS("operands-to-args", reduceOperandsToArgsDeltaPass) \
108-
DELTA_PASS("operands-skip", reduceOperandsSkipDeltaPass) \
109-
DELTA_PASS("operand-bundles", reduceOperandBundesDeltaPass) \
110-
DELTA_PASS("attributes", reduceAttributesDeltaPass) \
111-
DELTA_PASS("module-data", reduceModuleDataDeltaPass) \
112-
DELTA_PASS("opcodes", reduceOpcodesDeltaPass) \
113-
DELTA_PASS("volatile", reduceVolatileInstructionsDeltaPass) \
114-
DELTA_PASS("atomic-ordering", reduceAtomicOrderingDeltaPass) \
115-
DELTA_PASS("syncscopes", reduceAtomicSyncScopesDeltaPass) \
116-
DELTA_PASS("instruction-flags", reduceInstructionFlagsDeltaPass) \
117-
} while (false)
118-
119-
#define DELTA_PASSES_MIR \
120-
do { \
121-
DELTA_PASS("instructions", reduceInstructionsMIRDeltaPass) \
122-
DELTA_PASS("ir-instruction-references", \
123-
reduceIRInstructionReferencesDeltaPass) \
124-
DELTA_PASS("ir-block-references", reduceIRBlockReferencesDeltaPass) \
125-
DELTA_PASS("ir-function-references", reduceIRFunctionReferencesDeltaPass) \
126-
DELTA_PASS("instruction-flags", reduceInstructionFlagsMIRDeltaPass) \
127-
DELTA_PASS("register-uses", reduceRegisterUsesMIRDeltaPass) \
128-
DELTA_PASS("register-defs", reduceRegisterDefsMIRDeltaPass) \
129-
DELTA_PASS("register-hints", reduceVirtualRegisterHintsDeltaPass) \
130-
DELTA_PASS("register-masks", reduceRegisterMasksMIRDeltaPass) \
131-
} while (false)
73+
// Generate two separate Pass lists: IR_Passes and MIR_Passes
74+
static const DeltaPass IR_Passes[] = {
75+
#undef DELTA_PASS_IR
76+
#undef DELTA_PASS_MIR
77+
#define DELTA_PASS_IR(NAME, FUNC, DESC) {NAME, FUNC, DESC},
78+
#include "DeltaPasses.def"
79+
#undef DELTA_PASS_IR
80+
};
81+
82+
static const DeltaPass MIR_Passes[] = {
83+
#undef DELTA_PASS_IR
84+
#undef DELTA_PASS_MIR
85+
#define DELTA_PASS_MIR(NAME, FUNC, DESC) {NAME, FUNC, DESC},
86+
#include "DeltaPasses.def"
87+
#undef DELTA_PASS_MIR
88+
};
13289

13390
static void runAllDeltaPasses(TestRunner &Tester,
13491
const SmallStringSet &SkipPass) {
135-
#define DELTA_PASS(NAME, FUNC) \
136-
if (!SkipPass.count(NAME)) { \
137-
FUNC(Tester); \
138-
}
13992
if (Tester.getProgram().isMIR()) {
140-
DELTA_PASSES_MIR;
93+
for (const DeltaPass &Pass : MIR_Passes) {
94+
if (!SkipPass.count(Pass.Name)) {
95+
runDeltaPass(Tester, Pass);
96+
}
97+
}
14198
} else {
142-
DELTA_PASSES;
99+
for (const DeltaPass &Pass : IR_Passes) {
100+
if (!SkipPass.count(Pass.Name)) {
101+
runDeltaPass(Tester, Pass);
102+
}
103+
}
143104
}
144-
#undef DELTA_PASS
145105
}
146106

147107
static void runDeltaPassName(TestRunner &Tester, StringRef PassName) {
148-
#define DELTA_PASS(NAME, FUNC) \
149-
if (PassName == NAME) { \
150-
FUNC(Tester); \
151-
return; \
152-
}
153108
if (Tester.getProgram().isMIR()) {
154-
DELTA_PASSES_MIR;
109+
for (const DeltaPass &Pass : MIR_Passes) {
110+
if (PassName == Pass.Name) {
111+
runDeltaPass(Tester, Pass);
112+
return;
113+
}
114+
}
155115
} else {
156-
DELTA_PASSES;
116+
for (const DeltaPass &Pass : IR_Passes) {
117+
if (PassName == Pass.Name) {
118+
runDeltaPass(Tester, Pass);
119+
return;
120+
}
121+
}
157122
}
158-
#undef DELTA_PASS
159123

160124
// We should have errored on unrecognized passes before trying to run
161125
// anything.
@@ -164,24 +128,25 @@ static void runDeltaPassName(TestRunner &Tester, StringRef PassName) {
164128

165129
void llvm::printDeltaPasses(raw_ostream &OS) {
166130
OS << "Delta passes (pass to `--delta-passes=` as a comma separated list):\n";
167-
#define DELTA_PASS(NAME, FUNC) OS << " " << NAME << "\n";
168131
OS << " IR:\n";
169-
DELTA_PASSES;
132+
for (const DeltaPass &Pass : IR_Passes) {
133+
OS << " " << Pass.Name << '\n';
134+
}
170135
OS << " MIR:\n";
171-
DELTA_PASSES_MIR;
172-
#undef DELTA_PASS
136+
for (const DeltaPass &Pass : MIR_Passes) {
137+
OS << " " << Pass.Name << '\n';
138+
}
173139
}
174140

175141
// Built a set of available delta passes.
176142
static void collectPassNames(const TestRunner &Tester,
177143
SmallStringSet &NameSet) {
178-
#define DELTA_PASS(NAME, FUNC) NameSet.insert(NAME);
179-
if (Tester.getProgram().isMIR()) {
180-
DELTA_PASSES_MIR;
181-
} else {
182-
DELTA_PASSES;
144+
for (const DeltaPass &Pass : MIR_Passes) {
145+
NameSet.insert(Pass.Name);
146+
}
147+
for (const DeltaPass &Pass : IR_Passes) {
148+
NameSet.insert(Pass.Name);
183149
}
184-
#undef DELTA_PASS
185150
}
186151

187152
/// Verify all requested or skipped passes are valid names, and return them in a

‎llvm/tools/llvm-reduce/DeltaPass.h‎

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
//===--- DeltaPass.h - Delta Pass Structure --------------------*- C++ -*-===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
9+
#ifndef LLVM_TOOLS_LLVM_REDUCE_DELTAPASS_H
10+
#define LLVM_TOOLS_LLVM_REDUCE_DELTAPASS_H
11+
12+
#include "ReducerWorkItem.h"
13+
#include "deltas/Delta.h"
14+
#include "llvm/ADT/StringRef.h"
15+
16+
namespace llvm {
17+
struct DeltaPass {
18+
StringRef Name; // e.g., "strip-debug-info"
19+
void (*Func)(Oracle &, ReducerWorkItem &); // e.g., stripDebugInfoDeltaPass
20+
StringRef Desc; // e.g., "Stripping Debug Info"
21+
};
22+
} // namespace llvm
23+
24+
#endif

‎llvm/tools/llvm-reduce/DeltaPasses.def‎

Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,68 @@
1+
//===--- DeltaPasses.def - Delta Pass Definitions --------------*- C++ -*-===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
9+
10+
#ifndef DELTA_PASS_IR
11+
#define DELTA_PASS_IR(NAME, FUNC, DESC)
12+
#endif
13+
DELTA_PASS_IR("strip-debug-info", stripDebugInfoDeltaPass, "Stripping Debug Info")
14+
DELTA_PASS_IR("functions", reduceFunctionsDeltaPass, "Reducing Functions")
15+
DELTA_PASS_IR("function-bodies", reduceFunctionBodiesDeltaPass, "Reducing Function Bodies")
16+
DELTA_PASS_IR("special-globals", reduceSpecialGlobalsDeltaPass, "Reducing Special Globals")
17+
DELTA_PASS_IR("aliases", reduceAliasesDeltaPass, "Reducing Aliases")
18+
DELTA_PASS_IR("ifuncs", reduceIFuncsDeltaPass, "Reducing Ifuncs")
19+
DELTA_PASS_IR("simplify-conditionals-true", reduceConditionalsTrueDeltaPass, "Reducing conditional branches to true")
20+
DELTA_PASS_IR("simplify-conditionals-false",
21+
reduceConditionalsFalseDeltaPass, "Reducing conditional branches to false")
22+
DELTA_PASS_IR("invokes", reduceInvokesDeltaPass, "Reducing Invokes")
23+
DELTA_PASS_IR("unreachable-basic-blocks",
24+
reduceUnreachableBasicBlocksDeltaPass, "Removing Unreachable Basic Blocks")
25+
DELTA_PASS_IR("basic-blocks", reduceBasicBlocksDeltaPass, "Reducing Basic Blocks")
26+
DELTA_PASS_IR("simplify-cfg", reduceUsingSimplifyCFGDeltaPass, "Reducing using SimplifyCFG")
27+
DELTA_PASS_IR("function-data", reduceFunctionDataDeltaPass, "Reducing Function Data")
28+
DELTA_PASS_IR("global-values", reduceGlobalValuesDeltaPass, "Reducing GlobalValues")
29+
DELTA_PASS_IR("global-objects", reduceGlobalObjectsDeltaPass, "Reducing GlobalObjects")
30+
DELTA_PASS_IR("global-initializers", reduceGlobalsInitializersDeltaPass, "Reducing GV Initializers")
31+
DELTA_PASS_IR("global-variables", reduceGlobalsDeltaPass, "Reducing GlobalVariables")
32+
DELTA_PASS_IR("di-metadata", reduceDIMetadataDeltaPass, "Reducing DIMetadata")
33+
DELTA_PASS_IR("dbg-records", reduceDbgRecordDeltaPass, "Reducing DbgRecords")
34+
DELTA_PASS_IR("distinct-metadata", reduceDistinctMetadataDeltaPass, "Reducing Distinct Metadata")
35+
DELTA_PASS_IR("metadata", reduceMetadataDeltaPass,"Reducing Metadata")
36+
DELTA_PASS_IR("named-metadata", reduceNamedMetadataDeltaPass, "Reducing Named Metadata")
37+
DELTA_PASS_IR("arguments", reduceArgumentsDeltaPass, "Reducing Arguments")
38+
DELTA_PASS_IR("instructions", reduceInstructionsDeltaPass, "Reducing Instructions")
39+
DELTA_PASS_IR("simplify-instructions", simplifyInstructionsDeltaPass, "Simplifying Instructions")
40+
DELTA_PASS_IR("ir-passes", runIRPassesDeltaPass, "Running passes")
41+
DELTA_PASS_IR("operands-zero", reduceOperandsZeroDeltaPass, "Reducing Operands to zero")
42+
DELTA_PASS_IR("operands-one", reduceOperandsOneDeltaPass, "Reducing Operands to one")
43+
DELTA_PASS_IR("operands-nan", reduceOperandsNaNDeltaPass, "Reducing Operands to NaN")
44+
DELTA_PASS_IR("operands-to-args", reduceOperandsToArgsDeltaPass, "Converting operands to function arguments")
45+
DELTA_PASS_IR("operands-skip", reduceOperandsSkipDeltaPass, "Reducing operands by skipping over instructions")
46+
DELTA_PASS_IR("operand-bundles", reduceOperandBundesDeltaPass, "Reducing Operand Bundles")
47+
DELTA_PASS_IR("attributes", reduceAttributesDeltaPass, "Reducing Attributes")
48+
DELTA_PASS_IR("module-data", reduceModuleDataDeltaPass, "Reducing Module Data")
49+
DELTA_PASS_IR("opcodes", reduceOpcodesDeltaPass, "Reducing Opcodes")
50+
DELTA_PASS_IR("volatile", reduceVolatileInstructionsDeltaPass, "Reducing Volatile Instructions")
51+
DELTA_PASS_IR("atomic-ordering", reduceAtomicOrderingDeltaPass, "Reducing Atomic Ordering")
52+
DELTA_PASS_IR("syncscopes", reduceAtomicSyncScopesDeltaPass, "Reducing Atomic Sync Scopes")
53+
DELTA_PASS_IR("instruction-flags", reduceInstructionFlagsDeltaPass, "Reducing Instruction Flags")
54+
55+
56+
#ifndef DELTA_PASS_MIR
57+
#define DELTA_PASS_MIR(NAME, FUNC, DESC)
58+
#endif
59+
DELTA_PASS_MIR("instructions", reduceInstructionsMIRDeltaPass, "Reducing Instructions")
60+
DELTA_PASS_MIR("ir-instruction-references",
61+
reduceIRInstructionReferencesDeltaPass, "Reducing IR references from instructions")
62+
DELTA_PASS_MIR("ir-block-references", reduceIRBlockReferencesDeltaPass, "Reducing IR references from blocks")
63+
DELTA_PASS_MIR("ir-function-references", reduceIRFunctionReferencesDeltaPass, "Reducing IR references from functions")
64+
DELTA_PASS_MIR("instruction-flags", reduceInstructionFlagsMIRDeltaPass, "Reducing Instruction Flags")
65+
DELTA_PASS_MIR("register-uses", reduceRegisterUsesMIRDeltaPass, "Reducing register uses")
66+
DELTA_PASS_MIR("register-defs", reduceRegisterDefsMIRDeltaPass, "Reducing register defs")
67+
DELTA_PASS_MIR("register-hints", reduceVirtualRegisterHintsDeltaPass, "Reducing virtual register hints from functions")
68+
DELTA_PASS_MIR("register-masks", reduceRegisterMasksMIRDeltaPass, "Reducing register masks")

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

Lines changed: 11 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@
1313
//===----------------------------------------------------------------------===//
1414

1515
#include "Delta.h"
16+
#include "DeltaPass.h"
1617
#include "ReducerWorkItem.h"
1718
#include "TestRunner.h"
1819
#include "Utils.h"
@@ -180,11 +181,10 @@ using SharedTaskQueue = std::deque<std::shared_future<SmallString<0>>>;
180181
/// reduces the amount of chunks that are considered interesting by the
181182
/// given test. The number of chunks is determined by a preliminary run of the
182183
/// reduction pass where no change must be made to the module.
183-
void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
184-
StringRef Message) {
184+
void llvm::runDeltaPass(TestRunner &Test, const DeltaPass &Pass) {
185185
assert(!Test.getProgram().verify(&errs()) &&
186186
"input module is broken before making changes");
187-
errs() << "*** " << Message << "...\n";
187+
errs() << "*** " << Pass.Desc << " (" << Pass.Name << ")...\n";
188188

189189
int Targets;
190190
{
@@ -193,7 +193,7 @@ void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
193193
// made.
194194
std::vector<Chunk> AllChunks = {{0, INT_MAX}};
195195
Oracle Counter(AllChunks);
196-
ExtractChunksFromModule(Counter, Test.getProgram());
196+
Pass.Func(Counter, Test.getProgram());
197197
Targets = Counter.count();
198198

199199
assert(!Test.getProgram().verify(&errs()) &&
@@ -215,7 +215,7 @@ void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
215215
Oracle NoChunksCounter(NoChunks);
216216
std::unique_ptr<ReducerWorkItem> Clone =
217217
Test.getProgram().clone(Test.getTargetMachine());
218-
ExtractChunksFromModule(NoChunksCounter, *Clone);
218+
Pass.Func(NoChunksCounter, *Clone);
219219
assert(Targets == NoChunksCounter.count() &&
220220
"number of chunks changes when reducing");
221221
#endif
@@ -281,9 +281,8 @@ void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
281281
Chunk ChunkToCheck = *(I + J);
282282
TaskQueue.emplace_back(ChunkThreadPool.async(
283283
ProcessChunkFromSerializedBitcode, ChunkToCheck, std::ref(Test),
284-
ExtractChunksFromModule, UninterestingChunks,
285-
ChunksStillConsideredInteresting, OriginalBC,
286-
std::ref(AnyReduced)));
284+
Pass.Func, UninterestingChunks, ChunksStillConsideredInteresting,
285+
OriginalBC, std::ref(AnyReduced)));
287286
}
288287

289288
// Start processing results of the queued tasks. We wait for the first
@@ -305,7 +304,7 @@ void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
305304
Chunk ChunkToCheck = *(I + NumScheduledTasks);
306305
TaskQueue.emplace_back(ChunkThreadPool.async(
307306
ProcessChunkFromSerializedBitcode, ChunkToCheck,
308-
std::ref(Test), ExtractChunksFromModule, UninterestingChunks,
307+
std::ref(Test), Pass.Func, UninterestingChunks,
309308
ChunksStillConsideredInteresting, OriginalBC,
310309
std::ref(AnyReduced)));
311310
}
@@ -330,10 +329,9 @@ void llvm::runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
330329
// Forward I to the last chunk processed in parallel.
331330
I += NumChunksProcessed - 1;
332331
} else {
333-
Result =
334-
CheckChunk(*I, Test.getProgram().clone(Test.getTargetMachine()),
335-
Test, ExtractChunksFromModule, UninterestingChunks,
336-
ChunksStillConsideredInteresting);
332+
Result = CheckChunk(
333+
*I, Test.getProgram().clone(Test.getTargetMachine()), Test,
334+
Pass.Func, UninterestingChunks, ChunksStillConsideredInteresting);
337335
}
338336

339337
if (!Result)

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@
2424
namespace llvm {
2525

2626
class TestRunner;
27+
struct DeltaPass;
2728

2829
struct Chunk {
2930
int Begin;
@@ -134,8 +135,7 @@ using ReductionFunc = function_ref<void(Oracle &, ReducerWorkItem &)>;
134135
///
135136
/// Other implementations of the Delta Debugging algorithm can also be found in
136137
/// the CReduce, Delta, and Lithium projects.
137-
void runDeltaPass(TestRunner &Test, ReductionFunc ExtractChunksFromModule,
138-
StringRef Message);
138+
void runDeltaPass(TestRunner &Test, const DeltaPass &Pass);
139139
} // namespace llvm
140140

141141
#endif

0 commit comments

Comments
 (0)