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