SourceManager.cpp revision 206084
1//===--- SourceManager.cpp - Track and cache source files -----------------===// 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 SourceManager interface. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Basic/SourceManager.h" 15#include "clang/Basic/SourceManagerInternals.h" 16#include "clang/Basic/Diagnostic.h" 17#include "clang/Basic/FileManager.h" 18#include "llvm/Support/Compiler.h" 19#include "llvm/Support/MemoryBuffer.h" 20#include "llvm/Support/raw_ostream.h" 21#include "llvm/System/Path.h" 22#include <algorithm> 23#include <string> 24#include <cstring> 25 26using namespace clang; 27using namespace SrcMgr; 28using llvm::MemoryBuffer; 29 30//===----------------------------------------------------------------------===// 31// SourceManager Helper Classes 32//===----------------------------------------------------------------------===// 33 34ContentCache::~ContentCache() { 35 delete Buffer.getPointer(); 36} 37 38/// getSizeBytesMapped - Returns the number of bytes actually mapped for 39/// this ContentCache. This can be 0 if the MemBuffer was not actually 40/// instantiated. 41unsigned ContentCache::getSizeBytesMapped() const { 42 return Buffer.getPointer() ? Buffer.getPointer()->getBufferSize() : 0; 43} 44 45/// getSize - Returns the size of the content encapsulated by this ContentCache. 46/// This can be the size of the source file or the size of an arbitrary 47/// scratch buffer. If the ContentCache encapsulates a source file, that 48/// file is not lazily brought in from disk to satisfy this query. 49unsigned ContentCache::getSize() const { 50 return Buffer.getPointer() ? (unsigned) Buffer.getPointer()->getBufferSize() 51 : (unsigned) Entry->getSize(); 52} 53 54void ContentCache::replaceBuffer(const llvm::MemoryBuffer *B) { 55 assert(B != Buffer.getPointer()); 56 57 delete Buffer.getPointer(); 58 Buffer.setPointer(B); 59 Buffer.setInt(false); 60} 61 62const llvm::MemoryBuffer *ContentCache::getBuffer(Diagnostic &Diag, 63 bool *Invalid) const { 64 if (Invalid) 65 *Invalid = false; 66 67 // Lazily create the Buffer for ContentCaches that wrap files. 68 if (!Buffer.getPointer() && Entry) { 69 std::string ErrorStr; 70 struct stat FileInfo; 71 Buffer.setPointer(MemoryBuffer::getFile(Entry->getName(), &ErrorStr, 72 Entry->getSize(), &FileInfo)); 73 Buffer.setInt(false); 74 75 // If we were unable to open the file, then we are in an inconsistent 76 // situation where the content cache referenced a file which no longer 77 // exists. Most likely, we were using a stat cache with an invalid entry but 78 // the file could also have been removed during processing. Since we can't 79 // really deal with this situation, just create an empty buffer. 80 // 81 // FIXME: This is definitely not ideal, but our immediate clients can't 82 // currently handle returning a null entry here. Ideally we should detect 83 // that we are in an inconsistent situation and error out as quickly as 84 // possible. 85 if (!Buffer.getPointer()) { 86 const llvm::StringRef FillStr("<<<MISSING SOURCE FILE>>>\n"); 87 Buffer.setPointer(MemoryBuffer::getNewMemBuffer(Entry->getSize(), 88 "<invalid>")); 89 char *Ptr = const_cast<char*>(Buffer.getPointer()->getBufferStart()); 90 for (unsigned i = 0, e = Entry->getSize(); i != e; ++i) 91 Ptr[i] = FillStr[i % FillStr.size()]; 92 93 if (Diag.isDiagnosticInFlight()) 94 Diag.SetDelayedDiagnostic(diag::err_cannot_open_file, 95 Entry->getName(), ErrorStr); 96 else 97 Diag.Report(diag::err_cannot_open_file) 98 << Entry->getName() << ErrorStr; 99 100 Buffer.setInt(true); 101 } else if (FileInfo.st_size != Entry->getSize() || 102 FileInfo.st_mtime != Entry->getModificationTime()) { 103 // Check that the file's size, modification time, and inode are 104 // the same as in the file entry (which may have come from a 105 // stat cache). 106 if (Diag.isDiagnosticInFlight()) 107 Diag.SetDelayedDiagnostic(diag::err_file_modified, 108 Entry->getName()); 109 else 110 Diag.Report(diag::err_file_modified) << Entry->getName(); 111 112 Buffer.setInt(true); 113 } 114 } 115 116 if (Invalid) 117 *Invalid = Buffer.getInt(); 118 119 return Buffer.getPointer(); 120} 121 122unsigned LineTableInfo::getLineTableFilenameID(const char *Ptr, unsigned Len) { 123 // Look up the filename in the string table, returning the pre-existing value 124 // if it exists. 125 llvm::StringMapEntry<unsigned> &Entry = 126 FilenameIDs.GetOrCreateValue(Ptr, Ptr+Len, ~0U); 127 if (Entry.getValue() != ~0U) 128 return Entry.getValue(); 129 130 // Otherwise, assign this the next available ID. 131 Entry.setValue(FilenamesByID.size()); 132 FilenamesByID.push_back(&Entry); 133 return FilenamesByID.size()-1; 134} 135 136/// AddLineNote - Add a line note to the line table that indicates that there 137/// is a #line at the specified FID/Offset location which changes the presumed 138/// location to LineNo/FilenameID. 139void LineTableInfo::AddLineNote(unsigned FID, unsigned Offset, 140 unsigned LineNo, int FilenameID) { 141 std::vector<LineEntry> &Entries = LineEntries[FID]; 142 143 assert((Entries.empty() || Entries.back().FileOffset < Offset) && 144 "Adding line entries out of order!"); 145 146 SrcMgr::CharacteristicKind Kind = SrcMgr::C_User; 147 unsigned IncludeOffset = 0; 148 149 if (!Entries.empty()) { 150 // If this is a '#line 4' after '#line 42 "foo.h"', make sure to remember 151 // that we are still in "foo.h". 152 if (FilenameID == -1) 153 FilenameID = Entries.back().FilenameID; 154 155 // If we are after a line marker that switched us to system header mode, or 156 // that set #include information, preserve it. 157 Kind = Entries.back().FileKind; 158 IncludeOffset = Entries.back().IncludeOffset; 159 } 160 161 Entries.push_back(LineEntry::get(Offset, LineNo, FilenameID, Kind, 162 IncludeOffset)); 163} 164 165/// AddLineNote This is the same as the previous version of AddLineNote, but is 166/// used for GNU line markers. If EntryExit is 0, then this doesn't change the 167/// presumed #include stack. If it is 1, this is a file entry, if it is 2 then 168/// this is a file exit. FileKind specifies whether this is a system header or 169/// extern C system header. 170void LineTableInfo::AddLineNote(unsigned FID, unsigned Offset, 171 unsigned LineNo, int FilenameID, 172 unsigned EntryExit, 173 SrcMgr::CharacteristicKind FileKind) { 174 assert(FilenameID != -1 && "Unspecified filename should use other accessor"); 175 176 std::vector<LineEntry> &Entries = LineEntries[FID]; 177 178 assert((Entries.empty() || Entries.back().FileOffset < Offset) && 179 "Adding line entries out of order!"); 180 181 unsigned IncludeOffset = 0; 182 if (EntryExit == 0) { // No #include stack change. 183 IncludeOffset = Entries.empty() ? 0 : Entries.back().IncludeOffset; 184 } else if (EntryExit == 1) { 185 IncludeOffset = Offset-1; 186 } else if (EntryExit == 2) { 187 assert(!Entries.empty() && Entries.back().IncludeOffset && 188 "PPDirectives should have caught case when popping empty include stack"); 189 190 // Get the include loc of the last entries' include loc as our include loc. 191 IncludeOffset = 0; 192 if (const LineEntry *PrevEntry = 193 FindNearestLineEntry(FID, Entries.back().IncludeOffset)) 194 IncludeOffset = PrevEntry->IncludeOffset; 195 } 196 197 Entries.push_back(LineEntry::get(Offset, LineNo, FilenameID, FileKind, 198 IncludeOffset)); 199} 200 201 202/// FindNearestLineEntry - Find the line entry nearest to FID that is before 203/// it. If there is no line entry before Offset in FID, return null. 204const LineEntry *LineTableInfo::FindNearestLineEntry(unsigned FID, 205 unsigned Offset) { 206 const std::vector<LineEntry> &Entries = LineEntries[FID]; 207 assert(!Entries.empty() && "No #line entries for this FID after all!"); 208 209 // It is very common for the query to be after the last #line, check this 210 // first. 211 if (Entries.back().FileOffset <= Offset) 212 return &Entries.back(); 213 214 // Do a binary search to find the maximal element that is still before Offset. 215 std::vector<LineEntry>::const_iterator I = 216 std::upper_bound(Entries.begin(), Entries.end(), Offset); 217 if (I == Entries.begin()) return 0; 218 return &*--I; 219} 220 221/// \brief Add a new line entry that has already been encoded into 222/// the internal representation of the line table. 223void LineTableInfo::AddEntry(unsigned FID, 224 const std::vector<LineEntry> &Entries) { 225 LineEntries[FID] = Entries; 226} 227 228/// getLineTableFilenameID - Return the uniqued ID for the specified filename. 229/// 230unsigned SourceManager::getLineTableFilenameID(const char *Ptr, unsigned Len) { 231 if (LineTable == 0) 232 LineTable = new LineTableInfo(); 233 return LineTable->getLineTableFilenameID(Ptr, Len); 234} 235 236 237/// AddLineNote - Add a line note to the line table for the FileID and offset 238/// specified by Loc. If FilenameID is -1, it is considered to be 239/// unspecified. 240void SourceManager::AddLineNote(SourceLocation Loc, unsigned LineNo, 241 int FilenameID) { 242 std::pair<FileID, unsigned> LocInfo = getDecomposedInstantiationLoc(Loc); 243 244 const SrcMgr::FileInfo &FileInfo = getSLocEntry(LocInfo.first).getFile(); 245 246 // Remember that this file has #line directives now if it doesn't already. 247 const_cast<SrcMgr::FileInfo&>(FileInfo).setHasLineDirectives(); 248 249 if (LineTable == 0) 250 LineTable = new LineTableInfo(); 251 LineTable->AddLineNote(LocInfo.first.ID, LocInfo.second, LineNo, FilenameID); 252} 253 254/// AddLineNote - Add a GNU line marker to the line table. 255void SourceManager::AddLineNote(SourceLocation Loc, unsigned LineNo, 256 int FilenameID, bool IsFileEntry, 257 bool IsFileExit, bool IsSystemHeader, 258 bool IsExternCHeader) { 259 // If there is no filename and no flags, this is treated just like a #line, 260 // which does not change the flags of the previous line marker. 261 if (FilenameID == -1) { 262 assert(!IsFileEntry && !IsFileExit && !IsSystemHeader && !IsExternCHeader && 263 "Can't set flags without setting the filename!"); 264 return AddLineNote(Loc, LineNo, FilenameID); 265 } 266 267 std::pair<FileID, unsigned> LocInfo = getDecomposedInstantiationLoc(Loc); 268 const SrcMgr::FileInfo &FileInfo = getSLocEntry(LocInfo.first).getFile(); 269 270 // Remember that this file has #line directives now if it doesn't already. 271 const_cast<SrcMgr::FileInfo&>(FileInfo).setHasLineDirectives(); 272 273 if (LineTable == 0) 274 LineTable = new LineTableInfo(); 275 276 SrcMgr::CharacteristicKind FileKind; 277 if (IsExternCHeader) 278 FileKind = SrcMgr::C_ExternCSystem; 279 else if (IsSystemHeader) 280 FileKind = SrcMgr::C_System; 281 else 282 FileKind = SrcMgr::C_User; 283 284 unsigned EntryExit = 0; 285 if (IsFileEntry) 286 EntryExit = 1; 287 else if (IsFileExit) 288 EntryExit = 2; 289 290 LineTable->AddLineNote(LocInfo.first.ID, LocInfo.second, LineNo, FilenameID, 291 EntryExit, FileKind); 292} 293 294LineTableInfo &SourceManager::getLineTable() { 295 if (LineTable == 0) 296 LineTable = new LineTableInfo(); 297 return *LineTable; 298} 299 300//===----------------------------------------------------------------------===// 301// Private 'Create' methods. 302//===----------------------------------------------------------------------===// 303 304SourceManager::~SourceManager() { 305 delete LineTable; 306 307 // Delete FileEntry objects corresponding to content caches. Since the actual 308 // content cache objects are bump pointer allocated, we just have to run the 309 // dtors, but we call the deallocate method for completeness. 310 for (unsigned i = 0, e = MemBufferInfos.size(); i != e; ++i) { 311 MemBufferInfos[i]->~ContentCache(); 312 ContentCacheAlloc.Deallocate(MemBufferInfos[i]); 313 } 314 for (llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*>::iterator 315 I = FileInfos.begin(), E = FileInfos.end(); I != E; ++I) { 316 I->second->~ContentCache(); 317 ContentCacheAlloc.Deallocate(I->second); 318 } 319} 320 321void SourceManager::clearIDTables() { 322 MainFileID = FileID(); 323 SLocEntryTable.clear(); 324 LastLineNoFileIDQuery = FileID(); 325 LastLineNoContentCache = 0; 326 LastFileIDLookup = FileID(); 327 328 if (LineTable) 329 LineTable->clear(); 330 331 // Use up FileID #0 as an invalid instantiation. 332 NextOffset = 0; 333 createInstantiationLoc(SourceLocation(),SourceLocation(),SourceLocation(), 1); 334} 335 336/// getOrCreateContentCache - Create or return a cached ContentCache for the 337/// specified file. 338const ContentCache * 339SourceManager::getOrCreateContentCache(const FileEntry *FileEnt) { 340 assert(FileEnt && "Didn't specify a file entry to use?"); 341 342 // Do we already have information about this file? 343 ContentCache *&Entry = FileInfos[FileEnt]; 344 if (Entry) return Entry; 345 346 // Nope, create a new Cache entry. Make sure it is at least 8-byte aligned 347 // so that FileInfo can use the low 3 bits of the pointer for its own 348 // nefarious purposes. 349 unsigned EntryAlign = llvm::AlignOf<ContentCache>::Alignment; 350 EntryAlign = std::max(8U, EntryAlign); 351 Entry = ContentCacheAlloc.Allocate<ContentCache>(1, EntryAlign); 352 new (Entry) ContentCache(FileEnt); 353 return Entry; 354} 355 356 357/// createMemBufferContentCache - Create a new ContentCache for the specified 358/// memory buffer. This does no caching. 359const ContentCache* 360SourceManager::createMemBufferContentCache(const MemoryBuffer *Buffer) { 361 // Add a new ContentCache to the MemBufferInfos list and return it. Make sure 362 // it is at least 8-byte aligned so that FileInfo can use the low 3 bits of 363 // the pointer for its own nefarious purposes. 364 unsigned EntryAlign = llvm::AlignOf<ContentCache>::Alignment; 365 EntryAlign = std::max(8U, EntryAlign); 366 ContentCache *Entry = ContentCacheAlloc.Allocate<ContentCache>(1, EntryAlign); 367 new (Entry) ContentCache(); 368 MemBufferInfos.push_back(Entry); 369 Entry->setBuffer(Buffer); 370 return Entry; 371} 372 373void SourceManager::PreallocateSLocEntries(ExternalSLocEntrySource *Source, 374 unsigned NumSLocEntries, 375 unsigned NextOffset) { 376 ExternalSLocEntries = Source; 377 this->NextOffset = NextOffset; 378 SLocEntryLoaded.resize(NumSLocEntries + 1); 379 SLocEntryLoaded[0] = true; 380 SLocEntryTable.resize(SLocEntryTable.size() + NumSLocEntries); 381} 382 383void SourceManager::ClearPreallocatedSLocEntries() { 384 unsigned I = 0; 385 for (unsigned N = SLocEntryLoaded.size(); I != N; ++I) 386 if (!SLocEntryLoaded[I]) 387 break; 388 389 // We've already loaded all preallocated source location entries. 390 if (I == SLocEntryLoaded.size()) 391 return; 392 393 // Remove everything from location I onward. 394 SLocEntryTable.resize(I); 395 SLocEntryLoaded.clear(); 396 ExternalSLocEntries = 0; 397} 398 399 400//===----------------------------------------------------------------------===// 401// Methods to create new FileID's and instantiations. 402//===----------------------------------------------------------------------===// 403 404/// createFileID - Create a new fileID for the specified ContentCache and 405/// include position. This works regardless of whether the ContentCache 406/// corresponds to a file or some other input source. 407FileID SourceManager::createFileID(const ContentCache *File, 408 SourceLocation IncludePos, 409 SrcMgr::CharacteristicKind FileCharacter, 410 unsigned PreallocatedID, 411 unsigned Offset) { 412 if (PreallocatedID) { 413 // If we're filling in a preallocated ID, just load in the file 414 // entry and return. 415 assert(PreallocatedID < SLocEntryLoaded.size() && 416 "Preallocate ID out-of-range"); 417 assert(!SLocEntryLoaded[PreallocatedID] && 418 "Source location entry already loaded"); 419 assert(Offset && "Preallocate source location cannot have zero offset"); 420 SLocEntryTable[PreallocatedID] 421 = SLocEntry::get(Offset, FileInfo::get(IncludePos, File, FileCharacter)); 422 SLocEntryLoaded[PreallocatedID] = true; 423 FileID FID = FileID::get(PreallocatedID); 424 return FID; 425 } 426 427 SLocEntryTable.push_back(SLocEntry::get(NextOffset, 428 FileInfo::get(IncludePos, File, 429 FileCharacter))); 430 unsigned FileSize = File->getSize(); 431 assert(NextOffset+FileSize+1 > NextOffset && "Ran out of source locations!"); 432 NextOffset += FileSize+1; 433 434 // Set LastFileIDLookup to the newly created file. The next getFileID call is 435 // almost guaranteed to be from that file. 436 FileID FID = FileID::get(SLocEntryTable.size()-1); 437 return LastFileIDLookup = FID; 438} 439 440/// createInstantiationLoc - Return a new SourceLocation that encodes the fact 441/// that a token from SpellingLoc should actually be referenced from 442/// InstantiationLoc. 443SourceLocation SourceManager::createInstantiationLoc(SourceLocation SpellingLoc, 444 SourceLocation ILocStart, 445 SourceLocation ILocEnd, 446 unsigned TokLength, 447 unsigned PreallocatedID, 448 unsigned Offset) { 449 InstantiationInfo II = InstantiationInfo::get(ILocStart,ILocEnd, SpellingLoc); 450 if (PreallocatedID) { 451 // If we're filling in a preallocated ID, just load in the 452 // instantiation entry and return. 453 assert(PreallocatedID < SLocEntryLoaded.size() && 454 "Preallocate ID out-of-range"); 455 assert(!SLocEntryLoaded[PreallocatedID] && 456 "Source location entry already loaded"); 457 assert(Offset && "Preallocate source location cannot have zero offset"); 458 SLocEntryTable[PreallocatedID] = SLocEntry::get(Offset, II); 459 SLocEntryLoaded[PreallocatedID] = true; 460 return SourceLocation::getMacroLoc(Offset); 461 } 462 SLocEntryTable.push_back(SLocEntry::get(NextOffset, II)); 463 assert(NextOffset+TokLength+1 > NextOffset && "Ran out of source locations!"); 464 NextOffset += TokLength+1; 465 return SourceLocation::getMacroLoc(NextOffset-(TokLength+1)); 466} 467 468const llvm::MemoryBuffer * 469SourceManager::getMemoryBufferForFile(const FileEntry *File, 470 bool *Invalid) { 471 const SrcMgr::ContentCache *IR = getOrCreateContentCache(File); 472 assert(IR && "getOrCreateContentCache() cannot return NULL"); 473 return IR->getBuffer(Diag, Invalid); 474} 475 476bool SourceManager::overrideFileContents(const FileEntry *SourceFile, 477 const llvm::MemoryBuffer *Buffer) { 478 const SrcMgr::ContentCache *IR = getOrCreateContentCache(SourceFile); 479 if (IR == 0) 480 return true; 481 482 const_cast<SrcMgr::ContentCache *>(IR)->replaceBuffer(Buffer); 483 return false; 484} 485 486llvm::StringRef SourceManager::getBufferData(FileID FID, bool *Invalid) const { 487 bool MyInvalid = false; 488 const llvm::MemoryBuffer *Buf = getBuffer(FID, &MyInvalid); 489 if (Invalid) 490 *Invalid = MyInvalid; 491 492 if (MyInvalid) 493 return ""; 494 495 return Buf->getBuffer(); 496} 497 498//===----------------------------------------------------------------------===// 499// SourceLocation manipulation methods. 500//===----------------------------------------------------------------------===// 501 502/// getFileIDSlow - Return the FileID for a SourceLocation. This is a very hot 503/// method that is used for all SourceManager queries that start with a 504/// SourceLocation object. It is responsible for finding the entry in 505/// SLocEntryTable which contains the specified location. 506/// 507FileID SourceManager::getFileIDSlow(unsigned SLocOffset) const { 508 assert(SLocOffset && "Invalid FileID"); 509 510 // After the first and second level caches, I see two common sorts of 511 // behavior: 1) a lot of searched FileID's are "near" the cached file location 512 // or are "near" the cached instantiation location. 2) others are just 513 // completely random and may be a very long way away. 514 // 515 // To handle this, we do a linear search for up to 8 steps to catch #1 quickly 516 // then we fall back to a less cache efficient, but more scalable, binary 517 // search to find the location. 518 519 // See if this is near the file point - worst case we start scanning from the 520 // most newly created FileID. 521 std::vector<SrcMgr::SLocEntry>::const_iterator I; 522 523 if (SLocEntryTable[LastFileIDLookup.ID].getOffset() < SLocOffset) { 524 // Neither loc prunes our search. 525 I = SLocEntryTable.end(); 526 } else { 527 // Perhaps it is near the file point. 528 I = SLocEntryTable.begin()+LastFileIDLookup.ID; 529 } 530 531 // Find the FileID that contains this. "I" is an iterator that points to a 532 // FileID whose offset is known to be larger than SLocOffset. 533 unsigned NumProbes = 0; 534 while (1) { 535 --I; 536 if (ExternalSLocEntries) 537 getSLocEntry(FileID::get(I - SLocEntryTable.begin())); 538 if (I->getOffset() <= SLocOffset) { 539#if 0 540 printf("lin %d -> %d [%s] %d %d\n", SLocOffset, 541 I-SLocEntryTable.begin(), 542 I->isInstantiation() ? "inst" : "file", 543 LastFileIDLookup.ID, int(SLocEntryTable.end()-I)); 544#endif 545 FileID Res = FileID::get(I-SLocEntryTable.begin()); 546 547 // If this isn't an instantiation, remember it. We have good locality 548 // across FileID lookups. 549 if (!I->isInstantiation()) 550 LastFileIDLookup = Res; 551 NumLinearScans += NumProbes+1; 552 return Res; 553 } 554 if (++NumProbes == 8) 555 break; 556 } 557 558 // Convert "I" back into an index. We know that it is an entry whose index is 559 // larger than the offset we are looking for. 560 unsigned GreaterIndex = I-SLocEntryTable.begin(); 561 // LessIndex - This is the lower bound of the range that we're searching. 562 // We know that the offset corresponding to the FileID is is less than 563 // SLocOffset. 564 unsigned LessIndex = 0; 565 NumProbes = 0; 566 while (1) { 567 unsigned MiddleIndex = (GreaterIndex-LessIndex)/2+LessIndex; 568 unsigned MidOffset = getSLocEntry(FileID::get(MiddleIndex)).getOffset(); 569 570 ++NumProbes; 571 572 // If the offset of the midpoint is too large, chop the high side of the 573 // range to the midpoint. 574 if (MidOffset > SLocOffset) { 575 GreaterIndex = MiddleIndex; 576 continue; 577 } 578 579 // If the middle index contains the value, succeed and return. 580 if (isOffsetInFileID(FileID::get(MiddleIndex), SLocOffset)) { 581#if 0 582 printf("bin %d -> %d [%s] %d %d\n", SLocOffset, 583 I-SLocEntryTable.begin(), 584 I->isInstantiation() ? "inst" : "file", 585 LastFileIDLookup.ID, int(SLocEntryTable.end()-I)); 586#endif 587 FileID Res = FileID::get(MiddleIndex); 588 589 // If this isn't an instantiation, remember it. We have good locality 590 // across FileID lookups. 591 if (!I->isInstantiation()) 592 LastFileIDLookup = Res; 593 NumBinaryProbes += NumProbes; 594 return Res; 595 } 596 597 // Otherwise, move the low-side up to the middle index. 598 LessIndex = MiddleIndex; 599 } 600} 601 602SourceLocation SourceManager:: 603getInstantiationLocSlowCase(SourceLocation Loc) const { 604 do { 605 // Note: If Loc indicates an offset into a token that came from a macro 606 // expansion (e.g. the 5th character of the token) we do not want to add 607 // this offset when going to the instantiation location. The instatiation 608 // location is the macro invocation, which the offset has nothing to do 609 // with. This is unlike when we get the spelling loc, because the offset 610 // directly correspond to the token whose spelling we're inspecting. 611 Loc = getSLocEntry(getFileID(Loc)).getInstantiation() 612 .getInstantiationLocStart(); 613 } while (!Loc.isFileID()); 614 615 return Loc; 616} 617 618SourceLocation SourceManager::getSpellingLocSlowCase(SourceLocation Loc) const { 619 do { 620 std::pair<FileID, unsigned> LocInfo = getDecomposedLoc(Loc); 621 Loc = getSLocEntry(LocInfo.first).getInstantiation().getSpellingLoc(); 622 Loc = Loc.getFileLocWithOffset(LocInfo.second); 623 } while (!Loc.isFileID()); 624 return Loc; 625} 626 627 628std::pair<FileID, unsigned> 629SourceManager::getDecomposedInstantiationLocSlowCase(const SrcMgr::SLocEntry *E, 630 unsigned Offset) const { 631 // If this is an instantiation record, walk through all the instantiation 632 // points. 633 FileID FID; 634 SourceLocation Loc; 635 do { 636 Loc = E->getInstantiation().getInstantiationLocStart(); 637 638 FID = getFileID(Loc); 639 E = &getSLocEntry(FID); 640 Offset += Loc.getOffset()-E->getOffset(); 641 } while (!Loc.isFileID()); 642 643 return std::make_pair(FID, Offset); 644} 645 646std::pair<FileID, unsigned> 647SourceManager::getDecomposedSpellingLocSlowCase(const SrcMgr::SLocEntry *E, 648 unsigned Offset) const { 649 // If this is an instantiation record, walk through all the instantiation 650 // points. 651 FileID FID; 652 SourceLocation Loc; 653 do { 654 Loc = E->getInstantiation().getSpellingLoc(); 655 656 FID = getFileID(Loc); 657 E = &getSLocEntry(FID); 658 Offset += Loc.getOffset()-E->getOffset(); 659 } while (!Loc.isFileID()); 660 661 return std::make_pair(FID, Offset); 662} 663 664/// getImmediateSpellingLoc - Given a SourceLocation object, return the 665/// spelling location referenced by the ID. This is the first level down 666/// towards the place where the characters that make up the lexed token can be 667/// found. This should not generally be used by clients. 668SourceLocation SourceManager::getImmediateSpellingLoc(SourceLocation Loc) const{ 669 if (Loc.isFileID()) return Loc; 670 std::pair<FileID, unsigned> LocInfo = getDecomposedLoc(Loc); 671 Loc = getSLocEntry(LocInfo.first).getInstantiation().getSpellingLoc(); 672 return Loc.getFileLocWithOffset(LocInfo.second); 673} 674 675 676/// getImmediateInstantiationRange - Loc is required to be an instantiation 677/// location. Return the start/end of the instantiation information. 678std::pair<SourceLocation,SourceLocation> 679SourceManager::getImmediateInstantiationRange(SourceLocation Loc) const { 680 assert(Loc.isMacroID() && "Not an instantiation loc!"); 681 const InstantiationInfo &II = getSLocEntry(getFileID(Loc)).getInstantiation(); 682 return II.getInstantiationLocRange(); 683} 684 685/// getInstantiationRange - Given a SourceLocation object, return the 686/// range of tokens covered by the instantiation in the ultimate file. 687std::pair<SourceLocation,SourceLocation> 688SourceManager::getInstantiationRange(SourceLocation Loc) const { 689 if (Loc.isFileID()) return std::make_pair(Loc, Loc); 690 691 std::pair<SourceLocation,SourceLocation> Res = 692 getImmediateInstantiationRange(Loc); 693 694 // Fully resolve the start and end locations to their ultimate instantiation 695 // points. 696 while (!Res.first.isFileID()) 697 Res.first = getImmediateInstantiationRange(Res.first).first; 698 while (!Res.second.isFileID()) 699 Res.second = getImmediateInstantiationRange(Res.second).second; 700 return Res; 701} 702 703 704 705//===----------------------------------------------------------------------===// 706// Queries about the code at a SourceLocation. 707//===----------------------------------------------------------------------===// 708 709/// getCharacterData - Return a pointer to the start of the specified location 710/// in the appropriate MemoryBuffer. 711const char *SourceManager::getCharacterData(SourceLocation SL, 712 bool *Invalid) const { 713 // Note that this is a hot function in the getSpelling() path, which is 714 // heavily used by -E mode. 715 std::pair<FileID, unsigned> LocInfo = getDecomposedSpellingLoc(SL); 716 717 // Note that calling 'getBuffer()' may lazily page in a source file. 718 bool CharDataInvalid = false; 719 const llvm::MemoryBuffer *Buffer 720 = getSLocEntry(LocInfo.first).getFile().getContentCache()->getBuffer(Diag, 721 &CharDataInvalid); 722 if (Invalid) 723 *Invalid = CharDataInvalid; 724 return Buffer->getBufferStart() + (CharDataInvalid? 0 : LocInfo.second); 725} 726 727 728/// getColumnNumber - Return the column # for the specified file position. 729/// this is significantly cheaper to compute than the line number. 730unsigned SourceManager::getColumnNumber(FileID FID, unsigned FilePos, 731 bool *Invalid) const { 732 bool MyInvalid = false; 733 const char *Buf = getBuffer(FID, &MyInvalid)->getBufferStart(); 734 if (Invalid) 735 *Invalid = MyInvalid; 736 737 if (MyInvalid) 738 return 1; 739 740 unsigned LineStart = FilePos; 741 while (LineStart && Buf[LineStart-1] != '\n' && Buf[LineStart-1] != '\r') 742 --LineStart; 743 return FilePos-LineStart+1; 744} 745 746unsigned SourceManager::getSpellingColumnNumber(SourceLocation Loc, 747 bool *Invalid) const { 748 if (Loc.isInvalid()) return 0; 749 std::pair<FileID, unsigned> LocInfo = getDecomposedSpellingLoc(Loc); 750 return getColumnNumber(LocInfo.first, LocInfo.second, Invalid); 751} 752 753unsigned SourceManager::getInstantiationColumnNumber(SourceLocation Loc, 754 bool *Invalid) const { 755 if (Loc.isInvalid()) return 0; 756 std::pair<FileID, unsigned> LocInfo = getDecomposedInstantiationLoc(Loc); 757 return getColumnNumber(LocInfo.first, LocInfo.second, Invalid); 758} 759 760static DISABLE_INLINE void ComputeLineNumbers(Diagnostic &Diag, 761 ContentCache* FI, 762 llvm::BumpPtrAllocator &Alloc, 763 bool &Invalid); 764static void ComputeLineNumbers(Diagnostic &Diag, ContentCache* FI, 765 llvm::BumpPtrAllocator &Alloc, bool &Invalid) { 766 // Note that calling 'getBuffer()' may lazily page in the file. 767 const MemoryBuffer *Buffer = FI->getBuffer(Diag, &Invalid); 768 if (Invalid) 769 return; 770 771 // Find the file offsets of all of the *physical* source lines. This does 772 // not look at trigraphs, escaped newlines, or anything else tricky. 773 std::vector<unsigned> LineOffsets; 774 775 // Line #1 starts at char 0. 776 LineOffsets.push_back(0); 777 778 const unsigned char *Buf = (const unsigned char *)Buffer->getBufferStart(); 779 const unsigned char *End = (const unsigned char *)Buffer->getBufferEnd(); 780 unsigned Offs = 0; 781 while (1) { 782 // Skip over the contents of the line. 783 // TODO: Vectorize this? This is very performance sensitive for programs 784 // with lots of diagnostics and in -E mode. 785 const unsigned char *NextBuf = (const unsigned char *)Buf; 786 while (*NextBuf != '\n' && *NextBuf != '\r' && *NextBuf != '\0') 787 ++NextBuf; 788 Offs += NextBuf-Buf; 789 Buf = NextBuf; 790 791 if (Buf[0] == '\n' || Buf[0] == '\r') { 792 // If this is \n\r or \r\n, skip both characters. 793 if ((Buf[1] == '\n' || Buf[1] == '\r') && Buf[0] != Buf[1]) 794 ++Offs, ++Buf; 795 ++Offs, ++Buf; 796 LineOffsets.push_back(Offs); 797 } else { 798 // Otherwise, this is a null. If end of file, exit. 799 if (Buf == End) break; 800 // Otherwise, skip the null. 801 ++Offs, ++Buf; 802 } 803 } 804 805 // Copy the offsets into the FileInfo structure. 806 FI->NumLines = LineOffsets.size(); 807 FI->SourceLineCache = Alloc.Allocate<unsigned>(LineOffsets.size()); 808 std::copy(LineOffsets.begin(), LineOffsets.end(), FI->SourceLineCache); 809} 810 811/// getLineNumber - Given a SourceLocation, return the spelling line number 812/// for the position indicated. This requires building and caching a table of 813/// line offsets for the MemoryBuffer, so this is not cheap: use only when 814/// about to emit a diagnostic. 815unsigned SourceManager::getLineNumber(FileID FID, unsigned FilePos, 816 bool *Invalid) const { 817 ContentCache *Content; 818 if (LastLineNoFileIDQuery == FID) 819 Content = LastLineNoContentCache; 820 else 821 Content = const_cast<ContentCache*>(getSLocEntry(FID) 822 .getFile().getContentCache()); 823 824 // If this is the first use of line information for this buffer, compute the 825 /// SourceLineCache for it on demand. 826 if (Content->SourceLineCache == 0) { 827 bool MyInvalid = false; 828 ComputeLineNumbers(Diag, Content, ContentCacheAlloc, MyInvalid); 829 if (Invalid) 830 *Invalid = MyInvalid; 831 if (MyInvalid) 832 return 1; 833 } else if (Invalid) 834 *Invalid = false; 835 836 // Okay, we know we have a line number table. Do a binary search to find the 837 // line number that this character position lands on. 838 unsigned *SourceLineCache = Content->SourceLineCache; 839 unsigned *SourceLineCacheStart = SourceLineCache; 840 unsigned *SourceLineCacheEnd = SourceLineCache + Content->NumLines; 841 842 unsigned QueriedFilePos = FilePos+1; 843 844 // FIXME: I would like to be convinced that this code is worth being as 845 // complicated as it is, binary search isn't that slow. 846 // 847 // If it is worth being optimized, then in my opinion it could be more 848 // performant, simpler, and more obviously correct by just "galloping" outward 849 // from the queried file position. In fact, this could be incorporated into a 850 // generic algorithm such as lower_bound_with_hint. 851 // 852 // If someone gives me a test case where this matters, and I will do it! - DWD 853 854 // If the previous query was to the same file, we know both the file pos from 855 // that query and the line number returned. This allows us to narrow the 856 // search space from the entire file to something near the match. 857 if (LastLineNoFileIDQuery == FID) { 858 if (QueriedFilePos >= LastLineNoFilePos) { 859 // FIXME: Potential overflow? 860 SourceLineCache = SourceLineCache+LastLineNoResult-1; 861 862 // The query is likely to be nearby the previous one. Here we check to 863 // see if it is within 5, 10 or 20 lines. It can be far away in cases 864 // where big comment blocks and vertical whitespace eat up lines but 865 // contribute no tokens. 866 if (SourceLineCache+5 < SourceLineCacheEnd) { 867 if (SourceLineCache[5] > QueriedFilePos) 868 SourceLineCacheEnd = SourceLineCache+5; 869 else if (SourceLineCache+10 < SourceLineCacheEnd) { 870 if (SourceLineCache[10] > QueriedFilePos) 871 SourceLineCacheEnd = SourceLineCache+10; 872 else if (SourceLineCache+20 < SourceLineCacheEnd) { 873 if (SourceLineCache[20] > QueriedFilePos) 874 SourceLineCacheEnd = SourceLineCache+20; 875 } 876 } 877 } 878 } else { 879 if (LastLineNoResult < Content->NumLines) 880 SourceLineCacheEnd = SourceLineCache+LastLineNoResult+1; 881 } 882 } 883 884 // If the spread is large, do a "radix" test as our initial guess, based on 885 // the assumption that lines average to approximately the same length. 886 // NOTE: This is currently disabled, as it does not appear to be profitable in 887 // initial measurements. 888 if (0 && SourceLineCacheEnd-SourceLineCache > 20) { 889 unsigned FileLen = Content->SourceLineCache[Content->NumLines-1]; 890 891 // Take a stab at guessing where it is. 892 unsigned ApproxPos = Content->NumLines*QueriedFilePos / FileLen; 893 894 // Check for -10 and +10 lines. 895 unsigned LowerBound = std::max(int(ApproxPos-10), 0); 896 unsigned UpperBound = std::min(ApproxPos+10, FileLen); 897 898 // If the computed lower bound is less than the query location, move it in. 899 if (SourceLineCache < SourceLineCacheStart+LowerBound && 900 SourceLineCacheStart[LowerBound] < QueriedFilePos) 901 SourceLineCache = SourceLineCacheStart+LowerBound; 902 903 // If the computed upper bound is greater than the query location, move it. 904 if (SourceLineCacheEnd > SourceLineCacheStart+UpperBound && 905 SourceLineCacheStart[UpperBound] >= QueriedFilePos) 906 SourceLineCacheEnd = SourceLineCacheStart+UpperBound; 907 } 908 909 unsigned *Pos 910 = std::lower_bound(SourceLineCache, SourceLineCacheEnd, QueriedFilePos); 911 unsigned LineNo = Pos-SourceLineCacheStart; 912 913 LastLineNoFileIDQuery = FID; 914 LastLineNoContentCache = Content; 915 LastLineNoFilePos = QueriedFilePos; 916 LastLineNoResult = LineNo; 917 return LineNo; 918} 919 920unsigned SourceManager::getInstantiationLineNumber(SourceLocation Loc, 921 bool *Invalid) const { 922 if (Loc.isInvalid()) return 0; 923 std::pair<FileID, unsigned> LocInfo = getDecomposedInstantiationLoc(Loc); 924 return getLineNumber(LocInfo.first, LocInfo.second); 925} 926unsigned SourceManager::getSpellingLineNumber(SourceLocation Loc, 927 bool *Invalid) const { 928 if (Loc.isInvalid()) return 0; 929 std::pair<FileID, unsigned> LocInfo = getDecomposedSpellingLoc(Loc); 930 return getLineNumber(LocInfo.first, LocInfo.second); 931} 932 933/// getFileCharacteristic - return the file characteristic of the specified 934/// source location, indicating whether this is a normal file, a system 935/// header, or an "implicit extern C" system header. 936/// 937/// This state can be modified with flags on GNU linemarker directives like: 938/// # 4 "foo.h" 3 939/// which changes all source locations in the current file after that to be 940/// considered to be from a system header. 941SrcMgr::CharacteristicKind 942SourceManager::getFileCharacteristic(SourceLocation Loc) const { 943 assert(!Loc.isInvalid() && "Can't get file characteristic of invalid loc!"); 944 std::pair<FileID, unsigned> LocInfo = getDecomposedInstantiationLoc(Loc); 945 const SrcMgr::FileInfo &FI = getSLocEntry(LocInfo.first).getFile(); 946 947 // If there are no #line directives in this file, just return the whole-file 948 // state. 949 if (!FI.hasLineDirectives()) 950 return FI.getFileCharacteristic(); 951 952 assert(LineTable && "Can't have linetable entries without a LineTable!"); 953 // See if there is a #line directive before the location. 954 const LineEntry *Entry = 955 LineTable->FindNearestLineEntry(LocInfo.first.ID, LocInfo.second); 956 957 // If this is before the first line marker, use the file characteristic. 958 if (!Entry) 959 return FI.getFileCharacteristic(); 960 961 return Entry->FileKind; 962} 963 964/// Return the filename or buffer identifier of the buffer the location is in. 965/// Note that this name does not respect #line directives. Use getPresumedLoc 966/// for normal clients. 967const char *SourceManager::getBufferName(SourceLocation Loc, 968 bool *Invalid) const { 969 if (Loc.isInvalid()) return "<invalid loc>"; 970 971 return getBuffer(getFileID(Loc), Invalid)->getBufferIdentifier(); 972} 973 974 975/// getPresumedLoc - This method returns the "presumed" location of a 976/// SourceLocation specifies. A "presumed location" can be modified by #line 977/// or GNU line marker directives. This provides a view on the data that a 978/// user should see in diagnostics, for example. 979/// 980/// Note that a presumed location is always given as the instantiation point 981/// of an instantiation location, not at the spelling location. 982PresumedLoc SourceManager::getPresumedLoc(SourceLocation Loc) const { 983 if (Loc.isInvalid()) return PresumedLoc(); 984 985 // Presumed locations are always for instantiation points. 986 std::pair<FileID, unsigned> LocInfo = getDecomposedInstantiationLoc(Loc); 987 988 const SrcMgr::FileInfo &FI = getSLocEntry(LocInfo.first).getFile(); 989 const SrcMgr::ContentCache *C = FI.getContentCache(); 990 991 // To get the source name, first consult the FileEntry (if one exists) 992 // before the MemBuffer as this will avoid unnecessarily paging in the 993 // MemBuffer. 994 const char *Filename = 995 C->Entry ? C->Entry->getName() : C->getBuffer(Diag)->getBufferIdentifier(); 996 unsigned LineNo = getLineNumber(LocInfo.first, LocInfo.second); 997 unsigned ColNo = getColumnNumber(LocInfo.first, LocInfo.second); 998 SourceLocation IncludeLoc = FI.getIncludeLoc(); 999 1000 // If we have #line directives in this file, update and overwrite the physical 1001 // location info if appropriate. 1002 if (FI.hasLineDirectives()) { 1003 assert(LineTable && "Can't have linetable entries without a LineTable!"); 1004 // See if there is a #line directive before this. If so, get it. 1005 if (const LineEntry *Entry = 1006 LineTable->FindNearestLineEntry(LocInfo.first.ID, LocInfo.second)) { 1007 // If the LineEntry indicates a filename, use it. 1008 if (Entry->FilenameID != -1) 1009 Filename = LineTable->getFilename(Entry->FilenameID); 1010 1011 // Use the line number specified by the LineEntry. This line number may 1012 // be multiple lines down from the line entry. Add the difference in 1013 // physical line numbers from the query point and the line marker to the 1014 // total. 1015 unsigned MarkerLineNo = getLineNumber(LocInfo.first, Entry->FileOffset); 1016 LineNo = Entry->LineNo + (LineNo-MarkerLineNo-1); 1017 1018 // Note that column numbers are not molested by line markers. 1019 1020 // Handle virtual #include manipulation. 1021 if (Entry->IncludeOffset) { 1022 IncludeLoc = getLocForStartOfFile(LocInfo.first); 1023 IncludeLoc = IncludeLoc.getFileLocWithOffset(Entry->IncludeOffset); 1024 } 1025 } 1026 } 1027 1028 return PresumedLoc(Filename, LineNo, ColNo, IncludeLoc); 1029} 1030 1031//===----------------------------------------------------------------------===// 1032// Other miscellaneous methods. 1033//===----------------------------------------------------------------------===// 1034 1035/// \brief Get the source location for the given file:line:col triplet. 1036/// 1037/// If the source file is included multiple times, the source location will 1038/// be based upon the first inclusion. 1039SourceLocation SourceManager::getLocation(const FileEntry *SourceFile, 1040 unsigned Line, unsigned Col) const { 1041 assert(SourceFile && "Null source file!"); 1042 assert(Line && Col && "Line and column should start from 1!"); 1043 1044 fileinfo_iterator FI = FileInfos.find(SourceFile); 1045 if (FI == FileInfos.end()) 1046 return SourceLocation(); 1047 ContentCache *Content = FI->second; 1048 1049 // If this is the first use of line information for this buffer, compute the 1050 /// SourceLineCache for it on demand. 1051 if (Content->SourceLineCache == 0) { 1052 bool MyInvalid = false; 1053 ComputeLineNumbers(Diag, Content, ContentCacheAlloc, MyInvalid); 1054 if (MyInvalid) 1055 return SourceLocation(); 1056 } 1057 1058 // Find the first file ID that corresponds to the given file. 1059 FileID FirstFID; 1060 1061 // First, check the main file ID, since it is common to look for a 1062 // location in the main file. 1063 if (!MainFileID.isInvalid()) { 1064 const SLocEntry &MainSLoc = getSLocEntry(MainFileID); 1065 if (MainSLoc.isFile() && MainSLoc.getFile().getContentCache() == Content) 1066 FirstFID = MainFileID; 1067 } 1068 1069 if (FirstFID.isInvalid()) { 1070 // The location we're looking for isn't in the main file; look 1071 // through all of the source locations. 1072 for (unsigned I = 0, N = sloc_entry_size(); I != N; ++I) { 1073 const SLocEntry &SLoc = getSLocEntry(I); 1074 if (SLoc.isFile() && SLoc.getFile().getContentCache() == Content) { 1075 FirstFID = FileID::get(I); 1076 break; 1077 } 1078 } 1079 } 1080 1081 if (FirstFID.isInvalid()) 1082 return SourceLocation(); 1083 1084 if (Line > Content->NumLines) { 1085 unsigned Size = Content->getBuffer(Diag)->getBufferSize(); 1086 if (Size > 0) 1087 --Size; 1088 return getLocForStartOfFile(FirstFID).getFileLocWithOffset(Size); 1089 } 1090 1091 unsigned FilePos = Content->SourceLineCache[Line - 1]; 1092 const char *Buf = Content->getBuffer(Diag)->getBufferStart() + FilePos; 1093 unsigned BufLength = Content->getBuffer(Diag)->getBufferEnd() - Buf; 1094 unsigned i = 0; 1095 1096 // Check that the given column is valid. 1097 while (i < BufLength-1 && i < Col-1 && Buf[i] != '\n' && Buf[i] != '\r') 1098 ++i; 1099 if (i < Col-1) 1100 return getLocForStartOfFile(FirstFID).getFileLocWithOffset(FilePos + i); 1101 1102 return getLocForStartOfFile(FirstFID).getFileLocWithOffset(FilePos + Col - 1); 1103} 1104 1105/// \brief Determines the order of 2 source locations in the translation unit. 1106/// 1107/// \returns true if LHS source location comes before RHS, false otherwise. 1108bool SourceManager::isBeforeInTranslationUnit(SourceLocation LHS, 1109 SourceLocation RHS) const { 1110 assert(LHS.isValid() && RHS.isValid() && "Passed invalid source location!"); 1111 if (LHS == RHS) 1112 return false; 1113 1114 std::pair<FileID, unsigned> LOffs = getDecomposedLoc(LHS); 1115 std::pair<FileID, unsigned> ROffs = getDecomposedLoc(RHS); 1116 1117 // If the source locations are in the same file, just compare offsets. 1118 if (LOffs.first == ROffs.first) 1119 return LOffs.second < ROffs.second; 1120 1121 // If we are comparing a source location with multiple locations in the same 1122 // file, we get a big win by caching the result. 1123 1124 if (LastLFIDForBeforeTUCheck == LOffs.first && 1125 LastRFIDForBeforeTUCheck == ROffs.first) 1126 return LastResForBeforeTUCheck; 1127 1128 LastLFIDForBeforeTUCheck = LOffs.first; 1129 LastRFIDForBeforeTUCheck = ROffs.first; 1130 1131 // "Traverse" the include/instantiation stacks of both locations and try to 1132 // find a common "ancestor". 1133 // 1134 // First we traverse the stack of the right location and check each level 1135 // against the level of the left location, while collecting all levels in a 1136 // "stack map". 1137 1138 std::map<FileID, unsigned> ROffsMap; 1139 ROffsMap[ROffs.first] = ROffs.second; 1140 1141 while (1) { 1142 SourceLocation UpperLoc; 1143 const SrcMgr::SLocEntry &Entry = getSLocEntry(ROffs.first); 1144 if (Entry.isInstantiation()) 1145 UpperLoc = Entry.getInstantiation().getInstantiationLocStart(); 1146 else 1147 UpperLoc = Entry.getFile().getIncludeLoc(); 1148 1149 if (UpperLoc.isInvalid()) 1150 break; // We reached the top. 1151 1152 ROffs = getDecomposedLoc(UpperLoc); 1153 1154 if (LOffs.first == ROffs.first) 1155 return LastResForBeforeTUCheck = LOffs.second < ROffs.second; 1156 1157 ROffsMap[ROffs.first] = ROffs.second; 1158 } 1159 1160 // We didn't find a common ancestor. Now traverse the stack of the left 1161 // location, checking against the stack map of the right location. 1162 1163 while (1) { 1164 SourceLocation UpperLoc; 1165 const SrcMgr::SLocEntry &Entry = getSLocEntry(LOffs.first); 1166 if (Entry.isInstantiation()) 1167 UpperLoc = Entry.getInstantiation().getInstantiationLocStart(); 1168 else 1169 UpperLoc = Entry.getFile().getIncludeLoc(); 1170 1171 if (UpperLoc.isInvalid()) 1172 break; // We reached the top. 1173 1174 LOffs = getDecomposedLoc(UpperLoc); 1175 1176 std::map<FileID, unsigned>::iterator I = ROffsMap.find(LOffs.first); 1177 if (I != ROffsMap.end()) 1178 return LastResForBeforeTUCheck = LOffs.second < I->second; 1179 } 1180 1181 // There is no common ancestor, most probably because one location is in the 1182 // predefines buffer. 1183 // 1184 // FIXME: We should rearrange the external interface so this simply never 1185 // happens; it can't conceptually happen. Also see PR5662. 1186 1187 // If exactly one location is a memory buffer, assume it preceeds the other. 1188 bool LIsMB = !getSLocEntry(LOffs.first).getFile().getContentCache()->Entry; 1189 bool RIsMB = !getSLocEntry(ROffs.first).getFile().getContentCache()->Entry; 1190 if (LIsMB != RIsMB) 1191 return LastResForBeforeTUCheck = LIsMB; 1192 1193 // Otherwise, just assume FileIDs were created in order. 1194 return LastResForBeforeTUCheck = (LOffs.first < ROffs.first); 1195} 1196 1197/// PrintStats - Print statistics to stderr. 1198/// 1199void SourceManager::PrintStats() const { 1200 llvm::errs() << "\n*** Source Manager Stats:\n"; 1201 llvm::errs() << FileInfos.size() << " files mapped, " << MemBufferInfos.size() 1202 << " mem buffers mapped.\n"; 1203 llvm::errs() << SLocEntryTable.size() << " SLocEntry's allocated, " 1204 << NextOffset << "B of Sloc address space used.\n"; 1205 1206 unsigned NumLineNumsComputed = 0; 1207 unsigned NumFileBytesMapped = 0; 1208 for (fileinfo_iterator I = fileinfo_begin(), E = fileinfo_end(); I != E; ++I){ 1209 NumLineNumsComputed += I->second->SourceLineCache != 0; 1210 NumFileBytesMapped += I->second->getSizeBytesMapped(); 1211 } 1212 1213 llvm::errs() << NumFileBytesMapped << " bytes of files mapped, " 1214 << NumLineNumsComputed << " files with line #'s computed.\n"; 1215 llvm::errs() << "FileID scans: " << NumLinearScans << " linear, " 1216 << NumBinaryProbes << " binary.\n"; 1217} 1218 1219ExternalSLocEntrySource::~ExternalSLocEntrySource() { } 1220