1560 lines · plain
1// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py2// RUN: mlir-opt %s --sparse-reinterpret-map -sparsification | FileCheck %s3 4#DV = #sparse_tensor.encoding<{ map = (d0) -> (d0 : dense) }>5#SV = #sparse_tensor.encoding<{ map = (d0) -> (d0 : compressed) }>6 7#trait1 = {8 indexing_maps = [9 affine_map<(i) -> (i)>, // a10 affine_map<(i) -> (i)> // x (out)11 ],12 iterator_types = ["parallel"],13 doc = "x(i) = a(i) OP b"14}15 16// CHECK-LABEL: func @add_d(17// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,18// CHECK-SAME: %[[VAL_1:.*]]: f32,19// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {20// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index21// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index22// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index23// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>24// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_buffer %[[VAL_2]]25// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_8]] : memref<32xf32>)26// CHECK: scf.for %[[VAL_9:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {27// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<?xf32>28// CHECK: %[[VAL_11:.*]] = arith.addf %[[VAL_10]], %[[VAL_1]] : f3229// CHECK: memref.store %[[VAL_11]], %[[VAL_8]]{{\[}}%[[VAL_9]]] : memref<32xf32>30// CHECK: }31// CHECK: %[[VAL_12:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<32xf32>32// CHECK: return %[[VAL_12]] : tensor<32xf32>33// CHECK: }34func.func @add_d(%arga: tensor<32xf32, #DV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> {35 %0 = linalg.generic #trait136 ins(%arga: tensor<32xf32, #DV>)37 outs(%argx: tensor<32xf32>) {38 ^bb(%a: f32, %x: f32):39 %0 = arith.addf %a, %argb : f3240 linalg.yield %0 : f3241 } -> tensor<32xf32>42 return %0 : tensor<32xf32>43}44 45// CHECK-LABEL: func @add_d_init(46// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,47// CHECK-SAME: %[[VAL_1:.*]]: f32) -> tensor<32xf32> {48// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 32 : index49// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0.000000e+00 : f3250// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index51// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index52// CHECK: %[[VAL_INITTENSOR:.*]] = tensor.empty() : tensor<32xf32>53// CHECK: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>54// CHECK: %[[VAL_7:.*]] = bufferization.to_buffer %[[VAL_INITTENSOR]] : tensor<32xf32> to memref<32xf32>55// CHECK: linalg.fill ins(%[[VAL_3]] : f32) outs(%[[VAL_7]] : memref<32xf32>)56// CHECK: scf.for %[[VAL_8:.*]] = %[[VAL_4]] to %[[VAL_2]] step %[[VAL_5]] {57// CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_8]]] : memref<?xf32>58// CHECK: %[[VAL_10:.*]] = arith.addf %[[VAL_9]], %[[VAL_1]] : f3259// CHECK: memref.store %[[VAL_10]], %[[VAL_7]]{{\[}}%[[VAL_8]]] : memref<32xf32>60// CHECK: }61// CHECK: %[[VAL_11:.*]] = bufferization.to_tensor %[[VAL_7]] : memref<32xf32>62// CHECK: return %[[VAL_11]] : tensor<32xf32>63// CHECK: }64func.func @add_d_init(%arga: tensor<32xf32, #DV>, %argb: f32) -> tensor<32xf32> {65 %u = tensor.empty() : tensor<32xf32>66 %0 = linalg.generic #trait167 ins(%arga: tensor<32xf32, #DV>)68 outs(%u: tensor<32xf32>) {69 ^bb(%a: f32, %x: f32):70 %0 = arith.addf %a, %argb : f3271 linalg.yield %0 : f3272 } -> tensor<32xf32>73 return %0 : tensor<32xf32>74}75 76// CHECK-LABEL: func @mul_d(77// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,78// CHECK-SAME: %[[VAL_1:.*]]: f32,79// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {80// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index81// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index82// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index83// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>84// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_buffer %[[VAL_2]]85// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_8]] : memref<32xf32>)86// CHECK: scf.for %[[VAL_9:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {87// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<?xf32>88// CHECK: %[[VAL_11:.*]] = arith.mulf %[[VAL_10]], %[[VAL_1]] : f3289// CHECK: memref.store %[[VAL_11]], %[[VAL_8]]{{\[}}%[[VAL_9]]] : memref<32xf32>90// CHECK: }91// CHECK: %[[VAL_12:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<32xf32>92// CHECK: return %[[VAL_12]] : tensor<32xf32>93// CHECK: }94func.func @mul_d(%arga: tensor<32xf32, #DV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> {95 %0 = linalg.generic #trait196 ins(%arga: tensor<32xf32, #DV>)97 outs(%argx: tensor<32xf32>) {98 ^bb(%a: f32, %x: f32):99 %0 = arith.mulf %a, %argb : f32100 linalg.yield %0 : f32101 } -> tensor<32xf32>102 return %0 : tensor<32xf32>103}104 105// CHECK-LABEL: func @add_s(106// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,107// CHECK-SAME: %[[VAL_1:.*]]: f32,108// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {109// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index110// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index111// CHECK-DAG: %[[VAL_5:.*]] = arith.constant true112// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index113// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>114// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>115// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>116// CHECK-DAG: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex>117// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>118// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_buffer %[[VAL_2]]119// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_11]] : memref<32xf32>)120// CHECK: %[[VAL_14:.*]]:2 = scf.while (%[[VAL_15:.*]] = %[[VAL_12]], %[[VAL_16:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) {121// CHECK: %[[VAL_17:.*]] = arith.cmpi ult, %[[VAL_15]], %[[VAL_13]] : index122// CHECK: scf.condition(%[[VAL_17]]) %[[VAL_15]], %[[VAL_16]] : index, index123// CHECK: } do {124// CHECK: ^bb0(%[[VAL_18:.*]]: index, %[[VAL_19:.*]]: index):125// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_18]]] : memref<?xindex>126// CHECK: %[[VAL_21:.*]] = arith.cmpi eq, %[[VAL_20]], %[[VAL_19]] : index127// CHECK: scf.if %[[VAL_21]] {128// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_18]]] : memref<?xf32>129// CHECK: %[[VAL_23:.*]] = arith.addf %[[VAL_22]], %[[VAL_1]] : f32130// CHECK: memref.store %[[VAL_23]], %[[VAL_11]]{{\[}}%[[VAL_19]]] : memref<32xf32>131// CHECK: } else {132// CHECK: scf.if %[[VAL_5]] {133// CHECK: memref.store %[[VAL_1]], %[[VAL_11]]{{\[}}%[[VAL_19]]] : memref<32xf32>134// CHECK: } else {135// CHECK: }136// CHECK: }137// CHECK: %[[VAL_24:.*]] = arith.cmpi eq, %[[VAL_20]], %[[VAL_19]] : index138// CHECK: %[[VAL_25:.*]] = arith.addi %[[VAL_18]], %[[VAL_6]] : index139// CHECK: %[[VAL_26:.*]] = arith.select %[[VAL_24]], %[[VAL_25]], %[[VAL_18]] : index140// CHECK: %[[VAL_27:.*]] = arith.addi %[[VAL_19]], %[[VAL_6]] : index141// CHECK: scf.yield %[[VAL_26]], %[[VAL_27]] : index, index142// CHECK: }143// CHECK: scf.for %[[VAL_28:.*]] = %[[VAL_29:.*]]#1 to %[[VAL_3]] step %[[VAL_6]] {144// CHECK: memref.store %[[VAL_1]], %[[VAL_11]]{{\[}}%[[VAL_28]]] : memref<32xf32>145// CHECK: }146// CHECK: %[[VAL_30:.*]] = bufferization.to_tensor %[[VAL_11]] : memref<32xf32>147// CHECK: return %[[VAL_30]] : tensor<32xf32>148// CHECK: }149func.func @add_s(%arga: tensor<32xf32, #SV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> {150 %0 = linalg.generic #trait1151 ins(%arga: tensor<32xf32, #SV>)152 outs(%argx: tensor<32xf32>) {153 ^bb(%a: f32, %x: f32):154 %0 = arith.addf %a, %argb : f32155 linalg.yield %0 : f32156 } -> tensor<32xf32>157 return %0 : tensor<32xf32>158}159 160// CHECK-LABEL: func @repeated_add_s(161// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,162// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>) -> tensor<32xf32> {163// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index164// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index165// CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>166// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>167// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>168// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_buffer %[[VAL_1]]169// CHECK-DAG: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>170// CHECK-DAG: %[[VAL_10:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>171// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_8]] : memref<32xf32>)172// CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_3]] {173// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xindex>174// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32>175// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32>176// CHECK: %[[VAL_15:.*]] = arith.addf %[[VAL_13]], %[[VAL_14]] : f32177// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32>178// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32>179// CHECK: %[[VAL_18:.*]] = arith.addf %[[VAL_16]], %[[VAL_17]] : f32180// CHECK: %[[VAL_19:.*]] = arith.addf %[[VAL_15]], %[[VAL_18]] : f32181// CHECK: memref.store %[[VAL_19]], %[[VAL_8]]{{\[}}%[[VAL_12]]] : memref<32xf32>182// CHECK: }183// CHECK: %[[VAL_20:.*]] = bufferization.to_tensor %[[VAL_8]] : memref<32xf32>184// CHECK: return %[[VAL_20]] : tensor<32xf32>185// CHECK: }186func.func @repeated_add_s(%arga: tensor<32xf32, #SV>, %argx: tensor<32xf32>) -> tensor<32xf32> {187 %0 = linalg.generic #trait1188 ins(%arga: tensor<32xf32, #SV>)189 outs(%argx: tensor<32xf32>) {190 ^bb(%a: f32, %x: f32):191 %0 = arith.addf %a, %a : f32 // same tensor192 %1 = arith.addf %a, %a : f32 // should yield193 %2 = arith.addf %0, %1 : f32 // one guard194 linalg.yield %2 : f32195 } -> tensor<32xf32>196 return %0 : tensor<32xf32>197}198 199// CHECK-LABEL: func @mul_s(200// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,201// CHECK-SAME: %[[VAL_1:.*]]: f32,202// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {203// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index204// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index205// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>206// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>207// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>208// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_buffer %[[VAL_2]]209// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_9]] : memref<32xf32>)210// CHECK-DAG: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>211// CHECK-DAG: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>212// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_4]] {213// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex>214// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_12]]] : memref<?xf32>215// CHECK: %[[VAL_15:.*]] = arith.mulf %[[VAL_14]], %[[VAL_1]] : f32216// CHECK: memref.store %[[VAL_15]], %[[VAL_9]]{{\[}}%[[VAL_13]]] : memref<32xf32>217// CHECK: }218// CHECK: %[[VAL_16:.*]] = bufferization.to_tensor %[[VAL_9]] : memref<32xf32>219// CHECK: return %[[VAL_16]] : tensor<32xf32>220// CHECK: }221func.func @mul_s(%arga: tensor<32xf32, #SV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> {222 %0 = linalg.generic #trait1223 ins(%arga: tensor<32xf32, #SV>)224 outs(%argx: tensor<32xf32>) {225 ^bb(%a: f32, %x: f32):226 %0 = arith.mulf %a, %argb : f32227 linalg.yield %0 : f32228 } -> tensor<32xf32>229 return %0 : tensor<32xf32>230}231 232#trait2 = {233 indexing_maps = [234 affine_map<(i) -> (i)>, // a235 affine_map<(i) -> (i)>, // b236 affine_map<(i) -> (i)> // x (out)237 ],238 iterator_types = ["parallel"],239 doc = "x(i) = a(i) OP b(i)"240}241 242// CHECK-LABEL: func @add_dd(243// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,244// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>,245// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {246// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index247// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index248// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index249// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>250// CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_buffer %[[VAL_1]] : tensor<32xf32> to memref<32xf32>251// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_buffer %[[VAL_2]]252// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_9]] : memref<32xf32>)253// CHECK: scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {254// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xf32>255// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<32xf32>256// CHECK: %[[VAL_13:.*]] = arith.addf %[[VAL_11]], %[[VAL_12]] : f32257// CHECK: memref.store %[[VAL_13]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<32xf32>258// CHECK: }259// CHECK: %[[VAL_14:.*]] = bufferization.to_tensor %[[VAL_9]] : memref<32xf32>260// CHECK: return %[[VAL_14]] : tensor<32xf32>261// CHECK: }262func.func @add_dd(%arga: tensor<32xf32, #DV>, %argb: tensor<32xf32>, %argx: tensor<32xf32>) -> tensor<32xf32> {263 %0 = linalg.generic #trait2264 ins(%arga, %argb: tensor<32xf32, #DV>, tensor<32xf32>)265 outs(%argx: tensor<32xf32>) {266 ^bb(%a: f32, %b: f32, %x: f32):267 %0 = arith.addf %a, %b : f32268 linalg.yield %0 : f32269 } -> tensor<32xf32>270 return %0 : tensor<32xf32>271}272 273// CHECK-LABEL: func @mul_dd(274// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,275// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>,276// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {277// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index278// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index279// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index280// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>281// CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_buffer %[[VAL_1]] : tensor<32xf32> to memref<32xf32>282// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_buffer %[[VAL_2]]283// CHECK: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_9]] : memref<32xf32>)284// CHECK: scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {285// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xf32>286// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<32xf32>287// CHECK: %[[VAL_13:.*]] = arith.mulf %[[VAL_11]], %[[VAL_12]] : f32288// CHECK: memref.store %[[VAL_13]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<32xf32>289// CHECK: }290// CHECK: %[[VAL_14:.*]] = bufferization.to_tensor %[[VAL_9]] : memref<32xf32>291// CHECK: return %[[VAL_14]] : tensor<32xf32>292// CHECK: }293func.func @mul_dd(%arga: tensor<32xf32, #DV>, %argb: tensor<32xf32>, %argx: tensor<32xf32>) -> tensor<32xf32> {294 %0 = linalg.generic #trait2295 ins(%arga, %argb: tensor<32xf32, #DV>, tensor<32xf32>)296 outs(%argx: tensor<32xf32>) {297 ^bb(%a: f32, %b: f32, %x: f32):298 %0 = arith.mulf %a, %b : f32299 linalg.yield %0 : f32300 } -> tensor<32xf32>301 return %0 : tensor<32xf32>302}303 304// CHECK-LABEL: func @add_ds(305// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32>,306// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,307// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {308// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index309// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index310// CHECK-DAG: %[[VAL_5:.*]] = arith.constant true311// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index312// CHECK-DAG: %[[VAL_7:.*]] = bufferization.to_buffer %[[VAL_0]] : tensor<32xf32> to memref<32xf32>313// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>314// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>315// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>316// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_buffer %[[VAL_2]]317// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>)318// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>319// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex>320// CHECK: %[[VAL_15:.*]]:2 = scf.while (%[[VAL_16:.*]] = %[[VAL_13]], %[[VAL_17:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) {321// CHECK: %[[VAL_18:.*]] = arith.cmpi ult, %[[VAL_16]], %[[VAL_14]] : index322// CHECK: scf.condition(%[[VAL_18]]) %[[VAL_16]], %[[VAL_17]] : index, index323// CHECK: } do {324// CHECK: ^bb0(%[[VAL_19:.*]]: index, %[[VAL_20:.*]]: index):325// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_19]]] : memref<?xindex>326// CHECK: %[[VAL_22:.*]] = arith.cmpi eq, %[[VAL_21]], %[[VAL_20]] : index327// CHECK: scf.if %[[VAL_22]] {328// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_20]]] : memref<32xf32>329// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_19]]] : memref<?xf32>330// CHECK: %[[VAL_25:.*]] = arith.addf %[[VAL_23]], %[[VAL_24]] : f32331// CHECK: memref.store %[[VAL_25]], %[[VAL_12]]{{\[}}%[[VAL_20]]] : memref<32xf32>332// CHECK: } else {333// CHECK: scf.if %[[VAL_5]] {334// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_20]]] : memref<32xf32>335// CHECK: memref.store %[[VAL_26]], %[[VAL_12]]{{\[}}%[[VAL_20]]] : memref<32xf32>336// CHECK: } else {337// CHECK: }338// CHECK: }339// CHECK: %[[VAL_27:.*]] = arith.cmpi eq, %[[VAL_21]], %[[VAL_20]] : index340// CHECK: %[[VAL_28:.*]] = arith.addi %[[VAL_19]], %[[VAL_6]] : index341// CHECK: %[[VAL_29:.*]] = arith.select %[[VAL_27]], %[[VAL_28]], %[[VAL_19]] : index342// CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_20]], %[[VAL_6]] : index343// CHECK: scf.yield %[[VAL_29]], %[[VAL_30]] : index, index344// CHECK: }345// CHECK: scf.for %[[VAL_31:.*]] = %[[VAL_32:.*]]#1 to %[[VAL_3]] step %[[VAL_6]] {346// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_31]]] : memref<32xf32>347// CHECK: memref.store %[[VAL_33]], %[[VAL_12]]{{\[}}%[[VAL_31]]] : memref<32xf32>348// CHECK: }349// CHECK: %[[VAL_34:.*]] = bufferization.to_tensor %[[VAL_12]] : memref<32xf32>350// CHECK: return %[[VAL_34]] : tensor<32xf32>351// CHECK: }352func.func @add_ds(%arga: tensor<32xf32>, %argb: tensor<32xf32, #SV>, %argx: tensor<32xf32>) -> tensor<32xf32> {353 %0 = linalg.generic #trait2354 ins(%arga, %argb: tensor<32xf32>, tensor<32xf32, #SV>)355 outs(%argx: tensor<32xf32>) {356 ^bb(%a: f32, %b: f32, %x: f32):357 %0 = arith.addf %a, %b : f32358 linalg.yield %0 : f32359 } -> tensor<32xf32>360 return %0 : tensor<32xf32>361}362 363// CHECK-LABEL: func @mul_ds(364// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32>,365// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,366// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {367// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index368// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index369// CHECK-DAG: %[[VAL_5:.*]] = bufferization.to_buffer %[[VAL_0]] : tensor<32xf32> to memref<32xf32>370// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>371// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>372// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>373// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_buffer %[[VAL_2]]374// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_10]] : memref<32xf32>)375// CHECK-DAG: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_3]]] : memref<?xindex>376// CHECK-DAG: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>377// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] {378// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex>379// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_14]]] : memref<32xf32>380// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_13]]] : memref<?xf32>381// CHECK: %[[VAL_17:.*]] = arith.mulf %[[VAL_15]], %[[VAL_16]] : f32382// CHECK: memref.store %[[VAL_17]], %[[VAL_10]]{{\[}}%[[VAL_14]]] : memref<32xf32>383// CHECK: }384// CHECK: %[[VAL_18:.*]] = bufferization.to_tensor %[[VAL_10]] : memref<32xf32>385// CHECK: return %[[VAL_18]] : tensor<32xf32>386// CHECK: }387func.func @mul_ds(%arga: tensor<32xf32>, %argb: tensor<32xf32, #SV>, %argx: tensor<32xf32>) -> tensor<32xf32> {388 %0 = linalg.generic #trait2389 ins(%arga, %argb: tensor<32xf32>, tensor<32xf32, #SV>)390 outs(%argx: tensor<32xf32>) {391 ^bb(%a: f32, %b: f32, %x: f32):392 %0 = arith.mulf %a, %b : f32393 linalg.yield %0 : f32394 } -> tensor<32xf32>395 return %0 : tensor<32xf32>396}397 398// CHECK-LABEL: func @add_sd(399// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,400// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>,401// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {402// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 32 : index403// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index404// CHECK-DAG: %[[VAL_5:.*]] = arith.constant true405// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index406// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>407// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>408// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>409// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_buffer %[[VAL_1]] : tensor<32xf32> to memref<32xf32>410// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_buffer %[[VAL_2]]411// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>)412// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex>413// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>414// CHECK: %[[VAL_15:.*]]:2 = scf.while (%[[VAL_16:.*]] = %[[VAL_13]], %[[VAL_17:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) {415// CHECK: %[[VAL_18:.*]] = arith.cmpi ult, %[[VAL_16]], %[[VAL_14]] : index416// CHECK: scf.condition(%[[VAL_18]]) %[[VAL_16]], %[[VAL_17]] : index, index417// CHECK: } do {418// CHECK: ^bb0(%[[VAL_19:.*]]: index, %[[VAL_20:.*]]: index):419// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_19]]] : memref<?xindex>420// CHECK: %[[VAL_22:.*]] = arith.cmpi eq, %[[VAL_21]], %[[VAL_20]] : index421// CHECK: scf.if %[[VAL_22]] {422// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_19]]] : memref<?xf32>423// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_20]]] : memref<32xf32>424// CHECK: %[[VAL_25:.*]] = arith.addf %[[VAL_23]], %[[VAL_24]] : f32425// CHECK: memref.store %[[VAL_25]], %[[VAL_12]]{{\[}}%[[VAL_20]]] : memref<32xf32>426// CHECK: } else {427// CHECK: scf.if %[[VAL_5]] {428// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_20]]] : memref<32xf32>429// CHECK: memref.store %[[VAL_26]], %[[VAL_12]]{{\[}}%[[VAL_20]]] : memref<32xf32>430// CHECK: } else {431// CHECK: }432// CHECK: }433// CHECK: %[[VAL_27:.*]] = arith.cmpi eq, %[[VAL_21]], %[[VAL_20]] : index434// CHECK: %[[VAL_28:.*]] = arith.addi %[[VAL_19]], %[[VAL_6]] : index435// CHECK: %[[VAL_29:.*]] = arith.select %[[VAL_27]], %[[VAL_28]], %[[VAL_19]] : index436// CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_20]], %[[VAL_6]] : index437// CHECK: scf.yield %[[VAL_29]], %[[VAL_30]] : index, index438// CHECK: }439// CHECK: scf.for %[[VAL_31:.*]] = %[[VAL_32:.*]]#1 to %[[VAL_3]] step %[[VAL_6]] {440// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_31]]] : memref<32xf32>441// CHECK: memref.store %[[VAL_33]], %[[VAL_12]]{{\[}}%[[VAL_31]]] : memref<32xf32>442// CHECK: }443// CHECK: %[[VAL_34:.*]] = bufferization.to_tensor %[[VAL_12]] : memref<32xf32>444// CHECK: return %[[VAL_34]] : tensor<32xf32>445// CHECK: }446func.func @add_sd(%arga: tensor<32xf32, #SV>, %argb: tensor<32xf32>, %argx: tensor<32xf32>) -> tensor<32xf32> {447 %0 = linalg.generic #trait2448 ins(%arga, %argb: tensor<32xf32, #SV>, tensor<32xf32>)449 outs(%argx: tensor<32xf32>) {450 ^bb(%a: f32, %b: f32, %x: f32):451 %0 = arith.addf %a, %b : f32452 linalg.yield %0 : f32453 } -> tensor<32xf32>454 return %0 : tensor<32xf32>455}456 457// CHECK-LABEL: func @mul_sd(458// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse{{[0-9]*}}>,459// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>,460// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {461// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index462// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index463// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>464// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>465// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>466// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_buffer %[[VAL_1]] : tensor<32xf32> to memref<32xf32>467// CHECK-DAG: %[[VAL_10:.*]] = bufferization.to_buffer %[[VAL_2]]468// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_10]] : memref<32xf32>)469// CHECK-DAG: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>470// CHECK-DAG: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>471// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] {472// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex>473// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xf32>474// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_14]]] : memref<32xf32>475// CHECK: %[[VAL_17:.*]] = arith.mulf %[[VAL_15]], %[[VAL_16]] : f32476// CHECK: memref.store %[[VAL_17]], %[[VAL_10]]{{\[}}%[[VAL_14]]] : memref<32xf32>477// CHECK: }478// CHECK: %[[VAL_18:.*]] = bufferization.to_tensor %[[VAL_10]] : memref<32xf32>479// CHECK: return %[[VAL_18]] : tensor<32xf32>480// CHECK: }481func.func @mul_sd(%arga: tensor<32xf32, #SV>, %argb: tensor<32xf32>, %argx: tensor<32xf32>) -> tensor<32xf32> {482 %0 = linalg.generic #trait2483 ins(%arga, %argb: tensor<32xf32, #SV>, tensor<32xf32>)484 outs(%argx: tensor<32xf32>) {485 ^bb(%a: f32, %b: f32, %x: f32):486 %0 = arith.mulf %a, %b : f32487 linalg.yield %0 : f32488 } -> tensor<32xf32>489 return %0 : tensor<32xf32>490}491 492// CHECK-LABEL: func @add_ss(493// CHECK-SAME: %[[VAL_0:.*0]]: tensor<32xf32, #sparse{{[0-9]*}}>, %[[VAL_1:.*1]]: tensor<32xf32, #sparse{{[0-9]*}}>,494// CHECK-SAME: %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> {495// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index496// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index497// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>498// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>499// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>500// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>501// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>502// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>503// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_buffer %[[VAL_2]]504// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>)505// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>506// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>507// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>508// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>509// CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) {510// CHECK: %[[VAL_20:.*]] = arith.cmpi ult, %[[VAL_18]], %[[VAL_14]] : index511// CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_16]] : index512// CHECK: %[[VAL_22:.*]] = arith.andi %[[VAL_20]], %[[VAL_21]] : i1513// CHECK: scf.condition(%[[VAL_22]]) %[[VAL_18]], %[[VAL_19]] : index, index514// CHECK: } do {515// CHECK: ^bb0(%[[VAL_23:.*]]: index, %[[VAL_24:.*]]: index):516// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_23]]] : memref<?xindex>517// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_24]]] : memref<?xindex>518// CHECK: %[[VAL_27:.*]] = arith.cmpi ult, %[[VAL_26]], %[[VAL_25]] : index519// CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_26]], %[[VAL_25]] : index520// CHECK: %[[VAL_29:.*]] = arith.cmpi eq, %[[VAL_25]], %[[VAL_28]] : index521// CHECK: %[[VAL_30:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_28]] : index522// CHECK: %[[VAL_31:.*]] = arith.andi %[[VAL_29]], %[[VAL_30]] : i1523// CHECK: scf.if %[[VAL_31]] {524// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_23]]] : memref<?xf32>525// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_24]]] : memref<?xf32>526// CHECK: %[[VAL_34:.*]] = arith.addf %[[VAL_32]], %[[VAL_33]] : f32527// CHECK: memref.store %[[VAL_34]], %[[VAL_12]]{{\[}}%[[VAL_28]]] : memref<32xf32>528// CHECK: } else {529// CHECK: %[[VAL_35:.*]] = arith.cmpi eq, %[[VAL_25]], %[[VAL_28]] : index530// CHECK: scf.if %[[VAL_35]] {531// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_23]]] : memref<?xf32>532// CHECK: memref.store %[[VAL_36]], %[[VAL_12]]{{\[}}%[[VAL_28]]] : memref<32xf32>533// CHECK: } else {534// CHECK: %[[VAL_37:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_28]] : index535// CHECK: scf.if %[[VAL_37]] {536// CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_24]]] : memref<?xf32>537// CHECK: memref.store %[[VAL_38]], %[[VAL_12]]{{\[}}%[[VAL_28]]] : memref<32xf32>538// CHECK: } else {539// CHECK: }540// CHECK: }541// CHECK: }542// CHECK: %[[VAL_39:.*]] = arith.cmpi eq, %[[VAL_25]], %[[VAL_28]] : index543// CHECK: %[[VAL_40:.*]] = arith.addi %[[VAL_23]], %[[VAL_4]] : index544// CHECK: %[[VAL_41:.*]] = arith.select %[[VAL_39]], %[[VAL_40]], %[[VAL_23]] : index545// CHECK: %[[VAL_42:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_28]] : index546// CHECK: %[[VAL_43:.*]] = arith.addi %[[VAL_24]], %[[VAL_4]] : index547// CHECK: %[[VAL_44:.*]] = arith.select %[[VAL_42]], %[[VAL_43]], %[[VAL_24]] : index548// CHECK: scf.yield %[[VAL_41]], %[[VAL_44]] : index, index549// CHECK: }550// CHECK: scf.for %[[VAL_45:.*]] = %[[VAL_46:.*]]#0 to %[[VAL_14]] step %[[VAL_4]] {551// CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_45]]] : memref<?xindex>552// CHECK: %[[VAL_48:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_45]]] : memref<?xf32>553// CHECK: memref.store %[[VAL_48]], %[[VAL_12]]{{\[}}%[[VAL_47]]] : memref<32xf32>554// CHECK: }555// CHECK: scf.for %[[VAL_49:.*]] = %[[VAL_50:.*]]#1 to %[[VAL_16]] step %[[VAL_4]] {556// CHECK: %[[VAL_51:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_49]]] : memref<?xindex>557// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_49]]] : memref<?xf32>558// CHECK: memref.store %[[VAL_52]], %[[VAL_12]]{{\[}}%[[VAL_51]]] : memref<32xf32>559// CHECK: }560// CHECK: %[[VAL_53:.*]] = bufferization.to_tensor %[[VAL_12]] : memref<32xf32>561// CHECK: return %[[VAL_53]] : tensor<32xf32>562// CHECK: }563func.func @add_ss(%arga: tensor<32xf32, #SV>, %argb: tensor<32xf32, #SV>, %argx: tensor<32xf32>) -> tensor<32xf32> {564 %0 = linalg.generic #trait2565 ins(%arga, %argb: tensor<32xf32, #SV>, tensor<32xf32, #SV>)566 outs(%argx: tensor<32xf32>) {567 ^bb(%a: f32, %b: f32, %x: f32):568 %0 = arith.addf %a, %b : f32569 linalg.yield %0 : f32570 } -> tensor<32xf32>571 return %0 : tensor<32xf32>572}573 574// CHECK-LABEL: func @mul_ss(575// CHECK-SAME: %[[VAL_0:.*0]]: tensor<32xf32, #sparse{{[0-9]*}}>, %[[VAL_1:.*1]]: tensor<32xf32, #sparse{{[0-9]*}}>,576// CHECK-SAME: %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> {577// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index578// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index579// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>580// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>581// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>582// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>583// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xindex>584// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse{{[0-9]*}}> to memref<?xf32>585// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_buffer %[[VAL_2]]586// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_12]] : memref<32xf32>)587// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>588// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>589// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>590// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>591// CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) {592// CHECK: %[[VAL_20:.*]] = arith.cmpi ult, %[[VAL_18]], %[[VAL_14]] : index593// CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_16]] : index594// CHECK: %[[VAL_22:.*]] = arith.andi %[[VAL_20]], %[[VAL_21]] : i1595// CHECK: scf.condition(%[[VAL_22]]) %[[VAL_18]], %[[VAL_19]] : index, index596// CHECK: } do {597// CHECK: ^bb0(%[[VAL_23:.*]]: index, %[[VAL_24:.*]]: index):598// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_23]]] : memref<?xindex>599// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_24]]] : memref<?xindex>600// CHECK: %[[VAL_27:.*]] = arith.cmpi ult, %[[VAL_26]], %[[VAL_25]] : index601// CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_26]], %[[VAL_25]] : index602// CHECK: %[[VAL_29:.*]] = arith.cmpi eq, %[[VAL_25]], %[[VAL_28]] : index603// CHECK: %[[VAL_30:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_28]] : index604// CHECK: %[[VAL_31:.*]] = arith.andi %[[VAL_29]], %[[VAL_30]] : i1605// CHECK: scf.if %[[VAL_31]] {606// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_23]]] : memref<?xf32>607// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_24]]] : memref<?xf32>608// CHECK: %[[VAL_34:.*]] = arith.mulf %[[VAL_32]], %[[VAL_33]] : f32609// CHECK: memref.store %[[VAL_34]], %[[VAL_12]]{{\[}}%[[VAL_28]]] : memref<32xf32>610// CHECK: } else {611// CHECK: }612// CHECK: %[[VAL_35:.*]] = arith.cmpi eq, %[[VAL_25]], %[[VAL_28]] : index613// CHECK: %[[VAL_36:.*]] = arith.addi %[[VAL_23]], %[[VAL_4]] : index614// CHECK: %[[VAL_37:.*]] = arith.select %[[VAL_35]], %[[VAL_36]], %[[VAL_23]] : index615// CHECK: %[[VAL_38:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_28]] : index616// CHECK: %[[VAL_39:.*]] = arith.addi %[[VAL_24]], %[[VAL_4]] : index617// CHECK: %[[VAL_40:.*]] = arith.select %[[VAL_38]], %[[VAL_39]], %[[VAL_24]] : index618// CHECK: scf.yield %[[VAL_37]], %[[VAL_40]] : index, index619// CHECK: }620// CHECK: %[[VAL_41:.*]] = bufferization.to_tensor %[[VAL_12]] : memref<32xf32>621// CHECK: return %[[VAL_41]] : tensor<32xf32>622// CHECK: }623func.func @mul_ss(%arga: tensor<32xf32, #SV>, %argb: tensor<32xf32, #SV>, %argx: tensor<32xf32>) -> tensor<32xf32> {624 %0 = linalg.generic #trait2625 ins(%arga, %argb: tensor<32xf32, #SV>, tensor<32xf32, #SV>)626 outs(%argx: tensor<32xf32>) {627 ^bb(%a: f32, %b: f32, %x: f32):628 %0 = arith.mulf %a, %b : f32629 linalg.yield %0 : f32630 } -> tensor<32xf32>631 return %0 : tensor<32xf32>632}633 634// CHECK-LABEL: func @two_way_inv(635// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse{{[0-9]*}}>, %[[VAL_1:.*1]]: tensor<16xf32, #sparse{{[0-9]*}}>,636// CHECK-SAME: %[[VAL_2:.*2]]: f32,637// CHECK-SAME: %[[VAL_3:.*3]]: tensor<16xf32>) -> tensor<16xf32> {638// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index639// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index640// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>641// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>642// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xf32>643// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>644// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>645// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xf32>646// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_buffer %[[VAL_3]]647// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<16xf32>)648// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>649// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>650// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex>651// CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex>652// CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]]) : (index, index) -> (index, index) {653// CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_15]] : index654// CHECK: %[[VAL_22:.*]] = arith.cmpi ult, %[[VAL_20]], %[[VAL_17]] : index655// CHECK: %[[VAL_23:.*]] = arith.andi %[[VAL_21]], %[[VAL_22]] : i1656// CHECK: scf.condition(%[[VAL_23]]) %[[VAL_19]], %[[VAL_20]] : index, index657// CHECK: } do {658// CHECK: ^bb0(%[[VAL_24:.*]]: index, %[[VAL_25:.*]]: index):659// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_24]]] : memref<?xindex>660// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_25]]] : memref<?xindex>661// CHECK: %[[VAL_28:.*]] = arith.cmpi ult, %[[VAL_27]], %[[VAL_26]] : index662// CHECK: %[[VAL_29:.*]] = arith.select %[[VAL_28]], %[[VAL_27]], %[[VAL_26]] : index663// CHECK: %[[VAL_30:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_29]] : index664// CHECK: %[[VAL_31:.*]] = arith.cmpi eq, %[[VAL_27]], %[[VAL_29]] : index665// CHECK: %[[VAL_32:.*]] = arith.andi %[[VAL_30]], %[[VAL_31]] : i1666// CHECK: scf.if %[[VAL_32]] {667// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_24]]] : memref<?xf32>668// CHECK: %[[VAL_34:.*]] = arith.mulf %[[VAL_33]], %[[VAL_2]] : f32669// CHECK: %[[VAL_35:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_25]]] : memref<?xf32>670// CHECK: %[[VAL_36:.*]] = arith.mulf %[[VAL_35]], %[[VAL_2]] : f32671// CHECK: %[[VAL_37:.*]] = arith.addf %[[VAL_34]], %[[VAL_36]] : f32672// CHECK: memref.store %[[VAL_37]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32>673// CHECK: } else {674// CHECK: %[[VAL_38:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_29]] : index675// CHECK: scf.if %[[VAL_38]] {676// CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_24]]] : memref<?xf32>677// CHECK: %[[VAL_40:.*]] = arith.mulf %[[VAL_39]], %[[VAL_2]] : f32678// CHECK: memref.store %[[VAL_40]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32>679// CHECK: } else {680// CHECK: %[[VAL_41:.*]] = arith.cmpi eq, %[[VAL_27]], %[[VAL_29]] : index681// CHECK: scf.if %[[VAL_41]] {682// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_25]]] : memref<?xf32>683// CHECK: %[[VAL_43:.*]] = arith.mulf %[[VAL_42]], %[[VAL_2]] : f32684// CHECK: memref.store %[[VAL_43]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32>685// CHECK: } else {686// CHECK: }687// CHECK: }688// CHECK: }689// CHECK: %[[VAL_44:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_29]] : index690// CHECK: %[[VAL_45:.*]] = arith.addi %[[VAL_24]], %[[VAL_5]] : index691// CHECK: %[[VAL_46:.*]] = arith.select %[[VAL_44]], %[[VAL_45]], %[[VAL_24]] : index692// CHECK: %[[VAL_47:.*]] = arith.cmpi eq, %[[VAL_27]], %[[VAL_29]] : index693// CHECK: %[[VAL_48:.*]] = arith.addi %[[VAL_25]], %[[VAL_5]] : index694// CHECK: %[[VAL_49:.*]] = arith.select %[[VAL_47]], %[[VAL_48]], %[[VAL_25]] : index695// CHECK: scf.yield %[[VAL_46]], %[[VAL_49]] : index, index696// CHECK: }697// CHECK: scf.for %[[VAL_50:.*]] = %[[VAL_51:.*]]#0 to %[[VAL_15]] step %[[VAL_5]] {698// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_50]]] : memref<?xindex>699// CHECK: %[[VAL_53:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_50]]] : memref<?xf32>700// CHECK: %[[VAL_54:.*]] = arith.mulf %[[VAL_53]], %[[VAL_2]] : f32701// CHECK: memref.store %[[VAL_54]], %[[VAL_13]]{{\[}}%[[VAL_52]]] : memref<16xf32>702// CHECK: }703// CHECK: scf.for %[[VAL_55:.*]] = %[[VAL_56:.*]]#1 to %[[VAL_17]] step %[[VAL_5]] {704// CHECK: %[[VAL_57:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_55]]] : memref<?xindex>705// CHECK: %[[VAL_58:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_55]]] : memref<?xf32>706// CHECK: %[[VAL_59:.*]] = arith.mulf %[[VAL_58]], %[[VAL_2]] : f32707// CHECK: memref.store %[[VAL_59]], %[[VAL_13]]{{\[}}%[[VAL_57]]] : memref<16xf32>708// CHECK: }709// CHECK: %[[VAL_60:.*]] = bufferization.to_tensor %[[VAL_13]] : memref<16xf32>710// CHECK: return %[[VAL_60]] : tensor<16xf32>711// CHECK: }712func.func @two_way_inv(%arga: tensor<16xf32, #SV>, %argb: tensor<16xf32, #SV>, %argc: f32, %argx: tensor<16xf32>) -> tensor<16xf32> {713 // Kernel "x(i) = a(i) * c + b(i) * c".714 %0 = linalg.generic #trait2715 ins(%arga, %argb: tensor<16xf32, #SV>, tensor<16xf32, #SV>)716 outs(%argx: tensor<16xf32>) {717 ^bb(%a: f32, %b: f32, %x: f32):718 %0 = arith.mulf %a, %argc : f32719 %1 = arith.mulf %b, %argc : f32720 %2 = arith.addf %0, %1 : f32721 linalg.yield %2 : f32722 } -> tensor<16xf32>723 return %0 : tensor<16xf32>724}725 726// CHECK-LABEL: func @two_way_inv_alt(727// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse{{[0-9]*}}>, %[[VAL_1:.*1]]: tensor<16xf32, #sparse{{[0-9]*}}>,728// CHECK-SAME: %[[VAL_2:.*2]]: f32,729// CHECK-SAME: %[[VAL_3:.*3]]: tensor<16xf32>) -> tensor<16xf32> {730// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index731// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index732// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>733// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>734// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xf32>735// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>736// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>737// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xf32>738// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_buffer %[[VAL_3]]739// CHECK-DAG: linalg.fill ins(%{{.*}} : f32) outs(%[[VAL_13]] : memref<16xf32>)740// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>741// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>742// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex>743// CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex>744// CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]]) : (index, index) -> (index, index) {745// CHECK: %[[VAL_21:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_15]] : index746// CHECK: %[[VAL_22:.*]] = arith.cmpi ult, %[[VAL_20]], %[[VAL_17]] : index747// CHECK: %[[VAL_23:.*]] = arith.andi %[[VAL_21]], %[[VAL_22]] : i1748// CHECK: scf.condition(%[[VAL_23]]) %[[VAL_19]], %[[VAL_20]] : index, index749// CHECK: } do {750// CHECK: ^bb0(%[[VAL_24:.*]]: index, %[[VAL_25:.*]]: index):751// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_24]]] : memref<?xindex>752// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_25]]] : memref<?xindex>753// CHECK: %[[VAL_28:.*]] = arith.cmpi ult, %[[VAL_27]], %[[VAL_26]] : index754// CHECK: %[[VAL_29:.*]] = arith.select %[[VAL_28]], %[[VAL_27]], %[[VAL_26]] : index755// CHECK: %[[VAL_30:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_29]] : index756// CHECK: %[[VAL_31:.*]] = arith.cmpi eq, %[[VAL_27]], %[[VAL_29]] : index757// CHECK: %[[VAL_32:.*]] = arith.andi %[[VAL_30]], %[[VAL_31]] : i1758// CHECK: scf.if %[[VAL_32]] {759// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_24]]] : memref<?xf32>760// CHECK: %[[VAL_34:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_25]]] : memref<?xf32>761// CHECK: %[[VAL_35:.*]] = arith.addf %[[VAL_33]], %[[VAL_34]] : f32762// CHECK: %[[VAL_36:.*]] = arith.mulf %[[VAL_35]], %[[VAL_2]] : f32763// CHECK: memref.store %[[VAL_36]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32>764// CHECK: } else {765// CHECK: %[[VAL_37:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_29]] : index766// CHECK: scf.if %[[VAL_37]] {767// CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_24]]] : memref<?xf32>768// CHECK: %[[VAL_39:.*]] = arith.mulf %[[VAL_38]], %[[VAL_2]] : f32769// CHECK: memref.store %[[VAL_39]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32>770// CHECK: } else {771// CHECK: %[[VAL_40:.*]] = arith.cmpi eq, %[[VAL_27]], %[[VAL_29]] : index772// CHECK: scf.if %[[VAL_40]] {773// CHECK: %[[VAL_41:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_25]]] : memref<?xf32>774// CHECK: %[[VAL_42:.*]] = arith.mulf %[[VAL_41]], %[[VAL_2]] : f32775// CHECK: memref.store %[[VAL_42]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32>776// CHECK: } else {777// CHECK: }778// CHECK: }779// CHECK: }780// CHECK: %[[VAL_43:.*]] = arith.cmpi eq, %[[VAL_26]], %[[VAL_29]] : index781// CHECK: %[[VAL_44:.*]] = arith.addi %[[VAL_24]], %[[VAL_5]] : index782// CHECK: %[[VAL_45:.*]] = arith.select %[[VAL_43]], %[[VAL_44]], %[[VAL_24]] : index783// CHECK: %[[VAL_46:.*]] = arith.cmpi eq, %[[VAL_27]], %[[VAL_29]] : index784// CHECK: %[[VAL_47:.*]] = arith.addi %[[VAL_25]], %[[VAL_5]] : index785// CHECK: %[[VAL_48:.*]] = arith.select %[[VAL_46]], %[[VAL_47]], %[[VAL_25]] : index786// CHECK: scf.yield %[[VAL_45]], %[[VAL_48]] : index, index787// CHECK: }788// CHECK: scf.for %[[VAL_49:.*]] = %[[VAL_50:.*]]#0 to %[[VAL_15]] step %[[VAL_5]] {789// CHECK: %[[VAL_51:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_49]]] : memref<?xindex>790// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_49]]] : memref<?xf32>791// CHECK: %[[VAL_53:.*]] = arith.mulf %[[VAL_52]], %[[VAL_2]] : f32792// CHECK: memref.store %[[VAL_53]], %[[VAL_13]]{{\[}}%[[VAL_51]]] : memref<16xf32>793// CHECK: }794// CHECK: scf.for %[[VAL_54:.*]] = %[[VAL_55:.*]]#1 to %[[VAL_17]] step %[[VAL_5]] {795// CHECK: %[[VAL_56:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_54]]] : memref<?xindex>796// CHECK: %[[VAL_57:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_54]]] : memref<?xf32>797// CHECK: %[[VAL_58:.*]] = arith.mulf %[[VAL_57]], %[[VAL_2]] : f32798// CHECK: memref.store %[[VAL_58]], %[[VAL_13]]{{\[}}%[[VAL_56]]] : memref<16xf32>799// CHECK: }800// CHECK: %[[VAL_59:.*]] = bufferization.to_tensor %[[VAL_13]] : memref<16xf32>801// CHECK: return %[[VAL_59]] : tensor<16xf32>802// CHECK: }803func.func @two_way_inv_alt(%arga: tensor<16xf32, #SV>,804 %argb: tensor<16xf32, #SV>, %argc: f32, %argx: tensor<16xf32>) -> tensor<16xf32> {805 // Same kernel, but now expressed as "x(i) = (a(i) + b(i)) * c".806 %0 = linalg.generic #trait2807 ins(%arga, %argb: tensor<16xf32, #SV>, tensor<16xf32, #SV>)808 outs(%argx: tensor<16xf32>) {809 ^bb(%a: f32, %b: f32, %x: f32):810 %0 = arith.addf %a, %b : f32811 %1 = arith.mulf %0, %argc : f32812 linalg.yield %1 : f32813 } -> tensor<16xf32>814 return %0 : tensor<16xf32>815}816 817#trait_sum_reduction = {818 indexing_maps = [819 affine_map<(i) -> (i)>, // a820 affine_map<(i) -> ()> // x (scalar out)821 ],822 iterator_types = ["reduction"],823 doc = "x += SUM_i a(i)"824}825 826// CHECK-LABEL: func @sum_reduction(827// CHECK-SAME: %[[VAL_0:.*]]: tensor<?xf32, #sparse{{[0-9]*}}>,828// CHECK-SAME: %[[VAL_1:.*]]: tensor<f32>) -> tensor<f32> {829// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : index830// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : index831// CHECK-DAG: %[[VAL_4:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?xf32, #sparse{{[0-9]*}}> to memref<?xindex>832// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?xf32, #sparse{{[0-9]*}}> to memref<?xf32>833// CHECK-DAG: %[[VAL_6:.*]] = bufferization.to_buffer %[[VAL_1]] : tensor<f32> to memref<f32>834// CHECK-DAG: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>835// CHECK-DAG: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>836// CHECK-DAG: %[[VAL_10:.*]] = memref.load %[[VAL_6]][] : memref<f32>837// CHECK: %[[VAL_11:.*]] = scf.for %[[VAL_12:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (f32) {838// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32>839// CHECK: %[[VAL_15:.*]] = arith.addf %[[VAL_13]], %[[VAL_14]] : f32840// CHECK: scf.yield %[[VAL_15]] : f32841// CHECK: }842// CHECK: memref.store %[[VAL_11]], %[[VAL_6]][] : memref<f32>843// CHECK: %[[VAL_17:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<f32>844// CHECK: return %[[VAL_17]] : tensor<f32>845// CHECK: }846func.func @sum_reduction(%arga: tensor<?xf32, #SV>, %argx: tensor<f32>) -> tensor<f32> {847 %0 = linalg.generic #trait_sum_reduction848 ins(%arga: tensor<?xf32, #SV>)849 outs(%argx: tensor<f32>) {850 ^bb(%a: f32, %x: f32):851 %0 = arith.addf %x, %a : f32852 linalg.yield %0 : f32853 } -> tensor<f32>854 return %0 : tensor<f32>855}856 857#trait_sum_reduction2 = {858 indexing_maps = [859 affine_map<(i) -> (i)>, // a860 affine_map<(i) -> (i)>, // b861 affine_map<(i)-> ()> // x (scalar out)862 ],863 iterator_types = ["reduction"],864 doc = "x += SUM_i a(i) + b(i)"865}866 867// CHECK-LABEL: func @sum_reduction_ss(868// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse{{[0-9]*}}>, %[[VAL_1:.*1]]: tensor<16xf32, #sparse{{[0-9]*}}>,869// CHECK-SAME: %[[VAL_2:.*2]]: tensor<f32>) -> tensor<f32> {870// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index871// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index872// CHECK-DAG: %[[VAL_5:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>873// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>874// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xf32>875// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>876// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>877// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xf32>878// CHECK-DAG: %[[VAL_11:.*]] = bufferization.to_buffer %[[VAL_2]] : tensor<f32> to memref<f32>879// CHECK-DAG: %[[VAL_13:.*]] = memref.load %[[VAL_11]][] : memref<f32>880// CHECK-DAG: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>881// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>882// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>883// CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>884// CHECK: %[[VAL_18:.*]]:3 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]], %[[VAL_21:.*]] = %[[VAL_13]]) : (index, index, f32) -> (index, index, f32) {885// CHECK: %[[VAL_22:.*]] = arith.cmpi ult, %[[VAL_19]], %[[VAL_15]] : index886// CHECK: %[[VAL_23:.*]] = arith.cmpi ult, %[[VAL_20]], %[[VAL_17]] : index887// CHECK: %[[VAL_24:.*]] = arith.andi %[[VAL_22]], %[[VAL_23]] : i1888// CHECK: scf.condition(%[[VAL_24]]) %[[VAL_19]], %[[VAL_20]], %[[VAL_21]] : index, index, f32889// CHECK: } do {890// CHECK: ^bb0(%[[VAL_25:.*]]: index, %[[VAL_26:.*]]: index, %[[VAL_27:.*]]: f32):891// CHECK: %[[VAL_28:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_25]]] : memref<?xindex>892// CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_26]]] : memref<?xindex>893// CHECK: %[[VAL_30:.*]] = arith.cmpi ult, %[[VAL_29]], %[[VAL_28]] : index894// CHECK: %[[VAL_31:.*]] = arith.select %[[VAL_30]], %[[VAL_29]], %[[VAL_28]] : index895// CHECK: %[[VAL_32:.*]] = arith.cmpi eq, %[[VAL_28]], %[[VAL_31]] : index896// CHECK: %[[VAL_33:.*]] = arith.cmpi eq, %[[VAL_29]], %[[VAL_31]] : index897// CHECK: %[[VAL_34:.*]] = arith.andi %[[VAL_32]], %[[VAL_33]] : i1898// CHECK: %[[VAL_35:.*]] = scf.if %[[VAL_34]] -> (f32) {899// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_25]]] : memref<?xf32>900// CHECK: %[[VAL_37:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_26]]] : memref<?xf32>901// CHECK: %[[VAL_38:.*]] = arith.addf %[[VAL_36]], %[[VAL_37]] : f32902// CHECK: %[[VAL_39:.*]] = arith.addf %[[VAL_27]], %[[VAL_38]] : f32903// CHECK: scf.yield %[[VAL_39]] : f32904// CHECK: } else {905// CHECK: %[[VAL_40:.*]] = arith.cmpi eq, %[[VAL_28]], %[[VAL_31]] : index906// CHECK: %[[VAL_41:.*]] = scf.if %[[VAL_40]] -> (f32) {907// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_25]]] : memref<?xf32>908// CHECK: %[[VAL_43:.*]] = arith.addf %[[VAL_27]], %[[VAL_42]] : f32909// CHECK: scf.yield %[[VAL_43]] : f32910// CHECK: } else {911// CHECK: %[[VAL_44:.*]] = arith.cmpi eq, %[[VAL_29]], %[[VAL_31]] : index912// CHECK: %[[VAL_45:.*]] = scf.if %[[VAL_44]] -> (f32) {913// CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_26]]] : memref<?xf32>914// CHECK: %[[VAL_47:.*]] = arith.addf %[[VAL_27]], %[[VAL_46]] : f32915// CHECK: scf.yield %[[VAL_47]] : f32916// CHECK: } else {917// CHECK: scf.yield %[[VAL_27]] : f32918// CHECK: }919// CHECK: scf.yield %[[VAL_48:.*]] : f32920// CHECK: }921// CHECK: scf.yield %[[VAL_49:.*]] : f32922// CHECK: }923// CHECK: %[[VAL_50:.*]] = arith.cmpi eq, %[[VAL_28]], %[[VAL_31]] : index924// CHECK: %[[VAL_51:.*]] = arith.addi %[[VAL_25]], %[[VAL_4]] : index925// CHECK: %[[VAL_52:.*]] = arith.select %[[VAL_50]], %[[VAL_51]], %[[VAL_25]] : index926// CHECK: %[[VAL_53:.*]] = arith.cmpi eq, %[[VAL_29]], %[[VAL_31]] : index927// CHECK: %[[VAL_54:.*]] = arith.addi %[[VAL_26]], %[[VAL_4]] : index928// CHECK: %[[VAL_55:.*]] = arith.select %[[VAL_53]], %[[VAL_54]], %[[VAL_26]] : index929// CHECK: scf.yield %[[VAL_52]], %[[VAL_55]], %[[VAL_56:.*]] : index, index, f32930// CHECK: }931// CHECK: %[[VAL_57:.*]] = scf.for %[[VAL_58:.*]] = %[[VAL_59:.*]]#0 to %[[VAL_15]] step %[[VAL_4]] iter_args(%[[VAL_60:.*]] = %[[VAL_59]]#2) -> (f32) {932// CHECK: %[[VAL_61:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_58]]] : memref<?xf32>933// CHECK: %[[VAL_62:.*]] = arith.addf %[[VAL_60]], %[[VAL_61]] : f32934// CHECK: scf.yield %[[VAL_62]] : f32935// CHECK: }936// CHECK: %[[VAL_63:.*]] = scf.for %[[VAL_64:.*]] = %[[VAL_65:.*]]#1 to %[[VAL_17]] step %[[VAL_4]] iter_args(%[[VAL_66:.*]] = %[[VAL_67:.*]]) -> (f32) {937// CHECK: %[[VAL_68:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_64]]] : memref<?xf32>938// CHECK: %[[VAL_69:.*]] = arith.addf %[[VAL_66]], %[[VAL_68]] : f32939// CHECK: scf.yield %[[VAL_69]] : f32940// CHECK: }941// CHECK: memref.store %[[VAL_70:.*]], %[[VAL_11]][] : memref<f32>942// CHECK: %[[VAL_71:.*]] = bufferization.to_tensor %[[VAL_11]] : memref<f32>943// CHECK: return %[[VAL_71]] : tensor<f32>944// CHECK: }945func.func @sum_reduction_ss(%arga: tensor<16xf32, #SV>,946 %argb: tensor<16xf32, #SV>,947 %argx: tensor<f32>) -> tensor<f32> {948 // Just for testing. This case would be better expressed949 // as two separate reductions kernels.950 %0 = linalg.generic #trait_sum_reduction2951 ins(%arga, %argb: tensor<16xf32, #SV>, tensor<16xf32, #SV>)952 outs(%argx: tensor<f32>) {953 ^bb(%a: f32, %b: f32, %x: f32):954 %0 = arith.addf %a, %b : f32955 %1 = arith.addf %x, %0 : f32956 linalg.yield %1 : f32957 } -> tensor<f32>958 return %0 : tensor<f32>959}960 961#trait_sum_reduction_inv = {962 indexing_maps = [963 affine_map<(i) -> (i)>, // a964 affine_map<(i) -> ()>, // b965 affine_map<(i) -> (i)>, // c966 affine_map<(i) -> ()> // x (out)967 ],968 iterator_types = ["reduction"],969 doc = "x += SUM_i a(i) * b + c(i)"970}971 972// CHECK-LABEL: func @sum_reduction_inv(973// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse{{[0-9]*}}>, %[[VAL_1:.*1]]: tensor<f32>, %[[VAL_2:.*2]]: tensor<16xf32, #sparse{{[0-9]*}}>,974// CHECK-SAME: %[[VAL_3:.*3]]: tensor<f32>) -> tensor<f32> {975// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index976// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index977// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>978// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>979// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xf32>980// CHECK-DAG: %[[VAL_9:.*]] = bufferization.to_buffer %[[VAL_1]] : tensor<f32> to memref<f32>981// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.positions %[[VAL_2]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>982// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.coordinates %[[VAL_2]] {level = 0 : index} : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xindex>983// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<16xf32, #sparse{{[0-9]*}}> to memref<?xf32>984// CHECK-DAG: %[[VAL_13:.*]] = bufferization.to_buffer %[[VAL_3]] : tensor<f32> to memref<f32>985// CHECK-DAG: %[[VAL_15:.*]] = memref.load %[[VAL_13]][] : memref<f32>986// CHECK-DAG: %[[VAL_16:.*]] = memref.load %[[VAL_9]][] : memref<f32>987// CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>988// CHECK-DAG: %[[VAL_18:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>989// CHECK-DAG: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex>990// CHECK-DAG: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_5]]] : memref<?xindex>991// CHECK: %[[VAL_21:.*]]:3 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]], %[[VAL_24:.*]] = %[[VAL_15]]) : (index, index, f32) -> (index, index, f32) {992// CHECK: %[[VAL_25:.*]] = arith.cmpi ult, %[[VAL_22]], %[[VAL_18]] : index993// CHECK: %[[VAL_26:.*]] = arith.cmpi ult, %[[VAL_23]], %[[VAL_20]] : index994// CHECK: %[[VAL_27:.*]] = arith.andi %[[VAL_25]], %[[VAL_26]] : i1995// CHECK: scf.condition(%[[VAL_27]]) %[[VAL_22]], %[[VAL_23]], %[[VAL_24]] : index, index, f32996// CHECK: } do {997// CHECK: ^bb0(%[[VAL_28:.*]]: index, %[[VAL_29:.*]]: index, %[[VAL_30:.*]]: f32):998// CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_28]]] : memref<?xindex>999// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_29]]] : memref<?xindex>1000// CHECK: %[[VAL_33:.*]] = arith.cmpi ult, %[[VAL_32]], %[[VAL_31]] : index1001// CHECK: %[[VAL_34:.*]] = arith.select %[[VAL_33]], %[[VAL_32]], %[[VAL_31]] : index1002// CHECK: %[[VAL_35:.*]] = arith.cmpi eq, %[[VAL_31]], %[[VAL_34]] : index1003// CHECK: %[[VAL_36:.*]] = arith.cmpi eq, %[[VAL_32]], %[[VAL_34]] : index1004// CHECK: %[[VAL_37:.*]] = arith.andi %[[VAL_35]], %[[VAL_36]] : i11005// CHECK: %[[VAL_38:.*]] = scf.if %[[VAL_37]] -> (f32) {1006// CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_28]]] : memref<?xf32>1007// CHECK: %[[VAL_40:.*]] = arith.mulf %[[VAL_39]], %[[VAL_16]] : f321008// CHECK: %[[VAL_41:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_29]]] : memref<?xf32>1009// CHECK: %[[VAL_42:.*]] = arith.addf %[[VAL_40]], %[[VAL_41]] : f321010// CHECK: %[[VAL_43:.*]] = arith.addf %[[VAL_30]], %[[VAL_42]] : f321011// CHECK: scf.yield %[[VAL_43]] : f321012// CHECK: } else {1013// CHECK: %[[VAL_44:.*]] = arith.cmpi eq, %[[VAL_31]], %[[VAL_34]] : index1014// CHECK: %[[VAL_45:.*]] = scf.if %[[VAL_44]] -> (f32) {1015// CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_28]]] : memref<?xf32>1016// CHECK: %[[VAL_47:.*]] = arith.mulf %[[VAL_46]], %[[VAL_16]] : f321017// CHECK: %[[VAL_48:.*]] = arith.addf %[[VAL_30]], %[[VAL_47]] : f321018// CHECK: scf.yield %[[VAL_48]] : f321019// CHECK: } else {1020// CHECK: %[[VAL_49:.*]] = arith.cmpi eq, %[[VAL_32]], %[[VAL_34]] : index1021// CHECK: %[[VAL_50:.*]] = scf.if %[[VAL_49]] -> (f32) {1022// CHECK: %[[VAL_51:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_29]]] : memref<?xf32>1023// CHECK: %[[VAL_52:.*]] = arith.addf %[[VAL_30]], %[[VAL_51]] : f321024// CHECK: scf.yield %[[VAL_52]] : f321025// CHECK: } else {1026// CHECK: scf.yield %[[VAL_30]] : f321027// CHECK: }1028// CHECK: scf.yield %[[VAL_53:.*]] : f321029// CHECK: }1030// CHECK: scf.yield %[[VAL_54:.*]] : f321031// CHECK: }1032// CHECK: %[[VAL_55:.*]] = arith.cmpi eq, %[[VAL_31]], %[[VAL_34]] : index1033// CHECK: %[[VAL_56:.*]] = arith.addi %[[VAL_28]], %[[VAL_5]] : index1034// CHECK: %[[VAL_57:.*]] = arith.select %[[VAL_55]], %[[VAL_56]], %[[VAL_28]] : index1035// CHECK: %[[VAL_58:.*]] = arith.cmpi eq, %[[VAL_32]], %[[VAL_34]] : index1036// CHECK: %[[VAL_59:.*]] = arith.addi %[[VAL_29]], %[[VAL_5]] : index1037// CHECK: %[[VAL_60:.*]] = arith.select %[[VAL_58]], %[[VAL_59]], %[[VAL_29]] : index1038// CHECK: scf.yield %[[VAL_57]], %[[VAL_60]], %[[VAL_61:.*]] : index, index, f321039// CHECK: }1040// CHECK: %[[VAL_62:.*]] = scf.for %[[VAL_63:.*]] = %[[VAL_64:.*]]#0 to %[[VAL_18]] step %[[VAL_5]] iter_args(%[[VAL_65:.*]] = %[[VAL_64]]#2) -> (f32) {1041// CHECK: %[[VAL_66:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_63]]] : memref<?xf32>1042// CHECK: %[[VAL_67:.*]] = arith.mulf %[[VAL_66]], %[[VAL_16]] : f321043// CHECK: %[[VAL_68:.*]] = arith.addf %[[VAL_65]], %[[VAL_67]] : f321044// CHECK: scf.yield %[[VAL_68]] : f321045// CHECK: }1046// CHECK: %[[VAL_69:.*]] = scf.for %[[VAL_70:.*]] = %[[VAL_71:.*]]#1 to %[[VAL_20]] step %[[VAL_5]] iter_args(%[[VAL_72:.*]] = %[[VAL_73:.*]]) -> (f32) {1047// CHECK: %[[VAL_74:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_70]]] : memref<?xf32>1048// CHECK: %[[VAL_75:.*]] = arith.addf %[[VAL_72]], %[[VAL_74]] : f321049// CHECK: scf.yield %[[VAL_75]] : f321050// CHECK: }1051// CHECK: memref.store %[[VAL_76:.*]], %[[VAL_13]][] : memref<f32>1052// CHECK: %[[VAL_77:.*]] = bufferization.to_tensor %[[VAL_13]] : memref<f32>1053// CHECK: return %[[VAL_77]] : tensor<f32>1054// CHECK: }1055func.func @sum_reduction_inv(%arga: tensor<16xf32, #SV>,1056 %argb: tensor<f32>,1057 %argc: tensor<16xf32, #SV>,1058 %argx: tensor<f32>) -> tensor<f32> {1059 // Just for testing. This case would be better expressed1060 // as two separate reductions kernels.1061 %0 = linalg.generic #trait_sum_reduction_inv1062 ins(%arga, %argb, %argc : tensor<16xf32, #SV>, tensor<f32>, tensor<16xf32, #SV>)1063 outs(%argx: tensor<f32>) {1064 ^bb(%a: f32, %b: f32, %c: f32, %x: f32):1065 %0 = arith.mulf %a, %b : f321066 %1 = arith.addf %0, %c : f321067 %2 = arith.addf %x, %1 : f321068 linalg.yield %2 : f321069 } -> tensor<f32>1070 return %0 : tensor<f32>1071}1072 1073#trait_four_tensors = {1074 indexing_maps = [1075 affine_map<(i) -> (i)>, // A1076 affine_map<(i) -> (i)>, // B1077 affine_map<(i) -> (i)>, // C1078 affine_map<(i) -> (i)>, // D1079 affine_map<(i) -> (i)> // X (out)1080 ],1081 iterator_types = ["parallel"],1082 doc = "X(i) = A(i) + B(i) + C(i) + D(i)"1083}1084 1085// CHECK-LABEL: func @four_tensors_op(1086// CHECK-SAME: %[[VAL_0:.*0]]: tensor<?xf64>,1087// CHECK-SAME: %[[VAL_1:.*1]]: tensor<?xf64, #sparse{{[0-9]*}}>, %[[VAL_2:.*2]]: tensor<?xf64>, %[[VAL_3:.*3]]: tensor<?xf64, #sparse{{[0-9]*}}>,1088// CHECK-SAME: %[[VAL_4:.*]]: tensor<?xf64>) -> tensor<?xf64> {1089// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index1090// CHECK-DAG: %[[VAL_6:.*]] = arith.constant true1091// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index1092// CHECK-DAG: %[[VAL_8:.*]] = bufferization.to_buffer %[[VAL_0]] : tensor<?xf64> to memref<?xf64>1093// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xindex>1094// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xindex>1095// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xf64>1096// CHECK-DAG: %[[VAL_12:.*]] = bufferization.to_buffer %[[VAL_2]] : tensor<?xf64> to memref<?xf64>1097// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.positions %[[VAL_3]] {level = 0 : index} : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xindex>1098// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.coordinates %[[VAL_3]] {level = 0 : index} : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xindex>1099// CHECK-DAG: %[[VAL_15:.*]] = sparse_tensor.values %[[VAL_3]] : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xf64>1100// CHECK-DAG: %[[VAL_16:.*]] = tensor.dim %[[VAL_0]], %[[VAL_5]] : tensor<?xf64>1101// CHECK-DAG: %[[VAL_18:.*]] = bufferization.to_buffer %[[VAL_4]]1102// CHECK-DAG: linalg.fill ins(%{{.*}} : f64) outs(%[[VAL_18]] : memref<?xf64>)1103// CHECK-DAG: %[[VAL_19:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex>1104// CHECK-DAG: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex>1105// CHECK-DAG: %[[VAL_21:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_5]]] : memref<?xindex>1106// CHECK-DAG: %[[VAL_22:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_7]]] : memref<?xindex>1107// CHECK: %[[VAL_23:.*]]:3 = scf.while (%[[VAL_24:.*]] = %[[VAL_19]], %[[VAL_25:.*]] = %[[VAL_21]], %[[VAL_26:.*]] = %[[VAL_5]]) : (index, index, index) -> (index, index, index) {1108// CHECK: %[[VAL_27:.*]] = arith.cmpi ult, %[[VAL_24]], %[[VAL_20]] : index1109// CHECK: %[[VAL_28:.*]] = arith.cmpi ult, %[[VAL_25]], %[[VAL_22]] : index1110// CHECK: %[[VAL_29:.*]] = arith.andi %[[VAL_27]], %[[VAL_28]] : i11111// CHECK: scf.condition(%[[VAL_29]]) %[[VAL_24]], %[[VAL_25]], %[[VAL_26]] : index, index, index1112// CHECK: } do {1113// CHECK: ^bb0(%[[VAL_30:.*]]: index, %[[VAL_31:.*]]: index, %[[VAL_32:.*]]: index):1114// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_30]]] : memref<?xindex>1115// CHECK: %[[VAL_34:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_31]]] : memref<?xindex>1116// CHECK: %[[VAL_35:.*]] = arith.cmpi eq, %[[VAL_33]], %[[VAL_32]] : index1117// CHECK: %[[VAL_36:.*]] = arith.cmpi eq, %[[VAL_34]], %[[VAL_32]] : index1118// CHECK: %[[VAL_37:.*]] = arith.andi %[[VAL_35]], %[[VAL_36]] : i11119// CHECK: scf.if %[[VAL_37]] {1120// CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64>1121// CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_30]]] : memref<?xf64>1122// CHECK: %[[VAL_40:.*]] = arith.addf %[[VAL_38]], %[[VAL_39]] : f641123// CHECK: %[[VAL_41:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_32]]] : memref<?xf64>1124// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_31]]] : memref<?xf64>1125// CHECK: %[[VAL_43:.*]] = arith.addf %[[VAL_41]], %[[VAL_42]] : f641126// CHECK: %[[VAL_44:.*]] = arith.addf %[[VAL_40]], %[[VAL_43]] : f641127// CHECK: memref.store %[[VAL_44]], %[[VAL_18]]{{\[}}%[[VAL_32]]] : memref<?xf64>1128// CHECK: } else {1129// CHECK: %[[VAL_45:.*]] = arith.cmpi eq, %[[VAL_33]], %[[VAL_32]] : index1130// CHECK: scf.if %[[VAL_45]] {1131// CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64>1132// CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_30]]] : memref<?xf64>1133// CHECK: %[[VAL_48:.*]] = arith.addf %[[VAL_46]], %[[VAL_47]] : f641134// CHECK: %[[VAL_49:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_32]]] : memref<?xf64>1135// CHECK: %[[VAL_50:.*]] = arith.addf %[[VAL_48]], %[[VAL_49]] : f641136// CHECK: memref.store %[[VAL_50]], %[[VAL_18]]{{\[}}%[[VAL_32]]] : memref<?xf64>1137// CHECK: } else {1138// CHECK: %[[VAL_51:.*]] = arith.cmpi eq, %[[VAL_34]], %[[VAL_32]] : index1139// CHECK: scf.if %[[VAL_51]] {1140// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64>1141// CHECK: %[[VAL_53:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_32]]] : memref<?xf64>1142// CHECK: %[[VAL_54:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_31]]] : memref<?xf64>1143// CHECK: %[[VAL_55:.*]] = arith.addf %[[VAL_53]], %[[VAL_54]] : f641144// CHECK: %[[VAL_56:.*]] = arith.addf %[[VAL_52]], %[[VAL_55]] : f641145// CHECK: memref.store %[[VAL_56]], %[[VAL_18]]{{\[}}%[[VAL_32]]] : memref<?xf64>1146// CHECK: } else {1147// CHECK: scf.if %[[VAL_6]] {1148// CHECK: %[[VAL_57:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64>1149// CHECK: %[[VAL_58:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_32]]] : memref<?xf64>1150// CHECK: %[[VAL_59:.*]] = arith.addf %[[VAL_57]], %[[VAL_58]] : f641151// CHECK: memref.store %[[VAL_59]], %[[VAL_18]]{{\[}}%[[VAL_32]]] : memref<?xf64>1152// CHECK: } else {1153// CHECK: }1154// CHECK: }1155// CHECK: }1156// CHECK: }1157// CHECK: %[[VAL_60:.*]] = arith.cmpi eq, %[[VAL_33]], %[[VAL_32]] : index1158// CHECK: %[[VAL_61:.*]] = arith.addi %[[VAL_30]], %[[VAL_7]] : index1159// CHECK: %[[VAL_62:.*]] = arith.select %[[VAL_60]], %[[VAL_61]], %[[VAL_30]] : index1160// CHECK: %[[VAL_63:.*]] = arith.cmpi eq, %[[VAL_34]], %[[VAL_32]] : index1161// CHECK: %[[VAL_64:.*]] = arith.addi %[[VAL_31]], %[[VAL_7]] : index1162// CHECK: %[[VAL_65:.*]] = arith.select %[[VAL_63]], %[[VAL_64]], %[[VAL_31]] : index1163// CHECK: %[[VAL_66:.*]] = arith.addi %[[VAL_32]], %[[VAL_7]] : index1164// CHECK: scf.yield %[[VAL_62]], %[[VAL_65]], %[[VAL_66]] : index, index, index1165// CHECK: }1166// CHECK: %[[VAL_67:.*]]:2 = scf.while (%[[VAL_68:.*]] = %[[VAL_69:.*]]#0, %[[VAL_70:.*]] = %[[VAL_69]]#2) : (index, index) -> (index, index) {1167// CHECK: %[[VAL_71:.*]] = arith.cmpi ult, %[[VAL_68]], %[[VAL_20]] : index1168// CHECK: scf.condition(%[[VAL_71]]) %[[VAL_68]], %[[VAL_70]] : index, index1169// CHECK: } do {1170// CHECK: ^bb0(%[[VAL_72:.*]]: index, %[[VAL_73:.*]]: index):1171// CHECK: %[[VAL_74:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_72]]] : memref<?xindex>1172// CHECK: %[[VAL_75:.*]] = arith.cmpi eq, %[[VAL_74]], %[[VAL_73]] : index1173// CHECK: scf.if %[[VAL_75]] {1174// CHECK: %[[VAL_76:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_73]]] : memref<?xf64>1175// CHECK: %[[VAL_77:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_72]]] : memref<?xf64>1176// CHECK: %[[VAL_78:.*]] = arith.addf %[[VAL_76]], %[[VAL_77]] : f641177// CHECK: %[[VAL_79:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_73]]] : memref<?xf64>1178// CHECK: %[[VAL_80:.*]] = arith.addf %[[VAL_78]], %[[VAL_79]] : f641179// CHECK: memref.store %[[VAL_80]], %[[VAL_18]]{{\[}}%[[VAL_73]]] : memref<?xf64>1180// CHECK: } else {1181// CHECK: scf.if %[[VAL_6]] {1182// CHECK: %[[VAL_81:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_73]]] : memref<?xf64>1183// CHECK: %[[VAL_82:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_73]]] : memref<?xf64>1184// CHECK: %[[VAL_83:.*]] = arith.addf %[[VAL_81]], %[[VAL_82]] : f641185// CHECK: memref.store %[[VAL_83]], %[[VAL_18]]{{\[}}%[[VAL_73]]] : memref<?xf64>1186// CHECK: } else {1187// CHECK: }1188// CHECK: }1189// CHECK: %[[VAL_84:.*]] = arith.cmpi eq, %[[VAL_74]], %[[VAL_73]] : index1190// CHECK: %[[VAL_85:.*]] = arith.addi %[[VAL_72]], %[[VAL_7]] : index1191// CHECK: %[[VAL_86:.*]] = arith.select %[[VAL_84]], %[[VAL_85]], %[[VAL_72]] : index1192// CHECK: %[[VAL_87:.*]] = arith.addi %[[VAL_73]], %[[VAL_7]] : index1193// CHECK: scf.yield %[[VAL_86]], %[[VAL_87]] : index, index1194// CHECK: }1195// CHECK: %[[VAL_88:.*]]:2 = scf.while (%[[VAL_89:.*]] = %[[VAL_90:.*]]#1, %[[VAL_91:.*]] = %[[VAL_92:.*]]#1) : (index, index) -> (index, index) {1196// CHECK: %[[VAL_93:.*]] = arith.cmpi ult, %[[VAL_89]], %[[VAL_22]] : index1197// CHECK: scf.condition(%[[VAL_93]]) %[[VAL_89]], %[[VAL_91]] : index, index1198// CHECK: } do {1199// CHECK: ^bb0(%[[VAL_94:.*]]: index, %[[VAL_95:.*]]: index):1200// CHECK: %[[VAL_96:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_94]]] : memref<?xindex>1201// CHECK: %[[VAL_97:.*]] = arith.cmpi eq, %[[VAL_96]], %[[VAL_95]] : index1202// CHECK: scf.if %[[VAL_97]] {1203// CHECK: %[[VAL_98:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_95]]] : memref<?xf64>1204// CHECK: %[[VAL_99:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_95]]] : memref<?xf64>1205// CHECK: %[[VAL_100:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_94]]] : memref<?xf64>1206// CHECK: %[[VAL_101:.*]] = arith.addf %[[VAL_99]], %[[VAL_100]] : f641207// CHECK: %[[VAL_102:.*]] = arith.addf %[[VAL_98]], %[[VAL_101]] : f641208// CHECK: memref.store %[[VAL_102]], %[[VAL_18]]{{\[}}%[[VAL_95]]] : memref<?xf64>1209// CHECK: } else {1210// CHECK: scf.if %[[VAL_6]] {1211// CHECK: %[[VAL_103:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_95]]] : memref<?xf64>1212// CHECK: %[[VAL_104:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_95]]] : memref<?xf64>1213// CHECK: %[[VAL_105:.*]] = arith.addf %[[VAL_103]], %[[VAL_104]] : f641214// CHECK: memref.store %[[VAL_105]], %[[VAL_18]]{{\[}}%[[VAL_95]]] : memref<?xf64>1215// CHECK: } else {1216// CHECK: }1217// CHECK: }1218// CHECK: %[[VAL_106:.*]] = arith.cmpi eq, %[[VAL_96]], %[[VAL_95]] : index1219// CHECK: %[[VAL_107:.*]] = arith.addi %[[VAL_94]], %[[VAL_7]] : index1220// CHECK: %[[VAL_108:.*]] = arith.select %[[VAL_106]], %[[VAL_107]], %[[VAL_94]] : index1221// CHECK: %[[VAL_109:.*]] = arith.addi %[[VAL_95]], %[[VAL_7]] : index1222// CHECK: scf.yield %[[VAL_108]], %[[VAL_109]] : index, index1223// CHECK: }1224// CHECK: scf.for %[[VAL_110:.*]] = %[[VAL_111:.*]]#1 to %[[VAL_16]] step %[[VAL_7]] {1225// CHECK: %[[VAL_112:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_110]]] : memref<?xf64>1226// CHECK: %[[VAL_113:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_110]]] : memref<?xf64>1227// CHECK: %[[VAL_114:.*]] = arith.addf %[[VAL_112]], %[[VAL_113]] : f641228// CHECK: memref.store %[[VAL_114]], %[[VAL_18]]{{\[}}%[[VAL_110]]] : memref<?xf64>1229// CHECK: }1230// CHECK: %[[VAL_115:.*]] = bufferization.to_tensor %[[VAL_18]] : memref<?xf64>1231// CHECK: return %[[VAL_115]] : tensor<?xf64>1232// CHECK: }1233func.func @four_tensors_op(%arga: tensor<?xf64>,1234 %argb: tensor<?xf64, #SV>,1235 %argc: tensor<?xf64>,1236 %argd: tensor<?xf64, #SV>,1237 %argx: tensor<?xf64>) -> tensor<?xf64> {1238 %r = linalg.generic #trait_four_tensors1239 ins(%arga, %argb, %argc, %argd: tensor<?xf64>, tensor<?xf64, #SV>, tensor<?xf64>, tensor<?xf64, #SV>)1240 outs(%argx: tensor<?xf64>) {1241 ^bb(%a: f64, %b: f64, %c: f64, %d: f64, %x: f64):1242 %0 = arith.addf %a, %b : f641243 %1 = arith.addf %c, %d : f641244 %2 = arith.addf %0, %1 : f641245 linalg.yield %2 : f641246 } -> tensor<?xf64>1247 return %r : tensor<?xf64>1248}1249 1250#trait_red3s = {1251 indexing_maps = [1252 affine_map<(i) -> (i)>,1253 affine_map<(i) -> (i)>,1254 affine_map<(i) -> (i)>,1255 affine_map<(i) -> ()>1256 ],1257 iterator_types = ["reduction"],1258 doc = "x += a(i) + b(i) + c(i)"1259}1260 1261// CHECK-LABEL: func @red3s(1262// CHECK-SAME: %[[VAL_0:.*0]]: tensor<?xf64, #sparse{{[0-9]*}}>, %[[VAL_1:.*1]]: tensor<?xf64, #sparse{{[0-9]*}}>, %[[VAL_2:.*2]]: tensor<?xf64, #sparse{{[0-9]*}}>,1263// CHECK-SAME: %[[VAL_3:.*3]]: tensor<f64>) -> tensor<f64> {1264// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index1265// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index1266// CHECK-DAG: %[[VAL_6:.*]] = sparse_tensor.positions %[[VAL_0]] {level = 0 : index} : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xindex>1267// CHECK-DAG: %[[VAL_7:.*]] = sparse_tensor.coordinates %[[VAL_0]] {level = 0 : index} : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xindex>1268// CHECK-DAG: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xf64>1269// CHECK-DAG: %[[VAL_9:.*]] = sparse_tensor.positions %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xindex>1270// CHECK-DAG: %[[VAL_10:.*]] = sparse_tensor.coordinates %[[VAL_1]] {level = 0 : index} : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xindex>1271// CHECK-DAG: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xf64>1272// CHECK-DAG: %[[VAL_12:.*]] = sparse_tensor.positions %[[VAL_2]] {level = 0 : index} : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xindex>1273// CHECK-DAG: %[[VAL_13:.*]] = sparse_tensor.coordinates %[[VAL_2]] {level = 0 : index} : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xindex>1274// CHECK-DAG: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<?xf64, #sparse{{[0-9]*}}> to memref<?xf64>1275// CHECK-DAG: %[[VAL_15:.*]] = bufferization.to_buffer %[[VAL_3]] : tensor<f64> to memref<f64>1276// CHECK-DAG: %[[VAL_17:.*]] = memref.load %[[VAL_15]][] : memref<f64>1277// CHECK-DAG: %[[VAL_18:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>1278// CHECK-DAG: %[[VAL_19:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>1279// CHECK-DAG: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex>1280// CHECK-DAG: %[[VAL_21:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex>1281// CHECK-DAG: %[[VAL_22:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_4]]] : memref<?xindex>1282// CHECK-DAG: %[[VAL_23:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<?xindex>1283// CHECK: %[[VAL_24:.*]]:4 = scf.while (%[[VAL_25:.*]] = %[[VAL_18]], %[[VAL_26:.*]] = %[[VAL_20]], %[[VAL_27:.*]] = %[[VAL_22]], %[[VAL_28:.*]] = %[[VAL_17]]) : (index, index, index, f64) -> (index, index, index, f64) {1284// CHECK: %[[VAL_29:.*]] = arith.cmpi ult, %[[VAL_25]], %[[VAL_19]] : index1285// CHECK: %[[VAL_30:.*]] = arith.cmpi ult, %[[VAL_26]], %[[VAL_21]] : index1286// CHECK: %[[VAL_31:.*]] = arith.andi %[[VAL_29]], %[[VAL_30]] : i11287// CHECK: %[[VAL_32:.*]] = arith.cmpi ult, %[[VAL_27]], %[[VAL_23]] : index1288// CHECK: %[[VAL_33:.*]] = arith.andi %[[VAL_31]], %[[VAL_32]] : i11289// CHECK: scf.condition(%[[VAL_33]]) %[[VAL_25]], %[[VAL_26]], %[[VAL_27]], %[[VAL_28]] : index, index, index, f641290// CHECK: } do {1291// CHECK: ^bb0(%[[VAL_34:.*]]: index, %[[VAL_35:.*]]: index, %[[VAL_36:.*]]: index, %[[VAL_37:.*]]: f64):1292// CHECK-DAG: %[[VAL_38:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_34]]] : memref<?xindex>1293// CHECK-DAG: %[[VAL_39:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_35]]] : memref<?xindex>1294// CHECK-DAG: %[[VAL_42:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_36]]] : memref<?xindex>1295// CHECK: %[[VAL_40:.*]] = arith.cmpi ult, %[[VAL_39]], %[[VAL_38]] : index1296// CHECK: %[[VAL_41:.*]] = arith.select %[[VAL_40]], %[[VAL_39]], %[[VAL_38]] : index1297// CHECK: %[[VAL_43:.*]] = arith.cmpi ult, %[[VAL_42]], %[[VAL_41]] : index1298// CHECK: %[[VAL_44:.*]] = arith.select %[[VAL_43]], %[[VAL_42]], %[[VAL_41]] : index1299// CHECK: %[[VAL_45:.*]] = arith.cmpi eq, %[[VAL_38]], %[[VAL_44]] : index1300// CHECK: %[[VAL_46:.*]] = arith.cmpi eq, %[[VAL_39]], %[[VAL_44]] : index1301// CHECK: %[[VAL_47:.*]] = arith.andi %[[VAL_45]], %[[VAL_46]] : i11302// CHECK: %[[VAL_48:.*]] = arith.cmpi eq, %[[VAL_42]], %[[VAL_44]] : index1303// CHECK: %[[VAL_49:.*]] = arith.andi %[[VAL_47]], %[[VAL_48]] : i11304// CHECK: %[[VAL_50:.*]] = scf.if %[[VAL_49]] -> (f64) {1305// CHECK: %[[VAL_51:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_34]]] : memref<?xf64>1306// CHECK: %[[VAL_52:.*]] = arith.addf %[[VAL_37]], %[[VAL_51]] : f641307// CHECK: %[[VAL_53:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_35]]] : memref<?xf64>1308// CHECK: %[[VAL_54:.*]] = arith.addf %[[VAL_52]], %[[VAL_53]] : f641309// CHECK: %[[VAL_55:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_36]]] : memref<?xf64>1310// CHECK: %[[VAL_56:.*]] = arith.addf %[[VAL_54]], %[[VAL_55]] : f641311// CHECK: scf.yield %[[VAL_56]] : f641312// CHECK: } else {1313// CHECK: %[[VAL_57:.*]] = arith.cmpi eq, %[[VAL_39]], %[[VAL_44]] : index1314// CHECK: %[[VAL_58:.*]] = arith.cmpi eq, %[[VAL_42]], %[[VAL_44]] : index1315// CHECK: %[[VAL_59:.*]] = arith.andi %[[VAL_57]], %[[VAL_58]] : i11316// CHECK: %[[VAL_60:.*]] = scf.if %[[VAL_59]] -> (f64) {1317// CHECK: %[[VAL_61:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_35]]] : memref<?xf64>1318// CHECK: %[[VAL_62:.*]] = arith.addf %[[VAL_37]], %[[VAL_61]] : f641319// CHECK: %[[VAL_63:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_36]]] : memref<?xf64>1320// CHECK: %[[VAL_64:.*]] = arith.addf %[[VAL_62]], %[[VAL_63]] : f641321// CHECK: scf.yield %[[VAL_64]] : f641322// CHECK: } else {1323// CHECK: %[[VAL_65:.*]] = arith.cmpi eq, %[[VAL_38]], %[[VAL_44]] : index1324// CHECK: %[[VAL_66:.*]] = arith.cmpi eq, %[[VAL_42]], %[[VAL_44]] : index1325// CHECK: %[[VAL_67:.*]] = arith.andi %[[VAL_65]], %[[VAL_66]] : i11326// CHECK: %[[VAL_68:.*]] = scf.if %[[VAL_67]] -> (f64) {1327// CHECK: %[[VAL_69:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_34]]] : memref<?xf64>1328// CHECK: %[[VAL_70:.*]] = arith.addf %[[VAL_37]], %[[VAL_69]] : f641329// CHECK: %[[VAL_71:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_36]]] : memref<?xf64>1330// CHECK: %[[VAL_72:.*]] = arith.addf %[[VAL_70]], %[[VAL_71]] : f641331// CHECK: scf.yield %[[VAL_72]] : f641332// CHECK: } else {1333// CHECK: %[[VAL_73:.*]] = arith.cmpi eq, %[[VAL_42]], %[[VAL_44]] : index1334// CHECK: %[[VAL_74:.*]] = scf.if %[[VAL_73]] -> (f64) {1335// CHECK: %[[VAL_75:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_36]]] : memref<?xf64>1336// CHECK: %[[VAL_76:.*]] = arith.addf %[[VAL_37]], %[[VAL_75]] : f641337// CHECK: scf.yield %[[VAL_76]] : f641338// CHECK: } else {1339// CHECK: %[[VAL_77:.*]] = arith.cmpi eq, %[[VAL_38]], %[[VAL_44]] : index1340// CHECK: %[[VAL_78:.*]] = arith.cmpi eq, %[[VAL_39]], %[[VAL_44]] : index1341// CHECK: %[[VAL_79:.*]] = arith.andi %[[VAL_77]], %[[VAL_78]] : i11342// CHECK: %[[VAL_80:.*]] = scf.if %[[VAL_79]] -> (f64) {1343// CHECK: %[[VAL_81:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_34]]] : memref<?xf64>1344// CHECK: %[[VAL_82:.*]] = arith.addf %[[VAL_37]], %[[VAL_81]] : f641345// CHECK: %[[VAL_83:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_35]]] : memref<?xf64>1346// CHECK: %[[VAL_84:.*]] = arith.addf %[[VAL_82]], %[[VAL_83]] : f641347// CHECK: scf.yield %[[VAL_84]] : f641348// CHECK: } else {1349// CHECK: %[[VAL_85:.*]] = arith.cmpi eq, %[[VAL_39]], %[[VAL_44]] : index1350// CHECK: %[[VAL_86:.*]] = scf.if %[[VAL_85]] -> (f64) {1351// CHECK: %[[VAL_87:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_35]]] : memref<?xf64>1352// CHECK: %[[VAL_88:.*]] = arith.addf %[[VAL_37]], %[[VAL_87]] : f641353// CHECK: scf.yield %[[VAL_88]] : f641354// CHECK: } else {1355// CHECK: %[[VAL_89:.*]] = arith.cmpi eq, %[[VAL_38]], %[[VAL_44]] : index1356// CHECK: %[[VAL_90:.*]] = scf.if %[[VAL_89]] -> (f64) {1357// CHECK: %[[VAL_91:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_34]]] : memref<?xf64>1358// CHECK: %[[VAL_92:.*]] = arith.addf %[[VAL_37]], %[[VAL_91]] : f641359// CHECK: scf.yield %[[VAL_92]] : f641360// CHECK: } else {1361// CHECK: scf.yield %[[VAL_37]] : f641362// CHECK: }1363// CHECK: scf.yield %[[VAL_93:.*]] : f641364// CHECK: }1365// CHECK: scf.yield %[[VAL_94:.*]] : f641366// CHECK: }1367// CHECK: scf.yield %[[VAL_95:.*]] : f641368// CHECK: }1369// CHECK: scf.yield %[[VAL_96:.*]] : f641370// CHECK: }1371// CHECK: scf.yield %[[VAL_97:.*]] : f641372// CHECK: }1373// CHECK: scf.yield %[[VAL_98:.*]] : f641374// CHECK: }1375// CHECK: %[[VAL_99:.*]] = arith.cmpi eq, %[[VAL_38]], %[[VAL_44]] : index1376// CHECK: %[[VAL_100:.*]] = arith.addi %[[VAL_34]], %[[VAL_5]] : index1377// CHECK: %[[VAL_101:.*]] = arith.select %[[VAL_99]], %[[VAL_100]], %[[VAL_34]] : index1378// CHECK: %[[VAL_102:.*]] = arith.cmpi eq, %[[VAL_39]], %[[VAL_44]] : index1379// CHECK: %[[VAL_103:.*]] = arith.addi %[[VAL_35]], %[[VAL_5]] : index1380// CHECK: %[[VAL_104:.*]] = arith.select %[[VAL_102]], %[[VAL_103]], %[[VAL_35]] : index1381// CHECK: %[[VAL_105:.*]] = arith.cmpi eq, %[[VAL_42]], %[[VAL_44]] : index1382// CHECK: %[[VAL_106:.*]] = arith.addi %[[VAL_36]], %[[VAL_5]] : index1383// CHECK: %[[VAL_107:.*]] = arith.select %[[VAL_105]], %[[VAL_106]], %[[VAL_36]] : index1384// CHECK: scf.yield %[[VAL_101]], %[[VAL_104]], %[[VAL_107]], %[[VAL_108:.*]] : index, index, index, f641385// CHECK: }1386// CHECK: %[[VAL_109:.*]]:3 = scf.while (%[[VAL_110:.*]] = %[[VAL_111:.*]]#1, %[[VAL_112:.*]] = %[[VAL_111]]#2, %[[VAL_113:.*]] = %[[VAL_111]]#3) : (index, index, f64) -> (index, index, f64) {1387// CHECK: %[[VAL_114:.*]] = arith.cmpi ult, %[[VAL_110]], %[[VAL_21]] : index1388// CHECK: %[[VAL_115:.*]] = arith.cmpi ult, %[[VAL_112]], %[[VAL_23]] : index1389// CHECK: %[[VAL_116:.*]] = arith.andi %[[VAL_114]], %[[VAL_115]] : i11390// CHECK: scf.condition(%[[VAL_116]]) %[[VAL_110]], %[[VAL_112]], %[[VAL_113]] : index, index, f641391// CHECK: } do {1392// CHECK: ^bb0(%[[VAL_117:.*]]: index, %[[VAL_118:.*]]: index, %[[VAL_119:.*]]: f64):1393// CHECK: %[[VAL_120:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_117]]] : memref<?xindex>1394// CHECK: %[[VAL_121:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_118]]] : memref<?xindex>1395// CHECK: %[[VAL_122:.*]] = arith.cmpi ult, %[[VAL_121]], %[[VAL_120]] : index1396// CHECK: %[[VAL_123:.*]] = arith.select %[[VAL_122]], %[[VAL_121]], %[[VAL_120]] : index1397// CHECK: %[[VAL_124:.*]] = arith.cmpi eq, %[[VAL_120]], %[[VAL_123]] : index1398// CHECK: %[[VAL_125:.*]] = arith.cmpi eq, %[[VAL_121]], %[[VAL_123]] : index1399// CHECK: %[[VAL_126:.*]] = arith.andi %[[VAL_124]], %[[VAL_125]] : i11400// CHECK: %[[VAL_127:.*]] = scf.if %[[VAL_126]] -> (f64) {1401// CHECK: %[[VAL_128:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_117]]] : memref<?xf64>1402// CHECK: %[[VAL_129:.*]] = arith.addf %[[VAL_119]], %[[VAL_128]] : f641403// CHECK: %[[VAL_130:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_118]]] : memref<?xf64>1404// CHECK: %[[VAL_131:.*]] = arith.addf %[[VAL_129]], %[[VAL_130]] : f641405// CHECK: scf.yield %[[VAL_131]] : f641406// CHECK: } else {1407// CHECK: %[[VAL_132:.*]] = arith.cmpi eq, %[[VAL_121]], %[[VAL_123]] : index1408// CHECK: %[[VAL_133:.*]] = scf.if %[[VAL_132]] -> (f64) {1409// CHECK: %[[VAL_134:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_118]]] : memref<?xf64>1410// CHECK: %[[VAL_135:.*]] = arith.addf %[[VAL_119]], %[[VAL_134]] : f641411// CHECK: scf.yield %[[VAL_135]] : f641412// CHECK: } else {1413// CHECK: %[[VAL_136:.*]] = arith.cmpi eq, %[[VAL_120]], %[[VAL_123]] : index1414// CHECK: %[[VAL_137:.*]] = scf.if %[[VAL_136]] -> (f64) {1415// CHECK: %[[VAL_138:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_117]]] : memref<?xf64>1416// CHECK: %[[VAL_139:.*]] = arith.addf %[[VAL_119]], %[[VAL_138]] : f641417// CHECK: scf.yield %[[VAL_139]] : f641418// CHECK: } else {1419// CHECK: scf.yield %[[VAL_119]] : f641420// CHECK: }1421// CHECK: scf.yield %[[VAL_140:.*]] : f641422// CHECK: }1423// CHECK: scf.yield %[[VAL_141:.*]] : f641424// CHECK: }1425// CHECK: %[[VAL_142:.*]] = arith.cmpi eq, %[[VAL_120]], %[[VAL_123]] : index1426// CHECK: %[[VAL_143:.*]] = arith.addi %[[VAL_117]], %[[VAL_5]] : index1427// CHECK: %[[VAL_144:.*]] = arith.select %[[VAL_142]], %[[VAL_143]], %[[VAL_117]] : index1428// CHECK: %[[VAL_145:.*]] = arith.cmpi eq, %[[VAL_121]], %[[VAL_123]] : index1429// CHECK: %[[VAL_146:.*]] = arith.addi %[[VAL_118]], %[[VAL_5]] : index1430// CHECK: %[[VAL_147:.*]] = arith.select %[[VAL_145]], %[[VAL_146]], %[[VAL_118]] : index1431// CHECK: scf.yield %[[VAL_144]], %[[VAL_147]], %[[VAL_148:.*]] : index, index, f641432// CHECK: }1433// CHECK: %[[VAL_149:.*]]:3 = scf.while (%[[VAL_150:.*]] = %[[VAL_151:.*]]#0, %[[VAL_152:.*]] = %[[VAL_153:.*]]#1, %[[VAL_154:.*]] = %[[VAL_153]]#2) : (index, index, f64) -> (index, index, f64) {1434// CHECK: %[[VAL_155:.*]] = arith.cmpi ult, %[[VAL_150]], %[[VAL_19]] : index1435// CHECK: %[[VAL_156:.*]] = arith.cmpi ult, %[[VAL_152]], %[[VAL_23]] : index1436// CHECK: %[[VAL_157:.*]] = arith.andi %[[VAL_155]], %[[VAL_156]] : i11437// CHECK: scf.condition(%[[VAL_157]]) %[[VAL_150]], %[[VAL_152]], %[[VAL_154]] : index, index, f641438// CHECK: } do {1439// CHECK: ^bb0(%[[VAL_158:.*]]: index, %[[VAL_159:.*]]: index, %[[VAL_160:.*]]: f64):1440// CHECK: %[[VAL_161:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_158]]] : memref<?xindex>1441// CHECK: %[[VAL_162:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_159]]] : memref<?xindex>1442// CHECK: %[[VAL_163:.*]] = arith.cmpi ult, %[[VAL_162]], %[[VAL_161]] : index1443// CHECK: %[[VAL_164:.*]] = arith.select %[[VAL_163]], %[[VAL_162]], %[[VAL_161]] : index1444// CHECK: %[[VAL_165:.*]] = arith.cmpi eq, %[[VAL_161]], %[[VAL_164]] : index1445// CHECK: %[[VAL_166:.*]] = arith.cmpi eq, %[[VAL_162]], %[[VAL_164]] : index1446// CHECK: %[[VAL_167:.*]] = arith.andi %[[VAL_165]], %[[VAL_166]] : i11447// CHECK: %[[VAL_168:.*]] = scf.if %[[VAL_167]] -> (f64) {1448// CHECK: %[[VAL_169:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_158]]] : memref<?xf64>1449// CHECK: %[[VAL_170:.*]] = arith.addf %[[VAL_160]], %[[VAL_169]] : f641450// CHECK: %[[VAL_171:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_159]]] : memref<?xf64>1451// CHECK: %[[VAL_172:.*]] = arith.addf %[[VAL_170]], %[[VAL_171]] : f641452// CHECK: scf.yield %[[VAL_172]] : f641453// CHECK: } else {1454// CHECK: %[[VAL_173:.*]] = arith.cmpi eq, %[[VAL_162]], %[[VAL_164]] : index1455// CHECK: %[[VAL_174:.*]] = scf.if %[[VAL_173]] -> (f64) {1456// CHECK: %[[VAL_175:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_159]]] : memref<?xf64>1457// CHECK: %[[VAL_176:.*]] = arith.addf %[[VAL_160]], %[[VAL_175]] : f641458// CHECK: scf.yield %[[VAL_176]] : f641459// CHECK: } else {1460// CHECK: %[[VAL_177:.*]] = arith.cmpi eq, %[[VAL_161]], %[[VAL_164]] : index1461// CHECK: %[[VAL_178:.*]] = scf.if %[[VAL_177]] -> (f64) {1462// CHECK: %[[VAL_179:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_158]]] : memref<?xf64>1463// CHECK: %[[VAL_180:.*]] = arith.addf %[[VAL_160]], %[[VAL_179]] : f641464// CHECK: scf.yield %[[VAL_180]] : f641465// CHECK: } else {1466// CHECK: scf.yield %[[VAL_160]] : f641467// CHECK: }1468// CHECK: scf.yield %[[VAL_181:.*]] : f641469// CHECK: }1470// CHECK: scf.yield %[[VAL_182:.*]] : f641471// CHECK: }1472// CHECK: %[[VAL_183:.*]] = arith.cmpi eq, %[[VAL_161]], %[[VAL_164]] : index1473// CHECK: %[[VAL_184:.*]] = arith.addi %[[VAL_158]], %[[VAL_5]] : index1474// CHECK: %[[VAL_185:.*]] = arith.select %[[VAL_183]], %[[VAL_184]], %[[VAL_158]] : index1475// CHECK: %[[VAL_186:.*]] = arith.cmpi eq, %[[VAL_162]], %[[VAL_164]] : index1476// CHECK: %[[VAL_187:.*]] = arith.addi %[[VAL_159]], %[[VAL_5]] : index1477// CHECK: %[[VAL_188:.*]] = arith.select %[[VAL_186]], %[[VAL_187]], %[[VAL_159]] : index1478// CHECK: scf.yield %[[VAL_185]], %[[VAL_188]], %[[VAL_189:.*]] : index, index, f641479// CHECK: }1480// CHECK: %[[VAL_190:.*]] = scf.for %[[VAL_191:.*]] = %[[VAL_192:.*]]#1 to %[[VAL_23]] step %[[VAL_5]] iter_args(%[[VAL_193:.*]] = %[[VAL_192]]#2) -> (f64) {1481// CHECK: %[[VAL_194:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_191]]] : memref<?xf64>1482// CHECK: %[[VAL_195:.*]] = arith.addf %[[VAL_193]], %[[VAL_194]] : f641483// CHECK: scf.yield %[[VAL_195]] : f641484// CHECK: }1485// CHECK: %[[VAL_196:.*]]:3 = scf.while (%[[VAL_197:.*]] = %[[VAL_198:.*]]#0, %[[VAL_199:.*]] = %[[VAL_200:.*]]#0, %[[VAL_201:.*]] = %[[VAL_202:.*]]) : (index, index, f64) -> (index, index, f64) {1486// CHECK: %[[VAL_203:.*]] = arith.cmpi ult, %[[VAL_197]], %[[VAL_19]] : index1487// CHECK: %[[VAL_204:.*]] = arith.cmpi ult, %[[VAL_199]], %[[VAL_21]] : index1488// CHECK: %[[VAL_205:.*]] = arith.andi %[[VAL_203]], %[[VAL_204]] : i11489// CHECK: scf.condition(%[[VAL_205]]) %[[VAL_197]], %[[VAL_199]], %[[VAL_201]] : index, index, f641490// CHECK: } do {1491// CHECK: ^bb0(%[[VAL_206:.*]]: index, %[[VAL_207:.*]]: index, %[[VAL_208:.*]]: f64):1492// CHECK: %[[VAL_209:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_206]]] : memref<?xindex>1493// CHECK: %[[VAL_210:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_207]]] : memref<?xindex>1494// CHECK: %[[VAL_211:.*]] = arith.cmpi ult, %[[VAL_210]], %[[VAL_209]] : index1495// CHECK: %[[VAL_212:.*]] = arith.select %[[VAL_211]], %[[VAL_210]], %[[VAL_209]] : index1496// CHECK: %[[VAL_213:.*]] = arith.cmpi eq, %[[VAL_209]], %[[VAL_212]] : index1497// CHECK: %[[VAL_214:.*]] = arith.cmpi eq, %[[VAL_210]], %[[VAL_212]] : index1498// CHECK: %[[VAL_215:.*]] = arith.andi %[[VAL_213]], %[[VAL_214]] : i11499// CHECK: %[[VAL_216:.*]] = scf.if %[[VAL_215]] -> (f64) {1500// CHECK: %[[VAL_217:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_206]]] : memref<?xf64>1501// CHECK: %[[VAL_218:.*]] = arith.addf %[[VAL_208]], %[[VAL_217]] : f641502// CHECK: %[[VAL_219:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_207]]] : memref<?xf64>1503// CHECK: %[[VAL_220:.*]] = arith.addf %[[VAL_218]], %[[VAL_219]] : f641504// CHECK: scf.yield %[[VAL_220]] : f641505// CHECK: } else {1506// CHECK: %[[VAL_221:.*]] = arith.cmpi eq, %[[VAL_210]], %[[VAL_212]] : index1507// CHECK: %[[VAL_222:.*]] = scf.if %[[VAL_221]] -> (f64) {1508// CHECK: %[[VAL_223:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_207]]] : memref<?xf64>1509// CHECK: %[[VAL_224:.*]] = arith.addf %[[VAL_208]], %[[VAL_223]] : f641510// CHECK: scf.yield %[[VAL_224]] : f641511// CHECK: } else {1512// CHECK: %[[VAL_225:.*]] = arith.cmpi eq, %[[VAL_209]], %[[VAL_212]] : index1513// CHECK: %[[VAL_226:.*]] = scf.if %[[VAL_225]] -> (f64) {1514// CHECK: %[[VAL_227:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_206]]] : memref<?xf64>1515// CHECK: %[[VAL_228:.*]] = arith.addf %[[VAL_208]], %[[VAL_227]] : f641516// CHECK: scf.yield %[[VAL_228]] : f641517// CHECK: } else {1518// CHECK: scf.yield %[[VAL_208]] : f641519// CHECK: }1520// CHECK: scf.yield %[[VAL_229:.*]] : f641521// CHECK: }1522// CHECK: scf.yield %[[VAL_230:.*]] : f641523// CHECK: }1524// CHECK: %[[VAL_231:.*]] = arith.cmpi eq, %[[VAL_209]], %[[VAL_212]] : index1525// CHECK: %[[VAL_232:.*]] = arith.addi %[[VAL_206]], %[[VAL_5]] : index1526// CHECK: %[[VAL_233:.*]] = arith.select %[[VAL_231]], %[[VAL_232]], %[[VAL_206]] : index1527// CHECK: %[[VAL_234:.*]] = arith.cmpi eq, %[[VAL_210]], %[[VAL_212]] : index1528// CHECK: %[[VAL_235:.*]] = arith.addi %[[VAL_207]], %[[VAL_5]] : index1529// CHECK: %[[VAL_236:.*]] = arith.select %[[VAL_234]], %[[VAL_235]], %[[VAL_207]] : index1530// CHECK: scf.yield %[[VAL_233]], %[[VAL_236]], %[[VAL_237:.*]] : index, index, f641531// CHECK: }1532// CHECK: %[[VAL_238:.*]] = scf.for %[[VAL_239:.*]] = %[[VAL_240:.*]]#1 to %[[VAL_21]] step %[[VAL_5]] iter_args(%[[VAL_241:.*]] = %[[VAL_240]]#2) -> (f64) {1533// CHECK: %[[VAL_242:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_239]]] : memref<?xf64>1534// CHECK: %[[VAL_243:.*]] = arith.addf %[[VAL_241]], %[[VAL_242]] : f641535// CHECK: scf.yield %[[VAL_243]] : f641536// CHECK: }1537// CHECK: %[[VAL_244:.*]] = scf.for %[[VAL_245:.*]] = %[[VAL_246:.*]]#0 to %[[VAL_19]] step %[[VAL_5]] iter_args(%[[VAL_247:.*]] = %[[VAL_248:.*]]) -> (f64) {1538// CHECK: %[[VAL_249:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_245]]] : memref<?xf64>1539// CHECK: %[[VAL_250:.*]] = arith.addf %[[VAL_247]], %[[VAL_249]] : f641540// CHECK: scf.yield %[[VAL_250]] : f641541// CHECK: }1542// CHECK: memref.store %[[VAL_251:.*]], %[[VAL_15]][] : memref<f64>1543// CHECK: %[[VAL_252:.*]] = bufferization.to_tensor %[[VAL_15]] : memref<f64>1544// CHECK: return %[[VAL_252]] : tensor<f64>1545// CHECK: }1546func.func @red3s(%arga: tensor<?xf64, #SV>,1547 %argb: tensor<?xf64, #SV>,1548 %argc: tensor<?xf64, #SV>, %argx: tensor<f64>) ->tensor<f64>{1549 %0 = linalg.generic #trait_red3s1550 ins(%arga, %argb, %argc: tensor<?xf64, #SV>, tensor<?xf64, #SV>, tensor<?xf64, #SV>)1551 outs(%argx: tensor<f64>) {1552 ^bb(%a: f64,%b: f64,%c: f64,%x: f64):1553 %0 = arith.addf %x, %a : f641554 %1 = arith.addf %0, %b : f641555 %2 = arith.addf %1, %c : f641556 linalg.yield %2 : f641557 } -> tensor<f64>1558 return %0 : tensor<f64>1559}1560