mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-29 23:46:06 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/llvm/tools/llvm-reduce/DeltaManager.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

227 lines
9.7 KiB
C++
Raw Normal View History

[llvm-reduce] Add header guards and fix clang-tidy warnings Add header guards and fix other clang-tidy warnings in .h files. Also align misaligned header docs Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D99634
2021-04-01 20:38:39 -07:00
//===- DeltaManager.cpp - Runs Delta Passes to reduce Input ---------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file calls each specialized Delta pass in order to reduce the input IR
// file.
//
//===----------------------------------------------------------------------===//
#include "DeltaManager.h"
[tools] Forward declare classes & remove includes Reviewed By: MaskRay Differential Revision: https://reviews.llvm.org/D120208
2022-06-03 16:32:04 -07:00
#include "ReducerWorkItem.h"
[llvm-reduce] Add header guards and fix clang-tidy warnings Add header guards and fix other clang-tidy warnings in .h files. Also align misaligned header docs Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D99634
2021-04-01 20:38:39 -07:00
#include "TestRunner.h"
#include "deltas/Delta.h"
#include "deltas/ReduceAliases.h"
#include "deltas/ReduceArguments.h"
#include "deltas/ReduceAttributes.h"
#include "deltas/ReduceBasicBlocks.h"
[llvm-reduce] Add pass that reduces DebugInfo metadata This new pass for llvm-reduce attempts to reduce DebugInfo metadata. The process used is: 1. Scan every MD node, keeping track of nodes already visited. 2. Look for DebugInfo nodes, then record any operands that are lists. 3. Bisect though all the elements of the collected lists. Differential Revision: https://reviews.llvm.org/D132077
2022-10-06 14:20:13 -07:00
#include "deltas/ReduceDIMetadata.h"
[llvm-reduce] Add header guards and fix clang-tidy warnings Add header guards and fix other clang-tidy warnings in .h files. Also align misaligned header docs Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D99634
2021-04-01 20:38:39 -07:00
#include "deltas/ReduceFunctionBodies.h"
#include "deltas/ReduceFunctions.h"
[llvm-reduce] Reduce some GlobalObject properties Specifically, the section and the alignment. Reviewed By: hans Differential Revision: https://reviews.llvm.org/D112884
2021-10-30 19:27:35 -07:00
#include "deltas/ReduceGlobalObjects.h"
[llvm-reduce] Add header guards and fix clang-tidy warnings Add header guards and fix other clang-tidy warnings in .h files. Also align misaligned header docs Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D99634
2021-04-01 20:38:39 -07:00
#include "deltas/ReduceGlobalValues.h"
#include "deltas/ReduceGlobalVarInitializers.h"
#include "deltas/ReduceGlobalVars.h"
llvm-reduce: Add pass to reduce IR references from MIR This is typically the first thing I do when reducing a new testcase until the IR section can be deleted.
2022-04-19 12:10:38 -04:00
#include "deltas/ReduceIRReferences.h"
llvm-reduce: Add flag reduction pass Try to remove each flag from instructions. It may make more sense to introduce these flags instead.
2022-10-21 10:37:52 -07:00
#include "deltas/ReduceInstructionFlags.h"
llvm-reduce: Add pass to reduce MIR instruction flags
2022-04-19 16:42:27 -04:00
#include "deltas/ReduceInstructionFlagsMIR.h"
[llvm-reduce] Add header guards and fix clang-tidy warnings Add header guards and fix other clang-tidy warnings in .h files. Also align misaligned header docs Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D99634
2021-04-01 20:38:39 -07:00
#include "deltas/ReduceInstructions.h"
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
#include "deltas/ReduceInstructionsMIR.h"
llvm-reduce: Add reduction for invokes Main thing I was unsure about was to whether try to delete the now dead landing blocks, or leave that for the unreachable block reduction. Personality function is not reduced, but that should be a separate reduction on the function. Fixes #58815
2023-01-01 21:29:20 -05:00
#include "deltas/ReduceInvokes.h"
llvm-reduce: Add volatile reduction pass Removing volatile may help optimization passes do more to the IR. However, this will increase scheduler freedom.
2022-10-21 14:03:51 -07:00
#include "deltas/ReduceMemoryOperations.h"
[llvm-reduce] Add header guards and fix clang-tidy warnings Add header guards and fix other clang-tidy warnings in .h files. Also align misaligned header docs Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D99634
2021-04-01 20:38:39 -07:00
#include "deltas/ReduceMetadata.h"
[llvm-reduce] Remove various module data This removes the data layout, target triple, source filename, and module identifier when possible. Reviewed By: swamulism Differential Revision: https://reviews.llvm.org/D108568
2021-08-23 10:58:16 -07:00
#include "deltas/ReduceModuleData.h"
llvm-reduce: Add opcode reduction pass Try some dumb strength reductions to "simpler" opcodes. Make some opcode substitutions I typically try to get smaller MIR out of codegen. This is a bit target specific and I have a lot of increasingly target specific modifications I try during manual reduction.
2022-10-10 19:42:17 -07:00
#include "deltas/ReduceOpcodes.h"
[llvm-reduce] Add header guards and fix clang-tidy warnings Add header guards and fix other clang-tidy warnings in .h files. Also align misaligned header docs Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D99634
2021-04-01 20:38:39 -07:00
#include "deltas/ReduceOperandBundles.h"
[llvm-reduce] Add reduce operands pass Add reduction to set operands to default values Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D108903
2021-09-17 12:18:03 -07:00
#include "deltas/ReduceOperands.h"
[llvm-reduce] Introduce operands-skip pass. Add a new "operands-skip" pass whose goal is to remove instructions in the middle of dependency chains. For instance: ``` %baseptr = alloca i32 %arrayidx = getelementptr i32, i32* %baseptr, i32 %idxprom store i32 42, i32* %arrayidx ``` might be reducible to ``` %baseptr = alloca i32 %arrayidx = getelementptr ... ; now dead, together with the computation of %idxprom store i32 42, i32* %baseptr ``` Other passes would either replace `%baseptr` with undef (operands, instructions) or move it to become a function argument (operands-to-args), both of which might fail the interestingness check. In principle the implementation allows operand replacement with any value or instruction in the function that passes the filter constraints (same type, dominance, "more reduced"), but is limited in this patch to values that are directly or indirectly used to compute the current operand value, motivated by the example above. Additionally, function arguments are added to the candidate set which helps reducing the number of relevant arguments mitigating a concern of too many arguments mentioned in https://reviews.llvm.org/D110274#3025013. Possible future extensions: * Instead of requiring the same type, bitcast/trunc/zext could be automatically inserted for some more flexibility. * If undef is added to the candidate set, "operands-skip"is able to produce any reduction that "operands" can do. Additional candidates might be zero and one, where the "reductive power" classification can prefer one over the other. If undefined behaviour should not be introduced, undef can be removed from the candidate set. Recommit after resolving conflict with D112651 and reusing shouldReduceOperand from D113532. Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D111818
2021-11-11 18:23:27 -06:00
#include "deltas/ReduceOperandsSkip.h"
[llvm-reduce] Introduce operands-to-args pass. Instead of setting operands to undef as the "operands" pass does, convert the operands to a function argument. This avoids having to introduce undef values into the IR which have some unpredictability during optimizations. For instance, define void @func() { entry: %val = add i32 32, 21 store i32 %val, i32* null ret void } is reduced to define void @func(i32 %val) { entry: %val1 = add i32 32, 21 store i32 %val, i32* null ret void } (note that the instruction %val is renamed to %val1 when printing the IR to avoid ambiguity; ideally %val1 would be removed by dce or the instruction reduction pass) Any call to @func is replaced with a call to the function with the new signature and filled with undef. This is not ideal for IPA passes, but those out-of-scope for now. Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D111503
2021-10-13 09:05:54 -05:00
#include "deltas/ReduceOperandsToArgs.h"
llvm-reduce: Add reduction for instruction defs Try to insert an implicit_def to replace the instruction's value, replacing the original instruction's def with a dead register. If all defs are delete the instruction entirely. This is pretty similar to the instruction reduction, but leaves the new defs in the same place as the original instruction. This could possibly replace it. I'm not sure if we should directly delete the instructions here, or leave dead ones behind. This could also further work to replace physical register defs.
2022-06-27 14:28:33 -04:00
#include "deltas/ReduceRegisterDefs.h"
llvm-reduce: Add reduction for custom register masks I have a register allocator failure that only reproduces with IPRA enabled, and requires the specific regmask if I want to only run the one relevant pass. The printed custom regmask is enormous and I would like to reduce it. This reduces each individual bit in the mask, but it would probably be better to start at register units and clear all aliasing fields at a time. This would require stricter verification that all aliasing bits are set in regmasks (although I would prefer to switch regmasks to use register units in the first place).
2022-06-22 13:13:17 -04:00
#include "deltas/ReduceRegisterMasks.h"
llvm-reduce: Add pass to remove register uses Try to delete implicit uses, and add undef flags to explicit ones.
2022-04-22 11:44:37 -04:00
#include "deltas/ReduceRegisterUses.h"
[llvm-reduce] Add header guards and fix clang-tidy warnings Add header guards and fix other clang-tidy warnings in .h files. Also align misaligned header docs Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D99634
2021-04-01 20:38:39 -07:00
#include "deltas/ReduceSpecialGlobals.h"
this pass calls simplifyCFG on individual basic blocks; we want this so that we can reduce away incidental parts of the CFG in cases where the full simplifyCFG pass makes the test case uninteresting Differential Revision: https://reviews.llvm.org/D131920
2022-08-15 15:45:20 -06:00
#include "deltas/ReduceUsingSimplifyCFG.h"
llvm-reduce: Add reduction pass to remove regalloc hints I'm a bit confused by what's actually stored for the allocation hints. The MIR parser only handles the "simple" case where there's a single hint. I don't really understand the assertion in clearSimpleHint, or under what circumstances there are multiple hint registers.
2022-04-20 11:37:53 -04:00
#include "deltas/ReduceVirtualRegisters.h"
[llvm-reduce] Add delta pass to run IR passes The exact IR passes run is customizable via `-ir-passes`. Reviewed By: regehr Differential Revision: https://reviews.llvm.org/D123749
2022-04-13 17:36:58 -07:00
#include "deltas/RunIRPasses.h"
llvm-reduce: Add reduction pass to simplify instructions
2022-06-08 22:09:47 -04:00
#include "deltas/SimplifyInstructions.h"
[llvm-reduce] Attempt to strip debug info I often run llvm-reduce on IR that contains debug info, this prevents an extra step of `opt -passes=strip` I do every time and will result in a lot less invalid reductions around debug metadata. Reviewed By: dblaikie Differential Revision: https://reviews.llvm.org/D136208
2022-10-18 15:42:14 -07:00
#include "deltas/StripDebugInfo.h"
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
#include "llvm/Support/CommandLine.h"
[llvm-reduce] Add header guards and fix clang-tidy warnings Add header guards and fix other clang-tidy warnings in .h files. Also align misaligned header docs Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D99634
2021-04-01 20:38:39 -07:00
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
using namespace llvm;
llvm-reduce: Improve delta pass flag handling Verify all the requested passes exist before trying to run any. For long reductions, it was really annoying for it to get halfway through and then I come back later to an incomplete reduction. Also add a new skip-delta-passes flag. Most of the time I want to opt out of specific reductions, rather than run a select few.
2022-10-10 11:02:47 -07:00
using SmallStringSet = SmallSet<StringRef, 8>;
[llvm-reduce] Display all relevant options in -help Previously the options category given to cl::HideUnrelatedOptions was local to llvm-reduce.cpp and as a result only options declared in that file were visible in the -help options listing. This was a bit unfortunate since there were several useful options declared in other files. This patch addresses that. Differential Revision: https://reviews.llvm.org/D118682
2022-02-02 09:31:29 +01:00
extern cl::OptionCategory LLVMReduceOptions;
llvm-reduce: Improve delta pass flag handling Verify all the requested passes exist before trying to run any. For long reductions, it was really annoying for it to get halfway through and then I come back later to an incomplete reduction. Also add a new skip-delta-passes flag. Most of the time I want to opt out of specific reductions, rather than run a select few.
2022-10-10 11:02:47 -07:00
static cl::list<std::string>
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
DeltaPasses("delta-passes",
cl::desc("Delta passes to run, separated by commas. By "
[llvm-reduce] Display all relevant options in -help Previously the options category given to cl::HideUnrelatedOptions was local to llvm-reduce.cpp and as a result only options declared in that file were visible in the -help options listing. This was a bit unfortunate since there were several useful options declared in other files. This patch addresses that. Differential Revision: https://reviews.llvm.org/D118682
2022-02-02 09:31:29 +01:00
"default, run all delta passes."),
llvm-reduce: Improve delta pass flag handling Verify all the requested passes exist before trying to run any. For long reductions, it was really annoying for it to get halfway through and then I come back later to an incomplete reduction. Also add a new skip-delta-passes flag. Most of the time I want to opt out of specific reductions, rather than run a select few.
2022-10-10 11:02:47 -07:00
cl::cat(LLVMReduceOptions), cl::CommaSeparated);
static cl::list<std::string>
SkipDeltaPasses("skip-delta-passes",
cl::desc("Delta passes to not run, separated by commas. By "
"default, run all delta passes."),
cl::cat(LLVMReduceOptions), cl::CommaSeparated);
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
#define DELTA_PASSES \
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
do { \
[llvm-reduce] Attempt to strip debug info I often run llvm-reduce on IR that contains debug info, this prevents an extra step of `opt -passes=strip` I do every time and will result in a lot less invalid reductions around debug metadata. Reviewed By: dblaikie Differential Revision: https://reviews.llvm.org/D136208
2022-10-18 15:42:14 -07:00
DELTA_PASS("strip-debug-info", stripDebugInfoDeltaPass) \
llvm-reduce: reorder passes to run the ones first that delete function bodies; this makes reductions go faster
2022-08-02 10:32:49 -06:00
DELTA_PASS("functions", reduceFunctionsDeltaPass) \
DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass) \
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass) \
DELTA_PASS("aliases", reduceAliasesDeltaPass) \
llvm-reduce: Reduce ifuncs Reduce by calling the resolver function at the use site, and inserting an indirect call. Try to delete if there are no uses left over. We should also probably try to do something about constantexpr uses; perhaps treat them like aliases.
2022-11-22 16:55:44 -05:00
DELTA_PASS("ifuncs", reduceIFuncsDeltaPass) \
llvm-reduce: Add conditional reduction passes Copy this technique from bugpoint. Before trying to blindly delete blocks, try to fold branch conditions. This intuitively makes more sense for a faster reduction, since you can find dead paths in the function to prune out before trying to bisect blocks in source order. Seems to provide some speedup on my multi-hour reduction samples. This does have the potential to produce testcases with unreachable blocks. This is already a problem with the existing block reduction pass. I'm struggling dealing with invalid reductions in these cases, so in the future this should probably start deleting those. However, I do sometimes try to reduce failures in code that becomes unreachable, so I'm not totally sure what to do here.
2022-10-13 14:42:15 -07:00
DELTA_PASS("simplify-conditionals-true", reduceConditionalsTrueDeltaPass) \
DELTA_PASS("simplify-conditionals-false", reduceConditionalsFalseDeltaPass)\
llvm-reduce: Add reduction for invokes Main thing I was unsure about was to whether try to delete the now dead landing blocks, or leave that for the unreachable block reduction. Personality function is not reduced, but that should be a separate reduction on the function. Fixes #58815
2023-01-01 21:29:20 -05:00
DELTA_PASS("invokes", reduceInvokesDeltaPass) \
llvm-reduce: Fix block reduction with unreachable blocks Previously this would produce many invalid reductions with "Instruction does not dominate uses" verifier errors. This fixes issues in cases where the incoming IR has unreachable blocks, and the resulting reduction introduced new reachable blocks. Have basic-blocks skip functions that have unreachable blocks, Introduce a separate reduction which only deletes unreachable blocks. Cleanup any newly unreachable blocks after trimming out the requested deletions. Includes a variety of meta-reduced tests for llvm-reduce itself with -abort-on-invalid-reduction that were failing on different iterations of this patch. Bugpoint's implementation is much simpler (but currently I don't understand how it avoids disconnecting interesting blocks from the CFG).
2022-10-03 22:06:09 -07:00
DELTA_PASS("unreachable-basic-blocks", reduceUnreachableBasicBlocksDeltaPass) \
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass) \
llvm-reduce: Fix block reduction with unreachable blocks Previously this would produce many invalid reductions with "Instruction does not dominate uses" verifier errors. This fixes issues in cases where the incoming IR has unreachable blocks, and the resulting reduction introduced new reachable blocks. Have basic-blocks skip functions that have unreachable blocks, Introduce a separate reduction which only deletes unreachable blocks. Cleanup any newly unreachable blocks after trimming out the requested deletions. Includes a variety of meta-reduced tests for llvm-reduce itself with -abort-on-invalid-reduction that were failing on different iterations of this patch. Bugpoint's implementation is much simpler (but currently I don't understand how it avoids disconnecting interesting blocks from the CFG).
2022-10-03 22:06:09 -07:00
DELTA_PASS("simplify-cfg", reduceUsingSimplifyCFGDeltaPass) \
llvm-reduce: Add reduction for function personalities Fixes second piece of #58815
2023-01-02 08:25:26 -05:00
DELTA_PASS("function-data", reduceFunctionDataDeltaPass) \
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASS("global-values", reduceGlobalValuesDeltaPass) \
DELTA_PASS("global-objects", reduceGlobalObjectsDeltaPass) \
DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass) \
DELTA_PASS("global-variables", reduceGlobalsDeltaPass) \
[llvm-reduce] Add pass that reduces DebugInfo metadata This new pass for llvm-reduce attempts to reduce DebugInfo metadata. The process used is: 1. Scan every MD node, keeping track of nodes already visited. 2. Look for DebugInfo nodes, then record any operands that are lists. 3. Bisect though all the elements of the collected lists. Differential Revision: https://reviews.llvm.org/D132077
2022-10-06 14:20:13 -07:00
DELTA_PASS("di-metadata", reduceDIMetadataDeltaPass) \
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASS("metadata", reduceMetadataDeltaPass) \
llvm-reduce: Reduce individual operands of named metadata The current reduction tries all or nothing elimination of named metadata. I noticed in one case where one of the module flags was necessary, but it left the rest. Reduce the individual operands of named metadata nodes that are known to behave like lists. Be conservative since some named metadata may have more specific verifier requirements for the operands.
2023-01-01 10:52:02 -05:00
DELTA_PASS("named-metadata", reduceNamedMetadataDeltaPass) \
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASS("arguments", reduceArgumentsDeltaPass) \
DELTA_PASS("instructions", reduceInstructionsDeltaPass) \
DELTA_PASS("simplify-instructions", simplifyInstructionsDeltaPass) \
[llvm-reduce] Add delta pass to run IR passes The exact IR passes run is customizable via `-ir-passes`. Reviewed By: regehr Differential Revision: https://reviews.llvm.org/D123749
2022-04-13 17:36:58 -07:00
DELTA_PASS("ir-passes", runIRPassesDeltaPass) \
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
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) \
llvm-reduce: Add opcode reduction pass Try some dumb strength reductions to "simpler" opcodes. Make some opcode substitutions I typically try to get smaller MIR out of codegen. This is a bit target specific and I have a lot of increasingly target specific modifications I try during manual reduction.
2022-10-10 19:42:17 -07:00
DELTA_PASS("opcodes", reduceOpcodesDeltaPass) \
llvm-reduce: Add volatile reduction pass Removing volatile may help optimization passes do more to the IR. However, this will increase scheduler freedom.
2022-10-21 14:03:51 -07:00
DELTA_PASS("volatile", reduceVolatileInstructionsDeltaPass) \
llvm-reduce: Add a reduction to replace atomics with non-atomics Make load and store non-atomic. Make the others monotonic. We could probably try to incrementally relax the orderings; not sure how useful that would be.
2022-10-21 14:59:07 -07:00
DELTA_PASS("atomic-ordering", reduceAtomicOrderingDeltaPass) \
llvm-reduce: Add atomic syncscope reduction
2022-10-21 14:45:28 -07:00
DELTA_PASS("syncscopes", reduceAtomicSyncScopesDeltaPass) \
llvm-reduce: Add flag reduction pass Try to remove each flag from instructions. It may make more sense to introduce these flags instead.
2022-10-21 10:37:52 -07:00
DELTA_PASS("instruction-flags", reduceInstructionFlagsDeltaPass) \
} while (false)
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
#define DELTA_PASSES_MIR \
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
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) \
llvm-reduce: Add reduction for instruction defs Try to insert an implicit_def to replace the instruction's value, replacing the original instruction's def with a dead register. If all defs are delete the instruction entirely. This is pretty similar to the instruction reduction, but leaves the new defs in the same place as the original instruction. This could possibly replace it. I'm not sure if we should directly delete the instructions here, or leave dead ones behind. This could also further work to replace physical register defs.
2022-06-27 14:28:33 -04:00
DELTA_PASS("register-defs", reduceRegisterDefsMIRDeltaPass) \
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASS("register-hints", reduceVirtualRegisterHintsDeltaPass) \
llvm-reduce: Add reduction for custom register masks I have a register allocator failure that only reproduces with IPRA enabled, and requires the specific regmask if I want to only run the one relevant pass. The printed custom regmask is enormous and I would like to reduce it. This reduces each individual bit in the mask, but it would probably be better to start at register units and clear all aliasing fields at a time. This would require stricter verification that all aliasing bits are set in regmasks (although I would prefer to switch regmasks to use register units in the first place).
2022-06-22 13:13:17 -04:00
DELTA_PASS("register-masks", reduceRegisterMasksMIRDeltaPass) \
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
} while (false)
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
llvm-reduce: Improve delta pass flag handling Verify all the requested passes exist before trying to run any. For long reductions, it was really annoying for it to get halfway through and then I come back later to an incomplete reduction. Also add a new skip-delta-passes flag. Most of the time I want to opt out of specific reductions, rather than run a select few.
2022-10-10 11:02:47 -07:00
static void runAllDeltaPasses(TestRunner &Tester,
const SmallStringSet &SkipPass) {
#define DELTA_PASS(NAME, FUNC) \
if (!SkipPass.count(NAME)) { \
FUNC(Tester); \
}
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
if (Tester.getProgram().isMIR()) {
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASSES_MIR;
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
} else {
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASSES;
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
}
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
#undef DELTA_PASS
}
static void runDeltaPassName(TestRunner &Tester, StringRef PassName) {
#define DELTA_PASS(NAME, FUNC) \
if (PassName == NAME) { \
FUNC(Tester); \
return; \
}
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
if (Tester.getProgram().isMIR()) {
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASSES_MIR;
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
} else {
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASSES;
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
}
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
#undef DELTA_PASS
llvm-reduce: Improve delta pass flag handling Verify all the requested passes exist before trying to run any. For long reductions, it was really annoying for it to get halfway through and then I come back later to an incomplete reduction. Also add a new skip-delta-passes flag. Most of the time I want to opt out of specific reductions, rather than run a select few.
2022-10-10 11:02:47 -07:00
// We should have errored on unrecognized passes before trying to run
// anything.
llvm_unreachable("unknown delta pass");
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
}
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";
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
OS << " IR:\n";
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASSES;
Recommit "[llvm-reduce] Add MIR support" (Second try. Need to link against CodeGen and MC libs.) The llvm-reduce tool has been extended to operate on MIR (import, clone and export). Current limitation is that only a single machine function is supported. A single reducer pass that operates on machine instructions (while on SSA-form) has been added. Additional MIR specific reducer passes can be added later as needed. Differential Revision: https://reviews.llvm.org/D110527
2021-11-02 10:11:54 +01:00
OS << " MIR:\n";
[llvm] Wrap multi-statement macro definitions with do ... while (0)
2022-07-16 20:57:44 -07:00
DELTA_PASSES_MIR;
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
#undef DELTA_PASS
}
llvm-reduce: Improve delta pass flag handling Verify all the requested passes exist before trying to run any. For long reductions, it was really annoying for it to get halfway through and then I come back later to an incomplete reduction. Also add a new skip-delta-passes flag. Most of the time I want to opt out of specific reductions, rather than run a select few.
2022-10-10 11:02:47 -07:00
// 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;
}
#undef DELTA_PASS
}
/// Verify all requested or skipped passes are valid names, and return them in a
/// set.
static SmallStringSet handlePassList(const TestRunner &Tester,
const cl::list<std::string> &PassList) {
SmallStringSet AllPasses;
collectPassNames(Tester, AllPasses);
SmallStringSet PassSet;
for (StringRef PassName : PassList) {
if (!AllPasses.count(PassName)) {
errs() << "unknown pass \"" << PassName << "\"\n";
exit(1);
}
PassSet.insert(PassName);
}
return PassSet;
}
allow llvm-reduce, if asked, to run its set of passes more than once, taking longer to finish but also potentially resulting in a smaller reduced file.
2022-01-10 22:24:23 -07:00
void llvm::runDeltaPasses(TestRunner &Tester, int MaxPassIterations) {
llvm-reduce: Introduce new scoring mechanism for MIR reductions Many MIR reductions benefit from or require increasing the instruction count. For example, unlike in the IR, you may need to insert a new instruction to represent an undef. The current instruction reduction pass works around this by sticking implicit defs on whatever instruction happens to be first in the entry block block. Other strategies I've applied manually include breaking instructions with multiple defs into separate instructions, or breaking large register defs into multiple subregister defs. Make up a simple scoring system based on what I generally try to get rid of first when manually reducing. Counts implicit defs as free since reduction passes will be introducing them, although they probably should count for something. It also might make more sense to have a comparison the two functions, rather than having to compute a contextless number. This isn't particularly well tested since overall the MIR support isn't in a place where it is useful on the kinds of testcases I want to throw at it.
2022-04-19 17:19:36 -04:00
uint64_t OldComplexity = Tester.getProgram().getComplexityScore();
llvm-reduce: Improve delta pass flag handling Verify all the requested passes exist before trying to run any. For long reductions, it was really annoying for it to get halfway through and then I come back later to an incomplete reduction. Also add a new skip-delta-passes flag. Most of the time I want to opt out of specific reductions, rather than run a select few.
2022-10-10 11:02:47 -07:00
SmallStringSet RunPassSet, SkipPassSet;
if (!DeltaPasses.empty())
RunPassSet = handlePassList(Tester, DeltaPasses);
if (!SkipDeltaPasses.empty())
SkipPassSet = handlePassList(Tester, SkipDeltaPasses);
allow llvm-reduce, if asked, to run its set of passes more than once, taking longer to finish but also potentially resulting in a smaller reduced file.
2022-01-10 22:24:23 -07:00
for (int Iter = 0; Iter < MaxPassIterations; ++Iter) {
if (DeltaPasses.empty()) {
llvm-reduce: Improve delta pass flag handling Verify all the requested passes exist before trying to run any. For long reductions, it was really annoying for it to get halfway through and then I come back later to an incomplete reduction. Also add a new skip-delta-passes flag. Most of the time I want to opt out of specific reductions, rather than run a select few.
2022-10-10 11:02:47 -07:00
runAllDeltaPasses(Tester, SkipPassSet);
allow llvm-reduce, if asked, to run its set of passes more than once, taking longer to finish but also potentially resulting in a smaller reduced file.
2022-01-10 22:24:23 -07:00
} else {
llvm-reduce: Improve delta pass flag handling Verify all the requested passes exist before trying to run any. For long reductions, it was really annoying for it to get halfway through and then I come back later to an incomplete reduction. Also add a new skip-delta-passes flag. Most of the time I want to opt out of specific reductions, rather than run a select few.
2022-10-10 11:02:47 -07:00
for (StringRef PassName : DeltaPasses) {
if (!SkipPassSet.count(PassName))
runDeltaPassName(Tester, PassName);
allow llvm-reduce, if asked, to run its set of passes more than once, taking longer to finish but also potentially resulting in a smaller reduced file.
2022-01-10 22:24:23 -07:00
}
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
}
llvm-reduce: Improve delta pass flag handling Verify all the requested passes exist before trying to run any. For long reductions, it was really annoying for it to get halfway through and then I come back later to an incomplete reduction. Also add a new skip-delta-passes flag. Most of the time I want to opt out of specific reductions, rather than run a select few.
2022-10-10 11:02:47 -07:00
llvm-reduce: Introduce new scoring mechanism for MIR reductions Many MIR reductions benefit from or require increasing the instruction count. For example, unlike in the IR, you may need to insert a new instruction to represent an undef. The current instruction reduction pass works around this by sticking implicit defs on whatever instruction happens to be first in the entry block block. Other strategies I've applied manually include breaking instructions with multiple defs into separate instructions, or breaking large register defs into multiple subregister defs. Make up a simple scoring system based on what I generally try to get rid of first when manually reducing. Counts implicit defs as free since reduction passes will be introducing them, although they probably should count for something. It also might make more sense to have a comparison the two functions, rather than having to compute a contextless number. This isn't particularly well tested since overall the MIR support isn't in a place where it is useful on the kinds of testcases I want to throw at it.
2022-04-19 17:19:36 -04:00
uint64_t NewComplexity = Tester.getProgram().getComplexityScore();
if (NewComplexity >= OldComplexity)
allow llvm-reduce, if asked, to run its set of passes more than once, taking longer to finish but also potentially resulting in a smaller reduced file.
2022-01-10 22:24:23 -07:00
break;
llvm-reduce: Introduce new scoring mechanism for MIR reductions Many MIR reductions benefit from or require increasing the instruction count. For example, unlike in the IR, you may need to insert a new instruction to represent an undef. The current instruction reduction pass works around this by sticking implicit defs on whatever instruction happens to be first in the entry block block. Other strategies I've applied manually include breaking instructions with multiple defs into separate instructions, or breaking large register defs into multiple subregister defs. Make up a simple scoring system based on what I generally try to get rid of first when manually reducing. Counts implicit defs as free since reduction passes will be introducing them, although they probably should count for something. It also might make more sense to have a comparison the two functions, rather than having to compute a contextless number. This isn't particularly well tested since overall the MIR support isn't in a place where it is useful on the kinds of testcases I want to throw at it.
2022-04-19 17:19:36 -04:00
OldComplexity = NewComplexity;
[llvm-reduce] Add flag to only run specific passes Reviewed By: fhahn, hans Differential Revision: https://reviews.llvm.org/D101278
2021-04-30 11:48:03 -07:00
}
[llvm-reduce] Add header guards and fix clang-tidy warnings Add header guards and fix other clang-tidy warnings in .h files. Also align misaligned header docs Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D99634
2021-04-01 20:38:39 -07:00
}
Reference in New Issue Copy Permalink