forked from OSchip/llvm-project
[VectorOps] unify vector dialect "subscripts"
PiperOrigin-RevId: 286650682
This commit is contained in:
Aart Bik
A. Unique TensorFlower
parent
67c019ddac
commit
1d47564a53
|
|
@ -394,7 +394,7 @@ def LLVM_InsertValueOp : LLVM_OneResultOp<"insertvalue", [NoSideEffect]>,
|
|||
}
|
||||
def LLVM_ShuffleVectorOp
|
||||
: LLVM_OneResultOp<"shufflevector", [NoSideEffect]>,
|
||||
Arguments<(ins LLVM_Type:$v1, LLVM_Type:$v2, I32ArrayAttr:$mask)>,
|
||||
Arguments<(ins LLVM_Type:$v1, LLVM_Type:$v2, ArrayAttr:$mask)>,
|
||||
LLVM_Builder<
|
||||
"$res = builder.CreateShuffleVector($v1, $v2, extractPosition($mask));"> {
|
||||
let builders = [OpBuilder<
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ IntegerType getVectorSubscriptType(Builder &builder);
|
|||
|
||||
/// Returns an integer array attribute containing the given values using
|
||||
/// the integer type required for subscripts in the vector dialect.
|
||||
ArrayAttr getVectorSubscriptAttr(Builder &b, ArrayRef<int32_t> values);
|
||||
ArrayAttr getVectorSubscriptAttr(Builder &b, ArrayRef<int64_t> values);
|
||||
|
||||
#define GET_OP_CLASSES
|
||||
#include "mlir/Dialect/VectorOps/VectorOps.h.inc"
|
||||
|
|
|
|||
|
|
@ -220,7 +220,7 @@ def Vector_ShuffleOp :
|
|||
TCresVTEtIsSameAsOpBase<0, 0>>,
|
||||
PredOpTrait<"second operand v2 and result have same element type",
|
||||
TCresVTEtIsSameAsOpBase<0, 1>>]>,
|
||||
Arguments<(ins AnyVector:$v1, AnyVector:$v2, I32ArrayAttr:$mask)>,
|
||||
Arguments<(ins AnyVector:$v1, AnyVector:$v2, I64ArrayAttr:$mask)>,
|
||||
Results<(outs AnyVector:$vector)> {
|
||||
let summary = "shuffle operation";
|
||||
let description = [{
|
||||
|
|
@ -243,16 +243,16 @@ def Vector_ShuffleOp :
|
|||
|
||||
Examples:
|
||||
```
|
||||
%0 = vector.shuffle %a, %b[0:i32, 3:i32]
|
||||
%0 = vector.shuffle %a, %b[0, 3]
|
||||
: vector<2xf32>, vector<2xf32> ; yields vector<2xf32>
|
||||
%1 = vector.shuffle %c, %b[0:i32, 1:i32, 2:i32]
|
||||
%1 = vector.shuffle %c, %b[0, 1, 2]
|
||||
: vector<2x16xf32>, vector<1x16xf32> ; yields vector<3x16xf32>
|
||||
%2 = vector.shuffle %a, %b[3:i32, 2:i32, 1:i32 : 0:i32]
|
||||
%2 = vector.shuffle %a, %b[3, 2, 1, 0]
|
||||
: vector<2xf32>, vector<2xf32> ; yields vector<4xf32>
|
||||
|
||||
```
|
||||
}];
|
||||
let builders = [OpBuilder<"Builder *builder, OperationState &result, Value *v1, Value *v2, ArrayRef<int32_t>">];
|
||||
let builders = [OpBuilder<"Builder *builder, OperationState &result, Value *v1, Value *v2, ArrayRef<int64_t>">];
|
||||
let extraClassDeclaration = [{
|
||||
static StringRef getMaskAttrName() { return "mask"; }
|
||||
VectorType getV1VectorType() {
|
||||
|
|
@ -271,7 +271,7 @@ def Vector_ExtractElementOp :
|
|||
Vector_Op<"extractelement", [NoSideEffect,
|
||||
PredOpTrait<"operand and result have same element type",
|
||||
TCresVTEtIsSameAsOpBase<0, 0>>]>,
|
||||
Arguments<(ins AnyVector:$vector, I32:$position)>,
|
||||
Arguments<(ins AnyVector:$vector, AnyInteger:$position)>,
|
||||
Results<(outs AnyType)> {
|
||||
let summary = "extractelement operation";
|
||||
let description = [{
|
||||
|
|
@ -298,7 +298,7 @@ def Vector_ExtractOp :
|
|||
Vector_Op<"extract", [NoSideEffect,
|
||||
PredOpTrait<"operand and result have same element type",
|
||||
TCresVTEtIsSameAsOpBase<0, 0>>]>,
|
||||
Arguments<(ins AnyVector:$vector, I32ArrayAttr:$position)>,
|
||||
Arguments<(ins AnyVector:$vector, I64ArrayAttr:$position)>,
|
||||
Results<(outs AnyType)> {
|
||||
let summary = "extract operation";
|
||||
let description = [{
|
||||
|
|
@ -312,7 +312,7 @@ def Vector_ExtractOp :
|
|||
```
|
||||
}];
|
||||
let builders = [OpBuilder<
|
||||
"Builder *builder, OperationState &result, Value *source, ArrayRef<int32_t>">];
|
||||
"Builder *builder, OperationState &result, Value *source, ArrayRef<int64_t>">];
|
||||
let extraClassDeclaration = [{
|
||||
static StringRef getPositionAttrName() { return "position"; }
|
||||
VectorType getVectorType() {
|
||||
|
|
@ -379,7 +379,7 @@ def Vector_InsertElementOp :
|
|||
TCresVTEtIsSameAsOpBase<0, 0>>,
|
||||
PredOpTrait<"dest operand and result have same type",
|
||||
TCresIsSameAsOpBase<0, 1>>]>,
|
||||
Arguments<(ins AnyType:$source, AnyVector:$dest, I32:$position)>,
|
||||
Arguments<(ins AnyType:$source, AnyVector:$dest, AnyInteger:$position)>,
|
||||
Results<(outs AnyVector)> {
|
||||
let summary = "insertelement operation";
|
||||
let description = [{
|
||||
|
|
@ -411,7 +411,7 @@ def Vector_InsertOp :
|
|||
TCresVTEtIsSameAsOpBase<0, 0>>,
|
||||
PredOpTrait<"dest operand and result have same type",
|
||||
TCresIsSameAsOpBase<0, 1>>]>,
|
||||
Arguments<(ins AnyType:$source, AnyVector:$dest, I32ArrayAttr:$position)>,
|
||||
Arguments<(ins AnyType:$source, AnyVector:$dest, I64ArrayAttr:$position)>,
|
||||
Results<(outs AnyVector)> {
|
||||
let summary = "insert operation";
|
||||
let description = [{
|
||||
|
|
@ -421,15 +421,15 @@ def Vector_InsertOp :
|
|||
|
||||
Examples:
|
||||
```
|
||||
%2 = vector.insert %0, %1[3 : i32]:
|
||||
%2 = vector.insert %0, %1[3]:
|
||||
vector<8x16xf32> into vector<4x8x16xf32>
|
||||
%5 = vector.insert %3, %4[3 : i32, 3 : i32, 3 : i32]:
|
||||
%5 = vector.insert %3, %4[3, 3, 3]:
|
||||
f32 into vector<4x8x16xf32>
|
||||
```
|
||||
}];
|
||||
let builders = [OpBuilder<
|
||||
"Builder *builder, OperationState &result, Value *source, " #
|
||||
"Value *dest, ArrayRef<int32_t>">];
|
||||
"Value *dest, ArrayRef<int64_t>">];
|
||||
let extraClassDeclaration = [{
|
||||
static StringRef getPositionAttrName() { return "position"; }
|
||||
Type getSourceType() { return source()->getType(); }
|
||||
|
|
|
|||
|
|
@ -370,8 +370,8 @@ public:
|
|||
|
||||
// Remaining extraction of element from 1-D LLVM vector
|
||||
auto position = positionAttrs.back().cast<IntegerAttr>();
|
||||
auto i32Type = LLVM::LLVMType::getInt32Ty(lowering.getDialect());
|
||||
auto constant = rewriter.create<LLVM::ConstantOp>(loc, i32Type, position);
|
||||
auto i64Type = LLVM::LLVMType::getInt64Ty(lowering.getDialect());
|
||||
auto constant = rewriter.create<LLVM::ConstantOp>(loc, i64Type, position);
|
||||
extracted =
|
||||
rewriter.create<LLVM::ExtractElementOp>(loc, extracted, constant);
|
||||
rewriter.replaceOp(op, extracted);
|
||||
|
|
@ -452,8 +452,8 @@ public:
|
|||
}
|
||||
|
||||
// Insertion of an element into a 1-D LLVM vector.
|
||||
auto i32Type = LLVM::LLVMType::getInt32Ty(lowering.getDialect());
|
||||
auto constant = rewriter.create<LLVM::ConstantOp>(loc, i32Type, position);
|
||||
auto i64Type = LLVM::LLVMType::getInt64Ty(lowering.getDialect());
|
||||
auto constant = rewriter.create<LLVM::ConstantOp>(loc, i64Type, position);
|
||||
Value *inserted = rewriter.create<LLVM::InsertElementOp>(
|
||||
loc, lowering.convertType(oneDVectorType), extracted, adaptor.source(),
|
||||
constant);
|
||||
|
|
|
|||
|
|
@ -59,12 +59,12 @@ Operation *VectorOpsDialect::materializeConstant(OpBuilder &builder,
|
|||
}
|
||||
|
||||
IntegerType vector::getVectorSubscriptType(Builder &builder) {
|
||||
return builder.getIntegerType(32);
|
||||
return builder.getIntegerType(64);
|
||||
}
|
||||
|
||||
ArrayAttr vector::getVectorSubscriptAttr(Builder &builder,
|
||||
ArrayRef<int32_t> values) {
|
||||
return builder.getI32ArrayAttr(values);
|
||||
ArrayRef<int64_t> values) {
|
||||
return builder.getI64ArrayAttr(values);
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
|
@ -404,7 +404,7 @@ static Type inferExtractOpResultType(VectorType vectorType,
|
|||
}
|
||||
|
||||
void vector::ExtractOp::build(Builder *builder, OperationState &result,
|
||||
Value *source, ArrayRef<int32_t> position) {
|
||||
Value *source, ArrayRef<int64_t> position) {
|
||||
result.addOperands(source);
|
||||
auto positionAttr = getVectorSubscriptAttr(*builder, position);
|
||||
result.addTypes(inferExtractOpResultType(source->getType().cast<VectorType>(),
|
||||
|
|
@ -475,8 +475,8 @@ void ExtractSlicesOp::build(Builder *builder, OperationState &result,
|
|||
ArrayRef<int64_t> sizes,
|
||||
ArrayRef<int64_t> strides) {
|
||||
result.addOperands(vector);
|
||||
auto sizesAttr = builder->getI64ArrayAttr(sizes);
|
||||
auto stridesAttr = builder->getI64ArrayAttr(strides);
|
||||
auto sizesAttr = getVectorSubscriptAttr(*builder, sizes);
|
||||
auto stridesAttr = getVectorSubscriptAttr(*builder, strides);
|
||||
result.addTypes(tupleType);
|
||||
result.addAttribute(getSizesAttrName(), sizesAttr);
|
||||
result.addAttribute(getStridesAttrName(), stridesAttr);
|
||||
|
|
@ -648,7 +648,7 @@ static ParseResult parseBroadcastOp(OpAsmParser &parser,
|
|||
//===----------------------------------------------------------------------===//
|
||||
|
||||
void ShuffleOp::build(Builder *builder, OperationState &result, Value *v1,
|
||||
Value *v2, ArrayRef<int32_t> mask) {
|
||||
Value *v2, ArrayRef<int64_t> mask) {
|
||||
result.addOperands({v1, v2});
|
||||
auto maskAttr = getVectorSubscriptAttr(*builder, mask);
|
||||
result.addTypes(v1->getType());
|
||||
|
|
@ -772,7 +772,7 @@ static LogicalResult verify(InsertElementOp op) {
|
|||
//===----------------------------------------------------------------------===//
|
||||
|
||||
void InsertOp::build(Builder *builder, OperationState &result, Value *source,
|
||||
Value *dest, ArrayRef<int32_t> position) {
|
||||
Value *dest, ArrayRef<int64_t> position) {
|
||||
result.addOperands({source, dest});
|
||||
auto positionAttr = getVectorSubscriptAttr(*builder, position);
|
||||
result.addTypes(dest->getType());
|
||||
|
|
@ -897,8 +897,8 @@ void InsertStridedSliceOp::build(Builder *builder, OperationState &result,
|
|||
ArrayRef<int64_t> offsets,
|
||||
ArrayRef<int64_t> strides) {
|
||||
result.addOperands({source, dest});
|
||||
auto offsetsAttr = builder->getI64ArrayAttr(offsets);
|
||||
auto stridesAttr = builder->getI64ArrayAttr(strides);
|
||||
auto offsetsAttr = getVectorSubscriptAttr(*builder, offsets);
|
||||
auto stridesAttr = getVectorSubscriptAttr(*builder, strides);
|
||||
result.addTypes(dest->getType());
|
||||
result.addAttribute(getOffsetsAttrName(), offsetsAttr);
|
||||
result.addAttribute(getStridesAttrName(), stridesAttr);
|
||||
|
|
@ -1250,9 +1250,9 @@ void StridedSliceOp::build(Builder *builder, OperationState &result,
|
|||
Value *source, ArrayRef<int64_t> offsets,
|
||||
ArrayRef<int64_t> sizes, ArrayRef<int64_t> strides) {
|
||||
result.addOperands(source);
|
||||
auto offsetsAttr = builder->getI64ArrayAttr(offsets);
|
||||
auto sizesAttr = builder->getI64ArrayAttr(sizes);
|
||||
auto stridesAttr = builder->getI64ArrayAttr(strides);
|
||||
auto offsetsAttr = getVectorSubscriptAttr(*builder, offsets);
|
||||
auto sizesAttr = getVectorSubscriptAttr(*builder, sizes);
|
||||
auto stridesAttr = getVectorSubscriptAttr(*builder, strides);
|
||||
result.addTypes(
|
||||
inferStridedSliceOpResultType(source->getType().cast<VectorType>(),
|
||||
offsetsAttr, sizesAttr, stridesAttr));
|
||||
|
|
@ -1375,7 +1375,7 @@ public:
|
|||
// Replace 'stridedSliceOp' with ConstantMaskOp with sliced mask region.
|
||||
rewriter.replaceOpWithNewOp<ConstantMaskOp>(
|
||||
stridedSliceOp, stridedSliceOp.getResult()->getType(),
|
||||
rewriter.getI64ArrayAttr(sliceMaskDimSizes));
|
||||
vector::getVectorSubscriptAttr(rewriter, sliceMaskDimSizes));
|
||||
return matchSuccess();
|
||||
}
|
||||
};
|
||||
|
|
@ -1807,7 +1807,7 @@ public:
|
|||
// Replace 'createMaskOp' with ConstantMaskOp.
|
||||
rewriter.replaceOpWithNewOp<ConstantMaskOp>(
|
||||
createMaskOp, createMaskOp.getResult()->getType(),
|
||||
rewriter.getI64ArrayAttr(maskDimSizes));
|
||||
vector::getVectorSubscriptAttr(rewriter, maskDimSizes));
|
||||
return matchSuccess();
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -231,15 +231,15 @@ func @outerproduct_add(%arg0: vector<2xf32>, %arg1: vector<3xf32>, %arg2: vector
|
|||
// CHECK: llvm.return {{.*}} : !llvm<"[2 x <3 x float>]">
|
||||
|
||||
func @shuffle_1D_direct(%arg0: vector<2xf32>, %arg1: vector<2xf32>) -> vector<2xf32> {
|
||||
%1 = vector.shuffle %arg0, %arg1 [0 : i32, 1 : i32] : vector<2xf32>, vector<2xf32>
|
||||
%1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<2xf32>
|
||||
return %1 : vector<2xf32>
|
||||
}
|
||||
// CHECK-LABEL: shuffle_1D_direct(%arg0: !llvm<"<2 x float>">, %arg1: !llvm<"<2 x float>">)
|
||||
// CHECK: %[[s:.*]] = llvm.shufflevector %arg0, %arg1 [0 : i32, 1 : i32] : !llvm<"<2 x float>">, !llvm<"<2 x float>">
|
||||
// CHECK: %[[s:.*]] = llvm.shufflevector %arg0, %arg1 [0, 1] : !llvm<"<2 x float>">, !llvm<"<2 x float>">
|
||||
// CHECK: llvm.return %[[s]] : !llvm<"<2 x float>">
|
||||
|
||||
func @shuffle_1D(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<5xf32> {
|
||||
%1 = vector.shuffle %arg0, %arg1 [4 : i32, 3 : i32, 2 : i32, 1 : i32, 0 : i32] : vector<2xf32>, vector<3xf32>
|
||||
%1 = vector.shuffle %arg0, %arg1 [4, 3, 2, 1, 0] : vector<2xf32>, vector<3xf32>
|
||||
return %1 : vector<5xf32>
|
||||
}
|
||||
// CHECK-LABEL: shuffle_1D(%arg0: !llvm<"<2 x float>">, %arg1: !llvm<"<3 x float>">)
|
||||
|
|
@ -267,7 +267,7 @@ func @shuffle_1D(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<5xf32> {
|
|||
// CHECK: llvm.return %[[i5]] : !llvm<"<5 x float>">
|
||||
|
||||
func @shuffle_2D(%a: vector<1x4xf32>, %b: vector<2x4xf32>) -> vector<3x4xf32> {
|
||||
%1 = vector.shuffle %a, %b[1 : i32, 0 : i32, 2: i32] : vector<1x4xf32>, vector<2x4xf32>
|
||||
%1 = vector.shuffle %a, %b[1, 0, 2] : vector<1x4xf32>, vector<2x4xf32>
|
||||
return %1 : vector<3x4xf32>
|
||||
}
|
||||
// CHECK-LABEL: shuffle_2D(%arg0: !llvm<"[1 x <4 x float>]">, %arg1: !llvm<"[2 x <4 x float>]">)
|
||||
|
|
@ -291,38 +291,38 @@ func @extract_element(%arg0: vector<16xf32>) -> f32 {
|
|||
// CHECK: llvm.return %[[x]] : !llvm.float
|
||||
|
||||
func @extract_element_from_vec_1d(%arg0: vector<16xf32>) -> f32 {
|
||||
%0 = vector.extract %arg0[15 : i32]: vector<16xf32>
|
||||
%0 = vector.extract %arg0[15]: vector<16xf32>
|
||||
return %0 : f32
|
||||
}
|
||||
// CHECK-LABEL: extract_element_from_vec_1d
|
||||
// CHECK: llvm.mlir.constant(15 : i32) : !llvm.i32
|
||||
// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i32] : !llvm<"<16 x float>">
|
||||
// CHECK: llvm.mlir.constant(15 : i64) : !llvm.i64
|
||||
// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<16 x float>">
|
||||
// CHECK: llvm.return {{.*}} : !llvm.float
|
||||
|
||||
func @extract_vec_2d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<3x16xf32> {
|
||||
%0 = vector.extract %arg0[0 : i32]: vector<4x3x16xf32>
|
||||
%0 = vector.extract %arg0[0]: vector<4x3x16xf32>
|
||||
return %0 : vector<3x16xf32>
|
||||
}
|
||||
// CHECK-LABEL: extract_vec_2d_from_vec_3d
|
||||
// CHECK: llvm.extractvalue {{.*}}[0 : i32] : !llvm<"[4 x [3 x <16 x float>]]">
|
||||
// CHECK: llvm.extractvalue {{.*}}[0] : !llvm<"[4 x [3 x <16 x float>]]">
|
||||
// CHECK: llvm.return {{.*}} : !llvm<"[3 x <16 x float>]">
|
||||
|
||||
func @extract_vec_1d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<16xf32> {
|
||||
%0 = vector.extract %arg0[0 : i32, 0 : i32]: vector<4x3x16xf32>
|
||||
%0 = vector.extract %arg0[0, 0]: vector<4x3x16xf32>
|
||||
return %0 : vector<16xf32>
|
||||
}
|
||||
// CHECK-LABEL: extract_vec_1d_from_vec_3d
|
||||
// CHECK: llvm.extractvalue {{.*}}[0 : i32, 0 : i32] : !llvm<"[4 x [3 x <16 x float>]]">
|
||||
// CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm<"[4 x [3 x <16 x float>]]">
|
||||
// CHECK: llvm.return {{.*}} : !llvm<"<16 x float>">
|
||||
|
||||
func @extract_element_from_vec_3d(%arg0: vector<4x3x16xf32>) -> f32 {
|
||||
%0 = vector.extract %arg0[0 : i32, 0 : i32, 0 : i32]: vector<4x3x16xf32>
|
||||
%0 = vector.extract %arg0[0, 0, 0]: vector<4x3x16xf32>
|
||||
return %0 : f32
|
||||
}
|
||||
// CHECK-LABEL: extract_element_from_vec_3d
|
||||
// CHECK: llvm.extractvalue {{.*}}[0 : i32, 0 : i32] : !llvm<"[4 x [3 x <16 x float>]]">
|
||||
// CHECK: llvm.mlir.constant(0 : i32) : !llvm.i32
|
||||
// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i32] : !llvm<"<16 x float>">
|
||||
// CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm<"[4 x [3 x <16 x float>]]">
|
||||
// CHECK: llvm.mlir.constant(0 : i64) : !llvm.i64
|
||||
// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<16 x float>">
|
||||
// CHECK: llvm.return {{.*}} : !llvm.float
|
||||
|
||||
func @insert_element(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {
|
||||
|
|
@ -336,39 +336,39 @@ func @insert_element(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {
|
|||
// CHECK: llvm.return %[[x]] : !llvm<"<4 x float>">
|
||||
|
||||
func @insert_element_into_vec_1d(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {
|
||||
%0 = vector.insert %arg0, %arg1[3 : i32] : f32 into vector<4xf32>
|
||||
%0 = vector.insert %arg0, %arg1[3] : f32 into vector<4xf32>
|
||||
return %0 : vector<4xf32>
|
||||
}
|
||||
// CHECK-LABEL: insert_element_into_vec_1d
|
||||
// CHECK: llvm.mlir.constant(3 : i32) : !llvm.i32
|
||||
// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i32] : !llvm<"<4 x float>">
|
||||
// CHECK: llvm.mlir.constant(3 : i64) : !llvm.i64
|
||||
// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
|
||||
// CHECK: llvm.return {{.*}} : !llvm<"<4 x float>">
|
||||
|
||||
func @insert_vec_2d_into_vec_3d(%arg0: vector<8x16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
|
||||
%0 = vector.insert %arg0, %arg1[3 : i32] : vector<8x16xf32> into vector<4x8x16xf32>
|
||||
%0 = vector.insert %arg0, %arg1[3] : vector<8x16xf32> into vector<4x8x16xf32>
|
||||
return %0 : vector<4x8x16xf32>
|
||||
}
|
||||
// CHECK-LABEL: insert_vec_2d_into_vec_3d
|
||||
// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3 : i32] : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
// CHECK: llvm.return {{.*}} : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
|
||||
func @insert_vec_1d_into_vec_3d(%arg0: vector<16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
|
||||
%0 = vector.insert %arg0, %arg1[3 : i32, 7 : i32] : vector<16xf32> into vector<4x8x16xf32>
|
||||
%0 = vector.insert %arg0, %arg1[3, 7] : vector<16xf32> into vector<4x8x16xf32>
|
||||
return %0 : vector<4x8x16xf32>
|
||||
}
|
||||
// CHECK-LABEL: insert_vec_1d_into_vec_3d
|
||||
// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3 : i32, 7 : i32] : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
// CHECK: llvm.return {{.*}} : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
|
||||
func @insert_element_into_vec_3d(%arg0: f32, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
|
||||
%0 = vector.insert %arg0, %arg1[3 : i32, 7 : i32, 15 : i32] : f32 into vector<4x8x16xf32>
|
||||
%0 = vector.insert %arg0, %arg1[3, 7, 15] : f32 into vector<4x8x16xf32>
|
||||
return %0 : vector<4x8x16xf32>
|
||||
}
|
||||
// CHECK-LABEL: insert_element_into_vec_3d
|
||||
// CHECK: llvm.extractvalue {{.*}}[3 : i32, 7 : i32] : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
// CHECK: llvm.mlir.constant(15 : i32) : !llvm.i32
|
||||
// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i32] : !llvm<"<16 x float>">
|
||||
// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3 : i32, 7 : i32] : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
// CHECK: llvm.extractvalue {{.*}}[3, 7] : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
// CHECK: llvm.mlir.constant(15 : i64) : !llvm.i64
|
||||
// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<16 x float>">
|
||||
// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
// CHECK: llvm.return {{.*}} : !llvm<"[4 x [8 x <16 x float>]]">
|
||||
|
||||
func @vector_type_cast(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32>> {
|
||||
|
|
|
|||
|
|
@ -32,28 +32,28 @@ func @broadcast_dim2_mismatch(%arg0: vector<4x8xf32>) {
|
|||
|
||||
func @shuffle_elt_type_mismatch(%arg0: vector<2xf32>, %arg1: vector<2xi32>) {
|
||||
// expected-error@+1 {{'vector.shuffle' op failed to verify that second operand v2 and result have same element type}}
|
||||
%1 = vector.shuffle %arg0, %arg1 [0 : i32, 1 : i32] : vector<2xf32>, vector<2xi32>
|
||||
%1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<2xi32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @shuffle_rank_mismatch(%arg0: vector<2xf32>, %arg1: vector<4x2xf32>) {
|
||||
// expected-error@+1 {{'vector.shuffle' op rank mismatch}}
|
||||
%1 = vector.shuffle %arg0, %arg1 [0 : i32, 1 : i32] : vector<2xf32>, vector<4x2xf32>
|
||||
%1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<4x2xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @shuffle_trailing_dim_size_mismatch(%arg0: vector<2x2xf32>, %arg1: vector<2x4xf32>) {
|
||||
// expected-error@+1 {{'vector.shuffle' op dimension mismatch}}
|
||||
%1 = vector.shuffle %arg0, %arg1 [0 : i32, 1 : i32] : vector<2x2xf32>, vector<2x4xf32>
|
||||
%1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2x2xf32>, vector<2x4xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @shuffle_index_out_of_range(%arg0: vector<2xf32>, %arg1: vector<2xf32>) {
|
||||
// expected-error@+1 {{'vector.shuffle' op mask index #2 out of range}}
|
||||
%1 = vector.shuffle %arg0, %arg1 [0 : i32, 4 : i32] : vector<2xf32>, vector<2xf32>
|
||||
%1 = vector.shuffle %arg0, %arg1 [0, 4] : vector<2xf32>, vector<2xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
|
@ -89,35 +89,35 @@ func @extract_position_empty(%arg0: vector<4x8x16xf32>) {
|
|||
|
||||
func @extract_position_rank_overflow(%arg0: vector<4x8x16xf32>) {
|
||||
// expected-error@+1 {{expected position attribute of rank smaller than vector}}
|
||||
%1 = vector.extract %arg0[0 : i32, 0 : i32, 0 : i32, 0 : i32] : vector<4x8x16xf32>
|
||||
%1 = vector.extract %arg0[0, 0, 0, 0] : vector<4x8x16xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @extract_position_rank_overflow_generic(%arg0: vector<4x8x16xf32>) {
|
||||
// expected-error@+1 {{expected position attribute of rank smaller than vector}}
|
||||
%1 = "vector.extract" (%arg0) { position = [0 : i32, 0 : i32, 0 : i32, 0 : i32] } : (vector<4x8x16xf32>) -> (vector<16xf32>)
|
||||
%1 = "vector.extract" (%arg0) { position = [0, 0, 0, 0] } : (vector<4x8x16xf32>) -> (vector<16xf32>)
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @extract_position_overflow(%arg0: vector<4x8x16xf32>) {
|
||||
// expected-error@+1 {{expected position attribute #2 to be a non-negative integer smaller than the corresponding vector dimension}}
|
||||
%1 = vector.extract %arg0[0 : i32, 43 : i32, 0 : i32] : vector<4x8x16xf32>
|
||||
%1 = vector.extract %arg0[0, 43, 0] : vector<4x8x16xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @extract_precise_position_overflow(%arg0: vector<4x8x16xf32>) {
|
||||
// expected-error@+1 {{expected position attribute #3 to be a non-negative integer smaller than the corresponding vector dimension}}
|
||||
%1 = vector.extract %arg0[3 : i32, 7 : i32, 16 : i32] : vector<4x8x16xf32>
|
||||
%1 = vector.extract %arg0[3, 7, 16] : vector<4x8x16xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @extract_position_overflow(%arg0: vector<4x8x16xf32>) {
|
||||
// expected-error@+1 {{expected position attribute #3 to be a non-negative integer smaller than the corresponding vector dimension}}
|
||||
%1 = vector.extract %arg0[0 : i32, 0 : i32, -1 : i32] : vector<4x8x16xf32>
|
||||
%1 = vector.extract %arg0[0, 0, -1] : vector<4x8x16xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
|
@ -147,35 +147,35 @@ func @insert_vector_type(%a: f32, %b: vector<4x8x16xf32>) {
|
|||
|
||||
func @insert_vector_type(%a: f32, %b: vector<4x8x16xf32>) {
|
||||
// expected-error@+1 {{expected position attribute of rank smaller than dest vector rank}}
|
||||
%1 = vector.insert %a, %b[3 : i32,3 : i32,3 : i32,3 : i32,3 : i32,3 : i32] : f32 into vector<4x8x16xf32>
|
||||
%1 = vector.insert %a, %b[3, 3, 3, 3, 3, 3] : f32 into vector<4x8x16xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @insert_vector_type(%a: vector<4xf32>, %b: vector<4x8x16xf32>) {
|
||||
// expected-error@+1 {{expected position attribute rank + source rank to match dest vector rank}}
|
||||
%1 = vector.insert %a, %b[3 : i32] : vector<4xf32> into vector<4x8x16xf32>
|
||||
%1 = vector.insert %a, %b[3] : vector<4xf32> into vector<4x8x16xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @insert_vector_type(%a: f32, %b: vector<4x8x16xf32>) {
|
||||
// expected-error@+1 {{expected position attribute rank to match the dest vector rank}}
|
||||
%1 = vector.insert %a, %b[3 : i32,3 : i32] : f32 into vector<4x8x16xf32>
|
||||
%1 = vector.insert %a, %b[3, 3] : f32 into vector<4x8x16xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @insert_position_overflow(%a: f32, %b: vector<4x8x16xf32>) {
|
||||
// expected-error@+1 {{expected position attribute #3 to be a non-negative integer smaller than the corresponding dest vector dimension}}
|
||||
%1 = vector.insert %a, %b[0 : i32, 0 : i32, -1 : i32] : f32 into vector<4x8x16xf32>
|
||||
%1 = vector.insert %a, %b[0, 0, -1] : f32 into vector<4x8x16xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
||||
func @insert_precise_position_overflow(%a: f32, %b: vector<4x8x16xf32>) {
|
||||
// expected-error@+1 {{expected position attribute #1 to be a non-negative integer smaller than the corresponding dest vector dimension}}
|
||||
%1 = vector.insert %a, %b[4 : i32, 7 : i32, 15 : i32] : f32 into vector<4x8x16xf32>
|
||||
%1 = vector.insert %a, %b[4, 7, 15] : f32 into vector<4x8x16xf32>
|
||||
}
|
||||
|
||||
// -----
|
||||
|
|
|
|||
|
|
@ -48,19 +48,19 @@ func @vector_broadcast(%a: f32, %b: vector<16xf32>, %c: vector<1x16xf32>, %d: ve
|
|||
|
||||
// CHECK-LABEL: @shuffle1D
|
||||
func @shuffle1D(%a: vector<2xf32>, %b: vector<4xf32>) -> vector<2xf32> {
|
||||
// CHECK: vector.shuffle %{{.*}}, %{{.*}}[0 : i32, 1 : i32, 2 : i32, 3 : i32] : vector<2xf32>, vector<2xf32>
|
||||
%1 = vector.shuffle %a, %a[0 : i32, 1 : i32, 2: i32, 3 : i32] : vector<2xf32>, vector<2xf32>
|
||||
// CHECK-NEXT: vector.shuffle %{{.*}}, %{{.*}}[0 : i32, 1 : i32, 2 : i32] : vector<4xf32>, vector<4xf32>
|
||||
%2 = vector.shuffle %1, %b[0 : i32, 1 : i32, 2 : i32] : vector<4xf32>, vector<4xf32>
|
||||
// CHECK-NEXT: vector.shuffle %{{.*}}, %{{.*}}[0 : i32, 6 : i32] : vector<3xf32>, vector<4xf32>
|
||||
%3 = vector.shuffle %2, %b[0 : i32, 6 : i32] : vector<3xf32>, vector<4xf32>
|
||||
// CHECK: vector.shuffle %{{.*}}, %{{.*}}[0, 1, 2, 3] : vector<2xf32>, vector<2xf32>
|
||||
%1 = vector.shuffle %a, %a[0, 1, 2, 3] : vector<2xf32>, vector<2xf32>
|
||||
// CHECK-NEXT: vector.shuffle %{{.*}}, %{{.*}}[0, 1, 2] : vector<4xf32>, vector<4xf32>
|
||||
%2 = vector.shuffle %1, %b[0, 1, 2] : vector<4xf32>, vector<4xf32>
|
||||
// CHECK-NEXT: vector.shuffle %{{.*}}, %{{.*}}[0, 6] : vector<3xf32>, vector<4xf32>
|
||||
%3 = vector.shuffle %2, %b[0, 6] : vector<3xf32>, vector<4xf32>
|
||||
return %3 : vector<2xf32>
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @shuffle2D
|
||||
func @shuffle2D(%a: vector<1x4xf32>, %b: vector<2x4xf32>) -> vector<3x4xf32> {
|
||||
// CHECK: vector.shuffle %{{.*}}, %{{.*}}[0 : i32, 1 : i32, 2 : i32] : vector<1x4xf32>, vector<2x4xf32>
|
||||
%1 = vector.shuffle %a, %b[0 : i32, 1 : i32, 2: i32] : vector<1x4xf32>, vector<2x4xf32>
|
||||
// CHECK: vector.shuffle %{{.*}}, %{{.*}}[0, 1, 2] : vector<1x4xf32>, vector<2x4xf32>
|
||||
%1 = vector.shuffle %a, %b[0, 1, 2] : vector<1x4xf32>, vector<2x4xf32>
|
||||
return %1 : vector<3x4xf32>
|
||||
}
|
||||
|
||||
|
|
@ -75,12 +75,12 @@ func @extract_element(%a: vector<16xf32>) -> f32 {
|
|||
|
||||
// CHECK-LABEL: @extract
|
||||
func @extract(%arg0: vector<4x8x16xf32>) -> (vector<8x16xf32>, vector<16xf32>, f32) {
|
||||
// CHECK: vector.extract {{.*}}[3 : i32] : vector<4x8x16xf32>
|
||||
%1 = vector.extract %arg0[3 : i32] : vector<4x8x16xf32>
|
||||
// CHECK-NEXT: vector.extract {{.*}}[3 : i32, 3 : i32] : vector<4x8x16xf32>
|
||||
%2 = vector.extract %arg0[3 : i32, 3 : i32] : vector<4x8x16xf32>
|
||||
// CHECK-NEXT: vector.extract {{.*}}[3 : i32, 3 : i32, 3 : i32] : vector<4x8x16xf32>
|
||||
%3 = vector.extract %arg0[3 : i32, 3 : i32, 3 : i32] : vector<4x8x16xf32>
|
||||
// CHECK: vector.extract {{.*}}[3] : vector<4x8x16xf32>
|
||||
%1 = vector.extract %arg0[3] : vector<4x8x16xf32>
|
||||
// CHECK-NEXT: vector.extract {{.*}}[3, 3] : vector<4x8x16xf32>
|
||||
%2 = vector.extract %arg0[3, 3] : vector<4x8x16xf32>
|
||||
// CHECK-NEXT: vector.extract {{.*}}[3, 3, 3] : vector<4x8x16xf32>
|
||||
%3 = vector.extract %arg0[3, 3, 3] : vector<4x8x16xf32>
|
||||
return %1, %2, %3 : vector<8x16xf32>, vector<16xf32>, f32
|
||||
}
|
||||
|
||||
|
|
@ -95,12 +95,12 @@ func @insert_element(%a: f32, %b: vector<16xf32>) -> vector<16xf32> {
|
|||
|
||||
// CHECK-LABEL: @insert
|
||||
func @insert(%a: f32, %b: vector<16xf32>, %c: vector<8x16xf32>, %res: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
|
||||
// CHECK: vector.insert %{{.*}}, %{{.*}}[3 : i32] : vector<8x16xf32> into vector<4x8x16xf32>
|
||||
%1 = vector.insert %c, %res[3 : i32] : vector<8x16xf32> into vector<4x8x16xf32>
|
||||
// CHECK: vector.insert %{{.*}}, %{{.*}}[3 : i32, 3 : i32] : vector<16xf32> into vector<4x8x16xf32>
|
||||
%2 = vector.insert %b, %res[3 : i32, 3 : i32] : vector<16xf32> into vector<4x8x16xf32>
|
||||
// CHECK: vector.insert %{{.*}}, %{{.*}}[3 : i32, 3 : i32, 3 : i32] : f32 into vector<4x8x16xf32>
|
||||
%3 = vector.insert %a, %res[3 : i32, 3 : i32, 3 : i32] : f32 into vector<4x8x16xf32>
|
||||
// CHECK: vector.insert %{{.*}}, %{{.*}}[3] : vector<8x16xf32> into vector<4x8x16xf32>
|
||||
%1 = vector.insert %c, %res[3] : vector<8x16xf32> into vector<4x8x16xf32>
|
||||
// CHECK: vector.insert %{{.*}}, %{{.*}}[3, 3] : vector<16xf32> into vector<4x8x16xf32>
|
||||
%2 = vector.insert %b, %res[3, 3] : vector<16xf32> into vector<4x8x16xf32>
|
||||
// CHECK: vector.insert %{{.*}}, %{{.*}}[3, 3, 3] : f32 into vector<4x8x16xf32>
|
||||
%3 = vector.insert %a, %res[3, 3, 3] : f32 into vector<4x8x16xf32>
|
||||
return %3 : vector<4x8x16xf32>
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue