Home | History | Annotate | Download | only in CodeGen 
      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::EmitMemberPointer(const CXXMethodDecl *MD) {
    134   return GetBogusMemberPointer(
    135                          CGM.getContext().getMemberPointerType(MD->getType(),
    136                                          MD->getParent()->getTypeForDecl()));
    137 }
    138 
    139 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
    140                                                 CharUnits offset) {
    141   return GetBogusMemberPointer(QualType(MPT, 0));
    142 }
    143 
    144 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
    145   return GetBogusMemberPointer(MPT);
    146 }
    147 
    148 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
    149   // Fake answer.
    150   return true;
    151 }
    152 
    153 void CGCXXABI::buildThisParam(CodeGenFunction &CGF, FunctionArgList &params) {
    154   const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
    155 
    156   // FIXME: I'm not entirely sure I like using a fake decl just for code
    157   // generation. Maybe we can come up with a better way?
    158   ImplicitParamDecl *ThisDecl
    159     = ImplicitParamDecl::Create(CGM.getContext(), nullptr, MD->getLocation(),
    160                                 &CGM.getContext().Idents.get("this"),
    161                                 MD->getThisType(CGM.getContext()));
    162   params.push_back(ThisDecl);
    163   getThisDecl(CGF) = ThisDecl;
    164 }
    165 
    166 void CGCXXABI::EmitThisParam(CodeGenFunction &CGF) {
    167   /// Initialize the 'this' slot.
    168   assert(getThisDecl(CGF) && "no 'this' variable for function");
    169   getThisValue(CGF)
    170     = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
    171                              "this");
    172 }
    173 
    174 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
    175                                    RValue RV, QualType ResultType) {
    176   CGF.EmitReturnOfRValue(RV, ResultType);
    177 }
    178 
    179 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
    180   if (!requiresArrayCookie(expr))
    181     return CharUnits::Zero();
    182   return getArrayCookieSizeImpl(expr->getAllocatedType());
    183 }
    184 
    185 CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
    186   // BOGUS
    187   return CharUnits::Zero();
    188 }
    189 
    190 llvm::Value *CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
    191                                              llvm::Value *NewPtr,
    192                                              llvm::Value *NumElements,
    193                                              const CXXNewExpr *expr,
    194                                              QualType ElementType) {
    195   // Should never be called.
    196   ErrorUnsupportedABI(CGF, "array cookie initialization");
    197   return nullptr;
    198 }
    199 
    200 bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
    201                                    QualType elementType) {
    202   // If the class's usual deallocation function takes two arguments,
    203   // it needs a cookie.
    204   if (expr->doesUsualArrayDeleteWantSize())
    205     return true;
    206 
    207   return elementType.isDestructedType();
    208 }
    209 
    210 bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
    211   // If the class's usual deallocation function takes two arguments,
    212   // it needs a cookie.
    213   if (expr->doesUsualArrayDeleteWantSize())
    214     return true;
    215 
    216   return expr->getAllocatedType().isDestructedType();
    217 }
    218 
    219 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, llvm::Value *ptr,
    220                                const CXXDeleteExpr *expr, QualType eltTy,
    221                                llvm::Value *&numElements,
    222                                llvm::Value *&allocPtr, CharUnits &cookieSize) {
    223   // Derive a char* in the same address space as the pointer.
    224   unsigned AS = ptr->getType()->getPointerAddressSpace();
    225   llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS);
    226   ptr = CGF.Builder.CreateBitCast(ptr, charPtrTy);
    227 
    228   // If we don't need an array cookie, bail out early.
    229   if (!requiresArrayCookie(expr, eltTy)) {
    230     allocPtr = ptr;
    231     numElements = nullptr;
    232     cookieSize = CharUnits::Zero();
    233     return;
    234   }
    235 
    236   cookieSize = getArrayCookieSizeImpl(eltTy);
    237   allocPtr = CGF.Builder.CreateConstInBoundsGEP1_64(ptr,
    238                                                     -cookieSize.getQuantity());
    239   numElements = readArrayCookieImpl(CGF, allocPtr, cookieSize);
    240 }
    241 
    242 llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
    243                                            llvm::Value *ptr,
    244                                            CharUnits cookieSize) {
    245   ErrorUnsupportedABI(CGF, "reading a new[] cookie");
    246   return llvm::ConstantInt::get(CGF.SizeTy, 0);
    247 }
    248 
    249 /// Returns the adjustment, in bytes, required for the given
    250 /// member-pointer operation.  Returns null if no adjustment is
    251 /// required.
    252 llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
    253   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
    254          E->getCastKind() == CK_BaseToDerivedMemberPointer);
    255 
    256   QualType derivedType;
    257   if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
    258     derivedType = E->getSubExpr()->getType();
    259   else
    260     derivedType = E->getType();
    261 
    262   const CXXRecordDecl *derivedClass =
    263     derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
    264 
    265   return CGM.GetNonVirtualBaseClassOffset(derivedClass,
    266                                           E->path_begin(),
    267                                           E->path_end());
    268 }
    269 
    270 CharUnits CGCXXABI::getMemberPointerPathAdjustment(const APValue &MP) {
    271   // TODO: Store base specifiers in APValue member pointer paths so we can
    272   // easily reuse CGM.GetNonVirtualBaseClassOffset().
    273   const ValueDecl *MPD = MP.getMemberPointerDecl();
    274   CharUnits ThisAdjustment = CharUnits::Zero();
    275   ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath();
    276   bool DerivedMember = MP.isMemberPointerToDerivedMember();
    277   const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
    278   for (unsigned I = 0, N = Path.size(); I != N; ++I) {
    279     const CXXRecordDecl *Base = RD;
    280     const CXXRecordDecl *Derived = Path[I];
    281     if (DerivedMember)
    282       std::swap(Base, Derived);
    283     ThisAdjustment +=
    284       getContext().getASTRecordLayout(Derived).getBaseClassOffset(Base);
    285     RD = Path[I];
    286   }
    287   if (DerivedMember)
    288     ThisAdjustment = -ThisAdjustment;
    289   return ThisAdjustment;
    290 }
    291 
    292 llvm::BasicBlock *
    293 CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
    294                                         const CXXRecordDecl *RD) {
    295   if (CGM.getTarget().getCXXABI().hasConstructorVariants())
    296     llvm_unreachable("shouldn't be called in this ABI");
    297 
    298   ErrorUnsupportedABI(CGF, "complete object detection in ctor");
    299   return nullptr;
    300 }
    301 
    302 bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {
    303   return false;
    304 }
    305 
    306 llvm::CallInst *
    307 CGCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
    308                                               llvm::Value *Exn) {
    309   // Just call std::terminate and ignore the violating exception.
    310   return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
    311 }
    312