clang  6.0.0svn
SourceLocation.h
Go to the documentation of this file.
1 //===--- SourceLocation.h - Compact identifier for Source Files -*- C++ -*-===//
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 /// \file
11 /// \brief Defines the clang::SourceLocation class and associated facilities.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_BASIC_SOURCELOCATION_H
16 #define LLVM_CLANG_BASIC_SOURCELOCATION_H
17 
18 #include "clang/Basic/LLVM.h"
19 #include "llvm/Support/Compiler.h"
20 #include "llvm/Support/PointerLikeTypeTraits.h"
21 #include <cassert>
22 #include <functional>
23 #include <string>
24 #include <utility>
25 
26 namespace llvm {
27  class MemoryBuffer;
28  template <typename T> struct DenseMapInfo;
29  template <typename T> struct isPodLike;
30 }
31 
32 namespace clang {
33 
34 class SourceManager;
35 
36 /// \brief An opaque identifier used by SourceManager which refers to a
37 /// source file (MemoryBuffer) along with its \#include path and \#line data.
38 ///
39 class FileID {
40  /// \brief A mostly-opaque identifier, where 0 is "invalid", >0 is
41  /// this module, and <-1 is something loaded from another module.
42  int ID;
43 public:
44  FileID() : ID(0) {}
45 
46  bool isValid() const { return ID != 0; }
47  bool isInvalid() const { return ID == 0; }
48 
49  bool operator==(const FileID &RHS) const { return ID == RHS.ID; }
50  bool operator<(const FileID &RHS) const { return ID < RHS.ID; }
51  bool operator<=(const FileID &RHS) const { return ID <= RHS.ID; }
52  bool operator!=(const FileID &RHS) const { return !(*this == RHS); }
53  bool operator>(const FileID &RHS) const { return RHS < *this; }
54  bool operator>=(const FileID &RHS) const { return RHS <= *this; }
55 
56  static FileID getSentinel() { return get(-1); }
57  unsigned getHashValue() const { return static_cast<unsigned>(ID); }
58 
59 private:
60  friend class SourceManager;
61  friend class ASTWriter;
62  friend class ASTReader;
63 
64  static FileID get(int V) {
65  FileID F;
66  F.ID = V;
67  return F;
68  }
69  int getOpaqueValue() const { return ID; }
70 };
71 
72 
73 /// \brief Encodes a location in the source. The SourceManager can decode this
74 /// to get at the full include stack, line and column information.
75 ///
76 /// Technically, a source location is simply an offset into the manager's view
77 /// of the input source, which is all input buffers (including macro
78 /// expansions) concatenated in an effectively arbitrary order. The manager
79 /// actually maintains two blocks of input buffers. One, starting at offset
80 /// 0 and growing upwards, contains all buffers from this module. The other,
81 /// starting at the highest possible offset and growing downwards, contains
82 /// buffers of loaded modules.
83 ///
84 /// In addition, one bit of SourceLocation is used for quick access to the
85 /// information whether the location is in a file or a macro expansion.
86 ///
87 /// It is important that this type remains small. It is currently 32 bits wide.
89  unsigned ID;
90  friend class SourceManager;
91  friend class ASTReader;
92  friend class ASTWriter;
93  enum : unsigned {
94  MacroIDBit = 1U << 31
95  };
96 public:
97 
98  SourceLocation() : ID(0) {}
99 
100  bool isFileID() const { return (ID & MacroIDBit) == 0; }
101  bool isMacroID() const { return (ID & MacroIDBit) != 0; }
102 
103  /// \brief Return true if this is a valid SourceLocation object.
104  ///
105  /// Invalid SourceLocations are often used when events have no corresponding
106  /// location in the source (e.g. a diagnostic is required for a command line
107  /// option).
108  bool isValid() const { return ID != 0; }
109  bool isInvalid() const { return ID == 0; }
110 
111 private:
112  /// \brief Return the offset into the manager's global input view.
113  unsigned getOffset() const {
114  return ID & ~MacroIDBit;
115  }
116 
117  static SourceLocation getFileLoc(unsigned ID) {
118  assert((ID & MacroIDBit) == 0 && "Ran out of source locations!");
119  SourceLocation L;
120  L.ID = ID;
121  return L;
122  }
123 
124  static SourceLocation getMacroLoc(unsigned ID) {
125  assert((ID & MacroIDBit) == 0 && "Ran out of source locations!");
126  SourceLocation L;
127  L.ID = MacroIDBit | ID;
128  return L;
129  }
130 public:
131 
132  /// \brief Return a source location with the specified offset from this
133  /// SourceLocation.
135  assert(((getOffset()+Offset) & MacroIDBit) == 0 && "offset overflow");
136  SourceLocation L;
137  L.ID = ID+Offset;
138  return L;
139  }
140 
141  /// \brief When a SourceLocation itself cannot be used, this returns
142  /// an (opaque) 32-bit integer encoding for it.
143  ///
144  /// This should only be passed to SourceLocation::getFromRawEncoding, it
145  /// should not be inspected directly.
146  unsigned getRawEncoding() const { return ID; }
147 
148  /// \brief Turn a raw encoding of a SourceLocation object into
149  /// a real SourceLocation.
150  ///
151  /// \see getRawEncoding.
154  X.ID = Encoding;
155  return X;
156  }
157 
158  /// \brief When a SourceLocation itself cannot be used, this returns
159  /// an (opaque) pointer encoding for it.
160  ///
161  /// This should only be passed to SourceLocation::getFromPtrEncoding, it
162  /// should not be inspected directly.
163  void* getPtrEncoding() const {
164  // Double cast to avoid a warning "cast to pointer from integer of different
165  // size".
166  return (void*)(uintptr_t)getRawEncoding();
167  }
168 
169  /// \brief Turn a pointer encoding of a SourceLocation object back
170  /// into a real SourceLocation.
172  return getFromRawEncoding((unsigned)(uintptr_t)Encoding);
173  }
174 
176  return Start.isValid() && Start.isFileID() && End.isValid() &&
177  End.isFileID();
178  }
179 
180  void print(raw_ostream &OS, const SourceManager &SM) const;
181  std::string printToString(const SourceManager &SM) const;
182  void dump(const SourceManager &SM) const;
183 };
184 
185 inline bool operator==(const SourceLocation &LHS, const SourceLocation &RHS) {
186  return LHS.getRawEncoding() == RHS.getRawEncoding();
187 }
188 
189 inline bool operator!=(const SourceLocation &LHS, const SourceLocation &RHS) {
190  return !(LHS == RHS);
191 }
192 
193 inline bool operator<(const SourceLocation &LHS, const SourceLocation &RHS) {
194  return LHS.getRawEncoding() < RHS.getRawEncoding();
195 }
196 
197 /// \brief A trivial tuple used to represent a source range.
198 class SourceRange {
199  SourceLocation B;
200  SourceLocation E;
201 public:
203  SourceRange(SourceLocation loc) : B(loc), E(loc) {}
204  SourceRange(SourceLocation begin, SourceLocation end) : B(begin), E(end) {}
205 
206  SourceLocation getBegin() const { return B; }
207  SourceLocation getEnd() const { return E; }
208 
209  void setBegin(SourceLocation b) { B = b; }
210  void setEnd(SourceLocation e) { E = e; }
211 
212  bool isValid() const { return B.isValid() && E.isValid(); }
213  bool isInvalid() const { return !isValid(); }
214 
215  bool operator==(const SourceRange &X) const {
216  return B == X.B && E == X.E;
217  }
218 
219  bool operator!=(const SourceRange &X) const {
220  return B != X.B || E != X.E;
221  }
222 };
223 
224 /// \brief Represents a character-granular source range.
225 ///
226 /// The underlying SourceRange can either specify the starting/ending character
227 /// of the range, or it can specify the start of the range and the start of the
228 /// last token of the range (a "token range"). In the token range case, the
229 /// size of the last token must be measured to determine the actual end of the
230 /// range.
232  SourceRange Range;
233  bool IsTokenRange;
234 public:
235  CharSourceRange() : IsTokenRange(false) {}
236  CharSourceRange(SourceRange R, bool ITR) : Range(R), IsTokenRange(ITR) {}
237 
239  return CharSourceRange(R, true);
240  }
241 
243  return CharSourceRange(R, false);
244  }
245 
247  return getTokenRange(SourceRange(B, E));
248  }
250  return getCharRange(SourceRange(B, E));
251  }
252 
253  /// \brief Return true if the end of this range specifies the start of
254  /// the last token. Return false if the end of this range specifies the last
255  /// character in the range.
256  bool isTokenRange() const { return IsTokenRange; }
257  bool isCharRange() const { return !IsTokenRange; }
258 
259  SourceLocation getBegin() const { return Range.getBegin(); }
260  SourceLocation getEnd() const { return Range.getEnd(); }
261  SourceRange getAsRange() const { return Range; }
262 
263  void setBegin(SourceLocation b) { Range.setBegin(b); }
264  void setEnd(SourceLocation e) { Range.setEnd(e); }
265 
266  bool isValid() const { return Range.isValid(); }
267  bool isInvalid() const { return !isValid(); }
268 };
269 
270 /// \brief Represents an unpacked "presumed" location which can be presented
271 /// to the user.
272 ///
273 /// A 'presumed' location can be modified by \#line and GNU line marker
274 /// directives and is always the expansion point of a normal location.
275 ///
276 /// You can get a PresumedLoc from a SourceLocation with SourceManager.
277 class PresumedLoc {
278  const char *Filename;
279  unsigned Line, Col;
280  SourceLocation IncludeLoc;
281 
282 public:
283  PresumedLoc() : Filename(nullptr) {}
284  PresumedLoc(const char *FN, unsigned Ln, unsigned Co, SourceLocation IL)
285  : Filename(FN), Line(Ln), Col(Co), IncludeLoc(IL) {}
286 
287  /// \brief Return true if this object is invalid or uninitialized.
288  ///
289  /// This occurs when created with invalid source locations or when walking
290  /// off the top of a \#include stack.
291  bool isInvalid() const { return Filename == nullptr; }
292  bool isValid() const { return Filename != nullptr; }
293 
294  /// \brief Return the presumed filename of this location.
295  ///
296  /// This can be affected by \#line etc.
297  const char *getFilename() const {
298  assert(isValid());
299  return Filename;
300  }
301 
302  /// \brief Return the presumed line number of this location.
303  ///
304  /// This can be affected by \#line etc.
305  unsigned getLine() const {
306  assert(isValid());
307  return Line;
308  }
309 
310  /// \brief Return the presumed column number of this location.
311  ///
312  /// This cannot be affected by \#line, but is packaged here for convenience.
313  unsigned getColumn() const {
314  assert(isValid());
315  return Col;
316  }
317 
318  /// \brief Return the presumed include location of this location.
319  ///
320  /// This can be affected by GNU linemarker directives.
322  assert(isValid());
323  return IncludeLoc;
324  }
325 };
326 
327 class FileEntry;
328 
329 /// \brief A SourceLocation and its associated SourceManager.
330 ///
331 /// This is useful for argument passing to functions that expect both objects.
333  const SourceManager *SrcMgr;
334 public:
335  /// \brief Creates a FullSourceLoc where isValid() returns \c false.
336  explicit FullSourceLoc() : SrcMgr(nullptr) {}
337 
339  : SourceLocation(Loc), SrcMgr(&SM) {}
340 
341  bool hasManager() const {
342  bool hasSrcMgr = SrcMgr != nullptr;
343  assert(hasSrcMgr == isValid() && "FullSourceLoc has location but no manager");
344  return hasSrcMgr;
345  }
346 
347  /// \pre This FullSourceLoc has an associated SourceManager.
348  const SourceManager &getManager() const {
349  assert(SrcMgr && "SourceManager is NULL.");
350  return *SrcMgr;
351  }
352 
353  FileID getFileID() const;
354 
355  FullSourceLoc getExpansionLoc() const;
356  FullSourceLoc getSpellingLoc() const;
357  FullSourceLoc getFileLoc() const;
358  std::pair<FullSourceLoc, FullSourceLoc> getImmediateExpansionRange() const;
359  PresumedLoc getPresumedLoc(bool UseLineDirectives = true) const;
360  bool isMacroArgExpansion(FullSourceLoc *StartLoc = nullptr) const;
361  FullSourceLoc getImmediateMacroCallerLoc() const;
362  std::pair<FullSourceLoc, StringRef> getModuleImportLoc() const;
363  unsigned getFileOffset() const;
364 
365  unsigned getExpansionLineNumber(bool *Invalid = nullptr) const;
366  unsigned getExpansionColumnNumber(bool *Invalid = nullptr) const;
367 
368  unsigned getSpellingLineNumber(bool *Invalid = nullptr) const;
369  unsigned getSpellingColumnNumber(bool *Invalid = nullptr) const;
370 
371  const char *getCharacterData(bool *Invalid = nullptr) const;
372 
373  unsigned getLineNumber(bool *Invalid = nullptr) const;
374  unsigned getColumnNumber(bool *Invalid = nullptr) const;
375 
376  std::pair<FullSourceLoc, FullSourceLoc> getExpansionRange() const;
377 
378  const FileEntry *getFileEntry() const;
379 
380  /// \brief Return a StringRef to the source buffer data for the
381  /// specified FileID.
382  StringRef getBufferData(bool *Invalid = nullptr) const;
383 
384  /// \brief Decompose the specified location into a raw FileID + Offset pair.
385  ///
386  /// The first element is the FileID, the second is the offset from the
387  /// start of the buffer of the location.
388  std::pair<FileID, unsigned> getDecomposedLoc() const;
389 
390  bool isInSystemHeader() const;
391 
392  /// \brief Determines the order of 2 source locations in the translation unit.
393  ///
394  /// \returns true if this source location comes before 'Loc', false otherwise.
395  bool isBeforeInTranslationUnitThan(SourceLocation Loc) const;
396 
397  /// \brief Determines the order of 2 source locations in the translation unit.
398  ///
399  /// \returns true if this source location comes before 'Loc', false otherwise.
401  assert(Loc.isValid());
402  assert(SrcMgr == Loc.SrcMgr && "Loc comes from another SourceManager!");
403  return isBeforeInTranslationUnitThan((SourceLocation)Loc);
404  }
405 
406  /// \brief Comparison function class, useful for sorting FullSourceLocs.
408  bool operator()(const FullSourceLoc& lhs, const FullSourceLoc& rhs) const {
409  return lhs.isBeforeInTranslationUnitThan(rhs);
410  }
411  };
412 
413  /// \brief Prints information about this FullSourceLoc to stderr.
414  ///
415  /// This is useful for debugging.
416  void dump() const;
417 
418  friend inline bool
419  operator==(const FullSourceLoc &LHS, const FullSourceLoc &RHS) {
420  return LHS.getRawEncoding() == RHS.getRawEncoding() &&
421  LHS.SrcMgr == RHS.SrcMgr;
422  }
423 
424  friend inline bool
425  operator!=(const FullSourceLoc &LHS, const FullSourceLoc &RHS) {
426  return !(LHS == RHS);
427  }
428 
429 };
430 
431 
432 
433 } // end namespace clang
434 
435 namespace llvm {
436  /// Define DenseMapInfo so that FileID's can be used as keys in DenseMap and
437  /// DenseSets.
438  template <>
439  struct DenseMapInfo<clang::FileID> {
440  static inline clang::FileID getEmptyKey() {
441  return clang::FileID();
442  }
443  static inline clang::FileID getTombstoneKey() {
445  }
446 
447  static unsigned getHashValue(clang::FileID S) {
448  return S.getHashValue();
449  }
450 
451  static bool isEqual(clang::FileID LHS, clang::FileID RHS) {
452  return LHS == RHS;
453  }
454  };
455 
456  template <>
457  struct isPodLike<clang::SourceLocation> { static const bool value = true; };
458  template <>
459  struct isPodLike<clang::FileID> { static const bool value = true; };
460 
461  // Teach SmallPtrSet how to handle SourceLocation.
462  template<>
463  struct PointerLikeTypeTraits<clang::SourceLocation> {
464  static inline void *getAsVoidPointer(clang::SourceLocation L) {
465  return L.getPtrEncoding();
466  }
469  }
470  enum { NumLowBitsAvailable = 0 };
471  };
472 
473 } // end namespace llvm
474 
475 #endif
bool operator>=(const FileID &RHS) const
bool operator==(const SourceLocation &LHS, const SourceLocation &RHS)
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
friend bool operator==(const FullSourceLoc &LHS, const FullSourceLoc &RHS)
bool operator!=(const SourceLocation &LHS, const SourceLocation &RHS)
void setBegin(SourceLocation b)
bool operator<(const SourceLocation &LHS, const SourceLocation &RHS)
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:26
static CharSourceRange getTokenRange(SourceRange R)
bool operator>(const FileID &RHS) const
StringRef P
static FileID getSentinel()
void setBegin(SourceLocation b)
SourceLocation getBegin() const
static SourceLocation getFromRawEncoding(unsigned Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
unsigned getHashValue() const
bool isInvalid() const
friend bool operator!=(const FullSourceLoc &LHS, const FullSourceLoc &RHS)
uint32_t Offset
Definition: CacheTokens.cpp:43
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
SourceRange(SourceLocation loc)
static CharSourceRange getCharRange(SourceLocation B, SourceLocation E)
static void * getAsVoidPointer(clang::SourceLocation L)
static unsigned getHashValue(clang::FileID S)
bool operator==(const FileID &RHS) const
StringRef Filename
Definition: Format.cpp:1315
bool isValid() const
ID
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:26
bool isValid() const
bool hasManager() const
SourceLocation End
Represents a character-granular source range.
bool isInvalid() const
Return true if this object is invalid or uninitialized.
const AnnotatedLine * Line
bool operator<(const FileID &RHS) const
unsigned getLine() const
Return the presumed line number of this location.
bool operator!=(const SourceRange &X) const
const SourceManager & getManager() const
PresumedLoc(const char *FN, unsigned Ln, unsigned Co, SourceLocation IL)
void setEnd(SourceLocation e)
SourceRange(SourceLocation begin, SourceLocation end)
bool isInvalid() const
Represents an unpacked "presumed" location which can be presented to the user.
SourceLocation getEnd() const
bool operator<=(const FileID &RHS) const
bool operator==(const SourceRange &X) const
const SourceManager & SM
Definition: Format.cpp:1307
__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
static CharSourceRange getCharRange(SourceRange R)
const char * getFilename() const
Return the presumed filename of this location.
#define false
Definition: stdbool.h:33
unsigned getColumn() const
Return the presumed column number of this location.
bool isBeforeInTranslationUnitThan(SourceLocation Loc) const
Determines the order of 2 source locations in the translation unit.
Encodes a location in the source.
bool isBeforeInTranslationUnitThan(FullSourceLoc Loc) const
Determines the order of 2 source locations in the translation unit.
FullSourceLoc()
Creates a FullSourceLoc where isValid() returns false.
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
static bool isEqual(clang::FileID LHS, clang::FileID RHS)
static CharSourceRange getTokenRange(SourceLocation B, SourceLocation E)
bool operator!=(const FileID &RHS) const
bool isTokenRange() const
Return true if the end of this range specifies the start of the last token.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
SourceRange getAsRange() const
Dataflow Directional Tag Classes.
static bool isPairOfFileLocations(SourceLocation Start, SourceLocation End)
bool isValid() const
Return true if this is a valid SourceLocation object.
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:328
static clang::FileID getEmptyKey()
FullSourceLoc(SourceLocation Loc, const SourceManager &SM)
bool operator()(const FullSourceLoc &lhs, const FullSourceLoc &rhs) const
Comparison function class, useful for sorting FullSourceLocs.
SourceLocation getEnd() const
CharSourceRange(SourceRange R, bool ITR)
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13065
void setEnd(SourceLocation e)
bool isValid() const
static clang::FileID getTombstoneKey()
Writes an AST file containing the contents of a translation unit.
Definition: ASTWriter.h:82
A SourceLocation and its associated SourceManager.
static clang::SourceLocation getFromVoidPointer(void *P)
A trivial tuple used to represent a source range.
static SourceLocation getFromPtrEncoding(const void *Encoding)
Turn a pointer encoding of a SourceLocation object back into a real SourceLocation.
SourceLocation getIncludeLoc() const
Return the presumed include location of this location.
SourceLocation getBegin() const
This class handles loading and caching of source files into memory.
void * getPtrEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) pointer encoding for it...