contrib/llvm/tools/clang/lib/CodeGen/CGBlocks.cpp

   1 //===--- CGBlocks.cpp - Emit LLVM Code for declarations -------------------===//
   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 blocks.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CGDebugInfo.h"
  15 #include "CodeGenFunction.h"
  16 #include "CGObjCRuntime.h"
  17 #include "CodeGenModule.h"
  18 #include "CGBlocks.h"
  19 #include "clang/AST/DeclObjC.h"
  20 #include "llvm/Module.h"
  21 #include "llvm/ADT/SmallSet.h"
  22 #include "llvm/Target/TargetData.h"
  23 #include <algorithm>
  24
  25 using namespace clang;
  26 using namespace CodeGen;
  27
  28 CGBlockInfo::CGBlockInfo(const BlockExpr *blockExpr, const char *N)
  29   : Name(N), CXXThisIndex(0), CanBeGlobal(false), NeedsCopyDispose(false),
  30     HasCXXObject(false), UsesStret(false), StructureType(0), Block(blockExpr) {
  31
  32   // Skip asm prefix, if any.
  33   if (Name && Name[0] == '\01')
  34     ++Name;
  35 }
  36
  37 // Anchor the vtable to this translation unit.
  38 CodeGenModule::ByrefHelpers::~ByrefHelpers() {}
  39
  40 /// Build the given block as a global block.
  41 static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM,
  42                                         const CGBlockInfo &blockInfo,
  43                                         llvm::Constant *blockFn);
  44
  45 /// Build the helper function to copy a block.
  46 static llvm::Constant *buildCopyHelper(CodeGenModule &CGM,
  47                                        const CGBlockInfo &blockInfo) {
  48   return CodeGenFunction(CGM).GenerateCopyHelperFunction(blockInfo);
  49 }
  50
  51 /// Build the helper function to dipose of a block.
  52 static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM,
  53                                           const CGBlockInfo &blockInfo) {
  54   return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo);
  55 }
  56
  57 /// Build the block descriptor constant for a block.
  58 static llvm::Constant *buildBlockDescriptor(CodeGenModule &CGM,
  59                                             const CGBlockInfo &blockInfo) {
  60   ASTContext &C = CGM.getContext();
  61
  62   const llvm::Type *ulong = CGM.getTypes().ConvertType(C.UnsignedLongTy);
  63   const llvm::Type *i8p = CGM.getTypes().ConvertType(C.VoidPtrTy);
  64
  65   llvm::SmallVector<llvm::Constant*, 6> elements;
  66
  67   // reserved
  68   elements.push_back(llvm::ConstantInt::get(ulong, 0));
  69
  70   // Size
  71   // FIXME: What is the right way to say this doesn't fit?  We should give
  72   // a user diagnostic in that case.  Better fix would be to change the
  73   // API to size_t.
  74   elements.push_back(llvm::ConstantInt::get(ulong,
  75                                             blockInfo.BlockSize.getQuantity()));
  76
  77   // Optional copy/dispose helpers.
  78   if (blockInfo.NeedsCopyDispose) {
  79     // copy_func_helper_decl
  80     elements.push_back(buildCopyHelper(CGM, blockInfo));
  81
  82     // destroy_func_decl
  83     elements.push_back(buildDisposeHelper(CGM, blockInfo));
  84   }
  85
  86   // Signature.  Mandatory ObjC-style method descriptor @encode sequence.
  87   std::string typeAtEncoding =
  88     CGM.getContext().getObjCEncodingForBlock(blockInfo.getBlockExpr());
  89   elements.push_back(llvm::ConstantExpr::getBitCast(
  90                           CGM.GetAddrOfConstantCString(typeAtEncoding), i8p));
  91
  92   // GC layout.
  93   if (C.getLangOptions().ObjC1)
  94     elements.push_back(CGM.getObjCRuntime().BuildGCBlockLayout(CGM, blockInfo));
  95   else
  96     elements.push_back(llvm::Constant::getNullValue(i8p));
  97
  98   llvm::Constant *init = llvm::ConstantStruct::getAnon(elements);
  99
 100   llvm::GlobalVariable *global =
 101     new llvm::GlobalVariable(CGM.getModule(), init->getType(), true,
 102                              llvm::GlobalValue::InternalLinkage,
 103                              init, "__block_descriptor_tmp");
 104
 105   return llvm::ConstantExpr::getBitCast(global, CGM.getBlockDescriptorType());
 106 }
 107
 108 /*
 109   Purely notional variadic template describing the layout of a block.
 110
 111   template <class _ResultType, class... _ParamTypes, class... _CaptureTypes>
 112   struct Block_literal {
 113     /// Initialized to one of:
 114     ///   extern void *_NSConcreteStackBlock[];
 115     ///   extern void *_NSConcreteGlobalBlock[];
 116     ///
 117     /// In theory, we could start one off malloc'ed by setting
 118     /// BLOCK_NEEDS_FREE, giving it a refcount of 1, and using
 119     /// this isa:
 120     ///   extern void *_NSConcreteMallocBlock[];
 121     struct objc_class *isa;
 122
 123     /// These are the flags (with corresponding bit number) that the
 124     /// compiler is actually supposed to know about.
 125     ///  25. BLOCK_HAS_COPY_DISPOSE - indicates that the block
 126     ///   descriptor provides copy and dispose helper functions
 127     ///  26. BLOCK_HAS_CXX_OBJ - indicates that there's a captured
 128     ///   object with a nontrivial destructor or copy constructor
 129     ///  28. BLOCK_IS_GLOBAL - indicates that the block is allocated
 130     ///   as global memory
 131     ///  29. BLOCK_USE_STRET - indicates that the block function
 132     ///   uses stret, which objc_msgSend needs to know about
 133     ///  30. BLOCK_HAS_SIGNATURE - indicates that the block has an
 134     ///   @encoded signature string
 135     /// And we're not supposed to manipulate these:
 136     ///  24. BLOCK_NEEDS_FREE - indicates that the block has been moved
 137     ///   to malloc'ed memory
 138     ///  27. BLOCK_IS_GC - indicates that the block has been moved to
 139     ///   to GC-allocated memory
 140     /// Additionally, the bottom 16 bits are a reference count which
 141     /// should be zero on the stack.
 142     int flags;
 143
 144     /// Reserved;  should be zero-initialized.
 145     int reserved;
 146
 147     /// Function pointer generated from block literal.
 148     _ResultType (*invoke)(Block_literal *, _ParamTypes...);
 149
 150     /// Block description metadata generated from block literal.
 151     struct Block_descriptor *block_descriptor;
 152
 153     /// Captured values follow.
 154     _CapturesTypes captures...;
 155   };
 156  */
 157
 158 /// The number of fields in a block header.
 159 const unsigned BlockHeaderSize = 5;
 160
 161 namespace {
 162   /// A chunk of data that we actually have to capture in the block.
 163   struct BlockLayoutChunk {
 164     CharUnits Alignment;
 165     CharUnits Size;
 166     const BlockDecl::Capture *Capture; // null for 'this'
 167     llvm::Type *Type;
 168
 169     BlockLayoutChunk(CharUnits align, CharUnits size,
 170                      const BlockDecl::Capture *capture,
 171                      llvm::Type *type)
 172       : Alignment(align), Size(size), Capture(capture), Type(type) {}
 173
 174     /// Tell the block info that this chunk has the given field index.
 175     void setIndex(CGBlockInfo &info, unsigned index) {
 176       if (!Capture)
 177         info.CXXThisIndex = index;
 178       else
 179         info.Captures[Capture->getVariable()]
 180           = CGBlockInfo::Capture::makeIndex(index);
 181     }
 182   };
 183
 184   /// Order by descending alignment.
 185   bool operator<(const BlockLayoutChunk &left, const BlockLayoutChunk &right) {
 186     return left.Alignment > right.Alignment;
 187   }
 188 }
 189
 190 /// Determines if the given type is safe for constant capture in C++.
 191 static bool isSafeForCXXConstantCapture(QualType type) {
 192   const RecordType *recordType =
 193     type->getBaseElementTypeUnsafe()->getAs<RecordType>();
 194
 195   // Only records can be unsafe.
 196   if (!recordType) return true;
 197
 198   const CXXRecordDecl *record = cast<CXXRecordDecl>(recordType->getDecl());
 199
 200   // Maintain semantics for classes with non-trivial dtors or copy ctors.
 201   if (!record->hasTrivialDestructor()) return false;
 202   if (!record->hasTrivialCopyConstructor()) return false;
 203
 204   // Otherwise, we just have to make sure there aren't any mutable
 205   // fields that might have changed since initialization.
 206   return !record->hasMutableFields();
 207 }
 208
 209 /// It is illegal to modify a const object after initialization.
 210 /// Therefore, if a const object has a constant initializer, we don't
 211 /// actually need to keep storage for it in the block; we'll just
 212 /// rematerialize it at the start of the block function.  This is
 213 /// acceptable because we make no promises about address stability of
 214 /// captured variables.
 215 static llvm::Constant *tryCaptureAsConstant(CodeGenModule &CGM,
 216                                             const VarDecl *var) {
 217   QualType type = var->getType();
 218
 219   // We can only do this if the variable is const.
 220   if (!type.isConstQualified()) return 0;
 221
 222   // Furthermore, in C++ we have to worry about mutable fields:
 223   // C++ [dcl.type.cv]p4:
 224   //   Except that any class member declared mutable can be
 225   //   modified, any attempt to modify a const object during its
 226   //   lifetime results in undefined behavior.
 227   if (CGM.getLangOptions().CPlusPlus && !isSafeForCXXConstantCapture(type))
 228     return 0;
 229
 230   // If the variable doesn't have any initializer (shouldn't this be
 231   // invalid?), it's not clear what we should do.  Maybe capture as
 232   // zero?
 233   const Expr *init = var->getInit();
 234   if (!init) return 0;
 235
 236   return CGM.EmitConstantExpr(init, var->getType());
 237 }
 238
 239 /// Get the low bit of a nonzero character count.  This is the
 240 /// alignment of the nth byte if the 0th byte is universally aligned.
 241 static CharUnits getLowBit(CharUnits v) {
 242   return CharUnits::fromQuantity(v.getQuantity() & (~v.getQuantity() + 1));
 243 }
 244
 245 static void initializeForBlockHeader(CodeGenModule &CGM, CGBlockInfo &info,
 246                              llvm::SmallVectorImpl<llvm::Type*> &elementTypes) {
 247   ASTContext &C = CGM.getContext();
 248
 249   // The header is basically a 'struct { void *; int; int; void *; void *; }'.
 250   CharUnits ptrSize, ptrAlign, intSize, intAlign;
 251   llvm::tie(ptrSize, ptrAlign) = C.getTypeInfoInChars(C.VoidPtrTy);
 252   llvm::tie(intSize, intAlign) = C.getTypeInfoInChars(C.IntTy);
 253
 254   // Are there crazy embedded platforms where this isn't true?
 255   assert(intSize <= ptrSize && "layout assumptions horribly violated");
 256
 257   CharUnits headerSize = ptrSize;
 258   if (2 * intSize < ptrAlign) headerSize += ptrSize;
 259   else headerSize += 2 * intSize;
 260   headerSize += 2 * ptrSize;
 261
 262   info.BlockAlign = ptrAlign;
 263   info.BlockSize = headerSize;
 264
 265   assert(elementTypes.empty());
 266   llvm::Type *i8p = CGM.getTypes().ConvertType(C.VoidPtrTy);
 267   llvm::Type *intTy = CGM.getTypes().ConvertType(C.IntTy);
 268   elementTypes.push_back(i8p);
 269   elementTypes.push_back(intTy);
 270   elementTypes.push_back(intTy);
 271   elementTypes.push_back(i8p);
 272   elementTypes.push_back(CGM.getBlockDescriptorType());
 273
 274   assert(elementTypes.size() == BlockHeaderSize);
 275 }
 276
 277 /// Compute the layout of the given block.  Attempts to lay the block
 278 /// out with minimal space requirements.
 279 static void computeBlockInfo(CodeGenModule &CGM, CGBlockInfo &info) {
 280   ASTContext &C = CGM.getContext();
 281   const BlockDecl *block = info.getBlockDecl();
 282
 283   llvm::SmallVector<llvm::Type*, 8> elementTypes;
 284   initializeForBlockHeader(CGM, info, elementTypes);
 285
 286   if (!block->hasCaptures()) {
 287     info.StructureType =
 288       llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true);
 289     info.CanBeGlobal = true;
 290     return;
 291   }
 292
 293   // Collect the layout chunks.
 294   llvm::SmallVector<BlockLayoutChunk, 16> layout;
 295   layout.reserve(block->capturesCXXThis() +
 296                  (block->capture_end() - block->capture_begin()));
 297
 298   CharUnits maxFieldAlign;
 299
 300   // First, 'this'.
 301   if (block->capturesCXXThis()) {
 302     const DeclContext *DC = block->getDeclContext();
 303     for (; isa<BlockDecl>(DC); DC = cast<BlockDecl>(DC)->getDeclContext())
 304       ;
 305     QualType thisType;
 306     if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC))
 307       thisType = C.getPointerType(C.getRecordType(RD));
 308     else
 309       thisType = cast<CXXMethodDecl>(DC)->getThisType(C);
 310
 311     llvm::Type *llvmType = CGM.getTypes().ConvertType(thisType);
 312     std::pair<CharUnits,CharUnits> tinfo
 313       = CGM.getContext().getTypeInfoInChars(thisType);
 314     maxFieldAlign = std::max(maxFieldAlign, tinfo.second);
 315
 316     layout.push_back(BlockLayoutChunk(tinfo.second, tinfo.first, 0, llvmType));
 317   }
 318
 319   // Next, all the block captures.
 320   for (BlockDecl::capture_const_iterator ci = block->capture_begin(),
 321          ce = block->capture_end(); ci != ce; ++ci) {
 322     const VarDecl *variable = ci->getVariable();
 323
 324     if (ci->isByRef()) {
 325       // We have to copy/dispose of the __block reference.
 326       info.NeedsCopyDispose = true;
 327
 328       // Just use void* instead of a pointer to the byref type.
 329       QualType byRefPtrTy = C.VoidPtrTy;
 330
 331       llvm::Type *llvmType = CGM.getTypes().ConvertType(byRefPtrTy);
 332       std::pair<CharUnits,CharUnits> tinfo
 333         = CGM.getContext().getTypeInfoInChars(byRefPtrTy);
 334       maxFieldAlign = std::max(maxFieldAlign, tinfo.second);
 335
 336       layout.push_back(BlockLayoutChunk(tinfo.second, tinfo.first,
 337                                         &*ci, llvmType));
 338       continue;
 339     }
 340
 341     // Otherwise, build a layout chunk with the size and alignment of
 342     // the declaration.
 343     if (llvm::Constant *constant = tryCaptureAsConstant(CGM, variable)) {
 344       info.Captures[variable] = CGBlockInfo::Capture::makeConstant(constant);
 345       continue;
 346     }
 347
 348     // If we have a lifetime qualifier, honor it for capture purposes.
 349     // That includes *not* copying it if it's __unsafe_unretained.
 350     if (Qualifiers::ObjCLifetime lifetime
 351           = variable->getType().getObjCLifetime()) {
 352       switch (lifetime) {
 353       case Qualifiers::OCL_None: llvm_unreachable("impossible");
 354       case Qualifiers::OCL_ExplicitNone:
 355       case Qualifiers::OCL_Autoreleasing:
 356         break;
 357
 358       case Qualifiers::OCL_Strong:
 359       case Qualifiers::OCL_Weak:
 360         info.NeedsCopyDispose = true;
 361       }
 362
 363     // Block pointers require copy/dispose.  So do Objective-C pointers.
 364     } else if (variable->getType()->isObjCRetainableType()) {
 365       info.NeedsCopyDispose = true;
 366
 367     // So do types that require non-trivial copy construction.
 368     } else if (ci->hasCopyExpr()) {
 369       info.NeedsCopyDispose = true;
 370       info.HasCXXObject = true;
 371
 372     // And so do types with destructors.
 373     } else if (CGM.getLangOptions().CPlusPlus) {
 374       if (const CXXRecordDecl *record =
 375             variable->getType()->getAsCXXRecordDecl()) {
 376         if (!record->hasTrivialDestructor()) {
 377           info.HasCXXObject = true;
 378           info.NeedsCopyDispose = true;
 379         }
 380       }
 381     }
 382
 383     CharUnits size = C.getTypeSizeInChars(variable->getType());
 384     CharUnits align = C.getDeclAlign(variable);
 385     maxFieldAlign = std::max(maxFieldAlign, align);
 386
 387     llvm::Type *llvmType =
 388       CGM.getTypes().ConvertTypeForMem(variable->getType());
 389
 390     layout.push_back(BlockLayoutChunk(align, size, &*ci, llvmType));
 391   }
 392
 393   // If that was everything, we're done here.
 394   if (layout.empty()) {
 395     info.StructureType =
 396       llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true);
 397     info.CanBeGlobal = true;
 398     return;
 399   }
 400
 401   // Sort the layout by alignment.  We have to use a stable sort here
 402   // to get reproducible results.  There should probably be an
 403   // llvm::array_pod_stable_sort.
 404   std::stable_sort(layout.begin(), layout.end());
 405
 406   CharUnits &blockSize = info.BlockSize;
 407   info.BlockAlign = std::max(maxFieldAlign, info.BlockAlign);
 408
 409   // Assuming that the first byte in the header is maximally aligned,
 410   // get the alignment of the first byte following the header.
 411   CharUnits endAlign = getLowBit(blockSize);
 412
 413   // If the end of the header isn't satisfactorily aligned for the
 414   // maximum thing, look for things that are okay with the header-end
 415   // alignment, and keep appending them until we get something that's
 416   // aligned right.  This algorithm is only guaranteed optimal if
 417   // that condition is satisfied at some point; otherwise we can get
 418   // things like:
 419   //   header                 // next byte has alignment 4
 420   //   something_with_size_5; // next byte has alignment 1
 421   //   something_with_alignment_8;
 422   // which has 7 bytes of padding, as opposed to the naive solution
 423   // which might have less (?).
 424   if (endAlign < maxFieldAlign) {
 425     llvm::SmallVectorImpl<BlockLayoutChunk>::iterator
 426       li = layout.begin() + 1, le = layout.end();
 427
 428     // Look for something that the header end is already
 429     // satisfactorily aligned for.
 430     for (; li != le && endAlign < li->Alignment; ++li)
 431       ;
 432
 433     // If we found something that's naturally aligned for the end of
 434     // the header, keep adding things...
 435     if (li != le) {
 436       llvm::SmallVectorImpl<BlockLayoutChunk>::iterator first = li;
 437       for (; li != le; ++li) {
 438         assert(endAlign >= li->Alignment);
 439
 440         li->setIndex(info, elementTypes.size());
 441         elementTypes.push_back(li->Type);
 442         blockSize += li->Size;
 443         endAlign = getLowBit(blockSize);
 444
 445         // ...until we get to the alignment of the maximum field.
 446         if (endAlign >= maxFieldAlign)
 447           break;
 448       }
 449
 450       // Don't re-append everything we just appended.
 451       layout.erase(first, li);
 452     }
 453   }
 454
 455   // At this point, we just have to add padding if the end align still
 456   // isn't aligned right.
 457   if (endAlign < maxFieldAlign) {
 458     CharUnits padding = maxFieldAlign - endAlign;
 459
 460     elementTypes.push_back(llvm::ArrayType::get(CGM.Int8Ty,
 461                                                 padding.getQuantity()));
 462     blockSize += padding;
 463
 464     endAlign = getLowBit(blockSize);
 465     assert(endAlign >= maxFieldAlign);
 466   }
 467
 468   // Slam everything else on now.  This works because they have
 469   // strictly decreasing alignment and we expect that size is always a
 470   // multiple of alignment.
 471   for (llvm::SmallVectorImpl<BlockLayoutChunk>::iterator
 472          li = layout.begin(), le = layout.end(); li != le; ++li) {
 473     assert(endAlign >= li->Alignment);
 474     li->setIndex(info, elementTypes.size());
 475     elementTypes.push_back(li->Type);
 476     blockSize += li->Size;
 477     endAlign = getLowBit(blockSize);
 478   }
 479
 480   info.StructureType =
 481     llvm::StructType::get(CGM.getLLVMContext(), elementTypes, true);
 482 }
 483
 484 /// Emit a block literal expression in the current function.
 485 llvm::Value *CodeGenFunction::EmitBlockLiteral(const BlockExpr *blockExpr) {
 486   std::string Name = CurFn->getName();
 487   CGBlockInfo blockInfo(blockExpr, Name.c_str());
 488
 489   // Compute information about the layout, etc., of this block.
 490   computeBlockInfo(CGM, blockInfo);
 491
 492   // Using that metadata, generate the actual block function.
 493   llvm::Constant *blockFn
 494     = CodeGenFunction(CGM).GenerateBlockFunction(CurGD, blockInfo,
 495                                                  CurFuncDecl, LocalDeclMap);
 496   blockFn = llvm::ConstantExpr::getBitCast(blockFn, VoidPtrTy);
 497
 498   // If there is nothing to capture, we can emit this as a global block.
 499   if (blockInfo.CanBeGlobal)
 500     return buildGlobalBlock(CGM, blockInfo, blockFn);
 501
 502   // Otherwise, we have to emit this as a local block.
 503
 504   llvm::Constant *isa = CGM.getNSConcreteStackBlock();
 505   isa = llvm::ConstantExpr::getBitCast(isa, VoidPtrTy);
 506
 507   // Build the block descriptor.
 508   llvm::Constant *descriptor = buildBlockDescriptor(CGM, blockInfo);
 509
 510   const llvm::Type *intTy = ConvertType(getContext().IntTy);
 511
 512   llvm::AllocaInst *blockAddr =
 513     CreateTempAlloca(blockInfo.StructureType, "block");
 514   blockAddr->setAlignment(blockInfo.BlockAlign.getQuantity());
 515
 516   // Compute the initial on-stack block flags.
 517   BlockFlags flags = BLOCK_HAS_SIGNATURE;
 518   if (blockInfo.NeedsCopyDispose) flags |= BLOCK_HAS_COPY_DISPOSE;
 519   if (blockInfo.HasCXXObject) flags |= BLOCK_HAS_CXX_OBJ;
 520   if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET;
 521
 522   // Initialize the block literal.
 523   Builder.CreateStore(isa, Builder.CreateStructGEP(blockAddr, 0, "block.isa"));
 524   Builder.CreateStore(llvm::ConstantInt::get(intTy, flags.getBitMask()),
 525                       Builder.CreateStructGEP(blockAddr, 1, "block.flags"));
 526   Builder.CreateStore(llvm::ConstantInt::get(intTy, 0),
 527                       Builder.CreateStructGEP(blockAddr, 2, "block.reserved"));
 528   Builder.CreateStore(blockFn, Builder.CreateStructGEP(blockAddr, 3,
 529                                                        "block.invoke"));
 530   Builder.CreateStore(descriptor, Builder.CreateStructGEP(blockAddr, 4,
 531                                                           "block.descriptor"));
 532
 533   // Finally, capture all the values into the block.
 534   const BlockDecl *blockDecl = blockInfo.getBlockDecl();
 535
 536   // First, 'this'.
 537   if (blockDecl->capturesCXXThis()) {
 538     llvm::Value *addr = Builder.CreateStructGEP(blockAddr,
 539                                                 blockInfo.CXXThisIndex,
 540                                                 "block.captured-this.addr");
 541     Builder.CreateStore(LoadCXXThis(), addr);
 542   }
 543
 544   // Next, captured variables.
 545   for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(),
 546          ce = blockDecl->capture_end(); ci != ce; ++ci) {
 547     const VarDecl *variable = ci->getVariable();
 548     const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
 549
 550     // Ignore constant captures.
 551     if (capture.isConstant()) continue;
 552
 553     QualType type = variable->getType();
 554
 555     // This will be a [[type]]*, except that a byref entry will just be
 556     // an i8**.
 557     llvm::Value *blockField =
 558       Builder.CreateStructGEP(blockAddr, capture.getIndex(),
 559                               "block.captured");
 560
 561     // Compute the address of the thing we're going to move into the
 562     // block literal.
 563     llvm::Value *src;
 564     if (ci->isNested()) {
 565       // We need to use the capture from the enclosing block.
 566       const CGBlockInfo::Capture &enclosingCapture =
 567         BlockInfo->getCapture(variable);
 568
 569       // This is a [[type]]*, except that a byref entry wil just be an i8**.
 570       src = Builder.CreateStructGEP(LoadBlockStruct(),
 571                                     enclosingCapture.getIndex(),
 572                                     "block.capture.addr");
 573     } else {
 574       // This is a [[type]]*.
 575       src = LocalDeclMap[variable];
 576     }
 577
 578     // For byrefs, we just write the pointer to the byref struct into
 579     // the block field.  There's no need to chase the forwarding
 580     // pointer at this point, since we're building something that will
 581     // live a shorter life than the stack byref anyway.
 582     if (ci->isByRef()) {
 583       // Get a void* that points to the byref struct.
 584       if (ci->isNested())
 585         src = Builder.CreateLoad(src, "byref.capture");
 586       else
 587         src = Builder.CreateBitCast(src, VoidPtrTy);
 588
 589       // Write that void* into the capture field.
 590       Builder.CreateStore(src, blockField);
 591
 592     // If we have a copy constructor, evaluate that into the block field.
 593     } else if (const Expr *copyExpr = ci->getCopyExpr()) {
 594       EmitSynthesizedCXXCopyCtor(blockField, src, copyExpr);
 595
 596     // If it's a reference variable, copy the reference into the block field.
 597     } else if (type->isReferenceType()) {
 598       Builder.CreateStore(Builder.CreateLoad(src, "ref.val"), blockField);
 599
 600     // Otherwise, fake up a POD copy into the block field.
 601     } else {
 602       // Fake up a new variable so that EmitScalarInit doesn't think
 603       // we're referring to the variable in its own initializer.
 604       ImplicitParamDecl blockFieldPseudoVar(/*DC*/ 0, SourceLocation(),
 605                                             /*name*/ 0, type);
 606
 607       // We use one of these or the other depending on whether the
 608       // reference is nested.
 609       DeclRefExpr notNested(const_cast<VarDecl*>(variable), type, VK_LValue,
 610                             SourceLocation());
 611       BlockDeclRefExpr nested(const_cast<VarDecl*>(variable), type,
 612                               VK_LValue, SourceLocation(), /*byref*/ false);
 613
 614       Expr *declRef =
 615         (ci->isNested() ? static_cast<Expr*>(&nested) : &notNested);
 616
 617       ImplicitCastExpr l2r(ImplicitCastExpr::OnStack, type, CK_LValueToRValue,
 618                            declRef, VK_RValue);
 619       EmitExprAsInit(&l2r, &blockFieldPseudoVar,
 620                      LValue::MakeAddr(blockField, type,
 621                                       getContext().getDeclAlign(variable)
 622                                                   .getQuantity(),
 623                                       getContext()),
 624                      /*captured by init*/ false);
 625     }
 626
 627     // Push a destructor if necessary.  The semantics for when this
 628     // actually gets run are really obscure.
 629     if (!ci->isByRef()) {
 630       switch (QualType::DestructionKind dtorKind = type.isDestructedType()) {
 631       case QualType::DK_none:
 632         break;
 633
 634       // Block captures count as local values and have imprecise semantics.
 635       // They also can't be arrays, so need to worry about that.
 636       case QualType::DK_objc_strong_lifetime: {
 637         // This local is a GCC and MSVC compiler workaround.
 638         Destroyer *destroyer = &destroyARCStrongImprecise;
 639         pushDestroy(getCleanupKind(dtorKind), blockField, type,
 640                     *destroyer, /*useEHCleanupForArray*/ false);
 641         break;
 642       }
 643
 644       case QualType::DK_objc_weak_lifetime:
 645       case QualType::DK_cxx_destructor:
 646         pushDestroy(dtorKind, blockField, type);
 647         break;
 648       }
 649     }
 650   }
 651
 652   // Cast to the converted block-pointer type, which happens (somewhat
 653   // unfortunately) to be a pointer to function type.
 654   llvm::Value *result =
 655     Builder.CreateBitCast(blockAddr,
 656                           ConvertType(blockInfo.getBlockExpr()->getType()));
 657
 658   return result;
 659 }
 660
 661
 662 llvm::Type *CodeGenModule::getBlockDescriptorType() {
 663   if (BlockDescriptorType)
 664     return BlockDescriptorType;
 665
 666   llvm::Type *UnsignedLongTy =
 667     getTypes().ConvertType(getContext().UnsignedLongTy);
 668
 669   // struct __block_descriptor {
 670   //   unsigned long reserved;
 671   //   unsigned long block_size;
 672   //
 673   //   // later, the following will be added
 674   //
 675   //   struct {
 676   //     void (*copyHelper)();
 677   //     void (*copyHelper)();
 678   //   } helpers;                // !!! optional
 679   //
 680   //   const char *signature;   // the block signature
 681   //   const char *layout;      // reserved
 682   // };
 683   BlockDescriptorType =
 684     llvm::StructType::createNamed("struct.__block_descriptor",
 685                                   UnsignedLongTy, UnsignedLongTy, NULL);
 686
 687   // Now form a pointer to that.
 688   BlockDescriptorType = llvm::PointerType::getUnqual(BlockDescriptorType);
 689   return BlockDescriptorType;
 690 }
 691
 692 llvm::Type *CodeGenModule::getGenericBlockLiteralType() {
 693   if (GenericBlockLiteralType)
 694     return GenericBlockLiteralType;
 695
 696   llvm::Type *BlockDescPtrTy = getBlockDescriptorType();
 697
 698   // struct __block_literal_generic {
 699   //   void *__isa;
 700   //   int __flags;
 701   //   int __reserved;
 702   //   void (*__invoke)(void *);
 703   //   struct __block_descriptor *__descriptor;
 704   // };
 705   GenericBlockLiteralType =
 706     llvm::StructType::createNamed("struct.__block_literal_generic",
 707                                   VoidPtrTy,
 708                                   IntTy,
 709                                   IntTy,
 710                                   VoidPtrTy,
 711                                   BlockDescPtrTy,
 712                                   NULL);
 713
 714   return GenericBlockLiteralType;
 715 }
 716
 717
 718 RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr* E,
 719                                           ReturnValueSlot ReturnValue) {
 720   const BlockPointerType *BPT =
 721     E->getCallee()->getType()->getAs<BlockPointerType>();
 722
 723   llvm::Value *Callee = EmitScalarExpr(E->getCallee());
 724
 725   // Get a pointer to the generic block literal.
 726   const llvm::Type *BlockLiteralTy =
 727     llvm::PointerType::getUnqual(CGM.getGenericBlockLiteralType());
 728
 729   // Bitcast the callee to a block literal.
 730   llvm::Value *BlockLiteral =
 731     Builder.CreateBitCast(Callee, BlockLiteralTy, "block.literal");
 732
 733   // Get the function pointer from the literal.
 734   llvm::Value *FuncPtr = Builder.CreateStructGEP(BlockLiteral, 3, "tmp");
 735
 736   BlockLiteral = Builder.CreateBitCast(BlockLiteral, VoidPtrTy, "tmp");
 737
 738   // Add the block literal.
 739   CallArgList Args;
 740   Args.add(RValue::get(BlockLiteral), getContext().VoidPtrTy);
 741
 742   QualType FnType = BPT->getPointeeType();
 743
 744   // And the rest of the arguments.
 745   EmitCallArgs(Args, FnType->getAs<FunctionProtoType>(),
 746                E->arg_begin(), E->arg_end());
 747
 748   // Load the function.
 749   llvm::Value *Func = Builder.CreateLoad(FuncPtr, "tmp");
 750
 751   const FunctionType *FuncTy = FnType->castAs<FunctionType>();
 752   QualType ResultType = FuncTy->getResultType();
 753
 754   const CGFunctionInfo &FnInfo =
 755     CGM.getTypes().getFunctionInfo(ResultType, Args,
 756                                    FuncTy->getExtInfo());
 757
 758   // Cast the function pointer to the right type.
 759   const llvm::Type *BlockFTy =
 760     CGM.getTypes().GetFunctionType(FnInfo, false);
 761
 762   const llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy);
 763   Func = Builder.CreateBitCast(Func, BlockFTyPtr);
 764
 765   // And call the block.
 766   return EmitCall(FnInfo, Func, ReturnValue, Args);
 767 }
 768
 769 llvm::Value *CodeGenFunction::GetAddrOfBlockDecl(const VarDecl *variable,
 770                                                  bool isByRef) {
 771   assert(BlockInfo && "evaluating block ref without block information?");
 772   const CGBlockInfo::Capture &capture = BlockInfo->getCapture(variable);
 773
 774   // Handle constant captures.
 775   if (capture.isConstant()) return LocalDeclMap[variable];
 776
 777   llvm::Value *addr =
 778     Builder.CreateStructGEP(LoadBlockStruct(), capture.getIndex(),
 779                             "block.capture.addr");
 780
 781   if (isByRef) {
 782     // addr should be a void** right now.  Load, then cast the result
 783     // to byref*.
 784
 785     addr = Builder.CreateLoad(addr);
 786     const llvm::PointerType *byrefPointerType
 787       = llvm::PointerType::get(BuildByRefType(variable), 0);
 788     addr = Builder.CreateBitCast(addr, byrefPointerType,
 789                                  "byref.addr");
 790
 791     // Follow the forwarding pointer.
 792     addr = Builder.CreateStructGEP(addr, 1, "byref.forwarding");
 793     addr = Builder.CreateLoad(addr, "byref.addr.forwarded");
 794
 795     // Cast back to byref* and GEP over to the actual object.
 796     addr = Builder.CreateBitCast(addr, byrefPointerType);
 797     addr = Builder.CreateStructGEP(addr, getByRefValueLLVMField(variable),
 798                                    variable->getNameAsString());
 799   }
 800
 801   if (variable->getType()->isReferenceType())
 802     addr = Builder.CreateLoad(addr, "ref.tmp");
 803
 804   return addr;
 805 }
 806
 807 llvm::Constant *
 808 CodeGenModule::GetAddrOfGlobalBlock(const BlockExpr *blockExpr,
 809                                     const char *name) {
 810   CGBlockInfo blockInfo(blockExpr, name);
 811
 812   // Compute information about the layout, etc., of this block.
 813   computeBlockInfo(*this, blockInfo);
 814
 815   // Using that metadata, generate the actual block function.
 816   llvm::Constant *blockFn;
 817   {
 818     llvm::DenseMap<const Decl*, llvm::Value*> LocalDeclMap;
 819     blockFn = CodeGenFunction(*this).GenerateBlockFunction(GlobalDecl(),
 820                                                            blockInfo,
 821                                                            0, LocalDeclMap);
 822   }
 823   blockFn = llvm::ConstantExpr::getBitCast(blockFn, VoidPtrTy);
 824
 825   return buildGlobalBlock(*this, blockInfo, blockFn);
 826 }
 827
 828 static llvm::Constant *buildGlobalBlock(CodeGenModule &CGM,
 829                                         const CGBlockInfo &blockInfo,
 830                                         llvm::Constant *blockFn) {
 831   assert(blockInfo.CanBeGlobal);
 832
 833   // Generate the constants for the block literal initializer.
 834   llvm::Constant *fields[BlockHeaderSize];
 835
 836   // isa
 837   fields[0] = CGM.getNSConcreteGlobalBlock();
 838
 839   // __flags
 840   BlockFlags flags = BLOCK_IS_GLOBAL | BLOCK_HAS_SIGNATURE;
 841   if (blockInfo.UsesStret) flags |= BLOCK_USE_STRET;
 842
 843   fields[1] = llvm::ConstantInt::get(CGM.IntTy, flags.getBitMask());
 844
 845   // Reserved
 846   fields[2] = llvm::Constant::getNullValue(CGM.IntTy);
 847
 848   // Function
 849   fields[3] = blockFn;
 850
 851   // Descriptor
 852   fields[4] = buildBlockDescriptor(CGM, blockInfo);
 853
 854   llvm::Constant *init = llvm::ConstantStruct::getAnon(fields);
 855
 856   llvm::GlobalVariable *literal =
 857     new llvm::GlobalVariable(CGM.getModule(),
 858                              init->getType(),
 859                              /*constant*/ true,
 860                              llvm::GlobalVariable::InternalLinkage,
 861                              init,
 862                              "__block_literal_global");
 863   literal->setAlignment(blockInfo.BlockAlign.getQuantity());
 864
 865   // Return a constant of the appropriately-casted type.
 866   const llvm::Type *requiredType =
 867     CGM.getTypes().ConvertType(blockInfo.getBlockExpr()->getType());
 868   return llvm::ConstantExpr::getBitCast(literal, requiredType);
 869 }
 870
 871 llvm::Function *
 872 CodeGenFunction::GenerateBlockFunction(GlobalDecl GD,
 873                                        const CGBlockInfo &blockInfo,
 874                                        const Decl *outerFnDecl,
 875                                        const DeclMapTy &ldm) {
 876   const BlockDecl *blockDecl = blockInfo.getBlockDecl();
 877
 878   // Check if we should generate debug info for this block function.
 879   if (CGM.getModuleDebugInfo())
 880     DebugInfo = CGM.getModuleDebugInfo();
 881
 882   BlockInfo = &blockInfo;
 883
 884   // Arrange for local static and local extern declarations to appear
 885   // to be local to this function as well, in case they're directly
 886   // referenced in a block.
 887   for (DeclMapTy::const_iterator i = ldm.begin(), e = ldm.end(); i != e; ++i) {
 888     const VarDecl *var = dyn_cast<VarDecl>(i->first);
 889     if (var && !var->hasLocalStorage())
 890       LocalDeclMap[var] = i->second;
 891   }
 892
 893   // Begin building the function declaration.
 894
 895   // Build the argument list.
 896   FunctionArgList args;
 897
 898   // The first argument is the block pointer.  Just take it as a void*
 899   // and cast it later.
 900   QualType selfTy = getContext().VoidPtrTy;
 901   IdentifierInfo *II = &CGM.getContext().Idents.get(".block_descriptor");
 902
 903   ImplicitParamDecl selfDecl(const_cast<BlockDecl*>(blockDecl),
 904                              SourceLocation(), II, selfTy);
 905   args.push_back(&selfDecl);
 906
 907   // Now add the rest of the parameters.
 908   for (BlockDecl::param_const_iterator i = blockDecl->param_begin(),
 909        e = blockDecl->param_end(); i != e; ++i)
 910     args.push_back(*i);
 911
 912   // Create the function declaration.
 913   const FunctionProtoType *fnType =
 914     cast<FunctionProtoType>(blockInfo.getBlockExpr()->getFunctionType());
 915   const CGFunctionInfo &fnInfo =
 916     CGM.getTypes().getFunctionInfo(fnType->getResultType(), args,
 917                                    fnType->getExtInfo());
 918   if (CGM.ReturnTypeUsesSRet(fnInfo))
 919     blockInfo.UsesStret = true;
 920
 921   const llvm::FunctionType *fnLLVMType =
 922     CGM.getTypes().GetFunctionType(fnInfo, fnType->isVariadic());
 923
 924   MangleBuffer name;
 925   CGM.getBlockMangledName(GD, name, blockDecl);
 926   llvm::Function *fn =
 927     llvm::Function::Create(fnLLVMType, llvm::GlobalValue::InternalLinkage,
 928                            name.getString(), &CGM.getModule());
 929   CGM.SetInternalFunctionAttributes(blockDecl, fn, fnInfo);
 930
 931   // Begin generating the function.
 932   StartFunction(blockDecl, fnType->getResultType(), fn, fnInfo, args,
 933                 blockInfo.getBlockExpr()->getBody()->getLocStart());
 934   CurFuncDecl = outerFnDecl; // StartFunction sets this to blockDecl
 935
 936   // Okay.  Undo some of what StartFunction did.
 937
 938   // Pull the 'self' reference out of the local decl map.
 939   llvm::Value *blockAddr = LocalDeclMap[&selfDecl];
 940   LocalDeclMap.erase(&selfDecl);
 941   BlockPointer = Builder.CreateBitCast(blockAddr,
 942                                        blockInfo.StructureType->getPointerTo(),
 943                                        "block");
 944
 945   // If we have a C++ 'this' reference, go ahead and force it into
 946   // existence now.
 947   if (blockDecl->capturesCXXThis()) {
 948     llvm::Value *addr = Builder.CreateStructGEP(BlockPointer,
 949                                                 blockInfo.CXXThisIndex,
 950                                                 "block.captured-this");
 951     CXXThisValue = Builder.CreateLoad(addr, "this");
 952   }
 953
 954   // LoadObjCSelf() expects there to be an entry for 'self' in LocalDeclMap;
 955   // appease it.
 956   if (const ObjCMethodDecl *method
 957         = dyn_cast_or_null<ObjCMethodDecl>(CurFuncDecl)) {
 958     const VarDecl *self = method->getSelfDecl();
 959
 960     // There might not be a capture for 'self', but if there is...
 961     if (blockInfo.Captures.count(self)) {
 962       const CGBlockInfo::Capture &capture = blockInfo.getCapture(self);
 963       llvm::Value *selfAddr = Builder.CreateStructGEP(BlockPointer,
 964                                                       capture.getIndex(),
 965                                                       "block.captured-self");
 966       LocalDeclMap[self] = selfAddr;
 967     }
 968   }
 969
 970   // Also force all the constant captures.
 971   for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(),
 972          ce = blockDecl->capture_end(); ci != ce; ++ci) {
 973     const VarDecl *variable = ci->getVariable();
 974     const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
 975     if (!capture.isConstant()) continue;
 976
 977     unsigned align = getContext().getDeclAlign(variable).getQuantity();
 978
 979     llvm::AllocaInst *alloca =
 980       CreateMemTemp(variable->getType(), "block.captured-const");
 981     alloca->setAlignment(align);
 982
 983     Builder.CreateStore(capture.getConstant(), alloca, align);
 984
 985     LocalDeclMap[variable] = alloca;
 986   }
 987
 988   // Save a spot to insert the debug information for all the BlockDeclRefDecls.
 989   llvm::BasicBlock *entry = Builder.GetInsertBlock();
 990   llvm::BasicBlock::iterator entry_ptr = Builder.GetInsertPoint();
 991   --entry_ptr;
 992
 993   EmitStmt(blockDecl->getBody());
 994
 995   // Remember where we were...
 996   llvm::BasicBlock *resume = Builder.GetInsertBlock();
 997
 998   // Go back to the entry.
 999   ++entry_ptr;
