[lldb][NFCI] Change return type of UnixSignals::GetSignalInfo

[bulbazord]

Summary

There's no reason for GetSignalInfo to return the signal name. All users
of this method only use the return value to determine if the method
succeeded in filling in the output parameters, so let's explicitly make
it a bool instead of a pointer.

[JDevlieghere]

LGTM

lldb/include/lldb/Target/UnixSignals.h

GetSignalDescription(int32_t signo,
                        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;
 
   bool SignalIsValid(int32_t signo) const;
 
   int32_t GetSignalNumberFromName(const char *name) const;
 
-  const char *GetSignalInfo(int32_t signo, bool &should_suppress,
-                            bool &should_stop, bool &should_notify) const;
+  /// Gets the information for a particular signal
+  ///
+  /// GetSignalInfo takes a signal number and populates 3 out parameters
+  /// describing how lldb should react when a particular signal is received in
+  /// the inferior.
+  ///
+  /// \param[in] signo
+  ///   The signal number to get information about.
+  /// \param[out] should_suppress
+  ///   Should we suppress this signal?
+  /// \param[out] should_stop
+  ///   Should we stop if this signal is received?
+  /// \param[out] should_notify
+  ///   Should we notify the user if this signal is received?
+  ///
+  /// \return
+  ///   Returns a boolean value. Returns true if the out parameters were
+  ///   successfully populated, false otherwise.
+  bool GetSignalInfo(int32_t signo, bool &should_suppress, bool &should_stop,
+                     bool &should_notify) const;
 
   bool GetShouldSuppress(int32_t signo) const;
 
   bool SetShouldSuppress(int32_t signo, bool value);
 
   bool SetShouldSuppress(const char *signal_name, bool value);
 
   bool GetShouldStop(int32_t signo) const;

lldb/source/Target/UnixSignals.cpp

else {
     pos++;
     if (pos == end)
       return LLDB_INVALID_SIGNAL_NUMBER;
     else
       return pos->first;
   }
 }
 
-const char *UnixSignals::GetSignalInfo(int32_t signo, bool &should_suppress,
-                                       bool &should_stop,
-                                       bool &should_notify) const {
-  collection::const_iterator pos = m_signals.find(signo);
+bool UnixSignals::GetSignalInfo(int32_t signo, bool &should_suppress,
+                                bool &should_stop, bool &should_notify) const {
+  const auto pos = m_signals.find(signo);
   if (pos == m_signals.end())
-    return nullptr;
-  else {
-    const Signal &signal = pos->second;
-    should_suppress = signal.m_suppress;
-    should_stop = signal.m_stop;
-    should_notify = signal.m_notify;
-    return signal.m_name.AsCString("");
-  }
+    return false;
+
+  return true;
 }
 
 bool UnixSignals::GetShouldSuppress(int signo) const {
   collection::const_iterator pos = m_signals.find(signo);
   if (pos != m_signals.end())
     return pos->second.m_suppress;
   return false;
 }

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;
-  llvm::StringRef name =
+  bool success =
       signals.GetSignalInfo(signo, should_suppress, should_stop, should_notify);
-  EXPECT_EQ("SIG4", name);
+  ASSERT_TRUE(success);
   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.GetSignalAsStringRef(signo));
 }
 
 TEST(UnixSignalsTest, GetAsStringRef) {
   TestSignals signals;
 
   ASSERT_EQ(llvm::StringRef(), signals.GetSignalAsStringRef(100));
   ASSERT_EQ("SIG16", signals.GetSignalAsStringRef(16));
 }