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