[CIR][Lowering] Handle pointer of pointer of struct or array

Remove a shortcut preventing some level of memref recursion.

Author: keryell

clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp

@@ -1467,7 +1467,7 @@ mlir::Type lowerArrayType(cir::ArrayType type, bool hasValueSemantics,
     shape.push_back(arrayType.getSize());
     curType = arrayType.getEltType();
   }
-  auto elementType = converter.convertType(curType);
+  auto elementType = convertTypeForMemory(converter, curType);
   // FIXME: The element type might not be converted
   if (!elementType)
     return nullptr;
@@ -1482,13 +1482,17 @@ mlir::Type lowerArrayType(cir::ArrayType type, bool hasValueSemantics,
 mlir::TypeConverter prepareTypeConverter(mlir::DataLayout &dataLayout) {
   mlir::TypeConverter converter;
   converter.addConversion([&](cir::PointerType type) -> mlir::Type {
-    auto ty = convertTypeForMemory(converter, type.getPointee());
+    auto pointeeType = type.getPointee();
+    if (mlir::isa<cir::ArrayType>(pointeeType))
+      // A pointer to an array gives the array a reference semantics, lower to a
+      // memref.
+      return lowerArrayType(mlir::cast<cir::ArrayType>(pointeeType),
+                            /* hasValueSemantics */ false, converter);
+    auto ty = convertTypeForMemory(converter, pointeeType);
     // FIXME: The pointee type might not be converted (e.g. struct)
     if (!ty)
       return nullptr;
-    if (isa<cir::ArrayType>(type.getPointee()))
-      // An array is already lowered as a memref with reference semantics
-      return ty;
+    // Each level of pointer becomes a level of memref
     return mlir::MemRefType::get({}, ty);
   });
   converter.addConversion(
@@ -1527,23 +1531,15 @@ mlir::TypeConverter prepareTypeConverter(mlir::DataLayout &dataLayout) {
     return mlir::BFloat16Type::get(type.getContext());
   });
   converter.addConversion([&](cir::ArrayType type) -> mlir::Type {
-    // Arrays in C/C++ have a reference semantics when not in a
-    // class/struct/union, so use a memref.
-    return lowerArrayType(type, /* hasValueSemantics */ false, converter);
+    // Assume we are in a class/struct/union context with value semantics, so
+    // lower as a tensor.
+    return lowerArrayType(type, /* hasValueSemantics */ true, converter);
   });
   converter.addConversion([&](cir::VectorType type) -> mlir::Type {
     auto ty = converter.convertType(type.getEltType());
     return mlir::VectorType::get(type.getSize(), ty);
   });
   converter.addConversion([&](cir::StructType type) -> mlir::Type {
-    auto convertWithValueSemanticsArray = [&](mlir::Type t) {
-      if (mlir::isa<cir::ArrayType>(t))
-        // Inside a class/struct/union, an array has value semantics and is
-        // lowered as a tensor.
-        return lowerArrayType(mlir::cast<cir::ArrayType>(t),
-                              /* hasValueSemantics */ true, converter);
-      return converter.convertType(t);
-    };
     // FIXME(cir): create separate unions, struct, and classes types.
     // Convert struct members.
     llvm::SmallVector<mlir::Type> mlirMembers;
@@ -1552,13 +1548,13 @@ mlir::TypeConverter prepareTypeConverter(mlir::DataLayout &dataLayout) {
       // TODO(cir): This should be properly validated.
     case cir::StructType::Struct:
       for (auto ty : type.getMembers())
-        mlirMembers.push_back(convertWithValueSemanticsArray(ty));
+        mlirMembers.push_back(converter.convertType(ty));
       break;
     // Unions are lowered as only the largest member.
     case cir::StructType::Union: {
       auto largestMember = type.getLargestMember(dataLayout);
       if (largestMember)
-        mlirMembers.push_back(convertWithValueSemanticsArray(largestMember));
+        mlirMembers.push_back(converter.convertType(largestMember));
       break;
     }
     }