[mlir] Add artih.addui_carry conversion to LLVM

[kuhar]

Summary

This covers the scalar and 1-D vector case.

I haven't implemented conversion for the multidimensional vector case yet because the current LLVM conversion infrastructure (handleMultidimensionalVectors) does not seem to support ops with multiple results.

[Mogball]

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

205

Please spell out all autos where the type is not explicit in the statement on the right hand side (e.g. from a cast)

[kuhar]

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

205

I tried to match the style used by the surrounding code in this file. Should I change it despite the existing convention here? Or alternatively, update those autos in a separate patch?

[Mogball]

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

111

209

operandType cannot be null. Also, since this is a conversion pattern, I believe you don't need the type check.

219

Can the op infer this result type?

[Mogball]

The coding style has changed/is inconsistent throughout the code base unfortunately. If you would like to update the surrounding code to conform, that would be lovely but you don't have to do it in this patch

[kuhar]

In D132613#3747530, @Mogball wrote:

The coding style has changed/is inconsistent throughout the code base unfortunately. If you would like to update the surrounding code to conform, that would be lovely but you don't have to do it in this patch

Can you point me to some conversion code that best illustrates the preferred coding conventions?

[Mogball]

Quickly glancing through some of the conversion code, ShapeToStandard.cpp does a relatively decent job. But essentially, auto should be used if the result type is spelled out already on the right hand side or the type is "complicated", i.e. llvm::StringMap<int>::const_iterator should be auto

[kuhar]

Cleanups

[kuhar]

Thanks for the feedback, @Mogball!

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

219

Not from what I can tell

[Mogball]

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

219

It probably should be made to, but that's not a big deal.

[Mogball]

