//===--- CGClass.cpp - Emit LLVM Code for C++ classes -----------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This contains code dealing with C++ code generation of classes

//

//===----------------------------------------------------------------------===//

#include "CGBlocks.h"

#include "CGCXXABI.h"

#include "CGDebugInfo.h"

#include "CGRecordLayout.h"

#include "CodeGenFunction.h"

#include "TargetInfo.h"

#include "clang/AST/Attr.h"

#include "clang/AST/CXXInheritance.h"

#include "clang/AST/CharUnits.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/EvaluatedExprVisitor.h"

#include "clang/AST/RecordLayout.h"

#include "clang/AST/StmtCXX.h"

#include "clang/Basic/CodeGenOptions.h"

#include "clang/Basic/TargetBuiltins.h"

#include "clang/CodeGen/CGFunctionInfo.h"

#include "llvm/IR/Intrinsics.h"

#include "llvm/IR/Metadata.h"

#include "llvm/Transforms/Utils/SanitizerStats.h"

using namespace clang;

using namespace CodeGen;

/// Return the best known alignment for an unknown pointer to a

/// particular class.

CharUnits CodeGenModule::getClassPointerAlignment(const CXXRecordDecl *RD) {

  if (!RD->hasDefinition())

    return CharUnits::One(); // Hopefully won't be used anywhere.

  auto &layout = getContext().getASTRecordLayout(RD);

  // If the class is final, then we know that the pointer points to an

  // object of that type and can use the full alignment.

  if (RD->isEffectivelyFinal())

    return layout.getAlignment();

  // Otherwise, we have to assume it could be a subclass.

  return layout.getNonVirtualAlignment();

}

/// Return the smallest possible amount of storage that might be allocated

/// starting from the beginning of an object of a particular class.

///

/// This may be smaller than sizeof(RD) if RD has virtual base classes.

CharUnits CodeGenModule::getMinimumClassObjectSize(const CXXRecordDecl *RD) {

  if (!RD->hasDefinition())

    return CharUnits::One();

  auto &layout = getContext().getASTRecordLayout(RD);

  // If the class is final, then we know that the pointer points to an

  // object of that type and can use the full alignment.

  if (RD->isEffectivelyFinal())

    return layout.getSize();

  // Otherwise, we have to assume it could be a subclass.

  return std::max(layout.getNonVirtualSize(), CharUnits::One());

}

/// Return the best known alignment for a pointer to a virtual base,

/// given the alignment of a pointer to the derived class.

CharUnits CodeGenModule::getVBaseAlignment(CharUnits actualDerivedAlign,

                                           const CXXRecordDecl *derivedClass,

                                           const CXXRecordDecl *vbaseClass) {

  // The basic idea here is that an underaligned derived pointer might

  // indicate an underaligned base pointer.

  assert(vbaseClass->isCompleteDefinition());

  auto &baseLayout = getContext().getASTRecordLayout(vbaseClass);

  CharUnits expectedVBaseAlign = baseLayout.getNonVirtualAlignment();

  return getDynamicOffsetAlignment(actualDerivedAlign, derivedClass,

                                   expectedVBaseAlign);

}

CharUnits

CodeGenModule::getDynamicOffsetAlignment(CharUnits actualBaseAlign,

                                         const CXXRecordDecl *baseDecl,

                                         CharUnits expectedTargetAlign) {

  // If the base is an incomplete type (which is, alas, possible with

  // member pointers), be pessimistic.

  if (!baseDecl->isCompleteDefinition())

    return std::min(actualBaseAlign, expectedTargetAlign);

  auto &baseLayout = getContext().getASTRecordLayout(baseDecl);

  CharUnits expectedBaseAlign = baseLayout.getNonVirtualAlignment();

  // If the class is properly aligned, assume the target offset is, too.

  //

  // This actually isn't necessarily the right thing to do --- if the

  // class is a complete object, but it's only properly aligned for a

  // base subobject, then the alignments of things relative to it are

  // probably off as well.  (Note that this requires the alignment of

  // the target to be greater than the NV alignment of the derived

  // class.)

  //

  // However, our approach to this kind of under-alignment can only

  // ever be best effort; after all, we're never going to propagate

  // alignments through variables or parameters.  Note, in particular,

  // that constructing a polymorphic type in an address that's less

  // than pointer-aligned will generally trap in the constructor,

  // unless we someday add some sort of attribute to change the

  // assumed alignment of 'this'.  So our goal here is pretty much

  // just to allow the user to explicitly say that a pointer is

  // under-aligned and then safely access its fields and vtables.

  if (actualBaseAlign >= expectedBaseAlign) {

    return expectedTargetAlign;

  }

  // Otherwise, we might be offset by an arbitrary multiple of the

  // actual alignment.  The correct adjustment is to take the min of

  // the two alignments.

  return std::min(actualBaseAlign, expectedTargetAlign);

}

Address CodeGenFunction::LoadCXXThisAddress() {

  assert(CurFuncDecl && "loading 'this' without a func declaration?");

  auto *MD = cast<CXXMethodDecl>(CurFuncDecl);

  // Lazily compute CXXThisAlignment.

  if (CXXThisAlignment.isZero()) {

    // Just use the best known alignment for the parent.

    // TODO: if we're currently emitting a complete-object ctor/dtor,

    // we can always use the complete-object alignment.

    CXXThisAlignment = CGM.getClassPointerAlignment(MD->getParent());

  }

  llvm::Type *Ty = ConvertType(MD->getThisType()->getPointeeType());

  return Address(LoadCXXThis(), Ty, CXXThisAlignment);

}

