Delay calling ObjC class list read utility functions very early in process startup

[jasonmolenda]

Summary

When you are very early in process startup, before the system libraries have been initialized, and you run a simple expression, on Darwin systems, the Objective-C runtime plugin will run two utility functions to fetch the list of Objective-C class names in the inferior process. These function calls can cause problems when the process launch is this early, and the user expression may have been a simple one like "p globalvar=1" which would be harmless and not require a jitted expression.

This patch adds code to debugserver to use libdyld calls to find the process launch state, returns it in a JSON reply for a "jGetDyldProcessState" packet. This is passed up to DynamicLoaderMacOS::IsFullyInitialized() which checks for three specific process states that happen early in process startup, before system library initialization is completed.

Thread::SafeToCallFunctions() currently, on macOS, checks to see if the current thread is in __select, and does not run utility functions if it is. This patch updates SafeToCallFunctions() to also call DynamicLoader::IsFullyInitialized(), and avoid running utility functions if that is the case.

Then there are updates to AppleObjCRuntimeV2 to check the threads for SafeToCallFunctions() before scanning for dynamic objective-c classes, or the static shared cache objective-c classes.

I added a test case which stops process launch on the first malloc() call, runs a simple expression, and confirms (via the types log) that we did not read the objc class lists. Then it continues to main(), runs the simple expression again, and confirms (via types log) that it did read the objc class list.

The patch looks a bit big, mostly from piping the data from MachProcess::GetDyldProcessState() up to DynamicLoaderMacOS::IsFullyInitialized() through a handful of layers.

[JDevlieghere]

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

2519–2520

[begin bikeshedding]
Could we be more descriptive? Right now this sounds unactionable, which to be fair, it kind of is.

How about "could not execute support code to read Objective-C class data because it's not yet safe to do so and will be retried later.
[end bikeshedding]

Regardless we should say "class data" to match the other warnings or change those to say "class names".

[jasonmolenda]

Update patch to use Jonas' suggested wording of the warning we will issue when the objc class scanner functions cannot run yet, to make it clearer that they will run later and to match the style of the other warnings.

[JDevlieghere]

LGTM

lldb/tools/debugserver/source/RNBRemote.h

138–140

Nit, since you're touching this, why not align it with 'QStartNoAckMode'?

[jasonmolenda]

lldb/tools/debugserver/source/RNBRemote.h

138–140

clang-format decided to go on a little adventure here, when I added a line to this table. I didn't want to fight with it, so I just let it have its fun.

lldb/docs/lldb-gdb-remote.txt

 // PRIORITY TO IMPLEMENT
 //  Low. Only required if the target wants to keep the inferior process alive
 //  when the communication channel goes down.
 //----------------------------------------------------------------------
 
 The data in this packet is a single a character, which should be '0' if the
 inferior process should be killed, or '1' if the server should remove all
 breakpoints and detach from the inferior.
+
+//----------------------------------------------------------------------
+// "jGetDyldProcessState"
+//
+// BRIEF
+//  This packet fetches the process launch state, as reported by libdyld on
+//  Darwin systems, most importantly to indicate when the system libraries 
+//  have initialized sufficiently to safely call utility functions.
+//
+//
+//  LLDB SENDS: jGetDyldProcessState
+//  STUB REPLIES: {"process_state_value":48,"process_state string":"dyld_process_state_libSystem_initialized"}
+//
+// PRIORITY TO IMPLEMENT
+//  Low. This packet is needed to prevent lldb's utility functions for
+//  scanning the Objective-C class list from running very early in 
+//  process startup.
+//----------------------------------------------------------------------

lldb/include/lldb/Target/Process.h

/// \see Process::Notifications
   // On macOS 10.12, tvOS 10, iOS 10, watchOS 3 and newer, debugserver can
   // return information about the library shared cache (a set of standard
   // libraries that are loaded at the same location for all processes on a
   // system) in use.
   virtual lldb_private::StructuredData::ObjectSP GetSharedCacheInfo() {
     return StructuredData::ObjectSP();
   }
 
+  // Get information about the launch state of the process, if possible.
+  //
+  // On Darwin systems, libdyld can report on process state, most importantly
+  // the startup stages where the system library is not yet initialized.
+  virtual lldb_private::StructuredData::ObjectSP
+  GetDynamicLoaderProcessState() {
+    return {};
+  }
+
   /// Print a user-visible warning about a module being built with
   /// optimization
   ///
   /// Prints a async warning message to the user one time per Module where a
   /// function is found that was compiled with optimization, per Process.
   ///
   /// \param [in] sc
   ///     A SymbolContext with eSymbolContextFunction and eSymbolContextModule

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

protected:
   bool SetDYLDHandoverBreakpoint(lldb::addr_t notification_address);
 
   void ClearDYLDHandoverBreakpoint();
 
   void AddBinaries(const std::vector<lldb::addr_t> &load_addresses);
 
   void DoClear() override;
 
