[lldb] Change UnixSignals::GetSignalAsCString to GetSignalAsStringRef

[bulbazord]

Summary

This is in preparation to remove the uses of ConstString from
UnixSignals.

[DavidSpickett]

LGTM.

lldb/include/lldb/Target/UnixSignals.h

public:
   static lldb::UnixSignalsSP Create(const ArchSpec &arch);
   static lldb::UnixSignalsSP CreateForHost();
 
   // Constructors and Destructors
   UnixSignals();
 
   virtual ~UnixSignals();
 
-  const char *GetSignalAsCString(int32_t signo) const;
+  llvm::StringRef GetSignalAsStringRef(int32_t signo) const;
 
   std::string
   GetSignalDescription(int32_t signo,
                        std::optional<int32_t> code = std::nullopt,
                        std::optional<lldb::addr_t> addr = std::nullopt,
                        std::optional<lldb::addr_t> lower = std::nullopt,
                        std::optional<lldb::addr_t> upper = std::nullopt) const;
 

lldb/source/API/SBUnixSignals.cpp

SBUnixSignals::operator bool() const {
 
   return static_cast<bool>(GetSP());
 }
 
 const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
   LLDB_INSTRUMENT_VA(this, signo);
 
   if (auto signals_sp = GetSP())
-    return ConstString(signals_sp->GetSignalAsCString(signo)).GetCString();
+    return ConstString(signals_sp->GetSignalAsStringRef(signo)).GetCString();
 
   return nullptr;
 }
 
 int32_t SBUnixSignals::GetSignalNumberFromName(const char *name) const {
   LLDB_INSTRUMENT_VA(this, name);
 
   if (auto signals_sp = GetSP())

lldb/source/Commands/CommandObjectProcess.cpp

public:
   HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     if (!m_exe_ctx.HasProcessScope() || request.GetCursorIndex() != 0)
       return;
 
     UnixSignalsSP signals = m_exe_ctx.GetProcessPtr()->GetUnixSignals();
     int signo = signals->GetFirstSignalNumber();
     while (signo != LLDB_INVALID_SIGNAL_NUMBER) {
-      request.TryCompleteCurrentArg(signals->GetSignalAsCString(signo));
+      request.TryCompleteCurrentArg(signals->GetSignalAsStringRef(signo));
       signo = signals->GetNextSignalNumber(signo);
     }
   }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Process *process = m_exe_ctx.GetProcessPtr();
 
bool VerifyCommandOptionValue(const std::string &option, int &real_value) {
     return okay;
   }
 
   void PrintSignalHeader(Stream &str) {
     str.Printf("NAME         PASS   STOP   NOTIFY\n");
     str.Printf("===========  =====  =====  ======\n");
   }
 