/// Emit the address of a field using a member data pointer.

///

/// \param E Only used for emergency diagnostics

Address

CodeGenFunction::EmitCXXMemberDataPointerAddress(const Expr *E, Address base,

                                                 llvm::Value *memberPtr,

                                      const MemberPointerType *memberPtrType,

                                                 LValueBaseInfo *BaseInfo,

                                                 TBAAAccessInfo *TBAAInfo) {

  // Ask the ABI to compute the actual address.

  llvm::Value *ptr =

    CGM.getCXXABI().EmitMemberDataPointerAddress(*this, E, base,

                                                 memberPtr, memberPtrType);

  QualType memberType = memberPtrType->getPointeeType();

  CharUnits memberAlign =

      CGM.getNaturalTypeAlignment(memberType, BaseInfo, TBAAInfo);

  memberAlign =

    CGM.getDynamicOffsetAlignment(base.getAlignment(),

                            memberPtrType->getClass()->getAsCXXRecordDecl(),

                                  memberAlign);

  return Address(ptr, ConvertTypeForMem(memberPtrType->getPointeeType()),

                 memberAlign);

}

CharUnits CodeGenModule::computeNonVirtualBaseClassOffset(

    const CXXRecordDecl *DerivedClass, CastExpr::path_const_iterator Start,

    CastExpr::path_const_iterator End) {

  CharUnits Offset = CharUnits::Zero();

  const ASTContext &Context = getContext();

  const CXXRecordDecl *RD = DerivedClass;

  for (CastExpr::path_const_iterator I = Start; I != End; 
++I21.4k
) {

    const CXXBaseSpecifier *Base = *I;

    assert(!Base->isVirtual() && "Should not see virtual bases here!");

    // Get the layout.

    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);

    const auto *BaseDecl =

        cast<CXXRecordDecl>(Base->getType()->castAs<RecordType>()->getDecl());

    // Add the offset.

    Offset += Layout.getBaseClassOffset(BaseDecl);

    RD = BaseDecl;

  }

  return Offset;

}

llvm::Constant *

CodeGenModule::GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl,

                                   CastExpr::path_const_iterator PathBegin,

                                   CastExpr::path_const_iterator PathEnd) {

  assert(PathBegin != PathEnd && "Base path should not be empty!");

  CharUnits Offset =

      computeNonVirtualBaseClassOffset(ClassDecl, PathBegin, PathEnd);

  if (Offset.isZero())

    return nullptr;

  llvm::Type *PtrDiffTy =

  Types.ConvertType(getContext().getPointerDiffType());

  return llvm::ConstantInt::get(PtrDiffTy, Offset.getQuantity());

}

/// Gets the address of a direct base class within a complete object.

/// This should only be used for (1) non-virtual bases or (2) virtual bases

/// when the type is known to be complete (e.g. in complete destructors).

///

/// The object pointed to by 'This' is assumed to be non-null.

Address

CodeGenFunction::GetAddressOfDirectBaseInCompleteClass(Address This,

                                                   const CXXRecordDecl *Derived,

                                                   const CXXRecordDecl *Base,

                                                   bool BaseIsVirtual) {

  // 'this' must be a pointer (in some address space) to Derived.

  assert(This.getElementType() == ConvertType(Derived));

  // Compute the offset of the virtual base.

  CharUnits Offset;

  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Derived);

  if (BaseIsVirtual)

    Offset = Layout.getVBaseClassOffset(Base);

  else

    Offset = Layout.getBaseClassOffset(Base);

  // Shift and cast down to the base type.

  // TODO: for complete types, this should be possible with a GEP.

  Address V = This;

  if (!Offset.isZero()) {

    V = Builder.CreateElementBitCast(V, Int8Ty);

    V = Builder.CreateConstInBoundsByteGEP(V, Offset);

  }

  V = Builder.CreateElementBitCast(V, ConvertType(Base));

  return V;

}

static Address

ApplyNonVirtualAndVirtualOffset(CodeGenFunction &CGF, Address addr,

                                CharUnits nonVirtualOffset,

                                llvm::Value *virtualOffset,

                                const CXXRecordDecl *derivedClass,

                                const CXXRecordDecl *nearestVBase) {

  // Assert that we have something to do.

  assert(!nonVirtualOffset.isZero() || virtualOffset != nullptr);

  // Compute the offset from the static and dynamic components.

  llvm::Value *baseOffset;

  if (!nonVirtualOffset.isZero()) {

    llvm::Type *OffsetType =

        (CGF.CGM.getTarget().getCXXABI().isItaniumFamily() &&

         
CGF.CGM.getItaniumVTableContext().isRelativeLayout()1.21k
)

            ? 
CGF.Int32Ty4

            : 
CGF.PtrDiffTy1.34k
;

    baseOffset =

        llvm::ConstantInt::get(OffsetType, nonVirtualOffset.getQuantity());

    if (virtualOffset) {

      baseOffset = CGF.Builder.CreateAdd(virtualOffset, baseOffset);

    }

  } else {

    baseOffset = virtualOffset;

  }

  // Apply the base offset.

  llvm::Value *ptr = addr.getPointer();

  unsigned AddrSpace = ptr->getType()->getPointerAddressSpace();

  ptr = CGF.Builder.CreateBitCast(ptr, CGF.Int8Ty->getPointerTo(AddrSpace));

  ptr = CGF.Builder.CreateInBoundsGEP(CGF.Int8Ty, ptr, baseOffset, "add.ptr");

  // If we have a virtual component, the alignment of the result will

  // be relative only to the known alignment of that vbase.

  CharUnits alignment;

  if (virtualOffset) {

    assert(nearestVBase && "virtual offset without vbase?");

    alignment = CGF.CGM.getVBaseAlignment(addr.getAlignment(),

                                          derivedClass, nearestVBase);

  } else {

    alignment = addr.getAlignment();

  }

  alignment = alignment.alignmentAtOffset(nonVirtualOffset);

  return Address(ptr, CGF.Int8Ty, alignment);

}

