[driver] Refactor getRuntimePaths. NFC

[smeenai]

Summary

This used to be getRuntimePath till https://reviews.llvm.org/D115049
added a fallback search path for Android. As far as I can tell, the
intent has always been to use the first existing path though instead of
actually supporting multiple runtime paths. We can move the existence
checks into getRuntimePath and have it return std::optional, which also
makes the --print-runtime-dir behavior much cleaner.

The motivation is a follow-up change to Android runtime path searches,
which is much nicer with this in place.

[smeenai]

Rebase

[phosek]

LGTM

[glandium]

This conflicts with D146664

[smeenai]

In D158475#4623471, @glandium wrote:

This conflicts with D146664

It sounds like you want the same logic as D158476 to apply to the stdlib search as well as the runtimes search, right? I can make both be consistent.

[glandium]

In D158475#4623842, @smeenai wrote:

In D158475#4623471, @glandium wrote:

This conflicts with D146664

It sounds like you want the same logic as D158476 to apply to the stdlib search as well as the runtimes search, right?

Sounds about right.

I can make both be consistent.

That would be much appreciated.

[smeenai]

In D158475#4623852, @glandium wrote:

In D158475#4623842, @smeenai wrote:

In D158475#4623471, @glandium wrote:

This conflicts with D146664

It sounds like you want the same logic as D158476 to apply to the stdlib search as well as the runtimes search, right?

Sounds about right.

I can make both be consistent.

That would be much appreciated.

I'm halfway through an implementation of this, but I just realized that on Android, Clang never searches for C++ headers installed alongside the driver: https://github.com/llvm/llvm-project/blob/7af0eff5405bb88dc96c0b19892da0fbb44db433/clang/lib/Driver/ToolChains/Gnu.cpp#L3116-L3118. Are you using the C++ headers from the NDK but a library that you built locally, or are you manually specifying the path to your C++ headers?

[glandium]

In D158475#4626636, @smeenai wrote:

I'm halfway through an implementation of this, but I just realized that on Android, Clang never searches for C++ headers installed alongside the driver: https://github.com/llvm/llvm-project/blob/7af0eff5405bb88dc96c0b19892da0fbb44db433/clang/lib/Driver/ToolChains/Gnu.cpp#L3116-L3118. Are you using the C++ headers from the NDK but a library that you built locally, or are you manually specifying the path to your C++ headers?

At the moment, we're only really using libunwind from the clang stdlib directory. So we don't really have the problem with headers. It will eventually be a problem when we get to use libc++, which we'll want at some point.

[smeenai]

In D158475#4626856, @glandium wrote:

In D158475#4626636, @smeenai wrote:

I'm halfway through an implementation of this, but I just realized that on Android, Clang never searches for C++ headers installed alongside the driver: https://github.com/llvm/llvm-project/blob/7af0eff5405bb88dc96c0b19892da0fbb44db433/clang/lib/Driver/ToolChains/Gnu.cpp#L3116-L3118. Are you using the C++ headers from the NDK but a library that you built locally, or are you manually specifying the path to your C++ headers?

At the moment, we're only really using libunwind from the clang stdlib directory. So we don't really have the problem with headers. It will eventually be a problem when we get to use libc++, which we'll want at some point.

I decided to just fix the whole thing properly: D159292 and D159293.

