Add android-ndk-standalone test; add armv7 and thumb include and lib paths

[chh]

Summary

Add a new test android-ndk-standalone.cpp with new Android SDK release tree structure.
Detect armv7 sub architecture and thumb mode, to add system include and link search paths.

[rengolin]

Hi Chih-Hung,

Thanks for working on this, it could really help cross compilation.

I have a few inline comments, mostly to use the target parser instead of string parsing, but overall, looks good.

I'm also interested why you changed the version of the GCC (to 4.9). Does that change in any way from previous versions, or is that just to common up 4.4.3 and 4.8 into a single one? If it is, why not just keep 4.8 and avoid spurious changes?

cheers,
--renato

lib/Driver/ToolChains.cpp

1476

Why the /* static */ comment? Looks unnecessary. :)

1488

Please, use

if (ARM::parseArchVersion(Arch) == 7)

1495

We don't want to encourage "thumb" arches, and the TargetParser already deals with that (via parseArchISA), so you can simplify this method considerably by:

bool Thumb = Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) ||
             ARM::parseArchISA(Arch) == ARM::IK_THUMB;

1499

Same thing here... just change Thumb and create a Version variable and use them in your decision making, it should reduce to a single if / else if / else.

4398

Same thing here, use the target parser.

[chh]

Renato,

Thanks for the suggestions. I will upload a new patch using the target parser.

About the test input files and gcc versions, I made those changes to match current Android NDK file structure, which uses GCC 4.9. The version number is less important but file locations are different in newer NDK, or they were just not there in current test input. They are necessary for newer test cases to check if clang driver finds header file and library directories. I hope this patch does not affect other platforms.

[rengolin]

In D20600#439441, @chh wrote:

About the test input files and gcc versions, I made those changes to match current Android NDK file structure, which uses GCC 4.9. The version number is less important but file locations are different in newer NDK, or they were just not there in current test input. They are necessary for newer test cases to check if clang driver finds header file and library directories. I hope this patch does not affect other platforms.

Oh, the patch certainly *will* affect all Linux/GCC platforms, but I'm counting on it. So, please, don't remove the old tests, only add new ones. 4.9 may be the new NDK, but people could still be using the old one, even on Android. We'd also need a non-Android test, to make sure this works well on plain Linux, too. It should be fine to test on x86_64 only.

Once the patch is ready, I'll test in on my side (various Linaro toolchains, ARM, AArch64, Arch Linux) and see if it behaves well.

cheers,
--renato

[rengolin]

Adding some people that have touched the search path / toolchain part of the Clang driver, as this may change more things than it intends, and I'm a bit rusty with that code.

[chh]

lib/Driver/ToolChains.cpp

1476

It looks like some coding style. I found it used in CollectLibDirsAndTriples and Linux::GCCVersion::Parse.

1488

I changed it to also check SubArch, in case -march flag is not used:

llvm::ARM::parseArchVersion(Arch) == 7 ||
(Triple.getSubArch() == llvm::Triple::ARMSubArch_v7 && Arch == "")

[atanasyan]

• You do not need to add .keep file to the folder if this folder contains sub-folders or files. For example test/Driver/Inputs/basic_android_ndk_tree/include/c++/4.9/mipsel-linux-android/.keep is redundant.

• I am not sure but maybe something like basic_android_tree_v2 is better than basic_android_ndk_tree because in that case it is clear how to name new directories tree when NDK will change it in the future once again.

• Did you try to use MultilibSet infrastructure to select sub-libraries? It looks like MultilibSet AndroidMipsMultilibs in the ToolChains.cpp does very similar things.

[chh]

When I started adding armv7-a library subdirectories, I tried to minimize changes and impacts. So I avoided MultilibSet. Now to handle more vaiants and include directories, I am going to try MultilibSet but limit to Android's ARM target.

I will remove redundant .keep files in the next patch.

The Android NDK tree changes were not big although NDK is now release 12 going 13. I think no one has planned big or incompatible change in the future yet. So I thought it will be better just use one basic_android_ndk_tree test tree and add more test cases to it in the future. The old basic_android_tree test has fewer cases and I was thinking about replacing it in my first patch. We can remove it later.

[atanasyan]

In D20600#441114, @chh wrote:

The Android NDK tree changes were not big although NDK is now release 12 going 13. I think no one has planned big or incompatible change in the future yet. So I thought it will be better just use one basic_android_ndk_tree test tree and add more test cases to it in the future. The old basic_android_tree test has fewer cases and I was thinking about replacing it in my first patch. We can remove it later.

OK. Sounds reasonable.

[rengolin]

lib/Driver/ToolChains.cpp

1501

Still looks like you're repeating too many lines... I think you have to get all possibilities into as few variables as possible, and then have only one if/else. For example:

llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
bool Thumb =
         Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) ||
         llvm::ARM::parseArchISA(Arch) == llvm::ARM::IK_THUMB ||
         Triple.getArch() == llvm::Triple::thumb;
bool V7 = (Arch && llvm::ARM::parseArchVersion(Arch) == 7) ||
          (Triple.getSubArch() == llvm::Triple::ARMSubArch_v7);

if (V7 && Thumb)
  SubLibDirs.append(begin(ARMV7aThumbLibDirs), end(ARMV7aThumbLibDirs));
else if (V7)
  SubLibDirs.append(begin(ARMV7aLibDirs), end(ARMV7aLibDirs));
else if (Thumb)
  SubLibDirs.append(begin(ARMThumbLibDirs), end(ARMThumbLibDirs));

4404

Same comments here about bundling up all V7s and Thumbs into the same variable, and using only once.

[chh]

New diff3 uses Multilib and should be much simpler than previous patches.
Please take a look again. Thanks.

[atanasyan]

lib/Driver/ToolChains.cpp

2317

Using Multilibs you can simplify the code for selection. Take a look at findBiarchMultilibs or findMIPSMultilibs. The idea is to specify folders used by each library and flags which trigger selection of this library. Note that the flags do not have to match to command line flags one-to-one. You define them by yourself. Then you join all defined libraries together either in a plain array or using Either and Maybe "operators". After that you define set of flags (addMultilibFlag) and call MultilibSet::select only once. You do not have to check existence of file paths explicitly. The MultilibSet::select does it for you.

