Improve type conversion error propagation/failure during LLVM lowering

[bondhugula]

Summary

Improve type conversion error propagation/failure during LLVM lowering.

BEFORE

llvm-mlir/mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp:304: SmallVector<mlir::Type, 5> mlir::LLVMTypeConverter::getMemRefDescriptorFields(mlir::MemRefType, bool): Assertion `isStrided(type) && "Non-strided layout maps must have been normalized away"' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
Stack dump:
...

AFTER

<unknown>:0: error: integer overflow during size computation
<unknown>:0: error: Conversion to strided form failed either due to non-strided layout maps (which should have been normalized away) or other reasons
<unknown>:0: error: failed to legalize operation 'gpu.func' that was explicitly marked illegal
<unknown>:0: note: see current operation:
"gpu.func"() ( {
...

[bondhugula]

Base on upstream commit.

[bondhugula]

Update commit summary.

[ftynse]

mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp

306

Nit: user-visible error messages should not be capitalized.

307

Nit: what other reasons? This error is only emitted when the isStrided condition fails.

[bondhugula]

Adjust error message.

mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp

307

There are two more reasons (including the integer overflow case). Please see getStridesAndOffset failure return paths.

[bondhugula]

Rebase to remove parent dep.

mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp

for (const auto &en : llvm::enumerate(gpuFuncOp.getWorkgroupAttributions())) {
     auto globalOp = rewriter.create<LLVM::GlobalOp>(
         gpuFuncOp.getLoc(), arrayType, /*isConstant=*/false,
         LLVM::Linkage::Internal, name, /*value=*/Attribute(),
         /*alignment=*/0, gpu::GPUDialect::getWorkgroupAddressSpace());
     workgroupBuffers.push_back(globalOp);
   }
 
   // Rewrite the original GPU function to an LLVM function.
-  auto funcType = typeConverter->convertType(gpuFuncOp.getFunctionType())
-                      .template cast<LLVM::LLVMPointerType>()
-                      .getElementType();
+  auto convertedType = typeConverter->convertType(gpuFuncOp.getFunctionType());
+  if (!convertedType)
+    return failure();
+  auto funcType =
+      convertedType.template cast<LLVM::LLVMPointerType>().getElementType();
 
   // Remap proper input types.
   TypeConverter::SignatureConversion signatureConversion(
       gpuFuncOp.front().getNumArguments());
   getTypeConverter()->convertFunctionSignature(
       gpuFuncOp.getFunctionType(), /*isVariadic=*/false, signatureConversion);
 
   // Create the new function operation. Only copy those attributes that are

mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp

 }
 
 // Except for signatures, MLIR function types are converted into LLVM
 // pointer-to-function types.
 Type LLVMTypeConverter::convertFunctionType(FunctionType type) {
   SignatureConversion conversion(type.getNumInputs());
   Type converted =
       convertFunctionSignature(type, /*isVariadic=*/false, conversion);
+  if (!converted)
+    return {};
   return LLVM::LLVMPointerType::get(converted);
 }
 
 // Function types are converted to LLVM Function types by recursively converting
 // argument and result types.  If MLIR Function has zero results, the LLVM
 // Function has one VoidType result.  If MLIR Function has more than one result,
 // they are into an LLVM StructType in their order of appearance.
 Type LLVMTypeConverter::convertFunctionSignature(

 ///    Elem *alignedPtr;
 ///    Index offset;
 ///    Index sizes[Rank]; // omitted when rank == 0
 ///    Index strides[Rank]; // omitted when rank == 0
 ///  };
 SmallVector<Type, 5>
 LLVMTypeConverter::getMemRefDescriptorFields(MemRefType type,
                                              bool unpackAggregates) {
-  assert(isStrided(type) &&
-         "Non-strided layout maps must have been normalized away");
+  if (!isStrided(type)) {
+    emitError(
+        UnknownLoc::get(type.getContext()),
+        "conversion to strided form failed either due to non-strided layout "
+        "maps (which should have been normalized away) or other reasons");
+    return {};
+  }
 
   Type elementType = convertType(type.getElementType());
   if (!elementType)
     return {};
   auto ptrTy =
       LLVM::LLVMPointerType::get(elementType, type.getMemorySpaceAsInt());
   auto indexTy = getIndexType();