[mlir][LLVMIR] Add support for translating shufflevector

[myhsu]

Summary

Add support for translating llvm::ShuffleVectorInst

[Mogball]

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

1078

mask is never null (I'm not sure why it's checked elsewhere in this file).

[myhsu]

Removed (null) checks on ArrayAttr

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

static const DenseMap<unsigned, StringRef> opcMap = {
       // 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
-      // FIXME: shufflevector
+      // ShuffleVector is handled specially.
       // InsertValue is handled specially.
       // ExtractValue is handled specially.
       // FIXME: landingpad
   };
 #undef INST
 
   return opcMap.lookup(opcode);
 }
case llvm::Instruction::ExtractValue: {
     SmallVector<int32_t> idxValues;
     for (unsigned idx : evInst->getIndices())
       idxValues.push_back(static_cast<int32_t>(idx));
     ArrayAttr indices = b.getI32ArrayAttr(idxValues);
 
     instMap[inst] = b.create<ExtractValueOp>(loc, type, aggOperand, indices);
     return success();
   }
+  case llvm::Instruction::ShuffleVector: {
+    auto *svInst = cast<llvm::ShuffleVectorInst>(inst);
+    Value vec1 = processValue(svInst->getOperand(0));
+    if (!vec1)
+      return failure();
+    Value vec2 = processValue(svInst->getOperand(1));
+    if (!vec2)
+      return failure();
+
+    ArrayAttr mask = b.getI32ArrayAttr(svInst->getShuffleMask());
+
+    instMap[inst] = b.create<ShuffleVectorOp>(loc, vec1, vec2, mask);
+    return success();
+  }
   }
 }
 
 FlatSymbolRefAttr Importer::getPersonalityAsAttr(llvm::Function *f) {
   if (!f->hasPersonalityFn())
     return nullptr;
 
   llvm::Constant *pf = f->getPersonalityFn();

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

define void @insert_extract_value_array([4 x [4 x i8]] %x1) {
   %res1 = insertvalue [4 x [4 x i8 ]] %x1, i8 0, 0, 0
   ; CHECK: llvm.extractvalue %{{.+}}[1 : i32] : !llvm.array<4 x array<4 x i8>>
   %res2 = extractvalue [4 x [4 x i8 ]] %x1, 1
   ; CHECK: llvm.extractvalue %{{.+}}[0 : i32, 1 : i32] : !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 : 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
+}