1// RUN: mlir-opt %s -convert-vector-to-llvm -split-input-file | FileCheck %s 2 3 4func @bitcast_f32_to_i32_vector(%input: vector<16xf32>) -> vector<16xi32> { 5 %0 = vector.bitcast %input : vector<16xf32> to vector<16xi32> 6 return %0 : vector<16xi32> 7} 8 9// CHECK-LABEL: @bitcast_f32_to_i32_vector 10// CHECK-SAME: %[[input:.*]]: vector<16xf32> 11// CHECK: llvm.bitcast %[[input]] : vector<16xf32> to vector<16xi32> 12 13// ----- 14 15func @bitcast_i8_to_f32_vector(%input: vector<64xi8>) -> vector<16xf32> { 16 %0 = vector.bitcast %input : vector<64xi8> to vector<16xf32> 17 return %0 : vector<16xf32> 18} 19 20// CHECK-LABEL: @bitcast_i8_to_f32_vector 21// CHECK-SAME: %[[input:.*]]: vector<64xi8> 22// CHECK: llvm.bitcast %[[input]] : vector<64xi8> to vector<16xf32> 23 24// ----- 25 26func @bitcast_index_to_i8_vector(%input: vector<16xindex>) -> vector<128xi8> { 27 %0 = vector.bitcast %input : vector<16xindex> to vector<128xi8> 28 return %0 : vector<128xi8> 29} 30 31// CHECK-LABEL: @bitcast_index_to_i8_vector 32// CHECK-SAME: %[[input:.*]]: vector<16xindex> 33// CHECK: %[[T0:.*]] = llvm.mlir.cast %[[input]] : vector<16xindex> to vector<16xi64> 34// CHECK: llvm.bitcast %[[T0]] : vector<16xi64> to vector<128xi8> 35 36// ----- 37 38func @broadcast_vec1d_from_f32(%arg0: f32) -> vector<2xf32> { 39 %0 = vector.broadcast %arg0 : f32 to vector<2xf32> 40 return %0 : vector<2xf32> 41} 42// CHECK-LABEL: @broadcast_vec1d_from_f32 43// CHECK-SAME: %[[A:.*]]: f32) 44// CHECK: %[[T0:.*]] = splat %[[A]] : vector<2xf32> 45// CHECK: return %[[T0]] : vector<2xf32> 46 47// ----- 48 49func @broadcast_vec1d_from_index(%arg0: index) -> vector<2xindex> { 50 %0 = vector.broadcast %arg0 : index to vector<2xindex> 51 return %0 : vector<2xindex> 52} 53// CHECK-LABEL: @broadcast_vec1d_from_index 54// CHECK-SAME: %[[A:.*]]: index) 55// CHECK: %[[T0:.*]] = splat %[[A]] : vector<2xindex> 56// CHECK: return %[[T0]] : vector<2xindex> 57 58// ----- 59 60func @broadcast_vec2d_from_scalar(%arg0: f32) -> vector<2x3xf32> { 61 %0 = vector.broadcast %arg0 : f32 to vector<2x3xf32> 62 return %0 : vector<2x3xf32> 63} 64// CHECK-LABEL: @broadcast_vec2d_from_scalar( 65// CHECK-SAME: %[[A:.*]]: f32) 66// CHECK: %[[T0:.*]] = splat %[[A]] : vector<2x3xf32> 67// CHECK: return %[[T0]] : vector<2x3xf32> 68 69// ----- 70 71func @broadcast_vec3d_from_scalar(%arg0: f32) -> vector<2x3x4xf32> { 72 %0 = vector.broadcast %arg0 : f32 to vector<2x3x4xf32> 73 return %0 : vector<2x3x4xf32> 74} 75// CHECK-LABEL: @broadcast_vec3d_from_scalar( 76// CHECK-SAME: %[[A:.*]]: f32) 77// CHECK: %[[T0:.*]] = splat %[[A]] : vector<2x3x4xf32> 78// CHECK: return %[[T0]] : vector<2x3x4xf32> 79 80// ----- 81 82func @broadcast_vec1d_from_vec1d(%arg0: vector<2xf32>) -> vector<2xf32> { 83 %0 = vector.broadcast %arg0 : vector<2xf32> to vector<2xf32> 84 return %0 : vector<2xf32> 85} 86// CHECK-LABEL: @broadcast_vec1d_from_vec1d( 87// CHECK-SAME: %[[A:.*]]: vector<2xf32>) 88// CHECK: return %[[A]] : vector<2xf32> 89 90// ----- 91 92func @broadcast_vec2d_from_vec1d(%arg0: vector<2xf32>) -> vector<3x2xf32> { 93 %0 = vector.broadcast %arg0 : vector<2xf32> to vector<3x2xf32> 94 return %0 : vector<3x2xf32> 95} 96// CHECK-LABEL: @broadcast_vec2d_from_vec1d( 97// CHECK-SAME: %[[A:.*]]: vector<2xf32>) 98// CHECK: %[[T0:.*]] = constant dense<0.000000e+00> : vector<3x2xf32> 99// CHECK: %[[T1:.*]] = llvm.mlir.cast %[[T0]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> 100// CHECK: %[[T2:.*]] = llvm.insertvalue %[[A]], %[[T1]][0] : !llvm.array<3 x vector<2xf32>> 101// CHECK: %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][1] : !llvm.array<3 x vector<2xf32>> 102// CHECK: %[[T4:.*]] = llvm.insertvalue %[[A]], %[[T3]][2] : !llvm.array<3 x vector<2xf32>> 103// CHECK: %[[T5:.*]] = llvm.mlir.cast %[[T4]] : !llvm.array<3 x vector<2xf32>> to vector<3x2xf32> 104// CHECK: return %[[T5]] : vector<3x2xf32> 105 106// ----- 107 108func @broadcast_vec2d_from_index_vec1d(%arg0: vector<2xindex>) -> vector<3x2xindex> { 109 %0 = vector.broadcast %arg0 : vector<2xindex> to vector<3x2xindex> 110 return %0 : vector<3x2xindex> 111} 112// CHECK-LABEL: @broadcast_vec2d_from_index_vec1d( 113// CHECK-SAME: %[[A:.*]]: vector<2xindex>) 114// CHECK: %[[T0:.*]] = constant dense<0> : vector<3x2xindex> 115// CHECK: %[[T1:.*]] = llvm.mlir.cast %[[A]] : vector<2xindex> to vector<2xi64> 116// CHECK: %[[T2:.*]] = llvm.mlir.cast %[[T0]] : vector<3x2xindex> to !llvm.array<3 x vector<2xi64>> 117// CHECK: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][0] : !llvm.array<3 x vector<2xi64>> 118 119// CHECK: %[[T4:.*]] = llvm.mlir.cast %{{.*}} : !llvm.array<3 x vector<2xi64>> to vector<3x2xindex> 120// CHECK: return %[[T4]] : vector<3x2xindex> 121 122// ----- 123 124func @broadcast_vec3d_from_vec1d(%arg0: vector<2xf32>) -> vector<4x3x2xf32> { 125 %0 = vector.broadcast %arg0 : vector<2xf32> to vector<4x3x2xf32> 126 return %0 : vector<4x3x2xf32> 127} 128// CHECK-LABEL: @broadcast_vec3d_from_vec1d( 129// CHECK-SAME: %[[A:.*]]: vector<2xf32>) 130// CHECK: %[[T0:.*]] = constant dense<0.000000e+00> : vector<3x2xf32> 131// CHECK: %[[T1:.*]] = constant dense<0.000000e+00> : vector<4x3x2xf32> 132 133// CHECK: %[[T2:.*]] = llvm.mlir.cast %[[T0]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> 134// CHECK: %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][0] : !llvm.array<3 x vector<2xf32>> 135// CHECK: %[[T4:.*]] = llvm.insertvalue %[[A]], %[[T3]][1] : !llvm.array<3 x vector<2xf32>> 136// CHECK: %[[T5:.*]] = llvm.insertvalue %[[A]], %[[T4]][2] : !llvm.array<3 x vector<2xf32>> 137 138// CHECK: %[[T6:.*]] = llvm.mlir.cast %[[T1]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>> 139// CHECK: %[[T7:.*]] = llvm.insertvalue %[[T5]], %[[T6]][0] : !llvm.array<4 x array<3 x vector<2xf32>>> 140// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T5]], %[[T7]][1] : !llvm.array<4 x array<3 x vector<2xf32>>> 141// CHECK: %[[T9:.*]] = llvm.insertvalue %[[T5]], %[[T8]][2] : !llvm.array<4 x array<3 x vector<2xf32>>> 142// CHECK: %[[T10:.*]] = llvm.insertvalue %[[T5]], %[[T9]][3] : !llvm.array<4 x array<3 x vector<2xf32>>> 143 144// CHECK: %[[T11:.*]] = llvm.mlir.cast %[[T10]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> 145// CHECK: return %[[T11]] : vector<4x3x2xf32> 146 147// ----- 148 149func @broadcast_vec3d_from_vec2d(%arg0: vector<3x2xf32>) -> vector<4x3x2xf32> { 150 %0 = vector.broadcast %arg0 : vector<3x2xf32> to vector<4x3x2xf32> 151 return %0 : vector<4x3x2xf32> 152} 153// CHECK-LABEL: @broadcast_vec3d_from_vec2d( 154// CHECK-SAME: %[[A:.*]]: vector<3x2xf32>) 155// CHECK: %[[T0:.*]] = constant dense<0.000000e+00> : vector<4x3x2xf32> 156// CHECK: %[[T1:.*]] = llvm.mlir.cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> 157// CHECK: %[[T2:.*]] = llvm.mlir.cast %[[T0]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>> 158// CHECK: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][0] : !llvm.array<4 x array<3 x vector<2xf32>>> 159// CHECK: %[[T4:.*]] = llvm.mlir.cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> 160// CHECK: %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T3]][1] : !llvm.array<4 x array<3 x vector<2xf32>>> 161// CHECK: %[[T6:.*]] = llvm.mlir.cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> 162// CHECK: %[[T7:.*]] = llvm.insertvalue %[[T6]], %[[T5]][2] : !llvm.array<4 x array<3 x vector<2xf32>>> 163// CHECK: %[[T8:.*]] = llvm.mlir.cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> 164// CHECK: %[[T9:.*]] = llvm.insertvalue %[[T8]], %[[T7]][3] : !llvm.array<4 x array<3 x vector<2xf32>>> 165// CHECK: %[[T10:.*]] = llvm.mlir.cast %[[T9]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> 166// CHECK: return %[[T10]] : vector<4x3x2xf32> 167 168 169// ----- 170 171func @broadcast_stretch(%arg0: vector<1xf32>) -> vector<4xf32> { 172 %0 = vector.broadcast %arg0 : vector<1xf32> to vector<4xf32> 173 return %0 : vector<4xf32> 174} 175// CHECK-LABEL: @broadcast_stretch( 176// CHECK-SAME: %[[A:.*]]: vector<1xf32>) 177// CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i64) : i64 178// CHECK: %[[T2:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T1]] : i64] : vector<1xf32> 179// CHECK: %[[T3:.*]] = splat %[[T2]] : vector<4xf32> 180// CHECK: return %[[T3]] : vector<4xf32> 181 182// ----- 183 184func @broadcast_stretch_at_start(%arg0: vector<1x4xf32>) -> vector<3x4xf32> { 185 %0 = vector.broadcast %arg0 : vector<1x4xf32> to vector<3x4xf32> 186 return %0 : vector<3x4xf32> 187} 188// CHECK-LABEL: @broadcast_stretch_at_start( 189// CHECK-SAME: %[[A:.*]]: vector<1x4xf32>) 190// CHECK: %[[T1:.*]] = constant dense<0.000000e+00> : vector<3x4xf32> 191// CHECK: %[[T2:.*]] = llvm.mlir.cast %[[A]] : vector<1x4xf32> to !llvm.array<1 x vector<4xf32>> 192// CHECK: %[[T3:.*]] = llvm.extractvalue %[[T2]][0] : !llvm.array<1 x vector<4xf32>> 193// CHECK: %[[T4:.*]] = llvm.mlir.cast %[[T1]] : vector<3x4xf32> to !llvm.array<3 x vector<4xf32>> 194// CHECK: %[[T5:.*]] = llvm.insertvalue %[[T3]], %[[T4]][0] : !llvm.array<3 x vector<4xf32>> 195// CHECK: %[[T6:.*]] = llvm.insertvalue %[[T3]], %[[T5]][1] : !llvm.array<3 x vector<4xf32>> 196// CHECK: %[[T7:.*]] = llvm.insertvalue %[[T3]], %[[T6]][2] : !llvm.array<3 x vector<4xf32>> 197// CHECK: %[[T8:.*]] = llvm.mlir.cast %[[T7]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32> 198// CHECK: return %[[T8]] : vector<3x4xf32> 199 200// ----- 201 202func @broadcast_stretch_at_end(%arg0: vector<4x1xf32>) -> vector<4x3xf32> { 203 %0 = vector.broadcast %arg0 : vector<4x1xf32> to vector<4x3xf32> 204 return %0 : vector<4x3xf32> 205} 206// CHECK-LABEL: @broadcast_stretch_at_end( 207// CHECK-SAME: %[[A:.*]]: vector<4x1xf32>) 208// CHECK: %[[T1:.*]] = constant dense<0.000000e+00> : vector<4x3xf32> 209// CHECK: %[[T2:.*]] = llvm.mlir.cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> 210// CHECK: %[[T3:.*]] = llvm.extractvalue %[[T2]][0] : !llvm.array<4 x vector<1xf32>> 211// CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i64) : i64 212// CHECK: %[[T5:.*]] = llvm.extractelement %[[T3]]{{\[}}%[[T4]] : i64] : vector<1xf32> 213// CHECK: %[[T6:.*]] = splat %[[T5]] : vector<3xf32> 214// CHECK: %[[T7:.*]] = llvm.mlir.cast %[[T1]] : vector<4x3xf32> to !llvm.array<4 x vector<3xf32>> 215// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T6]], %[[T7]][0] : !llvm.array<4 x vector<3xf32>> 216// CHECK: %[[T9:.*]] = llvm.mlir.cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> 217// CHECK: %[[T10:.*]] = llvm.extractvalue %[[T9]][1] : !llvm.array<4 x vector<1xf32>> 218// CHECK: %[[T11:.*]] = llvm.mlir.constant(0 : i64) : i64 219// CHECK: %[[T12:.*]] = llvm.extractelement %[[T10]]{{\[}}%[[T11]] : i64] : vector<1xf32> 220// CHECK: %[[T13:.*]] = splat %[[T12]] : vector<3xf32> 221// CHECK: %[[T14:.*]] = llvm.insertvalue %[[T13]], %[[T8]][1] : !llvm.array<4 x vector<3xf32>> 222// CHECK: %[[T15:.*]] = llvm.mlir.cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> 223// CHECK: %[[T16:.*]] = llvm.extractvalue %[[T15]][2] : !llvm.array<4 x vector<1xf32>> 224// CHECK: %[[T17:.*]] = llvm.mlir.constant(0 : i64) : i64 225// CHECK: %[[T18:.*]] = llvm.extractelement %[[T16]]{{\[}}%[[T17]] : i64] : vector<1xf32> 226// CHECK: %[[T19:.*]] = splat %[[T18]] : vector<3xf32> 227// CHECK: %[[T20:.*]] = llvm.insertvalue %[[T19]], %[[T14]][2] : !llvm.array<4 x vector<3xf32>> 228// CHECK: %[[T21:.*]] = llvm.mlir.cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>> 229// CHECK: %[[T22:.*]] = llvm.extractvalue %[[T21]][3] : !llvm.array<4 x vector<1xf32>> 230// CHECK: %[[T23:.*]] = llvm.mlir.constant(0 : i64) : i64 231// CHECK: %[[T24:.*]] = llvm.extractelement %[[T22]]{{\[}}%[[T23]] : i64] : vector<1xf32> 232// CHECK: %[[T25:.*]] = splat %[[T24]] : vector<3xf32> 233// CHECK: %[[T26:.*]] = llvm.insertvalue %[[T25]], %[[T20]][3] : !llvm.array<4 x vector<3xf32>> 234// CHECK: %[[T27:.*]] = llvm.mlir.cast %[[T26]] : !llvm.array<4 x vector<3xf32>> to vector<4x3xf32> 235// CHECK: return %[[T27]] : vector<4x3xf32> 236 237// ----- 238 239func @broadcast_stretch_in_middle(%arg0: vector<4x1x2xf32>) -> vector<4x3x2xf32> { 240 %0 = vector.broadcast %arg0 : vector<4x1x2xf32> to vector<4x3x2xf32> 241 return %0 : vector<4x3x2xf32> 242} 243// CHECK-LABEL: @broadcast_stretch_in_middle( 244// CHECK-SAME: %[[A:.*]]: vector<4x1x2xf32>) -> vector<4x3x2xf32> { 245// CHECK: %[[T1:.*]] = constant dense<0.000000e+00> : vector<4x3x2xf32> 246// CHECK: %[[T2:.*]] = constant dense<0.000000e+00> : vector<3x2xf32> 247// CHECK: %[[T3:.*]] = llvm.mlir.cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> 248// CHECK: %[[T4:.*]] = llvm.extractvalue %[[T3]][0, 0] : !llvm.array<4 x array<1 x vector<2xf32>>> 249// CHECK: %[[T5:.*]] = llvm.mlir.cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> 250// CHECK: %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][0] : !llvm.array<3 x vector<2xf32>> 251// CHECK: %[[T7:.*]] = llvm.insertvalue %[[T4]], %[[T6]][1] : !llvm.array<3 x vector<2xf32>> 252// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T4]], %[[T7]][2] : !llvm.array<3 x vector<2xf32>> 253// CHECK: %[[T9:.*]] = llvm.mlir.cast %[[T1]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>> 254// CHECK: %[[T10:.*]] = llvm.insertvalue %[[T8]], %[[T9]][0] : !llvm.array<4 x array<3 x vector<2xf32>>> 255// CHECK: %[[T11:.*]] = llvm.mlir.cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> 256// CHECK: %[[T12:.*]] = llvm.extractvalue %[[T11]][1, 0] : !llvm.array<4 x array<1 x vector<2xf32>>> 257// CHECK: %[[T13:.*]] = llvm.mlir.cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> 258// CHECK: %[[T14:.*]] = llvm.insertvalue %[[T12]], %[[T13]][0] : !llvm.array<3 x vector<2xf32>> 259// CHECK: %[[T15:.*]] = llvm.insertvalue %[[T12]], %[[T14]][1] : !llvm.array<3 x vector<2xf32>> 260// CHECK: %[[T16:.*]] = llvm.insertvalue %[[T12]], %[[T15]][2] : !llvm.array<3 x vector<2xf32>> 261// CHECK: %[[T17:.*]] = llvm.insertvalue %[[T16]], %[[T10]][1] : !llvm.array<4 x array<3 x vector<2xf32>>> 262// CHECK: %[[T18:.*]] = llvm.mlir.cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> 263// CHECK: %[[T19:.*]] = llvm.extractvalue %[[T18]][2, 0] : !llvm.array<4 x array<1 x vector<2xf32>>> 264// CHECK: %[[T20:.*]] = llvm.mlir.cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> 265// CHECK: %[[T21:.*]] = llvm.insertvalue %[[T19]], %[[T20]][0] : !llvm.array<3 x vector<2xf32>> 266// CHECK: %[[T22:.*]] = llvm.insertvalue %[[T19]], %[[T21]][1] : !llvm.array<3 x vector<2xf32>> 267// CHECK: %[[T23:.*]] = llvm.insertvalue %[[T19]], %[[T22]][2] : !llvm.array<3 x vector<2xf32>> 268// CHECK: %[[T24:.*]] = llvm.insertvalue %[[T23]], %[[T17]][2] : !llvm.array<4 x array<3 x vector<2xf32>>> 269// CHECK: %[[T25:.*]] = llvm.mlir.cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>> 270// CHECK: %[[T26:.*]] = llvm.extractvalue %[[T25]][3, 0] : !llvm.array<4 x array<1 x vector<2xf32>>> 271// CHECK: %[[T27:.*]] = llvm.mlir.cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>> 272// CHECK: %[[T28:.*]] = llvm.insertvalue %[[T26]], %[[T27]][0] : !llvm.array<3 x vector<2xf32>> 273// CHECK: %[[T29:.*]] = llvm.insertvalue %[[T26]], %[[T28]][1] : !llvm.array<3 x vector<2xf32>> 274// CHECK: %[[T30:.*]] = llvm.insertvalue %[[T26]], %[[T29]][2] : !llvm.array<3 x vector<2xf32>> 275// CHECK: %[[T31:.*]] = llvm.insertvalue %[[T30]], %[[T24]][3] : !llvm.array<4 x array<3 x vector<2xf32>>> 276// CHECK: %[[T32:.*]] = llvm.mlir.cast %[[T31]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32> 277// CHECK: return %[[T32]] : vector<4x3x2xf32> 278 279// ----- 280 281func @outerproduct(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<2x3xf32> { 282 %2 = vector.outerproduct %arg0, %arg1 : vector<2xf32>, vector<3xf32> 283 return %2 : vector<2x3xf32> 284} 285// CHECK-LABEL: @outerproduct( 286// CHECK-SAME: %[[A:.*]]: vector<2xf32>, 287// CHECK-SAME: %[[B:.*]]: vector<3xf32>) 288// CHECK: %[[T2:.*]] = constant dense<0.000000e+00> : vector<2x3xf32> 289// CHECK: %[[T3:.*]] = llvm.mlir.constant(0 : i64) : i64 290// CHECK: %[[T4:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T3]] : i64] : vector<2xf32> 291// CHECK: %[[T5:.*]] = splat %[[T4]] : vector<3xf32> 292// CHECK: %[[T6:.*]] = mulf %[[T5]], %[[B]] : vector<3xf32> 293// CHECK: %[[T7:.*]] = llvm.mlir.cast %[[T2]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> 294// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T6]], %[[T7]][0] : !llvm.array<2 x vector<3xf32>> 295// CHECK: %[[T9:.*]] = llvm.mlir.constant(1 : i64) : i64 296// CHECK: %[[T10:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T9]] : i64] : vector<2xf32> 297// CHECK: %[[T11:.*]] = splat %[[T10]] : vector<3xf32> 298// CHECK: %[[T12:.*]] = mulf %[[T11]], %[[B]] : vector<3xf32> 299// CHECK: %[[T13:.*]] = llvm.insertvalue %[[T12]], %[[T8]][1] : !llvm.array<2 x vector<3xf32>> 300// CHECK: %[[T14:.*]] = llvm.mlir.cast %[[T13]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32> 301// CHECK: return %[[T14]] : vector<2x3xf32> 302 303// ----- 304 305func @outerproduct_index(%arg0: vector<2xindex>, %arg1: vector<3xindex>) -> vector<2x3xindex> { 306 %2 = vector.outerproduct %arg0, %arg1 : vector<2xindex>, vector<3xindex> 307 return %2 : vector<2x3xindex> 308} 309// CHECK-LABEL: @outerproduct_index( 310// CHECK-SAME: %[[A:.*]]: vector<2xindex>, 311// CHECK-SAME: %[[B:.*]]: vector<3xindex>) 312// CHECK: %[[T0:.*]] = constant dense<0> : vector<2x3xindex> 313// CHECK: %[[T1:.*]] = llvm.mlir.cast %[[A]] : vector<2xindex> to vector<2xi64> 314// CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i64) : i64 315// CHECK: %[[T3:.*]] = llvm.extractelement %[[T1]]{{\[}}%[[T2]] : i64] : vector<2xi64> 316// CHECK: %[[T4:.*]] = llvm.mlir.cast %[[T3]] : i64 to index 317// CHECK: %[[T5:.*]] = splat %[[T4]] : vector<3xindex> 318// CHECK: %[[T6:.*]] = muli %[[T5]], %[[B]] : vector<3xindex> 319// CHECK: %[[T7:.*]] = llvm.mlir.cast %[[T6]] : vector<3xindex> to vector<3xi64> 320// CHECK: %[[T8:.*]] = llvm.mlir.cast %[[T0]] : vector<2x3xindex> to !llvm.array<2 x vector<3xi64>> 321// CHECK: %{{.*}} = llvm.insertvalue %[[T7]], %[[T8]][0] : !llvm.array<2 x vector<3xi64>> 322 323// ----- 324 325func @outerproduct_add(%arg0: vector<2xf32>, %arg1: vector<3xf32>, %arg2: vector<2x3xf32>) -> vector<2x3xf32> { 326 %2 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xf32>, vector<3xf32> 327 return %2 : vector<2x3xf32> 328} 329// CHECK-LABEL: @outerproduct_add( 330// CHECK-SAME: %[[A:.*]]: vector<2xf32>, 331// CHECK-SAME: %[[B:.*]]: vector<3xf32>, 332// CHECK-SAME: %[[C:.*]]: vector<2x3xf32>) -> vector<2x3xf32> 333// CHECK: %[[T3:.*]] = constant dense<0.000000e+00> : vector<2x3xf32> 334// CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i64) : i64 335// CHECK: %[[T5:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T4]] : i64] : vector<2xf32> 336// CHECK: %[[T6:.*]] = splat %[[T5]] : vector<3xf32> 337// CHECK: %[[T7:.*]] = llvm.mlir.cast %[[C]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> 338// CHECK: %[[T8:.*]] = llvm.extractvalue %[[T7]][0] : !llvm.array<2 x vector<3xf32>> 339// CHECK: %[[T9:.*]] = "llvm.intr.fmuladd"(%[[T6]], %[[B]], %[[T8]]) : (vector<3xf32>, vector<3xf32>, vector<3xf32>) -> vector<3xf32> 340// CHECK: %[[T10:.*]] = llvm.mlir.cast %[[T3]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> 341// CHECK: %[[T11:.*]] = llvm.insertvalue %[[T9]], %[[T10]][0] : !llvm.array<2 x vector<3xf32>> 342// CHECK: %[[T12:.*]] = llvm.mlir.constant(1 : i64) : i64 343// CHECK: %[[T13:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T12]] : i64] : vector<2xf32> 344// CHECK: %[[T14:.*]] = splat %[[T13]] : vector<3xf32> 345// CHECK: %[[T15:.*]] = llvm.mlir.cast %[[C]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>> 346// CHECK: %[[T16:.*]] = llvm.extractvalue %[[T15]][1] : !llvm.array<2 x vector<3xf32>> 347// CHECK: %[[T17:.*]] = "llvm.intr.fmuladd"(%[[T14]], %[[B]], %[[T16]]) : (vector<3xf32>, vector<3xf32>, vector<3xf32>) -> vector<3xf32> 348// CHECK: %[[T18:.*]] = llvm.insertvalue %[[T17]], %[[T11]][1] : !llvm.array<2 x vector<3xf32>> 349// CHECK: %[[T19:.*]] = llvm.mlir.cast %[[T18]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32> 350// CHECK: return %[[T19]] : vector<2x3xf32> 351 352// ----- 353 354func @shuffle_1D_direct(%arg0: vector<2xf32>, %arg1: vector<2xf32>) -> vector<2xf32> { 355 %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<2xf32> 356 return %1 : vector<2xf32> 357} 358// CHECK-LABEL: @shuffle_1D_direct( 359// CHECK-SAME: %[[A:.*]]: vector<2xf32>, 360// CHECK-SAME: %[[B:.*]]: vector<2xf32>) 361// CHECK: %[[s:.*]] = llvm.shufflevector %[[A]], %[[B]] [0, 1] : vector<2xf32>, vector<2xf32> 362// CHECK: return %[[s]] : vector<2xf32> 363 364// ----- 365 366func @shuffle_1D_index_direct(%arg0: vector<2xindex>, %arg1: vector<2xindex>) -> vector<2xindex> { 367 %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xindex>, vector<2xindex> 368 return %1 : vector<2xindex> 369} 370// CHECK-LABEL: @shuffle_1D_index_direct( 371// CHECK-SAME: %[[A:.*]]: vector<2xindex>, 372// CHECK-SAME: %[[B:.*]]: vector<2xindex>) 373// CHECK: %[[T0:.*]] = llvm.mlir.cast %[[A]] : vector<2xindex> to vector<2xi64> 374// CHECK: %[[T1:.*]] = llvm.mlir.cast %[[B]] : vector<2xindex> to vector<2xi64> 375// CHECK: %[[T2:.*]] = llvm.shufflevector %[[T0]], %[[T1]] [0, 1] : vector<2xi64>, vector<2xi64> 376// CHECK: %[[T3:.*]] = llvm.mlir.cast %[[T2]] : vector<2xi64> to vector<2xindex> 377// CHECK: return %[[T3]] : vector<2xindex> 378 379// ----- 380 381func @shuffle_1D(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<5xf32> { 382 %1 = vector.shuffle %arg0, %arg1 [4, 3, 2, 1, 0] : vector<2xf32>, vector<3xf32> 383 return %1 : vector<5xf32> 384} 385// CHECK-LABEL: @shuffle_1D( 386// CHECK-SAME: %[[A:.*]]: vector<2xf32>, 387// CHECK-SAME: %[[B:.*]]: vector<3xf32>) 388// CHECK: %[[u0:.*]] = llvm.mlir.undef : vector<5xf32> 389// CHECK: %[[c2:.*]] = llvm.mlir.constant(2 : index) : i64 390// CHECK: %[[e1:.*]] = llvm.extractelement %[[B]][%[[c2]] : i64] : vector<3xf32> 391// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64 392// CHECK: %[[i1:.*]] = llvm.insertelement %[[e1]], %[[u0]][%[[c0]] : i64] : vector<5xf32> 393// CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64 394// CHECK: %[[e2:.*]] = llvm.extractelement %[[B]][%[[c1]] : i64] : vector<3xf32> 395// CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64 396// CHECK: %[[i2:.*]] = llvm.insertelement %[[e2]], %[[i1]][%[[c1]] : i64] : vector<5xf32> 397// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64 398// CHECK: %[[e3:.*]] = llvm.extractelement %[[B]][%[[c0]] : i64] : vector<3xf32> 399// CHECK: %[[c2:.*]] = llvm.mlir.constant(2 : index) : i64 400// CHECK: %[[i3:.*]] = llvm.insertelement %[[e3]], %[[i2]][%[[c2]] : i64] : vector<5xf32> 401// CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64 402// CHECK: %[[e4:.*]] = llvm.extractelement %[[A]][%[[c1]] : i64] : vector<2xf32> 403// CHECK: %[[c3:.*]] = llvm.mlir.constant(3 : index) : i64 404// CHECK: %[[i4:.*]] = llvm.insertelement %[[e4]], %[[i3]][%[[c3]] : i64] : vector<5xf32> 405// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64 406// CHECK: %[[e5:.*]] = llvm.extractelement %[[A]][%[[c0]] : i64] : vector<2xf32> 407// CHECK: %[[c4:.*]] = llvm.mlir.constant(4 : index) : i64 408// CHECK: %[[i5:.*]] = llvm.insertelement %[[e5]], %[[i4]][%[[c4]] : i64] : vector<5xf32> 409// CHECK: return %[[i5]] : vector<5xf32> 410 411// ----- 412 413func @shuffle_2D(%a: vector<1x4xf32>, %b: vector<2x4xf32>) -> vector<3x4xf32> { 414 %1 = vector.shuffle %a, %b[1, 0, 2] : vector<1x4xf32>, vector<2x4xf32> 415 return %1 : vector<3x4xf32> 416} 417// CHECK-LABEL: @shuffle_2D( 418// CHECK-SAME: %[[A:.*]]: vector<1x4xf32>, 419// CHECK-SAME: %[[B:.*]]: vector<2x4xf32>) 420// CHECK: %[[VAL_0:.*]] = llvm.mlir.cast %[[A]] : vector<1x4xf32> to !llvm.array<1 x vector<4xf32>> 421// CHECK: %[[VAL_1:.*]] = llvm.mlir.cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> 422// CHECK: %[[u0:.*]] = llvm.mlir.undef : !llvm.array<3 x vector<4xf32>> 423// CHECK: %[[e1:.*]] = llvm.extractvalue %[[VAL_1]][0] : !llvm.array<2 x vector<4xf32>> 424// CHECK: %[[i1:.*]] = llvm.insertvalue %[[e1]], %[[u0]][0] : !llvm.array<3 x vector<4xf32>> 425// CHECK: %[[e2:.*]] = llvm.extractvalue %[[VAL_0]][0] : !llvm.array<1 x vector<4xf32>> 426// CHECK: %[[i2:.*]] = llvm.insertvalue %[[e2]], %[[i1]][1] : !llvm.array<3 x vector<4xf32>> 427// CHECK: %[[e3:.*]] = llvm.extractvalue %[[VAL_1]][1] : !llvm.array<2 x vector<4xf32>> 428// CHECK: %[[i3:.*]] = llvm.insertvalue %[[e3]], %[[i2]][2] : !llvm.array<3 x vector<4xf32>> 429// CHECK: %[[VAL_3:.*]] = llvm.mlir.cast %[[i3]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32> 430// CHECK: return %[[VAL_3]] : vector<3x4xf32> 431 432// ----- 433 434func @extract_element(%arg0: vector<16xf32>) -> f32 { 435 %0 = constant 15 : i32 436 %1 = vector.extractelement %arg0[%0 : i32]: vector<16xf32> 437 return %1 : f32 438} 439// CHECK-LABEL: @extract_element( 440// CHECK-SAME: %[[A:.*]]: vector<16xf32>) 441// CHECK: %[[c:.*]] = constant 15 : i32 442// CHECK: %[[x:.*]] = llvm.extractelement %[[A]][%[[c]] : i32] : vector<16xf32> 443// CHECK: return %[[x]] : f32 444 445// ----- 446 447func @extract_element_from_vec_1d(%arg0: vector<16xf32>) -> f32 { 448 %0 = vector.extract %arg0[15]: vector<16xf32> 449 return %0 : f32 450} 451// CHECK-LABEL: @extract_element_from_vec_1d 452// CHECK: llvm.mlir.constant(15 : i64) : i64 453// CHECK: llvm.extractelement {{.*}}[{{.*}} : i64] : vector<16xf32> 454// CHECK: return {{.*}} : f32 455 456// ----- 457 458func @extract_index_element_from_vec_1d(%arg0: vector<16xindex>) -> index { 459 %0 = vector.extract %arg0[15]: vector<16xindex> 460 return %0 : index 461} 462// CHECK-LABEL: @extract_index_element_from_vec_1d( 463// CHECK-SAME: %[[A:.*]]: vector<16xindex>) 464// CHECK: %[[T0:.*]] = llvm.mlir.cast %[[A]] : vector<16xindex> to vector<16xi64> 465// CHECK: %[[T1:.*]] = llvm.mlir.constant(15 : i64) : i64 466// CHECK: %[[T2:.*]] = llvm.extractelement %[[T0]][%[[T1]] : i64] : vector<16xi64> 467// CHECK: %[[T3:.*]] = llvm.mlir.cast %[[T2]] : i64 to index 468// CHECK: return %[[T3]] : index 469 470// ----- 471 472func @extract_vec_2d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<3x16xf32> { 473 %0 = vector.extract %arg0[0]: vector<4x3x16xf32> 474 return %0 : vector<3x16xf32> 475} 476// CHECK-LABEL: @extract_vec_2d_from_vec_3d 477// CHECK: llvm.extractvalue {{.*}}[0] : !llvm.array<4 x array<3 x vector<16xf32>>> 478// CHECK: return {{.*}} : vector<3x16xf32> 479 480// ----- 481 482func @extract_vec_1d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<16xf32> { 483 %0 = vector.extract %arg0[0, 0]: vector<4x3x16xf32> 484 return %0 : vector<16xf32> 485} 486// CHECK-LABEL: @extract_vec_1d_from_vec_3d 487// CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vector<16xf32>>> 488// CHECK: return {{.*}} : vector<16xf32> 489 490// ----- 491 492func @extract_element_from_vec_3d(%arg0: vector<4x3x16xf32>) -> f32 { 493 %0 = vector.extract %arg0[0, 0, 0]: vector<4x3x16xf32> 494 return %0 : f32 495} 496// CHECK-LABEL: @extract_element_from_vec_3d 497// CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vector<16xf32>>> 498// CHECK: llvm.mlir.constant(0 : i64) : i64 499// CHECK: llvm.extractelement {{.*}}[{{.*}} : i64] : vector<16xf32> 500// CHECK: return {{.*}} : f32 501 502// ----- 503 504func @insert_element(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> { 505 %0 = constant 3 : i32 506 %1 = vector.insertelement %arg0, %arg1[%0 : i32] : vector<4xf32> 507 return %1 : vector<4xf32> 508} 509// CHECK-LABEL: @insert_element( 510// CHECK-SAME: %[[A:.*]]: f32, 511// CHECK-SAME: %[[B:.*]]: vector<4xf32>) 512// CHECK: %[[c:.*]] = constant 3 : i32 513// CHECK: %[[x:.*]] = llvm.insertelement %[[A]], %[[B]][%[[c]] : i32] : vector<4xf32> 514// CHECK: return %[[x]] : vector<4xf32> 515 516// ----- 517 518func @insert_element_into_vec_1d(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> { 519 %0 = vector.insert %arg0, %arg1[3] : f32 into vector<4xf32> 520 return %0 : vector<4xf32> 521} 522// CHECK-LABEL: @insert_element_into_vec_1d 523// CHECK: llvm.mlir.constant(3 : i64) : i64 524// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<4xf32> 525// CHECK: return {{.*}} : vector<4xf32> 526 527// ----- 528 529func @insert_index_element_into_vec_1d(%arg0: index, %arg1: vector<4xindex>) -> vector<4xindex> { 530 %0 = vector.insert %arg0, %arg1[3] : index into vector<4xindex> 531 return %0 : vector<4xindex> 532} 533// CHECK-LABEL: @insert_index_element_into_vec_1d( 534// CHECK-SAME: %[[A:.*]]: index, 535// CHECK-SAME: %[[B:.*]]: vector<4xindex>) 536// CHECK: %[[T0:.*]] = llvm.mlir.cast %[[A]] : index to i64 537// CHECK: %[[T1:.*]] = llvm.mlir.cast %[[B]] : vector<4xindex> to vector<4xi64> 538// CHECK: %[[T3:.*]] = llvm.mlir.constant(3 : i64) : i64 539// CHECK: %[[T4:.*]] = llvm.insertelement %[[T0]], %[[T1]][%[[T3]] : i64] : vector<4xi64> 540// CHECK: %[[T5:.*]] = llvm.mlir.cast %[[T4]] : vector<4xi64> to vector<4xindex> 541// CHECK: return %[[T5]] : vector<4xindex> 542 543// ----- 544 545func @insert_vec_2d_into_vec_3d(%arg0: vector<8x16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> { 546 %0 = vector.insert %arg0, %arg1[3] : vector<8x16xf32> into vector<4x8x16xf32> 547 return %0 : vector<4x8x16xf32> 548} 549// CHECK-LABEL: @insert_vec_2d_into_vec_3d 550// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm.array<4 x array<8 x vector<16xf32>>> 551// CHECK: return {{.*}} : vector<4x8x16xf32> 552 553// ----- 554 555func @insert_vec_1d_into_vec_3d(%arg0: vector<16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> { 556 %0 = vector.insert %arg0, %arg1[3, 7] : vector<16xf32> into vector<4x8x16xf32> 557 return %0 : vector<4x8x16xf32> 558} 559// CHECK-LABEL: @insert_vec_1d_into_vec_3d 560// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<16xf32>>> 561// CHECK: return {{.*}} : vector<4x8x16xf32> 562 563// ----- 564 565func @insert_element_into_vec_3d(%arg0: f32, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> { 566 %0 = vector.insert %arg0, %arg1[3, 7, 15] : f32 into vector<4x8x16xf32> 567 return %0 : vector<4x8x16xf32> 568} 569// CHECK-LABEL: @insert_element_into_vec_3d 570// CHECK: llvm.extractvalue {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<16xf32>>> 571// CHECK: llvm.mlir.constant(15 : i64) : i64 572// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<16xf32> 573// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<16xf32>>> 574// CHECK: return {{.*}} : vector<4x8x16xf32> 575 576// ----- 577 578func @vector_type_cast(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32>> { 579 %0 = vector.type_cast %arg0: memref<8x8x8xf32> to memref<vector<8x8x8xf32>> 580 return %0 : memref<vector<8x8x8xf32>> 581} 582// CHECK-LABEL: @vector_type_cast 583// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>>, ptr<array<8 x array<8 x vector<8xf32>>>>, i64)> 584// CHECK: %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)> 585// CHECK: %[[allocatedBit:.*]] = llvm.bitcast %[[allocated]] : !llvm.ptr<f32> to !llvm.ptr<array<8 x array<8 x vector<8xf32>>>> 586// CHECK: llvm.insertvalue %[[allocatedBit]], {{.*}}[0] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>>, ptr<array<8 x array<8 x vector<8xf32>>>>, i64)> 587// CHECK: %[[aligned:.*]] = llvm.extractvalue {{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)> 588// CHECK: %[[alignedBit:.*]] = llvm.bitcast %[[aligned]] : !llvm.ptr<f32> to !llvm.ptr<array<8 x array<8 x vector<8xf32>>>> 589// CHECK: llvm.insertvalue %[[alignedBit]], {{.*}}[1] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>>, ptr<array<8 x array<8 x vector<8xf32>>>>, i64)> 590// CHECK: llvm.mlir.constant(0 : index 591// CHECK: llvm.insertvalue {{.*}}[2] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>>, ptr<array<8 x array<8 x vector<8xf32>>>>, i64)> 592 593// ----- 594 595func @vector_index_type_cast(%arg0: memref<8x8x8xindex>) -> memref<vector<8x8x8xindex>> { 596 %0 = vector.type_cast %arg0: memref<8x8x8xindex> to memref<vector<8x8x8xindex>> 597 return %0 : memref<vector<8x8x8xindex>> 598} 599// CHECK-LABEL: @vector_index_type_cast( 600// CHECK-SAME: %[[A:.*]]: memref<8x8x8xindex>) 601// CHECK: %{{.*}} = llvm.mlir.cast %[[A]] : memref<8x8x8xindex> to !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<3 x i64>, array<3 x i64>)> 602 603// CHECK: %{{.*}} = llvm.mlir.cast %{{.*}} : !llvm.struct<(ptr<array<8 x array<8 x vector<8xi64>>>>, ptr<array<8 x array<8 x vector<8xi64>>>>, i64)> to memref<vector<8x8x8xindex>> 604 605// ----- 606 607func @vector_type_cast_non_zero_addrspace(%arg0: memref<8x8x8xf32, 3>) -> memref<vector<8x8x8xf32>, 3> { 608 %0 = vector.type_cast %arg0: memref<8x8x8xf32, 3> to memref<vector<8x8x8xf32>, 3> 609 return %0 : memref<vector<8x8x8xf32>, 3> 610} 611// CHECK-LABEL: @vector_type_cast_non_zero_addrspace 612// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>, 3>, ptr<array<8 x array<8 x vector<8xf32>>>, 3>, i64)> 613// CHECK: %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm.struct<(ptr<f32, 3>, ptr<f32, 3>, i64, array<3 x i64>, array<3 x i64>)> 614// CHECK: %[[allocatedBit:.*]] = llvm.bitcast %[[allocated]] : !llvm.ptr<f32, 3> to !llvm.ptr<array<8 x array<8 x vector<8xf32>>>, 3> 615// CHECK: llvm.insertvalue %[[allocatedBit]], {{.*}}[0] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>, 3>, ptr<array<8 x array<8 x vector<8xf32>>>, 3>, i64)> 616// CHECK: %[[aligned:.*]] = llvm.extractvalue {{.*}}[1] : !llvm.struct<(ptr<f32, 3>, ptr<f32, 3>, i64, array<3 x i64>, array<3 x i64>)> 617// CHECK: %[[alignedBit:.*]] = llvm.bitcast %[[aligned]] : !llvm.ptr<f32, 3> to !llvm.ptr<array<8 x array<8 x vector<8xf32>>>, 3> 618// CHECK: llvm.insertvalue %[[alignedBit]], {{.*}}[1] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>, 3>, ptr<array<8 x array<8 x vector<8xf32>>>, 3>, i64)> 619// CHECK: llvm.mlir.constant(0 : index 620// CHECK: llvm.insertvalue {{.*}}[2] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>, 3>, ptr<array<8 x array<8 x vector<8xf32>>>, 3>, i64)> 621 622// ----- 623 624func @vector_print_scalar_i1(%arg0: i1) { 625 vector.print %arg0 : i1 626 return 627} 628// 629// Type "boolean" always uses zero extension. 630// 631// CHECK-LABEL: @vector_print_scalar_i1( 632// CHECK-SAME: %[[A:.*]]: i1) 633// CHECK: %[[S:.*]] = zexti %[[A]] : i1 to i64 634// CHECK: llvm.call @printI64(%[[S]]) : (i64) -> () 635// CHECK: llvm.call @printNewline() : () -> () 636 637// ----- 638 639func @vector_print_scalar_i4(%arg0: i4) { 640 vector.print %arg0 : i4 641 return 642} 643// CHECK-LABEL: @vector_print_scalar_i4( 644// CHECK-SAME: %[[A:.*]]: i4) 645// CHECK: %[[S:.*]] = sexti %[[A]] : i4 to i64 646// CHECK: llvm.call @printI64(%[[S]]) : (i64) -> () 647// CHECK: llvm.call @printNewline() : () -> () 648 649// ----- 650 651func @vector_print_scalar_si4(%arg0: si4) { 652 vector.print %arg0 : si4 653 return 654} 655// CHECK-LABEL: @vector_print_scalar_si4( 656// CHECK-SAME: %[[A:.*]]: si4) 657// CHECK: %[[C:.*]] = llvm.mlir.cast %[[A]] : si4 to i4 658// CHECK: %[[S:.*]] = sexti %[[C]] : i4 to i64 659// CHECK: llvm.call @printI64(%[[S]]) : (i64) -> () 660// CHECK: llvm.call @printNewline() : () -> () 661 662// ----- 663 664func @vector_print_scalar_ui4(%arg0: ui4) { 665 vector.print %arg0 : ui4 666 return 667} 668// CHECK-LABEL: @vector_print_scalar_ui4( 669// CHECK-SAME: %[[A:.*]]: ui4) 670// CHECK: %[[C:.*]] = llvm.mlir.cast %[[A]] : ui4 to i4 671// CHECK: %[[S:.*]] = zexti %[[C]] : i4 to i64 672// CHECK: llvm.call @printU64(%[[S]]) : (i64) -> () 673// CHECK: llvm.call @printNewline() : () -> () 674 675// ----- 676 677func @vector_print_scalar_i32(%arg0: i32) { 678 vector.print %arg0 : i32 679 return 680} 681// CHECK-LABEL: @vector_print_scalar_i32( 682// CHECK-SAME: %[[A:.*]]: i32) 683// CHECK: %[[S:.*]] = sexti %[[A]] : i32 to i64 684// CHECK: llvm.call @printI64(%[[S]]) : (i64) -> () 685// CHECK: llvm.call @printNewline() : () -> () 686 687// ----- 688 689func @vector_print_scalar_ui32(%arg0: ui32) { 690 vector.print %arg0 : ui32 691 return 692} 693// CHECK-LABEL: @vector_print_scalar_ui32( 694// CHECK-SAME: %[[A:.*]]: ui32) 695// CHECK: %[[C:.*]] = llvm.mlir.cast %[[A]] : ui32 to i32 696// CHECK: %[[S:.*]] = zexti %[[C]] : i32 to i64 697// CHECK: llvm.call @printU64(%[[S]]) : (i64) -> () 698 699// ----- 700 701func @vector_print_scalar_i40(%arg0: i40) { 702 vector.print %arg0 : i40 703 return 704} 705// CHECK-LABEL: @vector_print_scalar_i40( 706// CHECK-SAME: %[[A:.*]]: i40) 707// CHECK: %[[S:.*]] = sexti %[[A]] : i40 to i64 708// CHECK: llvm.call @printI64(%[[S]]) : (i64) -> () 709// CHECK: llvm.call @printNewline() : () -> () 710 711// ----- 712 713func @vector_print_scalar_si40(%arg0: si40) { 714 vector.print %arg0 : si40 715 return 716} 717// CHECK-LABEL: @vector_print_scalar_si40( 718// CHECK-SAME: %[[A:.*]]: si40) 719// CHECK: %[[C:.*]] = llvm.mlir.cast %[[A]] : si40 to i40 720// CHECK: %[[S:.*]] = sexti %[[C]] : i40 to i64 721// CHECK: llvm.call @printI64(%[[S]]) : (i64) -> () 722// CHECK: llvm.call @printNewline() : () -> () 723 724// ----- 725 726func @vector_print_scalar_ui40(%arg0: ui40) { 727 vector.print %arg0 : ui40 728 return 729} 730// CHECK-LABEL: @vector_print_scalar_ui40( 731// CHECK-SAME: %[[A:.*]]: ui40) 732// CHECK: %[[C:.*]] = llvm.mlir.cast %[[A]] : ui40 to i40 733// CHECK: %[[S:.*]] = zexti %[[C]] : i40 to i64 734// CHECK: llvm.call @printU64(%[[S]]) : (i64) -> () 735// CHECK: llvm.call @printNewline() : () -> () 736 737// ----- 738 739func @vector_print_scalar_i64(%arg0: i64) { 740 vector.print %arg0 : i64 741 return 742} 743// CHECK-LABEL: @vector_print_scalar_i64( 744// CHECK-SAME: %[[A:.*]]: i64) 745// CHECK: llvm.call @printI64(%[[A]]) : (i64) -> () 746// CHECK: llvm.call @printNewline() : () -> () 747 748// ----- 749 750func @vector_print_scalar_ui64(%arg0: ui64) { 751 vector.print %arg0 : ui64 752 return 753} 754// CHECK-LABEL: @vector_print_scalar_ui64( 755// CHECK-SAME: %[[A:.*]]: ui64) 756// CHECK: %[[C:.*]] = llvm.mlir.cast %[[A]] : ui64 to i64 757// CHECK: llvm.call @printU64(%[[C]]) : (i64) -> () 758// CHECK: llvm.call @printNewline() : () -> () 759 760// ----- 761 762func @vector_print_scalar_index(%arg0: index) { 763 vector.print %arg0 : index 764 return 765} 766// CHECK-LABEL: @vector_print_scalar_index( 767// CHECK-SAME: %[[A:.*]]: index) 768// CHECK: %[[C:.*]] = llvm.mlir.cast %[[A]] : index to i64 769// CHECK: llvm.call @printU64(%[[C]]) : (i64) -> () 770// CHECK: llvm.call @printNewline() : () -> () 771 772// ----- 773 774func @vector_print_scalar_f32(%arg0: f32) { 775 vector.print %arg0 : f32 776 return 777} 778// CHECK-LABEL: @vector_print_scalar_f32( 779// CHECK-SAME: %[[A:.*]]: f32) 780// CHECK: llvm.call @printF32(%[[A]]) : (f32) -> () 781// CHECK: llvm.call @printNewline() : () -> () 782 783// ----- 784 785func @vector_print_scalar_f64(%arg0: f64) { 786 vector.print %arg0 : f64 787 return 788} 789// CHECK-LABEL: @vector_print_scalar_f64( 790// CHECK-SAME: %[[A:.*]]: f64) 791// CHECK: llvm.call @printF64(%[[A]]) : (f64) -> () 792// CHECK: llvm.call @printNewline() : () -> () 793 794// ----- 795 796func @vector_print_vector(%arg0: vector<2x2xf32>) { 797 vector.print %arg0 : vector<2x2xf32> 798 return 799} 800// CHECK-LABEL: @vector_print_vector( 801// CHECK-SAME: %[[A:.*]]: vector<2x2xf32>) 802// CHECK: %[[VAL_1:.*]] = llvm.mlir.cast %[[A]] : vector<2x2xf32> to !llvm.array<2 x vector<2xf32>> 803// CHECK: llvm.call @printOpen() : () -> () 804// CHECK: %[[x0:.*]] = llvm.extractvalue %[[VAL_1]][0] : !llvm.array<2 x vector<2xf32>> 805// CHECK: llvm.call @printOpen() : () -> () 806// CHECK: %[[x1:.*]] = llvm.mlir.constant(0 : index) : i64 807// CHECK: %[[x2:.*]] = llvm.extractelement %[[x0]][%[[x1]] : i64] : vector<2xf32> 808// CHECK: llvm.call @printF32(%[[x2]]) : (f32) -> () 809// CHECK: llvm.call @printComma() : () -> () 810// CHECK: %[[x3:.*]] = llvm.mlir.constant(1 : index) : i64 811// CHECK: %[[x4:.*]] = llvm.extractelement %[[x0]][%[[x3]] : i64] : vector<2xf32> 812// CHECK: llvm.call @printF32(%[[x4]]) : (f32) -> () 813// CHECK: llvm.call @printClose() : () -> () 814// CHECK: llvm.call @printComma() : () -> () 815// CHECK: %[[x5:.*]] = llvm.extractvalue %[[VAL_1]][1] : !llvm.array<2 x vector<2xf32>> 816// CHECK: llvm.call @printOpen() : () -> () 817// CHECK: %[[x6:.*]] = llvm.mlir.constant(0 : index) : i64 818// CHECK: %[[x7:.*]] = llvm.extractelement %[[x5]][%[[x6]] : i64] : vector<2xf32> 819// CHECK: llvm.call @printF32(%[[x7]]) : (f32) -> () 820// CHECK: llvm.call @printComma() : () -> () 821// CHECK: %[[x8:.*]] = llvm.mlir.constant(1 : index) : i64 822// CHECK: %[[x9:.*]] = llvm.extractelement %[[x5]][%[[x8]] : i64] : vector<2xf32> 823// CHECK: llvm.call @printF32(%[[x9]]) : (f32) -> () 824// CHECK: llvm.call @printClose() : () -> () 825// CHECK: llvm.call @printClose() : () -> () 826// CHECK: llvm.call @printNewline() : () -> () 827 828// ----- 829 830func @extract_strided_slice1(%arg0: vector<4xf32>) -> vector<2xf32> { 831 %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32> 832 return %0 : vector<2xf32> 833} 834// CHECK-LABEL: @extract_strided_slice1( 835// CHECK-SAME: %[[A:.*]]: vector<4xf32>) 836// CHECK: %[[T0:.*]] = llvm.shufflevector %[[A]], %[[A]] [2, 3] : vector<4xf32>, vector<4xf32> 837// CHECK: return %[[T0]] : vector<2xf32> 838 839// ----- 840 841func @extract_strided_index_slice1(%arg0: vector<4xindex>) -> vector<2xindex> { 842 %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xindex> to vector<2xindex> 843 return %0 : vector<2xindex> 844} 845// CHECK-LABEL: @extract_strided_index_slice1( 846// CHECK-SAME: %[[A:.*]]: vector<4xindex>) 847// CHECK: %[[T0:.*]] = llvm.mlir.cast %[[A]] : vector<4xindex> to vector<4xi64> 848// CHECK: %[[T1:.*]] = llvm.mlir.cast %[[A]] : vector<4xindex> to vector<4xi64> 849// CHECK: %[[T2:.*]] = llvm.shufflevector %[[T0]], %[[T1]] [2, 3] : vector<4xi64>, vector<4xi64> 850// CHECK: %[[T3:.*]] = llvm.mlir.cast %[[T2]] : vector<2xi64> to vector<2xindex> 851// CHECK: return %[[T3]] : vector<2xindex> 852 853// ----- 854 855func @extract_strided_slice2(%arg0: vector<4x8xf32>) -> vector<2x8xf32> { 856 %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4x8xf32> to vector<2x8xf32> 857 return %0 : vector<2x8xf32> 858} 859// CHECK-LABEL: @extract_strided_slice2( 860// CHECK-SAME: %[[ARG:.*]]: vector<4x8xf32>) 861// CHECK: %[[A:.*]] = llvm.mlir.cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> 862// CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.array<2 x vector<8xf32>> 863// CHECK: %[[T1:.*]] = llvm.extractvalue %[[A]][2] : !llvm.array<4 x vector<8xf32>> 864// CHECK: %[[T2:.*]] = llvm.insertvalue %[[T1]], %[[T0]][0] : !llvm.array<2 x vector<8xf32>> 865// CHECK: %[[T3:.*]] = llvm.extractvalue %[[A]][3] : !llvm.array<4 x vector<8xf32>> 866// CHECK: %[[T4:.*]] = llvm.insertvalue %[[T3]], %[[T2]][1] : !llvm.array<2 x vector<8xf32>> 867// CHECK: %[[T5:.*]] = llvm.mlir.cast %[[T4]] : !llvm.array<2 x vector<8xf32>> to vector<2x8xf32> 868// CHECK: return %[[T5]] 869 870// ----- 871 872func @extract_strided_slice3(%arg0: vector<4x8xf32>) -> vector<2x2xf32> { 873 %0 = vector.extract_strided_slice %arg0 {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8xf32> to vector<2x2xf32> 874 return %0 : vector<2x2xf32> 875} 876// CHECK-LABEL: @extract_strided_slice3( 877// CHECK-SAME: %[[ARG:.*]]: vector<4x8xf32>) 878// CHECK: %[[VAL_1:.*]] = constant 0.000000e+00 : f32 879// CHECK: %[[VAL_2:.*]] = splat %[[VAL_1]] : vector<2x2xf32> 880// CHECK: %[[A:.*]] = llvm.mlir.cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> 881// CHECK: %[[T2:.*]] = llvm.extractvalue %[[A]][2] : !llvm.array<4 x vector<8xf32>> 882// CHECK: %[[T3:.*]] = llvm.shufflevector %[[T2]], %[[T2]] [2, 3] : vector<8xf32>, vector<8xf32> 883// CHECK: %[[VAL_6:.*]] = llvm.mlir.cast %[[VAL_2]] : vector<2x2xf32> to !llvm.array<2 x vector<2xf32>> 884// CHECK: %[[T4:.*]] = llvm.insertvalue %[[T3]], %[[VAL_6]][0] : !llvm.array<2 x vector<2xf32>> 885// CHECK: %[[A:.*]] = llvm.mlir.cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>> 886// CHECK: %[[T5:.*]] = llvm.extractvalue %[[A]][3] : !llvm.array<4 x vector<8xf32>> 887// CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T5]] [2, 3] : vector<8xf32>, vector<8xf32> 888// CHECK: %[[T7:.*]] = llvm.insertvalue %[[T6]], %[[T4]][1] : !llvm.array<2 x vector<2xf32>> 889// CHECK: %[[VAL_12:.*]] = llvm.mlir.cast %[[T7]] : !llvm.array<2 x vector<2xf32>> to vector<2x2xf32> 890// CHECK: return %[[VAL_12]] : vector<2x2xf32> 891 892// ----- 893 894func @insert_strided_slice1(%b: vector<4x4xf32>, %c: vector<4x4x4xf32>) -> vector<4x4x4xf32> { 895 %0 = vector.insert_strided_slice %b, %c {offsets = [2, 0, 0], strides = [1, 1]} : vector<4x4xf32> into vector<4x4x4xf32> 896 return %0 : vector<4x4x4xf32> 897} 898// CHECK-LABEL: @insert_strided_slice1 899// CHECK: llvm.extractvalue {{.*}}[2] : !llvm.array<4 x array<4 x vector<4xf32>>> 900// CHECK: llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm.array<4 x array<4 x vector<4xf32>>> 901 902// ----- 903 904func @insert_strided_index_slice1(%b: vector<4x4xindex>, %c: vector<4x4x4xindex>) -> vector<4x4x4xindex> { 905 %0 = vector.insert_strided_slice %b, %c {offsets = [2, 0, 0], strides = [1, 1]} : vector<4x4xindex> into vector<4x4x4xindex> 906 return %0 : vector<4x4x4xindex> 907} 908// CHECK-LABEL: @insert_strided_index_slice1( 909// CHECK: llvm.extractvalue {{.*}}[2] : !llvm.array<4 x array<4 x vector<4xi64>>> 910// CHECK: llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm.array<4 x array<4 x vector<4xi64>>> 911 912// ----- 913 914func @insert_strided_slice2(%a: vector<2x2xf32>, %b: vector<4x4xf32>) -> vector<4x4xf32> { 915 %0 = vector.insert_strided_slice %a, %b {offsets = [2, 2], strides = [1, 1]} : vector<2x2xf32> into vector<4x4xf32> 916 return %0 : vector<4x4xf32> 917} 918// CHECK-LABEL: @insert_strided_slice2 919// 920// Subvector vector<2xf32> @0 into vector<4xf32> @2 921// CHECK: llvm.extractvalue {{.*}}[0] : !llvm.array<2 x vector<2xf32>> 922// CHECK-NEXT: llvm.mlir.cast %{{.*}} : vector<4x4xf32> to !llvm.array<4 x vector<4xf32>> 923// CHECK-NEXT: llvm.extractvalue {{.*}}[2] : !llvm.array<4 x vector<4xf32>> 924// Element @0 -> element @2 925// CHECK-NEXT: constant 0 : index 926// CHECK-NEXT: llvm.mlir.cast %{{.*}} : index to i64 927// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : i64] : vector<2xf32> 928// CHECK-NEXT: constant 2 : index 929// CHECK-NEXT: llvm.mlir.cast %{{.*}} : index to i64 930// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<4xf32> 931// Element @1 -> element @3 932// CHECK-NEXT: constant 1 : index 933// CHECK-NEXT: llvm.mlir.cast %{{.*}} : index to i64 934// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : i64] : vector<2xf32> 935// CHECK-NEXT: constant 3 : index 936// CHECK-NEXT: llvm.mlir.cast %{{.*}} : index to i64 937// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<4xf32> 938// CHECK-NEXT: llvm.mlir.cast %{{.*}} : vector<4x4xf32> to !llvm.array<4 x vector<4xf32>> 939// CHECK-NEXT: llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm.array<4 x vector<4xf32>> 940// 941// Subvector vector<2xf32> @1 into vector<4xf32> @3 942// CHECK: llvm.extractvalue {{.*}}[1] : !llvm.array<2 x vector<2xf32>> 943// CHECK-NEXT: llvm.mlir.cast %{{.*}} : vector<4x4xf32> to !llvm.array<4 x vector<4xf32>> 944// CHECK-NEXT: llvm.extractvalue {{.*}}[3] : !llvm.array<4 x vector<4xf32>> 945// Element @0 -> element @2 946// CHECK-NEXT: constant 0 : index 947// CHECK-NEXT: llvm.mlir.cast %{{.*}} : index to i64 948// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : i64] : vector<2xf32> 949// CHECK-NEXT: constant 2 : index 950// CHECK-NEXT: llvm.mlir.cast %{{.*}} : index to i64 951// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<4xf32> 952// Element @1 -> element @3 953// CHECK-NEXT: constant 1 : index 954// CHECK-NEXT: llvm.mlir.cast %{{.*}} : index to i64 955// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : i64] : vector<2xf32> 956// CHECK-NEXT: constant 3 : index 957// CHECK-NEXT: llvm.mlir.cast %{{.*}} : index to i64 958// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<4xf32> 959// CHECK-NEXT: llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm.array<4 x vector<4xf32>> 960 961// ----- 962 963func @insert_strided_slice3(%arg0: vector<2x4xf32>, %arg1: vector<16x4x8xf32>) -> vector<16x4x8xf32> { 964 %0 = vector.insert_strided_slice %arg0, %arg1 {offsets = [0, 0, 2], strides = [1, 1]}: 965 vector<2x4xf32> into vector<16x4x8xf32> 966 return %0 : vector<16x4x8xf32> 967} 968// CHECK-LABEL: @insert_strided_slice3( 969// CHECK-SAME: %[[A:.*]]: vector<2x4xf32>, 970// CHECK-SAME: %[[B:.*]]: vector<16x4x8xf32>) 971// CHECK: %[[s2:.*]] = llvm.mlir.cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> 972// CHECK: %[[s3:.*]] = llvm.extractvalue %[[s2]][0] : !llvm.array<16 x array<4 x vector<8xf32>>> 973// CHECK: %[[s4:.*]] = llvm.mlir.cast %[[A]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> 974// CHECK: %[[s5:.*]] = llvm.extractvalue %[[s4]][0] : !llvm.array<2 x vector<4xf32>> 975// CHECK: %[[s6:.*]] = llvm.mlir.cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> 976// CHECK: %[[s7:.*]] = llvm.extractvalue %[[s6]][0, 0] : !llvm.array<16 x array<4 x vector<8xf32>>> 977// CHECK: %[[s8:.*]] = constant 0 : index 978// CHECK: %[[s9:.*]] = llvm.mlir.cast %[[s8]] : index to i64 979// CHECK: %[[s10:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s9]] : i64] : vector<4xf32> 980// CHECK: %[[s11:.*]] = constant 2 : index 981// CHECK: %[[s12:.*]] = llvm.mlir.cast %[[s11]] : index to i64 982// CHECK: %[[s13:.*]] = llvm.insertelement %[[s10]], %[[s7]]{{\[}}%[[s12]] : i64] : vector<8xf32> 983// CHECK: %[[s14:.*]] = constant 1 : index 984// CHECK: %[[s15:.*]] = llvm.mlir.cast %[[s14]] : index to i64 985// CHECK: %[[s16:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s15]] : i64] : vector<4xf32> 986// CHECK: %[[s17:.*]] = constant 3 : index 987// CHECK: %[[s18:.*]] = llvm.mlir.cast %[[s17]] : index to i64 988// CHECK: %[[s19:.*]] = llvm.insertelement %[[s16]], %[[s13]]{{\[}}%[[s18]] : i64] : vector<8xf32> 989// CHECK: %[[s20:.*]] = constant 2 : index 990// CHECK: %[[s21:.*]] = llvm.mlir.cast %[[s20]] : index to i64 991// CHECK: %[[s22:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s21]] : i64] : vector<4xf32> 992// CHECK: %[[s23:.*]] = constant 4 : index 993// CHECK: %[[s24:.*]] = llvm.mlir.cast %[[s23]] : index to i64 994// CHECK: %[[s25:.*]] = llvm.insertelement %[[s22]], %[[s19]]{{\[}}%[[s24]] : i64] : vector<8xf32> 995// CHECK: %[[s26:.*]] = constant 3 : index 996// CHECK: %[[s27:.*]] = llvm.mlir.cast %[[s26]] : index to i64 997// CHECK: %[[s28:.*]] = llvm.extractelement %[[s5]]{{\[}}%[[s27]] : i64] : vector<4xf32> 998// CHECK: %[[s29:.*]] = constant 5 : index 999// CHECK: %[[s30:.*]] = llvm.mlir.cast %[[s29]] : index to i64 1000// CHECK: %[[s31:.*]] = llvm.insertelement %[[s28]], %[[s25]]{{\[}}%[[s30]] : i64] : vector<8xf32> 1001// CHECK: %[[s32:.*]] = llvm.insertvalue %[[s31]], %[[s3]][0] : !llvm.array<4 x vector<8xf32>> 1002// CHECK: %[[s33:.*]] = llvm.mlir.cast %[[A]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> 1003// CHECK: %[[s34:.*]] = llvm.extractvalue %[[s33]][1] : !llvm.array<2 x vector<4xf32>> 1004// CHECK: %[[s35:.*]] = llvm.mlir.cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> 1005// CHECK: %[[s36:.*]] = llvm.extractvalue %[[s35]][0, 1] : !llvm.array<16 x array<4 x vector<8xf32>>> 1006// CHECK: %[[s37:.*]] = constant 0 : index 1007// CHECK: %[[s38:.*]] = llvm.mlir.cast %[[s37]] : index to i64 1008// CHECK: %[[s39:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s38]] : i64] : vector<4xf32> 1009// CHECK: %[[s40:.*]] = constant 2 : index 1010// CHECK: %[[s41:.*]] = llvm.mlir.cast %[[s40]] : index to i64 1011// CHECK: %[[s42:.*]] = llvm.insertelement %[[s39]], %[[s36]]{{\[}}%[[s41]] : i64] : vector<8xf32> 1012// CHECK: %[[s43:.*]] = constant 1 : index 1013// CHECK: %[[s44:.*]] = llvm.mlir.cast %[[s43]] : index to i64 1014// CHECK: %[[s45:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s44]] : i64] : vector<4xf32> 1015// CHECK: %[[s46:.*]] = constant 3 : index 1016// CHECK: %[[s47:.*]] = llvm.mlir.cast %[[s46]] : index to i64 1017// CHECK: %[[s48:.*]] = llvm.insertelement %[[s45]], %[[s42]]{{\[}}%[[s47]] : i64] : vector<8xf32> 1018// CHECK: %[[s49:.*]] = constant 2 : index 1019// CHECK: %[[s50:.*]] = llvm.mlir.cast %[[s49]] : index to i64 1020// CHECK: %[[s51:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s50]] : i64] : vector<4xf32> 1021// CHECK: %[[s52:.*]] = constant 4 : index 1022// CHECK: %[[s53:.*]] = llvm.mlir.cast %[[s52]] : index to i64 1023// CHECK: %[[s54:.*]] = llvm.insertelement %[[s51]], %[[s48]]{{\[}}%[[s53]] : i64] : vector<8xf32> 1024// CHECK: %[[s55:.*]] = constant 3 : index 1025// CHECK: %[[s56:.*]] = llvm.mlir.cast %[[s55]] : index to i64 1026// CHECK: %[[s57:.*]] = llvm.extractelement %[[s34]]{{\[}}%[[s56]] : i64] : vector<4xf32> 1027// CHECK: %[[s58:.*]] = constant 5 : index 1028// CHECK: %[[s59:.*]] = llvm.mlir.cast %[[s58]] : index to i64 1029// CHECK: %[[s60:.*]] = llvm.insertelement %[[s57]], %[[s54]]{{\[}}%[[s59]] : i64] : vector<8xf32> 1030// CHECK: %[[s61:.*]] = llvm.insertvalue %[[s60]], %[[s32]][1] : !llvm.array<4 x vector<8xf32>> 1031// CHECK: %[[s62:.*]] = llvm.mlir.cast %[[B]] : vector<16x4x8xf32> to !llvm.array<16 x array<4 x vector<8xf32>>> 1032// CHECK: %[[s63:.*]] = llvm.insertvalue %[[s61]], %[[s62]][0] : !llvm.array<16 x array<4 x vector<8xf32>>> 1033// CHECK: %[[s64:.*]] = llvm.mlir.cast %[[s63]] : !llvm.array<16 x array<4 x vector<8xf32>>> to vector<16x4x8xf32> 1034// CHECK: return %[[s64]] : vector<16x4x8xf32> 1035 1036// ----- 1037 1038func @extract_strides(%arg0: vector<3x3xf32>) -> vector<1x1xf32> { 1039 %0 = vector.extract_slices %arg0, [2, 2], [1, 1] 1040 : vector<3x3xf32> into tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>> 1041 %1 = vector.tuple_get %0, 3 : tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>> 1042 return %1 : vector<1x1xf32> 1043} 1044// CHECK-LABEL: @extract_strides( 1045// CHECK-SAME: %[[ARG:.*]]: vector<3x3xf32>) 1046// CHECK: %[[VAL_1:.*]] = constant 0.000000e+00 : f32 1047// CHECK: %[[VAL_2:.*]] = splat %[[VAL_1]] : vector<1x1xf32> 1048// CHECK: %[[A:.*]] = llvm.mlir.cast %[[ARG]] : vector<3x3xf32> to !llvm.array<3 x vector<3xf32>> 1049// CHECK: %[[T2:.*]] = llvm.extractvalue %[[A]][2] : !llvm.array<3 x vector<3xf32>> 1050// CHECK: %[[T3:.*]] = llvm.shufflevector %[[T2]], %[[T2]] [2] : vector<3xf32>, vector<3xf32> 1051// CHECK: %[[VAL_6:.*]] = llvm.mlir.cast %[[VAL_2]] : vector<1x1xf32> to !llvm.array<1 x vector<1xf32>> 1052// CHECK: %[[T4:.*]] = llvm.insertvalue %[[T3]], %[[VAL_6]][0] : !llvm.array<1 x vector<1xf32>> 1053// CHECK: %[[VAL_8:.*]] = llvm.mlir.cast %[[T4]] : !llvm.array<1 x vector<1xf32>> to vector<1x1xf32> 1054// CHECK: return %[[VAL_8]] : vector<1x1xf32> 1055 1056// ----- 1057 1058func @vector_fma(%a: vector<8xf32>, %b: vector<2x4xf32>) -> (vector<8xf32>, vector<2x4xf32>) { 1059 // CHECK-LABEL: @vector_fma 1060 // CHECK-SAME: %[[A:.*]]: vector<8xf32> 1061 // CHECK-SAME: %[[B:.*]]: vector<2x4xf32> 1062 // CHECK: "llvm.intr.fmuladd" 1063 // CHECK-SAME: (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32> 1064 %0 = vector.fma %a, %a, %a : vector<8xf32> 1065 1066 // CHECK: %[[BL:.*]] = llvm.mlir.cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> 1067 // CHECK: %[[b00:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<4xf32>> 1068 // CHECK: %[[BL:.*]] = llvm.mlir.cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> 1069 // CHECK: %[[b01:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<4xf32>> 1070 // CHECK: %[[BL:.*]] = llvm.mlir.cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> 1071 // CHECK: %[[b02:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<4xf32>> 1072 // CHECK: %[[B0:.*]] = "llvm.intr.fmuladd"(%[[b00]], %[[b01]], %[[b02]]) : 1073 // CHECK-SAME: (vector<4xf32>, vector<4xf32>, vector<4xf32>) -> vector<4xf32> 1074 // CHECK: llvm.insertvalue %[[B0]], {{.*}}[0] : !llvm.array<2 x vector<4xf32>> 1075 // CHECK: %[[BL:.*]] = llvm.mlir.cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> 1076 // CHECK: %[[b10:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<4xf32>> 1077 // CHECK: %[[BL:.*]] = llvm.mlir.cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> 1078 // CHECK: %[[b11:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<4xf32>> 1079 // CHECK: %[[BL:.*]] = llvm.mlir.cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>> 1080 // CHECK: %[[b12:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<4xf32>> 1081 // CHECK: %[[B1:.*]] = "llvm.intr.fmuladd"(%[[b10]], %[[b11]], %[[b12]]) : 1082 // CHECK-SAME: (vector<4xf32>, vector<4xf32>, vector<4xf32>) -> vector<4xf32> 1083 // CHECK: llvm.insertvalue %[[B1]], {{.*}}[1] : !llvm.array<2 x vector<4xf32>> 1084 %1 = vector.fma %b, %b, %b : vector<2x4xf32> 1085 1086 return %0, %1: vector<8xf32>, vector<2x4xf32> 1087} 1088 1089// ----- 1090 1091func @reduce_f16(%arg0: vector<16xf16>) -> f16 { 1092 %0 = vector.reduction "add", %arg0 : vector<16xf16> into f16 1093 return %0 : f16 1094} 1095// CHECK-LABEL: @reduce_f16( 1096// CHECK-SAME: %[[A:.*]]: vector<16xf16>) 1097// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f16) : f16 1098// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]]) 1099// CHECK-SAME: {reassoc = false} : (f16, vector<16xf16>) -> f16 1100// CHECK: return %[[V]] : f16 1101 1102// ----- 1103 1104func @reduce_f32(%arg0: vector<16xf32>) -> f32 { 1105 %0 = vector.reduction "add", %arg0 : vector<16xf32> into f32 1106 return %0 : f32 1107} 1108// CHECK-LABEL: @reduce_f32( 1109// CHECK-SAME: %[[A:.*]]: vector<16xf32>) 1110// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32 1111// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]]) 1112// CHECK-SAME: {reassoc = false} : (f32, vector<16xf32>) -> f32 1113// CHECK: return %[[V]] : f32 1114 1115// ----- 1116 1117func @reduce_f64(%arg0: vector<16xf64>) -> f64 { 1118 %0 = vector.reduction "add", %arg0 : vector<16xf64> into f64 1119 return %0 : f64 1120} 1121// CHECK-LABEL: @reduce_f64( 1122// CHECK-SAME: %[[A:.*]]: vector<16xf64>) 1123// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : f64 1124// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]]) 1125// CHECK-SAME: {reassoc = false} : (f64, vector<16xf64>) -> f64 1126// CHECK: return %[[V]] : f64 1127 1128// ----- 1129 1130func @reduce_i8(%arg0: vector<16xi8>) -> i8 { 1131 %0 = vector.reduction "add", %arg0 : vector<16xi8> into i8 1132 return %0 : i8 1133} 1134// CHECK-LABEL: @reduce_i8( 1135// CHECK-SAME: %[[A:.*]]: vector<16xi8>) 1136// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]]) 1137// CHECK: return %[[V]] : i8 1138 1139// ----- 1140 1141func @reduce_i32(%arg0: vector<16xi32>) -> i32 { 1142 %0 = vector.reduction "add", %arg0 : vector<16xi32> into i32 1143 return %0 : i32 1144} 1145// CHECK-LABEL: @reduce_i32( 1146// CHECK-SAME: %[[A:.*]]: vector<16xi32>) 1147// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]]) 1148// CHECK: return %[[V]] : i32 1149 1150// ----- 1151 1152func @reduce_i64(%arg0: vector<16xi64>) -> i64 { 1153 %0 = vector.reduction "add", %arg0 : vector<16xi64> into i64 1154 return %0 : i64 1155} 1156// CHECK-LABEL: @reduce_i64( 1157// CHECK-SAME: %[[A:.*]]: vector<16xi64>) 1158// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]]) 1159// CHECK: return %[[V]] : i64 1160 1161// ----- 1162 1163func @reduce_index(%arg0: vector<16xindex>) -> index { 1164 %0 = vector.reduction "add", %arg0 : vector<16xindex> into index 1165 return %0 : index 1166} 1167// CHECK-LABEL: @reduce_index( 1168// CHECK-SAME: %[[A:.*]]: vector<16xindex>) 1169// CHECK: %[[T0:.*]] = llvm.mlir.cast %[[A]] : vector<16xindex> to vector<16xi64> 1170// CHECK: %[[T1:.*]] = "llvm.intr.vector.reduce.add"(%[[T0]]) 1171// CHECK: %[[T2:.*]] = llvm.mlir.cast %[[T1]] : i64 to index 1172// CHECK: return %[[T2]] : index 1173 1174// 4x16 16x3 4x3 1175// ----- 1176 1177func @matrix_ops(%A: vector<64xf64>, %B: vector<48xf64>) -> vector<12xf64> { 1178 %C = vector.matrix_multiply %A, %B 1179 { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } : 1180 (vector<64xf64>, vector<48xf64>) -> vector<12xf64> 1181 return %C: vector<12xf64> 1182} 1183// CHECK-LABEL: @matrix_ops 1184// CHECK: llvm.intr.matrix.multiply %{{.*}}, %{{.*}} { 1185// CHECK-SAME: lhs_columns = 16 : i32, lhs_rows = 4 : i32, rhs_columns = 3 : i32 1186// CHECK-SAME: } : (vector<64xf64>, vector<48xf64>) -> vector<12xf64> 1187 1188// ----- 1189 1190func @matrix_ops_index(%A: vector<64xindex>, %B: vector<48xindex>) -> vector<12xindex> { 1191 %C = vector.matrix_multiply %A, %B 1192 { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } : 1193 (vector<64xindex>, vector<48xindex>) -> vector<12xindex> 1194 return %C: vector<12xindex> 1195} 1196// CHECK-LABEL: @matrix_ops_index 1197// CHECK: llvm.intr.matrix.multiply %{{.*}}, %{{.*}} { 1198// CHECK-SAME: lhs_columns = 16 : i32, lhs_rows = 4 : i32, rhs_columns = 3 : i32 1199// CHECK-SAME: } : (vector<64xi64>, vector<48xi64>) -> vector<12xi64> 1200 1201// ----- 1202 1203func @transfer_read_1d(%A : memref<?xf32>, %base: index) -> vector<17xf32> { 1204 %f7 = constant 7.0: f32 1205 %f = vector.transfer_read %A[%base], %f7 1206 {permutation_map = affine_map<(d0) -> (d0)>} : 1207 memref<?xf32>, vector<17xf32> 1208 vector.transfer_write %f, %A[%base] 1209 {permutation_map = affine_map<(d0) -> (d0)>} : 1210 vector<17xf32>, memref<?xf32> 1211 return %f: vector<17xf32> 1212} 1213// CHECK-LABEL: func @transfer_read_1d 1214// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: index) -> vector<17xf32> 1215// CHECK: %[[c7:.*]] = constant 7.0 1216// CHECK: %[[C0:.*]] = constant 0 : index 1217// CHECK: %[[DIM:.*]] = memref.dim %{{.*}}, %[[C0]] : memref<?xf32> 1218// 1219// 1. Create a vector with linear indices [ 0 .. vector_length - 1 ]. 1220// CHECK: %[[linearIndex:.*]] = constant dense 1221// CHECK-SAME: <[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> : 1222// CHECK-SAME: vector<17xi32> 1223// 1224// 2. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ]. 1225// CHECK: %[[otrunc:.*]] = index_cast %[[BASE]] : index to i32 1226// CHECK: %[[offsetVec:.*]] = splat %[[otrunc]] : vector<17xi32> 1227// CHECK: %[[offsetVec2:.*]] = addi %[[offsetVec]], %[[linearIndex]] : vector<17xi32> 1228// 1229// 3. Let dim the memref dimension, compute the vector comparison mask: 1230// [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ] 1231// CHECK: %[[dtrunc:.*]] = index_cast %[[DIM]] : index to i32 1232// CHECK: %[[dimVec:.*]] = splat %[[dtrunc]] : vector<17xi32> 1233// CHECK: %[[mask:.*]] = cmpi slt, %[[offsetVec2]], %[[dimVec]] : vector<17xi32> 1234// 1235// 4. Bitcast to vector form. 1236// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : 1237// CHECK-SAME: (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1238// CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] : 1239// CHECK-SAME: !llvm.ptr<f32> to !llvm.ptr<vector<17xf32>> 1240// 1241// 5. Rewrite as a masked read. 1242// CHECK: %[[PASS_THROUGH:.*]] = splat %[[c7]] : vector<17xf32> 1243// CHECK: %[[loaded:.*]] = llvm.intr.masked.load %[[vecPtr]], %[[mask]], 1244// CHECK-SAME: %[[PASS_THROUGH]] {alignment = 4 : i32} : 1245// CHECK-SAME: (!llvm.ptr<vector<17xf32>>, vector<17xi1>, vector<17xf32>) -> vector<17xf32> 1246 1247// 1248// 1. Create a vector with linear indices [ 0 .. vector_length - 1 ]. 1249// CHECK: %[[linearIndex_b:.*]] = constant dense 1250// CHECK-SAME: <[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> : 1251// CHECK-SAME: vector<17xi32> 1252// 1253// 2. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ]. 1254// CHECK: splat %{{.*}} : vector<17xi32> 1255// CHECK: addi 1256// 1257// 3. Let dim the memref dimension, compute the vector comparison mask: 1258// [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ] 1259// CHECK: splat %{{.*}} : vector<17xi32> 1260// CHECK: %[[mask_b:.*]] = cmpi slt, {{.*}} : vector<17xi32> 1261// 1262// 4. Bitcast to vector form. 1263// CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} : 1264// CHECK-SAME: (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1265// CHECK: %[[vecPtr_b:.*]] = llvm.bitcast %[[gep_b]] : 1266// CHECK-SAME: !llvm.ptr<f32> to !llvm.ptr<vector<17xf32>> 1267// 1268// 5. Rewrite as a masked write. 1269// CHECK: llvm.intr.masked.store %[[loaded]], %[[vecPtr_b]], %[[mask_b]] 1270// CHECK-SAME: {alignment = 4 : i32} : 1271// CHECK-SAME: vector<17xf32>, vector<17xi1> into !llvm.ptr<vector<17xf32>> 1272 1273// ----- 1274 1275func @transfer_read_index_1d(%A : memref<?xindex>, %base: index) -> vector<17xindex> { 1276 %f7 = constant 7: index 1277 %f = vector.transfer_read %A[%base], %f7 1278 {permutation_map = affine_map<(d0) -> (d0)>} : 1279 memref<?xindex>, vector<17xindex> 1280 vector.transfer_write %f, %A[%base] 1281 {permutation_map = affine_map<(d0) -> (d0)>} : 1282 vector<17xindex>, memref<?xindex> 1283 return %f: vector<17xindex> 1284} 1285// CHECK-LABEL: func @transfer_read_index_1d 1286// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: index) -> vector<17xindex> 1287// CHECK: %[[C7:.*]] = constant 7 1288// CHECK: %{{.*}} = llvm.mlir.cast %[[C7]] : index to i64 1289 1290// CHECK: %[[loaded:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : 1291// CHECK-SAME: (!llvm.ptr<vector<17xi64>>, vector<17xi1>, vector<17xi64>) -> vector<17xi64> 1292 1293// CHECK: llvm.intr.masked.store %[[loaded]], %{{.*}}, %{{.*}} {alignment = 8 : i32} : 1294// CHECK-SAME: vector<17xi64>, vector<17xi1> into !llvm.ptr<vector<17xi64>> 1295 1296// ----- 1297 1298func @transfer_read_2d_to_1d(%A : memref<?x?xf32>, %base0: index, %base1: index) -> vector<17xf32> { 1299 %f7 = constant 7.0: f32 1300 %f = vector.transfer_read %A[%base0, %base1], %f7 1301 {permutation_map = affine_map<(d0, d1) -> (d1)>} : 1302 memref<?x?xf32>, vector<17xf32> 1303 return %f: vector<17xf32> 1304} 1305// CHECK-LABEL: func @transfer_read_2d_to_1d 1306// CHECK-SAME: %[[BASE_0:[a-zA-Z0-9]*]]: index, %[[BASE_1:[a-zA-Z0-9]*]]: index) -> vector<17xf32> 1307// CHECK: %[[c1:.*]] = constant 1 : index 1308// CHECK: %[[DIM:.*]] = memref.dim %{{.*}}, %[[c1]] : memref<?x?xf32> 1309// 1310// Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ]. 1311// CHECK: %[[trunc:.*]] = index_cast %[[BASE_1]] : index to i32 1312// CHECK: %[[offsetVec:.*]] = splat %[[trunc]] : vector<17xi32> 1313// 1314// Let dim the memref dimension, compute the vector comparison mask: 1315// [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ] 1316// CHECK: %[[dimtrunc:.*]] = index_cast %[[DIM]] : index to i32 1317// CHECK: splat %[[dimtrunc]] : vector<17xi32> 1318 1319// ----- 1320 1321func @transfer_read_1d_non_zero_addrspace(%A : memref<?xf32, 3>, %base: index) -> vector<17xf32> { 1322 %f7 = constant 7.0: f32 1323 %f = vector.transfer_read %A[%base], %f7 1324 {permutation_map = affine_map<(d0) -> (d0)>} : 1325 memref<?xf32, 3>, vector<17xf32> 1326 vector.transfer_write %f, %A[%base] 1327 {permutation_map = affine_map<(d0) -> (d0)>} : 1328 vector<17xf32>, memref<?xf32, 3> 1329 return %f: vector<17xf32> 1330} 1331// CHECK-LABEL: func @transfer_read_1d_non_zero_addrspace 1332// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: index) -> vector<17xf32> 1333// 1334// 1. Check address space for GEP is correct. 1335// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : 1336// CHECK-SAME: (!llvm.ptr<f32, 3>, i64) -> !llvm.ptr<f32, 3> 1337// CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] : 1338// CHECK-SAME: !llvm.ptr<f32, 3> to !llvm.ptr<vector<17xf32>, 3> 1339// 1340// 2. Check address space of the memref is correct. 1341// CHECK: %[[c0:.*]] = constant 0 : index 1342// CHECK: %[[DIM:.*]] = memref.dim %{{.*}}, %[[c0]] : memref<?xf32, 3> 1343// 1344// 3. Check address space for GEP is correct. 1345// CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} : 1346// CHECK-SAME: (!llvm.ptr<f32, 3>, i64) -> !llvm.ptr<f32, 3> 1347// CHECK: %[[vecPtr_b:.*]] = llvm.bitcast %[[gep_b]] : 1348// CHECK-SAME: !llvm.ptr<f32, 3> to !llvm.ptr<vector<17xf32>, 3> 1349 1350// ----- 1351 1352func @transfer_read_1d_inbounds(%A : memref<?xf32>, %base: index) -> vector<17xf32> { 1353 %f7 = constant 7.0: f32 1354 %f = vector.transfer_read %A[%base], %f7 {in_bounds = [true]} : 1355 memref<?xf32>, vector<17xf32> 1356 return %f: vector<17xf32> 1357} 1358// CHECK-LABEL: func @transfer_read_1d_inbounds 1359// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: index) -> vector<17xf32> 1360// 1361// 1. Bitcast to vector form. 1362// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : 1363// CHECK-SAME: (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1364// CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] : 1365// CHECK-SAME: !llvm.ptr<f32> to !llvm.ptr<vector<17xf32>> 1366// 1367// 2. Rewrite as a load. 1368// CHECK: %[[loaded:.*]] = llvm.load %[[vecPtr]] {alignment = 4 : i64} : !llvm.ptr<vector<17xf32>> 1369 1370// ----- 1371 1372// CHECK-LABEL: func @transfer_read_1d_mask 1373// CHECK: %[[mask1:.*]] = constant dense<[false, false, true, false, true]> 1374// CHECK: %[[cmpi:.*]] = cmpi slt 1375// CHECK: %[[mask2:.*]] = and %[[cmpi]], %[[mask1]] 1376// CHECK: %[[r:.*]] = llvm.intr.masked.load %{{.*}}, %[[mask2]] 1377// CHECK: return %[[r]] 1378func @transfer_read_1d_mask(%A : memref<?xf32>, %base : index) -> vector<5xf32> { 1379 %m = constant dense<[0, 0, 1, 0, 1]> : vector<5xi1> 1380 %f7 = constant 7.0: f32 1381 %f = vector.transfer_read %A[%base], %f7, %m : memref<?xf32>, vector<5xf32> 1382 return %f: vector<5xf32> 1383} 1384 1385// ----- 1386 1387func @transfer_read_1d_cast(%A : memref<?xi32>, %base: index) -> vector<12xi8> { 1388 %c0 = constant 0: i32 1389 %v = vector.transfer_read %A[%base], %c0 {in_bounds = [true]} : 1390 memref<?xi32>, vector<12xi8> 1391 return %v: vector<12xi8> 1392} 1393// CHECK-LABEL: func @transfer_read_1d_cast 1394// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: index) -> vector<12xi8> 1395// 1396// 1. Bitcast to vector form. 1397// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : 1398// CHECK-SAME: (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32> 1399// CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] : 1400// CHECK-SAME: !llvm.ptr<i32> to !llvm.ptr<vector<12xi8>> 1401// 1402// 2. Rewrite as a load. 1403// CHECK: %[[loaded:.*]] = llvm.load %[[vecPtr]] {alignment = 4 : i64} : !llvm.ptr<vector<12xi8>> 1404 1405// ----- 1406 1407func @genbool_1d() -> vector<8xi1> { 1408 %0 = vector.constant_mask [4] : vector<8xi1> 1409 return %0 : vector<8xi1> 1410} 1411// CHECK-LABEL: func @genbool_1d 1412// CHECK: %[[VAL_0:.*]] = constant dense<[true, true, true, true, false, false, false, false]> : vector<8xi1> 1413// CHECK: return %[[VAL_0]] : vector<8xi1> 1414 1415// ----- 1416 1417func @genbool_2d() -> vector<4x4xi1> { 1418 %v = vector.constant_mask [2, 2] : vector<4x4xi1> 1419 return %v: vector<4x4xi1> 1420} 1421 1422// CHECK-LABEL: func @genbool_2d 1423// CHECK: %[[VAL_0:.*]] = constant dense<[true, true, false, false]> : vector<4xi1> 1424// CHECK: %[[VAL_1:.*]] = constant dense<false> : vector<4x4xi1> 1425// CHECK: %[[VAL_2:.*]] = llvm.mlir.cast %[[VAL_1]] : vector<4x4xi1> to !llvm.array<4 x vector<4xi1>> 1426// CHECK: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_2]][0] : !llvm.array<4 x vector<4xi1>> 1427// CHECK: %[[VAL_4:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_3]][1] : !llvm.array<4 x vector<4xi1>> 1428// CHECK: %[[VAL_5:.*]] = llvm.mlir.cast %[[VAL_4]] : !llvm.array<4 x vector<4xi1>> to vector<4x4xi1> 1429// CHECK: return %[[VAL_5]] : vector<4x4xi1> 1430 1431// ----- 1432 1433func @flat_transpose(%arg0: vector<16xf32>) -> vector<16xf32> { 1434 %0 = vector.flat_transpose %arg0 { rows = 4: i32, columns = 4: i32 } 1435 : vector<16xf32> -> vector<16xf32> 1436 return %0 : vector<16xf32> 1437} 1438 1439// CHECK-LABEL: func @flat_transpose 1440// CHECK-SAME: %[[A:.*]]: vector<16xf32> 1441// CHECK: %[[T:.*]] = llvm.intr.matrix.transpose %[[A]] 1442// CHECK-SAME: {columns = 4 : i32, rows = 4 : i32} : 1443// CHECK-SAME: vector<16xf32> into vector<16xf32> 1444// CHECK: return %[[T]] : vector<16xf32> 1445 1446// ----- 1447 1448func @flat_transpose_index(%arg0: vector<16xindex>) -> vector<16xindex> { 1449 %0 = vector.flat_transpose %arg0 { rows = 4: i32, columns = 4: i32 } 1450 : vector<16xindex> -> vector<16xindex> 1451 return %0 : vector<16xindex> 1452} 1453// CHECK-LABEL: func @flat_transpose_index 1454// CHECK-SAME: %[[A:.*]]: vector<16xindex> 1455// CHECK: %[[T0:.*]] = llvm.mlir.cast %[[A]] : vector<16xindex> to vector<16xi64> 1456// CHECK: %[[T1:.*]] = llvm.intr.matrix.transpose %[[T0]] 1457// CHECK-SAME: {columns = 4 : i32, rows = 4 : i32} : 1458// CHECK-SAME: vector<16xi64> into vector<16xi64> 1459// CHECK: %[[T2:.*]] = llvm.mlir.cast %[[T1]] : vector<16xi64> to vector<16xindex> 1460// CHECK: return %[[T2]] : vector<16xindex> 1461 1462// ----- 1463 1464func @vector_load_op(%memref : memref<200x100xf32>, %i : index, %j : index) -> vector<8xf32> { 1465 %0 = vector.load %memref[%i, %j] : memref<200x100xf32>, vector<8xf32> 1466 return %0 : vector<8xf32> 1467} 1468 1469// CHECK-LABEL: func @vector_load_op 1470// CHECK: %[[c100:.*]] = llvm.mlir.constant(100 : index) : i64 1471// CHECK: %[[mul:.*]] = llvm.mul %{{.*}}, %[[c100]] : i64 1472// CHECK: %[[add:.*]] = llvm.add %[[mul]], %{{.*}} : i64 1473// CHECK: %[[gep:.*]] = llvm.getelementptr %{{.*}}[%[[add]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1474// CHECK: %[[bcast:.*]] = llvm.bitcast %[[gep]] : !llvm.ptr<f32> to !llvm.ptr<vector<8xf32>> 1475// CHECK: llvm.load %[[bcast]] {alignment = 4 : i64} : !llvm.ptr<vector<8xf32>> 1476 1477// ----- 1478 1479func @vector_load_op_index(%memref : memref<200x100xindex>, %i : index, %j : index) -> vector<8xindex> { 1480 %0 = vector.load %memref[%i, %j] : memref<200x100xindex>, vector<8xindex> 1481 return %0 : vector<8xindex> 1482} 1483// CHECK-LABEL: func @vector_load_op_index 1484// CHECK: %[[T0:.*]] = llvm.load %{{.*}} {alignment = 8 : i64} : !llvm.ptr<vector<8xi64>> 1485// CHECK: %[[T1:.*]] = llvm.mlir.cast %[[T0]] : vector<8xi64> to vector<8xindex> 1486// CHECK: return %[[T1]] : vector<8xindex> 1487 1488// ----- 1489 1490func @vector_store_op(%memref : memref<200x100xf32>, %i : index, %j : index) { 1491 %val = constant dense<11.0> : vector<4xf32> 1492 vector.store %val, %memref[%i, %j] : memref<200x100xf32>, vector<4xf32> 1493 return 1494} 1495 1496// CHECK-LABEL: func @vector_store_op 1497// CHECK: %[[c100:.*]] = llvm.mlir.constant(100 : index) : i64 1498// CHECK: %[[mul:.*]] = llvm.mul %{{.*}}, %[[c100]] : i64 1499// CHECK: %[[add:.*]] = llvm.add %[[mul]], %{{.*}} : i64 1500// CHECK: %[[gep:.*]] = llvm.getelementptr %{{.*}}[%[[add]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1501// CHECK: %[[bcast:.*]] = llvm.bitcast %[[gep]] : !llvm.ptr<f32> to !llvm.ptr<vector<4xf32>> 1502// CHECK: llvm.store %{{.*}}, %[[bcast]] {alignment = 4 : i64} : !llvm.ptr<vector<4xf32>> 1503 1504// ----- 1505 1506func @vector_store_op_index(%memref : memref<200x100xindex>, %i : index, %j : index) { 1507 %val = constant dense<11> : vector<4xindex> 1508 vector.store %val, %memref[%i, %j] : memref<200x100xindex>, vector<4xindex> 1509 return 1510} 1511// CHECK-LABEL: func @vector_store_op_index 1512// CHECK: llvm.store %{{.*}}, %{{.*}} {alignment = 8 : i64} : !llvm.ptr<vector<4xi64>> 1513 1514// ----- 1515 1516func @masked_load_op(%arg0: memref<?xf32>, %arg1: vector<16xi1>, %arg2: vector<16xf32>) -> vector<16xf32> { 1517 %c0 = constant 0: index 1518 %0 = vector.maskedload %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32> 1519 return %0 : vector<16xf32> 1520} 1521 1522// CHECK-LABEL: func @masked_load_op 1523// CHECK: %[[CO:.*]] = constant 0 : index 1524// CHECK: %[[C:.*]] = llvm.mlir.cast %[[CO]] : index to i64 1525// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1526// CHECK: %[[B:.*]] = llvm.bitcast %[[P]] : !llvm.ptr<f32> to !llvm.ptr<vector<16xf32>> 1527// CHECK: %[[L:.*]] = llvm.intr.masked.load %[[B]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.ptr<vector<16xf32>>, vector<16xi1>, vector<16xf32>) -> vector<16xf32> 1528// CHECK: return %[[L]] : vector<16xf32> 1529 1530// ----- 1531 1532func @masked_load_op_index(%arg0: memref<?xindex>, %arg1: vector<16xi1>, %arg2: vector<16xindex>) -> vector<16xindex> { 1533 %c0 = constant 0: index 1534 %0 = vector.maskedload %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<16xi1>, vector<16xindex> into vector<16xindex> 1535 return %0 : vector<16xindex> 1536} 1537// CHECK-LABEL: func @masked_load_op_index 1538// CHECK: %{{.*}} = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.ptr<vector<16xi64>>, vector<16xi1>, vector<16xi64>) -> vector<16xi64> 1539 1540// ----- 1541 1542func @masked_store_op(%arg0: memref<?xf32>, %arg1: vector<16xi1>, %arg2: vector<16xf32>) { 1543 %c0 = constant 0: index 1544 vector.maskedstore %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<16xi1>, vector<16xf32> 1545 return 1546} 1547 1548// CHECK-LABEL: func @masked_store_op 1549// CHECK: %[[CO:.*]] = constant 0 : index 1550// CHECK: %[[C:.*]] = llvm.mlir.cast %[[CO]] : index to i64 1551// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1552// CHECK: %[[B:.*]] = llvm.bitcast %[[P]] : !llvm.ptr<f32> to !llvm.ptr<vector<16xf32>> 1553// CHECK: llvm.intr.masked.store %{{.*}}, %[[B]], %{{.*}} {alignment = 4 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr<vector<16xf32>> 1554 1555// ----- 1556 1557func @masked_store_op_index(%arg0: memref<?xindex>, %arg1: vector<16xi1>, %arg2: vector<16xindex>) { 1558 %c0 = constant 0: index 1559 vector.maskedstore %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<16xi1>, vector<16xindex> 1560 return 1561} 1562// CHECK-LABEL: func @masked_store_op_index 1563// CHECK: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<16xi64>, vector<16xi1> into !llvm.ptr<vector<16xi64>> 1564 1565// ----- 1566 1567func @gather_op(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %arg2: vector<3xi1>, %arg3: vector<3xf32>) -> vector<3xf32> { 1568 %0 = constant 0: index 1569 %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 : memref<?xf32>, vector<3xi32>, vector<3xi1>, vector<3xf32> into vector<3xf32> 1570 return %1 : vector<3xf32> 1571} 1572 1573// CHECK-LABEL: func @gather_op 1574// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<f32>, vector<3xi32>) -> !llvm.vec<3 x ptr<f32>> 1575// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.vec<3 x ptr<f32>>, vector<3xi1>, vector<3xf32>) -> vector<3xf32> 1576// CHECK: return %[[G]] : vector<3xf32> 1577 1578// ----- 1579 1580func @gather_op_index(%arg0: memref<?xindex>, %arg1: vector<3xindex>, %arg2: vector<3xi1>, %arg3: vector<3xindex>) -> vector<3xindex> { 1581 %0 = constant 0: index 1582 %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 : memref<?xindex>, vector<3xindex>, vector<3xi1>, vector<3xindex> into vector<3xindex> 1583 return %1 : vector<3xindex> 1584} 1585 1586// CHECK-LABEL: func @gather_op_index 1587// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<i64>, vector<3xi64>) -> !llvm.vec<3 x ptr<i64>> 1588// CHECK: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.vec<3 x ptr<i64>>, vector<3xi1>, vector<3xi64>) -> vector<3xi64> 1589// CHECK: %{{.*}} = llvm.mlir.cast %[[G]] : vector<3xi64> to vector<3xindex> 1590 1591// ----- 1592 1593func @gather_2d_op(%arg0: memref<4x4xf32>, %arg1: vector<4xi32>, %arg2: vector<4xi1>, %arg3: vector<4xf32>) -> vector<4xf32> { 1594 %0 = constant 3 : index 1595 %1 = vector.gather %arg0[%0, %0][%arg1], %arg2, %arg3 : memref<4x4xf32>, vector<4xi32>, vector<4xi1>, vector<4xf32> into vector<4xf32> 1596 return %1 : vector<4xf32> 1597} 1598 1599// CHECK-LABEL: func @gather_2d_op 1600// CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1601// CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr<f32>, vector<4xi32>) -> !llvm.vec<4 x ptr<f32>> 1602// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.vec<4 x ptr<f32>>, vector<4xi1>, vector<4xf32>) -> vector<4xf32> 1603// CHECK: return %[[G]] : vector<4xf32> 1604 1605// ----- 1606 1607func @scatter_op(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %arg2: vector<3xi1>, %arg3: vector<3xf32>) { 1608 %0 = constant 0: index 1609 vector.scatter %arg0[%0][%arg1], %arg2, %arg3 : memref<?xf32>, vector<3xi32>, vector<3xi1>, vector<3xf32> 1610 return 1611} 1612 1613// CHECK-LABEL: func @scatter_op 1614// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<f32>, vector<3xi32>) -> !llvm.vec<3 x ptr<f32>> 1615// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<3xf32>, vector<3xi1> into !llvm.vec<3 x ptr<f32>> 1616 1617// ----- 1618 1619func @scatter_op_index(%arg0: memref<?xindex>, %arg1: vector<3xindex>, %arg2: vector<3xi1>, %arg3: vector<3xindex>) { 1620 %0 = constant 0: index 1621 vector.scatter %arg0[%0][%arg1], %arg2, %arg3 : memref<?xindex>, vector<3xindex>, vector<3xi1>, vector<3xindex> 1622 return 1623} 1624 1625// CHECK-LABEL: func @scatter_op_index 1626// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<i64>, vector<3xi64>) -> !llvm.vec<3 x ptr<i64>> 1627// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 8 : i32} : vector<3xi64>, vector<3xi1> into !llvm.vec<3 x ptr<i64>> 1628 1629// ----- 1630 1631func @scatter_2d_op(%arg0: memref<4x4xf32>, %arg1: vector<4xi32>, %arg2: vector<4xi1>, %arg3: vector<4xf32>) { 1632 %0 = constant 3 : index 1633 vector.scatter %arg0[%0, %0][%arg1], %arg2, %arg3 : memref<4x4xf32>, vector<4xi32>, vector<4xi1>, vector<4xf32> 1634 return 1635} 1636 1637// CHECK-LABEL: func @scatter_2d_op 1638// CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1639// CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr<f32>, vector<4xi32>) -> !llvm.vec<4 x ptr<f32>> 1640// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<4xf32>, vector<4xi1> into !llvm.vec<4 x ptr<f32>> 1641 1642// ----- 1643 1644func @expand_load_op(%arg0: memref<?xf32>, %arg1: vector<11xi1>, %arg2: vector<11xf32>) -> vector<11xf32> { 1645 %c0 = constant 0: index 1646 %0 = vector.expandload %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<11xi1>, vector<11xf32> into vector<11xf32> 1647 return %0 : vector<11xf32> 1648} 1649 1650// CHECK-LABEL: func @expand_load_op 1651// CHECK: %[[CO:.*]] = constant 0 : index 1652// CHECK: %[[C:.*]] = llvm.mlir.cast %[[CO]] : index to i64 1653// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1654// CHECK: %[[E:.*]] = "llvm.intr.masked.expandload"(%[[P]], %{{.*}}, %{{.*}}) : (!llvm.ptr<f32>, vector<11xi1>, vector<11xf32>) -> vector<11xf32> 1655// CHECK: return %[[E]] : vector<11xf32> 1656 1657// ----- 1658 1659func @expand_load_op_index(%arg0: memref<?xindex>, %arg1: vector<11xi1>, %arg2: vector<11xindex>) -> vector<11xindex> { 1660 %c0 = constant 0: index 1661 %0 = vector.expandload %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<11xi1>, vector<11xindex> into vector<11xindex> 1662 return %0 : vector<11xindex> 1663} 1664// CHECK-LABEL: func @expand_load_op_index 1665// CHECK: %{{.*}} = "llvm.intr.masked.expandload"(%{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i64>, vector<11xi1>, vector<11xi64>) -> vector<11xi64> 1666 1667// ----- 1668 1669func @compress_store_op(%arg0: memref<?xf32>, %arg1: vector<11xi1>, %arg2: vector<11xf32>) { 1670 %c0 = constant 0: index 1671 vector.compressstore %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<11xi1>, vector<11xf32> 1672 return 1673} 1674 1675// CHECK-LABEL: func @compress_store_op 1676// CHECK: %[[CO:.*]] = constant 0 : index 1677// CHECK: %[[C:.*]] = llvm.mlir.cast %[[CO]] : index to i64 1678// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> 1679// CHECK: "llvm.intr.masked.compressstore"(%{{.*}}, %[[P]], %{{.*}}) : (vector<11xf32>, !llvm.ptr<f32>, vector<11xi1>) -> () 1680 1681// ----- 1682 1683func @compress_store_op_index(%arg0: memref<?xindex>, %arg1: vector<11xi1>, %arg2: vector<11xindex>) { 1684 %c0 = constant 0: index 1685 vector.compressstore %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<11xi1>, vector<11xindex> 1686 return 1687} 1688// CHECK-LABEL: func @compress_store_op_index 1689// CHECK: "llvm.intr.masked.compressstore"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<11xi64>, !llvm.ptr<i64>, vector<11xi1>) -> () 1690