#include "clang/Lex/HeaderMap.h"
#include "clang/Basic/CharInfo.h"
#include "clang/Basic/FileManager.h"
#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/MemoryBuffer.h"
#include <cstdio>
using namespace clang;
enum {
HMAP_HeaderMagicNumber = ('h' << 24) | ('m' << 16) | ('a' << 8) | 'p',
HMAP_HeaderVersion = 1,
HMAP_EmptyBucketKey = 0
};
namespace clang {
struct HMapBucket {
uint32_t Key;
uint32_t Prefix; uint32_t Suffix; };
struct HMapHeader {
uint32_t Magic; uint16_t Version; uint16_t Reserved; uint32_t StringsOffset; uint32_t NumEntries; uint32_t NumBuckets; uint32_t MaxValueLength; };
}
static inline unsigned HashHMapKey(StringRef Str) {
unsigned Result = 0;
const char *S = Str.begin(), *End = Str.end();
for (; S != End; S++)
Result += toLowercase(*S) * 13;
return Result;
}
const HeaderMap *HeaderMap::Create(const FileEntry *FE, FileManager &FM) {
unsigned FileSize = FE->getSize();
if (FileSize <= sizeof(HMapHeader)) return 0;
OwningPtr<const llvm::MemoryBuffer> FileBuffer(FM.getBufferForFile(FE));
if (!FileBuffer) return 0; const char *FileStart = FileBuffer->getBufferStart();
const HMapHeader *Header = reinterpret_cast<const HMapHeader*>(FileStart);
bool NeedsByteSwap;
if (Header->Magic == HMAP_HeaderMagicNumber &&
Header->Version == HMAP_HeaderVersion)
NeedsByteSwap = false;
else if (Header->Magic == llvm::ByteSwap_32(HMAP_HeaderMagicNumber) &&
Header->Version == llvm::ByteSwap_16(HMAP_HeaderVersion))
NeedsByteSwap = true; else
return 0;
if (Header->Reserved != 0) return 0;
return new HeaderMap(FileBuffer.take(), NeedsByteSwap);
}
HeaderMap::~HeaderMap() {
delete FileBuffer;
}
const char *HeaderMap::getFileName() const {
return FileBuffer->getBufferIdentifier();
}
unsigned HeaderMap::getEndianAdjustedWord(unsigned X) const {
if (!NeedsBSwap) return X;
return llvm::ByteSwap_32(X);
}
const HMapHeader &HeaderMap::getHeader() const {
return *reinterpret_cast<const HMapHeader*>(FileBuffer->getBufferStart());
}
HMapBucket HeaderMap::getBucket(unsigned BucketNo) const {
HMapBucket Result;
Result.Key = HMAP_EmptyBucketKey;
const HMapBucket *BucketArray =
reinterpret_cast<const HMapBucket*>(FileBuffer->getBufferStart() +
sizeof(HMapHeader));
const HMapBucket *BucketPtr = BucketArray+BucketNo;
if ((const char*)(BucketPtr+1) > FileBuffer->getBufferEnd()) {
Result.Prefix = 0;
Result.Suffix = 0;
return Result; }
Result.Key = getEndianAdjustedWord(BucketPtr->Key);
Result.Prefix = getEndianAdjustedWord(BucketPtr->Prefix);
Result.Suffix = getEndianAdjustedWord(BucketPtr->Suffix);
return Result;
}
const char *HeaderMap::getString(unsigned StrTabIdx) const {
StrTabIdx += getEndianAdjustedWord(getHeader().StringsOffset);
if (StrTabIdx >= FileBuffer->getBufferSize())
return 0;
return FileBuffer->getBufferStart()+StrTabIdx;
}
void HeaderMap::dump() const {
const HMapHeader &Hdr = getHeader();
unsigned NumBuckets = getEndianAdjustedWord(Hdr.NumBuckets);
fprintf(stderr, "Header Map %s:\n %d buckets, %d entries\n",
getFileName(), NumBuckets,
getEndianAdjustedWord(Hdr.NumEntries));
for (unsigned i = 0; i != NumBuckets; ++i) {
HMapBucket B = getBucket(i);
if (B.Key == HMAP_EmptyBucketKey) continue;
const char *Key = getString(B.Key);
const char *Prefix = getString(B.Prefix);
const char *Suffix = getString(B.Suffix);
fprintf(stderr, " %d. %s -> '%s' '%s'\n", i, Key, Prefix, Suffix);
}
}
const FileEntry *HeaderMap::LookupFile(
StringRef Filename, FileManager &FM) const {
SmallString<1024> Path;
StringRef Dest = lookupFilename(Filename, Path);
if (Dest.empty())
return 0;
return FM.getFile(Dest);
}
StringRef HeaderMap::lookupFilename(StringRef Filename,
SmallVectorImpl<char> &DestPath) const {
const HMapHeader &Hdr = getHeader();
unsigned NumBuckets = getEndianAdjustedWord(Hdr.NumBuckets);
if (NumBuckets & (NumBuckets-1))
return StringRef();
for (unsigned Bucket = HashHMapKey(Filename);; ++Bucket) {
HMapBucket B = getBucket(Bucket & (NumBuckets-1));
if (B.Key == HMAP_EmptyBucketKey) return StringRef();
if (!Filename.equals_lower(getString(B.Key)))
continue;
StringRef Prefix = getString(B.Prefix);
StringRef Suffix = getString(B.Suffix);
DestPath.clear();
DestPath.append(Prefix.begin(), Prefix.end());
DestPath.append(Suffix.begin(), Suffix.end());
return StringRef(DestPath.begin(), DestPath.size());
}
}