[mlir][llvm] Use tablegen to import extract/insert ops from LLVM IR.

[gysit]

Summary

The revision imports the extract and insert value operations using
tablegen generated builders. Additionally, it moves the tests to
the instructions.ll test file.

[gysit]

Move tests close to the extract/insert element tests.

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

let assemblyFormat = [{
     $container `` $position attr-dict `:` type($container)
     custom<InsertExtractValueElementType>(type($res), ref(type($container)),
                                           ref($position))
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
 
+  string llvmInstName = "ExtractValue";
   string llvmBuilder = [{
     $res = builder.CreateExtractValue($container, extractPosition($position));
   }];
+  string mlirBuilder = [{
+    auto *evInst = cast<llvm::ExtractValueInst>(inst);
+    $res = $_builder.create<LLVM::ExtractValueOp>($_location,
+      $container, getPositionFromIndices(evInst->getIndices()));
+  }];
 }
 
 //===----------------------------------------------------------------------===//
 // InsertElementOp
 //===----------------------------------------------------------------------===//
 
 def LLVM_InsertElementOp : LLVM_Op<"insertelement", [Pure,
     TypesMatchWith<"argument type matches vector element type", "vector",
def LLVM_InsertValueOp : LLVM_Op<
   let assemblyFormat = [{
     $value `,` $container `` $position attr-dict `:` type($container)
     custom<InsertExtractValueElementType>(type($value), ref(type($container)),
                                           ref($position))
   }];
 
   let hasVerifier = 1;
 
+  string llvmInstName = "InsertValue";
   string llvmBuilder = [{
     $res = builder.CreateInsertValue($container, $value,
                                      extractPosition($position));
   }];
+  string mlirBuilder = [{
+    auto *ivInst = cast<llvm::InsertValueInst>(inst);
+    $res = $_builder.create<LLVM::InsertValueOp>($_location,
+      $container, $value, getPositionFromIndices(ivInst->getIndices()));
+  }];
 }
 
 //===----------------------------------------------------------------------===//
 // ShuffleVectorOp
 //===----------------------------------------------------------------------===//
 
 def LLVM_ShuffleVectorOp : LLVM_Op<"shufflevector",
     [Pure, AllTypesMatch<["v1", "v2"]>]> {

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

static StringRef getLLVMSyncScope(llvm::FenceInst *fenceInst) {
   SmallVector<StringRef> syncScopeNames;
   llvmContext.getSyncScopeNames(syncScopeNames);
   for (StringRef name : syncScopeNames)
     if (fenceInst->getSyncScopeID() == llvmContext.getOrInsertSyncScopeID(name))
       return name;
   llvm_unreachable("incorrect sync scope identifier");
 }
 
+/// Converts an array of unsigned indices to a signed integer position array.
+static SmallVector<int64_t> getPositionFromIndices(ArrayRef<unsigned> indices) {
+  SmallVector<int64_t> position;
+  llvm::append_range(position, indices);
+  return position;
+}
+
 DataLayoutSpecInterface
 mlir::translateDataLayout(const llvm::DataLayout &dataLayout,
                           MLIRContext *context) {
   assert(context && "expected MLIR context");
   std::string layoutstr = dataLayout.getStringRepresentation();
 
   // Remaining unhandled default layout defaults
   // e (little endian if not set)
for (llvm::Value *operand : llvm::drop_begin(gep->operand_values())) {
       indices.push_back(val);
     }
 
     Type type = convertType(inst->getType());
     Value res = b.create<GEPOp>(loc, type, sourceElementType, basePtr, indices);
     mapValue(inst, res);
     return success();
   }
-  if (inst->getOpcode() == llvm::Instruction::InsertValue) {
-    auto *ivInst = cast<llvm::InsertValueInst>(inst);
-    Value inserted = processValue(ivInst->getInsertedValueOperand());
-    Value aggOperand = processValue(ivInst->getAggregateOperand());
-
-    SmallVector<int64_t> indices;
-    llvm::append_range(indices, ivInst->getIndices());
-    Value res = b.create<InsertValueOp>(loc, aggOperand, inserted, indices);
-    mapValue(inst, res);
-    return success();
-  }
-  if (inst->getOpcode() == llvm::Instruction::ExtractValue) {
-    auto *evInst = cast<llvm::ExtractValueInst>(inst);
-    Value aggOperand = processValue(evInst->getAggregateOperand());
-
-    SmallVector<int64_t> indices;
-    llvm::append_range(indices, evInst->getIndices());
-    Value res = b.create<ExtractValueOp>(loc, aggOperand, indices);
-    mapValue(inst, res);
-    return success();
-  }
   if (inst->getOpcode() == llvm::Instruction::ShuffleVector) {
     auto *svInst = cast<llvm::ShuffleVectorInst>(inst);
     Value vec1 = processValue(svInst->getOperand(0));
     Value vec2 = processValue(svInst->getOperand(1));
 
     SmallVector<int32_t> mask(svInst->getShuffleMask());
     Value res = b.create<ShuffleVectorOp>(loc, vec1, vec2, mask);
     mapValue(inst, res);

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

 ; CHECK: ^[[BBD]](%[[BA2:.+]]: i32):
 def: ; pred: bb3, bbs
   %v2 = phi i32 [%vx, %bb3], [%vz, %bbs]
   ; CHECK: llvm.call @g(%[[BA2]])
   call void @g(i32 %v2)
   ret void
 }
 
-; Insert/ExtractValue
-; CHECK-LABEL: llvm.func @insert_extract_value_struct
-define float @insert_extract_value_struct({{i32},{float, double}}* %p) {
-  ; CHECK: %[[C0:.+]] = llvm.mlir.constant(2.000000e+00 : f64)
-  ; CHECK: %[[VT:.+]] = llvm.load %{{.+}}
-  %t = load {{i32},{float, double}}, {{i32},{float, double}}* %p
-  ; CHECK: %[[EV:.+]] = llvm.extractvalue %[[VT]][1, 0] :
-  ; CHECK-SAME: !llvm.struct<(struct<(i32)>, struct<(f32, f64)>)>
-  %s = extractvalue {{i32},{float, double}} %t, 1, 0
-  ; CHECK: %[[IV:.+]] = llvm.insertvalue %[[C0]], %[[VT]][1, 1] :
-  ; CHECK-SAME: !llvm.struct<(struct<(i32)>, struct<(f32, f64)>)>
-  %r = insertvalue {{i32},{float, double}} %t, double 2.0, 1, 1
-  ; CHECK: llvm.store %[[IV]], %{{.+}}
-  store {{i32},{float, double}} %r, {{i32},{float, double}}* %p
-  ; CHECK: llvm.return %[[EV]]
-  ret float %s
-}
-
-; CHECK-LABEL: llvm.func @insert_extract_value_array
-define void @insert_extract_value_array([4 x [4 x i8]] %x1) {
-  ; CHECK: %[[C0:.+]] = llvm.mlir.constant(0 : i8)
-  ; CHECK: llvm.insertvalue %[[C0]], %{{.+}}[0, 0] : !llvm.array<4 x array<4 x i8>>
-  %res1 = insertvalue [4 x [4 x i8 ]] %x1, i8 0, 0, 0
-  ; CHECK: llvm.extractvalue %{{.+}}[1] : !llvm.array<4 x array<4 x i8>>
-  %res2 = extractvalue [4 x [4 x i8 ]] %x1, 1
-  ; CHECK: llvm.extractvalue %{{.+}}[0, 1] : !llvm.array<4 x array<4 x i8>>
-  %res3 = extractvalue [4 x [4 x i8 ]] %x1, 0, 1
-  ret void
-}
-
 ; Shufflevector
 ; CHECK-LABEL: llvm.func @shuffle_vec
 define <4 x half> @shuffle_vec(<4 x half>* %arg0, <4 x half>* %arg1) {
   ; CHECK: %[[V0:.+]] = llvm.load %{{.+}} : !llvm.ptr<vector<4xf16>>
   %val0 = load <4 x half>, <4 x half>* %arg0
   ; CHECK: %[[V1:.+]] = llvm.load %{{.+}} : !llvm.ptr<vector<4xf16>>
   %val1 = load <4 x half>, <4 x half>* %arg1
   ; CHECK: llvm.shufflevector %[[V0]], %[[V1]] [2, 3, -1, -1] : vector<4xf16>

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

define <4 x half> @insert_element(<4 x half>* %vec, half %val, i32 %idx) {
   ; CHECK:  llvm.return %[[V2]]
   %1 = load <4 x half>, <4 x half>* %vec
   %2 = insertelement <4 x half> %1, half %val, i32 %idx
   ret <4 x half> %2
 }
 
 ; // -----
 
+; CHECK-LABEL: @insert_extract_value_struct
+; CHECK-SAME:  %[[PTR:[a-zA-Z0-9]+]]
+define float @insert_extract_value_struct({{i32},{float, double}}* %ptr) {
+  ; CHECK:  %[[C0:.+]] = llvm.mlir.constant(2.000000e+00 : f64)
+  ; CHECK:  %[[VT:.+]] = llvm.load %[[PTR]]
+  %1 = load {{i32},{float, double}}, {{i32},{float, double}}* %ptr
+  ; CHECK:  %[[EV:.+]] = llvm.extractvalue %[[VT]][1, 0] :
+  ; CHECK-SAME: !llvm.struct<(struct<(i32)>, struct<(f32, f64)>)>
+  %2 = extractvalue {{i32},{float, double}} %1, 1, 0
+  ; CHECK:  %[[IV:.+]] = llvm.insertvalue %[[C0]], %[[VT]][1, 1] :
+  ; CHECK-SAME: !llvm.struct<(struct<(i32)>, struct<(f32, f64)>)>
+  %3 = insertvalue {{i32},{float, double}} %1, double 2.0, 1, 1
+  ; CHECK:  llvm.store %[[IV]], %[[PTR]]
+  store {{i32},{float, double}} %3, {{i32},{float, double}}* %ptr
+  ; CHECK:  llvm.return %[[EV]]
+  ret float %2
+}
+
+; // -----
+
+; CHECK-LABEL: @insert_extract_value_array
+; CHECK-SAME:  %[[ARG1:[a-zA-Z0-9]+]]
+define void @insert_extract_value_array([4 x [4 x i8]] %arg1) {
+  ; CHECK:  %[[C0:.+]] = llvm.mlir.constant(0 : i8)
+  ; CHECK:  llvm.insertvalue %[[C0]], %[[ARG1]][0, 0] : !llvm.array<4 x array<4 x i8>>
+  %1 = insertvalue [4 x [4 x i8 ]] %arg1, i8 0, 0, 0
+  ; CHECK:  llvm.extractvalue %[[ARG1]][1] : !llvm.array<4 x array<4 x i8>>
+  %2 = extractvalue [4 x [4 x i8 ]] %arg1, 1
+  ; CHECK:  llvm.extractvalue %[[ARG1]][0, 1] : !llvm.array<4 x array<4 x i8>>
+  %3 = extractvalue [4 x [4 x i8 ]] %arg1, 0, 1
+  ret void
+}
+
+; // -----
+
 ; CHECK-LABEL: @select
 ; CHECK-SAME:  %[[ARG1:[a-zA-Z0-9]+]]
 ; CHECK-SAME:  %[[ARG2:[a-zA-Z0-9]+]]
 ; CHECK-SAME:  %[[COND:[a-zA-Z0-9]+]]
 define void @select(i32 %arg0, i32 %arg1, i1 %cond) {
   ; CHECK:  llvm.select %[[COND]], %[[ARG1]], %[[ARG2]] : i1, i32
   %1 = select i1 %cond, i32 %arg0, i32 %arg1
   ret void