contrib/llvm/tools/clang/lib/Lex/PTHLexer.cpp

   1 //===--- PTHLexer.cpp - Lex from a token stream ---------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the PTHLexer interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Lex/PTHLexer.h"
  15 #include "clang/Basic/FileManager.h"
  16 #include "clang/Basic/FileSystemStatCache.h"
  17 #include "clang/Basic/IdentifierTable.h"
  18 #include "clang/Basic/TokenKinds.h"
  19 #include "clang/Lex/LexDiagnostic.h"
  20 #include "clang/Lex/PTHManager.h"
  21 #include "clang/Lex/Preprocessor.h"
  22 #include "clang/Lex/Token.h"
  23 #include "llvm/ADT/StringExtras.h"
  24 #include "llvm/ADT/StringMap.h"
  25 #include "llvm/Support/EndianStream.h"
  26 #include "llvm/Support/MemoryBuffer.h"
  27 #include "llvm/Support/OnDiskHashTable.h"
  28 #include <memory>
  29 #include <system_error>
  30 using namespace clang;
  31
  32 static const unsigned StoredTokenSize = 1 + 1 + 2 + 4 + 4;
  33
  34 //===----------------------------------------------------------------------===//
  35 // PTHLexer methods.
  36 //===----------------------------------------------------------------------===//
  37
  38 PTHLexer::PTHLexer(Preprocessor &PP, FileID FID, const unsigned char *D,
  39                    const unsigned char *ppcond, PTHManager &PM)
  40   : PreprocessorLexer(&PP, FID), TokBuf(D), CurPtr(D), LastHashTokPtr(nullptr),
  41     PPCond(ppcond), CurPPCondPtr(ppcond), PTHMgr(PM) {
  42
  43   FileStartLoc = PP.getSourceManager().getLocForStartOfFile(FID);
  44 }
  45
  46 bool PTHLexer::Lex(Token& Tok) {
  47   //===--------------------------------------==//
  48   // Read the raw token data.
  49   //===--------------------------------------==//
  50   using namespace llvm::support;
  51
  52   // Shadow CurPtr into an automatic variable.
  53   const unsigned char *CurPtrShadow = CurPtr;
  54
  55   // Read in the data for the token.
  56   unsigned Word0 = endian::readNext<uint32_t, little, aligned>(CurPtrShadow);
  57   uint32_t IdentifierID =
  58       endian::readNext<uint32_t, little, aligned>(CurPtrShadow);
  59   uint32_t FileOffset =
  60       endian::readNext<uint32_t, little, aligned>(CurPtrShadow);
  61
  62   tok::TokenKind TKind = (tok::TokenKind) (Word0 & 0xFF);
  63   Token::TokenFlags TFlags = (Token::TokenFlags) ((Word0 >> 8) & 0xFF);
  64   uint32_t Len = Word0 >> 16;
  65
  66   CurPtr = CurPtrShadow;
  67
  68   //===--------------------------------------==//
  69   // Construct the token itself.
  70   //===--------------------------------------==//
  71
  72   Tok.startToken();
  73   Tok.setKind(TKind);
  74   Tok.setFlag(TFlags);
  75   assert(!LexingRawMode);
  76   Tok.setLocation(FileStartLoc.getLocWithOffset(FileOffset));
  77   Tok.setLength(Len);
  78
  79   // Handle identifiers.
  80   if (Tok.isLiteral()) {
  81     Tok.setLiteralData((const char*) (PTHMgr.SpellingBase + IdentifierID));
  82   }
  83   else if (IdentifierID) {
  84     MIOpt.ReadToken();
  85     IdentifierInfo *II = PTHMgr.GetIdentifierInfo(IdentifierID-1);
  86
  87     Tok.setIdentifierInfo(II);
  88
  89     // Change the kind of this identifier to the appropriate token kind, e.g.
  90     // turning "for" into a keyword.
  91     Tok.setKind(II->getTokenID());
  92
  93     if (II->isHandleIdentifierCase())
  94       return PP->HandleIdentifier(Tok);
  95
  96     return true;
  97   }
  98
  99   //===--------------------------------------==//
 100   // Process the token.
 101   //===--------------------------------------==//
 102   if (TKind == tok::eof) {
 103     // Save the end-of-file token.
 104     EofToken = Tok;
 105
 106     assert(!ParsingPreprocessorDirective);
 107     assert(!LexingRawMode);
 108
 109     return LexEndOfFile(Tok);
 110   }
 111
 112   if (TKind == tok::hash && Tok.isAtStartOfLine()) {
 113     LastHashTokPtr = CurPtr - StoredTokenSize;
 114     assert(!LexingRawMode);
 115     PP->HandleDirective(Tok);
 116
 117     return false;
 118   }
 119
 120   if (TKind == tok::eod) {
 121     assert(ParsingPreprocessorDirective);
 122     ParsingPreprocessorDirective = false;
 123     return true;
 124   }
 125
 126   MIOpt.ReadToken();
 127   return true;
 128 }
 129
 130 bool PTHLexer::LexEndOfFile(Token &Result) {
 131   // If we hit the end of the file while parsing a preprocessor directive,
 132   // end the preprocessor directive first.  The next token returned will
 133   // then be the end of file.
 134   if (ParsingPreprocessorDirective) {
 135     ParsingPreprocessorDirective = false; // Done parsing the "line".
 136     return true;  // Have a token.
 137   }
 138
 139   assert(!LexingRawMode);
 140
 141   // If we are in a #if directive, emit an error.
 142   while (!ConditionalStack.empty()) {
 143     if (PP->getCodeCompletionFileLoc() != FileStartLoc)
 144       PP->Diag(ConditionalStack.back().IfLoc,
 145                diag::err_pp_unterminated_conditional);
 146     ConditionalStack.pop_back();
 147   }
 148
 149   // Finally, let the preprocessor handle this.
 150   return PP->HandleEndOfFile(Result);
 151 }
 152
 153 // FIXME: We can just grab the last token instead of storing a copy
 154 // into EofToken.
 155 void PTHLexer::getEOF(Token& Tok) {
 156   assert(EofToken.is(tok::eof));
 157   Tok = EofToken;
 158 }
 159
 160 void PTHLexer::DiscardToEndOfLine() {
 161   assert(ParsingPreprocessorDirective && ParsingFilename == false &&
 162          "Must be in a preprocessing directive!");
 163
 164   // We assume that if the preprocessor wishes to discard to the end of
 165   // the line that it also means to end the current preprocessor directive.
 166   ParsingPreprocessorDirective = false;
 167
 168   // Skip tokens by only peeking at their token kind and the flags.
 169   // We don't need to actually reconstruct full tokens from the token buffer.
 170   // This saves some copies and it also reduces IdentifierInfo* lookup.
 171   const unsigned char* p = CurPtr;
 172   while (1) {
 173     // Read the token kind.  Are we at the end of the file?
 174     tok::TokenKind x = (tok::TokenKind) (uint8_t) *p;
 175     if (x == tok::eof) break;
 176
 177     // Read the token flags.  Are we at the start of the next line?
 178     Token::TokenFlags y = (Token::TokenFlags) (uint8_t) p[1];
 179     if (y & Token::StartOfLine) break;
 180
 181     // Skip to the next token.
 182     p += StoredTokenSize;
 183   }
 184
 185   CurPtr = p;
 186 }
 187
 188 /// SkipBlock - Used by Preprocessor to skip the current conditional block.
 189 bool PTHLexer::SkipBlock() {
 190   using namespace llvm::support;
 191   assert(CurPPCondPtr && "No cached PP conditional information.");
 192   assert(LastHashTokPtr && "No known '#' token.");
 193
 194   const unsigned char *HashEntryI = nullptr;
 195   uint32_t TableIdx;
 196
 197   do {
 198     // Read the token offset from the side-table.
 199     uint32_t Offset = endian::readNext<uint32_t, little, aligned>(CurPPCondPtr);
 200
 201     // Read the target table index from the side-table.
 202     TableIdx = endian::readNext<uint32_t, little, aligned>(CurPPCondPtr);
 203
 204     // Compute the actual memory address of the '#' token data for this entry.
 205     HashEntryI = TokBuf + Offset;
 206
 207     // Optmization: "Sibling jumping".  #if...#else...#endif blocks can
 208     //  contain nested blocks.  In the side-table we can jump over these
 209     //  nested blocks instead of doing a linear search if the next "sibling"
 210     //  entry is not at a location greater than LastHashTokPtr.
 211     if (HashEntryI < LastHashTokPtr && TableIdx) {
 212       // In the side-table we are still at an entry for a '#' token that
 213       // is earlier than the last one we saw.  Check if the location we would
 214       // stride gets us closer.
 215       const unsigned char* NextPPCondPtr =
 216         PPCond + TableIdx*(sizeof(uint32_t)*2);
 217       assert(NextPPCondPtr >= CurPPCondPtr);
 218       // Read where we should jump to.
 219       const unsigned char *HashEntryJ =
 220           TokBuf + endian::readNext<uint32_t, little, aligned>(NextPPCondPtr);
 221
 222       if (HashEntryJ <= LastHashTokPtr) {
 223         // Jump directly to the next entry in the side table.
 224         HashEntryI = HashEntryJ;
 225         TableIdx = endian::readNext<uint32_t, little, aligned>(NextPPCondPtr);
 226         CurPPCondPtr = NextPPCondPtr;
 227       }
 228     }
 229   }
 230   while (HashEntryI < LastHashTokPtr);
 231   assert(HashEntryI == LastHashTokPtr && "No PP-cond entry found for '#'");
 232   assert(TableIdx && "No jumping from #endifs.");
 233
 234   // Update our side-table iterator.
 235   const unsigned char* NextPPCondPtr = PPCond + TableIdx*(sizeof(uint32_t)*2);
 236   assert(NextPPCondPtr >= CurPPCondPtr);
 237   CurPPCondPtr = NextPPCondPtr;
 238
 239   // Read where we should jump to.
 240   HashEntryI =
 241       TokBuf + endian::readNext<uint32_t, little, aligned>(NextPPCondPtr);
 242   uint32_t NextIdx = endian::readNext<uint32_t, little, aligned>(NextPPCondPtr);
 243
 244   // By construction NextIdx will be zero if this is a #endif.  This is useful
 245   // to know to obviate lexing another token.
 246   bool isEndif = NextIdx == 0;
 247
 248   // This case can occur when we see something like this:
 249   //
 250   //  #if ...
 251   //   /* a comment or nothing */
 252   //  #elif
 253   //
 254   // If we are skipping the first #if block it will be the case that CurPtr
 255   // already points 'elif'.  Just return.
 256
 257   if (CurPtr > HashEntryI) {
 258     assert(CurPtr == HashEntryI + StoredTokenSize);
 259     // Did we reach a #endif?  If so, go ahead and consume that token as well.
 260     if (isEndif)
 261       CurPtr += StoredTokenSize * 2;
 262     else
 263       LastHashTokPtr = HashEntryI;
 264
 265     return isEndif;
 266   }
 267
 268   // Otherwise, we need to advance.  Update CurPtr to point to the '#' token.
 269   CurPtr = HashEntryI;
 270
 271   // Update the location of the last observed '#'.  This is useful if we
 272   // are skipping multiple blocks.
 273   LastHashTokPtr = CurPtr;
 274
 275   // Skip the '#' token.
 276   assert(((tok::TokenKind)*CurPtr) == tok::hash);
 277   CurPtr += StoredTokenSize;
 278
 279   // Did we reach a #endif?  If so, go ahead and consume that token as well.
 280   if (isEndif) {
 281     CurPtr += StoredTokenSize * 2;
 282   }
 283
 284   return isEndif;
 285 }
 286
 287 SourceLocation PTHLexer::getSourceLocation() {
 288   // getSourceLocation is not on the hot path.  It is used to get the location
 289   // of the next token when transitioning back to this lexer when done
 290   // handling a #included file.  Just read the necessary data from the token
 291   // data buffer to construct the SourceLocation object.
 292   // NOTE: This is a virtual function; hence it is defined out-of-line.
 293   using namespace llvm::support;
 294
 295   const unsigned char *OffsetPtr = CurPtr + (StoredTokenSize - 4);
 296   uint32_t Offset = endian::readNext<uint32_t, little, aligned>(OffsetPtr);
 297   return FileStartLoc.getLocWithOffset(Offset);
 298 }
 299
 300 //===----------------------------------------------------------------------===//
 301 // PTH file lookup: map from strings to file data.
 302 //===----------------------------------------------------------------------===//
 303
 304 /// PTHFileLookup - This internal data structure is used by the PTHManager
 305 ///  to map from FileEntry objects managed by FileManager to offsets within
 306 ///  the PTH file.
 307 namespace {
 308 class PTHFileData {
 309   const uint32_t TokenOff;
 310   const uint32_t PPCondOff;
 311 public:
 312   PTHFileData(uint32_t tokenOff, uint32_t ppCondOff)
 313     : TokenOff(tokenOff), PPCondOff(ppCondOff) {}
 314
 315   uint32_t getTokenOffset() const { return TokenOff; }
 316   uint32_t getPPCondOffset() const { return PPCondOff; }
 317 };
 318
 319
 320 class PTHFileLookupCommonTrait {
 321 public:
 322   typedef std::pair<unsigned char, const char*> internal_key_type;
 323   typedef unsigned hash_value_type;
 324   typedef unsigned offset_type;
 325
 326   static hash_value_type ComputeHash(internal_key_type x) {
 327     return llvm::HashString(x.second);
 328   }
 329
 330   static std::pair<unsigned, unsigned>
 331   ReadKeyDataLength(const unsigned char*& d) {
 332     using namespace llvm::support;
 333     unsigned keyLen =
 334         (unsigned)endian::readNext<uint16_t, little, unaligned>(d);
 335     unsigned dataLen = (unsigned) *(d++);
 336     return std::make_pair(keyLen, dataLen);
 337   }
 338
 339   static internal_key_type ReadKey(const unsigned char* d, unsigned) {
 340     unsigned char k = *(d++); // Read the entry kind.
 341     return std::make_pair(k, (const char*) d);
 342   }
 343 };
 344
 345 class PTHFileLookupTrait : public PTHFileLookupCommonTrait {
 346 public:
 347   typedef const FileEntry* external_key_type;
 348   typedef PTHFileData      data_type;
 349
 350   static internal_key_type GetInternalKey(const FileEntry* FE) {
 351     return std::make_pair((unsigned char) 0x1, FE->getName());
 352   }
 353
 354   static bool EqualKey(internal_key_type a, internal_key_type b) {
 355     return a.first == b.first && strcmp(a.second, b.second) == 0;
 356   }
 357
 358   static PTHFileData ReadData(const internal_key_type& k,
 359                               const unsigned char* d, unsigned) {
 360     assert(k.first == 0x1 && "Only file lookups can match!");
 361     using namespace llvm::support;
 362     uint32_t x = endian::readNext<uint32_t, little, unaligned>(d);
 363     uint32_t y = endian::readNext<uint32_t, little, unaligned>(d);
 364     return PTHFileData(x, y);
 365   }
 366 };
 367
 368 class PTHStringLookupTrait {
 369 public:
 370   typedef uint32_t data_type;
 371   typedef const std::pair<const char*, unsigned> external_key_type;
 372   typedef external_key_type internal_key_type;
 373   typedef uint32_t hash_value_type;
 374   typedef unsigned offset_type;
 375
 376   static bool EqualKey(const internal_key_type& a,
 377                        const internal_key_type& b) {
 378     return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0
 379                                   : false;
 380   }
 381
 382   static hash_value_type ComputeHash(const internal_key_type& a) {
 383     return llvm::HashString(StringRef(a.first, a.second));
 384   }
 385
 386   // This hopefully will just get inlined and removed by the optimizer.
 387   static const internal_key_type&
 388   GetInternalKey(const external_key_type& x) { return x; }
 389
 390   static std::pair<unsigned, unsigned>
 391   ReadKeyDataLength(const unsigned char*& d) {
 392     using namespace llvm::support;
 393     return std::make_pair(
 394         (unsigned)endian::readNext<uint16_t, little, unaligned>(d),
 395         sizeof(uint32_t));
 396   }
 397
 398   static std::pair<const char*, unsigned>
 399   ReadKey(const unsigned char* d, unsigned n) {
 400       assert(n >= 2 && d[n-1] == '\0');
 401       return std::make_pair((const char*) d, n-1);
 402     }
 403
 404   static uint32_t ReadData(const internal_key_type& k, const unsigned char* d,
 405                            unsigned) {
 406     using namespace llvm::support;
 407     return endian::readNext<uint32_t, little, unaligned>(d);
 408   }
 409 };
 410
 411 } // end anonymous namespace
 412
 413 typedef llvm::OnDiskChainedHashTable<PTHFileLookupTrait>   PTHFileLookup;
 414 typedef llvm::OnDiskChainedHashTable<PTHStringLookupTrait> PTHStringIdLookup;
 415
 416 //===----------------------------------------------------------------------===//
 417 // PTHManager methods.
 418 //===----------------------------------------------------------------------===//
 419
 420 PTHManager::PTHManager(const llvm::MemoryBuffer* buf, void* fileLookup,
 421                        const unsigned char* idDataTable,
 422                        IdentifierInfo** perIDCache,
 423                        void* stringIdLookup, unsigned numIds,
 424                        const unsigned char* spellingBase,
 425                        const char* originalSourceFile)
 426 : Buf(buf), PerIDCache(perIDCache), FileLookup(fileLookup),
 427   IdDataTable(idDataTable), StringIdLookup(stringIdLookup),
 428   NumIds(numIds), PP(nullptr), SpellingBase(spellingBase),
 429   OriginalSourceFile(originalSourceFile) {}
 430
 431 PTHManager::~PTHManager() {
 432   delete Buf;
 433   delete (PTHFileLookup*) FileLookup;
 434   delete (PTHStringIdLookup*) StringIdLookup;
 435   free(PerIDCache);
 436 }
 437
 438 static void InvalidPTH(DiagnosticsEngine &Diags, const char *Msg) {
 439   Diags.Report(Diags.getCustomDiagID(DiagnosticsEngine::Error, "%0")) << Msg;
 440 }
 441
 442 PTHManager *PTHManager::Create(const std::string &file,
 443                                DiagnosticsEngine &Diags) {
 444   // Memory map the PTH file.
 445   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileOrErr =
 446       llvm::MemoryBuffer::getFile(file);
 447
 448   if (!FileOrErr) {
 449     // FIXME: Add ec.message() to this diag.
 450     Diags.Report(diag::err_invalid_pth_file) << file;
 451     return nullptr;
 452   }
 453   std::unique_ptr<llvm::MemoryBuffer> File = std::move(FileOrErr.get());
 454
 455   using namespace llvm::support;
 456
 457   // Get the buffer ranges and check if there are at least three 32-bit
 458   // words at the end of the file.
 459   const unsigned char *BufBeg = (const unsigned char*)File->getBufferStart();
 460   const unsigned char *BufEnd = (const unsigned char*)File->getBufferEnd();
 461
 462   // Check the prologue of the file.
 463   if ((BufEnd - BufBeg) < (signed)(sizeof("cfe-pth") + 4 + 4) ||
 464       memcmp(BufBeg, "cfe-pth", sizeof("cfe-pth")) != 0) {
 465     Diags.Report(diag::err_invalid_pth_file) << file;
 466     return nullptr;
 467   }
 468
 469   // Read the PTH version.
 470   const unsigned char *p = BufBeg + (sizeof("cfe-pth"));
 471   unsigned Version = endian::readNext<uint32_t, little, aligned>(p);
 472
 473   if (Version < PTHManager::Version) {
 474     InvalidPTH(Diags,
 475         Version < PTHManager::Version
 476         ? "PTH file uses an older PTH format that is no longer supported"
 477         : "PTH file uses a newer PTH format that cannot be read");
 478     return nullptr;
 479   }
 480
 481   // Compute the address of the index table at the end of the PTH file.
 482   const unsigned char *PrologueOffset = p;
 483
 484   if (PrologueOffset >= BufEnd) {
 485     Diags.Report(diag::err_invalid_pth_file) << file;
 486     return nullptr;
 487   }
 488
 489   // Construct the file lookup table.  This will be used for mapping from
 490   // FileEntry*'s to cached tokens.
 491   const unsigned char* FileTableOffset = PrologueOffset + sizeof(uint32_t)*2;
 492   const unsigned char *FileTable =
 493       BufBeg + endian::readNext<uint32_t, little, aligned>(FileTableOffset);
 494
 495   if (!(FileTable > BufBeg && FileTable < BufEnd)) {
 496     Diags.Report(diag::err_invalid_pth_file) << file;
 497     return nullptr; // FIXME: Proper error diagnostic?
 498   }
 499
 500   std::unique_ptr<PTHFileLookup> FL(PTHFileLookup::Create(FileTable, BufBeg));
 501
 502   // Warn if the PTH file is empty.  We still want to create a PTHManager
 503   // as the PTH could be used with -include-pth.
 504   if (FL->isEmpty())
 505     InvalidPTH(Diags, "PTH file contains no cached source data");
 506
 507   // Get the location of the table mapping from persistent ids to the
 508   // data needed to reconstruct identifiers.
 509   const unsigned char* IDTableOffset = PrologueOffset + sizeof(uint32_t)*0;
 510   const unsigned char *IData =
 511       BufBeg + endian::readNext<uint32_t, little, aligned>(IDTableOffset);
 512
 513   if (!(IData >= BufBeg && IData < BufEnd)) {
 514     Diags.Report(diag::err_invalid_pth_file) << file;
 515     return nullptr;
 516   }
 517
 518   // Get the location of the hashtable mapping between strings and
 519   // persistent IDs.
 520   const unsigned char* StringIdTableOffset = PrologueOffset + sizeof(uint32_t)*1;
 521   const unsigned char *StringIdTable =
 522       BufBeg + endian::readNext<uint32_t, little, aligned>(StringIdTableOffset);
 523   if (!(StringIdTable >= BufBeg && StringIdTable < BufEnd)) {
 524     Diags.Report(diag::err_invalid_pth_file) << file;
 525     return nullptr;
 526   }
 527
 528   std::unique_ptr<PTHStringIdLookup> SL(
 529       PTHStringIdLookup::Create(StringIdTable, BufBeg));
 530
 531   // Get the location of the spelling cache.
 532   const unsigned char* spellingBaseOffset = PrologueOffset + sizeof(uint32_t)*3;
 533   const unsigned char *spellingBase =
 534       BufBeg + endian::readNext<uint32_t, little, aligned>(spellingBaseOffset);
 535   if (!(spellingBase >= BufBeg && spellingBase < BufEnd)) {
 536     Diags.Report(diag::err_invalid_pth_file) << file;
 537     return nullptr;
 538   }
 539
 540   // Get the number of IdentifierInfos and pre-allocate the identifier cache.
 541   uint32_t NumIds = endian::readNext<uint32_t, little, aligned>(IData);
 542
 543   // Pre-allocate the persistent ID -> IdentifierInfo* cache.  We use calloc()
 544   // so that we in the best case only zero out memory once when the OS returns
 545   // us new pages.
 546   IdentifierInfo **PerIDCache = nullptr;
 547
 548   if (NumIds) {
 549     PerIDCache = (IdentifierInfo**)calloc(NumIds, sizeof(*PerIDCache));
 550     if (!PerIDCache) {
 551       InvalidPTH(Diags, "Could not allocate memory for processing PTH file");
 552       return nullptr;
 553     }
 554   }
 555
 556   // Compute the address of the original source file.
 557   const unsigned char* originalSourceBase = PrologueOffset + sizeof(uint32_t)*4;
 558   unsigned len =
 559       endian::readNext<uint16_t, little, unaligned>(originalSourceBase);
 560   if (!len) originalSourceBase = nullptr;
 561
 562   // Create the new PTHManager.
 563   return new PTHManager(File.release(), FL.release(), IData, PerIDCache,
 564                         SL.release(), NumIds, spellingBase,
 565                         (const char *)originalSourceBase);
 566 }
 567
 568 IdentifierInfo* PTHManager::LazilyCreateIdentifierInfo(unsigned PersistentID) {
 569   using namespace llvm::support;
 570   // Look in the PTH file for the string data for the IdentifierInfo object.
 571   const unsigned char* TableEntry = IdDataTable + sizeof(uint32_t)*PersistentID;
 572   const unsigned char *IDData =
 573       (const unsigned char *)Buf->getBufferStart() +
 574       endian::readNext<uint32_t, little, aligned>(TableEntry);
 575   assert(IDData < (const unsigned char*)Buf->getBufferEnd());
 576
 577   // Allocate the object.
 578   std::pair<IdentifierInfo,const unsigned char*> *Mem =
 579     Alloc.Allocate<std::pair<IdentifierInfo,const unsigned char*> >();
 580
 581   Mem->second = IDData;
 582   assert(IDData[0] != '\0');
 583   IdentifierInfo *II = new ((void*) Mem) IdentifierInfo();
 584
 585   // Store the new IdentifierInfo in the cache.
 586   PerIDCache[PersistentID] = II;
 587   assert(II->getNameStart() && II->getNameStart()[0] != '\0');
 588   return II;
 589 }
 590
 591 IdentifierInfo* PTHManager::get(StringRef Name) {
 592   PTHStringIdLookup& SL = *((PTHStringIdLookup*)StringIdLookup);
 593   // Double check our assumption that the last character isn't '\0'.
 594   assert(Name.empty() || Name.back() != '\0');
 595   PTHStringIdLookup::iterator I = SL.find(std::make_pair(Name.data(),
 596                                                          Name.size()));
 597   if (I == SL.end()) // No identifier found?
 598     return nullptr;
 599
 600   // Match found.  Return the identifier!
 601   assert(*I > 0);
 602   return GetIdentifierInfo(*I-1);
 603 }
 604
 605 PTHLexer *PTHManager::CreateLexer(FileID FID) {
 606   const FileEntry *FE = PP->getSourceManager().getFileEntryForID(FID);
 607   if (!FE)
 608     return nullptr;
 609
 610   using namespace llvm::support;
 611
 612   // Lookup the FileEntry object in our file lookup data structure.  It will
 613   // return a variant that indicates whether or not there is an offset within
 614   // the PTH file that contains cached tokens.
 615   PTHFileLookup& PFL = *((PTHFileLookup*)FileLookup);
 616   PTHFileLookup::iterator I = PFL.find(FE);
 617
 618   if (I == PFL.end()) // No tokens available?
 619     return nullptr;
 620
 621   const PTHFileData& FileData = *I;
 622
 623   const unsigned char *BufStart = (const unsigned char *)Buf->getBufferStart();
 624   // Compute the offset of the token data within the buffer.
 625   const unsigned char* data = BufStart + FileData.getTokenOffset();
 626
 627   // Get the location of pp-conditional table.
 628   const unsigned char* ppcond = BufStart + FileData.getPPCondOffset();
 629   uint32_t Len = endian::readNext<uint32_t, little, aligned>(ppcond);
 630   if (Len == 0) ppcond = nullptr;
 631
 632   assert(PP && "No preprocessor set yet!");
 633   return new PTHLexer(*PP, FID, data, ppcond, *this);
 634 }
 635
 636 //===----------------------------------------------------------------------===//
 637 // 'stat' caching.
 638 //===----------------------------------------------------------------------===//
 639
 640 namespace {
 641 class PTHStatData {
 642 public:
 643   const bool HasData;
 644   uint64_t Size;
 645   time_t ModTime;
 646   llvm::sys::fs::UniqueID UniqueID;
 647   bool IsDirectory;
 648
 649   PTHStatData(uint64_t Size, time_t ModTime, llvm::sys::fs::UniqueID UniqueID,
 650               bool IsDirectory)
 651       : HasData(true), Size(Size), ModTime(ModTime), UniqueID(UniqueID),
 652         IsDirectory(IsDirectory) {}
 653
 654   PTHStatData() : HasData(false) {}
 655 };
 656
 657 class PTHStatLookupTrait : public PTHFileLookupCommonTrait {
 658 public:
 659   typedef const char* external_key_type;  // const char*
 660   typedef PTHStatData data_type;
 661
 662   static internal_key_type GetInternalKey(const char *path) {
 663     // The key 'kind' doesn't matter here because it is ignored in EqualKey.
 664     return std::make_pair((unsigned char) 0x0, path);
 665   }
 666
 667   static bool EqualKey(internal_key_type a, internal_key_type b) {
 668     // When doing 'stat' lookups we don't care about the kind of 'a' and 'b',
 669     // just the paths.
 670     return strcmp(a.second, b.second) == 0;
 671   }
 672
 673   static data_type ReadData(const internal_key_type& k, const unsigned char* d,
 674                             unsigned) {
 675
 676     if (k.first /* File or Directory */) {
 677       bool IsDirectory = true;
 678       if (k.first == 0x1 /* File */) {
 679         IsDirectory = false;
 680         d += 4 * 2; // Skip the first 2 words.
 681       }
 682
 683       using namespace llvm::support;
 684
 685       uint64_t File = endian::readNext<uint64_t, little, unaligned>(d);
 686       uint64_t Device = endian::readNext<uint64_t, little, unaligned>(d);
 687       llvm::sys::fs::UniqueID UniqueID(File, Device);
 688       time_t ModTime = endian::readNext<uint64_t, little, unaligned>(d);
 689       uint64_t Size = endian::readNext<uint64_t, little, unaligned>(d);
 690       return data_type(Size, ModTime, UniqueID, IsDirectory);
 691     }
 692
 693     // Negative stat.  Don't read anything.
 694     return data_type();
 695   }
 696 };
 697
 698 class PTHStatCache : public FileSystemStatCache {
 699   typedef llvm::OnDiskChainedHashTable<PTHStatLookupTrait> CacheTy;
 700   CacheTy Cache;
 701
 702 public:
 703   PTHStatCache(PTHFileLookup &FL) :
 704     Cache(FL.getNumBuckets(), FL.getNumEntries(), FL.getBuckets(),
 705           FL.getBase()) {}
 706
 707   LookupResult getStat(const char *Path, FileData &Data, bool isFile,
 708                        std::unique_ptr<vfs::File> *F,
 709                        vfs::FileSystem &FS) override {
 710     // Do the lookup for the file's data in the PTH file.
 711     CacheTy::iterator I = Cache.find(Path);
 712
 713     // If we don't get a hit in the PTH file just forward to 'stat'.
 714     if (I == Cache.end())
 715       return statChained(Path, Data, isFile, F, FS);
 716
 717     const PTHStatData &D = *I;
 718
 719     if (!D.HasData)
 720       return CacheMissing;
 721
 722     Data.Name = Path;
 723     Data.Size = D.Size;
 724     Data.ModTime = D.ModTime;
 725     Data.UniqueID = D.UniqueID;
 726     Data.IsDirectory = D.IsDirectory;
 727     Data.IsNamedPipe = false;
 728     Data.InPCH = true;
 729
 730     return CacheExists;
 731   }
 732 };
 733 } // end anonymous namespace
 734
 735 FileSystemStatCache *PTHManager::createStatCache() {
 736   return new PTHStatCache(*((PTHFileLookup*) FileLookup));
 737 }