[lldb][NFCI] Remove use of ConstString from UnixSignals::SignalCode

[bulbazord]

Summary

On llvm.org and all downstream forks that I'm aware of, SignalCodes are
always created from C string literals. They are never compared to
anything so they take up space in the ConstString StringPool for no
tangible benefit.

I've changed the type here to const llvm::StringLiteral instead of
using a StringRef or a const char * to express intent -- These
strings come from constant data whose lifetime is directly tied to that
of the running process (and are thus safe to store).

[JDevlieghere]

LGTM

lldb/include/lldb/Target/UnixSignals.h

void AddSignal(int signo, const char *name, bool default_suppress,
                  bool default_stop, bool default_notify,
                  const char *description, const char *alias = nullptr);
 
   enum SignalCodePrintOption { None, Address, Bounds };
 
   // Instead of calling this directly, use a ADD_SIGCODE macro to get compile
   // time checks when on the native platform.
   void AddSignalCode(
-      int signo, int code, const char *description,
+      int signo, int code, const llvm::StringLiteral description,
       SignalCodePrintOption print_option = SignalCodePrintOption::None);
 
   void RemoveSignal(int signo);
 
   /// Track how many times signals are hit as stop reasons.
   void IncrementSignalHitCount(int signo);
 
   /// Get the hit count statistics for signals.
public:
   std::vector<int32_t> GetFilteredSignals(std::optional<bool> should_suppress,
                                           std::optional<bool> should_stop,
                                           std::optional<bool> should_notify);
 
 protected:
   // Classes that inherit from UnixSignals can see and modify these
 
   struct SignalCode {
-    ConstString m_description;
-    SignalCodePrintOption m_print_option;
+    const llvm::StringLiteral m_description;
+    const SignalCodePrintOption m_print_option;
   };
 
   struct Signal {
     ConstString m_name;
     ConstString m_alias;
     std::string m_description;
     std::map<int32_t, SignalCode> m_codes;
     uint32_t m_hit_count = 0;

lldb/source/Target/UnixSignals.cpp

void UnixSignals::AddSignal(int signo, const char *name, bool default_suppress,
                             bool default_stop, bool default_notify,
                             const char *description, const char *alias) {
   Signal new_signal(name, default_suppress, default_stop, default_notify,
                     description, alias);
   m_signals.insert(std::make_pair(signo, new_signal));
   ++m_version;
 }
 
-void UnixSignals::AddSignalCode(int signo, int code, const char *description,
+void UnixSignals::AddSignalCode(int signo, int code,
+                                const llvm::StringLiteral description,
                                 SignalCodePrintOption print_option) {
   collection::iterator signal = m_signals.find(signo);
   assert(signal != m_signals.end() &&
          "Tried to add code to signal that does not exist.");
   signal->second.m_codes.insert(
-      std::pair{code, SignalCode{ConstString(description), print_option}});
+      std::pair{code, SignalCode{description, print_option}});
   ++m_version;
 }
 
 void UnixSignals::RemoveSignal(int signo) {
   collection::iterator pos = m_signals.find(signo);
   if (pos != m_signals.end())
     m_signals.erase(pos);
   ++m_version;
UnixSignals::GetSignalDescription(int32_t signo, std::optional<int32_t> code,
                                   std::optional<lldb::addr_t> upper) const {
   std::string str;
 
   collection::const_iterator pos = m_signals.find(signo);
   if (pos != m_signals.end()) {
     str = pos->second.m_name.GetCString();
 
     if (code) {
-      std::map<int, SignalCode>::const_iterator cpos =
+      std::map<int32_t, SignalCode>::const_iterator cpos =
           pos->second.m_codes.find(*code);
       if (cpos != pos->second.m_codes.end()) {
         const SignalCode &sc = cpos->second;
         str += ": ";
         if (sc.m_print_option != SignalCodePrintOption::Bounds)
-          str += sc.m_description.GetCString();
+          str += sc.m_description.str();
 
         std::stringstream strm;
         switch (sc.m_print_option) {
         case SignalCodePrintOption::None:
           break;
         case SignalCodePrintOption::Address:
           if (addr)
             strm << " (fault address: 0x" << std::hex << *addr << ")";
           break;
         case SignalCodePrintOption::Bounds:
           if (lower && upper && addr) {
             if ((unsigned long)(*addr) < *lower)
               strm << "lower bound violation ";
             else
               strm << "upper bound violation ";
 
             strm << "(fault address: 0x" << std::hex << *addr;
             strm << ", lower bound: 0x" << std::hex << *lower;
             strm << ", upper bound: 0x" << std::hex << *upper;
             strm << ")";
           } else
-            strm << sc.m_description.GetCString();
+            strm << sc.m_description.str();
 
           break;
         }
         str += strm.str();
       }
     }
   }