Address CodeGenFunction::GetAddressOfBaseClass(

    Address Value, const CXXRecordDecl *Derived,

    CastExpr::path_const_iterator PathBegin,

    CastExpr::path_const_iterator PathEnd, bool NullCheckValue,

    SourceLocation Loc) {

  assert(PathBegin != PathEnd && "Base path should not be empty!");

  CastExpr::path_const_iterator Start = PathBegin;

  const CXXRecordDecl *VBase = nullptr;

  // Sema has done some convenient canonicalization here: if the

  // access path involved any virtual steps, the conversion path will

  // *start* with a step down to the correct virtual base subobject,

  // and hence will not require any further steps.

  if ((*Start)->isVirtual()) {

    VBase = cast<CXXRecordDecl>(

        (*Start)->getType()->castAs<RecordType>()->getDecl());

    ++Start;

  }

  // Compute the static offset of the ultimate destination within its

  // allocating subobject (the virtual base, if there is one, or else

  // the "complete" object that we see).

  CharUnits NonVirtualOffset = CGM.computeNonVirtualBaseClassOffset(

      VBase ? 
VBase469
 : 
Derived18.0k
, Start, PathEnd);

  // If there's a virtual step, we can sometimes "devirtualize" it.

  // For now, that's limited to when the derived type is final.

  // TODO: "devirtualize" this for accesses to known-complete objects.

  if (VBase && 
Derived->hasAttr<FinalAttr>()469
) {

    const ASTRecordLayout &layout = getContext().getASTRecordLayout(Derived);

    CharUnits vBaseOffset = layout.getVBaseClassOffset(VBase);

    NonVirtualOffset += vBaseOffset;

    VBase = nullptr; // we no longer have a virtual step

  }

  // Get the base pointer type.

  llvm::Type *BaseValueTy = ConvertType((PathEnd[-1])->getType());

  llvm::Type *BasePtrTy =

      BaseValueTy->getPointerTo(Value.getType()->getPointerAddressSpace());

  QualType DerivedTy = getContext().getRecordType(Derived);

  CharUnits DerivedAlign = CGM.getClassPointerAlignment(Derived);

  // If the static offset is zero and we don't have a virtual step,

  // just do a bitcast; null checks are unnecessary.

  if (NonVirtualOffset.isZero() && 
!VBase17.4k
) {

    if (sanitizePerformTypeCheck()) {

      SanitizerSet SkippedChecks;

      SkippedChecks.set(SanitizerKind::Null, !NullCheckValue);

      EmitTypeCheck(TCK_Upcast, Loc, Value.getPointer(),

                    DerivedTy, DerivedAlign, SkippedChecks);

    }

    return Builder.CreateElementBitCast(Value, BaseValueTy);

  }

  llvm::BasicBlock *origBB = nullptr;

  llvm::BasicBlock *endBB = nullptr;

  // Skip over the offset (and the vtable load) if we're supposed to

  // null-check the pointer.

  if (NullCheckValue) {

    origBB = Builder.GetInsertBlock();

    llvm::BasicBlock *notNullBB = createBasicBlock("cast.notnull");

    endBB = createBasicBlock("cast.end");

    llvm::Value *isNull = Builder.CreateIsNull(Value.getPointer());

    Builder.CreateCondBr(isNull, endBB, notNullBB);

    EmitBlock(notNullBB);

  }

  if (sanitizePerformTypeCheck()) {

    SanitizerSet SkippedChecks;

    SkippedChecks.set(SanitizerKind::Null, true);

    EmitTypeCheck(VBase ? TCK_UpcastToVirtualBase : 
TCK_Upcast0
, Loc,

                  Value.getPointer(), DerivedTy, DerivedAlign, SkippedChecks);

  }

  // Compute the virtual offset.

  llvm::Value *VirtualOffset = nullptr;

  if (VBase) {

    VirtualOffset =

      CGM.getCXXABI().GetVirtualBaseClassOffset(*this, Value, Derived, VBase);

  }

  // Apply both offsets.

  Value = ApplyNonVirtualAndVirtualOffset(*this, Value, NonVirtualOffset,

                                          VirtualOffset, Derived, VBase);

  // Cast to the destination type.

  Value = Builder.CreateElementBitCast(Value, BaseValueTy);

  // Build a phi if we needed a null check.

  if (NullCheckValue) {

    llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();

    Builder.CreateBr(endBB);

    EmitBlock(endBB);

    llvm::PHINode *PHI = Builder.CreatePHI(BasePtrTy, 2, "cast.result");

    PHI->addIncoming(Value.getPointer(), notNullBB);

    PHI->addIncoming(llvm::Constant::getNullValue(BasePtrTy), origBB);

    Value = Value.withPointer(PHI);

  }

  return Value;

}

Address

