[lldb][NFCI] ConstString methods should take StringRefs by value

[bulbazord]

Summary

StringRef was made to be passed by value efficiently.

[kastiglione]

lldb/source/Utility/ConstString.cpp

305–306

I think the const can be removed too, since StringRefs are immutable.

[bulbazord]

lldb/source/Utility/ConstString.cpp

305–306

Yeah, I can remove const and that should be fine too. But StringRef objects aren't immutable, you can modify them with methods like consume_front and consume_back.

[kastiglione]

lldb/source/Utility/ConstString.cpp

305–306

thanks for pointing that out, I was thinking about the underlying char *, which isn't mutable. Now that the StringRef is passed by copy, then the caller's copy can't be modified.

[bulbazord]

Remove const where unneeded.

[fdeazeve]

LGTM, thanks for picking this up!

lldb/include/lldb/Utility/ConstString.h

 /// the program.
 class ConstString {
 public:
   /// Default constructor
   ///
   /// Initializes the string to an empty string.
   ConstString() = default;
 
-  explicit ConstString(const llvm::StringRef &s);
+  explicit ConstString(llvm::StringRef s);
 
   /// Construct with C String value
   ///
   /// Constructs this object with a C string by looking to see if the
   /// C string already exists in the global string pool. If it doesn't
   /// exist, it is added to the string pool.
   ///
   /// \param[in] cstr
public:
   /// If the C string already exists in the global string pool, it finds the
   /// current entry and returns the existing value. If it doesn't exist, it is
   /// added to the string pool.
   ///
   /// \param[in] cstr
   ///     A NULL terminated C string to add to the string pool.
   void SetCString(const char *cstr);
 
-  void SetString(const llvm::StringRef &s);
+  void SetString(llvm::StringRef s);
 
   /// Set the C string value and its mangled counterpart.
   ///
   /// Object files and debug symbols often use mangled string to represent the
   /// linkage name for a symbol, function or global. The string pool can
   /// efficiently store these values and their counterparts so when we run
   /// into another instance of a mangled name, we can avoid calling the name
   /// demangler over and over on the same strings and then trying to unique

lldb/source/Utility/ConstString.cpp

public:
   }
 
   const char *GetConstCStringWithLength(const char *cstr, size_t cstr_len) {
     if (cstr != nullptr)
       return GetConstCStringWithStringRef(llvm::StringRef(cstr, cstr_len));
     return nullptr;
   }
 
-  const char *GetConstCStringWithStringRef(const llvm::StringRef &string_ref) {
+  const char *GetConstCStringWithStringRef(llvm::StringRef string_ref) {
     if (string_ref.data()) {
       const uint8_t h = hash(string_ref);
 
       {
         llvm::sys::SmartScopedReader<false> rlock(m_string_pools[h].m_mutex);
         auto it = m_string_pools[h].m_string_map.find(string_ref);
         if (it != m_string_pools[h].m_string_map.end())
           return it->getKeyData();
for (const auto &pool : m_string_pools) {
       const Allocator &alloc = pool.m_string_map.getAllocator();
       stats.bytes_total += alloc.getTotalMemory();
       stats.bytes_used += alloc.getBytesAllocated();
     }
     return stats;
   }
 
 protected:
-  uint8_t hash(const llvm::StringRef &s) const {
+  uint8_t hash(llvm::StringRef s) const {
     uint32_t h = llvm::djbHash(s);
     return ((h >> 24) ^ (h >> 16) ^ (h >> 8) ^ h) & 0xff;
   }
 
   struct PoolEntry {
     mutable llvm::sys::SmartRWMutex<false> m_mutex;
     StringPool m_string_map;
   };

 }
 
 ConstString::ConstString(const char *cstr)
     : m_string(StringPool().GetConstCString(cstr)) {}
 
 ConstString::ConstString(const char *cstr, size_t cstr_len)
     : m_string(StringPool().GetConstCStringWithLength(cstr, cstr_len)) {}
 
-ConstString::ConstString(const llvm::StringRef &s)
+ConstString::ConstString(llvm::StringRef s)
     : m_string(StringPool().GetConstCStringWithStringRef(s)) {}
 
 bool ConstString::operator<(ConstString rhs) const {
   if (m_string == rhs.m_string)
     return false;
 
   llvm::StringRef lhs_string_ref(GetStringRef());
   llvm::StringRef rhs_string_ref(rhs.GetStringRef());
s->Printf("%*p: ConstString, string = %s%s%s, length = %" PRIu64,
             static_cast<const void *>(this), parens, cstr, parens,
             static_cast<uint64_t>(cstr_len));
 }
 
 void ConstString::SetCString(const char *cstr) {
   m_string = StringPool().GetConstCString(cstr);
 }
 
-void ConstString::SetString(const llvm::StringRef &s) {
-  m_string = StringPool().GetConstCStringWithLength(s.data(), s.size());
+void ConstString::SetString(llvm::StringRef s) {
+  m_string = StringPool().GetConstCStringWithStringRef(s);
 }
 
 void ConstString::SetStringWithMangledCounterpart(llvm::StringRef demangled,
                                                   ConstString mangled) {
   m_string = StringPool().GetConstCStringAndSetMangledCounterPart(
       demangled, mangled.m_string);
 }