//===------- 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 "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/RecordLayout.h"

#include "clang/AST/StmtObjC.h"

#include "clang/Basic/CodeGenOptions.h"

#include "clang/Basic/LangOptions.h"

#include "clang/CodeGen/CGFunctionInfo.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>

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::Type *IvarOffsetVarTy;

  /// ObjectPtrTy - LLVM type for object handles (typeof(id))

  llvm::PointerType *ObjectPtrTy;

  /// PtrObjectPtrTy - LLVM type for id *

  llvm::PointerType *PtrObjectPtrTy;

  /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))

  llvm::PointerType *SelectorPtrTy;

private:

  /// ProtocolPtrTy - LLVM type for external protocol handles

  /// (typeof(Protocol))

  llvm::Type *ExternalProtocolPtrTy;

public:

  llvm::Type *getExternalProtocolPtrTy() {

    if (!ExternalProtocolPtrTy) {

      // FIXME: It would be nice to unify this with the opaque type, so that the

      // IR comes out a bit cleaner.

      CodeGen::CodeGenTypes &Types = CGM.getTypes();

      ASTContext &Ctx = CGM.getContext();

      llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());

      ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);

    }

    return ExternalProtocolPtrTy;

  }

  // SuperCTy - clang type for struct objc_super.

  QualType SuperCTy;

  // SuperPtrCTy - clang type for struct objc_super *.

  QualType SuperPtrCTy;

  /// SuperTy - LLVM type for struct objc_super.

  llvm::StructType *SuperTy;

  /// SuperPtrTy - LLVM type for struct objc_super *.

  llvm::PointerType *SuperPtrTy;

  /// PropertyTy - LLVM type for struct objc_property (struct _prop_t

  /// in GCC parlance).

  llvm::StructType *PropertyTy;

  /// PropertyListTy - LLVM type for struct objc_property_list

  /// (_prop_list_t in GCC parlance).

  llvm::StructType *PropertyListTy;

  /// PropertyListPtrTy - LLVM type for struct objc_property_list*.

  llvm::PointerType *PropertyListPtrTy;

  // MethodTy - LLVM type for struct objc_method.

  llvm::StructType *MethodTy;

  /// CacheTy - LLVM type for struct objc_cache.

  llvm::Type *CacheTy;

  /// CachePtrTy - LLVM type for struct objc_cache *.

  llvm::PointerType *CachePtrTy;

  llvm::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 && 
copy45
)

      name = "objc_setProperty_atomic_copy";

    else if (atomic && 
!copy42
)

      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.getSizeType());

    Params.push_back(Ctx.BoolTy);

    Params.push_back(Ctx.BoolTy);

    llvm::FunctionType *FTy =

        Types.GetFunctionType(

          Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));

    return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");

  }

  /// This routine declares and returns address of:

  /// void objc_copyCppObjectAtomic(

  ///         void *dest, const void *src,

  ///         void (*copyHelper) (void *dest, const void *source));

  llvm::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[] = { ObjectPtrTy->getPointerTo() };

    llvm::FunctionType *FTy =

      llvm::FunctionType::get(ObjectPtrTy, args, false);

    return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");

  }

  /// GcAssignWeakFn -- LLVM objc_assign_weak function.

  llvm::FunctionCallee getGcAssignWeakFn() {

    // id objc_assign_weak (id, id *)

    llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };

    llvm::FunctionType *FTy =

      llvm::FunctionType::get(ObjectPtrTy, args, false);

    return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");

  }

  /// GcAssignGlobalFn -- LLVM objc_assign_global function.

  llvm::FunctionCallee getGcAssignGlobalFn() {

    // id objc_assign_global(id, id *)

    llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };

    llvm::FunctionType *FTy =

      llvm::FunctionType::get(ObjectPtrTy, args, false);

    return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");

  }

  /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.

  llvm::FunctionCallee getGcAssignThreadLocalFn() {

    // id objc_assign_threadlocal(id src, id * dest)

    llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };

    llvm::FunctionType *FTy =

      llvm::FunctionType::get(ObjectPtrTy, args, false);

    return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");

  }

  /// GcAssignIvarFn -- LLVM objc_assign_ivar function.

  llvm::FunctionCallee getGcAssignIvarFn() {

    // id objc_assign_ivar(id, id *, ptrdiff_t)

    llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),

                           CGM.PtrDiffTy };

    llvm::FunctionType *FTy =

      llvm::FunctionType::get(ObjectPtrTy, args, false);

    return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");

  }

  /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.

  llvm::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, ObjectPtrTy->getPointerTo() };

    llvm::FunctionType *FTy =

      llvm::FunctionType::get(ObjectPtrTy, args, false);

    return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");

  }

  /// ExceptionThrowFn - LLVM objc_exception_throw function.

  llvm::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()21
 : 
