[clang][driver] Find Apple default SDK path

[thieta]

Summary

Currently if you download clang and install it on macOS it will
not be able to compile C++ applications out of the box. The
driver can't find the SDK path without help of SDKROOT or -isysroot.

For the Xcode toolchain this is always supplied with xcrun or
the wrapper binary that sets the correct SDKROOT.

But for new users this might be very confusing and since the
path for the SDKs is stable unless the user decide to install
Xcode to an alternative path we can try a naive search for it.

Currently this patch fails a bunch of tests that seems to assume
that no SDK is found and then the macosx-min stuff is set to
something very low. This changes when you have a real SDK.

I also haven't added any new tests to test this since I am didn't
want to assume that Xcode is installed on the system running the
tests. Does anyone have a good idea for testing this?

Tagged a bunch of apple people that have touched the driver
recently - but feel free to add more in here if needed.

[thieta]

Ping - any thoughts on this one?

[dexonsmith]

I’m not at Apple anymore, but this is a long-standing platform decision that is intentional and seems unlikely to change. Note that /usr/bin/clang isn’t really clang, but a tool called xcrun which adds environment variables to help find a default SDK before executing /path/to/toolchain/usr/bin/clang.

When the driver is called directly it expects the build system to provide the appropriate SDK. There are situations where it could cause a problem for the driver to hunt around tor arbitrary SDKs.

If you still want to pursue this, @arphaman might be able to help find someone in a position to consider the impact / policy.

[MaskRay]

(With configuration file improvement, you can express the intention with a default configuration file.)

clang/lib/Driver/ToolChains/Darwin.cpp

 #include "clang/Basic/AlignedAllocation.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/TargetParser.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <cstdlib> // ::getenv
if (!SDKInfoOrErr) {
     TheDriver.Diag(diag::warn_drv_darwin_sdk_invalid_settings);
     return None;
   }
   return *SDKInfoOrErr;
 }
 
 } // namespace
 
+static const std::string guessSDKPath(const llvm::Triple::OSType OSType) {
+  std::string Platform;
+
+  if (OSType == llvm::Triple::OSType::MacOSX || OSType == llvm::Triple::OSType::Darwin) {
+    // Assume macOS when nothing specific is specified.
+    Platform = "MacOSX";
+  } else if (OSType == llvm::Triple::OSType::IOS) {
+    Platform = "IPhoneOS";
+  } else if (OSType == llvm::Triple::OSType::TvOS) {
+    Platform = "AppleTVOS";
+  } else if (OSType == llvm::Triple::OSType::WatchOS) {
+    Platform = "WatchOS";
+  }
+
+  std::string GuessPath = (
+    "/Applications/Xcode.app/Contents/Developer/Platforms/"
+    + Platform
+    + ".platform/Developer/SDKs/"
+    + Platform
+    + ".sdk");
+
+  return GuessPath;
+}
+
 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
   const OptTable &Opts = getDriver().getOpts();
 
   // Support allowing the SDKROOT environment variable used by xcrun and other
   // Xcode tools to define the default sysroot, by making it the default for
   // isysroot.
   if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
     // Warn if the path does not exist.
     if (!getVFS().exists(A->getValue()))
       getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
   } else {
     if (char *env = ::getenv("SDKROOT")) {
       // We only use this value as the default if it is an absolute path,
       // exists, and it is not the root path.
       if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
           StringRef(env) != "/") {
         Args.append(Args.MakeSeparateArg(
             nullptr, Opts.getOption(options::OPT_isysroot), env));
       }
+    } else {
+      // If the user doesn't pass -isysroot nor SDKROOT we will try to guess
+      // the standard path of the SDK (in /Applications/Xcode.app ...)
+      const std::string GuessPath = guessSDKPath(getTriple().getOS());
+      if (getVFS().exists(GuessPath)) {
+        Args.append(Args.MakeSeparateArg(
+          nullptr, Opts.getOption(options::OPT_isysroot), GuessPath));
+      }
     }
   }
 
   // Read the SDKSettings.json file for more information, like the SDK version
   // that we can pass down to the compiler.
   SDKInfo = parseSDKSettings(getVFS(), Args, getDriver());
 
   // The OS and the version can be specified using the -target argument.

 
 // Returns the effective header sysroot path to use. This comes either from
 // -isysroot or --sysroot.
 llvm::StringRef DarwinClang::GetHeaderSysroot(const llvm::opt::ArgList &DriverArgs) const {
   if(DriverArgs.hasArg(options::OPT_isysroot))
     return DriverArgs.getLastArgValue(options::OPT_isysroot);
   if (!getDriver().SysRoot.empty())
     return getDriver().SysRoot;
+
   return "/";
 }
 
 void DarwinClang::AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                                             llvm::opt::ArgStringList &CC1Args) const {
   const Driver &D = getDriver();
 
   llvm::StringRef Sysroot = GetHeaderSysroot(DriverArgs);