[mlir] Add ConstantLike trait to LLVM::ConstantOp

[ftynse]

Summary

This make LLVM dialect constants to work with m_constant matches. Implement
the folding hook for this operation as required by the trait. This in turn
allows LLVM::ConstantOp to properly participate in constant-folding.

Depends On D116757

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

let description = [{
     ```
   }];
   let results = (outs LLVM_Type:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
 def LLVM_ConstantOp
-    : LLVM_Op<"mlir.constant", [NoSideEffect]>,
+    : LLVM_Op<"mlir.constant", [NoSideEffect, ConstantLike]>,
       LLVM_Builder<[{$res = getLLVMConstant($_resultType, $value, $_location,
                                             moduleTranslation);}]>
 {
   let summary = "Defines a constant of LLVM type.";
   let description = [{
     Unlike LLVM IR, MLIR does not have first-class constant values. Therefore,
     all constants must be created as SSA values before being used in other
     operations. `llvm.mlir.constant` creates such values for scalars and
let description = [{
     ```
   }];
 
   let arguments = (ins AnyAttr:$value);
   let results = (outs LLVM_Type:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "`(` $value `)` attr-dict `:` type($res)";
   let verifier = [{ return ::verify(*this); }];
+  let hasFolder = 1;
 }
 
 // Operations that correspond to LLVM intrinsics. With MLIR operation set being
 // extendable, there is no reason to introduce a hard boundary between "core"
 // operations and intrinsics. However, we systematically prefix them with
 // "intr." to avoid potential name clashes.
 
 class LLVM_UnaryIntrinsicOp<string func, list<OpTrait> traits = []> :

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

if (auto structType = op.getType().dyn_cast<LLVMStructType>()) {
     return success();
   }
   if (!op.getValue().isa<IntegerAttr, ArrayAttr, FloatAttr, ElementsAttr>())
     return op.emitOpError()
            << "only supports integer, float, string or elements attributes";
   return success();
 }
 
+// Constant op constant-folds to its value.
+OpFoldResult LLVM::ConstantOp::fold(ArrayRef<Attribute>) { return getValue(); }
+
 //===----------------------------------------------------------------------===//
 // Utility functions for parsing atomic ops
 //===----------------------------------------------------------------------===//
 
 // Helper function to parse a keyword into the specified attribute named by
 // `attrName`. The keyword must match one of the string values defined by the
 // AtomicBinOp enum. The resulting I64 attribute is added to the `result`
 // state.

mlir/test/Dialect/LLVMIR/canonicalize.mlir

llvm.func @no_fold_extractvalue(%arr: !llvm.array<4xf32>) -> f32 {
   %1 = llvm.insertvalue %f0, %0[0, 0] : !llvm.array<4 x !llvm.array<4xf32>>
   %2 = llvm.insertvalue %arr, %1[0] : !llvm.array<4 x !llvm.array<4xf32>>
   %3 = llvm.extractvalue %2[0, 0] : !llvm.array<4 x !llvm.array<4xf32>>
 
   llvm.return %3 : f32
 }
 
 // -----
+
 // CHECK-LABEL: fold_bitcast
 // CHECK-SAME: %[[a0:arg[0-9]+]]
 // CHECK-NEXT: llvm.return %[[a0]]
 llvm.func @fold_bitcast(%x : !llvm.ptr<i8>) -> !llvm.ptr<i8> {
   %c = llvm.bitcast %x : !llvm.ptr<i8> to !llvm.ptr<i8>
   llvm.return %c : !llvm.ptr<i8>
 }
 

 // CHECK-SAME: %[[a0:arg[0-9]+]]
 // CHECK-NEXT: llvm.return %[[a0]]
 llvm.func @fold_gep(%x : !llvm.ptr<i8>) -> !llvm.ptr<i8> {
   %c0 = arith.constant 0 : i32
   %c = llvm.getelementptr %x[%c0] : (!llvm.ptr<i8>, i32) -> !llvm.ptr<i8>
   llvm.return %c : !llvm.ptr<i8>
 }
 
+// -----
+
+// Check that LLVM constants participate in cross-dialect constant folding. The
+// resulting constant is created in the arith dialect because the last folded
+// operation belongs to it.
+// CHECK-LABEL: llvm_constant
+func @llvm_constant() -> i32 {
+  // CHECK-NOT: llvm.mlir.constant
+  %0 = llvm.mlir.constant(40 : i32) : i32
+  %1 = llvm.mlir.constant(42 : i32) : i32
+  // CHECK: %[[RES:.*]] = arith.constant 82 : i32
+  // CHECK-NOT: arith.addi
+  %2 = arith.addi %0, %1 : i32
+  // CHECK: return %[[RES]]
+  return %2 : i32
+}