[lldb] Remove ConstString::StaticMemorySize

[JDevlieghere]

Summary

Remove ConstString::StaticMemorySize as it is unused and superseded by GetMemoryStats. It is referenced in a bunch of doc comments but I don't really understand why. My best guess it that the comments were copy-pasted from ConstString::MemorySize() even though it didn't make sense there either. The implementation of StaticMemorySize was being called on the MemoryPool, not on the ConstString itself.

lldb/include/lldb/Core/Declaration.h

public:
   }
 
   /// Get the memory cost of this object.
   ///
   /// \return
   ///     The number of bytes that this object occupies in memory.
   ///     The returned value does not include the bytes for any
   ///     shared string values.
-  ///
-  /// \see ConstString::StaticMemorySize ()
   size_t MemorySize() const;
 
   /// Set accessor for the declaration file specification.
   ///
   /// \param[in] file_spec
   ///     The new declaration file specification.
   void SetFile(const FileSpec &file_spec) { m_file = file_spec; }
 

lldb/include/lldb/Core/FileSpecList.h

public:
   /// Get the memory cost of this object.
   ///
   /// Return the size in bytes that this object takes in memory. This returns
   /// the size in bytes of this object, not any shared string values it may
   /// refer to.
   ///
   /// \return
   ///     The number of bytes that this object occupies in memory.
-  ///
-  /// \see ConstString::StaticMemorySize ()
   size_t MemorySize() const;
 
   bool IsEmpty() const { return m_files.empty(); }
 
   /// Get the number of files in the file list.
   ///
   /// \return
   ///     The number of files in the file spec list.

lldb/include/lldb/Core/Mangled.h

public:
   /// Get the memory cost of this object.
   ///
   /// Return the size in bytes that this object takes in memory. This returns
   /// the size in bytes of this object, not any shared string values it may
   /// refer to.
   ///
   /// \return
   ///     The number of bytes that this object occupies in memory.
-  ///
-  /// \see ConstString::StaticMemorySize ()
   size_t MemorySize() const;
 
   /// Set the string value in this object.
   ///
   /// If \a is_mangled is \b true, then the mangled named is set to \a name,
   /// else the demangled name is set to \a name.
   ///
   /// \param[in] name

lldb/include/lldb/Symbol/Function.h

public:
   ConstString GetName() const;
 
   /// Get the memory cost of this object.
   ///
   /// \return
   ///     The number of bytes that this object occupies in memory.
   ///     The returned value does not include the bytes for any
   ///     shared string values.
-  ///
-  /// \see ConstString::StaticMemorySize ()
   virtual size_t MemorySize() const;
 
 protected:
   /// Function method name (not a mangled name).
   ConstString m_name;
 
   /// Information describing where this function information was defined.
   Declaration m_declaration;
public:
   const Mangled &GetMangled() const;
 
   /// Get the memory cost of this object.
   ///
   /// \return
   ///     The number of bytes that this object occupies in memory.
   ///     The returned value does not include the bytes for any
   ///     shared string values.
-  ///
-  /// \see ConstString::StaticMemorySize ()
   size_t MemorySize() const override;
 
 private:
   /// Mangled inlined function name (can be empty if there is no mangled
   /// information).
   Mangled m_mangled;
 
   Declaration m_call_decl;
public:
   void DumpSymbolContext(Stream *s) override;
 
   /// Get the memory cost of this object.
   ///
   /// \return
   ///     The number of bytes that this object occupies in memory.
   ///     The returned value does not include the bytes for any
   ///     shared string values.
-  ///
-  /// \see ConstString::StaticMemorySize ()
   size_t MemorySize() const;
 
   /// Get whether compiler optimizations were enabled for this function
   ///
   /// The debug information may provide information about whether this
   /// function was compiled with optimization or not.  In this case,
   /// "optimized" means that the debug experience may be difficult for the
   /// user to understand.  Variables may not be available when the developer

lldb/include/lldb/Utility/ConstString.h

