[debugserver] Fix LC_BUILD_VERSION load command handling.

[friss]

Summary

In one of the 2 places the LC_BUILD_VERSION load command is handled, there
is a bug preventing us from actually handling them (the address where to
read the load command was not updated). This patch factors reading the
deployment target load commands into a helper and adds testing for the 2
code paths calling the helper.

The testing is a llittle bit complicated because the only times those load
commands matter is when debugging a simulator process. I added a new
decorator to check that a specific SDK is available. The actual testing was
fairly easy once I knew how to run a simulated process.

Adding Pavel as a reviewer given I slightly modified the lldb-server test
harness.

[labath]

I thing the changes are fine. The only part that worries me is the in-class initialization of the simulator variables. I think this will fail on non-apple hosts.

packages/Python/lldbsuite/test/tools/lldb-server/TestAppleSimulatorOSType.py

16–18 ↗

(On Diff #141083)

I think these will cause a problem as they will be executed even if the test is skipped. Will this throw an exception if "xcrun" fails (e.g. because you're on linux). It might be best to move this into some function..

113 ↗

(On Diff #141083)

If you make this a list (['watchos']), you won't have to add the weird-looking comma at the end.

packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

50 ↗

(On Diff #141083)

I don't think this needs to be a thread command, as the pid is not thread-specific. We could just make this a regular command like print-message et al.

[friss]

packages/Python/lldbsuite/test/tools/lldb-server/TestAppleSimulatorOSType.py

16–18 ↗

(On Diff #141083)

Yep, I coincidentally realized this on my commute this morning. I'll fix it.

packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

50 ↗

(On Diff #141083)

No problem.

[jasonmolenda]

Looks good to me.

packages/Python/lldbsuite/test/decorators.py

359 ↗

(On Diff #141083)

It might be helpful for anyone debugging this if examples of the names this is matching were included in a comment. iphonesimulator, appletvsimulator, watchsimulator. Different capitalization is used in so many places (and whether to include "os" suffix or not, and whether to include "apple" prefix or not) that it can be hard to know what's expected unless you run the command yourself.

tools/debugserver/source/MacOSX/MachProcess.mm

584 ↗

(On Diff #141083)

Not important, but we're requiring a MacOS SDK of 10.11 or newer and the tvos and watchos SDKs were available by then; we could remove these ifdefs. (LC_BUILD_VERSION is newer than that & needs to be kept around.)

588 ↗

(On Diff #141083)

It's equivalent, no big deal, but this is a bitwise | not a logical ||.

lldb/trunk/packages/Python/lldbsuite/test/decorators.py

def no_debug_info_test(func):
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from the regular tests.
     wrapper.__no_debug_info_test__ = True
     return wrapper
 
+def apple_simulator_test(platform):
+    """
+    Decorate the test as a test requiring a simulator for a specific platform.
+
+    Consider that a simulator is available if you have the corresponding SDK installed.
+    The SDK identifiers for simulators are iphonesimulator, appletvsimulator, watchsimulator
+    """
+    def should_skip_simulator_test():
+        if lldbplatformutil.getHostPlatform() != 'darwin':
+            return "simulator tests are run only on darwin hosts"
+        try:
+            DEVNULL = open(os.devnull, 'w')
+            output = subprocess.check_output(["xcodebuild", "-showsdks"], stderr=DEVNULL)
+            if re.search('%ssimulator' % platform, output):
+                return None
+            else:
+                return "%s simulator is not supported on this system." % platform
+        except subprocess.CalledProcessError:
+            return "%s is not supported on this system (xcodebuild failed)." % feature
+
+    return skipTestIfFn(should_skip_simulator_test)
+
 
 def debugserver_test(func):
     """Decorate the item as a debugserver test."""
     def should_skip_debugserver_test():
         return "debugserver tests" if configuration.dont_do_debugserver_test else None
     return skipTestIfFn(should_skip_debugserver_test)(func)
 
 

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestAppleSimulatorOSType.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+import lldbgdbserverutils
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+import json
+
+class TestAppleSimulatorOSType(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def check_simulator_ostype(self, sdk, platform_names, arch='x86_64'):
+        sim_devices_str = subprocess.check_output(['xcrun', 'simctl', 'list',
+                                                   '-j', 'devices'])
+        sim_devices = json.loads(sim_devices_str)['devices']
+        # Find an available simulator for the requested platform
+        deviceUDID = None
+        for (runtime,devices) in sim_devices.items():
+            if not any(p in runtime.lower() for p in platform_names):
+                continue
+            for device in devices:
+                if device['availability'] != '(available)':
+                    continue
+                deviceUDID = device['udid']
+                break
+            if deviceUDID != None:
+                break
+
+        # Launch the process using simctl
+        self.assertIsNotNone(deviceUDID)
+        exe_name = 'test_simulator_platform_{}'.format(platform_names[0])
+        sdkroot = subprocess.check_output(['xcrun', '--show-sdk-path', '--sdk',
+                                           sdk])
+        self.build(dictionary={ 'EXE': exe_name, 'SDKROOT': sdkroot.strip(),
+                                'ARCH': arch })
+        exe_path = self.getBuildArtifact(exe_name)
+        sim_launcher = subprocess.Popen(['xcrun', 'simctl', 'spawn',
+                                         deviceUDID, exe_path,
+                                         'print-pid', 'sleep:10'],
+                                        stderr=subprocess.PIPE)
+        # Get the PID from the process output
+        pid = None
+        while not pid:
+            stderr = sim_launcher.stderr.readline()
+            if stderr == '':
+                continue
+            m = re.match(r"PID: (.*)", stderr)
+            self.assertIsNotNone(m)
+            pid = int(m.group(1))
+
+        # Launch debug monitor attaching to the simulated process
+        self.init_debugserver_test()
+        server = self.connect_to_debug_monitor(attach_pid=pid)
+
+        # Setup packet sequences
+        self.add_no_ack_remote_stream()
+        self.add_process_info_collection_packets()
+        self.test_sequence.add_log_lines(
+            ["read packet: " +
+             "$jGetLoadedDynamicLibrariesInfos:{\"fetch_all_solibs\" : true}]#ce",
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
+              "capture": {1: "dylib_info_raw"}}],
+            True)
+
+        # Run the stream
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather process info response
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+
+        # Check that ostype is correct
+        self.assertTrue(process_info['ostype'] in platform_names)
+
+        # Now for dylibs
+        dylib_info_raw = context.get("dylib_info_raw")
+        dylib_info = json.loads(self.decode_gdbremote_binary(dylib_info_raw))
+        images = dylib_info['images']
+
+        image_info = None
+        for image in images:
+            if image['pathname'] != exe_path:
+                continue
+            image_info = image
+            break
+
+        self.assertIsNotNone(image_info)
+        self.assertTrue(image['min_version_os_name'] in platform_names)
+
+
+    @apple_simulator_test('iphone')
+    @debugserver_test
+    def test_simulator_ostype_ios(self):
+        self.check_simulator_ostype(sdk='iphonesimulator',
+                                    platform_names=['iphoneos', 'ios'])
+
+    @apple_simulator_test('appletv')
+    @debugserver_test
+    def test_simulator_ostype_tvos(self):
+        self.check_simulator_ostype(sdk='appletvsimulator',
+                                    platform_names=['tvos'])
+
+    @apple_simulator_test('watch')
+    @debugserver_test
+    def test_simulator_ostype_watchos(self):
+        self.check_simulator_ostype(sdk='watchsimulator',
+                                    platform_names=['watchos'], arch='i386')

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

 static const char *const GET_CODE_ADDRESS_PREFIX = "get-code-address-hex:";
 static const char *const CALL_FUNCTION_PREFIX = "call-function:";
 
 static const char *const THREAD_PREFIX = "thread:";
 static const char *const THREAD_COMMAND_NEW = "new";
 static const char *const THREAD_COMMAND_PRINT_IDS = "print-ids";
 static const char *const THREAD_COMMAND_SEGFAULT = "segfault";
 
+static const char *const PRINT_PID_COMMAND = "print-pid";
+
 static bool g_print_thread_ids = false;
 static pthread_mutex_t g_print_mutex = PTHREAD_MUTEX_INITIALIZER;
 static bool g_threads_do_segfault = false;
 
 static pthread_mutex_t g_jump_buffer_mutex = PTHREAD_MUTEX_INITIALIZER;
 static jmp_buf g_jump_buffer;
 static bool g_is_segfaulting = false;
 
 static char g_message[256];
 
 static volatile char g_c1 = '0';
 static volatile char g_c2 = '1';
 
+static void print_pid() {
+  fprintf(stderr, "PID: %d\n", getpid());
+}
+
 static void print_thread_id() {
 // Put in the right magic here for your platform to spit out the thread id (tid)
 // that debugserver/lldb-gdbserver would see as a TID. Otherwise, let the else
 // clause print out the unsupported text so that the unit test knows to skip
 // verifying thread ids.
 #if defined(__APPLE__)
   __uint64_t tid = 0;
   pthread_threadid_np(pthread_self(), &tid);
if (std::strstr(argv[i], STDERR_PREFIX)) {
         pthread_mutex_unlock(&g_print_mutex);
       } else if (std::strstr(argv[i] + strlen(THREAD_PREFIX),
                              THREAD_COMMAND_SEGFAULT)) {
         g_threads_do_segfault = true;
       } else {
         // At this point we don't do anything else with threads.
         // Later use thread index and send command to thread.
       }
+    } else if (std::strstr(argv[i], PRINT_PID_COMMAND)) {
+        print_pid();
     } else {
       // Treat the argument as text for stdout.
       printf("%s\n", argv[i]);
     }
   }
 
   // If we launched any threads, join them
   for (std::vector<pthread_t>::iterator it = threads.begin();

lldb/trunk/tools/debugserver/source/DNB.h

nub_thread_t DNBProcessGetThreadAtIndex(nub_process_t pid,
                                         nub_size_t thread_idx) DNB_EXPORT;
 nub_bool_t DNBProcessSyncThreadState(nub_process_t pid,
                                      nub_thread_t tid) DNB_EXPORT;
 nub_addr_t DNBProcessGetSharedLibraryInfoAddress(nub_process_t pid) DNB_EXPORT;
 nub_bool_t DNBProcessSharedLibrariesUpdated(nub_process_t pid) DNB_EXPORT;
 nub_size_t
 DNBProcessGetSharedLibraryInfo(nub_process_t pid, nub_bool_t only_changed,
                                DNBExecutableImageInfo **image_infos) DNB_EXPORT;
+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);
 nub_bool_t DNBProcessSetNameToAddressCallback(nub_process_t pid,
                                               DNBCallbackNameToAddress callback,
                                               void *baton) DNB_EXPORT;
 nub_bool_t DNBProcessSetSharedLibraryInfoCallback(
     nub_process_t pid, DNBCallbackCopyExecutableImageInfos callback,
     void *baton) DNB_EXPORT;
 nub_addr_t DNBProcessLookupAddress(nub_process_t pid, const char *name,
                                    const char *shlib) DNB_EXPORT;

lldb/trunk/tools/debugserver/source/DNB.cpp

nub_bool_t DNBProcessSharedLibrariesUpdated(nub_process_t pid) {
   MachProcessSP procSP;
   if (GetProcessSP(pid, procSP)) {
     procSP->SharedLibrariesUpdated();
     return true;
   }
   return false;
 }
 
+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))
+    return procSP->GetDeploymentInfo(lc, load_command_address,
+                                     major_version, minor_version,
+                                     patch_version);
+  return nullptr;
+}
+
+
 //----------------------------------------------------------------------
 // Get the current shared library information for a process. Only return
 // the shared libraries that have changed since the last shared library
 // state changed event if only_changed is non-zero.
 //----------------------------------------------------------------------
 nub_size_t
 DNBProcessGetSharedLibraryInfo(nub_process_t pid, nub_bool_t only_changed,
                                struct DNBExecutableImageInfo **image_infos) {

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

ThreadInfo::QoS GetRequestedQoS(nub_thread_t tid, nub_addr_t tsd,
                                   uint64_t dti_qos_class_index);
   nub_addr_t GetPThreadT(nub_thread_t tid);
   nub_addr_t GetDispatchQueueT(nub_thread_t tid);
   nub_addr_t
   GetTSDAddressForThread(nub_thread_t tid,
                          uint64_t plo_pthread_tsd_base_address_offset,
                          uint64_t plo_pthread_tsd_base_offset,
                          uint64_t plo_pthread_tsd_entry_size);
-
+  const char *
+  GetDeploymentInfo(const struct load_command&, uint64_t load_command_address,
+                    uint32_t& major_version, uint32_t& minor_version,
+                    uint32_t& patch_version);
   bool GetMachOInformationFromMemory(nub_addr_t mach_o_header_addr,
                                      int wordsize,
                                      struct mach_o_information &inf);
   JSONGenerator::ObjectSP FormatDynamicLibrariesIntoJSON(
       const std::vector<struct binary_image_information> &image_infos);
   void GetAllLoadedBinariesViaDYLDSPI(
       std::vector<struct binary_image_information> &image_infos);
   JSONGenerator::ObjectSP GetLoadedDynamicLibrariesInfos(

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

 nub_addr_t MachProcess::GetTSDAddressForThread(
     nub_thread_t tid, uint64_t plo_pthread_tsd_base_address_offset,
     uint64_t plo_pthread_tsd_base_offset, uint64_t plo_pthread_tsd_entry_size) {
   return m_thread_list.GetTSDAddressForThread(
       tid, plo_pthread_tsd_base_address_offset, plo_pthread_tsd_base_offset,
       plo_pthread_tsd_entry_size);
 }
 
+
+const char *MachProcess::GetDeploymentInfo(const struct load_command& lc,
+                                           uint64_t load_command_address,
+                                           uint32_t& major_version,
+                                           uint32_t& minor_version,
+                                           uint32_t& patch_version) {
+  uint32_t cmd = lc.cmd & ~LC_REQ_DYLD;
+  bool lc_cmd_known =
+    cmd == LC_VERSION_MIN_IPHONEOS || cmd == LC_VERSION_MIN_MACOSX ||
+    cmd == LC_VERSION_MIN_TVOS || cmd == LC_VERSION_MIN_WATCHOS;
+
+  if (lc_cmd_known) {
+    struct version_min_command vers_cmd;
+    if (ReadMemory(load_command_address, sizeof(struct version_min_command),
+                   &vers_cmd) != sizeof(struct version_min_command)) {
+      return nullptr;
+    }
+    major_version = vers_cmd.sdk >> 16;
+    minor_version = (vers_cmd.sdk >> 8) & 0xffu;
+    patch_version = vers_cmd.sdk & 0xffu;
+
+    switch (cmd) {
+    case LC_VERSION_MIN_IPHONEOS:
+      return "iphoneos";
+    case LC_VERSION_MIN_MACOSX:
+      return "macosx";
+    case LC_VERSION_MIN_TVOS:
+      return "tvos";
+    case LC_VERSION_MIN_WATCHOS:
+      return "watchos";
+    default:
+      return nullptr;
+    }
+  }
+#if defined (LC_BUILD_VERSION)
+  if (cmd == LC_BUILD_VERSION) {
+    struct build_version_command build_vers;
+    if (ReadMemory(load_command_address, sizeof(struct build_version_command),
+                   &build_vers) != sizeof(struct build_version_command)) {
+      return nullptr;
+    }
+    major_version = build_vers.sdk >> 16;;
+    minor_version = (build_vers.sdk >> 8) & 0xffu;
+    patch_version = build_vers.sdk & 0xffu;
+
+    switch (build_vers.platform) {
+    case PLATFORM_MACOS:
+      return "macosx";
+    case PLATFORM_IOS:
+      return "iphoneos";
+    case PLATFORM_TVOS:
+      return "tvos";
+    case PLATFORM_WATCHOS:
+      return "watchos";
+    case PLATFORM_BRIDGEOS:
+      return "bridgeos";
+    }
+  }
+#endif
+  return nullptr;
+}
+
 // Given an address, read the mach-o header and load commands out of memory to
 // fill in
 // the mach_o_information "inf" object.
 //
 // Returns false if there was an error in reading this mach-o file header/load
 // commands.
 
 bool MachProcess::GetMachOInformationFromMemory(
if (lc.cmd == LC_SEGMENT_64) {
       inf.segments.push_back(this_seg);
     }
     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);
     }
-    bool lc_cmd_known =
-        lc.cmd == LC_VERSION_MIN_IPHONEOS || lc.cmd == LC_VERSION_MIN_MACOSX;
-#if defined(LC_VERSION_MIN_TVOS)
-    lc_cmd_known |= lc.cmd == LC_VERSION_MIN_TVOS;
-#endif
-#if defined(LC_VERSION_MIN_WATCHOS)
-    lc_cmd_known |= lc.cmd == LC_VERSION_MIN_WATCHOS;
-#endif
-    if (lc_cmd_known) {
-      struct version_min_command vers_cmd;
-      if (ReadMemory(load_cmds_p, sizeof(struct version_min_command),
-                     &vers_cmd) != sizeof(struct version_min_command)) {
-        return false;
-      }
-      switch (lc.cmd) {
-      case LC_VERSION_MIN_IPHONEOS:
-        inf.min_version_os_name = "iphoneos";
-        break;
-      case LC_VERSION_MIN_MACOSX:
-        inf.min_version_os_name = "macosx";
-        break;
-#if defined(LC_VERSION_MIN_TVOS)
-      case LC_VERSION_MIN_TVOS:
-        inf.min_version_os_name = "tvos";
-        break;
-#endif
-#if defined(LC_VERSION_MIN_WATCHOS)
-      case LC_VERSION_MIN_WATCHOS:
-        inf.min_version_os_name = "watchos";
-        break;
-#endif
-      default:
-        return false;
-      }
-      uint32_t xxxx = vers_cmd.sdk >> 16;
-      uint32_t yy = (vers_cmd.sdk >> 8) & 0xffu;
-      uint32_t zz = vers_cmd.sdk & 0xffu;
-      inf.min_version_os_version = "";
-      inf.min_version_os_version += std::to_string(xxxx);
-      inf.min_version_os_version += ".";
-      inf.min_version_os_version += std::to_string(yy);
-      if (zz != 0) {
-        inf.min_version_os_version += ".";
-        inf.min_version_os_version += std::to_string(zz);
-      }
-    }
-#if defined (LC_BUILD_VERSION)
-    if (lc.cmd == LC_BUILD_VERSION)
-    {
-        struct build_version_command build_vers;
-        if (ReadMemory(load_cmds_p, sizeof(struct build_version_command),
-                       &build_vers) != sizeof(struct build_version_command)) {
-          return false;
-        }
-        switch (build_vers.platform)
-        {
-            case PLATFORM_MACOS:
-                inf.min_version_os_name = "macosx";
-                break;
-            case PLATFORM_IOS:
-                inf.min_version_os_name = "iphoneos";
-                break;
-            case PLATFORM_TVOS:
-                inf.min_version_os_name = "tvos";
-                break;
-            case PLATFORM_WATCHOS:
-                inf.min_version_os_name = "watchos";
-                break;
-            case PLATFORM_BRIDGEOS:
-                inf.min_version_os_name = "bridgeos";
-                break;
-        }
-        uint32_t xxxx = build_vers.sdk >> 16;;
-        uint32_t yy = (build_vers.sdk >> 8) & 0xffu;
-        uint32_t zz = build_vers.sdk & 0xffu;
-        inf.min_version_os_version = "";
-        inf.min_version_os_version += std::to_string(xxxx);
-        inf.min_version_os_version += ".";
-        inf.min_version_os_version += std::to_string(yy);
-        if (zz != 0) {
-            inf.min_version_os_version += ".";
-            inf.min_version_os_version += std::to_string(zz);
-        }
+
+    uint32_t major_version, minor_version, patch_version;
+    if (const char *platform = GetDeploymentInfo(lc, load_cmds_p,
+                                                 major_version, minor_version,
+                                                 patch_version)) {
+      inf.min_version_os_name = platform;
+      inf.min_version_os_version += std::to_string(major_version);
+      inf.min_version_os_version += std::to_string(minor_version);
+      if (patch_version != 0) {
+        inf.min_version_os_version += std::to_string(patch_version);
     }
-#endif
+
     load_cmds_p += lc.cmdsize;
   }
   return true;
 }
 
 // Given completely filled in array of binary_image_information structures,
 // create a JSONGenerator object
 // with all the details we want to send to lldb.

lldb/trunk/tools/debugserver/source/RNBRemote.cpp

#if (defined(__x86_64__) || defined(__i386__))
     if (exe_mach_header_addr != INVALID_NUB_ADDRESS) {
       uint64_t load_command_addr =
           exe_mach_header_addr +
           ((addr_size == 8) ? sizeof(mach_header_64) : sizeof(mach_header));
       load_command lc;
       for (uint32_t i = 0; i < mh.ncmds && !os_handled; ++i) {
         const nub_size_t bytes_read =
             DNBProcessMemoryRead(pid, load_command_addr, sizeof(lc), &lc);
-        uint32_t raw_cmd = lc.cmd & ~LC_REQ_DYLD;
-        if (bytes_read != sizeof(lc))
-          break;
-        switch (raw_cmd) {
-        case LC_VERSION_MIN_IPHONEOS:
-          os_handled = true;
-          rep << "ostype:ios;";
-          DNBLogThreadedIf(LOG_RNB_PROC,
-                           "LC_VERSION_MIN_IPHONEOS -> 'ostype:ios;'");
-          break;
-
-        case LC_VERSION_MIN_MACOSX:
-          os_handled = true;
-          rep << "ostype:macosx;";
-          DNBLogThreadedIf(LOG_RNB_PROC,
-                           "LC_VERSION_MIN_MACOSX -> 'ostype:macosx;'");
-          break;
 
-#if defined(LC_VERSION_MIN_TVOS)
-        case LC_VERSION_MIN_TVOS:
+        uint32_t major_version, minor_version, patch_version;
+        auto *platform = DNBGetDeploymentInfo(pid, lc, load_command_addr,
+                                              major_version, minor_version,
+                                              patch_version);
+        if (platform) {
           os_handled = true;
-          rep << "ostype:tvos;";
-          DNBLogThreadedIf(LOG_RNB_PROC,
-                           "LC_VERSION_MIN_TVOS -> 'ostype:tvos;'");
-          break;
-#endif
-
-#if defined(LC_VERSION_MIN_WATCHOS)
-        case LC_VERSION_MIN_WATCHOS:
-          os_handled = true;
-          rep << "ostype:watchos;";
-          DNBLogThreadedIf(LOG_RNB_PROC,
-                           "LC_VERSION_MIN_WATCHOS -> 'ostype:watchos;'");
-          break;
-#endif
-
-        default:
+          rep << "ostype:" << platform << ";";
           break;
         }
         load_command_addr = load_command_addr + lc.cmdsize;
       }
-
-// Test that the PLATFORM_* defines are available from mach-o/loader.h
-#if defined (PLATFORM_MACOS)
-      for (uint32_t i = 0; i < mh.ncmds && !os_handled; ++i) 
-      {
-        nub_size_t bytes_read =
-            DNBProcessMemoryRead(pid, load_command_addr, sizeof(lc), &lc);
-        uint32_t raw_cmd = lc.cmd & ~LC_REQ_DYLD;
-        if (bytes_read != sizeof(lc))
-          break;
-
-        if (raw_cmd == LC_BUILD_VERSION)
-        {
-          uint32_t platform; // first field of 'struct build_version_command'
-          bytes_read = DNBProcessMemoryRead(pid, load_command_addr + 8, sizeof(platform), &platform);
-          if (bytes_read != sizeof (platform))
-              break;
-          switch (platform)
-          {
-              case PLATFORM_MACOS:
-                  os_handled = true;
-                  rep << "ostype:macosx;";
-                  DNBLogThreadedIf(LOG_RNB_PROC,
-                           "LC_BUILD_VERSION PLATFORM_MACOS -> 'ostype:macosx;'");
-                  break;
-              case PLATFORM_IOS:
-                  os_handled = true;
-                  rep << "ostype:ios;";
-                  DNBLogThreadedIf(LOG_RNB_PROC,
-                           "LC_BUILD_VERSION PLATFORM_IOS -> 'ostype:ios;'");
-                  break;
-              case PLATFORM_TVOS:
-                  os_handled = true;
-                  rep << "ostype:tvos;";
-                  DNBLogThreadedIf(LOG_RNB_PROC,
-                           "LC_BUILD_VERSION PLATFORM_TVOS -> 'ostype:tvos;'");
-                  break;
-              case PLATFORM_WATCHOS:
-                  os_handled = true;
-                  rep << "ostype:watchos;";
-                  DNBLogThreadedIf(LOG_RNB_PROC,
-                           "LC_BUILD_VERSION PLATFORM_WATCHOS -> 'ostype:watchos;'");
-                  break;
-              case PLATFORM_BRIDGEOS:
-                  os_handled = true;
-                  rep << "ostype:bridgeos;";
-                  DNBLogThreadedIf(LOG_RNB_PROC,
-                           "LC_BUILD_VERSION PLATFORM_BRIDGEOS -> 'ostype:bridgeos;'");
-                  break;
-          }
-    }
-      }
-#endif // PLATFORM_MACOS
     }
 #endif // when compiling this on x86 targets
   }
 
   // If we weren't able to find the OS in a LC_VERSION_MIN load command, try
   // to set it correctly by using the cpu type and other tricks
   if (!os_handled) {
     // The OS in the triple should be "ios" or "macosx" which doesn't match our