d87e9ac810fa2b5965cf14fbedb7c6f61f0e23c4
[lldb.git] / clang / include / clang / Basic / SourceManager.h
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"
38 #include "clang/Basic/FileManager.h"
39 #include "clang/Basic/SourceLocation.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   ///
77   enum CharacteristicKind {
78     C_User, C_System, C_ExternCSystem, C_User_ModuleMap, C_System_ModuleMap
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.
117     const FileEntry *OrigEntry;
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.
123     const FileEntry *ContentsEntry;
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),
156           BufferOverridden(false), IsFileVolatile(false), IsTransient(false) {}
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.
161     ContentCache(const ContentCache &RHS)
162         : Buffer(nullptr, false), BufferOverridden(false),
163           IsFileVolatile(false), 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                                         FileManager &FM,
189                                         SourceLocation Loc = SourceLocation(),
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
290     SourceLocation getIncludeLoc() const {
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.
299     CharacteristicKind getFileCharacteristic() const {
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.
308     void setHasLineDirectives() {
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.
320   class ExpansionInfo {
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:
338     SourceLocation getSpellingLoc() const {
339       SourceLocation SpellLoc = SourceLocation::getFromRawEncoding(SpellingLoc);
340       return SpellLoc.isInvalid() ? getExpansionLocStart() : SpellLoc;
341     }
342
343     SourceLocation getExpansionLocStart() const {
344       return SourceLocation::getFromRawEncoding(ExpansionLocStart);
345     }
346
347     SourceLocation getExpansionLocEnd() const {
348       SourceLocation EndLoc =
349         SourceLocation::getFromRawEncoding(ExpansionLocEnd);
350       return EndLoc.isInvalid() ? getExpansionLocStart() : EndLoc;
351     }
352
353     bool isExpansionTokenRange() const {
354       return ExpansionIsTokenRange;
355     }
356
357     CharSourceRange getExpansionLocRange() const {
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() &&
366         SourceLocation::getFromRawEncoding(ExpansionLocEnd).isInvalid();
367     }
368
369     bool isMacroBodyExpansion() const {
370       return getExpansionLocStart().isValid() &&
371         SourceLocation::getFromRawEncoding(ExpansionLocEnd).isValid();
372     }
373
374     bool isFunctionMacroExpansion() const {
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,
386                                 SourceLocation Start, SourceLocation End,
387                                 bool ExpansionIsTokenRange = true) {
388       ExpansionInfo X;
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'.
415     static ExpansionInfo createForMacroArg(SourceLocation SpellingLoc,
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.
428     static ExpansionInfo createForTokenSplit(SourceLocation SpellingLoc,
429                                              SourceLocation Start,
430                                              SourceLocation End) {
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 {
443       FileInfo File;
444       ExpansionInfo Expansion;
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.
487 class ExternalSLocEntrySource {
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.
508 class InBeforeInTUCacheEntry {
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.
582 using ModuleBuildStack = ArrayRef<std::pair<std::string, FullSourceLoc>>;
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.
598   DiagnosticsEngine &Diag;
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:
759   SourceManager(DiagnosticsEngine &Diag, FileManager &FileMgr,
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.
778   void setOverridenFilesKeepOriginalName(bool value) {
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.
787   ModuleBuildStack getModuleBuildStack() const {
788     return StoredModuleBuildStack;
789   }
790
791   /// Set the module build stack.
792   void setModuleBuildStack(ModuleBuildStack 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
842   FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos,
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,
857                       SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User,
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,
873                       SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User,
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.
1028   Optional<FileEntryRef> getFileEntryRefForID(FileID FID) const {
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.
1041   const FileEntry *getFileEntryForSLocEntry(const SrcMgr::SLocEntry &sloc) const
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.
1109   SourceLocation getLocForStartOfFile(FileID FID) const {
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.
1121   SourceLocation getLocForEndOfFile(FileID FID) const {
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.
1133   SourceLocation getIncludeLoc(FileID FID) const {
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>
1146   getModuleImportLoc(SourceLocation Loc) const {
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.
1159   SourceLocation getExpansionLoc(SourceLocation Loc) const {
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.
1169   SourceLocation getFileLoc(SourceLocation Loc) const {
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.
1186   CharSourceRange getExpansionRange(SourceRange Range) const {
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.
1195   CharSourceRange getExpansionRange(CharSourceRange Range) const {
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.
1207   SourceLocation getSpellingLoc(SourceLocation Loc) const {
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.
1223   SourceLocation getComposedLoc(FileID FID, unsigned Offset) const {
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>
1252   getDecomposedExpansionLoc(SourceLocation Loc) const {
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>
1271   getDecomposedSpellingLoc(SourceLocation Loc) const {
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.
1337   bool isInSLocAddrSpace(SourceLocation Loc,
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.
1362   bool isInSameSLocAddrSpace(SourceLocation LHS, SourceLocation RHS,
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.
1462   bool isWrittenInSameFile(SourceLocation Loc1, SourceLocation Loc2) const {
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.
1470   bool isWrittenInMainFile(SourceLocation Loc) const {
1471     return getFileID(Loc) == getMainFileID();
1472   }
1473
1474   /// Returns whether \p Loc is located in a <built-in> file.
1475   bool isWrittenInBuiltinFile(SourceLocation Loc) const {
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.
1481   bool isWrittenInCommandLineFile(SourceLocation Loc) const {
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.
1487   bool isWrittenInScratchSpace(SourceLocation Loc) const {
1488     StringRef Filename(getPresumedLoc(Loc).getFilename());
1489     return Filename.equals("<scratch space>");
1490   }
1491
1492   /// Returns if a SourceLocation is in a system header.
1493   bool isInSystemHeader(SourceLocation Loc) const {
1494     return isSystem(getFileCharacteristic(Loc));
1495   }
1496
1497   /// Returns if a SourceLocation is in an "extern C" system header.
1498   bool isInExternCSystemHeader(SourceLocation Loc) const {
1499     return getFileCharacteristic(Loc) == SrcMgr::C_ExternCSystem;
1500   }
1501
1502   /// Returns whether \p Loc is expanded from a macro in a system header.
1503   bool isInSystemMacro(SourceLocation loc) const {
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.
1526   bool isInFileID(SourceLocation Loc, FileID FID,
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
1569   struct MemoryBufferSizes {
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".
1636   bool isBeforeInSLocAddrSpace(SourceLocation LHS, SourceLocation RHS) const {
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.
1655   bool isPointWithin(SourceLocation Location, SourceLocation Start,
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
1699   const SrcMgr::SLocEntry &getSLocEntry(FileID FID,
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
1710   void setExternalSLocEntrySource(ExternalSLocEntrySource *Source) {
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.
1726   bool isLoadedSourceLocation(SourceLocation Loc) const {
1727     return Loc.getOffset() >= CurrentLoadedOffset;
1728   }
1729
1730   /// Returns true if \p Loc did not come from a PCH/Module.
1731   bool isLocalSourceLocation(SourceLocation Loc) const {
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.
1748   SourceLocation getImmediateMacroCallerLoc(SourceLocation Loc) const {
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>
1864 class BeforeThanCompare;
1865
1866 /// Compare two source locations.
1867 template<>
1868 class BeforeThanCompare<SourceLocation> {
1869   SourceManager &SM;
1870
1871 public:
1872   explicit BeforeThanCompare(SourceManager &SM) : SM(SM) {}
1873
1874   bool operator()(SourceLocation LHS, SourceLocation RHS) const {
1875     return SM.isBeforeInTranslationUnit(LHS, RHS);
1876   }
1877 };
1878
1879 /// Compare two non-overlapping source ranges.
1880 template<>
1881 class BeforeThanCompare<SourceRange> {
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.
1894 class SourceManagerForFile {
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