CodeGenFunction::GetAddressOfDerivedClass(Address BaseAddr,

                                          const CXXRecordDecl *Derived,

                                        CastExpr::path_const_iterator PathBegin,

                                          CastExpr::path_const_iterator PathEnd,

                                          bool NullCheckValue) {

  assert(PathBegin != PathEnd && "Base path should not be empty!");

  QualType DerivedTy =

    getContext().getCanonicalType(getContext().getTagDeclType(Derived));

  unsigned AddrSpace = BaseAddr.getAddressSpace();

  llvm::Type *DerivedValueTy = ConvertType(DerivedTy);

  llvm::Type *DerivedPtrTy = DerivedValueTy->getPointerTo(AddrSpace);

  llvm::Value *NonVirtualOffset =

    CGM.GetNonVirtualBaseClassOffset(Derived, PathBegin, PathEnd);

  if (!NonVirtualOffset) {

    // No offset, we can just cast back.

    return Builder.CreateElementBitCast(BaseAddr, DerivedValueTy);

  }

  llvm::BasicBlock *CastNull = nullptr;

  llvm::BasicBlock *CastNotNull = nullptr;

  llvm::BasicBlock *CastEnd = nullptr;

  if (NullCheckValue) {

    CastNull = createBasicBlock("cast.null");

    CastNotNull = createBasicBlock("cast.notnull");

    CastEnd = createBasicBlock("cast.end");

    llvm::Value *IsNull = Builder.CreateIsNull(BaseAddr.getPointer());

    Builder.CreateCondBr(IsNull, CastNull, CastNotNull);

    EmitBlock(CastNotNull);

  }

  // Apply the offset.

  llvm::Value *Value = Builder.CreateBitCast(BaseAddr.getPointer(), Int8PtrTy);

  Value = Builder.CreateInBoundsGEP(

      Int8Ty, Value, Builder.CreateNeg(NonVirtualOffset), "sub.ptr");

  // Just cast.

  Value = Builder.CreateBitCast(Value, DerivedPtrTy);

  // Produce a PHI if we had a null-check.

  if (NullCheckValue) {

    Builder.CreateBr(CastEnd);

    EmitBlock(CastNull);

    Builder.CreateBr(CastEnd);

    EmitBlock(CastEnd);

    llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);

    PHI->addIncoming(Value, CastNotNull);

    PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);

    Value = PHI;

  }

  return Address(Value, DerivedValueTy, CGM.getClassPointerAlignment(Derived));

}

llvm::Value *CodeGenFunction::GetVTTParameter(GlobalDecl GD,

                                              bool ForVirtualBase,

                                              bool Delegating) {

  if (!CGM.getCXXABI().NeedsVTTParameter(GD)) {

    // This constructor/destructor does not need a VTT parameter.

    return nullptr;

  }

  const CXXRecordDecl *RD = cast<CXXMethodDecl>(CurCodeDecl)->getParent();

  const CXXRecordDecl *Base = cast<CXXMethodDecl>(GD.getDecl())->getParent();

  uint64_t SubVTTIndex;

  if (Delegating) {

    // If this is a delegating constructor call, just load the VTT.

    return LoadCXXVTT();

  } else if (RD == Base) {

    // If the record matches the base, this is the complete ctor/dtor

    // variant calling the base variant in a class with virtual bases.

    assert(!CGM.getCXXABI().NeedsVTTParameter(CurGD) &&

           "doing no-op VTT offset in base dtor/ctor?");

    assert(!ForVirtualBase && "Can't have same class as virtual base!");

    SubVTTIndex = 0;

  } else {

    const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);

    CharUnits BaseOffset = ForVirtualBase ?

      Layout.getVBaseClassOffset(Base) :

      
Layout.getBaseClassOffset(Base)179
;

    SubVTTIndex =

      CGM.getVTables().getSubVTTIndex(RD, BaseSubobject(Base, BaseOffset));

    assert(SubVTTIndex != 0 && "Sub-VTT index must be greater than zero!");

  }

  if (CGM.getCXXABI().NeedsVTTParameter(CurGD)) {

    // A VTT parameter was passed to the constructor, use it.

    llvm::Value *VTT = LoadCXXVTT();

    return Builder.CreateConstInBoundsGEP1_64(VoidPtrTy, VTT, SubVTTIndex);

  } else {

    // We're the complete constructor, so get the VTT by name.

    llvm::GlobalValue *VTT = CGM.getVTables().GetAddrOfVTT(RD);

    return Builder.CreateConstInBoundsGEP2_64(

        VTT->getValueType(), VTT, 0, SubVTTIndex);

  }

}

namespace {

  /// Call the destructor for a direct base class.

  struct CallBaseDtor final : EHScopeStack::Cleanup {

    const CXXRecordDecl *BaseClass;

    bool BaseIsVirtual;

    CallBaseDtor(const CXXRecordDecl *Base, bool BaseIsVirtual)

      : BaseClass(Base), BaseIsVirtual(BaseIsVirtual) {}

    void Emit(CodeGenFunction &CGF, Flags flags) override {

      const CXXRecordDecl *DerivedClass =

        cast<CXXMethodDecl>(CGF.CurCodeDecl)->getParent();

      const CXXDestructorDecl *D = BaseClass->getDestructor();

      // We are already inside a destructor, so presumably the object being

      // destroyed should have the expected type.

      QualType ThisTy = D->getThisObjectType();

      Address Addr =

        CGF.GetAddressOfDirectBaseInCompleteClass(CGF.LoadCXXThisAddress(),

                                                  DerivedClass, BaseClass,

                                                  BaseIsVirtual);

      CGF.EmitCXXDestructorCall(D, Dtor_Base, BaseIsVirtual,

                                /*Delegating=*/false, Addr, ThisTy);

    }

  };

  /// A visitor which checks whether an initializer uses 'this' in a

  /// way which requires the vtable to be properly set.

  struct DynamicThisUseChecker : ConstEvaluatedExprVisitor<DynamicThisUseChecker> {