[chh]

Now use MultilibSet.

[atanasyan]

LGTM

[rengolin]

Wait, this is not an Android-only change and can benefit ARM Linux, too. Please wait until I get to test it properly on a cross-linux environment.

Thanks!
--renato

[rengolin]

Also, do you really need to change the executable bit on the fake tools? I think you should rollback all of the state changes, so that we don't erroneously mark them as changed, when they actually not.

[chh]

Do not set executable bit of fake executable files in test input.

[chh]

I set executable bits the same way as the old basic_android_tree input.
I think they are unnecessary so now they are removed.

Please check if this patch works for other ARM toolchains.
Since I only tested the Android NDK toolchain, I felt safer to make this change only to Android.
Thanks.

[rengolin]

So, it seems that on Linux, there are slight changes. For instance, it's not "armv7-a" but "armv7-ar". Despite of that, the mechanism is the same, and everything else seems similar.

Can I encourage you to remove the "Android" from the name, just call it "ARMMultilibs" and have a property (local variable) that changes where it's isAndroid() or not?

[chh]

Renato,

I am not familiar with Linux ARM toolchain tree structure
and cannot find "armv7-ar" in clang source or test files either.
In fact I am not sure if my current change will cause any trouble
to non-Android ARM toolchain. So I added the Android qualification.

Would it be okay with you to have incremental changes?
If we have this patch first, it should be easier for you or anyone
to modify it to work with other toolchains, right?
I suppose a new toolchain test and input tree could be added and
the driver code could have a ARMMultilibs that works for multiple
toolchains, if that's possible with Multilibs.
Or we have one Multiblibs for each toolchain.

[rengolin]

I agree. Let's do incremental changes with this one. I'll see if we can pick up this one later on Linux.

Thanks! LGTM.

include/clang/Driver/ToolChain.h

protected:
   virtual Tool *buildLinker() const;
   virtual Tool *getTool(Action::ActionClass AC) const;
 
   /// \name Utilities for implementing subclasses.
   ///@{
   static void addSystemInclude(const llvm::opt::ArgList &DriverArgs,
                                llvm::opt::ArgStringList &CC1Args,
                                const Twine &Path);