public:
   /// Get the memory cost of this object.
   ///
   /// Return the size in bytes that this object takes in memory. This returns
   /// the size in bytes of this object, which does not include any the shared
   /// string values it may refer to.
   ///
   /// \return
   ///     The number of bytes that this object occupies in memory.
-  ///
-  /// \see ConstString::StaticMemorySize ()
   size_t MemorySize() const { return sizeof(ConstString); }
 
-  /// Get the size in bytes of the current global string pool.
-  ///
-  /// Reports the size in bytes of all shared C string values, containers and
-  /// any other values as a byte size for the entire string pool.
-  ///
-  /// \return
-  ///     The number of bytes that the global string pool occupies
-  ///     in memory.
-  static size_t StaticMemorySize();
-
   struct MemoryStats {
     size_t GetBytesTotal() const { return bytes_total; }
     size_t GetBytesUsed() const { return bytes_used; }
     size_t GetBytesUnused() const { return bytes_total - bytes_used; }
     size_t bytes_total = 0;
     size_t bytes_used = 0;
   };
 

lldb/include/lldb/Utility/FileSpec.h

public:
   /// Get the memory cost of this object.
   ///
   /// Return the size in bytes that this object takes in memory. This returns
   /// the size in bytes of this object, not any shared string values it may
   /// refer to.
   ///
   /// \return
   ///     The number of bytes that this object occupies in memory.
-  ///
-  /// \see ConstString::StaticMemorySize ()
   size_t MemorySize() const;
 
   /// Change the file specified with a new path.
   ///
   /// Update the contents of this object with a new path. The path will be
   /// split up into a directory and filename and stored as uniqued string
   /// values for quick comparison and efficient memory usage.
   ///

lldb/source/Utility/ConstString.cpp

const char *GetConstTrimmedCStringWithLength(const char *cstr,
                                                size_t cstr_len) {
     if (cstr != nullptr) {
       const size_t trimmed_len = strnlen(cstr, cstr_len);
       return GetConstCStringWithLength(cstr, trimmed_len);
     }
     return nullptr;
   }
 
-  // Return the size in bytes that this object and any items in its collection
-  // of uniqued strings + data count values takes in memory.
-  size_t MemorySize() const {
-    size_t mem_size = sizeof(Pool);
-    for (const auto &pool : m_string_pools) {
-      llvm::sys::SmartScopedReader<false> rlock(pool.m_mutex);
-      for (const auto &entry : pool.m_string_map)
-        mem_size += sizeof(StringPoolEntryType) + entry.getKey().size();
-    }
-    return mem_size;
-  }
-
   ConstString::MemoryStats GetMemoryStats() const {
     ConstString::MemoryStats stats;
     for (const auto &pool : m_string_pools) {
       llvm::sys::SmartScopedReader<false> rlock(pool.m_mutex);
       const Allocator &alloc = pool.m_string_map.getAllocator();
       stats.bytes_total += alloc.getTotalMemory();
       stats.bytes_used += alloc.getBytesAllocated();
     }
void ConstString::SetCStringWithLength(const char *cstr, size_t cstr_len) {
   m_string = StringPool().GetConstCStringWithLength(cstr, cstr_len);
 }
 
 void ConstString::SetTrimmedCStringWithLength(const char *cstr,
                                               size_t cstr_len) {
   m_string = StringPool().GetConstTrimmedCStringWithLength(cstr, cstr_len);
 }
 
-size_t ConstString::StaticMemorySize() {
-  // Get the size of the static string pool
-  return StringPool().MemorySize();
-}
-
 ConstString::MemoryStats ConstString::GetMemoryStats() {
   return StringPool().GetMemoryStats();
 }
 
 void llvm::format_provider<ConstString>::format(const ConstString &CS,
                                                 llvm::raw_ostream &OS,
                                                 llvm::StringRef Options) {
   format_provider<StringRef>::format(CS.GetStringRef(), OS, Options);