[Lldb-commits] [lldb] [lldb] Avoid unnecessary strlen of mangled names in ConstString (NFC) (PR #197995)

[via lldb-commits]

llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-lldb

Author: Dave Lee (kastiglione)

<details>
<summary>Changes</summary>

C++ mangled names are known to be quite long at times. This change constructs
StringRefs using available length data.


---
Full diff: https://github.com/llvm/llvm-project/pull/197995.diff


1 Files Affected:

- (modified) lldb/source/Utility/ConstString.cpp (+11-9) 


``````````diff
diff --git a/lldb/source/Utility/ConstString.cpp b/lldb/source/Utility/ConstString.cpp
index 0ee081427a0b7..9d17de7177f88 100644
--- a/lldb/source/Utility/ConstString.cpp
+++ b/lldb/source/Utility/ConstString.cpp
@@ -98,16 +98,17 @@ class Pool {
       // Since the entry is read only, and we derive the entry entirely from
       // the pointer, we don't need the lock.
       const StringPoolEntryType &entry = GetStringMapEntryFromKeyData(ccstr);
-      return entry.getKey().size();
+      return entry.getKeyLength();
     }
     return 0;
   }
 
   StringPoolValueType GetMangledCounterpart(const char *ccstr) {
     if (ccstr != nullptr) {
-      const PoolEntry &pool = selectPool(llvm::StringRef(ccstr));
+      const StringPoolEntryType &entry = GetStringMapEntryFromKeyData(ccstr);
+      const PoolEntry &pool = selectPool(entry.getKey());
       std::shared_lock<PoolMutex> lock(pool.m_mutex);
-      return GetStringMapEntryFromKeyData(ccstr).getValue();
+      return entry.getValue();
     }
     return nullptr;
   }
@@ -146,10 +147,10 @@ class Pool {
     return nullptr;
   }
 
-  const char *
-  GetConstCStringAndSetMangledCounterPart(llvm::StringRef demangled,
-                                          const char *mangled_ccstr) {
+  const char *GetConstCStringAndSetMangledCounterPart(llvm::StringRef demangled,
+                                                      llvm::StringRef mangled) {
     const char *demangled_ccstr = nullptr;
+    const char *const mangled_ccstr = mangled.data();
 
     {
       const uint32_t demangled_hash = StringPool::hash(demangled);
@@ -170,9 +171,10 @@ class Pool {
     {
       // Now assign the demangled const string as the counterpart of the
       // mangled const string...
-      PoolEntry &pool = selectPool(llvm::StringRef(mangled_ccstr));
+      StringPoolEntryType &entry = GetStringMapEntryFromKeyData(mangled_ccstr);
+      PoolEntry &pool = selectPool(mangled);
       std::lock_guard<PoolMutex> lock(pool.m_mutex);
-      GetStringMapEntryFromKeyData(mangled_ccstr).setValue(demangled_ccstr);
+      entry.setValue(demangled_ccstr);
     }
 
     // Return the constant demangled C string
@@ -341,7 +343,7 @@ void ConstString::SetString(llvm::StringRef s) {
 void ConstString::SetStringWithMangledCounterpart(llvm::StringRef demangled,
                                                   ConstString mangled) {
   m_string = StringPool().GetConstCStringAndSetMangledCounterPart(
-      demangled, mangled.m_string);
+      demangled, mangled.GetStringRef());
 }
 
 bool ConstString::GetMangledCounterpart(ConstString &counterpart) const {

``````````

</details>


https://github.com/llvm/llvm-project/pull/197995