getMessageSendFn()187
;

  }

  llvm::FunctionCallee getSendFn2(bool IsSuper) const {

    return IsSuper ? 
getMessageSendSuperFn2()466
 : 
getMessageSendFn()11.4k
;

  }

  llvm::FunctionCallee getSendStretFn(bool IsSuper) const {

    return IsSuper ? 
getMessageSendSuperStretFn()2
 : 
getMessageSendStretFn()2
;

  }

  llvm::FunctionCallee getSendStretFn2(bool IsSuper) const {

    return IsSuper ? 
getMessageSendSuperStretFn2()2
 : 
getMessageSendStretFn()13
;

  }

  llvm::FunctionCallee getSendFpretFn(bool IsSuper) const {

    return IsSuper ? 
getMessageSendSuperFpretFn()0
 : getMessageSendFpretFn();

  }

  llvm::FunctionCallee getSendFpretFn2(bool IsSuper) const {

    return IsSuper ? 
getMessageSendSuperFpretFn2()0
 : getMessageSendFpretFn();

  }

  llvm::FunctionCallee getSendFp2retFn(bool IsSuper) const {

    return IsSuper ? 
getMessageSendSuperFn()0
 : 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[] = { ExceptionDataTy->getPointerTo() };

    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[] = { ExceptionDataTy->getPointerTo() };

    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[] = { ExceptionDataTy->getPointerTo() };

    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.Int32Ty->getPointerTo() };

    return CGM.CreateRuntimeFunction(

        llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp",

        llvm::AttributeList::get(CGM.getLLVMContext(),

                                 llvm::AttributeList::FunctionIndex,

                                 llvm::Attribute::NonLazyBind));

  }

public:

  ObjCTypesHelper(CodeGen::CodeGenModule &cgm);

};

/// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's

/// modern abi

class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {

public:

  // MethodListnfABITy - LLVM for struct _method_list_t

  llvm::StructType *MethodListnfABITy;

  // MethodListnfABIPtrTy - LLVM for struct _method_list_t*

  llvm::PointerType *MethodListnfABIPtrTy;

  // ProtocolnfABITy = LLVM for struct _protocol_t

  llvm::StructType *ProtocolnfABITy;

  // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*

  llvm::PointerType *ProtocolnfABIPtrTy;

  // ProtocolListnfABITy - LLVM for struct _objc_protocol_list

  llvm::StructType *ProtocolListnfABITy;

  // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*

  llvm::PointerType *ProtocolListnfABIPtrTy;

  // ClassnfABITy - LLVM for struct _class_t

  llvm::StructType *ClassnfABITy;

  // ClassnfABIPtrTy - LLVM for struct _class_t*

  llvm::PointerType *ClassnfABIPtrTy;

  // IvarnfABITy - LLVM for struct _ivar_t

  llvm::StructType *IvarnfABITy;

  // IvarListnfABITy - LLVM for struct _ivar_list_t

  llvm::StructType *IvarListnfABITy;

  // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*

  llvm::PointerType *IvarListnfABIPtrTy;

  // ClassRonfABITy - LLVM for struct _class_ro_t

  llvm::StructType *ClassRonfABITy;

  // ImpnfABITy - LLVM for id (*)(id, SEL, ...)

  llvm::PointerType *ImpnfABITy;

  // CategorynfABITy - LLVM for struct _category_t

  llvm::StructType *CategorynfABITy;

  // New types for nonfragile abi messaging.

  // MessageRefTy - LLVM for:

  // struct _message_ref_t {

  //   IMP messenger;

  //   SEL name;

  // };

  llvm::StructType *MessageRefTy;

  // MessageRefCTy - clang type for struct _message_ref_t

  QualType MessageRefCTy;

  // MessageRefPtrTy - LLVM for struct _message_ref_t*

  llvm::Type *MessageRefPtrTy;

  // MessageRefCPtrTy - clang type for struct _message_ref_t*

  QualType MessageRefCPtrTy;

  // SuperMessageRefTy - LLVM for:

  // struct _super_message_ref_t {

  //   SUPER_IMP messenger;

  //   SEL name;

  // };

  llvm::StructType *SuperMessageRefTy;

  // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*

  llvm::PointerType *SuperMessageRefPtrTy;

  llvm::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::FunctionCallee F = CGM.CreateRuntimeFunction(

        llvm::FunctionType::get(ClassnfABIPtrTy, params, false),

        "objc_loadClassref",

        llvm::AttributeList::get(CGM.getLLVMContext(),

                                 llvm::AttributeList::FunctionIndex,

                                 {llvm::Attribute::NonLazyBind,

                                  llvm::Attribute::ReadNone,

                                  llvm::Attribute::NoUnwind}));

    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,

};

class CGObjCCommonMac : public CodeGen::CGObjCRuntime {

public:

