[lldb] Make LLDB resilient against failing dyld introspection APIs

[JDevlieghere]

Summary

Make LLDB resilient against failing dyld introspection APIs: dyld_process_create_for_current_task, dyld_process_snapshot_create_for_process and dyld_process_snapshot_get_shared_cache can all fail and return a nullptr. Instead of having an assert, which doesn't really make sense as we have no control over whether these calls succeed or not, bail out gracefully and use the fallback logic.

rdar://98070414

[aprantl]

Nice.

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

572

should this be auto *?

573

auto *dyld_process = dyld_process_create_for_current_task());
if (!dyld_process)
  return;

?

601

is this redundant?

[JDevlieghere]

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

573

We don't want to return, we want to fall through to the logic below the #endif. I guess I could pull it out into a helper function?

601

No, if this succeeds we're done here.

[JDevlieghere]

Reduce indentation with early returns in a helper function

[aprantl]

Thanks! Evidently I had trouble following the control flow in the earlier revision ;-)

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

 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/macosx/HostInfoMacOSX.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Timer.h"
 #include "Utility/UuidCompatibility.h"
 
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 // C++ Includes
 #include <string>
public:
   const UUID &GetUUID() const { return m_uuid; }
   const llvm::StringMap<SharedCacheImageInfo> &GetImages() const {
     return m_images;
   }
 
   SharedCacheInfo();
 
 private:
+  bool CreateSharedCacheInfoWithInstrospectionSPIs();
+
   llvm::StringMap<SharedCacheImageInfo> m_images;
   UUID m_uuid;
 };
 }
 
-SharedCacheInfo::SharedCacheInfo() {
+bool SharedCacheInfo::CreateSharedCacheInfoWithInstrospectionSPIs() {
 #if defined(SDK_HAS_NEW_DYLD_INTROSPECTION_SPIS)
   if (__builtin_available(macOS 12, *)) {
     if (dyld_process_create_for_current_task) {
-      auto dyld_process = dyld_process_create_for_current_task();
-      auto snapshot =
+      dyld_process_t dyld_process = dyld_process_create_for_current_task();
+      if (!dyld_process)
+        return false;
+
+      dyld_process_snapshot_t snapshot =
           dyld_process_snapshot_create_for_process(dyld_process, nullptr);
-      auto shared_cache = dyld_process_snapshot_get_shared_cache(snapshot);
-      assert(dyld_process && snapshot && shared_cache);
+      if (!snapshot)
+        return false;
+
+      auto on_exit = llvm::make_scope_exit(
+          [&]() { dyld_process_snapshot_dispose(snapshot); });
+
+      dyld_shared_cache_t shared_cache =
+          dyld_process_snapshot_get_shared_cache(snapshot);
+      if (!shared_cache)
+        return false;
 
       dyld_shared_cache_for_each_image(shared_cache, ^(dyld_image_t image) {
         __block uint64_t minVmAddr = UINT64_MAX;
         __block uint64_t maxVmAddr = 0;
         uuid_t uuidStore;
         __block uuid_t *uuid = &uuidStore;
 
         dyld_image_for_each_segment_info(image, ^(const char *segmentName,
                                                   uint64_t vmAddr,
                                                   uint64_t vmSize, int perm) {
           minVmAddr = std::min(minVmAddr, vmAddr);
           maxVmAddr = std::max(maxVmAddr, vmAddr + vmSize);
           dyld_image_copy_uuid(image, uuid);
         });
         assert(minVmAddr != UINT_MAX);
         assert(maxVmAddr != 0);
         m_images[dyld_image_get_installname(image)] = SharedCacheImageInfo{
             UUID::fromData(uuid, 16),
             std::make_shared<DataBufferUnowned>((uint8_t *)minVmAddr,
                                                 maxVmAddr - minVmAddr)};
       });
-      dyld_process_snapshot_dispose(snapshot);
-      return;
+      return true;
     }
   }
 #endif
+  return false;
+}
+
+SharedCacheInfo::SharedCacheInfo() {
+  if (CreateSharedCacheInfoWithInstrospectionSPIs())
+    return;
 
   size_t shared_cache_size;
   uint8_t *shared_cache_start =
       _dyld_get_shared_cache_range(&shared_cache_size);
   uuid_t dsc_uuid;
   _dyld_get_shared_cache_uuid(dsc_uuid);
   m_uuid = UUID::fromData(dsc_uuid);
 
   dyld_shared_cache_iterate_text(
       dsc_uuid, ^(const dyld_shared_cache_dylib_text_info *info) {
         m_images[info->path] = SharedCacheImageInfo{
             UUID::fromData(info->dylibUuid, 16),
             std::make_shared<DataBufferUnowned>(
                 shared_cache_start + info->textSegmentOffset,
                 shared_cache_size - info->textSegmentOffset)};
       });
 }
 
 SharedCacheImageInfo
 HostInfoMacOSX::GetSharedCacheImageInfo(llvm::StringRef image_name) {
   static SharedCacheInfo g_shared_cache_info;
   return g_shared_cache_info.GetImages().lookup(image_name);
 }