clang  3.8.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()));
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().arrangeFreeFunctionCall(Context.VoidTy, args,
596  fn, ReturnValueSlot(), args);
597 }
598 
599 /// Determine whether the given architecture supports unaligned atomic
600 /// accesses. They don't have to be fast, just faster than a function
601 /// call and a mutex.
602 static bool hasUnalignedAtomics(llvm::Triple::ArchType arch) {
603  // FIXME: Allow unaligned atomic load/store on x86. (It is not
604  // currently supported by the backend.)
605  return 0;
606 }
607 
608 /// Return the maximum size that permits atomic accesses for the given
609 /// architecture.
611  llvm::Triple::ArchType arch) {
612  // ARM has 8-byte atomic accesses, but it's not clear whether we
613  // want to rely on them here.
614 
615  // In the default case, just assume that any size up to a pointer is
616  // fine given adequate alignment.
618 }
619 
620 namespace {
621  class PropertyImplStrategy {
622  public:
623  enum StrategyKind {
624  /// The 'native' strategy is to use the architecture's provided
625  /// reads and writes.
626  Native,
627 
628  /// Use objc_setProperty and objc_getProperty.
629  GetSetProperty,
630 
631  /// Use objc_setProperty for the setter, but use expression
632  /// evaluation for the getter.
633  SetPropertyAndExpressionGet,
634 
635  /// Use objc_copyStruct.
636  CopyStruct,
637 
638  /// The 'expression' strategy is to emit normal assignment or
639  /// lvalue-to-rvalue expressions.
640  Expression
641  };
642 
643  StrategyKind getKind() const { return StrategyKind(Kind); }
644 
645  bool hasStrongMember() const { return HasStrong; }
646  bool isAtomic() const { return IsAtomic; }
647  bool isCopy() const { return IsCopy; }
648 
649  CharUnits getIvarSize() const { return IvarSize; }
650  CharUnits getIvarAlignment() const { return IvarAlignment; }
651 
652  PropertyImplStrategy(CodeGenModule &CGM,
653  const ObjCPropertyImplDecl *propImpl);
654 
655  private:
656  unsigned Kind : 8;
657  unsigned IsAtomic : 1;
658  unsigned IsCopy : 1;
659  unsigned HasStrong : 1;
660 
661  CharUnits IvarSize;
662  CharUnits IvarAlignment;
663  };
664 }
665 
666 /// Pick an implementation strategy for the given property synthesis.
667 PropertyImplStrategy::PropertyImplStrategy(CodeGenModule &CGM,
668  const ObjCPropertyImplDecl *propImpl) {
669  const ObjCPropertyDecl *prop = propImpl->getPropertyDecl();
670  ObjCPropertyDecl::SetterKind setterKind = prop->getSetterKind();
671 
672  IsCopy = (setterKind == ObjCPropertyDecl::Copy);
673  IsAtomic = prop->isAtomic();
674  HasStrong = false; // doesn't matter here.
675 
676  // Evaluate the ivar's size and alignment.
677  ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl();
678  QualType ivarType = ivar->getType();
679  std::tie(IvarSize, IvarAlignment) =
680  CGM.getContext().getTypeInfoInChars(ivarType);
681 
682  // If we have a copy property, we always have to use getProperty/setProperty.
683  // TODO: we could actually use setProperty and an expression for non-atomics.
684  if (IsCopy) {
685  Kind = GetSetProperty;
686  return;
687  }
688 
689  // Handle retain.
690  if (setterKind == ObjCPropertyDecl::Retain) {
691  // In GC-only, there's nothing special that needs to be done.
692  if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
693  // fallthrough
694 
695  // In ARC, if the property is non-atomic, use expression emission,
696  // which translates to objc_storeStrong. This isn't required, but
697  // it's slightly nicer.
698  } else if (CGM.getLangOpts().ObjCAutoRefCount && !IsAtomic) {
699  // Using standard expression emission for the setter is only
700  // acceptable if the ivar is __strong, which won't be true if
701  // the property is annotated with __attribute__((NSObject)).
702  // TODO: falling all the way back to objc_setProperty here is
703  // just laziness, though; we could still use objc_storeStrong
704  // if we hacked it right.
705  if (ivarType.getObjCLifetime() == Qualifiers::OCL_Strong)
706  Kind = Expression;
707  else
708  Kind = SetPropertyAndExpressionGet;
709  return;
710 
711  // Otherwise, we need to at least use setProperty. However, if
712  // the property isn't atomic, we can use normal expression
713  // emission for the getter.
714  } else if (!IsAtomic) {
715  Kind = SetPropertyAndExpressionGet;
716  return;
717 
718  // Otherwise, we have to use both setProperty and getProperty.
719  } else {
720  Kind = GetSetProperty;
721  return;
722  }
723  }
724 
725  // If we're not atomic, just use expression accesses.
726  if (!IsAtomic) {
727  Kind = Expression;
728  return;
729  }
730 
731  // Properties on bitfield ivars need to be emitted using expression
732  // accesses even if they're nominally atomic.
733  if (ivar->isBitField()) {
734  Kind = Expression;
735  return;
736  }
737 
738  // GC-qualified or ARC-qualified ivars need to be emitted as
739  // expressions. This actually works out to being atomic anyway,
740  // except for ARC __strong, but that should trigger the above code.
741  if (ivarType.hasNonTrivialObjCLifetime() ||
742  (CGM.getLangOpts().getGC() &&
743  CGM.getContext().getObjCGCAttrKind(ivarType))) {
744  Kind = Expression;
745  return;
746  }
747 
748  // Compute whether the ivar has strong members.
749  if (CGM.getLangOpts().getGC())
750  if (const RecordType *recordType = ivarType->getAs<RecordType>())
751  HasStrong = recordType->getDecl()->hasObjectMember();
752 
753  // We can never access structs with object members with a native
754  // access, because we need to use write barriers. This is what
755  // objc_copyStruct is for.
756  if (HasStrong) {
757  Kind = CopyStruct;
758  return;
759  }
760 
761  // Otherwise, this is target-dependent and based on the size and
762  // alignment of the ivar.
763 
764  // If the size of the ivar is not a power of two, give up. We don't
765  // want to get into the business of doing compare-and-swaps.
766  if (!IvarSize.isPowerOfTwo()) {
767  Kind = CopyStruct;
768  return;
769  }
770 
771  llvm::Triple::ArchType arch =
772  CGM.getTarget().getTriple().getArch();
773 
774  // Most architectures require memory to fit within a single cache
775  // line, so the alignment has to be at least the size of the access.
776  // Otherwise we have to grab a lock.
777  if (IvarAlignment < IvarSize && !hasUnalignedAtomics(arch)) {
778  Kind = CopyStruct;
779  return;
780  }
781 
782  // If the ivar's size exceeds the architecture's maximum atomic
783  // access size, we have to use CopyStruct.
784  if (IvarSize > getMaxAtomicAccessSize(CGM, arch)) {
785  Kind = CopyStruct;
786  return;
787  }
788 
789  // Otherwise, we can use native loads and stores.
790  Kind = Native;
791 }
792 
793 /// \brief Generate an Objective-C property getter function.
794 ///
795 /// The given Decl must be an ObjCImplementationDecl. \@synthesize
796 /// is illegal within a category.
798  const ObjCPropertyImplDecl *PID) {
799  llvm::Constant *AtomicHelperFn =
801  const ObjCPropertyDecl *PD = PID->getPropertyDecl();
802  ObjCMethodDecl *OMD = PD->getGetterMethodDecl();
803  assert(OMD && "Invalid call to generate getter (empty method)");
804  StartObjCMethod(OMD, IMP->getClassInterface());
805 
806  generateObjCGetterBody(IMP, PID, OMD, AtomicHelperFn);
807 
808  FinishFunction();
809 }
810 
811 static bool hasTrivialGetExpr(const ObjCPropertyImplDecl *propImpl) {
812  const Expr *getter = propImpl->getGetterCXXConstructor();
813  if (!getter) return true;
814 
815  // Sema only makes only of these when the ivar has a C++ class type,
816  // so the form is pretty constrained.
817 
818  // If the property has a reference type, we might just be binding a
819  // reference, in which case the result will be a gl-value. We should
820  // treat this as a non-trivial operation.
821  if (getter->isGLValue())
822  return false;
823 
824  // If we selected a trivial copy-constructor, we're okay.
825  if (const CXXConstructExpr *construct = dyn_cast<CXXConstructExpr>(getter))
826  return (construct->getConstructor()->isTrivial());
827 
828  // The constructor might require cleanups (in which case it's never
829  // trivial).
830  assert(isa<ExprWithCleanups>(getter));
831  return false;
832 }
833 
834 /// emitCPPObjectAtomicGetterCall - Call the runtime function to
835 /// copy the ivar into the resturn slot.
837  llvm::Value *returnAddr,
838  ObjCIvarDecl *ivar,
839  llvm::Constant *AtomicHelperFn) {
840  // objc_copyCppObjectAtomic (&returnSlot, &CppObjectIvar,
841  // AtomicHelperFn);
842  CallArgList args;
843 
844  // The 1st argument is the return Slot.
845  args.add(RValue::get(returnAddr), CGF.getContext().VoidPtrTy);
846 
847  // The 2nd argument is the address of the ivar.
848  llvm::Value *ivarAddr =
850  CGF.LoadObjCSelf(), ivar, 0).getPointer();
851  ivarAddr = CGF.Builder.CreateBitCast(ivarAddr, CGF.Int8PtrTy);
852  args.add(RValue::get(ivarAddr), CGF.getContext().VoidPtrTy);
853 
854  // Third argument is the helper function.
855  args.add(RValue::get(AtomicHelperFn), CGF.getContext().VoidPtrTy);
856 
857  llvm::Value *copyCppAtomicObjectFn =
860  args,
863  copyCppAtomicObjectFn, ReturnValueSlot(), args);
864 }
865 
866 void
868  const ObjCPropertyImplDecl *propImpl,
869  const ObjCMethodDecl *GetterMethodDecl,
870  llvm::Constant *AtomicHelperFn) {
871  // If there's a non-trivial 'get' expression, we just have to emit that.
872  if (!hasTrivialGetExpr(propImpl)) {
873  if (!AtomicHelperFn) {
875  /*nrvo*/ nullptr);
876  EmitReturnStmt(ret);
877  }
878  else {
879  ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl();
881  ivar, AtomicHelperFn);
882  }
883  return;
884  }
885 
886  const ObjCPropertyDecl *prop = propImpl->getPropertyDecl();
887  QualType propType = prop->getType();
888  ObjCMethodDecl *getterMethod = prop->getGetterMethodDecl();
889 
890  ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl();
891 
892  // Pick an implementation strategy.
893  PropertyImplStrategy strategy(CGM, propImpl);
894  switch (strategy.getKind()) {
895  case PropertyImplStrategy::Native: {
896  // We don't need to do anything for a zero-size struct.
897  if (strategy.getIvarSize().isZero())
898  return;
899 
901 
902  // Currently, all atomic accesses have to be through integer
903  // types, so there's no point in trying to pick a prettier type.
904  llvm::Type *bitcastType =
905  llvm::Type::getIntNTy(getLLVMContext(),
906  getContext().toBits(strategy.getIvarSize()));
907  bitcastType = bitcastType->getPointerTo(); // addrspace 0 okay
908 
909  // Perform an atomic load. This does not impose ordering constraints.
910  Address ivarAddr = LV.getAddress();
911  ivarAddr = Builder.CreateBitCast(ivarAddr, bitcastType);
912  llvm::LoadInst *load = Builder.CreateLoad(ivarAddr, "load");
913  load->setAtomic(llvm::Unordered);
914 
915  // Store that value into the return address. Doing this with a
916  // bitcast is likely to produce some pretty ugly IR, but it's not
917  // the *most* terrible thing in the world.
918  Builder.CreateStore(load, Builder.CreateBitCast(ReturnValue, bitcastType));
919 
920  // Make sure we don't do an autorelease.
921  AutoreleaseResult = false;
922  return;
923  }
924 
925  case PropertyImplStrategy::GetSetProperty: {
926  llvm::Value *getPropertyFn =
928  if (!getPropertyFn) {
929  CGM.ErrorUnsupported(propImpl, "Obj-C getter requiring atomic copy");
930  return;
931  }
932 
933  // Return (ivar-type) objc_getProperty((id) self, _cmd, offset, true).
934  // FIXME: Can't this be simpler? This might even be worse than the
935  // corresponding gcc code.
936  llvm::Value *cmd =
937  Builder.CreateLoad(GetAddrOfLocalVar(getterMethod->getCmdDecl()), "cmd");
938  llvm::Value *self = Builder.CreateBitCast(LoadObjCSelf(), VoidPtrTy);
939  llvm::Value *ivarOffset =
940  EmitIvarOffset(classImpl->getClassInterface(), ivar);
941 
942  CallArgList args;
943  args.add(RValue::get(self), getContext().getObjCIdType());
944  args.add(RValue::get(cmd), getContext().getObjCSelType());
945  args.add(RValue::get(ivarOffset), getContext().getPointerDiffType());
946  args.add(RValue::get(Builder.getInt1(strategy.isAtomic())),
947  getContext().BoolTy);
948 
949  // FIXME: We shouldn't need to get the function info here, the
950  // runtime already should have computed it to build the function.
951  llvm::Instruction *CallInstruction;
952  RValue RV = EmitCall(
953  getTypes().arrangeFreeFunctionCall(
954  propType, args, FunctionType::ExtInfo(), RequiredArgs::All),
955  getPropertyFn, ReturnValueSlot(), args, CGCalleeInfo(),
956  &CallInstruction);
957  if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(CallInstruction))
958  call->setTailCall();
959 
960  // We need to fix the type here. Ivars with copy & retain are
961  // always objects so we don't need to worry about complex or
962  // aggregates.
964  RV.getScalarVal(),
965  getTypes().ConvertType(getterMethod->getReturnType())));
966 
967  EmitReturnOfRValue(RV, propType);
968 
969  // objc_getProperty does an autorelease, so we should suppress ours.
970  AutoreleaseResult = false;
971 
972  return;
973  }
974 
975  case PropertyImplStrategy::CopyStruct:
976  emitStructGetterCall(*this, ivar, strategy.isAtomic(),
977  strategy.hasStrongMember());
978  return;
979 
980  case PropertyImplStrategy::Expression:
981  case PropertyImplStrategy::SetPropertyAndExpressionGet: {
983 
984  QualType ivarType = ivar->getType();
985  switch (getEvaluationKind(ivarType)) {
986  case TEK_Complex: {
989  /*init*/ true);
990  return;
991  }
992  case TEK_Aggregate:
993  // The return value slot is guaranteed to not be aliased, but
994  // that's not necessarily the same as "on the stack", so
995  // we still potentially need objc_memmove_collectable.
996  EmitAggregateCopy(ReturnValue, LV.getAddress(), ivarType);
997  return;
998  case TEK_Scalar: {
999  llvm::Value *value;
1000  if (propType->isReferenceType()) {
1001  value = LV.getAddress().getPointer();
1002  } else {
1003  // We want to load and autoreleaseReturnValue ARC __weak ivars.
1005  if (getLangOpts().ObjCAutoRefCount) {
1006  value = emitARCRetainLoadOfScalar(*this, LV, ivarType);
1007  } else {
1008  value = EmitARCLoadWeak(LV.getAddress());
1009  }
1010 
1011  // Otherwise we want to do a simple load, suppressing the
1012  // final autorelease.
1013  } else {
1014  value = EmitLoadOfLValue(LV, SourceLocation()).getScalarVal();
1015  AutoreleaseResult = false;
1016  }
1017 
1018  value = Builder.CreateBitCast(value, ConvertType(propType));
1019  value = Builder.CreateBitCast(
1020  value, ConvertType(GetterMethodDecl->getReturnType()));
1021  }
1022 
1023  EmitReturnOfRValue(RValue::get(value), propType);
1024  return;
1025  }
1026  }
1027  llvm_unreachable("bad evaluation kind");
1028  }
1029 
1030  }
1031  llvm_unreachable("bad @property implementation strategy!");
1032 }
1033 
1034 /// emitStructSetterCall - Call the runtime function to store the value
1035 /// from the first formal parameter into the given ivar.
1037  ObjCIvarDecl *ivar) {
1038  // objc_copyStruct (&structIvar, &Arg,
1039  // sizeof (struct something), true, false);
1040  CallArgList args;
1041 
1042  // The first argument is the address of the ivar.
1043  llvm::Value *ivarAddr = CGF.EmitLValueForIvar(CGF.TypeOfSelfObject(),
1044  CGF.LoadObjCSelf(), ivar, 0)
1045  .getPointer();
1046  ivarAddr = CGF.Builder.CreateBitCast(ivarAddr, CGF.Int8PtrTy);
1047  args.add(RValue::get(ivarAddr), CGF.getContext().VoidPtrTy);
1048 
1049  // The second argument is the address of the parameter variable.
1050  ParmVarDecl *argVar = *OMD->param_begin();
1051  DeclRefExpr argRef(argVar, false, argVar->getType().getNonReferenceType(),
1053  llvm::Value *argAddr = CGF.EmitLValue(&argRef).getPointer();
1054  argAddr = CGF.Builder.CreateBitCast(argAddr, CGF.Int8PtrTy);
1055  args.add(RValue::get(argAddr), CGF.getContext().VoidPtrTy);
1056 
1057  // The third argument is the sizeof the type.
1058  llvm::Value *size =
1059  CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(ivar->getType()));
1060  args.add(RValue::get(size), CGF.getContext().getSizeType());
1061 
1062  // The fourth argument is the 'isAtomic' flag.
1063  args.add(RValue::get(CGF.Builder.getTrue()), CGF.getContext().BoolTy);
1064 
1065  // The fifth argument is the 'hasStrong' flag.
1066  // FIXME: should this really always be false?
1067  args.add(RValue::get(CGF.Builder.getFalse()), CGF.getContext().BoolTy);
1068 
1069  llvm::Value *copyStructFn = CGF.CGM.getObjCRuntime().GetSetStructFunction();
1071  args,
1074  copyStructFn, ReturnValueSlot(), args);
1075 }
1076 
1077 /// emitCPPObjectAtomicSetterCall - Call the runtime function to store
1078 /// the value from the first formal parameter into the given ivar, using
1079 /// the Cpp API for atomic Cpp objects with non-trivial copy assignment.
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 =
1109  args,
1112  copyCppAtomicObjectFn, ReturnValueSlot(), args);
1113 }
1114 
1115 
1116 static bool hasTrivialSetExpr(const ObjCPropertyImplDecl *PID) {
1117  Expr *setter = PID->getSetterCXXAssignment();
1118  if (!setter) return true;
1119 
1120  // Sema only makes only of these when the ivar has a C++ class type,
1121  // so the form is pretty constrained.
1122 
1123  // An operator call is trivial if the function it calls is trivial.
1124  // This also implies that there's nothing non-trivial going on with
1125  // the arguments, because operator= can only be trivial if it's a
1126  // synthesized assignment operator and therefore both parameters are
1127  // references.
1128  if (CallExpr *call = dyn_cast<CallExpr>(setter)) {
1129  if (const FunctionDecl *callee
1130  = dyn_cast_or_null<FunctionDecl>(call->getCalleeDecl()))
1131  if (callee->isTrivial())
1132  return true;
1133  return false;
1134  }
1135 
1136  assert(isa<ExprWithCleanups>(setter));
1137  return false;
1138 }
1139 
1141  if (CGM.getLangOpts().getGC() != LangOptions::NonGC)
1142  return false;
1144 }
1145 
1146 void
1148  const ObjCPropertyImplDecl *propImpl,
1149  llvm::Constant *AtomicHelperFn) {
1150  const ObjCPropertyDecl *prop = propImpl->getPropertyDecl();
1151  ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl();
1152  ObjCMethodDecl *setterMethod = prop->getSetterMethodDecl();
1153 
1154  // Just use the setter expression if Sema gave us one and it's
1155  // non-trivial.
1156  if (!hasTrivialSetExpr(propImpl)) {
1157  if (!AtomicHelperFn)
1158  // If non-atomic, assignment is called directly.
1159  EmitStmt(propImpl->getSetterCXXAssignment());
1160  else
1161  // If atomic, assignment is called via a locking api.
1162  emitCPPObjectAtomicSetterCall(*this, setterMethod, ivar,
1163  AtomicHelperFn);
1164  return;
1165  }
1166 
1167  PropertyImplStrategy strategy(CGM, propImpl);
1168  switch (strategy.getKind()) {
1169  case PropertyImplStrategy::Native: {
1170  // We don't need to do anything for a zero-size struct.
1171  if (strategy.getIvarSize().isZero())
1172  return;
1173 
1174  Address argAddr = GetAddrOfLocalVar(*setterMethod->param_begin());
1175 
1176  LValue ivarLValue =
1177  EmitLValueForIvar(TypeOfSelfObject(), LoadObjCSelf(), ivar, /*quals*/ 0);
1178  Address ivarAddr = ivarLValue.getAddress();
1179 
1180  // Currently, all atomic accesses have to be through integer
1181  // types, so there's no point in trying to pick a prettier type.
1182  llvm::Type *bitcastType =
1183  llvm::Type::getIntNTy(getLLVMContext(),
1184  getContext().toBits(strategy.getIvarSize()));
1185 
1186  // Cast both arguments to the chosen operation type.
1187  argAddr = Builder.CreateElementBitCast(argAddr, bitcastType);
1188  ivarAddr = Builder.CreateElementBitCast(ivarAddr, bitcastType);
1189 
1190  // This bitcast load is likely to cause some nasty IR.
1191  llvm::Value *load = Builder.CreateLoad(argAddr);
1192 
1193  // Perform an atomic store. There are no memory ordering requirements.
1194  llvm::StoreInst *store = Builder.CreateStore(load, ivarAddr);
1195  store->setAtomic(llvm::Unordered);
1196  return;
1197  }
1198 
1199  case PropertyImplStrategy::GetSetProperty:
1200  case PropertyImplStrategy::SetPropertyAndExpressionGet: {
1201 
1202  llvm::Value *setOptimizedPropertyFn = nullptr;
1203  llvm::Value *setPropertyFn = nullptr;
1204  if (UseOptimizedSetter(CGM)) {
1205  // 10.8 and iOS 6.0 code and GC is off
1206  setOptimizedPropertyFn =
1207  CGM.getObjCRuntime()
1208  .GetOptimizedPropertySetFunction(strategy.isAtomic(),
1209  strategy.isCopy());
1210  if (!setOptimizedPropertyFn) {
1211  CGM.ErrorUnsupported(propImpl, "Obj-C optimized setter - NYI");
1212  return;
1213  }
1214  }
1215  else {
1216  setPropertyFn = CGM.getObjCRuntime().GetPropertySetFunction();
1217  if (!setPropertyFn) {
1218  CGM.ErrorUnsupported(propImpl, "Obj-C setter requiring atomic copy");
1219  return;
1220  }
1221  }
1222 
1223  // Emit objc_setProperty((id) self, _cmd, offset, arg,
1224  // <is-atomic>, <is-copy>).
1225  llvm::Value *cmd =
1226  Builder.CreateLoad(GetAddrOfLocalVar(setterMethod->getCmdDecl()));
1227  llvm::Value *self =
1229  llvm::Value *ivarOffset =
1230  EmitIvarOffset(classImpl->getClassInterface(), ivar);
1231  Address argAddr = GetAddrOfLocalVar(*setterMethod->param_begin());
1232  llvm::Value *arg = Builder.CreateLoad(argAddr, "arg");
1233  arg = Builder.CreateBitCast(arg, VoidPtrTy);
1234 
1235  CallArgList args;
1236  args.add(RValue::get(self), getContext().getObjCIdType());
1237  args.add(RValue::get(cmd), getContext().getObjCSelType());
1238  if (setOptimizedPropertyFn) {
1239  args.add(RValue::get(arg), getContext().getObjCIdType());
1240  args.add(RValue::get(ivarOffset), getContext().getPointerDiffType());
1241  EmitCall(getTypes().arrangeFreeFunctionCall(getContext().VoidTy, args,
1244  setOptimizedPropertyFn, ReturnValueSlot(), args);
1245  } else {
1246  args.add(RValue::get(ivarOffset), getContext().getPointerDiffType());
1247  args.add(RValue::get(arg), getContext().getObjCIdType());
1248  args.add(RValue::get(Builder.getInt1(strategy.isAtomic())),
1249  getContext().BoolTy);
1250  args.add(RValue::get(Builder.getInt1(strategy.isCopy())),
1251  getContext().BoolTy);
1252  // FIXME: We shouldn't need to get the function info here, the runtime
1253  // already should have computed it to build the function.
1254  EmitCall(getTypes().arrangeFreeFunctionCall(getContext().VoidTy, args,
1257  setPropertyFn, ReturnValueSlot(), args);
1258  }
1259 
1260  return;
1261  }
1262 
1263  case PropertyImplStrategy::CopyStruct:
1264  emitStructSetterCall(*this, setterMethod, ivar);
1265  return;
1266 
1267  case PropertyImplStrategy::Expression:
1268  break;
1269  }
1270 
1271  // Otherwise, fake up some ASTs and emit a normal assignment.
1272  ValueDecl *selfDecl = setterMethod->getSelfDecl();
1273  DeclRefExpr self(selfDecl, false, selfDecl->getType(),
1276  selfDecl->getType(), CK_LValueToRValue, &self,
1277  VK_RValue);
1278  ObjCIvarRefExpr ivarRef(ivar, ivar->getType().getNonReferenceType(),
1280  &selfLoad, true, true);
1281 
1282  ParmVarDecl *argDecl = *setterMethod->param_begin();
1283  QualType argType = argDecl->getType().getNonReferenceType();
1284  DeclRefExpr arg(argDecl, false, argType, VK_LValue, SourceLocation());
1287  &arg, VK_RValue);
1288 
1289  // The property type can differ from the ivar type in some situations with
1290  // Objective-C pointer types, we can always bit cast the RHS in these cases.
1291  // The following absurdity is just to ensure well-formed IR.
1292  CastKind argCK = CK_NoOp;
1293  if (ivarRef.getType()->isObjCObjectPointerType()) {
1294  if (argLoad.getType()->isObjCObjectPointerType())
1295  argCK = CK_BitCast;
1296  else if (argLoad.getType()->isBlockPointerType())
1298  else
1300  } else if (ivarRef.getType()->isBlockPointerType()) {
1301  if (argLoad.getType()->isBlockPointerType())
1302  argCK = CK_BitCast;
1303  else
1305  } else if (ivarRef.getType()->isPointerType()) {
1306  argCK = CK_BitCast;
1307  }
1309  ivarRef.getType(), argCK, &argLoad,
1310  VK_RValue);
1311  Expr *finalArg = &argLoad;
1312  if (!getContext().hasSameUnqualifiedType(ivarRef.getType(),
1313  argLoad.getType()))
1314  finalArg = &argCast;
1315 
1316 
1317  BinaryOperator assign(&ivarRef, finalArg, BO_Assign,
1318  ivarRef.getType(), VK_RValue, OK_Ordinary,
1319  SourceLocation(), false);
1320  EmitStmt(&assign);
1321 }
1322 
1323 /// \brief Generate an Objective-C property setter function.
1324 ///
1325 /// The given Decl must be an ObjCImplementationDecl. \@synthesize
1326 /// is illegal within a category.
1328  const ObjCPropertyImplDecl *PID) {
1329  llvm::Constant *AtomicHelperFn =
1331  const ObjCPropertyDecl *PD = PID->getPropertyDecl();
1332  ObjCMethodDecl *OMD = PD->getSetterMethodDecl();
1333  assert(OMD && "Invalid call to generate setter (empty method)");
1334  StartObjCMethod(OMD, IMP->getClassInterface());
1335 
1336  generateObjCSetterBody(IMP, PID, AtomicHelperFn);
1337 
1338  FinishFunction();
1339 }
1340 
1341 namespace {
1342  struct DestroyIvar final : EHScopeStack::Cleanup {
1343  private:
1344  llvm::Value *addr;
1345  const ObjCIvarDecl *ivar;
1346  CodeGenFunction::Destroyer *destroyer;
1347  bool useEHCleanupForArray;
1348  public:
1349  DestroyIvar(llvm::Value *addr, const ObjCIvarDecl *ivar,
1350  CodeGenFunction::Destroyer *destroyer,
1351  bool useEHCleanupForArray)
1352  : addr(addr), ivar(ivar), destroyer(destroyer),
1353  useEHCleanupForArray(useEHCleanupForArray) {}
1354 
1355  void Emit(CodeGenFunction &CGF, Flags flags) override {
1356  LValue lvalue
1357  = CGF.EmitLValueForIvar(CGF.TypeOfSelfObject(), addr, ivar, /*CVR*/ 0);
1358  CGF.emitDestroy(lvalue.getAddress(), ivar->getType(), destroyer,
1359  flags.isForNormalCleanup() && useEHCleanupForArray);
1360  }
1361  };
1362 }
1363 
1364 /// Like CodeGenFunction::destroyARCStrong, but do it with a call.
1366  Address addr,
1367  QualType type) {
1368  llvm::Value *null = getNullForVariable(addr);
1369  CGF.EmitARCStoreStrongCall(addr, null, /*ignored*/ true);
1370 }
1371 
1373  ObjCImplementationDecl *impl) {
1375 
1376  llvm::Value *self = CGF.LoadObjCSelf();
1377 
1378  const ObjCInterfaceDecl *iface = impl->getClassInterface();
1379  for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
1380  ivar; ivar = ivar->getNextIvar()) {
1381  QualType type = ivar->getType();
1382 
1383  // Check whether the ivar is a destructible type.
1384  QualType::DestructionKind dtorKind = type.isDestructedType();
1385  if (!dtorKind) continue;
1386 
1387  CodeGenFunction::Destroyer *destroyer = nullptr;
1388 
1389  // Use a call to objc_storeStrong to destroy strong ivars, for the
1390  // general benefit of the tools.
1391  if (dtorKind == QualType::DK_objc_strong_lifetime) {
1392  destroyer = destroyARCStrongWithStore;
1393 
1394  // Otherwise use the default for the destruction kind.
1395  } else {
1396  destroyer = CGF.getDestroyer(dtorKind);
1397  }
1398 
1399  CleanupKind cleanupKind = CGF.getCleanupKind(dtorKind);
1400 
1401  CGF.EHStack.pushCleanup<DestroyIvar>(cleanupKind, self, ivar, destroyer,
1402  cleanupKind & EHCleanup);
1403  }
1404 
1405  assert(scope.requiresCleanups() && "nothing to do in .cxx_destruct?");
1406 }
1407 
1409  ObjCMethodDecl *MD,
1410  bool ctor) {
1412  StartObjCMethod(MD, IMP->getClassInterface());
1413 
1414  // Emit .cxx_construct.
1415  if (ctor) {
1416  // Suppress the final autorelease in ARC.
1417  AutoreleaseResult = false;
1418 
1419  for (const auto *IvarInit : IMP->inits()) {
1420  FieldDecl *Field = IvarInit->getAnyMember();
1421  ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(Field);
1423  LoadObjCSelf(), Ivar, 0);
1424  EmitAggExpr(IvarInit->getInit(),
1428  }
1429  // constructor returns 'self'.
1430  CodeGenTypes &Types = CGM.getTypes();
1431  QualType IdTy(CGM.getContext().getObjCIdType());
1432  llvm::Value *SelfAsId =
1434  EmitReturnOfRValue(RValue::get(SelfAsId), IdTy);
1435 
1436  // Emit .cxx_destruct.
1437  } else {
1438  emitCXXDestructMethod(*this, IMP);
1439  }
1440  FinishFunction();
1441 }
1442 
1444  VarDecl *Self = cast<ObjCMethodDecl>(CurFuncDecl)->getSelfDecl();
1445  DeclRefExpr DRE(Self, /*is enclosing local*/ (CurFuncDecl != CurCodeDecl),
1446  Self->getType(), VK_LValue, SourceLocation());
1448 }
1449 
1451  const ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(CurFuncDecl);
1452  ImplicitParamDecl *selfDecl = OMD->getSelfDecl();
1453  const ObjCObjectPointerType *PTy = cast<ObjCObjectPointerType>(
1454  getContext().getCanonicalType(selfDecl->getType()));
1455  return PTy->getPointeeType();
1456 }
1457 
1459  llvm::Constant *EnumerationMutationFn =
1461 
1462  if (!EnumerationMutationFn) {
1463  CGM.ErrorUnsupported(&S, "Obj-C fast enumeration for this runtime");
1464  return;
1465  }
1466 
1467  CGDebugInfo *DI = getDebugInfo();
1468  if (DI)
1469  DI->EmitLexicalBlockStart(Builder, S.getSourceRange().getBegin());
1470 
1471  // The local variable comes into scope immediately.
1473  if (const DeclStmt *SD = dyn_cast<DeclStmt>(S.getElement()))
1474  variable = EmitAutoVarAlloca(*cast<VarDecl>(SD->getSingleDecl()));
1475 
1476  JumpDest LoopEnd = getJumpDestInCurrentScope("forcoll.end");
1477 
1478  // Fast enumeration state.
1479  QualType StateTy = CGM.getObjCFastEnumerationStateType();
1480  Address StatePtr = CreateMemTemp(StateTy, "state.ptr");
1481  EmitNullInitialization(StatePtr, StateTy);
1482 
1483  // Number of elements in the items array.
1484  static const unsigned NumItems = 16;
1485 
1486  // Fetch the countByEnumeratingWithState:objects:count: selector.
1487  IdentifierInfo *II[] = {
1488  &CGM.getContext().Idents.get("countByEnumeratingWithState"),
1489  &CGM.getContext().Idents.get("objects"),
1490  &CGM.getContext().Idents.get("count")
1491  };
1492  Selector FastEnumSel =
1493  CGM.getContext().Selectors.getSelector(llvm::array_lengthof(II), &II[0]);
1494 
1495  QualType ItemsTy =
1496  getContext().getConstantArrayType(getContext().getObjCIdType(),
1497  llvm::APInt(32, NumItems),
1498  ArrayType::Normal, 0);
1499  Address ItemsPtr = CreateMemTemp(ItemsTy, "items.ptr");
1500 
1501  // Emit the collection pointer. In ARC, we do a retain.
1502  llvm::Value *Collection;
1503  if (getLangOpts().ObjCAutoRefCount) {
1504  Collection = EmitARCRetainScalarExpr(S.getCollection());
1505 
1506  // Enter a cleanup to do the release.
1507  EmitObjCConsumeObject(S.getCollection()->getType(), Collection);
1508  } else {
1509  Collection = EmitScalarExpr(S.getCollection());
1510  }
1511 
1512  // The 'continue' label needs to appear within the cleanup for the
1513  // collection object.
1514  JumpDest AfterBody = getJumpDestInCurrentScope("forcoll.next");
1515 
1516  // Send it our message:
1517  CallArgList Args;
1518 
1519  // The first argument is a temporary of the enumeration-state type.
1520  Args.add(RValue::get(StatePtr.getPointer()),
1521  getContext().getPointerType(StateTy));
1522 
1523  // The second argument is a temporary array with space for NumItems
1524  // pointers. We'll actually be loading elements from the array
1525  // pointer written into the control state; this buffer is so that
1526  // collections that *aren't* backed by arrays can still queue up
1527  // batches of elements.
1528  Args.add(RValue::get(ItemsPtr.getPointer()),
1529  getContext().getPointerType(ItemsTy));
1530 
1531  // The third argument is the capacity of that temporary array.
1532  llvm::Type *UnsignedLongLTy = ConvertType(getContext().UnsignedLongTy);
1533  llvm::Constant *Count = llvm::ConstantInt::get(UnsignedLongLTy, NumItems);
1534  Args.add(RValue::get(Count), getContext().UnsignedLongTy);
1535 
1536  // Start the enumeration.
1537  RValue CountRV =
1539  getContext().UnsignedLongTy,
1540  FastEnumSel,
1541  Collection, Args);
1542 
1543  // The initial number of objects that were returned in the buffer.
1544  llvm::Value *initialBufferLimit = CountRV.getScalarVal();
1545 
1546  llvm::BasicBlock *EmptyBB = createBasicBlock("forcoll.empty");
1547  llvm::BasicBlock *LoopInitBB = createBasicBlock("forcoll.loopinit");
1548 
1549  llvm::Value *zero = llvm::Constant::getNullValue(UnsignedLongLTy);
1550 
1551  // If the limit pointer was zero to begin with, the collection is
1552  // empty; skip all this. Set the branch weight assuming this has the same
1553  // probability of exiting the loop as any other loop exit.
1554  uint64_t EntryCount = getCurrentProfileCount();
1555  Builder.CreateCondBr(
1556  Builder.CreateICmpEQ(initialBufferLimit, zero, "iszero"), EmptyBB,
1557  LoopInitBB,
1558  createProfileWeights(EntryCount, getProfileCount(S.getBody())));
1559 
1560  // Otherwise, initialize the loop.
1561  EmitBlock(LoopInitBB);
1562 
1563  // Save the initial mutations value. This is the value at an
1564  // address that was written into the state object by
1565  // countByEnumeratingWithState:objects:count:.
1566  Address StateMutationsPtrPtr = Builder.CreateStructGEP(
1567  StatePtr, 2, 2 * getPointerSize(), "mutationsptr.ptr");
1568  llvm::Value *StateMutationsPtr
1569  = Builder.CreateLoad(StateMutationsPtrPtr, "mutationsptr");
1570 
1571  llvm::Value *initialMutations =
1572  Builder.CreateAlignedLoad(StateMutationsPtr, getPointerAlign(),
1573  "forcoll.initial-mutations");
1574 
1575  // Start looping. This is the point we return to whenever we have a
1576  // fresh, non-empty batch of objects.
1577  llvm::BasicBlock *LoopBodyBB = createBasicBlock("forcoll.loopbody");
1578  EmitBlock(LoopBodyBB);
1579 
1580  // The current index into the buffer.
1581  llvm::PHINode *index = Builder.CreatePHI(UnsignedLongLTy, 3, "forcoll.index");
1582  index->addIncoming(zero, LoopInitBB);
1583 
1584  // The current buffer size.
1585  llvm::PHINode *count = Builder.CreatePHI(UnsignedLongLTy, 3, "forcoll.count");
1586  count->addIncoming(initialBufferLimit, LoopInitBB);
1587 
1589 
1590  // Check whether the mutations value has changed from where it was
1591  // at start. StateMutationsPtr should actually be invariant between
1592  // refreshes.
1593  StateMutationsPtr = Builder.CreateLoad(StateMutationsPtrPtr, "mutationsptr");
1594  llvm::Value *currentMutations
1595  = Builder.CreateAlignedLoad(StateMutationsPtr, getPointerAlign(),
1596  "statemutations");
1597 
1598  llvm::BasicBlock *WasMutatedBB = createBasicBlock("forcoll.mutated");
1599  llvm::BasicBlock *WasNotMutatedBB = createBasicBlock("forcoll.notmutated");
1600 
1601  Builder.CreateCondBr(Builder.CreateICmpEQ(currentMutations, initialMutations),
1602  WasNotMutatedBB, WasMutatedBB);
1603 
1604  // If so, call the enumeration-mutation function.
1605  EmitBlock(WasMutatedBB);
1606  llvm::Value *V =
1607  Builder.CreateBitCast(Collection,
1608  ConvertType(getContext().getObjCIdType()));
1609  CallArgList Args2;
1610  Args2.add(RValue::get(V), getContext().getObjCIdType());
1611  // FIXME: We shouldn't need to get the function info here, the runtime already
1612  // should have computed it to build the function.
1616  EnumerationMutationFn, ReturnValueSlot(), Args2);
1617 
1618  // Otherwise, or if the mutation function returns, just continue.
1619  EmitBlock(WasNotMutatedBB);
1620 
1621  // Initialize the element variable.
1622  RunCleanupsScope elementVariableScope(*this);
1623  bool elementIsVariable;
1624  LValue elementLValue;
1625  QualType elementType;
1626  if (const DeclStmt *SD = dyn_cast<DeclStmt>(S.getElement())) {
1627  // Initialize the variable, in case it's a __block variable or something.
1628  EmitAutoVarInit(variable);
1629 
1630  const VarDecl* D = cast<VarDecl>(SD->getSingleDecl());
1631  DeclRefExpr tempDRE(const_cast<VarDecl*>(D), false, D->getType(),
1633  elementLValue = EmitLValue(&tempDRE);
1634  elementType = D->getType();
1635  elementIsVariable = true;
1636 
1637  if (D->isARCPseudoStrong())
1638  elementLValue.getQuals().setObjCLifetime(Qualifiers::OCL_ExplicitNone);
1639  } else {
1640  elementLValue = LValue(); // suppress warning
1641  elementType = cast<Expr>(S.getElement())->getType();
1642  elementIsVariable = false;
1643  }
1644  llvm::Type *convertedElementType = ConvertType(elementType);
1645 
1646  // Fetch the buffer out of the enumeration state.
1647  // TODO: this pointer should actually be invariant between
1648  // refreshes, which would help us do certain loop optimizations.
1649  Address StateItemsPtr = Builder.CreateStructGEP(
1650  StatePtr, 1, getPointerSize(), "stateitems.ptr");
1651  llvm::Value *EnumStateItems =
1652  Builder.CreateLoad(StateItemsPtr, "stateitems");
1653 
1654  // Fetch the value at the current index from the buffer.
1655  llvm::Value *CurrentItemPtr =
1656  Builder.CreateGEP(EnumStateItems, index, "currentitem.ptr");
1657  llvm::Value *CurrentItem =
1658  Builder.CreateAlignedLoad(CurrentItemPtr, getPointerAlign());
1659 
1660  // Cast that value to the right type.
1661  CurrentItem = Builder.CreateBitCast(CurrentItem, convertedElementType,
1662  "currentitem");
1663 
1664  // Make sure we have an l-value. Yes, this gets evaluated every
1665  // time through the loop.
1666  if (!elementIsVariable) {
1667  elementLValue = EmitLValue(cast<Expr>(S.getElement()));
1668  EmitStoreThroughLValue(RValue::get(CurrentItem), elementLValue);
1669  } else {
1670  EmitScalarInit(CurrentItem, elementLValue);
1671  }
1672 
1673  // If we do have an element variable, this assignment is the end of
1674  // its initialization.
1675  if (elementIsVariable)
1676  EmitAutoVarCleanups(variable);
1677 
1678  // Perform the loop body, setting up break and continue labels.
1679  BreakContinueStack.push_back(BreakContinue(LoopEnd, AfterBody));
1680  {
1681  RunCleanupsScope Scope(*this);
1682  EmitStmt(S.getBody());
1683  }
1684  BreakContinueStack.pop_back();
1685 
1686  // Destroy the element variable now.
1687  elementVariableScope.ForceCleanup();
1688 
1689  // Check whether there are more elements.
1690  EmitBlock(AfterBody.getBlock());
1691 
1692  llvm::BasicBlock *FetchMoreBB = createBasicBlock("forcoll.refetch");
1693 
1694  // First we check in the local buffer.
1695  llvm::Value *indexPlusOne
1696  = Builder.CreateAdd(index, llvm::ConstantInt::get(UnsignedLongLTy, 1));
1697 
1698  // If we haven't overrun the buffer yet, we can continue.
1699  // Set the branch weights based on the simplifying assumption that this is
1700  // like a while-loop, i.e., ignoring that the false branch fetches more
1701  // elements and then returns to the loop.
1702  Builder.CreateCondBr(
1703  Builder.CreateICmpULT(indexPlusOne, count), LoopBodyBB, FetchMoreBB,
1704  createProfileWeights(getProfileCount(S.getBody()), EntryCount));
1705 
1706  index->addIncoming(indexPlusOne, AfterBody.getBlock());
1707  count->addIncoming(count, AfterBody.getBlock());
1708 
1709  // Otherwise, we have to fetch more elements.
1710  EmitBlock(FetchMoreBB);
1711 
1712  CountRV =
1714  getContext().UnsignedLongTy,
1715  FastEnumSel,
1716  Collection, Args);
1717 
1718  // If we got a zero count, we're done.
1719  llvm::Value *refetchCount = CountRV.getScalarVal();
1720 
1721  // (note that the message send might split FetchMoreBB)
1722  index->addIncoming(zero, Builder.GetInsertBlock());
1723  count->addIncoming(refetchCount, Builder.GetInsertBlock());
1724 
1725  Builder.CreateCondBr(Builder.CreateICmpEQ(refetchCount, zero),
1726  EmptyBB, LoopBodyBB);
1727 
1728  // No more elements.
1729  EmitBlock(EmptyBB);
1730 
1731  if (!elementIsVariable) {
1732  // If the element was not a declaration, set it to be null.
1733 
1734  llvm::Value *null = llvm::Constant::getNullValue(convertedElementType);
1735  elementLValue = EmitLValue(cast<Expr>(S.getElement()));
1736  EmitStoreThroughLValue(RValue::get(null), elementLValue);
1737  }
1738 
1739  if (DI)
1740  DI->EmitLexicalBlockEnd(Builder, S.getSourceRange().getEnd());
1741 
1742  // Leave the cleanup we entered in ARC.
1743  if (getLangOpts().ObjCAutoRefCount)
1744  PopCleanupBlock();
1745 
1746  EmitBlock(LoopEnd.getBlock());
1747 }
1748 
1750  CGM.getObjCRuntime().EmitTryStmt(*this, S);
1751 }
1752 
1754  CGM.getObjCRuntime().EmitThrowStmt(*this, S);
1755 }
1756 
1758  const ObjCAtSynchronizedStmt &S) {
1759  CGM.getObjCRuntime().EmitSynchronizedStmt(*this, S);
1760 }
1761 
1762 namespace {
1763  struct CallObjCRelease final : EHScopeStack::Cleanup {
1764  CallObjCRelease(llvm::Value *object) : object(object) {}
1765  llvm::Value *object;
1766 
1767  void Emit(CodeGenFunction &CGF, Flags flags) override {
1768  // Releases at the end of the full-expression are imprecise.
1769  CGF.EmitARCRelease(object, ARCImpreciseLifetime);
1770  }
1771  };
1772 }
1773 
1774 /// Produce the code for a CK_ARCConsumeObject. Does a primitive
1775 /// release at the end of the full-expression.
1777  llvm::Value *object) {
1778  // If we're in a conditional branch, we need to make the cleanup
1779  // conditional.
1780  pushFullExprCleanup<CallObjCRelease>(getARCCleanupKind(), object);
1781  return object;
1782 }
1783 
1785  llvm::Value *value) {
1786  return EmitARCRetainAutorelease(type, value);
1787 }
1788 
1789 /// Given a number of pointers, inform the optimizer that they're
1790 /// being intrinsically used up until this point in the program.
1792  llvm::Constant *&fn = CGM.getObjCEntrypoints().clang_arc_use;
1793  if (!fn) {
1794  llvm::FunctionType *fnType =
1795  llvm::FunctionType::get(CGM.VoidTy, None, true);
1796  fn = CGM.CreateRuntimeFunction(fnType, "clang.arc.use");
1797  }
1798 
1799  // This isn't really a "runtime" function, but as an intrinsic it
1800  // doesn't really matter as long as we align things up.
1801  EmitNounwindRuntimeCall(fn, values);
1802 }
1803 
1804 
1805 static llvm::Constant *createARCRuntimeFunction(CodeGenModule &CGM,
1806  llvm::FunctionType *type,
1807  StringRef fnName) {
1808  llvm::Constant *fn = CGM.CreateRuntimeFunction(type, fnName);
1809 
1810  if (llvm::Function *f = dyn_cast<llvm::Function>(fn)) {
1811  // If the target runtime doesn't naturally support ARC, emit weak
1812  // references to the runtime support library. We don't really
1813  // permit this to fail, but we need a particular relocation style.
1814  if (!CGM.getLangOpts().ObjCRuntime.hasNativeARC()) {
1815  f->setLinkage(llvm::Function::ExternalWeakLinkage);
1816  } else if (fnName == "objc_retain" || fnName == "objc_release") {
1817  // If we have Native ARC, set nonlazybind attribute for these APIs for
1818  // performance.
1819  f->addFnAttr(llvm::Attribute::NonLazyBind);
1820  }
1821  }
1822 
1823  return fn;
1824 }
1825 
1826 /// Perform an operation having the signature
1827 /// i8* (i8*)
1828 /// where a null input causes a no-op and returns null.
1829 static llvm::Value *emitARCValueOperation(CodeGenFunction &CGF,
1830  llvm::Value *value,
1831  llvm::Constant *&fn,
1832  StringRef fnName,
1833  bool isTailCall = false) {
1834  if (isa<llvm::ConstantPointerNull>(value)) return value;
1835 
1836  if (!fn) {
1837  llvm::FunctionType *fnType =
1838  llvm::FunctionType::get(CGF.Int8PtrTy, CGF.Int8PtrTy, false);
1839  fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName);
1840  }
1841 
1842  // Cast the argument to 'id'.
1843  llvm::Type *origType = value->getType();
1844  value = CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy);
1845 
1846  // Call the function.
1847  llvm::CallInst *call = CGF.EmitNounwindRuntimeCall(fn, value);
1848  if (isTailCall)
1849  call->setTailCall();
1850 
1851  // Cast the result back to the original type.
1852  return CGF.Builder.CreateBitCast(call, origType);
1853 }
1854 
1855 /// Perform an operation having the following signature:
1856 /// i8* (i8**)
1857 static llvm::Value *emitARCLoadOperation(CodeGenFunction &CGF,
1858  Address addr,
1859  llvm::Constant *&fn,
1860  StringRef fnName) {
1861  if (!fn) {
1862  llvm::FunctionType *fnType =
1863  llvm::FunctionType::get(CGF.Int8PtrTy, CGF.Int8PtrPtrTy, false);
1864  fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName);
1865  }
1866 
1867  // Cast the argument to 'id*'.
1868  llvm::Type *origType = addr.getElementType();
1869  addr = CGF.Builder.CreateBitCast(addr, CGF.Int8PtrPtrTy);
1870 
1871  // Call the function.
1872  llvm::Value *result = CGF.EmitNounwindRuntimeCall(fn, addr.getPointer());
1873 
1874  // Cast the result back to a dereference of the original type.
1875  if (origType != CGF.Int8PtrTy)
1876  result = CGF.Builder.CreateBitCast(result, origType);
1877 
1878  return result;
1879 }
1880 
1881 /// Perform an operation having the following signature:
1882 /// i8* (i8**, i8*)
1883 static llvm::Value *emitARCStoreOperation(CodeGenFunction &CGF,
1884  Address addr,
1885  llvm::Value *value,
1886  llvm::Constant *&fn,
1887  StringRef fnName,
1888  bool ignored) {
1889  assert(addr.getElementType() == value->getType());
1890 
1891  if (!fn) {
1892  llvm::Type *argTypes[] = { CGF.Int8PtrPtrTy, CGF.Int8PtrTy };
1893 
1894  llvm::FunctionType *fnType
1895  = llvm::FunctionType::get(CGF.Int8PtrTy, argTypes, false);
1896  fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName);
1897  }
1898 
1899  llvm::Type *origType = value->getType();
1900 
1901  llvm::Value *args[] = {
1902  CGF.Builder.CreateBitCast(addr.getPointer(), CGF.Int8PtrPtrTy),
1903  CGF.Builder.CreateBitCast(value, CGF.Int8PtrTy)
1904  };
1905  llvm::CallInst *result = CGF.EmitNounwindRuntimeCall(fn, args);
1906 
1907  if (ignored) return nullptr;
1908 
1909  return CGF.Builder.CreateBitCast(result, origType);
1910 }
1911 
1912 /// Perform an operation having the following signature:
1913 /// void (i8**, i8**)
1915  Address dst,
1916  Address src,
1917  llvm::Constant *&fn,
1918  StringRef fnName) {
1919  assert(dst.getType() == src.getType());
1920 
1921  if (!fn) {
1922  llvm::Type *argTypes[] = { CGF.Int8PtrPtrTy, CGF.Int8PtrPtrTy };
1923 
1924  llvm::FunctionType *fnType
1925  = llvm::FunctionType::get(CGF.Builder.getVoidTy(), argTypes, false);
1926  fn = createARCRuntimeFunction(CGF.CGM, fnType, fnName);
1927  }
1928 
1929  llvm::Value *args[] = {
1930  CGF.Builder.CreateBitCast(dst.getPointer(), CGF.Int8PtrPtrTy),
1932  };
1933  CGF.EmitNounwindRuntimeCall(fn, args);
1934 }
1935 
1936 /// Produce the code to do a retain. Based on the type, calls one of:
1937 /// call i8* \@objc_retain(i8* %value)
1938 /// call i8* \@objc_retainBlock(i8* %value)
1939 llvm::Value *CodeGenFunction::EmitARCRetain(QualType type, llvm::Value *value) {
1940  if (type->isBlockPointerType())
1941  return EmitARCRetainBlock(value, /*mandatory*/ false);
1942  else
1943  return EmitARCRetainNonBlock(value);
1944 }
1945 
1946 /// Retain the given object, with normal retain semantics.
1947 /// call i8* \@objc_retain(i8* %value)
1948 llvm::Value *CodeGenFunction::EmitARCRetainNonBlock(llvm::Value *value) {
1949  return emitARCValueOperation(*this, value,
1951  "objc_retain");
1952 }
1953 
1954 /// Retain the given block, with _Block_copy semantics.
1955 /// call i8* \@objc_retainBlock(i8* %value)
1956 ///
1957 /// \param mandatory - If false, emit the call with metadata
1958 /// indicating that it's okay for the optimizer to eliminate this call
1959 /// if it can prove that the block never escapes except down the stack.
1960 llvm::Value *CodeGenFunction::EmitARCRetainBlock(llvm::Value *value,
1961  bool mandatory) {
1962  llvm::Value *result
1963  = emitARCValueOperation(*this, value,
1965  "objc_retainBlock");
1966 
1967  // If the copy isn't mandatory, add !clang.arc.copy_on_escape to
1968  // tell the optimizer that it doesn't need to do this copy if the
1969  // block doesn't escape, where being passed as an argument doesn't
1970  // count as escaping.
1971  if (!mandatory && isa<llvm::Instruction>(result)) {
1972  llvm::CallInst *call
1973  = cast<llvm::CallInst>(result->stripPointerCasts());
1974  assert(call->getCalledValue() == CGM.getObjCEntrypoints().objc_retainBlock);
1975 
1976  call->setMetadata("clang.arc.copy_on_escape",
1977  llvm::MDNode::get(Builder.getContext(), None));
1978  }
1979 
1980  return result;
1981 }
1982 
1983 /// Retain the given object which is the result of a function call.
1984 /// call i8* \@objc_retainAutoreleasedReturnValue(i8* %value)
1985 ///
1986 /// Yes, this function name is one character away from a different
1987 /// call with completely different semantics.
1988 llvm::Value *
1990  // Fetch the void(void) inline asm which marks that we're going to
1991  // retain the autoreleased return value.
1992  llvm::InlineAsm *&marker
1994  if (!marker) {
1995  StringRef assembly
1996  = CGM.getTargetCodeGenInfo()
1998 
1999  // If we have an empty assembly string, there's nothing to do.
2000  if (assembly.empty()) {
2001 
2002  // Otherwise, at -O0, build an inline asm that we're going to call
2003  // in a moment.
2004  } else if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
2005  llvm::FunctionType *type =
2006  llvm::FunctionType::get(VoidTy, /*variadic*/false);
2007 
2008  marker = llvm::InlineAsm::get(type, assembly, "", /*sideeffects*/ true);
2009 
2010  // If we're at -O1 and above, we don't want to litter the code
2011  // with this marker yet, so leave a breadcrumb for the ARC
2012  // optimizer to pick up.
2013  } else {
2014  llvm::NamedMDNode *metadata =
2015  CGM.getModule().getOrInsertNamedMetadata(
2016  "clang.arc.retainAutoreleasedReturnValueMarker");
2017  assert(metadata->getNumOperands() <= 1);
2018  if (metadata->getNumOperands() == 0) {
2019  metadata->addOperand(llvm::MDNode::get(
2020  getLLVMContext(), llvm::MDString::get(getLLVMContext(), assembly)));
2021  }
2022  }
2023  }
2024 
2025  // Call the marker asm if we made one, which we do only at -O0.
2026  if (marker)
2027  Builder.CreateCall(marker);
2028 
2029  return emitARCValueOperation(*this, value,
2031  "objc_retainAutoreleasedReturnValue");
2032 }
2033 
2034 /// Release the given object.
2035 /// call void \@objc_release(i8* %value)
2036 void CodeGenFunction::EmitARCRelease(llvm::Value *value,
2037  ARCPreciseLifetime_t precise) {
2038  if (isa<llvm::ConstantPointerNull>(value)) return;
2039 
2040  llvm::Constant *&fn = CGM.getObjCEntrypoints().objc_release;
2041  if (!fn) {
2042  llvm::FunctionType *fnType =
2043  llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrTy, false);
2044  fn = createARCRuntimeFunction(CGM, fnType, "objc_release");
2045  }
2046 
2047  // Cast the argument to 'id'.
2048  value = Builder.CreateBitCast(value, Int8PtrTy);
2049 
2050  // Call objc_release.
2051  llvm::CallInst *call = EmitNounwindRuntimeCall(fn, value);
2052 
2053  if (precise == ARCImpreciseLifetime) {
2054  call->setMetadata("clang.imprecise_release",
2055  llvm::MDNode::get(Builder.getContext(), None));
2056  }
2057 }
2058 
2059 /// Destroy a __strong variable.
2060 ///
2061 /// At -O0, emit a call to store 'null' into the address;
2062 /// instrumenting tools prefer this because the address is exposed,
2063 /// but it's relatively cumbersome to optimize.
2064 ///
2065 /// At -O1 and above, just load and call objc_release.
2066 ///
2067 /// call void \@objc_storeStrong(i8** %addr, i8* null)
2069  ARCPreciseLifetime_t precise) {
2070  if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
2071  llvm::Value *null = getNullForVariable(addr);
2072  EmitARCStoreStrongCall(addr, null, /*ignored*/ true);
2073  return;
2074  }
2075 
2076  llvm::Value *value = Builder.CreateLoad(addr);
2077  EmitARCRelease(value, precise);
2078 }
2079 
2080 /// Store into a strong object. Always calls this:
2081 /// call void \@objc_storeStrong(i8** %addr, i8* %value)
2083  llvm::Value *value,
2084  bool ignored) {
2085  assert(addr.getElementType() == value->getType());
2086 
2087  llvm::Constant *&fn = CGM.getObjCEntrypoints().objc_storeStrong;
2088  if (!fn) {
2089  llvm::Type *argTypes[] = { Int8PtrPtrTy, Int8PtrTy };
2090  llvm::FunctionType *fnType
2091  = llvm::FunctionType::get(Builder.getVoidTy(), argTypes, false);
2092  fn = createARCRuntimeFunction(CGM, fnType, "objc_storeStrong");
2093  }
2094 
2095  llvm::Value *args[] = {
2098  };
2099  EmitNounwindRuntimeCall(fn, args);
2100 
2101  if (ignored) return nullptr;
2102  return value;
2103 }
2104 
2105 /// Store into a strong object. Sometimes calls this:
2106 /// call void \@objc_storeStrong(i8** %addr, i8* %value)
2107 /// Other times, breaks it down into components.
2109  llvm::Value *newValue,
2110  bool ignored) {
2111  QualType type = dst.getType();
2112  bool isBlock = type->isBlockPointerType();
2113 
2114  // Use a store barrier at -O0 unless this is a block type or the
2115  // lvalue is inadequately aligned.
2116  if (shouldUseFusedARCCalls() &&
2117  !isBlock &&
2118  (dst.getAlignment().isZero() ||
2120  return EmitARCStoreStrongCall(dst.getAddress(), newValue, ignored);
2121  }
2122 
2123  // Otherwise, split it out.
2124 
2125  // Retain the new value.
2126  newValue = EmitARCRetain(type, newValue);
2127 
2128  // Read the old value.
2129  llvm::Value *oldValue = EmitLoadOfScalar(dst, SourceLocation());
2130 
2131  // Store. We do this before the release so that any deallocs won't
2132  // see the old value.
2133  EmitStoreOfScalar(newValue, dst);
2134 
2135  // Finally, release the old value.
2136  EmitARCRelease(oldValue, dst.isARCPreciseLifetime());
2137 
2138  return newValue;
2139 }
2140 
2141 /// Autorelease the given object.
2142 /// call i8* \@objc_autorelease(i8* %value)
2143 llvm::Value *CodeGenFunction::EmitARCAutorelease(llvm::Value *value) {
2144  return emitARCValueOperation(*this, value,
2146  "objc_autorelease");
2147 }
2148 
2149 /// Autorelease the given object.
2150 /// call i8* \@objc_autoreleaseReturnValue(i8* %value)
2151 llvm::Value *
2153  return emitARCValueOperation(*this, value,
2155  "objc_autoreleaseReturnValue",
2156  /*isTailCall*/ true);
2157 }
2158 
2159 /// Do a fused retain/autorelease of the given object.
2160 /// call i8* \@objc_retainAutoreleaseReturnValue(i8* %value)
2161 llvm::Value *
2163  return emitARCValueOperation(*this, value,
2165  "objc_retainAutoreleaseReturnValue",
2166  /*isTailCall*/ true);
2167 }
2168 
2169 /// Do a fused retain/autorelease of the given object.
2170 /// call i8* \@objc_retainAutorelease(i8* %value)
2171 /// or
2172 /// %retain = call i8* \@objc_retainBlock(i8* %value)
2173 /// call i8* \@objc_autorelease(i8* %retain)
2175  llvm::Value *value) {
2176  if (!type->isBlockPointerType())
2177  return EmitARCRetainAutoreleaseNonBlock(value);
2178 
2179  if (isa<llvm::ConstantPointerNull>(value)) return value;
2180 
2181  llvm::Type *origType = value->getType();
2182  value = Builder.CreateBitCast(value, Int8PtrTy);
2183  value = EmitARCRetainBlock(value, /*mandatory*/ true);
2184  value = EmitARCAutorelease(value);
2185  return Builder.CreateBitCast(value, origType);
2186 }
2187 
2188 /// Do a fused retain/autorelease of the given object.
2189 /// call i8* \@objc_retainAutorelease(i8* %value)
2190 llvm::Value *
2192  return emitARCValueOperation(*this, value,
2194  "objc_retainAutorelease");
2195 }
2196 
2197 /// i8* \@objc_loadWeak(i8** %addr)
2198 /// Essentially objc_autorelease(objc_loadWeakRetained(addr)).
2200  return emitARCLoadOperation(*this, addr,
2202  "objc_loadWeak");
2203 }
2204 
2205 /// i8* \@objc_loadWeakRetained(i8** %addr)
2207  return emitARCLoadOperation(*this, addr,
2209  "objc_loadWeakRetained");
2210 }
2211 
2212 /// i8* \@objc_storeWeak(i8** %addr, i8* %value)
2213 /// Returns %value.
2215  llvm::Value *value,
2216  bool ignored) {
2217  return emitARCStoreOperation(*this, addr, value,
2219  "objc_storeWeak", ignored);
2220 }
2221 
2222 /// i8* \@objc_initWeak(i8** %addr, i8* %value)
2223 /// Returns %value. %addr is known to not have a current weak entry.
2224 /// Essentially equivalent to:
2225 /// *addr = nil; objc_storeWeak(addr, value);
2226 void CodeGenFunction::EmitARCInitWeak(Address addr, llvm::Value *value) {
2227  // If we're initializing to null, just write null to memory; no need
2228  // to get the runtime involved. But don't do this if optimization
2229  // is enabled, because accounting for this would make the optimizer
2230  // much more complicated.
2231  if (isa<llvm::ConstantPointerNull>(value) &&
2232  CGM.getCodeGenOpts().OptimizationLevel == 0) {
2233  Builder.CreateStore(value, addr);
2234  return;
2235  }
2236 
2237  emitARCStoreOperation(*this, addr, value,
2239  "objc_initWeak", /*ignored*/ true);
2240 }
2241 
2242 /// void \@objc_destroyWeak(i8** %addr)
2243 /// Essentially objc_storeWeak(addr, nil).
2245  llvm::Constant *&fn = CGM.getObjCEntrypoints().objc_destroyWeak;
2246  if (!fn) {
2247  llvm::FunctionType *fnType =
2248  llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrPtrTy, false);
2249  fn = createARCRuntimeFunction(CGM, fnType, "objc_destroyWeak");
2250  }
2251 
2252  // Cast the argument to 'id*'.
2253  addr = Builder.CreateBitCast(addr, Int8PtrPtrTy);
2254 
2255  EmitNounwindRuntimeCall(fn, addr.getPointer());
2256 }
2257 
2258 /// void \@objc_moveWeak(i8** %dest, i8** %src)
2259 /// Disregards the current value in %dest. Leaves %src pointing to nothing.
2260 /// Essentially (objc_copyWeak(dest, src), objc_destroyWeak(src)).
2262  emitARCCopyOperation(*this, dst, src,
2264  "objc_moveWeak");
2265 }
2266 
2267 /// void \@objc_copyWeak(i8** %dest, i8** %src)
2268 /// Disregards the current value in %dest. Essentially
2269 /// objc_release(objc_initWeak(dest, objc_readWeakRetained(src)))
2271  emitARCCopyOperation(*this, dst, src,
2273  "objc_copyWeak");
2274 }
2275 
2276 /// Produce the code to do a objc_autoreleasepool_push.
2277 /// call i8* \@objc_autoreleasePoolPush(void)
2279  llvm::Constant *&fn = CGM.getObjCEntrypoints().objc_autoreleasePoolPush;
2280  if (!fn) {
2281  llvm::FunctionType *fnType =
2282  llvm::FunctionType::get(Int8PtrTy, false);
2283  fn = createARCRuntimeFunction(CGM, fnType, "objc_autoreleasePoolPush");
2284  }
2285 
2286  return EmitNounwindRuntimeCall(fn);
2287 }
2288 
2289 /// Produce the code to do a primitive release.
2290 /// call void \@objc_autoreleasePoolPop(i8* %ptr)
2292  assert(value->getType() == Int8PtrTy);
2293 
2294  llvm::Constant *&fn = CGM.getObjCEntrypoints().objc_autoreleasePoolPop;
2295  if (!fn) {
2296  llvm::FunctionType *fnType =
2297  llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrTy, false);
2298 
2299  // We don't want to use a weak import here; instead we should not
2300  // fall into this path.
2301  fn = createARCRuntimeFunction(CGM, fnType, "objc_autoreleasePoolPop");
2302  }
2303 
2304  // objc_autoreleasePoolPop can throw.
2305  EmitRuntimeCallOrInvoke(fn, value);
2306 }
2307 
2308 /// Produce the code to do an MRR version objc_autoreleasepool_push.
2309 /// Which is: [[NSAutoreleasePool alloc] init];
2310 /// Where alloc is declared as: + (id) alloc; in NSAutoreleasePool class.
2311 /// init is declared as: - (id) init; in its NSObject super class.
2312 ///
2314  CGObjCRuntime &Runtime = CGM.getObjCRuntime();
2315  llvm::Value *Receiver = Runtime.EmitNSAutoreleasePoolClassRef(*this);
2316  // [NSAutoreleasePool alloc]
2317  IdentifierInfo *II = &CGM.getContext().Idents.get("alloc");
2318  Selector AllocSel = getContext().Selectors.getSelector(0, &II);
2319  CallArgList Args;
2320  RValue AllocRV =
2321  Runtime.GenerateMessageSend(*this, ReturnValueSlot(),
2322  getContext().getObjCIdType(),
2323  AllocSel, Receiver, Args);
2324 
2325  // [Receiver init]
2326  Receiver = AllocRV.getScalarVal();
2327  II = &CGM.getContext().Idents.get("init");
2328  Selector InitSel = getContext().Selectors.getSelector(0, &II);
2329  RValue InitRV =
2330  Runtime.GenerateMessageSend(*this, ReturnValueSlot(),
2331  getContext().getObjCIdType(),
2332  InitSel, Receiver, Args);
2333  return InitRV.getScalarVal();
2334 }
2335 
2336 /// Produce the code to do a primitive release.
2337 /// [tmp drain];
2339  IdentifierInfo *II = &CGM.getContext().Idents.get("drain");
2340  Selector DrainSel = getContext().Selectors.getSelector(0, &II);
2341  CallArgList Args;
2343  getContext().VoidTy, DrainSel, Arg, Args);
2344 }
2345 
2347  Address addr,
2348  QualType type) {
2350 }
2351 
2353  Address addr,
2354  QualType type) {
2356 }
2357 
2359  Address addr,
2360  QualType type) {
2361  CGF.EmitARCDestroyWeak(addr);
2362 }
2363 
2364 namespace {
2365  struct CallObjCAutoreleasePoolObject final : EHScopeStack::Cleanup {
2366  llvm::Value *Token;
2367 
2368  CallObjCAutoreleasePoolObject(llvm::Value *token) : Token(token) {}
2369 
2370  void Emit(CodeGenFunction &CGF, Flags flags) override {
2372  }
2373  };
2374  struct CallObjCMRRAutoreleasePoolObject final : EHScopeStack::Cleanup {
2375  llvm::Value *Token;
2376 
2377  CallObjCMRRAutoreleasePoolObject(llvm::Value *token) : Token(token) {}
2378 
2379  void Emit(CodeGenFunction &CGF, Flags flags) override {
2381  }
2382  };
2383 }
2384 
2386  if (CGM.getLangOpts().ObjCAutoRefCount)
2387  EHStack.pushCleanup<CallObjCAutoreleasePoolObject>(NormalCleanup, Ptr);
2388  else
2389  EHStack.pushCleanup<CallObjCMRRAutoreleasePoolObject>(NormalCleanup, Ptr);
2390 }
2391 
2393  LValue lvalue,
2394  QualType type) {
2395  switch (type.getObjCLifetime()) {
2396  case Qualifiers::OCL_None:
2400  return TryEmitResult(CGF.EmitLoadOfLValue(lvalue,
2402  false);
2403 
2404  case Qualifiers::OCL_Weak:
2405  return TryEmitResult(CGF.EmitARCLoadWeakRetained(lvalue.getAddress()),
2406  true);
2407  }
2408 
2409  llvm_unreachable("impossible lifetime!");
2410 }
2411 
2413  const Expr *e) {
2414  e = e->IgnoreParens();
2415  QualType type = e->getType();
2416 
2417  // If we're loading retained from a __strong xvalue, we can avoid
2418  // an extra retain/release pair by zeroing out the source of this
2419  // "move" operation.
2420  if (e->isXValue() &&
2421  !type.isConstQualified() &&
2423  // Emit the lvalue.
2424  LValue lv = CGF.EmitLValue(e);
2425 
2426  // Load the object pointer.
2427  llvm::Value *result = CGF.EmitLoadOfLValue(lv,
2429 
2430  // Set the source pointer to NULL.
2432 
2433  return TryEmitResult(result, true);
2434  }
2435 
2436  // As a very special optimization, in ARC++, if the l-value is the
2437  // result of a non-volatile assignment, do a simple retain of the
2438  // result of the call to objc_storeWeak instead of reloading.
2439  if (CGF.getLangOpts().CPlusPlus &&
2440  !type.isVolatileQualified() &&
2442  isa<BinaryOperator>(e) &&
2443  cast<BinaryOperator>(e)->getOpcode() == BO_Assign)
2444  return TryEmitResult(CGF.EmitScalarExpr(e), false);
2445 
2446  return tryEmitARCRetainLoadOfScalar(CGF, CGF.EmitLValue(e), type);
2447 }
2448 
2449 static llvm::Value *emitARCRetainAfterCall(CodeGenFunction &CGF,
2450  llvm::Value *value);
2451 
2452 /// Given that the given expression is some sort of call (which does
2453 /// not return retained), emit a retain following it.
2454 static llvm::Value *emitARCRetainCall(CodeGenFunction &CGF, const Expr *e) {
2455  llvm::Value *value = CGF.EmitScalarExpr(e);
2456  return emitARCRetainAfterCall(CGF, value);
2457 }
2458 
2459 static llvm::Value *emitARCRetainAfterCall(CodeGenFunction &CGF,
2460  llvm::Value *value) {
2461  if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(value)) {
2462  CGBuilderTy::InsertPoint ip = CGF.Builder.saveIP();
2463 
2464  // Place the retain immediately following the call.
2465  CGF.Builder.SetInsertPoint(call->getParent(),
2466  ++llvm::BasicBlock::iterator(call));
2467  value = CGF.EmitARCRetainAutoreleasedReturnValue(value);
2468 
2469  CGF.Builder.restoreIP(ip);
2470  return value;
2471  } else if (llvm::InvokeInst *invoke = dyn_cast<llvm::InvokeInst>(value)) {
2472  CGBuilderTy::InsertPoint ip = CGF.Builder.saveIP();
2473 
2474  // Place the retain at the beginning of the normal destination block.
2475  llvm::BasicBlock *BB = invoke->getNormalDest();
2476  CGF.Builder.SetInsertPoint(BB, BB->begin());
2477  value = CGF.EmitARCRetainAutoreleasedReturnValue(value);
2478 
2479  CGF.Builder.restoreIP(ip);
2480  return value;
2481 
2482  // Bitcasts can arise because of related-result returns. Rewrite
2483  // the operand.
2484  } else if (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(value)) {
2485  llvm::Value *operand = bitcast->getOperand(0);
2486  operand = emitARCRetainAfterCall(CGF, operand);
2487  bitcast->setOperand(0, operand);
2488  return bitcast;
2489 
2490  // Generic fall-back case.
2491  } else {
2492  // Retain using the non-block variant: we never need to do a copy
2493  // of a block that's been returned to us.
2494  return CGF.EmitARCRetainNonBlock(value);
2495  }
2496 }
2497 
2498 /// Determine whether it might be important to emit a separate
2499 /// objc_retain_block on the result of the given expression, or
2500 /// whether it's okay to just emit it in a +1 context.
2501 static bool shouldEmitSeparateBlockRetain(const Expr *e) {
2502  assert(e->getType()->isBlockPointerType());
2503  e = e->IgnoreParens();
2504 
2505  // For future goodness, emit block expressions directly in +1
2506  // contexts if we can.
2507  if (isa<BlockExpr>(e))
2508  return false;
2509 
2510  if (const CastExpr *cast = dyn_cast<CastExpr>(e)) {
2511  switch (cast->getCastKind()) {
2512  // Emitting these operations in +1 contexts is goodness.
2513  case CK_LValueToRValue:
2515  case CK_ARCConsumeObject:
2516  case CK_ARCProduceObject:
2517  return false;
2518 
2519  // These operations preserve a block type.
2520  case CK_NoOp:
2521  case CK_BitCast:
2522  return shouldEmitSeparateBlockRetain(cast->getSubExpr());
2523 
2524  // These operations are known to be bad (or haven't been considered).
2526  default:
2527  return true;
2528  }
2529  }
2530 
2531  return true;
2532 }
2533 
2534 /// Try to emit a PseudoObjectExpr at +1.
2535 ///
2536 /// This massively duplicates emitPseudoObjectRValue.
2538  const PseudoObjectExpr *E) {
2540 
2541  // Find the result expression.
2542  const Expr *resultExpr = E->getResultExpr();
2543  assert(resultExpr);
2544  TryEmitResult result;
2545 
2547  i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
2548  const Expr *semantic = *i;
2549 
2550  // If this semantic expression is an opaque value, bind it
2551  // to the result of its source expression.
2552  if (const OpaqueValueExpr *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
2554  OVMA opaqueData;
2555 
2556  // If this semantic is the result of the pseudo-object
2557  // expression, try to evaluate the source as +1.
2558  if (ov == resultExpr) {
2559  assert(!OVMA::shouldBindAsLValue(ov));
2560  result = tryEmitARCRetainScalarExpr(CGF, ov->getSourceExpr());
2561  opaqueData = OVMA::bind(CGF, ov, RValue::get(result.getPointer()));
2562 
2563  // Otherwise, just bind it.
2564  } else {
2565  opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
2566  }
2567  opaques.push_back(opaqueData);
2568 
2569  // Otherwise, if the expression is the result, evaluate it
2570  // and remember the result.
2571  } else if (semantic == resultExpr) {
2572  result = tryEmitARCRetainScalarExpr(CGF, semantic);
2573 
2574  // Otherwise, evaluate the expression in an ignored context.
2575  } else {
2576  CGF.EmitIgnoredExpr(semantic);
2577  }
2578  }
2579 
2580  // Unbind all the opaques now.
2581  for (unsigned i = 0, e = opaques.size(); i != e; ++i)
2582  opaques[i].unbind(CGF);
2583 
2584  return result;
2585 }
2586 
2587 static TryEmitResult
2589  // We should *never* see a nested full-expression here, because if
2590  // we fail to emit at +1, our caller must not retain after we close
2591  // out the full-expression.
2592  assert(!isa<ExprWithCleanups>(e));
2593 
2594  // The desired result type, if it differs from the type of the
2595  // ultimate opaque expression.
2596  llvm::Type *resultType = nullptr;
2597 
2598  while (true) {
2599  e = e->IgnoreParens();
2600 
2601  // There's a break at the end of this if-chain; anything
2602  // that wants to keep looping has to explicitly continue.
2603  if (const CastExpr *ce = dyn_cast<CastExpr>(e)) {
2604  switch (ce->getCastKind()) {
2605  // No-op casts don't change the type, so we just ignore them.
2606  case CK_NoOp:
2607  e = ce->getSubExpr();
2608  continue;
2609 
2610  case CK_LValueToRValue: {
2611  TryEmitResult loadResult
2612  = tryEmitARCRetainLoadOfScalar(CGF, ce->getSubExpr());
2613  if (resultType) {
2614  llvm::Value *value = loadResult.getPointer();
2615  value = CGF.Builder.CreateBitCast(value, resultType);
2616  loadResult.setPointer(value);
2617  }
2618  return loadResult;
2619  }
2620 
2621  // These casts can change the type, so remember that and
2622  // soldier on. We only need to remember the outermost such
2623  // cast, though.
2627  case CK_BitCast:
2628  if (!resultType)
2629  resultType = CGF.ConvertType(ce->getType());
2630  e = ce->getSubExpr();
2631  assert(e->getType()->hasPointerRepresentation());
2632  continue;
2633 
2634  // For consumptions, just emit the subexpression and thus elide
2635  // the retain/release pair.
2636  case CK_ARCConsumeObject: {
2637  llvm::Value *result = CGF.EmitScalarExpr(ce->getSubExpr());
2638  if (resultType) result = CGF.Builder.CreateBitCast(result, resultType);
2639  return TryEmitResult(result, true);
2640  }
2641 
2642  // Block extends are net +0. Naively, we could just recurse on
2643  // the subexpression, but actually we need to ensure that the
2644  // value is copied as a block, so there's a little filter here.
2645  case CK_ARCExtendBlockObject: {
2646  llvm::Value *result; // will be a +0 value
2647 
2648  // If we can't safely assume the sub-expression will produce a
2649  // block-copied value, emit the sub-expression at +0.
2650  if (shouldEmitSeparateBlockRetain(ce->getSubExpr())) {
2651  result = CGF.EmitScalarExpr(ce->getSubExpr());
2652 
2653  // Otherwise, try to emit the sub-expression at +1 recursively.
2654  } else {
2655  TryEmitResult subresult
2656  = tryEmitARCRetainScalarExpr(CGF, ce->getSubExpr());
2657  result = subresult.getPointer();
2658 
2659  // If that produced a retained value, just use that,
2660  // possibly casting down.
2661  if (subresult.getInt()) {
2662  if (resultType)
2663  result = CGF.Builder.CreateBitCast(result, resultType);
2664  return TryEmitResult(result, true);
2665  }
2666 
2667  // Otherwise it's +0.
2668  }
2669 
2670  // Retain the object as a block, then cast down.
2671  result = CGF.EmitARCRetainBlock(result, /*mandatory*/ true);
2672  if (resultType) result = CGF.Builder.CreateBitCast(result, resultType);
2673  return TryEmitResult(result, true);
2674  }
2675 
2676  // For reclaims, emit the subexpression as a retained call and
2677  // skip the consumption.
2679  llvm::Value *result = emitARCRetainCall(CGF, ce->getSubExpr());
2680  if (resultType) result = CGF.Builder.CreateBitCast(result, resultType);
2681  return TryEmitResult(result, true);
2682  }
2683 
2684  default:
2685  break;
2686  }
2687 
2688  // Skip __extension__.
2689  } else if (const UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
2690  if (op->getOpcode() == UO_Extension) {
2691  e = op->getSubExpr();
2692  continue;
2693  }
2694 
2695  // For calls and message sends, use the retained-call logic.
2696  // Delegate inits are a special case in that they're the only
2697  // returns-retained expression that *isn't* surrounded by
2698  // a consume.
2699  } else if (isa<CallExpr>(e) ||
2700  (isa<ObjCMessageExpr>(e) &&
2701  !cast<ObjCMessageExpr>(e)->isDelegateInitCall())) {
2702  llvm::Value *result = emitARCRetainCall(CGF, e);
2703  if (resultType) result = CGF.Builder.CreateBitCast(result, resultType);
2704  return TryEmitResult(result, true);
2705 
2706  // Look through pseudo-object expressions.
2707  } else if (const PseudoObjectExpr *pseudo = dyn_cast<PseudoObjectExpr>(e)) {
2708  TryEmitResult result
2709  = tryEmitARCRetainPseudoObject(CGF, pseudo);
2710  if (resultType) {
2711  llvm::Value *value = result.getPointer();
2712  value = CGF.Builder.CreateBitCast(value, resultType);
2713  result.setPointer(value);
2714  }
2715  return result;
2716  }
2717 
2718  // Conservatively halt the search at any other expression kind.
2719  break;
2720  }
2721 
2722  // We didn't find an obvious production, so emit what we've got and
2723  // tell the caller that we didn't manage to retain.
2724  llvm::Value *result = CGF.EmitScalarExpr(e);
2725  if (resultType) result = CGF.Builder.CreateBitCast(result, resultType);
2726  return TryEmitResult(result, false);
2727 }
2728 
2730  LValue lvalue,
2731  QualType type) {
2732  TryEmitResult result = tryEmitARCRetainLoadOfScalar(CGF, lvalue, type);
2733  llvm::Value *value = result.getPointer();
2734  if (!result.getInt())
2735  value = CGF.EmitARCRetain(type, value);
2736  return value;
2737 }
2738 
2739 /// EmitARCRetainScalarExpr - Semantically equivalent to
2740 /// EmitARCRetainObject(e->getType(), EmitScalarExpr(e)), but making a
2741 /// best-effort attempt to peephole expressions that naturally produce
2742 /// retained objects.
2744  // The retain needs to happen within the full-expression.
2745  if (const ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(e)) {
2746  enterFullExpression(cleanups);
2747  RunCleanupsScope scope(*this);
2748  return EmitARCRetainScalarExpr(cleanups->getSubExpr());
2749  }
2750 
2751  TryEmitResult result = tryEmitARCRetainScalarExpr(*this, e);
2752  llvm::Value *value = result.getPointer();
2753  if (!result.getInt())
2754  value = EmitARCRetain(e->getType(), value);
2755  return value;
2756 }
2757 
2758 llvm::Value *
2760  // The retain needs to happen within the full-expression.
2761  if (const ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(e)) {
2762  enterFullExpression(cleanups);
2763  RunCleanupsScope scope(*this);
2764  return EmitARCRetainAutoreleaseScalarExpr(cleanups->getSubExpr());
2765  }
2766 
2767  TryEmitResult result = tryEmitARCRetainScalarExpr(*this, e);
2768  llvm::Value *value = result.getPointer();
2769  if (result.getInt())
2770  value = EmitARCAutorelease(value);
2771  else
2772  value = EmitARCRetainAutorelease(e->getType(), value);
2773  return value;
2774 }
2775 
2777  llvm::Value *result;
2778  bool doRetain;
2779 
2781  result = EmitScalarExpr(e);
2782  doRetain = true;
2783  } else {
2784  TryEmitResult subresult = tryEmitARCRetainScalarExpr(*this, e);
2785  result = subresult.getPointer();
2786  doRetain = !subresult.getInt();
2787  }
2788 
2789  if (doRetain)
2790  result = EmitARCRetainBlock(result, /*mandatory*/ true);
2791  return EmitObjCConsumeObject(e->getType(), result);
2792 }
2793 
2795  // In ARC, retain and autorelease the expression.
2796  if (getLangOpts().ObjCAutoRefCount) {
2797  // Do so before running any cleanups for the full-expression.
2798  // EmitARCRetainAutoreleaseScalarExpr does this for us.
2800  }
2801 
2802  // Otherwise, use the normal scalar-expression emission. The
2803  // exception machinery doesn't do anything special with the
2804  // exception like retaining it, so there's no safety associated with
2805  // only running cleanups after the throw has started, and when it
2806  // matters it tends to be substantially inferior code.
2807  return EmitScalarExpr(expr);
2808 }
2809 
2810 std::pair<LValue,llvm::Value*>
2812  bool ignored) {
2813  // Evaluate the RHS first.
2814  TryEmitResult result = tryEmitARCRetainScalarExpr(*this, e->getRHS());
2815  llvm::Value *value = result.getPointer();
2816 
2817  bool hasImmediateRetain = result.getInt();
2818 
2819  // If we didn't emit a retained object, and the l-value is of block
2820  // type, then we need to emit the block-retain immediately in case
2821  // it invalidates the l-value.
2822  if (!hasImmediateRetain && e->getType()->isBlockPointerType()) {
2823  value = EmitARCRetainBlock(value, /*mandatory*/ false);
2824  hasImmediateRetain = true;
2825  }
2826 
2827  LValue lvalue = EmitLValue(e->getLHS());
2828 
2829  // If the RHS was emitted retained, expand this.
2830  if (hasImmediateRetain) {
2831  llvm::Value *oldValue = EmitLoadOfScalar(lvalue, SourceLocation());
2832  EmitStoreOfScalar(value, lvalue);
2833  EmitARCRelease(oldValue, lvalue.isARCPreciseLifetime());
2834  } else {
2835  value = EmitARCStoreStrong(lvalue, value, ignored);
2836  }
2837 
2838  return std::pair<LValue,llvm::Value*>(lvalue, value);
2839 }
2840 
2841 std::pair<LValue,llvm::Value*>
2843  llvm::Value *value = EmitARCRetainAutoreleaseScalarExpr(e->getRHS());
2844  LValue lvalue = EmitLValue(e->getLHS());
2845 
2846  EmitStoreOfScalar(value, lvalue);
2847 
2848  return std::pair<LValue,llvm::Value*>(lvalue, value);
2849 }
2850 
2852  const ObjCAutoreleasePoolStmt &ARPS) {
2853  const Stmt *subStmt = ARPS.getSubStmt();
2854  const CompoundStmt &S = cast<CompoundStmt>(*subStmt);
2855 
2856  CGDebugInfo *DI = getDebugInfo();
2857  if (DI)
2859 
2860  // Keep track of the current cleanup stack depth.
2861  RunCleanupsScope Scope(*this);
2862  if (CGM.getLangOpts().ObjCRuntime.hasNativeARC()) {
2863  llvm::Value *token = EmitObjCAutoreleasePoolPush();
2864  EHStack.pushCleanup<CallObjCAutoreleasePoolObject>(NormalCleanup, token);
2865  } else {
2866  llvm::Value *token = EmitObjCMRRAutoreleasePoolPush();
2867  EHStack.pushCleanup<CallObjCMRRAutoreleasePoolObject>(NormalCleanup, token);
2868  }
2869 
2870  for (const auto *I : S.body())
2871  EmitStmt(I);
2872 
2873  if (DI)
2875 }
2876 
2877 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
2878 /// make sure it survives garbage collection until this point.
2879 void CodeGenFunction::EmitExtendGCLifetime(llvm::Value *object) {
2880  // We just use an inline assembly.
2881  llvm::FunctionType *extenderType
2882  = llvm::FunctionType::get(VoidTy, VoidPtrTy, RequiredArgs::All);
2883  llvm::Value *extender
2884  = llvm::InlineAsm::get(extenderType,
2885  /* assembly */ "",
2886  /* constraints */ "r",
2887  /* side effects */ true);
2888 
2889  object = Builder.CreateBitCast(object, VoidPtrTy);
2890  EmitNounwindRuntimeCall(extender, object);
2891 }
2892 
2893 /// GenerateObjCAtomicSetterCopyHelperFunction - Given a c++ object type with
2894 /// non-trivial copy assignment function, produce following helper function.
2895 /// static void copyHelper(Ty *dest, const Ty *source) { *dest = *source; }
2896 ///
2897 llvm::Constant *
2899  const ObjCPropertyImplDecl *PID) {
2900  if (!getLangOpts().CPlusPlus ||
2902  return nullptr;
2903  QualType Ty = PID->getPropertyIvarDecl()->getType();
2904  if (!Ty->isRecordType())
2905  return nullptr;
2906  const ObjCPropertyDecl *PD = PID->getPropertyDecl();
2908  return nullptr;
2909  llvm::Constant *HelperFn = nullptr;
2910  if (hasTrivialSetExpr(PID))
2911  return nullptr;
2912  assert(PID->getSetterCXXAssignment() && "SetterCXXAssignment - null");
2913  if ((HelperFn = CGM.getAtomicSetterHelperFnMap(Ty)))
2914  return HelperFn;
2915 
2916  ASTContext &C = getContext();
2917  IdentifierInfo *II
2918  = &CGM.getContext().Idents.get("__assign_helper_atomic_property_");
2921  SourceLocation(),
2922  SourceLocation(), II, C.VoidTy,
2923  nullptr, SC_Static,
2924  false,
2925  false);
2926 
2927  QualType DestTy = C.getPointerType(Ty);
2928  QualType SrcTy = Ty;
2929  SrcTy.addConst();
2930  SrcTy = C.getPointerType(SrcTy);
2931 
2932  FunctionArgList args;
2933  ImplicitParamDecl dstDecl(getContext(), FD, SourceLocation(), nullptr,DestTy);
2934  args.push_back(&dstDecl);
2935  ImplicitParamDecl srcDecl(getContext(), FD, SourceLocation(), nullptr, SrcTy);
2936  args.push_back(&srcDecl);
2937 
2940 
2941  llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
2942 
2943  llvm::Function *Fn =
2945  "__assign_helper_atomic_property_",
2946  &CGM.getModule());
2947 
2948  CGM.SetInternalFunctionAttributes(nullptr, Fn, FI);
2949 
2950  StartFunction(FD, C.VoidTy, Fn, FI, args);
2951 
2952  DeclRefExpr DstExpr(&dstDecl, false, DestTy,
2954  UnaryOperator DST(&DstExpr, UO_Deref, DestTy->getPointeeType(),
2956 
2957  DeclRefExpr SrcExpr(&srcDecl, false, SrcTy,
2959  UnaryOperator SRC(&SrcExpr, UO_Deref, SrcTy->getPointeeType(),
2961 
2962  Expr *Args[2] = { &DST, &SRC };
2963  CallExpr *CalleeExp = cast<CallExpr>(PID->getSetterCXXAssignment());
2964  CXXOperatorCallExpr TheCall(C, OO_Equal, CalleeExp->getCallee(),
2965  Args, DestTy->getPointeeType(),
2966  VK_LValue, SourceLocation(), false);
2967 
2968  EmitStmt(&TheCall);
2969 
2970  FinishFunction();
2971  HelperFn = llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy);
2972  CGM.setAtomicSetterHelperFnMap(Ty, HelperFn);
2973  return HelperFn;
2974 }
2975 
2976 llvm::Constant *
2978  const ObjCPropertyImplDecl *PID) {
2979  if (!getLangOpts().CPlusPlus ||
2981  return nullptr;
2982  const ObjCPropertyDecl *PD = PID->getPropertyDecl();
2983  QualType Ty = PD->getType();
2984  if (!Ty->isRecordType())
2985  return nullptr;
2987  return nullptr;
2988  llvm::Constant *HelperFn = nullptr;
2989 
2990  if (hasTrivialGetExpr(PID))
2991  return nullptr;
2992  assert(PID->getGetterCXXConstructor() && "getGetterCXXConstructor - null");
2993  if ((HelperFn = CGM.getAtomicGetterHelperFnMap(Ty)))
2994  return HelperFn;
2995 
2996 
2997  ASTContext &C = getContext();
2998  IdentifierInfo *II
2999  = &CGM.getContext().Idents.get("__copy_helper_atomic_property_");
3002  SourceLocation(),
3003  SourceLocation(), II, C.VoidTy,
3004  nullptr, SC_Static,
3005  false,
3006  false);
3007 
3008  QualType DestTy = C.getPointerType(Ty);
3009  QualType SrcTy = Ty;
3010  SrcTy.addConst();
3011  SrcTy = C.getPointerType(SrcTy);
3012 
3013  FunctionArgList args;
3014  ImplicitParamDecl dstDecl(getContext(), FD, SourceLocation(), nullptr,DestTy);
3015  args.push_back(&dstDecl);
3016  ImplicitParamDecl srcDecl(getContext(), FD, SourceLocation(), nullptr, SrcTy);
3017  args.push_back(&srcDecl);
3018 
3021 
3022  llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
3023 
3024  llvm::Function *Fn =
3026  "__copy_helper_atomic_property_", &CGM.getModule());
3027 
3028  CGM.SetInternalFunctionAttributes(nullptr, Fn, FI);
3029 
3030  StartFunction(FD, C.VoidTy, Fn, FI, args);
3031 
3032  DeclRefExpr SrcExpr(&srcDecl, false, SrcTy,
3034 
3035  UnaryOperator SRC(&SrcExpr, UO_Deref, SrcTy->getPointeeType(),
3037 
3038  CXXConstructExpr *CXXConstExpr =
3039  cast<CXXConstructExpr>(PID->getGetterCXXConstructor());
3040 
3041  SmallVector<Expr*, 4> ConstructorArgs;
3042  ConstructorArgs.push_back(&SRC);
3043  ConstructorArgs.append(std::next(CXXConstExpr->arg_begin()),
3044  CXXConstExpr->arg_end());
3045 
3046  CXXConstructExpr *TheCXXConstructExpr =
3048  CXXConstExpr->getConstructor(),
3049  CXXConstExpr->isElidable(),
3050  ConstructorArgs,
3051  CXXConstExpr->hadMultipleCandidates(),
3052  CXXConstExpr->isListInitialization(),
3053  CXXConstExpr->isStdInitListInitialization(),
3054  CXXConstExpr->requiresZeroInitialization(),
3055  CXXConstExpr->getConstructionKind(),
3056  SourceRange());
3057 
3058  DeclRefExpr DstExpr(&dstDecl, false, DestTy,
3060 
3061  RValue DV = EmitAnyExpr(&DstExpr);
3062  CharUnits Alignment
3063  = getContext().getTypeAlignInChars(TheCXXConstructExpr->getType());
3064  EmitAggExpr(TheCXXConstructExpr,
3065  AggValueSlot::forAddr(Address(DV.getScalarVal(), Alignment),
3066  Qualifiers(),
3070 
3071  FinishFunction();
3072  HelperFn = llvm::ConstantExpr::getBitCast(Fn, VoidPtrTy);
3073  CGM.setAtomicGetterHelperFnMap(Ty, HelperFn);
3074  return HelperFn;
3075 }
3076 
3077 llvm::Value *
3079  // Get selectors for retain/autorelease.
3080  IdentifierInfo *CopyID = &getContext().Idents.get("copy");
3081  Selector CopySelector =
3083  IdentifierInfo *AutoreleaseID = &getContext().Idents.get("autorelease");
3084  Selector AutoreleaseSelector =
3085  getContext().Selectors.getNullarySelector(AutoreleaseID);
3086 
3087  // Emit calls to retain/autorelease.
3088  CGObjCRuntime &Runtime = CGM.getObjCRuntime();
3089  llvm::Value *Val = Block;
3090  RValue Result;
3091  Result = Runtime.GenerateMessageSend(*this, ReturnValueSlot(),
3092  Ty, CopySelector,
3093  Val, CallArgList(), nullptr, nullptr);
3094  Val = Result.getScalarVal();
3095  Result = Runtime.GenerateMessageSend(*this, ReturnValueSlot(),
3096  Ty, AutoreleaseSelector,
3097  Val, CallArgList(), nullptr, nullptr);
3098  Val = Result.getScalarVal();
3099  return Val;
3100 }
3101 
3102 
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:54
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1009
param_const_iterator param_begin() const
Definition: DeclObjC.h:359
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:1140
Defines the clang::ASTContext interface.
bool isAtomic() const
isAtomic - Return true if the property is atomic.
Definition: DeclObjC.h:2534
CastKind getCastKind() const
Definition: Expr.h:2658
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1483
llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)
Store into a strong object.
Definition: CGObjC.cpp:2108
CK_LValueToRValue - A conversion which causes the extraction of an r-value from the operand gl-value...
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1192
The receiver is an object instance.
Definition: ExprObjC.h:1005
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.
Smart pointer class that efficiently represents Objective-C method names.
llvm::Value * EmitARCRetainAutoreleaseScalarExpr(const Expr *expr)
Definition: CGObjC.cpp:2759
static bool hasTrivialGetExpr(const ObjCPropertyImplDecl *propImpl)
Definition: CGObjC.cpp:811
ObjCEntrypoints & getObjCEntrypoints() const
CanQualType VoidPtrTy
Definition: ASTContext.h:895
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
Definition: CGDecl.cpp:1420
A (possibly-)qualified type.
Definition: Type.h:575
static bool hasUnalignedAtomics(llvm::Triple::ArchType arch)
Determine whether the given architecture supports unaligned atomic accesses.
Definition: CGObjC.cpp:602
void EmitExtendGCLifetime(llvm::Value *object)
EmitExtendGCLifetime - Given a pointer to an Objective-C object, make sure it survives garbage collec...
Definition: CGObjC.cpp:2879
llvm::Value * getPointer() const
Definition: CGValue.h:327
llvm::Value * EmitARCExtendBlockObject(const Expr *expr)
Definition: CGObjC.cpp:2776
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1043
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2277
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1003
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:2244
static CXXConstructExpr * Create(const ASTContext &C, QualType T, SourceLocation Loc, CXXConstructorDecl *D, bool Elidable, ArrayRef< Expr * > Args, bool HadMultipleCandidates, bool ListInitialization, bool StdInitListInitialization, bool ZeroInitialization, ConstructionKind ConstructKind, SourceRange ParenOrBraceRange)
Definition: ExprCXX.cpp:824
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:738
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:5362
llvm::Constant * objc_autoreleaseReturnValue
id objc_autoreleaseReturnValue(id);
Address getAddress() const
Definition: CGValue.h:331
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
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:1568
void GenerateObjCSetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCSetter - Synthesize an Objective-C property setter function for the given property...
Definition: CGObjC.cpp:1327
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:4861
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1149
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:2270
llvm::Value * EmitObjCMRRAutoreleasePoolPush()
Produce the code to do an MRR version objc_autoreleasepool_push.
Definition: CGObjC.cpp:2313
llvm::Constant * GenerateObjCAtomicSetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
GenerateObjCAtomicSetterCopyHelperFunction - Given a c++ object type with non-trivial copy assignment...
Definition: CGObjC.cpp:2898
const LangOptions & getLangOpts() const
bool isBlockPointerType() const
Definition: Type.h:5311
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
Definition: CGObjC.cpp:1948
static llvm::Value * emitARCRetainLoadOfScalar(CodeGenFunction &CGF, LValue lvalue, QualType type)
Definition: CGObjC.cpp:2729
[ARC] Consumes a retainable object pointer that has just been produced, e.g.
const CGFunctionInfo & arrangeFreeFunctionDeclaration(QualType ResTy, const FunctionArgList &Args, const FunctionType::ExtInfo &Info, bool isVariadic)
Definition: CGCall.cpp:490
void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID)
createImplicitParams - Used to lazily create the self and cmd implict parameters. ...
Definition: DeclObjC.cpp:1022
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:699
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:52
Expr * getSetterCXXAssignment() const
Definition: DeclObjC.h:2700
const Expr * getCallee() const
Definition: Expr.h:2170
ObjCLifetime getObjCLifetime() const
Definition: Type.h:290
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:2278
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1793
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
Definition: CGDebugInfo.h:51
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
llvm::Value * EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty)
Definition: CGObjC.cpp:3078
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:2847
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1299
bool isObjCRetainableType() const
Definition: Type.cpp:3704
llvm::Value * EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E)
Definition: CGObjC.cpp:229
QualType getType() const
Definition: DeclObjC.h:2497
The collection of all-type qualifiers we support.
Definition: Type.h:116
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:2794
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:1496
ObjCProtocolDecl * getProtocol() const
Definition: ExprObjC.h:453
bool hasAttr() const
Definition: DeclBase.h:498
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:4557
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:91
std::pair< LValue, llvm::Value * > EmitARCStoreAutoreleasing(const BinaryOperator *e)
Definition: CGObjC.cpp:2842
llvm::Constant * objc_retainAutoreleasedReturnValue
id objc_retainAutoreleasedReturnValue(id);
llvm::Value * EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr)
Definition: CGObjC.cpp:1784
bool isReferenceType() const
Definition: Type.h:5314
llvm::Value * EmitARCRetainAutoreleaseReturnValue(llvm::Value *value)
Do a fused retain/autorelease of the given object.
Definition: CGObjC.cpp:2162
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2209
ImplicitParamDecl * getCmdDecl() const
Definition: DeclObjC.h:413
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
[ARC] Causes a value of block type to be copied to the heap, if it is not already there...
Token - This structure provides full information about a lexed token.
Definition: Token.h:37
llvm::Value * EmitARCAutoreleaseReturnValue(llvm::Value *value)
Autorelease the given object.
Definition: CGObjC.cpp:2152
void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, ObjCMethodDecl *MD, bool ctor)
Definition: CGObjC.cpp:1408
SourceLocation getLBracLoc() const
Definition: Stmt.h:617
Expr * getSubExpr()
Definition: Expr.h:2662
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:3159
virtual llvm::Constant * GetPropertySetFunction()=0
Return the runtime function for setting properties.
CleanupKind getCleanupKind(QualType::DestructionKind kind)
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param IfCond Not a nullptr if if clause was nullptr *otherwise *param PrivateVars List of references to private variables for the task *directive *param PrivateCopies List of private copies for each private variable in *p PrivateVars *param FirstprivateVars List of references to private variables for the *task directive *param FirstprivateCopies List of private copies for each private variable *in p FirstprivateVars *param FirstprivateInits List of references to auto generated variables *used for initialization of a single array element Used if firstprivate *variable is of array type *param Dependences List of dependences for the task construct
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:1987
IdentifierTable & Idents
Definition: ASTContext.h:451
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:102
Expr * getLHS() const
Definition: Expr.h:2921
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:4759
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:139
llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)
Store into a strong object.
Definition: CGObjC.cpp:2082
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:696
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:176
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:2068
const Qualifiers & getQuals() const
Definition: CGValue.h:311
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Definition: DeclObjC.cpp:885
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:4766
llvm::Constant * objc_release
void objc_release(id);
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2875
Selector getSelector() const
Definition: ExprObjC.cpp:306
Expr * getGetterCXXConstructor() const
Definition: DeclObjC.h:2693
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:4800
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:2199
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:38
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:2743
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
Definition: CGExpr.cpp:127
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:2501
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:608
static llvm::Value * emitARCRetainAfterCall(CodeGenFunction &CGF, llvm::Value *value)
Definition: CGObjC.cpp:2459
static TryEmitResult tryEmitARCRetainPseudoObject(CodeGenFunction &CGF, const PseudoObjectExpr *E)
Try to emit a PseudoObjectExpr at +1.
Definition: CGObjC.cpp:2537
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2610
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:118
uint64_t getCurrentProfileCount()
Get the profiler's current count.
Represents an ObjC class declaration.
Definition: DeclObjC.h:853
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclObjC.cpp:879
detail::InMemoryDirectory::const_iterator I
PropertyAttributeKind getPropertyAttributes() const
Definition: DeclObjC.h:2508
static TryEmitResult tryEmitARCRetainScalarExpr(CodeGenFunction &CGF, const Expr *e)
Definition: CGObjC.cpp:2588
std::pair< CharUnits, CharUnits > getTypeInfoInChars(const Type *T) const
QualType getType() const
Definition: Decl.h:530
llvm::Value * EmitARCRetainAutoreleasedReturnValue(llvm::Value *value)
Retain the given object which is the result of a function call.
Definition: CGObjC.cpp:1989
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:1642
llvm::Value * EmitARCRetainAutoreleaseNonBlock(llvm::Value *value)
Do a fused retain/autorelease of the given object.
Definition: CGObjC.cpp:2191
This object can be modified without requiring retains or releases.
Definition: Type.h:137
virtual StringRef getARCRetainAutoreleasedReturnValueMarker() const
Retrieve the address of a function to call immediately before calling objc_retainAutoreleasedReturnVa...
CK_AnyPointerToBlockPointerCast - Casting any non-block pointer to a block pointer.
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2605
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:3111
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:539
AutoVarEmission EmitAutoVarAlloca(const VarDecl &var)
EmitAutoVarAlloca - Emit the alloca and debug information for a local variable.
Definition: CGDecl.cpp:942
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:980
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:168
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
SourceLocation getBodyRBrace() const
getBodyRBrace - Gets the right brace of the body, if a body exists.
Definition: DeclBase.cpp:726
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:2214
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:521
Expr - This represents one expression.
Definition: Expr.h:104
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:2261
virtual llvm::Constant * GetSetStructFunction()=0
void EmitAutoVarInit(const AutoVarEmission &emission)
Definition: CGDecl.cpp:1166
static Address invalid()
Definition: Address.h:35
CK_BitCast - A conversion which causes a bit pattern of one type to be reinterpreted as a bit pattern...
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:2547
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:1348
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
Generate an Objective-C method.
Definition: CGObjC.cpp:558
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:2671
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:1036
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:875
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
DeclContext * getDeclContext()
Definition: DeclBase.h:393
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
struct ExtInfo * ExtInfo
Definition: CGCleanup.h:264
FormatToken * Token
void generateObjCSetterBody(const ObjCImplementationDecl *classImpl, const ObjCPropertyImplDecl *propImpl, llvm::Constant *AtomicHelperFn)
Definition: CGObjC.cpp:1147
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:411
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:2143
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
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:419
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:85
virtual llvm::Constant * GetPropertyGetFunction()=0
Return the runtime function for getting properties.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1593
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:1344
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:860
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)
Creates clause with a list of variables VL and a linear step Step.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1654
ValueDecl * getDecl()
Definition: Expr.h:1007
bool isGLValue() const
Definition: Expr.h:249
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:28
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:1883
param_const_iterator param_end() const
Definition: DeclObjC.h:362
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:424
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:376
CK_CPointerToObjCPointerCast - Casting a C pointer kind to an Objective-C pointer.
llvm::Constant * objc_retainBlock
id objc_retainBlock(id);
There is no lifetime qualification on this type.
Definition: Type.h:133
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:840
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:168
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
SelectorTable & Selectors
Definition: ASTContext.h:452
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:144
Kind
llvm::Constant * objc_storeWeak
id objc_storeWeak(id*, id);
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4692
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:569
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:1791
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:836
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
Definition: CGObjC.cpp:2036
LValue EmitDeclRefLValue(const DeclRefExpr *E)
Definition: CGExpr.cpp:2033
const TemplateArgument * iterator
Definition: Type.h:4070
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:1236
void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S)
Definition: CGObjC.cpp:1458
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:431
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
Definition: DeclObjC.cpp:756
QualType withConst() const
Definition: Type.h:741
llvm::Constant * objc_autoreleasePoolPush
void *objc_autoreleasePoolPush(void);
static TryEmitResult tryEmitARCRetainLoadOfScalar(CodeGenFunction &CGF, LValue lvalue, QualType type)
Definition: CGObjC.cpp:2392
const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)
Arrange the argument and result information for the declaration or definition of an Objective-C metho...
Definition: CGCall.cpp:312
virtual llvm::Value * EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF)
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2085
CanQualType VoidTy
Definition: ASTContext.h:881
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:1805
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:2416
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2712
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:1365
Assigning into this object requires a lifetime extension.
Definition: Type.h:150
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:94
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5159
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:1939
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:2338
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:1642
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
QualType getType() const
Definition: Expr.h:125
Expr * getResultExpr()
Return the result-bearing expression, or null if there is none.
Definition: Expr.h:4747
void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S)
Definition: CGObjC.cpp:1757
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.
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:1829
void GenerateObjCGetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCGetter - Synthesize an Objective-C property getter function.
Definition: CGObjC.cpp:797
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:2291
Address CreateMemTemp(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignment...
Definition: CGExpr.cpp:97
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1723
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:2206
Address CreateStructGEP(Address Addr, unsigned Index, CharUnits Offset, const llvm::Twine &Name="")
Definition: CGBuilder.h:191
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:99
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:78
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:1450
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Selector getSelector() const
Definition: DeclObjC.h:328
ObjCMethodDecl * getArrayWithObjectsMethod() const
Definition: ExprObjC.h:196
CK_BlockPointerToObjCPointerCast - Casting a block pointer to an ObjC pointer.
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:1423
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:121
semantics_iterator semantics_begin()
Definition: Expr.h:4760
llvm::Constant * GenerateObjCAtomicGetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
Definition: CGObjC.cpp:2977
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1946
static bool hasTrivialSetExpr(const ObjCPropertyImplDecl *PID)
Definition: CGObjC.cpp:1116
void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S)
Definition: CGObjC.cpp:1753
static CharUnits getMaxAtomicAccessSize(CodeGenModule &CGM, llvm::Triple::ArchType arch)
Return the maximum size that permits atomic accesses for the given architecture.
Definition: CGObjC.cpp:610
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type. ...
Definition: CGExprAgg.cpp:1401
ObjCMethodDecl * getDictWithObjectsMethod() const
Definition: ExprObjC.h:323
[ARC] Reclaim a retainable object pointer object that may have been produced and autoreleased as part...
Defines the Diagnostic-related interfaces.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:4836
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:5255
Represents a pointer to an Objective C object.
Definition: Type.h:4821
void EmitAutoVarCleanups(const AutoVarEmission &emission)
Definition: CGDecl.cpp:1370
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2220
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:2565
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:3544
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:248
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5675
QualType getCanonicalType() const
Definition: Type.h:5128
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:208
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:1914
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:2568
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
[ARC] Produces a retainable object pointer so that it may be consumed, e.g.
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:3732
llvm::Constant * objc_retainAutorelease
id objc_retainAutorelease(id);
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
Definition: CGDecl.cpp:658
llvm::Value * EmitIvarOffset(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
Definition: CGExpr.cpp:3727
llvm::Value * EmitARCRetainAutorelease(QualType type, llvm::Value *value)
Do a fused retain/autorelease of the given object.
Definition: CGObjC.cpp:2174
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:367
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:2226
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:984
ObjCPropertyDecl * getPropertyDecl() const
Definition: DeclObjC.h:2662
Reading or writing from this object requires a barrier call.
Definition: Type.h:147
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:1180
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5169
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:940
llvm::Type * ConvertType(QualType T)
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1609
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:944
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:1415
llvm::Value * EmitARCRetainBlock(llvm::Value *value, bool mandatory)
Retain the given block, with _Block_copy semantics.
Definition: CGObjC.cpp:1960
void generateObjCGetterBody(const ObjCImplementationDecl *classImpl, const ObjCPropertyImplDecl *propImpl, const ObjCMethodDecl *GetterMothodDecl, llvm::Constant *AtomicHelperFn)
Definition: CGObjC.cpp:867
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:2134
Expr * getRHS() const
Definition: Expr.h:2923
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:618
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:772
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:2385
CK_NoOp - A conversion which does not affect the type other than (possibly) adding qualifiers...
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:922
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 llvm::Value * emitARCRetainCall(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:2454
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
const CGFunctionInfo & arrangeFreeFunctionCall(const CallArgList &Args, const FunctionType *Ty, bool ChainCall)
Figure out the rules for calling a function with the given formal type using the given arguments...
Definition: CGCall.cpp:444
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
Definition: CGStmt.cpp:306
llvm::Value * LoadObjCSelf()
LoadObjCSelf - Load the value of self.
Definition: CGObjC.cpp:1443
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:106
CodeGenTypes & getTypes() const
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:384
void EmitObjCAtTryStmt(const ObjCAtTryStmt &S)
Definition: CGObjC.cpp:1749
LValue - This represents an lvalue references.
Definition: CGValue.h:152
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:144
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1487
llvm::Value * EmitObjCConsumeObject(QualType T, llvm::Value *Ptr)
Produce the code for a CK_ARCConsumeObject.
Definition: CGObjC.cpp:1776
CanQualType BoolTy
Definition: ASTContext.h:882
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:1857
llvm::PointerIntPair< llvm::Value *, 1, bool > TryEmitResult
Definition: CGObjC.cpp:31
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5148
The receiver is a superclass.
Definition: ExprObjC.h:1007
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1499
llvm::Constant * objc_retainAutoreleaseReturnValue
id objc_retainAutoreleaseReturnValue(id);
void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S)
Definition: CGObjC.cpp:2851
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:56
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
Definition: CGCleanup.cpp:586
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...
A class which abstracts out some details necessary for making a call.
Definition: Type.h:2872
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:5631
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:891
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2433
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:1372
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:1293