LLVM  14.0.0git
SourceMgr.cpp
Go to the documentation of this file.
1 //===- SourceMgr.cpp - Manager for Simple Source Buffers & Diagnostics ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the SourceMgr class. This class is used as a simple
10 // substrate for diagnostics, #include handling, and other low level things for
11 // simple parsers.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/Support/SourceMgr.h"
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/ADT/Twine.h"
21 #include "llvm/Support/ErrorOr.h"
22 #include "llvm/Support/Locale.h"
24 #include "llvm/Support/Path.h"
25 #include "llvm/Support/SMLoc.h"
26 #include "llvm/Support/WithColor.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 static std::vector<T> &GetOrCreateOffsetCache(void *&OffsetCache,
73  MemoryBuffer *Buffer) {
74  if (OffsetCache)
75  return *static_cast<std::vector<T> *>(OffsetCache);
76 
77  // Lazily fill in the offset cache.
78  auto *Offsets = new std::vector<T>();
79  size_t Sz = Buffer->getBufferSize();
81  StringRef S = Buffer->getBuffer();
82  for (size_t N = 0; N < Sz; ++N) {
83  if (S[N] == '\n')
84  Offsets->push_back(static_cast<T>(N));
85  }
86 
87  OffsetCache = Offsets;
88  return *Offsets;
89 }
90 
91 template <typename T>
92 unsigned SourceMgr::SrcBuffer::getLineNumberSpecialized(const char *Ptr) const {
93  std::vector<T> &Offsets =
94  GetOrCreateOffsetCache<T>(OffsetCache, Buffer.get());
95 
96  const char *BufStart = Buffer->getBufferStart();
97  assert(Ptr >= BufStart && Ptr <= Buffer->getBufferEnd());
98  ptrdiff_t PtrDiff = Ptr - BufStart;
99  assert(PtrDiff >= 0 &&
100  static_cast<size_t>(PtrDiff) <= std::numeric_limits<T>::max());
101  T PtrOffset = static_cast<T>(PtrDiff);
102 
103  // llvm::lower_bound gives the number of EOL before PtrOffset. Add 1 to get
104  // the line number.
105  return llvm::lower_bound(Offsets, PtrOffset) - Offsets.begin() + 1;
106 }
107 
108 /// Look up a given \p Ptr in in the buffer, determining which line it came
109 /// from.
110 unsigned SourceMgr::SrcBuffer::getLineNumber(const char *Ptr) const {
111  size_t Sz = Buffer->getBufferSize();
113  return getLineNumberSpecialized<uint8_t>(Ptr);
114  else if (Sz <= std::numeric_limits<uint16_t>::max())
115  return getLineNumberSpecialized<uint16_t>(Ptr);
116  else if (Sz <= std::numeric_limits<uint32_t>::max())
117  return getLineNumberSpecialized<uint32_t>(Ptr);
118  else
119  return getLineNumberSpecialized<uint64_t>(Ptr);
120 }
121 
122 template <typename T>
123 const char *SourceMgr::SrcBuffer::getPointerForLineNumberSpecialized(
124  unsigned LineNo) const {
125  std::vector<T> &Offsets =
126  GetOrCreateOffsetCache<T>(OffsetCache, Buffer.get());
127 
128  // We start counting line and column numbers from 1.
129  if (LineNo != 0)
130  --LineNo;
131 
132  const char *BufStart = Buffer->getBufferStart();
133 
134  // The offset cache contains the location of the \n for the specified line,
135  // we want the start of the line. As such, we look for the previous entry.
136  if (LineNo == 0)
137  return BufStart;
138  if (LineNo > Offsets.size())
139  return nullptr;
140  return BufStart + Offsets[LineNo - 1] + 1;
141 }
142 
143 /// Return a pointer to the first character of the specified line number or
144 /// null if the line number is invalid.
145 const char *
146 SourceMgr::SrcBuffer::getPointerForLineNumber(unsigned LineNo) const {
147  size_t Sz = Buffer->getBufferSize();
149  return getPointerForLineNumberSpecialized<uint8_t>(LineNo);
150  else if (Sz <= std::numeric_limits<uint16_t>::max())
151  return getPointerForLineNumberSpecialized<uint16_t>(LineNo);
152  else if (Sz <= std::numeric_limits<uint32_t>::max())
153  return getPointerForLineNumberSpecialized<uint32_t>(LineNo);
154  else
155  return getPointerForLineNumberSpecialized<uint64_t>(LineNo);
156 }
157 
158 SourceMgr::SrcBuffer::SrcBuffer(SourceMgr::SrcBuffer &&Other)
159  : Buffer(std::move(Other.Buffer)), OffsetCache(Other.OffsetCache),
160  IncludeLoc(Other.IncludeLoc) {
161  Other.OffsetCache = nullptr;
162 }
163 
164 SourceMgr::SrcBuffer::~SrcBuffer() {
165  if (OffsetCache) {
166  size_t Sz = Buffer->getBufferSize();
168  delete static_cast<std::vector<uint8_t> *>(OffsetCache);
169  else if (Sz <= std::numeric_limits<uint16_t>::max())
170  delete static_cast<std::vector<uint16_t> *>(OffsetCache);
171  else if (Sz <= std::numeric_limits<uint32_t>::max())
172  delete static_cast<std::vector<uint32_t> *>(OffsetCache);
173  else
174  delete static_cast<std::vector<uint64_t> *>(OffsetCache);
175  OffsetCache = nullptr;
176  }
177 }
178 
179 std::pair<unsigned, unsigned>
180 SourceMgr::getLineAndColumn(SMLoc Loc, unsigned BufferID) const {
181  if (!BufferID)
182  BufferID = FindBufferContainingLoc(Loc);
183  assert(BufferID && "Invalid location!");
184 
185  auto &SB = getBufferInfo(BufferID);
186  const char *Ptr = Loc.getPointer();
187 
188  unsigned LineNo = SB.getLineNumber(Ptr);
189  const char *BufStart = SB.Buffer->getBufferStart();
190  size_t NewlineOffs = StringRef(BufStart, Ptr - BufStart).find_last_of("\n\r");
191  if (NewlineOffs == StringRef::npos)
192  NewlineOffs = ~(size_t)0;
193  return std::make_pair(LineNo, Ptr - BufStart - NewlineOffs);
194 }
195 
196 // FIXME: Note that the formatting of source locations is spread between
197 // multiple functions, some in SourceMgr and some in SMDiagnostic. A better
198 // solution would be a general-purpose source location formatter
199 // in one of those two classes, or possibly in SMLoc.
200 
201 /// Get a string with the source location formatted in the standard
202 /// style, but without the line offset. If \p IncludePath is true, the path
203 /// is included. If false, only the file name and extension are included.
205  bool IncludePath) const {
206  auto BufferID = FindBufferContainingLoc(Loc);
207  assert(BufferID && "Invalid location!");
208  auto FileSpec = getBufferInfo(BufferID).Buffer->getBufferIdentifier();
209 
210  if (IncludePath) {
211  return FileSpec.str() + ":" + std::to_string(FindLineNumber(Loc, BufferID));
212  } else {
213  auto I = FileSpec.find_last_of("/\\");
214  I = (I == FileSpec.size()) ? 0 : (I + 1);
215  return FileSpec.substr(I).str() + ":" +
216  std::to_string(FindLineNumber(Loc, BufferID));
217  }
218 }
219 
220 /// Given a line and column number in a mapped buffer, turn it into an SMLoc.
221 /// This will return a null SMLoc if the line/column location is invalid.
222 SMLoc SourceMgr::FindLocForLineAndColumn(unsigned BufferID, unsigned LineNo,
223  unsigned ColNo) {
224  auto &SB = getBufferInfo(BufferID);
225  const char *Ptr = SB.getPointerForLineNumber(LineNo);
226  if (!Ptr)
227  return SMLoc();
228 
229  // We start counting line and column numbers from 1.
230  if (ColNo != 0)
231  --ColNo;
232 
233  // If we have a column number, validate it.
234  if (ColNo) {
235  // Make sure the location is within the current line.
236  if (Ptr + ColNo > SB.Buffer->getBufferEnd())
237  return SMLoc();
238 
239  // Make sure there is no newline in the way.
240  if (StringRef(Ptr, ColNo).find_first_of("\n\r") != StringRef::npos)
241  return SMLoc();
242 
243  Ptr += ColNo;
244  }
245 
246  return SMLoc::getFromPointer(Ptr);
247 }
248 
249 void SourceMgr::PrintIncludeStack(SMLoc IncludeLoc, raw_ostream &OS) const {
250  if (IncludeLoc == SMLoc())
251  return; // Top of stack.
252 
253  unsigned CurBuf = FindBufferContainingLoc(IncludeLoc);
254  assert(CurBuf && "Invalid or unspecified location!");
255 
256  PrintIncludeStack(getBufferInfo(CurBuf).IncludeLoc, OS);
257 
258  OS << "Included from " << getBufferInfo(CurBuf).Buffer->getBufferIdentifier()
259  << ":" << FindLineNumber(IncludeLoc, CurBuf) << ":\n";
260 }
261 
263  const Twine &Msg, ArrayRef<SMRange> Ranges,
264  ArrayRef<SMFixIt> FixIts) const {
265  // First thing to do: find the current buffer containing the specified
266  // location to pull out the source line.
268  std::pair<unsigned, unsigned> LineAndCol;
269  StringRef BufferID = "<unknown>";
270  StringRef LineStr;
271 
272  if (Loc.isValid()) {
273  unsigned CurBuf = FindBufferContainingLoc(Loc);
274  assert(CurBuf && "Invalid or unspecified location!");
275 
276  const MemoryBuffer *CurMB = getMemoryBuffer(CurBuf);
277  BufferID = CurMB->getBufferIdentifier();
278 
279  // Scan backward to find the start of the line.
280  const char *LineStart = Loc.getPointer();
281  const char *BufStart = CurMB->getBufferStart();
282  while (LineStart != BufStart && LineStart[-1] != '\n' &&
283  LineStart[-1] != '\r')
284  --LineStart;
285 
286  // Get the end of the line.
287  const char *LineEnd = Loc.getPointer();
288  const char *BufEnd = CurMB->getBufferEnd();
289  while (LineEnd != BufEnd && LineEnd[0] != '\n' && LineEnd[0] != '\r')
290  ++LineEnd;
291  LineStr = StringRef(LineStart, LineEnd - LineStart);
292 
293  // Convert any ranges to column ranges that only intersect the line of the
294  // location.
295  for (SMRange R : Ranges) {
296  if (!R.isValid())
297  continue;
298 
299  // If the line doesn't contain any part of the range, then ignore it.
300  if (R.Start.getPointer() > LineEnd || R.End.getPointer() < LineStart)
301  continue;
302 
303  // Ignore pieces of the range that go onto other lines.
304  if (R.Start.getPointer() < LineStart)
305  R.Start = SMLoc::getFromPointer(LineStart);
306  if (R.End.getPointer() > LineEnd)
307  R.End = SMLoc::getFromPointer(LineEnd);
308 
309  // Translate from SMLoc ranges to column ranges.
310  // FIXME: Handle multibyte characters.
311  ColRanges.push_back(std::make_pair(R.Start.getPointer() - LineStart,
312  R.End.getPointer() - LineStart));
313  }
314 
315  LineAndCol = getLineAndColumn(Loc, CurBuf);
316  }
317 
318  return SMDiagnostic(*this, Loc, BufferID, LineAndCol.first,
319  LineAndCol.second - 1, Kind, Msg.str(), LineStr,
320  ColRanges, FixIts);
321 }
322 
324  bool ShowColors) const {
325  // Report the message with the diagnostic handler if present.
326  if (DiagHandler) {
327  DiagHandler(Diagnostic, DiagContext);
328  return;
329  }
330 
331  if (Diagnostic.getLoc().isValid()) {
332  unsigned CurBuf = FindBufferContainingLoc(Diagnostic.getLoc());
333  assert(CurBuf && "Invalid or unspecified location!");
334  PrintIncludeStack(getBufferInfo(CurBuf).IncludeLoc, OS);
335  }
336 
337  Diagnostic.print(nullptr, OS, ShowColors);
338 }
339 
341  SourceMgr::DiagKind Kind, const Twine &Msg,
342  ArrayRef<SMRange> Ranges, ArrayRef<SMFixIt> FixIts,
343  bool ShowColors) const {
344  PrintMessage(OS, GetMessage(Loc, Kind, Msg, Ranges, FixIts), ShowColors);
345 }
346 
348  const Twine &Msg, ArrayRef<SMRange> Ranges,
349  ArrayRef<SMFixIt> FixIts, bool ShowColors) const {
350  PrintMessage(errs(), Loc, Kind, Msg, Ranges, FixIts, ShowColors);
351 }
352 
353 //===----------------------------------------------------------------------===//
354 // SMFixIt Implementation
355 //===----------------------------------------------------------------------===//
356 
357 SMFixIt::SMFixIt(SMRange R, const Twine &Replacement)
358  : Range(R), Text(Replacement.str()) {
359  assert(R.isValid());
360 }
361 
362 //===----------------------------------------------------------------------===//
363 // SMDiagnostic Implementation
364 //===----------------------------------------------------------------------===//
365 
367  int Col, SourceMgr::DiagKind Kind, StringRef Msg,
368  StringRef LineStr,
369  ArrayRef<std::pair<unsigned, unsigned>> Ranges,
370  ArrayRef<SMFixIt> Hints)
371  : SM(&sm), Loc(L), Filename(std::string(FN)), LineNo(Line), ColumnNo(Col),
372  Kind(Kind), Message(Msg), LineContents(LineStr), Ranges(Ranges.vec()),
373  FixIts(Hints.begin(), Hints.end()) {
374  llvm::sort(FixIts);
375 }
376 
377 static void buildFixItLine(std::string &CaretLine, std::string &FixItLine,
378  ArrayRef<SMFixIt> FixIts,
379  ArrayRef<char> SourceLine) {
380  if (FixIts.empty())
381  return;
382 
383  const char *LineStart = SourceLine.begin();
384  const char *LineEnd = SourceLine.end();
385 
386  size_t PrevHintEndCol = 0;
387 
388  for (const llvm::SMFixIt &Fixit : FixIts) {
389  // If the fixit contains a newline or tab, ignore it.
390  if (Fixit.getText().find_first_of("\n\r\t") != StringRef::npos)
391  continue;
392 
393  SMRange R = Fixit.getRange();
394 
395  // If the line doesn't contain any part of the range, then ignore it.
396  if (R.Start.getPointer() > LineEnd || R.End.getPointer() < LineStart)
397  continue;
398 
399  // Translate from SMLoc to column.
400  // Ignore pieces of the range that go onto other lines.
401  // FIXME: Handle multibyte characters in the source line.
402  unsigned FirstCol;
403  if (R.Start.getPointer() < LineStart)
404  FirstCol = 0;
405  else
406  FirstCol = R.Start.getPointer() - LineStart;
407 
408  // If we inserted a long previous hint, push this one forwards, and add
409  // an extra space to show that this is not part of the previous
410  // completion. This is sort of the best we can do when two hints appear
411  // to overlap.
412  //
413  // Note that if this hint is located immediately after the previous
414  // hint, no space will be added, since the location is more important.
415  unsigned HintCol = FirstCol;
416  if (HintCol < PrevHintEndCol)
417  HintCol = PrevHintEndCol + 1;
418 
419  // FIXME: This assertion is intended to catch unintended use of multibyte
420  // characters in fixits. If we decide to do this, we'll have to track
421  // separate byte widths for the source and fixit lines.
422  assert((size_t)sys::locale::columnWidth(Fixit.getText()) ==
423  Fixit.getText().size());
424 
425  // This relies on one byte per column in our fixit hints.
426  unsigned LastColumnModified = HintCol + Fixit.getText().size();
427  if (LastColumnModified > FixItLine.size())
428  FixItLine.resize(LastColumnModified, ' ');
429 
430  llvm::copy(Fixit.getText(), FixItLine.begin() + HintCol);
431 
432  PrevHintEndCol = LastColumnModified;
433 
434  // For replacements, mark the removal range with '~'.
435  // FIXME: Handle multibyte characters in the source line.
436  unsigned LastCol;
437  if (R.End.getPointer() >= LineEnd)
438  LastCol = LineEnd - LineStart;
439  else
440  LastCol = R.End.getPointer() - LineStart;
441 
442  std::fill(&CaretLine[FirstCol], &CaretLine[LastCol], '~');
443  }
444 }
445 
446 static void printSourceLine(raw_ostream &S, StringRef LineContents) {
447  // Print out the source line one character at a time, so we can expand tabs.
448  for (unsigned i = 0, e = LineContents.size(), OutCol = 0; i != e; ++i) {
449  size_t NextTab = LineContents.find('\t', i);
450  // If there were no tabs left, print the rest, we are done.
451  if (NextTab == StringRef::npos) {
452  S << LineContents.drop_front(i);
453  break;
454  }
455 
456  // Otherwise, print from i to NextTab.
457  S << LineContents.slice(i, NextTab);
458  OutCol += NextTab - i;
459  i = NextTab;
460 
461  // If we have a tab, emit at least one space, then round up to 8 columns.
462  do {
463  S << ' ';
464  ++OutCol;
465  } while ((OutCol % TabStop) != 0);
466  }
467  S << '\n';
468 }
469 
470 static bool isNonASCII(char c) { return c & 0x80; }
471 
472 void SMDiagnostic::print(const char *ProgName, raw_ostream &OS, bool ShowColors,
473  bool ShowKindLabel) const {
475 
476  {
477  WithColor S(OS, raw_ostream::SAVEDCOLOR, true, false, Mode);
478 
479  if (ProgName && ProgName[0])
480  S << ProgName << ": ";
481 
482  if (!Filename.empty()) {
483  if (Filename == "-")
484  S << "<stdin>";
485  else
486  S << Filename;
487 
488  if (LineNo != -1) {
489  S << ':' << LineNo;
490  if (ColumnNo != -1)
491  S << ':' << (ColumnNo + 1);
492  }
493  S << ": ";
494  }
495  }
496 
497  if (ShowKindLabel) {
498  switch (Kind) {
499  case SourceMgr::DK_Error:
500  WithColor::error(OS, "", !ShowColors);
501  break;
503  WithColor::warning(OS, "", !ShowColors);
504  break;
505  case SourceMgr::DK_Note:
506  WithColor::note(OS, "", !ShowColors);
507  break;
509  WithColor::remark(OS, "", !ShowColors);
510  break;
511  }
512  }
513 
514  WithColor(OS, raw_ostream::SAVEDCOLOR, true, false, Mode) << Message << '\n';
515 
516  if (LineNo == -1 || ColumnNo == -1)
517  return;
518 
519  // FIXME: If there are multibyte or multi-column characters in the source, all
520  // our ranges will be wrong. To do this properly, we'll need a byte-to-column
521  // map like Clang's TextDiagnostic. For now, we'll just handle tabs by
522  // expanding them later, and bail out rather than show incorrect ranges and
523  // misaligned fixits for any other odd characters.
524  if (any_of(LineContents, isNonASCII)) {
525  printSourceLine(OS, LineContents);
526  return;
527  }
528  size_t NumColumns = LineContents.size();
529 
530  // Build the line with the caret and ranges.
531  std::string CaretLine(NumColumns + 1, ' ');
532 
533  // Expand any ranges.
534  for (const std::pair<unsigned, unsigned> &R : Ranges)
535  std::fill(&CaretLine[R.first],
536  &CaretLine[std::min((size_t)R.second, CaretLine.size())], '~');
537 
538  // Add any fix-its.
539  // FIXME: Find the beginning of the line properly for multibyte characters.
540  std::string FixItInsertionLine;
542  CaretLine, FixItInsertionLine, FixIts,
543  makeArrayRef(Loc.getPointer() - ColumnNo, LineContents.size()));
544 
545  // Finally, plop on the caret.
546  if (unsigned(ColumnNo) <= NumColumns)
547  CaretLine[ColumnNo] = '^';
548  else
549  CaretLine[NumColumns] = '^';
550 
551  // ... and remove trailing whitespace so the output doesn't wrap for it. We
552  // know that the line isn't completely empty because it has the caret in it at
553  // least.
554  CaretLine.erase(CaretLine.find_last_not_of(' ') + 1);
555 
556  printSourceLine(OS, LineContents);
557 
558  {
560  WithColor S(OS, raw_ostream::GREEN, true, false, Mode);
561 
562  // Print out the caret line, matching tabs in the source line.
563  for (unsigned i = 0, e = CaretLine.size(), OutCol = 0; i != e; ++i) {
564  if (i >= LineContents.size() || LineContents[i] != '\t') {
565  S << CaretLine[i];
566  ++OutCol;
567  continue;
568  }
569 
570  // Okay, we have a tab. Insert the appropriate number of characters.
571  do {
572  S << CaretLine[i];
573  ++OutCol;
574  } while ((OutCol % TabStop) != 0);
575  }
576  S << '\n';
577  }
578 
579  // Print out the replacement line, matching tabs in the source line.
580  if (FixItInsertionLine.empty())
581  return;
582 
583  for (size_t i = 0, e = FixItInsertionLine.size(), OutCol = 0; i < e; ++i) {
584  if (i >= LineContents.size() || LineContents[i] != '\t') {
585  OS << FixItInsertionLine[i];
586  ++OutCol;
587  continue;
588  }
589 
590  // Okay, we have a tab. Insert the appropriate number of characters.
591  do {
592  OS << FixItInsertionLine[i];
593  // FIXME: This is trying not to break up replacements, but then to re-sync
594  // with the tabs between replacements. This will fail, though, if two
595  // fix-it replacements are exactly adjacent, or if a fix-it contains a
596  // space. Really we should be precomputing column widths, which we'll
597  // need anyway for multibyte chars.
598  if (FixItInsertionLine[i] != ' ')
599  ++i;
600  ++OutCol;
601  } while (((OutCol % TabStop) != 0) && i != e);
602  }
603  OS << '\n';
604 }
i
i
Definition: README.txt:29
llvm::SMFixIt::SMFixIt
SMFixIt(SMRange R, const Twine &Replacement)
Definition: SourceMgr.cpp:357
MemoryBuffer.h
llvm::SMDiagnostic::SMDiagnostic
SMDiagnostic()=default
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
T
llvm::lower_bound
auto lower_bound(R &&Range, T &&Value)
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1759
StringRef.h
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:59
llvm::StringRef::find
LLVM_NODISCARD size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:314
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1177
Path.h
llvm::raw_ostream::GREEN
static constexpr Colors GREEN
Definition: raw_ostream.h:112
llvm::sys::path::end
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:236
llvm::sys::path::begin
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:227
llvm::copy
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1700
llvm::WithColor
An RAII object that temporarily switches an output stream to a specific color.
Definition: WithColor.h:53
llvm::sys::locale::columnWidth
int columnWidth(StringRef s)
Definition: Locale.cpp:9
llvm::SourceMgr::DK_Note
@ DK_Note
Definition: SourceMgr.h:37
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:894
STLExtras.h
llvm::StringRef::slice
LLVM_NODISCARD StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: StringRef.h:731
llvm::MemoryBuffer
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:50
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:158
llvm::SourceMgr::PrintIncludeStack
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:249
llvm::SourceMgr::DK_Remark
@ DK_Remark
Definition: SourceMgr.h:36
llvm::WithColor::remark
static raw_ostream & remark()
Convenience method for printing "remark: " to stderr.
Definition: WithColor.cpp:81
llvm::WithColor::error
static raw_ostream & error()
Convenience method for printing "error: " to stderr.
Definition: WithColor.cpp:75
llvm::MemoryBuffer::getFile
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
Definition: MemoryBuffer.cpp:237
llvm::SMFixIt
Represents a single fixit, a replacement of one range of text with another.
Definition: SourceMgr.h:226
llvm::StringRef::find_last_of
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:435
llvm::SMLoc
Represents a location in source code.
Definition: SMLoc.h:23
ptrdiff_t
llvm::MemoryBuffer::getBufferEnd
const char * getBufferEnd() const
Definition: MemoryBuffer.h:66
llvm::MemoryBuffer::getBufferSize
size_t getBufferSize() const
Definition: MemoryBuffer.h:67
Twine.h
llvm::SMDiagnostic
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:251
SMLoc.h
llvm::ColorMode::Auto
@ Auto
Determine whether to use color based on the command line argument and the raw_ostream.
llvm::ColorMode::Disable
@ Disable
Disable colors.
printSourceLine
static void printSourceLine(raw_ostream &S, StringRef LineContents)
Definition: SourceMgr.cpp:446
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::MemoryBuffer::getBuffer
StringRef getBuffer() const
Definition: MemoryBuffer.h:69
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
SourceMgr.h
llvm::SourceMgr::getMemoryBuffer
const MemoryBuffer * getMemoryBuffer(unsigned i) const
Definition: SourceMgr.h:122
llvm::Twine::str
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
llvm::MemoryBuffer::getBufferIdentifier
virtual StringRef getBufferIdentifier() const
Return an identifier for this buffer, typically the filename it was read from.
Definition: MemoryBuffer.h:75
isNonASCII
static bool isNonASCII(char c)
Definition: SourceMgr.cpp:470
llvm::WithColor::warning
static raw_ostream & warning()
Convenience method for printing "warning: " to stderr.
Definition: WithColor.cpp:77
llvm::SMDiagnostic::print
void print(const char *ProgName, raw_ostream &S, bool ShowColors=true, bool ShowKindLabel=true) const
Definition: SourceMgr.cpp:472
llvm::SMLoc::isValid
bool isValid() const
Definition: SMLoc.h:29
llvm::sys::path::get_separator
StringRef get_separator(Style style=Style::native)
Return the preferred separator for this platform.
Definition: Path.cpp:610
llvm::SourceMgr::PrintMessage
void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges={}, ArrayRef< SMFixIt > FixIts={}, bool ShowColors=true) const
Emit a message about the specified location with the specified string.
Definition: SourceMgr.cpp:340
llvm::SourceMgr::DK_Warning
@ DK_Warning
Definition: SourceMgr.h:35
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
ErrorOr.h
buildFixItLine
static void buildFixItLine(std::string &CaretLine, std::string &FixItLine, ArrayRef< SMFixIt > FixIts, ArrayRef< char > SourceLine)
Definition: SourceMgr.cpp:377
I
#define I(x, y, z)
Definition: MD5.cpp:58
ArrayRef.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1707
Mode
SI Whole Quad Mode
Definition: SIWholeQuadMode.cpp:262
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::SourceMgr::FindBufferContainingLoc
unsigned FindBufferContainingLoc(SMLoc Loc) const
Return the ID of the buffer containing the specified location.
Definition: SourceMgr.cpp:61
llvm::any_of
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1656
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::SourceMgr
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling.
Definition: SourceMgr.h:31
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
TabStop
static const size_t TabStop
Definition: SourceMgr.cpp:38
llvm::ColorMode
ColorMode
Definition: WithColor.h:39
llvm::StringRef::size
constexpr LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:156
llvm::SourceMgr::DiagKind
DiagKind
Definition: SourceMgr.h:33
WithColor.h
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::MemoryBuffer::getBufferStart
const char * getBufferStart() const
Definition: MemoryBuffer.h:65
std
Definition: BitVector.h:838
llvm::StringRef::drop_front
LLVM_NODISCARD StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
Definition: StringRef.h:652
llvm::SMLoc::getPointer
const char * getPointer() const
Definition: SMLoc.h:34
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:151
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1590
llvm::SourceMgr::DK_Error
@ DK_Error
Definition: SourceMgr.h:34
Locale.h
llvm::raw_ostream::SAVEDCOLOR
static constexpr Colors SAVEDCOLOR
Definition: raw_ostream.h:118
llvm::SourceMgr::AddNewSourceBuffer
unsigned AddNewSourceBuffer(std::unique_ptr< MemoryBuffer > F, SMLoc IncludeLoc)
Add a new source buffer to this source manager.
Definition: SourceMgr.h:141
llvm::SourceMgr::GetMessage
SMDiagnostic GetMessage(SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges={}, ArrayRef< SMFixIt > FixIts={}) const
Return an SMDiagnostic at the specified location with the specified string.
Definition: SourceMgr.cpp:262
llvm::SourceMgr::AddIncludeFile
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
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:474
SmallVector.h
llvm::SMRange
Represents a range in source code.
Definition: SMLoc.h:48
N
#define N
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::to_string
std::string to_string(const T &Value)
Definition: ScopedPrinter.h:87
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::StringRef::data
const LLVM_NODISCARD char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:148
llvm::SMLoc::getFromPointer
static SMLoc getFromPointer(const char *Ptr)
Definition: SMLoc.h:36
llvm::SourceMgr::getLineAndColumn
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:180
llvm::SourceMgr::FindLocForLineAndColumn
SMLoc FindLocForLineAndColumn(unsigned BufferID, unsigned LineNo, unsigned ColNo)
Given a line and column number in a mapped buffer, turn it into an SMLoc.
Definition: SourceMgr.cpp:222
llvm::WithColor::note
static raw_ostream & note()
Convenience method for printing "note: " to stderr.
Definition: WithColor.cpp:79
llvm::SMDiagnostic::getLoc
SMLoc getLoc() const
Definition: SourceMgr.h:276
raw_ostream.h
llvm::SI::KernelInputOffsets::Offsets
Offsets
Offsets in bytes from the start of the input buffer.
Definition: SIInstrInfo.h:1260
GetOrCreateOffsetCache
static std::vector< T > & GetOrCreateOffsetCache(void *&OffsetCache, MemoryBuffer *Buffer)
Definition: SourceMgr.cpp:72
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:152
llvm::SourceMgr::getBufferInfo
const SrcBuffer & getBufferInfo(unsigned i) const
Definition: SourceMgr.h:117
SpecialSubKind::string
@ string
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1198
llvm::SourceMgr::getFormattedLocationNoOffset
std::string getFormattedLocationNoOffset(SMLoc Loc, bool IncludePath=false) const
Get a string with the SMLoc filename and line number formatted in the standard style.
Definition: SourceMgr.cpp:204
llvm::SourceMgr::FindLineNumber
unsigned FindLineNumber(SMLoc Loc, unsigned BufferID=0) const
Find the line number for the specified location in the specified file.
Definition: SourceMgr.h:166