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