Make ToolChain::SelectTool virtual.

[dougk]

Summary

This allows ToolChain to decide if Clang is not the right C compiler.

Also, removed comment in Driver::ShouldUseClangCompiler implying that there was an opt-out ability at that point - there isn't.

[chandlerc]

Suggested some improvements to the comments below. Generally, this makes sense, but I think you should also mention your end-goal in the commit log. I happen to know because we've chatted, and so this change makes sense to me, but others won't have that context.

For those reading the review log, the context is that there exist some embedded platforms which use specialized C derivatives and C compilers where Clang doesn't support their derivative yet. We'd like to add support for these platforms to Clang, but at least until we do, its useful if the toolchain for such an embedded target can detect special flags and dispatch to whatever embedded compiler is commonly used. This makes the Clang driver more of a drop-in replacement and starts us down the path of support.

Actually, Doug, it might be worth sending an email to cfe-dev with the overall plan you have here to support C-dialects on embedded platforms by dispatching to the vendor-provided SDK until Clang grows support for that dialect. There you can give an overview and hopefully that'll provide context for folks seeing these commits.

[chandlerc]

Folks on cfe-dev seem happy with this direction, so go ahead and submit with a tweaked comment as below...

include/clang/Driver/ToolChain.h

166–171

Sorry, my inline comment didn't take the first time.

I feel like this comment can be more direct, and avoid the weird "virtualized" wording. How about something like this:

/// Choose a tool to handle the action \p JA.
///
/// This can be overridden when a particular ToolChain needs to use
/// a C compiler other than Clang.

I think going into Driver::ShouldUseClangCompiler is more appropriate for the change description than a comment, it isn't really useful documentation to the reader of the interface.

include/clang/Driver/ToolChain.h

public:
   ///
   /// \param BoundArch - The bound architecture name, or 0.
   virtual llvm::opt::DerivedArgList *
   TranslateArgs(const llvm::opt::DerivedArgList &Args,
                 const char *BoundArch) const {
     return nullptr;
   }
 
   /// Choose a tool to use to handle the action \p JA.
-  Tool *SelectTool(const JobAction &JA) const;
+  /// This is virtualized because there are scenarios where you want the
+  /// default driver in the default driver-mode not to pick Clang as
+  /// the right tool for a C program, at the discretion of the ToolChain.
+  /// GetTool is overridable, but it's also necessary to avoid inquiring with
+  /// Driver::ShouldUseClangCompiler() which says "yes" to C, usually.
+  virtual Tool *SelectTool(const JobAction &JA) const;
 
   // Helper methods
 
   std::string GetFilePath(const char *Name) const;
   std::string GetProgramPath(const char *Name) const;
 
   /// Returns the linker path, respecting the -fuse-ld= argument to determine
   /// the linker suffix or name.

lib/Driver/Driver.cpp

default:
         TC = new toolchains::Generic_GCC(*this, Target, Args);
       break;
     }
   }
   return *TC;
 }
 
 bool Driver::ShouldUseClangCompiler(const JobAction &JA) const {
-  // Check if user requested no clang, or clang doesn't understand this type (we
-  // only handle single inputs for now).
+  // Say "no" if there is not exactly one input of a type clang understands.
   if (JA.size() != 1 ||
       !types::isAcceptedByClang((*JA.begin())->getType()))
     return false;
 
-  // Otherwise make sure this is an action clang understands.
+  // And say "no" if this is not a kind of action clang understands.
   if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
       !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
     return false;
 
   return true;
 }
 
 /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the