[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: eaf1735
Pull-Request: #2006

Author: lanza

clang/lib/CIR/CodeGen/CIRGenCXX.cpp

@@ -429,3 +429,12 @@ void CIRGenModule::emitCXXGlobalVarDeclInit(const VarDecl *varDecl,
   builder.setInsertionPointToEnd(block);
   cir::YieldOp::create(builder, addr->getLoc());
 }
+
+void CIRGenFunction::finishThunk() {
+  // Clear these to restore the invariants expected by
+  // StartFunction/FinishFunction.
+  CurCodeDecl = nullptr;
+  CurFuncDecl = nullptr;
+
+  finishFunction(SourceLocation());
+}

clang/lib/CIR/CodeGen/CIRGenCXXABI.cpp

@@ -104,3 +104,10 @@ bool CIRGenCXXABI::requiresArrayCookie(const CXXNewExpr *E) {
 
   return E->getAllocatedType().isDestructedType();
 }
+
+void CIRGenCXXABI::EmitReturnFromThunk(CIRGenFunction &CGF, RValue RV,
+                                       QualType ResultType) {
+  // Default implementation: just emit a normal return
+  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 This,
+                        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,8 @@ 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 +1158,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 +1365,13 @@ 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

@@ -2130,6 +2130,23 @@ 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();
+
+  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 This,
+                                    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,
@@ -2148,6 +2157,84 @@ mlir::Attribute CIRGenItaniumCXXABI::getAddrOfRTTIDescriptor(mlir::Location loc,
   return CIRGenItaniumRTTIBuilder(*this, CGM).BuildTypeInfo(loc, Ty);
 }
 
+mlir::Value
+CIRGenItaniumCXXABI::performThisAdjustment(CIRGenFunction &CGF, Address This,
+                                           const CXXRecordDecl *UnadjustedClass,
+                                           const ThunkInfo &TI) {
+  // Handle trivial case: no adjustment needed
+  if (!TI.This.NonVirtual && !TI.This.Virtual.Itanium.VCallOffsetOffset)
+    return This.getPointer();
+
+  auto &builder = CGF.getBuilder();
+  auto loc = builder.getUnknownLoc();
+  mlir::Value V = This.getPointer();
+
+  // Apply non-virtual adjustment first (for base-to-derived cast)
+  if (TI.This.NonVirtual) {
+    // Cast to i8* for byte-level pointer arithmetic
+    auto i8PtrTy = builder.getUInt8PtrTy();
+    V = builder.createBitcast(V, i8PtrTy);
+
+    // Create offset constant (NonVirtual is in bytes)
+    auto offsetConst = builder.getSInt64(TI.This.NonVirtual, loc);
+
+    // Perform pointer arithmetic: this_ptr + offset
+    V = builder.create<cir::PtrStrideOp>(loc, i8PtrTy, V, offsetConst);
+
+    // Cast back to original pointer type
+    V = builder.createBitcast(V, This.getType());
+  }
+
+  // Virtual adjustment (vcall offset lookup from vtable)
+  if (TI.This.Virtual.Itanium.VCallOffsetOffset) {
+    // TODO: Implement virtual adjustment - requires GetVTablePtr equivalent
+    llvm_unreachable(
+        "Virtual this adjustment NYI - requires vtable offset lookup");
+  }
+
+  return V;
+}
+
+mlir::Value CIRGenItaniumCXXABI::performReturnAdjustment(
+    CIRGenFunction &CGF, Address Ret, const CXXRecordDecl *UnadjustedClass,
+    const ReturnAdjustment &RA) {
+  // Handle trivial case: no adjustment needed
+  if (!RA.NonVirtual && !RA.Virtual.Itanium.VBaseOffsetOffset)
+    return Ret.getPointer();
+
+  auto &builder = CGF.getBuilder();
+  auto loc = builder.getUnknownLoc();
+  mlir::Value V = Ret.getPointer();
+
+  // For return adjustment, virtual adjustment is applied first,
+  // then non-virtual (opposite order from this adjustment)
+
+  // Virtual adjustment
+  if (RA.Virtual.Itanium.VBaseOffsetOffset) {
+    // TODO: Implement virtual return adjustment
+    llvm_unreachable(
+        "Virtual return adjustment NYI - requires vtable offset lookup");
+  }
+
+  // Apply non-virtual adjustment second (for derived-to-base cast)
+  if (RA.NonVirtual) {
+    // Cast to i8* for byte-level pointer arithmetic
+    auto i8PtrTy = builder.getUInt8PtrTy();
+    V = builder.createBitcast(V, i8PtrTy);
+
+    // Create offset constant
+    auto offsetConst = builder.getSInt64(RA.NonVirtual, loc);
+
+    // Perform pointer arithmetic
+    V = builder.create<cir::PtrStrideOp>(loc, i8PtrTy, V, offsetConst);
+
+    // Cast back to original pointer type
+    V = builder.createBitcast(V, Ret.getType());
+  }
+
+  return V;
+}
+
 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
@@ -2710,10 +2718,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 +2749,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;
 }
@@ -3058,7 +3074,6 @@ 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) {
     setCIRFunctionAttributes(globalDecl,