llvm/tools/llvm-reduce/DeltaManager.cpp

   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/ReduceDbgRecords.h"
  24 #include "deltas/ReduceDistinctMetadata.h"
  25 #include "deltas/ReduceFunctionBodies.h"
  26 #include "deltas/ReduceFunctions.h"
  27 #include "deltas/ReduceGlobalObjects.h"
  28 #include "deltas/ReduceGlobalValues.h"
  29 #include "deltas/ReduceGlobalVarInitializers.h"
  30 #include "deltas/ReduceGlobalVars.h"
  31 #include "deltas/ReduceIRReferences.h"
  32 #include "deltas/ReduceInstructionFlags.h"
  33 #include "deltas/ReduceInstructionFlagsMIR.h"
  34 #include "deltas/ReduceInstructions.h"
  35 #include "deltas/ReduceInstructionsMIR.h"
  36 #include "deltas/ReduceInvokes.h"
  37 #include "deltas/ReduceMemoryOperations.h"
  38 #include "deltas/ReduceMetadata.h"
  39 #include "deltas/ReduceModuleData.h"
  40 #include "deltas/ReduceOpcodes.h"
  41 #include "deltas/ReduceOperandBundles.h"
  42 #include "deltas/ReduceOperands.h"
  43 #include "deltas/ReduceOperandsSkip.h"
  44 #include "deltas/ReduceOperandsToArgs.h"
  45 #include "deltas/ReduceRegisterDefs.h"
  46 #include "deltas/ReduceRegisterMasks.h"
  47 #include "deltas/ReduceRegisterUses.h"
  48 #include "deltas/ReduceSpecialGlobals.h"
  49 #include "deltas/ReduceUsingSimplifyCFG.h"
  50 #include "deltas/ReduceVirtualRegisters.h"
  51 #include "deltas/RunIRPasses.h"
  52 #include "deltas/SimplifyInstructions.h"
  53 #include "deltas/StripDebugInfo.h"
  54 #include "llvm/ADT/SmallSet.h"
  55 #include "llvm/Support/CommandLine.h"
  56
  57 using namespace llvm;
  58
  59 using SmallStringSet = SmallSet<StringRef, 8>;
  60
  61 extern cl::OptionCategory LLVMReduceOptions;
  62 static cl::list<std::string>
  63     DeltaPasses("delta-passes",
  64                 cl::desc("Delta passes to run, separated by commas. By "
  65                          "default, run all delta passes."),
  66                 cl::cat(LLVMReduceOptions), cl::CommaSeparated);
  67
  68 static cl::list<std::string>
  69     SkipDeltaPasses("skip-delta-passes",
  70                     cl::desc("Delta passes to not run, separated by commas. By "
  71                              "default, run all delta passes."),
  72                     cl::cat(LLVMReduceOptions), cl::CommaSeparated);
  73
  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)
 132
 133 static void runAllDeltaPasses(TestRunner &Tester,
 134                               const SmallStringSet &SkipPass) {
 135 #define DELTA_PASS(NAME, FUNC)                                                 \
 136   if (!SkipPass.count(NAME)) {                                                 \
 137     FUNC(Tester);                                                              \
 138   }
 139   if (Tester.getProgram().isMIR()) {
 140     DELTA_PASSES_MIR;
 141   } else {
 142     DELTA_PASSES;
 143   }
 144 #undef DELTA_PASS
 145 }
 146
 147 static void runDeltaPassName(TestRunner &Tester, StringRef PassName) {
 148 #define DELTA_PASS(NAME, FUNC)                                                 \
 149   if (PassName == NAME) {                                                      \
 150     FUNC(Tester);                                                              \
 151     return;                                                                    \
 152   }
 153   if (Tester.getProgram().isMIR()) {
 154     DELTA_PASSES_MIR;
 155   } else {
 156     DELTA_PASSES;
 157   }
 158 #undef DELTA_PASS
 159
 160   // We should have errored on unrecognized passes before trying to run
 161   // anything.
 162   llvm_unreachable("unknown delta pass");
 163 }
 164
 165 void llvm::printDeltaPasses(raw_ostream &OS) {
 166   OS << "Delta passes (pass to `--delta-passes=` as a comma separated list):\n";
 167 #define DELTA_PASS(NAME, FUNC) OS << "  " << NAME << "\n";
 168   OS << " IR:\n";
 169   DELTA_PASSES;
 170   OS << " MIR:\n";
 171   DELTA_PASSES_MIR;
 172 #undef DELTA_PASS
 173 }
 174
 175 // Built a set of available delta passes.
 176 static void collectPassNames(const TestRunner &Tester,
 177                              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;
 183   }
 184 #undef DELTA_PASS
 185 }
 186
 187 /// Verify all requested or skipped passes are valid names, and return them in a
 188 /// set.
 189 static SmallStringSet handlePassList(const TestRunner &Tester,
 190                                      const cl::list<std::string> &PassList) {
 191   SmallStringSet AllPasses;
 192   collectPassNames(Tester, AllPasses);
 193
 194   SmallStringSet PassSet;
 195   for (StringRef PassName : PassList) {
 196     if (!AllPasses.count(PassName)) {
 197       errs() << "unknown pass \"" << PassName << "\"\n";
 198       exit(1);
 199     }
 200
 201     PassSet.insert(PassName);
 202   }
 203
 204   return PassSet;
 205 }
 206
 207 void llvm::runDeltaPasses(TestRunner &Tester, int MaxPassIterations) {
 208   uint64_t OldComplexity = Tester.getProgram().getComplexityScore();
 209
 210   SmallStringSet RunPassSet, SkipPassSet;
 211
 212   if (!DeltaPasses.empty())
 213     RunPassSet = handlePassList(Tester, DeltaPasses);
 214
 215   if (!SkipDeltaPasses.empty())
 216     SkipPassSet = handlePassList(Tester, SkipDeltaPasses);
 217
 218   for (int Iter = 0; Iter < MaxPassIterations; ++Iter) {
 219     if (DeltaPasses.empty()) {
 220       runAllDeltaPasses(Tester, SkipPassSet);
 221     } else {
 222       for (StringRef PassName : DeltaPasses) {
 223         if (!SkipPassSet.count(PassName))
 224           runDeltaPassName(Tester, PassName);
 225       }
 226     }
 227
 228     uint64_t NewComplexity = Tester.getProgram().getComplexityScore();
 229     if (NewComplexity >= OldComplexity)
 230       break;
 231     OldComplexity = NewComplexity;
 232   }
 233 }