1 //===---- CGBuiltin.cpp - Emit LLVM Code for builtins ---------------------===// 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 Objective-C code as LLVM code. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "CGDebugInfo.h" 15 #include "CGObjCRuntime.h" 16 #include "CodeGenFunction.h" 17 #include "CodeGenModule.h" 18 #include "TargetInfo.h" 19 #include "clang/AST/ASTContext.h" 20 #include "clang/AST/DeclObjC.h" 21 #include "clang/AST/StmtObjC.h" 22 #include "clang/Basic/Diagnostic.h" 23 #include "llvm/ADT/STLExtras.h" 24 #include "llvm/Target/TargetData.h" 25 #include "llvm/InlineAsm.h" 26 using namespace clang; 27 using namespace CodeGen; 28 29 typedef llvm::PointerIntPair<llvm::Value*,1,bool> TryEmitResult; 30 static TryEmitResult 31 tryEmitARCRetainScalarExpr(CodeGenFunction &CGF, const Expr *e); 32 33 /// Given the address of a variable of pointer type, find the correct 34 /// null to store into it. 35 static llvm::Constant *getNullForVariable(llvm::Value *addr) { 36 llvm::Type *type = 37 cast<llvm::PointerType>(addr->getType())->getElementType(); 38 return llvm::ConstantPointerNull::get(cast<llvm::PointerType>(type)); 39 } 40 41 /// Emits an instance of NSConstantString representing the object. 42 llvm::Value *CodeGenFunction::EmitObjCStringLiteral(const ObjCStringLiteral *E) 43 { 44 llvm::Constant *C = 45 CGM.getObjCRuntime().GenerateConstantString(E->getString()); 46 // FIXME: This bitcast should just be made an invariant on the Runtime. 47 return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType())); 48 } 49 50 /// Emit a selector. 51 llvm::Value *CodeGenFunction::EmitObjCSelectorExpr(const ObjCSelectorExpr *E) { 52 // Untyped selector. 53 // Note that this implementation allows for non-constant strings to be passed 54 // as arguments to @selector(). Currently, the only thing preventing this 55 // behaviour is the type checking in the front end. 56 return CGM.getObjCRuntime().GetSelector(Builder, E->getSelector()); 57 } 58 59 llvm::Value *CodeGenFunction::EmitObjCProtocolExpr(const ObjCProtocolExpr *E) { 60 // FIXME: This should pass the Decl not the name. 61 return CGM.getObjCRuntime().GenerateProtocolRef(Builder, E->getProtocol()); 62 } 63 64 /// \brief Adjust the type of the result of an Objective-C message send 65 /// expression when the method has a related result type. 66 static RValue AdjustRelatedResultType(CodeGenFunction &CGF, 67 const Expr *E, 68 const ObjCMethodDecl *Method, 69 RValue Result) { 70 if (!Method) 71 return Result; 72 73 if (!Method->hasRelatedResultType() || 74 CGF.getContext().hasSameType(E->getType(), Method->getResultType()) || 75 !Result.isScalar()) 76 return Result; 77 78 // We have applied a related result type. Cast the rvalue appropriately. 79 return RValue::get(CGF.Builder.CreateBitCast(Result.getScalarVal(), 80 CGF.ConvertType(E->getType()))); 81 } 82 83 /// Decide whether to extend the lifetime of the receiver of a 84 /// returns-inner-pointer message. 85 static bool 86 shouldExtendReceiverForInnerPointerMessage(const ObjCMessageExpr *message) { 87 switch (message->getReceiverKind()) { 88 89 // For a normal instance message, we should extend unless the 90 // receiver is loaded from a variable with precise lifetime. 91 case ObjCMessageExpr::Instance: { 92 const Expr *receiver = message->getInstanceReceiver(); 93 const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(receiver); 94 if (!ice || ice->getCastKind() != CK_LValueToRValue) return true; 95 receiver = ice->getSubExpr()->IgnoreParens(); 96 97 // Only __strong variables. 98 if (receiver->getType().getObjCLifetime() != Qualifiers::OCL_Strong) 99 return true; 100 101 // All ivars and fields have precise lifetime. 102 if (isa<MemberExpr>(receiver) || isa<ObjCIvarRefExpr>(receiver)) 103 return false; 104 105 // Otherwise, check for variables. 106 const DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(ice->getSubExpr()); 107 if (!declRef) return true; 108 const VarDecl *var = dyn_cast<VarDecl>(declRef->getDecl()); 109 if (!var) return true; 110 111 // All variables have precise lifetime except local variables with 112 // automatic storage duration that aren't specially marked. 113 return (var->hasLocalStorage() && 114 !var->hasAttr<ObjCPreciseLifetimeAttr>()); 115 } 116 117 case ObjCMessageExpr::Class: 118 case ObjCMessageExpr::SuperClass: 119 // It's never necessary for class objects. 120 return false; 121 122 case ObjCMessageExpr::SuperInstance: 123 // We generally assume that 'self' lives throughout a method call. 124 return false; 125 } 126 127 llvm_unreachable("invalid receiver kind"); 128 } 129 130 RValue CodeGenFunction::EmitObjCMessageExpr(const ObjCMessageExpr *E, 131 ReturnValueSlot Return) { 132 // Only the lookup mechanism and first two arguments of the method 133 // implementation vary between runtimes. We can get the receiver and 134 // arguments in generic code. 135 136 bool isDelegateInit = E->isDelegateInitCall(); 137 138 const ObjCMethodDecl *method = E->getMethodDecl(); 139 140 // We don't retain the receiver in delegate init calls, and this is 141 // safe because the receiver value is always loaded from 'self', 142 // which we zero out. We don't want to Block_copy block receivers, 143 // though. 144 bool retainSelf = 145 (!isDelegateInit && 146 CGM.getLangOptions().ObjCAutoRefCount && 147 method && 148 method->hasAttr<NSConsumesSelfAttr>()); 149 150 CGObjCRuntime &Runtime = CGM.getObjCRuntime(); 151 bool isSuperMessage = false; 152 bool isClassMessage = false; 153 ObjCInterfaceDecl *OID = 0; 154 // Find the receiver 155 QualType ReceiverType; 156 llvm::Value *Receiver = 0; 157 switch (E->getReceiverKind()) { 158 case ObjCMessageExpr::Instance: 159 ReceiverType = E->getInstanceReceiver()->getType(); 160 if (retainSelf) { 161 TryEmitResult ter = tryEmitARCRetainScalarExpr(*this, 162 E->getInstanceReceiver()); 163 Receiver = ter.getPointer(); 164 if (ter.getInt()) retainSelf = false; 165 } else 166 Receiver = EmitScalarExpr(E->getInstanceReceiver()); 167 break; 168 169 case ObjCMessageExpr::Class: { 170 ReceiverType = E->getClassReceiver(); 171 const ObjCObjectType *ObjTy = ReceiverType->getAs<ObjCObjectType>(); 172 assert(ObjTy && "Invalid Objective-C class message send"); 173 OID = ObjTy->getInterface(); 174 assert(OID && "Invalid Objective-C class message send"); 175 Receiver = Runtime.GetClass(Builder, OID); 176 isClassMessage = true; 177 break; 178 } 179 180 case ObjCMessageExpr::SuperInstance: 181 ReceiverType = E->getSuperType(); 182 Receiver = LoadObjCSelf(); 183 isSuperMessage = true; 184 break; 185 186 case ObjCMessageExpr::SuperClass: 187 ReceiverType = E->getSuperType(); 188 Receiver = LoadObjCSelf(); 189 isSuperMessage = true; 190 isClassMessage = true; 191 break; 192 } 193 194 if (retainSelf) 195 Receiver = EmitARCRetainNonBlock(Receiver); 196 197 // In ARC, we sometimes want to "extend the lifetime" 198 // (i.e. retain+autorelease) of receivers of returns-inner-pointer 199 // messages. 200 if (getLangOptions().ObjCAutoRefCount && method && 201 method->hasAttr<ObjCReturnsInnerPointerAttr>() && 202 shouldExtendReceiverForInnerPointerMessage(E)) 203 Receiver = EmitARCRetainAutorelease(ReceiverType, Receiver); 204 205 QualType ResultType = 206 method ? method->getResultType() : E->getType(); 207 208 CallArgList Args; 209 EmitCallArgs(Args, method, E->arg_begin(), E->arg_end()); 210 211 // For delegate init calls in ARC, do an unsafe store of null into 212 // self. This represents the call taking direct ownership of that 213 // value. We have to do this after emitting the other call 214 // arguments because they might also reference self, but we don't 215 // have to worry about any of them modifying self because that would 216 // be an undefined read and write of an object in unordered 217 // expressions. 218 if (isDelegateInit) { 219 assert(getLangOptions().ObjCAutoRefCount && 220 "delegate init calls should only be marked in ARC"); 221 222 // Do an unsafe store of null into self. 223 llvm::Value *selfAddr = 224 LocalDeclMap[cast<ObjCMethodDecl>(CurCodeDecl)->getSelfDecl()]; 225 assert(selfAddr && "no self entry for a delegate init call?"); 226 227 Builder.CreateStore(getNullForVariable(selfAddr), selfAddr); 228 } 229 230 RValue result; 231 if (isSuperMessage) { 232 // super is only valid in an Objective-C method 233 const ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(CurFuncDecl); 234 bool isCategoryImpl = isa<ObjCCategoryImplDecl>(OMD->getDeclContext()); 235 result = Runtime.GenerateMessageSendSuper(*this, Return, ResultType, 236 E->getSelector(), 237 OMD->getClassInterface(), 238 isCategoryImpl, 239 Receiver, 240 isClassMessage, 241 Args, 242 method); 243 } else { 244 result = Runtime.GenerateMessageSend(*this, Return, ResultType, 245 E->getSelector(), 246 Receiver, Args, OID, 247 method); 248 } 249 250 // For delegate init calls in ARC, implicitly store the result of 251 // the call back into self. This takes ownership of the value. 252 if (isDelegateInit) { 253 llvm::Value *selfAddr = 254 LocalDeclMap[cast<ObjCMethodDecl>(CurCodeDecl)->getSelfDecl()]; 255 llvm::Value *newSelf = result.getScalarVal(); 256 257 // The delegate return type isn't necessarily a matching type; in 258 // fact, it's quite likely to be 'id'. 259 llvm::Type *selfTy = 260 cast<llvm::PointerType>(selfAddr->getType())->getElementType(); 261 newSelf = Builder.CreateBitCast(newSelf, selfTy); 262 263 Builder.CreateStore(newSelf, selfAddr); 264 } 265 266 return AdjustRelatedResultType(*this, E, method, result); 267 } 268 269 namespace { 270 struct FinishARCDealloc : EHScopeStack::Cleanup { 271 void Emit(CodeGenFunction &CGF, Flags flags) { 272 const ObjCMethodDecl *method = cast<ObjCMethodDecl>(CGF.CurCodeDecl); 273 274 const ObjCImplDecl *impl = cast<ObjCImplDecl>(method->getDeclContext()); 275 const ObjCInterfaceDecl *iface = impl->getClassInterface(); 276 if (!iface->getSuperClass()) return; 277 278 bool isCategory = isa<ObjCCategoryImplDecl>(impl); 279 280 // Call [super dealloc] if we have a superclass. 281 llvm::Value *self = CGF.LoadObjCSelf(); 282 283 CallArgList args; 284 CGF.CGM.getObjCRuntime().GenerateMessageSendSuper(CGF, ReturnValueSlot(), 285 CGF.getContext().VoidTy, 286 method->getSelector(), 287 iface, 288 isCategory, 289 self, 290 /*is class msg*/ false, 291 args, 292 method); 293 } 294 }; 295 } 296 297 /// StartObjCMethod - Begin emission of an ObjCMethod. This generates 298 /// the LLVM function and sets the other context used by 299 /// CodeGenFunction. 300 void CodeGenFunction::StartObjCMethod(const ObjCMethodDecl *OMD, 301 const ObjCContainerDecl *CD, 302 SourceLocation StartLoc) { 303 FunctionArgList args; 304 // Check if we should generate debug info for this method. 305 if (CGM.getModuleDebugInfo() && !OMD->hasAttr<NoDebugAttr>()) 306 DebugInfo = CGM.getModuleDebugInfo(); 307 308 llvm::Function *Fn = CGM.getObjCRuntime().GenerateMethod(OMD, CD); 309 310 const CGFunctionInfo &FI = CGM.getTypes().getFunctionInfo(OMD); 311 CGM.SetInternalFunctionAttributes(OMD, Fn, FI); 312 313 args.push_back(OMD->getSelfDecl()); 314 args.push_back(OMD->getCmdDecl()); 315 316 for (ObjCMethodDecl::param_const_iterator PI = OMD->param_begin(), 317 E = OMD->param_end(); PI != E; ++PI) 318 args.push_back(*PI); 319 320 CurGD = OMD; 321 322 StartFunction(OMD, OMD->getResultType(), Fn, FI, args, StartLoc); 323 324 // In ARC, certain methods get an extra cleanup. 325 if (CGM.getLangOptions().ObjCAutoRefCount && 326 OMD->isInstanceMethod() && 327 OMD->getSelector().isUnarySelector()) { 328 const IdentifierInfo *ident = 329 OMD->getSelector().getIdentifierInfoForSlot(0); 330 if (ident->isStr("dealloc")) 331 EHStack.pushCleanup<FinishARCDealloc>(getARCCleanupKind()); 332 } 333 } 334 335 static llvm::Value *emitARCRetainLoadOfScalar(CodeGenFunction &CGF, 336 LValue lvalue, QualType type); 337 338 /// Generate an Objective-C method. An Objective-C method is a C function with 339 /// its pointer, name, and types registered in the class struture. 340 void CodeGenFunction::GenerateObjCMethod(const ObjCMethodDecl *OMD) { 341 StartObjCMethod(OMD, OMD->getClassInterface(), OMD->getLocStart()); 342 EmitStmt(OMD->getBody()); 343 FinishFunction(OMD->getBodyRBrace()); 344 } 345 346 /// emitStructGetterCall - Call the runtime function to load a property 347 /// into the return value slot. 348 static void emitStructGetterCall(CodeGenFunction &CGF, ObjCIvarDecl *ivar, 349 bool isAtomic, bool hasStrong) { 350 ASTContext &Context = CGF.getContext(); 351 352 llvm::Value *src = 353 CGF.EmitLValueForIvar(CGF.TypeOfSelfObject(), CGF.LoadObjCSelf(), 354 ivar, 0).getAddress(); 355 356 // objc_copyStruct (ReturnValue, &structIvar, 357 // sizeof (Type of Ivar), isAtomic, false); 358 CallArgList args; 359 360 llvm::Value *dest = CGF.Builder.CreateBitCast(CGF.ReturnValue, CGF.VoidPtrTy); 361 args.add(RValue::get(dest), Context.VoidPtrTy); 362 363 src = CGF.Builder.CreateBitCast(src, CGF.VoidPtrTy); 364 args.add(RValue::get(src), Context.VoidPtrTy); 365 366 CharUnits size = CGF.getContext().getTypeSizeInChars(ivar->getType()); 367 args.add(RValue::get(CGF.CGM.getSize(size)), Context.getSizeType()); 368 args.add(RValue::get(CGF.Builder.getInt1(isAtomic)), Context.BoolTy); 369 args.add(RValue::get(CGF.Builder.getInt1(hasStrong)), Context.BoolTy); 370 371 llvm::Value *fn = CGF.CGM.getObjCRuntime().GetGetStructFunction(); 372 CGF.EmitCall(CGF.getTypes().getFunctionInfo(Context.VoidTy, args, 373 FunctionType::ExtInfo()), 374 fn, ReturnValueSlot(), args); 375 } 376 377 /// Determine whether the given architecture supports unaligned atomic 378 /// accesses. They don't have to be fast, just faster than a function 379 /// call and a mutex. 380 static bool hasUnalignedAtomics(llvm::Triple::ArchType arch) { 381 // FIXME: Allow unaligned atomic load/store on x86. (It is not 382 // currently supported by the backend.) 383 return 0; 384 } 385 386 /// Return the maximum size that permits atomic accesses for the given 387 /// architecture. 388 static CharUnits getMaxAtomicAccessSize(CodeGenModule &CGM, 389 llvm::Triple::ArchType arch) { 390 // ARM has 8-byte atomic accesses, but it's not clear whether we 391 // want to rely on them here. 392 393 // In the default case, just assume that any size up to a pointer is 394 // fine given adequate alignment. 395 return CharUnits::fromQuantity(CGM.PointerSizeInBytes); 396 } 397 398 namespace { 399 class PropertyImplStrategy { 400 public: 401 enum StrategyKind { 402 /// The 'native' strategy is to use the architecture's provided 403 /// reads and writes. 404 Native, 405 406 /// Use objc_setProperty and objc_getProperty. 407 GetSetProperty, 408 409 /// Use objc_setProperty for the setter, but use expression 410 /// evaluation for the getter. 411 SetPropertyAndExpressionGet, 412 413 /// Use objc_copyStruct. 414 CopyStruct, 415 416 /// The 'expression' strategy is to emit normal assignment or 417 /// lvalue-to-rvalue expressions. 418 Expression 419 }; 420 421 StrategyKind getKind() const { return StrategyKind(Kind); } 422 423 bool hasStrongMember() const { return HasStrong; } 424 bool isAtomic() const { return IsAtomic; } 425 bool isCopy() const { return IsCopy; } 426 427 CharUnits getIvarSize() const { return IvarSize; } 428 CharUnits getIvarAlignment() const { return IvarAlignment; } 429 430 PropertyImplStrategy(CodeGenModule &CGM, 431 const ObjCPropertyImplDecl *propImpl); 432 433 private: 434 unsigned Kind : 8; 435 unsigned IsAtomic : 1; 436 unsigned IsCopy : 1; 437 unsigned HasStrong : 1; 438 439 CharUnits IvarSize; 440 CharUnits IvarAlignment; 441 }; 442 } 443 444 /// Pick an implementation strategy for the the given property synthesis. 445 PropertyImplStrategy::PropertyImplStrategy(CodeGenModule &CGM, 446 const ObjCPropertyImplDecl *propImpl) { 447 const ObjCPropertyDecl *prop = propImpl->getPropertyDecl(); 448 ObjCPropertyDecl::SetterKind setterKind = prop->getSetterKind(); 449 450 IsCopy = (setterKind == ObjCPropertyDecl::Copy); 451 IsAtomic = prop->isAtomic(); 452 HasStrong = false; // doesn't matter here. 453 454 // Evaluate the ivar's size and alignment. 455 ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl(); 456 QualType ivarType = ivar->getType(); 457 llvm::tie(IvarSize, IvarAlignment) 458 = CGM.getContext().getTypeInfoInChars(ivarType); 459 460 // If we have a copy property, we always have to use getProperty/setProperty. 461 // TODO: we could actually use setProperty and an expression for non-atomics. 462 if (IsCopy) { 463 Kind = GetSetProperty; 464 return; 465 } 466 467 // Handle retain. 468 if (setterKind == ObjCPropertyDecl::Retain) { 469 // In GC-only, there's nothing special that needs to be done. 470 if (CGM.getLangOptions().getGC() == LangOptions::GCOnly) { 471 // fallthrough 472 473 // In ARC, if the property is non-atomic, use expression emission, 474 // which translates to objc_storeStrong. This isn't required, but 475 // it's slightly nicer. 476 } else if (CGM.getLangOptions().ObjCAutoRefCount && !IsAtomic) { 477 Kind = Expression; 478 return; 479 480 // Otherwise, we need to at least use setProperty. However, if 481 // the property isn't atomic, we can use normal expression 482 // emission for the getter. 483 } else if (!IsAtomic) { 484 Kind = SetPropertyAndExpressionGet; 485 return; 486 487 // Otherwise, we have to use both setProperty and getProperty. 488 } else { 489 Kind = GetSetProperty; 490 return; 491 } 492 } 493 494 // If we're not atomic, just use expression accesses. 495 if (!IsAtomic) { 496 Kind = Expression; 497 return; 498 } 499 500 // Properties on bitfield ivars need to be emitted using expression 501 // accesses even if they're nominally atomic. 502 if (ivar->isBitField()) { 503 Kind = Expression; 504 return; 505 } 506 507 // GC-qualified or ARC-qualified ivars need to be emitted as 508 // expressions. This actually works out to being atomic anyway, 509 // except for ARC __strong, but that should trigger the above code. 510 if (ivarType.hasNonTrivialObjCLifetime() || 511 (CGM.getLangOptions().getGC() && 512 CGM.getContext().getObjCGCAttrKind(ivarType))) { 513 Kind = Expression; 514 return; 515 } 516 517 // Compute whether the ivar has strong members. 518 if (CGM.getLangOptions().getGC()) 519 if (const RecordType *recordType = ivarType->getAs<RecordType>()) 520 HasStrong = recordType->getDecl()->hasObjectMember(); 521 522 // We can never access structs with object members with a native 523 // access, because we need to use write barriers. This is what 524 // objc_copyStruct is for. 525 if (HasStrong) { 526 Kind = CopyStruct; 527 return; 528 } 529 530 // Otherwise, this is target-dependent and based on the size and 531 // alignment of the ivar. 532 533 // If the size of the ivar is not a power of two, give up. We don't 534 // want to get into the business of doing compare-and-swaps. 535 if (!IvarSize.isPowerOfTwo()) { 536 Kind = CopyStruct; 537 return; 538 } 539 540 llvm::Triple::ArchType arch = 541 CGM.getContext().getTargetInfo().getTriple().getArch(); 542 543 // Most architectures require memory to fit within a single cache 544 // line, so the alignment has to be at least the size of the access. 545 // Otherwise we have to grab a lock. 546 if (IvarAlignment < IvarSize && !hasUnalignedAtomics(arch)) { 547 Kind = CopyStruct; 548 return; 549 } 550 551 // If the ivar's size exceeds the architecture's maximum atomic 552 // access size, we have to use CopyStruct. 553 if (IvarSize > getMaxAtomicAccessSize(CGM, arch)) { 554 Kind = CopyStruct; 555 return; 556 } 557 558 // Otherwise, we can use native loads and stores. 559 Kind = Native; 560 } 561 562 /// GenerateObjCGetter - Generate an Objective-C property getter 563 /// function. The given Decl must be an ObjCImplementationDecl. @synthesize 564 /// is illegal within a category. 565 void CodeGenFunction::GenerateObjCGetter(ObjCImplementationDecl *IMP, 566 const ObjCPropertyImplDecl *PID) { 567 const ObjCPropertyDecl *PD = PID->getPropertyDecl(); 568 ObjCMethodDecl *OMD = PD->getGetterMethodDecl(); 569 assert(OMD && "Invalid call to generate getter (empty method)"); 570 StartObjCMethod(OMD, IMP->getClassInterface(), PID->getLocStart()); 571 572 generateObjCGetterBody(IMP, PID); 573 574 FinishFunction(); 575 } 576 577 static bool hasTrivialGetExpr(const ObjCPropertyImplDecl *propImpl) { 578 const Expr *getter = propImpl->getGetterCXXConstructor(); 579 if (!getter) return true; 580 581 // Sema only makes only of these when the ivar has a C++ class type, 582 // so the form is pretty constrained. 583 584 // If the property has a reference type, we might just be binding a 585 // reference, in which case the result will be a gl-value. We should 586 // treat this as a non-trivial operation. 587 if (getter->isGLValue()) 588 return false; 589 590 // If we selected a trivial copy-constructor, we're okay. 591 if (const CXXConstructExpr *construct = dyn_cast<CXXConstructExpr>(getter)) 592 return (construct->getConstructor()->isTrivial()); 593 594 // The constructor might require cleanups (in which case it's never 595 // trivial). 596 assert(isa<ExprWithCleanups>(getter)); 597 return false; 598 } 599 600 void 601 CodeGenFunction::generateObjCGetterBody(const ObjCImplementationDecl *classImpl, 602 const ObjCPropertyImplDecl *propImpl) { 603 // If there's a non-trivial 'get' expression, we just have to emit that. 604 if (!hasTrivialGetExpr(propImpl)) { 605 ReturnStmt ret(SourceLocation(), propImpl->getGetterCXXConstructor(), 606 /*nrvo*/ 0); 607 EmitReturnStmt(ret); 608 return; 609 } 610 611 const ObjCPropertyDecl *prop = propImpl->getPropertyDecl(); 612 QualType propType = prop->getType(); 613 ObjCMethodDecl *getterMethod = prop->getGetterMethodDecl(); 614 615 ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl(); 616 617 // Pick an implementation strategy. 618 PropertyImplStrategy strategy(CGM, propImpl); 619 switch (strategy.getKind()) { 620 case PropertyImplStrategy::Native: { 621 LValue LV = EmitLValueForIvar(TypeOfSelfObject(), LoadObjCSelf(), ivar, 0); 622 623 // Currently, all atomic accesses have to be through integer 624 // types, so there's no point in trying to pick a prettier type. 625 llvm::Type *bitcastType = 626 llvm::Type::getIntNTy(getLLVMContext(), 627 getContext().toBits(strategy.getIvarSize())); 628 bitcastType = bitcastType->getPointerTo(); // addrspace 0 okay 629 630 // Perform an atomic load. This does not impose ordering constraints. 631 llvm::Value *ivarAddr = LV.getAddress(); 632 ivarAddr = Builder.CreateBitCast(ivarAddr, bitcastType); 633 llvm::LoadInst *load = Builder.CreateLoad(ivarAddr, "load"); 634 load->setAlignment(strategy.getIvarAlignment().getQuantity()); 635 load->setAtomic(llvm::Unordered); 636 637 // Store that value into the return address. Doing this with a 638 // bitcast is likely to produce some pretty ugly IR, but it's not 639 // the *most* terrible thing in the world. 640 Builder.CreateStore(load, Builder.CreateBitCast(ReturnValue, bitcastType)); 641 642 // Make sure we don't do an autorelease. 643 AutoreleaseResult = false; 644 return; 645 } 646 647 case PropertyImplStrategy::GetSetProperty: { 648 llvm::Value *getPropertyFn = 649 CGM.getObjCRuntime().GetPropertyGetFunction(); 650 if (!getPropertyFn) { 651 CGM.ErrorUnsupported(propImpl, "Obj-C getter requiring atomic copy"); 652 return; 653 } 654 655 // Return (ivar-type) objc_getProperty((id) self, _cmd, offset, true). 656 // FIXME: Can't this be simpler? This might even be worse than the 657 // corresponding gcc code. 658 llvm::Value *cmd = 659 Builder.CreateLoad(LocalDeclMap[getterMethod->getCmdDecl()], "cmd"); 660 llvm::Value *self = Builder.CreateBitCast(LoadObjCSelf(), VoidPtrTy); 661 llvm::Value *ivarOffset = 662 EmitIvarOffset(classImpl->getClassInterface(), ivar); 663 664 CallArgList args; 665 args.add(RValue::get(self), getContext().getObjCIdType()); 666 args.add(RValue::get(cmd), getContext().getObjCSelType()); 667 args.add(RValue::get(ivarOffset), getContext().getPointerDiffType()); 668 args.add(RValue::get(Builder.getInt1(strategy.isAtomic())), 669 getContext().BoolTy); 670 671 // FIXME: We shouldn't need to get the function info here, the 672 // runtime already should have computed it to build the function. 673 RValue RV = EmitCall(getTypes().getFunctionInfo(propType, args, 674 FunctionType::ExtInfo()), 675 getPropertyFn, ReturnValueSlot(), args); 676 677 // We need to fix the type here. Ivars with copy & retain are 678 // always objects so we don't need to worry about complex or 679 // aggregates. 680 RV = RValue::get(Builder.CreateBitCast(RV.getScalarVal(), 681 getTypes().ConvertType(propType))); 682 683 EmitReturnOfRValue(RV, propType); 684 685 // objc_getProperty does an autorelease, so we should suppress ours. 686 AutoreleaseResult = false; 687 688 return; 689 } 690 691 case PropertyImplStrategy::CopyStruct: 692 emitStructGetterCall(*this, ivar, strategy.isAtomic(), 693 strategy.hasStrongMember()); 694 return; 695 696 case PropertyImplStrategy::Expression: 697 case PropertyImplStrategy::SetPropertyAndExpressionGet: { 698 LValue LV = EmitLValueForIvar(TypeOfSelfObject(), LoadObjCSelf(), ivar, 0); 699 700 QualType ivarType = ivar->getType(); 701 if (ivarType->isAnyComplexType()) { 702 ComplexPairTy pair = LoadComplexFromAddr(LV.getAddress(), 703 LV.isVolatileQualified()); 704 StoreComplexToAddr(pair, ReturnValue, LV.isVolatileQualified()); 705 } else if (hasAggregateLLVMType(ivarType)) { 706 // The return value slot is guaranteed to not be aliased, but 707 // that's not necessarily the same as "on the stack", so 708 // we still potentially need objc_memmove_collectable. 709 EmitAggregateCopy(ReturnValue, LV.getAddress(), ivarType); 710 } else { 711 llvm::Value *value; 712 if (propType->isReferenceType()) { 713 value = LV.getAddress(); 714 } else { 715 // We want to load and autoreleaseReturnValue ARC __weak ivars. 716 if (LV.getQuals().getObjCLifetime() == Qualifiers::OCL_Weak) { 717 value = emitARCRetainLoadOfScalar(*this, LV, ivarType); 718 719 // Otherwise we want to do a simple load, suppressing the 720 // final autorelease. 721 } else { 722 value = EmitLoadOfLValue(LV).getScalarVal(); 723 AutoreleaseResult = false; 724 } 725 726 value = Builder.CreateBitCast(value, ConvertType(propType)); 727 } 728 729 EmitReturnOfRValue(RValue::get(value), propType); 730 } 731 return; 732 } 733 734 } 735 llvm_unreachable("bad @property implementation strategy!"); 736 } 737 738 /// emitStructSetterCall - Call the runtime function to store the value 739 /// from the first formal parameter into the given ivar. 740 static void emitStructSetterCall(CodeGenFunction &CGF, ObjCMethodDecl *OMD, 741 ObjCIvarDecl *ivar) { 742 // objc_copyStruct (&structIvar, &Arg, 743 // sizeof (struct something), true, false); 744 CallArgList args; 745 746 // The first argument is the address of the ivar. 747 llvm::Value *ivarAddr = CGF.EmitLValueForIvar(CGF.TypeOfSelfObject(), 748 CGF.LoadObjCSelf(), ivar, 0) 749 .getAddress(); 750 ivarAddr = CGF.Builder.CreateBitCast(ivarAddr, CGF.Int8PtrTy); 751 args.add(RValue::get(ivarAddr), CGF.getContext().VoidPtrTy); 752 753 // The second argument is the address of the parameter variable. 754 ParmVarDecl *argVar = *OMD->param_begin(); 755 DeclRefExpr argRef(argVar, argVar->getType(), VK_LValue, SourceLocation()); 756 llvm::Value *argAddr = CGF.EmitLValue(&argRef).getAddress(); 757 argAddr = CGF.Builder.CreateBitCast(argAddr, CGF.Int8PtrTy); 758 args.add(RValue::get(argAddr), CGF.getContext().VoidPtrTy); 759 760 // The third argument is the sizeof the type. 761 llvm::Value *size = 762 CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(ivar->getType())); 763 args.add(RValue::get(size), CGF.getContext().getSizeType()); 764 765 // The fourth argument is the 'isAtomic' flag. 766 args.add(RValue::get(CGF.Builder.getTrue()), CGF.getContext().BoolTy); 767 768 // The fifth argument is the 'hasStrong' flag. 769 // FIXME: should this really always be false? 770 args.add(RValue::get(CGF.Builder.getFalse()), CGF.getContext().BoolTy); 771 772 llvm::Value *copyStructFn = CGF.CGM.getObjCRuntime().GetSetStructFunction(); 773 CGF.EmitCall(CGF.getTypes().getFunctionInfo(CGF.getContext().VoidTy, args, 774 FunctionType::ExtInfo()), 775 copyStructFn, ReturnValueSlot(), args); 776 } 777 778 static bool hasTrivialSetExpr(const ObjCPropertyImplDecl *PID) { 779 Expr *setter = PID->getSetterCXXAssignment(); 780 if (!setter) return true; 781 782 // Sema only makes only of these when the ivar has a C++ class type, 783 // so the form is pretty constrained. 784 785 // An operator call is trivial if the function it calls is trivial. 786 // This also implies that there's nothing non-trivial going on with 787 // the arguments, because operator= can only be trivial if it's a 788 // synthesized assignment operator and therefore both parameters are 789 // references. 790 if (CallExpr *call = dyn_cast<CallExpr>(setter)) { 791 if (const FunctionDecl *callee 792 = dyn_cast_or_null<FunctionDecl>(call->getCalleeDecl())) 793 if (callee->isTrivial()) 794 return true; 795 return false; 796 } 797 798 assert(isa<ExprWithCleanups>(setter)); 799 return false; 800 } 801 802 void 803 CodeGenFunction::generateObjCSetterBody(const ObjCImplementationDecl *classImpl, 804 const ObjCPropertyImplDecl *propImpl) { 805 // Just use the setter expression if Sema gave us one and it's 806 // non-trivial. There's no way to do this atomically. 807 if (!hasTrivialSetExpr(propImpl)) { 808 EmitStmt(propImpl->getSetterCXXAssignment()); 809 return; 810 } 811 812 const ObjCPropertyDecl *prop = propImpl->getPropertyDecl(); 813 ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl(); 814 ObjCMethodDecl *setterMethod = prop->getSetterMethodDecl(); 815 816 PropertyImplStrategy strategy(CGM, propImpl); 817 switch (strategy.getKind()) { 818 case PropertyImplStrategy::Native: { 819 llvm::Value *argAddr = LocalDeclMap[*setterMethod->param_begin()]; 820 821 LValue ivarLValue = 822 EmitLValueForIvar(TypeOfSelfObject(), LoadObjCSelf(), ivar, /*quals*/ 0); 823 llvm::Value *ivarAddr = ivarLValue.getAddress(); 824 825 // Currently, all atomic accesses have to be through integer 826 // types, so there's no point in trying to pick a prettier type. 827 llvm::Type *bitcastType = 828 llvm::Type::getIntNTy(getLLVMContext(), 829 getContext().toBits(strategy.getIvarSize())); 830 bitcastType = bitcastType->getPointerTo(); // addrspace 0 okay 831 832 // Cast both arguments to the chosen operation type. 833 argAddr = Builder.CreateBitCast(argAddr, bitcastType); 834 ivarAddr = Builder.CreateBitCast(ivarAddr, bitcastType); 835 836 // This bitcast load is likely to cause some nasty IR. 837 llvm::Value *load = Builder.CreateLoad(argAddr); 838 839 // Perform an atomic store. There are no memory ordering requirements. 840 llvm::StoreInst *store = Builder.CreateStore(load, ivarAddr); 841 store->setAlignment(strategy.getIvarAlignment().getQuantity()); 842 store->setAtomic(llvm::Unordered); 843 return; 844 } 845 846 case PropertyImplStrategy::GetSetProperty: 847 case PropertyImplStrategy::SetPropertyAndExpressionGet: { 848 llvm::Value *setPropertyFn = 849 CGM.getObjCRuntime().GetPropertySetFunction(); 850 if (!setPropertyFn) { 851 CGM.ErrorUnsupported(propImpl, "Obj-C setter requiring atomic copy"); 852 return; 853 } 854 855 // Emit objc_setProperty((id) self, _cmd, offset, arg, 856 // <is-atomic>, <is-copy>). 857 llvm::Value *cmd = 858 Builder.CreateLoad(LocalDeclMap[setterMethod->getCmdDecl()]); 859 llvm::Value *self = 860 Builder.CreateBitCast(LoadObjCSelf(), VoidPtrTy); 861 llvm::Value *ivarOffset = 862 EmitIvarOffset(classImpl->getClassInterface(), ivar); 863 llvm::Value *arg = LocalDeclMap[*setterMethod->param_begin()]; 864 arg = Builder.CreateBitCast(Builder.CreateLoad(arg, "arg"), VoidPtrTy); 865 866 CallArgList args; 867 args.add(RValue::get(self), getContext().getObjCIdType()); 868 args.add(RValue::get(cmd), getContext().getObjCSelType()); 869 args.add(RValue::get(ivarOffset), getContext().getPointerDiffType()); 870 args.add(RValue::get(arg), getContext().getObjCIdType()); 871 args.add(RValue::get(Builder.getInt1(strategy.isAtomic())), 872 getContext().BoolTy); 873 args.add(RValue::get(Builder.getInt1(strategy.isCopy())), 874 getContext().BoolTy); 875 // FIXME: We shouldn't need to get the function info here, the runtime 876 // already should have computed it to build the function. 877 EmitCall(getTypes().getFunctionInfo(getContext().VoidTy, args, 878 FunctionType::ExtInfo()), 879 setPropertyFn, ReturnValueSlot(), args); 880 return; 881 } 882 883 case PropertyImplStrategy::CopyStruct: 884 emitStructSetterCall(*this, setterMethod, ivar); 885 return; 886 887 case PropertyImplStrategy::Expression: 888 break; 889 } 890 891 // Otherwise, fake up some ASTs and emit a normal assignment. 892 ValueDecl *selfDecl = setterMethod->getSelfDecl(); 893 DeclRefExpr self(selfDecl, selfDecl->getType(), VK_LValue, SourceLocation()); 894 ImplicitCastExpr selfLoad(ImplicitCastExpr::OnStack, 895 selfDecl->getType(), CK_LValueToRValue, &self, 896 VK_RValue); 897 ObjCIvarRefExpr ivarRef(ivar, ivar->getType().getNonReferenceType(), 898 SourceLocation(), &selfLoad, true, true); 899 900 ParmVarDecl *argDecl = *setterMethod->param_begin(); 901 QualType argType = argDecl->getType().getNonReferenceType(); 902 DeclRefExpr arg(argDecl, argType, VK_LValue, SourceLocation()); 903 ImplicitCastExpr argLoad(ImplicitCastExpr::OnStack, 904 argType.getUnqualifiedType(), CK_LValueToRValue, 905 &arg, VK_RValue); 906 907 // The property type can differ from the ivar type in some situations with 908 // Objective-C pointer types, we can always bit cast the RHS in these cases. 909 // The following absurdity is just to ensure well-formed IR. 910 CastKind argCK = CK_NoOp; 911 if (ivarRef.getType()->isObjCObjectPointerType()) { 912 if (argLoad.getType()->isObjCObjectPointerType()) 913 argCK = CK_BitCast; 914 else if (argLoad.getType()->isBlockPointerType()) 915 argCK = CK_BlockPointerToObjCPointerCast; 916 else 917 argCK = CK_CPointerToObjCPointerCast; 918 } else if (ivarRef.getType()->isBlockPointerType()) { 919 if (argLoad.getType()->isBlockPointerType()) 920 argCK = CK_BitCast; 921 else 922 argCK = CK_AnyPointerToBlockPointerCast; 923 } else if (ivarRef.getType()->isPointerType()) { 924 argCK = CK_BitCast; 925 } 926 ImplicitCastExpr argCast(ImplicitCastExpr::OnStack, 927 ivarRef.getType(), argCK, &argLoad, 928 VK_RValue); 929 Expr *finalArg = &argLoad; 930 if (!getContext().hasSameUnqualifiedType(ivarRef.getType(), 931 argLoad.getType())) 932 finalArg = &argCast; 933 934 935 BinaryOperator assign(&ivarRef, finalArg, BO_Assign, 936 ivarRef.getType(), VK_RValue, OK_Ordinary, 937 SourceLocation()); 938 EmitStmt(&assign); 939 } 940 941 /// GenerateObjCSetter - Generate an Objective-C property setter 942 /// function. The given Decl must be an ObjCImplementationDecl. @synthesize 943 /// is illegal within a category. 944 void CodeGenFunction::GenerateObjCSetter(ObjCImplementationDecl *IMP, 945 const ObjCPropertyImplDecl *PID) { 946 const ObjCPropertyDecl *PD = PID->getPropertyDecl(); 947 ObjCMethodDecl *OMD = PD->getSetterMethodDecl(); 948 assert(OMD && "Invalid call to generate setter (empty method)"); 949 StartObjCMethod(OMD, IMP->getClassInterface(), PID->getLocStart()); 950 951 generateObjCSetterBody(IMP, PID); 952 953 FinishFunction(); 954 } 955 956 namespace { 957 struct DestroyIvar : EHScopeStack::Cleanup { 958 private: 959 llvm::Value *addr; 960 const ObjCIvarDecl *ivar; 961 CodeGenFunction::Destroyer &destroyer; 962 bool useEHCleanupForArray; 963 public: 964 DestroyIvar(llvm::Value *addr, const ObjCIvarDecl *ivar, 965 CodeGenFunction::Destroyer *destroyer, 966 bool useEHCleanupForArray) 967 : addr(addr), ivar(ivar), destroyer(*destroyer), 968 useEHCleanupForArray(useEHCleanupForArray) {} 969 970 void Emit(CodeGenFunction &CGF, Flags flags) { 971 LValue lvalue 972 = CGF.EmitLValueForIvar(CGF.TypeOfSelfObject(), addr, ivar, /*CVR*/ 0); 973 CGF.emitDestroy(lvalue.getAddress(), ivar->getType(), destroyer, 974 flags.isForNormalCleanup() && useEHCleanupForArray); 975 } 976 }; 977 } 978 979 /// Like CodeGenFunction::destroyARCStrong, but do it with a call. 980 static void destroyARCStrongWithStore(CodeGenFunction &CGF, 981 llvm::Value *addr, 982 QualType type) { 983 llvm::Value *null = getNullForVariable(addr); 984 CGF.EmitARCStoreStrongCall(addr, null, /*ignored*/ true); 985 } 986 987 static void emitCXXDestructMethod(CodeGenFunction &CGF, 988 ObjCImplementationDecl *impl) { 989 CodeGenFunction::RunCleanupsScope scope(CGF); 990 991 llvm::Value *self = CGF.LoadObjCSelf(); 992 993 const ObjCInterfaceDecl *iface = impl->getClassInterface(); 994 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin(); 995 ivar; ivar = ivar->getNextIvar()) { 996 QualType type = ivar->getType(); 997 998 // Check whether the ivar is a destructible type. 999 QualType::DestructionKind dtorKind = type.isDestructedType(); 1000 if (!dtorKind) continue; 1001 1002 CodeGenFunction::Destroyer *destroyer = 0; 1003 1004 // Use a call to objc_storeStrong to destroy strong ivars, for the 1005 // general benefit of the tools. 1006 if (dtorKind == QualType::DK_objc_strong_lifetime) { 1007 destroyer = &destroyARCStrongWithStore; 1008 1009 // Otherwise use the default for the destruction kind. 1010 } else { 1011 destroyer = &CGF.getDestroyer(dtorKind); 1012 } 1013 1014 CleanupKind cleanupKind = CGF.getCleanupKind(dtorKind); 1015 1016 CGF.EHStack.pushCleanup<DestroyIvar>(cleanupKind, self, ivar, destroyer, 1017 cleanupKind & EHCleanup); 1018 } 1019 1020 assert(scope.requiresCleanups() && "nothing to do in .cxx_destruct?"); 1021 } 1022 1023 void CodeGenFunction::GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, 1024 ObjCMethodDecl *MD, 1025 bool ctor) { 1026 MD->createImplicitParams(CGM.getContext(), IMP->getClassInterface()); 1027 StartObjCMethod(MD, IMP->getClassInterface(), MD->getLocStart()); 1028 1029 // Emit .cxx_construct. 1030 if (ctor) { 1031 // Suppress the final autorelease in ARC. 1032 AutoreleaseResult = false; 1033 1034 SmallVector<CXXCtorInitializer *, 8> IvarInitializers; 1035 for (ObjCImplementationDecl::init_const_iterator B = IMP->init_begin(), 1036 E = IMP->init_end(); B != E; ++B) { 1037 CXXCtorInitializer *IvarInit = (*B); 1038 FieldDecl *Field = IvarInit->getAnyMember(); 1039 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(Field); 1040 LValue LV = EmitLValueForIvar(TypeOfSelfObject(), 1041 LoadObjCSelf(), Ivar, 0); 1042 EmitAggExpr(IvarInit->getInit(), 1043 AggValueSlot::forLValue(LV, AggValueSlot::IsDestructed, 1044 AggValueSlot::DoesNotNeedGCBarriers, 1045 AggValueSlot::IsNotAliased)); 1046 } 1047 // constructor returns 'self'. 1048 CodeGenTypes &Types = CGM.getTypes(); 1049 QualType IdTy(CGM.getContext().getObjCIdType()); 1050 llvm::Value *SelfAsId = 1051 Builder.CreateBitCast(LoadObjCSelf(), Types.ConvertType(IdTy)); 1052 EmitReturnOfRValue(RValue::get(SelfAsId), IdTy); 1053 1054 // Emit .cxx_destruct. 1055 } else { 1056 emitCXXDestructMethod(*this, IMP); 1057 } 1058 FinishFunction(); 1059 } 1060 1061 bool CodeGenFunction::IndirectObjCSetterArg(const CGFunctionInfo &FI) { 1062 CGFunctionInfo::const_arg_iterator it = FI.arg_begin(); 1063 it++; it++; 1064 const ABIArgInfo &AI = it->info; 1065 // FIXME. Is this sufficient check? 1066 return (AI.getKind() == ABIArgInfo::Indirect); 1067 } 1068 1069 bool CodeGenFunction::IvarTypeWithAggrGCObjects(QualType Ty) { 1070 if (CGM.getLangOptions().getGC() == LangOptions::NonGC) 1071 return false; 1072 if (const RecordType *FDTTy = Ty.getTypePtr()->getAs<RecordType>()) 1073 return FDTTy->getDecl()->hasObjectMember(); 1074 return false; 1075 } 1076 1077 llvm::Value *CodeGenFunction::LoadObjCSelf() { 1078 const ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(CurFuncDecl); 1079 return Builder.CreateLoad(LocalDeclMap[OMD->getSelfDecl()], "self"); 1080 } 1081 1082 QualType CodeGenFunction::TypeOfSelfObject() { 1083 const ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(CurFuncDecl); 1084 ImplicitParamDecl *selfDecl = OMD->getSelfDecl(); 1085 const ObjCObjectPointerType *PTy = cast<ObjCObjectPointerType>( 1086 getContext().getCanonicalType(selfDecl->getType())); 1087 return PTy->getPointeeType(); 1088 } 1089 1090 LValue 1091 CodeGenFunction::EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E) { 1092 // This is a special l-value that just issues sends when we load or 1093 // store through it. 1094 1095 // For certain base kinds, we need to emit the base immediately. 1096 llvm::Value *Base; 1097 if (E->isSuperReceiver()) 1098 Base = LoadObjCSelf(); 1099 else if (E->isClassReceiver()) 1100 Base = CGM.getObjCRuntime().GetClass(Builder, E->getClassReceiver()); 1101 else 1102 Base = EmitScalarExpr(E->getBase()); 1103 return LValue::MakePropertyRef(E, Base); 1104 } 1105 1106 static RValue GenerateMessageSendSuper(CodeGenFunction &CGF, 1107 ReturnValueSlot Return, 1108 QualType ResultType, 1109 Selector S, 1110 llvm::Value *Receiver, 1111 const CallArgList &CallArgs) { 1112 const ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(CGF.CurFuncDecl); 1113 bool isClassMessage = OMD->isClassMethod(); 1114 bool isCategoryImpl = isa<ObjCCategoryImplDecl>(OMD->getDeclContext()); 1115 return CGF.CGM.getObjCRuntime() 1116 .GenerateMessageSendSuper(CGF, Return, ResultType, 1117 S, OMD->getClassInterface(), 1118 isCategoryImpl, Receiver, 1119 isClassMessage, CallArgs); 1120 } 1121 1122 RValue CodeGenFunction::EmitLoadOfPropertyRefLValue(LValue LV, 1123 ReturnValueSlot Return) { 1124 const ObjCPropertyRefExpr *E = LV.getPropertyRefExpr(); 1125 QualType ResultType = E->getGetterResultType(); 1126 Selector S; 1127 const ObjCMethodDecl *method; 1128 if (E->isExplicitProperty()) { 1129 const ObjCPropertyDecl *Property = E->getExplicitProperty(); 1130 S = Property->getGetterName(); 1131 method = Property->getGetterMethodDecl(); 1132 } else { 1133 method = E->getImplicitPropertyGetter(); 1134 S = method->getSelector(); 1135 } 1136 1137 llvm::Value *Receiver = LV.getPropertyRefBaseAddr(); 1138 1139 if (CGM.getLangOptions().ObjCAutoRefCount) { 1140 QualType receiverType; 1141 if (E->isSuperReceiver()) 1142 receiverType = E->getSuperReceiverType(); 1143 else if (E->isClassReceiver()) 1144 receiverType = getContext().getObjCClassType(); 1145 else 1146 receiverType = E->getBase()->getType(); 1147 } 1148 1149 // Accesses to 'super' follow a different code path. 1150 if (E->isSuperReceiver()) 1151 return AdjustRelatedResultType(*this, E, method, 1152 GenerateMessageSendSuper(*this, Return, 1153 ResultType, 1154 S, Receiver, 1155 CallArgList())); 1156 const ObjCInterfaceDecl *ReceiverClass 1157 = (E->isClassReceiver() ? E->getClassReceiver() : 0); 1158 return AdjustRelatedResultType(*this, E, method, 1159 CGM.getObjCRuntime(). 1160 GenerateMessageSend(*this, Return, ResultType, S, 1161 Receiver, CallArgList(), ReceiverClass)); 1162 } 1163 1164 void CodeGenFunction::EmitStoreThroughPropertyRefLValue(RValue Src, 1165 LValue Dst) { 1166 const ObjCPropertyRefExpr *E = Dst.getPropertyRefExpr(); 1167 Selector S = E->getSetterSelector(); 1168 QualType ArgType = E->getSetterArgType(); 1169 1170 // FIXME. Other than scalars, AST is not adequate for setter and 1171 // getter type mismatches which require conversion. 1172 if (Src.isScalar()) { 1173 llvm::Value *SrcVal = Src.getScalarVal(); 1174 QualType DstType = getContext().getCanonicalType(ArgType); 1175 llvm::Type *DstTy = ConvertType(DstType); 1176 if (SrcVal->getType() != DstTy) 1177 Src = 1178 RValue::get(EmitScalarConversion(SrcVal, E->getType(), DstType)); 1179 } 1180 1181 CallArgList Args; 1182 Args.add(Src, ArgType); 1183 1184 llvm::Value *Receiver = Dst.getPropertyRefBaseAddr(); 1185 QualType ResultType = getContext().VoidTy; 1186 1187 if (E->isSuperReceiver()) { 1188 GenerateMessageSendSuper(*this, ReturnValueSlot(), 1189 ResultType, S, Receiver, Args); 1190 return; 1191 } 1192 1193 const ObjCInterfaceDecl *ReceiverClass 1194 = (E->isClassReceiver() ? E->getClassReceiver() : 0); 1195 1196 CGM.getObjCRuntime().GenerateMessageSend(*this, ReturnValueSlot(), 1197 ResultType, S, Receiver, Args, 1198 ReceiverClass); 1199 } 1200 1201 void CodeGenFunction::EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S){ 1202 llvm::Constant *EnumerationMutationFn = 1203 CGM.getObjCRuntime().EnumerationMutationFunction(); 1204 1205 if (!EnumerationMutationFn) { 1206 CGM.ErrorUnsupported(&S, "Obj-C fast enumeration for this runtime"); 1207 return; 1208 } 1209 1210 CGDebugInfo *DI = getDebugInfo(); 1211 if (DI) 1212 DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin()); 1213 1214 // The local variable comes into scope immediately. 1215 AutoVarEmission variable = AutoVarEmission::invalid(); 1216 if (const DeclStmt *SD = dyn_cast<DeclStmt>(S.getElement())) 1217 variable = EmitAutoVarAlloca(*cast<VarDecl>(SD->getSingleDecl())); 1218 1219 JumpDest LoopEnd = getJumpDestInCurrentScope("forcoll.end"); 1220 1221 // Fast enumeration state. 1222 QualType StateTy = CGM.getObjCFastEnumerationStateType(); 1223 llvm::Value *StatePtr = CreateMemTemp(StateTy, "state.ptr"); 1224 EmitNullInitialization(StatePtr, StateTy); 1225 1226 // Number of elements in the items array. 1227 static const unsigned NumItems = 16; 1228 1229 // Fetch the countByEnumeratingWithState:objects:count: selector. 1230 IdentifierInfo *II[] = { 1231 &CGM.getContext().Idents.get("countByEnumeratingWithState"), 1232 &CGM.getContext().Idents.get("objects"), 1233 &CGM.getContext().Idents.get("count") 1234 }; 1235 Selector FastEnumSel = 1236 CGM.getContext().Selectors.getSelector(llvm::array_lengthof(II), &II[0]); 1237 1238 QualType ItemsTy = 1239 getContext().getConstantArrayType(getContext().getObjCIdType(), 1240 llvm::APInt(32, NumItems), 1241 ArrayType::Normal, 0); 1242 llvm::Value *ItemsPtr = CreateMemTemp(ItemsTy, "items.ptr"); 1243 1244 // Emit the collection pointer. In ARC, we do a retain. 1245 llvm::Value *Collection; 1246 if (getLangOptions().ObjCAutoRefCount) { 1247 Collection = EmitARCRetainScalarExpr(S.getCollection()); 1248 1249 // Enter a cleanup to do the release. 1250 EmitObjCConsumeObject(S.getCollection()->getType(), Collection); 1251 } else { 1252 Collection = EmitScalarExpr(S.getCollection()); 1253 } 1254 1255 // The 'continue' label needs to appear within the cleanup for the 1256 // collection object. 1257 JumpDest AfterBody = getJumpDestInCurrentScope("forcoll.next"); 1258 1259 // Send it our message: 1260 CallArgList Args; 1261 1262 // The first argument is a temporary of the enumeration-state type. 1263 Args.add(RValue::get(StatePtr), getContext().getPointerType(StateTy)); 1264 1265 // The second argument is a temporary array with space for NumItems 1266 // pointers. We'll actually be loading elements from the array 1267 // pointer written into the control state; this buffer is so that 1268 // collections that *aren't* backed by arrays can still queue up 1269 // batches of elements. 1270 Args.add(RValue::get(ItemsPtr), getContext().getPointerType(ItemsTy)); 1271 1272 // The third argument is the capacity of that temporary array. 1273 llvm::Type *UnsignedLongLTy = ConvertType(getContext().UnsignedLongTy); 1274 llvm::Constant *Count = llvm::ConstantInt::get(UnsignedLongLTy, NumItems); 1275 Args.add(RValue::get(Count), getContext().UnsignedLongTy); 1276 1277 // Start the enumeration. 1278 RValue CountRV = 1279 CGM.getObjCRuntime().GenerateMessageSend(*this, ReturnValueSlot(), 1280 getContext().UnsignedLongTy, 1281 FastEnumSel, 1282 Collection, Args); 1283 1284 // The initial number of objects that were returned in the buffer. 1285 llvm::Value *initialBufferLimit = CountRV.getScalarVal(); 1286 1287 llvm::BasicBlock *EmptyBB = createBasicBlock("forcoll.empty"); 1288 llvm::BasicBlock *LoopInitBB = createBasicBlock("forcoll.loopinit"); 1289 1290 llvm::Value *zero = llvm::Constant::getNullValue(UnsignedLongLTy); 1291 1292 // If the limit pointer was zero to begin with, the collection is 1293 // empty; skip all this. 1294 Builder.CreateCondBr(Builder.CreateICmpEQ(initialBufferLimit, zero, "iszero"), 1295 EmptyBB, LoopInitBB); 1296 1297 // Otherwise, initialize the loop. 1298 EmitBlock(LoopInitBB); 1299 1300 // Save the initial mutations value. This is the value at an 1301 // address that was written into the state object by 1302 // countByEnumeratingWithState:objects:count:. 1303 llvm::Value *StateMutationsPtrPtr = 1304 Builder.CreateStructGEP(StatePtr, 2, "mutationsptr.ptr"); 1305 llvm::Value *StateMutationsPtr = Builder.CreateLoad(StateMutationsPtrPtr, 1306 "mutationsptr"); 1307 1308 llvm::Value *initialMutations = 1309 Builder.CreateLoad(StateMutationsPtr, "forcoll.initial-mutations"); 1310 1311 // Start looping. This is the point we return to whenever we have a 1312 // fresh, non-empty batch of objects. 1313 llvm::BasicBlock *LoopBodyBB = createBasicBlock("forcoll.loopbody"); 1314 EmitBlock(LoopBodyBB); 1315 1316 // The current index into the buffer. 1317 llvm::PHINode *index = Builder.CreatePHI(UnsignedLongLTy, 3, "forcoll.index"); 1318 index->addIncoming(zero, LoopInitBB); 1319 1320 // The current buffer size. 1321 llvm::PHINode *count = Builder.CreatePHI(UnsignedLongLTy, 3, "forcoll.count"); 1322 count->addIncoming(initialBufferLimit, LoopInitBB); 1323 1324 // Check whether the mutations value has changed from where it was 1325 // at start. StateMutationsPtr should actually be invariant between 1326 // refreshes. 1327 StateMutationsPtr = Builder.CreateLoad(StateMutationsPtrPtr, "mutationsptr"); 1328 llvm::Value *currentMutations 1329 = Builder.CreateLoad(StateMutationsPtr, "statemutations"); 1330 1331 llvm::BasicBlock *WasMutatedBB = createBasicBlock("forcoll.mutated"); 1332 llvm::BasicBlock *WasNotMutatedBB = createBasicBlock("forcoll.notmutated"); 1333 1334 Builder.CreateCondBr(Builder.CreateICmpEQ(currentMutations, initialMutations), 1335 WasNotMutatedBB, WasMutatedBB); 1336 1337 // If so, call the enumeration-mutation function. 1338 EmitBlock(WasMutatedBB); 1339 llvm::Value *V = 1340 Builder.CreateBitCast(Collection, 1341 ConvertType(getContext().getObjCIdType())); 1342 CallArgList Args2; 1343 Args2.add(RValue::get(V), getContext().getObjCIdType()); 1344 // FIXME: We shouldn't need to get the function info here, the runtime already 1345 // should have computed it to build the function. 1346 EmitCall(CGM.getTypes().getFunctionInfo(getContext().VoidTy, Args2, 1347 FunctionType::ExtInfo()), 1348 EnumerationMutationFn, ReturnValueSlot(), Args2); 1349 1350 // Otherwise, or if the mutation function returns, just continue. 1351 EmitBlock(WasNotMutatedBB); 1352 1353 // Initialize the element variable. 1354 RunCleanupsScope elementVariableScope(*this); 1355 bool elementIsVariable; 1356 LValue elementLValue; 1357 QualType elementType; 1358 if (const DeclStmt *SD = dyn_cast<DeclStmt>(S.getElement())) { 1359 // Initialize the variable, in case it's a __block variable or something. 1360 EmitAutoVarInit(variable); 1361 1362 const VarDecl* D = cast<VarDecl>(SD->getSingleDecl()); 1363 DeclRefExpr tempDRE(const_cast<VarDecl*>(D), D->getType(), 1364 VK_LValue, SourceLocation()); 1365 elementLValue = EmitLValue(&tempDRE); 1366 elementType = D->getType(); 1367 elementIsVariable = true; 1368 1369 if (D->isARCPseudoStrong()) 1370 elementLValue.getQuals().setObjCLifetime(Qualifiers::OCL_ExplicitNone); 1371 } else { 1372 elementLValue = LValue(); // suppress warning 1373 elementType = cast<Expr>(S.getElement())->getType(); 1374 elementIsVariable = false; 1375 } 1376 llvm::Type *convertedElementType = ConvertType(elementType); 1377 1378 // Fetch the buffer out of the enumeration state. 1379 // TODO: this pointer should actually be invariant between 1380 // refreshes, which would help us do certain loop optimizations. 1381 llvm::Value *StateItemsPtr = 1382 Builder.CreateStructGEP(StatePtr, 1, "stateitems.ptr"); 1383 llvm::Value *EnumStateItems = 1384 Builder.CreateLoad(StateItemsPtr, "stateitems"); 1385 1386 // Fetch the value at the current index from the buffer. 1387 llvm::Value *CurrentItemPtr = 1388 Builder.CreateGEP(EnumStateItems, index, "currentitem.ptr"); 1389 llvm::Value *CurrentItem = Builder.CreateLoad(CurrentItemPtr); 1390 1391 // Cast that value to the right type. 1392 CurrentItem = Builder.CreateBitCast(CurrentItem, convertedElementType, 1393 "currentitem"); 1394 1395 // Make sure we have an l-value. Yes, this gets evaluated every 1396 // time through the loop. 1397 if (!elementIsVariable) { 1398 elementLValue = EmitLValue(cast<Expr>(S.getElement())); 1399 EmitStoreThroughLValue(RValue::get(CurrentItem), elementLValue); 1400 } else { 1401 EmitScalarInit(CurrentItem, elementLValue); 1402 } 1403 1404 // If we do have an element variable, this assignment is the end of 1405 // its initialization. 1406 if (elementIsVariable) 1407 EmitAutoVarCleanups(variable); 1408 1409 // Perform the loop body, setting up break and continue labels. 1410 BreakContinueStack.push_back(BreakContinue(LoopEnd, AfterBody)); 1411 { 1412 RunCleanupsScope Scope(*this); 1413 EmitStmt(S.getBody()); 1414 } 1415 BreakContinueStack.pop_back(); 1416 1417 // Destroy the element variable now. 1418 elementVariableScope.ForceCleanup(); 1419 1420 // Check whether there are more elements. 1421 EmitBlock(AfterBody.getBlock()); 1422 1423 llvm::BasicBlock *FetchMoreBB = createBasicBlock("forcoll.refetch"); 1424 1425 // First we check in the local buffer. 1426 llvm::Value *indexPlusOne 1427 = Builder.CreateAdd(index, llvm::ConstantInt::get(UnsignedLongLTy, 1)); 1428 1429 // If we haven't overrun the buffer yet, we can continue. 1430 Builder.CreateCondBr(Builder.CreateICmpULT(indexPlusOne, count), 1431 LoopBodyBB, FetchMoreBB); 1432 1433 index->addIncoming(indexPlusOne, AfterBody.getBlock()); 1434 count->addIncoming(count, AfterBody.getBlock()); 1435 1436 // Otherwise, we have to fetch more elements. 1437 EmitBlock(FetchMoreBB); 1438 1439 CountRV = 1440 CGM.getObjCRuntime().GenerateMessageSend(*this, ReturnValueSlot(), 1441 getContext().UnsignedLongTy, 1442 FastEnumSel, 1443 Collection, Args); 1444 1445 // If we got a zero count, we're done. 1446 llvm::Value *refetchCount = CountRV.getScalarVal(); 1447 1448 // (note that the message send might split FetchMoreBB) 1449 index->addIncoming(zero, Builder.GetInsertBlock()); 1450 count->addIncoming(refetchCount, Builder.GetInsertBlock()); 1451 1452 Builder.CreateCondBr(Builder.CreateICmpEQ(refetchCount, zero), 1453 EmptyBB, LoopBodyBB); 1454 1455 // No more elements. 1456 EmitBlock(EmptyBB); 1457 1458 if (!elementIsVariable) { 1459 // If the element was not a declaration, set it to be null. 1460 1461 llvm::Value *null = llvm::Constant::getNullValue(convertedElementType); 1462 elementLValue = EmitLValue(cast<Expr>(S.getElement())); 1463 EmitStoreThroughLValue(RValue::get(null), elementLValue); 1464 } 1465 1466 if (DI) 1467 DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd()); 1468 1469 // Leave the cleanup we entered in ARC. 1470 if (getLangOptions().ObjCAutoRefCount) 1471 PopCleanupBlock(); 1472 1473 EmitBlock(LoopEnd.getBlock()); 1474 } 1475 1476 void CodeGenFunction::EmitObjCAtTryStmt(const ObjCAtTryStmt &S) { 1477 CGM.getObjCRuntime().EmitTryStmt(*this, S); 1478 } 1479 1480 void CodeGenFunction::EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S) { 1481 CGM.getObjCRuntime().EmitThrowStmt(*this, S); 1482 } 1483 1484 void CodeGenFunction::EmitObjCAtSynchronizedStmt( 1485 const ObjCAtSynchronizedStmt &S) { 1486 CGM.getObjCRuntime().EmitSynchronizedStmt(*this, S); 1487 } 1488 1489 /// Produce the code for a CK_ARCProduceObject. Just does a 1490 /// primitive retain. 1491 llvm::Value *CodeGenFunction::EmitObjCProduceObject(QualType type, 1492 llvm::Value *value) { 1493 return EmitARCRetain(type, value); 1494 } 1495 1496 namespace { 1497 struct CallObjCRelease : EHScopeStack::Cleanup { 1498 CallObjCRelease(llvm::Value *object) : object(object) {} 1499 llvm::Value *object; 1500 1501 void Emit(CodeGenFunction &CGF, Flags flags) { 1502 CGF.EmitARCRelease(object, /*precise*/ true); 1503 } 1504 }; 1505 } 1506 1507 /// Produce the code for a CK_ARCConsumeObject. Does a primitive 1508 /// release at the end of the full-expression. 1509 llvm::Value *CodeGenFunction::EmitObjCConsumeObject(QualType type, 1510 llvm::Value *object) { 1511 // If we're in a conditional branch, we need to make the cleanup 1512 // conditional. 1513 pushFullExprCleanup<CallObjCRelease>(getARCCleanupKind(), object); 1514 return object; 1515 } 1516 1517 llvm::Value *CodeGenFunction::EmitObjCExtendObjectLifetime(QualType type, 1518 llvm::Value *value) { 1519 return EmitARCRetainAutorelease(type, value); 1520 } 1521 1522 1523 static llvm::Constant *createARCRuntimeFunction(CodeGenModule &CGM, 1524 llvm::FunctionType *type, 1525 StringRef fnName) { 1526 llvm::Constant *fn = CGM.CreateRuntimeFunction(type, fnName); 1527 1528 // In -fobjc-no-arc-runtime, emit weak references to the runtime 1529 // support library. 1530 if (!CGM.getCodeGenOpts().ObjCRuntimeHasARC) 1531 if (llvm::Function *f = dyn_cast<llvm::Function>(fn)) 1532 f->setLinkage(llvm::Function::ExternalWeakLinkage); 1533 1534 return fn; 1535 } 1536 1537 /// Perform an operation having the signature 1538 /// i8* (i8*) 1539 /// where a null input causes a no-op and returns null. 1540 static llvm::Value *emitARCValueOperation(CodeGenFunction &CGF, 1541 llvm::Value *value, 1542 llvm::Constant *&fn, 1543 StringRef fnName) { 1544 if (isa<llvm::ConstantPointerNull>(value)) return value; 1545 1546 if (!fn) { 1547 std::vector<llvm::Type*> args(1, CGF.Int8PtrTy); 1548 llvm::FunctionType *fnType = 1549 llvm::FunctionType::get(CGF.Int8PtrTy, args, false); 1550 fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName); 1551 } 1552 1553 // Cast the argument to 'id'. 1554 llvm::Type *origType = value->getType(); 1555 value = CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy); 1556 1557 // Call the function. 1558 llvm::CallInst *call = CGF.Builder.CreateCall(fn, value); 1559 call->setDoesNotThrow(); 1560 1561 // Cast the result back to the original type. 1562 return CGF.Builder.CreateBitCast(call, origType); 1563 } 1564 1565 /// Perform an operation having the following signature: 1566 /// i8* (i8**) 1567 static llvm::Value *emitARCLoadOperation(CodeGenFunction &CGF, 1568 llvm::Value *addr, 1569 llvm::Constant *&fn, 1570 StringRef fnName) { 1571 if (!fn) { 1572 std::vector<llvm::Type*> args(1, CGF.Int8PtrPtrTy); 1573 llvm::FunctionType *fnType = 1574 llvm::FunctionType::get(CGF.Int8PtrTy, args, false); 1575 fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName); 1576 } 1577 1578 // Cast the argument to 'id*'. 1579 llvm::Type *origType = addr->getType(); 1580 addr = CGF.Builder.CreateBitCast(addr, CGF.Int8PtrPtrTy); 1581 1582 // Call the function. 1583 llvm::CallInst *call = CGF.Builder.CreateCall(fn, addr); 1584 call->setDoesNotThrow(); 1585 1586 // Cast the result back to a dereference of the original type. 1587 llvm::Value *result = call; 1588 if (origType != CGF.Int8PtrPtrTy) 1589 result = CGF.Builder.CreateBitCast(result, 1590 cast<llvm::PointerType>(origType)->getElementType()); 1591 1592 return result; 1593 } 1594 1595 /// Perform an operation having the following signature: 1596 /// i8* (i8**, i8*) 1597 static llvm::Value *emitARCStoreOperation(CodeGenFunction &CGF, 1598 llvm::Value *addr, 1599 llvm::Value *value, 1600 llvm::Constant *&fn, 1601 StringRef fnName, 1602 bool ignored) { 1603 assert(cast<llvm::PointerType>(addr->getType())->getElementType() 1604 == value->getType()); 1605 1606 if (!fn) { 1607 llvm::Type *argTypes[] = { CGF.Int8PtrPtrTy, CGF.Int8PtrTy }; 1608 1609 llvm::FunctionType *fnType 1610 = llvm::FunctionType::get(CGF.Int8PtrTy, argTypes, false); 1611 fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName); 1612 } 1613 1614 llvm::Type *origType = value->getType(); 1615 1616 addr = CGF.Builder.CreateBitCast(addr, CGF.Int8PtrPtrTy); 1617 value = CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy); 1618 1619 llvm::CallInst *result = CGF.Builder.CreateCall2(fn, addr, value); 1620 result->setDoesNotThrow(); 1621 1622 if (ignored) return 0; 1623 1624 return CGF.Builder.CreateBitCast(result, origType); 1625 } 1626 1627 /// Perform an operation having the following signature: 1628 /// void (i8**, i8**) 1629 static void emitARCCopyOperation(CodeGenFunction &CGF, 1630 llvm::Value *dst, 1631 llvm::Value *src, 1632 llvm::Constant *&fn, 1633 StringRef fnName) { 1634 assert(dst->getType() == src->getType()); 1635 1636 if (!fn) { 1637 std::vector<llvm::Type*> argTypes(2, CGF.Int8PtrPtrTy); 1638 llvm::FunctionType *fnType 1639 = llvm::FunctionType::get(CGF.Builder.getVoidTy(), argTypes, false); 1640 fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName); 1641 } 1642 1643 dst = CGF.Builder.CreateBitCast(dst, CGF.Int8PtrPtrTy); 1644 src = CGF.Builder.CreateBitCast(src, CGF.Int8PtrPtrTy); 1645 1646 llvm::CallInst *result = CGF.Builder.CreateCall2(fn, dst, src); 1647 result->setDoesNotThrow(); 1648 } 1649 1650 /// Produce the code to do a retain. Based on the type, calls one of: 1651 /// call i8* @objc_retain(i8* %value) 1652 /// call i8* @objc_retainBlock(i8* %value) 1653 llvm::Value *CodeGenFunction::EmitARCRetain(QualType type, llvm::Value *value) { 1654 if (type->isBlockPointerType()) 1655 return EmitARCRetainBlock(value, /*mandatory*/ false); 1656 else 1657 return EmitARCRetainNonBlock(value); 1658 } 1659 1660 /// Retain the given object, with normal retain semantics. 1661 /// call i8* @objc_retain(i8* %value) 1662 llvm::Value *CodeGenFunction::EmitARCRetainNonBlock(llvm::Value *value) { 1663 return emitARCValueOperation(*this, value, 1664 CGM.getARCEntrypoints().objc_retain, 1665 "objc_retain"); 1666 } 1667 1668 /// Retain the given block, with _Block_copy semantics. 1669 /// call i8* @objc_retainBlock(i8* %value) 1670 /// 1671 /// \param mandatory - If false, emit the call with metadata 1672 /// indicating that it's okay for the optimizer to eliminate this call 1673 /// if it can prove that the block never escapes except down the stack. 1674 llvm::Value *CodeGenFunction::EmitARCRetainBlock(llvm::Value *value, 1675 bool mandatory) { 1676 llvm::Value *result 1677 = emitARCValueOperation(*this, value, 1678 CGM.getARCEntrypoints().objc_retainBlock, 1679 "objc_retainBlock"); 1680 1681 // If the copy isn't mandatory, add !clang.arc.copy_on_escape to 1682 // tell the optimizer that it doesn't need to do this copy if the 1683 // block doesn't escape, where being passed as an argument doesn't 1684 // count as escaping. 1685 if (!mandatory && isa<llvm::Instruction>(result)) { 1686 llvm::CallInst *call 1687 = cast<llvm::CallInst>(result->stripPointerCasts()); 1688 assert(call->getCalledValue() == CGM.getARCEntrypoints().objc_retainBlock); 1689 1690 SmallVector<llvm::Value*,1> args; 1691 call->setMetadata("clang.arc.copy_on_escape", 1692 llvm::MDNode::get(Builder.getContext(), args)); 1693 } 1694 1695 return result; 1696 } 1697 1698 /// Retain the given object which is the result of a function call. 1699 /// call i8* @objc_retainAutoreleasedReturnValue(i8* %value) 1700 /// 1701 /// Yes, this function name is one character away from a different 1702 /// call with completely different semantics. 1703 llvm::Value * 1704 CodeGenFunction::EmitARCRetainAutoreleasedReturnValue(llvm::Value *value) { 1705 // Fetch the void(void) inline asm which marks that we're going to 1706 // retain the autoreleased return value. 1707 llvm::InlineAsm *&marker 1708 = CGM.getARCEntrypoints().retainAutoreleasedReturnValueMarker; 1709 if (!marker) { 1710 StringRef assembly 1711 = CGM.getTargetCodeGenInfo() 1712 .getARCRetainAutoreleasedReturnValueMarker(); 1713 1714 // If we have an empty assembly string, there's nothing to do. 1715 if (assembly.empty()) { 1716 1717 // Otherwise, at -O0, build an inline asm that we're going to call 1718 // in a moment. 1719 } else if (CGM.getCodeGenOpts().OptimizationLevel == 0) { 1720 llvm::FunctionType *type = 1721 llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()), 1722 /*variadic*/ false); 1723 1724 marker = llvm::InlineAsm::get(type, assembly, "", /*sideeffects*/ true); 1725 1726 // If we're at -O1 and above, we don't want to litter the code 1727 // with this marker yet, so leave a breadcrumb for the ARC 1728 // optimizer to pick up. 1729 } else { 1730 llvm::NamedMDNode *metadata = 1731 CGM.getModule().getOrInsertNamedMetadata( 1732 "clang.arc.retainAutoreleasedReturnValueMarker"); 1733 assert(metadata->getNumOperands() <= 1); 1734 if (metadata->getNumOperands() == 0) { 1735 llvm::Value *string = llvm::MDString::get(getLLVMContext(), assembly); 1736 metadata->addOperand(llvm::MDNode::get(getLLVMContext(), string)); 1737 } 1738 } 1739 } 1740 1741 // Call the marker asm if we made one, which we do only at -O0. 1742 if (marker) Builder.CreateCall(marker); 1743 1744 return emitARCValueOperation(*this, value, 1745 CGM.getARCEntrypoints().objc_retainAutoreleasedReturnValue, 1746 "objc_retainAutoreleasedReturnValue"); 1747 } 1748 1749 /// Release the given object. 1750 /// call void @objc_release(i8* %value) 1751 void CodeGenFunction::EmitARCRelease(llvm::Value *value, bool precise) { 1752 if (isa<llvm::ConstantPointerNull>(value)) return; 1753 1754 llvm::Constant *&fn = CGM.getARCEntrypoints().objc_release; 1755 if (!fn) { 1756 std::vector<llvm::Type*> args(1, Int8PtrTy); 1757 llvm::FunctionType *fnType = 1758 llvm::FunctionType::get(Builder.getVoidTy(), args, false); 1759 fn = createARCRuntimeFunction(CGM, fnType, "objc_release"); 1760 } 1761 1762 // Cast the argument to 'id'. 1763 value = Builder.CreateBitCast(value, Int8PtrTy); 1764 1765 // Call objc_release. 1766 llvm::CallInst *call = Builder.CreateCall(fn, value); 1767 call->setDoesNotThrow(); 1768 1769 if (!precise) { 1770 SmallVector<llvm::Value*,1> args; 1771 call->setMetadata("clang.imprecise_release", 1772 llvm::MDNode::get(Builder.getContext(), args)); 1773 } 1774 } 1775 1776 /// Store into a strong object. Always calls this: 1777 /// call void @objc_storeStrong(i8** %addr, i8* %value) 1778 llvm::Value *CodeGenFunction::EmitARCStoreStrongCall(llvm::Value *addr, 1779 llvm::Value *value, 1780 bool ignored) { 1781 assert(cast<llvm::PointerType>(addr->getType())->getElementType() 1782 == value->getType()); 1783 1784 llvm::Constant *&fn = CGM.getARCEntrypoints().objc_storeStrong; 1785 if (!fn) { 1786 llvm::Type *argTypes[] = { Int8PtrPtrTy, Int8PtrTy }; 1787 llvm::FunctionType *fnType 1788 = llvm::FunctionType::get(Builder.getVoidTy(), argTypes, false); 1789 fn = createARCRuntimeFunction(CGM, fnType, "objc_storeStrong"); 1790 } 1791 1792 addr = Builder.CreateBitCast(addr, Int8PtrPtrTy); 1793 llvm::Value *castValue = Builder.CreateBitCast(value, Int8PtrTy); 1794 1795 Builder.CreateCall2(fn, addr, castValue)->setDoesNotThrow(); 1796 1797 if (ignored) return 0; 1798 return value; 1799 } 1800 1801 /// Store into a strong object. Sometimes calls this: 1802 /// call void @objc_storeStrong(i8** %addr, i8* %value) 1803 /// Other times, breaks it down into components. 1804 llvm::Value *CodeGenFunction::EmitARCStoreStrong(LValue dst, 1805 llvm::Value *newValue, 1806 bool ignored) { 1807 QualType type = dst.getType(); 1808 bool isBlock = type->isBlockPointerType(); 1809 1810 // Use a store barrier at -O0 unless this is a block type or the 1811 // lvalue is inadequately aligned. 1812 if (shouldUseFusedARCCalls() && 1813 !isBlock && 1814 !(dst.getAlignment() && dst.getAlignment() < PointerAlignInBytes)) { 1815 return EmitARCStoreStrongCall(dst.getAddress(), newValue, ignored); 1816 } 1817 1818 // Otherwise, split it out. 1819 1820 // Retain the new value. 1821 newValue = EmitARCRetain(type, newValue); 1822 1823 // Read the old value. 1824 llvm::Value *oldValue = EmitLoadOfScalar(dst); 1825 1826 // Store. We do this before the release so that any deallocs won't 1827 // see the old value. 1828 EmitStoreOfScalar(newValue, dst); 1829 1830 // Finally, release the old value. 1831 EmitARCRelease(oldValue, /*precise*/ false); 1832 1833 return newValue; 1834 } 1835 1836 /// Autorelease the given object. 1837 /// call i8* @objc_autorelease(i8* %value) 1838 llvm::Value *CodeGenFunction::EmitARCAutorelease(llvm::Value *value) { 1839 return emitARCValueOperation(*this, value, 1840 CGM.getARCEntrypoints().objc_autorelease, 1841 "objc_autorelease"); 1842 } 1843 1844 /// Autorelease the given object. 1845 /// call i8* @objc_autoreleaseReturnValue(i8* %value) 1846 llvm::Value * 1847 CodeGenFunction::EmitARCAutoreleaseReturnValue(llvm::Value *value) { 1848 return emitARCValueOperation(*this, value, 1849 CGM.getARCEntrypoints().objc_autoreleaseReturnValue, 1850 "objc_autoreleaseReturnValue"); 1851 } 1852 1853 /// Do a fused retain/autorelease of the given object. 1854 /// call i8* @objc_retainAutoreleaseReturnValue(i8* %value) 1855 llvm::Value * 1856 CodeGenFunction::EmitARCRetainAutoreleaseReturnValue(llvm::Value *value) { 1857 return emitARCValueOperation(*this, value, 1858 CGM.getARCEntrypoints().objc_retainAutoreleaseReturnValue, 1859 "objc_retainAutoreleaseReturnValue"); 1860 } 1861 1862 /// Do a fused retain/autorelease of the given object. 1863 /// call i8* @objc_retainAutorelease(i8* %value) 1864 /// or 1865 /// %retain = call i8* @objc_retainBlock(i8* %value) 1866 /// call i8* @objc_autorelease(i8* %retain) 1867 llvm::Value *CodeGenFunction::EmitARCRetainAutorelease(QualType type, 1868 llvm::Value *value) { 1869 if (!type->isBlockPointerType()) 1870 return EmitARCRetainAutoreleaseNonBlock(value); 1871 1872 if (isa<llvm::ConstantPointerNull>(value)) return value; 1873 1874 llvm::Type *origType = value->getType(); 1875 value = Builder.CreateBitCast(value, Int8PtrTy); 1876 value = EmitARCRetainBlock(value, /*mandatory*/ true); 1877 value = EmitARCAutorelease(value); 1878 return Builder.CreateBitCast(value, origType); 1879 } 1880 1881 /// Do a fused retain/autorelease of the given object. 1882 /// call i8* @objc_retainAutorelease(i8* %value) 1883 llvm::Value * 1884 CodeGenFunction::EmitARCRetainAutoreleaseNonBlock(llvm::Value *value) { 1885 return emitARCValueOperation(*this, value, 1886 CGM.getARCEntrypoints().objc_retainAutorelease, 1887 "objc_retainAutorelease"); 1888 } 1889 1890 /// i8* @objc_loadWeak(i8** %addr) 1891 /// Essentially objc_autorelease(objc_loadWeakRetained(addr)). 1892 llvm::Value *CodeGenFunction::EmitARCLoadWeak(llvm::Value *addr) { 1893 return emitARCLoadOperation(*this, addr, 1894 CGM.getARCEntrypoints().objc_loadWeak, 1895 "objc_loadWeak"); 1896 } 1897 1898 /// i8* @objc_loadWeakRetained(i8** %addr) 1899 llvm::Value *CodeGenFunction::EmitARCLoadWeakRetained(llvm::Value *addr) { 1900 return emitARCLoadOperation(*this, addr, 1901 CGM.getARCEntrypoints().objc_loadWeakRetained, 1902 "objc_loadWeakRetained"); 1903 } 1904 1905 /// i8* @objc_storeWeak(i8** %addr, i8* %value) 1906 /// Returns %value. 1907 llvm::Value *CodeGenFunction::EmitARCStoreWeak(llvm::Value *addr, 1908 llvm::Value *value, 1909 bool ignored) { 1910 return emitARCStoreOperation(*this, addr, value, 1911 CGM.getARCEntrypoints().objc_storeWeak, 1912 "objc_storeWeak", ignored); 1913 } 1914 1915 /// i8* @objc_initWeak(i8** %addr, i8* %value) 1916 /// Returns %value. %addr is known to not have a current weak entry. 1917 /// Essentially equivalent to: 1918 /// *addr = nil; objc_storeWeak(addr, value); 1919 void CodeGenFunction::EmitARCInitWeak(llvm::Value *addr, llvm::Value *value) { 1920 // If we're initializing to null, just write null to memory; no need 1921 // to get the runtime involved. But don't do this if optimization 1922 // is enabled, because accounting for this would make the optimizer 1923 // much more complicated. 1924 if (isa<llvm::ConstantPointerNull>(value) && 1925 CGM.getCodeGenOpts().OptimizationLevel == 0) { 1926 Builder.CreateStore(value, addr); 1927 return; 1928 } 1929 1930 emitARCStoreOperation(*this, addr, value, 1931 CGM.getARCEntrypoints().objc_initWeak, 1932 "objc_initWeak", /*ignored*/ true); 1933 } 1934 1935 /// void @objc_destroyWeak(i8** %addr) 1936 /// Essentially objc_storeWeak(addr, nil). 1937 void CodeGenFunction::EmitARCDestroyWeak(llvm::Value *addr) { 1938 llvm::Constant *&fn = CGM.getARCEntrypoints().objc_destroyWeak; 1939 if (!fn) { 1940 std::vector<llvm::Type*> args(1, Int8PtrPtrTy); 1941 llvm::FunctionType *fnType = 1942 llvm::FunctionType::get(Builder.getVoidTy(), args, false); 1943 fn = createARCRuntimeFunction(CGM, fnType, "objc_destroyWeak"); 1944 } 1945 1946 // Cast the argument to 'id*'. 1947 addr = Builder.CreateBitCast(addr, Int8PtrPtrTy); 1948 1949 llvm::CallInst *call = Builder.CreateCall(fn, addr); 1950 call->setDoesNotThrow(); 1951 } 1952 1953 /// void @objc_moveWeak(i8** %dest, i8** %src) 1954 /// Disregards the current value in %dest. Leaves %src pointing to nothing. 1955 /// Essentially (objc_copyWeak(dest, src), objc_destroyWeak(src)). 1956 void CodeGenFunction::EmitARCMoveWeak(llvm::Value *dst, llvm::Value *src) { 1957 emitARCCopyOperation(*this, dst, src, 1958 CGM.getARCEntrypoints().objc_moveWeak, 1959 "objc_moveWeak"); 1960 } 1961 1962 /// void @objc_copyWeak(i8** %dest, i8** %src) 1963 /// Disregards the current value in %dest. Essentially 1964 /// objc_release(objc_initWeak(dest, objc_readWeakRetained(src))) 1965 void CodeGenFunction::EmitARCCopyWeak(llvm::Value *dst, llvm::Value *src) { 1966 emitARCCopyOperation(*this, dst, src, 1967 CGM.getARCEntrypoints().objc_copyWeak, 1968 "objc_copyWeak"); 1969 } 1970 1971 /// Produce the code to do a objc_autoreleasepool_push. 1972 /// call i8* @objc_autoreleasePoolPush(void) 1973 llvm::Value *CodeGenFunction::EmitObjCAutoreleasePoolPush() { 1974 llvm::Constant *&fn = CGM.getRREntrypoints().objc_autoreleasePoolPush; 1975 if (!fn) { 1976 llvm::FunctionType *fnType = 1977 llvm::FunctionType::get(Int8PtrTy, false); 1978 fn = createARCRuntimeFunction(CGM, fnType, "objc_autoreleasePoolPush"); 1979 } 1980 1981 llvm::CallInst *call = Builder.CreateCall(fn); 1982 call->setDoesNotThrow(); 1983 1984 return call; 1985 } 1986 1987 /// Produce the code to do a primitive release. 1988 /// call void @objc_autoreleasePoolPop(i8* %ptr) 1989 void CodeGenFunction::EmitObjCAutoreleasePoolPop(llvm::Value *value) { 1990 assert(value->getType() == Int8PtrTy); 1991 1992 llvm::Constant *&fn = CGM.getRREntrypoints().objc_autoreleasePoolPop; 1993 if (!fn) { 1994 std::vector<llvm::Type*> args(1, Int8PtrTy); 1995 llvm::FunctionType *fnType = 1996 llvm::FunctionType::get(Builder.getVoidTy(), args, false); 1997 1998 // We don't want to use a weak import here; instead we should not 1999 // fall into this path. 2000 fn = createARCRuntimeFunction(CGM, fnType, "objc_autoreleasePoolPop"); 2001 } 2002 2003 llvm::CallInst *call = Builder.CreateCall(fn, value); 2004 call->setDoesNotThrow(); 2005 } 2006 2007 /// Produce the code to do an MRR version objc_autoreleasepool_push. 2008 /// Which is: [[NSAutoreleasePool alloc] init]; 2009 /// Where alloc is declared as: + (id) alloc; in NSAutoreleasePool class. 2010 /// init is declared as: - (id) init; in its NSObject super class. 2011 /// 2012 llvm::Value *CodeGenFunction::EmitObjCMRRAutoreleasePoolPush() { 2013 CGObjCRuntime &Runtime = CGM.getObjCRuntime(); 2014 llvm::Value *Receiver = Runtime.EmitNSAutoreleasePoolClassRef(Builder); 2015 // [NSAutoreleasePool alloc] 2016 IdentifierInfo *II = &CGM.getContext().Idents.get("alloc"); 2017 Selector AllocSel = getContext().Selectors.getSelector(0, &II); 2018 CallArgList Args; 2019 RValue AllocRV = 2020 Runtime.GenerateMessageSend(*this, ReturnValueSlot(), 2021 getContext().getObjCIdType(), 2022 AllocSel, Receiver, Args); 2023 2024 // [Receiver init] 2025 Receiver = AllocRV.getScalarVal(); 2026 II = &CGM.getContext().Idents.get("init"); 2027 Selector InitSel = getContext().Selectors.getSelector(0, &II); 2028 RValue InitRV = 2029 Runtime.GenerateMessageSend(*this, ReturnValueSlot(), 2030 getContext().getObjCIdType(), 2031 InitSel, Receiver, Args); 2032 return InitRV.getScalarVal(); 2033 } 2034 2035 /// Produce the code to do a primitive release. 2036 /// [tmp drain]; 2037 void CodeGenFunction::EmitObjCMRRAutoreleasePoolPop(llvm::Value *Arg) { 2038 IdentifierInfo *II = &CGM.getContext().Idents.get("drain"); 2039 Selector DrainSel = getContext().Selectors.getSelector(0, &II); 2040 CallArgList Args; 2041 CGM.getObjCRuntime().GenerateMessageSend(*this, ReturnValueSlot(), 2042 getContext().VoidTy, DrainSel, Arg, Args); 2043 } 2044 2045 void CodeGenFunction::destroyARCStrongPrecise(CodeGenFunction &CGF, 2046 llvm::Value *addr, 2047 QualType type) { 2048 llvm::Value *ptr = CGF.Builder.CreateLoad(addr, "strongdestroy"); 2049 CGF.EmitARCRelease(ptr, /*precise*/ true); 2050 } 2051 2052 void CodeGenFunction::destroyARCStrongImprecise(CodeGenFunction &CGF, 2053 llvm::Value *addr, 2054 QualType type) { 2055 llvm::Value *ptr = CGF.Builder.CreateLoad(addr, "strongdestroy"); 2056 CGF.EmitARCRelease(ptr, /*precise*/ false); 2057 } 2058 2059 void CodeGenFunction::destroyARCWeak(CodeGenFunction &CGF, 2060 llvm::Value *addr, 2061 QualType type) { 2062 CGF.EmitARCDestroyWeak(addr); 2063 } 2064 2065 namespace { 2066 struct CallObjCAutoreleasePoolObject : EHScopeStack::Cleanup { 2067 llvm::Value *Token; 2068 2069 CallObjCAutoreleasePoolObject(llvm::Value *token) : Token(token) {} 2070 2071 void Emit(CodeGenFunction &CGF, Flags flags) { 2072 CGF.EmitObjCAutoreleasePoolPop(Token); 2073 } 2074 }; 2075 struct CallObjCMRRAutoreleasePoolObject : EHScopeStack::Cleanup { 2076 llvm::Value *Token; 2077 2078 CallObjCMRRAutoreleasePoolObject(llvm::Value *token) : Token(token) {} 2079 2080 void Emit(CodeGenFunction &CGF, Flags flags) { 2081 CGF.EmitObjCMRRAutoreleasePoolPop(Token); 2082 } 2083 }; 2084 } 2085 2086 void CodeGenFunction::EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr) { 2087 if (CGM.getLangOptions().ObjCAutoRefCount) 2088 EHStack.pushCleanup<CallObjCAutoreleasePoolObject>(NormalCleanup, Ptr); 2089 else 2090 EHStack.pushCleanup<CallObjCMRRAutoreleasePoolObject>(NormalCleanup, Ptr); 2091 } 2092 2093 static TryEmitResult tryEmitARCRetainLoadOfScalar(CodeGenFunction &CGF, 2094 LValue lvalue, 2095 QualType type) { 2096 switch (type.getObjCLifetime()) { 2097 case Qualifiers::OCL_None: 2098 case Qualifiers::OCL_ExplicitNone: 2099 case Qualifiers::OCL_Strong: 2100 case Qualifiers::OCL_Autoreleasing: 2101 return TryEmitResult(CGF.EmitLoadOfLValue(lvalue).getScalarVal(), 2102 false); 2103 2104 case Qualifiers::OCL_Weak: 2105 return TryEmitResult(CGF.EmitARCLoadWeakRetained(lvalue.getAddress()), 2106 true); 2107 } 2108 2109 llvm_unreachable("impossible lifetime!"); 2110 return TryEmitResult(); 2111 } 2112 2113 static TryEmitResult tryEmitARCRetainLoadOfScalar(CodeGenFunction &CGF, 2114 const Expr *e) { 2115 e = e->IgnoreParens(); 2116 QualType type = e->getType(); 2117 2118 // If we're loading retained from a __strong xvalue, we can avoid 2119 // an extra retain/release pair by zeroing out the source of this 2120 // "move" operation. 2121 if (e->isXValue() && 2122 !type.isConstQualified() && 2123 type.getObjCLifetime() == Qualifiers::OCL_Strong) { 2124 // Emit the lvalue. 2125 LValue lv = CGF.EmitLValue(e); 2126 2127 // Load the object pointer. 2128 llvm::Value *result = CGF.EmitLoadOfLValue(lv).getScalarVal(); 2129 2130 // Set the source pointer to NULL. 2131 CGF.EmitStoreOfScalar(getNullForVariable(lv.getAddress()), lv); 2132 2133 return TryEmitResult(result, true); 2134 } 2135 2136 // As a very special optimization, in ARC++, if the l-value is the 2137 // result of a non-volatile assignment, do a simple retain of the 2138 // result of the call to objc_storeWeak instead of reloading. 2139 if (CGF.getLangOptions().CPlusPlus && 2140 !type.isVolatileQualified() && 2141 type.getObjCLifetime() == Qualifiers::OCL_Weak && 2142 isa<BinaryOperator>(e) && 2143 cast<BinaryOperator>(e)->getOpcode() == BO_Assign) 2144 return TryEmitResult(CGF.EmitScalarExpr(e), false); 2145 2146 return tryEmitARCRetainLoadOfScalar(CGF, CGF.EmitLValue(e), type); 2147 } 2148 2149 static llvm::Value *emitARCRetainAfterCall(CodeGenFunction &CGF, 2150 llvm::Value *value); 2151 2152 /// Given that the given expression is some sort of call (which does 2153 /// not return retained), emit a retain following it. 2154 static llvm::Value *emitARCRetainCall(CodeGenFunction &CGF, const Expr *e) { 2155 llvm::Value *value = CGF.EmitScalarExpr(e); 2156 return emitARCRetainAfterCall(CGF, value); 2157 } 2158 2159 static llvm::Value *emitARCRetainAfterCall(CodeGenFunction &CGF, 2160 llvm::Value *value) { 2161 if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(value)) { 2162 CGBuilderTy::InsertPoint ip = CGF.Builder.saveIP(); 2163 2164 // Place the retain immediately following the call. 2165 CGF.Builder.SetInsertPoint(call->getParent(), 2166 ++llvm::BasicBlock::iterator(call)); 2167 value = CGF.EmitARCRetainAutoreleasedReturnValue(value); 2168 2169 CGF.Builder.restoreIP(ip); 2170 return value; 2171 } else if (llvm::InvokeInst *invoke = dyn_cast<llvm::InvokeInst>(value)) { 2172 CGBuilderTy::InsertPoint ip = CGF.Builder.saveIP(); 2173 2174 // Place the retain at the beginning of the normal destination block. 2175 llvm::BasicBlock *BB = invoke->getNormalDest(); 2176 CGF.Builder.SetInsertPoint(BB, BB->begin()); 2177 value = CGF.EmitARCRetainAutoreleasedReturnValue(value); 2178 2179 CGF.Builder.restoreIP(ip); 2180 return value; 2181 2182 // Bitcasts can arise because of related-result returns. Rewrite 2183 // the operand. 2184 } else if (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(value)) { 2185 llvm::Value *operand = bitcast->getOperand(0); 2186 operand = emitARCRetainAfterCall(CGF, operand); 2187 bitcast->setOperand(0, operand); 2188 return bitcast; 2189 2190 // Generic fall-back case. 2191 } else { 2192 // Retain using the non-block variant: we never need to do a copy 2193 // of a block that's been returned to us. 2194 return CGF.EmitARCRetainNonBlock(value); 2195 } 2196 } 2197 2198 /// Determine whether it might be important to emit a separate 2199 /// objc_retain_block on the result of the given expression, or 2200 /// whether it's okay to just emit it in a +1 context. 2201 static bool shouldEmitSeparateBlockRetain(const Expr *e) { 2202 assert(e->getType()->isBlockPointerType()); 2203 e = e->IgnoreParens(); 2204 2205 // For future goodness, emit block expressions directly in +1 2206 // contexts if we can. 2207 if (isa<BlockExpr>(e)) 2208 return false; 2209 2210 if (const CastExpr *cast = dyn_cast<CastExpr>(e)) { 2211 switch (cast->getCastKind()) { 2212 // Emitting these operations in +1 contexts is goodness. 2213 case CK_LValueToRValue: 2214 case CK_ARCReclaimReturnedObject: 2215 case CK_ARCConsumeObject: 2216 case CK_ARCProduceObject: 2217 return false; 2218 2219 // These operations preserve a block type. 2220 case CK_NoOp: 2221 case CK_BitCast: 2222 return shouldEmitSeparateBlockRetain(cast->getSubExpr()); 2223 2224 // These operations are known to be bad (or haven't been considered). 2225 case CK_AnyPointerToBlockPointerCast: 2226 default: 2227 return true; 2228 } 2229 } 2230 2231 return true; 2232 } 2233 2234 static TryEmitResult 2235 tryEmitARCRetainScalarExpr(CodeGenFunction &CGF, const Expr *e) { 2236 // Look through cleanups. 2237 if (const ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(e)) { 2238 CodeGenFunction::RunCleanupsScope scope(CGF); 2239 return tryEmitARCRetainScalarExpr(CGF, cleanups->getSubExpr()); 2240 } 2241 2242 // The desired result type, if it differs from the type of the 2243 // ultimate opaque expression. 2244 llvm::Type *resultType = 0; 2245 2246 while (true) { 2247 e = e->IgnoreParens(); 2248 2249 // There's a break at the end of this if-chain; anything 2250 // that wants to keep looping has to explicitly continue. 2251 if (const CastExpr *ce = dyn_cast<CastExpr>(e)) { 2252 switch (ce->getCastKind()) { 2253 // No-op casts don't change the type, so we just ignore them. 2254 case CK_NoOp: 2255 e = ce->getSubExpr(); 2256 continue; 2257 2258 case CK_LValueToRValue: { 2259 TryEmitResult loadResult 2260 = tryEmitARCRetainLoadOfScalar(CGF, ce->getSubExpr()); 2261 if (resultType) { 2262 llvm::Value *value = loadResult.getPointer(); 2263 value = CGF.Builder.CreateBitCast(value, resultType); 2264 loadResult.setPointer(value); 2265 } 2266 return loadResult; 2267 } 2268 2269 // These casts can change the type, so remember that and 2270 // soldier on. We only need to remember the outermost such 2271 // cast, though. 2272 case CK_CPointerToObjCPointerCast: 2273 case CK_BlockPointerToObjCPointerCast: 2274 case CK_AnyPointerToBlockPointerCast: 2275 case CK_BitCast: 2276 if (!resultType) 2277 resultType = CGF.ConvertType(ce->getType()); 2278 e = ce->getSubExpr(); 2279 assert(e->getType()->hasPointerRepresentation()); 2280 continue; 2281 2282 // For consumptions, just emit the subexpression and thus elide 2283 // the retain/release pair. 2284 case CK_ARCConsumeObject: { 2285 llvm::Value *result = CGF.EmitScalarExpr(ce->getSubExpr()); 2286 if (resultType) result = CGF.Builder.CreateBitCast(result, resultType); 2287 return TryEmitResult(result, true); 2288 } 2289 2290 // Block extends are net +0. Naively, we could just recurse on 2291 // the subexpression, but actually we need to ensure that the 2292 // value is copied as a block, so there's a little filter here. 2293 case CK_ARCExtendBlockObject: { 2294 llvm::Value *result; // will be a +0 value 2295 2296 // If we can't safely assume the sub-expression will produce a 2297 // block-copied value, emit the sub-expression at +0. 2298 if (shouldEmitSeparateBlockRetain(ce->getSubExpr())) { 2299 result = CGF.EmitScalarExpr(ce->getSubExpr()); 2300 2301 // Otherwise, try to emit the sub-expression at +1 recursively. 2302 } else { 2303 TryEmitResult subresult 2304 = tryEmitARCRetainScalarExpr(CGF, ce->getSubExpr()); 2305 result = subresult.getPointer(); 2306 2307 // If that produced a retained value, just use that, 2308 // possibly casting down. 2309 if (subresult.getInt()) { 2310 if (resultType) 2311 result = CGF.Builder.CreateBitCast(result, resultType); 2312 return TryEmitResult(result, true); 2313 } 2314 2315 // Otherwise it's +0. 2316 } 2317 2318 // Retain the object as a block, then cast down. 2319 result = CGF.EmitARCRetainBlock(result, /*mandatory*/ true); 2320 if (resultType) result = CGF.Builder.CreateBitCast(result, resultType); 2321 return TryEmitResult(result, true); 2322 } 2323 2324 // For reclaims, emit the subexpression as a retained call and 2325 // skip the consumption. 2326 case CK_ARCReclaimReturnedObject: { 2327 llvm::Value *result = emitARCRetainCall(CGF, ce->getSubExpr()); 2328 if (resultType) result = CGF.Builder.CreateBitCast(result, resultType); 2329 return TryEmitResult(result, true); 2330 } 2331 2332 case CK_GetObjCProperty: { 2333 llvm::Value *result = emitARCRetainCall(CGF, ce); 2334 if (resultType) result = CGF.Builder.CreateBitCast(result, resultType); 2335 return TryEmitResult(result, true); 2336 } 2337 2338 default: 2339 break; 2340 } 2341 2342 // Skip __extension__. 2343 } else if (const UnaryOperator *op = dyn_cast<UnaryOperator>(e)) { 2344 if (op->getOpcode() == UO_Extension) { 2345 e = op->getSubExpr(); 2346 continue; 2347 } 2348 2349 // For calls and message sends, use the retained-call logic. 2350 // Delegate inits are a special case in that they're the only 2351 // returns-retained expression that *isn't* surrounded by 2352 // a consume. 2353 } else if (isa<CallExpr>(e) || 2354 (isa<ObjCMessageExpr>(e) && 2355 !cast<ObjCMessageExpr>(e)->isDelegateInitCall())) { 2356 llvm::Value *result = emitARCRetainCall(CGF, e); 2357 if (resultType) result = CGF.Builder.CreateBitCast(result, resultType); 2358 return TryEmitResult(result, true); 2359 } 2360 2361 // Conservatively halt the search at any other expression kind. 2362 break; 2363 } 2364 2365 // We didn't find an obvious production, so emit what we've got and 2366 // tell the caller that we didn't manage to retain. 2367 llvm::Value *result = CGF.EmitScalarExpr(e); 2368 if (resultType) result = CGF.Builder.CreateBitCast(result, resultType); 2369 return TryEmitResult(result, false); 2370 } 2371 2372 static llvm::Value *emitARCRetainLoadOfScalar(CodeGenFunction &CGF, 2373 LValue lvalue, 2374 QualType type) { 2375 TryEmitResult result = tryEmitARCRetainLoadOfScalar(CGF, lvalue, type); 2376 llvm::Value *value = result.getPointer(); 2377 if (!result.getInt()) 2378 value = CGF.EmitARCRetain(type, value); 2379 return value; 2380 } 2381 2382 /// EmitARCRetainScalarExpr - Semantically equivalent to 2383 /// EmitARCRetainObject(e->getType(), EmitScalarExpr(e)), but making a 2384 /// best-effort attempt to peephole expressions that naturally produce 2385 /// retained objects. 2386 llvm::Value *CodeGenFunction::EmitARCRetainScalarExpr(const Expr *e) { 2387 TryEmitResult result = tryEmitARCRetainScalarExpr(*this, e); 2388 llvm::Value *value = result.getPointer(); 2389 if (!result.getInt()) 2390 value = EmitARCRetain(e->getType(), value); 2391 return value; 2392 } 2393 2394 llvm::Value * 2395 CodeGenFunction::EmitARCRetainAutoreleaseScalarExpr(const Expr *e) { 2396 TryEmitResult result = tryEmitARCRetainScalarExpr(*this, e); 2397 llvm::Value *value = result.getPointer(); 2398 if (result.getInt()) 2399 value = EmitARCAutorelease(value); 2400 else 2401 value = EmitARCRetainAutorelease(e->getType(), value); 2402 return value; 2403 } 2404 2405 llvm::Value *CodeGenFunction::EmitARCExtendBlockObject(const Expr *e) { 2406 llvm::Value *result; 2407 bool doRetain; 2408 2409 if (shouldEmitSeparateBlockRetain(e)) { 2410 result = EmitScalarExpr(e); 2411 doRetain = true; 2412 } else { 2413 TryEmitResult subresult = tryEmitARCRetainScalarExpr(*this, e); 2414 result = subresult.getPointer(); 2415 doRetain = !subresult.getInt(); 2416 } 2417 2418 if (doRetain) 2419 result = EmitARCRetainBlock(result, /*mandatory*/ true); 2420 return EmitObjCConsumeObject(e->getType(), result); 2421 } 2422 2423 llvm::Value *CodeGenFunction::EmitObjCThrowOperand(const Expr *expr) { 2424 // In ARC, retain and autorelease the expression. 2425 if (getLangOptions().ObjCAutoRefCount) { 2426 // Do so before running any cleanups for the full-expression. 2427 // tryEmitARCRetainScalarExpr does make an effort to do things 2428 // inside cleanups, but there are crazy cases like 2429 // @throw A().foo; 2430 // where a full retain+autorelease is required and would 2431 // otherwise happen after the destructor for the temporary. 2432 CodeGenFunction::RunCleanupsScope cleanups(*this); 2433 if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(expr)) 2434 expr = ewc->getSubExpr(); 2435 2436 return EmitARCRetainAutoreleaseScalarExpr(expr); 2437 } 2438 2439 // Otherwise, use the normal scalar-expression emission. The 2440 // exception machinery doesn't do anything special with the 2441 // exception like retaining it, so there's no safety associated with 2442 // only running cleanups after the throw has started, and when it 2443 // matters it tends to be substantially inferior code. 2444 return EmitScalarExpr(expr); 2445 } 2446 2447 std::pair<LValue,llvm::Value*> 2448 CodeGenFunction::EmitARCStoreStrong(const BinaryOperator *e, 2449 bool ignored) { 2450 // Evaluate the RHS first. 2451 TryEmitResult result = tryEmitARCRetainScalarExpr(*this, e->getRHS()); 2452 llvm::Value *value = result.getPointer(); 2453 2454 bool hasImmediateRetain = result.getInt(); 2455 2456 // If we didn't emit a retained object, and the l-value is of block 2457 // type, then we need to emit the block-retain immediately in case 2458 // it invalidates the l-value. 2459 if (!hasImmediateRetain && e->getType()->isBlockPointerType()) { 2460 value = EmitARCRetainBlock(value, /*mandatory*/ false); 2461 hasImmediateRetain = true; 2462 } 2463 2464 LValue lvalue = EmitLValue(e->getLHS()); 2465 2466 // If the RHS was emitted retained, expand this. 2467 if (hasImmediateRetain) { 2468 llvm::Value *oldValue = 2469 EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatileQualified(), 2470 lvalue.getAlignment(), e->getType(), 2471 lvalue.getTBAAInfo()); 2472 EmitStoreOfScalar(value, lvalue.getAddress(), 2473 lvalue.isVolatileQualified(), lvalue.getAlignment(), 2474 e->getType(), lvalue.getTBAAInfo()); 2475 EmitARCRelease(oldValue, /*precise*/ false); 2476 } else { 2477 value = EmitARCStoreStrong(lvalue, value, ignored); 2478 } 2479 2480 return std::pair<LValue,llvm::Value*>(lvalue, value); 2481 } 2482 2483 std::pair<LValue,llvm::Value*> 2484 CodeGenFunction::EmitARCStoreAutoreleasing(const BinaryOperator *e) { 2485 llvm::Value *value = EmitARCRetainAutoreleaseScalarExpr(e->getRHS()); 2486 LValue lvalue = EmitLValue(e->getLHS()); 2487 2488 EmitStoreOfScalar(value, lvalue.getAddress(), 2489 lvalue.isVolatileQualified(), lvalue.getAlignment(), 2490 e->getType(), lvalue.getTBAAInfo()); 2491 2492 return std::pair<LValue,llvm::Value*>(lvalue, value); 2493 } 2494 2495 void CodeGenFunction::EmitObjCAutoreleasePoolStmt( 2496 const ObjCAutoreleasePoolStmt &ARPS) { 2497 const Stmt *subStmt = ARPS.getSubStmt(); 2498 const CompoundStmt &S = cast<CompoundStmt>(*subStmt); 2499 2500 CGDebugInfo *DI = getDebugInfo(); 2501 if (DI) 2502 DI->EmitLexicalBlockStart(Builder, S.getLBracLoc()); 2503 2504 // Keep track of the current cleanup stack depth. 2505 RunCleanupsScope Scope(*this); 2506 if (CGM.getCodeGenOpts().ObjCRuntimeHasARC) { 2507 llvm::Value *token = EmitObjCAutoreleasePoolPush(); 2508 EHStack.pushCleanup<CallObjCAutoreleasePoolObject>(NormalCleanup, token); 2509 } else { 2510 llvm::Value *token = EmitObjCMRRAutoreleasePoolPush(); 2511 EHStack.pushCleanup<CallObjCMRRAutoreleasePoolObject>(NormalCleanup, token); 2512 } 2513 2514 for (CompoundStmt::const_body_iterator I = S.body_begin(), 2515 E = S.body_end(); I != E; ++I) 2516 EmitStmt(*I); 2517 2518 if (DI) 2519 DI->EmitLexicalBlockEnd(Builder, S.getRBracLoc()); 2520 } 2521 2522 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object, 2523 /// make sure it survives garbage collection until this point. 2524 void CodeGenFunction::EmitExtendGCLifetime(llvm::Value *object) { 2525 // We just use an inline assembly. 2526 llvm::FunctionType *extenderType 2527 = llvm::FunctionType::get(VoidTy, VoidPtrTy, /*variadic*/ false); 2528 llvm::Value *extender 2529 = llvm::InlineAsm::get(extenderType, 2530 /* assembly */ "", 2531 /* constraints */ "r", 2532 /* side effects */ true); 2533 2534 object = Builder.CreateBitCast(object, VoidPtrTy); 2535 Builder.CreateCall(extender, object)->setDoesNotThrow(); 2536 } 2537 2538 CGObjCRuntime::~CGObjCRuntime() {} 2539