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
18 using namespace clang;
19 using namespace CodeGen;
20
~CGCXXABI()21 CGCXXABI::~CGCXXABI() { }
22
ErrorUnsupportedABI(CodeGenFunction & CGF,StringRef S)23 void CGCXXABI::ErrorUnsupportedABI(CodeGenFunction &CGF, StringRef S) {
24 DiagnosticsEngine &Diags = CGF.CGM.getDiags();
25 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
26 "cannot yet compile %0 in this ABI");
27 Diags.Report(CGF.getContext().getFullLoc(CGF.CurCodeDecl->getLocation()),
28 DiagID)
29 << S;
30 }
31
GetBogusMemberPointer(QualType T)32 llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) {
33 return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
34 }
35
36 llvm::Type *
ConvertMemberPointerType(const MemberPointerType * MPT)37 CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
38 return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
39 }
40
EmitLoadOfMemberFunctionPointer(CodeGenFunction & CGF,const Expr * E,Address This,llvm::Value * & ThisPtrForCall,llvm::Value * MemPtr,const MemberPointerType * MPT)41 CGCallee CGCXXABI::EmitLoadOfMemberFunctionPointer(
42 CodeGenFunction &CGF, const Expr *E, Address This,
43 llvm::Value *&ThisPtrForCall,
44 llvm::Value *MemPtr, const MemberPointerType *MPT) {
45 ErrorUnsupportedABI(CGF, "calls through member pointers");
46
47 ThisPtrForCall = This.getPointer();
48 const FunctionProtoType *FPT =
49 MPT->getPointeeType()->getAs<FunctionProtoType>();
50 const auto *RD =
51 cast<CXXRecordDecl>(MPT->getClass()->castAs<RecordType>()->getDecl());
52 llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
53 CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr));
54 unsigned AS = CGM.getTargetCodeGenInfo().getDefaultAS();
55 llvm::Constant *FnPtr = llvm::Constant::getNullValue(FTy->getPointerTo(AS));
56 return CGCallee::forDirect(FnPtr, FPT);
57 }
58
59 llvm::Value *
EmitMemberDataPointerAddress(CodeGenFunction & CGF,const Expr * E,Address Base,llvm::Value * MemPtr,const MemberPointerType * MPT)60 CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
61 Address Base, llvm::Value *MemPtr,
62 const MemberPointerType *MPT) {
63 ErrorUnsupportedABI(CGF, "loads of member pointers");
64 llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())
65 ->getPointerTo(Base.getAddressSpace());
66 return llvm::Constant::getNullValue(Ty);
67 }
68
EmitMemberPointerConversion(CodeGenFunction & CGF,const CastExpr * E,llvm::Value * Src)69 llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
70 const CastExpr *E,
71 llvm::Value *Src) {
72 ErrorUnsupportedABI(CGF, "member function pointer conversions");
73 return GetBogusMemberPointer(E->getType());
74 }
75
EmitMemberPointerConversion(const CastExpr * E,llvm::Constant * Src)76 llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E,
77 llvm::Constant *Src) {
78 return GetBogusMemberPointer(E->getType());
79 }
80
81 llvm::Value *
EmitMemberPointerComparison(CodeGenFunction & CGF,llvm::Value * L,llvm::Value * R,const MemberPointerType * MPT,bool Inequality)82 CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
83 llvm::Value *L,
84 llvm::Value *R,
85 const MemberPointerType *MPT,
86 bool Inequality) {
87 ErrorUnsupportedABI(CGF, "member function pointer comparison");
88 return CGF.Builder.getFalse();
89 }
90
91 llvm::Value *
EmitMemberPointerIsNotNull(CodeGenFunction & CGF,llvm::Value * MemPtr,const MemberPointerType * MPT)92 CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
93 llvm::Value *MemPtr,
94 const MemberPointerType *MPT) {
95 ErrorUnsupportedABI(CGF, "member function pointer null testing");
96 return CGF.Builder.getFalse();
97 }
98
99 llvm::Constant *
EmitNullMemberPointer(const MemberPointerType * MPT)100 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
101 return GetBogusMemberPointer(QualType(MPT, 0));
102 }
103
EmitMemberFunctionPointer(const CXXMethodDecl * MD)104 llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
105 return GetBogusMemberPointer(CGM.getContext().getMemberPointerType(
106 MD->getType(), MD->getParent()->getTypeForDecl()));
107 }
108
EmitMemberDataPointer(const MemberPointerType * MPT,CharUnits offset)109 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
110 CharUnits offset) {
111 return GetBogusMemberPointer(QualType(MPT, 0));
112 }
113
EmitMemberPointer(const APValue & MP,QualType MPT)114 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
115 return GetBogusMemberPointer(MPT);
116 }
117
isZeroInitializable(const MemberPointerType * MPT)118 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
119 // Fake answer.
120 return true;
121 }
122
buildThisParam(CodeGenFunction & CGF,FunctionArgList & params)123 void CGCXXABI::buildThisParam(CodeGenFunction &CGF, FunctionArgList ¶ms) {
124 const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
125
126 // FIXME: I'm not entirely sure I like using a fake decl just for code
127 // generation. Maybe we can come up with a better way?
128 auto *ThisDecl = ImplicitParamDecl::Create(
129 CGM.getContext(), nullptr, MD->getLocation(),
130 &CGM.getContext().Idents.get("this"), MD->getThisType(),
131 ImplicitParamDecl::CXXThis);
132 params.push_back(ThisDecl);
133 CGF.CXXABIThisDecl = ThisDecl;
134
135 // Compute the presumed alignment of 'this', which basically comes
136 // down to whether we know it's a complete object or not.
137 auto &Layout = CGF.getContext().getASTRecordLayout(MD->getParent());
138 if (MD->getParent()->getNumVBases() == 0 || // avoid vcall in common case
139 MD->getParent()->hasAttr<FinalAttr>() ||
140 !isThisCompleteObject(CGF.CurGD)) {
141 CGF.CXXABIThisAlignment = Layout.getAlignment();
142 } else {
143 CGF.CXXABIThisAlignment = Layout.getNonVirtualAlignment();
144 }
145 }
146
loadIncomingCXXThis(CodeGenFunction & CGF)147 llvm::Value *CGCXXABI::loadIncomingCXXThis(CodeGenFunction &CGF) {
148 return CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
149 "this");
150 }
151
setCXXABIThisValue(CodeGenFunction & CGF,llvm::Value * ThisPtr)152 void CGCXXABI::setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr) {
153 /// Initialize the 'this' slot.
154 assert(getThisDecl(CGF) && "no 'this' variable for function");
155 CGF.CXXABIThisValue = ThisPtr;
156 }
157
EmitReturnFromThunk(CodeGenFunction & CGF,RValue RV,QualType ResultType)158 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
159 RValue RV, QualType ResultType) {
160 assert(!CGF.hasAggregateEvaluationKind(ResultType) &&
161 "cannot handle aggregates");
162 CGF.EmitReturnOfRValue(RV, ResultType);
163 }
164
GetArrayCookieSize(const CXXNewExpr * expr)165 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
166 if (!requiresArrayCookie(expr))
167 return CharUnits::Zero();
168 return getArrayCookieSizeImpl(expr->getAllocatedType());
169 }
170
getArrayCookieSizeImpl(QualType elementType)171 CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
172 // BOGUS
173 return CharUnits::Zero();
174 }
175
InitializeArrayCookie(CodeGenFunction & CGF,Address NewPtr,llvm::Value * NumElements,const CXXNewExpr * expr,QualType ElementType)176 Address CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
177 Address NewPtr,
178 llvm::Value *NumElements,
179 const CXXNewExpr *expr,
180 QualType ElementType) {
181 // Should never be called.
182 ErrorUnsupportedABI(CGF, "array cookie initialization");
183 return Address::invalid();
184 }
185
requiresArrayCookie(const CXXDeleteExpr * expr,QualType elementType)186 bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
187 QualType elementType) {
188 // If the class's usual deallocation function takes two arguments,
189 // it needs a cookie.
190 if (expr->doesUsualArrayDeleteWantSize())
191 return true;
192
193 return elementType.isDestructedType();
194 }
195
requiresArrayCookie(const CXXNewExpr * expr)196 bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
197 // If the class's usual deallocation function takes two arguments,
198 // it needs a cookie.
199 if (expr->doesUsualArrayDeleteWantSize())
200 return true;
201
202 return expr->getAllocatedType().isDestructedType();
203 }
204
ReadArrayCookie(CodeGenFunction & CGF,Address ptr,const CXXDeleteExpr * expr,QualType eltTy,llvm::Value * & numElements,llvm::Value * & allocPtr,CharUnits & cookieSize)205 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, Address ptr,
206 const CXXDeleteExpr *expr, QualType eltTy,
207 llvm::Value *&numElements,
208 llvm::Value *&allocPtr, CharUnits &cookieSize) {
209 // Derive a char* in the same address space as the pointer.
210 ptr = CGF.Builder.CreateElementBitCast(ptr, CGF.Int8Ty);
211
212 // If we don't need an array cookie, bail out early.
213 if (!requiresArrayCookie(expr, eltTy)) {
214 allocPtr = ptr.getPointer();
215 numElements = nullptr;
216 cookieSize = CharUnits::Zero();
217 return;
218 }
219
220 cookieSize = getArrayCookieSizeImpl(eltTy);
221 Address allocAddr =
222 CGF.Builder.CreateConstInBoundsByteGEP(ptr, -cookieSize);
223 allocPtr = allocAddr.getPointer();
224 numElements = readArrayCookieImpl(CGF, allocAddr, cookieSize);
225 }
226
readArrayCookieImpl(CodeGenFunction & CGF,Address ptr,CharUnits cookieSize)227 llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
228 Address ptr,
229 CharUnits cookieSize) {
230 ErrorUnsupportedABI(CGF, "reading a new[] cookie");
231 return llvm::ConstantInt::get(CGF.SizeTy, 0);
232 }
233
234 /// Returns the adjustment, in bytes, required for the given
235 /// member-pointer operation. Returns null if no adjustment is
236 /// required.
getMemberPointerAdjustment(const CastExpr * E)237 llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
238 assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
239 E->getCastKind() == CK_BaseToDerivedMemberPointer);
240
241 QualType derivedType;
242 if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
243 derivedType = E->getSubExpr()->getType();
244 else
245 derivedType = E->getType();
246
247 const CXXRecordDecl *derivedClass =
248 derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
249
250 return CGM.GetNonVirtualBaseClassOffset(derivedClass,
251 E->path_begin(),
252 E->path_end());
253 }
254
getMemberPointerPathAdjustment(const APValue & MP)255 CharUnits CGCXXABI::getMemberPointerPathAdjustment(const APValue &MP) {
256 // TODO: Store base specifiers in APValue member pointer paths so we can
257 // easily reuse CGM.GetNonVirtualBaseClassOffset().
258 const ValueDecl *MPD = MP.getMemberPointerDecl();
259 CharUnits ThisAdjustment = CharUnits::Zero();
260 ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath();
261 bool DerivedMember = MP.isMemberPointerToDerivedMember();
262 const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
263 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
264 const CXXRecordDecl *Base = RD;
265 const CXXRecordDecl *Derived = Path[I];
266 if (DerivedMember)
267 std::swap(Base, Derived);
268 ThisAdjustment +=
269 getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base);
270 RD = Path[I];
271 }
272 if (DerivedMember)
273 ThisAdjustment = -ThisAdjustment;
274 return ThisAdjustment;
275 }
276
277 llvm::BasicBlock *
EmitCtorCompleteObjectHandler(CodeGenFunction & CGF,const CXXRecordDecl * RD)278 CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
279 const CXXRecordDecl *RD) {
280 if (CGM.getTarget().getCXXABI().hasConstructorVariants())
281 llvm_unreachable("shouldn't be called in this ABI");
282
283 ErrorUnsupportedABI(CGF, "complete object detection in ctor");
284 return nullptr;
285 }
286
setCXXDestructorDLLStorage(llvm::GlobalValue * GV,const CXXDestructorDecl * Dtor,CXXDtorType DT) const287 void CGCXXABI::setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
288 const CXXDestructorDecl *Dtor,
289 CXXDtorType DT) const {
290 // Assume the base C++ ABI has no special rules for destructor variants.
291 CGM.setDLLImportDLLExport(GV, Dtor);
292 }
293
getCXXDestructorLinkage(GVALinkage Linkage,const CXXDestructorDecl * Dtor,CXXDtorType DT) const294 llvm::GlobalValue::LinkageTypes CGCXXABI::getCXXDestructorLinkage(
295 GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const {
296 // Delegate back to CGM by default.
297 return CGM.getLLVMLinkageForDeclarator(Dtor, Linkage,
298 /*IsConstantVariable=*/false);
299 }
300
NeedsVTTParameter(GlobalDecl GD)301 bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {
302 return false;
303 }
304
305 llvm::CallInst *
emitTerminateForUnexpectedException(CodeGenFunction & CGF,llvm::Value * Exn)306 CGCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
307 llvm::Value *Exn) {
308 // Just call std::terminate and ignore the violating exception.
309 return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
310 }
311
getCatchAllTypeInfo()312 CatchTypeInfo CGCXXABI::getCatchAllTypeInfo() {
313 return CatchTypeInfo{nullptr, 0};
314 }
315
getVBPtrOffsets(const CXXRecordDecl * RD)316 std::vector<CharUnits> CGCXXABI::getVBPtrOffsets(const CXXRecordDecl *RD) {
317 return std::vector<CharUnits>();
318 }
319
addImplicitConstructorArgs(CodeGenFunction & CGF,const CXXConstructorDecl * D,CXXCtorType Type,bool ForVirtualBase,bool Delegating,CallArgList & Args)320 CGCXXABI::AddedStructorArgCounts CGCXXABI::addImplicitConstructorArgs(
321 CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type,
322 bool ForVirtualBase, bool Delegating, CallArgList &Args) {
323 AddedStructorArgs AddedArgs =
324 getImplicitConstructorArgs(CGF, D, Type, ForVirtualBase, Delegating);
325 for (size_t i = 0; i < AddedArgs.Prefix.size(); ++i) {
326 Args.insert(Args.begin() + 1 + i,
327 CallArg(RValue::get(AddedArgs.Prefix[i].Value),
328 AddedArgs.Prefix[i].Type));
329 }
330 for (const auto &arg : AddedArgs.Suffix) {
331 Args.add(RValue::get(arg.Value), arg.Type);
332 }
333 return AddedStructorArgCounts(AddedArgs.Prefix.size(),
334 AddedArgs.Suffix.size());
335 }
336