This is an archive of the discontinued LLVM Phabricator instance.

Differential D78713

[WIP][mlir][flang] use OpBuilder in <Op>::build methods
ClosedPublic

Authored by ftynse on Apr 23 2020, 7:11 AM.

Details

Reviewers
mravishankar
antiagainst
nicolasvasilache
herhut
rriddle
aartbik
jpienaar
jdoerfert
schweitz
DavidTruby
Commits
rGbb1d976febf2: [mlir][flang] use OpBuilder& instead of Builder* in <Op>::build methods

Diff Detail

Event Timeline

ftynse created this revision.Apr 23 2020, 7:11 AM
Herald added a reviewer: mravishankar. · View Herald TranscriptApr 23 2020, 7:11 AM
Herald added a reviewer: antiagainst. · View Herald Transcript
Herald added a reviewer: nicolasvasilache. · View Herald Transcript
Herald added a reviewer: herhut. · View Herald Transcript
Herald added a reviewer: rriddle. · View Herald Transcript
Herald added a reviewer: antiagainst. · View Herald Transcript
Herald added a reviewer: DavidTruby. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: jpienaar. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: llvm-commits, Kayjukh, frgossen and 16 others. · View Herald Transcript
nicolasvasilache accepted this revision.Apr 23 2020, 7:37 AM

Good to go on my end, let's wait for @rriddle to confirm.

Harbormaster failed remote builds in B54394: Diff 259558!Apr 23 2020, 8:04 AM
antiagainst accepted this revision.Apr 23 2020, 8:38 AM

LGTM.

rriddle accepted this revision.Apr 23 2020, 11:18 AM
ChinouneMehdi added projects: Restricted Project, Restricted Project.Apr 24 2020, 11:29 PM
Herald added a reviewer: jdoerfert. · View Herald TranscriptApr 24 2020, 11:29 PM
DavidTruby resigned from this revision.Apr 25 2020, 9:04 AM
herhut accepted this revision.Apr 27 2020, 4:20 AM

Thanks for the cleanup!

ftynse updated this revision to Diff 260285.Apr 27 2020, 4:58 AM

Rebase

Harbormaster failed remote builds in B54783: Diff 260285!Apr 27 2020, 5:52 AM
sscalpone added a subscriber: schweitz.Apr 27 2020, 9:17 AM
schweitz added a comment.Apr 27 2020, 10:18 AM

There is an update to FIR waiting here. https://reviews.llvm.org/D78835

schweitz added a comment.EditedApr 27 2020, 10:35 AM

Looks good to me. What was the motivation behind threading Builder over OpBuilder? (specifically in the flang/FIR changes)

schweitz accepted this revision.Apr 27 2020, 10:36 AM
mehdi_amini added a comment.Apr 27 2020, 11:08 AM
In D78713#2005739, @schweitz wrote:

Looks good to me. What was the motivation behind threading Builder over OpBuilder?

See: https://llvm.discourse.group/t/rfc-make-opty-build-take-opbuilder-instead-of-builder/974

ftynse added a comment.Apr 27 2020, 3:18 PM
In D78713#2005692, @schweitz wrote:

There is an update to FIR waiting here. https://reviews.llvm.org/D78835

If you are ready to land that, feel free to go ahead, I'll fix up when this lands.

ftynse updated this revision to Diff 260566.Apr 28 2020, 1:35 AM

Rebase

This revision was not accepted when it landed; it landed in state Needs Review.Apr 28 2020, 2:07 AM
Closed by commit rGbb1d976febf2: [mlir][flang] use OpBuilder& instead of Builder* in <Op>::build methods (authored by ftynse). · Explain Why
This revision was automatically updated to reflect the committed changes.
Harbormaster failed remote builds in B54933: Diff 260566!Apr 28 2020, 2:39 AM

Revision Contents

PathSize
flang/
include/
flang/
Optimizer/
Dialect/
28 lines
lib/
Optimizer/
Dialect/
10 lines
mlir/
docs/
2 lines
18 lines
Tutorials/
Toy/
4 lines
examples/
toy/
Ch2/
include/
toy/
14 lines
mlir/
22 lines
Ch3/
include/
toy/
14 lines
mlir/
22 lines
Ch4/
include/
toy/
14 lines
mlir/
22 lines
Ch5/
include/
toy/
14 lines
mlir/
22 lines
Ch6/
include/
toy/
14 lines
mlir/
22 lines
Ch7/
include/
toy/
16 lines
mlir/
26 lines
include/
mlir/
Dialect/
Affine/
IR/
14 lines
28 lines
GPU/
12 lines
LLVMIR/
52 lines
Linalg/
IR/
12 lines
2 lines
LoopOps/
12 lines
SPIRV/
2 lines
2 lines
14 lines
2 lines
2 lines
8 lines
20 lines
Shape/
IR/
2 lines
StandardOps/
IR/
12 lines
74 lines
Vector/
28 lines
IR/
4 lines
4 lines
4 lines
6 lines
14 lines
4 lines
Transforms/
2 lines
lib/
Conversion/
LinalgToSPIRV/
12 lines
Dialect/
Affine/
IR/
68 lines
GPU/
IR/
34 lines
Transforms/
4 lines
LLVMIR/
IR/
28 lines
Linalg/
IR/
24 lines
LoopOps/
36 lines
SPIRV/
2 lines
113 lines
Serialization/
4 lines
Transforms/
2 lines
StandardOps/
IR/
52 lines
Vector/
43 lines
IR/
10 lines
12 lines
9 lines
test/
lib/
Dialect/
Test/
14 lines
2 lines
mlir-tblgen/
10 lines
8 lines
6 lines
16 lines
tools/
mlir-linalg-ods-gen/
4 lines
mlir-tblgen/
18 lines
unittests/
Dialect/
SPIRV/
4 lines

Diff 259558

flang/include/flang/Optimizer/Dialect/FIROps.td

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Linesclass fir_SimpleOp<string mnemonic, list<OpTrait> traits>
let assemblyFormat = [{ let assemblyFormat = [{
operands attr-dict `:` functional-type(operands, results) operands attr-dict `:` functional-type(operands, results)
}]; }];
} }
// Base builder for allocate operations // Base builder for allocate operations
def fir_AllocateOpBuilder : OpBuilder< def fir_AllocateOpBuilder : OpBuilder<
"Builder *builder, OperationState &result, Type inType," "OpBuilder &builder, OperationState &result, Type inType,"
"ValueRange lenParams = {}, ValueRange sizes = {}," "ValueRange lenParams = {}, ValueRange sizes = {},"
"ArrayRef<NamedAttribute> attributes = {}", "ArrayRef<NamedAttribute> attributes = {}",
[{ [{
result.addTypes(getRefTy(inType)); result.addTypes(getRefTy(inType));
result.addAttribute("in_type", TypeAttr::get(inType)); result.addAttribute("in_type", TypeAttr::get(inType));
result.addOperands(sizes); result.addOperands(sizes);
result.addAttributes(attributes); result.addAttributes(attributes);
}]>; }]>;
def fir_NamedAllocateOpBuilder : OpBuilder< def fir_NamedAllocateOpBuilder : OpBuilder<
"Builder *builder, OperationState &result, Type inType, StringRef name," "OpBuilder &builder, OperationState &result, Type inType, StringRef name,"
"ValueRange lenParams = {}, ValueRange sizes = {}," "ValueRange lenParams = {}, ValueRange sizes = {},"
"ArrayRef<NamedAttribute> attributes = {}", "ArrayRef<NamedAttribute> attributes = {}",
[{ [{
result.addTypes(getRefTy(inType)); result.addTypes(getRefTy(inType));
result.addAttribute("in_type", TypeAttr::get(inType)); result.addAttribute("in_type", TypeAttr::get(inType));
result.addAttribute("name", builder->getStringAttr(name)); result.addAttribute("name", builder->getStringAttr(name));
result.addOperands(sizes); result.addOperands(sizes);
result.addAttributes(attributes); result.addAttributes(attributes);
}]>; }]>;
def fir_OneResultOpBuilder : OpBuilder< def fir_OneResultOpBuilder : OpBuilder<
"Builder *, OperationState &result, Type resultType," "OpBuilder &, OperationState &result, Type resultType,"
"ValueRange operands, ArrayRef<NamedAttribute> attributes = {}", "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
[{ [{
if (resultType) if (resultType)
result.addTypes(resultType); result.addTypes(resultType);
result.addOperands(operands); result.addOperands(operands);
result.addAttributes(attributes); result.addAttributes(attributes);
}]>; }]>;
▲ Show 20 Lines • Show All 178 Lines • ▼ Show 20 Lines let description = [{
The ssa-value has an undefined value if the memory reference is undefined The ssa-value has an undefined value if the memory reference is undefined
or null. or null.
}]; }];
let arguments = (ins AnyReferenceLike:$memref); let arguments = (ins AnyReferenceLike:$memref);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value refVal", "OpBuilder &builder, OperationState &result, Value refVal",
[{ [{
if (!refVal) { if (!refVal) {
mlir::emitError(result.location, "LoadOp has null argument"); mlir::emitError(result.location, "LoadOp has null argument");
return; return;
} }
auto refTy = refVal.getType().cast<fir::ReferenceType>(); auto refTy = refVal.getType().cast<fir::ReferenceType>();
result.addOperands(refVal); result.addOperands(refVal);
result.addTypes(refTy.getEleTy()); result.addTypes(refTy.getEleTy());
▲ Show 20 Lines • Show All 174 Lines • ▼ Show 20 Lines let arguments = (ins
Variadic<AnyType>:$targetArgs Variadic<AnyType>:$targetArgs
); );
let results = (outs); let results = (outs);
let successors = (successor VariadicSuccessor<AnySuccessor>:$targets); let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *, OperationState &result, Value selector," "OpBuilder &, OperationState &result, Value selector,"
"ValueRange properOperands, ArrayRef<Block *> destinations," "ValueRange properOperands, ArrayRef<Block *> destinations,"
"ArrayRef<ValueRange> operands = {}," "ArrayRef<ValueRange> operands = {},"
"ArrayRef<NamedAttribute> attributes = {}", "ArrayRef<NamedAttribute> attributes = {}",
[{ [{
result.addOperands(selector); result.addOperands(selector);
result.addOperands(properOperands); result.addOperands(properOperands);
for (auto kvp : llvm::zip(destinations, operands)) { for (auto kvp : llvm::zip(destinations, operands)) {
result.addSuccessors(std::get<0>(kvp)); result.addSuccessors(std::get<0>(kvp));
▲ Show 20 Lines • Show All 1,008 Lines • ▼ Show 20 Lines if (getNumOperands()) {
else else
p << "()"; p << "()";
sep = ", "; sep = ", ";
} }
} }
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, StringRef fieldName," "OpBuilder &builder, OperationState &result, StringRef fieldName,"
"Type recTy, ValueRange operands = {}", "Type recTy, ValueRange operands = {}",
[{ [{
result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName)); result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
result.addAttribute(typeAttrName(), TypeAttr::get(recTy)); result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
result.addOperands(operands); result.addOperands(operands);
}] }]
>]; >];
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Linesdef fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
let printer = [{ let printer = [{
p << getOperationName() << ' ' p << getOperationName() << ' '
<< getAttrOfType<mlir::StringAttr>(fieldAttrName()).getValue() << ", " << getAttrOfType<mlir::StringAttr>(fieldAttrName()).getValue() << ", "
<< getAttr(typeAttrName()); << getAttr(typeAttrName());
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, StringRef fieldName, Type recTy", "OpBuilder &builder, OperationState &result, StringRef fieldName, Type recTy",
[{ [{
result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName)); result.addAttribute(fieldAttrName(), builder->getStringAttr(fieldName));
result.addAttribute(typeAttrName(), TypeAttr::get(recTy)); result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
}] }]
>]; >];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static constexpr llvm::StringRef fieldAttrName() { return "field_id"; } static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
Show All 38 Linesdef fir_LoopOp : fir_Op<"loop", [ImplicitFirTerminator]> {
); );
let results = (outs Variadic<Index>:$lastVal); let results = (outs Variadic<Index>:$lastVal);
let regions = (region SizedRegion<1>:$region); let regions = (region SizedRegion<1>:$region);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"mlir::Builder *builder, OperationState &result," OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
"mlir::Value lowerBound, mlir::Value upperBound," "mlir::Value lowerBound, mlir::Value upperBound,"
"ValueRange step = {}, ArrayRef<NamedAttribute> attributes = {}"> "ValueRange step = {}, ArrayRef<NamedAttribute> attributes = {}">
]; ];
let parser = "return parseLoopOp(parser, result);"; let parser = "return parseLoopOp(parser, result);";
let printer = [{ let printer = [{
p << getOperationName() << ' ' << getInductionVar() << " = " p << getOperationName() << ' ' << getInductionVar() << " = "
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Linesdef fir_WhereOp : fir_Op<"where", [ImplicitFirTerminator]> {
}]; }];
let arguments = (ins I1:$condition); let arguments = (ins I1:$condition);
let regions = (region SizedRegion<1>:$whereRegion, AnyRegion:$otherRegion); let regions = (region SizedRegion<1>:$whereRegion, AnyRegion:$otherRegion);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"Value cond, bool withOtherRegion"> "Value cond, bool withOtherRegion">
]; ];
let parser = [{ return parseWhereOp(parser, result); }]; let parser = [{ return parseWhereOp(parser, result); }];
let printer = [{ let printer = [{
p << getOperationName() << ' ' << condition(); p << getOperationName() << ' ' << condition();
p.printRegion(whereRegion(), /*printEntryBlockArgs=*/false, p.printRegion(whereRegion(), /*printEntryBlockArgs=*/false,
▲ Show 20 Lines • Show All 298 Lines • ▼ Show 20 Lines let description = [{
floating-point types found in FIR. floating-point types found in FIR.
}]; }];
let arguments = (ins AnyRealLike:$lhs, AnyRealLike:$rhs); let arguments = (ins AnyRealLike:$lhs, AnyRealLike:$rhs);
let results = (outs AnyLogicalLike); let results = (outs AnyLogicalLike);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, CmpFPredicate predicate," "OpBuilder &builder, OperationState &result, CmpFPredicate predicate,"
"Value lhs, Value rhs", [{ "Value lhs, Value rhs", [{
buildCmpFOp(builder, result, predicate, lhs, rhs); buildCmpFOp(builder, result, predicate, lhs, rhs);
}]>]; }]>];
let parser = [{ return parseCmpfOp(parser, result); }]; let parser = [{ return parseCmpfOp(parser, result); }];
let printer = [{ printCmpfOp(p, *this); }]; let printer = [{ printCmpfOp(p, *this); }];
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Linesdef fir_CmpcOp : fir_Op<"cmpc",
let results = (outs AnyLogicalLike); let results = (outs AnyLogicalLike);
let parser = "return parseCmpcOp(parser, result);"; let parser = "return parseCmpcOp(parser, result);";
let printer = "printCmpcOp(p, *this);"; let printer = "printCmpcOp(p, *this);";
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, CmpFPredicate predicate," "OpBuilder &builder, OperationState &result, CmpFPredicate predicate,"
"Value lhs, Value rhs", [{ "Value lhs, Value rhs", [{
buildCmpCOp(builder, result, predicate, lhs, rhs); buildCmpCOp(builder, result, predicate, lhs, rhs);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static constexpr llvm::StringRef getPredicateAttrName() { static constexpr llvm::StringRef getPredicateAttrName() {
return "predicate"; return "predicate";
} }
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Linesdef fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
}]; }];
let printer = [{ let printer = [{
p << getOperationName() << ' ' << getAttr("in_type"); p << getOperationName() << ' ' << getAttr("in_type");
p.printOptionalAttrDict(getAttrs(), {"in_type"}); p.printOptionalAttrDict(getAttrs(), {"in_type"});
}]; }];
let builders = [ let builders = [
OpBuilder<"Builder *, OperationState &result, mlir::TypeAttr inty"> OpBuilder<"OpBuilder &, OperationState &result, mlir::TypeAttr inty">
]; ];
let verifier = [{ let verifier = [{
mlir::Type resultTy = getType(); mlir::Type resultTy = getType();
if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) { if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
if (tdesc.getOfTy() != getInType()) if (tdesc.getOfTy() != getInType())
return emitOpError("wrapped type mismatched"); return emitOpError("wrapped type mismatched");
} else { } else {
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines let printer = [{
Region &body = getOperation()->getRegion(0); Region &body = getOperation()->getRegion(0);
if (!body.empty()) if (!body.empty())
p.printRegion(body, /*printEntryBlockArgs=*/false, p.printRegion(body, /*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/true); /*printBlockTerminators=*/true);
}]; }];
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"mlir::Builder *builder, OperationState &result," OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
"StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}", "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
[{ [{
result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type)); result.addAttribute(typeAttrName(), mlir::TypeAttr::get(type));
result.addAttribute(mlir::SymbolTable::getSymbolAttrName(), result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name)); builder->getStringAttr(name));
result.addAttributes(attrs); result.addAttributes(attrs);
}]> }]>
]; ];
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines for (auto &op : getBlock())
return emitOpError("dispatch table must contain dt_entry"); return emitOpError("dispatch table must contain dt_entry");
return mlir::success(); return mlir::success();
}]; }];
let regions = (region SizedRegion<1>:$region); let regions = (region SizedRegion<1>:$region);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"mlir::Builder *builder, OperationState *result," OpBuilder<"mlir::OpBuilder &builder, OperationState *result,"
"StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}", "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
[{ [{
result->addAttribute(mlir::SymbolTable::getSymbolAttrName(), result->addAttribute(mlir::SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name)); builder->getStringAttr(name));
result->addAttributes(attrs); result->addAttributes(attrs);
}]> }]>
]; ];
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

flang/lib/Optimizer/Dialect/FIROps.cpp

Show First 20 Lines • Show All 179 Lines • ▼ Show 20 Lines
// Note: getCmpFPredicateNames() is inline static in StandardOps/IR/Ops.cpp // Note: getCmpFPredicateNames() is inline static in StandardOps/IR/Ops.cpp
mlir::CmpFPredicate fir::CmpfOp::getPredicateByName(llvm::StringRef name) { mlir::CmpFPredicate fir::CmpfOp::getPredicateByName(llvm::StringRef name) {
auto pred = mlir::symbolizeCmpFPredicate(name); auto pred = mlir::symbolizeCmpFPredicate(name);
assert(pred.hasValue() && "invalid predicate name"); assert(pred.hasValue() && "invalid predicate name");
return pred.getValue(); return pred.getValue();
} }
void fir::buildCmpFOp(Builder *builder, OperationState &result, void fir::buildCmpFOp(OpBuilder &builder, OperationState &result,
CmpFPredicate predicate, Value lhs, Value rhs) { CmpFPredicate predicate, Value lhs, Value rhs) {
result.addOperands({lhs, rhs}); result.addOperands({lhs, rhs});
result.types.push_back(builder->getI1Type()); result.types.push_back(builder->getI1Type());
result.addAttribute( result.addAttribute(
CmpfOp::getPredicateAttrName(), CmpfOp::getPredicateAttrName(),
builder->getI64IntegerAttr(static_cast<int64_t>(predicate))); builder->getI64IntegerAttr(static_cast<int64_t>(predicate)));
} }
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesmlir::ParseResult fir::parseCmpfOp(mlir::OpAsmParser &parser,
mlir::OperationState &result) { mlir::OperationState &result) {
return parseCmpOp<fir::CmpfOp>(parser, result); return parseCmpOp<fir::CmpfOp>(parser, result);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CmpcOp // CmpcOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void fir::buildCmpCOp(Builder *builder, OperationState &result, void fir::buildCmpCOp(OpBuilder &builder, OperationState &result,
CmpFPredicate predicate, Value lhs, Value rhs) { CmpFPredicate predicate, Value lhs, Value rhs) {
result.addOperands({lhs, rhs}); result.addOperands({lhs, rhs});
result.types.push_back(builder->getI1Type()); result.types.push_back(builder->getI1Type());
result.addAttribute( result.addAttribute(
fir::CmpcOp::getPredicateAttrName(), fir::CmpcOp::getPredicateAttrName(),
builder->getI64IntegerAttr(static_cast<int64_t>(predicate))); builder->getI64IntegerAttr(static_cast<int64_t>(predicate)));
} }
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines if (parser.parseOptionalAttrDict(result.attributes) ||
return mlir::failure(); return mlir::failure();
return mlir::success(); return mlir::success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenTypeDescOp // GenTypeDescOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void fir::GenTypeDescOp::build(Builder *, OperationState &result, void fir::GenTypeDescOp::build(OpBuilder &, OperationState &result,
mlir::TypeAttr inty) { mlir::TypeAttr inty) {
result.addAttribute("in_type", inty); result.addAttribute("in_type", inty);
result.addTypes(TypeDescType::get(inty.getValue())); result.addTypes(TypeDescType::get(inty.getValue()));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GlobalOp // GlobalOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 19 Lines if ((ele = elementTypeOf(ref)))
return mlir::success(); return mlir::success();
return mlir::failure(); return mlir::failure();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// LoopOp // LoopOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void fir::LoopOp::build(mlir::Builder *builder, OperationState &result, void fir::LoopOp::build(mlir::OpBuilder &builder, OperationState &result,
mlir::Value lb, mlir::Value ub, ValueRange step, mlir::Value lb, mlir::Value ub, ValueRange step,
ArrayRef<NamedAttribute> attributes) { ArrayRef<NamedAttribute> attributes) {
if (step.empty()) if (step.empty())
result.addOperands({lb, ub}); result.addOperands({lb, ub});
else else
result.addOperands({lb, ub, step[0]}); result.addOperands({lb, ub, step[0]});
mlir::Region *bodyRegion = result.addRegion(); mlir::Region *bodyRegion = result.addRegion();
LoopOp::ensureTerminator(*bodyRegion, *builder, result.location); LoopOp::ensureTerminator(*bodyRegion, *builder, result.location);
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Linesbool fir::StringLitOp::isWideValue() {
auto eleTy = getType().cast<fir::SequenceType>().getEleTy(); auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
return eleTy.cast<fir::CharacterType>().getFKind() != 1; return eleTy.cast<fir::CharacterType>().getFKind() != 1;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// WhereOp // WhereOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void fir::WhereOp::build(mlir::Builder *builder, OperationState &result, void fir::WhereOp::build(mlir::OpBuilder &builder, OperationState &result,
mlir::Value cond, bool withElseRegion) { mlir::Value cond, bool withElseRegion) {
result.addOperands(cond); result.addOperands(cond);
mlir::Region *thenRegion = result.addRegion(); mlir::Region *thenRegion = result.addRegion();
mlir::Region *elseRegion = result.addRegion(); mlir::Region *elseRegion = result.addRegion();
WhereOp::ensureTerminator(*thenRegion, *builder, result.location); WhereOp::ensureTerminator(*thenRegion, *builder, result.location);
if (withElseRegion) if (withElseRegion)
WhereOp::ensureTerminator(*elseRegion, *builder, result.location); WhereOp::ensureTerminator(*elseRegion, *builder, result.location);
} }
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

mlir/docs/DeclarativeRewrites.md

Show First 20 Lines • Show All 259 Lines • ▼ Show 20 Lines
`AOp` is generated via a nested result pattern; DRR won't be able to deduce the `AOp` is generated via a nested result pattern; DRR won't be able to deduce the
result type for it. A custom builder for `AOp` should be defined and it should result type for it. A custom builder for `AOp` should be defined and it should
deduce the result type by itself. The builder should have the separate parameter deduce the result type by itself. The builder should have the separate parameter
for each operand and attribute and deduce the result type internally by itself. for each operand and attribute and deduce the result type internally by itself.
For example, for the above `AOp`, a possible builder is: For example, for the above `AOp`, a possible builder is:
```c++ ```c++
void AOp::build(Builder *builder, OperationState &state, void AOp::build(OpBuilder &builder, OperationState &state,
Value input, Attribute attr) { Value input, Attribute attr) {
state.addOperands({input}); state.addOperands({input});
state.addAttribute("a_attr", attr); state.addAttribute("a_attr", attr);
Type type = ...; // Deduce result type here Type type = ...; // Deduce result type here
state.addTypes({type}); state.addTypes({type});
} }
``` ```
▲ Show 20 Lines • Show All 463 Lines • Show Last 20 Lines

mlir/docs/OpDefinitions.md

Show First 20 Lines • Show All 484 Lines • ▼ Show 20 Linesdef MyOp : ... {
); );
} }
``` ```
The following builders are generated: The following builders are generated:
```c++ ```c++
// All result-types/operands/attributes have one aggregate parameter. // All result-types/operands/attributes have one aggregate parameter.
static void build(Builder *odsBuilder, OperationState &odsState, static void build(OpBuilder &odsBuilder, OperationState &odsState,
ArrayRef<Type> resultTypes, ArrayRef<Type> resultTypes,
ValueRange operands, ValueRange operands,
ArrayRef<NamedAttribute> attributes); ArrayRef<NamedAttribute> attributes);
// Each result-type/operand/attribute has a separate parameter. The parameters // Each result-type/operand/attribute has a separate parameter. The parameters
// for attributes are of mlir::Attribute types. // for attributes are of mlir::Attribute types.
static void build(Builder *odsBuilder, OperationState &odsState, static void build(OpBuilder &odsBuilder, OperationState &odsState,
Type i32_result, Type f32_result, ..., Type i32_result, Type f32_result, ...,
Value i32_operand, Value f32_operand, ..., Value i32_operand, Value f32_operand, ...,
IntegerAttr i32_attr, FloatAttr f32_attr, ...); IntegerAttr i32_attr, FloatAttr f32_attr, ...);
// Each result-type/operand/attribute has a separate parameter. The parameters // Each result-type/operand/attribute has a separate parameter. The parameters
// for attributes are raw values unwrapped with mlir::Attribute instances. // for attributes are raw values unwrapped with mlir::Attribute instances.
// (Note that this builder will not always be generated. See the following // (Note that this builder will not always be generated. See the following
// explanation for more details.) // explanation for more details.)
static void build(Builder *odsBuilder, OperationState &odsState, static void build(OpBuilder &odsBuilder, OperationState &odsState,
Type i32_result, Type f32_result, ..., Type i32_result, Type f32_result, ...,
Value i32_operand, Value f32_operand, ..., Value i32_operand, Value f32_operand, ...,
APInt i32_attr, StringRef f32_attr, ...); APInt i32_attr, StringRef f32_attr, ...);
// Each operand/attribute has a separate parameter but result type is aggregate. // Each operand/attribute has a separate parameter but result type is aggregate.
static void build(Builder *odsBuilder, OperationState &odsState, static void build(OpBuilder &odsBuilder, OperationState &odsState,
ArrayRef<Type> resultTypes, ArrayRef<Type> resultTypes,
Value i32_operand, Value f32_operand, ..., Value i32_operand, Value f32_operand, ...,
IntegerAttr i32_attr, FloatAttr f32_attr, ...); IntegerAttr i32_attr, FloatAttr f32_attr, ...);
// All operands/attributes have aggregate parameters. // All operands/attributes have aggregate parameters.
// Generated if InferTypeOpInterface interface is specified. // Generated if InferTypeOpInterface interface is specified.
static void build(Builder *odsBuilder, OperationState &odsState, static void build(OpBuilder &odsBuilder, OperationState &odsState,
ValueRange operands, ValueRange operands,
ArrayRef<NamedAttribute> attributes); ArrayRef<NamedAttribute> attributes);
// (And manually specified builders depending on the specific op.) // (And manually specified builders depending on the specific op.)
``` ```
The first form provides basic uniformity so that we can create ops using the The first form provides basic uniformity so that we can create ops using the
same form regardless of the exact op. This is particularly useful for same form regardless of the exact op. This is particularly useful for
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
If we want to define a builder with a default value for the only attribute, we If we want to define a builder with a default value for the only attribute, we
can add into `MyOp`: can add into `MyOp`:
```tablegen ```tablegen
def MyOp : ... { def MyOp : ... {
... ...
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &state, float val = 0.5f", [{ OpBuilder<"OpBuilder &builder, OperationState &state, float val = 0.5f", [{
state.addAttribute("attr", builder->getF32FloatAttr(val)); state.addAttribute("attr", builder.getF32FloatAttr(val));
}]> }]>
]; ];
} }
``` ```
The generated builder will look like: The generated builder will look like:
```c++ ```c++
static void build(Builder *builder, OperationState &state, float val = 0.5f) { static void build(OpBuilder &builder, OperationState &state, float val = 0.5f) {
state.addAttribute("attr", builder->getF32FloatAttr(val)); state.addAttribute("attr", builder.getF32FloatAttr(val));
} }
``` ```
### Custom parser and printer methods ### Custom parser and printer methods
Functions to parse and print the operation's custom assembly form. Functions to parse and print the operation's custom assembly form.
### Custom verifier code ### Custom verifier code
▲ Show 20 Lines • Show All 758 Lines • Show Last 20 Lines

mlir/docs/Tutorials/Toy/Ch-2.md

Show First 20 Lines • Show All 470 Lines • ▼ Show 20 Lines
def ConstantOp : Toy_Op<"constant"> { def ConstantOp : Toy_Op<"constant"> {
... ...
// Add custom build methods for the constant operation. These methods populate // Add custom build methods for the constant operation. These methods populate
// the `state` that MLIR uses to create operations, i.e. these are used when // the `state` that MLIR uses to create operations, i.e. these are used when
// using `builder.create<ConstantOp>(...)`. // using `builder.create<ConstantOp>(...)`.
let builders = [ let builders = [
// Build a constant with a given constant tensor value. // Build a constant with a given constant tensor value.
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"DenseElementsAttr value", [{ "DenseElementsAttr value", [{
// Call into an autogenerated `build` method. // Call into an autogenerated `build` method.
build(builder, result, value.getType(), value); build(builder, result, value.getType(), value);
}]>, }]>,
// Build a constant with a given constant floating-point value. This builder // Build a constant with a given constant floating-point value. This builder
// creates a declaration for `ConstantOp::build` with the given parameters. // creates a declaration for `ConstantOp::build` with the given parameters.
OpBuilder<"Builder *builder, OperationState &result, double value"> OpBuilder<"OpBuilder &builder, OperationState &result, double value">
]; ];
} }
``` ```
#### Specifying a Custom Assembly Format #### Specifying a Custom Assembly Format
At this point we can generate our "Toy IR". For example, the following: At this point we can generate our "Toy IR". For example, the following:
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

mlir/examples/toy/Ch2/include/toy/Ops.td

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linesdef ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
let parser = [{ return ::parseConstantOp(parser, result); }]; let parser = [{ return ::parseConstantOp(parser, result); }];
let printer = [{ return ::print(p, *this); }]; let printer = [{ return ::print(p, *this); }];
// Add custom build methods for the constant operation. These method populates // Add custom build methods for the constant operation. These method populates
// the `state` that MLIR uses to create operations, i.e. these are used when // the `state` that MLIR uses to create operations, i.e. these are used when
// using `builder.create<ConstantOp>(...)`. // using `builder.create<ConstantOp>(...)`.
let builders = [ let builders = [
// Build a constant with a given constant tensor value. // Build a constant with a given constant tensor value.
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"DenseElementsAttr value", [{ "DenseElementsAttr value", [{
build(builder, state, value.getType(), value); build(builder, state, value.getType(), value);
}]>, }]>,
// Build a constant with a given constant floating-point value. // Build a constant with a given constant floating-point value.
OpBuilder<"Builder *builder, OperationState &state, double value"> OpBuilder<"OpBuilder &builder, OperationState &state, double value">
]; ];
// Invoke a static verify method to verify this constant operation. // Invoke a static verify method to verify this constant operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
def AddOp : Toy_Op<"add"> { def AddOp : Toy_Op<"add"> {
let summary = "element-wise addition operation"; let summary = "element-wise addition operation";
let description = [{ let description = [{
The "add" operation performs element-wise addition between two tensors. The "add" operation performs element-wise addition between two tensors.
The shapes of the tensor operands are expected to match. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building an AddOp with from the two input operands. // Allow building an AddOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def GenericCallOp : Toy_Op<"generic_call"> { def GenericCallOp : Toy_Op<"generic_call"> {
let summary = "generic call operation"; let summary = "generic call operation";
let description = [{ let description = [{
Generic calls represent calls to a user defined function that needs to Generic calls represent calls to a user defined function that needs to
be specialized for the shape of its arguments. The callee name is attached be specialized for the shape of its arguments. The callee name is attached
Show All 18 Linesdef GenericCallOp : Toy_Op<"generic_call"> {
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = [{ let assemblyFormat = [{
$callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results) $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
}]; }];
// Add custom build methods for the generic call operation. // Add custom build methods for the generic call operation.
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"StringRef callee, ArrayRef<Value> arguments"> "StringRef callee, ArrayRef<Value> arguments">
]; ];
} }
def MulOp : Toy_Op<"mul"> { def MulOp : Toy_Op<"mul"> {
let summary = "element-wise multiplication operation"; let summary = "element-wise multiplication operation";
let description = [{ let description = [{
The "mul" operation performs element-wise multiplication between two The "mul" operation performs element-wise multiplication between two
tensors. The shapes of the tensor operands are expected to match. tensors. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building a MulOp with from the two input operands. // Allow building a MulOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def PrintOp : Toy_Op<"print"> { def PrintOp : Toy_Op<"print"> {
let summary = "print operation"; let summary = "print operation";
let description = [{ let description = [{
The "print" builtin operation prints a given input tensor, and produces The "print" builtin operation prints a given input tensor, and produces
no results. no results.
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesdef ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
// value must match the return type of the enclosing function. // value must match the return type of the enclosing function.
let arguments = (ins Variadic<F64Tensor>:$input); let arguments = (ins Variadic<F64Tensor>:$input);
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = "($input^ `:` type($input))? attr-dict "; let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand. // Allow building a ReturnOp with no return operand.
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &state", [{ build(b, state, llvm::None); }] "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
>]; >];
// Provide extra utility definitions on the c++ operation class definition. // Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{ let extraClassDeclaration = [{
bool hasOperand() { return getNumOperands() != 0; } bool hasOperand() { return getNumOperands() != 0; }
}]; }];
// Invoke a static verify method to verify this return operation. // Invoke a static verify method to verify this return operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
def TransposeOp : Toy_Op<"transpose"> { def TransposeOp : Toy_Op<"transpose"> {
let summary = "transpose operation"; let summary = "transpose operation";
let arguments = (ins F64Tensor:$input); let arguments = (ins F64Tensor:$input);
let results = (outs F64Tensor); let results = (outs F64Tensor);
let assemblyFormat = [{ let assemblyFormat = [{
`(` $input `:` type($input) `)` attr-dict `to` type(results) `(` $input `:` type($input) `)` attr-dict `to` type(results)
}]; }];
// Allow building a TransposeOp with from the input operand. // Allow building a TransposeOp with from the input operand.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value input"> OpBuilder<"OpBuilder &b, OperationState &state, Value input">
]; ];
// Invoke a static verify method to verify this transpose operation. // Invoke a static verify method to verify this transpose operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
#endif // TOY_OPS #endif // TOY_OPS

mlir/examples/toy/Ch2/mlir/Dialect.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConstantOp // ConstantOp
/// Build a constant operation. /// Build a constant operation.
/// The builder is passed as an argument, so is the state that this method is /// The builder is passed as an argument, so is the state that this method is
/// expected to fill in order to build the operation. /// expected to fill in order to build the operation.
void ConstantOp::build(mlir::Builder *builder, mlir::OperationState &state, void ConstantOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
double value) { double value) {
auto dataType = RankedTensorType::get({}, builder->getF64Type()); auto dataType = RankedTensorType::get({}, builder.getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value); auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute); ConstantOp::build(builder, state, dataType, dataAttribute);
} }
/// The 'OpAsmPrinter' class provides a collection of methods for parsing /// The 'OpAsmPrinter' class provides a collection of methods for parsing
/// various punctuation, as well as attributes, operands, types, etc. Each of /// various punctuation, as well as attributes, operands, types, etc. Each of
/// these methods returns a `ParseResult`. This class is a wrapper around /// these methods returns a `ParseResult`. This class is a wrapper around
/// `LogicalResult` that can be converted to a boolean `true` value on failure, /// `LogicalResult` that can be converted to a boolean `true` value on failure,
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines for (int dim = 0, dimE = attrType.getRank(); dim < dimE; ++dim) {
} }
} }
return mlir::success(); return mlir::success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AddOp // AddOp
void AddOp::build(mlir::Builder *builder, mlir::OperationState &state, void AddOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
void GenericCallOp::build(mlir::Builder *builder, mlir::OperationState &state, void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
StringRef callee, ArrayRef<mlir::Value> arguments) { StringRef callee, ArrayRef<mlir::Value> arguments) {
// Generic call always returns an unranked Tensor initially. // Generic call always returns an unranked Tensor initially.
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(arguments); state.addOperands(arguments);
state.addAttribute("callee", builder->getSymbolRefAttr(callee)); state.addAttribute("callee", builder.getSymbolRefAttr(callee));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MulOp // MulOp
void MulOp::build(mlir::Builder *builder, mlir::OperationState &state, void MulOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ReturnOp // ReturnOp
static mlir::LogicalResult verify(ReturnOp op) { static mlir::LogicalResult verify(ReturnOp op) {
// We know that the parent operation is a function, because of the 'HasParent' // We know that the parent operation is a function, because of the 'HasParent'
Show All 28 Lines return op.emitError() << "type of return operand ("
<< *op.operand_type_begin() << *op.operand_type_begin()
<< ") doesn't match function result type (" << ") doesn't match function result type ("
<< results.front() << ")"; << results.front() << ")";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TransposeOp // TransposeOp
void TransposeOp::build(mlir::Builder *builder, mlir::OperationState &state, void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value value) { mlir::Value value) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(value); state.addOperands(value);
} }
static mlir::LogicalResult verify(TransposeOp op) { static mlir::LogicalResult verify(TransposeOp op) {
auto inputType = op.getOperand().getType().dyn_cast<RankedTensorType>(); auto inputType = op.getOperand().getType().dyn_cast<RankedTensorType>();
auto resultType = op.getType().dyn_cast<RankedTensorType>(); auto resultType = op.getType().dyn_cast<RankedTensorType>();
if (!inputType || !resultType) if (!inputType || !resultType)
return mlir::success(); return mlir::success();
Show All 16 Lines

mlir/examples/toy/Ch3/include/toy/Ops.td

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Linesdef ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
let parser = [{ return ::parseConstantOp(parser, result); }]; let parser = [{ return ::parseConstantOp(parser, result); }];
let printer = [{ return ::print(p, *this); }]; let printer = [{ return ::print(p, *this); }];
// Add custom build methods for the constant operation. These method populates // Add custom build methods for the constant operation. These method populates
// the `state` that MLIR uses to create operations, i.e. these are used when // the `state` that MLIR uses to create operations, i.e. these are used when
// using `builder.create<ConstantOp>(...)`. // using `builder.create<ConstantOp>(...)`.
let builders = [ let builders = [
// Build a constant with a given constant tensor value. // Build a constant with a given constant tensor value.
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"DenseElementsAttr value", [{ "DenseElementsAttr value", [{
build(builder, state, value.getType(), value); build(builder, state, value.getType(), value);
}]>, }]>,
// Build a constant with a given constant floating-point value. // Build a constant with a given constant floating-point value.
OpBuilder<"Builder *builder, OperationState &state, double value"> OpBuilder<"OpBuilder &builder, OperationState &state, double value">
]; ];
// Invoke a static verify method to verify this constant operation. // Invoke a static verify method to verify this constant operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
def AddOp : Toy_Op<"add", [NoSideEffect]> { def AddOp : Toy_Op<"add", [NoSideEffect]> {
let summary = "element-wise addition operation"; let summary = "element-wise addition operation";
let description = [{ let description = [{
The "add" operation performs element-wise addition between two tensors. The "add" operation performs element-wise addition between two tensors.
The shapes of the tensor operands are expected to match. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building an AddOp with from the two input operands. // Allow building an AddOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def GenericCallOp : Toy_Op<"generic_call"> { def GenericCallOp : Toy_Op<"generic_call"> {
let summary = "generic call operation"; let summary = "generic call operation";
let description = [{ let description = [{
Generic calls represent calls to a user defined function that needs to Generic calls represent calls to a user defined function that needs to
be specialized for the shape of its arguments. The callee name is attached be specialized for the shape of its arguments. The callee name is attached
Show All 18 Linesdef GenericCallOp : Toy_Op<"generic_call"> {
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = [{ let assemblyFormat = [{
$callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results) $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
}]; }];
// Add custom build methods for the generic call operation. // Add custom build methods for the generic call operation.
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"StringRef callee, ArrayRef<Value> arguments"> "StringRef callee, ArrayRef<Value> arguments">
]; ];
} }
def MulOp : Toy_Op<"mul", [NoSideEffect]> { def MulOp : Toy_Op<"mul", [NoSideEffect]> {
let summary = "element-wise multiplication operation"; let summary = "element-wise multiplication operation";
let description = [{ let description = [{
The "mul" operation performs element-wise multiplication between two The "mul" operation performs element-wise multiplication between two
tensors. The shapes of the tensor operands are expected to match. tensors. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building a MulOp with from the two input operands. // Allow building a MulOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def PrintOp : Toy_Op<"print"> { def PrintOp : Toy_Op<"print"> {
let summary = "print operation"; let summary = "print operation";
let description = [{ let description = [{
The "print" builtin operation prints a given input tensor, and produces The "print" builtin operation prints a given input tensor, and produces
no results. no results.
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesdef ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
// value must match the return type of the enclosing function. // value must match the return type of the enclosing function.
let arguments = (ins Variadic<F64Tensor>:$input); let arguments = (ins Variadic<F64Tensor>:$input);
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = "($input^ `:` type($input))? attr-dict "; let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand. // Allow building a ReturnOp with no return operand.
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &state", [{ build(b, state, llvm::None); }] "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
>]; >];
// Provide extra utility definitions on the c++ operation class definition. // Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{ let extraClassDeclaration = [{
bool hasOperand() { return getNumOperands() != 0; } bool hasOperand() { return getNumOperands() != 0; }
}]; }];
// Invoke a static verify method to verify this return operation. // Invoke a static verify method to verify this return operation.
Show All 10 Lines let assemblyFormat = [{
`(` $input `:` type($input) `)` attr-dict `to` type(results) `(` $input `:` type($input) `)` attr-dict `to` type(results)
}]; }];
// Enable registering canonicalization patterns with this operation. // Enable registering canonicalization patterns with this operation.
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
// Allow building a TransposeOp with from the input operand. // Allow building a TransposeOp with from the input operand.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value input"> OpBuilder<"OpBuilder &b, OperationState &state, Value input">
]; ];
// Invoke a static verify method to verify this transpose operation. // Invoke a static verify method to verify this transpose operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
#endif // TOY_OPS #endif // TOY_OPS

mlir/examples/toy/Ch3/mlir/Dialect.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConstantOp // ConstantOp
/// Build a constant operation. /// Build a constant operation.
/// The builder is passed as an argument, so is the state that this method is /// The builder is passed as an argument, so is the state that this method is
/// expected to fill in order to build the operation. /// expected to fill in order to build the operation.
void ConstantOp::build(mlir::Builder *builder, mlir::OperationState &state, void ConstantOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
double value) { double value) {
auto dataType = RankedTensorType::get({}, builder->getF64Type()); auto dataType = RankedTensorType::get({}, builder.getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value); auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute); ConstantOp::build(builder, state, dataType, dataAttribute);
} }
/// The 'OpAsmPrinter' class provides a collection of methods for parsing /// The 'OpAsmPrinter' class provides a collection of methods for parsing
/// various punctuation, as well as attributes, operands, types, etc. Each of /// various punctuation, as well as attributes, operands, types, etc. Each of
/// these methods returns a `ParseResult`. This class is a wrapper around /// these methods returns a `ParseResult`. This class is a wrapper around
/// `LogicalResult` that can be converted to a boolean `true` value on failure, /// `LogicalResult` that can be converted to a boolean `true` value on failure,
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines for (int dim = 0, dimE = attrType.getRank(); dim < dimE; ++dim) {
} }
} }
return mlir::success(); return mlir::success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AddOp // AddOp
void AddOp::build(mlir::Builder *builder, mlir::OperationState &state, void AddOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
void GenericCallOp::build(mlir::Builder *builder, mlir::OperationState &state, void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
StringRef callee, ArrayRef<mlir::Value> arguments) { StringRef callee, ArrayRef<mlir::Value> arguments) {
// Generic call always returns an unranked Tensor initially. // Generic call always returns an unranked Tensor initially.
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(arguments); state.addOperands(arguments);
state.addAttribute("callee", builder->getSymbolRefAttr(callee)); state.addAttribute("callee", builder.getSymbolRefAttr(callee));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MulOp // MulOp
void MulOp::build(mlir::Builder *builder, mlir::OperationState &state, void MulOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ReturnOp // ReturnOp
static mlir::LogicalResult verify(ReturnOp op) { static mlir::LogicalResult verify(ReturnOp op) {
// We know that the parent operation is a function, because of the 'HasParent' // We know that the parent operation is a function, because of the 'HasParent'
Show All 28 Lines return op.emitError() << "type of return operand ("
<< *op.operand_type_begin() << *op.operand_type_begin()
<< ") doesn't match function result type (" << ") doesn't match function result type ("
<< results.front() << ")"; << results.front() << ")";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TransposeOp // TransposeOp
void TransposeOp::build(mlir::Builder *builder, mlir::OperationState &state, void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value value) { mlir::Value value) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(value); state.addOperands(value);
} }
static mlir::LogicalResult verify(TransposeOp op) { static mlir::LogicalResult verify(TransposeOp op) {
auto inputType = op.getOperand().getType().dyn_cast<RankedTensorType>(); auto inputType = op.getOperand().getType().dyn_cast<RankedTensorType>();
auto resultType = op.getType().dyn_cast<RankedTensorType>(); auto resultType = op.getType().dyn_cast<RankedTensorType>();
if (!inputType || !resultType) if (!inputType || !resultType)
return mlir::success(); return mlir::success();
Show All 16 Lines

mlir/examples/toy/Ch4/include/toy/Ops.td

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesdef ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
let parser = [{ return ::parseConstantOp(parser, result); }]; let parser = [{ return ::parseConstantOp(parser, result); }];
let printer = [{ return ::print(p, *this); }]; let printer = [{ return ::print(p, *this); }];
// Add custom build methods for the constant operation. These method populates // Add custom build methods for the constant operation. These method populates
// the `state` that MLIR uses to create operations, i.e. these are used when // the `state` that MLIR uses to create operations, i.e. these are used when
// using `builder.create<ConstantOp>(...)`. // using `builder.create<ConstantOp>(...)`.
let builders = [ let builders = [
// Build a constant with a given constant tensor value. // Build a constant with a given constant tensor value.
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"DenseElementsAttr value", [{ "DenseElementsAttr value", [{
build(builder, state, value.getType(), value); build(builder, state, value.getType(), value);
}]>, }]>,
// Build a constant with a given constant floating-point value. // Build a constant with a given constant floating-point value.
OpBuilder<"Builder *builder, OperationState &state, double value"> OpBuilder<"OpBuilder &builder, OperationState &state, double value">
]; ];
// Invoke a static verify method to verify this constant operation. // Invoke a static verify method to verify this constant operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
def AddOp : Toy_Op<"add", def AddOp : Toy_Op<"add",
[NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> { [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
let summary = "element-wise addition operation"; let summary = "element-wise addition operation";
let description = [{ let description = [{
The "add" operation performs element-wise addition between two tensors. The "add" operation performs element-wise addition between two tensors.
The shapes of the tensor operands are expected to match. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building an AddOp with from the two input operands. // Allow building an AddOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def CastOp : Toy_Op<"cast", def CastOp : Toy_Op<"cast",
[DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect, [DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect,
SameOperandsAndResultShape]> { SameOperandsAndResultShape]> {
let summary = "shape cast operation"; let summary = "shape cast operation";
let description = [{ let description = [{
Show All 40 Linesdef GenericCallOp : Toy_Op<"generic_call",
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = [{ let assemblyFormat = [{
$callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results) $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
}]; }];
// Add custom build methods for the generic call operation. // Add custom build methods for the generic call operation.
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"StringRef callee, ArrayRef<Value> arguments"> "StringRef callee, ArrayRef<Value> arguments">
]; ];
} }
def MulOp : Toy_Op<"mul", def MulOp : Toy_Op<"mul",
[NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> { [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
let summary = "element-wise multiplication operation"; let summary = "element-wise multiplication operation";
let description = [{ let description = [{
The "mul" operation performs element-wise multiplication between two The "mul" operation performs element-wise multiplication between two
tensors. The shapes of the tensor operands are expected to match. tensors. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building a MulOp with from the two input operands. // Allow building a MulOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def PrintOp : Toy_Op<"print"> { def PrintOp : Toy_Op<"print"> {
let summary = "print operation"; let summary = "print operation";
let description = [{ let description = [{
The "print" builtin operation prints a given input tensor, and produces The "print" builtin operation prints a given input tensor, and produces
no results. no results.
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesdef ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
// value must match the return type of the enclosing function. // value must match the return type of the enclosing function.
let arguments = (ins Variadic<F64Tensor>:$input); let arguments = (ins Variadic<F64Tensor>:$input);
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = "($input^ `:` type($input))? attr-dict "; let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand. // Allow building a ReturnOp with no return operand.
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &state", [{ build(b, state, llvm::None); }] "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
>]; >];
// Provide extra utility definitions on the c++ operation class definition. // Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{ let extraClassDeclaration = [{
bool hasOperand() { return getNumOperands() != 0; } bool hasOperand() { return getNumOperands() != 0; }
}]; }];
// Invoke a static verify method to verify this return operation. // Invoke a static verify method to verify this return operation.
Show All 11 Lines let assemblyFormat = [{
`(` $input `:` type($input) `)` attr-dict `to` type(results) `(` $input `:` type($input) `)` attr-dict `to` type(results)
}]; }];
// Enable registering canonicalization patterns with this operation. // Enable registering canonicalization patterns with this operation.
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
// Allow building a TransposeOp with from the input operand. // Allow building a TransposeOp with from the input operand.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value input"> OpBuilder<"OpBuilder &b, OperationState &state, Value input">
]; ];
// Invoke a static verify method to verify this transpose operation. // Invoke a static verify method to verify this transpose operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
#endif // TOY_OPS #endif // TOY_OPS

mlir/examples/toy/Ch4/mlir/Dialect.cpp

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConstantOp // ConstantOp
/// Build a constant operation. /// Build a constant operation.
/// The builder is passed as an argument, so is the state that this method is /// The builder is passed as an argument, so is the state that this method is
/// expected to fill in order to build the operation. /// expected to fill in order to build the operation.
void ConstantOp::build(mlir::Builder *builder, mlir::OperationState &state, void ConstantOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
double value) { double value) {
auto dataType = RankedTensorType::get({}, builder->getF64Type()); auto dataType = RankedTensorType::get({}, builder.getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value); auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute); ConstantOp::build(builder, state, dataType, dataAttribute);
} }
/// The 'OpAsmPrinter' class provides a collection of methods for parsing /// The 'OpAsmPrinter' class provides a collection of methods for parsing
/// various punctuation, as well as attributes, operands, types, etc. Each of /// various punctuation, as well as attributes, operands, types, etc. Each of
/// these methods returns a `ParseResult`. This class is a wrapper around /// these methods returns a `ParseResult`. This class is a wrapper around
/// `LogicalResult` that can be converted to a boolean `true` value on failure, /// `LogicalResult` that can be converted to a boolean `true` value on failure,
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines for (int dim = 0, dimE = attrType.getRank(); dim < dimE; ++dim) {
} }
} }
return mlir::success(); return mlir::success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AddOp // AddOp
void AddOp::build(mlir::Builder *builder, mlir::OperationState &state, void AddOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
/// Infer the output shape of the AddOp, this is required by the shape inference /// Infer the output shape of the AddOp, this is required by the shape inference
/// interface. /// interface.
void AddOp::inferShapes() { getResult().setType(getOperand(0).getType()); } void AddOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CastOp // CastOp
/// Infer the output shape of the CastOp, this is required by the shape /// Infer the output shape of the CastOp, this is required by the shape
/// inference interface. /// inference interface.
void CastOp::inferShapes() { getResult().setType(getOperand().getType()); } void CastOp::inferShapes() { getResult().setType(getOperand().getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
void GenericCallOp::build(mlir::Builder *builder, mlir::OperationState &state, void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
StringRef callee, ArrayRef<mlir::Value> arguments) { StringRef callee, ArrayRef<mlir::Value> arguments) {
// Generic call always returns an unranked Tensor initially. // Generic call always returns an unranked Tensor initially.
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(arguments); state.addOperands(arguments);
state.addAttribute("callee", builder->getSymbolRefAttr(callee)); state.addAttribute("callee", builder.getSymbolRefAttr(callee));
} }
/// Return the callee of the generic call operation, this is required by the /// Return the callee of the generic call operation, this is required by the
/// call interface. /// call interface.
CallInterfaceCallable GenericCallOp::getCallableForCallee() { CallInterfaceCallable GenericCallOp::getCallableForCallee() {
return getAttrOfType<SymbolRefAttr>("callee"); return getAttrOfType<SymbolRefAttr>("callee");
} }
/// Get the argument operands to the called function, this is required by the /// Get the argument operands to the called function, this is required by the
/// call interface. /// call interface.
Operation::operand_range GenericCallOp::getArgOperands() { return inputs(); } Operation::operand_range GenericCallOp::getArgOperands() { return inputs(); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MulOp // MulOp
void MulOp::build(mlir::Builder *builder, mlir::OperationState &state, void MulOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
/// Infer the output shape of the MulOp, this is required by the shape inference /// Infer the output shape of the MulOp, this is required by the shape inference
/// interface. /// interface.
void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); } void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 32 Lines return op.emitError() << "type of return operand ("
<< *op.operand_type_begin() << *op.operand_type_begin()
<< ") doesn't match function result type (" << ") doesn't match function result type ("
<< results.front() << ")"; << results.front() << ")";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TransposeOp // TransposeOp
void TransposeOp::build(mlir::Builder *builder, mlir::OperationState &state, void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value value) { mlir::Value value) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(value); state.addOperands(value);
} }
void TransposeOp::inferShapes() { void TransposeOp::inferShapes() {
auto arrayTy = getOperand().getType().cast<RankedTensorType>(); auto arrayTy = getOperand().getType().cast<RankedTensorType>();
SmallVector<int64_t, 2> dims(llvm::reverse(arrayTy.getShape())); SmallVector<int64_t, 2> dims(llvm::reverse(arrayTy.getShape()));
getResult().setType(RankedTensorType::get(dims, arrayTy.getElementType())); getResult().setType(RankedTensorType::get(dims, arrayTy.getElementType()));
} }
Show All 22 Lines

mlir/examples/toy/Ch5/include/toy/Ops.td

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesdef ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
let parser = [{ return ::parseConstantOp(parser, result); }]; let parser = [{ return ::parseConstantOp(parser, result); }];
let printer = [{ return ::print(p, *this); }]; let printer = [{ return ::print(p, *this); }];
// Add custom build methods for the constant operation. These method populates // Add custom build methods for the constant operation. These method populates
// the `state` that MLIR uses to create operations, i.e. these are used when // the `state` that MLIR uses to create operations, i.e. these are used when
// using `builder.create<ConstantOp>(...)`. // using `builder.create<ConstantOp>(...)`.
let builders = [ let builders = [
// Build a constant with a given constant tensor value. // Build a constant with a given constant tensor value.
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"DenseElementsAttr value", [{ "DenseElementsAttr value", [{
build(builder, state, value.getType(), value); build(builder, state, value.getType(), value);
}]>, }]>,
// Build a constant with a given constant floating-point value. // Build a constant with a given constant floating-point value.
OpBuilder<"Builder *builder, OperationState &state, double value"> OpBuilder<"OpBuilder &builder, OperationState &state, double value">
]; ];
// Invoke a static verify method to verify this constant operation. // Invoke a static verify method to verify this constant operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
def AddOp : Toy_Op<"add", def AddOp : Toy_Op<"add",
[NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> { [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
let summary = "element-wise addition operation"; let summary = "element-wise addition operation";
let description = [{ let description = [{
The "add" operation performs element-wise addition between two tensors. The "add" operation performs element-wise addition between two tensors.
The shapes of the tensor operands are expected to match. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building an AddOp with from the two input operands. // Allow building an AddOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def CastOp : Toy_Op<"cast", def CastOp : Toy_Op<"cast",
[DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect, [DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect,
SameOperandsAndResultShape]> { SameOperandsAndResultShape]> {
let summary = "shape cast operation"; let summary = "shape cast operation";
let description = [{ let description = [{
Show All 40 Linesdef GenericCallOp : Toy_Op<"generic_call",
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = [{ let assemblyFormat = [{
$callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results) $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
}]; }];
// Add custom build methods for the generic call operation. // Add custom build methods for the generic call operation.
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"StringRef callee, ArrayRef<Value> arguments"> "StringRef callee, ArrayRef<Value> arguments">
]; ];
} }
def MulOp : Toy_Op<"mul", def MulOp : Toy_Op<"mul",
[NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> { [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
let summary = "element-wise multiplication operation"; let summary = "element-wise multiplication operation";
let description = [{ let description = [{
The "mul" operation performs element-wise multiplication between two The "mul" operation performs element-wise multiplication between two
tensors. The shapes of the tensor operands are expected to match. tensors. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building a MulOp with from the two input operands. // Allow building a MulOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def PrintOp : Toy_Op<"print"> { def PrintOp : Toy_Op<"print"> {
let summary = "print operation"; let summary = "print operation";
let description = [{ let description = [{
The "print" builtin operation prints a given input tensor, and produces The "print" builtin operation prints a given input tensor, and produces
no results. no results.
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Linesdef ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
// value must match the return type of the enclosing function. // value must match the return type of the enclosing function.
let arguments = (ins Variadic<F64Tensor>:$input); let arguments = (ins Variadic<F64Tensor>:$input);
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = "($input^ `:` type($input))? attr-dict "; let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand. // Allow building a ReturnOp with no return operand.
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &state", [{ build(b, state, llvm::None); }] "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
>]; >];
// Provide extra utility definitions on the c++ operation class definition. // Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{ let extraClassDeclaration = [{
bool hasOperand() { return getNumOperands() != 0; } bool hasOperand() { return getNumOperands() != 0; }
}]; }];
// Invoke a static verify method to verify this return operation. // Invoke a static verify method to verify this return operation.
Show All 11 Lines let assemblyFormat = [{
`(` $input `:` type($input) `)` attr-dict `to` type(results) `(` $input `:` type($input) `)` attr-dict `to` type(results)
}]; }];
// Enable registering canonicalization patterns with this operation. // Enable registering canonicalization patterns with this operation.
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
// Allow building a TransposeOp with from the input operand. // Allow building a TransposeOp with from the input operand.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value input"> OpBuilder<"OpBuilder &b, OperationState &state, Value input">
]; ];
// Invoke a static verify method to verify this transpose operation. // Invoke a static verify method to verify this transpose operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
#endif // TOY_OPS #endif // TOY_OPS

mlir/examples/toy/Ch5/mlir/Dialect.cpp

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConstantOp // ConstantOp
/// Build a constant operation. /// Build a constant operation.
/// The builder is passed as an argument, so is the state that this method is /// The builder is passed as an argument, so is the state that this method is
/// expected to fill in order to build the operation. /// expected to fill in order to build the operation.
void ConstantOp::build(mlir::Builder *builder, mlir::OperationState &state, void ConstantOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
double value) { double value) {
auto dataType = RankedTensorType::get({}, builder->getF64Type()); auto dataType = RankedTensorType::get({}, builder.getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value); auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute); ConstantOp::build(builder, state, dataType, dataAttribute);
} }
/// The 'OpAsmPrinter' class provides a collection of methods for parsing /// The 'OpAsmPrinter' class provides a collection of methods for parsing
/// various punctuation, as well as attributes, operands, types, etc. Each of /// various punctuation, as well as attributes, operands, types, etc. Each of
/// these methods returns a `ParseResult`. This class is a wrapper around /// these methods returns a `ParseResult`. This class is a wrapper around
/// `LogicalResult` that can be converted to a boolean `true` value on failure, /// `LogicalResult` that can be converted to a boolean `true` value on failure,
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines for (int dim = 0, dimE = attrType.getRank(); dim < dimE; ++dim) {
} }
} }
return mlir::success(); return mlir::success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AddOp // AddOp
void AddOp::build(mlir::Builder *builder, mlir::OperationState &state, void AddOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
/// Infer the output shape of the AddOp, this is required by the shape inference /// Infer the output shape of the AddOp, this is required by the shape inference
/// interface. /// interface.
void AddOp::inferShapes() { getResult().setType(getOperand(0).getType()); } void AddOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CastOp // CastOp
/// Infer the output shape of the CastOp, this is required by the shape /// Infer the output shape of the CastOp, this is required by the shape
/// inference interface. /// inference interface.
void CastOp::inferShapes() { getResult().setType(getOperand().getType()); } void CastOp::inferShapes() { getResult().setType(getOperand().getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
void GenericCallOp::build(mlir::Builder *builder, mlir::OperationState &state, void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
StringRef callee, ArrayRef<mlir::Value> arguments) { StringRef callee, ArrayRef<mlir::Value> arguments) {
// Generic call always returns an unranked Tensor initially. // Generic call always returns an unranked Tensor initially.
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(arguments); state.addOperands(arguments);
state.addAttribute("callee", builder->getSymbolRefAttr(callee)); state.addAttribute("callee", builder.getSymbolRefAttr(callee));
} }
/// Return the callee of the generic call operation, this is required by the /// Return the callee of the generic call operation, this is required by the
/// call interface. /// call interface.
CallInterfaceCallable GenericCallOp::getCallableForCallee() { CallInterfaceCallable GenericCallOp::getCallableForCallee() {
return getAttrOfType<SymbolRefAttr>("callee"); return getAttrOfType<SymbolRefAttr>("callee");
} }
/// Get the argument operands to the called function, this is required by the /// Get the argument operands to the called function, this is required by the
/// call interface. /// call interface.
Operation::operand_range GenericCallOp::getArgOperands() { return inputs(); } Operation::operand_range GenericCallOp::getArgOperands() { return inputs(); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MulOp // MulOp
void MulOp::build(mlir::Builder *builder, mlir::OperationState &state, void MulOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
/// Infer the output shape of the MulOp, this is required by the shape inference /// Infer the output shape of the MulOp, this is required by the shape inference
/// interface. /// interface.
void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); } void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 32 Lines return op.emitError() << "type of return operand ("
<< *op.operand_type_begin() << *op.operand_type_begin()
<< ") doesn't match function result type (" << ") doesn't match function result type ("
<< results.front() << ")"; << results.front() << ")";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TransposeOp // TransposeOp
void TransposeOp::build(mlir::Builder *builder, mlir::OperationState &state, void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value value) { mlir::Value value) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(value); state.addOperands(value);
} }
void TransposeOp::inferShapes() { void TransposeOp::inferShapes() {
auto arrayTy = getOperand().getType().cast<RankedTensorType>(); auto arrayTy = getOperand().getType().cast<RankedTensorType>();
SmallVector<int64_t, 2> dims(llvm::reverse(arrayTy.getShape())); SmallVector<int64_t, 2> dims(llvm::reverse(arrayTy.getShape()));
getResult().setType(RankedTensorType::get(dims, arrayTy.getElementType())); getResult().setType(RankedTensorType::get(dims, arrayTy.getElementType()));
} }
Show All 22 Lines

mlir/examples/toy/Ch6/include/toy/Ops.td

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesdef ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
let parser = [{ return ::parseConstantOp(parser, result); }]; let parser = [{ return ::parseConstantOp(parser, result); }];
let printer = [{ return ::print(p, *this); }]; let printer = [{ return ::print(p, *this); }];
// Add custom build methods for the constant operation. These method populates // Add custom build methods for the constant operation. These method populates
// the `state` that MLIR uses to create operations, i.e. these are used when // the `state` that MLIR uses to create operations, i.e. these are used when
// using `builder.create<ConstantOp>(...)`. // using `builder.create<ConstantOp>(...)`.
let builders = [ let builders = [
// Build a constant with a given constant tensor value. // Build a constant with a given constant tensor value.
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"DenseElementsAttr value", [{ "DenseElementsAttr value", [{
build(builder, state, value.getType(), value); build(builder, state, value.getType(), value);
}]>, }]>,
// Build a constant with a given constant floating-point value. // Build a constant with a given constant floating-point value.
OpBuilder<"Builder *builder, OperationState &state, double value"> OpBuilder<"OpBuilder &builder, OperationState &state, double value">
]; ];
// Invoke a static verify method to verify this constant operation. // Invoke a static verify method to verify this constant operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
def AddOp : Toy_Op<"add", def AddOp : Toy_Op<"add",
[NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> { [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
let summary = "element-wise addition operation"; let summary = "element-wise addition operation";
let description = [{ let description = [{
The "add" operation performs element-wise addition between two tensors. The "add" operation performs element-wise addition between two tensors.
The shapes of the tensor operands are expected to match. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building an AddOp with from the two input operands. // Allow building an AddOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def CastOp : Toy_Op<"cast", def CastOp : Toy_Op<"cast",
[DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect, [DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect,
SameOperandsAndResultShape]> { SameOperandsAndResultShape]> {
let summary = "shape cast operation"; let summary = "shape cast operation";
let description = [{ let description = [{
Show All 40 Linesdef GenericCallOp : Toy_Op<"generic_call",
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = [{ let assemblyFormat = [{
$callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results) $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
}]; }];
// Add custom build methods for the generic call operation. // Add custom build methods for the generic call operation.
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"StringRef callee, ArrayRef<Value> arguments"> "StringRef callee, ArrayRef<Value> arguments">
]; ];
} }
def MulOp : Toy_Op<"mul", def MulOp : Toy_Op<"mul",
[NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> { [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
let summary = "element-wise multiplication operation"; let summary = "element-wise multiplication operation";
let description = [{ let description = [{
The "mul" operation performs element-wise multiplication between two The "mul" operation performs element-wise multiplication between two
tensors. The shapes of the tensor operands are expected to match. tensors. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building a MulOp with from the two input operands. // Allow building a MulOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def PrintOp : Toy_Op<"print"> { def PrintOp : Toy_Op<"print"> {
let summary = "print operation"; let summary = "print operation";
let description = [{ let description = [{
The "print" builtin operation prints a given input tensor, and produces The "print" builtin operation prints a given input tensor, and produces
no results. no results.
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Linesdef ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
// value must match the return type of the enclosing function. // value must match the return type of the enclosing function.
let arguments = (ins Variadic<F64Tensor>:$input); let arguments = (ins Variadic<F64Tensor>:$input);
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = "($input^ `:` type($input))? attr-dict "; let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand. // Allow building a ReturnOp with no return operand.
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &state", [{ build(b, state, llvm::None); }] "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
>]; >];
// Provide extra utility definitions on the c++ operation class definition. // Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{ let extraClassDeclaration = [{
bool hasOperand() { return getNumOperands() != 0; } bool hasOperand() { return getNumOperands() != 0; }
}]; }];
// Invoke a static verify method to verify this return operation. // Invoke a static verify method to verify this return operation.
Show All 11 Lines let assemblyFormat = [{
`(` $input `:` type($input) `)` attr-dict `to` type(results) `(` $input `:` type($input) `)` attr-dict `to` type(results)
}]; }];
// Enable registering canonicalization patterns with this operation. // Enable registering canonicalization patterns with this operation.
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
// Allow building a TransposeOp with from the input operand. // Allow building a TransposeOp with from the input operand.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value input"> OpBuilder<"OpBuilder &b, OperationState &state, Value input">
]; ];
// Invoke a static verify method to verify this transpose operation. // Invoke a static verify method to verify this transpose operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
#endif // TOY_OPS #endif // TOY_OPS

mlir/examples/toy/Ch6/mlir/Dialect.cpp

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConstantOp // ConstantOp
/// Build a constant operation. /// Build a constant operation.
/// The builder is passed as an argument, so is the state that this method is /// The builder is passed as an argument, so is the state that this method is
/// expected to fill in order to build the operation. /// expected to fill in order to build the operation.
void ConstantOp::build(mlir::Builder *builder, mlir::OperationState &state, void ConstantOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
double value) { double value) {
auto dataType = RankedTensorType::get({}, builder->getF64Type()); auto dataType = RankedTensorType::get({}, builder.getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value); auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute); ConstantOp::build(builder, state, dataType, dataAttribute);
} }
/// The 'OpAsmPrinter' class provides a collection of methods for parsing /// The 'OpAsmPrinter' class provides a collection of methods for parsing
/// various punctuation, as well as attributes, operands, types, etc. Each of /// various punctuation, as well as attributes, operands, types, etc. Each of
/// these methods returns a `ParseResult`. This class is a wrapper around /// these methods returns a `ParseResult`. This class is a wrapper around
/// `LogicalResult` that can be converted to a boolean `true` value on failure, /// `LogicalResult` that can be converted to a boolean `true` value on failure,
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines for (int dim = 0, dimE = attrType.getRank(); dim < dimE; ++dim) {
} }
} }
return mlir::success(); return mlir::success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AddOp // AddOp
void AddOp::build(mlir::Builder *builder, mlir::OperationState &state, void AddOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
/// Infer the output shape of the AddOp, this is required by the shape inference /// Infer the output shape of the AddOp, this is required by the shape inference
/// interface. /// interface.
void AddOp::inferShapes() { getResult().setType(getOperand(0).getType()); } void AddOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CastOp // CastOp
/// Infer the output shape of the CastOp, this is required by the shape /// Infer the output shape of the CastOp, this is required by the shape
/// inference interface. /// inference interface.
void CastOp::inferShapes() { getResult().setType(getOperand().getType()); } void CastOp::inferShapes() { getResult().setType(getOperand().getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
void GenericCallOp::build(mlir::Builder *builder, mlir::OperationState &state, void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
StringRef callee, ArrayRef<mlir::Value> arguments) { StringRef callee, ArrayRef<mlir::Value> arguments) {
// Generic call always returns an unranked Tensor initially. // Generic call always returns an unranked Tensor initially.
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(arguments); state.addOperands(arguments);
state.addAttribute("callee", builder->getSymbolRefAttr(callee)); state.addAttribute("callee", builder.getSymbolRefAttr(callee));
} }
/// Return the callee of the generic call operation, this is required by the /// Return the callee of the generic call operation, this is required by the
/// call interface. /// call interface.
CallInterfaceCallable GenericCallOp::getCallableForCallee() { CallInterfaceCallable GenericCallOp::getCallableForCallee() {
return getAttrOfType<SymbolRefAttr>("callee"); return getAttrOfType<SymbolRefAttr>("callee");
} }
/// Get the argument operands to the called function, this is required by the /// Get the argument operands to the called function, this is required by the
/// call interface. /// call interface.
Operation::operand_range GenericCallOp::getArgOperands() { return inputs(); } Operation::operand_range GenericCallOp::getArgOperands() { return inputs(); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MulOp // MulOp
void MulOp::build(mlir::Builder *builder, mlir::OperationState &state, void MulOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
/// Infer the output shape of the MulOp, this is required by the shape inference /// Infer the output shape of the MulOp, this is required by the shape inference
/// interface. /// interface.
void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); } void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 32 Lines return op.emitError() << "type of return operand ("
<< *op.operand_type_begin() << *op.operand_type_begin()
<< ") doesn't match function result type (" << ") doesn't match function result type ("
<< results.front() << ")"; << results.front() << ")";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TransposeOp // TransposeOp
void TransposeOp::build(mlir::Builder *builder, mlir::OperationState &state, void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value value) { mlir::Value value) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(value); state.addOperands(value);
} }
void TransposeOp::inferShapes() { void TransposeOp::inferShapes() {
auto arrayTy = getOperand().getType().cast<RankedTensorType>(); auto arrayTy = getOperand().getType().cast<RankedTensorType>();
SmallVector<int64_t, 2> dims(llvm::reverse(arrayTy.getShape())); SmallVector<int64_t, 2> dims(llvm::reverse(arrayTy.getShape()));
getResult().setType(RankedTensorType::get(dims, arrayTy.getElementType())); getResult().setType(RankedTensorType::get(dims, arrayTy.getElementType()));
} }
Show All 22 Lines

mlir/examples/toy/Ch7/include/toy/Ops.td

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Linesdef ConstantOp : Toy_Op<"constant",
let parser = [{ return ::parseConstantOp(parser, result); }]; let parser = [{ return ::parseConstantOp(parser, result); }];
let printer = [{ return ::print(p, *this); }]; let printer = [{ return ::print(p, *this); }];
// Add custom build methods for the constant operation. These method populates // Add custom build methods for the constant operation. These method populates
// the `state` that MLIR uses to create operations, i.e. these are used when // the `state` that MLIR uses to create operations, i.e. these are used when
// using `builder.create<ConstantOp>(...)`. // using `builder.create<ConstantOp>(...)`.
let builders = [ let builders = [
// Build a constant with a given constant tensor value. // Build a constant with a given constant tensor value.
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"DenseElementsAttr value", [{ "DenseElementsAttr value", [{
build(builder, state, value.getType(), value); build(builder, state, value.getType(), value);
}]>, }]>,
// Build a constant with a given constant floating-point value. // Build a constant with a given constant floating-point value.
OpBuilder<"Builder *builder, OperationState &state, double value"> OpBuilder<"OpBuilder &builder, OperationState &state, double value">
]; ];
// Invoke a static verify method to verify this constant operation. // Invoke a static verify method to verify this constant operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
// Set the folder bit so that we can implement constant folders. // Set the folder bit so that we can implement constant folders.
let hasFolder = 1; let hasFolder = 1;
} }
Show All 10 Linesdef AddOp : Toy_Op<"add",
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building an AddOp with from the two input operands. // Allow building an AddOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def CastOp : Toy_Op<"cast", def CastOp : Toy_Op<"cast",
[DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect, [DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect,
SameOperandsAndResultShape]> { SameOperandsAndResultShape]> {
let summary = "shape cast operation"; let summary = "shape cast operation";
let description = [{ let description = [{
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesdef GenericCallOp : Toy_Op<"generic_call",
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = [{ let assemblyFormat = [{
$callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results) $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
}]; }];
// Add custom build methods for the generic call operation. // Add custom build methods for the generic call operation.
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"StringRef callee, ArrayRef<Value> arguments"> "StringRef callee, ArrayRef<Value> arguments">
]; ];
} }
def MulOp : Toy_Op<"mul", def MulOp : Toy_Op<"mul",
[NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> { [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
let summary = "element-wise multiplication operation"; let summary = "element-wise multiplication operation";
let description = [{ let description = [{
The "mul" operation performs element-wise multiplication between two The "mul" operation performs element-wise multiplication between two
tensors. The shapes of the tensor operands are expected to match. tensors. The shapes of the tensor operands are expected to match.
}]; }];
let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs); let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
let results = (outs F64Tensor); let results = (outs F64Tensor);
// Specify a parser and printer method. // Specify a parser and printer method.
let parser = [{ return ::parseBinaryOp(parser, result); }]; let parser = [{ return ::parseBinaryOp(parser, result); }];
let printer = [{ return ::printBinaryOp(p, *this); }]; let printer = [{ return ::printBinaryOp(p, *this); }];
// Allow building a MulOp with from the two input operands. // Allow building a MulOp with from the two input operands.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value lhs, Value rhs"> OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
]; ];
} }
def PrintOp : Toy_Op<"print"> { def PrintOp : Toy_Op<"print"> {
let summary = "print operation"; let summary = "print operation";
let description = [{ let description = [{
The "print" builtin operation prints a given input tensor, and produces The "print" builtin operation prints a given input tensor, and produces
no results. no results.
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Linesdef ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
// value must match the return type of the enclosing function. // value must match the return type of the enclosing function.
let arguments = (ins Variadic<Toy_Type>:$input); let arguments = (ins Variadic<Toy_Type>:$input);
// The return operation only emits the input in the format if it is present. // The return operation only emits the input in the format if it is present.
let assemblyFormat = "($input^ `:` type($input))? attr-dict "; let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand. // Allow building a ReturnOp with no return operand.
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &state", [{ build(b, state, llvm::None); }] "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
>]; >];
// Provide extra utility definitions on the c++ operation class definition. // Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{ let extraClassDeclaration = [{
bool hasOperand() { return getNumOperands() != 0; } bool hasOperand() { return getNumOperands() != 0; }
}]; }];
// Invoke a static verify method to verify this return operation. // Invoke a static verify method to verify this return operation.
Show All 10 Linesdef StructAccessOp : Toy_Op<"struct_access", [NoSideEffect]> {
let results = (outs Toy_Type:$output); let results = (outs Toy_Type:$output);
let assemblyFormat = [{ let assemblyFormat = [{
$input `[` $index `]` attr-dict `:` type($input) `->` type($output) $input `[` $index `]` attr-dict `:` type($input) `->` type($output)
}]; }];
// Allow building a StructAccessOp with just a struct value and an index. // Allow building a StructAccessOp with just a struct value and an index.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value input, size_t index"> OpBuilder<"OpBuilder &b, OperationState &state, Value input, size_t index">
]; ];
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
// Set the folder bit so that we can fold constant accesses. // Set the folder bit so that we can fold constant accesses.
let hasFolder = 1; let hasFolder = 1;
} }
Show All 31 Lines let assemblyFormat = [{
`(` $input `:` type($input) `)` attr-dict `to` type(results) `(` $input `:` type($input) `)` attr-dict `to` type(results)
}]; }];
// Enable registering canonicalization patterns with this operation. // Enable registering canonicalization patterns with this operation.
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
// Allow building a TransposeOp with from the input operand. // Allow building a TransposeOp with from the input operand.
let builders = [ let builders = [
OpBuilder<"Builder *b, OperationState &state, Value input"> OpBuilder<"OpBuilder &b, OperationState &state, Value input">
]; ];
// Invoke a static verify method to verify this transpose operation. // Invoke a static verify method to verify this transpose operation.
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
#endif // TOY_OPS #endif // TOY_OPS

mlir/examples/toy/Ch7/mlir/Dialect.cpp

Show First 20 Lines • Show All 148 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConstantOp // ConstantOp
/// Build a constant operation. /// Build a constant operation.
/// The builder is passed as an argument, so is the state that this method is /// The builder is passed as an argument, so is the state that this method is
/// expected to fill in order to build the operation. /// expected to fill in order to build the operation.
void ConstantOp::build(mlir::Builder *builder, mlir::OperationState &state, void ConstantOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
double value) { double value) {
auto dataType = RankedTensorType::get({}, builder->getF64Type()); auto dataType = RankedTensorType::get({}, builder.getF64Type());
auto dataAttribute = DenseElementsAttr::get(dataType, value); auto dataAttribute = DenseElementsAttr::get(dataType, value);
ConstantOp::build(builder, state, dataType, dataAttribute); ConstantOp::build(builder, state, dataType, dataAttribute);
} }
/// The 'OpAsmPrinter' class provides a collection of methods for parsing /// The 'OpAsmPrinter' class provides a collection of methods for parsing
/// various punctuation, as well as attributes, operands, types, etc. Each of /// various punctuation, as well as attributes, operands, types, etc. Each of
/// these methods returns a `ParseResult`. This class is a wrapper around /// these methods returns a `ParseResult`. This class is a wrapper around
/// `LogicalResult` that can be converted to a boolean `true` value on failure, /// `LogicalResult` that can be converted to a boolean `true` value on failure,
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines
/// Infer the output shape of the ConstantOp, this is required by the shape /// Infer the output shape of the ConstantOp, this is required by the shape
/// inference interface. /// inference interface.
void ConstantOp::inferShapes() { getResult().setType(value().getType()); } void ConstantOp::inferShapes() { getResult().setType(value().getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AddOp // AddOp
void AddOp::build(mlir::Builder *builder, mlir::OperationState &state, void AddOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
/// Infer the output shape of the AddOp, this is required by the shape inference /// Infer the output shape of the AddOp, this is required by the shape inference
/// interface. /// interface.
void AddOp::inferShapes() { getResult().setType(getOperand(0).getType()); } void AddOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CastOp // CastOp
/// Infer the output shape of the CastOp, this is required by the shape /// Infer the output shape of the CastOp, this is required by the shape
/// inference interface. /// inference interface.
void CastOp::inferShapes() { getResult().setType(getOperand().getType()); } void CastOp::inferShapes() { getResult().setType(getOperand().getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericCallOp // GenericCallOp
void GenericCallOp::build(mlir::Builder *builder, mlir::OperationState &state, void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
StringRef callee, ArrayRef<mlir::Value> arguments) { StringRef callee, ArrayRef<mlir::Value> arguments) {
// Generic call always returns an unranked Tensor initially. // Generic call always returns an unranked Tensor initially.
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(arguments); state.addOperands(arguments);
state.addAttribute("callee", builder->getSymbolRefAttr(callee)); state.addAttribute("callee", builder.getSymbolRefAttr(callee));
} }
/// Return the callee of the generic call operation, this is required by the /// Return the callee of the generic call operation, this is required by the
/// call interface. /// call interface.
CallInterfaceCallable GenericCallOp::getCallableForCallee() { CallInterfaceCallable GenericCallOp::getCallableForCallee() {
return getAttrOfType<SymbolRefAttr>("callee"); return getAttrOfType<SymbolRefAttr>("callee");
} }
/// Get the argument operands to the called function, this is required by the /// Get the argument operands to the called function, this is required by the
/// call interface. /// call interface.
Operation::operand_range GenericCallOp::getArgOperands() { return inputs(); } Operation::operand_range GenericCallOp::getArgOperands() { return inputs(); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MulOp // MulOp
void MulOp::build(mlir::Builder *builder, mlir::OperationState &state, void MulOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value lhs, mlir::Value rhs) { mlir::Value lhs, mlir::Value rhs) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands({lhs, rhs}); state.addOperands({lhs, rhs});
} }
/// Infer the output shape of the MulOp, this is required by the shape inference /// Infer the output shape of the MulOp, this is required by the shape inference
/// interface. /// interface.
void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); } void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 32 Lines return op.emitError() << "type of return operand ("
<< *op.operand_type_begin() << *op.operand_type_begin()
<< ") doesn't match function result type (" << ") doesn't match function result type ("
<< results.front() << ")"; << results.front() << ")";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// StructAccessOp // StructAccessOp
void StructAccessOp::build(mlir::Builder *b, mlir::OperationState &state, void StructAccessOp::build(mlir::OpBuilder &b, mlir::OperationState &state,
mlir::Value input, size_t index) { mlir::Value input, size_t index) {
// Extract the result type from the input type. // Extract the result type from the input type.
StructType structTy = input.getType().cast<StructType>(); StructType structTy = input.getType().cast<StructType>();
assert(index < structTy.getNumElementTypes()); assert(index < structTy.getNumElementTypes());
mlir::Type resultType = structTy.getElementTypes()[index]; mlir::Type resultType = structTy.getElementTypes()[index];
// Call into the auto-generated build method. // Call into the auto-generated build method.
build(b, state, resultType, input, b->getI64IntegerAttr(index)); build(b, state, resultType, input, b.getI64IntegerAttr(index));
} }
static mlir::LogicalResult verify(StructAccessOp op) { static mlir::LogicalResult verify(StructAccessOp op) {
StructType structTy = op.input().getType().cast<StructType>(); StructType structTy = op.input().getType().cast<StructType>();
size_t index = op.index().getZExtValue(); size_t index = op.index().getZExtValue();
if (index >= structTy.getNumElementTypes()) if (index >= structTy.getNumElementTypes())
return op.emitOpError() return op.emitOpError()
<< "index should be within the range of the input struct type"; << "index should be within the range of the input struct type";
mlir::Type resultType = op.getResult().getType(); mlir::Type resultType = op.getResult().getType();
if (resultType != structTy.getElementTypes()[index]) if (resultType != structTy.getElementTypes()[index])
return op.emitOpError() << "must have the same result type as the struct " return op.emitOpError() << "must have the same result type as the struct "
"element referred to by the index"; "element referred to by the index";
return mlir::success(); return mlir::success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TransposeOp // TransposeOp
void TransposeOp::build(mlir::Builder *builder, mlir::OperationState &state, void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::Value value) { mlir::Value value) {
state.addTypes(UnrankedTensorType::get(builder->getF64Type())); state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
state.addOperands(value); state.addOperands(value);
} }
void TransposeOp::inferShapes() { void TransposeOp::inferShapes() {
auto arrayTy = getOperand().getType().cast<RankedTensorType>(); auto arrayTy = getOperand().getType().cast<RankedTensorType>();
SmallVector<int64_t, 2> dims(llvm::reverse(arrayTy.getShape())); SmallVector<int64_t, 2> dims(llvm::reverse(arrayTy.getShape()));
getResult().setType(RankedTensorType::get(dims, arrayTy.getElementType())); getResult().setType(RankedTensorType::get(dims, arrayTy.getElementType()));
} }
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Affine/IR/AffineOps.h

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
// striding, and multiple stride levels (possibly using AffineMaps to specify // striding, and multiple stride levels (possibly using AffineMaps to specify
// multiple levels of striding). // multiple levels of striding).
// TODO(andydavis) Consider replacing src/dst memref indices with view memrefs. // TODO(andydavis) Consider replacing src/dst memref indices with view memrefs.
class AffineDmaStartOp : public Op<AffineDmaStartOp, OpTrait::VariadicOperands, class AffineDmaStartOp : public Op<AffineDmaStartOp, OpTrait::VariadicOperands,
OpTrait::ZeroResult> { OpTrait::ZeroResult> {
public: public:
using Op::Op; using Op::Op;
static void build(Builder *builder, OperationState &result, Value srcMemRef, static void build(OpBuilder &builder, OperationState &result, Value srcMemRef,
AffineMap srcMap, ValueRange srcIndices, Value destMemRef, AffineMap srcMap, ValueRange srcIndices, Value destMemRef,
AffineMap dstMap, ValueRange destIndices, Value tagMemRef, AffineMap dstMap, ValueRange destIndices, Value tagMemRef,
AffineMap tagMap, ValueRange tagIndices, Value numElements, AffineMap tagMap, ValueRange tagIndices, Value numElements,
Value stride = nullptr, Value elementsPerStride = nullptr); Value stride = nullptr, Value elementsPerStride = nullptr);
/// Returns the operand index of the src memref. /// Returns the operand index of the src memref.
unsigned getSrcMemRefOperandIndex() { return 0; } unsigned getSrcMemRefOperandIndex() { return 0; }
▲ Show 20 Lines • Show All 171 Lines • ▼ Show 20 Lines
// ... // ...
// affine.dma_wait %tag[%index], %num_elements : memref<1xi32, 2> // affine.dma_wait %tag[%index], %num_elements : memref<1xi32, 2>
// //
class AffineDmaWaitOp : public Op<AffineDmaWaitOp, OpTrait::VariadicOperands, class AffineDmaWaitOp : public Op<AffineDmaWaitOp, OpTrait::VariadicOperands,
OpTrait::ZeroResult> { OpTrait::ZeroResult> {
public: public:
using Op::Op; using Op::Op;
static void build(Builder *builder, OperationState &result, Value tagMemRef, static void build(OpBuilder &builder, OperationState &result, Value tagMemRef,
AffineMap tagMap, ValueRange tagIndices, Value numElements); AffineMap tagMap, ValueRange tagIndices, Value numElements);
static StringRef getOperationName() { return "affine.dma_wait"; } static StringRef getOperationName() { return "affine.dma_wait"; }
// Returns the Tag MemRef associated with the DMA operation being waited on. // Returns the Tag MemRef associated with the DMA operation being waited on.
Value getTagMemRef() { return getOperand(0); } Value getTagMemRef() { return getOperand(0); }
MemRefType getTagMemRefType() { MemRefType getTagMemRefType() {
return getTagMemRef().getType().cast<MemRefType>(); return getTagMemRef().getType().cast<MemRefType>();
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
// : memref<100x100xf32> // : memref<100x100xf32>
// //
class AffineLoadOp : public Op<AffineLoadOp, OpTrait::OneResult, class AffineLoadOp : public Op<AffineLoadOp, OpTrait::OneResult,
OpTrait::AtLeastNOperands<1>::Impl> { OpTrait::AtLeastNOperands<1>::Impl> {
public: public:
using Op::Op; using Op::Op;
/// Builds an affine load op with the specified map and operands. /// Builds an affine load op with the specified map and operands.
static void build(Builder *builder, OperationState &result, AffineMap map, static void build(OpBuilder &builder, OperationState &result, AffineMap map,
ValueRange operands); ValueRange operands);
/// Builds an affine load op with an identity map and operands. /// Builds an affine load op with an identity map and operands.
static void build(Builder *builder, OperationState &result, Value memref, static void build(OpBuilder &builder, OperationState &result, Value memref,
ValueRange indices = {}); ValueRange indices = {});
/// Builds an affine load op with the specified map and its operands. /// Builds an affine load op with the specified map and its operands.
static void build(Builder *builder, OperationState &result, Value memref, static void build(OpBuilder &builder, OperationState &result, Value memref,
AffineMap map, ValueRange mapOperands); AffineMap map, ValueRange mapOperands);
/// Returns the operand index of the memref. /// Returns the operand index of the memref.
unsigned getMemRefOperandIndex() { return 0; } unsigned getMemRefOperandIndex() { return 0; }
/// Get memref operand. /// Get memref operand.
Value getMemRef() { return getOperand(getMemRefOperandIndex()); } Value getMemRef() { return getOperand(getMemRefOperandIndex()); }
void setMemRef(Value value) { setOperand(getMemRefOperandIndex(), value); } void setMemRef(Value value) { setOperand(getMemRefOperandIndex(), value); }
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
// : memref<100x100xf32> // : memref<100x100xf32>
// //
class AffineStoreOp : public Op<AffineStoreOp, OpTrait::ZeroResult, class AffineStoreOp : public Op<AffineStoreOp, OpTrait::ZeroResult,
OpTrait::AtLeastNOperands<1>::Impl> { OpTrait::AtLeastNOperands<1>::Impl> {
public: public:
using Op::Op; using Op::Op;
/// Builds an affine store operation with the provided indices (identity map). /// Builds an affine store operation with the provided indices (identity map).
static void build(Builder *builder, OperationState &result, static void build(OpBuilder &builder, OperationState &result,
Value valueToStore, Value memref, ValueRange indices); Value valueToStore, Value memref, ValueRange indices);
/// Builds an affine store operation with the specified map and its operands. /// Builds an affine store operation with the specified map and its operands.
static void build(Builder *builder, OperationState &result, static void build(OpBuilder &builder, OperationState &result,
Value valueToStore, Value memref, AffineMap map, Value valueToStore, Value memref, AffineMap map,
ValueRange mapOperands); ValueRange mapOperands);
/// Get value to be stored by store operation. /// Get value to be stored by store operation.
Value getValueToStore() { return getOperand(0); } Value getValueToStore() { return getOperand(0); }
/// Returns the operand index of the memref. /// Returns the operand index of the memref.
unsigned getMemRefOperandIndex() { return 1; } unsigned getMemRefOperandIndex() { return 1; }
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Linesdef AffineApplyOp : Affine_Op<"apply", [NoSideEffect]> {
}]; }];
let arguments = (ins AffineMapAttr:$map, Variadic<Index>:$mapOperands); let arguments = (ins AffineMapAttr:$map, Variadic<Index>:$mapOperands);
let results = (outs Index); let results = (outs Index);
// TODO: The auto-generated builders should check to see if the return type // TODO: The auto-generated builders should check to see if the return type
// has a constant builder. That way we wouldn't need to explicitly specify the // has a constant builder. That way we wouldn't need to explicitly specify the
// result types here. // result types here.
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"AffineMap map, ValueRange mapOperands", [{ "AffineMap map, ValueRange mapOperands", [{
build(builder, result, builder->getIndexType(), map, mapOperands); build(builder, result, builder.getIndexType(), map, mapOperands);
}]> }]>
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
/// Returns the affine map to be applied by this operation. /// Returns the affine map to be applied by this operation.
AffineMap getAffineMap() { return map(); } AffineMap getAffineMap() { return map(); }
/// Returns the affine value map computed from this operation. /// Returns the affine value map computed from this operation.
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines let description = [{
} }
``` ```
}]; }];
let arguments = (ins Variadic<AnyType>); let arguments = (ins Variadic<AnyType>);
let regions = (region SizedRegion<1>:$region); let regions = (region SizedRegion<1>:$region);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"int64_t lowerBound, int64_t upperBound, int64_t step = 1">, "int64_t lowerBound, int64_t upperBound, int64_t step = 1">,
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"ValueRange lbOperands, AffineMap lbMap, " "ValueRange lbOperands, AffineMap lbMap, "
"ValueRange ubOperands, AffineMap ubMap, " "ValueRange ubOperands, AffineMap ubMap, "
"int64_t step = 1"> "int64_t step = 1">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static StringRef getStepAttrName() { return "step"; } static StringRef getStepAttrName() { return "step"; }
static StringRef getLowerBoundAttrName() { return "lower_bound"; } static StringRef getLowerBoundAttrName() { return "lower_bound"; }
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Lines let description = [{
``` ```
}]; }];
let arguments = (ins Variadic<AnyType>); let arguments = (ins Variadic<AnyType>);
let regions = (region SizedRegion<1>:$thenRegion, AnyRegion:$elseRegion); let regions = (region SizedRegion<1>:$thenRegion, AnyRegion:$elseRegion);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"IntegerSet set, ValueRange args, bool withElseRegion"> "IntegerSet set, ValueRange args, bool withElseRegion">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static StringRef getConditionAttrName() { return "condition"; } static StringRef getConditionAttrName() { return "condition"; }
IntegerSet getIntegerSet(); IntegerSet getIntegerSet();
void setIntegerSet(IntegerSet newSet); void setIntegerSet(IntegerSet newSet);
Show All 33 Lines
} }
class AffineMinMaxOpBase<string mnemonic, list<OpTrait> traits = []> : class AffineMinMaxOpBase<string mnemonic, list<OpTrait> traits = []> :
Op<Affine_Dialect, mnemonic, traits> { Op<Affine_Dialect, mnemonic, traits> {
let arguments = (ins AffineMapAttr:$map, Variadic<Index>:$operands); let arguments = (ins AffineMapAttr:$map, Variadic<Index>:$operands);
let results = (outs Index); let results = (outs Index);
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, AffineMap affineMap, " OpBuilder<"OpBuilder &builder, OperationState &result, AffineMap affineMap, "
"ValueRange mapOperands", "ValueRange mapOperands",
[{ [{
build(builder, result, builder->getIndexType(), affineMap, mapOperands); build(builder, result, builder.getIndexType(), affineMap, mapOperands);
}]> }]>
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static StringRef getMapAttrName() { return "map"; } static StringRef getMapAttrName() { return "map"; }
AffineMap getAffineMap() { return map(); } AffineMap getAffineMap() { return map(); }
ValueRange getMapOperands() { return operands(); } ValueRange getMapOperands() { return operands(); }
}]; }];
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Linesdef AffineParallelOp : Affine_Op<"parallel", [ImplicitAffineTerminator]> {
let arguments = (ins let arguments = (ins
AffineMapAttr:$lowerBoundsMap, AffineMapAttr:$lowerBoundsMap,
AffineMapAttr:$upperBoundsMap, AffineMapAttr:$upperBoundsMap,
I64ArrayAttr:$steps, I64ArrayAttr:$steps,
Variadic<Index>:$mapOperands); Variadic<Index>:$mapOperands);
let regions = (region SizedRegion<1>:$region); let regions = (region SizedRegion<1>:$region);
let builders = [ let builders = [
OpBuilder<"Builder* builder, OperationState& result," OpBuilder<"OpBuilder &builder, OperationState &result,"
"ArrayRef<int64_t> ranges">, "ArrayRef<int64_t> ranges">,
OpBuilder<"Builder* builder, OperationState& result, AffineMap lbMap," OpBuilder<"OpBuilder &builder, OperationState &result, AffineMap lbMap,"
"ValueRange lbArgs, AffineMap ubMap, ValueRange ubArgs">, "ValueRange lbArgs, AffineMap ubMap, ValueRange ubArgs">,
OpBuilder<"Builder* builder, OperationState& result, AffineMap lbMap," OpBuilder<"OpBuilder &builder, OperationState &result, AffineMap lbMap,"
"ValueRange lbArgs, AffineMap ubMap, ValueRange ubArgs," "ValueRange lbArgs, AffineMap ubMap, ValueRange ubArgs,"
"ArrayRef<int64_t> steps"> "ArrayRef<int64_t> steps">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
/// Get the number of dimensions. /// Get the number of dimensions.
unsigned getNumDims(); unsigned getNumDims();
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesdef AffinePrefetchOp : Affine_Op<"prefetch"> {
let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices, let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices,
BoolAttr:$isWrite, BoolAttr:$isWrite,
Confined<I32Attr, [IntMinValue<0>, Confined<I32Attr, [IntMinValue<0>,
IntMaxValue<3>]>:$localityHint, IntMaxValue<3>]>:$localityHint,
BoolAttr:$isDataCache); BoolAttr:$isDataCache);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value memref," "OpBuilder &builder, OperationState &result, Value memref,"
"AffineMap map, ArrayRef<Value> mapOperands, bool isWrite," "AffineMap map, ArrayRef<Value> mapOperands, bool isWrite,"
"unsigned localityHint, bool isDataCache", "unsigned localityHint, bool isDataCache",
[{ [{
assert(map.getNumInputs() == mapOperands.size() assert(map.getNumInputs() == mapOperands.size()
&& "inconsistent index info"); && "inconsistent index info");
auto localityHintAttr = builder->getI32IntegerAttr(localityHint); auto localityHintAttr = builder.getI32IntegerAttr(localityHint);
auto isWriteAttr = builder->getBoolAttr(isWrite); auto isWriteAttr = builder.getBoolAttr(isWrite);
auto isDataCacheAttr = builder->getBoolAttr(isDataCache); auto isDataCacheAttr = builder.getBoolAttr(isDataCache);
result.addOperands(memref); result.addOperands(memref);
result.addAttribute(getMapAttrName(), AffineMapAttr::get(map)); result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
result.addOperands(mapOperands); result.addOperands(mapOperands);
result.addAttribute(getLocalityHintAttrName(), localityHintAttr); result.addAttribute(getLocalityHintAttrName(), localityHintAttr);
result.addAttribute(getIsWriteAttrName(), isWriteAttr); result.addAttribute(getIsWriteAttrName(), isWriteAttr);
result.addAttribute(getIsDataCacheAttrName(), isDataCacheAttr); result.addAttribute(getIsDataCacheAttrName(), isDataCacheAttr);
}]>]; }]>];
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/GPU/GPUOps.td

Show First 20 Lines • Show All 146 Lines • ▼ Show 20 Lines let description = [{
attribution. attribution.
}]; }];
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, StringRef name, " OpBuilder<"OpBuilder &builder, OperationState &result, StringRef name, "
"FunctionType type, ArrayRef<Type> workgroupAttributions = {}, " "FunctionType type, ArrayRef<Type> workgroupAttributions = {}, "
"ArrayRef<Type> privateAttributions = {}, " "ArrayRef<Type> privateAttributions = {}, "
"ArrayRef<NamedAttribute> attrs = {}"> "ArrayRef<NamedAttribute> attrs = {}">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
/// Adds a workgroup attribution of the MemRef type with the given shape and /// Adds a workgroup attribution of the MemRef type with the given shape and
/// element type. /// element type.
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Lines module attributes {gpu.container_module} {
-> () -> ()
} }
``` ```
}]; }];
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, GPUFuncOp kernelFunc, " OpBuilder<"OpBuilder &builder, OperationState &result, GPUFuncOp kernelFunc, "
"Value gridSizeX, Value gridSizeY, Value gridSizeZ, " "Value gridSizeX, Value gridSizeY, Value gridSizeZ, "
"Value blockSizeX, Value blockSizeY, Value blockSizeZ, " "Value blockSizeX, Value blockSizeY, Value blockSizeZ, "
"ValueRange kernelOperands">, "ValueRange kernelOperands">,
OpBuilder<"Builder *builder, OperationState &result, GPUFuncOp kernelFunc, " OpBuilder<"OpBuilder &builder, OperationState &result, GPUFuncOp kernelFunc, "
"KernelDim3 gridSize, KernelDim3 blockSize, " "KernelDim3 gridSize, KernelDim3 blockSize, "
"ValueRange kernelOperands"> "ValueRange kernelOperands">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
/// The kernel function specified by the operation's `kernel` attribute. /// The kernel function specified by the operation's `kernel` attribute.
SymbolRefAttr kernel(); SymbolRefAttr kernel();
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines let description = [{
easier just to have that information by construction. easier just to have that information by construction.
}]; }];
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, Value gridSizeX," OpBuilder<"OpBuilder &builder, OperationState &result, Value gridSizeX,"
"Value gridSizeY, Value gridSizeZ, Value blockSizeX," "Value gridSizeY, Value gridSizeZ, Value blockSizeX,"
"Value blockSizeY, Value blockSizeZ"> "Value blockSizeY, Value blockSizeZ">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
/// Get the SSA values corresponding to kernel block identifiers. /// Get the SSA values corresponding to kernel block identifiers.
KernelDim3 getBlockIds(); KernelDim3 getBlockIds();
/// Get the SSA values corresponding to kernel thread identifiers. /// Get the SSA values corresponding to kernel thread identifiers.
Show All 30 Linesdef GPU_ReturnOp : GPU_Op<"return", [HasParent<"GPUFuncOp">, NoSideEffect,
Arguments<(ins Variadic<AnyType>:$operands)>, Results<(outs)> { Arguments<(ins Variadic<AnyType>:$operands)>, Results<(outs)> {
let summary = "Terminator for GPU functions."; let summary = "Terminator for GPU functions.";
let description = [{ let description = [{
A terminator operation for regions that appear in the body of `gpu.func` A terminator operation for regions that appear in the body of `gpu.func`
functions. The operands to the `gpu.return` are the result values returned functions. The operands to the `gpu.return` are the result values returned
by an invocation of the `gpu.func`. by an invocation of the `gpu.func`.
}]; }];
let builders = [OpBuilder<"Builder *builder, OperationState &result", " // empty">]; let builders = [OpBuilder<"OpBuilder &builder, OperationState &result", " // empty">];
let parser = [{ return parseReturnOp(parser, result); }]; let parser = [{ return parseReturnOp(parser, result); }];
let printer = [{ p << getOperationName(); }]; let printer = [{ p << getOperationName(); }];
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
} }
def GPU_TerminatorOp : GPU_Op<"terminator", [HasParent<"LaunchOp">, def GPU_TerminatorOp : GPU_Op<"terminator", [HasParent<"LaunchOp">,
NoSideEffect, Terminator]>, NoSideEffect, Terminator]>,
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines ```
gpu.module @symbol_name { gpu.module @symbol_name {
gpu.func {} gpu.func {}
... ...
gpu.module_end gpu.module_end
} }
``` ```
}]; }];
let builders = [OpBuilder<"Builder *builder, OperationState &result, " let builders = [OpBuilder<"OpBuilder &builder, OperationState &result, "
"StringRef name">]; "StringRef name">];
let parser = [{ return ::parseGPUModuleOp(parser, result); }]; let parser = [{ return ::parseGPUModuleOp(parser, result); }];
let printer = [{ return ::print(p, *this); }]; let printer = [{ return ::print(p, *this); }];
let regions = (region SizedRegion<1>:$body); let regions = (region SizedRegion<1>:$body);
// We need to ensure the block inside the region is properly terminated; // We need to ensure the block inside the region is properly terminated;
// the auto-generated builders do not guarantee that. // the auto-generated builders do not guarantee that.
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
Show All 15 Lines

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

Show All 16 Lines
include "mlir/Interfaces/ControlFlowInterfaces.td" include "mlir/Interfaces/ControlFlowInterfaces.td"
include "mlir/Interfaces/SideEffects.td" include "mlir/Interfaces/SideEffects.td"
class LLVM_Builder<string builder> { class LLVM_Builder<string builder> {
string llvmBuilder = builder; string llvmBuilder = builder;
} }
def LLVM_OneResultOpBuilder : OpBuilder< def LLVM_OneResultOpBuilder : OpBuilder<
"Builder *, OperationState &result, Type resultType, " "OpBuilder &, OperationState &result, Type resultType, "
"ValueRange operands, ArrayRef<NamedAttribute> attributes = {}", "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
[{ [{
if (resultType) result.addTypes(resultType); if (resultType) result.addTypes(resultType);
result.addOperands(operands); result.addOperands(operands);
for (auto namedAttr : attributes) { for (auto namedAttr : attributes) {
result.addAttribute(namedAttr.first, namedAttr.second); result.addAttribute(namedAttr.first, namedAttr.second);
} }
}]>; }]>;
def LLVM_ZeroResultOpBuilder : OpBuilder< def LLVM_ZeroResultOpBuilder : OpBuilder<
"Builder *, OperationState &result, ValueRange operands, " "OpBuilder &, OperationState &result, ValueRange operands, "
"ArrayRef<NamedAttribute> attributes = {}", "ArrayRef<NamedAttribute> attributes = {}",
[{ [{
result.addOperands(operands); result.addOperands(operands);
for (auto namedAttr : attributes) { for (auto namedAttr : attributes) {
result.addAttribute(namedAttr.first, namedAttr.second); result.addAttribute(namedAttr.first, namedAttr.second);
} }
}]>; }]>;
class LLVM_TwoBuilders<OpBuilder b1, OpBuilder b2> { class LLVM_TwoBuilders<OpBuilder b1, OpBuilder b2> {
list<OpBuilder> builders = [b1, b2]; list<OpBuilder> builders = [b1, b2];
} }
// Base class for LLVM operations with one result. // Base class for LLVM operations with one result.
class LLVM_OneResultOp<string mnemonic, list<OpTrait> traits = []> : class LLVM_OneResultOp<string mnemonic, list<OpTrait> traits = []> :
LLVM_Op<mnemonic, traits>, Results<(outs LLVM_Type:$res)> { LLVM_Op<mnemonic, traits>, Results<(outs LLVM_Type:$res)> {
let builders = [LLVM_OneResultOpBuilder]; let builders = [LLVM_OneResultOpBuilder];
} }
// Compatibility builder that takes an instance of wrapped llvm::VoidType // Compatibility builder that takes an instance of wrapped llvm::VoidType
// to indicate no result. // to indicate no result.
def LLVM_VoidResultTypeOpBuilder : OpBuilder< def LLVM_VoidResultTypeOpBuilder : OpBuilder<
"Builder *builder, OperationState &result, Type resultType, " "OpBuilder &builder, OperationState &result, Type resultType, "
"ValueRange operands, ArrayRef<NamedAttribute> attributes = {}", "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
[{ [{
auto llvmType = resultType.dyn_cast<LLVM::LLVMType>(); (void)llvmType; auto llvmType = resultType.dyn_cast<LLVM::LLVMType>(); (void)llvmType;
assert(llvmType && "result must be an LLVM type"); assert(llvmType && "result must be an LLVM type");
assert(llvmType.getUnderlyingType() && assert(llvmType.getUnderlyingType() &&
llvmType.getUnderlyingType()->isVoidTy() && llvmType.getUnderlyingType()->isVoidTy() &&
"for zero-result operands, only 'void' is accepted as result type"); "for zero-result operands, only 'void' is accepted as result type");
build(builder, result, operands, attributes); build(builder, result, operands, attributes);
}]>; }]>;
// Base class for LLVM operations with zero results. // Base class for LLVM operations with zero results.
class LLVM_ZeroResultOp<string mnemonic, list<OpTrait> traits = []> : class LLVM_ZeroResultOp<string mnemonic, list<OpTrait> traits = []> :
LLVM_Op<mnemonic, traits>, Results<(outs)>, LLVM_Op<mnemonic, traits>, Results<(outs)>,
LLVM_TwoBuilders<LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder>; LLVM_TwoBuilders<LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder>;
// Opaque builder used for terminator operations that contain successors. // Opaque builder used for terminator operations that contain successors.
def LLVM_TerminatorPassthroughOpBuilder : OpBuilder< def LLVM_TerminatorPassthroughOpBuilder : OpBuilder<
"Builder *, OperationState &result, ValueRange operands, " "OpBuilder &, OperationState &result, ValueRange operands, "
"SuccessorRange destinations, ArrayRef<NamedAttribute> attributes = {}", "SuccessorRange destinations, ArrayRef<NamedAttribute> attributes = {}",
[{ [{
result.addOperands(operands); result.addOperands(operands);
result.addSuccessors(destinations); result.addSuccessors(destinations);
result.addAttributes(attributes); result.addAttributes(attributes);
}]>; }]>;
// Base class for LLVM terminator operations. All terminator operations have // Base class for LLVM terminator operations. All terminator operations have
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
// Other integer operations. // Other integer operations.
def LLVM_ICmpOp : LLVM_OneResultOp<"icmp", [NoSideEffect]>, def LLVM_ICmpOp : LLVM_OneResultOp<"icmp", [NoSideEffect]>,
Arguments<(ins ICmpPredicate:$predicate, LLVM_Type:$lhs, Arguments<(ins ICmpPredicate:$predicate, LLVM_Type:$lhs,
LLVM_Type:$rhs)> { LLVM_Type:$rhs)> {
let llvmBuilder = [{ let llvmBuilder = [{
$res = builder.CreateICmp(getLLVMCmpPredicate($predicate), $lhs, $rhs); $res = builder.CreateICmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, ICmpPredicate predicate, Value lhs, " "OpBuilder &b, OperationState &result, ICmpPredicate predicate, Value lhs, "
"Value rhs", [{ "Value rhs", [{
LLVMDialect *dialect = &lhs.getType().cast<LLVMType>().getDialect(); LLVMDialect *dialect = &lhs.getType().cast<LLVMType>().getDialect();
build(b, result, LLVMType::getInt1Ty(dialect), build(b, result, LLVMType::getInt1Ty(dialect),
b->getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs); b.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs);
}]>]; }]>];
let parser = [{ return parseCmpOp<ICmpPredicate>(parser, result); }]; let parser = [{ return parseCmpOp<ICmpPredicate>(parser, result); }];
let printer = [{ printICmpOp(p, *this); }]; let printer = [{ printICmpOp(p, *this); }];
} }
// Predicate for float comparisons // Predicate for float comparisons
def FCmpPredicateFALSE : I64EnumAttrCase<"_false", 0>; def FCmpPredicateFALSE : I64EnumAttrCase<"_false", 0>;
def FCmpPredicateOEQ : I64EnumAttrCase<"oeq", 1>; def FCmpPredicateOEQ : I64EnumAttrCase<"oeq", 1>;
Show All 26 Lines
// Other integer operations. // Other integer operations.
def LLVM_FCmpOp : LLVM_OneResultOp<"fcmp", [NoSideEffect]>, def LLVM_FCmpOp : LLVM_OneResultOp<"fcmp", [NoSideEffect]>,
Arguments<(ins FCmpPredicate:$predicate, LLVM_Type:$lhs, Arguments<(ins FCmpPredicate:$predicate, LLVM_Type:$lhs,
LLVM_Type:$rhs)> { LLVM_Type:$rhs)> {
let llvmBuilder = [{ let llvmBuilder = [{
$res = builder.CreateFCmp(getLLVMCmpPredicate($predicate), $lhs, $rhs); $res = builder.CreateFCmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, FCmpPredicate predicate, Value lhs, " "OpBuilder &b, OperationState &result, FCmpPredicate predicate, Value lhs, "
"Value rhs", [{ "Value rhs", [{
LLVMDialect *dialect = &lhs.getType().cast<LLVMType>().getDialect(); LLVMDialect *dialect = &lhs.getType().cast<LLVMType>().getDialect();
build(b, result, LLVMType::getInt1Ty(dialect), build(b, result, LLVMType::getInt1Ty(dialect),
b->getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs); b.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs);
}]>]; }]>];
let parser = [{ return parseCmpOp<FCmpPredicate>(parser, result); }]; let parser = [{ return parseCmpOp<FCmpPredicate>(parser, result); }];
let printer = [{ printFCmpOp(p, *this); }]; let printer = [{ printFCmpOp(p, *this); }];
} }
// Floating point binary operations. // Floating point binary operations.
def LLVM_FAddOp : LLVM_ArithmeticOp<"fadd", "CreateFAdd">; def LLVM_FAddOp : LLVM_ArithmeticOp<"fadd", "CreateFAdd">;
def LLVM_FSubOp : LLVM_ArithmeticOp<"fsub", "CreateFSub">; def LLVM_FSubOp : LLVM_ArithmeticOp<"fsub", "CreateFSub">;
Show All 12 Lines string llvmBuilder = [{
if ($alignment.hasValue()) { if ($alignment.hasValue()) {
auto align = $alignment.getValue().getZExtValue(); auto align = $alignment.getValue().getZExtValue();
if (align != 0) if (align != 0)
alloca->setAlignment(llvm::MaybeAlign(align)); alloca->setAlignment(llvm::MaybeAlign(align));
} }
$res = alloca; $res = alloca;
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, Type resultType, Value arraySize, " "OpBuilder &b, OperationState &result, Type resultType, Value arraySize, "
"unsigned alignment", "unsigned alignment",
[{ [{
if (alignment == 0) if (alignment == 0)
return build(b, result, resultType, arraySize, IntegerAttr()); return build(b, result, resultType, arraySize, IntegerAttr());
build(b, result, resultType, arraySize, b->getI64IntegerAttr(alignment)); build(b, result, resultType, arraySize, b.getI64IntegerAttr(alignment));
}]>]; }]>];
let parser = [{ return parseAllocaOp(parser, result); }]; let parser = [{ return parseAllocaOp(parser, result); }];
let printer = [{ printAllocaOp(p, *this); }]; let printer = [{ printAllocaOp(p, *this); }];
let verifier = [{ let verifier = [{
if (alignment().hasValue()) { if (alignment().hasValue()) {
auto align = alignment().getValue().getSExtValue(); auto align = alignment().getValue().getSExtValue();
if (align < 0) if (align < 0)
return emitOpError("expected positive alignment"); return emitOpError("expected positive alignment");
} }
return success(); return success();
}]; }];
} }
def LLVM_GEPOp : LLVM_OneResultOp<"getelementptr", [NoSideEffect]>, def LLVM_GEPOp : LLVM_OneResultOp<"getelementptr", [NoSideEffect]>,
Arguments<(ins LLVM_Type:$base, Variadic<LLVM_Type>:$indices)>, Arguments<(ins LLVM_Type:$base, Variadic<LLVM_Type>:$indices)>,
LLVM_Builder<"$res = builder.CreateGEP($base, $indices);"> { LLVM_Builder<"$res = builder.CreateGEP($base, $indices);"> {
let assemblyFormat = [{ let assemblyFormat = [{
$base `[` $indices `]` attr-dict `:` functional-type(operands, results) $base `[` $indices `]` attr-dict `:` functional-type(operands, results)
}]; }];
} }
def LLVM_LoadOp : LLVM_OneResultOp<"load">, Arguments<(ins LLVM_Type:$addr)>, def LLVM_LoadOp : LLVM_OneResultOp<"load">, Arguments<(ins LLVM_Type:$addr)>,
LLVM_Builder<"$res = builder.CreateLoad($addr);"> { LLVM_Builder<"$res = builder.CreateLoad($addr);"> {
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, Value addr", "OpBuilder &b, OperationState &result, Value addr",
[{ [{
auto type = addr.getType().cast<LLVM::LLVMType>().getPointerElementTy(); auto type = addr.getType().cast<LLVM::LLVMType>().getPointerElementTy();
build(b, result, type, addr); build(b, result, type, addr);
}]>]; }]>];
let parser = [{ return parseLoadOp(parser, result); }]; let parser = [{ return parseLoadOp(parser, result); }];
let printer = [{ printLoadOp(p, *this); }]; let printer = [{ printLoadOp(p, *this); }];
} }
def LLVM_StoreOp : LLVM_ZeroResultOp<"store">, def LLVM_StoreOp : LLVM_ZeroResultOp<"store">,
Show All 37 Linesdef LLVM_InvokeOp : LLVM_Op<"invoke", [
Variadic<LLVM_Type>:$operands, Variadic<LLVM_Type>:$operands,
Variadic<LLVM_Type>:$normalDestOperands, Variadic<LLVM_Type>:$normalDestOperands,
Variadic<LLVM_Type>:$unwindDestOperands)>, Variadic<LLVM_Type>:$unwindDestOperands)>,
Results<(outs Variadic<LLVM_Type>)> { Results<(outs Variadic<LLVM_Type>)> {
let successors = (successor AnySuccessor:$normalDest, let successors = (successor AnySuccessor:$normalDest,
AnySuccessor:$unwindDest); AnySuccessor:$unwindDest);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, ArrayRef<Type> tys, " "OpBuilder &b, OperationState &result, ArrayRef<Type> tys, "
"FlatSymbolRefAttr callee, ValueRange ops, Block* normal, " "FlatSymbolRefAttr callee, ValueRange ops, Block* normal, "
"ValueRange normalOps, Block* unwind, ValueRange unwindOps", "ValueRange normalOps, Block* unwind, ValueRange unwindOps",
[{ [{
result.addAttribute("callee", callee); result.addAttribute("callee", callee);
build(b, result, tys, ops, normal, normalOps, unwind, unwindOps); build(b, result, tys, ops, normal, normalOps, unwind, unwindOps);
}]>, }]>,
OpBuilder< OpBuilder<
"Builder *b, OperationState &result, ArrayRef<Type> tys, " "OpBuilder &b, OperationState &result, ArrayRef<Type> tys, "
"ValueRange ops, Block* normal, " "ValueRange ops, Block* normal, "
"ValueRange normalOps, Block* unwind, ValueRange unwindOps", "ValueRange normalOps, Block* unwind, ValueRange unwindOps",
[{ [{
build(b, result, tys, /*callee=*/FlatSymbolRefAttr(), ops, normalOps, build(b, result, tys, /*callee=*/FlatSymbolRefAttr(), ops, normalOps,
unwindOps, normal, unwind); unwindOps, normal, unwind);
}]>]; }]>];
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
let parser = [{ return parseInvokeOp(parser, result); }]; let parser = [{ return parseInvokeOp(parser, result); }];
let printer = [{ printInvokeOp(p, *this); }]; let printer = [{ printInvokeOp(p, *this); }];
} }
def LLVM_LandingpadOp : LLVM_OneResultOp<"landingpad">, def LLVM_LandingpadOp : LLVM_OneResultOp<"landingpad">,
Arguments<(ins UnitAttr:$cleanup, Arguments<(ins UnitAttr:$cleanup,
Variadic<LLVM_Type>)> { Variadic<LLVM_Type>)> {
let verifier = [{ return ::verify(*this); }]; let verifier = [{ return ::verify(*this); }];
let parser = [{ return parseLandingpadOp(parser, result); }]; let parser = [{ return parseLandingpadOp(parser, result); }];
let printer = [{ printLandingpadOp(p, *this); }]; let printer = [{ printLandingpadOp(p, *this); }];
} }
def LLVM_CallOp : LLVM_Op<"call">, def LLVM_CallOp : LLVM_Op<"call">,
Arguments<(ins OptionalAttr<FlatSymbolRefAttr>:$callee, Arguments<(ins OptionalAttr<FlatSymbolRefAttr>:$callee,
Variadic<LLVM_Type>)>, Variadic<LLVM_Type>)>,
Results<(outs Variadic<LLVM_Type>)> { Results<(outs Variadic<LLVM_Type>)> {
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, LLVMFuncOp func," "OpBuilder &builder, OperationState &result, LLVMFuncOp func,"
"ValueRange operands, ArrayRef<NamedAttribute> attributes = {}", "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
[{ [{
LLVMType resultType = func.getType().getFunctionResultType(); LLVMType resultType = func.getType().getFunctionResultType();
if (!resultType.isVoidTy()) if (!resultType.isVoidTy())
result.addTypes(resultType); result.addTypes(resultType);
result.addAttribute("callee", builder->getSymbolRefAttr(func)); result.addAttribute("callee", builder.getSymbolRefAttr(func));
result.addAttributes(attributes); result.addAttributes(attributes);
result.addOperands(operands); result.addOperands(operands);
}]>]; }]>];
let verifier = [{ let verifier = [{
if (getNumResults() > 1) if (getNumResults() > 1)
return emitOpError("must have 0 or 1 result"); return emitOpError("must have 0 or 1 result");
return success(); return success();
}]; }];
let parser = [{ return parseCallOp(parser, result); }]; let parser = [{ return parseCallOp(parser, result); }];
let printer = [{ printCallOp(p, *this); }]; let printer = [{ printCallOp(p, *this); }];
} }
def LLVM_ExtractElementOp : LLVM_OneResultOp<"extractelement", [NoSideEffect]>, def LLVM_ExtractElementOp : LLVM_OneResultOp<"extractelement", [NoSideEffect]>,
Arguments<(ins LLVM_Type:$vector, Arguments<(ins LLVM_Type:$vector,
LLVM_Type:$position)> { LLVM_Type:$position)> {
string llvmBuilder = [{ string llvmBuilder = [{
$res = builder.CreateExtractElement($vector, $position); $res = builder.CreateExtractElement($vector, $position);
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, Value vector, Value position," "OpBuilder &b, OperationState &result, Value vector, Value position,"
"ArrayRef<NamedAttribute> attrs = {}">]; "ArrayRef<NamedAttribute> attrs = {}">];
let parser = [{ return parseExtractElementOp(parser, result); }]; let parser = [{ return parseExtractElementOp(parser, result); }];
let printer = [{ printExtractElementOp(p, *this); }]; let printer = [{ printExtractElementOp(p, *this); }];
} }
def LLVM_ExtractValueOp : LLVM_OneResultOp<"extractvalue", [NoSideEffect]>, def LLVM_ExtractValueOp : LLVM_OneResultOp<"extractvalue", [NoSideEffect]>,
Arguments<(ins LLVM_Type:$container, Arguments<(ins LLVM_Type:$container,
ArrayAttr:$position)> { ArrayAttr:$position)> {
string llvmBuilder = [{ string llvmBuilder = [{
Show All 14 Lines
def LLVM_InsertValueOp : LLVM_OneResultOp<"insertvalue", [NoSideEffect]>, def LLVM_InsertValueOp : LLVM_OneResultOp<"insertvalue", [NoSideEffect]>,
Arguments<(ins LLVM_Type:$container, LLVM_Type:$value, Arguments<(ins LLVM_Type:$container, LLVM_Type:$value,
ArrayAttr:$position)> { ArrayAttr:$position)> {
string llvmBuilder = [{ string llvmBuilder = [{
$res = builder.CreateInsertValue($container, $value, $res = builder.CreateInsertValue($container, $value,
extractPosition($position)); extractPosition($position));
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, Value container, Value value, " "OpBuilder &b, OperationState &result, Value container, Value value, "
"ArrayAttr position", "ArrayAttr position",
[{ [{
build(b, result, container.getType(), container, value, position); build(b, result, container.getType(), container, value, position);
}]>]; }]>];
let parser = [{ return parseInsertValueOp(parser, result); }]; let parser = [{ return parseInsertValueOp(parser, result); }];
let printer = [{ printInsertValueOp(p, *this); }]; let printer = [{ printInsertValueOp(p, *this); }];
} }
def LLVM_ShuffleVectorOp def LLVM_ShuffleVectorOp
: LLVM_OneResultOp<"shufflevector", [NoSideEffect]>, : LLVM_OneResultOp<"shufflevector", [NoSideEffect]>,
Arguments<(ins LLVM_Type:$v1, LLVM_Type:$v2, ArrayAttr:$mask)> { Arguments<(ins LLVM_Type:$v1, LLVM_Type:$v2, ArrayAttr:$mask)> {
string llvmBuilder = [{ string llvmBuilder = [{
SmallVector<unsigned, 4> position = extractPosition($mask); SmallVector<unsigned, 4> position = extractPosition($mask);
SmallVector<int, 4> mask(position.begin(), position.end()); SmallVector<int, 4> mask(position.begin(), position.end());
$res = builder.CreateShuffleVector($v1, $v2, mask); $res = builder.CreateShuffleVector($v1, $v2, mask);
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, Value v1, Value v2, " "OpBuilder &b, OperationState &result, Value v1, Value v2, "
"ArrayAttr mask, ArrayRef<NamedAttribute> attrs = {}">]; "ArrayAttr mask, ArrayRef<NamedAttribute> attrs = {}">];
let verifier = [{ let verifier = [{
auto wrappedVectorType1 = v1().getType().cast<LLVM::LLVMType>(); auto wrappedVectorType1 = v1().getType().cast<LLVM::LLVMType>();
auto wrappedVectorType2 = v2().getType().cast<LLVM::LLVMType>(); auto wrappedVectorType2 = v2().getType().cast<LLVM::LLVMType>();
if (!wrappedVectorType2.getUnderlyingType()->isVectorTy()) if (!wrappedVectorType2.getUnderlyingType()->isVectorTy())
return emitOpError("expected LLVM IR Dialect vector type for operand #2"); return emitOpError("expected LLVM IR Dialect vector type for operand #2");
if (wrappedVectorType1.getVectorElementType() != if (wrappedVectorType1.getVectorElementType() !=
wrappedVectorType2.getVectorElementType()) wrappedVectorType2.getVectorElementType())
return emitOpError("expected matching LLVM IR Dialect element types"); return emitOpError("expected matching LLVM IR Dialect element types");
return success(); return success();
}]; }];
let parser = [{ return parseShuffleVectorOp(parser, result); }]; let parser = [{ return parseShuffleVectorOp(parser, result); }];
let printer = [{ printShuffleVectorOp(p, *this); }]; let printer = [{ printShuffleVectorOp(p, *this); }];
} }
// Misc operations. // Misc operations.
def LLVM_SelectOp def LLVM_SelectOp
: LLVM_OneResultOp<"select", : LLVM_OneResultOp<"select",
[NoSideEffect, AllTypesMatch<["trueValue", "falseValue", "res"]>]>, [NoSideEffect, AllTypesMatch<["trueValue", "falseValue", "res"]>]>,
Arguments<(ins LLVM_Type:$condition, LLVM_Type:$trueValue, Arguments<(ins LLVM_Type:$condition, LLVM_Type:$trueValue,
LLVM_Type:$falseValue)>, LLVM_Type:$falseValue)>,
LLVM_Builder< LLVM_Builder<
"$res = builder.CreateSelect($condition, $trueValue, $falseValue);"> { "$res = builder.CreateSelect($condition, $trueValue, $falseValue);"> {
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, Value condition, Value lhs, " "OpBuilder &b, OperationState &result, Value condition, Value lhs, "
"Value rhs", [{ "Value rhs", [{
build(b, result, lhs.getType(), condition, lhs, rhs); build(b, result, lhs.getType(), condition, lhs, rhs);
}]>]; }]>];
let assemblyFormat = "operands attr-dict `:` type($condition) `,` type($res)"; let assemblyFormat = "operands attr-dict `:` type($condition) `,` type($res)";
} }
def LLVM_FreezeOp : LLVM_OneResultOp<"freeze", [SameOperandsAndResultType]>, def LLVM_FreezeOp : LLVM_OneResultOp<"freeze", [SameOperandsAndResultType]>,
Arguments<(ins LLVM_Type:$val)> { Arguments<(ins LLVM_Type:$val)> {
let assemblyFormat = "$val attr-dict `:` type($val)"; let assemblyFormat = "$val attr-dict `:` type($val)";
Show All 20 Linesdef LLVM_CondBrOp : LLVM_TerminatorOp<"cond_br",
let assemblyFormat = [{ let assemblyFormat = [{
$condition `,` $condition `,`
$trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,` $trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
$falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)? $falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)?
attr-dict attr-dict
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value condition," "OpBuilder &builder, OperationState &result, Value condition,"
"Block *trueDest, ValueRange trueOperands," "Block *trueDest, ValueRange trueOperands,"
"Block *falseDest, ValueRange falseOperands", [{ "Block *falseDest, ValueRange falseOperands", [{
build(builder, result, condition, trueOperands, falseOperands, trueDest, build(builder, result, condition, trueOperands, falseOperands, trueDest,
falseDest); falseDest);
}]>, OpBuilder< }]>, OpBuilder<
"Builder *builder, OperationState &result, Value condition," "OpBuilder &builder, OperationState &result, Value condition,"
"Block *trueDest, Block *falseDest, ValueRange falseOperands = {}", [{ "Block *trueDest, Block *falseDest, ValueRange falseOperands = {}", [{
build(builder, result, condition, trueDest, ValueRange(), falseDest, build(builder, result, condition, trueDest, ValueRange(), falseDest,
falseOperands); falseOperands);
}]>, LLVM_TerminatorPassthroughOpBuilder]; }]>, LLVM_TerminatorPassthroughOpBuilder];
} }
def LLVM_ReturnOp : LLVM_TerminatorOp<"return", [NoSideEffect]>, def LLVM_ReturnOp : LLVM_TerminatorOp<"return", [NoSideEffect]>,
Arguments<(ins Variadic<LLVM_Type>:$args)> { Arguments<(ins Variadic<LLVM_Type>:$args)> {
string llvmBuilder = [{ string llvmBuilder = [{
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Linesdef Linkage : LLVM_EnumAttr<
let cppNamespace = "::mlir::LLVM"; let cppNamespace = "::mlir::LLVM";
} }
def LLVM_AddressOfOp def LLVM_AddressOfOp
: LLVM_OneResultOp<"mlir.addressof">, : LLVM_OneResultOp<"mlir.addressof">,
Arguments<(ins FlatSymbolRefAttr:$global_name)> { Arguments<(ins FlatSymbolRefAttr:$global_name)> {
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, LLVMType resType, " OpBuilder<"OpBuilder &builder, OperationState &result, LLVMType resType, "
"StringRef name, ArrayRef<NamedAttribute> attrs = {}", [{ "StringRef name, ArrayRef<NamedAttribute> attrs = {}", [{
result.addAttribute("global_name", builder->getSymbolRefAttr(name)); result.addAttribute("global_name", builder.getSymbolRefAttr(name));
result.addAttributes(attrs); result.addAttributes(attrs);
result.addTypes(resType);}]>, result.addTypes(resType);}]>,
OpBuilder<"Builder *builder, OperationState &result, GlobalOp global, " OpBuilder<"OpBuilder &builder, OperationState &result, GlobalOp global, "
"ArrayRef<NamedAttribute> attrs = {}", [{ "ArrayRef<NamedAttribute> attrs = {}", [{
build(builder, result, build(builder, result,
global.getType().getPointerTo(global.addr_space().getZExtValue()), global.getType().getPointerTo(global.addr_space().getZExtValue()),
global.sym_name(), attrs);}]> global.sym_name(), attrs);}]>
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
/// Return the llvm.mlir.global operation that defined the value referenced /// Return the llvm.mlir.global operation that defined the value referenced
Show All 30 Lines Examples:
%0 = llvm.constant(0 : i32) : !llvm.i32 %0 = llvm.constant(0 : i32) : !llvm.i32
%1 = llvm.inttoptr %0 : !llvm.i32 to !llvm<"i32*"> %1 = llvm.inttoptr %0 : !llvm.i32 to !llvm<"i32*">
llvm.return %1 : !llvm<"i32*"> llvm.return %1 : !llvm<"i32*">
} }
}]; }];
let regions = (region AnyRegion:$initializer); let regions = (region AnyRegion:$initializer);
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, LLVMType type, " OpBuilder<"OpBuilder &builder, OperationState &result, LLVMType type, "
"bool isConstant, Linkage linkage, StringRef name, " "bool isConstant, Linkage linkage, StringRef name, "
"Attribute value, unsigned addrSpace = 0, " "Attribute value, unsigned addrSpace = 0, "
"ArrayRef<NamedAttribute> attrs = {}"> "ArrayRef<NamedAttribute> attrs = {}">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
/// Return the LLVM type of the global. /// Return the LLVM type of the global.
LLVMType getType() { LLVMType getType() {
Show All 31 Lines : LLVM_ZeroResultOp<"func", [AutomaticAllocationScope, IsolatedFromAbove,
OptionalAttr<ArrayAttr>:$passthrough)> { OptionalAttr<ArrayAttr>:$passthrough)> {
let summary = "LLVM dialect function, has wrapped LLVM IR function type"; let summary = "LLVM dialect function, has wrapped LLVM IR function type";
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, StringRef name, " OpBuilder<"OpBuilder &builder, OperationState &result, StringRef name, "
"LLVMType type, LLVM::Linkage linkage = LLVM::Linkage::External, " "LLVMType type, LLVM::Linkage linkage = LLVM::Linkage::External, "
"ArrayRef<NamedAttribute> attrs = {}, " "ArrayRef<NamedAttribute> attrs = {}, "
"ArrayRef<NamedAttributeList> argAttrs = {}"> "ArrayRef<NamedAttributeList> argAttrs = {}">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
// Add an entry block to an empty function, and set up the block arguments // Add an entry block to an empty function, and set up the block arguments
// to match the signature of the function. // to match the signature of the function.
▲ Show 20 Lines • Show All 321 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines let description = [{
Example: Example:
```mlir ```mlir
%3 = linalg.range %0:%1:%2 : !linalg.range %3 = linalg.range %0:%1:%2 : !linalg.range
```` ````
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value min, Value max, " "OpBuilder &builder, OperationState &result, Value min, Value max, "
"Value step", "Value step",
[{ [{
auto rangeType = RangeType::get(builder->getContext()); auto rangeType = RangeType::get(builder.getContext());
build(builder, result, rangeType, min, max, step); build(builder, result, rangeType, min, max, step);
}]>]; }]>];
// Fully specified by traits. // Fully specified by traits.
let verifier = ?; let verifier = ?;
let assemblyFormat = "$min `:` $max `:` $step attr-dict `:` type(results)"; let assemblyFormat = "$min `:` $max `:` $step attr-dict `:` type(results)";
} }
class Linalg_ReshapeLikeOp<string mnemonic> : class Linalg_ReshapeLikeOp<string mnemonic> :
Linalg_Op<mnemonic, [NoSideEffect]> { Linalg_Op<mnemonic, [NoSideEffect]> {
let builders = [ let builders = [
// Builder for a contracting reshape whose result type is computed from // Builder for a contracting reshape whose result type is computed from
// `src` and `reassociation`. // `src` and `reassociation`.
OpBuilder<"Builder *b, OperationState &result, Value src, " OpBuilder<"OpBuilder &b, OperationState &result, Value src, "
"ArrayRef<ArrayRef<AffineExpr>> reassociation, " "ArrayRef<ArrayRef<AffineExpr>> reassociation, "
"ArrayRef<NamedAttribute> attrs = {}">, "ArrayRef<NamedAttribute> attrs = {}">,
// Builder for a reshape whose result type is passed explicitly. This may be // Builder for a reshape whose result type is passed explicitly. This may be
// either a contracting or expanding reshape. // either a contracting or expanding reshape.
OpBuilder<"Builder *b, OperationState &result, Type resultType, Value src," OpBuilder<"OpBuilder &b, OperationState &result, Type resultType, Value src,"
"ArrayRef<ArrayRef<AffineExpr>> reassociation, " "ArrayRef<ArrayRef<AffineExpr>> reassociation, "
"ArrayRef<NamedAttribute> attrs = {}">]; "ArrayRef<NamedAttribute> attrs = {}">];
code commonExtraClassDeclaration = [{ code commonExtraClassDeclaration = [{
static StringRef getReassociationAttrName() { return "reassociation"; } static StringRef getReassociationAttrName() { return "reassociation"; }
}]; }];
let assemblyFormat = [{ let assemblyFormat = [{
$src $reassociation attr-dict `:` type($src) `into` type(results) $src $reassociation attr-dict `:` type($src) `into` type(results)
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines Examples:
```mlir ```mlir
%4 = linalg.slice %0[%1, %2] : memref<?x?xf32, stride_spec>, %4 = linalg.slice %0[%1, %2] : memref<?x?xf32, stride_spec>,
index, index, memref<?x?xf32, stride_spec> index, index, memref<?x?xf32, stride_spec>
``` ```
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, Value base, " "OpBuilder &b, OperationState &result, Value base, "
"ValueRange indexings">]; "ValueRange indexings">];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
enum { FirstIndexingOperand = 1 }; enum { FirstIndexingOperand = 1 };
unsigned getRank() { return getShapedType().getRank(); } unsigned getRank() { return getShapedType().getRank(); }
Type getElementType() { return getShapedType().getElementType(); } Type getElementType() { return getShapedType().getElementType(); }
ShapedType getShapedType() { return getType().cast<ShapedType>(); } ShapedType getShapedType() { return getType().cast<ShapedType>(); }
unsigned getBaseViewRank() { return getBaseViewType().getRank(); } unsigned getBaseViewRank() { return getBaseViewType().getRank(); }
Show All 27 Lines let description = [{
Example: Example:
```mlir ```mlir
%1 = linalg.transpose %0 (i, j) -> (j, i) : memref<?x?xf32, stride_spec> %1 = linalg.transpose %0 (i, j) -> (j, i) : memref<?x?xf32, stride_spec>
``` ```
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, Value view, " "OpBuilder &b, OperationState &result, Value view, "
"AffineMapAttr permutation, ArrayRef<NamedAttribute> attrs = {}">]; "AffineMapAttr permutation, ArrayRef<NamedAttribute> attrs = {}">];
let verifier = [{ let verifier = [{
if (!permutation().isPermutation()) if (!permutation().isPermutation())
return emitOpError("expected a permutation map"); return emitOpError("expected a permutation map");
if (permutation().getNumDims() != getShapedType().getRank()) if (permutation().getNumDims() != getShapedType().getRank())
return emitOpError("expected a permutation map of same rank as the view"); return emitOpError("expected a permutation map of same rank as the view");
return success(); return success();
Show All 27 Lines

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Lines let arguments = (ins
AnyStridedMemRef:$input, AnyStridedMemRef:$input,
AnyStridedMemRef:$output, AnyStridedMemRef:$output,
OptionalAttr<AffineMapAttr>:$inputPermutation, OptionalAttr<AffineMapAttr>:$inputPermutation,
OptionalAttr<AffineMapAttr>:$outputPermutation); OptionalAttr<AffineMapAttr>:$outputPermutation);
// TODO(ntv) this should go away once the usage of OptionalAttr triggers // TODO(ntv) this should go away once the usage of OptionalAttr triggers
// emission of builders with default arguments left unspecified. // emission of builders with default arguments left unspecified.
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value input, Value output", [{ "OpBuilder &builder, OperationState &result, Value input, Value output", [{
return build( return build(
builder, result, input, output, AffineMapAttr(), AffineMapAttr()); builder, result, input, output, AffineMapAttr(), AffineMapAttr());
}]>]; }]>];
let extraClassDeclaration = libraryCallName # [{ let extraClassDeclaration = libraryCallName # [{
// Rank-polymorphic. // Rank-polymorphic.
// filling_value -> O(ivs) with parallel iterators. // filling_value -> O(ivs) with parallel iterators.
llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() { llvm::Optional<SmallVector<StringRef, 8>> referenceIterators() {
▲ Show 20 Lines • Show All 700 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines let arguments = (ins Index:$lowerBound,
Index:$upperBound, Index:$upperBound,
Index:$step, Index:$step,
Variadic<AnyType>:$initArgs); Variadic<AnyType>:$initArgs);
let results = (outs Variadic<AnyType>:$results); let results = (outs Variadic<AnyType>:$results);
let regions = (region SizedRegion<1>:$region); let regions = (region SizedRegion<1>:$region);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"Value lowerBound, Value upperBound, Value step, " "Value lowerBound, Value upperBound, Value step, "
"ValueRange iterArgs = llvm::None"> "ValueRange iterArgs = llvm::None">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
Block *getBody() { return &region().front(); } Block *getBody() { return &region().front(); }
Value getInductionVar() { return getBody()->getArgument(0); } Value getInductionVar() { return getBody()->getArgument(0); }
OpBuilder getBodyBuilder() { OpBuilder getBodyBuilder() {
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines let description = [{
``` ```
}]; }];
let arguments = (ins I1:$condition); let arguments = (ins I1:$condition);
let results = (outs Variadic<AnyType>:$results); let results = (outs Variadic<AnyType>:$results);
let regions = (region SizedRegion<1>:$thenRegion, AnyRegion:$elseRegion); let regions = (region SizedRegion<1>:$thenRegion, AnyRegion:$elseRegion);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"Value cond, bool withElseRegion">, "Value cond, bool withElseRegion">,
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"TypeRange resultTypes, Value cond, bool withElseRegion"> "TypeRange resultTypes, Value cond, bool withElseRegion">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
OpBuilder getThenBodyBuilder() { OpBuilder getThenBodyBuilder() {
assert(!thenRegion().empty() && "Unexpected empty 'then' region."); assert(!thenRegion().empty() && "Unexpected empty 'then' region.");
Block &body = thenRegion().front(); Block &body = thenRegion().front();
return OpBuilder(&body, return OpBuilder(&body,
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines let arguments = (ins Variadic<Index>:$lowerBound,
Variadic<Index>:$upperBound, Variadic<Index>:$upperBound,
Variadic<Index>:$step, Variadic<Index>:$step,
Variadic<AnyType>:$initVals); Variadic<AnyType>:$initVals);
let results = (outs Variadic<AnyType>:$results); let results = (outs Variadic<AnyType>:$results);
let regions = (region SizedRegion<1>:$region); let regions = (region SizedRegion<1>:$region);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"ValueRange lowerBounds, ValueRange upperBounds, " "ValueRange lowerBounds, ValueRange upperBounds, "
"ValueRange steps, ValueRange initVals = {}">, "ValueRange steps, ValueRange initVals = {}">,
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
Block *getBody() { return &region().front(); } Block *getBody() { return &region().front(); }
ValueRange getInductionVars() { ValueRange getInductionVars() {
return getBody()->getArguments(); return getBody()->getArguments();
Show All 37 Lines loop.reduce(%operand) : f32 {
%res = addf %lhs, %rhs : f32 %res = addf %lhs, %rhs : f32
loop.reduce.return %res : f32 loop.reduce.return %res : f32
} }
``` ```
}]; }];
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"Value operand"> "Value operand">
]; ];
let arguments = (ins AnyType:$operand); let arguments = (ins AnyType:$operand);
let regions = (region SizedRegion<1>:$reductionOperator); let regions = (region SizedRegion<1>:$reductionOperator);
} }
def ReduceReturnOp : def ReduceReturnOp :
Show All 25 Lines let description = [{
If the parent operation defines no values, then the "loop.yield" may be If the parent operation defines no values, then the "loop.yield" may be
left out in the custom syntax and the builders will insert one implicitly. left out in the custom syntax and the builders will insert one implicitly.
Otherwise, it has to be present in the syntax to indicate which values are Otherwise, it has to be present in the syntax to indicate which values are
yielded. yielded.
}]; }];
let arguments = (ins Variadic<AnyType>:$results); let arguments = (ins Variadic<AnyType>:$results);
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result", OpBuilder<"OpBuilder &builder, OperationState &result",
[{ /* nothing to do */ }]> [{ /* nothing to do */ }]>
]; ];
} }
#endif // LOOP_OPS #endif // LOOP_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVAtomicOps.td

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesclass SPV_AtomicUpdateWithValueOp<string mnemonic, list<OpTrait> traits = []> :
); );
let results = (outs let results = (outs
SPV_Integer:$result SPV_Integer:$result
); );
let builders = [ let builders = [
OpBuilder< OpBuilder<
[{Builder *builder, OperationState &state, Value pointer, [{OpBuilder &builder, OperationState &state, Value pointer,
::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory, ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
Value value}], Value value}],
[{build(builder, state, value.getType(), pointer, scope, memory, value);}] [{build(builder, state, value.getType(), pointer, scope, memory, value);}]
> >
]; ];
} }
// ----- // -----
▲ Show 20 Lines • Show All 509 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/SPIRV/SPIRVCompositeOps.td

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines let arguments = (ins
I32ArrayAttr:$indices I32ArrayAttr:$indices
); );
let results = (outs let results = (outs
SPV_Type:$component SPV_Type:$component
); );
let builders = [ let builders = [
OpBuilder<[{Builder *builder, OperationState &state, OpBuilder<[{OpBuilder &builder, OperationState &state,
Value composite, ArrayRef<int32_t> indices}]> Value composite, ArrayRef<int32_t> indices}]>
]; ];
let hasFolder = 1; let hasFolder = 1;
} }
// ----- // -----
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesdef SPV_BranchOp : SPV_Op<"Branch", [
let results = (outs); let results = (outs);
let successors = (successor AnySuccessor:$target); let successors = (successor AnySuccessor:$target);
let verifier = [{ return success(); }]; let verifier = [{ return success(); }];
let builders = [ let builders = [
OpBuilder< OpBuilder<
"Builder *, OperationState &state, " "OpBuilder &, OperationState &state, "
"Block *successor, ValueRange arguments = {}", [{ "Block *successor, ValueRange arguments = {}", [{
state.addSuccessors(successor); state.addSuccessors(successor);
state.addOperands(arguments); state.addOperands(arguments);
}] }]
> >
]; ];
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linesdef SPV_BranchConditionalOp : SPV_Op<"BranchConditional", [
let results = (outs); let results = (outs);
let successors = (successor AnySuccessor:$trueTarget, let successors = (successor AnySuccessor:$trueTarget,
AnySuccessor:$falseTarget); AnySuccessor:$falseTarget);
let builders = [ let builders = [
OpBuilder< OpBuilder<
"Builder *builder, OperationState &state, Value condition, " "OpBuilder &builder, OperationState &state, Value condition, "
"Block *trueBlock, ValueRange trueArguments, " "Block *trueBlock, ValueRange trueArguments, "
"Block *falseBlock, ValueRange falseArguments, " "Block *falseBlock, ValueRange falseArguments, "
"Optional<std::pair<uint32_t, uint32_t>> weights = {}", "Optional<std::pair<uint32_t, uint32_t>> weights = {}",
[{ [{
ArrayAttr weightsAttr; ArrayAttr weightsAttr;
if (weights) { if (weights) {
weightsAttr = weightsAttr =
builder->getI32ArrayAttr({static_cast<int32_t>(weights->first), builder.getI32ArrayAttr({static_cast<int32_t>(weights->first),
static_cast<int32_t>(weights->second)}); static_cast<int32_t>(weights->second)});
} }
build(builder, state, condition, trueArguments, falseArguments, build(builder, state, condition, trueArguments, falseArguments,
weightsAttr, trueBlock, falseBlock); weightsAttr, trueBlock, falseBlock);
}] }]
> >
]; ];
let autogenSerialization = 0; let autogenSerialization = 0;
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Linesdef SPV_LoopOp : SPV_Op<"loop", [InFunctionScope]> {
let arguments = (ins let arguments = (ins
SPV_LoopControlAttr:$loop_control SPV_LoopControlAttr:$loop_control
); );
let results = (outs); let results = (outs);
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let builders = [OpBuilder<"Builder *builder, OperationState &state">]; let builders = [OpBuilder<"OpBuilder &builder, OperationState &state">];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
// Returns the entry block. // Returns the entry block.
Block *getEntryBlock(); Block *getEntryBlock();
// Returns the loop header block. // Returns the loop header block.
Block *getHeaderBlock(); Block *getHeaderBlock();
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Lines let extraClassDeclaration = [{
/// Adds a selection merge block containing one spv._merge op. /// Adds a selection merge block containing one spv._merge op.
void addMergeBlock(); void addMergeBlock();
/// Creates a spv.selection op for `if (<condition>) then { <thenBody> }` /// Creates a spv.selection op for `if (<condition>) then { <thenBody> }`
/// with `builder`. `builder`'s insertion point will remain at after the /// with `builder`. `builder`'s insertion point will remain at after the
/// newly inserted spv.selection op afterwards. /// newly inserted spv.selection op afterwards.
static SelectionOp createIfThen( static SelectionOp createIfThen(
Location loc, Value condition, Location loc, Value condition,
function_ref<void(OpBuilder *builder)> thenBody, function_ref<void(OpBuilder &builder)> thenBody,
OpBuilder *builder); OpBuilder &builder);
}]; }];
let hasOpcode = 0; let hasOpcode = 0;
let autogenSerialization = 0; let autogenSerialization = 0;
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
} }
#endif // SPIRV_CONTROLFLOW_OPS #endif // SPIRV_CONTROLFLOW_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVLogicalOps.td

Show First 20 Lines • Show All 848 Lines • ▼ Show 20 Lines let arguments = (ins
SPV_SelectType:$true_value, SPV_SelectType:$true_value,
SPV_SelectType:$false_value SPV_SelectType:$false_value
); );
let results = (outs let results = (outs
SPV_SelectType:$result SPV_SelectType:$result
); );
let builders = [OpBuilder<[{Builder *builder, OperationState &state, let builders = [OpBuilder<[{OpBuilder &builder, OperationState &state,
Value cond, Value trueValue, Value cond, Value trueValue,
Value falseValue}]>]; Value falseValue}]>];
let assemblyFormat = [{ let assemblyFormat = [{
operands attr-dict `:` type($condition) `,` type($result) operands attr-dict `:` type($condition) `,` type($result)
}]; }];
} }
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/SPIRV/SPIRVNonUniformOps.td

Show First 20 Lines • Show All 141 Lines • ▼ Show 20 Lines let arguments = (ins
SPV_ScopeAttr:$execution_scope SPV_ScopeAttr:$execution_scope
); );
let results = (outs let results = (outs
SPV_Bool:$result SPV_Bool:$result
); );
let builders = [ let builders = [
OpBuilder<[{Builder *builder, OperationState &state, spirv::Scope}]> OpBuilder<[{OpBuilder &builder, OperationState &state, spirv::Scope}]>
]; ];
let assemblyFormat = "$execution_scope attr-dict `:` type($result)"; let assemblyFormat = "$execution_scope attr-dict `:` type($result)";
} }
// ----- // -----
def SPV_GroupNonUniformFAddOp : def SPV_GroupNonUniformFAddOp :
▲ Show 20 Lines • Show All 506 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.td

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines let arguments = (ins
SPV_AnyPtr:$base_ptr, SPV_AnyPtr:$base_ptr,
Variadic<SPV_Integer>:$indices Variadic<SPV_Integer>:$indices
); );
let results = (outs let results = (outs
SPV_AnyPtr:$component_ptr SPV_AnyPtr:$component_ptr
); );
let builders = [OpBuilder<[{Builder *builder, OperationState &state, let builders = [OpBuilder<[{OpBuilder &builder, OperationState &state,
Value basePtr, ValueRange indices}]>]; Value basePtr, ValueRange indices}]>];
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
} }
// ----- // -----
def SPV_ControlBarrierOp : SPV_Op<"ControlBarrier", []> { def SPV_ControlBarrierOp : SPV_Op<"ControlBarrier", []> {
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Linesdef SPV_ExecutionModeOp : SPV_Op<"ExecutionMode", [InModuleScope]> {
); );
let results = (outs); let results = (outs);
let verifier = [{ return success(); }]; let verifier = [{ return success(); }];
let autogenSerialization = 0; let autogenSerialization = 0;
let builders = [OpBuilder<[{Builder *builder, OperationState &state, let builders = [OpBuilder<[{OpBuilder &builder, OperationState &state,
spirv::FuncOp function, spirv::FuncOp function,
spirv::ExecutionMode executionMode, spirv::ExecutionMode executionMode,
ArrayRef<int32_t> params}]>]; ArrayRef<int32_t> params}]>];
} }
// ----- // -----
def SPV_LoadOp : SPV_Op<"Load", []> { def SPV_LoadOp : SPV_Op<"Load", []> {
Show All 38 Linesdef SPV_LoadOp : SPV_Op<"Load", []> {
); );
let results = (outs let results = (outs
SPV_Type:$value SPV_Type:$value
); );
let builders = [ let builders = [
OpBuilder<[{ OpBuilder<[{
Builder *builder, OperationState &state, OpBuilder &builder, OperationState &state,
Value basePtr, IntegerAttr memory_access = {}, Value basePtr, IntegerAttr memory_access = {},
IntegerAttr alignment = {} IntegerAttr alignment = {}
}]> }]>
]; ];
} }
// ----- // -----
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines let arguments = (ins
SPV_Type:$value, SPV_Type:$value,
OptionalAttr<SPV_MemoryAccessAttr>:$memory_access, OptionalAttr<SPV_MemoryAccessAttr>:$memory_access,
OptionalAttr<I32Attr>:$alignment OptionalAttr<I32Attr>:$alignment
); );
let results = (outs); let results = (outs);
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"Value ptr, Value value, ArrayRef<NamedAttribute> namedAttrs = {}", [{ "Value ptr, Value value, ArrayRef<NamedAttribute> namedAttrs = {}", [{
state.addOperands(ptr); state.addOperands(ptr);
state.addOperands(value); state.addOperands(value);
state.addAttributes(namedAttrs); state.addAttributes(namedAttrs);
}]> }]>
]; ];
} }
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linesdef SPV_AddressOfOp : SPV_Op<"_address_of", [InFunctionScope, NoSideEffect]> {
let results = (outs let results = (outs
SPV_AnyPtr:$pointer SPV_AnyPtr:$pointer
); );
let hasOpcode = 0; let hasOpcode = 0;
let autogenSerialization = 0; let autogenSerialization = 0;
let builders = [OpBuilder<[{Builder *builder, OperationState &state, let builders = [OpBuilder<[{OpBuilder &builder, OperationState &state,
spirv::GlobalVariableOp var}]>]; spirv::GlobalVariableOp var}]>];
let assemblyFormat = "$variable attr-dict `:` type($pointer)"; let assemblyFormat = "$variable attr-dict `:` type($pointer)";
} }
// ----- // -----
def SPV_ConstantOp : SPV_Op<"constant", [ConstantLike, NoSideEffect]> { def SPV_ConstantOp : SPV_Op<"constant", [ConstantLike, NoSideEffect]> {
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesdef SPV_ConstantOp : SPV_Op<"constant", [ConstantLike, NoSideEffect]> {
let extraClassDeclaration = [{ let extraClassDeclaration = [{
// Returns true if a constant can be built for the given `type`. // Returns true if a constant can be built for the given `type`.
static bool isBuildableWith(Type type); static bool isBuildableWith(Type type);
// Creates a constant zero/one of the given `type` at the current insertion // Creates a constant zero/one of the given `type` at the current insertion
// point of `builder` and returns it. // point of `builder` and returns it.
static spirv::ConstantOp getZero(Type type, Location loc, static spirv::ConstantOp getZero(Type type, Location loc,
OpBuilder *builder); OpBuilder &builder);
static spirv::ConstantOp getOne(Type type, Location loc, static spirv::ConstantOp getOne(Type type, Location loc,
OpBuilder *builder); OpBuilder &builder);
}]; }];
let hasOpcode = 0; let hasOpcode = 0;
let autogenSerialization = 0; let autogenSerialization = 0;
} }
// ----- // -----
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines let arguments = (ins
FlatSymbolRefAttr:$fn, FlatSymbolRefAttr:$fn,
SymbolRefArrayAttr:$interface SymbolRefArrayAttr:$interface
); );
let results = (outs); let results = (outs);
let autogenSerialization = 0; let autogenSerialization = 0;
let builders = [OpBuilder<[{Builder *builder, OperationState &state, let builders = [OpBuilder<[{OpBuilder &builder, OperationState &state,
spirv::ExecutionModel executionModel, spirv::ExecutionModel executionModel,
spirv::FuncOp function, spirv::FuncOp function,
ArrayRef<Attribute> interfaceVars}]>]; ArrayRef<Attribute> interfaceVars}]>];
} }
// ----- // -----
def SPV_FuncOp : SPV_Op<"func", [ def SPV_FuncOp : SPV_Op<"func", [
Show All 38 Linesdef SPV_FuncOp : SPV_Op<"func", [
let results = (outs); let results = (outs);
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let verifier = [{ return success(); }]; let verifier = [{ return success(); }];
let builders = [OpBuilder<[{ let builders = [OpBuilder<[{
Builder *, OperationState &state, OpBuilder &, OperationState &state,
StringRef name, FunctionType type, StringRef name, FunctionType type,
spirv::FunctionControl control = spirv::FunctionControl::None, spirv::FunctionControl control = spirv::FunctionControl::None,
ArrayRef<NamedAttribute> attrs = {} ArrayRef<NamedAttribute> attrs = {}
}]>]; }]>];
let hasOpcode = 0; let hasOpcode = 0;
let autogenSerialization = 0; let autogenSerialization = 0;
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines let arguments = (ins
TypeAttr:$type, TypeAttr:$type,
StrAttr:$sym_name, StrAttr:$sym_name,
OptionalAttr<FlatSymbolRefAttr>:$initializer OptionalAttr<FlatSymbolRefAttr>:$initializer
); );
let results = (outs); let results = (outs);
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &state, " OpBuilder<"OpBuilder &builder, OperationState &state, "
"TypeAttr type, ArrayRef<NamedAttribute> namedAttrs", [{ "TypeAttr type, ArrayRef<NamedAttribute> namedAttrs", [{
state.addAttribute("type", type); state.addAttribute("type", type);
state.addAttributes(namedAttrs); state.addAttributes(namedAttrs);
}]>, }]>,
OpBuilder<[{Builder *builder, OperationState &state, OpBuilder<[{OpBuilder &builder, OperationState &state,
Type type, StringRef name, unsigned descriptorSet, Type type, StringRef name, unsigned descriptorSet,
unsigned binding}]>, unsigned binding}]>,
OpBuilder<[{Builder *builder, OperationState &state, OpBuilder<[{OpBuilder &builder, OperationState &state,
Type type, StringRef name, spirv::BuiltIn builtin}]> Type type, StringRef name, spirv::BuiltIn builtin}]>
]; ];
let hasOpcode = 0; let hasOpcode = 0;
let autogenSerialization = 0; let autogenSerialization = 0;
let extraClassDeclaration = [{ let extraClassDeclaration = [{
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines let arguments = (ins
OptionalAttr<SPV_VerCapExtAttr>:$vce_triple OptionalAttr<SPV_VerCapExtAttr>:$vce_triple
); );
let results = (outs); let results = (outs);
let regions = (region SizedRegion<1>:$body); let regions = (region SizedRegion<1>:$body);
let builders = [ let builders = [
OpBuilder<[{Builder *, OperationState &state}]>, OpBuilder<[{OpBuilder &, OperationState &state}]>,
OpBuilder<[{Builder *, OperationState &state, OpBuilder<[{OpBuilder &, OperationState &state,
spirv::AddressingModel addressing_model, spirv::AddressingModel addressing_model,
spirv::MemoryModel memory_model}]> spirv::MemoryModel memory_model}]>
]; ];
// We need to ensure the block inside the region is properly terminated; // We need to ensure the block inside the region is properly terminated;
// the auto-generated builders do not guarantee that. // the auto-generated builders do not guarantee that.
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

Show First 20 Lines • Show All 293 Lines • ▼ Show 20 Lines
} }
def Shape_YieldOp : Shape_Op<"yield", [NoSideEffect, Terminator]> { def Shape_YieldOp : Shape_Op<"yield", [NoSideEffect, Terminator]> {
let summary = "Returns the value to parent op"; let summary = "Returns the value to parent op";
let arguments = (ins Variadic<AnyType>:$operands); let arguments = (ins Variadic<AnyType>:$operands);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result", [{ build(b, result, llvm::None); }] "OpBuilder &b, OperationState &result", [{ build(b, result, llvm::None); }]
>]; >];
let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?"; let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
} }
// TODO: Add Ops: if_static, if_ranked // TODO: Add Ops: if_static, if_ranked
// For testing usage. // For testing usage.
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

Show All 40 Lines
/// ///
/// %1 = "std.constant"(){value: 42.0} : bf16 /// %1 = "std.constant"(){value: 42.0} : bf16
/// ///
class ConstantFloatOp : public ConstantOp { class ConstantFloatOp : public ConstantOp {
public: public:
using ConstantOp::ConstantOp; using ConstantOp::ConstantOp;
/// Builds a constant float op producing a float of the specified type. /// Builds a constant float op producing a float of the specified type.
static void build(Builder *builder, OperationState &result, static void build(OpBuilder &builder, OperationState &result,
const APFloat &value, FloatType type); const APFloat &value, FloatType type);
APFloat getValue() { return getAttrOfType<FloatAttr>("value").getValue(); } APFloat getValue() { return getAttrOfType<FloatAttr>("value").getValue(); }
static bool classof(Operation *op); static bool classof(Operation *op);
}; };
/// This is a refinement of the "constant" op for the case where it is /// This is a refinement of the "constant" op for the case where it is
/// returning an integer value of IntegerType. /// returning an integer value of IntegerType.
/// ///
/// %1 = "std.constant"(){value: 42} : i32 /// %1 = "std.constant"(){value: 42} : i32
/// ///
class ConstantIntOp : public ConstantOp { class ConstantIntOp : public ConstantOp {
public: public:
using ConstantOp::ConstantOp; using ConstantOp::ConstantOp;
/// Build a constant int op producing an integer of the specified width. /// Build a constant int op producing an integer of the specified width.
static void build(Builder *builder, OperationState &result, int64_t value, static void build(OpBuilder &builder, OperationState &result, int64_t value,
unsigned width); unsigned width);
/// Build a constant int op producing an integer with the specified type, /// Build a constant int op producing an integer with the specified type,
/// which must be an integer type. /// which must be an integer type.
static void build(Builder *builder, OperationState &result, int64_t value, static void build(OpBuilder &builder, OperationState &result, int64_t value,
Type type); Type type);
int64_t getValue() { return getAttrOfType<IntegerAttr>("value").getInt(); } int64_t getValue() { return getAttrOfType<IntegerAttr>("value").getInt(); }
static bool classof(Operation *op); static bool classof(Operation *op);
}; };
/// This is a refinement of the "constant" op for the case where it is /// This is a refinement of the "constant" op for the case where it is
/// returning an integer value of Index type. /// returning an integer value of Index type.
/// ///
/// %1 = "std.constant"(){value: 99} : () -> index /// %1 = "std.constant"(){value: 99} : () -> index
/// ///
class ConstantIndexOp : public ConstantOp { class ConstantIndexOp : public ConstantOp {
public: public:
using ConstantOp::ConstantOp; using ConstantOp::ConstantOp;
/// Build a constant int op producing an index. /// Build a constant int op producing an index.
static void build(Builder *builder, OperationState &result, int64_t value); static void build(OpBuilder &builder, OperationState &result, int64_t value);
int64_t getValue() { return getAttrOfType<IntegerAttr>("value").getInt(); } int64_t getValue() { return getAttrOfType<IntegerAttr>("value").getInt(); }
static bool classof(Operation *op); static bool classof(Operation *op);
}; };
// DmaStartOp starts a non-blocking DMA operation that transfers data from a // DmaStartOp starts a non-blocking DMA operation that transfers data from a
// source memref to a destination memref. The source and destination memref need // source memref to a destination memref. The source and destination memref need
Show All 32 Lines
// TODO(mlir-team): add additional operands to allow source and destination // TODO(mlir-team): add additional operands to allow source and destination
// striding, and multiple stride levels. // striding, and multiple stride levels.
// TODO(andydavis) Consider replacing src/dst memref indices with view memrefs. // TODO(andydavis) Consider replacing src/dst memref indices with view memrefs.
class DmaStartOp class DmaStartOp
: public Op<DmaStartOp, OpTrait::VariadicOperands, OpTrait::ZeroResult> { : public Op<DmaStartOp, OpTrait::VariadicOperands, OpTrait::ZeroResult> {
public: public:
using Op::Op; using Op::Op;
static void build(Builder *builder, OperationState &result, Value srcMemRef, static void build(OpBuilder &builder, OperationState &result, Value srcMemRef,
ValueRange srcIndices, Value destMemRef, ValueRange srcIndices, Value destMemRef,
ValueRange destIndices, Value numElements, Value tagMemRef, ValueRange destIndices, Value numElements, Value tagMemRef,
ValueRange tagIndices, Value stride = nullptr, ValueRange tagIndices, Value stride = nullptr,
Value elementsPerStride = nullptr); Value elementsPerStride = nullptr);
// Returns the source MemRefType for this DMA operation. // Returns the source MemRefType for this DMA operation.
Value getSrcMemRef() { return getOperand(0); } Value getSrcMemRef() { return getOperand(0); }
// Returns the rank (number of indices) of the source MemRefType. // Returns the rank (number of indices) of the source MemRefType.
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines
// ... // ...
// dma_wait %tag[%index], %num_elements : memref<1 x i32, (d0) -> (d0), 2> // dma_wait %tag[%index], %num_elements : memref<1 x i32, (d0) -> (d0), 2>
// //
class DmaWaitOp class DmaWaitOp
: public Op<DmaWaitOp, OpTrait::VariadicOperands, OpTrait::ZeroResult> { : public Op<DmaWaitOp, OpTrait::VariadicOperands, OpTrait::ZeroResult> {
public: public:
using Op::Op; using Op::Op;
static void build(Builder *builder, OperationState &result, Value tagMemRef, static void build(OpBuilder &builder, OperationState &result, Value tagMemRef,
ValueRange tagIndices, Value numElements); ValueRange tagIndices, Value numElements);
static StringRef getOperationName() { return "std.dma_wait"; } static StringRef getOperationName() { return "std.dma_wait"; }
// Returns the Tag MemRef associated with the DMA operation being waited on. // Returns the Tag MemRef associated with the DMA operation being waited on.
Value getTagMemRef() { return getOperand(0); } Value getTagMemRef() { return getOperand(0); }
// Returns the tag memref index for this DMA operation. // Returns the tag memref index for this DMA operation.
Show All 34 Lines

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

Show All 40 Lines
// Base class for standard cast operations. Requires single operand and result, // Base class for standard cast operations. Requires single operand and result,
// but does not constrain them to specific types. // but does not constrain them to specific types.
class CastOp<string mnemonic, list<OpTrait> traits = []> : class CastOp<string mnemonic, list<OpTrait> traits = []> :
Std_Op<mnemonic, !listconcat(traits, [NoSideEffect])> { Std_Op<mnemonic, !listconcat(traits, [NoSideEffect])> {
let results = (outs AnyType); let results = (outs AnyType);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value source, Type destType", [{ "OpBuilder &builder, OperationState &result, Value source, Type destType", [{
impl::buildCastOp(builder, result, source, destType); impl::buildCastOp(builder, result, source, destType);
}]>]; }]>];
let parser = [{ let parser = [{
return impl::parseCastOp(parser, result); return impl::parseCastOp(parser, result);
}]; }];
let printer = [{ let printer = [{
return printStandardCastOp(this->getOperation(), p); return printStandardCastOp(this->getOperation(), p);
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
class AllocLikeOp<string mnemonic, list<OpTrait> traits = []> : class AllocLikeOp<string mnemonic, list<OpTrait> traits = []> :
Std_Op<mnemonic, traits> { Std_Op<mnemonic, traits> {
let arguments = (ins Variadic<Index>:$value, let arguments = (ins Variadic<Index>:$value,
Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$alignment); Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$alignment);
let results = (outs AnyMemRef); let results = (outs AnyMemRef);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, MemRefType memrefType", [{ "OpBuilder &builder, OperationState &result, MemRefType memrefType", [{
result.types.push_back(memrefType); result.types.push_back(memrefType);
}]>, }]>,
OpBuilder< OpBuilder<
"Builder *builder, OperationState &result, MemRefType memrefType, " # "OpBuilder &builder, OperationState &result, MemRefType memrefType, " #
"ValueRange operands, IntegerAttr alignment = IntegerAttr()", [{ "ValueRange operands, IntegerAttr alignment = IntegerAttr()", [{
result.addOperands(operands); result.addOperands(operands);
result.types.push_back(memrefType); result.types.push_back(memrefType);
if (alignment) if (alignment)
result.addAttribute(getAlignmentAttrName(), alignment); result.addAttribute(getAlignmentAttrName(), alignment);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
▲ Show 20 Lines • Show All 368 Lines • ▼ Show 20 Linesdef GenericAtomicRMWOp : Std_Op<"generic_atomic_rmw", [
let results = (outs let results = (outs
AnyTypeOf<[AnySignlessInteger, AnyFloat]>:$result); AnyTypeOf<[AnySignlessInteger, AnyFloat]>:$result);
let regions = (region AnyRegion:$body); let regions = (region AnyRegion:$body);
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, " OpBuilder<"OpBuilder &builder, OperationState &result, "
"Value memref, ValueRange ivs"> "Value memref, ValueRange ivs">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
OpBuilder getBodyBuilder() { OpBuilder getBodyBuilder() {
assert(!body().empty() && "Unexpected empty 'body' region."); assert(!body().empty() && "Unexpected empty 'body' region.");
Block &block = body().front(); Block &block = body().front();
return OpBuilder(&block, block.end()); return OpBuilder(&block, block.end());
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines ^bb2:
br ^bb3(%2 : tensor<*xf32>) br ^bb3(%2 : tensor<*xf32>)
^bb3(%3: tensor<*xf32>): ^bb3(%3: tensor<*xf32>):
``` ```
}]; }];
let arguments = (ins Variadic<AnyType>:$destOperands); let arguments = (ins Variadic<AnyType>:$destOperands);
let successors = (successor AnySuccessor:$dest); let successors = (successor AnySuccessor:$dest);
let builders = [OpBuilder<"Builder *, OperationState &result, Block *dest, " let builders = [OpBuilder<"OpBuilder &, OperationState &result, Block *dest, "
"ValueRange destOperands = {}", [{ "ValueRange destOperands = {}", [{
result.addSuccessors(dest); result.addSuccessors(dest);
result.addOperands(destOperands); result.addOperands(destOperands);
}]>]; }]>];
// BranchOp is fully verified by traits. // BranchOp is fully verified by traits.
let verifier = ?; let verifier = ?;
Show All 33 Lines let description = [{
%2 = call @my_add(%0, %1) : (f32, f32) -> f32 %2 = call @my_add(%0, %1) : (f32, f32) -> f32
``` ```
}]; }];
let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<AnyType>:$operands); let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<AnyType>:$operands);
let results = (outs Variadic<AnyType>); let results = (outs Variadic<AnyType>);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, FuncOp callee," "OpBuilder &builder, OperationState &result, FuncOp callee,"
"ValueRange operands = {}", [{ "ValueRange operands = {}", [{
result.addOperands(operands); result.addOperands(operands);
result.addAttribute("callee", builder->getSymbolRefAttr(callee)); result.addAttribute("callee", builder.getSymbolRefAttr(callee));
result.addTypes(callee.getType().getResults()); result.addTypes(callee.getType().getResults());
}]>, OpBuilder< }]>, OpBuilder<
"Builder *builder, OperationState &result, SymbolRefAttr callee," "OpBuilder &builder, OperationState &result, SymbolRefAttr callee,"
"ArrayRef<Type> results, ValueRange operands = {}", [{ "ArrayRef<Type> results, ValueRange operands = {}", [{
result.addOperands(operands); result.addOperands(operands);
result.addAttribute("callee", callee); result.addAttribute("callee", callee);
result.addTypes(results); result.addTypes(results);
}]>, OpBuilder< }]>, OpBuilder<
"Builder *builder, OperationState &result, StringRef callee," "OpBuilder &builder, OperationState &result, StringRef callee,"
"ArrayRef<Type> results, ValueRange operands = {}", [{ "ArrayRef<Type> results, ValueRange operands = {}", [{
build(builder, result, builder->getSymbolRefAttr(callee), results, build(builder, result, builder.getSymbolRefAttr(callee), results,
operands); operands);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
StringRef getCallee() { return callee(); } StringRef getCallee() { return callee(); }
FunctionType getCalleeType(); FunctionType getCalleeType();
/// Get the argument operands to the called function. /// Get the argument operands to the called function.
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines %31 = call_indirect %15(%0, %1)
: (tensor<16xf32>, tensor<16xf32>) -> tensor<16xf32> : (tensor<16xf32>, tensor<16xf32>) -> tensor<16xf32>
``` ```
}]; }];
let arguments = (ins FunctionType:$callee, Variadic<AnyType>:$operands); let arguments = (ins FunctionType:$callee, Variadic<AnyType>:$operands);
let results = (outs Variadic<AnyType>:$results); let results = (outs Variadic<AnyType>:$results);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *, OperationState &result, Value callee," "OpBuilder &, OperationState &result, Value callee,"
"ValueRange operands = {}", [{ "ValueRange operands = {}", [{
result.operands.push_back(callee); result.operands.push_back(callee);
result.addOperands(operands); result.addOperands(operands);
result.addTypes(callee.getType().cast<FunctionType>().getResults()); result.addTypes(callee.getType().cast<FunctionType>().getResults());
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
Value getCallee() { return getOperand(0); } Value getCallee() { return getOperand(0); }
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Linesdef CmpFOp : Std_Op<"cmpf",
let arguments = (ins let arguments = (ins
CmpFPredicateAttr:$predicate, CmpFPredicateAttr:$predicate,
FloatLike:$lhs, FloatLike:$lhs,
FloatLike:$rhs FloatLike:$rhs
); );
let results = (outs BoolLike:$result); let results = (outs BoolLike:$result);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, CmpFPredicate predicate," "OpBuilder &builder, OperationState &result, CmpFPredicate predicate,"
"Value lhs, Value rhs", [{ "Value lhs, Value rhs", [{
::buildCmpFOp(builder, result, predicate, lhs, rhs); ::buildCmpFOp(builder, result, predicate, lhs, rhs);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static StringRef getPredicateAttrName() { return "predicate"; } static StringRef getPredicateAttrName() { return "predicate"; }
static CmpFPredicate getPredicateByName(StringRef name); static CmpFPredicate getPredicateByName(StringRef name);
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Linesdef CmpIOp : Std_Op<"cmpi",
let arguments = (ins let arguments = (ins
CmpIPredicateAttr:$predicate, CmpIPredicateAttr:$predicate,
SignlessIntegerLike:$lhs, SignlessIntegerLike:$lhs,
SignlessIntegerLike:$rhs SignlessIntegerLike:$rhs
); );
let results = (outs BoolLike:$result); let results = (outs BoolLike:$result);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, CmpIPredicate predicate," "OpBuilder &builder, OperationState &result, CmpIPredicate predicate,"
"Value lhs, Value rhs", [{ "Value lhs, Value rhs", [{
::buildCmpIOp(builder, result, predicate, lhs, rhs); ::buildCmpIOp(builder, result, predicate, lhs, rhs);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static StringRef getPredicateAttrName() { return "predicate"; } static StringRef getPredicateAttrName() { return "predicate"; }
static CmpIPredicate getPredicateByName(StringRef name); static CmpIPredicate getPredicateByName(StringRef name);
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Linesdef CondBranchOp : Std_Op<"cond_br",
}]; }];
let arguments = (ins I1:$condition, let arguments = (ins I1:$condition,
Variadic<AnyType>:$trueDestOperands, Variadic<AnyType>:$trueDestOperands,
Variadic<AnyType>:$falseDestOperands); Variadic<AnyType>:$falseDestOperands);
let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest); let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value condition," "OpBuilder &builder, OperationState &result, Value condition,"
"Block *trueDest, ValueRange trueOperands," "Block *trueDest, ValueRange trueOperands,"
"Block *falseDest, ValueRange falseOperands", [{ "Block *falseDest, ValueRange falseOperands", [{
build(builder, result, condition, trueOperands, falseOperands, trueDest, build(builder, result, condition, trueOperands, falseOperands, trueDest,
falseDest); falseDest);
}]>, OpBuilder< }]>, OpBuilder<
"Builder *builder, OperationState &result, Value condition," "OpBuilder &builder, OperationState &result, Value condition,"
"Block *trueDest, Block *falseDest, ValueRange falseOperands = {}", [{ "Block *trueDest, Block *falseDest, ValueRange falseOperands = {}", [{
build(builder, result, condition, trueDest, ValueRange(), falseDest, build(builder, result, condition, trueDest, ValueRange(), falseDest,
falseOperands); falseOperands);
}]>]; }]>];
// CondBranchOp is fully verified by traits. // CondBranchOp is fully verified by traits.
let verifier = ?; let verifier = ?;
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines let description = [{
reference a function simplifies this reference a function simplifies this
([rationale](../Rationale/Rationale.md#multithreading-the-compiler)). ([rationale](../Rationale/Rationale.md#multithreading-the-compiler)).
}]; }];
let arguments = (ins AnyAttr:$value); let arguments = (ins AnyAttr:$value);
let results = (outs AnyType); let results = (outs AnyType);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Attribute value", "OpBuilder &builder, OperationState &result, Attribute value",
[{ build(builder, result, value.getType(), value); }]>]; [{ build(builder, result, value.getType(), value); }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
Attribute getValue() { return getAttr("value"); } Attribute getValue() { return getAttr("value"); }
/// Returns true if a constant operation can be built with the given value /// Returns true if a constant operation can be built with the given value
/// and result type. /// and result type.
static bool isBuildableWith(Attribute value, Type type); static bool isBuildableWith(Attribute value, Type type);
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Linesdef DimOp : Std_Op<"dim", [NoSideEffect]> {
}]; }];
let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor], let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor],
"any tensor or memref type">:$memrefOrTensor, "any tensor or memref type">:$memrefOrTensor,
APIntAttr:$index); APIntAttr:$index);
let results = (outs Index); let results = (outs Index);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value memrefOrTensor," "OpBuilder &builder, OperationState &result, Value memrefOrTensor,"
"unsigned index", [{ "unsigned index", [{
auto indexType = builder->getIndexType(); auto indexType = builder.getIndexType();
auto indexAttr = builder->getIntegerAttr(indexType, index); auto indexAttr = builder.getIntegerAttr(indexType, index);
build(builder, result, indexType, memrefOrTensor, indexAttr); build(builder, result, indexType, memrefOrTensor, indexAttr);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
unsigned getIndex() { unsigned getIndex() {
return getAttrOfType<IntegerAttr>("index").getValue().getZExtValue(); return getAttrOfType<IntegerAttr>("index").getValue().getZExtValue();
} }
}]; }];
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines let description = [{
``` ```
}]; }];
let arguments = (ins AnyTypeOf<[AnyVector, AnyTensor]>:$aggregate, let arguments = (ins AnyTypeOf<[AnyVector, AnyTensor]>:$aggregate,
Variadic<Index>:$indices); Variadic<Index>:$indices);
let results = (outs AnyType:$result); let results = (outs AnyType:$result);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value aggregate," "OpBuilder &builder, OperationState &result, Value aggregate,"
"ValueRange indices = {}", [{ "ValueRange indices = {}", [{
auto resType = aggregate.getType().cast<ShapedType>() auto resType = aggregate.getType().cast<ShapedType>()
.getElementType(); .getElementType();
build(builder, result, resType, aggregate, indices); build(builder, result, resType, aggregate, indices);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
Value getAggregate() { return getOperand(0); } Value getAggregate() { return getOperand(0); }
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Linesdef LoadOp : Std_Op<"load",
}]; }];
let arguments = (ins Arg<AnyMemRef, "the reference to load from", let arguments = (ins Arg<AnyMemRef, "the reference to load from",
[MemRead]>:$memref, [MemRead]>:$memref,
Variadic<Index>:$indices); Variadic<Index>:$indices);
let results = (outs AnyType:$result); let results = (outs AnyType:$result);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *, OperationState &result, Value memref," "OpBuilder &, OperationState &result, Value memref,"
"ValueRange indices = {}", [{ "ValueRange indices = {}", [{
auto memrefType = memref.getType().cast<MemRefType>(); auto memrefType = memref.getType().cast<MemRefType>();
result.addOperands(memref); result.addOperands(memref);
result.addOperands(indices); result.addOperands(indices);
result.types.push_back(memrefType.getElementType()); result.types.push_back(memrefType.getElementType());
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
▲ Show 20 Lines • Show All 235 Lines • ▼ Show 20 Linesdef PrefetchOp : Std_Op<"prefetch"> {
let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices, let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices,
BoolAttr:$isWrite, BoolAttr:$isWrite,
Confined<I32Attr, [IntMinValue<0>, Confined<I32Attr, [IntMinValue<0>,
IntMaxValue<3>]>:$localityHint, IntMaxValue<3>]>:$localityHint,
BoolAttr:$isDataCache); BoolAttr:$isDataCache);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value memref," "OpBuilder &builder, OperationState &result, Value memref,"
"ArrayRef<Value> indices, bool isWrite, unsigned hint, bool isData", "ArrayRef<Value> indices, bool isWrite, unsigned hint, bool isData",
[{ [{
auto hintAttr = builder->getI32IntegerAttr(hint); auto hintAttr = builder.getI32IntegerAttr(hint);
auto isWriteAttr = builder->getBoolAttr(isWrite); auto isWriteAttr = builder.getBoolAttr(isWrite);
auto isDataCacheAttr = builder->getBoolAttr(isData); auto isDataCacheAttr = builder.getBoolAttr(isData);
result.addOperands(memref); result.addOperands(memref);
result.addOperands(indices); result.addOperands(indices);
result.addAttribute("localityHint", hintAttr); result.addAttribute("localityHint", hintAttr);
result.addAttribute("isWrite", isWriteAttr); result.addAttribute("isWrite", isWriteAttr);
result.addAttribute("isDataCache", isDataCacheAttr); result.addAttribute("isDataCache", isDataCacheAttr);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
Show All 24 Lines let description = [{
``` ```
}]; }];
let arguments = (ins AnyTensor); let arguments = (ins AnyTensor);
let results = (outs Index); let results = (outs Index);
let verifier = ?; let verifier = ?;
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value tensor", [{ "OpBuilder &builder, OperationState &result, Value tensor", [{
auto indexType = builder->getIndexType(); auto indexType = builder.getIndexType();
build(builder, result, indexType, tensor); build(builder, result, indexType, tensor);
}]>]; }]>];
let hasFolder = 1; let hasFolder = 1;
let assemblyFormat = "operands attr-dict `:` type(operands)"; let assemblyFormat = "operands attr-dict `:` type(operands)";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 25 Lines func @foo() : (i32, f8) {
return %0, %1 : i32, f8 return %0, %1 : i32, f8
} }
``` ```
}]; }];
let arguments = (ins Variadic<AnyType>:$operands); let arguments = (ins Variadic<AnyType>:$operands);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result", [{ build(b, result, llvm::None); }] "OpBuilder &b, OperationState &result", [{ build(b, result, llvm::None); }]
>]; >];
let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?"; let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// RsqrtOp // RsqrtOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Linesdef SelectOp : Std_Op<"select", [NoSideEffect,
}]; }];
let arguments = (ins BoolLike:$condition, let arguments = (ins BoolLike:$condition,
AnyType:$true_value, AnyType:$true_value,
AnyType:$false_value); AnyType:$false_value);
let results = (outs AnyType:$result); let results = (outs AnyType:$result);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value condition," "OpBuilder &builder, OperationState &result, Value condition,"
"Value trueValue, Value falseValue", [{ "Value trueValue, Value falseValue", [{
result.addOperands({condition, trueValue, falseValue}); result.addOperands({condition, trueValue, falseValue});
result.addTypes(trueValue.getType()); result.addTypes(trueValue.getType());
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
Value getCondition() { return condition(); } Value getCondition() { return condition(); }
Value getTrueValue() { return true_value(); } Value getTrueValue() { return true_value(); }
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines let description = [{
%5 = sexti %0 : vector<2 x i32> to vector<2 x i64> %5 = sexti %0 : vector<2 x i32> to vector<2 x i64>
``` ```
}]; }];
let arguments = (ins SignlessIntegerLike:$value); let arguments = (ins SignlessIntegerLike:$value);
let results = (outs SignlessIntegerLike); let results = (outs SignlessIntegerLike);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value value, Type destType", [{ "OpBuilder &builder, OperationState &result, Value value, Type destType", [{
result.addOperands(value); result.addOperands(value);
result.addTypes(destType); result.addTypes(destType);
}]>]; }]>];
let parser = [{ let parser = [{
return impl::parseCastOp(parser, result); return impl::parseCastOp(parser, result);
}]; }];
let printer = [{ let printer = [{
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines let description = [{
``` ```
}]; }];
let arguments = (ins AnyTypeOf<[AnySignlessInteger, AnyFloat], let arguments = (ins AnyTypeOf<[AnySignlessInteger, AnyFloat],
"integer or float type">:$input); "integer or float type">:$input);
let results = (outs AnyTypeOf<[AnyVector, AnyStaticShapeTensor]>:$aggregate); let results = (outs AnyTypeOf<[AnyVector, AnyStaticShapeTensor]>:$aggregate);
let builders = let builders =
[OpBuilder<"Builder *builder, OperationState &result, Value element, " [OpBuilder<"OpBuilder &builder, OperationState &result, Value element, "
"Type aggregateType", "Type aggregateType",
[{ build(builder, result, aggregateType, element); }]>]; [{ build(builder, result, aggregateType, element); }]>];
let hasFolder = 1; let hasFolder = 1;
let assemblyFormat = "$input attr-dict `:` type($aggregate)"; let assemblyFormat = "$input attr-dict `:` type($aggregate)";
} }
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesdef StoreOp : Std_Op<"store",
}]; }];
let arguments = (ins AnyType:$value, let arguments = (ins AnyType:$value,
Arg<AnyMemRef, "the reference to store to", Arg<AnyMemRef, "the reference to store to",
[MemWrite]>:$memref, [MemWrite]>:$memref,
Variadic<Index>:$indices); Variadic<Index>:$indices);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *, OperationState &result, Value valueToStore, Value memref", [{ "OpBuilder &, OperationState &result, Value valueToStore, Value memref", [{
result.addOperands(valueToStore); result.addOperands(valueToStore);
result.addOperands(memref); result.addOperands(memref);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
Value getValueToStore() { return getOperand(0); } Value getValueToStore() { return getOperand(0); }
Value getMemRef() { return getOperand(1); } Value getMemRef() { return getOperand(1); }
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Linesdef SubViewOp : Std_Op<"subview", [AttrSizedOperandSegments, NoSideEffect]> {
let assemblyFormat = [{ let assemblyFormat = [{
$source `[` $offsets `]` `[` $sizes `]` `[` $strides `]` attr-dict `:` $source `[` $offsets `]` `[` $sizes `]` `[` $strides `]` attr-dict `:`
type($source) `to` type($result) type($source) `to` type($result)
}]; }];
let builders = [ let builders = [
OpBuilder< OpBuilder<
"Builder *b, OperationState &result, Value source, " "OpBuilder &b, OperationState &result, Value source, "
"ValueRange offsets, ValueRange sizes, " "ValueRange offsets, ValueRange sizes, "
"ValueRange strides, Type resultType = Type(), " "ValueRange strides, Type resultType = Type(), "
"ArrayRef<NamedAttribute> attrs = {}">, "ArrayRef<NamedAttribute> attrs = {}">,
OpBuilder< OpBuilder<
"Builder *builder, OperationState &result, " "OpBuilder &builder, OperationState &result, "
"Type resultType, Value source"> "Type resultType, Value source">
]; ];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
/// Returns the type of the base memref operand. /// Returns the type of the base memref operand.
MemRefType getBaseMemRefType() { MemRefType getBaseMemRefType() {
return source().getType().cast<MemRefType>(); return source().getType().cast<MemRefType>();
} }
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Linesdef TensorLoadOp : Std_Op<"tensor_load",
let arguments = (ins Arg<AnyMemRef, "the reference to load from", let arguments = (ins Arg<AnyMemRef, "the reference to load from",
[MemRead]>:$memref); [MemRead]>:$memref);
let results = (outs AnyTensor:$result); let results = (outs AnyTensor:$result);
// TensorLoadOp is fully verified by traits. // TensorLoadOp is fully verified by traits.
let verifier = ?; let verifier = ?;
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value memref", [{ "OpBuilder &builder, OperationState &result, Value memref", [{
auto memrefType = memref.getType().cast<MemRefType>(); auto memrefType = memref.getType().cast<MemRefType>();
auto resultType = RankedTensorType::get(memrefType.getShape(), auto resultType = RankedTensorType::get(memrefType.getShape(),
memrefType.getElementType()); memrefType.getElementType());
result.addOperands(memref); result.addOperands(memref);
result.addTypes(resultType); result.addTypes(resultType);
}]>]; }]>];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines ```mlir
%5 = trunci %0 : vector<2 x i32> to vector<2 x i16> %5 = trunci %0 : vector<2 x i32> to vector<2 x i16>
``` ```
}]; }];
let arguments = (ins SignlessIntegerLike:$value); let arguments = (ins SignlessIntegerLike:$value);
let results = (outs SignlessIntegerLike); let results = (outs SignlessIntegerLike);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value value, Type destType", [{ "OpBuilder &builder, OperationState &result, Value value, Type destType", [{
result.addOperands(value); result.addOperands(value);
result.addTypes(destType); result.addTypes(destType);
}]>]; }]>];
let parser = [{ let parser = [{
return impl::parseCastOp(parser, result); return impl::parseCastOp(parser, result);
}]; }];
let printer = [{ let printer = [{
▲ Show 20 Lines • Show All 213 Lines • ▼ Show 20 Lines ```mlir
%5 = zexti %0 : vector<2 x i32> to vector<2 x i64> %5 = zexti %0 : vector<2 x i32> to vector<2 x i64>
``` ```
}]; }];
let arguments = (ins SignlessIntegerLike:$value); let arguments = (ins SignlessIntegerLike:$value);
let results = (outs SignlessIntegerLike); let results = (outs SignlessIntegerLike);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value value, Type destType", [{ "OpBuilder &builder, OperationState &result, Value value, Type destType", [{
result.addOperands(value); result.addOperands(value);
result.addTypes(destType); result.addTypes(destType);
}]>]; }]>];
let parser = [{ let parser = [{
return impl::parseCastOp(parser, result); return impl::parseCastOp(parser, result);
}]; }];
let printer = [{ let printer = [{
return printStandardCastOp(this->getOperation(), p); return printStandardCastOp(this->getOperation(), p);
}]; }];
} }
#endif // STANDARD_OPS #endif // STANDARD_OPS

mlir/include/mlir/Dialect/Vector/VectorOps.td

Show First 20 Lines • Show All 137 Lines • ▼ Show 20 Lines let description = [{
%lhs_mask = vector.constant_mask [7, 8, 16, 15] : vector<7x8x16x15xi1> %lhs_mask = vector.constant_mask [7, 8, 16, 15] : vector<7x8x16x15xi1>
%rhs_mask = vector.constant_mask [8, 16, 7, 5] : vector<8x16x7x5xi1> %rhs_mask = vector.constant_mask [8, 16, 7, 5] : vector<8x16x7x5xi1>
%5 = vector.contract #contraction_trait %0, %1, %2, %lhs_mask, %rhs_mask %5 = vector.contract #contraction_trait %0, %1, %2, %lhs_mask, %rhs_mask
: vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x8x5xf32> : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x8x5xf32>
``` ```
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value lhs, Value rhs, " "OpBuilder &builder, OperationState &result, Value lhs, Value rhs, "
"Value acc, ArrayAttr indexingMaps, ArrayAttr iteratorTypes">, "Value acc, ArrayAttr indexingMaps, ArrayAttr iteratorTypes">,
OpBuilder< OpBuilder<
"Builder *builder, OperationState &result, Value lhs, Value rhs, " "OpBuilder &builder, OperationState &result, Value lhs, Value rhs, "
"Value acc, ArrayRef<ArrayRef<AffineExpr>> indexingExprs, " "Value acc, ArrayRef<ArrayRef<AffineExpr>> indexingExprs, "
"ArrayRef<StringRef> iteratorTypes">]; "ArrayRef<StringRef> iteratorTypes">];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
VectorType getLhsType() { VectorType getLhsType() {
return lhs().getType().cast<VectorType>(); return lhs().getType().cast<VectorType>();
} }
VectorType getRhsType() { VectorType getRhsType() {
return rhs().getType().cast<VectorType>(); return rhs().getType().cast<VectorType>();
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines let description = [{
%0 = vector.shuffle %a, %b[0, 3] %0 = vector.shuffle %a, %b[0, 3]
: vector<2xf32>, vector<2xf32> ; yields vector<2xf32> : vector<2xf32>, vector<2xf32> ; yields vector<2xf32>
%1 = vector.shuffle %c, %b[0, 1, 2] %1 = vector.shuffle %c, %b[0, 1, 2]
: vector<2x16xf32>, vector<1x16xf32> ; yields vector<3x16xf32> : vector<2x16xf32>, vector<1x16xf32> ; yields vector<3x16xf32>
%2 = vector.shuffle %a, %b[3, 2, 1, 0] %2 = vector.shuffle %a, %b[3, 2, 1, 0]
: vector<2xf32>, vector<2xf32> ; yields vector<4xf32> : vector<2xf32>, vector<2xf32> ; yields vector<4xf32>
``` ```
}]; }];
let builders = [OpBuilder<"Builder *builder, OperationState &result," let builders = [OpBuilder<"OpBuilder &builder, OperationState &result,"
"Value v1, Value v2, ArrayRef<int64_t>">]; "Value v1, Value v2, ArrayRef<int64_t>">];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static StringRef getMaskAttrName() { return "mask"; } static StringRef getMaskAttrName() { return "mask"; }
VectorType getV1VectorType() { VectorType getV1VectorType() {
return v1().getType().cast<VectorType>(); return v1().getType().cast<VectorType>();
} }
VectorType getV2VectorType() { VectorType getV2VectorType() {
return v2().getType().cast<VectorType>(); return v2().getType().cast<VectorType>();
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines let description = [{
Example: Example:
```mlir ```mlir
%1 = vector.extract %0[3]: vector<4x8x16xf32> %1 = vector.extract %0[3]: vector<4x8x16xf32>
%2 = vector.extract %0[3, 3, 3]: vector<4x8x16xf32> %2 = vector.extract %0[3, 3, 3]: vector<4x8x16xf32>
``` ```
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value source," "OpBuilder &builder, OperationState &result, Value source,"
"ArrayRef<int64_t>">]; "ArrayRef<int64_t>">];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static StringRef getPositionAttrName() { return "position"; } static StringRef getPositionAttrName() { return "position"; }
VectorType getVectorType() { VectorType getVectorType() {
return vector().getType().cast<VectorType>(); return vector().getType().cast<VectorType>();
} }
}]; }];
} }
Show All 29 Lines let description = [{
%2 = vector.transfer_read ...: vector<4x3xf32> %2 = vector.transfer_read ...: vector<4x3xf32>
%3 = vector.extract_slices %2, [2, 2], [1, 1] %3 = vector.extract_slices %2, [2, 2], [1, 1]
: vector<4x3xf32> into tuple<vector<2x2xf32>, vector<2x1xf32>, : vector<4x3xf32> into tuple<vector<2x2xf32>, vector<2x1xf32>,
vector<2x2xf32>, vector<2x1xf32>> vector<2x2xf32>, vector<2x1xf32>>
``` ```
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, TupleType tupleType, " # "OpBuilder &builder, OperationState &result, TupleType tupleType, " #
"Value vector, ArrayRef<int64_t> sizes, " # "Value vector, ArrayRef<int64_t> sizes, " #
"ArrayRef<int64_t> strides">]; "ArrayRef<int64_t> strides">];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
VectorType getSourceVectorType() { VectorType getSourceVectorType() {
return vector().getType().cast<VectorType>(); return vector().getType().cast<VectorType>();
} }
TupleType getResultTupleType() { TupleType getResultTupleType() {
return getResult().getType().cast<TupleType>(); return getResult().getType().cast<TupleType>();
Show All 29 Lines let description = [{
```mlir ```mlir
%3 = vector.fma %0, %1, %2: vector<8x16xf32> %3 = vector.fma %0, %1, %2: vector<8x16xf32>
``` ```
}]; }];
// Fully specified by traits. // Fully specified by traits.
let verifier = ?; let verifier = ?;
let assemblyFormat = "$lhs `,` $rhs `,` $acc attr-dict `:` type($lhs)"; let assemblyFormat = "$lhs `,` $rhs `,` $acc attr-dict `:` type($lhs)";
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, Value lhs, Value rhs, Value acc", "OpBuilder &b, OperationState &result, Value lhs, Value rhs, Value acc",
"build(b, result, lhs.getType(), lhs, rhs, acc);">]; "build(b, result, lhs.getType(), lhs, rhs, acc);">];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
VectorType getVectorType() { return lhs().getType().cast<VectorType>(); } VectorType getVectorType() { return lhs().getType().cast<VectorType>(); }
}]; }];
} }
def Vector_InsertElementOp : def Vector_InsertElementOp :
Vector_Op<"insertelement", [NoSideEffect, Vector_Op<"insertelement", [NoSideEffect,
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines let description = [{
%5 = vector.insert %3, %4[3, 3, 3] : f32 into vector<4x8x16xf32> %5 = vector.insert %3, %4[3, 3, 3] : f32 into vector<4x8x16xf32>
``` ```
}]; }];
let assemblyFormat = [{ let assemblyFormat = [{
$source `,` $dest $position attr-dict `:` type($source) `into` type($dest) $source `,` $dest $position attr-dict `:` type($source) `into` type($dest)
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value source, " # "OpBuilder &builder, OperationState &result, Value source, " #
"Value dest, ArrayRef<int64_t>">]; "Value dest, ArrayRef<int64_t>">];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static StringRef getPositionAttrName() { return "position"; } static StringRef getPositionAttrName() { return "position"; }
Type getSourceType() { return source().getType(); } Type getSourceType() { return source().getType(); }
VectorType getDestVectorType() { VectorType getDestVectorType() {
return dest().getType().cast<VectorType>(); return dest().getType().cast<VectorType>();
} }
}]; }];
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines let description = [{
``` ```
}]; }];
let assemblyFormat = [{ let assemblyFormat = [{
$source `,` $dest attr-dict `:` type($source) `into` type($dest) $source `,` $dest attr-dict `:` type($source) `into` type($dest)
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value source, Value dest, " # "OpBuilder &builder, OperationState &result, Value source, Value dest, " #
"ArrayRef<int64_t> offsets, ArrayRef<int64_t> strides">]; "ArrayRef<int64_t> offsets, ArrayRef<int64_t> strides">];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static StringRef getOffsetsAttrName() { return "offsets"; } static StringRef getOffsetsAttrName() { return "offsets"; }
static StringRef getStridesAttrName() { return "strides"; } static StringRef getStridesAttrName() { return "strides"; }
VectorType getSourceVectorType() { VectorType getSourceVectorType() {
return source().getType().cast<VectorType>(); return source().getType().cast<VectorType>();
} }
VectorType getDestVectorType() { VectorType getDestVectorType() {
▲ Show 20 Lines • Show All 194 Lines • ▼ Show 20 Lines %1 = vector.strided_slice %0
vector<4x8x16xf32> to vector<2x4x16xf32> vector<4x8x16xf32> to vector<2x4x16xf32>
// TODO(ntv) Evolve to a range form syntax similar to: // TODO(ntv) Evolve to a range form syntax similar to:
%1 = vector.strided_slice %0[0:2:1][2:4:1] %1 = vector.strided_slice %0[0:2:1][2:4:1]
vector<4x8x16xf32> to vector<2x4x16xf32> vector<4x8x16xf32> to vector<2x4x16xf32>
``` ```
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value source, " # "OpBuilder &builder, OperationState &result, Value source, " #
"ArrayRef<int64_t> offsets, ArrayRef<int64_t> sizes, " # "ArrayRef<int64_t> offsets, ArrayRef<int64_t> sizes, " #
"ArrayRef<int64_t> strides">]; "ArrayRef<int64_t> strides">];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
static StringRef getOffsetsAttrName() { return "offsets"; } static StringRef getOffsetsAttrName() { return "offsets"; }
static StringRef getSizesAttrName() { return "sizes"; } static StringRef getSizesAttrName() { return "sizes"; }
static StringRef getStridesAttrName() { return "strides"; } static StringRef getStridesAttrName() { return "strides"; }
VectorType getVectorType(){ return vector().getType().cast<VectorType>(); } VectorType getVectorType(){ return vector().getType().cast<VectorType>(); }
void getOffsets(SmallVectorImpl<int64_t> &results); void getOffsets(SmallVectorImpl<int64_t> &results);
▲ Show 20 Lines • Show All 289 Lines • ▼ Show 20 Lines let description = [{
```mlir ```mlir
%A = alloc() : memref<5x4x3xf32> %A = alloc() : memref<5x4x3xf32>
%VA = vector.type_cast %A : memref<5x4x3xf32> to memref<vector<5x4x3xf32>> %VA = vector.type_cast %A : memref<5x4x3xf32> to memref<vector<5x4x3xf32>>
``` ```
}]; }];
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *builder, OperationState &result, Value source">]; "OpBuilder &builder, OperationState &result, Value source">];
let parser = [{ let parser = [{
return impl::parseCastOp(parser, result); return impl::parseCastOp(parser, result);
}]; }];
let extraClassDeclaration = [{ let extraClassDeclaration = [{
MemRefType getMemRefType() { MemRefType getMemRefType() {
return memref().getType().cast<MemRefType>(); return memref().getType().cast<MemRefType>();
▲ Show 20 Lines • Show All 267 Lines • ▼ Show 20 Lines let description = [{
```mlir ```mlir
%C = vector.matrix_multiply %A, %B %C = vector.matrix_multiply %A, %B
{ lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } : { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } :
(vector<64xf64>, vector<48xf64>) -> vector<12xf64> (vector<64xf64>, vector<48xf64>) -> vector<12xf64>
``` ```
}]; }];
let builders = [ let builders = [
OpBuilder<"Builder *builder, OperationState &result, Value lhs, Value rhs, " OpBuilder<"OpBuilder &builder, OperationState &result, Value lhs, Value rhs, "
"unsigned lhsRows, unsigned lhsColumns, unsigned rhsColumns", "unsigned lhsRows, unsigned lhsColumns, unsigned rhsColumns",
[{ [{
result.addOperands({lhs, rhs}); result.addOperands({lhs, rhs});
result.addAttribute("lhs_rows", builder->getI32IntegerAttr(lhsRows)); result.addAttribute("lhs_rows", builder.getI32IntegerAttr(lhsRows));
result.addAttribute("lhs_columns", builder->getI32IntegerAttr(lhsColumns)); result.addAttribute("lhs_columns", builder.getI32IntegerAttr(lhsColumns));
result.addAttribute("rhs_columns", builder->getI32IntegerAttr(rhsColumns)); result.addAttribute("rhs_columns", builder.getI32IntegerAttr(rhsColumns));
result.addTypes(VectorType::get(lhsRows * rhsColumns, result.addTypes(VectorType::get(lhsRows * rhsColumns,
lhs.getType().cast<VectorType>().getElementType())); lhs.getType().cast<VectorType>().getElementType()));
}]>, }]>,
]; ];
let verifier = ?; let verifier = ?;
let assemblyFormat = "$lhs `,` $rhs attr-dict " let assemblyFormat = "$lhs `,` $rhs attr-dict "
"`:` `(` type($lhs) `,` type($rhs) `)` `->` type($res)"; "`:` `(` type($lhs) `,` type($rhs) `)` `->` type($res)";
} }
#endif // VECTOR_OPS #endif // VECTOR_OPS

mlir/include/mlir/IR/Builders.h

Show First 20 Lines • Show All 313 Lines • ▼ Show 20 Linespublic:
/// Creates an operation given the fields represented as an OperationState. /// Creates an operation given the fields represented as an OperationState.
Operation *createOperation(const OperationState &state); Operation *createOperation(const OperationState &state);
/// Create an operation of specific op type at the current insertion point. /// Create an operation of specific op type at the current insertion point.
template <typename OpTy, typename... Args> template <typename OpTy, typename... Args>
OpTy create(Location location, Args &&... args) { OpTy create(Location location, Args &&... args) {
OperationState state(location, OpTy::getOperationName()); OperationState state(location, OpTy::getOperationName());
OpTy::build(this, state, std::forward<Args>(args)...); OpTy::build(*this, state, std::forward<Args>(args)...);
auto *op = createOperation(state); auto *op = createOperation(state);
auto result = dyn_cast<OpTy>(op); auto result = dyn_cast<OpTy>(op);
assert(result && "Builder didn't return the right type"); assert(result && "Builder didn't return the right type");
return result; return result;
} }
/// Create an operation of specific op type at the current insertion point, /// Create an operation of specific op type at the current insertion point,
/// and immediately try to fold it. This functions populates 'results' with /// and immediately try to fold it. This functions populates 'results' with
/// the results after folding the operation. /// the results after folding the operation.
template <typename OpTy, typename... Args> template <typename OpTy, typename... Args>
void createOrFold(SmallVectorImpl<Value> &results, Location location, void createOrFold(SmallVectorImpl<Value> &results, Location location,
Args &&... args) { Args &&... args) {
// Create the operation without using 'createOperation' as we don't want to // Create the operation without using 'createOperation' as we don't want to
// insert it yet. // insert it yet.
OperationState state(location, OpTy::getOperationName()); OperationState state(location, OpTy::getOperationName());
OpTy::build(this, state, std::forward<Args>(args)...); OpTy::build(*this, state, std::forward<Args>(args)...);
Operation *op = Operation::create(state); Operation *op = Operation::create(state);
// Fold the operation. If successful destroy it, otherwise insert it. // Fold the operation. If successful destroy it, otherwise insert it.
if (succeeded(tryFold(op, results))) if (succeeded(tryFold(op, results)))
op->destroy(); op->destroy();
else else
insert(op); insert(op);
} }
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

mlir/include/mlir/IR/Function.h

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linespublic:
static FuncOp create(Location location, StringRef name, FunctionType type, static FuncOp create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs = {}); ArrayRef<NamedAttribute> attrs = {});
static FuncOp create(Location location, StringRef name, FunctionType type, static FuncOp create(Location location, StringRef name, FunctionType type,
iterator_range<dialect_attr_iterator> attrs); iterator_range<dialect_attr_iterator> attrs);
static FuncOp create(Location location, StringRef name, FunctionType type, static FuncOp create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs, ArrayRef<NamedAttribute> attrs,
ArrayRef<NamedAttributeList> argAttrs); ArrayRef<NamedAttributeList> argAttrs);
static void build(Builder *builder, OperationState &result, StringRef name, static void build(OpBuilder &builder, OperationState &result, StringRef name,
FunctionType type, ArrayRef<NamedAttribute> attrs); FunctionType type, ArrayRef<NamedAttribute> attrs);
static void build(Builder *builder, OperationState &result, StringRef name, static void build(OpBuilder &builder, OperationState &result, StringRef name,
FunctionType type, ArrayRef<NamedAttribute> attrs, FunctionType type, ArrayRef<NamedAttribute> attrs,
ArrayRef<NamedAttributeList> argAttrs); ArrayRef<NamedAttributeList> argAttrs);
/// Operation hooks. /// Operation hooks.
static ParseResult parse(OpAsmParser &parser, OperationState &result); static ParseResult parse(OpAsmParser &parser, OperationState &result);
void print(OpAsmPrinter &p); void print(OpAsmPrinter &p);
LogicalResult verify(); LogicalResult verify();
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

mlir/include/mlir/IR/Module.h

Show All 32 Lines : public Op<
OpTrait::IsIsolatedFromAbove, OpTrait::SymbolTable, OpTrait::IsIsolatedFromAbove, OpTrait::SymbolTable,
OpTrait::SingleBlockImplicitTerminator<ModuleTerminatorOp>::Impl> { OpTrait::SingleBlockImplicitTerminator<ModuleTerminatorOp>::Impl> {
public: public:
using Op::Op; using Op::Op;
using Op::print; using Op::print;
static StringRef getOperationName() { return "module"; } static StringRef getOperationName() { return "module"; }
static void build(Builder *builder, OperationState &result, static void build(OpBuilder &builder, OperationState &result,
Optional<StringRef> name = llvm::None); Optional<StringRef> name = llvm::None);
/// Construct a module from the given location with an optional name. /// Construct a module from the given location with an optional name.
static ModuleOp create(Location loc, Optional<StringRef> name = llvm::None); static ModuleOp create(Location loc, Optional<StringRef> name = llvm::None);
/// Operation hooks. /// Operation hooks.
static ParseResult parse(OpAsmParser &parser, OperationState &result); static ParseResult parse(OpAsmParser &parser, OperationState &result);
void print(OpAsmPrinter &p); void print(OpAsmPrinter &p);
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
/// This operation does _not_ have a custom syntax. However, ModuleOp will omit /// This operation does _not_ have a custom syntax. However, ModuleOp will omit
/// the terminator in their custom syntax for brevity. /// the terminator in their custom syntax for brevity.
class ModuleTerminatorOp class ModuleTerminatorOp
: public Op<ModuleTerminatorOp, OpTrait::ZeroOperands, OpTrait::ZeroResult, : public Op<ModuleTerminatorOp, OpTrait::ZeroOperands, OpTrait::ZeroResult,
OpTrait::HasParent<ModuleOp>::Impl, OpTrait::IsTerminator> { OpTrait::HasParent<ModuleOp>::Impl, OpTrait::IsTerminator> {
public: public:
using Op::Op; using Op::Op;
static StringRef getOperationName() { return "module_terminator"; } static StringRef getOperationName() { return "module_terminator"; }
static void build(Builder *, OperationState &) {} static void build(OpBuilder &, OperationState &) {}
}; };
/// This class acts as an owning reference to a module, and will automatically /// This class acts as an owning reference to a module, and will automatically
/// destroy the held module if valid. /// destroy the held module if valid.
class OwningModuleRef { class OwningModuleRef {
public: public:
OwningModuleRef(std::nullptr_t = nullptr) {} OwningModuleRef(std::nullptr_t = nullptr) {}
OwningModuleRef(ModuleOp module) : module(module) {} OwningModuleRef(ModuleOp module) : module(module) {}
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/include/mlir/IR/OpBase.td

Show First 20 Lines • Show All 1,791 Lines • ▼ Show 20 Lines
// //
// TableGen generates several generic builders for each op by default (see // TableGen generates several generic builders for each op by default (see
// comment in the `Op` class). If the default generated ones cannot cover // comment in the `Op` class). If the default generated ones cannot cover
// some use case, custom builders can be defined using instances of this class. // some use case, custom builders can be defined using instances of this class.
// //
// The signature of the builder is always // The signature of the builder is always
// //
// ```c++ // ```c++
// static void build(Builder *builder, OperationState &state, // static void build(OpBuilder &builder, OperationState &state,
// <other-parameters>...) { // <other-parameters>...) {
// <body>... // <body>...
// } // }
// ``` // ```
// //
// To define a custom builder, the parameter list (*including* the `Builder // To define a custom builder, the parameter list (*including* the `Builder
// *builder, OperationState &state` part) and body should be passed in // *builder, OperationState &state` part) and body should be passed in
// as separate template arguments to this class. This is because we generate // as separate template arguments to this class. This is because we generate
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Linesclass Op<Dialect dialect, string mnemonic, list<OpTrait> props = []> {
// Define the hooks used for building, parsing, printing, verification. // Define the hooks used for building, parsing, printing, verification.
// Custom builder. // Custom builder.
// In addition to the custom builder provided here, and unless // In addition to the custom builder provided here, and unless
// skipDefaultBuilders is set, two default builders are generated, with the // skipDefaultBuilders is set, two default builders are generated, with the
// following signatures: // following signatures:
// //
// ```c++ // ```c++
// static void build(Builder *, OperationState &odsState, // static void build(OpBuilder &, OperationState &odsState,
// Type <result0-name>, Type <result1-name>, ..., // Type <result0-name>, Type <result1-name>, ...,
// Value <arg0-name>, Value <arg1-name>, ..., // Value <arg0-name>, Value <arg1-name>, ...,
// Attribute <attr0-name>, Attribute <attr1-name>, ...); // Attribute <attr0-name>, Attribute <attr1-name>, ...);
// ``` // ```
// * where the attributes follow the same declaration order as in the op. // * where the attributes follow the same declaration order as in the op.
// //
// ```c++ // ```c++
// static void build(Builder *, OperationState &odsState, // static void build(OpBuilder &, OperationState &odsState,
// ArrayRef<Type> resultTypes, // ArrayRef<Type> resultTypes,
// ArrayRef<Value> operands, // ArrayRef<Value> operands,
// ArrayRef<NamedAttribute> attributes); // ArrayRef<NamedAttribute> attributes);
// ``` // ```
list<OpBuilder> builders = ?; list<OpBuilder> builders = ?;
// Avoid generating default build functions. Custom builders must be // Avoid generating default build functions. Custom builders must be
// provided. // provided.
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

mlir/include/mlir/IR/OpDefinition.h

Show All 19 Lines
#define MLIR_IR_OPDEFINITION_H #define MLIR_IR_OPDEFINITION_H
#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"
#include "llvm/Support/PointerLikeTypeTraits.h" #include "llvm/Support/PointerLikeTypeTraits.h"
#include <type_traits> #include <type_traits>
namespace mlir { namespace mlir {
class Builder; class Builder;
class OpBuilder;
namespace OpTrait { namespace OpTrait {
template <typename ConcreteType> class OneResult; template <typename ConcreteType> class OneResult;
} }
/// This class represents success/failure for operation parsing. It is /// This class represents success/failure for operation parsing. It is
/// essentially a simple wrapper class around LogicalResult that allows for /// essentially a simple wrapper class around LogicalResult that allows for
/// explicit conversion to bool. This allows for the parser to chain together /// explicit conversion to bool. This allows for the parser to chain together
Show All 36 Lines
// These functions are out-of-line utilities, which avoids them being template // These functions are out-of-line utilities, which avoids them being template
// instantiated/duplicated. // instantiated/duplicated.
namespace impl { namespace impl {
/// Insert an operation, generated by `buildTerminatorOp`, at the end of the /// Insert an operation, generated by `buildTerminatorOp`, at the end of the
/// region's only block if it does not have a terminator already. If the region /// region's only block if it does not have a terminator already. If the region
/// is empty, insert a new block first. `buildTerminatorOp` should return the /// is empty, insert a new block first. `buildTerminatorOp` should return the
/// terminator operation to insert. /// terminator operation to insert.
void ensureRegionTerminator(Region &region, Location loc, void ensureRegionTerminator(
function_ref<Operation *()> buildTerminatorOp); Region &region, Location loc,
function_ref<Operation *(OpBuilder &)> buildTerminatorOp);
/// Templated version that fills the generates the provided operation type. /// Templated version that fills the generates the provided operation type.
template <typename OpTy> template <typename OpTy>
void ensureRegionTerminator(Region &region, Builder &builder, Location loc) { void ensureRegionTerminator(Region &region, Builder &builder, Location loc) {
ensureRegionTerminator(region, loc, [&] { ensureRegionTerminator(region, loc, [&](OpBuilder &b) {
OperationState state(loc, OpTy::getOperationName()); OperationState state(loc, OpTy::getOperationName());
OpTy::build(&builder, state); OpTy::build(b, state);
return Operation::create(state); return Operation::create(state);
}); });
} }
} // namespace impl } // namespace impl
/// This is the concrete base class that holds the operation pointer and has /// This is the concrete base class that holds the operation pointer and has
/// non-generic methods that only depend on State (to avoid having them /// non-generic methods that only depend on State (to avoid having them
/// instantiated on template types that don't affect them. /// instantiated on template types that don't affect them.
▲ Show 20 Lines • Show All 1,314 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// These functions are out-of-line implementations of the methods in UnaryOp and // These functions are out-of-line implementations of the methods in UnaryOp and
// BinaryOp, which avoids them being template instantiated/duplicated. // BinaryOp, which avoids them being template instantiated/duplicated.
namespace impl { namespace impl {
ParseResult parseOneResultOneOperandTypeOp(OpAsmParser &parser, ParseResult parseOneResultOneOperandTypeOp(OpAsmParser &parser,
OperationState &result); OperationState &result);
void buildBinaryOp(Builder *builder, OperationState &result, Value lhs, void buildBinaryOp(OpBuilder &builder, OperationState &result, Value lhs,
Value rhs); Value rhs);
ParseResult parseOneResultSameOperandTypeOp(OpAsmParser &parser, ParseResult parseOneResultSameOperandTypeOp(OpAsmParser &parser,
OperationState &result); OperationState &result);
// Prints the given binary `op` in custom assembly form if both the two operands // Prints the given binary `op` in custom assembly form if both the two operands
// and the result have the same time. Otherwise, prints the generic assembly // and the result have the same time. Otherwise, prints the generic assembly
// form. // form.
void printOneResultOp(Operation *op, OpAsmPrinter &p); void printOneResultOp(Operation *op, OpAsmPrinter &p);
} // namespace impl } // namespace impl
// These functions are out-of-line implementations of the methods in CastOp, // These functions are out-of-line implementations of the methods in CastOp,
// which avoids them being template instantiated/duplicated. // which avoids them being template instantiated/duplicated.
namespace impl { namespace impl {
void buildCastOp(Builder *builder, OperationState &result, Value source, void buildCastOp(OpBuilder &builder, OperationState &result, Value source,
Type destType); Type destType);
ParseResult parseCastOp(OpAsmParser &parser, OperationState &result); ParseResult parseCastOp(OpAsmParser &parser, OperationState &result);
void printCastOp(Operation *op, OpAsmPrinter &p); void printCastOp(Operation *op, OpAsmPrinter &p);
Value foldCastOp(Operation *op); Value foldCastOp(Operation *op);
} // namespace impl } // namespace impl
} // end namespace mlir } // end namespace mlir
#endif #endif

mlir/include/mlir/IR/PatternMatch.h

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Lines
/// ///
class PatternRewriter : public OpBuilder { class PatternRewriter : public OpBuilder {
public: public:
/// Create operation of specific op type at the current insertion point /// Create operation of specific op type at the current insertion point
/// without verifying to see if it is valid. /// without verifying to see if it is valid.
template <typename OpTy, typename... Args> template <typename OpTy, typename... Args>
OpTy create(Location location, Args... args) { OpTy create(Location location, Args... args) {
OperationState state(location, OpTy::getOperationName()); OperationState state(location, OpTy::getOperationName());
OpTy::build(this, state, args...); OpTy::build(*this, state, args...);
auto *op = createOperation(state); auto *op = createOperation(state);
auto result = dyn_cast<OpTy>(op); auto result = dyn_cast<OpTy>(op);
assert(result && "Builder didn't return the right type"); assert(result && "Builder didn't return the right type");
return result; return result;
} }
/// Creates an operation of specific op type at the current insertion point. /// Creates an operation of specific op type at the current insertion point.
/// If the result is an invalid op (the verifier hook fails), emit an error /// If the result is an invalid op (the verifier hook fails), emit an error
/// and return null. /// and return null.
template <typename OpTy, typename... Args> template <typename OpTy, typename... Args>
OpTy createChecked(Location location, Args... args) { OpTy createChecked(Location location, Args... args) {
OperationState state(location, OpTy::getOperationName()); OperationState state(location, OpTy::getOperationName());
OpTy::build(this, state, args...); OpTy::build(*this, state, args...);
auto *op = createOperation(state); auto *op = createOperation(state);
// If the Operation we produce is valid, return it. // If the Operation we produce is valid, return it.
if (!OpTy::verifyInvariants(op)) { if (!OpTy::verifyInvariants(op)) {
auto result = dyn_cast<OpTy>(op); auto result = dyn_cast<OpTy>(op);
assert(result && "Builder didn't return the right type"); assert(result && "Builder didn't return the right type");
return result; return result;
} }
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines

mlir/include/mlir/Transforms/FoldUtils.h

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Linespublic:
template <typename OpTy, typename... Args> template <typename OpTy, typename... Args>
void create(OpBuilder &builder, SmallVectorImpl<Value> &results, void create(OpBuilder &builder, SmallVectorImpl<Value> &results,
Location location, Args &&... args) { Location location, Args &&... args) {
// The op needs to be inserted only if the fold (below) fails, or the number // The op needs to be inserted only if the fold (below) fails, or the number
// of results of the op is zero (which is treated as an in-place // of results of the op is zero (which is treated as an in-place
// fold). Using create methods of the builder will insert the op, so not // fold). Using create methods of the builder will insert the op, so not
// using it here. // using it here.
OperationState state(location, OpTy::getOperationName()); OperationState state(location, OpTy::getOperationName());
OpTy::build(&builder, state, std::forward<Args>(args)...); OpTy::build(builder, state, std::forward<Args>(args)...);
Operation *op = Operation::create(state); Operation *op = Operation::create(state);
if (failed(tryToFold(builder, op, results)) || op->getNumResults() == 0) { if (failed(tryToFold(builder, op, results)) || op->getNumResults() == 0) {
builder.insert(op); builder.insert(op);
results.assign(op->result_begin(), op->result_end()); results.assign(op->result_begin(), op->result_end());
return; return;
} }
op->destroy(); op->destroy();
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Lines#define CREATE_GROUP_NON_UNIFORM_BIN_OP(opKind, spvOp) \
} break } break
switch (*binaryOpKind) { switch (*binaryOpKind) {
CREATE_GROUP_NON_UNIFORM_BIN_OP(IAdd, GroupNonUniformIAddOp); CREATE_GROUP_NON_UNIFORM_BIN_OP(IAdd, GroupNonUniformIAddOp);
} }
#undef CREATE_GROUP_NON_UNIFORM_BIN_OP #undef CREATE_GROUP_NON_UNIFORM_BIN_OP
// Get the output element accessed by this reduction. // Get the output element accessed by this reduction.
Value zero = spirv::ConstantOp::getZero( Value zero = spirv::ConstantOp::getZero(
typeConverter.getIndexType(rewriter.getContext()), loc, &rewriter); typeConverter.getIndexType(rewriter.getContext()), loc, rewriter);
SmallVector<Value, 1> zeroIndices(originalOutputType.getRank(), zero); SmallVector<Value, 1> zeroIndices(originalOutputType.getRank(), zero);
Value outputElementPtr = Value outputElementPtr =
spirv::getElementPtr(typeConverter, originalOutputType, convertedOutput, spirv::getElementPtr(typeConverter, originalOutputType, convertedOutput,
zeroIndices, loc, rewriter); zeroIndices, loc, rewriter);
// Write out the final reduction result. This should be only conducted by one // Write out the final reduction result. This should be only conducted by one
// invocation. We use spv.GroupNonUniformElect to find the invocation with the // invocation. We use spv.GroupNonUniformElect to find the invocation with the
// lowest ID. // lowest ID.
// //
// ``` // ```
// if (spv.GroupNonUniformElect) { output = ... } // if (spv.GroupNonUniformElect) { output = ... }
// ``` // ```
Value condition = rewriter.create<spirv::GroupNonUniformElectOp>( Value condition = rewriter.create<spirv::GroupNonUniformElectOp>(
loc, spirv::Scope::Subgroup); loc, spirv::Scope::Subgroup);
auto createAtomicOp = [&](OpBuilder *builder) { auto createAtomicOp = [&](OpBuilder &builder) {
#define CREATE_ATOMIC_BIN_OP(opKind, spvOp) \ #define CREATE_ATOMIC_BIN_OP(opKind, spvOp) \
case linalg::RegionMatcher::BinaryOpKind::opKind: { \ case linalg::RegionMatcher::BinaryOpKind::opKind: { \
builder->create<spirv::spvOp>(loc, outputElementPtr, spirv::Scope::Device, \ builder.create<spirv::spvOp>(loc, outputElementPtr, spirv::Scope::Device, \
spirv::MemorySemantics::AcquireRelease, \ spirv::MemorySemantics::AcquireRelease, \
groupOperation); \ groupOperation); \
} break } break
switch (*binaryOpKind) { CREATE_ATOMIC_BIN_OP(IAdd, AtomicIAddOp); } switch (*binaryOpKind) { CREATE_ATOMIC_BIN_OP(IAdd, AtomicIAddOp); }
#undef CREATE_ATOMIC_BIN_OP #undef CREATE_ATOMIC_BIN_OP
}; };
spirv::SelectionOp::createIfThen(loc, condition, createAtomicOp, &rewriter); spirv::SelectionOp::createIfThen(loc, condition, createAtomicOp, rewriter);
rewriter.eraseOp(genericOp); rewriter.eraseOp(genericOp);
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Pattern population // Pattern population
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void mlir::populateLinalgToSPIRVPatterns(MLIRContext *context, void mlir::populateLinalgToSPIRVPatterns(MLIRContext *context,
SPIRVTypeConverter &typeConverter, SPIRVTypeConverter &typeConverter,
OwningRewritePatternList &patterns) { OwningRewritePatternList &patterns) {
patterns.insert<SingleWorkgroupReduction>(context, typeConverter); patterns.insert<SingleWorkgroupReduction>(context, typeConverter);
} }

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

Show First 20 Lines • Show All 805 Lines • ▼ Show 20 Linesstatic LogicalResult foldMemRefCast(Operation *op) {
return success(folded); return success(folded);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AffineDmaStartOp // AffineDmaStartOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TODO(b/133776335) Check that map operands are loop IVs or symbols. // TODO(b/133776335) Check that map operands are loop IVs or symbols.
void AffineDmaStartOp::build(Builder *builder, OperationState &result, void AffineDmaStartOp::build(OpBuilder &builder, OperationState &result,
Value srcMemRef, AffineMap srcMap, Value srcMemRef, AffineMap srcMap,
ValueRange srcIndices, Value destMemRef, ValueRange srcIndices, Value destMemRef,
AffineMap dstMap, ValueRange destIndices, AffineMap dstMap, ValueRange destIndices,
Value tagMemRef, AffineMap tagMap, Value tagMemRef, AffineMap tagMap,
ValueRange tagIndices, Value numElements, ValueRange tagIndices, Value numElements,
Value stride, Value elementsPerStride) { Value stride, Value elementsPerStride) {
result.addOperands(srcMemRef); result.addOperands(srcMemRef);
result.addAttribute(getSrcMapAttrName(), AffineMapAttr::get(srcMap)); result.addAttribute(getSrcMapAttrName(), AffineMapAttr::get(srcMap));
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 LinesLogicalResult AffineDmaStartOp::fold(ArrayRef<Attribute> cstOperands,
return foldMemRefCast(*this); return foldMemRefCast(*this);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AffineDmaWaitOp // AffineDmaWaitOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TODO(b/133776335) Check that map operands are loop IVs or symbols. // TODO(b/133776335) Check that map operands are loop IVs or symbols.
void AffineDmaWaitOp::build(Builder *builder, OperationState &result, void AffineDmaWaitOp::build(OpBuilder &builder, OperationState &result,
Value tagMemRef, AffineMap tagMap, Value tagMemRef, AffineMap tagMap,
ValueRange tagIndices, Value numElements) { ValueRange tagIndices, Value numElements) {
result.addOperands(tagMemRef); result.addOperands(tagMemRef);
result.addAttribute(getTagMapAttrName(), AffineMapAttr::get(tagMap)); result.addAttribute(getTagMapAttrName(), AffineMapAttr::get(tagMap));
result.addOperands(tagIndices); result.addOperands(tagIndices);
result.addOperands(numElements); result.addOperands(numElements);
} }
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 LinesLogicalResult AffineDmaWaitOp::fold(ArrayRef<Attribute> cstOperands,
/// dma_wait(memrefcast) -> dma_wait /// dma_wait(memrefcast) -> dma_wait
return foldMemRefCast(*this); return foldMemRefCast(*this);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AffineForOp // AffineForOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void AffineForOp::build(Builder *builder, OperationState &result, void AffineForOp::build(OpBuilder &builder, OperationState &result,
ValueRange lbOperands, AffineMap lbMap, ValueRange lbOperands, AffineMap lbMap,
ValueRange ubOperands, AffineMap ubMap, int64_t step) { ValueRange ubOperands, AffineMap ubMap, int64_t step) {
assert(((!lbMap && lbOperands.empty()) || assert(((!lbMap && lbOperands.empty()) ||
lbOperands.size() == lbMap.getNumInputs()) && lbOperands.size() == lbMap.getNumInputs()) &&
"lower bound operand count does not match the affine map"); "lower bound operand count does not match the affine map");
assert(((!ubMap && ubOperands.empty()) || assert(((!ubMap && ubOperands.empty()) ||
ubOperands.size() == ubMap.getNumInputs()) && ubOperands.size() == ubMap.getNumInputs()) &&
"upper bound operand count does not match the affine map"); "upper bound operand count does not match the affine map");
assert(step > 0 && "step has to be a positive integer constant"); assert(step > 0 && "step has to be a positive integer constant");
// Add an attribute for the step. // Add an attribute for the step.
result.addAttribute(getStepAttrName(), result.addAttribute(getStepAttrName(),
builder->getIntegerAttr(builder->getIndexType(), step)); builder.getIntegerAttr(builder.getIndexType(), step));
// Add the lower bound. // Add the lower bound.
result.addAttribute(getLowerBoundAttrName(), AffineMapAttr::get(lbMap)); result.addAttribute(getLowerBoundAttrName(), AffineMapAttr::get(lbMap));
result.addOperands(lbOperands); result.addOperands(lbOperands);
// Add the upper bound. // Add the upper bound.
result.addAttribute(getUpperBoundAttrName(), AffineMapAttr::get(ubMap)); result.addAttribute(getUpperBoundAttrName(), AffineMapAttr::get(ubMap));
result.addOperands(ubOperands); result.addOperands(ubOperands);
// Create a region and a block for the body. The argument of the region is // Create a region and a block for the body. The argument of the region is
// the loop induction variable. // the loop induction variable.
Region *bodyRegion = result.addRegion(); Region *bodyRegion = result.addRegion();
Block *body = new Block(); Block *body = new Block();
body->addArgument(IndexType::get(builder->getContext())); body->addArgument(IndexType::get(builder.getContext()));
bodyRegion->push_back(body); bodyRegion->push_back(body);
ensureTerminator(*bodyRegion, *builder, result.location); ensureTerminator(*bodyRegion, builder, result.location);
// Set the operands list as resizable so that we can freely modify the bounds. // Set the operands list as resizable so that we can freely modify the bounds.
result.setOperandListToResizable(); result.setOperandListToResizable();
} }
void AffineForOp::build(Builder *builder, OperationState &result, int64_t lb, void AffineForOp::build(OpBuilder &builder, OperationState &result, int64_t lb,
int64_t ub, int64_t step) { int64_t ub, int64_t step) {
auto lbMap = AffineMap::getConstantMap(lb, builder->getContext()); auto lbMap = AffineMap::getConstantMap(lb, builder.getContext());
auto ubMap = AffineMap::getConstantMap(ub, builder->getContext()); auto ubMap = AffineMap::getConstantMap(ub, builder.getContext());
return build(builder, result, {}, lbMap, {}, ubMap, step); return build(builder, result, {}, lbMap, {}, ubMap, step);
} }
static LogicalResult verify(AffineForOp op) { static LogicalResult verify(AffineForOp op) {
// Check that the body defines as single block argument for the induction // Check that the body defines as single block argument for the induction
// variable. // variable.
auto *body = op.getBody(); auto *body = op.getBody();
if (body->getNumArguments() != 1 || !body->getArgument(0).getType().isIndex()) if (body->getNumArguments() != 1 || !body->getArgument(0).getType().isIndex())
▲ Show 20 Lines • Show All 593 Lines • ▼ Show 20 Linesvoid AffineIfOp::setIntegerSet(IntegerSet newSet) {
setAttr(getConditionAttrName(), IntegerSetAttr::get(newSet)); setAttr(getConditionAttrName(), IntegerSetAttr::get(newSet));
} }
void AffineIfOp::setConditional(IntegerSet set, ValueRange operands) { void AffineIfOp::setConditional(IntegerSet set, ValueRange operands) {
setIntegerSet(set); setIntegerSet(set);
getOperation()->setOperands(operands); getOperation()->setOperands(operands);
} }
void AffineIfOp::build(Builder *builder, OperationState &result, IntegerSet set, void AffineIfOp::build(OpBuilder &builder, OperationState &result,
ValueRange args, bool withElseRegion) { IntegerSet set, ValueRange args, bool withElseRegion) {
result.addOperands(args); result.addOperands(args);
result.addAttribute(getConditionAttrName(), IntegerSetAttr::get(set)); result.addAttribute(getConditionAttrName(), IntegerSetAttr::get(set));
Region *thenRegion = result.addRegion(); Region *thenRegion = result.addRegion();
Region *elseRegion = result.addRegion(); Region *elseRegion = result.addRegion();
AffineIfOp::ensureTerminator(*thenRegion, *builder, result.location); AffineIfOp::ensureTerminator(*thenRegion, builder, result.location);
if (withElseRegion) if (withElseRegion)
AffineIfOp::ensureTerminator(*elseRegion, *builder, result.location); AffineIfOp::ensureTerminator(*elseRegion, builder, result.location);
} }
/// Canonicalize an affine if op's conditional (integer set + operands). /// Canonicalize an affine if op's conditional (integer set + operands).
LogicalResult AffineIfOp::fold(ArrayRef<Attribute>, LogicalResult AffineIfOp::fold(ArrayRef<Attribute>,
SmallVectorImpl<OpFoldResult> &) { SmallVectorImpl<OpFoldResult> &) {
auto set = getIntegerSet(); auto set = getIntegerSet();
SmallVector<Value, 4> operands(getOperands()); SmallVector<Value, 4> operands(getOperands());
canonicalizeSetAndOperands(&set, &operands); canonicalizeSetAndOperands(&set, &operands);
Show All 14 Linesvoid AffineIfOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
MLIRContext *context) { MLIRContext *context) {
results.insert<SimplifyDeadElse>(context); results.insert<SimplifyDeadElse>(context);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AffineLoadOp // AffineLoadOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void AffineLoadOp::build(Builder *builder, OperationState &result, void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
AffineMap map, ValueRange operands) { AffineMap map, ValueRange operands) {
assert(operands.size() == 1 + map.getNumInputs() && "inconsistent operands"); assert(operands.size() == 1 + map.getNumInputs() && "inconsistent operands");
result.addOperands(operands); result.addOperands(operands);
if (map) if (map)
result.addAttribute(getMapAttrName(), AffineMapAttr::get(map)); result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
auto memrefType = operands[0].getType().cast<MemRefType>(); auto memrefType = operands[0].getType().cast<MemRefType>();
result.types.push_back(memrefType.getElementType()); result.types.push_back(memrefType.getElementType());
} }
void AffineLoadOp::build(Builder *builder, OperationState &result, Value memref, void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
AffineMap map, ValueRange mapOperands) { Value memref, AffineMap map, ValueRange mapOperands) {
assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info"); assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info");
result.addOperands(memref); result.addOperands(memref);
result.addOperands(mapOperands); result.addOperands(mapOperands);
auto memrefType = memref.getType().cast<MemRefType>(); auto memrefType = memref.getType().cast<MemRefType>();
result.addAttribute(getMapAttrName(), AffineMapAttr::get(map)); result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
result.types.push_back(memrefType.getElementType()); result.types.push_back(memrefType.getElementType());
} }
void AffineLoadOp::build(Builder *builder, OperationState &result, Value memref, void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
ValueRange indices) { Value memref, ValueRange indices) {
auto memrefType = memref.getType().cast<MemRefType>(); auto memrefType = memref.getType().cast<MemRefType>();
auto rank = memrefType.getRank(); auto rank = memrefType.getRank();
// Create identity map for memrefs with at least one dimension or () -> () // Create identity map for memrefs with at least one dimension or () -> ()
// for zero-dimensional memrefs. // for zero-dimensional memrefs.
auto map = rank ? builder->getMultiDimIdentityMap(rank) auto map =
: builder->getEmptyAffineMap(); rank ? builder.getMultiDimIdentityMap(rank) : builder.getEmptyAffineMap();
build(builder, result, memref, map, indices); build(builder, result, memref, map, indices);
} }
ParseResult AffineLoadOp::parse(OpAsmParser &parser, OperationState &result) { ParseResult AffineLoadOp::parse(OpAsmParser &parser, OperationState &result) {
auto &builder = parser.getBuilder(); auto &builder = parser.getBuilder();
auto indexTy = builder.getIndexType(); auto indexTy = builder.getIndexType();
MemRefType type; MemRefType type;
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines if (succeeded(foldMemRefCast(*this)))
return getResult(); return getResult();
return OpFoldResult(); return OpFoldResult();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AffineStoreOp // AffineStoreOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void AffineStoreOp::build(Builder *builder, OperationState &result, void AffineStoreOp::build(OpBuilder &builder, OperationState &result,
Value valueToStore, Value memref, AffineMap map, Value valueToStore, Value memref, AffineMap map,
ValueRange mapOperands) { ValueRange mapOperands) {
assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info"); assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info");
result.addOperands(valueToStore); result.addOperands(valueToStore);
result.addOperands(memref); result.addOperands(memref);
result.addOperands(mapOperands); result.addOperands(mapOperands);
result.addAttribute(getMapAttrName(), AffineMapAttr::get(map)); result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
} }
// Use identity map. // Use identity map.
void AffineStoreOp::build(Builder *builder, OperationState &result, void AffineStoreOp::build(OpBuilder &builder, OperationState &result,
Value valueToStore, Value memref, Value valueToStore, Value memref,
ValueRange indices) { ValueRange indices) {
auto memrefType = memref.getType().cast<MemRefType>(); auto memrefType = memref.getType().cast<MemRefType>();
auto rank = memrefType.getRank(); auto rank = memrefType.getRank();
// Create identity map for memrefs with at least one dimension or () -> () // Create identity map for memrefs with at least one dimension or () -> ()
// for zero-dimensional memrefs. // for zero-dimensional memrefs.
auto map = rank ? builder->getMultiDimIdentityMap(rank) auto map =
: builder->getEmptyAffineMap(); rank ? builder.getMultiDimIdentityMap(rank) : builder.getEmptyAffineMap();
build(builder, result, valueToStore, memref, map, indices); build(builder, result, valueToStore, memref, map, indices);
} }
ParseResult AffineStoreOp::parse(OpAsmParser &parser, OperationState &result) { ParseResult AffineStoreOp::parse(OpAsmParser &parser, OperationState &result) {
auto indexTy = parser.getBuilder().getIndexType(); auto indexTy = parser.getBuilder().getIndexType();
MemRefType type; MemRefType type;
OpAsmParser::OperandType storeValueInfo; OpAsmParser::OperandType storeValueInfo;
▲ Show 20 Lines • Show All 282 Lines • ▼ Show 20 LinesLogicalResult AffinePrefetchOp::fold(ArrayRef<Attribute> cstOperands,
/// prefetch(memrefcast) -> prefetch /// prefetch(memrefcast) -> prefetch
return foldMemRefCast(*this); return foldMemRefCast(*this);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// AffineParallelOp // AffineParallelOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void AffineParallelOp::build(Builder *builder, OperationState &result, void AffineParallelOp::build(OpBuilder &builder, OperationState &result,
ArrayRef<int64_t> ranges) { ArrayRef<int64_t> ranges) {
SmallVector<AffineExpr, 8> lbExprs(ranges.size(), SmallVector<AffineExpr, 8> lbExprs(ranges.size(),
builder->getAffineConstantExpr(0)); builder.getAffineConstantExpr(0));
auto lbMap = AffineMap::get(0, 0, lbExprs, builder->getContext()); auto lbMap = AffineMap::get(0, 0, lbExprs, builder.getContext());
SmallVector<AffineExpr, 8> ubExprs; SmallVector<AffineExpr, 8> ubExprs;
for (int64_t range : ranges) for (int64_t range : ranges)
ubExprs.push_back(builder->getAffineConstantExpr(range)); ubExprs.push_back(builder.getAffineConstantExpr(range));
auto ubMap = AffineMap::get(0, 0, ubExprs, builder->getContext()); auto ubMap = AffineMap::get(0, 0, ubExprs, builder.getContext());
build(builder, result, lbMap, {}, ubMap, {}); build(builder, result, lbMap, {}, ubMap, {});
} }
void AffineParallelOp::build(Builder *builder, OperationState &result, void AffineParallelOp::build(OpBuilder &builder, OperationState &result,
AffineMap lbMap, ValueRange lbArgs, AffineMap lbMap, ValueRange lbArgs,
AffineMap ubMap, ValueRange ubArgs) { AffineMap ubMap, ValueRange ubArgs) {
auto numDims = lbMap.getNumResults(); auto numDims = lbMap.getNumResults();
// Verify that the dimensionality of both maps are the same. // Verify that the dimensionality of both maps are the same.
assert(numDims == ubMap.getNumResults() && assert(numDims == ubMap.getNumResults() &&
"num dims and num results mismatch"); "num dims and num results mismatch");
// Make default step sizes of 1. // Make default step sizes of 1.
SmallVector<int64_t, 8> steps(numDims, 1); SmallVector<int64_t, 8> steps(numDims, 1);
build(builder, result, lbMap, lbArgs, ubMap, ubArgs, steps); build(builder, result, lbMap, lbArgs, ubMap, ubArgs, steps);
} }
void AffineParallelOp::build(Builder *builder, OperationState &result, void AffineParallelOp::build(OpBuilder &builder, OperationState &result,
AffineMap lbMap, ValueRange lbArgs, AffineMap lbMap, ValueRange lbArgs,
AffineMap ubMap, ValueRange ubArgs, AffineMap ubMap, ValueRange ubArgs,
ArrayRef<int64_t> steps) { ArrayRef<int64_t> steps) {
auto numDims = lbMap.getNumResults(); auto numDims = lbMap.getNumResults();
// Verify that the dimensionality of the maps matches the number of steps. // Verify that the dimensionality of the maps matches the number of steps.
assert(numDims == ubMap.getNumResults() && assert(numDims == ubMap.getNumResults() &&
"num dims and num results mismatch"); "num dims and num results mismatch");
assert(numDims == steps.size() && "num dims and num steps mismatch"); assert(numDims == steps.size() && "num dims and num steps mismatch");
result.addAttribute(getLowerBoundsMapAttrName(), AffineMapAttr::get(lbMap)); result.addAttribute(getLowerBoundsMapAttrName(), AffineMapAttr::get(lbMap));
result.addAttribute(getUpperBoundsMapAttrName(), AffineMapAttr::get(ubMap)); result.addAttribute(getUpperBoundsMapAttrName(), AffineMapAttr::get(ubMap));
result.addAttribute(getStepsAttrName(), builder->getI64ArrayAttr(steps)); result.addAttribute(getStepsAttrName(), builder.getI64ArrayAttr(steps));
result.addOperands(lbArgs); result.addOperands(lbArgs);
result.addOperands(ubArgs); result.addOperands(ubArgs);
// Create a region and a block for the body. // Create a region and a block for the body.
auto bodyRegion = result.addRegion(); auto bodyRegion = result.addRegion();
auto body = new Block(); auto body = new Block();
// Add all the block arguments. // Add all the block arguments.
for (unsigned i = 0; i < numDims; ++i) for (unsigned i = 0; i < numDims; ++i)
body->addArgument(IndexType::get(builder->getContext())); body->addArgument(IndexType::get(builder.getContext()));
bodyRegion->push_back(body); bodyRegion->push_back(body);
ensureTerminator(*bodyRegion, *builder, result.location); ensureTerminator(*bodyRegion, builder, result.location);
} }
unsigned AffineParallelOp::getNumDims() { return steps().size(); } unsigned AffineParallelOp::getNumDims() { return steps().size(); }
AffineParallelOp::operand_range AffineParallelOp::getLowerBoundsOperands() { AffineParallelOp::operand_range AffineParallelOp::getLowerBoundsOperands() {
return getOperands().take_front(lowerBoundsMap().getNumInputs()); return getOperands().take_front(lowerBoundsMap().getNumInputs());
} }
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Lines if (parser.parseColonType(valueType) ||
return failure(); return failure();
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// LaunchOp // LaunchOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void LaunchOp::build(Builder *builder, OperationState &result, Value gridSizeX, void LaunchOp::build(OpBuilder &builder, OperationState &result,
Value gridSizeY, Value gridSizeZ, Value blockSizeX, Value gridSizeX, Value gridSizeY, Value gridSizeZ,
Value blockSizeY, Value blockSizeZ) { Value blockSizeX, Value blockSizeY, Value blockSizeZ) {
// Add grid and block sizes as op operands, followed by the data operands. // Add grid and block sizes as op operands, followed by the data operands.
result.addOperands( result.addOperands(
{gridSizeX, gridSizeY, gridSizeZ, blockSizeX, blockSizeY, blockSizeZ}); {gridSizeX, gridSizeY, gridSizeZ, blockSizeX, blockSizeY, blockSizeZ});
// Create a kernel body region with kNumConfigRegionAttributes + N arguments, // Create a kernel body region with kNumConfigRegionAttributes + N arguments,
// where the first kNumConfigRegionAttributes arguments have `index` type and // where the first kNumConfigRegionAttributes arguments have `index` type and
// the rest have the same types as the data operands. // the rest have the same types as the data operands.
Region *kernelRegion = result.addRegion(); Region *kernelRegion = result.addRegion();
Block *body = new Block(); Block *body = new Block();
body->addArguments( body->addArguments(
std::vector<Type>(kNumConfigRegionAttributes, builder->getIndexType())); std::vector<Type>(kNumConfigRegionAttributes, builder.getIndexType()));
kernelRegion->push_back(body); kernelRegion->push_back(body);
} }
KernelDim3 LaunchOp::getBlockIds() { KernelDim3 LaunchOp::getBlockIds() {
assert(!body().getBlocks().empty() && "FuncOp body must not be empty."); assert(!body().getBlocks().empty() && "FuncOp body must not be empty.");
auto args = body().getBlocks().front().getArguments(); auto args = body().getBlocks().front().getArguments();
return KernelDim3{args[0], args[1], args[2]}; return KernelDim3{args[0], args[1], args[2]};
} }
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Linesstatic ParseResult parseLaunchOp(OpAsmParser &parser, OperationState &result) {
return failure(parser.parseRegion(*body, regionArgs, dataTypes) || return failure(parser.parseRegion(*body, regionArgs, dataTypes) ||
parser.parseOptionalAttrDict(result.attributes)); parser.parseOptionalAttrDict(result.attributes));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// LaunchFuncOp // LaunchFuncOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void LaunchFuncOp::build(Builder *builder, OperationState &result, void LaunchFuncOp::build(OpBuilder &builder, OperationState &result,
GPUFuncOp kernelFunc, Value gridSizeX, Value gridSizeY, GPUFuncOp kernelFunc, Value gridSizeX, Value gridSizeY,
Value gridSizeZ, Value blockSizeX, Value blockSizeY, Value gridSizeZ, Value blockSizeX, Value blockSizeY,
Value blockSizeZ, ValueRange kernelOperands) { Value blockSizeZ, ValueRange kernelOperands) {
// Add grid and block sizes as op operands, followed by the data operands. // Add grid and block sizes as op operands, followed by the data operands.
result.addOperands( result.addOperands(
{gridSizeX, gridSizeY, gridSizeZ, blockSizeX, blockSizeY, blockSizeZ}); {gridSizeX, gridSizeY, gridSizeZ, blockSizeX, blockSizeY, blockSizeZ});
result.addOperands(kernelOperands); result.addOperands(kernelOperands);
auto kernelModule = kernelFunc.getParentOfType<GPUModuleOp>(); auto kernelModule = kernelFunc.getParentOfType<GPUModuleOp>();
auto kernelSymbol = builder->getSymbolRefAttr( auto kernelSymbol = builder.getSymbolRefAttr(
kernelModule.getName(), kernelModule.getName(), {builder.getSymbolRefAttr(kernelFunc.getName())});
{builder->getSymbolRefAttr(kernelFunc.getName())});
result.addAttribute(getKernelAttrName(), kernelSymbol); result.addAttribute(getKernelAttrName(), kernelSymbol);
} }
void LaunchFuncOp::build(Builder *builder, OperationState &result, void LaunchFuncOp::build(OpBuilder &builder, OperationState &result,
GPUFuncOp kernelFunc, KernelDim3 gridSize, GPUFuncOp kernelFunc, KernelDim3 gridSize,
KernelDim3 blockSize, ValueRange kernelOperands) { KernelDim3 blockSize, ValueRange kernelOperands) {
build(builder, result, kernelFunc, gridSize.x, gridSize.y, gridSize.z, build(builder, result, kernelFunc, gridSize.x, gridSize.y, gridSize.z,
blockSize.x, blockSize.y, blockSize.z, kernelOperands); blockSize.x, blockSize.y, blockSize.z, kernelOperands);
} }
SymbolRefAttr LaunchFuncOp::kernel() { SymbolRefAttr LaunchFuncOp::kernel() {
return getAttrOfType<SymbolRefAttr>(getKernelAttrName()); return getAttrOfType<SymbolRefAttr>(getKernelAttrName());
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 LinesValue GPUFuncOp::addWorkgroupAttribution(ArrayRef<int64_t> shape,
auto numWorkgroupBuffersAttr = auto numWorkgroupBuffersAttr =
getAttrOfType<IntegerAttr>(getNumWorkgroupAttributionsAttrName()); getAttrOfType<IntegerAttr>(getNumWorkgroupAttributionsAttrName());
setAttr(getNumWorkgroupAttributionsAttrName(), setAttr(getNumWorkgroupAttributionsAttrName(),
IntegerAttr::get(numWorkgroupBuffersAttr.getType(), IntegerAttr::get(numWorkgroupBuffersAttr.getType(),
numWorkgroupBuffersAttr.getValue() + 1)); numWorkgroupBuffersAttr.getValue() + 1));
return attribution; return attribution;
} }
void GPUFuncOp::build(Builder *builder, OperationState &result, StringRef name, void GPUFuncOp::build(OpBuilder &builder, OperationState &result,
FunctionType type, ArrayRef<Type> workgroupAttributions, StringRef name, FunctionType type,
ArrayRef<Type> workgroupAttributions,
ArrayRef<Type> privateAttributions, ArrayRef<Type> privateAttributions,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
result.addAttribute(SymbolTable::getSymbolAttrName(), result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name)); builder.getStringAttr(name));
result.addAttribute(getTypeAttrName(), TypeAttr::get(type)); result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
result.addAttribute(getNumWorkgroupAttributionsAttrName(), result.addAttribute(getNumWorkgroupAttributionsAttrName(),
builder->getI64IntegerAttr(workgroupAttributions.size())); builder.getI64IntegerAttr(workgroupAttributions.size()));
result.addAttributes(attrs); result.addAttributes(attrs);
Region *body = result.addRegion(); Region *body = result.addRegion();
Block *entryBlock = new Block; Block *entryBlock = new Block;
entryBlock->addArguments(type.getInputs()); entryBlock->addArguments(type.getInputs());
entryBlock->addArguments(workgroupAttributions); entryBlock->addArguments(workgroupAttributions);
entryBlock->addArguments(privateAttributions); entryBlock->addArguments(privateAttributions);
body->getBlocks().push_back(entryBlock); body->getBlocks().push_back(entryBlock);
▲ Show 20 Lines • Show All 241 Lines • ▼ Show 20 Linesstatic LogicalResult verify(gpu::ReturnOp returnOp) {
} }
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GPUModuleOp // GPUModuleOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void GPUModuleOp::build(Builder *builder, OperationState &result, void GPUModuleOp::build(OpBuilder &builder, OperationState &result,
StringRef name) { StringRef name) {
ensureTerminator(*result.addRegion(), *builder, result.location); ensureTerminator(*result.addRegion(), builder, result.location);
result.attributes.push_back(builder->getNamedAttr( result.attributes.push_back(builder.getNamedAttr(
::mlir::SymbolTable::getSymbolAttrName(), builder->getStringAttr(name))); ::mlir::SymbolTable::getSymbolAttrName(), builder.getStringAttr(name)));
} }
static ParseResult parseGPUModuleOp(OpAsmParser &parser, static ParseResult parseGPUModuleOp(OpAsmParser &parser,
OperationState &result) { OperationState &result) {
StringAttr nameAttr; StringAttr nameAttr;
if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(), if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
result.attributes)) result.attributes))
return failure(); return failure();
Show All 31 Lines

mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp

Show First 20 Lines • Show All 259 Lines • ▼ Show 20 Linesprivate:
// Returns a gpu.module containing kernelFunc and all callees (recursive). // Returns a gpu.module containing kernelFunc and all callees (recursive).
gpu::GPUModuleOp createKernelModule(gpu::GPUFuncOp kernelFunc, gpu::GPUModuleOp createKernelModule(gpu::GPUFuncOp kernelFunc,
const SymbolTable &parentSymbolTable) { const SymbolTable &parentSymbolTable) {
// TODO: This code cannot use an OpBuilder because it must be inserted into // TODO: This code cannot use an OpBuilder because it must be inserted into
// a SymbolTable by the caller. SymbolTable needs to be refactored to // a SymbolTable by the caller. SymbolTable needs to be refactored to
// prevent manual building of Ops with symbols in code using SymbolTables // prevent manual building of Ops with symbols in code using SymbolTables
// and then this needs to use the OpBuilder. // and then this needs to use the OpBuilder.
auto context = getOperation().getContext(); auto context = getOperation().getContext();
Builder builder(context); OpBuilder builder(context);
OperationState state(kernelFunc.getLoc(), OperationState state(kernelFunc.getLoc(),
gpu::GPUModuleOp::getOperationName()); gpu::GPUModuleOp::getOperationName());
gpu::GPUModuleOp::build(&builder, state, kernelFunc.getName()); gpu::GPUModuleOp::build(builder, state, kernelFunc.getName());
auto kernelModule = cast<gpu::GPUModuleOp>(Operation::create(state)); auto kernelModule = cast<gpu::GPUModuleOp>(Operation::create(state));
SymbolTable symbolTable(kernelModule); SymbolTable symbolTable(kernelModule);
symbolTable.insert(kernelFunc); symbolTable.insert(kernelFunc);
SmallVector<Operation *, 8> symbolDefWorklist = {kernelFunc}; SmallVector<Operation *, 8> symbolDefWorklist = {kernelFunc};
while (!symbolDefWorklist.empty()) { while (!symbolDefWorklist.empty()) {
if (Optional<SymbolTable::UseRange> symbolUses = if (Optional<SymbolTable::UseRange> symbolUses =
SymbolTable::getSymbolUses(symbolDefWorklist.pop_back_val())) { SymbolTable::getSymbolUses(symbolDefWorklist.pop_back_val())) {
Show All 23 Lines

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

Show First 20 Lines • Show All 606 Lines • ▼ Show 20 Linesstatic ParseResult parseCallOp(OpAsmParser &parser, OperationState &result) {
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Printing/parsing for LLVM::ExtractElementOp. // Printing/parsing for LLVM::ExtractElementOp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Expects vector to be of wrapped LLVM vector type and position to be of // Expects vector to be of wrapped LLVM vector type and position to be of
// wrapped LLVM i32 type. // wrapped LLVM i32 type.
void LLVM::ExtractElementOp::build(Builder *b, OperationState &result, void LLVM::ExtractElementOp::build(OpBuilder &b, OperationState &result,
Value vector, Value position, Value vector, Value position,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
auto wrappedVectorType = vector.getType().cast<LLVM::LLVMType>(); auto wrappedVectorType = vector.getType().cast<LLVM::LLVMType>();
auto llvmType = wrappedVectorType.getVectorElementType(); auto llvmType = wrappedVectorType.getVectorElementType();
build(b, result, llvmType, vector, position); build(b, result, llvmType, vector, position);
result.addAttributes(attrs); result.addAttributes(attrs);
} }
▲ Show 20 Lines • Show All 263 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Builder, printer and verifier for LLVM::GlobalOp. // Builder, printer and verifier for LLVM::GlobalOp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Returns the name used for the linkage attribute. This *must* correspond to /// Returns the name used for the linkage attribute. This *must* correspond to
/// the name of the attribute in ODS. /// the name of the attribute in ODS.
static StringRef getLinkageAttrName() { return "linkage"; } static StringRef getLinkageAttrName() { return "linkage"; }
void GlobalOp::build(Builder *builder, OperationState &result, LLVMType type, void GlobalOp::build(OpBuilder &builder, OperationState &result, LLVMType type,
bool isConstant, Linkage linkage, StringRef name, bool isConstant, Linkage linkage, StringRef name,
Attribute value, unsigned addrSpace, Attribute value, unsigned addrSpace,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
result.addAttribute(SymbolTable::getSymbolAttrName(), result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name)); builder.getStringAttr(name));
result.addAttribute("type", TypeAttr::get(type)); result.addAttribute("type", TypeAttr::get(type));
if (isConstant) if (isConstant)
result.addAttribute("constant", builder->getUnitAttr()); result.addAttribute("constant", builder.getUnitAttr());
if (value) if (value)
result.addAttribute("value", value); result.addAttribute("value", value);
result.addAttribute(getLinkageAttrName(), builder->getI64IntegerAttr( result.addAttribute(getLinkageAttrName(),
static_cast<int64_t>(linkage))); builder.getI64IntegerAttr(static_cast<int64_t>(linkage)));
if (addrSpace != 0) if (addrSpace != 0)
result.addAttribute("addr_space", builder->getI32IntegerAttr(addrSpace)); result.addAttribute("addr_space", builder.getI32IntegerAttr(addrSpace));
result.attributes.append(attrs.begin(), attrs.end()); result.attributes.append(attrs.begin(), attrs.end());
result.addRegion(); result.addRegion();
} }
static void printGlobalOp(OpAsmPrinter &p, GlobalOp op) { static void printGlobalOp(OpAsmPrinter &p, GlobalOp op) {
p << op.getOperationName() << ' ' << stringifyLinkage(op.linkage()) << ' '; p << op.getOperationName() << ' ' << stringifyLinkage(op.linkage()) << ' ';
if (op.constant()) if (op.constant())
p << "constant "; p << "constant ";
▲ Show 20 Lines • Show All 183 Lines • ▼ Show 20 Linesstatic LogicalResult verify(GlobalOp op) {
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Printing/parsing for LLVM::ShuffleVectorOp. // Printing/parsing for LLVM::ShuffleVectorOp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Expects vector to be of wrapped LLVM vector type and position to be of // Expects vector to be of wrapped LLVM vector type and position to be of
// wrapped LLVM i32 type. // wrapped LLVM i32 type.
void LLVM::ShuffleVectorOp::build(Builder *b, OperationState &result, Value v1, void LLVM::ShuffleVectorOp::build(OpBuilder &b, OperationState &result,
Value v2, ArrayAttr mask, Value v1, Value v2, ArrayAttr mask,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
auto wrappedContainerType1 = v1.getType().cast<LLVM::LLVMType>(); auto wrappedContainerType1 = v1.getType().cast<LLVM::LLVMType>();
auto vType = LLVMType::getVectorTy( auto vType = LLVMType::getVectorTy(
wrappedContainerType1.getVectorElementType(), mask.size()); wrappedContainerType1.getVectorElementType(), mask.size());
build(b, result, vType, v1, v2, mask); build(b, result, vType, v1, v2, mask);
result.addAttributes(attrs); result.addAttributes(attrs);
} }
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 LinesBlock *LLVMFuncOp::addEntryBlock() {
push_back(entry); push_back(entry);
LLVMType type = getType(); LLVMType type = getType();
for (unsigned i = 0, e = type.getFunctionNumParams(); i < e; ++i) for (unsigned i = 0, e = type.getFunctionNumParams(); i < e; ++i)
entry->addArgument(type.getFunctionParamType(i)); entry->addArgument(type.getFunctionParamType(i));
return entry; return entry;
} }
void LLVMFuncOp::build(Builder *builder, OperationState &result, StringRef name, void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
LLVMType type, LLVM::Linkage linkage, StringRef name, LLVMType type, LLVM::Linkage linkage,
ArrayRef<NamedAttribute> attrs, ArrayRef<NamedAttribute> attrs,
ArrayRef<NamedAttributeList> argAttrs) { ArrayRef<NamedAttributeList> argAttrs) {
result.addRegion(); result.addRegion();
result.addAttribute(SymbolTable::getSymbolAttrName(), result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name)); builder.getStringAttr(name));
result.addAttribute("type", TypeAttr::get(type)); result.addAttribute("type", TypeAttr::get(type));
result.addAttribute(getLinkageAttrName(), builder->getI64IntegerAttr( result.addAttribute(getLinkageAttrName(),
static_cast<int64_t>(linkage))); builder.getI64IntegerAttr(static_cast<int64_t>(linkage)));
result.attributes.append(attrs.begin(), attrs.end()); result.attributes.append(attrs.begin(), attrs.end());
if (argAttrs.empty()) if (argAttrs.empty())
return; return;
unsigned numInputs = type.getUnderlyingType()->getFunctionNumParams(); unsigned numInputs = type.getUnderlyingType()->getFunctionNumParams();
assert(numInputs == argAttrs.size() && assert(numInputs == argAttrs.size() &&
"expected as many argument attribute lists as arguments"); "expected as many argument attribute lists as arguments");
SmallString<8> argAttrName; SmallString<8> argAttrName;
▲ Show 20 Lines • Show All 801 Lines • Show Last 20 Lines

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

Show First 20 Lines • Show All 462 Lines • ▼ Show 20 LinesgetSymbolLessAffineMaps(ArrayRef<ArrayRef<AffineExpr>> reassociation) {
for (auto exprs : reassociation) { for (auto exprs : reassociation) {
assert(exprs.size() != 0); assert(exprs.size() != 0);
maps.push_back(AffineMap::get(maxDim + 1, 0, exprs, exprs[0].getContext())); maps.push_back(AffineMap::get(maxDim + 1, 0, exprs, exprs[0].getContext()));
} }
return maps; return maps;
} }
void mlir::linalg::ReshapeOp::build( void mlir::linalg::ReshapeOp::build(
Builder *b, OperationState &result, Value src, OpBuilder &b, OperationState &result, Value src,
ArrayRef<ArrayRef<AffineExpr>> reassociation, ArrayRef<ArrayRef<AffineExpr>> reassociation,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
auto maps = getSymbolLessAffineMaps(reassociation); auto maps = getSymbolLessAffineMaps(reassociation);
auto memRefType = src.getType().cast<MemRefType>(); auto memRefType = src.getType().cast<MemRefType>();
auto resultType = computeReshapeCollapsedType(memRefType, maps); auto resultType = computeReshapeCollapsedType(memRefType, maps);
build(b, result, resultType, src, attrs); build(b, result, resultType, src, attrs);
result.addAttribute(ReshapeOp::getReassociationAttrName(), result.addAttribute(ReshapeOp::getReassociationAttrName(),
b->getAffineMapArrayAttr(maps)); b.getAffineMapArrayAttr(maps));
} }
void mlir::linalg::ReshapeOp::build( void mlir::linalg::ReshapeOp::build(
Builder *b, OperationState &result, Type resultType, Value src, OpBuilder &b, OperationState &result, Type resultType, Value src,
ArrayRef<ArrayRef<AffineExpr>> reassociation, ArrayRef<ArrayRef<AffineExpr>> reassociation,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
auto maps = getSymbolLessAffineMaps(reassociation); auto maps = getSymbolLessAffineMaps(reassociation);
build(b, result, resultType, src, attrs); build(b, result, resultType, src, attrs);
result.addAttribute(ReshapeOp::getReassociationAttrName(), result.addAttribute(ReshapeOp::getReassociationAttrName(),
b->getAffineMapArrayAttr(maps)); b.getAffineMapArrayAttr(maps));
} }
// Common verifier for reshape-like types. Fills `expandedType` and // Common verifier for reshape-like types. Fills `expandedType` and
// `collapsedType` with the proper `src` or `result` type. // `collapsedType` with the proper `src` or `result` type.
template <typename Op, typename T> template <typename Op, typename T>
LogicalResult verifyReshapeLikeTypes(Op op, T &expandedType, T &collapsedType) { LogicalResult verifyReshapeLikeTypes(Op op, T &expandedType, T &collapsedType) {
expandedType = op.getSrcType(); expandedType = op.getSrcType();
collapsedType = op.getResultType(); collapsedType = op.getResultType();
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines for (AffineMap m : reassociation) {
newShape.push_back(size); newShape.push_back(size);
currentDim += dim; currentDim += dim;
} }
return RankedTensorType::get(newShape, type.getElementType()); return RankedTensorType::get(newShape, type.getElementType());
} }
void mlir::linalg::TensorReshapeOp::build( void mlir::linalg::TensorReshapeOp::build(
Builder *b, OperationState &result, Value src, OpBuilder &b, OperationState &result, Value src,
ArrayRef<ArrayRef<AffineExpr>> reassociation, ArrayRef<ArrayRef<AffineExpr>> reassociation,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
auto maps = getSymbolLessAffineMaps(reassociation); auto maps = getSymbolLessAffineMaps(reassociation);
auto resultType = computeTensorReshapeCollapsedType( auto resultType = computeTensorReshapeCollapsedType(
src.getType().cast<RankedTensorType>(), maps); src.getType().cast<RankedTensorType>(), maps);
build(b, result, resultType, src, attrs); build(b, result, resultType, src, attrs);
result.addAttribute(TensorReshapeOp::getReassociationAttrName(), result.addAttribute(TensorReshapeOp::getReassociationAttrName(),
b->getAffineMapArrayAttr(maps)); b.getAffineMapArrayAttr(maps));
} }
void mlir::linalg::TensorReshapeOp::build( void mlir::linalg::TensorReshapeOp::build(
Builder *b, OperationState &result, Type resultType, Value src, OpBuilder &b, OperationState &result, Type resultType, Value src,
ArrayRef<ArrayRef<AffineExpr>> reassociation, ArrayRef<ArrayRef<AffineExpr>> reassociation,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
auto maps = getSymbolLessAffineMaps(reassociation); auto maps = getSymbolLessAffineMaps(reassociation);
build(b, result, resultType, src, attrs); build(b, result, resultType, src, attrs);
result.addAttribute(TensorReshapeOp::getReassociationAttrName(), result.addAttribute(TensorReshapeOp::getReassociationAttrName(),
b->getAffineMapArrayAttr(maps)); b.getAffineMapArrayAttr(maps));
} }
static LogicalResult verify(TensorReshapeOp op) { static LogicalResult verify(TensorReshapeOp op) {
RankedTensorType expandedType, collapsedType; RankedTensorType expandedType, collapsedType;
if (failed(verifyReshapeLikeTypes(op, expandedType, collapsedType))) if (failed(verifyReshapeLikeTypes(op, expandedType, collapsedType)))
return failure(); return failure();
auto maps = getAffineMaps(op.reassociation()); auto maps = getAffineMaps(op.reassociation());
// TODO(ntv): expanding a ? with a non-constant is under-specified. Error // TODO(ntv): expanding a ? with a non-constant is under-specified. Error
// out. // out.
RankedTensorType expectedType = RankedTensorType expectedType =
computeTensorReshapeCollapsedType(expandedType, maps); computeTensorReshapeCollapsedType(expandedType, maps);
if (collapsedType != expectedType) if (collapsedType != expectedType)
return op.emitOpError("expected collapsed type to be ") return op.emitOpError("expected collapsed type to be ")
<< expectedType << ", but got " << collapsedType; << expectedType << ", but got " << collapsedType;
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// SliceOp // SliceOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void mlir::linalg::SliceOp::build(Builder *b, OperationState &result, void mlir::linalg::SliceOp::build(OpBuilder &b, OperationState &result,
Value base, ValueRange indexings) { Value base, ValueRange indexings) {
result.addOperands(base); result.addOperands(base);
result.addOperands(indexings); result.addOperands(indexings);
auto memRefType = base.getType().cast<MemRefType>(); auto memRefType = base.getType().cast<MemRefType>();
int64_t offset; int64_t offset;
SmallVector<int64_t, 4> strides; SmallVector<int64_t, 4> strides;
auto res = getStridesAndOffset(memRefType, strides, offset); auto res = getStridesAndOffset(memRefType, strides, offset);
assert(succeeded(res) && strides.size() == indexings.size()); assert(succeeded(res) && strides.size() == indexings.size());
(void)res; (void)res;
unsigned rank = memRefType.getRank(); unsigned rank = memRefType.getRank();
// TODO(ntv): propagate static size and stride information when available. // TODO(ntv): propagate static size and stride information when available.
SmallVector<int64_t, 4> sizes(rank, -1); // -1 encodes dynamic size. SmallVector<int64_t, 4> sizes(rank, -1); // -1 encodes dynamic size.
result.addTypes({MemRefType::Builder(memRefType) result.addTypes({MemRefType::Builder(memRefType)
.setShape(sizes) .setShape(sizes)
.setAffineMaps(makeStridedLinearLayoutMap( .setAffineMaps(makeStridedLinearLayoutMap(
strides, offset, b->getContext()))}); strides, offset, b.getContext()))});
} }
static void print(OpAsmPrinter &p, SliceOp op) { static void print(OpAsmPrinter &p, SliceOp op) {
auto indexings = op.indexings(); auto indexings = op.indexings();
p << SliceOp::getOperationName() << " " << op.view() << "[" << indexings p << SliceOp::getOperationName() << " " << op.view() << "[" << indexings
<< "] "; << "] ";
p.printOptionalAttrDict(op.getAttrs()); p.printOptionalAttrDict(op.getAttrs());
p << " : " << op.getBaseViewType(); p << " : " << op.getBaseViewType();
Show All 40 Lines if (op.getRank() != rank)
return op.emitOpError() << "expected rank of the view(" << op.getRank() return op.emitOpError() << "expected rank of the view(" << op.getRank()
<< ") to be the number of ranges(" << rank << ")"; << ") to be the number of ranges(" << rank << ")";
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TransposeOp // TransposeOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void mlir::linalg::TransposeOp::build(Builder *b, OperationState &result, void mlir::linalg::TransposeOp::build(OpBuilder &b, OperationState &result,
Value view, AffineMapAttr permutation, Value view, AffineMapAttr permutation,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
auto permutationMap = permutation.getValue(); auto permutationMap = permutation.getValue();
assert(permutationMap); assert(permutationMap);
auto memRefType = view.getType().cast<MemRefType>(); auto memRefType = view.getType().cast<MemRefType>();
auto rank = memRefType.getRank(); auto rank = memRefType.getRank();
auto originalSizes = memRefType.getShape(); auto originalSizes = memRefType.getShape();
// Compute permuted sizes. // Compute permuted sizes.
SmallVector<int64_t, 4> sizes(rank, 0); SmallVector<int64_t, 4> sizes(rank, 0);
for (auto en : llvm::enumerate(permutationMap.getResults())) for (auto en : llvm::enumerate(permutationMap.getResults()))
sizes[en.index()] = sizes[en.index()] =
originalSizes[en.value().cast<AffineDimExpr>().getPosition()]; originalSizes[en.value().cast<AffineDimExpr>().getPosition()];
// Compute permuted strides. // Compute permuted strides.
int64_t offset; int64_t offset;
SmallVector<int64_t, 4> strides; SmallVector<int64_t, 4> strides;
auto res = getStridesAndOffset(memRefType, strides, offset); auto res = getStridesAndOffset(memRefType, strides, offset);
assert(succeeded(res) && strides.size() == static_cast<unsigned>(rank)); assert(succeeded(res) && strides.size() == static_cast<unsigned>(rank));
(void)res; (void)res;
auto map = makeStridedLinearLayoutMap(strides, offset, b->getContext()); auto map = makeStridedLinearLayoutMap(strides, offset, b.getContext());
map = permutationMap ? map.compose(permutationMap) : map; map = permutationMap ? map.compose(permutationMap) : map;
// Compute result type. // Compute result type.
MemRefType resultType = MemRefType resultType =
MemRefType::Builder(memRefType).setShape(sizes).setAffineMaps(map); MemRefType::Builder(memRefType).setShape(sizes).setAffineMaps(map);
build(b, result, resultType, view, attrs); build(b, result, resultType, view, attrs);
result.addAttribute(TransposeOp::getPermutationAttrName(), permutation); result.addAttribute(TransposeOp::getPermutationAttrName(), permutation);
} }
▲ Show 20 Lines • Show All 440 Lines • Show Last 20 Lines

mlir/lib/Dialect/LoopOps/LoopOps.cpp

Show All 33 Lines
#include "mlir/Dialect/LoopOps/LoopOps.cpp.inc" #include "mlir/Dialect/LoopOps/LoopOps.cpp.inc"
>(); >();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ForOp // ForOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void ForOp::build(Builder *builder, OperationState &result, Value lb, Value ub, void ForOp::build(OpBuilder &builder, OperationState &result, Value lb,
Value step, ValueRange iterArgs) { Value ub, Value step, ValueRange iterArgs) {
result.addOperands({lb, ub, step}); result.addOperands({lb, ub, step});
result.addOperands(iterArgs); result.addOperands(iterArgs);
for (Value v : iterArgs) for (Value v : iterArgs)
result.addTypes(v.getType()); result.addTypes(v.getType());
Region *bodyRegion = result.addRegion(); Region *bodyRegion = result.addRegion();
bodyRegion->push_back(new Block()); bodyRegion->push_back(new Block());
if (iterArgs.empty()) if (iterArgs.empty())
ForOp::ensureTerminator(*bodyRegion, *builder, result.location); ForOp::ensureTerminator(*bodyRegion, builder, result.location);
bodyRegion->front().addArgument(builder->getIndexType()); bodyRegion->front().addArgument(builder.getIndexType());
for (Value v : iterArgs) for (Value v : iterArgs)
bodyRegion->front().addArgument(v.getType()); bodyRegion->front().addArgument(v.getType());
} }
static LogicalResult verify(ForOp op) { static LogicalResult verify(ForOp op) {
if (auto cst = dyn_cast_or_null<ConstantIndexOp>(op.step().getDefiningOp())) if (auto cst = dyn_cast_or_null<ConstantIndexOp>(op.step().getDefiningOp()))
if (cst.getValue() <= 0) if (cst.getValue() <= 0)
return op.emitOpError("constant step operand must be positive"); return op.emitOpError("constant step operand must be positive");
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Linesvoid ForOp::getSuccessorRegions(Optional<unsigned> index,
regions.push_back(RegionSuccessor(&getLoopBody(), getRegionIterArgs())); regions.push_back(RegionSuccessor(&getLoopBody(), getRegionIterArgs()));
regions.push_back(RegionSuccessor(getResults())); regions.push_back(RegionSuccessor(getResults()));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// IfOp // IfOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void IfOp::build(Builder *builder, OperationState &result, Value cond, void IfOp::build(OpBuilder &builder, OperationState &result, Value cond,
bool withElseRegion) { bool withElseRegion) {
build(builder, result, /*resultTypes=*/llvm::None, cond, withElseRegion); build(builder, result, /*resultTypes=*/llvm::None, cond, withElseRegion);
} }
void IfOp::build(Builder *builder, OperationState &result, void IfOp::build(OpBuilder &builder, OperationState &result,
TypeRange resultTypes, Value cond, bool withElseRegion) { TypeRange resultTypes, Value cond, bool withElseRegion) {
result.addOperands(cond); result.addOperands(cond);
result.addTypes(resultTypes); result.addTypes(resultTypes);
Region *thenRegion = result.addRegion(); Region *thenRegion = result.addRegion();
thenRegion->push_back(new Block()); thenRegion->push_back(new Block());
if (resultTypes.empty()) if (resultTypes.empty())
IfOp::ensureTerminator(*thenRegion, *builder, result.location); IfOp::ensureTerminator(*thenRegion, builder, result.location);
Region *elseRegion = result.addRegion(); Region *elseRegion = result.addRegion();
if (withElseRegion) { if (withElseRegion) {
elseRegion->push_back(new Block()); elseRegion->push_back(new Block());
if (resultTypes.empty()) if (resultTypes.empty())
IfOp::ensureTerminator(*elseRegion, *builder, result.location); IfOp::ensureTerminator(*elseRegion, builder, result.location);
} }
} }
static LogicalResult verify(IfOp op) { static LogicalResult verify(IfOp op) {
// Verify that the entry of each child region does not have arguments. // Verify that the entry of each child region does not have arguments.
for (auto &region : op.getOperation()->getRegions()) { for (auto &region : op.getOperation()->getRegions()) {
if (region.empty()) if (region.empty())
continue; continue;
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Linesvoid IfOp::getSuccessorRegions(Optional<unsigned> index,
// Add the successor regions using the condition. // Add the successor regions using the condition.
regions.push_back(RegionSuccessor(condition ? &thenRegion() : elseRegion)); regions.push_back(RegionSuccessor(condition ? &thenRegion() : elseRegion));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ParallelOp // ParallelOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void ParallelOp::build(Builder *builder, OperationState &result, ValueRange lbs, void ParallelOp::build(OpBuilder &builder, OperationState &result,
ValueRange ubs, ValueRange steps, ValueRange initVals) { ValueRange lbs, ValueRange ubs, ValueRange steps,
ValueRange initVals) {
result.addOperands(lbs); result.addOperands(lbs);
result.addOperands(ubs); result.addOperands(ubs);
result.addOperands(steps); result.addOperands(steps);
result.addOperands(initVals); result.addOperands(initVals);
result.addAttribute( result.addAttribute(
ParallelOp::getOperandSegmentSizeAttr(), ParallelOp::getOperandSegmentSizeAttr(),
builder->getI32VectorAttr({static_cast<int32_t>(lbs.size()), builder.getI32VectorAttr({static_cast<int32_t>(lbs.size()),
static_cast<int32_t>(ubs.size()), static_cast<int32_t>(ubs.size()),
static_cast<int32_t>(steps.size()), static_cast<int32_t>(steps.size()),
static_cast<int32_t>(initVals.size())})); static_cast<int32_t>(initVals.size())}));
Region *bodyRegion = result.addRegion(); Region *bodyRegion = result.addRegion();
ParallelOp::ensureTerminator(*bodyRegion, *builder, result.location); ParallelOp::ensureTerminator(*bodyRegion, builder, result.location);
for (size_t i = 0, e = steps.size(); i < e; ++i) for (size_t i = 0, e = steps.size(); i < e; ++i)
bodyRegion->front().addArgument(builder->getIndexType()); bodyRegion->front().addArgument(builder.getIndexType());
for (Value init : initVals) for (Value init : initVals)
result.addTypes(init.getType()); result.addTypes(init.getType());
} }
static LogicalResult verify(ParallelOp op) { static LogicalResult verify(ParallelOp op) {
// Check that there is at least one value in lowerBound, upperBound and step. // Check that there is at least one value in lowerBound, upperBound and step.
// It is sufficient to test only step, because it is ensured already that the // It is sufficient to test only step, because it is ensured already that the
// number of elements in lowerBound, upperBound and step are the same. // number of elements in lowerBound, upperBound and step are the same.
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 LinesParallelOp mlir::loop::getParallelForInductionVarOwner(Value val) {
auto *containingOp = ivArg.getOwner()->getParentOp(); auto *containingOp = ivArg.getOwner()->getParentOp();
return dyn_cast<ParallelOp>(containingOp); return dyn_cast<ParallelOp>(containingOp);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ReduceOp // ReduceOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void ReduceOp::build(Builder *builder, OperationState &result, Value operand) { void ReduceOp::build(OpBuilder &builder, OperationState &result,
Value operand) {
auto type = operand.getType(); auto type = operand.getType();
result.addOperands(operand); result.addOperands(operand);
Region *bodyRegion = result.addRegion(); Region *bodyRegion = result.addRegion();
Block *b = new Block(); Block *b = new Block();
b->addArguments(ArrayRef<Type>{type, type}); b->addArguments(ArrayRef<Type>{type, type});
bodyRegion->getBlocks().insert(bodyRegion->end(), b); bodyRegion->getBlocks().insert(bodyRegion->end(), b);
} }
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp

Show First 20 Lines • Show All 590 Lines • ▼ Show 20 Lines Value strideVal = builder.create<spirv::ConstantOp>(
loc, indexType, IntegerAttr::get(indexType, strides[index.index()])); loc, indexType, IntegerAttr::get(indexType, strides[index.index()]));
Value update = builder.create<spirv::IMulOp>(loc, strideVal, index.value()); Value update = builder.create<spirv::IMulOp>(loc, strideVal, index.value());
ptrLoc = ptrLoc =
(ptrLoc ? builder.create<spirv::IAddOp>(loc, ptrLoc, update).getResult() (ptrLoc ? builder.create<spirv::IAddOp>(loc, ptrLoc, update).getResult()
: update); : update);
} }
SmallVector<Value, 2> linearizedIndices; SmallVector<Value, 2> linearizedIndices;
// Add a '0' at the start to index into the struct. // Add a '0' at the start to index into the struct.
auto zero = spirv::ConstantOp::getZero(indexType, loc, &builder); auto zero = spirv::ConstantOp::getZero(indexType, loc, builder);
linearizedIndices.push_back(zero); linearizedIndices.push_back(zero);
// If it is a zero-rank memref type, extract the element directly. // If it is a zero-rank memref type, extract the element directly.
if (!ptrLoc) { if (!ptrLoc) {
ptrLoc = zero; ptrLoc = zero;
} }
linearizedIndices.push_back(ptrLoc); linearizedIndices.push_back(ptrLoc);
return builder.create<spirv::AccessChainOp>(loc, basePtr, linearizedIndices); return builder.create<spirv::AccessChainOp>(loc, basePtr, linearizedIndices);
} }
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

Show First 20 Lines • Show All 782 Lines • ▼ Show 20 Lines if (resultType.isa<spirv::StructType>()) {
return nullptr; return nullptr;
} }
} }
resultType = cType.getElementType(index); resultType = cType.getElementType(index);
} }
return spirv::PointerType::get(resultType, resultStorageClass); return spirv::PointerType::get(resultType, resultStorageClass);
} }
void spirv::AccessChainOp::build(Builder *builder, OperationState &state, void spirv::AccessChainOp::build(OpBuilder &builder, OperationState &state,
Value basePtr, ValueRange indices) { Value basePtr, ValueRange indices) {
auto type = getElementPtrType(basePtr.getType(), indices, state.location); auto type = getElementPtrType(basePtr.getType(), indices, state.location);
assert(type && "Unable to deduce return type based on basePtr and indices"); assert(type && "Unable to deduce return type based on basePtr and indices");
build(builder, state, type, basePtr, indices); build(builder, state, type, basePtr, indices);
} }
static ParseResult parseAccessChainOp(OpAsmParser &parser, static ParseResult parseAccessChainOp(OpAsmParser &parser,
OperationState &state) { OperationState &state) {
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Linesstatic LogicalResult verify(spirv::AccessChainOp accessChainOp) {
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv._address_of // spv._address_of
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void spirv::AddressOfOp::build(Builder *builder, OperationState &state, void spirv::AddressOfOp::build(OpBuilder &builder, OperationState &state,
spirv::GlobalVariableOp var) { spirv::GlobalVariableOp var) {
build(builder, state, var.type(), builder->getSymbolRefAttr(var)); build(builder, state, var.type(), builder.getSymbolRefAttr(var));
} }
static LogicalResult verify(spirv::AddressOfOp addressOfOp) { static LogicalResult verify(spirv::AddressOfOp addressOfOp) {
auto varOp = dyn_cast_or_null<spirv::GlobalVariableOp>( auto varOp = dyn_cast_or_null<spirv::GlobalVariableOp>(
SymbolTable::lookupNearestSymbolFrom(addressOfOp.getParentOp(), SymbolTable::lookupNearestSymbolFrom(addressOfOp.getParentOp(),
addressOfOp.variable())); addressOfOp.variable()));
if (!varOp) { if (!varOp) {
return addressOfOp.emitOpError("expected spv.globalVariable symbol"); return addressOfOp.emitOpError("expected spv.globalVariable symbol");
▲ Show 20 Lines • Show All 287 Lines • ▼ Show 20 Linesstatic LogicalResult verify(spirv::CompositeConstructOp compositeConstructOp) {
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.CompositeExtractOp // spv.CompositeExtractOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void spirv::CompositeExtractOp::build(Builder *builder, OperationState &state, void spirv::CompositeExtractOp::build(OpBuilder &builder, OperationState &state,
Value composite, Value composite,
ArrayRef<int32_t> indices) { ArrayRef<int32_t> indices) {
auto indexAttr = builder->getI32ArrayAttr(indices); auto indexAttr = builder.getI32ArrayAttr(indices);
auto elementType = auto elementType =
getElementType(composite.getType(), indexAttr, state.location); getElementType(composite.getType(), indexAttr, state.location);
if (!elementType) { if (!elementType) {
return; return;
} }
build(builder, state, elementType, composite, indexAttr); build(builder, state, elementType, composite, indexAttr);
} }
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Lines if (type.getKind() >= Type::FIRST_SPIRV_TYPE &&
// TODO(antiagainst): support constant struct // TODO(antiagainst): support constant struct
return type.isa<spirv::ArrayType>(); return type.isa<spirv::ArrayType>();
} }
return true; return true;
} }
spirv::ConstantOp spirv::ConstantOp::getZero(Type type, Location loc, spirv::ConstantOp spirv::ConstantOp::getZero(Type type, Location loc,
OpBuilder *builder) { OpBuilder &builder) {
if (auto intType = type.dyn_cast<IntegerType>()) { if (auto intType = type.dyn_cast<IntegerType>()) {
unsigned width = intType.getWidth(); unsigned width = intType.getWidth();
if (width == 1) if (width == 1)
return builder->create<spirv::ConstantOp>(loc, type, return builder.create<spirv::ConstantOp>(loc, type,
builder->getBoolAttr(false)); builder.getBoolAttr(false));
return builder->create<spirv::ConstantOp>( return builder.create<spirv::ConstantOp>(
loc, type, builder->getIntegerAttr(type, APInt(width, 0))); loc, type, builder.getIntegerAttr(type, APInt(width, 0)));
} }
llvm_unreachable("unimplemented types for ConstantOp::getZero()"); llvm_unreachable("unimplemented types for ConstantOp::getZero()");
} }
spirv::ConstantOp spirv::ConstantOp::getOne(Type type, Location loc, spirv::ConstantOp spirv::ConstantOp::getOne(Type type, Location loc,
OpBuilder *builder) { OpBuilder &builder) {
if (auto intType = type.dyn_cast<IntegerType>()) { if (auto intType = type.dyn_cast<IntegerType>()) {
unsigned width = intType.getWidth(); unsigned width = intType.getWidth();
if (width == 1) if (width == 1)
return builder->create<spirv::ConstantOp>(loc, type, return builder.create<spirv::ConstantOp>(loc, type,
builder->getBoolAttr(true)); builder.getBoolAttr(true));
return builder->create<spirv::ConstantOp>( return builder.create<spirv::ConstantOp>(
loc, type, builder->getIntegerAttr(type, APInt(width, 1))); loc, type, builder.getIntegerAttr(type, APInt(width, 1)));
} }
llvm_unreachable("unimplemented types for ConstantOp::getOne()"); llvm_unreachable("unimplemented types for ConstantOp::getOne()");
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.EntryPoint // spv.EntryPoint
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void spirv::EntryPointOp::build(Builder *builder, OperationState &state, void spirv::EntryPointOp::build(OpBuilder &builder, OperationState &state,
spirv::ExecutionModel executionModel, spirv::ExecutionModel executionModel,
spirv::FuncOp function, spirv::FuncOp function,
ArrayRef<Attribute> interfaceVars) { ArrayRef<Attribute> interfaceVars) {
build(builder, state, build(builder, state,
builder->getI32IntegerAttr(static_cast<int32_t>(executionModel)), builder.getI32IntegerAttr(static_cast<int32_t>(executionModel)),
builder->getSymbolRefAttr(function), builder.getSymbolRefAttr(function),
builder->getArrayAttr(interfaceVars)); builder.getArrayAttr(interfaceVars));
} }
static ParseResult parseEntryPointOp(OpAsmParser &parser, static ParseResult parseEntryPointOp(OpAsmParser &parser,
OperationState &state) { OperationState &state) {
spirv::ExecutionModel execModel; spirv::ExecutionModel execModel;
SmallVector<OpAsmParser::OperandType, 0> identifiers; SmallVector<OpAsmParser::OperandType, 0> identifiers;
SmallVector<Type, 0> idTypes; SmallVector<Type, 0> idTypes;
SmallVector<Attribute, 4> interfaceVars; SmallVector<Attribute, 4> interfaceVars;
Show All 38 Linesstatic LogicalResult verify(spirv::EntryPointOp entryPointOp) {
// verification. // verification.
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ExecutionMode // spv.ExecutionMode
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void spirv::ExecutionModeOp::build(Builder *builder, OperationState &state, void spirv::ExecutionModeOp::build(OpBuilder &builder, OperationState &state,
spirv::FuncOp function, spirv::FuncOp function,
spirv::ExecutionMode executionMode, spirv::ExecutionMode executionMode,
ArrayRef<int32_t> params) { ArrayRef<int32_t> params) {
build(builder, state, builder->getSymbolRefAttr(function), build(builder, state, builder.getSymbolRefAttr(function),
builder->getI32IntegerAttr(static_cast<int32_t>(executionMode)), builder.getI32IntegerAttr(static_cast<int32_t>(executionMode)),
builder->getI32ArrayAttr(params)); builder.getI32ArrayAttr(params));
} }
static ParseResult parseExecutionModeOp(OpAsmParser &parser, static ParseResult parseExecutionModeOp(OpAsmParser &parser,
OperationState &state) { OperationState &state) {
spirv::ExecutionMode execMode; spirv::ExecutionMode execMode;
Attribute fn; Attribute fn;
if (parser.parseAttribute(fn, kFnNameAttrName, state.attributes) || if (parser.parseAttribute(fn, kFnNameAttrName, state.attributes) ||
parseEnumStrAttr(execMode, parser, state)) { parseEnumStrAttr(execMode, parser, state)) {
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines auto walkResult = walk([fnType](Operation *op) -> WalkResult {
return WalkResult::advance(); return WalkResult::advance();
}); });
// TODO(antiagainst): verify other bits like linkage type. // TODO(antiagainst): verify other bits like linkage type.
return failure(walkResult.wasInterrupted()); return failure(walkResult.wasInterrupted());
} }
void spirv::FuncOp::build(Builder *builder, OperationState &state, void spirv::FuncOp::build(OpBuilder &builder, OperationState &state,
StringRef name, FunctionType type, StringRef name, FunctionType type,
spirv::FunctionControl control, spirv::FunctionControl control,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
state.addAttribute(SymbolTable::getSymbolAttrName(), state.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name)); builder.getStringAttr(name));
state.addAttribute(getTypeAttrName(), TypeAttr::get(type)); state.addAttribute(getTypeAttrName(), TypeAttr::get(type));
state.addAttribute( state.addAttribute(spirv::attributeName<spirv::FunctionControl>(),
spirv::attributeName<spirv::FunctionControl>(), builder.getI32IntegerAttr(static_cast<uint32_t>(control)));
builder->getI32IntegerAttr(static_cast<uint32_t>(control)));
state.attributes.append(attrs.begin(), attrs.end()); state.attributes.append(attrs.begin(), attrs.end());
state.addRegion(); state.addRegion();
} }
// CallableOpInterface // CallableOpInterface
Region *spirv::FuncOp::getCallableRegion() { Region *spirv::FuncOp::getCallableRegion() {
return isExternal() ? nullptr : &body(); return isExternal() ? nullptr : &body();
} }
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
Operation::operand_range spirv::FunctionCallOp::getArgOperands() { Operation::operand_range spirv::FunctionCallOp::getArgOperands() {
return arguments(); return arguments();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.globalVariable // spv.globalVariable
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void spirv::GlobalVariableOp::build(Builder *builder, OperationState &state, void spirv::GlobalVariableOp::build(OpBuilder &builder, OperationState &state,
Type type, StringRef name, Type type, StringRef name,
unsigned descriptorSet, unsigned binding) { unsigned descriptorSet, unsigned binding) {
build(builder, state, TypeAttr::get(type), builder->getStringAttr(name), build(builder, state, TypeAttr::get(type), builder.getStringAttr(name),
nullptr); nullptr);
state.addAttribute( state.addAttribute(
spirv::SPIRVDialect::getAttributeName(spirv::Decoration::DescriptorSet), spirv::SPIRVDialect::getAttributeName(spirv::Decoration::DescriptorSet),
builder->getI32IntegerAttr(descriptorSet)); builder.getI32IntegerAttr(descriptorSet));
state.addAttribute( state.addAttribute(
spirv::SPIRVDialect::getAttributeName(spirv::Decoration::Binding), spirv::SPIRVDialect::getAttributeName(spirv::Decoration::Binding),
builder->getI32IntegerAttr(binding)); builder.getI32IntegerAttr(binding));
} }
void spirv::GlobalVariableOp::build(Builder *builder, OperationState &state, void spirv::GlobalVariableOp::build(OpBuilder &builder, OperationState &state,
Type type, StringRef name, Type type, StringRef name,
spirv::BuiltIn builtin) { spirv::BuiltIn builtin) {
build(builder, state, TypeAttr::get(type), builder->getStringAttr(name), build(builder, state, TypeAttr::get(type), builder.getStringAttr(name),
nullptr); nullptr);
state.addAttribute( state.addAttribute(
spirv::SPIRVDialect::getAttributeName(spirv::Decoration::BuiltIn), spirv::SPIRVDialect::getAttributeName(spirv::Decoration::BuiltIn),
builder->getStringAttr(spirv::stringifyBuiltIn(builtin))); builder.getStringAttr(spirv::stringifyBuiltIn(builtin)));
} }
static ParseResult parseGlobalVariableOp(OpAsmParser &parser, static ParseResult parseGlobalVariableOp(OpAsmParser &parser,
OperationState &state) { OperationState &state) {
// Parse variable name. // Parse variable name.
StringAttr nameAttr; StringAttr nameAttr;
if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(), if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
state.attributes)) { state.attributes)) {
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Linesstatic LogicalResult verify(spirv::GroupNonUniformBallotOp ballotOp) {
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformElectOp // spv.GroupNonUniformElectOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void spirv::GroupNonUniformElectOp::build(Builder *builder, void spirv::GroupNonUniformElectOp::build(OpBuilder &builder,
OperationState &state, OperationState &state,
spirv::Scope scope) { spirv::Scope scope) {
build(builder, state, builder->getI1Type(), scope); build(builder, state, builder.getI1Type(), scope);
} }
static LogicalResult verify(spirv::GroupNonUniformElectOp groupOp) { static LogicalResult verify(spirv::GroupNonUniformElectOp groupOp) {
spirv::Scope scope = groupOp.execution_scope(); spirv::Scope scope = groupOp.execution_scope();
if (scope != spirv::Scope::Workgroup && scope != spirv::Scope::Subgroup) if (scope != spirv::Scope::Workgroup && scope != spirv::Scope::Subgroup)
return groupOp.emitOpError( return groupOp.emitOpError(
"execution scope must be 'Workgroup' or 'Subgroup'"); "execution scope must be 'Workgroup' or 'Subgroup'");
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LoadOp // spv.LoadOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void spirv::LoadOp::build(Builder *builder, OperationState &state, void spirv::LoadOp::build(OpBuilder &builder, OperationState &state,
Value basePtr, IntegerAttr memory_access, Value basePtr, IntegerAttr memory_access,
IntegerAttr alignment) { IntegerAttr alignment) {
auto ptrType = basePtr.getType().cast<spirv::PointerType>(); auto ptrType = basePtr.getType().cast<spirv::PointerType>();
build(builder, state, ptrType.getPointeeType(), basePtr, memory_access, build(builder, state, ptrType.getPointeeType(), basePtr, memory_access,
alignment); alignment);
} }
static ParseResult parseLoadOp(OpAsmParser &parser, OperationState &state) { static ParseResult parseLoadOp(OpAsmParser &parser, OperationState &state) {
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesstatic LogicalResult verify(spirv::LoadOp loadOp) {
} }
return verifyMemoryAccessAttribute(loadOp); return verifyMemoryAccessAttribute(loadOp);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.loop // spv.loop
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void spirv::LoopOp::build(Builder *builder, OperationState &state) { void spirv::LoopOp::build(OpBuilder &builder, OperationState &state) {
state.addAttribute("loop_control", state.addAttribute("loop_control",
builder->getI32IntegerAttr( builder.getI32IntegerAttr(
static_cast<uint32_t>(spirv::LoopControl::None))); static_cast<uint32_t>(spirv::LoopControl::None)));
state.addRegion(); state.addRegion();
} }
static ParseResult parseLoopOp(OpAsmParser &parser, OperationState &state) { static ParseResult parseLoopOp(OpAsmParser &parser, OperationState &state) {
// TODO(antiagainst): support loop control properly // TODO(antiagainst): support loop control properly
Builder builder = parser.getBuilder(); Builder builder = parser.getBuilder();
state.addAttribute("loop_control", state.addAttribute("loop_control",
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Lines return mergeOp.emitOpError(
"can only be used in the last block of 'spv.selection' or 'spv.loop'"); "can only be used in the last block of 'spv.selection' or 'spv.loop'");
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.module // spv.module
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void spirv::ModuleOp::build(Builder *builder, OperationState &state) { void spirv::ModuleOp::build(OpBuilder &builder, OperationState &state) {
ensureTerminator(*state.addRegion(), *builder, state.location); ensureTerminator(*state.addRegion(), builder, state.location);
} }
void spirv::ModuleOp::build(Builder *builder, OperationState &state, void spirv::ModuleOp::build(OpBuilder &builder, OperationState &state,
spirv::AddressingModel addressing_model, spirv::AddressingModel addressing_model,
spirv::MemoryModel memory_model) { spirv::MemoryModel memory_model) {
state.addAttribute( state.addAttribute(
"addressing_model", "addressing_model",
builder->getI32IntegerAttr(static_cast<int32_t>(addressing_model))); builder.getI32IntegerAttr(static_cast<int32_t>(addressing_model)));
state.addAttribute("memory_model", builder->getI32IntegerAttr( state.addAttribute("memory_model", builder.getI32IntegerAttr(
static_cast<int32_t>(memory_model))); static_cast<int32_t>(memory_model)));
ensureTerminator(*state.addRegion(), *builder, state.location); ensureTerminator(*state.addRegion(), builder, state.location);
} }
static ParseResult parseModuleOp(OpAsmParser &parser, OperationState &state) { static ParseResult parseModuleOp(OpAsmParser &parser, OperationState &state) {
Region *body = state.addRegion(); Region *body = state.addRegion();
// Parse attributes // Parse attributes
spirv::AddressingModel addrModel; spirv::AddressingModel addrModel;
spirv::MemoryModel memoryModel; spirv::MemoryModel memoryModel;
▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Linesstatic LogicalResult verify(spirv::ReturnValueOp retValOp) {
// Verification is performed in spv.func op. // Verification is performed in spv.func op.
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Select // spv.Select
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void spirv::SelectOp::build(Builder *builder, OperationState &state, Value cond, void spirv::SelectOp::build(OpBuilder &builder, OperationState &state,
Value trueValue, Value falseValue) { Value cond, Value trueValue, Value falseValue) {
build(builder, state, trueValue.getType(), cond, trueValue, falseValue); build(builder, state, trueValue.getType(), cond, trueValue, falseValue);
} }
static LogicalResult verify(spirv::SelectOp op) { static LogicalResult verify(spirv::SelectOp op) {
if (auto conditionTy = op.condition().getType().dyn_cast<VectorType>()) { if (auto conditionTy = op.condition().getType().dyn_cast<VectorType>()) {
auto resultVectorTy = op.result().getType().dyn_cast<VectorType>(); auto resultVectorTy = op.result().getType().dyn_cast<VectorType>();
if (!resultVectorTy) { if (!resultVectorTy) {
return op.emitOpError("result expected to be of vector type when " return op.emitOpError("result expected to be of vector type when "
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Linesvoid spirv::SelectionOp::addMergeBlock() {
OpBuilder builder = OpBuilder::atBlockEnd(mergeBlock); OpBuilder builder = OpBuilder::atBlockEnd(mergeBlock);
// Add a spv._merge op into the merge block. // Add a spv._merge op into the merge block.
builder.create<spirv::MergeOp>(getLoc()); builder.create<spirv::MergeOp>(getLoc());
} }
spirv::SelectionOp spirv::SelectionOp::createIfThen( spirv::SelectionOp spirv::SelectionOp::createIfThen(
Location loc, Value condition, Location loc, Value condition,
function_ref<void(OpBuilder *builder)> thenBody, OpBuilder *builder) { function_ref<void(OpBuilder &builder)> thenBody, OpBuilder &builder) {
auto selectionControl = builder->getI32IntegerAttr( auto selectionControl = builder.getI32IntegerAttr(
static_cast<uint32_t>(spirv::SelectionControl::None)); static_cast<uint32_t>(spirv::SelectionControl::None));
auto selectionOp = builder->create<spirv::SelectionOp>(loc, selectionControl); auto selectionOp = builder.create<spirv::SelectionOp>(loc, selectionControl);
selectionOp.addMergeBlock(); selectionOp.addMergeBlock();
Block *mergeBlock = selectionOp.getMergeBlock(); Block *mergeBlock = selectionOp.getMergeBlock();
Block *thenBlock = nullptr; Block *thenBlock = nullptr;
// Build the "then" block. // Build the "then" block.
{ {
OpBuilder::InsertionGuard guard(*builder); OpBuilder::InsertionGuard guard(builder);
thenBlock = builder->createBlock(mergeBlock); thenBlock = builder.createBlock(mergeBlock);
thenBody(builder); thenBody(builder);
builder->create<spirv::BranchOp>(loc, mergeBlock); builder.create<spirv::BranchOp>(loc, mergeBlock);
} }
// Build the header block. // Build the header block.
{ {
OpBuilder::InsertionGuard guard(*builder); OpBuilder::InsertionGuard guard(builder);
builder->createBlock(thenBlock); builder.createBlock(thenBlock);
builder->create<spirv::BranchConditionalOp>( builder.create<spirv::BranchConditionalOp>(
loc, condition, thenBlock, loc, condition, thenBlock,
/*trueArguments=*/ArrayRef<Value>(), mergeBlock, /*trueArguments=*/ArrayRef<Value>(), mergeBlock,
/*falseArguments=*/ArrayRef<Value>()); /*falseArguments=*/ArrayRef<Value>());
} }
return selectionOp; return selectionOp;
} }
▲ Show 20 Lines • Show All 246 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp

Show First 20 Lines • Show All 515 Lines • ▼ Show 20 Lines
Optional<spirv::ModuleOp> Deserializer::collect() { return module; } Optional<spirv::ModuleOp> Deserializer::collect() { return module; }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Module structure // Module structure
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spirv::ModuleOp Deserializer::createModuleOp() { spirv::ModuleOp Deserializer::createModuleOp() {
Builder builder(context); OpBuilder builder(context);
OperationState state(unknownLoc, spirv::ModuleOp::getOperationName()); OperationState state(unknownLoc, spirv::ModuleOp::getOperationName());
spirv::ModuleOp::build(&builder, state); spirv::ModuleOp::build(builder, state);
return cast<spirv::ModuleOp>(Operation::create(state)); return cast<spirv::ModuleOp>(Operation::create(state));
} }
LogicalResult Deserializer::processHeader() { LogicalResult Deserializer::processHeader() {
if (binary.size() < spirv::kHeaderWordCount) if (binary.size() < spirv::kHeaderWordCount)
return emitError(unknownLoc, return emitError(unknownLoc,
"SPIR-V binary module must have a 5-word header"); "SPIR-V binary module must have a 5-word header");
▲ Show 20 Lines • Show All 1,826 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines for (auto argType : llvm::enumerate(funcOp.getType().getInputs())) {
// needs to be loaded into registers. // needs to be loaded into registers.
// TODO(ravishankarm) : This is loading value of the scalar into registers // TODO(ravishankarm) : This is loading value of the scalar into registers
// at the start of the function. It is probably better to do the load just // at the start of the function. It is probably better to do the load just
// before the use. There might be multiple loads and currently there is no // before the use. There might be multiple loads and currently there is no
// easy way to replace all uses with a sequence of operations. // easy way to replace all uses with a sequence of operations.
if (argType.value().cast<spirv::SPIRVType>().isScalarOrVector()) { if (argType.value().cast<spirv::SPIRVType>().isScalarOrVector()) {
auto indexType = SPIRVTypeConverter::getIndexType(funcOp.getContext()); auto indexType = SPIRVTypeConverter::getIndexType(funcOp.getContext());
auto zero = auto zero =
spirv::ConstantOp::getZero(indexType, funcOp.getLoc(), &rewriter); spirv::ConstantOp::getZero(indexType, funcOp.getLoc(), rewriter);
auto loadPtr = rewriter.create<spirv::AccessChainOp>( auto loadPtr = rewriter.create<spirv::AccessChainOp>(
funcOp.getLoc(), replacement, zero.constant()); funcOp.getLoc(), replacement, zero.constant());
replacement = rewriter.create<spirv::LoadOp>(funcOp.getLoc(), loadPtr); replacement = rewriter.create<spirv::LoadOp>(funcOp.getLoc(), loadPtr);
} }
signatureConverter.remapInput(argType.index(), replacement); signatureConverter.remapInput(argType.index(), replacement);
} }
// Creates a new function with the update signature. // Creates a new function with the update signature.
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

Show First 20 Lines • Show All 478 Lines • ▼ Show 20 Linesstatic LogicalResult verify(AtomicRMWOp op) {
} }
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// GenericAtomicRMWOp // GenericAtomicRMWOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void GenericAtomicRMWOp::build(Builder *builder, OperationState &result, void GenericAtomicRMWOp::build(OpBuilder &builder, OperationState &result,
Value memref, ValueRange ivs) { Value memref, ValueRange ivs) {
result.addOperands(memref); result.addOperands(memref);
result.addOperands(ivs); result.addOperands(ivs);
if (auto memrefType = memref.getType().dyn_cast<MemRefType>()) { if (auto memrefType = memref.getType().dyn_cast<MemRefType>()) {
Type elementType = memrefType.getElementType(); Type elementType = memrefType.getElementType();
result.addTypes(elementType); result.addTypes(elementType);
▲ Show 20 Lines • Show All 274 Lines • ▼ Show 20 Lines if (auto vectorType = type.dyn_cast<VectorType>())
return VectorType::get(vectorType.getShape(), i1Type); return VectorType::get(vectorType.getShape(), i1Type);
return i1Type; return i1Type;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CmpIOp // CmpIOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static void buildCmpIOp(Builder *build, OperationState &result, static void buildCmpIOp(OpBuilder &build, OperationState &result,
CmpIPredicate predicate, Value lhs, Value rhs) { CmpIPredicate predicate, Value lhs, Value rhs) {
result.addOperands({lhs, rhs}); result.addOperands({lhs, rhs});
result.types.push_back(getI1SameShape(lhs.getType())); result.types.push_back(getI1SameShape(lhs.getType()));
result.addAttribute( result.addAttribute(CmpIOp::getPredicateAttrName(),
CmpIOp::getPredicateAttrName(), build.getI64IntegerAttr(static_cast<int64_t>(predicate)));
build->getI64IntegerAttr(static_cast<int64_t>(predicate)));
} }
// Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer // Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer
// comparison predicates. // comparison predicates.
static bool applyCmpPredicate(CmpIPredicate predicate, const APInt &lhs, static bool applyCmpPredicate(CmpIPredicate predicate, const APInt &lhs,
const APInt &rhs) { const APInt &rhs) {
switch (predicate) { switch (predicate) {
case CmpIPredicate::eq: case CmpIPredicate::eq:
Show All 32 LinesOpFoldResult CmpIOp::fold(ArrayRef<Attribute> operands) {
auto val = applyCmpPredicate(getPredicate(), lhs.getValue(), rhs.getValue()); auto val = applyCmpPredicate(getPredicate(), lhs.getValue(), rhs.getValue());
return IntegerAttr::get(IntegerType::get(1, getContext()), APInt(1, val)); return IntegerAttr::get(IntegerType::get(1, getContext()), APInt(1, val));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CmpFOp // CmpFOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static void buildCmpFOp(Builder *build, OperationState &result, static void buildCmpFOp(OpBuilder &build, OperationState &result,
CmpFPredicate predicate, Value lhs, Value rhs) { CmpFPredicate predicate, Value lhs, Value rhs) {
result.addOperands({lhs, rhs}); result.addOperands({lhs, rhs});
result.types.push_back(getI1SameShape(lhs.getType())); result.types.push_back(getI1SameShape(lhs.getType()));
result.addAttribute( result.addAttribute(CmpFOp::getPredicateAttrName(),
CmpFOp::getPredicateAttrName(), build.getI64IntegerAttr(static_cast<int64_t>(predicate)));
build->getI64IntegerAttr(static_cast<int64_t>(predicate)));
} }
/// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point
/// comparison predicates. /// comparison predicates.
static bool applyCmpPredicate(CmpFPredicate predicate, const APFloat &lhs, static bool applyCmpPredicate(CmpFPredicate predicate, const APFloat &lhs,
const APFloat &rhs) { const APFloat &rhs) {
auto cmpResult = lhs.compare(rhs); auto cmpResult = lhs.compare(rhs);
switch (predicate) { switch (predicate) {
▲ Show 20 Lines • Show All 327 Lines • ▼ Show 20 Linesbool ConstantOp::isBuildableWith(Attribute value, Type type) {
if (value.getType() != type) if (value.getType() != type)
return false; return false;
// Finally, check that the attribute kind is handled. // Finally, check that the attribute kind is handled.
return value.isa<BoolAttr>() || value.isa<IntegerAttr>() || return value.isa<BoolAttr>() || value.isa<IntegerAttr>() ||
value.isa<FloatAttr>() || value.isa<ElementsAttr>() || value.isa<FloatAttr>() || value.isa<ElementsAttr>() ||
value.isa<UnitAttr>(); value.isa<UnitAttr>();
} }
void ConstantFloatOp::build(Builder *builder, OperationState &result, void ConstantFloatOp::build(OpBuilder &builder, OperationState &result,
const APFloat &value, FloatType type) { const APFloat &value, FloatType type) {
ConstantOp::build(builder, result, type, builder->getFloatAttr(type, value)); ConstantOp::build(builder, result, type, builder.getFloatAttr(type, value));
} }
bool ConstantFloatOp::classof(Operation *op) { bool ConstantFloatOp::classof(Operation *op) {
return ConstantOp::classof(op) && op->getResult(0).getType().isa<FloatType>(); return ConstantOp::classof(op) && op->getResult(0).getType().isa<FloatType>();
} }
/// ConstantIntOp only matches values whose result type is an IntegerType. /// ConstantIntOp only matches values whose result type is an IntegerType.
bool ConstantIntOp::classof(Operation *op) { bool ConstantIntOp::classof(Operation *op) {
return ConstantOp::classof(op) && return ConstantOp::classof(op) &&
op->getResult(0).getType().isSignlessInteger(); op->getResult(0).getType().isSignlessInteger();
} }
void ConstantIntOp::build(Builder *builder, OperationState &result, void ConstantIntOp::build(OpBuilder &builder, OperationState &result,
int64_t value, unsigned width) { int64_t value, unsigned width) {
Type type = builder->getIntegerType(width); Type type = builder.getIntegerType(width);
ConstantOp::build(builder, result, type, ConstantOp::build(builder, result, type, builder.getIntegerAttr(type, value));
builder->getIntegerAttr(type, value));
} }
/// Build a constant int op producing an integer with the specified type, /// Build a constant int op producing an integer with the specified type,
/// which must be an integer type. /// which must be an integer type.
void ConstantIntOp::build(Builder *builder, OperationState &result, void ConstantIntOp::build(OpBuilder &builder, OperationState &result,
int64_t value, Type type) { int64_t value, Type type) {
assert(type.isSignlessInteger() && assert(type.isSignlessInteger() &&
"ConstantIntOp can only have signless integer type"); "ConstantIntOp can only have signless integer type");
ConstantOp::build(builder, result, type, ConstantOp::build(builder, result, type, builder.getIntegerAttr(type, value));
builder->getIntegerAttr(type, value));
} }
/// ConstantIndexOp only matches values whose result type is Index. /// ConstantIndexOp only matches values whose result type is Index.
bool ConstantIndexOp::classof(Operation *op) { bool ConstantIndexOp::classof(Operation *op) {
return ConstantOp::classof(op) && op->getResult(0).getType().isIndex(); return ConstantOp::classof(op) && op->getResult(0).getType().isIndex();
} }
void ConstantIndexOp::build(Builder *builder, OperationState &result, void ConstantIndexOp::build(OpBuilder &builder, OperationState &result,
int64_t value) { int64_t value) {
Type type = builder->getIndexType(); Type type = builder.getIndexType();
ConstantOp::build(builder, result, type, ConstantOp::build(builder, result, type, builder.getIntegerAttr(type, value));
builder->getIntegerAttr(type, value));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// DeallocOp // DeallocOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace { namespace {
/// Fold Dealloc operations that are deallocating an AllocOp that is only used /// Fold Dealloc operations that are deallocating an AllocOp that is only used
/// by other Dealloc operations. /// by other Dealloc operations.
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 LinesOpFoldResult DimOp::fold(ArrayRef<Attribute> operands) {
return {}; return {};
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// DmaStartOp // DmaStartOp
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
void DmaStartOp::build(Builder *builder, OperationState &result, void DmaStartOp::build(OpBuilder &builder, OperationState &result,
Value srcMemRef, ValueRange srcIndices, Value destMemRef, Value srcMemRef, ValueRange srcIndices, Value destMemRef,
ValueRange destIndices, Value numElements, ValueRange destIndices, Value numElements,
Value tagMemRef, ValueRange tagIndices, Value stride, Value tagMemRef, ValueRange tagIndices, Value stride,
Value elementsPerStride) { Value elementsPerStride) {
result.addOperands(srcMemRef); result.addOperands(srcMemRef);
result.addOperands(srcIndices); result.addOperands(srcIndices);
result.addOperands(destMemRef); result.addOperands(destMemRef);
result.addOperands(destIndices); result.addOperands(destIndices);
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 LinesLogicalResult DmaStartOp::fold(ArrayRef<Attribute> cstOperands,
/// dma_start(memrefcast) -> dma_start /// dma_start(memrefcast) -> dma_start
return foldMemRefCast(*this); return foldMemRefCast(*this);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// DmaWaitOp // DmaWaitOp
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
void DmaWaitOp::build(Builder *builder, OperationState &result, Value tagMemRef, void DmaWaitOp::build(OpBuilder &builder, OperationState &result,
ValueRange tagIndices, Value numElements) { Value tagMemRef, ValueRange tagIndices,
Value numElements) {
result.addOperands(tagMemRef); result.addOperands(tagMemRef);
result.addOperands(tagIndices); result.addOperands(tagIndices);
result.addOperands(numElements); result.addOperands(numElements);
} }
void DmaWaitOp::print(OpAsmPrinter &p) { void DmaWaitOp::print(OpAsmPrinter &p) {
p << "dma_wait " << getTagMemRef() << '[' << getTagIndices() << "], " p << "dma_wait " << getTagMemRef() << '[' << getTagIndices() << "], "
<< getNumElements(); << getNumElements();
▲ Show 20 Lines • Show All 623 Lines • ▼ Show 20 Linesstatic Type inferSubViewResultType(MemRefType memRefType) {
auto stridedLayout = auto stridedLayout =
makeStridedLinearLayoutMap(strides, offset, memRefType.getContext()); makeStridedLinearLayoutMap(strides, offset, memRefType.getContext());
SmallVector<int64_t, 4> sizes(rank, ShapedType::kDynamicSize); SmallVector<int64_t, 4> sizes(rank, ShapedType::kDynamicSize);
return MemRefType::Builder(memRefType) return MemRefType::Builder(memRefType)
.setShape(sizes) .setShape(sizes)
.setAffineMaps(stridedLayout); .setAffineMaps(stridedLayout);
} }
void mlir::SubViewOp::build(Builder *b, OperationState &result, Value source, void mlir::SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
ValueRange offsets, ValueRange sizes, ValueRange offsets, ValueRange sizes,
ValueRange strides, Type resultType, ValueRange strides, Type resultType,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
if (!resultType) if (!resultType)
resultType = inferSubViewResultType(source.getType().cast<MemRefType>()); resultType = inferSubViewResultType(source.getType().cast<MemRefType>());
build(b, result, resultType, source, offsets, sizes, strides); build(b, result, resultType, source, offsets, sizes, strides);
result.addAttributes(attrs); result.addAttributes(attrs);
} }
void mlir::SubViewOp::build(Builder *b, OperationState &result, Type resultType, void mlir::SubViewOp::build(OpBuilder &b, OperationState &result,
Value source) { Type resultType, Value source) {
build(b, result, source, /*offsets=*/{}, /*sizes=*/{}, /*strides=*/{}, build(b, result, source, /*offsets=*/{}, /*sizes=*/{}, /*strides=*/{},
resultType); resultType);
} }
static LogicalResult verify(SubViewOp op) { static LogicalResult verify(SubViewOp op) {
auto baseType = op.getBaseMemRefType().cast<MemRefType>(); auto baseType = op.getBaseMemRefType().cast<MemRefType>();
auto subViewType = op.getType(); auto subViewType = op.getType();
▲ Show 20 Lines • Show All 678 Lines • Show Last 20 Lines

mlir/lib/Dialect/Vector/VectorOps.cpp

Show First 20 Lines • Show All 120 Lines • ▼ Show 20 Lines if (!op.acc().empty())
p << ", " << op.acc(); p << ", " << op.acc();
p << " : " << op.vector().getType() << " into " << op.dest().getType(); p << " : " << op.vector().getType() << " into " << op.dest().getType();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ContractionOp // ContractionOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void vector::ContractionOp::build(Builder *builder, OperationState &result, void vector::ContractionOp::build(OpBuilder &builder, OperationState &result,
Value lhs, Value rhs, Value acc, Value lhs, Value rhs, Value acc,
ArrayRef<ArrayRef<AffineExpr>> indexingExprs, ArrayRef<ArrayRef<AffineExpr>> indexingExprs,
ArrayRef<StringRef> iteratorTypes) { ArrayRef<StringRef> iteratorTypes) {
result.addOperands({lhs, rhs, acc}); result.addOperands({lhs, rhs, acc});
result.addTypes(acc.getType()); result.addTypes(acc.getType());
result.addAttribute(getIndexingMapsAttrName(), result.addAttribute(getIndexingMapsAttrName(),
builder->getAffineMapArrayAttr( builder.getAffineMapArrayAttr(
AffineMap::inferFromExprList(indexingExprs))); AffineMap::inferFromExprList(indexingExprs)));
result.addAttribute(getIteratorTypesAttrName(), result.addAttribute(getIteratorTypesAttrName(),
builder->getStrArrayAttr(iteratorTypes)); builder.getStrArrayAttr(iteratorTypes));
} }
void vector::ContractionOp::build(Builder *builder, OperationState &result, void vector::ContractionOp::build(OpBuilder &builder, OperationState &result,
Value lhs, Value rhs, Value acc, Value lhs, Value rhs, Value acc,
ArrayAttr indexingMaps, ArrayAttr indexingMaps,
ArrayAttr iteratorTypes) { ArrayAttr iteratorTypes) {
result.addOperands({lhs, rhs, acc}); result.addOperands({lhs, rhs, acc});
result.addTypes(acc.getType()); result.addTypes(acc.getType());
result.addAttribute(getIndexingMapsAttrName(), indexingMaps); result.addAttribute(getIndexingMapsAttrName(), indexingMaps);
result.addAttribute(getIteratorTypesAttrName(), iteratorTypes); result.addAttribute(getIteratorTypesAttrName(), iteratorTypes);
} }
▲ Show 20 Lines • Show All 305 Lines • ▼ Show 20 Lines
static Type inferExtractOpResultType(VectorType vectorType, static Type inferExtractOpResultType(VectorType vectorType,
ArrayAttr position) { ArrayAttr position) {
if (static_cast<int64_t>(position.size()) == vectorType.getRank()) if (static_cast<int64_t>(position.size()) == vectorType.getRank())
return vectorType.getElementType(); return vectorType.getElementType();
return VectorType::get(vectorType.getShape().drop_front(position.size()), return VectorType::get(vectorType.getShape().drop_front(position.size()),
vectorType.getElementType()); vectorType.getElementType());
} }
void vector::ExtractOp::build(Builder *builder, OperationState &result, void vector::ExtractOp::build(OpBuilder &builder, OperationState &result,
Value source, ArrayRef<int64_t> position) { Value source, ArrayRef<int64_t> position) {
result.addOperands(source); result.addOperands(source);
auto positionAttr = getVectorSubscriptAttr(*builder, position); auto positionAttr = getVectorSubscriptAttr(builder, position);
result.addTypes(inferExtractOpResultType(source.getType().cast<VectorType>(), result.addTypes(inferExtractOpResultType(source.getType().cast<VectorType>(),
positionAttr)); positionAttr));
result.addAttribute(getPositionAttrName(), positionAttr); result.addAttribute(getPositionAttrName(), positionAttr);
} }
static void print(OpAsmPrinter &p, vector::ExtractOp op) { static void print(OpAsmPrinter &p, vector::ExtractOp op) {
p << op.getOperationName() << " " << op.vector() << op.position(); p << op.getOperationName() << " " << op.vector() << op.position();
p.printOptionalAttrDict(op.getAttrs(), {"position"}); p.printOptionalAttrDict(op.getAttrs(), {"position"});
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesstatic LogicalResult verify(vector::ExtractOp op) {
} }
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ExtractSlicesOp // ExtractSlicesOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void ExtractSlicesOp::build(Builder *builder, OperationState &result, void ExtractSlicesOp::build(OpBuilder &builder, OperationState &result,
TupleType tupleType, Value vector, TupleType tupleType, Value vector,
ArrayRef<int64_t> sizes, ArrayRef<int64_t> sizes,
ArrayRef<int64_t> strides) { ArrayRef<int64_t> strides) {
result.addOperands(vector); result.addOperands(vector);
auto sizesAttr = getVectorSubscriptAttr(*builder, sizes); auto sizesAttr = getVectorSubscriptAttr(builder, sizes);
auto stridesAttr = getVectorSubscriptAttr(*builder, strides); auto stridesAttr = getVectorSubscriptAttr(builder, strides);
result.addTypes(tupleType); result.addTypes(tupleType);
result.addAttribute(getSizesAttrName(), sizesAttr); result.addAttribute(getSizesAttrName(), sizesAttr);
result.addAttribute(getStridesAttrName(), stridesAttr); result.addAttribute(getStridesAttrName(), stridesAttr);
} }
static LogicalResult static LogicalResult
isValidExtractOrInsertSlicesType(Operation *op, VectorType vectorType, isValidExtractOrInsertSlicesType(Operation *op, VectorType vectorType,
TupleType tupleType, ArrayRef<int64_t> sizes, TupleType tupleType, ArrayRef<int64_t> sizes,
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Linesstatic LogicalResult verify(BroadcastOp op) {
} }
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ShuffleOp // ShuffleOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void ShuffleOp::build(Builder *builder, OperationState &result, Value v1, void ShuffleOp::build(OpBuilder &builder, OperationState &result, Value v1,
Value v2, ArrayRef<int64_t> mask) { Value v2, ArrayRef<int64_t> mask) {
result.addOperands({v1, v2}); result.addOperands({v1, v2});
auto maskAttr = getVectorSubscriptAttr(*builder, mask); auto maskAttr = getVectorSubscriptAttr(builder, mask);
result.addTypes(v1.getType()); result.addTypes(v1.getType());
result.addAttribute(getMaskAttrName(), maskAttr); result.addAttribute(getMaskAttrName(), maskAttr);
} }
static void print(OpAsmPrinter &p, ShuffleOp op) { static void print(OpAsmPrinter &p, ShuffleOp op) {
p << op.getOperationName() << " " << op.v1() << ", " << op.v2() << " " p << op.getOperationName() << " " << op.v1() << ", " << op.v2() << " "
<< op.mask(); << op.mask();
p.printOptionalAttrDict(op.getAttrs(), {ShuffleOp::getMaskAttrName()}); p.printOptionalAttrDict(op.getAttrs(), {ShuffleOp::getMaskAttrName()});
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines if (dstVectorType.getRank() != 1)
return op.emitOpError("expected 1-D vector"); return op.emitOpError("expected 1-D vector");
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// InsertOp // InsertOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void InsertOp::build(Builder *builder, OperationState &result, Value source, void InsertOp::build(OpBuilder &builder, OperationState &result, Value source,
Value dest, ArrayRef<int64_t> position) { Value dest, ArrayRef<int64_t> position) {
result.addOperands({source, dest}); result.addOperands({source, dest});
auto positionAttr = getVectorSubscriptAttr(*builder, position); auto positionAttr = getVectorSubscriptAttr(builder, position);
result.addTypes(dest.getType()); result.addTypes(dest.getType());
result.addAttribute(getPositionAttrName(), positionAttr); result.addAttribute(getPositionAttrName(), positionAttr);
} }
static LogicalResult verify(InsertOp op) { static LogicalResult verify(InsertOp op) {
auto positionAttr = op.position().getValue(); auto positionAttr = op.position().getValue();
if (positionAttr.empty()) if (positionAttr.empty())
return op.emitOpError("expected non-empty position attribute"); return op.emitOpError("expected non-empty position attribute");
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
void InsertSlicesOp::getStrides(SmallVectorImpl<int64_t> &results) { void InsertSlicesOp::getStrides(SmallVectorImpl<int64_t> &results) {
populateFromInt64AttrArray(strides(), results); populateFromInt64AttrArray(strides(), results);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// InsertStridedSliceOp // InsertStridedSliceOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void InsertStridedSliceOp::build(Builder *builder, OperationState &result, void InsertStridedSliceOp::build(OpBuilder &builder, OperationState &result,
Value source, Value dest, Value source, Value dest,
ArrayRef<int64_t> offsets, ArrayRef<int64_t> offsets,
ArrayRef<int64_t> strides) { ArrayRef<int64_t> strides) {
result.addOperands({source, dest}); result.addOperands({source, dest});
auto offsetsAttr = getVectorSubscriptAttr(*builder, offsets); auto offsetsAttr = getVectorSubscriptAttr(builder, offsets);
auto stridesAttr = getVectorSubscriptAttr(*builder, strides); auto stridesAttr = getVectorSubscriptAttr(builder, strides);
result.addTypes(dest.getType()); result.addTypes(dest.getType());
result.addAttribute(getOffsetsAttrName(), offsetsAttr); result.addAttribute(getOffsetsAttrName(), offsetsAttr);
result.addAttribute(getStridesAttrName(), stridesAttr); result.addAttribute(getStridesAttrName(), stridesAttr);
} }
// TODO(ntv) Should be moved to Tablegen Confined attributes. // TODO(ntv) Should be moved to Tablegen Confined attributes.
template <typename OpType> template <typename OpType>
static LogicalResult isIntegerArrayAttrSmallerThanShape(OpType op, static LogicalResult isIntegerArrayAttrSmallerThanShape(OpType op,
▲ Show 20 Lines • Show All 256 Lines • ▼ Show 20 Linesstatic Type inferStridedSliceOpResultType(VectorType vectorType,
for (unsigned e = offsets.size(); idx < e; ++idx) for (unsigned e = offsets.size(); idx < e; ++idx)
shape.push_back(sizes[idx].cast<IntegerAttr>().getInt()); shape.push_back(sizes[idx].cast<IntegerAttr>().getInt());
for (unsigned e = vectorType.getShape().size(); idx < e; ++idx) for (unsigned e = vectorType.getShape().size(); idx < e; ++idx)
shape.push_back(vectorType.getShape()[idx]); shape.push_back(vectorType.getShape()[idx]);
return VectorType::get(shape, vectorType.getElementType()); return VectorType::get(shape, vectorType.getElementType());
} }
void StridedSliceOp::build(Builder *builder, OperationState &result, void StridedSliceOp::build(OpBuilder &builder, OperationState &result,
Value source, ArrayRef<int64_t> offsets, Value source, ArrayRef<int64_t> offsets,
ArrayRef<int64_t> sizes, ArrayRef<int64_t> strides) { ArrayRef<int64_t> sizes, ArrayRef<int64_t> strides) {
result.addOperands(source); result.addOperands(source);
auto offsetsAttr = getVectorSubscriptAttr(*builder, offsets); auto offsetsAttr = getVectorSubscriptAttr(builder, offsets);
auto sizesAttr = getVectorSubscriptAttr(*builder, sizes); auto sizesAttr = getVectorSubscriptAttr(builder, sizes);
auto stridesAttr = getVectorSubscriptAttr(*builder, strides); auto stridesAttr = getVectorSubscriptAttr(builder, strides);
result.addTypes( result.addTypes(
inferStridedSliceOpResultType(source.getType().cast<VectorType>(), inferStridedSliceOpResultType(source.getType().cast<VectorType>(),
offsetsAttr, sizesAttr, stridesAttr)); offsetsAttr, sizesAttr, stridesAttr));
result.addAttribute(getOffsetsAttrName(), offsetsAttr); result.addAttribute(getOffsetsAttrName(), offsetsAttr);
result.addAttribute(getSizesAttrName(), sizesAttr); result.addAttribute(getSizesAttrName(), sizesAttr);
result.addAttribute(getStridesAttrName(), stridesAttr); result.addAttribute(getStridesAttrName(), stridesAttr);
} }
▲ Show 20 Lines • Show All 369 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TypeCastOp // TypeCastOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static MemRefType inferVectorTypeCastResultType(MemRefType t) { static MemRefType inferVectorTypeCastResultType(MemRefType t) {
return MemRefType::get({}, VectorType::get(t.getShape(), t.getElementType())); return MemRefType::get({}, VectorType::get(t.getShape(), t.getElementType()));
} }
void TypeCastOp::build(Builder *builder, OperationState &result, Value source) { void TypeCastOp::build(OpBuilder &builder, OperationState &result,
Value source) {
result.addOperands(source); result.addOperands(source);
result.addTypes( result.addTypes(
inferVectorTypeCastResultType(source.getType().cast<MemRefType>())); inferVectorTypeCastResultType(source.getType().cast<MemRefType>()));
} }
static void print(OpAsmPrinter &p, TypeCastOp op) { static void print(OpAsmPrinter &p, TypeCastOp op) {
auto type = op.getOperand().getType().cast<MemRefType>(); auto type = op.getOperand().getType().cast<MemRefType>();
p << op.getOperationName() << ' ' << op.memref() << " : " << type << " to " p << op.getOperationName() << ' ' << op.memref() << " : " << type << " to "
▲ Show 20 Lines • Show All 286 Lines • Show Last 20 Lines

mlir/lib/IR/Function.cpp

Show All 18 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Function Operation. // Function Operation.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type, FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs) { ArrayRef<NamedAttribute> attrs) {
OperationState state(location, "func"); OperationState state(location, "func");
Builder builder(location->getContext()); OpBuilder builder(location->getContext());
FuncOp::build(&builder, state, name, type, attrs); FuncOp::build(builder, state, name, type, attrs);
return cast<FuncOp>(Operation::create(state)); return cast<FuncOp>(Operation::create(state));
} }
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type, FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
iterator_range<dialect_attr_iterator> attrs) { iterator_range<dialect_attr_iterator> attrs) {
SmallVector<NamedAttribute, 8> attrRef(attrs); SmallVector<NamedAttribute, 8> attrRef(attrs);
return create(location, name, type, llvm::makeArrayRef(attrRef)); return create(location, name, type, llvm::makeArrayRef(attrRef));
} }
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type, FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs, ArrayRef<NamedAttribute> attrs,
ArrayRef<NamedAttributeList> argAttrs) { ArrayRef<NamedAttributeList> argAttrs) {
FuncOp func = create(location, name, type, attrs); FuncOp func = create(location, name, type, attrs);
func.setAllArgAttrs(argAttrs); func.setAllArgAttrs(argAttrs);
return func; return func;
} }
void FuncOp::build(Builder *builder, OperationState &result, StringRef name, void FuncOp::build(OpBuilder &builder, OperationState &result, StringRef name,
FunctionType type, ArrayRef<NamedAttribute> attrs) { FunctionType type, ArrayRef<NamedAttribute> attrs) {
result.addAttribute(SymbolTable::getSymbolAttrName(), result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name)); builder.getStringAttr(name));
result.addAttribute(getTypeAttrName(), TypeAttr::get(type)); result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
result.attributes.append(attrs.begin(), attrs.end()); result.attributes.append(attrs.begin(), attrs.end());
result.addRegion(); result.addRegion();
} }
void FuncOp::build(Builder *builder, OperationState &result, StringRef name, void FuncOp::build(OpBuilder &builder, OperationState &result, StringRef name,
FunctionType type, ArrayRef<NamedAttribute> attrs, FunctionType type, ArrayRef<NamedAttribute> attrs,
ArrayRef<NamedAttributeList> argAttrs) { ArrayRef<NamedAttributeList> argAttrs) {
build(builder, result, name, type, attrs); build(builder, result, name, type, attrs);
assert(type.getNumInputs() == argAttrs.size()); assert(type.getNumInputs() == argAttrs.size());
SmallString<8> argAttrName; SmallString<8> argAttrName;
for (unsigned i = 0, e = type.getNumInputs(); i != e; ++i) for (unsigned i = 0, e = type.getNumInputs(); i != e; ++i)
if (auto argDict = argAttrs[i].getDictionary()) if (auto argDict = argAttrs[i].getDictionary())
result.addAttribute(getArgAttrName(i, argAttrName), argDict); result.addAttribute(getArgAttrName(i, argAttrName), argDict);
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

mlir/lib/IR/Module.cpp

Show All 10 Lines
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
using namespace mlir; using namespace mlir;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Module Operation. // Module Operation.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void ModuleOp::build(Builder *builder, OperationState &result, void ModuleOp::build(OpBuilder &builder, OperationState &result,
Optional<StringRef> name) { Optional<StringRef> name) {
ensureTerminator(*result.addRegion(), *builder, result.location); ensureTerminator(*result.addRegion(), builder, result.location);
if (name) if (name)
result.attributes.push_back(builder->getNamedAttr( result.attributes.push_back(builder.getNamedAttr(
mlir::SymbolTable::getSymbolAttrName(), builder->getStringAttr(*name))); mlir::SymbolTable::getSymbolAttrName(), builder.getStringAttr(*name)));
} }
/// Construct a module from the given context. /// Construct a module from the given context.
ModuleOp ModuleOp::create(Location loc, Optional<StringRef> name) { ModuleOp ModuleOp::create(Location loc, Optional<StringRef> name) {
OperationState state(loc, "module"); OperationState state(loc, "module");
Builder builder(loc->getContext()); OpBuilder builder(loc->getContext());
ModuleOp::build(&builder, state, name); ModuleOp::build(builder, state, name);
return cast<ModuleOp>(Operation::create(state)); return cast<ModuleOp>(Operation::create(state));
} }
ParseResult ModuleOp::parse(OpAsmParser &parser, OperationState &result) { ParseResult ModuleOp::parse(OpAsmParser &parser, OperationState &result) {
// If the name is present, parse it. // If the name is present, parse it.
StringAttr nameAttr; StringAttr nameAttr;
(void)parser.parseOptionalSymbolName( (void)parser.parseOptionalSymbolName(
nameAttr, mlir::SymbolTable::getSymbolAttrName(), result.attributes); nameAttr, mlir::SymbolTable::getSymbolAttrName(), result.attributes);
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

mlir/lib/IR/Operation.cpp

Show First 20 Lines • Show All 974 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// BinaryOp implementation // BinaryOp implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// These functions are out-of-line implementations of the methods in BinaryOp, // These functions are out-of-line implementations of the methods in BinaryOp,
// which avoids them being template instantiated/duplicated. // which avoids them being template instantiated/duplicated.
void impl::buildBinaryOp(Builder *builder, OperationState &result, Value lhs, void impl::buildBinaryOp(OpBuilder &builder, OperationState &result, Value lhs,
Value rhs) { Value rhs) {
assert(lhs.getType() == rhs.getType()); assert(lhs.getType() == rhs.getType());
result.addOperands({lhs, rhs}); result.addOperands({lhs, rhs});
result.types.push_back(lhs.getType()); result.types.push_back(lhs.getType());
} }
ParseResult impl::parseOneResultSameOperandTypeOp(OpAsmParser &parser, ParseResult impl::parseOneResultSameOperandTypeOp(OpAsmParser &parser,
OperationState &result) { OperationState &result) {
Show All 24 Linesvoid impl::printOneResultOp(Operation *op, OpAsmPrinter &p) {
// Now we can output only one type for all operands and the result. // Now we can output only one type for all operands and the result.
p << " : " << resultType; p << " : " << resultType;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CastOp implementation // CastOp implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
void impl::buildCastOp(Builder *builder, OperationState &result, Value source, void impl::buildCastOp(OpBuilder &builder, OperationState &result, Value source,
Type destType) { Type destType) {
result.addOperands(source); result.addOperands(source);
result.addTypes(destType); result.addTypes(destType);
} }
ParseResult impl::parseCastOp(OpAsmParser &parser, OperationState &result) { ParseResult impl::parseCastOp(OpAsmParser &parser, OperationState &result) {
OpAsmParser::OperandType srcInfo; OpAsmParser::OperandType srcInfo;
Type srcType, dstType; Type srcType, dstType;
Show All 24 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Insert an operation, generated by `buildTerminatorOp`, at the end of the /// Insert an operation, generated by `buildTerminatorOp`, at the end of the
/// region's only block if it does not have a terminator already. If the region /// region's only block if it does not have a terminator already. If the region
/// is empty, insert a new block first. `buildTerminatorOp` should return the /// is empty, insert a new block first. `buildTerminatorOp` should return the
/// terminator operation to insert. /// terminator operation to insert.
void impl::ensureRegionTerminator( void impl::ensureRegionTerminator(
Region &region, Location loc, Region &region, Location loc,
function_ref<Operation *()> buildTerminatorOp) { function_ref<Operation *(OpBuilder &)> buildTerminatorOp) {
if (region.empty()) if (region.empty())
region.push_back(new Block); region.push_back(new Block);
Block &block = region.back(); Block &block = region.back();
if (!block.empty() && block.back().isKnownTerminator()) if (!block.empty() && block.back().isKnownTerminator())
return; return;
block.push_back(buildTerminatorOp()); OpBuilder builder(loc.getContext());
block.push_back(buildTerminatorOp(builder));
} }

mlir/test/lib/Dialect/Test/TestOps.td

Show First 20 Lines • Show All 725 Lines • ▼ Show 20 Linesdef OpSymbolBindingA : TEST_Op<"symbol_binding_a", []> {
let results = (outs I32); let results = (outs I32);
} }
def OpSymbolBindingB : TEST_Op<"symbol_binding_b", []> { def OpSymbolBindingB : TEST_Op<"symbol_binding_b", []> {
let arguments = (ins I32:$operand); let arguments = (ins I32:$operand);
let results = (outs I32); let results = (outs I32);
let builders = [ let builders = [
OpBuilder< OpBuilder<
"Builder *builder, OperationState &state, Value operand", "OpBuilder &builder, OperationState &state, Value operand",
[{ [{
state.types.assign({builder->getIntegerType(32)}); state.types.assign({builder.getIntegerType(32)});
state.addOperands({operand}); state.addOperands({operand});
}]> }]>
]; ];
} }
def OpSymbolBindingC : TEST_Op<"symbol_binding_c", []> { def OpSymbolBindingC : TEST_Op<"symbol_binding_c", []> {
let arguments = (ins I32:$operand); let arguments = (ins I32:$operand);
let results = (outs I32); let results = (outs I32);
let builders = OpSymbolBindingB.builders; let builders = OpSymbolBindingB.builders;
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
} }
def TwoResultOp : TEST_Op<"two_result"> { def TwoResultOp : TEST_Op<"two_result"> {
let arguments = (ins MultiResultOpEnum:$kind); let arguments = (ins MultiResultOpEnum:$kind);
let results = (outs I32:$result1, F32:$result2); let results = (outs I32:$result1, F32:$result2);
let builders = [ let builders = [
OpBuilder< OpBuilder<
"Builder *builder, OperationState &state, IntegerAttr kind", "OpBuilder &builder, OperationState &state, IntegerAttr kind",
[{ [{
auto i32 = builder->getIntegerType(32); auto i32 = builder.getIntegerType(32);
auto f32 = builder->getF32Type(); auto f32 = builder.getF32Type();
state.types.assign({i32, f32}); state.types.assign({i32, f32});
state.addAttribute("kind", kind); state.addAttribute("kind", kind);
}]> }]>
]; ];
} }
def AnotherTwoResultOp : TEST_Op<"another_two_result"> { def AnotherTwoResultOp : TEST_Op<"another_two_result"> {
let arguments = (ins MultiResultOpEnum:$kind); let arguments = (ins MultiResultOpEnum:$kind);
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Lines let results = (outs
Variadic<I32>:$output2, Variadic<I32>:$output2,
Variadic<I32>:$output3 Variadic<I32>:$output3
); );
// We will use this op in a nested result pattern, where we cannot deduce the // We will use this op in a nested result pattern, where we cannot deduce the
// result type. So need to provide a builder not requiring result types. // result type. So need to provide a builder not requiring result types.
let builders = [ let builders = [
OpBuilder< OpBuilder<
"Builder *builder, OperationState &state, IntegerAttr count", "OpBuilder &builder, OperationState &state, IntegerAttr count",
[{ [{
auto i32Type = builder->getIntegerType(32); auto i32Type = builder.getIntegerType(32);
state.addTypes(i32Type); // $output1 state.addTypes(i32Type); // $output1
SmallVector<Type, 4> types(count.getInt(), i32Type); SmallVector<Type, 4> types(count.getInt(), i32Type);
state.addTypes(types); // $output2 state.addTypes(types); // $output2
state.addTypes(types); // $output3 state.addTypes(types); // $output3
state.addAttribute("count", count); state.addAttribute("count", count);
}]> }]>
]; ];
} }
▲ Show 20 Lines • Show All 251 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/Test/TestPatterns.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines for (int i = 0, e = fop.getNumArguments(); i < e; ++i) {
for (int j = 0; j < e; ++j) { for (int j = 0; j < e; ++j) {
std::array<Value, 2> values = {{fop.getArgument(i), fop.getArgument(j)}}; std::array<Value, 2> values = {{fop.getArgument(i), fop.getArgument(j)}};
SmallVector<Type, 2> inferredReturnTypes; SmallVector<Type, 2> inferredReturnTypes;
if (succeeded(OpTy::inferReturnTypes(context, llvm::None, values, if (succeeded(OpTy::inferReturnTypes(context, llvm::None, values,
op->getAttrs(), op->getRegions(), op->getAttrs(), op->getRegions(),
inferredReturnTypes))) { inferredReturnTypes))) {
OperationState state(location, OpTy::getOperationName()); OperationState state(location, OpTy::getOperationName());
// TODO(jpienaar): Expand to regions. // TODO(jpienaar): Expand to regions.
OpTy::build(&b, state, values, op->getAttrs()); OpTy::build(b, state, values, op->getAttrs());
(void)b.createOperation(state); (void)b.createOperation(state);
} }
} }
} }
} }
static void reifyReturnShape(Operation *op) { static void reifyReturnShape(Operation *op) {
OpBuilder b(op); OpBuilder b(op);
▲ Show 20 Lines • Show All 538 Lines • Show Last 20 Lines

mlir/test/mlir-tblgen/op-attribute.td

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
// DEF: void AOp::build( // DEF: void AOp::build(
// DEF: odsState.addAttribute("aAttr", aAttr); // DEF: odsState.addAttribute("aAttr", aAttr);
// DEF: odsState.addAttribute("bAttr", bAttr); // DEF: odsState.addAttribute("bAttr", bAttr);
// DEF: if (cAttr) { // DEF: if (cAttr) {
// DEF-NEXT: odsState.addAttribute("cAttr", cAttr); // DEF-NEXT: odsState.addAttribute("cAttr", cAttr);
// DEF: void AOp::build( // DEF: void AOp::build(
// DEF: some-return-type aAttr, some-return-type bAttr, /*optional*/some-attr-kind cAttr // DEF: some-return-type aAttr, some-return-type bAttr, /*optional*/some-attr-kind cAttr
// DEF: odsState.addAttribute("aAttr", some-const-builder-call((*odsBuilder), aAttr)); // DEF: odsState.addAttribute("aAttr", some-const-builder-call(odsBuilder, aAttr));
// DEF: void AOp::build( // DEF: void AOp::build(
// DEF: ArrayRef<NamedAttribute> attributes // DEF: ArrayRef<NamedAttribute> attributes
// DEF: odsState.addAttributes(attributes); // DEF: odsState.addAttributes(attributes);
// Test verify method // Test verify method
// --- // ---
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines let arguments = (ins
DefaultValuedAttr<SomeI32Enum, "::SomeI32Enum::case5">:$dv_enum_attr DefaultValuedAttr<SomeI32Enum, "::SomeI32Enum::case5">:$dv_enum_attr
); );
} }
// DECL-LABEL: DOp declarations // DECL-LABEL: DOp declarations
// DECL: static void build({{.*}}, APInt i32_attr, APFloat f64_attr, StringRef str_attr, bool bool_attr, ::SomeI32Enum enum_attr, APInt dv_i32_attr, APFloat dv_f64_attr, StringRef dv_str_attr = "abc", bool dv_bool_attr = true, ::SomeI32Enum dv_enum_attr = ::SomeI32Enum::case5) // DECL: static void build({{.*}}, APInt i32_attr, APFloat f64_attr, StringRef str_attr, bool bool_attr, ::SomeI32Enum enum_attr, APInt dv_i32_attr, APFloat dv_f64_attr, StringRef dv_str_attr = "abc", bool dv_bool_attr = true, ::SomeI32Enum dv_enum_attr = ::SomeI32Enum::case5)
// DEF-LABEL: DOp definitions // DEF-LABEL: DOp definitions
// DEF: odsState.addAttribute("str_attr", (*odsBuilder).getStringAttr(str_attr)); // DEF: odsState.addAttribute("str_attr", odsBuilder.getStringAttr(str_attr));
// DEF: odsState.addAttribute("dv_str_attr", (*odsBuilder).getStringAttr(dv_str_attr)); // DEF: odsState.addAttribute("dv_str_attr", odsBuilder.getStringAttr(dv_str_attr));
// Test derived type attr. // Test derived type attr.
// --- // ---
def DerivedTypeAttrOp : NS_Op<"derived_type_attr_op", []> { def DerivedTypeAttrOp : NS_Op<"derived_type_attr_op", []> {
let results = (outs AnyTensor:$output); let results = (outs AnyTensor:$output);
DerivedTypeAttr element_dtype = DerivedTypeAttr<"return output().getType();">; DerivedTypeAttr element_dtype = DerivedTypeAttr<"return output().getType();">;
} }
Show All 33 Lines
def MixOperandsAndAttrs : NS_Op<"mix_operands_and_attrs", []> { def MixOperandsAndAttrs : NS_Op<"mix_operands_and_attrs", []> {
let arguments = (ins F32Attr:$attr, F32:$operand, F32Attr:$otherAttr, F32:$otherArg); let arguments = (ins F32Attr:$attr, F32:$operand, F32Attr:$otherAttr, F32:$otherArg);
} }
// DEF-LABEL: MixOperandsAndAttrs definitions // DEF-LABEL: MixOperandsAndAttrs definitions
// DEF-DAG: Value MixOperandsAndAttrs::operand() // DEF-DAG: Value MixOperandsAndAttrs::operand()
// DEF-DAG: Value MixOperandsAndAttrs::otherArg() // DEF-DAG: Value MixOperandsAndAttrs::otherArg()
// DEF-DAG: void MixOperandsAndAttrs::build(Builder *odsBuilder, OperationState &odsState, FloatAttr attr, Value operand, FloatAttr otherAttr, Value otherArg) // DEF-DAG: void MixOperandsAndAttrs::build(OpBuilder &odsBuilder, OperationState &odsState, FloatAttr attr, Value operand, FloatAttr otherAttr, Value otherArg)
// DEF-DAG: APFloat MixOperandsAndAttrs::attr() // DEF-DAG: APFloat MixOperandsAndAttrs::attr()
// DEF-DAG: APFloat MixOperandsAndAttrs::otherAttr() // DEF-DAG: APFloat MixOperandsAndAttrs::otherAttr()
// Test unit attributes. // Test unit attributes.
// --- // ---
def UnitAttrOp : NS_Op<"unit_attr_op", []> { def UnitAttrOp : NS_Op<"unit_attr_op", []> {
let arguments = (ins UnitAttr:$attr); let arguments = (ins UnitAttr:$attr);
} }
// DEF-LABEL: UnitAttrOp definitions // DEF-LABEL: UnitAttrOp definitions
// DEF: bool UnitAttrOp::attr() { // DEF: bool UnitAttrOp::attr() {
// DEF: return {{.*}} != nullptr // DEF: return {{.*}} != nullptr
// DEF: build(Builder *odsBuilder, OperationState &odsState, /*optional*/UnitAttr attr) // DEF: build(OpBuilder &odsBuilder, OperationState &odsState, /*optional*/UnitAttr attr)
// Test elementAttr field of TypedArrayAttr. // Test elementAttr field of TypedArrayAttr.
// --- // ---
def SomeTypedArrayAttr : TypedArrayAttrBase<SomeAttr, "SomeAttr array">; def SomeTypedArrayAttr : TypedArrayAttrBase<SomeAttr, "SomeAttr array">;
// RECORD-LABEL: def SomeTypedArrayAttr // RECORD-LABEL: def SomeTypedArrayAttr
// RECORD: Attr elementAttr = SomeAttr; // RECORD: Attr elementAttr = SomeAttr;

mlir/test/mlir-tblgen/op-decl.td

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
// CHECK: Value r(); // CHECK: Value r();
// CHECK: Region &someRegion(); // CHECK: Region &someRegion();
// CHECK: MutableArrayRef<Region> someRegions(); // CHECK: MutableArrayRef<Region> someRegions();
// CHECK: IntegerAttr attr1Attr() // CHECK: IntegerAttr attr1Attr()
// CHECK: APInt attr1(); // CHECK: APInt attr1();
// CHECK: FloatAttr attr2Attr() // CHECK: FloatAttr attr2Attr()
// CHECK: Optional< APFloat > attr2(); // CHECK: Optional< APFloat > attr2();
// CHECK: static void build(Value val); // CHECK: static void build(Value val);
// CHECK: static void build(Builder *odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, IntegerAttr attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount) // CHECK: static void build(OpBuilder &odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, IntegerAttr attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount)
// CHECK: static void build(Builder *odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, APInt attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount) // CHECK: static void build(OpBuilder &odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, APInt attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount)
// CHECK: static void build(Builder *, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes, unsigned numRegions) // CHECK: static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes, unsigned numRegions)
// CHECK: static ParseResult parse(OpAsmParser &parser, OperationState &result); // CHECK: static ParseResult parse(OpAsmParser &parser, OperationState &result);
// CHECK: void print(OpAsmPrinter &p); // CHECK: void print(OpAsmPrinter &p);
// CHECK: LogicalResult verify(); // CHECK: LogicalResult verify();
// CHECK: static void getCanonicalizationPatterns(OwningRewritePatternList &results, MLIRContext *context); // CHECK: static void getCanonicalizationPatterns(OwningRewritePatternList &results, MLIRContext *context);
// CHECK: LogicalResult fold(ArrayRef<Attribute> operands, SmallVectorImpl<OpFoldResult> &results); // CHECK: LogicalResult fold(ArrayRef<Attribute> operands, SmallVectorImpl<OpFoldResult> &results);
// CHECK: // Display a graph for debugging purposes. // CHECK: // Display a graph for debugging purposes.
// CHECK: void displayGraph(); // CHECK: void displayGraph();
// CHECK: }; // CHECK: };
Show All 25 Lines
def NS_EOp : NS_Op<"op_with_optionals", []> { def NS_EOp : NS_Op<"op_with_optionals", []> {
let arguments = (ins Optional<I32>:$a); let arguments = (ins Optional<I32>:$a);
let results = (outs Optional<F32>:$b); let results = (outs Optional<F32>:$b);
} }
// CHECK-LABEL: NS::EOp declarations // CHECK-LABEL: NS::EOp declarations
// CHECK: Value a(); // CHECK: Value a();
// CHECK: Value b(); // CHECK: Value b();
// CHECK: static void build(Builder *odsBuilder, OperationState &odsState, /*optional*/Type b, /*optional*/Value a) // CHECK: static void build(OpBuilder &odsBuilder, OperationState &odsState, /*optional*/Type b, /*optional*/Value a)
// Check that default builders can be suppressed. // Check that default builders can be suppressed.
// --- // ---
def NS_SkipDefaultBuildersOp : NS_Op<"skip_default_builders", []> { def NS_SkipDefaultBuildersOp : NS_Op<"skip_default_builders", []> {
let skipDefaultBuilders = 1; let skipDefaultBuilders = 1;
let builders = [OpBuilder<"Value val">]; let builders = [OpBuilder<"Value val">];
} }
Show All 18 Lines

mlir/test/mlir-tblgen/op-operand.td

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
// Check that resizable operand list flag is set up correctly in all generated // Check that resizable operand list flag is set up correctly in all generated
// builders and in the parser. // builders and in the parser.
def OpE : NS_Op<"resizable_operand_list", [ResizableOperandList]> { def OpE : NS_Op<"resizable_operand_list", [ResizableOperandList]> {
let arguments = (ins Variadic<AnyType>:$input); let arguments = (ins Variadic<AnyType>:$input);
let assemblyFormat = "$input attr-dict `:` type($input)"; let assemblyFormat = "$input attr-dict `:` type($input)";
} }
// CHECK-LABEL: OpE::build(Builder *odsBuilder, OperationState &odsState, ValueRange // CHECK-LABEL: OpE::build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange
// CHECK: odsState.setOperandListToResizable() // CHECK: odsState.setOperandListToResizable()
// CHECK-LABEL: OpE::build(Builder *odsBuilder, OperationState &odsState, ArrayRef<Type> // CHECK-LABEL: OpE::build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type>
// CHECK: odsState.setOperandListToResizable() // CHECK: odsState.setOperandListToResizable()
// CHECK-LABEL: OpE::build(Builder *, OperationState // CHECK-LABEL: OpE::build(OpBuilder &, OperationState
// CHECK: odsState.setOperandListToResizable() // CHECK: odsState.setOperandListToResizable()
// CHECK-LABEL: OpE::parse // CHECK-LABEL: OpE::parse
// CHECK: result.setOperandListToResizable() // CHECK: result.setOperandListToResizable()

mlir/test/mlir-tblgen/op-result.td

Show All 17 Lines
// CHECK-NEXT: odsState.addTypes(resultTypes); // CHECK-NEXT: odsState.addTypes(resultTypes);
def OpB : NS_Op<"same_input_output_type_op", [SameOperandsAndResultType]> { def OpB : NS_Op<"same_input_output_type_op", [SameOperandsAndResultType]> {
let arguments = (ins I32:$x); let arguments = (ins I32:$x);
let results = (outs I32:$y); let results = (outs I32:$y);
} }
// CHECK-LABEL: OpB definitions // CHECK-LABEL: OpB definitions
// CHECK: void OpB::build(Builder *odsBuilder, OperationState &odsState, Type y, Value x) // CHECK: void OpB::build(OpBuilder &odsBuilder, OperationState &odsState, Type y, Value x)
// CHECK: odsState.addTypes(y); // CHECK: odsState.addTypes(y);
// CHECK: void OpB::build(Builder *odsBuilder, OperationState &odsState, Value x) // CHECK: void OpB::build(OpBuilder &odsBuilder, OperationState &odsState, Value x)
// CHECK: odsState.addTypes({x.getType()}); // CHECK: odsState.addTypes({x.getType()});
def OpC : NS_Op<"three_normal_result_op", []> { def OpC : NS_Op<"three_normal_result_op", []> {
let results = (outs I32:$x, /*unnamed*/I32, I32:$z); let results = (outs I32:$x, /*unnamed*/I32, I32:$z);
} }
// CHECK-LABEL: OpC definitions // CHECK-LABEL: OpC definitions
// CHECK: void OpC::build(Builder *odsBuilder, OperationState &odsState, Type x, Type resultType1, Type z) // CHECK: void OpC::build(OpBuilder &odsBuilder, OperationState &odsState, Type x, Type resultType1, Type z)
// CHECK-NEXT: odsState.addTypes(x) // CHECK-NEXT: odsState.addTypes(x)
// CHECK-NEXT: odsState.addTypes(resultType1) // CHECK-NEXT: odsState.addTypes(resultType1)
// CHECK-NEXT: odsState.addTypes(z) // CHECK-NEXT: odsState.addTypes(z)
// CHECK: void OpC::build(Builder *odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes) { // CHECK: void OpC::build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes) {
// CHECK-NEXT: assert(resultTypes.size() == 3u && "mismatched number of results"); // CHECK-NEXT: assert(resultTypes.size() == 3u && "mismatched number of results");
// CHECK-NEXT: odsState.addTypes(resultTypes); // CHECK-NEXT: odsState.addTypes(resultTypes);
def IntegerTypeAttr : TypeAttrBase<"IntegerType", "Integer type attribute">; def IntegerTypeAttr : TypeAttrBase<"IntegerType", "Integer type attribute">;
def OpD : NS_Op<"type_attr_as_result_type", [FirstAttrDerivedResultType]> { def OpD : NS_Op<"type_attr_as_result_type", [FirstAttrDerivedResultType]> {
let arguments = (ins I32:$x, IntegerTypeAttr:$attr, F32Attr:$f32); let arguments = (ins I32:$x, IntegerTypeAttr:$attr, F32Attr:$f32);
let results = (outs AnyTensor:$y); let results = (outs AnyTensor:$y);
} }
// CHECK-LABEL: OpD definitions // CHECK-LABEL: OpD definitions
// CHECK: void OpD::build(Builder *odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes) // CHECK: void OpD::build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes)
// CHECK: odsState.addTypes({attr.second.cast<TypeAttr>().getValue()}); // CHECK: odsState.addTypes({attr.second.cast<TypeAttr>().getValue()});
def OpE : NS_Op<"value_attr_as_result_type", [FirstAttrDerivedResultType]> { def OpE : NS_Op<"value_attr_as_result_type", [FirstAttrDerivedResultType]> {
let arguments = (ins I32:$x, F32Attr:$attr); let arguments = (ins I32:$x, F32Attr:$attr);
let results = (outs AnyTensor:$y); let results = (outs AnyTensor:$y);
} }
// CHECK-LABEL: OpE definitions // CHECK-LABEL: OpE definitions
// CHECK: void OpE::build(Builder *odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes) // CHECK: void OpE::build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes)
// CHECK: odsState.addTypes({attr.second.getType()}); // CHECK: odsState.addTypes({attr.second.getType()});
def OpF : NS_Op<"one_variadic_result_op", []> { def OpF : NS_Op<"one_variadic_result_op", []> {
let results = (outs Variadic<I32>:$x); let results = (outs Variadic<I32>:$x);
} }
// CHECK-LABEL: void OpF::build // CHECK-LABEL: void OpF::build
// CHECK-SAME: ArrayRef<Type> x // CHECK-SAME: ArrayRef<Type> x
// CHECK-NOT: assert // CHECK-NOT: assert
// CHECK: odsState.addTypes(x); // CHECK: odsState.addTypes(x);
def OpG : NS_Op<"one_normal_and_one_variadic_result_op", []> { def OpG : NS_Op<"one_normal_and_one_variadic_result_op", []> {
let results = (outs I32:$x, Variadic<I32>:$y); let results = (outs I32:$x, Variadic<I32>:$y);
} }
// CHECK-LABEL: OpG definitions // CHECK-LABEL: OpG definitions
// CHECK: void OpG::build(Builder *odsBuilder, OperationState &odsState, Type x, ArrayRef<Type> y) // CHECK: void OpG::build(OpBuilder &odsBuilder, OperationState &odsState, Type x, ArrayRef<Type> y)
// CHECK-NEXT: odsState.addTypes(x); // CHECK-NEXT: odsState.addTypes(x);
// CHECK-NEXT: odsState.addTypes(y); // CHECK-NEXT: odsState.addTypes(y);
// CHECK: void OpG::build // CHECK: void OpG::build
// CHECK: ArrayRef<Type> resultTypes // CHECK: ArrayRef<Type> resultTypes
// CHECK: assert(resultTypes.size() >= 1u && "mismatched number of return types"); // CHECK: assert(resultTypes.size() >= 1u && "mismatched number of return types");
// CHECK-NEXT: odsState.addTypes(resultTypes); // CHECK-NEXT: odsState.addTypes(resultTypes);
Show All 15 Lines
// Test that if the only operand is variadic, we access the first value in the // Test that if the only operand is variadic, we access the first value in the
// pack to set result type // pack to set result type
// --- // ---
def OpK : NS_Op<"only_input_is_variadic_with_same_value_type_op", [SameOperandsAndResultType]> { def OpK : NS_Op<"only_input_is_variadic_with_same_value_type_op", [SameOperandsAndResultType]> {
let arguments = (ins Variadic<AnyTensor>:$input); let arguments = (ins Variadic<AnyTensor>:$input);
let results = (outs AnyTensor:$result); let results = (outs AnyTensor:$result);
} }
// CHECK-LABEL: OpK::build(Builder *odsBuilder, OperationState &odsState, ValueRange input) // CHECK-LABEL: OpK::build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange input)
// CHECK: odsState.addTypes({input.front().getType()}); // CHECK: odsState.addTypes({input.front().getType()});

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-gen.cpp

Show First 20 Lines • Show All 1,461 Lines • ▼ Show 20 Lines const char *header = R"FMT( def {0} : LinalgNamedStructured_Op<"{1}", [
NInputs<{2}>, NInputs<{2}>,
NOutputs<{3}>, NOutputs<{3}>,
NamedStructuredOpTraits, NamedStructuredOpTraits,
SingleBlockImplicitTerminator<"YieldOp">]> { SingleBlockImplicitTerminator<"YieldOp">]> {
let arguments = (ins Variadic<LinalgOperand>:$views); let arguments = (ins Variadic<LinalgOperand>:$views);
let results = (outs Variadic<AnyRankedTensor>:$output_tensors); let results = (outs Variadic<AnyRankedTensor>:$output_tensors);
let regions = (region SizedRegion<1>:$region); let regions = (region SizedRegion<1>:$region);
let builders = [OpBuilder< let builders = [OpBuilder<
"Builder *b, OperationState &result, TypeRange outputTypes, " "OpBuilder &b, OperationState &result, TypeRange outputTypes, "
# "ValueRange views", # "ValueRange views",
[{{ [{{
result.addOperands(views); result.addOperands(views);
result.addTypes(outputTypes); result.addTypes(outputTypes);
buildNamedStructuredOpRegion<{0}>( buildNamedStructuredOpRegion<{0}>(
*b, result, TypeRange(views), outputTypes); b, result, TypeRange(views), outputTypes);
}]> }]>
]; ];
let parser = [{ let parser = [{
return ::parseNamedStructuredOp<{0}>(parser, result); return ::parseNamedStructuredOp<{0}>(parser, result);
}]; }];
let extraClassDeclaration = [{{ let extraClassDeclaration = [{{
llvm::Optional<SmallVector<StringRef, 8>> referenceIterators(); llvm::Optional<SmallVector<StringRef, 8>> referenceIterators();
llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps(); llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps();
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

Show First 20 Lines • Show All 737 Lines • ▼ Show 20 Lines auto emit = [&](AttrParamKind attrType, TypeParamKind paramKind,
if (inferType) { if (inferType) {
// Generate builder that infers type too. // Generate builder that infers type too.
// TODO(jpienaar): Subsume this with general checking if type can be // TODO(jpienaar): Subsume this with general checking if type can be
// inferred automatically. // inferred automatically.
// TODO(jpienaar): Expand to handle regions. // TODO(jpienaar): Expand to handle regions.
body << formatv(R"( body << formatv(R"(
SmallVector<Type, 2> inferredReturnTypes; SmallVector<Type, 2> inferredReturnTypes;
if (succeeded({0}::inferReturnTypes(odsBuilder->getContext(), if (succeeded({0}::inferReturnTypes(odsBuilder.getContext(),
{1}.location, {1}.operands, {1}.attributes, {1}.location, {1}.operands, {1}.attributes,
/*regions=*/{{}, inferredReturnTypes))) /*regions=*/{{}, inferredReturnTypes)))
{1}.addTypes(inferredReturnTypes); {1}.addTypes(inferredReturnTypes);
else else
llvm::report_fatal_error("Failed to infer result type(s).");)", llvm::report_fatal_error("Failed to infer result type(s).");)",
opClass.getClassName(), builderOpState); opClass.getClassName(), builderOpState);
return; return;
} }
Show All 40 Linesvoid OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
// we don't know how many results to create. // we don't know how many results to create.
if (op.getNumVariableLengthResults() != 0) if (op.getNumVariableLengthResults() != 0)
return; return;
int numResults = op.getNumResults(); int numResults = op.getNumResults();
// Signature // Signature
std::string params = std::string params =
std::string("Builder *odsBuilder, OperationState &") + builderOpState + std::string("OpBuilder &odsBuilder, OperationState &") + builderOpState +
", ValueRange operands, ArrayRef<NamedAttribute> attributes"; ", ValueRange operands, ArrayRef<NamedAttribute> attributes";
if (op.getNumVariadicRegions()) if (op.getNumVariadicRegions())
params += ", unsigned numRegions"; params += ", unsigned numRegions";
auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static); auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static);
auto &body = m.body(); auto &body = m.body();
// Operands // Operands
body << " " << builderOpState << ".addOperands(operands);\n"; body << " " << builderOpState << ".addOperands(operands);\n";
Show All 15 Linesvoid OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
SmallVector<std::string, 2> resultTypes(numResults, "operands[0].getType()"); SmallVector<std::string, 2> resultTypes(numResults, "operands[0].getType()");
body << " " << builderOpState << ".addTypes({" body << " " << builderOpState << ".addTypes({"
<< llvm::join(resultTypes, ", ") << "});\n\n"; << llvm::join(resultTypes, ", ") << "});\n\n";
} }
void OpEmitter::genInferredTypeCollectiveParamBuilder() { void OpEmitter::genInferredTypeCollectiveParamBuilder() {
// TODO(jpienaar): Expand to support regions. // TODO(jpienaar): Expand to support regions.
const char *params = const char *params =
"Builder *odsBuilder, OperationState &{0}, " "OpBuilder &odsBuilder, OperationState &{0}, "
"ValueRange operands, ArrayRef<NamedAttribute> attributes"; "ValueRange operands, ArrayRef<NamedAttribute> attributes";
auto &m = auto &m =
opClass.newMethod("void", "build", formatv(params, builderOpState).str(), opClass.newMethod("void", "build", formatv(params, builderOpState).str(),
OpMethod::MP_Static); OpMethod::MP_Static);
auto &body = m.body(); auto &body = m.body();
body << formatv(R"( body << formatv(R"(
SmallVector<Type, 2> inferredReturnTypes; SmallVector<Type, 2> inferredReturnTypes;
if (succeeded({0}::inferReturnTypes(odsBuilder->getContext(), if (succeeded({0}::inferReturnTypes(odsBuilder.getContext(),
{1}.location, operands, attributes, {1}.location, operands, attributes,
/*regions=*/{{}, inferredReturnTypes))) /*regions=*/{{}, inferredReturnTypes)))
build(odsBuilder, odsState, inferredReturnTypes, operands, attributes); build(odsBuilder, odsState, inferredReturnTypes, operands, attributes);
else else
llvm::report_fatal_error("Failed to infer result type(s).");)", llvm::report_fatal_error("Failed to infer result type(s).");)",
opClass.getClassName(), builderOpState); opClass.getClassName(), builderOpState);
} }
Show All 16 Linesvoid OpEmitter::genUseOperandAsResultTypeSeparateParamBuilder() {
m.body() << " " << builderOpState << ".addTypes({" << resultType; m.body() << " " << builderOpState << ".addTypes({" << resultType;
for (int i = 1; i != numResults; ++i) for (int i = 1; i != numResults; ++i)
m.body() << ", " << resultType; m.body() << ", " << resultType;
m.body() << "});\n\n"; m.body() << "});\n\n";
} }
void OpEmitter::genUseAttrAsResultTypeBuilder() { void OpEmitter::genUseAttrAsResultTypeBuilder() {
std::string params = std::string params =
std::string("Builder *odsBuilder, OperationState &") + builderOpState + std::string("OpBuilder &odsBuilder, OperationState &") + builderOpState +
", ValueRange operands, ArrayRef<NamedAttribute> attributes"; ", ValueRange operands, ArrayRef<NamedAttribute> attributes";
auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static); auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static);
auto &body = m.body(); auto &body = m.body();
// Push all result types to the operation state // Push all result types to the operation state
std::string resultType; std::string resultType;
const auto &namedAttr = op.getAttribute(0); const auto &namedAttr = op.getAttribute(0);
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Linesvoid OpEmitter::genCollectiveParamBuilder() {
int numResults = op.getNumResults(); int numResults = op.getNumResults();
int numVariadicResults = op.getNumVariableLengthResults(); int numVariadicResults = op.getNumVariableLengthResults();
int numNonVariadicResults = numResults - numVariadicResults; int numNonVariadicResults = numResults - numVariadicResults;
int numOperands = op.getNumOperands(); int numOperands = op.getNumOperands();
int numVariadicOperands = op.getNumVariableLengthOperands(); int numVariadicOperands = op.getNumVariableLengthOperands();
int numNonVariadicOperands = numOperands - numVariadicOperands; int numNonVariadicOperands = numOperands - numVariadicOperands;
// Signature // Signature
std::string params = std::string("Builder *, OperationState &") + std::string params = std::string("OpBuilder &, OperationState &") +
builderOpState + builderOpState +
", ArrayRef<Type> resultTypes, ValueRange operands, " ", ArrayRef<Type> resultTypes, ValueRange operands, "
"ArrayRef<NamedAttribute> attributes"; "ArrayRef<NamedAttribute> attributes";
if (op.getNumVariadicRegions()) if (op.getNumVariadicRegions())
params += ", unsigned numRegions"; params += ", unsigned numRegions";
auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static); auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static);
auto &body = m.body(); auto &body = m.body();
Show All 37 Lines
void OpEmitter::buildParamList(std::string &paramList, void OpEmitter::buildParamList(std::string &paramList,
SmallVectorImpl<std::string> &resultTypeNames, SmallVectorImpl<std::string> &resultTypeNames,
TypeParamKind typeParamKind, TypeParamKind typeParamKind,
AttrParamKind attrParamKind) { AttrParamKind attrParamKind) {
resultTypeNames.clear(); resultTypeNames.clear();
auto numResults = op.getNumResults(); auto numResults = op.getNumResults();
resultTypeNames.reserve(numResults); resultTypeNames.reserve(numResults);
paramList = "Builder *odsBuilder, OperationState &"; paramList = "OpBuilder &odsBuilder, OperationState &";
paramList.append(builderOpState); paramList.append(builderOpState);
switch (typeParamKind) { switch (typeParamKind) {
case TypeParamKind::None: case TypeParamKind::None:
break; break;
case TypeParamKind::Separate: { case TypeParamKind::Separate: {
// Add parameters for all return types // Add parameters for all return types
for (int i = 0; i < numResults; ++i) { for (int i = 0; i < numResults; ++i) {
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Linesvoid OpEmitter::genCodeForAddingArgAndRegionForBuilder(OpMethodBody &body,
} }
if (op.hasResizableOperandList()) if (op.hasResizableOperandList())
body << formatv(" {0}.setOperandListToResizable();\n", builderOpState); body << formatv(" {0}.setOperandListToResizable();\n", builderOpState);
// If the operation has the operand segment size attribute, add it here. // If the operation has the operand segment size attribute, add it here.
if (op.getTrait("OpTrait::AttrSizedOperandSegments")) { if (op.getTrait("OpTrait::AttrSizedOperandSegments")) {
body << " " << builderOpState body << " " << builderOpState
<< ".addAttribute(\"operand_segment_sizes\", " << ".addAttribute(\"operand_segment_sizes\", "
"odsBuilder->getI32VectorAttr({"; "odsBuilder.getI32VectorAttr({";
interleaveComma(llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) { interleaveComma(llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
if (op.getOperand(i).isOptional()) if (op.getOperand(i).isOptional())
body << "(" << getArgumentName(op, i) << " ? 1 : 0)"; body << "(" << getArgumentName(op, i) << " ? 1 : 0)";
else if (op.getOperand(i).isVariadic()) else if (op.getOperand(i).isVariadic())
body << "static_cast<int32_t>(" << getArgumentName(op, i) << ".size())"; body << "static_cast<int32_t>(" << getArgumentName(op, i) << ".size())";
else else
body << "1"; body << "1";
}); });
body << "}));\n"; body << "}));\n";
} }
// Push all attributes to the result. // Push all attributes to the result.
for (const auto &namedAttr : op.getAttributes()) { for (const auto &namedAttr : op.getAttributes()) {
auto &attr = namedAttr.attr; auto &attr = namedAttr.attr;
if (!attr.isDerivedAttr()) { if (!attr.isDerivedAttr()) {
bool emitNotNullCheck = attr.isOptional(); bool emitNotNullCheck = attr.isOptional();
if (emitNotNullCheck) { if (emitNotNullCheck) {
body << formatv(" if ({0}) ", namedAttr.name) << "{\n"; body << formatv(" if ({0}) ", namedAttr.name) << "{\n";
} }
if (isRawValueAttr && canUseUnwrappedRawValue(attr)) { if (isRawValueAttr && canUseUnwrappedRawValue(attr)) {
// If this is a raw value, then we need to wrap it in an Attribute // If this is a raw value, then we need to wrap it in an Attribute
// instance. // instance.
FmtContext fctx; FmtContext fctx;
fctx.withBuilder("(*odsBuilder)"); fctx.withBuilder("odsBuilder");
std::string builderTemplate = std::string builderTemplate =
std::string(attr.getConstBuilderTemplate()); std::string(attr.getConstBuilderTemplate());
// For StringAttr, its constant builder call will wrap the input in // For StringAttr, its constant builder call will wrap the input in
// quotes, which is correct for normal string literals, but incorrect // quotes, which is correct for normal string literals, but incorrect
// here given we use function arguments. So we need to strip the // here given we use function arguments. So we need to strip the
// wrapping quotes. // wrapping quotes.
▲ Show 20 Lines • Show All 665 Lines • Show Last 20 Lines

mlir/unittests/Dialect/SPIRV/SerializationTest.cpp

Show All 32 Lines
// Test Fixture // Test Fixture
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
class SerializationTest : public ::testing::Test { class SerializationTest : public ::testing::Test {
protected: protected:
SerializationTest() { createModuleOp(); } SerializationTest() { createModuleOp(); }
void createModuleOp() { void createModuleOp() {
Builder builder(&context); OpBuilder builder(&context);
OperationState state(UnknownLoc::get(&context), OperationState state(UnknownLoc::get(&context),
spirv::ModuleOp::getOperationName()); spirv::ModuleOp::getOperationName());
state.addAttribute("addressing_model", state.addAttribute("addressing_model",
builder.getI32IntegerAttr(static_cast<uint32_t>( builder.getI32IntegerAttr(static_cast<uint32_t>(
spirv::AddressingModel::Logical))); spirv::AddressingModel::Logical)));
state.addAttribute("memory_model", state.addAttribute("memory_model",
builder.getI32IntegerAttr( builder.getI32IntegerAttr(
static_cast<uint32_t>(spirv::MemoryModel::GLSL450))); static_cast<uint32_t>(spirv::MemoryModel::GLSL450)));
state.addAttribute("vce_triple", state.addAttribute("vce_triple",
spirv::VerCapExtAttr::get( spirv::VerCapExtAttr::get(
spirv::Version::V_1_0, ArrayRef<spirv::Capability>(), spirv::Version::V_1_0, ArrayRef<spirv::Capability>(),
ArrayRef<spirv::Extension>(), &context)); ArrayRef<spirv::Extension>(), &context));
spirv::ModuleOp::build(&builder, state); spirv::ModuleOp::build(builder, state);
module = cast<spirv::ModuleOp>(Operation::create(state)); module = cast<spirv::ModuleOp>(Operation::create(state));
} }
Type getFloatStructType() { Type getFloatStructType() {
OpBuilder opBuilder(module.body()); OpBuilder opBuilder(module.body());
llvm::SmallVector<Type, 1> elementTypes{opBuilder.getF32Type()}; llvm::SmallVector<Type, 1> elementTypes{opBuilder.getF32Type()};
llvm::SmallVector<spirv::StructType::LayoutInfo, 1> layoutInfo{0}; llvm::SmallVector<spirv::StructType::LayoutInfo, 1> layoutInfo{0};
auto structType = spirv::StructType::get(elementTypes, layoutInfo); auto structType = spirv::StructType::get(elementTypes, layoutInfo);
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines