Add format_provider for lldb::StateType

[clayborg]

Very close, just add a test for a bad value since someone can have code like:

StateType state;
llvm::formatv("{0}", state);

Just to make sure we don't crash during logging. Can remember what lldb_private::StateAsCString(...) returns, but I am guessing it is NULL for a bad state, so we need to make sure the logging won't crash with that.

[clayborg]

unittests/Core/StateTest.cpp

19 ↗

(On Diff #85415)

Add a test like:

EXPECT_EQ("(null)", llvm::formatv("{0}", static_cast<StateType>(-1)).str());

[labath]

In this case, StateAsCString was returning a pointer to a static buffer in a
scarily non-thread-safe way. I've changed it to print "unknown" instead and test
for that.

[clayborg]

Looks good as long as the test suite is happy.

lldb/trunk/include/lldb/Core/State.h

 //===-- State.h -------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_State_h_
 #define liblldb_State_h_
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "lldb/lldb-private.h"
+#include "llvm/Support/FormatProviders.h"
 
 namespace lldb_private {
 
 //------------------------------------------------------------------
 /// Converts a StateType to a C string.
 ///
 /// @param[in] state
 ///     The StateType object to convert.

 ///     process no longer exists are considered to be stopped.
 //------------------------------------------------------------------
 bool StateIsStoppedState(lldb::StateType state, bool must_exist);
 
 const char *GetPermissionsAsCString(uint32_t permissions);
 
 } // namespace lldb_private
 
+namespace llvm {
+template <> struct format_provider<lldb::StateType> {
+  static void format(const lldb::StateType &state, raw_ostream &Stream,
+                     StringRef Style) {
+    Stream << lldb_private::StateAsCString(state);
+  }
+};
+}
+
 #endif // liblldb_State_h_

lldb/trunk/source/Core/State.cpp

case eStateCrashed:
     return "crashed";
   case eStateDetached:
     return "detached";
   case eStateExited:
     return "exited";
   case eStateSuspended:
     return "suspended";
   }
-  static char unknown_state_string[64];
-  snprintf(unknown_state_string, sizeof(unknown_state_string), "StateType = %i",
-           state);
-  return unknown_state_string;
+  return "unknown";
 }
 
 const char *lldb_private::GetPermissionsAsCString(uint32_t permissions) {
   switch (permissions) {
   case 0:
     return "---";
   case ePermissionsWritable:
     return "-w-";

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

if (is_main_thread) {
       if (!already_notified) {
         LLDB_LOG(
             log,
             "tid = {0} handling main thread exit ({1}), expected exit state "
             "already set but state was {2} instead, setting exit state now",
             pid,
             thread_found ? "stopped tracking thread metadata"
                          : "thread metadata not found",
-            StateAsCString(GetState()));
+            GetState());
         // The main thread exited.  We're done monitoring.  Report to delegate.
         SetExitStatus(convert_pid_status_to_exit_type(status),
                       convert_pid_status_to_return_code(status), nullptr, true);
 
         // Notify delegate that our process has exited.
         SetState(StateType::eStateExited, true);
       } else
         LLDB_LOG(log, "tid = {0} main thread now exited (%s)", pid,
if (!StateIsStoppedState(thread_state, false)) {
         if (error.Fail())
           LLDB_LOG(log, "failed to resume thread {0}: {1}", thread.GetID(),
                    error);
       }
     } else {
       LLDB_LOG(log,
                "pid {0} tid {1}, thread was already marked as a stopped "
                "state (state={2}), leaving stop signal as is",
-               GetID(), thread.GetID(), StateAsCString(thread_state));
+               GetID(), thread.GetID(), thread_state);
       SignalIfAllThreadsStopped();
     }
 
     // Done handling.
     return;
   }
 
   // This thread is stopped.
for (auto thread_sp : m_threads) {
 
     if (action == nullptr) {
       LLDB_LOG(log, "no action specified for pid {0} tid {1}", GetID(),
                thread_sp->GetID());
       continue;
     }
 
     LLDB_LOG(log, "processing resume action state {0} for pid {1} tid {2}",
-             StateAsCString(action->state), GetID(), thread_sp->GetID());
+             action->state, GetID(), thread_sp->GetID());
 
     switch (action->state) {
     case eStateRunning:
     case eStateStepping: {
       // Run the thread, possibly feeding it the signal.
       const int signo = action->signal;
       ResumeThread(static_cast<NativeThreadLinux &>(*thread_sp), action->state,
                    signo);
Error NativeProcessLinux::Kill() {
   switch (m_state) {
   case StateType::eStateInvalid:
   case StateType::eStateExited:
   case StateType::eStateCrashed:
   case StateType::eStateDetached:
   case StateType::eStateUnloaded:
     // Nothing to do - the process is already dead.
     LLDB_LOG(log, "ignored for PID {0} due to current state: {1}", GetID(),
-             StateAsCString(m_state));
+             m_state);
     return error;
 
   case StateType::eStateConnected:
   case StateType::eStateAttaching:
   case StateType::eStateLaunching:
   case StateType::eStateStopped:
   case StateType::eStateRunning:
   case StateType::eStateStepping:
Error NativeProcessLinux::ResumeThread(NativeThreadLinux &thread,
   }
   case eStateStepping: {
     const auto step_result = thread.SingleStep(signo);
     if (step_result.Success())
       SetState(eStateRunning, true);
     return step_result;
   }
   default:
-    LLDB_LOG(log, "Unhandled state {0}.", StateAsCString(state));
+    LLDB_LOG(log, "Unhandled state {0}.", state);
     llvm_unreachable("Unhandled state for resume");
   }
 }
 
 //===----------------------------------------------------------------------===//
 
 void NativeProcessLinux::StopRunningThreads(const lldb::tid_t triggering_tid) {
   Log *const log = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD);

lldb/trunk/unittests/Core/CMakeLists.txt

 add_lldb_unittest(LLDBCoreTests
   ArchSpecTest.cpp
   BroadcasterTest.cpp
   DataExtractorTest.cpp
   ErrorTest.cpp
   ListenerTest.cpp
   LogTest.cpp
   ScalarTest.cpp
+  StateTest.cpp
   StructuredDataTest.cpp
   TimerTest.cpp
   )

lldb/trunk/unittests/Core/StateTest.cpp

+//===-- StateTest.cpp -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/State.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "gtest/gtest.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+TEST(StateTest, Formatv) {
+  EXPECT_EQ("exited", llvm::formatv("{0}", eStateExited).str());
+  EXPECT_EQ("stopped", llvm::formatv("{0}", eStateStopped).str());
+  EXPECT_EQ("unknown", llvm::formatv("{0}", StateType(-1)).str());
+}