[Mlir-commits] [mlir] [mlir][SparseTensor] Fix crash in SparseTensorEmptyConverter (PR #208913)

[Hocky Yudhiono]

================

----------------
hockyy wrote:

I just generated some other ops btw, it seems like these are failing too
```

// SparseTensorAllocConverter
func.func @alloc_tensor_i1_elem_type(%sz: index) -> tensor<?xi1, #sparse1d> {
  %0 = bufferization.alloc_tensor(%sz) : tensor<?xi1, #sparse1d>
  return %0 : tensor<?xi1, #sparse1d>
}

// SparseTensorReorderCOOConverter
func.func @reorder_coo_i1_elem_type(%arg0: tensor<?x?xi1, #unordered_coo>)
    -> tensor<?x?xi1, #ordered_coo> {
  %0 = sparse_tensor.reorder_coo quick_sort %arg0
    : tensor<?x?xi1, #unordered_coo> to tensor<?x?xi1, #ordered_coo>
  return %0 : tensor<?x?xi1, #ordered_coo>
}

// SparseTensorAssembleConverter
func.func @assemble_i1_elem_type(%pos: tensor<2xindex>, %coords: tensor<4x1xindex>,
                                 %vals: tensor<4xi1>) -> tensor<8xi1, #sparse1d> {
  %0 = sparse_tensor.assemble (%pos, %coords), %vals
    : (tensor<2xindex>, tensor<4x1xindex>), tensor<4xi1> to tensor<8xi1, #sparse1d>
  return %0 : tensor<8xi1, #sparse1d>
}

// SparseTensorToValuesConverter
func.func @values_i1_elem_type(%arg0: tensor<8xi1, #sparse1d>) -> memref<?xi1> {
  %0 = sparse_tensor.values %arg0 : tensor<8xi1, #sparse1d> to memref<?xi1>
  return %0 : memref<?xi1>
}

// SparseNumberOfEntriesConverter
func.func @number_of_entries_i1_elem_type(%arg0: tensor<8xi1, #sparse1d>) -> index {
  %0 = sparse_tensor.number_of_entries %arg0 : tensor<8xi1, #sparse1d>
  return %0 : index
}

// SparseTensorDisassembleConverter
func.func @disassemble_i1_elem_type(%sp: tensor<8xi1, #sparse1d>,
                                      %op: tensor<2xindex>, %oi: tensor<4x1xindex>,
                                      %od: tensor<4xi1>)
    -> (tensor<2xindex>, tensor<4x1xindex>, tensor<4xi1>) {
  %rp, %ri, %d, %rpl, %ril, %dl = sparse_tensor.disassemble %sp
    : tensor<8xi1, #sparse1d>
    out_lvls(%op, %oi : tensor<2xindex>, tensor<4x1xindex>)
    out_vals(%od : tensor<4xi1>)
    -> (tensor<2xindex>, tensor<4x1xindex>), tensor<4xi1>, (index, index), index
  return %rp, %ri, %d : tensor<2xindex>, tensor<4x1xindex>, tensor<4xi1>
}

// SparseTensorInsertConverter
func.func @insert_i1_elem_type(%arg0: tensor<8xi1, #sparse1d>, %idx: index, %val: i1)
    -> tensor<8xi1, #sparse1d> {
  %0 = tensor.insert %val into %arg0[%idx] : tensor<8xi1, #sparse1d>
  return %0 : tensor<8xi1, #sparse1d>
}

// SparseTensorCompressConverter
func.func @compress_i1_elem_type(%tensor: tensor<8x8xi1, #csr>,
                                 %values: memref<?xi1>, %filled: memref<?xi1>,
                                 %added: memref<?xindex>, %count: index, %i: index)
    -> tensor<8x8xi1, #csr> {
  %0 = sparse_tensor.compress %values, %filled, %added, %count into %tensor[%i]
    : memref<?xi1>, memref<?xi1>, memref<?xindex>, tensor<8x8xi1, #csr>
  return %0 : tensor<8x8xi1, #csr>
}

```

https://github.com/llvm/llvm-project/pull/208913