    typedef ConstEvaluatedExprVisitor<DynamicThisUseChecker> super;

    bool UsesThis;

    DynamicThisUseChecker(const ASTContext &C) : super(C), UsesThis(false) {}

    // Black-list all explicit and implicit references to 'this'.

    //

    // Do we need to worry about external references to 'this' derived

    // from arbitrary code?  If so, then anything which runs arbitrary

    // external code might potentially access the vtable.

    void VisitCXXThisExpr(const CXXThisExpr *E) { UsesThis = true; }

  };

} // end anonymous namespace

static bool BaseInitializerUsesThis(ASTContext &C, const Expr *Init) {

  DynamicThisUseChecker Checker(C);

  Checker.Visit(Init);

  return Checker.UsesThis;

}

static void EmitBaseInitializer(CodeGenFunction &CGF,

                                const CXXRecordDecl *ClassDecl,

                                CXXCtorInitializer *BaseInit) {

  assert(BaseInit->isBaseInitializer() &&

         "Must have base initializer!");

  Address ThisPtr = CGF.LoadCXXThisAddress();

  const Type *BaseType = BaseInit->getBaseClass();

  const auto *BaseClassDecl =

      cast<CXXRecordDecl>(BaseType->castAs<RecordType>()->getDecl());

  bool isBaseVirtual = BaseInit->isBaseVirtual();

  // If the initializer for the base (other than the constructor

  // itself) accesses 'this' in any way, we need to initialize the

  // vtables.

  if (BaseInitializerUsesThis(CGF.getContext(), BaseInit->getInit()))

    CGF.InitializeVTablePointers(ClassDecl);

  // We can pretend to be a complete class because it only matters for

  // virtual bases, and we only do virtual bases for complete ctors.

  Address V =

    CGF.GetAddressOfDirectBaseInCompleteClass(ThisPtr, ClassDecl,

                                              BaseClassDecl,

                                              isBaseVirtual);

  AggValueSlot AggSlot =

      AggValueSlot::forAddr(

          V, Qualifiers(),

          AggValueSlot::IsDestructed,

          AggValueSlot::DoesNotNeedGCBarriers,

          AggValueSlot::IsNotAliased,

          CGF.getOverlapForBaseInit(ClassDecl, BaseClassDecl, isBaseVirtual));

  CGF.EmitAggExpr(BaseInit->getInit(), AggSlot);

  if (CGF.CGM.getLangOpts().Exceptions &&

      
!BaseClassDecl->hasTrivialDestructor()7.72k
)

    CGF.EHStack.pushCleanup<CallBaseDtor>(EHCleanup, BaseClassDecl,

                                          isBaseVirtual);

}

static bool isMemcpyEquivalentSpecialMember(const CXXMethodDecl *D) {

  auto *CD = dyn_cast<CXXConstructorDecl>(D);

  if (!(CD && 
CD->isCopyOrMoveConstructor()100k
) &&

      
!D->isCopyAssignmentOperator()89.4k
 && 
!D->isMoveAssignmentOperator()89.2k
)

    return false;

  // We can emit a memcpy for a trivial copy or move constructor/assignment.

  if (D->isTrivial() && 
!D->getParent()->mayInsertExtraPadding()6.24k
)

    return true;

  // We *must* emit a memcpy for a defaulted union copy or move op.

  if (D->getParent()->isUnion() && 
D->isDefaulted()2
)

    return true;

  return false;

}

static void EmitLValueForAnyFieldInitialization(CodeGenFunction &CGF,

                                                CXXCtorInitializer *MemberInit,

                                                LValue &LHS) {

  FieldDecl *Field = MemberInit->getAnyMember();

  if (MemberInit->isIndirectMemberInitializer()) {

    // If we are initializing an anonymous union field, drill down to the field.

    IndirectFieldDecl *IndirectField = MemberInit->getIndirectMember();

    for (const auto *I : IndirectField->chain())

      LHS = CGF.EmitLValueForFieldInitialization(LHS, cast<FieldDecl>(I));

  } else {

    LHS = CGF.EmitLValueForFieldInitialization(LHS, Field);

  }

}

