1// RUN: mlir-opt %s -convert-vector-to-llvm | FileCheck %s 2 3func @broadcast_vec1d_from_scalar(%arg0: f32) -> vector<2xf32> { 4 %0 = vector.broadcast %arg0 : f32 to vector<2xf32> 5 return %0 : vector<2xf32> 6} 7// CHECK-LABEL: llvm.func @broadcast_vec1d_from_scalar( 8// CHECK-SAME: %[[A:.*]]: !llvm.float) 9// CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm<"<2 x float>"> 10// CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 11// CHECK: %[[T2:.*]] = llvm.insertelement %[[A]], %[[T0]][%[[T1]] : !llvm.i32] : !llvm<"<2 x float>"> 12// CHECK: %[[T3:.*]] = llvm.shufflevector %[[T2]], %[[T0]] [0 : i32, 0 : i32] : !llvm<"<2 x float>">, !llvm<"<2 x float>"> 13// CHECK: llvm.return %[[T3]] : !llvm<"<2 x float>"> 14 15func @broadcast_vec2d_from_scalar(%arg0: f32) -> vector<2x3xf32> { 16 %0 = vector.broadcast %arg0 : f32 to vector<2x3xf32> 17 return %0 : vector<2x3xf32> 18} 19// CHECK-LABEL: llvm.func @broadcast_vec2d_from_scalar( 20// CHECK-SAME: %[[A:.*]]: !llvm.float) 21// CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm<"[2 x <3 x float>]"> 22// CHECK: %[[T1:.*]] = llvm.mlir.undef : !llvm<"<3 x float>"> 23// CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 24// CHECK: %[[T3:.*]] = llvm.insertelement %[[A]], %[[T1]][%[[T2]] : !llvm.i32] : !llvm<"<3 x float>"> 25// CHECK: %[[T4:.*]] = llvm.shufflevector %[[T3]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>"> 26// CHECK: %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T0]][0] : !llvm<"[2 x <3 x float>]"> 27// CHECK: %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][1] : !llvm<"[2 x <3 x float>]"> 28// CHECK: llvm.return %[[T6]] : !llvm<"[2 x <3 x float>]"> 29 30func @broadcast_vec3d_from_scalar(%arg0: f32) -> vector<2x3x4xf32> { 31 %0 = vector.broadcast %arg0 : f32 to vector<2x3x4xf32> 32 return %0 : vector<2x3x4xf32> 33} 34// CHECK-LABEL: llvm.func @broadcast_vec3d_from_scalar( 35// CHECK-SAME: %[[A:.*]]: !llvm.float) 36// CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm<"[2 x [3 x <4 x float>]]"> 37// CHECK: %[[T1:.*]] = llvm.mlir.undef : !llvm<"<4 x float>"> 38// CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 39// CHECK: %[[T3:.*]] = llvm.insertelement %[[A]], %[[T1]][%[[T2]] : !llvm.i32] : !llvm<"<4 x float>"> 40// CHECK: %[[T4:.*]] = llvm.shufflevector %[[T3]], %[[T3]] [0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm<"<4 x float>">, !llvm<"<4 x float>"> 41// CHECK: %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T0]][0, 0] : !llvm<"[2 x [3 x <4 x float>]]"> 42// CHECK: %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][0, 1] : !llvm<"[2 x [3 x <4 x float>]]"> 43// CHECK: %[[T7:.*]] = llvm.insertvalue %[[T4]], %[[T6]][0, 2] : !llvm<"[2 x [3 x <4 x float>]]"> 44// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T4]], %[[T7]][1, 0] : !llvm<"[2 x [3 x <4 x float>]]"> 45// CHECK: %[[T9:.*]] = llvm.insertvalue %[[T4]], %[[T8]][1, 1] : !llvm<"[2 x [3 x <4 x float>]]"> 46// CHECK: %[[T10:.*]] = llvm.insertvalue %[[T4]], %[[T9]][1, 2] : !llvm<"[2 x [3 x <4 x float>]]"> 47// CHECK: llvm.return %[[T10]] : !llvm<"[2 x [3 x <4 x float>]]"> 48 49func @broadcast_vec1d_from_vec1d(%arg0: vector<2xf32>) -> vector<2xf32> { 50 %0 = vector.broadcast %arg0 : vector<2xf32> to vector<2xf32> 51 return %0 : vector<2xf32> 52} 53// CHECK-LABEL: llvm.func @broadcast_vec1d_from_vec1d( 54// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">) 55// CHECK: llvm.return %[[A]] : !llvm<"<2 x float>"> 56 57func @broadcast_vec2d_from_vec1d(%arg0: vector<2xf32>) -> vector<3x2xf32> { 58 %0 = vector.broadcast %arg0 : vector<2xf32> to vector<3x2xf32> 59 return %0 : vector<3x2xf32> 60} 61// CHECK-LABEL: llvm.func @broadcast_vec2d_from_vec1d( 62// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">) 63// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<3x2xf32>) : !llvm<"[3 x <2 x float>]"> 64// CHECK: %[[T1:.*]] = llvm.insertvalue %[[A]], %[[T0]][0] : !llvm<"[3 x <2 x float>]"> 65// CHECK: %[[T2:.*]] = llvm.insertvalue %[[A]], %[[T1]][1] : !llvm<"[3 x <2 x float>]"> 66// CHECK: %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][2] : !llvm<"[3 x <2 x float>]"> 67// CHECK: llvm.return %[[T3]] : !llvm<"[3 x <2 x float>]"> 68 69func @broadcast_vec3d_from_vec1d(%arg0: vector<2xf32>) -> vector<4x3x2xf32> { 70 %0 = vector.broadcast %arg0 : vector<2xf32> to vector<4x3x2xf32> 71 return %0 : vector<4x3x2xf32> 72} 73// CHECK-LABEL: llvm.func @broadcast_vec3d_from_vec1d( 74// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">) 75// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<3x2xf32>) : !llvm<"[3 x <2 x float>]"> 76// CHECK: %[[T1:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<4x3x2xf32>) : !llvm<"[4 x [3 x <2 x float>]]"> 77// CHECK: %[[T2:.*]] = llvm.insertvalue %[[A]], %[[T0]][0] : !llvm<"[3 x <2 x float>]"> 78// CHECK: %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][1] : !llvm<"[3 x <2 x float>]"> 79// CHECK: %[[T4:.*]] = llvm.insertvalue %[[A]], %[[T3]][2] : !llvm<"[3 x <2 x float>]"> 80// CHECK: %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T1]][0] : !llvm<"[4 x [3 x <2 x float>]]"> 81// CHECK: %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][1] : !llvm<"[4 x [3 x <2 x float>]]"> 82// CHECK: %[[T7:.*]] = llvm.insertvalue %[[T4]], %[[T6]][2] : !llvm<"[4 x [3 x <2 x float>]]"> 83// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T4]], %[[T7]][3] : !llvm<"[4 x [3 x <2 x float>]]"> 84// CHECK: llvm.return %[[T8]] : !llvm<"[4 x [3 x <2 x float>]]"> 85 86func @broadcast_vec3d_from_vec2d(%arg0: vector<3x2xf32>) -> vector<4x3x2xf32> { 87 %0 = vector.broadcast %arg0 : vector<3x2xf32> to vector<4x3x2xf32> 88 return %0 : vector<4x3x2xf32> 89} 90// CHECK-LABEL: llvm.func @broadcast_vec3d_from_vec2d( 91// CHECK-SAME: %[[A:.*]]: !llvm<"[3 x <2 x float>]">) 92// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<4x3x2xf32>) : !llvm<"[4 x [3 x <2 x float>]]"> 93// CHECK: %[[T1:.*]] = llvm.insertvalue %[[A]], %[[T0]][0] : !llvm<"[4 x [3 x <2 x float>]]"> 94// CHECK: %[[T2:.*]] = llvm.insertvalue %[[A]], %[[T1]][1] : !llvm<"[4 x [3 x <2 x float>]]"> 95// CHECK: %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][2] : !llvm<"[4 x [3 x <2 x float>]]"> 96// CHECK: %[[T4:.*]] = llvm.insertvalue %[[A]], %[[T3]][3] : !llvm<"[4 x [3 x <2 x float>]]"> 97// CHECK: llvm.return %[[T4]] : !llvm<"[4 x [3 x <2 x float>]]"> 98 99func @broadcast_stretch(%arg0: vector<1xf32>) -> vector<4xf32> { 100 %0 = vector.broadcast %arg0 : vector<1xf32> to vector<4xf32> 101 return %0 : vector<4xf32> 102} 103// CHECK-LABEL: llvm.func @broadcast_stretch( 104// CHECK-SAME: %[[A:.*]]: !llvm<"<1 x float>">) 105// CHECK: %[[T0:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 106// CHECK: %[[T1:.*]] = llvm.extractelement %[[A]][%[[T0]] : !llvm.i64] : !llvm<"<1 x float>"> 107// CHECK: %[[T2:.*]] = llvm.mlir.undef : !llvm<"<4 x float>"> 108// CHECK: %[[T3:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 109// CHECK: %[[T4:.*]] = llvm.insertelement %[[T1]], %[[T2]][%3 : !llvm.i32] : !llvm<"<4 x float>"> 110// CHECK: %[[T5:.*]] = llvm.shufflevector %[[T4]], %[[T2]] [0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm<"<4 x float>">, !llvm<"<4 x float>"> 111// CHECK: llvm.return %[[T5]] : !llvm<"<4 x float>"> 112 113func @broadcast_stretch_at_start(%arg0: vector<1x4xf32>) -> vector<3x4xf32> { 114 %0 = vector.broadcast %arg0 : vector<1x4xf32> to vector<3x4xf32> 115 return %0 : vector<3x4xf32> 116} 117// CHECK-LABEL: llvm.func @broadcast_stretch_at_start( 118// CHECK-SAME: %[[A:.*]]: !llvm<"[1 x <4 x float>]">) 119// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<3x4xf32>) : !llvm<"[3 x <4 x float>]"> 120// CHECK: %[[T1:.*]] = llvm.extractvalue %[[A]][0] : !llvm<"[1 x <4 x float>]"> 121// CHECK: %[[T2:.*]] = llvm.insertvalue %[[T1]], %[[T0]][0] : !llvm<"[3 x <4 x float>]"> 122// CHECK: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][1] : !llvm<"[3 x <4 x float>]"> 123// CHECK: %[[T4:.*]] = llvm.insertvalue %[[T1]], %[[T3]][2] : !llvm<"[3 x <4 x float>]"> 124// CHECK: llvm.return %[[T4]] : !llvm<"[3 x <4 x float>]"> 125 126func @broadcast_stretch_at_end(%arg0: vector<4x1xf32>) -> vector<4x3xf32> { 127 %0 = vector.broadcast %arg0 : vector<4x1xf32> to vector<4x3xf32> 128 return %0 : vector<4x3xf32> 129} 130// CHECK-LABEL: llvm.func @broadcast_stretch_at_end( 131// CHECK-SAME: %[[A:.*]]: !llvm<"[4 x <1 x float>]">) 132// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<4x3xf32>) : !llvm<"[4 x <3 x float>]"> 133// CHECK: %[[T1:.*]] = llvm.extractvalue %[[A]][0] : !llvm<"[4 x <1 x float>]"> 134// CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 135// CHECK: %[[T3:.*]] = llvm.extractelement %[[T1]][%[[T2]] : !llvm.i64] : !llvm<"<1 x float>"> 136// CHECK: %[[T4:.*]] = llvm.mlir.undef : !llvm<"<3 x float>"> 137// CHECK: %[[T5:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 138// CHECK: %[[T6:.*]] = llvm.insertelement %[[T3]], %[[T4]][%[[T5]] : !llvm.i32] : !llvm<"<3 x float>"> 139// CHECK: %[[T7:.*]] = llvm.shufflevector %[[T6]], %[[T4]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>"> 140// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T7]], %[[T0]][0] : !llvm<"[4 x <3 x float>]"> 141// CHECK: %[[T9:.*]] = llvm.extractvalue %[[A]][1] : !llvm<"[4 x <1 x float>]"> 142// CHECK: %[[T10:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 143// CHECK: %[[T11:.*]] = llvm.extractelement %[[T9]][%[[T10]] : !llvm.i64] : !llvm<"<1 x float>"> 144// CHECK: %[[T12:.*]] = llvm.mlir.undef : !llvm<"<3 x float>"> 145// CHECK: %[[T13:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 146// CHECK: %[[T14:.*]] = llvm.insertelement %[[T11]], %[[T12]][%[[T13]] : !llvm.i32] : !llvm<"<3 x float>"> 147// CHECK: %[[T15:.*]] = llvm.shufflevector %[[T14]], %[[T12]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>"> 148// CHECK: %[[T16:.*]] = llvm.insertvalue %[[T15]], %[[T8]][1] : !llvm<"[4 x <3 x float>]"> 149// CHECK: %[[T17:.*]] = llvm.extractvalue %[[A]][2] : !llvm<"[4 x <1 x float>]"> 150// CHECK: %[[T18:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 151// CHECK: %[[T19:.*]] = llvm.extractelement %[[T17]][%[[T18]] : !llvm.i64] : !llvm<"<1 x float>"> 152// CHECK: %[[T20:.*]] = llvm.mlir.undef : !llvm<"<3 x float>"> 153// CHECK: %[[T21:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 154// CHECK: %[[T22:.*]] = llvm.insertelement %[[T19]], %[[T20]][%[[T21]] : !llvm.i32] : !llvm<"<3 x float>"> 155// CHECK: %[[T23:.*]] = llvm.shufflevector %[[T22]], %[[T20]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>"> 156// CHECK: %[[T24:.*]] = llvm.insertvalue %[[T23]], %[[T16]][2] : !llvm<"[4 x <3 x float>]"> 157// CHECK: %[[T25:.*]] = llvm.extractvalue %[[A]][3] : !llvm<"[4 x <1 x float>]"> 158// CHECK: %[[T26:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 159// CHECK: %[[T27:.*]] = llvm.extractelement %[[T25]][%[[T26]] : !llvm.i64] : !llvm<"<1 x float>"> 160// CHECK: %[[T28:.*]] = llvm.mlir.undef : !llvm<"<3 x float>"> 161// CHECK: %[[T29:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 162// CHECK: %[[T30:.*]] = llvm.insertelement %[[T27]], %[[T28]][%[[T29]] : !llvm.i32] : !llvm<"<3 x float>"> 163// CHECK: %[[T31:.*]] = llvm.shufflevector %[[T30]], %[[T28]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>"> 164// CHECK: %[[T32:.*]] = llvm.insertvalue %[[T31]], %[[T24]][3] : !llvm<"[4 x <3 x float>]"> 165// CHECK: llvm.return %[[T32]] : !llvm<"[4 x <3 x float>]"> 166 167func @broadcast_stretch_in_middle(%arg0: vector<4x1x2xf32>) -> vector<4x3x2xf32> { 168 %0 = vector.broadcast %arg0 : vector<4x1x2xf32> to vector<4x3x2xf32> 169 return %0 : vector<4x3x2xf32> 170} 171// CHECK-LABEL: llvm.func @broadcast_stretch_in_middle( 172// CHECK-SAME: %[[A:.*]]: !llvm<"[4 x [1 x <2 x float>]]">) 173// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<4x3x2xf32>) : !llvm<"[4 x [3 x <2 x float>]]"> 174// CHECK: %[[T1:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<3x2xf32>) : !llvm<"[3 x <2 x float>]"> 175// CHECK: %[[T2:.*]] = llvm.extractvalue %[[A]][0, 0] : !llvm<"[4 x [1 x <2 x float>]]"> 176// CHECK: %[[T4:.*]] = llvm.insertvalue %[[T2]], %[[T1]][0] : !llvm<"[3 x <2 x float>]"> 177// CHECK: %[[T5:.*]] = llvm.insertvalue %[[T2]], %[[T4]][1] : !llvm<"[3 x <2 x float>]"> 178// CHECK: %[[T6:.*]] = llvm.insertvalue %[[T2]], %[[T5]][2] : !llvm<"[3 x <2 x float>]"> 179// CHECK: %[[T7:.*]] = llvm.insertvalue %[[T6]], %[[T0]][0] : !llvm<"[4 x [3 x <2 x float>]]"> 180// CHECK: %[[T8:.*]] = llvm.extractvalue %[[A]][1, 0] : !llvm<"[4 x [1 x <2 x float>]]"> 181// CHECK: %[[T10:.*]] = llvm.insertvalue %[[T8]], %[[T1]][0] : !llvm<"[3 x <2 x float>]"> 182// CHECK: %[[T11:.*]] = llvm.insertvalue %[[T8]], %[[T10]][1] : !llvm<"[3 x <2 x float>]"> 183// CHECK: %[[T12:.*]] = llvm.insertvalue %[[T8]], %[[T11]][2] : !llvm<"[3 x <2 x float>]"> 184// CHECK: %[[T13:.*]] = llvm.insertvalue %[[T12]], %[[T7]][1] : !llvm<"[4 x [3 x <2 x float>]]"> 185// CHECK: %[[T14:.*]] = llvm.extractvalue %[[A]][2, 0] : !llvm<"[4 x [1 x <2 x float>]]"> 186// CHECK: %[[T16:.*]] = llvm.insertvalue %[[T14]], %[[T1]][0] : !llvm<"[3 x <2 x float>]"> 187// CHECK: %[[T17:.*]] = llvm.insertvalue %[[T14]], %[[T16]][1] : !llvm<"[3 x <2 x float>]"> 188// CHECK: %[[T18:.*]] = llvm.insertvalue %[[T14]], %[[T17]][2] : !llvm<"[3 x <2 x float>]"> 189// CHECK: %[[T19:.*]] = llvm.insertvalue %[[T18]], %[[T13]][2] : !llvm<"[4 x [3 x <2 x float>]]"> 190// CHECK: %[[T20:.*]] = llvm.extractvalue %[[A]][3, 0] : !llvm<"[4 x [1 x <2 x float>]]"> 191// CHECK: %[[T22:.*]] = llvm.insertvalue %[[T20]], %[[T1]][0] : !llvm<"[3 x <2 x float>]"> 192// CHECK: %[[T23:.*]] = llvm.insertvalue %[[T20]], %[[T22]][1] : !llvm<"[3 x <2 x float>]"> 193// CHECK: %[[T24:.*]] = llvm.insertvalue %[[T20]], %[[T23]][2] : !llvm<"[3 x <2 x float>]"> 194// CHECK: %[[T25:.*]] = llvm.insertvalue %[[T24]], %[[T19]][3] : !llvm<"[4 x [3 x <2 x float>]]"> 195// CHECK: llvm.return %[[T25]] : !llvm<"[4 x [3 x <2 x float>]]"> 196 197func @outerproduct(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<2x3xf32> { 198 %2 = vector.outerproduct %arg0, %arg1 : vector<2xf32>, vector<3xf32> 199 return %2 : vector<2x3xf32> 200} 201// CHECK-LABEL: llvm.func @outerproduct( 202// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">, 203// CHECK-SAME: %[[B:.*]]: !llvm<"<3 x float>">) 204// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<2x3xf32>) 205// CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 206// CHECK: %[[T2:.*]] = llvm.extractelement %[[A]][%[[T1]] : !llvm.i64] : !llvm<"<2 x float>"> 207// CHECK: %[[T3:.*]] = llvm.mlir.undef : !llvm<"<3 x float>"> 208// CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 209// CHECK: %[[T5:.*]] = llvm.insertelement %[[T2]], %[[T3]][%4 : !llvm.i32] : !llvm<"<3 x float>"> 210// CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>"> 211// CHECK: %[[T7:.*]] = llvm.fmul %[[T6]], %[[B]] : !llvm<"<3 x float>"> 212// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T7]], %[[T0]][0] : !llvm<"[2 x <3 x float>]"> 213// CHECK: %[[T9:.*]] = llvm.mlir.constant(1 : i64) : !llvm.i64 214// CHECK: %[[T10:.*]] = llvm.extractelement %[[A]][%9 : !llvm.i64] : !llvm<"<2 x float>"> 215// CHECK: %[[T11:.*]] = llvm.mlir.undef : !llvm<"<3 x float>"> 216// CHECK: %[[T12:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 217// CHECK: %[[T13:.*]] = llvm.insertelement %[[T10]], %[[T11]][%12 : !llvm.i32] : !llvm<"<3 x float>"> 218// CHECK: %[[T14:.*]] = llvm.shufflevector %[[T13]], %[[T11]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>"> 219// CHECK: %[[T15:.*]] = llvm.fmul %[[T14]], %[[B]] : !llvm<"<3 x float>"> 220// CHECK: %[[T16:.*]] = llvm.insertvalue %[[T15]], %[[T8]][1] : !llvm<"[2 x <3 x float>]"> 221// CHECK: llvm.return %[[T16]] : !llvm<"[2 x <3 x float>]"> 222 223func @outerproduct_add(%arg0: vector<2xf32>, %arg1: vector<3xf32>, %arg2: vector<2x3xf32>) -> vector<2x3xf32> { 224 %2 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xf32>, vector<3xf32> 225 return %2 : vector<2x3xf32> 226} 227// CHECK-LABEL: llvm.func @outerproduct_add( 228// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">, 229// CHECK-SAME: %[[B:.*]]: !llvm<"<3 x float>">, 230// CHECK-SAME: %[[C:.*]]: !llvm<"[2 x <3 x float>]">) 231// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<2x3xf32>) 232// CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 233// CHECK: %[[T2:.*]] = llvm.extractelement %[[A]][%[[T1]] : !llvm.i64] : !llvm<"<2 x float>"> 234// CHECK: %[[T3:.*]] = llvm.mlir.undef : !llvm<"<3 x float>"> 235// CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 236// CHECK: %[[T5:.*]] = llvm.insertelement %[[T2]], %[[T3]][%[[T4]] : !llvm.i32] : !llvm<"<3 x float>"> 237// CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>"> 238// CHECK: %[[T7:.*]] = llvm.extractvalue %[[C]][0] : !llvm<"[2 x <3 x float>]"> 239// CHECK: %[[T8:.*]] = "llvm.intr.fmuladd"(%[[T6]], %[[B]], %[[T7]]) : (!llvm<"<3 x float>">, !llvm<"<3 x float>">, !llvm<"<3 x float>">) 240// CHECK: %[[T9:.*]] = llvm.insertvalue %[[T8]], %[[T0]][0] : !llvm<"[2 x <3 x float>]"> 241// CHECK: %[[T10:.*]] = llvm.mlir.constant(1 : i64) : !llvm.i64 242// CHECK: %[[T11:.*]] = llvm.extractelement %[[A]][%[[T10]] : !llvm.i64] : !llvm<"<2 x float>"> 243// CHECK: %[[T12:.*]] = llvm.mlir.undef : !llvm<"<3 x float>"> 244// CHECK: %[[T13:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 245// CHECK: %[[T14:.*]] = llvm.insertelement %[[T11]], %[[T12]][%[[T13]] : !llvm.i32] : !llvm<"<3 x float>"> 246// CHECK: %[[T15:.*]] = llvm.shufflevector %[[T14]], %[[T12]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>"> 247// CHECK: %[[T16:.*]] = llvm.extractvalue %[[C]][1] : !llvm<"[2 x <3 x float>]"> 248// CHECK: %[[T17:.*]] = "llvm.intr.fmuladd"(%[[T15]], %[[B]], %[[T16]]) : (!llvm<"<3 x float>">, !llvm<"<3 x float>">, !llvm<"<3 x float>">) 249// CHECK: %[[T18:.*]] = llvm.insertvalue %[[T17]], %[[T9]][1] : !llvm<"[2 x <3 x float>]"> 250// CHECK: llvm.return %[[T18]] : !llvm<"[2 x <3 x float>]"> 251 252func @shuffle_1D_direct(%arg0: vector<2xf32>, %arg1: vector<2xf32>) -> vector<2xf32> { 253 %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<2xf32> 254 return %1 : vector<2xf32> 255} 256// CHECK-LABEL: llvm.func @shuffle_1D_direct( 257// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">, 258// CHECK-SAME: %[[B:.*]]: !llvm<"<2 x float>">) 259// CHECK: %[[s:.*]] = llvm.shufflevector %[[A]], %[[B]] [0, 1] : !llvm<"<2 x float>">, !llvm<"<2 x float>"> 260// CHECK: llvm.return %[[s]] : !llvm<"<2 x float>"> 261 262func @shuffle_1D(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<5xf32> { 263 %1 = vector.shuffle %arg0, %arg1 [4, 3, 2, 1, 0] : vector<2xf32>, vector<3xf32> 264 return %1 : vector<5xf32> 265} 266// CHECK-LABEL: llvm.func @shuffle_1D( 267// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">, 268// CHECK-SAME: %[[B:.*]]: !llvm<"<3 x float>">) 269// CHECK: %[[u0:.*]] = llvm.mlir.undef : !llvm<"<5 x float>"> 270// CHECK: %[[c2:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 271// CHECK: %[[e1:.*]] = llvm.extractelement %[[B]][%[[c2]] : !llvm.i64] : !llvm<"<3 x float>"> 272// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 273// CHECK: %[[i1:.*]] = llvm.insertelement %[[e1]], %[[u0]][%[[c0]] : !llvm.i64] : !llvm<"<5 x float>"> 274// CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 275// CHECK: %[[e2:.*]] = llvm.extractelement %[[B]][%[[c1]] : !llvm.i64] : !llvm<"<3 x float>"> 276// CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 277// CHECK: %[[i2:.*]] = llvm.insertelement %[[e2]], %[[i1]][%[[c1]] : !llvm.i64] : !llvm<"<5 x float>"> 278// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 279// CHECK: %[[e3:.*]] = llvm.extractelement %[[B]][%[[c0]] : !llvm.i64] : !llvm<"<3 x float>"> 280// CHECK: %[[c2:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 281// CHECK: %[[i3:.*]] = llvm.insertelement %[[e3]], %[[i2]][%[[c2]] : !llvm.i64] : !llvm<"<5 x float>"> 282// CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 283// CHECK: %[[e4:.*]] = llvm.extractelement %[[A]][%[[c1]] : !llvm.i64] : !llvm<"<2 x float>"> 284// CHECK: %[[c3:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 285// CHECK: %[[i4:.*]] = llvm.insertelement %[[e4]], %[[i3]][%[[c3]] : !llvm.i64] : !llvm<"<5 x float>"> 286// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 287// CHECK: %[[e5:.*]] = llvm.extractelement %[[A]][%[[c0]] : !llvm.i64] : !llvm<"<2 x float>"> 288// CHECK: %[[c4:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 289// CHECK: %[[i5:.*]] = llvm.insertelement %[[e5]], %[[i4]][%[[c4]] : !llvm.i64] : !llvm<"<5 x float>"> 290// CHECK: llvm.return %[[i5]] : !llvm<"<5 x float>"> 291 292func @shuffle_2D(%a: vector<1x4xf32>, %b: vector<2x4xf32>) -> vector<3x4xf32> { 293 %1 = vector.shuffle %a, %b[1, 0, 2] : vector<1x4xf32>, vector<2x4xf32> 294 return %1 : vector<3x4xf32> 295} 296// CHECK-LABEL: llvm.func @shuffle_2D( 297// CHECK-SAME: %[[A:.*]]: !llvm<"[1 x <4 x float>]">, 298// CHECK-SAME: %[[B:.*]]: !llvm<"[2 x <4 x float>]">) 299// CHECK: %[[u0:.*]] = llvm.mlir.undef : !llvm<"[3 x <4 x float>]"> 300// CHECK: %[[e1:.*]] = llvm.extractvalue %[[B]][0] : !llvm<"[2 x <4 x float>]"> 301// CHECK: %[[i1:.*]] = llvm.insertvalue %[[e1]], %[[u0]][0] : !llvm<"[3 x <4 x float>]"> 302// CHECK: %[[e2:.*]] = llvm.extractvalue %[[A]][0] : !llvm<"[1 x <4 x float>]"> 303// CHECK: %[[i2:.*]] = llvm.insertvalue %[[e2]], %[[i1]][1] : !llvm<"[3 x <4 x float>]"> 304// CHECK: %[[e3:.*]] = llvm.extractvalue %[[B]][1] : !llvm<"[2 x <4 x float>]"> 305// CHECK: %[[i3:.*]] = llvm.insertvalue %[[e3]], %[[i2]][2] : !llvm<"[3 x <4 x float>]"> 306// CHECK: llvm.return %[[i3]] : !llvm<"[3 x <4 x float>]"> 307 308func @extract_element(%arg0: vector<16xf32>) -> f32 { 309 %0 = constant 15 : i32 310 %1 = vector.extractelement %arg0[%0 : i32]: vector<16xf32> 311 return %1 : f32 312} 313// CHECK-LABEL: llvm.func @extract_element( 314// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x float>">) 315// CHECK: %[[c:.*]] = llvm.mlir.constant(15 : i32) : !llvm.i32 316// CHECK: %[[x:.*]] = llvm.extractelement %[[A]][%[[c]] : !llvm.i32] : !llvm<"<16 x float>"> 317// CHECK: llvm.return %[[x]] : !llvm.float 318 319func @extract_element_from_vec_1d(%arg0: vector<16xf32>) -> f32 { 320 %0 = vector.extract %arg0[15]: vector<16xf32> 321 return %0 : f32 322} 323// CHECK-LABEL: llvm.func @extract_element_from_vec_1d 324// CHECK: llvm.mlir.constant(15 : i64) : !llvm.i64 325// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<16 x float>"> 326// CHECK: llvm.return {{.*}} : !llvm.float 327 328func @extract_vec_2d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<3x16xf32> { 329 %0 = vector.extract %arg0[0]: vector<4x3x16xf32> 330 return %0 : vector<3x16xf32> 331} 332// CHECK-LABEL: llvm.func @extract_vec_2d_from_vec_3d 333// CHECK: llvm.extractvalue {{.*}}[0] : !llvm<"[4 x [3 x <16 x float>]]"> 334// CHECK: llvm.return {{.*}} : !llvm<"[3 x <16 x float>]"> 335 336func @extract_vec_1d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<16xf32> { 337 %0 = vector.extract %arg0[0, 0]: vector<4x3x16xf32> 338 return %0 : vector<16xf32> 339} 340// CHECK-LABEL: llvm.func @extract_vec_1d_from_vec_3d 341// CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm<"[4 x [3 x <16 x float>]]"> 342// CHECK: llvm.return {{.*}} : !llvm<"<16 x float>"> 343 344func @extract_element_from_vec_3d(%arg0: vector<4x3x16xf32>) -> f32 { 345 %0 = vector.extract %arg0[0, 0, 0]: vector<4x3x16xf32> 346 return %0 : f32 347} 348// CHECK-LABEL: llvm.func @extract_element_from_vec_3d 349// CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm<"[4 x [3 x <16 x float>]]"> 350// CHECK: llvm.mlir.constant(0 : i64) : !llvm.i64 351// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<16 x float>"> 352// CHECK: llvm.return {{.*}} : !llvm.float 353 354func @insert_element(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> { 355 %0 = constant 3 : i32 356 %1 = vector.insertelement %arg0, %arg1[%0 : i32] : vector<4xf32> 357 return %1 : vector<4xf32> 358} 359// CHECK-LABEL: llvm.func @insert_element( 360// CHECK-SAME: %[[A:.*]]: !llvm.float, 361// CHECK-SAME: %[[B:.*]]: !llvm<"<4 x float>">) 362// CHECK: %[[c:.*]] = llvm.mlir.constant(3 : i32) : !llvm.i32 363// CHECK: %[[x:.*]] = llvm.insertelement %[[A]], %[[B]][%[[c]] : !llvm.i32] : !llvm<"<4 x float>"> 364// CHECK: llvm.return %[[x]] : !llvm<"<4 x float>"> 365 366func @insert_element_into_vec_1d(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> { 367 %0 = vector.insert %arg0, %arg1[3] : f32 into vector<4xf32> 368 return %0 : vector<4xf32> 369} 370// CHECK-LABEL: llvm.func @insert_element_into_vec_1d 371// CHECK: llvm.mlir.constant(3 : i64) : !llvm.i64 372// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>"> 373// CHECK: llvm.return {{.*}} : !llvm<"<4 x float>"> 374 375func @insert_vec_2d_into_vec_3d(%arg0: vector<8x16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> { 376 %0 = vector.insert %arg0, %arg1[3] : vector<8x16xf32> into vector<4x8x16xf32> 377 return %0 : vector<4x8x16xf32> 378} 379// CHECK-LABEL: llvm.func @insert_vec_2d_into_vec_3d 380// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm<"[4 x [8 x <16 x float>]]"> 381// CHECK: llvm.return {{.*}} : !llvm<"[4 x [8 x <16 x float>]]"> 382 383func @insert_vec_1d_into_vec_3d(%arg0: vector<16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> { 384 %0 = vector.insert %arg0, %arg1[3, 7] : vector<16xf32> into vector<4x8x16xf32> 385 return %0 : vector<4x8x16xf32> 386} 387// CHECK-LABEL: llvm.func @insert_vec_1d_into_vec_3d 388// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm<"[4 x [8 x <16 x float>]]"> 389// CHECK: llvm.return {{.*}} : !llvm<"[4 x [8 x <16 x float>]]"> 390 391func @insert_element_into_vec_3d(%arg0: f32, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> { 392 %0 = vector.insert %arg0, %arg1[3, 7, 15] : f32 into vector<4x8x16xf32> 393 return %0 : vector<4x8x16xf32> 394} 395// CHECK-LABEL: llvm.func @insert_element_into_vec_3d 396// CHECK: llvm.extractvalue {{.*}}[3, 7] : !llvm<"[4 x [8 x <16 x float>]]"> 397// CHECK: llvm.mlir.constant(15 : i64) : !llvm.i64 398// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<16 x float>"> 399// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm<"[4 x [8 x <16 x float>]]"> 400// CHECK: llvm.return {{.*}} : !llvm<"[4 x [8 x <16 x float>]]"> 401 402func @vector_type_cast(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32>> { 403 %0 = vector.type_cast %arg0: memref<8x8x8xf32> to memref<vector<8x8x8xf32>> 404 return %0 : memref<vector<8x8x8xf32>> 405} 406// CHECK-LABEL: llvm.func @vector_type_cast 407// CHECK: llvm.mlir.undef : !llvm<"{ [8 x [8 x <8 x float>]]*, [8 x [8 x <8 x float>]]*, i64 }"> 408// CHECK: %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }"> 409// CHECK: %[[allocatedBit:.*]] = llvm.bitcast %[[allocated]] : !llvm<"float*"> to !llvm<"[8 x [8 x <8 x float>]]*"> 410// CHECK: llvm.insertvalue %[[allocatedBit]], {{.*}}[0] : !llvm<"{ [8 x [8 x <8 x float>]]*, [8 x [8 x <8 x float>]]*, i64 }"> 411// CHECK: %[[aligned:.*]] = llvm.extractvalue {{.*}}[1] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }"> 412// CHECK: %[[alignedBit:.*]] = llvm.bitcast %[[aligned]] : !llvm<"float*"> to !llvm<"[8 x [8 x <8 x float>]]*"> 413// CHECK: llvm.insertvalue %[[alignedBit]], {{.*}}[1] : !llvm<"{ [8 x [8 x <8 x float>]]*, [8 x [8 x <8 x float>]]*, i64 }"> 414// CHECK: llvm.mlir.constant(0 : index 415// CHECK: llvm.insertvalue {{.*}}[2] : !llvm<"{ [8 x [8 x <8 x float>]]*, [8 x [8 x <8 x float>]]*, i64 }"> 416 417func @vector_type_cast_non_zero_addrspace(%arg0: memref<8x8x8xf32, 3>) -> memref<vector<8x8x8xf32>, 3> { 418 %0 = vector.type_cast %arg0: memref<8x8x8xf32, 3> to memref<vector<8x8x8xf32>, 3> 419 return %0 : memref<vector<8x8x8xf32>, 3> 420} 421// CHECK-LABEL: llvm.func @vector_type_cast_non_zero_addrspace 422// CHECK: llvm.mlir.undef : !llvm<"{ [8 x [8 x <8 x float>]] addrspace(3)*, [8 x [8 x <8 x float>]] addrspace(3)*, i64 }"> 423// CHECK: %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm<"{ float addrspace(3)*, float addrspace(3)*, i64, [3 x i64], [3 x i64] }"> 424// CHECK: %[[allocatedBit:.*]] = llvm.bitcast %[[allocated]] : !llvm<"float addrspace(3)*"> to !llvm<"[8 x [8 x <8 x float>]] addrspace(3)*"> 425// CHECK: llvm.insertvalue %[[allocatedBit]], {{.*}}[0] : !llvm<"{ [8 x [8 x <8 x float>]] addrspace(3)*, [8 x [8 x <8 x float>]] addrspace(3)*, i64 }"> 426// CHECK: %[[aligned:.*]] = llvm.extractvalue {{.*}}[1] : !llvm<"{ float addrspace(3)*, float addrspace(3)*, i64, [3 x i64], [3 x i64] }"> 427// CHECK: %[[alignedBit:.*]] = llvm.bitcast %[[aligned]] : !llvm<"float addrspace(3)*"> to !llvm<"[8 x [8 x <8 x float>]] addrspace(3)*"> 428// CHECK: llvm.insertvalue %[[alignedBit]], {{.*}}[1] : !llvm<"{ [8 x [8 x <8 x float>]] addrspace(3)*, [8 x [8 x <8 x float>]] addrspace(3)*, i64 }"> 429// CHECK: llvm.mlir.constant(0 : index 430// CHECK: llvm.insertvalue {{.*}}[2] : !llvm<"{ [8 x [8 x <8 x float>]] addrspace(3)*, [8 x [8 x <8 x float>]] addrspace(3)*, i64 }"> 431 432func @vector_print_scalar_i1(%arg0: i1) { 433 vector.print %arg0 : i1 434 return 435} 436// CHECK-LABEL: llvm.func @vector_print_scalar_i1( 437// CHECK-SAME: %[[A:.*]]: !llvm.i1) 438// CHECK: %[[T:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 439// CHECK: %[[F:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 440// CHECK: %[[S:.*]] = llvm.select %[[A]], %[[T]], %[[F]] : !llvm.i1, !llvm.i32 441// CHECK: llvm.call @print_i32(%[[S]]) : (!llvm.i32) -> () 442// CHECK: llvm.call @print_newline() : () -> () 443 444func @vector_print_scalar_i32(%arg0: i32) { 445 vector.print %arg0 : i32 446 return 447} 448// CHECK-LABEL: llvm.func @vector_print_scalar_i32( 449// CHECK-SAME: %[[A:.*]]: !llvm.i32) 450// CHECK: llvm.call @print_i32(%[[A]]) : (!llvm.i32) -> () 451// CHECK: llvm.call @print_newline() : () -> () 452 453func @vector_print_scalar_i64(%arg0: i64) { 454 vector.print %arg0 : i64 455 return 456} 457// CHECK-LABEL: llvm.func @vector_print_scalar_i64( 458// CHECK-SAME: %[[A:.*]]: !llvm.i64) 459// CHECK: llvm.call @print_i64(%[[A]]) : (!llvm.i64) -> () 460// CHECK: llvm.call @print_newline() : () -> () 461 462func @vector_print_scalar_f32(%arg0: f32) { 463 vector.print %arg0 : f32 464 return 465} 466// CHECK-LABEL: llvm.func @vector_print_scalar_f32( 467// CHECK-SAME: %[[A:.*]]: !llvm.float) 468// CHECK: llvm.call @print_f32(%[[A]]) : (!llvm.float) -> () 469// CHECK: llvm.call @print_newline() : () -> () 470 471func @vector_print_scalar_f64(%arg0: f64) { 472 vector.print %arg0 : f64 473 return 474} 475// CHECK-LABEL: llvm.func @vector_print_scalar_f64( 476// CHECK-SAME: %[[A:.*]]: !llvm.double) 477// CHECK: llvm.call @print_f64(%[[A]]) : (!llvm.double) -> () 478// CHECK: llvm.call @print_newline() : () -> () 479 480func @vector_print_vector(%arg0: vector<2x2xf32>) { 481 vector.print %arg0 : vector<2x2xf32> 482 return 483} 484// CHECK-LABEL: llvm.func @vector_print_vector( 485// CHECK-SAME: %[[A:.*]]: !llvm<"[2 x <2 x float>]">) 486// CHECK: llvm.call @print_open() : () -> () 487// CHECK: %[[x0:.*]] = llvm.extractvalue %[[A]][0] : !llvm<"[2 x <2 x float>]"> 488// CHECK: llvm.call @print_open() : () -> () 489// CHECK: %[[x1:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 490// CHECK: %[[x2:.*]] = llvm.extractelement %[[x0]][%[[x1]] : !llvm.i64] : !llvm<"<2 x float>"> 491// CHECK: llvm.call @print_f32(%[[x2]]) : (!llvm.float) -> () 492// CHECK: llvm.call @print_comma() : () -> () 493// CHECK: %[[x3:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 494// CHECK: %[[x4:.*]] = llvm.extractelement %[[x0]][%[[x3]] : !llvm.i64] : !llvm<"<2 x float>"> 495// CHECK: llvm.call @print_f32(%[[x4]]) : (!llvm.float) -> () 496// CHECK: llvm.call @print_close() : () -> () 497// CHECK: llvm.call @print_comma() : () -> () 498// CHECK: %[[x5:.*]] = llvm.extractvalue %[[A]][1] : !llvm<"[2 x <2 x float>]"> 499// CHECK: llvm.call @print_open() : () -> () 500// CHECK: %[[x6:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 501// CHECK: %[[x7:.*]] = llvm.extractelement %[[x5]][%[[x6]] : !llvm.i64] : !llvm<"<2 x float>"> 502// CHECK: llvm.call @print_f32(%[[x7]]) : (!llvm.float) -> () 503// CHECK: llvm.call @print_comma() : () -> () 504// CHECK: %[[x8:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 505// CHECK: %[[x9:.*]] = llvm.extractelement %[[x5]][%[[x8]] : !llvm.i64] : !llvm<"<2 x float>"> 506// CHECK: llvm.call @print_f32(%[[x9]]) : (!llvm.float) -> () 507// CHECK: llvm.call @print_close() : () -> () 508// CHECK: llvm.call @print_close() : () -> () 509// CHECK: llvm.call @print_newline() : () -> () 510 511func @extract_strided_slice1(%arg0: vector<4xf32>) -> vector<2xf32> { 512 %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32> 513 return %0 : vector<2xf32> 514} 515// CHECK-LABEL: llvm.func @extract_strided_slice1 516// CHECK: llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float 517// CHECK: llvm.mlir.constant(dense<0.000000e+00> : vector<2xf32>) : !llvm<"<2 x float>"> 518// CHECK: llvm.mlir.constant(2 : index) : !llvm.i64 519// CHECK: llvm.extractelement %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<4 x float>"> 520// CHECK: llvm.mlir.constant(0 : index) : !llvm.i64 521// CHECK: llvm.insertelement %{{.*}}, %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<2 x float>"> 522// CHECK: llvm.mlir.constant(3 : index) : !llvm.i64 523// CHECK: llvm.extractelement %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<4 x float>"> 524// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 525// CHECK: llvm.insertelement %{{.*}}, %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<2 x float>"> 526 527func @extract_strided_slice2(%arg0: vector<4x8xf32>) -> vector<2x8xf32> { 528 %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4x8xf32> to vector<2x8xf32> 529 return %0 : vector<2x8xf32> 530} 531// CHECK-LABEL: llvm.func @extract_strided_slice2 532// CHECK: llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float 533// CHECK: llvm.mlir.constant(dense<0.000000e+00> : vector<2x8xf32>) : !llvm<"[2 x <8 x float>]"> 534// CHECK: llvm.extractvalue %{{.*}}[2] : !llvm<"[4 x <8 x float>]"> 535// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"[2 x <8 x float>]"> 536// CHECK: llvm.extractvalue %{{.*}}[3] : !llvm<"[4 x <8 x float>]"> 537// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"[2 x <8 x float>]"> 538 539func @extract_strided_slice3(%arg0: vector<4x8xf32>) -> vector<2x2xf32> { 540 %0 = vector.extract_strided_slice %arg0 {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8xf32> to vector<2x2xf32> 541 return %0 : vector<2x2xf32> 542} 543// CHECK-LABEL: llvm.func @extract_strided_slice3 544// CHECK: llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float 545// CHECK: llvm.mlir.constant(dense<0.000000e+00> : vector<2x2xf32>) : !llvm<"[2 x <2 x float>]"> 546// 547// Subvector vector<8xf32> @2 548// CHECK: llvm.extractvalue {{.*}}[2] : !llvm<"[4 x <8 x float>]"> 549// CHECK: llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float 550// CHECK: llvm.mlir.constant(dense<0.000000e+00> : vector<2xf32>) : !llvm<"<2 x float>"> 551// CHECK: llvm.mlir.constant(2 : index) : !llvm.i64 552// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 x float>"> 553// CHECK: llvm.mlir.constant(0 : index) : !llvm.i64 554// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>"> 555// CHECK: llvm.mlir.constant(3 : index) : !llvm.i64 556// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 x float>"> 557// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 558// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>"> 559// CHECK: llvm.insertvalue {{.*}}, {{.*}}[0] : !llvm<"[2 x <2 x float>]"> 560// 561// Subvector vector<8xf32> @3 562// CHECK: llvm.extractvalue {{.*}}[3] : !llvm<"[4 x <8 x float>]"> 563// CHECK: llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float 564// CHECK: llvm.mlir.constant(dense<0.000000e+00> : vector<2xf32>) : !llvm<"<2 x float>"> 565// CHECK: llvm.mlir.constant(2 : index) : !llvm.i64 566// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 x float>"> 567// CHECK: llvm.mlir.constant(0 : index) : !llvm.i64 568// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>"> 569// CHECK: llvm.mlir.constant(3 : index) : !llvm.i64 570// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 x float>"> 571// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 572// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>"> 573// CHECK: llvm.insertvalue {{.*}}, {{.*}}[1] : !llvm<"[2 x <2 x float>]"> 574 575func @insert_strided_slice1(%b: vector<4x4xf32>, %c: vector<4x4x4xf32>) -> vector<4x4x4xf32> { 576 %0 = vector.insert_strided_slice %b, %c {offsets = [2, 0, 0], strides = [1, 1]} : vector<4x4xf32> into vector<4x4x4xf32> 577 return %0 : vector<4x4x4xf32> 578} 579// CHECK-LABEL: llvm.func @insert_strided_slice1 580// CHECK: llvm.extractvalue {{.*}}[2] : !llvm<"[4 x [4 x <4 x float>]]"> 581// CHECK-NEXT: llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm<"[4 x [4 x <4 x float>]]"> 582 583func @insert_strided_slice2(%a: vector<2x2xf32>, %b: vector<4x4xf32>) -> vector<4x4xf32> { 584 %0 = vector.insert_strided_slice %a, %b {offsets = [2, 2], strides = [1, 1]} : vector<2x2xf32> into vector<4x4xf32> 585 return %0 : vector<4x4xf32> 586} 587// CHECK-LABEL: llvm.func @insert_strided_slice2 588// 589// Subvector vector<2xf32> @0 into vector<4xf32> @2 590// CHECK: llvm.extractvalue {{.*}}[0] : !llvm<"[2 x <2 x float>]"> 591// CHECK-NEXT: llvm.extractvalue {{.*}}[2] : !llvm<"[4 x <4 x float>]"> 592// Element @0 -> element @2 593// CHECK-NEXT: llvm.mlir.constant(0 : index) : !llvm.i64 594// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>"> 595// CHECK-NEXT: llvm.mlir.constant(2 : index) : !llvm.i64 596// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>"> 597// Element @1 -> element @3 598// CHECK-NEXT: llvm.mlir.constant(1 : index) : !llvm.i64 599// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>"> 600// CHECK-NEXT: llvm.mlir.constant(3 : index) : !llvm.i64 601// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>"> 602// CHECK-NEXT: llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm<"[4 x <4 x float>]"> 603// 604// Subvector vector<2xf32> @1 into vector<4xf32> @3 605// CHECK: llvm.extractvalue {{.*}}[1] : !llvm<"[2 x <2 x float>]"> 606// CHECK-NEXT: llvm.extractvalue {{.*}}[3] : !llvm<"[4 x <4 x float>]"> 607// Element @0 -> element @2 608// CHECK-NEXT: llvm.mlir.constant(0 : index) : !llvm.i64 609// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>"> 610// CHECK-NEXT: llvm.mlir.constant(2 : index) : !llvm.i64 611// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>"> 612// Element @1 -> element @3 613// CHECK-NEXT: llvm.mlir.constant(1 : index) : !llvm.i64 614// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>"> 615// CHECK-NEXT: llvm.mlir.constant(3 : index) : !llvm.i64 616// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>"> 617// CHECK-NEXT: llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm<"[4 x <4 x float>]"> 618 619func @insert_strided_slice3(%arg0: vector<2x4xf32>, %arg1: vector<16x4x8xf32>) -> vector<16x4x8xf32> { 620 %0 = vector.insert_strided_slice %arg0, %arg1 {offsets = [0, 0, 2], strides = [1, 1]}: 621 vector<2x4xf32> into vector<16x4x8xf32> 622 return %0 : vector<16x4x8xf32> 623} 624// CHECK-LABEL: llvm.func @insert_strided_slice3( 625// CHECK-SAME: %[[A:.*]]: !llvm<"[2 x <4 x float>]">, 626// CHECK-SAME: %[[B:.*]]: !llvm<"[16 x [4 x <8 x float>]]">) 627// CHECK: %[[s0:.*]] = llvm.extractvalue %[[B]][0] : !llvm<"[16 x [4 x <8 x float>]]"> 628// CHECK: %[[s1:.*]] = llvm.extractvalue %[[A]][0] : !llvm<"[2 x <4 x float>]"> 629// CHECK: %[[s2:.*]] = llvm.extractvalue %[[B]][0, 0] : !llvm<"[16 x [4 x <8 x float>]]"> 630// CHECK: %[[s3:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 631// CHECK: %[[s4:.*]] = llvm.extractelement %[[s1]][%[[s3]] : !llvm.i64] : !llvm<"<4 x float>"> 632// CHECK: %[[s5:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 633// CHECK: %[[s6:.*]] = llvm.insertelement %[[s4]], %[[s2]][%[[s5]] : !llvm.i64] : !llvm<"<8 x float>"> 634// CHECK: %[[s7:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 635// CHECK: %[[s8:.*]] = llvm.extractelement %[[s1]][%[[s7]] : !llvm.i64] : !llvm<"<4 x float>"> 636// CHECK: %[[s9:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 637// CHECK: %[[s10:.*]] = llvm.insertelement %[[s8]], %[[s6]][%[[s9]] : !llvm.i64] : !llvm<"<8 x float>"> 638// CHECK: %[[s11:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 639// CHECK: %[[s12:.*]] = llvm.extractelement %[[s1]][%[[s11]] : !llvm.i64] : !llvm<"<4 x float>"> 640// CHECK: %[[s13:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 641// CHECK: %[[s14:.*]] = llvm.insertelement %[[s12]], %[[s10]][%[[s13]] : !llvm.i64] : !llvm<"<8 x float>"> 642// CHECK: %[[s15:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 643// CHECK: %[[s16:.*]] = llvm.extractelement %[[s1]][%[[s15]] : !llvm.i64] : !llvm<"<4 x float>"> 644// CHECK: %[[s17:.*]] = llvm.mlir.constant(5 : index) : !llvm.i64 645// CHECK: %[[s18:.*]] = llvm.insertelement %[[s16]], %[[s14]][%[[s17]] : !llvm.i64] : !llvm<"<8 x float>"> 646// CHECK: %[[s19:.*]] = llvm.insertvalue %[[s18]], %[[s0]][0] : !llvm<"[4 x <8 x float>]"> 647// CHECK: %[[s20:.*]] = llvm.extractvalue %[[A]][1] : !llvm<"[2 x <4 x float>]"> 648// CHECK: %[[s21:.*]] = llvm.extractvalue %[[B]][0, 1] : !llvm<"[16 x [4 x <8 x float>]]"> 649// CHECK: %[[s22:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 650// CHECK: %[[s23:.*]] = llvm.extractelement %[[s20]][%[[s22]] : !llvm.i64] : !llvm<"<4 x float>"> 651// CHECK: %[[s24:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 652// CHECK: %[[s25:.*]] = llvm.insertelement %[[s23]], %[[s21]][%[[s24]] : !llvm.i64] : !llvm<"<8 x float>"> 653// CHECK: %[[s26:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 654// CHECK: %[[s27:.*]] = llvm.extractelement %[[s20]][%[[s26]] : !llvm.i64] : !llvm<"<4 x float>"> 655// CHECK: %[[s28:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 656// CHECK: %[[s29:.*]] = llvm.insertelement %[[s27]], %[[s25]][%[[s28]] : !llvm.i64] : !llvm<"<8 x float>"> 657// CHECK: %[[s30:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 658// CHECK: %[[s31:.*]] = llvm.extractelement %[[s20]][%[[s30]] : !llvm.i64] : !llvm<"<4 x float>"> 659// CHECK: %[[s32:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 660// CHECK: %[[s33:.*]] = llvm.insertelement %[[s31]], %[[s29]][%[[s32]] : !llvm.i64] : !llvm<"<8 x float>"> 661// CHECK: %[[s34:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 662// CHECK: %[[s35:.*]] = llvm.extractelement %[[s20]][%[[s34]] : !llvm.i64] : !llvm<"<4 x float>"> 663// CHECK: %[[s36:.*]] = llvm.mlir.constant(5 : index) : !llvm.i64 664// CHECK: %[[s37:.*]] = llvm.insertelement %[[s35]], %[[s33]][%[[s36]] : !llvm.i64] : !llvm<"<8 x float>"> 665// CHECK: %[[s38:.*]] = llvm.insertvalue %[[s37]], %[[s19]][1] : !llvm<"[4 x <8 x float>]"> 666// CHECK: %[[s39:.*]] = llvm.insertvalue %[[s38]], %[[B]][0] : !llvm<"[16 x [4 x <8 x float>]]"> 667// CHECK: llvm.return %[[s39]] : !llvm<"[16 x [4 x <8 x float>]]"> 668 669func @extract_strides(%arg0: vector<3x3xf32>) -> vector<1x1xf32> { 670 %0 = vector.extract_slices %arg0, [2, 2], [1, 1] 671 : vector<3x3xf32> into tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>> 672 %1 = vector.tuple_get %0, 3 : tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>> 673 return %1 : vector<1x1xf32> 674} 675// CHECK-LABEL: llvm.func @extract_strides( 676// CHECK-SAME: %[[A:.*]]: !llvm<"[3 x <3 x float>]">) 677// CHECK: %[[s0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<1x1xf32>) : !llvm<"[1 x <1 x float>]"> 678// CHECK: %[[s1:.*]] = llvm.extractvalue %[[A]][2] : !llvm<"[3 x <3 x float>]"> 679// CHECK: %[[s3:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<1xf32>) : !llvm<"<1 x float>"> 680// CHECK: %[[s4:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 681// CHECK: %[[s5:.*]] = llvm.extractelement %[[s1]][%[[s4]] : !llvm.i64] : !llvm<"<3 x float>"> 682// CHECK: %[[s6:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 683// CHECK: %[[s7:.*]] = llvm.insertelement %[[s5]], %[[s3]][%[[s6]] : !llvm.i64] : !llvm<"<1 x float>"> 684// CHECK: %[[s8:.*]] = llvm.insertvalue %[[s7]], %[[s0]][0] : !llvm<"[1 x <1 x float>]"> 685// CHECK: llvm.return %[[s8]] : !llvm<"[1 x <1 x float>]"> 686 687// CHECK-LABEL: llvm.func @vector_fma( 688// CHECK-SAME: %[[A:.*]]: !llvm<"<8 x float>">, %[[B:.*]]: !llvm<"[2 x <4 x float>]">) 689// CHECK-SAME: -> !llvm<"{ <8 x float>, [2 x <4 x float>] }"> { 690func @vector_fma(%a: vector<8xf32>, %b: vector<2x4xf32>) -> (vector<8xf32>, vector<2x4xf32>) { 691 // CHECK: "llvm.intr.fmuladd"(%[[A]], %[[A]], %[[A]]) : 692 // CHECK-SAME: (!llvm<"<8 x float>">, !llvm<"<8 x float>">, !llvm<"<8 x float>">) -> !llvm<"<8 x float>"> 693 %0 = vector.fma %a, %a, %a : vector<8xf32> 694 695 // CHECK: %[[b00:.*]] = llvm.extractvalue %[[B]][0] : !llvm<"[2 x <4 x float>]"> 696 // CHECK: %[[b01:.*]] = llvm.extractvalue %[[B]][0] : !llvm<"[2 x <4 x float>]"> 697 // CHECK: %[[b02:.*]] = llvm.extractvalue %[[B]][0] : !llvm<"[2 x <4 x float>]"> 698 // CHECK: %[[B0:.*]] = "llvm.intr.fmuladd"(%[[b00]], %[[b01]], %[[b02]]) : 699 // CHECK-SAME: (!llvm<"<4 x float>">, !llvm<"<4 x float>">, !llvm<"<4 x float>">) -> !llvm<"<4 x float>"> 700 // CHECK: llvm.insertvalue %[[B0]], {{.*}}[0] : !llvm<"[2 x <4 x float>]"> 701 // CHECK: %[[b10:.*]] = llvm.extractvalue %[[B]][1] : !llvm<"[2 x <4 x float>]"> 702 // CHECK: %[[b11:.*]] = llvm.extractvalue %[[B]][1] : !llvm<"[2 x <4 x float>]"> 703 // CHECK: %[[b12:.*]] = llvm.extractvalue %[[B]][1] : !llvm<"[2 x <4 x float>]"> 704 // CHECK: %[[B1:.*]] = "llvm.intr.fmuladd"(%[[b10]], %[[b11]], %[[b12]]) : 705 // CHECK-SAME: (!llvm<"<4 x float>">, !llvm<"<4 x float>">, !llvm<"<4 x float>">) -> !llvm<"<4 x float>"> 706 // CHECK: llvm.insertvalue %[[B1]], {{.*}}[1] : !llvm<"[2 x <4 x float>]"> 707 %1 = vector.fma %b, %b, %b : vector<2x4xf32> 708 709 return %0, %1: vector<8xf32>, vector<2x4xf32> 710} 711 712func @reduce_f32(%arg0: vector<16xf32>) -> f32 { 713 %0 = vector.reduction "add", %arg0 : vector<16xf32> into f32 714 return %0 : f32 715} 716// CHECK-LABEL: llvm.func @reduce_f32( 717// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x float>">) 718// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float 719// CHECK: %[[V:.*]] = "llvm.intr.experimental.vector.reduce.v2.fadd"(%[[C]], %[[A]]) 720// CHECK-SAME: {reassoc = false} : (!llvm.float, !llvm<"<16 x float>">) -> !llvm.float 721// CHECK: llvm.return %[[V]] : !llvm.float 722 723func @reduce_f64(%arg0: vector<16xf64>) -> f64 { 724 %0 = vector.reduction "add", %arg0 : vector<16xf64> into f64 725 return %0 : f64 726} 727// CHECK-LABEL: llvm.func @reduce_f64( 728// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x double>">) 729// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : !llvm.double 730// CHECK: %[[V:.*]] = "llvm.intr.experimental.vector.reduce.v2.fadd"(%[[C]], %[[A]]) 731// CHECK-SAME: {reassoc = false} : (!llvm.double, !llvm<"<16 x double>">) -> !llvm.double 732// CHECK: llvm.return %[[V]] : !llvm.double 733 734func @reduce_i32(%arg0: vector<16xi32>) -> i32 { 735 %0 = vector.reduction "add", %arg0 : vector<16xi32> into i32 736 return %0 : i32 737} 738// CHECK-LABEL: llvm.func @reduce_i32( 739// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x i32>">) 740// CHECK: %[[V:.*]] = "llvm.intr.experimental.vector.reduce.add"(%[[A]]) 741// CHECK: llvm.return %[[V]] : !llvm.i32 742 743func @reduce_i64(%arg0: vector<16xi64>) -> i64 { 744 %0 = vector.reduction "add", %arg0 : vector<16xi64> into i64 745 return %0 : i64 746} 747// CHECK-LABEL: llvm.func @reduce_i64( 748// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x i64>">) 749// CHECK: %[[V:.*]] = "llvm.intr.experimental.vector.reduce.add"(%[[A]]) 750// CHECK: llvm.return %[[V]] : !llvm.i64 751 752 753// 4x16 16x3 4x3 754func @matrix_ops(%A: vector<64xf64>, %B: vector<48xf64>) -> vector<12xf64> { 755 %C = vector.matrix_multiply %A, %B 756 { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } : 757 (vector<64xf64>, vector<48xf64>) -> vector<12xf64> 758 return %C: vector<12xf64> 759} 760// CHECK-LABEL: llvm.func @matrix_ops 761// CHECK: llvm.intr.matrix.multiply %{{.*}}, %{{.*}} { 762// CHECK-SAME: lhs_columns = 16 : i32, lhs_rows = 4 : i32, rhs_columns = 3 : i32 763// CHECK-SAME: } : (!llvm<"<64 x double>">, !llvm<"<48 x double>">) -> !llvm<"<12 x double>"> 764 765func @transfer_read_1d(%A : memref<?xf32>, %base: index) -> vector<17xf32> { 766 %f7 = constant 7.0: f32 767 %f = vector.transfer_read %A[%base], %f7 768 {permutation_map = affine_map<(d0) -> (d0)>} : 769 memref<?xf32>, vector<17xf32> 770 vector.transfer_write %f, %A[%base] 771 {permutation_map = affine_map<(d0) -> (d0)>} : 772 vector<17xf32>, memref<?xf32> 773 return %f: vector<17xf32> 774} 775// CHECK-LABEL: func @transfer_read_1d 776// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm<"<17 x float>"> 777// 778// 1. Bitcast to vector form. 779// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : 780// CHECK-SAME: (!llvm<"float*">, !llvm.i64) -> !llvm<"float*"> 781// CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] : 782// CHECK-SAME: !llvm<"float*"> to !llvm<"<17 x float>*"> 783// 784// 2. Create a vector with linear indices [ 0 .. vector_length - 1 ]. 785// CHECK: %[[linearIndex:.*]] = llvm.mlir.constant( 786// CHECK-SAME: dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> : 787// CHECK-SAME: vector<17xi64>) : !llvm<"<17 x i64>"> 788// 789// 3. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ]. 790// CHECK: %[[offsetVec:.*]] = llvm.mlir.undef : !llvm<"<17 x i64>"> 791// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 792// CHECK: %[[offsetVec2:.*]] = llvm.insertelement %[[BASE]], %[[offsetVec]][%[[c0]] : 793// CHECK-SAME: !llvm.i32] : !llvm<"<17 x i64>"> 794// CHECK: %[[offsetVec3:.*]] = llvm.shufflevector %[[offsetVec2]], %{{.*}} [ 795// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 796// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 797// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] : 798// CHECK-SAME: !llvm<"<17 x i64>">, !llvm<"<17 x i64>"> 799// CHECK: %[[offsetVec4:.*]] = llvm.add %[[offsetVec3]], %[[linearIndex]] : 800// CHECK-SAME: !llvm<"<17 x i64>"> 801// 802// 4. Let dim the memref dimension, compute the vector comparison mask: 803// [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ] 804// CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 0] : 805// CHECK-SAME: !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }"> 806// CHECK: %[[dimVec:.*]] = llvm.mlir.undef : !llvm<"<17 x i64>"> 807// CHECK: %[[c01:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 808// CHECK: %[[dimVec2:.*]] = llvm.insertelement %[[DIM]], %[[dimVec]][%[[c01]] : 809// CHECK-SAME: !llvm.i32] : !llvm<"<17 x i64>"> 810// CHECK: %[[dimVec3:.*]] = llvm.shufflevector %[[dimVec2]], %{{.*}} [ 811// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 812// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 813// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] : 814// CHECK-SAME: !llvm<"<17 x i64>">, !llvm<"<17 x i64>"> 815// CHECK: %[[mask:.*]] = llvm.icmp "slt" %[[offsetVec4]], %[[dimVec3]] : 816// CHECK-SAME: !llvm<"<17 x i64>"> 817// 818// 5. Rewrite as a masked read. 819// CHECK: %[[PASS_THROUGH:.*]] = llvm.mlir.constant(dense<7.000000e+00> : 820// CHECK-SAME: vector<17xf32>) : !llvm<"<17 x float>"> 821// CHECK: %[[loaded:.*]] = llvm.intr.masked.load %[[vecPtr]], %[[mask]], 822// CHECK-SAME: %[[PASS_THROUGH]] {alignment = 4 : i32} : 823// CHECK-SAME: (!llvm<"<17 x float>*">, !llvm<"<17 x i1>">, !llvm<"<17 x float>">) -> !llvm<"<17 x float>"> 824 825// 826// 1. Bitcast to vector form. 827// CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} : 828// CHECK-SAME: (!llvm<"float*">, !llvm.i64) -> !llvm<"float*"> 829// CHECK: %[[vecPtr_b:.*]] = llvm.bitcast %[[gep_b]] : 830// CHECK-SAME: !llvm<"float*"> to !llvm<"<17 x float>*"> 831// 832// 2. Create a vector with linear indices [ 0 .. vector_length - 1 ]. 833// CHECK: %[[linearIndex_b:.*]] = llvm.mlir.constant( 834// CHECK-SAME: dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> : 835// CHECK-SAME: vector<17xi64>) : !llvm<"<17 x i64>"> 836// 837// 3. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ]. 838// CHECK: llvm.shufflevector {{.*}} [0 : i32, 0 : i32, 0 : i32, 0 : i32, 839// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 840// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32] : 841// CHECK-SAME: !llvm<"<17 x i64>">, !llvm<"<17 x i64>"> 842// CHECK: llvm.add 843// 844// 4. Let dim the memref dimension, compute the vector comparison mask: 845// [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ] 846// CHECK: llvm.shufflevector {{.*}} [0 : i32, 0 : i32, 0 : i32, 0 : i32, 847// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 848// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32] : 849// CHECK-SAME: !llvm<"<17 x i64>">, !llvm<"<17 x i64>"> 850// CHECK: %[[mask_b:.*]] = llvm.icmp "slt" {{.*}} : !llvm<"<17 x i64>"> 851// 852// 5. Rewrite as a masked write. 853// CHECK: llvm.intr.masked.store %[[loaded]], %[[vecPtr_b]], %[[mask_b]] 854// CHECK-SAME: {alignment = 4 : i32} : 855// CHECK-SAME: !llvm<"<17 x float>">, !llvm<"<17 x i1>"> into !llvm<"<17 x float>*"> 856 857func @transfer_read_2d_to_1d(%A : memref<?x?xf32>, %base0: index, %base1: index) -> vector<17xf32> { 858 %f7 = constant 7.0: f32 859 %f = vector.transfer_read %A[%base0, %base1], %f7 860 {permutation_map = affine_map<(d0, d1) -> (d1)>} : 861 memref<?x?xf32>, vector<17xf32> 862 return %f: vector<17xf32> 863} 864// CHECK-LABEL: func @transfer_read_2d_to_1d 865// CHECK-SAME: %[[BASE_0:[a-zA-Z0-9]*]]: !llvm.i64, %[[BASE_1:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm<"<17 x float>"> 866// 867// Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ]. 868// CHECK: %[[offsetVec:.*]] = llvm.mlir.undef : !llvm<"<17 x i64>"> 869// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 870// Here we check we properly use %BASE_1 871// CHECK: %[[offsetVec2:.*]] = llvm.insertelement %[[BASE_1]], %[[offsetVec]][%[[c0]] : 872// CHECK-SAME: !llvm.i32] : !llvm<"<17 x i64>"> 873// CHECK: %[[offsetVec3:.*]] = llvm.shufflevector %[[offsetVec2]], %{{.*}} [ 874// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 875// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 876// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] : 877// 878// Let dim the memref dimension, compute the vector comparison mask: 879// [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ] 880// Here we check we properly use %DIM[1] 881// CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 1] : 882// CHECK-SAME: !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }"> 883// CHECK: %[[dimVec:.*]] = llvm.mlir.undef : !llvm<"<17 x i64>"> 884// CHECK: %[[c01:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 885// CHECK: %[[dimVec2:.*]] = llvm.insertelement %[[DIM]], %[[dimVec]][%[[c01]] : 886// CHECK-SAME: !llvm.i32] : !llvm<"<17 x i64>"> 887// CHECK: %[[dimVec3:.*]] = llvm.shufflevector %[[dimVec2]], %{{.*}} [ 888// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 889// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 890// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] : 891// CHECK-SAME: !llvm<"<17 x i64>">, !llvm<"<17 x i64>"> 892 893func @transfer_read_1d_non_zero_addrspace(%A : memref<?xf32, 3>, %base: index) -> vector<17xf32> { 894 %f7 = constant 7.0: f32 895 %f = vector.transfer_read %A[%base], %f7 896 {permutation_map = affine_map<(d0) -> (d0)>} : 897 memref<?xf32, 3>, vector<17xf32> 898 vector.transfer_write %f, %A[%base] 899 {permutation_map = affine_map<(d0) -> (d0)>} : 900 vector<17xf32>, memref<?xf32, 3> 901 return %f: vector<17xf32> 902} 903// CHECK-LABEL: func @transfer_read_1d_non_zero_addrspace 904// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm<"<17 x float>"> 905// 906// 1. Check address space for GEP is correct. 907// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : 908// CHECK-SAME: (!llvm<"float addrspace(3)*">, !llvm.i64) -> !llvm<"float addrspace(3)*"> 909// CHECK: %[[vecPtr:.*]] = llvm.addrspacecast %[[gep]] : 910// CHECK-SAME: !llvm<"float addrspace(3)*"> to !llvm<"<17 x float>*"> 911// 912// 2. Check address space of the memref is correct. 913// CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 0] : 914// CHECK-SAME: !llvm<"{ float addrspace(3)*, float addrspace(3)*, i64, [1 x i64], [1 x i64] }"> 915// 916// 3. Check address apce for GEP is correct. 917// CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} : 918// CHECK-SAME: (!llvm<"float addrspace(3)*">, !llvm.i64) -> !llvm<"float addrspace(3)*"> 919// CHECK: %[[vecPtr_b:.*]] = llvm.addrspacecast %[[gep_b]] : 920// CHECK-SAME: !llvm<"float addrspace(3)*"> to !llvm<"<17 x float>*"> 921 922func @transfer_read_1d_not_masked(%A : memref<?xf32>, %base: index) -> vector<17xf32> { 923 %f7 = constant 7.0: f32 924 %f = vector.transfer_read %A[%base], %f7 {masked = [false]} : 925 memref<?xf32>, vector<17xf32> 926 return %f: vector<17xf32> 927} 928// CHECK-LABEL: func @transfer_read_1d_not_masked 929// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm<"<17 x float>"> 930// 931// 1. Bitcast to vector form. 932// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : 933// CHECK-SAME: (!llvm<"float*">, !llvm.i64) -> !llvm<"float*"> 934// CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] : 935// CHECK-SAME: !llvm<"float*"> to !llvm<"<17 x float>*"> 936// 937// 2. Rewrite as a load. 938// CHECK: %[[loaded:.*]] = llvm.load %[[vecPtr]] {alignment = 4 : i64} : !llvm<"<17 x float>*"> 939 940func @genbool_1d() -> vector<8xi1> { 941 %0 = vector.constant_mask [4] : vector<8xi1> 942 return %0 : vector<8xi1> 943} 944// CHECK-LABEL: func @genbool_1d 945// CHECK: %[[C1:.*]] = llvm.mlir.constant(dense<[true, true, true, true, false, false, false, false]> : vector<8xi1>) : !llvm<"<8 x i1>"> 946// CHECK: llvm.return %[[C1]] : !llvm<"<8 x i1>"> 947 948func @genbool_2d() -> vector<4x4xi1> { 949 %v = vector.constant_mask [2, 2] : vector<4x4xi1> 950 return %v: vector<4x4xi1> 951} 952 953// CHECK-LABEL: func @genbool_2d 954// CHECK: %[[C1:.*]] = llvm.mlir.constant(dense<[true, true, false, false]> : vector<4xi1>) : !llvm<"<4 x i1>"> 955// CHECK: %[[C2:.*]] = llvm.mlir.constant(dense<false> : vector<4x4xi1>) : !llvm<"[4 x <4 x i1>]"> 956// CHECK: %[[T0:.*]] = llvm.insertvalue %[[C1]], %[[C2]][0] : !llvm<"[4 x <4 x i1>]"> 957// CHECK: %[[T1:.*]] = llvm.insertvalue %[[C1]], %[[T0]][1] : !llvm<"[4 x <4 x i1>]"> 958// CHECK: llvm.return %[[T1]] : !llvm<"[4 x <4 x i1>]"> 959 960func @flat_transpose(%arg0: vector<16xf32>) -> vector<16xf32> { 961 %0 = vector.flat_transpose %arg0 { rows = 4: i32, columns = 4: i32 } 962 : vector<16xf32> -> vector<16xf32> 963 return %0 : vector<16xf32> 964} 965 966// CHECK-LABEL: func @flat_transpose 967// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x float>"> 968// CHECK: %[[T:.*]] = llvm.intr.matrix.transpose %[[A]] 969// CHECK-SAME: {columns = 4 : i32, rows = 4 : i32} : 970// CHECK-SAME: !llvm<"<16 x float>"> into !llvm<"<16 x float>"> 971// CHECK: llvm.return %[[T]] : !llvm<"<16 x float>"> 972