MLIR  20.0.0git
Location.h
Go to the documentation of this file.
1 //===- Location.h - MLIR Location Classes -----------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // These classes provide the ability to relate MLIR objects back to source
10 // location position information.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef MLIR_IR_LOCATION_H
15 #define MLIR_IR_LOCATION_H
16 
17 #include "mlir/IR/Attributes.h"
18 #include "llvm/Support/PointerLikeTypeTraits.h"
19 
20 namespace mlir {
21 
22 class Location;
23 class WalkResult;
24 
25 //===----------------------------------------------------------------------===//
26 // LocationAttr
27 //===----------------------------------------------------------------------===//
28 
29 /// Location objects represent source locations information in MLIR.
30 /// LocationAttr acts as the anchor for all Location based attributes.
31 class LocationAttr : public Attribute {
32 public:
34 
35  /// Walk all of the locations nested directly under, and including, the
36  /// current. This means that if a location is nested under a non-location
37  /// attribute, it will *not* be walked by this method. This walk is performed
38  /// in pre-order to get this behavior.
40 
41  /// Return an instance of the given location type if one is nested under the
42  /// current location. Returns nullptr if one could not be found.
43  template <typename T>
45  T result = {};
46  walk([&](auto loc) {
47  if (auto typedLoc = llvm::dyn_cast<T>(loc)) {
48  result = typedLoc;
49  return WalkResult::interrupt();
50  }
51  return WalkResult::advance();
52  });
53  return result;
54  }
55 
56  /// Methods for support type inquiry through isa, cast, and dyn_cast.
57  static bool classof(Attribute attr);
58 };
59 
60 //===----------------------------------------------------------------------===//
61 // Location
62 //===----------------------------------------------------------------------===//
63 
64 /// This class defines the main interface for locations in MLIR and acts as a
65 /// non-nullable wrapper around a LocationAttr.
66 class Location {
67 public:
68  Location(LocationAttr loc) : impl(loc) {
69  assert(loc && "location should never be null.");
70  }
72  assert(impl && "location should never be null.");
73  }
74 
75  /// Return the context this location is uniqued in.
76  MLIRContext *getContext() const { return impl.getContext(); }
77 
78  /// Access the impl location attribute.
79  operator LocationAttr() const { return impl; }
80  LocationAttr *operator->() const { return const_cast<LocationAttr *>(&impl); }
81 
82  /// Type casting utilities on the underlying location.
83  template <typename U>
84  [[deprecated("Use mlir::isa<U>() instead")]]
85  bool isa() const {
86  return llvm::isa<U>(*this);
87  }
88  template <typename U>
89  [[deprecated("Use mlir::dyn_cast<U>() instead")]]
90  U dyn_cast() const {
91  return llvm::dyn_cast<U>(*this);
92  }
93  template <typename U>
94  [[deprecated("Use mlir::cast<U>() instead")]]
95  U cast() const {
96  return llvm::cast<U>(*this);
97  }
98 
99  /// Comparison operators.
100  bool operator==(Location rhs) const { return impl == rhs.impl; }
101  bool operator!=(Location rhs) const { return !(*this == rhs); }
102 
103  /// Print the location.
104  void print(raw_ostream &os) const { impl.print(os); }
105  void dump() const { impl.dump(); }
106 
107  friend ::llvm::hash_code hash_value(Location arg);
108 
109  /// Methods for supporting PointerLikeTypeTraits.
110  const void *getAsOpaquePointer() const { return impl.getAsOpaquePointer(); }
111  static Location getFromOpaquePointer(const void *pointer) {
112  return LocationAttr(reinterpret_cast<const AttributeStorage *>(pointer));
113  }
114 
115  /// Support llvm style casting.
116  static bool classof(Attribute attr) { return llvm::isa<LocationAttr>(attr); }
117 
118 protected:
119  /// The internal backing location attribute.
121 };
122 
123 inline raw_ostream &operator<<(raw_ostream &os, const Location &loc) {
124  loc.print(os);
125  return os;
126 }
127 
128 // Make Location hashable.
129 inline ::llvm::hash_code hash_value(Location arg) {
130  return hash_value(arg.impl);
131 }
132 
133 } // namespace mlir
134 
135 //===----------------------------------------------------------------------===//
136 // Tablegen Attribute Declarations
137 //===----------------------------------------------------------------------===//
138 
139 // Forward declaration for class created later.
140 namespace mlir::detail {
141 struct FileLineColRangeAttrStorage;
142 } // namespace mlir::detail
143 
144 #define GET_ATTRDEF_CLASSES
145 #include "mlir/IR/BuiltinLocationAttributes.h.inc"
146 
147 namespace mlir {
148 
149 //===----------------------------------------------------------------------===//
150 // FusedLoc
151 //===----------------------------------------------------------------------===//
152 
153 /// This class represents a fused location whose metadata is known to be an
154 /// instance of the given type.
155 template <typename MetadataT>
156 class FusedLocWith : public FusedLoc {
157 public:
158  using FusedLoc::FusedLoc;
159 
160  /// Return the metadata associated with this fused location.
161  MetadataT getMetadata() const {
162  return llvm::cast<MetadataT>(FusedLoc::getMetadata());
163  }
164 
165  /// Support llvm style casting.
166  static bool classof(Attribute attr) {
167  auto fusedLoc = llvm::dyn_cast<FusedLoc>(attr);
168  return fusedLoc && mlir::isa_and_nonnull<MetadataT>(fusedLoc.getMetadata());
169  }
170 };
171 
172 //===----------------------------------------------------------------------===//
173 // FileLineColLoc
174 //===----------------------------------------------------------------------===//
175 
176 /// An instance of this location represents a tuple of file, line number, and
177 /// column number. This is similar to the type of location that you get from
178 /// most source languages.
179 ///
180 /// FileLineColLoc is a FileLineColRange with exactly one line and column.
182 public:
183  using FileLineColRange::FileLineColRange;
184 
185  static FileLineColLoc get(StringAttr filename, unsigned line,
186  unsigned column);
187  static FileLineColLoc get(MLIRContext *context, StringRef fileName,
188  unsigned line, unsigned column);
189 
190  StringAttr getFilename() const;
191  unsigned getLine() const;
192  unsigned getColumn() const;
193 
194  /// Methods for support type inquiry through isa, cast, and dyn_cast.
195  static bool classof(Attribute attr);
196 };
197 
198 //===----------------------------------------------------------------------===//
199 // OpaqueLoc
200 //===----------------------------------------------------------------------===//
201 
202 /// Returns an instance of opaque location which contains a given pointer to
203 /// an object. The corresponding MLIR location is set to UnknownLoc.
204 template <typename T>
205 inline OpaqueLoc OpaqueLoc::get(T underlyingLocation, MLIRContext *context) {
206  return get(reinterpret_cast<uintptr_t>(underlyingLocation), TypeID::get<T>(),
207  UnknownLoc::get(context));
208 }
209 
210 //===----------------------------------------------------------------------===//
211 // SubElements
212 //===----------------------------------------------------------------------===//
213 
214 /// Enable locations to be introspected as sub-elements.
215 template <>
217  static void walk(Location param, AttrTypeImmediateSubElementWalker &walker) {
218  walker.walk(param);
219  }
221  TypeSubElementReplacements &typeRepls) {
222  return cast<LocationAttr>(attrRepls.take_front(1)[0]);
223  }
224 };
225 
226 } // namespace mlir
227 
228 //===----------------------------------------------------------------------===//
229 // LLVM Utilities
230 //===----------------------------------------------------------------------===//
231 
232 namespace llvm {
233 
234 // Type hash just like pointers.
235 template <>
236 struct DenseMapInfo<mlir::Location> {
238  auto *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
239  return mlir::Location::getFromOpaquePointer(pointer);
240  }
243  return mlir::Location::getFromOpaquePointer(pointer);
244  }
245  static unsigned getHashValue(mlir::Location val) {
246  return mlir::hash_value(val);
247  }
248  static bool isEqual(mlir::Location LHS, mlir::Location RHS) {
249  return LHS == RHS;
250  }
251 };
252 
253 /// We align LocationStorage by 8, so allow LLVM to steal the low bits.
254 template <>
255 struct PointerLikeTypeTraits<mlir::Location> {
256 public:
257  static inline void *getAsVoidPointer(mlir::Location I) {
258  return const_cast<void *>(I.getAsOpaquePointer());
259  }
260  static inline mlir::Location getFromVoidPointer(void *P) {
262  }
263  static constexpr int NumLowBitsAvailable =
265 };
266 
267 /// The constructors in mlir::Location ensure that the class is a non-nullable
268 /// wrapper around mlir::LocationAttr. Override default behavior and always
269 /// return true for isPresent().
270 template <>
271 struct ValueIsPresent<mlir::Location> {
273  static inline bool isPresent(const mlir::Location &location) { return true; }
274 };
275 
276 /// Add support for llvm style casts. We provide a cast between To and From if
277 /// From is mlir::Location or derives from it.
278 template <typename To, typename From>
279 struct CastInfo<To, From,
280  std::enable_if_t<
281  std::is_same_v<mlir::Location, std::remove_const_t<From>> ||
282  std::is_base_of_v<mlir::Location, From>>>
283  : DefaultDoCastIfPossible<To, From, CastInfo<To, From>> {
284 
285  static inline bool isPossible(mlir::Location location) {
286  /// Return a constant true instead of a dynamic true when casting to self or
287  /// up the hierarchy. Additionally, all casting info is deferred to the
288  /// wrapped mlir::LocationAttr instance stored in mlir::Location.
289  return std::is_same_v<To, std::remove_const_t<From>> ||
290  isa<To>(static_cast<mlir::LocationAttr>(location));
291  }
292 
293  static inline To castFailed() { return To(); }
294 
295  static inline To doCast(mlir::Location location) {
296  return To(location->getImpl());
297  }
298 };
299 
300 } // namespace llvm
301 
302 #endif
void walk(Attribute element)
Walk an attribute.
This class is used by AttrTypeSubElementHandler instances to process sub element replacements.
ArrayRef< T > take_front(unsigned n)
Take the first N replacements as an ArrayRef, dropping them from this replacement list.
Base storage class appearing in an attribute.
Attributes are known-constant values of operations.
Definition: Attributes.h:25
constexpr Attribute()=default
ImplType * getImpl() const
Return the internal Attribute implementation.
Definition: Attributes.h:162
An instance of this location represents a tuple of file, line number, and column number.
Definition: Location.h:181
unsigned getLine() const
Definition: Location.cpp:176
StringAttr getFilename() const
Definition: Location.cpp:172
static FileLineColLoc get(StringAttr filename, unsigned line, unsigned column)
Definition: Location.cpp:160
unsigned getColumn() const
Definition: Location.cpp:178
static bool classof(Attribute attr)
Methods for support type inquiry through isa, cast, and dyn_cast.
Definition: Location.cpp:180
This class represents a fused location whose metadata is known to be an instance of the given type.
Definition: Location.h:156
MetadataT getMetadata() const
Return the metadata associated with this fused location.
Definition: Location.h:161
static bool classof(Attribute attr)
Support llvm style casting.
Definition: Location.h:166
Location objects represent source locations information in MLIR.
Definition: Location.h:31
WalkResult walk(function_ref< WalkResult(Location)> walkFn)
Walk all of the locations nested directly under, and including, the current.
Definition: Location.cpp:127
static bool classof(Attribute attr)
Methods for support type inquiry through isa, cast, and dyn_cast.
Definition: Location.cpp:140
T findInstanceOf()
Return an instance of the given location type if one is nested under the current location.
Definition: Location.h:44
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:66
const void * getAsOpaquePointer() const
Methods for supporting PointerLikeTypeTraits.
Definition: Location.h:110
MLIRContext * getContext() const
Return the context this location is uniqued in.
Definition: Location.h:76
friend ::llvm::hash_code hash_value(Location arg)
Definition: Location.h:129
Location(LocationAttr loc)
Definition: Location.h:68
static bool classof(Attribute attr)
Support llvm style casting.
Definition: Location.h:116
bool isa() const
Type casting utilities on the underlying location.
Definition: Location.h:85
Location(const LocationAttr::ImplType *impl)
Definition: Location.h:71
void dump() const
Definition: Location.h:105
LocationAttr impl
The internal backing location attribute.
Definition: Location.h:120
static Location getFromOpaquePointer(const void *pointer)
Definition: Location.h:111
bool operator!=(Location rhs) const
Definition: Location.h:101
LocationAttr * operator->() const
Definition: Location.h:80
U cast() const
Definition: Location.h:95
U dyn_cast() const
Definition: Location.h:90
bool operator==(Location rhs) const
Comparison operators.
Definition: Location.h:100
void print(raw_ostream &os) const
Print the location.
Definition: Location.h:104
MLIRContext is the top-level object for a collection of MLIR operations.
Definition: MLIRContext.h:60
A utility result that is used to signal how to proceed with an ongoing walk:
Definition: Visitors.h:33
static WalkResult advance()
Definition: Visitors.h:51
static WalkResult interrupt()
Definition: Visitors.h:50
The OpAsmOpInterface, see OpAsmInterface.td for more details.
Definition: CallGraph.h:229
AttrTypeReplacer.
Include the generated interface declarations.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
inline ::llvm::hash_code hash_value(AffineExpr arg)
Make AffineExpr hashable.
Definition: AffineExpr.h:260
raw_ostream & operator<<(raw_ostream &os, const AliasResult &result)
Definition: AliasAnalysis.h:78
static bool isEqual(mlir::Location LHS, mlir::Location RHS)
Definition: Location.h:248
static unsigned getHashValue(mlir::Location val)
Definition: Location.h:245
static mlir::Location getEmptyKey()
Definition: Location.h:237
static mlir::Location getTombstoneKey()
Definition: Location.h:241
static void * getAsVoidPointer(mlir::Location I)
Definition: Location.h:257
static mlir::Location getFromVoidPointer(void *P)
Definition: Location.h:260
static bool isPresent(const mlir::Location &location)
Definition: Location.h:273
static Location replace(Location param, AttrSubElementReplacements &attrRepls, TypeSubElementReplacements &typeRepls)
Definition: Location.h:220
static void walk(Location param, AttrTypeImmediateSubElementWalker &walker)
Definition: Location.h:217
This class provides support for interacting with the SubElementInterfaces for different types of para...