| //===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This provides Objective-C code generation targeting the Apple runtime. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "CGBlocks.h" |
| #include "CGCleanup.h" |
| #include "CGObjCRuntime.h" |
| #include "CGRecordLayout.h" |
| #include "CodeGenFunction.h" |
| #include "CodeGenModule.h" |
| #include "clang/CodeGen/ConstantInitBuilder.h" |
| #include "clang/AST/ASTContext.h" |
| #include "clang/AST/Decl.h" |
| #include "clang/AST/DeclObjC.h" |
| #include "clang/AST/RecordLayout.h" |
| #include "clang/AST/StmtObjC.h" |
| #include "clang/Basic/LangOptions.h" |
| #include "clang/CodeGen/CGFunctionInfo.h" |
| #include "clang/Frontend/CodeGenOptions.h" |
| #include "llvm/ADT/CachedHashString.h" |
| #include "llvm/ADT/DenseSet.h" |
| #include "llvm/ADT/SetVector.h" |
| #include "llvm/ADT/SmallPtrSet.h" |
| #include "llvm/ADT/SmallString.h" |
| #include "llvm/IR/CallSite.h" |
| #include "llvm/IR/DataLayout.h" |
| #include "llvm/IR/InlineAsm.h" |
| #include "llvm/IR/IntrinsicInst.h" |
| #include "llvm/IR/LLVMContext.h" |
| #include "llvm/IR/Module.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include <cstdio> |
| |
| using namespace clang; |
| using namespace CodeGen; |
| |
| namespace { |
| |
| // FIXME: We should find a nicer way to make the labels for metadata, string |
| // concatenation is lame. |
| |
| class ObjCCommonTypesHelper { |
| protected: |
| llvm::LLVMContext &VMContext; |
| |
| private: |
| // The types of these functions don't really matter because we |
| // should always bitcast before calling them. |
| |
| /// id objc_msgSend (id, SEL, ...) |
| /// |
| /// The default messenger, used for sends whose ABI is unchanged from |
| /// the all-integer/pointer case. |
| llvm::Constant *getMessageSendFn() const { |
| // Add the non-lazy-bind attribute, since objc_msgSend is likely to |
| // be called a lot. |
| llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; |
| return CGM.CreateRuntimeFunction( |
| llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend", |
| llvm::AttributeList::get(CGM.getLLVMContext(), |
| llvm::AttributeList::FunctionIndex, |
| llvm::Attribute::NonLazyBind)); |
| } |
| |
| /// void objc_msgSend_stret (id, SEL, ...) |
| /// |
| /// The messenger used when the return value is an aggregate returned |
| /// by indirect reference in the first argument, and therefore the |
| /// self and selector parameters are shifted over by one. |
| llvm::Constant *getMessageSendStretFn() const { |
| llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, |
| params, true), |
| "objc_msgSend_stret"); |
| |
| } |
| |
| /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...) |
| /// |
| /// The messenger used when the return value is returned on the x87 |
| /// floating-point stack; without a special entrypoint, the nil case |
| /// would be unbalanced. |
| llvm::Constant *getMessageSendFpretFn() const { |
| llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy, |
| params, true), |
| "objc_msgSend_fpret"); |
| |
| } |
| |
| /// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...) |
| /// |
| /// The messenger used when the return value is returned in two values on the |
| /// x87 floating point stack; without a special entrypoint, the nil case |
| /// would be unbalanced. Only used on 64-bit X86. |
| llvm::Constant *getMessageSendFp2retFn() const { |
| llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy }; |
| llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext); |
| llvm::Type *resultType = |
| llvm::StructType::get(longDoubleType, longDoubleType); |
| |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType, |
| params, true), |
| "objc_msgSend_fp2ret"); |
| } |
| |
| /// id objc_msgSendSuper(struct objc_super *super, SEL op, ...) |
| /// |
| /// The messenger used for super calls, which have different dispatch |
| /// semantics. The class passed is the superclass of the current |
| /// class. |
| llvm::Constant *getMessageSendSuperFn() const { |
| llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
| params, true), |
| "objc_msgSendSuper"); |
| } |
| |
| /// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...) |
| /// |
| /// A slightly different messenger used for super calls. The class |
| /// passed is the current class. |
| llvm::Constant *getMessageSendSuperFn2() const { |
| llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
| params, true), |
| "objc_msgSendSuper2"); |
| } |
| |
| /// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super, |
| /// SEL op, ...) |
| /// |
| /// The messenger used for super calls which return an aggregate indirectly. |
| llvm::Constant *getMessageSendSuperStretFn() const { |
| llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy }; |
| return CGM.CreateRuntimeFunction( |
| llvm::FunctionType::get(CGM.VoidTy, params, true), |
| "objc_msgSendSuper_stret"); |
| } |
| |
| /// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super, |
| /// SEL op, ...) |
| /// |
| /// objc_msgSendSuper_stret with the super2 semantics. |
| llvm::Constant *getMessageSendSuperStretFn2() const { |
| llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy }; |
| return CGM.CreateRuntimeFunction( |
| llvm::FunctionType::get(CGM.VoidTy, params, true), |
| "objc_msgSendSuper2_stret"); |
| } |
| |
| llvm::Constant *getMessageSendSuperFpretFn() const { |
| // There is no objc_msgSendSuper_fpret? How can that work? |
| return getMessageSendSuperFn(); |
| } |
| |
| llvm::Constant *getMessageSendSuperFpretFn2() const { |
| // There is no objc_msgSendSuper_fpret? How can that work? |
| return getMessageSendSuperFn2(); |
| } |
| |
| protected: |
| CodeGen::CodeGenModule &CGM; |
| |
| public: |
| llvm::IntegerType *ShortTy, *IntTy, *LongTy; |
| llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy; |
| llvm::Type *IvarOffsetVarTy; |
| |
| /// ObjectPtrTy - LLVM type for object handles (typeof(id)) |
| llvm::PointerType *ObjectPtrTy; |
| |
| /// PtrObjectPtrTy - LLVM type for id * |
| llvm::PointerType *PtrObjectPtrTy; |
| |
| /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL)) |
| llvm::PointerType *SelectorPtrTy; |
| |
| private: |
| /// ProtocolPtrTy - LLVM type for external protocol handles |
| /// (typeof(Protocol)) |
| llvm::Type *ExternalProtocolPtrTy; |
| |
| public: |
| llvm::Type *getExternalProtocolPtrTy() { |
| if (!ExternalProtocolPtrTy) { |
| // FIXME: It would be nice to unify this with the opaque type, so that the |
| // IR comes out a bit cleaner. |
| CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
| ASTContext &Ctx = CGM.getContext(); |
| llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType()); |
| ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T); |
| } |
| |
| return ExternalProtocolPtrTy; |
| } |
| |
| // SuperCTy - clang type for struct objc_super. |
| QualType SuperCTy; |
| // SuperPtrCTy - clang type for struct objc_super *. |
| QualType SuperPtrCTy; |
| |
| /// SuperTy - LLVM type for struct objc_super. |
| llvm::StructType *SuperTy; |
| /// SuperPtrTy - LLVM type for struct objc_super *. |
| llvm::PointerType *SuperPtrTy; |
| |
| /// PropertyTy - LLVM type for struct objc_property (struct _prop_t |
| /// in GCC parlance). |
| llvm::StructType *PropertyTy; |
| |
| /// PropertyListTy - LLVM type for struct objc_property_list |
| /// (_prop_list_t in GCC parlance). |
| llvm::StructType *PropertyListTy; |
| /// PropertyListPtrTy - LLVM type for struct objc_property_list*. |
| llvm::PointerType *PropertyListPtrTy; |
| |
| // MethodTy - LLVM type for struct objc_method. |
| llvm::StructType *MethodTy; |
| |
| /// CacheTy - LLVM type for struct objc_cache. |
| llvm::Type *CacheTy; |
| /// CachePtrTy - LLVM type for struct objc_cache *. |
| llvm::PointerType *CachePtrTy; |
| |
| llvm::Constant *getGetPropertyFn() { |
| CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
| ASTContext &Ctx = CGM.getContext(); |
| // id objc_getProperty (id, SEL, ptrdiff_t, bool) |
| CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType()); |
| CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType()); |
| CanQualType Params[] = { |
| IdType, SelType, |
| Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), Ctx.BoolTy}; |
| llvm::FunctionType *FTy = |
| Types.GetFunctionType( |
| Types.arrangeBuiltinFunctionDeclaration(IdType, Params)); |
| return CGM.CreateRuntimeFunction(FTy, "objc_getProperty"); |
| } |
| |
| llvm::Constant *getSetPropertyFn() { |
| CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
| ASTContext &Ctx = CGM.getContext(); |
| // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool) |
| CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType()); |
| CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType()); |
| CanQualType Params[] = { |
| IdType, |
| SelType, |
| Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), |
| IdType, |
| Ctx.BoolTy, |
| Ctx.BoolTy}; |
| llvm::FunctionType *FTy = |
| Types.GetFunctionType( |
| Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); |
| return CGM.CreateRuntimeFunction(FTy, "objc_setProperty"); |
| } |
| |
| llvm::Constant *getOptimizedSetPropertyFn(bool atomic, bool copy) { |
| CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
| ASTContext &Ctx = CGM.getContext(); |
| // void objc_setProperty_atomic(id self, SEL _cmd, |
| // id newValue, ptrdiff_t offset); |
| // void objc_setProperty_nonatomic(id self, SEL _cmd, |
| // id newValue, ptrdiff_t offset); |
| // void objc_setProperty_atomic_copy(id self, SEL _cmd, |
| // id newValue, ptrdiff_t offset); |
| // void objc_setProperty_nonatomic_copy(id self, SEL _cmd, |
| // id newValue, ptrdiff_t offset); |
| |
| SmallVector<CanQualType,4> Params; |
| CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType()); |
| CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType()); |
| Params.push_back(IdType); |
| Params.push_back(SelType); |
| Params.push_back(IdType); |
| Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified()); |
| llvm::FunctionType *FTy = |
| Types.GetFunctionType( |
| Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); |
| const char *name; |
| if (atomic && copy) |
| name = "objc_setProperty_atomic_copy"; |
| else if (atomic && !copy) |
| name = "objc_setProperty_atomic"; |
| else if (!atomic && copy) |
| name = "objc_setProperty_nonatomic_copy"; |
| else |
| name = "objc_setProperty_nonatomic"; |
| |
| return CGM.CreateRuntimeFunction(FTy, name); |
| } |
| |
| llvm::Constant *getCopyStructFn() { |
| CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
| ASTContext &Ctx = CGM.getContext(); |
| // void objc_copyStruct (void *, const void *, size_t, bool, bool) |
| SmallVector<CanQualType,5> Params; |
| Params.push_back(Ctx.VoidPtrTy); |
| Params.push_back(Ctx.VoidPtrTy); |
| Params.push_back(Ctx.getSizeType()); |
| Params.push_back(Ctx.BoolTy); |
| Params.push_back(Ctx.BoolTy); |
| llvm::FunctionType *FTy = |
| Types.GetFunctionType( |
| Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); |
| return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct"); |
| } |
| |
| /// This routine declares and returns address of: |
| /// void objc_copyCppObjectAtomic( |
| /// void *dest, const void *src, |
| /// void (*copyHelper) (void *dest, const void *source)); |
| llvm::Constant *getCppAtomicObjectFunction() { |
| CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
| ASTContext &Ctx = CGM.getContext(); |
| /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper); |
| SmallVector<CanQualType,3> Params; |
| Params.push_back(Ctx.VoidPtrTy); |
| Params.push_back(Ctx.VoidPtrTy); |
| Params.push_back(Ctx.VoidPtrTy); |
| llvm::FunctionType *FTy = |
| Types.GetFunctionType( |
| Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); |
| return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic"); |
| } |
| |
| llvm::Constant *getEnumerationMutationFn() { |
| CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
| ASTContext &Ctx = CGM.getContext(); |
| // void objc_enumerationMutation (id) |
| SmallVector<CanQualType,1> Params; |
| Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType())); |
| llvm::FunctionType *FTy = |
| Types.GetFunctionType( |
| Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params)); |
| return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation"); |
| } |
| |
| llvm::Constant *getLookUpClassFn() { |
| CodeGen::CodeGenTypes &Types = CGM.getTypes(); |
| ASTContext &Ctx = CGM.getContext(); |
| // Class objc_lookUpClass (const char *) |
| SmallVector<CanQualType,1> Params; |
| Params.push_back( |
| Ctx.getCanonicalType(Ctx.getPointerType(Ctx.CharTy.withConst()))); |
| llvm::FunctionType *FTy = |
| Types.GetFunctionType(Types.arrangeBuiltinFunctionDeclaration( |
| Ctx.getCanonicalType(Ctx.getObjCClassType()), |
| Params)); |
| return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass"); |
| } |
| |
| /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function. |
| llvm::Constant *getGcReadWeakFn() { |
| // id objc_read_weak (id *) |
| llvm::Type *args[] = { ObjectPtrTy->getPointerTo() }; |
| llvm::FunctionType *FTy = |
| llvm::FunctionType::get(ObjectPtrTy, args, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_read_weak"); |
| } |
| |
| /// GcAssignWeakFn -- LLVM objc_assign_weak function. |
| llvm::Constant *getGcAssignWeakFn() { |
| // id objc_assign_weak (id, id *) |
| llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; |
| llvm::FunctionType *FTy = |
| llvm::FunctionType::get(ObjectPtrTy, args, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak"); |
| } |
| |
| /// GcAssignGlobalFn -- LLVM objc_assign_global function. |
| llvm::Constant *getGcAssignGlobalFn() { |
| // id objc_assign_global(id, id *) |
| llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; |
| llvm::FunctionType *FTy = |
| llvm::FunctionType::get(ObjectPtrTy, args, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_assign_global"); |
| } |
| |
| /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function. |
| llvm::Constant *getGcAssignThreadLocalFn() { |
| // id objc_assign_threadlocal(id src, id * dest) |
| llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; |
| llvm::FunctionType *FTy = |
| llvm::FunctionType::get(ObjectPtrTy, args, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal"); |
| } |
| |
| /// GcAssignIvarFn -- LLVM objc_assign_ivar function. |
| llvm::Constant *getGcAssignIvarFn() { |
| // id objc_assign_ivar(id, id *, ptrdiff_t) |
| llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(), |
| CGM.PtrDiffTy }; |
| llvm::FunctionType *FTy = |
| llvm::FunctionType::get(ObjectPtrTy, args, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar"); |
| } |
| |
| /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function. |
| llvm::Constant *GcMemmoveCollectableFn() { |
| // void *objc_memmove_collectable(void *dst, const void *src, size_t size) |
| llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy }; |
| llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable"); |
| } |
| |
| /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function. |
| llvm::Constant *getGcAssignStrongCastFn() { |
| // id objc_assign_strongCast(id, id *) |
| llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() }; |
| llvm::FunctionType *FTy = |
| llvm::FunctionType::get(ObjectPtrTy, args, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast"); |
| } |
| |
| /// ExceptionThrowFn - LLVM objc_exception_throw function. |
| llvm::Constant *getExceptionThrowFn() { |
| // void objc_exception_throw(id) |
| llvm::Type *args[] = { ObjectPtrTy }; |
| llvm::FunctionType *FTy = |
| llvm::FunctionType::get(CGM.VoidTy, args, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw"); |
| } |
| |
| /// ExceptionRethrowFn - LLVM objc_exception_rethrow function. |
| llvm::Constant *getExceptionRethrowFn() { |
| // void objc_exception_rethrow(void) |
| llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow"); |
| } |
| |
| /// SyncEnterFn - LLVM object_sync_enter function. |
| llvm::Constant *getSyncEnterFn() { |
| // int objc_sync_enter (id) |
| llvm::Type *args[] = { ObjectPtrTy }; |
| llvm::FunctionType *FTy = |
| llvm::FunctionType::get(CGM.IntTy, args, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter"); |
| } |
| |
| /// SyncExitFn - LLVM object_sync_exit function. |
| llvm::Constant *getSyncExitFn() { |
| // int objc_sync_exit (id) |
| llvm::Type *args[] = { ObjectPtrTy }; |
| llvm::FunctionType *FTy = |
| llvm::FunctionType::get(CGM.IntTy, args, false); |
| return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit"); |
| } |
| |
| llvm::Constant *getSendFn(bool IsSuper) const { |
| return IsSuper ? getMessageSendSuperFn() : getMessageSendFn(); |
| } |
| |
| llvm::Constant *getSendFn2(bool IsSuper) const { |
| return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn(); |
| } |
| |
| llvm::Constant *getSendStretFn(bool IsSuper) const { |
| return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn(); |
| } |
| |
| llvm::Constant *getSendStretFn2(bool IsSuper) const { |
| return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn(); |
| } |
| |
| llvm::Constant *getSendFpretFn(bool IsSuper) const { |
| return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn(); |
| } |
| |
| llvm::Constant *getSendFpretFn2(bool IsSuper) const { |
| return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn(); |
| } |
| |
| llvm::Constant *getSendFp2retFn(bool IsSuper) const { |
| return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn(); |
| } |
| |
| llvm::Constant *getSendFp2RetFn2(bool IsSuper) const { |
| return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn(); |
| } |
| |
| ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm); |
| }; |
| |
| /// ObjCTypesHelper - Helper class that encapsulates lazy |
| /// construction of varies types used during ObjC generation. |
| class ObjCTypesHelper : public ObjCCommonTypesHelper { |
| public: |
| /// SymtabTy - LLVM type for struct objc_symtab. |
| llvm::StructType *SymtabTy; |
| /// SymtabPtrTy - LLVM type for struct objc_symtab *. |
| llvm::PointerType *SymtabPtrTy; |
| /// ModuleTy - LLVM type for struct objc_module. |
| llvm::StructType *ModuleTy; |
| |
| /// ProtocolTy - LLVM type for struct objc_protocol. |
| llvm::StructType *ProtocolTy; |
| /// ProtocolPtrTy - LLVM type for struct objc_protocol *. |
| llvm::PointerType *ProtocolPtrTy; |
| /// ProtocolExtensionTy - LLVM type for struct |
| /// objc_protocol_extension. |
| llvm::StructType *ProtocolExtensionTy; |
| /// ProtocolExtensionTy - LLVM type for struct |
| /// objc_protocol_extension *. |
| llvm::PointerType *ProtocolExtensionPtrTy; |
| /// MethodDescriptionTy - LLVM type for struct |
| /// objc_method_description. |
| llvm::StructType *MethodDescriptionTy; |
| /// MethodDescriptionListTy - LLVM type for struct |
| /// objc_method_description_list. |
| llvm::StructType *MethodDescriptionListTy; |
| /// MethodDescriptionListPtrTy - LLVM type for struct |
| /// objc_method_description_list *. |
| llvm::PointerType *MethodDescriptionListPtrTy; |
| /// ProtocolListTy - LLVM type for struct objc_property_list. |
| llvm::StructType *ProtocolListTy; |
| /// ProtocolListPtrTy - LLVM type for struct objc_property_list*. |
| llvm::PointerType *ProtocolListPtrTy; |
| /// CategoryTy - LLVM type for struct objc_category. |
| llvm::StructType *CategoryTy; |
| /// ClassTy - LLVM type for struct objc_class. |
| llvm::StructType *ClassTy; |
| /// ClassPtrTy - LLVM type for struct objc_class *. |
| llvm::PointerType *ClassPtrTy; |
| /// ClassExtensionTy - LLVM type for struct objc_class_ext. |
| llvm::StructType *ClassExtensionTy; |
| /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *. |
| llvm::PointerType *ClassExtensionPtrTy; |
| // IvarTy - LLVM type for struct objc_ivar. |
| llvm::StructType *IvarTy; |
| /// IvarListTy - LLVM type for struct objc_ivar_list. |
| llvm::StructType *IvarListTy; |
| /// IvarListPtrTy - LLVM type for struct objc_ivar_list *. |
| llvm::PointerType *IvarListPtrTy; |
| /// MethodListTy - LLVM type for struct objc_method_list. |
| llvm::StructType *MethodListTy; |
| /// MethodListPtrTy - LLVM type for struct objc_method_list *. |
| llvm::PointerType *MethodListPtrTy; |
| |
| /// ExceptionDataTy - LLVM type for struct _objc_exception_data. |
| llvm::StructType *ExceptionDataTy; |
| |
| /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function. |
| llvm::Constant *getExceptionTryEnterFn() { |
| llvm::Type *params[] = { ExceptionDataTy->getPointerTo() }; |
| return CGM.CreateRuntimeFunction( |
| llvm::FunctionType::get(CGM.VoidTy, params, false), |
| "objc_exception_try_enter"); |
| } |
| |
| /// ExceptionTryExitFn - LLVM objc_exception_try_exit function. |
| llvm::Constant *getExceptionTryExitFn() { |
| llvm::Type *params[] = { ExceptionDataTy->getPointerTo() }; |
| return CGM.CreateRuntimeFunction( |
| llvm::FunctionType::get(CGM.VoidTy, params, false), |
| "objc_exception_try_exit"); |
| } |
| |
| /// ExceptionExtractFn - LLVM objc_exception_extract function. |
| llvm::Constant *getExceptionExtractFn() { |
| llvm::Type *params[] = { ExceptionDataTy->getPointerTo() }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
| params, false), |
| "objc_exception_extract"); |
| } |
| |
| /// ExceptionMatchFn - LLVM objc_exception_match function. |
| llvm::Constant *getExceptionMatchFn() { |
| llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy }; |
| return CGM.CreateRuntimeFunction( |
| llvm::FunctionType::get(CGM.Int32Ty, params, false), |
| "objc_exception_match"); |
| } |
| |
| /// SetJmpFn - LLVM _setjmp function. |
| llvm::Constant *getSetJmpFn() { |
| // This is specifically the prototype for x86. |
| llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() }; |
| return CGM.CreateRuntimeFunction( |
| llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp", |
| llvm::AttributeList::get(CGM.getLLVMContext(), |
| llvm::AttributeList::FunctionIndex, |
| llvm::Attribute::NonLazyBind)); |
| } |
| |
| public: |
| ObjCTypesHelper(CodeGen::CodeGenModule &cgm); |
| }; |
| |
| /// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's |
| /// modern abi |
| class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper { |
| public: |
| // MethodListnfABITy - LLVM for struct _method_list_t |
| llvm::StructType *MethodListnfABITy; |
| |
| // MethodListnfABIPtrTy - LLVM for struct _method_list_t* |
| llvm::PointerType *MethodListnfABIPtrTy; |
| |
| // ProtocolnfABITy = LLVM for struct _protocol_t |
| llvm::StructType *ProtocolnfABITy; |
| |
| // ProtocolnfABIPtrTy = LLVM for struct _protocol_t* |
| llvm::PointerType *ProtocolnfABIPtrTy; |
| |
| // ProtocolListnfABITy - LLVM for struct _objc_protocol_list |
| llvm::StructType *ProtocolListnfABITy; |
| |
| // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list* |
| llvm::PointerType *ProtocolListnfABIPtrTy; |
| |
| // ClassnfABITy - LLVM for struct _class_t |
| llvm::StructType *ClassnfABITy; |
| |
| // ClassnfABIPtrTy - LLVM for struct _class_t* |
| llvm::PointerType *ClassnfABIPtrTy; |
| |
| // IvarnfABITy - LLVM for struct _ivar_t |
| llvm::StructType *IvarnfABITy; |
| |
| // IvarListnfABITy - LLVM for struct _ivar_list_t |
| llvm::StructType *IvarListnfABITy; |
| |
| // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t* |
| llvm::PointerType *IvarListnfABIPtrTy; |
| |
| // ClassRonfABITy - LLVM for struct _class_ro_t |
| llvm::StructType *ClassRonfABITy; |
| |
| // ImpnfABITy - LLVM for id (*)(id, SEL, ...) |
| llvm::PointerType *ImpnfABITy; |
| |
| // CategorynfABITy - LLVM for struct _category_t |
| llvm::StructType *CategorynfABITy; |
| |
| // New types for nonfragile abi messaging. |
| |
| // MessageRefTy - LLVM for: |
| // struct _message_ref_t { |
| // IMP messenger; |
| // SEL name; |
| // }; |
| llvm::StructType *MessageRefTy; |
| // MessageRefCTy - clang type for struct _message_ref_t |
| QualType MessageRefCTy; |
| |
| // MessageRefPtrTy - LLVM for struct _message_ref_t* |
| llvm::Type *MessageRefPtrTy; |
| // MessageRefCPtrTy - clang type for struct _message_ref_t* |
| QualType MessageRefCPtrTy; |
| |
| // SuperMessageRefTy - LLVM for: |
| // struct _super_message_ref_t { |
| // SUPER_IMP messenger; |
| // SEL name; |
| // }; |
| llvm::StructType *SuperMessageRefTy; |
| |
| // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t* |
| llvm::PointerType *SuperMessageRefPtrTy; |
| |
| llvm::Constant *getMessageSendFixupFn() { |
| // id objc_msgSend_fixup(id, struct message_ref_t*, ...) |
| llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
| params, true), |
| "objc_msgSend_fixup"); |
| } |
| |
| llvm::Constant *getMessageSendFpretFixupFn() { |
| // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...) |
| llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
| params, true), |
| "objc_msgSend_fpret_fixup"); |
| } |
| |
| llvm::Constant *getMessageSendStretFixupFn() { |
| // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...) |
| llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
| params, true), |
| "objc_msgSend_stret_fixup"); |
| } |
| |
| llvm::Constant *getMessageSendSuper2FixupFn() { |
| // id objc_msgSendSuper2_fixup (struct objc_super *, |
| // struct _super_message_ref_t*, ...) |
| llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
| params, true), |
| "objc_msgSendSuper2_fixup"); |
| } |
| |
| llvm::Constant *getMessageSendSuper2StretFixupFn() { |
| // id objc_msgSendSuper2_stret_fixup(struct objc_super *, |
| // struct _super_message_ref_t*, ...) |
| llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy, |
| params, true), |
| "objc_msgSendSuper2_stret_fixup"); |
| } |
| |
| llvm::Constant *getObjCEndCatchFn() { |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false), |
| "objc_end_catch"); |
| |
| } |
| |
| llvm::Constant *getObjCBeginCatchFn() { |
| llvm::Type *params[] = { Int8PtrTy }; |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy, |
| params, false), |
| "objc_begin_catch"); |
| } |
| |
| llvm::StructType *EHTypeTy; |
| llvm::Type *EHTypePtrTy; |
| |
| ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm); |
| }; |
| |
| enum class ObjCLabelType { |
| ClassName, |
| MethodVarName, |
| MethodVarType, |
| PropertyName, |
| }; |
| |
| class CGObjCCommonMac : public CodeGen::CGObjCRuntime { |
| public: |
| class SKIP_SCAN { |
| public: |
| unsigned skip; |
| unsigned scan; |
| SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0) |
| : skip(_skip), scan(_scan) {} |
| }; |
| |
| /// opcode for captured block variables layout 'instructions'. |
| /// In the following descriptions, 'I' is the value of the immediate field. |
| /// (field following the opcode). |
| /// |
| enum BLOCK_LAYOUT_OPCODE { |
| /// An operator which affects how the following layout should be |
| /// interpreted. |
| /// I == 0: Halt interpretation and treat everything else as |
| /// a non-pointer. Note that this instruction is equal |
| /// to '\0'. |
| /// I != 0: Currently unused. |
| BLOCK_LAYOUT_OPERATOR = 0, |
| |
| /// The next I+1 bytes do not contain a value of object pointer type. |
| /// Note that this can leave the stream unaligned, meaning that |
| /// subsequent word-size instructions do not begin at a multiple of |
| /// the pointer size. |
| BLOCK_LAYOUT_NON_OBJECT_BYTES = 1, |
| |
| /// The next I+1 words do not contain a value of object pointer type. |
| /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for |
| /// when the required skip quantity is a multiple of the pointer size. |
| BLOCK_LAYOUT_NON_OBJECT_WORDS = 2, |
| |
| /// The next I+1 words are __strong pointers to Objective-C |
| /// objects or blocks. |
| BLOCK_LAYOUT_STRONG = 3, |
| |
| /// The next I+1 words are pointers to __block variables. |
| BLOCK_LAYOUT_BYREF = 4, |
| |
| /// The next I+1 words are __weak pointers to Objective-C |
| /// objects or blocks. |
| BLOCK_LAYOUT_WEAK = 5, |
| |
| /// The next I+1 words are __unsafe_unretained pointers to |
| /// Objective-C objects or blocks. |
| BLOCK_LAYOUT_UNRETAINED = 6 |
| |
| /// The next I+1 words are block or object pointers with some |
| /// as-yet-unspecified ownership semantics. If we add more |
| /// flavors of ownership semantics, values will be taken from |
| /// this range. |
| /// |
| /// This is included so that older tools can at least continue |
| /// processing the layout past such things. |
| //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10, |
| |
| /// All other opcodes are reserved. Halt interpretation and |
| /// treat everything else as opaque. |
| }; |
| |
| class RUN_SKIP { |
| public: |
| enum BLOCK_LAYOUT_OPCODE opcode; |
| CharUnits block_var_bytepos; |
| CharUnits block_var_size; |
| RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR, |
| CharUnits BytePos = CharUnits::Zero(), |
| CharUnits Size = CharUnits::Zero()) |
| : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {} |
| |
| // Allow sorting based on byte pos. |
| bool operator<(const RUN_SKIP &b) const { |
| return block_var_bytepos < b.block_var_bytepos; |
| } |
| }; |
| |
| protected: |
| llvm::LLVMContext &VMContext; |
| // FIXME! May not be needing this after all. |
| unsigned ObjCABI; |
| |
| // arc/mrr layout of captured block literal variables. |
| SmallVector<RUN_SKIP, 16> RunSkipBlockVars; |
| |
| /// LazySymbols - Symbols to generate a lazy reference for. See |
| /// DefinedSymbols and FinishModule(). |
| llvm::SetVector<IdentifierInfo*> LazySymbols; |
| |
| /// DefinedSymbols - External symbols which are defined by this |
| /// module. The symbols in this list and LazySymbols are used to add |
| /// special linker symbols which ensure that Objective-C modules are |
| /// linked properly. |
| llvm::SetVector<IdentifierInfo*> DefinedSymbols; |
| |
| /// ClassNames - uniqued class names. |
| llvm::StringMap<llvm::GlobalVariable*> ClassNames; |
| |
| /// MethodVarNames - uniqued method variable names. |
| llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames; |
| |
| /// DefinedCategoryNames - list of category names in form Class_Category. |
| llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames; |
| |
| /// MethodVarTypes - uniqued method type signatures. We have to use |
| /// a StringMap here because have no other unique reference. |
| llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes; |
| |
| /// MethodDefinitions - map of methods which have been defined in |
| /// this translation unit. |
| llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions; |
| |
| /// PropertyNames - uniqued method variable names. |
| llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames; |
| |
| /// ClassReferences - uniqued class references. |
| llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences; |
| |
| /// SelectorReferences - uniqued selector references. |
| llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences; |
| |
| /// Protocols - Protocols for which an objc_protocol structure has |
| /// been emitted. Forward declarations are handled by creating an |
| /// empty structure whose initializer is filled in when/if defined. |
| llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols; |
| |
| /// DefinedProtocols - Protocols which have actually been |
| /// defined. We should not need this, see FIXME in GenerateProtocol. |
| llvm::DenseSet<IdentifierInfo*> DefinedProtocols; |
| |
| /// DefinedClasses - List of defined classes. |
| SmallVector<llvm::GlobalValue*, 16> DefinedClasses; |
| |
| /// ImplementedClasses - List of @implemented classes. |
| SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses; |
| |
| /// DefinedNonLazyClasses - List of defined "non-lazy" classes. |
| SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses; |
| |
| /// DefinedCategories - List of defined categories. |
| SmallVector<llvm::GlobalValue*, 16> DefinedCategories; |
| |
| /// DefinedNonLazyCategories - List of defined "non-lazy" categories. |
| SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories; |
| |
| /// Cached reference to the class for constant strings. This value has type |
| /// int * but is actually an Obj-C class pointer. |
| llvm::WeakTrackingVH ConstantStringClassRef; |
| |
| /// \brief The LLVM type corresponding to NSConstantString. |
| llvm::StructType *NSConstantStringType = nullptr; |
| |
| llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap; |
| |
| /// GetNameForMethod - Return a name for the given method. |
| /// \param[out] NameOut - The return value. |
| void GetNameForMethod(const ObjCMethodDecl *OMD, |
| const ObjCContainerDecl *CD, |
| SmallVectorImpl<char> &NameOut); |
| |
| /// GetMethodVarName - Return a unique constant for the given |
| /// selector's name. The return value has type char *. |
| llvm::Constant *GetMethodVarName(Selector Sel); |
| llvm::Constant *GetMethodVarName(IdentifierInfo *Ident); |
| |
| /// GetMethodVarType - Return a unique constant for the given |
| /// method's type encoding string. The return value has type char *. |
| |
| // FIXME: This is a horrible name. |
| llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D, |
| bool Extended = false); |
| llvm::Constant *GetMethodVarType(const FieldDecl *D); |
| |
| /// GetPropertyName - Return a unique constant for the given |
| /// name. The return value has type char *. |
| llvm::Constant *GetPropertyName(IdentifierInfo *Ident); |
| |
| // FIXME: This can be dropped once string functions are unified. |
| llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD, |
| const Decl *Container); |
| |
| /// GetClassName - Return a unique constant for the given selector's |
| /// runtime name (which may change via use of objc_runtime_name attribute on |
| /// class or protocol definition. The return value has type char *. |
| llvm::Constant *GetClassName(StringRef RuntimeName); |
| |
| llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD); |
| |
| /// BuildIvarLayout - Builds ivar layout bitmap for the class |
| /// implementation for the __strong or __weak case. |
| /// |
| /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there |
| /// are any weak ivars defined directly in the class. Meaningless unless |
| /// building a weak layout. Does not guarantee that the layout will |
| /// actually have any entries, because the ivar might be under-aligned. |
| llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI, |
| CharUnits beginOffset, |
| CharUnits endOffset, |
| bool forStrongLayout, |
| bool hasMRCWeakIvars); |
| |
| llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI, |
| CharUnits beginOffset, |
| CharUnits endOffset) { |
| return BuildIvarLayout(OI, beginOffset, endOffset, true, false); |
| } |
| |
| llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI, |
| CharUnits beginOffset, |
| CharUnits endOffset, |
| bool hasMRCWeakIvars) { |
| return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars); |
| } |
| |
| Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout); |
| |
| void UpdateRunSkipBlockVars(bool IsByref, |
| Qualifiers::ObjCLifetime LifeTime, |
| CharUnits FieldOffset, |
| CharUnits FieldSize); |
| |
| void BuildRCBlockVarRecordLayout(const RecordType *RT, |
| CharUnits BytePos, bool &HasUnion, |
| bool ByrefLayout=false); |
| |
| void BuildRCRecordLayout(const llvm::StructLayout *RecLayout, |
| const RecordDecl *RD, |
| ArrayRef<const FieldDecl*> RecFields, |
| CharUnits BytePos, bool &HasUnion, |
| bool ByrefLayout); |
| |
| uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout); |
| |
| llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout); |
| |
| /// GetIvarLayoutName - Returns a unique constant for the given |
| /// ivar layout bitmap. |
| llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident, |
| const ObjCCommonTypesHelper &ObjCTypes); |
| |
| /// EmitPropertyList - Emit the given property list. The return |
| /// value has type PropertyListPtrTy. |
| llvm::Constant *EmitPropertyList(Twine Name, |
| const Decl *Container, |
| const ObjCContainerDecl *OCD, |
| const ObjCCommonTypesHelper &ObjCTypes, |
| bool IsClassProperty); |
| |
| /// EmitProtocolMethodTypes - Generate the array of extended method type |
| /// strings. The return value has type Int8PtrPtrTy. |
| llvm::Constant *EmitProtocolMethodTypes(Twine Name, |
| ArrayRef<llvm::Constant*> MethodTypes, |
| const ObjCCommonTypesHelper &ObjCTypes); |
| |
| /// GetProtocolRef - Return a reference to the internal protocol |
| /// description, creating an empty one if it has not been |
| /// defined. The return value has type ProtocolPtrTy. |
| llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD); |
| |
| /// Return a reference to the given Class using runtime calls rather than |
| /// by a symbol reference. |
| llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF, |
| const ObjCInterfaceDecl *ID, |
| ObjCCommonTypesHelper &ObjCTypes); |
| |
| std::string GetSectionName(StringRef Section, StringRef MachOAttributes); |
| |
| public: |
| /// CreateMetadataVar - Create a global variable with internal |
| /// linkage for use by the Objective-C runtime. |
| /// |
| /// This is a convenience wrapper which not only creates the |
| /// variable, but also sets the section and alignment and adds the |
| /// global to the "llvm.used" list. |
| /// |
| /// \param Name - The variable name. |
| /// \param Init - The variable initializer; this is also used to |
| /// define the type of the variable. |
| /// \param Section - The section the variable should go into, or empty. |
| /// \param Align - The alignment for the variable, or 0. |
| /// \param AddToUsed - Whether the variable should be added to |
| /// "llvm.used". |
| llvm::GlobalVariable *CreateMetadataVar(Twine Name, |
| ConstantStructBuilder &Init, |
| StringRef Section, CharUnits Align, |
| bool AddToUsed); |
| llvm::GlobalVariable *CreateMetadataVar(Twine Name, |
| llvm::Constant *Init, |
| StringRef Section, CharUnits Align, |
| bool AddToUsed); |
| |
| llvm::GlobalVariable *CreateCStringLiteral(StringRef Name, |
| ObjCLabelType LabelType, |
| bool ForceNonFragileABI = false, |
| bool NullTerminate = true); |
| |
| protected: |
| CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF, |
| ReturnValueSlot Return, |
| QualType ResultType, |
| llvm::Value *Sel, |
| llvm::Value *Arg0, |
| QualType Arg0Ty, |
| bool IsSuper, |
| const CallArgList &CallArgs, |
| const ObjCMethodDecl *OMD, |
| const ObjCInterfaceDecl *ClassReceiver, |
| const ObjCCommonTypesHelper &ObjCTypes); |
| |
| /// EmitImageInfo - Emit the image info marker used to encode some module |
| /// level information. |
| void EmitImageInfo(); |
| |
| public: |
| CGObjCCommonMac(CodeGen::CodeGenModule &cgm) : |
| CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) { } |
| |
| bool isNonFragileABI() const { |
| return ObjCABI == 2; |
| } |
| |
| ConstantAddress GenerateConstantString(const StringLiteral *SL) override; |
| ConstantAddress GenerateConstantNSString(const StringLiteral *SL); |
| |
| llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD, |
| const ObjCContainerDecl *CD=nullptr) override; |
| |
| void GenerateProtocol(const ObjCProtocolDecl *PD) override; |
| |
| /// GetOrEmitProtocol - Get the protocol object for the given |
| /// declaration, emitting it if necessary. The return value has type |
| /// ProtocolPtrTy. |
| virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0; |
| |
| /// GetOrEmitProtocolRef - Get a forward reference to the protocol |
| /// object for the given declaration, emitting it if needed. These |
| /// forward references will be filled in with empty bodies if no |
| /// definition is seen. The return value has type ProtocolPtrTy. |
| virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0; |
| |
| virtual llvm::Constant *getNSConstantStringClassRef() = 0; |
| |
| llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM, |
| const CGBlockInfo &blockInfo) override; |
| llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM, |
| const CGBlockInfo &blockInfo) override; |
| |
| llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM, |
| QualType T) override; |
| }; |
| |
| namespace { |
| |
| enum class MethodListType { |
| CategoryInstanceMethods, |
| CategoryClassMethods, |
| InstanceMethods, |
| ClassMethods, |
| ProtocolInstanceMethods, |
| ProtocolClassMethods, |
| OptionalProtocolInstanceMethods, |
| OptionalProtocolClassMethods, |
| }; |
| |
| /// A convenience class for splitting the methods of a protocol into |
| /// the four interesting groups. |
| class ProtocolMethodLists { |
| public: |
| enum Kind { |
| RequiredInstanceMethods, |
| RequiredClassMethods, |
| OptionalInstanceMethods, |
| OptionalClassMethods |
| }; |
| enum { |
| NumProtocolMethodLists = 4 |
| }; |
| |
| static MethodListType getMethodListKind(Kind kind) { |
| switch (kind) { |
| case RequiredInstanceMethods: |
| return MethodListType::ProtocolInstanceMethods; |
| case RequiredClassMethods: |
| return MethodListType::ProtocolClassMethods; |
| case OptionalInstanceMethods: |
| return MethodListType::OptionalProtocolInstanceMethods; |
| case OptionalClassMethods: |
| return MethodListType::OptionalProtocolClassMethods; |
| } |
| llvm_unreachable("bad kind"); |
| } |
| |
| SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists]; |
| |
| static ProtocolMethodLists get(const ObjCProtocolDecl *PD) { |
| ProtocolMethodLists result; |
| |
| for (auto MD : PD->methods()) { |
| size_t index = (2 * size_t(MD->isOptional())) |
| + (size_t(MD->isClassMethod())); |
| result.Methods[index].push_back(MD); |
| } |
| |
| return result; |
| } |
| |
| template <class Self> |
| SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const { |
| // In both ABIs, the method types list is parallel with the |
| // concatenation of the methods arrays in the following order: |
| // instance methods |
| // class methods |
| // optional instance methods |
| // optional class methods |
| SmallVector<llvm::Constant*, 8> result; |
| |
| // Methods is already in the correct order for both ABIs. |
| for (auto &list : Methods) { |
| for (auto MD : list) { |
| result.push_back(self->GetMethodVarType(MD, true)); |
| } |
| } |
| |
| return result; |
| } |
| |
| template <class Self> |
| llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD, |
| Kind kind) const { |
| return self->emitMethodList(PD->getObjCRuntimeNameAsString(), |
| getMethodListKind(kind), Methods[kind]); |
| } |
| }; |
| |
| } // end anonymous namespace |
| |
| class CGObjCMac : public CGObjCCommonMac { |
| private: |
| friend ProtocolMethodLists; |
| |
| ObjCTypesHelper ObjCTypes; |
| |
| /// EmitModuleInfo - Another marker encoding module level |
| /// information. |
| void EmitModuleInfo(); |
| |
| /// EmitModuleSymols - Emit module symbols, the list of defined |
| /// classes and categories. The result has type SymtabPtrTy. |
| llvm::Constant *EmitModuleSymbols(); |
| |
| /// FinishModule - Write out global data structures at the end of |
| /// processing a translation unit. |
| void FinishModule(); |
| |
| /// EmitClassExtension - Generate the class extension structure used |
| /// to store the weak ivar layout and properties. The return value |
| /// has type ClassExtensionPtrTy. |
| llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID, |
| CharUnits instanceSize, |
| bool hasMRCWeakIvars, |
| bool isMetaclass); |
| |
| /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, |
| /// for the given class. |
| llvm::Value *EmitClassRef(CodeGenFunction &CGF, |
| const ObjCInterfaceDecl *ID); |
| |
| llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF, |
| IdentifierInfo *II); |
| |
| llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; |
| |
| /// EmitSuperClassRef - Emits reference to class's main metadata class. |
| llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID); |
| |
| /// EmitIvarList - Emit the ivar list for the given |
| /// implementation. If ForClass is true the list of class ivars |
| /// (i.e. metaclass ivars) is emitted, otherwise the list of |
| /// interface ivars will be emitted. The return value has type |
| /// IvarListPtrTy. |
| llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID, |
| bool ForClass); |
| |
| /// EmitMetaClass - Emit a forward reference to the class structure |
| /// for the metaclass of the given interface. The return value has |
| /// type ClassPtrTy. |
| llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID); |
| |
| /// EmitMetaClass - Emit a class structure for the metaclass of the |
| /// given implementation. The return value has type ClassPtrTy. |
| llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID, |
| llvm::Constant *Protocols, |
| ArrayRef<const ObjCMethodDecl *> Methods); |
| |
| void emitMethodConstant(ConstantArrayBuilder &builder, |
| const ObjCMethodDecl *MD); |
| |
| void emitMethodDescriptionConstant(ConstantArrayBuilder &builder, |
| const ObjCMethodDecl *MD); |
| |
| /// EmitMethodList - Emit the method list for the given |
| /// implementation. The return value has type MethodListPtrTy. |
| llvm::Constant *emitMethodList(Twine Name, MethodListType MLT, |
| ArrayRef<const ObjCMethodDecl *> Methods); |
| |
| /// GetOrEmitProtocol - Get the protocol object for the given |
| /// declaration, emitting it if necessary. The return value has type |
| /// ProtocolPtrTy. |
| llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override; |
| |
| /// GetOrEmitProtocolRef - Get a forward reference to the protocol |
| /// object for the given declaration, emitting it if needed. These |
| /// forward references will be filled in with empty bodies if no |
| /// definition is seen. The return value has type ProtocolPtrTy. |
| llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override; |
| |
| /// EmitProtocolExtension - Generate the protocol extension |
| /// structure used to store optional instance and class methods, and |
| /// protocol properties. The return value has type |
| /// ProtocolExtensionPtrTy. |
| llvm::Constant * |
| EmitProtocolExtension(const ObjCProtocolDecl *PD, |
| const ProtocolMethodLists &methodLists); |
| |
| /// EmitProtocolList - Generate the list of referenced |
| /// protocols. The return value has type ProtocolListPtrTy. |
| llvm::Constant *EmitProtocolList(Twine Name, |
| ObjCProtocolDecl::protocol_iterator begin, |
| ObjCProtocolDecl::protocol_iterator end); |
| |
| /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy, |
| /// for the given selector. |
| llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel); |
| Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel); |
| |
| public: |
| CGObjCMac(CodeGen::CodeGenModule &cgm); |
| |
| llvm::Constant *getNSConstantStringClassRef() override; |
| |
| llvm::Function *ModuleInitFunction() override; |
| |
| CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, |
| ReturnValueSlot Return, |
| QualType ResultType, |
| Selector Sel, llvm::Value *Receiver, |
| const CallArgList &CallArgs, |
| const ObjCInterfaceDecl *Class, |
| const ObjCMethodDecl *Method) override; |
| |
| CodeGen::RValue |
| GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, |
| ReturnValueSlot Return, QualType ResultType, |
| Selector Sel, const ObjCInterfaceDecl *Class, |
| bool isCategoryImpl, llvm::Value *Receiver, |
| bool IsClassMessage, const CallArgList &CallArgs, |
| const ObjCMethodDecl *Method) override; |
| |
| llvm::Value *GetClass(CodeGenFunction &CGF, |
| const ObjCInterfaceDecl *ID) override; |
| |
| llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override; |
| Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override; |
| |
| /// The NeXT/Apple runtimes do not support typed selectors; just emit an |
| /// untyped one. |
| llvm::Value *GetSelector(CodeGenFunction &CGF, |
| const ObjCMethodDecl *Method) override; |
| |
| llvm::Constant *GetEHType(QualType T) override; |
| |
| void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; |
| |
| void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; |
| |
| void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {} |
| |
| llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, |
| const ObjCProtocolDecl *PD) override; |
| |
| llvm::Constant *GetPropertyGetFunction() override; |
| llvm::Constant *GetPropertySetFunction() override; |
| llvm::Constant *GetOptimizedPropertySetFunction(bool atomic, |
| bool copy) override; |
| llvm::Constant *GetGetStructFunction() override; |
| llvm::Constant *GetSetStructFunction() override; |
| llvm::Constant *GetCppAtomicObjectGetFunction() override; |
| llvm::Constant *GetCppAtomicObjectSetFunction() override; |
| llvm::Constant *EnumerationMutationFunction() override; |
| |
| void EmitTryStmt(CodeGen::CodeGenFunction &CGF, |
| const ObjCAtTryStmt &S) override; |
| void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, |
| const ObjCAtSynchronizedStmt &S) override; |
| void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S); |
| void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, |
| bool ClearInsertionPoint=true) override; |
| llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, |
| Address AddrWeakObj) override; |
| void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, |
| llvm::Value *src, Address dst) override; |
| void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, |
| llvm::Value *src, Address dest, |
| bool threadlocal = false) override; |
| void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, |
| llvm::Value *src, Address dest, |
| llvm::Value *ivarOffset) override; |
| void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, |
| llvm::Value *src, Address dest) override; |
| void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, |
| Address dest, Address src, |
| llvm::Value *size) override; |
| |
| LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, |
| llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, |
| unsigned CVRQualifiers) override; |
| llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, |
| const ObjCInterfaceDecl *Interface, |
| const ObjCIvarDecl *Ivar) override; |
| }; |
| |
| class CGObjCNonFragileABIMac : public CGObjCCommonMac { |
| private: |
| friend ProtocolMethodLists; |
| ObjCNonFragileABITypesHelper ObjCTypes; |
| llvm::GlobalVariable* ObjCEmptyCacheVar; |
| llvm::Constant* ObjCEmptyVtableVar; |
| |
| /// SuperClassReferences - uniqued super class references. |
| llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences; |
| |
| /// MetaClassReferences - uniqued meta class references. |
| llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences; |
| |
| /// EHTypeReferences - uniqued class ehtype references. |
| llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences; |
| |
| /// VTableDispatchMethods - List of methods for which we generate |
| /// vtable-based message dispatch. |
| llvm::DenseSet<Selector> VTableDispatchMethods; |
| |
| /// DefinedMetaClasses - List of defined meta-classes. |
| std::vector<llvm::GlobalValue*> DefinedMetaClasses; |
| |
| /// isVTableDispatchedSelector - Returns true if SEL is a |
| /// vtable-based selector. |
| bool isVTableDispatchedSelector(Selector Sel); |
| |
| /// FinishNonFragileABIModule - Write out global data structures at the end of |
| /// processing a translation unit. |
| void FinishNonFragileABIModule(); |
| |
| /// AddModuleClassList - Add the given list of class pointers to the |
| /// module with the provided symbol and section names. |
| void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container, |
| StringRef SymbolName, StringRef SectionName); |
| |
| llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags, |
| unsigned InstanceStart, |
| unsigned InstanceSize, |
| const ObjCImplementationDecl *ID); |
| llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI, |
| bool isMetaclass, |
| llvm::Constant *IsAGV, |
| llvm::Constant *SuperClassGV, |
| llvm::Constant *ClassRoGV, |
| bool HiddenVisibility); |
| |
| void emitMethodConstant(ConstantArrayBuilder &builder, |
| const ObjCMethodDecl *MD, |
| bool forProtocol); |
| |
| /// Emit the method list for the given implementation. The return value |
| /// has type MethodListnfABITy. |
| llvm::Constant *emitMethodList(Twine Name, MethodListType MLT, |
| ArrayRef<const ObjCMethodDecl *> Methods); |
| |
| /// EmitIvarList - Emit the ivar list for the given |
| /// implementation. If ForClass is true the list of class ivars |
| /// (i.e. metaclass ivars) is emitted, otherwise the list of |
| /// interface ivars will be emitted. The return value has type |
| /// IvarListnfABIPtrTy. |
| llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID); |
| |
| llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID, |
| const ObjCIvarDecl *Ivar, |
| unsigned long int offset); |
| |
| /// GetOrEmitProtocol - Get the protocol object for the given |
| /// declaration, emitting it if necessary. The return value has type |
| /// ProtocolPtrTy. |
| llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override; |
| |
| /// GetOrEmitProtocolRef - Get a forward reference to the protocol |
| /// object for the given declaration, emitting it if needed. These |
| /// forward references will be filled in with empty bodies if no |
| /// definition is seen. The return value has type ProtocolPtrTy. |
| llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override; |
| |
| /// EmitProtocolList - Generate the list of referenced |
| /// protocols. The return value has type ProtocolListPtrTy. |
| llvm::Constant *EmitProtocolList(Twine Name, |
| ObjCProtocolDecl::protocol_iterator begin, |
| ObjCProtocolDecl::protocol_iterator end); |
| |
| CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF, |
| ReturnValueSlot Return, |
| QualType ResultType, |
| Selector Sel, |
| llvm::Value *Receiver, |
| QualType Arg0Ty, |
| bool IsSuper, |
| const CallArgList &CallArgs, |
| const ObjCMethodDecl *Method); |
| |
| /// GetClassGlobal - Return the global variable for the Objective-C |
| /// class of the given name. |
| llvm::Constant *GetClassGlobal(StringRef Name, |
| ForDefinition_t IsForDefinition, |
| bool Weak = false, bool DLLImport = false); |
| llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID, |
| bool isMetaclass, |
| ForDefinition_t isForDefinition); |
| |
| /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, |
| /// for the given class reference. |
| llvm::Value *EmitClassRef(CodeGenFunction &CGF, |
| const ObjCInterfaceDecl *ID); |
| |
| llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF, |
| IdentifierInfo *II, |
| const ObjCInterfaceDecl *ID); |
| |
| llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override; |
| |
| /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy, |
| /// for the given super class reference. |
| llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF, |
| const ObjCInterfaceDecl *ID); |
| |
| /// EmitMetaClassRef - Return a Value * of the address of _class_t |
| /// meta-data |
| llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF, |
| const ObjCInterfaceDecl *ID, bool Weak); |
| |
| /// ObjCIvarOffsetVariable - Returns the ivar offset variable for |
| /// the given ivar. |
| /// |
| llvm::GlobalVariable * ObjCIvarOffsetVariable( |
| const ObjCInterfaceDecl *ID, |
| const ObjCIvarDecl *Ivar); |
| |
| /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy, |
| /// for the given selector. |
| llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel); |
| Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel); |
| |
| /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C |
| /// interface. The return value has type EHTypePtrTy. |
| llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID, |
| ForDefinition_t IsForDefinition); |
| |
| StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; } |
| |
| StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; } |
| |
| void GetClassSizeInfo(const ObjCImplementationDecl *OID, |
| uint32_t &InstanceStart, |
| uint32_t &InstanceSize); |
| |
| // Shamelessly stolen from Analysis/CFRefCount.cpp |
| Selector GetNullarySelector(const char* name) const { |
| IdentifierInfo* II = &CGM.getContext().Idents.get(name); |
| return CGM.getContext().Selectors.getSelector(0, &II); |
| } |
| |
| Selector GetUnarySelector(const char* name) const { |
| IdentifierInfo* II = &CGM.getContext().Idents.get(name); |
| return CGM.getContext().Selectors.getSelector(1, &II); |
| } |
| |
| /// ImplementationIsNonLazy - Check whether the given category or |
| /// class implementation is "non-lazy". |
| bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const; |
| |
| bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF, |
| const ObjCIvarDecl *IV) { |
| // Annotate the load as an invariant load iff inside an instance method |
| // and ivar belongs to instance method's class and one of its super class. |
| // This check is needed because the ivar offset is a lazily |
| // initialised value that may depend on objc_msgSend to perform a fixup on |
| // the first message dispatch. |
| // |
| // An additional opportunity to mark the load as invariant arises when the |
| // base of the ivar access is a parameter to an Objective C method. |
| // However, because the parameters are not available in the current |
| // interface, we cannot perform this check. |
| if (const ObjCMethodDecl *MD = |
| dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl)) |
| if (MD->isInstanceMethod()) |
| if (const ObjCInterfaceDecl *ID = MD->getClassInterface()) |
| return IV->getContainingInterface()->isSuperClassOf(ID); |
| return false; |
| } |
| |
| public: |
| CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm); |
| |
| llvm::Constant *getNSConstantStringClassRef() override; |
| |
| llvm::Function *ModuleInitFunction() override; |
| |
| CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, |
| ReturnValueSlot Return, |
| QualType ResultType, Selector Sel, |
| llvm::Value *Receiver, |
| const CallArgList &CallArgs, |
| const ObjCInterfaceDecl *Class, |
| const ObjCMethodDecl *Method) override; |
| |
| CodeGen::RValue |
| GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, |
| ReturnValueSlot Return, QualType ResultType, |
| Selector Sel, const ObjCInterfaceDecl *Class, |
| bool isCategoryImpl, llvm::Value *Receiver, |
| bool IsClassMessage, const CallArgList &CallArgs, |
| const ObjCMethodDecl *Method) override; |
| |
| llvm::Value *GetClass(CodeGenFunction &CGF, |
| const ObjCInterfaceDecl *ID) override; |
| |
| llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override |
| { return EmitSelector(CGF, Sel); } |
| Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override |
| { return EmitSelectorAddr(CGF, Sel); } |
| |
| /// The NeXT/Apple runtimes do not support typed selectors; just emit an |
| /// untyped one. |
| llvm::Value *GetSelector(CodeGenFunction &CGF, |
| const ObjCMethodDecl *Method) override |
| { return EmitSelector(CGF, Method->getSelector()); } |
| |
| void GenerateCategory(const ObjCCategoryImplDecl *CMD) override; |
| |
| void GenerateClass(const ObjCImplementationDecl *ClassDecl) override; |
| |
| void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {} |
| |
| llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF, |
| const ObjCProtocolDecl *PD) override; |
| |
| llvm::Constant *GetEHType(QualType T) override; |
| |
| llvm::Constant *GetPropertyGetFunction() override { |
| return ObjCTypes.getGetPropertyFn(); |
| } |
| llvm::Constant *GetPropertySetFunction() override { |
| return ObjCTypes.getSetPropertyFn(); |
| } |
| |
| llvm::Constant *GetOptimizedPropertySetFunction(bool atomic, |
| bool copy) override { |
| return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy); |
| } |
| |
| llvm::Constant *GetSetStructFunction() override { |
| return ObjCTypes.getCopyStructFn(); |
| } |
| |
| llvm::Constant *GetGetStructFunction() override { |
| return ObjCTypes.getCopyStructFn(); |
| } |
| |
| llvm::Constant *GetCppAtomicObjectSetFunction() override { |
| return ObjCTypes.getCppAtomicObjectFunction(); |
| } |
| |
| llvm::Constant *GetCppAtomicObjectGetFunction() override { |
| return ObjCTypes.getCppAtomicObjectFunction(); |
| } |
| |
| llvm::Constant *EnumerationMutationFunction() override { |
| return ObjCTypes.getEnumerationMutationFn(); |
| } |
| |
| void EmitTryStmt(CodeGen::CodeGenFunction &CGF, |
| const ObjCAtTryStmt &S) override; |
| void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, |
| const ObjCAtSynchronizedStmt &S) override; |
| void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, |
| bool ClearInsertionPoint=true) override; |
| llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, |
| Address AddrWeakObj) override; |
| void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, |
| llvm::Value *src, Address edst) override; |
| void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, |
| llvm::Value *src, Address dest, |
| bool threadlocal = false) override; |
| void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, |
| llvm::Value *src, Address dest, |
| llvm::Value *ivarOffset) override; |
| void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, |
| llvm::Value *src, Address dest) override; |
| void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, |
| Address dest, Address src, |
| llvm::Value *size) override; |
| LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, |
| llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, |
| unsigned CVRQualifiers) override; |
| llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF, |
| const ObjCInterfaceDecl *Interface, |
| const ObjCIvarDecl *Ivar) override; |
| }; |
| |
| /// A helper class for performing the null-initialization of a return |
| /// value. |
| struct NullReturnState { |
| llvm::BasicBlock *NullBB; |
| NullReturnState() : NullBB(nullptr) {} |
| |
| /// Perform a null-check of the given receiver. |
| void init(CodeGenFunction &CGF, llvm::Value *receiver) { |
| // Make blocks for the null-receiver and call edges. |
| NullBB = CGF.createBasicBlock("msgSend.null-receiver"); |
| llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call"); |
| |
| // Check for a null receiver and, if there is one, jump to the |
| // null-receiver block. There's no point in trying to avoid it: |
| // we're always going to put *something* there, because otherwise |
| // we shouldn't have done this null-check in the first place. |
| llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver); |
| CGF.Builder.CreateCondBr(isNull, NullBB, callBB); |
| |
| // Otherwise, start performing the call. |
| CGF.EmitBlock(callBB); |
| } |
| |
| /// Complete the null-return operation. It is valid to call this |
| /// regardless of whether 'init' has been called. |
| RValue complete(CodeGenFunction &CGF, |
| ReturnValueSlot returnSlot, |
| RValue result, |
| QualType resultType, |
| const CallArgList &CallArgs, |
| const ObjCMethodDecl *Method) { |
| // If we never had to do a null-check, just use the raw result. |
| if (!NullBB) return result; |
| |
| // The continuation block. This will be left null if we don't have an |
| // IP, which can happen if the method we're calling is marked noreturn. |
| llvm::BasicBlock *contBB = nullptr; |
| |
| // Finish the call path. |
| llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock(); |
| if (callBB) { |
| contBB = CGF.createBasicBlock("msgSend.cont"); |
| CGF.Builder.CreateBr(contBB); |
| } |
| |
| // Okay, start emitting the null-receiver block. |
| CGF.EmitBlock(NullBB); |
| |
| // Release any consumed arguments we've got. |
| if (Method) { |
| CallArgList::const_iterator I = CallArgs.begin(); |
| for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(), |
| e = Method->param_end(); i != e; ++i, ++I) { |
| const ParmVarDecl *ParamDecl = (*i); |
| if (ParamDecl->hasAttr<NSConsumedAttr>()) { |
| RValue RV = I->RV; |
| assert(RV.isScalar() && |
| "NullReturnState::complete - arg not on object"); |
| CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime); |
| } |
| } |
| } |
| |
| // The phi code below assumes that we haven't needed any control flow yet. |
| assert(CGF.Builder.GetInsertBlock() == NullBB); |
| |
| // If we've got a void return, just jump to the continuation block. |
| if (result.isScalar() && resultType->isVoidType()) { |
| // No jumps required if the message-send was noreturn. |
| if (contBB) CGF.EmitBlock(contBB); |
| return result; |
| } |
| |
| // If we've got a scalar return, build a phi. |
| if (result.isScalar()) { |
| // Derive the null-initialization value. |
| llvm::Constant *null = CGF.CGM.EmitNullConstant(resultType); |
| |
| // If no join is necessary, just flow out. |
| if (!contBB) return RValue::get(null); |
| |
| // Otherwise, build a phi. |
| CGF.EmitBlock(contBB); |
| llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2); |
| phi->addIncoming(result.getScalarVal(), callBB); |
| phi->addIncoming(null, NullBB); |
| return RValue::get(phi); |
| } |
| |
| // If we've got an aggregate return, null the buffer out. |
| // FIXME: maybe we should be doing things differently for all the |
| // cases where the ABI has us returning (1) non-agg values in |
| // memory or (2) agg values in registers. |
| if (result.isAggregate()) { |
| assert(result.isAggregate() && "null init of non-aggregate result?"); |
| if (!returnSlot.isUnused()) |
| CGF.EmitNullInitialization(result.getAggregateAddress(), resultType); |
| if (contBB) CGF.EmitBlock(contBB); |
| return result; |
| } |
| |
| // Complex types. |
| CGF.EmitBlock(contBB); |
| CodeGenFunction::ComplexPairTy callResult = result.getComplexVal(); |
| |
| // Find the scalar type and its zero value. |
| llvm::Type *scalarTy = callResult.first->getType(); |
| llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy); |
| |
| // Build phis for both coordinates. |
| llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2); |
| real->addIncoming(callResult.first, callBB); |
| real->addIncoming(scalarZero, NullBB); |
| llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2); |
| imag->addIncoming(callResult.second, callBB); |
| imag->addIncoming(scalarZero, NullBB); |
| return RValue::getComplex(real, imag); |
| } |
| }; |
| |
| } // end anonymous namespace |
| |
| /* *** Helper Functions *** */ |
| |
| /// getConstantGEP() - Help routine to construct simple GEPs. |
| static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext, |
| llvm::GlobalVariable *C, unsigned idx0, |
| unsigned idx1) { |
| llvm::Value *Idxs[] = { |
| llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0), |
| llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1) |
| }; |
| return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs); |
| } |
| |
| /// hasObjCExceptionAttribute - Return true if this class or any super |
| /// class has the __objc_exception__ attribute. |
| static bool hasObjCExceptionAttribute(ASTContext &Context, |
| const ObjCInterfaceDecl *OID) { |
| if (OID->hasAttr<ObjCExceptionAttr>()) |
| return true; |
| if (const ObjCInterfaceDecl *Super = OID->getSuperClass()) |
| return hasObjCExceptionAttribute(Context, Super); |
| return false; |
| } |
| |
| /* *** CGObjCMac Public Interface *** */ |
| |
| CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm), |
| ObjCTypes(cgm) { |
| ObjCABI = 1; |
| EmitImageInfo(); |
| } |
| |
| /// GetClass - Return a reference to the class for the given interface |
| /// decl. |
| llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF, |
| const ObjCInterfaceDecl *ID) { |
| return EmitClassRef(CGF, ID); |
| } |
| |
| /// GetSelector - Return the pointer to the unique'd string for this selector. |
| llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) { |
| return EmitSelector(CGF, Sel); |
| } |
| Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) { |
| return EmitSelectorAddr(CGF, Sel); |
| } |
| llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl |
| *Method) { |
| return EmitSelector(CGF, Method->getSelector()); |
| } |
| |
| llvm::Constant *CGObjCMac::GetEHType(QualType T) { |
| if (T->isObjCIdType() || |
| T->isObjCQualifiedIdType()) { |
| return CGM.GetAddrOfRTTIDescriptor( |
| CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true); |
| } |
| if (T->isObjCClassType() || |
| T->isObjCQualifiedClassType()) { |
| return CGM.GetAddrOfRTTIDescriptor( |
| CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true); |
| } |
| if (T->isObjCObjectPointerType()) |
| return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true); |
| |
| llvm_unreachable("asking for catch type for ObjC type in fragile runtime"); |
| } |
| |
| /// Generate a constant CFString object. |
| /* |
| struct __builtin_CFString { |
| const int *isa; // point to __CFConstantStringClassReference |
| int flags; |
| const char *str; |
| long length; |
| }; |
| */ |
| |
| /// or Generate a constant NSString object. |
| /* |
| struct __builtin_NSString { |
| const int *isa; // point to __NSConstantStringClassReference |
| const char *str; |
| unsigned int length; |
| }; |
| */ |
| |
| ConstantAddress |
| CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) { |
| return (!CGM.getLangOpts().NoConstantCFStrings |
| ? CGM.GetAddrOfConstantCFString(SL) |
| : GenerateConstantNSString(SL)); |
| } |
| |
| static llvm::StringMapEntry<llvm::GlobalVariable *> & |
| GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map, |
| const StringLiteral *Literal, unsigned &StringLength) { |
| StringRef String = Literal->getString(); |
| StringLength = String.size(); |
| return *Map.insert(std::make_pair(String, nullptr)).first; |
| } |
| |
| llvm::Constant *CGObjCMac::getNSConstantStringClassRef() { |
| if (llvm::Value *V = ConstantStringClassRef) |
| return cast<llvm::Constant>(V); |
| |
| auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass; |
| std::string str = |
| StringClass.empty() ? "_NSConstantStringClassReference" |
| : "_" + StringClass + "ClassReference"; |
| |
| llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0); |
| auto GV = CGM.CreateRuntimeVariable(PTy, str); |
| auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo()); |
| ConstantStringClassRef = V; |
| return V; |
| } |
| |
| llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() { |
| if (llvm::Value *V = ConstantStringClassRef) |
| return cast<llvm::Constant>(V); |
| |
| auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass; |
| std::string str = |
| StringClass.empty() ? "OBJC_CLASS_$_NSConstantString" |
| : "OBJC_CLASS_$_" + StringClass; |
| auto GV = GetClassGlobal(str, NotForDefinition); |
| |
| // Make sure the result is of the correct type. |
| auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo()); |
| |
| ConstantStringClassRef = V; |
| return V; |
| } |
| |
| ConstantAddress |
| CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) { |
| unsigned StringLength = 0; |
| llvm::StringMapEntry<llvm::GlobalVariable *> &Entry = |
| GetConstantStringEntry(NSConstantStringMap, Literal, StringLength); |
| |
| if (auto *C = Entry.second) |
| return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment())); |
| |
| // If we don't already have it, get _NSConstantStringClassReference. |
| llvm::Constant *Class = getNSConstantStringClassRef(); |
| |
| // If we don't already have it, construct the type for a constant NSString. |
| if (!NSConstantStringType) { |
| NSConstantStringType = |
| llvm::StructType::create({ |
| CGM.Int32Ty->getPointerTo(), |
| CGM.Int8PtrTy, |
| CGM.IntTy |
| }, "struct.__builtin_NSString"); |
| } |
| |
| ConstantInitBuilder Builder(CGM); |
| auto Fields = Builder.beginStruct(NSConstantStringType); |
| |
| // Class pointer. |
| Fields.add(Class); |
| |
| // String pointer. |
| llvm::Constant *C = |
| llvm::ConstantDataArray::getString(VMContext, Entry.first()); |
| |
| llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage; |
| bool isConstant = !CGM.getLangOpts().WritableStrings; |
| |
| auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant, |
| Linkage, C, ".str"); |
| GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); |
| // Don't enforce the target's minimum global alignment, since the only use |
| // of the string is via this class initializer. |
| GV->setAlignment(1); |
| Fields.addBitCast(GV, CGM.Int8PtrTy); |
| |
| // String length. |
| Fields.addInt(CGM.IntTy, StringLength); |
| |
| // The struct. |
| CharUnits Alignment = CGM.getPointerAlign(); |
| GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment, |
| /*constant*/ true, |
| llvm::GlobalVariable::PrivateLinkage); |
| const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip"; |
| const char *NSStringNonFragileABISection = |
| "__DATA,__objc_stringobj,regular,no_dead_strip"; |
| // FIXME. Fix section. |
| GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile() |
| ? NSStringNonFragileABISection |
| : NSStringSection); |
| Entry.second = GV; |
| |
| return ConstantAddress(GV, Alignment); |
| } |
| |
| enum { |
| kCFTaggedObjectID_Integer = (1 << 1) + 1 |
| }; |
| |
| /// Generates a message send where the super is the receiver. This is |
| /// a message send to self with special delivery semantics indicating |
| /// which class's method should be called. |
| CodeGen::RValue |
| CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, |
| ReturnValueSlot Return, |
| QualType ResultType, |
| Selector Sel, |
| const ObjCInterfaceDecl *Class, |
| bool isCategoryImpl, |
| llvm::Value *Receiver, |
| bool IsClassMessage, |
| const CodeGen::CallArgList &CallArgs, |
| const ObjCMethodDecl *Method) { |
| // Create and init a super structure; this is a (receiver, class) |
| // pair we will pass to objc_msgSendSuper. |
| Address ObjCSuper = |
| CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(), |
| "objc_super"); |
| llvm::Value *ReceiverAsObject = |
| CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy); |
| CGF.Builder.CreateStore( |
| ReceiverAsObject, |
| CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero())); |
| |
| // If this is a class message the metaclass is passed as the target. |
| llvm::Value *Target; |
| if (IsClassMessage) { |
| if (isCategoryImpl) { |
| // Message sent to 'super' in a class method defined in a category |
| // implementation requires an odd treatment. |
| // If we are in a class method, we must retrieve the |
| // _metaclass_ for the current class, pointed at by |
| // the class's "isa" pointer. The following assumes that |
| // isa" is the first ivar in a class (which it must be). |
| Target = EmitClassRef(CGF, Class->getSuperClass()); |
| Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0); |
| Target = CGF.Builder.CreateAlignedLoad(Target, CGF.getPointerAlign()); |
| } else { |
| llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class); |
| llvm::Value *SuperPtr = |
| CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1); |
| llvm::Value *Super = |
| CGF.Builder.CreateAlignedLoad(SuperPtr, CGF.getPointerAlign()); |
| Target = Super; |
| } |
| } else if (isCategoryImpl) |
| Target = EmitClassRef(CGF, Class->getSuperClass()); |
| else { |
| llvm::Value *ClassPtr = EmitSuperClassRef(Class); |
| ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1); |
| Target = CGF.Builder.CreateAlignedLoad(ClassPtr, CGF.getPointerAlign()); |
| } |
| // FIXME: We shouldn't need to do this cast, rectify the ASTContext and |
| // ObjCTypes types. |
| llvm::Type *ClassTy = |
| CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType()); |
| Target = CGF.Builder.CreateBitCast(Target, ClassTy); |
| CGF.Builder.CreateStore(Target, |
| CGF.Builder.CreateStructGEP(ObjCSuper, 1, CGF.getPointerSize())); |
| return EmitMessageSend(CGF, Return, ResultType, |
| EmitSelector(CGF, Sel), |
| ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy, |
| true, CallArgs, Method, Class, ObjCTypes); |
| } |
| |
| /// Generate code for a message send expression. |
| CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF, |
| ReturnValueSlot Return, |
| QualType ResultType, |
| Selector Sel, |
| llvm::Value *Receiver, |
| const CallArgList &CallArgs, |
| const ObjCInterfaceDecl *Class, |
| const ObjCMethodDecl *Method) { |
| return EmitMessageSend(CGF, Return, ResultType, |
| EmitSelector(CGF, Sel), |
| Receiver, CGF.getContext().getObjCIdType(), |
| false, CallArgs, Method, Class, ObjCTypes); |
| } |
| |
| static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) { |
| do { |
| if (ID->isWeakImported()) |
| return true; |
| } while ((ID = ID->getSuperClass())); |
| |
| return false; |
| } |
| |
| CodeGen::RValue |
| CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF, |
| ReturnValueSlot Return, |
| QualType ResultType, |
| llvm::Value *Sel, |
| llvm::Value *Arg0, |
| QualType Arg0Ty, |
| bool IsSuper, |
| const CallArgList &CallArgs, |
| const ObjCMethodDecl *Method, |
| const ObjCInterfaceDecl *ClassReceiver, |
| const ObjCCommonTypesHelper &ObjCTypes) { |
| CallArgList ActualArgs; |
| if (!IsSuper) |
| Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy); |
| ActualArgs.add(RValue::get(Arg0), Arg0Ty); |
| ActualArgs.add(RValue::get(Sel), CGF.getContext().getObjCSelType()); |
| ActualArgs.addFrom(CallArgs); |
| |
| // If we're calling a method, use the formal signature. |
| MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs); |
| |
| if (Method) |
| assert(CGM.getContext().getCanonicalType(Method->getReturnType()) == |
| CGM.getContext().getCanonicalType(ResultType) && |
| "Result type mismatch!"); |
| |
| bool ReceiverCanBeNull = true; |
| |
| // Super dispatch assumes that self is non-null; even the messenger |
| // doesn't have a null check internally. |
| if (IsSuper) { |
| ReceiverCanBeNull = false; |
| |
| // If this is a direct dispatch of a class method, check whether the class, |
| // or anything in its hierarchy, was weak-linked. |
| } else if (ClassReceiver && Method && Method->isClassMethod()) { |
| ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver); |
| |
| // If we're emitting a method, and self is const (meaning just ARC, for now), |
| // and the receiver is a load of self, then self is a valid object. |
| } else if (auto CurMethod = |
| dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) { |
| auto Self = CurMethod->getSelfDecl(); |
| if (Self->getType().isConstQualified()) { |
| if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) { |
| llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer(); |
| if (SelfAddr == LI->getPointerOperand()) { |
| ReceiverCanBeNull = false; |
| } |
| } |
| } |
| } |
| |
| bool RequiresNullCheck = false; |
| |
| llvm::Constant *Fn = nullptr; |
| if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) { |
| if (ReceiverCanBeNull) RequiresNullCheck = true; |
| Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper) |
| : ObjCTypes.getSendStretFn(IsSuper); |
| } else if (CGM.ReturnTypeUsesFPRet(ResultType)) { |
| Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper) |
| : ObjCTypes.getSendFpretFn(IsSuper); |
| } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) { |
| Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper) |
| : ObjCTypes.getSendFp2retFn(IsSuper); |
| } else { |
| // arm64 uses objc_msgSend for stret methods and yet null receiver check |
| // must be made for it. |
| if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo)) |
| RequiresNullCheck = true; |
| Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper) |
| : ObjCTypes.getSendFn(IsSuper); |
| } |
| |
| // We don't need to emit a null check to zero out an indirect result if the |
| // result is ignored. |
| if (Return.isUnused()) |
| RequiresNullCheck = false; |
| |
| // Emit a null-check if there's a consumed argument other than the receiver. |
| if (!RequiresNullCheck && CGM.getLangOpts().ObjCAutoRefCount && Method) { |
| for (const auto *ParamDecl : Method->parameters()) { |
| if (ParamDecl->hasAttr<NSConsumedAttr>()) { |
| RequiresNullCheck = true; |
| break; |
| } |
| } |
| } |
| |
| NullReturnState nullReturn; |
| if (RequiresNullCheck) { |
| nullReturn.init(CGF, Arg0); |
| } |
| |
| llvm::Instruction *CallSite; |
| Fn = llvm::ConstantExpr::getBitCast(Fn, MSI.MessengerType); |
| CGCallee Callee = CGCallee::forDirect(Fn); |
| RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs, |
| &CallSite); |
| |
| // Mark the call as noreturn if the method is marked noreturn and the |
| // receiver cannot be null. |
| if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) { |
| llvm::CallSite(CallSite).setDoesNotReturn(); |
| } |
| |
| return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs, |
| RequiresNullCheck ? Method : nullptr); |
| } |
| |
| static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT, |
| bool pointee = false) { |
| // Note that GC qualification applies recursively to C pointer types |
| // that aren't otherwise decorated. This is weird, but it's probably |
| // an intentional workaround to the unreliable placement of GC qualifiers. |
| if (FQT.isObjCGCStrong()) |
| return Qualifiers::Strong; |
| |
| if (FQT.isObjCGCWeak()) |
| return Qualifiers::Weak; |
| |
| if (auto ownership = FQT.getObjCLifetime()) { |
| // Ownership does not apply recursively to C pointer types. |
| if (pointee) return Qualifiers::GCNone; |
| switch (ownership) { |
| case Qualifiers::OCL_Weak: return Qualifiers::Weak; |
| case Qualifiers::OCL_Strong: return Qualifiers::Strong; |
| case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone; |
| case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?"); |
| case Qualifiers::OCL_None: llvm_unreachable("known nonzero"); |
| } |
| llvm_unreachable("bad objc ownership"); |
| } |
| |
| // Treat unqualified retainable pointers as strong. |
| if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType()) |
| return Qualifiers::Strong; |
| |
| // Walk into C pointer types, but only in GC. |
| if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) { |
| if (const PointerType *PT = FQT->getAs<PointerType>()) |
| return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true); |
| } |
| |
| return Qualifiers::GCNone; |
| } |
| |
| namespace { |
| struct IvarInfo { |
| CharUnits Offset; |
| uint64_t SizeInWords; |
| IvarInfo(CharUnits offset, uint64_t sizeInWords) |
| : Offset(offset), SizeInWords(sizeInWords) {} |
| |
| // Allow sorting based on byte pos. |
| bool operator<(const IvarInfo &other) const { |
| return Offset < other.Offset; |
| } |
| }; |
| |
| /// A helper class for building GC layout strings. |
| class IvarLayoutBuilder { |
| CodeGenModule &CGM; |
| |
| /// The start of the layout. Offsets will be relative to this value, |
| /// and entries less than this value will be silently discarded. |
| CharUnits InstanceBegin; |
| |
| /// The end of the layout. Offsets will never exceed this value. |
| CharUnits InstanceEnd; |
| |
| /// Whether we're generating the strong layout or the weak layout. |
| bool ForStrongLayout; |
| |
| /// Whether the offsets in IvarsInfo might be out-of-order. |
| bool IsDisordered = false; |
| |
| llvm::SmallVector<IvarInfo, 8> IvarsInfo; |
| |
| public: |
| IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin, |
| CharUnits instanceEnd, bool forStrongLayout) |
| : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd), |
| ForStrongLayout(forStrongLayout) { |
| } |
| |
| void visitRecord(const RecordType *RT, CharUnits offset); |
| |
| template <class Iterator, class GetOffsetFn> |
| void visitAggregate(Iterator begin, Iterator end, |
| CharUnits aggrOffset, |
| const GetOffsetFn &getOffset); |
| |
| void visitField(const FieldDecl *field, CharUnits offset); |
| |
| /// Add the layout of a block implementation. |
| void visitBlock(const CGBlockInfo &blockInfo); |
| |
| /// Is there any information for an interesting bitmap? |
| bool hasBitmapData() const { return !IvarsInfo.empty(); } |
| |
| llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC, |
| llvm::SmallVectorImpl<unsigned char> &buffer); |
| |
| static void dump(ArrayRef<unsigned char> buffer) { |
| const unsigned char *s = buffer.data(); |
| for (unsigned i = 0, e = buffer.size(); i < e; i++) |
| if (!(s[i] & 0xf0)) |
| printf("0x0%x%s", s[i], s[i] != 0 ? ", " : ""); |
| else |
| printf("0x%x%s", s[i], s[i] != 0 ? ", " : ""); |
| printf("\n"); |
| } |
| }; |
| } // end anonymous namespace |
| |
| llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM, |
| const CGBlockInfo &blockInfo) { |
| |
| llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy); |
| if (CGM.getLangOpts().getGC() == LangOptions::NonGC) |
| return nullPtr; |
| |
| IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize, |
| /*for strong layout*/ true); |
| |
| builder.visitBlock(blockInfo); |
| |
| if (!builder.hasBitmapData()) |
| return nullPtr; |
| |
| llvm::SmallVector<unsigned char, 32> buffer; |
| llvm::Constant *C = builder.buildBitmap(*this, buffer); |
| if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) { |
| printf("\n block variable layout for block: "); |
| builder.dump(buffer); |
| } |
| |
| return C; |
| } |
| |
| void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) { |
| // __isa is the first field in block descriptor and must assume by runtime's |
| // convention that it is GC'able. |
| IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1)); |
| |
| const BlockDecl *blockDecl = blockInfo.getBlockDecl(); |
| |
| // Ignore the optional 'this' capture: C++ objects are not assumed |
| // to be GC'ed. |
| |
| CharUnits lastFieldOffset; |
| |
| // Walk the captured variables. |
| for (const auto &CI : blockDecl->captures()) { |
| const VarDecl *variable = CI.getVariable(); |
| QualType type = variable->getType(); |
| |
| const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable); |
| |
| // Ignore constant captures. |
| if (capture.isConstant()) continue; |
| |
| CharUnits fieldOffset = capture.getOffset(); |
| |
| // Block fields are not necessarily ordered; if we detect that we're |
| // adding them out-of-order, make sure we sort later. |
| if (fieldOffset < lastFieldOffset) |
| IsDisordered = true; |
| lastFieldOffset = fieldOffset; |
| |
| // __block variables are passed by their descriptor address. |
| if (CI.isByRef()) { |
| IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1)); |
| continue; |
| } |
| |
| assert(!type->isArrayType() && "array variable should not be caught"); |
| if (const RecordType *record = type->getAs<RecordType>()) { |
| visitRecord(record, fieldOffset); |
| continue; |
| } |
| |
| Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type); |
| |
| if (GCAttr == Qualifiers::Strong) { |
| assert(CGM.getContext().getTypeSize(type) |
| == CGM.getTarget().getPointerWidth(0)); |
| IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1)); |
| } |
| } |
| } |
| |
| /// getBlockCaptureLifetime - This routine returns life time of the captured |
| /// block variable for the purpose of block layout meta-data generation. FQT is |
| /// the type of the variable captured in the block. |
| Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT, |
| bool ByrefLayout) { |
| // If it has an ownership qualifier, we're done. |
| if (auto lifetime = FQT.getObjCLifetime()) |
| return lifetime; |
| |
| // If it doesn't, and this is ARC, it has no ownership. |
| if (CGM.getLangOpts().ObjCAutoRefCount) |
| return Qualifiers::OCL_None; |
| |
| // In MRC, retainable pointers are owned by non-__block variables. |
| if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType()) |
| return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong; |
| |
| return Qualifiers::OCL_None; |
| } |
| |
| void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref, |
| Qualifiers::ObjCLifetime LifeTime, |
| CharUnits FieldOffset, |
| CharUnits FieldSize) { |
| // __block variables are passed by their descriptor address. |
| if (IsByref) |
| RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset, |
| FieldSize)); |
| else if (LifeTime == Qualifiers::OCL_Strong) |
| RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset, |
| FieldSize)); |
| else if (LifeTime == Qualifiers::OCL_Weak) |
| RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset, |
| FieldSize)); |
| else if (LifeTime == Qualifiers::OCL_ExplicitNone) |
| RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset, |
| FieldSize)); |
| else |
| RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES, |
| FieldOffset, |
| FieldSize)); |
| } |
| |
| void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout, |
| const RecordDecl *RD, |
| ArrayRef<const FieldDecl*> RecFields, |
| CharUnits BytePos, bool &HasUnion, |
| bool ByrefLayout) { |
| bool IsUnion = (RD && RD->isUnion()); |
| CharUnits MaxUnionSize = CharUnits::Zero(); |
| const FieldDecl *MaxField = nullptr; |
| const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr; |
| CharUnits MaxFieldOffset = CharUnits::Zero(); |
| CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero(); |
| |
| if (RecFields.empty()) |
| return; |
| unsigned ByteSizeInBits = CGM.getTarget().getCharWidth(); |
| |
| for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { |
| const FieldDecl *Field = RecFields[i]; |
| // Note that 'i' here is actually the field index inside RD of Field, |
| // although this dependency is hidden. |
| const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD); |
| CharUnits FieldOffset = |
| CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i)); |
| |
| // Skip over unnamed or bitfields |
| if (!Field->getIdentifier() || Field->isBitField()) { |
| LastFieldBitfieldOrUnnamed = Field; |
| LastBitfieldOrUnnamedOffset = FieldOffset; |
| continue; |
| } |
| |
| LastFieldBitfieldOrUnnamed = nullptr; |
| QualType FQT = Field->getType(); |
| if (FQT->isRecordType() || FQT->isUnionType()) { |
| if (FQT->isUnionType()) |
| HasUnion = true; |
| |
| BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(), |
| BytePos + FieldOffset, HasUnion); |
| continue; |
| } |
| |
| if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { |
| const ConstantArrayType *CArray = |
| dyn_cast_or_null<ConstantArrayType>(Array); |
| uint64_t ElCount = CArray->getSize().getZExtValue(); |
| assert(CArray && "only array with known element size is supported"); |
| FQT = CArray->getElementType(); |
| while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { |
| const ConstantArrayType *CArray = |
| dyn_cast_or_null<ConstantArrayType>(Array); |
| ElCount *= CArray->getSize().getZExtValue(); |
| FQT = CArray->getElementType(); |
| } |
| if (FQT->isRecordType() && ElCount) { |
| int OldIndex = RunSkipBlockVars.size() - 1; |
| const RecordType *RT = FQT->getAs<RecordType>(); |
| BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset, |
| HasUnion); |
| |
| // Replicate layout information for each array element. Note that |
| // one element is already done. |
| uint64_t ElIx = 1; |
| for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) { |
| CharUnits Size = CGM.getContext().getTypeSizeInChars(RT); |
| for (int i = OldIndex+1; i <= FirstIndex; ++i) |
| RunSkipBlockVars.push_back( |
| RUN_SKIP(RunSkipBlockVars[i].opcode, |
| RunSkipBlockVars[i].block_var_bytepos + Size*ElIx, |
| RunSkipBlockVars[i].block_var_size)); |
| } |
| continue; |
| } |
| } |
| CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType()); |
| if (IsUnion) { |
| CharUnits UnionIvarSize = FieldSize; |
| if (UnionIvarSize > MaxUnionSize) { |
| MaxUnionSize = UnionIvarSize; |
| MaxField = Field; |
| MaxFieldOffset = FieldOffset; |
| } |
| } else { |
| UpdateRunSkipBlockVars(false, |
| getBlockCaptureLifetime(FQT, ByrefLayout), |
| BytePos + FieldOffset, |
| FieldSize); |
| } |
| } |
| |
| if (LastFieldBitfieldOrUnnamed) { |
| if (LastFieldBitfieldOrUnnamed->isBitField()) { |
| // Last field was a bitfield. Must update the info. |
| uint64_t BitFieldSize |
| = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext()); |
| unsigned UnsSize = (BitFieldSize / ByteSizeInBits) + |
| ((BitFieldSize % ByteSizeInBits) != 0); |
| CharUnits Size = CharUnits::fromQuantity(UnsSize); |
| Size += LastBitfieldOrUnnamedOffset; |
| UpdateRunSkipBlockVars(false, |
| getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(), |
| ByrefLayout), |
| BytePos + LastBitfieldOrUnnamedOffset, |
| Size); |
| } else { |
| assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed"); |
| // Last field was unnamed. Must update skip info. |
| CharUnits FieldSize |
| = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType()); |
| UpdateRunSkipBlockVars(false, |
| getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(), |
| ByrefLayout), |
| BytePos + LastBitfieldOrUnnamedOffset, |
| FieldSize); |
| } |
| } |
| |
| if (MaxField) |
| UpdateRunSkipBlockVars(false, |
| getBlockCaptureLifetime(MaxField->getType(), ByrefLayout), |
| BytePos + MaxFieldOffset, |
| MaxUnionSize); |
| } |
| |
| void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT, |
| CharUnits BytePos, |
| bool &HasUnion, |
| bool ByrefLayout) { |
| const RecordDecl *RD = RT->getDecl(); |
| SmallVector<const FieldDecl*, 16> Fields(RD->fields()); |
| llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0)); |
| const llvm::StructLayout *RecLayout = |
| CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty)); |
| |
| BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout); |
| } |
| |
| /// InlineLayoutInstruction - This routine produce an inline instruction for the |
| /// block variable layout if it can. If not, it returns 0. Rules are as follow: |
| /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world, |
| /// an inline layout of value 0x0000000000000xyz is interpreted as follows: |
| /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by |
| /// y captured object of BLOCK_LAYOUT_BYREF. Followed by |
| /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero |
| /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no |
| /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured. |
| uint64_t CGObjCCommonMac::InlineLayoutInstruction( |
| SmallVectorImpl<unsigned char> &Layout) { |
| uint64_t Result = 0; |
| if (Layout.size() <= 3) { |
| unsigned size = Layout.size(); |
| unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0; |
| unsigned char inst; |
| enum BLOCK_LAYOUT_OPCODE opcode ; |
| switch (size) { |
| case 3: |
| inst = Layout[0]; |
| opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
| if (opcode == BLOCK_LAYOUT_STRONG) |
| strong_word_count = (inst & 0xF)+1; |
| else |
| return 0; |
| inst = Layout[1]; |
| opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
| if (opcode == BLOCK_LAYOUT_BYREF) |
| byref_word_count = (inst & 0xF)+1; |
| else |
| return 0; |
| inst = Layout[2]; |
| opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
| if (opcode == BLOCK_LAYOUT_WEAK) |
| weak_word_count = (inst & 0xF)+1; |
| else |
| return 0; |
| break; |
| |
| case 2: |
| inst = Layout[0]; |
| opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
| if (opcode == BLOCK_LAYOUT_STRONG) { |
| strong_word_count = (inst & 0xF)+1; |
| inst = Layout[1]; |
| opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
| if (opcode == BLOCK_LAYOUT_BYREF) |
| byref_word_count = (inst & 0xF)+1; |
| else if (opcode == BLOCK_LAYOUT_WEAK) |
| weak_word_count = (inst & 0xF)+1; |
| else |
| return 0; |
| } |
| else if (opcode == BLOCK_LAYOUT_BYREF) { |
| byref_word_count = (inst & 0xF)+1; |
| inst = Layout[1]; |
| opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
| if (opcode == BLOCK_LAYOUT_WEAK) |
| weak_word_count = (inst & 0xF)+1; |
| else |
| return 0; |
| } |
| else |
| return 0; |
| break; |
| |
| case 1: |
| inst = Layout[0]; |
| opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
| if (opcode == BLOCK_LAYOUT_STRONG) |
| strong_word_count = (inst & 0xF)+1; |
| else if (opcode == BLOCK_LAYOUT_BYREF) |
| byref_word_count = (inst & 0xF)+1; |
| else if (opcode == BLOCK_LAYOUT_WEAK) |
| weak_word_count = (inst & 0xF)+1; |
| else |
| return 0; |
| break; |
| |
| default: |
| return 0; |
| } |
| |
| // Cannot inline when any of the word counts is 15. Because this is one less |
| // than the actual work count (so 15 means 16 actual word counts), |
| // and we can only display 0 thru 15 word counts. |
| if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16) |
| return 0; |
| |
| unsigned count = |
| (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0); |
| |
| if (size == count) { |
| if (strong_word_count) |
| Result = strong_word_count; |
| Result <<= 4; |
| if (byref_word_count) |
| Result += byref_word_count; |
| Result <<= 4; |
| if (weak_word_count) |
| Result += weak_word_count; |
| } |
| } |
| return Result; |
| } |
| |
| llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) { |
| llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy); |
| if (RunSkipBlockVars.empty()) |
| return nullPtr; |
| unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0); |
| unsigned ByteSizeInBits = CGM.getTarget().getCharWidth(); |
| unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits; |
| |
| // Sort on byte position; captures might not be allocated in order, |
| // and unions can do funny things. |
| llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end()); |
| SmallVector<unsigned char, 16> Layout; |
| |
| unsigned size = RunSkipBlockVars.size(); |
| for (unsigned i = 0; i < size; i++) { |
| enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode; |
| CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos; |
| CharUnits end_byte_pos = start_byte_pos; |
| unsigned j = i+1; |
| while (j < size) { |
| if (opcode == RunSkipBlockVars[j].opcode) { |
| end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos; |
| i++; |
| } |
| else |
| break; |
| } |
| CharUnits size_in_bytes = |
| end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size; |
| if (j < size) { |
| CharUnits gap = |
| RunSkipBlockVars[j].block_var_bytepos - |
| RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size; |
| size_in_bytes += gap; |
| } |
| CharUnits residue_in_bytes = CharUnits::Zero(); |
| if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) { |
| residue_in_bytes = size_in_bytes % WordSizeInBytes; |
| size_in_bytes -= residue_in_bytes; |
| opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS; |
| } |
| |
| unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes; |
| while (size_in_words >= 16) { |
| // Note that value in imm. is one less that the actual |
| // value. So, 0xf means 16 words follow! |
| unsigned char inst = (opcode << 4) | 0xf; |
| Layout.push_back(inst); |
| size_in_words -= 16; |
| } |
| if (size_in_words > 0) { |
| // Note that value in imm. is one less that the actual |
| // value. So, we subtract 1 away! |
| unsigned char inst = (opcode << 4) | (size_in_words-1); |
| Layout.push_back(inst); |
| } |
| if (residue_in_bytes > CharUnits::Zero()) { |
| unsigned char inst = |
| (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1); |
| Layout.push_back(inst); |
| } |
| } |
| |
| while (!Layout.empty()) { |
| unsigned char inst = Layout.back(); |
| enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
| if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS) |
| Layout.pop_back(); |
| else |
| break; |
| } |
| |
| uint64_t Result = InlineLayoutInstruction(Layout); |
| if (Result != 0) { |
| // Block variable layout instruction has been inlined. |
| if (CGM.getLangOpts().ObjCGCBitmapPrint) { |
| if (ComputeByrefLayout) |
| printf("\n Inline BYREF variable layout: "); |
| else |
| printf("\n Inline block variable layout: "); |
| printf("0x0%" PRIx64 "", Result); |
| if (auto numStrong = (Result & 0xF00) >> 8) |
| printf(", BL_STRONG:%d", (int) numStrong); |
| if (auto numByref = (Result & 0x0F0) >> 4) |
| printf(", BL_BYREF:%d", (int) numByref); |
| if (auto numWeak = (Result & 0x00F) >> 0) |
| printf(", BL_WEAK:%d", (int) numWeak); |
| printf(", BL_OPERATOR:0\n"); |
| } |
| return llvm::ConstantInt::get(CGM.IntPtrTy, Result); |
| } |
| |
| unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0; |
| Layout.push_back(inst); |
| std::string BitMap; |
| for (unsigned i = 0, e = Layout.size(); i != e; i++) |
| BitMap += Layout[i]; |
| |
| if (CGM.getLangOpts().ObjCGCBitmapPrint) { |
| if (ComputeByrefLayout) |
| printf("\n Byref variable layout: "); |
| else |
| printf("\n Block variable layout: "); |
| for (unsigned i = 0, e = BitMap.size(); i != e; i++) { |
| unsigned char inst = BitMap[i]; |
| enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4); |
| unsigned delta = 1; |
| switch (opcode |