+  bool IsFullyInitialized() override;
+
   static bool
   NotifyBreakpointHit(void *baton,
                       lldb_private::StoppointCallbackContext *context,
                       lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
 
   bool SetNotificationBreakpoint() override;
 
   void ClearNotificationBreakpoint() override;
protected:
   lldb::user_id_t m_dyld_handover_break_id;
   mutable std::recursive_mutex m_mutex;
   lldb::addr_t m_maybe_image_infos_address; // If dyld is still maintaining the
                                             // all_image_infos address, store it
                                             // here so we can use it to detect
                                             // exec's when talking to
                                             // debugservers that don't support
                                             // the "reason:exec" annotation.
+  bool m_libsystem_fully_initalized;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERMACOS_H

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

DynamicLoader *DynamicLoaderMacOS::CreateInstance(Process *process,
   return nullptr;
 }
 
 // Constructor
 DynamicLoaderMacOS::DynamicLoaderMacOS(Process *process)
     : DynamicLoaderDarwin(process), m_image_infos_stop_id(UINT32_MAX),
       m_break_id(LLDB_INVALID_BREAK_ID),
       m_dyld_handover_break_id(LLDB_INVALID_BREAK_ID), m_mutex(),
-      m_maybe_image_infos_address(LLDB_INVALID_ADDRESS) {}
+      m_maybe_image_infos_address(LLDB_INVALID_ADDRESS),
+      m_libsystem_fully_initalized(false) {}
 
 // Destructor
 DynamicLoaderMacOS::~DynamicLoaderMacOS() {
   if (LLDB_BREAK_ID_IS_VALID(m_break_id))
     m_process->GetTarget().RemoveBreakpointByID(m_break_id);
   if (LLDB_BREAK_ID_IS_VALID(m_dyld_handover_break_id))
     m_process->GetTarget().RemoveBreakpointByID(m_dyld_handover_break_id);
 }
if (m_process->GetThreadList().GetSize() == 1) {
         }
       }
     }
   }
 
   if (did_exec) {
     m_libpthread_module_wp.reset();
     m_pthread_getspecific_addr.Clear();
+    m_libsystem_fully_initalized = false;
   }
   return did_exec;
 }
 
 // Clear out the state of this class.
 void DynamicLoaderMacOS::DoClear() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   if (LLDB_BREAK_ID_IS_VALID(m_break_id))
     m_process->GetTarget().RemoveBreakpointByID(m_break_id);
   if (LLDB_BREAK_ID_IS_VALID(m_dyld_handover_break_id))
     m_process->GetTarget().RemoveBreakpointByID(m_dyld_handover_break_id);
 
   m_break_id = LLDB_INVALID_BREAK_ID;
   m_dyld_handover_break_id = LLDB_INVALID_BREAK_ID;
