[clang] [CIR] Add initial Microsoft C++ ABI support in ClangIR (PR #221038)
via cfe-commits
cfe-commits at lists.llvm.org
Tue Sep 15 07:08:27 PDT 2026
https://github.com/R-Goc updated https://github.com/llvm/llvm-project/pull/221038
>From 30f36a487b73b0e0cd9505e2e682e1711e45def8 Mon Sep 17 00:00:00 2001
From: R-Goc <ryszardgoc at gmail.com>
Date: Thu, 3 Sep 2026 22:43:20 +0200
Subject: [PATCH 1/5] [CIR] Add initial Microsoft C++ ABI skeleton in ClangIR
Introduce the initial skeleton for the Microsoft C++ ABI in ClangIR
CodeGen and TargetLowering:
- Implement CIRGenMicrosoftCXXABI stub class in CodeGen deriving from
CIRGenCXXABI, with all virtual methods stubbed out with Not-Yet-Implemented
(NYI) diagnostics or conservative defaults.
- Implement LowerMicrosoftCXXABI stub class in TargetLowering deriving
from CIRCXXABI.
- Wire up TargetCXXABI::Microsoft dispatch in CIRGenModule and LowerModule.
- Add cxx-msvc-abi.cpp lit test verifying that compiling with triple
x86_64-pc-windows-msvc initializes the ABI without crashing.
Assisted-by: Gemini:gemini-3.8-flash-high
---
clang/lib/CIR/CodeGen/CIRGenCXXABI.h | 3 +
.../lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp | 285 ++++++++++++++++++
clang/lib/CIR/CodeGen/CIRGenModule.cpp | 3 +-
clang/lib/CIR/CodeGen/CMakeLists.txt | 1 +
.../Transforms/TargetLowering/CIRCXXABI.h | 3 +
.../Transforms/TargetLowering/CMakeLists.txt | 1 +
.../TargetLowering/LowerMicrosoftCXXABI.cpp | 158 ++++++++++
.../Transforms/TargetLowering/LowerModule.cpp | 2 +-
clang/test/CIR/CodeGen/cxx-msvc-abi.cpp | 6 +
9 files changed, 460 insertions(+), 2 deletions(-)
create mode 100644 clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
create mode 100644 clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerMicrosoftCXXABI.cpp
create mode 100644 clang/test/CIR/CodeGen/cxx-msvc-abi.cpp
diff --git a/clang/lib/CIR/CodeGen/CIRGenCXXABI.h b/clang/lib/CIR/CodeGen/CIRGenCXXABI.h
index bb100f7afd929..85cf647bf451c 100644
--- a/clang/lib/CIR/CodeGen/CIRGenCXXABI.h
+++ b/clang/lib/CIR/CodeGen/CIRGenCXXABI.h
@@ -391,6 +391,9 @@ class CIRGenCXXABI {
/// Creates and Itanium-family ABI
CIRGenCXXABI *CreateCIRGenItaniumCXXABI(CIRGenModule &cgm);
+/// Creates Microsoft ABI
+CIRGenCXXABI *CreateCIRGenMicrosoftCXXABI(CIRGenModule &cgm);
+
} // namespace clang::CIRGen
#endif
diff --git a/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp b/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
new file mode 100644
index 0000000000000..f30d9c4b984a9
--- /dev/null
+++ b/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
@@ -0,0 +1,285 @@
+//===--- CIRGenMicrosoftCXXABI.cpp - Emit CIR Code for MS C++ ABI --------===//
+//
+// 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 provides C++ code generation targeting the Microsoft C++ ABI.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CIRGenCXXABI.h"
+#include "CIRGenFunction.h"
+#include "CIRGenModule.h"
+
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/Mangle.h"
+
+using namespace clang;
+using namespace clang::CIRGen;
+
+namespace {
+
+class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
+public:
+ CIRGenMicrosoftCXXABI(CIRGenModule &cgm) : CIRGenCXXABI(cgm) {}
+
+ AddedStructorArgCounts
+ buildStructorSignature(GlobalDecl gd,
+ llvm::SmallVectorImpl<CanQualType> &argTys) override {
+ return AddedStructorArgCounts{};
+ }
+
+ void addImplicitStructorParams(CIRGenFunction &cgf, QualType &resTy,
+ FunctionArgList ¶ms) override {}
+
+ void emitInstanceFunctionProlog(SourceLocation loc,
+ CIRGenFunction &cgf) override {}
+
+ AddedStructorArgs getImplicitConstructorArgs(CIRGenFunction &cgf,
+ const CXXConstructorDecl *d,
+ CXXCtorType type,
+ bool forVirtualBase,
+ bool delegating) override {
+ return AddedStructorArgs{};
+ }
+
+ mlir::Value getCXXDestructorImplicitParam(CIRGenFunction &cgf,
+ const CXXDestructorDecl *dd,
+ CXXDtorType type,
+ bool forVirtualBase,
+ bool delegating) override {
+ return nullptr;
+ }
+
+ void emitCXXConstructors(const CXXConstructorDecl *d) override {
+ cgm.errorNYI(d->getSourceRange(), "emitCXXConstructors: MSVC ABI");
+ }
+
+ void emitCXXDestructors(const CXXDestructorDecl *d) override {
+ cgm.errorNYI(d->getSourceRange(), "emitCXXDestructors: MSVC ABI");
+ }
+
+ void emitCXXStructor(GlobalDecl gd) override {
+ cgm.errorNYI(gd.getDecl()->getSourceRange(), "emitCXXStructor: MSVC ABI");
+ }
+
+ void emitDestructorCall(CIRGenFunction &cgf, const CXXDestructorDecl *dd,
+ CXXDtorType type, bool forVirtualBase,
+ bool delegating, Address thisAddr,
+ QualType thisTy) override {
+ cgf.cgm.errorNYI(dd->getSourceRange(), "emitDestructorCall: MSVC ABI");
+ }
+
+ mlir::Value emitVirtualDestructorCall(CIRGenFunction &cgf,
+ const CXXDestructorDecl *dtor,
+ CXXDtorType dtorType, Address thisAddr,
+ DeleteOrMemberCallExpr e) override {
+ cgf.cgm.errorNYI(dtor->getSourceRange(),
+ "emitVirtualDestructorCall: MSVC ABI");
+ return nullptr;
+ }
+
+ void emitVirtualObjectDelete(CIRGenFunction &cgf, const CXXDeleteExpr *de,
+ Address ptr, QualType elementType,
+ const CXXDestructorDecl *dtor) override {
+ cgf.cgm.errorNYI(de->getSourceRange(), "emitVirtualObjectDelete: MSVC ABI");
+ }
+
+ const CXXRecordDecl *
+ getThisArgumentTypeForMethod(const CXXMethodDecl *md) override {
+ return md->getParent();
+ }
+
+ Address adjustThisArgumentForVirtualFunctionCall(CIRGenFunction &cgf,
+ GlobalDecl gd,
+ Address thisAddr,
+ bool virtualCall) override {
+ return thisAddr;
+ }
+
+ bool isVirtualOffsetNeededForVTableField(CIRGenFunction &cgf,
+ CIRGenFunction::VPtr vptr) override {
+ return false;
+ }
+
+ cir::GlobalOp getAddrOfVTable(const CXXRecordDecl *rd,
+ CharUnits vptrOffset) override {
+ cgm.errorNYI(rd->getSourceRange(), "getAddrOfVTable: MSVC ABI");
+ return nullptr;
+ }
+
+ mlir::Value getVTableAddressPoint(BaseSubobject base,
+ const CXXRecordDecl *vtableClass) override {
+ cgm.errorNYI(vtableClass->getSourceRange(),
+ "getVTableAddressPoint: MSVC ABI");
+ return nullptr;
+ }
+
+ mlir::Value getVTableAddressPointInStructor(
+ CIRGenFunction &cgf, const CXXRecordDecl *vtableClass, BaseSubobject base,
+ const CXXRecordDecl *nearestVBase) override {
+ cgf.cgm.errorNYI(vtableClass->getSourceRange(),
+ "getVTableAddressPointInStructor: MSVC ABI");
+ return nullptr;
+ }
+
+ CIRGenCallee getVirtualFunctionPointer(CIRGenFunction &cgf, GlobalDecl gd,
+ Address thisAddr, mlir::Type ty,
+ SourceLocation loc) override {
+ cgf.cgm.errorNYI(loc, "getVirtualFunctionPointer: MSVC ABI");
+ return CIRGenCallee();
+ }
+
+ void emitVTableDefinitions(CIRGenVTables &cgvt,
+ const CXXRecordDecl *rd) override {
+ cgm.errorNYI(rd->getSourceRange(), "emitVTableDefinitions: MSVC ABI");
+ }
+
+ void emitVirtualInheritanceTables(const CXXRecordDecl *rd) override {
+ if (rd->getNumVBases())
+ cgm.errorNYI(rd->getSourceRange(),
+ "emitVirtualInheritanceTables: MSVC VBTables");
+ }
+
+ void
+ initializeHiddenVirtualInheritanceMembers(CIRGenFunction &cgf,
+ const CXXRecordDecl *rd) override {
+ if (rd->getNumVBases())
+ cgf.cgm.errorNYI(rd->getSourceRange(),
+ "initializeHiddenVirtualInheritanceMembers: vbptr stores");
+ }
+
+ mlir::Value
+ getVirtualBaseClassOffset(mlir::Location loc, CIRGenFunction &cgf,
+ Address thisAddr, const CXXRecordDecl *classDecl,
+ const CXXRecordDecl *baseClassDecl) override {
+ cgf.cgm.errorNYI(loc, "getVirtualBaseClassOffset: MSVC ABI");
+ return nullptr;
+ }
+
+ cir::MethodAttr buildVirtualMethodAttr(cir::MethodType methodTy,
+ const CXXMethodDecl *md) override {
+ cgm.errorNYI(md->getSourceRange(), "buildVirtualMethodAttr: MSVC ABI");
+ return cir::MethodAttr();
+ }
+
+ mlir::Value performThisAdjustment(CIRGenFunction &cgf, Address thisAddr,
+ const CXXRecordDecl *unadjustedClass,
+ const ThunkInfo &ti) override {
+ return thisAddr.emitRawPointer();
+ }
+
+ mlir::Value performReturnAdjustment(CIRGenFunction &cgf, Address ret,
+ const CXXRecordDecl *unadjustedClass,
+ const ReturnAdjustment &ra) override {
+ return ret.emitRawPointer();
+ }
+
+ bool canSpeculativelyEmitVTable(const CXXRecordDecl *rd) const override {
+ return false;
+ }
+
+ bool doStructorsInitializeVPtrs(const CXXRecordDecl *vtableClass) override {
+ return false;
+ }
+
+ bool exportThunk() override { return false; }
+
+ bool useThunkForDtorVariant(const CXXDestructorDecl *dtor,
+ CXXDtorType dt) const override {
+ return false;
+ }
+
+ void setThunkLinkage(cir::FuncOp thunk, bool forVTable, GlobalDecl gd,
+ bool returnAdjustment) override {
+ thunk.setLinkage(cir::GlobalLinkageKind::LinkOnceODRLinkage);
+ }
+
+ llvm::StringRef getPureVirtualCallName() override { return "_purecall"; }
+ llvm::StringRef getDeletedVirtualCallName() override { return "_purecall"; }
+
+ bool isZeroInitializable(const MemberPointerType *mpt) override {
+ return true;
+ }
+
+ bool requiresArrayCookie(const CXXNewExpr *e) override {
+ return false;
+ }
+
+ CharUnits getArrayCookieSizeImpl(QualType elementType) override {
+ return CharUnits::Zero();
+ }
+
+ Address initializeArrayCookie(CIRGenFunction &cgf, Address newPtr,
+ mlir::Value numElements, const CXXNewExpr *e,
+ QualType elementType) override {
+ cgf.cgm.errorNYI(e->getSourceRange(), "initializeArrayCookie: MSVC ABI");
+ return newPtr;
+ }
+
+ bool shouldTypeidBeNullChecked(QualType srcTy) override {
+ return false;
+ }
+
+ mlir::Value emitTypeid(CIRGenFunction &cgf, QualType srcTy, Address thisPtr,
+ mlir::Type typeInfoPtrTy) override {
+ cgf.cgm.errorNYI(cgf.getLoc(srcTy->getAsCXXRecordDecl()->getLocation()),
+ "emitTypeid: MSVC ABI");
+ return cgf.getBuilder().getNullPtr(
+ typeInfoPtrTy, cgf.getLoc(srcTy->getAsCXXRecordDecl()->getLocation()));
+ }
+
+ void emitBadTypeidCall(CIRGenFunction &cgf, mlir::Location loc) override {
+ cgf.cgm.errorNYI(loc, "emitBadTypeidCall: MSVC ABI");
+ }
+
+ void emitBadCastCall(CIRGenFunction &cgf, mlir::Location loc) override {
+ cgm.errorNYI(loc, "emitBadCastCall: MSVC ABI");
+ }
+
+ mlir::Value emitDynamicCast(CIRGenFunction &cgf, mlir::Location loc,
+ QualType srcRecordTy, QualType destRecordTy,
+ cir::PointerType destCIRTy, bool isRefCast,
+ Address src) override {
+ cgf.cgm.errorNYI(loc, "emitDynamicCast: MSVC ABI");
+ return cgf.getBuilder().getNullPtr(destCIRTy, loc);
+ }
+
+ mlir::Attribute getAddrOfRTTIDescriptor(mlir::Location loc,
+ QualType ty) override {
+ cgm.errorNYI(loc, "getAddrOfRTTIDescriptor: MSVC ABI");
+ return nullptr;
+ }
+
+ CatchTypeInfo getCatchAllTypeInfo() override {
+ return CatchTypeInfo{nullptr, 0};
+ }
+
+ CatchTypeInfo
+ getAddrOfCXXCatchHandlerType(mlir::Location loc, QualType ty,
+ QualType catchHandlerType) override {
+ cgm.errorNYI(loc, "getAddrOfCXXCatchHandlerType: MSVC ABI");
+ return CatchTypeInfo{nullptr, 0};
+ }
+
+ void emitRethrow(CIRGenFunction &cgf, bool isNoReturn) override {
+ cgm.errorNYI("emitRethrow: MSVC ABI");
+ }
+
+ void emitThrow(CIRGenFunction &cgf, const CXXThrowExpr *e) override {
+ cgf.cgm.errorNYI(e->getSourceRange(), "emitThrow: MSVC ABI");
+ }
+
+ void registerGlobalDtor(const VarDecl *vd, cir::FuncOp dtor,
+ mlir::Value addr) override {}
+};
+
+} // namespace
+
+CIRGenCXXABI *clang::CIRGen::CreateCIRGenMicrosoftCXXABI(CIRGenModule &cgm) {
+ return new CIRGenMicrosoftCXXABI(cgm);
+}
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
index bdc2707723283..301257ca0d777 100644
--- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -65,6 +65,8 @@ static CIRGenCXXABI *createCXXABI(CIRGenModule &cgm) {
case TargetCXXABI::AppleARM64:
case TargetCXXABI::GenericARM:
return CreateCIRGenItaniumCXXABI(cgm);
+ case TargetCXXABI::Microsoft:
+ return CreateCIRGenMicrosoftCXXABI(cgm);
case TargetCXXABI::Fuchsia:
case TargetCXXABI::iOS:
@@ -72,7 +74,6 @@ static CIRGenCXXABI *createCXXABI(CIRGenModule &cgm) {
case TargetCXXABI::GenericMIPS:
case TargetCXXABI::WebAssembly:
case TargetCXXABI::XL:
- case TargetCXXABI::Microsoft:
cgm.errorNYI("createCXXABI: C++ ABI kind");
return nullptr;
}
diff --git a/clang/lib/CIR/CodeGen/CMakeLists.txt b/clang/lib/CIR/CodeGen/CMakeLists.txt
index c4bd520fc61b7..1b5c0b91b394e 100644
--- a/clang/lib/CIR/CodeGen/CMakeLists.txt
+++ b/clang/lib/CIR/CodeGen/CMakeLists.txt
@@ -39,6 +39,7 @@ add_clang_library(clangCIR
CIRGenExprScalar.cpp
CIRGenFunction.cpp
CIRGenItaniumCXXABI.cpp
+ CIRGenMicrosoftCXXABI.cpp
CIRGenModule.cpp
CIRGenOpenACC.cpp
CIRGenOpenACCClause.cpp
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRCXXABI.h b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRCXXABI.h
index 5c5d6421aea71..1f65c871d8315 100644
--- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRCXXABI.h
+++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRCXXABI.h
@@ -172,6 +172,9 @@ class CIRCXXABI {
/// Creates an Itanium-family ABI.
std::unique_ptr<CIRCXXABI> createItaniumCXXABI(LowerModule &lm);
+/// Creates a Microsoft-family ABI.
+std::unique_ptr<CIRCXXABI> createMicrosoftCXXABI(LowerModule &lm);
+
} // namespace cir
#endif // CLANG_LIB_CIR_DIALECT_TRANSFORMS_TARGETLOWERING_CIRCXXABI_H
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CMakeLists.txt b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CMakeLists.txt
index 81cc336699391..8a92bee9a6187 100644
--- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CMakeLists.txt
+++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CMakeLists.txt
@@ -3,6 +3,7 @@ add_clang_library(MLIRCIRTargetLowering
CIRCXXABI.cpp
LowerModule.cpp
LowerItaniumCXXABI.cpp
+ LowerMicrosoftCXXABI.cpp
TargetLoweringInfo.cpp
Targets/AMDGPU.cpp
Targets/NVPTX.cpp
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerMicrosoftCXXABI.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerMicrosoftCXXABI.cpp
new file mode 100644
index 0000000000000..f670981453bed
--- /dev/null
+++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerMicrosoftCXXABI.cpp
@@ -0,0 +1,158 @@
+//===---- LowerMicrosoftCXXABI.cpp - Emit CIR for Microsoft-specific code -===//
+//
+// 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 provides CIR lowering logic targeting the Microsoft C++ ABI.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CIRCXXABI.h"
+#include "LowerModule.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace cir {
+
+namespace {
+
+class LowerMicrosoftCXXABI : public CIRCXXABI {
+public:
+ LowerMicrosoftCXXABI(LowerModule &lm) : CIRCXXABI(lm) {}
+
+ mlir::Type
+ lowerDataMemberType(cir::DataMemberType type,
+ const mlir::TypeConverter &typeConverter) const override {
+ llvm_unreachable("Microsoft ABI member pointer lowering NYI");
+ }
+
+ mlir::Type
+ lowerMethodType(cir::MethodType type,
+ const mlir::TypeConverter &typeConverter) const override {
+ llvm_unreachable("Microsoft ABI method pointer lowering NYI");
+ }
+
+ mlir::TypedAttr lowerDataMemberConstant(
+ cir::DataMemberAttr attr, const mlir::DataLayout &layout,
+ const mlir::TypeConverter &typeConverter) const override {
+ llvm_unreachable("Microsoft ABI member pointer lowering NYI");
+ }
+
+ mlir::TypedAttr lowerDataMemberOffsetConstant(
+ cir::DataMemberOffsetAttr attr, const mlir::DataLayout &layout,
+ const mlir::TypeConverter &typeConverter) const override {
+ llvm_unreachable("Microsoft ABI member pointer lowering NYI");
+ }
+
+ mlir::TypedAttr
+ lowerMethodConstant(cir::MethodAttr attr, const mlir::DataLayout &layout,
+ const mlir::TypeConverter &typeConverter) const override {
+ llvm_unreachable("Microsoft ABI method pointer lowering NYI");
+ }
+
+ mlir::Operation *
+ lowerGetRuntimeMember(cir::GetRuntimeMemberOp op, mlir::Type loweredResultTy,
+ mlir::Value loweredAddr, mlir::Value loweredMember,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI member pointer lowering NYI");
+ }
+
+ void
+ lowerGetMethod(cir::GetMethodOp op, mlir::Value &callee, mlir::Value &thisArg,
+ mlir::Value loweredMethod, mlir::Value loweredObjectPtr,
+ mlir::ConversionPatternRewriter &rewriter) const override {
+ llvm_unreachable("Microsoft ABI method pointer lowering NYI");
+ }
+
+ mlir::Value lowerBaseDataMember(cir::BaseDataMemberOp op,
+ mlir::Value loweredSrc,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI member pointer lowering NYI");
+ }
+
+ mlir::Value lowerDerivedDataMember(cir::DerivedDataMemberOp op,
+ mlir::Value loweredSrc,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI member pointer lowering NYI");
+ }
+
+ mlir::Value lowerBaseMethod(cir::BaseMethodOp op, mlir::Value loweredSrc,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI method pointer lowering NYI");
+ }
+
+ mlir::Value lowerDerivedMethod(cir::DerivedMethodOp op,
+ mlir::Value loweredSrc,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI method pointer lowering NYI");
+ }
+
+ mlir::Value lowerDataMemberCmp(cir::CmpOp op, mlir::Value loweredLhs,
+ mlir::Value loweredRhs,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI member pointer lowering NYI");
+ }
+
+ mlir::Value lowerMethodCmp(cir::CmpOp op, mlir::Value loweredLhs,
+ mlir::Value loweredRhs,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI method pointer lowering NYI");
+ }
+
+ mlir::Value lowerDataMemberBitcast(cir::CastOp op, mlir::Type loweredDstTy,
+ mlir::Value loweredSrc,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI member pointer lowering NYI");
+ }
+
+ mlir::Value
+ lowerDataMemberToBoolCast(cir::CastOp op, mlir::Value loweredSrc,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI member pointer lowering NYI");
+ }
+
+ mlir::Value lowerMethodBitcast(cir::CastOp op, mlir::Type loweredDstTy,
+ mlir::Value loweredSrc,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI method pointer lowering NYI");
+ }
+
+ mlir::Value lowerMethodToBoolCast(cir::CastOp op, mlir::Value loweredSrc,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI method pointer lowering NYI");
+ }
+
+ mlir::Value lowerDynamicCast(cir::DynamicCastOp op,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI dynamic cast lowering NYI");
+ }
+
+ mlir::Value lowerVTableGetTypeInfo(cir::VTableGetTypeInfoOp op,
+ mlir::OpBuilder &builder) const override {
+ llvm_unreachable("Microsoft ABI vtable get type info lowering NYI");
+ }
+
+ clang::CharUnits
+ getArrayCookieSizeImpl(mlir::Type elementType,
+ const mlir::DataLayout &dataLayout) const override {
+ llvm_unreachable("Microsoft ABI array cookie lowering NYI");
+ }
+
+ mlir::Value readArrayCookieImpl(mlir::Location loc, mlir::Value allocPtr,
+ clang::CharUnits cookieSize,
+ clang::CharUnits cookieAlignment,
+ const mlir::DataLayout &dataLayout,
+ CIRBaseBuilderTy &builder) const override {
+ llvm_unreachable("Microsoft ABI array cookie lowering NYI");
+ }
+};
+
+} // namespace
+
+std::unique_ptr<CIRCXXABI> createMicrosoftCXXABI(LowerModule &lm) {
+ return std::make_unique<LowerMicrosoftCXXABI>(lm);
+}
+
+} // namespace cir
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerModule.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerModule.cpp
index 5fd5c8c429f48..8ed0fb5b2cd26 100644
--- a/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerModule.cpp
+++ b/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerModule.cpp
@@ -37,7 +37,7 @@ static std::unique_ptr<CIRCXXABI> createCXXABI(LowerModule &lm) {
case clang::TargetCXXABI::XL:
return createItaniumCXXABI(lm);
case clang::TargetCXXABI::Microsoft:
- llvm_unreachable("Windows ABI NYI");
+ return createMicrosoftCXXABI(lm);
}
llvm_unreachable("invalid C++ ABI kind");
diff --git a/clang/test/CIR/CodeGen/cxx-msvc-abi.cpp b/clang/test/CIR/CodeGen/cxx-msvc-abi.cpp
new file mode 100644
index 0000000000000..e1a4d7519f5d4
--- /dev/null
+++ b/clang/test/CIR/CodeGen/cxx-msvc-abi.cpp
@@ -0,0 +1,6 @@
+// RUN: %clang_cc1 -triple x86_64-pc-windows-msvc -std=c++17 -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --check-prefix=CIR --input-file=%t.cir %s
+
+void empty() {}
+
+// CIR: cir.func {{.*}} @"?empty@@YAXXZ"()
>From f65bf5cba2e704a55614427aaac2742ae8793b99 Mon Sep 17 00:00:00 2001
From: R-Goc <ryszardgoc at gmail.com>
Date: Thu, 3 Sep 2026 22:46:49 +0200
Subject: [PATCH 2/5] run clang-format
---
.../lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp | 567 +++++++++---------
1 file changed, 282 insertions(+), 285 deletions(-)
diff --git a/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp b/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
index f30d9c4b984a9..9e5faa5b5e54d 100644
--- a/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
@@ -1,285 +1,282 @@
-//===--- CIRGenMicrosoftCXXABI.cpp - Emit CIR Code for MS C++ ABI --------===//
-//
-// 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 provides C++ code generation targeting the Microsoft C++ ABI.
-//
-//===----------------------------------------------------------------------===//
-
-#include "CIRGenCXXABI.h"
-#include "CIRGenFunction.h"
-#include "CIRGenModule.h"
-
-#include "clang/AST/Decl.h"
-#include "clang/AST/DeclCXX.h"
-#include "clang/AST/Mangle.h"
-
-using namespace clang;
-using namespace clang::CIRGen;
-
-namespace {
-
-class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
-public:
- CIRGenMicrosoftCXXABI(CIRGenModule &cgm) : CIRGenCXXABI(cgm) {}
-
- AddedStructorArgCounts
- buildStructorSignature(GlobalDecl gd,
- llvm::SmallVectorImpl<CanQualType> &argTys) override {
- return AddedStructorArgCounts{};
- }
-
- void addImplicitStructorParams(CIRGenFunction &cgf, QualType &resTy,
- FunctionArgList ¶ms) override {}
-
- void emitInstanceFunctionProlog(SourceLocation loc,
- CIRGenFunction &cgf) override {}
-
- AddedStructorArgs getImplicitConstructorArgs(CIRGenFunction &cgf,
- const CXXConstructorDecl *d,
- CXXCtorType type,
- bool forVirtualBase,
- bool delegating) override {
- return AddedStructorArgs{};
- }
-
- mlir::Value getCXXDestructorImplicitParam(CIRGenFunction &cgf,
- const CXXDestructorDecl *dd,
- CXXDtorType type,
- bool forVirtualBase,
- bool delegating) override {
- return nullptr;
- }
-
- void emitCXXConstructors(const CXXConstructorDecl *d) override {
- cgm.errorNYI(d->getSourceRange(), "emitCXXConstructors: MSVC ABI");
- }
-
- void emitCXXDestructors(const CXXDestructorDecl *d) override {
- cgm.errorNYI(d->getSourceRange(), "emitCXXDestructors: MSVC ABI");
- }
-
- void emitCXXStructor(GlobalDecl gd) override {
- cgm.errorNYI(gd.getDecl()->getSourceRange(), "emitCXXStructor: MSVC ABI");
- }
-
- void emitDestructorCall(CIRGenFunction &cgf, const CXXDestructorDecl *dd,
- CXXDtorType type, bool forVirtualBase,
- bool delegating, Address thisAddr,
- QualType thisTy) override {
- cgf.cgm.errorNYI(dd->getSourceRange(), "emitDestructorCall: MSVC ABI");
- }
-
- mlir::Value emitVirtualDestructorCall(CIRGenFunction &cgf,
- const CXXDestructorDecl *dtor,
- CXXDtorType dtorType, Address thisAddr,
- DeleteOrMemberCallExpr e) override {
- cgf.cgm.errorNYI(dtor->getSourceRange(),
- "emitVirtualDestructorCall: MSVC ABI");
- return nullptr;
- }
-
- void emitVirtualObjectDelete(CIRGenFunction &cgf, const CXXDeleteExpr *de,
- Address ptr, QualType elementType,
- const CXXDestructorDecl *dtor) override {
- cgf.cgm.errorNYI(de->getSourceRange(), "emitVirtualObjectDelete: MSVC ABI");
- }
-
- const CXXRecordDecl *
- getThisArgumentTypeForMethod(const CXXMethodDecl *md) override {
- return md->getParent();
- }
-
- Address adjustThisArgumentForVirtualFunctionCall(CIRGenFunction &cgf,
- GlobalDecl gd,
- Address thisAddr,
- bool virtualCall) override {
- return thisAddr;
- }
-
- bool isVirtualOffsetNeededForVTableField(CIRGenFunction &cgf,
- CIRGenFunction::VPtr vptr) override {
- return false;
- }
-
- cir::GlobalOp getAddrOfVTable(const CXXRecordDecl *rd,
- CharUnits vptrOffset) override {
- cgm.errorNYI(rd->getSourceRange(), "getAddrOfVTable: MSVC ABI");
- return nullptr;
- }
-
- mlir::Value getVTableAddressPoint(BaseSubobject base,
- const CXXRecordDecl *vtableClass) override {
- cgm.errorNYI(vtableClass->getSourceRange(),
- "getVTableAddressPoint: MSVC ABI");
- return nullptr;
- }
-
- mlir::Value getVTableAddressPointInStructor(
- CIRGenFunction &cgf, const CXXRecordDecl *vtableClass, BaseSubobject base,
- const CXXRecordDecl *nearestVBase) override {
- cgf.cgm.errorNYI(vtableClass->getSourceRange(),
- "getVTableAddressPointInStructor: MSVC ABI");
- return nullptr;
- }
-
- CIRGenCallee getVirtualFunctionPointer(CIRGenFunction &cgf, GlobalDecl gd,
- Address thisAddr, mlir::Type ty,
- SourceLocation loc) override {
- cgf.cgm.errorNYI(loc, "getVirtualFunctionPointer: MSVC ABI");
- return CIRGenCallee();
- }
-
- void emitVTableDefinitions(CIRGenVTables &cgvt,
- const CXXRecordDecl *rd) override {
- cgm.errorNYI(rd->getSourceRange(), "emitVTableDefinitions: MSVC ABI");
- }
-
- void emitVirtualInheritanceTables(const CXXRecordDecl *rd) override {
- if (rd->getNumVBases())
- cgm.errorNYI(rd->getSourceRange(),
- "emitVirtualInheritanceTables: MSVC VBTables");
- }
-
- void
- initializeHiddenVirtualInheritanceMembers(CIRGenFunction &cgf,
- const CXXRecordDecl *rd) override {
- if (rd->getNumVBases())
- cgf.cgm.errorNYI(rd->getSourceRange(),
- "initializeHiddenVirtualInheritanceMembers: vbptr stores");
- }
-
- mlir::Value
- getVirtualBaseClassOffset(mlir::Location loc, CIRGenFunction &cgf,
- Address thisAddr, const CXXRecordDecl *classDecl,
- const CXXRecordDecl *baseClassDecl) override {
- cgf.cgm.errorNYI(loc, "getVirtualBaseClassOffset: MSVC ABI");
- return nullptr;
- }
-
- cir::MethodAttr buildVirtualMethodAttr(cir::MethodType methodTy,
- const CXXMethodDecl *md) override {
- cgm.errorNYI(md->getSourceRange(), "buildVirtualMethodAttr: MSVC ABI");
- return cir::MethodAttr();
- }
-
- mlir::Value performThisAdjustment(CIRGenFunction &cgf, Address thisAddr,
- const CXXRecordDecl *unadjustedClass,
- const ThunkInfo &ti) override {
- return thisAddr.emitRawPointer();
- }
-
- mlir::Value performReturnAdjustment(CIRGenFunction &cgf, Address ret,
- const CXXRecordDecl *unadjustedClass,
- const ReturnAdjustment &ra) override {
- return ret.emitRawPointer();
- }
-
- bool canSpeculativelyEmitVTable(const CXXRecordDecl *rd) const override {
- return false;
- }
-
- bool doStructorsInitializeVPtrs(const CXXRecordDecl *vtableClass) override {
- return false;
- }
-
- bool exportThunk() override { return false; }
-
- bool useThunkForDtorVariant(const CXXDestructorDecl *dtor,
- CXXDtorType dt) const override {
- return false;
- }
-
- void setThunkLinkage(cir::FuncOp thunk, bool forVTable, GlobalDecl gd,
- bool returnAdjustment) override {
- thunk.setLinkage(cir::GlobalLinkageKind::LinkOnceODRLinkage);
- }
-
- llvm::StringRef getPureVirtualCallName() override { return "_purecall"; }
- llvm::StringRef getDeletedVirtualCallName() override { return "_purecall"; }
-
- bool isZeroInitializable(const MemberPointerType *mpt) override {
- return true;
- }
-
- bool requiresArrayCookie(const CXXNewExpr *e) override {
- return false;
- }
-
- CharUnits getArrayCookieSizeImpl(QualType elementType) override {
- return CharUnits::Zero();
- }
-
- Address initializeArrayCookie(CIRGenFunction &cgf, Address newPtr,
- mlir::Value numElements, const CXXNewExpr *e,
- QualType elementType) override {
- cgf.cgm.errorNYI(e->getSourceRange(), "initializeArrayCookie: MSVC ABI");
- return newPtr;
- }
-
- bool shouldTypeidBeNullChecked(QualType srcTy) override {
- return false;
- }
-
- mlir::Value emitTypeid(CIRGenFunction &cgf, QualType srcTy, Address thisPtr,
- mlir::Type typeInfoPtrTy) override {
- cgf.cgm.errorNYI(cgf.getLoc(srcTy->getAsCXXRecordDecl()->getLocation()),
- "emitTypeid: MSVC ABI");
- return cgf.getBuilder().getNullPtr(
- typeInfoPtrTy, cgf.getLoc(srcTy->getAsCXXRecordDecl()->getLocation()));
- }
-
- void emitBadTypeidCall(CIRGenFunction &cgf, mlir::Location loc) override {
- cgf.cgm.errorNYI(loc, "emitBadTypeidCall: MSVC ABI");
- }
-
- void emitBadCastCall(CIRGenFunction &cgf, mlir::Location loc) override {
- cgm.errorNYI(loc, "emitBadCastCall: MSVC ABI");
- }
-
- mlir::Value emitDynamicCast(CIRGenFunction &cgf, mlir::Location loc,
- QualType srcRecordTy, QualType destRecordTy,
- cir::PointerType destCIRTy, bool isRefCast,
- Address src) override {
- cgf.cgm.errorNYI(loc, "emitDynamicCast: MSVC ABI");
- return cgf.getBuilder().getNullPtr(destCIRTy, loc);
- }
-
- mlir::Attribute getAddrOfRTTIDescriptor(mlir::Location loc,
- QualType ty) override {
- cgm.errorNYI(loc, "getAddrOfRTTIDescriptor: MSVC ABI");
- return nullptr;
- }
-
- CatchTypeInfo getCatchAllTypeInfo() override {
- return CatchTypeInfo{nullptr, 0};
- }
-
- CatchTypeInfo
- getAddrOfCXXCatchHandlerType(mlir::Location loc, QualType ty,
- QualType catchHandlerType) override {
- cgm.errorNYI(loc, "getAddrOfCXXCatchHandlerType: MSVC ABI");
- return CatchTypeInfo{nullptr, 0};
- }
-
- void emitRethrow(CIRGenFunction &cgf, bool isNoReturn) override {
- cgm.errorNYI("emitRethrow: MSVC ABI");
- }
-
- void emitThrow(CIRGenFunction &cgf, const CXXThrowExpr *e) override {
- cgf.cgm.errorNYI(e->getSourceRange(), "emitThrow: MSVC ABI");
- }
-
- void registerGlobalDtor(const VarDecl *vd, cir::FuncOp dtor,
- mlir::Value addr) override {}
-};
-
-} // namespace
-
-CIRGenCXXABI *clang::CIRGen::CreateCIRGenMicrosoftCXXABI(CIRGenModule &cgm) {
- return new CIRGenMicrosoftCXXABI(cgm);
-}
+//===--- CIRGenMicrosoftCXXABI.cpp - Emit CIR Code for MS C++ ABI --------===//
+//
+// 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 provides C++ code generation targeting the Microsoft C++ ABI.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CIRGenCXXABI.h"
+#include "CIRGenFunction.h"
+#include "CIRGenModule.h"
+
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/Mangle.h"
+
+using namespace clang;
+using namespace clang::CIRGen;
+
+namespace {
+
+class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
+public:
+ CIRGenMicrosoftCXXABI(CIRGenModule &cgm) : CIRGenCXXABI(cgm) {}
+
+ AddedStructorArgCounts
+ buildStructorSignature(GlobalDecl gd,
+ llvm::SmallVectorImpl<CanQualType> &argTys) override {
+ return AddedStructorArgCounts{};
+ }
+
+ void addImplicitStructorParams(CIRGenFunction &cgf, QualType &resTy,
+ FunctionArgList ¶ms) override {}
+
+ void emitInstanceFunctionProlog(SourceLocation loc,
+ CIRGenFunction &cgf) override {}
+
+ AddedStructorArgs getImplicitConstructorArgs(CIRGenFunction &cgf,
+ const CXXConstructorDecl *d,
+ CXXCtorType type,
+ bool forVirtualBase,
+ bool delegating) override {
+ return AddedStructorArgs{};
+ }
+
+ mlir::Value getCXXDestructorImplicitParam(CIRGenFunction &cgf,
+ const CXXDestructorDecl *dd,
+ CXXDtorType type,
+ bool forVirtualBase,
+ bool delegating) override {
+ return nullptr;
+ }
+
+ void emitCXXConstructors(const CXXConstructorDecl *d) override {
+ cgm.errorNYI(d->getSourceRange(), "emitCXXConstructors: MSVC ABI");
+ }
+
+ void emitCXXDestructors(const CXXDestructorDecl *d) override {
+ cgm.errorNYI(d->getSourceRange(), "emitCXXDestructors: MSVC ABI");
+ }
+
+ void emitCXXStructor(GlobalDecl gd) override {
+ cgm.errorNYI(gd.getDecl()->getSourceRange(), "emitCXXStructor: MSVC ABI");
+ }
+
+ void emitDestructorCall(CIRGenFunction &cgf, const CXXDestructorDecl *dd,
+ CXXDtorType type, bool forVirtualBase,
+ bool delegating, Address thisAddr,
+ QualType thisTy) override {
+ cgf.cgm.errorNYI(dd->getSourceRange(), "emitDestructorCall: MSVC ABI");
+ }
+
+ mlir::Value emitVirtualDestructorCall(CIRGenFunction &cgf,
+ const CXXDestructorDecl *dtor,
+ CXXDtorType dtorType, Address thisAddr,
+ DeleteOrMemberCallExpr e) override {
+ cgf.cgm.errorNYI(dtor->getSourceRange(),
+ "emitVirtualDestructorCall: MSVC ABI");
+ return nullptr;
+ }
+
+ void emitVirtualObjectDelete(CIRGenFunction &cgf, const CXXDeleteExpr *de,
+ Address ptr, QualType elementType,
+ const CXXDestructorDecl *dtor) override {
+ cgf.cgm.errorNYI(de->getSourceRange(), "emitVirtualObjectDelete: MSVC ABI");
+ }
+
+ const CXXRecordDecl *
+ getThisArgumentTypeForMethod(const CXXMethodDecl *md) override {
+ return md->getParent();
+ }
+
+ Address adjustThisArgumentForVirtualFunctionCall(CIRGenFunction &cgf,
+ GlobalDecl gd,
+ Address thisAddr,
+ bool virtualCall) override {
+ return thisAddr;
+ }
+
+ bool isVirtualOffsetNeededForVTableField(CIRGenFunction &cgf,
+ CIRGenFunction::VPtr vptr) override {
+ return false;
+ }
+
+ cir::GlobalOp getAddrOfVTable(const CXXRecordDecl *rd,
+ CharUnits vptrOffset) override {
+ cgm.errorNYI(rd->getSourceRange(), "getAddrOfVTable: MSVC ABI");
+ return nullptr;
+ }
+
+ mlir::Value getVTableAddressPoint(BaseSubobject base,
+ const CXXRecordDecl *vtableClass) override {
+ cgm.errorNYI(vtableClass->getSourceRange(),
+ "getVTableAddressPoint: MSVC ABI");
+ return nullptr;
+ }
+
+ mlir::Value getVTableAddressPointInStructor(
+ CIRGenFunction &cgf, const CXXRecordDecl *vtableClass, BaseSubobject base,
+ const CXXRecordDecl *nearestVBase) override {
+ cgf.cgm.errorNYI(vtableClass->getSourceRange(),
+ "getVTableAddressPointInStructor: MSVC ABI");
+ return nullptr;
+ }
+
+ CIRGenCallee getVirtualFunctionPointer(CIRGenFunction &cgf, GlobalDecl gd,
+ Address thisAddr, mlir::Type ty,
+ SourceLocation loc) override {
+ cgf.cgm.errorNYI(loc, "getVirtualFunctionPointer: MSVC ABI");
+ return CIRGenCallee();
+ }
+
+ void emitVTableDefinitions(CIRGenVTables &cgvt,
+ const CXXRecordDecl *rd) override {
+ cgm.errorNYI(rd->getSourceRange(), "emitVTableDefinitions: MSVC ABI");
+ }
+
+ void emitVirtualInheritanceTables(const CXXRecordDecl *rd) override {
+ if (rd->getNumVBases())
+ cgm.errorNYI(rd->getSourceRange(),
+ "emitVirtualInheritanceTables: MSVC VBTables");
+ }
+
+ void
+ initializeHiddenVirtualInheritanceMembers(CIRGenFunction &cgf,
+ const CXXRecordDecl *rd) override {
+ if (rd->getNumVBases())
+ cgf.cgm.errorNYI(
+ rd->getSourceRange(),
+ "initializeHiddenVirtualInheritanceMembers: vbptr stores");
+ }
+
+ mlir::Value
+ getVirtualBaseClassOffset(mlir::Location loc, CIRGenFunction &cgf,
+ Address thisAddr, const CXXRecordDecl *classDecl,
+ const CXXRecordDecl *baseClassDecl) override {
+ cgf.cgm.errorNYI(loc, "getVirtualBaseClassOffset: MSVC ABI");
+ return nullptr;
+ }
+
+ cir::MethodAttr buildVirtualMethodAttr(cir::MethodType methodTy,
+ const CXXMethodDecl *md) override {
+ cgm.errorNYI(md->getSourceRange(), "buildVirtualMethodAttr: MSVC ABI");
+ return cir::MethodAttr();
+ }
+
+ mlir::Value performThisAdjustment(CIRGenFunction &cgf, Address thisAddr,
+ const CXXRecordDecl *unadjustedClass,
+ const ThunkInfo &ti) override {
+ return thisAddr.emitRawPointer();
+ }
+
+ mlir::Value performReturnAdjustment(CIRGenFunction &cgf, Address ret,
+ const CXXRecordDecl *unadjustedClass,
+ const ReturnAdjustment &ra) override {
+ return ret.emitRawPointer();
+ }
+
+ bool canSpeculativelyEmitVTable(const CXXRecordDecl *rd) const override {
+ return false;
+ }
+
+ bool doStructorsInitializeVPtrs(const CXXRecordDecl *vtableClass) override {
+ return false;
+ }
+
+ bool exportThunk() override { return false; }
+
+ bool useThunkForDtorVariant(const CXXDestructorDecl *dtor,
+ CXXDtorType dt) const override {
+ return false;
+ }
+
+ void setThunkLinkage(cir::FuncOp thunk, bool forVTable, GlobalDecl gd,
+ bool returnAdjustment) override {
+ thunk.setLinkage(cir::GlobalLinkageKind::LinkOnceODRLinkage);
+ }
+
+ llvm::StringRef getPureVirtualCallName() override { return "_purecall"; }
+ llvm::StringRef getDeletedVirtualCallName() override { return "_purecall"; }
+
+ bool isZeroInitializable(const MemberPointerType *mpt) override {
+ return true;
+ }
+
+ bool requiresArrayCookie(const CXXNewExpr *e) override { return false; }
+
+ CharUnits getArrayCookieSizeImpl(QualType elementType) override {
+ return CharUnits::Zero();
+ }
+
+ Address initializeArrayCookie(CIRGenFunction &cgf, Address newPtr,
+ mlir::Value numElements, const CXXNewExpr *e,
+ QualType elementType) override {
+ cgf.cgm.errorNYI(e->getSourceRange(), "initializeArrayCookie: MSVC ABI");
+ return newPtr;
+ }
+
+ bool shouldTypeidBeNullChecked(QualType srcTy) override { return false; }
+
+ mlir::Value emitTypeid(CIRGenFunction &cgf, QualType srcTy, Address thisPtr,
+ mlir::Type typeInfoPtrTy) override {
+ cgf.cgm.errorNYI(cgf.getLoc(srcTy->getAsCXXRecordDecl()->getLocation()),
+ "emitTypeid: MSVC ABI");
+ return cgf.getBuilder().getNullPtr(
+ typeInfoPtrTy, cgf.getLoc(srcTy->getAsCXXRecordDecl()->getLocation()));
+ }
+
+ void emitBadTypeidCall(CIRGenFunction &cgf, mlir::Location loc) override {
+ cgf.cgm.errorNYI(loc, "emitBadTypeidCall: MSVC ABI");
+ }
+
+ void emitBadCastCall(CIRGenFunction &cgf, mlir::Location loc) override {
+ cgm.errorNYI(loc, "emitBadCastCall: MSVC ABI");
+ }
+
+ mlir::Value emitDynamicCast(CIRGenFunction &cgf, mlir::Location loc,
+ QualType srcRecordTy, QualType destRecordTy,
+ cir::PointerType destCIRTy, bool isRefCast,
+ Address src) override {
+ cgf.cgm.errorNYI(loc, "emitDynamicCast: MSVC ABI");
+ return cgf.getBuilder().getNullPtr(destCIRTy, loc);
+ }
+
+ mlir::Attribute getAddrOfRTTIDescriptor(mlir::Location loc,
+ QualType ty) override {
+ cgm.errorNYI(loc, "getAddrOfRTTIDescriptor: MSVC ABI");
+ return nullptr;
+ }
+
+ CatchTypeInfo getCatchAllTypeInfo() override {
+ return CatchTypeInfo{nullptr, 0};
+ }
+
+ CatchTypeInfo
+ getAddrOfCXXCatchHandlerType(mlir::Location loc, QualType ty,
+ QualType catchHandlerType) override {
+ cgm.errorNYI(loc, "getAddrOfCXXCatchHandlerType: MSVC ABI");
+ return CatchTypeInfo{nullptr, 0};
+ }
+
+ void emitRethrow(CIRGenFunction &cgf, bool isNoReturn) override {
+ cgm.errorNYI("emitRethrow: MSVC ABI");
+ }
+
+ void emitThrow(CIRGenFunction &cgf, const CXXThrowExpr *e) override {
+ cgf.cgm.errorNYI(e->getSourceRange(), "emitThrow: MSVC ABI");
+ }
+
+ void registerGlobalDtor(const VarDecl *vd, cir::FuncOp dtor,
+ mlir::Value addr) override {}
+};
+
+} // namespace
+
+CIRGenCXXABI *clang::CIRGen::CreateCIRGenMicrosoftCXXABI(CIRGenModule &cgm) {
+ return new CIRGenMicrosoftCXXABI(cgm);
+}
>From 7402e033e8cc3332b6b646e1ec7242681edadfad Mon Sep 17 00:00:00 2001
From: R-Goc <ryszardgoc at gmail.com>
Date: Thu, 3 Sep 2026 23:19:22 +0200
Subject: [PATCH 3/5] fix line endings
---
.../lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp | 564 +++++++++---------
1 file changed, 282 insertions(+), 282 deletions(-)
diff --git a/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp b/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
index 9e5faa5b5e54d..0b7c4d3164d97 100644
--- a/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
@@ -1,282 +1,282 @@
-//===--- CIRGenMicrosoftCXXABI.cpp - Emit CIR Code for MS C++ ABI --------===//
-//
-// 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 provides C++ code generation targeting the Microsoft C++ ABI.
-//
-//===----------------------------------------------------------------------===//
-
-#include "CIRGenCXXABI.h"
-#include "CIRGenFunction.h"
-#include "CIRGenModule.h"
-
-#include "clang/AST/Decl.h"
-#include "clang/AST/DeclCXX.h"
-#include "clang/AST/Mangle.h"
-
-using namespace clang;
-using namespace clang::CIRGen;
-
-namespace {
-
-class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
-public:
- CIRGenMicrosoftCXXABI(CIRGenModule &cgm) : CIRGenCXXABI(cgm) {}
-
- AddedStructorArgCounts
- buildStructorSignature(GlobalDecl gd,
- llvm::SmallVectorImpl<CanQualType> &argTys) override {
- return AddedStructorArgCounts{};
- }
-
- void addImplicitStructorParams(CIRGenFunction &cgf, QualType &resTy,
- FunctionArgList ¶ms) override {}
-
- void emitInstanceFunctionProlog(SourceLocation loc,
- CIRGenFunction &cgf) override {}
-
- AddedStructorArgs getImplicitConstructorArgs(CIRGenFunction &cgf,
- const CXXConstructorDecl *d,
- CXXCtorType type,
- bool forVirtualBase,
- bool delegating) override {
- return AddedStructorArgs{};
- }
-
- mlir::Value getCXXDestructorImplicitParam(CIRGenFunction &cgf,
- const CXXDestructorDecl *dd,
- CXXDtorType type,
- bool forVirtualBase,
- bool delegating) override {
- return nullptr;
- }
-
- void emitCXXConstructors(const CXXConstructorDecl *d) override {
- cgm.errorNYI(d->getSourceRange(), "emitCXXConstructors: MSVC ABI");
- }
-
- void emitCXXDestructors(const CXXDestructorDecl *d) override {
- cgm.errorNYI(d->getSourceRange(), "emitCXXDestructors: MSVC ABI");
- }
-
- void emitCXXStructor(GlobalDecl gd) override {
- cgm.errorNYI(gd.getDecl()->getSourceRange(), "emitCXXStructor: MSVC ABI");
- }
-
- void emitDestructorCall(CIRGenFunction &cgf, const CXXDestructorDecl *dd,
- CXXDtorType type, bool forVirtualBase,
- bool delegating, Address thisAddr,
- QualType thisTy) override {
- cgf.cgm.errorNYI(dd->getSourceRange(), "emitDestructorCall: MSVC ABI");
- }
-
- mlir::Value emitVirtualDestructorCall(CIRGenFunction &cgf,
- const CXXDestructorDecl *dtor,
- CXXDtorType dtorType, Address thisAddr,
- DeleteOrMemberCallExpr e) override {
- cgf.cgm.errorNYI(dtor->getSourceRange(),
- "emitVirtualDestructorCall: MSVC ABI");
- return nullptr;
- }
-
- void emitVirtualObjectDelete(CIRGenFunction &cgf, const CXXDeleteExpr *de,
- Address ptr, QualType elementType,
- const CXXDestructorDecl *dtor) override {
- cgf.cgm.errorNYI(de->getSourceRange(), "emitVirtualObjectDelete: MSVC ABI");
- }
-
- const CXXRecordDecl *
- getThisArgumentTypeForMethod(const CXXMethodDecl *md) override {
- return md->getParent();
- }
-
- Address adjustThisArgumentForVirtualFunctionCall(CIRGenFunction &cgf,
- GlobalDecl gd,
- Address thisAddr,
- bool virtualCall) override {
- return thisAddr;
- }
-
- bool isVirtualOffsetNeededForVTableField(CIRGenFunction &cgf,
- CIRGenFunction::VPtr vptr) override {
- return false;
- }
-
- cir::GlobalOp getAddrOfVTable(const CXXRecordDecl *rd,
- CharUnits vptrOffset) override {
- cgm.errorNYI(rd->getSourceRange(), "getAddrOfVTable: MSVC ABI");
- return nullptr;
- }
-
- mlir::Value getVTableAddressPoint(BaseSubobject base,
- const CXXRecordDecl *vtableClass) override {
- cgm.errorNYI(vtableClass->getSourceRange(),
- "getVTableAddressPoint: MSVC ABI");
- return nullptr;
- }
-
- mlir::Value getVTableAddressPointInStructor(
- CIRGenFunction &cgf, const CXXRecordDecl *vtableClass, BaseSubobject base,
- const CXXRecordDecl *nearestVBase) override {
- cgf.cgm.errorNYI(vtableClass->getSourceRange(),
- "getVTableAddressPointInStructor: MSVC ABI");
- return nullptr;
- }
-
- CIRGenCallee getVirtualFunctionPointer(CIRGenFunction &cgf, GlobalDecl gd,
- Address thisAddr, mlir::Type ty,
- SourceLocation loc) override {
- cgf.cgm.errorNYI(loc, "getVirtualFunctionPointer: MSVC ABI");
- return CIRGenCallee();
- }
-
- void emitVTableDefinitions(CIRGenVTables &cgvt,
- const CXXRecordDecl *rd) override {
- cgm.errorNYI(rd->getSourceRange(), "emitVTableDefinitions: MSVC ABI");
- }
-
- void emitVirtualInheritanceTables(const CXXRecordDecl *rd) override {
- if (rd->getNumVBases())
- cgm.errorNYI(rd->getSourceRange(),
- "emitVirtualInheritanceTables: MSVC VBTables");
- }
-
- void
- initializeHiddenVirtualInheritanceMembers(CIRGenFunction &cgf,
- const CXXRecordDecl *rd) override {
- if (rd->getNumVBases())
- cgf.cgm.errorNYI(
- rd->getSourceRange(),
- "initializeHiddenVirtualInheritanceMembers: vbptr stores");
- }
-
- mlir::Value
- getVirtualBaseClassOffset(mlir::Location loc, CIRGenFunction &cgf,
- Address thisAddr, const CXXRecordDecl *classDecl,
- const CXXRecordDecl *baseClassDecl) override {
- cgf.cgm.errorNYI(loc, "getVirtualBaseClassOffset: MSVC ABI");
- return nullptr;
- }
-
- cir::MethodAttr buildVirtualMethodAttr(cir::MethodType methodTy,
- const CXXMethodDecl *md) override {
- cgm.errorNYI(md->getSourceRange(), "buildVirtualMethodAttr: MSVC ABI");
- return cir::MethodAttr();
- }
-
- mlir::Value performThisAdjustment(CIRGenFunction &cgf, Address thisAddr,
- const CXXRecordDecl *unadjustedClass,
- const ThunkInfo &ti) override {
- return thisAddr.emitRawPointer();
- }
-
- mlir::Value performReturnAdjustment(CIRGenFunction &cgf, Address ret,
- const CXXRecordDecl *unadjustedClass,
- const ReturnAdjustment &ra) override {
- return ret.emitRawPointer();
- }
-
- bool canSpeculativelyEmitVTable(const CXXRecordDecl *rd) const override {
- return false;
- }
-
- bool doStructorsInitializeVPtrs(const CXXRecordDecl *vtableClass) override {
- return false;
- }
-
- bool exportThunk() override { return false; }
-
- bool useThunkForDtorVariant(const CXXDestructorDecl *dtor,
- CXXDtorType dt) const override {
- return false;
- }
-
- void setThunkLinkage(cir::FuncOp thunk, bool forVTable, GlobalDecl gd,
- bool returnAdjustment) override {
- thunk.setLinkage(cir::GlobalLinkageKind::LinkOnceODRLinkage);
- }
-
- llvm::StringRef getPureVirtualCallName() override { return "_purecall"; }
- llvm::StringRef getDeletedVirtualCallName() override { return "_purecall"; }
-
- bool isZeroInitializable(const MemberPointerType *mpt) override {
- return true;
- }
-
- bool requiresArrayCookie(const CXXNewExpr *e) override { return false; }
-
- CharUnits getArrayCookieSizeImpl(QualType elementType) override {
- return CharUnits::Zero();
- }
-
- Address initializeArrayCookie(CIRGenFunction &cgf, Address newPtr,
- mlir::Value numElements, const CXXNewExpr *e,
- QualType elementType) override {
- cgf.cgm.errorNYI(e->getSourceRange(), "initializeArrayCookie: MSVC ABI");
- return newPtr;
- }
-
- bool shouldTypeidBeNullChecked(QualType srcTy) override { return false; }
-
- mlir::Value emitTypeid(CIRGenFunction &cgf, QualType srcTy, Address thisPtr,
- mlir::Type typeInfoPtrTy) override {
- cgf.cgm.errorNYI(cgf.getLoc(srcTy->getAsCXXRecordDecl()->getLocation()),
- "emitTypeid: MSVC ABI");
- return cgf.getBuilder().getNullPtr(
- typeInfoPtrTy, cgf.getLoc(srcTy->getAsCXXRecordDecl()->getLocation()));
- }
-
- void emitBadTypeidCall(CIRGenFunction &cgf, mlir::Location loc) override {
- cgf.cgm.errorNYI(loc, "emitBadTypeidCall: MSVC ABI");
- }
-
- void emitBadCastCall(CIRGenFunction &cgf, mlir::Location loc) override {
- cgm.errorNYI(loc, "emitBadCastCall: MSVC ABI");
- }
-
- mlir::Value emitDynamicCast(CIRGenFunction &cgf, mlir::Location loc,
- QualType srcRecordTy, QualType destRecordTy,
- cir::PointerType destCIRTy, bool isRefCast,
- Address src) override {
- cgf.cgm.errorNYI(loc, "emitDynamicCast: MSVC ABI");
- return cgf.getBuilder().getNullPtr(destCIRTy, loc);
- }
-
- mlir::Attribute getAddrOfRTTIDescriptor(mlir::Location loc,
- QualType ty) override {
- cgm.errorNYI(loc, "getAddrOfRTTIDescriptor: MSVC ABI");
- return nullptr;
- }
-
- CatchTypeInfo getCatchAllTypeInfo() override {
- return CatchTypeInfo{nullptr, 0};
- }
-
- CatchTypeInfo
- getAddrOfCXXCatchHandlerType(mlir::Location loc, QualType ty,
- QualType catchHandlerType) override {
- cgm.errorNYI(loc, "getAddrOfCXXCatchHandlerType: MSVC ABI");
- return CatchTypeInfo{nullptr, 0};
- }
-
- void emitRethrow(CIRGenFunction &cgf, bool isNoReturn) override {
- cgm.errorNYI("emitRethrow: MSVC ABI");
- }
-
- void emitThrow(CIRGenFunction &cgf, const CXXThrowExpr *e) override {
- cgf.cgm.errorNYI(e->getSourceRange(), "emitThrow: MSVC ABI");
- }
-
- void registerGlobalDtor(const VarDecl *vd, cir::FuncOp dtor,
- mlir::Value addr) override {}
-};
-
-} // namespace
-
-CIRGenCXXABI *clang::CIRGen::CreateCIRGenMicrosoftCXXABI(CIRGenModule &cgm) {
- return new CIRGenMicrosoftCXXABI(cgm);
-}
+//===--- CIRGenMicrosoftCXXABI.cpp - Emit CIR Code for MS C++ ABI --------===//
+//
+// 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 provides C++ code generation targeting the Microsoft C++ ABI.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CIRGenCXXABI.h"
+#include "CIRGenFunction.h"
+#include "CIRGenModule.h"
+
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/Mangle.h"
+
+using namespace clang;
+using namespace clang::CIRGen;
+
+namespace {
+
+class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
+public:
+ CIRGenMicrosoftCXXABI(CIRGenModule &cgm) : CIRGenCXXABI(cgm) {}
+
+ AddedStructorArgCounts
+ buildStructorSignature(GlobalDecl gd,
+ llvm::SmallVectorImpl<CanQualType> &argTys) override {
+ return AddedStructorArgCounts{};
+ }
+
+ void addImplicitStructorParams(CIRGenFunction &cgf, QualType &resTy,
+ FunctionArgList ¶ms) override {}
+
+ void emitInstanceFunctionProlog(SourceLocation loc,
+ CIRGenFunction &cgf) override {}
+
+ AddedStructorArgs getImplicitConstructorArgs(CIRGenFunction &cgf,
+ const CXXConstructorDecl *d,
+ CXXCtorType type,
+ bool forVirtualBase,
+ bool delegating) override {
+ return AddedStructorArgs{};
+ }
+
+ mlir::Value getCXXDestructorImplicitParam(CIRGenFunction &cgf,
+ const CXXDestructorDecl *dd,
+ CXXDtorType type,
+ bool forVirtualBase,
+ bool delegating) override {
+ return nullptr;
+ }
+
+ void emitCXXConstructors(const CXXConstructorDecl *d) override {
+ cgm.errorNYI(d->getSourceRange(), "emitCXXConstructors: MSVC ABI");
+ }
+
+ void emitCXXDestructors(const CXXDestructorDecl *d) override {
+ cgm.errorNYI(d->getSourceRange(), "emitCXXDestructors: MSVC ABI");
+ }
+
+ void emitCXXStructor(GlobalDecl gd) override {
+ cgm.errorNYI(gd.getDecl()->getSourceRange(), "emitCXXStructor: MSVC ABI");
+ }
+
+ void emitDestructorCall(CIRGenFunction &cgf, const CXXDestructorDecl *dd,
+ CXXDtorType type, bool forVirtualBase,
+ bool delegating, Address thisAddr,
+ QualType thisTy) override {
+ cgf.cgm.errorNYI(dd->getSourceRange(), "emitDestructorCall: MSVC ABI");
+ }
+
+ mlir::Value emitVirtualDestructorCall(CIRGenFunction &cgf,
+ const CXXDestructorDecl *dtor,
+ CXXDtorType dtorType, Address thisAddr,
+ DeleteOrMemberCallExpr e) override {
+ cgf.cgm.errorNYI(dtor->getSourceRange(),
+ "emitVirtualDestructorCall: MSVC ABI");
+ return nullptr;
+ }
+
+ void emitVirtualObjectDelete(CIRGenFunction &cgf, const CXXDeleteExpr *de,
+ Address ptr, QualType elementType,
+ const CXXDestructorDecl *dtor) override {
+ cgf.cgm.errorNYI(de->getSourceRange(), "emitVirtualObjectDelete: MSVC ABI");
+ }
+
+ const CXXRecordDecl *
+ getThisArgumentTypeForMethod(const CXXMethodDecl *md) override {
+ return md->getParent();
+ }
+
+ Address adjustThisArgumentForVirtualFunctionCall(CIRGenFunction &cgf,
+ GlobalDecl gd,
+ Address thisAddr,
+ bool virtualCall) override {
+ return thisAddr;
+ }
+
+ bool isVirtualOffsetNeededForVTableField(CIRGenFunction &cgf,
+ CIRGenFunction::VPtr vptr) override {
+ return false;
+ }
+
+ cir::GlobalOp getAddrOfVTable(const CXXRecordDecl *rd,
+ CharUnits vptrOffset) override {
+ cgm.errorNYI(rd->getSourceRange(), "getAddrOfVTable: MSVC ABI");
+ return nullptr;
+ }
+
+ mlir::Value getVTableAddressPoint(BaseSubobject base,
+ const CXXRecordDecl *vtableClass) override {
+ cgm.errorNYI(vtableClass->getSourceRange(),
+ "getVTableAddressPoint: MSVC ABI");
+ return nullptr;
+ }
+
+ mlir::Value getVTableAddressPointInStructor(
+ CIRGenFunction &cgf, const CXXRecordDecl *vtableClass, BaseSubobject base,
+ const CXXRecordDecl *nearestVBase) override {
+ cgf.cgm.errorNYI(vtableClass->getSourceRange(),
+ "getVTableAddressPointInStructor: MSVC ABI");
+ return nullptr;
+ }
+
+ CIRGenCallee getVirtualFunctionPointer(CIRGenFunction &cgf, GlobalDecl gd,
+ Address thisAddr, mlir::Type ty,
+ SourceLocation loc) override {
+ cgf.cgm.errorNYI(loc, "getVirtualFunctionPointer: MSVC ABI");
+ return CIRGenCallee();
+ }
+
+ void emitVTableDefinitions(CIRGenVTables &cgvt,
+ const CXXRecordDecl *rd) override {
+ cgm.errorNYI(rd->getSourceRange(), "emitVTableDefinitions: MSVC ABI");
+ }
+
+ void emitVirtualInheritanceTables(const CXXRecordDecl *rd) override {
+ if (rd->getNumVBases())
+ cgm.errorNYI(rd->getSourceRange(),
+ "emitVirtualInheritanceTables: MSVC VBTables");
+ }
+
+ void
+ initializeHiddenVirtualInheritanceMembers(CIRGenFunction &cgf,
+ const CXXRecordDecl *rd) override {
+ if (rd->getNumVBases())
+ cgf.cgm.errorNYI(
+ rd->getSourceRange(),
+ "initializeHiddenVirtualInheritanceMembers: vbptr stores");
+ }
+
+ mlir::Value
+ getVirtualBaseClassOffset(mlir::Location loc, CIRGenFunction &cgf,
+ Address thisAddr, const CXXRecordDecl *classDecl,
+ const CXXRecordDecl *baseClassDecl) override {
+ cgf.cgm.errorNYI(loc, "getVirtualBaseClassOffset: MSVC ABI");
+ return nullptr;
+ }
+
+ cir::MethodAttr buildVirtualMethodAttr(cir::MethodType methodTy,
+ const CXXMethodDecl *md) override {
+ cgm.errorNYI(md->getSourceRange(), "buildVirtualMethodAttr: MSVC ABI");
+ return cir::MethodAttr();
+ }
+
+ mlir::Value performThisAdjustment(CIRGenFunction &cgf, Address thisAddr,
+ const CXXRecordDecl *unadjustedClass,
+ const ThunkInfo &ti) override {
+ return thisAddr.emitRawPointer();
+ }
+
+ mlir::Value performReturnAdjustment(CIRGenFunction &cgf, Address ret,
+ const CXXRecordDecl *unadjustedClass,
+ const ReturnAdjustment &ra) override {
+ return ret.emitRawPointer();
+ }
+
+ bool canSpeculativelyEmitVTable(const CXXRecordDecl *rd) const override {
+ return false;
+ }
+
+ bool doStructorsInitializeVPtrs(const CXXRecordDecl *vtableClass) override {
+ return false;
+ }
+
+ bool exportThunk() override { return false; }
+
+ bool useThunkForDtorVariant(const CXXDestructorDecl *dtor,
+ CXXDtorType dt) const override {
+ return false;
+ }
+
+ void setThunkLinkage(cir::FuncOp thunk, bool forVTable, GlobalDecl gd,
+ bool returnAdjustment) override {
+ thunk.setLinkage(cir::GlobalLinkageKind::LinkOnceODRLinkage);
+ }
+
+ llvm::StringRef getPureVirtualCallName() override { return "_purecall"; }
+ llvm::StringRef getDeletedVirtualCallName() override { return "_purecall"; }
+
+ bool isZeroInitializable(const MemberPointerType *mpt) override {
+ return true;
+ }
+
+ bool requiresArrayCookie(const CXXNewExpr *e) override { return false; }
+
+ CharUnits getArrayCookieSizeImpl(QualType elementType) override {
+ return CharUnits::Zero();
+ }
+
+ Address initializeArrayCookie(CIRGenFunction &cgf, Address newPtr,
+ mlir::Value numElements, const CXXNewExpr *e,
+ QualType elementType) override {
+ cgf.cgm.errorNYI(e->getSourceRange(), "initializeArrayCookie: MSVC ABI");
+ return newPtr;
+ }
+
+ bool shouldTypeidBeNullChecked(QualType srcTy) override { return false; }
+
+ mlir::Value emitTypeid(CIRGenFunction &cgf, QualType srcTy, Address thisPtr,
+ mlir::Type typeInfoPtrTy) override {
+ cgf.cgm.errorNYI(cgf.getLoc(srcTy->getAsCXXRecordDecl()->getLocation()),
+ "emitTypeid: MSVC ABI");
+ return cgf.getBuilder().getNullPtr(
+ typeInfoPtrTy, cgf.getLoc(srcTy->getAsCXXRecordDecl()->getLocation()));
+ }
+
+ void emitBadTypeidCall(CIRGenFunction &cgf, mlir::Location loc) override {
+ cgf.cgm.errorNYI(loc, "emitBadTypeidCall: MSVC ABI");
+ }
+
+ void emitBadCastCall(CIRGenFunction &cgf, mlir::Location loc) override {
+ cgm.errorNYI(loc, "emitBadCastCall: MSVC ABI");
+ }
+
+ mlir::Value emitDynamicCast(CIRGenFunction &cgf, mlir::Location loc,
+ QualType srcRecordTy, QualType destRecordTy,
+ cir::PointerType destCIRTy, bool isRefCast,
+ Address src) override {
+ cgf.cgm.errorNYI(loc, "emitDynamicCast: MSVC ABI");
+ return cgf.getBuilder().getNullPtr(destCIRTy, loc);
+ }
+
+ mlir::Attribute getAddrOfRTTIDescriptor(mlir::Location loc,
+ QualType ty) override {
+ cgm.errorNYI(loc, "getAddrOfRTTIDescriptor: MSVC ABI");
+ return nullptr;
+ }
+
+ CatchTypeInfo getCatchAllTypeInfo() override {
+ return CatchTypeInfo{nullptr, 0};
+ }
+
+ CatchTypeInfo
+ getAddrOfCXXCatchHandlerType(mlir::Location loc, QualType ty,
+ QualType catchHandlerType) override {
+ cgm.errorNYI(loc, "getAddrOfCXXCatchHandlerType: MSVC ABI");
+ return CatchTypeInfo{nullptr, 0};
+ }
+
+ void emitRethrow(CIRGenFunction &cgf, bool isNoReturn) override {
+ cgm.errorNYI("emitRethrow: MSVC ABI");
+ }
+
+ void emitThrow(CIRGenFunction &cgf, const CXXThrowExpr *e) override {
+ cgf.cgm.errorNYI(e->getSourceRange(), "emitThrow: MSVC ABI");
+ }
+
+ void registerGlobalDtor(const VarDecl *vd, cir::FuncOp dtor,
+ mlir::Value addr) override {}
+};
+
+} // namespace
+
+CIRGenCXXABI *clang::CIRGen::CreateCIRGenMicrosoftCXXABI(CIRGenModule &cgm) {
+ return new CIRGenMicrosoftCXXABI(cgm);
+}
>From d39cc96194e3d6a3ac32a496d31f58a4021b02db Mon Sep 17 00:00:00 2001
From: R-Goc <ryszardgoc at gmail.com>
Date: Fri, 4 Sep 2026 01:02:10 +0200
Subject: [PATCH 4/5] fix missing method
---
clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp | 12 ++++++++++++
1 file changed, 12 insertions(+)
diff --git a/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp b/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
index 0b7c4d3164d97..9e3fc9a8f55a6 100644
--- a/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
@@ -89,6 +89,18 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
cgf.cgm.errorNYI(de->getSourceRange(), "emitVirtualObjectDelete: MSVC ABI");
}
+ size_t getSrcArgforCopyCtor(const CXXConstructorDecl *cd,
+ FunctionArgList &args) const override {
+ assert(args.size() >= 2 &&
+ "expected the arglist to have at least two args!");
+ // The 'most_derived' parameter goes second if the ctor is variadic and
+ // has v-bases.
+ if (cd->getParent()->getNumVBases() > 0 &&
+ cd->getType()->castAs<FunctionProtoType>()->isVariadic())
+ return 2;
+ return 1;
+ }
+
const CXXRecordDecl *
getThisArgumentTypeForMethod(const CXXMethodDecl *md) override {
return md->getParent();
>From 72d4077bf650dbc489fc32a67edbd007052e1548 Mon Sep 17 00:00:00 2001
From: R-Goc <ryszardgoc at gmail.com>
Date: Tue, 15 Sep 2026 16:08:01 +0200
Subject: [PATCH 5/5] NYI everything
---
.../lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp | 63 ++++++++++++++-----
1 file changed, 47 insertions(+), 16 deletions(-)
diff --git a/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp b/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
index 9e3fc9a8f55a6..c8a29bfb550f2 100644
--- a/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenMicrosoftCXXABI.cpp
@@ -29,21 +29,30 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
AddedStructorArgCounts
buildStructorSignature(GlobalDecl gd,
- llvm::SmallVectorImpl<CanQualType> &argTys) override {
+ SmallVectorImpl<CanQualType> &argTys) override {
+ cgm.errorNYI(gd.getDecl()->getSourceRange(),
+ "buildStructorSignature: MSVC ABI");
return AddedStructorArgCounts{};
}
void addImplicitStructorParams(CIRGenFunction &cgf, QualType &resTy,
- FunctionArgList ¶ms) override {}
+ FunctionArgList ¶ms) override {
+ cgf.cgm.errorNYI(cgf.curGD.getDecl()->getSourceRange(),
+ "addImplicitStructorParams: MSVC ABI");
+ }
void emitInstanceFunctionProlog(SourceLocation loc,
- CIRGenFunction &cgf) override {}
+ CIRGenFunction &cgf) override {
+ cgf.cgm.errorNYI(loc, "emitInstanceFunctionProlog: MSVC ABI");
+ }
AddedStructorArgs getImplicitConstructorArgs(CIRGenFunction &cgf,
const CXXConstructorDecl *d,
CXXCtorType type,
bool forVirtualBase,
bool delegating) override {
+ cgf.cgm.errorNYI(d->getSourceRange(),
+ "getImplicitConstructorArgs: MSVC ABI");
return AddedStructorArgs{};
}
@@ -52,6 +61,8 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
CXXDtorType type,
bool forVirtualBase,
bool delegating) override {
+ cgf.cgm.errorNYI(dd->getSourceRange(),
+ "getCXXDestructorImplicitParam: MSVC ABI");
return nullptr;
}
@@ -91,6 +102,7 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
size_t getSrcArgforCopyCtor(const CXXConstructorDecl *cd,
FunctionArgList &args) const override {
+ cgm.errorNYI(cd->getSourceRange(), "getSrcArgforCopyCtor: MSVC ABI");
assert(args.size() >= 2 &&
"expected the arglist to have at least two args!");
// The 'most_derived' parameter goes second if the ctor is variadic and
@@ -103,6 +115,8 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
const CXXRecordDecl *
getThisArgumentTypeForMethod(const CXXMethodDecl *md) override {
+ cgm.errorNYI(md->getSourceRange(),
+ "getThisArgumentTypeForMethod: MSVC ABI");
return md->getParent();
}
@@ -110,11 +124,14 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
GlobalDecl gd,
Address thisAddr,
bool virtualCall) override {
+ cgf.cgm.errorNYI(gd.getDecl()->getSourceRange(),
+ "adjustThisArgumentForVirtualFunctionCall: MSVC ABI");
return thisAddr;
}
bool isVirtualOffsetNeededForVTableField(CIRGenFunction &cgf,
CIRGenFunction::VPtr vptr) override {
+ cgf.cgm.errorNYI("isVirtualOffsetNeededForVTableField: MSVC ABI");
return false;
}
@@ -152,18 +169,15 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
}
void emitVirtualInheritanceTables(const CXXRecordDecl *rd) override {
- if (rd->getNumVBases())
- cgm.errorNYI(rd->getSourceRange(),
- "emitVirtualInheritanceTables: MSVC VBTables");
+ cgm.errorNYI(rd->getSourceRange(),
+ "emitVirtualInheritanceTables: MSVC ABI");
}
void
initializeHiddenVirtualInheritanceMembers(CIRGenFunction &cgf,
const CXXRecordDecl *rd) override {
- if (rd->getNumVBases())
- cgf.cgm.errorNYI(
- rd->getSourceRange(),
- "initializeHiddenVirtualInheritanceMembers: vbptr stores");
+ cgf.cgm.errorNYI(rd->getSourceRange(),
+ "initializeHiddenVirtualInheritanceMembers: MSVC ABI");
}
mlir::Value
@@ -183,12 +197,14 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
mlir::Value performThisAdjustment(CIRGenFunction &cgf, Address thisAddr,
const CXXRecordDecl *unadjustedClass,
const ThunkInfo &ti) override {
+ cgf.cgm.errorNYI("performThisAdjustment: MSVC ABI");
return thisAddr.emitRawPointer();
}
mlir::Value performReturnAdjustment(CIRGenFunction &cgf, Address ret,
const CXXRecordDecl *unadjustedClass,
const ReturnAdjustment &ra) override {
+ cgf.cgm.errorNYI("performReturnAdjustment: MSVC ABI");
return ret.emitRawPointer();
}
@@ -197,6 +213,8 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
}
bool doStructorsInitializeVPtrs(const CXXRecordDecl *vtableClass) override {
+ cgm.errorNYI(vtableClass->getSourceRange(),
+ "doStructorsInitializeVPtrs: MSVC ABI");
return false;
}
@@ -204,24 +222,31 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
bool useThunkForDtorVariant(const CXXDestructorDecl *dtor,
CXXDtorType dt) const override {
+ cgm.errorNYI(dtor->getSourceRange(), "useThunkForDtorVariant: MSVC ABI");
return false;
}
void setThunkLinkage(cir::FuncOp thunk, bool forVTable, GlobalDecl gd,
bool returnAdjustment) override {
- thunk.setLinkage(cir::GlobalLinkageKind::LinkOnceODRLinkage);
+ cgm.errorNYI(gd.getDecl()->getSourceRange(),
+ "setThunkLinkage: MSVC ABI");
}
- llvm::StringRef getPureVirtualCallName() override { return "_purecall"; }
- llvm::StringRef getDeletedVirtualCallName() override { return "_purecall"; }
+ StringRef getPureVirtualCallName() override { return "_purecall"; }
+ StringRef getDeletedVirtualCallName() override { return "_purecall"; }
bool isZeroInitializable(const MemberPointerType *mpt) override {
+ cgm.errorNYI("isZeroInitializable: MSVC ABI");
return true;
}
- bool requiresArrayCookie(const CXXNewExpr *e) override { return false; }
+ bool requiresArrayCookie(const CXXNewExpr *e) override {
+ cgm.errorNYI(e->getSourceRange(), "requiresArrayCookie: MSVC ABI");
+ return false;
+ }
CharUnits getArrayCookieSizeImpl(QualType elementType) override {
+ cgm.errorNYI("getArrayCookieSizeImpl: MSVC ABI");
return CharUnits::Zero();
}
@@ -232,7 +257,10 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
return newPtr;
}
- bool shouldTypeidBeNullChecked(QualType srcTy) override { return false; }
+ bool shouldTypeidBeNullChecked(QualType srcTy) override {
+ cgm.errorNYI("shouldTypeidBeNullChecked: MSVC ABI");
+ return false;
+ }
mlir::Value emitTypeid(CIRGenFunction &cgf, QualType srcTy, Address thisPtr,
mlir::Type typeInfoPtrTy) override {
@@ -265,6 +293,7 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
}
CatchTypeInfo getCatchAllTypeInfo() override {
+ cgm.errorNYI("getCatchAllTypeInfo: MSVC ABI");
return CatchTypeInfo{nullptr, 0};
}
@@ -284,7 +313,9 @@ class CIRGenMicrosoftCXXABI : public CIRGenCXXABI {
}
void registerGlobalDtor(const VarDecl *vd, cir::FuncOp dtor,
- mlir::Value addr) override {}
+ mlir::Value addr) override {
+ cgm.errorNYI(vd->getSourceRange(), "registerGlobalDtor: MSVC ABI");
+ }
};
} // namespace
More information about the cfe-commits
mailing list