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