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