clang  5.0.0
SourceManager.cpp
Go to the documentation of this file.
1 //===--- SourceManager.cpp - Track and cache source files -----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the SourceManager interface.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "clang/Basic/Diagnostic.h"
18 #include "llvm/ADT/Optional.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/StringSwitch.h"
21 #include "llvm/Support/Capacity.h"
22 #include "llvm/Support/Compiler.h"
23 #include "llvm/Support/MemoryBuffer.h"
24 #include "llvm/Support/Path.h"
25 #include "llvm/Support/raw_ostream.h"
26 #include <algorithm>
27 #include <cstring>
28 
29 using namespace clang;
30 using namespace SrcMgr;
31 using llvm::MemoryBuffer;
32 
33 //===----------------------------------------------------------------------===//
34 // SourceManager Helper Classes
35 //===----------------------------------------------------------------------===//
36 
38  if (shouldFreeBuffer())
39  delete Buffer.getPointer();
40 }
41 
42 /// getSizeBytesMapped - Returns the number of bytes actually mapped for this
43 /// ContentCache. This can be 0 if the MemBuffer was not actually expanded.
45  return Buffer.getPointer() ? Buffer.getPointer()->getBufferSize() : 0;
46 }
47 
48 /// Returns the kind of memory used to back the memory buffer for
49 /// this content cache. This is used for performance analysis.
50 llvm::MemoryBuffer::BufferKind ContentCache::getMemoryBufferKind() const {
51  assert(Buffer.getPointer());
52 
53  // Should be unreachable, but keep for sanity.
54  if (!Buffer.getPointer())
55  return llvm::MemoryBuffer::MemoryBuffer_Malloc;
56 
57  llvm::MemoryBuffer *buf = Buffer.getPointer();
58  return buf->getBufferKind();
59 }
60 
61 /// getSize - Returns the size of the content encapsulated by this ContentCache.
62 /// This can be the size of the source file or the size of an arbitrary
63 /// scratch buffer. If the ContentCache encapsulates a source file, that
64 /// file is not lazily brought in from disk to satisfy this query.
65 unsigned ContentCache::getSize() const {
66  return Buffer.getPointer() ? (unsigned) Buffer.getPointer()->getBufferSize()
68 }
69 
70 void ContentCache::replaceBuffer(llvm::MemoryBuffer *B, bool DoNotFree) {
71  if (B && B == Buffer.getPointer()) {
72  assert(0 && "Replacing with the same buffer");
73  Buffer.setInt(DoNotFree? DoNotFreeFlag : 0);
74  return;
75  }
76 
77  if (shouldFreeBuffer())
78  delete Buffer.getPointer();
79  Buffer.setPointer(B);
80  Buffer.setInt((B && DoNotFree) ? DoNotFreeFlag : 0);
81 }
82 
84  const SourceManager &SM,
85  SourceLocation Loc,
86  bool *Invalid) const {
87  // Lazily create the Buffer for ContentCaches that wrap files. If we already
88  // computed it, just return what we have.
89  if (Buffer.getPointer() || !ContentsEntry) {
90  if (Invalid)
91  *Invalid = isBufferInvalid();
92 
93  return Buffer.getPointer();
94  }
95 
96  bool isVolatile = SM.userFilesAreVolatile() && !IsSystemFile;
97  auto BufferOrError =
99 
100  // If we were unable to open the file, then we are in an inconsistent
101  // situation where the content cache referenced a file which no longer
102  // exists. Most likely, we were using a stat cache with an invalid entry but
103  // the file could also have been removed during processing. Since we can't
104  // really deal with this situation, just create an empty buffer.
105  //
106  // FIXME: This is definitely not ideal, but our immediate clients can't
107  // currently handle returning a null entry here. Ideally we should detect
108  // that we are in an inconsistent situation and error out as quickly as
109  // possible.
110  if (!BufferOrError) {
111  StringRef FillStr("<<<MISSING SOURCE FILE>>>\n");
112  Buffer.setPointer(MemoryBuffer::getNewUninitMemBuffer(
113  ContentsEntry->getSize(), "<invalid>").release());
114  char *Ptr = const_cast<char*>(Buffer.getPointer()->getBufferStart());
115  for (unsigned i = 0, e = ContentsEntry->getSize(); i != e; ++i)
116  Ptr[i] = FillStr[i % FillStr.size()];
117 
118  if (Diag.isDiagnosticInFlight())
119  Diag.SetDelayedDiagnostic(diag::err_cannot_open_file,
121  BufferOrError.getError().message());
122  else
123  Diag.Report(Loc, diag::err_cannot_open_file)
124  << ContentsEntry->getName() << BufferOrError.getError().message();
125 
126  Buffer.setInt(Buffer.getInt() | InvalidFlag);
127 
128  if (Invalid) *Invalid = true;
129  return Buffer.getPointer();
130  }
131 
132  Buffer.setPointer(BufferOrError->release());
133 
134  // Check that the file's size is the same as in the file entry (which may
135  // have come from a stat cache).
136  if (getRawBuffer()->getBufferSize() != (size_t)ContentsEntry->getSize()) {
137  if (Diag.isDiagnosticInFlight())
138  Diag.SetDelayedDiagnostic(diag::err_file_modified,
140  else
141  Diag.Report(Loc, diag::err_file_modified)
142  << ContentsEntry->getName();
143 
144  Buffer.setInt(Buffer.getInt() | InvalidFlag);
145  if (Invalid) *Invalid = true;
146  return Buffer.getPointer();
147  }
148 
149  // If the buffer is valid, check to see if it has a UTF Byte Order Mark
150  // (BOM). We only support UTF-8 with and without a BOM right now. See
151  // http://en.wikipedia.org/wiki/Byte_order_mark for more information.
152  StringRef BufStr = Buffer.getPointer()->getBuffer();
153  const char *InvalidBOM = llvm::StringSwitch<const char *>(BufStr)
154  .StartsWith("\xFE\xFF", "UTF-16 (BE)")
155  .StartsWith("\xFF\xFE", "UTF-16 (LE)")
156  .StartsWith("\x00\x00\xFE\xFF", "UTF-32 (BE)")
157  .StartsWith("\xFF\xFE\x00\x00", "UTF-32 (LE)")
158  .StartsWith("\x2B\x2F\x76", "UTF-7")
159  .StartsWith("\xF7\x64\x4C", "UTF-1")
160  .StartsWith("\xDD\x73\x66\x73", "UTF-EBCDIC")
161  .StartsWith("\x0E\xFE\xFF", "SDSU")
162  .StartsWith("\xFB\xEE\x28", "BOCU-1")
163  .StartsWith("\x84\x31\x95\x33", "GB-18030")
164  .Default(nullptr);
165 
166  if (InvalidBOM) {
167  Diag.Report(Loc, diag::err_unsupported_bom)
168  << InvalidBOM << ContentsEntry->getName();
169  Buffer.setInt(Buffer.getInt() | InvalidFlag);
170  }
171 
172  if (Invalid)
173  *Invalid = isBufferInvalid();
174 
175  return Buffer.getPointer();
176 }
177 
179  auto IterBool =
180  FilenameIDs.insert(std::make_pair(Name, FilenamesByID.size()));
181  if (IterBool.second)
182  FilenamesByID.push_back(&*IterBool.first);
183  return IterBool.first->second;
184 }
185 
186 /// Add a line note to the line table that indicates that there is a \#line or
187 /// GNU line marker at the specified FID/Offset location which changes the
188 /// presumed location to LineNo/FilenameID. If EntryExit is 0, then this doesn't
189 /// change the presumed \#include stack. If it is 1, this is a file entry, if
190 /// it is 2 then this is a file exit. FileKind specifies whether this is a
191 /// system header or extern C system header.
192 void LineTableInfo::AddLineNote(FileID FID, unsigned Offset, unsigned LineNo,
193  int FilenameID, unsigned EntryExit,
194  SrcMgr::CharacteristicKind FileKind) {
195  std::vector<LineEntry> &Entries = LineEntries[FID];
196 
197  // An unspecified FilenameID means use the last filename if available, or the
198  // main source file otherwise.
199  if (FilenameID == -1 && !Entries.empty())
200  FilenameID = Entries.back().FilenameID;
201 
202  assert((Entries.empty() || Entries.back().FileOffset < Offset) &&
203  "Adding line entries out of order!");
204 
205  unsigned IncludeOffset = 0;
206  if (EntryExit == 0) { // No #include stack change.
207  IncludeOffset = Entries.empty() ? 0 : Entries.back().IncludeOffset;
208  } else if (EntryExit == 1) {
209  IncludeOffset = Offset-1;
210  } else if (EntryExit == 2) {
211  assert(!Entries.empty() && Entries.back().IncludeOffset &&
212  "PPDirectives should have caught case when popping empty include stack");
213 
214  // Get the include loc of the last entries' include loc as our include loc.
215  IncludeOffset = 0;
216  if (const LineEntry *PrevEntry =
217  FindNearestLineEntry(FID, Entries.back().IncludeOffset))
218  IncludeOffset = PrevEntry->IncludeOffset;
219  }
220 
221  Entries.push_back(LineEntry::get(Offset, LineNo, FilenameID, FileKind,
222  IncludeOffset));
223 }
224 
225 
226 /// FindNearestLineEntry - Find the line entry nearest to FID that is before
227 /// it. If there is no line entry before Offset in FID, return null.
229  unsigned Offset) {
230  const std::vector<LineEntry> &Entries = LineEntries[FID];
231  assert(!Entries.empty() && "No #line entries for this FID after all!");
232 
233  // It is very common for the query to be after the last #line, check this
234  // first.
235  if (Entries.back().FileOffset <= Offset)
236  return &Entries.back();
237 
238  // Do a binary search to find the maximal element that is still before Offset.
239  std::vector<LineEntry>::const_iterator I =
240  std::upper_bound(Entries.begin(), Entries.end(), Offset);
241  if (I == Entries.begin()) return nullptr;
242  return &*--I;
243 }
244 
245 /// \brief Add a new line entry that has already been encoded into
246 /// the internal representation of the line table.
248  const std::vector<LineEntry> &Entries) {
249  LineEntries[FID] = Entries;
250 }
251 
252 /// getLineTableFilenameID - Return the uniqued ID for the specified filename.
253 ///
255  return getLineTable().getLineTableFilenameID(Name);
256 }
257 
258 /// AddLineNote - Add a line note to the line table for the FileID and offset
259 /// specified by Loc. If FilenameID is -1, it is considered to be
260 /// unspecified.
261 void SourceManager::AddLineNote(SourceLocation Loc, unsigned LineNo,
262  int FilenameID, bool IsFileEntry,
263  bool IsFileExit,
264  SrcMgr::CharacteristicKind FileKind) {
265  std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
266 
267  bool Invalid = false;
268  const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
269  if (!Entry.isFile() || Invalid)
270  return;
271 
272  const SrcMgr::FileInfo &FileInfo = Entry.getFile();
273 
274  // Remember that this file has #line directives now if it doesn't already.
275  const_cast<SrcMgr::FileInfo&>(FileInfo).setHasLineDirectives();
276 
277  (void) getLineTable();
278 
279  unsigned EntryExit = 0;
280  if (IsFileEntry)
281  EntryExit = 1;
282  else if (IsFileExit)
283  EntryExit = 2;
284 
285  LineTable->AddLineNote(LocInfo.first, LocInfo.second, LineNo, FilenameID,
286  EntryExit, FileKind);
287 }
288 
290  if (!LineTable)
291  LineTable = new LineTableInfo();
292  return *LineTable;
293 }
294 
295 //===----------------------------------------------------------------------===//
296 // Private 'Create' methods.
297 //===----------------------------------------------------------------------===//
298 
300  bool UserFilesAreVolatile)
301  : Diag(Diag), FileMgr(FileMgr), OverridenFilesKeepOriginalName(true),
302  UserFilesAreVolatile(UserFilesAreVolatile), FilesAreTransient(false),
303  ExternalSLocEntries(nullptr), LineTable(nullptr), NumLinearScans(0),
304  NumBinaryProbes(0) {
305  clearIDTables();
306  Diag.setSourceManager(this);
307 }
308 
310  delete LineTable;
311 
312  // Delete FileEntry objects corresponding to content caches. Since the actual
313  // content cache objects are bump pointer allocated, we just have to run the
314  // dtors, but we call the deallocate method for completeness.
315  for (unsigned i = 0, e = MemBufferInfos.size(); i != e; ++i) {
316  if (MemBufferInfos[i]) {
317  MemBufferInfos[i]->~ContentCache();
318  ContentCacheAlloc.Deallocate(MemBufferInfos[i]);
319  }
320  }
321  for (llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*>::iterator
322  I = FileInfos.begin(), E = FileInfos.end(); I != E; ++I) {
323  if (I->second) {
324  I->second->~ContentCache();
325  ContentCacheAlloc.Deallocate(I->second);
326  }
327  }
328 }
329 
331  MainFileID = FileID();
332  LocalSLocEntryTable.clear();
333  LoadedSLocEntryTable.clear();
334  SLocEntryLoaded.clear();
335  LastLineNoFileIDQuery = FileID();
336  LastLineNoContentCache = nullptr;
337  LastFileIDLookup = FileID();
338 
339  if (LineTable)
340  LineTable->clear();
341 
342  // Use up FileID #0 as an invalid expansion.
343  NextLocalOffset = 0;
344  CurrentLoadedOffset = MaxLoadedOffset;
346 }
347 
349  assert(MainFileID.isInvalid() && "expected uninitialized SourceManager");
350 
351  auto CloneContentCache = [&](const ContentCache *Cache) -> ContentCache * {
352  auto *Clone = new (ContentCacheAlloc.Allocate<ContentCache>()) ContentCache;
353  Clone->OrigEntry = Cache->OrigEntry;
354  Clone->ContentsEntry = Cache->ContentsEntry;
355  Clone->BufferOverridden = Cache->BufferOverridden;
356  Clone->IsSystemFile = Cache->IsSystemFile;
357  Clone->IsTransient = Cache->IsTransient;
358  Clone->replaceBuffer(Cache->getRawBuffer(), /*DoNotFree*/true);
359  return Clone;
360  };
361 
362  // Ensure all SLocEntries are loaded from the external source.
363  for (unsigned I = 0, N = Old.LoadedSLocEntryTable.size(); I != N; ++I)
364  if (!Old.SLocEntryLoaded[I])
365  Old.loadSLocEntry(I, nullptr);
366 
367  // Inherit any content cache data from the old source manager.
368  for (auto &FileInfo : Old.FileInfos) {
369  SrcMgr::ContentCache *&Slot = FileInfos[FileInfo.first];
370  if (Slot)
371  continue;
372  Slot = CloneContentCache(FileInfo.second);
373  }
374 }
375 
376 /// getOrCreateContentCache - Create or return a cached ContentCache for the
377 /// specified file.
378 const ContentCache *
379 SourceManager::getOrCreateContentCache(const FileEntry *FileEnt,
380  bool isSystemFile) {
381  assert(FileEnt && "Didn't specify a file entry to use?");
382 
383  // Do we already have information about this file?
384  ContentCache *&Entry = FileInfos[FileEnt];
385  if (Entry) return Entry;
386 
387  // Nope, create a new Cache entry.
388  Entry = ContentCacheAlloc.Allocate<ContentCache>();
389 
390  if (OverriddenFilesInfo) {
391  // If the file contents are overridden with contents from another file,
392  // pass that file to ContentCache.
393  llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator
394  overI = OverriddenFilesInfo->OverriddenFiles.find(FileEnt);
395  if (overI == OverriddenFilesInfo->OverriddenFiles.end())
396  new (Entry) ContentCache(FileEnt);
397  else
398  new (Entry) ContentCache(OverridenFilesKeepOriginalName ? FileEnt
399  : overI->second,
400  overI->second);
401  } else {
402  new (Entry) ContentCache(FileEnt);
403  }
404 
405  Entry->IsSystemFile = isSystemFile;
406  Entry->IsTransient = FilesAreTransient;
407 
408  return Entry;
409 }
410 
411 
412 /// createMemBufferContentCache - Create a new ContentCache for the specified
413 /// memory buffer. This does no caching.
414 const ContentCache *SourceManager::createMemBufferContentCache(
415  std::unique_ptr<llvm::MemoryBuffer> Buffer) {
416  // Add a new ContentCache to the MemBufferInfos list and return it.
417  ContentCache *Entry = ContentCacheAlloc.Allocate<ContentCache>();
418  new (Entry) ContentCache();
419  MemBufferInfos.push_back(Entry);
420  Entry->setBuffer(std::move(Buffer));
421  return Entry;
422 }
423 
424 const SrcMgr::SLocEntry &SourceManager::loadSLocEntry(unsigned Index,
425  bool *Invalid) const {
426  assert(!SLocEntryLoaded[Index]);
427  if (ExternalSLocEntries->ReadSLocEntry(-(static_cast<int>(Index) + 2))) {
428  if (Invalid)
429  *Invalid = true;
430  // If the file of the SLocEntry changed we could still have loaded it.
431  if (!SLocEntryLoaded[Index]) {
432  // Try to recover; create a SLocEntry so the rest of clang can handle it.
433  LoadedSLocEntryTable[Index] = SLocEntry::get(0,
434  FileInfo::get(SourceLocation(),
435  getFakeContentCacheForRecovery(),
436  SrcMgr::C_User));
437  }
438  }
439 
440  return LoadedSLocEntryTable[Index];
441 }
442 
443 std::pair<int, unsigned>
445  unsigned TotalSize) {
446  assert(ExternalSLocEntries && "Don't have an external sloc source");
447  // Make sure we're not about to run out of source locations.
448  if (CurrentLoadedOffset - TotalSize < NextLocalOffset)
449  return std::make_pair(0, 0);
450  LoadedSLocEntryTable.resize(LoadedSLocEntryTable.size() + NumSLocEntries);
451  SLocEntryLoaded.resize(LoadedSLocEntryTable.size());
452  CurrentLoadedOffset -= TotalSize;
453  int ID = LoadedSLocEntryTable.size();
454  return std::make_pair(-ID - 1, CurrentLoadedOffset);
455 }
456 
457 /// \brief As part of recovering from missing or changed content, produce a
458 /// fake, non-empty buffer.
459 llvm::MemoryBuffer *SourceManager::getFakeBufferForRecovery() const {
460  if (!FakeBufferForRecovery)
461  FakeBufferForRecovery =
462  llvm::MemoryBuffer::getMemBuffer("<<<INVALID BUFFER>>");
463 
464  return FakeBufferForRecovery.get();
465 }
466 
467 /// \brief As part of recovering from missing or changed content, produce a
468 /// fake content cache.
469 const SrcMgr::ContentCache *
470 SourceManager::getFakeContentCacheForRecovery() const {
471  if (!FakeContentCacheForRecovery) {
472  FakeContentCacheForRecovery = llvm::make_unique<SrcMgr::ContentCache>();
473  FakeContentCacheForRecovery->replaceBuffer(getFakeBufferForRecovery(),
474  /*DoNotFree=*/true);
475  }
476  return FakeContentCacheForRecovery.get();
477 }
478 
479 /// \brief Returns the previous in-order FileID or an invalid FileID if there
480 /// is no previous one.
481 FileID SourceManager::getPreviousFileID(FileID FID) const {
482  if (FID.isInvalid())
483  return FileID();
484 
485  int ID = FID.ID;
486  if (ID == -1)
487  return FileID();
488 
489  if (ID > 0) {
490  if (ID-1 == 0)
491  return FileID();
492  } else if (unsigned(-(ID-1) - 2) >= LoadedSLocEntryTable.size()) {
493  return FileID();
494  }
495 
496  return FileID::get(ID-1);
497 }
498 
499 /// \brief Returns the next in-order FileID or an invalid FileID if there is
500 /// no next one.
501 FileID SourceManager::getNextFileID(FileID FID) const {
502  if (FID.isInvalid())
503  return FileID();
504 
505  int ID = FID.ID;
506  if (ID > 0) {
507  if (unsigned(ID+1) >= local_sloc_entry_size())
508  return FileID();
509  } else if (ID+1 >= -1) {
510  return FileID();
511  }
512 
513  return FileID::get(ID+1);
514 }
515 
516 //===----------------------------------------------------------------------===//
517 // Methods to create new FileID's and macro expansions.
518 //===----------------------------------------------------------------------===//
519 
520 /// createFileID - Create a new FileID for the specified ContentCache and
521 /// include position. This works regardless of whether the ContentCache
522 /// corresponds to a file or some other input source.
524  SourceLocation IncludePos,
525  SrcMgr::CharacteristicKind FileCharacter,
526  int LoadedID, unsigned LoadedOffset) {
527  if (LoadedID < 0) {
528  assert(LoadedID != -1 && "Loading sentinel FileID");
529  unsigned Index = unsigned(-LoadedID) - 2;
530  assert(Index < LoadedSLocEntryTable.size() && "FileID out of range");
531  assert(!SLocEntryLoaded[Index] && "FileID already loaded");
532  LoadedSLocEntryTable[Index] = SLocEntry::get(LoadedOffset,
533  FileInfo::get(IncludePos, File, FileCharacter));
534  SLocEntryLoaded[Index] = true;
535  return FileID::get(LoadedID);
536  }
537  LocalSLocEntryTable.push_back(SLocEntry::get(NextLocalOffset,
538  FileInfo::get(IncludePos, File,
539  FileCharacter)));
540  unsigned FileSize = File->getSize();
541  assert(NextLocalOffset + FileSize + 1 > NextLocalOffset &&
542  NextLocalOffset + FileSize + 1 <= CurrentLoadedOffset &&
543  "Ran out of source locations!");
544  // We do a +1 here because we want a SourceLocation that means "the end of the
545  // file", e.g. for the "no newline at the end of the file" diagnostic.
546  NextLocalOffset += FileSize + 1;
547 
548  // Set LastFileIDLookup to the newly created file. The next getFileID call is
549  // almost guaranteed to be from that file.
550  FileID FID = FileID::get(LocalSLocEntryTable.size()-1);
551  return LastFileIDLookup = FID;
552 }
553 
556  SourceLocation ExpansionLoc,
557  unsigned TokLength) {
558  ExpansionInfo Info = ExpansionInfo::createForMacroArg(SpellingLoc,
559  ExpansionLoc);
560  return createExpansionLocImpl(Info, TokLength);
561 }
562 
565  SourceLocation ExpansionLocStart,
566  SourceLocation ExpansionLocEnd,
567  unsigned TokLength,
568  int LoadedID,
569  unsigned LoadedOffset) {
570  ExpansionInfo Info = ExpansionInfo::create(SpellingLoc, ExpansionLocStart,
571  ExpansionLocEnd);
572  return createExpansionLocImpl(Info, TokLength, LoadedID, LoadedOffset);
573 }
574 
576 SourceManager::createExpansionLocImpl(const ExpansionInfo &Info,
577  unsigned TokLength,
578  int LoadedID,
579  unsigned LoadedOffset) {
580  if (LoadedID < 0) {
581  assert(LoadedID != -1 && "Loading sentinel FileID");
582  unsigned Index = unsigned(-LoadedID) - 2;
583  assert(Index < LoadedSLocEntryTable.size() && "FileID out of range");
584  assert(!SLocEntryLoaded[Index] && "FileID already loaded");
585  LoadedSLocEntryTable[Index] = SLocEntry::get(LoadedOffset, Info);
586  SLocEntryLoaded[Index] = true;
587  return SourceLocation::getMacroLoc(LoadedOffset);
588  }
589  LocalSLocEntryTable.push_back(SLocEntry::get(NextLocalOffset, Info));
590  assert(NextLocalOffset + TokLength + 1 > NextLocalOffset &&
591  NextLocalOffset + TokLength + 1 <= CurrentLoadedOffset &&
592  "Ran out of source locations!");
593  // See createFileID for that +1.
594  NextLocalOffset += TokLength + 1;
595  return SourceLocation::getMacroLoc(NextLocalOffset - (TokLength + 1));
596 }
597 
598 llvm::MemoryBuffer *SourceManager::getMemoryBufferForFile(const FileEntry *File,
599  bool *Invalid) {
600  const SrcMgr::ContentCache *IR = getOrCreateContentCache(File);
601  assert(IR && "getOrCreateContentCache() cannot return NULL");
602  return IR->getBuffer(Diag, *this, SourceLocation(), Invalid);
603 }
604 
606  llvm::MemoryBuffer *Buffer,
607  bool DoNotFree) {
608  const SrcMgr::ContentCache *IR = getOrCreateContentCache(SourceFile);
609  assert(IR && "getOrCreateContentCache() cannot return NULL");
610 
611  const_cast<SrcMgr::ContentCache *>(IR)->replaceBuffer(Buffer, DoNotFree);
612  const_cast<SrcMgr::ContentCache *>(IR)->BufferOverridden = true;
613 
614  getOverriddenFilesInfo().OverriddenFilesWithBuffer.insert(SourceFile);
615 }
616 
618  const FileEntry *NewFile) {
619  assert(SourceFile->getSize() == NewFile->getSize() &&
620  "Different sizes, use the FileManager to create a virtual file with "
621  "the correct size");
622  assert(FileInfos.count(SourceFile) == 0 &&
623  "This function should be called at the initialization stage, before "
624  "any parsing occurs.");
625  getOverriddenFilesInfo().OverriddenFiles[SourceFile] = NewFile;
626 }
627 
629  if (!isFileOverridden(File))
630  return;
631 
632  const SrcMgr::ContentCache *IR = getOrCreateContentCache(File);
633  const_cast<SrcMgr::ContentCache *>(IR)->replaceBuffer(nullptr);
634  const_cast<SrcMgr::ContentCache *>(IR)->ContentsEntry = IR->OrigEntry;
635 
636  assert(OverriddenFilesInfo);
637  OverriddenFilesInfo->OverriddenFiles.erase(File);
638  OverriddenFilesInfo->OverriddenFilesWithBuffer.erase(File);
639 }
640 
642  const SrcMgr::ContentCache *CC = getOrCreateContentCache(File);
643  const_cast<SrcMgr::ContentCache *>(CC)->IsTransient = true;
644 }
645 
646 StringRef SourceManager::getBufferData(FileID FID, bool *Invalid) const {
647  bool MyInvalid = false;
648  const SLocEntry &SLoc = getSLocEntry(FID, &MyInvalid);
649  if (!SLoc.isFile() || MyInvalid) {
650  if (Invalid)
651  *Invalid = true;
652  return "<<<<<INVALID SOURCE LOCATION>>>>>";
653  }
654 
655  llvm::MemoryBuffer *Buf = SLoc.getFile().getContentCache()->getBuffer(
656  Diag, *this, SourceLocation(), &MyInvalid);
657  if (Invalid)
658  *Invalid = MyInvalid;
659 
660  if (MyInvalid)
661  return "<<<<<INVALID SOURCE LOCATION>>>>>";
662 
663  return Buf->getBuffer();
664 }
665 
666 //===----------------------------------------------------------------------===//
667 // SourceLocation manipulation methods.
668 //===----------------------------------------------------------------------===//
669 
670 /// \brief Return the FileID for a SourceLocation.
671 ///
672 /// This is the cache-miss path of getFileID. Not as hot as that function, but
673 /// still very important. It is responsible for finding the entry in the
674 /// SLocEntry tables that contains the specified location.
675 FileID SourceManager::getFileIDSlow(unsigned SLocOffset) const {
676  if (!SLocOffset)
677  return FileID::get(0);
678 
679  // Now it is time to search for the correct file. See where the SLocOffset
680  // sits in the global view and consult local or loaded buffers for it.
681  if (SLocOffset < NextLocalOffset)
682  return getFileIDLocal(SLocOffset);
683  return getFileIDLoaded(SLocOffset);
684 }
685 
686 /// \brief Return the FileID for a SourceLocation with a low offset.
687 ///
688 /// This function knows that the SourceLocation is in a local buffer, not a
689 /// loaded one.
690 FileID SourceManager::getFileIDLocal(unsigned SLocOffset) const {
691  assert(SLocOffset < NextLocalOffset && "Bad function choice");
692 
693  // After the first and second level caches, I see two common sorts of
694  // behavior: 1) a lot of searched FileID's are "near" the cached file
695  // location or are "near" the cached expansion location. 2) others are just
696  // completely random and may be a very long way away.
697  //
698  // To handle this, we do a linear search for up to 8 steps to catch #1 quickly
699  // then we fall back to a less cache efficient, but more scalable, binary
700  // search to find the location.
701 
702  // See if this is near the file point - worst case we start scanning from the
703  // most newly created FileID.
704  const SrcMgr::SLocEntry *I;
705 
706  if (LastFileIDLookup.ID < 0 ||
707  LocalSLocEntryTable[LastFileIDLookup.ID].getOffset() < SLocOffset) {
708  // Neither loc prunes our search.
709  I = LocalSLocEntryTable.end();
710  } else {
711  // Perhaps it is near the file point.
712  I = LocalSLocEntryTable.begin()+LastFileIDLookup.ID;
713  }
714 
715  // Find the FileID that contains this. "I" is an iterator that points to a
716  // FileID whose offset is known to be larger than SLocOffset.
717  unsigned NumProbes = 0;
718  while (1) {
719  --I;
720  if (I->getOffset() <= SLocOffset) {
721  FileID Res = FileID::get(int(I - LocalSLocEntryTable.begin()));
722 
723  // If this isn't an expansion, remember it. We have good locality across
724  // FileID lookups.
725  if (!I->isExpansion())
726  LastFileIDLookup = Res;
727  NumLinearScans += NumProbes+1;
728  return Res;
729  }
730  if (++NumProbes == 8)
731  break;
732  }
733 
734  // Convert "I" back into an index. We know that it is an entry whose index is
735  // larger than the offset we are looking for.
736  unsigned GreaterIndex = I - LocalSLocEntryTable.begin();
737  // LessIndex - This is the lower bound of the range that we're searching.
738  // We know that the offset corresponding to the FileID is is less than
739  // SLocOffset.
740  unsigned LessIndex = 0;
741  NumProbes = 0;
742  while (1) {
743  bool Invalid = false;
744  unsigned MiddleIndex = (GreaterIndex-LessIndex)/2+LessIndex;
745  unsigned MidOffset = getLocalSLocEntry(MiddleIndex, &Invalid).getOffset();
746  if (Invalid)
747  return FileID::get(0);
748 
749  ++NumProbes;
750 
751  // If the offset of the midpoint is too large, chop the high side of the
752  // range to the midpoint.
753  if (MidOffset > SLocOffset) {
754  GreaterIndex = MiddleIndex;
755  continue;
756  }
757 
758  // If the middle index contains the value, succeed and return.
759  // FIXME: This could be made faster by using a function that's aware of
760  // being in the local area.
761  if (isOffsetInFileID(FileID::get(MiddleIndex), SLocOffset)) {
762  FileID Res = FileID::get(MiddleIndex);
763 
764  // If this isn't a macro expansion, remember it. We have good locality
765  // across FileID lookups.
766  if (!LocalSLocEntryTable[MiddleIndex].isExpansion())
767  LastFileIDLookup = Res;
768  NumBinaryProbes += NumProbes;
769  return Res;
770  }
771 
772  // Otherwise, move the low-side up to the middle index.
773  LessIndex = MiddleIndex;
774  }
775 }
776 
777 /// \brief Return the FileID for a SourceLocation with a high offset.
778 ///
779 /// This function knows that the SourceLocation is in a loaded buffer, not a
780 /// local one.
781 FileID SourceManager::getFileIDLoaded(unsigned SLocOffset) const {
782  // Sanity checking, otherwise a bug may lead to hanging in release build.
783  if (SLocOffset < CurrentLoadedOffset) {
784  assert(0 && "Invalid SLocOffset or bad function choice");
785  return FileID();
786  }
787 
788  // Essentially the same as the local case, but the loaded array is sorted
789  // in the other direction.
790 
791  // First do a linear scan from the last lookup position, if possible.
792  unsigned I;
793  int LastID = LastFileIDLookup.ID;
794  if (LastID >= 0 || getLoadedSLocEntryByID(LastID).getOffset() < SLocOffset)
795  I = 0;
796  else
797  I = (-LastID - 2) + 1;
798 
799  unsigned NumProbes;
800  for (NumProbes = 0; NumProbes < 8; ++NumProbes, ++I) {
801  // Make sure the entry is loaded!
803  if (E.getOffset() <= SLocOffset) {
804  FileID Res = FileID::get(-int(I) - 2);
805 
806  if (!E.isExpansion())
807  LastFileIDLookup = Res;
808  NumLinearScans += NumProbes + 1;
809  return Res;
810  }
811  }
812 
813  // Linear scan failed. Do the binary search. Note the reverse sorting of the
814  // table: GreaterIndex is the one where the offset is greater, which is
815  // actually a lower index!
816  unsigned GreaterIndex = I;
817  unsigned LessIndex = LoadedSLocEntryTable.size();
818  NumProbes = 0;
819  while (1) {
820  ++NumProbes;
821  unsigned MiddleIndex = (LessIndex - GreaterIndex) / 2 + GreaterIndex;
822  const SrcMgr::SLocEntry &E = getLoadedSLocEntry(MiddleIndex);
823  if (E.getOffset() == 0)
824  return FileID(); // invalid entry.
825 
826  ++NumProbes;
827 
828  if (E.getOffset() > SLocOffset) {
829  // Sanity checking, otherwise a bug may lead to hanging in release build.
830  if (GreaterIndex == MiddleIndex) {
831  assert(0 && "binary search missed the entry");
832  return FileID();
833  }
834  GreaterIndex = MiddleIndex;
835  continue;
836  }
837 
838  if (isOffsetInFileID(FileID::get(-int(MiddleIndex) - 2), SLocOffset)) {
839  FileID Res = FileID::get(-int(MiddleIndex) - 2);
840  if (!E.isExpansion())
841  LastFileIDLookup = Res;
842  NumBinaryProbes += NumProbes;
843  return Res;
844  }
845 
846  // Sanity checking, otherwise a bug may lead to hanging in release build.
847  if (LessIndex == MiddleIndex) {
848  assert(0 && "binary search missed the entry");
849  return FileID();
850  }
851  LessIndex = MiddleIndex;
852  }
853 }
854 
855 SourceLocation SourceManager::
856 getExpansionLocSlowCase(SourceLocation Loc) const {
857  do {
858  // Note: If Loc indicates an offset into a token that came from a macro
859  // expansion (e.g. the 5th character of the token) we do not want to add
860  // this offset when going to the expansion location. The expansion
861  // location is the macro invocation, which the offset has nothing to do
862  // with. This is unlike when we get the spelling loc, because the offset
863  // directly correspond to the token whose spelling we're inspecting.
865  } while (!Loc.isFileID());
866 
867  return Loc;
868 }
869 
870 SourceLocation SourceManager::getSpellingLocSlowCase(SourceLocation Loc) const {
871  do {
872  std::pair<FileID, unsigned> LocInfo = getDecomposedLoc(Loc);
873  Loc = getSLocEntry(LocInfo.first).getExpansion().getSpellingLoc();
874  Loc = Loc.getLocWithOffset(LocInfo.second);
875  } while (!Loc.isFileID());
876  return Loc;
877 }
878 
879 SourceLocation SourceManager::getFileLocSlowCase(SourceLocation Loc) const {
880  do {
881  if (isMacroArgExpansion(Loc))
882  Loc = getImmediateSpellingLoc(Loc);
883  else
884  Loc = getImmediateExpansionRange(Loc).first;
885  } while (!Loc.isFileID());
886  return Loc;
887 }
888 
889 
890 std::pair<FileID, unsigned>
891 SourceManager::getDecomposedExpansionLocSlowCase(
892  const SrcMgr::SLocEntry *E) const {
893  // If this is an expansion record, walk through all the expansion points.
894  FileID FID;
895  SourceLocation Loc;
896  unsigned Offset;
897  do {
898  Loc = E->getExpansion().getExpansionLocStart();
899 
900  FID = getFileID(Loc);
901  E = &getSLocEntry(FID);
902  Offset = Loc.getOffset()-E->getOffset();
903  } while (!Loc.isFileID());
904 
905  return std::make_pair(FID, Offset);
906 }
907 
908 std::pair<FileID, unsigned>
909 SourceManager::getDecomposedSpellingLocSlowCase(const SrcMgr::SLocEntry *E,
910  unsigned Offset) const {
911  // If this is an expansion record, walk through all the expansion points.
912  FileID FID;
913  SourceLocation Loc;
914  do {
915  Loc = E->getExpansion().getSpellingLoc();
916  Loc = Loc.getLocWithOffset(Offset);
917 
918  FID = getFileID(Loc);
919  E = &getSLocEntry(FID);
920  Offset = Loc.getOffset()-E->getOffset();
921  } while (!Loc.isFileID());
922 
923  return std::make_pair(FID, Offset);
924 }
925 
926 /// getImmediateSpellingLoc - Given a SourceLocation object, return the
927 /// spelling location referenced by the ID. This is the first level down
928 /// towards the place where the characters that make up the lexed token can be
929 /// found. This should not generally be used by clients.
931  if (Loc.isFileID()) return Loc;
932  std::pair<FileID, unsigned> LocInfo = getDecomposedLoc(Loc);
933  Loc = getSLocEntry(LocInfo.first).getExpansion().getSpellingLoc();
934  return Loc.getLocWithOffset(LocInfo.second);
935 }
936 
937 
938 /// getImmediateExpansionRange - Loc is required to be an expansion location.
939 /// Return the start/end of the expansion information.
940 std::pair<SourceLocation,SourceLocation>
942  assert(Loc.isMacroID() && "Not a macro expansion loc!");
943  const ExpansionInfo &Expansion = getSLocEntry(getFileID(Loc)).getExpansion();
944  return Expansion.getExpansionLocRange();
945 }
946 
947 /// getExpansionRange - Given a SourceLocation object, return the range of
948 /// tokens covered by the expansion in the ultimate file.
949 std::pair<SourceLocation,SourceLocation>
951  if (Loc.isFileID()) return std::make_pair(Loc, Loc);
952 
953  std::pair<SourceLocation,SourceLocation> Res =
955 
956  // Fully resolve the start and end locations to their ultimate expansion
957  // points.
958  while (!Res.first.isFileID())
959  Res.first = getImmediateExpansionRange(Res.first).first;
960  while (!Res.second.isFileID())
961  Res.second = getImmediateExpansionRange(Res.second).second;
962  return Res;
963 }
964 
966  SourceLocation *StartLoc) const {
967  if (!Loc.isMacroID()) return false;
968 
969  FileID FID = getFileID(Loc);
970  const SrcMgr::ExpansionInfo &Expansion = getSLocEntry(FID).getExpansion();
971  if (!Expansion.isMacroArgExpansion()) return false;
972 
973  if (StartLoc)
974  *StartLoc = Expansion.getExpansionLocStart();
975  return true;
976 }
977 
979  if (!Loc.isMacroID()) return false;
980 
981  FileID FID = getFileID(Loc);
982  const SrcMgr::ExpansionInfo &Expansion = getSLocEntry(FID).getExpansion();
983  return Expansion.isMacroBodyExpansion();
984 }
985 
987  SourceLocation *MacroBegin) const {
988  assert(Loc.isValid() && Loc.isMacroID() && "Expected a valid macro loc");
989 
990  std::pair<FileID, unsigned> DecompLoc = getDecomposedLoc(Loc);
991  if (DecompLoc.second > 0)
992  return false; // Does not point at the start of expansion range.
993 
994  bool Invalid = false;
995  const SrcMgr::ExpansionInfo &ExpInfo =
996  getSLocEntry(DecompLoc.first, &Invalid).getExpansion();
997  if (Invalid)
998  return false;
999  SourceLocation ExpLoc = ExpInfo.getExpansionLocStart();
1000 
1001  if (ExpInfo.isMacroArgExpansion()) {
1002  // For macro argument expansions, check if the previous FileID is part of
1003  // the same argument expansion, in which case this Loc is not at the
1004  // beginning of the expansion.
1005  FileID PrevFID = getPreviousFileID(DecompLoc.first);
1006  if (!PrevFID.isInvalid()) {
1007  const SrcMgr::SLocEntry &PrevEntry = getSLocEntry(PrevFID, &Invalid);
1008  if (Invalid)
1009  return false;
1010  if (PrevEntry.isExpansion() &&
1011  PrevEntry.getExpansion().getExpansionLocStart() == ExpLoc)
1012  return false;
1013  }
1014  }
1015 
1016  if (MacroBegin)
1017  *MacroBegin = ExpLoc;
1018  return true;
1019 }
1020 
1022  SourceLocation *MacroEnd) const {
1023  assert(Loc.isValid() && Loc.isMacroID() && "Expected a valid macro loc");
1024 
1025  FileID FID = getFileID(Loc);
1026  SourceLocation NextLoc = Loc.getLocWithOffset(1);
1027  if (isInFileID(NextLoc, FID))
1028  return false; // Does not point at the end of expansion range.
1029 
1030  bool Invalid = false;
1031  const SrcMgr::ExpansionInfo &ExpInfo =
1032  getSLocEntry(FID, &Invalid).getExpansion();
1033  if (Invalid)
1034  return false;
1035 
1036  if (ExpInfo.isMacroArgExpansion()) {
1037  // For macro argument expansions, check if the next FileID is part of the
1038  // same argument expansion, in which case this Loc is not at the end of the
1039  // expansion.
1040  FileID NextFID = getNextFileID(FID);
1041  if (!NextFID.isInvalid()) {
1042  const SrcMgr::SLocEntry &NextEntry = getSLocEntry(NextFID, &Invalid);
1043  if (Invalid)
1044  return false;
1045  if (NextEntry.isExpansion() &&
1046  NextEntry.getExpansion().getExpansionLocStart() ==
1047  ExpInfo.getExpansionLocStart())
1048  return false;
1049  }
1050  }
1051 
1052  if (MacroEnd)
1053  *MacroEnd = ExpInfo.getExpansionLocEnd();
1054  return true;
1055 }
1056 
1057 
1058 //===----------------------------------------------------------------------===//
1059 // Queries about the code at a SourceLocation.
1060 //===----------------------------------------------------------------------===//
1061 
1062 /// getCharacterData - Return a pointer to the start of the specified location
1063 /// in the appropriate MemoryBuffer.
1065  bool *Invalid) const {
1066  // Note that this is a hot function in the getSpelling() path, which is
1067  // heavily used by -E mode.
1068  std::pair<FileID, unsigned> LocInfo = getDecomposedSpellingLoc(SL);
1069 
1070  // Note that calling 'getBuffer()' may lazily page in a source file.
1071  bool CharDataInvalid = false;
1072  const SLocEntry &Entry = getSLocEntry(LocInfo.first, &CharDataInvalid);
1073  if (CharDataInvalid || !Entry.isFile()) {
1074  if (Invalid)
1075  *Invalid = true;
1076 
1077  return "<<<<INVALID BUFFER>>>>";
1078  }
1079  llvm::MemoryBuffer *Buffer = Entry.getFile().getContentCache()->getBuffer(
1080  Diag, *this, SourceLocation(), &CharDataInvalid);
1081  if (Invalid)
1082  *Invalid = CharDataInvalid;
1083  return Buffer->getBufferStart() + (CharDataInvalid? 0 : LocInfo.second);
1084 }
1085 
1086 
1087 /// getColumnNumber - Return the column # for the specified file position.
1088 /// this is significantly cheaper to compute than the line number.
1089 unsigned SourceManager::getColumnNumber(FileID FID, unsigned FilePos,
1090  bool *Invalid) const {
1091  bool MyInvalid = false;
1092  llvm::MemoryBuffer *MemBuf = getBuffer(FID, &MyInvalid);
1093  if (Invalid)
1094  *Invalid = MyInvalid;
1095 
1096  if (MyInvalid)
1097  return 1;
1098 
1099  // It is okay to request a position just past the end of the buffer.
1100  if (FilePos > MemBuf->getBufferSize()) {
1101  if (Invalid)
1102  *Invalid = true;
1103  return 1;
1104  }
1105 
1106  const char *Buf = MemBuf->getBufferStart();
1107  // See if we just calculated the line number for this FilePos and can use
1108  // that to lookup the start of the line instead of searching for it.
1109  if (LastLineNoFileIDQuery == FID &&
1110  LastLineNoContentCache->SourceLineCache != nullptr &&
1111  LastLineNoResult < LastLineNoContentCache->NumLines) {
1112  unsigned *SourceLineCache = LastLineNoContentCache->SourceLineCache;
1113  unsigned LineStart = SourceLineCache[LastLineNoResult - 1];
1114  unsigned LineEnd = SourceLineCache[LastLineNoResult];
1115  if (FilePos >= LineStart && FilePos < LineEnd) {
1116  // LineEnd is the LineStart of the next line.
1117  // A line ends with separator LF or CR+LF on Windows.
1118  // FilePos might point to the last separator,
1119  // but we need a column number at most 1 + the last column.
1120  if (FilePos + 1 == LineEnd && FilePos > LineStart) {
1121  if (Buf[FilePos - 1] == '\r' || Buf[FilePos - 1] == '\n')
1122  --FilePos;
1123  }
1124  return FilePos - LineStart + 1;
1125  }
1126  }
1127 
1128  unsigned LineStart = FilePos;
1129  while (LineStart && Buf[LineStart-1] != '\n' && Buf[LineStart-1] != '\r')
1130  --LineStart;
1131  return FilePos-LineStart+1;
1132 }
1133 
1134 // isInvalid - Return the result of calling loc.isInvalid(), and
1135 // if Invalid is not null, set its value to same.
1136 template<typename LocType>
1137 static bool isInvalid(LocType Loc, bool *Invalid) {
1138  bool MyInvalid = Loc.isInvalid();
1139  if (Invalid)
1140  *Invalid = MyInvalid;
1141  return MyInvalid;
1142 }
1143 
1145  bool *Invalid) const {
1146  if (isInvalid(Loc, Invalid)) return 0;
1147  std::pair<FileID, unsigned> LocInfo = getDecomposedSpellingLoc(Loc);
1148  return getColumnNumber(LocInfo.first, LocInfo.second, Invalid);
1149 }
1150 
1152  bool *Invalid) const {
1153  if (isInvalid(Loc, Invalid)) return 0;
1154  std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
1155  return getColumnNumber(LocInfo.first, LocInfo.second, Invalid);
1156 }
1157 
1159  bool *Invalid) const {
1160  PresumedLoc PLoc = getPresumedLoc(Loc);
1161  if (isInvalid(PLoc, Invalid)) return 0;
1162  return PLoc.getColumn();
1163 }
1164 
1165 #ifdef __SSE2__
1166 #include <emmintrin.h>
1167 #endif
1168 
1169 static LLVM_ATTRIBUTE_NOINLINE void
1171  llvm::BumpPtrAllocator &Alloc,
1172  const SourceManager &SM, bool &Invalid);
1174  llvm::BumpPtrAllocator &Alloc,
1175  const SourceManager &SM, bool &Invalid) {
1176  // Note that calling 'getBuffer()' may lazily page in the file.
1177  MemoryBuffer *Buffer = FI->getBuffer(Diag, SM, SourceLocation(), &Invalid);
1178  if (Invalid)
1179  return;
1180 
1181  // Find the file offsets of all of the *physical* source lines. This does
1182  // not look at trigraphs, escaped newlines, or anything else tricky.
1183  SmallVector<unsigned, 256> LineOffsets;
1184 
1185  // Line #1 starts at char 0.
1186  LineOffsets.push_back(0);
1187 
1188  const unsigned char *Buf = (const unsigned char *)Buffer->getBufferStart();
1189  const unsigned char *End = (const unsigned char *)Buffer->getBufferEnd();
1190  unsigned Offs = 0;
1191  while (1) {
1192  // Skip over the contents of the line.
1193  const unsigned char *NextBuf = (const unsigned char *)Buf;
1194 
1195 #ifdef __SSE2__
1196  // Try to skip to the next newline using SSE instructions. This is very
1197  // performance sensitive for programs with lots of diagnostics and in -E
1198  // mode.
1199  __m128i CRs = _mm_set1_epi8('\r');
1200  __m128i LFs = _mm_set1_epi8('\n');
1201 
1202  // First fix up the alignment to 16 bytes.
1203  while (((uintptr_t)NextBuf & 0xF) != 0) {
1204  if (*NextBuf == '\n' || *NextBuf == '\r' || *NextBuf == '\0')
1205  goto FoundSpecialChar;
1206  ++NextBuf;
1207  }
1208 
1209  // Scan 16 byte chunks for '\r' and '\n'. Ignore '\0'.
1210  while (NextBuf+16 <= End) {
1211  const __m128i Chunk = *(const __m128i*)NextBuf;
1212  __m128i Cmp = _mm_or_si128(_mm_cmpeq_epi8(Chunk, CRs),
1213  _mm_cmpeq_epi8(Chunk, LFs));
1214  unsigned Mask = _mm_movemask_epi8(Cmp);
1215 
1216  // If we found a newline, adjust the pointer and jump to the handling code.
1217  if (Mask != 0) {
1218  NextBuf += llvm::countTrailingZeros(Mask);
1219  goto FoundSpecialChar;
1220  }
1221  NextBuf += 16;
1222  }
1223 #endif
1224 
1225  while (*NextBuf != '\n' && *NextBuf != '\r' && *NextBuf != '\0')
1226  ++NextBuf;
1227 
1228 #ifdef __SSE2__
1229 FoundSpecialChar:
1230 #endif
1231  Offs += NextBuf-Buf;
1232  Buf = NextBuf;
1233 
1234  if (Buf[0] == '\n' || Buf[0] == '\r') {
1235  // If this is \n\r or \r\n, skip both characters.
1236  if ((Buf[1] == '\n' || Buf[1] == '\r') && Buf[0] != Buf[1]) {
1237  ++Offs;
1238  ++Buf;
1239  }
1240  ++Offs;
1241  ++Buf;
1242  LineOffsets.push_back(Offs);
1243  } else {
1244  // Otherwise, this is a null. If end of file, exit.
1245  if (Buf == End) break;
1246  // Otherwise, skip the null.
1247  ++Offs;
1248  ++Buf;
1249  }
1250  }
1251 
1252  // Copy the offsets into the FileInfo structure.
1253  FI->NumLines = LineOffsets.size();
1254  FI->SourceLineCache = Alloc.Allocate<unsigned>(LineOffsets.size());
1255  std::copy(LineOffsets.begin(), LineOffsets.end(), FI->SourceLineCache);
1256 }
1257 
1258 /// getLineNumber - Given a SourceLocation, return the spelling line number
1259 /// for the position indicated. This requires building and caching a table of
1260 /// line offsets for the MemoryBuffer, so this is not cheap: use only when
1261 /// about to emit a diagnostic.
1262 unsigned SourceManager::getLineNumber(FileID FID, unsigned FilePos,
1263  bool *Invalid) const {
1264  if (FID.isInvalid()) {
1265  if (Invalid)
1266  *Invalid = true;
1267  return 1;
1268  }
1269 
1270  ContentCache *Content;
1271  if (LastLineNoFileIDQuery == FID)
1272  Content = LastLineNoContentCache;
1273  else {
1274  bool MyInvalid = false;
1275  const SLocEntry &Entry = getSLocEntry(FID, &MyInvalid);
1276  if (MyInvalid || !Entry.isFile()) {
1277  if (Invalid)
1278  *Invalid = true;
1279  return 1;
1280  }
1281 
1282  Content = const_cast<ContentCache*>(Entry.getFile().getContentCache());
1283  }
1284 
1285  // If this is the first use of line information for this buffer, compute the
1286  /// SourceLineCache for it on demand.
1287  if (!Content->SourceLineCache) {
1288  bool MyInvalid = false;
1289  ComputeLineNumbers(Diag, Content, ContentCacheAlloc, *this, MyInvalid);
1290  if (Invalid)
1291  *Invalid = MyInvalid;
1292  if (MyInvalid)
1293  return 1;
1294  } else if (Invalid)
1295  *Invalid = false;
1296 
1297  // Okay, we know we have a line number table. Do a binary search to find the
1298  // line number that this character position lands on.
1299  unsigned *SourceLineCache = Content->SourceLineCache;
1300  unsigned *SourceLineCacheStart = SourceLineCache;
1301  unsigned *SourceLineCacheEnd = SourceLineCache + Content->NumLines;
1302 
1303  unsigned QueriedFilePos = FilePos+1;
1304 
1305  // FIXME: I would like to be convinced that this code is worth being as
1306  // complicated as it is, binary search isn't that slow.
1307  //
1308  // If it is worth being optimized, then in my opinion it could be more
1309  // performant, simpler, and more obviously correct by just "galloping" outward
1310  // from the queried file position. In fact, this could be incorporated into a
1311  // generic algorithm such as lower_bound_with_hint.
1312  //
1313  // If someone gives me a test case where this matters, and I will do it! - DWD
1314 
1315  // If the previous query was to the same file, we know both the file pos from
1316  // that query and the line number returned. This allows us to narrow the
1317  // search space from the entire file to something near the match.
1318  if (LastLineNoFileIDQuery == FID) {
1319  if (QueriedFilePos >= LastLineNoFilePos) {
1320  // FIXME: Potential overflow?
1321  SourceLineCache = SourceLineCache+LastLineNoResult-1;
1322 
1323  // The query is likely to be nearby the previous one. Here we check to
1324  // see if it is within 5, 10 or 20 lines. It can be far away in cases
1325  // where big comment blocks and vertical whitespace eat up lines but
1326  // contribute no tokens.
1327  if (SourceLineCache+5 < SourceLineCacheEnd) {
1328  if (SourceLineCache[5] > QueriedFilePos)
1329  SourceLineCacheEnd = SourceLineCache+5;
1330  else if (SourceLineCache+10 < SourceLineCacheEnd) {
1331  if (SourceLineCache[10] > QueriedFilePos)
1332  SourceLineCacheEnd = SourceLineCache+10;
1333  else if (SourceLineCache+20 < SourceLineCacheEnd) {
1334  if (SourceLineCache[20] > QueriedFilePos)
1335  SourceLineCacheEnd = SourceLineCache+20;
1336  }
1337  }
1338  }
1339  } else {
1340  if (LastLineNoResult < Content->NumLines)
1341  SourceLineCacheEnd = SourceLineCache+LastLineNoResult+1;
1342  }
1343  }
1344 
1345  unsigned *Pos
1346  = std::lower_bound(SourceLineCache, SourceLineCacheEnd, QueriedFilePos);
1347  unsigned LineNo = Pos-SourceLineCacheStart;
1348 
1349  LastLineNoFileIDQuery = FID;
1350  LastLineNoContentCache = Content;
1351  LastLineNoFilePos = QueriedFilePos;
1352  LastLineNoResult = LineNo;
1353  return LineNo;
1354 }
1355 
1357  bool *Invalid) const {
1358  if (isInvalid(Loc, Invalid)) return 0;
1359  std::pair<FileID, unsigned> LocInfo = getDecomposedSpellingLoc(Loc);
1360  return getLineNumber(LocInfo.first, LocInfo.second);
1361 }
1363  bool *Invalid) const {
1364  if (isInvalid(Loc, Invalid)) return 0;
1365  std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
1366  return getLineNumber(LocInfo.first, LocInfo.second);
1367 }
1369  bool *Invalid) const {
1370  PresumedLoc PLoc = getPresumedLoc(Loc);
1371  if (isInvalid(PLoc, Invalid)) return 0;
1372  return PLoc.getLine();
1373 }
1374 
1375 /// getFileCharacteristic - return the file characteristic of the specified
1376 /// source location, indicating whether this is a normal file, a system
1377 /// header, or an "implicit extern C" system header.
1378 ///
1379 /// This state can be modified with flags on GNU linemarker directives like:
1380 /// # 4 "foo.h" 3
1381 /// which changes all source locations in the current file after that to be
1382 /// considered to be from a system header.
1385  assert(Loc.isValid() && "Can't get file characteristic of invalid loc!");
1386  std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
1387  bool Invalid = false;
1388  const SLocEntry &SEntry = getSLocEntry(LocInfo.first, &Invalid);
1389  if (Invalid || !SEntry.isFile())
1390  return C_User;
1391 
1392  const SrcMgr::FileInfo &FI = SEntry.getFile();
1393 
1394  // If there are no #line directives in this file, just return the whole-file
1395  // state.
1396  if (!FI.hasLineDirectives())
1397  return FI.getFileCharacteristic();
1398 
1399  assert(LineTable && "Can't have linetable entries without a LineTable!");
1400  // See if there is a #line directive before the location.
1401  const LineEntry *Entry =
1402  LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second);
1403 
1404  // If this is before the first line marker, use the file characteristic.
1405  if (!Entry)
1406  return FI.getFileCharacteristic();
1407 
1408  return Entry->FileKind;
1409 }
1410 
1411 /// Return the filename or buffer identifier of the buffer the location is in.
1412 /// Note that this name does not respect \#line directives. Use getPresumedLoc
1413 /// for normal clients.
1415  bool *Invalid) const {
1416  if (isInvalid(Loc, Invalid)) return "<invalid loc>";
1417 
1418  return getBuffer(getFileID(Loc), Invalid)->getBufferIdentifier();
1419 }
1420 
1421 
1422 /// getPresumedLoc - This method returns the "presumed" location of a
1423 /// SourceLocation specifies. A "presumed location" can be modified by \#line
1424 /// or GNU line marker directives. This provides a view on the data that a
1425 /// user should see in diagnostics, for example.
1426 ///
1427 /// Note that a presumed location is always given as the expansion point of an
1428 /// expansion location, not at the spelling location.
1430  bool UseLineDirectives) const {
1431  if (Loc.isInvalid()) return PresumedLoc();
1432 
1433  // Presumed locations are always for expansion points.
1434  std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
1435 
1436  bool Invalid = false;
1437  const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
1438  if (Invalid || !Entry.isFile())
1439  return PresumedLoc();
1440 
1441  const SrcMgr::FileInfo &FI = Entry.getFile();
1442  const SrcMgr::ContentCache *C = FI.getContentCache();
1443 
1444  // To get the source name, first consult the FileEntry (if one exists)
1445  // before the MemBuffer as this will avoid unnecessarily paging in the
1446  // MemBuffer.
1447  StringRef Filename;
1448  if (C->OrigEntry)
1449  Filename = C->OrigEntry->getName();
1450  else
1451  Filename = C->getBuffer(Diag, *this)->getBufferIdentifier();
1452 
1453  unsigned LineNo = getLineNumber(LocInfo.first, LocInfo.second, &Invalid);
1454  if (Invalid)
1455  return PresumedLoc();
1456  unsigned ColNo = getColumnNumber(LocInfo.first, LocInfo.second, &Invalid);
1457  if (Invalid)
1458  return PresumedLoc();
1459 
1460  SourceLocation IncludeLoc = FI.getIncludeLoc();
1461 
1462  // If we have #line directives in this file, update and overwrite the physical
1463  // location info if appropriate.
1464  if (UseLineDirectives && FI.hasLineDirectives()) {
1465  assert(LineTable && "Can't have linetable entries without a LineTable!");
1466  // See if there is a #line directive before this. If so, get it.
1467  if (const LineEntry *Entry =
1468  LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second)) {
1469  // If the LineEntry indicates a filename, use it.
1470  if (Entry->FilenameID != -1)
1471  Filename = LineTable->getFilename(Entry->FilenameID);
1472 
1473  // Use the line number specified by the LineEntry. This line number may
1474  // be multiple lines down from the line entry. Add the difference in
1475  // physical line numbers from the query point and the line marker to the
1476  // total.
1477  unsigned MarkerLineNo = getLineNumber(LocInfo.first, Entry->FileOffset);
1478  LineNo = Entry->LineNo + (LineNo-MarkerLineNo-1);
1479 
1480  // Note that column numbers are not molested by line markers.
1481 
1482  // Handle virtual #include manipulation.
1483  if (Entry->IncludeOffset) {
1484  IncludeLoc = getLocForStartOfFile(LocInfo.first);
1485  IncludeLoc = IncludeLoc.getLocWithOffset(Entry->IncludeOffset);
1486  }
1487  }
1488  }
1489 
1490  return PresumedLoc(Filename.data(), LineNo, ColNo, IncludeLoc);
1491 }
1492 
1493 /// \brief Returns whether the PresumedLoc for a given SourceLocation is
1494 /// in the main file.
1495 ///
1496 /// This computes the "presumed" location for a SourceLocation, then checks
1497 /// whether it came from a file other than the main file. This is different
1498 /// from isWrittenInMainFile() because it takes line marker directives into
1499 /// account.
1501  if (Loc.isInvalid()) return false;
1502 
1503  // Presumed locations are always for expansion points.
1504  std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
1505 
1506  bool Invalid = false;
1507  const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
1508  if (Invalid || !Entry.isFile())
1509  return false;
1510 
1511  const SrcMgr::FileInfo &FI = Entry.getFile();
1512 
1513  // Check if there is a line directive for this location.
1514  if (FI.hasLineDirectives())
1515  if (const LineEntry *Entry =
1516  LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second))
1517  if (Entry->IncludeOffset)
1518  return false;
1519 
1520  return FI.getIncludeLoc().isInvalid();
1521 }
1522 
1523 /// \brief The size of the SLocEntry that \p FID represents.
1525  bool Invalid = false;
1526  const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid);
1527  if (Invalid)
1528  return 0;
1529 
1530  int ID = FID.ID;
1531  unsigned NextOffset;
1532  if ((ID > 0 && unsigned(ID+1) == local_sloc_entry_size()))
1533  NextOffset = getNextLocalOffset();
1534  else if (ID+1 == -1)
1535  NextOffset = MaxLoadedOffset;
1536  else
1537  NextOffset = getSLocEntry(FileID::get(ID+1)).getOffset();
1538 
1539  return NextOffset - Entry.getOffset() - 1;
1540 }
1541 
1542 //===----------------------------------------------------------------------===//
1543 // Other miscellaneous methods.
1544 //===----------------------------------------------------------------------===//
1545 
1546 /// \brief Retrieve the inode for the given file entry, if possible.
1547 ///
1548 /// This routine involves a system call, and therefore should only be used
1549 /// in non-performance-critical code.
1552  if (!File)
1553  return None;
1554 
1555  llvm::sys::fs::UniqueID ID;
1556  if (llvm::sys::fs::getUniqueID(File->getName(), ID))
1557  return None;
1558 
1559  return ID;
1560 }
1561 
1562 /// \brief Get the source location for the given file:line:col triplet.
1563 ///
1564 /// If the source file is included multiple times, the source location will
1565 /// be based upon an arbitrary inclusion.
1567  unsigned Line,
1568  unsigned Col) const {
1569  assert(SourceFile && "Null source file!");
1570  assert(Line && Col && "Line and column should start from 1!");
1571 
1572  FileID FirstFID = translateFile(SourceFile);
1573  return translateLineCol(FirstFID, Line, Col);
1574 }
1575 
1576 /// \brief Get the FileID for the given file.
1577 ///
1578 /// If the source file is included multiple times, the FileID will be the
1579 /// first inclusion.
1581  assert(SourceFile && "Null source file!");
1582 
1583  // Find the first file ID that corresponds to the given file.
1584  FileID FirstFID;
1585 
1586  // First, check the main file ID, since it is common to look for a
1587  // location in the main file.
1588  Optional<llvm::sys::fs::UniqueID> SourceFileUID;
1589  Optional<StringRef> SourceFileName;
1590  if (MainFileID.isValid()) {
1591  bool Invalid = false;
1592  const SLocEntry &MainSLoc = getSLocEntry(MainFileID, &Invalid);
1593  if (Invalid)
1594  return FileID();
1595 
1596  if (MainSLoc.isFile()) {
1597  const ContentCache *MainContentCache
1598  = MainSLoc.getFile().getContentCache();
1599  if (!MainContentCache) {
1600  // Can't do anything
1601  } else if (MainContentCache->OrigEntry == SourceFile) {
1602  FirstFID = MainFileID;
1603  } else {
1604  // Fall back: check whether we have the same base name and inode
1605  // as the main file.
1606  const FileEntry *MainFile = MainContentCache->OrigEntry;
1607  SourceFileName = llvm::sys::path::filename(SourceFile->getName());
1608  if (*SourceFileName == llvm::sys::path::filename(MainFile->getName())) {
1609  SourceFileUID = getActualFileUID(SourceFile);
1610  if (SourceFileUID) {
1611  if (Optional<llvm::sys::fs::UniqueID> MainFileUID =
1612  getActualFileUID(MainFile)) {
1613  if (*SourceFileUID == *MainFileUID) {
1614  FirstFID = MainFileID;
1615  SourceFile = MainFile;
1616  }
1617  }
1618  }
1619  }
1620  }
1621  }
1622  }
1623 
1624  if (FirstFID.isInvalid()) {
1625  // The location we're looking for isn't in the main file; look
1626  // through all of the local source locations.
1627  for (unsigned I = 0, N = local_sloc_entry_size(); I != N; ++I) {
1628  bool Invalid = false;
1629  const SLocEntry &SLoc = getLocalSLocEntry(I, &Invalid);
1630  if (Invalid)
1631  return FileID();
1632 
1633  if (SLoc.isFile() &&
1634  SLoc.getFile().getContentCache() &&
1635  SLoc.getFile().getContentCache()->OrigEntry == SourceFile) {
1636  FirstFID = FileID::get(I);
1637  break;
1638  }
1639  }
1640  // If that still didn't help, try the modules.
1641  if (FirstFID.isInvalid()) {
1642  for (unsigned I = 0, N = loaded_sloc_entry_size(); I != N; ++I) {
1643  const SLocEntry &SLoc = getLoadedSLocEntry(I);
1644  if (SLoc.isFile() &&
1645  SLoc.getFile().getContentCache() &&
1646  SLoc.getFile().getContentCache()->OrigEntry == SourceFile) {
1647  FirstFID = FileID::get(-int(I) - 2);
1648  break;
1649  }
1650  }
1651  }
1652  }
1653 
1654  // If we haven't found what we want yet, try again, but this time stat()
1655  // each of the files in case the files have changed since we originally
1656  // parsed the file.
1657  if (FirstFID.isInvalid() &&
1658  (SourceFileName ||
1659  (SourceFileName = llvm::sys::path::filename(SourceFile->getName()))) &&
1660  (SourceFileUID || (SourceFileUID = getActualFileUID(SourceFile)))) {
1661  bool Invalid = false;
1662  for (unsigned I = 0, N = local_sloc_entry_size(); I != N; ++I) {
1663  FileID IFileID;
1664  IFileID.ID = I;
1665  const SLocEntry &SLoc = getSLocEntry(IFileID, &Invalid);
1666  if (Invalid)
1667  return FileID();
1668 
1669  if (SLoc.isFile()) {
1670  const ContentCache *FileContentCache
1671  = SLoc.getFile().getContentCache();
1672  const FileEntry *Entry = FileContentCache ? FileContentCache->OrigEntry
1673  : nullptr;
1674  if (Entry &&
1675  *SourceFileName == llvm::sys::path::filename(Entry->getName())) {
1676  if (Optional<llvm::sys::fs::UniqueID> EntryUID =
1677  getActualFileUID(Entry)) {
1678  if (*SourceFileUID == *EntryUID) {
1679  FirstFID = FileID::get(I);
1680  SourceFile = Entry;
1681  break;
1682  }
1683  }
1684  }
1685  }
1686  }
1687  }
1688 
1689  (void) SourceFile;
1690  return FirstFID;
1691 }
1692 
1693 /// \brief Get the source location in \arg FID for the given line:col.
1694 /// Returns null location if \arg FID is not a file SLocEntry.
1696  unsigned Line,
1697  unsigned Col) const {
1698  // Lines are used as a one-based index into a zero-based array. This assert
1699  // checks for possible buffer underruns.
1700  assert(Line && Col && "Line and column should start from 1!");
1701 
1702  if (FID.isInvalid())
1703  return SourceLocation();
1704 
1705  bool Invalid = false;
1706  const SLocEntry &Entry = getSLocEntry(FID, &Invalid);
1707  if (Invalid)
1708  return SourceLocation();
1709 
1710  if (!Entry.isFile())
1711  return SourceLocation();
1712 
1713  SourceLocation FileLoc = SourceLocation::getFileLoc(Entry.getOffset());
1714 
1715  if (Line == 1 && Col == 1)
1716  return FileLoc;
1717 
1718  ContentCache *Content
1719  = const_cast<ContentCache *>(Entry.getFile().getContentCache());
1720  if (!Content)
1721  return SourceLocation();
1722 
1723  // If this is the first use of line information for this buffer, compute the
1724  // SourceLineCache for it on demand.
1725  if (!Content->SourceLineCache) {
1726  bool MyInvalid = false;
1727  ComputeLineNumbers(Diag, Content, ContentCacheAlloc, *this, MyInvalid);
1728  if (MyInvalid)
1729  return SourceLocation();
1730  }
1731 
1732  if (Line > Content->NumLines) {
1733  unsigned Size = Content->getBuffer(Diag, *this)->getBufferSize();
1734  if (Size > 0)
1735  --Size;
1736  return FileLoc.getLocWithOffset(Size);
1737  }
1738 
1739  llvm::MemoryBuffer *Buffer = Content->getBuffer(Diag, *this);
1740  unsigned FilePos = Content->SourceLineCache[Line - 1];
1741  const char *Buf = Buffer->getBufferStart() + FilePos;
1742  unsigned BufLength = Buffer->getBufferSize() - FilePos;
1743  if (BufLength == 0)
1744  return FileLoc.getLocWithOffset(FilePos);
1745 
1746  unsigned i = 0;
1747 
1748  // Check that the given column is valid.
1749  while (i < BufLength-1 && i < Col-1 && Buf[i] != '\n' && Buf[i] != '\r')
1750  ++i;
1751  return FileLoc.getLocWithOffset(FilePos + i);
1752 }
1753 
1754 /// \brief Compute a map of macro argument chunks to their expanded source
1755 /// location. Chunks that are not part of a macro argument will map to an
1756 /// invalid source location. e.g. if a file contains one macro argument at
1757 /// offset 100 with length 10, this is how the map will be formed:
1758 /// 0 -> SourceLocation()
1759 /// 100 -> Expanded macro arg location
1760 /// 110 -> SourceLocation()
1761 void SourceManager::computeMacroArgsCache(MacroArgsMap &MacroArgsCache,
1762  FileID FID) const {
1763  assert(FID.isValid());
1764 
1765  // Initially no macro argument chunk is present.
1766  MacroArgsCache.insert(std::make_pair(0, SourceLocation()));
1767 
1768  int ID = FID.ID;
1769  while (1) {
1770  ++ID;
1771  // Stop if there are no more FileIDs to check.
1772  if (ID > 0) {
1773  if (unsigned(ID) >= local_sloc_entry_size())
1774  return;
1775  } else if (ID == -1) {
1776  return;
1777  }
1778 
1779  bool Invalid = false;
1780  const SrcMgr::SLocEntry &Entry = getSLocEntryByID(ID, &Invalid);
1781  if (Invalid)
1782  return;
1783  if (Entry.isFile()) {
1784  SourceLocation IncludeLoc = Entry.getFile().getIncludeLoc();
1785  if (IncludeLoc.isInvalid())
1786  continue;
1787  if (!isInFileID(IncludeLoc, FID))
1788  return; // No more files/macros that may be "contained" in this file.
1789 
1790  // Skip the files/macros of the #include'd file, we only care about macros
1791  // that lexed macro arguments from our file.
1792  if (Entry.getFile().NumCreatedFIDs)
1793  ID += Entry.getFile().NumCreatedFIDs - 1/*because of next ++ID*/;
1794  continue;
1795  }
1796 
1797  const ExpansionInfo &ExpInfo = Entry.getExpansion();
1798 
1799  if (ExpInfo.getExpansionLocStart().isFileID()) {
1800  if (!isInFileID(ExpInfo.getExpansionLocStart(), FID))
1801  return; // No more files/macros that may be "contained" in this file.
1802  }
1803 
1804  if (!ExpInfo.isMacroArgExpansion())
1805  continue;
1806 
1807  associateFileChunkWithMacroArgExp(MacroArgsCache, FID,
1808  ExpInfo.getSpellingLoc(),
1809  SourceLocation::getMacroLoc(Entry.getOffset()),
1810  getFileIDSize(FileID::get(ID)));
1811  }
1812 }
1813 
1814 void SourceManager::associateFileChunkWithMacroArgExp(
1815  MacroArgsMap &MacroArgsCache,
1816  FileID FID,
1817  SourceLocation SpellLoc,
1818  SourceLocation ExpansionLoc,
1819  unsigned ExpansionLength) const {
1820  if (!SpellLoc.isFileID()) {
1821  unsigned SpellBeginOffs = SpellLoc.getOffset();
1822  unsigned SpellEndOffs = SpellBeginOffs + ExpansionLength;
1823 
1824  // The spelling range for this macro argument expansion can span multiple
1825  // consecutive FileID entries. Go through each entry contained in the
1826  // spelling range and if one is itself a macro argument expansion, recurse
1827  // and associate the file chunk that it represents.
1828 
1829  FileID SpellFID; // Current FileID in the spelling range.
1830  unsigned SpellRelativeOffs;
1831  std::tie(SpellFID, SpellRelativeOffs) = getDecomposedLoc(SpellLoc);
1832  while (1) {
1833  const SLocEntry &Entry = getSLocEntry(SpellFID);
1834  unsigned SpellFIDBeginOffs = Entry.getOffset();
1835  unsigned SpellFIDSize = getFileIDSize(SpellFID);
1836  unsigned SpellFIDEndOffs = SpellFIDBeginOffs + SpellFIDSize;
1837  const ExpansionInfo &Info = Entry.getExpansion();
1838  if (Info.isMacroArgExpansion()) {
1839  unsigned CurrSpellLength;
1840  if (SpellFIDEndOffs < SpellEndOffs)
1841  CurrSpellLength = SpellFIDSize - SpellRelativeOffs;
1842  else
1843  CurrSpellLength = ExpansionLength;
1844  associateFileChunkWithMacroArgExp(MacroArgsCache, FID,
1845  Info.getSpellingLoc().getLocWithOffset(SpellRelativeOffs),
1846  ExpansionLoc, CurrSpellLength);
1847  }
1848 
1849  if (SpellFIDEndOffs >= SpellEndOffs)
1850  return; // we covered all FileID entries in the spelling range.
1851 
1852  // Move to the next FileID entry in the spelling range.
1853  unsigned advance = SpellFIDSize - SpellRelativeOffs + 1;
1854  ExpansionLoc = ExpansionLoc.getLocWithOffset(advance);
1855  ExpansionLength -= advance;
1856  ++SpellFID.ID;
1857  SpellRelativeOffs = 0;
1858  }
1859 
1860  }
1861 
1862  assert(SpellLoc.isFileID());
1863 
1864  unsigned BeginOffs;
1865  if (!isInFileID(SpellLoc, FID, &BeginOffs))
1866  return;
1867 
1868  unsigned EndOffs = BeginOffs + ExpansionLength;
1869 
1870  // Add a new chunk for this macro argument. A previous macro argument chunk
1871  // may have been lexed again, so e.g. if the map is
1872  // 0 -> SourceLocation()
1873  // 100 -> Expanded loc #1
1874  // 110 -> SourceLocation()
1875  // and we found a new macro FileID that lexed from offet 105 with length 3,
1876  // the new map will be:
1877  // 0 -> SourceLocation()
1878  // 100 -> Expanded loc #1
1879  // 105 -> Expanded loc #2
1880  // 108 -> Expanded loc #1
1881  // 110 -> SourceLocation()
1882  //
1883  // Since re-lexed macro chunks will always be the same size or less of
1884  // previous chunks, we only need to find where the ending of the new macro
1885  // chunk is mapped to and update the map with new begin/end mappings.
1886 
1887  MacroArgsMap::iterator I = MacroArgsCache.upper_bound(EndOffs);
1888  --I;
1889  SourceLocation EndOffsMappedLoc = I->second;
1890  MacroArgsCache[BeginOffs] = ExpansionLoc;
1891  MacroArgsCache[EndOffs] = EndOffsMappedLoc;
1892 }
1893 
1894 /// \brief If \arg Loc points inside a function macro argument, the returned
1895 /// location will be the macro location in which the argument was expanded.
1896 /// If a macro argument is used multiple times, the expanded location will
1897 /// be at the first expansion of the argument.
1898 /// e.g.
1899 /// MY_MACRO(foo);
1900 /// ^
1901 /// Passing a file location pointing at 'foo', will yield a macro location
1902 /// where 'foo' was expanded into.
1905  if (Loc.isInvalid() || !Loc.isFileID())
1906  return Loc;
1907 
1908  FileID FID;
1909  unsigned Offset;
1910  std::tie(FID, Offset) = getDecomposedLoc(Loc);
1911  if (FID.isInvalid())
1912  return Loc;
1913 
1914  std::unique_ptr<MacroArgsMap> &MacroArgsCache = MacroArgsCacheMap[FID];
1915  if (!MacroArgsCache) {
1916  MacroArgsCache = llvm::make_unique<MacroArgsMap>();
1917  computeMacroArgsCache(*MacroArgsCache, FID);
1918  }
1919 
1920  assert(!MacroArgsCache->empty());
1921  MacroArgsMap::iterator I = MacroArgsCache->upper_bound(Offset);
1922  --I;
1923 
1924  unsigned MacroArgBeginOffs = I->first;
1925  SourceLocation MacroArgExpandedLoc = I->second;
1926  if (MacroArgExpandedLoc.isValid())
1927  return MacroArgExpandedLoc.getLocWithOffset(Offset - MacroArgBeginOffs);
1928 
1929  return Loc;
1930 }
1931 
1932 std::pair<FileID, unsigned>
1934  if (FID.isInvalid())
1935  return std::make_pair(FileID(), 0);
1936 
1937  // Uses IncludedLocMap to retrieve/cache the decomposed loc.
1938 
1939  typedef std::pair<FileID, unsigned> DecompTy;
1940  typedef llvm::DenseMap<FileID, DecompTy> MapTy;
1941  std::pair<MapTy::iterator, bool>
1942  InsertOp = IncludedLocMap.insert(std::make_pair(FID, DecompTy()));
1943  DecompTy &DecompLoc = InsertOp.first->second;
1944  if (!InsertOp.second)
1945  return DecompLoc; // already in map.
1946 
1947  SourceLocation UpperLoc;
1948  bool Invalid = false;
1949  const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid);
1950  if (!Invalid) {
1951  if (Entry.isExpansion())
1952  UpperLoc = Entry.getExpansion().getExpansionLocStart();
1953  else
1954  UpperLoc = Entry.getFile().getIncludeLoc();
1955  }
1956 
1957  if (UpperLoc.isValid())
1958  DecompLoc = getDecomposedLoc(UpperLoc);
1959 
1960  return DecompLoc;
1961 }
1962 
1963 /// Given a decomposed source location, move it up the include/expansion stack
1964 /// to the parent source location. If this is possible, return the decomposed
1965 /// version of the parent in Loc and return false. If Loc is the top-level
1966 /// entry, return true and don't modify it.
1967 static bool MoveUpIncludeHierarchy(std::pair<FileID, unsigned> &Loc,
1968  const SourceManager &SM) {
1969  std::pair<FileID, unsigned> UpperLoc = SM.getDecomposedIncludedLoc(Loc.first);
1970  if (UpperLoc.first.isInvalid())
1971  return true; // We reached the top.
1972 
1973  Loc = UpperLoc;
1974  return false;
1975 }
1976 
1977 /// Return the cache entry for comparing the given file IDs
1978 /// for isBeforeInTranslationUnit.
1979 InBeforeInTUCacheEntry &SourceManager::getInBeforeInTUCache(FileID LFID,
1980  FileID RFID) const {
1981  // This is a magic number for limiting the cache size. It was experimentally
1982  // derived from a small Objective-C project (where the cache filled
1983  // out to ~250 items). We can make it larger if necessary.
1984  enum { MagicCacheSize = 300 };
1985  IsBeforeInTUCacheKey Key(LFID, RFID);
1986 
1987  // If the cache size isn't too large, do a lookup and if necessary default
1988  // construct an entry. We can then return it to the caller for direct
1989  // use. When they update the value, the cache will get automatically
1990  // updated as well.
1991  if (IBTUCache.size() < MagicCacheSize)
1992  return IBTUCache[Key];
1993 
1994  // Otherwise, do a lookup that will not construct a new value.
1995  InBeforeInTUCache::iterator I = IBTUCache.find(Key);
1996  if (I != IBTUCache.end())
1997  return I->second;
1998 
1999  // Fall back to the overflow value.
2000  return IBTUCacheOverflow;
2001 }
2002 
2003 /// \brief Determines the order of 2 source locations in the translation unit.
2004 ///
2005 /// \returns true if LHS source location comes before RHS, false otherwise.
2007  SourceLocation RHS) const {
2008  assert(LHS.isValid() && RHS.isValid() && "Passed invalid source location!");
2009  if (LHS == RHS)
2010  return false;
2011 
2012  std::pair<FileID, unsigned> LOffs = getDecomposedLoc(LHS);
2013  std::pair<FileID, unsigned> ROffs = getDecomposedLoc(RHS);
2014 
2015  // getDecomposedLoc may have failed to return a valid FileID because, e.g. it
2016  // is a serialized one referring to a file that was removed after we loaded
2017  // the PCH.
2018  if (LOffs.first.isInvalid() || ROffs.first.isInvalid())
2019  return LOffs.first.isInvalid() && !ROffs.first.isInvalid();
2020 
2021  std::pair<bool, bool> InSameTU = isInTheSameTranslationUnit(LOffs, ROffs);
2022  if (InSameTU.first)
2023  return InSameTU.second;
2024 
2025  // If we arrived here, the location is either in a built-ins buffer or
2026  // associated with global inline asm. PR5662 and PR22576 are examples.
2027 
2028  StringRef LB = getBuffer(LOffs.first)->getBufferIdentifier();
2029  StringRef RB = getBuffer(ROffs.first)->getBufferIdentifier();
2030  bool LIsBuiltins = LB == "<built-in>";
2031  bool RIsBuiltins = RB == "<built-in>";
2032  // Sort built-in before non-built-in.
2033  if (LIsBuiltins || RIsBuiltins) {
2034  if (LIsBuiltins != RIsBuiltins)
2035  return LIsBuiltins;
2036  // Both are in built-in buffers, but from different files. We just claim that
2037  // lower IDs come first.
2038  return LOffs.first < ROffs.first;
2039  }
2040  bool LIsAsm = LB == "<inline asm>";
2041  bool RIsAsm = RB == "<inline asm>";
2042  // Sort assembler after built-ins, but before the rest.
2043  if (LIsAsm || RIsAsm) {
2044  if (LIsAsm != RIsAsm)
2045  return RIsAsm;
2046  assert(LOffs.first == ROffs.first);
2047  return false;
2048  }
2049  bool LIsScratch = LB == "<scratch space>";
2050  bool RIsScratch = RB == "<scratch space>";
2051  // Sort scratch after inline asm, but before the rest.
2052  if (LIsScratch || RIsScratch) {
2053  if (LIsScratch != RIsScratch)
2054  return LIsScratch;
2055  return LOffs.second < ROffs.second;
2056  }
2057  llvm_unreachable("Unsortable locations found");
2058 }
2059 
2061  std::pair<FileID, unsigned> &LOffs,
2062  std::pair<FileID, unsigned> &ROffs) const {
2063  // If the source locations are in the same file, just compare offsets.
2064  if (LOffs.first == ROffs.first)
2065  return std::make_pair(true, LOffs.second < ROffs.second);
2066 
2067  // If we are comparing a source location with multiple locations in the same
2068  // file, we get a big win by caching the result.
2069  InBeforeInTUCacheEntry &IsBeforeInTUCache =
2070  getInBeforeInTUCache(LOffs.first, ROffs.first);
2071 
2072  // If we are comparing a source location with multiple locations in the same
2073  // file, we get a big win by caching the result.
2074  if (IsBeforeInTUCache.isCacheValid(LOffs.first, ROffs.first))
2075  return std::make_pair(
2076  true, IsBeforeInTUCache.getCachedResult(LOffs.second, ROffs.second));
2077 
2078  // Okay, we missed in the cache, start updating the cache for this query.
2079  IsBeforeInTUCache.setQueryFIDs(LOffs.first, ROffs.first,
2080  /*isLFIDBeforeRFID=*/LOffs.first.ID < ROffs.first.ID);
2081 
2082  // We need to find the common ancestor. The only way of doing this is to
2083  // build the complete include chain for one and then walking up the chain
2084  // of the other looking for a match.
2085  // We use a map from FileID to Offset to store the chain. Easier than writing
2086  // a custom set hash info that only depends on the first part of a pair.
2087  typedef llvm::SmallDenseMap<FileID, unsigned, 16> LocSet;
2088  LocSet LChain;
2089  do {
2090  LChain.insert(LOffs);
2091  // We catch the case where LOffs is in a file included by ROffs and
2092  // quit early. The other way round unfortunately remains suboptimal.
2093  } while (LOffs.first != ROffs.first && !MoveUpIncludeHierarchy(LOffs, *this));
2094  LocSet::iterator I;
2095  while((I = LChain.find(ROffs.first)) == LChain.end()) {
2096  if (MoveUpIncludeHierarchy(ROffs, *this))
2097  break; // Met at topmost file.
2098  }
2099  if (I != LChain.end())
2100  LOffs = *I;
2101 
2102  // If we exited because we found a nearest common ancestor, compare the
2103  // locations within the common file and cache them.
2104  if (LOffs.first == ROffs.first) {
2105  IsBeforeInTUCache.setCommonLoc(LOffs.first, LOffs.second, ROffs.second);
2106  return std::make_pair(
2107  true, IsBeforeInTUCache.getCachedResult(LOffs.second, ROffs.second));
2108  }
2109  // Clear the lookup cache, it depends on a common location.
2110  IsBeforeInTUCache.clear();
2111  return std::make_pair(false, false);
2112 }
2113 
2115  llvm::errs() << "\n*** Source Manager Stats:\n";
2116  llvm::errs() << FileInfos.size() << " files mapped, " << MemBufferInfos.size()
2117  << " mem buffers mapped.\n";
2118  llvm::errs() << LocalSLocEntryTable.size() << " local SLocEntry's allocated ("
2119  << llvm::capacity_in_bytes(LocalSLocEntryTable)
2120  << " bytes of capacity), "
2121  << NextLocalOffset << "B of Sloc address space used.\n";
2122  llvm::errs() << LoadedSLocEntryTable.size()
2123  << " loaded SLocEntries allocated, "
2124  << MaxLoadedOffset - CurrentLoadedOffset
2125  << "B of Sloc address space used.\n";
2126 
2127  unsigned NumLineNumsComputed = 0;
2128  unsigned NumFileBytesMapped = 0;
2129  for (fileinfo_iterator I = fileinfo_begin(), E = fileinfo_end(); I != E; ++I){
2130  NumLineNumsComputed += I->second->SourceLineCache != nullptr;
2131  NumFileBytesMapped += I->second->getSizeBytesMapped();
2132  }
2133  unsigned NumMacroArgsComputed = MacroArgsCacheMap.size();
2134 
2135  llvm::errs() << NumFileBytesMapped << " bytes of files mapped, "
2136  << NumLineNumsComputed << " files with line #'s computed, "
2137  << NumMacroArgsComputed << " files with macro args computed.\n";
2138  llvm::errs() << "FileID scans: " << NumLinearScans << " linear, "
2139  << NumBinaryProbes << " binary.\n";
2140 }
2141 
2142 LLVM_DUMP_METHOD void SourceManager::dump() const {
2143  llvm::raw_ostream &out = llvm::errs();
2144 
2145  auto DumpSLocEntry = [&](int ID, const SrcMgr::SLocEntry &Entry,
2146  llvm::Optional<unsigned> NextStart) {
2147  out << "SLocEntry <FileID " << ID << "> " << (Entry.isFile() ? "file" : "expansion")
2148  << " <SourceLocation " << Entry.getOffset() << ":";
2149  if (NextStart)
2150  out << *NextStart << ">\n";
2151  else
2152  out << "???\?>\n";
2153  if (Entry.isFile()) {
2154  auto &FI = Entry.getFile();
2155  if (FI.NumCreatedFIDs)
2156  out << " covers <FileID " << ID << ":" << int(ID + FI.NumCreatedFIDs)
2157  << ">\n";
2158  if (FI.getIncludeLoc().isValid())
2159  out << " included from " << FI.getIncludeLoc().getOffset() << "\n";
2160  if (auto *CC = FI.getContentCache()) {
2161  out << " for " << (CC->OrigEntry ? CC->OrigEntry->getName() : "<none>")
2162  << "\n";
2163  if (CC->BufferOverridden)
2164  out << " contents overridden\n";
2165  if (CC->ContentsEntry != CC->OrigEntry) {
2166  out << " contents from "
2167  << (CC->ContentsEntry ? CC->ContentsEntry->getName() : "<none>")
2168  << "\n";
2169  }
2170  }
2171  } else {
2172  auto &EI = Entry.getExpansion();
2173  out << " spelling from " << EI.getSpellingLoc().getOffset() << "\n";
2174  out << " macro " << (EI.isMacroArgExpansion() ? "arg" : "body")
2175  << " range <" << EI.getExpansionLocStart().getOffset() << ":"
2176  << EI.getExpansionLocEnd().getOffset() << ">\n";
2177  }
2178  };
2179 
2180  // Dump local SLocEntries.
2181  for (unsigned ID = 0, NumIDs = LocalSLocEntryTable.size(); ID != NumIDs; ++ID) {
2182  DumpSLocEntry(ID, LocalSLocEntryTable[ID],
2183  ID == NumIDs - 1 ? NextLocalOffset
2184  : LocalSLocEntryTable[ID + 1].getOffset());
2185  }
2186  // Dump loaded SLocEntries.
2187  llvm::Optional<unsigned> NextStart;
2188  for (unsigned Index = 0; Index != LoadedSLocEntryTable.size(); ++Index) {
2189  int ID = -(int)Index - 2;
2190  if (SLocEntryLoaded[Index]) {
2191  DumpSLocEntry(ID, LoadedSLocEntryTable[Index], NextStart);
2192  NextStart = LoadedSLocEntryTable[Index].getOffset();
2193  } else {
2194  NextStart = None;
2195  }
2196  }
2197 }
2198 
2200 
2201 /// Return the amount of memory used by memory buffers, breaking down
2202 /// by heap-backed versus mmap'ed memory.
2204  size_t malloc_bytes = 0;
2205  size_t mmap_bytes = 0;
2206 
2207  for (unsigned i = 0, e = MemBufferInfos.size(); i != e; ++i)
2208  if (size_t sized_mapped = MemBufferInfos[i]->getSizeBytesMapped())
2209  switch (MemBufferInfos[i]->getMemoryBufferKind()) {
2210  case llvm::MemoryBuffer::MemoryBuffer_MMap:
2211  mmap_bytes += sized_mapped;
2212  break;
2213  case llvm::MemoryBuffer::MemoryBuffer_Malloc:
2214  malloc_bytes += sized_mapped;
2215  break;
2216  }
2217 
2218  return MemoryBufferSizes(malloc_bytes, mmap_bytes);
2219 }
2220 
2222  size_t size = llvm::capacity_in_bytes(MemBufferInfos)
2223  + llvm::capacity_in_bytes(LocalSLocEntryTable)
2224  + llvm::capacity_in_bytes(LoadedSLocEntryTable)
2225  + llvm::capacity_in_bytes(SLocEntryLoaded)
2226  + llvm::capacity_in_bytes(FileInfos);
2227 
2228  if (OverriddenFilesInfo)
2229  size += llvm::capacity_in_bytes(OverriddenFilesInfo->OverriddenFiles);
2230 
2231  return size;
2232 }
bool hasLineDirectives() const
Return true if this FileID has #line directives in it.
bool isMacroArgExpansion(SourceLocation Loc, SourceLocation *StartLoc=nullptr) const
Tests whether the given source location represents a macro argument's expansion into the function-lik...
const FileEntry * OrigEntry
Reference to the file entry representing this ContentCache.
StringRef getFilename(unsigned ID) const
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.
static bool MoveUpIncludeHierarchy(std::pair< FileID, unsigned > &Loc, const SourceManager &SM)
Given a decomposed source location, move it up the include/expansion stack to the parent source locat...
unsigned getColumn() const
Return the presumed column number of this location.
bool isMacroID() const
std::pair< FileID, unsigned > getDecomposedExpansionLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
unsigned local_sloc_entry_size() const
Get the number of local SLocEntries we have.
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c.h:60
Defines the clang::FileManager interface and associated types.
SourceLocation getImmediateSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
unsigned getSizeBytesMapped() const
Returns the number of bytes actually mapped for this ContentCache.
Defines the SourceManager interface.
unsigned getNextLocalOffset() const
unsigned getSpellingLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
unsigned NumLines
The number of lines in this ContentCache.
const SrcMgr::SLocEntry & getSLocEntry(FileID FID, bool *Invalid=nullptr) const
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer...
llvm::MemoryBuffer * getBuffer(FileID FID, SourceLocation Loc, bool *Invalid=nullptr) const
Return the buffer for the specified FileID.
TypePropertyCache< Private > Cache
Definition: Type.cpp:3326
unsigned getPresumedLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
Each ExpansionInfo encodes the expansion location - where the token was ultimately expanded...
const ExpansionInfo & getExpansion() const
std::unique_ptr< llvm::MemoryBuffer > Buffer
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1205
void setQueryFIDs(FileID LHS, FileID RHS, bool isLFIDBeforeRFID)
Set up a new query.
llvm::DenseMap< Stmt *, Stmt * > MapTy
Definition: ParentMap.cpp:22
fileinfo_iterator fileinfo_begin() const
void setCommonLoc(FileID commonFID, unsigned lCommonOffset, unsigned rCommonOffset)
SourceLocation getIncludeLoc() const
CharacteristicKind getFileCharacteristic() const
Return whether this is a system header or not.
virtual bool ReadSLocEntry(int ID)=0
Read the source location entry with index ID, which will always be less than -1.
unsigned getLineTableFilenameID(StringRef Str)
void SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1="", StringRef Arg2="")
Set the "delayed" diagnostic that will be emitted once the current diagnostic completes.
Definition: Diagnostic.cpp:138
static LLVM_ATTRIBUTE_NOINLINE void ComputeLineNumbers(DiagnosticsEngine &Diag, ContentCache *FI, llvm::BumpPtrAllocator &Alloc, const SourceManager &SM, bool &Invalid)
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:82
Used to hold and unique data used to represent #line information.
off_t getSize() const
Definition: FileManager.h:87
void disableFileContentsOverride(const FileEntry *File)
Disable overridding the contents of a file, previously enabled with overrideFileContents.
StringRef getBufferData(FileID FID, bool *Invalid=nullptr) const
Return a StringRef to the source buffer data for the specified FileID.
std::pair< SourceLocation, SourceLocation > getExpansionRange(SourceLocation Loc) const
Given a SourceLocation object, return the range of tokens covered by the expansion in the ultimate fi...
bool isDiagnosticInFlight() const
Determine whethere there is already a diagnostic in flight.
Definition: Diagnostic.h:765
llvm::MemoryBuffer * getRawBuffer() const
Get the underlying buffer, returning NULL if the buffer is not yet available.
bool isFileID() const
One instance of this struct is kept for every file loaded or used.
Definition: SourceManager.h:99
const LineEntry * FindNearestLineEntry(FileID FID, unsigned Offset)
Find the line entry nearest to FID that is before it.
StringRef getBufferName(SourceLocation Loc, bool *Invalid=nullptr) const
Return the filename or buffer identifier of the buffer the location is in.
unsigned IsTransient
True if this file may be transient, that is, if it might not exist at some later point in time when t...
void setSourceManager(SourceManager *SrcMgr)
Definition: Diagnostic.h:442
unsigned getExpansionColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const
std::pair< FileID, unsigned > getDecomposedSpellingLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set1_epi8(char __b)
Initializes all values in a 128-bit vector of [16 x i8] with the specified 8-bit value.
Definition: emmintrin.h:3831
unsigned getFileIDSize(FileID FID) const
The size of the SLocEntry that FID represents.
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
uint32_t Offset
Definition: CacheTokens.cpp:43
bool isMacroBodyExpansion(SourceLocation Loc) const
Tests whether the given source location represents the expansion of a macro body. ...
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:147
Defines the Diagnostic-related interfaces.
StringRef getName() const
Definition: FileManager.h:84
unsigned getLine() const
Return the presumed line number of this location.
SourceLocation translateFileLineCol(const FileEntry *SourceFile, unsigned Line, unsigned Col) const
Get the source location for the given file:line:col triplet.
detail::InMemoryDirectory::const_iterator I
bool isInvalid() const
SrcMgr::CharacteristicKind FileKind
Set the 0 if no flags, 1 if a system header,.
void initializeForReplay(const SourceManager &Old)
Initialize this source manager suitably to replay the compilation described by Old.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
bool isMacroBodyExpansion() const
StringRef Filename
Definition: Format.cpp:1301
unsigned getPresumedColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
SourceLocation translateLineCol(FileID FID, unsigned Line, unsigned Col) const
Get the source location in FID for the given line:col.
void setFileIsTransient(const FileEntry *SourceFile)
Specify that a file is transient.
size_t getDataStructureSizes() const
Return the amount of memory used for various side tables and data structures in the SourceManager...
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...
SourceLocation getMacroArgExpandedLocation(SourceLocation Loc) const
If Loc points inside a function macro argument, the returned location will be the macro location in w...
static Optional< llvm::sys::fs::UniqueID > getActualFileUID(const FileEntry *File)
Retrieve the inode for the given file entry, if possible.
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
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...
Defines implementation details of the clang::SourceManager class.
FileManager & getFileManager() const
SourceLocation createMacroArgExpansionLoc(SourceLocation Loc, SourceLocation ExpansionLoc, unsigned TokLength)
Return a new SourceLocation that encodes the fact that a token from SpellingLoc should actually be re...
const FileEntry * ContentsEntry
References the file which the contents were actually loaded from.
const SrcMgr::SLocEntry & getLocalSLocEntry(unsigned Index, bool *Invalid=nullptr) const
Get a local SLocEntry. This is exposed for indexing.
static LineEntry get(unsigned Offs, unsigned Line, int Filename, SrcMgr::CharacteristicKind FileKind, unsigned IncludeOffset)
unsigned getExpansionLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
Represents an unpacked "presumed" location which can be presented to the user.
SourceLocation createExpansionLoc(SourceLocation Loc, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd, unsigned TokLength, int LoadedID=0, unsigned LoadedOffset=0)
Return a new SourceLocation that encodes the fact that a token from SpellingLoc should actually be re...
SourceLocation getExpansionLocEnd() const
unsigned getColumnNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const
Return the column # for the specified file position.
const SourceManager & SM
Definition: Format.cpp:1293
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c.h:82
void AddEntry(FileID FID, const std::vector< LineEntry > &Entries)
Add a new line entry that has already been encoded into the internal representation of the line table...
void overrideFileContents(const FileEntry *SourceFile, llvm::MemoryBuffer *Buffer, bool DoNotFree)
Override the contents of the given source file by providing an already-allocated buffer.
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
Information about a FileID, basically just the logical file that it represents and include stack info...
#define false
Definition: stdbool.h:33
Encodes a location in the source.
AnnotatedLine & Line
bool isValid() const
Return true if this is a valid SourceLocation object.
const std::string ID
unsigned IsSystemFile
True if this content cache was initially created for a source file considered as a system one...
unsigned getOffset() const
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
bool isAtEndOfImmediateMacroExpansion(SourceLocation Loc, SourceLocation *MacroEnd=nullptr) const
Returns true if the given MacroID location points at the character end of the immediate macro expansi...
unsigned getSpellingColumnNumber(SourceLocation Loc, bool *Invalid=nullptr) const
llvm::MemoryBuffer * getMemoryBufferForFile(const FileEntry *File, bool *Invalid=nullptr)
Retrieve the memory buffer associated with the given file.
bool isCacheValid(FileID LHS, FileID RHS) const
Return true if the currently cached values match up with the specified LHS/RHS query.
const FileInfo & getFile() const
void replaceBuffer(llvm::MemoryBuffer *B, bool DoNotFree=false)
Replace the existing buffer (which will be deleted) with the given buffer.
unsigned * SourceLineCache
A bump pointer allocated array of offsets for each source line.
SourceManager(DiagnosticsEngine &Diag, FileManager &FileMgr, bool UserFilesAreVolatile=false)
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
MemoryBufferSizes getMemoryBufferSizes() const
Return the amount of memory used by memory buffers, breaking down by heap-backed versus mmap'ed memor...
static bool isInvalid(LocType Loc, bool *Invalid)
llvm::MemoryBuffer::BufferKind getMemoryBufferKind() const
Returns the kind of memory used to back the memory buffer for this content cache. ...
StringRef Name
Definition: USRFinder.cpp:123
bool getCachedResult(unsigned LOffset, unsigned ROffset) const
If the cache is valid, compute the result given the specified offsets in the LHS/RHS FileID's...
SrcMgr::CharacteristicKind getFileCharacteristic(SourceLocation Loc) const
Return the file characteristic of the specified source location, indicating whether this is a normal ...
unsigned getLineTableFilenameID(StringRef Str)
Return the uniqued ID for the specified filename.
bool isAtStartOfImmediateMacroExpansion(SourceLocation Loc, SourceLocation *MacroBegin=nullptr) const
Returns true if the given MacroID location points at the beginning of the immediate macro expansion...
std::pair< SourceLocation, SourceLocation > getImmediateExpansionRange(SourceLocation Loc) const
Return the start/end of the expansion information for an expansion location.
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const FileEntry *Entry, bool isVolatile=false, bool ShouldCloseOpenFile=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
const ContentCache * getContentCache() const
fileinfo_iterator fileinfo_end() const
void AddLineNote(SourceLocation Loc, unsigned LineNo, int FilenameID, bool IsFileEntry, bool IsFileExit, SrcMgr::CharacteristicKind FileKind)
Add a line note to the line table for the FileID and offset specified by Loc.
unsigned getLineNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const
Given a SourceLocation, return the spelling line number for the position indicated.
detail::InMemoryDirectory::const_iterator E
SourceLocation getExpansionLocStart() const
bool shouldFreeBuffer() const
Determine whether the buffer should be freed.
llvm::DenseMap< const FileEntry *, SrcMgr::ContentCache * >::const_iterator fileinfo_iterator
FileID translateFile(const FileEntry *SourceFile) const
Get the FileID for the given file.
void setBuffer(std::unique_ptr< llvm::MemoryBuffer > B)
bool userFilesAreVolatile() const
True if non-system source files should be treated as volatile (likely to change while trying to use t...
Holds the cache used by isBeforeInTranslationUnit.
bool isInvalid() const
std::pair< int, unsigned > AllocateLoadedSLocEntries(unsigned NumSLocEntries, unsigned TotalSize)
Allocate a number of loaded SLocEntries, which will be actually loaded on demand from the external so...
The type-property cache.
Definition: Type.cpp:3286
std::pair< bool, bool > isInTheSameTranslationUnit(std::pair< FileID, unsigned > &LOffs, std::pair< FileID, unsigned > &ROffs) const
Determines whether the two decomposed source location is in the same translation unit.
bool isBufferInvalid() const
Determine whether the buffer itself is invalid.
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_or_si128(__m128i __a, __m128i __b)
Performs a bitwise OR of two 128-bit integer vectors.
Definition: emmintrin.h:2733
void PrintStats() const
Print statistics to stderr.
LineTableInfo & getLineTable()
Retrieve the stored line table.
static __inline__ int __DEFAULT_FN_ATTRS _mm_movemask_epi8(__m128i __a)
Copies the values of the most significant bits from each 8-bit element in a 128-bit integer vector of...
Definition: emmintrin.h:4333
unsigned loaded_sloc_entry_size() const
Get the number of loaded SLocEntries we have.
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file. ...
llvm::MemoryBuffer * getBuffer(DiagnosticsEngine &Diag, const SourceManager &SM, SourceLocation Loc=SourceLocation(), bool *Invalid=nullptr) const
Returns the memory buffer for the associated content.
std::pair< SourceLocation, SourceLocation > getExpansionLocRange() const
#define true
Definition: stdbool.h:32
const SrcMgr::SLocEntry & getLoadedSLocEntry(unsigned Index, bool *Invalid=nullptr) const
Get a loaded SLocEntry. This is exposed for indexing.
std::pair< FileID, unsigned > getDecomposedIncludedLoc(FileID FID) const
Returns the "included/expanded in" decomposed location of the given FileID.
bool isFileOverridden(const FileEntry *File) const
Returns true if the file contents have been overridden.
void AddLineNote(FileID FID, unsigned Offset, unsigned LineNo, int FilenameID, unsigned EntryExit, SrcMgr::CharacteristicKind FileKind)
Add a line note to the line table that indicates that there is a #line or GNU line marker at the spec...
bool isValid() const
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
This class handles loading and caching of source files into memory.
unsigned getSize() const
Returns the size of the content encapsulated by this ContentCache.
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi8(__m128i __a, __m128i __b)
Compares each of the corresponding 8-bit values of the 128-bit integer vectors for equality...
Definition: emmintrin.h:3160
SourceLocation getSpellingLoc() const
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.