[CIR][CIRGen][NFC] Add more skeleton for handling inheritance ctors

While here add some bits for ptr auth and match OG.

clang/include/clang/CIR/MissingFeatures.h

@@ -60,6 +60,7 @@ struct MissingFeatures {
   static bool tbaa() { return false; }
   static bool cleanups() { return false; }
   static bool emitNullabilityCheck() { return false; }
+  static bool ptrAuth() { return false; }
 
   // GNU vectors are done, but other kinds of vectors haven't been implemented.
   static bool scalableVectors() { return false; }

clang/lib/CIR/CodeGen/Address.h

@@ -91,6 +91,13 @@ class Address {
     return PointerAndKnownNonNull.getPointer();
   }
 
+  mlir::Value getBasePointer() const {
+    // TODO(cir): Remove the version above when we catchup with OG codegen on
+    // ptr auth.
+    assert(isValid() && "pointer isn't valid");
+    return getPointer();
+  }
+
   /// Return the alignment of this pointer.
   clang::CharUnits getAlignment() const {
     // assert(isValid());

clang/lib/CIR/CodeGen/CIRGenClass.cpp

@@ -1811,6 +1811,30 @@ void CIRGenFunction::buildCXXAggrConstructorCall(
     constantCount.erase();
 }
 
+static bool canEmitDelegateCallArgs(CIRGenFunction &CGF,
+                                    const CXXConstructorDecl *Ctor,
+                                    CXXCtorType Type, CallArgList &Args) {
+  // We can't forward a variadic call.
+  if (Ctor->isVariadic())
+    return false;
+
+  if (CGF.getTarget().getCXXABI().areArgsDestroyedLeftToRightInCallee()) {
+    // If the parameters are callee-cleanup, it's not safe to forward.
+    for (auto *P : Ctor->parameters())
+      if (P->needsDestruction(CGF.getContext()))
+        return false;
+
+    // Likewise if they're inalloca.
+    const CIRGenFunctionInfo &Info =
+        CGF.CGM.getTypes().arrangeCXXConstructorCall(Args, Ctor, Type, 0, 0);
+    if (Info.usesInAlloca())
+      return false;
+  }
+
+  // Anything else should be OK.
+  return true;
+}
+
 void CIRGenFunction::buildCXXConstructorCall(const clang::CXXConstructorDecl *D,
                                              clang::CXXCtorType Type,
                                              bool ForVirtualBase,
@@ -1872,7 +1896,14 @@ void CIRGenFunction::buildCXXConstructorCall(
 
   bool PassPrototypeArgs = true;
 
-  assert(!D->getInheritedConstructor() && "inheritance NYI");
+  // Check whether we can actually emit the constructor before trying to do so.
+  if (auto Inherited = D->getInheritedConstructor()) {
+    PassPrototypeArgs = getTypes().inheritingCtorHasParams(Inherited, Type);
+    if (PassPrototypeArgs && !canEmitDelegateCallArgs(*this, D, Type, Args)) {
+      llvm_unreachable("NYI");
+      return;
+    }
+  }
 
   // Insert any ABI-specific implicit constructor arguments.
   CIRGenCXXABI::AddedStructorArgCounts ExtraArgs =
@@ -1891,4 +1922,33 @@ void CIRGenFunction::buildCXXConstructorCall(
          ClassDecl->isDynamicClass() || Type == Ctor_Base ||
          !CGM.getCodeGenOpts().StrictVTablePointers &&
              "vtable assumption loads NYI");
+}
+
+void CIRGenFunction::buildInheritedCXXConstructorCall(
+    const CXXConstructorDecl *D, bool ForVirtualBase, Address This,
+    bool InheritedFromVBase, const CXXInheritedCtorInitExpr *E) {
+  CallArgList Args;
+  CallArg ThisArg(RValue::get(getAsNaturalPointerTo(
+                      This, D->getThisType()->getPointeeType())),
+                  D->getThisType());
+
+  // Forward the parameters.
+  if (InheritedFromVBase &&
+      CGM.getTarget().getCXXABI().hasConstructorVariants()) {
+    llvm_unreachable("NYI");
+  } else if (!CXXInheritedCtorInitExprArgs.empty()) {
+    // The inheriting constructor was inlined; just inject its arguments.
+    llvm_unreachable("NYI");
+  } else {
+    // The inheriting constructor was not inlined. Emit delegating arguments.
+    llvm_unreachable("NYI");
+  }
+
+  llvm_unreachable("NYI");
+}
+
+void CIRGenFunction::buildInlinedInheritingCXXConstructorCall(
+    const CXXConstructorDecl *Ctor, CXXCtorType CtorType, bool ForVirtualBase,
+    bool Delegating, CallArgList &Args) {
+  llvm_unreachable("NYI");
 }

clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp

@@ -296,9 +296,7 @@ class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
   }
   void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
   void VisitCXXConstructExpr(const CXXConstructExpr *E);
-  void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E) {
-    llvm_unreachable("NYI");
-  }
+  void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
   void VisitLambdaExpr(LambdaExpr *E);
   void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
     ASTContext &Ctx = CGF.getContext();
@@ -1456,6 +1454,14 @@ void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
   Visit(E->getRHS());
 }
 
