[Mlir-commits] [mlir] 94b15a1 - [mlir][spirv] Add basic support for SPV_EXT_replicated_composites (#147067)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Tue Jul 15 06:45:17 PDT 2025
Author: Mohammadreza Ameri Mahabadian
Date: 2025-07-15T09:45:13-04:00
New Revision: 94b15a1ece37963c9804fc7f0c498d140ea5fd9d
URL: https://github.com/llvm/llvm-project/commit/94b15a1ece37963c9804fc7f0c498d140ea5fd9d
DIFF: https://github.com/llvm/llvm-project/commit/94b15a1ece37963c9804fc7f0c498d140ea5fd9d.diff
LOG: [mlir][spirv] Add basic support for SPV_EXT_replicated_composites (#147067)
This patch introduces two new ops to the SPIR-V dialect:
- `spirv.EXT.ConstantCompositeReplicate`
- `spirv.EXT.SpecConstantCompositeReplicate`
These ops represent composite constants and specialization constants,
respectively, constructed by replicating a single splat constant across
all elements. They correspond to `SPV_EXT_replicated_composites`
extension instructions:
- `OpConstantCompositeReplicatedEXT`
- `OpSpecConstantCompositeReplicatedEXT`
No transformation to these new ops has been introduced in this patch.
This approach is chosen as per the discussions on RFC
https://discourse.llvm.org/t/rfc-basic-support-for-spv-ext-replicated-composites-in-mlir-spir-v-compile-time-constant-lowering-only/86987
---------
Signed-off-by: Mohammadreza Ameri Mahabadian <mohammadreza.amerimahabadian at arm.com>
Added:
Modified:
mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td
mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td
mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp
mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
mlir/lib/Target/SPIRV/Deserialization/Deserializer.h
mlir/lib/Target/SPIRV/Serialization/SerializeOps.cpp
mlir/lib/Target/SPIRV/Serialization/Serializer.cpp
mlir/lib/Target/SPIRV/Serialization/Serializer.h
mlir/test/Dialect/SPIRV/IR/availability.mlir
mlir/test/Dialect/SPIRV/IR/structure-ops.mlir
mlir/test/Target/SPIRV/constant.mlir
mlir/test/Target/SPIRV/spec-constant.mlir
Removed:
################################################################################
diff --git a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td
index 1f614d63cb54f..90383265002a3 100644
--- a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td
+++ b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td
@@ -359,6 +359,7 @@ def SPV_EXT_shader_atomic_float_min_max : I32EnumAttrCase<"SPV_EXT_shader_atomi
def SPV_EXT_shader_image_int64 : I32EnumAttrCase<"SPV_EXT_shader_image_int64", 1010>;
def SPV_EXT_shader_atomic_float16_add : I32EnumAttrCase<"SPV_EXT_shader_atomic_float16_add", 1011>;
def SPV_EXT_mesh_shader : I32EnumAttrCase<"SPV_EXT_mesh_shader", 1012>;
+def SPV_EXT_replicated_composites : I32EnumAttrCase<"SPV_EXT_replicated_composites", 1013>;
def SPV_AMD_gpu_shader_half_float_fetch : I32EnumAttrCase<"SPV_AMD_gpu_shader_half_float_fetch", 2000>;
def SPV_AMD_shader_ballot : I32EnumAttrCase<"SPV_AMD_shader_ballot", 2001>;
@@ -446,7 +447,7 @@ def SPIRV_ExtensionAttr :
SPV_EXT_shader_stencil_export, SPV_EXT_shader_viewport_index_layer,
SPV_EXT_shader_atomic_float_add, SPV_EXT_shader_atomic_float_min_max,
SPV_EXT_shader_image_int64, SPV_EXT_shader_atomic_float16_add,
- SPV_EXT_mesh_shader,
+ SPV_EXT_mesh_shader, SPV_EXT_replicated_composites,
SPV_ARM_tensors,
SPV_AMD_gpu_shader_half_float_fetch, SPV_AMD_shader_ballot,
SPV_AMD_shader_explicit_vertex_parameter, SPV_AMD_shader_fragment_mask,
@@ -849,6 +850,12 @@ def SPIRV_C_CooperativeMatrixKHR : I32EnumAttrCase<"Coope
MinVersion<SPIRV_V_1_6>
];
}
+def SPIRV_C_ReplicatedCompositesEXT : I32EnumAttrCase<"ReplicatedCompositesEXT", 6024> {
+ list<Availability> availability = [
+ Extension<[SPV_EXT_replicated_composites]>,
+ MinVersion<SPIRV_V_1_0>
+ ];
+}
def SPIRV_C_BitInstructions : I32EnumAttrCase<"BitInstructions", 6025> {
list<Availability> availability = [
Extension<[SPV_KHR_bit_instructions]>
@@ -1500,7 +1507,7 @@ def SPIRV_CapabilityAttr :
SPIRV_C_USMStorageClassesINTEL, SPIRV_C_IOPipesINTEL, SPIRV_C_BlockingPipesINTEL,
SPIRV_C_FPGARegINTEL, SPIRV_C_DotProductInputAll,
SPIRV_C_DotProductInput4x8BitPacked, SPIRV_C_DotProduct, SPIRV_C_RayCullMaskKHR,
- SPIRV_C_CooperativeMatrixKHR,
+ SPIRV_C_CooperativeMatrixKHR, SPIRV_C_ReplicatedCompositesEXT,
SPIRV_C_BitInstructions, SPIRV_C_AtomicFloat32AddEXT, SPIRV_C_AtomicFloat64AddEXT,
SPIRV_C_LongConstantCompositeINTEL, SPIRV_C_OptNoneINTEL,
SPIRV_C_AtomicFloat16AddEXT, SPIRV_C_DebugInfoModuleINTEL, SPIRV_C_SplitBarrierINTEL,
@@ -4565,6 +4572,8 @@ def SPIRV_OC_OpCooperativeMatrixLoadKHR : I32EnumAttrCase<"OpCooperativeMa
def SPIRV_OC_OpCooperativeMatrixStoreKHR : I32EnumAttrCase<"OpCooperativeMatrixStoreKHR", 4458>;
def SPIRV_OC_OpCooperativeMatrixMulAddKHR : I32EnumAttrCase<"OpCooperativeMatrixMulAddKHR", 4459>;
def SPIRV_OC_OpCooperativeMatrixLengthKHR : I32EnumAttrCase<"OpCooperativeMatrixLengthKHR", 4460>;
+def SPIRV_OC_OpConstantCompositeReplicateEXT : I32EnumAttrCase<"OpConstantCompositeReplicateEXT", 4461>;
+def SPIRV_OC_OpSpecConstantCompositeReplicateEXT : I32EnumAttrCase<"OpSpecConstantCompositeReplicateEXT", 4462>;
def SPIRV_OC_OpEmitMeshTasksEXT : I32EnumAttrCase<"OpEmitMeshTasksEXT", 5294>;
def SPIRV_OC_OpSetMeshOutputsEXT : I32EnumAttrCase<"OpSetMeshOutputsEXT", 5295>;
def SPIRV_OC_OpSubgroupBlockReadINTEL : I32EnumAttrCase<"OpSubgroupBlockReadINTEL", 5575>;
@@ -4674,6 +4683,8 @@ def SPIRV_OpcodeAttr :
SPIRV_OC_OpSUDotAccSat, SPIRV_OC_OpTypeCooperativeMatrixKHR,
SPIRV_OC_OpCooperativeMatrixLoadKHR, SPIRV_OC_OpCooperativeMatrixStoreKHR,
SPIRV_OC_OpCooperativeMatrixMulAddKHR, SPIRV_OC_OpCooperativeMatrixLengthKHR,
+ SPIRV_OC_OpConstantCompositeReplicateEXT,
+ SPIRV_OC_OpSpecConstantCompositeReplicateEXT,
SPIRV_OC_OpEmitMeshTasksEXT, SPIRV_OC_OpSetMeshOutputsEXT,
SPIRV_OC_OpSubgroupBlockReadINTEL, SPIRV_OC_OpSubgroupBlockWriteINTEL,
SPIRV_OC_OpAssumeTrueKHR, SPIRV_OC_OpAtomicFAddEXT,
diff --git a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td
index c5a85f881b35e..7986025d6ca31 100644
--- a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td
+++ b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td
@@ -135,6 +135,47 @@ def SPIRV_ConstantOp : SPIRV_Op<"Constant",
let autogenSerialization = 0;
}
+
+// -----
+
+def SPIRV_EXTConstantCompositeReplicateOp : SPIRV_ExtVendorOp<"ConstantCompositeReplicate", [Pure]> {
+ let summary = [{
+ Declare a new replicated composite constant op.
+ }];
+
+ let description = [{
+ Represents a splat composite constant i.e., all elements of composite constant
+ have the same value.
+
+ #### Example:
+
+ ```mlir
+ %0 = spirv.EXT.ConstantCompositeReplicate [1 : i32] : vector<2xi32>
+ %1 = spirv.EXT.ConstantCompositeReplicate [1 : i32] : !spirv.array<2 x vector<2xi32>>
+ %2 = spirv.EXT.ConstantCompositeReplicate [dense<[1, 2]> : vector<2xi32>] : !spirv.array<2 x vector<2xi32>>
+ ```
+ }];
+
+ let availability = [
+ MinVersion<SPIRV_V_1_0>,
+ MaxVersion<SPIRV_V_1_6>,
+ Extension<[SPV_EXT_replicated_composites]>,
+ Capability<[SPIRV_C_ReplicatedCompositesEXT]>
+ ];
+
+ let arguments = (ins
+ AnyAttr:$value
+ );
+
+ let results = (outs
+ SPIRV_Composite:$replicated_constant
+ );
+
+ let autogenSerialization = 0;
+
+ let assemblyFormat = "` ` `[` $value `]` `:` type($replicated_constant) attr-dict";
+}
+
// -----
def SPIRV_EntryPointOp : SPIRV_Op<"EntryPoint", [InModuleScope]> {
@@ -689,6 +730,43 @@ def SPIRV_SpecConstantCompositeOp : SPIRV_Op<"SpecConstantComposite", [
// -----
+def SPIRV_EXTSpecConstantCompositeReplicateOp : SPIRV_ExtVendorOp<"SpecConstantCompositeReplicate", [InModuleScope, Symbol]> {
+ let summary = "Declare a new replicated composite specialization constant op.";
+
+ let description = [{
+ Represents a splat spec composite constant i.e., all elements of spec composite
+ constant have the same value. The splat value must come from a symbol reference
+ of spec constant instruction.
+
+ #### Example:
+
+ ```mlir
+ spirv.SpecConstant @sc_i32_1 = 1 : i32
+ spirv.EXT.SpecConstantCompositeReplicate @scc_splat_array_of_i32 (@sc_i32_1) : !spirv.array<3 x i32>
+ spirv.EXT.SpecConstantCompositeReplicate @scc_splat_struct_of_i32 (@sc_i32_1) : !spirv.struct<(i32, i32, i32)>
+ ```
+ }];
+
+ let availability = [
+ MinVersion<SPIRV_V_1_0>,
+ MaxVersion<SPIRV_V_1_6>,
+ Extension<[SPV_EXT_replicated_composites]>,
+ Capability<[SPIRV_C_ReplicatedCompositesEXT]>
+ ];
+
+ let arguments = (ins
+ TypeAttr:$type,
+ StrAttr:$sym_name,
+ SymbolRefAttr:$constituent
+ );
+
+ let results = (outs);
+
+ let autogenSerialization = 0;
+}
+
+// -----
+
def SPIRV_SpecConstantOperationOp : SPIRV_Op<"SpecConstantOperation", [
Pure, InFunctionScope,
SingleBlockImplicitTerminator<"YieldOp">]> {
diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
index 7042f12ba00f8..656236246b1ad 100644
--- a/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
+++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
@@ -763,6 +763,44 @@ void mlir::spirv::AddressOfOp::getAsmResultNames(
setNameFn(getResult(), specialName.str());
}
+//===----------------------------------------------------------------------===//
+// spirv.EXTConstantCompositeReplicate
+//===----------------------------------------------------------------------===//
+
+LogicalResult spirv::EXTConstantCompositeReplicateOp::verify() {
+ Type valueType;
+ if (auto typedAttr = dyn_cast<TypedAttr>(getValue())) {
+ valueType = typedAttr.getType();
+ } else if (auto arrayAttr = dyn_cast<ArrayAttr>(getValue())) {
+ auto typedElemAttr = dyn_cast<TypedAttr>(arrayAttr[0]);
+ if (!typedElemAttr)
+ return emitError("value attribute is not typed");
+ valueType =
+ spirv::ArrayType::get(typedElemAttr.getType(), arrayAttr.size());
+ } else {
+ return emitError("unknown value attribute type");
+ }
+
+ auto compositeType = dyn_cast<spirv::CompositeType>(getType());
+ if (!compositeType)
+ return emitError("result type is not a composite type");
+
+ Type compositeElementType = compositeType.getElementType(0);
+
+ SmallVector<Type, 3> possibleTypes = {compositeElementType};
+ while (auto type = dyn_cast<spirv::CompositeType>(compositeElementType)) {
+ compositeElementType = type.getElementType(0);
+ possibleTypes.push_back(compositeElementType);
+ }
+
+ if (!is_contained(possibleTypes, valueType)) {
+ return emitError("expected value attribute type ")
+ << interleaved(possibleTypes, " or ") << ", but got: " << valueType;
+ }
+
+ return success();
+}
+
//===----------------------------------------------------------------------===//
// spirv.ControlBarrierOp
//===----------------------------------------------------------------------===//
@@ -1864,6 +1902,69 @@ LogicalResult spirv::SpecConstantCompositeOp::verify() {
return success();
}
+//===----------------------------------------------------------------------===//
+// spirv.EXTSpecConstantCompositeReplicateOp
+//===----------------------------------------------------------------------===//
+
+ParseResult
+spirv::EXTSpecConstantCompositeReplicateOp::parse(OpAsmParser &parser,
+ OperationState &result) {
+ StringAttr compositeName;
+ FlatSymbolRefAttr specConstRef;
+ const char *attrName = "spec_const";
+ NamedAttrList attrs;
+ Type type;
+
+ if (parser.parseSymbolName(compositeName, SymbolTable::getSymbolAttrName(),
+ result.attributes) ||
+ parser.parseLParen() ||
+ parser.parseAttribute(specConstRef, Type(), attrName, attrs) ||
+ parser.parseRParen() || parser.parseColonType(type))
+ return failure();
+
+ StringAttr compositeSpecConstituentName =
+ spirv::EXTSpecConstantCompositeReplicateOp::getConstituentAttrName(
+ result.name);
+ result.addAttribute(compositeSpecConstituentName, specConstRef);
+
+ StringAttr typeAttrName =
+ spirv::EXTSpecConstantCompositeReplicateOp::getTypeAttrName(result.name);
+ result.addAttribute(typeAttrName, TypeAttr::get(type));
+
+ return success();
+}
+
+void spirv::EXTSpecConstantCompositeReplicateOp::print(OpAsmPrinter &printer) {
+ printer << " ";
+ printer.printSymbolName(getSymName());
+ printer << " (" << this->getConstituent() << ") : " << getType();
+}
+
+LogicalResult spirv::EXTSpecConstantCompositeReplicateOp::verify() {
+ auto compositeType = dyn_cast<spirv::CompositeType>(getType());
+ if (!compositeType)
+ return emitError("result type must be a composite type, but provided ")
+ << getType();
+
+ Operation *constituentOp = SymbolTable::lookupNearestSymbolFrom(
+ (*this)->getParentOp(), this->getConstituent());
+ if (!constituentOp)
+ return emitError(
+ "splat spec constant reference defining constituent not found");
+
+ auto constituentSpecConstOp = dyn_cast<spirv::SpecConstantOp>(constituentOp);
+ if (!constituentSpecConstOp)
+ return emitError("constituent is not a spec constant");
+
+ Type constituentType = constituentSpecConstOp.getDefaultValue().getType();
+ Type compositeElementType = compositeType.getElementType(0);
+ if (constituentType != compositeElementType)
+ return emitError("constituent has incorrect type: expected ")
+ << compositeElementType << ", but provided " << constituentType;
+
+ return success();
+}
+
//===----------------------------------------------------------------------===//
// spirv.SpecConstantOperation
//===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp b/mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp
index 55d6a380d0bff..9fa03725d05ee 100644
--- a/mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp
+++ b/mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp
@@ -45,6 +45,12 @@ Value spirv::Deserializer::getValue(uint32_t id) {
return opBuilder.create<spirv::ConstantOp>(unknownLoc, constInfo->second,
constInfo->first);
}
+ if (std::optional<std::pair<Attribute, Type>> constCompositeReplicateInfo =
+ getConstantCompositeReplicate(id)) {
+ return opBuilder.create<spirv::EXTConstantCompositeReplicateOp>(
+ unknownLoc, constCompositeReplicateInfo->second,
+ constCompositeReplicateInfo->first);
+ }
if (auto varOp = getGlobalVariable(id)) {
auto addressOfOp = opBuilder.create<spirv::AddressOfOp>(
unknownLoc, varOp.getType(), SymbolRefAttr::get(varOp.getOperation()));
@@ -56,10 +62,18 @@ Value spirv::Deserializer::getValue(uint32_t id) {
SymbolRefAttr::get(constOp.getOperation()));
return referenceOfOp.getReference();
}
- if (auto constCompositeOp = getSpecConstantComposite(id)) {
+ if (SpecConstantCompositeOp specConstCompositeOp =
+ getSpecConstantComposite(id)) {
+ auto referenceOfOp = opBuilder.create<spirv::ReferenceOfOp>(
+ unknownLoc, specConstCompositeOp.getType(),
+ SymbolRefAttr::get(specConstCompositeOp.getOperation()));
+ return referenceOfOp.getReference();
+ }
+ if (auto specConstCompositeReplicateOp =
+ getSpecConstantCompositeReplicate(id)) {
auto referenceOfOp = opBuilder.create<spirv::ReferenceOfOp>(
- unknownLoc, constCompositeOp.getType(),
- SymbolRefAttr::get(constCompositeOp.getOperation()));
+ unknownLoc, specConstCompositeReplicateOp.getType(),
+ SymbolRefAttr::get(specConstCompositeReplicateOp.getOperation()));
return referenceOfOp.getReference();
}
if (auto specConstOperationInfo = getSpecConstantOperation(id)) {
@@ -175,8 +189,12 @@ LogicalResult spirv::Deserializer::processInstruction(
return processConstant(operands, /*isSpec=*/true);
case spirv::Opcode::OpConstantComposite:
return processConstantComposite(operands);
+ case spirv::Opcode::OpConstantCompositeReplicateEXT:
+ return processConstantCompositeReplicateEXT(operands);
case spirv::Opcode::OpSpecConstantComposite:
return processSpecConstantComposite(operands);
+ case spirv::Opcode::OpSpecConstantCompositeReplicateEXT:
+ return processSpecConstantCompositeReplicateEXT(operands);
case spirv::Opcode::OpSpecConstantOp:
return processSpecConstantOperation(operands);
case spirv::Opcode::OpConstantTrue:
diff --git a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
index b1abd8b3dffe9..d133d0332e271 100644
--- a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
+++ b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp
@@ -678,6 +678,14 @@ spirv::Deserializer::getConstant(uint32_t id) {
return constIt->getSecond();
}
+std::optional<std::pair<Attribute, Type>>
+spirv::Deserializer::getConstantCompositeReplicate(uint32_t id) {
+ if (auto it = constantCompositeReplicateMap.find(id);
+ it != constantCompositeReplicateMap.end())
+ return it->second;
+ return std::nullopt;
+}
+
std::optional<spirv::SpecConstOperationMaterializationInfo>
spirv::Deserializer::getSpecConstantOperation(uint32_t id) {
auto constIt = specConstOperationMap.find(id);
@@ -1554,15 +1562,63 @@ spirv::Deserializer::processConstantComposite(ArrayRef<uint32_t> operands) {
return success();
}
+LogicalResult spirv::Deserializer::processConstantCompositeReplicateEXT(
+ ArrayRef<uint32_t> operands) {
+ if (operands.size() != 3) {
+ return emitError(
+ unknownLoc,
+ "OpConstantCompositeReplicateEXT expects 3 operands but found ")
+ << operands.size();
+ }
+
+ Type resultType = getType(operands[0]);
+ if (!resultType) {
+ return emitError(unknownLoc, "undefined result type from <id> ")
+ << operands[0];
+ }
+
+ auto compositeType = dyn_cast<CompositeType>(resultType);
+ if (!compositeType) {
+ return emitError(unknownLoc,
+ "result type from <id> is not a composite type")
+ << operands[0];
+ }
+
+ uint32_t resultID = operands[1];
+ uint32_t constantID = operands[2];
+
+ std::optional<std::pair<Attribute, Type>> constantInfo =
+ getConstant(constantID);
+ if (constantInfo.has_value()) {
+ constantCompositeReplicateMap.try_emplace(
+ resultID, constantInfo.value().first, resultType);
+ return success();
+ }
+
+ std::optional<std::pair<Attribute, Type>> replicatedConstantCompositeInfo =
+ getConstantCompositeReplicate(constantID);
+ if (replicatedConstantCompositeInfo.has_value()) {
+ constantCompositeReplicateMap.try_emplace(
+ resultID, replicatedConstantCompositeInfo.value().first, resultType);
+ return success();
+ }
+
+ return emitError(unknownLoc, "OpConstantCompositeReplicateEXT operand <id> ")
+ << constantID
+ << " must come from a normal constant or a "
+ "OpConstantCompositeReplicateEXT";
+}
+
LogicalResult
spirv::Deserializer::processSpecConstantComposite(ArrayRef<uint32_t> operands) {
if (operands.size() < 2) {
- return emitError(unknownLoc,
- "OpConstantComposite must have type <id> and result <id>");
+ return emitError(
+ unknownLoc,
+ "OpSpecConstantComposite must have type <id> and result <id>");
}
if (operands.size() < 3) {
return emitError(unknownLoc,
- "OpConstantComposite must have at least 1 parameter");
+ "OpSpecConstantComposite must have at least 1 parameter");
}
Type resultType = getType(operands[0]);
@@ -1589,6 +1645,41 @@ spirv::Deserializer::processSpecConstantComposite(ArrayRef<uint32_t> operands) {
return success();
}
+LogicalResult spirv::Deserializer::processSpecConstantCompositeReplicateEXT(
+ ArrayRef<uint32_t> operands) {
+ if (operands.size() != 3) {
+ return emitError(unknownLoc, "OpSpecConstantCompositeReplicateEXT expects "
+ "3 operands but found ")
+ << operands.size();
+ }
+
+ Type resultType = getType(operands[0]);
+ if (!resultType) {
+ return emitError(unknownLoc, "undefined result type from <id> ")
+ << operands[0];
+ }
+
+ auto compositeType = dyn_cast<CompositeType>(resultType);
+ if (!compositeType) {
+ return emitError(unknownLoc,
+ "result type from <id> is not a composite type")
+ << operands[0];
+ }
+
+ uint32_t resultID = operands[1];
+
+ auto symName = opBuilder.getStringAttr(getSpecConstantSymbol(resultID));
+ spirv::SpecConstantOp constituentSpecConstantOp =
+ getSpecConstant(operands[2]);
+ auto op = opBuilder.create<spirv::EXTSpecConstantCompositeReplicateOp>(
+ unknownLoc, TypeAttr::get(resultType), symName,
+ SymbolRefAttr::get(constituentSpecConstantOp));
+
+ specConstCompositeReplicateMap[resultID] = op;
+
+ return success();
+}
+
LogicalResult
spirv::Deserializer::processSpecConstantOperation(ArrayRef<uint32_t> operands) {
if (operands.size() < 3)
diff --git a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.h b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.h
index 1bc9e4a3c75d8..20482bd2bf501 100644
--- a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.h
+++ b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.h
@@ -190,6 +190,11 @@ class Deserializer {
/// Gets the constant's attribute and type associated with the given <id>.
std::optional<std::pair<Attribute, Type>> getConstant(uint32_t id);
+ /// Gets the replicated composite constant's attribute and type associated
+ /// with the given <id>.
+ std::optional<std::pair<Attribute, Type>>
+ getConstantCompositeReplicate(uint32_t id);
+
/// Gets the info needed to materialize the spec constant operation op
/// associated with the given <id>.
std::optional<SpecConstOperationMaterializationInfo>
@@ -220,6 +225,13 @@ class Deserializer {
return specConstCompositeMap.lookup(id);
}
+ /// Gets the replicated composite specialization constant with the given
+ /// result <id>.
+ spirv::EXTSpecConstantCompositeReplicateOp
+ getSpecConstantCompositeReplicate(uint32_t id) {
+ return specConstCompositeReplicateMap.lookup(id);
+ }
+
/// Creates a spirv::SpecConstantOp.
spirv::SpecConstantOp createSpecConstant(Location loc, uint32_t resultID,
TypedAttr defaultValue);
@@ -313,10 +325,20 @@ class Deserializer {
/// `operands`.
LogicalResult processConstantComposite(ArrayRef<uint32_t> operands);
+ /// Processes a SPIR-V OpConstantCompositeReplicateEXT instruction with
+ /// the given `operands`.
+ LogicalResult
+ processConstantCompositeReplicateEXT(ArrayRef<uint32_t> operands);
+
/// Processes a SPIR-V OpSpecConstantComposite instruction with the given
/// `operands`.
LogicalResult processSpecConstantComposite(ArrayRef<uint32_t> operands);
+ /// Processes a SPIR-V OpSpecConstantCompositeReplicateEXT instruction with
+ /// the given `operands`.
+ LogicalResult
+ processSpecConstantCompositeReplicateEXT(ArrayRef<uint32_t> operands);
+
/// Processes a SPIR-V OpSpecConstantOp instruction with the given
/// `operands`.
LogicalResult processSpecConstantOperation(ArrayRef<uint32_t> operands);
@@ -549,12 +571,28 @@ class Deserializer {
/// (and type) here. Later when it's used, we materialize the constant.
DenseMap<uint32_t, std::pair<Attribute, Type>> constantMap;
+ // Result <id> to replicated constant attribute and type mapping.
+ ///
+ /// In the SPIR-V binary format, OpConstantCompositeReplicateEXT is placed in
+ /// the module and shared by instructions at module level and in subsequent
+ /// functions. But in the SPIR-V dialect, this is materialized to where
+ /// it's used in the function. So when seeing a
+ /// OpConstantCompositeReplicateEXT in the binary format, we don't immediately
+ /// emit a `spirv.EXT.ConstantCompositeReplicate` op into the module, we keep
+ /// the id of its value and type here. Later when it's used, we materialize
+ /// the `spirv.EXT.ConstantCompositeReplicate`.
+ DenseMap<uint32_t, std::pair<Attribute, Type>> constantCompositeReplicateMap;
+
// Result <id> to spec constant mapping.
DenseMap<uint32_t, spirv::SpecConstantOp> specConstMap;
// Result <id> to composite spec constant mapping.
DenseMap<uint32_t, spirv::SpecConstantCompositeOp> specConstCompositeMap;
+ // Result <id> to replicated composite spec constant mapping.
+ DenseMap<uint32_t, spirv::EXTSpecConstantCompositeReplicateOp>
+ specConstCompositeReplicateMap;
+
/// Result <id> to info needed to materialize an OpSpecConstantOp
/// mapping.
DenseMap<uint32_t, SpecConstOperationMaterializationInfo>
diff --git a/mlir/lib/Target/SPIRV/Serialization/SerializeOps.cpp b/mlir/lib/Target/SPIRV/Serialization/SerializeOps.cpp
index ff3cc92ee8078..d62529b85b3aa 100644
--- a/mlir/lib/Target/SPIRV/Serialization/SerializeOps.cpp
+++ b/mlir/lib/Target/SPIRV/Serialization/SerializeOps.cpp
@@ -66,6 +66,16 @@ LogicalResult Serializer::processConstantOp(spirv::ConstantOp op) {
return failure();
}
+LogicalResult Serializer::processConstantCompositeReplicateOp(
+ spirv::EXTConstantCompositeReplicateOp op) {
+ if (uint32_t resultID = prepareConstantCompositeReplicate(
+ op.getLoc(), op.getType(), op.getValue())) {
+ valueIDMap[op.getResult()] = resultID;
+ return success();
+ }
+ return failure();
+}
+
LogicalResult Serializer::processSpecConstantOp(spirv::SpecConstantOp op) {
if (auto resultID = prepareConstantScalar(op.getLoc(), op.getDefaultValue(),
/*isSpec=*/true)) {
@@ -118,6 +128,38 @@ Serializer::processSpecConstantCompositeOp(spirv::SpecConstantCompositeOp op) {
return processName(resultID, op.getSymName());
}
+LogicalResult Serializer::processSpecConstantCompositeReplicateOp(
+ spirv::EXTSpecConstantCompositeReplicateOp op) {
+ uint32_t typeID = 0;
+ if (failed(processType(op.getLoc(), op.getType(), typeID))) {
+ return failure();
+ }
+
+ auto constituent = dyn_cast<FlatSymbolRefAttr>(op.getConstituent());
+ if (!constituent)
+ return op.emitError(
+ "expected flat symbol reference for constituent instead of ")
+ << op.getConstituent();
+
+ StringRef constituentName = constituent.getValue();
+ uint32_t constituentID = getSpecConstID(constituentName);
+ if (!constituentID) {
+ return op.emitError("unknown result <id> for replicated spec constant ")
+ << constituentName;
+ }
+
+ uint32_t resultID = getNextID();
+ uint32_t operands[] = {typeID, resultID, constituentID};
+
+ encodeInstructionInto(typesGlobalValues,
+ spirv::Opcode::OpSpecConstantCompositeReplicateEXT,
+ operands);
+
+ specConstIDMap[op.getSymName()] = resultID;
+
+ return processName(resultID, op.getSymName());
+}
+
LogicalResult
Serializer::processSpecConstantOperationOp(spirv::SpecConstantOperationOp op) {
uint32_t typeID = 0;
diff --git a/mlir/lib/Target/SPIRV/Serialization/Serializer.cpp b/mlir/lib/Target/SPIRV/Serialization/Serializer.cpp
index ebebd2d283afa..3400fcf6374e8 100644
--- a/mlir/lib/Target/SPIRV/Serialization/Serializer.cpp
+++ b/mlir/lib/Target/SPIRV/Serialization/Serializer.cpp
@@ -1109,6 +1109,55 @@ uint32_t Serializer::prepareConstantFp(Location loc, FloatAttr floatAttr,
return resultID;
}
+uint32_t Serializer::prepareConstantCompositeReplicate(Location loc,
+ Type resultType,
+ Attribute valueAttr) {
+ std::pair<Attribute, Type> valueTypePair{valueAttr, resultType};
+ if (uint32_t id = getConstantCompositeReplicateID(valueTypePair)) {
+ return id;
+ }
+
+ uint32_t typeID = 0;
+ if (failed(processType(loc, resultType, typeID))) {
+ return 0;
+ }
+
+ Type valueType;
+ if (auto typedAttr = dyn_cast<TypedAttr>(valueAttr)) {
+ valueType = typedAttr.getType();
+ } else if (auto arrayAttr = dyn_cast<ArrayAttr>(valueAttr)) {
+ auto typedElemAttr = dyn_cast<TypedAttr>(arrayAttr[0]);
+ if (!typedElemAttr)
+ return 0;
+ valueType =
+ spirv::ArrayType::get(typedElemAttr.getType(), arrayAttr.size());
+ } else {
+ return 0;
+ }
+
+ auto compositeType = dyn_cast<CompositeType>(resultType);
+ if (!compositeType)
+ return 0;
+ Type elementType = compositeType.getElementType(0);
+
+ uint32_t constandID;
+ if (elementType == valueType) {
+ constandID = prepareConstant(loc, elementType, valueAttr);
+ } else {
+ constandID = prepareConstantCompositeReplicate(loc, elementType, valueAttr);
+ }
+
+ uint32_t resultID = getNextID();
+ uint32_t operands[] = {typeID, resultID, constandID};
+
+ encodeInstructionInto(typesGlobalValues,
+ spirv::Opcode::OpConstantCompositeReplicateEXT,
+ operands);
+
+ constCompositeReplicateIDMap[valueTypePair] = resultID;
+ return resultID;
+}
+
//===----------------------------------------------------------------------===//
// Control flow
//===----------------------------------------------------------------------===//
@@ -1328,6 +1377,9 @@ LogicalResult Serializer::processOperation(Operation *opInst) {
return processBranchConditionalOp(op);
})
.Case([&](spirv::ConstantOp op) { return processConstantOp(op); })
+ .Case([&](spirv::EXTConstantCompositeReplicateOp op) {
+ return processConstantCompositeReplicateOp(op);
+ })
.Case([&](spirv::FuncOp op) { return processFuncOp(op); })
.Case([&](spirv::GlobalVariableOp op) {
return processGlobalVariableOp(op);
@@ -1339,6 +1391,9 @@ LogicalResult Serializer::processOperation(Operation *opInst) {
.Case([&](spirv::SpecConstantCompositeOp op) {
return processSpecConstantCompositeOp(op);
})
+ .Case([&](spirv::EXTSpecConstantCompositeReplicateOp op) {
+ return processSpecConstantCompositeReplicateOp(op);
+ })
.Case([&](spirv::SpecConstantOperationOp op) {
return processSpecConstantOperationOp(op);
})
diff --git a/mlir/lib/Target/SPIRV/Serialization/Serializer.h b/mlir/lib/Target/SPIRV/Serialization/Serializer.h
index 9edb0f4af008d..7047869bca4cd 100644
--- a/mlir/lib/Target/SPIRV/Serialization/Serializer.h
+++ b/mlir/lib/Target/SPIRV/Serialization/Serializer.h
@@ -108,11 +108,17 @@ class Serializer {
LogicalResult processConstantOp(spirv::ConstantOp op);
+ LogicalResult processConstantCompositeReplicateOp(
+ spirv::EXTConstantCompositeReplicateOp op);
+
LogicalResult processSpecConstantOp(spirv::SpecConstantOp op);
LogicalResult
processSpecConstantCompositeOp(spirv::SpecConstantCompositeOp op);
+ LogicalResult processSpecConstantCompositeReplicateOp(
+ spirv::EXTSpecConstantCompositeReplicateOp op);
+
LogicalResult
processSpecConstantOperationOp(spirv::SpecConstantOperationOp op);
@@ -191,6 +197,11 @@ class Serializer {
return constIDMap.lookup(value);
}
+ uint32_t getConstantCompositeReplicateID(
+ std::pair<Attribute, Type> valueTypePair) const {
+ return constCompositeReplicateIDMap.lookup(valueTypePair);
+ }
+
/// Main dispatch method for processing a constant with the given `constType`
/// and `valueAttr`. `constType` is needed here because we can interpret the
/// `valueAttr` as a
diff erent type than the type of `valueAttr` itself; for
@@ -230,6 +241,12 @@ class Serializer {
uint32_t prepareConstantFp(Location loc, FloatAttr floatAttr,
bool isSpec = false);
+ /// Prepares `spirv.EXTConstantCompositeReplicateOp` serialization. This
+ /// method emits OpConstantCompositeReplicateEXT and returns the result <id>
+ /// associated with it.
+ uint32_t prepareConstantCompositeReplicate(Location loc, Type resultType,
+ Attribute valueAttr);
+
//===--------------------------------------------------------------------===//
// Control flow
//===--------------------------------------------------------------------===//
@@ -389,6 +406,9 @@ class Serializer {
/// Map from constant values to their <id>s.
DenseMap<Attribute, uint32_t> constIDMap;
+ /// Map from a replicated composite constant's value and type to their <id>s.
+ DenseMap<std::pair<Attribute, Type>, uint32_t> constCompositeReplicateIDMap;
+
/// Map from specialization constant names to their <id>s.
llvm::StringMap<uint32_t> specConstIDMap;
diff --git a/mlir/test/Dialect/SPIRV/IR/availability.mlir b/mlir/test/Dialect/SPIRV/IR/availability.mlir
index 9c8665b1e4bbe..f56bc3967b4b7 100644
--- a/mlir/test/Dialect/SPIRV/IR/availability.mlir
+++ b/mlir/test/Dialect/SPIRV/IR/availability.mlir
@@ -292,3 +292,17 @@ func.func @set_mesh_outputs(%0 : i32, %1 : i32) -> () {
spirv.EXT.SetMeshOutputs %0, %1 : i32, i32
spirv.Return
}
+
+//===----------------------------------------------------------------------===//
+// Replicated Composite Constant op
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: constant_composite_replicate
+func.func @constant_composite_replicate() -> () {
+ // CHECK: min version: v1.0
+ // CHECK: max version: v1.6
+ // CHECK: extensions: [ [SPV_EXT_replicated_composites] ]
+ // CHECK: capabilities: [ [ReplicatedCompositesEXT] ]
+ %0 = spirv.EXT.ConstantCompositeReplicate [1 : i32] : vector<2xi32>
+ spirv.Return
+}
diff --git a/mlir/test/Dialect/SPIRV/IR/structure-ops.mlir b/mlir/test/Dialect/SPIRV/IR/structure-ops.mlir
index 207549afdda94..99ad2a8a2e64b 100644
--- a/mlir/test/Dialect/SPIRV/IR/structure-ops.mlir
+++ b/mlir/test/Dialect/SPIRV/IR/structure-ops.mlir
@@ -163,6 +163,51 @@ func.func @coop_matrix_const_wrong_type() -> () {
return
}
+// -----
+
+//===----------------------------------------------------------------------===//
+// spirv.EXT.ConstantCompositeReplicate
+//===----------------------------------------------------------------------===//
+
+func.func @ccr_result_not_composite() -> () {
+ // expected-error @+1 {{op result #0 must be vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float or BFloat16 values of length 2/3/4/8/16 or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type or any SPIR-V tensorArm type, but got 'i32'}}
+ %0 = spirv.EXT.ConstantCompositeReplicate [1 : i32] : i32
+ return
+}
+
+// -----
+
+func.func @ccr_wrong_splat_type() -> () {
+ // expected-error @+1 {{expected value attribute type 'f32', but got: 'i32'}}
+ %0 = spirv.EXT.ConstantCompositeReplicate [1 : i32] : vector<2xf32>
+ return
+}
+
+// -----
+
+func.func @ccr_wrong_splat_type() -> () {
+ // expected-error @+1 {{expected value attribute type '!spirv.array<3 x i32>' or 'i32', but got: 'vector<2xi32>'}}
+ %0 = spirv.EXT.ConstantCompositeReplicate [dense<[1, 2]> : vector<2xi32>] : !spirv.array<2 x !spirv.array<3 x i32>>
+ return
+}
+
+// -----
+
+func.func @ccr_wrong_splat_type() -> () {
+ // expected-error @+1 {{expected value attribute type 'f32', but got: 'i32'}}
+ %0 = spirv.EXT.ConstantCompositeReplicate [1 : i32] : !spirv.arm.tensor<2x3xf32>
+ return
+}
+
+// -----
+
+func.func @ccr_wrong_splat_type() -> () {
+ // expected-error @+1 {{expected value attribute type 'vector<3xi32>' or 'i32', but got: 'vector<2xi32>'}}
+ %0 = spirv.EXT.ConstantCompositeReplicate [dense<[1, 2]> : vector<2xi32>] : !spirv.array<2 x vector<3xi32>>
+ return
+}
+
+
// -----
//===----------------------------------------------------------------------===//
@@ -854,6 +899,48 @@ spirv.module Logical GLSL450 {
spirv.SpecConstantComposite @scc (@sc1) : !spirv.coopmatrix<8x16xf32, Device, MatrixA>
}
+//===----------------------------------------------------------------------===//
+// spirv.EXT.SpecConstantCompositeReplicate
+//===----------------------------------------------------------------------===//
+
+// -----
+
+spirv.module Logical GLSL450 {
+ // expected-error @+1 {{result type must be a composite type, but provided 'i32'}}
+ spirv.EXT.SpecConstantCompositeReplicate @sccr (@sc_i32_1) : i32
+}
+
+// -----
+
+spirv.module Logical GLSL450 {
+ // expected-error @+1 {{splat spec constant reference defining constituent not found}}
+ spirv.EXT.SpecConstantCompositeReplicate @sccr (@sc_f32_1) : !spirv.array<3 x i32>
+}
+
+// -----
+
+spirv.module Logical GLSL450 {
+ spirv.SpecConstant @sc_f32_1 = 1.0 : f32
+ // expected-error @+1 {{constituent has incorrect type: expected 'i32', but provided 'f32'}}
+ spirv.EXT.SpecConstantCompositeReplicate @sccr (@sc_f32_1) : !spirv.array<3 x i32>
+}
+
+// -----
+
+spirv.module Logical GLSL450 {
+ spirv.SpecConstant @sc_f32_1 = 1.0 : f32
+ // expected-error @+1 {{constituent has incorrect type: expected 'i32', but provided 'f32'}}
+ spirv.EXT.SpecConstantCompositeReplicate @sccr (@sc_f32_1) : !spirv.struct<(i32, i32, i32)>
+}
+
+// -----
+
+spirv.module Logical GLSL450 {
+ spirv.SpecConstant @sc_f32_1 = 1.0 : f32
+ // expected-error @+1 {{constituent has incorrect type: expected 'i32', but provided 'f32'}}
+ spirv.EXT.SpecConstantCompositeReplicate @sccr (@sc_f32_1) : !spirv.arm.tensor<2x3xi32>
+}
+
//===----------------------------------------------------------------------===//
// spirv.SpecConstantOperation
//===----------------------------------------------------------------------===//
diff --git a/mlir/test/Target/SPIRV/constant.mlir b/mlir/test/Target/SPIRV/constant.mlir
index 8d4e53418b70f..76d34c2a96e67 100644
--- a/mlir/test/Target/SPIRV/constant.mlir
+++ b/mlir/test/Target/SPIRV/constant.mlir
@@ -1,4 +1,4 @@
-// RUN: mlir-translate --no-implicit-module --test-spirv-roundtrip %s | FileCheck %s
+// RUN: mlir-translate --no-implicit-module --split-input-file --test-spirv-roundtrip %s | FileCheck %s
spirv.module Logical GLSL450 requires #spirv.vce<v1.0, [Shader], []> {
// CHECK-LABEL: @bool_const
@@ -306,3 +306,106 @@ spirv.module Logical GLSL450 requires #spirv.vce<v1.0, [Shader], []> {
spirv.ReturnValue %coop : !spirv.coopmatrix<16x16xi8, Subgroup, MatrixAcc>
}
}
+
+// -----
+
+spirv.module Logical GLSL450 requires #spirv.vce<v1.0, [Shader, ReplicatedCompositesEXT], [SPV_EXT_replicated_composites]> {
+
+ // CHECK-LABEL: @splat_vector_i32
+ spirv.func @splat_vector_i32() -> (vector<3xi32>) "None" {
+ // CHECK: spirv.EXT.ConstantCompositeReplicate [1 : i32] : vector<3xi32>
+ %1 = spirv.EXT.ConstantCompositeReplicate [1 : i32] : vector<3xi32>
+ spirv.ReturnValue %1 : vector<3xi32>
+ }
+
+ // CHECK-LABEL: @splat_array_of_i32
+ spirv.func @splat_array_of_i32() -> (!spirv.array<3 x i32>) "None" {
+ // CHECK: spirv.EXT.ConstantCompositeReplicate [1 : i32] : !spirv.array<3 x i32>
+ %1 = spirv.EXT.ConstantCompositeReplicate [1 : i32] : !spirv.array<3 x i32>
+ spirv.ReturnValue %1 : !spirv.array<3 x i32>
+ }
+
+ // CHECK-LABEL: @splat_array_of_vectors_of_i32
+ spirv.func @splat_array_of_vectors_of_i32() -> (!spirv.array<3 x vector<2xi32>>) "None" {
+ // CHECK: spirv.EXT.ConstantCompositeReplicate [dense<[1, 2]> : vector<2xi32>] : !spirv.array<3 x vector<2xi32>>
+ %0 = spirv.EXT.ConstantCompositeReplicate [dense<[1, 2]> : vector<2xi32>] : !spirv.array<3 x vector<2xi32>>
+ spirv.ReturnValue %0 : !spirv.array<3 x vector<2xi32>>
+ }
+
+ // CHECK-LABEL: @splat_array_of_splat_array_of_i32
+ spirv.func @splat_array_of_splat_array_of_i32() -> (!spirv.array<2 x !spirv.array<3 x i32>>) "None" {
+ // CHECK: %0 = spirv.EXT.ConstantCompositeReplicate [3 : i32] : !spirv.array<2 x !spirv.array<3 x i32>>
+ %0 = spirv.EXT.ConstantCompositeReplicate [3 : i32] : !spirv.array<2 x !spirv.array<3 x i32>>
+ spirv.ReturnValue %0 : !spirv.array<2 x !spirv.array<3 x i32>>
+ }
+
+ // CHECK-LABEL: @splat_array_of_non_splat_array_of_i32
+ spirv.func @splat_array_of_non_splat_array_of_i32() -> (!spirv.array<2 x !spirv.array<3 x i32>>) "None" {
+ // CHECK: %0 = spirv.EXT.ConstantCompositeReplicate {{\[}}[1 : i32, 2 : i32, 3 : i32]] : !spirv.array<2 x !spirv.array<3 x i32>>
+ %0 = spirv.EXT.ConstantCompositeReplicate [[1 : i32, 2 : i32, 3 : i32]] : !spirv.array<2 x !spirv.array<3 x i32>>
+ spirv.ReturnValue %0 : !spirv.array<2 x !spirv.array<3 x i32>>
+ }
+
+ // CHECK-LABEL: @splat_array_of_splat_vectors_of_i32
+ spirv.func @splat_array_of_splat_vectors_of_i32() -> (!spirv.array<2 x vector<2xi32>>) "None" {
+ // CHECK: spirv.EXT.ConstantCompositeReplicate [2 : i32] : !spirv.array<2 x vector<2xi32>>
+ %0 = spirv.EXT.ConstantCompositeReplicate [2 : i32] : !spirv.array<2 x vector<2xi32>>
+ spirv.ReturnValue %0 : !spirv.array<2 x vector<2xi32>>
+ }
+
+ // CHECK-LABEL: @splat_arm_tensor_of_i32
+ spirv.func @splat_arm_tensor_of_i32() -> (!spirv.arm.tensor<2x3xi32>) "None" {
+ // CHECK: spirv.EXT.ConstantCompositeReplicate [2 : i32] : !spirv.arm.tensor<2x3xi32>
+ %0 = spirv.EXT.ConstantCompositeReplicate [2 : i32] : !spirv.arm.tensor<2x3xi32>
+ spirv.ReturnValue %0 : !spirv.arm.tensor<2x3xi32>
+ }
+
+ // CHECK-LABEL: @splat_vector_f32
+ spirv.func @splat_vector_f32() -> (vector<3xf32>) "None" {
+ // CHECK: spirv.EXT.ConstantCompositeReplicate [1.000000e+00 : f32] : vector<3xf32>
+ %1 = spirv.EXT.ConstantCompositeReplicate [1.0 : f32] : vector<3xf32>
+ spirv.ReturnValue %1 : vector<3xf32>
+ }
+
+ // CHECK-LABEL: @splat_array_of_f32
+ spirv.func @splat_array_of_f32() -> (!spirv.array<3 x f32>) "None" {
+ // CHECK: spirv.EXT.ConstantCompositeReplicate [1.000000e+00 : f32] : !spirv.array<3 x f32>
+ %1 = spirv.EXT.ConstantCompositeReplicate [1.0 : f32] : !spirv.array<3 x f32>
+ spirv.ReturnValue %1 : !spirv.array<3 x f32>
+ }
+
+ // CHECK-LABEL: @splat_array_of_splat_array_of_f32
+ spirv.func @splat_array_of_splat_array_of_f32() -> (!spirv.array<2 x !spirv.array<3 x f32>>) "None" {
+ // CHECK: %0 = spirv.EXT.ConstantCompositeReplicate [3.000000e+00 : f32] : !spirv.array<2 x !spirv.array<3 x f32>>
+ %0 = spirv.EXT.ConstantCompositeReplicate [3.0 : f32] : !spirv.array<2 x !spirv.array<3 x f32>>
+ spirv.ReturnValue %0 : !spirv.array<2 x !spirv.array<3 x f32>>
+ }
+
+ // CHECK-LABEL: @splat_array_of_non_splat_array_of_f32
+ spirv.func @splat_array_of_non_splat_array_of_f32() -> (!spirv.array<2 x !spirv.array<3 x f32>>) "None" {
+ // CHECK: %0 = spirv.EXT.ConstantCompositeReplicate {{\[}}[1.000000e+00 : f32, 2.000000e+00 : f32, 3.000000e+00 : f32]] : !spirv.array<2 x !spirv.array<3 x f32>>
+ %0 = spirv.EXT.ConstantCompositeReplicate [[1.0 : f32, 2.0 : f32, 3.0 : f32]] : !spirv.array<2 x !spirv.array<3 x f32>>
+ spirv.ReturnValue %0 : !spirv.array<2 x !spirv.array<3 x f32>>
+ }
+
+ // CHECK-LABEL: @splat_array_of_vectors_of_f32
+ spirv.func @splat_array_of_vectors_of_f32() -> (!spirv.array<3 x vector<2xf32>>) "None" {
+ // CHECK: spirv.EXT.ConstantCompositeReplicate [dense<[1.000000e+00, 2.000000e+00]> : vector<2xf32>] : !spirv.array<3 x vector<2xf32>>
+ %0 = spirv.EXT.ConstantCompositeReplicate [dense<[1.0, 2.0]> : vector<2xf32>] : !spirv.array<3 x vector<2xf32>>
+ spirv.ReturnValue %0 : !spirv.array<3 x vector<2xf32>>
+ }
+
+ // CHECK-LABEL: @splat_array_of_splat_vectors_of_f32
+ spirv.func @splat_array_of_splat_vectors_of_f32() -> (!spirv.array<2 x vector<2xf32>>) "None" {
+ // CHECK: spirv.EXT.ConstantCompositeReplicate [2.000000e+00 : f32] : !spirv.array<2 x vector<2xf32>>
+ %0 = spirv.EXT.ConstantCompositeReplicate [2.0 : f32] : !spirv.array<2 x vector<2xf32>>
+ spirv.ReturnValue %0 : !spirv.array<2 x vector<2xf32>>
+ }
+
+ // CHECK-LABEL: @splat_arm_tensor_of_f32
+ spirv.func @splat_arm_tensor_of_f32() -> (!spirv.arm.tensor<2x3xf32>) "None" {
+ // CHECK: spirv.EXT.ConstantCompositeReplicate [2.000000e+00 : f32] : !spirv.arm.tensor<2x3xf32>
+ %0 = spirv.EXT.ConstantCompositeReplicate [2.0 : f32] : !spirv.arm.tensor<2x3xf32>
+ spirv.ReturnValue %0 : !spirv.arm.tensor<2x3xf32>
+ }
+}
diff --git a/mlir/test/Target/SPIRV/spec-constant.mlir b/mlir/test/Target/SPIRV/spec-constant.mlir
index 078d77125b3fd..f434956ab34a3 100644
--- a/mlir/test/Target/SPIRV/spec-constant.mlir
+++ b/mlir/test/Target/SPIRV/spec-constant.mlir
@@ -88,6 +88,33 @@ spirv.module Logical GLSL450 requires #spirv.vce<v1.0, [Shader], []> {
// -----
+spirv.module Logical GLSL450 requires #spirv.vce<v1.0, [Shader, ReplicatedCompositesEXT], [SPV_EXT_replicated_composites]> {
+
+ spirv.SpecConstant @sc_i32_1 = 1 : i32
+
+ // CHECK: spirv.EXT.SpecConstantCompositeReplicate @scc_splat_array_of_i32 (@sc_i32_1) : !spirv.array<3 x i32>
+ spirv.EXT.SpecConstantCompositeReplicate @scc_splat_array_of_i32 (@sc_i32_1) : !spirv.array<3 x i32>
+
+ // CHECK: spirv.EXT.SpecConstantCompositeReplicate @scc_splat_struct_of_i32 (@sc_i32_1) : !spirv.struct<(i32, i32, i32)>
+ spirv.EXT.SpecConstantCompositeReplicate @scc_splat_struct_of_i32 (@sc_i32_1) : !spirv.struct<(i32, i32, i32)>
+
+ // CHECK: spirv.EXT.SpecConstantCompositeReplicate @scc_splat_vector_of_i32 (@sc_i32_1) : vector<3xi32>
+ spirv.EXT.SpecConstantCompositeReplicate @scc_splat_vector_of_i32 (@sc_i32_1) : vector<3 x i32>
+
+ spirv.SpecConstant @sc_f32_1 = 1.0 : f32
+
+ // CHECK: spirv.EXT.SpecConstantCompositeReplicate @scc_splat_array_of_f32 (@sc_f32_1) : !spirv.array<3 x f32>
+ spirv.EXT.SpecConstantCompositeReplicate @scc_splat_array_of_f32 (@sc_f32_1) : !spirv.array<3 x f32>
+
+ // CHECK: spirv.EXT.SpecConstantCompositeReplicate @scc_splat_struct_of_f32 (@sc_f32_1) : !spirv.struct<(f32, f32, f32)>
+ spirv.EXT.SpecConstantCompositeReplicate @scc_splat_struct_of_f32 (@sc_f32_1) : !spirv.struct<(f32, f32, f32)>
+
+ // CHECK: spirv.EXT.SpecConstantCompositeReplicate @scc_splat_vector_of_f32 (@sc_f32_1) : vector<3xf32>
+ spirv.EXT.SpecConstantCompositeReplicate @scc_splat_vector_of_f32 (@sc_f32_1) : vector<3 x f32>
+}
+
+// -----
+
spirv.module Logical GLSL450 requires #spirv.vce<v1.0, [Shader], []> {
spirv.SpecConstant @sc_i32_1 = 1 : i32
More information about the Mlir-commits
mailing list