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