+  static void
+      addSystemIncludeIfExists(const llvm::opt::ArgList &DriverArgs,
+                               llvm::opt::ArgStringList &CC1Args,
+                               const Twine &Path);
   static void addExternCSystemInclude(const llvm::opt::ArgList &DriverArgs,
                                       llvm::opt::ArgStringList &CC1Args,
                                       const Twine &Path);
   static void
       addExternCSystemIncludeIfExists(const llvm::opt::ArgList &DriverArgs,
                                       llvm::opt::ArgStringList &CC1Args,
                                       const Twine &Path);
   static void addSystemIncludes(const llvm::opt::ArgList &DriverArgs,

lib/Driver/ToolChain.cpp

 /// \brief Utility function to add a system include directory to CC1 arguments.
 /*static*/ void ToolChain::addSystemInclude(const ArgList &DriverArgs,
                                             ArgStringList &CC1Args,
                                             const Twine &Path) {
   CC1Args.push_back("-internal-isystem");
   CC1Args.push_back(DriverArgs.MakeArgString(Path));
 }
 
+void ToolChain::addSystemIncludeIfExists(const ArgList &DriverArgs,
+                                         ArgStringList &CC1Args,
+                                         const Twine &Path) {
+  if (llvm::sys::fs::exists(Path))
+    addSystemInclude(DriverArgs, CC1Args, Path);
+}
+
+
 /// \brief Utility function to add a system include directory with extern "C"
 /// semantics to CC1 arguments.
 ///
 /// Note that this should be used rarely, and only for directories that
 /// historically and for legacy reasons are treated as having implicit extern
 /// "C" semantics. These semantics are *ignored* by and large today, but its
 /// important to preserve the preprocessor changes resulting from the
 /// classification.

lib/Driver/ToolChains.h

public:
   /// use.
   ///
   /// This class tries to find a GCC installation on the system, and report
   /// information about it. It starts from the host information provided to the
   /// Driver, and has logic for fuzzing that where appropriate.
   class GCCInstallationDetector {
     bool IsValid;
     llvm::Triple GCCTriple;
+    llvm::Triple TargetTriple;
     const Driver &D;
 
     // FIXME: These might be better as path objects.
     std::string GCCInstallPath;
     std::string GCCParentLibPath;
 
     /// The primary multilib appropriate for the given flags.
     Multilib SelectedMultilib;
     /// On Biarch systems, this corresponds to the default multilib when
     /// targeting the non-default multilib. Otherwise, it is empty.
     llvm::Optional<Multilib> BiarchSibling;
 
     GCCVersion Version;
 
     // We retain the list of install paths that were considered and rejected in
     // order to print out detailed information in verbose mode.
     std::set<std::string> CandidateGCCInstallPaths;
 
     /// The set of multilibs that the detected installation supports.
     MultilibSet Multilibs;
 
+    /// Optional lib subdirectories for SubArchTypes.
+    SmallVector<StringRef, 4> CandidateSubLibDirs;
+
   public:
     explicit GCCInstallationDetector(const Driver &D) : IsValid(false), D(D) {}
     void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args,
               ArrayRef<std::string> ExtraTripleAliases = None);
 
     /// \brief Check whether we detected a valid GCC install.
     bool isValid() const { return IsValid; }
 
     /// \brief Get the GCC triple for the detected install.
     const llvm::Triple &getTriple() const { return GCCTriple; }
 
+    /// \brief Get the GCC target triple for this compilation.
+    const llvm::Triple &getTargetTriple() const { return TargetTriple; }
+
     /// \brief Get the detected GCC installation path.
     StringRef getInstallPath() const { return GCCInstallPath; }
 
     /// \brief Get the detected GCC parent lib path.
     StringRef getParentLibPath() const { return GCCParentLibPath; }
 
+    /// \brief Get the SubArchType subdirectories under lib.
+    const SmallVectorImpl<StringRef> &getSubLibs() { return CandidateSubLibDirs; }
+
     /// \brief Get the detected Multilib
     const Multilib &getMultilib() const { return SelectedMultilib; }
 
     /// \brief Get the whole MultilibSet
     const MultilibSet &getMultilibs() const { return Multilibs; }
 
     /// Get the biarch sibling multilib (if it exists).
     /// \return true iff such a sibling exists
     bool getBiarchSibling(Multilib &M) const;
 
     /// \brief Get the detected GCC version string.
     const GCCVersion &getVersion() const { return Version; }
 
     /// \brief Print information about the detected GCC installation.
     void print(raw_ostream &OS) const;
 
   private:
     static void
+    CollectSubLibDirs(const llvm::Triple &Triple,
+                      const llvm::opt::ArgList &Args,
+                      SmallVectorImpl<StringRef> &SubLibDirs);
+
+    static void
     CollectLibDirsAndTriples(const llvm::Triple &TargetTriple,
                              const llvm::Triple &BiarchTriple,
+                             const llvm::opt::ArgList &Args,
                              SmallVectorImpl<StringRef> &LibDirs,
+                             SmallVectorImpl<StringRef> &SubLibDirs,
                              SmallVectorImpl<StringRef> &TripleAliases,
                              SmallVectorImpl<StringRef> &BiarchLibDirs,
                              SmallVectorImpl<StringRef> &BiarchTripleAliases);
 
     void ScanLibDirForGCCTriple(const llvm::Triple &TargetArch,
                                 const llvm::opt::ArgList &Args,
                                 const std::string &LibDir,
                                 StringRef CandidateTriple,
protected:
   /// @{
 
   /// \brief Check whether the target triple's architecture is 64-bits.
   bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
 
   /// \brief Check whether the target triple's architecture is 32-bits.
   bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
 
+  void addSystemIncludeWithSubArchDir(StringRef SubArchDir,
+                                      const llvm::opt::ArgList &DriverArgs,
+                                      llvm::opt::ArgStringList &CC1Args,
+                                      Twine Path) const;
+
   bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix, StringRef GCCTriple,
+                                StringRef SubArchDir,
                                 StringRef GCCMultiarchTriple,
                                 StringRef TargetMultiarchTriple,
                                 Twine IncludeSuffix,
                                 const llvm::opt::ArgList &DriverArgs,
                                 llvm::opt::ArgStringList &CC1Args) const;
 
   /// @}
 
public:
   Linux(const Driver &D, const llvm::Triple &Triple,
         const llvm::opt::ArgList &Args);
 
   bool HasNativeLLVMSupport() const override;
 
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
+  StringRef GetClangCXXStdlibSubArchIncludeDir(
+      const llvm::opt::ArgList &DriverArgs) const;
   void AddClangCXXStdlibIncludeArgs(
       const llvm::opt::ArgList &DriverArgs,
       llvm::opt::ArgStringList &CC1Args) const override;
   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                           llvm::opt::ArgStringList &CC1Args) const override;
   bool isPIEDefault() const override;
   SanitizerMask getSupportedSanitizers() const override;
   void addProfileRTLibs(const llvm::opt::ArgList &Args,

lib/Driver/ToolChains.cpp

 ///
 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
 /// should instead pull the target out of the driver. This is currently
 /// necessary because the driver doesn't store the final version of the target
 /// triple.
 void Generic_GCC::GCCInstallationDetector::init(
     const llvm::Triple &TargetTriple, const ArgList &Args,
     ArrayRef<std::string> ExtraTripleAliases) {
+  this->TargetTriple = TargetTriple;
   llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
                                          ? TargetTriple.get64BitArchVariant()
                                          : TargetTriple.get32BitArchVariant();
   // The library directories which may contain GCC installations.
   SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
   // The compatible GCC triples for this particular architecture.
   SmallVector<StringRef, 16> CandidateTripleAliases;
   SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
-  CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
+  CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, Args,
+                           CandidateLibDirs, CandidateSubLibDirs,
                            CandidateTripleAliases, CandidateBiarchLibDirs,
                            CandidateBiarchTripleAliases);
 
   // Compute the set of prefixes for our search.
   SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
                                        D.PrefixDirs.end());
 
   StringRef GCCToolchainDir = getGCCToolchainDir(Args);

 bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
   if (BiarchSibling.hasValue()) {
     M = BiarchSibling.getValue();
     return true;
   }
   return false;
 }
 
+/*static*/ void Generic_GCC::GCCInstallationDetector::CollectSubLibDirs(
+    const llvm::Triple &Triple, const ArgList &Args,
+    SmallVectorImpl<StringRef> &SubLibDirs) {
+  // Recognize only thumb and armv7 types for now.
+  static const char *const ARMThumbLibDirs[] = {"/thumb"};
+  static const char *const ARMV7aLibDirs[] = {"/armv7-a"};
+  static const char *const ARMV7aThumbLibDirs[] = {
+      "/armv7-a/thumb", "/armv7-a"};
+  using std::begin;
+  using std::end;
+  llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
+  bool Thumb = Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false);
+  if (Arch == "armv7" || Arch == "armv7-a" || Arch == "armv7a") {
+    if (Thumb)
+      SubLibDirs.append(begin(ARMV7aThumbLibDirs), end(ARMV7aThumbLibDirs));
+    else
+      SubLibDirs.append(begin(ARMV7aLibDirs), end(ARMV7aLibDirs));
+    return;
+  }
+  if (Arch == "thumb") {
+    SubLibDirs.append(begin(ARMThumbLibDirs), end(ARMThumbLibDirs));
+    return;
+  }
+  switch (Triple.getArch()) {
+  case llvm::Triple::thumb:
+    SubLibDirs.append(begin(ARMThumbLibDirs), end(ARMThumbLibDirs));
+    break;
+  case llvm::Triple::arm:
+    if (Triple.getSubArch() == llvm::Triple::ARMSubArch_v7 && Arch == "") {
+      if (Thumb)
+        SubLibDirs.append(begin(ARMV7aThumbLibDirs), end(ARMV7aThumbLibDirs));
+      else
+        SubLibDirs.append(begin(ARMV7aLibDirs), end(ARMV7aLibDirs));
+    } else {
+      if (Thumb)
+        SubLibDirs.append(begin(ARMThumbLibDirs), end(ARMThumbLibDirs));
+    }
+    break;
+  default:
+    break;
+  }
+}
+
 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
