[mlir][LLVMIR] Fix incorrect llvm.fcmp result type

[myhsu]

Summary

Similar to D127536, if any of the operands for FCmpOp is a vector, returns a vector<Nxi1> rather than an i1 type result.

[Mogball]

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

890

does llvm.fmp do implicit broadcasting?

[myhsu]

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

890

I just checked LLVM IR and LLVM Dialect's semantic and surprisingly found that neither llvm.icmp nor llvm.fcmp (and their LLVM IR counterparts) do implicit broadcasting: LLVM IR simply says that operands under comparison should have identical types. Let me cleanup the code here.

What I'm more curious is why did the original ICmpOp::build do implicit broadcasting at the first place?

[myhsu]

Do not broadcast when the operand types are different

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

890

What I'm more curious is why did the original ICmpOp::build do implicit broadcasting at the first place?

nvm, it was me that first did implicit broadcasting for ICmpOp::build in D127536 for reason I cannot remember now.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

instMap[inst] = b.create<ICmpOp>(
         rhs);
     return success();
   }
   case llvm::Instruction::FCmp: {
     Value lhs = processValue(inst->getOperand(0));
     Value rhs = processValue(inst->getOperand(1));
     if (!lhs || !rhs)
       return failure();
+
+    Type boolType = b.getI1Type();
+    Type resType = boolType;
+    if (LLVM::isCompatibleVectorType(lhs.getType()) ||
+        LLVM::isCompatibleVectorType(rhs.getType())) {
+      int64_t numLHSElements = 1, numRHSElements = 1;
+      if (LLVM::isCompatibleVectorType(lhs.getType()))
+        numLHSElements =
+            LLVM::getVectorNumElements(lhs.getType()).getFixedValue();
+      if (LLVM::isCompatibleVectorType(rhs.getType()))
+        numRHSElements =
+            LLVM::getVectorNumElements(rhs.getType()).getFixedValue();
+      resType =
+          VectorType::get({std::max(numLHSElements, numRHSElements)}, boolType);
+    }
+
     instMap[inst] = b.create<FCmpOp>(
-        loc, b.getI1Type(),
+        loc, resType,
         getFCmpPredicate(cast<llvm::FCmpInst>(inst)->getPredicate()), lhs, rhs);
     return success();
   }
   case llvm::Instruction::Br: {
     auto *brInst = cast<llvm::BranchInst>(inst);
     OperationState state(loc,
                          brInst->isConditional() ? "llvm.cond_br" : "llvm.br");
     if (brInst->isConditional()) {

mlir/test/Dialect/LLVMIR/roundtrip.mlir

llvm.func @useInlineAsm(%arg0: i32) {
 
   // CHECK-NEXT:  llvm.inline_asm "foo", "=r,=r,r" {{.*}} : (i32) -> !llvm.struct<(i8, i8)>
   %5 = llvm.inline_asm "foo", "=r,=r,r" %arg0 : (i32) -> !llvm.struct<(i8, i8)>
 
   llvm.return
 }
 
 // CHECK-LABEL: @fastmathFlags
-func.func @fastmathFlags(%arg0: f32, %arg1: f32, %arg2: i32) {
+func.func @fastmathFlags(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: vector<2 x f32>, %arg4: vector<2 x f32>) {
 // CHECK: {{.*}} = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
 // CHECK: {{.*}} = llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
 // CHECK: {{.*}} = llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
 // CHECK: {{.*}} = llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
 // CHECK: {{.*}} = llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
   %0 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
   %1 = llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
   %2 = llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
   %3 = llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
   %4 = llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
 
-// CHECK: {{.*}} = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: %[[SCALAR_PRED0:.+]] = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
   %5 = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: %{{.*}} = llvm.add %[[SCALAR_PRED0]], %[[SCALAR_PRED0]] : i1
+  %typecheck_5 = llvm.add %5, %5 : i1
+// CHECK: %[[VEC_PRED0:.+]] = llvm.fcmp "oeq" %arg3, %arg4 {fastmathFlags = #llvm.fastmath<fast>} : vector<2xf32>
+  %vcmp = llvm.fcmp "oeq" %arg3, %arg4 {fastmathFlags = #llvm.fastmath<fast>} : vector<2xf32>
+// CHECK: %{{.*}} = llvm.add %[[VEC_PRED0]], %[[VEC_PRED0]] : vector<2xi1>
+  %typecheck_vcmp = llvm.add %vcmp, %vcmp : vector<2xi1>
 
 // CHECK: {{.*}} = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32
   %6 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32
 
 // CHECK: {{.*}} = llvm.call @foo(%arg2) {fastmathFlags = #llvm.fastmath<fast>} : (i32) -> !llvm.struct<(i32, f64, i32)>
   %7 = llvm.call @foo(%arg2) {fastmathFlags = #llvm.fastmath<fast>} : (i32) -> !llvm.struct<(i32, f64, i32)>
 
 // CHECK: {{.*}} = llvm.fadd %arg0, %arg1 : f32