+void AggExprEmitter::VisitCXXInheritedCtorInitExpr(
+    const CXXInheritedCtorInitExpr *E) {
+  AggValueSlot Slot = EnsureSlot(CGF.getLoc(E->getSourceRange()), E->getType());
+  CGF.buildInheritedCXXConstructorCall(E->getConstructor(),
+                                       E->constructsVBase(), Slot.getAddress(),
+                                       E->inheritedFromVBase(), E);
+}
+
 //===----------------------------------------------------------------------===//
 //                        Helpers and dispatcher
 //===----------------------------------------------------------------------===//

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -655,6 +655,24 @@ class CIRGenFunction : public CIRGenTypeCache {
   void buildCXXConstructExpr(const clang::CXXConstructExpr *E,
                              AggValueSlot Dest);
 
+  /// Emit a call to an inheriting constructor (that is, one that invokes a
+  /// constructor inherited from a base class) by inlining its definition. This
+  /// is necessary if the ABI does not support forwarding the arguments to the
+  /// base class constructor (because they're variadic or similar).
+  void buildInlinedInheritingCXXConstructorCall(const CXXConstructorDecl *Ctor,
+                                                CXXCtorType CtorType,
+                                                bool ForVirtualBase,
+                                                bool Delegating,
+                                                CallArgList &Args);
+
+  /// Emit a call to a constructor inherited from a base class, passing the
+  /// current constructor's arguments along unmodified (without even making
+  /// a copy).
+  void buildInheritedCXXConstructorCall(const CXXConstructorDecl *D,
+                                        bool ForVirtualBase, Address This,
+                                        bool InheritedFromVBase,
+                                        const CXXInheritedCtorInitExpr *E);
+
   void buildCXXConstructorCall(const clang::CXXConstructorDecl *D,
                                clang::CXXCtorType Type, bool ForVirtualBase,
                                bool Delegating, AggValueSlot ThisAVS,
@@ -920,6 +938,12 @@ class CIRGenFunction : public CIRGenTypeCache {
   RValue buildCallExpr(const clang::CallExpr *E,
                        ReturnValueSlot ReturnValue = ReturnValueSlot());
 
+  Address getAsNaturalAddressOf(Address Addr, QualType PointeeTy);
+
+  mlir::Value getAsNaturalPointerTo(Address Addr, QualType PointeeType) {
+    return getAsNaturalAddressOf(Addr, PointeeType).getBasePointer();
+  }
+
   mlir::Value buildRuntimeCall(mlir::Location loc, mlir::cir::FuncOp callee,
                                ArrayRef<mlir::Value> args = {});
 
@@ -1937,6 +1961,10 @@ class CIRGenFunction : public CIRGenTypeCache {
                          Destroyer *destroyer, bool checkZeroLength,
                          bool useEHCleanup);
 
+  /// The values of function arguments to use when evaluating
+  /// CXXInheritedCtorInitExprs within this context.
+  CallArgList CXXInheritedCtorInitExprArgs;
+
   // Points to the outermost active conditional control. This is used so that
   // we know if a temporary should be destroyed conditionally.
   ConditionalEvaluation *OutermostConditional = nullptr;

clang/lib/CIR/CodeGen/CIRGenPointerAuth.cpp

@@ -0,0 +1,23 @@
+//===--- CIRGenPointerAuth.cpp - CIR generation for ptr auth --------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains common routines relating to the emission of
+// pointer authentication operations.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CIRGenFunction.h"
+
+using namespace clang;
+using namespace cir;
+
+Address CIRGenFunction::getAsNaturalAddressOf(Address Addr,
+                                              QualType PointeeTy) {
+  assert(!MissingFeatures::ptrAuth() && "NYI");
+  return Addr;
+}

clang/lib/CIR/CodeGen/CMakeLists.txt

@@ -34,6 +34,7 @@ add_clang_library(clangCIR
   CIRGenOpenCLRuntime.cpp
   CIRGenOpenCL.cpp
   CIRGenOpenMPRuntime.cpp
+  CIRGenPointerAuth.cpp
   CIRGenStmt.cpp
   CIRGenStmtOpenMP.cpp
   CIRGenTBAA.cpp