clang  3.9.0
CGObjC.cpp
Go to the documentation of this file.
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"
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
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.
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.
47 {
48  llvm::Constant *C =
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 ///
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 
114  const ObjCMethodDecl *MethodWithObjects) {
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(
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(
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(
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 
227 }
228 
230  const ObjCDictionaryLiteral *E) {
232 }
233 
234 /// Emit a selector.
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 
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.
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
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.
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 
315  // It's never necessary for class objects.
316  return false;
317 
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.
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 
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()) {
381  ReceiverType = E->getInstanceReceiver()->getType();
382  if (retainSelf) {
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 
403  ReceiverType = E->getSuperType();
404  Receiver = LoadObjCSelf();
405  isSuperMessage = true;
406  break;
407 
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>() &&
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 {
489  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;
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.
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 
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 =
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.
559  StartObjCMethod(OMD, OMD->getClassInterface());
561  assert(isa<CompoundStmt>(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.
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.
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.
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.
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 
641  StrategyKind getKind() const { return StrategyKind(Kind); }
642 
643  bool hasStrongMember() const { return HasStrong; }
644  bool isAtomic() const { return IsAtomic; }
645  bool isCopy() const { return IsCopy; }
646 
647  CharUnits getIvarSize() const { return IvarSize; }
648  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.
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.
796  const ObjCPropertyImplDecl *PID) {
797  llvm::Constant *AtomicHelperFn =
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 
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.
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 =
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 =
857  CGF.EmitCall(
859  copyCppAtomicObjectFn, ReturnValueSlot(), args);
860 }
861 
862 void
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) {
871  /*nrvo*/ nullptr);
872  EmitReturnStmt(ret);
873  }
874  else {
875  ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl();
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 
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 =
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.
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: {
986 
987  QualType ivarType = ivar->getType();
988  switch (getEvaluationKind(ivarType)) {
989  case TEK_Complex: {
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.
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.
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(),
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(
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.
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 =
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(),
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 =
1108  CGF.EmitCall(
1110  copyCppAtomicObjectFn, ReturnValueSlot(), args);
1111 }
1112 
1113 
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 
1139  if (CGM.getLangOpts().getGC() != LangOptions::NonGC)
1140  return false;
1142 }
1143 
1144 void
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 =
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(),
1270  selfDecl->getType(), CK_LValueToRValue, &self,
1271  VK_RValue);
1272  ObjCIvarRefExpr ivarRef(ivar, ivar->getType().getNonReferenceType(),
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());
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  }
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.
1322  const ObjCPropertyImplDecl *PID) {
1323  llvm::Constant *AtomicHelperFn =
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:
1343  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 
1349  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.
1360  Address addr,
1361  QualType type) {
1362  llvm::Value *null = getNullForVariable(addr);
1363  CGF.EmitARCStoreStrongCall(addr, null, /*ignored*/ true);
1364 }
1365 
1367  ObjCImplementationDecl *impl) {
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 
1403  ObjCMethodDecl *MD,
1404  bool ctor) {
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);
1417  LoadObjCSelf(), Ivar, 0);
1418  EmitAggExpr(IvarInit->getInit(),
1422  }
1423  // constructor returns 'self'.
1424  CodeGenTypes &Types = CGM.getTypes();
1425  QualType IdTy(CGM.getContext().getObjCIdType());
1426  llvm::Value *SelfAsId =
1428  EmitReturnOfRValue(RValue::get(SelfAsId), IdTy);
1429 
1430  // Emit .cxx_destruct.
1431  } else {
1432  emitCXXDestructMethod(*this, IMP);
1433  }
1434  FinishFunction();
1435 }
1436 
1438  VarDecl *Self = cast<ObjCMethodDecl>(CurFuncDecl)->getSelfDecl();
1439  DeclRefExpr DRE(Self, /*is enclosing local*/ (CurFuncDecl != CurCodeDecl),
1440  Self->getType(), VK_LValue, SourceLocation());
1442 }
1443 
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 
1453  llvm::Constant *EnumerationMutationFn =
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.
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 =
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 
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(
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(),
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 =
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 
1742  CGM.getObjCRuntime().EmitTryStmt(*this, S);
1743 }
1744 
1746  CGM.getObjCRuntime().EmitThrowStmt(*this, S);
1747 }
1748 
1750  const ObjCAtSynchronizedStmt &S) {
1751  CGM.getObjCRuntime().EmitSynchronizedStmt(*this, S);
1752 }
1753 
1754 namespace {
1755  struct CallObjCRelease final : EHScopeStack::Cleanup {
1756  CallObjCRelease(llvm::Value *object) : object(object) {}
1757  llvm::Value *object;
1758 
1759  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.
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 
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.
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 
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.
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**)
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*)
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**)
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),
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)
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)
1940 llvm::Value *CodeGenFunction::EmitARCRetainNonBlock(llvm::Value *value) {
1941  return emitARCValueOperation(*this, value,
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.
1952 llvm::Value *CodeGenFunction::EmitARCRetainBlock(llvm::Value *value,
1953  bool mandatory) {
1954  llvm::Value *result
1955  = emitARCValueOperation(*this, value,
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 
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
1980  if (!marker) {
1981  StringRef assembly
1982  = CGF.CGM.getTargetCodeGenInfo()
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 *
2025  return emitARCValueOperation(*this, value,
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 *
2040  return emitARCValueOperation(*this, value,
2042  "objc_unsafeClaimAutoreleasedReturnValue");
2043 }
2044 
2045 /// Release the given object.
2046 /// call void \@objc_release(i8* %value)
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)
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)
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[] = {
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.
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() ||
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)
2154 llvm::Value *CodeGenFunction::EmitARCAutorelease(llvm::Value *value) {
2155  return emitARCValueOperation(*this, value,
2157  "objc_autorelease");
2158 }
2159 
2160 /// Autorelease the given object.
2161 /// call i8* \@objc_autoreleaseReturnValue(i8* %value)
2162 llvm::Value *
2164  return emitARCValueOperation(*this, value,
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 *
2174  return emitARCValueOperation(*this, value,
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)
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 *
2203  return emitARCValueOperation(*this, value,
2205  "objc_retainAutorelease");
2206 }
2207 
2208 /// i8* \@objc_loadWeak(i8** %addr)
2209 /// Essentially objc_autorelease(objc_loadWeakRetained(addr)).
2211  return emitARCLoadOperation(*this, addr,
2213  "objc_loadWeak");
2214 }
2215 
2216 /// i8* \@objc_loadWeakRetained(i8** %addr)
2218  return emitARCLoadOperation(*this, addr,
2220  "objc_loadWeakRetained");
2221 }
2222 
2223 /// i8* \@objc_storeWeak(i8** %addr, i8* %value)
2224 /// Returns %value.
2226  llvm::Value *value,
2227  bool ignored) {
2228  return emitARCStoreOperation(*this, addr, value,
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);
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,
2250  "objc_initWeak", /*ignored*/ true);
2251 }
2252 
2253 /// void \@objc_destroyWeak(i8** %addr)
2254 /// Essentially objc_storeWeak(addr, nil).
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)).
2273  emitARCCopyOperation(*this, dst, src,
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)))
2282  emitARCCopyOperation(*this, dst, src,
2284  "objc_copyWeak");
2285 }
2286 
2287 /// Produce the code to do a objc_autoreleasepool_push.
2288 /// call i8* \@objc_autoreleasePoolPush(void)
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)
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 ///
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];
2350  IdentifierInfo *II = &CGM.getContext().Idents.get("drain");
2351  Selector DrainSel = getContext().Selectors.getSelector(0, &II);
2352  CallArgList Args;
2354  getContext().VoidTy, DrainSel, Arg, Args);
2355 }
2356 
2358  Address addr,
2359  QualType type) {
2361 }
2362 
2364  Address addr,
2365  QualType type) {
2367 }
2368 
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 
2379  CallObjCAutoreleasePoolObject(llvm::Value *token) : Token(token) {}
2380 
2381  void Emit(CodeGenFunction &CGF, Flags flags) override {
2383  }
2384  };
2385  struct CallObjCMRRAutoreleasePoolObject final : EHScopeStack::Cleanup {
2386  llvm::Value *Token;
2387 
2388  CallObjCMRRAutoreleasePoolObject(llvm::Value *token) : Token(token) {}
2389 
2390  void Emit(CodeGenFunction &CGF, Flags flags) override {
2392  }
2393  };
2394 }
2395 
2397  if (CGM.getLangOpts().ObjCAutoRefCount)
2398  EHStack.pushCleanup<CallObjCAutoreleasePoolObject>(NormalCleanup, Ptr);
2399  else
2400  EHStack.pushCleanup<CallObjCMRRAutoreleasePoolObject>(NormalCleanup, Ptr);
2401 }
2402 
2404  LValue lvalue,
2405  QualType type) {
2406  switch (type.getObjCLifetime()) {
2407  case Qualifiers::OCL_None:
2411  return TryEmitResult(CGF.EmitLoadOfLValue(lvalue,
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 
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() &&
2434  // Emit the lvalue.
2435  LValue lv = CGF.EmitLValue(e);
2436 
2437  // Load the object pointer.
2438  llvm::Value *result = CGF.EmitLoadOfLValue(lv,
2440 
2441  // Set the source pointer to NULL.
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() &&
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)>
2463 
2464 /// Insert code immediately after a call.
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.
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.
2523  const Expr *e) {
2524  llvm::Value *value = CGF.EmitScalarExpr(e);
2525  return emitARCOperationAfterCall(CGF, value,
2526  [](CodeGenFunction &CGF, llvm::Value *value) {
2528  },
2529  [](CodeGenFunction &CGF, llvm::Value *value) {
2530  return value;
2531  });
2532 }
2533 
2535  bool allowUnsafeClaim) {
2536  if (allowUnsafeClaim &&
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.
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;
2587  Impl &asImpl() { return *static_cast<Impl*>(this); }
2588 
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
2620 ARCExprEmitter<Impl,Result>::visitPseudoObjectExpr(const PseudoObjectExpr *E) {
2622 
2623  // Find the result expression.
2624  const Expr *resultExpr = E->getResultExpr();
2625  assert(resultExpr);
2626  Result result;
2627 
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)) {
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>
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
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>
2723 Result ARCExprEmitter<Impl,Result>::visitBinAssign(const BinaryOperator *e) {
2724  switch (e->getLHS()->getType().getObjCLifetime()) {
2726  return asImpl().visitBinAssignUnsafeUnretained(e);
2727 
2728  case Qualifiers::OCL_Weak:
2729  return asImpl().visitBinAssignWeak(e);
2730 
2732  return asImpl().visitBinAssignAutoreleasing(e);
2733 
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>::
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
2763 ARCExprEmitter<Impl,Result>::visitBinAssignAutoreleasing(const BinaryOperator *e) {
2764  return asImpl().visitExpr(e);
2765 }
2766 
2767 template <typename Impl, typename Result>
2768 Result
2769 ARCExprEmitter<Impl,Result>::visitBinAssignWeak(const BinaryOperator *e) {
2770  return asImpl().visitExpr(e);
2771 }
2772 
2773 template <typename Impl, typename Result>
2774 Result
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>
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 
2824  ARCRetainExprEmitter(CodeGenFunction &CGF) : ARCExprEmitter(CGF) {}
2825 
2826  llvm::Value *getValueOfResult(TryEmitResult result) {
2827  return result.getPointer();
2828  }
2829 
2830  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 
2837  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.
2843  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.
2851  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.
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.
2879  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.
2885  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 
2892  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
2903  return ARCRetainExprEmitter(CGF).visit(e);
2904 }
2905 
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.
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 *
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 
2954  llvm::Value *result;
2955  bool doRetain;
2956 
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 
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.
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 
2993  ARCUnsafeUnretainedExprEmitter(CodeGenFunction &CGF) : ARCExprEmitter(CGF) {}
2994 
2995  llvm::Value *getValueOfResult(llvm::Value *value) {
2996  return value;
2997  }
2998 
2999  llvm::Value *emitBitCast(llvm::Value *value, llvm::Type *resultType) {
3000  return CGF.Builder.CreateBitCast(value, resultType);
3001  }
3002 
3003  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.
3009  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.)
3016  llvm::Value *visitExtendBlockObject(const Expr *e) {
3017  return CGF.EmitARCExtendBlockObject(e);
3018  }
3019 
3020  /// For reclaims, perform an unsafeClaim if that's enabled.
3021  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.
3027  llvm::Value *visitCall(const Expr *e) {
3028  return CGF.EmitScalarExpr(e);
3029  }
3030 
3031  /// Just do normal scalar emission in the default case.
3032  llvm::Value *visitExpr(const Expr *e) {
3033  return CGF.EmitScalarExpr(e);
3034  }
3035 };
3036 }
3037 
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.
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*>
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) {
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*>
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*>
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 
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)
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)
3142 }
3143 
3144 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
3145 /// make sure it survives garbage collection until this point.
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 *
3166  const ObjCPropertyImplDecl *PID) {
3167  if (!getLangOpts().CPlusPlus ||
3169  return nullptr;
3170  QualType Ty = PID->getPropertyIvarDecl()->getType();
3171  if (!Ty->isRecordType())
3172  return nullptr;
3173  const ObjCPropertyDecl *PD = PID->getPropertyDecl();
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_");
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 =
3207 
3208  llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
3209 
3210  llvm::Function *Fn =
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,
3221  UnaryOperator DST(&DstExpr, UO_Deref, DestTy->getPointeeType(),
3223 
3224  DeclRefExpr SrcExpr(&srcDecl, false, SrcTy,
3226  UnaryOperator SRC(&SrcExpr, UO_Deref, SrcTy->getPointeeType(),
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 *
3245  const ObjCPropertyImplDecl *PID) {
3246  if (!getLangOpts().CPlusPlus ||
3248  return nullptr;
3249  const ObjCPropertyDecl *PD = PID->getPropertyDecl();
3250  QualType Ty = PD->getType();
3251  if (!Ty->isRecordType())
3252  return nullptr;
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_");
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 =
3288 
3289  llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
3290 
3291  llvm::Function *Fn =
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,
3301 
3302  UnaryOperator SRC(&SrcExpr, UO_Deref, SrcTy->getPointeeType(),
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 =
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,
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(),
3337 
3338  FinishFunction();
3339  HelperFn = llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy);
3340  CGM.setAtomicGetterHelperFnMap(Ty, HelperFn);
3341  return HelperFn;
3342 }
3343 
3344 llvm::Value *
3346  // Get selectors for retain/autorelease.
3347  IdentifierInfo *CopyID = &getContext().Idents.get("copy");
3348  Selector CopySelector =
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 
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
Definition: CGCall.cpp:599
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:52
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1009
param_const_iterator param_begin() const
Definition: DeclObjC.h:354
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:151
static bool UseOptimizedSetter(CodeGenModule &CGM)
Definition: CGObjC.cpp:1138
Defines the clang::ASTContext interface.
bool isAtomic() const
isAtomic - Return true if the property is atomic.
Definition: DeclObjC.h:818
CastKind getCastKind() const
Definition: Expr.h:2680
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1561
llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)
Store into a strong object.
Definition: CGObjC.cpp:2119
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1367
The receiver is an object instance.
Definition: ExprObjC.h:1005
llvm::Value * EmitARCReclaimReturnedObject(const Expr *e, bool allowUnsafeClaim)
Definition: CGObjC.cpp:2534
void EmitCallArgs(CallArgList &Args, const T *CallArgTypeInfo, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, const FunctionDecl *CalleeDecl=nullptr, unsigned ParamsToSkip=0)
EmitCallArgs - Emit call arguments for a function.
static llvm::Value * emitARCRetainCallResult(CodeGenFunction &CGF, const Expr *e)
Given that the given expression is some sort of call (which does not return retained), emit a retain following it.
Definition: CGObjC.cpp:2508
Smart pointer class that efficiently represents Objective-C method names.
llvm::Value * EmitARCRetainAutoreleaseScalarExpr(const Expr *expr)
Definition: CGObjC.cpp:2936
static bool hasTrivialGetExpr(const ObjCPropertyImplDecl *propImpl)
Definition: CGObjC.cpp:809
ObjCEntrypoints & getObjCEntrypoints() const
CanQualType VoidPtrTy
Definition: ASTContext.h:908
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
Definition: CGDecl.cpp:1429
A (possibly-)qualified type.
Definition: Type.h:598
static bool hasUnalignedAtomics(llvm::Triple::ArchType arch)
Determine whether the given architecture supports unaligned atomic accesses.
Definition: CGObjC.cpp:600
void EmitExtendGCLifetime(llvm::Value *object)
EmitExtendGCLifetime - Given a pointer to an Objective-C object, make sure it survives garbage collec...
Definition: CGObjC.cpp:3146
llvm::Value * getPointer() const
Definition: CGValue.h:327
llvm::Value * EmitARCExtendBlockObject(const Expr *expr)
Definition: CGObjC.cpp:2953
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1071
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2361
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1032
virtual llvm::Function * GenerateMethod(const ObjCMethodDecl *OMD, const ObjCContainerDecl *CD)=0
Generate a function preamble for a method with the specified types.
llvm::Module & getModule() const
QualType getClassReceiver() const
Returns the type of a class message send, or NULL if the message is not a class message.
Definition: ExprObjC.h:1174
bool isDelegateInitCall() const
isDelegateInitCall - Answers whether this message send has been tagged as a "delegate init call"...
Definition: ExprObjC.h:1307
static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
Definition: CGValue.h:524
void EmitARCDestroyWeak(Address addr)
void @objc_destroyWeak(i8** addr) Essentially objc_storeWeak(addr, nil).
Definition: CGObjC.cpp:2255
virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, ReturnValueSlot ReturnSlot, QualType ResultType, Selector Sel, llvm::Value *Receiver, const CallArgList &CallArgs, const ObjCInterfaceDecl *Class=nullptr, const ObjCMethodDecl *Method=nullptr)=0
Generate an Objective-C message send operation.
void EmitLexicalBlockEnd(CGBuilderTy &Builder, SourceLocation Loc)
Emit metadata to indicate the end of a new lexical block and pop the current block.
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Implements runtime-specific code generation functions.
Definition: CGObjCRuntime.h:63
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:761
static RValue AdjustObjCObjectType(CodeGenFunction &CGF, QualType ET, RValue Result)
Adjust the type of an Objective-C object that doesn't match up due to type erasure at various points...
Definition: CGObjC.cpp:251
bool isRecordType() const
Definition: Type.h:5539
llvm::Constant * objc_autoreleaseReturnValue
id objc_autoreleaseReturnValue(id);
Address getAddress() const
Definition: CGValue.h:331
bool hasARCUnsafeClaimAutoreleasedReturnValue() const
Is objc_unsafeClaimAutoreleasedReturnValue available?
Definition: ObjCRuntime.h:312
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
const llvm::DataLayout & getDataLayout() const
static Destroyer destroyARCStrongPrecise
Represents Objective-C's @throw statement.
Definition: StmtObjC.h:313
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
Definition: CGExpr.cpp:1593
void GenerateObjCSetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCSetter - Synthesize an Objective-C property setter function for the given property...
Definition: CGObjC.cpp:1321
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5031
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1162
llvm::Constant * objc_loadWeakRetained
id objc_loadWeakRetained(id*);
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
void EmitARCCopyWeak(Address dst, Address src)
void @objc_copyWeak(i8** dest, i8** src) Disregards the current value in dest.
Definition: CGObjC.cpp:2281
llvm::Value * EmitObjCMRRAutoreleasePoolPush()
Produce the code to do an MRR version objc_autoreleasepool_push.
Definition: CGObjC.cpp:2324
llvm::Constant * GenerateObjCAtomicSetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
GenerateObjCAtomicSetterCopyHelperFunction - Given a c++ object type with non-trivial copy assignment...
Definition: CGObjC.cpp:3165
const LangOptions & getLangOpts() const
bool isBlockPointerType() const
Definition: Type.h:5488
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
Definition: CGObjC.cpp:1940
static llvm::Value * emitARCRetainLoadOfScalar(CodeGenFunction &CGF, LValue lvalue, QualType type)
Definition: CGObjC.cpp:2906
void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID)
createImplicitParams - Used to lazily create the self and cmd implict parameters. ...
Definition: DeclObjC.cpp:1050
llvm::function_ref< llvm::Value *(CodeGenFunction &CGF, llvm::Value *value)> ValueTransform
Definition: CGObjC.cpp:2462
static CXXConstructExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, CXXConstructorDecl *Ctor, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, ConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Definition: ExprCXX.cpp:751
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Definition: ExprObjC.h:309
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:768
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:52
Expr * getSetterCXXAssignment() const
Definition: DeclObjC.h:2750
const Expr * getCallee() const
Definition: Expr.h:2188
ObjCLifetime getObjCLifetime() const
Definition: Type.h:308
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclObjC.h:291
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
llvm::Value * EmitObjCAutoreleasePoolPush()
Produce the code to do a objc_autoreleasepool_push.
Definition: CGObjC.cpp:2289
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1813
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
Definition: CGDebugInfo.h:52
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
llvm::Value * EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty)
Definition: CGObjC.cpp:3345
llvm::Constant * getAtomicSetterHelperFnMap(QualType Ty)
Defines the Objective-C statement AST node classes.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:2936
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1377
bool isObjCRetainableType() const
Definition: Type.cpp:3699
llvm::Value * EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E)
Definition: CGObjC.cpp:229
QualType getType() const
Definition: DeclObjC.h:781
The collection of all-type qualifiers we support.
Definition: Type.h:117
virtual llvm::Constant * GetOptimizedPropertySetFunction(bool atomic, bool copy)=0
Return the runtime function for optimized setting properties.
A jump destination is an abstract label, branching to which may require a jump out through normal cle...
llvm::Constant * getPointer() const
Definition: Address.h:84
llvm::Value * EmitObjCThrowOperand(const Expr *expr)
Definition: CGObjC.cpp:2971
llvm::Constant * objc_autorelease
id objc_autorelease(id);
llvm::Constant * objc_copyWeak
void objc_copyWeak(id *dest, id *src);
llvm::Constant * getAtomicGetterHelperFnMap(QualType Ty)
One of these records is kept for each identifier that is lexed.
void emitDestroy(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
emitDestroy - Immediately perform the destruction of the given object.
Definition: CGDecl.cpp:1505
ObjCProtocolDecl * getProtocol() const
Definition: ExprObjC.h:453
static void emitStructGetterCall(CodeGenFunction &CGF, ObjCIvarDecl *ivar, bool isAtomic, bool hasStrong)
emitStructGetterCall - Call the runtime function to load a property into the return value slot...
Definition: CGObjC.cpp:569
Represents a class type in Objective C.
Definition: Type.h:4727
llvm::Constant * objc_loadWeak
id objc_loadWeak(id*);
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:92
std::pair< LValue, llvm::Value * > EmitARCStoreAutoreleasing(const BinaryOperator *e)
Definition: CGObjC.cpp:3109
llvm::Constant * objc_retainAutoreleasedReturnValue
id objc_retainAutoreleasedReturnValue(id);
llvm::Value * EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr)
Definition: CGObjC.cpp:1776
bool isReferenceType() const
Definition: Type.h:5491
llvm::Value * EmitARCRetainAutoreleaseReturnValue(llvm::Value *value)
Do a fused retain/autorelease of the given object.
Definition: CGObjC.cpp:2173
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2293
ImplicitParamDecl * getCmdDecl() const
Definition: DeclObjC.h:408
StringLiteral * getString()
Definition: ExprObjC.h:40
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:81
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
llvm::Value * EmitARCAutoreleaseReturnValue(llvm::Value *value)
Autorelease the given object.
Definition: CGObjC.cpp:2163
void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, ObjCMethodDecl *MD, bool ctor)
Definition: CGObjC.cpp:1402
SourceLocation getLBracLoc() const
Definition: Stmt.h:629
Expr * getSubExpr()
Definition: Expr.h:2684
RValue EmitCall(const CGFunctionInfo &FnInfo, llvm::Value *Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, CGCalleeInfo CalleeInfo=CGCalleeInfo(), llvm::Instruction **callOrInvoke=nullptr)
EmitCall - Generate a call of the given function, expecting the given result type, and using the given argument list which specifies both the LLVM arguments and the types they were derived from.
Definition: CGCall.cpp:3507
virtual llvm::Constant * GetPropertySetFunction()=0
Return the runtime function for setting properties.
CleanupKind getCleanupKind(QualType::DestructionKind kind)
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
Definition: ExprObjC.h:144
llvm::Value * EmitObjCBoxedExpr(const ObjCBoxedExpr *E)
EmitObjCBoxedExpr - This routine generates code to call the appropriate expression boxing method...
Definition: CGObjC.cpp:60
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2007
IdentifierTable & Idents
Definition: ASTContext.h:459
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:105
Expr * getLHS() const
Definition: Expr.h:2943
ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)
EmitLoadOfComplex - Load a complex number from the specified l-value.
const Expr *const * const_semantics_iterator
Definition: Expr.h:4746
virtual CodeGen::RValue GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, ReturnValueSlot ReturnSlot, QualType ResultType, Selector Sel, const ObjCInterfaceDecl *Class, bool isCategoryImpl, llvm::Value *Self, bool IsClassMessage, const CallArgList &CallArgs, const ObjCMethodDecl *Method=nullptr)=0
Generate an Objective-C message send operation to the super class initiated in a method for Class and...
RValue EmitAnyExpr(const Expr *E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
EmitAnyExpr - Emit code to compute the specified expression which can have any type.
Definition: CGExpr.cpp:140
llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)
Store into a strong object.
Definition: CGObjC.cpp:2093
llvm::Constant * objc_initWeak
id objc_initWeak(id*, id);
bool hasOptimizedSetter() const
Does this runtime supports optimized setter entrypoints?
Definition: ObjCRuntime.h:175
llvm::Value * EmitObjCStringLiteral(const ObjCStringLiteral *E)
Emits an instance of NSConstantString representing the object.
Definition: CGObjC.cpp:46
Selector getNullarySelector(IdentifierInfo *ID)
ObjCMethodDecl * getBoxingMethod() const
Definition: ExprObjC.h:111
CharUnits getAlignment() const
Definition: CGValue.h:316
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:901
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
Definition: CGBuilder.h:168
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise)
Destroy a __strong variable.
Definition: CGObjC.cpp:2079
const Qualifiers & getQuals() const
Definition: CGValue.h:311
static llvm::Value * emitARCUnsafeClaimCallResult(CodeGenFunction &CGF, const Expr *e)
Given that the given expression is some sort of call (which does not return retained), perform an unsafeClaim following it.
Definition: CGObjC.cpp:2522
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Definition: DeclObjC.cpp:913
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
Definition: ObjCRuntime.h:160
QualType getSuperType() const
Retrieve the type referred to by 'super'.
Definition: ExprObjC.h:1231
semantics_iterator semantics_end()
Definition: Expr.h:4753
llvm::Constant * objc_release
void objc_release(id);
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2897
Selector getSelector() const
Definition: ExprObjC.cpp:306
Expr * getGetterCXXConstructor() const
Definition: DeclObjC.h:2743
llvm::Value * EmitARCUnsafeUnretainedScalarExpr(const Expr *expr)
EmitARCUnsafeUnretainedScalarExpr - Semantically equivalent to immediately releasing the resut of Emi...
Definition: CGObjC.cpp:3047
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:4970
void setAtomicGetterHelperFnMap(QualType Ty, llvm::Constant *Fn)
llvm::Value * EmitARCLoadWeak(Address addr)
i8* @objc_loadWeak(i8** addr) Essentially objc_autorelease(objc_loadWeakRetained(addr)).
Definition: CGObjC.cpp:2210
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:29
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
void incrementProfileCounter(const Stmt *S)
Increment the profiler's counter for the given statement.
void EmitStmt(const Stmt *S)
EmitStmt - Emit the code for the statement.
Definition: CGStmt.cpp:48
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
llvm::Value * EmitARCRetainScalarExpr(const Expr *expr)
EmitARCRetainScalarExpr - Semantically equivalent to EmitARCRetainObject(e->getType(), EmitScalarExpr(e)), but making a best-effort attempt to peephole expressions that naturally produce retained objects.
Definition: CGObjC.cpp:2920
static bool shouldEmitSeparateBlockRetain(const Expr *e)
Determine whether it might be important to emit a separate objc_retain_block on the result of the giv...
Definition: CGObjC.cpp:2548
Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...
Definition: EHScopeStack.h:85
void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn)
Assign counters to regions and configure them for PGO of a given function.
Definition: CodeGenPGO.cpp:614
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2632
bool requiresCleanups() const
Determine whether this scope requires any cleanups.
Expr * Key
The key for the dictionary element.
Definition: ExprObjC.h:214
virtual llvm::Constant * GetGetStructFunction()=0
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
An ordinary object is located at an address in memory.
Definition: Specifiers.h:121
uint64_t getCurrentProfileCount()
Get the profiler's current count.
Represents an ObjC class declaration.
Definition: DeclObjC.h:1091
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclObjC.cpp:907
detail::InMemoryDirectory::const_iterator I
PropertyAttributeKind getPropertyAttributes() const
Definition: DeclObjC.h:792
static TryEmitResult tryEmitARCRetainScalarExpr(CodeGenFunction &CGF, const Expr *e)
Definition: CGObjC.cpp:2902
std::pair< CharUnits, CharUnits > getTypeInfoInChars(const Type *T) const
QualType getType() const
Definition: Decl.h:599
llvm::Value * EmitARCRetainAutoreleasedReturnValue(llvm::Value *value)
Retain the given object which is the result of a function call.
Definition: CGObjC.cpp:2023
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, bool isConstexprSpecified=false)
Definition: Decl.h:1720
llvm::Value * EmitARCRetainAutoreleaseNonBlock(llvm::Value *value)
Do a fused retain/autorelease of the given object.
Definition: CGObjC.cpp:2202
This object can be modified without requiring retains or releases.
Definition: Type.h:138
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2655
llvm::CallSite EmitRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef< llvm::Value * > args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
Definition: CGCall.cpp:3456
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource AlignSource=AlignmentSource::Type)
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
Definition: CGObjC.cpp:341
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:349
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:551
AutoVarEmission EmitAutoVarAlloca(const VarDecl &var)
EmitAutoVarAlloca - Emit the alloca and debug information for a local variable.
Definition: CGDecl.cpp:953
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
llvm::CallInst * EmitNounwindRuntimeCall(llvm::Value *callee, const Twine &name="")
const TargetCodeGenInfo & getTargetCodeGenInfo()
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1009
void EmitAnyExprToMem(const Expr *E, Address Location, Qualifiers Quals, bool IsInitializer)
EmitAnyExprToMem - Emits the code necessary to evaluate an arbitrary expression into the given memory...
Definition: CGExpr.cpp:169
llvm::Constant * objc_storeStrong
id objc_storeStrong(id*, id);
const TargetInfo & getTarget() const
CastKind
CastKind - The kind of operation required for a conversion.
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:38
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
CleanupKind getARCCleanupKind()
Retrieves the default cleanup kind for an ARC cleanup.
ASTContext * Context
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
bool isUnarySelector() const
llvm::Value * EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored)
i8* @objc_storeWeak(i8** addr, i8* value) Returns value.
Definition: CGObjC.cpp:2225
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1251
static TypeEvaluationKind getEvaluationKind(QualType T)
hasAggregateLLVMType - Return true if the specified AST type will map into an aggregate LLVM type or ...
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
static bool shouldExtendReceiverForInnerPointerMessage(const ObjCMessageExpr *message)
Decide whether to extend the lifetime of the receiver of a returns-inner-pointer message.
Definition: CGObjC.cpp:269
llvm::Value * getPointer() const
Definition: Address.h:38
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:590
Expr - This represents one expression.
Definition: Expr.h:105
llvm::Constant * objc_autoreleasePoolPop
void objc_autoreleasePoolPop(void*);
void EmitARCMoveWeak(Address dst, Address src)
void @objc_moveWeak(i8** dest, i8** src) Disregards the current value in dest.
Definition: CGObjC.cpp:2272
virtual llvm::Constant * GetSetStructFunction()=0
void EmitAutoVarInit(const AutoVarEmission &emission)
Definition: CGDecl.cpp:1178
static Address invalid()
Definition: Address.h:35
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
SetterKind getSetterKind() const
getSetterKind - Return the method used for doing assignment in the property setter.
Definition: DeclObjC.h:842
void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource AlignSource=AlignmentSource::Type, llvm::MDNode *TBAAInfo=nullptr, bool isInit=false, QualType TBAABaseTy=QualType(), uint64_t TBAAOffset=0, bool isNontemporal=false)
EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...
Definition: CGExpr.cpp:1374
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
Generate an Objective-C method.
Definition: CGObjC.cpp:558
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:2721
static void emitStructSetterCall(CodeGenFunction &CGF, ObjCMethodDecl *OMD, ObjCIvarDecl *ivar)
emitStructSetterCall - Call the runtime function to store the value from the first formal parameter i...
Definition: CGObjC.cpp:1038
void SetInternalFunctionAttributes(const Decl *D, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, bool ClearInsertionPoint=true)=0
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:886
llvm::Constant * objc_retain
id objc_retain(id);
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:257
ASTContext & getContext() const
llvm::BasicBlock * getBlock() const
Represents Objective-C's @synchronized statement.
Definition: StmtObjC.h:262
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:397
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
FormatToken * Token
void generateObjCSetterBody(const ObjCImplementationDecl *classImpl, const ObjCPropertyImplDecl *propImpl, llvm::Constant *AtomicHelperFn)
Definition: CGObjC.cpp:1145
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:406
void add(RValue rvalue, QualType type, bool needscopy=false)
Definition: CGCall.h:81
virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtTryStmt &S)=0
llvm::Value * EmitARCAutorelease(llvm::Value *value)
Autorelease the given object.
Definition: CGObjC.cpp:2154
Selector getSelector() const
Definition: ExprObjC.h:409
llvm::LLVMContext & getLLVMContext()
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
Definition: ExprObjC.h:184
const CGFunctionInfo & arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args)
Definition: CGCall.cpp:586
virtual llvm::Value * GetSelector(CodeGenFunction &CGF, Selector Sel)=0
Get a selector for the specified name and type values.
Expr * getElement(unsigned Index)
getExpr - Return the Expr at the specified index.
Definition: ExprObjC.h:187
bool isInstanceMethod() const
Definition: DeclObjC.h:414
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:93
virtual llvm::Constant * GetPropertyGetFunction()=0
Return the runtime function for getting properties.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1613
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:1366
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:860
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1668
ValueDecl * getDecl()
Definition: Expr.h:1017
bool isGLValue() const
Definition: Expr.h:250
The result type of a method or function.
ARCPreciseLifetime_t isARCPreciseLifetime() const
Definition: CGValue.h:279
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
forAddr - Make a slot for an aggregate value.
Definition: CGValue.h:502
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:29
static llvm::Value * emitARCStoreOperation(CodeGenFunction &CGF, Address addr, llvm::Value *value, llvm::Constant *&fn, StringRef fnName, bool ignored)
Perform an operation having the following signature: i8* (i8**, i8*)
Definition: CGObjC.cpp:1875
param_const_iterator param_end() const
Definition: DeclObjC.h:357
virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtSynchronizedStmt &S)=0
The l-value was considered opaque, so the alignment was determined from a type.
bool isClassMethod() const
Definition: DeclObjC.h:419
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:371
llvm::Constant * objc_retainBlock
id objc_retainBlock(id);
There is no lifetime qualification on this type.
Definition: Type.h:134
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:848
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:160
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
SelectorTable & Selectors
Definition: ASTContext.h:460
llvm::Constant * CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeSet ExtraAttrs=llvm::AttributeSet())
Create a new runtime function with the specified type and name.
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:145
Kind
llvm::Constant * objc_storeWeak
id objc_storeWeak(id*, id);
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4679
static llvm::Value * emitARCUnsafeUnretainedScalarExpr(CodeGenFunction &CGF, const Expr *e)
Definition: CGObjC.cpp:3038
ASTContext & getContext() const
Encodes a location in the source.
llvm::Value * EmitObjCArrayLiteral(const ObjCArrayLiteral *E)
Definition: CGObjC.cpp:225
body_range body()
Definition: Stmt.h:581
void EmitARCIntrinsicUse(ArrayRef< llvm::Value * > values)
Given a number of pointers, inform the optimizer that they're being intrinsically used up until this ...
Definition: CGObjC.cpp:1783
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
static void emitCPPObjectAtomicGetterCall(CodeGenFunction &CGF, llvm::Value *returnAddr, ObjCIvarDecl *ivar, llvm::Constant *AtomicHelperFn)
emitCPPObjectAtomicGetterCall - Call the runtime function to copy the ivar into the resturn slot...
Definition: CGObjC.cpp:834
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
Definition: CGObjC.cpp:2047
LValue EmitDeclRefLValue(const DeclRefExpr *E)
Definition: CGExpr.cpp:2072
std::pair< LValue, llvm::Value * > EmitARCStoreUnsafeUnretained(const BinaryOperator *e, bool ignored)
Definition: CGObjC.cpp:3059
const TemplateArgument * iterator
Definition: Type.h:4233
virtual ConstantAddress GenerateConstantString(const StringLiteral *)=0
Generate a constant string object.
llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource AlignSource=AlignmentSource::Type, llvm::MDNode *TBAAInfo=nullptr, QualType TBAABaseTy=QualType(), uint64_t TBAAOffset=0, bool isNontemporal=false)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
Definition: CGExpr.cpp:1262
void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S)
Definition: CGObjC.cpp:1452
llvm::Value * EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value)
Claim a possibly-autoreleased return value at +0.
Definition: CGObjC.cpp:2038
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > PL, ArrayRef< Expr * > IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:443
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
Definition: DeclObjC.cpp:784
QualType withConst() const
Definition: Type.h:764
llvm::Constant * objc_autoreleasePoolPush
void *objc_autoreleasePoolPush(void);
static TryEmitResult tryEmitARCRetainLoadOfScalar(CodeGenFunction &CGF, LValue lvalue, QualType type)
Definition: CGObjC.cpp:2403
const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)
Objective-C methods are C functions with some implicit parameters.
Definition: CGCall.cpp:405
virtual llvm::Value * EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF)
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2325
CanQualType VoidTy
Definition: ASTContext.h:893
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:441
virtual llvm::Value * GenerateProtocolRef(CodeGenFunction &CGF, const ObjCProtocolDecl *OPD)=0
Emit the code to return the named protocol as an object, as in a @protocol expression.
llvm::InlineAsm * retainAutoreleasedReturnValueMarker
A void(void) inline asm to use to mark that the return value of a call will be immediately retain...
static llvm::Constant * createARCRuntimeFunction(CodeGenModule &CGM, llvm::FunctionType *type, StringRef fnName)
Definition: CGObjC.cpp:1797
const CodeGenOptions & getCodeGenOpts() const
An aligned address.
Definition: Address.h:25
void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())
Emit code for the start of a function.
const LangOptions & getLangOpts() const
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:699
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2734
QualType getReturnType() const
Definition: DeclObjC.h:330
JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
Expr * getSubExpr()
Definition: ExprObjC.h:108
static void destroyARCStrongWithStore(CodeGenFunction &CGF, Address addr, QualType type)
Like CodeGenFunction::destroyARCStrong, but do it with a call.
Definition: CGObjC.cpp:1359
Assigning into this object requires a lifetime extension.
Definition: Type.h:151
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:94
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5329
virtual llvm::Constant * GetCppAtomicObjectGetFunction()=0
API for atomic copying of qualified aggregates with non-trivial copy assignment (c++) in getter...
llvm::Value * EmitARCRetain(QualType type, llvm::Value *value)
Produce the code to do a retain.
Definition: CGObjC.cpp:1931
void enterFullExpression(const ExprWithCleanups *E)
static Destroyer destroyARCStrongImprecise
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
Expr * Value
The value of the dictionary element.
Definition: ExprObjC.h:217
ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)
Returns a pointer to a character array containing the literal and a terminating '\0' character...
void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr)
Produce the code to do a primitive release.
Definition: CGObjC.cpp:2349
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1155
FunctionArgList - Type for representing both the decl and type of parameters to a function...
Definition: CGCall.h:146
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1882
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
QualType getType() const
Definition: Expr.h:126
Expr * getResultExpr()
Return the result-bearing expression, or null if there is none.
Definition: Expr.h:4734
void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S)
Definition: CGObjC.cpp:1749
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
llvm::Constant * objc_unsafeClaimAutoreleasedReturnValue
id objc_unsafeClaimAutoreleasedReturnValue(id);
static llvm::Value * emitARCValueOperation(CodeGenFunction &CGF, llvm::Value *value, llvm::Constant *&fn, StringRef fnName, bool isTailCall=false)
Perform an operation having the signature i8* (i8*) where a null input causes a no-op and returns nul...
Definition: CGObjC.cpp:1821
void GenerateObjCGetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCGetter - Synthesize an Objective-C property getter function.
Definition: CGObjC.cpp:795
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr)
Produce the code to do a primitive release.
Definition: CGObjC.cpp:2302
Address CreateMemTemp(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignment...
Definition: CGExpr.cpp:98
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1983
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:25
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:58
llvm::Value * EmitARCLoadWeakRetained(Address addr)
i8* @objc_loadWeakRetained(i8** addr)
Definition: CGObjC.cpp:2217
Address CreateStructGEP(Address Addr, unsigned Index, CharUnits Offset, const llvm::Twine &Name="")
Definition: CGBuilder.h:183
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:91
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:70
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
llvm::Constant * objc_destroyWeak
void objc_destroyWeak(id*);
U cast(CodeGen::Address addr)
Definition: Address.h:109
llvm::Constant * clang_arc_use
void clang.arc.use(...);
QualType TypeOfSelfObject()
TypeOfSelfObject - Return type of object that this self represents.
Definition: CGObjC.cpp:1444
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Selector getSelector() const
Definition: DeclObjC.h:328
Checking the destination of a store. Must be suitably sized and aligned.
ObjCMethodDecl * getArrayWithObjectsMethod() const
Definition: ExprObjC.h:196
detail::InMemoryDirectory::const_iterator E
void EmitAggregateCopy(Address DestPtr, Address SrcPtr, QualType EltTy, bool isVolatile=false, bool isAssignment=false)
EmitAggregateCopy - Emit an aggregate copy.
Definition: CGExprAgg.cpp:1459
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:113
semantics_iterator semantics_begin()
Definition: Expr.h:4747
llvm::Constant * GenerateObjCAtomicGetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
Definition: CGObjC.cpp:3244
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1966
static bool hasTrivialSetExpr(const ObjCPropertyImplDecl *PID)
Definition: CGObjC.cpp:1114
void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S)
Definition: CGObjC.cpp:1745
virtual StringRef getARCRetainAutoreleasedReturnValueMarker() const
Retrieve the address of a function to call immediately before calling objc_retainAutoreleasedReturnVa...
static CharUnits getMaxAtomicAccessSize(CodeGenModule &CGM, llvm::Triple::ArchType arch)
Return the maximum size that permits atomic accesses for the given architecture.
Definition: CGObjC.cpp:608
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type. ...
Definition: CGExprAgg.cpp:1437
ObjCMethodDecl * getDictWithObjectsMethod() const
Definition: ExprObjC.h:323
Defines the Diagnostic-related interfaces.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5006
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:5432
Represents a pointer to an Objective C object.
Definition: Type.h:4991
void EmitAutoVarCleanups(const AutoVarEmission &emission)
Definition: CGDecl.cpp:1382
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2461
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:860
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:44
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3707
static llvm::Value * emitARCOperationAfterCall(CodeGenFunction &CGF, llvm::Value *value, ValueTransform doAfterCall, ValueTransform doFallback)
Insert code immediately after a call.
Definition: CGObjC.cpp:2465
virtual llvm::Constant * EnumerationMutationFunction()=0
EnumerationMutationFunction - Return the function that's called by the compiler when a mutation is de...
bool isXValue() const
Definition: Expr.h:249
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5818
QualType getCanonicalType() const
Definition: Type.h:5298
const Stmt * getSubStmt() const
Definition: StmtObjC.h:356
Represents Objective-C's collection statement.
Definition: StmtObjC.h:24
Address CreateConstArrayGEP(Address Addr, uint64_t Index, CharUnits EltSize, const llvm::Twine &Name="")
Given addr = [n x T]* ...
Definition: CGBuilder.h:206
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
static void emitARCCopyOperation(CodeGenFunction &CGF, Address dst, Address src, llvm::Constant *&fn, StringRef fnName)
Perform an operation having the following signature: void (i8**, i8**)
Definition: CGObjC.cpp:1906
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:863
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
Definition: CodeGenTypes.h:120
LValue EmitLValueForIvar(QualType ObjectTy, llvm::Value *Base, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)
Definition: CGExpr.cpp:3945
llvm::Constant * objc_retainAutorelease
id objc_retainAutorelease(id);
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
Definition: CGDecl.cpp:660
llvm::Value * EmitIvarOffset(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
Definition: CGExpr.cpp:3940
llvm::Value * EmitARCRetainAutorelease(QualType type, llvm::Value *value)
Do a fused retain/autorelease of the given object.
Definition: CGObjC.cpp:2185
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:397
void setAtomicSetterHelperFnMap(QualType Ty, llvm::Constant *Fn)
void EmitARCInitWeak(Address addr, llvm::Value *value)
i8* @objc_initWeak(i8** addr, i8* value) Returns value.
Definition: CGObjC.cpp:2237
ARCPreciseLifetime_t
Does an ARC strong l-value have precise lifetime?
Definition: CGValue.h:119
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:479
llvm::Constant * objc_moveWeak
void objc_moveWeak(id *dest, id *src);
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
virtual llvm::Value * GetClass(CodeGenFunction &CGF, const ObjCInterfaceDecl *OID)=0
GetClass - Return a reference to the class for the given interface decl.
bool hasNonTrivialObjCLifetime() const
Definition: Type.h:1013
ObjCPropertyDecl * getPropertyDecl() const
Definition: DeclObjC.h:2712
Reading or writing from this object requires a barrier call.
Definition: Type.h:148
bool hasAtomicCopyHelper() const
Definition: ObjCRuntime.h:298
void EmitLexicalBlockStart(CGBuilderTy &Builder, SourceLocation Loc)
Emit metadata to indicate the beginning of a new lexical block and push the block onto the stack...
llvm::iterator_range< arg_iterator > arguments()
Definition: ExprObjC.h:1357
A non-RAII class containing all the information about a bound opaque value.
bool isARCPseudoStrong() const
Determine whether this variable is an ARC pseudo-__strong variable.
Definition: Decl.h:1249
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5339
llvm::Value * EmitObjCCollectionLiteral(const Expr *E, const ObjCMethodDecl *MethodWithObjects)
Definition: CGObjC.cpp:113
void EmitReturnStmt(const ReturnStmt &S)
EmitReturnStmt - Note that due to GCC extensions, this can have an operand if the function returns vo...
Definition: CGStmt.cpp:981
Opcode getOpcode() const
Definition: Expr.h:2940
llvm::Type * ConvertType(QualType T)
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1849
static llvm::Constant * getNullForVariable(Address addr)
Given the address of a variable of pointer type, find the correct null to store into it...
Definition: CGObjC.cpp:40
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
Definition: CGExpr.cpp:970
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
The receiver is a class.
Definition: ExprObjC.h:1003
Represents Objective-C's @try ... @catch ... @finally statement.
Definition: StmtObjC.h:154
bool AutoreleaseResult
In ARC, whether we should autorelease the return value.
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
Definition: CGExpr.cpp:1440
llvm::Value * EmitARCRetainBlock(llvm::Value *value, bool mandatory)
Retain the given block, with _Block_copy semantics.
Definition: CGObjC.cpp:1952
void generateObjCGetterBody(const ObjCImplementationDecl *classImpl, const ObjCPropertyImplDecl *propImpl, const ObjCMethodDecl *GetterMothodDecl, llvm::Constant *AtomicHelperFn)
Definition: CGObjC.cpp:863
void ForceCleanup()
Force the emission of cleanups now, instead of waiting until this object is destroyed.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2148
Expr * getRHS() const
Definition: Expr.h:2945
QualType getType() const
Definition: CGValue.h:258
void StartObjCMethod(const ObjCMethodDecl *MD, const ObjCContainerDecl *CD)
StartObjCMethod - Begin emission of an ObjCMethod.
Definition: CGObjC.cpp:518
SourceLocation getRBracLoc() const
Definition: Stmt.h:630
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:810
virtual llvm::Constant * GetCppAtomicObjectSetFunction()=0
API for atomic copying of qualified aggregates with non-trivial copy assignment (c++) in setter...
QualType getObjCFastEnumerationStateType()
Retrieve the record type that describes the state of an Objective-C fast enumeration loop (for...
void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr)
Definition: CGObjC.cpp:2396
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:932
static RValue get(llvm::Value *V)
Definition: CGValue.h:85
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
static const Expr * findWeakLValue(const Expr *E)
Given an expression of ObjC pointer type, check whether it was immediately loaded from an ARC __weak ...
Definition: CGObjC.cpp:328
static void emitAutoreleasedReturnValueMarker(CodeGenFunction &CGF)
Definition: CGObjC.cpp:1975
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
Definition: CGStmt.cpp:336
llvm::Value * LoadObjCSelf()
LoadObjCSelf - Load the value of self.
Definition: CGObjC.cpp:1437
Qualifiers::GC getObjCGCAttrKind(QualType Ty) const
Return one of the GCNone, Weak or Strong Objective-C garbage collection attributes.
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:109
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
CodeGenTypes & getTypes() const
A trivial tuple used to represent a source range.
void EmitObjCAtTryStmt(const ObjCAtTryStmt &S)
Definition: CGObjC.cpp:1741
LValue - This represents an lvalue references.
Definition: CGValue.h:152
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:147
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1521
llvm::Value * EmitObjCConsumeObject(QualType T, llvm::Value *Ptr)
Produce the code for a CK_ARCConsumeObject.
Definition: CGObjC.cpp:1768
CanQualType BoolTy
Definition: ASTContext.h:894
static llvm::Value * emitARCLoadOperation(CodeGenFunction &CGF, Address addr, llvm::Constant *&fn, StringRef fnName)
Perform an operation having the following signature: i8* (i8**)
Definition: CGObjC.cpp:1849
llvm::PointerIntPair< llvm::Value *, 1, bool > TryEmitResult
Definition: CGObjC.cpp:31
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5318
The receiver is a superclass.
Definition: ExprObjC.h:1007
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1505
llvm::Constant * objc_retainAutoreleaseReturnValue
id objc_retainAutoreleaseReturnValue(id);
void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S)
Definition: CGObjC.cpp:3118
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:56
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1136
Represents Objective-C's @autoreleasepool Statement.
Definition: StmtObjC.h:345
CGCalleeInfo - Class to encapsulate the information about a callee to be used during the generation o...
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
Definition: ExprObjC.h:307
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
Definition: Type.h:5765
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
bool hasLocalStorage() const
hasLocalStorage - Returns true if a variable with function scope is a non-static local variable...
Definition: Decl.h:963
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2295
static void emitCPPObjectAtomicSetterCall(CodeGenFunction &CGF, ObjCMethodDecl *OMD, ObjCIvarDecl *ivar, llvm::Constant *AtomicHelperFn)
emitCPPObjectAtomicSetterCall - Call the runtime function to store the value from the first formal pa...
Definition: CGObjC.cpp:1080
llvm::Value * EmitObjCSelectorExpr(const ObjCSelectorExpr *E)
Emit a selector.
Definition: CGObjC.cpp:235
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
static void emitCXXDestructMethod(CodeGenFunction &CGF, ObjCImplementationDecl *impl)
Definition: CGObjC.cpp:1366
llvm::Value * EmitObjCProtocolExpr(const ObjCProtocolExpr *E)
Definition: CGObjC.cpp:243
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1466