Remap the target SDK directory to the host SDK directory

[aprantl]

Summary

This is mostly useful for Swift support; it allows LLDB to substitute a matching SDK it shipped with instead of the sysroot path that was used at compile time.

rdar://problem/60640017

[labath]

I think this needs a lot more discussion. First, there's some weird layering going on here, where the class SDK is declared in lldb/Utility, but it's implemented in PlatformDarwin. But even before we sort that out, we probably need to figure out what exactly is the scope of the new class (e.g. should it cover only Mac sdks, or more).

Then there's the question of the usage of the host platform in the Module class, which is not very ideal. Elsewhere, one would ask the target for it's current platform and use that, but since Modules are idependent of a target, that can't happen here. Still, I don't think that jumping to the host platform is the right solution to that.

It also needs tests. The SDK class looks to be perfectly unit-testable, and if we include the "module sdk" (or maybe the resultant path mappings) in its "dump" output, then we could use lldb-test to test it's interaction with the module and dwarf classes too.

lldb/include/lldb/Utility/SDK.h

18–19 ↗

(On Diff #251526)

If this is going to be specific to apple sdks, then it should have a less generic name (other platforms have sdks too).

20 ↗

(On Diff #251526)

Are all of these ConstStrings really needed? The code uses StringRefs for string manipulation anyway, and it's very doubtful that any of this is going to be a performance bottleneck. OTOH, each ConstString adds some junk to the global string pool which never gets deleted.

lldb/source/Core/Module.cpp

1603

Routing this via host platform seems like a bad design choice. Theoretically, if I am cross-debugging a linux binary, I should be able to ask some entity which knows about linux sysroots even if I am on a mac.

And indeed, we don't have that many callers of Platform::GetHostPlatform, and none of them are in the Module hierarchy.

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

1285–1358

Implementing this inside PlatformDarwin.cpp is super weird.

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

670–681 ↗

(On Diff #251526)

Unless we're planning to add these methods to llvm::DWARFUnit, they should go someplace else. There's no reason why this functionality needs to be implemented from within DWARFUnits.

[shafik]

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

1318

We should document what we expect the format to be. I mean I can deduce it from the code but I would prefer to have it spelled out and then check the code parses the expected format correctly.

1336

We should have tests for this and the rest of the methods here.

[aprantl]

Thanks, Pavel, these are all very valid concerns and in retrospect I should have at least slapped an RFC label on this before dumping into phabricator last night. The goal of this (and I should have mentioned that in the description) is to make the Xcode SDK something that behaves more like the compiler's resource directory, as in that it ships with LLDB rather than with the debugged program. This important primarily for importing Swift and Clang modules in the expression evaluator, and getting at the APINotes from the SDK in Swift.

For a cross-debugging scenario, this means you have to have an SDK for your target installed alongside LLDB. In Xcode this will always be the case. As you correctly identified my first patch does not work if you are cross debugging, e.g., a macOS target from a Linux machine because we are querying the HostPlatform for the SDK path and only PlatformDarwin implements this function. I'm open to any suggestions (and will also think about this myself) for how to make the layering less awkward, the only hard requirement I have is that I need the SDK path remapping information inside the per-module Swift typesystem, so I can't depend on a target for any of this.

What do you think about the general idea of a HostPlatform having several cross-SDKs installed and knowing where to find them? What would be a better place for this otherwise?

[labath]

Thanks for the explanation. I have some ideas on this below, though I am not sure if I know enough about the problem to be able to tell which ones are feasible.

In D76471#1933923, @aprantl wrote:

Thanks, Pavel, these are all very valid concerns and in retrospect I should have at least slapped an RFC label on this before dumping into phabricator last night. The goal of this (and I should have mentioned that in the description) is to make the Xcode SDK something that behaves more like the compiler's resource directory, as in that it ships with LLDB rather than with the debugged program. This important primarily for importing Swift and Clang modules in the expression evaluator, and getting at the APINotes from the SDK in Swift.

For a cross-debugging scenario, this means you have to have an SDK for your target installed alongside LLDB. In Xcode this will always be the case. As you correctly identified my first patch does not work if you are cross debugging, e.g., a macOS target from a Linux machine because we are querying the HostPlatform for the SDK path and only PlatformDarwin implements this function. I'm open to any suggestions (and will also think about this myself) for how to make the layering less awkward, the only hard requirement I have is that I need the SDK path remapping information inside the per-module Swift typesystem, so I can't depend on a target for any of this.

What do you think about the general idea of a HostPlatform having several cross-SDKs installed and knowing where to find them? What would be a better place for this otherwise?

I don't think putting this knowledge inside the host platform instance is a good idea. It already seems very odd to be enumerating all darwin platforms inside PlatformDarwin, when there is already PlatformXXX class for each of these platforms. It would be even weirder to include non-darwin platforms there.

Technically, platform objects are not tied to any particular target, and all you need to get one is an ArchSpec (static Platform::GetPlatformForArchitecture). Putting this knowledge into the "right" platform instances and then finding them based on the module's ArchSpec seems like it should be possible. I'm not convinced its a good idea to reach for a Platform object from a Module (it seems to open possibilities for inconsistencies between the platform chosen in this way, and the platform used for eventual launches), but it definitely seems better than defaulting to the host platform object (which also doesn't do anything to address the inconsistency).

Alternatively, since the list of "sdk" that the lldb happens to come with is a property of how it is built/deployed, it may also make sense to put this logic into the Host module somehow. A combination of the two approaches might be interesting too (the interactions between host and platform are always a bit weird). E.g., we could still query the Platform object for the sdk, but it would defer to some Host functionality to produce the right value. That way we could use xcrun (or whatever) on a mac, but theoretically other host systems could implement a different mechanism to locate the mac SDKs.

Finally, it may be possible to just have the list of sdks as some hardcoded list (populated by the build system?), in which case the code for that could live just about anywhere...

[aprantl]

I've reworked this a little based on your feedback.

First, I've renamed SDK to XcodeSDK. An Xcode SDK is a fairly specific concept and I'm not going to pretend that it makes sense to generalize it for something else, so I thought the name should reflect this. I've kept it in Utility though, since the functionality mirrors ArchSpec and one platform typically hosts many SDKs at the same time. I entertained the idea of creating a base class and each platform would implement its own SDK, which sounds neat, but with all the merging functionality needed, this doesn't really work out.

I did incorporate the suggestion of requesting a platform (because I do think it should be Platform or Host that is calling xcrun) via the Module's ArchSpec.

Finally I added unit tests for all of the SDK functionality.

I have no great idea for how to test the remapping functionality other than completely end-to-end, because its primary effect is showing when debugging the OS itself (you need to resolve files *inside* the SDK).

Let me know what you think!

[labath]

In D76471#1947250, @aprantl wrote:

I've reworked this a little based on your feedback.

First, I've renamed SDK to XcodeSDK. An Xcode SDK is a fairly specific concept and I'm not going to pretend that it makes sense to generalize it for something else, so I thought the name should reflect this. I've kept it in Utility though, since the functionality mirrors ArchSpec and one platform typically hosts many SDKs at the same time. I entertained the idea of creating a base class and each platform would implement its own SDK, which sounds neat, but with all the merging functionality needed, this doesn't really work out.

Thanks.

That sounds fine. I don't have a problem with a class like this residing in Utility. I also don't think it's time to try to generalize this just yet, as its very likely that the generalized concept would not fit what some other platform wants to do. I just think some of the apis should reflect the specificity of this more. Some inline comments reflect that.

I did incorporate the suggestion of requesting a platform (because I do think it should be Platform or Host that is calling xcrun) via the Module's ArchSpec.

That sounds fine to me, though I'd like to hear @jingham's take on Platform in this way. The part that I'm not super-clear on is the type argument to the GetSDKPath function. I mean, if I look at the XcodeSDK::Type enum, then the list pretty much mirrors the list if Platform classes we have. So asking a PlatformRemoteAppleWatch for an "AppleTV" sdk sounds nonsensical, and one gets the impression that this information should be already encoded in the selection of the platform object. It probably already is, via the ArchSpec argument, no?

In case of Apple platforms, this won't make a difference in practice, since the support for that is implemented in PlatformDarwin (which all of these inherit from), but it sounds like this will be a problem for the "linux" sdk (assuming this is what I think it is), as there the selected platform will be PlatformLinux, which has no clue about these sdk thingies.

So, it sounds to me like the sdk type should somehow play a role in the selection of the platform instance, or this functionality should be moved down into some Host function.

Finally I added unit tests for all of the SDK functionality.

I have no great idea for how to test the remapping functionality other than completely end-to-end, because its primary effect is showing when debugging the OS itself (you need to resolve files *inside* the SDK).

I guess this is down to our current inability to "mock" xcrun responses (?) It might be possible to do something about that in a unit test with a custom platform plugin, but it seems that the amount of untested functionality here is not very big (Module::RegisterSDK, basically), so we could let that slide.

lldb/include/lldb/Core/Module.h

517

RegisterXCodeSDK?

983

m_xcode_sdk

lldb/include/lldb/Target/Platform.h

437

GetXCodeSDKPath? (and maybe the argument can be the proper enum type now.

lldb/include/lldb/Utility/XcodeSDK.h

25

the fancy && is useless here without std::move (and it's not even very useful with it).

[aprantl]

In case of Apple platforms, this won't make a difference in practice, since the support for that is implemented in PlatformDarwin (which all of these inherit from), but it sounds like this will be a problem for the "linux" sdk (assuming this is what I think it is), as there the selected platform will be PlatformLinux, which has no clue about these sdk thingies.

The "Linux" SDK is a placeholder of sorts when debugging a Swift-on-Linux server application (e.g., something like https://www.kitura.io/) from *within* Xcode that points to a directory that contains the Swift resources/stdlib cross-compiled for Linux. So this is still an Xcode SDK that should be managed by PlatformDarwin despite the confusing name.

So, it sounds to me like the sdk type should somehow play a role in the selection of the platform instance, or this functionality should be moved down into some Host function.

Since there is only going to be one place that does the SDK detection via xcrun, I would either move it to PlatformDarwin or HostMacOSX. Personally, I think I prefer the Host, since this is something that is really about the machine LLDB is running on and not about the remote platform.

[labath]

Having this in the host layer sounds good to me.

[aprantl]

I just had an off-list conversation with @jingham were we discussed what should be Platform versus Host in detail. The resulting solution looks even more convoluted at first, but it actually solves a bunch of problems that I had with either of the previous proposals. Jim argued that an interface that retrieves an SDK for the target should live in PlatformDarwin, since we are querying something about a Darwin platform, and in principle, this interface should also be available if you are (hypothetically) debugging a macOS process from a Linux host, even if it isn't implemented at the time. However, the one concrete implementation that we have, the one that calls xcrun must live in HostInfoMacOSX, because xcrun doesn't anywhere else.

With this in mind I arrived at this version of the patch where the implementation lives in HostInfoMacOSX, but the interface lives in PlatformDarwin, which forwards to the host if an implementation exists. Let me (Pavel & Jim) know what you think about this variant!

[JDevlieghere]

I think the current separation makes a lot of sense, but I don't like that XcodeSDK class is part of Utility. I understand the need from a layering perspective and I don't really have a better idea, but maybe someone else does?

[labath]

I don't think that spreading this out over host and platform is convoluted. In fact, I was going to propose something like that myself. However, it does bring us back to the question of the "linux" sdk.

A couple of comments ago you said:

The "Linux" SDK is a placeholder of sorts when debugging a Swift-on-Linux server application (e.g., something like https://www.kitura.io/) from *within* Xcode that points to a directory that contains the Swift resources/stdlib cross-compiled for Linux.

When you say "cross-compiled", I am imagining that the resulting binary will be a regular linux elf file, and it's triple will be detected as ***-linux. So, Platform::GetPlatformForArchitecture(GetArchitecture(), nullptr) will return PlatformLinux, and the subsequent GetSDKPath will return blank, whereas I am expecting that you would want it to return HostInfoMacOSX::GetXcodeSDK(linux) (if running on macos).

So, if all of this is true, and we want this interface to reside on the Platform class, then I think the implementation of GetSDKPath needs to be spread out over the individual platform classes, which would delegate to the appropriate host api. E.g. PlatformLinux::GetSDKPath (with no arguments) would be implemented via HostInfo::GetXcodeSDK(linux), PlatformRemoteAppleWatch::GetSDKPath as HostInfo::GetXcodeSDK(watchos), etc.

This would give us maximum flexibility. For instance one could implement HostInfoLinux::GetXcodeSDK to locate the xcode sdk through some other mechanism, and then cross-debugging mac binaries would work too. Or, one could implement PlatformXXX::GetSDKPath to download the sdk from the remote system somehow if it is not found on the host, and then we would be able to debug on any host. However, I found all of these scenarios fairly unlikely, which is why I said that going straight for the host seems fine. The interface is still sensible -- we just say that the host system has to provide the sdks for any of the listed platforms. And if the host doesn't provide that, tough luck. That setup can always be generalized if we have a need for it.

In D76471#1954045, @JDevlieghere wrote:

I think the current separation makes a lot of sense, but I don't like that XcodeSDK class is part of Utility. I understand the need from a layering perspective and I don't really have a better idea, but maybe someone else does?

We could move it up to Host, and have it be next to the HostInfo::GetXcodeSDK function which returns it. Would that look any better?

[aprantl]

In D76471#1954205, @labath wrote:

I don't think that spreading this out over host and platform is convoluted. In fact, I was going to propose something like that myself. However, it does bring us back to the question of the "linux" sdk.

A couple of comments ago you said:

The "Linux" SDK is a placeholder of sorts when debugging a Swift-on-Linux server application (e.g., something like https://www.kitura.io/) from *within* Xcode that points to a directory that contains the Swift resources/stdlib cross-compiled for Linux.

When you say "cross-compiled", I am imagining that the resulting binary will be a regular linux elf file, and it's triple will be detected as ***-linux. So, Platform::GetPlatformForArchitecture(GetArchitecture(), nullptr) will return PlatformLinux, and the subsequent GetSDKPath will return blank, whereas I am expecting that you would want it to return HostInfoMacOSX::GetXcodeSDK(linux) (if running on macos).

So, if all of this is true, and we want this interface to reside on the Platform class, then I think the implementation of GetSDKPath needs to be spread out over the individual platform classes, which would delegate to the appropriate host api. E.g. PlatformLinux::GetSDKPath (with no arguments) would be implemented via HostInfo::GetXcodeSDK(linux), PlatformRemoteAppleWatch::GetSDKPath as HostInfo::GetXcodeSDK(watchos), etc.

This would give us maximum flexibility. For instance one could implement HostInfoLinux::GetXcodeSDK to locate the xcode sdk through some other mechanism, and then cross-debugging mac binaries would work too. Or, one could implement PlatformXXX::GetSDKPath to download the sdk from the remote system somehow if it is not found on the host, and then we would be able to debug on any host. However, I found all of these scenarios fairly unlikely, which is why I said that going straight for the host seems fine. The interface is still sensible -- we just say that the host system has to provide the sdks for any of the listed platforms. And if the host doesn't provide that, tough luck. That setup can always be generalized if we have a need for it.

Great! I think the current version of the patch reflects all of that, with only one difference — something that I actually overlooked in the previous version. We now have Platform that provides the interface to provide an SDK, and will forward the question to Host. Each Host can define its own mechanisms for doing so. So far I have only provided an implementation for macOS, which runs xcrun. What I can't do is remove the SDK parameter from the interface in platform, because Xcode may contain differently versioned SDKs (e.g., a MacOSX10.14.sdk and a MacOSX10.15.sdk) plus some wrinkles that are only relevant when you are developing the OS itself. That said, even without removing the SDK parameter from GetSDKPath(), we can still implement HostInfoLinux::GetXcodeSDK() for hypothetical Linux -> macOS cross-debugger you mentioned above, so I don't think the extra parameter tarnishes the design.

In D76471#1954045, @JDevlieghere wrote:

I think the current separation makes a lot of sense, but I don't like that XcodeSDK class is part of Utility. I understand the need from a layering perspective and I don't really have a better idea, but maybe someone else does?

We could move it up to Host, and have it be next to the HostInfo::GetXcodeSDK function which returns it. Would that look any better?

In a way XcodeSDK is like Triple or ArchSpec, so I've started to feel less bad about putting it into Utility, where ArchSpec lives.

[labath]

Ok, I think we have converged onto something here. I just think it would be good to rename some functions/variables to make it clear they are working with an xcode sdk, and not some generic entity.

In D76471#1955908, @aprantl wrote:

Great! I think the current version of the patch reflects all of that, with only one difference — something that I actually overlooked in the previous version. We now have Platform that provides the interface to provide an SDK, and will forward the question to Host. Each Host can define its own mechanisms for doing so. So far I have only provided an implementation for macOS, which runs xcrun. What I can't do is remove the SDK parameter from the interface in platform, because Xcode may contain differently versioned SDKs (e.g., a MacOSX10.14.sdk and a MacOSX10.15.sdk) plus some wrinkles that are only relevant when you are developing the OS itself. That said, even without removing the SDK parameter from GetSDKPath(), we can still implement HostInfoLinux::GetXcodeSDK() for hypothetical Linux -> macOS cross-debugger you mentioned above, so I don't think the extra parameter tarnishes the design.

Yeah, it seems acceptable. The "sdk type" argument still seems somewhat redundant. Theoretically we could pass in just the triple component out the xcodesdk object, but that would just mean the individual platforms would have to reconstruct the XcodeSDK object, which is already present in the caller, so it's not ideal either...

lldb/include/lldb/Core/Module.h

517

ping

983

ping?

[aprantl]

Renamed SDK -> XcodeSDK where applicable. Sorry I missed this earlier.

[aprantl]

Yeah, it seems acceptable. The "sdk type" argument still seems somewhat redundant. Theoretically we could pass in just the triple component out the xcodesdk object, but that would just mean the individual platforms would have to reconstruct the XcodeSDK object, which is already present in the caller, so it's not ideal either...

It's an entire string, not just the type, because it also contains an (optional) version number.

lldb/include/lldb/Target/Platform.h

437

That would look clean, but unfortunately it has to be a full XcodeSDK string, because in addition to the type, it optionally also contains a version number and some other bits that are applicable only when developing the OS itself.

[labath]

Ok, I think we've done what we can here.

In D76471#1958814, @aprantl wrote:

Yeah, it seems acceptable. The "sdk type" argument still seems somewhat redundant. Theoretically we could pass in just the triple component out the xcodesdk object, but that would just mean the individual platforms would have to reconstruct the XcodeSDK object, which is already present in the caller, so it's not ideal either...

It's an entire string, not just the type, because it also contains an (optional) version number.

err.. I meant "just the _version_ component", but it sounds like you are saying you need more than the version.

[sylvestre.ledru]

lldb/source/Utility/XcodeSDK.cpp

73

With older version of the libcstdc++ (some Ubuntu LTS), it fails with:

 error: chosen constructor is explicit in copy-initialization
  return {sdk, version};
         ^~~~~~~~~~~~~~
/usr/lib/gcc/i686-linux-gnu/5.3.1/../../../../include/c++/5.3.1/tuple:612:19: note: explicit constructor declared here
        constexpr tuple(_U1&& __a1, _U2&& __a2)

@aprantl Could you please have a look ?

[aprantl]

lldb/source/Utility/XcodeSDK.cpp

73

I have made an attempt in f5be71b4450, but if that doesn't work, I'll need some help since I don't really know what works and doesn't work on that particular platform.

lldb/include/lldb/Core/Module.h

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
+#include "lldb/Utility/XcodeSDK.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
public:
   const llvm::sys::TimePoint<> &GetObjectModificationTime() const {
     return m_object_mod_time;
   }
 
   void SetObjectModificationTime(const llvm::sys::TimePoint<> &mod_time) {
     m_mod_time = mod_time;
   }
 
+  /// This callback will be called by SymbolFile implementations when
+  /// parsing a compile unit that contains SDK information.
+  /// \param sdk will be merged with \p m_sdk.
+  /// \param sysroot will be added to the path remapping dictionary.
+  void RegisterXcodeSDK(llvm::StringRef sdk, llvm::StringRef sysroot);
+
   /// Tells whether this module is capable of being the main executable for a
   /// process.
   ///
   /// \return
   ///     \b true if it is, \b false otherwise.
   bool IsExecutable();
 
   /// Tells whether this module has been loaded in the target passed in. This
protected:
   ///< we need to keep all old symbol files around in case anyone has type
   ///references to them
   TypeSystemMap m_type_system_map;   ///< A map of any type systems associated
                                      ///with this module
   /// Module specific source remappings for when you have debug info for a
   /// module that doesn't match where the sources currently are.
   PathMappingList m_source_mappings =
       ModuleList::GetGlobalModuleListProperties().GetSymlinkMappings();
+
+  /// The (Xcode) SDK this module was compiled with.
+  XcodeSDK m_xcode_sdk;
+  
   lldb::SectionListUP m_sections_up; ///< Unified section list for module that
                                      /// is used by the ObjectFile and and
                                      /// ObjectFile instances for the debug info
 
   std::atomic<bool> m_did_load_objfile{false};
   std::atomic<bool> m_did_load_symfile{false};
   std::atomic<bool> m_did_set_uuid{false};
   mutable bool m_file_has_changed : 1,

lldb/include/lldb/Host/HostInfoBase.h

 //===-- HostInfoBase.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_HOSTINFOBASE_H
 #define LLDB_HOST_HOSTINFOBASE_H
 
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UserIDResolver.h"
+#include "lldb/Utility/XcodeSDK.h"
 #include "lldb/lldb-enumerations.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <stdint.h>
 
 #include <string>
 
 namespace lldb_private {
public:
   /// If the triple does not specify the vendor, os, and environment parts, we
   /// "augment" these using information from the host and return the resulting
   /// ArchSpec object.
   static ArchSpec GetAugmentedArchSpec(llvm::StringRef triple);
 
   static bool ComputePathRelativeToLibrary(FileSpec &file_spec,
                                            llvm::StringRef dir);
 
+  /// Return the directory containing a specific Xcode SDK.
+  static std::string GetXcodeSDK(XcodeSDK sdk) { return {}; }
+
 protected:
   static bool ComputeSharedLibraryDirectory(FileSpec &file_spec);
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static bool ComputeProcessTempFileDirectory(FileSpec &file_spec);
   static bool ComputeGlobalTempFileDirectory(FileSpec &file_spec);
   static bool ComputeTempFileBaseDirectory(FileSpec &file_spec);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
   static bool ComputeSystemPluginsDirectory(FileSpec &file_spec);
   static bool ComputeUserPluginsDirectory(FileSpec &file_spec);
 
   static void ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                              ArchSpec &arch_64);
 };
 }
 
 #endif

lldb/include/lldb/Host/macosx/HostInfoMacOSX.h

 //===-- HostInfoMacOSX.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_MACOSX_HOSTINFOMACOSX_H
 #define LLDB_HOST_MACOSX_HOSTINFOMACOSX_H
 
 #include "lldb/Host/posix/HostInfoPosix.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/XcodeSDK.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ArchSpec;
 
 class HostInfoMacOSX : public HostInfoPosix {
   friend class HostInfoBase;
 
 private:
   // Static class, unconstructable.
   HostInfoMacOSX() = delete;
   ~HostInfoMacOSX() = delete;
 
 public:
   static llvm::VersionTuple GetOSVersion();
   static llvm::VersionTuple GetMacCatalystVersion();
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static FileSpec GetProgramFileSpec();
+  static std::string FindXcodeContentsDirectoryInPath(llvm::StringRef path);
 
+  /// Query xcrun to find an Xcode SDK directory.
+  static std::string GetXcodeSDK(XcodeSDK sdk);
 protected:
   static bool ComputeSupportExeDirectory(FileSpec &file_spec);
   static void ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                              ArchSpec &arch_64);
   static bool ComputeHeaderDirectory(FileSpec &file_spec);
   static bool ComputeSystemPluginsDirectory(FileSpec &file_spec);
   static bool ComputeUserPluginsDirectory(FileSpec &file_spec);
 };
 }
 
 #endif

lldb/include/lldb/Target/Platform.h

public:
 
   // Given a target, find the local SDK directory if one exists on the current
   // host.
   virtual lldb_private::ConstString
   GetSDKDirectory(lldb_private::Target &target) {
     return lldb_private::ConstString();
   }
 
+  virtual llvm::StringRef GetSDKPath(lldb_private::XcodeSDK sdk) {
+    return {};
+  }
+
   const std::string &GetRemoteURL() const { return m_remote_url; }
 
   bool IsHost() const {
     return m_is_host; // Is this the default host platform?
   }
 
   bool IsRemote() const { return !m_is_host; }
 

lldb/include/lldb/Utility/XcodeSDK.h

+//===-- XcodeSDK.h ----------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_SDK_H
+#define LLDB_UTILITY_SDK_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/VersionTuple.h"
+#include <tuple>
+
+namespace lldb_private {
+
+/// An abstraction for Xcode-style SDKs that works like \ref ArchSpec.
+class XcodeSDK {
+  std::string m_name;
+
+public:
+  XcodeSDK() = default;
+  XcodeSDK(std::string &&name) : m_name(std::move(name)) {}
+  static XcodeSDK GetAnyMacOS() { return XcodeSDK("MacOSX.sdk"); }
+
+  enum Type : int {
+    MacOSX = 0,
+    iPhoneSimulator,
+    iPhoneOS,
+    AppleTVSimulator,
+    AppleTVOS,
+    WatchSimulator,
+    watchOS,
+    bridgeOS,
+    Linux,
+    numSDKTypes,
+    unknown = -1
+  };
+  static llvm::StringRef GetNameForType(Type type);
+
+  /// The merge function follows a strict order to maintain monotonicity:
+  /// 1. SDK with the higher SDKType wins.
+  /// 2. The newer SDK wins.
+  void Merge(XcodeSDK other);
+
+  XcodeSDK &operator=(XcodeSDK other);
+  bool operator==(XcodeSDK other);
+
+  /// Return parsed SDK number, and SDK version number.
+  std::tuple<Type, llvm::VersionTuple> Parse() const;
+  llvm::VersionTuple GetVersion() const;
+  Type GetType() const;
+  llvm::StringRef GetString() const;
+
+  static bool SDKSupportsModules(Type type, llvm::VersionTuple version);
+  static bool SDKSupportsModules(Type desired_type, const FileSpec &sdk_path);
+  static llvm::StringRef GetSDKNameForType(Type type);
+};
+
+} // namespace lldb_private
+
+#endif

lldb/source/Core/Module.cpp

 }
 
 bool Module::RemapSourceFile(llvm::StringRef path,
                              std::string &new_path) const {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   return m_source_mappings.RemapPath(path, new_path);
 }
 
+void Module::RegisterXcodeSDK(llvm::StringRef sdk_name, llvm::StringRef sysroot) {
+  XcodeSDK sdk(sdk_name.str());
+  if (m_xcode_sdk == sdk)
+    return;
+  m_xcode_sdk.Merge(sdk);
+  PlatformSP module_platform =
+      Platform::GetPlatformForArchitecture(GetArchitecture(), nullptr);
+  ConstString sdk_path(module_platform->GetSDKPath(sdk));
+  if (!sdk_path)
+    return;
+  // If merged SDK changed for a previously registered source path, update it.
+  // This could happend with -fdebug-prefix-map, otherwise it's unlikely.
+  ConstString sysroot_cs(sysroot);
+  if (!m_source_mappings.Replace(sysroot_cs, sdk_path, true))
+    // In the general case, however, append it to the list.
+    m_source_mappings.Append(sysroot_cs, sdk_path, false);
+}
+
 bool Module::MergeArchitecture(const ArchSpec &arch_spec) {
   if (!arch_spec.IsValid())
     return false;
   LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_MODULES),
            "module has arch %s, merging/replacing with arch %s",
            m_arch.GetTriple().getTriple().c_str(),
            arch_spec.GetTriple().getTriple().c_str());
   if (!m_arch.IsCompatibleMatch(arch_spec)) {

lldb/source/Host/macosx/objcxx/HostInfoMacOSX.mm

 //===-- HostInfoMacOSX.mm ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/macosx/HostInfoMacOSX.h"
 #include "lldb/Host/FileSystem.h"
+#include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Log.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
#if defined(TARGET_OS_WATCH) && TARGET_OS_WATCH == 1
       arch_32.GetTriple().setOS(llvm::Triple::WatchOS);
 #else
       arch_32.GetTriple().setOS(llvm::Triple::IOS);
 #endif
       arch_64.Clear();
     }
   }
 }
+
+std::string HostInfoMacOSX::GetXcodeSDK(XcodeSDK sdk) {
+  std::string xcrun_cmd = "xcrun --show-sdk-path --sdk " +
+                          XcodeSDK::GetSDKNameForType(sdk.GetType()).str();
+  llvm::VersionTuple version = sdk.GetVersion();
+  if (!version.empty())
+    xcrun_cmd += version.getAsString();
+
+  int status = 0;
+  int signo = 0;
+  std::string output_str;
+  lldb_private::Status error =
+      Host::RunShellCommand(xcrun_cmd.c_str(), FileSpec(), &status, &signo,
+                            &output_str, std::chrono::seconds(15));
+
+  // Check that xcrun return something useful.
+  if (status != 0 || output_str.empty())
+    return {};
+
+  // Convert to a StringRef so we can manipulate the string without modifying
+  // the underlying data.
+  llvm::StringRef output(output_str);
+
+  // Remove any trailing newline characters.
+  output = output.rtrim();
+
+  // Strip any leading newline characters and everything before them.
+  const size_t last_newline = output.rfind('\n');
+  if (last_newline != llvm::StringRef::npos)
+    output = output.substr(last_newline + 1);
+
+  // Whatever is left in output should be a valid path.
+  if (!FileSystem::Instance().Exists(output))
+    return {};
+  return output.str();
+}

lldb/source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.h

public:
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx,
                                        lldb_private::ArchSpec &arch) override;
 
   void
   AddClangModuleCompilationOptions(lldb_private::Target *target,
                                    std::vector<std::string> &options) override {
     return PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
-        target, options, PlatformDarwin::SDKType::iPhoneSimulator);
+        target, options, lldb_private::XcodeSDK::Type::iPhoneSimulator);
   }
 
 protected:
   std::mutex m_sdk_dir_mutex;
   std::string m_sdk_directory;
   std::string m_build_update;
 
   const char *GetSDKDirectoryAsCString();
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformAppleTVSimulator);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMAPPLETVSIMULATOR_H

lldb/source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.h

public:
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx,
                                        lldb_private::ArchSpec &arch) override;
 
   void
   AddClangModuleCompilationOptions(lldb_private::Target *target,
                                    std::vector<std::string> &options) override {
     return PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
-        target, options, PlatformDarwin::SDKType::iPhoneSimulator);
+        target, options, lldb_private::XcodeSDK::Type::iPhoneSimulator);
   }
 
 protected:
   std::mutex m_sdk_dir_mutex;
   std::string m_sdk_directory;
   std::string m_build_update;
 
   const char *GetSDKDirectoryAsCString();
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformAppleWatchSimulator);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMAPPLEWATCHSIMULATOR_H

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

 //===-- PlatformDarwin.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMDARWIN_H
 #define LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMDARWIN_H
 
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
 #include "lldb/Host/FileSystem.h"
+#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StructuredData.h"
+#include "lldb/Utility/XcodeSDK.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FileSystem.h"
 
 #include <string>
 #include <tuple>
 
 class PlatformDarwin : public PlatformPOSIX {
 public:
public:
   lldb_private::FileSpec LocateExecutable(const char *basename) override;
 
   lldb_private::Status
   LaunchProcess(lldb_private::ProcessLaunchInfo &launch_info) override;
 
   static std::tuple<llvm::VersionTuple, llvm::StringRef>
   ParseVersionBuildDir(llvm::StringRef str);
 
-  enum SDKType : int {
-    MacOSX = 0,
-    iPhoneSimulator,
-    iPhoneOS,
-    AppleTVSimulator,
-    AppleTVOS,
-    WatchSimulator,
-    watchOS,
-    bridgeOS,
-    Linux,
-    numSDKTypes,
-    unknown = -1
-  };
-
   llvm::Expected<lldb_private::StructuredData::DictionarySP>
   FetchExtendedCrashInformation(lldb_private::Process &process) override;
 
-  static llvm::StringRef GetSDKNameForType(SDKType type);
-  static lldb_private::FileSpec GetXcodeSDK(SDKType type);
+  llvm::StringRef GetSDKPath(lldb_private::XcodeSDK sdk) override;
+
   static lldb_private::FileSpec GetXcodeContentsDirectory();
   static lldb_private::FileSpec GetXcodeDeveloperDirectory();
 
   /// Return the toolchain directroy the current LLDB instance is located in.
   static lldb_private::FileSpec GetCurrentToolchainDirectory();
 
   /// Return the command line tools directory the current LLDB instance is
   /// located in.
protected:
 
   void ReadLibdispatchOffsets(lldb_private::Process *process);
 
   virtual lldb_private::Status GetSharedModuleWithLocalCache(
       const lldb_private::ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
       const lldb_private::FileSpecList *module_search_paths_ptr,
       lldb::ModuleSP *old_module_sp_ptr, bool *did_create_ptr);
 
-  static bool SDKSupportsModules(SDKType sdk_type, llvm::VersionTuple version);
-
-  static bool SDKSupportsModules(SDKType desired_type,
-                                 const lldb_private::FileSpec &sdk_path);
-
   struct SDKEnumeratorInfo {
     lldb_private::FileSpec found_path;
-    SDKType sdk_type;
+    lldb_private::XcodeSDK::Type sdk_type;
   };
 
   static lldb_private::FileSystem::EnumerateDirectoryResult
   DirectoryEnumerator(void *baton, llvm::sys::fs::file_type file_type,
                       llvm::StringRef path);
 
   static lldb_private::FileSpec
-  FindSDKInXcodeForModules(SDKType sdk_type,
+  FindSDKInXcodeForModules(lldb_private::XcodeSDK::Type sdk_type,
                            const lldb_private::FileSpec &sdks_spec);
 
   static lldb_private::FileSpec
-  GetSDKDirectoryForModules(PlatformDarwin::SDKType sdk_type);
-
-  void
-  AddClangModuleCompilationOptionsForSDKType(lldb_private::Target *target,
-                                             std::vector<std::string> &options,
-                                             SDKType sdk_type);
+  GetSDKDirectoryForModules(lldb_private::XcodeSDK::Type sdk_type);
 
+  void AddClangModuleCompilationOptionsForSDKType(
+      lldb_private::Target *target, std::vector<std::string> &options,
+      lldb_private::XcodeSDK::Type sdk_type);
 
   lldb_private::Status FindBundleBinaryInExecSearchPaths(
       const lldb_private::ModuleSpec &module_spec,
       lldb_private::Process *process, lldb::ModuleSP &module_sp,
       const lldb_private::FileSpecList *module_search_paths_ptr,
       lldb::ModuleSP *old_module_sp_ptr, bool *did_create_ptr);
 
   static std::string FindComponentInPath(llvm::StringRef path,
                                          llvm::StringRef component);
   static std::string FindXcodeContentsDirectoryInPath(llvm::StringRef path);
 
+  std::string m_developer_directory;
+  llvm::StringMap<std::string> m_sdk_path;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformDarwin);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMDARWIN_H

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

     if (FileSystem::Instance().Exists(command_line_tools_path)) {
       g_command_line_tools_filespec = command_line_tools_path;
     }
   }
 
   return g_command_line_tools_filespec;
 }
 
