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