WIP on some CIR → MLIR experiment

README.md

@@ -1,3 +1,35 @@
 # ClangIR (CIR)
 
+## Work-in-progress on CIR→MLIR lowering
+
+This is a huge work-in-progress version adding new features used by [`aie++` C++
+programming model](https://github.com/keryell/mlir-aie/tree/clangir), such as
+better support for lowering through MLIR standard dialects.
+
+What is experimented here:
+- adding new features to CIR→MLIR lowering;
+- cleaner lowering C/C++arrays as `tensor` for value semantics (for example in
+  structs) and `memref` for reference semantics (all the other uses);
+- fixing array support and allocation;
+- allowing pointer to array or struct;
+- adding support for class/struct/union by first experimenting with `tuple` and
+  then introducing a new `named_tuple` dialect;
+- implementation of more type of C/C++ casts;
+- support struct member access through some `memref` flattening and casting
+  casting;
+- fixing a lot of verification bugs which are triggered when using ClangIR in a
+  broader framework;
+- enabling in-lining interface to CIR dialect;
+- exposing some API to use ClangIR from a broader framework.
+
+The output of this new lowering flow has not been tested yet followed by the
+MLIR std→LLVMIR.
+
+An alternative design could be to rely on some MLIR std→LLVMIR→MLIR std
+back-and-forth traveling in the same module to have some parts of the LLVMIR
+dialect to implement some missing features like it is done in the
+[Polygeist](https://github.com/llvm/Polygeist) project.
+
+## Main documentation
+
 Check https://clangir.org for general information, build instructions and documentation.

clang/include/clang/CIR/LowerToLLVM.h

@@ -13,7 +13,9 @@
 #define CLANG_CIR_LOWERTOLLVM_H
 
 #include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/DialectConversion.h"
 
+#include <functional>
 #include <memory>
 
 namespace llvm {
@@ -34,6 +36,9 @@ mlir::ModuleOp lowerDirectlyFromCIRToLLVMDialect(mlir::ModuleOp theModule,
                                                  bool disableCCLowering = false,
                                                  bool disableDebugInfo = false);
 
+void runAtStartOfConvertCIRToLLVMPass(
+    std::function<void(mlir::ConversionTarget)>);
+
 // Lower directly from pristine CIR to LLVMIR.
 std::unique_ptr<llvm::Module> lowerDirectlyFromCIRToLLVMIR(
     mlir::ModuleOp theModule, llvm::LLVMContext &llvmCtx,

clang/include/clang/CIR/LowerToMLIR.h

@@ -12,13 +12,24 @@
 #ifndef CLANG_CIR_LOWERTOMLIR_H
 #define CLANG_CIR_LOWERTOMLIR_H
 
+#include "mlir/Interfaces/DataLayoutInterfaces.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include "clang/CIR/Dialect/IR/CIRTypes.h"
+#include <functional>
 
 namespace cir {
 
 void populateCIRLoopToSCFConversionPatterns(mlir::RewritePatternSet &patterns,
                                             mlir::TypeConverter &converter);
 
+mlir::Type lowerArrayType(cir::ArrayType type, bool hasValueSemantics,
+                          mlir::TypeConverter &converter);
+
+mlir::TypeConverter prepareTypeConverter(mlir::DataLayout &dataLayout);
+
+void runAtStartOfConvertCIRToMLIRPass(
+    std::function<void(mlir::ConversionTarget)>);
+
 mlir::ModuleOp
 lowerFromCIRToMLIRToLLVMDialect(mlir::ModuleOp theModule,
                                 mlir::MLIRContext *mlirCtx = nullptr);

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -41,6 +41,7 @@
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/LogicalResult.h"
+#include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 
@@ -117,6 +118,40 @@ struct CIROpAsmDialectInterface : public OpAsmDialectInterface {
         .Default([](Attribute) { return AliasResult::NoAlias; });
   }
 };
+
+// Minimal interface to inline region with only one block for now (not handling
+// the terminator remapping), assuming everything is inlinable.
+struct CIRInlinerInterface : DialectInlinerInterface {
+  using DialectInlinerInterface::DialectInlinerInterface;
+  // Always allows inlining.
+  bool isLegalToInline(Operation *call, Operation *callable,
+                       bool wouldBeCloned) const final override {
+    return true;
+  }
+
+  // Always allows inlining.
+  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
+                       IRMapping &valueMapping) const final override {
+    return true;
+  }
+
+  // Always allows inlining.
+  bool isLegalToInline(Operation *op, Region *, bool wouldBeCloned,
+                       IRMapping &) const final override {
+    return true;
+  }
+
+  // Handle the terminator in the case of a single block
+  void handleTerminator(Operation *op,
+                        ValueRange valuesToReplace) const final override {
+    // Only handle cir.return for now
+    if (auto returnOp = dyn_cast<cir::ReturnOp>(op))
+      for (auto &&[value, operand] :
+           llvm::zip(valuesToReplace, returnOp.getOperands()))
+        value.replaceAllUsesWith(operand);
+  }
+};
+
 } // namespace
 
 /// Dialect initialization, the instance will be owned by the context. This is
@@ -128,7 +163,7 @@ void cir::CIRDialect::initialize() {
 #define GET_OP_LIST
 #include "clang/CIR/Dialect/IR/CIROps.cpp.inc"
       >();
-  addInterfaces<CIROpAsmDialectInterface>();
+  addInterfaces<CIRInlinerInterface, CIROpAsmDialectInterface>();
 }
 
 Operation *cir::CIRDialect::materializeConstant(mlir::OpBuilder &builder,

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -584,7 +584,7 @@ mlir::Value CirAttrToValue::visitCirAttr(cir::ConstArrayAttr constArr) {
   auto loc = parentOp->getLoc();
   mlir::Value result;
 
-  if (auto zeros = constArr.getTrailingZerosNum()) {
+  if (constArr.getTrailingZerosNum()) {
     auto arrayTy = constArr.getType();
     result = rewriter.create<mlir::LLVM::ZeroOp>(
         loc, converter->convertType(arrayTy));
@@ -1381,6 +1381,8 @@ struct ConvertCIRToLLVMPass
 
   void processCIRAttrs(mlir::ModuleOp moduleOp);
 
+  inline static std::function<void(mlir::ConversionTarget)> runAtStartHook;
+
   StringRef getDescription() const override {
     return "Convert the prepared CIR dialect module to LLVM dialect";
   }
@@ -4781,6 +4783,9 @@ void ConvertCIRToLLVMPass::runOnOperation() {
                     // ,YieldOp
                     >();
   // clang-format on
+  if (runAtStartHook)
+    runAtStartHook(target);
+
   target.addLegalDialect<mlir::LLVM::LLVMDialect>();
   target.addIllegalDialect<mlir::BuiltinDialect, cir::CIRDialect,
                            mlir::func::FuncDialect>();
@@ -4818,6 +4823,13 @@ void ConvertCIRToLLVMPass::runOnOperation() {
   processCIRAttrs(module);
 }
 
+/// Set a hook to be called just before applying the dialect conversion so other
+/// dialects or patterns can be added
+void runAtStartOfConvertCIRToLLVMPass(
+    std::function<void(mlir::ConversionTarget)> hook) {
+  ConvertCIRToLLVMPass::runAtStartHook = std::move(hook);
+}
+
 std::unique_ptr<mlir::Pass> createConvertCIRToLLVMPass() {
   return std::make_unique<ConvertCIRToLLVMPass>();
 }

clang/lib/CIR/Lowering/ThroughMLIR/CMakeLists.txt

@@ -41,6 +41,7 @@ add_clang_library(clangCIRLoweringThroughMLIR
   MLIRTransforms
   MLIRSupport
   MLIRMemRefDialect
+  MLIRNamedTupleDialect
   MLIROpenMPDialect
   MLIROpenMPToLLVMIRTranslation
   )