1//===----- CGCXXABI.cpp - Interface to C++ ABIs ---------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This provides an abstract class for C++ code generation. Concrete subclasses
10// of this implement code generation for specific C++ ABIs.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CGCXXABI.h"
15#include "CGCleanup.h"
16#include "clang/AST/Attr.h"
17
18using namespace clang;
19using namespace CodeGen;
20
21CGCXXABI::~CGCXXABI() { }
22
23void CGCXXABI::ErrorUnsupportedABI(CodeGenFunction &CGF, StringRef S) {
24 DiagnosticsEngine &Diags = CGF.CGM.getDiags();
25 unsigned DiagID = Diags.getCustomDiagID(L: DiagnosticsEngine::Error,
26 FormatString: "cannot yet compile %0 in this ABI");
27 Diags.Report(Loc: CGF.getContext().getFullLoc(Loc: CGF.CurCodeDecl->getLocation()),
28 DiagID)
29 << S;
30}
31
32llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) {
33 return llvm::Constant::getNullValue(Ty: CGM.getTypes().ConvertType(T));
34}
35
36llvm::Type *
37CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
38 return CGM.getTypes().ConvertType(T: CGM.getContext().getPointerDiffType());
39}
40
41CGCallee CGCXXABI::EmitLoadOfMemberFunctionPointer(
42 CodeGenFunction &CGF, const Expr *E, Address This,
43 llvm::Value *&ThisPtrForCall,
44 llvm::Value *MemPtr, const MemberPointerType *MPT) {
45 ErrorUnsupportedABI(CGF, S: "calls through member pointers");
46
47 ThisPtrForCall = This.getPointer();
48 const auto *FPT = MPT->getPointeeType()->castAs<FunctionProtoType>();
49 llvm::Constant *FnPtr = llvm::Constant::getNullValue(
50 Ty: llvm::PointerType::getUnqual(C&: CGM.getLLVMContext()));
51 return CGCallee::forDirect(functionPtr: FnPtr, abstractInfo: FPT);
52}
53
54llvm::Value *
55CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
56 Address Base, llvm::Value *MemPtr,
57 const MemberPointerType *MPT) {
58 ErrorUnsupportedABI(CGF, S: "loads of member pointers");
59 llvm::Type *Ty =
60 llvm::PointerType::get(C&: CGF.getLLVMContext(), AddressSpace: Base.getAddressSpace());
61 return llvm::Constant::getNullValue(Ty);
62}
63
64llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
65 const CastExpr *E,
66 llvm::Value *Src) {
67 ErrorUnsupportedABI(CGF, S: "member function pointer conversions");
68 return GetBogusMemberPointer(T: E->getType());
69}
70
71llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E,
72 llvm::Constant *Src) {
73 return GetBogusMemberPointer(T: E->getType());
74}
75
76llvm::Value *
77CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
78 llvm::Value *L,
79 llvm::Value *R,
80 const MemberPointerType *MPT,
81 bool Inequality) {
82 ErrorUnsupportedABI(CGF, S: "member function pointer comparison");
83 return CGF.Builder.getFalse();
84}
85
86llvm::Value *
87CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
88 llvm::Value *MemPtr,
89 const MemberPointerType *MPT) {
90 ErrorUnsupportedABI(CGF, S: "member function pointer null testing");
91 return CGF.Builder.getFalse();
92}
93
94llvm::Constant *
95CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
96 return GetBogusMemberPointer(T: QualType(MPT, 0));
97}
98
99llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
100 return GetBogusMemberPointer(T: CGM.getContext().getMemberPointerType(
101 T: MD->getType(), Cls: MD->getParent()->getTypeForDecl()));
102}
103
104llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
105 CharUnits offset) {
106 return GetBogusMemberPointer(T: QualType(MPT, 0));
107}
108
109llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
110 return GetBogusMemberPointer(T: MPT);
111}
112
113bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
114 // Fake answer.
115 return true;
116}
117
118void CGCXXABI::buildThisParam(CodeGenFunction &CGF, FunctionArgList &params) {
119 const CXXMethodDecl *MD = cast<CXXMethodDecl>(Val: CGF.CurGD.getDecl());
120
121 // FIXME: I'm not entirely sure I like using a fake decl just for code
122 // generation. Maybe we can come up with a better way?
123 auto *ThisDecl =
124 ImplicitParamDecl::Create(CGM.getContext(), nullptr, MD->getLocation(),
125 &CGM.getContext().Idents.get(Name: "this"),
126 MD->getThisType(), ImplicitParamKind::CXXThis);
127 params.push_back(Elt: ThisDecl);
128 CGF.CXXABIThisDecl = ThisDecl;
129
130 // Compute the presumed alignment of 'this', which basically comes
131 // down to whether we know it's a complete object or not.
132 auto &Layout = CGF.getContext().getASTRecordLayout(MD->getParent());
133 if (MD->getParent()->getNumVBases() == 0 || // avoid vcall in common case
134 MD->getParent()->isEffectivelyFinal() ||
135 isThisCompleteObject(GD: CGF.CurGD)) {
136 CGF.CXXABIThisAlignment = Layout.getAlignment();
137 } else {
138 CGF.CXXABIThisAlignment = Layout.getNonVirtualAlignment();
139 }
140}
141
142llvm::Value *CGCXXABI::loadIncomingCXXThis(CodeGenFunction &CGF) {
143 return CGF.Builder.CreateLoad(Addr: CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
144 Name: "this");
145}
146
147void CGCXXABI::setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr) {
148 /// Initialize the 'this' slot.
149 assert(getThisDecl(CGF) && "no 'this' variable for function");
150 CGF.CXXABIThisValue = ThisPtr;
151}
152
153bool CGCXXABI::mayNeedDestruction(const VarDecl *VD) const {
154 if (VD->needsDestruction(Ctx: getContext()))
155 return true;
156
157 // If the variable has an incomplete class type (or array thereof), it
158 // might need destruction.
159 const Type *T = VD->getType()->getBaseElementTypeUnsafe();
160 if (T->getAs<RecordType>() && T->isIncompleteType())
161 return true;
162
163 return false;
164}
165
166bool CGCXXABI::isEmittedWithConstantInitializer(
167 const VarDecl *VD, bool InspectInitForWeakDef) const {
168 VD = VD->getMostRecentDecl();
169 if (VD->hasAttr<ConstInitAttr>())
170 return true;
171
172 // All later checks examine the initializer specified on the variable. If
173 // the variable is weak, such examination would not be correct.
174 if (!InspectInitForWeakDef && (VD->isWeak() || VD->hasAttr<SelectAnyAttr>()))
175 return false;
176
177 const VarDecl *InitDecl = VD->getInitializingDeclaration();
178 if (!InitDecl)
179 return false;
180
181 // If there's no initializer to run, this is constant initialization.
182 if (!InitDecl->hasInit())
183 return true;
184
185 // If we have the only definition, we don't need a thread wrapper if we
186 // will emit the value as a constant.
187 if (isUniqueGVALinkage(L: getContext().GetGVALinkageForVariable(VD)))
188 return !mayNeedDestruction(VD) && InitDecl->evaluateValue();
189
190 // Otherwise, we need a thread wrapper unless we know that every
191 // translation unit will emit the value as a constant. We rely on the
192 // variable being constant-initialized in every translation unit if it's
193 // constant-initialized in any translation unit, which isn't actually
194 // guaranteed by the standard but is necessary for sanity.
195 return InitDecl->hasConstantInitialization();
196}
197
198void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
199 RValue RV, QualType ResultType) {
200 assert(!CGF.hasAggregateEvaluationKind(ResultType) &&
201 "cannot handle aggregates");
202 CGF.EmitReturnOfRValue(RV, Ty: ResultType);
203}
204
205CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
206 if (!requiresArrayCookie(E: expr))
207 return CharUnits::Zero();
208 return getArrayCookieSizeImpl(elementType: expr->getAllocatedType());
209}
210
211CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
212 // BOGUS
213 return CharUnits::Zero();
214}
215
216Address CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
217 Address NewPtr,
218 llvm::Value *NumElements,
219 const CXXNewExpr *expr,
220 QualType ElementType) {
221 // Should never be called.
222 ErrorUnsupportedABI(CGF, S: "array cookie initialization");
223 return Address::invalid();
224}
225
226bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
227 QualType elementType) {
228 // If the class's usual deallocation function takes two arguments,
229 // it needs a cookie.
230 if (expr->doesUsualArrayDeleteWantSize())
231 return true;
232
233 return elementType.isDestructedType();
234}
235
236bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
237 // If the class's usual deallocation function takes two arguments,
238 // it needs a cookie.
239 if (expr->doesUsualArrayDeleteWantSize())
240 return true;
241
242 return expr->getAllocatedType().isDestructedType();
243}
244
245void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, Address ptr,
246 const CXXDeleteExpr *expr, QualType eltTy,
247 llvm::Value *&numElements,
248 llvm::Value *&allocPtr, CharUnits &cookieSize) {
249 // Derive a char* in the same address space as the pointer.
250 ptr = ptr.withElementType(ElemTy: CGF.Int8Ty);
251
252 // If we don't need an array cookie, bail out early.
253 if (!requiresArrayCookie(expr, elementType: eltTy)) {
254 allocPtr = ptr.getPointer();
255 numElements = nullptr;
256 cookieSize = CharUnits::Zero();
257 return;
258 }
259
260 cookieSize = getArrayCookieSizeImpl(elementType: eltTy);
261 Address allocAddr =
262 CGF.Builder.CreateConstInBoundsByteGEP(Addr: ptr, Offset: -cookieSize);
263 allocPtr = allocAddr.getPointer();
264 numElements = readArrayCookieImpl(IGF&: CGF, ptr: allocAddr, cookieSize);
265}
266
267llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
268 Address ptr,
269 CharUnits cookieSize) {
270 ErrorUnsupportedABI(CGF, S: "reading a new[] cookie");
271 return llvm::ConstantInt::get(Ty: CGF.SizeTy, V: 0);
272}
273
274/// Returns the adjustment, in bytes, required for the given
275/// member-pointer operation. Returns null if no adjustment is
276/// required.
277llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
278 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
279 E->getCastKind() == CK_BaseToDerivedMemberPointer);
280
281 QualType derivedType;
282 if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
283 derivedType = E->getSubExpr()->getType();
284 else
285 derivedType = E->getType();
286
287 const CXXRecordDecl *derivedClass =
288 derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
289
290 return CGM.GetNonVirtualBaseClassOffset(ClassDecl: derivedClass,
291 PathBegin: E->path_begin(),
292 PathEnd: E->path_end());
293}
294
295llvm::BasicBlock *
296CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
297 const CXXRecordDecl *RD) {
298 if (CGM.getTarget().getCXXABI().hasConstructorVariants())
299 llvm_unreachable("shouldn't be called in this ABI");
300
301 ErrorUnsupportedABI(CGF, S: "complete object detection in ctor");
302 return nullptr;
303}
304
305void CGCXXABI::setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
306 const CXXDestructorDecl *Dtor,
307 CXXDtorType DT) const {
308 // Assume the base C++ ABI has no special rules for destructor variants.
309 CGM.setDLLImportDLLExport(GV, Dtor);
310}
311
312llvm::GlobalValue::LinkageTypes CGCXXABI::getCXXDestructorLinkage(
313 GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const {
314 // Delegate back to CGM by default.
315 return CGM.getLLVMLinkageForDeclarator(Dtor, Linkage);
316}
317
318bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {
319 return false;
320}
321
322llvm::CallInst *
323CGCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
324 llvm::Value *Exn) {
325 // Just call std::terminate and ignore the violating exception.
326 return CGF.EmitNounwindRuntimeCall(callee: CGF.CGM.getTerminateFn());
327}
328
329CatchTypeInfo CGCXXABI::getCatchAllTypeInfo() {
330 return CatchTypeInfo{.RTTI: nullptr, .Flags: 0};
331}
332
333std::vector<CharUnits> CGCXXABI::getVBPtrOffsets(const CXXRecordDecl *RD) {
334 return std::vector<CharUnits>();
335}
336
337CGCXXABI::AddedStructorArgCounts CGCXXABI::addImplicitConstructorArgs(
338 CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type,
339 bool ForVirtualBase, bool Delegating, CallArgList &Args) {
340 AddedStructorArgs AddedArgs =
341 getImplicitConstructorArgs(CGF, D, Type, ForVirtualBase, Delegating);
342 for (size_t i = 0; i < AddedArgs.Prefix.size(); ++i) {
343 Args.insert(I: Args.begin() + 1 + i,
344 Elt: CallArg(RValue::get(V: AddedArgs.Prefix[i].Value),
345 AddedArgs.Prefix[i].Type));
346 }
347 for (const auto &arg : AddedArgs.Suffix) {
348 Args.add(rvalue: RValue::get(V: arg.Value), type: arg.Type);
349 }
350 return AddedStructorArgCounts(AddedArgs.Prefix.size(),
351 AddedArgs.Suffix.size());
352}
353

source code of clang/lib/CodeGen/CGCXXABI.cpp