[MLIR] add negi in standard dialect

[• qqsun8819]

Summary

Now we only have negf to accept float arguments. In llvm ir neg can also support integer arguments,
so add a negi in standard dialect so that neg can support integer arguments
This patch is inspired by lowering TF dialect to HLO dialect when a hlo.neg is created whose argument is integer, like:

%1 = "xla_hlo.neg"(%13) : (tensor<64>) -> tensor<i64>

[mehdi_amini]

I understand that this is present in TF and HLO, but do we need this in standard right now? How do you plan to use this?
(It seems like this isn't an instruction in LLVM right now)

[ftynse]

I think integer negation is always okay being implemented as "0 - x" (the only dangerous case is signed INT_MIN, but negating it leads to overflow in any case). This isn't the case for floating point numbers because of special values (nan/inf) and normalization, so it needs an instruction.

[• qqsun8819]

In D75662#1907027, @mehdi_amini wrote:

I understand that this is present in TF and HLO, but do we need this in standard right now? How do you plan to use this?
(It seems like this isn't an instruction in LLVM right now)

I create a pr in TF to add use this instruction in lhlo lowering to linalg : https://github.com/tensorflow/tensorflow/pull/37381

[ftynse]

In D75662#1909044, @qqsun8819 wrote:

In D75662#1907027, @mehdi_amini wrote:

I understand that this is present in TF and HLO, but do we need this in standard right now? How do you plan to use this?
(It seems like this isn't an instruction in LLVM right now)

I create a pr in TF to add use this instruction in lhlo lowering to linalg : https://github.com/tensorflow/tensorflow/pull/37381

And what prevents you from emitting

%0 = constant 0 : i??
%1 = cmpi "slt" %arg, %0 : i??
%2 = subi %0, %arg : i??
%3 = select %1, %2, %arg

there instead of changing the standard dialect?

[• qqsun8819]

solved in https://github.com/tensorflow/tensorflow/pull/37381 no need to modify standard dialect

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 def LLVM_URemOp : LLVM_ArithmeticOp<"urem", "CreateURem">;
 def LLVM_SRemOp : LLVM_ArithmeticOp<"srem", "CreateSRem">;
 def LLVM_AndOp : LLVM_ArithmeticOp<"and", "CreateAnd">;
 def LLVM_OrOp : LLVM_ArithmeticOp<"or", "CreateOr">;
 def LLVM_XOrOp : LLVM_ArithmeticOp<"xor", "CreateXor">;
 def LLVM_ShlOp : LLVM_ArithmeticOp<"shl", "CreateShl">;
 def LLVM_LShrOp : LLVM_ArithmeticOp<"lshr", "CreateLShr">;
 def LLVM_AShrOp : LLVM_ArithmeticOp<"ashr", "CreateAShr">;
+def LLVM_NegOp : LLVM_UnaryArithmeticOp<"neg", "CreateNeg">;
 
 // Predicate for integer comparisons.
 def ICmpPredicateEQ  : I64EnumAttrCase<"eq", 0>;
 def ICmpPredicateNE  : I64EnumAttrCase<"ne", 1>;
 def ICmpPredicateSLT : I64EnumAttrCase<"slt", 2>;
 def ICmpPredicateSLE : I64EnumAttrCase<"sle", 3>;
 def ICmpPredicateSGT : I64EnumAttrCase<"sgt", 4>;
 def ICmpPredicateSGE : I64EnumAttrCase<"sge", 5>;

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 class UnaryOpSameOperandAndResultType<string mnemonic,
                                       list<OpTrait> traits = []> :
     UnaryOp<mnemonic, !listconcat(traits, [SameOperandsAndResultType])> {
   let parser = [{
     return impl::parseOneResultSameOperandTypeOp(parser, result);
   }];
 }
 
+class IntegerUnaryOp<string mnemonic, list<OpTrait> traits = []> :
+    UnaryOpSameOperandAndResultType<mnemonic, traits>,
+    Arguments<(ins SignlessIntegerLike:$operand)>;
+
 class FloatUnaryOp<string mnemonic, list<OpTrait> traits = []> :
     UnaryOpSameOperandAndResultType<mnemonic, traits>,
     Arguments<(ins FloatLike:$operand)>;
 
 // Base class for standard arithmetic operations.  Requires operands and
 // results to be of the same type, but does not constrain them to specific
 // types.  Individual classes will have `lhs` and `rhs` accessor to operands.
 class ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
def NegFOp : FloatUnaryOp<"negf"> {
   let description = [{
     The `negf` operation computes the negation of a given value. It takes one
     operand and returns one result of the same type. This type may be a float
     scalar type, a vector whose element type is float, or a tensor of floats.
     It has no standard attributes.
   }];
 }
 
+def NegIOp : IntegerUnaryOp<"negi"> {
+  let summary = "integer negation";
+  let description = [{
+    The `negi` operation computes the negation of a given value. It takes one
+    operand and returns one result of the same type. This type may be a integer 
+    scalar type, a vector whose element type is integer, or a tensor of integers.
+    It has no standard attributes.
+  }];
+}
+  
 def OrOp : IntArithmeticOp<"or", [Commutative]> {
   let summary = "integer binary or";
   let hasFolder = 1;
 }
 
 def PrefetchOp : Std_Op<"prefetch"> {
   let summary = "prefetch operation";
   let description = [{

mlir/lib/Conversion/StandardToLLVM/ConvertStandardToLLVM.cpp

struct Log10OpLowering : public UnaryOpLLVMOpLowering<Log10Op, LLVM::Log10Op> {
   using Super::Super;
 };
 struct Log2OpLowering : public UnaryOpLLVMOpLowering<Log2Op, LLVM::Log2Op> {
   using Super::Super;
 };
 struct NegFOpLowering : public UnaryOpLLVMOpLowering<NegFOp, LLVM::FNegOp> {
   using Super::Super;
 };
+struct NegIOpLowering : public UnaryOpLLVMOpLowering<NegIOp, LLVM::NegOp> {
+  using Super::Super;
+};
 struct AddIOpLowering : public BinaryOpLLVMOpLowering<AddIOp, LLVM::AddOp> {
   using Super::Super;
 };
 struct SubIOpLowering : public BinaryOpLLVMOpLowering<SubIOp, LLVM::SubOp> {
   using Super::Super;
 };
 struct MulIOpLowering : public BinaryOpLLVMOpLowering<MulIOp, LLVM::MulOp> {
   using Super::Super;
patterns.insert<
       Log10OpLowering,
       Log2OpLowering,
       FPExtLowering,
       FPTruncLowering,
       IndexCastOpLowering,
       MulFOpLowering,
       MulIOpLowering,
       NegFOpLowering,
+      NegIOpLowering,
       OrOpLowering,
       PrefetchOpLowering,
       RemFOpLowering,
       ReturnOpLowering,
       SIToFPLowering,
       SelectOpLowering,
       ShiftLeftOpLowering,
       SignExtendIOpLowering,