Replace HashStringUsingDJB with llvm::djbHash

[labath]

Summary

The llvm function is equivalent to this one. Where possible I tried to
replace const char* with llvm::StringRef to avoid extra strlen
computations. In most places, I was able to track the c string back to
the ConstString it was created from.

This also removes the unused ExportTable class.

[aprantl]

include/lldb/Core/MappedHash.h

156 ↗

(On Diff #135339)

Yeah this looks like it was a dead end dating back to 2011.

source/Target/ObjCLanguageRuntime.cpp

49 ↗

(On Diff #135339)

m_hash_to_isa_map.insert({llvm::djbHash(class_name), isa});

[davide]

Thanks.

[JDevlieghere]

We probably want to have a test to ensure this stays in sync with the hashes we generate for object files and dSYMs?

[clayborg]

No need to add additional dSYM tests, because all dSYM tests will fail if the hashing isn't correct.

[JDevlieghere]

In D43596#1015848, @clayborg wrote:

No need to add additional dSYM tests, because all dSYM tests will fail if the hashing isn't correct.

Maybe I misunderstand, but D42740 suggested that this never worked (or maybe it did accidentally, because we ended up in the right bucket) for unicode characters?

[clayborg]

The only input we currently use this on is DWARF and I believe all DWARF strings are UTF8 so this should all work correctly, no?

[aprantl]

In D43596#1015903, @clayborg wrote:

The only input we currently use this on is DWARF and I believe all DWARF strings are UTF8 so this should all work correctly, no?

The hashing algorithms produced different hashes for characters with bit 7 set. That would apply for all UTF-8 characters that are outside of the 7-bit ascii range.

Jonas, do we have any tests in LLDB that try to lookup a variable with non-ASCII characters?

[labath]

This adds a test which looks up a type with unicode characters. I have verified
this test does not pass when run against a pre-D42740 compiler.

[aprantl]

Nice!

[amccarth]

lldb/trunk/packages/Python/lldbsuite/test/lang/c/unicode/TestUnicodeSymbols.py

13

Oops! Looks like this Python file got checked in with a mixture of tabs and spaces.

lldb/trunk/include/lldb/Core/MappedHash.h

 #include <functional>
 #include <map>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Stream.h"
+#include "llvm/Support/DJB.h"
 
 class MappedHash {
 public:
   enum HashFunctionType {
     eHashFunctionDJB = 0u // Daniel J Bernstein hash function that is also used
                           // by the ELF GNU_HASH sections
   };
 
-  static uint32_t HashStringUsingDJB(const char *s) {
-    uint32_t h = 5381;
-
-    for (unsigned char c = *s; c; c = *++s)
-      h = ((h << 5) + h) + c;
-
-    return h;
-  }
-
-  static uint32_t HashString(uint32_t hash_function, const char *s) {
-    if (!s)
-      return 0;
-
+  static uint32_t HashString(uint32_t hash_function, llvm::StringRef s) {
     switch (hash_function) {
     case MappedHash::eHashFunctionDJB:
-      return HashStringUsingDJB(s);
+      return llvm::djbHash(s);
 
     default:
       break;
     }
     llvm_unreachable("Invalid hash function index");
   }
 
   static const uint32_t HASH_MAGIC = 0x48415348u;
template <typename T> struct Header {
     //
     //        // Returns a buffer that contains a serialized version of this
     //        table
     //        // that must be freed with free().
     //        virtual void *
     //        Write (int fd);
   };
 
-  template <typename __KeyType, class __HeaderDataType, class __ValueType>
-  class ExportTable {
-  public:
-    typedef __HeaderDataType HeaderDataType;
-    typedef Header<HeaderDataType> HeaderType;
-    typedef __KeyType KeyType;
-    typedef __ValueType ValueType;
-
-    struct Entry {
-      uint32_t hash;
-      KeyType key;
-      ValueType value;
-    };
-
-    typedef std::vector<ValueType> ValueArrayType;
-
-    typedef std::map<KeyType, ValueArrayType> HashData;
-    // Map a name hash to one or more name infos
-    typedef std::map<uint32_t, HashData> HashToHashData;
-
-    virtual KeyType GetKeyForStringType(const char *cstr) const = 0;
-
-    virtual size_t GetByteSize(const HashData &key_to_key_values) = 0;
-
-    virtual bool WriteHashData(const HashData &hash_data,
-                               lldb_private::Stream &ostrm) = 0;
-    //
-    void AddEntry(const char *cstr, const ValueType &value) {
-      Entry entry;
-      entry.hash = MappedHash::HashString(eHashFunctionDJB, cstr);
-      entry.key = GetKeyForStringType(cstr);
-      entry.value = value;
-      m_entries.push_back(entry);
-    }
-
-    void Save(const HeaderDataType &header_data, lldb_private::Stream &ostrm) {
-      if (m_entries.empty())
-        return;
-
-      const uint32_t num_entries = m_entries.size();
-      uint32_t i = 0;
-
-      HeaderType header;
-
-      header.magic = HASH_MAGIC;
-      header.version = 1;
-      header.hash_function = eHashFunctionDJB;
-      header.bucket_count = 0;
-      header.hashes_count = 0;
-      header.prologue_length = header_data.GetByteSize();
-
-      // We need to figure out the number of unique hashes first before we can
-      // calculate the number of buckets we want to use.
-      typedef std::vector<uint32_t> hash_coll;
-      hash_coll unique_hashes;
-      unique_hashes.resize(num_entries);
-      for (i = 0; i < num_entries; ++i)
-        unique_hashes[i] = m_entries[i].hash;
-      std::sort(unique_hashes.begin(), unique_hashes.end());
-      hash_coll::iterator pos =
-          std::unique(unique_hashes.begin(), unique_hashes.end());
-      const size_t num_unique_hashes =
-          std::distance(unique_hashes.begin(), pos);
-
-      if (num_unique_hashes > 1024)
-        header.bucket_count = num_unique_hashes / 4;
-      else if (num_unique_hashes > 16)
-        header.bucket_count = num_unique_hashes / 2;
-      else
-        header.bucket_count = num_unique_hashes;
-      if (header.bucket_count == 0)
-        header.bucket_count = 1;
-
-      std::vector<HashToHashData> hash_buckets;
-      std::vector<uint32_t> hash_indexes(header.bucket_count, 0);
-      std::vector<uint32_t> hash_values;
-      std::vector<uint32_t> hash_offsets;
-      hash_buckets.resize(header.bucket_count);
-      uint32_t bucket_entry_empties = 0;
-      // StreamString hash_file_data(Stream::eBinary,
-      // dwarf->GetObjectFile()->GetAddressByteSize(),
-      // dwarf->GetObjectFile()->GetByteSize());
-
-      // Push all of the hashes into their buckets and create all bucket
-      // entries all populated with data.
-      for (i = 0; i < num_entries; ++i) {
-        const uint32_t hash = m_entries[i].hash;
-        const uint32_t bucket_idx = hash % header.bucket_count;
-        const uint32_t strp_offset = m_entries[i].str_offset;
-        const uint32_t die_offset = m_entries[i].die_offset;
-        hash_buckets[bucket_idx][hash][strp_offset].push_back(die_offset);
-      }
-
-      // Now for each bucket we write the bucket value which is the
-      // number of hashes and the hash index encoded into a single
-      // 32 bit unsigned integer.
-      for (i = 0; i < header.bucket_count; ++i) {
-        HashToHashData &bucket_entry = hash_buckets[i];
-
-        if (bucket_entry.empty()) {
-          // Empty bucket
-          ++bucket_entry_empties;
-          hash_indexes[i] = UINT32_MAX;
-        } else {
-          const uint32_t hash_value_index = hash_values.size();
-          uint32_t hash_count = 0;
-          typename HashToHashData::const_iterator pos, end = bucket_entry.end();
-          for (pos = bucket_entry.begin(); pos != end; ++pos) {
-            hash_values.push_back(pos->first);
-            hash_offsets.push_back(GetByteSize(pos->second));
-            ++hash_count;
-          }
-
-          hash_indexes[i] = hash_value_index;
-        }
-      }
-      header.hashes_count = hash_values.size();
-
-      // Write the header out now that we have the hash_count
-      header.Write(ostrm);
-
-      // Now for each bucket we write the start index of the hashes
-      // for the current bucket, or UINT32_MAX if the bucket is empty
-      for (i = 0; i < header.bucket_count; ++i) {
-        ostrm.PutHex32(hash_indexes[i]);
-      }
-
-      // Now we need to write out all of the hash values
-      for (i = 0; i < header.hashes_count; ++i) {
-        ostrm.PutHex32(hash_values[i]);
-      }
-
-      // Now we need to write out all of the hash data offsets,
-      // there is an offset for each hash in the hashes array
-      // that was written out above
-      for (i = 0; i < header.hashes_count; ++i) {
-        ostrm.PutHex32(hash_offsets[i]);
-      }
-
-      // Now we write the data for each hash and verify we got the offset
-      // correct above...
-      for (i = 0; i < header.bucket_count; ++i) {
-        HashToHashData &bucket_entry = hash_buckets[i];
-
-        typename HashToHashData::const_iterator pos, end = bucket_entry.end();
-        for (pos = bucket_entry.begin(); pos != end; ++pos) {
-          if (!bucket_entry.empty()) {
-            WriteHashData(pos->second);
-          }
-        }
-      }
-    }
-
-  protected:
-    typedef std::vector<Entry> collection;
-    collection m_entries;
-  };
-
   // A class for reading and using a saved hash table from a block of data
   // in memory
   template <typename __KeyType, class __HeaderType, class __HashData>
   class MemoryTable {
   public:
     typedef __HeaderType HeaderType;
     typedef __KeyType KeyType;
     typedef __HashData HashData;
public:
 
     uint32_t GetHashDataOffset(uint32_t hash_idx) const {
       uint32_t result = UINT32_MAX;
       if (m_hash_offsets && hash_idx < m_header.hashes_count)
         memcpy(&result, m_hash_offsets + hash_idx, sizeof(uint32_t));
       return result;
     }
 
-    bool Find(const char *name, Pair &pair) const {
-      if (!name || !name[0])
+    bool Find(llvm::StringRef name, Pair &pair) const {
+      if (name.empty())
         return false;
 
       if (IsValid()) {
         const uint32_t bucket_count = m_header.bucket_count;
         const uint32_t hash_count = m_header.hashes_count;
         const uint32_t hash_value =
             MappedHash::HashString(m_header.hash_function, name);
         const uint32_t bucket_idx = hash_value % bucket_count;
public:
     // match this string for the key, then "eResultKeyMismatch" should be
     // returned and all data for the current HashData must be consumed or
     // skipped and the "hash_data_offset_ptr" offset needs to be updated to
     // point to the next HashData. If the end of the HashData objects for
     // a given hash value have been reached, then "eResultEndOfHashData"
     // should be returned. If anything else goes wrong during parsing,
     // return "eResultError" and the corresponding "Find()" function will
     // be canceled and return false.
-    virtual Result GetHashDataForName(const char *name,
+    virtual Result GetHashDataForName(llvm::StringRef name,
                                       lldb::offset_t *hash_data_offset_ptr,
                                       Pair &pair) const = 0;
 
     const HeaderType &GetHeader() { return m_header; }
 
     void ForEach(
         std::function<bool(const HashData &hash_data)> const &callback) const {
       const size_t num_hash_offsets = m_header.hashes_count;

lldb/trunk/packages/Python/lldbsuite/test/lang/c/unicode/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+CFLAGS_EXTRAS += -finput-charset=UTF-8 -fextended-identifiers -std=c99
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/lang/c/unicode/TestUnicodeSymbols.py

+# coding=utf8
+import lldb
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+
+class TestUnicodeSymbols(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_union_members(self):
+        self.build()
+  spec = lldb.SBModuleSpec()
+  spec.SetFileSpec(lldb.SBFileSpec(self.getBuildArtifact("a.out")))
+  module = lldb.SBModule(spec)
+  self.assertTrue(module.IsValid())
+  mytype = module.FindFirstType("foobár")
+  self.assertTrue(mytype.IsValid())
+  self.assertTrue(mytype.IsPointerType())

lldb/trunk/packages/Python/lldbsuite/test/lang/c/unicode/main.c

+typedef void *foob\u00E1r;
+foob\u00E1r X = 0;
+int main() {
+  return (long)X;
+}

lldb/trunk/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

public:
     size_t
     AppendAllDIEsThatMatchingRegex(const lldb_private::RegularExpression &regex,
                                    DIEInfoArray &die_info_array) const;
 
     size_t AppendAllDIEsInRange(const uint32_t die_offset_start,
                                 const uint32_t die_offset_end,
                                 DIEInfoArray &die_info_array) const;
 
-    size_t FindByName(const char *name, DIEArray &die_offsets);
+    size_t FindByName(llvm::StringRef name, DIEArray &die_offsets);
 
-    size_t FindByNameAndTag(const char *name, const dw_tag_t tag,
+    size_t FindByNameAndTag(llvm::StringRef name, const dw_tag_t tag,
                             DIEArray &die_offsets);
 
-    size_t
-    FindByNameAndTagAndQualifiedNameHash(const char *name, const dw_tag_t tag,
-                                         const uint32_t qualified_name_hash,
-                                         DIEArray &die_offsets);
+    size_t FindByNameAndTagAndQualifiedNameHash(
+        llvm::StringRef name, const dw_tag_t tag,
+        const uint32_t qualified_name_hash, DIEArray &die_offsets);
 
-    size_t FindCompleteObjCClassByName(const char *name, DIEArray &die_offsets,
+    size_t FindCompleteObjCClassByName(llvm::StringRef name,
+                                       DIEArray &die_offsets,
                                        bool must_be_implementation);
 
   protected:
     Result AppendHashDataForRegularExpression(
         const lldb_private::RegularExpression &regex,
         lldb::offset_t *hash_data_offset_ptr, Pair &pair) const;
 
-    size_t FindByName(const char *name, DIEInfoArray &die_info_array);
+    size_t FindByName(llvm::StringRef name, DIEInfoArray &die_info_array);
 
-    Result GetHashDataForName(const char *name,
+    Result GetHashDataForName(llvm::StringRef name,
                               lldb::offset_t *hash_data_offset_ptr,
                               Pair &pair) const override;
 
     const lldb_private::DWARFDataExtractor &m_data;
     const lldb_private::DWARFDataExtractor &m_string_table;
     std::string m_name;
   };
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.cpp

if (count > 0) {
     }
   } else
     hash_data.clear();
   return true;
 }
 
 DWARFMappedHash::MemoryTable::Result
 DWARFMappedHash::MemoryTable::GetHashDataForName(
-    const char *name, lldb::offset_t *hash_data_offset_ptr, Pair &pair) const {
+    llvm::StringRef name, lldb::offset_t *hash_data_offset_ptr,
+    Pair &pair) const {
   pair.key = m_data.GetU32(hash_data_offset_ptr);
   pair.value.clear();
 
   // If the key is zero, this terminates our chain of HashData objects
   // for this hash value.
   if (pair.key == 0)
     return eResultEndOfHashData;
 
const size_t min_total_hash_data_size =
       count * m_header.header_data.GetMinimumHashDataByteSize();
   if (count > 0 &&
       m_data.ValidOffsetForDataOfSize(*hash_data_offset_ptr,
                                       min_total_hash_data_size)) {
     // We have at least one HashData entry, and we have enough
     // data to parse at least "count" HashData entries.
 
     // First make sure the entire C string matches...
-    const bool match = strcmp(name, strp_cstr) == 0;
+    const bool match = name == strp_cstr;
 
     if (!match && m_header.header_data.HashDataHasFixedByteSize()) {
       // If the string doesn't match and we have fixed size data,
       // we can just add the total byte size of all HashData objects
       // to the hash data offset and be done...
       *hash_data_offset_ptr += min_total_hash_data_size;
     } else {
       // If the string does match, or we don't have fixed size data
while (!done && hash_data_offset != UINT32_MAX) {
             die_info_array.push_back(die_info);
         }
       }
     }
   }
   return die_info_array.size();
 }
 
-size_t DWARFMappedHash::MemoryTable::FindByName(const char *name,
+size_t DWARFMappedHash::MemoryTable::FindByName(llvm::StringRef name,
                                                 DIEArray &die_offsets) {
-  if (!name || !name[0])
+  if (name.empty())
     return 0;
 
   DIEInfoArray die_info_array;
   if (FindByName(name, die_info_array))
     DWARFMappedHash::ExtractDIEArray(die_info_array, die_offsets);
   return die_info_array.size();
 }
 
-size_t DWARFMappedHash::MemoryTable::FindByNameAndTag(const char *name,
+size_t DWARFMappedHash::MemoryTable::FindByNameAndTag(llvm::StringRef name,
                                                       const dw_tag_t tag,
                                                       DIEArray &die_offsets) {
   DIEInfoArray die_info_array;
   if (FindByName(name, die_info_array))
     DWARFMappedHash::ExtractDIEArray(die_info_array, tag, die_offsets);
   return die_info_array.size();
 }
 
 size_t DWARFMappedHash::MemoryTable::FindByNameAndTagAndQualifiedNameHash(
-    const char *name, const dw_tag_t tag, const uint32_t qualified_name_hash,
-    DIEArray &die_offsets) {
+    llvm::StringRef name, const dw_tag_t tag,
+    const uint32_t qualified_name_hash, DIEArray &die_offsets) {
   DIEInfoArray die_info_array;
   if (FindByName(name, die_info_array))
     DWARFMappedHash::ExtractDIEArray(die_info_array, tag, qualified_name_hash,
                                      die_offsets);
   return die_info_array.size();
 }
 
 size_t DWARFMappedHash::MemoryTable::FindCompleteObjCClassByName(
-    const char *name, DIEArray &die_offsets, bool must_be_implementation) {
+    llvm::StringRef name, DIEArray &die_offsets, bool must_be_implementation) {
   DIEInfoArray die_info_array;
   if (FindByName(name, die_info_array)) {
     if (must_be_implementation &&
         GetHeader().header_data.ContainsAtom(eAtomTypeTypeFlags)) {
       // If we have two atoms, then we have the DIE offset and
       // the type flags so we can find the objective C class
       // efficiently.
       DWARFMappedHash::ExtractTypesFromDIEArray(die_info_array, UINT32_MAX,
                                                 eTypeFlagClassIsImplementation,
                                                 die_offsets);
     } else {
       // We don't only want the one true definition, so try and see
       // what we can find, and only return class or struct DIEs.
       // If we do have the full implementation, then return it alone,
       // else return all possible matches.
       const bool return_implementation_only_if_available = true;
       DWARFMappedHash::ExtractClassOrStructDIEArray(
           die_info_array, return_implementation_only_if_available, die_offsets);
     }
   }
   return die_offsets.size();
 }
 
-size_t DWARFMappedHash::MemoryTable::FindByName(const char *name,
+size_t DWARFMappedHash::MemoryTable::FindByName(llvm::StringRef name,
                                                 DIEInfoArray &die_info_array) {
-  if (!name || !name[0])
+  if (name.empty())
     return 0;
 
   Pair kv_pair;
   size_t old_size = die_info_array.size();
   if (Find(name, kv_pair)) {
     die_info_array.swap(kv_pair.value);
     return die_info_array.size() - old_size;
   }
   return 0;
 }

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFCompileUnit *dwarf_cu,
   return (CompileUnit *)dwarf_cu->GetUserData();
 }
 
 size_t SymbolFileDWARF::GetObjCMethodDIEOffsets(ConstString class_name,
                                                 DIEArray &method_die_offsets) {
   method_die_offsets.clear();
   if (m_using_apple_tables) {
     if (m_apple_objc_ap.get())
-      m_apple_objc_ap->FindByName(class_name.GetCString(), method_die_offsets);
+      m_apple_objc_ap->FindByName(class_name.GetStringRef(),
+                                  method_die_offsets);
   } else {
     if (!m_indexed)
       Index();
 
     m_objc_class_selectors_index.Find(class_name, method_die_offsets);
   }
   return method_die_offsets.size();
 }
if (m_apple_names_ap.get()) {
       const char *name_cstr = name.GetCString();
       llvm::StringRef basename;
       llvm::StringRef context;
 
       if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
                                                           basename))
         basename = name_cstr;
 
-      m_apple_names_ap->FindByName(basename.data(), die_offsets);
+      m_apple_names_ap->FindByName(basename, die_offsets);
     }
   } else {
     // Index the DWARF if we haven't already
     if (!m_indexed)
       Index();
 
     m_global_index.Find(name, die_offsets);
   }
SymbolFileDWARF::FindFunctions(const ConstString &name,
 
   // If name is empty then we won't find anything.
   if (name.IsEmpty())
     return 0;
 
   // Remember how many sc_list are in the list before we search in case
   // we are appending the results to a variable list.
 
-  const char *name_cstr = name.GetCString();
-
   const uint32_t original_size = sc_list.GetSize();
 
   DWARFDebugInfo *info = DebugInfo();
   if (info == NULL)
     return 0;
 
   std::set<const DWARFDebugInfoEntry *> resolved_dies;
   if (m_using_apple_tables) {
     if (m_apple_names_ap.get()) {
 
       DIEArray die_offsets;
 
       uint32_t num_matches = 0;
 
       if (name_type_mask & eFunctionNameTypeFull) {
         // If they asked for the full name, match what they typed.  At some
         // point we may
         // want to canonicalize this (strip double spaces, etc.  For now, we
         // just add all the
         // dies that we find by exact match.
-        num_matches = m_apple_names_ap->FindByName(name_cstr, die_offsets);
+        num_matches =
+            m_apple_names_ap->FindByName(name.GetStringRef(), die_offsets);
         for (uint32_t i = 0; i < num_matches; i++) {
           const DIERef &die_ref = die_offsets[i];
           DWARFDIE die = info->GetDIE(die_ref);
           if (die) {
             if (!DIEInDeclContext(parent_decl_ctx, die))
               continue; // The containing decl contexts don't match
 
             if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
               if (ResolveFunction(die, include_inlines, sc_list))
                 resolved_dies.insert(die.GetDIE());
             }
           } else {
             GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
                 "the DWARF debug information has been modified (.apple_names "
                 "accelerator table had bad die 0x%8.8x for '%s')",
-                die_ref.die_offset, name_cstr);
+                die_ref.die_offset, name.GetCString());
           }
         }
       }
 
       if (name_type_mask & eFunctionNameTypeSelector) {
         if (parent_decl_ctx && parent_decl_ctx->IsValid())
           return 0; // no selectors in namespaces
 
-        num_matches = m_apple_names_ap->FindByName(name_cstr, die_offsets);
+        num_matches =
+            m_apple_names_ap->FindByName(name.GetStringRef(), die_offsets);
         // Now make sure these are actually ObjC methods.  In this case we can
         // simply look up the name,
         // and if it is an ObjC method name, we're good.
 
         for (uint32_t i = 0; i < num_matches; i++) {
           const DIERef &die_ref = die_offsets[i];
           DWARFDIE die = info->GetDIE(die_ref);
           if (die) {
             const char *die_name = die.GetName();
             if (ObjCLanguage::IsPossibleObjCMethodName(die_name)) {
               if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
                 if (ResolveFunction(die, include_inlines, sc_list))
                   resolved_dies.insert(die.GetDIE());
               }
             }
           } else {
             GetObjectFile()->GetModule()->ReportError(
                 "the DWARF debug information has been modified (.apple_names "
                 "accelerator table had bad die 0x%8.8x for '%s')",
-                die_ref.die_offset, name_cstr);
+                die_ref.die_offset, name.GetCString());
           }
         }
         die_offsets.clear();
       }
 
       if (((name_type_mask & eFunctionNameTypeMethod) && !parent_decl_ctx) ||
           name_type_mask & eFunctionNameTypeBase) {
         // The apple_names table stores just the "base name" of C++ methods in
         // the table.  So we have to
         // extract the base name, look that up, and if there is any other
         // information in the name we were
         // passed in we have to post-filter based on that.
 
         // FIXME: Arrange the logic above so that we don't calculate the base
         // name twice:
-        num_matches = m_apple_names_ap->FindByName(name_cstr, die_offsets);
+        num_matches =
+            m_apple_names_ap->FindByName(name.GetStringRef(), die_offsets);
 
         for (uint32_t i = 0; i < num_matches; i++) {
           const DIERef &die_ref = die_offsets[i];
           DWARFDIE die = info->GetDIE(die_ref);
           if (die) {
             if (!DIEInDeclContext(parent_decl_ctx, die))
               continue; // The containing decl contexts don't match
 
if (m_apple_names_ap.get()) {
               }
               if (keep_die)
                 resolved_dies.insert(die.GetDIE());
             }
           } else {
             GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
                 "the DWARF debug information has been modified (.apple_names "
                 "accelerator table had bad die 0x%8.8x for '%s')",
-                die_ref.die_offset, name_cstr);
+                die_ref.die_offset, name.GetCString());
           }
         }
         die_offsets.clear();
       }
     }
   } else {
 
     // Index the DWARF if we haven't already
uint32_t SymbolFileDWARF::FindTypes(
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return 0;
 
   DIEArray die_offsets;
 
   if (m_using_apple_tables) {
     if (m_apple_types_ap.get()) {
-      const char *name_cstr = name.GetCString();
-      m_apple_types_ap->FindByName(name_cstr, die_offsets);
+      m_apple_types_ap->FindByName(name.GetStringRef(), die_offsets);
     }
   } else {
     if (!m_indexed)
       Index();
 
     m_type_index.Find(name, die_offsets);
   }
 
size_t SymbolFileDWARF::FindTypes(const std::vector<CompilerContext> &context,
 
   ConstString name = context.back().name;
 
   if (!name)
     return 0;
 
   if (m_using_apple_tables) {
     if (m_apple_types_ap.get()) {
-      const char *name_cstr = name.GetCString();
-      m_apple_types_ap->FindByName(name_cstr, die_offsets);
+      m_apple_types_ap->FindByName(name.GetStringRef(), die_offsets);
     }
   } else {
     if (!m_indexed)
       Index();
 
     m_type_index.Find(name, die_offsets);
   }
 
SymbolFileDWARF::FindNamespace(const SymbolContext &sc, const ConstString &name,
   DWARFDebugInfo *info = DebugInfo();
   if (info) {
     DIEArray die_offsets;
 
     // Index if we already haven't to make sure the compile units
     // get indexed and make their global DIE index list
     if (m_using_apple_tables) {
       if (m_apple_namespaces_ap.get()) {
-        const char *name_cstr = name.GetCString();
-        m_apple_namespaces_ap->FindByName(name_cstr, die_offsets);
+        m_apple_namespaces_ap->FindByName(name.GetStringRef(), die_offsets);
       }
     } else {
       if (!m_indexed)
         Index();
 
       m_namespace_index.Find(name, die_offsets);
     }
 
TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
 
   if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
     return type_sp;
 
   DIEArray die_offsets;
 
   if (m_using_apple_tables) {
     if (m_apple_types_ap.get()) {
-      const char *name_cstr = type_name.GetCString();
-      m_apple_types_ap->FindCompleteObjCClassByName(name_cstr, die_offsets,
-                                                    must_be_implementation);
+      m_apple_types_ap->FindCompleteObjCClassByName(
+          type_name.GetStringRef(), die_offsets, must_be_implementation);
     }
   } else {
     if (!m_indexed)
       Index();
 
     m_type_index.Find(type_name, die_offsets);
   }
 
if (type_name) {
           const bool has_tag =
               m_apple_types_ap->GetHeader().header_data.ContainsAtom(
                   DWARFMappedHash::eAtomTypeTag);
           const bool has_qualified_name_hash =
               m_apple_types_ap->GetHeader().header_data.ContainsAtom(
                   DWARFMappedHash::eAtomTypeQualNameHash);
           if (has_tag && has_qualified_name_hash) {
             const char *qualified_name = dwarf_decl_ctx.GetQualifiedName();
-            const uint32_t qualified_name_hash =
-                MappedHash::HashStringUsingDJB(qualified_name);
+            const uint32_t qualified_name_hash = llvm::djbHash(qualified_name);
             if (log)
               GetObjectFile()->GetModule()->LogMessage(
                   log, "FindByNameAndTagAndQualifiedNameHash()");
             m_apple_types_ap->FindByNameAndTagAndQualifiedNameHash(
-                type_name.GetCString(), tag, qualified_name_hash, die_offsets);
+                type_name.GetStringRef(), tag, qualified_name_hash,
+                die_offsets);
           } else if (has_tag) {
             if (log)
               GetObjectFile()->GetModule()->LogMessage(log,
                                                        "FindByNameAndTag()");
-            m_apple_types_ap->FindByNameAndTag(type_name.GetCString(), tag,
+            m_apple_types_ap->FindByNameAndTag(type_name.GetStringRef(), tag,
                                                die_offsets);
           } else {
-            m_apple_types_ap->FindByName(type_name.GetCString(), die_offsets);
+            m_apple_types_ap->FindByName(type_name.GetStringRef(), die_offsets);
           }
         }
       } else {
         if (!m_indexed)
           Index();
 
         m_type_index.Find(type_name, die_offsets);
       }

lldb/trunk/source/Target/ObjCLanguageRuntime.cpp

 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Timer.h"
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/DJB.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 ObjCLanguageRuntime::~ObjCLanguageRuntime() {}
 
 ObjCLanguageRuntime::ObjCLanguageRuntime(Process *process)
     : LanguageRuntime(process), m_impl_cache(),
       m_has_new_literals_and_indexing(eLazyBoolCalculate),
       m_isa_to_descriptor(), m_hash_to_isa_map(), m_type_size_cache(),
       m_isa_to_descriptor_stop_id(UINT32_MAX), m_complete_class_cache(),
       m_negative_complete_class_cache() {}
 
 bool ObjCLanguageRuntime::AddClass(ObjCISA isa,
                                    const ClassDescriptorSP &descriptor_sp,
                                    const char *class_name) {
   if (isa != 0) {
     m_isa_to_descriptor[isa] = descriptor_sp;
     // class_name is assumed to be valid
-    m_hash_to_isa_map.insert(
-        std::make_pair(MappedHash::HashStringUsingDJB(class_name), isa));
+    m_hash_to_isa_map.insert(std::make_pair(llvm::djbHash(class_name), isa));
     return true;
   }
   return false;
 }
 
 void ObjCLanguageRuntime::AddToMethodCache(lldb::addr_t class_addr,
                                            lldb::addr_t selector,
                                            lldb::addr_t impl_addr) {
if (m_hash_to_isa_map.empty()) {
       for (ISAToDescriptorIterator pos = m_isa_to_descriptor.begin();
            pos != end; ++pos) {
         if (pos->second->GetClassName() == name)
           return pos;
       }
     } else {
       // Name hashes were provided, so use them to efficiently lookup name to
       // isa/descriptor
-      const uint32_t name_hash =
-          MappedHash::HashStringUsingDJB(name.GetCString());
+      const uint32_t name_hash = llvm::djbHash(name.GetStringRef());
       std::pair<HashToISAIterator, HashToISAIterator> range =
           m_hash_to_isa_map.equal_range(name_hash);
       for (HashToISAIterator range_pos = range.first; range_pos != range.second;
            ++range_pos) {
         ISAToDescriptorIterator pos =
             m_isa_to_descriptor.find(range_pos->second);
         if (pos != m_isa_to_descriptor.end()) {
           if (pos->second->GetClassName() == name)