-bool PlatformDarwin::SDKSupportsModules(SDKType sdk_type,
-                                        llvm::VersionTuple version) {
-  switch (sdk_type) {
-  case SDKType::MacOSX:
-    return version >= llvm::VersionTuple(10, 10);
-  case SDKType::iPhoneOS:
-  case SDKType::iPhoneSimulator:
-  case SDKType::AppleTVOS:
-  case SDKType::AppleTVSimulator:
-    return version >= llvm::VersionTuple(8);
-  case SDKType::watchOS:
-  case SDKType::WatchSimulator:
-    return version >= llvm::VersionTuple(6);
-  default:
-    return false;
-  }
-
-  return false;
-}
-
-bool PlatformDarwin::SDKSupportsModules(SDKType desired_type,
-                                        const FileSpec &sdk_path) {
-  ConstString last_path_component = sdk_path.GetLastPathComponent();
-
-  if (last_path_component) {
-    const llvm::StringRef sdk_name = last_path_component.GetStringRef();
-
-    const std::string sdk_name_lower = sdk_name.lower();
-    const llvm::StringRef sdk_string = GetSDKNameForType(desired_type);
-    if (!llvm::StringRef(sdk_name_lower).startswith(sdk_string))
-      return false;
-
-    auto version_part = sdk_name.drop_front(sdk_string.size());
-    version_part.consume_back(".sdk");
-
-    llvm::VersionTuple version;
-    if (version.tryParse(version_part))
-      return false;
-    return SDKSupportsModules(desired_type, version);
-  }
-
-  return false;
-}
-
 FileSystem::EnumerateDirectoryResult PlatformDarwin::DirectoryEnumerator(
     void *baton, llvm::sys::fs::file_type file_type, llvm::StringRef path) {
   SDKEnumeratorInfo *enumerator_info = static_cast<SDKEnumeratorInfo *>(baton);
 
   FileSpec spec(path);
-  if (SDKSupportsModules(enumerator_info->sdk_type, spec)) {
+  if (XcodeSDK::SDKSupportsModules(enumerator_info->sdk_type, spec)) {
     enumerator_info->found_path = spec;
     return FileSystem::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
   }
 
   return FileSystem::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
 }
 
-FileSpec PlatformDarwin::FindSDKInXcodeForModules(SDKType sdk_type,
+FileSpec PlatformDarwin::FindSDKInXcodeForModules(XcodeSDK::Type sdk_type,
                                                   const FileSpec &sdks_spec) {
   // Look inside Xcode for the required installed iOS SDK version
 
   if (!FileSystem::Instance().IsDirectory(sdks_spec)) {
     return FileSpec();
   }
 
   const bool find_directories = true;

       DirectoryEnumerator, &enumerator_info);
 
   if (FileSystem::Instance().IsDirectory(enumerator_info.found_path))
     return enumerator_info.found_path;
   else
     return FileSpec();
 }
 
-FileSpec PlatformDarwin::GetSDKDirectoryForModules(SDKType sdk_type) {
+FileSpec PlatformDarwin::GetSDKDirectoryForModules(XcodeSDK::Type sdk_type) {
   FileSpec sdks_spec = GetXcodeContentsDirectory();
   sdks_spec.AppendPathComponent("Developer");
   sdks_spec.AppendPathComponent("Platforms");
 
   switch (sdk_type) {
-  case SDKType::MacOSX:
+  case XcodeSDK::Type::MacOSX:
     sdks_spec.AppendPathComponent("MacOSX.platform");
     break;
-  case SDKType::iPhoneSimulator:
+  case XcodeSDK::Type::iPhoneSimulator:
     sdks_spec.AppendPathComponent("iPhoneSimulator.platform");
     break;
-  case SDKType::iPhoneOS:
+  case XcodeSDK::Type::iPhoneOS:
     sdks_spec.AppendPathComponent("iPhoneOS.platform");
     break;
   default:
     llvm_unreachable("unsupported sdk");
   }
 
   sdks_spec.AppendPathComponent("Developer");
   sdks_spec.AppendPathComponent("SDKs");
 
-  if (sdk_type == SDKType::MacOSX) {
+  if (sdk_type == XcodeSDK::Type::MacOSX) {
     llvm::VersionTuple version = HostInfo::GetOSVersion();
 
     if (!version.empty()) {
-      if (SDKSupportsModules(SDKType::MacOSX, version)) {
+      if (XcodeSDK::SDKSupportsModules(XcodeSDK::Type::MacOSX, version)) {
         // If the Xcode SDKs are not available then try to use the
         // Command Line Tools one which is only for MacOSX.
         if (!FileSystem::Instance().Exists(sdks_spec)) {
           sdks_spec = GetCommandLineToolsLibraryPath();
           sdks_spec.AppendPathComponent("SDKs");
         }
 
         // We slightly prefer the exact SDK for this machine.  See if it is
         // there.
 
         FileSpec native_sdk_spec = sdks_spec;
         StreamString native_sdk_name;
         native_sdk_name.Printf("MacOSX%u.%u.sdk", version.getMajor(),
                                version.getMinor().getValueOr(0));
         native_sdk_spec.AppendPathComponent(native_sdk_name.GetString());
 
         if (FileSystem::Instance().Exists(native_sdk_spec)) {
           return native_sdk_spec;
         }
       }
     }
   }
 
   return FindSDKInXcodeForModules(sdk_type, sdks_spec);
 }
 
 std::tuple<llvm::VersionTuple, llvm::StringRef>
 PlatformDarwin::ParseVersionBuildDir(llvm::StringRef dir) {
   llvm::StringRef build;
   llvm::StringRef version_str;
   llvm::StringRef build_str;
   std::tie(version_str, build_str) = dir.split(' ');
   llvm::VersionTuple version;
   if (!version.tryParse(version_str) ||
       build_str.empty()) {
     if (build_str.consume_front("(")) {
       size_t pos = build_str.find(')');
       build = build_str.slice(0, pos);
     }
   }
 
   return std::make_tuple(version, build);
 }
 
 llvm::Expected<StructuredData::DictionarySP>
 PlatformDarwin::FetchExtendedCrashInformation(Process &process) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   StructuredData::ArraySP annotations = ExtractCrashInfoAnnotations(process);
 
   if (!annotations || !annotations->GetSize()) {
     LLDB_LOG(log, "Couldn't extract crash information annotations");
     return nullptr;
   }
 
   StructuredData::DictionarySP extended_crash_info =
       std::make_shared<StructuredData::Dictionary>();
 
   extended_crash_info->AddItem("crash-info annotations", annotations);
 
   return extended_crash_info;
 }
 
 StructuredData::ArraySP
 PlatformDarwin::ExtractCrashInfoAnnotations(Process &process) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   ConstString section_name("__crash_info");
   Target &target = process.GetTarget();
   StructuredData::ArraySP array_sp = std::make_shared<StructuredData::Array>();
 
   for (ModuleSP module : target.GetImages().Modules()) {
     SectionList *sections = module->GetSectionList();
 
     std::string module_name = module->GetSpecificationDescription();
 
     // The DYDL module is skipped since it's always loaded when running the
     // binary.

 
     array_sp->AddItem(entry_sp);
   }
 
   return array_sp;
 }
 
 void PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
-    Target *target, std::vector<std::string> &options, SDKType sdk_type) {
+    Target *target, std::vector<std::string> &options, XcodeSDK::Type sdk_type) {
   const std::vector<std::string> apple_arguments = {
       "-x",       "objective-c++", "-fobjc-arc",
       "-fblocks", "-D_ISO646_H",   "-D__ISO646_H",
       "-fgnuc-version=4.2.1"};
 
   options.insert(options.end(), apple_arguments.begin(), apple_arguments.end());
 
   StreamString minimum_version_option;
   bool use_current_os_version = false;
   switch (sdk_type) {
-  case SDKType::iPhoneOS:
+  case XcodeSDK::Type::iPhoneOS:
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
     use_current_os_version = true;
 #else
     use_current_os_version = false;
 #endif
     break;
 
-  case SDKType::iPhoneSimulator:
+  case XcodeSDK::Type::iPhoneSimulator:
     use_current_os_version = false;
     break;
 
-  case SDKType::MacOSX:
+  case XcodeSDK::Type::MacOSX:
 #if defined(__i386__) || defined(__x86_64__)
     use_current_os_version = true;
 #else
     use_current_os_version = false;
 #endif
     break;
   default:
     break;

       ObjectFile *object_file = exe_module_sp->GetObjectFile();
       if (object_file)
         version = object_file->GetMinimumOSVersion();
     }
   }
   // Only add the version-min options if we got a version from somewhere
   if (!version.empty()) {
     switch (sdk_type) {
-    case SDKType::iPhoneOS:
+    case XcodeSDK::Type::iPhoneOS:
       minimum_version_option.PutCString("-mios-version-min=");
       minimum_version_option.PutCString(version.getAsString());
       break;
-    case SDKType::iPhoneSimulator:
+    case XcodeSDK::Type::iPhoneSimulator:
       minimum_version_option.PutCString("-mios-simulator-version-min=");
       minimum_version_option.PutCString(version.getAsString());
       break;
-    case SDKType::MacOSX:
+    case XcodeSDK::Type::MacOSX:
       minimum_version_option.PutCString("-mmacosx-version-min=");
       minimum_version_option.PutCString(version.getAsString());
       break;
     default:
       llvm_unreachable("unsupported sdk");
     }
     options.push_back(std::string(minimum_version_option.GetString()));
   }

         return buffer.str().str();
       }
     }
   }
 
   return {};
 }
 