-    const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
+    const llvm::Triple &TargetTriple,
+    const llvm::Triple &BiarchTriple,
+    const ArgList &Args,
     SmallVectorImpl<StringRef> &LibDirs,
+    SmallVectorImpl<StringRef> &SubLibDirs,
     SmallVectorImpl<StringRef> &TripleAliases,
     SmallVectorImpl<StringRef> &BiarchLibDirs,
     SmallVectorImpl<StringRef> &BiarchTripleAliases) {
   // Declare a bunch of static data sets that we'll select between below. These
   // are specifically designed to always refer to string literals to avoid any
   // lifetime or initialization issues.
   static const char *const AArch64LibDirs[] = {"/lib64", "/lib"};
   static const char *const AArch64Triples[] = {
/*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
   case llvm::Triple::aarch64_be:
     LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
     TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
     BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
     BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
     break;
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
+    CollectSubLibDirs(TargetTriple, Args, SubLibDirs);
     LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
       TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
     } else {
       TripleAliases.append(begin(ARMTriples), end(ARMTriples));
     }
     break;
   case llvm::Triple::armeb:
static bool findBiarchMultilibs(const Driver &D,
   // in what would normally be GCCInstallPath and put the 64-bit
   // libs in a subdirectory named 64. The simple logic we follow is that
   // *if* there is a subdirectory of the right name with crtbegin.o in it,
   // we use that. If not, and if not a biarch triple alias, we look for
   // crtbegin.o without the subdirectory.
 
   Multilib Default;
   Multilib Alt64 = Multilib()
                        .gccSuffix("/64")
                        .includeSuffix("/64")
                        .flag("-m32")
                        .flag("+m64")
                        .flag("-mx32");
   Multilib Alt32 = Multilib()
                        .gccSuffix("/32")
                        .includeSuffix("/32")
                        .flag("+m32")
bool Generic_GCC::IsIntegratedAssemblerDefault() const {
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
     return true;
   default:
     return false;
   }
 }
 
+/// \brief Helper to add system include path with subarch directory suffix.
+void Generic_GCC::addSystemIncludeWithSubArchDir(
+    StringRef SubArchDir, const llvm::opt::ArgList &DriverArgs,
+    llvm::opt::ArgStringList &CC1Args, Twine Path) const {
+  if (SubArchDir != "")
+    addSystemIncludeIfExists(DriverArgs, CC1Args, Path + "/" + SubArchDir);
+  addSystemInclude(DriverArgs, CC1Args, Path);
+}
+
 /// \brief Helper to add the variant paths of a libstdc++ installation.
 bool Generic_GCC::addLibStdCXXIncludePaths(
-    Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
+    Twine Base, Twine Suffix, StringRef GCCTriple,
+    StringRef SubArchDir, StringRef GCCMultiarchTriple,
     StringRef TargetMultiarchTriple, Twine IncludeSuffix,
     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
   if (!getVFS().exists(Base + Suffix))
     return false;
 
   addSystemInclude(DriverArgs, CC1Args, Base + Suffix);
 
   // The vanilla GCC layout of libstdc++ headers uses a triple subdirectory. If
   // that path exists or we have neither a GCC nor target multiarch triple, use
   // this vanilla search path.
   if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
       getVFS().exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) {
-    addSystemInclude(DriverArgs, CC1Args,
-                     Base + Suffix + "/" + GCCTriple + IncludeSuffix);
+    addSystemIncludeWithSubArchDir(
+        SubArchDir, DriverArgs, CC1Args,
   } else {
     // Otherwise try to use multiarch naming schemes which have normalized the
     // triples and put the triple before the suffix.
     //
     // GCC surprisingly uses *both* the GCC triple with a multilib suffix and
     // the target triple, so we support that here.
-    addSystemInclude(DriverArgs, CC1Args,
-                     Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
-    addSystemInclude(DriverArgs, CC1Args,
-                     Base + "/" + TargetMultiarchTriple + Suffix);
+    addSystemIncludeWithSubArchDir(SubArchDir, DriverArgs, CC1Args,
+    addSystemIncludeWithSubArchDir(SubArchDir, DriverArgs, CC1Args,
   }
 
   addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward");
   return true;
 }
 
 void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs,
                                         ArgStringList &CC1Args) const {

 Tool *Minix::buildLinker() const { return new tools::minix::Linker(*this); }
 
 static void addPathIfExists(const Driver &D, const Twine &Path,
                             ToolChain::path_list &Paths) {
   if (D.getVFS().exists(Path))
     Paths.push_back(Path.str());
 }
 
+static void addPathIfExists(const Driver &D, const Twine &Path,
+                            const SmallVectorImpl<StringRef> &SubDirs,
+                            ToolChain::path_list &Paths) {
+  for (const auto &Suffix : SubDirs)
+    addPathIfExists(D, Path + Suffix, Paths);
+  addPathIfExists(D, Path, Paths);
+}
+
 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
 
 Solaris::Solaris(const Driver &D, const llvm::Triple &Triple,
                  const ArgList &Args)
     : Generic_GCC(D, Triple, Args) {
 
   GCCInstallation.init(Triple, Args);
 
if (GCCInstallation.isValid()) {
 
     // Add toolchain / multilib specific file paths.
     addMultilibsFilePaths(D, Multilibs, Multilib,
                           GCCInstallation.getInstallPath(), Paths);
 
     // Sourcery CodeBench MIPS toolchain holds some libraries under
     // a biarch-like suffix of the GCC installation.
     addPathIfExists(D, GCCInstallation.getInstallPath() + Multilib.gccSuffix(),
-                    Paths);
+                    GCCInstallation.getSubLibs(), Paths);
 
     // GCC cross compiling toolchains will install target libraries which ship
     // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
     // any part of the GCC installation in
     // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
     // debatable, but is the reality today. We need to search this tree even
     // when we have a sysroot somewhere else. It is the responsibility of
     // whomever is doing the cross build targeting a sysroot using a GCC
     // installation that is *not* within the system root to ensure two things:
     //
     //  1) Any DSOs that are linked in from this tree or from the install path
     //     above must be present on the system root and found via an
     //     appropriate rpath.
     //  2) There must not be libraries installed into
     //     <prefix>/<triple>/<libdir> unless they should be preferred over
     //     those within the system root.
     //
     // Note that this matches the GCC behavior. See the below comment for where
     // Clang diverges from GCC's behavior.
     addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib/../" +
                            OSLibDir + Multilib.osSuffix(),
-                    Paths);
+                    GCCInstallation.getSubLibs(), Paths);
 
     // If the GCC installation we found is inside of the sysroot, we want to
     // prefer libraries installed in the parent prefix of the GCC installation.
     // It is important to *not* use these paths when the GCC installation is
     // outside of the system root as that can pick up unintended libraries.
     // This usually happens when there is an external cross compiler on the
     // host system, and a more minimal sysroot available that is the target of
     // the cross. Note that GCC does include some of these directories in some
if (VersionText[0] == 'v' &&
         MaxVersion = Version;
         MaxVersionString = VersionText;
       }
     }
   }
   return MaxVersion ? (base + "/" + MaxVersionString).str() : "";
 }
 
+StringRef Linux::GetClangCXXStdlibSubArchIncludeDir(
+    const ArgList &DriverArgs) const {
+  // Only recognize armv7-a for now.
+  llvm::StringRef Arch = DriverArgs.getLastArgValue(options::OPT_march_EQ);
+  if (Arch == "armv7" || Arch == "armv7-a" || Arch == "armv7a")
+    return "armv7-a";
+  llvm::Triple::SubArchType SubArchType = GCCInstallation.getTargetTriple().getSubArch();
+  return (SubArchType == llvm::Triple::ARMSubArch_v7) ? "armv7-a" : "";
+}
+
 void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
                                          ArgStringList &CC1Args) const {
   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
       DriverArgs.hasArg(options::OPT_nostdincxx))
     return;
 
   // Check if libc++ has been enabled and provide its include paths if so.
   if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
     const std::string LibCXXIncludePathCandidates[] = {
if (!GCCInstallation.isValid())
     return;
 
   // By default, look for the C++ headers in an include directory adjacent to
   // the lib directory of the GCC installation. Note that this is expect to be
   // equivalent to '/usr/include/c++/X.Y' in almost all cases.
   StringRef LibDir = GCCInstallation.getParentLibPath();
   StringRef InstallDir = GCCInstallation.getInstallPath();
   StringRef TripleStr = GCCInstallation.getTriple().str();
+  StringRef SubArchDir = GetClangCXXStdlibSubArchIncludeDir(DriverArgs);
   const Multilib &Multilib = GCCInstallation.getMultilib();
   const std::string GCCMultiarchTriple = getMultiarchTriple(
       getDriver(), GCCInstallation.getTriple(), getDriver().SysRoot);
   const std::string TargetMultiarchTriple =
       getMultiarchTriple(getDriver(), getTriple(), getDriver().SysRoot);
   const GCCVersion &Version = GCCInstallation.getVersion();
 
   // The primary search for libstdc++ supports multiarch variants.
   if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
-                               "/c++/" + Version.Text, TripleStr,
+                               "/c++/" + Version.Text, TripleStr, SubArchDir,
                                GCCMultiarchTriple, TargetMultiarchTriple,
                                Multilib.includeSuffix(), DriverArgs, CC1Args))
     return;
 
   // Otherwise, fall back on a bunch of options which don't use multiarch
   // layouts for simplicity.
   const std::string LibStdCXXIncludePathCandidates[] = {
       // Gentoo is weird and places its headers inside the GCC install,
       // so if the first attempt to find the headers fails, try these patterns.
       InstallDir.str() + "/include/g++-v" + Version.Text,
       InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
           Version.MinorStr,
       InstallDir.str() + "/include/g++-v" + Version.MajorStr,
       // Android standalone toolchain has C++ headers in yet another place.
       LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
       // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
       // without a subdirectory corresponding to the gcc version.
       LibDir.str() + "/../include/c++",
   };
 
   for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {
     if (addLibStdCXXIncludePaths(IncludePath, /*Suffix*/ "", TripleStr,
+                                 /*SubArchDir*/ "",
                                  /*GCCMultiarchTriple*/ "",
                                  /*TargetMultiarchTriple*/ "",
                                  Multilib.includeSuffix(), DriverArgs, CC1Args))
       break;
   }
 }
 
 void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,
