]> granicus.if.org Git - clang/commitdiff
Remove OnDiskHashTable.h, since it's been moved to llvm
authorJustin Bogner <mail@justinbogner.com>
Fri, 18 Apr 2014 19:57:06 +0000 (19:57 +0000)
committerJustin Bogner <mail@justinbogner.com>
Fri, 18 Apr 2014 19:57:06 +0000 (19:57 +0000)
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@206637 91177308-0d34-0410-b5e6-96231b3b80d8

include/clang/Basic/OnDiskHashTable.h [deleted file]
include/clang/Serialization/ASTReader.h
include/clang/Serialization/Module.h
lib/Frontend/CacheTokens.cpp
lib/Lex/PTHLexer.cpp
lib/Serialization/ASTReaderInternals.h
lib/Serialization/ASTWriter.cpp
lib/Serialization/GlobalModuleIndex.cpp

diff --git a/include/clang/Basic/OnDiskHashTable.h b/include/clang/Basic/OnDiskHashTable.h
deleted file mode 100644 (file)
index 1a9a96a..0000000
+++ /dev/null
@@ -1,455 +0,0 @@
-//===--- OnDiskHashTable.h - On-Disk Hash Table Implementation --*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Defines facilities for reading and writing on-disk hash tables.
-///
-//===----------------------------------------------------------------------===//
-#ifndef LLVM_CLANG_BASIC_ON_DISK_HASH_TABLE_H
-#define LLVM_CLANG_BASIC_ON_DISK_HASH_TABLE_H
-
-#include "clang/Basic/LLVM.h"
-#include "llvm/Support/Allocator.h"
-#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/EndianStream.h"
-#include "llvm/Support/Host.h"
-#include "llvm/Support/MathExtras.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cassert>
-#include <cstdlib>
-
-namespace clang {
-
-namespace io {
-
-typedef uint32_t Offset;
-
-inline void Pad(raw_ostream& Out, unsigned A) {
-  using namespace llvm::support;
-  Offset off = (Offset) Out.tell();
-  for (uint32_t n = llvm::OffsetToAlignment(off, A); n; --n)
-    endian::Writer<little>(Out).write<uint8_t>(0);
-}
-
-} // end namespace io
-
-template<typename Info>
-class OnDiskChainedHashTableGenerator {
-  unsigned NumBuckets;
-  unsigned NumEntries;
-  llvm::BumpPtrAllocator BA;
-
-  class Item {
-  public:
-    typename Info::key_type key;
-    typename Info::data_type data;
-    Item *next;
-    const uint32_t hash;
-
-    Item(typename Info::key_type_ref k, typename Info::data_type_ref d,
-         Info &InfoObj)
-    : key(k), data(d), next(0), hash(InfoObj.ComputeHash(k)) {}
-  };
-
-  class Bucket {
-  public:
-    io::Offset off;
-    Item* head;
-    unsigned length;
-
-    Bucket() {}
-  };
-
-  Bucket* Buckets;
-
-private:
-  void insert(Bucket* b, size_t size, Item* E) {
-    unsigned idx = E->hash & (size - 1);
-    Bucket& B = b[idx];
-    E->next = B.head;
-    ++B.length;
-    B.head = E;
-  }
-
-  void resize(size_t newsize) {
-    Bucket* newBuckets = (Bucket*) std::calloc(newsize, sizeof(Bucket));
-    // Populate newBuckets with the old entries.
-    for (unsigned i = 0; i < NumBuckets; ++i)
-      for (Item* E = Buckets[i].head; E ; ) {
-        Item* N = E->next;
-        E->next = 0;
-        insert(newBuckets, newsize, E);
-        E = N;
-      }
-
-    free(Buckets);
-    NumBuckets = newsize;
-    Buckets = newBuckets;
-  }
-
-public:
-
-  void insert(typename Info::key_type_ref key,
-              typename Info::data_type_ref data) {
-    Info InfoObj;
-    insert(key, data, InfoObj);
-  }
-
-  void insert(typename Info::key_type_ref key,
-              typename Info::data_type_ref data, Info &InfoObj) {
-
-    ++NumEntries;
-    if (4*NumEntries >= 3*NumBuckets) resize(NumBuckets*2);
-    insert(Buckets, NumBuckets, new (BA.Allocate<Item>()) Item(key, data,
-                                                               InfoObj));
-  }
-
-  io::Offset Emit(raw_ostream &out) {
-    Info InfoObj;
-    return Emit(out, InfoObj);
-  }
-
-  io::Offset Emit(raw_ostream &out, Info &InfoObj) {
-    using namespace llvm::support;
-    endian::Writer<little> LE(out);
-
-    // Emit the payload of the table.
-    for (unsigned i = 0; i < NumBuckets; ++i) {
-      Bucket& B = Buckets[i];
-      if (!B.head) continue;
-
-      // Store the offset for the data of this bucket.
-      B.off = out.tell();
-      assert(B.off && "Cannot write a bucket at offset 0. Please add padding.");
-
-      // Write out the number of items in the bucket.
-      LE.write<uint16_t>(B.length);
-      assert(B.length != 0  && "Bucket has a head but zero length?");
-
-      // Write out the entries in the bucket.
-      for (Item *I = B.head; I ; I = I->next) {
-        LE.write<uint32_t>(I->hash);
-        const std::pair<unsigned, unsigned>& Len =
-          InfoObj.EmitKeyDataLength(out, I->key, I->data);
-        InfoObj.EmitKey(out, I->key, Len.first);
-        InfoObj.EmitData(out, I->key, I->data, Len.second);
-      }
-    }
-
-    // Emit the hashtable itself.
-    io::Pad(out, 4);
-    io::Offset TableOff = out.tell();
-    LE.write<uint32_t>(NumBuckets);
-    LE.write<uint32_t>(NumEntries);
-    for (unsigned i = 0; i < NumBuckets; ++i)
-      LE.write<uint32_t>(Buckets[i].off);
-
-    return TableOff;
-  }
-
-  OnDiskChainedHashTableGenerator() {
-    NumEntries = 0;
-    NumBuckets = 64;
-    // Note that we do not need to run the constructors of the individual
-    // Bucket objects since 'calloc' returns bytes that are all 0.
-    Buckets = (Bucket*) std::calloc(NumBuckets, sizeof(Bucket));
-  }
-
-  ~OnDiskChainedHashTableGenerator() {
-    std::free(Buckets);
-  }
-};
-
-template <typename Info> class OnDiskChainedHashTable {
-  const unsigned NumBuckets;
-  const unsigned NumEntries;
-  const unsigned char *const Buckets;
-  const unsigned char *const Base;
-  Info InfoObj;
-
-public:
-  typedef typename Info::internal_key_type internal_key_type;
-  typedef typename Info::external_key_type external_key_type;
-  typedef typename Info::data_type         data_type;
-
-  OnDiskChainedHashTable(unsigned NumBuckets, unsigned NumEntries,
-                         const unsigned char *Buckets,
-                         const unsigned char *Base,
-                         const Info &InfoObj = Info())
-      : NumBuckets(NumBuckets), NumEntries(NumEntries), Buckets(Buckets),
-        Base(Base), InfoObj(InfoObj) {
-    assert((reinterpret_cast<uintptr_t>(Buckets) & 0x3) == 0 &&
-           "'buckets' must have a 4-byte alignment");
-  }
-
-  unsigned getNumBuckets() const { return NumBuckets; }
-  unsigned getNumEntries() const { return NumEntries; }
-  const unsigned char *getBase() const { return Base; }
-  const unsigned char *getBuckets() const { return Buckets; }
-
-  bool isEmpty() const { return NumEntries == 0; }
-
-  class iterator {
-    internal_key_type Key;
-    const unsigned char *const Data;
-    const unsigned Len;
-    Info *InfoObj;
-
-  public:
-    iterator() : Data(0), Len(0) {}
-    iterator(const internal_key_type K, const unsigned char *D, unsigned L,
-             Info *InfoObj)
-        : Key(K), Data(D), Len(L), InfoObj(InfoObj) {}
-
-    data_type operator*() const { return InfoObj->ReadData(Key, Data, Len); }
-    bool operator==(const iterator &X) const { return X.Data == Data; }
-    bool operator!=(const iterator &X) const { return X.Data != Data; }
-  };
-
-  iterator find(const external_key_type &EKey, Info *InfoPtr = 0) {
-    if (!InfoPtr)
-      InfoPtr = &InfoObj;
-
-    using namespace llvm::support;
-    const internal_key_type &IKey = InfoObj.GetInternalKey(EKey);
-    unsigned KeyHash = InfoObj.ComputeHash(IKey);
-
-    // Each bucket is just a 32-bit offset into the hash table file.
-    unsigned Idx = KeyHash & (NumBuckets - 1);
-    const unsigned char *Bucket = Buckets + sizeof(uint32_t) * Idx;
-
-    unsigned Offset = endian::readNext<uint32_t, little, aligned>(Bucket);
-    if (Offset == 0)
-      return iterator(); // Empty bucket.
-    const unsigned char *Items = Base + Offset;
-
-    // 'Items' starts with a 16-bit unsigned integer representing the
-    // number of items in this bucket.
-    unsigned Len = endian::readNext<uint16_t, little, unaligned>(Items);
-
-    for (unsigned i = 0; i < Len; ++i) {
-      // Read the hash.
-      uint32_t ItemHash = endian::readNext<uint32_t, little, unaligned>(Items);
-
-      // Determine the length of the key and the data.
-      const std::pair<unsigned, unsigned> &L = Info::ReadKeyDataLength(Items);
-      unsigned ItemLen = L.first + L.second;
-
-      // Compare the hashes.  If they are not the same, skip the entry entirely.
-      if (ItemHash != KeyHash) {
-        Items += ItemLen;
-        continue;
-      }
-
-      // Read the key.
-      const internal_key_type &X =
-          InfoPtr->ReadKey((const unsigned char *const)Items, L.first);
-
-      // If the key doesn't match just skip reading the value.
-      if (!InfoPtr->EqualKey(X, IKey)) {
-        Items += ItemLen;
-        continue;
-      }
-
-      // The key matches!
-      return iterator(X, Items + L.first, L.second, InfoPtr);
-    }
-
-    return iterator();
-  }
-
-  iterator end() const { return iterator(); }
-
-  Info &getInfoObj() { return InfoObj; }
-
-  static OnDiskChainedHashTable* Create(const unsigned char* Buckets,
-                                        const unsigned char* const Base,
-                                        const Info &InfoObj = Info()) {
-    using namespace llvm::support;
-    assert(Buckets > Base);
-    assert((reinterpret_cast<uintptr_t>(Buckets) & 0x3) == 0 &&
-           "buckets should be 4-byte aligned.");
-
-    unsigned NumBuckets = endian::readNext<uint32_t, little, aligned>(Buckets);
-    unsigned NumEntries = endian::readNext<uint32_t, little, aligned>(Buckets);
-    return new OnDiskChainedHashTable<Info>(NumBuckets, NumEntries, Buckets,
-                                            Base, InfoObj);
-  }
-};
-
-template<typename Info>
-class OnDiskIterableChainedHashTable : public OnDiskChainedHashTable<Info> {
-  const unsigned char *Payload;
-
-public:
-  typedef OnDiskChainedHashTable<Info>          base_type;
-  typedef typename base_type::internal_key_type internal_key_type;
-  typedef typename base_type::external_key_type external_key_type;
-  typedef typename base_type::data_type         data_type;
-
-  OnDiskIterableChainedHashTable(unsigned NumBuckets, unsigned NumEntries,
-                                 const unsigned char *Buckets,
-                                 const unsigned char *Payload,
-                                 const unsigned char *Base,
-                                 const Info &InfoObj = Info())
-      : base_type(NumBuckets, NumEntries, Buckets, Base, InfoObj),
-        Payload(Payload) {}
-
-  /// \brief Iterates over all of the keys in the table.
-  class key_iterator {
-    const unsigned char *Ptr;
-    unsigned NumItemsInBucketLeft;
-    unsigned NumEntriesLeft;
-    Info *InfoObj;
-
-  public:
-    typedef external_key_type value_type;
-
-    key_iterator(const unsigned char *const Ptr, unsigned NumEntries,
-                 Info *InfoObj)
-        : Ptr(Ptr), NumItemsInBucketLeft(0), NumEntriesLeft(NumEntries),
-          InfoObj(InfoObj) {}
-    key_iterator()
-        : Ptr(0), NumItemsInBucketLeft(0), NumEntriesLeft(0), InfoObj(0) {}
-
-    friend bool operator==(const key_iterator &X, const key_iterator &Y) {
-      return X.NumEntriesLeft == Y.NumEntriesLeft;
-    }
-    friend bool operator!=(const key_iterator &X, const key_iterator &Y) {
-      return X.NumEntriesLeft != Y.NumEntriesLeft;
-    }
-
-    key_iterator &operator++() { // Preincrement
-      using namespace llvm::support;
-      if (!NumItemsInBucketLeft) {
-        // 'Items' starts with a 16-bit unsigned integer representing the
-        // number of items in this bucket.
-        NumItemsInBucketLeft =
-            endian::readNext<uint16_t, little, unaligned>(Ptr);
-      }
-      Ptr += 4; // Skip the hash.
-      // Determine the length of the key and the data.
-      const std::pair<unsigned, unsigned> &L = Info::ReadKeyDataLength(Ptr);
-      Ptr += L.first + L.second;
-      assert(NumItemsInBucketLeft);
-      --NumItemsInBucketLeft;
-      assert(NumEntriesLeft);
-      --NumEntriesLeft;
-      return *this;
-    }
-    key_iterator operator++(int) { // Postincrement
-      key_iterator tmp = *this; ++*this; return tmp;
-    }
-
-    value_type operator*() const {
-      const unsigned char *LocalPtr = Ptr;
-      if (!NumItemsInBucketLeft)
-        LocalPtr += 2; // number of items in bucket
-      LocalPtr += 4;   // Skip the hash.
-
-      // Determine the length of the key and the data.
-      const std::pair<unsigned, unsigned> &L =
-          Info::ReadKeyDataLength(LocalPtr);
-
-      // Read the key.
-      const internal_key_type &Key = InfoObj->ReadKey(LocalPtr, L.first);
-      return InfoObj->GetExternalKey(Key);
-    }
-  };
-
-  key_iterator key_begin() {
-    return key_iterator(Payload, this->getNumEntries(), &this->getInfoObj());
-  }
-  key_iterator key_end() { return key_iterator(); }
-
-  /// \brief Iterates over all the entries in the table, returning the data.
-  class data_iterator {
-    const unsigned char *Ptr;
-    unsigned NumItemsInBucketLeft;
-    unsigned NumEntriesLeft;
-    Info *InfoObj;
-
-  public:
-    typedef data_type value_type;
-
-    data_iterator(const unsigned char *const Ptr, unsigned NumEntries,
-                  Info *InfoObj)
-        : Ptr(Ptr), NumItemsInBucketLeft(0), NumEntriesLeft(NumEntries),
-          InfoObj(InfoObj) {}
-    data_iterator()
-        : Ptr(0), NumItemsInBucketLeft(0), NumEntriesLeft(0), InfoObj(0) {}
-
-    bool operator==(const data_iterator &X) const {
-      return X.NumEntriesLeft == NumEntriesLeft;
-    }
-    bool operator!=(const data_iterator &X) const {
-      return X.NumEntriesLeft != NumEntriesLeft;
-    }
-
-    data_iterator &operator++() { // Preincrement
-      using namespace llvm::support;
-      if (!NumItemsInBucketLeft) {
-        // 'Items' starts with a 16-bit unsigned integer representing the
-        // number of items in this bucket.
-        NumItemsInBucketLeft =
-            endian::readNext<uint16_t, little, unaligned>(Ptr);
-      }
-      Ptr += 4; // Skip the hash.
-      // Determine the length of the key and the data.
-      const std::pair<unsigned, unsigned> &L = Info::ReadKeyDataLength(Ptr);
-      Ptr += L.first + L.second;
-      assert(NumItemsInBucketLeft);
-      --NumItemsInBucketLeft;
-      assert(NumEntriesLeft);
-      --NumEntriesLeft;
-      return *this;
-    }
-    data_iterator operator++(int) { // Postincrement
-      data_iterator tmp = *this; ++*this; return tmp;
-    }
-
-    value_type operator*() const {
-      const unsigned char *LocalPtr = Ptr;
-      if (!NumItemsInBucketLeft)
-        LocalPtr += 2; // number of items in bucket
-      LocalPtr += 4;   // Skip the hash.
-
-      // Determine the length of the key and the data.
-      const std::pair<unsigned, unsigned> &L =
-          Info::ReadKeyDataLength(LocalPtr);
-
-      // Read the key.
-      const internal_key_type &Key = InfoObj->ReadKey(LocalPtr, L.first);
-      return InfoObj->ReadData(Key, LocalPtr + L.first, L.second);
-    }
-  };
-
-  data_iterator data_begin() {
-    return data_iterator(Payload, this->getNumEntries(), &this->getInfoObj());
-  }
-  data_iterator data_end() { return data_iterator(); }
-
-  static OnDiskIterableChainedHashTable *
-  Create(const unsigned char *Buckets, const unsigned char *const Payload,
-         const unsigned char *const Base, const Info &InfoObj = Info()) {
-    using namespace llvm::support;
-    assert(Buckets > Base);
-    assert((reinterpret_cast<uintptr_t>(Buckets) & 0x3) == 0 &&
-           "buckets should be 4-byte aligned.");
-
-    unsigned NumBuckets = endian::readNext<uint32_t, little, aligned>(Buckets);
-    unsigned NumEntries = endian::readNext<uint32_t, little, aligned>(Buckets);
-    return new OnDiskIterableChainedHashTable<Info>(
-        NumBuckets, NumEntries, Buckets, Payload, Base, InfoObj);
-  }
-};
-
-} // end namespace clang
-
-#endif
index ffd72752557be9fc7394ea278e4f3c9a7cfc01d0..13d3ff231778f0dfe7cb3c9a0ad376638438b236 100644 (file)
@@ -259,7 +259,7 @@ class ReadMethodPoolVisitor;
 namespace reader {
   class ASTIdentifierLookupTrait;
   /// \brief The on-disk hash table used for the DeclContext's Name lookup table.
-  typedef OnDiskIterableChainedHashTable<ASTDeclContextNameLookupTrait>
+  typedef llvm::OnDiskIterableChainedHashTable<ASTDeclContextNameLookupTrait>
     ASTDeclContextNameLookupTable;
 }
 
index 0c551b7f4b580aedceae9490bdf92bfb68b16a8d..49520390559b55c4de55760739376d6d3a741c5a 100644 (file)
 #include <memory>
 #include <string>
 
+namespace llvm {
+template <typename Info> class OnDiskChainedHashTable;
+template <typename Info> class OnDiskIterableChainedHashTable;
+}
+
 namespace clang {
 
 class FileEntry;
 class DeclContext;
 class Module;
-template<typename Info> class OnDiskChainedHashTable;
-template<typename Info> class OnDiskIterableChainedHashTable;
 
 namespace serialization {
 
@@ -50,7 +53,7 @@ struct DeclContextInfo {
   DeclContextInfo()
     : NameLookupTableData(), LexicalDecls(), NumLexicalDecls() {}
 
-  OnDiskIterableChainedHashTable<reader::ASTDeclContextNameLookupTrait>
+  llvm::OnDiskIterableChainedHashTable<reader::ASTDeclContextNameLookupTrait>
     *NameLookupTableData; // an ASTDeclContextNameLookupTable.
   const KindDeclIDPair *LexicalDecls;
   unsigned NumLexicalDecls;
index 2cb65826ad6382269db84cfe6181cc610dadd0bb..0d4d1c4710a0e0a83349b5c335d8ab7561497348 100644 (file)
@@ -17,7 +17,6 @@
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemStatCache.h"
 #include "clang/Basic/IdentifierTable.h"
-#include "clang/Basic/OnDiskHashTable.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
@@ -26,6 +25,7 @@
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/OnDiskHashTable.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 #endif
 
 using namespace clang;
-using namespace clang::io;
 
 //===----------------------------------------------------------------------===//
 // PTH-specific stuff.
 //===----------------------------------------------------------------------===//
 
+typedef uint32_t Offset;
+
 namespace {
 class PTHEntry {
   Offset TokenData, PPCondData;
@@ -171,7 +172,7 @@ public:
 };
 } // end anonymous namespace
 
-typedef OnDiskChainedHashTableGenerator<FileEntryPTHEntryInfo> PTHMap;
+typedef llvm::OnDiskChainedHashTableGenerator<FileEntryPTHEntryInfo> PTHMap;
 
 namespace {
 class PTHWriter {
@@ -287,8 +288,11 @@ void PTHWriter::EmitToken(const Token& T) {
 PTHEntry PTHWriter::LexTokens(Lexer& L) {
   // Pad 0's so that we emit tokens to a 4-byte alignment.
   // This speed up reading them back in.
-  Pad(Out, 4);
-  Offset TokenOff = (Offset) Out.tell();
+  using namespace llvm::support;
+  endian::Writer<little> LE(Out);
+  uint32_t TokenOff = Out.tell();
+  for (uint64_t N = llvm::OffsetToAlignment(TokenOff, 4); N; --N, ++TokenOff)
+    LE.write<uint8_t>(0);
 
   // Keep track of matching '#if' ... '#endif'.
   typedef std::vector<std::pair<Offset, unsigned> > PPCondTable;
@@ -636,7 +640,7 @@ std::pair<Offset,Offset> PTHWriter::EmitIdentifierTable() {
   PTHIdKey *IIDMap = (PTHIdKey*)calloc(idcount, sizeof(PTHIdKey));
 
   // Create the hashtable.
-  OnDiskChainedHashTableGenerator<PTHIdentifierTableTrait> IIOffMap;
+  llvm::OnDiskChainedHashTableGenerator<PTHIdentifierTableTrait> IIOffMap;
 
   // Generate mapping from persistent IDs -> IdentifierInfo*.
   for (IDMap::iterator I = IM.begin(), E = IM.end(); I != E; ++I) {
index 1ca16d39b4df39b3bf4ac2546cf1609c0856f5fe..f30e12157fe915c7cdc9cb9051627e5736948296 100644 (file)
@@ -15,7 +15,6 @@
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemStatCache.h"
 #include "clang/Basic/IdentifierTable.h"
-#include "clang/Basic/OnDiskHashTable.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Lex/PTHManager.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/OnDiskHashTable.h"
 #include "llvm/Support/system_error.h"
 #include <memory>
 using namespace clang;
-using namespace clang::io;
 
 #define DISK_TOKEN_SIZE (1+1+2+4+4)
 
@@ -409,8 +408,8 @@ public:
 
 } // end anonymous namespace
 
-typedef OnDiskChainedHashTable<PTHFileLookupTrait>   PTHFileLookup;
-typedef OnDiskChainedHashTable<PTHStringLookupTrait> PTHStringIdLookup;
+typedef llvm::OnDiskChainedHashTable<PTHFileLookupTrait>   PTHFileLookup;
+typedef llvm::OnDiskChainedHashTable<PTHStringLookupTrait> PTHStringIdLookup;
 
 //===----------------------------------------------------------------------===//
 // PTHManager methods.
@@ -693,7 +692,7 @@ public:
 };
 
 class PTHStatCache : public FileSystemStatCache {
-  typedef OnDiskChainedHashTable<PTHStatLookupTrait> CacheTy;
+  typedef llvm::OnDiskChainedHashTable<PTHStatLookupTrait> CacheTy;
   CacheTy Cache;
 
 public:
index fd328926eb3e208dd59d973b93061e4854fe267c..7f0201b916d5f2ef74f3ef6f2272dc8205812790 100644 (file)
@@ -14,9 +14,9 @@
 #define LLVM_CLANG_SERIALIZATION_ASTREADER_INTERNALS_H
 
 #include "clang/AST/DeclarationName.h"
-#include "clang/Basic/OnDiskHashTable.h"
 #include "clang/Serialization/ASTBitCodes.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/OnDiskHashTable.h"
 #include <sys/stat.h>
 #include <utility>
 
@@ -140,7 +140,7 @@ public:
   
 /// \brief The on-disk hash table used to contain information about
 /// all of the identifiers in the program.
-typedef OnDiskIterableChainedHashTable<ASTIdentifierLookupTrait>
+typedef llvm::OnDiskIterableChainedHashTable<ASTIdentifierLookupTrait>
   ASTIdentifierLookupTable;
 
 /// \brief Class that performs lookup for a selector's entries in the global
@@ -182,7 +182,7 @@ public:
 };
   
 /// \brief The on-disk hash table used for the global method pool.
-typedef OnDiskChainedHashTable<ASTSelectorLookupTrait>
+typedef llvm::OnDiskChainedHashTable<ASTSelectorLookupTrait>
   ASTSelectorLookupTable;
   
 /// \brief Trait class used to search the on-disk hash table containing all of
@@ -229,7 +229,7 @@ public:
 };
 
 /// \brief The on-disk hash table used for known header files.
-typedef OnDiskChainedHashTable<HeaderFileInfoTrait>
+typedef llvm::OnDiskChainedHashTable<HeaderFileInfoTrait>
   HeaderFileInfoLookupTable;
   
 } // end namespace clang::serialization::reader
index 4e2c2e665b8d6748658a6fb8da06d340d09677b3..cb25fe6f886f0a7c467159420009a4a3d315be86 100644 (file)
@@ -25,7 +25,6 @@
 #include "clang/AST/TypeLocVisitor.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemStatCache.h"
-#include "clang/Basic/OnDiskHashTable.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/SourceManagerInternals.h"
 #include "clang/Basic/TargetInfo.h"
@@ -49,6 +48,7 @@
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/OnDiskHashTable.h"
 #include "llvm/Support/Path.h"
 #include <algorithm>
 #include <cstdio>
@@ -1575,7 +1575,7 @@ void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS, StringRef isysroot) {
     FilesByUID.resize(HS.header_file_size());
   
   HeaderFileInfoTrait GeneratorTrait(*this, HS);
-  OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator;  
+  llvm::OnDiskChainedHashTableGenerator<HeaderFileInfoTrait> Generator;
   SmallVector<const char *, 4> SavedStrings;
   unsigned NumHeaderSearchEntries = 0;
   for (unsigned UID = 0, LastUID = FilesByUID.size(); UID != LastUID; ++UID) {
@@ -1948,7 +1948,7 @@ void ASTWriter::WritePreprocessor(const Preprocessor &PP, bool IsModule) {
   llvm::array_pod_sort(MacroDirectives.begin(), MacroDirectives.end(),
                        &compareMacroDirectives);
 
-  OnDiskChainedHashTableGenerator<ASTMacroTableTrait> Generator;
+  llvm::OnDiskChainedHashTableGenerator<ASTMacroTableTrait> Generator;
 
   // Emit the macro directives as a list and associate the offset with the
   // identifier they belong to.
@@ -2834,7 +2834,7 @@ void ASTWriter::WriteSelectors(Sema &SemaRef) {
   unsigned NumTableEntries = 0;
   // Create and write out the blob that contains selectors and the method pool.
   {
-    OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator;
+    llvm::OnDiskChainedHashTableGenerator<ASTMethodPoolTrait> Generator;
     ASTMethodPoolTrait Trait(*this);
 
     // Create the on-disk hash table representation. We walk through every
@@ -3260,7 +3260,7 @@ void ASTWriter::WriteIdentifierTable(Preprocessor &PP,
   // Create and write out the blob that contains the identifier
   // strings.
   {
-    OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator;
+    llvm::OnDiskChainedHashTableGenerator<ASTIdentifierTableTrait> Generator;
     ASTIdentifierTableTrait Trait(*this, PP, IdResolver, IsModule);
 
     // Look for any identifiers that were named while processing the
@@ -3464,7 +3464,8 @@ ASTWriter::GenerateNameLookupTable(const DeclContext *DC,
   assert(!DC->LookupPtr.getInt() && "must call buildLookups first");
   assert(DC == DC->getPrimaryContext() && "only primary DC has lookup table");
 
-  OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait> Generator;
+  llvm::OnDiskChainedHashTableGenerator<ASTDeclContextNameLookupTrait>
+      Generator;
   ASTDeclContextNameLookupTrait Trait(*this);
 
   // Create the on-disk hash table representation.
index 631683d92f04babd9d8adb053615f4b4d030cdd3..1649476342b7fb648fbb8ea26faab268afc8e784 100644 (file)
@@ -13,7 +13,6 @@
 
 #include "ASTReaderInternals.h"
 #include "clang/Basic/FileManager.h"
-#include "clang/Basic/OnDiskHashTable.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Serialization/ASTBitCodes.h"
 #include "clang/Serialization/GlobalModuleIndex.h"
@@ -27,6 +26,7 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LockFileManager.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/OnDiskHashTable.h"
 #include "llvm/Support/Path.h"
 #include <cstdio>
 using namespace clang;
@@ -115,7 +115,7 @@ public:
   }
 };
 
-typedef OnDiskIterableChainedHashTable<IdentifierIndexReaderTrait>
+typedef llvm::OnDiskIterableChainedHashTable<IdentifierIndexReaderTrait>
     IdentifierIndexTable;
 
 }
@@ -611,9 +611,8 @@ bool GlobalModuleIndexBuilder::loadModuleFile(const FileEntry *File) {
 
     // Handle the identifier table
     if (State == ASTBlock && Code == IDENTIFIER_TABLE && Record[0] > 0) {
-      typedef
-          OnDiskIterableChainedHashTable<InterestingASTIdentifierLookupTrait>
-          InterestingIdentifierTable;
+      typedef llvm::OnDiskIterableChainedHashTable<
+          InterestingASTIdentifierLookupTrait> InterestingIdentifierTable;
       std::unique_ptr<InterestingIdentifierTable> Table(
           InterestingIdentifierTable::Create(
               (const unsigned char *)Blob.data() + Record[0],
@@ -718,7 +717,7 @@ void GlobalModuleIndexBuilder::writeIndex(llvm::BitstreamWriter &Stream) {
 
   // Write the identifier -> module file mapping.
   {
-    OnDiskChainedHashTableGenerator<IdentifierIndexWriterTrait> Generator;
+    llvm::OnDiskChainedHashTableGenerator<IdentifierIndexWriterTrait> Generator;
     IdentifierIndexWriterTrait Trait;
 
     // Populate the hash table.