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