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