Update on "[CIR][CIRGen] Support mutable and recursive named records"

This allows a named StructType to be mutated after it has been created,
if it is identified and incomplete.

The motivation for this is to improve the codegen of CIR in certain
scenarios where an incomplete type is used and later completed. These
usually leave the IR in an inconsistent state, where there are two
records types with the same identifier but different definitions (one
complete the other incomplete).

For example:

```c++
struct Node {
  Node *next;
};
void test(struct Node n) {}
```

Generates:

```mlir
!temp_struct = !cir.struct<struct "Node" incomplete>
!full_struct = !cir.struct<struct "Node" {!cir.ptr<!temp_struct>}>
```

To generate the `Node` struct type, its members must be created first.
However, the `next` member is a recursive reference, so it can only be
completed after its parent. This generates a temporary incomplete
definition of the `Node` type that remains in the code even after the
type to which it refers is completed. As a consequence, accessing the
`next` member of a `Node` value fetches the old incomplete version of
the type which affects CIR's type-checking capabilities.

This patch ensures that, once the parent is fully visited, the `next`
member can be completed in place, automatically updating any references
to it at a low cost. To represent recursive types, the StructType now
is equipped with self-references. These are represented by a
`cir.struct` type with just the name of the parent struct that it
refers to. The same snippet of code will not generate the following
CIR IR:

```mlir
!full_struct = !cir.struct<struct "Node" {!cir.ptr<!cir.struct<struct "Node">>}>
```

Summary of the changes made:
 - Named records are now uniquely identified by their name. An attempt
   to create a new record with the same will fail.
 - Anonymous records are uniquely identified by members and other
   relevant attributes.
 - StructType has a new `mutate` method that allows it to be mutated
   after it has been created. Each type can only be mutated if it is
   identified and incomplete, rendering further changes impossible.
 - When building a new name StructType, the builder will try to first
   create, then complete the type, ensuring that:

    - Inexistent types are created
    - Existing incomplete types are completed
    - Existing complete types with matching attributes are reused
    - Existing complete types with different attributes raise errors

 - StructType now uses the CyclicParser/Printer guard to avoid infinite
   recursion and identify when it should print/parse a self-reference.

[ghstack-poisoned]

Author: sitio-couto

clang/include/clang/CIR/LowerToLLVM.h

@@ -31,7 +31,8 @@ namespace cir {
 namespace direct {
 std::unique_ptr<llvm::Module>
 lowerDirectlyFromCIRToLLVMIR(mlir::ModuleOp theModule,
-                             llvm::LLVMContext &llvmCtx);
+                             llvm::LLVMContext &llvmCtx,
+                             bool disableVerifier = false);
 }
 
 // Lower directly from pristine CIR to LLVMIR.

clang/lib/CIR/FrontendAction/CIRGenAction.cpp

@@ -72,11 +72,14 @@ static std::string sanitizePassOptions(llvm::StringRef o) {
 
 namespace cir {
 
-static std::unique_ptr<llvm::Module> lowerFromCIRToLLVMIR(
-    const clang::FrontendOptions &feOptions, mlir::ModuleOp mlirMod,
-    std::unique_ptr<mlir::MLIRContext> mlirCtx, llvm::LLVMContext &llvmCtx) {
+static std::unique_ptr<llvm::Module>
+lowerFromCIRToLLVMIR(const clang::FrontendOptions &feOptions,
+                     mlir::ModuleOp mlirMod,
+                     std::unique_ptr<mlir::MLIRContext> mlirCtx,
+                     llvm::LLVMContext &llvmCtx, bool disableVerifier = false) {
   if (feOptions.ClangIRDirectLowering)
-    return direct::lowerDirectlyFromCIRToLLVMIR(mlirMod, llvmCtx);
+    return direct::lowerDirectlyFromCIRToLLVMIR(mlirMod, llvmCtx,
+                                                disableVerifier);
   else
     return lowerFromCIRToMLIRToLLVMIR(mlirMod, std::move(mlirCtx), llvmCtx);
 }
@@ -245,7 +248,8 @@ class CIRGenConsumer : public clang::ASTConsumer {
     case CIRGenAction::OutputType::EmitLLVM: {
       llvm::LLVMContext llvmCtx;
       auto llvmModule =
-          lowerFromCIRToLLVMIR(feOptions, mlirMod, std::move(mlirCtx), llvmCtx);
+          lowerFromCIRToLLVMIR(feOptions, mlirMod, std::move(mlirCtx), llvmCtx,
+                               feOptions.ClangIRDisableCIRVerifier);
 
       llvmModule->setTargetTriple(targetOptions.Triple);
 
@@ -259,7 +263,8 @@ class CIRGenConsumer : public clang::ASTConsumer {
     case CIRGenAction::OutputType::EmitObj: {
       llvm::LLVMContext llvmCtx;
       auto llvmModule =
-          lowerFromCIRToLLVMIR(feOptions, mlirMod, std::move(mlirCtx), llvmCtx);
+          lowerFromCIRToLLVMIR(feOptions, mlirMod, std::move(mlirCtx), llvmCtx,
+                               feOptions.ClangIRDisableCIRVerifier);
 
       llvmModule->setTargetTriple(targetOptions.Triple);
       EmitBackendOutput(diagnosticsEngine, headerSearchOptions, codeGenOptions,
@@ -272,7 +277,8 @@ class CIRGenConsumer : public clang::ASTConsumer {
     case CIRGenAction::OutputType::EmitAssembly: {
       llvm::LLVMContext llvmCtx;
       auto llvmModule =
-          lowerFromCIRToLLVMIR(feOptions, mlirMod, std::move(mlirCtx), llvmCtx);
+          lowerFromCIRToLLVMIR(feOptions, mlirMod, std::move(mlirCtx), llvmCtx,
+                               feOptions.ClangIRDisableCIRVerifier);
 
       llvmModule->setTargetTriple(targetOptions.Triple);
       EmitBackendOutput(diagnosticsEngine, headerSearchOptions, codeGenOptions,

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

@@ -2160,7 +2160,8 @@ std::unique_ptr<mlir::Pass> createConvertCIRToLLVMPass() {
 extern void registerCIRDialectTranslation(mlir::MLIRContext &context);
 
 std::unique_ptr<llvm::Module>
-lowerDirectlyFromCIRToLLVMIR(mlir::ModuleOp theModule, LLVMContext &llvmCtx) {
+lowerDirectlyFromCIRToLLVMIR(mlir::ModuleOp theModule, LLVMContext &llvmCtx,
+                             bool disableVerifier) {
   mlir::MLIRContext *mlirCtx = theModule.getContext();
   mlir::PassManager pm(mlirCtx);
 
@@ -2177,6 +2178,7 @@ lowerDirectlyFromCIRToLLVMIR(mlir::ModuleOp theModule, LLVMContext &llvmCtx) {
   // emmited and how to properly avoid them.
   pm.addPass(mlir::createReconcileUnrealizedCastsPass());
 
+  pm.enableVerifier(!disableVerifier);
   (void)mlir::applyPassManagerCLOptions(pm);
 
   auto result = !mlir::failed(pm.run(theModule));

clang/tools/cir-translate/cir-translate.cpp

@@ -26,7 +26,8 @@ namespace direct {
 extern void registerCIRDialectTranslation(mlir::DialectRegistry &registry);
 extern std::unique_ptr<llvm::Module>
 lowerDirectlyFromCIRToLLVMIR(mlir::ModuleOp theModule,
-                             llvm::LLVMContext &llvmCtx);
+                             llvm::LLVMContext &llvmCtx,
+                             bool disableVerifier = false);
 } // namespace direct
 }