[NFC][clang] Refactor getCompilationPhases step 1: Move list of phases into Types.def table.

[plotfi]

Summary

Simplifying the phases generation process, first by copying the phases info into the Table.

[compnerd]

The explicit list I think is way better for readability, this is a nice starting point for cleaning this up.

clang/include/clang/Driver/Types.def

18

Please update the comment here indicating the new field

clang/lib/Driver/Driver.cpp

3304

Why can this not be a range based for loop?

clang/lib/Driver/Types.cpp

271

Can we return llvm::SmallVectorImpl<phases::ID> instead? The size is immaterial to this I think.

303

A comment to indicate that the concrete list will become the implementation would be nice.

[compnerd]

clang/lib/Driver/Types.cpp

29

I think that we can abuse the preprocessor a bit and get something that is nicer to read. Lets make the last parameter a variadic and pass along the phases to the list. Something like:

ENTRY('a', "std::string")
ENTRY('b', "std::string", "std::vector<std::string>")
ENTRY('c', "std::string", "std::vector<std::string>", "int")

const struct {
  unsigned int id;
  std::vector<std::string> strings;
} array[] = {
#define ENTRY(id, strings...) { id, { strings } },
#include "reduced.def"
#undef ENTRY
};

[plotfi]

Update diff based on @compnerd's feedback

[plotfi]

@aaron.ballman Any thoughts on this?

[aaron.ballman]

clang/include/clang/Driver/Types.h

100

Please drop the top-level const as it doesn't add much utility.

clang/lib/Driver/Driver.cpp

2217

Why are you changing this to an STL type?

3236–3238

