[mlir][sparse] simplify negi code generation with subi

[aartbik]

Summary

The lack of negi details leaked from merger class into codegen part.
Also, special case for vector code was not needed, the type can be used directly!

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

static Value genExp(Merger &merger, CodeGen &codegen, PatternRewriter &rewriter,
   if (exp == -1u)
     return Value();
   if (merger.exp(exp).kind == Kind::kTensor)
     return genTensorLoad(merger, codegen, rewriter, op, exp);
   if (merger.exp(exp).kind == Kind::kInvariant)
     return genInvariantValue(merger, codegen, rewriter, exp);
   Value v0 = genExp(merger, codegen, rewriter, op, merger.exp(exp).children.e0);
   Value v1 = genExp(merger, codegen, rewriter, op, merger.exp(exp).children.e1);
-  if (merger.exp(exp).kind == Kind::kNegI) {
-    // TODO: no negi in std, need to make zero explicit.
-    Type tp = op.getOutputTensorTypes()[0].getElementType();
-    v1 = v0;
-    v0 = rewriter.create<ConstantOp>(loc, tp, rewriter.getZeroAttr(tp));
-    if (codegen.curVecLength > 1)
-      v0 = genVectorInvariantValue(codegen, rewriter, v0);
-  }
   return merger.buildExp(rewriter, loc, exp, v0, v1);
 }
 
 /// Determines if affine expression is invariant.
 static bool isInvariantAffine(const CodeGen &codegen, AffineExpr a,
                               unsigned ldx, bool &atLevel) {
   switch (a.getKind()) {
   case AffineExprKind::DimId: {

mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp

if (x.hasValue()) {
       unsigned e = x.getValue();
       if (isa<AbsFOp>(def))
         return addExp(kAbsF, e);
       if (isa<CeilFOp>(def))
         return addExp(kCeilF, e);
       if (isa<FloorFOp>(def))
         return addExp(kFloorF, e);
       if (isa<NegFOp>(def))
-        return addExp(kNegF, e); // TODO: no negi in std?
+        return addExp(kNegF, e); // no negi in std
       if (isa<FPTruncOp>(def))
         return addExp(kTruncF, e, v);
       if (isa<FPExtOp>(def))
         return addExp(kExtF, e, v);
       if (isa<FPToSIOp>(def))
         return addExp(kCastFS, e, v);
       if (isa<FPToUIOp>(def))
         return addExp(kCastFU, e, v);
Value Merger::buildExp(PatternRewriter &rewriter, Location loc, unsigned e,
   case kAbsF:
     return rewriter.create<AbsFOp>(loc, v0);
   case kCeilF:
     return rewriter.create<CeilFOp>(loc, v0);
   case kFloorF:
     return rewriter.create<FloorFOp>(loc, v0);
   case kNegF:
     return rewriter.create<NegFOp>(loc, v0);
-  case kNegI:
-    assert(v1); // no negi in std
-    return rewriter.create<SubIOp>(loc, v0, v1);
+  case kNegI: // no negi in std
+    return rewriter.create<SubIOp>(
+        loc,
+        rewriter.create<ConstantOp>(loc, v0.getType(),
+                                    rewriter.getZeroAttr(v0.getType())),
+        v0);
   case kTruncF:
     return rewriter.create<FPTruncOp>(loc, v0, inferType(e, v0));
   case kExtF:
     return rewriter.create<FPExtOp>(loc, v0, inferType(e, v0));
   case kCastFS:
     return rewriter.create<FPToSIOp>(loc, v0, inferType(e, v0));
   case kCastFU:
     return rewriter.create<FPToUIOp>(loc, v0, inferType(e, v0));