LLVM  7.0.0svn
SourceMgr.cpp
Go to the documentation of this file.
1 //===- SourceMgr.cpp - Manager for Simple Source Buffers & Diagnostics ----===//
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 SourceMgr class. This class is used as a simple
11 // substrate for diagnostics, #include handling, and other low level things for
12 // simple parsers.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #include "llvm/Support/SourceMgr.h"
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/ADT/Twine.h"
22 #include "llvm/Support/ErrorOr.h"
23 #include "llvm/Support/Locale.h"
25 #include "llvm/Support/Path.h"
26 #include "llvm/Support/SMLoc.h"
28 #include <algorithm>
29 #include <cassert>
30 #include <cstddef>
31 #include <limits>
32 #include <memory>
33 #include <string>
34 #include <utility>
35 
36 using namespace llvm;
37 
38 static const size_t TabStop = 8;
39 
40 unsigned SourceMgr::AddIncludeFile(const std::string &Filename,
41  SMLoc IncludeLoc,
42  std::string &IncludedFile) {
43  IncludedFile = Filename;
45  MemoryBuffer::getFile(IncludedFile);
46 
47  // If the file didn't exist directly, see if it's in an include path.
48  for (unsigned i = 0, e = IncludeDirectories.size(); i != e && !NewBufOrErr;
49  ++i) {
50  IncludedFile =
51  IncludeDirectories[i] + sys::path::get_separator().data() + Filename;
52  NewBufOrErr = MemoryBuffer::getFile(IncludedFile);
53  }
54 
55  if (!NewBufOrErr)
56  return 0;
57 
58  return AddNewSourceBuffer(std::move(*NewBufOrErr), IncludeLoc);
59 }
60 
62  for (unsigned i = 0, e = Buffers.size(); i != e; ++i)
63  if (Loc.getPointer() >= Buffers[i].Buffer->getBufferStart() &&
64  // Use <= here so that a pointer to the null at the end of the buffer
65  // is included as part of the buffer.
66  Loc.getPointer() <= Buffers[i].Buffer->getBufferEnd())
67  return i + 1;
68  return 0;
69 }
70 
71 template <typename T>
72 unsigned SourceMgr::SrcBuffer::getLineNumber(const char *Ptr) const {
73 
74  // Ensure OffsetCache is allocated and populated with offsets of all the
75  // '\n' bytes.
76  std::vector<T> *Offsets = nullptr;
77  if (OffsetCache.isNull()) {
78  Offsets = new std::vector<T>();
79  OffsetCache = Offsets;
80  size_t Sz = Buffer->getBufferSize();
82  StringRef S = Buffer->getBuffer();
83  for (size_t N = 0; N < Sz; ++N) {
84  if (S[N] == '\n') {
85  Offsets->push_back(static_cast<T>(N));
86  }
87  }
88  } else {
89  Offsets = OffsetCache.get<std::vector<T> *>();
90  }
91 
92  const char *BufStart = Buffer->getBufferStart();
93  assert(Ptr >= BufStart && Ptr <= Buffer->getBufferEnd());
94  ptrdiff_t PtrDiff = Ptr - BufStart;
95  assert(PtrDiff >= 0 && static_cast<size_t>(PtrDiff) <= std::numeric_limits<T>::max());
96  T PtrOffset = static_cast<T>(PtrDiff);
97 
98  // std::lower_bound returns the first EOL offset that's not-less-than
99  // PtrOffset, meaning the EOL that _ends the line_ that PtrOffset is on
100  // (including if PtrOffset refers to the EOL itself). If there's no such
101  // EOL, returns end().
102  auto EOL = std::lower_bound(Offsets->begin(), Offsets->end(), PtrOffset);
103 
104  // Lines count from 1, so add 1 to the distance from the 0th line.
105  return (1 + (EOL - Offsets->begin()));
106 }
107 
108 SourceMgr::SrcBuffer::SrcBuffer(SourceMgr::SrcBuffer &&Other)
109  : Buffer(std::move(Other.Buffer)),
110  OffsetCache(Other.OffsetCache),
111  IncludeLoc(Other.IncludeLoc) {
112  Other.OffsetCache = nullptr;
113 }
114 
115 SourceMgr::SrcBuffer::~SrcBuffer() {
116  if (!OffsetCache.isNull()) {
117  if (OffsetCache.is<std::vector<uint8_t>*>())
118  delete OffsetCache.get<std::vector<uint8_t>*>();
119  else if (OffsetCache.is<std::vector<uint16_t>*>())
120  delete OffsetCache.get<std::vector<uint16_t>*>();
121  else if (OffsetCache.is<std::vector<uint32_t>*>())
122  delete OffsetCache.get<std::vector<uint32_t>*>();
123  else
124  delete OffsetCache.get<std::vector<uint64_t>*>();
125  OffsetCache = nullptr;
126  }
127 }
128 
129 std::pair<unsigned, unsigned>
130 SourceMgr::getLineAndColumn(SMLoc Loc, unsigned BufferID) const {
131  if (!BufferID)
132  BufferID = FindBufferContainingLoc(Loc);
133  assert(BufferID && "Invalid Location!");
134 
135  auto &SB = getBufferInfo(BufferID);
136  const char *Ptr = Loc.getPointer();
137 
138  size_t Sz = SB.Buffer->getBufferSize();
140  unsigned LineNo;
142  LineNo = SB.getLineNumber<uint8_t>(Ptr);
143  else if (Sz <= std::numeric_limits<uint16_t>::max())
144  LineNo = SB.getLineNumber<uint16_t>(Ptr);
145  else if (Sz <= std::numeric_limits<uint32_t>::max())
146  LineNo = SB.getLineNumber<uint32_t>(Ptr);
147  else
148  LineNo = SB.getLineNumber<uint64_t>(Ptr);
149 
150  const char *BufStart = SB.Buffer->getBufferStart();
151  size_t NewlineOffs = StringRef(BufStart, Ptr-BufStart).find_last_of("\n\r");
152  if (NewlineOffs == StringRef::npos) NewlineOffs = ~(size_t)0;
153  return std::make_pair(LineNo, Ptr-BufStart-NewlineOffs);
154 }
155 
156 void SourceMgr::PrintIncludeStack(SMLoc IncludeLoc, raw_ostream &OS) const {
157  if (IncludeLoc == SMLoc()) return; // Top of stack.
158 
159  unsigned CurBuf = FindBufferContainingLoc(IncludeLoc);
160  assert(CurBuf && "Invalid or unspecified location!");
161 
162  PrintIncludeStack(getBufferInfo(CurBuf).IncludeLoc, OS);
163 
164  OS << "Included from "
165  << getBufferInfo(CurBuf).Buffer->getBufferIdentifier()
166  << ":" << FindLineNumber(IncludeLoc, CurBuf) << ":\n";
167 }
168 
170  const Twine &Msg,
171  ArrayRef<SMRange> Ranges,
172  ArrayRef<SMFixIt> FixIts) const {
173  // First thing to do: find the current buffer containing the specified
174  // location to pull out the source line.
176  std::pair<unsigned, unsigned> LineAndCol;
177  StringRef BufferID = "<unknown>";
178  std::string LineStr;
179 
180  if (Loc.isValid()) {
181  unsigned CurBuf = FindBufferContainingLoc(Loc);
182  assert(CurBuf && "Invalid or unspecified location!");
183 
184  const MemoryBuffer *CurMB = getMemoryBuffer(CurBuf);
185  BufferID = CurMB->getBufferIdentifier();
186 
187  // Scan backward to find the start of the line.
188  const char *LineStart = Loc.getPointer();
189  const char *BufStart = CurMB->getBufferStart();
190  while (LineStart != BufStart && LineStart[-1] != '\n' &&
191  LineStart[-1] != '\r')
192  --LineStart;
193 
194  // Get the end of the line.
195  const char *LineEnd = Loc.getPointer();
196  const char *BufEnd = CurMB->getBufferEnd();
197  while (LineEnd != BufEnd && LineEnd[0] != '\n' && LineEnd[0] != '\r')
198  ++LineEnd;
199  LineStr = std::string(LineStart, LineEnd);
200 
201  // Convert any ranges to column ranges that only intersect the line of the
202  // location.
203  for (unsigned i = 0, e = Ranges.size(); i != e; ++i) {
204  SMRange R = Ranges[i];
205  if (!R.isValid()) continue;
206 
207  // If the line doesn't contain any part of the range, then ignore it.
208  if (R.Start.getPointer() > LineEnd || R.End.getPointer() < LineStart)
209  continue;
210 
211  // Ignore pieces of the range that go onto other lines.
212  if (R.Start.getPointer() < LineStart)
213  R.Start = SMLoc::getFromPointer(LineStart);
214  if (R.End.getPointer() > LineEnd)
215  R.End = SMLoc::getFromPointer(LineEnd);
216 
217  // Translate from SMLoc ranges to column ranges.
218  // FIXME: Handle multibyte characters.
219  ColRanges.push_back(std::make_pair(R.Start.getPointer()-LineStart,
220  R.End.getPointer()-LineStart));
221  }
222 
223  LineAndCol = getLineAndColumn(Loc, CurBuf);
224  }
225 
226  return SMDiagnostic(*this, Loc, BufferID, LineAndCol.first,
227  LineAndCol.second-1, Kind, Msg.str(),
228  LineStr, ColRanges, FixIts);
229 }
230 
232  bool ShowColors) const {
233  // Report the message with the diagnostic handler if present.
234  if (DiagHandler) {
235  DiagHandler(Diagnostic, DiagContext);
236  return;
237  }
238 
239  if (Diagnostic.getLoc().isValid()) {
240  unsigned CurBuf = FindBufferContainingLoc(Diagnostic.getLoc());
241  assert(CurBuf && "Invalid or unspecified location!");
242  PrintIncludeStack(getBufferInfo(CurBuf).IncludeLoc, OS);
243  }
244 
245  Diagnostic.print(nullptr, OS, ShowColors);
246 }
247 
250  const Twine &Msg, ArrayRef<SMRange> Ranges,
251  ArrayRef<SMFixIt> FixIts, bool ShowColors) const {
252  PrintMessage(OS, GetMessage(Loc, Kind, Msg, Ranges, FixIts), ShowColors);
253 }
254 
256  const Twine &Msg, ArrayRef<SMRange> Ranges,
257  ArrayRef<SMFixIt> FixIts, bool ShowColors) const {
258  PrintMessage(errs(), Loc, Kind, Msg, Ranges, FixIts, ShowColors);
259 }
260 
261 //===----------------------------------------------------------------------===//
262 // SMDiagnostic Implementation
263 //===----------------------------------------------------------------------===//
264 
266  int Line, int Col, SourceMgr::DiagKind Kind,
267  StringRef Msg, StringRef LineStr,
268  ArrayRef<std::pair<unsigned,unsigned>> Ranges,
269  ArrayRef<SMFixIt> Hints)
270  : SM(&sm), Loc(L), Filename(FN), LineNo(Line), ColumnNo(Col), Kind(Kind),
271  Message(Msg), LineContents(LineStr), Ranges(Ranges.vec()),
272  FixIts(Hints.begin(), Hints.end()) {
273  llvm::sort(FixIts.begin(), FixIts.end());
274 }
275 
276 static void buildFixItLine(std::string &CaretLine, std::string &FixItLine,
277  ArrayRef<SMFixIt> FixIts, ArrayRef<char> SourceLine){
278  if (FixIts.empty())
279  return;
280 
281  const char *LineStart = SourceLine.begin();
282  const char *LineEnd = SourceLine.end();
283 
284  size_t PrevHintEndCol = 0;
285 
286  for (ArrayRef<SMFixIt>::iterator I = FixIts.begin(), E = FixIts.end();
287  I != E; ++I) {
288  // If the fixit contains a newline or tab, ignore it.
289  if (I->getText().find_first_of("\n\r\t") != StringRef::npos)
290  continue;
291 
292  SMRange R = I->getRange();
293 
294  // If the line doesn't contain any part of the range, then ignore it.
295  if (R.Start.getPointer() > LineEnd || R.End.getPointer() < LineStart)
296  continue;
297 
298  // Translate from SMLoc to column.
299  // Ignore pieces of the range that go onto other lines.
300  // FIXME: Handle multibyte characters in the source line.
301  unsigned FirstCol;
302  if (R.Start.getPointer() < LineStart)
303  FirstCol = 0;
304  else
305  FirstCol = R.Start.getPointer() - LineStart;
306 
307  // If we inserted a long previous hint, push this one forwards, and add
308  // an extra space to show that this is not part of the previous
309  // completion. This is sort of the best we can do when two hints appear
310  // to overlap.
311  //
312  // Note that if this hint is located immediately after the previous
313  // hint, no space will be added, since the location is more important.
314  unsigned HintCol = FirstCol;
315  if (HintCol < PrevHintEndCol)
316  HintCol = PrevHintEndCol + 1;
317 
318  // FIXME: This assertion is intended to catch unintended use of multibyte
319  // characters in fixits. If we decide to do this, we'll have to track
320  // separate byte widths for the source and fixit lines.
321  assert((size_t)sys::locale::columnWidth(I->getText()) ==
322  I->getText().size());
323 
324  // This relies on one byte per column in our fixit hints.
325  unsigned LastColumnModified = HintCol + I->getText().size();
326  if (LastColumnModified > FixItLine.size())
327  FixItLine.resize(LastColumnModified, ' ');
328 
329  std::copy(I->getText().begin(), I->getText().end(),
330  FixItLine.begin() + HintCol);
331 
332  PrevHintEndCol = LastColumnModified;
333 
334  // For replacements, mark the removal range with '~'.
335  // FIXME: Handle multibyte characters in the source line.
336  unsigned LastCol;
337  if (R.End.getPointer() >= LineEnd)
338  LastCol = LineEnd - LineStart;
339  else
340  LastCol = R.End.getPointer() - LineStart;
341 
342  std::fill(&CaretLine[FirstCol], &CaretLine[LastCol], '~');
343  }
344 }
345 
346 static void printSourceLine(raw_ostream &S, StringRef LineContents) {
347  // Print out the source line one character at a time, so we can expand tabs.
348  for (unsigned i = 0, e = LineContents.size(), OutCol = 0; i != e; ++i) {
349  if (LineContents[i] != '\t') {
350  S << LineContents[i];
351  ++OutCol;
352  continue;
353  }
354 
355  // If we have a tab, emit at least one space, then round up to 8 columns.
356  do {
357  S << ' ';
358  ++OutCol;
359  } while ((OutCol % TabStop) != 0);
360  }
361  S << '\n';
362 }
363 
364 static bool isNonASCII(char c) {
365  return c & 0x80;
366 }
367 
368 void SMDiagnostic::print(const char *ProgName, raw_ostream &S, bool ShowColors,
369  bool ShowKindLabel) const {
370  // Display colors only if OS supports colors.
371  ShowColors &= S.has_colors();
372 
373  if (ShowColors)
375 
376  if (ProgName && ProgName[0])
377  S << ProgName << ": ";
378 
379  if (!Filename.empty()) {
380  if (Filename == "-")
381  S << "<stdin>";
382  else
383  S << Filename;
384 
385  if (LineNo != -1) {
386  S << ':' << LineNo;
387  if (ColumnNo != -1)
388  S << ':' << (ColumnNo+1);
389  }
390  S << ": ";
391  }
392 
393  if (ShowKindLabel) {
394  switch (Kind) {
395  case SourceMgr::DK_Error:
396  if (ShowColors)
397  S.changeColor(raw_ostream::RED, true);
398  S << "error: ";
399  break;
401  if (ShowColors)
403  S << "warning: ";
404  break;
405  case SourceMgr::DK_Note:
406  if (ShowColors)
408  S << "note: ";
409  break;
411  if (ShowColors)
413  S << "remark: ";
414  break;
415  }
416 
417  if (ShowColors) {
418  S.resetColor();
420  }
421  }
422 
423  S << Message << '\n';
424 
425  if (ShowColors)
426  S.resetColor();
427 
428  if (LineNo == -1 || ColumnNo == -1)
429  return;
430 
431  // FIXME: If there are multibyte or multi-column characters in the source, all
432  // our ranges will be wrong. To do this properly, we'll need a byte-to-column
433  // map like Clang's TextDiagnostic. For now, we'll just handle tabs by
434  // expanding them later, and bail out rather than show incorrect ranges and
435  // misaligned fixits for any other odd characters.
436  if (find_if(LineContents, isNonASCII) != LineContents.end()) {
437  printSourceLine(S, LineContents);
438  return;
439  }
440  size_t NumColumns = LineContents.size();
441 
442  // Build the line with the caret and ranges.
443  std::string CaretLine(NumColumns+1, ' ');
444 
445  // Expand any ranges.
446  for (unsigned r = 0, e = Ranges.size(); r != e; ++r) {
447  std::pair<unsigned, unsigned> R = Ranges[r];
448  std::fill(&CaretLine[R.first],
449  &CaretLine[std::min((size_t)R.second, CaretLine.size())],
450  '~');
451  }
452 
453  // Add any fix-its.
454  // FIXME: Find the beginning of the line properly for multibyte characters.
455  std::string FixItInsertionLine;
456  buildFixItLine(CaretLine, FixItInsertionLine, FixIts,
457  makeArrayRef(Loc.getPointer() - ColumnNo,
458  LineContents.size()));
459 
460  // Finally, plop on the caret.
461  if (unsigned(ColumnNo) <= NumColumns)
462  CaretLine[ColumnNo] = '^';
463  else
464  CaretLine[NumColumns] = '^';
465 
466  // ... and remove trailing whitespace so the output doesn't wrap for it. We
467  // know that the line isn't completely empty because it has the caret in it at
468  // least.
469  CaretLine.erase(CaretLine.find_last_not_of(' ')+1);
470 
471  printSourceLine(S, LineContents);
472 
473  if (ShowColors)
475 
476  // Print out the caret line, matching tabs in the source line.
477  for (unsigned i = 0, e = CaretLine.size(), OutCol = 0; i != e; ++i) {
478  if (i >= LineContents.size() || LineContents[i] != '\t') {
479  S << CaretLine[i];
480  ++OutCol;
481  continue;
482  }
483 
484  // Okay, we have a tab. Insert the appropriate number of characters.
485  do {
486  S << CaretLine[i];
487  ++OutCol;
488  } while ((OutCol % TabStop) != 0);
489  }
490  S << '\n';
491 
492  if (ShowColors)
493  S.resetColor();
494 
495  // Print out the replacement line, matching tabs in the source line.
496  if (FixItInsertionLine.empty())
497  return;
498 
499  for (size_t i = 0, e = FixItInsertionLine.size(), OutCol = 0; i < e; ++i) {
500  if (i >= LineContents.size() || LineContents[i] != '\t') {
501  S << FixItInsertionLine[i];
502  ++OutCol;
503  continue;
504  }
505 
506  // Okay, we have a tab. Insert the appropriate number of characters.
507  do {
508  S << FixItInsertionLine[i];
509  // FIXME: This is trying not to break up replacements, but then to re-sync
510  // with the tabs between replacements. This will fail, though, if two
511  // fix-it replacements are exactly adjacent, or if a fix-it contains a
512  // space. Really we should be precomputing column widths, which we'll
513  // need anyway for multibyte chars.
514  if (FixItInsertionLine[i] != ' ')
515  ++i;
516  ++OutCol;
517  } while (((OutCol % TabStop) != 0) && i != e);
518  }
519  S << '\n';
520 }
virtual StringRef getBufferIdentifier() const
Return an identifier for this buffer, typically the filename it was read from.
Definition: MemoryBuffer.h:71
Represents a range in source code.
Definition: SMLoc.h:49
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:250
Represents either an error or a value T.
Definition: ErrorOr.h:69
unsigned FindBufferContainingLoc(SMLoc Loc) const
Return the ID of the buffer containing the specified location.
Definition: SourceMgr.cpp:61
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:241
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
SMLoc getLoc() const
Definition: SourceMgr.h:286
void print(const char *ProgName, raw_ostream &S, bool ShowColors=true, bool ShowKindLabel=true) const
Definition: SourceMgr.cpp:368
iterator begin() const
Definition: ArrayRef.h:137
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
virtual raw_ostream & changeColor(enum Colors Color, bool Bold=false, bool BG=false)
Changes the foreground color of text that will be output from this point forward. ...
Definition: raw_ostream.h:257
void PrintIncludeStack(SMLoc IncludeLoc, raw_ostream &OS) const
Prints the names of included files and the line of the file they were included from.
Definition: SourceMgr.cpp:156
Offsets
Offsets in bytes from the start of the input buffer.
Definition: SIInstrInfo.h:940
LLVM_NODISCARD size_t find_last_of(char C, size_t From=npos) const
Find the last character in the string that is C, or npos if not found.
Definition: StringRef.h:421
std::pair< unsigned, unsigned > getLineAndColumn(SMLoc Loc, unsigned BufferID=0) const
Find the line and column number for the specified location in the specified file. ...
Definition: SourceMgr.cpp:130
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
SMLoc Start
Definition: SMLoc.h:51
SMDiagnostic()=default
void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges=None, ArrayRef< SMFixIt > FixIts=None, bool ShowColors=true) const
Emit a message about the specified location with the specified string.
Definition: SourceMgr.cpp:248
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:772
const MemoryBuffer * getMemoryBuffer(unsigned i) const
Definition: SourceMgr.h:131
static const size_t TabStop
Definition: SourceMgr.cpp:38
unsigned AddNewSourceBuffer(std::unique_ptr< MemoryBuffer > F, SMLoc IncludeLoc)
Add a new source buffer to this source manager.
Definition: SourceMgr.h:152
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
auto lower_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range))
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1004
int columnWidth(StringRef s)
Definition: Locale.cpp:9
const char * getPointer() const
Definition: SMLoc.h:35
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
auto find_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range))
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:936
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling...
Definition: SourceMgr.h:42
virtual bool has_colors() const
This function determines if this stream is displayed and supports colors.
Definition: raw_ostream.h:279
StringRef get_separator(Style style=Style::native)
Return the preferred separator for this platform.
Definition: Path.cpp:617
SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges=None, ArrayRef< SMFixIt > FixIts=None) const
Return an SMDiagnostic at the specified location with the specified string.
Definition: SourceMgr.cpp:169
const SrcBuffer & getBufferInfo(unsigned i) const
Definition: SourceMgr.h:126
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:859
bool isValid() const
Definition: SMLoc.h:60
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
iterator end() const
Definition: ArrayRef.h:138
static void printSourceLine(raw_ostream &S, StringRef LineContents)
Definition: SourceMgr.cpp:346
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:42
bool isValid() const
Definition: SMLoc.h:30
SMLoc End
Definition: SMLoc.h:51
unsigned FindLineNumber(SMLoc Loc, unsigned BufferID=0) const
Find the line number for the specified location in the specified file.
Definition: SourceMgr.h:177
static bool isNonASCII(char c)
Definition: SourceMgr.cpp:364
static SMLoc getFromPointer(const char *Ptr)
Definition: SMLoc.h:37
unsigned AddIncludeFile(const std::string &Filename, SMLoc IncludeLoc, std::string &IncludedFile)
Search for a file with the specified name in the current directory or in one of the IncludeDirs...
Definition: SourceMgr.cpp:40
const char * getBufferEnd() const
Definition: MemoryBuffer.h:62
static const size_t npos
Definition: StringRef.h:51
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
static void buildFixItLine(std::string &CaretLine, std::string &FixItLine, ArrayRef< SMFixIt > FixIts, ArrayRef< char > SourceLine)
Definition: SourceMgr.cpp:276
const char * getBufferStart() const
Definition: MemoryBuffer.h:61
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:18
Provides ErrorOr<T> smart pointer.
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
const unsigned Kind
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
virtual raw_ostream & resetColor()
Resets the colors to terminal defaults.
Definition: raw_ostream.h:268
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Represents a location in source code.
Definition: SMLoc.h:24
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:960
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:260