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