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