Unify random timeouts throughout LLDB and make them configurable.

[aprantl]

Summary

Since these timeouts guard against catastrophic error in debugserver, I also increased all of them to the maximum value among them.

The motivation for this test was the observation that an asanified LLDB would often exhibit seemingly random test failures that could be traced back to debugserver packets getting out of sync. With this path applied I can no longer reproduce the one particular failure mode that I was investigating.

rdar://problem/49441261

[aprantl]

I should also note that I did check that process was either checked or dereferenced above the the locations where this patch dereferences it.

[aprantl]

Tweaked the name of the option after some off-line discussion with Jim.

[jingham]

LGTM

[clayborg]

The motivation for this test was the observation that an asanified LLDB would often exhibit seemingly random test failures that could be traced back to debugserver packets getting out of sync. With this path applied I can no longer reproduce the one particular failure mode that I was investigating.

I hate that GDB remote packets can get out of sync. We should really think about adding sequence IDs to the GDB remote packets and responses and teach our GDB communication code to correctly deal with these. So many weird problems happen when things get out of sync.

lldb/include/lldb/Target/Process.h

 public:
   // Pass nullptr for "process" if the ProcessProperties are to be the global
   // copy
   ProcessProperties(lldb_private::Process *process);
 
   ~ProcessProperties() override;
 
   bool GetDisableMemoryCache() const;
-
   uint64_t GetMemoryCacheLineSize() const;
-
   Args GetExtraStartupCommands() const;
-
   void SetExtraStartupCommands(const Args &args);
-
   FileSpec GetPythonOSPluginPath() const;
-
   void SetPythonOSPluginPath(const FileSpec &file);
-
   bool GetIgnoreBreakpointsInExpressions() const;
-
   void SetIgnoreBreakpointsInExpressions(bool ignore);
-
   bool GetUnwindOnErrorInExpressions() const;
-
   void SetUnwindOnErrorInExpressions(bool ignore);
-
   bool GetStopOnSharedLibraryEvents() const;
-
   void SetStopOnSharedLibraryEvents(bool stop);
-
   bool GetDetachKeepsStopped() const;
-
   void SetDetachKeepsStopped(bool keep_stopped);
-
   bool GetWarningsOptimization() const;
-
   bool GetStopOnExec() const;
+  std::chrono::seconds GetUtilityExpressionTimeout() const;
 
 protected:
   static void OptionValueChangedCallback(void *baton,
                                          OptionValue *option_value);
 
   Process *m_process; // Can be nullptr for global ProcessProperties
 };
 

lldb/source/Plugins/InstrumentationRuntime/ASan/ASanRuntime.cpp

 bool AddressSanitizerRuntime::CheckIfRuntimeIsValid(
     const lldb::ModuleSP module_sp) {
   const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
       ConstString("__asan_get_alloc_stack"), lldb::eSymbolTypeAny);
 
   return symbol != nullptr;
 }
 
