18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/ADT/TypeSwitch.h"
21 #include "llvm/Support/Casting.h"
22 #include "llvm/Support/FormatVariadic.h"
27 #include "mlir/Dialect/EmitC/IR/EmitCDialect.cpp.inc"
33 void EmitCDialect::initialize() {
36 #include "mlir/Dialect/EmitC/IR/EmitC.cpp.inc"
39 #define GET_TYPEDEF_LIST
40 #include "mlir/Dialect/EmitC/IR/EmitCTypes.cpp.inc"
43 #define GET_ATTRDEF_LIST
44 #include "mlir/Dialect/EmitC/IR/EmitCAttributes.cpp.inc"
53 return builder.
create<emitc::ConstantOp>(loc, type, value);
59 builder.
create<emitc::YieldOp>(loc);
63 if (llvm::isa<emitc::OpaqueType>(type))
65 if (
auto ptrType = llvm::dyn_cast<emitc::PointerType>(type))
67 if (
auto arrayType = llvm::dyn_cast<emitc::ArrayType>(type)) {
68 auto elemType = arrayType.getElementType();
69 return !llvm::isa<emitc::ArrayType>(elemType) &&
74 if (llvm::isa<IntegerType>(type))
76 if (llvm::isa<FloatType>(type))
78 if (
auto tensorType = llvm::dyn_cast<TensorType>(type)) {
79 if (!tensorType.hasStaticShape()) {
82 auto elemType = tensorType.getElementType();
83 if (llvm::isa<emitc::ArrayType>(elemType)) {
88 if (
auto tupleType = llvm::dyn_cast<TupleType>(type)) {
89 return llvm::all_of(tupleType.getTypes(), [](
Type type) {
90 return !llvm::isa<emitc::ArrayType>(type) && isSupportedEmitCType(type);
97 if (
auto intType = llvm::dyn_cast<IntegerType>(type)) {
98 switch (intType.getWidth()) {
113 return llvm::isa<IndexType, emitc::OpaqueType>(type) ||
118 if (
auto floatType = llvm::dyn_cast<FloatType>(type)) {
119 switch (floatType.getWidth()) {
121 if (llvm::isa<Float16Type, BFloat16Type>(type))
136 return isa<emitc::SignedSizeTType, emitc::SizeTType, emitc::PtrDiffTType>(
144 assert(op->
getNumResults() == 1 &&
"operation must have 1 result");
146 if (llvm::isa<emitc::OpaqueAttr>(value))
149 if (llvm::isa<StringAttr>(value))
151 <<
"string attributes are not supported, use #emitc.opaque instead";
154 if (
auto lType = dyn_cast<LValueType>(resultType))
155 resultType = lType.getValueType();
156 Type attrType = cast<TypedAttr>(value).getType();
161 if (resultType != attrType)
163 <<
"requires attribute to either be an #emitc.opaque attribute or "
165 << attrType <<
") to match the op's result type (" << resultType
176 template <
class ArgType>
177 FailureOr<SmallVector<ReplacementItem>>
184 if (fmtArgs.empty()) {
185 items.push_back(toParse);
189 while (!toParse.empty()) {
190 size_t idx = toParse.find(
'{');
191 if (idx == StringRef::npos) {
193 items.push_back(toParse);
198 items.push_back(toParse.take_front(idx));
199 toParse = toParse.drop_front(idx);
202 if (toParse.size() < 2) {
204 <<
"expected '}' after unescaped '{' at end of string";
207 char nextChar = toParse[1];
208 if (nextChar ==
'{') {
210 items.push_back(toParse.take_front(1));
211 toParse = toParse.drop_front(2);
214 if (nextChar ==
'}') {
216 toParse = toParse.drop_front(2);
221 return (*
emitError)() <<
"expected '}' after unescaped '{'";
233 Type lhsType = getLhs().getType();
234 Type rhsType = getRhs().getType();
236 if (isa<emitc::PointerType>(lhsType) && isa<emitc::PointerType>(rhsType))
237 return emitOpError(
"requires that at most one operand is a pointer");
239 if ((isa<emitc::PointerType>(lhsType) &&
240 !isa<IntegerType, emitc::OpaqueType>(rhsType)) ||
241 (isa<emitc::PointerType>(rhsType) &&
242 !isa<IntegerType, emitc::OpaqueType>(lhsType)))
243 return emitOpError(
"requires that one operand is an integer or of opaque "
244 "type if the other is a pointer");
254 StringRef applicableOperatorStr = getApplicableOperator();
257 if (applicableOperatorStr.empty())
258 return emitOpError(
"applicable operator must not be empty");
261 if (applicableOperatorStr !=
"&" && applicableOperatorStr !=
"*")
262 return emitOpError(
"applicable operator is illegal");
264 Type operandType = getOperand().getType();
265 Type resultType = getResult().getType();
266 if (applicableOperatorStr ==
"&") {
267 if (!llvm::isa<emitc::LValueType>(operandType))
268 return emitOpError(
"operand type must be an lvalue when applying `&`");
269 if (!llvm::isa<emitc::PointerType>(resultType))
270 return emitOpError(
"result type must be a pointer when applying `&`");
272 if (!llvm::isa<emitc::PointerType>(operandType))
273 return emitOpError(
"operand type must be a pointer when applying `*`");
288 if (!variable.getDefiningOp())
289 return emitOpError() <<
"cannot assign to block argument";
291 Type valueType = getValue().getType();
292 Type variableType = variable.getType().getValueType();
293 if (variableType != valueType)
294 return emitOpError() <<
"requires value's type (" << valueType
295 <<
") to match variable's type (" << variableType
296 <<
")\n variable: " << variable
297 <<
"\n value: " << getValue() <<
"\n";
306 Type input = inputs.front(), output = outputs.front();
308 if (
auto arrayType = dyn_cast<emitc::ArrayType>(input)) {
309 if (
auto pointerType = dyn_cast<emitc::PointerType>(output)) {
310 return (arrayType.getElementType() == pointerType.getPointee()) &&
311 arrayType.getShape().size() == 1 && arrayType.getShape()[0] >= 1;
329 if (getCallee().empty())
330 return emitOpError(
"callee must not be empty");
332 if (std::optional<ArrayAttr> argsAttr = getArgs()) {
334 auto intAttr = llvm::dyn_cast<IntegerAttr>(arg);
335 if (intAttr && llvm::isa<IndexType>(intAttr.getType())) {
336 int64_t index = intAttr.getInt();
339 if ((index < 0) || (index >=
static_cast<int64_t
>(getNumOperands())))
340 return emitOpError(
"index argument is out of range");
343 }
else if (llvm::isa<ArrayAttr>(
346 return emitOpError(
"array argument has no type");
351 if (std::optional<ArrayAttr> templateArgsAttr = getTemplateArgs()) {
352 for (
Attribute tArg : *templateArgsAttr) {
353 if (!llvm::isa<TypeAttr, IntegerAttr, FloatAttr, emitc::OpaqueAttr>(tArg))
354 return emitOpError(
"template argument has invalid type");
358 if (llvm::any_of(getResultTypes(), llvm::IsaPred<ArrayType>)) {
359 return emitOpError() <<
"cannot return array type";
373 if (
auto opaqueValue = llvm::dyn_cast<emitc::OpaqueAttr>(value)) {
374 if (opaqueValue.getValue().empty())
375 return emitOpError() <<
"value must not be empty";
380 OpFoldResult emitc::ConstantOp::fold(FoldAdaptor adaptor) {
return getValue(); }
387 auto yieldOp = cast<YieldOp>(getBody()->getTerminator());
388 Value yieldedValue = yieldOp.getResult();
390 assert(rootOp &&
"Yielded value not defined within expression");
395 Type resultType = getResult().getType();
396 Region ®ion = getRegion();
401 return emitOpError(
"must yield a value at termination");
404 Value yieldResult = yield.getResult();
407 return emitOpError(
"must yield a value at termination");
411 if (resultType != yieldType)
412 return emitOpError(
"requires yielded type to match return type");
416 return emitOpError(
"contains an unsupported operation");
417 if (op.getNumResults() != 1)
418 return emitOpError(
"requires exactly one result for each operation");
419 if (!op.getResult(0).hasOneUse())
420 return emitOpError(
"requires exactly one use for each operation");
431 Value ub,
Value step, BodyBuilderFn bodyBuilder) {
441 ForOp::ensureTerminator(*bodyRegion, builder, result.
location);
469 regionArgs.push_back(inductionVariable);
478 regionArgs.front().type = type;
489 ForOp::ensureTerminator(*body, builder, result.
location);
499 p <<
" " << getInductionVar() <<
" = " <<
getLowerBound() <<
" to "
504 p <<
" : " << t <<
' ';
511 LogicalResult ForOp::verifyRegions() {
516 "expected induction variable to be same type as bounds and step");
529 return emitOpError(
"requires a 'callee' symbol reference attribute");
532 return emitOpError() <<
"'" << fnAttr.getValue()
533 <<
"' does not reference a valid function";
536 auto fnType = fn.getFunctionType();
537 if (fnType.getNumInputs() != getNumOperands())
538 return emitOpError(
"incorrect number of operands for callee");
540 for (
unsigned i = 0, e = fnType.getNumInputs(); i != e; ++i)
541 if (getOperand(i).
getType() != fnType.getInput(i))
542 return emitOpError(
"operand type mismatch: expected operand type ")
543 << fnType.getInput(i) <<
", but provided "
544 << getOperand(i).getType() <<
" for operand number " << i;
546 if (fnType.getNumResults() != getNumResults())
547 return emitOpError(
"incorrect number of results for callee");
549 for (
unsigned i = 0, e = fnType.getNumResults(); i != e; ++i)
550 if (getResult(i).
getType() != fnType.getResult(i)) {
551 auto diag = emitOpError(
"result type mismatch at index ") << i;
552 diag.attachNote() <<
" op result types: " << getResultTypes();
553 diag.attachNote() <<
"function result types: " << fnType.getResults();
560 FunctionType CallOp::getCalleeType() {
571 auto fnAttr = getSymNameAttr();
573 return emitOpError(
"requires a 'sym_name' symbol reference attribute");
576 return emitOpError() <<
"'" << fnAttr.getValue()
577 <<
"' does not reference a valid function";
591 state.addAttribute(getFunctionTypeAttrName(state.name),
TypeAttr::get(type));
592 state.attributes.append(attrs.begin(), attrs.end());
595 if (argAttrs.empty())
597 assert(type.getNumInputs() == argAttrs.size());
599 builder, state, argAttrs, std::nullopt,
600 getArgAttrsAttrName(state.name), getResAttrsAttrName(state.name));
610 parser, result,
false,
611 getFunctionTypeAttrName(result.
name), buildFuncType,
612 getArgAttrsAttrName(result.
name), getResAttrsAttrName(result.
name));
617 p, *
this,
false, getFunctionTypeAttrName(),
618 getArgAttrsAttrName(), getResAttrsAttrName());
622 if (llvm::any_of(getArgumentTypes(), llvm::IsaPred<LValueType>)) {
623 return emitOpError(
"cannot have lvalue type as argument");
626 if (getNumResults() > 1)
627 return emitOpError(
"requires zero or exactly one result, but has ")
630 if (getNumResults() == 1 && isa<ArrayType>(getResultTypes()[0]))
631 return emitOpError(
"cannot return array type");
641 auto function = cast<FuncOp>((*this)->getParentOp());
644 if (getNumOperands() !=
function.getNumResults())
645 return emitOpError(
"has ")
646 << getNumOperands() <<
" operands, but enclosing function (@"
647 <<
function.getName() <<
") returns " <<
function.getNumResults();
649 if (
function.getNumResults() == 1)
650 if (getOperand().
getType() !=
function.getResultTypes()[0])
651 return emitError() <<
"type of the return operand ("
652 << getOperand().getType()
653 <<
") doesn't match function result type ("
654 <<
function.getResultTypes()[0] <<
")"
655 <<
" in function @" <<
function.getName();
664 bool addThenBlock,
bool addElseBlock) {
665 assert((!addElseBlock || addThenBlock) &&
666 "must not create else block w/o then block");
680 bool withElseRegion) {
690 if (withElseRegion) {
698 assert(thenBuilder &&
"the builder callback for 'then' must be present");
705 thenBuilder(builder, result.
location);
711 elseBuilder(builder, result.
location);
746 bool printBlockTerminators =
false;
748 p <<
" " << getCondition();
752 printBlockTerminators);
755 Region &elseRegion = getElseRegion();
756 if (!elseRegion.
empty()) {
760 printBlockTerminators);
782 Region *elseRegion = &this->getElseRegion();
783 if (elseRegion->
empty())
791 FoldAdaptor adaptor(operands, *
this);
792 auto boolAttr = dyn_cast_or_null<BoolAttr>(adaptor.getCondition());
793 if (!boolAttr || boolAttr.getValue())
794 regions.emplace_back(&getThenRegion());
797 if (!boolAttr || !boolAttr.getValue()) {
798 if (!getElseRegion().empty())
799 regions.emplace_back(&getElseRegion());
801 regions.emplace_back();
805 void IfOp::getRegionInvocationBounds(
808 if (
auto cond = llvm::dyn_cast_or_null<BoolAttr>(operands[0])) {
811 invocationBounds.emplace_back(0, cond.getValue() ? 1 : 0);
812 invocationBounds.emplace_back(0, cond.getValue() ? 0 : 1);
815 invocationBounds.assign(2, {0, 1});
824 bool standardInclude = getIsStandardInclude();
829 p <<
"\"" << getInclude() <<
"\"";
845 <<
"expected trailing '>' for standard include";
860 if (getValue().empty())
861 return emitOpError() <<
"value must not be empty";
869 Type lhsType = getLhs().getType();
870 Type rhsType = getRhs().getType();
871 Type resultType = getResult().getType();
873 if (isa<emitc::PointerType>(rhsType) && !isa<emitc::PointerType>(lhsType))
874 return emitOpError(
"rhs can only be a pointer if lhs is a pointer");
876 if (isa<emitc::PointerType>(lhsType) &&
877 !isa<IntegerType, emitc::OpaqueType, emitc::PointerType>(rhsType))
878 return emitOpError(
"requires that rhs is an integer, pointer or of opaque "
879 "type if lhs is a pointer");
881 if (isa<emitc::PointerType>(lhsType) && isa<emitc::PointerType>(rhsType) &&
882 !isa<IntegerType, emitc::PtrDiffTType, emitc::OpaqueType>(resultType))
883 return emitOpError(
"requires that the result is an integer, ptrdiff_t or "
884 "of opaque type if lhs and rhs are pointers");
901 Value result = getResult();
905 return emitOpError() <<
"yields a value not returned by parent";
908 return emitOpError() <<
"does not yield a value to be returned by parent";
919 if (
auto arrayType = llvm::dyn_cast<emitc::ArrayType>(getValue().
getType())) {
921 if (
getIndices().size() != (
size_t)arrayType.getRank()) {
922 return emitOpError() <<
"on array operand requires number of indices ("
924 <<
") to match the rank of the array type ("
925 << arrayType.getRank() <<
")";
928 for (
unsigned i = 0, e =
getIndices().size(); i != e; ++i) {
931 return emitOpError() <<
"on array operand requires index operand " << i
932 <<
" to be integer-like, but got " << type;
936 Type elementType = arrayType.getElementType();
938 if (elementType != resultType) {
939 return emitOpError() <<
"on array operand requires element type ("
940 << elementType <<
") and result type (" << resultType
947 if (
auto pointerType =
948 llvm::dyn_cast<emitc::PointerType>(getValue().
getType())) {
952 <<
"on pointer operand requires one index operand, but got "
958 return emitOpError() <<
"on pointer operand requires index operand to be "
959 "integer-like, but got "
963 Type pointeeType = pointerType.getPointee();
965 if (pointeeType != resultType) {
966 return emitOpError() <<
"on pointer operand requires pointee type ("
967 << pointeeType <<
") and result type (" << resultType
984 return this->emitOpError();
986 FailureOr<SmallVector<ReplacementItem>> fmt =
991 size_t numPlaceholders = llvm::count_if(*fmt, [](
ReplacementItem &item) {
992 return std::holds_alternative<Placeholder>(item);
995 if (numPlaceholders != getFmtArgs().size()) {
997 <<
"requires operands for each placeholder in the format string";
1011 #include "mlir/Dialect/EmitC/IR/EmitCEnums.cpp.inc"
1017 #define GET_ATTRDEF_CLASSES
1018 #include "mlir/Dialect/EmitC/IR/EmitCAttributes.cpp.inc"
1024 #define GET_TYPEDEF_CLASSES
1025 #include "mlir/Dialect/EmitC/IR/EmitCTypes.cpp.inc"
1046 if (!isValidElementType(elementType))
1047 return parser.
emitError(typeLoc,
"invalid array element type"),
Type();
1050 return parser.
getChecked<ArrayType>(dimensions, elementType);
1056 printer << dim <<
'x';
1066 return emitError() <<
"shape must not be empty";
1068 for (int64_t dim : shape) {
1070 return emitError() <<
"dimensions must have non-negative size";
1074 return emitError() <<
"element type must not be none";
1076 if (!isValidElementType(elementType))
1077 return emitError() <<
"invalid array element type";
1084 Type elementType)
const {
1101 <<
"!emitc.lvalue must wrap supported emitc type, but got " << value;
1103 if (llvm::isa<emitc::ArrayType>(value))
1104 return emitError() <<
"!emitc.lvalue cannot wrap !emitc.array type";
1115 llvm::StringRef value) {
1116 if (value.empty()) {
1117 return emitError() <<
"expected non empty string in !emitc.opaque type";
1119 if (value.back() ==
'*') {
1120 return emitError() <<
"pointer not allowed as outer type with "
1121 "!emitc.opaque, use !emitc.ptr instead";
1132 if (llvm::isa<emitc::LValueType>(value))
1133 return emitError() <<
"pointers to lvalues are not allowed";
1152 if (
auto array = llvm::dyn_cast<ArrayType>(type))
1172 if (!llvm::isa<ElementsAttr, IntegerAttr, FloatAttr, emitc::OpaqueAttr>(
1175 <<
"initial value should be a integer, float, elements or opaque "
1182 return emitOpError(
"expected valid emitc type");
1184 if (getInitialValue().has_value()) {
1185 Attribute initValue = getInitialValue().value();
1188 if (
auto elementsAttr = llvm::dyn_cast<ElementsAttr>(initValue)) {
1189 auto arrayType = llvm::dyn_cast<ArrayType>(
getType());
1191 return emitOpError(
"expected array type, but got ") <<
getType();
1193 Type initType = elementsAttr.getType();
1195 if (initType != tensorType) {
1196 return emitOpError(
"initial value expected to be of type ")
1197 <<
getType() <<
", but was of type " << initType;
1199 }
else if (
auto intAttr = dyn_cast<IntegerAttr>(initValue)) {
1200 if (intAttr.getType() !=
getType()) {
1201 return emitOpError(
"initial value expected to be of type ")
1202 <<
getType() <<
", but was of type " << intAttr.getType();
1204 }
else if (
auto floatAttr = dyn_cast<FloatAttr>(initValue)) {
1205 if (floatAttr.getType() !=
getType()) {
1206 return emitOpError(
"initial value expected to be of type ")
1207 <<
getType() <<
", but was of type " << floatAttr.getType();
1209 }
else if (!isa<emitc::OpaqueAttr>(initValue)) {
1210 return emitOpError(
"initial value should be a integer, float, elements "
1211 "or opaque attribute, but got ")
1215 if (getStaticSpecifier() && getExternSpecifier()) {
1216 return emitOpError(
"cannot have both static and extern specifiers");
1231 return emitOpError(
"'")
1232 << getName() <<
"' does not reference a valid emitc.global";
1234 Type resultType = getResult().getType();
1235 Type globalType = global.getType();
1238 if (llvm::isa<ArrayType>(globalType)) {
1239 if (globalType != resultType)
1240 return emitOpError(
"on array type expects result type ")
1241 << resultType <<
" to match type " << globalType
1242 <<
" of the global @" << getName();
1247 auto lvalueType = dyn_cast<LValueType>(resultType);
1248 if (!lvalueType || lvalueType.getValueType() != globalType)
1249 return emitOpError(
"on non-array type expects result inner type ")
1250 << lvalueType.getValueType() <<
" to match type " << globalType
1251 <<
" of the global @" << getName();
1266 Region ®ion = *caseRegions.emplace_back(std::make_unique<Region>());
1270 caseValues.push_back(value);
1279 for (
auto [value, region] : llvm::zip(cases.
asArrayRef(), caseRegions)) {
1281 p <<
"case " << value <<
' ';
1287 const Twine &name) {
1288 auto yield = dyn_cast<emitc::YieldOp>(region.
front().
back());
1290 return op.emitOpError(
"expected region to end with emitc.yield, but got ")
1293 if (yield.getNumOperands() != 0) {
1294 return (op.emitOpError(
"expected each region to return ")
1295 <<
"0 values, but " << name <<
" returns "
1296 << yield.getNumOperands())
1297 .attachNote(yield.getLoc())
1298 <<
"see yield operation here";
1306 return emitOpError(
"unsupported type ") << getArg().getType();
1308 if (getCases().size() != getCaseRegions().size()) {
1309 return emitOpError(
"has ")
1310 << getCaseRegions().size() <<
" case regions but "
1311 << getCases().size() <<
" case values";
1315 for (int64_t value : getCases())
1316 if (!valueSet.insert(value).second)
1317 return emitOpError(
"has duplicate case value: ") << value;
1319 if (failed(
verifyRegion(*
this, getDefaultRegion(),
"default region")))
1323 if (failed(
verifyRegion(*
this, caseRegion,
"case region #" + Twine(idx))))
1329 unsigned emitc::SwitchOp::getNumCases() {
return getCases().size(); }
1331 Block &emitc::SwitchOp::getDefaultBlock() {
return getDefaultRegion().
front(); }
1333 Block &emitc::SwitchOp::getCaseBlock(
unsigned idx) {
1334 assert(idx < getNumCases() &&
"case index out-of-bounds");
1335 return getCaseRegions()[idx].front();
1338 void SwitchOp::getSuccessorRegions(
1340 llvm::copy(getRegions(), std::back_inserter(successors));
1343 void SwitchOp::getEntrySuccessorRegions(
1346 FoldAdaptor adaptor(operands, *
this);
1349 auto arg = dyn_cast_or_null<IntegerAttr>(adaptor.getArg());
1351 llvm::copy(getRegions(), std::back_inserter(successors));
1357 for (
auto [caseValue, caseRegion] : llvm::zip(getCases(), getCaseRegions())) {
1358 if (caseValue == arg.getInt()) {
1359 successors.emplace_back(&caseRegion);
1363 successors.emplace_back(&getDefaultRegion());
1366 void SwitchOp::getRegionInvocationBounds(
1368 auto operandValue = llvm::dyn_cast_or_null<IntegerAttr>(operands.front());
1369 if (!operandValue) {
1375 unsigned liveIndex = getNumRegions() - 1;
1376 const auto *iteratorToInt = llvm::find(getCases(), operandValue.getInt());
1378 liveIndex = iteratorToInt != getCases().end()
1379 ? std::distance(getCases().begin(), iteratorToInt)
1382 for (
unsigned regIndex = 0, regNum = getNumRegions(); regIndex < regNum;
1384 bounds.emplace_back(0, regIndex == liveIndex);
1391 state.addRegion()->emplaceBlock();
1392 state.attributes.push_back(
1400 #define GET_OP_CLASSES
1401 #include "mlir/Dialect/EmitC/IR/EmitC.cpp.inc"
static std::optional< int64_t > getUpperBound(Value iv)
Gets the constant upper bound on an affine.for iv.
static std::optional< int64_t > getLowerBound(Value iv)
Gets the constant lower bound on an iv.
static void copy(Location loc, Value dst, Value src, Value size, OpBuilder &builder)
Copies the given number of bytes from src to dst pointers.
static LogicalResult verifyInitializationAttribute(Operation *op, Attribute value)
Check that the type of the initial value is compatible with the operations result type.
static LogicalResult verifyRegion(emitc::SwitchOp op, Region ®ion, const Twine &name)
static ParseResult parseEmitCGlobalOpTypeAndInitialValue(OpAsmParser &parser, TypeAttr &typeAttr, Attribute &initialValue)
static ParseResult parseSwitchCases(OpAsmParser &parser, DenseI64ArrayAttr &cases, SmallVectorImpl< std::unique_ptr< Region >> &caseRegions)
Parse the case regions and values.
static void printEmitCGlobalOpTypeAndInitialValue(OpAsmPrinter &p, GlobalOp op, TypeAttr type, Attribute initialValue)
static void printSwitchCases(OpAsmPrinter &p, Operation *op, DenseI64ArrayAttr cases, RegionRange caseRegions)
Print the case regions and values.
static Type getInitializerTypeForGlobal(Type type)
FailureOr< SmallVector< ReplacementItem > > parseFormatString(StringRef toParse, ArgType fmtArgs, std::optional< llvm::function_ref< mlir::InFlightDiagnostic()>> emitError={})
Parse a format string and return a list of its parts.
static Operation * materializeConstant(Dialect *dialect, OpBuilder &builder, Attribute value, Type type, Location loc)
A utility function used to materialize a constant for a given attribute and type.
static MLIRContext * getContext(OpFoldResult val)
static std::string diag(const llvm::Value &value)
static void print(spirv::VerCapExtAttr triple, DialectAsmPrinter &printer)
static Type getElementType(Type type, ArrayRef< int32_t > indices, function_ref< InFlightDiagnostic(StringRef)> emitErrorFn)
Walks the given type hierarchy with the given indices, potentially down to component granularity,...
static ArrayRef< int64_t > getShape(Type type)
Returns the shape of the given type.
This base class exposes generic asm parser hooks, usable across the various derived parsers.
virtual Builder & getBuilder() const =0
Return a builder which provides useful access to MLIRContext, global objects like types and attribute...
virtual ParseResult parseOptionalAttrDict(NamedAttrList &result)=0
Parse a named dictionary into 'result' if it is present.
virtual ParseResult parseOptionalEqual()=0
Parse a = token if present.
virtual ParseResult parseOptionalKeyword(StringRef keyword)=0
Parse the given keyword if present.
MLIRContext * getContext() const
virtual InFlightDiagnostic emitError(SMLoc loc, const Twine &message={})=0
Emit a diagnostic at the specified location and return failure.
virtual ParseResult parseOptionalColon()=0
Parse a : token if present.
ParseResult parseInteger(IntT &result)
Parse an integer value from the stream.
virtual ParseResult parseLess()=0
Parse a '<' token.
virtual ParseResult parseDimensionList(SmallVectorImpl< int64_t > &dimensions, bool allowDynamic=true, bool withTrailingX=true)=0
Parse a dimension list of a tensor or memref type.
virtual ParseResult parseOptionalGreater()=0
Parse a '>' token if present.
virtual ParseResult parseEqual()=0
Parse a = token.
virtual OptionalParseResult parseOptionalAttribute(Attribute &result, Type type={})=0
Parse an arbitrary optional attribute of a given type and return it in result.
virtual SMLoc getCurrentLocation()=0
Get the location of the next token and store it into the argument.
auto getChecked(SMLoc loc, ParamsT &&...params)
Invoke the getChecked method of the given Attribute or Type class, using the provided location to emi...
virtual SMLoc getNameLoc() const =0
Return the location of the original name token.
virtual ParseResult parseOptionalLess()=0
Parse a '<' token if present.
virtual ParseResult parseGreater()=0
Parse a '>' token.
virtual ParseResult parseType(Type &result)=0
Parse a type.
ParseResult parseKeyword(StringRef keyword)
Parse a given keyword.
virtual ParseResult parseAttribute(Attribute &result, Type type={})=0
Parse an arbitrary attribute of a given type and return it in result.
This base class exposes generic asm printer hooks, usable across the various derived printers.
virtual void printAttributeWithoutType(Attribute attr)
Print the given attribute without its type.
virtual void printType(Type type)
Attributes are known-constant values of operations.
Block represents an ordered list of Operations.
BlockArgument getArgument(unsigned i)
Operation * getTerminator()
Get the terminator operation of this block.
BlockArgument addArgument(Type type, Location loc)
Add one value to the argument list.
bool mightHaveTerminator()
Check whether this block might have a terminator.
iterator_range< iterator > without_terminator()
Return an iterator range over the operation within this block excluding the terminator operation at t...
This class is a general helper class for creating context-global objects like types,...
DenseI64ArrayAttr getDenseI64ArrayAttr(ArrayRef< int64_t > values)
FunctionType getFunctionType(TypeRange inputs, TypeRange results)
IntegerType getIntegerType(unsigned width)
StringAttr getStringAttr(const Twine &bytes)
NamedAttribute getNamedAttr(StringRef name, Attribute val)
A symbol reference with a reference path containing a single element.
This class represents a diagnostic that is inflight and set to be reported.
This class represents upper and lower bounds on the number of times a region of a RegionBranchOpInter...
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
MLIRContext is the top-level object for a collection of MLIR operations.
The OpAsmParser has methods for interacting with the asm parser: parsing things from it,...
virtual ParseResult parseRegion(Region ®ion, ArrayRef< Argument > arguments={}, bool enableNameShadowing=false)=0
Parses a region.
virtual ParseResult resolveOperand(const UnresolvedOperand &operand, Type type, SmallVectorImpl< Value > &result)=0
Resolve an operand to an SSA value, emitting an error on failure.
virtual ParseResult parseOperand(UnresolvedOperand &result, bool allowResultNumber=true)=0
Parse a single SSA value operand name along with a result number if allowResultNumber is true.
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
virtual void printNewline()=0
Print a newline and indent the printer to the start of the current operation.
virtual void printOptionalAttrDict(ArrayRef< NamedAttribute > attrs, ArrayRef< StringRef > elidedAttrs={})=0
If the specified operation has attributes, print out an attribute dictionary with their values.
virtual void printRegion(Region &blocks, bool printEntryBlockArgs=true, bool printBlockTerminators=true, bool printEmptyBlock=false)=0
Prints a region.
RAII guard to reset the insertion point of the builder when destroyed.
This class helps build Operations.
void setInsertionPointToStart(Block *block)
Sets the insertion point to the start of the specified block.
Block * createBlock(Region *parent, Region::iterator insertPt={}, TypeRange argTypes=std::nullopt, ArrayRef< Location > locs=std::nullopt)
Add new block with 'argTypes' arguments and set the insertion point to the end of it.
Operation * create(const OperationState &state)
Creates an operation given the fields represented as an OperationState.
This class represents a single result from folding an operation.
type_range getType() const
Operation is the basic unit of execution within MLIR.
OpResult getResult(unsigned idx)
Get the 'idx'th result of this operation.
Operation * getParentOp()
Returns the closest surrounding operation that contains this operation or nullptr if this is a top-le...
OperationName getName()
The name of an operation is the key identifier for it.
InFlightDiagnostic emitOpError(const Twine &message={})
Emit an error with the op name prefixed, like "'dim' op " which is convenient for verifiers.
unsigned getNumResults()
Return the number of results held by this operation.
This class implements Optional functionality for ParseResult.
bool has_value() const
Returns true if we contain a valid ParseResult value.
This class represents a point being branched from in the methods of the RegionBranchOpInterface.
bool isParent() const
Returns true if branching from the parent op.
This class provides an abstraction over the different types of ranges over Regions.
This class represents a successor of a region.
This class contains a list of basic blocks and a link to the parent operation it is attached to.
This class represents a collection of SymbolTables.
Operation * lookupNearestSymbolFrom(Operation *from, StringAttr symbol)
Returns the operation registered with the given symbol name within the closest parent operation of,...
static StringRef getSymbolAttrName()
Return the name of the attribute used for symbol names.
This class provides an abstraction over the various different ranges of value types.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Type getType() const
Return the type of this value.
Operation * getDefiningOp() const
If this value is the result of an operation, return the operation that defines it.
Base class for DenseArrayAttr that is instantiated and specialized for each supported element type be...
ArrayRef< T > asArrayRef() const
A named class for passing around the variadic flag.
mlir::Value getVar(mlir::Operation *accDataClauseOp)
Used to obtain the var from a data clause operation.
void addArgAndResultAttrs(Builder &builder, OperationState &result, ArrayRef< DictionaryAttr > argAttrs, ArrayRef< DictionaryAttr > resultAttrs, StringAttr argAttrsName, StringAttr resAttrsName)
Adds argument and result attributes, provided as argAttrs and resultAttrs arguments,...
constexpr void enumerate(std::tuple< Tys... > &tuple, CallbackT &&callback)
std::variant< StringRef, Placeholder > ReplacementItem
void buildTerminatedBody(OpBuilder &builder, Location loc)
Default callback for builders of ops carrying a region.
bool isSupportedFloatType(mlir::Type type)
Determines whether type is a valid floating-point type in EmitC.
bool isSupportedEmitCType(mlir::Type type)
Determines whether type is valid in EmitC.
bool isPointerWideType(mlir::Type type)
Determines whether type is a emitc.size_t/ssize_t type.
bool isIntegerIndexOrOpaqueType(Type type)
Determines whether type is integer like, i.e.
bool isSupportedIntegerType(mlir::Type type)
Determines whether type is a valid integer type in EmitC.
void printFunctionOp(OpAsmPrinter &p, FunctionOpInterface op, bool isVariadic, StringRef typeAttrName, StringAttr argAttrsName, StringAttr resAttrsName)
Printer implementation for function-like operations.
ParseResult parseFunctionOp(OpAsmParser &parser, OperationState &result, bool allowVariadic, StringAttr typeAttrName, FuncTypeBuilder funcTypeBuilder, StringAttr argAttrsName, StringAttr resAttrsName)
Parser implementation for function-like operations.
Operation::operand_range getIndices(Operation *op)
Get the indices that the given load/store operation is operating on.
QueryRef parse(llvm::StringRef line, const QuerySession &qs)
Include the generated interface declarations.
Type getType(OpFoldResult ofr)
Returns the int type of the integer in ofr.
std::conditional_t< std::is_same_v< Ty, mlir::Type >, mlir::Value, detail::TypedValue< Ty > > TypedValue
If Ty is mlir::Type this will select Value instead of having a wrapper around it.
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
LogicalResult verify(Operation *op, bool verifyRecursively=true)
Perform (potentially expensive) checks of invariants, used to detect compiler bugs,...
UnresolvedOperand ssaName
This is the representation of an operand reference.
This represents an operation in an abstracted form, suitable for use with the builder APIs.
SmallVector< Value, 4 > operands
void addOperands(ValueRange newOperands)
void addAttribute(StringRef name, Attribute attr)
Add an attribute with the specified name.
SmallVector< std::unique_ptr< Region >, 1 > regions
Regions that the op will hold.
Region * addRegion()
Create a region that should be attached to the operation.