forked from OSchip/llvm-project
Remove OnDiskHashTable.h, since it's been moved to llvm
llvm-svn: 206637
This commit is contained in:
Justin Bogner
parent
28da676709
commit
bb094f0669
|
|
@ -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
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,13 +23,16 @@
|
|||
#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;
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
||||
|
|
@ -35,12 +35,13 @@
|
|||
#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) {
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
|
@ -25,10 +24,10 @@
|
|||
#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:
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
Loading…
Reference in New Issue