[mlir] VectorToLLVM: propagate up from replaceTransferOp

In the Vector to LLVM conversion, the `replaceTransferOp` function calls into a type converter that may fail and suppresses the status. Change the function to return the failure status instead, Since it is called from a pattern, the failure can be readily propagated to the rest of infrastructure.
llvm · May 7, 2020 · a99f62c · a99f62c
1 parent a23f190
commit a99f62c
Showing 1 changed file with 29 additions and 27 deletions.
diff --git a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp
@@ -747,10 +747,10 @@ class VectorTypeCastOpConversion : public ConvertToLLVMPattern {
 };
 
 template <typename ConcreteOp>
-void replaceTransferOp(ConversionPatternRewriter &rewriter,
-                       LLVMTypeConverter &typeConverter, Location loc,
-                       Operation *op, ArrayRef<Value> operands, Value dataPtr,
-                       Value mask);
+LogicalResult replaceTransferOp(ConversionPatternRewriter &rewriter,
+                                LLVMTypeConverter &typeConverter, Location loc,
+                                Operation *op, ArrayRef<Value> operands,
+                                Value dataPtr, Value mask);
 
 LogicalResult getLLVMTypeAndAlignment(LLVMTypeConverter &typeConverter,
                                       Type type, LLVM::LLVMType &llvmType,
@@ -766,11 +766,10 @@ LogicalResult getLLVMTypeAndAlignment(LLVMTypeConverter &typeConverter,
 }
 
 template <>
-void replaceTransferOp<TransferReadOp>(ConversionPatternRewriter &rewriter,
-                                       LLVMTypeConverter &typeConverter,
-                                       Location loc, Operation *op,
-                                       ArrayRef<Value> operands, Value dataPtr,
-                                       Value mask) {
+LogicalResult replaceTransferOp<TransferReadOp>(
+    ConversionPatternRewriter &rewriter, LLVMTypeConverter &typeConverter,
+    Location loc, Operation *op, ArrayRef<Value> operands, Value dataPtr,
+    Value mask) {
   auto xferOp = cast<TransferReadOp>(op);
   auto toLLVMTy = [&](Type t) { return typeConverter.convertType(t); };
   VectorType fillType = xferOp.getVectorType();
@@ -779,28 +778,33 @@ void replaceTransferOp<TransferReadOp>(ConversionPatternRewriter &rewriter,
 
   LLVM::LLVMType vecTy;
   unsigned align;
-  if (succeeded(getLLVMTypeAndAlignment(typeConverter, xferOp.getVectorType(),
-                                        vecTy, align)))
-    rewriter.replaceOpWithNewOp<LLVM::MaskedLoadOp>(
-        op, vecTy, dataPtr, mask, ValueRange{fill},
-        rewriter.getI32IntegerAttr(align));
+  if (failed(getLLVMTypeAndAlignment(typeConverter, xferOp.getVectorType(),
+                                     vecTy, align)))
+    return failure();
+
+  rewriter.replaceOpWithNewOp<LLVM::MaskedLoadOp>(
+      op, vecTy, dataPtr, mask, ValueRange{fill},
+      rewriter.getI32IntegerAttr(align));
+  return success();
 }
 
 template <>
-void replaceTransferOp<TransferWriteOp>(ConversionPatternRewriter &rewriter,
-                                        LLVMTypeConverter &typeConverter,
-                                        Location loc, Operation *op,
-                                        ArrayRef<Value> operands, Value dataPtr,
-                                        Value mask) {
+LogicalResult replaceTransferOp<TransferWriteOp>(
+    ConversionPatternRewriter &rewriter, LLVMTypeConverter &typeConverter,
+    Location loc, Operation *op, ArrayRef<Value> operands, Value dataPtr,
+    Value mask) {
   auto adaptor = TransferWriteOpOperandAdaptor(operands);
 
   auto xferOp = cast<TransferWriteOp>(op);
   LLVM::LLVMType vecTy;
   unsigned align;
-  if (succeeded(getLLVMTypeAndAlignment(typeConverter, xferOp.getVectorType(),
-                                        vecTy, align)))
-    rewriter.replaceOpWithNewOp<LLVM::MaskedStoreOp>(
-        op, adaptor.vector(), dataPtr, mask, rewriter.getI32IntegerAttr(align));
+  if (failed(getLLVMTypeAndAlignment(typeConverter, xferOp.getVectorType(),
+                                     vecTy, align)))
+    return failure();
+
+  rewriter.replaceOpWithNewOp<LLVM::MaskedStoreOp>(
+      op, adaptor.vector(), dataPtr, mask, rewriter.getI32IntegerAttr(align));
+  return success();
 }
 
 static TransferReadOpOperandAdaptor
@@ -906,10 +910,8 @@ class VectorTransferConversion : public ConvertToLLVMPattern {
                                                 mask);
 
     // 5. Rewrite as a masked read / write.
-    replaceTransferOp<ConcreteOp>(rewriter, typeConverter, loc, op, operands,
-                                  vectorDataPtr, mask);
-
-    return success();
+    return replaceTransferOp<ConcreteOp>(rewriter, typeConverter, loc, op,
+                                         operands, vectorDataPtr, mask);
   }
 };