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 =
125 StringRef ConstantName = ALE ?
"__NSArray0__" :
"__NSDictionary0__";
127 llvm::Constant *Constant =
131 cast<llvm::LoadInst>(Ptr)->setMetadata(
154 bool TrackNeededObjects =
159 for (uint64_t i = 0; i < NumElements; i++) {
169 if (TrackNeededObjects) {
170 NeededObjects.push_back(value);
188 if (TrackNeededObjects) {
189 NeededObjects.push_back(keyValue);
190 NeededObjects.push_back(valueValue);
225 Receiver, Args, Class, MethodWithObjects);
231 if (TrackNeededObjects) {
292 if (
auto opaque = dyn_cast<OpaqueValueExpr>(receiver)) {
293 if (opaque->getSourceExpr())
298 if (!ice || ice->
getCastKind() != CK_LValueToRValue)
return true;
302 if (
auto opaque = dyn_cast<OpaqueValueExpr>(receiver)) {
303 if (opaque->getSourceExpr())
312 if (isa<MemberExpr>(receiver) || isa<ObjCIvarRefExpr>(receiver))
317 if (!declRef)
return true;
319 if (!var)
return true;
324 !var->
hasAttr<ObjCPreciseLifetimeAttr>());
337 llvm_unreachable(
"invalid receiver kind");
345 if (
auto CE = dyn_cast<CastExpr>(E)) {
346 if (CE->getCastKind() == CK_LValueToRValue) {
348 return CE->getSubExpr();
384 method->
hasAttr<NSConsumesSelfAttr>());
387 bool isSuperMessage =
false;
388 bool isClassMessage =
false;
399 Receiver = ter.getPointer();
400 if (ter.getInt()) retainSelf =
false;
408 assert(ObjTy &&
"Invalid Objective-C class message send");
410 assert(OID &&
"Invalid Objective-C class message send");
411 Receiver = Runtime.
GetClass(*
this, OID);
412 isClassMessage =
true;
419 isSuperMessage =
true;
425 isSuperMessage =
true;
426 isClassMessage =
true;
437 method->
hasAttr<ObjCReturnsInnerPointerAttr>() &&
453 if (isDelegateInit) {
455 "delegate init calls should only be marked in ARC");
464 if (isSuperMessage) {
467 bool isCategoryImpl = isa<ObjCCategoryImplDecl>(OMD->
getDeclContext());
485 if (isDelegateInit) {
508 if (!iface->getSuperClass())
return;
510 bool isCategory = isa<ObjCCategoryImplDecl>(impl);
537 if (OMD->
hasAttr<NoDebugAttr>())
562 if (ident->
isStr(
"dealloc"))
575 assert(isa<CompoundStmt>(OMD->
getBody()));
584 bool isAtomic,
bool hasStrong) {
624 llvm::Triple::ArchType arch) {
634 class PropertyImplStrategy {
646 SetPropertyAndExpressionGet,
656 StrategyKind
getKind()
const {
return StrategyKind(
Kind); }
658 bool hasStrongMember()
const {
return HasStrong; }
659 bool isAtomic()
const {
return IsAtomic; }
660 bool isCopy()
const {
return IsCopy; }
662 CharUnits getIvarSize()
const {
return IvarSize; }
663 CharUnits getIvarAlignment()
const {
return IvarAlignment; }
670 unsigned IsAtomic : 1;
672 unsigned HasStrong : 1;
692 std::tie(IvarSize, IvarAlignment) =
698 Kind = GetSetProperty;
711 }
else if (CGM.
getLangOpts().ObjCAutoRefCount && !IsAtomic) {
721 Kind = SetPropertyAndExpressionGet;
727 }
else if (!IsAtomic) {
728 Kind = SetPropertyAndExpressionGet;
733 Kind = GetSetProperty;
764 HasStrong =
recordType->getDecl()->hasObjectMember();
779 if (!IvarSize.isPowerOfTwo()) {
784 llvm::Triple::ArchType arch =
812 llvm::Constant *AtomicHelperFn =
816 assert(OMD &&
"Invalid call to generate getter (empty method)");
826 if (!getter)
return true;
839 return (construct->getConstructor()->isTrivial());
843 assert(isa<ExprWithCleanups>(getter));
852 llvm::Constant *AtomicHelperFn) {
870 llvm::Constant *copyCppAtomicObjectFn =
882 llvm::Constant *AtomicHelperFn) {
885 if (!AtomicHelperFn) {
893 ivar, AtomicHelperFn);
905 PropertyImplStrategy strategy(CGM, propImpl);
906 switch (strategy.getKind()) {
907 case PropertyImplStrategy::Native: {
909 if (strategy.getIvarSize().isZero())
918 bitcastType = bitcastType->getPointerTo();
924 load->setAtomic(llvm::AtomicOrdering::Unordered);
930 uint64_t retTySize = CGM.
getDataLayout().getTypeSizeInBits(retTy);
932 if (ivarSize > retTySize) {
934 ivarVal =
Builder.CreateTrunc(load, newTy);
935 bitcastType = newTy->getPointerTo();
945 case PropertyImplStrategy::GetSetProperty: {
946 llvm::Constant *getPropertyFn =
948 if (!getPropertyFn) {
972 llvm::Instruction *CallInstruction;
974 getTypes().arrangeBuiltinFunctionCall(propType, args),
976 if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(CallInstruction))
986 EmitReturnOfRValue(RV, propType);
994 case PropertyImplStrategy::CopyStruct:
996 strategy.hasStrongMember());
999 case PropertyImplStrategy::Expression:
1000 case PropertyImplStrategy::SetPropertyAndExpressionGet: {
1047 llvm_unreachable(
"bad evaluation kind");
1051 llvm_unreachable(
"bad @property implementation strategy!");
1102 llvm::Constant *AtomicHelperFn) {
1125 llvm::Constant *fn =
1136 if (!setter)
return true;
1146 if (
CallExpr *call = dyn_cast<CallExpr>(setter)) {
1148 = dyn_cast_or_null<FunctionDecl>(call->getCalleeDecl()))
1149 if (callee->isTrivial())
1154 assert(isa<ExprWithCleanups>(setter));
1167 llvm::Constant *AtomicHelperFn) {
1175 if (!AtomicHelperFn)
1185 PropertyImplStrategy strategy(CGM, propImpl);
1186 switch (strategy.getKind()) {
1187 case PropertyImplStrategy::Native: {
1189 if (strategy.getIvarSize().isZero())
1196 Address ivarAddr = ivarLValue.getAddress();
1202 getContext().toBits(strategy.getIvarSize()));
1213 store->setAtomic(llvm::AtomicOrdering::Unordered);
1217 case PropertyImplStrategy::GetSetProperty:
1218 case PropertyImplStrategy::SetPropertyAndExpressionGet: {
1220 llvm::Constant *setOptimizedPropertyFn =
nullptr;
1221 llvm::Constant *setPropertyFn =
nullptr;
1224 setOptimizedPropertyFn =
1228 if (!setOptimizedPropertyFn) {
1235 if (!setPropertyFn) {
1256 if (setOptimizedPropertyFn) {
1279 case PropertyImplStrategy::CopyStruct:
1283 case PropertyImplStrategy::Expression:
1292 selfDecl->
getType(), CK_LValueToRValue, &
self,
1296 &selfLoad,
true,
true);
1299 QualType argType = argDecl->getType().getNonReferenceType();
1309 if (ivarRef.getType()->isObjCObjectPointerType()) {
1310 if (argLoad.getType()->isObjCObjectPointerType())
1312 else if (argLoad.getType()->isBlockPointerType())
1313 argCK = CK_BlockPointerToObjCPointerCast;
1315 argCK = CK_CPointerToObjCPointerCast;
1316 }
else if (ivarRef.getType()->isBlockPointerType()) {
1317 if (argLoad.getType()->isBlockPointerType())
1320 argCK = CK_AnyPointerToBlockPointerCast;
1321 }
else if (ivarRef.getType()->isPointerType()) {
1325 ivarRef.getType(), argCK, &argLoad,
1327 Expr *finalArg = &argLoad;
1330 finalArg = &argCast;
1345 llvm::Constant *AtomicHelperFn =
1349 assert(OMD &&
"Invalid call to generate setter (empty method)");
1363 bool useEHCleanupForArray;
1367 bool useEHCleanupForArray)
1368 : addr(addr), ivar(ivar), destroyer(destroyer),
1369 useEHCleanupForArray(useEHCleanupForArray) {}
1375 flags.isForNormalCleanup() && useEHCleanupForArray);
1401 if (!dtorKind)
continue;
1417 CGF.
EHStack.pushCleanup<DestroyIvar>(cleanupKind,
self, ivar, destroyer,
1435 for (
const auto *IvarInit : IMP->
inits()) {
1436 FieldDecl *Field = IvarInit->getAnyMember();
1476 llvm::Constant *EnumerationMutationFnPtr =
1478 if (!EnumerationMutationFnPtr) {
1504 static const unsigned NumItems = 16;
1517 llvm::APInt(32, NumItems),
1553 llvm::Constant *Count = llvm::ConstantInt::get(NSUIntegerTy, NumItems);
1560 FastEnumSel, Collection, Args);
1568 llvm::Value *zero = llvm::Constant::getNullValue(NSUIntegerTy);
1575 Builder.CreateICmpEQ(initialBufferLimit, zero,
"iszero"), EmptyBB,
1592 "forcoll.initial-mutations");
1600 llvm::PHINode *index =
Builder.CreatePHI(NSUIntegerTy, 3,
"forcoll.index");
1601 index->addIncoming(zero, LoopInitBB);
1604 llvm::PHINode *count =
Builder.CreatePHI(NSUIntegerTy, 3,
"forcoll.count");
1605 count->addIncoming(initialBufferLimit, LoopInitBB);
1618 llvm::BasicBlock *WasNotMutatedBB =
createBasicBlock(
"forcoll.notmutated");
1620 Builder.CreateCondBr(
Builder.CreateICmpEQ(currentMutations, initialMutations),
1621 WasNotMutatedBB, WasMutatedBB);
1641 bool elementIsVariable;
1648 const VarDecl* D = cast<VarDecl>(SD->getSingleDecl());
1653 elementIsVariable =
true;
1658 elementLValue =
LValue();
1659 elementType = cast<Expr>(S.
getElement())->getType();
1660 elementIsVariable =
false;
1674 Builder.CreateGEP(EnumStateItems, index,
"currentitem.ptr");
1684 if (!elementIsVariable) {
1694 if (elementIsVariable)
1698 BreakContinueStack.push_back(BreakContinue(LoopEnd, AfterBody));
1703 BreakContinueStack.pop_back();
1715 Builder.CreateAdd(index, llvm::ConstantInt::get(NSUIntegerTy, 1));
1722 Builder.CreateICmpULT(indexPlusOne, count), LoopBodyBB, FetchMoreBB,
1725 index->addIncoming(indexPlusOne, AfterBody.getBlock());
1726 count->addIncoming(count, AfterBody.getBlock());
1734 FastEnumSel, Collection, Args);
1740 index->addIncoming(zero,
Builder.GetInsertBlock());
1741 count->addIncoming(refetchCount,
Builder.GetInsertBlock());
1744 EmptyBB, LoopBodyBB);
1749 if (!elementIsVariable) {
1752 llvm::Value *null = llvm::Constant::getNullValue(convertedElementType);
1779 CallObjCRelease(
llvm::Value *
object) : object(
object) {}
1809 llvm::FunctionType *fnType =
1810 llvm::FunctionType::get(CGM.
VoidTy, None,
true);
1821 llvm::FunctionType *FTy,
1825 if (
auto *F = dyn_cast<llvm::Function>(RTF)) {
1831 F->setLinkage(llvm::Function::ExternalWeakLinkage);
1832 }
else if (Name ==
"objc_retain" || Name ==
"objc_release") {
1835 F->addFnAttr(llvm::Attribute::NonLazyBind);
1847 llvm::Constant *&fn,
1849 bool isTailCall =
false) {
1850 if (isa<llvm::ConstantPointerNull>(value))
1854 llvm::FunctionType *fnType =
1866 call->setTailCall();
1876 llvm::Constant *&fn,
1879 llvm::FunctionType *fnType =
1903 llvm::Constant *&fn,
1911 llvm::FunctionType *fnType
1912 = llvm::FunctionType::get(CGF.
Int8PtrTy, argTypes,
false);
1924 if (ignored)
return nullptr;
1934 llvm::Constant *&fn,
1941 llvm::FunctionType *fnType
1942 = llvm::FunctionType::get(CGF.
Builder.getVoidTy(), argTypes,
false);
1982 "objc_retainBlock");
1988 if (!mandatory && isa<llvm::Instruction>(result)) {
1989 llvm::CallInst *call
1990 = cast<llvm::CallInst>(result->stripPointerCasts());
1993 call->setMetadata(
"clang.arc.copy_on_escape",
1994 llvm::MDNode::get(
Builder.getContext(), None));
2003 llvm::InlineAsm *&marker
2011 if (assembly.empty()) {
2016 llvm::FunctionType *type =
2017 llvm::FunctionType::get(CGF.
VoidTy,
false);
2019 marker = llvm::InlineAsm::get(type, assembly,
"",
true);
2025 llvm::NamedMDNode *metadata =
2027 "clang.arc.retainAutoreleasedReturnValueMarker");
2028 assert(metadata->getNumOperands() <= 1);
2029 if (metadata->getNumOperands() == 0) {
2031 metadata->addOperand(llvm::MDNode::get(ctx,
2032 llvm::MDString::get(ctx, assembly)));
2052 "objc_retainAutoreleasedReturnValue");
2067 "objc_unsafeClaimAutoreleasedReturnValue");
2074 if (isa<llvm::ConstantPointerNull>(value))
return;
2078 llvm::FunctionType *fnType =
2090 call->setMetadata(
"clang.imprecise_release",
2091 llvm::MDNode::get(
Builder.getContext(), None));
2126 llvm::FunctionType *fnType
2127 = llvm::FunctionType::get(
Builder.getVoidTy(), argTypes,
false);
2137 if (ignored)
return nullptr;
2182 "objc_autorelease");
2191 "objc_autoreleaseReturnValue",
2201 "objc_retainAutoreleaseReturnValue",
2215 if (isa<llvm::ConstantPointerNull>(value))
return value;
2230 "objc_retainAutorelease");
2245 "objc_loadWeakRetained");
2255 "objc_storeWeak", ignored);
2267 if (isa<llvm::ConstantPointerNull>(value) &&
2275 "objc_initWeak",
true);
2283 llvm::FunctionType *fnType =
2332 llvm::FunctionType *fnType =
2333 llvm::FunctionType::get(
Int8PtrTy,
false);
2347 llvm::FunctionType *fnType =
2374 AllocSel, Receiver, Args);
2383 InitSel, Receiver, Args);
2425 CallObjCAutoreleasePoolObject(
llvm::Value *token) : Token(token) {}
2434 CallObjCMRRAutoreleasePoolObject(
llvm::Value *token) : Token(token) {}
2466 llvm_unreachable(
"impossible lifetime!");
2499 isa<BinaryOperator>(e) &&
2500 cast<BinaryOperator>(e)->getOpcode() == BO_Assign)
2515 if (llvm::CallInst *call = dyn_cast<llvm::CallInst>(value)) {
2516 CGBuilderTy::InsertPoint ip = CGF.
Builder.saveIP();
2519 CGF.
Builder.SetInsertPoint(call->getParent(),
2520 ++llvm::BasicBlock::iterator(call));
2521 value = doAfterCall(CGF, value);
2525 }
else if (llvm::InvokeInst *invoke = dyn_cast<llvm::InvokeInst>(value)) {
2526 CGBuilderTy::InsertPoint ip = CGF.
Builder.saveIP();
2529 llvm::BasicBlock *BB = invoke->getNormalDest();
2530 CGF.
Builder.SetInsertPoint(BB, BB->begin());
2531 value = doAfterCall(CGF, value);
2538 }
else if (llvm::BitCastInst *bitcast = dyn_cast<llvm::BitCastInst>(value)) {
2541 bitcast->setOperand(0, operand);
2548 return doFallback(CGF, value);
2581 bool allowUnsafeClaim) {
2582 if (allowUnsafeClaim &&
2600 if (isa<BlockExpr>(e))
2604 switch (
cast->getCastKind()) {
2606 case CK_LValueToRValue:
2607 case CK_ARCReclaimReturnedObject:
2608 case CK_ARCConsumeObject:
2609 case CK_ARCProduceObject:
2618 case CK_AnyPointerToBlockPointerCast:
2630 template <
typename Impl,
typename Result>
class ARCExprEmitter {
2633 Impl &asImpl() {
return *
static_cast<Impl*
>(
this); }
2638 Result visit(
const Expr *e);
2639 Result visitCastExpr(
const CastExpr *e);
2664 template <
typename Impl,
typename Result>
2666 ARCExprEmitter<Impl,Result>::visitPseudoObjectExpr(
const PseudoObjectExpr *E) {
2676 const Expr *semantic = *i;
2680 if (
const OpaqueValueExpr *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
2686 if (ov == resultExpr) {
2687 assert(!OVMA::shouldBindAsLValue(ov));
2688 result = asImpl().visit(ov->getSourceExpr());
2689 opaqueData = OVMA::bind(CGF, ov,
2694 opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
2696 opaques.push_back(opaqueData);
2700 }
else if (semantic == resultExpr) {
2701 result = asImpl().visit(semantic);
2710 for (
unsigned i = 0, e = opaques.size(); i != e; ++i)
2711 opaques[i].unbind(CGF);
2716 template <
typename Impl,
typename Result>
2717 Result ARCExprEmitter<Impl,Result>::visitCastExpr(
const CastExpr *e) {
2725 case CK_CPointerToObjCPointerCast:
2726 case CK_BlockPointerToObjCPointerCast:
2727 case CK_AnyPointerToBlockPointerCast:
2731 Result result = asImpl().visit(e->
getSubExpr());
2732 return asImpl().emitBitCast(result, resultType);
2736 case CK_LValueToRValue:
2737 return asImpl().visitLValueToRValue(e->
getSubExpr());
2738 case CK_ARCConsumeObject:
2739 return asImpl().visitConsumeObject(e->
getSubExpr());
2740 case CK_ARCExtendBlockObject:
2741 return asImpl().visitExtendBlockObject(e->
getSubExpr());
2742 case CK_ARCReclaimReturnedObject:
2743 return asImpl().visitReclaimReturnedObject(e->
getSubExpr());
2747 return asImpl().visitExpr(e);
2751 template <
typename Impl,
typename Result>
2753 ARCExprEmitter<Impl,Result>::visitBinaryOperator(
const BinaryOperator *e) {
2758 return asImpl().visit(e->
getRHS());
2761 return asImpl().visitBinAssign(e);
2764 return asImpl().visitExpr(e);
2768 template <
typename Impl,
typename Result>
2769 Result ARCExprEmitter<Impl,Result>::visitBinAssign(
const BinaryOperator *e) {
2772 return asImpl().visitBinAssignUnsafeUnretained(e);
2775 return asImpl().visitBinAssignWeak(e);
2778 return asImpl().visitBinAssignAutoreleasing(e);
2781 return asImpl().visitBinAssignStrong(e);
2784 return asImpl().visitExpr(e);
2786 llvm_unreachable(
"bad ObjC ownership qualifier");
2791 template <
typename Impl,
typename Result>
2792 Result ARCExprEmitter<Impl,Result>::
2796 Result result = asImpl().visit(e->
getRHS());
2807 template <
typename Impl,
typename Result>
2809 ARCExprEmitter<Impl,Result>::visitBinAssignAutoreleasing(
const BinaryOperator *e) {
2810 return asImpl().visitExpr(e);
2813 template <
typename Impl,
typename Result>
2815 ARCExprEmitter<Impl,Result>::visitBinAssignWeak(
const BinaryOperator *e) {
2816 return asImpl().visitExpr(e);
2819 template <
typename Impl,
typename Result>
2821 ARCExprEmitter<Impl,Result>::visitBinAssignStrong(
const BinaryOperator *e) {
2822 return asImpl().visitExpr(e);
2826 template <
typename Impl,
typename Result>
2827 Result ARCExprEmitter<Impl,Result>::visit(
const Expr *e) {
2832 assert(!isa<ExprWithCleanups>(e));
2838 if (
const CastExpr *ce = dyn_cast<CastExpr>(e)) {
2839 return asImpl().visitCastExpr(ce);
2842 }
else if (
auto op = dyn_cast<BinaryOperator>(e)) {
2843 return asImpl().visitBinaryOperator(op);
2851 }
else if (isa<CallExpr>(e) ||
2852 (isa<ObjCMessageExpr>(e) &&
2853 !cast<ObjCMessageExpr>(e)->isDelegateInitCall())) {
2854 return asImpl().visitCall(e);
2857 }
else if (
const PseudoObjectExpr *pseudo = dyn_cast<PseudoObjectExpr>(e)) {
2858 return asImpl().visitPseudoObjectExpr(pseudo);
2861 return asImpl().visitExpr(e);
2867 struct ARCRetainExprEmitter :
2868 public ARCExprEmitter<ARCRetainExprEmitter, TryEmitResult> {
2873 return result.getPointer();
2879 result.setPointer(value);
2910 if (subresult.getInt()) {
2915 result = subresult.getPointer();
2949 return ARCRetainExprEmitter(CGF).visit(e);
2957 if (!result.getInt())
2976 if (!result.getInt())
2992 if (result.getInt())
3008 result = subresult.getPointer();
3009 doRetain = !subresult.getInt();
3036 struct ARCUnsafeUnretainedExprEmitter :
3037 public ARCExprEmitter<ARCUnsafeUnretainedExprEmitter, llvm::Value*> {
3039 ARCUnsafeUnretainedExprEmitter(
CodeGenFunction &CGF) : ARCExprEmitter(CGF) {}
3086 return ARCUnsafeUnretainedExprEmitter(CGF).visit(e);
3104 std::pair<LValue,llvm::Value*>
3120 return std::pair<LValue,llvm::Value*>(std::move(lvalue), value);
3123 std::pair<LValue,llvm::Value*>
3130 bool hasImmediateRetain = result.getInt();
3137 hasImmediateRetain =
true;
3143 if (hasImmediateRetain) {
3151 return std::pair<LValue,llvm::Value*>(lvalue, value);
3154 std::pair<LValue,llvm::Value*>
3161 return std::pair<LValue,llvm::Value*>(lvalue, value);
3183 for (
const auto *I : S.
body())
3194 llvm::FunctionType *extenderType
3197 = llvm::InlineAsm::get(extenderType,
3222 llvm::Constant *HelperFn =
nullptr;
3248 args.push_back(&DstDecl);
3251 args.push_back(&SrcDecl);
3258 llvm::Function *Fn =
3260 "__assign_helper_atomic_property_",
3269 UnaryOperator DST(&DstExpr, UO_Deref, DestTy->getPointeeType(),
3277 Expr *Args[2] = { &DST, &SRC };
3280 Args, DestTy->getPointeeType(),
3286 HelperFn = llvm::ConstantExpr::getBitCast(Fn,
VoidPtrTy);
3303 llvm::Constant *HelperFn =
nullptr;
3331 args.push_back(&DstDecl);
3334 args.push_back(&SrcDecl);
3341 llvm::Function *Fn =
3343 "__copy_helper_atomic_property_", &CGM.
getModule());
3359 ConstructorArgs.push_back(&SRC);
3360 ConstructorArgs.append(std::next(CXXConstExpr->arg_begin()),
3361 CXXConstExpr->arg_end());
3365 CXXConstExpr->getConstructor(),
3366 CXXConstExpr->isElidable(),
3368 CXXConstExpr->hadMultipleCandidates(),
3369 CXXConstExpr->isListInitialization(),
3370 CXXConstExpr->isStdInitListInitialization(),
3371 CXXConstExpr->requiresZeroInitialization(),
3372 CXXConstExpr->getConstructionKind(),
3390 HelperFn = llvm::ConstantExpr::getBitCast(Fn,
VoidPtrTy);
3414 Ty, AutoreleaseSelector,
3422 assert(Args.size() == 3 &&
"Expected 3 argument here!");
3425 llvm::FunctionType *FTy =
3434 return Builder.CreateICmpNE(CallRes, llvm::Constant::getNullValue(
Int32Ty));
3437 void CodeGenModule::emitAtAvailableLinkGuard() {
3438 if (!IsOSVersionAtLeastFn)
3448 llvm::Metadata *Args[2] = {llvm::MDString::get(Context,
"-framework"),
3449 llvm::MDString::get(Context,
"CoreFoundation")};
3450 LinkerOptionsMetadata.push_back(llvm::MDNode::get(Context, Args));
3453 llvm::FunctionType *FTy =
3455 llvm::Constant *CFFunc =
3456 CreateRuntimeFunction(FTy,
"CFBundleGetVersionNumber");
3458 llvm::FunctionType *CheckFTy = llvm::FunctionType::get(
VoidTy, {},
false);
3459 llvm::Function *CFLinkCheckFunc = cast<llvm::Function>(CreateBuiltinFunction(
3460 CheckFTy,
"__clang_at_available_requires_core_foundation_framework"));
3461 CFLinkCheckFunc->setLinkage(llvm::GlobalValue::LinkOnceAnyLinkage);
3466 CGF.
Builder.CreateUnreachable();
3467 addCompilerUsedGlobal(CFLinkCheckFunc);
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
llvm::PointerType * Int8PtrPtrTy
const llvm::DataLayout & getDataLayout() const
A call to an overloaded operator written using operator syntax.
The receiver is the instance of the superclass object.
ReturnValueSlot - Contains the address where the return value of a function can be stored...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
static bool UseOptimizedSetter(CodeGenModule &CGM)
SourceLocation getRBracLoc() const
Defines the clang::ASTContext interface.
bool isClassMethod() const
Represents a function declaration or definition.
llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)
Store into a strong object.
The receiver is an object instance.
llvm::Value * EmitARCReclaimReturnedObject(const Expr *e, bool allowUnsafeClaim)
Other implicit parameter.
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.
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Smart pointer class that efficiently represents Objective-C method names.
QualType getObjCIdType() const
Represents the Objective-CC id type.
llvm::Value * EmitARCRetainAutoreleaseScalarExpr(const Expr *expr)
static bool hasTrivialGetExpr(const ObjCPropertyImplDecl *propImpl)
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
A (possibly-)qualified type.
bool isBlockPointerType() const
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...
CodeGenTypes & getTypes()
const CodeGenOptions & getCodeGenOpts() const
Selector getSelector() const
llvm::Value * EmitARCExtendBlockObject(const Expr *expr)
ObjCInterfaceDecl * getClassInterface()
virtual llvm::Function * GenerateMethod(const ObjCMethodDecl *OMD, const ObjCContainerDecl *CD)=0
Generate a function preamble for a method with the specified types.
Address CreateMemTemp(QualType T, const Twine &Name="tmp", Address *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
ObjCIvarDecl * getPropertyIvarDecl() const
void EmitARCDestroyWeak(Address addr)
void @objc_destroyWeak(i8** addr) Essentially objc_storeWeak(addr, nil).
ObjCProtocolDecl * getProtocol() const
Stmt - This represents one statement.
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.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool requiresCleanups() const
Determine whether this scope requires any cleanups.
Implements runtime-specific code generation functions.
void addConst()
Add the const type qualifier to this QualType.
bool isRecordType() const
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...
llvm::Constant * objc_autoreleaseReturnValue
id objc_autoreleaseReturnValue(id);
CharUnits getPointerSize() const
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Expr * getSetterCXXAssignment() 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...
Represents a call to a C++ constructor.
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
bool isZero() const
isZero - Test whether the quantity equals zero.
QualType withConst() const
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.
Floating point control options.
llvm::Constant * GenerateObjCAtomicSetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
GenerateObjCAtomicSetterCopyHelperFunction - Given a c++ object type with non-trivial copy assignment...
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
static llvm::Value * emitARCRetainLoadOfScalar(CodeGenFunction &CGF, LValue lvalue, QualType type)
param_const_iterator param_end() const
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
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::Instruction **callOrInvoke, SourceLocation Loc)
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.
Represents a variable declaration or definition.
Objects with "hidden" visibility are not seen by the dynamic linker.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
const T * getAs() const
Member-template getAs<specific type>'.
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
virtual StringRef getARCRetainAutoreleasedReturnValueMarker() const
Retrieve the address of a function to call immediately before calling objc_retainAutoreleasedReturnVa...
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.
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)
llvm::Value * getPointer() const
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 ...
Represents a parameter to a function.
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.
void add(RValue rvalue, QualType type)
A jump destination is an abstract label, branching to which may require a jump out through normal cle...
bool isARCPseudoStrong() const
Determine whether this variable is an ARC pseudo-__strong variable.
llvm::Value * EmitObjCThrowOperand(const Expr *expr)
const Stmt * getSubStmt() const
const AstTypeMatcher< RecordType > recordType
Matches record types (e.g.
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.
Address getAddress() const
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
Expr * getGetterCXXConstructor() 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.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
const ParmVarDecl *const * param_const_iterator
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 hasOptimizedSetter() const
Does this runtime supports optimized setter entrypoints?
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)
SetterKind getSetterKind() const
getSetterKind - Return the method used for doing assignment in the property setter.
llvm::Value * EmitARCRetainAutoreleaseReturnValue(llvm::Value *value)
Do a fused retain/autorelease of the given object.
Represents a member of a struct/union/class.
CharUnits getAlignment() const
StringLiteral * getString()
bool isReferenceType() const
ObjCMethodDecl * getSetterMethodDecl() const
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.
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
forAddr - Make a slot for an aggregate value.
void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, ObjCMethodDecl *MD, bool ctor)
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...
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Selector getSelector() const
void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)
EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...
ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc)
EmitLoadOfComplex - Load a complex number from the specified l-value.
const Expr *const * const_semantics_iterator
bool isUnarySelector() const
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.
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)
Store into a strong object.
ARCPreciseLifetime_t isARCPreciseLifetime() const
llvm::Constant * objc_initWeak
id objc_initWeak(id*, id);
llvm::Value * EmitObjCStringLiteral(const ObjCStringLiteral *E)
Emits an instance of NSConstantString representing the object.
bool isBitField() const
Determines whether this field is a bitfield.
Selector getNullarySelector(IdentifierInfo *ID)
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.
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.
Qualifiers::GC getObjCGCAttrKind(QualType Ty) const
Return one of the GCNone, Weak or Strong Objective-C garbage collection attributes.
SourceLocation getLBracLoc() const
SourceLocation getLocEnd() const LLVM_READONLY
PropertyAttributeKind getPropertyAttributes() const
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".
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
llvm::Value * EmitARCUnsafeUnretainedScalarExpr(const Expr *expr)
EmitARCUnsafeUnretainedScalarExpr - Semantically equivalent to immediately releasing the resut of Emi...
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)).
ObjCStringLiteral, used for Objective-C string literals i.e.
Scope - A scope is a transient data structure that is used while parsing the program.
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.
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
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...
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
void ForceCleanup(std::initializer_list< llvm::Value **> ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
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.
ObjCMethodDecl * getArrayWithObjectsMethod() const
virtual llvm::Constant * GetGetStructFunction()=0
GlobalDecl CurGD
CurGD - The GlobalDecl for the current function being compiled.
CharUnits getPointerAlign() const
An ordinary object is located at an address in memory.
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.
QualType getReturnType() const
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
static llvm::Constant * createARCRuntimeFunction(CodeGenModule &CGM, llvm::FunctionType *FTy, StringRef Name)
static TryEmitResult tryEmitARCRetainScalarExpr(CodeGenFunction &CGF, const Expr *e)
bool isAtomic() const
isAtomic - Return true if the property is atomic.
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.
ObjCMethodDecl * getDictWithObjectsMethod() const
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.
llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource Source=AlignmentSource::Type, bool isNontemporal=false)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
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
ASTContext & getContext() const
llvm::CallInst * EmitNounwindRuntimeCall(llvm::Value *callee, const Twine &name="")
const TargetCodeGenInfo & getTargetCodeGenInfo()
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
void objc_storeStrong(id*, id);
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...
CleanupKind getARCCleanupKind()
Retrieves the default cleanup kind for an ARC cleanup.
static AutoVarEmission invalid()
llvm::Value * EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored)
i8* @objc_storeWeak(i8** addr, i8* value) Returns value.
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
ObjCMethodDecl * getBoxingMethod() const
static bool shouldExtendReceiverForInnerPointerMessage(const ObjCMessageExpr *message)
Decide whether to extend the lifetime of the receiver of a returns-inner-pointer message.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Expr - This represents one expression.
bool hasAtomicCopyHelper() const
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)
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
Generate an Objective-C method.
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.
static void emitStructSetterCall(CodeGenFunction &CGF, ObjCMethodDecl *OMD, ObjCIvarDecl *ivar)
emitStructSetterCall - Call the runtime function to store the value from the first formal parameter i...
llvm::BasicBlock * getBlock() const
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
bool isObjCRetainableType() const
virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, bool ClearInsertionPoint=true)=0
llvm::Constant * objc_retain
id objc_retain(id);
const Expr * getCallee() const
llvm::PointerType * getType() const
Return the type of the pointer value.
ObjCLifetime getObjCLifetime() const
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
DeclContext * getDeclContext()
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)
virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtTryStmt &S)=0
llvm::Value * EmitARCAutorelease(llvm::Value *value)
Autorelease the given object.
llvm::LLVMContext & getLLVMContext()
SmallVector< llvm::OperandBundleDef, 1 > getBundlesForFunclet(llvm::Value *Callee)
const CGFunctionInfo & arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args)
llvm::IntegerType * Int32Ty
virtual llvm::Value * GetSelector(CodeGenFunction &CGF, Selector Sel)=0
Get a selector for the specified name and type values.
Expr * getElement(unsigned Index)
getElement - Return the Element at the specified index.
clang::ObjCRuntime ObjCRuntime
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...
virtual llvm::Constant * GetPropertyGetFunction()=0
Return the runtime function for getting properties.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
LValue MakeNaturalAlignAddrLValue(llvm::Value *V, QualType T)
An expression that sends a message to the given Objective-C object or class.
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
bool isInstanceMethod() const
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
const TargetInfo & getTarget() const
const Qualifiers & getQuals() const
Selector getSelector() const
const LangOptions & getLangOpts() const
ASTContext & getContext() const
ImplicitParamDecl * getSelfDecl() const
bool hasEmptyCollections() const
Are the empty collection symbols available?
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*)
bool isConstQualified() const
Determine whether this type is const-qualified.
virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtSynchronizedStmt &S)=0
The l-value was considered opaque, so the alignment was determined from a type.
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="")
SelectorTable & Selectors
Assigning into this object requires the old value to be released and the new value to be retained...
QualType getCanonicalType() const
llvm::Constant * objc_storeWeak
id objc_storeWeak(id*, id);
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
static llvm::Value * emitARCUnsafeUnretainedScalarExpr(CodeGenFunction &CGF, const Expr *e)
Encodes a location in the source.
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go...
llvm::Value * EmitObjCArrayLiteral(const ObjCArrayLiteral *E)
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)
virtual ConstantAddress GenerateConstantString(const StringLiteral *)=0
Generate a constant string object.
LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK)
Same as EmitLValue but additionally we generate checking code to guard against undefined behavior...
AggValueSlot::Overlap_t overlapForReturnValue()
Determine whether a return value slot may overlap some other object.
CastKind getCastKind() const
llvm::CallSite EmitRuntimeCallOrInvoke(llvm::Value *callee, ArrayRef< llvm::Value *> args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S)
llvm::Value * EmitARCUnsafeClaimAutoreleasedReturnValue(llvm::Value *value)
Claim a possibly-autoreleased return value at +0.
SourceLocation getLocStart() const LLVM_READONLY
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
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.
void EmitStmt(const Stmt *S, ArrayRef< const Attr *> Attrs=None)
EmitStmt - Emit the code for the statement.
virtual llvm::Value * EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF)
ObjCEntrypoints & getObjCEntrypoints() 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...
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.
Represents one property declaration in an Objective-C interface.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
static Destroyer emitARCIntrinsicUse
All available information about a concrete callee.
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...
const ObjCMethodDecl * getMethodDecl() const
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.
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 emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr)
void enterFullExpression(const ExprWithCleanups *E)
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
static Destroyer destroyARCStrongImprecise
void FinishFunction(SourceLocation EndLoc=SourceLocation())
FinishFunction - Complete IR generation of the current function.
Expr * Value
The value of the dictionary element.
std::pair< CharUnits, CharUnits > getTypeInfoInChars(const Type *T) const
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()
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
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);
const ObjCInterfaceDecl * getClassInterface() const
Dataflow Directional Tag Classes.
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.
unsigned char PointerAlignInBytes
void EmitObjCAutoreleasePoolPop(llvm::Value *Ptr)
Produce the code to do a primitive release.
The basic abstraction for the target Objective-C runtime.
llvm::Value * EmitARCLoadWeakRetained(Address addr)
i8* @objc_loadWeakRetained(i8** addr)
Address CreateStructGEP(Address Addr, unsigned Index, CharUnits Offset, const llvm::Twine &Name="")
QualType getSuperType() const
Retrieve the type referred to by 'super'.
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
void EmitARCIntrinsicUse(ArrayRef< llvm::Value *> values)
Given a number of pointers, inform the optimizer that they're being intrinsically used up until this ...
llvm::Constant * getPointer() const
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
llvm::Constant * objc_destroyWeak
void objc_destroyWeak(id*);
U cast(CodeGen::Address addr)
llvm::Constant * clang_arc_use
void clang.arc.use(...);
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
QualType TypeOfSelfObject()
TypeOfSelfObject - Return type of object that this self represents.
Checking the destination of a store. Must be suitably sized and aligned.
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
semantics_iterator semantics_begin()
static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
llvm::Constant * GenerateObjCAtomicGetterCopyHelperFunction(const ObjCPropertyImplDecl *PID)
llvm::Module & getModule() const
static bool hasTrivialSetExpr(const ObjCPropertyImplDecl *PID)
void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
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. ...
QualType getClassReceiver() const
Returns the type of a class message send, or NULL if the message is not a class message.
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...
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...
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
Represents Objective-C's collection statement.
CodeGenTypes & getTypes() const
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**)
bool hasNonTrivialObjCLifetime() const
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
llvm::Type * getElementType() const
Return the type of the values stored in this address.
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
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.
llvm::PointerType * Int8PtrTy
const TargetInfo & Target
bool isDelegateInitCall() const
isDelegateInitCall - Answers whether this message send has been tagged as a "delegate init call"...
LValue EmitLValueForIvar(QualType ObjectTy, llvm::Value *Base, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)
llvm::Constant * objc_retainAutorelease
id objc_retainAutorelease(id);
param_const_iterator param_begin() const
llvm::Value * EmitIvarOffset(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)
void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
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?
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
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.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
virtual llvm::Value * GetClass(CodeGenFunction &CGF, const ObjCInterfaceDecl *OID)=0
GetClass - Return a reference to the class for the given interface decl.
Reading or writing from this object requires a barrier call.
void EmitLexicalBlockStart(CGBuilderTy &Builder, SourceLocation Loc)
Emit metadata to indicate the beginning of a new lexical block and push the block onto the stack...
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
TranslationUnitDecl * getTranslationUnitDecl() const
llvm::iterator_range< arg_iterator > arguments()
A non-RAII class containing all the information about a bound opaque value.
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.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
ImplicitParamDecl * getCmdDecl() const
Represents Objective-C's @try ... @catch ... @finally statement.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
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)
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.
llvm::Constant * IsOSVersionAtLeastFn
bool hasARCUnsafeClaimAutoreleasedReturnValue() const
Is objc_unsafeClaimAutoreleasedReturnValue available?
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)
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)
EmitAggregateCopy - Emit an aggregate copy.
A reference to a declared variable, function, enum, etc.
static RValue get(llvm::Value *V)
ObjCPropertyDecl * getPropertyDecl() const
static const Expr * findWeakLValue(const Expr *E)
Given an expression of ObjC pointer type, check whether it was immediately loaded from an ARC __weak ...
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
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.
An l-value expression is a reference to an object with independent storage.
A trivial tuple used to represent a source range.
void EmitObjCAtTryStmt(const ObjCAtTryStmt &S)
LValue - This represents an lvalue references.
An abstract representation of regular/ObjC call/message targets.
ObjCMethodDecl * getGetterMethodDecl() const
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
const LangOptions & getLangOpts() const
The receiver is a superclass.
llvm::Constant * objc_retainAutoreleaseReturnValue
id objc_retainAutoreleaseReturnValue(id);
void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S)
SourceLocation getBegin() const
CallArgList - Type for representing both the value and type of arguments in a call.
Represents Objective-C's @autoreleasepool Statement.
llvm::Value * getPointer() const
SourceLocation getBodyRBrace() const
getBodyRBrace - Gets the right brace of the body, if a body exists.
SourceLocation getLocation() const
void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr)
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
llvm::Value * EmitBuiltinAvailable(ArrayRef< llvm::Value *> Args)
ArrayRef< ParmVarDecl * > parameters() const
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...
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.
llvm::Value * EmitObjCSelectorExpr(const ObjCSelectorExpr *E)
Emit a selector.
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
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.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
const llvm::Triple & getTriple() const