  class SKIP_SCAN {

  public:

    unsigned skip;

    unsigned scan;

    SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)

      : skip(_skip), scan(_scan) {}

  };

  /// opcode for captured block variables layout 'instructions'.

  /// In the following descriptions, 'I' is the value of the immediate field.

  /// (field following the opcode).

  ///

  enum BLOCK_LAYOUT_OPCODE {

    /// An operator which affects how the following layout should be

    /// interpreted.

    ///   I == 0: Halt interpretation and treat everything else as

    ///           a non-pointer.  Note that this instruction is equal

    ///           to '\0'.

    ///   I != 0: Currently unused.

    BLOCK_LAYOUT_OPERATOR            = 0,

    /// The next I+1 bytes do not contain a value of object pointer type.

    /// Note that this can leave the stream unaligned, meaning that

    /// subsequent word-size instructions do not begin at a multiple of

    /// the pointer size.

    BLOCK_LAYOUT_NON_OBJECT_BYTES    = 1,

    /// The next I+1 words do not contain a value of object pointer type.

    /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for

    /// when the required skip quantity is a multiple of the pointer size.

    BLOCK_LAYOUT_NON_OBJECT_WORDS    = 2,

    /// The next I+1 words are __strong pointers to Objective-C

    /// objects or blocks.

    BLOCK_LAYOUT_STRONG              = 3,

    /// The next I+1 words are pointers to __block variables.

    BLOCK_LAYOUT_BYREF               = 4,

    /// The next I+1 words are __weak pointers to Objective-C

    /// objects or blocks.

    BLOCK_LAYOUT_WEAK                = 5,

    /// The next I+1 words are __unsafe_unretained pointers to

    /// Objective-C objects or blocks.

    BLOCK_LAYOUT_UNRETAINED          = 6

    /// The next I+1 words are block or object pointers with some

    /// as-yet-unspecified ownership semantics.  If we add more

    /// flavors of ownership semantics, values will be taken from

    /// this range.

    ///

    /// This is included so that older tools can at least continue

    /// processing the layout past such things.

    //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,

    /// All other opcodes are reserved.  Halt interpretation and

    /// treat everything else as opaque.

  };

  class RUN_SKIP {

  public:

    enum BLOCK_LAYOUT_OPCODE opcode;

    CharUnits block_var_bytepos;

    CharUnits block_var_size;

    RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,

             CharUnits BytePos = CharUnits::Zero(),

             CharUnits Size = CharUnits::Zero())

    : opcode(Opcode), block_var_bytepos(BytePos),  block_var_size(Size) {}

    // Allow sorting based on byte pos.

    bool operator<(const RUN_SKIP &b) const {

      return block_var_bytepos < b.block_var_bytepos;

    }

  };

