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