[CIR] Implement non-virtual thunk generation for multiple inheritance

This patch implements complete support for generating non-virtual thunks
in ClangIR for multiple inheritance scenarios. Thunks are small adapter
functions that adjust the 'this' pointer and forward calls to the actual
target function when virtual functions are overridden in derived classes
with multiple base classes.

Implementation details:

1. **CIRGenVTables.cpp**:
   - Implemented `generateThunk()` to create thunk function bodies with
     proper scope management (SymTableScopeTy + LexicalScope)
   - Implemented `emitCallAndReturnForThunk()` to emit the call sequence
   - Implemented `setThunkProperties()` to set linkage and properties
   - Fixed VTable double-insertion bug in vtable emission

2. **CIRGenCXXABI.h/cpp**:
   - Added virtual methods `performThisAdjustment()` and
     `performReturnAdjustment()` to base class
   - Implemented `EmitReturnFromThunk()` default implementation

3. **CIRGenItaniumCXXABI.cpp**:
   - Implemented `performThisAdjustment()` for non-virtual adjustments
     using cir.ptr_stride operations
   - Implemented `performReturnAdjustment()` for covariant return types
   - Virtual adjustments marked as NYI with llvm_unreachable

4. **CIRGenFunction.h/cpp**:
   - Added `startThunk()`, `generateThunk()`, `emitCallAndReturnForThunk()`,
     `finishThunk()`, and `emitMustTailThunk()` methods
   - Implemented `finishThunk()` to properly cleanup after thunk generation

5. **CIRGenModule.cpp**:
   - Removed assertion blocking thunks in `setFunctionAttributes()`
   - Fixed insertion point management in vtable creation

6. **CIRGenCXX.cpp**:
   - Added null checks for GlobalDecl in XRay attributes for thunks

7. **Test Updates**:
   - Added `clang/test/CIR/CodeGen/vtable-thunk.cpp` for CIR generation
   - Added `clang/test/CIR/Lowering/vtable-thunk.cpp` for LLVM lowering
   - Fixed offset expectations (16 bytes for x86_64 layout)
   - Reordered FileCheck patterns to match actual CIR output order

This implementation closely follows CodeGen's approach in
CodeGenVTables.cpp and CodeGenItaniumCXXABI.cpp, with adaptations for
CIR's MLIR-based infrastructure (e.g., location requirements, operation
builders, scope management).

Limitations:
- Virtual adjustments (vcall offsets) not yet implemented
- Musttail thunks for variadic functions not yet implemented
- Return adjustments implemented but not extensively tested

Test Plan:
```
bin/llvm-lit -v ../../clang/test/CIR/CodeGen/vtable-thunk.cpp
bin/llvm-lit -v ../../clang/test/CIR/Lowering/vtable-thunk.cpp
```

Both tests pass, verifying:
- CIR generation with correct thunk mangling and operations
- Vtable contains thunk references
- Lowering to LLVM IR produces correct getelementptr operations

ghstack-source-id: eb03968
Pull-Request: #2006

Author: lanza

clang/lib/CIR/CodeGen/CIRGenCXXABI.cpp

@@ -104,3 +104,11 @@ bool CIRGenCXXABI::requiresArrayCookie(const CXXNewExpr *E) {
 
   return E->getAllocatedType().isDestructedType();
 }
+
+void CIRGenCXXABI::emitReturnFromThunk(CIRGenFunction &cgf, RValue rv,
+                                       QualType resultType) {
+  assert(!cgf.hasAggregateEvaluationKind(resultType) &&
+         "cannot handle aggregates");
+  auto loc = cgf.getBuilder().getUnknownLoc();
+  cgf.emitReturnOfRValue(loc, rv, resultType);
+}

clang/lib/CIR/CodeGen/CIRGenCXXABI.h

