contrib/llvm/tools/clang/lib/CodeGen/CGCXXABI.cpp

   1 //===----- CGCXXABI.cpp - Interface to C++ ABIs ---------------------------===//
   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"
  16
  17 using namespace clang;
  18 using namespace CodeGen;
  19
  20 CGCXXABI::~CGCXXABI() { }
  21
  22 void CGCXXABI::ErrorUnsupportedABI(CodeGenFunction &CGF, StringRef S) {
  23   DiagnosticsEngine &Diags = CGF.CGM.getDiags();
  24   unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  25                                           "cannot yet compile %0 in this ABI");
  26   Diags.Report(CGF.getContext().getFullLoc(CGF.CurCodeDecl->getLocation()),
  27                DiagID)
  28     << S;
  29 }
  30
  31 bool CGCXXABI::canCopyArgument(const CXXRecordDecl *RD) const {
  32   // If RD has a non-trivial move or copy constructor, we cannot copy the
  33   // argument.
  34   if (RD->hasNonTrivialCopyConstructor() || RD->hasNonTrivialMoveConstructor())
  35     return false;
  36
  37   // If RD has a non-trivial destructor, we cannot copy the argument.
  38   if (RD->hasNonTrivialDestructor())
  39     return false;
  40
  41   // We can only copy the argument if there exists at least one trivial,
  42   // non-deleted copy or move constructor.
  43   // FIXME: This assumes that all lazily declared copy and move constructors are
  44   // not deleted.  This assumption might not be true in some corner cases.
  45   bool CopyDeleted = false;
  46   bool MoveDeleted = false;
  47   for (const CXXConstructorDecl *CD : RD->ctors()) {
  48     if (CD->isCopyConstructor() || CD->isMoveConstructor()) {
  49       assert(CD->isTrivial());
  50       // We had at least one undeleted trivial copy or move ctor.  Return
  51       // directly.
  52       if (!CD->isDeleted())
  53         return true;
  54       if (CD->isCopyConstructor())
  55         CopyDeleted = true;
  56       else
  57         MoveDeleted = true;
  58     }
  59   }
  60
  61   // If all trivial copy and move constructors are deleted, we cannot copy the
  62   // argument.
  63   return !(CopyDeleted && MoveDeleted);
  64 }
  65
  66 llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) {
  67   return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
  68 }
  69
  70 llvm::Type *
  71 CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
  72   return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
  73 }
  74
  75 llvm::Value *CGCXXABI::EmitLoadOfMemberFunctionPointer(
  76     CodeGenFunction &CGF, const Expr *E, llvm::Value *&This,
  77     llvm::Value *MemPtr, const MemberPointerType *MPT) {
  78   ErrorUnsupportedABI(CGF, "calls through member pointers");
  79
  80   const FunctionProtoType *FPT =
  81     MPT->getPointeeType()->getAs<FunctionProtoType>();
  82   const CXXRecordDecl *RD =
  83     cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
  84   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
  85                               CGM.getTypes().arrangeCXXMethodType(RD, FPT));
  86   return llvm::Constant::getNullValue(FTy->getPointerTo());
  87 }
  88
  89 llvm::Value *
  90 CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
  91                                        llvm::Value *Base, llvm::Value *MemPtr,
  92                                        const MemberPointerType *MPT) {
  93   ErrorUnsupportedABI(CGF, "loads of member pointers");
  94   llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())->getPointerTo();
  95   return llvm::Constant::getNullValue(Ty);
  96 }
  97
  98 llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
  99                                                    const CastExpr *E,
 100                                                    llvm::Value *Src) {
 101   ErrorUnsupportedABI(CGF, "member function pointer conversions");
 102   return GetBogusMemberPointer(E->getType());
 103 }
 104
 105 llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E,
 106                                                       llvm::Constant *Src) {
 107   return GetBogusMemberPointer(E->getType());
 108 }
 109
 110 llvm::Value *
 111 CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
 112                                       llvm::Value *L,
 113                                       llvm::Value *R,
 114                                       const MemberPointerType *MPT,
 115                                       bool Inequality) {
 116   ErrorUnsupportedABI(CGF, "member function pointer comparison");
 117   return CGF.Builder.getFalse();
 118 }
 119
 120 llvm::Value *
 121 CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
 122                                      llvm::Value *MemPtr,
 123                                      const MemberPointerType *MPT) {
 124   ErrorUnsupportedABI(CGF, "member function pointer null testing");
 125   return CGF.Builder.getFalse();
 126 }
 127
 128 llvm::Constant *
 129 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
 130   return GetBogusMemberPointer(QualType(MPT, 0));
 131 }
 132
 133 llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
 134   return GetBogusMemberPointer(CGM.getContext().getMemberPointerType(
 135       MD->getType(), MD->getParent()->getTypeForDecl()));
 136 }
 137
 138 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
 139                                                 CharUnits offset) {
 140   return GetBogusMemberPointer(QualType(MPT, 0));
 141 }
 142
 143 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
 144   return GetBogusMemberPointer(MPT);
 145 }
 146
 147 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
 148   // Fake answer.
 149   return true;
 150 }
 151
 152 void CGCXXABI::buildThisParam(CodeGenFunction &CGF, FunctionArgList &params) {
 153   const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
 154
 155   // FIXME: I'm not entirely sure I like using a fake decl just for code
 156   // generation. Maybe we can come up with a better way?
 157   ImplicitParamDecl *ThisDecl
 158     = ImplicitParamDecl::Create(CGM.getContext(), nullptr, MD->getLocation(),
 159                                 &CGM.getContext().Idents.get("this"),
 160                                 MD->getThisType(CGM.getContext()));
 161   params.push_back(ThisDecl);
 162   getThisDecl(CGF) = ThisDecl;
 163 }
 164
 165 void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) {
 166   /// Initialize the 'this' slot.
 167   assert(getThisDecl(CGF) && "no 'this' variable for function");
 168   getThisValue(CGF)
 169     = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
 170                              "this");
 171 }
 172
 173 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
 174                                    RValue RV, QualType ResultType) {
 175   CGF.EmitReturnOfRValue(RV, ResultType);
 176 }
 177
 178 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
 179   if (!requiresArrayCookie(expr))
 180     return CharUnits::Zero();
 181   return getArrayCookieSizeImpl(expr->getAllocatedType());
 182 }
 183
 184 CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
 185   // BOGUS
 186   return CharUnits::Zero();
 187 }
 188
 189 llvm::Value *CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
 190                                              llvm::Value *NewPtr,
 191                                              llvm::Value *NumElements,
 192                                              const CXXNewExpr *expr,
 193                                              QualType ElementType) {
 194   // Should never be called.
 195   ErrorUnsupportedABI(CGF, "array cookie initialization");
 196   return nullptr;
 197 }
 198
 199 bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
 200                                    QualType elementType) {
 201   // If the class's usual deallocation function takes two arguments,
 202   // it needs a cookie.
 203   if (expr->doesUsualArrayDeleteWantSize())
 204     return true;
 205
 206   return elementType.isDestructedType();
 207 }
 208
 209 bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
 210   // If the class's usual deallocation function takes two arguments,
 211   // it needs a cookie.
 212   if (expr->doesUsualArrayDeleteWantSize())
 213     return true;
 214
 215   return expr->getAllocatedType().isDestructedType();
 216 }
 217
 218 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *ptr,
 219                                const CXXDeleteExpr *expr, QualType eltTy,
 220                                llvm::Value *&numElements,
 221                                llvm::Value *&allocPtr, CharUnits &cookieSize) {
 222   // Derive a char* in the same address space as the pointer.
 223   unsigned AS = ptr->getType()->getPointerAddressSpace();
 224   llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS);
 225   ptr = CGF.Builder.CreateBitCast(ptr, charPtrTy);
 226
 227   // If we don't need an array cookie, bail out early.
 228   if (!requiresArrayCookie(expr, eltTy)) {
 229     allocPtr = ptr;
 230     numElements = nullptr;
 231     cookieSize = CharUnits::Zero();
 232     return;
 233   }
 234
 235   cookieSize = getArrayCookieSizeImpl(eltTy);
 236   allocPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ptr,
 237                                                     -cookieSize.getQuantity());
 238   numElements = readArrayCookieImpl(CGF, allocPtr, cookieSize);
 239 }
 240
 241 llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
 242                                            llvm::Value *ptr,
 243                                            CharUnits cookieSize) {
 244   ErrorUnsupportedABI(CGF, "reading a new[] cookie");
 245   return llvm::ConstantInt::get(CGF.SizeTy, 0);
 246 }
 247
 248 /// Returns the adjustment, in bytes, required for the given
 249 /// member-pointer operation.  Returns null if no adjustment is
 250 /// required.
 251 llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
 252   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
 253          E->getCastKind() == CK_BaseToDerivedMemberPointer);
 254
 255   QualType derivedType;
 256   if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
 257     derivedType = E->getSubExpr()->getType();
 258   else
 259     derivedType = E->getType();
 260
 261   const CXXRecordDecl *derivedClass =
 262     derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
 263
 264   return CGM.GetNonVirtualBaseClassOffset(derivedClass,
 265                                           E->path_begin(),
 266                                           E->path_end());
 267 }
 268
 269 CharUnits CGCXXABI::getMemberPointerPathAdjustment(const APValue &MP) {
 270   // TODO: Store base specifiers in APValue member pointer paths so we can
 271   // easily reuse CGM.GetNonVirtualBaseClassOffset().
 272   const ValueDecl *MPD = MP.getMemberPointerDecl();
 273   CharUnits ThisAdjustment = CharUnits::Zero();
 274   ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath();
 275   bool DerivedMember = MP.isMemberPointerToDerivedMember();
 276   const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
 277   for (unsigned I = 0, N = Path.size(); I != N; ++I) {
 278     const CXXRecordDecl *Base = RD;
 279     const CXXRecordDecl *Derived = Path[I];
 280     if (DerivedMember)
 281       std::swap(Base, Derived);
 282     ThisAdjustment +=
 283       getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base);
 284     RD = Path[I];
 285   }
 286   if (DerivedMember)
 287     ThisAdjustment = -ThisAdjustment;
 288   return ThisAdjustment;
 289 }
 290
 291 llvm::BasicBlock *
 292 CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
 293                                         const CXXRecordDecl *RD) {
 294   if (CGM.getTarget().getCXXABI().hasConstructorVariants())
 295     llvm_unreachable("shouldn't be called in this ABI");
 296
 297   ErrorUnsupportedABI(CGF, "complete object detection in ctor");
 298   return nullptr;
 299 }
 300
 301 bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {
 302   return false;
 303 }
 304
 305 llvm::CallInst *
 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 }