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