+  m_libsystem_fully_initalized = false;
+}
+
+bool DynamicLoaderMacOS::IsFullyInitialized() {
+  if (m_libsystem_fully_initalized)
+    return true;
+
+  StructuredData::ObjectSP process_state_sp(
+      m_process->GetDynamicLoaderProcessState());
+  if (!process_state_sp)
+    return true;
+  if (process_state_sp->GetAsDictionary()->HasKey("error"))
+    return true;
+  if (!process_state_sp->GetAsDictionary()->HasKey("process_state string"))
+    return true;
+  std::string proc_state = process_state_sp->GetAsDictionary()
+                               ->GetValueForKey("process_state string")
+                               ->GetAsString()
+                               ->GetValue()
+                               .str();
+  if (proc_state == "dyld_process_state_not_started" ||
+      proc_state == "dyld_process_state_dyld_initialized" ||
+      proc_state == "dyld_process_state_terminated_before_inits") {
+    return false;
+  }
+  m_libsystem_fully_initalized = true;
+  return true;
 }
 
 // Check if we have found DYLD yet
 bool DynamicLoaderMacOS::DidSetNotificationBreakpoint() {
   return LLDB_BREAK_ID_IS_VALID(m_break_id);
 }
 
 void DynamicLoaderMacOS::ClearNotificationBreakpoint() {

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

protected:
 
     TaggedPointerVendorLegacy(const TaggedPointerVendorLegacy &) = delete;
     const TaggedPointerVendorLegacy &
     operator=(const TaggedPointerVendorLegacy &) = delete;
   };
 
   struct DescriptorMapUpdateResult {
     bool m_update_ran;
+    bool m_retry_update;
     uint32_t m_num_found;
 
-    DescriptorMapUpdateResult(bool ran, uint32_t found) {
+    DescriptorMapUpdateResult(bool ran, bool retry, uint32_t found) {
       m_update_ran = ran;
+
+      m_retry_update = retry;
+
       m_num_found = found;
     }
 
-    static DescriptorMapUpdateResult Fail() { return {false, 0}; }
+    static DescriptorMapUpdateResult Fail() { return {false, false, 0}; }
 
     static DescriptorMapUpdateResult Success(uint32_t found) {
-      return {true, found};
+      return {true, false, found};
     }
+
+    static DescriptorMapUpdateResult Retry() { return {false, true, 0}; }
   };
 
   /// Abstraction to read the Objective-C class info.
   class ClassInfoExtractor {
   public:
     ClassInfoExtractor(AppleObjCRuntimeV2 &runtime) : m_runtime(runtime) {}
     std::mutex &GetMutex() { return m_mutex; }
 
private:
   /// or destroyed. Unlike the count in gdb_objc_realized_classes, it will
   /// change when lazily named classes get realized.
   bool RealizedClassGenerationCountChanged();
 
   uint32_t ParseClassInfoArray(const lldb_private::DataExtractor &data,
                                uint32_t num_class_infos);
 
   enum class SharedCacheWarningReason {
+    eExpressionUnableToRun,
     eExpressionExecutionFailure,
     eNotEnoughClassesRead
   };
 
   void WarnIfNoClassesCached(SharedCacheWarningReason reason);
   void WarnIfNoExpandedSharedCache();
 
   lldb::addr_t GetSharedCacheReadOnlyAddress();

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

AppleObjCRuntimeV2::DynamicClassInfoExtractor::UpdateISAToDescriptorMap(
 
   ExecutionContext exe_ctx;
 
   ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread();
 
   if (!thread_sp)
     return DescriptorMapUpdateResult::Fail();
 
+  if (!thread_sp->SafeToCallFunctions())
+    return DescriptorMapUpdateResult::Retry();
+
   thread_sp->CalculateExecutionContext(exe_ctx);
   TypeSystemClang *ast =
       ScratchTypeSystemClang::GetForTarget(process->GetTarget());
 
   if (!ast)
     return DescriptorMapUpdateResult::Fail();
 
   Address function_address;
if (get_class_info_function->WriteFunctionArguments(
     }
   } else {
     if (log) {
       LLDB_LOGF(log, "Error writing function arguments.");
       diagnostics.Dump(log);
     }
   }
 
-  return DescriptorMapUpdateResult(success, num_class_infos);
+  return DescriptorMapUpdateResult(success, false, num_class_infos);
 }
 
 uint32_t AppleObjCRuntimeV2::ParseClassInfoArray(const DataExtractor &data,
                                                  uint32_t num_class_infos) {
   // Parses an array of "num_class_infos" packed ClassInfo structures:
   //
   //    struct ClassInfo
   //    {
AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::UpdateISAToDescriptorMap() {
 
   ExecutionContext exe_ctx;
 
   ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread();
 
   if (!thread_sp)
     return DescriptorMapUpdateResult::Fail();
 
+  if (!thread_sp->SafeToCallFunctions())
+    return DescriptorMapUpdateResult::Retry();
+
   thread_sp->CalculateExecutionContext(exe_ctx);
   TypeSystemClang *ast =
       ScratchTypeSystemClang::GetForTarget(process->GetTarget());
 
   if (!ast)
     return DescriptorMapUpdateResult::Fail();
 
   Address function_address;
if (log) {
       LLDB_LOGF(log, "Error writing function arguments.");
       diagnostics.Dump(log);
     }
   }
 
   // Deallocate the memory we allocated for the ClassInfo array
   process->DeallocateMemory(class_infos_addr);
 
-  return DescriptorMapUpdateResult(success, num_class_infos);
+  return DescriptorMapUpdateResult(success, false, num_class_infos);
 }
 
 lldb::addr_t AppleObjCRuntimeV2::GetSharedCacheReadOnlyAddress() {
   Process *process = GetProcess();
 
   if (process) {
     ModuleSP objc_module_sp(GetObjCModule());
 
if (!m_loaded_objc_opt) {
       // (Foundation alone has thousands of classes)
       const uint32_t num_classes_to_warn_at = 500;
 
       DescriptorMapUpdateResult shared_cache_update_result =
           m_shared_cache_class_info_extractor.UpdateISAToDescriptorMap();
 
       LLDB_LOGF(log,
                 "attempted to read objc class data - results: "
-                "[dynamic_update]: ran: %s, count: %" PRIu32
-                " [shared_cache_update]: ran: %s, count: %" PRIu32,
+                "[dynamic_update]: ran: %s, retry: %s, count: %" PRIu32
+                " [shared_cache_update]: ran: %s, retry: %s, count: %" PRIu32,
                 dynamic_update_result.m_update_ran ? "yes" : "no",
+                dynamic_update_result.m_retry_update ? "yes" : "no",
                 dynamic_update_result.m_num_found,
                 shared_cache_update_result.m_update_ran ? "yes" : "no",
+                shared_cache_update_result.m_retry_update ? "yes" : "no",
                 shared_cache_update_result.m_num_found);
 
       // warn if:
       // - we could not run either expression
       // - we found fewer than num_classes_to_warn_at classes total
-      if ((!shared_cache_update_result.m_update_ran) ||
+      if (dynamic_update_result.m_retry_update ||
+          shared_cache_update_result.m_retry_update)
+        WarnIfNoClassesCached(SharedCacheWarningReason::eExpressionUnableToRun);
+      else if ((!shared_cache_update_result.m_update_ran) ||
                (!dynamic_update_result.m_update_ran))
         WarnIfNoClassesCached(
             SharedCacheWarningReason::eExpressionExecutionFailure);
       else if (dynamic_update_result.m_num_found +
                    shared_cache_update_result.m_num_found <
                num_classes_to_warn_at)
         WarnIfNoClassesCached(SharedCacheWarningReason::eNotEnoughClassesRead);
       else
         m_loaded_objc_opt = true;
case SharedCacheWarningReason::eNotEnoughClassesRead:
     break;
   case SharedCacheWarningReason::eExpressionExecutionFailure:
     Debugger::ReportWarning(
         "could not execute support code to read "
         "Objective-C class data in the process. This may "
         "reduce the quality of type information available.\n",
         debugger.GetID(), &m_no_classes_cached_warning);
     break;
+  case SharedCacheWarningReason::eExpressionUnableToRun:
+    Debugger::ReportWarning(
+        "could not execute support code to read Objective-C class data because "
+        "it's not yet safe to do so, and will be retried later.\n",
+        debugger.GetID(), nullptr);
+    break;
   }
 }
 
 void AppleObjCRuntimeV2::WarnIfNoExpandedSharedCache() {
   if (!m_objc_module_sp)
     return;
 
   ObjectFile *object_file = m_objc_module_sp->GetObjectFile();

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

public:
   StructuredData::ObjectSP GetThreadsInfo();
 
   bool GetThreadExtendedInfoSupported();
 
   bool GetLoadedDynamicLibrariesInfosSupported();
 
   bool GetSharedCacheInfoSupported();
 
+  bool GetDynamicLoaderProcessStateSupported();
+
   bool GetMemoryTaggingSupported();
 
   bool UsesNativeSignals();
 
   lldb::DataBufferSP ReadMemoryTags(lldb::addr_t addr, size_t len,
                                     int32_t type);
 
   Status WriteMemoryTags(lldb::addr_t addr, size_t len, int32_t type,
protected:
   LazyBool m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
   LazyBool m_supports_qXfer_features_read = eLazyBoolCalculate;
   LazyBool m_supports_qXfer_memory_map_read = eLazyBoolCalculate;
   LazyBool m_supports_qXfer_siginfo_read = eLazyBoolCalculate;
   LazyBool m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
   LazyBool m_supports_jThreadExtendedInfo = eLazyBoolCalculate;
   LazyBool m_supports_jLoadedDynamicLibrariesInfos = eLazyBoolCalculate;
   LazyBool m_supports_jGetSharedCacheInfo = eLazyBoolCalculate;
+  LazyBool m_supports_jGetDyldProcessState = eLazyBoolCalculate;
   LazyBool m_supports_QPassSignals = eLazyBoolCalculate;
   LazyBool m_supports_error_string_reply = eLazyBoolCalculate;
   LazyBool m_supports_multiprocess = eLazyBoolCalculate;
   LazyBool m_supports_memory_tagging = eLazyBoolCalculate;
   LazyBool m_supports_qSaveCore = eLazyBoolCalculate;
   LazyBool m_uses_native_signals = eLazyBoolCalculate;
 
   bool m_supports_qProcessInfoPID : 1, m_supports_qfProcessInfo : 1,

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

if (SendPacketAndWaitForResponse("jGetSharedCacheInfo:", response) ==
       if (response.IsOKResponse()) {
         m_supports_jGetSharedCacheInfo = eLazyBoolYes;
       }
     }
   }
   return m_supports_jGetSharedCacheInfo;
 }
 
+bool GDBRemoteCommunicationClient::GetDynamicLoaderProcessStateSupported() {
+  if (m_supports_jGetDyldProcessState == eLazyBoolCalculate) {
+    StringExtractorGDBRemote response;
+    m_supports_jGetDyldProcessState = eLazyBoolNo;
+    if (SendPacketAndWaitForResponse("jGetDyldProcessState", response) ==
+        PacketResult::Success) {
+      if (!response.IsUnsupportedResponse())
+        m_supports_jGetDyldProcessState = eLazyBoolYes;
+    }
+  }
+  return m_supports_jGetDyldProcessState;
+}
+
 bool GDBRemoteCommunicationClient::GetMemoryTaggingSupported() {
   if (m_supports_memory_tagging == eLazyBoolCalculate) {
     GetRemoteQSupported();
   }
   return m_supports_memory_tagging == eLazyBoolYes;
 }
 
 DataBufferSP GDBRemoteCommunicationClient::ReadMemoryTags(lldb::addr_t addr,

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

public:
   StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos(
       const std::vector<lldb::addr_t> &load_addresses) override;
 
   StructuredData::ObjectSP
   GetLoadedDynamicLibrariesInfos_sender(StructuredData::ObjectSP args);
 
   StructuredData::ObjectSP GetSharedCacheInfo() override;
 
+  StructuredData::ObjectSP GetDynamicLoaderProcessState() override;
+
   std::string HarmonizeThreadIdsForProfileData(
       StringExtractorGDBRemote &inputStringExtractor);
 
   void DidFork(lldb::pid_t child_pid, lldb::tid_t child_tid) override;
   void DidVFork(lldb::pid_t child_pid, lldb::tid_t child_tid) override;
   void DidVForkDone() override;
   void DidExec() override;
 

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response) ==
               StructuredData::ParseJSON(std::string(response.GetStringRef()));
         }
       }
     }
   }
   return object_sp;
 }
 
