lib/CodeGen/CGExprAgg.cpp

   1 //===--- CGExprAgg.cpp - Emit LLVM Code from Aggregate Expressions --------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This contains code to emit Aggregate Expr nodes as LLVM code.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CodeGenFunction.h"
  15 #include "CodeGenModule.h"
  16 #include "CGObjCRuntime.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/AST/DeclCXX.h"
  19 #include "clang/AST/DeclTemplate.h"
  20 #include "clang/AST/StmtVisitor.h"
  21 #include "llvm/Constants.h"
  22 #include "llvm/Function.h"
  23 #include "llvm/GlobalVariable.h"
  24 #include "llvm/Intrinsics.h"
  25 using namespace clang;
  26 using namespace CodeGen;
  27
  28 //===----------------------------------------------------------------------===//
  29 //                        Aggregate Expression Emitter
  30 //===----------------------------------------------------------------------===//
  31
  32 namespace  {
  33 class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
  34   CodeGenFunction &CGF;
  35   CGBuilderTy &Builder;
  36   AggValueSlot Dest;
  37
  38   /// We want to use 'dest' as the return slot except under two
  39   /// conditions:
  40   ///   - The destination slot requires garbage collection, so we
  41   ///     need to use the GC API.
  42   ///   - The destination slot is potentially aliased.
  43   bool shouldUseDestForReturnSlot() const {
  44     return !(Dest.requiresGCollection() || Dest.isPotentiallyAliased());
  45   }
  46
  47   ReturnValueSlot getReturnValueSlot() const {
  48     if (!shouldUseDestForReturnSlot())
  49       return ReturnValueSlot();
  50
  51     return ReturnValueSlot(Dest.getAddr(), Dest.isVolatile());
  52   }
  53
  54   AggValueSlot EnsureSlot(QualType T) {
  55     if (!Dest.isIgnored()) return Dest;
  56     return CGF.CreateAggTemp(T, "agg.tmp.ensured");
  57   }
  58   void EnsureDest(QualType T) {
  59     if (!Dest.isIgnored()) return;
  60     Dest = CGF.CreateAggTemp(T, "agg.tmp.ensured");
  61   }
  62
  63 public:
  64   AggExprEmitter(CodeGenFunction &cgf, AggValueSlot Dest)
  65     : CGF(cgf), Builder(CGF.Builder), Dest(Dest) {
  66   }
  67
  68   //===--------------------------------------------------------------------===//
  69   //                               Utilities
  70   //===--------------------------------------------------------------------===//
  71
  72   /// EmitAggLoadOfLValue - Given an expression with aggregate type that
  73   /// represents a value lvalue, this method emits the address of the lvalue,
  74   /// then loads the result into DestPtr.
  75   void EmitAggLoadOfLValue(const Expr *E);
  76
  77   /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
  78   void EmitFinalDestCopy(QualType type, const LValue &src);
  79   void EmitFinalDestCopy(QualType type, RValue src,
  80                          CharUnits srcAlignment = CharUnits::Zero());
  81   void EmitCopy(QualType type, const AggValueSlot &dest,
  82                 const AggValueSlot &src);
  83
  84   void EmitMoveFromReturnSlot(const Expr *E, RValue Src);
  85
  86   void EmitStdInitializerList(llvm::Value *DestPtr, InitListExpr *InitList);
  87   void EmitArrayInit(llvm::Value *DestPtr, llvm::ArrayType *AType,
  88                      QualType elementType, InitListExpr *E);
  89
  90   AggValueSlot::NeedsGCBarriers_t needsGC(QualType T) {
  91     if (CGF.getLangOpts().getGC() && TypeRequiresGCollection(T))
  92       return AggValueSlot::NeedsGCBarriers;
  93     return AggValueSlot::DoesNotNeedGCBarriers;
  94   }
  95
  96   bool TypeRequiresGCollection(QualType T);
  97
  98   //===--------------------------------------------------------------------===//
  99   //                            Visitor Methods
 100   //===--------------------------------------------------------------------===//
 101
 102   void VisitStmt(Stmt *S) {
 103     CGF.ErrorUnsupported(S, "aggregate expression");
 104   }
 105   void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); }
 106   void VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
 107     Visit(GE->getResultExpr());
 108   }
 109   void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
 110   void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
 111     return Visit(E->getReplacement());
 112   }
 113
 114   // l-values.
 115   void VisitDeclRefExpr(DeclRefExpr *E) {
 116     // For aggregates, we should always be able to emit the variable
 117     // as an l-value unless it's a reference.  This is due to the fact
 118     // that we can't actually ever see a normal l2r conversion on an
 119     // aggregate in C++, and in C there's no language standard
 120     // actively preventing us from listing variables in the captures
 121     // list of a block.
 122     if (E->getDecl()->getType()->isReferenceType()) {
 123       if (CodeGenFunction::ConstantEmission result
 124             = CGF.tryEmitAsConstant(E)) {
 125         EmitFinalDestCopy(E->getType(), result.getReferenceLValue(CGF, E));
 126         return;
 127       }
 128     }
 129
 130     EmitAggLoadOfLValue(E);
 131   }
 132
 133   void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
 134   void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
 135   void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
 136   void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
 137   void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
 138     EmitAggLoadOfLValue(E);
 139   }
 140   void VisitPredefinedExpr(const PredefinedExpr *E) {
 141     EmitAggLoadOfLValue(E);
 142   }
 143
 144   // Operators.
 145   void VisitCastExpr(CastExpr *E);
 146   void VisitCallExpr(const CallExpr *E);
 147   void VisitStmtExpr(const StmtExpr *E);
 148   void VisitBinaryOperator(const BinaryOperator *BO);
 149   void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO);
 150   void VisitBinAssign(const BinaryOperator *E);
 151   void VisitBinComma(const BinaryOperator *E);
 152
 153   void VisitObjCMessageExpr(ObjCMessageExpr *E);
 154   void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
 155     EmitAggLoadOfLValue(E);
 156   }
 157
 158   void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
 159   void VisitChooseExpr(const ChooseExpr *CE);
 160   void VisitInitListExpr(InitListExpr *E);
 161   void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
 162   void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
 163     Visit(DAE->getExpr());
 164   }
 165   void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
 166   void VisitCXXConstructExpr(const CXXConstructExpr *E);
 167   void VisitLambdaExpr(LambdaExpr *E);
 168   void VisitExprWithCleanups(ExprWithCleanups *E);
 169   void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
 170   void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
 171   void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
 172   void VisitOpaqueValueExpr(OpaqueValueExpr *E);
 173
 174   void VisitPseudoObjectExpr(PseudoObjectExpr *E) {
 175     if (E->isGLValue()) {
 176       LValue LV = CGF.EmitPseudoObjectLValue(E);
 177       return EmitFinalDestCopy(E->getType(), LV);
 178     }
 179
 180     CGF.EmitPseudoObjectRValue(E, EnsureSlot(E->getType()));
 181   }
 182
 183   void VisitVAArgExpr(VAArgExpr *E);
 184
 185   void EmitInitializationToLValue(Expr *E, LValue Address);
 186   void EmitNullInitializationToLValue(LValue Address);
 187   //  case Expr::ChooseExprClass:
 188   void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
 189   void VisitAtomicExpr(AtomicExpr *E) {
 190     CGF.EmitAtomicExpr(E, EnsureSlot(E->getType()).getAddr());
 191   }
 192 };
 193 }  // end anonymous namespace.
 194
 195 //===----------------------------------------------------------------------===//
 196 //                                Utilities
 197 //===----------------------------------------------------------------------===//
 198
 199 /// EmitAggLoadOfLValue - Given an expression with aggregate type that
 200 /// represents a value lvalue, this method emits the address of the lvalue,
 201 /// then loads the result into DestPtr.
 202 void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
 203   LValue LV = CGF.EmitLValue(E);
 204   EmitFinalDestCopy(E->getType(), LV);
 205 }
 206
 207 /// \brief True if the given aggregate type requires special GC API calls.
 208 bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
 209   // Only record types have members that might require garbage collection.
 210   const RecordType *RecordTy = T->getAs<RecordType>();
 211   if (!RecordTy) return false;
 212
 213   // Don't mess with non-trivial C++ types.
 214   RecordDecl *Record = RecordTy->getDecl();
 215   if (isa<CXXRecordDecl>(Record) &&
 216       (!cast<CXXRecordDecl>(Record)->hasTrivialCopyConstructor() ||
 217        !cast<CXXRecordDecl>(Record)->hasTrivialDestructor()))
 218     return false;
 219
 220   // Check whether the type has an object member.
 221   return Record->hasObjectMember();
 222 }
 223
 224 /// \brief Perform the final move to DestPtr if for some reason
 225 /// getReturnValueSlot() didn't use it directly.
 226 ///
 227 /// The idea is that you do something like this:
 228 ///   RValue Result = EmitSomething(..., getReturnValueSlot());
 229 ///   EmitMoveFromReturnSlot(E, Result);
 230 ///
 231 /// If nothing interferes, this will cause the result to be emitted
 232 /// directly into the return value slot.  Otherwise, a final move
 233 /// will be performed.
 234 void AggExprEmitter::EmitMoveFromReturnSlot(const Expr *E, RValue src) {
 235   if (shouldUseDestForReturnSlot()) {
 236     // Logically, Dest.getAddr() should equal Src.getAggregateAddr().
 237     // The possibility of undef rvalues complicates that a lot,
 238     // though, so we can't really assert.
 239     return;
 240   }
 241
 242   // Otherwise, copy from there to the destination.
 243   assert(Dest.getAddr() != src.getAggregateAddr());
 244   std::pair<CharUnits, CharUnits> typeInfo =
 245     CGF.getContext().getTypeInfoInChars(E->getType());
 246   EmitFinalDestCopy(E->getType(), src, typeInfo.second);
 247 }
 248
 249 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
 250 void AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src,
 251                                        CharUnits srcAlign) {
 252   assert(src.isAggregate() && "value must be aggregate value!");
 253   LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddr(), type, srcAlign);
 254   EmitFinalDestCopy(type, srcLV);
 255 }
 256
 257 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
 258 void AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src) {
 259   // If Dest is ignored, then we're evaluating an aggregate expression
 260   // in a context that doesn't care about the result.  Note that loads
 261   // from volatile l-values force the existence of a non-ignored
 262   // destination.
 263   if (Dest.isIgnored())
 264     return;
 265
 266   AggValueSlot srcAgg =
 267     AggValueSlot::forLValue(src, AggValueSlot::IsDestructed,
 268                             needsGC(type), AggValueSlot::IsAliased);
 269   EmitCopy(type, Dest, srcAgg);
 270 }
 271
 272 /// Perform a copy from the source into the destination.
 273 ///
 274 /// \param type - the type of the aggregate being copied; qualifiers are
 275 ///   ignored
 276 void AggExprEmitter::EmitCopy(QualType type, const AggValueSlot &dest,
 277                               const AggValueSlot &src) {
 278   if (dest.requiresGCollection()) {
 279     CharUnits sz = CGF.getContext().getTypeSizeInChars(type);
 280     llvm::Value *size = llvm::ConstantInt::get(CGF.SizeTy, sz.getQuantity());
 281     CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF,
 282                                                       dest.getAddr(),
 283                                                       src.getAddr(),
 284                                                       size);
 285     return;
 286   }
 287
 288   // If the result of the assignment is used, copy the LHS there also.
 289   // It's volatile if either side is.  Use the minimum alignment of
 290   // the two sides.
 291   CGF.EmitAggregateCopy(dest.getAddr(), src.getAddr(), type,
 292                         dest.isVolatile() || src.isVolatile(),
 293                         std::min(dest.getAlignment(), src.getAlignment()));
 294 }
 295
 296 static QualType GetStdInitializerListElementType(QualType T) {
 297   // Just assume that this is really std::initializer_list.
 298   ClassTemplateSpecializationDecl *specialization =
 299       cast<ClassTemplateSpecializationDecl>(T->castAs<RecordType>()->getDecl());
 300   return specialization->getTemplateArgs()[0].getAsType();
 301 }
 302
 303 /// \brief Prepare cleanup for the temporary array.
 304 static void EmitStdInitializerListCleanup(CodeGenFunction &CGF,
 305                                           QualType arrayType,
 306                                           llvm::Value *addr,
 307                                           const InitListExpr *initList) {
 308   QualType::DestructionKind dtorKind = arrayType.isDestructedType();
 309   if (!dtorKind)
 310     return; // Type doesn't need destroying.
 311   if (dtorKind != QualType::DK_cxx_destructor) {
 312     CGF.ErrorUnsupported(initList, "ObjC ARC type in initializer_list");
 313     return;
 314   }
 315
 316   CodeGenFunction::Destroyer *destroyer = CGF.getDestroyer(dtorKind);
 317   CGF.pushDestroy(NormalAndEHCleanup, addr, arrayType, destroyer,
 318                   /*EHCleanup=*/true);
 319 }
 320
 321 /// \brief Emit the initializer for a std::initializer_list initialized with a
 322 /// real initializer list.
 323 void AggExprEmitter::EmitStdInitializerList(llvm::Value *destPtr,
 324                                             InitListExpr *initList) {
 325   // We emit an array containing the elements, then have the init list point
 326   // at the array.
 327   ASTContext &ctx = CGF.getContext();
 328   unsigned numInits = initList->getNumInits();
 329   QualType element = GetStdInitializerListElementType(initList->getType());
 330   llvm::APInt size(ctx.getTypeSize(ctx.getSizeType()), numInits);
 331   QualType array = ctx.getConstantArrayType(element, size, ArrayType::Normal,0);
 332   llvm::Type *LTy = CGF.ConvertTypeForMem(array);
 333   llvm::AllocaInst *alloc = CGF.CreateTempAlloca(LTy);
 334   alloc->setAlignment(ctx.getTypeAlignInChars(array).getQuantity());
 335   alloc->setName(".initlist.");
 336
 337   EmitArrayInit(alloc, cast<llvm::ArrayType>(LTy), element, initList);
 338
 339   // FIXME: The diagnostics are somewhat out of place here.
 340   RecordDecl *record = initList->getType()->castAs<RecordType>()->getDecl();
 341   RecordDecl::field_iterator field = record->field_begin();
 342   if (field == record->field_end()) {
 343     CGF.ErrorUnsupported(initList, "weird std::initializer_list");
 344     return;
 345   }
 346
 347   QualType elementPtr = ctx.getPointerType(element.withConst());
 348
 349   // Start pointer.
 350   if (!ctx.hasSameType(field->getType(), elementPtr)) {
 351     CGF.ErrorUnsupported(initList, "weird std::initializer_list");
 352     return;
 353   }
 354   LValue DestLV = CGF.MakeNaturalAlignAddrLValue(destPtr, initList->getType());
 355   LValue start = CGF.EmitLValueForFieldInitialization(DestLV, *field);
 356   llvm::Value *arrayStart = Builder.CreateStructGEP(alloc, 0, "arraystart");
 357   CGF.EmitStoreThroughLValue(RValue::get(arrayStart), start);
 358   ++field;
 359
 360   if (field == record->field_end()) {
 361     CGF.ErrorUnsupported(initList, "weird std::initializer_list");
 362     return;
 363   }
 364   LValue endOrLength = CGF.EmitLValueForFieldInitialization(DestLV, *field);
 365   if (ctx.hasSameType(field->getType(), elementPtr)) {
 366     // End pointer.
 367     llvm::Value *arrayEnd = Builder.CreateStructGEP(alloc,numInits, "arrayend");
 368     CGF.EmitStoreThroughLValue(RValue::get(arrayEnd), endOrLength);
 369   } else if(ctx.hasSameType(field->getType(), ctx.getSizeType())) {
 370     // Length.
 371     CGF.EmitStoreThroughLValue(RValue::get(Builder.getInt(size)), endOrLength);
 372   } else {
 373     CGF.ErrorUnsupported(initList, "weird std::initializer_list");
 374     return;
 375   }
 376
 377   if (!Dest.isExternallyDestructed())
 378     EmitStdInitializerListCleanup(CGF, array, alloc, initList);
 379 }
 380
 381 /// \brief Emit initialization of an array from an initializer list.
 382 void AggExprEmitter::EmitArrayInit(llvm::Value *DestPtr, llvm::ArrayType *AType,
 383                                    QualType elementType, InitListExpr *E) {
 384   uint64_t NumInitElements = E->getNumInits();
 385
 386   uint64_t NumArrayElements = AType->getNumElements();
 387   assert(NumInitElements <= NumArrayElements);
 388
 389   // DestPtr is an array*.  Construct an elementType* by drilling
 390   // down a level.
 391   llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
 392   llvm::Value *indices[] = { zero, zero };
 393   llvm::Value *begin =
 394     Builder.CreateInBoundsGEP(DestPtr, indices, "arrayinit.begin");
 395
 396   // Exception safety requires us to destroy all the
 397   // already-constructed members if an initializer throws.
 398   // For that, we'll need an EH cleanup.
 399   QualType::DestructionKind dtorKind = elementType.isDestructedType();
 400   llvm::AllocaInst *endOfInit = 0;
 401   EHScopeStack::stable_iterator cleanup;
 402   llvm::Instruction *cleanupDominator = 0;
 403   if (CGF.needsEHCleanup(dtorKind)) {
 404     // In principle we could tell the cleanup where we are more
 405     // directly, but the control flow can get so varied here that it
 406     // would actually be quite complex.  Therefore we go through an
 407     // alloca.
 408     endOfInit = CGF.CreateTempAlloca(begin->getType(),
 409                                      "arrayinit.endOfInit");
 410     cleanupDominator = Builder.CreateStore(begin, endOfInit);
 411     CGF.pushIrregularPartialArrayCleanup(begin, endOfInit, elementType,
 412                                          CGF.getDestroyer(dtorKind));
 413     cleanup = CGF.EHStack.stable_begin();
 414
 415   // Otherwise, remember that we didn't need a cleanup.
 416   } else {
 417     dtorKind = QualType::DK_none;
 418   }
 419
 420   llvm::Value *one = llvm::ConstantInt::get(CGF.SizeTy, 1);
 421
 422   // The 'current element to initialize'.  The invariants on this
 423   // variable are complicated.  Essentially, after each iteration of
 424   // the loop, it points to the last initialized element, except
 425   // that it points to the beginning of the array before any
 426   // elements have been initialized.
 427   llvm::Value *element = begin;
 428
 429   // Emit the explicit initializers.
 430   for (uint64_t i = 0; i != NumInitElements; ++i) {
 431     // Advance to the next element.
 432     if (i > 0) {
 433       element = Builder.CreateInBoundsGEP(element, one, "arrayinit.element");
 434
 435       // Tell the cleanup that it needs to destroy up to this
 436       // element.  TODO: some of these stores can be trivially
 437       // observed to be unnecessary.
 438       if (endOfInit) Builder.CreateStore(element, endOfInit);
 439     }
 440
 441     // If these are nested std::initializer_list inits, do them directly,
 442     // because they are conceptually the same "location".
 443     InitListExpr *initList = dyn_cast<InitListExpr>(E->getInit(i));
 444     if (initList && initList->initializesStdInitializerList()) {
 445       EmitStdInitializerList(element, initList);
 446     } else {
 447       LValue elementLV = CGF.MakeAddrLValue(element, elementType);
 448       EmitInitializationToLValue(E->getInit(i), elementLV);
 449     }
 450   }
 451
 452   // Check whether there's a non-trivial array-fill expression.
 453   // Note that this will be a CXXConstructExpr even if the element
 454   // type is an array (or array of array, etc.) of class type.
 455   Expr *filler = E->getArrayFiller();
 456   bool hasTrivialFiller = true;
 457   if (CXXConstructExpr *cons = dyn_cast_or_null<CXXConstructExpr>(filler)) {
 458     assert(cons->getConstructor()->isDefaultConstructor());
 459     hasTrivialFiller = cons->getConstructor()->isTrivial();
 460   }
 461
 462   // Any remaining elements need to be zero-initialized, possibly
 463   // using the filler expression.  We can skip this if the we're
 464   // emitting to zeroed memory.
 465   if (NumInitElements != NumArrayElements &&
 466       !(Dest.isZeroed() && hasTrivialFiller &&
 467         CGF.getTypes().isZeroInitializable(elementType))) {
 468
 469     // Use an actual loop.  This is basically
 470     //   do { *array++ = filler; } while (array != end);
 471
 472     // Advance to the start of the rest of the array.
 473     if (NumInitElements) {
 474       element = Builder.CreateInBoundsGEP(element, one, "arrayinit.start");
 475       if (endOfInit) Builder.CreateStore(element, endOfInit);
 476     }
 477
 478     // Compute the end of the array.
 479     llvm::Value *end = Builder.CreateInBoundsGEP(begin,
 480                       llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements),
 481                                                  "arrayinit.end");
 482
 483     llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
 484     llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body");
 485
 486     // Jump into the body.
 487     CGF.EmitBlock(bodyBB);
 488     llvm::PHINode *currentElement =
 489       Builder.CreatePHI(element->getType(), 2, "arrayinit.cur");
 490     currentElement->addIncoming(element, entryBB);
 491
 492     // Emit the actual filler expression.
 493     LValue elementLV = CGF.MakeAddrLValue(currentElement, elementType);
 494     if (filler)
 495       EmitInitializationToLValue(filler, elementLV);
 496     else
 497       EmitNullInitializationToLValue(elementLV);
 498
 499     // Move on to the next element.
 500     llvm::Value *nextElement =
 501       Builder.CreateInBoundsGEP(currentElement, one, "arrayinit.next");
 502
 503     // Tell the EH cleanup that we finished with the last element.
 504     if (endOfInit) Builder.CreateStore(nextElement, endOfInit);
 505
 506     // Leave the loop if we're done.
 507     llvm::Value *done = Builder.CreateICmpEQ(nextElement, end,
 508                                              "arrayinit.done");
 509     llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end");
 510     Builder.CreateCondBr(done, endBB, bodyBB);
 511     currentElement->addIncoming(nextElement, Builder.GetInsertBlock());
 512
 513     CGF.EmitBlock(endBB);
 514   }
 515
 516   // Leave the partial-array cleanup if we entered one.
 517   if (dtorKind) CGF.DeactivateCleanupBlock(cleanup, cleanupDominator);
 518 }
 519
 520 //===----------------------------------------------------------------------===//
 521 //                            Visitor Methods
 522 //===----------------------------------------------------------------------===//
 523
 524 void AggExprEmitter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E){
 525   Visit(E->GetTemporaryExpr());
 526 }
 527
 528 void AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) {
 529   EmitFinalDestCopy(e->getType(), CGF.getOpaqueLValueMapping(e));
 530 }
 531
 532 void
 533 AggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
 534   if (E->getType().isPODType(CGF.getContext())) {
 535     // For a POD type, just emit a load of the lvalue + a copy, because our
 536     // compound literal might alias the destination.
 537     // FIXME: This is a band-aid; the real problem appears to be in our handling
 538     // of assignments, where we store directly into the LHS without checking
 539     // whether anything in the RHS aliases.
 540     EmitAggLoadOfLValue(E);
 541     return;
 542   }
 543
 544   AggValueSlot Slot = EnsureSlot(E->getType());
 545   CGF.EmitAggExpr(E->getInitializer(), Slot);
 546 }
 547
 548
 549 void AggExprEmitter::VisitCastExpr(CastExpr *E) {
 550   switch (E->getCastKind()) {
 551   case CK_Dynamic: {
 552     // FIXME: Can this actually happen? We have no test coverage for it.
 553     assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?");
 554     LValue LV = CGF.EmitCheckedLValue(E->getSubExpr(),
 555                                       CodeGenFunction::TCK_Load);
 556     // FIXME: Do we also need to handle property references here?
 557     if (LV.isSimple())
 558       CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E));
 559     else
 560       CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast");
 561
 562     if (!Dest.isIgnored())
 563       CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination");
 564     break;
 565   }
 566
 567   case CK_ToUnion: {
 568     if (Dest.isIgnored()) break;
 569
 570     // GCC union extension
 571     QualType Ty = E->getSubExpr()->getType();
 572     QualType PtrTy = CGF.getContext().getPointerType(Ty);
 573     llvm::Value *CastPtr = Builder.CreateBitCast(Dest.getAddr(),
 574                                                  CGF.ConvertType(PtrTy));
 575     EmitInitializationToLValue(E->getSubExpr(),
 576                                CGF.MakeAddrLValue(CastPtr, Ty));
 577     break;
 578   }
 579
 580   case CK_DerivedToBase:
 581   case CK_BaseToDerived:
 582   case CK_UncheckedDerivedToBase: {
 583     llvm_unreachable("cannot perform hierarchy conversion in EmitAggExpr: "
 584                 "should have been unpacked before we got here");
 585   }
 586
 587   case CK_LValueToRValue:
 588     // If we're loading from a volatile type, force the destination
 589     // into existence.
 590     if (E->getSubExpr()->getType().isVolatileQualified()) {
 591       EnsureDest(E->getType());
 592       return Visit(E->getSubExpr());
 593     }
 594     // fallthrough
 595
 596   case CK_NoOp:
 597   case CK_AtomicToNonAtomic:
 598   case CK_NonAtomicToAtomic:
 599   case CK_UserDefinedConversion:
 600   case CK_ConstructorConversion:
 601     assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(),
 602                                                    E->getType()) &&
 603            "Implicit cast types must be compatible");
 604     Visit(E->getSubExpr());
 605     break;
 606
 607   case CK_LValueBitCast:
 608     llvm_unreachable("should not be emitting lvalue bitcast as rvalue");
 609
 610   case CK_Dependent:
 611   case CK_BitCast:
 612   case CK_ArrayToPointerDecay:
 613   case CK_FunctionToPointerDecay:
 614   case CK_NullToPointer:
 615   case CK_NullToMemberPointer:
 616   case CK_BaseToDerivedMemberPointer:
 617   case CK_DerivedToBaseMemberPointer:
 618   case CK_MemberPointerToBoolean:
 619   case CK_ReinterpretMemberPointer:
 620   case CK_IntegralToPointer:
 621   case CK_PointerToIntegral:
 622   case CK_PointerToBoolean:
 623   case CK_ToVoid:
 624   case CK_VectorSplat:
 625   case CK_IntegralCast:
 626   case CK_IntegralToBoolean:
 627   case CK_IntegralToFloating:
 628   case CK_FloatingToIntegral:
 629   case CK_FloatingToBoolean:
 630   case CK_FloatingCast:
 631   case CK_CPointerToObjCPointerCast:
 632   case CK_BlockPointerToObjCPointerCast:
 633   case CK_AnyPointerToBlockPointerCast:
 634   case CK_ObjCObjectLValueCast:
 635   case CK_FloatingRealToComplex:
 636   case CK_FloatingComplexToReal:
 637   case CK_FloatingComplexToBoolean:
 638   case CK_FloatingComplexCast:
 639   case CK_FloatingComplexToIntegralComplex:
 640   case CK_IntegralRealToComplex:
 641   case CK_IntegralComplexToReal:
 642   case CK_IntegralComplexToBoolean:
 643   case CK_IntegralComplexCast:
 644   case CK_IntegralComplexToFloatingComplex:
 645   case CK_ARCProduceObject:
 646   case CK_ARCConsumeObject:
 647   case CK_ARCReclaimReturnedObject:
 648   case CK_ARCExtendBlockObject:
 649   case CK_CopyAndAutoreleaseBlockObject:
 650   case CK_BuiltinFnToFnPtr:
 651     llvm_unreachable("cast kind invalid for aggregate types");
 652   }
 653 }
 654
 655 void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
 656   if (E->getCallReturnType()->isReferenceType()) {
 657     EmitAggLoadOfLValue(E);
 658     return;
 659   }
 660
 661   RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot());
 662   EmitMoveFromReturnSlot(E, RV);
 663 }
 664
 665 void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
 666   RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot());
 667   EmitMoveFromReturnSlot(E, RV);
 668 }
 669
 670 void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
 671   CGF.EmitIgnoredExpr(E->getLHS());
 672   Visit(E->getRHS());
 673 }
 674
 675 void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
 676   CodeGenFunction::StmtExprEvaluation eval(CGF);
 677   CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
 678 }
 679
 680 void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
 681   if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
 682     VisitPointerToDataMemberBinaryOperator(E);
 683   else
 684     CGF.ErrorUnsupported(E, "aggregate binary expression");
 685 }
 686
 687 void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
 688                                                     const BinaryOperator *E) {
 689   LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E);
 690   EmitFinalDestCopy(E->getType(), LV);
 691 }
 692
 693 /// Is the value of the given expression possibly a reference to or
 694 /// into a __block variable?
 695 static bool isBlockVarRef(const Expr *E) {
 696   // Make sure we look through parens.
 697   E = E->IgnoreParens();
 698
 699   // Check for a direct reference to a __block variable.
 700   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
 701     const VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl());
 702     return (var && var->hasAttr<BlocksAttr>());
 703   }
 704
 705   // More complicated stuff.
 706
 707   // Binary operators.
 708   if (const BinaryOperator *op = dyn_cast<BinaryOperator>(E)) {
 709     // For an assignment or pointer-to-member operation, just care
 710     // about the LHS.
 711     if (op->isAssignmentOp() || op->isPtrMemOp())
 712       return isBlockVarRef(op->getLHS());
 713
 714     // For a comma, just care about the RHS.
 715     if (op->getOpcode() == BO_Comma)
 716       return isBlockVarRef(op->getRHS());
 717
 718     // FIXME: pointer arithmetic?
 719     return false;
 720
 721   // Check both sides of a conditional operator.
 722   } else if (const AbstractConditionalOperator *op
 723                = dyn_cast<AbstractConditionalOperator>(E)) {
 724     return isBlockVarRef(op->getTrueExpr())
 725         || isBlockVarRef(op->getFalseExpr());
 726
 727   // OVEs are required to support BinaryConditionalOperators.
 728   } else if (const OpaqueValueExpr *op
 729                = dyn_cast<OpaqueValueExpr>(E)) {
 730     if (const Expr *src = op->getSourceExpr())
 731       return isBlockVarRef(src);
 732
 733   // Casts are necessary to get things like (*(int*)&var) = foo().
 734   // We don't really care about the kind of cast here, except
 735   // we don't want to look through l2r casts, because it's okay
 736   // to get the *value* in a __block variable.
 737   } else if (const CastExpr *cast = dyn_cast<CastExpr>(E)) {
 738     if (cast->getCastKind() == CK_LValueToRValue)
 739       return false;
 740     return isBlockVarRef(cast->getSubExpr());
 741
 742   // Handle unary operators.  Again, just aggressively look through
 743   // it, ignoring the operation.
 744   } else if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E)) {
 745     return isBlockVarRef(uop->getSubExpr());
 746
 747   // Look into the base of a field access.
 748   } else if (const MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
 749     return isBlockVarRef(mem->getBase());
 750
 751   // Look into the base of a subscript.
 752   } else if (const ArraySubscriptExpr *sub = dyn_cast<ArraySubscriptExpr>(E)) {
 753     return isBlockVarRef(sub->getBase());
 754   }
 755
 756   return false;
 757 }
 758
 759 void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
 760   // For an assignment to work, the value on the right has
 761   // to be compatible with the value on the left.
 762   assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
 763                                                  E->getRHS()->getType())
 764          && "Invalid assignment");
 765
 766   // If the LHS might be a __block variable, and the RHS can
 767   // potentially cause a block copy, we need to evaluate the RHS first
 768   // so that the assignment goes the right place.
 769   // This is pretty semantically fragile.
 770   if (isBlockVarRef(E->getLHS()) &&
 771       E->getRHS()->HasSideEffects(CGF.getContext())) {
 772     // Ensure that we have a destination, and evaluate the RHS into that.
 773     EnsureDest(E->getRHS()->getType());
 774     Visit(E->getRHS());
 775
 776     // Now emit the LHS and copy into it.
 777     LValue LHS = CGF.EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
 778
 779     EmitCopy(E->getLHS()->getType(),
 780              AggValueSlot::forLValue(LHS, AggValueSlot::IsDestructed,
 781                                      needsGC(E->getLHS()->getType()),
 782                                      AggValueSlot::IsAliased),
 783              Dest);
 784     return;
 785   }
 786
 787   LValue LHS = CGF.EmitLValue(E->getLHS());
 788
 789   // Codegen the RHS so that it stores directly into the LHS.
 790   AggValueSlot LHSSlot =
 791     AggValueSlot::forLValue(LHS, AggValueSlot::IsDestructed,
 792                             needsGC(E->getLHS()->getType()),
 793                             AggValueSlot::IsAliased);
 794   CGF.EmitAggExpr(E->getRHS(), LHSSlot);
 795
 796   // Copy into the destination if the assignment isn't ignored.
 797   EmitFinalDestCopy(E->getType(), LHS);
 798 }
 799
 800 void AggExprEmitter::
 801 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
 802   llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
 803   llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
 804   llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
 805
 806   // Bind the common expression if necessary.
 807   CodeGenFunction::OpaqueValueMapping binding(CGF, E);
 808
 809   CodeGenFunction::ConditionalEvaluation eval(CGF);
 810   CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
 811
 812   // Save whether the destination's lifetime is externally managed.
 813   bool isExternallyDestructed = Dest.isExternallyDestructed();
 814
 815   eval.begin(CGF);
 816   CGF.EmitBlock(LHSBlock);
 817   Visit(E->getTrueExpr());
 818   eval.end(CGF);
 819
 820   assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!");
 821   CGF.Builder.CreateBr(ContBlock);
 822
 823   // If the result of an agg expression is unused, then the emission
 824   // of the LHS might need to create a destination slot.  That's fine
 825   // with us, and we can safely emit the RHS into the same slot, but
 826   // we shouldn't claim that it's already being destructed.
 827   Dest.setExternallyDestructed(isExternallyDestructed);
 828
 829   eval.begin(CGF);
 830   CGF.EmitBlock(RHSBlock);
 831   Visit(E->getFalseExpr());
 832   eval.end(CGF);
 833
 834   CGF.EmitBlock(ContBlock);
 835 }
 836
 837 void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) {
 838   Visit(CE->getChosenSubExpr(CGF.getContext()));
 839 }
 840
 841 void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
 842   llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
 843   llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
 844
 845   if (!ArgPtr) {
 846     CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
 847     return;
 848   }
 849
 850   EmitFinalDestCopy(VE->getType(), CGF.MakeAddrLValue(ArgPtr, VE->getType()));
 851 }
 852
 853 void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
 854   // Ensure that we have a slot, but if we already do, remember
 855   // whether it was externally destructed.
 856   bool wasExternallyDestructed = Dest.isExternallyDestructed();
 857   EnsureDest(E->getType());
 858
 859   // We're going to push a destructor if there isn't already one.
 860   Dest.setExternallyDestructed();
 861
 862   Visit(E->getSubExpr());
 863
 864   // Push that destructor we promised.
 865   if (!wasExternallyDestructed)
 866     CGF.EmitCXXTemporary(E->getTemporary(), E->getType(), Dest.getAddr());
 867 }
 868
 869 void
 870 AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
 871   AggValueSlot Slot = EnsureSlot(E->getType());
 872   CGF.EmitCXXConstructExpr(E, Slot);
 873 }
 874
 875 void
 876 AggExprEmitter::VisitLambdaExpr(LambdaExpr *E) {
 877   AggValueSlot Slot = EnsureSlot(E->getType());
 878   CGF.EmitLambdaExpr(E, Slot);
 879 }
 880
 881 void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
 882   CGF.enterFullExpression(E);
 883   CodeGenFunction::RunCleanupsScope cleanups(CGF);
 884   Visit(E->getSubExpr());
 885 }
 886
 887 void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
 888   QualType T = E->getType();
 889   AggValueSlot Slot = EnsureSlot(T);
 890   EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T));
 891 }
 892
 893 void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
 894   QualType T = E->getType();
 895   AggValueSlot Slot = EnsureSlot(T);
 896   EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T));
 897 }
 898
 899 /// isSimpleZero - If emitting this value will obviously just cause a store of
 900 /// zero to memory, return true.  This can return false if uncertain, so it just
 901 /// handles simple cases.
 902 static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
 903   E = E->IgnoreParens();
 904
 905   // 0
 906   if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
 907     return IL->getValue() == 0;
 908   // +0.0
 909   if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
 910     return FL->getValue().isPosZero();
 911   // int()
 912   if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
 913       CGF.getTypes().isZeroInitializable(E->getType()))
 914     return true;
 915   // (int*)0 - Null pointer expressions.
 916   if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
 917     return ICE->getCastKind() == CK_NullToPointer;
 918   // '\0'
 919   if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
 920     return CL->getValue() == 0;
 921
 922   // Otherwise, hard case: conservatively return false.
 923   return false;
 924 }
 925
 926
 927 void
 928 AggExprEmitter::EmitInitializationToLValue(Expr* E, LValue LV) {
 929   QualType type = LV.getType();
 930   // FIXME: Ignore result?
 931   // FIXME: Are initializers affected by volatile?
 932   if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
 933     // Storing "i32 0" to a zero'd memory location is a noop.
 934   } else if (isa<ImplicitValueInitExpr>(E)) {
 935     EmitNullInitializationToLValue(LV);
 936   } else if (type->isReferenceType()) {
 937     RValue RV = CGF.EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
 938     CGF.EmitStoreThroughLValue(RV, LV);
 939   } else if (type->isAnyComplexType()) {
 940     CGF.EmitComplexExprIntoAddr(E, LV.getAddress(), false);
 941   } else if (CGF.hasAggregateLLVMType(type)) {
 942     CGF.EmitAggExpr(E, AggValueSlot::forLValue(LV,
 943                                                AggValueSlot::IsDestructed,
 944                                       AggValueSlot::DoesNotNeedGCBarriers,
 945                                                AggValueSlot::IsNotAliased,
 946                                                Dest.isZeroed()));
 947   } else if (LV.isSimple()) {
 948     CGF.EmitScalarInit(E, /*D=*/0, LV, /*Captured=*/false);
 949   } else {
 950     CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV);
 951   }
 952 }
 953
 954 void AggExprEmitter::EmitNullInitializationToLValue(LValue lv) {
 955   QualType type = lv.getType();
 956
 957   // If the destination slot is already zeroed out before the aggregate is
 958   // copied into it, we don't have to emit any zeros here.
 959   if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(type))
 960     return;
 961
 962   if (!CGF.hasAggregateLLVMType(type)) {
 963     // For non-aggregates, we can store zero.
 964     llvm::Value *null = llvm::Constant::getNullValue(CGF.ConvertType(type));
 965     // Note that the following is not equivalent to
 966     // EmitStoreThroughBitfieldLValue for ARC types.
 967     if (lv.isBitField()) {
 968       CGF.EmitStoreThroughBitfieldLValue(RValue::get(null), lv);
 969     } else {
 970       assert(lv.isSimple());
 971       CGF.EmitStoreOfScalar(null, lv, /* isInitialization */ true);
 972     }
 973   } else {
 974     // There's a potential optimization opportunity in combining
 975     // memsets; that would be easy for arrays, but relatively
 976     // difficult for structures with the current code.
 977     CGF.EmitNullInitialization(lv.getAddress(), lv.getType());
 978   }
 979 }
 980
 981 void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
 982 #if 0
 983   // FIXME: Assess perf here?  Figure out what cases are worth optimizing here
 984   // (Length of globals? Chunks of zeroed-out space?).
 985   //
 986   // If we can, prefer a copy from a global; this is a lot less code for long
 987   // globals, and it's easier for the current optimizers to analyze.
 988   if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) {
 989     llvm::GlobalVariable* GV =
 990     new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true,
 991                              llvm::GlobalValue::InternalLinkage, C, "");
 992     EmitFinalDestCopy(E->getType(), CGF.MakeAddrLValue(GV, E->getType()));
 993     return;
 994   }
 995 #endif
 996   if (E->hadArrayRangeDesignator())
 997     CGF.ErrorUnsupported(E, "GNU array range designator extension");
 998
 999   if (E->initializesStdInitializerList()) {
1000     EmitStdInitializerList(Dest.getAddr(), E);
1001     return;
1002   }
1003
1004   AggValueSlot Dest = EnsureSlot(E->getType());
1005   LValue DestLV = CGF.MakeAddrLValue(Dest.getAddr(), E->getType(),
1006                                      Dest.getAlignment());
1007
1008   // Handle initialization of an array.
1009   if (E->getType()->isArrayType()) {
1010     if (E->isStringLiteralInit())
1011       return Visit(E->getInit(0));
1012
1013     QualType elementType =
1014         CGF.getContext().getAsArrayType(E->getType())->getElementType();
1015
1016     llvm::PointerType *APType =
1017       cast<llvm::PointerType>(Dest.getAddr()->getType());
1018     llvm::ArrayType *AType =
1019       cast<llvm::ArrayType>(APType->getElementType());
1020
1021     EmitArrayInit(Dest.getAddr(), AType, elementType, E);
1022     return;
1023   }
1024
1025   assert(E->getType()->isRecordType() && "Only support structs/unions here!");
1026
1027   // Do struct initialization; this code just sets each individual member
1028   // to the approprate value.  This makes bitfield support automatic;
1029   // the disadvantage is that the generated code is more difficult for
1030   // the optimizer, especially with bitfields.
1031   unsigned NumInitElements = E->getNumInits();
1032   RecordDecl *record = E->getType()->castAs<RecordType>()->getDecl();
1033
1034   if (record->isUnion()) {
1035     // Only initialize one field of a union. The field itself is
1036     // specified by the initializer list.
1037     if (!E->getInitializedFieldInUnion()) {
1038       // Empty union; we have nothing to do.
1039
1040 #ifndef NDEBUG
1041       // Make sure that it's really an empty and not a failure of
1042       // semantic analysis.
1043       for (RecordDecl::field_iterator Field = record->field_begin(),
1044                                    FieldEnd = record->field_end();
1045            Field != FieldEnd; ++Field)
1046         assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
1047 #endif
1048       return;
1049     }
1050
1051     // FIXME: volatility
1052     FieldDecl *Field = E->getInitializedFieldInUnion();
1053
1054     LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestLV, Field);
1055     if (NumInitElements) {
1056       // Store the initializer into the field
1057       EmitInitializationToLValue(E->getInit(0), FieldLoc);
1058     } else {
1059       // Default-initialize to null.
1060       EmitNullInitializationToLValue(FieldLoc);
1061     }
1062
1063     return;
1064   }
1065
1066   // We'll need to enter cleanup scopes in case any of the member
1067   // initializers throw an exception.
1068   SmallVector<EHScopeStack::stable_iterator, 16> cleanups;
1069   llvm::Instruction *cleanupDominator = 0;
1070
1071   // Here we iterate over the fields; this makes it simpler to both
1072   // default-initialize fields and skip over unnamed fields.
1073   unsigned curInitIndex = 0;
1074   for (RecordDecl::field_iterator field = record->field_begin(),
1075                                fieldEnd = record->field_end();
1076        field != fieldEnd; ++field) {
1077     // We're done once we hit the flexible array member.
1078     if (field->getType()->isIncompleteArrayType())
1079       break;
1080
1081     // Always skip anonymous bitfields.
1082     if (field->isUnnamedBitfield())
1083       continue;
1084
1085     // We're done if we reach the end of the explicit initializers, we
1086     // have a zeroed object, and the rest of the fields are
1087     // zero-initializable.
1088     if (curInitIndex == NumInitElements && Dest.isZeroed() &&
1089         CGF.getTypes().isZeroInitializable(E->getType()))
1090       break;
1091
1092
1093     LValue LV = CGF.EmitLValueForFieldInitialization(DestLV, *field);
1094     // We never generate write-barries for initialized fields.
1095     LV.setNonGC(true);
1096
1097     if (curInitIndex < NumInitElements) {
1098       // Store the initializer into the field.
1099       EmitInitializationToLValue(E->getInit(curInitIndex++), LV);
1100     } else {
1101       // We're out of initalizers; default-initialize to null
1102       EmitNullInitializationToLValue(LV);
1103     }
1104
1105     // Push a destructor if necessary.
1106     // FIXME: if we have an array of structures, all explicitly
1107     // initialized, we can end up pushing a linear number of cleanups.
1108     bool pushedCleanup = false;
1109     if (QualType::DestructionKind dtorKind
1110           = field->getType().isDestructedType()) {
1111       assert(LV.isSimple());
1112       if (CGF.needsEHCleanup(dtorKind)) {
1113         if (!cleanupDominator)
1114           cleanupDominator = CGF.Builder.CreateUnreachable(); // placeholder
1115
1116         CGF.pushDestroy(EHCleanup, LV.getAddress(), field->getType(),
1117                         CGF.getDestroyer(dtorKind), false);
1118         cleanups.push_back(CGF.EHStack.stable_begin());
1119         pushedCleanup = true;
1120       }
1121     }
1122
1123     // If the GEP didn't get used because of a dead zero init or something
1124     // else, clean it up for -O0 builds and general tidiness.
1125     if (!pushedCleanup && LV.isSimple())
1126       if (llvm::GetElementPtrInst *GEP =
1127             dyn_cast<llvm::GetElementPtrInst>(LV.getAddress()))
1128         if (GEP->use_empty())
1129           GEP->eraseFromParent();
1130   }
1131
1132   // Deactivate all the partial cleanups in reverse order, which
1133   // generally means popping them.
1134   for (unsigned i = cleanups.size(); i != 0; --i)
1135     CGF.DeactivateCleanupBlock(cleanups[i-1], cleanupDominator);
1136
1137   // Destroy the placeholder if we made one.
1138   if (cleanupDominator)
1139     cleanupDominator->eraseFromParent();
1140 }
1141
1142 //===----------------------------------------------------------------------===//
1143 //                        Entry Points into this File
1144 //===----------------------------------------------------------------------===//
1145
1146 /// GetNumNonZeroBytesInInit - Get an approximate count of the number of
1147 /// non-zero bytes that will be stored when outputting the initializer for the
1148 /// specified initializer expression.
1149 static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {
1150   E = E->IgnoreParens();
1151
1152   // 0 and 0.0 won't require any non-zero stores!
1153   if (isSimpleZero(E, CGF)) return CharUnits::Zero();
1154
1155   // If this is an initlist expr, sum up the size of sizes of the (present)
1156   // elements.  If this is something weird, assume the whole thing is non-zero.
1157   const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
1158   if (ILE == 0 || !CGF.getTypes().isZeroInitializable(ILE->getType()))
1159     return CGF.getContext().getTypeSizeInChars(E->getType());
1160
1161   // InitListExprs for structs have to be handled carefully.  If there are
1162   // reference members, we need to consider the size of the reference, not the
1163   // referencee.  InitListExprs for unions and arrays can't have references.
1164   if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
1165     if (!RT->isUnionType()) {
1166       RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
1167       CharUnits NumNonZeroBytes = CharUnits::Zero();
1168
1169       unsigned ILEElement = 0;
1170       for (RecordDecl::field_iterator Field = SD->field_begin(),
1171            FieldEnd = SD->field_end(); Field != FieldEnd; ++Field) {
1172         // We're done once we hit the flexible array member or run out of
1173         // InitListExpr elements.
1174         if (Field->getType()->isIncompleteArrayType() ||
1175             ILEElement == ILE->getNumInits())
1176           break;
1177         if (Field->isUnnamedBitfield())
1178           continue;
1179
1180         const Expr *E = ILE->getInit(ILEElement++);
1181
1182         // Reference values are always non-null and have the width of a pointer.
1183         if (Field->getType()->isReferenceType())
1184           NumNonZeroBytes += CGF.getContext().toCharUnitsFromBits(
1185               CGF.getContext().getTargetInfo().getPointerWidth(0));
1186         else
1187           NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
1188       }
1189
1190       return NumNonZeroBytes;
1191     }
1192   }
1193
1194
1195   CharUnits NumNonZeroBytes = CharUnits::Zero();
1196   for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
1197     NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF);
1198   return NumNonZeroBytes;
1199 }
1200
1201 /// CheckAggExprForMemSetUse - If the initializer is large and has a lot of
1202 /// zeros in it, emit a memset and avoid storing the individual zeros.
1203 ///
1204 static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
1205                                      CodeGenFunction &CGF) {
1206   // If the slot is already known to be zeroed, nothing to do.  Don't mess with
1207   // volatile stores.
1208   if (Slot.isZeroed() || Slot.isVolatile() || Slot.getAddr() == 0) return;
1209
1210   // C++ objects with a user-declared constructor don't need zero'ing.
1211   if (CGF.getLangOpts().CPlusPlus)
1212     if (const RecordType *RT = CGF.getContext()
1213                        .getBaseElementType(E->getType())->getAs<RecordType>()) {
1214       const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1215       if (RD->hasUserDeclaredConstructor())
1216         return;
1217     }
1218
1219   // If the type is 16-bytes or smaller, prefer individual stores over memset.
1220   std::pair<CharUnits, CharUnits> TypeInfo =
1221     CGF.getContext().getTypeInfoInChars(E->getType());
1222   if (TypeInfo.first <= CharUnits::fromQuantity(16))
1223     return;
1224
1225   // Check to see if over 3/4 of the initializer are known to be zero.  If so,
1226   // we prefer to emit memset + individual stores for the rest.
1227   CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
1228   if (NumNonZeroBytes*4 > TypeInfo.first)
1229     return;
1230
1231   // Okay, it seems like a good idea to use an initial memset, emit the call.
1232   llvm::Constant *SizeVal = CGF.Builder.getInt64(TypeInfo.first.getQuantity());
1233   CharUnits Align = TypeInfo.second;
1234
1235   llvm::Value *Loc = Slot.getAddr();
1236
1237   Loc = CGF.Builder.CreateBitCast(Loc, CGF.Int8PtrTy);
1238   CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal,
1239                            Align.getQuantity(), false);
1240
1241   // Tell the AggExprEmitter that the slot is known zero.
1242   Slot.setZeroed();
1243 }
1244
1245
1246
1247
1248 /// EmitAggExpr - Emit the computation of the specified expression of aggregate
1249 /// type.  The result is computed into DestPtr.  Note that if DestPtr is null,
1250 /// the value of the aggregate expression is not needed.  If VolatileDest is
1251 /// true, DestPtr cannot be 0.
1252 void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot) {
1253   assert(E && hasAggregateLLVMType(E->getType()) &&
1254          "Invalid aggregate expression to emit");
1255   assert((Slot.getAddr() != 0 || Slot.isIgnored()) &&
1256          "slot has bits but no address");
1257
1258   // Optimize the slot if possible.
1259   CheckAggExprForMemSetUse(Slot, E, *this);
1260
1261   AggExprEmitter(*this, Slot).Visit(const_cast<Expr*>(E));
1262 }
1263
1264 LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) {
1265   assert(hasAggregateLLVMType(E->getType()) && "Invalid argument!");
1266   llvm::Value *Temp = CreateMemTemp(E->getType());
1267   LValue LV = MakeAddrLValue(Temp, E->getType());
1268   EmitAggExpr(E, AggValueSlot::forLValue(LV, AggValueSlot::IsNotDestructed,
1269                                          AggValueSlot::DoesNotNeedGCBarriers,
1270                                          AggValueSlot::IsNotAliased));
1271   return LV;
1272 }
1273
1274 void CodeGenFunction::EmitAggregateCopy(llvm::Value *DestPtr,
1275                                         llvm::Value *SrcPtr, QualType Ty,
1276                                         bool isVolatile,
1277                                         CharUnits alignment,
1278                                         bool isAssignment) {
1279   assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
1280
1281   if (getLangOpts().CPlusPlus) {
1282     if (const RecordType *RT = Ty->getAs<RecordType>()) {
1283       CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
1284       assert((Record->hasTrivialCopyConstructor() ||
1285               Record->hasTrivialCopyAssignment() ||
1286               Record->hasTrivialMoveConstructor() ||
1287               Record->hasTrivialMoveAssignment()) &&
1288              "Trying to aggregate-copy a type without a trivial copy "
1289              "constructor or assignment operator");
1290       // Ignore empty classes in C++.
1291       if (Record->isEmpty())
1292         return;
1293     }
1294   }
1295
1296   // Aggregate assignment turns into llvm.memcpy.  This is almost valid per
1297   // C99 6.5.16.1p3, which states "If the value being stored in an object is
1298   // read from another object that overlaps in anyway the storage of the first
1299   // object, then the overlap shall be exact and the two objects shall have
1300   // qualified or unqualified versions of a compatible type."
1301   //
1302   // memcpy is not defined if the source and destination pointers are exactly
1303   // equal, but other compilers do this optimization, and almost every memcpy
1304   // implementation handles this case safely.  If there is a libc that does not
1305   // safely handle this, we can add a target hook.
1306
1307   // Get data size and alignment info for this aggregate. If this is an
1308   // assignment don't copy the tail padding. Otherwise copying it is fine.
1309   std::pair<CharUnits, CharUnits> TypeInfo;
1310   if (isAssignment)
1311     TypeInfo = getContext().getTypeInfoDataSizeInChars(Ty);
1312   else
1313     TypeInfo = getContext().getTypeInfoInChars(Ty);
1314
1315   if (alignment.isZero())
1316     alignment = TypeInfo.second;
1317
1318   // FIXME: Handle variable sized types.
1319
1320   // FIXME: If we have a volatile struct, the optimizer can remove what might
1321   // appear to be `extra' memory ops:
1322   //
1323   // volatile struct { int i; } a, b;
1324   //
1325   // int main() {
1326   //   a = b;
1327   //   a = b;
1328   // }
1329   //
1330   // we need to use a different call here.  We use isVolatile to indicate when
1331   // either the source or the destination is volatile.
1332
1333   llvm::PointerType *DPT = cast<llvm::PointerType>(DestPtr->getType());
1334   llvm::Type *DBP =
1335     llvm::Type::getInt8PtrTy(getLLVMContext(), DPT->getAddressSpace());
1336   DestPtr = Builder.CreateBitCast(DestPtr, DBP);
1337
1338   llvm::PointerType *SPT = cast<llvm::PointerType>(SrcPtr->getType());
1339   llvm::Type *SBP =
1340     llvm::Type::getInt8PtrTy(getLLVMContext(), SPT->getAddressSpace());
1341   SrcPtr = Builder.CreateBitCast(SrcPtr, SBP);
1342
1343   // Don't do any of the memmove_collectable tests if GC isn't set.
1344   if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
1345     // fall through
1346   } else if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
1347     RecordDecl *Record = RecordTy->getDecl();
1348     if (Record->hasObjectMember()) {
1349       CharUnits size = TypeInfo.first;
1350       llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
1351       llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size.getQuantity());
1352       CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
1353                                                     SizeVal);
1354       return;
1355     }
1356   } else if (Ty->isArrayType()) {
1357     QualType BaseType = getContext().getBaseElementType(Ty);
1358     if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
1359       if (RecordTy->getDecl()->hasObjectMember()) {
1360         CharUnits size = TypeInfo.first;
1361         llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
1362         llvm::Value *SizeVal =
1363           llvm::ConstantInt::get(SizeTy, size.getQuantity());
1364         CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
1365                                                       SizeVal);
1366         return;
1367       }
1368     }
1369   }
1370
1371   // Determine the metadata to describe the position of any padding in this
1372   // memcpy, as well as the TBAA tags for the members of the struct, in case
1373   // the optimizer wishes to expand it in to scalar memory operations.
1374   llvm::MDNode *TBAAStructTag = CGM.getTBAAStructInfo(Ty);
1375
1376   Builder.CreateMemCpy(DestPtr, SrcPtr,
1377                        llvm::ConstantInt::get(IntPtrTy,
1378                                               TypeInfo.first.getQuantity()),
1379                        alignment.getQuantity(), isVolatile,
1380                        /*TBAATag=*/0, TBAAStructTag);
1381 }
1382
1383 void CodeGenFunction::MaybeEmitStdInitializerListCleanup(llvm::Value *loc,
1384                                                          const Expr *init) {
1385   const ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(init);
1386   if (cleanups)
1387     init = cleanups->getSubExpr();
1388
1389   if (isa<InitListExpr>(init) &&
1390       cast<InitListExpr>(init)->initializesStdInitializerList()) {
1391     // We initialized this std::initializer_list with an initializer list.
1392     // A backing array was created. Push a cleanup for it.
1393     EmitStdInitializerListCleanup(loc, cast<InitListExpr>(init));
1394   }
1395 }
1396
1397 static void EmitRecursiveStdInitializerListCleanup(CodeGenFunction &CGF,
1398                                                    llvm::Value *arrayStart,
1399                                                    const InitListExpr *init) {
1400   // Check if there are any recursive cleanups to do, i.e. if we have
1401   //   std::initializer_list<std::initializer_list<obj>> list = {{obj()}};
1402   // then we need to destroy the inner array as well.
1403   for (unsigned i = 0, e = init->getNumInits(); i != e; ++i) {
1404     const InitListExpr *subInit = dyn_cast<InitListExpr>(init->getInit(i));
1405     if (!subInit || !subInit->initializesStdInitializerList())
1406       continue;
1407
1408     // This one needs to be destroyed. Get the address of the std::init_list.
1409     llvm::Value *offset = llvm::ConstantInt::get(CGF.SizeTy, i);
1410     llvm::Value *loc = CGF.Builder.CreateInBoundsGEP(arrayStart, offset,
1411                                                  "std.initlist");
1412     CGF.EmitStdInitializerListCleanup(loc, subInit);
1413   }
1414 }
1415
1416 void CodeGenFunction::EmitStdInitializerListCleanup(llvm::Value *loc,
1417                                                     const InitListExpr *init) {
1418   ASTContext &ctx = getContext();
1419   QualType element = GetStdInitializerListElementType(init->getType());
1420   unsigned numInits = init->getNumInits();
1421   llvm::APInt size(ctx.getTypeSize(ctx.getSizeType()), numInits);
1422   QualType array =ctx.getConstantArrayType(element, size, ArrayType::Normal, 0);
1423   QualType arrayPtr = ctx.getPointerType(array);
1424   llvm::Type *arrayPtrType = ConvertType(arrayPtr);
1425
1426   // lvalue is the location of a std::initializer_list, which as its first
1427   // element has a pointer to the array we want to destroy.
1428   llvm::Value *startPointer = Builder.CreateStructGEP(loc, 0, "startPointer");
1429   llvm::Value *startAddress = Builder.CreateLoad(startPointer, "startAddress");
1430
1431   ::EmitRecursiveStdInitializerListCleanup(*this, startAddress, init);
1432
1433   llvm::Value *arrayAddress =
1434       Builder.CreateBitCast(startAddress, arrayPtrType, "arrayAddress");
1435   ::EmitStdInitializerListCleanup(*this, array, arrayAddress, init);
1436 }