[lldb] Add IsSafeToCallAPI to DynamicLoader

[JDevlieghere]

Summary

On Darwin based systems, lldb will get notified by dyld before it itself finished initializing, at which point it's not safe to call certain APIs or SPIs. Add a method to the DynamicLoader to query that.

[aprantl]

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

1118

Out of curiosity: Is this an error when ReadAllImageInfosStructure() returns false? In that case a better API might be one that also bubbles up the error.

[JDevlieghere]

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

1118

It can fail if m_dyld_all_image_infos_addr is not known or if we fail to read memory. I guess the latter could be considered an error and something we might want to surface, but probably not from this API. If we don't know the answer to whether it's safe to do so is still no.

[aprantl]

lldb/include/lldb/Target/DynamicLoader.h

260

*Perhaps* IsFullyInitialized() ?

lldb/include/lldb/Target/DynamicLoader.h

 //===-- DynamicLoader.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_TARGET_DYNAMICLOADER_H
 #define LLDB_TARGET_DYNAMICLOADER_H
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-types.h"
 
virtual bool GetSharedCacheInformation(lldb::addr_t &base_address, UUID &uuid,
                                          LazyBool &private_shared_cache) {
     base_address = LLDB_INVALID_ADDRESS;
     uuid.Clear();
     using_shared_cache = eLazyBoolCalculate;
     private_shared_cache = eLazyBoolCalculate;
     return false;
   }
 
+  /// Return whether the dynamic loader is fully initialized and it's safe to
+  /// call its APIs.
+  ///
+  /// On some systems (e.g. Darwin based systems), lldb will get notified by
+  /// the dynamic loader before it itself finished initializing and it's not
+  /// safe to call certain APIs or SPIs.
+  virtual bool IsSafeToCallAPI() { return true; }
+
 protected:
   // Utility methods for derived classes
 
   /// Checks to see if the target module has changed, updates the target
   /// accordingly and returns the target executable module.
   lldb::ModuleSP GetTargetExecutable();
 
   /// Updates the load address of every allocatable section in \p module.
protected:
 
   // Read an unsigned int of the given size from memory at the given addr.
   // Return -1 if the read fails, otherwise return the result as an int64_t.
   int64_t ReadUnsignedIntWithSizeInBytes(lldb::addr_t addr, int size_in_bytes);
 
   // Read a pointer from memory at the given addr. Return LLDB_INVALID_ADDRESS
   // if the read fails.
   lldb::addr_t ReadPointer(lldb::addr_t addr);
-  
   // Calls into the Process protected method LoadOperatingSystemPlugin:
   void LoadOperatingSystemPlugin(bool flush);
 
 
   // Member variables.
   Process
       *m_process; ///< The process that this dynamic loader plug-in is tracking.
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_DYNAMICLOADER_H

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h

 // data structures.
 
 #ifndef LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERMACOSXDYLD_H
 #define LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERMACOSXDYLD_H
 
 #include <mutex>
 #include <vector>
 
 #include "lldb/Host/SafeMachO.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 
 #include "DynamicLoaderDarwin.h"
 
bool GetSharedCacheInformation(
       lldb_private::LazyBool &using_shared_cache,
       lldb_private::LazyBool &private_shared_cache) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
+  bool IsSafeToCallAPI() override;
+
 protected:
   void PutToLog(lldb_private::Log *log) const;
 
   void DoInitialImageFetch() override;
 
   bool NeedToDoInitialImageFetch() override;
 
   bool DidSetNotificationBreakpoint() override;

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

if (version_or_magic != static_cast<uint32_t>(-1) &&
       // after
       // sharedCacheUUID -- that is, 16 bytes after it, if we wanted to fetch
       // it.
     }
   }
   return false;
 }
 
+bool DynamicLoaderMacOSXDYLD::IsSafeToCallAPI() {
+  if (ReadAllImageInfosStructure())
+    return m_dyld_all_image_infos.libSystemInitialized;
+  return false;
+}
+
 void DynamicLoaderMacOSXDYLD::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance);
   DynamicLoaderMacOS::Initialize();
 }
 
 void DynamicLoaderMacOSXDYLD::Terminate() {
   DynamicLoaderMacOS::Terminate();