+StructuredData::ObjectSP ProcessGDBRemote::GetDynamicLoaderProcessState() {
+  StructuredData::ObjectSP object_sp;
+  StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
+
+  if (m_gdb_comm.GetDynamicLoaderProcessStateSupported()) {
+    StringExtractorGDBRemote response;
+    response.SetResponseValidatorToJSON();
+    if (m_gdb_comm.SendPacketAndWaitForResponse("jGetDyldProcessState",
+                                                response) ==
+        GDBRemoteCommunication::PacketResult::Success) {
+      StringExtractorGDBRemote::ResponseType response_type =
+          response.GetResponseType();
+      if (response_type == StringExtractorGDBRemote::eResponse) {
+        if (!response.Empty()) {
+          object_sp =
+              StructuredData::ParseJSON(std::string(response.GetStringRef()));
+        }
+      }
+    }
+  }
+  return object_sp;
+}
+
 StructuredData::ObjectSP ProcessGDBRemote::GetSharedCacheInfo() {
   StructuredData::ObjectSP object_sp;
   StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
 
   if (m_gdb_comm.GetSharedCacheInfoSupported()) {
     StreamString packet;
     packet << "jGetSharedCacheInfo:";
     args_dict->Dump(packet, false);

lldb/source/Target/Thread.cpp

return loader->GetThreadLocalData(module, shared_from_this(),
                                       tls_file_addr);
   else
     return LLDB_INVALID_ADDRESS;
 }
 
 bool Thread::SafeToCallFunctions() {
   Process *process = GetProcess().get();
   if (process) {
+    DynamicLoader *loader = GetProcess()->GetDynamicLoader();
+    if (loader && loader->IsFullyInitialized() == false)
+      return false;
+
     SystemRuntime *runtime = process->GetSystemRuntime();
     if (runtime) {
       return runtime->SafeToCallFunctionsOnThisThread(shared_from_this());
     }
   }
   return true;
 }
 

lldb/test/API/macosx/early-process-launch/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/macosx/early-process-launch/TestEarlyProcessLaunch.py

+"""Test that we don't read objc class tables early in process startup."""
+
+
+import time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestEarlyProcessLaunch(TestBase):
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @skipUnlessDarwin
+    @add_test_categories(['pyapi'])
+    def test_early_process_launch(self):
+        """Test that we don't read objc class tables early in proc startup"""
+        self.build()
+
+        ###
+        ### Hit a breakpoint on the first malloc() call, which 
+        ### is before libSystem has finished initializing.  At
+        ### this point, we should not read the objc class tables.
+        ### Then continue to main(), which is past libSystem 
+        ### initializing.  Try again, and they should be read.
+        ### 
+        ### Use the types logging to detect the difference.
+
+        target, process, _, bkpt = lldbutil.run_to_name_breakpoint(
+            self, 'malloc')
+
+        target.DisableAllBreakpoints()
+        target.BreakpointCreateByName("main")
+
+        logfile_early = os.path.join(self.getBuildDir(), "types-log-early.txt")
+        self.addTearDownHook(lambda: self.runCmd("log disable lldb types"))
+        self.runCmd("log enable -f %s lldb types" % logfile_early)
+        self.runCmd("p global = 15")
+
+        err = process.Continue()
+        self.assertTrue(err.Success())
+
+        logfile_later = os.path.join(self.getBuildDir(), "types-log-later.txt")
+        self.runCmd("log enable -f %s lldb types" % logfile_later)
+        self.runCmd("p global = 25")
+
+        self.assertTrue(os.path.exists(logfile_early))
+        self.assertTrue(os.path.exists(logfile_later))
+        early_text = open(logfile_early).read()
+        later_text = open(logfile_later).read()
+
+        self.assertIn("ran: no, retry: yes", early_text)
+        self.assertNotIn("ran: no, retry: yes", later_text)
+
+        self.assertNotIn("ran: yes, retry: no", early_text)
+        self.assertIn("ran: yes, retry: no", later_text)

lldb/test/API/macosx/early-process-launch/main.c

+int global = 10;
+int main() { return global; }

lldb/tools/debugserver/source/DNB.h

nub_size_t DNBProcessGetAvailableSTDOUT(nub_process_t pid, char *buf,
                                         nub_size_t buf_size) DNB_EXPORT;
 nub_size_t DNBProcessGetAvailableSTDERR(nub_process_t pid, char *buf,
                                         nub_size_t buf_size) DNB_EXPORT;
 nub_size_t DNBProcessGetAvailableProfileData(nub_process_t pid, char *buf,
                                              nub_size_t buf_size) DNB_EXPORT;
 nub_size_t DNBProcessGetStopCount(nub_process_t pid) DNB_EXPORT;
 uint32_t DNBProcessGetCPUType(nub_process_t pid) DNB_EXPORT;
 size_t DNBGetAllInfos(std::vector<struct kinfo_proc> &proc_infos);
+JSONGenerator::ObjectSP DNBGetDyldProcessState(nub_process_t pid);
 
 // Process executable and arguments
 const char *DNBProcessGetExecutablePath(nub_process_t pid);
 const char *DNBProcessGetArgumentAtIndex(nub_process_t pid, nub_size_t idx);
 nub_size_t DNBProcessGetArgumentCount(nub_process_t pid);
 
 // Process events
 nub_event_t DNBProcessWaitForEvents(nub_process_t pid, nub_event_t event_mask,

lldb/tools/debugserver/source/DNB.cpp

if (err < 0) {
     return 0;
   }
 
   // Trim down our array to fit what we actually got back
   proc_infos.resize(size / sizeof(struct kinfo_proc));
   return proc_infos.size();
 }
 
+JSONGenerator::ObjectSP DNBGetDyldProcessState(nub_process_t pid) {
+  MachProcessSP procSP;
+  if (GetProcessSP(pid, procSP)) {
+    return procSP->GetDyldProcessState();
+  }
+  return {};
+}
+
 static size_t
 GetAllInfosMatchingName(const char *full_process_name,
                         std::vector<struct kinfo_proc> &matching_proc_infos) {
 
   matching_proc_infos.clear();
   if (full_process_name && full_process_name[0]) {
     // We only get the process name, not the full path, from the proc_info.  So
     // just take the

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

#endif // WITH_SPRINGBOARD
 
   Genealogy::ThreadActivitySP GetGenealogyInfoForThread(nub_thread_t tid,
                                                         bool &timed_out);
 
   Genealogy::ProcessExecutableInfoSP GetGenealogyImageInfo(size_t idx);
 
   DNBProfileDataScanType GetProfileScanType() { return m_profile_scan_type; }
 
+  JSONGenerator::ObjectSP GetDyldProcessState();
+
 private:
   enum {
     eMachProcessFlagsNone = 0,
     eMachProcessFlagsAttached = (1 << 0),
     eMachProcessFlagsUsingBKS = (1 << 2), // only read via ProcessUsingBackBoard()
     eMachProcessFlagsUsingFBS = (1 << 3), // only read via ProcessUsingFrontBoard()
     eMachProcessFlagsBoardCalculated = (1 << 4)
   };
private:
   void *(*m_dyld_process_info_create)(task_t task, uint64_t timestamp,
                                       kern_return_t *kernelError);
   void (*m_dyld_process_info_for_each_image)(
       void *info, void (^callback)(uint64_t machHeaderAddress,
                                    const uuid_t uuid, const char *path));
   void (*m_dyld_process_info_release)(void *info);
   void (*m_dyld_process_info_get_cache)(void *info, void *cacheInfo);
   uint32_t (*m_dyld_process_info_get_platform)(void *info);
+  void (*m_dyld_process_info_get_state)(void *info, void *stateInfo);
 };
 
 #endif // LLDB_TOOLS_DEBUGSERVER_SOURCE_MACOSX_MACHPROCESS_H

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

 #ifndef MACH_PROCESS_USE_POSIX_SPAWN
 #define MACH_PROCESS_USE_POSIX_SPAWN 1
 #endif
 
 #ifndef _POSIX_SPAWN_DISABLE_ASLR
 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
 #endif
 
-
 MachProcess::MachProcess()
     : m_pid(0), m_cpu_type(0), m_child_stdin(-1), m_child_stdout(-1),
       m_child_stderr(-1), m_path(), m_args(), m_task(this),
       m_flags(eMachProcessFlagsNone), m_stdio_thread(0),
       m_stdio_mutex(PTHREAD_MUTEX_RECURSIVE), m_stdout_data(),
       m_profile_enabled(false), m_profile_interval_usec(0), m_profile_thread(0),
       m_profile_data_mutex(PTHREAD_MUTEX_RECURSIVE), m_profile_data(),
-      m_profile_events(0, eMachProcessProfileCancel),
-      m_thread_actions(), m_exception_messages(),
+      m_profile_events(0, eMachProcessProfileCancel), m_thread_actions(),
+      m_exception_messages(),
       m_exception_messages_mutex(PTHREAD_MUTEX_RECURSIVE), m_thread_list(),
       m_activities(), m_state(eStateUnloaded),
       m_state_mutex(PTHREAD_MUTEX_RECURSIVE), m_events(0, kAllEventsMask),
       m_private_events(0, kAllEventsMask), m_breakpoints(), m_watchpoints(),
       m_name_to_addr_callback(NULL), m_name_to_addr_baton(NULL),
       m_image_infos_callback(NULL), m_image_infos_baton(NULL),
       m_sent_interrupt_signo(0), m_auto_resume_signo(0), m_did_exec(false),
       m_dyld_process_info_create(nullptr),
       m_dyld_process_info_for_each_image(nullptr),
       m_dyld_process_info_release(nullptr),
-      m_dyld_process_info_get_cache(nullptr) {
+      m_dyld_process_info_get_cache(nullptr),
+      m_dyld_process_info_get_state(nullptr) {
   m_dyld_process_info_create =
       (void *(*)(task_t task, uint64_t timestamp, kern_return_t * kernelError))
           dlsym(RTLD_DEFAULT, "_dyld_process_info_create");
   m_dyld_process_info_for_each_image =
       (void (*)(void *info, void (^)(uint64_t machHeaderAddress,
                                      const uuid_t uuid, const char *path)))
           dlsym(RTLD_DEFAULT, "_dyld_process_info_for_each_image");
   m_dyld_process_info_release =
       (void (*)(void *info))dlsym(RTLD_DEFAULT, "_dyld_process_info_release");
   m_dyld_process_info_get_cache = (void (*)(void *info, void *cacheInfo))dlsym(
       RTLD_DEFAULT, "_dyld_process_info_get_cache");
   m_dyld_process_info_get_platform = (uint32_t (*)(void *info))dlsym(
       RTLD_DEFAULT, "_dyld_process_info_get_platform");
+  m_dyld_process_info_get_state = (void (*)(void *info, void *stateInfo))dlsym(
+      RTLD_DEFAULT, "_dyld_process_info_get_state");
 
   DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__);
 }
 
 MachProcess::~MachProcess() {
   DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__);
   Clear();
 }
size_t MachProcess::GetAvailableSTDOUT(char *buf, size_t buf_size) {
   return bytes_available;
 }
 
 nub_addr_t MachProcess::GetDYLDAllImageInfosAddress() {
   DNBError err;
   return m_task.GetDYLDAllImageInfosAddress(err);
 }
 
+/// From dyld SPI header dyld_process_info.h
+struct dyld_process_state_info {
+  uint64_t timestamp;
+  uint32_t imageCount;
+  uint32_t initialImageCount;
+  // one of dyld_process_state_* values
+  uint8_t dyldState;
+};
+enum {
+  dyld_process_state_not_started = 0x00,
+  dyld_process_state_dyld_initialized = 0x10,
+  dyld_process_state_terminated_before_inits = 0x20,
+  dyld_process_state_libSystem_initialized = 0x30,
+  dyld_process_state_running_initializers = 0x40,
+  dyld_process_state_program_running = 0x50,
+  dyld_process_state_dyld_terminated = 0x60
+};
+
+JSONGenerator::ObjectSP MachProcess::GetDyldProcessState() {
+  JSONGenerator::DictionarySP reply_sp(new JSONGenerator::Dictionary());
+  if (!m_dyld_process_info_get_state) {
+    reply_sp->AddStringItem("error",
+                            "_dyld_process_info_get_state unavailable");
+    return reply_sp;
+  }
+  if (!m_dyld_process_info_create) {
+    reply_sp->AddStringItem("error", "_dyld_process_info_create unavailable");
+    return reply_sp;
+  }
+
+  kern_return_t kern_ret;
+  dyld_process_info info =
+      m_dyld_process_info_create(m_task.TaskPort(), 0, &kern_ret);
+  if (!info || kern_ret != KERN_SUCCESS) {
+    reply_sp->AddStringItem(
+        "error", "Unable to create dyld_process_info for inferior task");
+    return reply_sp;
+  }
+
+  struct dyld_process_state_info state_info;
+  m_dyld_process_info_get_state(info, &state_info);
+  reply_sp->AddIntegerItem("process_state_value", state_info.dyldState);
+  switch (state_info.dyldState) {
+  case dyld_process_state_not_started:
+    reply_sp->AddStringItem("process_state string",
+                            "dyld_process_state_not_started");
+    break;
+  case dyld_process_state_dyld_initialized:
+    reply_sp->AddStringItem("process_state string",
+                            "dyld_process_state_dyld_initialized");
+    break;
+  case dyld_process_state_terminated_before_inits:
+    reply_sp->AddStringItem("process_state string",
+                            "dyld_process_state_terminated_before_inits");
+    break;
+  case dyld_process_state_libSystem_initialized:
+    reply_sp->AddStringItem("process_state string",
+                            "dyld_process_state_libSystem_initialized");
+    break;
+  case dyld_process_state_running_initializers:
+    reply_sp->AddStringItem("process_state string",
+                            "dyld_process_state_running_initializers");
+    break;
+  case dyld_process_state_program_running:
+    reply_sp->AddStringItem("process_state string",
+                            "dyld_process_state_program_running");
+    break;
+  case dyld_process_state_dyld_terminated:
+    reply_sp->AddStringItem("process_state string",
+                            "dyld_process_state_dyld_terminated");
+    break;
+  };
+
+  m_dyld_process_info_release(info);
+
+  return reply_sp;
+}
+
 size_t MachProcess::GetAvailableSTDERR(char *buf, size_t buf_size) { return 0; }
 
 void *MachProcess::STDIOThread(void *arg) {
   MachProcess *proc = (MachProcess *)arg;
   DNBLogThreadedIf(LOG_PROCESS,
                    "MachProcess::%s ( arg = %p ) thread starting...",
                    __FUNCTION__, arg);
 

lldb/tools/debugserver/source/RNBRemote.h

enum PacketEnum {
     watchpoint_support_info,            // 'qWatchpointSupportInfo:'
     allocate_memory,                    // '_M'
     deallocate_memory,                  // '_m'
     set_process_event,                  // 'QSetProcessEvent:'
     save_register_state,                // '_g'
     restore_register_state,             // '_G'
     speed_test,                         // 'qSpeedTest:'
     set_detach_on_error,                // 'QSetDetachOnError:'
     query_transfer,                     // 'qXfer:'
+    json_query_dyld_process_state,      // 'jGetDyldProcessState'
     unknown_type
   };
 
   typedef rnb_err_t (RNBRemote::*HandlePacketCallback)(const char *p);
 
   RNBRemote();
   ~RNBRemote();
 
   void Initialize();
public:
   rnb_err_t HandlePacket_GetProfileData(const char *p);
   rnb_err_t HandlePacket_SetEnableAsyncProfiling(const char *p);
   rnb_err_t HandlePacket_QEnableCompression(const char *p);
   rnb_err_t HandlePacket_WatchpointSupportInfo(const char *p);
   rnb_err_t HandlePacket_qSpeedTest(const char *p);
   rnb_err_t HandlePacket_qXfer(const char *p);
   rnb_err_t HandlePacket_stop_process(const char *p);
   rnb_err_t HandlePacket_QSetDetachOnError(const char *p);
+  rnb_err_t HandlePacket_jGetDyldProcessState(const char *p);
   rnb_err_t SendStopReplyPacketForThread(nub_thread_t tid);
   rnb_err_t SendHexEncodedBytePacket(const char *header, const void *buf,
                                      size_t buf_len, const char *footer);
   rnb_err_t SendSTDOUTPacket(char *buf, nub_size_t buf_size);
   rnb_err_t SendSTDERRPacket(char *buf, nub_size_t buf_size);
   void FlushSTDIO();
   void SendAsyncProfileData();
   rnb_err_t SendAsyncProfileDataPacket(char *buf, nub_size_t buf_size);

lldb/tools/debugserver/source/RNBRemote.cpp

t.push_back(
              NULL, "QSetDetachOnError:",
              "Set whether debugserver will detach (1) or kill (0) from the "
              "process it is controlling if it loses connection to lldb."));
   t.push_back(Packet(
       speed_test, &RNBRemote::HandlePacket_qSpeedTest, NULL, "qSpeedTest:",
       "Test the maximum speed at which packet can be sent/received."));
   t.push_back(Packet(query_transfer, &RNBRemote::HandlePacket_qXfer, NULL,
                      "qXfer:", "Support the qXfer packet."));
+  t.push_back(Packet(json_query_dyld_process_state,
+                     &RNBRemote::HandlePacket_jGetDyldProcessState, NULL,
+                     "jGetDyldProcessState",
+                     "Query the process state from dyld."));
 }
 
 void RNBRemote::FlushSTDIO() {
   if (m_ctx.HasValidProcessID()) {
     nub_process_t pid = m_ctx.ProcessID();
     char buf[256];
     nub_size_t count;
     do {

 #else
   strm << "name:debugserver;";
 #endif
   strm << "version:" << DEBUGSERVER_VERSION_NUM << ";";
 
   return SendPacket(strm.str());
 }
 
+rnb_err_t RNBRemote::HandlePacket_jGetDyldProcessState(const char *p) {
+  const nub_process_t pid = m_ctx.ProcessID();
+  if (pid == INVALID_NUB_PROCESS)
+    return SendPacket("E87");
+
+  JSONGenerator::ObjectSP dyld_state_sp = DNBGetDyldProcessState(pid);
+  if (dyld_state_sp) {
+    std::ostringstream strm;
+    dyld_state_sp->DumpBinaryEscaped(strm);
+    dyld_state_sp->Clear();
+    if (strm.str().size() > 0)
+      return SendPacket(strm.str());
+  }
+  return SendPacket("E88");
+}
+
 // A helper function that retrieves a single integer value from
 // a one-level-deep JSON dictionary of key-value pairs.  e.g.
 // jThreadExtendedInfo:{"plo_pthread_tsd_base_address_offset":0,"plo_pthread_tsd_base_offset":224,"plo_pthread_tsd_entry_size":8,"thread":144305}]
 //
 uint64_t get_integer_value_for_key_name_from_json(const char *key,
                                                   const char *json_string) {
   uint64_t retval = INVALID_NUB_ADDRESS;
   std::string key_with_quotes = "\"";