[mlir][llvm] Use tablegen to import shufflevector from LLVM IR.

[gysit]

Summary

The revision imports the shuffle vector operation using
tablegen generated builders. Additionally, it moves its test to
the instructions.ll test file.

Depends on D135874

[ftynse]

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

925

Shouldn't this be $mask?

[gysit]

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

925

The shufflevector instruction has only two operands and the mask seems to be stored internally in the shufflevector instruction class. Apparently, the way to access this kind of attributes-like data is to cast the operation to its type and then use the getters:

auto *svInst = cast<llvm::ShuffleVectorInst>(inst);
svInst->getShuffleMask()

Maybe I am missing something here? I use the same mechanism to access the position of the insertvalue / extractvalue operations.

[ftynse]

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

925

Sorry, I haven't noticed it was defined two lines above.

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

def LLVM_ShuffleVectorOp : LLVM_Op<"shufflevector",
 
   let assemblyFormat = [{
     $v1 `,` $v2 $mask attr-dict `:` type($v1)
     custom<ShuffleType>(ref(type($v1)), type($res), ref($mask))
   }];
 
   let hasVerifier = 1;
 
+  string llvmInstName = "ShuffleVector";
   string llvmBuilder = [{
     $res = builder.CreateShuffleVector($v1, $v2, $mask);
   }];
+  string mlirBuilder = [{
+    auto *svInst = cast<llvm::ShuffleVectorInst>(inst);
+    SmallVector<int32_t> mask(svInst->getShuffleMask());
+    $res = $_builder.create<LLVM::ShuffleVectorOp>(
+      $_location, $v1, $v2, mask);
+  }];
 }
 
 // Misc operations.
 def LLVM_SelectOp
     : LLVM_Op<"select",
           [Pure, AllTypesMatch<["trueValue", "falseValue", "res"]>]>,
       LLVM_Builder<
           "$res = builder.CreateSelect($condition, $trueValue, $falseValue);"> {

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

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::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);
-    return success();
-  }
 
   return emitError(loc) << "unknown instruction: " << diag(*inst);
 }
 
 FlatSymbolRefAttr Importer::getPersonalityAsAttr(llvm::Function *f) {
   if (!f->hasPersonalityFn())
     return nullptr;
 

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
 }
 
-; 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>
-  %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
-}
-
 ; Varadic function definition
 %struct.va_list = type { i8* }
 
 declare void @llvm.va_start(i8*)
 declare void @llvm.va_copy(i8*, i8*)
 declare void @llvm.va_end(i8*)
 
 ; CHECK-LABEL: llvm.func @variadic_function

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

 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
 }
 
 ; // -----
 
+; CHECK-LABEL: func @shuffle_vec
+; CHECK-SAME:  %[[ARG1:[a-zA-Z0-9]+]]
+; CHECK-SAME:  %[[ARG2:[a-zA-Z0-9]+]]
+define <4 x half> @shuffle_vec(<4 x half> %arg1, <4 x half> %arg2) {
+  ; CHECK:  llvm.shufflevector %[[ARG1]], %[[ARG2]] [2, 3, -1, -1] : vector<4xf16>
+  %1 = shufflevector <4 x half> %arg1, <4 x half> %arg2, <4 x i32> <i32 2, i32 3, i32 undef, i32 undef>
+  ret <4 x half> %1
+}
+
+; // -----
+
 ; CHECK-LABEL: @alloca
 ; CHECK-SAME:  %[[SIZE:[a-zA-Z0-9]+]]
 define double* @alloca(i64 %size) {
   ; CHECK:  %[[C1:[0-9]+]] = llvm.mlir.constant(1 : i32) : i32
   ; CHECK:  llvm.alloca %[[C1]] x f64 {alignment = 8 : i64} : (i32) -> !llvm.ptr<f64>
   ; CHECK:  llvm.alloca %[[SIZE]] x i32 {alignment = 8 : i64} : (i64) -> !llvm.ptr<i32>
   ; CHECK:  llvm.alloca %[[SIZE]] x i32 {alignment = 4 : i64} : (i64) -> !llvm.ptr<i32, 3>
   %1 = alloca double