CGExprAgg.cpp revision 243830
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" 15193326Sed#include "CodeGenModule.h" 16198092Srdivacky#include "CGObjCRuntime.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" 21193326Sed#include "llvm/Constants.h" 22193326Sed#include "llvm/Function.h" 23193326Sed#include "llvm/GlobalVariable.h" 24193326Sed#include "llvm/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; 37208600Srdivacky 38226633Sdim /// We want to use 'dest' as the return slot except under two 39226633Sdim /// conditions: 40226633Sdim /// - The destination slot requires garbage collection, so we 41226633Sdim /// need to use the GC API. 42226633Sdim /// - The destination slot is potentially aliased. 43226633Sdim bool shouldUseDestForReturnSlot() const { 44226633Sdim return !(Dest.requiresGCollection() || Dest.isPotentiallyAliased()); 45226633Sdim } 46226633Sdim 47208600Srdivacky ReturnValueSlot getReturnValueSlot() const { 48226633Sdim if (!shouldUseDestForReturnSlot()) 49226633Sdim return ReturnValueSlot(); 50208600Srdivacky 51218893Sdim return ReturnValueSlot(Dest.getAddr(), Dest.isVolatile()); 52208600Srdivacky } 53208600Srdivacky 54218893Sdim AggValueSlot EnsureSlot(QualType T) { 55218893Sdim if (!Dest.isIgnored()) return Dest; 56218893Sdim return CGF.CreateAggTemp(T, "agg.tmp.ensured"); 57218893Sdim } 58239462Sdim void EnsureDest(QualType T) { 59239462Sdim if (!Dest.isIgnored()) return; 60239462Sdim Dest = CGF.CreateAggTemp(T, "agg.tmp.ensured"); 61239462Sdim } 62218893Sdim 63193326Sedpublic: 64239462Sdim AggExprEmitter(CodeGenFunction &cgf, AggValueSlot Dest) 65239462Sdim : CGF(cgf), Builder(CGF.Builder), Dest(Dest) { 66193326Sed } 67193326Sed 68193326Sed //===--------------------------------------------------------------------===// 69193326Sed // Utilities 70193326Sed //===--------------------------------------------------------------------===// 71193326Sed 72193326Sed /// EmitAggLoadOfLValue - Given an expression with aggregate type that 73193326Sed /// represents a value lvalue, this method emits the address of the lvalue, 74193326Sed /// then loads the result into DestPtr. 75193326Sed void EmitAggLoadOfLValue(const Expr *E); 76193326Sed 77193326Sed /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired. 78239462Sdim void EmitFinalDestCopy(QualType type, const LValue &src); 79239462Sdim void EmitFinalDestCopy(QualType type, RValue src, 80239462Sdim CharUnits srcAlignment = CharUnits::Zero()); 81239462Sdim void EmitCopy(QualType type, const AggValueSlot &dest, 82239462Sdim const AggValueSlot &src); 83193326Sed 84226633Sdim void EmitMoveFromReturnSlot(const Expr *E, RValue Src); 85208600Srdivacky 86234353Sdim void EmitStdInitializerList(llvm::Value *DestPtr, InitListExpr *InitList); 87234353Sdim void EmitArrayInit(llvm::Value *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 102193326Sed void VisitStmt(Stmt *S) { 103193326Sed CGF.ErrorUnsupported(S, "aggregate expression"); 104193326Sed } 105193326Sed void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); } 106221345Sdim void VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 107221345Sdim Visit(GE->getResultExpr()); 108221345Sdim } 109193326Sed void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); } 110224145Sdim void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) { 111224145Sdim return Visit(E->getReplacement()); 112224145Sdim } 113193326Sed 114193326Sed // l-values. 115234353Sdim void VisitDeclRefExpr(DeclRefExpr *E) { 116234353Sdim // For aggregates, we should always be able to emit the variable 117234353Sdim // as an l-value unless it's a reference. This is due to the fact 118234353Sdim // that we can't actually ever see a normal l2r conversion on an 119234353Sdim // aggregate in C++, and in C there's no language standard 120234353Sdim // actively preventing us from listing variables in the captures 121234353Sdim // list of a block. 122234353Sdim if (E->getDecl()->getType()->isReferenceType()) { 123234353Sdim if (CodeGenFunction::ConstantEmission result 124234353Sdim = CGF.tryEmitAsConstant(E)) { 125239462Sdim EmitFinalDestCopy(E->getType(), result.getReferenceLValue(CGF, E)); 126234353Sdim return; 127234353Sdim } 128234353Sdim } 129234353Sdim 130234353Sdim EmitAggLoadOfLValue(E); 131234353Sdim } 132234353Sdim 133193326Sed void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); } 134193326Sed void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); } 135193326Sed void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); } 136224145Sdim void VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 137193326Sed void VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 138193326Sed EmitAggLoadOfLValue(E); 139193326Sed } 140193326Sed void VisitPredefinedExpr(const PredefinedExpr *E) { 141198092Srdivacky EmitAggLoadOfLValue(E); 142193326Sed } 143198092Srdivacky 144193326Sed // Operators. 145198092Srdivacky void VisitCastExpr(CastExpr *E); 146193326Sed void VisitCallExpr(const CallExpr *E); 147193326Sed void VisitStmtExpr(const StmtExpr *E); 148193326Sed void VisitBinaryOperator(const BinaryOperator *BO); 149198398Srdivacky void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO); 150193326Sed void VisitBinAssign(const BinaryOperator *E); 151193326Sed void VisitBinComma(const BinaryOperator *E); 152193326Sed 153193326Sed void VisitObjCMessageExpr(ObjCMessageExpr *E); 154193326Sed void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 155193326Sed EmitAggLoadOfLValue(E); 156193326Sed } 157198092Srdivacky 158218893Sdim void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO); 159198092Srdivacky void VisitChooseExpr(const ChooseExpr *CE); 160193326Sed void VisitInitListExpr(InitListExpr *E); 161201361Srdivacky void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E); 162193326Sed void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 163193326Sed Visit(DAE->getExpr()); 164193326Sed } 165193326Sed void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E); 166193326Sed void VisitCXXConstructExpr(const CXXConstructExpr *E); 167234353Sdim void VisitLambdaExpr(LambdaExpr *E); 168218893Sdim void VisitExprWithCleanups(ExprWithCleanups *E); 169210299Sed void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 170199482Srdivacky void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); } 171224145Sdim void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E); 172218893Sdim void VisitOpaqueValueExpr(OpaqueValueExpr *E); 173218893Sdim 174234353Sdim void VisitPseudoObjectExpr(PseudoObjectExpr *E) { 175234353Sdim if (E->isGLValue()) { 176234353Sdim LValue LV = CGF.EmitPseudoObjectLValue(E); 177239462Sdim return EmitFinalDestCopy(E->getType(), LV); 178234353Sdim } 179234353Sdim 180234353Sdim CGF.EmitPseudoObjectRValue(E, EnsureSlot(E->getType())); 181234353Sdim } 182234353Sdim 183193326Sed void VisitVAArgExpr(VAArgExpr *E); 184193326Sed 185224145Sdim void EmitInitializationToLValue(Expr *E, LValue Address); 186224145Sdim void EmitNullInitializationToLValue(LValue Address); 187193326Sed // case Expr::ChooseExprClass: 188200583Srdivacky void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); } 189226633Sdim void VisitAtomicExpr(AtomicExpr *E) { 190226633Sdim CGF.EmitAtomicExpr(E, EnsureSlot(E->getType()).getAddr()); 191226633Sdim } 192193326Sed}; 193193326Sed} // end anonymous namespace. 194193326Sed 195193326Sed//===----------------------------------------------------------------------===// 196193326Sed// Utilities 197193326Sed//===----------------------------------------------------------------------===// 198193326Sed 199193326Sed/// EmitAggLoadOfLValue - Given an expression with aggregate type that 200193326Sed/// represents a value lvalue, this method emits the address of the lvalue, 201193326Sed/// then loads the result into DestPtr. 202193326Sedvoid AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) { 203193326Sed LValue LV = CGF.EmitLValue(E); 204239462Sdim EmitFinalDestCopy(E->getType(), LV); 205193326Sed} 206193326Sed 207208600Srdivacky/// \brief True if the given aggregate type requires special GC API calls. 208208600Srdivackybool AggExprEmitter::TypeRequiresGCollection(QualType T) { 209208600Srdivacky // Only record types have members that might require garbage collection. 210208600Srdivacky const RecordType *RecordTy = T->getAs<RecordType>(); 211208600Srdivacky if (!RecordTy) return false; 212208600Srdivacky 213208600Srdivacky // Don't mess with non-trivial C++ types. 214208600Srdivacky RecordDecl *Record = RecordTy->getDecl(); 215208600Srdivacky if (isa<CXXRecordDecl>(Record) && 216208600Srdivacky (!cast<CXXRecordDecl>(Record)->hasTrivialCopyConstructor() || 217208600Srdivacky !cast<CXXRecordDecl>(Record)->hasTrivialDestructor())) 218208600Srdivacky return false; 219208600Srdivacky 220208600Srdivacky // Check whether the type has an object member. 221208600Srdivacky return Record->hasObjectMember(); 222208600Srdivacky} 223208600Srdivacky 224226633Sdim/// \brief Perform the final move to DestPtr if for some reason 225226633Sdim/// getReturnValueSlot() didn't use it directly. 226208600Srdivacky/// 227208600Srdivacky/// The idea is that you do something like this: 228208600Srdivacky/// RValue Result = EmitSomething(..., getReturnValueSlot()); 229226633Sdim/// EmitMoveFromReturnSlot(E, Result); 230226633Sdim/// 231226633Sdim/// If nothing interferes, this will cause the result to be emitted 232226633Sdim/// directly into the return value slot. Otherwise, a final move 233226633Sdim/// will be performed. 234239462Sdimvoid AggExprEmitter::EmitMoveFromReturnSlot(const Expr *E, RValue src) { 235226633Sdim if (shouldUseDestForReturnSlot()) { 236226633Sdim // Logically, Dest.getAddr() should equal Src.getAggregateAddr(). 237226633Sdim // The possibility of undef rvalues complicates that a lot, 238226633Sdim // though, so we can't really assert. 239226633Sdim return; 240210299Sed } 241226633Sdim 242239462Sdim // Otherwise, copy from there to the destination. 243239462Sdim assert(Dest.getAddr() != src.getAggregateAddr()); 244239462Sdim std::pair<CharUnits, CharUnits> typeInfo = 245234982Sdim CGF.getContext().getTypeInfoInChars(E->getType()); 246239462Sdim EmitFinalDestCopy(E->getType(), src, typeInfo.second); 247208600Srdivacky} 248208600Srdivacky 249193326Sed/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired. 250239462Sdimvoid AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src, 251239462Sdim CharUnits srcAlign) { 252239462Sdim assert(src.isAggregate() && "value must be aggregate value!"); 253239462Sdim LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddr(), type, srcAlign); 254239462Sdim EmitFinalDestCopy(type, srcLV); 255239462Sdim} 256193326Sed 257239462Sdim/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired. 258239462Sdimvoid AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src) { 259218893Sdim // If Dest is ignored, then we're evaluating an aggregate expression 260239462Sdim // in a context that doesn't care about the result. Note that loads 261239462Sdim // from volatile l-values force the existence of a non-ignored 262239462Sdim // destination. 263239462Sdim if (Dest.isIgnored()) 264239462Sdim return; 265212904Sdim 266239462Sdim AggValueSlot srcAgg = 267239462Sdim AggValueSlot::forLValue(src, AggValueSlot::IsDestructed, 268239462Sdim needsGC(type), AggValueSlot::IsAliased); 269239462Sdim EmitCopy(type, Dest, srcAgg); 270239462Sdim} 271193326Sed 272239462Sdim/// Perform a copy from the source into the destination. 273239462Sdim/// 274239462Sdim/// \param type - the type of the aggregate being copied; qualifiers are 275239462Sdim/// ignored 276239462Sdimvoid AggExprEmitter::EmitCopy(QualType type, const AggValueSlot &dest, 277239462Sdim const AggValueSlot &src) { 278239462Sdim if (dest.requiresGCollection()) { 279239462Sdim CharUnits sz = CGF.getContext().getTypeSizeInChars(type); 280239462Sdim llvm::Value *size = llvm::ConstantInt::get(CGF.SizeTy, sz.getQuantity()); 281198092Srdivacky CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF, 282239462Sdim dest.getAddr(), 283239462Sdim src.getAddr(), 284239462Sdim size); 285198092Srdivacky return; 286198092Srdivacky } 287239462Sdim 288193326Sed // If the result of the assignment is used, copy the LHS there also. 289239462Sdim // It's volatile if either side is. Use the minimum alignment of 290239462Sdim // the two sides. 291239462Sdim CGF.EmitAggregateCopy(dest.getAddr(), src.getAddr(), type, 292239462Sdim dest.isVolatile() || src.isVolatile(), 293239462Sdim std::min(dest.getAlignment(), src.getAlignment())); 294193326Sed} 295193326Sed 296234353Sdimstatic QualType GetStdInitializerListElementType(QualType T) { 297234353Sdim // Just assume that this is really std::initializer_list. 298234353Sdim ClassTemplateSpecializationDecl *specialization = 299234353Sdim cast<ClassTemplateSpecializationDecl>(T->castAs<RecordType>()->getDecl()); 300234353Sdim return specialization->getTemplateArgs()[0].getAsType(); 301234353Sdim} 302234353Sdim 303234353Sdim/// \brief Prepare cleanup for the temporary array. 304234353Sdimstatic void EmitStdInitializerListCleanup(CodeGenFunction &CGF, 305234353Sdim QualType arrayType, 306234353Sdim llvm::Value *addr, 307234353Sdim const InitListExpr *initList) { 308234353Sdim QualType::DestructionKind dtorKind = arrayType.isDestructedType(); 309234353Sdim if (!dtorKind) 310234353Sdim return; // Type doesn't need destroying. 311234353Sdim if (dtorKind != QualType::DK_cxx_destructor) { 312234353Sdim CGF.ErrorUnsupported(initList, "ObjC ARC type in initializer_list"); 313234353Sdim return; 314234353Sdim } 315234353Sdim 316234353Sdim CodeGenFunction::Destroyer *destroyer = CGF.getDestroyer(dtorKind); 317234353Sdim CGF.pushDestroy(NormalAndEHCleanup, addr, arrayType, destroyer, 318234353Sdim /*EHCleanup=*/true); 319234353Sdim} 320234353Sdim 321234353Sdim/// \brief Emit the initializer for a std::initializer_list initialized with a 322234353Sdim/// real initializer list. 323234353Sdimvoid AggExprEmitter::EmitStdInitializerList(llvm::Value *destPtr, 324234353Sdim InitListExpr *initList) { 325234353Sdim // We emit an array containing the elements, then have the init list point 326234353Sdim // at the array. 327234353Sdim ASTContext &ctx = CGF.getContext(); 328234353Sdim unsigned numInits = initList->getNumInits(); 329234353Sdim QualType element = GetStdInitializerListElementType(initList->getType()); 330234353Sdim llvm::APInt size(ctx.getTypeSize(ctx.getSizeType()), numInits); 331234353Sdim QualType array = ctx.getConstantArrayType(element, size, ArrayType::Normal,0); 332234353Sdim llvm::Type *LTy = CGF.ConvertTypeForMem(array); 333234353Sdim llvm::AllocaInst *alloc = CGF.CreateTempAlloca(LTy); 334234353Sdim alloc->setAlignment(ctx.getTypeAlignInChars(array).getQuantity()); 335234353Sdim alloc->setName(".initlist."); 336234353Sdim 337234353Sdim EmitArrayInit(alloc, cast<llvm::ArrayType>(LTy), element, initList); 338234353Sdim 339234353Sdim // FIXME: The diagnostics are somewhat out of place here. 340234353Sdim RecordDecl *record = initList->getType()->castAs<RecordType>()->getDecl(); 341234353Sdim RecordDecl::field_iterator field = record->field_begin(); 342234353Sdim if (field == record->field_end()) { 343234353Sdim CGF.ErrorUnsupported(initList, "weird std::initializer_list"); 344234353Sdim return; 345234353Sdim } 346234353Sdim 347234353Sdim QualType elementPtr = ctx.getPointerType(element.withConst()); 348234353Sdim 349234353Sdim // Start pointer. 350234353Sdim if (!ctx.hasSameType(field->getType(), elementPtr)) { 351234353Sdim CGF.ErrorUnsupported(initList, "weird std::initializer_list"); 352234353Sdim return; 353234353Sdim } 354234982Sdim LValue DestLV = CGF.MakeNaturalAlignAddrLValue(destPtr, initList->getType()); 355234982Sdim LValue start = CGF.EmitLValueForFieldInitialization(DestLV, *field); 356234353Sdim llvm::Value *arrayStart = Builder.CreateStructGEP(alloc, 0, "arraystart"); 357234353Sdim CGF.EmitStoreThroughLValue(RValue::get(arrayStart), start); 358234353Sdim ++field; 359234353Sdim 360234353Sdim if (field == record->field_end()) { 361234353Sdim CGF.ErrorUnsupported(initList, "weird std::initializer_list"); 362234353Sdim return; 363234353Sdim } 364234982Sdim LValue endOrLength = CGF.EmitLValueForFieldInitialization(DestLV, *field); 365234353Sdim if (ctx.hasSameType(field->getType(), elementPtr)) { 366234353Sdim // End pointer. 367234353Sdim llvm::Value *arrayEnd = Builder.CreateStructGEP(alloc,numInits, "arrayend"); 368234353Sdim CGF.EmitStoreThroughLValue(RValue::get(arrayEnd), endOrLength); 369234353Sdim } else if(ctx.hasSameType(field->getType(), ctx.getSizeType())) { 370234353Sdim // Length. 371234353Sdim CGF.EmitStoreThroughLValue(RValue::get(Builder.getInt(size)), endOrLength); 372234353Sdim } else { 373234353Sdim CGF.ErrorUnsupported(initList, "weird std::initializer_list"); 374234353Sdim return; 375234353Sdim } 376234353Sdim 377234353Sdim if (!Dest.isExternallyDestructed()) 378234353Sdim EmitStdInitializerListCleanup(CGF, array, alloc, initList); 379234353Sdim} 380234353Sdim 381234353Sdim/// \brief Emit initialization of an array from an initializer list. 382234353Sdimvoid AggExprEmitter::EmitArrayInit(llvm::Value *DestPtr, llvm::ArrayType *AType, 383234353Sdim QualType elementType, InitListExpr *E) { 384234353Sdim uint64_t NumInitElements = E->getNumInits(); 385234353Sdim 386234353Sdim uint64_t NumArrayElements = AType->getNumElements(); 387234353Sdim assert(NumInitElements <= NumArrayElements); 388234353Sdim 389234353Sdim // DestPtr is an array*. Construct an elementType* by drilling 390234353Sdim // down a level. 391234353Sdim llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0); 392234353Sdim llvm::Value *indices[] = { zero, zero }; 393234353Sdim llvm::Value *begin = 394234353Sdim Builder.CreateInBoundsGEP(DestPtr, indices, "arrayinit.begin"); 395234353Sdim 396234353Sdim // Exception safety requires us to destroy all the 397234353Sdim // already-constructed members if an initializer throws. 398234353Sdim // For that, we'll need an EH cleanup. 399234353Sdim QualType::DestructionKind dtorKind = elementType.isDestructedType(); 400234353Sdim llvm::AllocaInst *endOfInit = 0; 401234353Sdim EHScopeStack::stable_iterator cleanup; 402234353Sdim llvm::Instruction *cleanupDominator = 0; 403234353Sdim if (CGF.needsEHCleanup(dtorKind)) { 404234353Sdim // In principle we could tell the cleanup where we are more 405234353Sdim // directly, but the control flow can get so varied here that it 406234353Sdim // would actually be quite complex. Therefore we go through an 407234353Sdim // alloca. 408234353Sdim endOfInit = CGF.CreateTempAlloca(begin->getType(), 409234353Sdim "arrayinit.endOfInit"); 410234353Sdim cleanupDominator = Builder.CreateStore(begin, endOfInit); 411234353Sdim CGF.pushIrregularPartialArrayCleanup(begin, endOfInit, elementType, 412234353Sdim CGF.getDestroyer(dtorKind)); 413234353Sdim cleanup = CGF.EHStack.stable_begin(); 414234353Sdim 415234353Sdim // Otherwise, remember that we didn't need a cleanup. 416234353Sdim } else { 417234353Sdim dtorKind = QualType::DK_none; 418234353Sdim } 419234353Sdim 420234353Sdim llvm::Value *one = llvm::ConstantInt::get(CGF.SizeTy, 1); 421234353Sdim 422234353Sdim // The 'current element to initialize'. The invariants on this 423234353Sdim // variable are complicated. Essentially, after each iteration of 424234353Sdim // the loop, it points to the last initialized element, except 425234353Sdim // that it points to the beginning of the array before any 426234353Sdim // elements have been initialized. 427234353Sdim llvm::Value *element = begin; 428234353Sdim 429234353Sdim // Emit the explicit initializers. 430234353Sdim for (uint64_t i = 0; i != NumInitElements; ++i) { 431234353Sdim // Advance to the next element. 432234353Sdim if (i > 0) { 433234353Sdim element = Builder.CreateInBoundsGEP(element, one, "arrayinit.element"); 434234353Sdim 435234353Sdim // Tell the cleanup that it needs to destroy up to this 436234353Sdim // element. TODO: some of these stores can be trivially 437234353Sdim // observed to be unnecessary. 438234353Sdim if (endOfInit) Builder.CreateStore(element, endOfInit); 439234353Sdim } 440234353Sdim 441234353Sdim // If these are nested std::initializer_list inits, do them directly, 442234353Sdim // because they are conceptually the same "location". 443234353Sdim InitListExpr *initList = dyn_cast<InitListExpr>(E->getInit(i)); 444234353Sdim if (initList && initList->initializesStdInitializerList()) { 445234353Sdim EmitStdInitializerList(element, initList); 446234353Sdim } else { 447234353Sdim LValue elementLV = CGF.MakeAddrLValue(element, elementType); 448234353Sdim EmitInitializationToLValue(E->getInit(i), elementLV); 449234353Sdim } 450234353Sdim } 451234353Sdim 452234353Sdim // Check whether there's a non-trivial array-fill expression. 453234353Sdim // Note that this will be a CXXConstructExpr even if the element 454234353Sdim // type is an array (or array of array, etc.) of class type. 455234353Sdim Expr *filler = E->getArrayFiller(); 456234353Sdim bool hasTrivialFiller = true; 457234353Sdim if (CXXConstructExpr *cons = dyn_cast_or_null<CXXConstructExpr>(filler)) { 458234353Sdim assert(cons->getConstructor()->isDefaultConstructor()); 459234353Sdim hasTrivialFiller = cons->getConstructor()->isTrivial(); 460234353Sdim } 461234353Sdim 462234353Sdim // Any remaining elements need to be zero-initialized, possibly 463234353Sdim // using the filler expression. We can skip this if the we're 464234353Sdim // emitting to zeroed memory. 465234353Sdim if (NumInitElements != NumArrayElements && 466234353Sdim !(Dest.isZeroed() && hasTrivialFiller && 467234353Sdim CGF.getTypes().isZeroInitializable(elementType))) { 468234353Sdim 469234353Sdim // Use an actual loop. This is basically 470234353Sdim // do { *array++ = filler; } while (array != end); 471234353Sdim 472234353Sdim // Advance to the start of the rest of the array. 473234353Sdim if (NumInitElements) { 474234353Sdim element = Builder.CreateInBoundsGEP(element, one, "arrayinit.start"); 475234353Sdim if (endOfInit) Builder.CreateStore(element, endOfInit); 476234353Sdim } 477234353Sdim 478234353Sdim // Compute the end of the array. 479234353Sdim llvm::Value *end = Builder.CreateInBoundsGEP(begin, 480234353Sdim llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements), 481234353Sdim "arrayinit.end"); 482234353Sdim 483234353Sdim llvm::BasicBlock *entryBB = Builder.GetInsertBlock(); 484234353Sdim llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body"); 485234353Sdim 486234353Sdim // Jump into the body. 487234353Sdim CGF.EmitBlock(bodyBB); 488234353Sdim llvm::PHINode *currentElement = 489234353Sdim Builder.CreatePHI(element->getType(), 2, "arrayinit.cur"); 490234353Sdim currentElement->addIncoming(element, entryBB); 491234353Sdim 492234353Sdim // Emit the actual filler expression. 493234353Sdim LValue elementLV = CGF.MakeAddrLValue(currentElement, elementType); 494234353Sdim if (filler) 495234353Sdim EmitInitializationToLValue(filler, elementLV); 496234353Sdim else 497234353Sdim EmitNullInitializationToLValue(elementLV); 498234353Sdim 499234353Sdim // Move on to the next element. 500234353Sdim llvm::Value *nextElement = 501234353Sdim Builder.CreateInBoundsGEP(currentElement, one, "arrayinit.next"); 502234353Sdim 503234353Sdim // Tell the EH cleanup that we finished with the last element. 504234353Sdim if (endOfInit) Builder.CreateStore(nextElement, endOfInit); 505234353Sdim 506234353Sdim // Leave the loop if we're done. 507234353Sdim llvm::Value *done = Builder.CreateICmpEQ(nextElement, end, 508234353Sdim "arrayinit.done"); 509234353Sdim llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end"); 510234353Sdim Builder.CreateCondBr(done, endBB, bodyBB); 511234353Sdim currentElement->addIncoming(nextElement, Builder.GetInsertBlock()); 512234353Sdim 513234353Sdim CGF.EmitBlock(endBB); 514234353Sdim } 515234353Sdim 516234353Sdim // Leave the partial-array cleanup if we entered one. 517234353Sdim if (dtorKind) CGF.DeactivateCleanupBlock(cleanup, cleanupDominator); 518234353Sdim} 519234353Sdim 520193326Sed//===----------------------------------------------------------------------===// 521193326Sed// Visitor Methods 522193326Sed//===----------------------------------------------------------------------===// 523193326Sed 524224145Sdimvoid AggExprEmitter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E){ 525224145Sdim Visit(E->GetTemporaryExpr()); 526224145Sdim} 527224145Sdim 528218893Sdimvoid AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) { 529239462Sdim EmitFinalDestCopy(e->getType(), CGF.getOpaqueLValueMapping(e)); 530218893Sdim} 531218893Sdim 532224145Sdimvoid 533224145SdimAggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 534224145Sdim if (E->getType().isPODType(CGF.getContext())) { 535224145Sdim // For a POD type, just emit a load of the lvalue + a copy, because our 536224145Sdim // compound literal might alias the destination. 537224145Sdim // FIXME: This is a band-aid; the real problem appears to be in our handling 538224145Sdim // of assignments, where we store directly into the LHS without checking 539224145Sdim // whether anything in the RHS aliases. 540224145Sdim EmitAggLoadOfLValue(E); 541224145Sdim return; 542224145Sdim } 543224145Sdim 544224145Sdim AggValueSlot Slot = EnsureSlot(E->getType()); 545224145Sdim CGF.EmitAggExpr(E->getInitializer(), Slot); 546224145Sdim} 547224145Sdim 548224145Sdim 549198092Srdivackyvoid AggExprEmitter::VisitCastExpr(CastExpr *E) { 550198092Srdivacky switch (E->getCastKind()) { 551212904Sdim case CK_Dynamic: { 552243830Sdim // FIXME: Can this actually happen? We have no test coverage for it. 553208600Srdivacky assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?"); 554243830Sdim LValue LV = CGF.EmitCheckedLValue(E->getSubExpr(), 555243830Sdim CodeGenFunction::TCK_Load); 556208600Srdivacky // FIXME: Do we also need to handle property references here? 557208600Srdivacky if (LV.isSimple()) 558208600Srdivacky CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E)); 559208600Srdivacky else 560208600Srdivacky CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast"); 561208600Srdivacky 562218893Sdim if (!Dest.isIgnored()) 563218893Sdim CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination"); 564208600Srdivacky break; 565208600Srdivacky } 566208600Srdivacky 567212904Sdim case CK_ToUnion: { 568221345Sdim if (Dest.isIgnored()) break; 569221345Sdim 570198092Srdivacky // GCC union extension 571212904Sdim QualType Ty = E->getSubExpr()->getType(); 572212904Sdim QualType PtrTy = CGF.getContext().getPointerType(Ty); 573218893Sdim llvm::Value *CastPtr = Builder.CreateBitCast(Dest.getAddr(), 574193401Sed CGF.ConvertType(PtrTy)); 575224145Sdim EmitInitializationToLValue(E->getSubExpr(), 576224145Sdim CGF.MakeAddrLValue(CastPtr, Ty)); 577198092Srdivacky break; 578193326Sed } 579193326Sed 580212904Sdim case CK_DerivedToBase: 581212904Sdim case CK_BaseToDerived: 582212904Sdim case CK_UncheckedDerivedToBase: { 583226633Sdim llvm_unreachable("cannot perform hierarchy conversion in EmitAggExpr: " 584208600Srdivacky "should have been unpacked before we got here"); 585208600Srdivacky } 586208600Srdivacky 587239462Sdim case CK_LValueToRValue: 588239462Sdim // If we're loading from a volatile type, force the destination 589239462Sdim // into existence. 590239462Sdim if (E->getSubExpr()->getType().isVolatileQualified()) { 591239462Sdim EnsureDest(E->getType()); 592239462Sdim return Visit(E->getSubExpr()); 593239462Sdim } 594239462Sdim // fallthrough 595239462Sdim 596212904Sdim case CK_NoOp: 597234353Sdim case CK_AtomicToNonAtomic: 598234353Sdim case CK_NonAtomicToAtomic: 599212904Sdim case CK_UserDefinedConversion: 600212904Sdim case CK_ConstructorConversion: 601198092Srdivacky assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(), 602198092Srdivacky E->getType()) && 603198092Srdivacky "Implicit cast types must be compatible"); 604198092Srdivacky Visit(E->getSubExpr()); 605198092Srdivacky break; 606218893Sdim 607212904Sdim case CK_LValueBitCast: 608218893Sdim llvm_unreachable("should not be emitting lvalue bitcast as rvalue"); 609221345Sdim 610218893Sdim case CK_Dependent: 611218893Sdim case CK_BitCast: 612218893Sdim case CK_ArrayToPointerDecay: 613218893Sdim case CK_FunctionToPointerDecay: 614218893Sdim case CK_NullToPointer: 615218893Sdim case CK_NullToMemberPointer: 616218893Sdim case CK_BaseToDerivedMemberPointer: 617218893Sdim case CK_DerivedToBaseMemberPointer: 618218893Sdim case CK_MemberPointerToBoolean: 619234353Sdim case CK_ReinterpretMemberPointer: 620218893Sdim case CK_IntegralToPointer: 621218893Sdim case CK_PointerToIntegral: 622218893Sdim case CK_PointerToBoolean: 623218893Sdim case CK_ToVoid: 624218893Sdim case CK_VectorSplat: 625218893Sdim case CK_IntegralCast: 626218893Sdim case CK_IntegralToBoolean: 627218893Sdim case CK_IntegralToFloating: 628218893Sdim case CK_FloatingToIntegral: 629218893Sdim case CK_FloatingToBoolean: 630218893Sdim case CK_FloatingCast: 631226633Sdim case CK_CPointerToObjCPointerCast: 632226633Sdim case CK_BlockPointerToObjCPointerCast: 633218893Sdim case CK_AnyPointerToBlockPointerCast: 634218893Sdim case CK_ObjCObjectLValueCast: 635218893Sdim case CK_FloatingRealToComplex: 636218893Sdim case CK_FloatingComplexToReal: 637218893Sdim case CK_FloatingComplexToBoolean: 638218893Sdim case CK_FloatingComplexCast: 639218893Sdim case CK_FloatingComplexToIntegralComplex: 640218893Sdim case CK_IntegralRealToComplex: 641218893Sdim case CK_IntegralComplexToReal: 642218893Sdim case CK_IntegralComplexToBoolean: 643218893Sdim case CK_IntegralComplexCast: 644218893Sdim case CK_IntegralComplexToFloatingComplex: 645226633Sdim case CK_ARCProduceObject: 646226633Sdim case CK_ARCConsumeObject: 647226633Sdim case CK_ARCReclaimReturnedObject: 648226633Sdim case CK_ARCExtendBlockObject: 649234353Sdim case CK_CopyAndAutoreleaseBlockObject: 650243830Sdim case CK_BuiltinFnToFnPtr: 651218893Sdim llvm_unreachable("cast kind invalid for aggregate types"); 652198398Srdivacky } 653193326Sed} 654193326Sed 655193326Sedvoid AggExprEmitter::VisitCallExpr(const CallExpr *E) { 656193326Sed if (E->getCallReturnType()->isReferenceType()) { 657193326Sed EmitAggLoadOfLValue(E); 658193326Sed return; 659193326Sed } 660198092Srdivacky 661208600Srdivacky RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot()); 662226633Sdim EmitMoveFromReturnSlot(E, RV); 663193326Sed} 664193326Sed 665193326Sedvoid AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) { 666208600Srdivacky RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot()); 667226633Sdim EmitMoveFromReturnSlot(E, RV); 668193326Sed} 669193326Sed 670193326Sedvoid AggExprEmitter::VisitBinComma(const BinaryOperator *E) { 671218893Sdim CGF.EmitIgnoredExpr(E->getLHS()); 672218893Sdim Visit(E->getRHS()); 673193326Sed} 674193326Sed 675193326Sedvoid AggExprEmitter::VisitStmtExpr(const StmtExpr *E) { 676218893Sdim CodeGenFunction::StmtExprEvaluation eval(CGF); 677218893Sdim CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest); 678193326Sed} 679193326Sed 680193326Sedvoid AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) { 681212904Sdim if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI) 682198398Srdivacky VisitPointerToDataMemberBinaryOperator(E); 683198398Srdivacky else 684198398Srdivacky CGF.ErrorUnsupported(E, "aggregate binary expression"); 685193326Sed} 686193326Sed 687198398Srdivackyvoid AggExprEmitter::VisitPointerToDataMemberBinaryOperator( 688198398Srdivacky const BinaryOperator *E) { 689198398Srdivacky LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E); 690239462Sdim EmitFinalDestCopy(E->getType(), LV); 691198398Srdivacky} 692198398Srdivacky 693239462Sdim/// Is the value of the given expression possibly a reference to or 694239462Sdim/// into a __block variable? 695239462Sdimstatic bool isBlockVarRef(const Expr *E) { 696239462Sdim // Make sure we look through parens. 697239462Sdim E = E->IgnoreParens(); 698239462Sdim 699239462Sdim // Check for a direct reference to a __block variable. 700239462Sdim if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 701239462Sdim const VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl()); 702239462Sdim return (var && var->hasAttr<BlocksAttr>()); 703239462Sdim } 704239462Sdim 705239462Sdim // More complicated stuff. 706239462Sdim 707239462Sdim // Binary operators. 708239462Sdim if (const BinaryOperator *op = dyn_cast<BinaryOperator>(E)) { 709239462Sdim // For an assignment or pointer-to-member operation, just care 710239462Sdim // about the LHS. 711239462Sdim if (op->isAssignmentOp() || op->isPtrMemOp()) 712239462Sdim return isBlockVarRef(op->getLHS()); 713239462Sdim 714239462Sdim // For a comma, just care about the RHS. 715239462Sdim if (op->getOpcode() == BO_Comma) 716239462Sdim return isBlockVarRef(op->getRHS()); 717239462Sdim 718239462Sdim // FIXME: pointer arithmetic? 719239462Sdim return false; 720239462Sdim 721239462Sdim // Check both sides of a conditional operator. 722239462Sdim } else if (const AbstractConditionalOperator *op 723239462Sdim = dyn_cast<AbstractConditionalOperator>(E)) { 724239462Sdim return isBlockVarRef(op->getTrueExpr()) 725239462Sdim || isBlockVarRef(op->getFalseExpr()); 726239462Sdim 727239462Sdim // OVEs are required to support BinaryConditionalOperators. 728239462Sdim } else if (const OpaqueValueExpr *op 729239462Sdim = dyn_cast<OpaqueValueExpr>(E)) { 730239462Sdim if (const Expr *src = op->getSourceExpr()) 731239462Sdim return isBlockVarRef(src); 732239462Sdim 733239462Sdim // Casts are necessary to get things like (*(int*)&var) = foo(). 734239462Sdim // We don't really care about the kind of cast here, except 735239462Sdim // we don't want to look through l2r casts, because it's okay 736239462Sdim // to get the *value* in a __block variable. 737239462Sdim } else if (const CastExpr *cast = dyn_cast<CastExpr>(E)) { 738239462Sdim if (cast->getCastKind() == CK_LValueToRValue) 739239462Sdim return false; 740239462Sdim return isBlockVarRef(cast->getSubExpr()); 741239462Sdim 742239462Sdim // Handle unary operators. Again, just aggressively look through 743239462Sdim // it, ignoring the operation. 744239462Sdim } else if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E)) { 745239462Sdim return isBlockVarRef(uop->getSubExpr()); 746239462Sdim 747239462Sdim // Look into the base of a field access. 748239462Sdim } else if (const MemberExpr *mem = dyn_cast<MemberExpr>(E)) { 749239462Sdim return isBlockVarRef(mem->getBase()); 750239462Sdim 751239462Sdim // Look into the base of a subscript. 752239462Sdim } else if (const ArraySubscriptExpr *sub = dyn_cast<ArraySubscriptExpr>(E)) { 753239462Sdim return isBlockVarRef(sub->getBase()); 754239462Sdim } 755239462Sdim 756239462Sdim return false; 757239462Sdim} 758239462Sdim 759193326Sedvoid AggExprEmitter::VisitBinAssign(const BinaryOperator *E) { 760193326Sed // For an assignment to work, the value on the right has 761193326Sed // to be compatible with the value on the left. 762193326Sed assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 763193326Sed E->getRHS()->getType()) 764193326Sed && "Invalid assignment"); 765218893Sdim 766239462Sdim // If the LHS might be a __block variable, and the RHS can 767239462Sdim // potentially cause a block copy, we need to evaluate the RHS first 768239462Sdim // so that the assignment goes the right place. 769239462Sdim // This is pretty semantically fragile. 770239462Sdim if (isBlockVarRef(E->getLHS()) && 771239462Sdim E->getRHS()->HasSideEffects(CGF.getContext())) { 772239462Sdim // Ensure that we have a destination, and evaluate the RHS into that. 773239462Sdim EnsureDest(E->getRHS()->getType()); 774239462Sdim Visit(E->getRHS()); 775239462Sdim 776239462Sdim // Now emit the LHS and copy into it. 777243830Sdim LValue LHS = CGF.EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store); 778239462Sdim 779239462Sdim EmitCopy(E->getLHS()->getType(), 780239462Sdim AggValueSlot::forLValue(LHS, AggValueSlot::IsDestructed, 781239462Sdim needsGC(E->getLHS()->getType()), 782239462Sdim AggValueSlot::IsAliased), 783239462Sdim Dest); 784239462Sdim return; 785239462Sdim } 786221345Sdim 787193326Sed LValue LHS = CGF.EmitLValue(E->getLHS()); 788193326Sed 789234353Sdim // Codegen the RHS so that it stores directly into the LHS. 790234353Sdim AggValueSlot LHSSlot = 791234353Sdim AggValueSlot::forLValue(LHS, AggValueSlot::IsDestructed, 792234353Sdim needsGC(E->getLHS()->getType()), 793234353Sdim AggValueSlot::IsAliased); 794239462Sdim CGF.EmitAggExpr(E->getRHS(), LHSSlot); 795239462Sdim 796239462Sdim // Copy into the destination if the assignment isn't ignored. 797239462Sdim EmitFinalDestCopy(E->getType(), LHS); 798193326Sed} 799193326Sed 800218893Sdimvoid AggExprEmitter:: 801218893SdimVisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 802193326Sed llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 803193326Sed llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 804193326Sed llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 805198092Srdivacky 806218893Sdim // Bind the common expression if necessary. 807218893Sdim CodeGenFunction::OpaqueValueMapping binding(CGF, E); 808218893Sdim 809218893Sdim CodeGenFunction::ConditionalEvaluation eval(CGF); 810201361Srdivacky CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 811198092Srdivacky 812218893Sdim // Save whether the destination's lifetime is externally managed. 813226633Sdim bool isExternallyDestructed = Dest.isExternallyDestructed(); 814218893Sdim 815218893Sdim eval.begin(CGF); 816193326Sed CGF.EmitBlock(LHSBlock); 817218893Sdim Visit(E->getTrueExpr()); 818218893Sdim eval.end(CGF); 819198092Srdivacky 820218893Sdim assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!"); 821218893Sdim CGF.Builder.CreateBr(ContBlock); 822193326Sed 823218893Sdim // If the result of an agg expression is unused, then the emission 824218893Sdim // of the LHS might need to create a destination slot. That's fine 825218893Sdim // with us, and we can safely emit the RHS into the same slot, but 826226633Sdim // we shouldn't claim that it's already being destructed. 827226633Sdim Dest.setExternallyDestructed(isExternallyDestructed); 828198092Srdivacky 829218893Sdim eval.begin(CGF); 830193326Sed CGF.EmitBlock(RHSBlock); 831218893Sdim Visit(E->getFalseExpr()); 832218893Sdim eval.end(CGF); 833198092Srdivacky 834193326Sed CGF.EmitBlock(ContBlock); 835193326Sed} 836193326Sed 837198092Srdivackyvoid AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) { 838198092Srdivacky Visit(CE->getChosenSubExpr(CGF.getContext())); 839198092Srdivacky} 840198092Srdivacky 841193326Sedvoid AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 842193326Sed llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 843193326Sed llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 844193326Sed 845193326Sed if (!ArgPtr) { 846193326Sed CGF.ErrorUnsupported(VE, "aggregate va_arg expression"); 847193326Sed return; 848193326Sed } 849193326Sed 850239462Sdim EmitFinalDestCopy(VE->getType(), CGF.MakeAddrLValue(ArgPtr, VE->getType())); 851193326Sed} 852193326Sed 853193326Sedvoid AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 854218893Sdim // Ensure that we have a slot, but if we already do, remember 855226633Sdim // whether it was externally destructed. 856226633Sdim bool wasExternallyDestructed = Dest.isExternallyDestructed(); 857239462Sdim EnsureDest(E->getType()); 858198092Srdivacky 859226633Sdim // We're going to push a destructor if there isn't already one. 860226633Sdim Dest.setExternallyDestructed(); 861226633Sdim 862218893Sdim Visit(E->getSubExpr()); 863193326Sed 864226633Sdim // Push that destructor we promised. 865226633Sdim if (!wasExternallyDestructed) 866234353Sdim CGF.EmitCXXTemporary(E->getTemporary(), E->getType(), Dest.getAddr()); 867193326Sed} 868193326Sed 869193326Sedvoid 870193326SedAggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) { 871218893Sdim AggValueSlot Slot = EnsureSlot(E->getType()); 872218893Sdim CGF.EmitCXXConstructExpr(E, Slot); 873193326Sed} 874193326Sed 875234353Sdimvoid 876234353SdimAggExprEmitter::VisitLambdaExpr(LambdaExpr *E) { 877234353Sdim AggValueSlot Slot = EnsureSlot(E->getType()); 878234353Sdim CGF.EmitLambdaExpr(E, Slot); 879234353Sdim} 880234353Sdim 881218893Sdimvoid AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) { 882234353Sdim CGF.enterFullExpression(E); 883234353Sdim CodeGenFunction::RunCleanupsScope cleanups(CGF); 884234353Sdim Visit(E->getSubExpr()); 885193326Sed} 886193326Sed 887210299Sedvoid AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 888218893Sdim QualType T = E->getType(); 889218893Sdim AggValueSlot Slot = EnsureSlot(T); 890224145Sdim EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T)); 891198398Srdivacky} 892198398Srdivacky 893201361Srdivackyvoid AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 894218893Sdim QualType T = E->getType(); 895218893Sdim AggValueSlot Slot = EnsureSlot(T); 896224145Sdim EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T)); 897218893Sdim} 898201361Srdivacky 899218893Sdim/// isSimpleZero - If emitting this value will obviously just cause a store of 900218893Sdim/// zero to memory, return true. This can return false if uncertain, so it just 901218893Sdim/// handles simple cases. 902218893Sdimstatic bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) { 903221345Sdim E = E->IgnoreParens(); 904221345Sdim 905218893Sdim // 0 906218893Sdim if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E)) 907218893Sdim return IL->getValue() == 0; 908218893Sdim // +0.0 909218893Sdim if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E)) 910218893Sdim return FL->getValue().isPosZero(); 911218893Sdim // int() 912218893Sdim if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) && 913218893Sdim CGF.getTypes().isZeroInitializable(E->getType())) 914218893Sdim return true; 915218893Sdim // (int*)0 - Null pointer expressions. 916218893Sdim if (const CastExpr *ICE = dyn_cast<CastExpr>(E)) 917218893Sdim return ICE->getCastKind() == CK_NullToPointer; 918218893Sdim // '\0' 919218893Sdim if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E)) 920218893Sdim return CL->getValue() == 0; 921218893Sdim 922218893Sdim // Otherwise, hard case: conservatively return false. 923218893Sdim return false; 924201361Srdivacky} 925201361Srdivacky 926218893Sdim 927203955Srdivackyvoid 928224145SdimAggExprEmitter::EmitInitializationToLValue(Expr* E, LValue LV) { 929224145Sdim QualType type = LV.getType(); 930193326Sed // FIXME: Ignore result? 931193326Sed // FIXME: Are initializers affected by volatile? 932218893Sdim if (Dest.isZeroed() && isSimpleZero(E, CGF)) { 933218893Sdim // Storing "i32 0" to a zero'd memory location is a noop. 934218893Sdim } else if (isa<ImplicitValueInitExpr>(E)) { 935224145Sdim EmitNullInitializationToLValue(LV); 936224145Sdim } else if (type->isReferenceType()) { 937210299Sed RValue RV = CGF.EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0); 938224145Sdim CGF.EmitStoreThroughLValue(RV, LV); 939224145Sdim } else if (type->isAnyComplexType()) { 940193326Sed CGF.EmitComplexExprIntoAddr(E, LV.getAddress(), false); 941224145Sdim } else if (CGF.hasAggregateLLVMType(type)) { 942226633Sdim CGF.EmitAggExpr(E, AggValueSlot::forLValue(LV, 943226633Sdim AggValueSlot::IsDestructed, 944226633Sdim AggValueSlot::DoesNotNeedGCBarriers, 945226633Sdim AggValueSlot::IsNotAliased, 946224145Sdim Dest.isZeroed())); 947224145Sdim } else if (LV.isSimple()) { 948224145Sdim CGF.EmitScalarInit(E, /*D=*/0, LV, /*Captured=*/false); 949193326Sed } else { 950224145Sdim CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV); 951193326Sed } 952193326Sed} 953193326Sed 954224145Sdimvoid AggExprEmitter::EmitNullInitializationToLValue(LValue lv) { 955224145Sdim QualType type = lv.getType(); 956224145Sdim 957218893Sdim // If the destination slot is already zeroed out before the aggregate is 958218893Sdim // copied into it, we don't have to emit any zeros here. 959224145Sdim if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(type)) 960218893Sdim return; 961218893Sdim 962224145Sdim if (!CGF.hasAggregateLLVMType(type)) { 963234353Sdim // For non-aggregates, we can store zero. 964224145Sdim llvm::Value *null = llvm::Constant::getNullValue(CGF.ConvertType(type)); 965234353Sdim // Note that the following is not equivalent to 966234353Sdim // EmitStoreThroughBitfieldLValue for ARC types. 967234353Sdim if (lv.isBitField()) { 968234353Sdim CGF.EmitStoreThroughBitfieldLValue(RValue::get(null), lv); 969234353Sdim } else { 970234353Sdim assert(lv.isSimple()); 971234353Sdim CGF.EmitStoreOfScalar(null, lv, /* isInitialization */ true); 972234353Sdim } 973193326Sed } else { 974193326Sed // There's a potential optimization opportunity in combining 975193326Sed // memsets; that would be easy for arrays, but relatively 976193326Sed // difficult for structures with the current code. 977224145Sdim CGF.EmitNullInitialization(lv.getAddress(), lv.getType()); 978193326Sed } 979193326Sed} 980193326Sed 981193326Sedvoid AggExprEmitter::VisitInitListExpr(InitListExpr *E) { 982193326Sed#if 0 983200583Srdivacky // FIXME: Assess perf here? Figure out what cases are worth optimizing here 984200583Srdivacky // (Length of globals? Chunks of zeroed-out space?). 985193326Sed // 986193326Sed // If we can, prefer a copy from a global; this is a lot less code for long 987193326Sed // globals, and it's easier for the current optimizers to analyze. 988200583Srdivacky if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) { 989193326Sed llvm::GlobalVariable* GV = 990200583Srdivacky new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true, 991200583Srdivacky llvm::GlobalValue::InternalLinkage, C, ""); 992239462Sdim EmitFinalDestCopy(E->getType(), CGF.MakeAddrLValue(GV, E->getType())); 993193326Sed return; 994193326Sed } 995193326Sed#endif 996218893Sdim if (E->hadArrayRangeDesignator()) 997193326Sed CGF.ErrorUnsupported(E, "GNU array range designator extension"); 998193326Sed 999234353Sdim if (E->initializesStdInitializerList()) { 1000234353Sdim EmitStdInitializerList(Dest.getAddr(), E); 1001234353Sdim return; 1002234353Sdim } 1003218893Sdim 1004234982Sdim AggValueSlot Dest = EnsureSlot(E->getType()); 1005234982Sdim LValue DestLV = CGF.MakeAddrLValue(Dest.getAddr(), E->getType(), 1006234982Sdim Dest.getAlignment()); 1007234353Sdim 1008193326Sed // Handle initialization of an array. 1009193326Sed if (E->getType()->isArrayType()) { 1010234982Sdim if (E->isStringLiteralInit()) 1011234982Sdim return Visit(E->getInit(0)); 1012193326Sed 1013234353Sdim QualType elementType = 1014234353Sdim CGF.getContext().getAsArrayType(E->getType())->getElementType(); 1015193326Sed 1016234353Sdim llvm::PointerType *APType = 1017234982Sdim cast<llvm::PointerType>(Dest.getAddr()->getType()); 1018234353Sdim llvm::ArrayType *AType = 1019234353Sdim cast<llvm::ArrayType>(APType->getElementType()); 1020224145Sdim 1021234982Sdim EmitArrayInit(Dest.getAddr(), AType, elementType, E); 1022193326Sed return; 1023193326Sed } 1024198092Srdivacky 1025193326Sed assert(E->getType()->isRecordType() && "Only support structs/unions here!"); 1026198092Srdivacky 1027193326Sed // Do struct initialization; this code just sets each individual member 1028193326Sed // to the approprate value. This makes bitfield support automatic; 1029193326Sed // the disadvantage is that the generated code is more difficult for 1030193326Sed // the optimizer, especially with bitfields. 1031193326Sed unsigned NumInitElements = E->getNumInits(); 1032224145Sdim RecordDecl *record = E->getType()->castAs<RecordType>()->getDecl(); 1033212904Sdim 1034224145Sdim if (record->isUnion()) { 1035193326Sed // Only initialize one field of a union. The field itself is 1036193326Sed // specified by the initializer list. 1037193326Sed if (!E->getInitializedFieldInUnion()) { 1038193326Sed // Empty union; we have nothing to do. 1039198092Srdivacky 1040193326Sed#ifndef NDEBUG 1041193326Sed // Make sure that it's really an empty and not a failure of 1042193326Sed // semantic analysis. 1043224145Sdim for (RecordDecl::field_iterator Field = record->field_begin(), 1044224145Sdim FieldEnd = record->field_end(); 1045193326Sed Field != FieldEnd; ++Field) 1046193326Sed assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed"); 1047193326Sed#endif 1048193326Sed return; 1049193326Sed } 1050193326Sed 1051193326Sed // FIXME: volatility 1052193326Sed FieldDecl *Field = E->getInitializedFieldInUnion(); 1053218893Sdim 1054234982Sdim LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestLV, Field); 1055193326Sed if (NumInitElements) { 1056193326Sed // Store the initializer into the field 1057224145Sdim EmitInitializationToLValue(E->getInit(0), FieldLoc); 1058193326Sed } else { 1059218893Sdim // Default-initialize to null. 1060224145Sdim EmitNullInitializationToLValue(FieldLoc); 1061193326Sed } 1062193326Sed 1063193326Sed return; 1064193326Sed } 1065198092Srdivacky 1066224145Sdim // We'll need to enter cleanup scopes in case any of the member 1067224145Sdim // initializers throw an exception. 1068226633Sdim SmallVector<EHScopeStack::stable_iterator, 16> cleanups; 1069234353Sdim llvm::Instruction *cleanupDominator = 0; 1070224145Sdim 1071193326Sed // Here we iterate over the fields; this makes it simpler to both 1072193326Sed // default-initialize fields and skip over unnamed fields. 1073224145Sdim unsigned curInitIndex = 0; 1074224145Sdim for (RecordDecl::field_iterator field = record->field_begin(), 1075224145Sdim fieldEnd = record->field_end(); 1076224145Sdim field != fieldEnd; ++field) { 1077224145Sdim // We're done once we hit the flexible array member. 1078224145Sdim if (field->getType()->isIncompleteArrayType()) 1079193326Sed break; 1080193326Sed 1081224145Sdim // Always skip anonymous bitfields. 1082224145Sdim if (field->isUnnamedBitfield()) 1083193326Sed continue; 1084193326Sed 1085224145Sdim // We're done if we reach the end of the explicit initializers, we 1086224145Sdim // have a zeroed object, and the rest of the fields are 1087224145Sdim // zero-initializable. 1088224145Sdim if (curInitIndex == NumInitElements && Dest.isZeroed() && 1089218893Sdim CGF.getTypes().isZeroInitializable(E->getType())) 1090218893Sdim break; 1091218893Sdim 1092234982Sdim 1093234982Sdim LValue LV = CGF.EmitLValueForFieldInitialization(DestLV, *field); 1094193326Sed // We never generate write-barries for initialized fields. 1095224145Sdim LV.setNonGC(true); 1096218893Sdim 1097224145Sdim if (curInitIndex < NumInitElements) { 1098204962Srdivacky // Store the initializer into the field. 1099224145Sdim EmitInitializationToLValue(E->getInit(curInitIndex++), LV); 1100193326Sed } else { 1101193326Sed // We're out of initalizers; default-initialize to null 1102224145Sdim EmitNullInitializationToLValue(LV); 1103193326Sed } 1104224145Sdim 1105224145Sdim // Push a destructor if necessary. 1106224145Sdim // FIXME: if we have an array of structures, all explicitly 1107224145Sdim // initialized, we can end up pushing a linear number of cleanups. 1108224145Sdim bool pushedCleanup = false; 1109224145Sdim if (QualType::DestructionKind dtorKind 1110224145Sdim = field->getType().isDestructedType()) { 1111224145Sdim assert(LV.isSimple()); 1112224145Sdim if (CGF.needsEHCleanup(dtorKind)) { 1113234353Sdim if (!cleanupDominator) 1114234353Sdim cleanupDominator = CGF.Builder.CreateUnreachable(); // placeholder 1115234353Sdim 1116224145Sdim CGF.pushDestroy(EHCleanup, LV.getAddress(), field->getType(), 1117224145Sdim CGF.getDestroyer(dtorKind), false); 1118224145Sdim cleanups.push_back(CGF.EHStack.stable_begin()); 1119224145Sdim pushedCleanup = true; 1120224145Sdim } 1121224145Sdim } 1122218893Sdim 1123218893Sdim // If the GEP didn't get used because of a dead zero init or something 1124218893Sdim // else, clean it up for -O0 builds and general tidiness. 1125224145Sdim if (!pushedCleanup && LV.isSimple()) 1126218893Sdim if (llvm::GetElementPtrInst *GEP = 1127224145Sdim dyn_cast<llvm::GetElementPtrInst>(LV.getAddress())) 1128218893Sdim if (GEP->use_empty()) 1129218893Sdim GEP->eraseFromParent(); 1130193326Sed } 1131224145Sdim 1132224145Sdim // Deactivate all the partial cleanups in reverse order, which 1133224145Sdim // generally means popping them. 1134224145Sdim for (unsigned i = cleanups.size(); i != 0; --i) 1135234353Sdim CGF.DeactivateCleanupBlock(cleanups[i-1], cleanupDominator); 1136234353Sdim 1137234353Sdim // Destroy the placeholder if we made one. 1138234353Sdim if (cleanupDominator) 1139234353Sdim cleanupDominator->eraseFromParent(); 1140193326Sed} 1141193326Sed 1142193326Sed//===----------------------------------------------------------------------===// 1143193326Sed// Entry Points into this File 1144193326Sed//===----------------------------------------------------------------------===// 1145193326Sed 1146218893Sdim/// GetNumNonZeroBytesInInit - Get an approximate count of the number of 1147218893Sdim/// non-zero bytes that will be stored when outputting the initializer for the 1148218893Sdim/// specified initializer expression. 1149221345Sdimstatic CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) { 1150221345Sdim E = E->IgnoreParens(); 1151218893Sdim 1152218893Sdim // 0 and 0.0 won't require any non-zero stores! 1153221345Sdim if (isSimpleZero(E, CGF)) return CharUnits::Zero(); 1154218893Sdim 1155218893Sdim // If this is an initlist expr, sum up the size of sizes of the (present) 1156218893Sdim // elements. If this is something weird, assume the whole thing is non-zero. 1157218893Sdim const InitListExpr *ILE = dyn_cast<InitListExpr>(E); 1158218893Sdim if (ILE == 0 || !CGF.getTypes().isZeroInitializable(ILE->getType())) 1159221345Sdim return CGF.getContext().getTypeSizeInChars(E->getType()); 1160218893Sdim 1161218893Sdim // InitListExprs for structs have to be handled carefully. If there are 1162218893Sdim // reference members, we need to consider the size of the reference, not the 1163218893Sdim // referencee. InitListExprs for unions and arrays can't have references. 1164218893Sdim if (const RecordType *RT = E->getType()->getAs<RecordType>()) { 1165218893Sdim if (!RT->isUnionType()) { 1166218893Sdim RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl(); 1167221345Sdim CharUnits NumNonZeroBytes = CharUnits::Zero(); 1168218893Sdim 1169218893Sdim unsigned ILEElement = 0; 1170218893Sdim for (RecordDecl::field_iterator Field = SD->field_begin(), 1171218893Sdim FieldEnd = SD->field_end(); Field != FieldEnd; ++Field) { 1172218893Sdim // We're done once we hit the flexible array member or run out of 1173218893Sdim // InitListExpr elements. 1174218893Sdim if (Field->getType()->isIncompleteArrayType() || 1175218893Sdim ILEElement == ILE->getNumInits()) 1176218893Sdim break; 1177218893Sdim if (Field->isUnnamedBitfield()) 1178218893Sdim continue; 1179218893Sdim 1180218893Sdim const Expr *E = ILE->getInit(ILEElement++); 1181218893Sdim 1182218893Sdim // Reference values are always non-null and have the width of a pointer. 1183218893Sdim if (Field->getType()->isReferenceType()) 1184221345Sdim NumNonZeroBytes += CGF.getContext().toCharUnitsFromBits( 1185226633Sdim CGF.getContext().getTargetInfo().getPointerWidth(0)); 1186218893Sdim else 1187218893Sdim NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF); 1188218893Sdim } 1189218893Sdim 1190218893Sdim return NumNonZeroBytes; 1191218893Sdim } 1192218893Sdim } 1193218893Sdim 1194218893Sdim 1195221345Sdim CharUnits NumNonZeroBytes = CharUnits::Zero(); 1196218893Sdim for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i) 1197218893Sdim NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF); 1198218893Sdim return NumNonZeroBytes; 1199218893Sdim} 1200218893Sdim 1201218893Sdim/// CheckAggExprForMemSetUse - If the initializer is large and has a lot of 1202218893Sdim/// zeros in it, emit a memset and avoid storing the individual zeros. 1203218893Sdim/// 1204218893Sdimstatic void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E, 1205218893Sdim CodeGenFunction &CGF) { 1206218893Sdim // If the slot is already known to be zeroed, nothing to do. Don't mess with 1207218893Sdim // volatile stores. 1208218893Sdim if (Slot.isZeroed() || Slot.isVolatile() || Slot.getAddr() == 0) return; 1209221345Sdim 1210221345Sdim // C++ objects with a user-declared constructor don't need zero'ing. 1211243830Sdim if (CGF.getLangOpts().CPlusPlus) 1212221345Sdim if (const RecordType *RT = CGF.getContext() 1213221345Sdim .getBaseElementType(E->getType())->getAs<RecordType>()) { 1214221345Sdim const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 1215221345Sdim if (RD->hasUserDeclaredConstructor()) 1216221345Sdim return; 1217221345Sdim } 1218221345Sdim 1219218893Sdim // If the type is 16-bytes or smaller, prefer individual stores over memset. 1220221345Sdim std::pair<CharUnits, CharUnits> TypeInfo = 1221221345Sdim CGF.getContext().getTypeInfoInChars(E->getType()); 1222221345Sdim if (TypeInfo.first <= CharUnits::fromQuantity(16)) 1223218893Sdim return; 1224218893Sdim 1225218893Sdim // Check to see if over 3/4 of the initializer are known to be zero. If so, 1226218893Sdim // we prefer to emit memset + individual stores for the rest. 1227221345Sdim CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF); 1228221345Sdim if (NumNonZeroBytes*4 > TypeInfo.first) 1229218893Sdim return; 1230218893Sdim 1231218893Sdim // Okay, it seems like a good idea to use an initial memset, emit the call. 1232221345Sdim llvm::Constant *SizeVal = CGF.Builder.getInt64(TypeInfo.first.getQuantity()); 1233221345Sdim CharUnits Align = TypeInfo.second; 1234218893Sdim 1235218893Sdim llvm::Value *Loc = Slot.getAddr(); 1236218893Sdim 1237234353Sdim Loc = CGF.Builder.CreateBitCast(Loc, CGF.Int8PtrTy); 1238221345Sdim CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, 1239221345Sdim Align.getQuantity(), false); 1240218893Sdim 1241218893Sdim // Tell the AggExprEmitter that the slot is known zero. 1242218893Sdim Slot.setZeroed(); 1243218893Sdim} 1244218893Sdim 1245218893Sdim 1246218893Sdim 1247218893Sdim 1248193326Sed/// EmitAggExpr - Emit the computation of the specified expression of aggregate 1249193326Sed/// type. The result is computed into DestPtr. Note that if DestPtr is null, 1250193326Sed/// the value of the aggregate expression is not needed. If VolatileDest is 1251193326Sed/// true, DestPtr cannot be 0. 1252239462Sdimvoid CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot) { 1253193326Sed assert(E && hasAggregateLLVMType(E->getType()) && 1254193326Sed "Invalid aggregate expression to emit"); 1255218893Sdim assert((Slot.getAddr() != 0 || Slot.isIgnored()) && 1256218893Sdim "slot has bits but no address"); 1257198092Srdivacky 1258218893Sdim // Optimize the slot if possible. 1259218893Sdim CheckAggExprForMemSetUse(Slot, E, *this); 1260218893Sdim 1261239462Sdim AggExprEmitter(*this, Slot).Visit(const_cast<Expr*>(E)); 1262193326Sed} 1263193326Sed 1264203955SrdivackyLValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) { 1265203955Srdivacky assert(hasAggregateLLVMType(E->getType()) && "Invalid argument!"); 1266203955Srdivacky llvm::Value *Temp = CreateMemTemp(E->getType()); 1267212904Sdim LValue LV = MakeAddrLValue(Temp, E->getType()); 1268226633Sdim EmitAggExpr(E, AggValueSlot::forLValue(LV, AggValueSlot::IsNotDestructed, 1269226633Sdim AggValueSlot::DoesNotNeedGCBarriers, 1270226633Sdim AggValueSlot::IsNotAliased)); 1271212904Sdim return LV; 1272203955Srdivacky} 1273203955Srdivacky 1274193326Sedvoid CodeGenFunction::EmitAggregateCopy(llvm::Value *DestPtr, 1275193326Sed llvm::Value *SrcPtr, QualType Ty, 1276239462Sdim bool isVolatile, 1277243830Sdim CharUnits alignment, 1278243830Sdim bool isAssignment) { 1279193326Sed assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex"); 1280198092Srdivacky 1281243830Sdim if (getLangOpts().CPlusPlus) { 1282207619Srdivacky if (const RecordType *RT = Ty->getAs<RecordType>()) { 1283208600Srdivacky CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl()); 1284208600Srdivacky assert((Record->hasTrivialCopyConstructor() || 1285226633Sdim Record->hasTrivialCopyAssignment() || 1286226633Sdim Record->hasTrivialMoveConstructor() || 1287226633Sdim Record->hasTrivialMoveAssignment()) && 1288208600Srdivacky "Trying to aggregate-copy a type without a trivial copy " 1289208600Srdivacky "constructor or assignment operator"); 1290208600Srdivacky // Ignore empty classes in C++. 1291208600Srdivacky if (Record->isEmpty()) 1292207619Srdivacky return; 1293207619Srdivacky } 1294207619Srdivacky } 1295207619Srdivacky 1296193326Sed // Aggregate assignment turns into llvm.memcpy. This is almost valid per 1297193326Sed // C99 6.5.16.1p3, which states "If the value being stored in an object is 1298193326Sed // read from another object that overlaps in anyway the storage of the first 1299193326Sed // object, then the overlap shall be exact and the two objects shall have 1300193326Sed // qualified or unqualified versions of a compatible type." 1301193326Sed // 1302193326Sed // memcpy is not defined if the source and destination pointers are exactly 1303193326Sed // equal, but other compilers do this optimization, and almost every memcpy 1304193326Sed // implementation handles this case safely. If there is a libc that does not 1305193326Sed // safely handle this, we can add a target hook. 1306198092Srdivacky 1307243830Sdim // Get data size and alignment info for this aggregate. If this is an 1308243830Sdim // assignment don't copy the tail padding. Otherwise copying it is fine. 1309243830Sdim std::pair<CharUnits, CharUnits> TypeInfo; 1310243830Sdim if (isAssignment) 1311243830Sdim TypeInfo = getContext().getTypeInfoDataSizeInChars(Ty); 1312243830Sdim else 1313243830Sdim TypeInfo = getContext().getTypeInfoInChars(Ty); 1314198092Srdivacky 1315239462Sdim if (alignment.isZero()) 1316239462Sdim alignment = TypeInfo.second; 1317234353Sdim 1318193326Sed // FIXME: Handle variable sized types. 1319198092Srdivacky 1320193326Sed // FIXME: If we have a volatile struct, the optimizer can remove what might 1321193326Sed // appear to be `extra' memory ops: 1322193326Sed // 1323193326Sed // volatile struct { int i; } a, b; 1324193326Sed // 1325193326Sed // int main() { 1326193326Sed // a = b; 1327193326Sed // a = b; 1328193326Sed // } 1329193326Sed // 1330206275Srdivacky // we need to use a different call here. We use isVolatile to indicate when 1331193326Sed // either the source or the destination is volatile. 1332206275Srdivacky 1333226633Sdim llvm::PointerType *DPT = cast<llvm::PointerType>(DestPtr->getType()); 1334226633Sdim llvm::Type *DBP = 1335218893Sdim llvm::Type::getInt8PtrTy(getLLVMContext(), DPT->getAddressSpace()); 1336226633Sdim DestPtr = Builder.CreateBitCast(DestPtr, DBP); 1337206275Srdivacky 1338226633Sdim llvm::PointerType *SPT = cast<llvm::PointerType>(SrcPtr->getType()); 1339226633Sdim llvm::Type *SBP = 1340218893Sdim llvm::Type::getInt8PtrTy(getLLVMContext(), SPT->getAddressSpace()); 1341226633Sdim SrcPtr = Builder.CreateBitCast(SrcPtr, SBP); 1342206275Srdivacky 1343224145Sdim // Don't do any of the memmove_collectable tests if GC isn't set. 1344234353Sdim if (CGM.getLangOpts().getGC() == LangOptions::NonGC) { 1345224145Sdim // fall through 1346224145Sdim } else if (const RecordType *RecordTy = Ty->getAs<RecordType>()) { 1347210299Sed RecordDecl *Record = RecordTy->getDecl(); 1348210299Sed if (Record->hasObjectMember()) { 1349221345Sdim CharUnits size = TypeInfo.first; 1350226633Sdim llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 1351221345Sdim llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size.getQuantity()); 1352210299Sed CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr, 1353210299Sed SizeVal); 1354210299Sed return; 1355210299Sed } 1356224145Sdim } else if (Ty->isArrayType()) { 1357210299Sed QualType BaseType = getContext().getBaseElementType(Ty); 1358210299Sed if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) { 1359210299Sed if (RecordTy->getDecl()->hasObjectMember()) { 1360221345Sdim CharUnits size = TypeInfo.first; 1361226633Sdim llvm::Type *SizeTy = ConvertType(getContext().getSizeType()); 1362221345Sdim llvm::Value *SizeVal = 1363221345Sdim llvm::ConstantInt::get(SizeTy, size.getQuantity()); 1364210299Sed CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr, 1365210299Sed SizeVal); 1366210299Sed return; 1367210299Sed } 1368210299Sed } 1369210299Sed } 1370243830Sdim 1371243830Sdim // Determine the metadata to describe the position of any padding in this 1372243830Sdim // memcpy, as well as the TBAA tags for the members of the struct, in case 1373243830Sdim // the optimizer wishes to expand it in to scalar memory operations. 1374243830Sdim llvm::MDNode *TBAAStructTag = CGM.getTBAAStructInfo(Ty); 1375210299Sed 1376218893Sdim Builder.CreateMemCpy(DestPtr, SrcPtr, 1377221345Sdim llvm::ConstantInt::get(IntPtrTy, 1378221345Sdim TypeInfo.first.getQuantity()), 1379243830Sdim alignment.getQuantity(), isVolatile, 1380243830Sdim /*TBAATag=*/0, TBAAStructTag); 1381193326Sed} 1382234353Sdim 1383234353Sdimvoid CodeGenFunction::MaybeEmitStdInitializerListCleanup(llvm::Value *loc, 1384234353Sdim const Expr *init) { 1385234353Sdim const ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(init); 1386234353Sdim if (cleanups) 1387234353Sdim init = cleanups->getSubExpr(); 1388234353Sdim 1389234353Sdim if (isa<InitListExpr>(init) && 1390234353Sdim cast<InitListExpr>(init)->initializesStdInitializerList()) { 1391234353Sdim // We initialized this std::initializer_list with an initializer list. 1392234353Sdim // A backing array was created. Push a cleanup for it. 1393234353Sdim EmitStdInitializerListCleanup(loc, cast<InitListExpr>(init)); 1394234353Sdim } 1395234353Sdim} 1396234353Sdim 1397234353Sdimstatic void EmitRecursiveStdInitializerListCleanup(CodeGenFunction &CGF, 1398234353Sdim llvm::Value *arrayStart, 1399234353Sdim const InitListExpr *init) { 1400234353Sdim // Check if there are any recursive cleanups to do, i.e. if we have 1401234353Sdim // std::initializer_list<std::initializer_list<obj>> list = {{obj()}}; 1402234353Sdim // then we need to destroy the inner array as well. 1403234353Sdim for (unsigned i = 0, e = init->getNumInits(); i != e; ++i) { 1404234353Sdim const InitListExpr *subInit = dyn_cast<InitListExpr>(init->getInit(i)); 1405234353Sdim if (!subInit || !subInit->initializesStdInitializerList()) 1406234353Sdim continue; 1407234353Sdim 1408234353Sdim // This one needs to be destroyed. Get the address of the std::init_list. 1409234353Sdim llvm::Value *offset = llvm::ConstantInt::get(CGF.SizeTy, i); 1410234353Sdim llvm::Value *loc = CGF.Builder.CreateInBoundsGEP(arrayStart, offset, 1411234353Sdim "std.initlist"); 1412234353Sdim CGF.EmitStdInitializerListCleanup(loc, subInit); 1413234353Sdim } 1414234353Sdim} 1415234353Sdim 1416234353Sdimvoid CodeGenFunction::EmitStdInitializerListCleanup(llvm::Value *loc, 1417234353Sdim const InitListExpr *init) { 1418234353Sdim ASTContext &ctx = getContext(); 1419234353Sdim QualType element = GetStdInitializerListElementType(init->getType()); 1420234353Sdim unsigned numInits = init->getNumInits(); 1421234353Sdim llvm::APInt size(ctx.getTypeSize(ctx.getSizeType()), numInits); 1422234353Sdim QualType array =ctx.getConstantArrayType(element, size, ArrayType::Normal, 0); 1423234353Sdim QualType arrayPtr = ctx.getPointerType(array); 1424234353Sdim llvm::Type *arrayPtrType = ConvertType(arrayPtr); 1425234353Sdim 1426234353Sdim // lvalue is the location of a std::initializer_list, which as its first 1427234353Sdim // element has a pointer to the array we want to destroy. 1428234353Sdim llvm::Value *startPointer = Builder.CreateStructGEP(loc, 0, "startPointer"); 1429234353Sdim llvm::Value *startAddress = Builder.CreateLoad(startPointer, "startAddress"); 1430234353Sdim 1431234353Sdim ::EmitRecursiveStdInitializerListCleanup(*this, startAddress, init); 1432234353Sdim 1433234353Sdim llvm::Value *arrayAddress = 1434234353Sdim Builder.CreateBitCast(startAddress, arrayPtrType, "arrayAddress"); 1435234353Sdim ::EmitStdInitializerListCleanup(*this, array, arrayAddress, init); 1436234353Sdim} 1437