[Driver] Remove the notion of Tools, turn ToolChain into an Action visitor.

The "Tool" abstraction wasn't buying us enough to deserve the added
complexity. Now a ToolChain turns Actions into Jobs, and every helper
tool is searched for relative to Swift first. Much simpler.

Swift SVN r31563

Author: jrose-apple

include/swift/Driver/Job.h

@@ -33,7 +33,6 @@ namespace driver {
 class Action;
 class InputAction;
 class Job;
-class Tool;
 
 class CommandOutput {
   types::ID PrimaryOutputType;
@@ -89,12 +88,9 @@ class Job {
   };
 
 private:
-  /// The action which caused the creation of this Job.
-  const Action &Source;
-
-  /// The tool which created this Job, and the conditions under which it must
-  /// be run.
-  llvm::PointerIntPair<const Tool *, 2, Condition> CreatorAndCondition;
+  /// The action which caused the creation of this Job, and the conditions
+  /// under which it must be run.
+  llvm::PointerIntPair<const Action *, 2, Condition> SourceAndCondition;
 
   /// The list of other Jobs which are inputs to this Job.
   SmallVector<const Job *, 4> Inputs;
@@ -113,17 +109,16 @@ class Job {
   llvm::sys::TimeValue InputModTime = llvm::sys::TimeValue::MaxTime();
 
 public:
-  Job(const Action &Source, const Tool &Creator,
+  Job(const Action &Source,
       SmallVectorImpl<const Job *> &&Inputs,
       std::unique_ptr<CommandOutput> Output,
       const char *Executable,
       llvm::opt::ArgStringList Arguments)
-      : Source(Source), CreatorAndCondition(&Creator, Condition::Always),
+      : SourceAndCondition(&Source, Condition::Always),
         Inputs(std::move(Inputs)), Output(std::move(Output)),
         Executable(Executable), Arguments(std::move(Arguments)) {}
 
-  const Action &getSource() const { return Source; }
-  const Tool &getCreator() const { return *CreatorAndCondition.getPointer(); }
+  const Action &getSource() const { return *SourceAndCondition.getPointer(); }
 
   const char *getExecutable() const { return Executable; }
   const llvm::opt::ArgStringList &getArguments() const { return Arguments; }
@@ -132,10 +127,10 @@ class Job {
   const CommandOutput &getOutput() const { return *Output; }
 
   Condition getCondition() const {
-    return CreatorAndCondition.getInt();
+    return SourceAndCondition.getInt();
   }
   void setCondition(Condition Cond) {
-    CreatorAndCondition.setInt(Cond);
+    SourceAndCondition.setInt(Cond);
   }
 
   void setInputModTime(llvm::sys::TimeValue time) {

include/swift/Driver/Tool.h

@@ -13,67 +13,109 @@
 #ifndef SWIFT_DRIVER_TOOLCHAIN_H
 #define SWIFT_DRIVER_TOOLCHAIN_H
 
-#include "swift/Basic/LLVM.h"
 #include "swift/Driver/Action.h"
 #include "swift/Driver/Types.h"
-#include "llvm/Support/Program.h"
+#include "swift/Basic/LLVM.h"
+#include "llvm/Option/Option.h"
 #include "llvm/ADT/Triple.h"
 
 #include <memory>
 
-namespace llvm {
-namespace opt {
-  class ArgList;
-  class DerivedArgList;
-  class InputArgList;
-}
-}
-
 namespace swift {
 namespace driver {
+  class CommandOutput;
   class Compilation;
   class Driver;
-  class Tool;
-
+  class Job;
+  class OutputInfo;
+
+/// A ToolChain is responsible for turning abstract Actions into concrete,
+/// runnable Jobs.
+///
+/// The primary purpose of a ToolChain is built around the
+/// \c constructInvocation family of methods. This is a set of callbacks
+/// following the Visitor pattern for the various JobAction subclasses, which
+/// returns an executable name and arguments for the Job to be run. The base
+/// ToolChain knows how to perform most operations, but some (like linking)
+/// require platform-specific knowledge, provided in subclasses.
 class ToolChain {
   const Driver &D;
   const llvm::Triple Triple;
-
-  mutable std::unique_ptr<Tool> Swift;
-  mutable std::unique_ptr<Tool> MergeModule;
-  mutable std::unique_ptr<Tool> LLDB;
-  mutable std::unique_ptr<Tool> Linker;
-  mutable std::unique_ptr<Tool> Dsymutil;
-  mutable std::unique_ptr<Tool> AutolinkExtract;
-
-  Tool *getSwift() const;
-  Tool *getMergeModule() const;
-  Tool *getLLDB() const;
-  Tool *getLinker() const;
-  Tool *getDsymutil() const;
-  Tool *getAutolinkExtract() const;
+  mutable llvm::StringMap<std::string> ProgramLookupCache;
 
 protected:
   ToolChain(const Driver &D, const llvm::Triple &T) : D(D), Triple(T) {}
 
-  virtual std::unique_ptr<Tool> buildLinker() const = 0;
+  /// A special name used to identify the Swift executable itself.
+  constexpr static const char * const SWIFT_EXECUTABLE_NAME = "swift";
+
+  /// Packs together the supplementary information about the job being created.
+  struct JobContext {
+    ArrayRef<const Job *> Inputs;
+    const CommandOutput &Output;
+    ArrayRef<const Action *> InputActions;
+    const llvm::opt::ArgList &Args;
+    const OutputInfo &OI;
+  };
+
+  virtual std::pair<const char *, llvm::opt::ArgStringList>
+  constructInvocation(const CompileJobAction &job,
+                      const JobContext &context) const;
+  virtual std::pair<const char *, llvm::opt::ArgStringList>
+  constructInvocation(const BackendJobAction &job,
+                      const JobContext &context) const;
+  virtual std::pair<const char *, llvm::opt::ArgStringList>
+  constructInvocation(const MergeModuleJobAction &job,
+                      const JobContext &context) const;
+
+  virtual std::pair<const char *, llvm::opt::ArgStringList>
+  constructInvocation(const REPLJobAction &job,
+                      const JobContext &context) const;
+
+  virtual std::pair<const char *, llvm::opt::ArgStringList>
+  constructInvocation(const GenerateDSYMJobAction &job,
+                      const JobContext &context) const;
+  virtual std::pair<const char *, llvm::opt::ArgStringList>
+  constructInvocation(const AutolinkExtractJobAction &job,
+                      const JobContext &context) const;
+  virtual std::pair<const char *, llvm::opt::ArgStringList>
+  constructInvocation(const LinkJobAction &job,
+                      const JobContext &context) const;
+
+  /// Searches for the given executable in appropriate paths relative to the
+  /// Swift binary.
+  ///
+  /// This method caches its results.
+  ///
+  /// \sa findProgramRelativeToSwiftImpl
+  std::string findProgramRelativeToSwift(StringRef name) const;
+
+  /// An override point for platform-specific subclasses to customize how to
+  /// do relative searches for programs.
+  ///
+  /// This method is invoked by findProgramRelativeToSwift().
+  virtual std::string findProgramRelativeToSwiftImpl(StringRef name) const;
 
 public:
   virtual ~ToolChain() = default;
 
-  // Accessors
-
   const Driver &getDriver() const { return D; }
   const llvm::Triple &getTriple() const { return Triple; }
 
-  /// Choose a tool to use to handle the action \p JA.
-  virtual Tool *selectTool(const JobAction &JA) const;
+  /// Construct a Job for the action \p JA, taking the given information into
+  /// account.
+  ///
+  /// This method dispatches to the various \c constructInvocation methods,
+  /// which may be overridden by platform-specific subclasses.
+  std::unique_ptr<Job> constructJob(const JobAction &JA,
+                                    SmallVectorImpl<const Job *> &&inputs,
+                                    std::unique_ptr<CommandOutput> output,
+                                    const ActionList &inputActions,
+                                    const llvm::opt::ArgList &args,
+                                    const OutputInfo &OI) const;
 
   /// Look up \p Name in the list of program search paths.
-  virtual std::string getProgramPath(StringRef Name) const;
-
-  // Platform defaults information
-
+  ///
   /// Return the default langauge type to use for the given extension.
   virtual types::ID lookupTypeForExtension(StringRef Ext) const;
 };

include/swift/Driver/ToolChain.h

@@ -30,17 +30,6 @@ namespace driver {
     DynamicLibrary
   };
 
-  /// Searches for an executable relative to the compiler itself.
-  ///
-  /// This first looks next to the compiler binary, then checks to see if the
-  /// compiler is in an Xcode toolchain and looks in the bin directory outside
-  /// the toolchain.
-  ///
-  /// \returns The path to the executable being searched for, or an empty string
-  /// if it cannot be found.
-  std::string findRelativeExecutable(StringRef compilerPath,
-                                     StringRef executableName);
-
 } // end namespace driver
 } // end namespace swift
 

include/swift/Driver/Util.h

@@ -72,7 +72,7 @@ def driver_print_actions : Flag<["-"], "driver-print-actions">,
 def driver_print_output_file_map : Flag<["-"], "driver-print-output-file-map">,
   InternalDebugOpt, HelpText<"Dump the contents of the output file map">;
 def driver_print_bindings : Flag<["-"], "driver-print-bindings">,
-  InternalDebugOpt, HelpText<"Dump list of bindings">;
+  InternalDebugOpt, HelpText<"Dump list of job inputs and outputs">;
 def driver_print_jobs : Flag<["-"], "driver-print-jobs">, InternalDebugOpt,
   HelpText<"Dump list of jobs to execute">;
 def _HASH_HASH_HASH : Flag<["-"], "###">, Alias<driver_print_jobs>;

include/swift/Option/Options.td

@@ -7,12 +7,9 @@ set(swiftDriver_sources
   Job.cpp
   OutputFileMap.cpp
   ParseableOutput.cpp
-  Tool.cpp
-  Tools.cpp
   ToolChain.cpp
   ToolChains.cpp
   Types.cpp
-  Util.cpp
   )
 
 add_swift_library(swiftDriver

lib/Driver/CMakeLists.txt

@@ -23,7 +23,6 @@
 #include "swift/Driver/Driver.h"
 #include "swift/Driver/Job.h"
 #include "swift/Driver/ParseableOutput.h"
-#include "swift/Driver/Tool.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TinyPtrVector.h"
@@ -338,7 +337,7 @@ int Compilation::performJobsImpl() {
     }
   }
 
-  int Result = 0;
+  int Result = EXIT_SUCCESS;
 
   // Set up a callback which will be called immediately after a task has
   // started. This callback may be used to provide output indicating that the
@@ -374,21 +373,23 @@ int Compilation::performJobsImpl() {
         llvm::errs() << Output;
     }
 
-    if (ReturnCode != 0) {
+    if (ReturnCode != EXIT_SUCCESS) {
       // The task failed, so return true without performing any further
       // dependency analysis.
 
       // Store this task's ReturnCode as our Result if we haven't stored
       // anything yet.
-      if (Result == 0)
+      if (Result == EXIT_SUCCESS)
         Result = ReturnCode;
 
-      if (!FinishedCmd->getCreator().hasGoodDiagnostics() || ReturnCode != 1)
+      if (!isa<CompileJobAction>(FinishedCmd->getSource()) ||
+          ReturnCode != EXIT_FAILURE) {
         Diags.diagnose(SourceLoc(), diag::error_command_failed,
-                       FinishedCmd->getCreator().getNameForDiagnostics(),
+                       FinishedCmd->getSource().getClassName(),
                        ReturnCode);
+      }
 
-      return ContinueBuildingAfterErrors ? 
+      return ContinueBuildingAfterErrors ?
           TaskFinishedResponse::ContinueExecution :
           TaskFinishedResponse::StopExecution;
     }
@@ -455,7 +456,7 @@ int Compilation::performJobsImpl() {
                      ErrorMsg);
 
     Diags.diagnose(SourceLoc(), diag::error_command_signalled,
-                   SignalledCmd->getCreator().getNameForDiagnostics());
+                   SignalledCmd->getSource().getClassName());
 
     // Since the task signalled, so unconditionally set result to -2.
     Result = -2;