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