CGExprAgg.cpp revision 314564
1193326Sed//===--- CGExprAgg.cpp - Emit LLVM Code from Aggregate Expressions --------===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This contains code to emit Aggregate Expr nodes as LLVM code. 11193326Sed// 12193326Sed//===----------------------------------------------------------------------===// 13193326Sed 14193326Sed#include "CodeGenFunction.h" 15249423Sdim#include "CGObjCRuntime.h" 16193326Sed#include "CodeGenModule.h" 17193326Sed#include "clang/AST/ASTContext.h" 18193326Sed#include "clang/AST/DeclCXX.h" 19234353Sdim#include "clang/AST/DeclTemplate.h" 20193326Sed#include "clang/AST/StmtVisitor.h" 21249423Sdim#include "llvm/IR/Constants.h" 22249423Sdim#include "llvm/IR/Function.h" 23249423Sdim#include "llvm/IR/GlobalVariable.h" 24249423Sdim#include "llvm/IR/Intrinsics.h" 25193326Sedusing namespace clang; 26193326Sedusing namespace CodeGen; 27193326Sed 28193326Sed//===----------------------------------------------------------------------===// 29193326Sed// Aggregate Expression Emitter 30193326Sed//===----------------------------------------------------------------------===// 31193326Sed 32193326Sednamespace { 33199990Srdivackyclass AggExprEmitter : public StmtVisitor<AggExprEmitter> { 34193326Sed CodeGenFunction &CGF; 35193326Sed CGBuilderTy &Builder; 36218893Sdim AggValueSlot Dest; 37288943Sdim bool IsResultUnused; 38208600Srdivacky 39226633Sdim /// We want to use 'dest' as the return slot except under two 40226633Sdim /// conditions: 41226633Sdim /// - The destination slot requires garbage collection, so we 42226633Sdim /// need to use the GC API. 43226633Sdim /// - The destination slot is potentially aliased. 44226633Sdim bool shouldUseDestForReturnSlot() const { 45226633Sdim return !(Dest.requiresGCollection() || Dest.isPotentiallyAliased()); 46226633Sdim } 47226633Sdim 48208600Srdivacky ReturnValueSlot getReturnValueSlot() const { 49226633Sdim if (!shouldUseDestForReturnSlot()) 50226633Sdim return ReturnValueSlot(); 51208600Srdivacky 52296417Sdim return ReturnValueSlot(Dest.getAddress(), Dest.isVolatile(), 53296417Sdim IsResultUnused); 54208600Srdivacky } 55208600Srdivacky 56218893Sdim AggValueSlot EnsureSlot(QualType T) { 57218893Sdim if (!Dest.isIgnored()) return Dest; 58218893Sdim return CGF.CreateAggTemp(T, "agg.tmp.ensured"); 59218893Sdim } 60239462Sdim void EnsureDest(QualType T) { 61239462Sdim if (!Dest.isIgnored()) return; 62239462Sdim Dest = CGF.CreateAggTemp(T, "agg.tmp.ensured"); 63239462Sdim } 64218893Sdim 65193326Sedpublic: 66288943Sdim AggExprEmitter(CodeGenFunction &cgf, AggValueSlot Dest, bool IsResultUnused) 67288943Sdim : CGF(cgf), Builder(CGF.Builder), Dest(Dest), 68288943Sdim IsResultUnused(IsResultUnused) { } 69193326Sed 70193326Sed //===--------------------------------------------------------------------===// 71193326Sed // Utilities 72193326Sed //===--------------------------------------------------------------------===// 73193326Sed 74193326Sed /// EmitAggLoadOfLValue - Given an expression with aggregate type that 75193326Sed /// represents a value lvalue, this method emits the address of the lvalue, 76193326Sed /// then loads the result into DestPtr. 77193326Sed void EmitAggLoadOfLValue(const Expr *E); 78193326Sed 79193326Sed /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired. 80239462Sdim void EmitFinalDestCopy(QualType type, const LValue &src); 81296417Sdim void EmitFinalDestCopy(QualType type, RValue src); 82239462Sdim void EmitCopy(QualType type, const AggValueSlot &dest, 83239462Sdim const AggValueSlot &src); 84193326Sed 85226633Sdim void EmitMoveFromReturnSlot(const Expr *E, RValue Src); 86208600Srdivacky 87296417Sdim void EmitArrayInit(Address DestPtr, llvm::ArrayType *AType, 88234353Sdim QualType elementType, InitListExpr *E); 89234353Sdim 90226633Sdim AggValueSlot::NeedsGCBarriers_t needsGC(QualType T) { 91234353Sdim if (CGF.getLangOpts().getGC() && TypeRequiresGCollection(T)) 92226633Sdim return AggValueSlot::NeedsGCBarriers; 93226633Sdim return AggValueSlot::DoesNotNeedGCBarriers; 94226633Sdim } 95226633Sdim 96208600Srdivacky bool TypeRequiresGCollection(QualType T); 97208600Srdivacky 98193326Sed //===--------------------------------------------------------------------===// 99193326Sed // Visitor Methods 100193326Sed //===--------------------------------------------------------------------===// 101198092Srdivacky 102288943Sdim void Visit(Expr *E) { 103288943Sdim ApplyDebugLocation DL(CGF, E); 104288943Sdim StmtVisitor<AggExprEmitter>::Visit(E); 105288943Sdim } 106288943Sdim 107193326Sed void VisitStmt(Stmt *S) { 108193326Sed CGF.ErrorUnsupported(S, "aggregate expression"); 109193326Sed } 110193326Sed void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); } 111221345Sdim void VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 112221345Sdim Visit(GE->getResultExpr()); 113221345Sdim } 114193326Sed void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); } 115224145Sdim void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) { 116224145Sdim return Visit(E->getReplacement()); 117224145Sdim } 118193326Sed 119193326Sed // l-values. 120234353Sdim void VisitDeclRefExpr(DeclRefExpr *E) { 121234353Sdim // For aggregates, we should always be able to emit the variable 122234353Sdim // as an l-value unless it's a reference. This is due to the fact 123234353Sdim // that we can't actually ever see a normal l2r conversion on an 124234353Sdim // aggregate in C++, and in C there's no language standard 125234353Sdim // actively preventing us from listing variables in the captures 126234353Sdim // list of a block. 127234353Sdim if (E->getDecl()->getType()->isReferenceType()) { 128234353Sdim if (CodeGenFunction::ConstantEmission result 129234353Sdim = CGF.tryEmitAsConstant(E)) { 130239462Sdim EmitFinalDestCopy(E->getType(), result.getReferenceLValue(CGF, E)); 131234353Sdim return; 132234353Sdim } 133234353Sdim } 134234353Sdim 135234353Sdim EmitAggLoadOfLValue(E); 136234353Sdim } 137234353Sdim 138193326Sed void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); } 139193326Sed void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); } 140193326Sed void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); } 141224145Sdim void VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 142193326Sed void VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 143193326Sed EmitAggLoadOfLValue(E); 144193326Sed } 145193326Sed void VisitPredefinedExpr(const PredefinedExpr *E) { 146198092Srdivacky EmitAggLoadOfLValue(E); 147193326Sed } 148198092Srdivacky 149193326Sed // Operators. 150198092Srdivacky void VisitCastExpr(CastExpr *E); 151193326Sed void VisitCallExpr(const CallExpr *E); 152193326Sed void VisitStmtExpr(const StmtExpr *E); 153193326Sed void VisitBinaryOperator(const BinaryOperator *BO); 154198398Srdivacky void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO); 155193326Sed void VisitBinAssign(const BinaryOperator *E); 156193326Sed void VisitBinComma(const BinaryOperator *E); 157193326Sed 158193326Sed void VisitObjCMessageExpr(ObjCMessageExpr *E); 159193326Sed void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 160193326Sed EmitAggLoadOfLValue(E); 161193326Sed } 162198092Srdivacky 163288943Sdim void VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E); 164218893Sdim void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO); 165198092Srdivacky void VisitChooseExpr(const ChooseExpr *CE); 166193326Sed void VisitInitListExpr(InitListExpr *E); 167314564Sdim void VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E, 168314564Sdim llvm::Value *outerBegin = nullptr); 169201361Srdivacky void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E); 170288943Sdim void VisitNoInitExpr(NoInitExpr *E) { } // Do nothing. 171193326Sed void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 172193326Sed Visit(DAE->getExpr()); 173193326Sed } 174251662Sdim void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) { 175251662Sdim CodeGenFunction::CXXDefaultInitExprScope Scope(CGF); 176251662Sdim Visit(DIE->getExpr()); 177251662Sdim } 178193326Sed void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E); 179193326Sed void VisitCXXConstructExpr(const CXXConstructExpr *E); 180309124Sdim void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E); 181234353Sdim void VisitLambdaExpr(LambdaExpr *E); 182261991Sdim void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E); 183218893Sdim void VisitExprWithCleanups(ExprWithCleanups *E); 184210299Sed void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 185199482Srdivacky void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); } 186224145Sdim void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E); 187218893Sdim void VisitOpaqueValueExpr(OpaqueValueExpr *E); 188218893Sdim 189234353Sdim void VisitPseudoObjectExpr(PseudoObjectExpr *E) { 190234353Sdim if (E->isGLValue()) { 191234353Sdim LValue LV = CGF.EmitPseudoObjectLValue(E); 192239462Sdim return EmitFinalDestCopy(E->getType(), LV); 193234353Sdim } 194234353Sdim 195234353Sdim CGF.EmitPseudoObjectRValue(E, EnsureSlot(E->getType())); 196234353Sdim } 197234353Sdim 198193326Sed void VisitVAArgExpr(VAArgExpr *E); 199193326Sed 200224145Sdim void EmitInitializationToLValue(Expr *E, LValue Address); 201224145Sdim void EmitNullInitializationToLValue(LValue Address); 202193326Sed // case Expr::ChooseExprClass: 203200583Srdivacky void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); } 204226633Sdim void VisitAtomicExpr(AtomicExpr *E) { 205296417Sdim RValue Res = CGF.EmitAtomicExpr(E); 206296417Sdim EmitFinalDestCopy(E->getType(), Res); 207226633Sdim } 208193326Sed}; 209193326Sed} // end anonymous namespace. 210193326Sed 211193326Sed//===----------------------------------------------------------------------===// 212193326Sed// Utilities 213193326Sed//===----------------------------------------------------------------------===// 214193326Sed 215193326Sed/// EmitAggLoadOfLValue - Given an expression with aggregate type that 216193326Sed/// represents a value lvalue, this method emits the address of the lvalue, 217193326Sed/// then loads the result into DestPtr. 218193326Sedvoid AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) { 219193326Sed LValue LV = CGF.EmitLValue(E); 220249423Sdim 221249423Sdim // If the type of the l-value is atomic, then do an atomic load. 222288943Sdim if (LV.getType()->isAtomicType() || CGF.LValueIsSuitableForInlineAtomic(LV)) { 223261991Sdim CGF.EmitAtomicLoad(LV, E->getExprLoc(), Dest); 224249423Sdim return; 225249423Sdim } 226249423Sdim 227239462Sdim EmitFinalDestCopy(E->getType(), LV); 228193326Sed} 229193326Sed 230208600Srdivacky/// \brief True if the given aggregate type requires special GC API calls. 231208600Srdivackybool AggExprEmitter::TypeRequiresGCollection(QualType T) { 232208600Srdivacky // Only record types have members that might require garbage collection. 233208600Srdivacky const RecordType *RecordTy = T->getAs<RecordType>(); 234208600Srdivacky if (!RecordTy) return false; 235208600Srdivacky 236208600Srdivacky // Don't mess with non-trivial C++ types. 237208600Srdivacky RecordDecl *Record = RecordTy->getDecl(); 238208600Srdivacky if (isa<CXXRecordDecl>(Record) && 239249423Sdim (cast<CXXRecordDecl>(Record)->hasNonTrivialCopyConstructor() || 240208600Srdivacky !cast<CXXRecordDecl>(Record)->hasTrivialDestructor())) 241208600Srdivacky return false; 242208600Srdivacky 243208600Srdivacky // Check whether the type has an object member. 244208600Srdivacky return Record->hasObjectMember(); 245208600Srdivacky} 246208600Srdivacky 247226633Sdim/// \brief Perform the final move to DestPtr if for some reason 248226633Sdim/// getReturnValueSlot() didn't use it directly. 249208600Srdivacky/// 250208600Srdivacky/// The idea is that you do something like this: 251208600Srdivacky/// RValue Result = EmitSomething(..., getReturnValueSlot()); 252226633Sdim/// EmitMoveFromReturnSlot(E, Result); 253226633Sdim/// 254226633Sdim/// If nothing interferes, this will cause the result to be emitted 255226633Sdim/// directly into the return value slot. Otherwise, a final move 256226633Sdim/// will be performed. 257239462Sdimvoid AggExprEmitter::EmitMoveFromReturnSlot(const Expr *E, RValue src) { 258226633Sdim if (shouldUseDestForReturnSlot()) { 259226633Sdim // Logically, Dest.getAddr() should equal Src.getAggregateAddr(). 260226633Sdim // The possibility of undef rvalues complicates that a lot, 261226633Sdim // though, so we can't really assert. 262226633Sdim return; 263210299Sed } 264226633Sdim 265239462Sdim // Otherwise, copy from there to the destination. 266296417Sdim assert(Dest.getPointer() != src.getAggregatePointer()); 267296417Sdim EmitFinalDestCopy(E->getType(), src); 268208600Srdivacky} 269208600Srdivacky 270193326Sed/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired. 271296417Sdimvoid AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src) { 272239462Sdim assert(src.isAggregate() && "value must be aggregate value!"); 273296417Sdim LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddress(), type); 274239462Sdim EmitFinalDestCopy(type, srcLV); 275239462Sdim} 276193326Sed 277239462Sdim/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired. 278239462Sdimvoid AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src) { 279218893Sdim // If Dest is ignored, then we're evaluating an aggregate expression 280239462Sdim // in a context that doesn't care about the result. Note that loads 281239462Sdim // from volatile l-values force the existence of a non-ignored 282239462Sdim // destination. 283239462Sdim if (Dest.isIgnored()) 284239462Sdim return; 285212904Sdim 286239462Sdim AggValueSlot srcAgg = 287239462Sdim AggValueSlot::forLValue(src, AggValueSlot::IsDestructed, 288239462Sdim needsGC(type), AggValueSlot::IsAliased); 289239462Sdim EmitCopy(type, Dest, srcAgg); 290239462Sdim} 291193326Sed 292239462Sdim/// Perform a copy from the source into the destination. 293239462Sdim/// 294239462Sdim/// \param type - the type of the aggregate being copied; qualifiers are 295239462Sdim/// ignored 296239462Sdimvoid AggExprEmitter::EmitCopy(QualType type, const AggValueSlot &dest, 297239462Sdim const AggValueSlot &src) { 298239462Sdim if (dest.requiresGCollection()) { 299239462Sdim CharUnits sz = CGF.getContext().getTypeSizeInChars(type); 300239462Sdim llvm::Value *size = llvm::ConstantInt::get(CGF.SizeTy, sz.getQuantity()); 301198092Srdivacky CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF, 302296417Sdim dest.getAddress(), 303296417Sdim src.getAddress(), 304239462Sdim size); 305198092Srdivacky return; 306198092Srdivacky } 307239462Sdim 308193326Sed // If the result of the assignment is used, copy the LHS there also. 309239462Sdim // It's volatile if either side is. Use the minimum alignment of 310239462Sdim // the two sides. 311296417Sdim CGF.EmitAggregateCopy(dest.getAddress(), src.getAddress(), type, 312296417Sdim dest.isVolatile() || src.isVolatile()); 313193326Sed} 314193326Sed 315234353Sdim/// \brief Emit the initializer for a std::initializer_list initialized with a 316234353Sdim/// real initializer list. 317261991Sdimvoid 318261991SdimAggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { 319261991Sdim // Emit an array containing the elements. The array is externally destructed 320261991Sdim // if the std::initializer_list object is. 321261991Sdim ASTContext &Ctx = CGF.getContext(); 322261991Sdim LValue Array = CGF.EmitLValue(E->getSubExpr()); 323261991Sdim assert(Array.isSimple() && "initializer_list array not a simple lvalue"); 324296417Sdim Address ArrayPtr = Array.getAddress(); 325234353Sdim 326261991Sdim const ConstantArrayType *ArrayType = 327261991Sdim Ctx.getAsConstantArrayType(E->getSubExpr()->getType()); 328261991Sdim assert(ArrayType && "std::initializer_list constructed from non-array"); 329234353Sdim 330261991Sdim // FIXME: Perform the checks on the field types in SemaInit. 331261991Sdim RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl(); 332261991Sdim RecordDecl::field_iterator Field = Record->field_begin(); 333261991Sdim if (Field == Record->field_end()) { 334261991Sdim CGF.ErrorUnsupported(E, "weird std::initializer_list"); 335234353Sdim return; 336234353Sdim } 337234353Sdim 338234353Sdim // Start pointer. 339261991Sdim if (!Field->getType()->isPointerType() || 340261991Sdim !Ctx.hasSameType(Field->getType()->getPointeeType(), 341261991Sdim ArrayType->getElementType())) { 342261991Sdim CGF.ErrorUnsupported(E, "weird std::initializer_list"); 343234353Sdim return; 344234353Sdim } 345234353Sdim 346261991Sdim AggValueSlot Dest = EnsureSlot(E->getType()); 347296417Sdim LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType()); 348261991Sdim LValue Start = CGF.EmitLValueForFieldInitialization(DestLV, *Field); 349261991Sdim llvm::Value *Zero = llvm::ConstantInt::get(CGF.PtrDiffTy, 0); 350261991Sdim llvm::Value *IdxStart[] = { Zero, Zero }; 351261991Sdim llvm::Value *ArrayStart = 352296417Sdim Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxStart, "arraystart"); 353261991Sdim CGF.EmitStoreThroughLValue(RValue::get(ArrayStart), Start); 354261991Sdim ++Field; 355261991Sdim 356261991Sdim if (Field == Record->field_end()) { 357261991Sdim CGF.ErrorUnsupported(E, "weird std::initializer_list"); 358234353Sdim return; 359234353Sdim } 360261991Sdim 361261991Sdim llvm::Value *Size = Builder.getInt(ArrayType->getSize()); 362261991Sdim LValue EndOrLength = CGF.EmitLValueForFieldInitialization(DestLV, *Field); 363261991Sdim if (Field->getType()->isPointerType() && 364261991Sdim Ctx.hasSameType(Field->getType()->getPointeeType(), 365261991Sdim ArrayType->getElementType())) { 366234353Sdim // End pointer. 367261991Sdim llvm::Value *IdxEnd[] = { Zero, Size }; 368261991Sdim llvm::Value *ArrayEnd = 369296417Sdim Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxEnd, "arrayend"); 370261991Sdim CGF.EmitStoreThroughLValue(RValue::get(ArrayEnd), EndOrLength); 371261991Sdim } else if (Ctx.hasSameType(Field->getType(), Ctx.getSizeType())) { 372234353Sdim // Length. 373261991Sdim CGF.EmitStoreThroughLValue(RValue::get(Size), EndOrLength); 374234353Sdim } else { 375261991Sdim CGF.ErrorUnsupported(E, "weird std::initializer_list"); 376234353Sdim return; 377234353Sdim } 378234353Sdim} 379234353Sdim 380276479Sdim/// \brief Determine if E is a trivial array filler, that is, one that is 381276479Sdim/// equivalent to zero-initialization. 382276479Sdimstatic bool isTrivialFiller(Expr *E) { 383276479Sdim if (!E) 384276479Sdim return true; 385276479Sdim 386276479Sdim if (isa<ImplicitValueInitExpr>(E)) 387276479Sdim return true; 388276479Sdim 389276479Sdim if (auto *ILE = dyn_cast<InitListExpr>(E)) { 390276479Sdim if (ILE->getNumInits()) 391276479Sdim return false; 392276479Sdim return isTrivialFiller(ILE->getArrayFiller()); 393276479Sdim } 394276479Sdim 395276479Sdim if (auto *Cons = dyn_cast_or_null<CXXConstructExpr>(E)) 396276479Sdim return Cons->getConstructor()->isDefaultConstructor() && 397276479Sdim Cons->getConstructor()->isTrivial(); 398276479Sdim 399276479Sdim // FIXME: Are there other cases where we can avoid emitting an initializer? 400276479Sdim return false; 401276479Sdim} 402276479Sdim 403234353Sdim/// \brief Emit initialization of an array from an initializer list. 404296417Sdimvoid AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType, 405234353Sdim QualType elementType, InitListExpr *E) { 406234353Sdim uint64_t NumInitElements = E->getNumInits(); 407234353Sdim 408234353Sdim uint64_t NumArrayElements = AType->getNumElements(); 409234353Sdim assert(NumInitElements <= NumArrayElements); 410234353Sdim 411234353Sdim // DestPtr is an array*. Construct an elementType* by drilling 412234353Sdim // down a level. 413234353Sdim llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0); 414234353Sdim llvm::Value *indices[] = { zero, zero }; 415234353Sdim llvm::Value *begin = 416296417Sdim Builder.CreateInBoundsGEP(DestPtr.getPointer(), indices, "arrayinit.begin"); 417234353Sdim 418296417Sdim CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType); 419296417Sdim CharUnits elementAlign = 420296417Sdim DestPtr.getAlignment().alignmentOfArrayElement(elementSize); 421296417Sdim 422234353Sdim // Exception safety requires us to destroy all the 423234353Sdim // already-constructed members if an initializer throws. 424234353Sdim // For that, we'll need an EH cleanup. 425234353Sdim QualType::DestructionKind dtorKind = elementType.isDestructedType(); 426296417Sdim Address endOfInit = Address::invalid(); 427234353Sdim EHScopeStack::stable_iterator cleanup; 428276479Sdim llvm::Instruction *cleanupDominator = nullptr; 429234353Sdim if (CGF.needsEHCleanup(dtorKind)) { 430234353Sdim // In principle we could tell the cleanup where we are more 431234353Sdim // directly, but the control flow can get so varied here that it 432234353Sdim // would actually be quite complex. Therefore we go through an 433234353Sdim // alloca. 434296417Sdim endOfInit = CGF.CreateTempAlloca(begin->getType(), CGF.getPointerAlign(), 435234353Sdim "arrayinit.endOfInit"); 436234353Sdim cleanupDominator = Builder.CreateStore(begin, endOfInit); 437234353Sdim CGF.pushIrregularPartialArrayCleanup(begin, endOfInit, elementType, 438296417Sdim elementAlign, 439234353Sdim CGF.getDestroyer(dtorKind)); 440234353Sdim cleanup = CGF.EHStack.stable_begin(); 441234353Sdim 442234353Sdim // Otherwise, remember that we didn't need a cleanup. 443234353Sdim } else { 444234353Sdim dtorKind = QualType::DK_none; 445234353Sdim } 446234353Sdim 447234353Sdim llvm::Value *one = llvm::ConstantInt::get(CGF.SizeTy, 1); 448234353Sdim 449234353Sdim // The 'current element to initialize'. The invariants on this 450234353Sdim // variable are complicated. Essentially, after each iteration of 451234353Sdim // the loop, it points to the last initialized element, except 452234353Sdim // that it points to the beginning of the array before any 453234353Sdim // elements have been initialized. 454234353Sdim llvm::Value *element = begin; 455234353Sdim 456234353Sdim // Emit the explicit initializers. 457234353Sdim for (uint64_t i = 0; i != NumInitElements; ++i) { 458234353Sdim // Advance to the next element. 459234353Sdim if (i > 0) { 460234353Sdim element = Builder.CreateInBoundsGEP(element, one, "arrayinit.element"); 461234353Sdim 462234353Sdim // Tell the cleanup that it needs to destroy up to this 463234353Sdim // element. TODO: some of these stores can be trivially 464234353Sdim // observed to be unnecessary. 465296417Sdim if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit); 466234353Sdim } 467234353Sdim 468296417Sdim LValue elementLV = 469296417Sdim CGF.MakeAddrLValue(Address(element, elementAlign), elementType); 470261991Sdim EmitInitializationToLValue(E->getInit(i), elementLV); 471234353Sdim } 472234353Sdim 473234353Sdim // Check whether there's a non-trivial array-fill expression. 474234353Sdim Expr *filler = E->getArrayFiller(); 475276479Sdim bool hasTrivialFiller = isTrivialFiller(filler); 476234353Sdim 477234353Sdim // Any remaining elements need to be zero-initialized, possibly 478234353Sdim // using the filler expression. We can skip this if the we're 479234353Sdim // emitting to zeroed memory. 480234353Sdim if (NumInitElements != NumArrayElements && 481234353Sdim !(Dest.isZeroed() && hasTrivialFiller && 482234353Sdim CGF.getTypes().isZeroInitializable(elementType))) { 483234353Sdim 484234353Sdim // Use an actual loop. This is basically 485234353Sdim // do { *array++ = filler; } while (array != end); 486234353Sdim 487234353Sdim // Advance to the start of the rest of the array. 488234353Sdim if (NumInitElements) { 489234353Sdim element = Builder.CreateInBoundsGEP(element, one, "arrayinit.start"); 490296417Sdim if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit); 491234353Sdim } 492234353Sdim 493234353Sdim // Compute the end of the array. 494234353Sdim llvm::Value *end = Builder.CreateInBoundsGEP(begin, 495234353Sdim llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements), 496234353Sdim "arrayinit.end"); 497234353Sdim 498234353Sdim llvm::BasicBlock *entryBB = Builder.GetInsertBlock(); 499234353Sdim llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body"); 500234353Sdim 501234353Sdim // Jump into the body. 502234353Sdim CGF.EmitBlock(bodyBB); 503234353Sdim llvm::PHINode *currentElement = 504234353Sdim Builder.CreatePHI(element->getType(), 2, "arrayinit.cur"); 505234353Sdim currentElement->addIncoming(element, entryBB); 506234353Sdim 507234353Sdim // Emit the actual filler expression. 508296417Sdim LValue elementLV = 509296417Sdim CGF.MakeAddrLValue(Address(currentElement, elementAlign), elementType); 510234353Sdim if (filler) 511234353Sdim EmitInitializationToLValue(filler, elementLV); 512234353Sdim else 513234353Sdim EmitNullInitializationToLValue(elementLV); 514234353Sdim 515234353Sdim // Move on to the next element. 516234353Sdim llvm::Value *nextElement = 517234353Sdim Builder.CreateInBoundsGEP(currentElement, one, "arrayinit.next"); 518234353Sdim 519234353Sdim // Tell the EH cleanup that we finished with the last element. 520296417Sdim if (endOfInit.isValid()) Builder.CreateStore(nextElement, endOfInit); 521234353Sdim 522234353Sdim // Leave the loop if we're done. 523234353Sdim llvm::Value *done = Builder.CreateICmpEQ(nextElement, end, 524234353Sdim "arrayinit.done"); 525234353Sdim llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end"); 526234353Sdim Builder.CreateCondBr(done, endBB, bodyBB); 527234353Sdim currentElement->addIncoming(nextElement, Builder.GetInsertBlock()); 528234353Sdim 529234353Sdim CGF.EmitBlock(endBB); 530234353Sdim } 531234353Sdim 532234353Sdim // Leave the partial-array cleanup if we entered one. 533234353Sdim if (dtorKind) CGF.DeactivateCleanupBlock(cleanup, cleanupDominator); 534234353Sdim} 535234353Sdim 536193326Sed//===----------------------------------------------------------------------===// 537193326Sed// Visitor Methods 538193326Sed//===----------------------------------------------------------------------===// 539193326Sed 540224145Sdimvoid AggExprEmitter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E){ 541224145Sdim Visit(E->GetTemporaryExpr()); 542224145Sdim} 543224145Sdim 544218893Sdimvoid AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) { 545239462Sdim EmitFinalDestCopy(e->getType(), CGF.getOpaqueLValueMapping(e)); 546218893Sdim} 547218893Sdim 548224145Sdimvoid 549224145SdimAggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 550249423Sdim if (Dest.isPotentiallyAliased() && 551249423Sdim E->getType().isPODType(CGF.getContext())) { 552224145Sdim // For a POD type, just emit a load of the lvalue + a copy, because our 553224145Sdim // compound literal might alias the destination. 554224145Sdim EmitAggLoadOfLValue(E); 555224145Sdim return; 556224145Sdim } 557224145Sdim 558224145Sdim AggValueSlot Slot = EnsureSlot(E->getType()); 559224145Sdim CGF.EmitAggExpr(E->getInitializer(), Slot); 560224145Sdim} 561224145Sdim 562249423Sdim/// Attempt to look through various unimportant expressions to find a 563249423Sdim/// cast of the given kind. 564249423Sdimstatic Expr *findPeephole(Expr *op, CastKind kind) { 565249423Sdim while (true) { 566249423Sdim op = op->IgnoreParens(); 567249423Sdim if (CastExpr *castE = dyn_cast<CastExpr>(op)) { 568249423Sdim if (castE->getCastKind() == kind) 569249423Sdim return castE->getSubExpr(); 570249423Sdim if (castE->getCastKind() == CK_NoOp) 571249423Sdim continue; 572249423Sdim } 573276479Sdim return nullptr; 574249423Sdim } 575249423Sdim} 576224145Sdim 577198092Srdivackyvoid AggExprEmitter::VisitCastExpr(CastExpr *E) { 578296417Sdim if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E)) 579296417Sdim CGF.CGM.EmitExplicitCastExprType(ECE, &CGF); 580198092Srdivacky switch (E->getCastKind()) { 581212904Sdim case CK_Dynamic: { 582243830Sdim // FIXME: Can this actually happen? We have no test coverage for it. 583208600Srdivacky assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?"); 584243830Sdim LValue LV = CGF.EmitCheckedLValue(E->getSubExpr(), 585243830Sdim CodeGenFunction::TCK_Load); 586208600Srdivacky // FIXME: Do we also need to handle property references here? 587208600Srdivacky if (LV.isSimple()) 588208600Srdivacky CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E)); 589208600Srdivacky else 590208600Srdivacky CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast"); 591208600Srdivacky 592218893Sdim if (!Dest.isIgnored()) 593218893Sdim CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination"); 594208600Srdivacky break; 595208600Srdivacky } 596208600Srdivacky 597212904Sdim case CK_ToUnion: { 598288943Sdim // Evaluate even if the destination is ignored. 599288943Sdim if (Dest.isIgnored()) { 600288943Sdim CGF.EmitAnyExpr(E->getSubExpr(), AggValueSlot::ignored(), 601288943Sdim /*ignoreResult=*/true); 602288943Sdim break; 603288943Sdim } 604221345Sdim 605198092Srdivacky // GCC union extension 606212904Sdim QualType Ty = E->getSubExpr()->getType(); 607296417Sdim Address CastPtr = 608296417Sdim Builder.CreateElementBitCast(Dest.getAddress(), CGF.ConvertType(Ty)); 609224145Sdim EmitInitializationToLValue(E->getSubExpr(), 610224145Sdim CGF.MakeAddrLValue(CastPtr, Ty)); 611198092Srdivacky break; 612193326Sed } 613193326Sed 614212904Sdim case CK_DerivedToBase: 615212904Sdim case CK_BaseToDerived: 616212904Sdim case CK_UncheckedDerivedToBase: { 617226633Sdim llvm_unreachable("cannot perform hierarchy conversion in EmitAggExpr: " 618208600Srdivacky "should have been unpacked before we got here"); 619208600Srdivacky } 620208600Srdivacky 621249423Sdim case CK_NonAtomicToAtomic: 622249423Sdim case CK_AtomicToNonAtomic: { 623249423Sdim bool isToAtomic = (E->getCastKind() == CK_NonAtomicToAtomic); 624249423Sdim 625249423Sdim // Determine the atomic and value types. 626249423Sdim QualType atomicType = E->getSubExpr()->getType(); 627249423Sdim QualType valueType = E->getType(); 628249423Sdim if (isToAtomic) std::swap(atomicType, valueType); 629249423Sdim 630249423Sdim assert(atomicType->isAtomicType()); 631249423Sdim assert(CGF.getContext().hasSameUnqualifiedType(valueType, 632249423Sdim atomicType->castAs<AtomicType>()->getValueType())); 633249423Sdim 634249423Sdim // Just recurse normally if we're ignoring the result or the 635249423Sdim // atomic type doesn't change representation. 636249423Sdim if (Dest.isIgnored() || !CGF.CGM.isPaddedAtomicType(atomicType)) { 637249423Sdim return Visit(E->getSubExpr()); 638249423Sdim } 639249423Sdim 640249423Sdim CastKind peepholeTarget = 641249423Sdim (isToAtomic ? CK_AtomicToNonAtomic : CK_NonAtomicToAtomic); 642249423Sdim 643249423Sdim // These two cases are reverses of each other; try to peephole them. 644249423Sdim if (Expr *op = findPeephole(E->getSubExpr(), peepholeTarget)) { 645249423Sdim assert(CGF.getContext().hasSameUnqualifiedType(op->getType(), 646249423Sdim E->getType()) && 647249423Sdim "peephole significantly changed types?"); 648249423Sdim return Visit(op); 649249423Sdim } 650249423Sdim 651249423Sdim // If we're converting an r-value of non-atomic type to an r-value 652261991Sdim // of atomic type, just emit directly into the relevant sub-object. 653249423Sdim if (isToAtomic) { 654261991Sdim AggValueSlot valueDest = Dest; 655261991Sdim if (!valueDest.isIgnored() && CGF.CGM.isPaddedAtomicType(atomicType)) { 656261991Sdim // Zero-initialize. (Strictly speaking, we only need to intialize 657261991Sdim // the padding at the end, but this is simpler.) 658261991Sdim if (!Dest.isZeroed()) 659296417Sdim CGF.EmitNullInitialization(Dest.getAddress(), atomicType); 660261991Sdim 661261991Sdim // Build a GEP to refer to the subobject. 662296417Sdim Address valueAddr = 663296417Sdim CGF.Builder.CreateStructGEP(valueDest.getAddress(), 0, 664296417Sdim CharUnits()); 665261991Sdim valueDest = AggValueSlot::forAddr(valueAddr, 666261991Sdim valueDest.getQualifiers(), 667261991Sdim valueDest.isExternallyDestructed(), 668261991Sdim valueDest.requiresGCollection(), 669261991Sdim valueDest.isPotentiallyAliased(), 670261991Sdim AggValueSlot::IsZeroed); 671261991Sdim } 672261991Sdim 673261991Sdim CGF.EmitAggExpr(E->getSubExpr(), valueDest); 674249423Sdim return; 675249423Sdim } 676249423Sdim 677249423Sdim // Otherwise, we're converting an atomic type to a non-atomic type. 678261991Sdim // Make an atomic temporary, emit into that, and then copy the value out. 679249423Sdim AggValueSlot atomicSlot = 680249423Sdim CGF.CreateAggTemp(atomicType, "atomic-to-nonatomic.temp"); 681249423Sdim CGF.EmitAggExpr(E->getSubExpr(), atomicSlot); 682249423Sdim 683296417Sdim Address valueAddr = 684296417Sdim Builder.CreateStructGEP(atomicSlot.getAddress(), 0, CharUnits()); 685249423Sdim RValue rvalue = RValue::getAggregate(valueAddr, atomicSlot.isVolatile()); 686249423Sdim return EmitFinalDestCopy(valueType, rvalue); 687249423Sdim } 688249423Sdim 689239462Sdim case CK_LValueToRValue: 690239462Sdim // If we're loading from a volatile type, force the destination 691239462Sdim // into existence. 692239462Sdim if (E->getSubExpr()->getType().isVolatileQualified()) { 693239462Sdim EnsureDest(E->getType()); 694239462Sdim return Visit(E->getSubExpr()); 695239462Sdim } 696249423Sdim 697239462Sdim // fallthrough 698239462Sdim 699212904Sdim case CK_NoOp: 700212904Sdim case CK_UserDefinedConversion: 701212904Sdim case CK_ConstructorConversion: 702198092Srdivacky assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(), 703198092Srdivacky E->getType()) && 704198092Srdivacky "Implicit cast types must be compatible"); 705198092Srdivacky Visit(E->getSubExpr()); 706198092Srdivacky break; 707218893Sdim 708212904Sdim case CK_LValueBitCast: 709218893Sdim llvm_unreachable("should not be emitting lvalue bitcast as rvalue"); 710221345Sdim 711218893Sdim case CK_Dependent: 712218893Sdim case CK_BitCast: 713218893Sdim case CK_ArrayToPointerDecay: 714218893Sdim case CK_FunctionToPointerDecay: 715218893Sdim case CK_NullToPointer: 716218893Sdim case CK_NullToMemberPointer: 717218893Sdim case CK_BaseToDerivedMemberPointer: 718218893Sdim case CK_DerivedToBaseMemberPointer: 719218893Sdim case CK_MemberPointerToBoolean: 720234353Sdim case CK_ReinterpretMemberPointer: 721218893Sdim case CK_IntegralToPointer: 722218893Sdim case CK_PointerToIntegral: 723218893Sdim case CK_PointerToBoolean: 724218893Sdim case CK_ToVoid: 725218893Sdim case CK_VectorSplat: 726218893Sdim case CK_IntegralCast: 727296417Sdim case CK_BooleanToSignedIntegral: 728218893Sdim case CK_IntegralToBoolean: 729218893Sdim case CK_IntegralToFloating: 730218893Sdim case CK_FloatingToIntegral: 731218893Sdim case CK_FloatingToBoolean: 732218893Sdim case CK_FloatingCast: 733226633Sdim case CK_CPointerToObjCPointerCast: 734226633Sdim case CK_BlockPointerToObjCPointerCast: 735218893Sdim case CK_AnyPointerToBlockPointerCast: 736218893Sdim case CK_ObjCObjectLValueCast: 737218893Sdim case CK_FloatingRealToComplex: 738218893Sdim case CK_FloatingComplexToReal: 739218893Sdim case CK_FloatingComplexToBoolean: 740218893Sdim case CK_FloatingComplexCast: 741218893Sdim case CK_FloatingComplexToIntegralComplex: 742218893Sdim case CK_IntegralRealToComplex: 743218893Sdim case CK_IntegralComplexToReal: 744218893Sdim case CK_IntegralComplexToBoolean: 745218893Sdim case CK_IntegralComplexCast: 746218893Sdim case CK_IntegralComplexToFloatingComplex: 747226633Sdim case CK_ARCProduceObject: 748226633Sdim case CK_ARCConsumeObject: 749226633Sdim case CK_ARCReclaimReturnedObject: 750226633Sdim case CK_ARCExtendBlockObject: 751234353Sdim case CK_CopyAndAutoreleaseBlockObject: 752243830Sdim case CK_BuiltinFnToFnPtr: 753249423Sdim case CK_ZeroToOCLEvent: 754314564Sdim case CK_ZeroToOCLQueue: 755276479Sdim case CK_AddressSpaceConversion: 756314564Sdim case CK_IntToOCLSampler: 757218893Sdim llvm_unreachable("cast kind invalid for aggregate types"); 758198398Srdivacky } 759193326Sed} 760193326Sed 761193326Sedvoid AggExprEmitter::VisitCallExpr(const CallExpr *E) { 762288943Sdim if (E->getCallReturnType(CGF.getContext())->isReferenceType()) { 763193326Sed EmitAggLoadOfLValue(E); 764193326Sed return; 765193326Sed } 766198092Srdivacky 767208600Srdivacky RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot()); 768226633Sdim EmitMoveFromReturnSlot(E, RV); 769193326Sed} 770193326Sed 771193326Sedvoid AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) { 772208600Srdivacky RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot()); 773226633Sdim EmitMoveFromReturnSlot(E, RV); 774193326Sed} 775193326Sed 776193326Sedvoid AggExprEmitter::VisitBinComma(const BinaryOperator *E) { 777218893Sdim CGF.EmitIgnoredExpr(E->getLHS()); 778218893Sdim Visit(E->getRHS()); 779193326Sed} 780193326Sed 781193326Sedvoid AggExprEmitter::VisitStmtExpr(const StmtExpr *E) { 782218893Sdim CodeGenFunction::StmtExprEvaluation eval(CGF); 783218893Sdim CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest); 784193326Sed} 785193326Sed 786193326Sedvoid AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) { 787212904Sdim if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI) 788198398Srdivacky VisitPointerToDataMemberBinaryOperator(E); 789198398Srdivacky else 790198398Srdivacky CGF.ErrorUnsupported(E, "aggregate binary expression"); 791193326Sed} 792193326Sed 793198398Srdivackyvoid AggExprEmitter::VisitPointerToDataMemberBinaryOperator( 794198398Srdivacky const BinaryOperator *E) { 795198398Srdivacky LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E); 796239462Sdim EmitFinalDestCopy(E->getType(), LV); 797198398Srdivacky} 798198398Srdivacky 799239462Sdim/// Is the value of the given expression possibly a reference to or 800239462Sdim/// into a __block variable? 801239462Sdimstatic bool isBlockVarRef(const Expr *E) { 802239462Sdim // Make sure we look through parens. 803239462Sdim E = E->IgnoreParens(); 804239462Sdim 805239462Sdim // Check for a direct reference to a __block variable. 806239462Sdim if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 807239462Sdim const VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl()); 808239462Sdim return (var && var->hasAttr<BlocksAttr>()); 809239462Sdim } 810239462Sdim 811239462Sdim // More complicated stuff. 812239462Sdim 813239462Sdim // Binary operators. 814239462Sdim if (const BinaryOperator *op = dyn_cast<BinaryOperator>(E)) { 815239462Sdim // For an assignment or pointer-to-member operation, just care 816239462Sdim // about the LHS. 817239462Sdim if (op->isAssignmentOp() || op->isPtrMemOp()) 818239462Sdim return isBlockVarRef(op->getLHS()); 819239462Sdim 820239462Sdim // For a comma, just care about the RHS. 821239462Sdim if (op->getOpcode() == BO_Comma) 822239462Sdim return isBlockVarRef(op->getRHS()); 823239462Sdim 824239462Sdim // FIXME: pointer arithmetic? 825239462Sdim return false; 826239462Sdim 827239462Sdim // Check both sides of a conditional operator. 828239462Sdim } else if (const AbstractConditionalOperator *op 829239462Sdim = dyn_cast<AbstractConditionalOperator>(E)) { 830239462Sdim return isBlockVarRef(op->getTrueExpr()) 831239462Sdim || isBlockVarRef(op->getFalseExpr()); 832239462Sdim 833239462Sdim // OVEs are required to support BinaryConditionalOperators. 834239462Sdim } else if (const OpaqueValueExpr *op 835239462Sdim = dyn_cast<OpaqueValueExpr>(E)) { 836239462Sdim if (const Expr *src = op->getSourceExpr()) 837239462Sdim return isBlockVarRef(src); 838239462Sdim 839239462Sdim // Casts are necessary to get things like (*(int*)&var) = foo(). 840239462Sdim // We don't really care about the kind of cast here, except 841239462Sdim // we don't want to look through l2r casts, because it's okay 842239462Sdim // to get the *value* in a __block variable. 843239462Sdim } else if (const CastExpr *cast = dyn_cast<CastExpr>(E)) { 844239462Sdim if (cast->getCastKind() == CK_LValueToRValue) 845239462Sdim return false; 846239462Sdim return isBlockVarRef(cast->getSubExpr()); 847239462Sdim 848239462Sdim // Handle unary operators. Again, just aggressively look through 849239462Sdim // it, ignoring the operation. 850239462Sdim } else if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E)) { 851239462Sdim return isBlockVarRef(uop->getSubExpr()); 852239462Sdim 853239462Sdim // Look into the base of a field access. 854239462Sdim } else if (const MemberExpr *mem = dyn_cast<MemberExpr>(E)) { 855239462Sdim return isBlockVarRef(mem->getBase()); 856239462Sdim 857239462Sdim // Look into the base of a subscript. 858239462Sdim } else if (const ArraySubscriptExpr *sub = dyn_cast<ArraySubscriptExpr>(E)) { 859239462Sdim return isBlockVarRef(sub->getBase()); 860239462Sdim } 861239462Sdim 862239462Sdim return false; 863239462Sdim} 864239462Sdim 865193326Sedvoid AggExprEmitter::VisitBinAssign(const BinaryOperator *E) { 866193326Sed // For an assignment to work, the value on the right has 867193326Sed // to be compatible with the value on the left. 868193326Sed assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 869193326Sed E->getRHS()->getType()) 870193326Sed && "Invalid assignment"); 871218893Sdim 872239462Sdim // If the LHS might be a __block variable, and the RHS can 873239462Sdim // potentially cause a block copy, we need to evaluate the RHS first 874239462Sdim // so that the assignment goes the right place. 875239462Sdim // This is pretty semantically fragile. 876239462Sdim if (isBlockVarRef(E->getLHS()) && 877239462Sdim E->getRHS()->HasSideEffects(CGF.getContext())) { 878239462Sdim // Ensure that we have a destination, and evaluate the RHS into that. 879239462Sdim EnsureDest(E->getRHS()->getType()); 880239462Sdim Visit(E->getRHS()); 881239462Sdim 882239462Sdim // Now emit the LHS and copy into it. 883243830Sdim LValue LHS = CGF.EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store); 884239462Sdim 885249423Sdim // That copy is an atomic copy if the LHS is atomic. 886288943Sdim if (LHS.getType()->isAtomicType() || 887288943Sdim CGF.LValueIsSuitableForInlineAtomic(LHS)) { 888249423Sdim CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false); 889249423Sdim return; 890249423Sdim } 891249423Sdim 892239462Sdim EmitCopy(E->getLHS()->getType(), 893239462Sdim AggValueSlot::forLValue(LHS, AggValueSlot::IsDestructed, 894239462Sdim needsGC(E->getLHS()->getType()), 895239462Sdim AggValueSlot::IsAliased), 896239462Sdim Dest); 897239462Sdim return; 898239462Sdim } 899221345Sdim 900193326Sed LValue LHS = CGF.EmitLValue(E->getLHS()); 901193326Sed 902249423Sdim // If we have an atomic type, evaluate into the destination and then 903249423Sdim // do an atomic copy. 904288943Sdim if (LHS.getType()->isAtomicType() || 905288943Sdim CGF.LValueIsSuitableForInlineAtomic(LHS)) { 906249423Sdim EnsureDest(E->getRHS()->getType()); 907249423Sdim Visit(E->getRHS()); 908249423Sdim CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false); 909249423Sdim return; 910249423Sdim } 911249423Sdim 912234353Sdim // Codegen the RHS so that it stores directly into the LHS. 913234353Sdim AggValueSlot LHSSlot = 914234353Sdim AggValueSlot::forLValue(LHS, AggValueSlot::IsDestructed, 915234353Sdim needsGC(E->getLHS()->getType()), 916234353Sdim AggValueSlot::IsAliased); 917249423Sdim // A non-volatile aggregate destination might have volatile member. 918249423Sdim if (!LHSSlot.isVolatile() && 919249423Sdim CGF.hasVolatileMember(E->getLHS()->getType())) 920249423Sdim LHSSlot.setVolatile(true); 921249423Sdim 922239462Sdim CGF.EmitAggExpr(E->getRHS(), LHSSlot); 923239462Sdim 924239462Sdim // Copy into the destination if the assignment isn't ignored. 925239462Sdim EmitFinalDestCopy(E->getType(), LHS); 926193326Sed} 927193326Sed 928218893Sdimvoid AggExprEmitter:: 929218893SdimVisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 930193326Sed llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 931193326Sed llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 932193326Sed llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 933198092Srdivacky 934218893Sdim // Bind the common expression if necessary. 935218893Sdim CodeGenFunction::OpaqueValueMapping binding(CGF, E); 936218893Sdim 937218893Sdim CodeGenFunction::ConditionalEvaluation eval(CGF); 938288943Sdim CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock, 939288943Sdim CGF.getProfileCount(E)); 940198092Srdivacky 941218893Sdim // Save whether the destination's lifetime is externally managed. 942226633Sdim bool isExternallyDestructed = Dest.isExternallyDestructed(); 943218893Sdim 944218893Sdim eval.begin(CGF); 945193326Sed CGF.EmitBlock(LHSBlock); 946288943Sdim CGF.incrementProfileCounter(E); 947218893Sdim Visit(E->getTrueExpr()); 948218893Sdim eval.end(CGF); 949198092Srdivacky 950218893Sdim assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!"); 951218893Sdim CGF.Builder.CreateBr(ContBlock); 952193326Sed 953218893Sdim // If the result of an agg expression is unused, then the emission 954218893Sdim // of the LHS might need to create a destination slot. That's fine 955218893Sdim // with us, and we can safely emit the RHS into the same slot, but 956226633Sdim // we shouldn't claim that it's already being destructed. 957226633Sdim Dest.setExternallyDestructed(isExternallyDestructed); 958198092Srdivacky 959218893Sdim eval.begin(CGF); 960193326Sed CGF.EmitBlock(RHSBlock); 961218893Sdim Visit(E->getFalseExpr()); 962218893Sdim eval.end(CGF); 963198092Srdivacky 964193326Sed CGF.EmitBlock(ContBlock); 965193326Sed} 966193326Sed 967198092Srdivackyvoid AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) { 968261991Sdim Visit(CE->getChosenSubExpr()); 969198092Srdivacky} 970198092Srdivacky 971193326Sedvoid AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 972296417Sdim Address ArgValue = Address::invalid(); 973296417Sdim Address ArgPtr = CGF.EmitVAArg(VE, ArgValue); 974193326Sed 975309124Sdim // If EmitVAArg fails, emit an error. 976296417Sdim if (!ArgPtr.isValid()) { 977309124Sdim CGF.ErrorUnsupported(VE, "aggregate va_arg expression"); 978193326Sed return; 979193326Sed } 980193326Sed 981239462Sdim EmitFinalDestCopy(VE->getType(), CGF.MakeAddrLValue(ArgPtr, VE->getType())); 982193326Sed} 983193326Sed 984193326Sedvoid AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 985218893Sdim // Ensure that we have a slot, but if we already do, remember 986226633Sdim // whether it was externally destructed. 987226633Sdim bool wasExternallyDestructed = Dest.isExternallyDestructed(); 988239462Sdim EnsureDest(E->getType()); 989198092Srdivacky 990226633Sdim // We're going to push a destructor if there isn't already one. 991226633Sdim Dest.setExternallyDestructed(); 992226633Sdim 993218893Sdim Visit(E->getSubExpr()); 994193326Sed 995226633Sdim // Push that destructor we promised. 996226633Sdim if (!wasExternallyDestructed) 997296417Sdim CGF.EmitCXXTemporary(E->getTemporary(), E->getType(), Dest.getAddress()); 998193326Sed} 999193326Sed 1000193326Sedvoid 1001193326SedAggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) { 1002218893Sdim AggValueSlot Slot = EnsureSlot(E->getType()); 1003218893Sdim CGF.EmitCXXConstructExpr(E, Slot); 1004193326Sed} 1005193326Sed 1006309124Sdimvoid AggExprEmitter::VisitCXXInheritedCtorInitExpr( 1007309124Sdim const CXXInheritedCtorInitExpr *E) { 1008309124Sdim AggValueSlot Slot = EnsureSlot(E->getType()); 1009309124Sdim CGF.EmitInheritedCXXConstructorCall( 1010309124Sdim E->getConstructor(), E->constructsVBase(), Slot.getAddress(), 1011309124Sdim E->inheritedFromVBase(), E); 1012309124Sdim} 1013309124Sdim 1014234353Sdimvoid 1015234353SdimAggExprEmitter::VisitLambdaExpr(LambdaExpr *E) { 1016234353Sdim AggValueSlot Slot = EnsureSlot(E->getType()); 1017234353Sdim CGF.EmitLambdaExpr(E, Slot); 1018234353Sdim} 1019234353Sdim 1020218893Sdimvoid AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) { 1021234353Sdim CGF.enterFullExpression(E); 1022234353Sdim CodeGenFunction::RunCleanupsScope cleanups(CGF); 1023234353Sdim Visit(E->getSubExpr()); 1024193326Sed} 1025193326Sed 1026210299Sedvoid AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1027218893Sdim QualType T = E->getType(); 1028218893Sdim AggValueSlot Slot = EnsureSlot(T); 1029296417Sdim EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T)); 1030198398Srdivacky} 1031198398Srdivacky 1032201361Srdivackyvoid AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 1033218893Sdim QualType T = E->getType(); 1034218893Sdim AggValueSlot Slot = EnsureSlot(T); 1035296417Sdim EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T)); 1036218893Sdim} 1037201361Srdivacky 1038218893Sdim/// isSimpleZero - If emitting this value will obviously just cause a store of 1039218893Sdim/// zero to memory, return true. This can return false if uncertain, so it just 1040218893Sdim/// handles simple cases. 1041218893Sdimstatic bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) { 1042221345Sdim E = E->IgnoreParens(); 1043221345Sdim 1044218893Sdim // 0 1045218893Sdim if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E)) 1046218893Sdim return IL->getValue() == 0; 1047218893Sdim // +0.0 1048218893Sdim if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E)) 1049218893Sdim return FL->getValue().isPosZero(); 1050218893Sdim // int() 1051218893Sdim if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) && 1052218893Sdim CGF.getTypes().isZeroInitializable(E->getType())) 1053218893Sdim return true; 1054218893Sdim // (int*)0 - Null pointer expressions. 1055218893Sdim if (const CastExpr *ICE = dyn_cast<CastExpr>(E)) 1056314564Sdim return ICE->getCastKind() == CK_NullToPointer && 1057314564Sdim CGF.getTypes().isPointerZeroInitializable(E->getType()); 1058218893Sdim // '\0' 1059218893Sdim if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E)) 1060218893Sdim return CL->getValue() == 0; 1061218893Sdim 1062218893Sdim // Otherwise, hard case: conservatively return false. 1063218893Sdim return false; 1064201361Srdivacky} 1065201361Srdivacky 1066218893Sdim 1067203955Srdivackyvoid 1068261991SdimAggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) { 1069224145Sdim QualType type = LV.getType(); 1070193326Sed // FIXME: Ignore result? 1071193326Sed // FIXME: Are initializers affected by volatile? 1072218893Sdim if (Dest.isZeroed() && isSimpleZero(E, CGF)) { 1073218893Sdim // Storing "i32 0" to a zero'd memory location is a noop. 1074249423Sdim return; 1075249423Sdim } else if (isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) { 1076249423Sdim return EmitNullInitializationToLValue(LV); 1077288943Sdim } else if (isa<NoInitExpr>(E)) { 1078288943Sdim // Do nothing. 1079288943Sdim return; 1080224145Sdim } else if (type->isReferenceType()) { 1081261991Sdim RValue RV = CGF.EmitReferenceBindingToExpr(E); 1082249423Sdim return CGF.EmitStoreThroughLValue(RV, LV); 1083249423Sdim } 1084249423Sdim 1085249423Sdim switch (CGF.getEvaluationKind(type)) { 1086249423Sdim case TEK_Complex: 1087249423Sdim CGF.EmitComplexExprIntoLValue(E, LV, /*isInit*/ true); 1088249423Sdim return; 1089249423Sdim case TEK_Aggregate: 1090226633Sdim CGF.EmitAggExpr(E, AggValueSlot::forLValue(LV, 1091226633Sdim AggValueSlot::IsDestructed, 1092226633Sdim AggValueSlot::DoesNotNeedGCBarriers, 1093226633Sdim AggValueSlot::IsNotAliased, 1094224145Sdim Dest.isZeroed())); 1095249423Sdim return; 1096249423Sdim case TEK_Scalar: 1097249423Sdim if (LV.isSimple()) { 1098276479Sdim CGF.EmitScalarInit(E, /*D=*/nullptr, LV, /*Captured=*/false); 1099249423Sdim } else { 1100249423Sdim CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV); 1101249423Sdim } 1102249423Sdim return; 1103193326Sed } 1104249423Sdim llvm_unreachable("bad evaluation kind"); 1105193326Sed} 1106193326Sed 1107224145Sdimvoid AggExprEmitter::EmitNullInitializationToLValue(LValue lv) { 1108224145Sdim QualType type = lv.getType(); 1109224145Sdim 1110218893Sdim // If the destination slot is already zeroed out before the aggregate is 1111218893Sdim // copied into it, we don't have to emit any zeros here. 1112224145Sdim if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(type)) 1113218893Sdim return; 1114218893Sdim 1115249423Sdim if (CGF.hasScalarEvaluationKind(type)) { 1116249423Sdim // For non-aggregates, we can store the appropriate null constant. 1117249423Sdim llvm::Value *null = CGF.CGM.EmitNullConstant(type); 1118234353Sdim // Note that the following is not equivalent to 1119234353Sdim // EmitStoreThroughBitfieldLValue for ARC types. 1120234353Sdim if (lv.isBitField()) { 1121234353Sdim CGF.EmitStoreThroughBitfieldLValue(RValue::get(null), lv); 1122234353Sdim } else { 1123234353Sdim assert(lv.isSimple()); 1124234353Sdim CGF.EmitStoreOfScalar(null, lv, /* isInitialization */ true); 1125234353Sdim } 1126193326Sed } else { 1127193326Sed // There's a potential optimization opportunity in combining 1128193326Sed // memsets; that would be easy for arrays, but relatively 1129193326Sed // difficult for structures with the current code. 1130224145Sdim CGF.EmitNullInitialization(lv.getAddress(), lv.getType()); 1131193326Sed } 1132193326Sed} 1133193326Sed 1134193326Sedvoid AggExprEmitter::VisitInitListExpr(InitListExpr *E) { 1135193326Sed#if 0 1136200583Srdivacky // FIXME: Assess perf here? Figure out what cases are worth optimizing here 1137200583Srdivacky // (Length of globals? Chunks of zeroed-out space?). 1138193326Sed // 1139193326Sed // If we can, prefer a copy from a global; this is a lot less code for long 1140193326Sed // globals, and it's easier for the current optimizers to analyze. 1141200583Srdivacky if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) { 1142193326Sed llvm::GlobalVariable* GV = 1143200583Srdivacky new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true, 1144200583Srdivacky llvm::GlobalValue::InternalLinkage, C, ""); 1145239462Sdim EmitFinalDestCopy(E->getType(), CGF.MakeAddrLValue(GV, E->getType())); 1146193326Sed return; 1147193326Sed } 1148193326Sed#endif 1149218893Sdim if (E->hadArrayRangeDesignator()) 1150193326Sed CGF.ErrorUnsupported(E, "GNU array range designator extension"); 1151193326Sed 1152314564Sdim if (E->isTransparent()) 1153314564Sdim return Visit(E->getInit(0)); 1154314564Sdim 1155261991Sdim AggValueSlot Dest = EnsureSlot(E->getType()); 1156218893Sdim 1157296417Sdim LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType()); 1158234353Sdim 1159193326Sed // Handle initialization of an array. 1160193326Sed if (E->getType()->isArrayType()) { 1161234353Sdim QualType elementType = 1162234353Sdim CGF.getContext().getAsArrayType(E->getType())->getElementType(); 1163193326Sed 1164296417Sdim auto AType = cast<llvm::ArrayType>(Dest.getAddress().getElementType()); 1165296417Sdim EmitArrayInit(Dest.getAddress(), AType, elementType, E); 1166193326Sed return; 1167193326Sed } 1168198092Srdivacky 1169193326Sed assert(E->getType()->isRecordType() && "Only support structs/unions here!"); 1170198092Srdivacky 1171193326Sed // Do struct initialization; this code just sets each individual member 1172193326Sed // to the approprate value. This makes bitfield support automatic; 1173193326Sed // the disadvantage is that the generated code is more difficult for 1174193326Sed // the optimizer, especially with bitfields. 1175193326Sed unsigned NumInitElements = E->getNumInits(); 1176224145Sdim RecordDecl *record = E->getType()->castAs<RecordType>()->getDecl(); 1177251662Sdim 1178309124Sdim // We'll need to enter cleanup scopes in case any of the element 1179309124Sdim // initializers throws an exception. 1180309124Sdim SmallVector<EHScopeStack::stable_iterator, 16> cleanups; 1181309124Sdim llvm::Instruction *cleanupDominator = nullptr; 1182309124Sdim 1183309124Sdim unsigned curInitIndex = 0; 1184309124Sdim 1185309124Sdim // Emit initialization of base classes. 1186309124Sdim if (auto *CXXRD = dyn_cast<CXXRecordDecl>(record)) { 1187309124Sdim assert(E->getNumInits() >= CXXRD->getNumBases() && 1188309124Sdim "missing initializer for base class"); 1189309124Sdim for (auto &Base : CXXRD->bases()) { 1190309124Sdim assert(!Base.isVirtual() && "should not see vbases here"); 1191309124Sdim auto *BaseRD = Base.getType()->getAsCXXRecordDecl(); 1192309124Sdim Address V = CGF.GetAddressOfDirectBaseInCompleteClass( 1193309124Sdim Dest.getAddress(), CXXRD, BaseRD, 1194309124Sdim /*isBaseVirtual*/ false); 1195309124Sdim AggValueSlot AggSlot = 1196309124Sdim AggValueSlot::forAddr(V, Qualifiers(), 1197309124Sdim AggValueSlot::IsDestructed, 1198309124Sdim AggValueSlot::DoesNotNeedGCBarriers, 1199309124Sdim AggValueSlot::IsNotAliased); 1200309124Sdim CGF.EmitAggExpr(E->getInit(curInitIndex++), AggSlot); 1201309124Sdim 1202309124Sdim if (QualType::DestructionKind dtorKind = 1203309124Sdim Base.getType().isDestructedType()) { 1204309124Sdim CGF.pushDestroy(dtorKind, V, Base.getType()); 1205309124Sdim cleanups.push_back(CGF.EHStack.stable_begin()); 1206309124Sdim } 1207309124Sdim } 1208309124Sdim } 1209309124Sdim 1210251662Sdim // Prepare a 'this' for CXXDefaultInitExprs. 1211296417Sdim CodeGenFunction::FieldConstructionScope FCS(CGF, Dest.getAddress()); 1212251662Sdim 1213224145Sdim if (record->isUnion()) { 1214193326Sed // Only initialize one field of a union. The field itself is 1215193326Sed // specified by the initializer list. 1216193326Sed if (!E->getInitializedFieldInUnion()) { 1217193326Sed // Empty union; we have nothing to do. 1218198092Srdivacky 1219193326Sed#ifndef NDEBUG 1220193326Sed // Make sure that it's really an empty and not a failure of 1221193326Sed // semantic analysis. 1222276479Sdim for (const auto *Field : record->fields()) 1223193326Sed assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed"); 1224193326Sed#endif 1225193326Sed return; 1226193326Sed } 1227193326Sed 1228193326Sed // FIXME: volatility 1229193326Sed FieldDecl *Field = E->getInitializedFieldInUnion(); 1230218893Sdim 1231234982Sdim LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestLV, Field); 1232193326Sed if (NumInitElements) { 1233193326Sed // Store the initializer into the field 1234224145Sdim EmitInitializationToLValue(E->getInit(0), FieldLoc); 1235193326Sed } else { 1236218893Sdim // Default-initialize to null. 1237224145Sdim EmitNullInitializationToLValue(FieldLoc); 1238193326Sed } 1239193326Sed 1240193326Sed return; 1241193326Sed } 1242198092Srdivacky 1243193326Sed // Here we iterate over the fields; this makes it simpler to both 1244193326Sed // default-initialize fields and skip over unnamed fields. 1245276479Sdim for (const auto *field : record->fields()) { 1246224145Sdim // We're done once we hit the flexible array member. 1247224145Sdim if (field->getType()->isIncompleteArrayType()) 1248193326Sed break; 1249193326Sed 1250224145Sdim // Always skip anonymous bitfields. 1251224145Sdim if (field->isUnnamedBitfield()) 1252193326Sed continue; 1253193326Sed 1254224145Sdim // We're done if we reach the end of the explicit initializers, we 1255224145Sdim // have a zeroed object, and the rest of the fields are 1256224145Sdim // zero-initializable. 1257224145Sdim if (curInitIndex == NumInitElements && Dest.isZeroed() && 1258218893Sdim CGF.getTypes().isZeroInitializable(E->getType())) 1259218893Sdim break; 1260218893Sdim 1261234982Sdim 1262276479Sdim LValue LV = CGF.EmitLValueForFieldInitialization(DestLV, field); 1263193326Sed // We never generate write-barries for initialized fields. 1264224145Sdim LV.setNonGC(true); 1265218893Sdim 1266224145Sdim if (curInitIndex < NumInitElements) { 1267204962Srdivacky // Store the initializer into the field. 1268224145Sdim EmitInitializationToLValue(E->getInit(curInitIndex++), LV); 1269193326Sed } else { 1270193326Sed // We're out of initalizers; default-initialize to null 1271224145Sdim EmitNullInitializationToLValue(LV); 1272193326Sed } 1273224145Sdim 1274224145Sdim // Push a destructor if necessary. 1275224145Sdim // FIXME: if we have an array of structures, all explicitly 1276224145Sdim // initialized, we can end up pushing a linear number of cleanups. 1277224145Sdim bool pushedCleanup = false; 1278224145Sdim if (QualType::DestructionKind dtorKind 1279224145Sdim = field->getType().isDestructedType()) { 1280224145Sdim assert(LV.isSimple()); 1281224145Sdim if (CGF.needsEHCleanup(dtorKind)) { 1282234353Sdim if (!cleanupDominator) 1283296417Sdim cleanupDominator = CGF.Builder.CreateAlignedLoad( 1284296417Sdim CGF.Int8Ty, 1285296417Sdim llvm::Constant::getNullValue(CGF.Int8PtrTy), 1286296417Sdim CharUnits::One()); // placeholder 1287234353Sdim 1288224145Sdim CGF.pushDestroy(EHCleanup, LV.getAddress(), field->getType(), 1289224145Sdim CGF.getDestroyer(dtorKind), false); 1290224145Sdim cleanups.push_back(CGF.EHStack.stable_begin()); 1291224145Sdim pushedCleanup = true; 1292224145Sdim } 1293224145Sdim } 1294218893Sdim 1295218893Sdim // If the GEP didn't get used because of a dead zero init or something 1296218893Sdim // else, clean it up for -O0 builds and general tidiness. 1297224145Sdim if (!pushedCleanup && LV.isSimple()) 1298218893Sdim if (llvm::GetElementPtrInst *GEP = 1299296417Sdim dyn_cast<llvm::GetElementPtrInst>(LV.getPointer())) 1300218893Sdim if (GEP->use_empty()) 1301218893Sdim GEP->eraseFromParent(); 1302193326Sed } 1303224145Sdim 1304224145Sdim // Deactivate all the partial cleanups in reverse order, which 1305224145Sdim // generally means popping them. 1306224145Sdim for (unsigned i = cleanups.size(); i != 0; --i) 1307234353Sdim CGF.DeactivateCleanupBlock(cleanups[i-1], cleanupDominator); 1308234353Sdim 1309234353Sdim // Destroy the placeholder if we made one. 1310234353Sdim if (cleanupDominator) 1311234353Sdim cleanupDominator->eraseFromParent(); 1312193326Sed} 1313193326Sed 1314314564Sdimvoid AggExprEmitter::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E, 1315314564Sdim llvm::Value *outerBegin) { 1316314564Sdim // Emit the common subexpression. 1317314564Sdim CodeGenFunction::OpaqueValueMapping binding(CGF, E->getCommonExpr()); 1318314564Sdim 1319314564Sdim Address destPtr = EnsureSlot(E->getType()).getAddress(); 1320314564Sdim uint64_t numElements = E->getArraySize().getZExtValue(); 1321314564Sdim 1322314564Sdim if (!numElements) 1323314564Sdim return; 1324314564Sdim 1325314564Sdim // destPtr is an array*. Construct an elementType* by drilling down a level. 1326314564Sdim llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0); 1327314564Sdim llvm::Value *indices[] = {zero, zero}; 1328314564Sdim llvm::Value *begin = Builder.CreateInBoundsGEP(destPtr.getPointer(), indices, 1329314564Sdim "arrayinit.begin"); 1330314564Sdim 1331314564Sdim // Prepare to special-case multidimensional array initialization: we avoid 1332314564Sdim // emitting multiple destructor loops in that case. 1333314564Sdim if (!outerBegin) 1334314564Sdim outerBegin = begin; 1335314564Sdim ArrayInitLoopExpr *InnerLoop = dyn_cast<ArrayInitLoopExpr>(E->getSubExpr()); 1336314564Sdim 1337314564Sdim QualType elementType = 1338314564Sdim CGF.getContext().getAsArrayType(E->getType())->getElementType(); 1339314564Sdim CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType); 1340314564Sdim CharUnits elementAlign = 1341314564Sdim destPtr.getAlignment().alignmentOfArrayElement(elementSize); 1342314564Sdim 1343314564Sdim llvm::BasicBlock *entryBB = Builder.GetInsertBlock(); 1344314564Sdim llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body"); 1345314564Sdim 1346314564Sdim // Jump into the body. 1347314564Sdim CGF.EmitBlock(bodyBB); 1348314564Sdim llvm::PHINode *index = 1349314564Sdim Builder.CreatePHI(zero->getType(), 2, "arrayinit.index"); 1350314564Sdim index->addIncoming(zero, entryBB); 1351314564Sdim llvm::Value *element = Builder.CreateInBoundsGEP(begin, index); 1352314564Sdim 1353314564Sdim // Prepare for a cleanup. 1354314564Sdim QualType::DestructionKind dtorKind = elementType.isDestructedType(); 1355314564Sdim EHScopeStack::stable_iterator cleanup; 1356314564Sdim if (CGF.needsEHCleanup(dtorKind) && !InnerLoop) { 1357314564Sdim if (outerBegin->getType() != element->getType()) 1358314564Sdim outerBegin = Builder.CreateBitCast(outerBegin, element->getType()); 1359314564Sdim CGF.pushRegularPartialArrayCleanup(outerBegin, element, elementType, 1360314564Sdim elementAlign, 1361314564Sdim CGF.getDestroyer(dtorKind)); 1362314564Sdim cleanup = CGF.EHStack.stable_begin(); 1363314564Sdim } else { 1364314564Sdim dtorKind = QualType::DK_none; 1365314564Sdim } 1366314564Sdim 1367314564Sdim // Emit the actual filler expression. 1368314564Sdim { 1369314564Sdim // Temporaries created in an array initialization loop are destroyed 1370314564Sdim // at the end of each iteration. 1371314564Sdim CodeGenFunction::RunCleanupsScope CleanupsScope(CGF); 1372314564Sdim CodeGenFunction::ArrayInitLoopExprScope Scope(CGF, index); 1373314564Sdim LValue elementLV = 1374314564Sdim CGF.MakeAddrLValue(Address(element, elementAlign), elementType); 1375314564Sdim 1376314564Sdim if (InnerLoop) { 1377314564Sdim // If the subexpression is an ArrayInitLoopExpr, share its cleanup. 1378314564Sdim auto elementSlot = AggValueSlot::forLValue( 1379314564Sdim elementLV, AggValueSlot::IsDestructed, 1380314564Sdim AggValueSlot::DoesNotNeedGCBarriers, AggValueSlot::IsNotAliased); 1381314564Sdim AggExprEmitter(CGF, elementSlot, false) 1382314564Sdim .VisitArrayInitLoopExpr(InnerLoop, outerBegin); 1383314564Sdim } else 1384314564Sdim EmitInitializationToLValue(E->getSubExpr(), elementLV); 1385314564Sdim } 1386314564Sdim 1387314564Sdim // Move on to the next element. 1388314564Sdim llvm::Value *nextIndex = Builder.CreateNUWAdd( 1389314564Sdim index, llvm::ConstantInt::get(CGF.SizeTy, 1), "arrayinit.next"); 1390314564Sdim index->addIncoming(nextIndex, Builder.GetInsertBlock()); 1391314564Sdim 1392314564Sdim // Leave the loop if we're done. 1393314564Sdim llvm::Value *done = Builder.CreateICmpEQ( 1394314564Sdim nextIndex, llvm::ConstantInt::get(CGF.SizeTy, numElements), 1395314564Sdim "arrayinit.done"); 1396314564Sdim llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end"); 1397314564Sdim Builder.CreateCondBr(done, endBB, bodyBB); 1398314564Sdim 1399314564Sdim CGF.EmitBlock(endBB); 1400314564Sdim 1401314564Sdim // Leave the partial-array cleanup if we entered one. 1402314564Sdim if (dtorKind) 1403314564Sdim CGF.DeactivateCleanupBlock(cleanup, index); 1404314564Sdim} 1405314564Sdim 1406288943Sdimvoid AggExprEmitter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) { 1407288943Sdim AggValueSlot Dest = EnsureSlot(E->getType()); 1408288943Sdim 1409296417Sdim LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType()); 1410288943Sdim EmitInitializationToLValue(E->getBase(), DestLV); 1411288943Sdim VisitInitListExpr(E->getUpdater()); 1412288943Sdim} 1413288943Sdim 1414193326Sed//===----------------------------------------------------------------------===// 1415193326Sed// Entry Points into this File 1416193326Sed//===----------------------------------------------------------------------===// 1417193326Sed 1418218893Sdim/// GetNumNonZeroBytesInInit - Get an approximate count of the number of 1419218893Sdim/// non-zero bytes that will be stored when outputting the initializer for the 1420218893Sdim/// specified initializer expression. 1421221345Sdimstatic CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) { 1422221345Sdim E = E->IgnoreParens(); 1423218893Sdim 1424218893Sdim // 0 and 0.0 won't require any non-zero stores! 1425221345Sdim if (isSimpleZero(E, CGF)) return CharUnits::Zero(); 1426218893Sdim 1427218893Sdim // If this is an initlist expr, sum up the size of sizes of the (present) 1428218893Sdim // elements. If this is something weird, assume the whole thing is non-zero. 1429218893Sdim const InitListExpr *ILE = dyn_cast<InitListExpr>(E); 1430276479Sdim if (!ILE || !CGF.getTypes().isZeroInitializable(ILE->getType())) 1431221345Sdim return CGF.getContext().getTypeSizeInChars(E->getType()); 1432218893Sdim 1433218893Sdim // InitListExprs for structs have to be handled carefully. If there are 1434218893Sdim // reference members, we need to consider the size of the reference, not the 1435218893Sdim // referencee. InitListExprs for unions and arrays can't have references. 1436218893Sdim if (const RecordType *RT = E->getType()->getAs<RecordType>()) { 1437218893Sdim if (!RT->isUnionType()) { 1438218893Sdim RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl(); 1439221345Sdim CharUnits NumNonZeroBytes = CharUnits::Zero(); 1440218893Sdim 1441218893Sdim unsigned ILEElement = 0; 1442309124Sdim if (auto *CXXRD = dyn_cast<CXXRecordDecl>(SD)) 1443309124Sdim while (ILEElement != CXXRD->getNumBases()) 1444309124Sdim NumNonZeroBytes += 1445309124Sdim GetNumNonZeroBytesInInit(ILE->getInit(ILEElement++), CGF); 1446276479Sdim for (const auto *Field : SD->fields()) { 1447218893Sdim // We're done once we hit the flexible array member or run out of 1448218893Sdim // InitListExpr elements. 1449218893Sdim if (Field->getType()->isIncompleteArrayType() || 1450218893Sdim ILEElement == ILE->getNumInits()) 1451218893Sdim break; 1452218893Sdim if (Field->isUnnamedBitfield()) 1453218893Sdim continue; 1454218893Sdim 1455218893Sdim const Expr *E = ILE->getInit(ILEElement++); 1456218893Sdim 1457218893Sdim // Reference values are always non-null and have the width of a pointer. 1458218893Sdim if (Field->getType()->isReferenceType()) 1459221345Sdim NumNonZeroBytes += CGF.getContext().toCharUnitsFromBits( 1460251662Sdim CGF.getTarget().getPointerWidth(0)); 1461218893Sdim else 1462218893Sdim NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF); 1463218893Sdim } 1464218893Sdim 1465218893Sdim return NumNonZeroBytes; 1466218893Sdim } 1467218893Sdim } 1468218893Sdim 1469218893Sdim 1470221345Sdim CharUnits NumNonZeroBytes = CharUnits::Zero(); 1471218893Sdim for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i) 1472218893Sdim NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF); 1473218893Sdim return NumNonZeroBytes; 1474218893Sdim} 1475218893Sdim 1476218893Sdim/// CheckAggExprForMemSetUse - If the initializer is large and has a lot of 1477218893Sdim/// zeros in it, emit a memset and avoid storing the individual zeros. 1478218893Sdim/// 1479218893Sdimstatic void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E, 1480218893Sdim CodeGenFunction &CGF) { 1481218893Sdim // If the slot is already known to be zeroed, nothing to do. Don't mess with 1482218893Sdim // volatile stores. 1483296417Sdim if (Slot.isZeroed() || Slot.isVolatile() || !Slot.getAddress().isValid()) 1484276479Sdim return; 1485221345Sdim 1486221345Sdim // C++ objects with a user-declared constructor don't need zero'ing. 1487243830Sdim if (CGF.getLangOpts().CPlusPlus) 1488221345Sdim if (const RecordType *RT = CGF.getContext() 1489221345Sdim .getBaseElementType(E->getType())->getAs<RecordType>()) { 1490221345Sdim const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1491221345Sdim if (RD->hasUserDeclaredConstructor()) 1492221345Sdim return; 1493221345Sdim } 1494221345Sdim 1495218893Sdim // If the type is 16-bytes or smaller, prefer individual stores over memset. 1496296417Sdim CharUnits Size = CGF.getContext().getTypeSizeInChars(E->getType()); 1497296417Sdim if (Size <= CharUnits::fromQuantity(16)) 1498218893Sdim return; 1499218893Sdim 1500218893Sdim // Check to see if over 3/4 of the initializer are known to be zero. If so, 1501218893Sdim // we prefer to emit memset + individual stores for the rest. 1502221345Sdim CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF); 1503296417Sdim if (NumNonZeroBytes*4 > Size) 1504218893Sdim return; 1505218893Sdim 1506218893Sdim // Okay, it seems like a good idea to use an initial memset, emit the call. 1507296417Sdim llvm::Constant *SizeVal = CGF.Builder.getInt64(Size.getQuantity()); 1508218893Sdim 1509296417Sdim Address Loc = Slot.getAddress(); 1510296417Sdim Loc = CGF.Builder.CreateElementBitCast(Loc, CGF.Int8Ty); 1511296417Sdim CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, false); 1512218893Sdim 1513218893Sdim // Tell the AggExprEmitter that the slot is known zero. 1514218893Sdim Slot.setZeroed(); 1515218893Sdim} 1516218893Sdim 1517218893Sdim 1518218893Sdim 1519218893Sdim 1520193326Sed/// EmitAggExpr - Emit the computation of the specified expression of aggregate 1521193326Sed/// type. The result is computed into DestPtr. Note that if DestPtr is null, 1522193326Sed/// the value of the aggregate expression is not needed. If VolatileDest is 1523193326Sed/// true, DestPtr cannot be 0. 1524239462Sdimvoid CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot) { 1525249423Sdim assert(E && hasAggregateEvaluationKind(E->getType()) && 1526193326Sed "Invalid aggregate expression to emit"); 1527296417Sdim assert((Slot.getAddress().isValid() || Slot.isIgnored()) && 1528218893Sdim "slot has bits but no address"); 1529198092Srdivacky 1530218893Sdim // Optimize the slot if possible. 1531218893Sdim CheckAggExprForMemSetUse(Slot, E, *this); 1532218893Sdim 1533288943Sdim AggExprEmitter(*this, Slot, Slot.isIgnored()).Visit(const_cast<Expr*>(E)); 1534193326Sed} 1535193326Sed 1536203955SrdivackyLValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) { 1537249423Sdim assert(hasAggregateEvaluationKind(E->getType()) && "Invalid argument!"); 1538296417Sdim Address Temp = CreateMemTemp(E->getType()); 1539212904Sdim LValue LV = MakeAddrLValue(Temp, E->getType()); 1540226633Sdim EmitAggExpr(E, AggValueSlot::forLValue(LV, AggValueSlot::IsNotDestructed, 1541226633Sdim AggValueSlot::DoesNotNeedGCBarriers, 1542226633Sdim AggValueSlot::IsNotAliased)); 1543212904Sdim return LV; 1544203955Srdivacky} 1545203955Srdivacky 1546296417Sdimvoid CodeGenFunction::EmitAggregateCopy(Address DestPtr, 1547296417Sdim Address SrcPtr, QualType Ty, 1548239462Sdim bool isVolatile, 1549243830Sdim bool isAssignment) { 1550193326Sed assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex"); 1551198092Srdivacky 1552243830Sdim if (getLangOpts().CPlusPlus) { 1553207619Srdivacky if (const RecordType *RT = Ty->getAs<RecordType>()) { 1554208600Srdivacky CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl()); 1555208600Srdivacky assert((Record->hasTrivialCopyConstructor() || 1556226633Sdim Record->hasTrivialCopyAssignment() || 1557226633Sdim Record->hasTrivialMoveConstructor() || 1558288943Sdim Record->hasTrivialMoveAssignment() || 1559288943Sdim Record->isUnion()) && 1560249423Sdim "Trying to aggregate-copy a type without a trivial copy/move " 1561208600Srdivacky "constructor or assignment operator"); 1562208600Srdivacky // Ignore empty classes in C++. 1563208600Srdivacky if (Record->isEmpty()) 1564207619Srdivacky return; 1565207619Srdivacky } 1566207619Srdivacky } 1567207619Srdivacky 1568193326Sed // Aggregate assignment turns into llvm.memcpy. This is almost valid per 1569193326Sed // C99 6.5.16.1p3, which states "If the value being stored in an object is 1570193326Sed // read from another object that overlaps in anyway the storage of the first 1571193326Sed // object, then the overlap shall be exact and the two objects shall have 1572193326Sed // qualified or unqualified versions of a compatible type." 1573193326Sed // 1574193326Sed // memcpy is not defined if the source and destination pointers are exactly 1575193326Sed // equal, but other compilers do this optimization, and almost every memcpy 1576193326Sed // implementation handles this case safely. If there is a libc that does not 1577193326Sed // safely handle this, we can add a target hook. 1578198092Srdivacky 1579296417Sdim // Get data size info for this aggregate. If this is an assignment, 1580296417Sdim // don't copy the tail padding, because we might be assigning into a 1581296417Sdim // base subobject where the tail padding is claimed. Otherwise, 1582296417Sdim // copying it is fine. 1583243830Sdim std::pair<CharUnits, CharUnits> TypeInfo; 1584243830Sdim if (isAssignment) 1585243830Sdim TypeInfo = getContext().getTypeInfoDataSizeInChars(Ty); 1586243830Sdim else 1587243830Sdim TypeInfo = getContext().getTypeInfoInChars(Ty); 1588198092Srdivacky 1589288943Sdim llvm::Value *SizeVal = nullptr; 1590288943Sdim if (TypeInfo.first.isZero()) { 1591288943Sdim // But note that getTypeInfo returns 0 for a VLA. 1592288943Sdim if (auto *VAT = dyn_cast_or_null<VariableArrayType>( 1593288943Sdim getContext().getAsArrayType(Ty))) { 1594288943Sdim QualType BaseEltTy; 1595288943Sdim SizeVal = emitArrayLength(VAT, BaseEltTy, DestPtr); 1596288943Sdim TypeInfo = getContext().getTypeInfoDataSizeInChars(BaseEltTy); 1597288943Sdim std::pair<CharUnits, CharUnits> LastElementTypeInfo; 1598288943Sdim if (!isAssignment) 1599288943Sdim LastElementTypeInfo = getContext().getTypeInfoInChars(BaseEltTy); 1600288943Sdim assert(!TypeInfo.first.isZero()); 1601288943Sdim SizeVal = Builder.CreateNUWMul( 1602288943Sdim SizeVal, 1603288943Sdim llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity())); 1604288943Sdim if (!isAssignment) { 1605288943Sdim SizeVal = Builder.CreateNUWSub( 1606288943Sdim SizeVal, 1607288943Sdim llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity())); 1608288943Sdim SizeVal = Builder.CreateNUWAdd( 1609288943Sdim SizeVal, llvm::ConstantInt::get( 1610288943Sdim SizeTy, LastElementTypeInfo.first.getQuantity())); 1611288943Sdim } 1612288943Sdim } 1613288943Sdim } 1614288943Sdim if (!SizeVal) { 1615288943Sdim SizeVal = llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity()); 1616288943Sdim } 1617198092Srdivacky 1618193326Sed // FIXME: If we have a volatile struct, the optimizer can remove what might 1619193326Sed // appear to be `extra' memory ops: 1620193326Sed // 1621193326Sed // volatile struct { int i; } a, b; 1622193326Sed // 1623193326Sed // int main() { 1624193326Sed // a = b; 1625193326Sed // a = b; 1626193326Sed // } 1627193326Sed // 1628206275Srdivacky // we need to use a different call here. We use isVolatile to indicate when 1629193326Sed // either the source or the destination is volatile. 1630206275Srdivacky 1631296417Sdim DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty); 1632296417Sdim SrcPtr = Builder.CreateElementBitCast(SrcPtr, Int8Ty); 1633206275Srdivacky 1634224145Sdim // Don't do any of the memmove_collectable tests if GC isn't set. 1635234353Sdim if (CGM.getLangOpts().getGC() == LangOptions::NonGC) { 1636224145Sdim // fall through 1637224145Sdim } else if (const RecordType *RecordTy = Ty->getAs<RecordType>()) { 1638210299Sed RecordDecl *Record = RecordTy->getDecl(); 1639210299Sed if (Record->hasObjectMember()) { 1640210299Sed CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr, 1641210299Sed SizeVal); 1642210299Sed return; 1643210299Sed } 1644224145Sdim } else if (Ty->isArrayType()) { 1645210299Sed QualType BaseType = getContext().getBaseElementType(Ty); 1646210299Sed if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) { 1647210299Sed if (RecordTy->getDecl()->hasObjectMember()) { 1648210299Sed CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr, 1649210299Sed SizeVal); 1650210299Sed return; 1651210299Sed } 1652210299Sed } 1653210299Sed } 1654243830Sdim 1655296417Sdim auto Inst = Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, isVolatile); 1656296417Sdim 1657243830Sdim // Determine the metadata to describe the position of any padding in this 1658243830Sdim // memcpy, as well as the TBAA tags for the members of the struct, in case 1659243830Sdim // the optimizer wishes to expand it in to scalar memory operations. 1660296417Sdim if (llvm::MDNode *TBAAStructTag = CGM.getTBAAStructInfo(Ty)) 1661296417Sdim Inst->setMetadata(llvm::LLVMContext::MD_tbaa_struct, TBAAStructTag); 1662193326Sed} 1663