[CIR][CIRGen] Handle NYI in CIRGenModule::tryEmitBaseDestructorAsAlias (#1180)

This removes some NYI in CIRGenModule::tryEmitBaseDestructorAsAlias and
similar to #1179, use
`assert(false)` to tell devs to add test.

It is slightly verbose due to the difference between LLVM and CIR's type
system. LLVM's pointer are opaque types while CIR's pointer are typed.
So we need to handle these pointers when transforming the generated cir.

Author: ChuanqiXu9

Diff for: clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -3594,6 +3594,16 @@ class CIR_CallOp<string mnemonic, list<Trait> extra_traits = []> :
 
     bool isIndirect() { return !getCallee(); }
     mlir::Value getIndirectCall();
+
+    void setArg(unsigned index, mlir::Value value) {
+      if (!isIndirect()) {
+        setOperand(index, value);
+        return;
+      }
+
+      // For indirect call, the operand list is shifted by one.
+      setOperand(index + 1, value);
+    }
   }];
 
   let hasCustomAssemblyFormat = 1;

Diff for: clang/lib/CIR/CodeGen/CIRGenCXX.cpp

@@ -146,7 +146,8 @@ bool CIRGenModule::tryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D) {
     // members with attribute "AlwaysInline" and expect no reference to
     // be generated. It is desirable to reenable this optimisation after
     // corresponding LLVM changes.
-    llvm_unreachable("NYI");
+    addReplacement(MangledName, Aliasee);
+    return false;
   }
 
   // If we have a weak, non-discardable alias (weak, weak_odr), like an
@@ -155,7 +156,8 @@ bool CIRGenModule::tryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D) {
   // symbol reference from another TU. The other TU must also mark the
   // referenced symbol as weak, which we cannot rely on.
   if (cir::isWeakForLinker(Linkage) && getTriple().isOSBinFormatCOFF()) {
-    llvm_unreachable("NYI");
+    llvm_unreachable("please sent a PR with a test and remove this.\n");
+    return true;
   }
 
   // If we don't have a definition for the destructor yet or the definition
@@ -169,8 +171,10 @@ bool CIRGenModule::tryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D) {
   // different COMDATs in different TUs. Another option would be to
   // output the alias both for weak_odr and linkonce_odr, but that
   // requires explicit comdat support in the IL.
-  if (cir::isWeakForLinker(TargetLinkage))
-    llvm_unreachable("NYI");
+  if (cir::isWeakForLinker(TargetLinkage)) {
+    llvm_unreachable("please sent a PR with a test and remove this.\n");
+    return true;
+  }
 
   // Create the alias with no name.
   emitAliasForGlobal(MangledName, Entry, AliasDecl, Aliasee, Linkage);

Diff for: clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -3493,6 +3493,39 @@ void CIRGenModule::addReplacement(StringRef Name, mlir::Operation *Op) {
   Replacements[Name] = Op;
 }
 
+void CIRGenModule::replacePointerTypeArgs(cir::FuncOp OldF, cir::FuncOp NewF) {
+  auto optionalUseRange = OldF.getSymbolUses(theModule);
+  if (!optionalUseRange)
+    return;
+
+  for (auto U : *optionalUseRange) {
+    // CallTryOp only shows up after FlattenCFG.
+    auto Call = mlir::dyn_cast<cir::CallOp>(U.getUser());
+    if (!Call)
+      continue;
+
+    auto ArgOps = Call.getArgOps();
+    auto FuncArgTypes = NewF.getFunctionType().getInputs();
+    for (unsigned I = 0; I < FuncArgTypes.size(); I++) {
+      if (ArgOps[I].getType() == FuncArgTypes[I])
+        continue;
+
+      auto argPointerTy = mlir::dyn_cast<cir::PointerType>(ArgOps[I].getType());
+      auto funcArgPointerTy = mlir::dyn_cast<cir::PointerType>(FuncArgTypes[I]);
+
+      // If we can't solve it, leave it for the verifier to bail out.
+      if (!argPointerTy || !funcArgPointerTy)
+        continue;
+
+      mlir::OpBuilder::InsertionGuard guard(builder);
+      builder.setInsertionPoint(Call);
+      auto castedArg =
+          builder.createBitcast(Call.getLoc(), ArgOps[I], funcArgPointerTy);
+      Call.setArg(I, castedArg);
+    }
+  }
+}
+
 void CIRGenModule::applyReplacements() {
   for (auto &I : Replacements) {
     StringRef MangledName = I.first();
@@ -3505,6 +3538,10 @@ void CIRGenModule::applyReplacements() {
     auto NewF = dyn_cast<cir::FuncOp>(Replacement);
     assert(NewF && "not implemented");
 
+    // LLVM has opaque pointer but CIR not. So we may have to handle these
+    // different pointer types when performing replacement.
+    replacePointerTypeArgs(OldF, NewF);
+
     // Replace old with new, but keep the old order.
     if (OldF.replaceAllSymbolUses(NewF.getSymNameAttr(), theModule).failed())
       llvm_unreachable("internal error, cannot RAUW symbol");

Diff for: clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -860,6 +860,11 @@ class CIRGenModule : public CIRGenTypeCache {
   /// Call replaceAllUsesWith on all pairs in Replacements.
   void applyReplacements();
 
+  /// A helper function to replace all uses of OldF to NewF that replace
+  /// the type of pointer arguments. This is not needed to tradtional
+  /// pipeline since LLVM has opaque pointers but CIR not.
+  void replacePointerTypeArgs(cir::FuncOp OldF, cir::FuncOp NewF);
+
   void setNonAliasAttributes(GlobalDecl GD, mlir::Operation *GV);
   /// Map source language used to a CIR attribute.
   cir::SourceLanguage getCIRSourceLanguage();

Diff for: clang/test/CIR/CodeGen/dtor-alias.cpp

@@ -0,0 +1,18 @@
+// FIXME: Remove of -clangir-disable-passes may trigger a memory safe bug in CIR internally during
+// lowering
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu \
+// RUN:   -mconstructor-aliases -fclangir -emit-cir %s -o %t.cir \
+// RUN:   -clangir-disable-passes -o %t.cir
+// RUN: FileCheck %s --input-file=%t.cir
+
+namespace {
+struct A {
+  ~A() {}
+};
+
+struct B : public A {};
+}
+
+B x;
+
+// CHECK: cir.call @_ZN12_GLOBAL__N_11AD2Ev({{.*}}) : (!cir.ptr<!ty_28anonymous_namespace293A3AA>) -> ()