[mlir] support recursive type conversion of named LLVM structs

[ftynse]

Summary

A previous commit added support for converting elemental types contained in
LLVM dialect types in case they were not compatible with the LLVM dialect. It
was missing support for named structs as they could be recursive, which was not
supported by the conversion infra. Now that it is, add support for converting
such named structs.

Depends On D113579

[ftynse]

Rebase.

[kiranchandramohan]

mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp

67

Was the counter increment missed here?

mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp

LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
 
   // LLVM container types may (recursively) contain other types that must be
   // converted even when the outer type is compatible.
   addConversion([&](LLVM::LLVMPointerType type) -> llvm::Optional<Type> {
     if (auto pointee = convertType(type.getElementType()))
       return LLVM::LLVMPointerType::get(pointee, type.getAddressSpace());
     return llvm::None;
   });
-  addConversion([&](LLVM::LLVMStructType type) -> llvm::Optional<Type> {
-    // TODO: handle conversion of identified structs, which may be recursive.
-    if (type.isIdentified())
-      return type;
+  addConversion([&](LLVM::LLVMStructType type, SmallVectorImpl<Type> &results,
+                    ArrayRef<Type> callStack) -> llvm::Optional<LogicalResult> {
+    if (type.isIdentified()) {
+      auto convertedType = LLVM::LLVMStructType::getIdentified(
+          type.getContext(), ("_Converted_" + type.getName()).str());
+      unsigned counter = 1;
+      while (convertedType.isInitialized()) {
+        assert(counter != UINT_MAX &&
+               "about to overflow struct renaming counter in conversion");
+        convertedType = LLVM::LLVMStructType::getIdentified(
+            type.getContext(),
+            ("_Converted_" + std::to_string(counter) + type.getName()).str());
+      }
+      if (llvm::count(callStack, type) > 1) {
+        results.push_back(convertedType);
+        return success();
+      }
+
+      SmallVector<Type> convertedElemTypes;
+      convertedElemTypes.reserve(type.getBody().size());
+      if (failed(convertTypes(type.getBody(), convertedElemTypes)))
+        return llvm::None;
+
+      if (failed(convertedType.setBody(convertedElemTypes, type.isPacked())))
+        return failure();
+      results.push_back(convertedType);
+      return success();
+    }
 
     SmallVector<Type> convertedSubtypes;
     convertedSubtypes.reserve(type.getBody().size());
     if (failed(convertTypes(type.getBody(), convertedSubtypes)))
       return llvm::None;
 
-    return LLVM::LLVMStructType::getLiteral(type.getContext(),
-                                            convertedSubtypes, type.isPacked());
+    results.push_back(LLVM::LLVMStructType::getLiteral(
+        type.getContext(), convertedSubtypes, type.isPacked()));
+    return success();
   });
   addConversion([&](LLVM::LLVMArrayType type) -> llvm::Optional<Type> {
     if (auto element = convertType(type.getElementType()))
       return LLVM::LLVMArrayType::get(element, type.getNumElements());
     return llvm::None;
   });
   addConversion([&](LLVM::LLVMFunctionType type) -> llvm::Optional<Type> {
     Type convertedResType = convertType(type.getReturnType());

mlir/test/Conversion/StandardToLLVM/convert-types.mlir

 // RUN: mlir-opt -test-convert-call-op %s | FileCheck %s
 
 // CHECK-LABEL: @ptr
 // CHECK: !llvm.ptr<i42>
 func private @ptr() -> !llvm.ptr<!test.smpla>
 
 // CHECK-LABEL: @ptr_ptr()
 // CHECK: !llvm.ptr<ptr<i42>> 
 func private @ptr_ptr() -> !llvm.ptr<!llvm.ptr<!test.smpla>>
 
 // CHECK-LABEL: @struct_ptr()
 // CHECK: !llvm.struct<(ptr<i42>)> 
 func private @struct_ptr() -> !llvm.struct<(ptr<!test.smpla>)>
 
 // CHECK-LABEL: @named_struct_ptr()
-// CHECK: !llvm.struct<"named", (ptr<!test.smpla>)> 
+// CHECK: !llvm.struct<"_Converted_named", (ptr<i42>)>
 func private @named_struct_ptr() -> !llvm.struct<"named", (ptr<!test.smpla>)>
 
 // CHECK-LABEL: @array_ptr()
 // CHECK: !llvm.array<10 x ptr<i42>> 
 func private @array_ptr() -> !llvm.array<10 x ptr<!test.smpla>>
 
 // CHECK-LABEL: @func()
 // CHECK: !llvm.ptr<func<i42 (i42)>>
 func private @func() -> !llvm.ptr<!llvm.func<!test.smpla (!test.smpla)>>
 
 // TODO: support conversion of recursive types in the conversion infra.
 // CHECK-LABEL: @named_recursive()
-// CHECK: !llvm.struct<"recursive", (ptr<!test.smpla>, ptr<struct<"recursive">>)> 
+// CHECK: !llvm.struct<"_Converted_recursive", (ptr<i42>, ptr<struct<"_Converted_recursive">>)>
 func private @named_recursive() -> !llvm.struct<"recursive", (ptr<!test.smpla>, ptr<struct<"recursive">>)>