-llvm::StringRef PlatformDarwin::GetSDKNameForType(SDKType type) {
-  switch (type) {
-  case MacOSX:
-    return "macosx";
-  case iPhoneSimulator:
-    return "iphonesimulator";
-  case iPhoneOS:
-    return "iphoneos";
-  case AppleTVSimulator:
-    return "appletvsimulator";
-  case AppleTVOS:
-    return "appletvos";
-  case WatchSimulator:
-    return "watchsimulator";
-  case watchOS:
-    return "watchos";
-  case bridgeOS:
-    return "bridgeos";
-  case Linux:
-    return "linux";
-  case numSDKTypes:
-  case unknown:
-    return "";
-  }
-  llvm_unreachable("unhandled switch case");
-}
-
-FileSpec PlatformDarwin::GetXcodeSDK(SDKType type) {
-  std::string xcrun_cmd =
-      "xcrun --show-sdk-path --sdk " + GetSDKNameForType(type).str();
-
-  int status = 0;
-  int signo = 0;
-  std::string output_str;
-  lldb_private::Status error =
-      Host::RunShellCommand(xcrun_cmd.c_str(), FileSpec(), &status, &signo,
-                            &output_str, std::chrono::seconds(15));
-
-  // Check that xcrun return something useful.
-  if (status != 0 || output_str.empty())
-    return {};
-
-  // Convert to a StringRef so we can manipulate the string without modifying
-  // the underlying data.
-  llvm::StringRef output(output_str);
-
-  // Remove any trailing newline characters.
-  output = output.rtrim();
-
-  // Strip any leading newline characters and everything before them.
-  const size_t last_newline = output.rfind('\n');
-  if (last_newline != llvm::StringRef::npos)
-    output = output.substr(last_newline + 1);
-
-  // Whatever is left in output should be a valid path.
-  if (!FileSystem::Instance().Exists(output))
-    return {};
-
-  // Find the contents dir in the xcrun provided path.
-  std::string xcode_contents_dir = FindXcodeContentsDirectoryInPath(output);
-  if (xcode_contents_dir.empty())
-    return {};
-
-  return FileSpec(xcode_contents_dir);
+llvm::StringRef PlatformDarwin::GetSDKPath(XcodeSDK sdk) {
+  std::string &path = m_sdk_path[sdk.GetString()];
+  if (path.empty())
+    path = HostInfo::GetXcodeSDK(sdk);
+  return path;
 }
 
 FileSpec PlatformDarwin::GetXcodeContentsDirectory() {
   static FileSpec g_xcode_contents_path;
   static std::once_flag g_once_flag;
   std::call_once(g_once_flag, [&]() {
     // Try the shlib dir first.
     if (FileSpec fspec = HostInfo::GetShlibDir()) {

             FindXcodeContentsDirectoryInPath(fspec.GetPath());
         if (!xcode_contents_dir.empty()) {
           g_xcode_contents_path = FileSpec(xcode_contents_dir);
           return;
         }
       }
     }
 
-    if (FileSpec fspec = GetXcodeSDK(SDKType::MacOSX)) {
+    FileSpec fspec(HostInfo::GetXcodeSDK(XcodeSDK::GetAnyMacOS()));
+    if (fspec) {
       if (FileSystem::Instance().Exists(fspec)) {
         std::string xcode_contents_dir =
             FindXcodeContentsDirectoryInPath(fspec.GetPath());
         if (!xcode_contents_dir.empty()) {
           g_xcode_contents_path = FileSpec(xcode_contents_dir);
           return;
         }
       }

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.h

public:
 
   lldb_private::ConstString
   GetSDKDirectory(lldb_private::Target &target) override;
 
   void
   AddClangModuleCompilationOptions(lldb_private::Target *target,
                                    std::vector<std::string> &options) override {
     return PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
-        target, options, PlatformDarwin::SDKType::MacOSX);
+        target, options, lldb_private::XcodeSDK::Type::MacOSX);
   }
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformMacOSX);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMMACOSX_H

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

sdk_path.Printf("%s/Developer/Platforms/MacOSX.platform/Developer/"
                     "SDKs/MacOSX%u.%u.sdk",
                     fspec.GetPath().c_str(), version.getMajor(),
                     version.getMinor().getValue());
     if (FileSystem::Instance().Exists(fspec))
       return ConstString(sdk_path.GetString());
   }
 
   // Use the default SDK as a fallback.
-  if (FileSpec fspec = GetXcodeSDK(SDKType::MacOSX)) {
+  FileSpec fspec(HostInfo::GetXcodeSDK(lldb_private::XcodeSDK::GetAnyMacOS()));
+  if (fspec) {
     if (FileSystem::Instance().Exists(fspec))
       return ConstString(fspec.GetPath());
   }
 
   return {};
 }
 
 Status PlatformMacOSX::GetSymbolFile(const FileSpec &platform_file,

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.h

GetSharedModule(const lldb_private::ModuleSpec &module_spec,
                   const lldb_private::FileSpecList *module_search_paths_ptr,
                   lldb::ModuleSP *old_module_sp_ptr,
                   bool *did_create_ptr) override;
 
   void
   AddClangModuleCompilationOptions(lldb_private::Target *target,
                                    std::vector<std::string> &options) override {
     return PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
-        target, options, PlatformDarwin::SDKType::iPhoneOS);
+        target, options, lldb_private::XcodeSDK::Type::iPhoneOS);
   }
 
 protected:
   struct SDKDirectoryInfo {
     SDKDirectoryInfo(const lldb_private::FileSpec &sdk_dir_spec);
     lldb_private::FileSpec directory;
     lldb_private::ConstString build;
     llvm::VersionTuple version;

lldb/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.h

public:
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx,
                                        lldb_private::ArchSpec &arch) override;
 
   void
   AddClangModuleCompilationOptions(lldb_private::Target *target,
                                    std::vector<std::string> &options) override {
     return PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
-        target, options, PlatformDarwin::SDKType::iPhoneSimulator);
+        target, options, lldb_private::XcodeSDK::Type::iPhoneSimulator);
   }
 
 protected:
   std::mutex m_sdk_dir_mutex;
   std::string m_sdk_directory;
   std::string m_build_update;
 
   const char *GetSDKDirectoryAsCString();
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformiOSSimulator);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMIOSSIMULATOR_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h

 //===-- DWARFUnit.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFUNIT_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFUNIT_H
 
 #include "DWARFDIE.h"
 #include "DWARFDebugInfoEntry.h"
 #include "lldb/lldb-enumerations.h"
+#include "lldb/Utility/XcodeSDK.h"
 #include "llvm/Support/RWMutex.h"
 #include <atomic>
 
 class DWARFUnit;
 class DWARFCompileUnit;
 class NameToDIE;
 class SymbolFileDWARF;
 class SymbolFileDWARFDwo;

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (dwarf_cu.GetOffset() == 0 && GetDebugMapSymfile()) {
       cu_sp = m_debug_map_symfile->GetCompileUnit(this);
       dwarf_cu.SetUserData(cu_sp.get());
     } else {
       ModuleSP module_sp(m_objfile_sp->GetModule());
       if (module_sp) {
         const DWARFBaseDIE cu_die =
             dwarf_cu.GetNonSkeletonUnit().GetUnitDIEOnly();
         if (cu_die) {
+          const char *sdk =
+            cu_die.GetAttributeValueAsString(DW_AT_APPLE_sdk, "");
+          const char *sysroot =
+              cu_die.GetAttributeValueAsString(DW_AT_LLVM_sysroot, "");
+          module_sp->RegisterXcodeSDK(sdk, sysroot);
           FileSpec cu_file_spec(cu_die.GetName(), dwarf_cu.GetPathStyle());
           MakeAbsoluteAndRemap(cu_file_spec, dwarf_cu, module_sp);
 
           LanguageType cu_language = SymbolFileDWARF::LanguageTypeFromDWARF(
               cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
 
           bool is_optimized = dwarf_cu.GetNonSkeletonUnit().GetIsOptimized();
           BuildCuTranslationTable();

lldb/source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility
   TildeExpressionResolver.cpp
   Timer.cpp
   UUID.cpp
   UriParser.cpp
   UserID.cpp
   UserIDResolver.cpp
   VASprintf.cpp
   VMRange.cpp
+  XcodeSDK.cpp
 
   LINK_LIBS
     ${LLDB_SYSTEM_LIBS}
     # lldbUtility does not depend on other LLDB libraries
 
   LINK_COMPONENTS
     BinaryFormat
     Support
   )

lldb/source/Utility/XcodeSDK.cpp

+//===-- XcodeSDK.cpp ------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/XcodeSDK.h"
+
+#include "lldb/lldb-types.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+XcodeSDK &XcodeSDK::operator=(XcodeSDK other) {
+  m_name = other.m_name;
+  return *this;
+}
+
+bool XcodeSDK::operator==(XcodeSDK other) {
+  return m_name == other.m_name;
+}
+
+static XcodeSDK::Type ParseSDKName(llvm::StringRef &name) {
+  if (name.consume_front("MacOSX"))
+    return XcodeSDK::MacOSX;
+  if (name.consume_front("iPhoneSimulator"))
+    return XcodeSDK::iPhoneSimulator;
+  if (name.consume_front("iPhoneOS"))
+    return XcodeSDK::iPhoneOS;
+  if (name.consume_front("AppleTVSimulator"))
+    return XcodeSDK::AppleTVSimulator;
+  if (name.consume_front("AppleTVOS"))
+    return XcodeSDK::AppleTVOS;
+  if (name.consume_front("WatchSimulator"))
+    return XcodeSDK::WatchSimulator;
+  if (name.consume_front("WatchOS"))
+    return XcodeSDK::watchOS;
+  if (name.consume_front("bridgeOS"))
+    return XcodeSDK::bridgeOS;
+  if (name.consume_front("Linux"))
+    return XcodeSDK::Linux;
+  static_assert(XcodeSDK::Linux == XcodeSDK::numSDKTypes - 1,
+                "New SDK type was added, update this list!");
+  return XcodeSDK::unknown;
+}
+
+static llvm::VersionTuple ParseSDKVersion(llvm::StringRef &name) {
+  unsigned i = 0;
+  while (i < name.size() && name[i] >= '0' && name[i] <= '9')
+    ++i;
+  if (name[i++] != '.')
+    return {};
+  while (i < name.size() && name[i] >= '0' && name[i] <= '9')
+    ++i;
+  if (name[i++] != '.')
+    return {};
+
+  llvm::VersionTuple version;
+  version.tryParse(name.slice(0, i - 1));
+  name = name.drop_front(i);
+  return version;
+}
+
+
+std::tuple<XcodeSDK::Type, llvm::VersionTuple> XcodeSDK::Parse() const {
+  llvm::StringRef input(m_name);
+  XcodeSDK::Type sdk = ParseSDKName(input);
+  llvm::VersionTuple version = ParseSDKVersion(input);
+  return {sdk, version};
+}
+
+llvm::VersionTuple XcodeSDK::GetVersion() const {
+  llvm::StringRef input(m_name);
+  ParseSDKName(input);
+  return ParseSDKVersion(input);
+}
+
+XcodeSDK::Type XcodeSDK::GetType() const {
+  llvm::StringRef input(m_name);
+  return ParseSDKName(input);
+}
+
+llvm::StringRef XcodeSDK::GetString() const { return m_name; }
+
+void XcodeSDK::Merge(XcodeSDK other) {
+  // The "bigger" SDK always wins.
+  if (Parse() < other.Parse())
+    *this = other;
+}
+
+llvm::StringRef XcodeSDK::GetSDKNameForType(XcodeSDK::Type type) {
+  switch (type) {
+  case MacOSX:
+    return "macosx";
+  case iPhoneSimulator:
+    return "iphonesimulator";
+  case iPhoneOS:
+    return "iphoneos";
+  case AppleTVSimulator:
+    return "appletvsimulator";
+  case AppleTVOS:
+    return "appletvos";
+  case WatchSimulator:
+    return "watchsimulator";
+  case watchOS:
+    return "watchos";
+  case bridgeOS:
+    return "bridgeos";
+  case Linux:
+    return "linux";
+  case numSDKTypes:
+  case unknown:
+    return "";
+  }
+  llvm_unreachable("unhandled switch case");
+}
+
+bool XcodeSDK::SDKSupportsModules(XcodeSDK::Type sdk_type,
+                                  llvm::VersionTuple version) {
+  switch (sdk_type) {
+  case Type::MacOSX:
+    return version >= llvm::VersionTuple(10, 10);
+  case Type::iPhoneOS:
+  case Type::iPhoneSimulator:
+  case Type::AppleTVOS:
+  case Type::AppleTVSimulator:
+    return version >= llvm::VersionTuple(8);
+  case Type::watchOS:
+  case Type::WatchSimulator:
+    return version >= llvm::VersionTuple(6);
+  default:
+    return false;
+  }
+
+  return false;
+}
+
+bool XcodeSDK::SDKSupportsModules(XcodeSDK::Type desired_type,
+                                  const FileSpec &sdk_path) {
+  ConstString last_path_component = sdk_path.GetLastPathComponent();
+
+  if (last_path_component) {
+    const llvm::StringRef sdk_name = last_path_component.GetStringRef();
+
+    const std::string sdk_name_lower = sdk_name.lower();
+    const llvm::StringRef sdk_string = GetSDKNameForType(desired_type);
+    if (!llvm::StringRef(sdk_name_lower).startswith(sdk_string))
+      return false;
+
+    auto version_part = sdk_name.drop_front(sdk_string.size());
+    version_part.consume_back(".sdk");
+
+    llvm::VersionTuple version;
+    if (version.tryParse(version_part))
+      return false;
+    return SDKSupportsModules(desired_type, version);
+  }
+
+  return false;
+}

lldb/unittests/Platform/PlatformDarwinTest.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 struct PlatformDarwinTester : public PlatformDarwin {
 public:
   using PlatformDarwin::FindComponentInPath;
   using PlatformDarwin::FindXcodeContentsDirectoryInPath;
-  static bool SDKSupportsModules(SDKType desired_type,
-                                 const lldb_private::FileSpec &sdk_path) {
-    return PlatformDarwin::SDKSupportsModules(desired_type, sdk_path);
-  }
 };
 
 TEST(PlatformDarwinTest, TestParseVersionBuildDir) {
   llvm::VersionTuple V;
   llvm::StringRef D;
 
   std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("1.2.3 (test1)");
   EXPECT_EQ(llvm::VersionTuple(1, 2, 3), V);
TEST(PlatformDarwinTest, TestParseVersionBuildDir) {
   EXPECT_EQ("test", D);
 
   std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("2.3.4 test");
   EXPECT_EQ(llvm::VersionTuple(2, 3, 4), V);
   EXPECT_EQ("", D);
 
   std::tie(V, D) = PlatformDarwin::ParseVersionBuildDir("3.4.5");
   EXPECT_EQ(llvm::VersionTuple(3, 4, 5), V);
-
-  std::string base = "/Applications/Xcode.app/Contents/Developer/Platforms/";
-  EXPECT_TRUE(PlatformDarwinTester::SDKSupportsModules(
-      PlatformDarwin::SDKType::iPhoneSimulator,
-      FileSpec(
-          base +
-          "iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk")));
-  EXPECT_FALSE(PlatformDarwinTester::SDKSupportsModules(
-      PlatformDarwin::SDKType::iPhoneSimulator,
-      FileSpec(
-          base +
-          "iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator7.2.sdk")));
-  EXPECT_TRUE(PlatformDarwinTester::SDKSupportsModules(
-      PlatformDarwin::SDKType::MacOSX,
-      FileSpec(base + "MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk")));
-  EXPECT_FALSE(PlatformDarwinTester::SDKSupportsModules(
-      PlatformDarwin::SDKType::MacOSX,
-      FileSpec(base + "MacOSX.platform/Developer/SDKs/MacOSX10.9.sdk")));
 }
 
 TEST(PlatformDarwinTest, FindXcodeContentsDirectoryInPath) {
   std::string standard =
       "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/"
       "Developer/SDKs/MacOSX.sdk";
   EXPECT_EQ("/Applications/Xcode.app/Contents",
             PlatformDarwinTester::FindXcodeContentsDirectoryInPath(standard));
TEST(PlatformDarwinTest, FindXcodeContentsDirectoryInPath) {
 
   std::string no_capitalization =
       "/Applications/Xcode.app/contents/Developer/Platforms/MacOSX.platform/"
       "Developer/SDKs/MacOSX10.15.sdk";
   EXPECT_EQ("", PlatformDarwinTester::FindXcodeContentsDirectoryInPath(
                     no_capitalization));
 }
 
-TEST(PlatformDarwinTest, GetSDKNameForType) {
-  EXPECT_EQ("macosx",
-            PlatformDarwin::GetSDKNameForType(PlatformDarwin::SDKType::MacOSX));
-  EXPECT_EQ("iphonesimulator", PlatformDarwin::GetSDKNameForType(
-                                   PlatformDarwin::SDKType::iPhoneSimulator));
-  EXPECT_EQ("iphoneos", PlatformDarwin::GetSDKNameForType(
-                            PlatformDarwin::SDKType::iPhoneOS));
-  EXPECT_EQ("appletvsimulator", PlatformDarwin::GetSDKNameForType(
-                                    PlatformDarwin::SDKType::AppleTVSimulator));
-  EXPECT_EQ("appletvos", PlatformDarwin::GetSDKNameForType(
-                             PlatformDarwin::SDKType::AppleTVOS));
-  EXPECT_EQ("watchsimulator", PlatformDarwin::GetSDKNameForType(
-                                  PlatformDarwin::SDKType::WatchSimulator));
-  EXPECT_EQ("watchos", PlatformDarwin::GetSDKNameForType(
-                           PlatformDarwin::SDKType::watchOS));
-  EXPECT_EQ("linux",
-            PlatformDarwin::GetSDKNameForType(PlatformDarwin::SDKType::Linux));
-  EXPECT_EQ("", PlatformDarwin::GetSDKNameForType(
-                    PlatformDarwin::SDKType::numSDKTypes));
-  EXPECT_EQ(
-      "", PlatformDarwin::GetSDKNameForType(PlatformDarwin::SDKType::unknown));
-}
-
 TEST(PlatformDarwinTest, FindComponentInPath) {
   EXPECT_EQ("/path/to/foo",
             PlatformDarwinTester::FindComponentInPath("/path/to/foo/", "foo"));
 
   EXPECT_EQ("/path/to/foo",
             PlatformDarwinTester::FindComponentInPath("/path/to/foo", "foo"));
 
   EXPECT_EQ("/path/to/foobar", PlatformDarwinTester::FindComponentInPath(
                                    "/path/to/foobar", "foo"));
 
   EXPECT_EQ("/path/to/foobar", PlatformDarwinTester::FindComponentInPath(
                                    "/path/to/foobar", "bar"));
 
   EXPECT_EQ("",
             PlatformDarwinTester::FindComponentInPath("/path/to/foo", "bar"));
 }

lldb/unittests/Utility/CMakeLists.txt

add_lldb_unittest(UtilityTests
   TildeExpressionResolverTest.cpp
   TimeoutTest.cpp
   TimerTest.cpp
   UriParserTest.cpp
   UserIDResolverTest.cpp
   UUIDTest.cpp
   VASprintfTest.cpp
   VMRangeTest.cpp
+  XcodeSDKTest.cpp
 
   LINK_LIBS
       lldbUtility
       lldbUtilityHelpers
       LLVMTestingSupport
   LINK_COMPONENTS
     Support
   )
 
 add_unittest_inputs(UtilityTests
   StructuredData-basic.json
   )

lldb/unittests/Utility/XcodeSDKTest.cpp

+//===-- XcodeSDKTest.cpp --------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/XcodeSDK.h"
+
+#include "llvm/ADT/StringRef.h"
+
+#include <tuple>
+
+using namespace lldb_private;
+
+TEST(XcodeSDKTest, ParseTest) {
+  EXPECT_EQ(XcodeSDK::GetAnyMacOS().GetType(), XcodeSDK::MacOSX);
+  EXPECT_EQ(XcodeSDK("MacOSX.sdk").GetType(), XcodeSDK::MacOSX);
+  EXPECT_EQ(XcodeSDK("iPhoneSimulator.sdk").GetType(), XcodeSDK::iPhoneSimulator);
+  EXPECT_EQ(XcodeSDK("iPhoneOS.sdk").GetType(), XcodeSDK::iPhoneOS);
+  EXPECT_EQ(XcodeSDK("AppleTVSimulator.sdk").GetType(), XcodeSDK::AppleTVSimulator);
+  EXPECT_EQ(XcodeSDK("AppleTVOS.sdk").GetType(), XcodeSDK::AppleTVOS);
+  EXPECT_EQ(XcodeSDK("WatchSimulator.sdk").GetType(), XcodeSDK::WatchSimulator);
+  EXPECT_EQ(XcodeSDK("WatchOS.sdk").GetType(), XcodeSDK::watchOS);
+  EXPECT_EQ(XcodeSDK("Linux.sdk").GetType(), XcodeSDK::Linux);
+  EXPECT_EQ(XcodeSDK("MacOSX.sdk").GetVersion(), llvm::VersionTuple());
+  EXPECT_EQ(XcodeSDK("MacOSX10.9.sdk").GetVersion(), llvm::VersionTuple(10, 9));
+  EXPECT_EQ(XcodeSDK("MacOSX10.15.4.sdk").GetVersion(), llvm::VersionTuple(10, 15));
+}
+
+TEST(XcodeSDKTest, MergeTest) {
+  XcodeSDK sdk("MacOSX.sdk");
+  sdk.Merge(XcodeSDK("WatchOS.sdk"));
+  // This doesn't make any particular sense and shouldn't happen in practice, we
+  // just want to guarantee a well-defined behavior when choosing one
+  // SDK to fit all CUs in an lldb::Module.
+  // -> The higher number wins.
+  EXPECT_EQ(sdk.GetType(), XcodeSDK::watchOS);
+  sdk.Merge(XcodeSDK("WatchOS1.1.sdk"));
+  EXPECT_EQ(sdk.GetVersion(), llvm::VersionTuple(1, 1));
+  sdk.Merge(XcodeSDK("WatchOS2.0.sdk"));
+  EXPECT_EQ(sdk.GetVersion(), llvm::VersionTuple(2, 0));
+}
+
+TEST(XcodeSDKTest, SDKSupportsModules) {
+  std::string base = "/Applications/Xcode.app/Contents/Developer/Platforms/";
+  EXPECT_TRUE(XcodeSDK::SDKSupportsModules(
+      XcodeSDK::Type::iPhoneSimulator,
+      FileSpec(
+          base +
+          "iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.0.sdk")));
+  EXPECT_FALSE(XcodeSDK::SDKSupportsModules(
+      XcodeSDK::Type::iPhoneSimulator,
+      FileSpec(
+          base +
+          "iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator7.2.sdk")));
+  EXPECT_TRUE(XcodeSDK::SDKSupportsModules(
+      XcodeSDK::Type::MacOSX,
+      FileSpec(base + "MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk")));
+  EXPECT_FALSE(XcodeSDK::SDKSupportsModules(
+      XcodeSDK::Type::MacOSX,
+      FileSpec(base + "MacOSX.platform/Developer/SDKs/MacOSX10.9.sdk")));
+}
+
+TEST(XcodeSDKTest, GetSDKNameForType) {
+  EXPECT_EQ("macosx", XcodeSDK::GetSDKNameForType(XcodeSDK::Type::MacOSX));
+  EXPECT_EQ("iphonesimulator",
+            XcodeSDK::GetSDKNameForType(XcodeSDK::Type::iPhoneSimulator));
+  EXPECT_EQ("iphoneos", XcodeSDK::GetSDKNameForType(XcodeSDK::Type::iPhoneOS));
+  EXPECT_EQ("appletvsimulator",
+            XcodeSDK::GetSDKNameForType(XcodeSDK::Type::AppleTVSimulator));
+  EXPECT_EQ("appletvos",
+            XcodeSDK::GetSDKNameForType(XcodeSDK::Type::AppleTVOS));
+  EXPECT_EQ("watchsimulator",
+            XcodeSDK::GetSDKNameForType(XcodeSDK::Type::WatchSimulator));
+  EXPECT_EQ("watchos", XcodeSDK::GetSDKNameForType(XcodeSDK::Type::watchOS));
+  EXPECT_EQ("linux", XcodeSDK::GetSDKNameForType(XcodeSDK::Type::Linux));
+  EXPECT_EQ("", XcodeSDK::GetSDKNameForType(XcodeSDK::Type::numSDKTypes));
+  EXPECT_EQ("", XcodeSDK::GetSDKNameForType(XcodeSDK::Type::unknown));
+}