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;
42 return llvm::ConstantPointerNull::get(cast<llvm::PointerType>(type));
65 assert(BoxingMethod &&
"BoxingMethod is null");
66 assert(BoxingMethod->
isClassMethod() &&
"BoxingMethod must be a class method");
83 if (ValueType->isObjCBoxableRecordType()) {
108 Args, ClassDecl, BoxingMethod);
119 DLE = cast<ObjCDictionaryLiteral>(
E);
122 uint64_t NumElements =
140 bool TrackNeededObjects =
145 for (uint64_t i = 0; i < NumElements; i++) {
155 if (TrackNeededObjects) {
156 NeededObjects.push_back(value);
174 if (TrackNeededObjects) {
175 NeededObjects.push_back(keyValue);
176 NeededObjects.push_back(valueValue);
211 Receiver, Args, Class, MethodWithObjects);
217 if (TrackNeededObjects) {
278 if (
auto opaque = dyn_cast<OpaqueValueExpr>(receiver)) {
279 if (opaque->getSourceExpr())
284 if (!ice || ice->
getCastKind() != CK_LValueToRValue)
return true;
288 if (
auto opaque = dyn_cast<OpaqueValueExpr>(receiver)) {
289 if (opaque->getSourceExpr())
298 if (isa<MemberExpr>(receiver) || isa<ObjCIvarRefExpr>(receiver))
303 if (!declRef)
return true;
305 if (!var)
return true;
310 !var->hasAttr<ObjCPreciseLifetimeAttr>());
323 llvm_unreachable(
"invalid receiver kind");
331 if (
auto CE = dyn_cast<CastExpr>(E)) {
332 if (CE->getCastKind() == CK_LValueToRValue) {
334 return CE->getSubExpr();
370 method->hasAttr<NSConsumesSelfAttr>());
373 bool isSuperMessage =
false;
374 bool isClassMessage =
false;
385 Receiver = ter.getPointer();
386 if (ter.getInt()) retainSelf =
false;
394 assert(ObjTy &&
"Invalid Objective-C class message send");
396 assert(OID &&
"Invalid Objective-C class message send");
397 Receiver = Runtime.
GetClass(*
this, OID);
398 isClassMessage =
true;
405 isSuperMessage =
true;
411 isSuperMessage =
true;
412 isClassMessage =
true;
423 method->hasAttr<ObjCReturnsInnerPointerAttr>() &&
439 if (isDelegateInit) {
441 "delegate init calls should only be marked in ARC");
450 if (isSuperMessage) {
453 bool isCategoryImpl = isa<ObjCCategoryImplDecl>(OMD->getDeclContext());
471 if (isDelegateInit) {
492 const ObjCImplDecl *impl = cast<ObjCImplDecl>(method->getDeclContext());
494 if (!iface->getSuperClass())
return;
496 bool isCategory = isa<ObjCCategoryImplDecl>(impl);
523 if (OMD->hasAttr<NoDebugAttr>())
540 OMD->getLocation(), StartLoc);
548 if (ident->
isStr(
"dealloc"))
561 assert(isa<CompoundStmt>(OMD->
getBody()));
570 bool isAtomic,
bool hasStrong) {
609 llvm::Triple::ArchType arch) {
619 class PropertyImplStrategy {
631 SetPropertyAndExpressionGet,
641 StrategyKind
getKind()
const {
return StrategyKind(
Kind); }
643 bool hasStrongMember()
const {
return HasStrong; }
644 bool isAtomic()
const {
return IsAtomic; }
645 bool isCopy()
const {
return IsCopy; }
647 CharUnits getIvarSize()
const {
return IvarSize; }
648 CharUnits getIvarAlignment()
const {
return IvarAlignment; }
655 unsigned IsAtomic : 1;
657 unsigned HasStrong : 1;
665 PropertyImplStrategy::PropertyImplStrategy(
CodeGenModule &CGM,
677 std::tie(IvarSize, IvarAlignment) =
683 Kind = GetSetProperty;
696 }
else if (CGM.
getLangOpts().ObjCAutoRefCount && !IsAtomic) {
706 Kind = SetPropertyAndExpressionGet;
712 }
else if (!IsAtomic) {
713 Kind = SetPropertyAndExpressionGet;
718 Kind = GetSetProperty;
749 HasStrong = recordType->getDecl()->hasObjectMember();
764 if (!IvarSize.isPowerOfTwo()) {
769 llvm::Triple::ArchType arch =
797 llvm::Constant *AtomicHelperFn =
801 assert(OMD &&
"Invalid call to generate getter (empty method)");
811 if (!getter)
return true;
824 return (construct->getConstructor()->isTrivial());
828 assert(isa<ExprWithCleanups>(getter));
835 llvm::Value *returnAddr,
837 llvm::Constant *AtomicHelperFn) {
846 llvm::Value *ivarAddr =
855 llvm::Value *copyCppAtomicObjectFn =
866 llvm::Constant *AtomicHelperFn) {
869 if (!AtomicHelperFn) {
877 ivar, AtomicHelperFn);
889 PropertyImplStrategy strategy(CGM, propImpl);
890 switch (strategy.getKind()) {
891 case PropertyImplStrategy::Native: {
893 if (strategy.getIvarSize().isZero())
902 bitcastType = bitcastType->getPointerTo();
908 load->setAtomic(llvm::AtomicOrdering::Unordered);
914 uint64_t retTySize = CGM.
getDataLayout().getTypeSizeInBits(retTy);
915 llvm::Value *ivarVal = load;
916 if (ivarSize > retTySize) {
918 ivarVal =
Builder.CreateTrunc(load, newTy);
919 bitcastType = newTy->getPointerTo();
929 case PropertyImplStrategy::GetSetProperty: {
930 llvm::Value *getPropertyFn =
932 if (!getPropertyFn) {
943 llvm::Value *ivarOffset =
955 llvm::Instruction *CallInstruction;
957 getTypes().arrangeBuiltinFunctionCall(propType, args),
960 if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(CallInstruction))
970 EmitReturnOfRValue(RV, propType);
978 case PropertyImplStrategy::CopyStruct:
980 strategy.hasStrongMember());
983 case PropertyImplStrategy::Expression:
984 case PropertyImplStrategy::SetPropertyAndExpressionGet: {
1029 llvm_unreachable(
"bad evaluation kind");
1033 llvm_unreachable(
"bad @property implementation strategy!");
1083 llvm::Constant *AtomicHelperFn) {
1089 llvm::Value *ivarAddr =
1106 llvm::Value *copyCppAtomicObjectFn =
1116 if (!setter)
return true;
1126 if (
CallExpr *call = dyn_cast<CallExpr>(setter)) {
1128 = dyn_cast_or_null<FunctionDecl>(call->getCalleeDecl()))
1129 if (callee->isTrivial())
1134 assert(isa<ExprWithCleanups>(setter));
1147 llvm::Constant *AtomicHelperFn) {
1155 if (!AtomicHelperFn)
1165 PropertyImplStrategy strategy(CGM, propImpl);
1166 switch (strategy.getKind()) {
1167 case PropertyImplStrategy::Native: {
1169 if (strategy.getIvarSize().isZero())
1176 Address ivarAddr = ivarLValue.getAddress();
1182 getContext().toBits(strategy.getIvarSize()));
1193 store->setAtomic(llvm::AtomicOrdering::Unordered);
1197 case PropertyImplStrategy::GetSetProperty:
1198 case PropertyImplStrategy::SetPropertyAndExpressionGet: {
1200 llvm::Value *setOptimizedPropertyFn =
nullptr;
1201 llvm::Value *setPropertyFn =
nullptr;
1204 setOptimizedPropertyFn =
1208 if (!setOptimizedPropertyFn) {
1215 if (!setPropertyFn) {
1227 llvm::Value *ivarOffset =
1236 if (setOptimizedPropertyFn) {
1257 case PropertyImplStrategy::CopyStruct:
1261 case PropertyImplStrategy::Expression:
1270 selfDecl->
getType(), CK_LValueToRValue, &
self,
1274 &selfLoad,
true,
true);
1277 QualType argType = argDecl->getType().getNonReferenceType();
1287 if (ivarRef.getType()->isObjCObjectPointerType()) {
1288 if (argLoad.getType()->isObjCObjectPointerType())
1290 else if (argLoad.getType()->isBlockPointerType())
1291 argCK = CK_BlockPointerToObjCPointerCast;
1293 argCK = CK_CPointerToObjCPointerCast;
1294 }
else if (ivarRef.getType()->isBlockPointerType()) {
1295 if (argLoad.getType()->isBlockPointerType())
1298 argCK = CK_AnyPointerToBlockPointerCast;
1299 }
else if (ivarRef.getType()->isPointerType()) {
1303 ivarRef.getType(), argCK, &argLoad,
1305 Expr *finalArg = &argLoad;
1308 finalArg = &argCast;
1323 llvm::Constant *AtomicHelperFn =
1327 assert(OMD &&
"Invalid call to generate setter (empty method)");
1341 bool useEHCleanupForArray;
1343 DestroyIvar(llvm::Value *addr,
const ObjCIvarDecl *ivar,
1345 bool useEHCleanupForArray)
1346 : addr(addr), ivar(ivar), destroyer(destroyer),
1347 useEHCleanupForArray(useEHCleanupForArray) {}
1353 flags.isForNormalCleanup() && useEHCleanupForArray);
1379 if (!dtorKind)
continue;
1395 CGF.
EHStack.pushCleanup<DestroyIvar>(cleanupKind,
self, ivar, destroyer,
1413 for (
const auto *IvarInit : IMP->
inits()) {
1414 FieldDecl *Field = IvarInit->getAnyMember();
1426 llvm::Value *SelfAsId =
1453 llvm::Constant *EnumerationMutationFn =
1456 if (!EnumerationMutationFn) {
1478 static const unsigned NumItems = 16;
1491 llvm::APInt(32, NumItems),
1498 llvm::Value *Collection;
1529 llvm::Constant *
Count = llvm::ConstantInt::get(UnsignedLongLTy, NumItems);
1540 llvm::Value *initialBufferLimit = CountRV.
getScalarVal();
1545 llvm::Value *zero = llvm::Constant::getNullValue(UnsignedLongLTy);
1552 Builder.CreateICmpEQ(initialBufferLimit, zero,
"iszero"), EmptyBB,
1564 llvm::Value *StateMutationsPtr
1567 llvm::Value *initialMutations =
1569 "forcoll.initial-mutations");
1577 llvm::PHINode *index =
Builder.CreatePHI(UnsignedLongLTy, 3,
"forcoll.index");
1578 index->addIncoming(zero, LoopInitBB);
1581 llvm::PHINode *count =
Builder.CreatePHI(UnsignedLongLTy, 3,
"forcoll.count");
1582 count->addIncoming(initialBufferLimit, LoopInitBB);
1590 llvm::Value *currentMutations
1595 llvm::BasicBlock *WasNotMutatedBB =
createBasicBlock(
"forcoll.notmutated");
1597 Builder.CreateCondBr(
Builder.CreateICmpEQ(currentMutations, initialMutations),
1598 WasNotMutatedBB, WasMutatedBB);
1618 bool elementIsVariable;
1625 const VarDecl* D = cast<VarDecl>(SD->getSingleDecl());
1630 elementIsVariable =
true;
1635 elementLValue =
LValue();
1636 elementType = cast<Expr>(S.
getElement())->getType();
1637 elementIsVariable =
false;
1646 llvm::Value *EnumStateItems =
1650 llvm::Value *CurrentItemPtr =
1651 Builder.CreateGEP(EnumStateItems, index,
"currentitem.ptr");
1652 llvm::Value *CurrentItem =
1661 if (!elementIsVariable) {
1670 if (elementIsVariable)
1674 BreakContinueStack.push_back(BreakContinue(LoopEnd, AfterBody));
1679 BreakContinueStack.pop_back();
1690 llvm::Value *indexPlusOne
1691 =
Builder.CreateAdd(index, llvm::ConstantInt::get(UnsignedLongLTy, 1));
1698 Builder.CreateICmpULT(indexPlusOne, count), LoopBodyBB, FetchMoreBB,
1701 index->addIncoming(indexPlusOne, AfterBody.
getBlock());
1702 count->addIncoming(count, AfterBody.
getBlock());
1717 index->addIncoming(zero,
Builder.GetInsertBlock());
1718 count->addIncoming(refetchCount,
Builder.GetInsertBlock());
1721 EmptyBB, LoopBodyBB);
1726 if (!elementIsVariable) {
1729 llvm::Value *null = llvm::Constant::getNullValue(convertedElementType);
1756 CallObjCRelease(llvm::Value *
object) : object(object) {}
1757 llvm::Value *object;
1769 llvm::Value *
object) {
1777 llvm::Value *value) {
1786 llvm::FunctionType *fnType =
1787 llvm::FunctionType::get(CGM.
VoidTy,
None,
true);
1798 llvm::FunctionType *
type,
1802 if (llvm::Function *f = dyn_cast<llvm::Function>(fn)) {
1807 f->setLinkage(llvm::Function::ExternalWeakLinkage);
1808 }
else if (fnName ==
"objc_retain" || fnName ==
"objc_release") {
1811 f->addFnAttr(llvm::Attribute::NonLazyBind);
1823 llvm::Constant *&fn,
1825 bool isTailCall =
false) {
1826 if (isa<llvm::ConstantPointerNull>(value))
return value;
1829 llvm::FunctionType *fnType =
1841 call->setTailCall();
1851 llvm::Constant *&fn,
1854 llvm::FunctionType *fnType =
1878 llvm::Constant *&fn,
1886 llvm::FunctionType *fnType
1887 = llvm::FunctionType::get(CGF.
Int8PtrTy, argTypes,
false);
1893 llvm::Value *args[] = {
1899 if (ignored)
return nullptr;
1909 llvm::Constant *&fn,
1916 llvm::FunctionType *fnType
1917 = llvm::FunctionType::get(CGF.
Builder.getVoidTy(), argTypes,
false);
1921 llvm::Value *args[] = {
1957 "objc_retainBlock");
1963 if (!mandatory && isa<llvm::Instruction>(result)) {
1964 llvm::CallInst *call
1965 = cast<llvm::CallInst>(result->stripPointerCasts());
1968 call->setMetadata(
"clang.arc.copy_on_escape",
1978 llvm::InlineAsm *&marker
1986 if (assembly.empty()) {
1991 llvm::FunctionType *
type =
1992 llvm::FunctionType::get(CGF.
VoidTy,
false);
1994 marker = llvm::InlineAsm::get(type, assembly,
"",
true);
2000 llvm::NamedMDNode *metadata =
2002 "clang.arc.retainAutoreleasedReturnValueMarker");
2003 assert(metadata->getNumOperands() <= 1);
2004 if (metadata->getNumOperands() == 0) {
2006 metadata->addOperand(llvm::MDNode::get(ctx,
2007 llvm::MDString::get(ctx, assembly)));
2014 CGF.
Builder.CreateCall(marker);
2027 "objc_retainAutoreleasedReturnValue");
2042 "objc_unsafeClaimAutoreleasedReturnValue");
2049 if (isa<llvm::ConstantPointerNull>(value))
return;
2053 llvm::FunctionType *fnType =
2065 call->setMetadata(
"clang.imprecise_release",
2101 llvm::FunctionType *fnType
2102 = llvm::FunctionType::get(
Builder.getVoidTy(), argTypes,
false);
2106 llvm::Value *args[] = {
2112 if (ignored)
return nullptr;
2120 llvm::Value *newValue,
2157 "objc_autorelease");
2166 "objc_autoreleaseReturnValue",
2176 "objc_retainAutoreleaseReturnValue",
2186 llvm::Value *value) {
2190 if (isa<llvm::ConstantPointerNull>(value))
return value;
2205 "objc_retainAutorelease");
2220 "objc_loadWeakRetained");
2230 "objc_storeWeak", ignored);
2242 if (isa<llvm::ConstantPointerNull>(value) &&
2250 "objc_initWeak",
true);
2258 llvm::FunctionType *fnType =
2292 llvm::FunctionType *fnType =
2293 llvm::FunctionType::get(
Int8PtrTy,
false);
2307 llvm::FunctionType *fnType =
2334 AllocSel, Receiver, Args);
2343 InitSel, Receiver, Args);
2379 CallObjCAutoreleasePoolObject(llvm::Value *token) :
Token(token) {}
2388 CallObjCMRRAutoreleasePoolObject(llvm::Value *token) :
Token(token) {}
2420 llvm_unreachable(
"impossible lifetime!");
2453 isa<BinaryOperator>(e) &&
2454 cast<BinaryOperator>(e)->getOpcode() == BO_Assign)
2461 llvm::Value *value)>
2469 if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(value)) {
2470 CGBuilderTy::InsertPoint ip = CGF.
Builder.saveIP();
2473 CGF.
Builder.SetInsertPoint(call->getParent(),
2475 value = doAfterCall(CGF, value);
2479 }
else if (llvm::InvokeInst *invoke = dyn_cast<llvm::InvokeInst>(value)) {
2480 CGBuilderTy::InsertPoint ip = CGF.
Builder.saveIP();
2483 llvm::BasicBlock *BB = invoke->getNormalDest();
2484 CGF.
Builder.SetInsertPoint(BB, BB->begin());
2485 value = doAfterCall(CGF, value);
2492 }
else if (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(value)) {
2493 llvm::Value *operand = bitcast->getOperand(0);
2495 bitcast->setOperand(0, operand);
2502 return doFallback(CGF, value);
2535 bool allowUnsafeClaim) {
2536 if (allowUnsafeClaim &&
2554 if (isa<BlockExpr>(e))
2558 switch (
cast->getCastKind()) {
2560 case CK_LValueToRValue:
2561 case CK_ARCReclaimReturnedObject:
2562 case CK_ARCConsumeObject:
2563 case CK_ARCProduceObject:
2572 case CK_AnyPointerToBlockPointerCast:
2584 template <
typename Impl,
typename Result>
class ARCExprEmitter {
2587 Impl &asImpl() {
return *
static_cast<Impl*
>(
this); }
2618 template <
typename Impl,
typename Result>
2630 const Expr *semantic = *i;
2634 if (
const OpaqueValueExpr *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
2640 if (ov == resultExpr) {
2641 assert(!OVMA::shouldBindAsLValue(ov));
2642 result = asImpl().visit(ov->getSourceExpr());
2643 opaqueData = OVMA::bind(CGF, ov,
2648 opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
2650 opaques.push_back(opaqueData);
2654 }
else if (semantic == resultExpr) {
2655 result = asImpl().visit(semantic);
2659 CGF.EmitIgnoredExpr(semantic);
2664 for (
unsigned i = 0, e = opaques.size(); i != e; ++i)
2665 opaques[i].unbind(CGF);
2670 template <
typename Impl,
typename Result>
2671 Result ARCExprEmitter<Impl,Result>::visitCastExpr(
const CastExpr *e) {
2679 case CK_CPointerToObjCPointerCast:
2680 case CK_BlockPointerToObjCPointerCast:
2681 case CK_AnyPointerToBlockPointerCast:
2686 return asImpl().emitBitCast(result, resultType);
2690 case CK_LValueToRValue:
2691 return asImpl().visitLValueToRValue(e->
getSubExpr());
2692 case CK_ARCConsumeObject:
2693 return asImpl().visitConsumeObject(e->
getSubExpr());
2694 case CK_ARCExtendBlockObject:
2695 return asImpl().visitExtendBlockObject(e->
getSubExpr());
2696 case CK_ARCReclaimReturnedObject:
2697 return asImpl().visitReclaimReturnedObject(e->
getSubExpr());
2701 return asImpl().visitExpr(e);
2705 template <
typename Impl,
typename Result>
2707 ARCExprEmitter<Impl,Result>::visitBinaryOperator(
const BinaryOperator *e) {
2710 CGF.EmitIgnoredExpr(e->
getLHS());
2711 CGF.EnsureInsertPoint();
2712 return asImpl().visit(e->
getRHS());
2715 return asImpl().visitBinAssign(e);
2718 return asImpl().visitExpr(e);
2722 template <
typename Impl,
typename Result>
2726 return asImpl().visitBinAssignUnsafeUnretained(e);
2729 return asImpl().visitBinAssignWeak(e);
2732 return asImpl().visitBinAssignAutoreleasing(e);
2735 return asImpl().visitBinAssignStrong(e);
2738 return asImpl().visitExpr(e);
2740 llvm_unreachable(
"bad ObjC ownership qualifier");
2745 template <
typename Impl,
typename Result>
2746 Result ARCExprEmitter<Impl,Result>::
2755 CGF.EmitStoreThroughLValue(
RValue::get(asImpl().getValueOfResult(result)),
2761 template <
typename Impl,
typename Result>
2763 ARCExprEmitter<Impl,Result>::visitBinAssignAutoreleasing(
const BinaryOperator *e) {
2764 return asImpl().visitExpr(e);
2767 template <
typename Impl,
typename Result>
2769 ARCExprEmitter<Impl,Result>::visitBinAssignWeak(
const BinaryOperator *e) {
2770 return asImpl().visitExpr(e);
2773 template <
typename Impl,
typename Result>
2775 ARCExprEmitter<Impl,Result>::visitBinAssignStrong(
const BinaryOperator *e) {
2776 return asImpl().visitExpr(e);
2780 template <
typename Impl,
typename Result>
2781 Result ARCExprEmitter<Impl,Result>::visit(
const Expr *e) {
2786 assert(!isa<ExprWithCleanups>(e));
2792 if (
const CastExpr *ce = dyn_cast<CastExpr>(e)) {
2793 return asImpl().visitCastExpr(ce);
2796 }
else if (
auto op = dyn_cast<BinaryOperator>(e)) {
2797 return asImpl().visitBinaryOperator(op);
2805 }
else if (isa<CallExpr>(e) ||
2806 (isa<ObjCMessageExpr>(e) &&
2807 !cast<ObjCMessageExpr>(e)->isDelegateInitCall())) {
2808 return asImpl().visitCall(e);
2811 }
else if (
const PseudoObjectExpr *pseudo = dyn_cast<PseudoObjectExpr>(e)) {
2812 return asImpl().visitPseudoObjectExpr(pseudo);
2815 return asImpl().visitExpr(e);
2821 struct ARCRetainExprEmitter :
2822 public ARCExprEmitter<ARCRetainExprEmitter, TryEmitResult> {
2827 return result.getPointer();
2831 llvm::Value *value = result.getPointer();
2832 value = CGF.Builder.CreateBitCast(value, resultType);
2833 result.setPointer(value);
2844 llvm::Value *result = CGF.EmitScalarExpr(e);
2852 llvm::Value *result;
2857 result = CGF.EmitScalarExpr(e);
2864 if (subresult.getInt()) {
2869 result = subresult.getPointer();
2873 result = CGF.EmitARCRetainBlock(result,
true);
2895 llvm::Value *result = CGF.EmitScalarExpr(e);
2903 return ARCRetainExprEmitter(CGF).visit(e);
2910 llvm::Value *value = result.getPointer();
2911 if (!result.getInt())
2929 llvm::Value *value = result.getPointer();
2930 if (!result.getInt())
2945 llvm::Value *value = result.getPointer();
2946 if (result.getInt())
2954 llvm::Value *result;
2962 result = subresult.getPointer();
2963 doRetain = !subresult.getInt();
2990 struct ARCUnsafeUnretainedExprEmitter :
2991 public ARCExprEmitter<ARCUnsafeUnretainedExprEmitter, llvm::Value*> {
2993 ARCUnsafeUnretainedExprEmitter(
CodeGenFunction &CGF) : ARCExprEmitter(CGF) {}
2995 llvm::Value *getValueOfResult(llvm::Value *value) {
2999 llvm::Value *emitBitCast(llvm::Value *value,
llvm::Type *resultType) {
3000 return CGF.Builder.CreateBitCast(value, resultType);
3003 llvm::Value *visitLValueToRValue(
const Expr *e) {
3004 return CGF.EmitScalarExpr(e);
3009 llvm::Value *visitConsumeObject(
const Expr *e) {
3010 llvm::Value *value = CGF.EmitScalarExpr(e);
3011 return CGF.EmitObjCConsumeObject(e->
getType(), value);
3016 llvm::Value *visitExtendBlockObject(
const Expr *e) {
3017 return CGF.EmitARCExtendBlockObject(e);
3021 llvm::Value *visitReclaimReturnedObject(
const Expr *e) {
3022 return CGF.EmitARCReclaimReturnedObject(e,
true);
3027 llvm::Value *visitCall(
const Expr *e) {
3028 return CGF.EmitScalarExpr(e);
3032 llvm::Value *visitExpr(
const Expr *e) {
3033 return CGF.EmitScalarExpr(e);
3040 return ARCUnsafeUnretainedExprEmitter(CGF).visit(e);
3058 std::pair<LValue,llvm::Value*>
3074 return std::pair<LValue,llvm::Value*>(std::move(lvalue), value);
3077 std::pair<LValue,llvm::Value*>
3082 llvm::Value *value = result.getPointer();
3084 bool hasImmediateRetain = result.getInt();
3091 hasImmediateRetain =
true;
3097 if (hasImmediateRetain) {
3105 return std::pair<LValue,llvm::Value*>(lvalue, value);
3108 std::pair<LValue,llvm::Value*>
3115 return std::pair<LValue,llvm::Value*>(lvalue, value);
3137 for (
const auto *
I : S.
body())
3148 llvm::FunctionType *extenderType
3150 llvm::Value *extender
3151 = llvm::InlineAsm::get(extenderType,
3176 llvm::Constant *HelperFn =
nullptr;
3201 args.push_back(&dstDecl);
3203 args.push_back(&srcDecl);
3210 llvm::Function *Fn =
3212 "__assign_helper_atomic_property_",
3221 UnaryOperator DST(&DstExpr, UO_Deref, DestTy->getPointeeType(),
3229 Expr *Args[2] = { &DST, &SRC };
3232 Args, DestTy->getPointeeType(),
3238 HelperFn = llvm::ConstantExpr::getBitCast(Fn,
VoidPtrTy);
3255 llvm::Constant *HelperFn =
nullptr;
3282 args.push_back(&dstDecl);
3284 args.push_back(&srcDecl);
3291 llvm::Function *Fn =
3293 "__copy_helper_atomic_property_", &CGM.
getModule());
3309 ConstructorArgs.push_back(&SRC);
3310 ConstructorArgs.append(std::next(CXXConstExpr->arg_begin()),
3311 CXXConstExpr->arg_end());
3315 CXXConstExpr->getConstructor(),
3316 CXXConstExpr->isElidable(),
3318 CXXConstExpr->hadMultipleCandidates(),
3319 CXXConstExpr->isListInitialization(),
3320 CXXConstExpr->isStdInitListInitialization(),
3321 CXXConstExpr->requiresZeroInitialization(),
3322 CXXConstExpr->getConstructionKind(),
3339 HelperFn = llvm::ConstantExpr::getBitCast(Fn,
VoidPtrTy);
3356 llvm::Value *Val = Block;
3363 Ty, AutoreleaseSelector,
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
llvm::PointerType * Int8PtrPtrTy
A call to an overloaded operator written using operator syntax.
The receiver is the instance of the superclass object.
param_const_iterator param_begin() const
ReturnValueSlot - Contains the address where the return value of a function can be stored...
static bool UseOptimizedSetter(CodeGenModule &CGM)
Defines the clang::ASTContext interface.
bool isAtomic() const
isAtomic - Return true if the property is atomic.
CastKind getCastKind() const
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)
Store into a strong object.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
The receiver is an object instance.
llvm::Value * EmitARCReclaimReturnedObject(const Expr *e, bool allowUnsafeClaim)
void EmitCallArgs(CallArgList &Args, const T *CallArgTypeInfo, llvm::iterator_range< CallExpr::const_arg_iterator > ArgRange, const FunctionDecl *CalleeDecl=nullptr, unsigned ParamsToSkip=0)
EmitCallArgs - Emit call arguments for a function.
static llvm::Value * emitARCRetainCallResult(CodeGenFunction &CGF, const Expr *e)
Given that the given expression is some sort of call (which does not return retained), emit a retain following it.
Smart pointer class that efficiently represents Objective-C method names.
llvm::Value * EmitARCRetainAutoreleaseScalarExpr(const Expr *expr)
static bool hasTrivialGetExpr(const ObjCPropertyImplDecl *propImpl)
ObjCEntrypoints & getObjCEntrypoints() const
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
A (possibly-)qualified type.
static bool hasUnalignedAtomics(llvm::Triple::ArchType arch)
Determine whether the given architecture supports unaligned atomic accesses.
void EmitExtendGCLifetime(llvm::Value *object)
EmitExtendGCLifetime - Given a pointer to an Objective-C object, make sure it survives garbage collec...
llvm::Value * getPointer() const
CodeGenTypes & getTypes()
llvm::Value * EmitARCExtendBlockObject(const Expr *expr)
ObjCInterfaceDecl * getClassInterface()
bool isBitField() const
Determines whether this field is a bitfield.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
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.
bool isDelegateInitCall() const
isDelegateInitCall - Answers whether this message send has been tagged as a "delegate init call"...
static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
void EmitARCDestroyWeak(Address addr)
void @objc_destroyWeak(i8** addr) Essentially objc_storeWeak(addr, nil).
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.
void addConst()
Add the const type qualifier to this QualType.
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...
bool isRecordType() const
llvm::Constant * objc_autoreleaseReturnValue
id objc_autoreleaseReturnValue(id);
Address getAddress() const
bool hasARCUnsafeClaimAutoreleasedReturnValue() const
Is objc_unsafeClaimAutoreleasedReturnValue available?
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.
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
void GenerateObjCSetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCSetter - Synthesize an Objective-C property setter function for the given property...
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Represents a call to a C++ constructor.
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.
llvm::Value * EmitObjCMRRAutoreleasePoolPush()
Produce the code to do an MRR version objc_autoreleasepool_push.
llvm::Constant * GenerateObjCAtomicSetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
GenerateObjCAtomicSetterCopyHelperFunction - Given a c++ object type with non-trivial copy assignment...
const LangOptions & getLangOpts() const
bool isBlockPointerType() const
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
static llvm::Value * emitARCRetainLoadOfScalar(CodeGenFunction &CGF, LValue lvalue, QualType type)
void createImplicitParams(ASTContext &Context, const ObjCInterfaceDecl *ID)
createImplicitParams - Used to lazily create the self and cmd implict parameters. ...
llvm::function_ref< llvm::Value *(CodeGenFunction &CGF, llvm::Value *value)> ValueTransform
static Destroyer destroyARCWeak
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)
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
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...
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Expr * getSetterCXXAssignment() const
const Expr * getCallee() const
ObjCLifetime getObjCLifetime() const
SourceLocation getLocStart() const LLVM_READONLY
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.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
ObjCMethodDecl - Represents an instance or class method declaration.
llvm::Value * EmitBlockCopyAndAutorelease(llvm::Value *Block, QualType Ty)
bool shouldUseFusedARCCalls()
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...
ParmVarDecl - Represents a parameter to a function.
bool isObjCRetainableType() const
llvm::Value * EmitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E)
The collection of all-type qualifiers we support.
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
llvm::Value * EmitObjCThrowOperand(const Expr *expr)
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.
ObjCProtocolDecl * getProtocol() const
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...
Represents a class type in Objective C.
CGDebugInfo * getDebugInfo()
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 ...
std::pair< LValue, llvm::Value * > EmitARCStoreAutoreleasing(const BinaryOperator *e)
llvm::Constant * objc_retainAutoreleasedReturnValue
id objc_retainAutoreleasedReturnValue(id);
llvm::Value * EmitObjCExtendObjectLifetime(QualType T, llvm::Value *Ptr)
bool isReferenceType() const
llvm::Value * EmitARCRetainAutoreleaseReturnValue(llvm::Value *value)
Do a fused retain/autorelease of the given object.
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
ImplicitParamDecl * getCmdDecl() const
StringLiteral * getString()
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Token - This structure provides full information about a lexed token.
llvm::Value * EmitARCAutoreleaseReturnValue(llvm::Value *value)
Autorelease the given object.
void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, ObjCMethodDecl *MD, bool ctor)
SourceLocation getLBracLoc() const
RValue EmitCall(const CGFunctionInfo &FnInfo, llvm::Value *Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, CGCalleeInfo CalleeInfo=CGCalleeInfo(), llvm::Instruction **callOrInvoke=nullptr)
EmitCall - Generate a call of the given function, expecting the given result type, and using the given argument list which specifies both the LLVM arguments and the types they were derived from.
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]];.
llvm::Value * EmitObjCBoxedExpr(const ObjCBoxedExpr *E)
EmitObjCBoxedExpr - This routine generates code to call the appropriate expression boxing method...
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)
EmitLoadOfComplex - Load a complex number from the specified l-value.
const Expr *const * const_semantics_iterator
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.
llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)
Store into a strong object.
llvm::Constant * objc_initWeak
id objc_initWeak(id*, id);
bool hasOptimizedSetter() const
Does this runtime supports optimized setter entrypoints?
llvm::Value * EmitObjCStringLiteral(const ObjCStringLiteral *E)
Emits an instance of NSConstantString representing the object.
Selector getNullarySelector(IdentifierInfo *ID)
ObjCMethodDecl * getBoxingMethod() const
CharUnits getAlignment() const
ObjCContainerDecl - Represents a container for method declarations.
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...
CharUnits - This is an opaque type for sizes expressed in character units.
void EmitARCDestroyStrong(Address addr, ARCPreciseLifetime_t precise)
Destroy a __strong variable.
const Qualifiers & getQuals() const
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.
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
QualType getSuperType() const
Retrieve the type referred to by 'super'.
llvm::PointerType * VoidPtrTy
semantics_iterator semantics_end()
llvm::Constant * objc_release
void objc_release(id);
A builtin binary operation expression such as "x + y" or "x <= y".
Selector getSelector() const
Expr * getGetterCXXConstructor() const
llvm::Value * EmitARCUnsafeUnretainedScalarExpr(const Expr *expr)
EmitARCUnsafeUnretainedScalarExpr - Semantically equivalent to immediately releasing the resut of Emi...
CharUnits getPointerSize() const
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
void setAtomicGetterHelperFnMap(QualType Ty, llvm::Constant *Fn)
llvm::Value * EmitARCLoadWeak(Address addr)
i8* @objc_loadWeak(i8** addr) Essentially objc_autorelease(objc_loadWeakRetained(addr)).
ObjCStringLiteral, used for Objective-C string literals i.e.
Scope - A scope is a transient data structure that is used while parsing the program.
void incrementProfileCounter(const Stmt *S)
Increment the profiler's counter for the given statement.
void EmitStmt(const Stmt *S)
EmitStmt - Emit the code for the statement.
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.
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...
Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...
void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn)
Assign counters to regions and configure them for PGO of a given function.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
bool requiresCleanups() const
Determine whether this scope requires any cleanups.
Expr * Key
The key for the dictionary element.
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.
uint64_t getCurrentProfileCount()
Get the profiler's current count.
Represents an ObjC class declaration.
SourceLocation getLocEnd() const LLVM_READONLY
detail::InMemoryDirectory::const_iterator I
PropertyAttributeKind getPropertyAttributes() const
static TryEmitResult tryEmitARCRetainScalarExpr(CodeGenFunction &CGF, const Expr *e)
std::pair< CharUnits, CharUnits > getTypeInfoInChars(const Type *T) const
llvm::Value * EmitARCRetainAutoreleasedReturnValue(llvm::Value *value)
Retain the given object which is the result of a function call.
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)
llvm::Value * EmitARCRetainAutoreleaseNonBlock(llvm::Value *value)
Do a fused retain/autorelease of the given object.
This object can be modified without requiring retains or releases.
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
llvm::CallSite EmitRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef< llvm::Value * > args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource AlignSource=AlignmentSource::Type)
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
const ParmVarDecl *const * param_const_iterator
CompoundStmt - This represents a group of statements like { stmt stmt }.
AutoVarEmission EmitAutoVarAlloca(const VarDecl &var)
EmitAutoVarAlloca - Emit the alloca and debug information for a local variable.
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.
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...
llvm::Constant * objc_storeStrong
id objc_storeStrong(id*, id);
const TargetInfo & getTarget() const
CastKind
CastKind - The kind of operation required for a conversion.
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
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.
static AutoVarEmission invalid()
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
bool isUnarySelector() const
llvm::Value * EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored)
i8* @objc_storeWeak(i8** addr, i8* value) Returns value.
const ObjCMethodDecl * getMethodDecl() const
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.
llvm::Value * getPointer() const
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Expr - This represents one expression.
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.
virtual llvm::Constant * GetSetStructFunction()=0
void EmitAutoVarInit(const AutoVarEmission &emission)
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.
void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource AlignSource=AlignmentSource::Type, llvm::MDNode *TBAAInfo=nullptr, bool isInit=false, QualType TBAABaseTy=QualType(), uint64_t TBAAOffset=0, bool isNontemporal=false)
EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
Generate an Objective-C method.
ObjCIvarDecl * getPropertyIvarDecl() const
static void emitStructSetterCall(CodeGenFunction &CGF, ObjCMethodDecl *OMD, ObjCIvarDecl *ivar)
emitStructSetterCall - Call the runtime function to store the value from the first formal parameter i...
void SetInternalFunctionAttributes(const Decl *D, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, bool ClearInsertionPoint=true)=0
TranslationUnitDecl * getTranslationUnitDecl() const
llvm::Constant * objc_retain
id objc_retain(id);
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
ASTContext & getContext() const
llvm::BasicBlock * getBlock() const
Represents Objective-C's @synchronized statement.
ObjCSelectorExpr used for @selector in Objective-C.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
void generateObjCSetterBody(const ObjCImplementationDecl *classImpl, const ObjCPropertyImplDecl *propImpl, llvm::Constant *AtomicHelperFn)
ImplicitParamDecl * getSelfDecl() const
void add(RValue rvalue, QualType type, bool needscopy=false)
virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtTryStmt &S)=0
llvm::Value * EmitARCAutorelease(llvm::Value *value)
Autorelease the given object.
Selector getSelector() const
llvm::LLVMContext & getLLVMContext()
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
const CGFunctionInfo & arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args)
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.
bool isInstanceMethod() const
clang::ObjCRuntime ObjCRuntime
virtual llvm::Constant * GetPropertyGetFunction()=0
Return the runtime function for getting properties.
QualType getObjCIdType() const
Represents the Objective-CC id type.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
An expression that sends a message to the given Objective-C object or class.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
The result type of a method or function.
ARCPreciseLifetime_t isARCPreciseLifetime() const
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.
GlobalDecl - represents a global declaration.
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*)
param_const_iterator param_end() const
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
ArrayRef< ParmVarDecl * > parameters() const
llvm::Constant * objc_retainBlock
id objc_retainBlock(id);
There is no lifetime qualification on this type.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
SelectorTable & Selectors
llvm::Constant * CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeSet ExtraAttrs=llvm::AttributeSet())
Create a new runtime function with the specified type and name.
Assigning into this object requires the old value to be released and the new value to be retained...
llvm::Constant * objc_storeWeak
id objc_storeWeak(id*, id);
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
static llvm::Value * emitARCUnsafeUnretainedScalarExpr(CodeGenFunction &CGF, const Expr *e)
ASTContext & getContext() const
Encodes a location in the source.
CharUnits getPointerAlign() const
llvm::Value * EmitObjCArrayLiteral(const ObjCArrayLiteral *E)
void EmitARCIntrinsicUse(ArrayRef< llvm::Value * > values)
Given a number of pointers, inform the optimizer that they're being intrinsically used up until this ...
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...
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
LValue EmitDeclRefLValue(const DeclRefExpr *E)
std::pair< LValue, llvm::Value * > EmitARCStoreUnsafeUnretained(const BinaryOperator *e, bool ignored)
const TemplateArgument * iterator
virtual ConstantAddress GenerateConstantString(const StringLiteral *)=0
Generate a constant string object.
llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource AlignSource=AlignmentSource::Type, llvm::MDNode *TBAAInfo=nullptr, QualType TBAABaseTy=QualType(), uint64_t TBAAOffset=0, bool isNontemporal=false)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S)
llvm::Value * EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value)
Claim a possibly-autoreleased return value at +0.
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. ...
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
QualType withConst() const
llvm::Constant * objc_autoreleasePoolPush
void *objc_autoreleasePoolPush(void);
static TryEmitResult tryEmitARCRetainLoadOfScalar(CodeGenFunction &CGF, LValue lvalue, QualType type)
const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)
Objective-C methods are C functions with some implicit parameters.
virtual llvm::Value * EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF)
const ObjCInterfaceDecl * getClassInterface() const
ObjCProtocolExpr used for protocol expression in Objective-C.
virtual llvm::Value * GenerateProtocolRef(CodeGenFunction &CGF, const ObjCProtocolDecl *OPD)=0
Emit the code to return the named protocol as an object, as in a @protocol expression.
llvm::InlineAsm * retainAutoreleasedReturnValueMarker
A void(void) inline asm to use to mark that the return value of a call will be immediately retain...
static llvm::Constant * createARCRuntimeFunction(CodeGenModule &CGM, llvm::FunctionType *type, StringRef fnName)
const CodeGenOptions & getCodeGenOpts() const
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.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
QualType getReturnType() const
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...
static void destroyARCStrongWithStore(CodeGenFunction &CGF, Address addr, QualType type)
Like CodeGenFunction::destroyARCStrong, but do it with a call.
Assigning into this object requires a lifetime extension.
ObjCBoxedExpr - used for generalized expression boxing.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
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.
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.
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.
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...
FunctionArgList - Type for representing both the decl and type of parameters to a function...
ObjCIvarDecl * getNextIvar()
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
Expr * getResultExpr()
Return the result-bearing expression, or null if there is none.
void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S)
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
llvm::Constant * objc_unsafeClaimAutoreleasedReturnValue
id objc_unsafeClaimAutoreleasedReturnValue(id);
static llvm::Value * emitARCValueOperation(CodeGenFunction &CGF, llvm::Value *value, llvm::Constant *&fn, StringRef fnName, bool isTailCall=false)
Perform an operation having the signature i8* (i8*) where a null input causes a no-op and returns nul...
void GenerateObjCGetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCGetter - Synthesize an Objective-C property getter function.
bool isZero() const
isZero - Test whether the quantity equals zero.
unsigned char PointerAlignInBytes
void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr)
Produce the code to do a primitive release.
Address CreateMemTemp(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignment...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
The basic abstraction for the target Objective-C runtime.
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
llvm::Value * EmitARCLoadWeakRetained(Address addr)
i8* @objc_loadWeakRetained(i8** addr)
Address CreateStructGEP(Address Addr, unsigned Index, CharUnits Offset, const llvm::Twine &Name="")
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
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)
llvm::Constant * clang_arc_use
void clang.arc.use(...);
QualType TypeOfSelfObject()
TypeOfSelfObject - Return type of object that this self represents.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Selector getSelector() const
Checking the destination of a store. Must be suitably sized and aligned.
ObjCMethodDecl * getArrayWithObjectsMethod() const
detail::InMemoryDirectory::const_iterator E
void EmitAggregateCopy(Address DestPtr, Address SrcPtr, QualType EltTy, bool isVolatile=false, bool isAssignment=false)
EmitAggregateCopy - Emit an aggregate copy.
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
semantics_iterator semantics_begin()
llvm::Constant * GenerateObjCAtomicGetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
static bool hasTrivialSetExpr(const ObjCPropertyImplDecl *PID)
void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S)
virtual StringRef getARCRetainAutoreleasedReturnValueMarker() const
Retrieve the address of a function to call immediately before calling objc_retainAutoreleasedReturnVa...
static CharUnits getMaxAtomicAccessSize(CodeGenModule &CGM, llvm::Triple::ArchType arch)
Return the maximum size that permits atomic accesses for the given architecture.
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type. ...
ObjCMethodDecl * getDictWithObjectsMethod() const
Defines the Diagnostic-related interfaces.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Represents a pointer to an Objective C object.
void EmitAutoVarCleanups(const AutoVarEmission &emission)
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
ObjCMethodDecl * getGetterMethodDecl() const
llvm::PointerType * getType() const
Return the type of the pointer value.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
static llvm::Value * emitARCOperationAfterCall(CodeGenFunction &CGF, llvm::Value *value, ValueTransform doAfterCall, ValueTransform doFallback)
Insert code immediately after a call.
virtual llvm::Constant * EnumerationMutationFunction()=0
EnumerationMutationFunction - Return the function that's called by the compiler when a mutation is de...
const T * getAs() const
Member-template getAs<specific type>'.
QualType getCanonicalType() const
const Stmt * getSubStmt() const
Represents Objective-C's collection statement.
Address CreateConstArrayGEP(Address Addr, uint64_t Index, CharUnits EltSize, const llvm::Twine &Name="")
Given addr = [n x T]* ...
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**)
ObjCMethodDecl * getSetterMethodDecl() const
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...
llvm::PointerType * Int8PtrTy
LValue EmitLValueForIvar(QualType ObjectTy, llvm::Value *Base, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)
llvm::Constant * objc_retainAutorelease
id objc_retainAutorelease(id);
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
llvm::Value * EmitIvarOffset(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
llvm::Value * EmitARCRetainAutorelease(QualType type, llvm::Value *value)
Do a fused retain/autorelease of the given object.
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
void setAtomicSetterHelperFnMap(QualType Ty, llvm::Constant *Fn)
void EmitARCInitWeak(Address addr, llvm::Value *value)
i8* @objc_initWeak(i8** addr, i8* value) Returns value.
ARCPreciseLifetime_t
Does an ARC strong l-value have precise lifetime?
ObjCIvarRefExpr - A reference to an ObjC instance variable.
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
ObjCPropertyDecl * getPropertyDecl() const
Reading or writing from this object requires a barrier call.
bool hasAtomicCopyHelper() const
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()
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.
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
llvm::Value * EmitObjCCollectionLiteral(const Expr *E, const ObjCMethodDecl *MethodWithObjects)
void EmitReturnStmt(const ReturnStmt &S)
EmitReturnStmt - Note that due to GCC extensions, this can have an operand if the function returns vo...
llvm::Type * ConvertType(QualType T)
ObjCIvarDecl - Represents an ObjC instance variable.
static llvm::Constant * getNullForVariable(Address addr)
Given the address of a variable of pointer type, find the correct null to store into it...
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
Represents Objective-C's @try ... @catch ... @finally statement.
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 ...
llvm::Value * EmitARCRetainBlock(llvm::Value *value, bool mandatory)
Retain the given block, with _Block_copy semantics.
void generateObjCGetterBody(const ObjCImplementationDecl *classImpl, const ObjCPropertyImplDecl *propImpl, const ObjCMethodDecl *GetterMothodDecl, llvm::Constant *AtomicHelperFn)
void ForceCleanup()
Force the emission of cleanups now, instead of waiting until this object is destroyed.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
void StartObjCMethod(const ObjCMethodDecl *MD, const ObjCContainerDecl *CD)
StartObjCMethod - Begin emission of an ObjCMethod.
SourceLocation getRBracLoc() const
static Decl::Kind getKind(const Decl *D)
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)
A reference to a declared variable, function, enum, etc.
static RValue get(llvm::Value *V)
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 ...
static void emitAutoreleasedReturnValueMarker(CodeGenFunction &CGF)
Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
llvm::Value * LoadObjCSelf()
LoadObjCSelf - Load the value of self.
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.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
CodeGenTypes & getTypes() const
A trivial tuple used to represent a source range.
void EmitObjCAtTryStmt(const ObjCAtTryStmt &S)
LValue - This represents an lvalue references.
Information for lazily generating a cleanup.
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
llvm::Value * EmitObjCConsumeObject(QualType T, llvm::Value *Ptr)
Produce the code for a CK_ARCConsumeObject.
static llvm::Value * emitARCLoadOperation(CodeGenFunction &CGF, Address addr, llvm::Constant *&fn, StringRef fnName)
Perform an operation having the following signature: i8* (i8**)
llvm::PointerIntPair< llvm::Value *, 1, bool > TryEmitResult
bool isConstQualified() const
Determine whether this type is const-qualified.
The receiver is a superclass.
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
llvm::Constant * objc_retainAutoreleaseReturnValue
id objc_retainAutoreleaseReturnValue(id);
void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S)
CallArgList - Type for representing both the value and type of arguments in a call.
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Represents Objective-C's @autoreleasepool Statement.
CGCalleeInfo - Class to encapsulate the information about a callee to be used during the generation o...
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
bool hasLocalStorage() const
hasLocalStorage - Returns true if a variable with function scope is a non-static local variable...
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
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...
llvm::Value * EmitObjCSelectorExpr(const ObjCSelectorExpr *E)
Emit a selector.
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
static void emitCXXDestructMethod(CodeGenFunction &CGF, ObjCImplementationDecl *impl)
unsigned char PointerSizeInBytes
llvm::Value * EmitObjCProtocolExpr(const ObjCProtocolExpr *E)
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.