@@ -234,6 +234,24 @@ class CIRGenCXXABI {
   virtual void setThunkLinkage(cir::FuncOp Thunk, bool ForVTable, GlobalDecl GD,
                                bool ReturnAdjustment) = 0;
 
+  /// Perform adjustment on the this pointer for a thunk.
+  /// Returns the adjusted this pointer value.
+  virtual mlir::Value
+  performThisAdjustment(CIRGenFunction &cgf, Address thisAddr,
+                        const CXXRecordDecl *unadjustedClass,
+                        const ThunkInfo &ti) = 0;
+
+  /// Perform adjustment on a return pointer for a thunk (covariant returns).
+  /// Returns the adjusted return pointer value.
+  virtual mlir::Value
+  performReturnAdjustment(CIRGenFunction &cgf, Address ret,
+                          const CXXRecordDecl *unadjustedClass,
+                          const ReturnAdjustment &ra) = 0;
+
+  /// Emit a return from a thunk.
+  virtual void emitReturnFromThunk(CIRGenFunction &cgf, RValue rv,
+                                   QualType resultType);
+
   virtual mlir::Attribute getAddrOfRTTIDescriptor(mlir::Location loc,
                                                   QualType Ty) = 0;
   virtual CatchTypeInfo

clang/lib/CIR/CodeGen/CIRGenFunction.cpp

@@ -765,8 +765,10 @@ cir::FuncOp CIRGenFunction::generateCode(clang::GlobalDecl gd, cir::FuncOp fn,
   // Create a scope in the symbol table to hold variable declarations.
   SymTableScopeTy varScope(symbolTable);
   // Compiler synthetized functions might have invalid slocs...
-  auto bSrcLoc = fd->getBody()->getBeginLoc();
-  auto eSrcLoc = fd->getBody()->getEndLoc();
+  auto bSrcLoc =
+      (fd && fd->getBody()) ? fd->getBody()->getBeginLoc() : SourceLocation();
+  auto eSrcLoc =
+      (fd && fd->getBody()) ? fd->getBody()->getEndLoc() : SourceLocation();
   auto unknownLoc = builder.getUnknownLoc();
 
   auto fnBeginLoc = bSrcLoc.isValid() ? getLoc(bSrcLoc) : unknownLoc;
@@ -1158,11 +1160,11 @@ void CIRGenFunction::StartFunction(GlobalDecl gd, QualType retTy,
     llvm_unreachable("NYI");
 
   // Apply xray attributes to the function (as a string, for now)
-  if (d->getAttr<XRayInstrumentAttr>()) {
+  if (d && d->getAttr<XRayInstrumentAttr>()) {
     assert(!cir::MissingFeatures::xray());
   }
 
-  if (ShouldXRayInstrumentFunction()) {
+  if (d && ShouldXRayInstrumentFunction()) {
     assert(!cir::MissingFeatures::xray());
   }
 
@@ -1365,12 +1367,15 @@ void CIRGenFunction::StartFunction(GlobalDecl gd, QualType retTy,
 
       // Location of the store to the param storage tracked as beginning of
       // the function body.
-      auto fnBodyBegin = getLoc(fd->getBody()->getBeginLoc());
+      auto fnBodyBegin = (fd && fd->getBody())
+                             ? getLoc(fd->getBody()->getBeginLoc())
+                             : getLoc(Loc);
       builder.CIRBaseBuilderTy::createStore(fnBodyBegin, paramVal, addr);
     }
     assert(builder.getInsertionBlock() && "Should be valid");
 
-    auto fnEndLoc = getLoc(fd->getBody()->getEndLoc());
+    auto fnEndLoc = (fd && fd->getBody()) ? getLoc(fd->getBody()->getEndLoc())
+                                          : getLoc(Loc);
 
     // When the current function is not void, create an address to store the
     // result value.

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -2131,6 +2131,24 @@ class CIRGenFunction : public CIRGenTypeCache {
 
   void emitDestructorBody(FunctionArgList &Args);
 
+  /// Generate a thunk for the given method.
+  void generateThunk(cir::FuncOp fn, const CIRGenFunctionInfo &fnInfo,
+                     GlobalDecl gd, const ThunkInfo &thunk,
+                     bool isUnprototyped);
+
+  void startThunk(cir::FuncOp fn, GlobalDecl gd,
+                  const CIRGenFunctionInfo &fnInfo, bool isUnprototyped);
+
+  void emitCallAndReturnForThunk(cir::FuncOp callee, const ThunkInfo *thunk,
+                                 bool isUnprototyped);
+
+  /// Finish thunk generation.
+  void finishThunk();
+
+  /// Emit a musttail call for a thunk with a potentially adjusted this pointer.
+  void emitMustTailThunk(GlobalDecl gd, mlir::Value adjustedThisPtr,
+                         cir::FuncOp callee);
+
   mlir::LogicalResult emitDoStmt(const clang::DoStmt &S);
 
   mlir::Value emitDynamicCast(Address ThisAddr, const CXXDynamicCastExpr *DCE);

clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp

@@ -243,6 +243,15 @@ class CIRGenItaniumCXXABI : public CIRGenCXXABI {
   }
 
   bool exportThunk() override { return true; }
+
+  mlir::Value performThisAdjustment(CIRGenFunction &cgf, Address thisAddr,
+                                    const CXXRecordDecl *unadjustedClass,
+                                    const ThunkInfo &ti) override;
+
+  mlir::Value performReturnAdjustment(CIRGenFunction &cgf, Address ret,
+                                      const CXXRecordDecl *unadjustedClass,
+                                      const ReturnAdjustment &ra) override;
+
   mlir::Attribute getAddrOfRTTIDescriptor(mlir::Location loc,
                                           QualType Ty) override;
   bool useThunkForDtorVariant(const CXXDestructorDecl *Dtor,
@@ -2144,6 +2153,63 @@ mlir::Attribute CIRGenItaniumCXXABI::getAddrOfRTTIDescriptor(mlir::Location loc,
   return CIRGenItaniumRTTIBuilder(*this, CGM).BuildTypeInfo(loc, Ty);
 }
 
+static mlir::Value performTypeAdjustment(CIRGenFunction &cgf,
+                                         Address initialPtr,
+                                         const CXXRecordDecl *unadjustedClass,
+                                         int64_t nonVirtualAdjustment,
+                                         int64_t virtualAdjustment,
+                                         bool isReturnAdjustment) {
+  if (!nonVirtualAdjustment && !virtualAdjustment)
+    return initialPtr.getPointer();
+
+  auto &builder = cgf.getBuilder();
+  auto loc = builder.getUnknownLoc();
+  auto i8PtrTy = builder.getUInt8PtrTy();
+  mlir::Value v = builder.createBitcast(initialPtr.getPointer(), i8PtrTy);
+
+  // In a base-to-derived cast, the non-virtual adjustment is applied first.
+  if (nonVirtualAdjustment && !isReturnAdjustment) {
+    auto offsetConst = builder.getSInt64(nonVirtualAdjustment, loc);
+    v = builder.create<cir::PtrStrideOp>(loc, i8PtrTy, v, offsetConst);
+  }
+
+  // Perform the virtual adjustment if we have one.
+  mlir::Value resultPtr;
+  if (virtualAdjustment) {
+    llvm_unreachable("Virtual adjustment NYI - requires vtable offset lookup");
+  } else {
+    resultPtr = v;
+  }
+
+  // In a derived-to-base conversion, the non-virtual adjustment is
+  // applied second.
+  if (nonVirtualAdjustment && isReturnAdjustment) {
+    auto offsetConst = builder.getSInt64(nonVirtualAdjustment, loc);
+    resultPtr =
+        builder.create<cir::PtrStrideOp>(loc, i8PtrTy, resultPtr, offsetConst);
+  }
+
+  // Cast back to original pointer type
+  return builder.createBitcast(resultPtr, initialPtr.getType());
+}
+
+mlir::Value CIRGenItaniumCXXABI::performThisAdjustment(
+    CIRGenFunction &cgf, Address thisAddr, const CXXRecordDecl *unadjustedClass,
+    const ThunkInfo &ti) {
+  return performTypeAdjustment(cgf, thisAddr, unadjustedClass,
+                               ti.This.NonVirtual,
+                               ti.This.Virtual.Itanium.VCallOffsetOffset,
+                               /*IsReturnAdjustment=*/false);
+}
+
+mlir::Value CIRGenItaniumCXXABI::performReturnAdjustment(
+    CIRGenFunction &cgf, Address ret, const CXXRecordDecl *unadjustedClass,
+    const ReturnAdjustment &ra) {
+  return performTypeAdjustment(cgf, ret, unadjustedClass, ra.NonVirtual,
+                               ra.Virtual.Itanium.VBaseOffsetOffset,
+                               /*IsReturnAdjustment=*/true);
+}
+
 void CIRGenItaniumCXXABI::emitVTableDefinitions(CIRGenVTables &CGVT,
                                                 const CXXRecordDecl *RD) {
   auto VTable = getAddrOfVTable(RD, CharUnits());

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -826,14 +826,22 @@ cir::GlobalOp CIRGenModule::createGlobalOp(CIRGenModule &cgm,
     // Some global emissions are triggered while emitting a function, e.g.
     // void s() { const char *s = "yolo"; ... }
     //
-    // Be sure to insert global before the current function
+    // Save the current function context for later insertion logic
     auto *curCGF = cgm.getCurrCIRGenFun();
-    if (curCGF)
-      builder.setInsertionPoint(curCGF->CurFn);
+
+    // Clear insertion point to prevent auto-insertion by create()
+    // We'll manually insert at the correct location below
+    builder.clearInsertionPoint();
 
     g = cir::GlobalOp::create(builder, loc, name, t, isConstant, linkage,
                               addrSpace);
-    if (!curCGF) {
+
+    // Manually insert at the correct location
+    if (curCGF) {
+      // Insert before the current function being generated
+      cgm.getModule().insert(mlir::Block::iterator(curCGF->CurFn), g);
+    } else {
+      // Insert at specified point or at end of module
       if (insertPoint)
         cgm.getModule().insert(insertPoint, g);
       else
@@ -2675,6 +2683,11 @@ void CIRGenModule::setDSOLocal(mlir::Operation *op) const {
   }
 }
 
+void CIRGenModule::setGVProperties(mlir::Operation *op, GlobalDecl gd) const {
+  assert(!cir::MissingFeatures::setDLLImportDLLExport());
+  setGVPropertiesAux(op, dyn_cast<NamedDecl>(gd.getDecl()));
+}
+
 void CIRGenModule::setGVProperties(mlir::Operation *op,
                                    const NamedDecl *d) const {
   assert(!cir::MissingFeatures::setDLLImportDLLExport());
@@ -2710,10 +2723,12 @@ cir::FuncOp CIRGenModule::createCIRFunction(mlir::Location loc, StringRef name,
     // Some global emissions are triggered while emitting a function, e.g.
     // void s() { x.method() }
     //
-    // Be sure to insert a new function before a current one.
+    // Save the current function context for later insertion logic
     auto *curCGF = getCurrCIRGenFun();
-    if (curCGF)
-      builder.setInsertionPoint(curCGF->CurFn);
+
+    // Clear insertion point to prevent auto-insertion by create()
+    // We'll manually insert at the correct location below
+    builder.clearInsertionPoint();
 
     f = cir::FuncOp::create(builder, loc, name, ty);
 
@@ -2739,8 +2754,14 @@ cir::FuncOp CIRGenModule::createCIRFunction(mlir::Location loc, StringRef name,
     // Set the special member attribute for this function, if applicable.
     setCXXSpecialMemberAttr(f, fd);
 
-    if (!curCGF)
+    // Manually insert at the correct location
+    if (curCGF) {
+      // Insert before the current function being generated
+      theModule.insert(mlir::Block::iterator(curCGF->CurFn), f);
+    } else {
+      // Insert at end of module
       theModule.push_back(f);
+    }
   }
   return f;
 }
@@ -3064,20 +3085,27 @@ void CIRGenModule::setFunctionAttributes(GlobalDecl globalDecl,
   // NOTE(cir): Original CodeGen checks if this is an intrinsic. In CIR we
   // represent them in dedicated ops. The correct attributes are ensured during
   // translation to LLVM. Thus, we don't need to check for them here.
-  assert(!isThunk && "isThunk NYI");
 
-  if (!isIncompleteFunction) {
+  const auto *funcDecl = dyn_cast<FunctionDecl>(globalDecl.getDecl());
+
+  if (!isIncompleteFunction)
     setCIRFunctionAttributes(globalDecl,
                              getTypes().arrangeGlobalDeclaration(globalDecl),
                              func, isThunk);
+
+  // Add the Returned attribute for "this", except for iOS 5 and earlier
+  // where substantial code, including the libstdc++ dylib, was compiled with
+  // GCC and does not actually return "this".
+  if (!isThunk && getCXXABI().HasThisReturn(globalDecl) &&
+      !(getTriple().isiOS() && getTriple().isOSVersionLT(6))) {
+    llvm_unreachable("NYI");
   }
 
   // TODO(cir): Complete the remaining part of the function.
   assert(!cir::MissingFeatures::setFunctionAttributes());
 
   if (!isIncompleteFunction && func.isDeclaration())
-    getTargetCIRGenInfo().setTargetAttributes(globalDecl.getDecl(), func,
-                                              *this);
+    getTargetCIRGenInfo().setTargetAttributes(funcDecl, func, *this);
 
   // TODO(cir): This needs a lot of work to better match CodeGen. That
   // ultimately ends up in setGlobalVisibility, which already has the linkage of

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -680,8 +680,9 @@ class CIRGenModule : public CIRGenTypeCache {
   void setDSOLocal(mlir::Operation *Op) const;
   /// Set visibility, dllimport/dllexport and dso_local.
   /// This must be called after dllimport/dllexport is set.
-  void setGVProperties(mlir::Operation *Op, const NamedDecl *D) const;
-  void setGVPropertiesAux(mlir::Operation *Op, const NamedDecl *D) const;
+  void setGVProperties(mlir::Operation *op, GlobalDecl gd) const;
+  void setGVProperties(mlir::Operation *op, const NamedDecl *d) const;
+  void setGVPropertiesAux(mlir::Operation *op, const NamedDecl *d) const;
 
   /// Set the TLS mode for the given global Op for the thread-local
   /// variable declaration D.
@@ -760,8 +761,8 @@ class CIRGenModule : public CIRGenTypeCache {
   void UpdateCompletedType(const clang::TagDecl *TD);
 
   /// Set function attributes for a function declaration.
-  void setFunctionAttributes(GlobalDecl GD, cir::FuncOp F,
-                             bool IsIncompleteFunction, bool IsThunk);
+  void setFunctionAttributes(GlobalDecl globalDecl, cir::FuncOp func,
+                             bool isIncompleteFunction, bool isThunk);
 
   /// Set the CIR function attributes (sext, zext, etc).
   void setCIRFunctionAttributes(GlobalDecl GD, const CIRGenFunctionInfo &info,