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

   1 //===--- CGDecl.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 Decl nodes as LLVM code.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CodeGenFunction.h"
  15 #include "CGDebugInfo.h"
  16 #include "CGOpenCLRuntime.h"
  17 #include "CodeGenModule.h"
  18 #include "clang/AST/ASTContext.h"
  19 #include "clang/AST/CharUnits.h"
  20 #include "clang/AST/Decl.h"
  21 #include "clang/AST/DeclObjC.h"
  22 #include "clang/Basic/SourceManager.h"
  23 #include "clang/Basic/TargetInfo.h"
  24 #include "clang/Frontend/CodeGenOptions.h"
  25 #include "llvm/IR/DataLayout.h"
  26 #include "llvm/IR/GlobalVariable.h"
  27 #include "llvm/IR/Intrinsics.h"
  28 #include "llvm/IR/Type.h"
  29 using namespace clang;
  30 using namespace CodeGen;
  31
  32
  33 void CodeGenFunction::EmitDecl(const Decl &D) {
  34   switch (D.getKind()) {
  35   case Decl::TranslationUnit:
  36   case Decl::Namespace:
  37   case Decl::UnresolvedUsingTypename:
  38   case Decl::ClassTemplateSpecialization:
  39   case Decl::ClassTemplatePartialSpecialization:
  40   case Decl::TemplateTypeParm:
  41   case Decl::UnresolvedUsingValue:
  42   case Decl::NonTypeTemplateParm:
  43   case Decl::CXXMethod:
  44   case Decl::CXXConstructor:
  45   case Decl::CXXDestructor:
  46   case Decl::CXXConversion:
  47   case Decl::Field:
  48   case Decl::MSProperty:
  49   case Decl::IndirectField:
  50   case Decl::ObjCIvar:
  51   case Decl::ObjCAtDefsField:
  52   case Decl::ParmVar:
  53   case Decl::ImplicitParam:
  54   case Decl::ClassTemplate:
  55   case Decl::FunctionTemplate:
  56   case Decl::TypeAliasTemplate:
  57   case Decl::TemplateTemplateParm:
  58   case Decl::ObjCMethod:
  59   case Decl::ObjCCategory:
  60   case Decl::ObjCProtocol:
  61   case Decl::ObjCInterface:
  62   case Decl::ObjCCategoryImpl:
  63   case Decl::ObjCImplementation:
  64   case Decl::ObjCProperty:
  65   case Decl::ObjCCompatibleAlias:
  66   case Decl::AccessSpec:
  67   case Decl::LinkageSpec:
  68   case Decl::ObjCPropertyImpl:
  69   case Decl::FileScopeAsm:
  70   case Decl::Friend:
  71   case Decl::FriendTemplate:
  72   case Decl::Block:
  73   case Decl::Captured:
  74   case Decl::ClassScopeFunctionSpecialization:
  75     llvm_unreachable("Declaration should not be in declstmts!");
  76   case Decl::Function:  // void X();
  77   case Decl::Record:    // struct/union/class X;
  78   case Decl::Enum:      // enum X;
  79   case Decl::EnumConstant: // enum ? { X = ? }
  80   case Decl::CXXRecord: // struct/union/class X; [C++]
  81   case Decl::Using:          // using X; [C++]
  82   case Decl::UsingShadow:
  83   case Decl::NamespaceAlias:
  84   case Decl::StaticAssert: // static_assert(X, ""); [C++0x]
  85   case Decl::Label:        // __label__ x;
  86   case Decl::Import:
  87   case Decl::OMPThreadPrivate:
  88   case Decl::Empty:
  89     // None of these decls require codegen support.
  90     return;
  91
  92   case Decl::UsingDirective: // using namespace X; [C++]
  93     if (CGDebugInfo *DI = getDebugInfo())
  94       DI->EmitUsingDirective(cast<UsingDirectiveDecl>(D));
  95     return;
  96   case Decl::Var: {
  97     const VarDecl &VD = cast<VarDecl>(D);
  98     assert(VD.isLocalVarDecl() &&
  99            "Should not see file-scope variables inside a function!");
 100     return EmitVarDecl(VD);
 101   }
 102
 103   case Decl::Typedef:      // typedef int X;
 104   case Decl::TypeAlias: {  // using X = int; [C++0x]
 105     const TypedefNameDecl &TD = cast<TypedefNameDecl>(D);
 106     QualType Ty = TD.getUnderlyingType();
 107
 108     if (Ty->isVariablyModifiedType())
 109       EmitVariablyModifiedType(Ty);
 110   }
 111   }
 112 }
 113
 114 /// EmitVarDecl - This method handles emission of any variable declaration
 115 /// inside a function, including static vars etc.
 116 void CodeGenFunction::EmitVarDecl(const VarDecl &D) {
 117   switch (D.getStorageClass()) {
 118   case SC_None:
 119   case SC_Auto:
 120   case SC_Register:
 121     return EmitAutoVarDecl(D);
 122   case SC_Static: {
 123     llvm::GlobalValue::LinkageTypes Linkage =
 124       llvm::GlobalValue::InternalLinkage;
 125
 126     // If the function definition has some sort of weak linkage, its
 127     // static variables should also be weak so that they get properly
 128     // uniqued.  We can't do this in C, though, because there's no
 129     // standard way to agree on which variables are the same (i.e.
 130     // there's no mangling).
 131     if (getLangOpts().CPlusPlus)
 132       if (llvm::GlobalValue::isWeakForLinker(CurFn->getLinkage()))
 133         Linkage = CurFn->getLinkage();
 134
 135     return EmitStaticVarDecl(D, Linkage);
 136   }
 137   case SC_Extern:
 138   case SC_PrivateExtern:
 139     // Don't emit it now, allow it to be emitted lazily on its first use.
 140     return;
 141   case SC_OpenCLWorkGroupLocal:
 142     return CGM.getOpenCLRuntime().EmitWorkGroupLocalVarDecl(*this, D);
 143   }
 144
 145   llvm_unreachable("Unknown storage class");
 146 }
 147
 148 static std::string GetStaticDeclName(CodeGenFunction &CGF, const VarDecl &D,
 149                                      const char *Separator) {
 150   CodeGenModule &CGM = CGF.CGM;
 151   if (CGF.getLangOpts().CPlusPlus) {
 152     StringRef Name = CGM.getMangledName(&D);
 153     return Name.str();
 154   }
 155
 156   std::string ContextName;
 157   if (!CGF.CurFuncDecl) {
 158     // Better be in a block declared in global scope.
 159     const NamedDecl *ND = cast<NamedDecl>(&D);
 160     const DeclContext *DC = ND->getDeclContext();
 161     if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) {
 162       MangleBuffer Name;
 163       CGM.getBlockMangledName(GlobalDecl(), Name, BD);
 164       ContextName = Name.getString();
 165     }
 166     else
 167       llvm_unreachable("Unknown context for block static var decl");
 168   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CGF.CurFuncDecl)) {
 169     StringRef Name = CGM.getMangledName(FD);
 170     ContextName = Name.str();
 171   } else if (isa<ObjCMethodDecl>(CGF.CurFuncDecl))
 172     ContextName = CGF.CurFn->getName();
 173   else
 174     llvm_unreachable("Unknown context for static var decl");
 175
 176   return ContextName + Separator + D.getNameAsString();
 177 }
 178
 179 llvm::GlobalVariable *
 180 CodeGenFunction::CreateStaticVarDecl(const VarDecl &D,
 181                                      const char *Separator,
 182                                      llvm::GlobalValue::LinkageTypes Linkage) {
 183   QualType Ty = D.getType();
 184   assert(Ty->isConstantSizeType() && "VLAs can't be static");
 185
 186   // Use the label if the variable is renamed with the asm-label extension.
 187   std::string Name;
 188   if (D.hasAttr<AsmLabelAttr>())
 189     Name = CGM.getMangledName(&D);
 190   else
 191     Name = GetStaticDeclName(*this, D, Separator);
 192
 193   llvm::Type *LTy = CGM.getTypes().ConvertTypeForMem(Ty);
 194   unsigned AddrSpace =
 195    CGM.GetGlobalVarAddressSpace(&D, CGM.getContext().getTargetAddressSpace(Ty));
 196   llvm::GlobalVariable *GV =
 197     new llvm::GlobalVariable(CGM.getModule(), LTy,
 198                              Ty.isConstant(getContext()), Linkage,
 199                              CGM.EmitNullConstant(D.getType()), Name, 0,
 200                              llvm::GlobalVariable::NotThreadLocal,
 201                              AddrSpace);
 202   GV->setAlignment(getContext().getDeclAlign(&D).getQuantity());
 203   if (Linkage != llvm::GlobalValue::InternalLinkage)
 204     GV->setVisibility(CurFn->getVisibility());
 205
 206   if (D.getTLSKind())
 207     CGM.setTLSMode(GV, D);
 208
 209   return GV;
 210 }
 211
 212 /// hasNontrivialDestruction - Determine whether a type's destruction is
 213 /// non-trivial. If so, and the variable uses static initialization, we must
 214 /// register its destructor to run on exit.
 215 static bool hasNontrivialDestruction(QualType T) {
 216   CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
 217   return RD && !RD->hasTrivialDestructor();
 218 }
 219
 220 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
 221 /// global variable that has already been created for it.  If the initializer
 222 /// has a different type than GV does, this may free GV and return a different
 223 /// one.  Otherwise it just returns GV.
 224 llvm::GlobalVariable *
 225 CodeGenFunction::AddInitializerToStaticVarDecl(const VarDecl &D,
 226                                                llvm::GlobalVariable *GV) {
 227   llvm::Constant *Init = CGM.EmitConstantInit(D, this);
 228
 229   // If constant emission failed, then this should be a C++ static
 230   // initializer.
 231   if (!Init) {
 232     if (!getLangOpts().CPlusPlus)
 233       CGM.ErrorUnsupported(D.getInit(), "constant l-value expression");
 234     else if (Builder.GetInsertBlock()) {
 235       // Since we have a static initializer, this global variable can't
 236       // be constant.
 237       GV->setConstant(false);
 238
 239       EmitCXXGuardedInit(D, GV, /*PerformInit*/true);
 240     }
 241     return GV;
 242   }
 243
 244   // The initializer may differ in type from the global. Rewrite
 245   // the global to match the initializer.  (We have to do this
 246   // because some types, like unions, can't be completely represented
 247   // in the LLVM type system.)
 248   if (GV->getType()->getElementType() != Init->getType()) {
 249     llvm::GlobalVariable *OldGV = GV;
 250
 251     GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(),
 252                                   OldGV->isConstant(),
 253                                   OldGV->getLinkage(), Init, "",
 254                                   /*InsertBefore*/ OldGV,
 255                                   OldGV->getThreadLocalMode(),
 256                            CGM.getContext().getTargetAddressSpace(D.getType()));
 257     GV->setVisibility(OldGV->getVisibility());
 258
 259     // Steal the name of the old global
 260     GV->takeName(OldGV);
 261
 262     // Replace all uses of the old global with the new global
 263     llvm::Constant *NewPtrForOldDecl =
 264     llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
 265     OldGV->replaceAllUsesWith(NewPtrForOldDecl);
 266
 267     // Erase the old global, since it is no longer used.
 268     OldGV->eraseFromParent();
 269   }
 270
 271   GV->setConstant(CGM.isTypeConstant(D.getType(), true));
 272   GV->setInitializer(Init);
 273
 274   if (hasNontrivialDestruction(D.getType())) {
 275     // We have a constant initializer, but a nontrivial destructor. We still
 276     // need to perform a guarded "initialization" in order to register the
 277     // destructor.
 278     EmitCXXGuardedInit(D, GV, /*PerformInit*/false);
 279   }
 280
 281   return GV;
 282 }
 283
 284 void CodeGenFunction::EmitStaticVarDecl(const VarDecl &D,
 285                                       llvm::GlobalValue::LinkageTypes Linkage) {
 286   llvm::Value *&DMEntry = LocalDeclMap[&D];
 287   assert(DMEntry == 0 && "Decl already exists in localdeclmap!");
 288
 289   // Check to see if we already have a global variable for this
 290   // declaration.  This can happen when double-emitting function
 291   // bodies, e.g. with complete and base constructors.
 292   llvm::Constant *addr =
 293     CGM.getStaticLocalDeclAddress(&D);
 294
 295   llvm::GlobalVariable *var;
 296   if (addr) {
 297     var = cast<llvm::GlobalVariable>(addr->stripPointerCasts());
 298   } else {
 299     addr = var = CreateStaticVarDecl(D, ".", Linkage);
 300   }
 301
 302   // Store into LocalDeclMap before generating initializer to handle
 303   // circular references.
 304   DMEntry = addr;
 305   CGM.setStaticLocalDeclAddress(&D, addr);
 306
 307   // We can't have a VLA here, but we can have a pointer to a VLA,
 308   // even though that doesn't really make any sense.
 309   // Make sure to evaluate VLA bounds now so that we have them for later.
 310   if (D.getType()->isVariablyModifiedType())
 311     EmitVariablyModifiedType(D.getType());
 312
 313   // Save the type in case adding the initializer forces a type change.
 314   llvm::Type *expectedType = addr->getType();
 315
 316   // If this value has an initializer, emit it.
 317   if (D.getInit())
 318     var = AddInitializerToStaticVarDecl(D, var);
 319
 320   var->setAlignment(getContext().getDeclAlign(&D).getQuantity());
 321
 322   if (D.hasAttr<AnnotateAttr>())
 323     CGM.AddGlobalAnnotations(&D, var);
 324
 325   if (const SectionAttr *SA = D.getAttr<SectionAttr>())
 326     var->setSection(SA->getName());
 327
 328   if (D.hasAttr<UsedAttr>())
 329     CGM.AddUsedGlobal(var);
 330
 331   // We may have to cast the constant because of the initializer
 332   // mismatch above.
 333   //
 334   // FIXME: It is really dangerous to store this in the map; if anyone
 335   // RAUW's the GV uses of this constant will be invalid.
 336   llvm::Constant *castedAddr = llvm::ConstantExpr::getBitCast(var, expectedType);
 337   DMEntry = castedAddr;
 338   CGM.setStaticLocalDeclAddress(&D, castedAddr);
 339
 340   // Emit global variable debug descriptor for static vars.
 341   CGDebugInfo *DI = getDebugInfo();
 342   if (DI &&
 343       CGM.getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) {
 344     DI->setLocation(D.getLocation());
 345     DI->EmitGlobalVariable(var, &D);
 346   }
 347 }
 348
 349 namespace {
 350   struct DestroyObject : EHScopeStack::Cleanup {
 351     DestroyObject(llvm::Value *addr, QualType type,
 352                   CodeGenFunction::Destroyer *destroyer,
 353                   bool useEHCleanupForArray)
 354       : addr(addr), type(type), destroyer(destroyer),
 355         useEHCleanupForArray(useEHCleanupForArray) {}
 356
 357     llvm::Value *addr;
 358     QualType type;
 359     CodeGenFunction::Destroyer *destroyer;
 360     bool useEHCleanupForArray;
 361
 362     void Emit(CodeGenFunction &CGF, Flags flags) {
 363       // Don't use an EH cleanup recursively from an EH cleanup.
 364       bool useEHCleanupForArray =
 365         flags.isForNormalCleanup() && this->useEHCleanupForArray;
 366
 367       CGF.emitDestroy(addr, type, destroyer, useEHCleanupForArray);
 368     }
 369   };
 370
 371   struct DestroyNRVOVariable : EHScopeStack::Cleanup {
 372     DestroyNRVOVariable(llvm::Value *addr,
 373                         const CXXDestructorDecl *Dtor,
 374                         llvm::Value *NRVOFlag)
 375       : Dtor(Dtor), NRVOFlag(NRVOFlag), Loc(addr) {}
 376
 377     const CXXDestructorDecl *Dtor;
 378     llvm::Value *NRVOFlag;
 379     llvm::Value *Loc;
 380
 381     void Emit(CodeGenFunction &CGF, Flags flags) {
 382       // Along the exceptions path we always execute the dtor.
 383       bool NRVO = flags.isForNormalCleanup() && NRVOFlag;
 384
 385       llvm::BasicBlock *SkipDtorBB = 0;
 386       if (NRVO) {
 387         // If we exited via NRVO, we skip the destructor call.
 388         llvm::BasicBlock *RunDtorBB = CGF.createBasicBlock("nrvo.unused");
 389         SkipDtorBB = CGF.createBasicBlock("nrvo.skipdtor");
 390         llvm::Value *DidNRVO = CGF.Builder.CreateLoad(NRVOFlag, "nrvo.val");
 391         CGF.Builder.CreateCondBr(DidNRVO, SkipDtorBB, RunDtorBB);
 392         CGF.EmitBlock(RunDtorBB);
 393       }
 394
 395       CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete,
 396                                 /*ForVirtualBase=*/false,
 397                                 /*Delegating=*/false,
 398                                 Loc);
 399
 400       if (NRVO) CGF.EmitBlock(SkipDtorBB);
 401     }
 402   };
 403
 404   struct CallStackRestore : EHScopeStack::Cleanup {
 405     llvm::Value *Stack;
 406     CallStackRestore(llvm::Value *Stack) : Stack(Stack) {}
 407     void Emit(CodeGenFunction &CGF, Flags flags) {
 408       llvm::Value *V = CGF.Builder.CreateLoad(Stack);
 409       llvm::Value *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore);
 410       CGF.Builder.CreateCall(F, V);
 411     }
 412   };
 413
 414   struct ExtendGCLifetime : EHScopeStack::Cleanup {
 415     const VarDecl &Var;
 416     ExtendGCLifetime(const VarDecl *var) : Var(*var) {}
 417
 418     void Emit(CodeGenFunction &CGF, Flags flags) {
 419       // Compute the address of the local variable, in case it's a
 420       // byref or something.
 421       DeclRefExpr DRE(const_cast<VarDecl*>(&Var), false,
 422                       Var.getType(), VK_LValue, SourceLocation());
 423       llvm::Value *value = CGF.EmitLoadOfScalar(CGF.EmitDeclRefLValue(&DRE));
 424       CGF.EmitExtendGCLifetime(value);
 425     }
 426   };
 427
 428   struct CallCleanupFunction : EHScopeStack::Cleanup {
 429     llvm::Constant *CleanupFn;
 430     const CGFunctionInfo &FnInfo;
 431     const VarDecl &Var;
 432
 433     CallCleanupFunction(llvm::Constant *CleanupFn, const CGFunctionInfo *Info,
 434                         const VarDecl *Var)
 435       : CleanupFn(CleanupFn), FnInfo(*Info), Var(*Var) {}
 436
 437     void Emit(CodeGenFunction &CGF, Flags flags) {
 438       DeclRefExpr DRE(const_cast<VarDecl*>(&Var), false,
 439                       Var.getType(), VK_LValue, SourceLocation());
 440       // Compute the address of the local variable, in case it's a byref
 441       // or something.
 442       llvm::Value *Addr = CGF.EmitDeclRefLValue(&DRE).getAddress();
 443
 444       // In some cases, the type of the function argument will be different from
 445       // the type of the pointer. An example of this is
 446       // void f(void* arg);
 447       // __attribute__((cleanup(f))) void *g;
 448       //
 449       // To fix this we insert a bitcast here.
 450       QualType ArgTy = FnInfo.arg_begin()->type;
 451       llvm::Value *Arg =
 452         CGF.Builder.CreateBitCast(Addr, CGF.ConvertType(ArgTy));
 453
 454       CallArgList Args;
 455       Args.add(RValue::get(Arg),
 456                CGF.getContext().getPointerType(Var.getType()));
 457       CGF.EmitCall(FnInfo, CleanupFn, ReturnValueSlot(), Args);
 458     }
 459   };
 460
 461   /// A cleanup to call @llvm.lifetime.end.
 462   class CallLifetimeEnd : public EHScopeStack::Cleanup {
 463     llvm::Value *Addr;
 464     llvm::Value *Size;
 465   public:
 466     CallLifetimeEnd(llvm::Value *addr, llvm::Value *size)
 467       : Addr(addr), Size(size) {}
 468
 469     void Emit(CodeGenFunction &CGF, Flags flags) {
 470       llvm::Value *castAddr = CGF.Builder.CreateBitCast(Addr, CGF.Int8PtrTy);
 471       CGF.Builder.CreateCall2(CGF.CGM.getLLVMLifetimeEndFn(),
 472                               Size, castAddr)
 473         ->setDoesNotThrow();
 474     }
 475   };
 476 }
 477
 478 /// EmitAutoVarWithLifetime - Does the setup required for an automatic
 479 /// variable with lifetime.
 480 static void EmitAutoVarWithLifetime(CodeGenFunction &CGF, const VarDecl &var,
 481                                     llvm::Value *addr,
 482                                     Qualifiers::ObjCLifetime lifetime) {
 483   switch (lifetime) {
 484   case Qualifiers::OCL_None:
 485     llvm_unreachable("present but none");
 486
 487   case Qualifiers::OCL_ExplicitNone:
 488     // nothing to do
 489     break;
 490
 491   case Qualifiers::OCL_Strong: {
 492     CodeGenFunction::Destroyer *destroyer =
 493       (var.hasAttr<ObjCPreciseLifetimeAttr>()
 494        ? CodeGenFunction::destroyARCStrongPrecise
 495        : CodeGenFunction::destroyARCStrongImprecise);
 496
 497     CleanupKind cleanupKind = CGF.getARCCleanupKind();
 498     CGF.pushDestroy(cleanupKind, addr, var.getType(), destroyer,
 499                     cleanupKind & EHCleanup);
 500     break;
 501   }
 502   case Qualifiers::OCL_Autoreleasing:
 503     // nothing to do
 504     break;
 505
 506   case Qualifiers::OCL_Weak:
 507     // __weak objects always get EH cleanups; otherwise, exceptions
 508     // could cause really nasty crashes instead of mere leaks.
 509     CGF.pushDestroy(NormalAndEHCleanup, addr, var.getType(),
 510                     CodeGenFunction::destroyARCWeak,
 511                     /*useEHCleanup*/ true);
 512     break;
 513   }
 514 }
 515
 516 static bool isAccessedBy(const VarDecl &var, const Stmt *s) {
 517   if (const Expr *e = dyn_cast<Expr>(s)) {
 518     // Skip the most common kinds of expressions that make
 519     // hierarchy-walking expensive.
 520     s = e = e->IgnoreParenCasts();
 521
 522     if (const DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e))
 523       return (ref->getDecl() == &var);
 524     if (const BlockExpr *be = dyn_cast<BlockExpr>(e)) {
 525       const BlockDecl *block = be->getBlockDecl();
 526       for (BlockDecl::capture_const_iterator i = block->capture_begin(),
 527            e = block->capture_end(); i != e; ++i) {
 528         if (i->getVariable() == &var)
 529           return true;
 530       }
 531     }
 532   }
 533
 534   for (Stmt::const_child_range children = s->children(); children; ++children)
 535     // children might be null; as in missing decl or conditional of an if-stmt.
 536     if ((*children) && isAccessedBy(var, *children))
 537       return true;
 538
 539   return false;
 540 }
 541
 542 static bool isAccessedBy(const ValueDecl *decl, const Expr *e) {
 543   if (!decl) return false;
 544   if (!isa<VarDecl>(decl)) return false;
 545   const VarDecl *var = cast<VarDecl>(decl);
 546   return isAccessedBy(*var, e);
 547 }
 548
 549 static void drillIntoBlockVariable(CodeGenFunction &CGF,
 550                                    LValue &lvalue,
 551                                    const VarDecl *var) {
 552   lvalue.setAddress(CGF.BuildBlockByrefAddress(lvalue.getAddress(), var));
 553 }
 554
 555 void CodeGenFunction::EmitScalarInit(const Expr *init,
 556                                      const ValueDecl *D,
 557                                      LValue lvalue,
 558                                      bool capturedByInit) {
 559   Qualifiers::ObjCLifetime lifetime = lvalue.getObjCLifetime();
 560   if (!lifetime) {
 561     llvm::Value *value = EmitScalarExpr(init);
 562     if (capturedByInit)
 563       drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
 564     EmitStoreThroughLValue(RValue::get(value), lvalue, true);
 565     return;
 566   }
 567
 568   // If we're emitting a value with lifetime, we have to do the
 569   // initialization *before* we leave the cleanup scopes.
 570   if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(init)) {
 571     enterFullExpression(ewc);
 572     init = ewc->getSubExpr();
 573   }
 574   CodeGenFunction::RunCleanupsScope Scope(*this);
 575
 576   // We have to maintain the illusion that the variable is
 577   // zero-initialized.  If the variable might be accessed in its
 578   // initializer, zero-initialize before running the initializer, then
 579   // actually perform the initialization with an assign.
 580   bool accessedByInit = false;
 581   if (lifetime != Qualifiers::OCL_ExplicitNone)
 582     accessedByInit = (capturedByInit || isAccessedBy(D, init));
 583   if (accessedByInit) {
 584     LValue tempLV = lvalue;
 585     // Drill down to the __block object if necessary.
 586     if (capturedByInit) {
 587       // We can use a simple GEP for this because it can't have been
 588       // moved yet.
 589       tempLV.setAddress(Builder.CreateStructGEP(tempLV.getAddress(),
 590                                    getByRefValueLLVMField(cast<VarDecl>(D))));
 591     }
 592
 593     llvm::PointerType *ty
 594       = cast<llvm::PointerType>(tempLV.getAddress()->getType());
 595     ty = cast<llvm::PointerType>(ty->getElementType());
 596
 597     llvm::Value *zero = llvm::ConstantPointerNull::get(ty);
 598
 599     // If __weak, we want to use a barrier under certain conditions.
 600     if (lifetime == Qualifiers::OCL_Weak)
 601       EmitARCInitWeak(tempLV.getAddress(), zero);
 602
 603     // Otherwise just do a simple store.
 604     else
 605       EmitStoreOfScalar(zero, tempLV, /* isInitialization */ true);
 606   }
 607
 608   // Emit the initializer.
 609   llvm::Value *value = 0;
 610
 611   switch (lifetime) {
 612   case Qualifiers::OCL_None:
 613     llvm_unreachable("present but none");
 614
 615   case Qualifiers::OCL_ExplicitNone:
 616     // nothing to do
 617     value = EmitScalarExpr(init);
 618     break;
 619
 620   case Qualifiers::OCL_Strong: {
 621     value = EmitARCRetainScalarExpr(init);
 622     break;
 623   }
 624
 625   case Qualifiers::OCL_Weak: {
 626     // No way to optimize a producing initializer into this.  It's not
 627     // worth optimizing for, because the value will immediately
 628     // disappear in the common case.
 629     value = EmitScalarExpr(init);
 630
 631     if (capturedByInit) drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
 632     if (accessedByInit)
 633       EmitARCStoreWeak(lvalue.getAddress(), value, /*ignored*/ true);
 634     else
 635       EmitARCInitWeak(lvalue.getAddress(), value);
 636     return;
 637   }
 638
 639   case Qualifiers::OCL_Autoreleasing:
 640     value = EmitARCRetainAutoreleaseScalarExpr(init);
 641     break;
 642   }
 643
 644   if (capturedByInit) drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
 645
 646   // If the variable might have been accessed by its initializer, we
 647   // might have to initialize with a barrier.  We have to do this for
 648   // both __weak and __strong, but __weak got filtered out above.
 649   if (accessedByInit && lifetime == Qualifiers::OCL_Strong) {
 650     llvm::Value *oldValue = EmitLoadOfScalar(lvalue);
 651     EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
 652     EmitARCRelease(oldValue, ARCImpreciseLifetime);
 653     return;
 654   }
 655
 656   EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
 657 }
 658
 659 /// EmitScalarInit - Initialize the given lvalue with the given object.
 660 void CodeGenFunction::EmitScalarInit(llvm::Value *init, LValue lvalue) {
 661   Qualifiers::ObjCLifetime lifetime = lvalue.getObjCLifetime();
 662   if (!lifetime)
 663     return EmitStoreThroughLValue(RValue::get(init), lvalue, true);
 664
 665   switch (lifetime) {
 666   case Qualifiers::OCL_None:
 667     llvm_unreachable("present but none");
 668
 669   case Qualifiers::OCL_ExplicitNone:
 670     // nothing to do
 671     break;
 672
 673   case Qualifiers::OCL_Strong:
 674     init = EmitARCRetain(lvalue.getType(), init);
 675     break;
 676
 677   case Qualifiers::OCL_Weak:
 678     // Initialize and then skip the primitive store.
 679     EmitARCInitWeak(lvalue.getAddress(), init);
 680     return;
 681
 682   case Qualifiers::OCL_Autoreleasing:
 683     init = EmitARCRetainAutorelease(lvalue.getType(), init);
 684     break;
 685   }
 686
 687   EmitStoreOfScalar(init, lvalue, /* isInitialization */ true);
 688 }
 689
 690 /// canEmitInitWithFewStoresAfterMemset - Decide whether we can emit the
 691 /// non-zero parts of the specified initializer with equal or fewer than
 692 /// NumStores scalar stores.
 693 static bool canEmitInitWithFewStoresAfterMemset(llvm::Constant *Init,
 694                                                 unsigned &NumStores) {
 695   // Zero and Undef never requires any extra stores.
 696   if (isa<llvm::ConstantAggregateZero>(Init) ||
 697       isa<llvm::ConstantPointerNull>(Init) ||
 698       isa<llvm::UndefValue>(Init))
 699     return true;
 700   if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
 701       isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
 702       isa<llvm::ConstantExpr>(Init))
 703     return Init->isNullValue() || NumStores--;
 704
 705   // See if we can emit each element.
 706   if (isa<llvm::ConstantArray>(Init) || isa<llvm::ConstantStruct>(Init)) {
 707     for (unsigned i = 0, e = Init->getNumOperands(); i != e; ++i) {
 708       llvm::Constant *Elt = cast<llvm::Constant>(Init->getOperand(i));
 709       if (!canEmitInitWithFewStoresAfterMemset(Elt, NumStores))
 710         return false;
 711     }
 712     return true;
 713   }
 714
 715   if (llvm::ConstantDataSequential *CDS =
 716         dyn_cast<llvm::ConstantDataSequential>(Init)) {
 717     for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
 718       llvm::Constant *Elt = CDS->getElementAsConstant(i);
 719       if (!canEmitInitWithFewStoresAfterMemset(Elt, NumStores))
 720         return false;
 721     }
 722     return true;
 723   }
 724
 725   // Anything else is hard and scary.
 726   return false;
 727 }
 728
 729 /// emitStoresForInitAfterMemset - For inits that
 730 /// canEmitInitWithFewStoresAfterMemset returned true for, emit the scalar
 731 /// stores that would be required.
 732 static void emitStoresForInitAfterMemset(llvm::Constant *Init, llvm::Value *Loc,
 733                                          bool isVolatile, CGBuilderTy &Builder) {
 734   assert(!Init->isNullValue() && !isa<llvm::UndefValue>(Init) &&
 735          "called emitStoresForInitAfterMemset for zero or undef value.");
 736
 737   if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
 738       isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
 739       isa<llvm::ConstantExpr>(Init)) {
 740     Builder.CreateStore(Init, Loc, isVolatile);
 741     return;
 742   }
 743
 744   if (llvm::ConstantDataSequential *CDS =
 745         dyn_cast<llvm::ConstantDataSequential>(Init)) {
 746     for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
 747       llvm::Constant *Elt = CDS->getElementAsConstant(i);
 748
 749       // If necessary, get a pointer to the element and emit it.
 750       if (!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))
 751         emitStoresForInitAfterMemset(Elt, Builder.CreateConstGEP2_32(Loc, 0, i),
 752                                      isVolatile, Builder);
 753     }
 754     return;
 755   }
 756
 757   assert((isa<llvm::ConstantStruct>(Init) || isa<llvm::ConstantArray>(Init)) &&
 758          "Unknown value type!");
 759
 760   for (unsigned i = 0, e = Init->getNumOperands(); i != e; ++i) {
 761     llvm::Constant *Elt = cast<llvm::Constant>(Init->getOperand(i));
 762
 763     // If necessary, get a pointer to the element and emit it.
 764     if (!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))
 765       emitStoresForInitAfterMemset(Elt, Builder.CreateConstGEP2_32(Loc, 0, i),
 766                                    isVolatile, Builder);
 767   }
 768 }
 769
 770
 771 /// shouldUseMemSetPlusStoresToInitialize - Decide whether we should use memset
 772 /// plus some stores to initialize a local variable instead of using a memcpy
 773 /// from a constant global.  It is beneficial to use memset if the global is all
 774 /// zeros, or mostly zeros and large.
 775 static bool shouldUseMemSetPlusStoresToInitialize(llvm::Constant *Init,
 776                                                   uint64_t GlobalSize) {
 777   // If a global is all zeros, always use a memset.
 778   if (isa<llvm::ConstantAggregateZero>(Init)) return true;
 779
 780   // If a non-zero global is <= 32 bytes, always use a memcpy.  If it is large,
 781   // do it if it will require 6 or fewer scalar stores.
 782   // TODO: Should budget depends on the size?  Avoiding a large global warrants
 783   // plopping in more stores.
 784   unsigned StoreBudget = 6;
 785   uint64_t SizeLimit = 32;
 786
 787   return GlobalSize > SizeLimit &&
 788          canEmitInitWithFewStoresAfterMemset(Init, StoreBudget);
 789 }
 790
 791 /// Should we use the LLVM lifetime intrinsics for the given local variable?
 792 static bool shouldUseLifetimeMarkers(CodeGenFunction &CGF, const VarDecl &D,
 793                                      unsigned Size) {
 794   // Always emit lifetime markers in -fsanitize=use-after-scope mode.
 795   if (CGF.getLangOpts().Sanitize.UseAfterScope)
 796     return true;
 797   // For now, only in optimized builds.
 798   if (CGF.CGM.getCodeGenOpts().OptimizationLevel == 0)
 799     return false;
 800
 801   // Limit the size of marked objects to 32 bytes. We don't want to increase
 802   // compile time by marking tiny objects.
 803   unsigned SizeThreshold = 32;
 804
 805   return Size > SizeThreshold;
 806 }
 807
 808
 809 /// EmitAutoVarDecl - Emit code and set up an entry in LocalDeclMap for a
 810 /// variable declaration with auto, register, or no storage class specifier.
 811 /// These turn into simple stack objects, or GlobalValues depending on target.
 812 void CodeGenFunction::EmitAutoVarDecl(const VarDecl &D) {
 813   AutoVarEmission emission = EmitAutoVarAlloca(D);
 814   EmitAutoVarInit(emission);
 815   EmitAutoVarCleanups(emission);
 816 }
 817
 818 /// EmitAutoVarAlloca - Emit the alloca and debug information for a
 819 /// local variable.  Does not emit initalization or destruction.
 820 CodeGenFunction::AutoVarEmission
 821 CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
 822   QualType Ty = D.getType();
 823
 824   AutoVarEmission emission(D);
 825
 826   bool isByRef = D.hasAttr<BlocksAttr>();
 827   emission.IsByRef = isByRef;
 828
 829   CharUnits alignment = getContext().getDeclAlign(&D);
 830   emission.Alignment = alignment;
 831
 832   // If the type is variably-modified, emit all the VLA sizes for it.
 833   if (Ty->isVariablyModifiedType())
 834     EmitVariablyModifiedType(Ty);
 835
 836   llvm::Value *DeclPtr;
 837   if (Ty->isConstantSizeType()) {
 838     bool NRVO = getLangOpts().ElideConstructors &&
 839       D.isNRVOVariable();
 840
 841     // If this value is a POD array or struct with a statically
 842     // determinable constant initializer, there are optimizations we can do.
 843     //
 844     // TODO: We should constant-evaluate the initializer of any variable,
 845     // as long as it is initialized by a constant expression. Currently,
 846     // isConstantInitializer produces wrong answers for structs with
 847     // reference or bitfield members, and a few other cases, and checking
 848     // for POD-ness protects us from some of these.
 849     if (D.getInit() &&
 850         (Ty->isArrayType() || Ty->isRecordType()) &&
 851         (Ty.isPODType(getContext()) ||
 852          getContext().getBaseElementType(Ty)->isObjCObjectPointerType()) &&
 853         D.getInit()->isConstantInitializer(getContext(), false)) {
 854
 855       // If the variable's a const type, and it's neither an NRVO
 856       // candidate nor a __block variable and has no mutable members,
 857       // emit it as a global instead.
 858       if (CGM.getCodeGenOpts().MergeAllConstants && !NRVO && !isByRef &&
 859           CGM.isTypeConstant(Ty, true)) {
 860         EmitStaticVarDecl(D, llvm::GlobalValue::InternalLinkage);
 861
 862         emission.Address = 0; // signal this condition to later callbacks
 863         assert(emission.wasEmittedAsGlobal());
 864         return emission;
 865       }
 866
 867       // Otherwise, tell the initialization code that we're in this case.
 868       emission.IsConstantAggregate = true;
 869     }
 870
 871     // A normal fixed sized variable becomes an alloca in the entry block,
 872     // unless it's an NRVO variable.
 873     llvm::Type *LTy = ConvertTypeForMem(Ty);
 874
 875     if (NRVO) {
 876       // The named return value optimization: allocate this variable in the
 877       // return slot, so that we can elide the copy when returning this
 878       // variable (C++0x [class.copy]p34).
 879       DeclPtr = ReturnValue;
 880
 881       if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
 882         if (!cast<CXXRecordDecl>(RecordTy->getDecl())->hasTrivialDestructor()) {
 883           // Create a flag that is used to indicate when the NRVO was applied
 884           // to this variable. Set it to zero to indicate that NRVO was not
 885           // applied.
 886           llvm::Value *Zero = Builder.getFalse();
 887           llvm::Value *NRVOFlag = CreateTempAlloca(Zero->getType(), "nrvo");
 888           EnsureInsertPoint();
 889           Builder.CreateStore(Zero, NRVOFlag);
 890
 891           // Record the NRVO flag for this variable.
 892           NRVOFlags[&D] = NRVOFlag;
 893           emission.NRVOFlag = NRVOFlag;
 894         }
 895       }
 896     } else {
 897       if (isByRef)
 898         LTy = BuildByRefType(&D);
 899
 900       llvm::AllocaInst *Alloc = CreateTempAlloca(LTy);
 901       Alloc->setName(D.getName());
 902
 903       CharUnits allocaAlignment = alignment;
 904       if (isByRef)
 905         allocaAlignment = std::max(allocaAlignment,
 906             getContext().toCharUnitsFromBits(getTarget().getPointerAlign(0)));
 907       Alloc->setAlignment(allocaAlignment.getQuantity());
 908       DeclPtr = Alloc;
 909
 910       // Emit a lifetime intrinsic if meaningful.  There's no point
 911       // in doing this if we don't have a valid insertion point (?).
 912       uint64_t size = CGM.getDataLayout().getTypeAllocSize(LTy);
 913       if (HaveInsertPoint() && shouldUseLifetimeMarkers(*this, D, size)) {
 914         llvm::Value *sizeV = llvm::ConstantInt::get(Int64Ty, size);
 915
 916         emission.SizeForLifetimeMarkers = sizeV;
 917         llvm::Value *castAddr = Builder.CreateBitCast(Alloc, Int8PtrTy);
 918         Builder.CreateCall2(CGM.getLLVMLifetimeStartFn(), sizeV, castAddr)
 919           ->setDoesNotThrow();
 920       } else {
 921         assert(!emission.useLifetimeMarkers());
 922       }
 923     }
 924   } else {
 925     EnsureInsertPoint();
 926
 927     if (!DidCallStackSave) {
 928       // Save the stack.
 929       llvm::Value *Stack = CreateTempAlloca(Int8PtrTy, "saved_stack");
 930
 931       llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stacksave);
 932       llvm::Value *V = Builder.CreateCall(F);
 933
 934       Builder.CreateStore(V, Stack);
 935
 936       DidCallStackSave = true;
 937
 938       // Push a cleanup block and restore the stack there.
 939       // FIXME: in general circumstances, this should be an EH cleanup.
 940       EHStack.pushCleanup<CallStackRestore>(NormalCleanup, Stack);
 941     }
 942
 943     llvm::Value *elementCount;
 944     QualType elementType;
 945     llvm::tie(elementCount, elementType) = getVLASize(Ty);
 946
 947     llvm::Type *llvmTy = ConvertTypeForMem(elementType);
 948
 949     // Allocate memory for the array.
 950     llvm::AllocaInst *vla = Builder.CreateAlloca(llvmTy, elementCount, "vla");
 951     vla->setAlignment(alignment.getQuantity());
 952
 953     DeclPtr = vla;
 954   }
 955
 956   llvm::Value *&DMEntry = LocalDeclMap[&D];
 957   assert(DMEntry == 0 && "Decl already exists in localdeclmap!");
 958   DMEntry = DeclPtr;
 959   emission.Address = DeclPtr;
 960
 961   // Emit debug info for local var declaration.
 962   if (HaveInsertPoint())
 963     if (CGDebugInfo *DI = getDebugInfo()) {
 964       if (CGM.getCodeGenOpts().getDebugInfo()
 965             >= CodeGenOptions::LimitedDebugInfo) {
 966         DI->setLocation(D.getLocation());
 967         DI->EmitDeclareOfAutoVariable(&D, DeclPtr, Builder);
 968       }
 969     }
 970
 971   if (D.hasAttr<AnnotateAttr>())
 972       EmitVarAnnotations(&D, emission.Address);
 973
 974   return emission;
 975 }
 976
 977 /// Determines whether the given __block variable is potentially
 978 /// captured by the given expression.
 979 static bool isCapturedBy(const VarDecl &var, const Expr *e) {
 980   // Skip the most common kinds of expressions that make
 981   // hierarchy-walking expensive.
 982   e = e->IgnoreParenCasts();
 983
 984   if (const BlockExpr *be = dyn_cast<BlockExpr>(e)) {
 985     const BlockDecl *block = be->getBlockDecl();
 986     for (BlockDecl::capture_const_iterator i = block->capture_begin(),
 987            e = block->capture_end(); i != e; ++i) {
 988       if (i->getVariable() == &var)
 989         return true;
 990     }
 991
 992     // No need to walk into the subexpressions.
 993     return false;
 994   }
 995
 996   if (const StmtExpr *SE = dyn_cast<StmtExpr>(e)) {
 997     const CompoundStmt *CS = SE->getSubStmt();
 998     for (CompoundStmt::const_body_iterator BI = CS->body_begin(),
 999            BE = CS->body_end(); BI != BE; ++BI)
1000       if (Expr *E = dyn_cast<Expr>((*BI))) {
1001         if (isCapturedBy(var, E))
1002             return true;
1003       }
1004       else if (DeclStmt *DS = dyn_cast<DeclStmt>((*BI))) {
1005           // special case declarations
1006           for (DeclStmt::decl_iterator I = DS->decl_begin(), E = DS->decl_end();
1007                I != E; ++I) {
1008               if (VarDecl *VD = dyn_cast<VarDecl>((*I))) {
1009                 Expr *Init = VD->getInit();
1010                 if (Init && isCapturedBy(var, Init))
1011                   return true;
1012               }
1013           }
1014       }
1015       else
1016         // FIXME. Make safe assumption assuming arbitrary statements cause capturing.
1017         // Later, provide code to poke into statements for capture analysis.
1018         return true;
1019     return false;
1020   }
1021
1022   for (Stmt::const_child_range children = e->children(); children; ++children)
1023     if (isCapturedBy(var, cast<Expr>(*children)))
1024       return true;
1025
1026   return false;
1027 }
1028
1029 /// \brief Determine whether the given initializer is trivial in the sense
1030 /// that it requires no code to be generated.
1031 static bool isTrivialInitializer(const Expr *Init) {
1032   if (!Init)
1033     return true;
1034
1035   if (const CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init))
1036     if (CXXConstructorDecl *Constructor = Construct->getConstructor())
1037       if (Constructor->isTrivial() &&
1038           Constructor->isDefaultConstructor() &&
1039           !Construct->requiresZeroInitialization())
1040         return true;
1041
1042   return false;
1043 }
1044 void CodeGenFunction::EmitAutoVarInit(const AutoVarEmission &emission) {
1045   assert(emission.Variable && "emission was not valid!");
1046
1047   // If this was emitted as a global constant, we're done.
1048   if (emission.wasEmittedAsGlobal()) return;
1049
1050   const VarDecl &D = *emission.Variable;
1051   QualType type = D.getType();
1052
1053   // If this local has an initializer, emit it now.
1054   const Expr *Init = D.getInit();
1055
1056   // If we are at an unreachable point, we don't need to emit the initializer
1057   // unless it contains a label.
1058   if (!HaveInsertPoint()) {
1059     if (!Init || !ContainsLabel(Init)) return;
1060     EnsureInsertPoint();
1061   }
1062
1063   // Initialize the structure of a __block variable.
1064   if (emission.IsByRef)
1065     emitByrefStructureInit(emission);
1066
1067   if (isTrivialInitializer(Init))
1068     return;
1069
1070   CharUnits alignment = emission.Alignment;
1071
1072   // Check whether this is a byref variable that's potentially
1073   // captured and moved by its own initializer.  If so, we'll need to
1074   // emit the initializer first, then copy into the variable.
1075   bool capturedByInit = emission.IsByRef && isCapturedBy(D, Init);
1076
1077   llvm::Value *Loc =
1078     capturedByInit ? emission.Address : emission.getObjectAddress(*this);
1079
1080   llvm::Constant *constant = 0;
1081   if (emission.IsConstantAggregate) {
1082     assert(!capturedByInit && "constant init contains a capturing block?");
1083     constant = CGM.EmitConstantInit(D, this);
1084   }
1085
1086   if (!constant) {
1087     LValue lv = MakeAddrLValue(Loc, type, alignment);
1088     lv.setNonGC(true);
1089     return EmitExprAsInit(Init, &D, lv, capturedByInit);
1090   }
1091
1092   // If this is a simple aggregate initialization, we can optimize it
1093   // in various ways.
1094   bool isVolatile = type.isVolatileQualified();
1095
1096   llvm::Value *SizeVal =
1097     llvm::ConstantInt::get(IntPtrTy,
1098                            getContext().getTypeSizeInChars(type).getQuantity());
1099
1100   llvm::Type *BP = Int8PtrTy;
1101   if (Loc->getType() != BP)
1102     Loc = Builder.CreateBitCast(Loc, BP);
1103
1104   // If the initializer is all or mostly zeros, codegen with memset then do
1105   // a few stores afterward.
1106   if (shouldUseMemSetPlusStoresToInitialize(constant,
1107                 CGM.getDataLayout().getTypeAllocSize(constant->getType()))) {
1108     Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, 0), SizeVal,
1109                          alignment.getQuantity(), isVolatile);
1110     // Zero and undef don't require a stores.
1111     if (!constant->isNullValue() && !isa<llvm::UndefValue>(constant)) {
1112       Loc = Builder.CreateBitCast(Loc, constant->getType()->getPointerTo());
1113       emitStoresForInitAfterMemset(constant, Loc, isVolatile, Builder);
1114     }
1115   } else {
1116     // Otherwise, create a temporary global with the initializer then
1117     // memcpy from the global to the alloca.
1118     std::string Name = GetStaticDeclName(*this, D, ".");
1119     llvm::GlobalVariable *GV =
1120       new llvm::GlobalVariable(CGM.getModule(), constant->getType(), true,
1121                                llvm::GlobalValue::PrivateLinkage,
1122                                constant, Name);
1123     GV->setAlignment(alignment.getQuantity());
1124     GV->setUnnamedAddr(true);
1125
1126     llvm::Value *SrcPtr = GV;
1127     if (SrcPtr->getType() != BP)
1128       SrcPtr = Builder.CreateBitCast(SrcPtr, BP);
1129
1130     Builder.CreateMemCpy(Loc, SrcPtr, SizeVal, alignment.getQuantity(),
1131                          isVolatile);
1132   }
1133 }
1134
1135 /// Emit an expression as an initializer for a variable at the given
1136 /// location.  The expression is not necessarily the normal
1137 /// initializer for the variable, and the address is not necessarily
1138 /// its normal location.
1139 ///
1140 /// \param init the initializing expression
1141 /// \param var the variable to act as if we're initializing
1142 /// \param loc the address to initialize; its type is a pointer
1143 ///   to the LLVM mapping of the variable's type
1144 /// \param alignment the alignment of the address
1145 /// \param capturedByInit true if the variable is a __block variable
1146 ///   whose address is potentially changed by the initializer
1147 void CodeGenFunction::EmitExprAsInit(const Expr *init,
1148                                      const ValueDecl *D,
1149                                      LValue lvalue,
1150                                      bool capturedByInit) {
1151   QualType type = D->getType();
1152
1153   if (type->isReferenceType()) {
1154     RValue rvalue = EmitReferenceBindingToExpr(init, D);
1155     if (capturedByInit)
1156       drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
1157     EmitStoreThroughLValue(rvalue, lvalue, true);
1158     return;
1159   }
1160   switch (getEvaluationKind(type)) {
1161   case TEK_Scalar:
1162     EmitScalarInit(init, D, lvalue, capturedByInit);
1163     return;
1164   case TEK_Complex: {
1165     ComplexPairTy complex = EmitComplexExpr(init);
1166     if (capturedByInit)
1167       drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
1168     EmitStoreOfComplex(complex, lvalue, /*init*/ true);
1169     return;
1170   }
1171   case TEK_Aggregate:
1172     if (type->isAtomicType()) {
1173       EmitAtomicInit(const_cast<Expr*>(init), lvalue);
1174     } else {
1175       // TODO: how can we delay here if D is captured by its initializer?
1176       EmitAggExpr(init, AggValueSlot::forLValue(lvalue,
1177                                               AggValueSlot::IsDestructed,
1178                                          AggValueSlot::DoesNotNeedGCBarriers,
1179                                               AggValueSlot::IsNotAliased));
1180     }
1181     MaybeEmitStdInitializerListCleanup(lvalue.getAddress(), init);
1182     return;
1183   }
1184   llvm_unreachable("bad evaluation kind");
1185 }
1186
1187 /// Enter a destroy cleanup for the given local variable.
1188 void CodeGenFunction::emitAutoVarTypeCleanup(
1189                             const CodeGenFunction::AutoVarEmission &emission,
1190                             QualType::DestructionKind dtorKind) {
1191   assert(dtorKind != QualType::DK_none);
1192
1193   // Note that for __block variables, we want to destroy the
1194   // original stack object, not the possibly forwarded object.
1195   llvm::Value *addr = emission.getObjectAddress(*this);
1196
1197   const VarDecl *var = emission.Variable;
1198   QualType type = var->getType();
1199
1200   CleanupKind cleanupKind = NormalAndEHCleanup;
1201   CodeGenFunction::Destroyer *destroyer = 0;
1202
1203   switch (dtorKind) {
1204   case QualType::DK_none:
1205     llvm_unreachable("no cleanup for trivially-destructible variable");
1206
1207   case QualType::DK_cxx_destructor:
1208     // If there's an NRVO flag on the emission, we need a different
1209     // cleanup.
1210     if (emission.NRVOFlag) {
1211       assert(!type->isArrayType());
1212       CXXDestructorDecl *dtor = type->getAsCXXRecordDecl()->getDestructor();
1213       EHStack.pushCleanup<DestroyNRVOVariable>(cleanupKind, addr, dtor,
1214                                                emission.NRVOFlag);
1215       return;
1216     }
1217     break;
1218
1219   case QualType::DK_objc_strong_lifetime:
1220     // Suppress cleanups for pseudo-strong variables.
1221     if (var->isARCPseudoStrong()) return;
1222
1223     // Otherwise, consider whether to use an EH cleanup or not.
1224     cleanupKind = getARCCleanupKind();
1225
1226     // Use the imprecise destroyer by default.
1227     if (!var->hasAttr<ObjCPreciseLifetimeAttr>())
1228       destroyer = CodeGenFunction::destroyARCStrongImprecise;
1229     break;
1230
1231   case QualType::DK_objc_weak_lifetime:
1232     break;
1233   }
1234
1235   // If we haven't chosen a more specific destroyer, use the default.
1236   if (!destroyer) destroyer = getDestroyer(dtorKind);
1237
1238   // Use an EH cleanup in array destructors iff the destructor itself
1239   // is being pushed as an EH cleanup.
1240   bool useEHCleanup = (cleanupKind & EHCleanup);
1241   EHStack.pushCleanup<DestroyObject>(cleanupKind, addr, type, destroyer,
1242                                      useEHCleanup);
1243 }
1244
1245 void CodeGenFunction::EmitAutoVarCleanups(const AutoVarEmission &emission) {
1246   assert(emission.Variable && "emission was not valid!");
1247
1248   // If this was emitted as a global constant, we're done.
1249   if (emission.wasEmittedAsGlobal()) return;
1250
1251   // If we don't have an insertion point, we're done.  Sema prevents
1252   // us from jumping into any of these scopes anyway.
1253   if (!HaveInsertPoint()) return;
1254
1255   const VarDecl &D = *emission.Variable;
1256
1257   // Make sure we call @llvm.lifetime.end.  This needs to happen
1258   // *last*, so the cleanup needs to be pushed *first*.
1259   if (emission.useLifetimeMarkers()) {
1260     EHStack.pushCleanup<CallLifetimeEnd>(NormalCleanup,
1261                                          emission.getAllocatedAddress(),
1262                                          emission.getSizeForLifetimeMarkers());
1263   }
1264
1265   // Check the type for a cleanup.
1266   if (QualType::DestructionKind dtorKind = D.getType().isDestructedType())
1267     emitAutoVarTypeCleanup(emission, dtorKind);
1268
1269   // In GC mode, honor objc_precise_lifetime.
1270   if (getLangOpts().getGC() != LangOptions::NonGC &&
1271       D.hasAttr<ObjCPreciseLifetimeAttr>()) {
1272     EHStack.pushCleanup<ExtendGCLifetime>(NormalCleanup, &D);
1273   }
1274
1275   // Handle the cleanup attribute.
1276   if (const CleanupAttr *CA = D.getAttr<CleanupAttr>()) {
1277     const FunctionDecl *FD = CA->getFunctionDecl();
1278
1279     llvm::Constant *F = CGM.GetAddrOfFunction(FD);
1280     assert(F && "Could not find function!");
1281
1282     const CGFunctionInfo &Info = CGM.getTypes().arrangeFunctionDeclaration(FD);
1283     EHStack.pushCleanup<CallCleanupFunction>(NormalAndEHCleanup, F, &Info, &D);
1284   }
1285
1286   // If this is a block variable, call _Block_object_destroy
1287   // (on the unforwarded address).
1288   if (emission.IsByRef)
1289     enterByrefCleanup(emission);
1290 }
1291
1292 CodeGenFunction::Destroyer *
1293 CodeGenFunction::getDestroyer(QualType::DestructionKind kind) {
1294   switch (kind) {
1295   case QualType::DK_none: llvm_unreachable("no destroyer for trivial dtor");
1296   case QualType::DK_cxx_destructor:
1297     return destroyCXXObject;
1298   case QualType::DK_objc_strong_lifetime:
1299     return destroyARCStrongPrecise;
1300   case QualType::DK_objc_weak_lifetime:
1301     return destroyARCWeak;
1302   }
1303   llvm_unreachable("Unknown DestructionKind");
1304 }
1305
1306 /// pushEHDestroy - Push the standard destructor for the given type as
1307 /// an EH-only cleanup.
1308 void CodeGenFunction::pushEHDestroy(QualType::DestructionKind dtorKind,
1309                                   llvm::Value *addr, QualType type) {
1310   assert(dtorKind && "cannot push destructor for trivial type");
1311   assert(needsEHCleanup(dtorKind));
1312
1313   pushDestroy(EHCleanup, addr, type, getDestroyer(dtorKind), true);
1314 }
1315
1316 /// pushDestroy - Push the standard destructor for the given type as
1317 /// at least a normal cleanup.
1318 void CodeGenFunction::pushDestroy(QualType::DestructionKind dtorKind,
1319                                   llvm::Value *addr, QualType type) {
1320   assert(dtorKind && "cannot push destructor for trivial type");
1321
1322   CleanupKind cleanupKind = getCleanupKind(dtorKind);
1323   pushDestroy(cleanupKind, addr, type, getDestroyer(dtorKind),
1324               cleanupKind & EHCleanup);
1325 }
1326
1327 void CodeGenFunction::pushDestroy(CleanupKind cleanupKind, llvm::Value *addr,
1328                                   QualType type, Destroyer *destroyer,
1329                                   bool useEHCleanupForArray) {
1330   pushFullExprCleanup<DestroyObject>(cleanupKind, addr, type,
1331                                      destroyer, useEHCleanupForArray);
1332 }
1333
1334 /// emitDestroy - Immediately perform the destruction of the given
1335 /// object.
1336 ///
1337 /// \param addr - the address of the object; a type*
1338 /// \param type - the type of the object; if an array type, all
1339 ///   objects are destroyed in reverse order
1340 /// \param destroyer - the function to call to destroy individual
1341 ///   elements
1342 /// \param useEHCleanupForArray - whether an EH cleanup should be
1343 ///   used when destroying array elements, in case one of the
1344 ///   destructions throws an exception
1345 void CodeGenFunction::emitDestroy(llvm::Value *addr, QualType type,
1346                                   Destroyer *destroyer,
1347                                   bool useEHCleanupForArray) {
1348   const ArrayType *arrayType = getContext().getAsArrayType(type);
1349   if (!arrayType)
1350     return destroyer(*this, addr, type);
1351
1352   llvm::Value *begin = addr;
1353   llvm::Value *length = emitArrayLength(arrayType, type, begin);
1354
1355   // Normally we have to check whether the array is zero-length.
1356   bool checkZeroLength = true;
1357
1358   // But if the array length is constant, we can suppress that.
1359   if (llvm::ConstantInt *constLength = dyn_cast<llvm::ConstantInt>(length)) {
1360     // ...and if it's constant zero, we can just skip the entire thing.
1361     if (constLength->isZero()) return;
1362     checkZeroLength = false;
1363   }
1364
1365   llvm::Value *end = Builder.CreateInBoundsGEP(begin, length);
1366   emitArrayDestroy(begin, end, type, destroyer,
1367                    checkZeroLength, useEHCleanupForArray);
1368 }
1369
1370 /// emitArrayDestroy - Destroys all the elements of the given array,
1371 /// beginning from last to first.  The array cannot be zero-length.
1372 ///
1373 /// \param begin - a type* denoting the first element of the array
1374 /// \param end - a type* denoting one past the end of the array
1375 /// \param type - the element type of the array
1376 /// \param destroyer - the function to call to destroy elements
1377 /// \param useEHCleanup - whether to push an EH cleanup to destroy
1378 ///   the remaining elements in case the destruction of a single
1379 ///   element throws
1380 void CodeGenFunction::emitArrayDestroy(llvm::Value *begin,
1381                                        llvm::Value *end,
1382                                        QualType type,
1383                                        Destroyer *destroyer,
1384                                        bool checkZeroLength,
1385                                        bool useEHCleanup) {
1386   assert(!type->isArrayType());
1387
1388   // The basic structure here is a do-while loop, because we don't
1389   // need to check for the zero-element case.
1390   llvm::BasicBlock *bodyBB = createBasicBlock("arraydestroy.body");
1391   llvm::BasicBlock *doneBB = createBasicBlock("arraydestroy.done");
1392
1393   if (checkZeroLength) {
1394     llvm::Value *isEmpty = Builder.CreateICmpEQ(begin, end,
1395                                                 "arraydestroy.isempty");
1396     Builder.CreateCondBr(isEmpty, doneBB, bodyBB);
1397   }
1398
1399   // Enter the loop body, making that address the current address.
1400   llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1401   EmitBlock(bodyBB);
1402   llvm::PHINode *elementPast =
1403     Builder.CreatePHI(begin->getType(), 2, "arraydestroy.elementPast");
1404   elementPast->addIncoming(end, entryBB);
1405
1406   // Shift the address back by one element.
1407   llvm::Value *negativeOne = llvm::ConstantInt::get(SizeTy, -1, true);
1408   llvm::Value *element = Builder.CreateInBoundsGEP(elementPast, negativeOne,
1409                                                    "arraydestroy.element");
1410
1411   if (useEHCleanup)
1412     pushRegularPartialArrayCleanup(begin, element, type, destroyer);
1413
1414   // Perform the actual destruction there.
1415   destroyer(*this, element, type);
1416
1417   if (useEHCleanup)
1418     PopCleanupBlock();
1419
1420   // Check whether we've reached the end.
1421   llvm::Value *done = Builder.CreateICmpEQ(element, begin, "arraydestroy.done");
1422   Builder.CreateCondBr(done, doneBB, bodyBB);
1423   elementPast->addIncoming(element, Builder.GetInsertBlock());
1424
1425   // Done.
1426   EmitBlock(doneBB);
1427 }
1428
1429 /// Perform partial array destruction as if in an EH cleanup.  Unlike
1430 /// emitArrayDestroy, the element type here may still be an array type.
1431 static void emitPartialArrayDestroy(CodeGenFunction &CGF,
1432                                     llvm::Value *begin, llvm::Value *end,
1433                                     QualType type,
1434                                     CodeGenFunction::Destroyer *destroyer) {
1435   // If the element type is itself an array, drill down.
1436   unsigned arrayDepth = 0;
1437   while (const ArrayType *arrayType = CGF.getContext().getAsArrayType(type)) {
1438     // VLAs don't require a GEP index to walk into.
1439     if (!isa<VariableArrayType>(arrayType))
1440       arrayDepth++;
1441     type = arrayType->getElementType();
1442   }
1443
1444   if (arrayDepth) {
1445     llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, arrayDepth+1);
1446
1447     SmallVector<llvm::Value*,4> gepIndices(arrayDepth, zero);
1448     begin = CGF.Builder.CreateInBoundsGEP(begin, gepIndices, "pad.arraybegin");
1449     end = CGF.Builder.CreateInBoundsGEP(end, gepIndices, "pad.arrayend");
1450   }
1451
1452   // Destroy the array.  We don't ever need an EH cleanup because we
1453   // assume that we're in an EH cleanup ourselves, so a throwing
1454   // destructor causes an immediate terminate.
1455   CGF.emitArrayDestroy(begin, end, type, destroyer,
1456                        /*checkZeroLength*/ true, /*useEHCleanup*/ false);
1457 }
1458
1459 namespace {
1460   /// RegularPartialArrayDestroy - a cleanup which performs a partial
1461   /// array destroy where the end pointer is regularly determined and
1462   /// does not need to be loaded from a local.
1463   class RegularPartialArrayDestroy : public EHScopeStack::Cleanup {
1464     llvm::Value *ArrayBegin;
1465     llvm::Value *ArrayEnd;
1466     QualType ElementType;
1467     CodeGenFunction::Destroyer *Destroyer;
1468   public:
1469     RegularPartialArrayDestroy(llvm::Value *arrayBegin, llvm::Value *arrayEnd,
1470                                QualType elementType,
1471                                CodeGenFunction::Destroyer *destroyer)
1472       : ArrayBegin(arrayBegin), ArrayEnd(arrayEnd),
1473         ElementType(elementType), Destroyer(destroyer) {}
1474
1475     void Emit(CodeGenFunction &CGF, Flags flags) {
1476       emitPartialArrayDestroy(CGF, ArrayBegin, ArrayEnd,
1477                               ElementType, Destroyer);
1478     }
1479   };
1480
1481   /// IrregularPartialArrayDestroy - a cleanup which performs a
1482   /// partial array destroy where the end pointer is irregularly
1483   /// determined and must be loaded from a local.
1484   class IrregularPartialArrayDestroy : public EHScopeStack::Cleanup {
1485     llvm::Value *ArrayBegin;
1486     llvm::Value *ArrayEndPointer;
1487     QualType ElementType;
1488     CodeGenFunction::Destroyer *Destroyer;
1489   public:
1490     IrregularPartialArrayDestroy(llvm::Value *arrayBegin,
1491                                  llvm::Value *arrayEndPointer,
1492                                  QualType elementType,
1493                                  CodeGenFunction::Destroyer *destroyer)
1494       : ArrayBegin(arrayBegin), ArrayEndPointer(arrayEndPointer),
1495         ElementType(elementType), Destroyer(destroyer) {}
1496
1497     void Emit(CodeGenFunction &CGF, Flags flags) {
1498       llvm::Value *arrayEnd = CGF.Builder.CreateLoad(ArrayEndPointer);
1499       emitPartialArrayDestroy(CGF, ArrayBegin, arrayEnd,
1500                               ElementType, Destroyer);
1501     }
1502   };
1503 }
1504
1505 /// pushIrregularPartialArrayCleanup - Push an EH cleanup to destroy
1506 /// already-constructed elements of the given array.  The cleanup
1507 /// may be popped with DeactivateCleanupBlock or PopCleanupBlock.
1508 ///
1509 /// \param elementType - the immediate element type of the array;
1510 ///   possibly still an array type
1511 void CodeGenFunction::pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin,
1512                                                  llvm::Value *arrayEndPointer,
1513                                                        QualType elementType,
1514                                                        Destroyer *destroyer) {
1515   pushFullExprCleanup<IrregularPartialArrayDestroy>(EHCleanup,
1516                                                     arrayBegin, arrayEndPointer,
1517                                                     elementType, destroyer);
1518 }
1519
1520 /// pushRegularPartialArrayCleanup - Push an EH cleanup to destroy
1521 /// already-constructed elements of the given array.  The cleanup
1522 /// may be popped with DeactivateCleanupBlock or PopCleanupBlock.
1523 ///
1524 /// \param elementType - the immediate element type of the array;
1525 ///   possibly still an array type
1526 void CodeGenFunction::pushRegularPartialArrayCleanup(llvm::Value *arrayBegin,
1527                                                      llvm::Value *arrayEnd,
1528                                                      QualType elementType,
1529                                                      Destroyer *destroyer) {
1530   pushFullExprCleanup<RegularPartialArrayDestroy>(EHCleanup,
1531                                                   arrayBegin, arrayEnd,
1532                                                   elementType, destroyer);
1533 }
1534
1535 /// Lazily declare the @llvm.lifetime.start intrinsic.
1536 llvm::Constant *CodeGenModule::getLLVMLifetimeStartFn() {
1537   if (LifetimeStartFn) return LifetimeStartFn;
1538   LifetimeStartFn = llvm::Intrinsic::getDeclaration(&getModule(),
1539                                             llvm::Intrinsic::lifetime_start);
1540   return LifetimeStartFn;
1541 }
1542
1543 /// Lazily declare the @llvm.lifetime.end intrinsic.
1544 llvm::Constant *CodeGenModule::getLLVMLifetimeEndFn() {
1545   if (LifetimeEndFn) return LifetimeEndFn;
1546   LifetimeEndFn = llvm::Intrinsic::getDeclaration(&getModule(),
1547                                               llvm::Intrinsic::lifetime_end);
1548   return LifetimeEndFn;
1549 }
1550
1551 namespace {
1552   /// A cleanup to perform a release of an object at the end of a
1553   /// function.  This is used to balance out the incoming +1 of a
1554   /// ns_consumed argument when we can't reasonably do that just by
1555   /// not doing the initial retain for a __block argument.
1556   struct ConsumeARCParameter : EHScopeStack::Cleanup {
1557     ConsumeARCParameter(llvm::Value *param,
1558                         ARCPreciseLifetime_t precise)
1559       : Param(param), Precise(precise) {}
1560
1561     llvm::Value *Param;
1562     ARCPreciseLifetime_t Precise;
1563
1564     void Emit(CodeGenFunction &CGF, Flags flags) {
1565       CGF.EmitARCRelease(Param, Precise);
1566     }
1567   };
1568 }
1569
1570 /// Emit an alloca (or GlobalValue depending on target)
1571 /// for the specified parameter and set up LocalDeclMap.
1572 void CodeGenFunction::EmitParmDecl(const VarDecl &D, llvm::Value *Arg,
1573                                    unsigned ArgNo) {
1574   // FIXME: Why isn't ImplicitParamDecl a ParmVarDecl?
1575   assert((isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D)) &&
1576          "Invalid argument to EmitParmDecl");
1577
1578   Arg->setName(D.getName());
1579
1580   QualType Ty = D.getType();
1581
1582   // Use better IR generation for certain implicit parameters.
1583   if (isa<ImplicitParamDecl>(D)) {
1584     // The only implicit argument a block has is its literal.
1585     if (BlockInfo) {
1586       LocalDeclMap[&D] = Arg;
1587       llvm::Value *LocalAddr = 0;
1588       if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
1589         // Allocate a stack slot to let the debug info survive the RA.
1590         llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty),
1591                                                    D.getName() + ".addr");
1592         Alloc->setAlignment(getContext().getDeclAlign(&D).getQuantity());
1593         LValue lv = MakeAddrLValue(Alloc, Ty, getContext().getDeclAlign(&D));
1594         EmitStoreOfScalar(Arg, lv, /* isInitialization */ true);
1595         LocalAddr = Builder.CreateLoad(Alloc);
1596       }
1597
1598       if (CGDebugInfo *DI = getDebugInfo()) {
1599         if (CGM.getCodeGenOpts().getDebugInfo()
1600               >= CodeGenOptions::LimitedDebugInfo) {
1601           DI->setLocation(D.getLocation());
1602           DI->EmitDeclareOfBlockLiteralArgVariable(*BlockInfo, Arg, LocalAddr, Builder);
1603         }
1604       }
1605
1606       return;
1607     }
1608   }
1609
1610   llvm::Value *DeclPtr;
1611   // If this is an aggregate or variable sized value, reuse the input pointer.
1612   if (!Ty->isConstantSizeType() ||
1613       !CodeGenFunction::hasScalarEvaluationKind(Ty)) {
1614     DeclPtr = Arg;
1615   } else {
1616     // Otherwise, create a temporary to hold the value.
1617     llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty),
1618                                                D.getName() + ".addr");
1619     CharUnits Align = getContext().getDeclAlign(&D);
1620     Alloc->setAlignment(Align.getQuantity());
1621     DeclPtr = Alloc;
1622
1623     bool doStore = true;
1624
1625     Qualifiers qs = Ty.getQualifiers();
1626     LValue lv = MakeAddrLValue(DeclPtr, Ty, Align);
1627     if (Qualifiers::ObjCLifetime lt = qs.getObjCLifetime()) {
1628       // We honor __attribute__((ns_consumed)) for types with lifetime.
1629       // For __strong, it's handled by just skipping the initial retain;
1630       // otherwise we have to balance out the initial +1 with an extra
1631       // cleanup to do the release at the end of the function.
1632       bool isConsumed = D.hasAttr<NSConsumedAttr>();
1633
1634       // 'self' is always formally __strong, but if this is not an
1635       // init method then we don't want to retain it.
1636       if (D.isARCPseudoStrong()) {
1637         const ObjCMethodDecl *method = cast<ObjCMethodDecl>(CurCodeDecl);
1638         assert(&D == method->getSelfDecl());
1639         assert(lt == Qualifiers::OCL_Strong);
1640         assert(qs.hasConst());
1641         assert(method->getMethodFamily() != OMF_init);
1642         (void) method;
1643         lt = Qualifiers::OCL_ExplicitNone;
1644       }
1645
1646       if (lt == Qualifiers::OCL_Strong) {
1647         if (!isConsumed) {
1648           if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
1649             // use objc_storeStrong(&dest, value) for retaining the
1650             // object. But first, store a null into 'dest' because
1651             // objc_storeStrong attempts to release its old value.
1652             llvm::Value * Null = CGM.EmitNullConstant(D.getType());
1653             EmitStoreOfScalar(Null, lv, /* isInitialization */ true);
1654             EmitARCStoreStrongCall(lv.getAddress(), Arg, true);
1655             doStore = false;
1656           }
1657           else
1658           // Don't use objc_retainBlock for block pointers, because we
1659           // don't want to Block_copy something just because we got it
1660           // as a parameter.
1661             Arg = EmitARCRetainNonBlock(Arg);
1662         }
1663       } else {
1664         // Push the cleanup for a consumed parameter.
1665         if (isConsumed) {
1666           ARCPreciseLifetime_t precise = (D.hasAttr<ObjCPreciseLifetimeAttr>()
1667                                 ? ARCPreciseLifetime : ARCImpreciseLifetime);
1668           EHStack.pushCleanup<ConsumeARCParameter>(getARCCleanupKind(), Arg,
1669                                                    precise);
1670         }
1671
1672         if (lt == Qualifiers::OCL_Weak) {
1673           EmitARCInitWeak(DeclPtr, Arg);
1674           doStore = false; // The weak init is a store, no need to do two.
1675         }
1676       }
1677
1678       // Enter the cleanup scope.
1679       EmitAutoVarWithLifetime(*this, D, DeclPtr, lt);
1680     }
1681
1682     // Store the initial value into the alloca.
1683     if (doStore)
1684       EmitStoreOfScalar(Arg, lv, /* isInitialization */ true);
1685   }
1686
1687   llvm::Value *&DMEntry = LocalDeclMap[&D];
1688   assert(DMEntry == 0 && "Decl already exists in localdeclmap!");
1689   DMEntry = DeclPtr;
1690
1691   // Emit debug info for param declaration.
1692   if (CGDebugInfo *DI = getDebugInfo()) {
1693     if (CGM.getCodeGenOpts().getDebugInfo()
1694           >= CodeGenOptions::LimitedDebugInfo) {
1695       DI->EmitDeclareOfArgVariable(&D, DeclPtr, ArgNo, Builder);
1696     }
1697   }
1698
1699   if (D.hasAttr<AnnotateAttr>())
1700       EmitVarAnnotations(&D, DeclPtr);
1701 }