[opt] refactor opt main function

[Kokan]

Summary

• set ->keep() as soon as possible
• refactor target machine detection
• refactor early exit with -module-summary/hash with -S option
• refactor use OutputKind
• extract initialize passes
• run-twice small refactors
• use == for SmallVector

Signed-off-by: Peter Kokai <[e-mail]>

[MaskRay]

llvm/tools/opt/opt.cpp

693

GetOutputKind is only called once. The change does not seem to improve readability.

944

llvm_unreachable

llvm/tools/llc/llc.cpp

if (RelaxAll.getNumOccurrences() > 0 &&
 
     auto HasError =
         ((const LLCDiagnosticHandler *)(Context.getDiagHandlerPtr()))->HasError;
     if (*HasError)
       return 1;
 
     // Compare the two outputs and make sure they're the same
     if (CompileTwice) {
-      if (Buffer.size() != CompileTwiceBuffer.size() ||
-          (memcmp(Buffer.data(), CompileTwiceBuffer.data(), Buffer.size()) !=
-           0)) {
+      if (Buffer != CompileTwiceBuffer) {
         errs()
             << "Running the pass manager twice changed the output.\n"
                "Writing the result of the second run to the specified output\n"
                "To generate the one-run comparison binary, just run without\n"
                "the compile-twice option\n";
         Out->os() << Buffer;
         Out->keep();
         return 1;

llvm/tools/opt/opt.cpp

static CodeGenOpt::Level GetCodeGenOptLevel() {
   if (OptLevelO2)
     return CodeGenOpt::Default;
   if (OptLevelO3)
     return CodeGenOpt::Aggressive;
   return CodeGenOpt::None;
 }
 
 // Returns the TargetMachine instance or zero if no triple is provided.
-static TargetMachine* GetTargetMachine(Triple TheTriple, StringRef CPUStr,
-                                       StringRef FeaturesStr,
-                                       const TargetOptions &Options) {
+static std::unique_ptr<TargetMachine>
+GetTargetMachine(Triple TheTriple, StringRef CPUStr, StringRef FeaturesStr,
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(MArch, TheTriple,
                                                          Error);
   // Some modules don't specify a triple, and this is okay.
   if (!TheTarget) {
     return nullptr;
   }
 
-  return TheTarget->createTargetMachine(TheTriple.getTriple(), CPUStr,
-                                        FeaturesStr, Options, getRelocModel(),
-                                        getCodeModel(), GetCodeGenOptLevel());
+  return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
+      TheTriple.getTriple(), CPUStr, FeaturesStr, Options, getRelocModel(),
+      getCodeModel(), GetCodeGenOptLevel()));
+}
+
+static OutputKind GetOutputKind() {
+  if (NoOutput)
+    return OK_NoOutput;
+
+  if (OutputAssembly)
+    return OK_OutputAssembly;
+
+  if (OutputThinLTOBC)
+    return OK_OutputThinLTOBitcode;
+
+  return OK_OutputBitcode;
 }
 
 #ifdef LINK_POLLY_INTO_TOOLS
 namespace polly {
 void initializePollyPasses(llvm::PassRegistry &Registry);
 }
 #endif
 
for (const auto &Entry : Map) {
     DebugifyStatistics Stats = Entry.second;
 
     OS << Pass << ',' << Stats.NumDbgValuesMissing << ','
        << Stats.NumDbgLocsMissing << ',' << Stats.getMissingValueRatio() << ','
        << Stats.getEmptyLocationRatio() << '\n';
   }
 }
 
-//===----------------------------------------------------------------------===//
-// main for opt
-//
-int main(int argc, char **argv) {
-  InitLLVM X(argc, argv);
-
-  // Enable debug stream buffering.
-  EnableDebugBuffering = true;
-
-  LLVMContext Context;
-
-  InitializeAllTargets();
-  InitializeAllTargetMCs();
-  InitializeAllAsmPrinters();
-  InitializeAllAsmParsers();
-
+static void InitializetDefaultPasses() {
   // Initialize passes
   PassRegistry &Registry = *PassRegistry::getPassRegistry();
   initializeCore(Registry);
   initializeCoroutines(Registry);
   initializeScalarOpts(Registry);
   initializeObjCARCOpts(Registry);
   initializeVectorization(Registry);
   initializeIPO(Registry);
static void InitializetDefaultPasses() {
   initializeWasmEHPreparePass(Registry);
   initializeWriteBitcodePassPass(Registry);
   initializeHardwareLoopsPass(Registry);
   initializeTypePromotionPass(Registry);
 
 #ifdef LINK_POLLY_INTO_TOOLS
   polly::initializePollyPasses(Registry);
 #endif
+}
+
+//===----------------------------------------------------------------------===//
+// main for opt
+//
+int main(int argc, char **argv) {
+  InitLLVM X(argc, argv);
+
+  // Enable debug st0ream buffering.
+  EnableDebugBuffering = true;
+
+  LLVMContext Context;
+
+  InitializeAllTargets();
+  InitializeAllTargetMCs();
+  InitializeAllAsmPrinters();
+  InitializeAllAsmParsers();
+
+  InitializetDefaultPasses();
 
   cl::ParseCommandLineOptions(argc, argv,
     "llvm .bc -> .bc modular optimizer and analysis printer\n");
 
   if (AnalyzeOnly && NoOutput) {
     errs() << argv[0] << ": analyze mode conflicts with no-output mode.\n";
     return 1;
   }
 
   SMDiagnostic Err;
 
   Context.setDiscardValueNames(DiscardValueNames);
   if (!DisableDITypeMap)
     Context.enableDebugTypeODRUniquing();
 
   Expected<std::unique_ptr<ToolOutputFile>> RemarksFileOrErr =
       setupOptimizationRemarks(Context, RemarksFilename, RemarksPasses,
                                RemarksFormat, RemarksWithHotness,
                                RemarksHotnessThreshold);
   if (Error E = RemarksFileOrErr.takeError()) {
     errs() << toString(std::move(E)) << '\n';
     return 1;
   }
   std::unique_ptr<ToolOutputFile> RemarksFile = std::move(*RemarksFileOrErr);
+  if (RemarksFile)
+    RemarksFile->keep();
+
+  if (OutputAssembly) {
+    if (EmitSummaryIndex) {
+      errs() << argv[0]
+             << ": Text output is incompatible with -module-summary\n";
+      return 1;
+    }
+    if (EmitModuleHash) {
+      errs() << argv[0] << ": Text output is incompatible with -module-hash\n";
+      return 1;
+    }
+  }
 
   // Load the input module...
   std::unique_ptr<Module> M =
       parseIRFile(InputFilename, Err, Context, !NoVerify, ClDataLayout);
 
   if (!M) {
     Err.print(argv[0], errs());
     return 1;
if (NoOutput) {
     if (EC) {
       errs() << EC.message() << '\n';
       return 1;
     }
 
     if (!ThinLinkBitcodeFile.empty()) {
       ThinLinkOut.reset(
           new ToolOutputFile(ThinLinkBitcodeFile, EC, sys::fs::OF_None));
+      ThinLinkOut->keep();
       if (EC) {
         errs() << EC.message() << '\n';
         return 1;
       }
     }
   }
 
   Triple ModuleTriple(M->getTargetTriple());
-  std::string CPUStr, FeaturesStr;
-  TargetMachine *Machine = nullptr;
-  const TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
 
-  if (ModuleTriple.getArch()) {
-    CPUStr = getCPUStr();
-    FeaturesStr = getFeaturesStr();
-    Machine = GetTargetMachine(ModuleTriple, CPUStr, FeaturesStr, Options);
-  } else if (ModuleTriple.getArchName() != "unknown" &&
-             ModuleTriple.getArchName() != "") {
+  if (!ModuleTriple.getArch() && ModuleTriple.getArchName() != "unknown" &&
     errs() << argv[0] << ": unrecognized architecture '"
            << ModuleTriple.getArchName() << "' provided.\n";
     return 1;
   }
 
-  std::unique_ptr<TargetMachine> TM(Machine);
+  std::string CPUStr = getCPUStr();
+  std::string FeaturesStr = getFeaturesStr();
+  const TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
+
+  std::unique_ptr<TargetMachine> TM =
+      GetTargetMachine(ModuleTriple, CPUStr, FeaturesStr, Options);
 
   // Override function attributes based on CPUStr, FeaturesStr, and command line
   // flags.
   setFunctionAttributes(CPUStr, FeaturesStr, *M);
 
   // If the output is set to be emitted to standard out, and standard out is a
   // console, print out a warning message and refuse to do it.  We don't
   // impress anyone by spewing tons of binary goo to a terminal.
   if (!Force && !NoOutput && !AnalyzeOnly && !OutputAssembly)
     if (CheckBitcodeOutputToConsole(Out->os(), !Quiet))
       NoOutput = true;
 
+  OutputKind OK = GetOutputKind();
+
   if (OutputThinLTOBC)
     M->addModuleFlag(Module::Error, "EnableSplitLTOUnit", SplitLTOUnit);
 
   if (PassPipeline.getNumOccurrences() > 0) {
-    OutputKind OK = OK_NoOutput;
-    if (!NoOutput)
-      OK = OutputAssembly
-               ? OK_OutputAssembly
-               : (OutputThinLTOBC ? OK_OutputThinLTOBitcode : OK_OutputBitcode);
-
     VerifierKind VK = VK_VerifyInAndOut;
     if (NoVerify)
       VK = VK_NoVerifier;
     else if (VerifyEach)
       VK = VK_VerifyEachPass;
 
     // The user has asked to use the new pass manager and provided a pipeline
     // string. Hand off the rest of the functionality to the new code for that
if (!Out) {
                                               sys::fs::OF_None);
       if (EC) {
         errs() << EC.message() << '\n';
         return 1;
       }
     }
     Passes.add(createBreakpointPrinter(Out->os()));
     NoOutput = true;
+    Out->keep();
   }
 
   if (TM) {
     // FIXME: We should dyn_cast this when supported.
     auto &LTM = static_cast<LLVMTargetMachine &>(*TM);
     Pass *TPC = LTM.createPassConfig(Passes);
     Passes.add(TPC);
   }
int main(int argc, char **argv) {
   // Write bitcode or assembly to the output as the last step...
   if (ShouldEmitOutput || RunTwice) {
     assert(Out);
     OS = &Out->os();
     if (RunTwice) {
       BOS = std::make_unique<raw_svector_ostream>(Buffer);
       OS = BOS.get();
     }
-    if (OutputAssembly) {
-      if (EmitSummaryIndex)
-        report_fatal_error("Text output is incompatible with -module-summary");
-      if (EmitModuleHash)
-        report_fatal_error("Text output is incompatible with -module-hash");
-      Passes.add(createPrintModulePass(*OS, "", PreserveAssemblyUseListOrder));
-    } else if (OutputThinLTOBC)
+
+    switch (OK) {
+    case OK_NoOutput:
+      assert(false);
+      break;
+    case OK_OutputThinLTOBitcode:
       Passes.add(createWriteThinLTOBitcodePass(
           *OS, ThinLinkOut ? &ThinLinkOut->os() : nullptr));
-    else
+      break;
+    case OK_OutputBitcode:
       Passes.add(createBitcodeWriterPass(*OS, PreserveBitcodeUseListOrder,
                                          EmitSummaryIndex, EmitModuleHash));
+      break;
+    case OK_OutputAssembly:
+      Passes.add(createPrintModulePass(*OS, "", PreserveAssemblyUseListOrder));
+      break;
+    }
+    Out->keep();
   }
 
   // Before executing passes, print the final values of the LLVM options.
   cl::PrintOptionValues();
 
-  if (!RunTwice) {
-    // Now that we have all of the passes ready, run them.
-    Passes.run(*M);
-  } else {
+  std::unique_ptr<Module> ModuleCopy;
+  if (RunTwice) {
+    ModuleCopy = CloneModule(*M);
+  }
+
+
+  if (RunTwice) {
     // If requested, run all passes twice with the same pass manager to catch
     // bugs caused by persistent state in the passes.
-    std::unique_ptr<Module> M2(CloneModule(*M));
-    // Run all passes on the original module first, so the second run processes
-    // the clone to catch CloneModule bugs.
-    Passes.run(*M);
+    // Run all passes on the second run processes the clone to catch CloneModule
+    // bugs.
     FirstRunBuffer = Buffer;
     Buffer.clear();
 
-    Passes.run(*M2);
+    Passes.run(*ModuleCopy);
 
     // Compare the two outputs and make sure they're the same
     assert(Out);
-    if (Buffer.size() != FirstRunBuffer.size() ||
-        (memcmp(Buffer.data(), FirstRunBuffer.data(), Buffer.size()) != 0)) {
+    if (Buffer != FirstRunBuffer) {
       errs()
           << "Running the pass manager twice changed the output.\n"
              "Writing the result of the second run to the specified output.\n"
              "To generate the one-run comparison binary, just run without\n"
              "the compile-twice option\n";
-      if (ShouldEmitOutput) {
+      if (ShouldEmitOutput)
         Out->os() << BOS->str();
-        Out->keep();
-      }
-      if (RemarksFile)
-        RemarksFile->keep();
       return 1;
     }
     if (ShouldEmitOutput)
       Out->os() << BOS->str();
   }
 
   if (DebugifyEach && !DebugifyExport.empty())
     exportDebugifyStats(DebugifyExport, Passes.getDebugifyStatsMap());
 
-  // Declare success.
-  if (!NoOutput || PrintBreakpoints)
-    Out->keep();
-
-  if (RemarksFile)
-    RemarksFile->keep();
-
-  if (ThinLinkOut)
-    ThinLinkOut->keep();
 
   return 0;
 }