342 lines
12 KiB
TableGen
342 lines
12 KiB
TableGen
//===- BuiltinLocationAttributes.td - Builtin Locations ----*- tablegen -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Defines the set of builtin MLIR location attributes.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef BUILTIN_LOCATION_ATTRIBUTES_TD
|
|
#define BUILTIN_LOCATION_ATTRIBUTES_TD
|
|
|
|
include "mlir/IR/AttrTypeBase.td"
|
|
include "mlir/IR/BuiltinDialect.td"
|
|
|
|
// Base class for Builtin dialect location attributes.
|
|
class Builtin_LocationAttr<string name, list<Trait> traits = []>
|
|
: LocationAttrDef<Builtin_Dialect, name, traits> {
|
|
let cppClassName = name;
|
|
let mnemonic = ?;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// CallSiteLoc
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def CallSiteLoc : Builtin_LocationAttr<"CallSiteLoc"> {
|
|
let summary = "A callsite source location";
|
|
let description = [{
|
|
Syntax:
|
|
|
|
```
|
|
callsite-location ::= `callsite` `(` location `at` location `)`
|
|
```
|
|
|
|
An instance of this location allows for representing a directed stack of
|
|
location usages. This connects a location of a `callee` with the location
|
|
of a `caller`.
|
|
|
|
Example:
|
|
|
|
```mlir
|
|
loc(callsite("foo" at "mysource.cc":10:8))
|
|
```
|
|
}];
|
|
let parameters = (ins "Location":$callee, "Location":$caller);
|
|
let builders = [
|
|
AttrBuilderWithInferredContext<(ins "Location":$callee,
|
|
"Location":$caller), [{
|
|
return $_get(callee->getContext(), callee, caller);
|
|
}]>,
|
|
AttrBuilderWithInferredContext<(ins "Location":$name,
|
|
"ArrayRef<Location>":$frames)>
|
|
];
|
|
let skipDefaultBuilders = 1;
|
|
let attrName = "builtin.call_site_loc";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// FileLineColRange
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def FileLineColRange : Builtin_LocationAttr<"FileLineColRange"> {
|
|
let summary = "A file:line:column source location range";
|
|
let description = [{
|
|
Syntax:
|
|
|
|
```
|
|
filelinecol-location ::= string-literal `:` integer-literal `:`
|
|
integer-literal
|
|
(`to` (integer-literal ?) `:` integer-literal ?)
|
|
```
|
|
|
|
An instance of this location represents a tuple of file, start and end line
|
|
number, and start and end column number. It allows for the following
|
|
configurations:
|
|
|
|
* A single file line location: `file:line`;
|
|
* A single file line col location: `file:line:column`;
|
|
* A single line range: `file:line:column to :column`;
|
|
* A single file range: `file:line:column to line:column`;
|
|
|
|
Example:
|
|
|
|
```mlir
|
|
loc("mysource.cc":10:8 to 12:18)
|
|
```
|
|
}];
|
|
|
|
let parameters = (ins "StringAttr":$filename,
|
|
"unsigned":$start_line, "unsigned":$start_column,
|
|
"unsigned":$end_line, "unsigned":$end_column);
|
|
let builders = [
|
|
AttrBuilderWithInferredContext<(ins "StringAttr":$filename), [{
|
|
return $_get(filename.getContext(), filename, ArrayRef<unsigned>{});
|
|
}]>,
|
|
AttrBuilderWithInferredContext<(ins "StringAttr":$filename,
|
|
"unsigned":$line), [{
|
|
return $_get(filename.getContext(), filename,
|
|
ArrayRef<unsigned>{line});
|
|
}]>,
|
|
AttrBuilderWithInferredContext<(ins "StringAttr":$filename,
|
|
"unsigned":$line,
|
|
"unsigned":$column), [{
|
|
return $_get(filename.getContext(), filename,
|
|
ArrayRef<unsigned>{line, column});
|
|
}]>,
|
|
AttrBuilder<(ins "::llvm::StringRef":$filename,
|
|
"unsigned":$start_line,
|
|
"unsigned":$start_column), [{
|
|
return $_get($_ctxt,
|
|
StringAttr::get($_ctxt, filename.empty() ? "-" : filename),
|
|
ArrayRef<unsigned>{start_line, start_column});
|
|
}]>,
|
|
AttrBuilderWithInferredContext<(ins "::mlir::StringAttr":$filename,
|
|
"unsigned":$line,
|
|
"unsigned":$start_column,
|
|
"unsigned":$end_column), [{
|
|
return $_get(filename.getContext(), filename,
|
|
ArrayRef<unsigned>{line, start_column, end_column});
|
|
}]>,
|
|
AttrBuilderWithInferredContext<(ins "::mlir::StringAttr":$filename,
|
|
"unsigned":$start_line,
|
|
"unsigned":$start_column,
|
|
"unsigned":$end_line,
|
|
"unsigned":$end_column), [{
|
|
return $_get(filename.getContext(), filename,
|
|
ArrayRef<unsigned>{start_line, start_column, end_column, end_line});
|
|
}]>,
|
|
AttrBuilder<(ins "::llvm::StringRef":$filename,
|
|
"unsigned":$start_line,
|
|
"unsigned":$start_column,
|
|
"unsigned":$end_line,
|
|
"unsigned":$end_column), [{
|
|
return $_get($_ctxt,
|
|
StringAttr::get($_ctxt, filename.empty() ? "-" : filename),
|
|
ArrayRef<unsigned>{start_line, start_column, end_column, end_line});
|
|
}]>,
|
|
];
|
|
|
|
let extraClassDeclaration = [{
|
|
::mlir::StringAttr getFilename() const;
|
|
unsigned getStartLine() const;
|
|
unsigned getStartColumn() const;
|
|
unsigned getEndColumn() const;
|
|
unsigned getEndLine() const;
|
|
}];
|
|
let skipDefaultBuilders = 1;
|
|
let genAccessors = 0;
|
|
let genStorageClass = 0;
|
|
let attrName = "builtin.file_line_range";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// FusedLoc
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def FusedLoc : Builtin_LocationAttr<"FusedLoc"> {
|
|
let summary = "A tuple of other source locations";
|
|
let description = [{
|
|
Syntax:
|
|
|
|
```
|
|
fusion-metadata ::= `<` attribute-value `>`
|
|
fused-location ::= `fused` fusion-metadata? `[` (location (`,` location)* )? `]`
|
|
```
|
|
|
|
An instance of a `fused` location represents a grouping of several other
|
|
source locations, with optional metadata that describes the context of the
|
|
fusion. There are many places within a compiler in which several constructs
|
|
may be fused together, e.g. pattern rewriting, that normally result partial
|
|
or even total loss of location information. With `fused` locations, this is
|
|
a non-issue.
|
|
|
|
Example:
|
|
|
|
```mlir
|
|
loc(fused["mysource.cc":10:8, "mysource.cc":22:8])
|
|
loc(fused<"CSE">["mysource.cc":10:8, "mysource.cc":22:8])
|
|
```
|
|
}];
|
|
let parameters = (ins ArrayRefParameter<"Location", "">:$locations,
|
|
"Attribute":$metadata);
|
|
let extraClassDeclaration = [{
|
|
static Location get(ArrayRef<Location> locs, Attribute metadata,
|
|
MLIRContext *context);
|
|
static Location get(MLIRContext *context, ArrayRef<Location> locs) {
|
|
return get(locs, Attribute(), context);
|
|
}
|
|
}];
|
|
let attrName = "builtin.fused_loc";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// NameLoc
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def NameLoc : Builtin_LocationAttr<"NameLoc"> {
|
|
let summary = "A named source location";
|
|
let description = [{
|
|
Syntax:
|
|
|
|
```
|
|
name-location ::= string-literal (`(` location `)`)?
|
|
```
|
|
|
|
An instance of this location allows for attaching a name to a child location.
|
|
This can be useful for representing the locations of variable, or node,
|
|
definitions.
|
|
|
|
#### Example:
|
|
|
|
```mlir
|
|
loc("CSE"("mysource.cc":10:8))
|
|
```
|
|
}];
|
|
let parameters = (ins "StringAttr":$name, "Location":$childLoc);
|
|
let builders = [
|
|
AttrBuilderWithInferredContext<(ins "StringAttr":$name,
|
|
"Location":$childLoc), [{
|
|
return $_get(name.getContext(), name, childLoc);
|
|
}]>,
|
|
AttrBuilderWithInferredContext<(ins "StringAttr":$name), [{
|
|
return $_get(name.getContext(), name,
|
|
UnknownLoc::get(name.getContext()));
|
|
}]>
|
|
];
|
|
let skipDefaultBuilders = 1;
|
|
let attrName = "builtin.name_loc";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// OpaqueLoc
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def OpaqueLoc : Builtin_LocationAttr<"OpaqueLoc"> {
|
|
let summary = "An opaque source location";
|
|
let description = [{
|
|
An instance of this location essentially contains a pointer to some data
|
|
structure that is external to MLIR and an optional location that can be used
|
|
if the first one is not suitable. Since it contains an external structure,
|
|
only the optional location is used during serialization.
|
|
|
|
#### Example:
|
|
|
|
```mlir
|
|
%0 = "example.operation"() : () -> i32 loc("mysource")
|
|
%1 = arith.constant 4 : index loc(callsite("mysum" at "mysource.cc":10:8))
|
|
```
|
|
}];
|
|
let parameters = (ins "uintptr_t":$underlyingLocation,
|
|
"TypeID":$underlyingTypeID,
|
|
"Location":$fallbackLocation);
|
|
let builders = [
|
|
AttrBuilderWithInferredContext<(ins "uintptr_t":$underlyingLocation,
|
|
"TypeID":$underlyingTypeID,
|
|
"Location":$fallbackLocation), [{
|
|
return $_get(fallbackLocation->getContext(), underlyingLocation,
|
|
underlyingTypeID, fallbackLocation);
|
|
}]>
|
|
];
|
|
let extraClassDeclaration = [{
|
|
/// Returns an instance of opaque location which contains a given pointer to
|
|
/// an object. The corresponding MLIR location is set to UnknownLoc.
|
|
template <typename T>
|
|
static OpaqueLoc get(T underlyingLocation, MLIRContext *context);
|
|
|
|
/// Returns an instance of opaque location which contains a given pointer to
|
|
/// an object and an additional MLIR location.
|
|
template <typename T>
|
|
static OpaqueLoc get(T underlyingLocation, Location fallbackLocation) {
|
|
return get(reinterpret_cast<uintptr_t>(underlyingLocation),
|
|
TypeID::get<T>(), fallbackLocation);
|
|
}
|
|
|
|
/// Returns a pointer to some data structure that opaque location stores.
|
|
template <typename T> static T getUnderlyingLocation(Location location) {
|
|
assert(isa<T>(location));
|
|
return reinterpret_cast<T>(
|
|
mlir::cast<mlir::OpaqueLoc>(static_cast<LocationAttr>(location))
|
|
.getUnderlyingLocation());
|
|
}
|
|
|
|
/// Returns a pointer to some data structure that opaque location stores.
|
|
/// Returns nullptr if provided location is not opaque location or if it
|
|
/// contains a pointer of different type.
|
|
template <typename T>
|
|
static T getUnderlyingLocationOrNull(Location location) {
|
|
return isa<T>(location)
|
|
? reinterpret_cast<T>(mlir::cast<mlir::OpaqueLoc>(
|
|
static_cast<LocationAttr>(location))
|
|
.getUnderlyingLocation())
|
|
: T(nullptr);
|
|
}
|
|
|
|
/// Checks whether provided location is opaque location and contains a
|
|
/// pointer to an object of particular type.
|
|
template <typename T> static bool isa(Location location) {
|
|
auto opaque_loc =
|
|
mlir::dyn_cast<OpaqueLoc>(static_cast<LocationAttr>(location));
|
|
return opaque_loc && opaque_loc.getUnderlyingTypeID() == TypeID::get<T>();
|
|
}
|
|
}];
|
|
let skipDefaultBuilders = 1;
|
|
let attrName = "builtin.opaque_loc";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// UnknownLoc
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def UnknownLoc : Builtin_LocationAttr<"UnknownLoc"> {
|
|
let summary = "An unspecified source location";
|
|
let description = [{
|
|
Syntax:
|
|
|
|
```
|
|
unknown-location ::= `?`
|
|
```
|
|
|
|
Source location information is an extremely integral part of the MLIR
|
|
infrastructure. As such, location information is always present in the IR,
|
|
and must explicitly be set to unknown. Thus, an instance of the `unknown`
|
|
location represents an unspecified source location.
|
|
|
|
Example:
|
|
|
|
```mlir
|
|
loc(?)
|
|
```
|
|
}];
|
|
let extraClassDeclaration = [{
|
|
static UnknownLoc get(MLIRContext *context);
|
|
}];
|
|
let attrName = "builtin.unknown_loc";
|
|
}
|
|
|
|
#endif // BUILTIN_LOCATION_ATTRIBUTES_TD
|