void MyriadToolChain::AddClangCXXStdlibIncludeArgs(
   // Only libstdc++, for now.
   StringRef LibDir = GCCInstallation.getParentLibPath();
   const GCCVersion &Version = GCCInstallation.getVersion();
   StringRef TripleStr = GCCInstallation.getTriple().str();
   const Multilib &Multilib = GCCInstallation.getMultilib();
 
   addLibStdCXXIncludePaths(
       LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
-      "", TripleStr, "", "", Multilib.includeSuffix(), DriverArgs, CC1Args);
+      "", TripleStr, "", "", "", Multilib.includeSuffix(), DriverArgs, CC1Args);
 }
 
 // MyriadToolChain handles several triples:
 //  {shave,sparc{,el}}-myriad-{rtems,unknown}-elf
 Tool *MyriadToolChain::SelectTool(const JobAction &JA) const {
   // The inherited method works fine if not targeting the SHAVE.
   if (!isShaveCompilation(getTriple()))
     return ToolChain::SelectTool(JA);

test/Driver/android-standalone.cpp

 // Test header and library paths when Clang is used with Android standalone
 // toolchain.
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target arm-linux-androideabi -stdlib=libstdc++ \
 // RUN:     -B%S/Inputs/basic_android_tree \
 // RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
 // RUN:   | FileCheck  %s
 // CHECK: {{.*}}clang{{.*}}" "-cc1"
-// CHECK: "-internal-isystem" "{{.*}}/arm-linux-androideabi/include/c++/4.4.3"
-// CHECK: "-internal-isystem" "{{.*}}/arm-linux-androideabi/include/c++/4.4.3/arm-linux-androideabi"
+// CHECK: "-internal-isystem" "{{.*}}/include/c++/4.9"
+// CHECK-NOT: "-internal-isystem" "{{.*}}/include/c++/4.9/arm-linux-androideabi/armv7-a"
+// CHECK: "-internal-isystem" "{{.*}}/include/c++/4.9/arm-linux-androideabi"
+// CHECK: "-internal-isystem" "{{.*}}/include/c++/4.9/backward"
+// CHECK: "-internal-isystem" "{{.*}}/sysroot/usr/local/include"
+// CHECK: "-internal-isystem" "{{.*}}/lib/clang/{{[^/]*}}/include"
 // CHECK: "-internal-externc-isystem" "{{.*}}/sysroot/include"
 // CHECK: "-internal-externc-isystem" "{{.*}}/sysroot/usr/include"
 // CHECK: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
-// CHECK: "-L{{.*}}/lib/gcc/arm-linux-androideabi/4.4.3"
-// CHECK: "-L{{.*}}/lib/gcc/arm-linux-androideabi/4.4.3/../../../../arm-linux-androideabi/lib"
+// CHECK-NOT: "-L{{.*}}/lib/gcc/arm-linux-androideabi/4.9/armv7-a"
+// CHECK: "-L{{.*}}/lib/gcc/arm-linux-androideabi/4.9"
+// CHECK: "-L{{.*}}/lib/gcc/arm-linux-androideabi/4.9/../../../../arm-linux-androideabi/lib"
 // CHECK: "-L{{.*}}/sysroot/usr/lib"
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target armv7a-none-linux-androideabi -stdlib=libstdc++ \
+// RUN:     -B%S/Inputs/basic_android_tree \
+// RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
+// RUN:   | FileCheck  --check-prefix=CHECK-ARMV7 %s
+// CHECK-ARMV7: {{.*}}clang{{.*}}" "-cc1"
+// CHECK-ARMV7: "-internal-isystem" "{{.*}}/include/c++/4.9"
+// CHECK-ARMV7: "-internal-isystem" "{{.*}}/include/c++/4.9/arm-linux-androideabi/armv7-a"
+// CHECK-ARMV7: "-internal-isystem" "{{.*}}/include/c++/4.9/arm-linux-androideabi"
+// CHECK-ARMV7: "-internal-isystem" "{{.*}}/include/c++/4.9/backward"
+// CHECK-ARMV7: "-internal-isystem" "{{.*}}/sysroot/usr/local/include"
+// CHECK-ARMV7: "-internal-isystem" "{{.*}}/lib/clang/{{[^/]*}}/include"
+// CHECK-ARMV7: "-internal-externc-isystem" "{{.*}}/sysroot/include"
+// CHECK-ARMV7: "-internal-externc-isystem" "{{.*}}/sysroot/usr/include"
+// CHECK-ARMV7: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
+// CHECK-ARMV7: "-L{{.*}}/lib/gcc/arm-linux-androideabi/4.9/armv7-a"
+// CHECK-ARMV7: "-L{{.*}}/lib/gcc/arm-linux-androideabi/4.9"
+// CHECK-ARMV7: "-L{{.*}}/lib/gcc/arm-linux-androideabi/4.9/../../../../arm-linux-androideabi/lib"
+// CHECK-ARMV7: "-L{{.*}}/sysroot/usr/lib"
+//
+// Other flags that can trigger armv7 mode.
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target arm-linux-androideabi -stdlib=libstdc++ \
+// RUN:     -march=armv7 \
+// RUN:     -B%S/Inputs/basic_android_tree \
+// RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
+// RUN:   | FileCheck  --check-prefix=CHECK-ARMV7 %s
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target arm-linux-androideabi -stdlib=libstdc++ \
+// RUN:     -march=armv7a \
+// RUN:     -B%S/Inputs/basic_android_tree \
+// RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
+// RUN:   | FileCheck  --check-prefix=CHECK-ARMV7 %s
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target arm-linux-androideabi -stdlib=libstdc++ \
+// RUN:     -march=armv7-a \
+// RUN:     -B%S/Inputs/basic_android_tree \
+// RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
+// RUN:   | FileCheck  --check-prefix=CHECK-ARMV7 %s
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target aarch64-linux-android -stdlib=libstdc++ \
 // RUN:     -B%S/Inputs/basic_android_tree \
 // RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
 // RUN:   | FileCheck --check-prefix=CHECK-AARCH64 %s
 // CHECK-AARCH64: {{.*}}clang{{.*}}" "-cc1"
-// CHECK-AARCH64: "-internal-isystem" "{{.*}}/aarch64-linux-android/include/c++/4.8"
-// CHECK-AARCH64: "-internal-isystem" "{{.*}}/aarch64-linux-android/include/c++/4.8/aarch64-linux-android"
+// CHECK-AARCH64: "-internal-isystem" "{{.*}}/include/c++/4.9"
+// CHECK-AARCH64: "-internal-isystem" "{{.*}}/include/c++/4.9/aarch64-linux-android"
+// CHECK-AARCH64: "-internal-isystem" "{{.*}}/include/c++/4.9/backward"
 // CHECK-AARCH64: "-internal-externc-isystem" "{{.*}}/sysroot/include"
 // CHECK-AARCH64: "-internal-externc-isystem" "{{.*}}/sysroot/usr/include"
 // CHECK-AARCH64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
-// CHECK-AARCH64: "-L{{.*}}/lib/gcc/aarch64-linux-android/4.8"
-// CHECK-AARCH64: "-L{{.*}}/lib/gcc/aarch64-linux-android/4.8/../../../../aarch64-linux-android/lib"
+// CHECK-AARCH64: "-L{{.*}}/lib/gcc/aarch64-linux-android/4.9"
+// CHECK-AARCH64: "-L{{.*}}/lib/gcc/aarch64-linux-android/4.9/../../../../aarch64-linux-android/lib"
 // CHECK-AARCH64: "-L{{.*}}/sysroot/usr/lib"
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target arm64-linux-android -stdlib=libstdc++ \
 // RUN:     -B%S/Inputs/basic_android_tree \
 // RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
 // RUN:   | FileCheck --check-prefix=CHECK-ARM64 %s
 // CHECK-ARM64: {{.*}}clang{{.*}}" "-cc1"
-// CHECK-ARM64: "-internal-isystem" "{{.*}}/aarch64-linux-android/include/c++/4.8"
-// CHECK-ARM64: "-internal-isystem" "{{.*}}/aarch64-linux-android/include/c++/4.8/aarch64-linux-android"
+// CHECK-ARM64: "-internal-isystem" "{{.*}}/include/c++/4.9"
+// CHECK-ARM64: "-internal-isystem" "{{.*}}/include/c++/4.9/aarch64-linux-android"
+// CHECK-ARM64: "-internal-isystem" "{{.*}}/include/c++/4.9/backward"
 // CHECK-ARM64: "-internal-externc-isystem" "{{.*}}/sysroot/include"
 // CHECK-ARM64: "-internal-externc-isystem" "{{.*}}/sysroot/usr/include"
 // CHECK-ARM64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
-// CHECK-ARM64: "-L{{.*}}/lib/gcc/aarch64-linux-android/4.8"
-// CHECK-ARM64: "-L{{.*}}/lib/gcc/aarch64-linux-android/4.8/../../../../aarch64-linux-android/lib"
+// CHECK-ARM64: "-L{{.*}}/lib/gcc/aarch64-linux-android/4.9"
+// CHECK-ARM64: "-L{{.*}}/lib/gcc/aarch64-linux-android/4.9/../../../../aarch64-linux-android/lib"
 // CHECK-ARM64: "-L{{.*}}/sysroot/usr/lib"
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target mipsel-linux-android \
 // RUN:     -mips32 -stdlib=libstdc++ \
 // RUN:     -B%S/Inputs/basic_android_tree \
 // RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
 // RUN:   | FileCheck --check-prefix=CHECK-MIPS %s
 // CHECK-MIPS: {{.*}}clang{{.*}}" "-cc1"
-// CHECK-MIPS: "-internal-isystem" "{{.*}}/mipsel-linux-android/include/c++/4.4.3"
-// CHECK-MIPS: "-internal-isystem" "{{.*}}/mipsel-linux-android/include/c++/4.4.3/mipsel-linux-android"
+// CHECK-MIPS: "-internal-isystem" "{{.*}}/include/c++/4.9"
+// CHECK-MIPS: "-internal-isystem" "{{.*}}/include/c++/4.9/mipsel-linux-android"
+// CHECK-MIPS: "-internal-isystem" "{{.*}}/include/c++/4.9/backward"
 // CHECK-MIPS: "-internal-externc-isystem" "{{.*}}/sysroot/include"
 // CHECK-MIPS: "-internal-externc-isystem" "{{.*}}/sysroot/usr/include"
 // CHECK-MIPS: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
-// CHECK-MIPS: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.4.3"
-// CHECK-MIPS: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.4.3/../../../../mipsel-linux-android/lib"
+// CHECK-MIPS: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.9"
+// CHECK-MIPS: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.9/../../../../mipsel-linux-android/lib"
 // CHECK-MIPS: "-L{{.*}}/sysroot/usr/lib"
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target mipsel-linux-android \
 // RUN:     -march=mips32 -mips32r2 -stdlib=libstdc++ \
 // RUN:     -B%S/Inputs/basic_android_tree \
 // RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
 // RUN:   | FileCheck --check-prefix=CHECK-MIPSR2 %s
 // CHECK-MIPSR2: {{.*}}clang{{.*}}" "-cc1"
-// CHECK-MIPSR2: "-internal-isystem" "{{.*}}/mipsel-linux-android/include/c++/4.4.3"
-// CHECK-MIPSR2: "-internal-isystem" "{{.*}}/mipsel-linux-android/include/c++/4.4.3/mipsel-linux-android"
+// CHECK-MIPSR2: "-internal-isystem" "{{.*}}/include/c++/4.9"
+// NOT-YET-CHECK-MIPSR2: "-internal-isystem" "{{.*}}/include/c++/4.9/mipsel-linux-android/mips-r2"
+// CHECK-MIPSR2: "-internal-isystem" "{{.*}}/include/c++/4.9/mipsel-linux-android"
+// CHECK-MIPSR2: "-internal-isystem" "{{.*}}/include/c++/4.9/backward"
 // CHECK-MIPSR2: "-internal-externc-isystem" "{{.*}}/sysroot/include"
 // CHECK-MIPSR2: "-internal-externc-isystem" "{{.*}}/sysroot/usr/include"
 // CHECK-MIPSR2: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
-// CHECK-MIPSR2: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.4.3/mips-r2"
-// CHECK-MIPSR2: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.4.3/../../../../mipsel-linux-android/lib"
+// CHECK-MIPSR2: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.9/mips-r2"
+// CHECK-MIPSR2: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.9/../../../../mipsel-linux-android/lib"
 // CHECK-MIPSR2: "-L{{.*}}/sysroot/usr/lib"
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target mipsel-linux-android \
-// RUN:     -mips32 -march=mips32r2 -stdlib=libstdc++ \
-// RUN:     -B%S/Inputs/basic_android_tree \
-// RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
-// RUN:   | FileCheck --check-prefix=CHECK-MIPSR2-A %s
-// CHECK-MIPSR2-A: {{.*}}clang{{.*}}" "-cc1"
-// CHECK-MIPSR2-A: "-internal-isystem" "{{.*}}/mipsel-linux-android/include/c++/4.4.3"
-// CHECK-MIPSR2-A: "-internal-isystem" "{{.*}}/mipsel-linux-android/include/c++/4.4.3/mipsel-linux-android"
-// CHECK-MIPSR2-A: "-internal-externc-isystem" "{{.*}}/sysroot/include"
-// CHECK-MIPSR2-A: "-internal-externc-isystem" "{{.*}}/sysroot/usr/include"
-// CHECK-MIPSR2-A: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
-// CHECK-MIPSR2-A: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.4.3/mips-r2"
-// CHECK-MIPSR2-A: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.4.3/../../../../mipsel-linux-android/lib"
-// CHECK-MIPSR2-A: "-L{{.*}}/sysroot/usr/lib"
-//
-// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
-// RUN:     -target mipsel-linux-android \
 // RUN:     -mips32r6 -stdlib=libstdc++ \
 // RUN:     -B%S/Inputs/basic_android_tree \
 // RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
 // RUN:   | FileCheck --check-prefix=CHECK-MIPSR6 %s
 // CHECK-MIPSR6: {{.*}}clang{{.*}}" "-cc1"
-// CHECK-MIPSR6: "-internal-isystem" "{{.*}}/mipsel-linux-android/include/c++/4.4.3"
-// CHECK-MIPSR6: "-internal-isystem" "{{.*}}/mipsel-linux-android/include/c++/4.4.3/mipsel-linux-android"
+// CHECK-MIPSR6: "-internal-isystem" "{{.*}}/include/c++/4.9"
+// NOT-YET-CHECK-MIPSR6: "-internal-isystem" "{{.*}}/include/c++/4.9/mipsel-linux-android/mips-r6"
+// CHECK-MIPSR6: "-internal-isystem" "{{.*}}/include/c++/4.9/mipsel-linux-android"
+// CHECK-MIPSR6: "-internal-isystem" "{{.*}}/include/c++/4.9/backward"
 // CHECK-MIPSR6: "-internal-externc-isystem" "{{.*}}/sysroot/include"
 // CHECK-MIPSR6: "-internal-externc-isystem" "{{.*}}/sysroot/usr/include"
 // CHECK-MIPSR6: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
-// CHECK-MIPSR6: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.4.3/mips-r6"
-// CHECK-MIPSR6: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.4.3/../../../../mipsel-linux-android/lib"
+// CHECK-MIPSR6: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.9/mips-r6"
+// CHECK-MIPSR6: "-L{{.*}}/lib/gcc/mipsel-linux-android/4.9/../../../../mipsel-linux-android/lib"
 // CHECK-MIPSR6: "-L{{.*}}/sysroot/usr/lib"
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target i686-linux-android \
+// RUN:     -stdlib=libstdc++ \
+// RUN:     -B%S/Inputs/basic_android_tree \
+// RUN:     --sysroot=%S/Inputs/basic_android_tree/sysroot \
+// RUN:   | FileCheck --check-prefix=CHECK-I686 %s
+// CHECK-I686: {{.*}}clang{{.*}}" "-cc1"
+// CHECK-I686: "-internal-isystem" "{{.*}}/include/c++/4.9"
+// CHECK-I686: "-internal-isystem" "{{.*}}/include/c++/4.9/i686-linux-android"
+// CHECK-I686: "-internal-isystem" "{{.*}}/include/c++/4.9/backward"
+// CHECK-I686: "-internal-externc-isystem" "{{.*}}/sysroot/include"
+// CHECK-I686: "-internal-externc-isystem" "{{.*}}/sysroot/usr/include"
+// CHECK-I686: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
+// CHECK-I686: "-L{{.*}}/lib/gcc/i686-linux-android/4.9"
+// CHECK-I686: "-L{{.*}}/lib/gcc/i686-linux-android/4.9/../../../../i686-linux-android/lib"
+// CHECK-I686: "-L{{.*}}/sysroot/usr/lib"

test/Driver/fuse-ld.c

 // RUN:     -B%S/Inputs/basic_android_tree/bin 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=CHECK-ANDROID-ARM-GOLD
 // CHECK-ANDROID-ARM-GOLD: Inputs/basic_android_tree/bin{{/|\\+}}arm-linux-androideabi-ld.gold
 
 // RUN: %clang %s -### \
 // RUN:     -target arm-linux-androideabi \
 // RUN:     -gcc-toolchain %S/Inputs/basic_android_tree 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-ANDROID-ARM-LD-TC
-// CHECK-ANDROID-ARM-LD-TC: Inputs/basic_android_tree/lib/gcc/arm-linux-androideabi/4.4.3/../../../../arm-linux-androideabi/bin{{/|\\+}}ld
+// CHECK-ANDROID-ARM-LD-TC: Inputs/basic_android_tree/lib/gcc/arm-linux-androideabi/4.9/../../../../arm-linux-androideabi/bin{{/|\\+}}ld
 
 // RUN: %clang %s -### -fuse-ld=bfd \
 // RUN:     -target arm-linux-androideabi \
 // RUN:     -gcc-toolchain %S/Inputs/basic_android_tree 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=CHECK-ANDROID-ARM-BFD-TC
-// CHECK-ANDROID-ARM-BFD-TC: Inputs/basic_android_tree/lib/gcc/arm-linux-androideabi/4.4.3/../../../../arm-linux-androideabi/bin{{/|\\+}}ld.bfd
+// CHECK-ANDROID-ARM-BFD-TC: Inputs/basic_android_tree/lib/gcc/arm-linux-androideabi/4.9/../../../../arm-linux-androideabi/bin{{/|\\+}}ld.bfd
 
 // RUN: %clang %s -### -fuse-ld=gold \
 // RUN:     -target arm-linux-androideabi \
 // RUN:     -gcc-toolchain %S/Inputs/basic_android_tree 2>&1 \
 // RUN:   | FileCheck %s -check-prefix=CHECK-ANDROID-ARM-GOLD-TC
-// CHECK-ANDROID-ARM-GOLD-TC: Inputs/basic_android_tree/lib/gcc/arm-linux-androideabi/4.4.3/../../../../arm-linux-androideabi/bin{{/|\\+}}ld.gold
+// CHECK-ANDROID-ARM-GOLD-TC: Inputs/basic_android_tree/lib/gcc/arm-linux-androideabi/4.9/../../../../arm-linux-androideabi/bin{{/|\\+}}ld.gold