Skip to content

Commit 75ae4a4

Browse files
dcaballedcaballe
committed
[mlir][Vector] Remove usage of vector.insertelement/extractelement from Vector
This PR is part of the last step to remove `vector.extractelement` and `vector.insertelement` ops. RFC: https://discourse.llvm.org/t/rfc-psa-remove-vector-extractelement-and-vector-insertelement-ops-in-favor-of-vector-extract-and-vector-insert-ops It removes instances of `vector.extractelement` and `vector.insertelement` from the Vector dialect layer.
1 parent a00b736 commit 75ae4a4

File tree

7 files changed

+71
-184
lines changed

7 files changed

+71
-184
lines changed

‎mlir/include/mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -233,8 +233,8 @@ void populateBreakDownVectorReductionPatterns(
233233
///
234234
/// [DecomposeNDExtractStridedSlice]
235235
/// ================================
236-
/// For such cases, we can rewrite it to ExtractOp/ExtractElementOp + lower
237-
/// rank ExtractStridedSliceOp + InsertOp/InsertElementOp for the n-D case.
236+
/// For such cases, we can rewrite it to ExtractOp + lower rank
237+
/// ExtractStridedSliceOp + InsertOp for the n-D case.
238238
void populateVectorInsertExtractStridedSliceDecompositionPatterns(
239239
RewritePatternSet &patterns, PatternBenefit benefit = 1);
240240

‎mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp‎

Lines changed: 5 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -157,7 +157,7 @@ static Value generateMaskCheck(OpBuilder &b, OpTy xferOp, Value iv) {
157157
return Value();
158158

159159
Location loc = xferOp.getLoc();
160-
return b.create<vector::ExtractElementOp>(loc, xferOp.getMask(), iv);
160+
return b.create<vector::ExtractOp>(loc, xferOp.getMask(), iv);
161161
}
162162

163163
/// Helper function TransferOpConversion and TransferOp1dConversion.
@@ -760,8 +760,7 @@ struct DecomposePrintOpConversion : public VectorToSCFPattern<vector::PrintOp> {
760760

761761
if (vectorType.getRank() != 1) {
762762
// Flatten n-D vectors to 1D. This is done to allow indexing with a
763-
// non-constant value (which can currently only be done via
764-
// vector.extractelement for 1D vectors).
763+
// non-constant value.
765764
auto flatLength = std::accumulate(shape.begin(), shape.end(), 1,
766765
std::multiplies<int64_t>());
767766
auto flatVectorType =
@@ -824,8 +823,7 @@ struct DecomposePrintOpConversion : public VectorToSCFPattern<vector::PrintOp> {
824823
}
825824

826825
// Print the scalar elements in the inner most loop.
827-
auto element =
828-
rewriter.create<vector::ExtractElementOp>(loc, value, flatIndex);
826+
auto element = rewriter.create<vector::ExtractOp>(loc, value, flatIndex);
829827
rewriter.create<vector::PrintOp>(loc, element,
830828
vector::PrintPunctuation::NoPunctuation);
831829

@@ -1567,7 +1565,7 @@ struct Strategy1d<TransferReadOp> {
15671565
/*inBoundsCase=*/
15681566
[&](OpBuilder &b, Location loc) {
15691567
Value val = b.create<memref::LoadOp>(loc, xferOp.getBase(), indices);
1570-
return b.create<vector::InsertElementOp>(loc, val, vec, iv);
1568+
return b.create<vector::InsertOp>(loc, val, vec, iv);
15711569
},
15721570
/*outOfBoundsCase=*/
15731571
[&](OpBuilder & /*b*/, Location loc) { return vec; });
@@ -1595,8 +1593,7 @@ struct Strategy1d<TransferWriteOp> {
15951593
generateInBoundsCheck(
15961594
b, xferOp, iv, dim,
15971595
/*inBoundsCase=*/[&](OpBuilder &b, Location loc) {
1598-
auto val =
1599-
b.create<vector::ExtractElementOp>(loc, xferOp.getVector(), iv);
1596+
auto val = b.create<vector::ExtractOp>(loc, xferOp.getVector(), iv);
16001597
b.create<memref::StoreOp>(loc, val, xferOp.getBase(), indices);
16011598
});
16021599
b.create<scf::YieldOp>(loc);

‎mlir/lib/Dialect/Vector/Transforms/VectorDistribute.cpp‎

Lines changed: 5 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -1255,27 +1255,6 @@ struct WarpOpExtractScalar : public WarpDistributionPattern {
12551255
WarpShuffleFromIdxFn warpShuffleFromIdxFn;
12561256
};
12571257

1258-
/// Pattern to convert vector.extractelement to vector.extract.
1259-
struct WarpOpExtractElement : public WarpDistributionPattern {
1260-
using Base::Base;
1261-
LogicalResult matchAndRewrite(WarpExecuteOnLane0Op warpOp,
1262-
PatternRewriter &rewriter) const override {
1263-
OpOperand *operand =
1264-
getWarpResult(warpOp, llvm::IsaPred<vector::ExtractElementOp>);
1265-
if (!operand)
1266-
return failure();
1267-
auto extractOp = operand->get().getDefiningOp<vector::ExtractElementOp>();
1268-
SmallVector<OpFoldResult> indices;
1269-
if (auto pos = extractOp.getPosition()) {
1270-
indices.push_back(pos);
1271-
}
1272-
rewriter.setInsertionPoint(extractOp);
1273-
rewriter.replaceOpWithNewOp<vector::ExtractOp>(
1274-
extractOp, extractOp.getVector(), indices);
1275-
return success();
1276-
}
1277-
};
1278-
12791258
/// Pattern to move out vector.insert with a scalar input.
12801259
/// Only supports 1-D and 0-D destinations for now.
12811260
struct WarpOpInsertScalar : public WarpDistributionPattern {
@@ -1483,26 +1462,6 @@ struct WarpOpInsert : public WarpDistributionPattern {
14831462
}
14841463
};
14851464

1486-
struct WarpOpInsertElement : public WarpDistributionPattern {
1487-
using Base::Base;
1488-
LogicalResult matchAndRewrite(WarpExecuteOnLane0Op warpOp,
1489-
PatternRewriter &rewriter) const override {
1490-
OpOperand *operand =
1491-
getWarpResult(warpOp, llvm::IsaPred<vector::InsertElementOp>);
1492-
if (!operand)
1493-
return failure();
1494-
auto insertOp = operand->get().getDefiningOp<vector::InsertElementOp>();
1495-
SmallVector<OpFoldResult> indices;
1496-
if (auto pos = insertOp.getPosition()) {
1497-
indices.push_back(pos);
1498-
}
1499-
rewriter.setInsertionPoint(insertOp);
1500-
rewriter.replaceOpWithNewOp<vector::InsertOp>(
1501-
insertOp, insertOp.getSource(), insertOp.getDest(), indices);
1502-
return success();
1503-
}
1504-
};
1505-
15061465
/// Sink scf.for region out of WarpExecuteOnLane0Op. This can be done only if
15071466
/// the scf.ForOp is the last operation in the region so that it doesn't
15081467
/// change the order of execution. This creates a new scf.for region after the
@@ -1761,11 +1720,11 @@ void mlir::vector::populatePropagateWarpVectorDistributionPatterns(
17611720
const WarpShuffleFromIdxFn &warpShuffleFromIdxFn, PatternBenefit benefit,
17621721
PatternBenefit readBenefit) {
17631722
patterns.add<WarpOpTransferRead>(patterns.getContext(), readBenefit);
1764-
patterns.add<WarpOpElementwise, WarpOpDeadResult, WarpOpBroadcast,
1765-
WarpOpShapeCast, WarpOpExtract, WarpOpForwardOperand,
1766-
WarpOpConstant, WarpOpExtractElement, WarpOpInsertElement,
1767-
WarpOpInsertScalar, WarpOpInsert, WarpOpCreateMask>(
1768-
patterns.getContext(), benefit);
1723+
patterns
1724+
.add<WarpOpElementwise, WarpOpDeadResult, WarpOpBroadcast,
1725+
WarpOpShapeCast, WarpOpExtract, WarpOpForwardOperand, WarpOpConstant,
1726+
WarpOpInsertScalar, WarpOpInsert, WarpOpCreateMask>(
1727+
patterns.getContext(), benefit);
17691728
patterns.add<WarpOpExtractScalar>(patterns.getContext(), warpShuffleFromIdxFn,
17701729
benefit);
17711730
patterns.add<WarpOpScfForOp>(patterns.getContext(), distributionMapFn,

‎mlir/lib/Dialect/Vector/Transforms/VectorTransferOpTransforms.cpp‎

Lines changed: 25 additions & 94 deletions
Original file line numberDiff line numberDiff line change
@@ -767,23 +767,26 @@ class FlattenContiguousRowMajorTransferWritePattern
767767
unsigned targetVectorBitwidth;
768768
};
769769

770-
/// Base class for `vector.extract/vector.extract_element(vector.transfer_read)`
771-
/// to `memref.load` patterns. The `match` method is shared for both
772-
/// `vector.extract` and `vector.extract_element`.
773-
template <class VectorExtractOp>
774-
class RewriteScalarExtractOfTransferReadBase
775-
: public OpRewritePattern<VectorExtractOp> {
776-
using Base = OpRewritePattern<VectorExtractOp>;
777-
770+
/// Rewrite `vector.extract(vector.transfer_read)` to `memref.load`.
771+
///
772+
/// All the users of the transfer op must be `vector.extract` ops. If
773+
/// `allowMultipleUses` is set to true, rewrite transfer ops with any number of
774+
/// users. Otherwise, rewrite only if the extract op is the single user of the
775+
/// transfer op. Rewriting a single vector load with multiple scalar loads may
776+
/// negatively affect performance.
777+
class RewriteScalarExtractOfTransferRead
778+
: public OpRewritePattern<vector::ExtractOp> {
778779
public:
779-
RewriteScalarExtractOfTransferReadBase(MLIRContext *context,
780-
PatternBenefit benefit,
781-
bool allowMultipleUses)
782-
: Base(context, benefit), allowMultipleUses(allowMultipleUses) {}
783-
784-
LogicalResult match(VectorExtractOp extractOp) const {
785-
auto xferOp =
786-
extractOp.getVector().template getDefiningOp<vector::TransferReadOp>();
780+
RewriteScalarExtractOfTransferRead(MLIRContext *context,
781+
PatternBenefit benefit,
782+
bool allowMultipleUses)
783+
: OpRewritePattern(context, benefit),
784+
allowMultipleUses(allowMultipleUses) {}
785+
786+
LogicalResult matchAndRewrite(vector::ExtractOp extractOp,
787+
PatternRewriter &rewriter) const override {
788+
// Match phase.
789+
auto xferOp = extractOp.getVector().getDefiningOp<vector::TransferReadOp>();
787790
if (!xferOp)
788791
return failure();
789792
// Check that we are extracting a scalar and not a sub-vector.
@@ -795,8 +798,7 @@ class RewriteScalarExtractOfTransferReadBase
795798
// If multiple uses are allowed, check if all the xfer uses are extract ops.
796799
if (allowMultipleUses &&
797800
!llvm::all_of(xferOp->getUses(), [](OpOperand &use) {
798-
return isa<vector::ExtractOp, vector::ExtractElementOp>(
799-
use.getOwner());
801+
return isa<vector::ExtractOp>(use.getOwner());
800802
}))
801803
return failure();
802804
// Mask not supported.
@@ -808,81 +810,8 @@ class RewriteScalarExtractOfTransferReadBase
808810
// Cannot rewrite if the indices may be out of bounds.
809811
if (xferOp.hasOutOfBoundsDim())
810812
return failure();
811-
return success();
812-
}
813-
814-
private:
815-
bool allowMultipleUses;
816-
};
817-
818-
/// Rewrite `vector.extractelement(vector.transfer_read)` to `memref.load`.
819-
///
820-
/// All the users of the transfer op must be either `vector.extractelement` or
821-
/// `vector.extract` ops. If `allowMultipleUses` is set to true, rewrite
822-
/// transfer ops with any number of users. Otherwise, rewrite only if the
823-
/// extract op is the single user of the transfer op. Rewriting a single
824-
/// vector load with multiple scalar loads may negatively affect performance.
825-
class RewriteScalarExtractElementOfTransferRead
826-
: public RewriteScalarExtractOfTransferReadBase<vector::ExtractElementOp> {
827-
using RewriteScalarExtractOfTransferReadBase::
828-
RewriteScalarExtractOfTransferReadBase;
829-
830-
LogicalResult matchAndRewrite(vector::ExtractElementOp extractOp,
831-
PatternRewriter &rewriter) const override {
832-
if (failed(match(extractOp)))
833-
return failure();
834-
835-
// Construct scalar load.
836-
auto loc = extractOp.getLoc();
837-
auto xferOp = extractOp.getVector().getDefiningOp<vector::TransferReadOp>();
838-
SmallVector<Value> newIndices(xferOp.getIndices().begin(),
839-
xferOp.getIndices().end());
840-
if (extractOp.getPosition()) {
841-
AffineExpr sym0, sym1;
842-
bindSymbols(extractOp.getContext(), sym0, sym1);
843-
OpFoldResult ofr = affine::makeComposedFoldedAffineApply(
844-
rewriter, loc, sym0 + sym1,
845-
{newIndices[newIndices.size() - 1], extractOp.getPosition()});
846-
if (auto value = dyn_cast<Value>(ofr)) {
847-
newIndices[newIndices.size() - 1] = value;
848-
} else {
849-
newIndices[newIndices.size() - 1] =
850-
rewriter.create<arith::ConstantIndexOp>(loc,
851-
*getConstantIntValue(ofr));
852-
}
853-
}
854-
if (isa<MemRefType>(xferOp.getBase().getType())) {
855-
rewriter.replaceOpWithNewOp<memref::LoadOp>(extractOp, xferOp.getBase(),
856-
newIndices);
857-
} else {
858-
rewriter.replaceOpWithNewOp<tensor::ExtractOp>(
859-
extractOp, xferOp.getBase(), newIndices);
860-
}
861-
862-
return success();
863-
}
864-
};
865-
866-
/// Rewrite `vector.extractelement(vector.transfer_read)` to `memref.load`.
867-
/// Rewrite `vector.extract(vector.transfer_read)` to `memref.load`.
868-
///
869-
/// All the users of the transfer op must be either `vector.extractelement` or
870-
/// `vector.extract` ops. If `allowMultipleUses` is set to true, rewrite
871-
/// transfer ops with any number of users. Otherwise, rewrite only if the
872-
/// extract op is the single user of the transfer op. Rewriting a single
873-
/// vector load with multiple scalar loads may negatively affect performance.
874-
class RewriteScalarExtractOfTransferRead
875-
: public RewriteScalarExtractOfTransferReadBase<vector::ExtractOp> {
876-
using RewriteScalarExtractOfTransferReadBase::
877-
RewriteScalarExtractOfTransferReadBase;
878-
879-
LogicalResult matchAndRewrite(vector::ExtractOp extractOp,
880-
PatternRewriter &rewriter) const override {
881-
if (failed(match(extractOp)))
882-
return failure();
883813

884-
// Construct scalar load.
885-
auto xferOp = extractOp.getVector().getDefiningOp<vector::TransferReadOp>();
814+
// Rewrite phase: construct scalar load.
886815
SmallVector<Value> newIndices(xferOp.getIndices().begin(),
887816
xferOp.getIndices().end());
888817
for (auto [i, pos] : llvm::enumerate(extractOp.getMixedPosition())) {
@@ -923,6 +852,9 @@ class RewriteScalarExtractOfTransferRead
923852

924853
return success();
925854
}
855+
856+
private:
857+
bool allowMultipleUses;
926858
};
927859

928860
/// Rewrite transfer_writes of vectors of size 1 (e.g., vector<1x1xf32>)
@@ -979,8 +911,7 @@ void mlir::vector::transferOpflowOpt(RewriterBase &rewriter,
979911
void mlir::vector::populateScalarVectorTransferLoweringPatterns(
980912
RewritePatternSet &patterns, PatternBenefit benefit,
981913
bool allowMultipleUses) {
982-
patterns.add<RewriteScalarExtractElementOfTransferRead,
983-
RewriteScalarExtractOfTransferRead>(patterns.getContext(),
914+
patterns.add<RewriteScalarExtractOfTransferRead>(patterns.getContext(),
984915
benefit, allowMultipleUses);
985916
patterns.add<RewriteScalarWrite>(patterns.getContext(), benefit);
986917
}

‎mlir/test/Conversion/VectorToSCF/vector-to-scf.mlir‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ func.func @materialize_read_1d() {
3737
// Both accesses in the load must be clipped otherwise %i1 + 2 and %i1 + 3 will go out of bounds.
3838
// CHECK: scf.if
3939
// CHECK-NEXT: memref.load
40-
// CHECK-NEXT: vector.insertelement
40+
// CHECK-NEXT: vector.insert
4141
// CHECK-NEXT: scf.yield
4242
// CHECK-NEXT: else
4343
// CHECK-NEXT: scf.yield
@@ -103,7 +103,7 @@ func.func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
103103
// CHECK: %[[L0:.*]] = affine.apply #[[$ADD]](%[[I0]], %[[I6]])
104104
// CHECK: scf.if {{.*}} -> (vector<3xf32>) {
105105
// CHECK-NEXT: %[[SCAL:.*]] = memref.load %{{.*}}[%[[L0]], %[[I1]], %[[I2]], %[[L3]]] : memref<?x?x?x?xf32>
106-
// CHECK-NEXT: %[[RVEC:.*]] = vector.insertelement %[[SCAL]], %{{.*}}[%[[I6]] : index] : vector<3xf32>
106+
// CHECK-NEXT: %[[RVEC:.*]] = vector.insert %[[SCAL]], %{{.*}} [%[[I6]]] : f32 into vector<3xf32>
107107
// CHECK-NEXT: scf.yield
108108
// CHECK-NEXT: } else {
109109
// CHECK-NEXT: scf.yield
@@ -540,9 +540,9 @@ func.func @transfer_write_scalable(%arg0: memref<?xf32, strided<[?], offset: ?>>
540540
// CHECK: %[[VSCALE:.*]] = vector.vscale
541541
// CHECK: %[[UB:.*]] = arith.muli %[[VSCALE]], %[[C_16]] : index
542542
// CHECK: scf.for %[[IDX:.*]] = %[[C_0]] to %[[UB]] step %[[STEP]] {
543-
// CHECK: %[[MASK_VAL:.*]] = vector.extractelement %[[MASK_VEC]][%[[IDX]] : index] : vector<[16]xi1>
543+
// CHECK: %[[MASK_VAL:.*]] = vector.extract %[[MASK_VEC]][%[[IDX]]] : i1 from vector<[16]xi1>
544544
// CHECK: scf.if %[[MASK_VAL]] {
545-
// CHECK: %[[VAL_TO_STORE:.*]] = vector.extractelement %{{.*}}[%[[IDX]] : index] : vector<[16]xf32>
545+
// CHECK: %[[VAL_TO_STORE:.*]] = vector.extract %{{.*}}[%[[IDX]]] : f32 from vector<[16]xf32>
546546
// CHECK: memref.store %[[VAL_TO_STORE]], %[[ARG_0]][%[[IDX]]] : memref<?xf32, strided<[?], offset: ?>>
547547
// CHECK: } else {
548548
// CHECK: }
@@ -561,7 +561,7 @@ func.func @vector_print_vector_0d(%arg0: vector<f32>) {
561561
// CHECK: %[[FLAT_VEC:.*]] = vector.shape_cast %[[VEC]] : vector<f32> to vector<1xf32>
562562
// CHECK: vector.print punctuation <open>
563563
// CHECK: scf.for %[[IDX:.*]] = %[[C0]] to %[[C1]] step %[[C1]] {
564-
// CHECK: %[[EL:.*]] = vector.extractelement %[[FLAT_VEC]]{{\[}}%[[IDX]] : index] : vector<1xf32>
564+
// CHECK: %[[EL:.*]] = vector.extract %[[FLAT_VEC]][%[[IDX]]] : f32 from vector<1xf32>
565565
// CHECK: vector.print %[[EL]] : f32 punctuation <no_punctuation>
566566
// CHECK: %[[IS_NOT_LAST:.*]] = arith.cmpi ult, %[[IDX]], %[[C0]] : index
567567
// CHECK: scf.if %[[IS_NOT_LAST]] {
@@ -591,7 +591,7 @@ func.func @vector_print_vector(%arg0: vector<2x2xf32>) {
591591
// CHECK: scf.for %[[J:.*]] = %[[C0]] to %[[C2]] step %[[C1]] {
592592
// CHECK: %[[OUTER_INDEX:.*]] = arith.muli %[[I]], %[[C2]] : index
593593
// CHECK: %[[FLAT_INDEX:.*]] = arith.addi %[[J]], %[[OUTER_INDEX]] : index
594-
// CHECK: %[[EL:.*]] = vector.extractelement %[[FLAT_VEC]]{{\[}}%[[FLAT_INDEX]] : index] : vector<4xf32>
594+
// CHECK: %[[EL:.*]] = vector.extract %[[FLAT_VEC]][%[[FLAT_INDEX]]] : f32 from vector<4xf32>
595595
// CHECK: vector.print %[[EL]] : f32 punctuation <no_punctuation>
596596
// CHECK: %[[IS_NOT_LAST_J:.*]] = arith.cmpi ult, %[[J]], %[[C1]] : index
597597
// CHECK: scf.if %[[IS_NOT_LAST_J]] {
@@ -625,7 +625,7 @@ func.func @vector_print_scalable_vector(%arg0: vector<[4]xi32>) {
625625
// CHECK: %[[LAST_INDEX:.*]] = arith.subi %[[UPPER_BOUND]], %[[C1]] : index
626626
// CHECK: vector.print punctuation <open>
627627
// CHECK: scf.for %[[IDX:.*]] = %[[C0]] to %[[UPPER_BOUND]] step %[[C1]] {
628-
// CHECK: %[[EL:.*]] = vector.extractelement %[[VEC]]{{\[}}%[[IDX]] : index] : vector<[4]xi32>
628+
// CHECK: %[[EL:.*]] = vector.extract %[[VEC]][%[[IDX]]] : i32 from vector<[4]xi32>
629629
// CHECK: vector.print %[[EL]] : i32 punctuation <no_punctuation>
630630
// CHECK: %[[IS_NOT_LAST:.*]] = arith.cmpi ult, %[[IDX]], %[[LAST_INDEX]] : index
631631
// CHECK: scf.if %[[IS_NOT_LAST]] {

‎mlir/test/Dialect/Vector/scalar-vector-transfer-to-memref.mlir‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
func.func @transfer_read_0d(%m: memref<?x?x?xf32>, %idx: index) -> f32 {
99
%cst = arith.constant 0.0 : f32
1010
%0 = vector.transfer_read %m[%idx, %idx, %idx], %cst : memref<?x?x?xf32>, vector<f32>
11-
%1 = vector.extractelement %0[] : vector<f32>
11+
%1 = vector.extract %0[] : f32 from vector<f32>
1212
return %1 : f32
1313
}
1414

@@ -24,7 +24,7 @@ func.func @transfer_read_1d(%m: memref<?x?x?xf32>, %idx: index, %idx2: index) ->
2424
%cst = arith.constant 0.0 : f32
2525
%c0 = arith.constant 0 : index
2626
%0 = vector.transfer_read %m[%idx, %idx, %idx], %cst {in_bounds = [true]} : memref<?x?x?xf32>, vector<5xf32>
27-
%1 = vector.extractelement %0[%idx2 : index] : vector<5xf32>
27+
%1 = vector.extract %0[%idx2] : f32 from vector<5xf32>
2828
return %1 : f32
2929
}
3030

@@ -37,7 +37,7 @@ func.func @transfer_read_1d(%m: memref<?x?x?xf32>, %idx: index, %idx2: index) ->
3737
func.func @tensor_transfer_read_0d(%t: tensor<?x?x?xf32>, %idx: index) -> f32 {
3838
%cst = arith.constant 0.0 : f32
3939
%0 = vector.transfer_read %t[%idx, %idx, %idx], %cst : tensor<?x?x?xf32>, vector<f32>
40-
%1 = vector.extractelement %0[] : vector<f32>
40+
%1 = vector.extract %0[] : f32 from vector<f32>
4141
return %1 : f32
4242
}
4343

0 commit comments

Comments
 (0)