nit: "artih.addui_carry" misspelled in the title

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

 struct IndexCastOpLowering : public ConvertOpToLLVMPattern<arith::IndexCastOp> {
   using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(arith::IndexCastOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
+struct AddUICarryOpLowering
+    : public ConvertOpToLLVMPattern<arith::AddUICarryOp> {
+  using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
+
+  LogicalResult
+  matchAndRewrite(arith::AddUICarryOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override;
+};
+
 struct CmpIOpLowering : public ConvertOpToLLVMPattern<arith::CmpIOp> {
   using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
return LLVM::detail::handleMultidimensionalVectors(
         }
         return rewriter.create<LLVM::SExtOp>(op.getLoc(), llvm1DVectorTy,
                                              adaptor.getIn());
       },
       rewriter);
 }
 
 //===----------------------------------------------------------------------===//
+// AddUICarryOpLowering
+//===----------------------------------------------------------------------===//
+
+LogicalResult AddUICarryOpLowering::matchAndRewrite(
+    arith::AddUICarryOp op, OpAdaptor adaptor,
+    ConversionPatternRewriter &rewriter) const {
+  Type operandType = adaptor.getLhs().getType();
+  Type sumResultType = op.getSum().getType();
+  Type carryResultType = op.getCarry().getType();
+
+  if (!LLVM::isCompatibleType(operandType))
+    return failure();
+
+  MLIRContext *ctx = rewriter.getContext();
+  Location loc = op.getLoc();
+
+  // Handle the scalar and 1D vector cases.
+  if (!operandType.isa<LLVM::LLVMArrayType>()) {
+    Type newCarryType = typeConverter->convertType(carryResultType);
+    Type structType =
+        LLVM::LLVMStructType::getLiteral(ctx, {sumResultType, newCarryType});
+    Value addOverflow = rewriter.create<LLVM::UAddWithOverflowOp>(
+        loc, structType, adaptor.getLhs(), adaptor.getRhs());
+    Value sumExtracted =
+        rewriter.create<LLVM::ExtractValueOp>(loc, addOverflow, 0);
+    Value carryExtracted =
+        rewriter.create<LLVM::ExtractValueOp>(loc, addOverflow, 1);
+    rewriter.replaceOp(op, {sumExtracted, carryExtracted});
+    return success();
+  }
+
+  if (!sumResultType.isa<VectorType>())
+    return rewriter.notifyMatchFailure(loc, "expected vector result types");
+
+  return rewriter.notifyMatchFailure(loc,
+                                     "ND vector types are not supported yet");
+}
+
+//===----------------------------------------------------------------------===//
 // CmpIOpLowering
 //===----------------------------------------------------------------------===//
 
 // Convert arith.cmp predicate into the LLVM dialect CmpPredicate. The two enums
 // share numerical values so just cast.
 template <typename LLVMPredType, typename PredType>
 static LLVMPredType convertCmpPredicate(PredType pred) {
   return static_cast<LLVMPredType>(pred);

 
 void mlir::arith::populateArithmeticToLLVMConversionPatterns(
     LLVMTypeConverter &converter, RewritePatternSet &patterns) {
   // clang-format off
   patterns.add<
     AddFOpLowering,
     AddIOpLowering,
     AndIOpLowering,
+    AddUICarryOpLowering,
     BitcastOpLowering,
     ConstantOpLowering,
     CmpFOpLowering,
     CmpIOpLowering,
     DivFOpLowering,
     DivSIOpLowering,
     DivUIOpLowering,
     ExtFOpLowering,

mlir/test/Conversion/ArithmeticToLLVM/arith-to-llvm.mlir

 func.func @bitcast_1d(%arg0: vector<2xf32>) {
   // CHECK: llvm.bitcast %{{.*}} : vector<2xf32> to vector<2xi32>
   arith.bitcast %arg0 : vector<2xf32> to vector<2xi32>
   return
 }
 
 // -----
 
+// CHECK-LABEL: @addui_carry_scalar
+// CHECK-SAME:    ([[ARG0:%.+]]: i32, [[ARG1:%.+]]: i32) -> (i32, i1)
+func.func @addui_carry_scalar(%arg0: i32, %arg1: i32) -> (i32, i1) {
+  // CHECK-NEXT: [[RES:%.+]] = "llvm.intr.uadd.with.overflow"([[ARG0]], [[ARG1]]) : (i32, i32) -> !llvm.struct<(i32, i1)>
+  // CHECK-NEXT: [[SUM:%.+]] = llvm.extractvalue [[RES]][0] : !llvm.struct<(i32, i1)>
+  // CHECK-NEXT: [[CARRY:%.+]] = llvm.extractvalue [[RES]][1] : !llvm.struct<(i32, i1)>
+  %sum, %carry = arith.addui_carry %arg0, %arg1 : i32, i1
+  // CHECK-NEXT: return [[SUM]], [[CARRY]] : i32, i1
+  return %sum, %carry : i32, i1
+}
+
+// CHECK-LABEL: @addui_carry_vector1d
+// CHECK-SAME:    ([[ARG0:%.+]]: vector<3xi16>, [[ARG1:%.+]]: vector<3xi16>) -> (vector<3xi16>, vector<3xi1>)
+func.func @addui_carry_vector1d(%arg0: vector<3xi16>, %arg1: vector<3xi16>) -> (vector<3xi16>, vector<3xi1>) {
+  // CHECK-NEXT: [[RES:%.+]] = "llvm.intr.uadd.with.overflow"([[ARG0]], [[ARG1]]) : (vector<3xi16>, vector<3xi16>) -> !llvm.struct<(vector<3xi16>, vector<3xi1>)>
+  // CHECK-NEXT: [[SUM:%.+]] = llvm.extractvalue [[RES]][0] : !llvm.struct<(vector<3xi16>, vector<3xi1>)>
+  // CHECK-NEXT: [[CARRY:%.+]] = llvm.extractvalue [[RES]][1] : !llvm.struct<(vector<3xi16>, vector<3xi1>)>
+  %sum, %carry = arith.addui_carry %arg0, %arg1 : vector<3xi16>, vector<3xi1>
+  // CHECK-NEXT: return [[SUM]], [[CARRY]] : vector<3xi16>, vector<3xi1>
+  return %sum, %carry : vector<3xi16>, vector<3xi1>
+}
+
+// -----
+
 // CHECK-LABEL: func @cmpf_2dvector(
 func.func @cmpf_2dvector(%arg0 : vector<4x3xf32>, %arg1 : vector<4x3xf32>) {
   // CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast
   // CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast
   // CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.array<4 x vector<3xf32>>
   // CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.array<4 x vector<3xf32>>
   // CHECK: %[[CMP:.*]] = llvm.fcmp "olt" %[[EXTRACT1]], %[[EXTRACT2]] : vector<3xf32>
   // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[CMP]], %2[0] : !llvm.array<4 x vector<3xi1>>