Nick Lewycky | 5d4a755 | 2013-10-01 21:51:38 +0000 | [diff] [blame] | 1 | //===----- CGCXXABI.cpp - Interface to C++ ABIs ---------------------------===// |
Anders Carlsson | 4992eaf | 2010-11-28 17:46:52 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This provides an abstract class for C++ code generation. Concrete subclasses |
| 11 | // of this implement code generation for specific C++ ABIs. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #include "CGCXXABI.h" |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 16 | #include "CGCleanup.h" |
Anders Carlsson | 4992eaf | 2010-11-28 17:46:52 +0000 | [diff] [blame] | 17 | |
| 18 | using namespace clang; |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 19 | using namespace CodeGen; |
Anders Carlsson | 4992eaf | 2010-11-28 17:46:52 +0000 | [diff] [blame] | 20 | |
Anders Carlsson | 1af610f | 2010-11-28 17:50:09 +0000 | [diff] [blame] | 21 | CGCXXABI::~CGCXXABI() { } |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 22 | |
Reid Kleckner | a8a0f76 | 2013-03-22 19:02:54 +0000 | [diff] [blame] | 23 | void CGCXXABI::ErrorUnsupportedABI(CodeGenFunction &CGF, StringRef S) { |
David Blaikie | d6471f7 | 2011-09-25 23:23:43 +0000 | [diff] [blame] | 24 | DiagnosticsEngine &Diags = CGF.CGM.getDiags(); |
| 25 | unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, |
Timur Iskhodzhanov | c56b552 | 2012-06-29 01:14:21 +0000 | [diff] [blame] | 26 | "cannot yet compile %0 in this ABI"); |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 27 | Diags.Report(CGF.getContext().getFullLoc(CGF.CurCodeDecl->getLocation()), |
| 28 | DiagID) |
| 29 | << S; |
| 30 | } |
| 31 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 32 | bool CGCXXABI::canCopyArgument(const CXXRecordDecl *RD) const { |
| 33 | // If RD has a non-trivial move or copy constructor, we cannot copy the |
| 34 | // argument. |
| 35 | if (RD->hasNonTrivialCopyConstructor() || RD->hasNonTrivialMoveConstructor()) |
| 36 | return false; |
| 37 | |
| 38 | // If RD has a non-trivial destructor, we cannot copy the argument. |
| 39 | if (RD->hasNonTrivialDestructor()) |
| 40 | return false; |
| 41 | |
| 42 | // We can only copy the argument if there exists at least one trivial, |
| 43 | // non-deleted copy or move constructor. |
| 44 | // FIXME: This assumes that all lazily declared copy and move constructors are |
| 45 | // not deleted. This assumption might not be true in some corner cases. |
| 46 | bool CopyDeleted = false; |
| 47 | bool MoveDeleted = false; |
| 48 | for (const CXXConstructorDecl *CD : RD->ctors()) { |
| 49 | if (CD->isCopyConstructor() || CD->isMoveConstructor()) { |
| 50 | assert(CD->isTrivial()); |
| 51 | // We had at least one undeleted trivial copy or move ctor. Return |
| 52 | // directly. |
| 53 | if (!CD->isDeleted()) |
| 54 | return true; |
| 55 | if (CD->isCopyConstructor()) |
| 56 | CopyDeleted = true; |
| 57 | else |
| 58 | MoveDeleted = true; |
| 59 | } |
| 60 | } |
| 61 | |
| 62 | // If all trivial copy and move constructors are deleted, we cannot copy the |
| 63 | // argument. |
| 64 | return !(CopyDeleted && MoveDeleted); |
| 65 | } |
| 66 | |
Reid Kleckner | a8a0f76 | 2013-03-22 19:02:54 +0000 | [diff] [blame] | 67 | llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) { |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 68 | return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T)); |
| 69 | } |
| 70 | |
Chris Lattner | 9cbe4f0 | 2011-07-09 17:41:47 +0000 | [diff] [blame] | 71 | llvm::Type * |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 72 | CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) { |
| 73 | return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType()); |
| 74 | } |
| 75 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 76 | llvm::Value *CGCXXABI::EmitLoadOfMemberFunctionPointer( |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 77 | CodeGenFunction &CGF, const Expr *E, Address This, |
| 78 | llvm::Value *&ThisPtrForCall, |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 79 | llvm::Value *MemPtr, const MemberPointerType *MPT) { |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 80 | ErrorUnsupportedABI(CGF, "calls through member pointers"); |
| 81 | |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 82 | ThisPtrForCall = This.getPointer(); |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 83 | const FunctionProtoType *FPT = |
| 84 | MPT->getPointeeType()->getAs<FunctionProtoType>(); |
| 85 | const CXXRecordDecl *RD = |
| 86 | cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl()); |
John McCall | de5d3c7 | 2012-02-17 03:33:10 +0000 | [diff] [blame] | 87 | llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType( |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 88 | CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr)); |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 89 | return llvm::Constant::getNullValue(FTy->getPointerTo()); |
| 90 | } |
| 91 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 92 | llvm::Value * |
| 93 | CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E, |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 94 | Address Base, llvm::Value *MemPtr, |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 95 | const MemberPointerType *MPT) { |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 96 | ErrorUnsupportedABI(CGF, "loads of member pointers"); |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 97 | llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType()) |
| 98 | ->getPointerTo(Base.getAddressSpace()); |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 99 | return llvm::Constant::getNullValue(Ty); |
| 100 | } |
| 101 | |
| 102 | llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF, |
| 103 | const CastExpr *E, |
| 104 | llvm::Value *Src) { |
| 105 | ErrorUnsupportedABI(CGF, "member function pointer conversions"); |
Reid Kleckner | a8a0f76 | 2013-03-22 19:02:54 +0000 | [diff] [blame] | 106 | return GetBogusMemberPointer(E->getType()); |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 107 | } |
| 108 | |
John McCall | 4d4e5c1 | 2012-02-15 01:22:51 +0000 | [diff] [blame] | 109 | llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E, |
| 110 | llvm::Constant *Src) { |
Reid Kleckner | a8a0f76 | 2013-03-22 19:02:54 +0000 | [diff] [blame] | 111 | return GetBogusMemberPointer(E->getType()); |
John McCall | 4d4e5c1 | 2012-02-15 01:22:51 +0000 | [diff] [blame] | 112 | } |
| 113 | |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 114 | llvm::Value * |
| 115 | CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF, |
| 116 | llvm::Value *L, |
| 117 | llvm::Value *R, |
| 118 | const MemberPointerType *MPT, |
| 119 | bool Inequality) { |
| 120 | ErrorUnsupportedABI(CGF, "member function pointer comparison"); |
| 121 | return CGF.Builder.getFalse(); |
| 122 | } |
| 123 | |
| 124 | llvm::Value * |
| 125 | CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF, |
| 126 | llvm::Value *MemPtr, |
| 127 | const MemberPointerType *MPT) { |
| 128 | ErrorUnsupportedABI(CGF, "member function pointer null testing"); |
| 129 | return CGF.Builder.getFalse(); |
| 130 | } |
| 131 | |
| 132 | llvm::Constant * |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 133 | CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) { |
Reid Kleckner | a8a0f76 | 2013-03-22 19:02:54 +0000 | [diff] [blame] | 134 | return GetBogusMemberPointer(QualType(MPT, 0)); |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 135 | } |
| 136 | |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 137 | llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) { |
| 138 | return GetBogusMemberPointer(CGM.getContext().getMemberPointerType( |
| 139 | MD->getType(), MD->getParent()->getTypeForDecl())); |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 140 | } |
| 141 | |
John McCall | 5808ce4 | 2011-02-03 08:15:49 +0000 | [diff] [blame] | 142 | llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT, |
| 143 | CharUnits offset) { |
Reid Kleckner | a8a0f76 | 2013-03-22 19:02:54 +0000 | [diff] [blame] | 144 | return GetBogusMemberPointer(QualType(MPT, 0)); |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 145 | } |
| 146 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 147 | llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) { |
Reid Kleckner | a8a0f76 | 2013-03-22 19:02:54 +0000 | [diff] [blame] | 148 | return GetBogusMemberPointer(MPT); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 149 | } |
| 150 | |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 151 | bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) { |
| 152 | // Fake answer. |
| 153 | return true; |
| 154 | } |
| 155 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 156 | void CGCXXABI::buildThisParam(CodeGenFunction &CGF, FunctionArgList ¶ms) { |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 157 | const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl()); |
| 158 | |
| 159 | // FIXME: I'm not entirely sure I like using a fake decl just for code |
| 160 | // generation. Maybe we can come up with a better way? |
| 161 | ImplicitParamDecl *ThisDecl |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 162 | = ImplicitParamDecl::Create(CGM.getContext(), nullptr, MD->getLocation(), |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 163 | &CGM.getContext().Idents.get("this"), |
| 164 | MD->getThisType(CGM.getContext())); |
John McCall | d26bc76 | 2011-03-09 04:27:21 +0000 | [diff] [blame] | 165 | params.push_back(ThisDecl); |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 166 | CGF.CXXABIThisDecl = ThisDecl; |
| 167 | |
| 168 | // Compute the presumed alignment of 'this', which basically comes |
| 169 | // down to whether we know it's a complete object or not. |
| 170 | auto &Layout = CGF.getContext().getASTRecordLayout(MD->getParent()); |
| 171 | if (MD->getParent()->getNumVBases() == 0 || // avoid vcall in common case |
| 172 | MD->getParent()->hasAttr<FinalAttr>() || |
| 173 | !isThisCompleteObject(CGF.CurGD)) { |
| 174 | CGF.CXXABIThisAlignment = Layout.getAlignment(); |
| 175 | } else { |
| 176 | CGF.CXXABIThisAlignment = Layout.getNonVirtualAlignment(); |
| 177 | } |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 178 | } |
| 179 | |
| 180 | void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) { |
| 181 | /// Initialize the 'this' slot. |
| 182 | assert(getThisDecl(CGF) && "no 'this' variable for function"); |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 183 | CGF.CXXABIThisValue |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 184 | = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)), |
| 185 | "this"); |
| 186 | } |
| 187 | |
| 188 | void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF, |
| 189 | RValue RV, QualType ResultType) { |
| 190 | CGF.EmitReturnOfRValue(RV, ResultType); |
| 191 | } |
| 192 | |
John McCall | 6ec278d | 2011-01-27 09:37:56 +0000 | [diff] [blame] | 193 | CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) { |
John McCall | e2b45e2 | 2012-05-01 05:23:51 +0000 | [diff] [blame] | 194 | if (!requiresArrayCookie(expr)) |
| 195 | return CharUnits::Zero(); |
| 196 | return getArrayCookieSizeImpl(expr->getAllocatedType()); |
| 197 | } |
| 198 | |
| 199 | CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) { |
| 200 | // BOGUS |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 201 | return CharUnits::Zero(); |
| 202 | } |
| 203 | |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 204 | Address CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF, |
| 205 | Address NewPtr, |
| 206 | llvm::Value *NumElements, |
| 207 | const CXXNewExpr *expr, |
| 208 | QualType ElementType) { |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 209 | // Should never be called. |
| 210 | ErrorUnsupportedABI(CGF, "array cookie initialization"); |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 211 | return Address::invalid(); |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 212 | } |
| 213 | |
John McCall | e2b45e2 | 2012-05-01 05:23:51 +0000 | [diff] [blame] | 214 | bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr, |
| 215 | QualType elementType) { |
| 216 | // If the class's usual deallocation function takes two arguments, |
| 217 | // it needs a cookie. |
| 218 | if (expr->doesUsualArrayDeleteWantSize()) |
| 219 | return true; |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 220 | |
John McCall | e2b45e2 | 2012-05-01 05:23:51 +0000 | [diff] [blame] | 221 | return elementType.isDestructedType(); |
| 222 | } |
| 223 | |
| 224 | bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) { |
| 225 | // If the class's usual deallocation function takes two arguments, |
| 226 | // it needs a cookie. |
| 227 | if (expr->doesUsualArrayDeleteWantSize()) |
| 228 | return true; |
| 229 | |
| 230 | return expr->getAllocatedType().isDestructedType(); |
| 231 | } |
| 232 | |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 233 | void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, Address ptr, |
John McCall | e2b45e2 | 2012-05-01 05:23:51 +0000 | [diff] [blame] | 234 | const CXXDeleteExpr *expr, QualType eltTy, |
| 235 | llvm::Value *&numElements, |
| 236 | llvm::Value *&allocPtr, CharUnits &cookieSize) { |
| 237 | // Derive a char* in the same address space as the pointer. |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 238 | ptr = CGF.Builder.CreateElementBitCast(ptr, CGF.Int8Ty); |
John McCall | e2b45e2 | 2012-05-01 05:23:51 +0000 | [diff] [blame] | 239 | |
| 240 | // If we don't need an array cookie, bail out early. |
| 241 | if (!requiresArrayCookie(expr, eltTy)) { |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 242 | allocPtr = ptr.getPointer(); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 243 | numElements = nullptr; |
John McCall | e2b45e2 | 2012-05-01 05:23:51 +0000 | [diff] [blame] | 244 | cookieSize = CharUnits::Zero(); |
| 245 | return; |
| 246 | } |
| 247 | |
| 248 | cookieSize = getArrayCookieSizeImpl(eltTy); |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 249 | Address allocAddr = |
| 250 | CGF.Builder.CreateConstInBoundsByteGEP(ptr, -cookieSize); |
| 251 | allocPtr = allocAddr.getPointer(); |
| 252 | numElements = readArrayCookieImpl(CGF, allocAddr, cookieSize); |
John McCall | e2b45e2 | 2012-05-01 05:23:51 +0000 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF, |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 256 | Address ptr, |
John McCall | e2b45e2 | 2012-05-01 05:23:51 +0000 | [diff] [blame] | 257 | CharUnits cookieSize) { |
| 258 | ErrorUnsupportedABI(CGF, "reading a new[] cookie"); |
| 259 | return llvm::ConstantInt::get(CGF.SizeTy, 0); |
Anders Carlsson | ee7cde2 | 2010-11-28 17:49:03 +0000 | [diff] [blame] | 260 | } |
| 261 | |
John McCall | 4d4e5c1 | 2012-02-15 01:22:51 +0000 | [diff] [blame] | 262 | /// Returns the adjustment, in bytes, required for the given |
| 263 | /// member-pointer operation. Returns null if no adjustment is |
| 264 | /// required. |
| 265 | llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) { |
| 266 | assert(E->getCastKind() == CK_DerivedToBaseMemberPointer || |
| 267 | E->getCastKind() == CK_BaseToDerivedMemberPointer); |
| 268 | |
| 269 | QualType derivedType; |
| 270 | if (E->getCastKind() == CK_DerivedToBaseMemberPointer) |
| 271 | derivedType = E->getSubExpr()->getType(); |
| 272 | else |
| 273 | derivedType = E->getType(); |
| 274 | |
| 275 | const CXXRecordDecl *derivedClass = |
| 276 | derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl(); |
| 277 | |
| 278 | return CGM.GetNonVirtualBaseClassOffset(derivedClass, |
| 279 | E->path_begin(), |
| 280 | E->path_end()); |
| 281 | } |
Timur Iskhodzhanov | 1d4fff5 | 2013-02-27 13:46:31 +0000 | [diff] [blame] | 282 | |
Reid Kleckner | f632730 | 2013-05-09 21:01:17 +0000 | [diff] [blame] | 283 | CharUnits CGCXXABI::getMemberPointerPathAdjustment(const APValue &MP) { |
| 284 | // TODO: Store base specifiers in APValue member pointer paths so we can |
| 285 | // easily reuse CGM.GetNonVirtualBaseClassOffset(). |
| 286 | const ValueDecl *MPD = MP.getMemberPointerDecl(); |
| 287 | CharUnits ThisAdjustment = CharUnits::Zero(); |
| 288 | ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath(); |
| 289 | bool DerivedMember = MP.isMemberPointerToDerivedMember(); |
| 290 | const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext()); |
| 291 | for (unsigned I = 0, N = Path.size(); I != N; ++I) { |
| 292 | const CXXRecordDecl *Base = RD; |
| 293 | const CXXRecordDecl *Derived = Path[I]; |
| 294 | if (DerivedMember) |
| 295 | std::swap(Base, Derived); |
| 296 | ThisAdjustment += |
| 297 | getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base); |
| 298 | RD = Path[I]; |
| 299 | } |
| 300 | if (DerivedMember) |
| 301 | ThisAdjustment = -ThisAdjustment; |
| 302 | return ThisAdjustment; |
| 303 | } |
| 304 | |
Reid Kleckner | 9063302 | 2013-06-19 15:20:38 +0000 | [diff] [blame] | 305 | llvm::BasicBlock * |
| 306 | CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF, |
| 307 | const CXXRecordDecl *RD) { |
Timur Iskhodzhanov | 1d4fff5 | 2013-02-27 13:46:31 +0000 | [diff] [blame] | 308 | if (CGM.getTarget().getCXXABI().hasConstructorVariants()) |
| 309 | llvm_unreachable("shouldn't be called in this ABI"); |
| 310 | |
| 311 | ErrorUnsupportedABI(CGF, "complete object detection in ctor"); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 312 | return nullptr; |
Timur Iskhodzhanov | 1d4fff5 | 2013-02-27 13:46:31 +0000 | [diff] [blame] | 313 | } |
Richard Smith | b80a16e | 2013-04-19 16:42:07 +0000 | [diff] [blame] | 314 | |
Peter Collingbourne | e1e35f7 | 2013-06-28 20:45:28 +0000 | [diff] [blame] | 315 | bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) { |
| 316 | return false; |
| 317 | } |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 318 | |
| 319 | llvm::CallInst * |
| 320 | CGCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF, |
| 321 | llvm::Value *Exn) { |
| 322 | // Just call std::terminate and ignore the violating exception. |
| 323 | return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn()); |
| 324 | } |
Pirama Arumuga Nainar | 87d948e | 2016-03-03 15:49:35 -0800 | [diff] [blame] | 325 | |
| 326 | CatchTypeInfo CGCXXABI::getCatchAllTypeInfo() { |
| 327 | return CatchTypeInfo{nullptr, 0}; |
| 328 | } |
| 329 | |
| 330 | std::vector<CharUnits> CGCXXABI::getVBPtrOffsets(const CXXRecordDecl *RD) { |
| 331 | return std::vector<CharUnits>(); |
| 332 | } |