| //===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This provides Objective-C code generation targeting the Apple runtime. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "CGBlocks.h" | |
| #include "CGCleanup.h" | |
| #include "CGObjCMacConstantLiteralUtil.h" | |
| #include "CGObjCRuntime.h" | |
| #include "CGRecordLayout.h" | |
| #include "CodeGenFunction.h" | |
| #include "CodeGenModule.h" | |
| #include "clang/AST/ASTContext.h" | |
| #include "clang/AST/Attr.h" | |
| #include "clang/AST/Decl.h" | |
| #include "clang/AST/DeclObjC.h" | |
| #include "clang/AST/Mangle.h" | |
| #include "clang/AST/RecordLayout.h" | |
| #include "clang/AST/StmtObjC.h" | |
| #include "clang/Basic/CodeGenOptions.h" | |
| #include "clang/Basic/LangOptions.h" | |
| #include "clang/CodeGen/CodeGenABITypes.h" | |
| #include "clang/CodeGen/ConstantInitBuilder.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/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/ScopedPrinter.h" | |
| #include "llvm/Support/raw_ostream.h" | |
| #include <cstdio> | |
| #include <numeric> | |
| 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee getMessageSendSuperStretFn2() const { | |
| llvm::Type *params[] = {Int8PtrTy, SuperPtrTy, SelectorPtrTy}; | |
| return CGM.CreateRuntimeFunction( | |
| llvm::FunctionType::get(CGM.VoidTy, params, true), | |
| "objc_msgSendSuper2_stret"); | |
| } | |
| llvm::FunctionCallee getMessageSendSuperFpretFn() const { | |
| // There is no objc_msgSendSuper_fpret? How can that work? | |
| return getMessageSendSuperFn(); | |
| } | |
| llvm::FunctionCallee 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::PointerType *Int8PtrProgramASTy; | |
| 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; | |
| // 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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.getCanonicalSizeType()); | |
| 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee getGcReadWeakFn() { | |
| // id objc_read_weak (id *) | |
| llvm::Type *args[] = {CGM.DefaultPtrTy}; | |
| llvm::FunctionType *FTy = llvm::FunctionType::get(ObjectPtrTy, args, false); | |
| return CGM.CreateRuntimeFunction(FTy, "objc_read_weak"); | |
| } | |
| /// GcAssignWeakFn -- LLVM objc_assign_weak function. | |
| llvm::FunctionCallee getGcAssignWeakFn() { | |
| // id objc_assign_weak (id, id *) | |
| llvm::Type *args[] = {ObjectPtrTy, CGM.DefaultPtrTy}; | |
| llvm::FunctionType *FTy = llvm::FunctionType::get(ObjectPtrTy, args, false); | |
| return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak"); | |
| } | |
| /// GcAssignGlobalFn -- LLVM objc_assign_global function. | |
| llvm::FunctionCallee getGcAssignGlobalFn() { | |
| // id objc_assign_global(id, id *) | |
| llvm::Type *args[] = {ObjectPtrTy, CGM.DefaultPtrTy}; | |
| llvm::FunctionType *FTy = llvm::FunctionType::get(ObjectPtrTy, args, false); | |
| return CGM.CreateRuntimeFunction(FTy, "objc_assign_global"); | |
| } | |
| /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function. | |
| llvm::FunctionCallee getGcAssignThreadLocalFn() { | |
| // id objc_assign_threadlocal(id src, id * dest) | |
| llvm::Type *args[] = {ObjectPtrTy, CGM.DefaultPtrTy}; | |
| llvm::FunctionType *FTy = llvm::FunctionType::get(ObjectPtrTy, args, false); | |
| return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal"); | |
| } | |
| /// GcAssignIvarFn -- LLVM objc_assign_ivar function. | |
| llvm::FunctionCallee getGcAssignIvarFn() { | |
| // id objc_assign_ivar(id, id *, ptrdiff_t) | |
| llvm::Type *args[] = {ObjectPtrTy, CGM.DefaultPtrTy, 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::FunctionCallee 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::FunctionCallee getGcAssignStrongCastFn() { | |
| // id objc_assign_strongCast(id, id *) | |
| llvm::Type *args[] = {ObjectPtrTy, CGM.DefaultPtrTy}; | |
| llvm::FunctionType *FTy = llvm::FunctionType::get(ObjectPtrTy, args, false); | |
| return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast"); | |
| } | |
| /// ExceptionThrowFn - LLVM objc_exception_throw function. | |
| llvm::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee getSendFn(bool IsSuper) const { | |
| return IsSuper ? getMessageSendSuperFn() : getMessageSendFn(); | |
| } | |
| llvm::FunctionCallee getSendFn2(bool IsSuper) const { | |
| return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn(); | |
| } | |
| llvm::FunctionCallee getSendStretFn(bool IsSuper) const { | |
| return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn(); | |
| } | |
| llvm::FunctionCallee getSendStretFn2(bool IsSuper) const { | |
| return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn(); | |
| } | |
| llvm::FunctionCallee getSendFpretFn(bool IsSuper) const { | |
| return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn(); | |
| } | |
| llvm::FunctionCallee getSendFpretFn2(bool IsSuper) const { | |
| return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn(); | |
| } | |
| llvm::FunctionCallee getSendFp2retFn(bool IsSuper) const { | |
| return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn(); | |
| } | |
| llvm::FunctionCallee 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::FunctionCallee getExceptionTryEnterFn() { | |
| llvm::Type *params[] = {CGM.DefaultPtrTy}; | |
| return CGM.CreateRuntimeFunction( | |
| llvm::FunctionType::get(CGM.VoidTy, params, false), | |
| "objc_exception_try_enter"); | |
| } | |
| /// ExceptionTryExitFn - LLVM objc_exception_try_exit function. | |
| llvm::FunctionCallee getExceptionTryExitFn() { | |
| llvm::Type *params[] = {CGM.DefaultPtrTy}; | |
| return CGM.CreateRuntimeFunction( | |
| llvm::FunctionType::get(CGM.VoidTy, params, false), | |
| "objc_exception_try_exit"); | |
| } | |
| /// ExceptionExtractFn - LLVM objc_exception_extract function. | |
| llvm::FunctionCallee getExceptionExtractFn() { | |
| llvm::Type *params[] = {CGM.DefaultPtrTy}; | |
| return CGM.CreateRuntimeFunction( | |
| llvm::FunctionType::get(ObjectPtrTy, params, false), | |
| "objc_exception_extract"); | |
| } | |
| /// ExceptionMatchFn - LLVM objc_exception_match function. | |
| llvm::FunctionCallee getExceptionMatchFn() { | |
| llvm::Type *params[] = {ClassPtrTy, ObjectPtrTy}; | |
| return CGM.CreateRuntimeFunction( | |
| llvm::FunctionType::get(CGM.Int32Ty, params, false), | |
| "objc_exception_match"); | |
| } | |
| /// SetJmpFn - LLVM _setjmp function. | |
| llvm::FunctionCallee getSetJmpFn() { | |
| // This is specifically the prototype for x86. | |
| llvm::Type *params[] = {CGM.DefaultPtrTy}; | |
| 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee getObjCEndCatchFn() { | |
| return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false), | |
| "objc_end_catch"); | |
| } | |
| llvm::FunctionCallee getObjCBeginCatchFn() { | |
| llvm::Type *params[] = {Int8PtrTy}; | |
| return CGM.CreateRuntimeFunction( | |
| llvm::FunctionType::get(Int8PtrTy, params, false), "objc_begin_catch"); | |
| } | |
| /// Class objc_loadClassref (void *) | |
| /// | |
| /// Loads from a classref. For Objective-C stub classes, this invokes the | |
| /// initialization callback stored inside the stub. For all other classes | |
| /// this simply dereferences the pointer. | |
| llvm::FunctionCallee getLoadClassrefFn() const { | |
| // Add the non-lazy-bind attribute, since objc_loadClassref is likely to | |
| // be called a lot. | |
| // | |
| // Also it is safe to make it readnone, since we never load or store the | |
| // classref except by calling this function. | |
| llvm::Type *params[] = {Int8PtrPtrTy}; | |
| llvm::LLVMContext &C = CGM.getLLVMContext(); | |
| llvm::AttributeSet AS = llvm::AttributeSet::get( | |
| C, { | |
| llvm::Attribute::get(C, llvm::Attribute::NonLazyBind), | |
| llvm::Attribute::getWithMemoryEffects( | |
| C, llvm::MemoryEffects::none()), | |
| llvm::Attribute::get(C, llvm::Attribute::NoUnwind), | |
| }); | |
| llvm::FunctionCallee F = CGM.CreateRuntimeFunction( | |
| llvm::FunctionType::get(ClassnfABIPtrTy, params, false), | |
| "objc_loadClassref", | |
| llvm::AttributeList::get(CGM.getLLVMContext(), | |
| llvm::AttributeList::FunctionIndex, AS)); | |
| if (!CGM.getTriple().isOSBinFormatCOFF()) | |
| cast<llvm::Function>(F.getCallee()) | |
| ->setLinkage(llvm::Function::ExternalWeakLinkage); | |
| return F; | |
| } | |
| llvm::StructType *EHTypeTy; | |
| llvm::Type *EHTypePtrTy; | |
| ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm); | |
| }; | |
| enum class ObjCLabelType { | |
| ClassName, | |
| MethodVarName, | |
| MethodVarType, | |
| PropertyName, | |
| LayoutBitMap, | |
| }; | |
| using namespace CGObjCMacConstantLiteralUtil; | |
| 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) {} | |
| }; | |
| // clang-format off | |
| /// 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. | |
| }; | |
| // clang-format on | |
| 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; | |
| /// Information about a direct method definition | |
| struct DirectMethodInfo { | |
| llvm::Function | |
| *Implementation; // The true implementation (where body is emitted) | |
| llvm::Function *Thunk; // The nil-check thunk (nullptr if not generated) | |
| DirectMethodInfo(llvm::Function *Impl, llvm::Function *Thunk = nullptr) | |
| : Implementation(Impl), Thunk(Thunk) {} | |
| }; | |
| /// DirectMethodDefinitions - map of direct methods which have been defined in | |
| /// this translation unit. | |
| llvm::DenseMap<const ObjCMethodDecl *, DirectMethodInfo> | |
| DirectMethodDefinitions; | |
| /// MethodSelectorStubs - Map from (selector,class) to stub function. | |
| llvm::DenseMap<std::pair<Selector, StringRef>, llvm::Function *> | |
| MethodSelectorStubs; | |
| /// 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; | |
| /// DefinedStubCategories - List of defined categories on class stubs. | |
| SmallVector<llvm::GlobalValue *, 16> DefinedStubCategories; | |
| /// 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; | |
| llvm::WeakTrackingVH ConstantArrayClassRef; | |
| llvm::WeakTrackingVH ConstantDictionaryClassRef; | |
| llvm::WeakTrackingVH ConstantIntegerNumberClassRef; | |
| llvm::WeakTrackingVH ConstantFloatNumberClassRef; | |
| llvm::WeakTrackingVH ConstantDoubleNumberClassRef; | |
| /// The LLVM type corresponding to NSConstantString. | |
| llvm::StructType *NSConstantStringType = nullptr; | |
| llvm::StructType *NSConstantArrayType = nullptr; | |
| llvm::StructType *NSConstantDictionaryType = nullptr; | |
| llvm::StructType *NSConstantIntegerNumberType = nullptr; | |
| llvm::StructType *NSConstantFloatNumberType = nullptr; | |
| llvm::StructType *NSConstantDoubleNumberType = nullptr; | |
| llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap; | |
| /// Uniqued CF boolean singletons. | |
| llvm::GlobalVariable *DefinedCFBooleanTrue = nullptr; | |
| llvm::GlobalVariable *DefinedCFBooleanFalse = nullptr; | |
| /// Uniqued `NSNumber`s. | |
| llvm::DenseMap<NSConstantNumberMapInfo, llvm::GlobalVariable *> | |
| NSConstantNumberMap; | |
| /// Cached empty collection singletons. | |
| llvm::GlobalVariable *DefinedEmptyNSDictionary = nullptr; | |
| llvm::GlobalVariable *DefinedEmptyNSArray = nullptr; | |
| /// 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); | |
| /// Returns the section name to use for NSNumber integer literals. | |
| static constexpr llvm::StringLiteral GetNSConstantIntegerNumberSectionName() { | |
| return "__DATA,__objc_intobj,regular,no_dead_strip"; | |
| } | |
| /// Returns the section name to use for NSNumber float literals. | |
| static constexpr llvm::StringLiteral GetNSConstantFloatNumberSectionName() { | |
| return "__DATA,__objc_floatobj,regular,no_dead_strip"; | |
| } | |
| /// Returns the section name to use for NSNumber double literals. | |
| static constexpr llvm::StringLiteral GetNSConstantDoubleNumberSectionName() { | |
| return "__DATA,__objc_doubleobj,regular,no_dead_strip"; | |
| } | |
| /// Returns the section name used for the internal ID arrays | |
| /// used by `NSConstantArray` and `NSConstantDictionary`. | |
| static constexpr llvm::StringLiteral | |
| GetNSConstantCollectionStorageSectionName() { | |
| return "__DATA,__objc_arraydata,regular,no_dead_strip"; | |
| } | |
| /// Returns the section name to use for NSArray literals. | |
| static constexpr llvm::StringLiteral GetNSConstantArraySectionName() { | |
| return "__DATA,__objc_arrayobj,regular,no_dead_strip"; | |
| } | |
| /// Returns the section name to use for NSDictionary literals. | |
| static constexpr llvm::StringLiteral GetNSConstantDictionarySectionName() { | |
| return "__DATA,__objc_dictobj,regular,no_dead_strip"; | |
| } | |
| 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, | |
| Selector 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; } | |
| /// Emits, and caches, a reference to the `__kCFBooleanTrue` singleton. | |
| llvm::GlobalVariable *EmitConstantCFBooleanTrue() { | |
| if (DefinedCFBooleanTrue) | |
| return DefinedCFBooleanTrue; | |
| assert(CGM.getLangOpts().ObjCRuntime.hasConstantCFBooleans() && | |
| "The current ABI doesn't support the constant CFBooleanTrue " | |
| "singleton!"); | |
| DefinedCFBooleanTrue = cast<llvm::GlobalVariable>( | |
| CGM.CreateRuntimeVariable(CGM.DefaultPtrTy, "__kCFBooleanTrue")); | |
| DefinedCFBooleanTrue->addAttribute("objc_arc_inert"); | |
| return DefinedCFBooleanTrue; | |
| } | |
| /// Emits, and caches, a reference to the `__kCFBooleanFalse` singleton. | |
| llvm::GlobalVariable *EmitConstantCFBooleanFalse() { | |
| if (DefinedCFBooleanFalse) | |
| return DefinedCFBooleanFalse; | |
| assert(CGM.getLangOpts().ObjCRuntime.hasConstantCFBooleans() && | |
| "The current ABI doesn't support the constant CFBooleanFalse " | |
| "singleton!"); | |
| DefinedCFBooleanFalse = cast<llvm::GlobalVariable>( | |
| CGM.CreateRuntimeVariable(CGM.DefaultPtrTy, "__kCFBooleanFalse")); | |
| DefinedCFBooleanFalse->addAttribute("objc_arc_inert"); | |
| return DefinedCFBooleanFalse; | |
| } | |
| /// Emits, and caches, a reference to the empty dictionary singleton. | |
| llvm::GlobalVariable *EmitEmptyConstantNSDictionary() { | |
| if (DefinedEmptyNSDictionary) | |
| return DefinedEmptyNSDictionary; | |
| assert(CGM.getLangOpts().ObjCRuntime.hasConstantEmptyCollections() && | |
| "The current ABI doesn't support an empty constant NSDictionary " | |
| "singleton!"); | |
| DefinedEmptyNSDictionary = cast<llvm::GlobalVariable>( | |
| CGM.CreateRuntimeVariable(CGM.DefaultPtrTy, "__NSDictionary0__struct")); | |
| DefinedEmptyNSDictionary->addAttribute("objc_arc_inert"); | |
| return DefinedEmptyNSDictionary; | |
| } | |
| /// Emits, and caches, a reference to the empty array singleton. | |
| llvm::GlobalVariable *EmitEmptyConstantNSArray() { | |
| if (DefinedEmptyNSArray) | |
| return DefinedEmptyNSArray; | |
| assert( | |
| CGM.getLangOpts().ObjCRuntime.hasConstantEmptyCollections() && | |
| "The current ABI doesn't support an empty constant NSArray singleton!"); | |
| DefinedEmptyNSArray = cast<llvm::GlobalVariable>( | |
| CGM.CreateRuntimeVariable(CGM.DefaultPtrTy, "__NSArray0__struct")); | |
| DefinedEmptyNSArray->addAttribute("objc_arc_inert"); | |
| return DefinedEmptyNSArray; | |
| } | |
| ConstantAddress GenerateConstantString(const StringLiteral *SL) override; | |
| ConstantAddress GenerateConstantNumber(const bool Value, | |
| const QualType &Ty) override; | |
| ConstantAddress GenerateConstantNumber(const llvm::APSInt &Value, | |
| const QualType &Ty) override; | |
| ConstantAddress GenerateConstantNumber(const llvm::APFloat &Value, | |
| const QualType &Ty) override; | |
| ConstantAddress | |
| GenerateConstantArray(const ArrayRef<llvm::Constant *> &Objects) override; | |
| ConstantAddress GenerateConstantDictionary( | |
| const ObjCDictionaryLiteral *E, | |
| ArrayRef<std::pair<llvm::Constant *, llvm::Constant *>> KeysAndObjects) | |
| override; | |
| ConstantAddress GenerateConstantNSString(const StringLiteral *SL); | |
| ConstantAddress GenerateConstantNSNumber(const bool Value, | |
| const QualType &Ty); | |
| ConstantAddress GenerateConstantNSNumber(const llvm::APSInt &Value, | |
| const QualType &Ty); | |
| ConstantAddress GenerateConstantNSNumber(const llvm::APFloat &Value, | |
| const QualType &Ty); | |
| ConstantAddress | |
| GenerateConstantNSArray(const ArrayRef<llvm::Constant *> &Objects); | |
| ConstantAddress GenerateConstantNSDictionary( | |
| const ObjCDictionaryLiteral *E, | |
| ArrayRef<std::pair<llvm::Constant *, llvm::Constant *>> KeysAndObjects); | |
| llvm::Function * | |
| GenerateMethod(const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD = nullptr) override; | |
| DirectMethodInfo &GenerateDirectMethod(const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD); | |
| llvm::Function *GenerateObjCDirectThunk(const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD, | |
| llvm::Function *Implementation); | |
| llvm::Function *GetDirectMethodCallee(const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD, | |
| bool ReceiverCanBeNull, | |
| bool ClassObjectCanBeUnrealized); | |
| /// Generate class realization code: [self self] | |
| /// This is used for class methods to ensure the class is initialized. | |
| /// Returns the realized class object. | |
| llvm::Value *GenerateClassRealization(CodeGenFunction &CGF, | |
| llvm::Value *classObject, | |
| const ObjCInterfaceDecl *OID); | |
| void GenerateDirectMethodsPreconditionCheck( | |
| CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD) override; | |
| void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn, | |
| const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD) override; | |
| llvm::Function * | |
| GenerateMethodSelectorStub(Selector Sel, StringRef ClassName, | |
| const ObjCCommonTypesHelper &ObjCTypes); | |
| void GenerateProtocol(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. | |
| virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) = 0; | |
| virtual llvm::Constant *getNSConstantStringClassRef() = 0; | |
| virtual llvm::Constant *getNSConstantArrayClassRef() = 0; | |
| virtual llvm::Constant *getNSConstantDictionaryClassRef() = 0; | |
| virtual llvm::Constant *getNSConstantIntegerNumberClassRef() = 0; | |
| virtual llvm::Constant *getNSConstantFloatNumberClassRef() = 0; | |
| virtual llvm::Constant *getNSConstantDoubleNumberClassRef() = 0; | |
| llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM, | |
| const CGBlockInfo &blockInfo) override; | |
| llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM, | |
| const CGBlockInfo &blockInfo) override; | |
| std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM, | |
| const CGBlockInfo &blockInfo) override; | |
| llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM, | |
| QualType T) override; | |
| private: | |
| void fillRunSkipBlockVars(CodeGenModule &CGM, const CGBlockInfo &blockInfo); | |
| llvm::GlobalVariable *EmitNSConstantCollectionLiteralArrayStorage( | |
| const ArrayRef<llvm::Constant *> &Elements); | |
| }; | |
| 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); | |
| ConstantAddress EmitSelectorAddr(Selector Sel); | |
| public: | |
| CGObjCMac(CodeGen::CodeGenModule &cgm); | |
| llvm::Constant *getNSConstantStringClassRef() override; | |
| llvm::Constant *getNSConstantArrayClassRef() override; | |
| llvm::Constant *getNSConstantDictionaryClassRef() override; | |
| llvm::Constant *getNSConstantIntegerNumberClassRef() override; | |
| llvm::Constant *getNSConstantFloatNumberClassRef() override; | |
| llvm::Constant *getNSConstantDoubleNumberClassRef() 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::FunctionCallee GetPropertyGetFunction() override; | |
| llvm::FunctionCallee GetPropertySetFunction() override; | |
| llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, | |
| bool copy) override; | |
| llvm::FunctionCallee GetGetStructFunction() override; | |
| llvm::FunctionCallee GetSetStructFunction() override; | |
| llvm::FunctionCallee GetCppAtomicObjectGetFunction() override; | |
| llvm::FunctionCallee GetCppAtomicObjectSetFunction() override; | |
| llvm::FunctionCallee 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); | |
| llvm::Constant *GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID); | |
| llvm::Value *EmitLoadOfClassRef(CodeGenFunction &CGF, | |
| const ObjCInterfaceDecl *ID, | |
| llvm::GlobalVariable *Entry); | |
| /// 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); | |
| ConstantAddress EmitSelectorAddr(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 { | |
| const IdentifierInfo *II = &CGM.getContext().Idents.get(name); | |
| return CGM.getContext().Selectors.getSelector(0, &II); | |
| } | |
| Selector GetUnarySelector(const char *name) const { | |
| 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. | |
| // | |
| // Note that for direct methods, because objc_msgSend is skipped, | |
| // and that the method may be inlined, this optimization actually | |
| // can't be performed. | |
| if (const ObjCMethodDecl *MD = | |
| dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl)) | |
| if (MD->isInstanceMethod() && !MD->isDirectMethod()) | |
| if (const ObjCInterfaceDecl *ID = MD->getClassInterface()) | |
| return IV->getContainingInterface()->isSuperClassOf(ID); | |
| return false; | |
| } | |
| bool isClassLayoutKnownStatically(const ObjCInterfaceDecl *ID) { | |
| // Test a class by checking its superclasses up to | |
| // its base class if it has one. | |
| assert(ID != nullptr && "Passed a null class to check layout"); | |
| for (; ID != nullptr; ID = ID->getSuperClass()) { | |
| // The layout of base class NSObject | |
| // is guaranteed to be statically known | |
| if (ID->getIdentifier()->getName() == "NSObject") | |
| return true; | |
| // If we cannot see the @implementation of a class, | |
| // we cannot statically know the class layout. | |
| if (!ID->getImplementation()) | |
| return false; | |
| } | |
| // We know the layout of all the intermediate classes and superclasses. | |
| return true; | |
| } | |
| public: | |
| CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm); | |
| llvm::Constant *getNSConstantStringClassRef() override; | |
| llvm::Constant *getNSConstantArrayClassRef() override; | |
| llvm::Constant *getNSConstantDictionaryClassRef() override; | |
| llvm::Constant *getNSConstantIntegerNumberClassRef() override; | |
| llvm::Constant *getNSConstantFloatNumberClassRef() override; | |
| llvm::Constant *getNSConstantDoubleNumberClassRef() 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(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::FunctionCallee GetPropertyGetFunction() override { | |
| return ObjCTypes.getGetPropertyFn(); | |
| } | |
| llvm::FunctionCallee GetPropertySetFunction() override { | |
| return ObjCTypes.getSetPropertyFn(); | |
| } | |
| llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, | |
| bool copy) override { | |
| return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy); | |
| } | |
| llvm::FunctionCallee GetSetStructFunction() override { | |
| return ObjCTypes.getCopyStructFn(); | |
| } | |
| llvm::FunctionCallee GetGetStructFunction() override { | |
| return ObjCTypes.getCopyStructFn(); | |
| } | |
| llvm::FunctionCallee GetCppAtomicObjectSetFunction() override { | |
| return ObjCTypes.getCppAtomicObjectFunction(); | |
| } | |
| llvm::FunctionCallee GetCppAtomicObjectGetFunction() override { | |
| return ObjCTypes.getCppAtomicObjectFunction(); | |
| } | |
| llvm::FunctionCallee 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 = nullptr; | |
| NullReturnState() = default; | |
| /// 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); | |
| // Destroy any consumed arguments we've got. | |
| if (Method) { | |
| CGObjCRuntime::destroyCalleeDestroyedArguments(CGF, Method, CallArgs); | |
| } | |
| // 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::Value *null = | |
| CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(resultType), 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 *** */ | |
| /// 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; | |
| } | |
| static llvm::GlobalValue::LinkageTypes | |
| getLinkageTypeForObjCMetadata(CodeGenModule &CGM, StringRef Section) { | |
| if (CGM.getTriple().isOSBinFormatMachO() && | |
| (Section.empty() || Section.starts_with("__DATA"))) | |
| return llvm::GlobalValue::InternalLinkage; | |
| return llvm::GlobalValue::PrivateLinkage; | |
| } | |
| /// A helper function to create an internal or private global variable. | |
| static llvm::GlobalVariable * | |
| finishAndCreateGlobal(ConstantInitBuilder::StructBuilder &Builder, | |
| const llvm::Twine &Name, CodeGenModule &CGM) { | |
| std::string SectionName; | |
| if (CGM.getTriple().isOSBinFormatMachO()) | |
| SectionName = "__DATA, __objc_const"; | |
| auto *GV = Builder.finishAndCreateGlobal( | |
| Name, CGM.getPointerAlign(), /*constant*/ false, | |
| getLinkageTypeForObjCMetadata(CGM, SectionName)); | |
| GV->setSection(SectionName); | |
| return GV; | |
| } | |
| /* *** 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(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)); | |
| } | |
| ConstantAddress CGObjCCommonMac::GenerateConstantNumber(const bool Value, | |
| const QualType &Ty) { | |
| return GenerateConstantNSNumber(Value, Ty); | |
| } | |
| ConstantAddress | |
| CGObjCCommonMac::GenerateConstantNumber(const llvm::APSInt &Value, | |
| const QualType &Ty) { | |
| return GenerateConstantNSNumber(Value, Ty); | |
| } | |
| ConstantAddress | |
| CGObjCCommonMac::GenerateConstantNumber(const llvm::APFloat &Value, | |
| const QualType &Ty) { | |
| return GenerateConstantNSNumber(Value, Ty); | |
| } | |
| ConstantAddress CGObjCCommonMac::GenerateConstantArray( | |
| const ArrayRef<llvm::Constant *> &Objects) { | |
| return GenerateConstantNSArray(Objects); | |
| } | |
| ConstantAddress CGObjCCommonMac::GenerateConstantDictionary( | |
| const ObjCDictionaryLiteral *E, | |
| ArrayRef<std::pair<llvm::Constant *, llvm::Constant *>> KeysAndObjects) { | |
| return GenerateConstantNSDictionary(E, KeysAndObjects); | |
| } | |
| 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); | |
| ConstantStringClassRef = GV; | |
| return GV; | |
| } | |
| llvm::Constant *CGObjCMac::getNSConstantArrayClassRef() { | |
| llvm_unreachable("constant array literals not supported for fragile ABI"); | |
| } | |
| llvm::Constant *CGObjCMac::getNSConstantDictionaryClassRef() { | |
| llvm_unreachable("constant dictionary literals not supported for fragile " | |
| "ABI"); | |
| } | |
| llvm::Constant *CGObjCMac::getNSConstantIntegerNumberClassRef() { | |
| llvm_unreachable("constant number literals not supported for fragile ABI"); | |
| } | |
| llvm::Constant *CGObjCMac::getNSConstantFloatNumberClassRef() { | |
| llvm_unreachable("constant number literals not supported for fragile ABI"); | |
| } | |
| llvm::Constant *CGObjCMac::getNSConstantDoubleNumberClassRef() { | |
| llvm_unreachable("constant number literals not supported for fragile ABI"); | |
| } | |
| 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; | |
| llvm::Constant *GV = GetClassGlobal(str, NotForDefinition); | |
| ConstantStringClassRef = GV; | |
| return GV; | |
| } | |
| llvm::Constant *CGObjCNonFragileABIMac::getNSConstantArrayClassRef() { | |
| if (llvm::Value *V = ConstantArrayClassRef) | |
| return cast<llvm::Constant>(V); | |
| const std::string &ArrayClass = CGM.getLangOpts().ObjCConstantArrayClass; | |
| std::string Str = ArrayClass.empty() ? "OBJC_CLASS_$_NSConstantArray" | |
| : "OBJC_CLASS_$_" + ArrayClass; | |
| llvm::Constant *GV = GetClassGlobal(Str, NotForDefinition); | |
| ConstantArrayClassRef = GV; | |
| return GV; | |
| } | |
| llvm::Constant *CGObjCNonFragileABIMac::getNSConstantDictionaryClassRef() { | |
| if (llvm::Value *V = ConstantDictionaryClassRef) | |
| return cast<llvm::Constant>(V); | |
| const std::string &DictionaryClass = | |
| CGM.getLangOpts().ObjCConstantDictionaryClass; | |
| std::string Str = DictionaryClass.empty() | |
| ? "OBJC_CLASS_$_NSConstantDictionary" | |
| : "OBJC_CLASS_$_" + DictionaryClass; | |
| llvm::Constant *GV = GetClassGlobal(Str, NotForDefinition); | |
| ConstantDictionaryClassRef = GV; | |
| return GV; | |
| } | |
| llvm::Constant *CGObjCNonFragileABIMac::getNSConstantIntegerNumberClassRef() { | |
| if (llvm::Value *V = ConstantIntegerNumberClassRef) | |
| return cast<llvm::Constant>(V); | |
| const std::string &NumberClass = | |
| CGM.getLangOpts().ObjCConstantIntegerNumberClass; | |
| std::string Str = NumberClass.empty() ? "OBJC_CLASS_$_NSConstantIntegerNumber" | |
| : "OBJC_CLASS_$_" + NumberClass; | |
| llvm::Constant *GV = GetClassGlobal(Str, NotForDefinition); | |
| ConstantIntegerNumberClassRef = GV; | |
| return GV; | |
| } | |
| llvm::Constant *CGObjCNonFragileABIMac::getNSConstantFloatNumberClassRef() { | |
| if (llvm::Value *V = ConstantFloatNumberClassRef) | |
| return cast<llvm::Constant>(V); | |
| const std::string &NumberClass = | |
| CGM.getLangOpts().ObjCConstantFloatNumberClass; | |
| std::string Str = NumberClass.empty() ? "OBJC_CLASS_$_NSConstantFloatNumber" | |
| : "OBJC_CLASS_$_" + NumberClass; | |
| llvm::Constant *GV = GetClassGlobal(Str, NotForDefinition); | |
| ConstantFloatNumberClassRef = GV; | |
| return GV; | |
| } | |
| llvm::Constant *CGObjCNonFragileABIMac::getNSConstantDoubleNumberClassRef() { | |
| if (llvm::Value *V = ConstantDoubleNumberClassRef) | |
| return cast<llvm::Constant>(V); | |
| const std::string &NumberClass = | |
| CGM.getLangOpts().ObjCConstantDoubleNumberClass; | |
| std::string Str = NumberClass.empty() ? "OBJC_CLASS_$_NSConstantDoubleNumber" | |
| : "OBJC_CLASS_$_" + NumberClass; | |
| llvm::Constant *GV = GetClassGlobal(Str, NotForDefinition); | |
| ConstantDoubleNumberClassRef = GV; | |
| return GV; | |
| } | |
| 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, C->getValueType(), | |
| CharUnits::fromQuantity(C->getAlign().valueOrOne())); | |
| // 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) { | |
| // NOTE: The existing implementation used a pointer to a Int32Ty not a | |
| // struct pointer as the ISA type when emitting constant strings so this is | |
| // maintained for now. | |
| NSConstantStringType = | |
| llvm::StructType::create({CGM.DefaultPtrTy, CGM.Int8PtrTy, CGM.IntTy}, | |
| "struct.__builtin_NSString"); | |
| } | |
| ConstantInitBuilder Builder(CGM); | |
| auto Fields = Builder.beginStruct(NSConstantStringType); | |
| // Class pointer. | |
| Fields.addSignedPointer(Class, | |
| CGM.getCodeGenOpts().PointerAuth.ObjCIsaPointers, | |
| GlobalDecl(), QualType()); | |
| // 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(llvm::Align(1)); | |
| Fields.add(GV); | |
| // 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, GV->getValueType(), Alignment); | |
| } | |
| /// Emit the boolean singletons for BOOL literals @YES and @NO. | |
| ConstantAddress CGObjCCommonMac::GenerateConstantNSNumber(const bool Value, | |
| const QualType &Ty) { | |
| llvm::GlobalVariable *Val = | |
| Value ? EmitConstantCFBooleanTrue() : EmitConstantCFBooleanFalse(); | |
| return ConstantAddress(Val, Val->getValueType(), CGM.getPointerAlign()); | |
| } | |
| /// Generate a constant NSConstantIntegerNumber from an ObjC integer literal, | |
| /// e.g., @2. | |
| /* | |
| struct __builtin_NSConstantIntegerNumber { | |
| struct._class_t *isa; // point to _NSConstantIntegerNumberClassReference | |
| char const *const _encoding; | |
| long long const _value; | |
| }; | |
| */ | |
| ConstantAddress | |
| CGObjCCommonMac::GenerateConstantNSNumber(const llvm::APSInt &Value, | |
| const QualType &Ty) { | |
| CharUnits Alignment = CGM.getPointerAlign(); | |
| // Check if we've already emitted, if so emit a reference to it. | |
| llvm::GlobalVariable *&Entry = | |
| NSConstantNumberMap[{CGM.getContext().getCanonicalType(Ty), Value}]; | |
| if (Entry) { | |
| return ConstantAddress(Entry, Entry->getValueType(), Alignment); | |
| } | |
| // The encoding type. | |
| std::string ObjCEncodingType; | |
| CodeGenFunction(CGM).getContext().getObjCEncodingForType(Ty, | |
| ObjCEncodingType); | |
| llvm::Constant *const Class = getNSConstantIntegerNumberClassRef(); | |
| if (!NSConstantIntegerNumberType) { | |
| NSConstantIntegerNumberType = llvm::StructType::create( | |
| { | |
| CGM.DefaultPtrTy, // isa | |
| CGM.Int8PtrTy, // _encoding | |
| CGM.Int64Ty, // _value | |
| }, | |
| "struct.__builtin_NSConstantIntegerNumber"); | |
| } | |
| ConstantInitBuilder Builder(CGM); | |
| auto Fields = Builder.beginStruct(NSConstantIntegerNumberType); | |
| // Class pointer. | |
| Fields.addSignedPointer(Class, | |
| CGM.getCodeGenOpts().PointerAuth.ObjCIsaPointers, | |
| GlobalDecl(), QualType()); | |
| // add the @encode. | |
| Fields.add(CGM.GetAddrOfConstantCString(ObjCEncodingType).getPointer()); | |
| // add the value stored. | |
| llvm::Constant *IntegerValue = | |
| llvm::ConstantInt::get(CGM.Int64Ty, Value.extOrTrunc(64)); | |
| Fields.add(IntegerValue); | |
| // The struct. | |
| llvm::GlobalVariable *const GV = Fields.finishAndCreateGlobal( | |
| "_unnamed_nsconstantintegernumber_", Alignment, | |
| /* constant */ true, llvm::GlobalVariable::PrivateLinkage); | |
| GV->setSection(GetNSConstantIntegerNumberSectionName()); | |
| GV->addAttribute("objc_arc_inert"); | |
| Entry = GV; | |
| return ConstantAddress(GV, GV->getValueType(), Alignment); | |
| } | |
| /// Generate either a constant NSConstantFloatNumber or NSConstantDoubleNumber | |
| /// from an ObjC literal based on it's encoding. @(2.2f) would be | |
| /// NSConstantFloatNumber. @(2.222) would be NSConstantDoubleNumber. | |
| /* | |
| struct __builtin_NSConstantFloatNumber { | |
| struct._class_t *isa; // point to _NSConstantFloatNumberClassReference | |
| float const _value; | |
| }; | |
| struct __builtin_NSConstantDoubleNumber { | |
| struct._class_t *isa; // point to _NSConstantDoubleNumberClassReference | |
| double const _value; | |
| }; | |
| */ | |
| ConstantAddress | |
| CGObjCCommonMac::GenerateConstantNSNumber(const llvm::APFloat &Value, | |
| const QualType &Ty) { | |
| CharUnits Alignment = CGM.getPointerAlign(); | |
| // Check if we've already emitted, if so emit a reference to it. | |
| llvm::GlobalVariable *&Entry = | |
| NSConstantNumberMap[{CGM.getContext().getCanonicalType(Ty), Value}]; | |
| if (Entry) { | |
| return ConstantAddress(Entry, Entry->getValueType(), Alignment); | |
| } | |
| // @encode type used to pick which class type to use. | |
| std::string ObjCEncodingType; | |
| CodeGenFunction(CGM).getContext().getObjCEncodingForType(Ty, | |
| ObjCEncodingType); | |
| assert((ObjCEncodingType == "d" || ObjCEncodingType == "f") && | |
| "Unexpected or unknown ObjCEncodingType used in constant NSNumber"); | |
| llvm::GlobalValue::LinkageTypes Linkage = | |
| llvm::GlobalVariable::PrivateLinkage; | |
| // Handle floats. | |
| if (ObjCEncodingType == "f") { | |
| llvm::Constant *const Class = getNSConstantFloatNumberClassRef(); | |
| if (!NSConstantFloatNumberType) { | |
| NSConstantFloatNumberType = llvm::StructType::create( | |
| { | |
| CGM.DefaultPtrTy, // isa | |
| CGM.FloatTy, // _value | |
| }, | |
| "struct.__builtin_NSConstantFloatNumber"); | |
| } | |
| ConstantInitBuilder Builder(CGM); | |
| auto Fields = Builder.beginStruct(NSConstantFloatNumberType); | |
| // Class pointer. | |
| Fields.addSignedPointer(Class, | |
| CGM.getCodeGenOpts().PointerAuth.ObjCIsaPointers, | |
| GlobalDecl(), QualType()); | |
| // add the value stored. | |
| llvm::Constant *FV = llvm::ConstantFP::get(CGM.FloatTy, Value); | |
| Fields.add(FV); | |
| // The struct. | |
| llvm::GlobalVariable *const GV = Fields.finishAndCreateGlobal( | |
| "_unnamed_nsconstantfloatnumber_", Alignment, | |
| /*constant*/ true, Linkage); | |
| GV->setSection(GetNSConstantFloatNumberSectionName()); | |
| GV->addAttribute("objc_arc_inert"); | |
| Entry = GV; | |
| return ConstantAddress(GV, GV->getValueType(), Alignment); | |
| } | |
| llvm::Constant *const Class = getNSConstantDoubleNumberClassRef(); | |
| if (!NSConstantDoubleNumberType) { | |
| // NOTE: this will be padded on some 32-bit targets and is expected. | |
| NSConstantDoubleNumberType = llvm::StructType::create( | |
| { | |
| CGM.DefaultPtrTy, // isa | |
| CGM.DoubleTy, // _value | |
| }, | |
| "struct.__builtin_NSConstantDoubleNumber"); | |
| } | |
| ConstantInitBuilder Builder(CGM); | |
| auto Fields = Builder.beginStruct(NSConstantDoubleNumberType); | |
| // Class pointer. | |
| Fields.addSignedPointer(Class, | |
| CGM.getCodeGenOpts().PointerAuth.ObjCIsaPointers, | |
| GlobalDecl(), QualType()); | |
| // add the value stored. | |
| llvm::Constant *DV = llvm::ConstantFP::get(CGM.DoubleTy, Value); | |
| Fields.add(DV); | |
| // The struct. | |
| llvm::GlobalVariable *const GV = Fields.finishAndCreateGlobal( | |
| "_unnamed_nsconstantdoublenumber_", Alignment, | |
| /*constant*/ true, Linkage); | |
| GV->setSection(GetNSConstantDoubleNumberSectionName()); | |
| GV->addAttribute("objc_arc_inert"); | |
| Entry = GV; | |
| return ConstantAddress(GV, GV->getValueType(), Alignment); | |
| } | |
| /// Shared private method to emit the id array storage for constant NSArray and | |
| /// NSDictionary literals as they share the same sections and behavior. | |
| llvm::GlobalVariable * | |
| CGObjCCommonMac::EmitNSConstantCollectionLiteralArrayStorage( | |
| const ArrayRef<llvm::Constant *> &Elements) { | |
| llvm::Type *ElementsTy = Elements[0]->getType(); | |
| llvm::ArrayType *ArrayTy = llvm::ArrayType::get(ElementsTy, Elements.size()); | |
| llvm::Constant *const ArrayData = llvm::ConstantArray::get(ArrayTy, Elements); | |
| llvm::GlobalVariable *ObjectsGV = new llvm::GlobalVariable( | |
| CGM.getModule(), ArrayTy, true, llvm::GlobalValue::InternalLinkage, | |
| ArrayData, "_unnamed_array_storage"); | |
| ObjectsGV->setAlignment(CGM.getPointerAlign().getAsAlign()); | |
| ObjectsGV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); | |
| ObjectsGV->setSection(GetNSConstantCollectionStorageSectionName()); | |
| return ObjectsGV; | |
| } | |
| /// Generate a constant NSConstantArray from an ObjC array literal, | |
| /// e.g., @[ @2 ] or the singleton for an empty `__NSArray0__struct`. | |
| /* | |
| struct __builtin_NSArray { | |
| struct._class_t *isa; // points to _NSConstantArrayClassReference | |
| NSUInteger const _count; | |
| id const *const _objects; | |
| }; | |
| */ | |
| ConstantAddress CGObjCCommonMac::GenerateConstantNSArray( | |
| const ArrayRef<llvm::Constant *> &Objects) { | |
| CharUnits Alignment = CGM.getPointerAlign(); | |
| if (Objects.size() == 0) { | |
| llvm::GlobalVariable *GV = EmitEmptyConstantNSArray(); | |
| return ConstantAddress(GV, GV->getValueType(), Alignment); | |
| } | |
| ASTContext &Context = CGM.getContext(); | |
| CodeGenTypes &Types = CGM.getTypes(); | |
| llvm::Constant *const Class = getNSConstantArrayClassRef(); | |
| llvm::Type *const NSUIntegerTy = | |
| Types.ConvertType(Context.getNSUIntegerType()); | |
| if (!NSConstantArrayType) { | |
| NSConstantArrayType = llvm::StructType::create( | |
| { | |
| CGM.DefaultPtrTy, // isa | |
| NSUIntegerTy, // _count | |
| CGM.DefaultPtrTy, // _objects | |
| }, | |
| "struct.__builtin_NSArray"); | |
| } | |
| ConstantInitBuilder Builder(CGM); | |
| auto Fields = Builder.beginStruct(NSConstantArrayType); | |
| // Class pointer. | |
| Fields.addSignedPointer(Class, | |
| CGM.getCodeGenOpts().PointerAuth.ObjCIsaPointers, | |
| GlobalDecl(), QualType()); | |
| // count. | |
| uint64_t ObjectCount = Objects.size(); | |
| llvm::Constant *Count = llvm::ConstantInt::get(NSUIntegerTy, ObjectCount); | |
| Fields.add(Count); | |
| // objects. | |
| llvm::GlobalVariable *ObjectsGV = | |
| EmitNSConstantCollectionLiteralArrayStorage(Objects); | |
| Fields.add(ObjectsGV); | |
| // The struct. | |
| llvm::GlobalVariable *GV = Fields.finishAndCreateGlobal( | |
| "_unnamed_nsarray_", Alignment, | |
| /* constant */ true, llvm::GlobalValue::PrivateLinkage); | |
| GV->setSection(GetNSConstantArraySectionName()); | |
| GV->addAttribute("objc_arc_inert"); | |
| return ConstantAddress(GV, GV->getValueType(), Alignment); | |
| } | |
| /// Generate a constant NSConstantDictionary from an ObjC dictionary literal | |
| /// with string keys, e.g., @{ @"someNum" : @2 } or the singleton for an empty | |
| /// `__NSDictionary0__struct`. | |
| /* | |
| struct __builtin_NSDictionary { | |
| struct._class_t *isa; // point to _NSConstantDictionaryClassReference | |
| NSUInteger const _hashOptions; | |
| NSUInteger const _count; | |
| id const *const _keys; | |
| id const *const _objects; | |
| }; | |
| */ | |
| ConstantAddress CGObjCCommonMac::GenerateConstantNSDictionary( | |
| const ObjCDictionaryLiteral *E, | |
| ArrayRef<std::pair<llvm::Constant *, llvm::Constant *>> KeysAndObjects) { | |
| CharUnits Alignment = CGM.getPointerAlign(); | |
| if (KeysAndObjects.size() == 0) { | |
| llvm::GlobalVariable *GV = EmitEmptyConstantNSDictionary(); | |
| return ConstantAddress(GV, GV->getValueType(), Alignment); | |
| } | |
| ASTContext &Context = CGM.getContext(); | |
| CodeGenTypes &Types = CGM.getTypes(); | |
| llvm::Constant *const Class = getNSConstantDictionaryClassRef(); | |
| llvm::Type *const NSUIntegerTy = | |
| Types.ConvertType(Context.getNSUIntegerType()); | |
| if (!NSConstantDictionaryType) { | |
| NSConstantDictionaryType = llvm::StructType::create( | |
| { | |
| CGM.DefaultPtrTy, // isa | |
| NSUIntegerTy, // _hashOptions | |
| NSUIntegerTy, // _count | |
| CGM.DefaultPtrTy, // _keys | |
| CGM.DefaultPtrTy, // _objects | |
| }, | |
| "struct.__builtin_NSDictionary"); | |
| } | |
| ConstantInitBuilder Builder(CGM); | |
| auto Fields = Builder.beginStruct(NSConstantDictionaryType); | |
| // Class pointer. | |
| Fields.addSignedPointer(Class, | |
| CGM.getCodeGenOpts().PointerAuth.ObjCIsaPointers, | |
| GlobalDecl(), QualType()); | |
| // Use the hashing helper to manage the keys and sorting. Sort by UTF-16 | |
| // code unit exactly when the keys are emitted as constant CFStrings (which | |
| // store and compare keys as UTF-16); with -fno-constant-cfstrings the keys | |
| // are OBJC_CLASS_$_NSConstantString compared as raw bytes, so sort by | |
| // UTF-8 byte order instead. | |
| auto HashOpts(NSDictionaryBuilder::Options::Sorted); | |
| NSDictionaryBuilder DictBuilder(E, KeysAndObjects, HashOpts, | |
| !CGM.getLangOpts().NoConstantCFStrings); | |
| // Ask `HashBuilder` for the fully sorted keys / values and the count. | |
| uint64_t const NumElements = DictBuilder.getNumElements(); | |
| llvm::Constant *OptionsConstant = llvm::ConstantInt::get( | |
| NSUIntegerTy, static_cast<uint64_t>(DictBuilder.getOptions())); | |
| Fields.add(OptionsConstant); | |
| // count. | |
| llvm::Constant *Count = llvm::ConstantInt::get(NSUIntegerTy, NumElements); | |
| Fields.add(Count); | |
| // Split sorted pairs into separate keys and objects arrays for storage. | |
| SmallVector<llvm::Constant *, 16> SortedKeys, SortedObjects; | |
| SortedKeys.reserve(NumElements); | |
| SortedObjects.reserve(NumElements); | |
| for (auto &[Key, Obj] : DictBuilder.getElements()) { | |
| SortedKeys.push_back(Key); | |
| SortedObjects.push_back(Obj); | |
| } | |
| // keys. | |
| llvm::GlobalVariable *KeysGV = | |
| EmitNSConstantCollectionLiteralArrayStorage(SortedKeys); | |
| Fields.add(KeysGV); | |
| // objects. | |
| llvm::GlobalVariable *ObjectsGV = | |
| EmitNSConstantCollectionLiteralArrayStorage(SortedObjects); | |
| Fields.add(ObjectsGV); | |
| // The struct. | |
| llvm::GlobalVariable *GV = Fields.finishAndCreateGlobal( | |
| "_unnamed_nsdictionary_", Alignment, | |
| /* constant */ true, llvm::GlobalValue::PrivateLinkage); | |
| GV->setSection(GetNSConstantDictionarySectionName()); | |
| GV->addAttribute("objc_arc_inert"); | |
| return ConstantAddress(GV, GV->getValueType(), 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. | |
| RawAddress 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)); | |
| // If this is a class message the metaclass is passed as the target. | |
| llvm::Type *ClassTyPtr = llvm::PointerType::getUnqual(VMContext); | |
| 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(ClassTyPtr, 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(ClassTyPtr, 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(ClassTyPtr, 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)); | |
| return EmitMessageSend(CGF, Return, ResultType, 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, Sel, Receiver, | |
| CGF.getContext().getObjCIdType(), false, CallArgs, | |
| Method, Class, ObjCTypes); | |
| } | |
| CodeGen::RValue CGObjCCommonMac::EmitMessageSend( | |
| CodeGen::CodeGenFunction &CGF, ReturnValueSlot Return, QualType ResultType, | |
| Selector Sel, llvm::Value *Arg0, QualType Arg0Ty, bool IsSuper, | |
| const CallArgList &CallArgs, const ObjCMethodDecl *Method, | |
| const ObjCInterfaceDecl *ClassReceiver, | |
| const ObjCCommonTypesHelper &ObjCTypes) { | |
| CodeGenTypes &Types = CGM.getTypes(); | |
| auto selTy = CGF.getContext().getObjCSelType(); | |
| llvm::Value *ReceiverValue = | |
| llvm::PoisonValue::get(Types.ConvertType(Arg0Ty)); | |
| llvm::Value *SelValue = llvm::UndefValue::get(Types.ConvertType(selTy)); | |
| CallArgList ActualArgs; | |
| if (!IsSuper) | |
| Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy); | |
| ActualArgs.add(RValue::get(ReceiverValue), Arg0Ty); | |
| if (!Method || !Method->isDirectMethod()) | |
| ActualArgs.add(RValue::get(SelValue), selTy); | |
| 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 = | |
| canMessageReceiverBeNull(CGF, Method, IsSuper, ClassReceiver, Arg0); | |
| bool ClassObjectCanBeUnrealized = | |
| Method && Method->isClassMethod() && | |
| canClassObjectBeUnrealized(ClassReceiver, CGF); | |
| bool RequiresNullCheck = false; | |
| bool RequiresReceiverValue = true; | |
| bool RequiresSelValue = true; | |
| llvm::FunctionCallee Fn = nullptr; | |
| if (Method && Method->isDirectMethod()) { | |
| assert(!IsSuper); | |
| Fn = GetDirectMethodCallee(Method, Method->getClassInterface(), | |
| ReceiverCanBeNull, ClassObjectCanBeUnrealized); | |
| // Direct methods will synthesize the proper `_cmd` internally, | |
| // so just don't bother with setting the `_cmd` argument. | |
| RequiresSelValue = false; | |
| } else 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; | |
| // The class name that's used to create the class msgSend stub declaration. | |
| StringRef ClassName; | |
| // We cannot use class msgSend stubs in the following cases: | |
| // 1. The class is annotated with `objc_class_stub` or | |
| // `objc_runtime_visible`. | |
| // 2. The selector name contains a '$'. | |
| if (CGM.getCodeGenOpts().ObjCMsgSendClassSelectorStubs && ClassReceiver && | |
| Method && Method->isClassMethod() && | |
| !ClassReceiver->hasAttr<ObjCClassStubAttr>() && | |
| !ClassReceiver->hasAttr<ObjCRuntimeVisibleAttr>() && | |
| Sel.getAsString().find('$') == std::string::npos) | |
| ClassName = ClassReceiver->getObjCRuntimeNameAsString(); | |
| bool UseClassStub = ClassName.data(); | |
| // Try to use a selector stub declaration instead of objc_msgSend. | |
| if (!IsSuper && | |
| (CGM.getCodeGenOpts().ObjCMsgSendSelectorStubs || UseClassStub)) { | |
| Fn = GenerateMethodSelectorStub(Sel, ClassName, ObjCTypes); | |
| // Selector stubs synthesize `_cmd` in the stub, so we don't have to. | |
| RequiresReceiverValue = !UseClassStub; | |
| RequiresSelValue = false; | |
| } else { | |
| Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper) | |
| : ObjCTypes.getSendFn(IsSuper); | |
| } | |
| } | |
| // Cast function to proper signature | |
| llvm::Constant *BitcastFn = cast<llvm::Constant>( | |
| CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType)); | |
| // 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 && Method && Method->hasParamDestroyedInCallee()) | |
| RequiresNullCheck = true; | |
| if (CGM.shouldHavePreconditionInline(Method)) { | |
| // For variadic class methods, we need to inline precondition checks. That | |
| // include two things: | |
| // 1. We have to inline the class realization if we are not sure if it must | |
| // have been realized. | |
| if (ClassReceiver && ClassObjectCanBeUnrealized) { | |
| // Perform class realization using the helper function | |
| Arg0 = GenerateClassRealization(CGF, Arg0, ClassReceiver); | |
| ActualArgs[0] = CallArg(RValue::get(Arg0), ActualArgs[0].Ty); | |
| } | |
| // 2. We have to inline the precondition thunk if we are not sure if the | |
| // receiver can be null. Luckly, `NullReturnState` already does that for | |
| // corner cases like ns_consume, so we only need to override the flag, | |
| // regardless if the return value is unused. | |
| RequiresNullCheck |= ReceiverCanBeNull; | |
| } | |
| NullReturnState nullReturn; | |
| if (RequiresNullCheck) { | |
| nullReturn.init(CGF, Arg0); | |
| } | |
| // Pass the receiver value if it's needed. | |
| if (RequiresReceiverValue) | |
| ActualArgs[0] = CallArg(RValue::get(Arg0), Arg0Ty); | |
| // If a selector value needs to be passed, emit the load before the call. | |
| if (RequiresSelValue) { | |
| SelValue = GetSelector(CGF, Sel); | |
| ActualArgs[1] = CallArg(RValue::get(SelValue), selTy); | |
| } | |
| llvm::CallBase *CallSite; | |
| CGCallee Callee = CGCallee::forDirect(BitcastFn); | |
| 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) { | |
| 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->getAsCanonical<RecordType>()) { | |
| visitRecord(record, fieldOffset); | |
| continue; | |
| } | |
| Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type); | |
| if (GCAttr == Qualifiers::Strong) { | |
| assert(CGM.getContext().getTypeSize(type) == | |
| CGM.getTarget().getPointerWidth(LangAS::Default)); | |
| 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->castAsCanonical<RecordType>(), | |
| BytePos + FieldOffset, HasUnion); | |
| continue; | |
| } | |
| if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { | |
| auto *CArray = cast<ConstantArrayType>(Array); | |
| uint64_t ElCount = CArray->getZExtSize(); | |
| assert(CArray && "only array with known element size is supported"); | |
| FQT = CArray->getElementType(); | |
| while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) { | |
| auto *CArray = cast<ConstantArrayType>(Array); | |
| ElCount *= CArray->getZExtSize(); | |
| FQT = CArray->getElementType(); | |
| } | |
| if (FQT->isRecordType() && ElCount) { | |
| int OldIndex = RunSkipBlockVars.size() - 1; | |
| auto *RT = FQT->castAsCanonical<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(); | |
| 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()->getDefinitionOrSelf(); | |
| 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(LangAS::Default); | |
| 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 char C : Layout) | |
| BitMap += C; | |
| 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) { | |
| case BLOCK_LAYOUT_OPERATOR: | |
| printf("BL_OPERATOR:"); | |
| delta = 0; | |
| break; | |
| case BLOCK_LAYOUT_NON_OBJECT_BYTES: | |
| printf("BL_NON_OBJECT_BYTES:"); | |
| break; | |
| case BLOCK_LAYOUT_NON_OBJECT_WORDS: | |
| printf("BL_NON_OBJECT_WORD:"); | |
| break; | |
| case BLOCK_LAYOUT_STRONG: | |
| printf("BL_STRONG:"); | |
| break; | |
| case BLOCK_LAYOUT_BYREF: | |
| printf("BL_BYREF:"); | |
| break; | |
| case BLOCK_LAYOUT_WEAK: | |
| printf("BL_WEAK:"); | |
| break; | |
| case BLOCK_LAYOUT_UNRETAINED: | |
| printf("BL_UNRETAINED:"); | |
| break; | |
| } | |
| // Actual value of word count is one more that what is in the imm. | |
| // field of the instruction | |
| printf("%d", (inst & 0xf) + delta); | |
| if (i < e - 1) | |
| printf(", "); | |
| else | |
| printf("\n"); | |
| } | |
| } | |
| return CreateCStringLiteral(BitMap, ObjCLabelType::LayoutBitMap, | |
| /*ForceNonFragileABI=*/true, | |
| /*NullTerminate=*/false); | |
| } | |
| static std::string getBlockLayoutInfoString( | |
| const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars, | |
| bool HasCopyDisposeHelpers) { | |
| std::string Str; | |
| for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) { | |
| if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) { | |
| // Copy/dispose helpers don't have any information about | |
| // __unsafe_unretained captures, so unconditionally concatenate a string. | |
| Str += "u"; | |
| } else if (HasCopyDisposeHelpers) { | |
| // Information about __strong, __weak, or byref captures has already been | |
| // encoded into the names of the copy/dispose helpers. We have to add a | |
| // string here only when the copy/dispose helpers aren't generated (which | |
| // happens when the block is non-escaping). | |
| continue; | |
| } else { | |
| switch (R.opcode) { | |
| case CGObjCCommonMac::BLOCK_LAYOUT_STRONG: | |
| Str += "s"; | |
| break; | |
| case CGObjCCommonMac::BLOCK_LAYOUT_BYREF: | |
| Str += "r"; | |
| break; | |
| case CGObjCCommonMac::BLOCK_LAYOUT_WEAK: | |
| Str += "w"; | |
| break; | |
| default: | |
| continue; | |
| } | |
| } | |
| Str += llvm::to_string(R.block_var_bytepos.getQuantity()); | |
| Str += "l" + llvm::to_string(R.block_var_size.getQuantity()); | |
| } | |
| return Str; | |
| } | |
| void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM, | |
| const CGBlockInfo &blockInfo) { | |
| assert(CGM.getLangOpts().getGC() == LangOptions::NonGC); | |
| RunSkipBlockVars.clear(); | |
| bool hasUnion = false; | |
| unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(LangAS::Default); | |
| unsigned ByteSizeInBits = CGM.getTarget().getCharWidth(); | |
| unsigned WordSizeInBytes = WordSizeInBits / ByteSizeInBits; | |
| const BlockDecl *blockDecl = blockInfo.getBlockDecl(); | |
| // Calculate the basic layout of the block structure. | |
| const llvm::StructLayout *layout = | |
| CGM.getDataLayout().getStructLayout(blockInfo.StructureType); | |
| // Ignore the optional 'this' capture: C++ objects are not assumed | |
| // to be GC'ed. | |
| if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero()) | |
| UpdateRunSkipBlockVars(false, Qualifiers::OCL_None, | |
| blockInfo.BlockHeaderForcedGapOffset, | |
| blockInfo.BlockHeaderForcedGapSize); | |
| // 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 = | |
| CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex())); | |
| assert(!type->isArrayType() && "array variable should not be caught"); | |
| if (!CI.isByRef()) | |
| if (const auto *record = type->getAsCanonical<RecordType>()) { | |
| BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion); | |
| continue; | |
| } | |
| CharUnits fieldSize; | |
| if (CI.isByRef()) | |
| fieldSize = CharUnits::fromQuantity(WordSizeInBytes); | |
| else | |
| fieldSize = CGM.getContext().getTypeSizeInChars(type); | |
| UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false), | |
| fieldOffset, fieldSize); | |
| } | |
| } | |
| llvm::Constant * | |
| CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM, | |
| const CGBlockInfo &blockInfo) { | |
| fillRunSkipBlockVars(CGM, blockInfo); | |
| return getBitmapBlockLayout(false); | |
| } | |
| std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM, | |
| const CGBlockInfo &blockInfo) { | |
| fillRunSkipBlockVars(CGM, blockInfo); | |
| return getBlockLayoutInfoString(RunSkipBlockVars, blockInfo.NeedsCopyDispose); | |
| } | |
| llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM, | |
| QualType T) { | |
| assert(CGM.getLangOpts().getGC() == LangOptions::NonGC); | |
| assert(!T->isArrayType() && "__block array variable should not be caught"); | |
| CharUnits fieldOffset; | |
| RunSkipBlockVars.clear(); | |
| bool hasUnion = false; | |
| if (const auto *record = T->getAsCanonical<RecordType>()) { | |
| BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, | |
| true /*ByrefLayout */); | |
| llvm::Constant *Result = getBitmapBlockLayout(true); | |
| if (isa<llvm::ConstantInt>(Result)) | |
| Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy); | |
| return Result; | |
| } | |
| llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy); | |
| return nullPtr; | |
| } | |
| llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF, | |
| const ObjCProtocolDecl *PD) { | |
| // FIXME: I don't understand why gcc generates this, or where it is | |
| // resolved. Investigate. Its also wasteful to look this up over and over. | |
| LazySymbols.insert(&CGM.getContext().Idents.get("Protocol")); | |
| return GetProtocolRef(PD); | |
| } | |
| void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) { | |
| // FIXME: We shouldn't need this, the protocol decl should contain enough | |
| // information to tell us whether this was a declaration or a definition. | |
| DefinedProtocols.insert(PD->getIdentifier()); | |
| // If we have generated a forward reference to this protocol, emit | |
| // it now. Otherwise do nothing, the protocol objects are lazily | |
| // emitted. | |
| if (Protocols.count(PD->getIdentifier())) | |
| GetOrEmitProtocol(PD); | |
| } | |
| llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) { | |
| if (DefinedProtocols.count(PD->getIdentifier())) | |
| return GetOrEmitProtocol(PD); | |
| return GetOrEmitProtocolRef(PD); | |
| } | |
| llvm::Value * | |
| CGObjCCommonMac::EmitClassRefViaRuntime(CodeGenFunction &CGF, | |
| const ObjCInterfaceDecl *ID, | |
| ObjCCommonTypesHelper &ObjCTypes) { | |
| llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn(); | |
| llvm::Value *className = CGF.CGM | |
| .GetAddrOfConstantCString(std::string( | |
| ID->getObjCRuntimeNameAsString())) | |
| .getPointer(); | |
| ASTContext &ctx = CGF.CGM.getContext(); | |
| className = CGF.Builder.CreateBitCast( | |
| className, CGF.ConvertType(ctx.getPointerType(ctx.CharTy.withConst()))); | |
| llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className); | |
| call->setDoesNotThrow(); | |
| return call; | |
| } | |
| /* | |
| // Objective-C 1.0 extensions | |
| struct _objc_protocol { | |
| struct _objc_protocol_extension *isa; | |
| char *protocol_name; | |
| struct _objc_protocol_list *protocol_list; | |
| struct _objc__method_prototype_list *instance_methods; | |
| struct _objc__method_prototype_list *class_methods | |
| }; | |
| See EmitProtocolExtension(). | |
| */ | |
| llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) { | |
| llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()]; | |
| // Early exit if a defining object has already been generated. | |
| if (Entry && Entry->hasInitializer()) | |
| return Entry; | |
| // Use the protocol definition, if there is one. | |
| if (const ObjCProtocolDecl *Def = PD->getDefinition()) | |
| PD = Def; | |
| // FIXME: I don't understand why gcc generates this, or where it is | |
| // resolved. Investigate. Its also wasteful to look this up over and over. | |
| LazySymbols.insert(&CGM.getContext().Idents.get("Protocol")); | |
| // Construct method lists. | |
| auto methodLists = ProtocolMethodLists::get(PD); | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.ProtocolTy); | |
| values.add(EmitProtocolExtension(PD, methodLists)); | |
| values.add(GetClassName(PD->getObjCRuntimeNameAsString())); | |
| values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(), | |
| PD->protocol_begin(), PD->protocol_end())); | |
| values.add(methodLists.emitMethodList( | |
| this, PD, ProtocolMethodLists::RequiredInstanceMethods)); | |
| values.add(methodLists.emitMethodList( | |
| this, PD, ProtocolMethodLists::RequiredClassMethods)); | |
| if (Entry) { | |
| // Already created, update the initializer. | |
| assert(Entry->hasPrivateLinkage()); | |
| values.finishAndSetAsInitializer(Entry); | |
| } else { | |
| Entry = values.finishAndCreateGlobal( | |
| "OBJC_PROTOCOL_" + PD->getName(), CGM.getPointerAlign(), | |
| /*constant*/ false, llvm::GlobalValue::PrivateLinkage); | |
| Entry->setSection("__OBJC,__protocol,regular,no_dead_strip"); | |
| Protocols[PD->getIdentifier()] = Entry; | |
| } | |
| CGM.addCompilerUsedGlobal(Entry); | |
| return Entry; | |
| } | |
| llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) { | |
| llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; | |
| if (!Entry) { | |
| // We use the initializer as a marker of whether this is a forward | |
| // reference or not. At module finalization we add the empty | |
| // contents for protocols which were referenced but never defined. | |
| Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, | |
| false, llvm::GlobalValue::PrivateLinkage, | |
| nullptr, "OBJC_PROTOCOL_" + PD->getName()); | |
| Entry->setSection("__OBJC,__protocol,regular,no_dead_strip"); | |
| // FIXME: Is this necessary? Why only for protocol? | |
| Entry->setAlignment(llvm::Align(4)); | |
| } | |
| return Entry; | |
| } | |
| /* | |
| struct _objc_protocol_extension { | |
| uint32_t size; | |
| struct objc_method_description_list *optional_instance_methods; | |
| struct objc_method_description_list *optional_class_methods; | |
| struct objc_property_list *instance_properties; | |
| const char ** extendedMethodTypes; | |
| struct objc_property_list *class_properties; | |
| }; | |
| */ | |
| llvm::Constant * | |
| CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD, | |
| const ProtocolMethodLists &methodLists) { | |
| auto optInstanceMethods = methodLists.emitMethodList( | |
| this, PD, ProtocolMethodLists::OptionalInstanceMethods); | |
| auto optClassMethods = methodLists.emitMethodList( | |
| this, PD, ProtocolMethodLists::OptionalClassMethods); | |
| auto extendedMethodTypes = EmitProtocolMethodTypes( | |
| "OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(), | |
| methodLists.emitExtendedTypesArray(this), ObjCTypes); | |
| auto instanceProperties = EmitPropertyList( | |
| "OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD, ObjCTypes, false); | |
| auto classProperties = | |
| EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr, | |
| PD, ObjCTypes, true); | |
| // Return null if no extension bits are used. | |
| if (optInstanceMethods->isNullValue() && optClassMethods->isNullValue() && | |
| extendedMethodTypes->isNullValue() && instanceProperties->isNullValue() && | |
| classProperties->isNullValue()) { | |
| return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy); | |
| } | |
| uint64_t size = | |
| CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy); | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy); | |
| values.addInt(ObjCTypes.IntTy, size); | |
| values.add(optInstanceMethods); | |
| values.add(optClassMethods); | |
| values.add(instanceProperties); | |
| values.add(extendedMethodTypes); | |
| values.add(classProperties); | |
| // No special section, but goes in llvm.used | |
| return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values, | |
| StringRef(), CGM.getPointerAlign(), true); | |
| } | |
| /* | |
| struct objc_protocol_list { | |
| struct objc_protocol_list *next; | |
| long count; | |
| Protocol *list[]; | |
| }; | |
| */ | |
| llvm::Constant * | |
| CGObjCMac::EmitProtocolList(Twine name, | |
| ObjCProtocolDecl::protocol_iterator begin, | |
| ObjCProtocolDecl::protocol_iterator end) { | |
| // Just return null for empty protocol lists | |
| auto PDs = GetRuntimeProtocolList(begin, end); | |
| if (PDs.empty()) | |
| return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy); | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(); | |
| // This field is only used by the runtime. | |
| values.addNullPointer(ObjCTypes.ProtocolListPtrTy); | |
| // Reserve a slot for the count. | |
| auto countSlot = values.addPlaceholder(); | |
| auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy); | |
| for (const auto *Proto : PDs) | |
| refsArray.add(GetProtocolRef(Proto)); | |
| auto count = refsArray.size(); | |
| // This list is null terminated. | |
| refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy); | |
| refsArray.finishAndAddTo(values); | |
| values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count); | |
| StringRef section; | |
| if (CGM.getTriple().isOSBinFormatMachO()) | |
| section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; | |
| llvm::GlobalVariable *GV = | |
| CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false); | |
| return GV; | |
| } | |
| static void PushProtocolProperties( | |
| llvm::SmallPtrSet<const IdentifierInfo *, 16> &PropertySet, | |
| SmallVectorImpl<const ObjCPropertyDecl *> &Properties, | |
| const ObjCProtocolDecl *Proto, bool IsClassProperty) { | |
| for (const auto *PD : Proto->properties()) { | |
| if (IsClassProperty != PD->isClassProperty()) | |
| continue; | |
| if (!PropertySet.insert(PD->getIdentifier()).second) | |
| continue; | |
| Properties.push_back(PD); | |
| } | |
| for (const auto *P : Proto->protocols()) | |
| PushProtocolProperties(PropertySet, Properties, P, IsClassProperty); | |
| } | |
| /* | |
| struct _objc_property { | |
| const char * const name; | |
| const char * const attributes; | |
| }; | |
| struct _objc_property_list { | |
| uint32_t entsize; // sizeof (struct _objc_property) | |
| uint32_t prop_count; | |
| struct _objc_property[prop_count]; | |
| }; | |
| */ | |
| llvm::Constant *CGObjCCommonMac::EmitPropertyList( | |
| Twine Name, const Decl *Container, const ObjCContainerDecl *OCD, | |
| const ObjCCommonTypesHelper &ObjCTypes, bool IsClassProperty) { | |
| if (IsClassProperty) { | |
| // Make this entry NULL for OS X with deployment target < 10.11, for iOS | |
| // with deployment target < 9.0. | |
| const llvm::Triple &Triple = CGM.getTarget().getTriple(); | |
| if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) || | |
| (Triple.isiOS() && Triple.isOSVersionLT(9))) | |
| return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); | |
| } | |
| SmallVector<const ObjCPropertyDecl *, 16> Properties; | |
| llvm::SmallPtrSet<const IdentifierInfo *, 16> PropertySet; | |
| if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) | |
| for (const ObjCCategoryDecl *ClassExt : OID->known_extensions()) | |
| for (auto *PD : ClassExt->properties()) { | |
| if (IsClassProperty != PD->isClassProperty()) | |
| continue; | |
| if (PD->isDirectProperty()) | |
| continue; | |
| PropertySet.insert(PD->getIdentifier()); | |
| Properties.push_back(PD); | |
| } | |
| for (const auto *PD : OCD->properties()) { | |
| if (IsClassProperty != PD->isClassProperty()) | |
| continue; | |
| // Don't emit duplicate metadata for properties that were already in a | |
| // class extension. | |
| if (!PropertySet.insert(PD->getIdentifier()).second) | |
| continue; | |
| if (PD->isDirectProperty()) | |
| continue; | |
| Properties.push_back(PD); | |
| } | |
| if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) { | |
| for (const auto *P : OID->all_referenced_protocols()) | |
| PushProtocolProperties(PropertySet, Properties, P, IsClassProperty); | |
| } else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) { | |
| for (const auto *P : CD->protocols()) | |
| PushProtocolProperties(PropertySet, Properties, P, IsClassProperty); | |
| } | |
| // Return null for empty list. | |
| if (Properties.empty()) | |
| return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy); | |
| unsigned propertySize = | |
| CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy); | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(); | |
| values.addInt(ObjCTypes.IntTy, propertySize); | |
| values.addInt(ObjCTypes.IntTy, Properties.size()); | |
| auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy); | |
| for (auto PD : Properties) { | |
| auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy); | |
| property.add(GetPropertyName(PD->getIdentifier())); | |
| property.add(GetPropertyTypeString(PD, Container)); | |
| property.finishAndAddTo(propertiesArray); | |
| } | |
| propertiesArray.finishAndAddTo(values); | |
| StringRef Section; | |
| if (CGM.getTriple().isOSBinFormatMachO()) | |
| Section = (ObjCABI == 2) ? "__DATA, __objc_const" | |
| : "__OBJC,__property,regular,no_dead_strip"; | |
| llvm::GlobalVariable *GV = | |
| CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true); | |
| return GV; | |
| } | |
| llvm::Constant *CGObjCCommonMac::EmitProtocolMethodTypes( | |
| Twine Name, ArrayRef<llvm::Constant *> MethodTypes, | |
| const ObjCCommonTypesHelper &ObjCTypes) { | |
| // Return null for empty list. | |
| if (MethodTypes.empty()) | |
| return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy); | |
| llvm::ArrayType *AT = | |
| llvm::ArrayType::get(ObjCTypes.Int8PtrTy, MethodTypes.size()); | |
| llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes); | |
| StringRef Section; | |
| if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2) | |
| Section = "__DATA, __objc_const"; | |
| llvm::GlobalVariable *GV = | |
| CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true); | |
| return GV; | |
| } | |
| /* | |
| struct _objc_category { | |
| char *category_name; | |
| char *class_name; | |
| struct _objc_method_list *instance_methods; | |
| struct _objc_method_list *class_methods; | |
| struct _objc_protocol_list *protocols; | |
| uint32_t size; // sizeof(struct _objc_category) | |
| struct _objc_property_list *instance_properties; | |
| struct _objc_property_list *class_properties; | |
| }; | |
| */ | |
| void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) { | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy); | |
| // FIXME: This is poor design, the OCD should have a pointer to the category | |
| // decl. Additionally, note that Category can be null for the @implementation | |
| // w/o an @interface case. Sema should just create one for us as it does for | |
| // @implementation so everyone else can live life under a clear blue sky. | |
| const ObjCInterfaceDecl *Interface = OCD->getClassInterface(); | |
| const ObjCCategoryDecl *Category = | |
| Interface->FindCategoryDeclaration(OCD->getIdentifier()); | |
| SmallString<256> ExtName; | |
| llvm::raw_svector_ostream(ExtName) | |
| << Interface->getName() << '_' << OCD->getName(); | |
| ConstantInitBuilder Builder(CGM); | |
| auto Values = Builder.beginStruct(ObjCTypes.CategoryTy); | |
| enum { InstanceMethods, ClassMethods, NumMethodLists }; | |
| SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists]; | |
| for (const auto *MD : OCD->methods()) { | |
| if (!MD->isDirectMethod()) | |
| Methods[unsigned(MD->isClassMethod())].push_back(MD); | |
| } | |
| Values.add(GetClassName(OCD->getName())); | |
| Values.add(GetClassName(Interface->getObjCRuntimeNameAsString())); | |
| LazySymbols.insert(Interface->getIdentifier()); | |
| Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods, | |
| Methods[InstanceMethods])); | |
| Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods, | |
| Methods[ClassMethods])); | |
| if (Category) { | |
| Values.add(EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(), | |
| Category->protocol_begin(), | |
| Category->protocol_end())); | |
| } else { | |
| Values.addNullPointer(ObjCTypes.ProtocolListPtrTy); | |
| } | |
| Values.addInt(ObjCTypes.IntTy, Size); | |
| // If there is no category @interface then there can be no properties. | |
| if (Category) { | |
| Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(), OCD, | |
| Category, ObjCTypes, false)); | |
| Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(), OCD, | |
| Category, ObjCTypes, true)); | |
| } else { | |
| Values.addNullPointer(ObjCTypes.PropertyListPtrTy); | |
| Values.addNullPointer(ObjCTypes.PropertyListPtrTy); | |
| } | |
| llvm::GlobalVariable *GV = CreateMetadataVar( | |
| "OBJC_CATEGORY_" + ExtName.str(), Values, | |
| "__OBJC,__category,regular,no_dead_strip", CGM.getPointerAlign(), true); | |
| DefinedCategories.push_back(GV); | |
| DefinedCategoryNames.insert(llvm::CachedHashString(ExtName)); | |
| // method definition entries must be clear for next implementation. | |
| MethodDefinitions.clear(); | |
| } | |
| // clang-format off | |
| enum FragileClassFlags { | |
| /// Apparently: is not a meta-class. | |
| FragileABI_Class_Factory = 0x00001, | |
| /// Is a meta-class. | |
| FragileABI_Class_Meta = 0x00002, | |
| /// Has a non-trivial constructor or destructor. | |
| FragileABI_Class_HasCXXStructors = 0x02000, | |
| /// Has hidden visibility. | |
| FragileABI_Class_Hidden = 0x20000, | |
| /// Class implementation was compiled under ARC. | |
| FragileABI_Class_CompiledByARC = 0x04000000, | |
| /// Class implementation was compiled under MRC and has MRC weak ivars. | |
| /// Exclusive with CompiledByARC. | |
| FragileABI_Class_HasMRCWeakIvars = 0x08000000, | |
| }; | |
| enum NonFragileClassFlags { | |
| /// Is a meta-class. | |
| NonFragileABI_Class_Meta = 0x00001, | |
| /// Is a root class. | |
| NonFragileABI_Class_Root = 0x00002, | |
| /// Has a non-trivial constructor or destructor. | |
| NonFragileABI_Class_HasCXXStructors = 0x00004, | |
| /// Has hidden visibility. | |
| NonFragileABI_Class_Hidden = 0x00010, | |
| /// Has the exception attribute. | |
| NonFragileABI_Class_Exception = 0x00020, | |
| /// (Obsolete) ARC-specific: this class has a .release_ivars method | |
| NonFragileABI_Class_HasIvarReleaser = 0x00040, | |
| /// Class implementation was compiled under ARC. | |
| NonFragileABI_Class_CompiledByARC = 0x00080, | |
| /// Class has non-trivial destructors, but zero-initialization is okay. | |
| NonFragileABI_Class_HasCXXDestructorOnly = 0x00100, | |
| /// Class implementation was compiled under MRC and has MRC weak ivars. | |
| /// Exclusive with CompiledByARC. | |
| NonFragileABI_Class_HasMRCWeakIvars = 0x00200, | |
| }; | |
| // clang-format on | |
| static bool hasWeakMember(QualType type) { | |
| if (type.getObjCLifetime() == Qualifiers::OCL_Weak) { | |
| return true; | |
| } | |
| if (auto *RD = type->getAsRecordDecl()) { | |
| for (auto *field : RD->fields()) { | |
| if (hasWeakMember(field->getType())) | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| /// For compatibility, we only want to set the "HasMRCWeakIvars" flag | |
| /// (and actually fill in a layout string) if we really do have any | |
| /// __weak ivars. | |
| static bool hasMRCWeakIvars(CodeGenModule &CGM, | |
| const ObjCImplementationDecl *ID) { | |
| if (!CGM.getLangOpts().ObjCWeak) | |
| return false; | |
| assert(CGM.getLangOpts().getGC() == LangOptions::NonGC); | |
| for (const ObjCIvarDecl *ivar = | |
| ID->getClassInterface()->all_declared_ivar_begin(); | |
| ivar; ivar = ivar->getNextIvar()) { | |
| if (hasWeakMember(ivar->getType())) | |
| return true; | |
| } | |
| return false; | |
| } | |
| /* | |
| struct _objc_class { | |
| Class isa; | |
| Class super_class; | |
| const char *name; | |
| long version; | |
| long info; | |
| long instance_size; | |
| struct _objc_ivar_list *ivars; | |
| struct _objc_method_list *methods; | |
| struct _objc_cache *cache; | |
| struct _objc_protocol_list *protocols; | |
| // Objective-C 1.0 extensions (<rdr://4585769>) | |
| const char *ivar_layout; | |
| struct _objc_class_ext *ext; | |
| }; | |
| See EmitClassExtension(); | |
| */ | |
| void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) { | |
| IdentifierInfo *RuntimeName = | |
| &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString()); | |
| DefinedSymbols.insert(RuntimeName); | |
| std::string ClassName = ID->getNameAsString(); | |
| // FIXME: Gross | |
| ObjCInterfaceDecl *Interface = | |
| const_cast<ObjCInterfaceDecl *>(ID->getClassInterface()); | |
| llvm::Constant *Protocols = | |
| EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(), | |
| Interface->all_referenced_protocol_begin(), | |
| Interface->all_referenced_protocol_end()); | |
| unsigned Flags = FragileABI_Class_Factory; | |
| if (ID->hasNonZeroConstructors() || ID->hasDestructors()) | |
| Flags |= FragileABI_Class_HasCXXStructors; | |
| bool hasMRCWeak = false; | |
| if (CGM.getLangOpts().ObjCAutoRefCount) | |
| Flags |= FragileABI_Class_CompiledByARC; | |
| else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID))) | |
| Flags |= FragileABI_Class_HasMRCWeakIvars; | |
| CharUnits Size = CGM.getContext() | |
| .getASTObjCInterfaceLayout(ID->getClassInterface()) | |
| .getSize(); | |
| // FIXME: Set CXX-structors flag. | |
| if (ID->getClassInterface()->getVisibility() == HiddenVisibility) | |
| Flags |= FragileABI_Class_Hidden; | |
| enum { InstanceMethods, ClassMethods, NumMethodLists }; | |
| SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists]; | |
| for (const auto *MD : ID->methods()) { | |
| if (!MD->isDirectMethod()) | |
| Methods[unsigned(MD->isClassMethod())].push_back(MD); | |
| } | |
| for (const auto *PID : ID->property_impls()) { | |
| if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { | |
| if (PID->getPropertyDecl()->isDirectProperty()) | |
| continue; | |
| if (ObjCMethodDecl *MD = PID->getGetterMethodDecl()) | |
| if (GetMethodDefinition(MD)) | |
| Methods[InstanceMethods].push_back(MD); | |
| if (ObjCMethodDecl *MD = PID->getSetterMethodDecl()) | |
| if (GetMethodDefinition(MD)) | |
| Methods[InstanceMethods].push_back(MD); | |
| } | |
| } | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.ClassTy); | |
| values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods])); | |
| if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) { | |
| // Record a reference to the super class. | |
| LazySymbols.insert(Super->getIdentifier()); | |
| values.add(GetClassName(Super->getObjCRuntimeNameAsString())); | |
| } else { | |
| values.addNullPointer(ObjCTypes.ClassPtrTy); | |
| } | |
| values.add(GetClassName(ID->getObjCRuntimeNameAsString())); | |
| // Version is always 0. | |
| values.addInt(ObjCTypes.LongTy, 0); | |
| values.addInt(ObjCTypes.LongTy, Flags); | |
| values.addInt(ObjCTypes.LongTy, Size.getQuantity()); | |
| values.add(EmitIvarList(ID, false)); | |
| values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods, | |
| Methods[InstanceMethods])); | |
| // cache is always NULL. | |
| values.addNullPointer(ObjCTypes.CachePtrTy); | |
| values.add(Protocols); | |
| values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size)); | |
| values.add(EmitClassExtension(ID, Size, hasMRCWeak, | |
| /*isMetaclass*/ false)); | |
| std::string Name("OBJC_CLASS_"); | |
| Name += ClassName; | |
| const char *Section = "__OBJC,__class,regular,no_dead_strip"; | |
| // Check for a forward reference. | |
| llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); | |
| if (GV) { | |
| assert(GV->getValueType() == ObjCTypes.ClassTy && | |
| "Forward metaclass reference has incorrect type."); | |
| values.finishAndSetAsInitializer(GV); | |
| GV->setSection(Section); | |
| GV->setAlignment(CGM.getPointerAlign().getAsAlign()); | |
| CGM.addCompilerUsedGlobal(GV); | |
| } else | |
| GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true); | |
| DefinedClasses.push_back(GV); | |
| ImplementedClasses.push_back(Interface); | |
| // method definition entries must be clear for next implementation. | |
| MethodDefinitions.clear(); | |
| } | |
| llvm::Constant * | |
| CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID, | |
| llvm::Constant *Protocols, | |
| ArrayRef<const ObjCMethodDecl *> Methods) { | |
| unsigned Flags = FragileABI_Class_Meta; | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy); | |
| if (ID->getClassInterface()->getVisibility() == HiddenVisibility) | |
| Flags |= FragileABI_Class_Hidden; | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.ClassTy); | |
| // The isa for the metaclass is the root of the hierarchy. | |
| const ObjCInterfaceDecl *Root = ID->getClassInterface(); | |
| while (const ObjCInterfaceDecl *Super = Root->getSuperClass()) | |
| Root = Super; | |
| values.add(GetClassName(Root->getObjCRuntimeNameAsString())); | |
| // The super class for the metaclass is emitted as the name of the | |
| // super class. The runtime fixes this up to point to the | |
| // *metaclass* for the super class. | |
| if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) { | |
| values.add(GetClassName(Super->getObjCRuntimeNameAsString())); | |
| } else { | |
| values.addNullPointer(ObjCTypes.ClassPtrTy); | |
| } | |
| values.add(GetClassName(ID->getObjCRuntimeNameAsString())); | |
| // Version is always 0. | |
| values.addInt(ObjCTypes.LongTy, 0); | |
| values.addInt(ObjCTypes.LongTy, Flags); | |
| values.addInt(ObjCTypes.LongTy, Size); | |
| values.add(EmitIvarList(ID, true)); | |
| values.add( | |
| emitMethodList(ID->getName(), MethodListType::ClassMethods, Methods)); | |
| // cache is always NULL. | |
| values.addNullPointer(ObjCTypes.CachePtrTy); | |
| values.add(Protocols); | |
| // ivar_layout for metaclass is always NULL. | |
| values.addNullPointer(ObjCTypes.Int8PtrTy); | |
| // The class extension is used to store class properties for metaclasses. | |
| values.add(EmitClassExtension(ID, CharUnits::Zero(), false /*hasMRCWeak*/, | |
| /*isMetaclass*/ true)); | |
| std::string Name("OBJC_METACLASS_"); | |
| Name += ID->getName(); | |
| // Check for a forward reference. | |
| llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); | |
| if (GV) { | |
| assert(GV->getValueType() == ObjCTypes.ClassTy && | |
| "Forward metaclass reference has incorrect type."); | |
| values.finishAndSetAsInitializer(GV); | |
| } else { | |
| GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(), | |
| /*constant*/ false, | |
| llvm::GlobalValue::PrivateLinkage); | |
| } | |
| GV->setSection("__OBJC,__meta_class,regular,no_dead_strip"); | |
| CGM.addCompilerUsedGlobal(GV); | |
| return GV; | |
| } | |
| llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) { | |
| std::string Name = "OBJC_METACLASS_" + ID->getNameAsString(); | |
| // FIXME: Should we look these up somewhere other than the module. Its a bit | |
| // silly since we only generate these while processing an implementation, so | |
| // exactly one pointer would work if know when we entered/exitted an | |
| // implementation block. | |
| // Check for an existing forward reference. | |
| // Previously, metaclass with internal linkage may have been defined. | |
| // pass 'true' as 2nd argument so it is returned. | |
| llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); | |
| if (!GV) | |
| GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false, | |
| llvm::GlobalValue::PrivateLinkage, nullptr, | |
| Name); | |
| assert(GV->getValueType() == ObjCTypes.ClassTy && | |
| "Forward metaclass reference has incorrect type."); | |
| return GV; | |
| } | |
| llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) { | |
| std::string Name = "OBJC_CLASS_" + ID->getNameAsString(); | |
| llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true); | |
| if (!GV) | |
| GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false, | |
| llvm::GlobalValue::PrivateLinkage, nullptr, | |
| Name); | |
| assert(GV->getValueType() == ObjCTypes.ClassTy && | |
| "Forward class metadata reference has incorrect type."); | |
| return GV; | |
| } | |
| /* | |
| Emit a "class extension", which in this specific context means extra | |
| data that doesn't fit in the normal fragile-ABI class structure, and | |
| has nothing to do with the language concept of a class extension. | |
| struct objc_class_ext { | |
| uint32_t size; | |
| const char *weak_ivar_layout; | |
| struct _objc_property_list *properties; | |
| }; | |
| */ | |
| llvm::Constant *CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID, | |
| CharUnits InstanceSize, | |
| bool hasMRCWeakIvars, | |
| bool isMetaclass) { | |
| // Weak ivar layout. | |
| llvm::Constant *layout; | |
| if (isMetaclass) { | |
| layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy); | |
| } else { | |
| layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize, | |
| hasMRCWeakIvars); | |
| } | |
| // Properties. | |
| llvm::Constant *propertyList = | |
| EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_") | |
| : Twine("_OBJC_$_PROP_LIST_")) + | |
| ID->getName(), | |
| ID, ID->getClassInterface(), ObjCTypes, isMetaclass); | |
| // Return null if no extension bits are used. | |
| if (layout->isNullValue() && propertyList->isNullValue()) { | |
| return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy); | |
| } | |
| uint64_t size = | |
| CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy); | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy); | |
| values.addInt(ObjCTypes.IntTy, size); | |
| values.add(layout); | |
| values.add(propertyList); | |
| return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values, | |
| "__OBJC,__class_ext,regular,no_dead_strip", | |
| CGM.getPointerAlign(), true); | |
| } | |
| /* | |
| struct objc_ivar { | |
| char *ivar_name; | |
| char *ivar_type; | |
| int ivar_offset; | |
| }; | |
| struct objc_ivar_list { | |
| int ivar_count; | |
| struct objc_ivar list[count]; | |
| }; | |
| */ | |
| llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID, | |
| bool ForClass) { | |
| // When emitting the root class GCC emits ivar entries for the | |
| // actual class structure. It is not clear if we need to follow this | |
| // behavior; for now lets try and get away with not doing it. If so, | |
| // the cleanest solution would be to make up an ObjCInterfaceDecl | |
| // for the class. | |
| if (ForClass) | |
| return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy); | |
| const ObjCInterfaceDecl *OID = ID->getClassInterface(); | |
| ConstantInitBuilder builder(CGM); | |
| auto ivarList = builder.beginStruct(); | |
| auto countSlot = ivarList.addPlaceholder(); | |
| auto ivars = ivarList.beginArray(ObjCTypes.IvarTy); | |
| for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin(); IVD; | |
| IVD = IVD->getNextIvar()) { | |
| // Ignore unnamed bit-fields. | |
| if (!IVD->getDeclName()) | |
| continue; | |
| auto ivar = ivars.beginStruct(ObjCTypes.IvarTy); | |
| ivar.add(GetMethodVarName(IVD->getIdentifier())); | |
| ivar.add(GetMethodVarType(IVD)); | |
| ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD)); | |
| ivar.finishAndAddTo(ivars); | |
| } | |
| // Return null for empty list. | |
| auto count = ivars.size(); | |
| if (count == 0) { | |
| ivars.abandon(); | |
| ivarList.abandon(); | |
| return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy); | |
| } | |
| ivars.finishAndAddTo(ivarList); | |
| ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count); | |
| llvm::GlobalVariable *GV; | |
| GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList, | |
| "__OBJC,__instance_vars,regular,no_dead_strip", | |
| CGM.getPointerAlign(), true); | |
| return GV; | |
| } | |
| /// Build a struct objc_method_description constant for the given method. | |
| /// | |
| /// struct objc_method_description { | |
| /// SEL method_name; | |
| /// char *method_types; | |
| /// }; | |
| void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder, | |
| const ObjCMethodDecl *MD) { | |
| auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy); | |
| description.add(GetMethodVarName(MD->getSelector())); | |
| description.add(GetMethodVarType(MD)); | |
| description.finishAndAddTo(builder); | |
| } | |
| /// Build a struct objc_method constant for the given method. | |
| /// | |
| /// struct objc_method { | |
| /// SEL method_name; | |
| /// char *method_types; | |
| /// void *method; | |
| /// }; | |
| void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder, | |
| const ObjCMethodDecl *MD) { | |
| llvm::Function *fn = GetMethodDefinition(MD); | |
| assert(fn && "no definition registered for method"); | |
| auto method = builder.beginStruct(ObjCTypes.MethodTy); | |
| method.add(GetMethodVarName(MD->getSelector())); | |
| method.add(GetMethodVarType(MD)); | |
| method.add(fn); | |
| method.finishAndAddTo(builder); | |
| } | |
| /// Build a struct objc_method_list or struct objc_method_description_list, | |
| /// as appropriate. | |
| /// | |
| /// struct objc_method_list { | |
| /// struct objc_method_list *obsolete; | |
| /// int count; | |
| /// struct objc_method methods_list[count]; | |
| /// }; | |
| /// | |
| /// struct objc_method_description_list { | |
| /// int count; | |
| /// struct objc_method_description list[count]; | |
| /// }; | |
| llvm::Constant * | |
| CGObjCMac::emitMethodList(Twine name, MethodListType MLT, | |
| ArrayRef<const ObjCMethodDecl *> methods) { | |
| StringRef prefix; | |
| StringRef section; | |
| bool forProtocol = false; | |
| switch (MLT) { | |
| case MethodListType::CategoryInstanceMethods: | |
| prefix = "OBJC_CATEGORY_INSTANCE_METHODS_"; | |
| section = "__OBJC,__cat_inst_meth,regular,no_dead_strip"; | |
| forProtocol = false; | |
| break; | |
| case MethodListType::CategoryClassMethods: | |
| prefix = "OBJC_CATEGORY_CLASS_METHODS_"; | |
| section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; | |
| forProtocol = false; | |
| break; | |
| case MethodListType::InstanceMethods: | |
| prefix = "OBJC_INSTANCE_METHODS_"; | |
| section = "__OBJC,__inst_meth,regular,no_dead_strip"; | |
| forProtocol = false; | |
| break; | |
| case MethodListType::ClassMethods: | |
| prefix = "OBJC_CLASS_METHODS_"; | |
| section = "__OBJC,__cls_meth,regular,no_dead_strip"; | |
| forProtocol = false; | |
| break; | |
| case MethodListType::ProtocolInstanceMethods: | |
| prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_"; | |
| section = "__OBJC,__cat_inst_meth,regular,no_dead_strip"; | |
| forProtocol = true; | |
| break; | |
| case MethodListType::ProtocolClassMethods: | |
| prefix = "OBJC_PROTOCOL_CLASS_METHODS_"; | |
| section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; | |
| forProtocol = true; | |
| break; | |
| case MethodListType::OptionalProtocolInstanceMethods: | |
| prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_"; | |
| section = "__OBJC,__cat_inst_meth,regular,no_dead_strip"; | |
| forProtocol = true; | |
| break; | |
| case MethodListType::OptionalProtocolClassMethods: | |
| prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_"; | |
| section = "__OBJC,__cat_cls_meth,regular,no_dead_strip"; | |
| forProtocol = true; | |
| break; | |
| } | |
| // Return null for empty list. | |
| if (methods.empty()) | |
| return llvm::Constant::getNullValue( | |
| forProtocol ? ObjCTypes.MethodDescriptionListPtrTy | |
| : ObjCTypes.MethodListPtrTy); | |
| // For protocols, this is an objc_method_description_list, which has | |
| // a slightly different structure. | |
| if (forProtocol) { | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(); | |
| values.addInt(ObjCTypes.IntTy, methods.size()); | |
| auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy); | |
| for (auto MD : methods) { | |
| emitMethodDescriptionConstant(methodArray, MD); | |
| } | |
| methodArray.finishAndAddTo(values); | |
| llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section, | |
| CGM.getPointerAlign(), true); | |
| return GV; | |
| } | |
| // Otherwise, it's an objc_method_list. | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(); | |
| values.addNullPointer(ObjCTypes.Int8PtrTy); | |
| values.addInt(ObjCTypes.IntTy, methods.size()); | |
| auto methodArray = values.beginArray(ObjCTypes.MethodTy); | |
| for (auto MD : methods) { | |
| if (!MD->isDirectMethod()) | |
| emitMethodConstant(methodArray, MD); | |
| } | |
| methodArray.finishAndAddTo(values); | |
| llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section, | |
| CGM.getPointerAlign(), true); | |
| return GV; | |
| } | |
| llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD) { | |
| llvm::Function *Method; | |
| if (OMD->isDirectMethod()) { | |
| // Returns DirectMethodInfo& containing both Implementation and Thunk | |
| DirectMethodInfo &Info = GenerateDirectMethod(OMD, CD); | |
| Method = Info.Implementation; // Extract implementation for body generation | |
| } else { | |
| auto Name = getSymbolNameForMethod(OMD); | |
| CodeGenTypes &Types = CGM.getTypes(); | |
| llvm::FunctionType *MethodTy = | |
| Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD)); | |
| Method = llvm::Function::Create( | |
| MethodTy, llvm::GlobalValue::InternalLinkage, Name, &CGM.getModule()); | |
| } | |
| MethodDefinitions.insert(std::make_pair(OMD, Method)); | |
| return Method; | |
| } | |
| /// Generate or retrieve a direct method info. | |
| CGObjCCommonMac::DirectMethodInfo & | |
| CGObjCCommonMac::GenerateDirectMethod(const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD) { | |
| auto *COMD = OMD->getCanonicalDecl(); | |
| // Fast path: return cached entry if this is not an implementation (no body) | |
| // or if the return types match between declaration and implementation. | |
| auto Cached = DirectMethodDefinitions.find(COMD); | |
| if (Cached != DirectMethodDefinitions.end()) { | |
| if (!OMD->getBody() || COMD->getReturnType() == OMD->getReturnType()) | |
| return Cached->second; | |
| } | |
| CodeGenTypes &Types = CGM.getTypes(); | |
| llvm::FunctionType *MethodTy = | |
| Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD)); | |
| std::string Name = | |
| getSymbolNameForMethod(OMD, /*includeCategoryName*/ false, | |
| CGM.isObjCDirectPreconditionThunkEnabled()); | |
| std::string ThunkName = Name + "_thunk"; | |
| // Replace OldFn with NewFn: transfer name, replace all uses, and erase. | |
| auto ReplaceFunction = [](llvm::Function *OldFn, llvm::Function *NewFn) { | |
| NewFn->takeName(OldFn); | |
| OldFn->replaceAllUsesWith(NewFn); | |
| OldFn->eraseFromParent(); | |
| }; | |
| // Check if the function already exists in the module (created by Clang or | |
| // Swift). | |
| llvm::Function *Fn = CGM.getModule().getFunction(Name); | |
| // Function doesn't exist yet. | |
| if (!Fn) { | |
| Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage, | |
| Name, &CGM.getModule()); | |
| return DirectMethodDefinitions.insert({COMD, DirectMethodInfo(Fn)}) | |
| .first->second; | |
| } | |
| // Function exists with matching type. | |
| // Other frontends operating on the same module may have created the function. | |
| if (Fn->getFunctionType() == MethodTy) { | |
| // Reinforce linkage in case Swift created it with different linkage. | |
| Fn->setLinkage(llvm::GlobalValue::ExternalLinkage); | |
| // Check if Swift also created a thunk for this method. | |
| DirectMethodInfo Info(Fn); | |
| if (llvm::Function *Thunk = CGM.getModule().getFunction(ThunkName)) | |
| Info.Thunk = Thunk; | |
| return DirectMethodDefinitions.insert({COMD, Info}).first->second; | |
| } | |
| // Function exists but with mismatched type - replace it. | |
| // This happens when Swift's optional handling differs from ObjC, or when | |
| // ObjC declaration and implementation have slightly different return types. | |
| llvm::Function *NewFn = llvm::Function::Create( | |
| MethodTy, llvm::GlobalValue::ExternalLinkage, "", &CGM.getModule()); | |
| ReplaceFunction(Fn, NewFn); | |
| // Check if the thunk also needs replacement. | |
| DirectMethodInfo Info(NewFn); | |
| if (llvm::Function *OldThunk = CGM.getModule().getFunction(ThunkName)) { | |
| llvm::Function *NewThunk = GenerateObjCDirectThunk(OMD, CD, NewFn); | |
| ReplaceFunction(OldThunk, NewThunk); | |
| Info.Thunk = NewThunk; | |
| } | |
| if (Cached != DirectMethodDefinitions.end()) { | |
| Cached->second = Info; | |
| return Cached->second; | |
| } | |
| return DirectMethodDefinitions.insert({COMD, Info}).first->second; | |
| } | |
| /// Start an Objective-C direct method precondition thunk. | |
| void CodeGenFunction::StartObjCDirectPreconditionThunk( | |
| const ObjCMethodDecl *OMD, llvm::Function *Fn, const CGFunctionInfo &FI) { | |
| // Mark this as a thunk function to disable ARC parameter processing | |
| // and other thunk-inappropriate behavior. We don't need to retain | |
| // parameters because we're going to immediately forward them. | |
| // | |
| // Skipping ARC parameter processing is correct as long as (1) we don't | |
| // run any code that could invalidate the parameters between the start of | |
| // the thunk and the call and (2) we don't use the parameters after the | |
| // call. Both hold whether we tail-call or not. Class realization could in | |
| // theory invalidate parameters, but we assume that doesn't happen in | |
| // practice. | |
| CurFuncIsThunk = true; | |
| // Build argument list for StartFunction. | |
| // We must include all parameters to match the thunk's LLVM function type. | |
| FunctionArgList FunctionArgs; | |
| FunctionArgs.push_back(OMD->getSelfDecl()); | |
| FunctionArgs.append(OMD->param_begin(), OMD->param_end()); | |
| // The Start/Finish thunk pattern is borrowed from CGVTables.cpp | |
| // for C++ virtual method thunks, but adapted for ObjC direct methods. | |
| // | |
| // Like C++ thunks, we don't have an actual AST body for the thunk - we only | |
| // have the method's parameter declarations. Therefore, we pass empty | |
| // `GlobalDecl` to `StartFunction` ... | |
| StartFunction(GlobalDecl(), OMD->getReturnType(), Fn, FI, FunctionArgs, | |
| OMD->getLocation(), OMD->getLocation()); | |
| // and manually set the decl afterwards so other utilities / helpers in CGF | |
| // can still access the AST (e.g. arrange function arguments) | |
| CurCodeDecl = OMD; | |
| CurFuncDecl = OMD; | |
| } | |
| /// Finish an Objective-C direct method precondition thunk. | |
| void CodeGenFunction::FinishObjCDirectPreconditionThunk() { | |
| // Create a dummy block to return the value of the thunk. | |
| // | |
| // The non-nil branch alredy returned because of musttail. | |
| // Only nil branch will jump to this return block. | |
| // If the nil check is not emitted (for class methods), this will be a dead | |
| // block. | |
| // | |
| // Either way, the LLVM optimizer will simplify it later. This is just to make | |
| // CFG happy. | |
| EmitBlock(createBasicBlock("dummy_ret_block")); | |
| // Disable the final ARC autorelease. | |
| // Thunk functions are tailcall to actual implementation, so it doesn't need | |
| // to worry about ARC. | |
| AutoreleaseResult = false; | |
| // Clear these to restore the invariants expected by | |
| // StartFunction/FinishFunction. | |
| CurCodeDecl = nullptr; | |
| CurFuncDecl = nullptr; | |
| FinishFunction(); | |
| } | |
| llvm::Function * | |
| CGObjCCommonMac::GenerateObjCDirectThunk(const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD, | |
| llvm::Function *Implementation) { | |
| assert(CGM.shouldHavePreconditionThunk(OMD) && | |
| "Should only generate thunk when optimization enabled"); | |
| assert(Implementation && "Implementation must exist"); | |
| llvm::FunctionType *ThunkTy = Implementation->getFunctionType(); | |
| std::string ThunkName = Implementation->getName().str() + "_thunk"; | |
| // Create thunk with linkonce_odr linkage (allows deduplication) | |
| llvm::Function *Thunk = | |
| llvm::Function::Create(ThunkTy, llvm::GlobalValue::LinkOnceODRLinkage, | |
| ThunkName, &CGM.getModule()); | |
| // Thunks should always have hidden visibility, other link units will have | |
| // their own version of the (identical) thunk. If they make cross link-unit | |
| // call, they are either calling through their thunk or directly dispatching | |
| // to the true implementation, so making thunk visibile is meaningless. | |
| Thunk->setVisibility(llvm::GlobalValue::HiddenVisibility); | |
| Thunk->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); | |
| // Start the ObjC direct thunk (sets up state and calls StartFunction) | |
| const CGFunctionInfo &FI = CGM.getTypes().arrangeObjCMethodDeclaration(OMD); | |
| // Create a CodeGenFunction to generate the thunk body | |
| CodeGenFunction CGF(CGM); | |
| CGF.StartObjCDirectPreconditionThunk(OMD, Thunk, FI); | |
| // Set function attributes from CGFunctionInfo to ensure the thunk has | |
| // matching parameter attributes (especially sret) for musttail correctness. | |
| // We use SetLLVMFunctionAttributes rather than copying from Implementation | |
| // because Implementation may not have its attributes set yet at this point. | |
| CGM.SetLLVMFunctionAttributes(GlobalDecl(OMD), FI, Thunk, /*IsThunk=*/false); | |
| CGM.SetLLVMFunctionAttributesForDefinition(OMD, Thunk); | |
| // - [self self] for class methods (class realization) | |
| // - if (self == nil) branch to nil block with zero return | |
| // - continuation block for non-nil case | |
| GenerateDirectMethodsPreconditionCheck(CGF, Thunk, OMD, CD); | |
| // Now emit the musttail call to the true implementation | |
| // Collect all arguments for forwarding | |
| SmallVector<llvm::Value *, 8> Args; | |
| for (auto &Arg : Thunk->args()) | |
| Args.push_back(&Arg); | |
| // Create musttail call to the implementation | |
| llvm::CallInst *Call = CGF.Builder.CreateCall(Implementation, Args); | |
| Call->setTailCallKind(llvm::CallInst::TCK_MustTail); | |
| // Apply call-site attributes using ConstructAttributeList | |
| // When sret is used, the call must have matching sret attributes on the first | |
| // parameter for musttail to work correctly. This mirrors what C++ thunks do | |
| // in EmitMustTailThunk. | |
| unsigned CallingConv; | |
| llvm::AttributeList Attrs; | |
| CGM.ConstructAttributeList(Implementation->getName(), FI, GlobalDecl(OMD), | |
| Attrs, CallingConv, /*AttrOnCallSite=*/true, | |
| /*IsThunk=*/false); | |
| Call->setAttributes(Attrs); | |
| Call->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv)); | |
| // Immediately return the call result (musttail requirement). | |
| // For sret returns, the Apple ABI produces void-returning LLVM functions, | |
| // so checking the LLVM return type is suffice. | |
| if (ThunkTy->getReturnType()->isVoidTy()) | |
| CGF.Builder.CreateRetVoid(); | |
| else | |
| CGF.Builder.CreateRet(Call); | |
| // Finish the ObjC direct thunk (creates dummy block and calls FinishFunction) | |
| CGF.FinishObjCDirectPreconditionThunk(); | |
| return Thunk; | |
| } | |
| llvm::Function *CGObjCCommonMac::GetDirectMethodCallee( | |
| const ObjCMethodDecl *OMD, const ObjCContainerDecl *CD, | |
| bool ReceiverCanBeNull, bool ClassObjectCanBeUnrealized) { | |
| // Get from cache or populate the function declaration. | |
| // Copy by value to avoid holding a reference into DirectMethodDefinitions | |
| // DenseMap, which could be invalidated by future insertions. | |
| DirectMethodInfo Info = GenerateDirectMethod(OMD, CD); | |
| // If thunk optimization not enabled (or variadic method which can't use | |
| // thunks), use implementation directly. Variadic methods and methods without | |
| // the optimization enabled include precondition checks in the implementation. | |
| if (!CGM.shouldHavePreconditionThunk(OMD)) { | |
| return Info.Implementation; | |
| } | |
| // Thunk is lazily generated. | |
| auto getOrCreateThunk = [&]() { | |
| if (!Info.Thunk) { | |
| Info.Thunk = GenerateObjCDirectThunk(OMD, CD, Info.Implementation); | |
| // Write back the lazily created thunk to the map. | |
| DirectMethodDefinitions.insert_or_assign(OMD->getCanonicalDecl(), Info); | |
| } | |
| return Info.Thunk; | |
| }; | |
| if (OMD->isInstanceMethod()) { | |
| // If we can prove instance methods receiver is not null, return the true | |
| // implementation | |
| return ReceiverCanBeNull ? getOrCreateThunk() : Info.Implementation; | |
| } | |
| assert(OMD->isClassMethod() && | |
| "OMD should either be a class method or instance method"); | |
| // For class methods, it need to be non-null and realized before we dispatch | |
| // to true implementation | |
| return (ReceiverCanBeNull || ClassObjectCanBeUnrealized) | |
| ? getOrCreateThunk() | |
| : Info.Implementation; | |
| } | |
| llvm::Value * | |
| CGObjCCommonMac::GenerateClassRealization(CodeGenFunction &CGF, | |
| llvm::Value *classObject, | |
| const ObjCInterfaceDecl *OID) { | |
| // Generate: self = [self self] | |
| // This forces class lazy initialization | |
| Selector SelfSel = GetNullarySelector("self", CGM.getContext()); | |
| auto ResultType = CGF.getContext().getObjCIdType(); | |
| CallArgList Args; | |
| RValue result = GeneratePossiblySpecializedMessageSend( | |
| CGF, ReturnValueSlot(), ResultType, SelfSel, classObject, Args, OID, | |
| nullptr, true); | |
| return result.getScalarVal(); | |
| } | |
| void CGObjCCommonMac::GenerateDirectMethodsPreconditionCheck( | |
| CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD) { | |
| auto &Builder = CGF.Builder; | |
| bool ReceiverCanBeNull = true; | |
| auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl()); | |
| auto selfValue = Builder.CreateLoad(selfAddr); | |
| // Generate: | |
| // | |
| // /* for class methods only to force class lazy initialization */ | |
| // self = [self self]; | |
| // | |
| // /* unless the receiver is never NULL */ | |
| // if (self == nil) { | |
| // return (ReturnType){ }; | |
| // } | |
| if (OMD->isClassMethod()) { | |
| const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD); | |
| assert(OID && | |
| "GenerateDirectMethod() should be called with the Class Interface"); | |
| // TODO: If this method is inlined, the caller might know that `self` is | |
| // already initialized; for example, it might be an ordinary Objective-C | |
| // method which always receives an initialized `self`, or it might have just | |
| // forced initialization on its own. | |
| // | |
| // We should find a way to eliminate this unnecessary initialization in such | |
| // cases in LLVM. | |
| // Perform class realization using the helper function | |
| llvm::Value *realizedClass = GenerateClassRealization(CGF, selfValue, OID); | |
| Builder.CreateStore(realizedClass, selfAddr); | |
| // Nullable `Class` expressions cannot be messaged with a direct method | |
| // so the only reason why the receive can be null would be because | |
| // of weak linking. | |
| ReceiverCanBeNull = isWeakLinkedClass(OID); | |
| } | |
| // Generate nil check | |
| if (ReceiverCanBeNull) { | |
| llvm::BasicBlock *SelfIsNilBlock = | |
| CGF.createBasicBlock("objc_direct_method.self_is_nil"); | |
| llvm::BasicBlock *ContBlock = | |
| CGF.createBasicBlock("objc_direct_method.cont"); | |
| // if (self == nil) { | |
| auto selfTy = cast<llvm::PointerType>(selfValue->getType()); | |
| auto Zero = llvm::ConstantPointerNull::get(selfTy); | |
| llvm::MDBuilder MDHelper(CGM.getLLVMContext()); | |
| Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock, | |
| ContBlock, MDHelper.createUnlikelyBranchWeights()); | |
| CGF.EmitBlock(SelfIsNilBlock); | |
| // return (ReturnType){ }; | |
| auto retTy = OMD->getReturnType(); | |
| Builder.SetInsertPoint(SelfIsNilBlock); | |
| if (!retTy->isVoidType()) { | |
| CGF.EmitNullInitialization(CGF.ReturnValue, retTy); | |
| } | |
| CGF.EmitBranchThroughCleanup(CGF.ReturnBlock); | |
| // } | |
| // rest of the body | |
| CGF.EmitBlock(ContBlock); | |
| Builder.SetInsertPoint(ContBlock); | |
| } | |
| } | |
| void CGObjCCommonMac::GenerateDirectMethodPrologue( | |
| CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD, | |
| const ObjCContainerDecl *CD) { | |
| // Generate precondition checks (class realization + nil check) if needed | |
| if (!CGM.isObjCDirectPreconditionThunkEnabled()) | |
| GenerateDirectMethodsPreconditionCheck(CGF, Fn, OMD, CD); | |
| auto &Builder = CGF.Builder; | |
| // Only synthesize _cmd if it's referenced | |
| // This is the actual "prologue" work that always happens | |
| if (OMD->getCmdDecl()->isUsed()) { | |
| // `_cmd` is not a parameter to direct methods, so storage must be | |
| // explicitly declared for it. | |
| CGF.EmitVarDecl(*OMD->getCmdDecl()); | |
| Builder.CreateStore(GetSelector(CGF, OMD), | |
| CGF.GetAddrOfLocalVar(OMD->getCmdDecl())); | |
| } | |
| } | |
| llvm::Function *CGObjCCommonMac::GenerateMethodSelectorStub( | |
| Selector Sel, StringRef ClassName, const ObjCCommonTypesHelper &ObjCTypes) { | |
| assert((!ClassName.data() || !ClassName.empty()) && | |
| "class name cannot be an empty string"); | |
| auto Key = std::make_pair(Sel, ClassName); | |
| auto I = MethodSelectorStubs.find(Key); | |
| if (I != MethodSelectorStubs.end()) | |
| return I->second; | |
| auto *FnTy = llvm::FunctionType::get( | |
| ObjCTypes.ObjectPtrTy, {ObjCTypes.ObjectPtrTy, ObjCTypes.SelectorPtrTy}, | |
| /*IsVarArg=*/true); | |
| std::string FnName; | |
| if (ClassName.data()) | |
| FnName = ("objc_msgSendClass$" + Sel.getAsString() + "$_OBJC_CLASS_$_" + | |
| llvm::Twine(ClassName)) | |
| .str(); | |
| else | |
| FnName = "objc_msgSend$" + Sel.getAsString(); | |
| auto *Fn = | |
| cast<llvm::Function>(CGM.CreateRuntimeFunction(FnTy, FnName).getCallee()); | |
| MethodSelectorStubs.insert(std::make_pair(Key, Fn)); | |
| return Fn; | |
| } | |
| llvm::GlobalVariable * | |
| CGObjCCommonMac::CreateMetadataVar(Twine Name, ConstantStructBuilder &Init, | |
| StringRef Section, CharUnits Align, | |
| bool AddToUsed) { | |
| llvm::GlobalValue::LinkageTypes LT = | |
| getLinkageTypeForObjCMetadata(CGM, Section); | |
| llvm::GlobalVariable *GV = | |
| Init.finishAndCreateGlobal(Name, Align, /*constant*/ false, LT); | |
| if (!Section.empty()) | |
| GV->setSection(Section); | |
| if (AddToUsed) | |
| CGM.addCompilerUsedGlobal(GV); | |
| return GV; | |
| } | |
| llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name, | |
| llvm::Constant *Init, | |
| StringRef Section, | |
| CharUnits Align, | |
| bool AddToUsed) { | |
| llvm::Type *Ty = Init->getType(); | |
| llvm::GlobalValue::LinkageTypes LT = | |
| getLinkageTypeForObjCMetadata(CGM, Section); | |
| llvm::GlobalVariable *GV = | |
| new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name); | |
| if (!Section.empty()) | |
| GV->setSection(Section); | |
| GV->setAlignment(Align.getAsAlign()); | |
| if (AddToUsed) | |
| CGM.addCompilerUsedGlobal(GV); | |
| return GV; | |
| } | |
| llvm::GlobalVariable * | |
| CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type, | |
| bool ForceNonFragileABI, | |
| bool NullTerminate) { | |
| StringRef Label; | |
| switch (Type) { | |
| case ObjCLabelType::ClassName: | |
| Label = "OBJC_CLASS_NAME_"; | |
| break; | |
| case ObjCLabelType::MethodVarName: | |
| Label = "OBJC_METH_VAR_NAME_"; | |
| break; | |
| case ObjCLabelType::MethodVarType: | |
| Label = "OBJC_METH_VAR_TYPE_"; | |
| break; | |
| case ObjCLabelType::PropertyName: | |
| Label = "OBJC_PROP_NAME_ATTR_"; | |
| break; | |
| case ObjCLabelType::LayoutBitMap: | |
| Label = "OBJC_LAYOUT_BITMAP_"; | |
| break; | |
| } | |
| bool NonFragile = ForceNonFragileABI || isNonFragileABI(); | |
| StringRef Section; | |
| switch (Type) { | |
| case ObjCLabelType::ClassName: | |
| Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals" | |
| : "__TEXT,__cstring,cstring_literals"; | |
| break; | |
| case ObjCLabelType::MethodVarName: | |
| Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals" | |
| : "__TEXT,__cstring,cstring_literals"; | |
| break; | |
| case ObjCLabelType::MethodVarType: | |
| Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals" | |
| : "__TEXT,__cstring,cstring_literals"; | |
| break; | |
| case ObjCLabelType::PropertyName: | |
| Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals" | |
| : "__TEXT,__cstring,cstring_literals"; | |
| break; | |
| case ObjCLabelType::LayoutBitMap: | |
| Section = "__TEXT,__cstring,cstring_literals"; | |
| break; | |
| } | |
| llvm::Constant *Value = | |
| llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate); | |
| llvm::GlobalVariable *GV = new llvm::GlobalVariable( | |
| CGM.getModule(), Value->getType(), | |
| /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, Value, Label); | |
| if (CGM.getTriple().isOSBinFormatMachO()) | |
| GV->setSection(Section); | |
| GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); | |
| GV->setAlignment(CharUnits::One().getAsAlign()); | |
| CGM.addCompilerUsedGlobal(GV); | |
| return GV; | |
| } | |
| llvm::Function *CGObjCMac::ModuleInitFunction() { | |
| // Abuse this interface function as a place to finalize. | |
| FinishModule(); | |
| return nullptr; | |
| } | |
| llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() { | |
| return ObjCTypes.getGetPropertyFn(); | |
| } | |
| llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() { | |
| return ObjCTypes.getSetPropertyFn(); | |
| } | |
| llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic, | |
| bool copy) { | |
| return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy); | |
| } | |
| llvm::FunctionCallee CGObjCMac::GetGetStructFunction() { | |
| return ObjCTypes.getCopyStructFn(); | |
| } | |
| llvm::FunctionCallee CGObjCMac::GetSetStructFunction() { | |
| return ObjCTypes.getCopyStructFn(); | |
| } | |
| llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() { | |
| return ObjCTypes.getCppAtomicObjectFunction(); | |
| } | |
| llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() { | |
| return ObjCTypes.getCppAtomicObjectFunction(); | |
| } | |
| llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() { | |
| return ObjCTypes.getEnumerationMutationFn(); | |
| } | |
| void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) { | |
| return EmitTryOrSynchronizedStmt(CGF, S); | |
| } | |
| void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF, | |
| const ObjCAtSynchronizedStmt &S) { | |
| return EmitTryOrSynchronizedStmt(CGF, S); | |
| } | |
| namespace { | |
| struct PerformFragileFinally final : EHScopeStack::Cleanup { | |
| const Stmt &S; | |
| Address SyncArgSlot; | |
| Address CallTryExitVar; | |
| Address ExceptionData; | |
| ObjCTypesHelper &ObjCTypes; | |
| PerformFragileFinally(const Stmt *S, Address SyncArgSlot, | |
| Address CallTryExitVar, Address ExceptionData, | |
| ObjCTypesHelper *ObjCTypes) | |
| : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar), | |
| ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {} | |
| void Emit(CodeGenFunction &CGF, Flags flags) override { | |
| // Check whether we need to call objc_exception_try_exit. | |
| // In optimized code, this branch will always be folded. | |
| llvm::BasicBlock *FinallyCallExit = | |
| CGF.createBasicBlock("finally.call_exit"); | |
| llvm::BasicBlock *FinallyNoCallExit = | |
| CGF.createBasicBlock("finally.no_call_exit"); | |
| CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar), | |
| FinallyCallExit, FinallyNoCallExit); | |
| CGF.EmitBlock(FinallyCallExit); | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(), | |
| ExceptionData.emitRawPointer(CGF)); | |
| CGF.EmitBlock(FinallyNoCallExit); | |
| if (isa<ObjCAtTryStmt>(S)) { | |
| if (const ObjCAtFinallyStmt *FinallyStmt = | |
| cast<ObjCAtTryStmt>(S).getFinallyStmt()) { | |
| // Don't try to do the @finally if this is an EH cleanup. | |
| if (flags.isForEHCleanup()) | |
| return; | |
| // Save the current cleanup destination in case there's | |
| // control flow inside the finally statement. | |
| llvm::Value *CurCleanupDest = | |
| CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot()); | |
| CGF.EmitStmt(FinallyStmt->getFinallyBody()); | |
| if (CGF.HaveInsertPoint()) { | |
| CGF.Builder.CreateStore(CurCleanupDest, | |
| CGF.getNormalCleanupDestSlot()); | |
| } else { | |
| // Currently, the end of the cleanup must always exist. | |
| CGF.EnsureInsertPoint(); | |
| } | |
| } | |
| } else { | |
| // Emit objc_sync_exit(expr); as finally's sole statement for | |
| // @synchronized. | |
| llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot); | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg); | |
| } | |
| } | |
| }; | |
| class FragileHazards { | |
| CodeGenFunction &CGF; | |
| SmallVector<llvm::Value *, 20> Locals; | |
| llvm::DenseSet<llvm::BasicBlock *> BlocksBeforeTry; | |
| llvm::InlineAsm *ReadHazard; | |
| llvm::InlineAsm *WriteHazard; | |
| llvm::FunctionType *GetAsmFnType(); | |
| void collectLocals(); | |
| void emitReadHazard(CGBuilderTy &Builder); | |
| public: | |
| FragileHazards(CodeGenFunction &CGF); | |
| void emitWriteHazard(); | |
| void emitHazardsInNewBlocks(); | |
| }; | |
| } // end anonymous namespace | |
| /// Create the fragile-ABI read and write hazards based on the current | |
| /// state of the function, which is presumed to be immediately prior | |
| /// to a @try block. These hazards are used to maintain correct | |
| /// semantics in the face of optimization and the fragile ABI's | |
| /// cavalier use of setjmp/longjmp. | |
| FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) { | |
| collectLocals(); | |
| if (Locals.empty()) | |
| return; | |
| // Collect all the blocks in the function. | |
| for (llvm::BasicBlock &BB : *CGF.CurFn) | |
| BlocksBeforeTry.insert(&BB); | |
| llvm::FunctionType *AsmFnTy = GetAsmFnType(); | |
| // Create a read hazard for the allocas. This inhibits dead-store | |
| // optimizations and forces the values to memory. This hazard is | |
| // inserted before any 'throwing' calls in the protected scope to | |
| // reflect the possibility that the variables might be read from the | |
| // catch block if the call throws. | |
| { | |
| std::string Constraint; | |
| for (unsigned I = 0, E = Locals.size(); I != E; ++I) { | |
| if (I) | |
| Constraint += ','; | |
| Constraint += "*m"; | |
| } | |
| ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false); | |
| } | |
| // Create a write hazard for the allocas. This inhibits folding | |
| // loads across the hazard. This hazard is inserted at the | |
| // beginning of the catch path to reflect the possibility that the | |
| // variables might have been written within the protected scope. | |
| { | |
| std::string Constraint; | |
| for (unsigned I = 0, E = Locals.size(); I != E; ++I) { | |
| if (I) | |
| Constraint += ','; | |
| Constraint += "=*m"; | |
| } | |
| WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false); | |
| } | |
| } | |
| /// Emit a write hazard at the current location. | |
| void FragileHazards::emitWriteHazard() { | |
| if (Locals.empty()) | |
| return; | |
| llvm::CallInst *Call = CGF.EmitNounwindRuntimeCall(WriteHazard, Locals); | |
| for (auto Pair : llvm::enumerate(Locals)) | |
| Call->addParamAttr( | |
| Pair.index(), | |
| llvm::Attribute::get( | |
| CGF.getLLVMContext(), llvm::Attribute::ElementType, | |
| cast<llvm::AllocaInst>(Pair.value())->getAllocatedType())); | |
| } | |
| void FragileHazards::emitReadHazard(CGBuilderTy &Builder) { | |
| assert(!Locals.empty()); | |
| llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals); | |
| call->setDoesNotThrow(); | |
| call->setCallingConv(CGF.getRuntimeCC()); | |
| for (auto Pair : llvm::enumerate(Locals)) | |
| call->addParamAttr( | |
| Pair.index(), | |
| llvm::Attribute::get( | |
| Builder.getContext(), llvm::Attribute::ElementType, | |
| cast<llvm::AllocaInst>(Pair.value())->getAllocatedType())); | |
| } | |
| /// Emit read hazards in all the protected blocks, i.e. all the blocks | |
| /// which have been inserted since the beginning of the try. | |
| void FragileHazards::emitHazardsInNewBlocks() { | |
| if (Locals.empty()) | |
| return; | |
| CGBuilderTy Builder(CGF.CGM, CGF.getLLVMContext()); | |
| // Iterate through all blocks, skipping those prior to the try. | |
| for (llvm::BasicBlock &BB : *CGF.CurFn) { | |
| if (BlocksBeforeTry.count(&BB)) | |
| continue; | |
| // Walk through all the calls in the block. | |
| for (llvm::BasicBlock::iterator BI = BB.begin(), BE = BB.end(); BI != BE; | |
| ++BI) { | |
| llvm::Instruction &I = *BI; | |
| // Ignore instructions that aren't non-intrinsic calls. | |
| // These are the only calls that can possibly call longjmp. | |
| if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) | |
| continue; | |
| if (isa<llvm::IntrinsicInst>(I)) | |
| continue; | |
| // Ignore call sites marked nounwind. This may be questionable, | |
| // since 'nounwind' doesn't necessarily mean 'does not call longjmp'. | |
| if (cast<llvm::CallBase>(I).doesNotThrow()) | |
| continue; | |
| // Insert a read hazard before the call. This will ensure that | |
| // any writes to the locals are performed before making the | |
| // call. If the call throws, then this is sufficient to | |
| // guarantee correctness as long as it doesn't also write to any | |
| // locals. | |
| Builder.SetInsertPoint(BI); | |
| emitReadHazard(Builder); | |
| } | |
| } | |
| } | |
| static void addIfPresent(llvm::DenseSet<llvm::Value *> &S, Address V) { | |
| if (V.isValid()) | |
| if (llvm::Value *Ptr = V.getBasePointer()) | |
| S.insert(Ptr); | |
| } | |
| void FragileHazards::collectLocals() { | |
| // Compute a set of allocas to ignore. | |
| llvm::DenseSet<llvm::Value *> AllocasToIgnore; | |
| addIfPresent(AllocasToIgnore, CGF.ReturnValue); | |
| addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest); | |
| // Collect all the allocas currently in the function. This is | |
| // probably way too aggressive. | |
| llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock(); | |
| for (llvm::Instruction &I : Entry) | |
| if (isa<llvm::AllocaInst>(I) && !AllocasToIgnore.count(&I)) | |
| Locals.push_back(&I); | |
| } | |
| llvm::FunctionType *FragileHazards::GetAsmFnType() { | |
| SmallVector<llvm::Type *, 16> tys(Locals.size()); | |
| for (unsigned i = 0, e = Locals.size(); i != e; ++i) | |
| tys[i] = Locals[i]->getType(); | |
| return llvm::FunctionType::get(CGF.VoidTy, tys, false); | |
| } | |
| /* | |
| Objective-C setjmp-longjmp (sjlj) Exception Handling | |
| -- | |
| A catch buffer is a setjmp buffer plus: | |
| - a pointer to the exception that was caught | |
| - a pointer to the previous exception data buffer | |
| - two pointers of reserved storage | |
| Therefore catch buffers form a stack, with a pointer to the top | |
| of the stack kept in thread-local storage. | |
| objc_exception_try_enter pushes a catch buffer onto the EH stack. | |
| objc_exception_try_exit pops the given catch buffer, which is | |
| required to be the top of the EH stack. | |
| objc_exception_throw pops the top of the EH stack, writes the | |
| thrown exception into the appropriate field, and longjmps | |
| to the setjmp buffer. It crashes the process (with a printf | |
| and an abort()) if there are no catch buffers on the stack. | |
| objc_exception_extract just reads the exception pointer out of the | |
| catch buffer. | |
| There's no reason an implementation couldn't use a light-weight | |
| setjmp here --- something like __builtin_setjmp, but API-compatible | |
| with the heavyweight setjmp. This will be more important if we ever | |
| want to implement correct ObjC/C++ exception interactions for the | |
| fragile ABI. | |
| Note that for this use of setjmp/longjmp to be correct in the presence of | |
| optimization, we use inline assembly on the set of local variables to force | |
| flushing locals to memory immediately before any protected calls and to | |
| inhibit optimizing locals across the setjmp->catch edge. | |
| The basic framework for a @try-catch-finally is as follows: | |
| { | |
| objc_exception_data d; | |
| id _rethrow = null; | |
| bool _call_try_exit = true; | |
| objc_exception_try_enter(&d); | |
| if (!setjmp(d.jmp_buf)) { | |
| ... try body ... | |
| } else { | |
| // exception path | |
| id _caught = objc_exception_extract(&d); | |
| // enter new try scope for handlers | |
| if (!setjmp(d.jmp_buf)) { | |
| ... match exception and execute catch blocks ... | |
| // fell off end, rethrow. | |
| _rethrow = _caught; | |
| ... jump-through-finally to finally_rethrow ... | |
| } else { | |
| // exception in catch block | |
| _rethrow = objc_exception_extract(&d); | |
| _call_try_exit = false; | |
| ... jump-through-finally to finally_rethrow ... | |
| } | |
| } | |
| ... jump-through-finally to finally_end ... | |
| finally: | |
| if (_call_try_exit) | |
| objc_exception_try_exit(&d); | |
| ... finally block .... | |
| ... dispatch to finally destination ... | |
| finally_rethrow: | |
| objc_exception_throw(_rethrow); | |
| finally_end: | |
| } | |
| This framework differs slightly from the one gcc uses, in that gcc | |
| uses _rethrow to determine if objc_exception_try_exit should be called | |
| and if the object should be rethrown. This breaks in the face of | |
| throwing nil and introduces unnecessary branches. | |
| We specialize this framework for a few particular circumstances: | |
| - If there are no catch blocks, then we avoid emitting the second | |
| exception handling context. | |
| - If there is a catch-all catch block (i.e. @catch(...) or @catch(id | |
| e)) we avoid emitting the code to rethrow an uncaught exception. | |
| - FIXME: If there is no @finally block we can do a few more | |
| simplifications. | |
| Rethrows and Jumps-Through-Finally | |
| -- | |
| '@throw;' is supported by pushing the currently-caught exception | |
| onto ObjCEHStack while the @catch blocks are emitted. | |
| Branches through the @finally block are handled with an ordinary | |
| normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC | |
| exceptions are not compatible with C++ exceptions, and this is | |
| hardly the only place where this will go wrong. | |
| @synchronized(expr) { stmt; } is emitted as if it were: | |
| id synch_value = expr; | |
| objc_sync_enter(synch_value); | |
| @try { stmt; } @finally { objc_sync_exit(synch_value); } | |
| */ | |
| void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, | |
| const Stmt &S) { | |
| bool isTry = isa<ObjCAtTryStmt>(S); | |
| // A destination for the fall-through edges of the catch handlers to | |
| // jump to. | |
| CodeGenFunction::JumpDest FinallyEnd = | |
| CGF.getJumpDestInCurrentScope("finally.end"); | |
| // A destination for the rethrow edge of the catch handlers to jump | |
| // to. | |
| CodeGenFunction::JumpDest FinallyRethrow = | |
| CGF.getJumpDestInCurrentScope("finally.rethrow"); | |
| // For @synchronized, call objc_sync_enter(sync.expr). The | |
| // evaluation of the expression must occur before we enter the | |
| // @synchronized. We can't avoid a temp here because we need the | |
| // value to be preserved. If the backend ever does liveness | |
| // correctly after setjmp, this will be unnecessary. | |
| Address SyncArgSlot = Address::invalid(); | |
| if (!isTry) { | |
| llvm::Value *SyncArg = | |
| CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr()); | |
| SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy); | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg); | |
| SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(), | |
| CGF.getPointerAlign(), "sync.arg"); | |
| CGF.Builder.CreateStore(SyncArg, SyncArgSlot); | |
| } | |
| // Allocate memory for the setjmp buffer. This needs to be kept | |
| // live throughout the try and catch blocks. | |
| Address ExceptionData = CGF.CreateTempAlloca( | |
| ObjCTypes.ExceptionDataTy, CGF.getPointerAlign(), "exceptiondata.ptr"); | |
| // Create the fragile hazards. Note that this will not capture any | |
| // of the allocas required for exception processing, but will | |
| // capture the current basic block (which extends all the way to the | |
| // setjmp call) as "before the @try". | |
| FragileHazards Hazards(CGF); | |
| // Create a flag indicating whether the cleanup needs to call | |
| // objc_exception_try_exit. This is true except when | |
| // - no catches match and we're branching through the cleanup | |
| // just to rethrow the exception, or | |
| // - a catch matched and we're falling out of the catch handler. | |
| // The setjmp-safety rule here is that we should always store to this | |
| // variable in a place that dominates the branch through the cleanup | |
| // without passing through any setjmps. | |
| Address CallTryExitVar = CGF.CreateTempAlloca( | |
| CGF.Builder.getInt1Ty(), CharUnits::One(), "_call_try_exit"); | |
| // A slot containing the exception to rethrow. Only needed when we | |
| // have both a @catch and a @finally. | |
| Address PropagatingExnVar = Address::invalid(); | |
| // Push a normal cleanup to leave the try scope. | |
| CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S, | |
| SyncArgSlot, CallTryExitVar, | |
| ExceptionData, &ObjCTypes); | |
| // Enter a try block: | |
| // - Call objc_exception_try_enter to push ExceptionData on top of | |
| // the EH stack. | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(), | |
| ExceptionData.emitRawPointer(CGF)); | |
| // - Call setjmp on the exception data buffer. | |
| llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0); | |
| llvm::Value *GEPIndexes[] = {Zero, Zero, Zero}; | |
| llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP( | |
| ObjCTypes.ExceptionDataTy, ExceptionData.emitRawPointer(CGF), GEPIndexes, | |
| "setjmp_buffer"); | |
| llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall( | |
| ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result"); | |
| SetJmpResult->setCanReturnTwice(); | |
| // If setjmp returned 0, enter the protected block; otherwise, | |
| // branch to the handler. | |
| llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try"); | |
| llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler"); | |
| llvm::Value *DidCatch = | |
| CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception"); | |
| CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock); | |
| // Emit the protected block. | |
| CGF.EmitBlock(TryBlock); | |
| CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar); | |
| CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody() | |
| : cast<ObjCAtSynchronizedStmt>(S).getSynchBody()); | |
| CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP(); | |
| // Emit the exception handler block. | |
| CGF.EmitBlock(TryHandler); | |
| // Don't optimize loads of the in-scope locals across this point. | |
| Hazards.emitWriteHazard(); | |
| // For a @synchronized (or a @try with no catches), just branch | |
| // through the cleanup to the rethrow block. | |
| if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) { | |
| // Tell the cleanup not to re-pop the exit. | |
| CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar); | |
| CGF.EmitBranchThroughCleanup(FinallyRethrow); | |
| // Otherwise, we have to match against the caught exceptions. | |
| } else { | |
| // Retrieve the exception object. We may emit multiple blocks but | |
| // nothing can cross this so the value is already in SSA form. | |
| llvm::CallInst *Caught = CGF.EmitNounwindRuntimeCall( | |
| ObjCTypes.getExceptionExtractFn(), ExceptionData.emitRawPointer(CGF), | |
| "caught"); | |
| // Push the exception to rethrow onto the EH value stack for the | |
| // benefit of any @throws in the handlers. | |
| CGF.ObjCEHValueStack.push_back(Caught); | |
| const ObjCAtTryStmt *AtTryStmt = cast<ObjCAtTryStmt>(&S); | |
| bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr); | |
| llvm::BasicBlock *CatchBlock = nullptr; | |
| llvm::BasicBlock *CatchHandler = nullptr; | |
| if (HasFinally) { | |
| // Save the currently-propagating exception before | |
| // objc_exception_try_enter clears the exception slot. | |
| PropagatingExnVar = CGF.CreateTempAlloca( | |
| Caught->getType(), CGF.getPointerAlign(), "propagating_exception"); | |
| CGF.Builder.CreateStore(Caught, PropagatingExnVar); | |
| // Enter a new exception try block (in case a @catch block | |
| // throws an exception). | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(), | |
| ExceptionData.emitRawPointer(CGF)); | |
| llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall( | |
| ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp.result"); | |
| SetJmpResult->setCanReturnTwice(); | |
| llvm::Value *Threw = | |
| CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception"); | |
| CatchBlock = CGF.createBasicBlock("catch"); | |
| CatchHandler = CGF.createBasicBlock("catch_for_catch"); | |
| CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock); | |
| CGF.EmitBlock(CatchBlock); | |
| } | |
| CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar); | |
| // Handle catch list. As a special case we check if everything is | |
| // matched and avoid generating code for falling off the end if | |
| // so. | |
| bool AllMatched = false; | |
| for (const ObjCAtCatchStmt *CatchStmt : AtTryStmt->catch_stmts()) { | |
| const VarDecl *CatchParam = CatchStmt->getCatchParamDecl(); | |
| const ObjCObjectPointerType *OPT = nullptr; | |
| // catch(...) always matches. | |
| if (!CatchParam) { | |
| AllMatched = true; | |
| } else { | |
| OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>(); | |
| // catch(id e) always matches under this ABI, since only | |
| // ObjC exceptions end up here in the first place. | |
| // FIXME: For the time being we also match id<X>; this should | |
| // be rejected by Sema instead. | |
| if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType())) | |
| AllMatched = true; | |
| } | |
| // If this is a catch-all, we don't need to test anything. | |
| if (AllMatched) { | |
| CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF); | |
| if (CatchParam) { | |
| CGF.EmitAutoVarDecl(*CatchParam); | |
| assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"); | |
| // These types work out because ConvertType(id) == i8*. | |
| EmitInitOfCatchParam(CGF, Caught, CatchParam); | |
| } | |
| CGF.EmitStmt(CatchStmt->getCatchBody()); | |
| // The scope of the catch variable ends right here. | |
| CatchVarCleanups.ForceCleanup(); | |
| CGF.EmitBranchThroughCleanup(FinallyEnd); | |
| break; | |
| } | |
| assert(OPT && "Unexpected non-object pointer type in @catch"); | |
| const ObjCObjectType *ObjTy = OPT->getObjectType(); | |
| // FIXME: @catch (Class c) ? | |
| ObjCInterfaceDecl *IDecl = ObjTy->getInterface(); | |
| assert(IDecl && "Catch parameter must have Objective-C type!"); | |
| // Check if the @catch block matches the exception object. | |
| llvm::Value *Class = EmitClassRef(CGF, IDecl); | |
| llvm::Value *matchArgs[] = {Class, Caught}; | |
| llvm::CallInst *Match = CGF.EmitNounwindRuntimeCall( | |
| ObjCTypes.getExceptionMatchFn(), matchArgs, "match"); | |
| llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match"); | |
| llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next"); | |
| CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"), | |
| MatchedBlock, NextCatchBlock); | |
| // Emit the @catch block. | |
| CGF.EmitBlock(MatchedBlock); | |
| // Collect any cleanups for the catch variable. The scope lasts until | |
| // the end of the catch body. | |
| CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF); | |
| CGF.EmitAutoVarDecl(*CatchParam); | |
| assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"); | |
| // Initialize the catch variable. | |
| llvm::Value *Tmp = CGF.Builder.CreateBitCast( | |
| Caught, CGF.ConvertType(CatchParam->getType())); | |
| EmitInitOfCatchParam(CGF, Tmp, CatchParam); | |
| CGF.EmitStmt(CatchStmt->getCatchBody()); | |
| // We're done with the catch variable. | |
| CatchVarCleanups.ForceCleanup(); | |
| CGF.EmitBranchThroughCleanup(FinallyEnd); | |
| CGF.EmitBlock(NextCatchBlock); | |
| } | |
| CGF.ObjCEHValueStack.pop_back(); | |
| // If nothing wanted anything to do with the caught exception, | |
| // kill the extract call. | |
| if (Caught->use_empty()) | |
| Caught->eraseFromParent(); | |
| if (!AllMatched) | |
| CGF.EmitBranchThroughCleanup(FinallyRethrow); | |
| if (HasFinally) { | |
| // Emit the exception handler for the @catch blocks. | |
| CGF.EmitBlock(CatchHandler); | |
| // In theory we might now need a write hazard, but actually it's | |
| // unnecessary because there's no local-accessing code between | |
| // the try's write hazard and here. | |
| // Hazards.emitWriteHazard(); | |
| // Extract the new exception and save it to the | |
| // propagating-exception slot. | |
| assert(PropagatingExnVar.isValid()); | |
| llvm::CallInst *NewCaught = CGF.EmitNounwindRuntimeCall( | |
| ObjCTypes.getExceptionExtractFn(), ExceptionData.emitRawPointer(CGF), | |
| "caught"); | |
| CGF.Builder.CreateStore(NewCaught, PropagatingExnVar); | |
| // Don't pop the catch handler; the throw already did. | |
| CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar); | |
| CGF.EmitBranchThroughCleanup(FinallyRethrow); | |
| } | |
| } | |
| // Insert read hazards as required in the new blocks. | |
| Hazards.emitHazardsInNewBlocks(); | |
| // Pop the cleanup. | |
| CGF.Builder.restoreIP(TryFallthroughIP); | |
| if (CGF.HaveInsertPoint()) | |
| CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar); | |
| CGF.PopCleanupBlock(); | |
| CGF.EmitBlock(FinallyEnd.getBlock(), true); | |
| // Emit the rethrow block. | |
| CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP(); | |
| CGF.EmitBlock(FinallyRethrow.getBlock(), true); | |
| if (CGF.HaveInsertPoint()) { | |
| // If we have a propagating-exception variable, check it. | |
| llvm::Value *PropagatingExn; | |
| if (PropagatingExnVar.isValid()) { | |
| PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar); | |
| // Otherwise, just look in the buffer for the exception to throw. | |
| } else { | |
| llvm::CallInst *Caught = CGF.EmitNounwindRuntimeCall( | |
| ObjCTypes.getExceptionExtractFn(), ExceptionData.emitRawPointer(CGF)); | |
| PropagatingExn = Caught; | |
| } | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(), | |
| PropagatingExn); | |
| CGF.Builder.CreateUnreachable(); | |
| } | |
| CGF.Builder.restoreIP(SavedIP); | |
| } | |
| void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF, | |
| const ObjCAtThrowStmt &S, | |
| bool ClearInsertionPoint) { | |
| llvm::Value *ExceptionAsObject; | |
| if (const Expr *ThrowExpr = S.getThrowExpr()) { | |
| llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr); | |
| ExceptionAsObject = | |
| CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy); | |
| } else { | |
| assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && | |
| "Unexpected rethrow outside @catch block."); | |
| ExceptionAsObject = CGF.ObjCEHValueStack.back(); | |
| } | |
| CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject) | |
| ->setDoesNotReturn(); | |
| CGF.Builder.CreateUnreachable(); | |
| // Clear the insertion point to indicate we are in unreachable code. | |
| if (ClearInsertionPoint) | |
| CGF.Builder.ClearInsertionPoint(); | |
| } | |
| /// EmitObjCWeakRead - Code gen for loading value of a __weak | |
| /// object: objc_read_weak (id *src) | |
| /// | |
| llvm::Value *CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, | |
| Address AddrWeakObj) { | |
| llvm::Type *DestTy = AddrWeakObj.getElementType(); | |
| llvm::Value *AddrWeakObjVal = CGF.Builder.CreateBitCast( | |
| AddrWeakObj.emitRawPointer(CGF), ObjCTypes.PtrObjectPtrTy); | |
| llvm::Value *read_weak = CGF.EmitNounwindRuntimeCall( | |
| ObjCTypes.getGcReadWeakFn(), AddrWeakObjVal, "weakread"); | |
| read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy); | |
| return read_weak; | |
| } | |
| /// EmitObjCWeakAssign - Code gen for assigning to a __weak object. | |
| /// objc_assign_weak (id src, id *dst) | |
| /// | |
| void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, | |
| llvm::Value *src, Address dst) { | |
| llvm::Type *SrcTy = src->getType(); | |
| if (!isa<llvm::PointerType>(SrcTy)) { | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); | |
| assert(Size <= 8 && "does not support size > 8"); | |
| src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) | |
| : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); | |
| src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); | |
| } | |
| src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); | |
| llvm::Value *dstVal = CGF.Builder.CreateBitCast(dst.emitRawPointer(CGF), | |
| ObjCTypes.PtrObjectPtrTy); | |
| llvm::Value *args[] = {src, dstVal}; | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(), args, | |
| "weakassign"); | |
| } | |
| /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object. | |
| /// objc_assign_global (id src, id *dst) | |
| /// | |
| void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, | |
| llvm::Value *src, Address dst, | |
| bool threadlocal) { | |
| llvm::Type *SrcTy = src->getType(); | |
| if (!isa<llvm::PointerType>(SrcTy)) { | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); | |
| assert(Size <= 8 && "does not support size > 8"); | |
| src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) | |
| : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); | |
| src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); | |
| } | |
| src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); | |
| llvm::Value *dstVal = CGF.Builder.CreateBitCast(dst.emitRawPointer(CGF), | |
| ObjCTypes.PtrObjectPtrTy); | |
| llvm::Value *args[] = {src, dstVal}; | |
| if (!threadlocal) | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(), args, | |
| "globalassign"); | |
| else | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(), args, | |
| "threadlocalassign"); | |
| } | |
| /// EmitObjCIvarAssign - Code gen for assigning to a __strong object. | |
| /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset) | |
| /// | |
| void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, | |
| llvm::Value *src, Address dst, | |
| llvm::Value *ivarOffset) { | |
| assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL"); | |
| llvm::Type *SrcTy = src->getType(); | |
| if (!isa<llvm::PointerType>(SrcTy)) { | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); | |
| assert(Size <= 8 && "does not support size > 8"); | |
| src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) | |
| : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); | |
| src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); | |
| } | |
| src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); | |
| llvm::Value *dstVal = CGF.Builder.CreateBitCast(dst.emitRawPointer(CGF), | |
| ObjCTypes.PtrObjectPtrTy); | |
| llvm::Value *args[] = {src, dstVal, ivarOffset}; | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args); | |
| } | |
| /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object. | |
| /// objc_assign_strongCast (id src, id *dst) | |
| /// | |
| void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, | |
| llvm::Value *src, Address dst) { | |
| llvm::Type *SrcTy = src->getType(); | |
| if (!isa<llvm::PointerType>(SrcTy)) { | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); | |
| assert(Size <= 8 && "does not support size > 8"); | |
| src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty) | |
| : CGF.Builder.CreateBitCast(src, CGM.Int64Ty); | |
| src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); | |
| } | |
| src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); | |
| llvm::Value *dstVal = CGF.Builder.CreateBitCast(dst.emitRawPointer(CGF), | |
| ObjCTypes.PtrObjectPtrTy); | |
| llvm::Value *args[] = {src, dstVal}; | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(), args, | |
| "strongassign"); | |
| } | |
| void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, | |
| Address DestPtr, Address SrcPtr, | |
| llvm::Value *size) { | |
| llvm::Value *args[] = {DestPtr.emitRawPointer(CGF), | |
| SrcPtr.emitRawPointer(CGF), size}; | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args); | |
| } | |
| /// EmitObjCValueForIvar - Code Gen for ivar reference. | |
| /// | |
| LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, | |
| QualType ObjectTy, | |
| llvm::Value *BaseValue, | |
| const ObjCIvarDecl *Ivar, | |
| unsigned CVRQualifiers) { | |
| const ObjCInterfaceDecl *ID = | |
| ObjectTy->castAs<ObjCObjectType>()->getInterface(); | |
| return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers, | |
| EmitIvarOffset(CGF, ID, Ivar)); | |
| } | |
| llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF, | |
| const ObjCInterfaceDecl *Interface, | |
| const ObjCIvarDecl *Ivar) { | |
| uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar); | |
| return llvm::ConstantInt::get( | |
| CGM.getTypes().ConvertType(CGM.getContext().LongTy), Offset); | |
| } | |
| /* *** Private Interface *** */ | |
| std::string CGObjCCommonMac::GetSectionName(StringRef Section, | |
| StringRef MachOAttributes) { | |
| switch (CGM.getTriple().getObjectFormat()) { | |
| case llvm::Triple::UnknownObjectFormat: | |
| llvm_unreachable("unexpected object file format"); | |
| case llvm::Triple::MachO: { | |
| if (MachOAttributes.empty()) | |
| return ("__DATA," + Section).str(); | |
| return ("__DATA," + Section + "," + MachOAttributes).str(); | |
| } | |
| case llvm::Triple::ELF: | |
| assert(Section.starts_with("__") && "expected the name to begin with __"); | |
| return Section.substr(2).str(); | |
| case llvm::Triple::COFF: | |
| assert(Section.starts_with("__") && "expected the name to begin with __"); | |
| return ("." + Section.substr(2) + "$B").str(); | |
| case llvm::Triple::Wasm: | |
| case llvm::Triple::GOFF: | |
| case llvm::Triple::SPIRV: | |
| case llvm::Triple::XCOFF: | |
| case llvm::Triple::DXContainer: | |
| llvm::report_fatal_error( | |
| "Objective-C support is unimplemented for object file format"); | |
| } | |
| llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum"); | |
| } | |
| // clang-format off | |
| /// EmitImageInfo - Emit the image info marker used to encode some module | |
| /// level information. | |
| /// | |
| /// See: <rdr://4810609&4810587&4810587> | |
| /// struct IMAGE_INFO { | |
| /// unsigned version; | |
| /// unsigned flags; | |
| /// }; | |
| enum ImageInfoFlags { | |
| eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang. | |
| eImageInfo_GarbageCollected = (1 << 1), | |
| eImageInfo_GCOnly = (1 << 2), | |
| eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache. | |
| eImageInfo_SignedClassRO = (1 << 4), // Reused (was _CorrectedSynthesize) | |
| eImageInfo_ImageIsSimulated = (1 << 5), | |
| eImageInfo_ClassProperties = (1 << 6) | |
| }; | |
| // clang-format on | |
| void CGObjCCommonMac::EmitImageInfo() { | |
| unsigned version = 0; // Version is unused? | |
| std::string Section = | |
| (ObjCABI == 1) | |
| ? "__OBJC,__image_info,regular" | |
| : GetSectionName("__objc_imageinfo", "regular,no_dead_strip"); | |
| // Generate module-level named metadata to convey this information to the | |
| // linker and code-gen. | |
| llvm::Module &Mod = CGM.getModule(); | |
| // Add the ObjC ABI version to the module flags. | |
| Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI); | |
| Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version", | |
| version); | |
| Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section", | |
| llvm::MDString::get(VMContext, Section)); | |
| auto Int8Ty = llvm::Type::getInt8Ty(VMContext); | |
| if (CGM.getLangOpts().getGC() == LangOptions::NonGC) { | |
| // Non-GC overrides those files which specify GC. | |
| Mod.addModuleFlag(llvm::Module::Error, "Objective-C Garbage Collection", | |
| llvm::ConstantInt::get(Int8Ty, 0)); | |
| } else { | |
| // Add the ObjC garbage collection value. | |
| Mod.addModuleFlag( | |
| llvm::Module::Error, "Objective-C Garbage Collection", | |
| llvm::ConstantInt::get(Int8Ty, (uint8_t)eImageInfo_GarbageCollected)); | |
| if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) { | |
| // Add the ObjC GC Only value. | |
| Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only", | |
| eImageInfo_GCOnly); | |
| // Require that GC be specified and set to eImageInfo_GarbageCollected. | |
| llvm::Metadata *Ops[2] = { | |
| llvm::MDString::get(VMContext, "Objective-C Garbage Collection"), | |
| llvm::ConstantAsMetadata::get( | |
| llvm::ConstantInt::get(Int8Ty, eImageInfo_GarbageCollected))}; | |
| Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only", | |
| llvm::MDNode::get(VMContext, Ops)); | |
| } | |
| } | |
| // Indicate whether we're compiling this to run on a simulator. | |
| if (CGM.getTarget().getTriple().isSimulatorEnvironment()) | |
| Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated", | |
| eImageInfo_ImageIsSimulated); | |
| // Indicate whether we are generating class properties. | |
| Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties", | |
| eImageInfo_ClassProperties); | |
| // Indicate whether we want enforcement of pointer signing for class_ro_t | |
| // pointers. | |
| if (CGM.getLangOpts().PointerAuthObjcClassROPointers) | |
| Mod.addModuleFlag(llvm::Module::Error, | |
| "Objective-C Enforce ClassRO Pointer Signing", | |
| eImageInfo_SignedClassRO); | |
| else | |
| Mod.addModuleFlag(llvm::Module::Error, | |
| "Objective-C Enforce ClassRO Pointer Signing", | |
| llvm::ConstantInt::get(Int8Ty, 0)); | |
| } | |
| // struct objc_module { | |
| // unsigned long version; | |
| // unsigned long size; | |
| // const char *name; | |
| // Symtab symtab; | |
| // }; | |
| // FIXME: Get from somewhere | |
| static const int ModuleVersion = 7; | |
| void CGObjCMac::EmitModuleInfo() { | |
| uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy); | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.ModuleTy); | |
| values.addInt(ObjCTypes.LongTy, ModuleVersion); | |
| values.addInt(ObjCTypes.LongTy, Size); | |
| // This used to be the filename, now it is unused. <rdr://4327263> | |
| values.add(GetClassName(StringRef(""))); | |
| values.add(EmitModuleSymbols()); | |
| CreateMetadataVar("OBJC_MODULES", values, | |
| "__OBJC,__module_info,regular,no_dead_strip", | |
| CGM.getPointerAlign(), true); | |
| } | |
| llvm::Constant *CGObjCMac::EmitModuleSymbols() { | |
| unsigned NumClasses = DefinedClasses.size(); | |
| unsigned NumCategories = DefinedCategories.size(); | |
| // Return null if no symbols were defined. | |
| if (!NumClasses && !NumCategories) | |
| return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy); | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(); | |
| values.addInt(ObjCTypes.LongTy, 0); | |
| values.addNullPointer(ObjCTypes.SelectorPtrTy); | |
| values.addInt(ObjCTypes.ShortTy, NumClasses); | |
| values.addInt(ObjCTypes.ShortTy, NumCategories); | |
| // The runtime expects exactly the list of defined classes followed | |
| // by the list of defined categories, in a single array. | |
| auto array = values.beginArray(ObjCTypes.Int8PtrTy); | |
| for (unsigned i = 0; i < NumClasses; i++) { | |
| const ObjCInterfaceDecl *ID = ImplementedClasses[i]; | |
| assert(ID); | |
| if (ObjCImplementationDecl *IMP = ID->getImplementation()) | |
| // We are implementing a weak imported interface. Give it external linkage | |
| if (ID->isWeakImported() && !IMP->isWeakImported()) | |
| DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage); | |
| array.add(DefinedClasses[i]); | |
| } | |
| for (unsigned i = 0; i < NumCategories; i++) | |
| array.add(DefinedCategories[i]); | |
| array.finishAndAddTo(values); | |
| llvm::GlobalVariable *GV = CreateMetadataVar( | |
| "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip", | |
| CGM.getPointerAlign(), true); | |
| return GV; | |
| } | |
| llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF, | |
| IdentifierInfo *II) { | |
| LazySymbols.insert(II); | |
| llvm::GlobalVariable *&Entry = ClassReferences[II]; | |
| if (!Entry) { | |
| Entry = | |
| CreateMetadataVar("OBJC_CLASS_REFERENCES_", GetClassName(II->getName()), | |
| "__OBJC,__cls_refs,literal_pointers,no_dead_strip", | |
| CGM.getPointerAlign(), true); | |
| } | |
| return CGF.Builder.CreateAlignedLoad(Entry->getValueType(), Entry, | |
| CGF.getPointerAlign()); | |
| } | |
| llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF, | |
| const ObjCInterfaceDecl *ID) { | |
| // If the class has the objc_runtime_visible attribute, we need to | |
| // use the Objective-C runtime to get the class. | |
| if (ID->hasAttr<ObjCRuntimeVisibleAttr>()) | |
| return EmitClassRefViaRuntime(CGF, ID, ObjCTypes); | |
| IdentifierInfo *RuntimeName = | |
| &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString()); | |
| return EmitClassRefFromId(CGF, RuntimeName); | |
| } | |
| llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) { | |
| IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool"); | |
| return EmitClassRefFromId(CGF, II); | |
| } | |
| llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) { | |
| return CGF.Builder.CreateLoad(EmitSelectorAddr(Sel)); | |
| } | |
| ConstantAddress CGObjCMac::EmitSelectorAddr(Selector Sel) { | |
| CharUnits Align = CGM.getPointerAlign(); | |
| llvm::GlobalVariable *&Entry = SelectorReferences[Sel]; | |
| if (!Entry) { | |
| Entry = CreateMetadataVar( | |
| "OBJC_SELECTOR_REFERENCES_", GetMethodVarName(Sel), | |
| "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true); | |
| Entry->setExternallyInitialized(true); | |
| } | |
| return ConstantAddress(Entry, ObjCTypes.SelectorPtrTy, Align); | |
| } | |
| llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) { | |
| llvm::GlobalVariable *&Entry = ClassNames[RuntimeName]; | |
| if (!Entry) | |
| Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName); | |
| return Entry; | |
| } | |
| llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) { | |
| return MethodDefinitions.lookup(MD); | |
| } | |
| /// GetIvarLayoutName - Returns a unique constant for the given | |
| /// ivar layout bitmap. | |
| llvm::Constant * | |
| CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident, | |
| const ObjCCommonTypesHelper &ObjCTypes) { | |
| return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy); | |
| } | |
| void IvarLayoutBuilder::visitRecord(const RecordType *RT, CharUnits offset) { | |
| const RecordDecl *RD = RT->getDecl()->getDefinitionOrSelf(); | |
| // If this is a union, remember that we had one, because it might mess | |
| // up the ordering of layout entries. | |
| if (RD->isUnion()) | |
| IsDisordered = true; | |
| const ASTRecordLayout *recLayout = nullptr; | |
| visitAggregate(RD->field_begin(), RD->field_end(), offset, | |
| [&](const FieldDecl *field) -> CharUnits { | |
| if (!recLayout) | |
| recLayout = &CGM.getContext().getASTRecordLayout(RD); | |
| auto offsetInBits = | |
| recLayout->getFieldOffset(field->getFieldIndex()); | |
| return CGM.getContext().toCharUnitsFromBits(offsetInBits); | |
| }); | |
| } | |
| template <class Iterator, class GetOffsetFn> | |
| void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end, | |
| CharUnits aggregateOffset, | |
| const GetOffsetFn &getOffset) { | |
| for (; begin != end; ++begin) { | |
| auto field = *begin; | |
| // Skip over bitfields. | |
| if (field->isBitField()) { | |
| continue; | |
| } | |
| // Compute the offset of the field within the aggregate. | |
| CharUnits fieldOffset = aggregateOffset + getOffset(field); | |
| visitField(field, fieldOffset); | |
| } | |
| } | |
| /// Collect layout information for the given fields into IvarsInfo. | |
| void IvarLayoutBuilder::visitField(const FieldDecl *field, | |
| CharUnits fieldOffset) { | |
| QualType fieldType = field->getType(); | |
| // Drill down into arrays. | |
| uint64_t numElts = 1; | |
| if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) { | |
| numElts = 0; | |
| fieldType = arrayType->getElementType(); | |
| } | |
| // Unlike incomplete arrays, constant arrays can be nested. | |
| while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) { | |
| numElts *= arrayType->getZExtSize(); | |
| fieldType = arrayType->getElementType(); | |
| } | |
| assert(!fieldType->isArrayType() && "ivar of non-constant array type?"); | |
| // If we ended up with a zero-sized array, we've done what we can do within | |
| // the limits of this layout encoding. | |
| if (numElts == 0) | |
| return; | |
| // Recurse if the base element type is a record type. | |
| if (const auto *recType = fieldType->getAsCanonical<RecordType>()) { | |
| size_t oldEnd = IvarsInfo.size(); | |
| visitRecord(recType, fieldOffset); | |
| // If we have an array, replicate the first entry's layout information. | |
| auto numEltEntries = IvarsInfo.size() - oldEnd; | |
| if (numElts != 1 && numEltEntries != 0) { | |
| CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType); | |
| for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) { | |
| // Copy the last numEltEntries onto the end of the array, adjusting | |
| // each for the element size. | |
| for (size_t i = 0; i != numEltEntries; ++i) { | |
| auto firstEntry = IvarsInfo[oldEnd + i]; | |
| IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize, | |
| firstEntry.SizeInWords)); | |
| } | |
| } | |
| } | |
| return; | |
| } | |
| // Classify the element type. | |
| Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType); | |
| // If it matches what we're looking for, add an entry. | |
| if ((ForStrongLayout && GCAttr == Qualifiers::Strong) || | |
| (!ForStrongLayout && GCAttr == Qualifiers::Weak)) { | |
| assert(CGM.getContext().getTypeSizeInChars(fieldType) == | |
| CGM.getPointerSize()); | |
| IvarsInfo.push_back(IvarInfo(fieldOffset, numElts)); | |
| } | |
| } | |
| /// buildBitmap - This routine does the horsework of taking the offsets of | |
| /// strong/weak references and creating a bitmap. The bitmap is also | |
| /// returned in the given buffer, suitable for being passed to \c dump(). | |
| llvm::Constant * | |
| IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC, | |
| llvm::SmallVectorImpl<unsigned char> &buffer) { | |
| // The bitmap is a series of skip/scan instructions, aligned to word | |
| // boundaries. The skip is performed first. | |
| const unsigned char MaxNibble = 0xF; | |
| const unsigned char SkipMask = 0xF0, SkipShift = 4; | |
| const unsigned char ScanMask = 0x0F, ScanShift = 0; | |
| assert(!IvarsInfo.empty() && "generating bitmap for no data"); | |
| // Sort the ivar info on byte position in case we encounterred a | |
| // union nested in the ivar list. | |
| if (IsDisordered) { | |
| // This isn't a stable sort, but our algorithm should handle it fine. | |
| llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end()); | |
| } else { | |
| assert(llvm::is_sorted(IvarsInfo)); | |
| } | |
| assert(IvarsInfo.back().Offset < InstanceEnd); | |
| assert(buffer.empty()); | |
| // Skip the next N words. | |
| auto skip = [&](unsigned numWords) { | |
| assert(numWords > 0); | |
| // Try to merge into the previous byte. Since scans happen second, we | |
| // can't do this if it includes a scan. | |
| if (!buffer.empty() && !(buffer.back() & ScanMask)) { | |
| unsigned lastSkip = buffer.back() >> SkipShift; | |
| if (lastSkip < MaxNibble) { | |
| unsigned claimed = std::min(MaxNibble - lastSkip, numWords); | |
| numWords -= claimed; | |
| lastSkip += claimed; | |
| buffer.back() = (lastSkip << SkipShift); | |
| } | |
| } | |
| while (numWords >= MaxNibble) { | |
| buffer.push_back(MaxNibble << SkipShift); | |
| numWords -= MaxNibble; | |
| } | |
| if (numWords) { | |
| buffer.push_back(numWords << SkipShift); | |
| } | |
| }; | |
| // Scan the next N words. | |
| auto scan = [&](unsigned numWords) { | |
| assert(numWords > 0); | |
| // Try to merge into the previous byte. Since scans happen second, we can | |
| // do this even if it includes a skip. | |
| if (!buffer.empty()) { | |
| unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift; | |
| if (lastScan < MaxNibble) { | |
| unsigned claimed = std::min(MaxNibble - lastScan, numWords); | |
| numWords -= claimed; | |
| lastScan += claimed; | |
| buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift); | |
| } | |
| } | |
| while (numWords >= MaxNibble) { | |
| buffer.push_back(MaxNibble << ScanShift); | |
| numWords -= MaxNibble; | |
| } | |
| if (numWords) { | |
| buffer.push_back(numWords << ScanShift); | |
| } | |
| }; | |
| // One past the end of the last scan. | |
| unsigned endOfLastScanInWords = 0; | |
| const CharUnits WordSize = CGM.getPointerSize(); | |
| // Consider all the scan requests. | |
| for (auto &request : IvarsInfo) { | |
| CharUnits beginOfScan = request.Offset - InstanceBegin; | |
| // Ignore scan requests that don't start at an even multiple of the | |
| // word size. We can't encode them. | |
| if (!beginOfScan.isMultipleOf(WordSize)) | |
| continue; | |
| // Ignore scan requests that start before the instance start. | |
| // This assumes that scans never span that boundary. The boundary | |
| // isn't the true start of the ivars, because in the fragile-ARC case | |
| // it's rounded up to word alignment, but the test above should leave | |
| // us ignoring that possibility. | |
| if (beginOfScan.isNegative()) { | |
| assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin); | |
| continue; | |
| } | |
| unsigned beginOfScanInWords = beginOfScan / WordSize; | |
| unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords; | |
| // If the scan starts some number of words after the last one ended, | |
| // skip forward. | |
| if (beginOfScanInWords > endOfLastScanInWords) { | |
| skip(beginOfScanInWords - endOfLastScanInWords); | |
| // Otherwise, start scanning where the last left off. | |
| } else { | |
| beginOfScanInWords = endOfLastScanInWords; | |
| // If that leaves us with nothing to scan, ignore this request. | |
| if (beginOfScanInWords >= endOfScanInWords) | |
| continue; | |
| } | |
| // Scan to the end of the request. | |
| assert(beginOfScanInWords < endOfScanInWords); | |
| scan(endOfScanInWords - beginOfScanInWords); | |
| endOfLastScanInWords = endOfScanInWords; | |
| } | |
| if (buffer.empty()) | |
| return llvm::ConstantPointerNull::get(CGM.Int8PtrTy); | |
| // For GC layouts, emit a skip to the end of the allocation so that we | |
| // have precise information about the entire thing. This isn't useful | |
| // or necessary for the ARC-style layout strings. | |
| if (CGM.getLangOpts().getGC() != LangOptions::NonGC) { | |
| unsigned lastOffsetInWords = | |
| (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize; | |
| if (lastOffsetInWords > endOfLastScanInWords) { | |
| skip(lastOffsetInWords - endOfLastScanInWords); | |
| } | |
| } | |
| // Null terminate the string. | |
| buffer.push_back(0); | |
| return CGObjC.CreateCStringLiteral(reinterpret_cast<char *>(buffer.data()), | |
| ObjCLabelType::LayoutBitMap); | |
| } | |
| /// BuildIvarLayout - Builds ivar layout bitmap for the class | |
| /// implementation for the __strong or __weak case. | |
| /// The layout map displays which words in ivar list must be skipped | |
| /// and which must be scanned by GC (see below). String is built of bytes. | |
| /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count | |
| /// of words to skip and right nibble is count of words to scan. So, each | |
| /// nibble represents up to 15 workds to skip or scan. Skipping the rest is | |
| /// represented by a 0x00 byte which also ends the string. | |
| /// 1. when ForStrongLayout is true, following ivars are scanned: | |
| /// - id, Class | |
| /// - object * | |
| /// - __strong anything | |
| /// | |
| /// 2. When ForStrongLayout is false, following ivars are scanned: | |
| /// - __weak anything | |
| /// | |
| llvm::Constant * | |
| CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD, | |
| CharUnits beginOffset, CharUnits endOffset, | |
| bool ForStrongLayout, bool HasMRCWeakIvars) { | |
| // If this is MRC, and we're either building a strong layout or there | |
| // are no weak ivars, bail out early. | |
| llvm::Type *PtrTy = CGM.Int8PtrTy; | |
| if (CGM.getLangOpts().getGC() == LangOptions::NonGC && | |
| !CGM.getLangOpts().ObjCAutoRefCount && | |
| (ForStrongLayout || !HasMRCWeakIvars)) | |
| return llvm::Constant::getNullValue(PtrTy); | |
| const ObjCInterfaceDecl *OI = OMD->getClassInterface(); | |
| SmallVector<const ObjCIvarDecl *, 32> ivars; | |
| // GC layout strings include the complete object layout, possibly | |
| // inaccurately in the non-fragile ABI; the runtime knows how to fix this | |
| // up. | |
| // | |
| // ARC layout strings only include the class's ivars. In non-fragile | |
| // runtimes, that means starting at InstanceStart, rounded up to word | |
| // alignment. In fragile runtimes, there's no InstanceStart, so it means | |
| // starting at the offset of the first ivar, rounded up to word alignment. | |
| // | |
| // MRC weak layout strings follow the ARC style. | |
| CharUnits baseOffset; | |
| if (CGM.getLangOpts().getGC() == LangOptions::NonGC) { | |
| for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin(); IVD; | |
| IVD = IVD->getNextIvar()) | |
| ivars.push_back(IVD); | |
| if (isNonFragileABI()) { | |
| baseOffset = beginOffset; // InstanceStart | |
| } else if (!ivars.empty()) { | |
| baseOffset = | |
| CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0])); | |
| } else { | |
| baseOffset = CharUnits::Zero(); | |
| } | |
| baseOffset = baseOffset.alignTo(CGM.getPointerAlign()); | |
| } else { | |
| CGM.getContext().DeepCollectObjCIvars(OI, true, ivars); | |
| baseOffset = CharUnits::Zero(); | |
| } | |
| if (ivars.empty()) | |
| return llvm::Constant::getNullValue(PtrTy); | |
| IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout); | |
| builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(), | |
| [&](const ObjCIvarDecl *ivar) -> CharUnits { | |
| return CharUnits::fromQuantity( | |
| ComputeIvarBaseOffset(CGM, OMD, ivar)); | |
| }); | |
| if (!builder.hasBitmapData()) | |
| return llvm::Constant::getNullValue(PtrTy); | |
| llvm::SmallVector<unsigned char, 4> buffer; | |
| llvm::Constant *C = builder.buildBitmap(*this, buffer); | |
| if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) { | |
| printf("\n%s ivar layout for class '%s': ", | |
| ForStrongLayout ? "strong" : "weak", | |
| OMD->getClassInterface()->getName().str().c_str()); | |
| builder.dump(buffer); | |
| } | |
| return C; | |
| } | |
| llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) { | |
| llvm::GlobalVariable *&Entry = MethodVarNames[Sel]; | |
| // FIXME: Avoid std::string in "Sel.getAsString()" | |
| if (!Entry) | |
| Entry = | |
| CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName); | |
| return Entry; | |
| } | |
| // FIXME: Merge into a single cstring creation function. | |
| llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) { | |
| return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID)); | |
| } | |
| llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) { | |
| std::string TypeStr; | |
| CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field); | |
| llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr]; | |
| if (!Entry) | |
| Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType); | |
| return Entry; | |
| } | |
| llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D, | |
| bool Extended) { | |
| std::string TypeStr = | |
| CGM.getContext().getObjCEncodingForMethodDecl(D, Extended); | |
| llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr]; | |
| if (!Entry) | |
| Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType); | |
| return Entry; | |
| } | |
| // FIXME: Merge into a single cstring creation function. | |
| llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) { | |
| llvm::GlobalVariable *&Entry = PropertyNames[Ident]; | |
| if (!Entry) | |
| Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName); | |
| return Entry; | |
| } | |
| // FIXME: Merge into a single cstring creation function. | |
| // FIXME: This Decl should be more precise. | |
| llvm::Constant * | |
| CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD, | |
| const Decl *Container) { | |
| std::string TypeStr = | |
| CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container); | |
| return GetPropertyName(&CGM.getContext().Idents.get(TypeStr)); | |
| } | |
| void CGObjCMac::FinishModule() { | |
| EmitModuleInfo(); | |
| // Emit the dummy bodies for any protocols which were referenced but | |
| // never defined. | |
| for (auto &entry : Protocols) { | |
| llvm::GlobalVariable *global = entry.second; | |
| if (global->hasInitializer()) | |
| continue; | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.ProtocolTy); | |
| values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy); | |
| values.add(GetClassName(entry.first->getName())); | |
| values.addNullPointer(ObjCTypes.ProtocolListPtrTy); | |
| values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy); | |
| values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy); | |
| values.finishAndSetAsInitializer(global); | |
| CGM.addCompilerUsedGlobal(global); | |
| } | |
| // Add assembler directives to add lazy undefined symbol references | |
| // for classes which are referenced but not defined. This is | |
| // important for correct linker interaction. | |
| // | |
| // FIXME: It would be nice if we had an LLVM construct for this. | |
| if ((!LazySymbols.empty() || !DefinedSymbols.empty()) && | |
| CGM.getTriple().isOSBinFormatMachO()) { | |
| SmallString<256> Asm; | |
| llvm::raw_svector_ostream OS(Asm); | |
| for (const auto *Sym : DefinedSymbols) | |
| OS << "\t.objc_class_name_" << Sym->getName() << "=0\n" | |
| << "\t.globl .objc_class_name_" << Sym->getName() << "\n"; | |
| for (const auto *Sym : LazySymbols) | |
| OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n"; | |
| for (const auto &Category : DefinedCategoryNames) | |
| OS << "\t.objc_category_name_" << Category << "=0\n" | |
| << "\t.globl .objc_category_name_" << Category << "\n"; | |
| CGM.getModule().appendModuleInlineAsm(OS.str()); | |
| } | |
| } | |
| CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm) | |
| : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr), | |
| ObjCEmptyVtableVar(nullptr) { | |
| ObjCABI = 2; | |
| } | |
| /* *** */ | |
| ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm) | |
| : VMContext(cgm.getLLVMContext()), CGM(cgm) { | |
| CodeGen::CodeGenTypes &Types = CGM.getTypes(); | |
| ASTContext &Ctx = CGM.getContext(); | |
| unsigned ProgramAS = CGM.getDataLayout().getProgramAddressSpace(); | |
| ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy)); | |
| IntTy = CGM.IntTy; | |
| LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy)); | |
| Int8PtrTy = CGM.Int8PtrTy; | |
| Int8PtrProgramASTy = llvm::PointerType::get(CGM.getLLVMContext(), ProgramAS); | |
| Int8PtrPtrTy = CGM.Int8PtrPtrTy; | |
| // arm64 targets use "int" ivar offset variables. All others, | |
| // including OS X x86_64 and Windows x86_64, use "long" ivar offsets. | |
| if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64) | |
| IvarOffsetVarTy = IntTy; | |
| else | |
| IvarOffsetVarTy = LongTy; | |
| ObjectPtrTy = cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType())); | |
| PtrObjectPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| SelectorPtrTy = | |
| cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType())); | |
| // I'm not sure I like this. The implicit coordination is a bit | |
| // gross. We should solve this in a reasonable fashion because this | |
| // is a pretty common task (match some runtime data structure with | |
| // an LLVM data structure). | |
| // FIXME: This is leaked. | |
| // FIXME: Merge with rewriter code? | |
| // struct _objc_super { | |
| // id self; | |
| // Class cls; | |
| // } | |
| RecordDecl *RD = RecordDecl::Create( | |
| Ctx, TagTypeKind::Struct, Ctx.getTranslationUnitDecl(), SourceLocation(), | |
| SourceLocation(), &Ctx.Idents.get("_objc_super")); | |
| RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), | |
| nullptr, Ctx.getObjCIdType(), nullptr, nullptr, | |
| false, ICIS_NoInit)); | |
| RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), | |
| nullptr, Ctx.getObjCClassType(), nullptr, | |
| nullptr, false, ICIS_NoInit)); | |
| RD->completeDefinition(); | |
| SuperCTy = Ctx.getCanonicalTagType(RD); | |
| SuperPtrCTy = Ctx.getPointerType(SuperCTy); | |
| SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy)); | |
| SuperPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _prop_t { | |
| // char *name; | |
| // char *attributes; | |
| // } | |
| PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy); | |
| // struct _prop_list_t { | |
| // uint32_t entsize; // sizeof(struct _prop_t) | |
| // uint32_t count_of_properties; | |
| // struct _prop_t prop_list[count_of_properties]; | |
| // } | |
| PropertyListTy = llvm::StructType::create( | |
| "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0)); | |
| // struct _prop_list_t * | |
| PropertyListPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _objc_method { | |
| // SEL _cmd; | |
| // char *method_type; | |
| // char *_imp; | |
| // } | |
| MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy, | |
| Int8PtrTy, Int8PtrProgramASTy); | |
| // struct _objc_cache * | |
| CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache"); | |
| CachePtrTy = llvm::PointerType::getUnqual(VMContext); | |
| } | |
| ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm) | |
| : ObjCCommonTypesHelper(cgm) { | |
| // struct _objc_method_description { | |
| // SEL name; | |
| // char *types; | |
| // } | |
| MethodDescriptionTy = llvm::StructType::create( | |
| "struct._objc_method_description", SelectorPtrTy, Int8PtrTy); | |
| // struct _objc_method_description_list { | |
| // int count; | |
| // struct _objc_method_description[1]; | |
| // } | |
| MethodDescriptionListTy = | |
| llvm::StructType::create("struct._objc_method_description_list", IntTy, | |
| llvm::ArrayType::get(MethodDescriptionTy, 0)); | |
| // struct _objc_method_description_list * | |
| MethodDescriptionListPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // Protocol description structures | |
| // struct _objc_protocol_extension { | |
| // uint32_t size; // sizeof(struct _objc_protocol_extension) | |
| // struct _objc_method_description_list *optional_instance_methods; | |
| // struct _objc_method_description_list *optional_class_methods; | |
| // struct _objc_property_list *instance_properties; | |
| // const char ** extendedMethodTypes; | |
| // struct _objc_property_list *class_properties; | |
| // } | |
| ProtocolExtensionTy = llvm::StructType::create( | |
| "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy, | |
| MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy, | |
| PropertyListPtrTy); | |
| // struct _objc_protocol_extension * | |
| ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // Handle construction of Protocol and ProtocolList types | |
| // struct _objc_protocol { | |
| // struct _objc_protocol_extension *isa; | |
| // char *protocol_name; | |
| // struct _objc_protocol **_objc_protocol_list; | |
| // struct _objc_method_description_list *instance_methods; | |
| // struct _objc_method_description_list *class_methods; | |
| // } | |
| ProtocolTy = llvm::StructType::create( | |
| {ProtocolExtensionPtrTy, Int8PtrTy, | |
| llvm::PointerType::getUnqual(VMContext), MethodDescriptionListPtrTy, | |
| MethodDescriptionListPtrTy}, | |
| "struct._objc_protocol"); | |
| ProtocolListTy = | |
| llvm::StructType::create({llvm::PointerType::getUnqual(VMContext), LongTy, | |
| llvm::ArrayType::get(ProtocolTy, 0)}, | |
| "struct._objc_protocol_list"); | |
| // struct _objc_protocol_list * | |
| ProtocolListPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| ProtocolPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // Class description structures | |
| // struct _objc_ivar { | |
| // char *ivar_name; | |
| // char *ivar_type; | |
| // int ivar_offset; | |
| // } | |
| IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy, | |
| IntTy); | |
| // struct _objc_ivar_list * | |
| IvarListTy = llvm::StructType::create(VMContext, "struct._objc_ivar_list"); | |
| IvarListPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _objc_method_list * | |
| MethodListTy = | |
| llvm::StructType::create(VMContext, "struct._objc_method_list"); | |
| MethodListPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _objc_class_extension * | |
| ClassExtensionTy = llvm::StructType::create( | |
| "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy); | |
| ClassExtensionPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _objc_class { | |
| // Class isa; | |
| // Class super_class; | |
| // char *name; | |
| // long version; | |
| // long info; | |
| // long instance_size; | |
| // struct _objc_ivar_list *ivars; | |
| // struct _objc_method_list *methods; | |
| // struct _objc_cache *cache; | |
| // struct _objc_protocol_list *protocols; | |
| // char *ivar_layout; | |
| // struct _objc_class_ext *ext; | |
| // }; | |
| ClassTy = llvm::StructType::create( | |
| {llvm::PointerType::getUnqual(VMContext), | |
| llvm::PointerType::getUnqual(VMContext), Int8PtrTy, LongTy, LongTy, | |
| LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy, ProtocolListPtrTy, | |
| Int8PtrTy, ClassExtensionPtrTy}, | |
| "struct._objc_class"); | |
| ClassPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _objc_category { | |
| // char *category_name; | |
| // char *class_name; | |
| // struct _objc_method_list *instance_method; | |
| // struct _objc_method_list *class_method; | |
| // struct _objc_protocol_list *protocols; | |
| // uint32_t size; // sizeof(struct _objc_category) | |
| // struct _objc_property_list *instance_properties;// category's @property | |
| // struct _objc_property_list *class_properties; | |
| // } | |
| CategoryTy = llvm::StructType::create( | |
| "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy, | |
| MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy, | |
| PropertyListPtrTy); | |
| // Global metadata structures | |
| // struct _objc_symtab { | |
| // long sel_ref_cnt; | |
| // SEL *refs; | |
| // short cls_def_cnt; | |
| // short cat_def_cnt; | |
| // char *defs[cls_def_cnt + cat_def_cnt]; | |
| // } | |
| SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy, | |
| SelectorPtrTy, ShortTy, ShortTy, | |
| llvm::ArrayType::get(Int8PtrTy, 0)); | |
| SymtabPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _objc_module { | |
| // long version; | |
| // long size; // sizeof(struct _objc_module) | |
| // char *name; | |
| // struct _objc_symtab* symtab; | |
| // } | |
| ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy, | |
| Int8PtrTy, SymtabPtrTy); | |
| // FIXME: This is the size of the setjmp buffer and should be target | |
| // specific. 18 is what's used on 32-bit X86. | |
| uint64_t SetJmpBufferSize = 18; | |
| // Exceptions | |
| llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4); | |
| ExceptionDataTy = llvm::StructType::create( | |
| "struct._objc_exception_data", | |
| llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy); | |
| } | |
| ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper( | |
| CodeGen::CodeGenModule &cgm) | |
| : ObjCCommonTypesHelper(cgm) { | |
| // struct _method_list_t { | |
| // uint32_t entsize; // sizeof(struct _objc_method) | |
| // uint32_t method_count; | |
| // struct _objc_method method_list[method_count]; | |
| // } | |
| MethodListnfABITy = | |
| llvm::StructType::create("struct.__method_list_t", IntTy, IntTy, | |
| llvm::ArrayType::get(MethodTy, 0)); | |
| // struct method_list_t * | |
| MethodListnfABIPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _protocol_t { | |
| // id isa; // NULL | |
| // const char * const protocol_name; | |
| // const struct _protocol_list_t * protocol_list; // super protocols | |
| // const struct method_list_t * const instance_methods; | |
| // const struct method_list_t * const class_methods; | |
| // const struct method_list_t *optionalInstanceMethods; | |
| // const struct method_list_t *optionalClassMethods; | |
| // const struct _prop_list_t * properties; | |
| // const uint32_t size; // sizeof(struct _protocol_t) | |
| // const uint32_t flags; // = 0 | |
| // const char ** extendedMethodTypes; | |
| // const char *demangledName; | |
| // const struct _prop_list_t * class_properties; | |
| // } | |
| ProtocolnfABITy = llvm::StructType::create( | |
| "struct._protocol_t", ObjectPtrTy, Int8PtrTy, | |
| llvm::PointerType::getUnqual(VMContext), MethodListnfABIPtrTy, | |
| MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy, | |
| PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy, | |
| PropertyListPtrTy); | |
| // struct _protocol_t* | |
| ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _protocol_list_t { | |
| // long protocol_count; // Note, this is 32/64 bit | |
| // struct _protocol_t *[protocol_count]; | |
| // } | |
| ProtocolListnfABITy = llvm::StructType::create( | |
| {LongTy, llvm::ArrayType::get(ProtocolnfABIPtrTy, 0)}, | |
| "struct._objc_protocol_list"); | |
| // struct _objc_protocol_list* | |
| ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _ivar_t { | |
| // unsigned [long] int *offset; // pointer to ivar offset location | |
| // char *name; | |
| // char *type; | |
| // uint32_t alignment; | |
| // uint32_t size; | |
| // } | |
| IvarnfABITy = llvm::StructType::create( | |
| "struct._ivar_t", llvm::PointerType::getUnqual(VMContext), Int8PtrTy, | |
| Int8PtrTy, IntTy, IntTy); | |
| // struct _ivar_list_t { | |
| // uint32 entsize; // sizeof(struct _ivar_t) | |
| // uint32 count; | |
| // struct _iver_t list[count]; | |
| // } | |
| IvarListnfABITy = | |
| llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy, | |
| llvm::ArrayType::get(IvarnfABITy, 0)); | |
| IvarListnfABIPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _class_ro_t { | |
| // uint32_t const flags; | |
| // uint32_t const instanceStart; | |
| // uint32_t const instanceSize; | |
| // uint32_t const reserved; // only when building for 64bit targets | |
| // const uint8_t * const ivarLayout; | |
| // const char *const name; | |
| // const struct _method_list_t * const baseMethods; | |
| // const struct _objc_protocol_list *const baseProtocols; | |
| // const struct _ivar_list_t *const ivars; | |
| // const uint8_t * const weakIvarLayout; | |
| // const struct _prop_list_t * const properties; | |
| // } | |
| // FIXME. Add 'reserved' field in 64bit abi mode! | |
| ClassRonfABITy = llvm::StructType::create( | |
| "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy, | |
| MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy, | |
| Int8PtrTy, PropertyListPtrTy); | |
| // ImpnfABITy - LLVM for id (*)(id, SEL, ...) | |
| ImpnfABITy = CGM.DefaultPtrTy; | |
| // struct _class_t { | |
| // struct _class_t *isa; | |
| // struct _class_t * const superclass; | |
| // void *cache; | |
| // IMP *vtable; | |
| // struct class_ro_t *ro; | |
| // } | |
| ClassnfABITy = llvm::StructType::create( | |
| {llvm::PointerType::getUnqual(VMContext), | |
| llvm::PointerType::getUnqual(VMContext), CachePtrTy, | |
| llvm::PointerType::getUnqual(VMContext), | |
| llvm::PointerType::getUnqual(VMContext)}, | |
| "struct._class_t"); | |
| // LLVM for struct _class_t * | |
| ClassnfABIPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct _category_t { | |
| // const char * const name; | |
| // struct _class_t *const cls; | |
| // const struct _method_list_t * const instance_methods; | |
| // const struct _method_list_t * const class_methods; | |
| // const struct _protocol_list_t * const protocols; | |
| // const struct _prop_list_t * const properties; | |
| // const struct _prop_list_t * const class_properties; | |
| // const uint32_t size; | |
| // } | |
| CategorynfABITy = llvm::StructType::create( | |
| "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy, | |
| MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy, | |
| PropertyListPtrTy, IntTy); | |
| // New types for nonfragile abi messaging. | |
| CodeGen::CodeGenTypes &Types = CGM.getTypes(); | |
| ASTContext &Ctx = CGM.getContext(); | |
| // MessageRefTy - LLVM for: | |
| // struct _message_ref_t { | |
| // IMP messenger; | |
| // SEL name; | |
| // }; | |
| // First the clang type for struct _message_ref_t | |
| RecordDecl *RD = RecordDecl::Create( | |
| Ctx, TagTypeKind::Struct, Ctx.getTranslationUnitDecl(), SourceLocation(), | |
| SourceLocation(), &Ctx.Idents.get("_message_ref_t")); | |
| RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), | |
| nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false, | |
| ICIS_NoInit)); | |
| RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), | |
| nullptr, Ctx.getObjCSelType(), nullptr, nullptr, | |
| false, ICIS_NoInit)); | |
| RD->completeDefinition(); | |
| MessageRefCTy = Ctx.getCanonicalTagType(RD); | |
| MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy); | |
| MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy)); | |
| // MessageRefPtrTy - LLVM for struct _message_ref_t* | |
| MessageRefPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // SuperMessageRefTy - LLVM for: | |
| // struct _super_message_ref_t { | |
| // SUPER_IMP messenger; | |
| // SEL name; | |
| // }; | |
| SuperMessageRefTy = llvm::StructType::create("struct._super_message_ref_t", | |
| ImpnfABITy, SelectorPtrTy); | |
| // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t* | |
| SuperMessageRefPtrTy = llvm::PointerType::getUnqual(VMContext); | |
| // struct objc_typeinfo { | |
| // const void** vtable; // objc_ehtype_vtable + 2 | |
| // const char* name; // c++ typeinfo string | |
| // Class cls; | |
| // }; | |
| EHTypeTy = llvm::StructType::create("struct._objc_typeinfo", | |
| llvm::PointerType::getUnqual(VMContext), | |
| Int8PtrTy, ClassnfABIPtrTy); | |
| EHTypePtrTy = llvm::PointerType::getUnqual(VMContext); | |
| } | |
| llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() { | |
| FinishNonFragileABIModule(); | |
| return nullptr; | |
| } | |
| void CGObjCNonFragileABIMac::AddModuleClassList( | |
| ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName, | |
| StringRef SectionName) { | |
| unsigned NumClasses = Container.size(); | |
| if (!NumClasses) | |
| return; | |
| SmallVector<llvm::Constant *, 8> Symbols(NumClasses); | |
| for (unsigned i = 0; i < NumClasses; i++) | |
| Symbols[i] = Container[i]; | |
| llvm::Constant *Init = llvm::ConstantArray::get( | |
| llvm::ArrayType::get(ObjCTypes.Int8PtrTy, Symbols.size()), Symbols); | |
| // Section name is obtained by calling GetSectionName, which returns | |
| // sections in the __DATA segment on MachO. | |
| assert((!CGM.getTriple().isOSBinFormatMachO() || | |
| SectionName.starts_with("__DATA")) && | |
| "SectionName expected to start with __DATA on MachO"); | |
| llvm::GlobalVariable *GV = new llvm::GlobalVariable( | |
| CGM.getModule(), Init->getType(), false, | |
| llvm::GlobalValue::PrivateLinkage, Init, SymbolName); | |
| GV->setAlignment(CGM.getDataLayout().getABITypeAlign(Init->getType())); | |
| GV->setSection(SectionName); | |
| CGM.addCompilerUsedGlobal(GV); | |
| } | |
| void CGObjCNonFragileABIMac::FinishNonFragileABIModule() { | |
| // nonfragile abi has no module definition. | |
| // Build list of all implemented class addresses in array | |
| // L_OBJC_LABEL_CLASS_$. | |
| for (unsigned i = 0, NumClasses = ImplementedClasses.size(); i < NumClasses; | |
| i++) { | |
| const ObjCInterfaceDecl *ID = ImplementedClasses[i]; | |
| assert(ID); | |
| if (ObjCImplementationDecl *IMP = ID->getImplementation()) | |
| // We are implementing a weak imported interface. Give it external linkage | |
| if (ID->isWeakImported() && !IMP->isWeakImported()) { | |
| DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage); | |
| DefinedMetaClasses[i]->setLinkage( | |
| llvm::GlobalVariable::ExternalLinkage); | |
| } | |
| } | |
| AddModuleClassList( | |
| DefinedClasses, "OBJC_LABEL_CLASS_$", | |
| GetSectionName("__objc_classlist", "regular,no_dead_strip")); | |
| AddModuleClassList( | |
| DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$", | |
| GetSectionName("__objc_nlclslist", "regular,no_dead_strip")); | |
| // Build list of all implemented category addresses in array | |
| // L_OBJC_LABEL_CATEGORY_$. | |
| AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$", | |
| GetSectionName("__objc_catlist", "regular,no_dead_strip")); | |
| AddModuleClassList( | |
| DefinedStubCategories, "OBJC_LABEL_STUB_CATEGORY_$", | |
| GetSectionName("__objc_catlist2", "regular,no_dead_strip")); | |
| AddModuleClassList( | |
| DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$", | |
| GetSectionName("__objc_nlcatlist", "regular,no_dead_strip")); | |
| EmitImageInfo(); | |
| } | |
| /// isVTableDispatchedSelector - Returns true if SEL is not in the list of | |
| /// VTableDispatchMethods; false otherwise. What this means is that | |
| /// except for the 19 selectors in the list, we generate 32bit-style | |
| /// message dispatch call for all the rest. | |
| bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) { | |
| // At various points we've experimented with using vtable-based | |
| // dispatch for all methods. | |
| switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) { | |
| case CodeGenOptions::Legacy: | |
| return false; | |
| case CodeGenOptions::NonLegacy: | |
| return true; | |
| case CodeGenOptions::Mixed: | |
| break; | |
| } | |
| // If so, see whether this selector is in the white-list of things which must | |
| // use the new dispatch convention. We lazily build a dense set for this. | |
| if (VTableDispatchMethods.empty()) { | |
| VTableDispatchMethods.insert(GetNullarySelector("alloc")); | |
| VTableDispatchMethods.insert(GetNullarySelector("class")); | |
| VTableDispatchMethods.insert(GetNullarySelector("self")); | |
| VTableDispatchMethods.insert(GetNullarySelector("isFlipped")); | |
| VTableDispatchMethods.insert(GetNullarySelector("length")); | |
| VTableDispatchMethods.insert(GetNullarySelector("count")); | |
| // These are vtable-based if GC is disabled. | |
| // Optimistically use vtable dispatch for hybrid compiles. | |
| if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) { | |
| VTableDispatchMethods.insert(GetNullarySelector("retain")); | |
| VTableDispatchMethods.insert(GetNullarySelector("release")); | |
| VTableDispatchMethods.insert(GetNullarySelector("autorelease")); | |
| } | |
| VTableDispatchMethods.insert(GetUnarySelector("allocWithZone")); | |
| VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass")); | |
| VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector")); | |
| VTableDispatchMethods.insert(GetUnarySelector("objectForKey")); | |
| VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex")); | |
| VTableDispatchMethods.insert(GetUnarySelector("isEqualToString")); | |
| VTableDispatchMethods.insert(GetUnarySelector("isEqual")); | |
| // These are vtable-based if GC is enabled. | |
| // Optimistically use vtable dispatch for hybrid compiles. | |
| if (CGM.getLangOpts().getGC() != LangOptions::NonGC) { | |
| VTableDispatchMethods.insert(GetNullarySelector("hash")); | |
| VTableDispatchMethods.insert(GetUnarySelector("addObject")); | |
| // "countByEnumeratingWithState:objects:count" | |
| const IdentifierInfo *KeyIdents[] = { | |
| &CGM.getContext().Idents.get("countByEnumeratingWithState"), | |
| &CGM.getContext().Idents.get("objects"), | |
| &CGM.getContext().Idents.get("count")}; | |
| VTableDispatchMethods.insert( | |
| CGM.getContext().Selectors.getSelector(3, KeyIdents)); | |
| } | |
| } | |
| return VTableDispatchMethods.count(Sel); | |
| } | |
| /// BuildClassRoTInitializer - generate meta-data for: | |
| /// struct _class_ro_t { | |
| /// uint32_t const flags; | |
| /// uint32_t const instanceStart; | |
| /// uint32_t const instanceSize; | |
| /// uint32_t const reserved; // only when building for 64bit targets | |
| /// const uint8_t * const ivarLayout; | |
| /// const char *const name; | |
| /// const struct _method_list_t * const baseMethods; | |
| /// const struct _protocol_list_t *const baseProtocols; | |
| /// const struct _ivar_list_t *const ivars; | |
| /// const uint8_t * const weakIvarLayout; | |
| /// const struct _prop_list_t * const properties; | |
| /// } | |
| /// | |
| llvm::GlobalVariable *CGObjCNonFragileABIMac::BuildClassRoTInitializer( | |
| unsigned flags, unsigned InstanceStart, unsigned InstanceSize, | |
| const ObjCImplementationDecl *ID) { | |
| std::string ClassName = std::string(ID->getObjCRuntimeNameAsString()); | |
| CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart); | |
| CharUnits endInstance = CharUnits::fromQuantity(InstanceSize); | |
| bool hasMRCWeak = false; | |
| if (CGM.getLangOpts().ObjCAutoRefCount) | |
| flags |= NonFragileABI_Class_CompiledByARC; | |
| else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID))) | |
| flags |= NonFragileABI_Class_HasMRCWeakIvars; | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy); | |
| values.addInt(ObjCTypes.IntTy, flags); | |
| values.addInt(ObjCTypes.IntTy, InstanceStart); | |
| values.addInt(ObjCTypes.IntTy, InstanceSize); | |
| values.add((flags & NonFragileABI_Class_Meta) | |
| ? GetIvarLayoutName(nullptr, ObjCTypes) | |
| : BuildStrongIvarLayout(ID, beginInstance, endInstance)); | |
| values.add(GetClassName(ID->getObjCRuntimeNameAsString())); | |
| // const struct _method_list_t * const baseMethods; | |
| SmallVector<const ObjCMethodDecl *, 16> methods; | |
| if (flags & NonFragileABI_Class_Meta) { | |
| for (const auto *MD : ID->class_methods()) | |
| if (!MD->isDirectMethod()) | |
| methods.push_back(MD); | |
| } else { | |
| for (const auto *MD : ID->instance_methods()) | |
| if (!MD->isDirectMethod()) | |
| methods.push_back(MD); | |
| } | |
| llvm::Constant *MethListPtr = emitMethodList( | |
| ID->getObjCRuntimeNameAsString(), | |
| (flags & NonFragileABI_Class_Meta) ? MethodListType::ClassMethods | |
| : MethodListType::InstanceMethods, | |
| methods); | |
| const PointerAuthSchema &MethListSchema = | |
| CGM.getCodeGenOpts().PointerAuth.ObjCMethodListPointer; | |
| if (!MethListPtr->isNullValue()) | |
| values.addSignedPointer(MethListPtr, MethListSchema, GlobalDecl(), | |
| QualType()); | |
| else | |
| values.add(MethListPtr); | |
| const ObjCInterfaceDecl *OID = ID->getClassInterface(); | |
| assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer"); | |
| values.add(EmitProtocolList("_OBJC_CLASS_PROTOCOLS_$_" + | |
| OID->getObjCRuntimeNameAsString(), | |
| OID->all_referenced_protocol_begin(), | |
| OID->all_referenced_protocol_end())); | |
| if (flags & NonFragileABI_Class_Meta) { | |
| values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy); | |
| values.add(GetIvarLayoutName(nullptr, ObjCTypes)); | |
| values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + | |
| ID->getObjCRuntimeNameAsString(), | |
| ID, ID->getClassInterface(), ObjCTypes, true)); | |
| } else { | |
| values.add(EmitIvarList(ID)); | |
| values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak)); | |
| values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + | |
| ID->getObjCRuntimeNameAsString(), | |
| ID, ID->getClassInterface(), ObjCTypes, false)); | |
| } | |
| llvm::SmallString<64> roLabel; | |
| llvm::raw_svector_ostream(roLabel) | |
| << ((flags & NonFragileABI_Class_Meta) ? "_OBJC_METACLASS_RO_$_" | |
| : "_OBJC_CLASS_RO_$_") | |
| << ClassName; | |
| return finishAndCreateGlobal(values, roLabel, CGM); | |
| } | |
| /// Build the metaclass object for a class. | |
| /// | |
| /// struct _class_t { | |
| /// struct _class_t *isa; | |
| /// struct _class_t * const superclass; | |
| /// void *cache; | |
| /// IMP *vtable; | |
| /// struct class_ro_t *ro; | |
| /// } | |
| /// | |
| llvm::GlobalVariable *CGObjCNonFragileABIMac::BuildClassObject( | |
| const ObjCInterfaceDecl *CI, bool isMetaclass, llvm::Constant *IsAGV, | |
| llvm::Constant *SuperClassGV, llvm::Constant *ClassRoGV, | |
| bool HiddenVisibility) { | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.ClassnfABITy); | |
| const PointerAuthOptions &PointerAuthOpts = CGM.getCodeGenOpts().PointerAuth; | |
| values.addSignedPointer(IsAGV, PointerAuthOpts.ObjCIsaPointers, GlobalDecl(), | |
| QualType()); | |
| if (SuperClassGV) | |
| values.addSignedPointer(SuperClassGV, PointerAuthOpts.ObjCSuperPointers, | |
| GlobalDecl(), QualType()); | |
| else | |
| values.addNullPointer(ObjCTypes.ClassnfABIPtrTy); | |
| values.add(ObjCEmptyCacheVar); | |
| values.add(ObjCEmptyVtableVar); | |
| values.addSignedPointer(ClassRoGV, PointerAuthOpts.ObjCClassROPointers, | |
| GlobalDecl(), QualType()); | |
| llvm::GlobalVariable *GV = cast<llvm::GlobalVariable>( | |
| GetClassGlobal(CI, isMetaclass, ForDefinition)); | |
| values.finishAndSetAsInitializer(GV); | |
| if (CGM.getTriple().isOSBinFormatMachO()) | |
| GV->setSection("__DATA, __objc_data"); | |
| GV->setAlignment(CGM.getDataLayout().getABITypeAlign(ObjCTypes.ClassnfABITy)); | |
| if (!CGM.getTriple().isOSBinFormatCOFF()) | |
| if (HiddenVisibility) | |
| GV->setVisibility(llvm::GlobalValue::HiddenVisibility); | |
| if (CGM.getCodeGenOpts().ObjCMsgSendClassSelectorStubs && !isMetaclass) | |
| CGM.addUsedGlobal(GV); | |
| return GV; | |
| } | |
| bool CGObjCNonFragileABIMac::ImplementationIsNonLazy( | |
| const ObjCImplDecl *OD) const { | |
| return OD->getClassMethod(GetNullarySelector("load")) != nullptr || | |
| OD->getClassInterface()->hasAttr<ObjCNonLazyClassAttr>() || | |
| OD->hasAttr<ObjCNonLazyClassAttr>(); | |
| } | |
| void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID, | |
| uint32_t &InstanceStart, | |
| uint32_t &InstanceSize) { | |
| const ASTRecordLayout &RL = | |
| CGM.getContext().getASTObjCInterfaceLayout(OID->getClassInterface()); | |
| // InstanceSize is really instance end. | |
| InstanceSize = RL.getDataSize().getQuantity(); | |
| // If there are no fields, the start is the same as the end. | |
| if (!RL.getFieldCount()) | |
| InstanceStart = InstanceSize; | |
| else | |
| InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth(); | |
| } | |
| static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM, | |
| StringRef Name) { | |
| IdentifierInfo &II = CGM.getContext().Idents.get(Name); | |
| TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl(); | |
| DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl); | |
| const VarDecl *VD = nullptr; | |
| for (const auto *Result : DC->lookup(&II)) | |
| if ((VD = dyn_cast<VarDecl>(Result))) | |
| break; | |
| if (!VD) | |
| return llvm::GlobalValue::DLLImportStorageClass; | |
| if (VD->hasAttr<DLLExportAttr>()) | |
| return llvm::GlobalValue::DLLExportStorageClass; | |
| if (VD->hasAttr<DLLImportAttr>()) | |
| return llvm::GlobalValue::DLLImportStorageClass; | |
| return llvm::GlobalValue::DefaultStorageClass; | |
| } | |
| void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) { | |
| if (!ObjCEmptyCacheVar) { | |
| ObjCEmptyCacheVar = new llvm::GlobalVariable( | |
| CGM.getModule(), ObjCTypes.CacheTy, false, | |
| llvm::GlobalValue::ExternalLinkage, nullptr, "_objc_empty_cache"); | |
| if (CGM.getTriple().isOSBinFormatCOFF()) | |
| ObjCEmptyCacheVar->setDLLStorageClass( | |
| getStorage(CGM, "_objc_empty_cache")); | |
| // Only OS X with deployment version <10.9 use the empty vtable symbol | |
| const llvm::Triple &Triple = CGM.getTarget().getTriple(); | |
| if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9)) | |
| ObjCEmptyVtableVar = new llvm::GlobalVariable( | |
| CGM.getModule(), ObjCTypes.ImpnfABITy, false, | |
| llvm::GlobalValue::ExternalLinkage, nullptr, "_objc_empty_vtable"); | |
| else | |
| ObjCEmptyVtableVar = llvm::ConstantPointerNull::get(CGM.DefaultPtrTy); | |
| } | |
| // FIXME: Is this correct (that meta class size is never computed)? | |
| uint32_t InstanceStart = | |
| CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy); | |
| uint32_t InstanceSize = InstanceStart; | |
| uint32_t flags = NonFragileABI_Class_Meta; | |
| llvm::Constant *SuperClassGV, *IsAGV; | |
| const auto *CI = ID->getClassInterface(); | |
| assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0"); | |
| // Build the flags for the metaclass. | |
| bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF()) | |
| ? !CI->hasAttr<DLLExportAttr>() | |
| : CI->getVisibility() == HiddenVisibility; | |
| if (classIsHidden) | |
| flags |= NonFragileABI_Class_Hidden; | |
| // FIXME: why is this flag set on the metaclass? | |
| // ObjC metaclasses have no fields and don't really get constructed. | |
| if (ID->hasNonZeroConstructors() || ID->hasDestructors()) { | |
| flags |= NonFragileABI_Class_HasCXXStructors; | |
| if (!ID->hasNonZeroConstructors()) | |
| flags |= NonFragileABI_Class_HasCXXDestructorOnly; | |
| } | |
| if (!CI->getSuperClass()) { | |
| // class is root | |
| flags |= NonFragileABI_Class_Root; | |
| SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition); | |
| IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition); | |
| } else { | |
| // Has a root. Current class is not a root. | |
| const ObjCInterfaceDecl *Root = ID->getClassInterface(); | |
| while (const ObjCInterfaceDecl *Super = Root->getSuperClass()) | |
| Root = Super; | |
| const auto *Super = CI->getSuperClass(); | |
| IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition); | |
| SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition); | |
| } | |
| llvm::GlobalVariable *CLASS_RO_GV = | |
| BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID); | |
| llvm::GlobalVariable *MetaTClass = BuildClassObject( | |
| CI, /*metaclass*/ true, IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden); | |
| CGM.setGVProperties(MetaTClass, CI); | |
| DefinedMetaClasses.push_back(MetaTClass); | |
| // Metadata for the class | |
| flags = 0; | |
| if (classIsHidden) | |
| flags |= NonFragileABI_Class_Hidden; | |
| if (ID->hasNonZeroConstructors() || ID->hasDestructors()) { | |
| flags |= NonFragileABI_Class_HasCXXStructors; | |
| // Set a flag to enable a runtime optimization when a class has | |
| // fields that require destruction but which don't require | |
| // anything except zero-initialization during construction. This | |
| // is most notably true of __strong and __weak types, but you can | |
| // also imagine there being C++ types with non-trivial default | |
| // constructors that merely set all fields to null. | |
| if (!ID->hasNonZeroConstructors()) | |
| flags |= NonFragileABI_Class_HasCXXDestructorOnly; | |
| } | |
| if (hasObjCExceptionAttribute(CGM.getContext(), CI)) | |
| flags |= NonFragileABI_Class_Exception; | |
| if (!CI->getSuperClass()) { | |
| flags |= NonFragileABI_Class_Root; | |
| SuperClassGV = nullptr; | |
| } else { | |
| // Has a root. Current class is not a root. | |
| const auto *Super = CI->getSuperClass(); | |
| SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition); | |
| } | |
| GetClassSizeInfo(ID, InstanceStart, InstanceSize); | |
| CLASS_RO_GV = | |
| BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID); | |
| llvm::GlobalVariable *ClassMD = | |
| BuildClassObject(CI, /*metaclass*/ false, MetaTClass, SuperClassGV, | |
| CLASS_RO_GV, classIsHidden); | |
| CGM.setGVProperties(ClassMD, CI); | |
| DefinedClasses.push_back(ClassMD); | |
| ImplementedClasses.push_back(CI); | |
| // Determine if this class is also "non-lazy". | |
| if (ImplementationIsNonLazy(ID)) | |
| DefinedNonLazyClasses.push_back(ClassMD); | |
| // Force the definition of the EHType if necessary. | |
| if (flags & NonFragileABI_Class_Exception) | |
| (void)GetInterfaceEHType(CI, ForDefinition); | |
| // Make sure method definition entries are all clear for next implementation. | |
| MethodDefinitions.clear(); | |
| } | |
| /// GenerateProtocolRef - This routine is called to generate code for | |
| /// a protocol reference expression; as in: | |
| /// @code | |
| /// @protocol(Proto1); | |
| /// @endcode | |
| /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1 | |
| /// which will hold address of the protocol meta-data. | |
| /// | |
| llvm::Value * | |
| CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF, | |
| const ObjCProtocolDecl *PD) { | |
| // This routine is called for @protocol only. So, we must build definition | |
| // of protocol's meta-data (not a reference to it!) | |
| assert(!PD->isNonRuntimeProtocol() && | |
| "attempting to get a protocol ref to a static protocol."); | |
| llvm::Constant *Init = GetOrEmitProtocol(PD); | |
| std::string ProtocolName("_OBJC_PROTOCOL_REFERENCE_$_"); | |
| ProtocolName += PD->getObjCRuntimeNameAsString(); | |
| CharUnits Align = CGF.getPointerAlign(); | |
| llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName); | |
| if (PTGV) | |
| return CGF.Builder.CreateAlignedLoad(PTGV->getValueType(), PTGV, Align); | |
| PTGV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false, | |
| llvm::GlobalValue::WeakAnyLinkage, Init, | |
| ProtocolName); | |
| PTGV->setSection( | |
| GetSectionName("__objc_protorefs", "coalesced,no_dead_strip")); | |
| PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility); | |
| PTGV->setAlignment(Align.getAsAlign()); | |
| if (!CGM.getTriple().isOSBinFormatMachO()) | |
| PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolName)); | |
| CGM.addUsedGlobal(PTGV); | |
| return CGF.Builder.CreateAlignedLoad(PTGV->getValueType(), PTGV, Align); | |
| } | |
| /// GenerateCategory - Build metadata for a category implementation. | |
| /// struct _category_t { | |
| /// const char * const name; | |
| /// struct _class_t *const cls; | |
| /// const struct _method_list_t * const instance_methods; | |
| /// const struct _method_list_t * const class_methods; | |
| /// const struct _protocol_list_t * const protocols; | |
| /// const struct _prop_list_t * const properties; | |
| /// const struct _prop_list_t * const class_properties; | |
| /// const uint32_t size; | |
| /// } | |
| /// | |
| void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) { | |
| const ObjCInterfaceDecl *Interface = OCD->getClassInterface(); | |
| const char *Prefix = "_OBJC_$_CATEGORY_"; | |
| llvm::SmallString<64> ExtCatName(Prefix); | |
| ExtCatName += Interface->getObjCRuntimeNameAsString(); | |
| ExtCatName += "_$_"; | |
| ExtCatName += OCD->getNameAsString(); | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.CategorynfABITy); | |
| values.add(GetClassName(OCD->getIdentifier()->getName())); | |
| // meta-class entry symbol | |
| values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition)); | |
| std::string listName = | |
| (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str(); | |
| SmallVector<const ObjCMethodDecl *, 16> instanceMethods; | |
| SmallVector<const ObjCMethodDecl *, 8> classMethods; | |
| for (const auto *MD : OCD->methods()) { | |
| if (MD->isDirectMethod()) | |
| continue; | |
| if (MD->isInstanceMethod()) { | |
| instanceMethods.push_back(MD); | |
| } else { | |
| classMethods.push_back(MD); | |
| } | |
| } | |
| llvm::Constant *InstanceMethodList = emitMethodList( | |
| listName, MethodListType::CategoryInstanceMethods, instanceMethods); | |
| const PointerAuthSchema &MethListSchema = | |
| CGM.getCodeGenOpts().PointerAuth.ObjCMethodListPointer; | |
| if (!InstanceMethodList->isNullValue()) | |
| values.addSignedPointer(InstanceMethodList, MethListSchema, GlobalDecl(), | |
| QualType()); | |
| else | |
| values.add(InstanceMethodList); | |
| llvm::Constant *ClassMethodList = emitMethodList( | |
| listName, MethodListType::CategoryClassMethods, classMethods); | |
| if (!ClassMethodList->isNullValue()) | |
| values.addSignedPointer(ClassMethodList, MethListSchema, GlobalDecl(), | |
| QualType()); | |
| else | |
| values.add(ClassMethodList); | |
| // Keep track of whether we have actual metadata to emit. | |
| bool isEmptyCategory = | |
| InstanceMethodList->isNullValue() && ClassMethodList->isNullValue(); | |
| const ObjCCategoryDecl *Category = | |
| Interface->FindCategoryDeclaration(OCD->getIdentifier()); | |
| if (Category) { | |
| SmallString<256> ExtName; | |
| llvm::raw_svector_ostream(ExtName) | |
| << Interface->getObjCRuntimeNameAsString() << "_$_" << OCD->getName(); | |
| auto protocolList = | |
| EmitProtocolList("_OBJC_CATEGORY_PROTOCOLS_$_" + | |
| Interface->getObjCRuntimeNameAsString() + "_$_" + | |
| Category->getName(), | |
| Category->protocol_begin(), Category->protocol_end()); | |
| auto propertyList = EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(), | |
| OCD, Category, ObjCTypes, false); | |
| auto classPropertyList = | |
| EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(), OCD, | |
| Category, ObjCTypes, true); | |
| values.add(protocolList); | |
| values.add(propertyList); | |
| values.add(classPropertyList); | |
| isEmptyCategory &= protocolList->isNullValue() && | |
| propertyList->isNullValue() && | |
| classPropertyList->isNullValue(); | |
| } else { | |
| values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy); | |
| values.addNullPointer(ObjCTypes.PropertyListPtrTy); | |
| values.addNullPointer(ObjCTypes.PropertyListPtrTy); | |
| } | |
| if (isEmptyCategory) { | |
| // Empty category, don't emit any metadata. | |
| values.abandon(); | |
| MethodDefinitions.clear(); | |
| return; | |
| } | |
| unsigned Size = | |
| CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy); | |
| values.addInt(ObjCTypes.IntTy, Size); | |
| llvm::GlobalVariable *GCATV = | |
| finishAndCreateGlobal(values, ExtCatName.str(), CGM); | |
| CGM.addCompilerUsedGlobal(GCATV); | |
| if (Interface->hasAttr<ObjCClassStubAttr>()) | |
| DefinedStubCategories.push_back(GCATV); | |
| else | |
| DefinedCategories.push_back(GCATV); | |
| // Determine if this category is also "non-lazy". | |
| if (ImplementationIsNonLazy(OCD)) | |
| DefinedNonLazyCategories.push_back(GCATV); | |
| // method definition entries must be clear for next implementation. | |
| MethodDefinitions.clear(); | |
| } | |
| /// emitMethodConstant - Return a struct objc_method constant. If | |
| /// forProtocol is true, the implementation will be null; otherwise, | |
| /// the method must have a definition registered with the runtime. | |
| /// | |
| /// struct _objc_method { | |
| /// SEL _cmd; | |
| /// char *method_type; | |
| /// char *_imp; | |
| /// } | |
| void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder, | |
| const ObjCMethodDecl *MD, | |
| bool forProtocol) { | |
| auto method = builder.beginStruct(ObjCTypes.MethodTy); | |
| method.add(GetMethodVarName(MD->getSelector())); | |
| method.add(GetMethodVarType(MD)); | |
| if (forProtocol) { | |
| // Protocol methods have no implementation. So, this entry is always NULL. | |
| method.addNullPointer(ObjCTypes.Int8PtrProgramASTy); | |
| } else { | |
| llvm::Function *fn = GetMethodDefinition(MD); | |
| assert(fn && "no definition for method?"); | |
| if (const PointerAuthSchema &Schema = | |
| CGM.getCodeGenOpts().PointerAuth.ObjCMethodListFunctionPointers) { | |
| llvm::Constant *Bitcast = | |
| llvm::ConstantExpr::getBitCast(fn, ObjCTypes.Int8PtrProgramASTy); | |
| method.addSignedPointer(Bitcast, Schema, GlobalDecl(), QualType()); | |
| } else | |
| method.add(fn); | |
| } | |
| method.finishAndAddTo(builder); | |
| } | |
| /// Build meta-data for method declarations. | |
| /// | |
| /// struct _method_list_t { | |
| /// uint32_t entsize; // sizeof(struct _objc_method) | |
| /// uint32_t method_count; | |
| /// struct _objc_method method_list[method_count]; | |
| /// } | |
| /// | |
| llvm::Constant *CGObjCNonFragileABIMac::emitMethodList( | |
| Twine name, MethodListType kind, ArrayRef<const ObjCMethodDecl *> methods) { | |
| // Return null for empty list. | |
| if (methods.empty()) | |
| return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy); | |
| StringRef prefix; | |
| bool forProtocol; | |
| switch (kind) { | |
| case MethodListType::CategoryInstanceMethods: | |
| prefix = "_OBJC_$_CATEGORY_INSTANCE_METHODS_"; | |
| forProtocol = false; | |
| break; | |
| case MethodListType::CategoryClassMethods: | |
| prefix = "_OBJC_$_CATEGORY_CLASS_METHODS_"; | |
| forProtocol = false; | |
| break; | |
| case MethodListType::InstanceMethods: | |
| prefix = "_OBJC_$_INSTANCE_METHODS_"; | |
| forProtocol = false; | |
| break; | |
| case MethodListType::ClassMethods: | |
| prefix = "_OBJC_$_CLASS_METHODS_"; | |
| forProtocol = false; | |
| break; | |
| case MethodListType::ProtocolInstanceMethods: | |
| prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_"; | |
| forProtocol = true; | |
| break; | |
| case MethodListType::ProtocolClassMethods: | |
| prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_"; | |
| forProtocol = true; | |
| break; | |
| case MethodListType::OptionalProtocolInstanceMethods: | |
| prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_"; | |
| forProtocol = true; | |
| break; | |
| case MethodListType::OptionalProtocolClassMethods: | |
| prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_"; | |
| forProtocol = true; | |
| break; | |
| } | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(); | |
| // sizeof(struct _objc_method) | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy); | |
| values.addInt(ObjCTypes.IntTy, Size); | |
| // method_count | |
| values.addInt(ObjCTypes.IntTy, methods.size()); | |
| auto methodArray = values.beginArray(ObjCTypes.MethodTy); | |
| for (auto MD : methods) | |
| emitMethodConstant(methodArray, MD, forProtocol); | |
| methodArray.finishAndAddTo(values); | |
| llvm::GlobalVariable *GV = finishAndCreateGlobal(values, prefix + name, CGM); | |
| CGM.addCompilerUsedGlobal(GV); | |
| return GV; | |
| } | |
| /// ObjCIvarOffsetVariable - Returns the ivar offset variable for | |
| /// the given ivar. | |
| llvm::GlobalVariable * | |
| CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID, | |
| const ObjCIvarDecl *Ivar) { | |
| const ObjCInterfaceDecl *Container = Ivar->getContainingInterface(); | |
| llvm::SmallString<64> Name("OBJC_IVAR_$_"); | |
| Name += Container->getObjCRuntimeNameAsString(); | |
| Name += "."; | |
| Name += Ivar->getName(); | |
| llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name); | |
| if (!IvarOffsetGV) { | |
| IvarOffsetGV = new llvm::GlobalVariable( | |
| CGM.getModule(), ObjCTypes.IvarOffsetVarTy, false, | |
| llvm::GlobalValue::ExternalLinkage, nullptr, Name.str()); | |
| if (CGM.getTriple().isOSBinFormatCOFF()) { | |
| bool IsPrivateOrPackage = | |
| Ivar->getAccessControl() == ObjCIvarDecl::Private || | |
| Ivar->getAccessControl() == ObjCIvarDecl::Package; | |
| const ObjCInterfaceDecl *ContainingID = Ivar->getContainingInterface(); | |
| if (ContainingID->hasAttr<DLLImportAttr>()) | |
| IvarOffsetGV->setDLLStorageClass( | |
| llvm::GlobalValue::DLLImportStorageClass); | |
| else if (ContainingID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage) | |
| IvarOffsetGV->setDLLStorageClass( | |
| llvm::GlobalValue::DLLExportStorageClass); | |
| } | |
| } | |
| return IvarOffsetGV; | |
| } | |
| llvm::Constant * | |
| CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID, | |
| const ObjCIvarDecl *Ivar, | |
| unsigned long int Offset) { | |
| llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar); | |
| IvarOffsetGV->setInitializer( | |
| llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset)); | |
| IvarOffsetGV->setAlignment( | |
| CGM.getDataLayout().getABITypeAlign(ObjCTypes.IvarOffsetVarTy)); | |
| if (!CGM.getTriple().isOSBinFormatCOFF()) { | |
| // FIXME: This matches gcc, but shouldn't the visibility be set on the use | |
| // as well (i.e., in ObjCIvarOffsetVariable). | |
| if (Ivar->getAccessControl() == ObjCIvarDecl::Private || | |
| Ivar->getAccessControl() == ObjCIvarDecl::Package || | |
| ID->getVisibility() == HiddenVisibility) | |
| IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility); | |
| else | |
| IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility); | |
| } | |
| // If ID's layout is known, then make the global constant. This serves as a | |
| // useful assertion: we'll never use this variable to calculate ivar offsets, | |
| // so if the runtime tries to patch it then we should crash. | |
| if (isClassLayoutKnownStatically(ID)) | |
| IvarOffsetGV->setConstant(true); | |
| if (CGM.getTriple().isOSBinFormatMachO()) | |
| IvarOffsetGV->setSection("__DATA, __objc_ivar"); | |
| return IvarOffsetGV; | |
| } | |
| /// EmitIvarList - Emit the ivar list for the given | |
| /// implementation. The return value has type | |
| /// IvarListnfABIPtrTy. | |
| /// struct _ivar_t { | |
| /// unsigned [long] int *offset; // pointer to ivar offset location | |
| /// char *name; | |
| /// char *type; | |
| /// uint32_t alignment; | |
| /// uint32_t size; | |
| /// } | |
| /// struct _ivar_list_t { | |
| /// uint32 entsize; // sizeof(struct _ivar_t) | |
| /// uint32 count; | |
| /// struct _iver_t list[count]; | |
| /// } | |
| /// | |
| llvm::Constant * | |
| CGObjCNonFragileABIMac::EmitIvarList(const ObjCImplementationDecl *ID) { | |
| ConstantInitBuilder builder(CGM); | |
| auto ivarList = builder.beginStruct(); | |
| ivarList.addInt(ObjCTypes.IntTy, | |
| CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy)); | |
| auto ivarCountSlot = ivarList.addPlaceholder(); | |
| auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy); | |
| const ObjCInterfaceDecl *OID = ID->getClassInterface(); | |
| assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface"); | |
| // FIXME. Consolidate this with similar code in GenerateClass. | |
| for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin(); IVD; | |
| IVD = IVD->getNextIvar()) { | |
| // Ignore unnamed bit-fields. | |
| if (!IVD->getDeclName()) | |
| continue; | |
| auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy); | |
| ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD, | |
| ComputeIvarBaseOffset(CGM, ID, IVD))); | |
| ivar.add(GetMethodVarName(IVD->getIdentifier())); | |
| ivar.add(GetMethodVarType(IVD)); | |
| llvm::Type *FieldTy = CGM.getTypes().ConvertTypeForMem(IVD->getType()); | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy); | |
| unsigned Align = | |
| CGM.getContext().getPreferredTypeAlign(IVD->getType().getTypePtr()) >> | |
| 3; | |
| Align = llvm::Log2_32(Align); | |
| ivar.addInt(ObjCTypes.IntTy, Align); | |
| // NOTE. Size of a bitfield does not match gcc's, because of the | |
| // way bitfields are treated special in each. But I am told that | |
| // 'size' for bitfield ivars is ignored by the runtime so it does | |
| // not matter. If it matters, there is enough info to get the | |
| // bitfield right! | |
| ivar.addInt(ObjCTypes.IntTy, Size); | |
| ivar.finishAndAddTo(ivars); | |
| } | |
| // Return null for empty list. | |
| if (ivars.empty()) { | |
| ivars.abandon(); | |
| ivarList.abandon(); | |
| return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy); | |
| } | |
| auto ivarCount = ivars.size(); | |
| ivars.finishAndAddTo(ivarList); | |
| ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount); | |
| const char *Prefix = "_OBJC_$_INSTANCE_VARIABLES_"; | |
| llvm::GlobalVariable *GV = finishAndCreateGlobal( | |
| ivarList, Prefix + OID->getObjCRuntimeNameAsString(), CGM); | |
| CGM.addCompilerUsedGlobal(GV); | |
| return GV; | |
| } | |
| llvm::Constant * | |
| CGObjCNonFragileABIMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) { | |
| llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()]; | |
| assert(!PD->isNonRuntimeProtocol() && | |
| "attempting to GetOrEmit a non-runtime protocol"); | |
| if (!Entry) { | |
| // We use the initializer as a marker of whether this is a forward | |
| // reference or not. At module finalization we add the empty | |
| // contents for protocols which were referenced but never defined. | |
| llvm::SmallString<64> Protocol; | |
| llvm::raw_svector_ostream(Protocol) | |
| << "_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString(); | |
| Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy, | |
| false, llvm::GlobalValue::ExternalLinkage, | |
| nullptr, Protocol); | |
| if (!CGM.getTriple().isOSBinFormatMachO()) | |
| Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol)); | |
| } | |
| return Entry; | |
| } | |
| /// GetOrEmitProtocol - Generate the protocol meta-data: | |
| /// @code | |
| /// struct _protocol_t { | |
| /// id isa; // NULL | |
| /// const char * const protocol_name; | |
| /// const struct _protocol_list_t * protocol_list; // super protocols | |
| /// const struct method_list_t * const instance_methods; | |
| /// const struct method_list_t * const class_methods; | |
| /// const struct method_list_t *optionalInstanceMethods; | |
| /// const struct method_list_t *optionalClassMethods; | |
| /// const struct _prop_list_t * properties; | |
| /// const uint32_t size; // sizeof(struct _protocol_t) | |
| /// const uint32_t flags; // = 0 | |
| /// const char ** extendedMethodTypes; | |
| /// const char *demangledName; | |
| /// const struct _prop_list_t * class_properties; | |
| /// } | |
| /// @endcode | |
| /// | |
| llvm::Constant * | |
| CGObjCNonFragileABIMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) { | |
| llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()]; | |
| // Early exit if a defining object has already been generated. | |
| if (Entry && Entry->hasInitializer()) | |
| return Entry; | |
| // Use the protocol definition, if there is one. | |
| assert(PD->hasDefinition() && | |
| "emitting protocol metadata without definition"); | |
| PD = PD->getDefinition(); | |
| auto methodLists = ProtocolMethodLists::get(PD); | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy); | |
| // isa is NULL | |
| values.addNullPointer(ObjCTypes.ObjectPtrTy); | |
| values.add(GetClassName(PD->getObjCRuntimeNameAsString())); | |
| values.add(EmitProtocolList("_OBJC_$_PROTOCOL_REFS_" + | |
| PD->getObjCRuntimeNameAsString(), | |
| PD->protocol_begin(), PD->protocol_end())); | |
| values.add(methodLists.emitMethodList( | |
| this, PD, ProtocolMethodLists::RequiredInstanceMethods)); | |
| values.add(methodLists.emitMethodList( | |
| this, PD, ProtocolMethodLists::RequiredClassMethods)); | |
| values.add(methodLists.emitMethodList( | |
| this, PD, ProtocolMethodLists::OptionalInstanceMethods)); | |
| values.add(methodLists.emitMethodList( | |
| this, PD, ProtocolMethodLists::OptionalClassMethods)); | |
| values.add( | |
| EmitPropertyList("_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(), | |
| nullptr, PD, ObjCTypes, false)); | |
| uint32_t Size = | |
| CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy); | |
| values.addInt(ObjCTypes.IntTy, Size); | |
| values.addInt(ObjCTypes.IntTy, 0); | |
| values.add(EmitProtocolMethodTypes( | |
| "_OBJC_$_PROTOCOL_METHOD_TYPES_" + PD->getObjCRuntimeNameAsString(), | |
| methodLists.emitExtendedTypesArray(this), ObjCTypes)); | |
| // const char *demangledName; | |
| values.addNullPointer(ObjCTypes.Int8PtrTy); | |
| values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + | |
| PD->getObjCRuntimeNameAsString(), | |
| nullptr, PD, ObjCTypes, true)); | |
| if (Entry) { | |
| // Already created, fix the linkage and update the initializer. | |
| Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage); | |
| values.finishAndSetAsInitializer(Entry); | |
| } else { | |
| llvm::SmallString<64> symbolName; | |
| llvm::raw_svector_ostream(symbolName) | |
| << "_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString(); | |
| Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(), | |
| /*constant*/ false, | |
| llvm::GlobalValue::WeakAnyLinkage); | |
| if (!CGM.getTriple().isOSBinFormatMachO()) | |
| Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName)); | |
| Protocols[PD->getIdentifier()] = Entry; | |
| } | |
| Entry->setVisibility(llvm::GlobalValue::HiddenVisibility); | |
| CGM.addUsedGlobal(Entry); | |
| // Use this protocol meta-data to build protocol list table in section | |
| // __DATA, __objc_protolist | |
| llvm::SmallString<64> ProtocolRef; | |
| llvm::raw_svector_ostream(ProtocolRef) | |
| << "_OBJC_LABEL_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString(); | |
| llvm::GlobalVariable *PTGV = new llvm::GlobalVariable( | |
| CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy, false, | |
| llvm::GlobalValue::WeakAnyLinkage, Entry, ProtocolRef); | |
| if (!CGM.getTriple().isOSBinFormatMachO()) | |
| PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef)); | |
| PTGV->setAlignment( | |
| CGM.getDataLayout().getABITypeAlign(ObjCTypes.ProtocolnfABIPtrTy)); | |
| PTGV->setSection( | |
| GetSectionName("__objc_protolist", "coalesced,no_dead_strip")); | |
| PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility); | |
| CGM.addUsedGlobal(PTGV); | |
| return Entry; | |
| } | |
| /// EmitProtocolList - Generate protocol list meta-data: | |
| /// @code | |
| /// struct _protocol_list_t { | |
| /// long protocol_count; // Note, this is 32/64 bit | |
| /// struct _protocol_t[protocol_count]; | |
| /// } | |
| /// @endcode | |
| /// | |
| llvm::Constant *CGObjCNonFragileABIMac::EmitProtocolList( | |
| Twine Name, ObjCProtocolDecl::protocol_iterator begin, | |
| ObjCProtocolDecl::protocol_iterator end) { | |
| // Just return null for empty protocol lists | |
| auto Protocols = GetRuntimeProtocolList(begin, end); | |
| if (Protocols.empty()) | |
| return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy); | |
| SmallVector<llvm::Constant *, 16> ProtocolRefs; | |
| ProtocolRefs.reserve(Protocols.size()); | |
| for (const auto *PD : Protocols) | |
| ProtocolRefs.push_back(GetProtocolRef(PD)); | |
| // If all of the protocols in the protocol list are objc_non_runtime_protocol | |
| // just return null | |
| if (ProtocolRefs.size() == 0) | |
| return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy); | |
| // FIXME: We shouldn't need to do this lookup here, should we? | |
| SmallString<256> TmpName; | |
| Name.toVector(TmpName); | |
| llvm::GlobalVariable *GV = | |
| CGM.getModule().getGlobalVariable(TmpName.str(), true); | |
| if (GV) | |
| return GV; | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(); | |
| auto countSlot = values.addPlaceholder(); | |
| // A null-terminated array of protocols. | |
| auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy); | |
| for (auto const &proto : ProtocolRefs) | |
| array.add(proto); | |
| auto count = array.size(); | |
| array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy); | |
| array.finishAndAddTo(values); | |
| values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count); | |
| GV = finishAndCreateGlobal(values, Name, CGM); | |
| CGM.addCompilerUsedGlobal(GV); | |
| return GV; | |
| } | |
| /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference. | |
| /// This code gen. amounts to generating code for: | |
| /// @code | |
| /// (type *)((char *)base + _OBJC_IVAR_$_.ivar; | |
| /// @encode | |
| /// | |
| LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar( | |
| CodeGen::CodeGenFunction &CGF, QualType ObjectTy, llvm::Value *BaseValue, | |
| const ObjCIvarDecl *Ivar, unsigned CVRQualifiers) { | |
| ObjCInterfaceDecl *ID = ObjectTy->castAs<ObjCObjectType>()->getInterface(); | |
| llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar); | |
| return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers, | |
| Offset); | |
| } | |
| llvm::Value * | |
| CGObjCNonFragileABIMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF, | |
| const ObjCInterfaceDecl *Interface, | |
| const ObjCIvarDecl *Ivar) { | |
| llvm::Value *IvarOffsetValue; | |
| if (isClassLayoutKnownStatically(Interface)) { | |
| IvarOffsetValue = llvm::ConstantInt::get( | |
| ObjCTypes.IvarOffsetVarTy, | |
| ComputeIvarBaseOffset(CGM, Interface->getImplementation(), Ivar)); | |
| } else { | |
| llvm::GlobalVariable *GV = ObjCIvarOffsetVariable(Interface, Ivar); | |
| IvarOffsetValue = CGF.Builder.CreateAlignedLoad(GV->getValueType(), GV, | |
| CGF.getSizeAlign(), "ivar"); | |
| if (IsIvarOffsetKnownIdempotent(CGF, Ivar)) | |
| cast<llvm::LoadInst>(IvarOffsetValue) | |
| ->setMetadata(llvm::LLVMContext::MD_invariant_load, | |
| llvm::MDNode::get(VMContext, {})); | |
| } | |
| // This could be 32bit int or 64bit integer depending on the architecture. | |
| // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value | |
| // as this is what caller always expects. | |
| if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy) | |
| IvarOffsetValue = CGF.Builder.CreateIntCast( | |
| IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv"); | |
| return IvarOffsetValue; | |
| } | |
| static void appendSelectorForMessageRefTable(std::string &buffer, | |
| Selector selector) { | |
| if (selector.isUnarySelector()) { | |
| buffer += selector.getNameForSlot(0); | |
| return; | |
| } | |
| for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) { | |
| buffer += selector.getNameForSlot(i); | |
| buffer += '_'; | |
| } | |
| } | |
| /// Emit a "vtable" message send. We emit a weak hidden-visibility | |
| /// struct, initially containing the selector pointer and a pointer to | |
| /// a "fixup" variant of the appropriate objc_msgSend. To call, we | |
| /// load and call the function pointer, passing the address of the | |
| /// struct as the second parameter. The runtime determines whether | |
| /// the selector is currently emitted using vtable dispatch; if so, it | |
| /// substitutes a stub function which simply tail-calls through the | |
| /// appropriate vtable slot, and if not, it substitues a stub function | |
| /// which tail-calls objc_msgSend. Both stubs adjust the selector | |
| /// argument to correctly point to the selector. | |
| RValue CGObjCNonFragileABIMac::EmitVTableMessageSend( | |
| CodeGenFunction &CGF, ReturnValueSlot returnSlot, QualType resultType, | |
| Selector selector, llvm::Value *arg0, QualType arg0Type, bool isSuper, | |
| const CallArgList &formalArgs, const ObjCMethodDecl *method) { | |
| // Compute the actual arguments. | |
| CallArgList args; | |
| // First argument: the receiver / super-call structure. | |
| if (!isSuper) | |
| arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy); | |
| args.add(RValue::get(arg0), arg0Type); | |
| // Second argument: a pointer to the message ref structure. Leave | |
| // the actual argument value blank for now. | |
| args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy); | |
| llvm::append_range(args, formalArgs); | |
| MessageSendInfo MSI = getMessageSendInfo(method, resultType, args); | |
| NullReturnState nullReturn; | |
| // Find the function to call and the mangled name for the message | |
| // ref structure. Using a different mangled name wouldn't actually | |
| // be a problem; it would just be a waste. | |
| // | |
| // The runtime currently never uses vtable dispatch for anything | |
| // except normal, non-super message-sends. | |
| // FIXME: don't use this for that. | |
| llvm::FunctionCallee fn = nullptr; | |
| std::string messageRefName("_"); | |
| if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) { | |
| if (isSuper) { | |
| fn = ObjCTypes.getMessageSendSuper2StretFixupFn(); | |
| messageRefName += "objc_msgSendSuper2_stret_fixup"; | |
| } else { | |
| nullReturn.init(CGF, arg0); | |
| fn = ObjCTypes.getMessageSendStretFixupFn(); | |
| messageRefName += "objc_msgSend_stret_fixup"; | |
| } | |
| } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) { | |
| fn = ObjCTypes.getMessageSendFpretFixupFn(); | |
| messageRefName += "objc_msgSend_fpret_fixup"; | |
| } else { | |
| if (isSuper) { | |
| fn = ObjCTypes.getMessageSendSuper2FixupFn(); | |
| messageRefName += "objc_msgSendSuper2_fixup"; | |
| } else { | |
| fn = ObjCTypes.getMessageSendFixupFn(); | |
| messageRefName += "objc_msgSend_fixup"; | |
| } | |
| } | |
| assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend"); | |
| messageRefName += '_'; | |
| // Append the selector name, except use underscores anywhere we | |
| // would have used colons. | |
| appendSelectorForMessageRefTable(messageRefName, selector); | |
| llvm::GlobalVariable *messageRef = | |
| CGM.getModule().getGlobalVariable(messageRefName); | |
| if (!messageRef) { | |
| // Build the message ref structure. | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(); | |
| values.add(cast<llvm::Constant>(fn.getCallee())); | |
| values.add(GetMethodVarName(selector)); | |
| messageRef = values.finishAndCreateGlobal( | |
| messageRefName, CharUnits::fromQuantity(16), | |
| /*constant*/ false, llvm::GlobalValue::WeakAnyLinkage); | |
| messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility); | |
| messageRef->setSection(GetSectionName("__objc_msgrefs", "coalesced")); | |
| } | |
| bool requiresnullCheck = false; | |
| if (CGM.getLangOpts().ObjCAutoRefCount && method) | |
| for (const auto *ParamDecl : method->parameters()) { | |
| if (ParamDecl->isDestroyedInCallee()) { | |
| if (!nullReturn.NullBB) | |
| nullReturn.init(CGF, arg0); | |
| requiresnullCheck = true; | |
| break; | |
| } | |
| } | |
| Address mref = | |
| Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy), | |
| ObjCTypes.MessageRefTy, CGF.getPointerAlign()); | |
| // Update the message ref argument. | |
| args[1].setRValue(RValue::get(mref, CGF)); | |
| // Load the function to call from the message ref table. | |
| Address calleeAddr = CGF.Builder.CreateStructGEP(mref, 0); | |
| llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn"); | |
| calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType); | |
| CGCallee callee(CGCalleeInfo(), calleePtr); | |
| RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args); | |
| return nullReturn.complete(CGF, returnSlot, result, resultType, formalArgs, | |
| requiresnullCheck ? method : nullptr); | |
| } | |
| /// Generate code for a message send expression in the nonfragile abi. | |
| CodeGen::RValue CGObjCNonFragileABIMac::GenerateMessageSend( | |
| CodeGen::CodeGenFunction &CGF, ReturnValueSlot Return, QualType ResultType, | |
| Selector Sel, llvm::Value *Receiver, const CallArgList &CallArgs, | |
| const ObjCInterfaceDecl *Class, const ObjCMethodDecl *Method) { | |
| return isVTableDispatchedSelector(Sel) | |
| ? EmitVTableMessageSend(CGF, Return, ResultType, Sel, Receiver, | |
| CGF.getContext().getObjCIdType(), false, | |
| CallArgs, Method) | |
| : EmitMessageSend(CGF, Return, ResultType, Sel, Receiver, | |
| CGF.getContext().getObjCIdType(), false, | |
| CallArgs, Method, Class, ObjCTypes); | |
| } | |
| llvm::Constant * | |
| CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID, | |
| bool metaclass, | |
| ForDefinition_t isForDefinition) { | |
| auto prefix = | |
| (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix()); | |
| return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(), | |
| isForDefinition, ID->isWeakImported(), | |
| !isForDefinition && | |
| CGM.getTriple().isOSBinFormatCOFF() && | |
| ID->hasAttr<DLLImportAttr>()); | |
| } | |
| llvm::Constant * | |
| CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name, | |
| ForDefinition_t IsForDefinition, | |
| bool Weak, bool DLLImport) { | |
| llvm::GlobalValue::LinkageTypes L = | |
| Weak ? llvm::GlobalValue::ExternalWeakLinkage | |
| : llvm::GlobalValue::ExternalLinkage; | |
| llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name); | |
| if (!GV || GV->getValueType() != ObjCTypes.ClassnfABITy) { | |
| auto *NewGV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, L, | |
| nullptr, Name); | |
| if (DLLImport) | |
| NewGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass); | |
| if (GV) { | |
| GV->replaceAllUsesWith(NewGV); | |
| GV->eraseFromParent(); | |
| } | |
| GV = NewGV; | |
| CGM.getModule().insertGlobalVariable(GV); | |
| } | |
| assert(GV->getLinkage() == L); | |
| return GV; | |
| } | |
| llvm::Constant * | |
| CGObjCNonFragileABIMac::GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID) { | |
| llvm::Constant *ClassGV = | |
| GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition); | |
| if (!ID->hasAttr<ObjCClassStubAttr>()) | |
| return ClassGV; | |
| ClassGV = llvm::ConstantExpr::getPointerCast(ClassGV, ObjCTypes.Int8PtrTy); | |
| // Stub classes are pointer-aligned. Classrefs pointing at stub classes | |
| // must set the least significant bit set to 1. | |
| auto *Idx = llvm::ConstantInt::get(CGM.Int32Ty, 1); | |
| return llvm::ConstantExpr::getPtrAdd(ClassGV, Idx); | |
| } | |
| llvm::Value * | |
| CGObjCNonFragileABIMac::EmitLoadOfClassRef(CodeGenFunction &CGF, | |
| const ObjCInterfaceDecl *ID, | |
| llvm::GlobalVariable *Entry) { | |
| if (ID && ID->hasAttr<ObjCClassStubAttr>()) { | |
| // Classrefs pointing at Objective-C stub classes must be loaded by calling | |
| // a special runtime function. | |
| return CGF.EmitRuntimeCall(ObjCTypes.getLoadClassrefFn(), Entry, | |
| "load_classref_result"); | |
| } | |
| CharUnits Align = CGF.getPointerAlign(); | |
| return CGF.Builder.CreateAlignedLoad(Entry->getValueType(), Entry, Align); | |
| } | |
| llvm::Value *CGObjCNonFragileABIMac::EmitClassRefFromId( | |
| CodeGenFunction &CGF, IdentifierInfo *II, const ObjCInterfaceDecl *ID) { | |
| llvm::GlobalVariable *&Entry = ClassReferences[II]; | |
| if (!Entry) { | |
| llvm::Constant *ClassGV; | |
| if (ID) { | |
| ClassGV = GetClassGlobalForClassRef(ID); | |
| } else { | |
| ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(), | |
| NotForDefinition); | |
| assert(ClassGV->getType() == ObjCTypes.ClassnfABIPtrTy && | |
| "classref was emitted with the wrong type?"); | |
| } | |
| std::string SectionName = | |
| GetSectionName("__objc_classrefs", "regular,no_dead_strip"); | |
| Entry = new llvm::GlobalVariable( | |
| CGM.getModule(), ClassGV->getType(), false, | |
| getLinkageTypeForObjCMetadata(CGM, SectionName), ClassGV, | |
| "OBJC_CLASSLIST_REFERENCES_$_"); | |
| Entry->setAlignment(CGF.getPointerAlign().getAsAlign()); | |
| if (!ID || !ID->hasAttr<ObjCClassStubAttr>()) | |
| Entry->setSection(SectionName); | |
| CGM.addCompilerUsedGlobal(Entry); | |
| } | |
| return EmitLoadOfClassRef(CGF, ID, Entry); | |
| } | |
| llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF, | |
| const ObjCInterfaceDecl *ID) { | |
| // If the class has the objc_runtime_visible attribute, we need to | |
| // use the Objective-C runtime to get the class. | |
| if (ID->hasAttr<ObjCRuntimeVisibleAttr>()) | |
| return EmitClassRefViaRuntime(CGF, ID, ObjCTypes); | |
| return EmitClassRefFromId(CGF, ID->getIdentifier(), ID); | |
| } | |
| llvm::Value * | |
| CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) { | |
| IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool"); | |
| return EmitClassRefFromId(CGF, II, nullptr); | |
| } | |
| llvm::Value * | |
| CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF, | |
| const ObjCInterfaceDecl *ID) { | |
| llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()]; | |
| if (!Entry) { | |
| llvm::Constant *ClassGV = GetClassGlobalForClassRef(ID); | |
| std::string SectionName = | |
| GetSectionName("__objc_superrefs", "regular,no_dead_strip"); | |
| Entry = new llvm::GlobalVariable(CGM.getModule(), ClassGV->getType(), false, | |
| llvm::GlobalValue::PrivateLinkage, ClassGV, | |
| "OBJC_CLASSLIST_SUP_REFS_$_"); | |
| Entry->setAlignment(CGF.getPointerAlign().getAsAlign()); | |
| // Loading a reference to a class stub calls objc_loadClassref, which | |
| // updates the reference in place. We cannot use the __objc_superrefs | |
| // section here because it's a constant section. | |
| if (!ID->hasAttr<ObjCClassStubAttr>()) | |
| Entry->setSection(SectionName); | |
| CGM.addCompilerUsedGlobal(Entry); | |
| } | |
| return EmitLoadOfClassRef(CGF, ID, Entry); | |
| } | |
| /// EmitMetaClassRef - Return a Value * of the address of _class_t | |
| /// meta-data | |
| /// | |
| llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef( | |
| CodeGenFunction &CGF, const ObjCInterfaceDecl *ID, bool Weak) { | |
| CharUnits Align = CGF.getPointerAlign(); | |
| llvm::GlobalVariable *&Entry = MetaClassReferences[ID->getIdentifier()]; | |
| if (!Entry) { | |
| auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition); | |
| std::string SectionName = | |
| GetSectionName("__objc_superrefs", "regular,no_dead_strip"); | |
| Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy, | |
| false, llvm::GlobalValue::PrivateLinkage, | |
| MetaClassGV, "OBJC_CLASSLIST_SUP_REFS_$_"); | |
| Entry->setAlignment(Align.getAsAlign()); | |
| Entry->setSection(SectionName); | |
| CGM.addCompilerUsedGlobal(Entry); | |
| } | |
| return CGF.Builder.CreateAlignedLoad(ObjCTypes.ClassnfABIPtrTy, Entry, Align); | |
| } | |
| /// GetClass - Return a reference to the class for the given interface | |
| /// decl. | |
| llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF, | |
| const ObjCInterfaceDecl *ID) { | |
| if (ID->isWeakImported()) { | |
| auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition); | |
| (void)ClassGV; | |
| assert(!isa<llvm::GlobalVariable>(ClassGV) || | |
| cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage()); | |
| } | |
| return EmitClassRef(CGF, ID); | |
| } | |
| /// 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 CGObjCNonFragileABIMac::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. | |
| RawAddress 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)); | |
| // If this is a class message the metaclass is passed as the target. | |
| llvm::Value *Target; | |
| if (IsClassMessage) | |
| Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported()); | |
| else | |
| Target = EmitSuperClassRef(CGF, Class); | |
| // 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)); | |
| return (isVTableDispatchedSelector(Sel)) | |
| ? EmitVTableMessageSend( | |
| CGF, Return, ResultType, Sel, ObjCSuper.getPointer(), | |
| ObjCTypes.SuperPtrCTy, true, CallArgs, Method) | |
| : EmitMessageSend(CGF, Return, ResultType, Sel, | |
| ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy, | |
| true, CallArgs, Method, Class, ObjCTypes); | |
| } | |
| llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF, | |
| Selector Sel) { | |
| Address Addr = EmitSelectorAddr(Sel); | |
| llvm::LoadInst *LI = CGF.Builder.CreateLoad(Addr); | |
| LI->setMetadata(llvm::LLVMContext::MD_invariant_load, | |
| llvm::MDNode::get(VMContext, {})); | |
| return LI; | |
| } | |
| ConstantAddress CGObjCNonFragileABIMac::EmitSelectorAddr(Selector Sel) { | |
| llvm::GlobalVariable *&Entry = SelectorReferences[Sel]; | |
| CharUnits Align = CGM.getPointerAlign(); | |
| if (!Entry) { | |
| std::string SectionName = | |
| GetSectionName("__objc_selrefs", "literal_pointers,no_dead_strip"); | |
| Entry = new llvm::GlobalVariable( | |
| CGM.getModule(), ObjCTypes.SelectorPtrTy, false, | |
| getLinkageTypeForObjCMetadata(CGM, SectionName), GetMethodVarName(Sel), | |
| "OBJC_SELECTOR_REFERENCES_"); | |
| Entry->setExternallyInitialized(true); | |
| Entry->setSection(SectionName); | |
| Entry->setAlignment(Align.getAsAlign()); | |
| CGM.addCompilerUsedGlobal(Entry); | |
| } | |
| return ConstantAddress(Entry, ObjCTypes.SelectorPtrTy, Align); | |
| } | |
| /// EmitObjCIvarAssign - Code gen for assigning to a __strong object. | |
| /// objc_assign_ivar (id src, id *dst, ptrdiff_t) | |
| /// | |
| void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, | |
| llvm::Value *src, Address dst, | |
| llvm::Value *ivarOffset) { | |
| llvm::Type *SrcTy = src->getType(); | |
| if (!isa<llvm::PointerType>(SrcTy)) { | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); | |
| assert(Size <= 8 && "does not support size > 8"); | |
| src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) | |
| : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); | |
| src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); | |
| } | |
| src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); | |
| llvm::Value *dstVal = CGF.Builder.CreateBitCast(dst.emitRawPointer(CGF), | |
| ObjCTypes.PtrObjectPtrTy); | |
| llvm::Value *args[] = {src, dstVal, ivarOffset}; | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args); | |
| } | |
| /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object. | |
| /// objc_assign_strongCast (id src, id *dst) | |
| /// | |
| void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign( | |
| CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dst) { | |
| llvm::Type *SrcTy = src->getType(); | |
| if (!isa<llvm::PointerType>(SrcTy)) { | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); | |
| assert(Size <= 8 && "does not support size > 8"); | |
| src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) | |
| : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); | |
| src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); | |
| } | |
| src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); | |
| llvm::Value *dstVal = CGF.Builder.CreateBitCast(dst.emitRawPointer(CGF), | |
| ObjCTypes.PtrObjectPtrTy); | |
| llvm::Value *args[] = {src, dstVal}; | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(), args, | |
| "weakassign"); | |
| } | |
| void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable( | |
| CodeGen::CodeGenFunction &CGF, Address DestPtr, Address SrcPtr, | |
| llvm::Value *Size) { | |
| llvm::Value *args[] = {DestPtr.emitRawPointer(CGF), | |
| SrcPtr.emitRawPointer(CGF), Size}; | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args); | |
| } | |
| /// EmitObjCWeakRead - Code gen for loading value of a __weak | |
| /// object: objc_read_weak (id *src) | |
| /// | |
| llvm::Value * | |
| CGObjCNonFragileABIMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, | |
| Address AddrWeakObj) { | |
| llvm::Type *DestTy = AddrWeakObj.getElementType(); | |
| llvm::Value *AddrWeakObjVal = CGF.Builder.CreateBitCast( | |
| AddrWeakObj.emitRawPointer(CGF), ObjCTypes.PtrObjectPtrTy); | |
| llvm::Value *read_weak = CGF.EmitNounwindRuntimeCall( | |
| ObjCTypes.getGcReadWeakFn(), AddrWeakObjVal, "weakread"); | |
| read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy); | |
| return read_weak; | |
| } | |
| /// EmitObjCWeakAssign - Code gen for assigning to a __weak object. | |
| /// objc_assign_weak (id src, id *dst) | |
| /// | |
| void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, | |
| llvm::Value *src, Address dst) { | |
| llvm::Type *SrcTy = src->getType(); | |
| if (!isa<llvm::PointerType>(SrcTy)) { | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); | |
| assert(Size <= 8 && "does not support size > 8"); | |
| src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) | |
| : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); | |
| src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); | |
| } | |
| src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); | |
| llvm::Value *dstVal = CGF.Builder.CreateBitCast(dst.emitRawPointer(CGF), | |
| ObjCTypes.PtrObjectPtrTy); | |
| llvm::Value *args[] = {src, dstVal}; | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(), args, | |
| "weakassign"); | |
| } | |
| /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object. | |
| /// objc_assign_global (id src, id *dst) | |
| /// | |
| void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, | |
| llvm::Value *src, Address dst, | |
| bool threadlocal) { | |
| llvm::Type *SrcTy = src->getType(); | |
| if (!isa<llvm::PointerType>(SrcTy)) { | |
| unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy); | |
| assert(Size <= 8 && "does not support size > 8"); | |
| src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy) | |
| : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy)); | |
| src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy); | |
| } | |
| src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy); | |
| llvm::Value *dstVal = CGF.Builder.CreateBitCast(dst.emitRawPointer(CGF), | |
| ObjCTypes.PtrObjectPtrTy); | |
| llvm::Value *args[] = {src, dstVal}; | |
| if (!threadlocal) | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(), args, | |
| "globalassign"); | |
| else | |
| CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(), args, | |
| "threadlocalassign"); | |
| } | |
| void CGObjCNonFragileABIMac::EmitSynchronizedStmt( | |
| CodeGen::CodeGenFunction &CGF, const ObjCAtSynchronizedStmt &S) { | |
| EmitAtSynchronizedStmt(CGF, S, ObjCTypes.getSyncEnterFn(), | |
| ObjCTypes.getSyncExitFn()); | |
| } | |
| llvm::Constant *CGObjCNonFragileABIMac::GetEHType(QualType T) { | |
| // There's a particular fixed type info for 'id'. | |
| if (T->isObjCIdType() || T->isObjCQualifiedIdType()) { | |
| auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id"); | |
| if (!IDEHType) { | |
| IDEHType = new llvm::GlobalVariable( | |
| CGM.getModule(), ObjCTypes.EHTypeTy, false, | |
| llvm::GlobalValue::ExternalLinkage, nullptr, "OBJC_EHTYPE_id"); | |
| if (CGM.getTriple().isOSBinFormatCOFF()) | |
| IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id")); | |
| } | |
| return IDEHType; | |
| } | |
| // All other types should be Objective-C interface pointer types. | |
| const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>(); | |
| assert(PT && "Invalid @catch type."); | |
| const ObjCInterfaceType *IT = PT->getInterfaceType(); | |
| assert(IT && "Invalid @catch type."); | |
| return GetInterfaceEHType(IT->getDecl(), NotForDefinition); | |
| } | |
| void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF, | |
| const ObjCAtTryStmt &S) { | |
| EmitTryCatchStmt(CGF, S, ObjCTypes.getObjCBeginCatchFn(), | |
| ObjCTypes.getObjCEndCatchFn(), | |
| ObjCTypes.getExceptionRethrowFn()); | |
| } | |
| /// EmitThrowStmt - Generate code for a throw statement. | |
| void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF, | |
| const ObjCAtThrowStmt &S, | |
| bool ClearInsertionPoint) { | |
| if (const Expr *ThrowExpr = S.getThrowExpr()) { | |
| llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr); | |
| Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy); | |
| llvm::CallBase *Call = | |
| CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception); | |
| Call->setDoesNotReturn(); | |
| } else { | |
| llvm::CallBase *Call = | |
| CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn()); | |
| Call->setDoesNotReturn(); | |
| } | |
| CGF.Builder.CreateUnreachable(); | |
| if (ClearInsertionPoint) | |
| CGF.Builder.ClearInsertionPoint(); | |
| } | |
| llvm::Constant * | |
| CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID, | |
| ForDefinition_t IsForDefinition) { | |
| llvm::GlobalVariable *&Entry = EHTypeReferences[ID->getIdentifier()]; | |
| StringRef ClassName = ID->getObjCRuntimeNameAsString(); | |
| // If we don't need a definition, return the entry if found or check | |
| // if we use an external reference. | |
| if (!IsForDefinition) { | |
| if (Entry) | |
| return Entry; | |
| // If this type (or a super class) has the __objc_exception__ | |
| // attribute, emit an external reference. | |
| if (hasObjCExceptionAttribute(CGM.getContext(), ID)) { | |
| std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str(); | |
| Entry = new llvm::GlobalVariable( | |
| CGM.getModule(), ObjCTypes.EHTypeTy, false, | |
| llvm::GlobalValue::ExternalLinkage, nullptr, EHTypeName); | |
| CGM.setGVProperties(Entry, ID); | |
| return Entry; | |
| } | |
| } | |
| // Otherwise we need to either make a new entry or fill in the initializer. | |
| assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition"); | |
| std::string VTableName = "objc_ehtype_vtable"; | |
| auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName); | |
| if (!VTableGV) { | |
| VTableGV = new llvm::GlobalVariable( | |
| CGM.getModule(), ObjCTypes.Int8PtrTy, false, | |
| llvm::GlobalValue::ExternalLinkage, nullptr, VTableName); | |
| if (CGM.getTriple().isOSBinFormatCOFF()) | |
| VTableGV->setDLLStorageClass(getStorage(CGM, VTableName)); | |
| } | |
| llvm::Constant *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2); | |
| llvm::Constant *VTablePtr = llvm::ConstantExpr::getGetElementPtr( | |
| CGM.getDataLayout(), VTableGV->getValueType(), VTableGV, VTableIdx, | |
| llvm::GEPNoWrapFlags::inBounds()); | |
| ConstantInitBuilder builder(CGM); | |
| auto values = builder.beginStruct(ObjCTypes.EHTypeTy); | |
| const PointerAuthSchema &TypeInfoSchema = | |
| CGM.getCodeGenOpts().PointerAuth.CXXTypeInfoVTablePointer; | |
| values.addSignedPointer(VTablePtr, TypeInfoSchema, GlobalDecl(), QualType()); | |
| values.add(GetClassName(ClassName)); | |
| values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition)); | |
| llvm::GlobalValue::LinkageTypes L = IsForDefinition | |
| ? llvm::GlobalValue::ExternalLinkage | |
| : llvm::GlobalValue::WeakAnyLinkage; | |
| if (Entry) { | |
| values.finishAndSetAsInitializer(Entry); | |
| Entry->setAlignment(CGM.getPointerAlign().getAsAlign()); | |
| } else { | |
| Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName, | |
| CGM.getPointerAlign(), | |
| /*constant*/ false, L); | |
| if (hasObjCExceptionAttribute(CGM.getContext(), ID)) | |
| CGM.setGVProperties(Entry, ID); | |
| } | |
| assert(Entry->getLinkage() == L); | |
| if (!CGM.getTriple().isOSBinFormatCOFF()) | |
| if (ID->getVisibility() == HiddenVisibility) | |
| Entry->setVisibility(llvm::GlobalValue::HiddenVisibility); | |
| if (IsForDefinition) | |
| if (CGM.getTriple().isOSBinFormatMachO()) | |
| Entry->setSection("__DATA,__objc_const"); | |
| return Entry; | |
| } | |
| /* *** */ | |
| CodeGen::CGObjCRuntime * | |
| CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) { | |
| switch (CGM.getLangOpts().ObjCRuntime.getKind()) { | |
| case ObjCRuntime::FragileMacOSX: | |
| return new CGObjCMac(CGM); | |
| case ObjCRuntime::MacOSX: | |
| case ObjCRuntime::iOS: | |
| case ObjCRuntime::WatchOS: | |
| return new CGObjCNonFragileABIMac(CGM); | |
| case ObjCRuntime::GNUstep: | |
| case ObjCRuntime::GCC: | |
| case ObjCRuntime::ObjFW: | |
| llvm_unreachable("these runtimes are not Mac runtimes"); | |
| } | |
| llvm_unreachable("bad runtime"); | |
| } | |
| // Public wrapper function for external compilers (e.g., Swift) to access | |
| // the Mac runtime's GetDirectMethodCallee functionality. | |
| llvm::Function *clang::CodeGen::getObjCDirectMethodCallee( | |
| CodeGenModule &CGM, const ObjCMethodDecl *OMD, const ObjCContainerDecl *CD, | |
| bool ReceiverCanBeNull, bool ClassObjectCanBeUnrealized) { | |
| // This function should only be called when targeting Darwin platforms, | |
| // which always use the Mac runtime. | |
| assert(CGM.getLangOpts().ObjCRuntime.isNeXTFamily() && | |
| "getObjCDirectMethodCallee requires Mac ObjC runtime"); | |
| CGObjCCommonMac *MacRuntime = | |
| static_cast<CGObjCCommonMac *>(&CGM.getObjCRuntime()); | |
| return MacRuntime->GetDirectMethodCallee(OMD, CD, ReceiverCanBeNull, | |
| ClassObjectCanBeUnrealized); | |
| } |