1//===- DeltaManager.cpp - Runs Delta Passes to reduce Input ---------------===// 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// This file calls each specialized Delta pass in order to reduce the input IR 10// file. 11// 12//===----------------------------------------------------------------------===// 13 14#include "DeltaManager.h" 15#include "ReducerWorkItem.h" 16#include "TestRunner.h" 17#include "deltas/Delta.h" 18#include "deltas/ReduceAliases.h" 19#include "deltas/ReduceArguments.h" 20#include "deltas/ReduceAttributes.h" 21#include "deltas/ReduceBasicBlocks.h" 22#include "deltas/ReduceDIMetadata.h" 23#include "deltas/ReduceFunctionBodies.h" 24#include "deltas/ReduceFunctions.h" 25#include "deltas/ReduceGlobalObjects.h" 26#include "deltas/ReduceGlobalValues.h" 27#include "deltas/ReduceGlobalVarInitializers.h" 28#include "deltas/ReduceGlobalVars.h" 29#include "deltas/ReduceIRReferences.h" 30#include "deltas/ReduceInstructionFlags.h" 31#include "deltas/ReduceInstructionFlagsMIR.h" 32#include "deltas/ReduceInstructions.h" 33#include "deltas/ReduceInstructionsMIR.h" 34#include "deltas/ReduceInvokes.h" 35#include "deltas/ReduceMemoryOperations.h" 36#include "deltas/ReduceMetadata.h" 37#include "deltas/ReduceModuleData.h" 38#include "deltas/ReduceOpcodes.h" 39#include "deltas/ReduceOperandBundles.h" 40#include "deltas/ReduceOperands.h" 41#include "deltas/ReduceOperandsSkip.h" 42#include "deltas/ReduceOperandsToArgs.h" 43#include "deltas/ReduceRegisterDefs.h" 44#include "deltas/ReduceRegisterMasks.h" 45#include "deltas/ReduceRegisterUses.h" 46#include "deltas/ReduceSpecialGlobals.h" 47#include "deltas/ReduceUsingSimplifyCFG.h" 48#include "deltas/ReduceVirtualRegisters.h" 49#include "deltas/RunIRPasses.h" 50#include "deltas/SimplifyInstructions.h" 51#include "deltas/StripDebugInfo.h" 52#include "llvm/ADT/SmallSet.h" 53#include "llvm/Support/CommandLine.h" 54 55using namespace llvm; 56 57using SmallStringSet = SmallSet<StringRef, 8>; 58 59extern cl::OptionCategory LLVMReduceOptions; 60static cl::list<std::string> 61 DeltaPasses("delta-passes", 62 cl::desc("Delta passes to run, separated by commas. By " 63 "default, run all delta passes."), 64 cl::cat(LLVMReduceOptions), cl::CommaSeparated); 65 66static cl::list<std::string> 67 SkipDeltaPasses("skip-delta-passes", 68 cl::desc("Delta passes to not run, separated by commas. By " 69 "default, run all delta passes."), 70 cl::cat(LLVMReduceOptions), cl::CommaSeparated); 71 72#define DELTA_PASSES \ 73 do { \ 74 DELTA_PASS("strip-debug-info", stripDebugInfoDeltaPass) \ 75 DELTA_PASS("functions", reduceFunctionsDeltaPass) \ 76 DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass) \ 77 DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass) \ 78 DELTA_PASS("aliases", reduceAliasesDeltaPass) \ 79 DELTA_PASS("ifuncs", reduceIFuncsDeltaPass) \ 80 DELTA_PASS("simplify-conditionals-true", reduceConditionalsTrueDeltaPass) \ 81 DELTA_PASS("simplify-conditionals-false", reduceConditionalsFalseDeltaPass)\ 82 DELTA_PASS("invokes", reduceInvokesDeltaPass) \ 83 DELTA_PASS("unreachable-basic-blocks", reduceUnreachableBasicBlocksDeltaPass) \ 84 DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass) \ 85 DELTA_PASS("simplify-cfg", reduceUsingSimplifyCFGDeltaPass) \ 86 DELTA_PASS("function-data", reduceFunctionDataDeltaPass) \ 87 DELTA_PASS("global-values", reduceGlobalValuesDeltaPass) \ 88 DELTA_PASS("global-objects", reduceGlobalObjectsDeltaPass) \ 89 DELTA_PASS("global-initializers", reduceGlobalsInitializersDeltaPass) \ 90 DELTA_PASS("global-variables", reduceGlobalsDeltaPass) \ 91 DELTA_PASS("di-metadata", reduceDIMetadataDeltaPass) \ 92 DELTA_PASS("metadata", reduceMetadataDeltaPass) \ 93 DELTA_PASS("named-metadata", reduceNamedMetadataDeltaPass) \ 94 DELTA_PASS("arguments", reduceArgumentsDeltaPass) \ 95 DELTA_PASS("instructions", reduceInstructionsDeltaPass) \ 96 DELTA_PASS("simplify-instructions", simplifyInstructionsDeltaPass) \ 97 DELTA_PASS("ir-passes", runIRPassesDeltaPass) \ 98 DELTA_PASS("operands-zero", reduceOperandsZeroDeltaPass) \ 99 DELTA_PASS("operands-one", reduceOperandsOneDeltaPass) \ 100 DELTA_PASS("operands-nan", reduceOperandsNaNDeltaPass) \ 101 DELTA_PASS("operands-to-args", reduceOperandsToArgsDeltaPass) \ 102 DELTA_PASS("operands-skip", reduceOperandsSkipDeltaPass) \ 103 DELTA_PASS("operand-bundles", reduceOperandBundesDeltaPass) \ 104 DELTA_PASS("attributes", reduceAttributesDeltaPass) \ 105 DELTA_PASS("module-data", reduceModuleDataDeltaPass) \ 106 DELTA_PASS("opcodes", reduceOpcodesDeltaPass) \ 107 DELTA_PASS("volatile", reduceVolatileInstructionsDeltaPass) \ 108 DELTA_PASS("atomic-ordering", reduceAtomicOrderingDeltaPass) \ 109 DELTA_PASS("syncscopes", reduceAtomicSyncScopesDeltaPass) \ 110 DELTA_PASS("instruction-flags", reduceInstructionFlagsDeltaPass) \ 111} while (false) 112 113#define DELTA_PASSES_MIR \ 114 do { \ 115 DELTA_PASS("instructions", reduceInstructionsMIRDeltaPass) \ 116 DELTA_PASS("ir-instruction-references", \ 117 reduceIRInstructionReferencesDeltaPass) \ 118 DELTA_PASS("ir-block-references", reduceIRBlockReferencesDeltaPass) \ 119 DELTA_PASS("ir-function-references", reduceIRFunctionReferencesDeltaPass) \ 120 DELTA_PASS("instruction-flags", reduceInstructionFlagsMIRDeltaPass) \ 121 DELTA_PASS("register-uses", reduceRegisterUsesMIRDeltaPass) \ 122 DELTA_PASS("register-defs", reduceRegisterDefsMIRDeltaPass) \ 123 DELTA_PASS("register-hints", reduceVirtualRegisterHintsDeltaPass) \ 124 DELTA_PASS("register-masks", reduceRegisterMasksMIRDeltaPass) \ 125 } while (false) 126 127static void runAllDeltaPasses(TestRunner &Tester, 128 const SmallStringSet &SkipPass) { 129#define DELTA_PASS(NAME, FUNC) \ 130 if (!SkipPass.count(NAME)) { \ 131 FUNC(Tester); \ 132 } 133 if (Tester.getProgram().isMIR()) { 134 DELTA_PASSES_MIR; 135 } else { 136 DELTA_PASSES; 137 } 138#undef DELTA_PASS 139} 140 141static void runDeltaPassName(TestRunner &Tester, StringRef PassName) { 142#define DELTA_PASS(NAME, FUNC) \ 143 if (PassName == NAME) { \ 144 FUNC(Tester); \ 145 return; \ 146 } 147 if (Tester.getProgram().isMIR()) { 148 DELTA_PASSES_MIR; 149 } else { 150 DELTA_PASSES; 151 } 152#undef DELTA_PASS 153 154 // We should have errored on unrecognized passes before trying to run 155 // anything. 156 llvm_unreachable("unknown delta pass"); 157} 158 159void llvm::printDeltaPasses(raw_ostream &OS) { 160 OS << "Delta passes (pass to `--delta-passes=` as a comma separated list):\n"; 161#define DELTA_PASS(NAME, FUNC) OS << " " << NAME << "\n"; 162 OS << " IR:\n"; 163 DELTA_PASSES; 164 OS << " MIR:\n"; 165 DELTA_PASSES_MIR; 166#undef DELTA_PASS 167} 168 169// Built a set of available delta passes. 170static void collectPassNames(const TestRunner &Tester, 171 SmallStringSet &NameSet) { 172#define DELTA_PASS(NAME, FUNC) NameSet.insert(NAME); 173 if (Tester.getProgram().isMIR()) { 174 DELTA_PASSES_MIR; 175 } else { 176 DELTA_PASSES; 177 } 178#undef DELTA_PASS 179} 180 181/// Verify all requested or skipped passes are valid names, and return them in a 182/// set. 183static SmallStringSet handlePassList(const TestRunner &Tester, 184 const cl::list<std::string> &PassList) { 185 SmallStringSet AllPasses; 186 collectPassNames(Tester, AllPasses); 187 188 SmallStringSet PassSet; 189 for (StringRef PassName : PassList) { 190 if (!AllPasses.count(PassName)) { 191 errs() << "unknown pass \"" << PassName << "\"\n"; 192 exit(1); 193 } 194 195 PassSet.insert(PassName); 196 } 197 198 return PassSet; 199} 200 201void llvm::runDeltaPasses(TestRunner &Tester, int MaxPassIterations) { 202 uint64_t OldComplexity = Tester.getProgram().getComplexityScore(); 203 204 SmallStringSet RunPassSet, SkipPassSet; 205 206 if (!DeltaPasses.empty()) 207 RunPassSet = handlePassList(Tester, DeltaPasses); 208 209 if (!SkipDeltaPasses.empty()) 210 SkipPassSet = handlePassList(Tester, SkipDeltaPasses); 211 212 for (int Iter = 0; Iter < MaxPassIterations; ++Iter) { 213 if (DeltaPasses.empty()) { 214 runAllDeltaPasses(Tester, SkipPassSet); 215 } else { 216 for (StringRef PassName : DeltaPasses) { 217 if (!SkipPassSet.count(PassName)) 218 runDeltaPassName(Tester, PassName); 219 } 220 } 221 222 uint64_t NewComplexity = Tester.getProgram().getComplexityScore(); 223 if (NewComplexity >= OldComplexity) 224 break; 225 OldComplexity = NewComplexity; 226 } 227} 228