[mlir][llvm] Add poison constant.

[Moxinilian]

Summary

This patch introduces the poison constant from LLVM in the LLVM IR dialect. It also adds import and export support for it, along with roundtrip tests.

[gysit]

I suggest to update the commit title / message to "Introduce poison operation" since it is actually an operation in MLIR.

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

1676

nit: I think "wrapping an LLVM IR structure type" can be dropped here?

mlir/test/Dialect/LLVMIR/roundtrip.mlir

445

nit: Let's use a bit longer variable names in the tests. Here I would suggest:
x -> UNDEF
y -> POISON

[Moxinilian]

Address comments.

mlir/docs/Dialects/LLVM.md

 ### Context-Level Values
 
 Some value kinds in LLVM IR, such as constants and undefs, are uniqued in
 context and used directly in relevant operations. MLIR does not support such
 values for thread-safety and concept parsimony reasons. Instead, regular values
 are produced by dedicated operations that have the corresponding semantics:
 [`llvm.mlir.constant`](#llvmmlirconstant-mlirllvmconstantop),
 [`llvm.mlir.undef`](#llvmmlirundef-mlirllvmundefop),
+[`llvm.mlir.poison`](#llvmmlirpoison-mlirllvmpoisonop),
 [`llvm.mlir.null`](#llvmmlirnull-mlirllvmnullop). Note how these operations are
 prefixed with `mlir.` to indicate that they don't belong to LLVM IR but are only
 necessary to model it in MLIR. The values produced by these operations are
 usable just like any other value.
 
 Examples:
 
 ```mlir

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

let description = [{
     %0 = llvm.mlir.undef : !llvm.struct<(i32, f32)>
     ```
   }];
   let results = (outs LLVM_Type:$res);
   let builders = [LLVM_OneResultOpBuilder];
   let assemblyFormat = "attr-dict `:` type($res)";
 }
 
+def LLVM_PoisonOp : LLVM_Op<"mlir.poison", [Pure]>,
+                    LLVM_Builder<"$res = llvm::PoisonValue::get($_resultType);"> {
+  let summary = "Creates a poison value of LLVM dialect type.";
+  let description = [{
+    Unlike LLVM IR, MLIR does not have first-class poison values. Such values
+    must be created as SSA values using `llvm.mlir.poison`. This operation has
+    no operands or attributes. It creates a poison value of the specified LLVM
+    IR dialect type wrapping an LLVM IR structure type.
+
+    Example:
+
+    ```mlir
+    // Create a poison value for a structure with a 32-bit integer followed
+    // by a float.
+    %0 = llvm.mlir.poison : !llvm.struct<(i32, f32)>
+    ```
+  }];
+  let results = (outs LLVM_Type:$res);
+  let builders = [LLVM_OneResultOpBuilder];
+  let assemblyFormat = "attr-dict `:` type($res)";
+}
+
 def LLVM_ConstantOp
     : LLVM_Op<"mlir.constant", [Pure, 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,

mlir/lib/Target/LLVMIR/ModuleImport.cpp

FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
   }
 
   // Convert null pointer constants.
   if (auto *nullPtr = dyn_cast<llvm::ConstantPointerNull>(constant)) {
     Type type = convertType(nullPtr->getType());
     return builder.create<NullOp>(loc, type).getResult();
   }
 
+  // Convert poison.
+  if (auto *poisonVal = dyn_cast<llvm::PoisonValue>(constant)) {
+    Type type = convertType(poisonVal->getType());
+    return builder.create<PoisonOp>(loc, type).getResult();
+  }
+
   // Convert undef.
   if (auto *undefVal = dyn_cast<llvm::UndefValue>(constant)) {
     Type type = convertType(undefVal->getType());
     return builder.create<UndefOp>(loc, type).getResult();
   }
 
   // Convert global variable accesses.
   if (auto *globalVar = dyn_cast<llvm::GlobalVariable>(constant)) {

mlir/test/Dialect/LLVMIR/roundtrip.mlir

 // CHECK-LABEL: @useFreezeOp
 func.func @useFreezeOp(%arg0: i32) {
   // CHECK:  = llvm.freeze %[[ARG0:.*]] : i32
   %0 = llvm.freeze %arg0 : i32
   // CHECK: %[[x:.*]] = llvm.mlir.undef : i8
   %1 = llvm.mlir.undef : i8
   // CHECK:  = llvm.freeze %[[x]] : i8
   %2 = llvm.freeze %1 : i8
+  // CHECK: %[[y:.*]] = llvm.mlir.poison : i8
+  %3 = llvm.mlir.poison : i8
+  // CHECK:  = llvm.freeze %[[y]] : i8
+  %4 = llvm.freeze %3 : i8
   return
 }
 
 // CHECK-LABEL: @useFenceInst
 func.func @useFenceInst() {
   // CHECK:  syncscope("agent") seq_cst
   llvm.fence syncscope("agent") seq_cst
   // CHECK:  seq_cst

mlir/test/Target/LLVMIR/Import/instructions.ll

 }
 
 ; // -----
 
 ; CHECK-LABEL: @freeze
 ; CHECK-SAME:  %[[ARG1:[a-zA-Z0-9]+]]
 define void @freeze(i32 %arg1) {
   ; CHECK:  %[[UNDEF:[0-9]+]] = llvm.mlir.undef : i64
+  ; CHECK:  %[[POISON:[0-9]+]] = llvm.mlir.poison : i16
   ; CHECK:  llvm.freeze %[[ARG1]] : i32
   ; CHECK:  llvm.freeze %[[UNDEF]] : i64
+  ; CHECK:  llvm.freeze %[[POISON]] : i16
   %1 = freeze i32 %arg1
   %2 = freeze i64 undef
+  %3 = freeze i16 poison
   ret void
 }
 
 ; // -----
 
 ; CHECK-LABEL: @unreachable
 define void @unreachable() {
   ; CHECK:  llvm.unreachable

mlir/test/Target/LLVMIR/llvmir.mlir

 
 // CHECK-LABEL: @callFreezeOp
 llvm.func @callFreezeOp(%x : i32) {
   // CHECK: freeze i32 %{{[0-9]+}}
   %0 = llvm.freeze %x : i32
   %1 = llvm.mlir.undef : i32
   // CHECK: freeze i32 undef
   %2 = llvm.freeze %1 : i32
+  %3 = llvm.mlir.poison : i32
+  // CHECK: freeze i32 poison
+  %4 = llvm.freeze %3 : i32
   llvm.return
 }
 
 // CHECK-LABEL: @freezeUsed
 llvm.func @freezeUsed(%x : i32) -> i64 {
   // CHECK: %[[frozen:.*]] = freeze i32
   %frozen = llvm.freeze %x : i32
   // CHECK: %[[ext:.*]] = sext i32 %[[frozen]] to i64