1 //===--- SourceManager.h - Track and cache source files ---------*- C++ -*-===// 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 /// \file 11 /// \brief Defines the SourceManager interface. 12 /// 13 /// There are three different types of locations in a %file: a spelling 14 /// location, an expansion location, and a presumed location. 15 /// 16 /// Given an example of: 17 /// \code 18 /// #define min(x, y) x < y ? x : y 19 /// \endcode 20 /// 21 /// and then later on a use of min: 22 /// \code 23 /// #line 17 24 /// return min(a, b); 25 /// \endcode 26 /// 27 /// The expansion location is the line in the source code where the macro 28 /// was expanded (the return statement), the spelling location is the 29 /// location in the source where the macro was originally defined, 30 /// and the presumed location is where the line directive states that 31 /// the line is 17, or any other line. 32 /// 33 //===----------------------------------------------------------------------===// 34 35 #ifndef LLVM_CLANG_SOURCEMANAGER_H 36 #define LLVM_CLANG_SOURCEMANAGER_H 37 38 #include "clang/Basic/FileManager.h" 39 #include "clang/Basic/LLVM.h" 40 #include "clang/Basic/SourceLocation.h" 41 #include "llvm/ADT/ArrayRef.h" 42 #include "llvm/ADT/DenseMap.h" 43 #include "llvm/ADT/DenseSet.h" 44 #include "llvm/ADT/IntrusiveRefCntPtr.h" 45 #include "llvm/ADT/OwningPtr.h" 46 #include "llvm/ADT/PointerIntPair.h" 47 #include "llvm/ADT/PointerUnion.h" 48 #include "llvm/Support/Allocator.h" 49 #include "llvm/Support/DataTypes.h" 50 #include "llvm/Support/MemoryBuffer.h" 51 #include <cassert> 52 #include <map> 53 #include <vector> 54 55 namespace clang { 56 57 class DiagnosticsEngine; 58 class SourceManager; 59 class FileManager; 60 class FileEntry; 61 class LineTableInfo; 62 class LangOptions; 63 class ASTWriter; 64 class ASTReader; 65 66 /// \brief Public enums and private classes that are part of the 67 /// SourceManager implementation. 68 /// 69 namespace SrcMgr { 70 /// \brief Indicates whether a file or directory holds normal user code, 71 /// system code, or system code which is implicitly 'extern "C"' in C++ mode. 72 /// 73 /// Entire directories can be tagged with this (this is maintained by 74 /// DirectoryLookup and friends) as can specific FileInfos when a \#pragma 75 /// system_header is seen or in various other cases. 76 /// 77 enum CharacteristicKind { 78 C_User, C_System, C_ExternCSystem 79 }; 80 81 /// \brief One instance of this struct is kept for every file loaded or used. 82 /// 83 /// This object owns the MemoryBuffer object. 84 class ContentCache { 85 enum CCFlags { 86 /// \brief Whether the buffer is invalid. 87 InvalidFlag = 0x01, 88 /// \brief Whether the buffer should not be freed on destruction. 89 DoNotFreeFlag = 0x02 90 }; 91 92 /// \brief The actual buffer containing the characters from the input 93 /// file. 94 /// 95 /// This is owned by the ContentCache object. The bits indicate 96 /// whether the buffer is invalid. 97 mutable llvm::PointerIntPair<const llvm::MemoryBuffer *, 2> Buffer; 98 99 public: 100 /// \brief Reference to the file entry representing this ContentCache. 101 /// 102 /// This reference does not own the FileEntry object. 103 /// 104 /// It is possible for this to be NULL if the ContentCache encapsulates 105 /// an imaginary text buffer. 106 const FileEntry *OrigEntry; 107 108 /// \brief References the file which the contents were actually loaded from. 109 /// 110 /// Can be different from 'Entry' if we overridden the contents of one file 111 /// with the contents of another file. 112 const FileEntry *ContentsEntry; 113 114 /// \brief A bump pointer allocated array of offsets for each source line. 115 /// 116 /// This is lazily computed. This is owned by the SourceManager 117 /// BumpPointerAllocator object. 118 unsigned *SourceLineCache; 119 120 /// \brief The number of lines in this ContentCache. 121 /// 122 /// This is only valid if SourceLineCache is non-null. 123 unsigned NumLines : 31; 124 125 /// \brief Indicates whether the buffer itself was provided to override 126 /// the actual file contents. 127 /// 128 /// When true, the original entry may be a virtual file that does not 129 /// exist. 130 unsigned BufferOverridden : 1; 131 132 /// \brief True if this content cache was initially created for a source 133 /// file considered as a system one. 134 unsigned IsSystemFile : 1; 135 136 ContentCache(const FileEntry *Ent = 0) 137 : Buffer(0, false), OrigEntry(Ent), ContentsEntry(Ent), 138 SourceLineCache(0), NumLines(0), BufferOverridden(false), 139 IsSystemFile(false) {} 140 ContentCache(const FileEntry * Ent,const FileEntry * contentEnt)141 ContentCache(const FileEntry *Ent, const FileEntry *contentEnt) 142 : Buffer(0, false), OrigEntry(Ent), ContentsEntry(contentEnt), 143 SourceLineCache(0), NumLines(0), BufferOverridden(false), 144 IsSystemFile(false) {} 145 146 ~ContentCache(); 147 148 /// The copy ctor does not allow copies where source object has either 149 /// a non-NULL Buffer or SourceLineCache. Ownership of allocated memory 150 /// is not transferred, so this is a logical error. ContentCache(const ContentCache & RHS)151 ContentCache(const ContentCache &RHS) 152 : Buffer(0, false), SourceLineCache(0), BufferOverridden(false), 153 IsSystemFile(false) 154 { 155 OrigEntry = RHS.OrigEntry; 156 ContentsEntry = RHS.ContentsEntry; 157 158 assert (RHS.Buffer.getPointer() == 0 && RHS.SourceLineCache == 0 && 159 "Passed ContentCache object cannot own a buffer."); 160 161 NumLines = RHS.NumLines; 162 } 163 164 /// \brief Returns the memory buffer for the associated content. 165 /// 166 /// \param Diag Object through which diagnostics will be emitted if the 167 /// buffer cannot be retrieved. 168 /// 169 /// \param Loc If specified, is the location that invalid file diagnostics 170 /// will be emitted at. 171 /// 172 /// \param Invalid If non-NULL, will be set \c true if an error occurred. 173 const llvm::MemoryBuffer *getBuffer(DiagnosticsEngine &Diag, 174 const SourceManager &SM, 175 SourceLocation Loc = SourceLocation(), 176 bool *Invalid = 0) const; 177 178 /// \brief Returns the size of the content encapsulated by this 179 /// ContentCache. 180 /// 181 /// This can be the size of the source file or the size of an 182 /// arbitrary scratch buffer. If the ContentCache encapsulates a source 183 /// file this size is retrieved from the file's FileEntry. 184 unsigned getSize() const; 185 186 /// \brief Returns the number of bytes actually mapped for this 187 /// ContentCache. 188 /// 189 /// This can be 0 if the MemBuffer was not actually expanded. 190 unsigned getSizeBytesMapped() const; 191 192 /// Returns the kind of memory used to back the memory buffer for 193 /// this content cache. This is used for performance analysis. 194 llvm::MemoryBuffer::BufferKind getMemoryBufferKind() const; 195 setBuffer(const llvm::MemoryBuffer * B)196 void setBuffer(const llvm::MemoryBuffer *B) { 197 assert(!Buffer.getPointer() && "MemoryBuffer already set."); 198 Buffer.setPointer(B); 199 Buffer.setInt(false); 200 } 201 202 /// \brief Get the underlying buffer, returning NULL if the buffer is not 203 /// yet available. getRawBuffer()204 const llvm::MemoryBuffer *getRawBuffer() const { 205 return Buffer.getPointer(); 206 } 207 208 /// \brief Replace the existing buffer (which will be deleted) 209 /// with the given buffer. 210 void replaceBuffer(const llvm::MemoryBuffer *B, bool DoNotFree = false); 211 212 /// \brief Determine whether the buffer itself is invalid. isBufferInvalid()213 bool isBufferInvalid() const { 214 return Buffer.getInt() & InvalidFlag; 215 } 216 217 /// \brief Determine whether the buffer should be freed. shouldFreeBuffer()218 bool shouldFreeBuffer() const { 219 return (Buffer.getInt() & DoNotFreeFlag) == 0; 220 } 221 222 private: 223 // Disable assignments. 224 ContentCache &operator=(const ContentCache& RHS) LLVM_DELETED_FUNCTION; 225 }; 226 227 /// \brief Information about a FileID, basically just the logical file 228 /// that it represents and include stack information. 229 /// 230 /// Each FileInfo has include stack information, indicating where it came 231 /// from. This information encodes the \#include chain that a token was 232 /// expanded from. The main include file has an invalid IncludeLoc. 233 /// 234 /// FileInfos contain a "ContentCache *", with the contents of the file. 235 /// 236 class FileInfo { 237 /// \brief The location of the \#include that brought in this file. 238 /// 239 /// This is an invalid SLOC for the main file (top of the \#include chain). 240 unsigned IncludeLoc; // Really a SourceLocation 241 242 /// \brief Number of FileIDs (files and macros) that were created during 243 /// preprocessing of this \#include, including this SLocEntry. 244 /// 245 /// Zero means the preprocessor didn't provide such info for this SLocEntry. 246 unsigned NumCreatedFIDs; 247 248 /// \brief Contains the ContentCache* and the bits indicating the 249 /// characteristic of the file and whether it has \#line info, all 250 /// bitmangled together. 251 uintptr_t Data; 252 253 friend class clang::SourceManager; 254 friend class clang::ASTWriter; 255 friend class clang::ASTReader; 256 public: 257 /// \brief Return a FileInfo object. get(SourceLocation IL,const ContentCache * Con,CharacteristicKind FileCharacter)258 static FileInfo get(SourceLocation IL, const ContentCache *Con, 259 CharacteristicKind FileCharacter) { 260 FileInfo X; 261 X.IncludeLoc = IL.getRawEncoding(); 262 X.NumCreatedFIDs = 0; 263 X.Data = (uintptr_t)Con; 264 assert((X.Data & 7) == 0 &&"ContentCache pointer insufficiently aligned"); 265 assert((unsigned)FileCharacter < 4 && "invalid file character"); 266 X.Data |= (unsigned)FileCharacter; 267 return X; 268 } 269 getIncludeLoc()270 SourceLocation getIncludeLoc() const { 271 return SourceLocation::getFromRawEncoding(IncludeLoc); 272 } getContentCache()273 const ContentCache* getContentCache() const { 274 return reinterpret_cast<const ContentCache*>(Data & ~uintptr_t(7)); 275 } 276 277 /// \brief Return whether this is a system header or not. getFileCharacteristic()278 CharacteristicKind getFileCharacteristic() const { 279 return (CharacteristicKind)(Data & 3); 280 } 281 282 /// \brief Return true if this FileID has \#line directives in it. hasLineDirectives()283 bool hasLineDirectives() const { return (Data & 4) != 0; } 284 285 /// \brief Set the flag that indicates that this FileID has 286 /// line table entries associated with it. setHasLineDirectives()287 void setHasLineDirectives() { 288 Data |= 4; 289 } 290 }; 291 292 /// \brief Each ExpansionInfo encodes the expansion location - where 293 /// the token was ultimately expanded, and the SpellingLoc - where the actual 294 /// character data for the token came from. 295 class ExpansionInfo { 296 // Really these are all SourceLocations. 297 298 /// \brief Where the spelling for the token can be found. 299 unsigned SpellingLoc; 300 301 /// In a macro expansion, ExpansionLocStart and ExpansionLocEnd 302 /// indicate the start and end of the expansion. In object-like macros, 303 /// they will be the same. In a function-like macro expansion, the start 304 /// will be the identifier and the end will be the ')'. Finally, in 305 /// macro-argument instantiations, the end will be 'SourceLocation()', an 306 /// invalid location. 307 unsigned ExpansionLocStart, ExpansionLocEnd; 308 309 public: getSpellingLoc()310 SourceLocation getSpellingLoc() const { 311 return SourceLocation::getFromRawEncoding(SpellingLoc); 312 } getExpansionLocStart()313 SourceLocation getExpansionLocStart() const { 314 return SourceLocation::getFromRawEncoding(ExpansionLocStart); 315 } getExpansionLocEnd()316 SourceLocation getExpansionLocEnd() const { 317 SourceLocation EndLoc = 318 SourceLocation::getFromRawEncoding(ExpansionLocEnd); 319 return EndLoc.isInvalid() ? getExpansionLocStart() : EndLoc; 320 } 321 getExpansionLocRange()322 std::pair<SourceLocation,SourceLocation> getExpansionLocRange() const { 323 return std::make_pair(getExpansionLocStart(), getExpansionLocEnd()); 324 } 325 isMacroArgExpansion()326 bool isMacroArgExpansion() const { 327 // Note that this needs to return false for default constructed objects. 328 return getExpansionLocStart().isValid() && 329 SourceLocation::getFromRawEncoding(ExpansionLocEnd).isInvalid(); 330 } 331 isMacroBodyExpansion()332 bool isMacroBodyExpansion() const { 333 return getExpansionLocStart().isValid() && 334 SourceLocation::getFromRawEncoding(ExpansionLocEnd).isValid(); 335 } 336 isFunctionMacroExpansion()337 bool isFunctionMacroExpansion() const { 338 return getExpansionLocStart().isValid() && 339 getExpansionLocStart() != getExpansionLocEnd(); 340 } 341 342 /// \brief Return a ExpansionInfo for an expansion. 343 /// 344 /// Start and End specify the expansion range (where the macro is 345 /// expanded), and SpellingLoc specifies the spelling location (where 346 /// the characters from the token come from). All three can refer to 347 /// normal File SLocs or expansion locations. create(SourceLocation SpellingLoc,SourceLocation Start,SourceLocation End)348 static ExpansionInfo create(SourceLocation SpellingLoc, 349 SourceLocation Start, SourceLocation End) { 350 ExpansionInfo X; 351 X.SpellingLoc = SpellingLoc.getRawEncoding(); 352 X.ExpansionLocStart = Start.getRawEncoding(); 353 X.ExpansionLocEnd = End.getRawEncoding(); 354 return X; 355 } 356 357 /// \brief Return a special ExpansionInfo for the expansion of 358 /// a macro argument into a function-like macro's body. 359 /// 360 /// ExpansionLoc specifies the expansion location (where the macro is 361 /// expanded). This doesn't need to be a range because a macro is always 362 /// expanded at a macro parameter reference, and macro parameters are 363 /// always exactly one token. SpellingLoc specifies the spelling location 364 /// (where the characters from the token come from). ExpansionLoc and 365 /// SpellingLoc can both refer to normal File SLocs or expansion locations. 366 /// 367 /// Given the code: 368 /// \code 369 /// #define F(x) f(x) 370 /// F(42); 371 /// \endcode 372 /// 373 /// When expanding '\c F(42)', the '\c x' would call this with an 374 /// SpellingLoc pointing at '\c 42' and an ExpansionLoc pointing at its 375 /// location in the definition of '\c F'. createForMacroArg(SourceLocation SpellingLoc,SourceLocation ExpansionLoc)376 static ExpansionInfo createForMacroArg(SourceLocation SpellingLoc, 377 SourceLocation ExpansionLoc) { 378 // We store an intentionally invalid source location for the end of the 379 // expansion range to mark that this is a macro argument ion rather than 380 // a normal one. 381 return create(SpellingLoc, ExpansionLoc, SourceLocation()); 382 } 383 }; 384 385 /// \brief This is a discriminated union of FileInfo and ExpansionInfo. 386 /// 387 /// SourceManager keeps an array of these objects, and they are uniquely 388 /// identified by the FileID datatype. 389 class SLocEntry { 390 unsigned Offset; // low bit is set for expansion info. 391 union { 392 FileInfo File; 393 ExpansionInfo Expansion; 394 }; 395 public: getOffset()396 unsigned getOffset() const { return Offset >> 1; } 397 isExpansion()398 bool isExpansion() const { return Offset & 1; } isFile()399 bool isFile() const { return !isExpansion(); } 400 getFile()401 const FileInfo &getFile() const { 402 assert(isFile() && "Not a file SLocEntry!"); 403 return File; 404 } 405 getExpansion()406 const ExpansionInfo &getExpansion() const { 407 assert(isExpansion() && "Not a macro expansion SLocEntry!"); 408 return Expansion; 409 } 410 get(unsigned Offset,const FileInfo & FI)411 static SLocEntry get(unsigned Offset, const FileInfo &FI) { 412 SLocEntry E; 413 E.Offset = Offset << 1; 414 E.File = FI; 415 return E; 416 } 417 get(unsigned Offset,const ExpansionInfo & Expansion)418 static SLocEntry get(unsigned Offset, const ExpansionInfo &Expansion) { 419 SLocEntry E; 420 E.Offset = (Offset << 1) | 1; 421 E.Expansion = Expansion; 422 return E; 423 } 424 }; 425 } // end SrcMgr namespace. 426 427 /// \brief External source of source location entries. 428 class ExternalSLocEntrySource { 429 public: 430 virtual ~ExternalSLocEntrySource(); 431 432 /// \brief Read the source location entry with index ID, which will always be 433 /// less than -1. 434 /// 435 /// \returns true if an error occurred that prevented the source-location 436 /// entry from being loaded. 437 virtual bool ReadSLocEntry(int ID) = 0; 438 439 /// \brief Retrieve the module import location and name for the given ID, if 440 /// in fact it was loaded from a module (rather than, say, a precompiled 441 /// header). 442 virtual std::pair<SourceLocation, StringRef> getModuleImportLoc(int ID) = 0; 443 }; 444 445 446 /// \brief Holds the cache used by isBeforeInTranslationUnit. 447 /// 448 /// The cache structure is complex enough to be worth breaking out of 449 /// SourceManager. 450 class InBeforeInTUCacheEntry { 451 /// \brief The FileID's of the cached query. 452 /// 453 /// If these match up with a subsequent query, the result can be reused. 454 FileID LQueryFID, RQueryFID; 455 456 /// \brief True if LQueryFID was created before RQueryFID. 457 /// 458 /// This is used to compare macro expansion locations. 459 bool IsLQFIDBeforeRQFID; 460 461 /// \brief The file found in common between the two \#include traces, i.e., 462 /// the nearest common ancestor of the \#include tree. 463 FileID CommonFID; 464 465 /// \brief The offset of the previous query in CommonFID. 466 /// 467 /// Usually, this represents the location of the \#include for QueryFID, but 468 /// if LQueryFID is a parent of RQueryFID (or vice versa) then these can be a 469 /// random token in the parent. 470 unsigned LCommonOffset, RCommonOffset; 471 public: 472 /// \brief Return true if the currently cached values match up with 473 /// the specified LHS/RHS query. 474 /// 475 /// If not, we can't use the cache. isCacheValid(FileID LHS,FileID RHS)476 bool isCacheValid(FileID LHS, FileID RHS) const { 477 return LQueryFID == LHS && RQueryFID == RHS; 478 } 479 480 /// \brief If the cache is valid, compute the result given the 481 /// specified offsets in the LHS/RHS FileID's. getCachedResult(unsigned LOffset,unsigned ROffset)482 bool getCachedResult(unsigned LOffset, unsigned ROffset) const { 483 // If one of the query files is the common file, use the offset. Otherwise, 484 // use the #include loc in the common file. 485 if (LQueryFID != CommonFID) LOffset = LCommonOffset; 486 if (RQueryFID != CommonFID) ROffset = RCommonOffset; 487 488 // It is common for multiple macro expansions to be "included" from the same 489 // location (expansion location), in which case use the order of the FileIDs 490 // to determine which came first. This will also take care the case where 491 // one of the locations points at the inclusion/expansion point of the other 492 // in which case its FileID will come before the other. 493 if (LOffset == ROffset) 494 return IsLQFIDBeforeRQFID; 495 496 return LOffset < ROffset; 497 } 498 499 /// \brief Set up a new query. setQueryFIDs(FileID LHS,FileID RHS,bool isLFIDBeforeRFID)500 void setQueryFIDs(FileID LHS, FileID RHS, bool isLFIDBeforeRFID) { 501 assert(LHS != RHS); 502 LQueryFID = LHS; 503 RQueryFID = RHS; 504 IsLQFIDBeforeRQFID = isLFIDBeforeRFID; 505 } 506 clear()507 void clear() { 508 LQueryFID = RQueryFID = FileID(); 509 IsLQFIDBeforeRQFID = false; 510 } 511 setCommonLoc(FileID commonFID,unsigned lCommonOffset,unsigned rCommonOffset)512 void setCommonLoc(FileID commonFID, unsigned lCommonOffset, 513 unsigned rCommonOffset) { 514 CommonFID = commonFID; 515 LCommonOffset = lCommonOffset; 516 RCommonOffset = rCommonOffset; 517 } 518 519 }; 520 521 /// \brief The stack used when building modules on demand, which is used 522 /// to provide a link between the source managers of the different compiler 523 /// instances. 524 typedef ArrayRef<std::pair<std::string, FullSourceLoc> > ModuleBuildStack; 525 526 /// \brief This class handles loading and caching of source files into memory. 527 /// 528 /// This object owns the MemoryBuffer objects for all of the loaded 529 /// files and assigns unique FileID's for each unique \#include chain. 530 /// 531 /// The SourceManager can be queried for information about SourceLocation 532 /// objects, turning them into either spelling or expansion locations. Spelling 533 /// locations represent where the bytes corresponding to a token came from and 534 /// expansion locations represent where the location is in the user's view. In 535 /// the case of a macro expansion, for example, the spelling location indicates 536 /// where the expanded token came from and the expansion location specifies 537 /// where it was expanded. 538 class SourceManager : public RefCountedBase<SourceManager> { 539 /// \brief DiagnosticsEngine object. 540 DiagnosticsEngine &Diag; 541 542 FileManager &FileMgr; 543 544 mutable llvm::BumpPtrAllocator ContentCacheAlloc; 545 546 /// \brief Memoized information about all of the files tracked by this 547 /// SourceManager. 548 /// 549 /// This map allows us to merge ContentCache entries based 550 /// on their FileEntry*. All ContentCache objects will thus have unique, 551 /// non-null, FileEntry pointers. 552 llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*> FileInfos; 553 554 /// \brief True if the ContentCache for files that are overriden by other 555 /// files, should report the original file name. Defaults to true. 556 bool OverridenFilesKeepOriginalName; 557 558 /// \brief True if non-system source files should be treated as volatile 559 /// (likely to change while trying to use them). Defaults to false. 560 bool UserFilesAreVolatile; 561 562 struct OverriddenFilesInfoTy { 563 /// \brief Files that have been overriden with the contents from another 564 /// file. 565 llvm::DenseMap<const FileEntry *, const FileEntry *> OverriddenFiles; 566 /// \brief Files that were overridden with a memory buffer. 567 llvm::DenseSet<const FileEntry *> OverriddenFilesWithBuffer; 568 }; 569 570 /// \brief Lazily create the object keeping overridden files info, since 571 /// it is uncommonly used. 572 OwningPtr<OverriddenFilesInfoTy> OverriddenFilesInfo; 573 getOverriddenFilesInfo()574 OverriddenFilesInfoTy &getOverriddenFilesInfo() { 575 if (!OverriddenFilesInfo) 576 OverriddenFilesInfo.reset(new OverriddenFilesInfoTy); 577 return *OverriddenFilesInfo; 578 } 579 580 /// \brief Information about various memory buffers that we have read in. 581 /// 582 /// All FileEntry* within the stored ContentCache objects are NULL, 583 /// as they do not refer to a file. 584 std::vector<SrcMgr::ContentCache*> MemBufferInfos; 585 586 /// \brief The table of SLocEntries that are local to this module. 587 /// 588 /// Positive FileIDs are indexes into this table. Entry 0 indicates an invalid 589 /// expansion. 590 SmallVector<SrcMgr::SLocEntry, 0> LocalSLocEntryTable; 591 592 /// \brief The table of SLocEntries that are loaded from other modules. 593 /// 594 /// Negative FileIDs are indexes into this table. To get from ID to an index, 595 /// use (-ID - 2). 596 mutable SmallVector<SrcMgr::SLocEntry, 0> LoadedSLocEntryTable; 597 598 /// \brief The starting offset of the next local SLocEntry. 599 /// 600 /// This is LocalSLocEntryTable.back().Offset + the size of that entry. 601 unsigned NextLocalOffset; 602 603 /// \brief The starting offset of the latest batch of loaded SLocEntries. 604 /// 605 /// This is LoadedSLocEntryTable.back().Offset, except that that entry might 606 /// not have been loaded, so that value would be unknown. 607 unsigned CurrentLoadedOffset; 608 609 /// \brief The highest possible offset is 2^31-1, so CurrentLoadedOffset 610 /// starts at 2^31. 611 static const unsigned MaxLoadedOffset = 1U << 31U; 612 613 /// \brief A bitmap that indicates whether the entries of LoadedSLocEntryTable 614 /// have already been loaded from the external source. 615 /// 616 /// Same indexing as LoadedSLocEntryTable. 617 std::vector<bool> SLocEntryLoaded; 618 619 /// \brief An external source for source location entries. 620 ExternalSLocEntrySource *ExternalSLocEntries; 621 622 /// \brief A one-entry cache to speed up getFileID. 623 /// 624 /// LastFileIDLookup records the last FileID looked up or created, because it 625 /// is very common to look up many tokens from the same file. 626 mutable FileID LastFileIDLookup; 627 628 /// \brief Holds information for \#line directives. 629 /// 630 /// This is referenced by indices from SLocEntryTable. 631 LineTableInfo *LineTable; 632 633 /// \brief These ivars serve as a cache used in the getLineNumber 634 /// method which is used to speedup getLineNumber calls to nearby locations. 635 mutable FileID LastLineNoFileIDQuery; 636 mutable SrcMgr::ContentCache *LastLineNoContentCache; 637 mutable unsigned LastLineNoFilePos; 638 mutable unsigned LastLineNoResult; 639 640 /// \brief The file ID for the main source file of the translation unit. 641 FileID MainFileID; 642 643 /// \brief The file ID for the precompiled preamble there is one. 644 FileID PreambleFileID; 645 646 // Statistics for -print-stats. 647 mutable unsigned NumLinearScans, NumBinaryProbes; 648 649 /// The key value into the IsBeforeInTUCache table. 650 typedef std::pair<FileID, FileID> IsBeforeInTUCacheKey; 651 652 /// The IsBeforeInTranslationUnitCache is a mapping from FileID pairs 653 /// to cache results. 654 typedef llvm::DenseMap<IsBeforeInTUCacheKey, InBeforeInTUCacheEntry> 655 InBeforeInTUCache; 656 657 /// Cache results for the isBeforeInTranslationUnit method. 658 mutable InBeforeInTUCache IBTUCache; 659 mutable InBeforeInTUCacheEntry IBTUCacheOverflow; 660 661 /// Return the cache entry for comparing the given file IDs 662 /// for isBeforeInTranslationUnit. 663 InBeforeInTUCacheEntry &getInBeforeInTUCache(FileID LFID, FileID RFID) const; 664 665 // Cache for the "fake" buffer used for error-recovery purposes. 666 mutable llvm::MemoryBuffer *FakeBufferForRecovery; 667 668 mutable SrcMgr::ContentCache *FakeContentCacheForRecovery; 669 670 /// \brief Lazily computed map of macro argument chunks to their expanded 671 /// source location. 672 typedef std::map<unsigned, SourceLocation> MacroArgsMap; 673 674 mutable llvm::DenseMap<FileID, MacroArgsMap *> MacroArgsCacheMap; 675 676 /// \brief The stack of modules being built, which is used to detect 677 /// cycles in the module dependency graph as modules are being built, as 678 /// well as to describe why we're rebuilding a particular module. 679 /// 680 /// There is no way to set this value from the command line. If we ever need 681 /// to do so (e.g., if on-demand module construction moves out-of-process), 682 /// we can add a cc1-level option to do so. 683 SmallVector<std::pair<std::string, FullSourceLoc>, 2> StoredModuleBuildStack; 684 685 // SourceManager doesn't support copy construction. 686 explicit SourceManager(const SourceManager&) LLVM_DELETED_FUNCTION; 687 void operator=(const SourceManager&) LLVM_DELETED_FUNCTION; 688 public: 689 SourceManager(DiagnosticsEngine &Diag, FileManager &FileMgr, 690 bool UserFilesAreVolatile = false); 691 ~SourceManager(); 692 693 void clearIDTables(); 694 getDiagnostics()695 DiagnosticsEngine &getDiagnostics() const { return Diag; } 696 getFileManager()697 FileManager &getFileManager() const { return FileMgr; } 698 699 /// \brief Set true if the SourceManager should report the original file name 700 /// for contents of files that were overriden by other files.Defaults to true. setOverridenFilesKeepOriginalName(bool value)701 void setOverridenFilesKeepOriginalName(bool value) { 702 OverridenFilesKeepOriginalName = value; 703 } 704 705 /// \brief True if non-system source files should be treated as volatile 706 /// (likely to change while trying to use them). userFilesAreVolatile()707 bool userFilesAreVolatile() const { return UserFilesAreVolatile; } 708 709 /// \brief Retrieve the module build stack. getModuleBuildStack()710 ModuleBuildStack getModuleBuildStack() const { 711 return StoredModuleBuildStack; 712 } 713 714 /// \brief Set the module build stack. setModuleBuildStack(ModuleBuildStack stack)715 void setModuleBuildStack(ModuleBuildStack stack) { 716 StoredModuleBuildStack.clear(); 717 StoredModuleBuildStack.append(stack.begin(), stack.end()); 718 } 719 720 /// \brief Push an entry to the module build stack. pushModuleBuildStack(StringRef moduleName,FullSourceLoc importLoc)721 void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc) { 722 StoredModuleBuildStack.push_back(std::make_pair(moduleName.str(),importLoc)); 723 } 724 725 /// \brief Create the FileID for a memory buffer that will represent the 726 /// FileID for the main source. 727 /// 728 /// One example of when this would be used is when the main source is read 729 /// from STDIN. 730 FileID createMainFileIDForMemBuffer(const llvm::MemoryBuffer *Buffer, 731 SrcMgr::CharacteristicKind Kind = SrcMgr::C_User) { 732 assert(MainFileID.isInvalid() && "MainFileID already set!"); 733 MainFileID = createFileIDForMemBuffer(Buffer, Kind); 734 return MainFileID; 735 } 736 737 //===--------------------------------------------------------------------===// 738 // MainFileID creation and querying methods. 739 //===--------------------------------------------------------------------===// 740 741 /// \brief Returns the FileID of the main source file. getMainFileID()742 FileID getMainFileID() const { return MainFileID; } 743 744 /// \brief Create the FileID for the main source file. 745 FileID createMainFileID(const FileEntry *SourceFile, 746 SrcMgr::CharacteristicKind Kind = SrcMgr::C_User) { 747 assert(MainFileID.isInvalid() && "MainFileID already set!"); 748 MainFileID = createFileID(SourceFile, SourceLocation(), Kind); 749 return MainFileID; 750 } 751 752 /// \brief Set the file ID for the main source file. setMainFileID(FileID FID)753 void setMainFileID(FileID FID) { 754 assert(MainFileID.isInvalid() && "MainFileID already set!"); 755 MainFileID = FID; 756 } 757 758 /// \brief Set the file ID for the precompiled preamble. setPreambleFileID(FileID Preamble)759 void setPreambleFileID(FileID Preamble) { 760 assert(PreambleFileID.isInvalid() && "PreambleFileID already set!"); 761 PreambleFileID = Preamble; 762 } 763 764 /// \brief Get the file ID for the precompiled preamble if there is one. getPreambleFileID()765 FileID getPreambleFileID() const { return PreambleFileID; } 766 767 //===--------------------------------------------------------------------===// 768 // Methods to create new FileID's and macro expansions. 769 //===--------------------------------------------------------------------===// 770 771 /// \brief Create a new FileID that represents the specified file 772 /// being \#included from the specified IncludePosition. 773 /// 774 /// This translates NULL into standard input. 775 FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos, 776 SrcMgr::CharacteristicKind FileCharacter, 777 int LoadedID = 0, unsigned LoadedOffset = 0) { 778 const SrcMgr::ContentCache * 779 IR = getOrCreateContentCache(SourceFile, 780 /*isSystemFile=*/FileCharacter != SrcMgr::C_User); 781 assert(IR && "getOrCreateContentCache() cannot return NULL"); 782 return createFileID(IR, IncludePos, FileCharacter, LoadedID, LoadedOffset); 783 } 784 785 /// \brief Create a new FileID that represents the specified memory buffer. 786 /// 787 /// This does no caching of the buffer and takes ownership of the 788 /// MemoryBuffer, so only pass a MemoryBuffer to this once. 789 FileID createFileIDForMemBuffer(const llvm::MemoryBuffer *Buffer, 790 SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User, 791 int LoadedID = 0, unsigned LoadedOffset = 0, 792 SourceLocation IncludeLoc = SourceLocation()) { 793 return createFileID(createMemBufferContentCache(Buffer), IncludeLoc, 794 FileCharacter, LoadedID, LoadedOffset); 795 } 796 797 /// \brief Return a new SourceLocation that encodes the 798 /// fact that a token from SpellingLoc should actually be referenced from 799 /// ExpansionLoc, and that it represents the expansion of a macro argument 800 /// into the function-like macro body. 801 SourceLocation createMacroArgExpansionLoc(SourceLocation Loc, 802 SourceLocation ExpansionLoc, 803 unsigned TokLength); 804 805 /// \brief Return a new SourceLocation that encodes the fact 806 /// that a token from SpellingLoc should actually be referenced from 807 /// ExpansionLoc. 808 SourceLocation createExpansionLoc(SourceLocation Loc, 809 SourceLocation ExpansionLocStart, 810 SourceLocation ExpansionLocEnd, 811 unsigned TokLength, 812 int LoadedID = 0, 813 unsigned LoadedOffset = 0); 814 815 /// \brief Retrieve the memory buffer associated with the given file. 816 /// 817 /// \param Invalid If non-NULL, will be set \c true if an error 818 /// occurs while retrieving the memory buffer. 819 const llvm::MemoryBuffer *getMemoryBufferForFile(const FileEntry *File, 820 bool *Invalid = 0); 821 822 /// \brief Override the contents of the given source file by providing an 823 /// already-allocated buffer. 824 /// 825 /// \param SourceFile the source file whose contents will be overriden. 826 /// 827 /// \param Buffer the memory buffer whose contents will be used as the 828 /// data in the given source file. 829 /// 830 /// \param DoNotFree If true, then the buffer will not be freed when the 831 /// source manager is destroyed. 832 void overrideFileContents(const FileEntry *SourceFile, 833 const llvm::MemoryBuffer *Buffer, 834 bool DoNotFree = false); 835 836 /// \brief Override the given source file with another one. 837 /// 838 /// \param SourceFile the source file which will be overriden. 839 /// 840 /// \param NewFile the file whose contents will be used as the 841 /// data instead of the contents of the given source file. 842 void overrideFileContents(const FileEntry *SourceFile, 843 const FileEntry *NewFile); 844 845 /// \brief Returns true if the file contents have been overridden. isFileOverridden(const FileEntry * File)846 bool isFileOverridden(const FileEntry *File) { 847 if (OverriddenFilesInfo) { 848 if (OverriddenFilesInfo->OverriddenFilesWithBuffer.count(File)) 849 return true; 850 if (OverriddenFilesInfo->OverriddenFiles.find(File) != 851 OverriddenFilesInfo->OverriddenFiles.end()) 852 return true; 853 } 854 return false; 855 } 856 857 /// \brief Disable overridding the contents of a file, previously enabled 858 /// with #overrideFileContents. 859 /// 860 /// This should be called before parsing has begun. 861 void disableFileContentsOverride(const FileEntry *File); 862 863 //===--------------------------------------------------------------------===// 864 // FileID manipulation methods. 865 //===--------------------------------------------------------------------===// 866 867 /// \brief Return the buffer for the specified FileID. 868 /// 869 /// If there is an error opening this buffer the first time, this 870 /// manufactures a temporary buffer and returns a non-empty error string. 871 const llvm::MemoryBuffer *getBuffer(FileID FID, SourceLocation Loc, 872 bool *Invalid = 0) const { 873 bool MyInvalid = false; 874 const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &MyInvalid); 875 if (MyInvalid || !Entry.isFile()) { 876 if (Invalid) 877 *Invalid = true; 878 879 return getFakeBufferForRecovery(); 880 } 881 882 return Entry.getFile().getContentCache()->getBuffer(Diag, *this, Loc, 883 Invalid); 884 } 885 886 const llvm::MemoryBuffer *getBuffer(FileID FID, bool *Invalid = 0) const { 887 bool MyInvalid = false; 888 const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &MyInvalid); 889 if (MyInvalid || !Entry.isFile()) { 890 if (Invalid) 891 *Invalid = true; 892 893 return getFakeBufferForRecovery(); 894 } 895 896 return Entry.getFile().getContentCache()->getBuffer(Diag, *this, 897 SourceLocation(), 898 Invalid); 899 } 900 901 /// \brief Returns the FileEntry record for the provided FileID. getFileEntryForID(FileID FID)902 const FileEntry *getFileEntryForID(FileID FID) const { 903 bool MyInvalid = false; 904 const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &MyInvalid); 905 if (MyInvalid || !Entry.isFile()) 906 return 0; 907 908 const SrcMgr::ContentCache *Content = Entry.getFile().getContentCache(); 909 if (!Content) 910 return 0; 911 return Content->OrigEntry; 912 } 913 914 /// \brief Returns the FileEntry record for the provided SLocEntry. getFileEntryForSLocEntry(const SrcMgr::SLocEntry & sloc)915 const FileEntry *getFileEntryForSLocEntry(const SrcMgr::SLocEntry &sloc) const 916 { 917 const SrcMgr::ContentCache *Content = sloc.getFile().getContentCache(); 918 if (!Content) 919 return 0; 920 return Content->OrigEntry; 921 } 922 923 /// \brief Return a StringRef to the source buffer data for the 924 /// specified FileID. 925 /// 926 /// \param FID The file ID whose contents will be returned. 927 /// \param Invalid If non-NULL, will be set true if an error occurred. 928 StringRef getBufferData(FileID FID, bool *Invalid = 0) const; 929 930 /// \brief Get the number of FileIDs (files and macros) that were created 931 /// during preprocessing of \p FID, including it. getNumCreatedFIDsForFileID(FileID FID)932 unsigned getNumCreatedFIDsForFileID(FileID FID) const { 933 bool Invalid = false; 934 const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid); 935 if (Invalid || !Entry.isFile()) 936 return 0; 937 938 return Entry.getFile().NumCreatedFIDs; 939 } 940 941 /// \brief Set the number of FileIDs (files and macros) that were created 942 /// during preprocessing of \p FID, including it. setNumCreatedFIDsForFileID(FileID FID,unsigned NumFIDs)943 void setNumCreatedFIDsForFileID(FileID FID, unsigned NumFIDs) const { 944 bool Invalid = false; 945 const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid); 946 if (Invalid || !Entry.isFile()) 947 return; 948 949 assert(Entry.getFile().NumCreatedFIDs == 0 && "Already set!"); 950 const_cast<SrcMgr::FileInfo &>(Entry.getFile()).NumCreatedFIDs = NumFIDs; 951 } 952 953 //===--------------------------------------------------------------------===// 954 // SourceLocation manipulation methods. 955 //===--------------------------------------------------------------------===// 956 957 /// \brief Return the FileID for a SourceLocation. 958 /// 959 /// This is a very hot method that is used for all SourceManager queries 960 /// that start with a SourceLocation object. It is responsible for finding 961 /// the entry in SLocEntryTable which contains the specified location. 962 /// getFileID(SourceLocation SpellingLoc)963 FileID getFileID(SourceLocation SpellingLoc) const { 964 unsigned SLocOffset = SpellingLoc.getOffset(); 965 966 // If our one-entry cache covers this offset, just return it. 967 if (isOffsetInFileID(LastFileIDLookup, SLocOffset)) 968 return LastFileIDLookup; 969 970 return getFileIDSlow(SLocOffset); 971 } 972 973 /// \brief Return the filename of the file containing a SourceLocation. getFilename(SourceLocation SpellingLoc)974 StringRef getFilename(SourceLocation SpellingLoc) const { 975 if (const FileEntry *F = getFileEntryForID(getFileID(SpellingLoc))) 976 return F->getName(); 977 return StringRef(); 978 } 979 980 /// \brief Return the source location corresponding to the first byte of 981 /// the specified file. getLocForStartOfFile(FileID FID)982 SourceLocation getLocForStartOfFile(FileID FID) const { 983 bool Invalid = false; 984 const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid); 985 if (Invalid || !Entry.isFile()) 986 return SourceLocation(); 987 988 unsigned FileOffset = Entry.getOffset(); 989 return SourceLocation::getFileLoc(FileOffset); 990 } 991 992 /// \brief Return the source location corresponding to the last byte of the 993 /// specified file. getLocForEndOfFile(FileID FID)994 SourceLocation getLocForEndOfFile(FileID FID) const { 995 bool Invalid = false; 996 const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid); 997 if (Invalid || !Entry.isFile()) 998 return SourceLocation(); 999 1000 unsigned FileOffset = Entry.getOffset(); 1001 return SourceLocation::getFileLoc(FileOffset + getFileIDSize(FID) - 1); 1002 } 1003 1004 /// \brief Returns the include location if \p FID is a \#include'd file 1005 /// otherwise it returns an invalid location. getIncludeLoc(FileID FID)1006 SourceLocation getIncludeLoc(FileID FID) const { 1007 bool Invalid = false; 1008 const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid); 1009 if (Invalid || !Entry.isFile()) 1010 return SourceLocation(); 1011 1012 return Entry.getFile().getIncludeLoc(); 1013 } 1014 1015 // \brief Returns the import location if the given source location is 1016 // located within a module, or an invalid location if the source location 1017 // is within the current translation unit. 1018 std::pair<SourceLocation, StringRef> getModuleImportLoc(SourceLocation Loc)1019 getModuleImportLoc(SourceLocation Loc) const { 1020 FileID FID = getFileID(Loc); 1021 1022 // Positive file IDs are in the current translation unit, and -1 is a 1023 // placeholder. 1024 if (FID.ID >= -1) 1025 return std::make_pair(SourceLocation(), ""); 1026 1027 return ExternalSLocEntries->getModuleImportLoc(FID.ID); 1028 } 1029 1030 /// \brief Given a SourceLocation object \p Loc, return the expansion 1031 /// location referenced by the ID. getExpansionLoc(SourceLocation Loc)1032 SourceLocation getExpansionLoc(SourceLocation Loc) const { 1033 // Handle the non-mapped case inline, defer to out of line code to handle 1034 // expansions. 1035 if (Loc.isFileID()) return Loc; 1036 return getExpansionLocSlowCase(Loc); 1037 } 1038 1039 /// \brief Given \p Loc, if it is a macro location return the expansion 1040 /// location or the spelling location, depending on if it comes from a 1041 /// macro argument or not. getFileLoc(SourceLocation Loc)1042 SourceLocation getFileLoc(SourceLocation Loc) const { 1043 if (Loc.isFileID()) return Loc; 1044 return getFileLocSlowCase(Loc); 1045 } 1046 1047 /// \brief Return the start/end of the expansion information for an 1048 /// expansion location. 1049 /// 1050 /// \pre \p Loc is required to be an expansion location. 1051 std::pair<SourceLocation,SourceLocation> 1052 getImmediateExpansionRange(SourceLocation Loc) const; 1053 1054 /// \brief Given a SourceLocation object, return the range of 1055 /// tokens covered by the expansion the ultimate file. 1056 std::pair<SourceLocation,SourceLocation> 1057 getExpansionRange(SourceLocation Loc) const; 1058 1059 1060 /// \brief Given a SourceLocation object, return the spelling 1061 /// location referenced by the ID. 1062 /// 1063 /// This is the place where the characters that make up the lexed token 1064 /// can be found. getSpellingLoc(SourceLocation Loc)1065 SourceLocation getSpellingLoc(SourceLocation Loc) const { 1066 // Handle the non-mapped case inline, defer to out of line code to handle 1067 // expansions. 1068 if (Loc.isFileID()) return Loc; 1069 return getSpellingLocSlowCase(Loc); 1070 } 1071 1072 /// \brief Given a SourceLocation object, return the spelling location 1073 /// referenced by the ID. 1074 /// 1075 /// This is the first level down towards the place where the characters 1076 /// that make up the lexed token can be found. This should not generally 1077 /// be used by clients. 1078 SourceLocation getImmediateSpellingLoc(SourceLocation Loc) const; 1079 1080 /// \brief Decompose the specified location into a raw FileID + Offset pair. 1081 /// 1082 /// The first element is the FileID, the second is the offset from the 1083 /// start of the buffer of the location. getDecomposedLoc(SourceLocation Loc)1084 std::pair<FileID, unsigned> getDecomposedLoc(SourceLocation Loc) const { 1085 FileID FID = getFileID(Loc); 1086 bool Invalid = false; 1087 const SrcMgr::SLocEntry &E = getSLocEntry(FID, &Invalid); 1088 if (Invalid) 1089 return std::make_pair(FileID(), 0); 1090 return std::make_pair(FID, Loc.getOffset()-E.getOffset()); 1091 } 1092 1093 /// \brief Decompose the specified location into a raw FileID + Offset pair. 1094 /// 1095 /// If the location is an expansion record, walk through it until we find 1096 /// the final location expanded. 1097 std::pair<FileID, unsigned> getDecomposedExpansionLoc(SourceLocation Loc)1098 getDecomposedExpansionLoc(SourceLocation Loc) const { 1099 FileID FID = getFileID(Loc); 1100 bool Invalid = false; 1101 const SrcMgr::SLocEntry *E = &getSLocEntry(FID, &Invalid); 1102 if (Invalid) 1103 return std::make_pair(FileID(), 0); 1104 1105 unsigned Offset = Loc.getOffset()-E->getOffset(); 1106 if (Loc.isFileID()) 1107 return std::make_pair(FID, Offset); 1108 1109 return getDecomposedExpansionLocSlowCase(E); 1110 } 1111 1112 /// \brief Decompose the specified location into a raw FileID + Offset pair. 1113 /// 1114 /// If the location is an expansion record, walk through it until we find 1115 /// its spelling record. 1116 std::pair<FileID, unsigned> getDecomposedSpellingLoc(SourceLocation Loc)1117 getDecomposedSpellingLoc(SourceLocation Loc) const { 1118 FileID FID = getFileID(Loc); 1119 bool Invalid = false; 1120 const SrcMgr::SLocEntry *E = &getSLocEntry(FID, &Invalid); 1121 if (Invalid) 1122 return std::make_pair(FileID(), 0); 1123 1124 unsigned Offset = Loc.getOffset()-E->getOffset(); 1125 if (Loc.isFileID()) 1126 return std::make_pair(FID, Offset); 1127 return getDecomposedSpellingLocSlowCase(E, Offset); 1128 } 1129 1130 /// \brief Returns the offset from the start of the file that the 1131 /// specified SourceLocation represents. 1132 /// 1133 /// This is not very meaningful for a macro ID. getFileOffset(SourceLocation SpellingLoc)1134 unsigned getFileOffset(SourceLocation SpellingLoc) const { 1135 return getDecomposedLoc(SpellingLoc).second; 1136 } 1137 1138 /// \brief Tests whether the given source location represents a macro 1139 /// argument's expansion into the function-like macro definition. 1140 /// 1141 /// Such source locations only appear inside of the expansion 1142 /// locations representing where a particular function-like macro was 1143 /// expanded. 1144 bool isMacroArgExpansion(SourceLocation Loc) const; 1145 1146 /// \brief Tests whether the given source location represents the expansion of 1147 /// a macro body. 1148 /// 1149 /// This is equivalent to testing whether the location is part of a macro 1150 /// expansion but not the expansion of an argument to a function-like macro. 1151 bool isMacroBodyExpansion(SourceLocation Loc) const; 1152 1153 /// \brief Returns true if \p Loc is inside the [\p Start, +\p Length) 1154 /// chunk of the source location address space. 1155 /// 1156 /// If it's true and \p RelativeOffset is non-null, it will be set to the 1157 /// relative offset of \p Loc inside the chunk. 1158 bool isInSLocAddrSpace(SourceLocation Loc, 1159 SourceLocation Start, unsigned Length, 1160 unsigned *RelativeOffset = 0) const { 1161 assert(((Start.getOffset() < NextLocalOffset && 1162 Start.getOffset()+Length <= NextLocalOffset) || 1163 (Start.getOffset() >= CurrentLoadedOffset && 1164 Start.getOffset()+Length < MaxLoadedOffset)) && 1165 "Chunk is not valid SLoc address space"); 1166 unsigned LocOffs = Loc.getOffset(); 1167 unsigned BeginOffs = Start.getOffset(); 1168 unsigned EndOffs = BeginOffs + Length; 1169 if (LocOffs >= BeginOffs && LocOffs < EndOffs) { 1170 if (RelativeOffset) 1171 *RelativeOffset = LocOffs - BeginOffs; 1172 return true; 1173 } 1174 1175 return false; 1176 } 1177 1178 /// \brief Return true if both \p LHS and \p RHS are in the local source 1179 /// location address space or the loaded one. 1180 /// 1181 /// If it's true and \p RelativeOffset is non-null, it will be set to the 1182 /// offset of \p RHS relative to \p LHS. isInSameSLocAddrSpace(SourceLocation LHS,SourceLocation RHS,int * RelativeOffset)1183 bool isInSameSLocAddrSpace(SourceLocation LHS, SourceLocation RHS, 1184 int *RelativeOffset) const { 1185 unsigned LHSOffs = LHS.getOffset(), RHSOffs = RHS.getOffset(); 1186 bool LHSLoaded = LHSOffs >= CurrentLoadedOffset; 1187 bool RHSLoaded = RHSOffs >= CurrentLoadedOffset; 1188 1189 if (LHSLoaded == RHSLoaded) { 1190 if (RelativeOffset) 1191 *RelativeOffset = RHSOffs - LHSOffs; 1192 return true; 1193 } 1194 1195 return false; 1196 } 1197 1198 //===--------------------------------------------------------------------===// 1199 // Queries about the code at a SourceLocation. 1200 //===--------------------------------------------------------------------===// 1201 1202 /// \brief Return a pointer to the start of the specified location 1203 /// in the appropriate spelling MemoryBuffer. 1204 /// 1205 /// \param Invalid If non-NULL, will be set \c true if an error occurs. 1206 const char *getCharacterData(SourceLocation SL, bool *Invalid = 0) const; 1207 1208 /// \brief Return the column # for the specified file position. 1209 /// 1210 /// This is significantly cheaper to compute than the line number. This 1211 /// returns zero if the column number isn't known. This may only be called 1212 /// on a file sloc, so you must choose a spelling or expansion location 1213 /// before calling this method. 1214 unsigned getColumnNumber(FileID FID, unsigned FilePos, 1215 bool *Invalid = 0) const; 1216 unsigned getSpellingColumnNumber(SourceLocation Loc, bool *Invalid = 0) const; 1217 unsigned getExpansionColumnNumber(SourceLocation Loc, 1218 bool *Invalid = 0) const; 1219 unsigned getPresumedColumnNumber(SourceLocation Loc, bool *Invalid = 0) const; 1220 1221 1222 /// \brief Given a SourceLocation, return the spelling line number 1223 /// for the position indicated. 1224 /// 1225 /// This requires building and caching a table of line offsets for the 1226 /// MemoryBuffer, so this is not cheap: use only when about to emit a 1227 /// diagnostic. 1228 unsigned getLineNumber(FileID FID, unsigned FilePos, bool *Invalid = 0) const; 1229 unsigned getSpellingLineNumber(SourceLocation Loc, bool *Invalid = 0) const; 1230 unsigned getExpansionLineNumber(SourceLocation Loc, bool *Invalid = 0) const; 1231 unsigned getPresumedLineNumber(SourceLocation Loc, bool *Invalid = 0) const; 1232 1233 /// \brief Return the filename or buffer identifier of the buffer the 1234 /// location is in. 1235 /// 1236 /// Note that this name does not respect \#line directives. Use 1237 /// getPresumedLoc for normal clients. 1238 const char *getBufferName(SourceLocation Loc, bool *Invalid = 0) const; 1239 1240 /// \brief Return the file characteristic of the specified source 1241 /// location, indicating whether this is a normal file, a system 1242 /// header, or an "implicit extern C" system header. 1243 /// 1244 /// This state can be modified with flags on GNU linemarker directives like: 1245 /// \code 1246 /// # 4 "foo.h" 3 1247 /// \endcode 1248 /// which changes all source locations in the current file after that to be 1249 /// considered to be from a system header. 1250 SrcMgr::CharacteristicKind getFileCharacteristic(SourceLocation Loc) const; 1251 1252 /// \brief Returns the "presumed" location of a SourceLocation specifies. 1253 /// 1254 /// A "presumed location" can be modified by \#line or GNU line marker 1255 /// directives. This provides a view on the data that a user should see 1256 /// in diagnostics, for example. 1257 /// 1258 /// Note that a presumed location is always given as the expansion point of 1259 /// an expansion location, not at the spelling location. 1260 /// 1261 /// \returns The presumed location of the specified SourceLocation. If the 1262 /// presumed location cannot be calculate (e.g., because \p Loc is invalid 1263 /// or the file containing \p Loc has changed on disk), returns an invalid 1264 /// presumed location. 1265 PresumedLoc getPresumedLoc(SourceLocation Loc, 1266 bool UseLineDirectives = true) const; 1267 1268 /// \brief Returns true if both SourceLocations correspond to the same file. isFromSameFile(SourceLocation Loc1,SourceLocation Loc2)1269 bool isFromSameFile(SourceLocation Loc1, SourceLocation Loc2) const { 1270 return getFileID(Loc1) == getFileID(Loc2); 1271 } 1272 1273 /// \brief Returns true if the file of provided SourceLocation is the main 1274 /// file. isFromMainFile(SourceLocation Loc)1275 bool isFromMainFile(SourceLocation Loc) const { 1276 return getFileID(Loc) == getMainFileID(); 1277 } 1278 1279 /// \brief Returns if a SourceLocation is in a system header. isInSystemHeader(SourceLocation Loc)1280 bool isInSystemHeader(SourceLocation Loc) const { 1281 return getFileCharacteristic(Loc) != SrcMgr::C_User; 1282 } 1283 1284 /// \brief Returns if a SourceLocation is in an "extern C" system header. isInExternCSystemHeader(SourceLocation Loc)1285 bool isInExternCSystemHeader(SourceLocation Loc) const { 1286 return getFileCharacteristic(Loc) == SrcMgr::C_ExternCSystem; 1287 } 1288 1289 /// \brief Returns whether \p Loc is expanded from a macro in a system header. isInSystemMacro(SourceLocation loc)1290 bool isInSystemMacro(SourceLocation loc) { 1291 return loc.isMacroID() && isInSystemHeader(getSpellingLoc(loc)); 1292 } 1293 1294 /// \brief The size of the SLocEnty that \p FID represents. 1295 unsigned getFileIDSize(FileID FID) const; 1296 1297 /// \brief Given a specific FileID, returns true if \p Loc is inside that 1298 /// FileID chunk and sets relative offset (offset of \p Loc from beginning 1299 /// of FileID) to \p relativeOffset. 1300 bool isInFileID(SourceLocation Loc, FileID FID, 1301 unsigned *RelativeOffset = 0) const { 1302 unsigned Offs = Loc.getOffset(); 1303 if (isOffsetInFileID(FID, Offs)) { 1304 if (RelativeOffset) 1305 *RelativeOffset = Offs - getSLocEntry(FID).getOffset(); 1306 return true; 1307 } 1308 1309 return false; 1310 } 1311 1312 //===--------------------------------------------------------------------===// 1313 // Line Table Manipulation Routines 1314 //===--------------------------------------------------------------------===// 1315 1316 /// \brief Return the uniqued ID for the specified filename. 1317 /// 1318 unsigned getLineTableFilenameID(StringRef Str); 1319 1320 /// \brief Add a line note to the line table for the FileID and offset 1321 /// specified by Loc. 1322 /// 1323 /// If FilenameID is -1, it is considered to be unspecified. 1324 void AddLineNote(SourceLocation Loc, unsigned LineNo, int FilenameID); 1325 void AddLineNote(SourceLocation Loc, unsigned LineNo, int FilenameID, 1326 bool IsFileEntry, bool IsFileExit, 1327 bool IsSystemHeader, bool IsExternCHeader); 1328 1329 /// \brief Determine if the source manager has a line table. hasLineTable()1330 bool hasLineTable() const { return LineTable != 0; } 1331 1332 /// \brief Retrieve the stored line table. 1333 LineTableInfo &getLineTable(); 1334 1335 //===--------------------------------------------------------------------===// 1336 // Queries for performance analysis. 1337 //===--------------------------------------------------------------------===// 1338 1339 /// \brief Return the total amount of physical memory allocated by the 1340 /// ContentCache allocator. getContentCacheSize()1341 size_t getContentCacheSize() const { 1342 return ContentCacheAlloc.getTotalMemory(); 1343 } 1344 1345 struct MemoryBufferSizes { 1346 const size_t malloc_bytes; 1347 const size_t mmap_bytes; 1348 MemoryBufferSizesMemoryBufferSizes1349 MemoryBufferSizes(size_t malloc_bytes, size_t mmap_bytes) 1350 : malloc_bytes(malloc_bytes), mmap_bytes(mmap_bytes) {} 1351 }; 1352 1353 /// \brief Return the amount of memory used by memory buffers, breaking down 1354 /// by heap-backed versus mmap'ed memory. 1355 MemoryBufferSizes getMemoryBufferSizes() const; 1356 1357 /// \brief Return the amount of memory used for various side tables and 1358 /// data structures in the SourceManager. 1359 size_t getDataStructureSizes() const; 1360 1361 //===--------------------------------------------------------------------===// 1362 // Other miscellaneous methods. 1363 //===--------------------------------------------------------------------===// 1364 1365 /// \brief Get the source location for the given file:line:col triplet. 1366 /// 1367 /// If the source file is included multiple times, the source location will 1368 /// be based upon the first inclusion. 1369 SourceLocation translateFileLineCol(const FileEntry *SourceFile, 1370 unsigned Line, unsigned Col) const; 1371 1372 /// \brief Get the FileID for the given file. 1373 /// 1374 /// If the source file is included multiple times, the FileID will be the 1375 /// first inclusion. 1376 FileID translateFile(const FileEntry *SourceFile) const; 1377 1378 /// \brief Get the source location in \p FID for the given line:col. 1379 /// Returns null location if \p FID is not a file SLocEntry. 1380 SourceLocation translateLineCol(FileID FID, 1381 unsigned Line, unsigned Col) const; 1382 1383 /// \brief If \p Loc points inside a function macro argument, the returned 1384 /// location will be the macro location in which the argument was expanded. 1385 /// If a macro argument is used multiple times, the expanded location will 1386 /// be at the first expansion of the argument. 1387 /// e.g. 1388 /// MY_MACRO(foo); 1389 /// ^ 1390 /// Passing a file location pointing at 'foo', will yield a macro location 1391 /// where 'foo' was expanded into. 1392 SourceLocation getMacroArgExpandedLocation(SourceLocation Loc) const; 1393 1394 /// \brief Determines the order of 2 source locations in the translation unit. 1395 /// 1396 /// \returns true if LHS source location comes before RHS, false otherwise. 1397 bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const; 1398 1399 /// \brief Determines the order of 2 source locations in the "source location 1400 /// address space". isBeforeInSLocAddrSpace(SourceLocation LHS,SourceLocation RHS)1401 bool isBeforeInSLocAddrSpace(SourceLocation LHS, SourceLocation RHS) const { 1402 return isBeforeInSLocAddrSpace(LHS, RHS.getOffset()); 1403 } 1404 1405 /// \brief Determines the order of a source location and a source location 1406 /// offset in the "source location address space". 1407 /// 1408 /// Note that we always consider source locations loaded from isBeforeInSLocAddrSpace(SourceLocation LHS,unsigned RHS)1409 bool isBeforeInSLocAddrSpace(SourceLocation LHS, unsigned RHS) const { 1410 unsigned LHSOffset = LHS.getOffset(); 1411 bool LHSLoaded = LHSOffset >= CurrentLoadedOffset; 1412 bool RHSLoaded = RHS >= CurrentLoadedOffset; 1413 if (LHSLoaded == RHSLoaded) 1414 return LHSOffset < RHS; 1415 1416 return LHSLoaded; 1417 } 1418 1419 // Iterators over FileInfos. 1420 typedef llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*> 1421 ::const_iterator fileinfo_iterator; fileinfo_begin()1422 fileinfo_iterator fileinfo_begin() const { return FileInfos.begin(); } fileinfo_end()1423 fileinfo_iterator fileinfo_end() const { return FileInfos.end(); } hasFileInfo(const FileEntry * File)1424 bool hasFileInfo(const FileEntry *File) const { 1425 return FileInfos.find(File) != FileInfos.end(); 1426 } 1427 1428 /// \brief Print statistics to stderr. 1429 /// 1430 void PrintStats() const; 1431 1432 /// \brief Get the number of local SLocEntries we have. local_sloc_entry_size()1433 unsigned local_sloc_entry_size() const { return LocalSLocEntryTable.size(); } 1434 1435 /// \brief Get a local SLocEntry. This is exposed for indexing. 1436 const SrcMgr::SLocEntry &getLocalSLocEntry(unsigned Index, 1437 bool *Invalid = 0) const { 1438 assert(Index < LocalSLocEntryTable.size() && "Invalid index"); 1439 return LocalSLocEntryTable[Index]; 1440 } 1441 1442 /// \brief Get the number of loaded SLocEntries we have. loaded_sloc_entry_size()1443 unsigned loaded_sloc_entry_size() const { return LoadedSLocEntryTable.size();} 1444 1445 /// \brief Get a loaded SLocEntry. This is exposed for indexing. 1446 const SrcMgr::SLocEntry &getLoadedSLocEntry(unsigned Index, 1447 bool *Invalid = 0) const { 1448 assert(Index < LoadedSLocEntryTable.size() && "Invalid index"); 1449 if (SLocEntryLoaded[Index]) 1450 return LoadedSLocEntryTable[Index]; 1451 return loadSLocEntry(Index, Invalid); 1452 } 1453 1454 const SrcMgr::SLocEntry &getSLocEntry(FileID FID, bool *Invalid = 0) const { 1455 if (FID.ID == 0 || FID.ID == -1) { 1456 if (Invalid) *Invalid = true; 1457 return LocalSLocEntryTable[0]; 1458 } 1459 return getSLocEntryByID(FID.ID); 1460 } 1461 getNextLocalOffset()1462 unsigned getNextLocalOffset() const { return NextLocalOffset; } 1463 setExternalSLocEntrySource(ExternalSLocEntrySource * Source)1464 void setExternalSLocEntrySource(ExternalSLocEntrySource *Source) { 1465 assert(LoadedSLocEntryTable.empty() && 1466 "Invalidating existing loaded entries"); 1467 ExternalSLocEntries = Source; 1468 } 1469 1470 /// \brief Allocate a number of loaded SLocEntries, which will be actually 1471 /// loaded on demand from the external source. 1472 /// 1473 /// NumSLocEntries will be allocated, which occupy a total of TotalSize space 1474 /// in the global source view. The lowest ID and the base offset of the 1475 /// entries will be returned. 1476 std::pair<int, unsigned> 1477 AllocateLoadedSLocEntries(unsigned NumSLocEntries, unsigned TotalSize); 1478 1479 /// \brief Returns true if \p Loc came from a PCH/Module. isLoadedSourceLocation(SourceLocation Loc)1480 bool isLoadedSourceLocation(SourceLocation Loc) const { 1481 return Loc.getOffset() >= CurrentLoadedOffset; 1482 } 1483 1484 /// \brief Returns true if \p Loc did not come from a PCH/Module. isLocalSourceLocation(SourceLocation Loc)1485 bool isLocalSourceLocation(SourceLocation Loc) const { 1486 return Loc.getOffset() < NextLocalOffset; 1487 } 1488 1489 /// \brief Returns true if \p FID came from a PCH/Module. isLoadedFileID(FileID FID)1490 bool isLoadedFileID(FileID FID) const { 1491 assert(FID.ID != -1 && "Using FileID sentinel value"); 1492 return FID.ID < 0; 1493 } 1494 1495 /// \brief Returns true if \p FID did not come from a PCH/Module. isLocalFileID(FileID FID)1496 bool isLocalFileID(FileID FID) const { 1497 return !isLoadedFileID(FID); 1498 } 1499 1500 /// Gets the location of the immediate macro caller, one level up the stack 1501 /// toward the initial macro typed into the source. getImmediateMacroCallerLoc(SourceLocation Loc)1502 SourceLocation getImmediateMacroCallerLoc(SourceLocation Loc) const { 1503 if (!Loc.isMacroID()) return Loc; 1504 1505 // When we have the location of (part of) an expanded parameter, its 1506 // spelling location points to the argument as expanded in the macro call, 1507 // and therefore is used to locate the macro caller. 1508 if (isMacroArgExpansion(Loc)) 1509 return getImmediateSpellingLoc(Loc); 1510 1511 // Otherwise, the caller of the macro is located where this macro is 1512 // expanded (while the spelling is part of the macro definition). 1513 return getImmediateExpansionRange(Loc).first; 1514 } 1515 1516 private: 1517 const llvm::MemoryBuffer *getFakeBufferForRecovery() const; 1518 const SrcMgr::ContentCache *getFakeContentCacheForRecovery() const; 1519 1520 const SrcMgr::SLocEntry &loadSLocEntry(unsigned Index, bool *Invalid) const; 1521 1522 /// \brief Get the entry with the given unwrapped FileID. getSLocEntryByID(int ID)1523 const SrcMgr::SLocEntry &getSLocEntryByID(int ID) const { 1524 assert(ID != -1 && "Using FileID sentinel value"); 1525 if (ID < 0) 1526 return getLoadedSLocEntryByID(ID); 1527 return getLocalSLocEntry(static_cast<unsigned>(ID)); 1528 } 1529 1530 const SrcMgr::SLocEntry &getLoadedSLocEntryByID(int ID, 1531 bool *Invalid = 0) const { 1532 return getLoadedSLocEntry(static_cast<unsigned>(-ID - 2), Invalid); 1533 } 1534 1535 /// Implements the common elements of storing an expansion info struct into 1536 /// the SLocEntry table and producing a source location that refers to it. 1537 SourceLocation createExpansionLocImpl(const SrcMgr::ExpansionInfo &Expansion, 1538 unsigned TokLength, 1539 int LoadedID = 0, 1540 unsigned LoadedOffset = 0); 1541 1542 /// \brief Return true if the specified FileID contains the 1543 /// specified SourceLocation offset. This is a very hot method. isOffsetInFileID(FileID FID,unsigned SLocOffset)1544 inline bool isOffsetInFileID(FileID FID, unsigned SLocOffset) const { 1545 const SrcMgr::SLocEntry &Entry = getSLocEntry(FID); 1546 // If the entry is after the offset, it can't contain it. 1547 if (SLocOffset < Entry.getOffset()) return false; 1548 1549 // If this is the very last entry then it does. 1550 if (FID.ID == -2) 1551 return true; 1552 1553 // If it is the last local entry, then it does if the location is local. 1554 if (FID.ID+1 == static_cast<int>(LocalSLocEntryTable.size())) 1555 return SLocOffset < NextLocalOffset; 1556 1557 // Otherwise, the entry after it has to not include it. This works for both 1558 // local and loaded entries. 1559 return SLocOffset < getSLocEntryByID(FID.ID+1).getOffset(); 1560 } 1561 1562 /// \brief Create a new fileID for the specified ContentCache and 1563 /// include position. 1564 /// 1565 /// This works regardless of whether the ContentCache corresponds to a 1566 /// file or some other input source. 1567 FileID createFileID(const SrcMgr::ContentCache* File, 1568 SourceLocation IncludePos, 1569 SrcMgr::CharacteristicKind DirCharacter, 1570 int LoadedID, unsigned LoadedOffset); 1571 1572 const SrcMgr::ContentCache * 1573 getOrCreateContentCache(const FileEntry *SourceFile, 1574 bool isSystemFile = false); 1575 1576 /// \brief Create a new ContentCache for the specified memory buffer. 1577 const SrcMgr::ContentCache* 1578 createMemBufferContentCache(const llvm::MemoryBuffer *Buf); 1579 1580 FileID getFileIDSlow(unsigned SLocOffset) const; 1581 FileID getFileIDLocal(unsigned SLocOffset) const; 1582 FileID getFileIDLoaded(unsigned SLocOffset) const; 1583 1584 SourceLocation getExpansionLocSlowCase(SourceLocation Loc) const; 1585 SourceLocation getSpellingLocSlowCase(SourceLocation Loc) const; 1586 SourceLocation getFileLocSlowCase(SourceLocation Loc) const; 1587 1588 std::pair<FileID, unsigned> 1589 getDecomposedExpansionLocSlowCase(const SrcMgr::SLocEntry *E) const; 1590 std::pair<FileID, unsigned> 1591 getDecomposedSpellingLocSlowCase(const SrcMgr::SLocEntry *E, 1592 unsigned Offset) const; 1593 void computeMacroArgsCache(MacroArgsMap *&MacroArgsCache, FileID FID) const; 1594 void associateFileChunkWithMacroArgExp(MacroArgsMap &MacroArgsCache, 1595 FileID FID, 1596 SourceLocation SpellLoc, 1597 SourceLocation ExpansionLoc, 1598 unsigned ExpansionLength) const; 1599 friend class ASTReader; 1600 friend class ASTWriter; 1601 }; 1602 1603 /// \brief Comparison function object. 1604 template<typename T> 1605 class BeforeThanCompare; 1606 1607 /// \brief Compare two source locations. 1608 template<> 1609 class BeforeThanCompare<SourceLocation> { 1610 SourceManager &SM; 1611 1612 public: BeforeThanCompare(SourceManager & SM)1613 explicit BeforeThanCompare(SourceManager &SM) : SM(SM) { } 1614 operator()1615 bool operator()(SourceLocation LHS, SourceLocation RHS) const { 1616 return SM.isBeforeInTranslationUnit(LHS, RHS); 1617 } 1618 }; 1619 1620 /// \brief Compare two non-overlapping source ranges. 1621 template<> 1622 class BeforeThanCompare<SourceRange> { 1623 SourceManager &SM; 1624 1625 public: BeforeThanCompare(SourceManager & SM)1626 explicit BeforeThanCompare(SourceManager &SM) : SM(SM) { } 1627 operator()1628 bool operator()(SourceRange LHS, SourceRange RHS) { 1629 return SM.isBeforeInTranslationUnit(LHS.getBegin(), RHS.getBegin()); 1630 } 1631 }; 1632 1633 } // end namespace clang 1634 1635 1636 #endif 1637