clang/include/clang/Driver/ToolChain.h

 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/TargetParser/Triple.h"
 #include <cassert>
 #include <climits>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
 namespace llvm {
 namespace opt {
 
 class Arg;
 class ArgList;
public:
   const char *
   getCompilerRTArgString(const llvm::opt::ArgList &Args, StringRef Component,
                          FileType Type = ToolChain::FT_Static) const;
 
   std::string getCompilerRTBasename(const llvm::opt::ArgList &Args,
                                     StringRef Component,
                                     FileType Type = ToolChain::FT_Static) const;
 
-  // Returns target specific runtime paths.
-  path_list getRuntimePaths() const;
+  // Returns the target specific runtime path if it exists.
+  std::optional<std::string> getRuntimePath() const;
 
   // Returns target specific standard library paths.
   path_list getStdlibPaths() const;
 
   // Returns <ResourceDir>/lib/<OSName>/<arch> or <ResourceDir>/lib/<triple>.
   // This is used by runtimes (such as OpenMP) to find arch-specific libraries.
   virtual path_list getArchSpecificLibPaths() const;
 

clang/lib/Driver/Driver.cpp

for (const std::string &Path : TC.getFilePaths()) {
       else
         llvm::outs() << Path;
     }
     llvm::outs() << "\n";
     return false;
   }
 
   if (C.getArgs().hasArg(options::OPT_print_runtime_dir)) {
-    std::string RuntimePath;
-    // Get the first existing path, if any.
-    for (auto Path : TC.getRuntimePaths()) {
-      if (getVFS().exists(Path)) {
-        RuntimePath = Path;
-        break;
-      }
-    }
-    if (!RuntimePath.empty())
-      llvm::outs() << RuntimePath << '\n';
+    if (std::optional<std::string> RuntimePath = TC.getRuntimePath())
+      llvm::outs() << *RuntimePath << '\n';
     else
       llvm::outs() << TC.getCompilerRTPath() << '\n';
     return false;
   }
 
   if (C.getArgs().hasArg(options::OPT_print_diagnostic_options)) {
     std::vector<std::string> Flags = DiagnosticIDs::getDiagnosticFlags();
     for (std::size_t I = 0; I != Flags.size(); I += 2)

clang/lib/Driver/ToolChain.cpp

ToolChain::ToolChain(const Driver &D, const llvm::Triple &T,
                      const ArgList &Args)
     : D(D), Triple(T), Args(Args), CachedRTTIArg(GetRTTIArgument(Args)),
       CachedRTTIMode(CalculateRTTIMode(Args, Triple, CachedRTTIArg)) {
   auto addIfExists = [this](path_list &List, const std::string &Path) {
     if (getVFS().exists(Path))
       List.push_back(Path);
   };
 
-  for (const auto &Path : getRuntimePaths())
-    addIfExists(getLibraryPaths(), Path);
+  if (std::optional<std::string> Path = getRuntimePath())
+    getLibraryPaths().push_back(*Path);
   for (const auto &Path : getStdlibPaths())
     addIfExists(getFilePaths(), Path);
   for (const auto &Path : getArchSpecificLibPaths())
     addIfExists(getFilePaths(), Path);
 }
 
 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
 ToolChain::executeToolChainProgram(StringRef Executable) const {

 }
 
 const char *ToolChain::getCompilerRTArgString(const llvm::opt::ArgList &Args,
                                               StringRef Component,
                                               FileType Type) const {
   return Args.MakeArgString(getCompilerRT(Args, Component, Type));
 }
 
-ToolChain::path_list ToolChain::getRuntimePaths() const {
-  path_list Paths;
-  auto addPathForTriple = [this, &Paths](const llvm::Triple &Triple) {
+std::optional<std::string> ToolChain::getRuntimePath() const {
+  auto getPathForTriple =
+      [this](const llvm::Triple &Triple) -> std::optional<std::string> {
     SmallString<128> P(D.ResourceDir);
     llvm::sys::path::append(P, "lib", Triple.str());
-    Paths.push_back(std::string(P.str()));
+    if (getVFS().exists(P))
+      return std::string(P);
+    return {};
   };
 
-  addPathForTriple(getTriple());
+  if (auto Path = getPathForTriple(getTriple()))
+    return *Path;
 
   // When building with per target runtime directories, various ways of naming
   // the Arm architecture may have been normalised to simply "arm".
   // For example "armv8l" (Armv8 AArch32 little endian) is replaced with "arm".
   // Since an armv8l system can use libraries built for earlier architecture
   // versions assuming endian and float ABI match.
   //
   // Original triple: armv8l-unknown-linux-gnueabihf
   //  Runtime triple: arm-unknown-linux-gnueabihf
   //
   // We do not do this for armeb (big endian) because doing so could make us
   // select little endian libraries. In addition, all known armeb triples only
   // use the "armeb" architecture name.
   //
   // M profile Arm is bare metal and we know they will not be using the per
   // target runtime directory layout.
   if (getTriple().getArch() == Triple::arm && !getTriple().isArmMClass()) {
     llvm::Triple ArmTriple = getTriple();
     ArmTriple.setArch(Triple::arm);
-    addPathForTriple(ArmTriple);
+    if (auto Path = getPathForTriple(ArmTriple))
+      return *Path;
   }
 
   // Android targets may include an API level at the end. We still want to fall
   // back on a path without the API level.
   if (getTriple().isAndroid() &&
       getTriple().getEnvironmentName() != "android") {
     llvm::Triple TripleWithoutLevel = getTriple();
     TripleWithoutLevel.setEnvironmentName("android");
-    addPathForTriple(TripleWithoutLevel);
+    if (auto Path = getPathForTriple(TripleWithoutLevel))
+      return *Path;
   }
 
-  return Paths;
+  return {};
 }
 
 ToolChain::path_list ToolChain::getStdlibPaths() const {
   path_list Paths;
   SmallString<128> P(D.Dir);
   llvm::sys::path::append(P, "..", "lib", getTripleString());
   Paths.push_back(std::string(P.str()));