clang/lib/CodeGen/CGCXXABI.cpp

   1 //===----- CGCXXABI.cpp - Interface to C++ ABIs ---------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This provides an abstract class for C++ code generation. Concrete subclasses
  10 // of this implement code generation for specific C++ ABIs.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CGCXXABI.h"
  15 #include "CGCleanup.h"
  16 #include "clang/AST/Attr.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 llvm::Constant *CGCXXABI::GetBogusMemberPointer(QualType T) {
  33   return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
  34 }
  35
  36 llvm::Type *
  37 CGCXXABI::ConvertMemberPointerType(const MemberPointerType *MPT) {
  38   return CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
  39 }
  40
  41 CGCallee CGCXXABI::EmitLoadOfMemberFunctionPointer(
  42     CodeGenFunction &CGF, const Expr *E, Address This,
  43     llvm::Value *&ThisPtrForCall,
  44     llvm::Value *MemPtr, const MemberPointerType *MPT) {
  45   ErrorUnsupportedABI(CGF, "calls through member pointers");
  46
  47   ThisPtrForCall = This.getPointer();
  48   const auto *FPT = MPT->getPointeeType()->castAs<FunctionProtoType>();
  49   const auto *RD =
  50       cast<CXXRecordDecl>(MPT->getClass()->castAs<RecordType>()->getDecl());
  51   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
  52       CGM.getTypes().arrangeCXXMethodType(RD, FPT, /*FD=*/nullptr));
  53   llvm::Constant *FnPtr = llvm::Constant::getNullValue(FTy->getPointerTo());
  54   return CGCallee::forDirect(FnPtr, FPT);
  55 }
  56
  57 llvm::Value *
  58 CGCXXABI::EmitMemberDataPointerAddress(CodeGenFunction &CGF, const Expr *E,
  59                                        Address Base, llvm::Value *MemPtr,
  60                                        const MemberPointerType *MPT) {
  61   ErrorUnsupportedABI(CGF, "loads of member pointers");
  62   llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())
  63                          ->getPointerTo(Base.getAddressSpace());
  64   return llvm::Constant::getNullValue(Ty);
  65 }
  66
  67 llvm::Value *CGCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
  68                                                    const CastExpr *E,
  69                                                    llvm::Value *Src) {
  70   ErrorUnsupportedABI(CGF, "member function pointer conversions");
  71   return GetBogusMemberPointer(E->getType());
  72 }
  73
  74 llvm::Constant *CGCXXABI::EmitMemberPointerConversion(const CastExpr *E,
  75                                                       llvm::Constant *Src) {
  76   return GetBogusMemberPointer(E->getType());
  77 }
  78
  79 llvm::Value *
  80 CGCXXABI::EmitMemberPointerComparison(CodeGenFunction &CGF,
  81                                       llvm::Value *L,
  82                                       llvm::Value *R,
  83                                       const MemberPointerType *MPT,
  84                                       bool Inequality) {
  85   ErrorUnsupportedABI(CGF, "member function pointer comparison");
  86   return CGF.Builder.getFalse();
  87 }
  88
  89 llvm::Value *
  90 CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
  91                                      llvm::Value *MemPtr,
  92                                      const MemberPointerType *MPT) {
  93   ErrorUnsupportedABI(CGF, "member function pointer null testing");
  94   return CGF.Builder.getFalse();
  95 }
  96
  97 llvm::Constant *
  98 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
  99   return GetBogusMemberPointer(QualType(MPT, 0));
 100 }
 101
 102 llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
 103   return GetBogusMemberPointer(CGM.getContext().getMemberPointerType(
 104       MD->getType(), MD->getParent()->getTypeForDecl()));
 105 }
 106
 107 llvm::Constant *CGCXXABI::EmitMemberDataPointer(const MemberPointerType *MPT,
 108                                                 CharUnits offset) {
 109   return GetBogusMemberPointer(QualType(MPT, 0));
 110 }
 111
 112 llvm::Constant *CGCXXABI::EmitMemberPointer(const APValue &MP, QualType MPT) {
 113   return GetBogusMemberPointer(MPT);
 114 }
 115
 116 bool CGCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
 117   // Fake answer.
 118   return true;
 119 }
 120
 121 void CGCXXABI::buildThisParam(CodeGenFunction &CGF, FunctionArgList &params) {
 122   const CXXMethodDecl *MD = cast<CXXMethodDecl>(CGF.CurGD.getDecl());
 123
 124   // FIXME: I'm not entirely sure I like using a fake decl just for code
 125   // generation. Maybe we can come up with a better way?
 126   auto *ThisDecl = ImplicitParamDecl::Create(
 127       CGM.getContext(), nullptr, MD->getLocation(),
 128       &CGM.getContext().Idents.get("this"), MD->getThisType(),
 129       ImplicitParamDecl::CXXThis);
 130   params.push_back(ThisDecl);
 131   CGF.CXXABIThisDecl = ThisDecl;
 132
 133   // Compute the presumed alignment of 'this', which basically comes
 134   // down to whether we know it's a complete object or not.
 135   auto &Layout = CGF.getContext().getASTRecordLayout(MD->getParent());
 136   if (MD->getParent()->getNumVBases() == 0 || // avoid vcall in common case
 137       MD->getParent()->isEffectivelyFinal() ||
 138       isThisCompleteObject(CGF.CurGD)) {
 139     CGF.CXXABIThisAlignment = Layout.getAlignment();
 140   } else {
 141     CGF.CXXABIThisAlignment = Layout.getNonVirtualAlignment();
 142   }
 143 }
 144
 145 llvm::Value *CGCXXABI::loadIncomingCXXThis(CodeGenFunction &CGF) {
 146   return CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(getThisDecl(CGF)),
 147                                 "this");
 148 }
 149
 150 void CGCXXABI::setCXXABIThisValue(CodeGenFunction &CGF, llvm::Value *ThisPtr) {
 151   /// Initialize the 'this' slot.
 152   assert(getThisDecl(CGF) && "no 'this' variable for function");
 153   CGF.CXXABIThisValue = ThisPtr;
 154 }
 155
 156 bool CGCXXABI::mayNeedDestruction(const VarDecl *VD) const {
 157   if (VD->needsDestruction(getContext()))
 158     return true;
 159
 160   // If the variable has an incomplete class type (or array thereof), it
 161   // might need destruction.
 162   const Type *T = VD->getType()->getBaseElementTypeUnsafe();
 163   if (T->getAs<RecordType>() && T->isIncompleteType())
 164     return true;
 165
 166   return false;
 167 }
 168
 169 bool CGCXXABI::isEmittedWithConstantInitializer(
 170     const VarDecl *VD, bool InspectInitForWeakDef) const {
 171   VD = VD->getMostRecentDecl();
 172   if (VD->hasAttr<ConstInitAttr>())
 173     return true;
 174
 175   // All later checks examine the initializer specified on the variable. If
 176   // the variable is weak, such examination would not be correct.
 177   if (!InspectInitForWeakDef && (VD->isWeak() || VD->hasAttr<SelectAnyAttr>()))
 178     return false;
 179
 180   const VarDecl *InitDecl = VD->getInitializingDeclaration();
 181   if (!InitDecl)
 182     return false;
 183
 184   // If there's no initializer to run, this is constant initialization.
 185   if (!InitDecl->hasInit())
 186     return true;
 187
 188   // If we have the only definition, we don't need a thread wrapper if we
 189   // will emit the value as a constant.
 190   if (isUniqueGVALinkage(getContext().GetGVALinkageForVariable(VD)))
 191     return !mayNeedDestruction(VD) && InitDecl->evaluateValue();
 192
 193   // Otherwise, we need a thread wrapper unless we know that every
 194   // translation unit will emit the value as a constant. We rely on the
 195   // variable being constant-initialized in every translation unit if it's
 196   // constant-initialized in any translation unit, which isn't actually
 197   // guaranteed by the standard but is necessary for sanity.
 198   return InitDecl->hasConstantInitialization();
 199 }
 200
 201 void CGCXXABI::EmitReturnFromThunk(CodeGenFunction &CGF,
 202                                    RValue RV, QualType ResultType) {
 203   assert(!CGF.hasAggregateEvaluationKind(ResultType) &&
 204          "cannot handle aggregates");
 205   CGF.EmitReturnOfRValue(RV, ResultType);
 206 }
 207
 208 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
 209   if (!requiresArrayCookie(expr))
 210     return CharUnits::Zero();
 211   return getArrayCookieSizeImpl(expr->getAllocatedType());
 212 }
 213
 214 CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
 215   // BOGUS
 216   return CharUnits::Zero();
 217 }
 218
 219 Address CGCXXABI::InitializeArrayCookie(CodeGenFunction &CGF,
 220                                         Address NewPtr,
 221                                         llvm::Value *NumElements,
 222                                         const CXXNewExpr *expr,
 223                                         QualType ElementType) {
 224   // Should never be called.
 225   ErrorUnsupportedABI(CGF, "array cookie initialization");
 226   return Address::invalid();
 227 }
 228
 229 bool CGCXXABI::requiresArrayCookie(const CXXDeleteExpr *expr,
 230                                    QualType elementType) {
 231   // If the class's usual deallocation function takes two arguments,
 232   // it needs a cookie.
 233   if (expr->doesUsualArrayDeleteWantSize())
 234     return true;
 235
 236   return elementType.isDestructedType();
 237 }
 238
 239 bool CGCXXABI::requiresArrayCookie(const CXXNewExpr *expr) {
 240   // If the class's usual deallocation function takes two arguments,
 241   // it needs a cookie.
 242   if (expr->doesUsualArrayDeleteWantSize())
 243     return true;
 244
 245   return expr->getAllocatedType().isDestructedType();
 246 }
 247
 248 void CGCXXABI::ReadArrayCookie(CodeGenFunction &CGF, Address ptr,
 249                                const CXXDeleteExpr *expr, QualType eltTy,
 250                                llvm::Value *&numElements,
 251                                llvm::Value *&allocPtr, CharUnits &cookieSize) {
 252   // Derive a char* in the same address space as the pointer.
 253   ptr = CGF.Builder.CreateElementBitCast(ptr, CGF.Int8Ty);
 254
 255   // If we don't need an array cookie, bail out early.
 256   if (!requiresArrayCookie(expr, eltTy)) {
 257     allocPtr = ptr.getPointer();
 258     numElements = nullptr;
 259     cookieSize = CharUnits::Zero();
 260     return;
 261   }
 262
 263   cookieSize = getArrayCookieSizeImpl(eltTy);
 264   Address allocAddr =
 265     CGF.Builder.CreateConstInBoundsByteGEP(ptr, -cookieSize);
 266   allocPtr = allocAddr.getPointer();
 267   numElements = readArrayCookieImpl(CGF, allocAddr, cookieSize);
 268 }
 269
 270 llvm::Value *CGCXXABI::readArrayCookieImpl(CodeGenFunction &CGF,
 271                                            Address ptr,
 272                                            CharUnits cookieSize) {
 273   ErrorUnsupportedABI(CGF, "reading a new[] cookie");
 274   return llvm::ConstantInt::get(CGF.SizeTy, 0);
 275 }
 276
 277 /// Returns the adjustment, in bytes, required for the given
 278 /// member-pointer operation.  Returns null if no adjustment is
 279 /// required.
 280 llvm::Constant *CGCXXABI::getMemberPointerAdjustment(const CastExpr *E) {
 281   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
 282          E->getCastKind() == CK_BaseToDerivedMemberPointer);
 283
 284   QualType derivedType;
 285   if (E->getCastKind() == CK_DerivedToBaseMemberPointer)
 286     derivedType = E->getSubExpr()->getType();
 287   else
 288     derivedType = E->getType();
 289
 290   const CXXRecordDecl *derivedClass =
 291     derivedType->castAs<MemberPointerType>()->getClass()->getAsCXXRecordDecl();
 292
 293   return CGM.GetNonVirtualBaseClassOffset(derivedClass,
 294                                           E->path_begin(),
 295                                           E->path_end());
 296 }
 297
 298 llvm::BasicBlock *
 299 CGCXXABI::EmitCtorCompleteObjectHandler(CodeGenFunction &CGF,
 300                                         const CXXRecordDecl *RD) {
 301   if (CGM.getTarget().getCXXABI().hasConstructorVariants())
 302     llvm_unreachable("shouldn't be called in this ABI");
 303
 304   ErrorUnsupportedABI(CGF, "complete object detection in ctor");
 305   return nullptr;
 306 }
 307
 308 void CGCXXABI::setCXXDestructorDLLStorage(llvm::GlobalValue *GV,
 309                                           const CXXDestructorDecl *Dtor,
 310                                           CXXDtorType DT) const {
 311   // Assume the base C++ ABI has no special rules for destructor variants.
 312   CGM.setDLLImportDLLExport(GV, Dtor);
 313 }
 314
 315 llvm::GlobalValue::LinkageTypes CGCXXABI::getCXXDestructorLinkage(
 316     GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const {
 317   // Delegate back to CGM by default.
 318   return CGM.getLLVMLinkageForDeclarator(Dtor, Linkage,
 319                                          /*IsConstantVariable=*/false);
 320 }
 321
 322 bool CGCXXABI::NeedsVTTParameter(GlobalDecl GD) {
 323   return false;
 324 }
 325
 326 llvm::CallInst *
 327 CGCXXABI::emitTerminateForUnexpectedException(CodeGenFunction &CGF,
 328                                               llvm::Value *Exn) {
 329   // Just call std::terminate and ignore the violating exception.
 330   return CGF.EmitNounwindRuntimeCall(CGF.CGM.getTerminateFn());
 331 }
 332
 333 CatchTypeInfo CGCXXABI::getCatchAllTypeInfo() {
 334   return CatchTypeInfo{nullptr, 0};
 335 }
 336
 337 std::vector<CharUnits> CGCXXABI::getVBPtrOffsets(const CXXRecordDecl *RD) {
 338   return std::vector<CharUnits>();
 339 }
 340
 341 CGCXXABI::AddedStructorArgCounts CGCXXABI::addImplicitConstructorArgs(
 342     CodeGenFunction &CGF, const CXXConstructorDecl *D, CXXCtorType Type,
 343     bool ForVirtualBase, bool Delegating, CallArgList &Args) {
 344   AddedStructorArgs AddedArgs =
 345       getImplicitConstructorArgs(CGF, D, Type, ForVirtualBase, Delegating);
 346   for (size_t i = 0; i < AddedArgs.Prefix.size(); ++i) {
 347     Args.insert(Args.begin() + 1 + i,
 348                 CallArg(RValue::get(AddedArgs.Prefix[i].Value),
 349                         AddedArgs.Prefix[i].Type));
 350   }
 351   for (const auto &arg : AddedArgs.Suffix) {
 352     Args.add(RValue::get(arg.Value), arg.Type);
 353   }
 354   return AddedStructorArgCounts(AddedArgs.Prefix.size(),
 355                                 AddedArgs.Suffix.size());
 356 }