Skip to content

Commit a9c71d3

Browse files
banach-spacebanach-space
authored
[mlir][vector] Add more tests for ConvertVectorToLLVM (5/n) (#106510)
1 parent f19dff1 commit a9c71d3

File tree

1 file changed

+88
-65
lines changed

1 file changed

+88
-65
lines changed

‎mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir

Lines changed: 88 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
// RUN: mlir-opt %s -convert-vector-to-llvm -split-input-file | FileCheck %s
22

3+
// TODO: Add tests for for vector.type_cast that would cover scalable vectors
4+
35
func.func @bitcast_f32_to_i32_vector_0d(%input: vector<f32>) -> vector<i32> {
46
%0 = vector.bitcast %input : vector<f32> to vector<i32>
57
return %0 : vector<i32>
@@ -1467,8 +1469,6 @@ func.func @insert_scalar_into_vec_2d_f32_dynamic_idx(%arg0: vector<1x16xf32>, %a
14671469
// CHECK-LABEL: @insert_scalar_into_vec_2d_f32_dynamic_idx(
14681470
// CHECK: vector.insert
14691471

1470-
// -----
1471-
14721472
func.func @insert_scalar_into_vec_2d_f32_dynamic_idx_scalable(%arg0: vector<1x[16]xf32>, %arg1: f32, %idx: index)
14731473
-> vector<1x[16]xf32> {
14741474
%0 = vector.insert %arg1, %arg0[0, %idx]: f32 into vector<1x[16]xf32>
@@ -1482,11 +1482,11 @@ func.func @insert_scalar_into_vec_2d_f32_dynamic_idx_scalable(%arg0: vector<1x[1
14821482

14831483
// -----
14841484

1485-
func.func @vector_type_cast(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32>> {
1485+
func.func @type_cast_f32(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32>> {
14861486
%0 = vector.type_cast %arg0: memref<8x8x8xf32> to memref<vector<8x8x8xf32>>
14871487
return %0 : memref<vector<8x8x8xf32>>
14881488
}
1489-
// CHECK-LABEL: @vector_type_cast
1489+
// CHECK-LABEL: @type_cast_f32
14901490
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64)>
14911491
// CHECK: %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)>
14921492
// CHECK: llvm.insertvalue %[[allocated]], {{.*}}[0] : !llvm.struct<(ptr, ptr, i64)>
@@ -1495,18 +1495,22 @@ func.func @vector_type_cast(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32
14951495
// CHECK: llvm.mlir.constant(0 : index
14961496
// CHECK: llvm.insertvalue {{.*}}[2] : !llvm.struct<(ptr, ptr, i64)>
14971497

1498+
// NOTE: No test for scalable vectors - the input memref is fixed size.
1499+
14981500
// -----
14991501

1500-
func.func @vector_index_type_cast(%arg0: memref<8x8x8xindex>) -> memref<vector<8x8x8xindex>> {
1502+
func.func @type_cast_index(%arg0: memref<8x8x8xindex>) -> memref<vector<8x8x8xindex>> {
15011503
%0 = vector.type_cast %arg0: memref<8x8x8xindex> to memref<vector<8x8x8xindex>>
15021504
return %0 : memref<vector<8x8x8xindex>>
15031505
}
1504-
// CHECK-LABEL: @vector_index_type_cast(
1506+
// CHECK-LABEL: @type_cast_index(
15051507
// CHECK-SAME: %[[A:.*]]: memref<8x8x8xindex>)
15061508
// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[A]] : memref<8x8x8xindex> to !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)>
15071509

15081510
// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %{{.*}} : !llvm.struct<(ptr, ptr, i64)> to memref<vector<8x8x8xindex>>
15091511

1512+
// NOTE: No test for scalable vectors - the input memref is fixed size.
1513+
15101514
// -----
15111515

15121516
func.func @vector_type_cast_non_zero_addrspace(%arg0: memref<8x8x8xf32, 3>) -> memref<vector<8x8x8xf32>, 3> {
@@ -1522,40 +1526,42 @@ func.func @vector_type_cast_non_zero_addrspace(%arg0: memref<8x8x8xf32, 3>) -> m
15221526
// CHECK: llvm.mlir.constant(0 : index
15231527
// CHECK: llvm.insertvalue {{.*}}[2] : !llvm.struct<(ptr<3>, ptr<3>, i64)>
15241528

1529+
// NOTE: No test for scalable vectors - the input memref is fixed size.
1530+
15251531
// -----
15261532

1527-
func.func @vector_print_scalar_i1(%arg0: i1) {
1533+
func.func @print_scalar_i1(%arg0: i1) {
15281534
vector.print %arg0 : i1
15291535
return
15301536
}
15311537
//
15321538
// Type "boolean" always uses zero extension.
15331539
//
1534-
// CHECK-LABEL: @vector_print_scalar_i1(
1540+
// CHECK-LABEL: @print_scalar_i1(
15351541
// CHECK-SAME: %[[A:.*]]: i1)
15361542
// CHECK: %[[S:.*]] = arith.extui %[[A]] : i1 to i64
15371543
// CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
15381544
// CHECK: llvm.call @printNewline() : () -> ()
15391545

15401546
// -----
15411547

1542-
func.func @vector_print_scalar_i4(%arg0: i4) {
1548+
func.func @print_scalar_i4(%arg0: i4) {
15431549
vector.print %arg0 : i4
15441550
return
15451551
}
1546-
// CHECK-LABEL: @vector_print_scalar_i4(
1552+
// CHECK-LABEL: @print_scalar_i4(
15471553
// CHECK-SAME: %[[A:.*]]: i4)
15481554
// CHECK: %[[S:.*]] = arith.extsi %[[A]] : i4 to i64
15491555
// CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
15501556
// CHECK: llvm.call @printNewline() : () -> ()
15511557

15521558
// -----
15531559

1554-
func.func @vector_print_scalar_si4(%arg0: si4) {
1560+
func.func @print_scalar_si4(%arg0: si4) {
15551561
vector.print %arg0 : si4
15561562
return
15571563
}
1558-
// CHECK-LABEL: @vector_print_scalar_si4(
1564+
// CHECK-LABEL: @print_scalar_si4(
15591565
// CHECK-SAME: %[[A:.*]]: si4)
15601566
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : si4 to i4
15611567
// CHECK: %[[S:.*]] = arith.extsi %[[C]] : i4 to i64
@@ -1564,11 +1570,11 @@ func.func @vector_print_scalar_si4(%arg0: si4) {
15641570

15651571
// -----
15661572

1567-
func.func @vector_print_scalar_ui4(%arg0: ui4) {
1573+
func.func @print_scalar_ui4(%arg0: ui4) {
15681574
vector.print %arg0 : ui4
15691575
return
15701576
}
1571-
// CHECK-LABEL: @vector_print_scalar_ui4(
1577+
// CHECK-LABEL: @print_scalar_ui4(
15721578
// CHECK-SAME: %[[A:.*]]: ui4)
15731579
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui4 to i4
15741580
// CHECK: %[[S:.*]] = arith.extui %[[C]] : i4 to i64
@@ -1577,47 +1583,47 @@ func.func @vector_print_scalar_ui4(%arg0: ui4) {
15771583

15781584
// -----
15791585

1580-
func.func @vector_print_scalar_i32(%arg0: i32) {
1586+
func.func @print_scalar_i32(%arg0: i32) {
15811587
vector.print %arg0 : i32
15821588
return
15831589
}
1584-
// CHECK-LABEL: @vector_print_scalar_i32(
1590+
// CHECK-LABEL: @print_scalar_i32(
15851591
// CHECK-SAME: %[[A:.*]]: i32)
15861592
// CHECK: %[[S:.*]] = arith.extsi %[[A]] : i32 to i64
15871593
// CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
15881594
// CHECK: llvm.call @printNewline() : () -> ()
15891595

15901596
// -----
15911597

1592-
func.func @vector_print_scalar_ui32(%arg0: ui32) {
1598+
func.func @print_scalar_ui32(%arg0: ui32) {
15931599
vector.print %arg0 : ui32
15941600
return
15951601
}
1596-
// CHECK-LABEL: @vector_print_scalar_ui32(
1602+
// CHECK-LABEL: @print_scalar_ui32(
15971603
// CHECK-SAME: %[[A:.*]]: ui32)
15981604
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui32 to i32
15991605
// CHECK: %[[S:.*]] = arith.extui %[[C]] : i32 to i64
16001606
// CHECK: llvm.call @printU64(%[[S]]) : (i64) -> ()
16011607

16021608
// -----
16031609

1604-
func.func @vector_print_scalar_i40(%arg0: i40) {
1610+
func.func @print_scalar_i40(%arg0: i40) {
16051611
vector.print %arg0 : i40
16061612
return
16071613
}
1608-
// CHECK-LABEL: @vector_print_scalar_i40(
1614+
// CHECK-LABEL: @print_scalar_i40(
16091615
// CHECK-SAME: %[[A:.*]]: i40)
16101616
// CHECK: %[[S:.*]] = arith.extsi %[[A]] : i40 to i64
16111617
// CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
16121618
// CHECK: llvm.call @printNewline() : () -> ()
16131619

16141620
// -----
16151621

1616-
func.func @vector_print_scalar_si40(%arg0: si40) {
1622+
func.func @print_scalar_si40(%arg0: si40) {
16171623
vector.print %arg0 : si40
16181624
return
16191625
}
1620-
// CHECK-LABEL: @vector_print_scalar_si40(
1626+
// CHECK-LABEL: @print_scalar_si40(
16211627
// CHECK-SAME: %[[A:.*]]: si40)
16221628
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : si40 to i40
16231629
// CHECK: %[[S:.*]] = arith.extsi %[[C]] : i40 to i64
@@ -1626,11 +1632,11 @@ func.func @vector_print_scalar_si40(%arg0: si40) {
16261632

16271633
// -----
16281634

1629-
func.func @vector_print_scalar_ui40(%arg0: ui40) {
1635+
func.func @print_scalar_ui40(%arg0: ui40) {
16301636
vector.print %arg0 : ui40
16311637
return
16321638
}
1633-
// CHECK-LABEL: @vector_print_scalar_ui40(
1639+
// CHECK-LABEL: @print_scalar_ui40(
16341640
// CHECK-SAME: %[[A:.*]]: ui40)
16351641
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui40 to i40
16361642
// CHECK: %[[S:.*]] = arith.extui %[[C]] : i40 to i64
@@ -1639,57 +1645,57 @@ func.func @vector_print_scalar_ui40(%arg0: ui40) {
16391645

16401646
// -----
16411647

1642-
func.func @vector_print_scalar_i64(%arg0: i64) {
1648+
func.func @print_scalar_i64(%arg0: i64) {
16431649
vector.print %arg0 : i64
16441650
return
16451651
}
1646-
// CHECK-LABEL: @vector_print_scalar_i64(
1652+
// CHECK-LABEL: @print_scalar_i64(
16471653
// CHECK-SAME: %[[A:.*]]: i64)
16481654
// CHECK: llvm.call @printI64(%[[A]]) : (i64) -> ()
16491655
// CHECK: llvm.call @printNewline() : () -> ()
16501656

16511657
// -----
16521658

1653-
func.func @vector_print_scalar_ui64(%arg0: ui64) {
1659+
func.func @print_scalar_ui64(%arg0: ui64) {
16541660
vector.print %arg0 : ui64
16551661
return
16561662
}
1657-
// CHECK-LABEL: @vector_print_scalar_ui64(
1663+
// CHECK-LABEL: @print_scalar_ui64(
16581664
// CHECK-SAME: %[[A:.*]]: ui64)
16591665
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui64 to i64
16601666
// CHECK: llvm.call @printU64(%[[C]]) : (i64) -> ()
16611667
// CHECK: llvm.call @printNewline() : () -> ()
16621668

16631669
// -----
16641670

1665-
func.func @vector_print_scalar_index(%arg0: index) {
1671+
func.func @print_scalar_index(%arg0: index) {
16661672
vector.print %arg0 : index
16671673
return
16681674
}
1669-
// CHECK-LABEL: @vector_print_scalar_index(
1675+
// CHECK-LABEL: @print_scalar_index(
16701676
// CHECK-SAME: %[[A:.*]]: index)
16711677
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : index to i64
16721678
// CHECK: llvm.call @printU64(%[[C]]) : (i64) -> ()
16731679
// CHECK: llvm.call @printNewline() : () -> ()
16741680

16751681
// -----
16761682

1677-
func.func @vector_print_scalar_f32(%arg0: f32) {
1683+
func.func @print_scalar_f32(%arg0: f32) {
16781684
vector.print %arg0 : f32
16791685
return
16801686
}
1681-
// CHECK-LABEL: @vector_print_scalar_f32(
1687+
// CHECK-LABEL: @print_scalar_f32(
16821688
// CHECK-SAME: %[[A:.*]]: f32)
16831689
// CHECK: llvm.call @printF32(%[[A]]) : (f32) -> ()
16841690
// CHECK: llvm.call @printNewline() : () -> ()
16851691

16861692
// -----
16871693

1688-
func.func @vector_print_scalar_f64(%arg0: f64) {
1694+
func.func @print_scalar_f64(%arg0: f64) {
16891695
vector.print %arg0 : f64
16901696
return
16911697
}
1692-
// CHECK-LABEL: @vector_print_scalar_f64(
1698+
// CHECK-LABEL: @print_scalar_f64(
16931699
// CHECK-SAME: %[[A:.*]]: f64)
16941700
// CHECK: llvm.call @printF64(%[[A]]) : (f64) -> ()
16951701
// CHECK: llvm.call @printNewline() : () -> ()
@@ -1699,46 +1705,50 @@ func.func @vector_print_scalar_f64(%arg0: f64) {
16991705
// CHECK-LABEL: module {
17001706
// CHECK: llvm.func @printString(!llvm.ptr)
17011707
// CHECK: llvm.mlir.global private constant @[[GLOBAL_STR:.*]]({{.*}})
1702-
// CHECK: @vector_print_string
1708+
// CHECK: @print_string
17031709
// CHECK-NEXT: %[[GLOBAL_ADDR:.*]] = llvm.mlir.addressof @[[GLOBAL_STR]] : !llvm.ptr
17041710
// CHECK-NEXT: %[[STR_PTR:.*]] = llvm.getelementptr %[[GLOBAL_ADDR]][0] : (!llvm.ptr) -> !llvm.ptr
17051711
// CHECK-NEXT: llvm.call @printString(%[[STR_PTR]]) : (!llvm.ptr) -> ()
1706-
func.func @vector_print_string() {
1712+
func.func @print_string() {
17071713
vector.print str "Hello, World!"
17081714
return
17091715
}
17101716

17111717
// -----
17121718

1713-
func.func @extract_strided_slice1(%arg0: vector<4xf32>) -> vector<2xf32> {
1719+
func.func @extract_strided_slice_f32(%arg0: vector<4xf32>) -> vector<2xf32> {
17141720
%0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32>
17151721
return %0 : vector<2xf32>
17161722
}
1717-
// CHECK-LABEL: @extract_strided_slice1(
1723+
// CHECK-LABEL: @extract_strided_slice_f32(
17181724
// CHECK-SAME: %[[A:.*]]: vector<4xf32>)
17191725
// CHECK: %[[T0:.*]] = llvm.shufflevector %[[A]], %[[A]] [2, 3] : vector<4xf32>
17201726
// CHECK: return %[[T0]] : vector<2xf32>
17211727

1728+
// NOTE: For scalable vectors we could only extract vector<[4]xf32> from vector<[4]xf32>, but that would be a NOP.
1729+
17221730
// -----
17231731

1724-
func.func @extract_strided_index_slice1(%arg0: vector<4xindex>) -> vector<2xindex> {
1732+
func.func @extract_strided_slice_index(%arg0: vector<4xindex>) -> vector<2xindex> {
17251733
%0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xindex> to vector<2xindex>
17261734
return %0 : vector<2xindex>
17271735
}
1728-
// CHECK-LABEL: @extract_strided_index_slice1(
1736+
// CHECK-LABEL: @extract_strided_slice_index(
17291737
// CHECK-SAME: %[[A:.*]]: vector<4xindex>)
17301738
// CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4xindex> to vector<4xi64>
17311739
// CHECK: %[[T2:.*]] = llvm.shufflevector %[[T0]], %[[T0]] [2, 3] : vector<4xi64>
17321740
// CHECK: %[[T3:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<2xi64> to vector<2xindex>
17331741
// CHECK: return %[[T3]] : vector<2xindex>
17341742

1743+
// NOTE: For scalable vectors we could only extract vector<[4]xindex> from vector<[4]xindex>, but that would be a NOP.
1744+
17351745
// -----
17361746

1737-
func.func @extract_strided_slice2(%arg0: vector<4x8xf32>) -> vector<2x8xf32> {
1747+
func.func @extract_strided_slice_f32_1d_from_2d(%arg0: vector<4x8xf32>) -> vector<2x8xf32> {
17381748
%0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4x8xf32> to vector<2x8xf32>
17391749
return %0 : vector<2x8xf32>
17401750
}
1741-
// CHECK-LABEL: @extract_strided_slice2(
1751+
// CHECK-LABEL: @extract_strided_slice_f32_1d_from_2d(
17421752
// CHECK-SAME: %[[ARG:.*]]: vector<4x8xf32>)
17431753
// CHECK: %[[A:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>>
17441754
// CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.array<2 x vector<8xf32>>
@@ -1749,13 +1759,28 @@ func.func @extract_strided_slice2(%arg0: vector<4x8xf32>) -> vector<2x8xf32> {
17491759
// CHECK: %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T4]] : !llvm.array<2 x vector<8xf32>> to vector<2x8xf32>
17501760
// CHECK: return %[[T5]]
17511761

1762+
func.func @extract_strided_slice_f32_1d_from_2d_scalable(%arg0: vector<4x[8]xf32>) -> vector<2x[8]xf32> {
1763+
%0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4x[8]xf32> to vector<2x[8]xf32>
1764+
return %0 : vector<2x[8]xf32>
1765+
}
1766+
// CHECK-LABEL: func.func @extract_strided_slice_f32_1d_from_2d_scalable(
1767+
// CHECK-SAME: %[[ARG:.*]]: vector<4x[8]xf32>)
1768+
// CHECK: %[[A:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<4x[8]xf32> to !llvm.array<4 x vector<[8]xf32>>
1769+
// CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.array<2 x vector<[8]xf32>>
1770+
// CHECK: %[[T1:.*]] = llvm.extractvalue %[[A]][2] : !llvm.array<4 x vector<[8]xf32>>
1771+
// CHECK: %[[T2:.*]] = llvm.insertvalue %[[T1]], %[[T0]][0] : !llvm.array<2 x vector<[8]xf32>>
1772+
// CHECK: %[[T3:.*]] = llvm.extractvalue %[[A]][3] : !llvm.array<4 x vector<[8]xf32>>
1773+
// CHECK: %[[T4:.*]] = llvm.insertvalue %[[T3]], %[[T2]][1] : !llvm.array<2 x vector<[8]xf32>>
1774+
// CHECK: %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T4]] : !llvm.array<2 x vector<[8]xf32>> to vector<2x[8]xf32>
1775+
// CHECK: return %[[T5]]
1776+
17521777
// -----
17531778

1754-
func.func @extract_strided_slice3(%arg0: vector<4x8xf32>) -> vector<2x2xf32> {
1779+
func.func @extract_strided_slice_f32_2d_from_2d(%arg0: vector<4x8xf32>) -> vector<2x2xf32> {
17551780
%0 = vector.extract_strided_slice %arg0 {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8xf32> to vector<2x2xf32>
17561781
return %0 : vector<2x2xf32>
17571782
}
1758-
// CHECK-LABEL: @extract_strided_slice3(
1783+
// CHECK-LABEL: @extract_strided_slice_f32_2d_from_2d(
17591784
// CHECK-SAME: %[[ARG:.*]]: vector<4x8xf32>)
17601785
// CHECK: %[[A:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>>
17611786
// CHECK: %[[VAL_2:.*]] = arith.constant dense<0.000000e+00> : vector<2x2xf32>
@@ -1769,27 +1794,25 @@ func.func @extract_strided_slice3(%arg0: vector<4x8xf32>) -> vector<2x2xf32> {
17691794
// CHECK: %[[VAL_12:.*]] = builtin.unrealized_conversion_cast %[[T7]] : !llvm.array<2 x vector<2xf32>> to vector<2x2xf32>
17701795
// CHECK: return %[[VAL_12]] : vector<2x2xf32>
17711796

1772-
// -----
1773-
1774-
func.func @extract_strided_slice_scalable(%arg0 : vector<1x4x[4]xi32>) -> vector<1x1x[4]xi32> {
1775-
%0 = vector.extract_strided_slice %arg0 {offsets = [0, 3, 0], sizes = [1, 1, 4], strides = [1, 1, 1]} : vector<1x4x[4]xi32> to vector<1x1x[4]xi32>
1776-
return %0 : vector<1x1x[4]xi32>
1777-
}
1778-
1779-
// CHECK-LABEL: func.func @extract_strided_slice_scalable(
1780-
// CHECK-SAME: %[[ARG_0:.*]]: vector<1x4x[4]xi32>) -> vector<1x1x[4]xi32> {
1781-
1782-
// CHECK: %[[CAST_1:.*]] = builtin.unrealized_conversion_cast %[[ARG_0]] : vector<1x4x[4]xi32> to !llvm.array<1 x array<4 x vector<[4]xi32>>>
1783-
// CHECK: %[[CST:.*]] = arith.constant dense<0> : vector<1x1x[4]xi32>
1784-
// CHECK: %[[CAST_2:.*]] = builtin.unrealized_conversion_cast %[[CST]] : vector<1x1x[4]xi32> to !llvm.array<1 x array<1 x vector<[4]xi32>>>
1785-
// CHECK: %[[CST_1:.*]] = arith.constant dense<0> : vector<1x[4]xi32>
1786-
// CHECK: %[[CAST_3:.*]] = builtin.unrealized_conversion_cast %[[CST_1]] : vector<1x[4]xi32> to !llvm.array<1 x vector<[4]xi32>>
1787-
1788-
// CHECK: %[[EXT:.*]] = llvm.extractvalue %[[CAST_1]][0, 3] : !llvm.array<1 x array<4 x vector<[4]xi32>>>
1789-
// CHECK: %[[INS_1:.*]] = llvm.insertvalue %[[EXT]], %[[CAST_3]][0] : !llvm.array<1 x vector<[4]xi32>>
1790-
// CHECK: %[[INS_2:.*]] = llvm.insertvalue %[[INS_1]], %[[CAST_2]][0] : !llvm.array<1 x array<1 x vector<[4]xi32>>>
1791-
1792-
// CHECK: builtin.unrealized_conversion_cast %[[INS_2]] : !llvm.array<1 x array<1 x vector<[4]xi32>>> to vector<1x1x[4]xi32>
1797+
// NOTE: For scalable vectors, we can only extract "full" scalable dimensions
1798+
// (e.g. [8] from [8], but not [4] from [8]).
1799+
1800+
func.func @extract_strided_slice_f32_2d_from_2d_scalable(%arg0: vector<4x[8]xf32>) -> vector<2x[8]xf32> {
1801+
%0 = vector.extract_strided_slice %arg0 {offsets = [2, 0], sizes = [2, 8], strides = [1, 1]} : vector<4x[8]xf32> to vector<2x[8]xf32>
1802+
return %0 : vector<2x[8]xf32>
1803+
}
1804+
// CHECK-LABEL: @extract_strided_slice_f32_2d_from_2d_scalable(
1805+
// CHECK-SAME: %[[ARG:.*]]: vector<4x[8]xf32>)
1806+
// CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<4x[8]xf32> to !llvm.array<4 x vector<[8]xf32>>
1807+
// CHECK: %[[T2:.*]] = arith.constant 0.000000e+00 : f32
1808+
// CHECK: %[[T3:.*]] = arith.constant dense<0.000000e+00> : vector<2x[8]xf32>
1809+
// CHECK: %[[T4:.*]] = builtin.unrealized_conversion_cast %[[T3]] : vector<2x[8]xf32> to !llvm.array<2 x vector<[8]xf32>>
1810+
// CHECK: %[[T5:.*]] = llvm.extractvalue %[[T1]][2] : !llvm.array<4 x vector<[8]xf32>>
1811+
// CHECK: %[[T6:.*]] = llvm.insertvalue %[[T5]], %[[T4]][0] : !llvm.array<2 x vector<[8]xf32>>
1812+
// CHECK: %[[T7:.*]] = llvm.extractvalue %[[T1]][3] : !llvm.array<4 x vector<[8]xf32>>
1813+
// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T7]], %[[T6]][1] : !llvm.array<2 x vector<[8]xf32>>
1814+
// CHECK: %[[T9:.*]] = builtin.unrealized_conversion_cast %[[T8]] : !llvm.array<2 x vector<[8]xf32>> to vector<2x[8]xf32>
1815+
// CHECK: return %[[T9]] : vector<2x[8]xf32>
17931816

17941817
// -----
17951818

0 commit comments

Comments
 (0)