1000   Builder.SetInsertPoint(entry, entry_ptr);
1001
1002   // Emit debug information for all the BlockDeclRefDecls.
1003   // FIXME: also for 'this'
1004   if (CGDebugInfo *DI = getDebugInfo()) {
1005     for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(),
1006            ce = blockDecl->capture_end(); ci != ce; ++ci) {
1007       const VarDecl *variable = ci->getVariable();
1008       DI->setLocation(variable->getLocation());
1009
1010       const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
1011       if (capture.isConstant()) {
1012         DI->EmitDeclareOfAutoVariable(variable, LocalDeclMap[variable],
1013                                       Builder);
1014         continue;
1015       }
1016
1017       DI->EmitDeclareOfBlockDeclRefVariable(variable, BlockPointer,
1018                                             Builder, blockInfo);
1019     }
1020   }
1021
1022   // And resume where we left off.
1023   if (resume == 0)
1024     Builder.ClearInsertionPoint();
1025   else
1026     Builder.SetInsertPoint(resume);
1027
1028   FinishFunction(cast<CompoundStmt>(blockDecl->getBody())->getRBracLoc());
1029
1030   return fn;
1031 }
1032
1033 /*
1034     notes.push_back(HelperInfo());
1035     HelperInfo &note = notes.back();
1036     note.index = capture.getIndex();
1037     note.RequiresCopying = (ci->hasCopyExpr() || BlockRequiresCopying(type));
1038     note.cxxbar_import = ci->getCopyExpr();
1039
1040     if (ci->isByRef()) {
1041       note.flag = BLOCK_FIELD_IS_BYREF;
1042       if (type.isObjCGCWeak())
1043         note.flag |= BLOCK_FIELD_IS_WEAK;
1044     } else if (type->isBlockPointerType()) {
1045       note.flag = BLOCK_FIELD_IS_BLOCK;
1046     } else {
1047       note.flag = BLOCK_FIELD_IS_OBJECT;
1048     }
1049  */
1050
1051
1052
1053 llvm::Constant *
1054 CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) {
1055   ASTContext &C = getContext();
1056
1057   FunctionArgList args;
1058   ImplicitParamDecl dstDecl(0, SourceLocation(), 0, C.VoidPtrTy);
1059   args.push_back(&dstDecl);
1060   ImplicitParamDecl srcDecl(0, SourceLocation(), 0, C.VoidPtrTy);
1061   args.push_back(&srcDecl);
1062
1063   const CGFunctionInfo &FI =
1064       CGM.getTypes().getFunctionInfo(C.VoidTy, args, FunctionType::ExtInfo());
1065
1066   // FIXME: it would be nice if these were mergeable with things with
1067   // identical semantics.
1068   const llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI, false);
1069
1070   llvm::Function *Fn =
1071     llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
1072                            "__copy_helper_block_", &CGM.getModule());
1073
1074   IdentifierInfo *II
1075     = &CGM.getContext().Idents.get("__copy_helper_block_");
1076
1077   // Check if we should generate debug info for this block helper function.
1078   if (CGM.getModuleDebugInfo())
1079     DebugInfo = CGM.getModuleDebugInfo();
1080
1081   FunctionDecl *FD = FunctionDecl::Create(C,
1082                                           C.getTranslationUnitDecl(),
1083                                           SourceLocation(),
1084                                           SourceLocation(), II, C.VoidTy, 0,
1085                                           SC_Static,
1086                                           SC_None,
1087                                           false,
1088                                           true);
1089   StartFunction(FD, C.VoidTy, Fn, FI, args, SourceLocation());
1090
1091   const llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();
1092
1093   llvm::Value *src = GetAddrOfLocalVar(&srcDecl);
1094   src = Builder.CreateLoad(src);
1095   src = Builder.CreateBitCast(src, structPtrTy, "block.source");
1096
1097   llvm::Value *dst = GetAddrOfLocalVar(&dstDecl);
1098   dst = Builder.CreateLoad(dst);
1099   dst = Builder.CreateBitCast(dst, structPtrTy, "block.dest");
1100
1101   const BlockDecl *blockDecl = blockInfo.getBlockDecl();
1102
1103   for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(),
1104          ce = blockDecl->capture_end(); ci != ce; ++ci) {
1105     const VarDecl *variable = ci->getVariable();
1106     QualType type = variable->getType();
1107
1108     const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
1109     if (capture.isConstant()) continue;
1110
1111     const Expr *copyExpr = ci->getCopyExpr();
1112     BlockFieldFlags flags;
1113
1114     bool isARCWeakCapture = false;
1115
1116     if (copyExpr) {
1117       assert(!ci->isByRef());
1118       // don't bother computing flags
1119
1120     } else if (ci->isByRef()) {
1121       flags = BLOCK_FIELD_IS_BYREF;
1122       if (type.isObjCGCWeak())
1123         flags |= BLOCK_FIELD_IS_WEAK;
1124
1125     } else if (type->isObjCRetainableType()) {
1126       flags = BLOCK_FIELD_IS_OBJECT;
1127       if (type->isBlockPointerType())
1128         flags = BLOCK_FIELD_IS_BLOCK;
1129
1130       // Special rules for ARC captures:
1131       if (getLangOptions().ObjCAutoRefCount) {
1132         Qualifiers qs = type.getQualifiers();
1133
1134         // Don't generate special copy logic for a captured object
1135         // unless it's __strong or __weak.
1136         if (!qs.hasStrongOrWeakObjCLifetime())
1137           continue;
1138
1139         // Support __weak direct captures.
1140         if (qs.getObjCLifetime() == Qualifiers::OCL_Weak)
1141           isARCWeakCapture = true;
1142       }
1143     } else {
1144       continue;
1145     }
1146
1147     unsigned index = capture.getIndex();
1148     llvm::Value *srcField = Builder.CreateStructGEP(src, index);
1149     llvm::Value *dstField = Builder.CreateStructGEP(dst, index);
1150
1151     // If there's an explicit copy expression, we do that.
1152     if (copyExpr) {
1153       EmitSynthesizedCXXCopyCtor(dstField, srcField, copyExpr);
1154     } else if (isARCWeakCapture) {
1155       EmitARCCopyWeak(dstField, srcField);
1156     } else {
1157       llvm::Value *srcValue = Builder.CreateLoad(srcField, "blockcopy.src");
1158       srcValue = Builder.CreateBitCast(srcValue, VoidPtrTy);
1159       llvm::Value *dstAddr = Builder.CreateBitCast(dstField, VoidPtrTy);
1160       Builder.CreateCall3(CGM.getBlockObjectAssign(), dstAddr, srcValue,
1161                           llvm::ConstantInt::get(Int32Ty, flags.getBitMask()));
1162     }
1163   }
1164
1165   FinishFunction();
1166
1167   return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy);
1168 }
1169
1170 llvm::Constant *
1171 CodeGenFunction::GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo) {
1172   ASTContext &C = getContext();
1173
1174   FunctionArgList args;
1175   ImplicitParamDecl srcDecl(0, SourceLocation(), 0, C.VoidPtrTy);
1176   args.push_back(&srcDecl);
1177
1178   const CGFunctionInfo &FI =
1179       CGM.getTypes().getFunctionInfo(C.VoidTy, args, FunctionType::ExtInfo());
1180
1181   // FIXME: We'd like to put these into a mergable by content, with
1182   // internal linkage.
1183   const llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI, false);
1184
1185   llvm::Function *Fn =
1186     llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
1187                            "__destroy_helper_block_", &CGM.getModule());
1188
1189   // Check if we should generate debug info for this block destroy function.
1190   if (CGM.getModuleDebugInfo())
1191     DebugInfo = CGM.getModuleDebugInfo();
1192
1193   IdentifierInfo *II
1194     = &CGM.getContext().Idents.get("__destroy_helper_block_");
1195
1196   FunctionDecl *FD = FunctionDecl::Create(C, C.getTranslationUnitDecl(),
1197                                           SourceLocation(),
1198                                           SourceLocation(), II, C.VoidTy, 0,
1199                                           SC_Static,
1200                                           SC_None,
1201                                           false, true);
1202   StartFunction(FD, C.VoidTy, Fn, FI, args, SourceLocation());
1203
1204   const llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();
1205
1206   llvm::Value *src = GetAddrOfLocalVar(&srcDecl);
1207   src = Builder.CreateLoad(src);
1208   src = Builder.CreateBitCast(src, structPtrTy, "block");
1209
1210   const BlockDecl *blockDecl = blockInfo.getBlockDecl();
1211
1212   CodeGenFunction::RunCleanupsScope cleanups(*this);
1213
1214   for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(),
1215          ce = blockDecl->capture_end(); ci != ce; ++ci) {
1216     const VarDecl *variable = ci->getVariable();
1217     QualType type = variable->getType();
1218
1219     const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
1220     if (capture.isConstant()) continue;
1221
1222     BlockFieldFlags flags;
1223     const CXXDestructorDecl *dtor = 0;
1224
1225     bool isARCWeakCapture = false;
1226
1227     if (ci->isByRef()) {
1228       flags = BLOCK_FIELD_IS_BYREF;
1229       if (type.isObjCGCWeak())
1230         flags |= BLOCK_FIELD_IS_WEAK;
1231     } else if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) {
1232       if (record->hasTrivialDestructor())
1233         continue;
1234       dtor = record->getDestructor();
1235     } else if (type->isObjCRetainableType()) {
1236       flags = BLOCK_FIELD_IS_OBJECT;
1237       if (type->isBlockPointerType())
1238         flags = BLOCK_FIELD_IS_BLOCK;
1239
1240       // Special rules for ARC captures.
1241       if (getLangOptions().ObjCAutoRefCount) {
1242         Qualifiers qs = type.getQualifiers();
1243
1244         // Don't generate special dispose logic for a captured object
1245         // unless it's __strong or __weak.
1246         if (!qs.hasStrongOrWeakObjCLifetime())
1247           continue;
1248
1249         // Support __weak direct captures.
1250         if (qs.getObjCLifetime() == Qualifiers::OCL_Weak)
1251           isARCWeakCapture = true;
1252       }
1253     } else {
1254       continue;
1255     }
1256
1257     unsigned index = capture.getIndex();
1258     llvm::Value *srcField = Builder.CreateStructGEP(src, index);
1259
1260     // If there's an explicit copy expression, we do that.
1261     if (dtor) {
1262       PushDestructorCleanup(dtor, srcField);
1263
1264     // If this is a __weak capture, emit the release directly.
1265     } else if (isARCWeakCapture) {
1266       EmitARCDestroyWeak(srcField);
1267
1268     // Otherwise we call _Block_object_dispose.  It wouldn't be too
1269     // hard to just emit this as a cleanup if we wanted to make sure
1270     // that things were done in reverse.
1271     } else {
1272       llvm::Value *value = Builder.CreateLoad(srcField);
1273       value = Builder.CreateBitCast(value, VoidPtrTy);
1274       BuildBlockRelease(value, flags);
1275     }
1276   }
1277
1278   cleanups.ForceCleanup();
1279
1280   FinishFunction();
1281
1282   return llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy);
1283 }
1284
1285 namespace {
1286
1287 /// Emits the copy/dispose helper functions for a __block object of id type.
1288 class ObjectByrefHelpers : public CodeGenModule::ByrefHelpers {
1289   BlockFieldFlags Flags;
1290
1291 public:
1292   ObjectByrefHelpers(CharUnits alignment, BlockFieldFlags flags)
1293     : ByrefHelpers(alignment), Flags(flags) {}
1294
1295   void emitCopy(CodeGenFunction &CGF, llvm::Value *destField,
1296                 llvm::Value *srcField) {
1297     destField = CGF.Builder.CreateBitCast(destField, CGF.VoidPtrTy);
1298
1299     srcField = CGF.Builder.CreateBitCast(srcField, CGF.VoidPtrPtrTy);
1300     llvm::Value *srcValue = CGF.Builder.CreateLoad(srcField);
1301
1302     unsigned flags = (Flags | BLOCK_BYREF_CALLER).getBitMask();
1303
1304     llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.Int32Ty, flags);
1305     llvm::Value *fn = CGF.CGM.getBlockObjectAssign();
1306     CGF.Builder.CreateCall3(fn, destField, srcValue, flagsVal);
1307   }
1308
1309   void emitDispose(CodeGenFunction &CGF, llvm::Value *field) {
1310     field = CGF.Builder.CreateBitCast(field, CGF.Int8PtrTy->getPointerTo(0));
1311     llvm::Value *value = CGF.Builder.CreateLoad(field);
1312
1313     CGF.BuildBlockRelease(value, Flags | BLOCK_BYREF_CALLER);
1314   }
1315
1316   void profileImpl(llvm::FoldingSetNodeID &id) const {
1317     id.AddInteger(Flags.getBitMask());
1318   }
1319 };
1320
1321 /// Emits the copy/dispose helpers for an ARC __block __weak variable.
1322 class ARCWeakByrefHelpers : public CodeGenModule::ByrefHelpers {
1323 public:
1324   ARCWeakByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {}
1325
1326   void emitCopy(CodeGenFunction &CGF, llvm::Value *destField,
1327                 llvm::Value *srcField) {
1328     CGF.EmitARCMoveWeak(destField, srcField);
1329   }
1330
1331   void emitDispose(CodeGenFunction &CGF, llvm::Value *field) {
1332     CGF.EmitARCDestroyWeak(field);
1333   }
1334
1335   void profileImpl(llvm::FoldingSetNodeID &id) const {
1336     // 0 is distinguishable from all pointers and byref flags
1337     id.AddInteger(0);
1338   }
1339 };
1340
1341 /// Emits the copy/dispose helpers for an ARC __block __strong variable
1342 /// that's not of block-pointer type.
1343 class ARCStrongByrefHelpers : public CodeGenModule::ByrefHelpers {
1344 public:
1345   ARCStrongByrefHelpers(CharUnits alignment) : ByrefHelpers(alignment) {}
1346
1347   void emitCopy(CodeGenFunction &CGF, llvm::Value *destField,
1348                 llvm::Value *srcField) {
1349     // Do a "move" by copying the value and then zeroing out the old
1350     // variable.
1351
1352     llvm::Value *value = CGF.Builder.CreateLoad(srcField);
1353     llvm::Value *null =
1354       llvm::ConstantPointerNull::get(cast<llvm::PointerType>(value->getType()));
1355     CGF.Builder.CreateStore(value, destField);
1356     CGF.Builder.CreateStore(null, srcField);
1357   }
1358
1359   void emitDispose(CodeGenFunction &CGF, llvm::Value *field) {
1360     llvm::Value *value = CGF.Builder.CreateLoad(field);
1361     CGF.EmitARCRelease(value, /*precise*/ false);
1362   }
1363
1364   void profileImpl(llvm::FoldingSetNodeID &id) const {
1365     // 1 is distinguishable from all pointers and byref flags
1366     id.AddInteger(1);
1367   }
1368 };
1369
1370 /// Emits the copy/dispose helpers for a __block variable with a
1371 /// nontrivial copy constructor or destructor.
1372 class CXXByrefHelpers : public CodeGenModule::ByrefHelpers {
1373   QualType VarType;
1374   const Expr *CopyExpr;
1375
1376 public:
1377   CXXByrefHelpers(CharUnits alignment, QualType type,
1378                   const Expr *copyExpr)
1379     : ByrefHelpers(alignment), VarType(type), CopyExpr(copyExpr) {}
1380
1381   bool needsCopy() const { return CopyExpr != 0; }
1382   void emitCopy(CodeGenFunction &CGF, llvm::Value *destField,
1383                 llvm::Value *srcField) {
1384     if (!CopyExpr) return;
1385     CGF.EmitSynthesizedCXXCopyCtor(destField, srcField, CopyExpr);
1386   }
1387
1388   void emitDispose(CodeGenFunction &CGF, llvm::Value *field) {
1389     EHScopeStack::stable_iterator cleanupDepth = CGF.EHStack.stable_begin();
1390     CGF.PushDestructorCleanup(VarType, field);
1391     CGF.PopCleanupBlocks(cleanupDepth);
1392   }
1393
1394   void profileImpl(llvm::FoldingSetNodeID &id) const {
1395     id.AddPointer(VarType.getCanonicalType().getAsOpaquePtr());
1396   }
1397 };
1398 } // end anonymous namespace
1399
1400 static llvm::Constant *
1401 generateByrefCopyHelper(CodeGenFunction &CGF,
1402                         const llvm::StructType &byrefType,
1403                         CodeGenModule::ByrefHelpers &byrefInfo) {
1404   ASTContext &Context = CGF.getContext();
1405
1406   QualType R = Context.VoidTy;
1407
1408   FunctionArgList args;
1409   ImplicitParamDecl dst(0, SourceLocation(), 0, Context.VoidPtrTy);
1410   args.push_back(&dst);
1411
1412   ImplicitParamDecl src(0, SourceLocation(), 0, Context.VoidPtrTy);
1413   args.push_back(&src);
1414
1415   const CGFunctionInfo &FI =
1416     CGF.CGM.getTypes().getFunctionInfo(R, args, FunctionType::ExtInfo());
1417
1418   CodeGenTypes &Types = CGF.CGM.getTypes();
1419   const llvm::FunctionType *LTy = Types.GetFunctionType(FI, false);
1420
1421   // FIXME: We'd like to put these into a mergable by content, with
1422   // internal linkage.
1423   llvm::Function *Fn =
1424     llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
1425                            "__Block_byref_object_copy_", &CGF.CGM.getModule());
1426
1427   IdentifierInfo *II
1428     = &Context.Idents.get("__Block_byref_object_copy_");
1429
1430   FunctionDecl *FD = FunctionDecl::Create(Context,
1431                                           Context.getTranslationUnitDecl(),
1432                                           SourceLocation(),
1433                                           SourceLocation(), II, R, 0,
1434                                           SC_Static,
1435                                           SC_None,
1436                                           false, true);
1437
1438   CGF.StartFunction(FD, R, Fn, FI, args, SourceLocation());
1439
1440   if (byrefInfo.needsCopy()) {
1441     const llvm::Type *byrefPtrType = byrefType.getPointerTo(0);
1442
1443     // dst->x
1444     llvm::Value *destField = CGF.GetAddrOfLocalVar(&dst);
1445     destField = CGF.Builder.CreateLoad(destField);
1446     destField = CGF.Builder.CreateBitCast(destField, byrefPtrType);
1447     destField = CGF.Builder.CreateStructGEP(destField, 6, "x");
1448
1449     // src->x
1450     llvm::Value *srcField = CGF.GetAddrOfLocalVar(&src);
1451     srcField = CGF.Builder.CreateLoad(srcField);
1452     srcField = CGF.Builder.CreateBitCast(srcField, byrefPtrType);
1453     srcField = CGF.Builder.CreateStructGEP(srcField, 6, "x");
1454
1455     byrefInfo.emitCopy(CGF, destField, srcField);
1456   }
1457
1458   CGF.FinishFunction();
1459
1460   return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy);
1461 }
1462
1463 /// Build the copy helper for a __block variable.
1464 static llvm::Constant *buildByrefCopyHelper(CodeGenModule &CGM,
1465                                             const llvm::StructType &byrefType,
1466                                             CodeGenModule::ByrefHelpers &info) {
1467   CodeGenFunction CGF(CGM);
1468   return generateByrefCopyHelper(CGF, byrefType, info);
1469 }
1470
1471 /// Generate code for a __block variable's dispose helper.
1472 static llvm::Constant *
1473 generateByrefDisposeHelper(CodeGenFunction &CGF,
1474                            const llvm::StructType &byrefType,
1475                            CodeGenModule::ByrefHelpers &byrefInfo) {
1476   ASTContext &Context = CGF.getContext();
1477   QualType R = Context.VoidTy;
1478
1479   FunctionArgList args;
1480   ImplicitParamDecl src(0, SourceLocation(), 0, Context.VoidPtrTy);
1481   args.push_back(&src);
1482
1483   const CGFunctionInfo &FI =
1484     CGF.CGM.getTypes().getFunctionInfo(R, args, FunctionType::ExtInfo());
1485
1486   CodeGenTypes &Types = CGF.CGM.getTypes();
1487   const llvm::FunctionType *LTy = Types.GetFunctionType(FI, false);
1488
1489   // FIXME: We'd like to put these into a mergable by content, with
1490   // internal linkage.
1491   llvm::Function *Fn =
1492     llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
1493                            "__Block_byref_object_dispose_",
1494                            &CGF.CGM.getModule());
1495
1496   IdentifierInfo *II
1497     = &Context.Idents.get("__Block_byref_object_dispose_");
1498
1499   FunctionDecl *FD = FunctionDecl::Create(Context,
1500                                           Context.getTranslationUnitDecl(),
1501                                           SourceLocation(),
1502                                           SourceLocation(), II, R, 0,
1503                                           SC_Static,
1504                                           SC_None,
1505                                           false, true);
1506   CGF.StartFunction(FD, R, Fn, FI, args, SourceLocation());
1507
1508   if (byrefInfo.needsDispose()) {
1509     llvm::Value *V = CGF.GetAddrOfLocalVar(&src);
1510     V = CGF.Builder.CreateLoad(V);
1511     V = CGF.Builder.CreateBitCast(V, byrefType.getPointerTo(0));
1512     V = CGF.Builder.CreateStructGEP(V, 6, "x");
1513
1514     byrefInfo.emitDispose(CGF, V);
1515   }
1516
1517   CGF.FinishFunction();
1518
1519   return llvm::ConstantExpr::getBitCast(Fn, CGF.Int8PtrTy);
1520 }
1521
1522 /// Build the dispose helper for a __block variable.
1523 static llvm::Constant *buildByrefDisposeHelper(CodeGenModule &CGM,
1524                                               const llvm::StructType &byrefType,
1525                                             CodeGenModule::ByrefHelpers &info) {
1526   CodeGenFunction CGF(CGM);
1527   return generateByrefDisposeHelper(CGF, byrefType, info);
1528 }
1529
1530 ///
1531 template <class T> static T *buildByrefHelpers(CodeGenModule &CGM,
1532                                                const llvm::StructType &byrefTy,
1533                                                T &byrefInfo) {
1534   // Increase the field's alignment to be at least pointer alignment,
1535   // since the layout of the byref struct will guarantee at least that.
1536   byrefInfo.Alignment = std::max(byrefInfo.Alignment,
1537                               CharUnits::fromQuantity(CGM.PointerAlignInBytes));
1538
1539   llvm::FoldingSetNodeID id;
1540   byrefInfo.Profile(id);
1541
1542   void *insertPos;
1543   CodeGenModule::ByrefHelpers *node
1544     = CGM.ByrefHelpersCache.FindNodeOrInsertPos(id, insertPos);
1545   if (node) return static_cast<T*>(node);
1546
1547   byrefInfo.CopyHelper = buildByrefCopyHelper(CGM, byrefTy, byrefInfo);
1548   byrefInfo.DisposeHelper = buildByrefDisposeHelper(CGM, byrefTy, byrefInfo);
1549
1550   T *copy = new (CGM.getContext()) T(byrefInfo);
1551   CGM.ByrefHelpersCache.InsertNode(copy, insertPos);
1552   return copy;
1553 }
1554
1555 CodeGenModule::ByrefHelpers *
1556 CodeGenFunction::buildByrefHelpers(const llvm::StructType &byrefType,
1557                                    const AutoVarEmission &emission) {
1558   const VarDecl &var = *emission.Variable;
1559   QualType type = var.getType();
1560
1561   if (const CXXRecordDecl *record = type->getAsCXXRecordDecl()) {
1562     const Expr *copyExpr = CGM.getContext().getBlockVarCopyInits(&var);
1563     if (!copyExpr && record->hasTrivialDestructor()) return 0;
1564
1565     CXXByrefHelpers byrefInfo(emission.Alignment, type, copyExpr);
1566     return ::buildByrefHelpers(CGM, byrefType, byrefInfo);
1567   }
1568
1569   // Otherwise, if we don't have a retainable type, there's nothing to do.
1570   // that the runtime does extra copies.
1571   if (!type->isObjCRetainableType()) return 0;
1572
1573   Qualifiers qs = type.getQualifiers();
1574
1575   // If we have lifetime, that dominates.
1576   if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) {
1577     assert(getLangOptions().ObjCAutoRefCount);
1578
1579     switch (lifetime) {
1580     case Qualifiers::OCL_None: llvm_unreachable("impossible");
1581
1582     // These are just bits as far as the runtime is concerned.
1583     case Qualifiers::OCL_ExplicitNone:
1584     case Qualifiers::OCL_Autoreleasing:
1585       return 0;
1586
1587     // Tell the runtime that this is ARC __weak, called by the
1588     // byref routines.
1589     case Qualifiers::OCL_Weak: {
1590       ARCWeakByrefHelpers byrefInfo(emission.Alignment);
1591       return ::buildByrefHelpers(CGM, byrefType, byrefInfo);
1592     }
1593
1594     // ARC __strong __block variables need to be retained.
1595     case Qualifiers::OCL_Strong:
1596       // Block-pointers need to be _Block_copy'ed, so we let the
1597       // runtime be in charge.  But we can't use the code below
1598       // because we don't want to set BYREF_CALLER, which will
1599       // just make the runtime ignore us.
1600       if (type->isBlockPointerType()) {
1601         BlockFieldFlags flags = BLOCK_FIELD_IS_BLOCK;
1602         ObjectByrefHelpers byrefInfo(emission.Alignment, flags);
1603         return ::buildByrefHelpers(CGM, byrefType, byrefInfo);
1604
1605       // Otherwise, we transfer ownership of the retain from the stack
1606       // to the heap.
1607       } else {
1608         ARCStrongByrefHelpers byrefInfo(emission.Alignment);
1609         return ::buildByrefHelpers(CGM, byrefType, byrefInfo);
1610       }
1611     }
1612     llvm_unreachable("fell out of lifetime switch!");
1613   }
1614
1615   BlockFieldFlags flags;
1616   if (type->isBlockPointerType()) {
1617     flags |= BLOCK_FIELD_IS_BLOCK;
1618   } else if (CGM.getContext().isObjCNSObjectType(type) ||
1619              type->isObjCObjectPointerType()) {
1620     flags |= BLOCK_FIELD_IS_OBJECT;
1621   } else {
1622     return 0;
1623   }
1624
1625   if (type.isObjCGCWeak())
1626     flags |= BLOCK_FIELD_IS_WEAK;
1627
1628   ObjectByrefHelpers byrefInfo(emission.Alignment, flags);
1629   return ::buildByrefHelpers(CGM, byrefType, byrefInfo);
1630 }
1631
1632 unsigned CodeGenFunction::getByRefValueLLVMField(const ValueDecl *VD) const {
1633   assert(ByRefValueInfo.count(VD) && "Did not find value!");
1634
1635   return ByRefValueInfo.find(VD)->second.second;
1636 }
1637
1638 llvm::Value *CodeGenFunction::BuildBlockByrefAddress(llvm::Value *BaseAddr,
1639                                                      const VarDecl *V) {
1640   llvm::Value *Loc = Builder.CreateStructGEP(BaseAddr, 1, "forwarding");
1641   Loc = Builder.CreateLoad(Loc);
1642   Loc = Builder.CreateStructGEP(Loc, getByRefValueLLVMField(V),
1643                                 V->getNameAsString());
1644   return Loc;
1645 }
1646
1647 /// BuildByRefType - This routine changes a __block variable declared as T x
1648 ///   into:
1649 ///
1650 ///      struct {
1651 ///        void *__isa;
1652 ///        void *__forwarding;
1653 ///        int32_t __flags;
1654 ///        int32_t __size;
1655 ///        void *__copy_helper;       // only if needed
1656 ///        void *__destroy_helper;    // only if needed
1657 ///        char padding[X];           // only if needed
1658 ///        T x;
1659 ///      } x
1660 ///
1661 const llvm::Type *CodeGenFunction::BuildByRefType(const VarDecl *D) {
1662   std::pair<const llvm::Type *, unsigned> &Info = ByRefValueInfo[D];
1663   if (Info.first)
1664     return Info.first;
1665
1666   QualType Ty = D->getType();
1667
1668   llvm::SmallVector<llvm::Type *, 8> types;
1669
1670   llvm::StructType *ByRefType =
1671     llvm::StructType::createNamed(getLLVMContext(),
1672                                 "struct.__block_byref_" + D->getNameAsString());
1673
1674   // void *__isa;
1675   types.push_back(Int8PtrTy);
1676
1677   // void *__forwarding;
1678   types.push_back(llvm::PointerType::getUnqual(ByRefType));
1679
1680   // int32_t __flags;
1681   types.push_back(Int32Ty);
1682
1683   // int32_t __size;
1684   types.push_back(Int32Ty);
1685
1686   bool HasCopyAndDispose = getContext().BlockRequiresCopying(Ty);
1687   if (HasCopyAndDispose) {
1688     /// void *__copy_helper;
1689     types.push_back(Int8PtrTy);
1690
1691     /// void *__destroy_helper;
1692     types.push_back(Int8PtrTy);
1693   }
1694
1695   bool Packed = false;
1696   CharUnits Align = getContext().getDeclAlign(D);
1697   if (Align > getContext().toCharUnitsFromBits(Target.getPointerAlign(0))) {
1698     // We have to insert padding.
1699
1700     // The struct above has 2 32-bit integers.
1701     unsigned CurrentOffsetInBytes = 4 * 2;
1702
1703     // And either 2 or 4 pointers.
1704     CurrentOffsetInBytes += (HasCopyAndDispose ? 4 : 2) *
1705       CGM.getTargetData().getTypeAllocSize(Int8PtrTy);
1706
1707     // Align the offset.
1708     unsigned AlignedOffsetInBytes =
1709       llvm::RoundUpToAlignment(CurrentOffsetInBytes, Align.getQuantity());
1710
1711     unsigned NumPaddingBytes = AlignedOffsetInBytes - CurrentOffsetInBytes;
1712     if (NumPaddingBytes > 0) {
1713       llvm::Type *Ty = llvm::Type::getInt8Ty(getLLVMContext());
1714       // FIXME: We need a sema error for alignment larger than the minimum of
1715       // the maximal stack alignment and the alignment of malloc on the system.
1716       if (NumPaddingBytes > 1)
1717         Ty = llvm::ArrayType::get(Ty, NumPaddingBytes);
1718
1719       types.push_back(Ty);
1720
1721       // We want a packed struct.
1722       Packed = true;
1723     }
1724   }
1725
1726   // T x;
1727   types.push_back(ConvertTypeForMem(Ty));
1728
1729   ByRefType->setBody(types, Packed);
1730
1731   Info.first = ByRefType;
1732
1733   Info.second = types.size() - 1;
1734
1735   return Info.first;
1736 }
1737
1738 /// Initialize the structural components of a __block variable, i.e.
1739 /// everything but the actual object.
1740 void CodeGenFunction::emitByrefStructureInit(const AutoVarEmission &emission) {
1741   // Find the address of the local.
1742   llvm::Value *addr = emission.Address;
1743
1744   // That's an alloca of the byref structure type.
1745   const llvm::StructType *byrefType = cast<llvm::StructType>(
1746                  cast<llvm::PointerType>(addr->getType())->getElementType());
1747
1748   // Build the byref helpers if necessary.  This is null if we don't need any.
1749   CodeGenModule::ByrefHelpers *helpers =
1750     buildByrefHelpers(*byrefType, emission);
1751
1752   const VarDecl &D = *emission.Variable;
1753   QualType type = D.getType();
1754
1755   llvm::Value *V;
1756
1757   // Initialize the 'isa', which is just 0 or 1.
1758   int isa = 0;
1759   if (type.isObjCGCWeak())
1760     isa = 1;
1761   V = Builder.CreateIntToPtr(Builder.getInt32(isa), Int8PtrTy, "isa");
1762   Builder.CreateStore(V, Builder.CreateStructGEP(addr, 0, "byref.isa"));
1763
1764   // Store the address of the variable into its own forwarding pointer.
1765   Builder.CreateStore(addr,
1766                       Builder.CreateStructGEP(addr, 1, "byref.forwarding"));
1767
1768   // Blocks ABI:
1769   //   c) the flags field is set to either 0 if no helper functions are
1770   //      needed or BLOCK_HAS_COPY_DISPOSE if they are,
1771   BlockFlags flags;
1772   if (helpers) flags |= BLOCK_HAS_COPY_DISPOSE;
1773   Builder.CreateStore(llvm::ConstantInt::get(IntTy, flags.getBitMask()),
1774                       Builder.CreateStructGEP(addr, 2, "byref.flags"));
1775
1776   CharUnits byrefSize = CGM.GetTargetTypeStoreSize(byrefType);
1777   V = llvm::ConstantInt::get(IntTy, byrefSize.getQuantity());
1778   Builder.CreateStore(V, Builder.CreateStructGEP(addr, 3, "byref.size"));
1779
1780   if (helpers) {
1781     llvm::Value *copy_helper = Builder.CreateStructGEP(addr, 4);
1782     Builder.CreateStore(helpers->CopyHelper, copy_helper);
1783
1784     llvm::Value *destroy_helper = Builder.CreateStructGEP(addr, 5);
1785     Builder.CreateStore(helpers->DisposeHelper, destroy_helper);
1786   }
1787 }
1788
1789 void CodeGenFunction::BuildBlockRelease(llvm::Value *V, BlockFieldFlags flags) {
1790   llvm::Value *F = CGM.getBlockObjectDispose();
1791   llvm::Value *N;
1792   V = Builder.CreateBitCast(V, Int8PtrTy);
1793   N = llvm::ConstantInt::get(Int32Ty, flags.getBitMask());
1794   Builder.CreateCall2(F, V, N);
1795 }
1796
1797 namespace {
1798   struct CallBlockRelease : EHScopeStack::Cleanup {
1799     llvm::Value *Addr;
1800     CallBlockRelease(llvm::Value *Addr) : Addr(Addr) {}
1801
1802     void Emit(CodeGenFunction &CGF, Flags flags) {
1803       // Should we be passing FIELD_IS_WEAK here?
1804       CGF.BuildBlockRelease(Addr, BLOCK_FIELD_IS_BYREF);
1805     }
1806   };
1807 }
1808
1809 /// Enter a cleanup to destroy a __block variable.  Note that this
1810 /// cleanup should be a no-op if the variable hasn't left the stack
1811 /// yet; if a cleanup is required for the variable itself, that needs
1812 /// to be done externally.
1813 void CodeGenFunction::enterByrefCleanup(const AutoVarEmission &emission) {
1814   // We don't enter this cleanup if we're in pure-GC mode.
1815   if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly)
1816     return;
1817
1818   EHStack.pushCleanup<CallBlockRelease>(NormalAndEHCleanup, emission.Address);
1819 }