[NFC][clang] Adding ability to skip compiler phases in clang driver.

[plotfi]

Summary

Changing getFinalPhase to getPhasesToRun. Instead of only returning the final phase it returns the final phase as well as a collection of the phases to skip. This is useful for cases where you want to do up to a compile phase that emits some information per compilation unit, but then you want a link phase for merging the compilation unit artifacts into one file without having to invoke the backend/assembler phases.

[plotfi]

clang/include/clang/Driver/Phases.h

30

I could change this to a SmallVector or SmallSet

[plotfi]

Add full context, change std::set to llvm::SmallSet

[plotfi]

Removing obvious comment.

clang/include/clang/Driver/Driver.h

private:
   mutable llvm::StringMap<std::unique_ptr<ToolChain>> ToolChains;
 
 private:
   /// TranslateInputArgs - Create a new derived argument list from the input
   /// arguments, after applying the standard argument translations.
   llvm::opt::DerivedArgList *
   TranslateInputArgs(const llvm::opt::InputArgList &Args) const;
 
-  // getFinalPhase - Determine which compilation mode we are in and record
-  // which option we used to determine the final phase.
-  phases::ID getFinalPhase(const llvm::opt::DerivedArgList &DAL,
-                           llvm::opt::Arg **FinalPhaseArg = nullptr) const;
+  // getPhasesToRun - Determine which compilation mode we are in and record
+  // which option we used to determine the final phase and the phases to skip.
+  phases::PhasesToRun
+  getPhasesToRun(const llvm::opt::DerivedArgList &DAL,
 
   // Before executing jobs, sets up response files for commands that need them.
   void setUpResponseFiles(Compilation &C, Command &Cmd);
 
   void generatePrefixedToolNames(StringRef Tool, const ToolChain &TC,
                                  SmallVectorImpl<std::string> &Names) const;
 
   /// Find the appropriate .crash diagonostic file for the child crash

clang/include/clang/Driver/Phases.h

 //===--- Phases.h - Transformations on Driver Types -------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+#include <llvm/ADT/SmallSet.h>
+
 #ifndef LLVM_CLANG_DRIVER_PHASES_H
 #define LLVM_CLANG_DRIVER_PHASES_H
 
 namespace clang {
 namespace driver {
 namespace phases {
   /// ID - Ordered values for successive stages in the
   /// compilation process which interact with user options.
   enum ID {
     Preprocess,
     Precompile,
     Compile,
     Backend,
     Assemble,
     Link
   };
 
+  struct PhasesToRun {
+    ID FinalPhase;
+    llvm::SmallSet<ID, 6> SkipPhases;
+  };
+
   enum {
     MaxNumberOfPhases = Link + 1
   };
 
   const char *getPhaseName(ID Id);
 
 } // end namespace phases
 } // end namespace driver
 } // end namespace clang
 
 #endif

clang/lib/Driver/Driver.cpp

InputArgList Driver::ParseArgStrings(ArrayRef<const char *> ArgStrings,
   }
 
   return Args;
 }
 
 // Determine which compilation mode we are in. We look for options which
 // affect the phase, starting with the earliest phases, and record which
 // option we used to determine the final phase.
-phases::ID Driver::getFinalPhase(const DerivedArgList &DAL,
+phases::PhasesToRun Driver::getPhasesToRun(const DerivedArgList &DAL,
                                            Arg **FinalPhaseArg) const {
   Arg *PhaseArg = nullptr;
   phases::ID FinalPhase;
+  llvm::SmallSet<phases::ID, 6> SkipPhases;
 
   // -{E,EP,P,M,MM} only run the preprocessor.
   if (CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
       (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) ||
       (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) ||
       (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))) {
     FinalPhase = phases::Preprocess;
 
if (CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
 
     // Otherwise do everything.
   } else
     FinalPhase = phases::Link;
 
   if (FinalPhaseArg)
     *FinalPhaseArg = PhaseArg;
 
-  return FinalPhase;
+  return { FinalPhase, SkipPhases };
 }
 
 static Arg *MakeInputArg(DerivedArgList &Args, OptTable &Opts,
                          StringRef Value, bool Claim = true) {
   Arg *A = new Arg(Opts.getOption(options::OPT_INPUT), Value,
                    Args.getBaseArgs().MakeIndex(Value), Value.data());
   Args.AddSynthesizedArg(A);
   if (Claim)
void Driver::BuildActions(Compilation &C, DerivedArgList &Args,
   llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
 
   if (!SuppressMissingInputWarning && Inputs.empty()) {
     Diag(clang::diag::err_drv_no_input_files);
     return;
   }
 
   Arg *FinalPhaseArg;
-  phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
+  phases::PhasesToRun PhasesToRun = getPhasesToRun(Args, &FinalPhaseArg);
+  phases::ID FinalPhase = PhasesToRun.FinalPhase;
 
   if (FinalPhase == phases::Link) {
     if (Args.hasArg(options::OPT_emit_llvm))
       Diag(clang::diag::err_drv_emit_llvm_link);
     if (IsCLMode() && LTOMode != LTOK_None &&
         !Args.getLastArgValue(options::OPT_fuse_ld_EQ).equals_lower("lld"))
       Diag(clang::diag::err_drv_lto_without_lld);
   }
for (auto &I : Inputs) {
     for (SmallVectorImpl<phases::ID>::iterator i = PL.begin(), e = PL.end();
          i != e; ++i) {
       phases::ID Phase = *i;
 
       // We are done if this step is past what the user requested.
       if (Phase > FinalPhase)
         break;
 
+      if (llvm::is_contained(PhasesToRun.SkipPhases, Phase))
+        continue;
+
       // Add any offload action the host action depends on.
       Current = OffloadBuilder.addDeviceDependencesToHostAction(
           Current, InputArg, Phase, FinalPhase, PL);
       if (!Current)
         break;
 
       // Queue linker inputs.
       if (Phase == phases::Link) {