protected:

  llvm::LLVMContext &VMContext;

  // FIXME! May not be needing this after all.

  unsigned ObjCABI;

  // arc/mrr layout of captured block literal variables.

  SmallVector<RUN_SKIP, 16> RunSkipBlockVars;

  /// LazySymbols - Symbols to generate a lazy reference for. See

  /// DefinedSymbols and FinishModule().

  llvm::SetVector<IdentifierInfo*> LazySymbols;

  /// DefinedSymbols - External symbols which are defined by this

  /// module. The symbols in this list and LazySymbols are used to add

  /// special linker symbols which ensure that Objective-C modules are

  /// linked properly.

  llvm::SetVector<IdentifierInfo*> DefinedSymbols;

  /// ClassNames - uniqued class names.

  llvm::StringMap<llvm::GlobalVariable*> ClassNames;

  /// MethodVarNames - uniqued method variable names.

  llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;

  /// DefinedCategoryNames - list of category names in form Class_Category.

  llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames;

  /// MethodVarTypes - uniqued method type signatures. We have to use

  /// a StringMap here because have no other unique reference.

  llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;

  /// MethodDefinitions - map of methods which have been defined in

  /// this translation unit.

  llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;

  /// DirectMethodDefinitions - map of direct methods which have been defined in

  /// this translation unit.

  llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> DirectMethodDefinitions;

  /// 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;

  /// The LLVM type corresponding to NSConstantString.

  llvm::StructType *NSConstantStringType = nullptr;

  llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap;

  /// GetNameForMethod - Return a name for the given method.

  /// \param[out] NameOut - The return value.

  void GetNameForMethod(const ObjCMethodDecl *OMD,

                        const ObjCContainerDecl *CD,

                        SmallVectorImpl<char> &NameOut,

                        bool ignoreCategoryNamespace = false);

  /// GetMethodVarName - Return a unique constant for the given

  /// selector's name. The return value has type char *.

  llvm::Constant *GetMethodVarName(Selector Sel);

  llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);

  /// GetMethodVarType - Return a unique constant for the given

  /// method's type encoding string. The return value has type char *.

  // FIXME: This is a horrible name.

  llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,

                                   bool Extended = false);

  llvm::Constant *GetMethodVarType(const FieldDecl *D);

  /// GetPropertyName - Return a unique constant for the given

  /// name. The return value has type char *.

  llvm::Constant *GetPropertyName(IdentifierInfo *Ident);

  // FIXME: This can be dropped once string functions are unified.

  llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,

                                        const Decl *Container);

  /// GetClassName - Return a unique constant for the given selector's

  /// runtime name (which may change via use of objc_runtime_name attribute on

  /// class or protocol definition. The return value has type char *.

  llvm::Constant *GetClassName(StringRef RuntimeName);

  llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);

  /// BuildIvarLayout - Builds ivar layout bitmap for the class

  /// implementation for the __strong or __weak case.

  ///

  /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there

  ///   are any weak ivars defined directly in the class.  Meaningless unless

  ///   building a weak layout.  Does not guarantee that the layout will

  ///   actually have any entries, because the ivar might be under-aligned.

  llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,

                                  CharUnits beginOffset,

                                  CharUnits endOffset,

                                  bool forStrongLayout,

                                  bool hasMRCWeakIvars);

  llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,

                                        CharUnits beginOffset,

                                        CharUnits endOffset) {

    return BuildIvarLayout(OI, beginOffset, endOffset, true, false);

  }

  llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,

                                      CharUnits beginOffset,

                                      CharUnits endOffset,

                                      bool hasMRCWeakIvars) {

    return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);

  }

  Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);

  void UpdateRunSkipBlockVars(bool IsByref,

                              Qualifiers::ObjCLifetime LifeTime,

                              CharUnits FieldOffset,

                              CharUnits FieldSize);

  void BuildRCBlockVarRecordLayout(const RecordType *RT,

                                   CharUnits BytePos, bool &HasUnion,

                                   bool ByrefLayout=false);

  void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,

                           const RecordDecl *RD,

                           ArrayRef<const FieldDecl*> RecFields,

                           CharUnits BytePos, bool &HasUnion,

                           bool ByrefLayout);

  uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);

  llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);

  /// GetIvarLayoutName - Returns a unique constant for the given

  /// ivar layout bitmap.

  llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,

                                    const ObjCCommonTypesHelper &ObjCTypes);

  /// EmitPropertyList - Emit the given property list. The return

  /// value has type PropertyListPtrTy.

  llvm::Constant *EmitPropertyList(Twine Name,

                                   const Decl *Container,

                                   const ObjCContainerDecl *OCD,

                                   const ObjCCommonTypesHelper &ObjCTypes,

                                   bool IsClassProperty);

  /// EmitProtocolMethodTypes - Generate the array of extended method type

  /// strings. The return value has type Int8PtrPtrTy.

  llvm::Constant *EmitProtocolMethodTypes(Twine Name,

                                          ArrayRef<llvm::Constant*> MethodTypes,

                                       const ObjCCommonTypesHelper &ObjCTypes);

  /// GetProtocolRef - Return a reference to the internal protocol

  /// description, creating an empty one if it has not been

  /// defined. The return value has type ProtocolPtrTy.

  llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);

  /// Return a reference to the given Class using runtime calls rather than

  /// by a symbol reference.

  llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,

                                      const ObjCInterfaceDecl *ID,

                                      ObjCCommonTypesHelper &ObjCTypes);

  std::string GetSectionName(StringRef Section, StringRef MachOAttributes);

public:

  /// CreateMetadataVar - Create a global variable with internal

  /// linkage for use by the Objective-C runtime.

  ///

  /// This is a convenience wrapper which not only creates the

  /// variable, but also sets the section and alignment and adds the

  /// global to the "llvm.used" list.

  ///

  /// \param Name - The variable name.

  /// \param Init - The variable initializer; this is also used to

  ///   define the type of the variable.

  /// \param Section - The section the variable should go into, or empty.

  /// \param Align - The alignment for the variable, or 0.

  /// \param AddToUsed - Whether the variable should be added to

  ///   "llvm.used".

  llvm::GlobalVariable *CreateMetadataVar(Twine Name,

                                          ConstantStructBuilder &Init,

                                          StringRef Section, CharUnits Align,

                                          bool AddToUsed);

  llvm::GlobalVariable *CreateMetadataVar(Twine Name,

                                          llvm::Constant *Init,

                                          StringRef Section, CharUnits Align,

                                          bool AddToUsed);

  llvm::GlobalVariable *CreateCStringLiteral(StringRef Name,

                                             ObjCLabelType LabelType,

                                             bool ForceNonFragileABI = false,

                                             bool NullTerminate = true);

protected:

  CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,

                                  ReturnValueSlot Return,