debugserver: Support ios simulator load command disambiguation in qProcessInfo

[aprantl]

Summary

This patch basically moves the disambiguation code from a place where it was complicated to implement straight to where the load command is parsed, which has the neat side affect of actually supporting all call sites!

rdar://problem/66011909

[aprantl]

Update comment. I wonder if it is feasible to give the macCatalyst code the same treatment. It's more tricky because supporting zippered objects would force some additional state into the function.

[friss]

LGTM!

lldb/tools/debugserver/source/DNB.cpp

1396

s/doesn't/isn't/ ?

lldb/tools/debugserver/source/MacOSX/MachProcess.mm

782–783

I guess at this point we were really sure it was maybe a simulator :-)

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

def check_load_commands(self, expected_load_command):
             if expected_load_command in line:
               found += 1
         self.assertEquals(found, 1, "wrong load command")
 
     def check_debugserver(self, log, expected_platform, expected_version):
         """scan the debugserver packet log"""
         logfile = open(log, "r")
         dylib_info = None
-        response = False
+        process_info_ostype = None
+        expect_dylib_info_response = False
+        expect_process_info_response = False
         for line in logfile:
-            if response:
+            if expect_dylib_info_response:
                 while line[0] != '$':
                     line = line[1:]
                 line = line[1:]
                 # Unescape '}'.
                 dylib_info = json.loads(line.replace('}]','}')[:-4])
-                response = False
+                expect_dylib_info_response = False
             if 'send packet: $jGetLoadedDynamicLibrariesInfos:{' in line:
-                response = True
+                expect_dylib_info_response = True
+            if expect_process_info_response:
+                for pair in line.split(';'):
+                    keyval = pair.split(':')
+                    if len(keyval) == 2 and keyval[0] == 'ostype':
+                        process_info_ostype = keyval[1]
+            if 'send packet: $qProcessInfo#' in line:
+                expect_process_info_response = True
 
+        self.assertEquals(process_info_ostype, expected_platform)
         self.assertTrue(dylib_info)
         aout_info = None
         for image in dylib_info['images']:
             if image['pathname'].endswith('a.out'):
                 aout_info = image
         self.assertTrue(aout_info)
         self.assertEquals(aout_info['min_version_os_name'], expected_platform)
         if expected_version:

lldb/tools/debugserver/source/DNB.cpp

 const char *DNBGetDeploymentInfo(nub_process_t pid,
                                  const struct load_command& lc,
                                  uint64_t load_command_address,
                                  uint32_t& major_version,
                                  uint32_t& minor_version,
                                  uint32_t& patch_version) {
   MachProcessSP procSP;
   if (GetProcessSP(pid, procSP)) {
-    // FIXME: This doesn't correct for older ios simulator and macCatalyst.
+    // FIXME: This doesn't correct for macCatalyst.
     auto info = procSP->GetDeploymentInfo(lc, load_command_address);
     major_version = info.major_version;
     minor_version = info.minor_version;
     patch_version = info.patch_version;
     return procSP->GetPlatformString(info.platform);
   }
   return nullptr;
 }

lldb/tools/debugserver/source/MacOSX/MachProcess.h

GetTSDAddressForThread(nub_thread_t tid,
                          uint64_t plo_pthread_tsd_base_offset,
                          uint64_t plo_pthread_tsd_entry_size);
 
   struct DeploymentInfo {
     DeploymentInfo() = default;
     operator bool() { return platform > 0; }
     /// The Mach-O platform type;
     unsigned char platform = 0;
-    /// Pre-LC_BUILD_VERSION files don't disambiguate between ios and ios
-    /// simulator.
-    bool maybe_simulator = false;
     uint32_t major_version = 0;
     uint32_t minor_version = 0;
     uint32_t patch_version = 0;
   };
   DeploymentInfo GetDeploymentInfo(const struct load_command &,
                                    uint64_t load_command_address);
   static const char *GetPlatformString(unsigned char platform);
   bool GetMachOInformationFromMemory(uint32_t platform,

lldb/tools/debugserver/source/MacOSX/MachProcess.mm

auto handle_version_min = [&](char platform) {
     struct version_min_command vers_cmd;
     if (ReadMemory(load_command_address, sizeof(struct version_min_command),
                    &vers_cmd) != sizeof(struct version_min_command))
       return;
     info.platform = platform;
     info.major_version = vers_cmd.version >> 16;
     info.minor_version = (vers_cmd.version >> 8) & 0xffu;
     info.patch_version = vers_cmd.version & 0xffu;
-    info.maybe_simulator = true;
+
+    // Disambiguate legacy simulator platforms.
+#if (defined(__x86_64__) || defined(__i386__))
+    // If we are running on Intel macOS, it is safe to assume this is
+    // really a back-deploying simulator binary.
+    switch (info.platform) {
+    case PLATFORM_IOS:
+      info.platform = PLATFORM_IOSSIMULATOR;
+      break;
+    case PLATFORM_TVOS:
+      info.platform = PLATFORM_TVOSSIMULATOR;
+      break;
+    case PLATFORM_WATCHOS:
+      info.platform = PLATFORM_WATCHOSSIMULATOR;
+      break;
+    }
+#else
+    // On an Apple Silicon macOS host, there is no ambiguity. The only
+    // binaries that use legacy load commands are back-deploying
+    // native iOS binaries. All simulator binaries use the newer,
+    // unambiguous LC_BUILD_VERSION load commands.
+#endif
   };
   switch (cmd) {
   case LC_VERSION_MIN_IPHONEOS:
     handle_version_min(PLATFORM_IOS);
     break;
   case LC_VERSION_MIN_MACOSX:
     handle_version_min(PLATFORM_MACOS);
     break;
for (uint32_t j = 0; j < inf.mach_header.ncmds; j++) {
     }
     if (lc.cmd == LC_UUID) {
       struct uuid_command uuidcmd;
       if (ReadMemory(load_cmds_p, sizeof(struct uuid_command), &uuidcmd) ==
           sizeof(struct uuid_command))
         uuid_copy(inf.uuid, uuidcmd.uuid);
     }
     if (DeploymentInfo deployment_info = GetDeploymentInfo(lc, load_cmds_p)) {
-      // Simulator support. If the platform is ambiguous, use the dyld info.
-      if (deployment_info.maybe_simulator) {
-        if (deployment_info.maybe_simulator) {
-#if (defined(__x86_64__) || defined(__i386__))
-          // If dyld doesn't return a platform, use a heuristic.
-          // If we are running on Intel macOS, it is safe to assume
-          // this is really a back-deploying simulator binary.
-          switch (deployment_info.platform) {
-          case PLATFORM_IOS:
-            deployment_info.platform = PLATFORM_IOSSIMULATOR;
-            break;
-          case PLATFORM_TVOS:
-            deployment_info.platform = PLATFORM_TVOSSIMULATOR;
-            break;
-          case PLATFORM_WATCHOS:
-            deployment_info.platform = PLATFORM_WATCHOSSIMULATOR;
-            break;
-          }
-#else
-          // On an Apple Silicon macOS host, there is no
-          // ambiguity. The only binaries that use legacy load
-          // commands are back-deploying native iOS binaries. All
-          // simulator binaries use the newer, unambiguous
-          // LC_BUILD_VERSION load commands.
-          deployment_info.maybe_simulator = false;
-#endif
-        }
-      }
       const char *lc_platform = GetPlatformString(deployment_info.platform);
       // macCatalyst support.
       //
       // This handles two special cases:
       //
       // 1. Frameworks that have both a PLATFORM_MACOS and a
       //    PLATFORM_MACCATALYST load command.  Make sure to select
       //    the requested one.