-static constexpr std::chrono::seconds g_retrieve_report_data_function_timeout(2);
 const char *address_sanitizer_retrieve_report_data_prefix = R"(
 extern "C"
 {
 int __asan_report_present();
 void *__asan_get_report_pc();
 void *__asan_get_report_bp();
 void *__asan_get_report_sp();
 void *__asan_get_report_address();
StructuredData::ObjectSP AddressSanitizerRuntime::RetrieveReportData() {
   if (!frame_sp)
     return StructuredData::ObjectSP();
 
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetTryAllThreads(true);
   options.SetStopOthers(true);
   options.SetIgnoreBreakpoints(true);
-  options.SetTimeout(g_retrieve_report_data_function_timeout);
+  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
   options.SetPrefix(address_sanitizer_retrieve_report_data_prefix);
   options.SetAutoApplyFixIts(false);
   options.SetLanguage(eLanguageTypeObjC_plus_plus);
 
   ValueObjectSP return_value_sp;
   ExecutionContext exe_ctx;
   Status eval_error;
   frame_sp->CalculateExecutionContext(exe_ctx);

lldb/source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp

 }
 
 lldb::InstrumentationRuntimeType ThreadSanitizerRuntime::GetTypeStatic() {
   return eInstrumentationRuntimeTypeThreadSanitizer;
 }
 
 ThreadSanitizerRuntime::~ThreadSanitizerRuntime() { Deactivate(); }
 
-static constexpr std::chrono::seconds g_retrieve_data_function_timeout(2);
-
 const char *thread_sanitizer_retrieve_report_data_prefix = R"(
 extern "C"
 {
     void *__tsan_get_current_report();
     int __tsan_get_report_data(void *report, const char **description, int *count,
                                int *stack_count, int *mop_count, int *loc_count,
                                int *mutex_count, int *thread_count,
                                int *unique_tid_count, void **sleep_trace,
ThreadSanitizerRuntime::RetrieveReportData(ExecutionContextRef exe_ctx_ref) {
   if (!frame_sp)
     return StructuredData::ObjectSP();
 
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetTryAllThreads(true);
   options.SetStopOthers(true);
   options.SetIgnoreBreakpoints(true);
-  options.SetTimeout(g_retrieve_data_function_timeout);
+  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
   options.SetPrefix(thread_sanitizer_retrieve_report_data_prefix);
   options.SetAutoApplyFixIts(false);
   options.SetLanguage(eLanguageTypeObjC_plus_plus);
 
   ValueObjectSP main_value;
   ExecutionContext exe_ctx;
   Status eval_error;
   frame_sp->CalculateExecutionContext(exe_ctx);

lldb/source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.cpp

StructuredData::ObjectSP UndefinedBehaviorSanitizerRuntime::RetrieveReportData(
 
   StreamFileSP Stream(target.GetDebugger().GetOutputFile());
 
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetTryAllThreads(true);
   options.SetStopOthers(true);
   options.SetIgnoreBreakpoints(true);
-  options.SetTimeout(std::chrono::seconds(2));
+  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
   options.SetPrefix(ub_sanitizer_retrieve_report_data_prefix);
   options.SetAutoApplyFixIts(false);
   options.SetLanguage(eLanguageTypeObjC_plus_plus);
 
   ValueObjectSP main_value;
   ExecutionContext exe_ctx;
   Status eval_error;
   frame_sp->CalculateExecutionContext(exe_ctx);

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

ValueObjectSP ItaniumABILanguageRuntime::GetExceptionObjectForThread(
 
   DiagnosticManager diagnostics;
   ExecutionContext exe_ctx;
   EvaluateExpressionOptions options;
 
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
   options.SetStopOthers(true);
-  options.SetTimeout(std::chrono::milliseconds(500));
+  options.SetTimeout(m_process->GetUtilityExpressionTimeout());
   options.SetTryAllThreads(false);
   thread_sp->CalculateExecutionContext(exe_ctx);
 
   const ModuleList &modules = m_process->GetTarget().GetImages();
   SymbolContextList contexts;
   SymbolContext context;
 
   modules.FindSymbolsWithNameAndType(

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

 #include "Plugins/Process/Utility/HistoryThread.h"
 #include "Plugins/Language/ObjC/NSString.h"
 
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
-static constexpr std::chrono::seconds g_po_function_timeout(15);
-
 AppleObjCRuntime::~AppleObjCRuntime() {}
 
 AppleObjCRuntime::AppleObjCRuntime(Process *process)
     : ObjCLanguageRuntime(process), m_read_objc_library(false),
       m_objc_trampoline_handler_up(), m_Foundation_major() {
   ReadObjCLibraryIfNeeded(process->GetTarget().GetImages());
 }
 
m_print_object_caller_up->WriteFunctionArguments(
         exe_ctx, wrapper_struct_addr, arg_value_list, diagnostics);
   }
 
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetTryAllThreads(true);
   options.SetStopOthers(true);
   options.SetIgnoreBreakpoints(true);
-  options.SetTimeout(g_po_function_timeout);
+  options.SetTimeout(process->GetUtilityExpressionTimeout());
   options.SetIsForUtilityExpr(true);
 
   ExpressionResults results = m_print_object_caller_up->ExecuteFunction(
       exe_ctx, &wrapper_struct_addr, options, diagnostics, ret);
   if (results != eExpressionCompleted) {
     strm.Printf("Error evaluating Print Object function: %d.\n", results);
     return false;
   }

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

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
 
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
-// 2 second timeout when running utility functions
-static constexpr std::chrono::seconds g_utility_function_timeout(2);
-
 static const char *g_get_dynamic_class_info_name =
     "__lldb_apple_objc_v2_get_dynamic_class_info";
 // Testing using the new C++11 raw string literals. If this breaks GCC then we
 // will need to revert to the code above...
 static const char *g_get_dynamic_class_info_body = R"(
 
 extern "C"
 {
AppleObjCRuntimeV2::UpdateISAToDescriptorMapDynamic(
   // Write our function arguments into the process so we can run our function
   if (get_class_info_function->WriteFunctionArguments(
           exe_ctx, m_get_class_info_args, arguments, diagnostics)) {
     EvaluateExpressionOptions options;
     options.SetUnwindOnError(true);
     options.SetTryAllThreads(false);
     options.SetStopOthers(true);
     options.SetIgnoreBreakpoints(true);
-    options.SetTimeout(g_utility_function_timeout);
+    options.SetTimeout(process->GetUtilityExpressionTimeout());
     options.SetIsForUtilityExpr(true);
 
     Value return_value;
     return_value.SetValueType(Value::eValueTypeScalar);
     // return_value.SetContext (Value::eContextTypeClangType,
     // clang_uint32_t_type);
     return_value.SetCompilerType(clang_uint32_t_type);
     return_value.GetScalar() = 0;
AppleObjCRuntimeV2::UpdateISAToDescriptorMapSharedCache() {
   if (get_shared_cache_class_info_function->WriteFunctionArguments(
           exe_ctx, m_get_shared_cache_class_info_args, arguments,
           diagnostics)) {
     EvaluateExpressionOptions options;
     options.SetUnwindOnError(true);
     options.SetTryAllThreads(false);
     options.SetStopOthers(true);
     options.SetIgnoreBreakpoints(true);
-    options.SetTimeout(g_utility_function_timeout);
+    options.SetTimeout(process->GetUtilityExpressionTimeout());
     options.SetIsForUtilityExpr(true);
 
     Value return_value;
     return_value.SetValueType(Value::eValueTypeScalar);
     // return_value.SetContext (Value::eContextTypeClangType,
     // clang_uint32_t_type);
     return_value.SetCompilerType(clang_uint32_t_type);
     return_value.GetScalar() = 0;

lldb/source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp

static void CreateHistoryThreadFromValueObject(ProcessSP process_sp,
   thread_name_with_number << thread_name << " Thread " << tid;
   history_thread->SetThreadName(thread_name_with_number.str().c_str());
   // Save this in the Process' ExtendedThreadList so a strong pointer retains
   // the object
   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
   result.push_back(new_thread_sp);
 }
 
-static constexpr std::chrono::seconds g_get_stack_function_timeout(2);
-
 HistoryThreads MemoryHistoryASan::GetHistoryThreads(lldb::addr_t address) {
   HistoryThreads result;
 
   ProcessSP process_sp = m_process_wp.lock();
   if (!process_sp)
     return result;
 
   ThreadSP thread_sp =
HistoryThreads MemoryHistoryASan::GetHistoryThreads(lldb::addr_t address) {
   Status eval_error;
   expr.Printf(memory_history_asan_command_format, address, address);
 
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetTryAllThreads(true);
   options.SetStopOthers(true);
   options.SetIgnoreBreakpoints(true);
-  options.SetTimeout(g_get_stack_function_timeout);
+  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
   options.SetPrefix(memory_history_asan_command_prefix);
   options.SetAutoApplyFixIts(false);
   options.SetLanguage(eLanguageTypeObjC_plus_plus);
 
   ExpressionResults expr_result = UserExpression::Evaluate(
       exe_ctx, options, expr.GetString(), "", return_value_sp, eval_error);
   if (expr_result != eExpressionCompleted) {
     process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

Status PlatformPOSIX::EvaluateLibdlExpression(
   frame_sp->CalculateExecutionContext(exe_ctx);
   EvaluateExpressionOptions expr_options;
   expr_options.SetUnwindOnError(true);
   expr_options.SetIgnoreBreakpoints(true);
   expr_options.SetExecutionPolicy(eExecutionPolicyAlways);
   expr_options.SetLanguage(eLanguageTypeC_plus_plus);
   expr_options.SetTrapExceptions(false); // dlopen can't throw exceptions, so
                                          // don't do the work to trap them.
-  expr_options.SetTimeout(std::chrono::seconds(2));
+  expr_options.SetTimeout(process->GetUtilityExpressionTimeout());
 
   Status expr_error;
   ExpressionResults result =
       UserExpression::Evaluate(exe_ctx, expr_options, expr_cstr, expr_prefix,
                                result_valobj_sp, expr_error);
   if (result != eExpressionCompleted)
     return expr_error;
 
uint32_t PlatformPOSIX::DoLoadImage(lldb_private::Process *process,
   // Now run the caller:
   EvaluateExpressionOptions options;
   options.SetExecutionPolicy(eExecutionPolicyAlways);
   options.SetLanguage(eLanguageTypeC_plus_plus);
   options.SetIgnoreBreakpoints(true);
   options.SetUnwindOnError(true);
   options.SetTrapExceptions(false); // dlopen can't throw exceptions, so
                                     // don't do the work to trap them.
-  options.SetTimeout(std::chrono::seconds(2));
+  options.SetTimeout(process->GetUtilityExpressionTimeout());
   options.SetIsForUtilityExpr(true);
 
   Value return_value;
   // Fetch the clang types we will need:
   ClangASTContext *ast = process->GetTarget().GetScratchClangASTContext();
 
   CompilerType clang_void_pointer_type
       = ast->GetBasicType(eBasicTypeVoid).GetPointerType();

lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp

if (sc_list.GetContextAtIndex(0, sc)) {
           eSymbolContextFunction | eSymbolContextSymbol;
       const bool use_inline_block_range = false;
       EvaluateExpressionOptions options;
       options.SetStopOthers(true);
       options.SetUnwindOnError(true);
       options.SetIgnoreBreakpoints(true);
       options.SetTryAllThreads(true);
       options.SetDebug(false);
-      options.SetTimeout(std::chrono::milliseconds(500));
+      options.SetTimeout(process->GetUtilityExpressionTimeout());
       options.SetTrapExceptions(false);
 
       addr_t prot_arg;
       if (prot == eMmapProtNone)
         prot_arg = PROT_NONE;
       else {
         prot_arg = 0;
         if (prot & eMmapProtExec)
if (sc_list.GetContextAtIndex(0, sc)) {
           eSymbolContextFunction | eSymbolContextSymbol;
       const bool use_inline_block_range = false;
       EvaluateExpressionOptions options;
       options.SetStopOthers(true);
       options.SetUnwindOnError(true);
       options.SetIgnoreBreakpoints(true);
       options.SetTryAllThreads(true);
       options.SetDebug(false);
-      options.SetTimeout(std::chrono::milliseconds(500));
+      options.SetTimeout(process->GetUtilityExpressionTimeout());
       options.SetTrapExceptions(false);
 
       AddressRange munmap_range;
       if (sc.GetAddressRange(range_scope, 0, use_inline_block_range,
                              munmap_range)) {
         lldb::addr_t args[] = {addr, length};
         lldb::ThreadPlanSP call_plan_sp(
             new ThreadPlanCallFunction(*thread, munmap_range.GetBaseAddress(),
if (thread == NULL || address == NULL)
     return false;
 
   EvaluateExpressionOptions options;
   options.SetStopOthers(true);
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
   options.SetTryAllThreads(true);
   options.SetDebug(false);
-  options.SetTimeout(std::chrono::milliseconds(500));
+  options.SetTimeout(process->GetUtilityExpressionTimeout());
   options.SetTrapExceptions(trap_exceptions);
 
   ClangASTContext *clang_ast_context =
       process->GetTarget().GetScratchClangASTContext();
   CompilerType clang_void_ptr_type =
       clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
   lldb::ThreadPlanSP call_plan_sp(
       new ThreadPlanCallFunction(*thread, *address, clang_void_ptr_type,

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

void DumpProcessGDBRemotePacketHistory(void *p, const char *path) {
   if (error.Success())
     ((ProcessGDBRemote *)p)->GetGDBRemote().DumpHistory(strm);
 }
 } // namespace lldb
 
 namespace {
 
 static constexpr PropertyDefinition g_properties[] = {
-    {"packet-timeout", OptionValue::eTypeUInt64, true, 1, NULL, {},
+    {"packet-timeout", OptionValue::eTypeUInt64, true, 1
+#if defined(__has_feature)
+#if __has_feature(address_sanitizer)
+      + 4
+#endif
+#endif
+      , NULL, {},
      "Specify the default packet timeout in seconds."},
     {"target-definition-file", OptionValue::eTypeFileSpec, true, 0, NULL, {},
      "The file that provides the description for remote target registers."}};
 
 enum { ePropertyPacketTimeout, ePropertyTargetDefinitionFile };
 
 class PluginProperties : public Properties {
 public:

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

AppleGetItemInfoHandler::GetItemInfo(Thread &thread, uint64_t item,
   addr_t args_addr = SetupGetItemInfoFunction(thread, argument_values);
 
   DiagnosticManager diagnostics;
   ExecutionContext exe_ctx;
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
   options.SetStopOthers(true);
-  options.SetTimeout(std::chrono::milliseconds(500));
+  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
   options.SetTryAllThreads(false);
   options.SetIsForUtilityExpr(true);
   thread.CalculateExecutionContext(exe_ctx);
 
   if (!m_get_item_info_impl_code) {
     error.SetErrorString("Unable to compile function to call "
                          "__introspection_dispatch_queue_item_get_info");
     return return_value;

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp

AppleGetPendingItemsHandler::GetPendingItems(Thread &thread, addr_t queue,
   ExecutionContext exe_ctx;
   FunctionCaller *get_pending_items_caller =
       m_get_pending_items_impl_code->GetFunctionCaller();
 
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
   options.SetStopOthers(true);
-  options.SetTimeout(std::chrono::milliseconds(500));
+  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
   options.SetTryAllThreads(false);
   options.SetIsForUtilityExpr(true);
   thread.CalculateExecutionContext(exe_ctx);
 
   if (get_pending_items_caller == NULL) {
     error.SetErrorString("Unable to compile function to call "
                          "__introspection_dispatch_queue_get_pending_items");
     return return_value;

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp

AppleGetQueuesHandler::GetCurrentQueues(Thread &thread, addr_t page_to_free,
   }
 
   DiagnosticManager diagnostics;
   ExecutionContext exe_ctx;
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
   options.SetStopOthers(true);
-  options.SetTimeout(std::chrono::milliseconds(500));
+  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
   options.SetTryAllThreads(false);
   options.SetIsForUtilityExpr(true);
   thread.CalculateExecutionContext(exe_ctx);
 
   ExpressionResults func_call_ret;
   Value results;
   func_call_ret = get_queues_caller->ExecuteFunction(
       exe_ctx, &args_addr, options, diagnostics, results);

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp

AppleGetThreadItemInfoHandler::GetThreadItemInfo(Thread &thread,
   DiagnosticManager diagnostics;
   ExecutionContext exe_ctx;
   EvaluateExpressionOptions options;
   FunctionCaller *get_thread_item_info_caller = nullptr;
 
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
   options.SetStopOthers(true);
-  options.SetTimeout(std::chrono::milliseconds(500));
+  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
   options.SetTryAllThreads(false);
   options.SetIsForUtilityExpr(true);
   thread.CalculateExecutionContext(exe_ctx);
 
   if (!m_get_thread_item_info_impl_code) {
     error.SetErrorString("Unable to compile function to call "
                          "__introspection_dispatch_thread_get_item_info");
     return return_value;

lldb/source/Target/Process.cpp

static constexpr PropertyDefinition g_properties[] = {
      {}, "If true, detach will attempt to keep the process stopped."},
     {"memory-cache-line-size", OptionValue::eTypeUInt64, false, 512, nullptr,
      {}, "The memory cache line size"},
     {"optimization-warnings", OptionValue::eTypeBoolean, false, true, nullptr,
      {}, "If true, warn when stopped in code that is optimized where "
          "stepping and variable availability may not behave as expected."},
     {"stop-on-exec", OptionValue::eTypeBoolean, true, true,
      nullptr, {},
-     "If true, stop when a shared library is loaded or unloaded."}};
+     "If true, stop when a shared library is loaded or unloaded."},
+    {"utility-expression-timeout", OptionValue::eTypeUInt64, false, 15,
+     nullptr, {},
+     "The time in seconds to wait for LLDB-internal utility expressions."}
+};
 
 enum {
   ePropertyDisableMemCache,
   ePropertyExtraStartCommand,
   ePropertyIgnoreBreakpointsInExpressions,
   ePropertyUnwindOnErrorInExpressions,
   ePropertyPythonOSPluginPath,
   ePropertyStopOnSharedLibraryEvents,
   ePropertyDetachKeepsStopped,
   ePropertyMemCacheLineSize,
   ePropertyWarningOptimization,
-  ePropertyStopOnExec
+  ePropertyStopOnExec,
+  ePropertyUtilityExpressionTimeout,
 };
 
 ProcessProperties::ProcessProperties(lldb_private::Process *process)
     : Properties(),
       m_process(process) // Can be nullptr for global ProcessProperties
 {
   if (process == nullptr) {
     // Global process properties, set them up one time

 }
 
 bool ProcessProperties::GetStopOnExec() const {
   const uint32_t idx = ePropertyStopOnExec;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
+std::chrono::seconds ProcessProperties::GetUtilityExpressionTimeout() const {
+  const uint32_t idx = ePropertyUtilityExpressionTimeout;
+  uint64_t value = m_collection_sp->GetPropertyAtIndexAsUInt64(
+     nullptr, idx, g_properties[idx].default_uint_value);
+  return std::chrono::seconds(value);
+}
+
 Status ProcessLaunchCommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
   const int short_option = m_getopt_table[option_idx].val;
 
   switch (short_option) {
   case 's': // Stop at program entry point
if (m_private_state_thread.IsJoinable()) {
     std::shared_ptr<EventDataReceipt> event_receipt_sp(new EventDataReceipt());
     m_private_state_control_broadcaster.BroadcastEvent(signal,
                                                        event_receipt_sp);
 
     // Wait for the event receipt or for the private state thread to exit
     bool receipt_received = false;
     if (PrivateStateThreadIsValid()) {
       while (!receipt_received) {
-        // Check for a receipt for 2 seconds and then check if the private
+        // Check for a receipt for n seconds and then check if the private
         // state thread is still around.
         receipt_received =
-            event_receipt_sp->WaitForEventReceived(std::chrono::seconds(2));
+          event_receipt_sp->WaitForEventReceived(GetUtilityExpressionTimeout());
         if (!receipt_received) {
           // Check if the private state thread is still around. If it isn't
           // then we are done waiting
           if (!PrivateStateThreadIsValid())
             break; // Private state thread exited or is exiting, we are done
         }
       }
     }
while (true) {
                 "couldn't resume inferior the %d time: \"%s\".", num_resumes,
                 resume_error.AsCString());
             return_value = eExpressionSetupError;
             break;
           }
         }
 
         got_event =
-            listener_sp->GetEvent(event_sp, std::chrono::milliseconds(500));
+            listener_sp->GetEvent(event_sp, GetUtilityExpressionTimeout());
         if (!got_event) {
           if (log)
             log->Printf("Process::RunThreadPlan(): didn't get any event after "
                         "resume %" PRIu32 ", exiting.",
                         num_resumes);
 
           diagnostic_manager.Printf(eDiagnosticSeverityError,
                                     "didn't get any event after resume %" PRIu32
#endif
             const bool use_run_lock = false;
             Halt(clear_thread_plans, use_run_lock);
           }
           if (halt_error.Success()) {
             if (log)
               log->PutCString("Process::RunThreadPlan(): Halt succeeded.");
 
             got_event =
-                listener_sp->GetEvent(event_sp, std::chrono::milliseconds(500));
+                listener_sp->GetEvent(event_sp, GetUtilityExpressionTimeout());
 
             if (got_event) {
               stop_state =
                   Process::ProcessEventData::GetStateFromEvent(event_sp.get());
               if (log) {
                 log->Printf("Process::RunThreadPlan(): Stopped with event: %s",
                             StateAsCString(stop_state));
                 if (stop_state == lldb::eStateStopped &&