-  void PrintSignal(Stream &str, int32_t signo, const char *sig_name,
+  void PrintSignal(Stream &str, int32_t signo, llvm::StringRef sig_name,
                    const UnixSignalsSP &signals_sp) {
     bool stop;
     bool suppress;
     bool notify;
 
-    str.Printf("%-11s  ", sig_name);
+    str.Format("{0, -11}  ", sig_name);
     if (signals_sp->GetSignalInfo(signo, suppress, stop, notify)) {
       bool pass = !suppress;
       str.Printf("%s  %s  %s", (pass ? "true " : "false"),
                  (stop ? "true " : "false"), (notify ? "true " : "false"));
     }
     str.Printf("\n");
   }
 
if (num_valid_signals > 0) {
         if (signo != LLDB_INVALID_SIGNAL_NUMBER)
           PrintSignal(str, signo, signal_args.GetArgumentAtIndex(i),
                       signals_sp);
       }
     } else // Print info for ALL signals
     {
       int32_t signo = signals_sp->GetFirstSignalNumber();
       while (signo != LLDB_INVALID_SIGNAL_NUMBER) {
-        PrintSignal(str, signo, signals_sp->GetSignalAsCString(signo),
+        PrintSignal(str, signo, signals_sp->GetSignalAsStringRef(signo),
                     signals_sp);
         signo = signals_sp->GetNextSignalNumber(signo);
       }
     }
   }
 
 protected:
   bool DoExecute(Args &signal_args, CommandReturnObject &result) override {

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

GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo(
 
   lldb::UnixSignalsSP signals = UnixSignals::CreateForHost();
   for (auto signo = signals->GetFirstSignalNumber();
        signo != LLDB_INVALID_SIGNAL_NUMBER;
        signo = signals->GetNextSignalNumber(signo)) {
     auto dictionary = std::make_shared<StructuredData::Dictionary>();
 
     dictionary->AddIntegerItem("signo", signo);
-    dictionary->AddStringItem("name", signals->GetSignalAsCString(signo));
+    dictionary->AddStringItem("name", signals->GetSignalAsStringRef(signo));
 
     bool suppress, stop, notify;
     signals->GetSignalInfo(signo, suppress, stop, notify);
     dictionary->AddBooleanItem("suppress", suppress);
     dictionary->AddBooleanItem("stop", stop);
     dictionary->AddBooleanItem("notify", notify);
 
     signal_array.Push(dictionary);

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

) {
 
   if (state != eStateInvalid && state != eStateUnloaded &&
       state != eStateExited && state != eStateDetached) {
     StreamString stream;
     if (signo == 0)
       stream.Format(DEBUGSERVER_BASENAME " died with an exit status of {0:x8}",
                     exit_status);
     else {
-      const char *signal_name =
-          process_sp->GetUnixSignals()->GetSignalAsCString(signo);
+      llvm::StringRef signal_name =
+          process_sp->GetUnixSignals()->GetSignalAsStringRef(signo);
       const char *format_str = DEBUGSERVER_BASENAME " died with signal {0}";
-      if (signal_name)
+      if (!signal_name.empty())
         stream.Format(format_str, signal_name);
       else
         stream.Format(format_str, signo);
     }
     process_sp->SetExitStatus(-1, stream.GetString());
   }
   // Debugserver has exited we need to let our ProcessGDBRemote know that it no
   // longer has a debugserver instance

lldb/source/Target/Process.cpp

LLDB_LOGF(log,
             ", exited=%i, signal=%i, exit_status=%i)\n",
             pid, exited, signo, exit_status);
 
   if (exited) {
     TargetSP target_sp(Debugger::FindTargetWithProcessID(pid));
     if (target_sp) {
       ProcessSP process_sp(target_sp->GetProcessSP());
       if (process_sp) {
-        const char *signal_cstr = nullptr;
-        if (signo)
-          signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo);
-
-        process_sp->SetExitStatus(exit_status, signal_cstr);
+        llvm::StringRef signal_str =
+            process_sp->GetUnixSignals()->GetSignalAsStringRef(signo);
+        process_sp->SetExitStatus(exit_status, signal_str);
       }
     }
     return true;
   }
   return false;
 }
 
 bool Process::UpdateThreadList(ThreadList &old_thread_list,

lldb/source/Target/StopInfo.cpp

public:
   // If should stop returns false, check if we should notify of this event
   bool DoShouldNotify(Event *event_ptr) override {
     ThreadSP thread_sp(m_thread_wp.lock());
     if (thread_sp) {
       bool should_notify =
           thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
       if (should_notify) {
         StreamString strm;
-        strm.Printf(
-            "thread %d received signal: %s", thread_sp->GetIndexID(),
-            thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(
+        strm.Format(
+            "thread {0:d} received signal: {1}", thread_sp->GetIndexID(),
+            thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsStringRef(
                 m_value));
         Process::ProcessEventData::AddRestartedReason(event_ptr,
                                                       strm.GetData());
       }
       return should_notify;
     }
     return true;
   }

lldb/source/Target/UnixSignals.cpp

 
 void UnixSignals::RemoveSignal(int signo) {
   collection::iterator pos = m_signals.find(signo);
   if (pos != m_signals.end())
     m_signals.erase(pos);
   ++m_version;
 }
 
-const char *UnixSignals::GetSignalAsCString(int signo) const {
-  collection::const_iterator pos = m_signals.find(signo);
+llvm::StringRef UnixSignals::GetSignalAsStringRef(int32_t signo) const {
+  const auto pos = m_signals.find(signo);
   if (pos == m_signals.end())
-    return nullptr;
-  else
-    return pos->second.m_name.GetCString();
+    return {};
+  return pos->second.m_name.GetStringRef();
 }
 
 std::string
 UnixSignals::GetSignalDescription(int32_t signo, std::optional<int32_t> code,
                                   std::optional<lldb::addr_t> addr,
                                   std::optional<lldb::addr_t> lower,
                                   std::optional<lldb::addr_t> upper) const {
   std::string str;

lldb/unittests/Signals/UnixSignalsTest.cpp

TEST(UnixSignalsTest, Reset) {
   EXPECT_EQ(suppress_val, signals.GetShouldSuppress(2));
 }
 
 TEST(UnixSignalsTest, GetInfo) {
   TestSignals signals;
 
   bool should_suppress = false, should_stop = false, should_notify = false;
   int32_t signo = 4;
-  std::string name =
+  llvm::StringRef name =
       signals.GetSignalInfo(signo, should_suppress, should_stop, should_notify);
   EXPECT_EQ("SIG4", name);
   EXPECT_EQ(true, should_suppress);
   EXPECT_EQ(false, should_stop);
   EXPECT_EQ(true, should_notify);
 
   EXPECT_EQ(true, signals.GetShouldSuppress(signo));
   EXPECT_EQ(false, signals.GetShouldStop(signo));
   EXPECT_EQ(true, signals.GetShouldNotify(signo));
-  EXPECT_EQ(name, signals.GetSignalAsCString(signo));
+  EXPECT_EQ(name, signals.GetSignalAsStringRef(signo));
 }
 
-TEST(UnixSignalsTest, GetAsCString) {
+TEST(UnixSignalsTest, GetAsStringRef) {
   TestSignals signals;
 
-  ASSERT_EQ(nullptr, signals.GetSignalAsCString(100));
-  std::string name = signals.GetSignalAsCString(16);
-  ASSERT_EQ("SIG16", name);
+  ASSERT_EQ(llvm::StringRef(), signals.GetSignalAsStringRef(100));
+  ASSERT_EQ("SIG16", signals.GetSignalAsStringRef(16));
 }
 
 TEST(UnixSignalsTest, GetAsString) {
   TestSignals signals;
 
   ASSERT_EQ("", signals.GetSignalDescription(100, std::nullopt));
   ASSERT_EQ("SIG16", signals.GetSignalDescription(16, std::nullopt));
   ASSERT_EQ("", signals.GetSignalDescription(100, 100));