static void EmitMemberInitializer(CodeGenFunction &CGF,

                                  const CXXRecordDecl *ClassDecl,

                                  CXXCtorInitializer *MemberInit,

                                  const CXXConstructorDecl *Constructor,

                                  FunctionArgList &Args) {

  ApplyDebugLocation Loc(CGF, MemberInit->getSourceLocation());

  assert(MemberInit->isAnyMemberInitializer() &&

         "Must have member initializer!");

  assert(MemberInit->getInit() && "Must have initializer!");

  // non-static data member initializers.

  FieldDecl *Field = MemberInit->getAnyMember();

  QualType FieldType = Field->getType();

  llvm::Value *ThisPtr = CGF.LoadCXXThis();

  QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl);

  LValue LHS;

  // If a base constructor is being emitted, create an LValue that has the

  // non-virtual alignment.

  if (CGF.CurGD.getCtorType() == Ctor_Base)

    LHS = CGF.MakeNaturalAlignPointeeAddrLValue(ThisPtr, RecordTy);

  else

    LHS = CGF.MakeNaturalAlignAddrLValue(ThisPtr, RecordTy);

  EmitLValueForAnyFieldInitialization(CGF, MemberInit, LHS);

  // Special case: if we are in a copy or move constructor, and we are copying

  // an array of PODs or classes with trivial copy constructors, ignore the

  // AST and perform the copy we know is equivalent.

  // FIXME: This is hacky at best... if we had a bit more explicit information

  // in the AST, we could generalize it more easily.

  const ConstantArrayType *Array

    = CGF.getContext().getAsConstantArrayType(FieldType);

  if (Array && 
Constructor->isDefaulted()86
 &&

      
Constructor->isCopyOrMoveConstructor()38
) {

    QualType BaseElementTy = CGF.getContext().getBaseElementType(Array);

    CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(MemberInit->getInit());

    if (BaseElementTy.isPODType(CGF.getContext()) ||

        
(18
CE18
 && 
isMemcpyEquivalentSpecialMember(CE->getConstructor())0
)) {

      unsigned SrcArgIndex =

          CGF.CGM.getCXXABI().getSrcArgforCopyCtor(Constructor, Args);

      llvm::Value *SrcPtr

        = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(Args[SrcArgIndex]));

      LValue ThisRHSLV = CGF.MakeNaturalAlignAddrLValue(SrcPtr, RecordTy);

      LValue Src = CGF.EmitLValueForFieldInitialization(ThisRHSLV, Field);

      // Copy the aggregate.

      CGF.EmitAggregateCopy(LHS, Src, FieldType, CGF.getOverlapForFieldInit(Field),

                            LHS.isVolatileQualified());

      // Ensure that we destroy the objects if an exception is thrown later in

      // the constructor.

      QualType::DestructionKind dtorKind = FieldType.isDestructedType();

      if (CGF.needsEHCleanup(dtorKind))

        CGF.pushEHDestroy(dtorKind, LHS.getAddress(CGF), FieldType);

      return;

    }

  }

  CGF.EmitInitializerForField(Field, LHS, MemberInit->getInit());

}

void CodeGenFunction::EmitInitializerForField(FieldDecl *Field, LValue LHS,

                                              Expr *Init) {

  QualType FieldType = Field->getType();

  switch (getEvaluationKind(FieldType)) {

  case TEK_Scalar:

    if (LHS.isSimple()) {

      EmitExprAsInit(Init, Field, LHS, false);

    } else {

      RValue RHS = RValue::get(EmitScalarExpr(Init));

      EmitStoreThroughLValue(RHS, LHS);

    }

    break;

  case TEK_Complex:

    EmitComplexExprIntoLValue(Init, LHS, /*isInit*/ true);

    break;

  case TEK_Aggregate: {

    AggValueSlot Slot = AggValueSlot::forLValue(

        LHS, *this, AggValueSlot::IsDestructed,

        AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased,

        getOverlapForFieldInit(Field), AggValueSlot::IsNotZeroed,

        // Checks are made by the code that calls constructor.

        AggValueSlot::IsSanitizerChecked);

    EmitAggExpr(Init, Slot);

    break;

  }

  }

  // Ensure that we destroy this object if an exception is thrown

  // later in the constructor.

  QualType::DestructionKind dtorKind = FieldType.isDestructedType();

  if (needsEHCleanup(dtorKind))

    pushEHDestroy(dtorKind, LHS.getAddress(*this), FieldType);

}

/// Checks whether the given constructor is a valid subject for the

/// complete-to-base constructor delegation optimization, i.e.

/// emitting the complete constructor as a simple call to the base

/// constructor.

bool CodeGenFunction::IsConstructorDelegationValid(

    const CXXConstructorDecl *Ctor) {

  // Currently we disable the optimization for classes with virtual

  // bases because (1) the addresses of parameter variables need to be

  // consistent across all initializers but (2) the delegate function

  // call necessarily creates a second copy of the parameter variable.

  //

  // The limiting example (purely theoretical AFAIK):

  //   struct A { A(int &c) { c++; } };

  //   struct B : virtual A {

  //     B(int count) : A(count) { printf("%d\n", count); }

  //   };

  // ...although even this example could in principle be emitted as a

  // delegation since the address of the parameter doesn't escape.

  if (Ctor->getParent()->getNumVBases()) {

    // TODO: white-list trivial vbase initializers.  This case wouldn't

    // be subject to the restrictions below.

    // TODO: white-list cases where:

    //  - there are no non-reference parameters to the constructor

    //  - the initializers don't access any non-reference parameters

    //  - the initializers don't take the address of non-reference

    //    parameters

    //  - etc.

    // If we ever add any of the above cases, remember that:

    //  - function-try-blocks will always exclude this optimization

    //  - we need to perform the constructor prologue and cleanup in

    //    EmitConstructorBody.

    return false;

  }

  // We also disable the optimization for variadic functions because

  // it's impossible to "re-pass" varargs.

  if (Ctor->getType()->castAs<FunctionProtoType>()->isVariadic())

    return false;

  // FIXME: Decide if we can do a delegation of a delegating constructor.

  if (Ctor->isDelegatingConstructor())

    return false;

  return true;

}

// Emit code in ctor (Prologue==true) or dtor (Prologue==false)

// to poison the extra field paddings inserted under

// -fsanitize-address-field-padding=1|2.

void CodeGenFunction::EmitAsanPrologueOrEpilogue(bool Prologue) {

  ASTContext &Context = getContext();

  const CXXRecordDecl *ClassDecl =

      Prologue ? 
cast<CXXConstructorDecl>(CurGD.getDecl())->getParent()40.4k

               : 
cast<CXXDestructorDecl>(CurGD.getDecl())->getParent()15.3k
;

  if (!ClassDecl->mayInsertExtraPadding()) 
return55.8k
;

  struct SizeAndOffset {

    uint64_t Size;

    uint64_t Offset;

  };

  unsigned PtrSize = CGM.getDataLayout().getPointerSizeInBits();

  const ASTRecordLayout &Info = Context.getASTRecordLayout(ClassDecl);

  // Populate sizes and offsets of fields.

  SmallVector<SizeAndOffset, 16> SSV(Info.getFieldCount());

  for (unsigned i = 0, e = Info.getFieldCount(); i != e; 
++i112
)

    SSV[i].Offset =

        Context.toCharUnitsFromBits(Info.getFieldOffset(i)).getQuantity();

  size_t NumFields = 0;

  for (const auto *Field : ClassDecl->fields()) {

    const FieldDecl *D = Field;

    auto FieldInfo = Context.getTypeInfoInChars(D->getType());

    CharUnits FieldSize = FieldInfo.Width;

    assert(NumFields < SSV.size());

    SSV[NumFields].Size = D->isBitField() ? 
00
 : FieldSize.getQuantity();

    NumFields++;

  }

  assert(NumFields == SSV.size());

  if (SSV.size() <= 1) 
return0
;

  // We will insert calls to __asan_* run-time functions.

  // LLVM AddressSanitizer pass may decide to inline them later.

  llvm::Type *Args[2] = {IntPtrTy, IntPtrTy};

  llvm::FunctionType *FTy =

      llvm::FunctionType::get(CGM.VoidTy, Args, false);

  llvm::FunctionCallee F = CGM.CreateRuntimeFunction(

      FTy, Prologue ? 
"__asan_poison_intra_object_redzone"22

                    : 
"__asan_unpoison_intra_object_redzone"19
);

  llvm::Value *ThisPtr = LoadCXXThis();

  ThisPtr = Builder.CreatePtrToInt(ThisPtr, IntPtrTy);

  uint64_t TypeSize = Info.getNonVirtualSize().getQuantity();

  // For each field check if it has sufficient padding,

  // if so (un)poison it with a call.

  for (size_t i = 0; i < SSV.size(); 
i++112
) {

    uint64_t AsanAlignment = 8;

    uint64_t NextField = i == SSV.size() - 1 ? 
TypeSize41
 : 
SSV[i + 1].Offset71
;

    uint64_t PoisonSize = NextField - SSV[i].Offset - SSV[i].Size;

    uint64_t EndOffset = SSV[i].Offset + SSV[i].Size;

    if (PoisonSize < AsanAlignment || 
!SSV[i].Size94
 ||

        
(NextField % AsanAlignment) != 094
)

      continue;

    Builder.CreateCall(

        F, {Builder.CreateAdd(ThisPtr, Builder.getIntN(PtrSize, EndOffset)),

            Builder.getIntN(PtrSize, PoisonSize)});

  }

}

/// EmitConstructorBody - Emits the body of the current constructor.

void CodeGenFunction::EmitConstructorBody(FunctionArgList &Args) {

  EmitAsanPrologueOrEpilogue(true);

  const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(CurGD.getDecl());

  CXXCtorType CtorType = CurGD.getCtorType();

  assert((CGM.getTarget().getCXXABI().hasConstructorVariants() ||

          CtorType == Ctor_Complete) &&

         "can only generate complete ctor for this ABI");

  // Before we go any further, try the complete->base constructor

  // delegation optimization.

  if (CtorType == Ctor_Complete && 
IsConstructorDelegationValid(Ctor)17.8k
 &&

      
CGM.getTarget().getCXXABI().hasConstructorVariants()17.1k
) {

    EmitDelegateCXXConstructorCall(Ctor, Ctor_Base, Args, Ctor->getEndLoc());

    return;

  }

  const FunctionDecl *Definition = nullptr;

  Stmt *Body = Ctor->getBody(Definition);

  assert(Definition == Ctor && "emitting wrong constructor body");

  // Enter the function-try-block before the constructor prologue if

  // applicable.

  bool IsTryBody = (Body && isa<CXXTryStmt>(Body));

  if (IsTryBody)

    EnterCXXTryStmt(*cast<CXXTryStmt>(Body), true);

  incrementProfileCounter(Body);

  RunCleanupsScope RunCleanups(*this);

  // TODO: in restricted cases, we can emit the vbase initializers of

  // a complete ctor and then delegate to the base ctor.

  // Emit the constructor prologue, i.e. the base and member

  // initializers.

  EmitCtorPrologue(Ctor, CtorType, Args);

  // Emit the body of the statement.

  if (IsTryBody)

    EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock());

  else if (Body)

    EmitStmt(Body);

  // Emit any cleanup blocks associated with the member or base

  // initializers, which includes (along the exceptional path) the

  // destructors for those members and bases that were fully

  // constructed.

  RunCleanups.ForceCleanup();

  if (IsTryBody)

    ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true);

}

namespace {

  /// RAII object to indicate that codegen is copying the value representation

  /// instead of the object representation. Useful when copying a struct or

  /// class which has uninitialized members and we're only performing

  /// lvalue-to-rvalue conversion on the object but not its members.

  class CopyingValueRepresentation {

  public:

    explicit CopyingValueRepresentation(CodeGenFunction &CGF)

        : CGF(CGF), OldSanOpts(CGF.SanOpts) {

      CGF.SanOpts.set(SanitizerKind::Bool, false);

      CGF.SanOpts.set(SanitizerKind::Enum, false);

    }

    ~CopyingValueRepresentation() {

      CGF.SanOpts = OldSanOpts;

    }

  private:

    CodeGenFunction &CGF;

    SanitizerSet OldSanOpts;

  };

} // end anonymous namespace

namespace {

  class FieldMemcpyizer {

  public:

    FieldMemcpyizer(CodeGenFunction &CGF, const CXXRecordDecl *ClassDecl,

                    const VarDecl *SrcRec)

