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