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