      : CGF(CGF), ClassDecl(ClassDecl), SrcRec(SrcRec),

        RecLayout(CGF.getContext().getASTRecordLayout(ClassDecl)),

        FirstField(nullptr), LastField(nullptr), FirstFieldOffset(0),

        LastFieldOffset(0), LastAddedFieldIndex(0) {}

    bool isMemcpyableField(FieldDecl *F) const {

      // Never memcpy fields when we are adding poisoned paddings.

      if (CGF.getContext().getLangOpts().SanitizeAddressFieldPadding)

        return false;

      Qualifiers Qual = F->getType().getQualifiers();

      if (Qual.hasVolatile() || 
Qual.hasObjCLifetime()526
)

        return false;

      return true;

    }

    void addMemcpyableField(FieldDecl *F) {

      if (F->isZeroSize(CGF.getContext()))

        return;

      if (!FirstField)

        addInitialField(F);

      else

        addNextField(F);

    }

    CharUnits getMemcpySize(uint64_t FirstByteOffset) const {

      ASTContext &Ctx = CGF.getContext();

      unsigned LastFieldSize =

          LastField->isBitField()

              ? 
LastField->getBitWidthValue(Ctx)6

              : Ctx.toBits(

                    Ctx.getTypeInfoDataSizeInChars(LastField->getType()).Width);

      uint64_t MemcpySizeBits = LastFieldOffset + LastFieldSize -

                                FirstByteOffset + Ctx.getCharWidth() - 1;

      CharUnits MemcpySize = Ctx.toCharUnitsFromBits(MemcpySizeBits);

      return MemcpySize;

    }

    void emitMemcpy() {

      // Give the subclass a chance to bail out if it feels the memcpy isn't

      // worth it (e.g. Hasn't aggregated enough data).

      if (!FirstField) {

        return;

      }

      uint64_t FirstByteOffset;

      if (FirstField->isBitField()) {

        const CGRecordLayout &RL =

          CGF.getTypes().getCGRecordLayout(FirstField->getParent());

        const CGBitFieldInfo &BFInfo = RL.getBitFieldInfo(FirstField);

        // FirstFieldOffset is not appropriate for bitfields,

        // we need to use the storage offset instead.

        FirstByteOffset = CGF.getContext().toBits(BFInfo.StorageOffset);

      } else {

        FirstByteOffset = FirstFieldOffset;

      }

      CharUnits MemcpySize = getMemcpySize(FirstByteOffset);

      QualType RecordTy = CGF.getContext().getTypeDeclType(ClassDecl);

      Address ThisPtr = CGF.LoadCXXThisAddress();

      LValue DestLV = CGF.MakeAddrLValue(ThisPtr, RecordTy);

      LValue Dest = CGF.EmitLValueForFieldInitialization(DestLV, FirstField);

      llvm::Value *SrcPtr = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(SrcRec));

      LValue SrcLV = CGF.MakeNaturalAlignAddrLValue(SrcPtr, RecordTy);

      LValue Src = CGF.EmitLValueForFieldInitialization(SrcLV, FirstField);

      emitMemcpyIR(

          Dest.isBitField() ? 
Dest.getBitFieldAddress()12
 : 
Dest.getAddress(CGF)84
,

          Src.isBitField() ? 
Src.getBitFieldAddress()12
 : 
Src.getAddress(CGF)84
,

          MemcpySize);

      reset();

    }

    void reset() {

      FirstField = nullptr;

    }

  protected:

    CodeGenFunction &CGF;

    const CXXRecordDecl *ClassDecl;

  private:

    void emitMemcpyIR(Address DestPtr, Address SrcPtr, CharUnits Size) {

      DestPtr = CGF.Builder.CreateElementBitCast(DestPtr, CGF.Int8Ty);

      SrcPtr = CGF.Builder.CreateElementBitCast(SrcPtr, CGF.Int8Ty);

      CGF.Builder.CreateMemCpy(DestPtr, SrcPtr, Size.getQuantity());

    }

    void addInitialField(FieldDecl *F) {

      FirstField = F;

      LastField = F;

      FirstFieldOffset = RecLayout.getFieldOffset(F->getFieldIndex());

      LastFieldOffset = FirstFieldOffset;

      LastAddedFieldIndex = F->getFieldIndex();

    }

    void addNextField(FieldDecl *F) {

      // For the most part, the following invariant will hold:

      //   F->getFieldIndex() == LastAddedFieldIndex + 1

      // The one exception is that Sema won't add a copy-initializer for an

      // unnamed bitfield, which will show up here as a gap in the sequence.

      assert(F->getFieldIndex() >= LastAddedFieldIndex + 1 &&

             "Cannot aggregate fields out of order.");

      LastAddedFieldIndex = F->getFieldIndex();

      // The 'first' and 'last' fields are chosen by offset, rather than field

      // index. This allows the code to support bitfields, as well as regular

      // fields.

      uint64_t FOffset = RecLayout.getFieldOffset(F->getFieldIndex());

      if (FOffset < FirstFieldOffset) {

        FirstField = F;

        FirstFieldOffset = FOffset;

      } else if (FOffset >= LastFieldOffset) {

        LastField = F;

        LastFieldOffset = FOffset;

      }

    }

    const VarDecl *SrcRec;

    const ASTRecordLayout &RecLayout;

    FieldDecl *FirstField;

    FieldDecl *LastField;

    uint64_t FirstFieldOffset, LastFieldOffset;

    unsigned LastAddedFieldIndex;

  };

  class ConstructorMemcpyizer : public FieldMemcpyizer {

  private: