[lldb] Improve error message when running static initialisers in expression fails

[teemperor]

Summary

The current error message is current error: couldn't run static initializers: couldn't run static initializer: which
just doesn't make a lot of sense.

This patch removes the duplicate error message and tries to improve the error message (at least for this test
case).

lldb/packages/Python/lldbsuite/test/commands/expression/static-initializers/TestStaticInitializers.py

class StaticInitializers(TestBase):
 
     def test_failing_init(self):
         """ Test a static initializer that fails to execute. """
         self.build()
 
         lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.cpp", False))
 
-        # FIXME: This error message is not even remotely helpful.
         self.expect("expr -p -- struct Foo2 { Foo2() { do_abort(); } }; Foo2 f;", error=True,
-                    substrs=["error: couldn't run static initializers: couldn't run static initializer:"])
+                    substrs=["error: couldn't run static initializers:\nerror: Execution interrupted: "])

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

lldb::ThreadPlanSP call_static_initializer(new ThreadPlanCallFunction(
         llvm::ArrayRef<lldb::addr_t>(), options));
 
     DiagnosticManager execution_errors;
     lldb::ExpressionResults results =
         exe_ctx.GetThreadRef().GetProcess()->RunThreadPlan(
             exe_ctx, call_static_initializer, options, execution_errors);
 
     if (results != lldb::eExpressionCompleted) {
-      err.SetErrorStringWithFormat("couldn't run static initializer: %s",
-                                   execution_errors.GetString().c_str());
+      if (execution_errors.Diagnostics().empty())
+        err.SetErrorStringWithFormatv("ExpressionResults: {0}", results);
+      else
+        err.SetErrorStringWithFormatv("{0}", execution_errors.GetString());
       return err;
     }
   }
 
   return err;
 }

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
   if (exe_ctx.GetProcessPtr() && execution_policy == eExecutionPolicyTopLevel) {
     Status static_init_error =
         parser.RunStaticInitializers(m_execution_unit_sp, exe_ctx);
 
     if (!static_init_error.Success()) {
       const char *error_cstr = static_init_error.AsCString();
       if (error_cstr && error_cstr[0])
         diagnostic_manager.Printf(eDiagnosticSeverityError,
-                                  "couldn't run static initializers: %s\n",
+                                  "couldn't run static initializers:\n%s\n",
                                   error_cstr);
       else
         diagnostic_manager.PutString(eDiagnosticSeverityError,
                                      "couldn't run static initializers\n");
       return false;
     }
   }
 

lldb/source/Target/Process.cpp

#endif
 
     if (return_value == eExpressionCompleted || should_unwind) {
       thread_plan_sp->RestoreThreadState();
     }
 
     // Now do some processing on the results of the run:
     if (return_value == eExpressionInterrupted ||
         return_value == eExpressionHitBreakpoint) {
-      if (log) {
-        StreamString s;
-        if (event_sp)
-          event_sp->Dump(&s);
-        else {
-          log->PutCString("Process::RunThreadPlan(): Stop event that "
-                          "interrupted us is NULL.");
-        }
 
-        StreamString ts;
 
-        const char *event_explanation = nullptr;
 
-        do {
-          if (!event_sp) {
-            event_explanation = "<no event>";
-            break;
-          } else if (event_sp->GetType() == eBroadcastBitInterrupt) {
-            event_explanation = "<user interrupt>";
-            break;
-          } else {
-            const Process::ProcessEventData *event_data =
-                Process::ProcessEventData::GetEventDataFromEvent(
-                    event_sp.get());
+              Process::ProcessEventData::GetEventDataFromEvent(event_sp.get());
 
-            if (!event_data) {
-              event_explanation = "<no event data>";
-              break;
-            }
 
-            Process *process = event_data->GetProcessSP().get();
 
-            if (!process) {
-              event_explanation = "<no process>";
-              break;
-            }
 
-            ThreadList &thread_list = process->GetThreadList();
 
-            uint32_t num_threads = thread_list.GetSize();
-            uint32_t thread_index;
 
-            ts.Printf("<%u threads> ", num_threads);
 
-            for (thread_index = 0; thread_index < num_threads; ++thread_index) {
-              Thread *thread = thread_list.GetThreadAtIndex(thread_index).get();
 
-              if (!thread) {
-                ts.Printf("<?> ");
-                continue;
-              }
 
-              ts.Printf("<0x%4.4" PRIx64 " ", thread->GetID());
-              RegisterContext *register_context =
-                  thread->GetRegisterContext().get();
 
-              if (register_context)
-                ts.Printf("[ip 0x%" PRIx64 "] ", register_context->GetPC());
-              else
-                ts.Printf("[ip unknown] ");
 
-              // Show the private stop info here, the public stop info will be
-              // from the last natural stop.
-              lldb::StopInfoSP stop_info_sp = thread->GetPrivateStopInfo();
-              if (stop_info_sp) {
-                const char *stop_desc = stop_info_sp->GetDescription();
-                if (stop_desc)
-                  ts.PutCString(stop_desc);
-              }
-              ts.Printf(">");
-            }
 
-            event_explanation = ts.GetData();
-          }
-        } while (false);
 
-        if (event_explanation)
-          LLDB_LOGF(log,
-                    "Process::RunThreadPlan(): execution interrupted: %s %s",
-                    s.GetData(), event_explanation);
-        else
-          LLDB_LOGF(log, "Process::RunThreadPlan(): execution interrupted: %s",
-                    s.GetData());
-      }
+      std::string error = s.GetString();
+        error += " " + std::string(event_explanation);
+
+      diagnostic_manager.PutString(eDiagnosticSeverityError,
+                                   "Execution interrupted: " + error);
+                error.c_str());
 
       if (should_unwind) {
         LLDB_LOGF(log,
                   "Process::RunThreadPlan: ExecutionInterrupted - "
                   "discarding thread plans up to %p.",
                   static_cast<void *>(thread_plan_sp.get()));
         thread->DiscardThreadPlansUpToPlan(thread_plan_sp);
       } else {