[mlir][LLVMIR] Add support for translating insertelement/extractelement.

[jacquesguan]

Summary

Add support for translating llvm::InsertElement and llvm::ExtractElement.

[myhsu]

LGTM. Thank you!

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

static const DenseMap<unsigned, StringRef> opcMap = {
       // FIXME: cleanuppad
       // FIXME: catchpad
       // ICmp is handled specially.
       // FCmp is handled specially.
       // PHI is handled specially.
       INST(Freeze, Freeze), INST(Call, Call),
       // FIXME: select
       // FIXME: vaarg
-      // FIXME: extractelement
-      // FIXME: insertelement
+      INST(ExtractElement, ExtractElement), INST(InsertElement, InsertElement),
       // ShuffleVector is handled specially.
       // InsertValue is handled specially.
       // ExtractValue is handled specially.
       // FIXME: landingpad
   };
 #undef INST
 
   return opcMap.lookup(opcode);
LogicalResult Importer::processInstruction(llvm::Instruction *inst) {
   case llvm::Instruction::UIToFP:
   case llvm::Instruction::SIToFP:
   case llvm::Instruction::FPTrunc:
   case llvm::Instruction::FPExt:
   case llvm::Instruction::PtrToInt:
   case llvm::Instruction::IntToPtr:
   case llvm::Instruction::AddrSpaceCast:
   case llvm::Instruction::Freeze:
-  case llvm::Instruction::BitCast: {
+  case llvm::Instruction::BitCast:
+  case llvm::Instruction::ExtractElement:
+  case llvm::Instruction::InsertElement: {
     OperationState state(loc, lookupOperationNameFromOpcode(inst->getOpcode()));
     SmallVector<Value, 4> ops;
     ops.reserve(inst->getNumOperands());
     for (auto *op : inst->operand_values()) {
       Value value = processValue(op);
       if (!value)
         return failure();
       ops.push_back(value);

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

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 : i32, 3 : i32, -1 : i32, -1 : i32] : vector<4xf16>, vector<4xf16>
   %shuffle = shufflevector <4 x half> %val0, <4 x half> %val1, <4 x i32> <i32 2, i32 3, i32 undef, i32 undef>
   ret <4 x half> %shuffle
 }
+
+; ExtractElement
+; CHECK-LABEL: llvm.func @extract_element
+define half @extract_element(<4 x half>* %vec, i32 %idx) {
+  ; CHECK: %[[V0:.+]] = llvm.load %{{.+}} : !llvm.ptr<vector<4xf16>>
+  %val0 = load <4 x half>, <4 x half>* %vec
+  ; CHECK: %[[V1:.+]] = llvm.extractelement %[[V0]][%{{.+}} : i32] : vector<4xf16>
+  %r = extractelement <4 x half> %val0, i32 %idx
+  ; CHECK: llvm.return %[[V1]]
+  ret half %r
+}
+
+; InsertElement
+; CHECK-LABEL: llvm.func @insert_element
+define <4 x half> @insert_element(<4 x half>* %vec, half %v, i32 %idx) {
+  ; CHECK: %[[V0:.+]] = llvm.load %{{.+}} : !llvm.ptr<vector<4xf16>>
+  %val0 = load <4 x half>, <4 x half>* %vec
+  ; CHECK: %[[V1:.+]] = llvm.insertelement %{{.+}}, %[[V0]][%{{.+}} : i32] : vector<4xf16>
+  %r = insertelement <4 x half> %val0, half %v, i32 %idx
+  ; CHECK: llvm.return %[[V1]]
+  ret <4 x half> %r
+}