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