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