You could use a const & here and avoid the copy. Either that, or drop the const (it's not a common pattern in the code base).

3279–3280

Same here

clang/lib/Driver/Types.cpp

271

Agreed, I think this API should be working with SmallVectors and not std::vectors.

300

Please don't use auto here as the type is not spelled out in the initialization.

301–303

You can replace all three lines by:
assert(std::equal(Phases.begin(), Phases.end(), P.begin(), P.end()) && "Invalid phase or size");

[plotfi]

Updated to address @aaron.ballman 's feedback

clang/lib/Driver/Driver.cpp

2217

I changed it because it didn't look like you can return a SmallVector, but I just changed it back to the old SmallVector function calling style.

3236–3238

Going to keep the copy. I want to eventually merge getCompilationPhases and getFinalPhase into the same function.

clang/lib/Driver/Types.cpp

301–303

Nice!

[aaron.ballman]

clang/lib/Driver/Types.cpp

306

Can't you use the local Phases object instead of calling getInfo() again? This seems like it wants to be P = Phases;

[plotfi]

clang/lib/Driver/Types.cpp

306

Oh yeah sure. I can change that. Anything else pop out at you?

[plotfi]

Update.

[aaron.ballman]

clang/lib/Driver/Types.cpp

306

You can drop the P.clear() as part of that assignment, but otherwise, no.

[plotfi]

clang/lib/Driver/Types.cpp

306

Ahh. I understand what you mean now. Thanks!

[aaron.ballman]

LGTM!

clang/lib/Driver/Types.cpp

304

Spurious a at the end of the comment should be removed.

[plotfi]

Removing 'A'

[plotfi]

This was a mistake. Updated the Wrong diff.

clang/include/clang/Driver/Types.h

 namespace llvm {
 class StringRef;
 }
 namespace clang {
 namespace driver {
 namespace types {
   enum ID {
     TY_INVALID,
-#define TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, FLAGS) TY_##ID,
+#define TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, FLAGS, PHASES) TY_##ID,
 #include "clang/Driver/Types.def"
 #undef TYPE
     TY_LAST
   };
 
   /// getTypeName - Return the name of the type for \p Id.
   const char *getTypeName(ID Id);
 
#undef TYPE
   ID lookupTypeForExtension(llvm::StringRef Ext);
 
   /// lookupTypeForTypSpecifier - Lookup the type to use for a user
   /// specified type name.
   ID lookupTypeForTypeSpecifier(const char *Name);
 
   /// getCompilationPhases - Get the list of compilation phases ('Phases') to be
   /// done for type 'Id'.
-  void getCompilationPhases(
-    ID Id,
-    llvm::SmallVectorImpl<phases::ID> &Phases);
+  const llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> &getCompilationPhases(ID Id);
 
   /// lookupCXXTypeForCType - Lookup CXX input type that corresponds to given
   /// C type (used for clang++ emulation of g++ behaviour)
   ID lookupCXXTypeForCType(ID Id);
 
   /// Lookup header file input type that corresponds to given
   /// source file type (used for clang-cl emulation of \Yc).
   ID lookupHeaderTypeForSourceType(ID Id);
 
 } // end namespace types
 } // end namespace driver
 } // end namespace clang
 
 #endif

clang/include/clang/Driver/Types.def

 // must define the TYPE macro to make use of this information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TYPE
 #error "Define TYPE prior to including this file!"
 #endif
 
 // TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, FLAGS)
 
 // The first value is the type name as a string; for types which can
 // be user specified this should be the equivalent -x option.
 
 // The second value is the type id, which will result in a
 // clang::driver::types::TY_XX enum constant.
 
 // The third value is that id of the type for preprocessed inputs of
 // this type, or INVALID if this type is not preprocessed.
 
 // The fourth value is the suffix to use when creating temporary files
 // of this type, or null if unspecified.
 
 // The fifth value is a string containing option flags. Valid values:
 //  a - The type should only be assembled.
 //  p - The type should only be precompiled.
 //  u - The type can be user specified (with -x).
 //  m - Precompiling this type produces a module file.
 //  A - The type's temporary suffix should be appended when generating
 //      outputs of this type.
 
 
 // C family source language (with and without preprocessing).
-TYPE("cpp-output",               PP_C,         INVALID,         "i",     "u")
-TYPE("c",                        C,            PP_C,            "c",     "u")
-TYPE("cl",                       CL,           PP_C,            "cl",    "u")
-TYPE("cuda-cpp-output",          PP_CUDA,      INVALID,         "cui",   "u")
-TYPE("cuda",                     CUDA,         PP_CUDA,         "cu",    "u")
-TYPE("cuda",                     CUDA_DEVICE,  PP_CUDA,         "cu",    "")
-TYPE("hip-cpp-output",           PP_HIP,       INVALID,         "cui",   "u")
-TYPE("hip",                      HIP,          PP_HIP,          "cu",    "u")
-TYPE("hip",                      HIP_DEVICE,   PP_HIP,          "cu",    "")
-TYPE("objective-c-cpp-output",   PP_ObjC,      INVALID,         "mi",    "u")
-TYPE("objc-cpp-output",          PP_ObjC_Alias, INVALID,        "mi",    "u")
-TYPE("objective-c",              ObjC,         PP_ObjC,         "m",     "u")
-TYPE("c++-cpp-output",           PP_CXX,       INVALID,         "ii",    "u")
-TYPE("c++",                      CXX,          PP_CXX,          "cpp",   "u")
-TYPE("objective-c++-cpp-output", PP_ObjCXX,    INVALID,         "mii",   "u")
-TYPE("objc++-cpp-output",        PP_ObjCXX_Alias, INVALID,      "mii",   "u")
-TYPE("objective-c++",            ObjCXX,       PP_ObjCXX,       "mm",    "u")
-TYPE("renderscript",             RenderScript, PP_C,            "rs",    "u")
+TYPE("cpp-output",               PP_C,         INVALID,         "i",     "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("c",                        C,            PP_C,            "c",     "u",  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("cl",                       CL,           PP_C,            "cl",    "u",  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("cuda-cpp-output",          PP_CUDA,      INVALID,         "cui",   "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("cuda",                     CUDA,         PP_CUDA,         "cu",    "u",  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("cuda",                     CUDA_DEVICE,  PP_CUDA,         "cu",    "" ,  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("hip-cpp-output",           PP_HIP,       INVALID,         "cui",   "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("hip",                      HIP,          PP_HIP,          "cu",    "u",  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("hip",                      HIP_DEVICE,   PP_HIP,          "cu",    "" ,  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("objective-c-cpp-output",   PP_ObjC,      INVALID,         "mi",    "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("objc-cpp-output",          PP_ObjC_Alias, INVALID,        "mi",    "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("objective-c",              ObjC,         PP_ObjC,         "m",     "u",  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("c++-cpp-output",           PP_CXX,       INVALID,         "ii",    "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("c++",                      CXX,          PP_CXX,          "cpp",   "u",  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("objective-c++-cpp-output", PP_ObjCXX,    INVALID,         "mii",   "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("objc++-cpp-output",        PP_ObjCXX_Alias, INVALID,      "mii",   "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("objective-c++",            ObjCXX,       PP_ObjCXX,       "mm",    "u",  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("renderscript",             RenderScript, PP_C,            "rs",    "u",  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
 
 // C family input files to precompile.
-TYPE("c-header-cpp-output",      PP_CHeader,   INVALID,         "i",     "p")
-TYPE("c-header",                 CHeader,      PP_CHeader,      "h",     "pu")
-TYPE("cl-header",                CLHeader,     PP_CHeader,      "h",     "pu")
-TYPE("objective-c-header-cpp-output", PP_ObjCHeader, INVALID,   "mi",    "p")
-TYPE("objective-c-header",       ObjCHeader,   PP_ObjCHeader,   "h",     "pu")
-TYPE("c++-header-cpp-output",    PP_CXXHeader, INVALID,         "ii",    "p")
-TYPE("c++-header",               CXXHeader,    PP_CXXHeader,    "hh",    "pu")
-TYPE("objective-c++-header-cpp-output", PP_ObjCXXHeader, INVALID, "mii", "p")
-TYPE("objective-c++-header",     ObjCXXHeader, PP_ObjCXXHeader, "h",     "pu")
-TYPE("c++-module",               CXXModule,    PP_CXXModule,    "cppm",  "mu")
-TYPE("c++-module-cpp-output",    PP_CXXModule, INVALID,         "iim",   "m")
+TYPE("c-header-cpp-output",      PP_CHeader,   INVALID,         "i",     "p",  (PHASES { phases::Precompile }))
+TYPE("c-header",                 CHeader,      PP_CHeader,      "h",     "pu", (PHASES { phases::Preprocess, phases::Precompile }))
+TYPE("cl-header",                CLHeader,     PP_CHeader,      "h",     "pu", (PHASES { phases::Preprocess, phases::Precompile }))
+TYPE("objective-c-header-cpp-output", PP_ObjCHeader, INVALID,   "mi",    "p",  (PHASES { phases::Precompile }))
+TYPE("objective-c-header",       ObjCHeader,   PP_ObjCHeader,   "h",     "pu", (PHASES { phases::Preprocess, phases::Precompile }))
+TYPE("c++-header-cpp-output",    PP_CXXHeader, INVALID,         "ii",    "p",  (PHASES { phases::Precompile }))
+TYPE("c++-header",               CXXHeader,    PP_CXXHeader,    "hh",    "pu", (PHASES { phases::Preprocess, phases::Precompile }))
+TYPE("objective-c++-header-cpp-output", PP_ObjCXXHeader, INVALID, "mii", "p",  (PHASES { phases::Precompile }))
+TYPE("objective-c++-header",     ObjCXXHeader, PP_ObjCXXHeader, "h",     "pu", (PHASES { phases::Preprocess, phases::Precompile }))
+TYPE("c++-module",               CXXModule,    PP_CXXModule,    "cppm",  "mu", (PHASES { phases::Preprocess, phases::Precompile, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("c++-module-cpp-output",    PP_CXXModule, INVALID,         "iim",   "m",  (PHASES { phases::Precompile, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
 
 // Other languages.
-TYPE("ada",                      Ada,          INVALID,         nullptr, "u")
-TYPE("assembler",                PP_Asm,       INVALID,         "s",     "au")
-TYPE("assembler-with-cpp",       Asm,          PP_Asm,          "S",     "au")
-TYPE("f95",                      PP_Fortran,   INVALID,         nullptr, "u")
-TYPE("f95-cpp-input",            Fortran,      PP_Fortran,      nullptr, "u")
-TYPE("java",                     Java,         INVALID,         nullptr, "u")
+TYPE("ada",                      Ada,          INVALID,         nullptr, "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("assembler",                PP_Asm,       INVALID,         "s",     "au", (PHASES { phases::Assemble, phases::Link }))
+TYPE("assembler-with-cpp",       Asm,          PP_Asm,          "S",     "au", (PHASES { phases::Preprocess, phases::Assemble, phases::Link }))
+TYPE("f95",                      PP_Fortran,   INVALID,         nullptr, "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("f95-cpp-input",            Fortran,      PP_Fortran,      nullptr, "u",  (PHASES { phases::Preprocess, phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("java",                     Java,         INVALID,         nullptr, "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
 
 // LLVM IR/LTO types. We define separate types for IR and LTO because LTO
 // outputs should use the standard suffixes.
-TYPE("ir",                       LLVM_IR,      INVALID,         "ll",    "u")
-TYPE("ir",                       LLVM_BC,      INVALID,         "bc",    "u")
-TYPE("lto-ir",                   LTO_IR,       INVALID,         "s",     "")
-TYPE("lto-bc",                   LTO_BC,       INVALID,         "o",     "")
+TYPE("ir",                       LLVM_IR,      INVALID,         "ll",    "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("ir",                       LLVM_BC,      INVALID,         "bc",    "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("lto-ir",                   LTO_IR,       INVALID,         "s",     "",   (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("lto-bc",                   LTO_BC,       INVALID,         "o",     "",   (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
 
 // Misc.
-TYPE("ast",                      AST,          INVALID,         "ast",   "u")
-TYPE("ifs",                      IFS,          INVALID,         "ifs",   "u")
-TYPE("pcm",                      ModuleFile,   INVALID,         "pcm",   "u")
-TYPE("plist",                    Plist,        INVALID,         "plist", "")
-TYPE("rewritten-objc",           RewrittenObjC,INVALID,         "cpp",   "")
-TYPE("rewritten-legacy-objc",    RewrittenLegacyObjC,INVALID,   "cpp",   "")
-TYPE("remap",                    Remap,        INVALID,         "remap", "")
-TYPE("precompiled-header",       PCH,          INVALID,         "gch",   "A")
-TYPE("object",                   Object,       INVALID,         "o",     "")
-TYPE("treelang",                 Treelang,     INVALID,         nullptr, "u")
-TYPE("image",                    Image,        INVALID,         "out",   "")
-TYPE("dSYM",                     dSYM,         INVALID,         "dSYM",  "A")
-TYPE("dependencies",             Dependencies, INVALID,         "d",     "")
-TYPE("cuda-fatbin",              CUDA_FATBIN,  INVALID,         "fatbin","A")
-TYPE("hip-fatbin",               HIP_FATBIN,   INVALID,         "hipfb", "A")
-TYPE("none",                     Nothing,      INVALID,         nullptr, "u")
+TYPE("ast",                      AST,          INVALID,         "ast",   "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("ifs",                      IFS,          INVALID,         "ifs",   "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("pcm",                      ModuleFile,   INVALID,         "pcm",   "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("plist",                    Plist,        INVALID,         "plist", "",   (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("rewritten-objc",           RewrittenObjC,INVALID,         "cpp",   "",   (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("rewritten-legacy-objc",    RewrittenLegacyObjC,INVALID,   "cpp",   "",   (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("remap",                    Remap,        INVALID,         "remap", "",   (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("precompiled-header",       PCH,          INVALID,         "gch",   "A",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("object",                   Object,       INVALID,         "o",     "",   (PHASES { phases::Link }))
+TYPE("treelang",                 Treelang,     INVALID,         nullptr, "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("image",                    Image,        INVALID,         "out",   "",   (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("dSYM",                     dSYM,         INVALID,         "dSYM",  "A",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("dependencies",             Dependencies, INVALID,         "d",     "",   (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("cuda-fatbin",              CUDA_FATBIN,  INVALID,         "fatbin","A",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("hip-fatbin",               HIP_FATBIN,   INVALID,         "hipfb", "A",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))
+TYPE("none",                     Nothing,      INVALID,         nullptr, "u",  (PHASES { phases::Compile, phases::Backend, phases::Assemble, phases::Link }))

clang/lib/Driver/Driver.cpp

class OffloadingActionBuilder final {
   Compilation &C;
 
   /// Map between an input argument and the offload kinds used to process it.
   std::map<const Arg *, unsigned> InputArgToOffloadKindMap;
 
   /// Builder interface. It doesn't build anything or keep any state.
   class DeviceActionBuilder {
   public:
     typedef llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PhasesTy;
 
     enum ActionBuilderReturnCode {
       // The builder acted successfully on the current action.
       ABRT_Success,
       // The builder didn't have to act on the current action.
       ABRT_Inactive,
       // The builder was successful and requested the host action to not be
       // generated.
public:
     virtual ~DeviceActionBuilder() {}
 
     /// Fill up the array \a DA with all the device dependences that should be
     /// added to the provided host action \a HostAction. By default it is
     /// inactive.
     virtual ActionBuilderReturnCode
     getDeviceDependences(OffloadAction::DeviceDependences &DA,
                          phases::ID CurPhase, phases::ID FinalPhase,
-                         PhasesTy &Phases) {
+                         const PhasesTy &Phases) {
       return ABRT_Inactive;
     }
 
     /// Update the state to include the provided host action \a HostAction as a
     /// dependency of the current device action. By default it is inactive.
     virtual ActionBuilderReturnCode addDeviceDepences(Action *HostAction) {
       return ABRT_Inactive;
     }
class OffloadingActionBuilder final {
   public:
     CudaActionBuilder(Compilation &C, DerivedArgList &Args,
                       const Driver::InputList &Inputs)
         : CudaActionBuilderBase(C, Args, Inputs, Action::OFK_Cuda) {}
 
     ActionBuilderReturnCode
     getDeviceDependences(OffloadAction::DeviceDependences &DA,
                          phases::ID CurPhase, phases::ID FinalPhase,
-                         PhasesTy &Phases) override {
+                         const PhasesTy &Phases) override {
       if (!IsActive)
         return ABRT_Inactive;
 
       // If we don't have more CUDA actions, we don't have any dependences to
       // create for the host.
       if (CudaDeviceActions.empty())
         return ABRT_Success;
 
HIPActionBuilder(Compilation &C, DerivedArgList &Args,
                      const Driver::InputList &Inputs)
         : CudaActionBuilderBase(C, Args, Inputs, Action::OFK_HIP) {}
 
     bool canUseBundlerUnbundler() const override { return true; }
 
     ActionBuilderReturnCode
     getDeviceDependences(OffloadAction::DeviceDependences &DA,
                          phases::ID CurPhase, phases::ID FinalPhase,
-                         PhasesTy &Phases) override {
+                         const PhasesTy &Phases) override {
       // amdgcn does not support linking of object files, therefore we skip
       // backend and assemble phases to output LLVM IR. Except for generating
       // non-relocatable device coee, where we generate fat binary for device
       // code and pass to host in Backend phase.
       if (CudaDeviceActions.empty() ||
           (CurPhase == phases::Backend && Relocatable) ||
           CurPhase == phases::Assemble)
         return ABRT_Success;
class OffloadingActionBuilder final {
   public:
     OpenMPActionBuilder(Compilation &C, DerivedArgList &Args,
                         const Driver::InputList &Inputs)
         : DeviceActionBuilder(C, Args, Inputs, Action::OFK_OpenMP) {}
 
     ActionBuilderReturnCode
     getDeviceDependences(OffloadAction::DeviceDependences &DA,
                          phases::ID CurPhase, phases::ID FinalPhase,
-                         PhasesTy &Phases) override {
+                         const PhasesTy &Phases) override {
       if (OpenMPDeviceActions.empty())
         return ABRT_Inactive;
 
       // We should always have an action for each input.
       assert(OpenMPDeviceActions.size() == ToolChains.size() &&
              "Number of OpenMP actions and toolchains do not match.");
 
       // The host only depends on device action in the linking phase, when all
public:
 
   /// Generate an action that adds device dependences (if any) to a host action.
   /// If no device dependence actions exist, just return the host action \a
   /// HostAction. If an error is found or if no builder requires the host action
   /// to be generated, return nullptr.
   Action *
   addDeviceDependencesToHostAction(Action *HostAction, const Arg *InputArg,
                                    phases::ID CurPhase, phases::ID FinalPhase,
-                                   DeviceActionBuilder::PhasesTy &Phases) {
+                                   const DeviceActionBuilder::PhasesTy &Phases) {
     if (!IsValid)
       return nullptr;
 
     if (SpecializedBuilders.empty())
       return HostAction;
 
     assert(HostAction && "Invalid host action!");
 
void Driver::BuildActions(Compilation &C, DerivedArgList &Args,
 
   // Builder to be used to build offloading actions.
   OffloadingActionBuilder OffloadBuilder(C, Args, Inputs);
 
   // Construct the actions to perform.
   HeaderModulePrecompileJobAction *HeaderModuleAction = nullptr;
   ActionList LinkerInputs;
 
-  llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL;
+  unsigned LastPLSize = 0;
   for (auto &I : Inputs) {
     types::ID InputType = I.first;
     const Arg *InputArg = I.second;
 
-    PL.clear();
-    types::getCompilationPhases(InputType, PL);
+    const llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> &PL =
+        types::getCompilationPhases(InputType);
+    LastPLSize = PL.size();
 
     // If the first step comes after the final phase we are doing as part of
     // this compilation, warn the user about it.
     phases::ID InitialPhase = PL[0];
     if (InitialPhase > FinalPhase) {
       if (InputArg->isClaimed())
         continue;
 
if (InitialPhase > FinalPhase) {
             << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
       continue;
     }
 
     if (YcArg) {
       // Add a separate precompile phase for the compile phase.
       if (FinalPhase >= phases::Compile) {
         const types::ID HeaderType = lookupHeaderTypeForSourceType(InputType);
-        llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PCHPL;
-        types::getCompilationPhases(HeaderType, PCHPL);
+        const llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> &PCHPL =
+            types::getCompilationPhases(HeaderType);
         // Build the pipeline for the pch file.
         Action *ClangClPch =
             C.MakeAction<InputAction>(*InputArg, HeaderType);
         for (phases::ID Phase : PCHPL)
           ClangClPch = ConstructPhaseAction(C, Args, Phase, ClangClPch);
         assert(ClangClPch);
         Actions.push_back(ClangClPch);
         // The driver currently exits after the first failed command.  This
         // relies on that behavior, to make sure if the pch generation fails,
         // the main compilation won't run.
         // FIXME: If the main compilation fails, the PCH generation should
         // probably not be considered successful either.
       }
     }
 
     // Build the pipeline for this file.
     Action *Current = C.MakeAction<InputAction>(*InputArg, InputType);
 
     // Use the current host action in any of the offloading actions, if
     // required.
     if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
       break;
 
-    for (SmallVectorImpl<phases::ID>::iterator i = PL.begin(), e = PL.end();
-         i != e; ++i) {
+    for (auto 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;
 
       // Add any offload action the host action depends on.
       Current = OffloadBuilder.addDeviceDependencesToHostAction(
void Driver::BuildActions(Compilation &C, DerivedArgList &Args,
   if (!LinkerInputs.empty()) {
     Action *LA = C.MakeAction<LinkJobAction>(LinkerInputs, types::TY_Image);
     LA = OffloadBuilder.processHostLinkAction(LA);
     Actions.push_back(LA);
   }
 
   // If we are linking, claim any options which are obviously only used for
   // compilation.
-  if (FinalPhase == phases::Link && PL.size() == 1) {
+  // FIXME: Understand why the last Phase List length is used here.
+  if (FinalPhase == phases::Link && LastPLSize == 1) {
     Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
     Args.ClaimAllArgs(options::OPT_cl_compile_Group);
   }
 
   // If --print-supported-cpus, -mcpu=? or -mtune=? is specified, build a custom
   // Compile phase that prints out supported cpu models and quits.
   if (Arg *A = Args.getLastArg(options::OPT_print_supported_cpus)) {
     // Use the -mcpu=? flag as the dummy input to cc1.

clang/lib/Driver/Types.cpp

 //===--- Types.cpp - Driver input & temporary type information ------------===//
 //
 // 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 "clang/Driver/Types.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/SmallVector.h"
 #include <cassert>
-#include <string.h>
 
 using namespace clang::driver;
 using namespace clang::driver::types;
 
 struct TypeInfo {
   const char *Name;
   const char *Flags;
   const char *TempSuffix;
   ID PreprocessedType;
+  const llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> Phases;
 };
 
 static const TypeInfo TypeInfos[] = {
-#define TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, FLAGS) \
-  { NAME, FLAGS, TEMP_SUFFIX, TY_##PP_TYPE, },
+#define TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, FLAGS, PHASES) \
+  { NAME, FLAGS, TEMP_SUFFIX, TY_##PP_TYPE, PHASES, },
+#define PHASES llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
 #include "clang/Driver/Types.def"
 #undef TYPE
 };
 static const unsigned numTypes = llvm::array_lengthof(TypeInfos);
 
 static const TypeInfo &getInfo(unsigned id) {
   assert(id > 0 && id - 1 < numTypes && "Invalid Type ID.");
   return TypeInfos[id - 1];
if (canTypeBeUserSpecified(Id) &&
         strcmp(Name, getInfo(Id).Name) == 0)
       return Id;
   }
 
   return TY_INVALID;
 }
 
 // FIXME: Why don't we just put this list in the defs file, eh.
-void types::getCompilationPhases(ID Id, llvm::SmallVectorImpl<phases::ID> &P) {
+// FIXME: The list is now in Types.def but for now this function will verify
+//        the old behavior and a subsequent change will delete most of the body.
+const llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> &types::getCompilationPhases(ID Id) {
+  llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> P;
   if (Id != TY_Object) {
     if (getPreprocessedType(Id) != TY_INVALID) {
       P.push_back(phases::Preprocess);
     }
 
     if (getPrecompiledType(Id) != TY_INVALID) {
       P.push_back(phases::Precompile);
     }
 
     if (!onlyPrecompileType(Id)) {
       if (!onlyAssembleType(Id)) {
         P.push_back(phases::Compile);
         P.push_back(phases::Backend);
       }
       P.push_back(phases::Assemble);
     }
   }
 
   if (!onlyPrecompileType(Id)) {
     P.push_back(phases::Link);
   }
   assert(0 < P.size() && "Not enough phases in list");
   assert(P.size() <= phases::MaxNumberOfPhases && "Too many phases in list");
+
+  const llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> &Phases = getInfo(Id).Phases;
+  assert(Phases.size() == P.size() && "Invalid size.");
+  for (unsigned i = 0; i < Phases.size(); i++)
+    assert(Phases[i] == P[i] && "Invalid Phase");
+
+  return Phases;
 }
 
 ID types::lookupCXXTypeForCType(ID Id) {
   switch (Id) {
   default:
     return Id;
 
   case types::TY_C:
     return types::TY_CXX;
   case types::TY_PP_C:
     return types::TY_PP_CXX;
   case types::TY_CHeader: