Correctly detect legacy iOS simulator Mach-O objectfiles

[aprantl]

Summary

The code in ObjectFileMachO didn't disambiguate between ios and ios-simulator object files for Mach-O objects using the legacy ambiguous LC_VERSION_MIN load commands. This used to not matter before taught ArchSpec that ios and ios-simulator are no longer compatible.

rdar://problem/66545307

[friss]

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

5029–5030

It seems like this will also mark a binary with LC_VERSION_MIN_MACOSX as a simulator binary?

[aprantl]

Excellent point, Fred!

[aprantl]

Fix typo in test

[aprantl]

Fix a second mistake in the updated test.

[friss]

LGTM!

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

void ObjectFileMachO::GetAllArchSpecs(const llvm::MachO::mach_header &header,
   lldb::offset_t offset = lc_offset;
   for (uint32_t i = 0; i < header.ncmds; ++i) {
     const lldb::offset_t cmd_offset = offset;
     if (data.GetU32(&offset, &load_cmd, 2) == NULL)
       break;
 
     struct version_min_command version_min;
     switch (load_cmd.cmd) {
-    case llvm::MachO::LC_VERSION_MIN_IPHONEOS:
     case llvm::MachO::LC_VERSION_MIN_MACOSX:
+    case llvm::MachO::LC_VERSION_MIN_IPHONEOS:
     case llvm::MachO::LC_VERSION_MIN_TVOS:
     case llvm::MachO::LC_VERSION_MIN_WATCHOS: {
       if (load_cmd.cmdsize != sizeof(version_min))
         break;
       if (data.ExtractBytes(cmd_offset, sizeof(version_min),
                             data.GetByteOrder(), &version_min) == 0)
         break;
       MinOS min_os(version_min.version);
       llvm::SmallString<32> os_name;
       llvm::raw_svector_ostream os(os_name);
       os << GetOSName(load_cmd.cmd) << min_os.major_version << '.'
          << min_os.minor_version << '.' << min_os.patch_version;
 
       auto triple = base_triple;
       triple.setOSName(os.str());
-      os_name.clear();
+
+      // Disambiguate legacy simulator platforms.
+      if (load_cmd.cmd != llvm::MachO::LC_VERSION_MIN_MACOSX &&
+          (base_triple.getArch() == llvm::Triple::x86_64 ||
+           base_triple.getArch() == llvm::Triple::x86)) {
+        // The combination of legacy LC_VERSION_MIN load command and
+        // x86 architecture always indicates a simulator environment.
+        // The combination of LC_VERSION_MIN and arm architecture only
+        // appears for native binaries. Back-deploying simulator
+        // binaries on Apple Silicon Macs use the modern unambigous
+        // LC_BUILD_VERSION load commands; no special handling required.
+        triple.setEnvironment(llvm::Triple::Simulator);
+      }
       add_triple(triple);
       break;
     }
     default:
       break;
     }
 
     offset = cmd_offset + load_cmd.cmdsize;

lldb/source/Utility/ArchSpec.cpp

if ((lhs_triple_os == llvm::Triple::IOS &&
          lhs_triple_env == llvm::Triple::MacABI &&
          rhs_triple_os == llvm::Triple::MacOSX) ||
         (lhs_triple_os == llvm::Triple::MacOSX &&
          rhs_triple_os == llvm::Triple::IOS &&
          rhs_triple_env == llvm::Triple::MacABI))
       return true;
   }
 
-  if (lhs_triple_os != rhs_triple_os) {
-    const bool rhs_os_specified = rhs.TripleOSWasSpecified();
-    const bool lhs_os_specified = TripleOSWasSpecified();
-    // Both architectures had the OS specified, so if they aren't equal then
-    // we return false
-    if (rhs_os_specified && lhs_os_specified)
-      return false;
-
-    // Only fail if both os types are not unknown
-    if (lhs_triple_os != llvm::Triple::UnknownOS &&
-        rhs_triple_os != llvm::Triple::UnknownOS)
-      return false;
-  }
-
   // x86_64-apple-ios-macabi and x86_64-apple-ios are not compatible.
   if (lhs_triple_os == llvm::Triple::IOS &&
       rhs_triple_os == llvm::Triple::IOS &&
       (lhs_triple_env == llvm::Triple::MacABI ||
        rhs_triple_env == llvm::Triple::MacABI) &&
       lhs_triple_env != rhs_triple_env)
     return false;
 
+  if (lhs_triple_os != rhs_triple_os) {
+    const bool lhs_os_specified = TripleOSWasSpecified();
+    const bool rhs_os_specified = rhs.TripleOSWasSpecified();
+    // If both OS types are specified and different, fail.
+    if (lhs_os_specified && rhs_os_specified)
+      return false;
+
+    // If the pair of os+env is both unspecified, match any other os+env combo.
+    if (!exact_match && ((!lhs_os_specified && !lhs_triple.hasEnvironment()) ||
+                         (!rhs_os_specified && !rhs_triple.hasEnvironment())))
+      return true;
+  }
+
   return IsCompatibleEnvironment(lhs_triple_env, rhs_triple_env);
 }
 
 void ArchSpec::UpdateCore() {
   llvm::StringRef arch_name(m_triple.getArchName());
   const CoreDefinition *core_def = FindCoreDefinition(arch_name);
   if (core_def) {
     m_core = core_def->core;

lldb/test/API/macosx/simulator/TestSimulatorPlatform.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 import lldbsuite.test.lldbutil as lldbutil
 import json
 import unittest2
 
 
-@skipIfDarwin # rdar://problem/64552748
 class TestSimulatorPlatformLaunching(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     def check_load_commands(self, expected_load_command):
         """sanity check the built binary for the expected number of load commands"""
         load_cmds = subprocess.check_output(
def check_debugserver(self, log, expected_platform, expected_version):
                 aout_info = image
         self.assertTrue(aout_info)
         self.assertEquals(aout_info['min_version_os_name'], expected_platform)
         if expected_version:
             self.assertEquals(aout_info['min_version_os_sdk'], expected_version)
 
 
     def run_with(self, arch, os, vers, env, expected_load_command):
-        self.build(dictionary={'TRIPLE': arch+'-apple-'+os+vers+'-'+env})
+        env_list = [env] if env else []
+        triple = '-'.join([arch, 'apple', os + vers] + env_list)
+        self.build(dictionary={'TRIPLE': triple})
         self.check_load_commands(expected_load_command)
         log = self.getBuildArtifact('packets.log')
         self.expect("log enable gdb-remote packets -f "+log)
         lldbutil.run_to_source_breakpoint(self, "break here",
                                           lldb.SBFileSpec("hello.c"))
-        self.expect('image list -b -t',
-                    patterns=['a\.out '+arch+'-apple-'+os+vers+'.*-'+env])
+        triple_re = '-'.join([arch, 'apple', os + vers+'.*'] + env_list)
+        self.expect('image list -b -t', patterns=['a\.out '+triple_re])
         self.check_debugserver(log, os+env, vers)
 
     @skipUnlessDarwin
     @skipIfDarwinEmbedded
     @apple_simulator_test('iphone')
     def test_ios(self):
         """Test running an iOS simulator binary"""
         self.run_with(arch=self.getArchitecture(),
class TestSimulatorPlatformLaunching(TestBase):
     # Older Mach-O versions used less expressive load commands, such
     # as LC_VERSION_MIN_IPHONEOS that wouldn't distinguish between ios
     # and ios-simulator.  When targeting a simulator on Apple Silicon
     # macOS, however, these legacy load commands are never generated.
     #
         
     @skipUnlessDarwin
     @skipIfDarwinEmbedded
+    def test_lc_version_min_macosx(self):
+        """Test running a back-deploying non-simulator MacOS X binary"""
+        self.run_with(arch=self.getArchitecture(),
+                      os='macosx', vers='10.9', env='',
+                      expected_load_command='LC_VERSION_MIN_MACOSX')
+    @skipUnlessDarwin
+    @skipIfDarwinEmbedded
     @apple_simulator_test('iphone')
     @skipIf(archs=['arm64','arm64e'])
     def test_lc_version_min_iphoneos(self):
         """Test running a back-deploying iOS simulator binary
            with a legacy iOS load command"""
         self.run_with(arch=self.getArchitecture(),
                       os='ios', vers='11.0', env='simulator',
                       expected_load_command='LC_VERSION_MIN_IPHONEOS')

lldb/unittests/Utility/ArchSpecTest.cpp

TEST(ArchSpecTest, Compatibility) {
     ASSERT_FALSE(A.IsExactMatch(B));
     ASSERT_FALSE(A.IsCompatibleMatch(B));
   }
   {
     ArchSpec A("x86_64-*-*");
     ArchSpec B("x86_64-apple-ios-simulator");
     ASSERT_FALSE(A.IsExactMatch(B));
     ASSERT_FALSE(A.IsCompatibleMatch(B));
+    ASSERT_FALSE(B.IsExactMatch(A));
+    ASSERT_FALSE(B.IsCompatibleMatch(A));
+  }
+  {
+    ArchSpec A("x86_64-apple-ios");
+    ArchSpec B("x86_64-apple-ios-simulator");
+    ASSERT_FALSE(A.IsExactMatch(B));
+    ASSERT_FALSE(A.IsCompatibleMatch(B));
+    ASSERT_FALSE(B.IsExactMatch(A));
+    ASSERT_FALSE(B.IsCompatibleMatch(A));
+  }
+  {
+    // FIXME: This is surprisingly not equivalent to "x86_64-*-*".
+    ArchSpec A("x86_64");
+    ArchSpec B("x86_64-apple-ios-simulator");
+    ASSERT_FALSE(A.IsExactMatch(B));
+    ASSERT_TRUE(A.IsCompatibleMatch(B));
+    ASSERT_FALSE(B.IsExactMatch(A));
+    ASSERT_TRUE(B.IsCompatibleMatch(A));
   }
   {
     ArchSpec A("arm64-apple-ios");
     ArchSpec B("arm64-apple-ios-simulator");
     ASSERT_FALSE(A.IsExactMatch(B));
     ASSERT_FALSE(A.IsCompatibleMatch(B));
     ASSERT_FALSE(B.IsCompatibleMatch(A));
     ASSERT_FALSE(B.IsCompatibleMatch(A));