31 #include "llvm/ADT/APFloat.h"
32 #include "llvm/ADT/APInt.h"
33 #include "llvm/ADT/ArrayRef.h"
34 #include "llvm/ADT/STLExtras.h"
35 #include "llvm/ADT/StringExtras.h"
36 #include "llvm/ADT/TypeSwitch.h"
37 #include "llvm/Support/InterleavedRange.h"
50 auto constOp = dyn_cast_or_null<spirv::ConstantOp>(op);
54 auto valueAttr = constOp.getValue();
55 auto integerValueAttr = llvm::dyn_cast<IntegerAttr>(valueAttr);
56 if (!integerValueAttr) {
60 if (integerValueAttr.getType().isSignlessInteger())
61 value = integerValueAttr.getInt();
63 value = integerValueAttr.getSInt();
70 spirv::MemorySemantics memorySemantics) {
77 auto atMostOneInSet = spirv::MemorySemantics::Acquire |
78 spirv::MemorySemantics::Release |
79 spirv::MemorySemantics::AcquireRelease |
80 spirv::MemorySemantics::SequentiallyConsistent;
83 llvm::popcount(
static_cast<uint32_t
>(memorySemantics & atMostOneInSet));
86 "expected at most one of these four memory constraints "
87 "to be set: `Acquire`, `Release`,"
88 "`AcquireRelease` or `SequentiallyConsistent`");
97 stringifyDecoration(spirv::Decoration::DescriptorSet));
98 auto bindingName = llvm::convertToSnakeFromCamelCase(
99 stringifyDecoration(spirv::Decoration::Binding));
102 if (descriptorSet && binding) {
105 printer <<
" bind(" << descriptorSet.getInt() <<
", " << binding.getInt()
110 auto builtInName = llvm::convertToSnakeFromCamelCase(
111 stringifyDecoration(spirv::Decoration::BuiltIn));
112 if (
auto builtin = op->
getAttrOfType<StringAttr>(builtInName)) {
113 printer <<
" " << builtInName <<
"(\"" << builtin.getValue() <<
"\")";
114 elidedAttrs.push_back(builtInName);
132 auto fnType = llvm::dyn_cast<FunctionType>(type);
134 parser.
emitError(loc,
"expected function type");
139 result.
addTypes(fnType.getResults());
150 assert(op->
getNumResults() == 1 &&
"op should have one result");
156 [&](
Type type) { return type != resultType; })) {
165 p <<
" : " << resultType;
168 template <
typename BlockReadWriteOpTy>
172 if (
auto valVecTy = llvm::dyn_cast<VectorType>(valType))
173 valType = valVecTy.getElementType();
176 llvm::cast<spirv::PointerType>(ptr.
getType()).getPointeeType()) {
177 return op.emitOpError(
"mismatch in result type and pointer type");
188 if (indices.empty()) {
189 emitErrorFn(
"expected at least one index for spirv.CompositeExtract");
193 for (
auto index : indices) {
194 if (
auto cType = llvm::dyn_cast<spirv::CompositeType>(type)) {
195 if (cType.hasCompileTimeKnownNumElements() &&
197 static_cast<uint64_t
>(index) >= cType.getNumElements())) {
198 emitErrorFn(
"index ") << index <<
" out of bounds for " << type;
201 type = cType.getElementType(index);
203 emitErrorFn(
"cannot extract from non-composite type ")
204 << type <<
" with index " << index;
214 auto indicesArrayAttr = llvm::dyn_cast<ArrayAttr>(indices);
215 if (!indicesArrayAttr) {
216 emitErrorFn(
"expected a 32-bit integer array attribute for 'indices'");
219 if (indicesArrayAttr.empty()) {
220 emitErrorFn(
"expected at least one index for spirv.CompositeExtract");
225 for (
auto indexAttr : indicesArrayAttr) {
226 auto indexIntAttr = llvm::dyn_cast<IntegerAttr>(indexAttr);
228 emitErrorFn(
"expected an 32-bit integer for index, but found '")
232 indexVals.push_back(indexIntAttr.getInt());
252 template <
typename ExtendedBinaryOp>
254 auto resultType = llvm::cast<spirv::StructType>(op.getType());
255 if (resultType.getNumElements() != 2)
256 return op.emitOpError(
"expected result struct type containing two members");
258 if (!llvm::all_equal({op.getOperand1().
getType(), op.getOperand2().getType(),
259 resultType.getElementType(0),
260 resultType.getElementType(1)}))
261 return op.emitOpError(
262 "expected all operand types and struct member types are the same");
279 auto structType = llvm::dyn_cast<spirv::StructType>(resultType);
280 if (!structType || structType.getNumElements() != 2)
281 return parser.
emitError(loc,
"expected spirv.struct type with two members");
301 return op->
emitError(
"expected the same type for the first operand and "
302 "result, but provided ")
314 spirv::GlobalVariableOp var) {
319 auto varOp = dyn_cast_or_null<spirv::GlobalVariableOp>(
323 return emitOpError(
"expected spirv.GlobalVariable symbol");
325 if (getPointer().
getType() != varOp.getType()) {
327 "result type mismatch with the referenced global variable's type");
337 operand_range constituents = this->getConstituents();
345 auto coopElementType =
348 [](
auto coopType) {
return coopType.getElementType(); })
349 .Default([](
Type) {
return nullptr; });
352 if (coopElementType) {
353 if (constituents.size() != 1)
354 return emitOpError(
"has incorrect number of operands: expected ")
355 <<
"1, but provided " << constituents.size();
356 if (coopElementType != constituents.front().getType())
357 return emitOpError(
"operand type mismatch: expected operand type ")
358 << coopElementType <<
", but provided "
359 << constituents.front().getType();
364 auto cType = llvm::cast<spirv::CompositeType>(
getType());
365 if (constituents.size() == cType.getNumElements()) {
366 for (
auto index : llvm::seq<uint32_t>(0, constituents.size())) {
367 if (constituents[index].
getType() != cType.getElementType(index)) {
368 return emitOpError(
"operand type mismatch: expected operand type ")
369 << cType.getElementType(index) <<
", but provided "
370 << constituents[index].getType();
377 auto resultType = llvm::dyn_cast<VectorType>(cType);
380 "expected to return a vector or cooperative matrix when the number of "
381 "constituents is less than what the result needs");
384 for (
Value component : constituents) {
385 if (!llvm::isa<VectorType>(component.getType()) &&
386 !component.getType().isIntOrFloat())
387 return emitOpError(
"operand type mismatch: expected operand to have "
388 "a scalar or vector type, but provided ")
389 << component.getType();
391 Type elementType = component.getType();
392 if (
auto vectorType = llvm::dyn_cast<VectorType>(component.getType())) {
393 sizes.push_back(vectorType.getNumElements());
394 elementType = vectorType.getElementType();
399 if (elementType != resultType.getElementType())
400 return emitOpError(
"operand element type mismatch: expected to be ")
401 << resultType.getElementType() <<
", but provided " << elementType;
403 unsigned totalCount = std::accumulate(sizes.begin(), sizes.end(), 0);
404 if (totalCount != cType.getNumElements())
405 return emitOpError(
"has incorrect number of operands: expected ")
406 << cType.getNumElements() <<
", but provided " << totalCount;
423 build(builder, state, elementType, composite, indexAttr);
430 StringRef indicesAttrName =
431 spirv::CompositeExtractOp::getIndicesAttrName(result.
name);
453 printer <<
' ' << getComposite() <<
getIndices() <<
" : "
458 auto indicesArrayAttr = llvm::dyn_cast<ArrayAttr>(
getIndices());
465 return emitOpError(
"invalid result type: expected ")
466 << resultType <<
" but provided " <<
getType();
480 build(builder, state, composite.
getType(),
object, composite, indexAttr);
486 Type objectType, compositeType;
488 StringRef indicesAttrName =
489 spirv::CompositeInsertOp::getIndicesAttrName(result.
name);
503 auto indicesArrayAttr = llvm::dyn_cast<ArrayAttr>(
getIndices());
509 if (objectType != getObject().
getType()) {
510 return emitOpError(
"object operand type should be ")
511 << objectType <<
", but found " << getObject().getType();
515 return emitOpError(
"result type should be the same as "
516 "the composite type, but found ")
517 << getComposite().getType() <<
" vs " <<
getType();
524 printer <<
" " << getObject() <<
", " << getComposite() <<
getIndices()
525 <<
" : " << getObject().
getType() <<
" into "
526 << getComposite().getType();
536 StringRef valueAttrName = spirv::ConstantOp::getValueAttrName(result.
name);
541 if (
auto typedAttr = llvm::dyn_cast<TypedAttr>(value))
542 type = typedAttr.getType();
543 if (llvm::isa<NoneType, TensorType>(type)) {
548 if (llvm::isa<TensorArmType>(type)) {
558 printer <<
' ' << getValue();
559 if (llvm::isa<spirv::ArrayType>(
getType()))
565 if (isa<spirv::CooperativeMatrixType>(opType)) {
566 auto denseAttr = dyn_cast<DenseElementsAttr>(value);
567 if (!denseAttr || !denseAttr.isSplat())
568 return op.emitOpError(
"expected a splat dense attribute for cooperative "
569 "matrix constant, but found ")
572 if (llvm::isa<IntegerAttr, FloatAttr>(value)) {
573 auto valueType = llvm::cast<TypedAttr>(value).getType();
574 if (valueType != opType)
575 return op.emitOpError(
"result type (")
576 << opType <<
") does not match value type (" << valueType <<
")";
579 if (llvm::isa<DenseIntOrFPElementsAttr, SparseElementsAttr>(value)) {
580 auto valueType = llvm::cast<TypedAttr>(value).getType();
581 if (valueType == opType)
583 auto arrayType = llvm::dyn_cast<spirv::ArrayType>(opType);
584 auto shapedType = llvm::dyn_cast<ShapedType>(valueType);
586 return op.emitOpError(
"result or element type (")
587 << opType <<
") does not match value type (" << valueType
588 <<
"), must be the same or spirv.array";
590 int numElements = arrayType.getNumElements();
591 auto opElemType = arrayType.getElementType();
592 while (
auto t = llvm::dyn_cast<spirv::ArrayType>(opElemType)) {
593 numElements *= t.getNumElements();
594 opElemType = t.getElementType();
596 if (!opElemType.isIntOrFloat())
597 return op.emitOpError(
"only support nested array result type");
599 auto valueElemType = shapedType.getElementType();
600 if (valueElemType != opElemType) {
601 return op.emitOpError(
"result element type (")
602 << opElemType <<
") does not match value element type ("
603 << valueElemType <<
")";
606 if (numElements != shapedType.getNumElements()) {
607 return op.emitOpError(
"result number of elements (")
608 << numElements <<
") does not match value number of elements ("
609 << shapedType.getNumElements() <<
")";
613 if (
auto arrayAttr = llvm::dyn_cast<ArrayAttr>(value)) {
614 auto arrayType = llvm::dyn_cast<spirv::ArrayType>(opType);
616 return op.emitOpError(
617 "must have spirv.array result type for array value");
618 Type elemType = arrayType.getElementType();
619 for (
Attribute element : arrayAttr.getValue()) {
626 return op.emitOpError(
"cannot have attribute: ") << value;
636 bool spirv::ConstantOp::isBuildableWith(
Type type) {
638 if (!llvm::isa<spirv::SPIRVType>(type))
643 return llvm::isa<spirv::ArrayType>(type);
651 if (
auto intType = llvm::dyn_cast<IntegerType>(type)) {
652 unsigned width = intType.getWidth();
654 return spirv::ConstantOp::create(builder, loc, type,
656 return spirv::ConstantOp::create(
657 builder, loc, type, builder.
getIntegerAttr(type, APInt(width, 0)));
659 if (
auto floatType = llvm::dyn_cast<FloatType>(type)) {
660 return spirv::ConstantOp::create(builder, loc, type,
663 if (
auto vectorType = llvm::dyn_cast<VectorType>(type)) {
664 Type elemType = vectorType.getElementType();
665 if (llvm::isa<IntegerType>(elemType)) {
666 return spirv::ConstantOp::create(
671 if (llvm::isa<FloatType>(elemType)) {
672 return spirv::ConstantOp::create(
679 llvm_unreachable(
"unimplemented types for ConstantOp::getZero()");
682 spirv::ConstantOp spirv::ConstantOp::getOne(
Type type,
Location loc,
684 if (
auto intType = llvm::dyn_cast<IntegerType>(type)) {
685 unsigned width = intType.getWidth();
687 return spirv::ConstantOp::create(builder, loc, type,
689 return spirv::ConstantOp::create(
690 builder, loc, type, builder.
getIntegerAttr(type, APInt(width, 1)));
692 if (
auto floatType = llvm::dyn_cast<FloatType>(type)) {
693 return spirv::ConstantOp::create(builder, loc, type,
696 if (
auto vectorType = llvm::dyn_cast<VectorType>(type)) {
697 Type elemType = vectorType.getElementType();
698 if (llvm::isa<IntegerType>(elemType)) {
699 return spirv::ConstantOp::create(
704 if (llvm::isa<FloatType>(elemType)) {
705 return spirv::ConstantOp::create(
712 llvm_unreachable(
"unimplemented types for ConstantOp::getOne()");
715 void mlir::spirv::ConstantOp::getAsmResultNames(
720 llvm::raw_svector_ostream specialName(specialNameBuffer);
721 specialName <<
"cst";
723 IntegerType intTy = llvm::dyn_cast<IntegerType>(type);
725 if (IntegerAttr intCst = llvm::dyn_cast<IntegerAttr>(getValue())) {
728 if (intTy.getWidth() == 1) {
729 return setNameFn(getResult(), (intCst.getInt() ?
"true" :
"false"));
732 if (intTy.isSignless()) {
733 specialName << intCst.getInt();
734 }
else if (intTy.isUnsigned()) {
735 specialName << intCst.getUInt();
737 specialName << intCst.getSInt();
741 if (intTy || llvm::isa<FloatType>(type)) {
742 specialName <<
'_' << type;
745 if (
auto vecType = llvm::dyn_cast<VectorType>(type)) {
746 specialName <<
"_vec_";
747 specialName << vecType.getDimSize(0);
749 Type elementType = vecType.getElementType();
751 if (llvm::isa<IntegerType>(elementType) ||
752 llvm::isa<FloatType>(elementType)) {
753 specialName <<
"x" << elementType;
757 setNameFn(getResult(), specialName.str());
760 void mlir::spirv::AddressOfOp::getAsmResultNames(
763 llvm::raw_svector_ostream specialName(specialNameBuffer);
764 specialName << getVariable() <<
"_addr";
765 setNameFn(getResult(), specialName.str());
776 if (
auto typedAttr = dyn_cast<TypedAttr>(attr)) {
777 return typedAttr.getType();
780 if (
auto arrayAttr = dyn_cast<ArrayAttr>(attr)) {
790 return emitError(
"unknown value attribute type");
792 auto compositeType = dyn_cast<spirv::CompositeType>(
getType());
794 return emitError(
"result type is not a composite type");
796 Type compositeElementType = compositeType.getElementType(0);
799 while (
auto type = dyn_cast<spirv::CompositeType>(compositeElementType)) {
800 compositeElementType = type.getElementType(0);
801 possibleTypes.push_back(compositeElementType);
804 if (!is_contained(possibleTypes, valueType)) {
805 return emitError(
"expected value attribute type ")
806 << interleaved(possibleTypes,
" or ") <<
", but got: " << valueType;
825 spirv::ExecutionModel executionModel,
826 spirv::FuncOp
function,
828 build(builder, state,
835 spirv::ExecutionModel execModel;
839 if (parseEnumStrAttr<spirv::ExecutionModelAttr>(execModel, parser, result) ||
848 FlatSymbolRefAttr var;
850 if (parser.parseAttribute(var, Type(),
"var_symbol", attrs))
852 interfaceVars.push_back(var);
865 auto interfaceVars = getInterface().getValue();
866 if (!interfaceVars.empty())
867 printer <<
", " << llvm::interleaved(interfaceVars);
881 spirv::FuncOp
function,
882 spirv::ExecutionMode executionMode,
891 spirv::ExecutionMode execMode;
894 parseEnumStrAttr<spirv::ExecutionModeAttr>(execMode, parser, result)) {
906 values.push_back(llvm::cast<IntegerAttr>(value).getInt());
908 StringRef valuesAttrName =
909 spirv::ExecutionModeOp::getValuesAttrName(result.
name);
918 printer <<
" \"" << stringifyExecutionMode(getExecutionMode()) <<
"\"";
919 ArrayAttr values = this->getValues();
921 printer <<
", " << llvm::interleaved(values.getAsValueRange<IntegerAttr>());
941 bool isVariadic =
false;
943 parser,
false, entryArgs, isVariadic, resultTypes,
948 for (
auto &arg : entryArgs)
949 argTypes.push_back(arg.type);
955 spirv::FunctionControl fnControl;
956 if (parseEnumStrAttr<spirv::FunctionControlAttr>(fnControl, parser, result))
964 assert(resultAttrs.size() == resultTypes.size());
966 builder, result, entryArgs, resultAttrs, getArgAttrsAttrName(result.
name),
967 getResAttrsAttrName(result.
name));
980 auto fnType = getFunctionType();
982 printer, *
this, fnType.getInputs(),
983 false, fnType.getResults());
984 printer <<
" \"" << spirv::stringifyFunctionControl(getFunctionControl())
988 {spirv::attributeName<spirv::FunctionControl>(),
989 getFunctionTypeAttrName(), getArgAttrsAttrName(), getResAttrsAttrName(),
990 getFunctionControlAttrName()});
993 Region &body = this->getBody();
1001 LogicalResult spirv::FuncOp::verifyType() {
1002 FunctionType fnType = getFunctionType();
1003 if (fnType.getNumResults() > 1)
1004 return emitOpError(
"cannot have more than one result");
1006 auto hasDecorationAttr = [&](spirv::Decoration decoration,
1007 unsigned argIndex) {
1008 auto func = llvm::cast<FunctionOpInterface>(getOperation());
1009 for (
auto argAttr : cast<FunctionOpInterface>(func).
getArgAttrs(argIndex)) {
1010 if (argAttr.getName() != spirv::DecorationAttr::name)
1012 if (
auto decAttr = dyn_cast<spirv::DecorationAttr>(argAttr.getValue()))
1013 return decAttr.getValue() == decoration;
1018 for (
unsigned i = 0, e = this->getNumArguments(); i != e; ++i) {
1019 Type param = fnType.getInputs()[i];
1020 auto inputPtrType = dyn_cast<spirv::PointerType>(param);
1024 auto pointeePtrType =
1025 dyn_cast<spirv::PointerType>(inputPtrType.getPointeeType());
1026 if (pointeePtrType) {
1032 if (pointeePtrType.getStorageClass() !=
1033 spirv::StorageClass::PhysicalStorageBuffer)
1036 bool hasAliasedPtr =
1037 hasDecorationAttr(spirv::Decoration::AliasedPointer, i);
1038 bool hasRestrictPtr =
1039 hasDecorationAttr(spirv::Decoration::RestrictPointer, i);
1040 if (!hasAliasedPtr && !hasRestrictPtr)
1041 return emitOpError()
1042 <<
"with a pointer points to a physical buffer pointer must "
1043 "be decorated either 'AliasedPointer' or 'RestrictPointer'";
1050 if (
auto pointeeArrayType =
1051 dyn_cast<spirv::ArrayType>(inputPtrType.getPointeeType())) {
1053 dyn_cast<spirv::PointerType>(pointeeArrayType.getElementType());
1055 pointeePtrType = inputPtrType;
1058 if (!pointeePtrType || pointeePtrType.getStorageClass() !=
1059 spirv::StorageClass::PhysicalStorageBuffer)
1062 bool hasAliased = hasDecorationAttr(spirv::Decoration::Aliased, i);
1063 bool hasRestrict = hasDecorationAttr(spirv::Decoration::Restrict, i);
1064 if (!hasAliased && !hasRestrict)
1065 return emitOpError() <<
"with physical buffer pointer must be decorated "
1066 "either 'Aliased' or 'Restrict'";
1072 LogicalResult spirv::FuncOp::verifyBody() {
1073 FunctionType fnType = getFunctionType();
1074 if (!isExternal()) {
1075 Block &entryBlock = front();
1077 unsigned numArguments = this->getNumArguments();
1079 return emitOpError(
"entry block must have ")
1080 << numArguments <<
" arguments to match function signature";
1082 for (
auto [index, fnArgType, blockArgType] :
1084 if (blockArgType != fnArgType) {
1085 return emitOpError(
"type of entry block argument #")
1086 << index <<
'(' << blockArgType
1087 <<
") must match the type of the corresponding argument in "
1088 <<
"function signature(" << fnArgType <<
')';
1094 if (
auto retOp = dyn_cast<spirv::ReturnOp>(op)) {
1095 if (fnType.getNumResults() != 0)
1096 return retOp.emitOpError(
"cannot be used in functions returning value");
1097 }
else if (
auto retOp = dyn_cast<spirv::ReturnValueOp>(op)) {
1098 if (fnType.getNumResults() != 1)
1099 return retOp.emitOpError(
1100 "returns 1 value but enclosing function requires ")
1101 << fnType.getNumResults() <<
" results";
1103 auto retOperandType = retOp.getValue().getType();
1104 auto fnResultType = fnType.getResult(0);
1105 if (retOperandType != fnResultType)
1106 return retOp.emitOpError(
" return value's type (")
1107 << retOperandType <<
") mismatch with function's result type ("
1108 << fnResultType <<
")";
1115 return failure(walkResult.wasInterrupted());
1119 StringRef name, FunctionType type,
1120 spirv::FunctionControl control,
1124 state.addAttribute(getFunctionTypeAttrName(state.name),
TypeAttr::get(type));
1125 state.addAttribute(spirv::attributeName<spirv::FunctionControl>(),
1126 builder.
getAttr<spirv::FunctionControlAttr>(control));
1127 state.attributes.append(attrs.begin(), attrs.end());
1175 Type type, StringRef name,
1176 unsigned descriptorSet,
unsigned binding) {
1179 spirv::SPIRVDialect::getAttributeName(spirv::Decoration::DescriptorSet),
1182 spirv::SPIRVDialect::getAttributeName(spirv::Decoration::Binding),
1187 Type type, StringRef name,
1188 spirv::BuiltIn builtin) {
1191 spirv::SPIRVDialect::getAttributeName(spirv::Decoration::BuiltIn),
1198 StringAttr nameAttr;
1199 StringRef initializerAttrName =
1200 spirv::GlobalVariableOp::getInitializerAttrName(result.
name);
1221 StringRef typeAttrName =
1222 spirv::GlobalVariableOp::getTypeAttrName(result.
name);
1227 if (!llvm::isa<spirv::PointerType>(type)) {
1228 return parser.
emitError(loc,
"expected spirv.ptr type");
1237 spirv::attributeName<spirv::StorageClass>()};
1244 StringRef initializerAttrName = this->getInitializerAttrName();
1246 if (
auto initializer = this->getInitializer()) {
1247 printer <<
" " << initializerAttrName <<
'(';
1250 elidedAttrs.push_back(initializerAttrName);
1253 StringRef typeAttrName = this->getTypeAttrName();
1254 elidedAttrs.push_back(typeAttrName);
1256 printer <<
" : " <<
getType();
1260 if (!llvm::isa<spirv::PointerType>(
getType()))
1261 return emitOpError(
"result must be of a !spv.ptr type");
1267 auto storageClass = this->storageClass();
1268 if (storageClass == spirv::StorageClass::Generic ||
1269 storageClass == spirv::StorageClass::Function) {
1270 return emitOpError(
"storage class cannot be '")
1271 << stringifyStorageClass(storageClass) <<
"'";
1275 this->getInitializerAttrName())) {
1277 (*this)->getParentOp(), init.getAttr());
1281 if (!initOp || !isa<spirv::GlobalVariableOp, spirv::SpecConstantOp,
1282 spirv::SpecConstantCompositeOp>(initOp)) {
1283 return emitOpError(
"initializer must be result of a "
1284 "spirv.SpecConstant or spirv.GlobalVariable or "
1285 "spirv.SpecConstantCompositeOp op");
1310 spirv::StorageClass storageClass;
1321 if (
auto valVecTy = llvm::dyn_cast<VectorType>(elementType))
1332 printer <<
" " << getPtr() <<
", " << getValue() <<
" : "
1333 << getValue().getType();
1424 std::optional<StringRef> name) {
1434 spirv::AddressingModel addressingModel,
1435 spirv::MemoryModel memoryModel,
1436 std::optional<VerCapExtAttr> vceTriple,
1437 std::optional<StringRef> name) {
1440 builder.
getAttr<spirv::AddressingModelAttr>(addressingModel));
1441 state.addAttribute(
"memory_model",
1442 builder.
getAttr<spirv::MemoryModelAttr>(memoryModel));
1446 state.addAttribute(getVCETripleAttrName(), *vceTriple);
1457 StringAttr nameAttr;
1462 spirv::AddressingModel addrModel;
1463 spirv::MemoryModel memoryModel;
1464 if (spirv::parseEnumKeywordAttr<spirv::AddressingModelAttr>(addrModel, parser,
1466 spirv::parseEnumKeywordAttr<spirv::MemoryModelAttr>(memoryModel, parser,
1473 spirv::ModuleOp::getVCETripleAttrName(),
1490 if (std::optional<StringRef> name = getName()) {
1499 auto addressingModelAttrName = spirv::attributeName<spirv::AddressingModel>();
1500 auto memoryModelAttrName = spirv::attributeName<spirv::MemoryModel>();
1501 elidedAttrs.assign({addressingModelAttrName, memoryModelAttrName,
1504 if (std::optional<spirv::VerCapExtAttr> triple = getVceTriple()) {
1505 printer <<
" requires " << *triple;
1506 elidedAttrs.push_back(spirv::ModuleOp::getVCETripleAttrName());
1514 LogicalResult spirv::ModuleOp::verifyRegions() {
1515 Dialect *dialect = (*this)->getDialect();
1520 for (
auto &op : *getBody()) {
1522 return op.
emitError(
"'spirv.module' can only contain spirv.* ops");
1527 if (
auto entryPointOp = dyn_cast<spirv::EntryPointOp>(op)) {
1528 auto funcOp =
table.lookup<spirv::FuncOp>(entryPointOp.getFn());
1530 return entryPointOp.emitError(
"function '")
1531 << entryPointOp.getFn() <<
"' not found in 'spirv.module'";
1533 if (
auto interface = entryPointOp.getInterface()) {
1535 auto varSymRef = llvm::dyn_cast<FlatSymbolRefAttr>(varRef);
1537 return entryPointOp.emitError(
1538 "expected symbol reference for interface "
1539 "specification instead of '")
1543 table.lookup<spirv::GlobalVariableOp>(varSymRef.getValue());
1545 return entryPointOp.emitError(
"expected spirv.GlobalVariable "
1546 "symbol reference instead of'")
1547 << varSymRef <<
"'";
1552 auto key = std::pair<spirv::FuncOp, spirv::ExecutionModel>(
1553 funcOp, entryPointOp.getExecutionModel());
1554 if (!entryPoints.try_emplace(key, entryPointOp).second)
1555 return entryPointOp.emitError(
"duplicate of a previous EntryPointOp");
1556 }
else if (
auto funcOp = dyn_cast<spirv::FuncOp>(op)) {
1560 auto linkageAttr = funcOp.getLinkageAttributes();
1561 auto hasImportLinkage =
1562 linkageAttr && (linkageAttr.value().getLinkageType().getValue() ==
1563 spirv::LinkageType::Import);
1564 if (funcOp.isExternal() && !hasImportLinkage)
1566 "'spirv.module' cannot contain external functions "
1567 "without 'Import' linkage_attributes (LinkageAttributes)");
1570 for (
auto &block : funcOp)
1571 for (
auto &op : block) {
1574 "functions in 'spirv.module' can only contain spirv.* ops");
1588 (*this)->getParentOp(), getSpecConstAttr());
1591 auto specConstOp = dyn_cast_or_null<spirv::SpecConstantOp>(specConstSym);
1593 constType = specConstOp.getDefaultValue().getType();
1595 auto specConstCompositeOp =
1596 dyn_cast_or_null<spirv::SpecConstantCompositeOp>(specConstSym);
1597 if (specConstCompositeOp)
1598 constType = specConstCompositeOp.getType();
1600 if (!specConstOp && !specConstCompositeOp)
1602 "expected spirv.SpecConstant or spirv.SpecConstantComposite symbol");
1604 if (getReference().
getType() != constType)
1605 return emitOpError(
"result type mismatch with the referenced "
1606 "specialization constant's type");
1617 StringAttr nameAttr;
1619 StringRef defaultValueAttrName =
1620 spirv::SpecConstantOp::getDefaultValueAttrName(result.
name);
1628 IntegerAttr specIdAttr;
1645 if (
auto specID = (*this)->getAttrOfType<IntegerAttr>(
kSpecIdAttrName))
1647 printer <<
" = " << getDefaultValue();
1651 if (
auto specID = (*this)->getAttrOfType<IntegerAttr>(
kSpecIdAttrName))
1652 if (specID.getValue().isNegative())
1653 return emitOpError(
"SpecId cannot be negative");
1655 auto value = getDefaultValue();
1656 if (llvm::isa<IntegerAttr, FloatAttr>(value)) {
1658 if (!llvm::isa<spirv::SPIRVType>(value.getType()))
1659 return emitOpError(
"default value bitwidth disallowed");
1663 "default value can only be a bool, integer, or float scalar");
1671 VectorType resultType = llvm::cast<VectorType>(
getType());
1673 size_t numResultElements = resultType.getNumElements();
1674 if (numResultElements != getComponents().size())
1675 return emitOpError(
"result type element count (")
1676 << numResultElements
1677 <<
") mismatch with the number of component selectors ("
1678 << getComponents().size() <<
")";
1680 size_t totalSrcElements =
1681 llvm::cast<VectorType>(getVector1().
getType()).getNumElements() +
1682 llvm::cast<VectorType>(getVector2().
getType()).getNumElements();
1684 for (
const auto &selector : getComponents().getAsValueRange<IntegerAttr>()) {
1685 uint32_t index = selector.getZExtValue();
1686 if (index >= totalSrcElements &&
1687 index != std::numeric_limits<uint32_t>().
max())
1688 return emitOpError(
"component selector ")
1689 << index <<
" out of range: expected to be in [0, "
1690 << totalSrcElements <<
") or 0xffffffff";
1703 [](
auto matrixType) {
return matrixType.getElementType(); })
1704 .Default([](
Type) {
return nullptr; });
1706 assert(elementType &&
"Unhandled type");
1709 if (getScalar().
getType() != elementType)
1710 return emitOpError(
"input matrix components' type and scaling value must "
1711 "have the same type");
1721 auto inputMatrix = llvm::cast<spirv::MatrixType>(getMatrix().
getType());
1722 auto resultMatrix = llvm::cast<spirv::MatrixType>(getResult().
getType());
1725 if (inputMatrix.getNumRows() != resultMatrix.getNumColumns())
1726 return emitError(
"input matrix rows count must be equal to "
1727 "output matrix columns count");
1729 if (inputMatrix.getNumColumns() != resultMatrix.getNumRows())
1730 return emitError(
"input matrix columns count must be equal to "
1731 "output matrix rows count");
1734 if (inputMatrix.getElementType() != resultMatrix.getElementType())
1735 return emitError(
"input and output matrices must have the same "
1746 auto matrixType = llvm::cast<spirv::MatrixType>(getMatrix().
getType());
1747 auto vectorType = llvm::cast<VectorType>(getVector().
getType());
1748 auto resultType = llvm::cast<VectorType>(
getType());
1750 if (matrixType.getNumColumns() != vectorType.getNumElements())
1751 return emitOpError(
"matrix columns (")
1752 << matrixType.getNumColumns() <<
") must match vector operand size ("
1753 << vectorType.getNumElements() <<
")";
1755 if (resultType.getNumElements() != matrixType.getNumRows())
1756 return emitOpError(
"result size (")
1757 << resultType.getNumElements() <<
") must match the matrix rows ("
1758 << matrixType.getNumRows() <<
")";
1760 if (matrixType.getElementType() != resultType.getElementType())
1761 return emitOpError(
"matrix and result element types must match");
1771 auto vectorType = llvm::cast<VectorType>(getVector().
getType());
1772 auto matrixType = llvm::cast<spirv::MatrixType>(getMatrix().
getType());
1773 auto resultType = llvm::cast<VectorType>(
getType());
1775 if (matrixType.getNumRows() != vectorType.getNumElements())
1776 return emitOpError(
"number of components in vector must equal the number "
1777 "of components in each column in matrix");
1779 if (resultType.getNumElements() != matrixType.getNumColumns())
1780 return emitOpError(
"number of columns in matrix must equal the number of "
1781 "components in result");
1783 if (matrixType.getElementType() != resultType.getElementType())
1784 return emitOpError(
"matrix must be a matrix with the same component type "
1785 "as the component type in result");
1795 auto leftMatrix = llvm::cast<spirv::MatrixType>(getLeftmatrix().
getType());
1796 auto rightMatrix = llvm::cast<spirv::MatrixType>(getRightmatrix().
getType());
1797 auto resultMatrix = llvm::cast<spirv::MatrixType>(getResult().
getType());
1800 if (leftMatrix.getNumColumns() != rightMatrix.getNumRows())
1801 return emitError(
"left matrix columns' count must be equal to "
1802 "the right matrix rows' count");
1805 if (rightMatrix.getNumColumns() != resultMatrix.getNumColumns())
1807 "right and result matrices must have equal columns' count");
1810 if (rightMatrix.getElementType() != resultMatrix.getElementType())
1811 return emitError(
"right and result matrices' component type must"
1815 if (leftMatrix.getElementType() != resultMatrix.getElementType())
1816 return emitError(
"left and result matrices' component type"
1817 " must be the same");
1820 if (leftMatrix.getNumRows() != resultMatrix.getNumRows())
1821 return emitError(
"left and result matrices must have equal rows' count");
1833 StringAttr compositeName;
1845 const char *attrName =
"spec_const";
1852 constituents.push_back(specConstRef);
1858 StringAttr compositeSpecConstituentsName =
1859 spirv::SpecConstantCompositeOp::getConstituentsAttrName(result.
name);
1867 StringAttr typeAttrName =
1868 spirv::SpecConstantCompositeOp::getTypeAttrName(result.
name);
1877 printer <<
" (" << llvm::interleaved(this->getConstituents().getValue())
1882 auto cType = llvm::dyn_cast<spirv::CompositeType>(
getType());
1883 auto constituents = this->getConstituents().getValue();
1886 return emitError(
"result type must be a composite type, but provided ")
1889 if (llvm::isa<spirv::CooperativeMatrixType>(cType))
1890 return emitError(
"unsupported composite type ") << cType;
1891 if (constituents.size() != cType.getNumElements())
1892 return emitError(
"has incorrect number of operands: expected ")
1893 << cType.getNumElements() <<
", but provided "
1894 << constituents.size();
1896 for (
auto index : llvm::seq<uint32_t>(0, constituents.size())) {
1897 auto constituent = llvm::cast<FlatSymbolRefAttr>(constituents[index]);
1899 auto constituentSpecConstOp =
1901 (*this)->getParentOp(), constituent.getAttr()));
1903 if (constituentSpecConstOp.getDefaultValue().getType() !=
1904 cType.getElementType(index))
1905 return emitError(
"has incorrect types of operands: expected ")
1906 << cType.getElementType(index) <<
", but provided "
1907 << constituentSpecConstOp.getDefaultValue().getType();
1920 StringAttr compositeName;
1922 const char *attrName =
"spec_const";
1933 StringAttr compositeSpecConstituentName =
1934 spirv::EXTSpecConstantCompositeReplicateOp::getConstituentAttrName(
1936 result.
addAttribute(compositeSpecConstituentName, specConstRef);
1938 StringAttr typeAttrName =
1939 spirv::EXTSpecConstantCompositeReplicateOp::getTypeAttrName(result.
name);
1948 printer <<
" (" << this->getConstituent() <<
") : " <<
getType();
1952 auto compositeType = dyn_cast<spirv::CompositeType>(
getType());
1954 return emitError(
"result type must be a composite type, but provided ")
1958 (*this)->getParentOp(), this->getConstituent());
1961 "splat spec constant reference defining constituent not found");
1963 auto constituentSpecConstOp = dyn_cast<spirv::SpecConstantOp>(constituentOp);
1964 if (!constituentSpecConstOp)
1965 return emitError(
"constituent is not a spec constant");
1967 Type constituentType = constituentSpecConstOp.getDefaultValue().getType();
1968 Type compositeElementType = compositeType.getElementType(0);
1969 if (constituentType != compositeElementType)
1970 return emitError(
"constituent has incorrect type: expected ")
1971 << compositeElementType <<
", but provided " << constituentType;
1996 spirv::YieldOp::create(builder, wrappedOp->
getLoc(), wrappedOp->
getResult(0));
2008 printer <<
" wraps ";
2012 LogicalResult spirv::SpecConstantOperationOp::verifyRegions() {
2013 Block &block = getRegion().getBlocks().
front();
2016 return emitOpError(
"expected exactly 2 nested ops");
2021 return emitOpError(
"invalid enclosed op");
2024 if (!isa<spirv::ConstantOp, spirv::ReferenceOfOp,
2025 spirv::SpecConstantOperationOp>(operand.getDefiningOp()))
2027 "invalid operand, must be defined by a constant operation");
2038 llvm::dyn_cast<spirv::StructType>(getResult().
getType());
2041 return emitError(
"result type must be a struct type with two memebers");
2045 VectorType exponentVecTy = llvm::dyn_cast<VectorType>(exponentTy);
2046 IntegerType exponentIntTy = llvm::dyn_cast<IntegerType>(exponentTy);
2048 Type operandTy = getOperand().getType();
2049 VectorType operandVecTy = llvm::dyn_cast<VectorType>(operandTy);
2050 FloatType operandFTy = llvm::dyn_cast<FloatType>(operandTy);
2052 if (significandTy != operandTy)
2053 return emitError(
"member zero of the resulting struct type must be the "
2054 "same type as the operand");
2056 if (exponentVecTy) {
2057 IntegerType componentIntTy =
2058 llvm::dyn_cast<IntegerType>(exponentVecTy.getElementType());
2059 if (!componentIntTy || componentIntTy.getWidth() != 32)
2060 return emitError(
"member one of the resulting struct type must"
2061 "be a scalar or vector of 32 bit integer type");
2062 }
else if (!exponentIntTy || exponentIntTy.getWidth() != 32) {
2063 return emitError(
"member one of the resulting struct type "
2064 "must be a scalar or vector of 32 bit integer type");
2068 if (operandVecTy && exponentVecTy &&
2069 (exponentVecTy.getNumElements() == operandVecTy.getNumElements()))
2072 if (operandFTy && exponentIntTy)
2075 return emitError(
"member one of the resulting struct type must have the same "
2076 "number of components as the operand type");
2084 Type significandType = getX().getType();
2085 Type exponentType = getExp().getType();
2087 if (llvm::isa<FloatType>(significandType) !=
2088 llvm::isa<IntegerType>(exponentType))
2089 return emitOpError(
"operands must both be scalars or vectors");
2092 if (
auto vectorType = llvm::dyn_cast<VectorType>(type))
2093 return vectorType.getNumElements();
2098 return emitOpError(
"operands must have the same number of elements");
2133 return emitOpError(
"vector operand and result type mismatch");
2134 auto scalarType = llvm::cast<VectorType>(
getType()).getElementType();
2135 if (getScalar().
getType() != scalarType)
2136 return emitOpError(
"scalar operand and result element type match");
static std::string bindingName()
Returns the string name of the Binding decoration.
static std::string descriptorSetName()
Returns the string name of the DescriptorSet decoration.
static Value getZero(OpBuilder &b, Location loc, Type elementType)
Get zero value for an element type.
static int64_t getNumElements(Type t)
Compute the total number of elements in the given type, also taking into account nested types.
static Value max(ImplicitLocOpBuilder &builder, Value value, Value bound)
static void print(spirv::VerCapExtAttr triple, DialectAsmPrinter &printer)
static ParseResult parseArithmeticExtendedBinaryOp(OpAsmParser &parser, OperationState &result)
static LogicalResult verifyConstantType(spirv::ConstantOp op, Attribute value, Type opType)
static ParseResult parseOneResultSameOperandTypeOp(OpAsmParser &parser, OperationState &result)
static LogicalResult verifyArithmeticExtendedBinaryOp(ExtendedBinaryOp op)
static LogicalResult verifyShiftOp(Operation *op)
static LogicalResult verifyBlockReadWritePtrAndValTypes(BlockReadWriteOpTy op, Value ptr, Value val)
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 void printOneResultOp(Operation *op, OpAsmPrinter &p)
static void printArithmeticExtendedBinaryOp(Operation *op, OpAsmPrinter &printer)
ParseResult parseSymbolName(StringAttr &result)
Parse an -identifier and store it (without the '@' symbol) in a string attribute.
virtual ParseResult parseOptionalSymbolName(StringAttr &result)=0
Parse an optional -identifier and store it (without the '@' symbol) in a string attribute.
virtual ParseResult parseCommaSeparatedList(Delimiter delimiter, function_ref< ParseResult()> parseElementFn, StringRef contextMessage=StringRef())=0
Parse a list of comma-separated items with an optional delimiter.
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 parseOptionalKeyword(StringRef keyword)=0
Parse the given keyword if present.
MLIRContext * getContext() const
virtual ParseResult parseRParen()=0
Parse a ) token.
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 addTypeToList(Type type, SmallVectorImpl< Type > &result)
Add the specified type to the end of the specified type list and return success.
virtual ParseResult parseEqual()=0
Parse a = token.
virtual ParseResult parseOptionalAttrDictWithKeyword(NamedAttrList &result)=0
Parse a named dictionary into 'result' if the attributes keyword is present.
virtual ParseResult parseColonType(Type &result)=0
Parse a colon followed by a type.
virtual SMLoc getCurrentLocation()=0
Get the location of the next token and store it into the argument.
virtual ParseResult parseOptionalComma()=0
Parse a , token if present.
virtual ParseResult parseColon()=0
Parse a : token.
ParseResult addTypesToList(ArrayRef< Type > types, SmallVectorImpl< Type > &result)
Add the specified types to the end of the specified type list and return success.
virtual ParseResult parseLParen()=0
Parse a ( token.
virtual ParseResult parseType(Type &result)=0
Parse a type.
virtual ParseResult parseOptionalLParen()=0
Parse a ( token if present.
ParseResult parseKeywordType(const char *keyword, Type &result)
Parse a keyword followed by 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.
virtual void printSymbolName(StringRef symbolRef)
Print the given string as a symbol reference, i.e.
Attributes are known-constant values of operations.
Block represents an ordered list of Operations.
ValueTypeRange< BlockArgListType > getArgumentTypes()
Return a range containing the types of the arguments for this block.
unsigned getNumArguments()
OpListType & getOperations()
IntegerAttr getI32IntegerAttr(int32_t value)
IntegerAttr getIntegerAttr(Type type, int64_t value)
ArrayAttr getI32ArrayAttr(ArrayRef< int32_t > values)
FloatAttr getFloatAttr(Type type, double value)
FunctionType getFunctionType(TypeRange inputs, TypeRange results)
IntegerType getIntegerType(unsigned width)
BoolAttr getBoolAttr(bool value)
StringAttr getStringAttr(const Twine &bytes)
MLIRContext * getContext() const
ArrayAttr getArrayAttr(ArrayRef< Attribute > value)
Attr getAttr(Args &&...args)
Get or construct an instance of the attribute Attr with provided arguments.
static DenseElementsAttr get(ShapedType type, ArrayRef< Attribute > values)
Constructs a dense elements attribute from an array of element values.
static DenseFPElementsAttr get(const ShapedType &type, Arg &&arg)
Get an instance of a DenseFPElementsAttr with the given arguments.
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
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 defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work t...
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 OptionalParseResult parseOptionalRegion(Region ®ion, ArrayRef< Argument > arguments={}, bool enableNameShadowing=false)=0
Parses a region if present.
ParseResult resolveOperands(Operands &&operands, Type type, SmallVectorImpl< Value > &result)
Resolve a list of operands to SSA values, emitting an error on failure, or appending the results to t...
virtual Operation * parseGenericOperation(Block *insertBlock, Block::iterator insertPt)=0
Parse an operation in its generic form.
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.
virtual ParseResult parseOperandList(SmallVectorImpl< UnresolvedOperand > &result, Delimiter delimiter=Delimiter::None, bool allowResultNumber=true, int requiredOperandCount=-1)=0
Parse zero or more SSA comma-separated operand references with a specified surrounding delimiter,...
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
void printOperands(const ContainerType &container)
Print a comma separated list of operands.
virtual void printOptionalAttrDictWithKeyword(ArrayRef< NamedAttribute > attrs, ArrayRef< StringRef > elidedAttrs={})=0
If the specified operation has attributes, print out an attribute dictionary prefixed with 'attribute...
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 printGenericOp(Operation *op, bool printOpName=true)=0
Print the entire operation with the default generic assembly form.
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.
Block * createBlock(Region *parent, Region::iterator insertPt={}, TypeRange argTypes={}, ArrayRef< Location > locs={})
Add new block with 'argTypes' arguments and set the insertion point to the end of it.
void setInsertionPointToEnd(Block *block)
Sets the insertion point to the end of the specified block.
A trait to mark ops that can be enclosed/wrapped in a SpecConstantOperation op.
type_range getType() const
Operation is the basic unit of execution within MLIR.
Value getOperand(unsigned idx)
bool hasTrait()
Returns true if the operation was registered with a particular trait, e.g.
Dialect * getDialect()
Return the dialect this operation is associated with, or nullptr if the associated dialect is not loa...
AttrClass getAttrOfType(StringAttr name)
OpResult getResult(unsigned idx)
Get the 'idx'th result of this operation.
Location getLoc()
The source location the operation was defined or derived from.
ArrayRef< NamedAttribute > getAttrs()
Return all of the attributes on this operation.
InFlightDiagnostic emitError(const Twine &message={})
Emit an error about fatal conditions with this operation, reporting up to any diagnostic handlers tha...
operand_type_range getOperandTypes()
result_type_range getResultTypes()
operand_range getOperands()
Returns an iterator on the underlying Value's.
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 contains a list of basic blocks and a link to the parent operation it is attached to.
void push_back(Block *block)
This class allows for representing and managing the symbol table used by operations with the 'SymbolT...
static StringRef getSymbolAttrName()
Return the name of the attribute used for symbol names.
static Operation * lookupNearestSymbolFrom(Operation *from, StringAttr symbol)
Returns the operation registered with the given symbol name within the closest parent operation of,...
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
Dialect & getDialect() const
Get the dialect this type is registered to.
Type front()
Return first type in the range.
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.
A utility result that is used to signal how to proceed with an ongoing walk:
static WalkResult advance()
static ArrayType get(Type elementType, unsigned elementCount)
static PointerType get(Type pointeeType, StorageClass storageClass)
unsigned getNumElements() const
Type getElementType(unsigned) const
An attribute that specifies the SPIR-V (version, capabilities, extensions) triple.
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,...
void walk(Operation *op, function_ref< void(Region *)> callback, WalkOrder order)
Walk all of the regions, blocks, or operations nested under (and including) the given operation.
constexpr void enumerate(std::tuple< Tys... > &tuple, CallbackT &&callback)
ArrayRef< NamedAttribute > getArgAttrs(FunctionOpInterface op, unsigned index)
Return all of the attributes for the argument at 'index'.
ParseResult parseFunctionSignatureWithArguments(OpAsmParser &parser, bool allowVariadic, SmallVectorImpl< OpAsmParser::Argument > &arguments, bool &isVariadic, SmallVectorImpl< Type > &resultTypes, SmallVectorImpl< DictionaryAttr > &resultAttrs)
Parses a function signature using parser.
void printFunctionAttributes(OpAsmPrinter &p, Operation *op, ArrayRef< StringRef > elided={})
Prints the list of function prefixed with the "attributes" keyword.
void printFunctionSignature(OpAsmPrinter &p, FunctionOpInterface op, ArrayRef< Type > argTypes, bool isVariadic, ArrayRef< Type > resultTypes)
Prints the signature of the function-like operation op.
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)
constexpr char kFnNameAttrName[]
constexpr char kSpecIdAttrName[]
static Type getValueType(Attribute attr)
LogicalResult verifyMemorySemantics(Operation *op, spirv::MemorySemantics memorySemantics)
ParseResult parseEnumStrAttr(EnumClass &value, OpAsmParser &parser, StringRef attrName=spirv::attributeName< EnumClass >())
Parses the next string attribute in parser as an enumerant of the given EnumClass.
void printVariableDecorations(Operation *op, OpAsmPrinter &printer, SmallVectorImpl< StringRef > &elidedAttrs)
AddressingModel getAddressingModel(TargetEnvAttr targetAttr, bool use64bitAddress)
Returns addressing model selected based on target environment.
FailureOr< ExecutionModel > getExecutionModel(TargetEnvAttr targetAttr)
Returns execution model selected based on target environment.
FailureOr< MemoryModel > getMemoryModel(TargetEnvAttr targetAttr)
Returns memory model selected based on target environment.
LogicalResult extractValueFromConstOp(Operation *op, int32_t &value)
ParseResult parseVariableDecorations(OpAsmParser &parser, OperationState &state)
Include the generated interface declarations.
Type getType(OpFoldResult ofr)
Returns the int type of the integer in ofr.
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,...
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 addAttribute(StringRef name, Attribute attr)
Add an attribute with the specified name.
void addTypes(ArrayRef< Type > newTypes)
SmallVector< Type, 4 > types
Types of the results of this operation.
Region * addRegion()
Create a region that should be attached to the operation.